Address potential error state after good send

[ric-plt/lib/rmr.git] / src / rmr / common / src / rt_generic_static.c

diff --git a/src/rmr/common/src/rt_generic_static.c b/src/rmr/common/src/rt_generic_static.c
index 253e7ab..816e18a 100644 (file)
--- a/src/rmr/common/src/rt_generic_static.c
+++ b/src/rmr/common/src/rt_generic_static.c
@@ -153,6 +153,39 @@ static char* clip( char* buf ) {
        return buf;
 }
 
+/*
+       This accepts a pointer to a nil terminated string, and ensures that there is a
+       newline as the last character. If there is not, a new buffer is allocated and
+       the newline is added.  If a new buffer is allocated, the buffer passed in is
+       freed.  The function returns a pointer which the caller should use, and must
+       free.  In the event of an error, a nil pointer is returned.
+*/
+static char* ensure_nlterm( char* buf ) {
+       char*   nb = NULL;
+       int             len = 1;
+       
+
+       nb = buf;
+       if( buf == NULL || (len = strlen( buf )) < 2 ) {
+               if( (nb = (char *) malloc( sizeof( char ) * 2 )) != NULL ) {
+                       *nb = '\n';
+                       *(nb+1) = 0;
+               }
+       } else {
+               if( buf[len-1] != '\n' ) {
+                       fprintf( stderr, "[WRN] rmr buf_check: input buffer was not newline terminated (file missing final \\n?)\n" );
+                       if( (nb = (char *) malloc( sizeof( char ) * (len + 2) )) != NULL ) {
+                               memcpy( nb, buf, len );
+                               *(nb+len) = '\n';                       // insert \n and nil into the two extra bytes we allocated
+                               *(nb+len+1) = 0;
+                       }       
+
+                       free( buf );
+               }
+       }
+
+       return nb;
+}
 
 /*
        Given a message type create a route table entry and add to the hash keyed on the
@@ -168,7 +201,7 @@ static rtable_ent_t* uta_add_rte( route_table_t* rt, uint64_t key, int nrrgroups
        }
 
        if( (rte = (rtable_ent_t *) malloc( sizeof( *rte ) )) == NULL ) {
-               fprintf( stderr, "rmr_add_rte: malloc failed for entry\n" );
+               fprintf( stderr, "[ERR] rmr_add_rte: malloc failed for entry\n" );
                return NULL;
        }
        memset( rte, 0, sizeof( *rte ) );
@@ -193,7 +226,7 @@ static rtable_ent_t* uta_add_rte( route_table_t* rt, uint64_t key, int nrrgroups
 
        rmr_sym_map( rt->hash, key, rte );                                                      // add to hash using numeric mtype as key
 
-       if( DEBUG ) fprintf( stderr, "[DBUG] route table entry created: k=%lx groups=%d\n", key, nrrgroups );
+       if( DEBUG ) fprintf( stderr, "[DBUG] route table entry created: k=%llx groups=%d\n", (long long) key, nrrgroups );
        return rte;
 }
 
@@ -238,17 +271,20 @@ static void build_entry( uta_ctx_t* ctx, char* ts_field, uint32_t subid, char* r
                                rte = uta_add_rte( ctx->new_rtable, key, ngtoks );                                                              // get/create entry for this key
 
                                for( grp = 0; grp < ngtoks; grp++ ) {
-                                       if( (ntoks = uta_tokenise( gtokens[grp], tokens, 64, ',' )) > 0 ) {
+                                       if( (ntoks = uta_rmip_tokenise( gtokens[grp], ctx->ip_list, tokens, 64, ',' )) > 0 ) {          // remove any referneces to our ip addrs
                                                for( i = 0; i < ntoks; i++ ) {
-                                                       if( DEBUG > 1  || (vlevel > 1)) fprintf( stderr, "[DBUG]    add endpoint  %s\n", ts_field );
-                                                       uta_add_ep( ctx->new_rtable, rte, tokens[i], grp );
+                                                       if( strcmp( tokens[i], ctx->my_name ) != 0 ) {                                  // don't add if it is us -- cannot send to ourself
+                                                               if( DEBUG > 1  || (vlevel > 1)) fprintf( stderr, "[DBUG] add endpoint  ts=%s %s\n", ts_field, tokens[i] );
+                                                               uta_add_ep( ctx->new_rtable, rte, tokens[i], grp );
+                                                       }
                                                }
                                        }
                                }
                        }
                } else {
-                       if( DEBUG || (vlevel > 2) )
+                       if( DEBUG || (vlevel > 2) ) {
                                fprintf( stderr, "entry not included, sender not matched: %s\n", tokens[1] );
+                       }
                }
 }
 
@@ -489,7 +525,7 @@ static void read_static_rt( uta_ctx_t* ctx, int vlevel ) {
                return;
        }
 
-       if( (fbuf = uta_fib( fname ) ) == NULL ) {                      // read file into a single buffer (nil terminated string)
+       if( (fbuf = ensure_nlterm( uta_fib( fname ) ) ) == NULL ) {                     // read file into a single buffer (nil terminated string)
                fprintf( stderr, "[WRN] rmr read_static: seed route table could not be opened: %s: %s\n", fname, strerror( errno ) );
                return;
        }
@@ -506,8 +542,8 @@ static void read_static_rt( uta_ctx_t* ctx, int vlevel ) {
                if( (eor = strchr( rec, '\n' )) != NULL ) {
                        *eor = 0;
                } else {
-                       fprintf( stderr, "[WARN] rmr read_static: seed route table had malformed records (missing newline): %s\n", fname );
-                       fprintf( stderr, "[WARN] rmr read_static: seed route table not used%s\n", fname );
+                       fprintf( stderr, "[WRN] rmr read_static: seed route table had malformed records (missing newline): %s\n", fname );
+                       fprintf( stderr, "[WRN] rmr read_static: seed route table not used: %s\n", fname );
                        free( fbuf );
                        return;
                }
@@ -812,14 +848,14 @@ static endpoint_t* rt_ensure_ep( route_table_t* rt, char const* ep_name ) {
        endpoint_t*     ep;
 
        if( !rt || !ep_name || ! *ep_name ) {
-               fprintf( stderr, "[WARN] rmr: rt_ensure:  internal mishap, something undefined rt=%p ep_name=%p\n", rt, ep_name );
+               fprintf( stderr, "[WRN] rmr: rt_ensure:  internal mishap, something undefined rt=%p ep_name=%p\n", rt, ep_name );
                errno = EINVAL;
                return NULL;
        }
 
        if( (ep = uta_get_ep( rt, ep_name )) == NULL ) {                                        // not there yet, make
                if( (ep = (endpoint_t *) malloc( sizeof( *ep ) )) == NULL ) {
-                       fprintf( stderr, "[WARN] rmr: rt_ensure:  malloc failed for endpoint creation: %s\n", ep_name );
+                       fprintf( stderr, "[WRN] rmr: rt_ensure:  malloc failed for endpoint creation: %s\n", ep_name );
                        errno = ENOMEM;
                        return NULL;
                }