+ Route Table Collector
+ A side thread which either attempts to connect and request a table
+ from the Route Manager, or opens a port and listens for Route Manager
+ to push table updates.
+
+ It may do other things along the way (latency measurements, alarms,
+ respond to RMR pings, etc.).
+
+ The behaviour with respect to listening for Route Manager updates vs
+ the initiation of the connection and sending a request depends on the
+ value of the ENV_RTG_ADDR (RMR_RTG_SVC) environment variable. If
+ host:port, or IP:port, is given, then we assume that we make the connection
+ and send a request for the table (request mode). If the variable is just
+ a port, then we assume Route Manager will connect and push updates (original
+ method).
+
+ If the variable is not defined, the default behaviour, in order to be
+ backwards compatable, depends on the presence of the ENV_CTL_PORT
+ (RMR_CTL_PORT) variable (new with the support for requesting a table).
+
+
+ ENV_CTL_PORT ENV_RTG_ADDR Behaviour
+ unset unset Open default CTL port (DEF_CTL_PORT) and
+ wait for Rt Mgr to push tables
+
+ set unset Use the default Rt Mgr wellknown addr
+ and port (DEF_RTG_WK_ADDR) to connect
+ and request a table. The control port
+ used is the value set by ENV_CTL_PORT.
+
+ unset set As described above. The default control
+ port (DEF_CTL_PORT) is used.
+
+ When we are running in request mode, then we will send the RMR message
+ RMRRM_REFRESH to this address (wormhole) as a request for the route manager
+ to send a new table. We will attempt to connect and send requests until
+ we have a table. Calls to rmr_ready() will report FALSE until a table is
+ loaded _unless_ a seed table was given.
+
+ Route table information is expected to arrive on RMR messages with type
+ RMRRM_TABLE_DATA. There is NOT a specific message type for each possible
+ table record, so the payload is as it appears in the seed file or as
+ delivered in old versions. It may take several RMRRM_TABLE_DATA messages
+ to completely supply a new table or table update. See the header for parse_rt_rec
+ in common for a description of possible message contents.
+
+ Buffers received from the route table generator can contain multiple newline terminated
+ records, but each buffer must be less than 4K in length, and the last record in a
+ buffer may NOT be split across buffers.
+
+ Other chores:
+ In addition to the primary task of getting, vetting, and installing a new route table, or
+ updates to the existing table, this thread will periodically cause the send counts for each
+ endpoint known to be written to standard error. The frequency is once every 180 seconds, and
+ more frequently if verbose mode (see ENV_VERBOSE_FILE) is > 0.
+*/
+static void* rtc( void* vctx ) {
+ uta_ctx_t* ctx; // context user has -- where we pin the route table
+ uta_ctx_t* pvt_cx; // private context for session with rtg
+ rmr_mbuf_t* msg = NULL; // message from rtg
+ char* my_port; // the port number that we will listen on (4561 has been the default for this)
+ char* rtg_addr; // host:port address of route table generator (route manager)
+ char* daddr; // duplicated rtg address string to parse/trash
+ size_t buf_size; // nng needs var pointer not just size?
+ int i;
+ long blabber = 0; // time of last blabber so we don't flood if rtg goes bad
+ int cstate = -1; // connection state to rtg
+ int state; // processing state of some nng function
+ char* tokens[128];
+ char wbuf[128];
+ int ntoks;
+ int vfd = -1; // verbose file des if we have one
+ int vlevel = 0; // how chatty we should be 0== no nattering allowed
+ char* eptr;
+ int epfd = -1; // fd for epoll so we can multi-task
+ struct epoll_event events[1]; // list of events to give to epoll; we only have one we care about
+ struct epoll_event epe; // event definition for event to listen to
+ int count_delay = 30; // number of seconds between writing count info; initially every 30s
+ int bump_freq = 0; // time at which we will bump count frequency to every 5 minutes
+ int flags = 0;
+ int rt_req_freq = DEF_RTREQ_FREQ; // request frequency (sec) when wanting a new table
+ int nxt_rt_req = 0; // time of next request
+
+
+ if( (ctx = (uta_ctx_t *) vctx) == NULL ) {
+ rmr_vlog( RMR_VL_CRIT, "rmr_rtc: internal mishap: context passed in was nil\n" );
+ return NULL;
+ }
+
+ if( (ctx->ephash = rmr_sym_alloc( RT_SIZE )) == NULL ) { // master hash table for endpoints (each rt will reference this)
+ rmr_vlog( RMR_VL_CRIT, "rmr_rtc: internal mishap: unable to allocate an endpoint hash table\n" );
+ return NULL;
+ }
+
+ if( (eptr = getenv( ENV_VERBOSE_FILE )) != NULL ) {
+ vfd = open( eptr, O_RDONLY );
+ vlevel = refresh_vlevel( vfd );
+ }
+
+ if( (eptr = getenv( ENV_RTREQ_FREA )) != NULL ) {
+ rt_req_freq = atoi( eptr );
+ if( rt_req_freq < 1 || rt_req_freq > 300 ) {
+ rt_req_freq = DEF_RTREQ_FREQ;
+ rmr_vlog( RMR_VL_WARN, "rmr_rtc: RT request frequency (%d) out of range (1-300), using default", DEF_RTREQ_FREQ );
+ }
+ }
+ rmr_vlog( RMR_VL_INFO, "rmr_rtc: RT request frequency set to: %d seconds", rt_req_freq );
+
+ ctx->flags |= CFL_NO_RTACK; // don't ack when reading from a file
+ read_static_rt( ctx, vlevel ); // seed the route table if one provided
+ ctx->flags &= ~CFL_NO_RTACK;
+
+
+ my_port = getenv( ENV_CTL_PORT ); // default port to listen on (likely 4561)
+ if( my_port == NULL || ! *my_port ) { // if undefined, then go with default
+ my_port = DEF_CTL_PORT;
+ daddr = DEF_CTL_PORT; // backwards compat; if ctl port not hard defined, default is to listen
+ } else {
+ daddr = DEF_RTG_WK_ADDR; // if ctl port is defined, then default changes to connecting to well known RM addr
+ }
+
+ if( (rtg_addr = getenv( ENV_RTG_ADDR )) == NULL || ! *rtg_addr ) { // undefined, use default set above
+ rtg_addr = daddr;
+ }
+
+ daddr = strdup( rtg_addr ); // dup to destroy during parse
+
+ ntoks = uta_tokenise( daddr, tokens, 120, ':' ); // should be host:ip of rt mgr (could be port only which we assume is old listen port)
+ switch( ntoks ) {
+ case 0: // should not happen, but prevent accidents and allow default to ignore additional tokens
+ break;
+
+ case 1:
+ my_port = tokens[0]; // just port -- assume backlevel environment where we just listen
+ flags |= RTCFL_HAVE_UPDATE; // prevent sending update reqests
+ break;
+
+ default:
+ if( strcmp( tokens[0], "tcp" ) == 0 ) { // old school nng tcp:xxxx so we listen on xxx
+ flags |= RTCFL_HAVE_UPDATE; // and signal not to try to request an update
+ my_port = tokens[1];
+ } else {
+ // rtg_addr points at rt mgr address and my port set from env or default stands as is
+ }
+ break;
+ }
+
+ if( (pvt_cx = init( my_port, MAX_RTC_BUF, FL_NOTHREAD )) == NULL ) { // open a private context (no RT listener!)
+ rmr_vlog( RMR_VL_CRIT, "rmr_rtc: unable to initialise listen port for RTG (pvt_cx)\n" );
+
+ while( TRUE ) { // no listen port, just dump counts now and then
+ sleep( count_delay );
+ rt_epcounts( ctx->rtable, ctx->my_name );
+ }
+
+ return NULL;
+ }
+
+ ctx->rtg_whid = -1;
+
+ if( DEBUG ) rmr_vlog( RMR_VL_DEBUG, "rtc thread is running and listening; listening for rtg conns on %s\n", my_port );
+
+ bump_freq = time( NULL ) + 300; // after 5 minutes we decrease the count frequency
+ blabber = 0;
+ while( 1 ) { // until the cows return, pigs fly, or somesuch event likely not to happen
+ while( msg == NULL || msg->len <= 0 ) { // until we actually have something from the other side
+ if( (flags & RTCFL_HAVE_UPDATE) == 0 && time( NULL ) >= nxt_rt_req ) { // no route table updated from rt mgr; request one
+ if( ctx->rtg_whid < 0 ) {
+ ctx->rtg_whid = rmr_wh_open( pvt_cx, rtg_addr );
+ }
+ send_update_req( pvt_cx, ctx );
+ nxt_rt_req = time( NULL ) + rt_req_freq;
+ }
+
+ msg = rmr_torcv_msg( pvt_cx, msg, 1000 );
+
+ if( time( NULL ) > blabber ) {
+ vlevel = refresh_vlevel( vfd );
+ if( vlevel >= 0 ) { // allow it to be forced off with -n in verbose file
+ blabber = time( NULL ) + count_delay; // set next time to blabber, then do so
+ if( blabber > bump_freq ) {
+ count_delay = 300;
+ }
+ rt_epcounts( ctx->rtable, ctx->my_name );
+ }
+ }
+
+ if( ctx->shutdown != 0 ) {
+ break; // mostly for unit test, but allows a forced stop
+ }
+ }
+
+ vlevel = refresh_vlevel( vfd ); // ensure it's fresh when we get a message
+
+ if( msg != NULL && msg->len > 0 ) {
+ rtc_parse_msg( ctx, pvt_cx, msg, vlevel, &flags );
+ }
+
+ if( ctx->shutdown ) { // mostly for testing, but allows user app to close us down if rmr_*() function sets this
+ return NULL;
+ }
+
+ }
+
+ return NULL; // unreachable, but some compilers don't see that and complain.
+}
+
+#ifndef SI95_BUILD
+// this is nng specific inas much as we allow raw (non-RMR) messages
+
+/*
+ NOTE: This is the original rtc code when we supported "raw" nano/nng messages
+ from the route manger. It is deprecated in favour of managing all RM-RMR
+ communications via an RMR session.
+
+ The rtc() function above is the new and preferred function regardless
+ of transport.
+
+ -----------------------------------------------------------------------------------