src/rmr/common/src/tools_static.c

   1 // :vi sw=4 ts=4 noet:
   2 /*
   3 ==================================================================================
   4         Copyright (c) 2019 Nokia
   5         Copyright (c) 2018-2019 AT&T Intellectual Property.
   6
   7    Licensed under the Apache License, Version 2.0 (the "License");
   8    you may not use this file except in compliance with the License.
   9    You may obtain a copy of the License at
  10
  11            http://www.apache.org/licenses/LICENSE-2.0
  12
  13    Unless required by applicable law or agreed to in writing, software
  14    distributed under the License is distributed on an "AS IS" BASIS,
  15    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16    See the License for the specific language governing permissions and
  17    limitations under the License.
  18 ==================================================================================
  19 */
  20
  21 /*
  22         Mnemonic:       tools_static.c
  23         Abstract:       A small set of very simple tools to support Uta == RMR.
  24                                         uta_tokenise -- simple string tokeniser
  25                                         uta_rmip_tokenise -- tokenise and remove ip addresses from the list
  26                                         uta_h2ip        -- look up host name and return an ip address
  27                                         uta_lookup_rtg  -- looks in env for rtg host:port
  28                                         uta_has_str     -- searches buffer of tokens for a string
  29
  30                                         uta_link2       -- establish a nanomsg connection to a host
  31
  32         Author:         E. Scott Daniels
  33         Date:           30 November 2018
  34 */
  35
  36 #ifndef _tools_static_c
  37 #define _tools_static_c
  38
  39 #include <stdio.h>
  40 #include <stdlib.h>
  41 #include <netdb.h>
  42 #include <errno.h>
  43 #include <string.h>
  44 #include <errno.h>
  45 #include <pthread.h>
  46 #include <ctype.h>
  47
  48 #include <sys/types.h>          // these are needed to suss out ip addresses from interfaces
  49 #include <ifaddrs.h>
  50 #include <arpa/inet.h>
  51 #include <sys/socket.h>
  52 #include <netdb.h>
  53
  54 // --- some protos needed for better organisation --------
  55 int is_this_myip( if_addrs_t* l, char* addr );
  56
  57
  58 // ----------------------------------------------------------------------------------
  59
  60 /*
  61         Simple tokeniser. Split a null terminated string into tokens recording the
  62         pointers in the tokens array provided.  Tokens MUST be large enough. Max is
  63         the max number of tokens to split into.  Returns the actual number of tokens
  64         recorded in the pointer array.
  65
  66         CAUTION: this modifies the string passed in!!
  67 */
  68 static int uta_tokenise( char* buf, char** tokens, int max, char sep ) {
  69         char* end;                                      // end of token
  70         int     n = 0;
  71
  72         if( !buf || ! tokens || !(*buf) ) {
  73                 return 0;
  74         }
  75
  76         tokens[n++] = buf;
  77         end = buf;
  78         while( n < max && *end && (end = strchr( end, sep )) != NULL ) {
  79                 *end = 0;
  80                 tokens[n++] = ++end;
  81         }
  82
  83         return n;
  84 }
  85
  86 /*
  87         Tokenise and remove matches.
  88         Given a buffer of 'sep' separated tokens, and a list of things,
  89         return up to max tokens with any tokens that matched things in
  90         the list. Toks is the user supplied array of char* which we will
  91         fill in (up to max) with pointers to tokens from buf.  This
  92         damages buf, so the caller must dup the string if it must be
  93         preserved for later, original, use.  The pointers returned in
  94         toks will reference portions of bufs.
  95
  96         Returns the number of tokens referenced by toks.
  97 */
  98 static int uta_rmip_tokenise( char* buf, if_addrs_t* iplist, char** toks, int max, char sep ) {
  99         int     ntoks = 0;                      // total toks in the original buffer
 100         int             pcount = 0;                     // count after prune
 101         char**  all_toks;
 102         int i;
 103         int j;
 104
 105
 106         all_toks = malloc( sizeof( char * ) * max );                                    // refernce to all tokens; we'll prune
 107         pcount = ntoks = uta_tokenise( buf, all_toks, max, sep );               // split them up
 108         j = 0;
 109         if( ntoks > 0 ) {
 110                 for( i = 0; i < ntoks; i++ ) {
 111                         if( is_this_myip( iplist, all_toks[i] ) ) {
 112                                 pcount--;                                                                       // ours, prune
 113                         } else {
 114                                 toks[j++] = all_toks[i];                                        // not one of ours, keep it
 115                         }
 116                 }
 117         }
 118
 119         free( all_toks );
 120         return pcount;
 121 }
 122
 123 /*
 124         Xlate hostname (expected to be name:port) to an IP address that nano will tolerate.
 125         We'll use the first address from the list to keep it simple. If the first character
 126         of the name is a digit, we assume it's really an IP address and just return that.
 127
 128         Return is a string which the caller must free. Even if the string passed in is already
 129         an IP address, a duplicate will be returend so that it can always be freed.
 130         On error a nil pointer is returned.
 131 */
 132 static char* uta_h2ip( char const* hname ) {
 133         char                    buf[120];
 134         struct hostent* hent;
 135         unsigned int    octs[4];
 136         unsigned int    a;
 137         int                             i;
 138         char*                   tok;
 139         char*                   dname;          // duplicated name for distruction
 140
 141         dname = strdup( hname );
 142
 143         if( isdigit( *dname ) || *dname == '[' ) {              // hostnames can't start with digit, or ipv6 [; assume ip address
 144                 return dname;
 145         }
 146
 147         if( (tok = strchr( dname, ':' )) != NULL ) {
 148                 *(tok++) = 0;
 149         }
 150
 151         hent = gethostbyname( dname );
 152         if( hent == NULL || hent->h_addr_list == NULL ) {
 153                 //fprintf( stderr, "[WRN] h2ip: dns lookup failed for: %s\n", dname );
 154                 free( dname );
 155                 return NULL;
 156         }
 157
 158         a = ntohl( *((unsigned int *)hent->h_addr_list[0]) );
 159         for( i = 3; i >= 0; i-- ) {
 160                 octs[i] = a & 0xff;
 161                 a = a >> 8;
 162         }
 163
 164         if( tok ) {                                                     // if :port was given, smash it back on
 165                 snprintf( buf, sizeof( buf ), "%d.%d.%d.%d:%s", octs[0], octs[1], octs[2], octs[3], tok );
 166         } else {
 167                 snprintf( buf, sizeof( buf ), "%d.%d.%d.%d", octs[0], octs[1], octs[2], octs[3] );
 168         }
 169
 170         free( dname );
 171         return strdup( buf );
 172 }
 173
 174
 175 /*
 176         Looks for the environment variable RMR_RTG_SVC which we assume to be name[:port], and
 177         does a dns lookup on the name. If the env does not have such a variable, we default to
 178         "rtg" and a port of 5656.
 179
 180         Returns true (1) if lookup found something;
 181
 182         CAUTION:  this is ONLY used if the RTG is a pub and we are using pub/sub to get updates.
 183                         There are issues with some underlying transport pub/sub implementations so this
 184                         is likley NOT needed/used.
 185 */
 186 static int uta_lookup_rtg( uta_ctx_t* ctx ) {
 187         char*   ev;                                     // pointer to the env value
 188         char*   def_port = "5656";
 189         char*   port = NULL;
 190         char*   dstr = NULL;
 191
 192         if( ctx == NULL ) {
 193                 return 0;
 194         }
 195
 196
 197         if( ctx->rtg_addr ) {
 198                 free( ctx->rtg_addr );
 199         }
 200
 201         if( (ev = getenv( "RMR_RTG_SVC" )) == NULL ) {
 202                 ev = "rtg";
 203                 port = def_port;
 204         } else {
 205                 dstr = strdup( ev );                    // copy so we can trash it
 206                 if( (port = strchr( dstr, ':' )) == NULL ) {
 207                         port = def_port;
 208                 } else {
 209                         *port = 0;
 210                         port++;                                         // point at the first digit
 211                 }
 212                 ev = dstr;                                              // all references below assume ev
 213         }
 214
 215         ctx->rtg_addr = uta_h2ip( ev );         // convert name to IP addr
 216         ctx->rtg_port = atoi( port );
 217         if( dstr ) {
 218                 free( dstr );
 219         }
 220
 221         return ctx->rtg_addr != NULL;
 222 }
 223
 224
 225 /*
 226         Expects a buffer of 'sep' separated tokens and looks to see if
 227         the given string is one of those tokens. Returns the token
 228         index (0 - n-1) if the string is found; -1 otherwise. The max
 229         parameter supplies the maximum number of tokens to search in
 230         the buffer.
 231
 232         On failure (-1) errno will be set in cases where memory cannot
 233         be alocated (is this even possible any more?). If errno is 0
 234         and failure is returned, then the caller should assume that
 235         the token isn't in the list, or the list had no elements.
 236 */
 237 static int uta_has_str( char const* buf, char const* str, char sep, int max ) {
 238         char*   dbuf;                   // duplicated buf so we can trash
 239         char** tokens;                  // pointer to tokens from the string
 240         int             ntokens;                // number of tokens buf split into
 241         int             i;
 242         int             rc;                             // return code
 243
 244         if( max < 2 ) {
 245                 return -1;
 246         }
 247
 248         dbuf = strdup( buf );
 249         if( dbuf == NULL  ) {
 250                 errno = ENOMEM;
 251                 return -1;
 252         }
 253
 254         if( (tokens = (char **) malloc( sizeof( char * ) * max )) == NULL ) {
 255                 errno = ENOMEM;
 256                 free( dbuf );
 257                 return -1;
 258         }
 259
 260         ntokens = uta_tokenise( dbuf, tokens, max, sep );
 261         errno = 0;
 262         rc = -1;
 263         for( i = 0; rc < 0 && i < ntokens; i++ ) {
 264                 if( tokens[i] ) {
 265                         if( strcmp( tokens[i], str ) == 0 ) {
 266                                 rc = i;
 267                         }
 268                 }
 269         }
 270
 271         free( dbuf );
 272         free( tokens );
 273         return rc;
 274 }
 275
 276 /*
 277         Generate a list of all IP address associated with the interfaces available.
 278         For now we capture them all, but we may need to limit. The port is smashed
 279         onto each IP we find so that we can do a direct compare against the addr
 280         that could be in the route table.
 281
 282         If the environment variable which limits the binding of our listen port
 283         to a single interface (ENV_BIND_IF) then ONLY that interface/address is added
 284         to the list so that we don't pick up entries from the rtable that are for other
 285         processes listening on different interfaces.
 286
 287         The ENV_BIN_IF environment variable may be either an IP address (v6 must be in
 288         square braces), or an interface name (e.g. eth0).
 289 */
 290 if_addrs_t*  mk_ip_list( char* port ) {
 291         if_addrs_t* l;
 292         struct  ifaddrs *ifs;           // pointer to head
 293         struct  ifaddrs *ele;           // pointer into the list
 294         char    octs[NI_MAXHOST+1];
 295         char    wbuf[NI_MAXHOST+128];
 296         char*   fmt;
 297         char*   envp;                           // at the environment var if there
 298         char*   target_if = NULL;       // target interface supplied by ENV_BIND_IF
 299         char*   tok;
 300
 301
 302         if( (l = (if_addrs_t *) malloc( sizeof( if_addrs_t ) )) == NULL ) {
 303                 return NULL;
 304         }
 305         memset( l, 0, sizeof( if_addrs_t ) );
 306         l->addrs = (char **) malloc( sizeof( char* ) * 128 );
 307         if( l->addrs == NULL ) {
 308                 free( l );
 309                 return NULL;
 310         }
 311
 312         if( (envp = getenv( ENV_BIND_IF )) != NULL ) {
 313                 if( isdigit( *envp ) || *envp == '[' ) {                                        // ip address given and not device name
 314                         snprintf( wbuf, sizeof( wbuf ), "%s:%s", envp, port );          // smash port onto the addr as is
 315                         l->addrs[l->naddrs] = strdup( wbuf );
 316                         l->naddrs++;
 317                         if( DEBUG ) fprintf( stderr, "[INFO] rmr: using only specific bind interface when searching specific RT entries: %s\n", wbuf );
 318                         return l;
 319                 }
 320
 321                 target_if = envp;               // device name given, suss it out below
 322         }
 323
 324         getifaddrs( &ifs );
 325         for( ele = ifs; ele; ele = ele->ifa_next ) {
 326                 memset( octs, 0, sizeof( octs ) );
 327                 if( ele && strcmp( ele->ifa_name, "lo" ) &&                                                                     // do NOT capture the loopback interface address
 328                         (target_if == NULL || strcmp( ele->ifa_name, target_if ) == 0 ) ) {             // no target, or matches ENV_BIND_IF target
 329
 330                         if( ele->ifa_addr->sa_family == AF_INET ) {
 331                                 getnameinfo( ele->ifa_addr, sizeof( struct sockaddr_in ),  octs, NI_MAXHOST, NULL, 0, NI_NUMERICHOST );
 332                                 fmt = "%s:%s";
 333                         } else {
 334                                 if( ele->ifa_addr->sa_family == AF_INET6 ) {
 335                                         getnameinfo( ele->ifa_addr, sizeof( struct sockaddr_in6 ),  octs, NI_MAXHOST, NULL, 0, NI_NUMERICHOST );
 336                                         fmt = "[%s]:%s";
 337                                 }
 338                         }
 339
 340                         if( *octs ) {
 341                                 if( (tok = strchr( octs, '%' )) != NULL ) {                     // for unknown reasons some ip6 addrs have %if-name appended; truncate
 342                                         *tok = 0;
 343                                 }
 344                                 if( l->naddrs < 128 ) {
 345                                         if( DEBUG ) fprintf( stderr, "[DBUG] capture address: %s: %s\n", ele->ifa_name, octs );
 346
 347                                         snprintf( wbuf, sizeof( wbuf ), fmt, octs, port );              // smash port onto the addr
 348                                         l->addrs[l->naddrs] = strdup( wbuf );
 349                                         l->naddrs++;
 350                                 }
 351                         }
 352                 }
 353         }
 354
 355         if( ifs ) {
 356                 freeifaddrs( ifs );
 357         }
 358
 359         return l;
 360 }
 361
 362 /*
 363         Check the address:port passed in and return true if it matches
 364         one of the addresses we saw when we built the list. Right now
 365         this isn't a speed intensive part of our processing, so we just
 366         do a straight search through the list. We don't expect this to
 367         ever be a higly driven functions so not bothering to optimise.
 368 */
 369 int is_this_myip( if_addrs_t* l, char* addr ) {
 370         int i;
 371
 372         if( l == NULL ) {
 373                 return 0;
 374         }
 375
 376         if( addr == NULL ) {
 377                 return 0;
 378         }
 379
 380         for( i = 0; i < l->naddrs; i++ ) {
 381                 if( l->addrs[i] != NULL  &&  strcmp( addr, l->addrs[i] ) == 0 ) {
 382                         return 1;
 383                 }
 384         }
 385
 386         return 0;
 387 }
 388
 389 /*
 390         Expects a buffer containing "sep" separated tokens, and a list of
 391         IP addresses anchored by ip_list.  Searches the tokens to see if
 392         any are an ip address:port which is in the ip list.  Returns true
 393         (1) if a token is in the list, false otherwise.
 394 */
 395 static int has_myip( char const* buf, if_addrs_t* list, char sep, int max ) {
 396         char*   dbuf;                   // duplicated buf so we can trash
 397         char** tokens;                  // pointer to tokens from the string
 398         int             ntokens;                // number of tokens buf split into
 399         int             i;
 400         int             rc = 0;                 // return code
 401
 402         if( max < 2 ) {
 403                 return 0;
 404         }
 405
 406         if( buf == NULL ) {
 407                 return 0;
 408         }
 409
 410         if( list == NULL ) {
 411                 return 0;
 412         }
 413
 414
 415         dbuf = strdup( buf );                   // get a copy we can mess with
 416         if( dbuf == NULL  ) {
 417                 errno = ENOMEM;
 418                 return 0;
 419         }
 420
 421         if( (tokens = (char **) malloc( sizeof( char * ) * max )) == NULL ) {
 422                 errno = ENOMEM;
 423                 free( dbuf );
 424                 return 0;
 425         }
 426
 427         ntokens = uta_tokenise( dbuf, tokens, max, sep );
 428         errno = 0;
 429         rc = 0;
 430         for( i = 0; ! rc  && i < ntokens; i++ ) {
 431                 if( tokens[i] ) {
 432                         if( is_this_myip( list, tokens[i] ) ) {
 433                                 rc = 1;
 434                                 break;
 435                         }
 436                 }
 437         }
 438
 439         free( dbuf );
 440         free( tokens );
 441         return rc;
 442 }
 443
 444 /*
 445         Given a list manager block, return the default IP address.
 446         For now, that is just the first address on the list which
 447         easily could be non-deterministic and change with each restart
 448         of the application if a specific interface is not provided via
 449         the environment variable (ENV_BIND_IF) and if there is more than
 450         one device available on the container/physical host.
 451 */
 452 static char* get_default_ip( if_addrs_t* iplist ) {
 453
 454         if( iplist != NULL  &&  iplist->naddrs > 0  &&  iplist->addrs != NULL ) {
 455                 return strdup( iplist->addrs[0] );
 456         }
 457
 458         return NULL;
 459 }
 460
 461 #endif