libcfs/libcfs/nidstrings.c

   1 /* -*- mode: c; c-basic-offset: 8; indent-tabs-mode: nil; -*-
   2  * vim:expandtab:shiftwidth=8:tabstop=8:
   3  *
   4  * GPL HEADER START
   5  *
   6  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License version 2 only,
  10  * as published by the Free Software Foundation.
  11  *
  12  * This program is distributed in the hope that it will be useful, but
  13  * WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * General Public License version 2 for more details (a copy is included
  16  * in the LICENSE file that accompanied this code).
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * version 2 along with this program; If not, see
  20  * http://www.sun.com/software/products/lustre/docs/GPLv2.pdf
  21  *
  22  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,
  23  * CA 95054 USA or visit www.sun.com if you need additional information or
  24  * have any questions.
  25  *
  26  * GPL HEADER END
  27  */
  28 /*
  29  * Copyright (c) 2008, 2010, Oracle and/or its affiliates. All rights reserved.
  30  * Use is subject to license terms.
  31  */
  32 /*
  33  * This file is part of Lustre, http://www.lustre.org/
  34  * Lustre is a trademark of Sun Microsystems, Inc.
  35  *
  36  * libcfs/libcfs/nidstrings.c
  37  *
  38  * Author: Phil Schwan <phil@clusterfs.com>
  39  */
  40
  41 #ifndef EXPORT_SYMTAB
  42 # define EXPORT_SYMTAB
  43 #endif
  44
  45 #define DEBUG_SUBSYSTEM S_LNET
  46
  47 #include <libcfs/libcfs.h>
  48 #include <lnet/lnet.h>
  49 #ifndef __KERNEL__
  50 #ifdef HAVE_GETHOSTBYNAME
  51 # include <netdb.h>
  52 #endif
  53 #endif
  54
  55 /* CAVEAT VENDITOR! Keep the canonical string representation of nets/nids
  56  * consistent in all conversion functions.  Some code fragments are copied
  57  * around for the sake of clarity...
  58  */
  59
  60 /* CAVEAT EMPTOR! Racey temporary buffer allocation!
  61  * Choose the number of nidstrings to support the MAXIMUM expected number of
  62  * concurrent users.  If there are more, the returned string will be volatile.
  63  * NB this number must allow for a process to be descheduled for a timeslice
  64  * between getting its string and using it.
  65  */
  66
  67 static char      libcfs_nidstrings[LNET_NIDSTR_COUNT][LNET_NIDSTR_SIZE];
  68 static int       libcfs_nidstring_idx = 0;
  69
  70 #ifdef __KERNEL__
  71 static cfs_spinlock_t libcfs_nidstring_lock;
  72
  73 void libcfs_init_nidstrings (void)
  74 {
  75         cfs_spin_lock_init(&libcfs_nidstring_lock);
  76 }
  77
  78 # define NIDSTR_LOCK(f)   cfs_spin_lock_irqsave(&libcfs_nidstring_lock, f)
  79 # define NIDSTR_UNLOCK(f) cfs_spin_unlock_irqrestore(&libcfs_nidstring_lock, f)
  80 #else
  81 # define NIDSTR_LOCK(f)   (f=0)                 /* avoid unused var warnings */
  82 # define NIDSTR_UNLOCK(f) (f=0)
  83 #endif
  84
  85 static char *
  86 libcfs_next_nidstring (void)
  87 {
  88         char          *str;
  89         unsigned long  flags;
  90
  91         NIDSTR_LOCK(flags);
  92
  93         str = libcfs_nidstrings[libcfs_nidstring_idx++];
  94         if (libcfs_nidstring_idx ==
  95             sizeof(libcfs_nidstrings)/sizeof(libcfs_nidstrings[0]))
  96                 libcfs_nidstring_idx = 0;
  97
  98         NIDSTR_UNLOCK(flags);
  99         return str;
 100 }
 101
 102 static int  libcfs_lo_str2addr(const char *str, int nob, __u32 *addr);
 103 static void libcfs_ip_addr2str(__u32 addr, char *str);
 104 static int  libcfs_ip_str2addr(const char *str, int nob, __u32 *addr);
 105 static void libcfs_decnum_addr2str(__u32 addr, char *str);
 106 static void libcfs_hexnum_addr2str(__u32 addr, char *str);
 107 static int  libcfs_num_str2addr(const char *str, int nob, __u32 *addr);
 108 static int  libcfs_ip_parse(char *str, int len, cfs_list_t *list);
 109 static int  libcfs_num_parse(char *str, int len, cfs_list_t *list);
 110 static int  libcfs_ip_match(__u32 addr, cfs_list_t *list);
 111 static int  libcfs_num_match(__u32 addr, cfs_list_t *list);
 112
 113 struct netstrfns {
 114         int          nf_type;
 115         char        *nf_name;
 116         char        *nf_modname;
 117         void       (*nf_addr2str)(__u32 addr, char *str);
 118         int        (*nf_str2addr)(const char *str, int nob, __u32 *addr);
 119         int        (*nf_parse_addrlist)(char *str, int len,
 120                                         cfs_list_t *list);
 121         int        (*nf_match_addr)(__u32 addr, cfs_list_t *list);
 122 };
 123
 124 static struct netstrfns  libcfs_netstrfns[] = {
 125         {/* .nf_type      */  LOLND,
 126          /* .nf_name      */  "lo",
 127          /* .nf_modname   */  "klolnd",
 128          /* .nf_addr2str  */  libcfs_decnum_addr2str,
 129          /* .nf_str2addr  */  libcfs_lo_str2addr,
 130          /* .nf_parse_addr*/  libcfs_num_parse,
 131          /* .nf_match_addr*/  libcfs_num_match},
 132         {/* .nf_type      */  SOCKLND,
 133          /* .nf_name      */  "tcp",
 134          /* .nf_modname   */  "ksocklnd",
 135          /* .nf_addr2str  */  libcfs_ip_addr2str,
 136          /* .nf_str2addr  */  libcfs_ip_str2addr,
 137          /* .nf_parse_addrlist*/  libcfs_ip_parse,
 138          /* .nf_match_addr*/  libcfs_ip_match},
 139         {/* .nf_type      */  O2IBLND,
 140          /* .nf_name      */  "o2ib",
 141          /* .nf_modname   */  "ko2iblnd",
 142          /* .nf_addr2str  */  libcfs_ip_addr2str,
 143          /* .nf_str2addr  */  libcfs_ip_str2addr,
 144          /* .nf_parse_addrlist*/  libcfs_ip_parse,
 145          /* .nf_match_addr*/  libcfs_ip_match},
 146         {/* .nf_type      */  CIBLND,
 147          /* .nf_name      */  "cib",
 148          /* .nf_modname   */  "kciblnd",
 149          /* .nf_addr2str  */  libcfs_ip_addr2str,
 150          /* .nf_str2addr  */  libcfs_ip_str2addr,
 151          /* .nf_parse_addrlist*/  libcfs_ip_parse,
 152          /* .nf_match_addr*/  libcfs_ip_match},
 153         {/* .nf_type      */  OPENIBLND,
 154          /* .nf_name      */  "openib",
 155          /* .nf_modname   */  "kopeniblnd",
 156          /* .nf_addr2str  */  libcfs_ip_addr2str,
 157          /* .nf_str2addr  */  libcfs_ip_str2addr,
 158          /* .nf_parse_addrlist*/  libcfs_ip_parse,
 159          /* .nf_match_addr*/  libcfs_ip_match},
 160         {/* .nf_type      */  IIBLND,
 161          /* .nf_name      */  "iib",
 162          /* .nf_modname   */  "kiiblnd",
 163          /* .nf_addr2str  */  libcfs_ip_addr2str,
 164          /* .nf_str2addr  */  libcfs_ip_str2addr,
 165          /* .nf_parse_addrlist*/  libcfs_ip_parse,
 166          /* .nf_match_addr*/  libcfs_ip_match},
 167         {/* .nf_type      */  VIBLND,
 168          /* .nf_name      */  "vib",
 169          /* .nf_modname   */  "kviblnd",
 170          /* .nf_addr2str  */  libcfs_ip_addr2str,
 171          /* .nf_str2addr  */  libcfs_ip_str2addr,
 172          /* .nf_parse_addrlist*/  libcfs_ip_parse,
 173          /* .nf_match_addr*/  libcfs_ip_match},
 174         {/* .nf_type      */  RALND,
 175          /* .nf_name      */  "ra",
 176          /* .nf_modname   */  "kralnd",
 177          /* .nf_addr2str  */  libcfs_ip_addr2str,
 178          /* .nf_str2addr  */  libcfs_ip_str2addr,
 179          /* .nf_parse_addrlist*/  libcfs_ip_parse,
 180          /* .nf_match_addr*/  libcfs_ip_match},
 181         {/* .nf_type      */  QSWLND,
 182          /* .nf_name      */  "elan",
 183          /* .nf_modname   */  "kqswlnd",
 184          /* .nf_addr2str  */  libcfs_decnum_addr2str,
 185          /* .nf_str2addr  */  libcfs_num_str2addr,
 186          /* .nf_parse_addrlist*/  libcfs_num_parse,
 187          /* .nf_match_addr*/  libcfs_num_match},
 188         {/* .nf_type      */  GMLND,
 189          /* .nf_name      */  "gm",
 190          /* .nf_modname   */  "kgmlnd",
 191          /* .nf_addr2str  */  libcfs_hexnum_addr2str,
 192          /* .nf_str2addr  */  libcfs_num_str2addr,
 193          /* .nf_parse_addrlist*/  libcfs_num_parse,
 194          /* .nf_match_addr*/  libcfs_num_match},
 195         {/* .nf_type      */  MXLND,
 196          /* .nf_name      */  "mx",
 197          /* .nf_modname   */  "kmxlnd",
 198          /* .nf_addr2str  */  libcfs_ip_addr2str,
 199          /* .nf_str2addr  */  libcfs_ip_str2addr,
 200          /* .nf_parse_addrlist*/  libcfs_ip_parse,
 201          /* .nf_match_addr*/  libcfs_ip_match},
 202         {/* .nf_type      */  PTLLND,
 203          /* .nf_name      */  "ptl",
 204          /* .nf_modname   */  "kptllnd",
 205          /* .nf_addr2str  */  libcfs_decnum_addr2str,
 206          /* .nf_str2addr  */  libcfs_num_str2addr,
 207          /* .nf_parse_addrlist*/  libcfs_num_parse,
 208          /* .nf_match_addr*/  libcfs_num_match},
 209         /* placeholder for net0 alias.  It MUST BE THE LAST ENTRY */
 210         {/* .nf_type      */  -1},
 211 };
 212
 213 const int libcfs_nnetstrfns = sizeof(libcfs_netstrfns)/sizeof(libcfs_netstrfns[0]);
 214
 215 int
 216 libcfs_lo_str2addr(const char *str, int nob, __u32 *addr)
 217 {
 218         *addr = 0;
 219         return 1;
 220 }
 221
 222 void
 223 libcfs_ip_addr2str(__u32 addr, char *str)
 224 {
 225 #if 0   /* never lookup */
 226 #if !defined(__KERNEL__) && defined HAVE_GETHOSTBYNAME
 227         __u32           netip = htonl(addr);
 228         struct hostent *he = gethostbyaddr(&netip, sizeof(netip), AF_INET);
 229
 230         if (he != NULL) {
 231                 snprintf(str, LNET_NIDSTR_SIZE, "%s", he->h_name);
 232                 return;
 233         }
 234 #endif
 235 #endif
 236         snprintf(str, LNET_NIDSTR_SIZE, "%u.%u.%u.%u",
 237                  (addr >> 24) & 0xff, (addr >> 16) & 0xff,
 238                  (addr >> 8) & 0xff, addr & 0xff);
 239 }
 240
 241 /* CAVEAT EMPTOR XscanfX
 242  * I use "%n" at the end of a sscanf format to detect trailing junk.  However
 243  * sscanf may return immediately if it sees the terminating '0' in a string, so
 244  * I initialise the %n variable to the expected length.  If sscanf sets it;
 245  * fine, if it doesn't, then the scan ended at the end of the string, which is
 246  * fine too :) */
 247
 248 int
 249 libcfs_ip_str2addr(const char *str, int nob, __u32 *addr)
 250 {
 251         int   a;
 252         int   b;
 253         int   c;
 254         int   d;
 255         int   n = nob;                          /* XscanfX */
 256
 257         /* numeric IP? */
 258         if (sscanf(str, "%u.%u.%u.%u%n", &a, &b, &c, &d, &n) >= 4 &&
 259             n == nob &&
 260             (a & ~0xff) == 0 && (b & ~0xff) == 0 &&
 261             (c & ~0xff) == 0 && (d & ~0xff) == 0) {
 262                 *addr = ((a<<24)|(b<<16)|(c<<8)|d);
 263                 return 1;
 264         }
 265
 266 #if !defined(__KERNEL__) && defined HAVE_GETHOSTBYNAME
 267         /* known hostname? */
 268         if (('a' <= str[0] && str[0] <= 'z') ||
 269             ('A' <= str[0] && str[0] <= 'Z')) {
 270                 char *tmp;
 271
 272                 LIBCFS_ALLOC(tmp, nob + 1);
 273                 if (tmp != NULL) {
 274                         struct hostent *he;
 275
 276                         memcpy(tmp, str, nob);
 277                         tmp[nob] = 0;
 278
 279                         he = gethostbyname(tmp);
 280
 281                         LIBCFS_FREE(tmp, nob);
 282
 283                         if (he != NULL) {
 284                                 __u32 ip = *(__u32 *)he->h_addr;
 285
 286                                 *addr = ntohl(ip);
 287                                 return 1;
 288                         }
 289                 }
 290         }
 291 #endif
 292         return 0;
 293 }
 294
 295 void
 296 libcfs_decnum_addr2str(__u32 addr, char *str)
 297 {
 298         snprintf(str, LNET_NIDSTR_SIZE, "%u", addr);
 299 }
 300
 301 void
 302 libcfs_hexnum_addr2str(__u32 addr, char *str)
 303 {
 304         snprintf(str, LNET_NIDSTR_SIZE, "0x%x", addr);
 305 }
 306
 307 int
 308 libcfs_num_str2addr(const char *str, int nob, __u32 *addr)
 309 {
 310         int     n;
 311
 312         n = nob;
 313         if (sscanf(str, "0x%x%n", addr, &n) >= 1 && n == nob)
 314                 return 1;
 315
 316         n = nob;
 317         if (sscanf(str, "0X%x%n", addr, &n) >= 1 && n == nob)
 318                 return 1;
 319
 320         n = nob;
 321         if (sscanf(str, "%u%n", addr, &n) >= 1 && n == nob)
 322                 return 1;
 323
 324         return 0;
 325 }
 326
 327 struct netstrfns *
 328 libcfs_lnd2netstrfns(int lnd)
 329 {
 330         int    i;
 331
 332         if (lnd >= 0)
 333                 for (i = 0; i < libcfs_nnetstrfns; i++)
 334                         if (lnd == libcfs_netstrfns[i].nf_type)
 335                                 return &libcfs_netstrfns[i];
 336
 337         return NULL;
 338 }
 339
 340 struct netstrfns *
 341 libcfs_namenum2netstrfns(const char *name)
 342 {
 343         struct netstrfns *nf;
 344         int               i;
 345
 346         for (i = 0; i < libcfs_nnetstrfns; i++) {
 347                 nf = &libcfs_netstrfns[i];
 348                 if (nf->nf_type >= 0 &&
 349                     !strncmp(name, nf->nf_name, strlen(nf->nf_name)))
 350                         return nf;
 351         }
 352         return NULL;
 353 }
 354
 355 struct netstrfns *
 356 libcfs_name2netstrfns(const char *name)
 357 {
 358         int    i;
 359
 360         for (i = 0; i < libcfs_nnetstrfns; i++)
 361                 if (libcfs_netstrfns[i].nf_type >= 0 &&
 362                     !strcmp(libcfs_netstrfns[i].nf_name, name))
 363                         return &libcfs_netstrfns[i];
 364
 365         return NULL;
 366 }
 367
 368 int
 369 libcfs_isknown_lnd(int type)
 370 {
 371         return libcfs_lnd2netstrfns(type) != NULL;
 372 }
 373
 374 char *
 375 libcfs_lnd2modname(int lnd)
 376 {
 377         struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
 378
 379         return (nf == NULL) ? NULL : nf->nf_modname;
 380 }
 381
 382 char *
 383 libcfs_lnd2str(int lnd)
 384 {
 385         char           *str;
 386         struct netstrfns *nf = libcfs_lnd2netstrfns(lnd);
 387
 388         if (nf != NULL)
 389                 return nf->nf_name;
 390
 391         str = libcfs_next_nidstring();
 392         snprintf(str, LNET_NIDSTR_SIZE, "?%u?", lnd);
 393         return str;
 394 }
 395
 396 int
 397 libcfs_str2lnd(const char *str)
 398 {
 399         struct netstrfns *nf = libcfs_name2netstrfns(str);
 400
 401         if (nf != NULL)
 402                 return nf->nf_type;
 403
 404         return -1;
 405 }
 406
 407 char *
 408 libcfs_net2str(__u32 net)
 409 {
 410         int               lnd = LNET_NETTYP(net);
 411         int               num = LNET_NETNUM(net);
 412         struct netstrfns *nf  = libcfs_lnd2netstrfns(lnd);
 413         char             *str = libcfs_next_nidstring();
 414
 415         if (nf == NULL)
 416                 snprintf(str, LNET_NIDSTR_SIZE, "<%u:%u>", lnd, num);
 417         else if (num == 0)
 418                 snprintf(str, LNET_NIDSTR_SIZE, "%s", nf->nf_name);
 419         else
 420                 snprintf(str, LNET_NIDSTR_SIZE, "%s%u", nf->nf_name, num);
 421
 422         return str;
 423 }
 424
 425 char *
 426 libcfs_nid2str(lnet_nid_t nid)
 427 {
 428         __u32             addr = LNET_NIDADDR(nid);
 429         __u32             net = LNET_NIDNET(nid);
 430         int               lnd = LNET_NETTYP(net);
 431         int               nnum = LNET_NETNUM(net);
 432         struct netstrfns *nf;
 433         char             *str;
 434         int               nob;
 435
 436         if (nid == LNET_NID_ANY)
 437                 return "LNET_NID_ANY";
 438
 439         nf = libcfs_lnd2netstrfns(lnd);
 440         str = libcfs_next_nidstring();
 441
 442         if (nf == NULL)
 443                 snprintf(str, LNET_NIDSTR_SIZE, "%x@<%u:%u>", addr, lnd, nnum);
 444         else {
 445                 nf->nf_addr2str(addr, str);
 446                 nob = strlen(str);
 447                 if (nnum == 0)
 448                         snprintf(str + nob, LNET_NIDSTR_SIZE - nob, "@%s",
 449                                  nf->nf_name);
 450                 else
 451                         snprintf(str + nob, LNET_NIDSTR_SIZE - nob, "@%s%u",
 452                                  nf->nf_name, nnum);
 453         }
 454
 455         return str;
 456 }
 457
 458 static struct netstrfns *
 459 libcfs_str2net_internal(const char *str, __u32 *net)
 460 {
 461         struct netstrfns *nf;
 462         int               nob;
 463         int               netnum;
 464         int               i;
 465
 466         for (i = 0; i < libcfs_nnetstrfns; i++) {
 467                 nf = &libcfs_netstrfns[i];
 468                 if (nf->nf_type >= 0 &&
 469                     !strncmp(str, nf->nf_name, strlen(nf->nf_name)))
 470                         break;
 471         }
 472
 473         if (i == libcfs_nnetstrfns)
 474                 return NULL;
 475
 476         nob = strlen(nf->nf_name);
 477
 478         if (strlen(str) == (unsigned int)nob) {
 479                 netnum = 0;
 480         } else {
 481                 if (nf->nf_type == LOLND) /* net number not allowed */
 482                         return NULL;
 483
 484                 str += nob;
 485                 i = strlen(str);
 486                 if (sscanf(str, "%u%n", &netnum, &i) < 1 ||
 487                     i != (int)strlen(str))
 488                         return NULL;
 489         }
 490
 491         *net = LNET_MKNET(nf->nf_type, netnum);
 492         return nf;
 493 }
 494
 495 __u32
 496 libcfs_str2net(const char *str)
 497 {
 498         __u32  net;
 499
 500         if (libcfs_str2net_internal(str, &net) != NULL)
 501                 return net;
 502
 503         return LNET_NIDNET(LNET_NID_ANY);
 504 }
 505
 506 lnet_nid_t
 507 libcfs_str2nid(const char *str)
 508 {
 509         const char       *sep = strchr(str, '@');
 510         struct netstrfns *nf;
 511         __u32             net;
 512         __u32             addr;
 513
 514         if (sep != NULL) {
 515                 nf = libcfs_str2net_internal(sep + 1, &net);
 516                 if (nf == NULL)
 517                         return LNET_NID_ANY;
 518         } else {
 519                 sep = str + strlen(str);
 520                 net = LNET_MKNET(SOCKLND, 0);
 521                 nf = libcfs_lnd2netstrfns(SOCKLND);
 522                 LASSERT (nf != NULL);
 523         }
 524
 525         if (!nf->nf_str2addr(str, (int)(sep - str), &addr))
 526                 return LNET_NID_ANY;
 527
 528         return LNET_MKNID(net, addr);
 529 }
 530
 531 char *
 532 libcfs_id2str(lnet_process_id_t id)
 533 {
 534         char *str = libcfs_next_nidstring();
 535
 536         if (id.pid == LNET_PID_ANY) {
 537                 snprintf(str, LNET_NIDSTR_SIZE,
 538                          "LNET_PID_ANY-%s", libcfs_nid2str(id.nid));
 539                 return str;
 540         }
 541
 542         snprintf(str, LNET_NIDSTR_SIZE, "%s%u-%s",
 543                  ((id.pid & LNET_PID_USERFLAG) != 0) ? "U" : "",
 544                  (id.pid & ~LNET_PID_USERFLAG), libcfs_nid2str(id.nid));
 545         return str;
 546 }
 547
 548 int
 549 libcfs_str2anynid(lnet_nid_t *nidp, const char *str)
 550 {
 551         if (!strcmp(str, "*")) {
 552                 *nidp = LNET_NID_ANY;
 553                 return 1;
 554         }
 555
 556         *nidp = libcfs_str2nid(str);
 557         return *nidp != LNET_NID_ANY;
 558 }
 559
 560 /**
 561  * Nid range list syntax.
 562  * \verbatim
 563  *
 564  * <nidlist>         :== <nidrange> [ ' ' <nidrange> ]
 565  * <nidrange>        :== <addrrange> '@' <net>
 566  * <addrrange>       :== '*' |
 567  *                       <ipaddr_range> |
 568  *                       <numaddr_range>
 569  * <ipaddr_range>    :== <numaddr_range>.<numaddr_range>.<numaddr_range>.
 570  *                       <numaddr_range>
 571  * <numaddr_range>   :== <number> |
 572  *                       <expr_list>
 573  * <expr_list>       :== '[' <range_expr> [ ',' <range_expr>] ']'
 574  * <range_expr>      :== <number> |
 575  *                       <number> '-' <number> |
 576  *                       <number> '-' <number> '/' <number>
 577  * <net>             :== <netname> | <netname><number>
 578  * <netname>         :== "lo" | "tcp" | "o2ib" | "cib" | "openib" | "iib" |
 579  *                       "vib" | "ra" | "elan" | "mx" | "ptl"
 580  * \endverbatim
 581  */
 582
 583 /**
 584  * Structure to represent NULL-less strings.
 585  */
 586 struct lstr {
 587         char *ls_str;
 588         int ls_len;
 589 };
 590
 591 /**
 592  * Structure to represent \<nidrange\> token of the syntax.
 593  *
 594  * One of this is created for each \<net\> parsed.
 595  */
 596 struct nidrange {
 597         /**
 598          * Link to list of this structures which is built on nid range
 599          * list parsing.
 600          */
 601         cfs_list_t nr_link;
 602         /**
 603          * List head for addrrange::ar_link.
 604          */
 605         cfs_list_t nr_addrranges;
 606         /**
 607          * Flag indicating that *@<net> is found.
 608          */
 609         int nr_all;
 610         /**
 611          * Pointer to corresponding element of libcfs_netstrfns.
 612          */
 613         struct netstrfns *nr_netstrfns;
 614         /**
 615          * Number of network. E.g. 5 if \<net\> is "elan5".
 616          */
 617         int nr_netnum;
 618 };
 619
 620 /**
 621  * Structure to represent \<addrrange\> token of the syntax.
 622  */
 623 struct addrrange {
 624         /**
 625          * Link to nidrange::nr_addrranges.
 626          */
 627         cfs_list_t ar_link;
 628         /**
 629          * List head for numaddr_range::nar_link.
 630          */
 631         cfs_list_t ar_numaddr_ranges;
 632 };
 633
 634 /**
 635  * Structure to represent \<numaddr_range\> token of the syntax.
 636  */
 637 struct numaddr_range {
 638         /**
 639          * Link to addrrange::ar_numaddr_ranges.
 640          */
 641         cfs_list_t nar_link;
 642         /**
 643          * List head for range_expr::re_link.
 644          */
 645         cfs_list_t nar_range_exprs;
 646 };
 647
 648 /**
 649  * Structure to represent \<range_expr\> token of the syntax.
 650  */
 651 struct range_expr {
 652         /**
 653          * Link to numaddr_range::nar_range_exprs.
 654          */
 655         cfs_list_t re_link;
 656         __u32 re_lo;
 657         __u32 re_hi;
 658         __u32 re_stride;
 659 };
 660
 661 int
 662 cfs_iswhite(char c)
 663 {
 664         switch (c) {
 665         case ' ':
 666         case '\t':
 667         case '\n':
 668         case '\r':
 669                 return 1;
 670         default:
 671                 break;
 672         }
 673         return 0;
 674 }
 675
 676 /*
 677  * Extracts tokens from strings.
 678  *
 679  * Looks for \a delim in string \a next, sets \a res to point to
 680  * substring before the delimiter, sets \a next right after the found
 681  * delimiter.
 682  *
 683  * \retval 1 if \a res points to a string of non-whitespace characters
 684  * \retval 0 otherwise
 685  */
 686 static int
 687 gettok(struct lstr *next, char delim, struct lstr *res)
 688 {
 689         char *end;
 690
 691         if (next->ls_str == NULL)
 692                 return 0;
 693
 694         /* skip leading white spaces */
 695         while (next->ls_len) {
 696                 if (!cfs_iswhite(*next->ls_str))
 697                         break;
 698                 next->ls_str ++;
 699                 next->ls_len --;
 700         }
 701         if (next->ls_len == 0)
 702                 /* whitespaces only */
 703                 return 0;
 704
 705         if (*next->ls_str == delim)
 706                 /* first non-writespace is the delimiter */
 707                 return 0;
 708
 709         res->ls_str = next->ls_str;
 710         end = memchr(next->ls_str, delim, next->ls_len);
 711         if (end == NULL) {
 712                 /* there is no the delimeter in the string */
 713                 end = next->ls_str + next->ls_len;
 714                 next->ls_str = NULL;
 715         } else {
 716                 next->ls_str = end + 1;
 717                 next->ls_len -= (end - res->ls_str + 1);
 718         }
 719
 720         /* skip ending whitespaces */
 721         while (--end != res->ls_str)
 722                 if (!cfs_iswhite(*end))
 723                         break;
 724
 725         res->ls_len = end - res->ls_str + 1;
 726         return 1;
 727 }
 728
 729 /**
 730  * Converts string to integer.
 731  *
 732  * Accepts decimal and hexadecimal number recordings.
 733  *
 734  * \retval 1 if first \a nob chars of \a str convert to decimal or
 735  * hexadecimal integer in the range [\a min, \a max]
 736  * \retval 0 otherwise
 737  */
 738 static int
 739 libcfs_str2num_check(const char *str, int nob, unsigned *num,
 740                      unsigned min, unsigned max)
 741 {
 742         int n;
 743         char nstr[12];
 744
 745         n = nob;
 746         if (sscanf(str, "%u%n", num, &n) != 1 || n != nob)
 747                 if (sscanf(str, "0x%x%n", num, &n) != 1 || n != nob)
 748                         if (sscanf(str, "0X%x%n", num, &n) != 1 || n != nob)
 749                                 return 0;
 750         sprintf(nstr, "%u", *num);
 751         if (n != strlen(nstr) || memcmp(nstr, str, n)) {
 752                 sprintf(nstr, "0x%x", *num);
 753                 if (n != strlen(nstr) || memcmp(nstr, str, n)) {
 754                         sprintf(nstr, "0X%x", *num);
 755                         if (n != strlen(nstr) || memcmp(nstr, str, n))
 756                                 return 0;
 757                 }
 758         }
 759         if (*num < min || *num > max)
 760                 return 0;
 761         return 1;
 762 }
 763
 764 /**
 765  * Parses \<range_expr\> token of the syntax.
 766  *
 767  * \retval pointer to allocated range_expr and initialized
 768  * range_expr::re_lo, range_expr::re_hi and range_expr:re_stride if \a
 769  `* src parses to
 770  * \<number\> |
 771  * \<number\> '-' \<number\> |
 772  * \<number\> '-' \<number\> '/' \<number\>
 773  * \retval NULL othersize
 774  */
 775 static struct range_expr *
 776 parse_range_expr(struct lstr *src, unsigned min, unsigned max)
 777 {
 778         struct lstr tok;
 779         struct range_expr *expr;
 780
 781         LIBCFS_ALLOC(expr, sizeof(struct range_expr));
 782         if (expr == NULL)
 783                 return NULL;
 784
 785         if (libcfs_str2num_check(src->ls_str, src->ls_len, &expr->re_lo,
 786                                  min, max)) {
 787                 /* <number> is parsed */
 788                 expr->re_hi = expr->re_lo;
 789                 expr->re_stride = 1;
 790                 return expr;
 791         }
 792
 793         if (!gettok(src, '-', &tok))
 794                 goto failed;
 795         if (!libcfs_str2num_check(tok.ls_str, tok.ls_len, &expr->re_lo,
 796                                   min, max))
 797                 goto failed;
 798         /* <number> - */
 799         if (libcfs_str2num_check(src->ls_str, src->ls_len, &expr->re_hi,
 800                                  min, max)) {
 801                 /* <number> - <number> is parsed */
 802                 expr->re_stride = 1;
 803                 return expr;
 804         }
 805
 806         /* go to check <number> '-' <number> '/' <number> */
 807         if (gettok(src, '/', &tok)) {
 808                 if (!libcfs_str2num_check(tok.ls_str, tok.ls_len,
 809                                           &expr->re_hi, min, max))
 810                         goto failed;
 811                 /* <number> - <number> / ... */
 812                 if (libcfs_str2num_check(src->ls_str, src->ls_len,
 813                                          &expr->re_stride, min, max))
 814                         /* <number> - <number> / <number> is parsed */
 815                         return expr;
 816         }
 817
 818 failed:
 819         LIBCFS_FREE(expr, sizeof(struct range_expr));
 820         return NULL;
 821 }
 822
 823 /**
 824  * Parses \<expr_list\> token of the syntax.
 825  *
 826  * \retval 1 if \a str parses to '[' \<range_expr\> [ ',' \<range_expr\>] ']'
 827  * \retval 0 otherwise
 828  */
 829 static int
 830 parse_expr_list(struct lstr *str, cfs_list_t *list,
 831                 unsigned min, unsigned max)
 832 {
 833         struct lstr res;
 834         struct range_expr *range;
 835
 836         if (str->ls_str[0] != '[' || str->ls_str[str->ls_len - 1] != ']')
 837                 return 0;
 838         str->ls_str ++;
 839         str->ls_len -= 2;
 840
 841         while (str->ls_str) {
 842                 if (gettok(str, ',', &res) == 0)
 843                         return 0;
 844                 range = parse_range_expr(&res, min, max);
 845                 if (range == NULL)
 846                         return 0;
 847                 cfs_list_add_tail(&range->re_link, list);
 848         }
 849         return 1;
 850 }
 851
 852 /**
 853  * Parses \<numaddr_range\> token of the syntax.
 854  *
 855  * \retval 1 if \a str parses to \<number\> | \<expr_list\>
 856  * \retval 0 otherwise
 857  */
 858 static int
 859 num_parse(char *str, int len,
 860           cfs_list_t *list, unsigned min, unsigned max)
 861 {
 862         __u32 num;
 863         struct lstr src;
 864         struct numaddr_range *numaddr;
 865
 866         src.ls_str = str;
 867         src.ls_len = len;
 868
 869         LIBCFS_ALLOC(numaddr, sizeof(struct numaddr_range));
 870         if (numaddr == NULL)
 871                 return 0;
 872         cfs_list_add_tail(&numaddr->nar_link, list);
 873         CFS_INIT_LIST_HEAD(&numaddr->nar_range_exprs);
 874
 875         if (libcfs_str2num_check(src.ls_str, src.ls_len, &num, min, max)) {
 876                 /* <number> */
 877                 struct range_expr *expr;
 878
 879                 LIBCFS_ALLOC(expr, sizeof(struct range_expr));
 880                 if (expr == NULL)
 881                         return 0;
 882
 883                 expr->re_lo = expr->re_hi = num;
 884                 expr->re_stride = 1;
 885                 cfs_list_add_tail(&expr->re_link, &numaddr->nar_range_exprs);
 886                 return 1;
 887         }
 888
 889         return parse_expr_list(&src, &numaddr->nar_range_exprs, min, max);
 890 }
 891
 892 /**
 893  * Nf_parse_addrlist method for networks using numeric addresses.
 894  *
 895  * Examples of such networks are gm and elan.
 896  *
 897  * \retval 1 if \a str parsed to numeric address
 898  * \retval 0 otherwise
 899  */
 900 static int
 901 libcfs_num_parse(char *str, int len, cfs_list_t *list)
 902 {
 903         return num_parse(str, len, list, 0, MAX_NUMERIC_VALUE);
 904 }
 905
 906 /**
 907  * Nf_parse_addrlist method for networks using ip addresses.
 908  *
 909  * Examples of such networks are tcp and o2ib.
 910  *
 911  * \retval 1 if \a str parsed to ip address
 912  * \retval 0 otherwise
 913  */
 914 static int
 915 libcfs_ip_parse(char *str, int len,
 916                 cfs_list_t *list)
 917 {
 918         struct lstr src, res;
 919         int i;
 920
 921         src.ls_str = str;
 922         src.ls_len = len;
 923         i = 0;
 924         while (src.ls_str) {
 925                 if (gettok(&src, '.', &res) == 0)
 926                         return 0;
 927                 if (!num_parse(res.ls_str, res.ls_len, list, 0, 255))
 928                         return 0;
 929                 i ++;
 930         }
 931
 932         return (i == 4) ? 1 : 0;
 933 }
 934
 935 /**
 936  * Parses \<addrrange\> token on the syntax.
 937  *
 938  * Allocates struct addrrange and links to \a nidrange via
 939  * (nidrange::nr_addrranges)
 940  *
 941  * \retval 1 if \a src parses to '*' | \<ipaddr_range\> | \<numaddr_range\>
 942  * \retval 0 otherwise
 943  */
 944 static int
 945 parse_addrange(const struct lstr *src, struct nidrange *nidrange)
 946 {
 947         struct addrrange *addrrange;
 948
 949         if (src->ls_len == 1 && src->ls_str[0] == '*') {
 950                 nidrange->nr_all = 1;
 951                 return 1;
 952         }
 953
 954         LIBCFS_ALLOC(addrrange, sizeof(struct addrrange));
 955         if (addrrange == NULL)
 956                 return 0;
 957         cfs_list_add_tail(&addrrange->ar_link, &nidrange->nr_addrranges);
 958         CFS_INIT_LIST_HEAD(&addrrange->ar_numaddr_ranges);
 959
 960         return nidrange->nr_netstrfns->nf_parse_addrlist(src->ls_str,
 961                                                 src->ls_len,
 962                                                 &addrrange->ar_numaddr_ranges);
 963 }
 964
 965 /**
 966  * Finds or creates struct nidrange.
 967  *
 968  * Checks if \a src is a valid network name, looks for corresponding
 969  * nidrange on the ist of nidranges (\a nidlist), creates new struct
 970  * nidrange if it is not found.
 971  *
 972  * \retval pointer to struct nidrange matching network specified via \a src
 973  * \retval NULL if \a src does not match any network
 974  */
 975 static struct nidrange *
 976 add_nidrange(const struct lstr *src,
 977              cfs_list_t *nidlist)
 978 {
 979         struct netstrfns *nf;
 980         struct nidrange *nr;
 981         int endlen;
 982         unsigned netnum;
 983
 984         if (src->ls_len >= LNET_NIDSTR_SIZE)
 985                 return NULL;
 986
 987         nf = libcfs_namenum2netstrfns(src->ls_str);
 988         if (nf == NULL)
 989                 return NULL;
 990         endlen = src->ls_len - strlen(nf->nf_name);
 991         if (endlen == 0)
 992                 /* network name only, e.g. "elan" or "tcp" */
 993                 netnum = 0;
 994         else {
 995                 /* e.g. "elan25" or "tcp23", refuse to parse if
 996                  * network name is not appended with decimal or
 997                  * hexadecimal number */
 998                 if (!libcfs_str2num_check(src->ls_str + strlen(nf->nf_name),
 999                                           endlen, &netnum,
1000                                           0, MAX_NUMERIC_VALUE))
1001                         return NULL;
1002         }
1003
1004         cfs_list_for_each_entry(nr, nidlist, nr_link) {
1005                 if (nr->nr_netstrfns != nf)
1006                         continue;
1007                 if (nr->nr_netnum != netnum)
1008                         continue;
1009                 return nr;
1010         }
1011
1012         LIBCFS_ALLOC(nr, sizeof(struct nidrange));
1013         if (nr == NULL)
1014                 return NULL;
1015         cfs_list_add_tail(&nr->nr_link, nidlist);
1016         CFS_INIT_LIST_HEAD(&nr->nr_addrranges);
1017         nr->nr_netstrfns = nf;
1018         nr->nr_all = 0;
1019         nr->nr_netnum = netnum;
1020
1021         return nr;
1022 }
1023
1024 /**
1025  * Parses \<nidrange\> token of the syntax.
1026  *
1027  * \retval 1 if \a src parses to \<addrrange\> '@' \<net\>
1028  * \retval 0 otherwise
1029  */
1030 static int
1031 parse_nidrange(struct lstr *src, cfs_list_t *nidlist)
1032 {
1033         struct lstr addrrange, net, tmp;
1034         struct nidrange *nr;
1035
1036         tmp = *src;
1037         if (gettok(src, '@', &addrrange) == 0)
1038                 goto failed;
1039
1040         if (gettok(src, '@', &net) == 0 || src->ls_str != NULL)
1041                 goto failed;
1042
1043         nr = add_nidrange(&net, nidlist);
1044         if (nr == NULL)
1045                 goto failed;
1046
1047         if (!parse_addrange(&addrrange, nr))
1048                 goto failed;
1049
1050         return 1;
1051  failed:
1052         CWARN("can't parse nidrange: \"%.*s\"\n", tmp.ls_len, tmp.ls_str);
1053         return 0;
1054 }
1055
1056 /**
1057  * Frees range_expr structures of \a list.
1058  *
1059  * \retval none
1060  */
1061 static void
1062 free_range_exprs(cfs_list_t *list)
1063 {
1064         cfs_list_t *pos, *next;
1065
1066         cfs_list_for_each_safe(pos, next, list) {
1067                 cfs_list_del(pos);
1068                 LIBCFS_FREE(cfs_list_entry(pos, struct range_expr, re_link),
1069                             sizeof(struct range_expr));
1070         }
1071 }
1072
1073 /**
1074  * Frees numaddr_range structures of \a list.
1075  *
1076  * For each struct numaddr_range structure found on \a list it frees
1077  * range_expr list attached to it and frees the numddr_range itself.
1078  *
1079  * \retval none
1080  */
1081 static void
1082 free_numaddr_ranges(cfs_list_t *list)
1083 {
1084         cfs_list_t *pos, *next;
1085         struct numaddr_range *numaddr;
1086
1087         cfs_list_for_each_safe(pos, next, list) {
1088                 numaddr = cfs_list_entry(pos, struct numaddr_range, nar_link);
1089                 free_range_exprs(&numaddr->nar_range_exprs);
1090                 cfs_list_del(pos);
1091                 LIBCFS_FREE(numaddr, sizeof(struct numaddr_range));
1092         }
1093 }
1094
1095 /**
1096  * Frees addrrange structures of \a list.
1097  *
1098  * For each struct addrrange structure found on \a list it frees
1099  * numaddr_range list attached to it and frees the addrrange itself.
1100  *
1101  * \retval none
1102  */
1103 static void
1104 free_addrranges(cfs_list_t *list)
1105 {
1106         cfs_list_t *pos, *next;
1107         struct addrrange *ar;
1108
1109         cfs_list_for_each_safe(pos, next, list) {
1110                 ar = cfs_list_entry(pos, struct addrrange, ar_link);
1111                 free_numaddr_ranges(&ar->ar_numaddr_ranges);
1112                 cfs_list_del(pos);
1113                 LIBCFS_FREE(ar, sizeof(struct addrrange));
1114         }
1115 }
1116
1117 /**
1118  * Frees nidrange strutures of \a list.
1119  *
1120  * For each struct nidrange structure found on \a list it frees
1121  * addrrange list attached to it and frees the nidrange itself.
1122  *
1123  * \retval none
1124  */
1125 void
1126 cfs_free_nidlist(cfs_list_t *list)
1127 {
1128         cfs_list_t *pos, *next;
1129         struct nidrange *nr;
1130
1131         cfs_list_for_each_safe(pos, next, list) {
1132                 nr = cfs_list_entry(pos, struct nidrange, nr_link);
1133                 free_addrranges(&nr->nr_addrranges);
1134                 cfs_list_del(pos);
1135                 LIBCFS_FREE(nr, sizeof(struct nidrange));
1136         }
1137 }
1138
1139 /**
1140  * Parses nid range list.
1141  *
1142  * Parses with rigorous syntax and overflow checking \a str into
1143  * \<nidrange\> [ ' ' \<nidrange\> ], compiles \a str into set of
1144  * structures and links that structure to \a nidlist. The resulting
1145  * list can be used to match a NID againts set of NIDS defined by \a
1146  * str.
1147  * \see cfs_match_nid
1148  *
1149  * \retval 1 on success
1150  * \retval 0 otherwise
1151  */
1152 int
1153 cfs_parse_nidlist(char *str, int len, cfs_list_t *nidlist)
1154 {
1155         struct lstr src, res;
1156         int rc;
1157         ENTRY;
1158
1159         src.ls_str = str;
1160         src.ls_len = len;
1161         CFS_INIT_LIST_HEAD(nidlist);
1162         while (src.ls_str) {
1163                 rc = gettok(&src, ' ', &res);
1164                 if (rc == 0) {
1165                         cfs_free_nidlist(nidlist);
1166                         RETURN(0);
1167                 }
1168                 rc = parse_nidrange(&res, nidlist);
1169                 if (rc == 0) {
1170                         cfs_free_nidlist(nidlist);
1171                         RETURN(0);
1172                 }
1173         }
1174         RETURN(1);
1175 }
1176
1177 /**
1178  * Matches address (\a addr) against address set encoded in \a list.
1179  *
1180  * \see libcfs_num_match(), libcfs_ip_match()
1181  *
1182  * \retval 1 if \a addr matches
1183  * \retval 0 otherwise
1184  */
1185 static int
1186 match_numaddr(__u32 addr, cfs_list_t *list, int shift, __u32 mask)
1187 {
1188         struct numaddr_range *numaddr;
1189         struct range_expr *expr;
1190         int ip, ok;
1191         ENTRY;
1192
1193         cfs_list_for_each_entry(numaddr, list, nar_link) {
1194                 ip = (addr >> shift) & mask;
1195                 shift -= 8;
1196                 ok = 0;
1197                 cfs_list_for_each_entry(expr, &numaddr->nar_range_exprs,
1198                                         re_link) {
1199                         if (ip >= expr->re_lo &&
1200                             ip <= expr->re_hi &&
1201                             ((ip - expr->re_lo) % expr->re_stride) == 0) {
1202                                 ok = 1;
1203                                 break;
1204                         }
1205                 }
1206                 if (!ok)
1207                         RETURN(0);
1208         }
1209         RETURN(1);
1210 }
1211
1212 /*
1213  * Nf_match_addr method for networks using numeric addresses
1214  *
1215  * \retval 1 on match
1216  * \retval 0 otherwise
1217  */
1218 static int
1219 libcfs_num_match(__u32 addr, cfs_list_t *numaddr)
1220 {
1221         return match_numaddr(addr, numaddr, 0, 0xffffffff);
1222 }
1223
1224 /*
1225  * Nf_match_addr method for networks using ip addresses
1226  *
1227  * \retval 1 on match
1228  * \retval 0 otherwise
1229  */
1230 static int
1231 libcfs_ip_match(__u32 addr, cfs_list_t *numaddr)
1232 {
1233         return match_numaddr(addr, numaddr, 24, 0xff);
1234 }
1235
1236 /**
1237  * Matches a nid (\a nid) against the compiled list of nidranges (\a nidlist).
1238  *
1239  * \see cfs_parse_nidlist()
1240  *
1241  * \retval 1 on match
1242  * \retval 0  otherwises
1243  */
1244 int cfs_match_nid(lnet_nid_t nid, cfs_list_t *nidlist)
1245 {
1246         struct nidrange *nr;
1247         struct addrrange *ar;
1248         ENTRY;
1249
1250         cfs_list_for_each_entry(nr, nidlist, nr_link) {
1251                 if (nr->nr_netstrfns->nf_type != LNET_NETTYP(LNET_NIDNET(nid)))
1252                         continue;
1253                 if (nr->nr_netnum != LNET_NETNUM(LNET_NIDNET(nid)))
1254                         continue;
1255                 if (nr->nr_all)
1256                         RETURN(1);
1257                 cfs_list_for_each_entry(ar, &nr->nr_addrranges, ar_link)
1258                         if (nr->nr_netstrfns->nf_match_addr(LNET_NIDADDR(nid),
1259                                                        &ar->ar_numaddr_ranges))
1260                                 RETURN(1);
1261         }
1262         RETURN(0);
1263 }
1264
1265 #ifdef __KERNEL__
1266
1267 EXPORT_SYMBOL(libcfs_isknown_lnd);
1268 EXPORT_SYMBOL(libcfs_lnd2modname);
1269 EXPORT_SYMBOL(libcfs_lnd2str);
1270 EXPORT_SYMBOL(libcfs_str2lnd);
1271 EXPORT_SYMBOL(libcfs_net2str);
1272 EXPORT_SYMBOL(libcfs_nid2str);
1273 EXPORT_SYMBOL(libcfs_str2net);
1274 EXPORT_SYMBOL(libcfs_str2nid);
1275 EXPORT_SYMBOL(libcfs_id2str);
1276 EXPORT_SYMBOL(libcfs_str2anynid);
1277 EXPORT_SYMBOL(cfs_iswhite);
1278 EXPORT_SYMBOL(cfs_free_nidlist);
1279 EXPORT_SYMBOL(cfs_parse_nidlist);
1280 EXPORT_SYMBOL(cfs_match_nid);
1281
1282 #endif