lib/addr.c

   1 /*
   2  * lib/addr.c           Abstract Address
   3  *
   4  *      This library is free software; you can redistribute it and/or
   5  *      modify it under the terms of the GNU Lesser General Public
   6  *      License as published by the Free Software Foundation version 2.1
   7  *      of the License.
   8  *
   9  * Copyright (c) 2003-2006 Thomas Graf <tgraf@suug.ch>
  10  */
  11
  12 /**
  13  * @ingroup utils
  14  * @defgroup addr Abstract Address
  15  *
  16  * @par 1) Transform character string to abstract address
  17  * @code
  18  * struct nl_addr *a = nl_addr_parse("::1", AF_UNSPEC);
  19  * printf("Address family: %s\n", nl_af2str(nl_addr_get_family(a)));
  20  * nl_addr_put(a);
  21  * a = nl_addr_parse("11:22:33:44:55:66", AF_UNSPEC);
  22  * printf("Address family: %s\n", nl_af2str(nl_addr_get_family(a)));
  23  * nl_addr_put(a);
  24  * @endcode
  25  * @{
  26  */
  27
  28 #include <netlink-local.h>
  29 #include <netlink/netlink.h>
  30 #include <netlink/utils.h>
  31 #include <netlink/addr.h>
  32 #include <linux/socket.h>
  33
  34 /* All this DECnet stuff is stolen from iproute2, thanks to whoever wrote
  35  * this, probably Alexey. */
  36 static inline uint16_t dn_ntohs(uint16_t addr)
  37 {
  38         union {
  39                 uint8_t byte[2];
  40                 uint16_t word;
  41         } u = {
  42                 .word = addr,
  43         };
  44
  45         return ((uint16_t) u.byte[0]) | (((uint16_t) u.byte[1]) << 8);
  46 }
  47
  48 static inline int do_digit(char *str, uint16_t *addr, uint16_t scale,
  49                            size_t *pos, size_t len, int *started)
  50 {
  51         uint16_t tmp = *addr / scale;
  52
  53         if (*pos == len)
  54                 return 1;
  55
  56         if (((tmp) > 0) || *started || (scale == 1)) {
  57                 *str = tmp + '0';
  58                 *started = 1;
  59                 (*pos)++;
  60                 *addr -= (tmp * scale);
  61         }
  62
  63         return 0;
  64 }
  65
  66 static const char *dnet_ntop(char *addrbuf, size_t addrlen, char *str,
  67                              size_t len)
  68 {
  69         uint16_t addr = dn_ntohs(*(uint16_t *)addrbuf);
  70         uint16_t area = addr >> 10;
  71         size_t pos = 0;
  72         int started = 0;
  73
  74         if (addrlen != 2)
  75                 return NULL;
  76
  77         addr &= 0x03ff;
  78
  79         if (len == 0)
  80                 return str;
  81
  82         if (do_digit(str + pos, &area, 10, &pos, len, &started))
  83                 return str;
  84
  85         if (do_digit(str + pos, &area, 1, &pos, len, &started))
  86                 return str;
  87
  88         if (pos == len)
  89                 return str;
  90
  91         *(str + pos) = '.';
  92         pos++;
  93         started = 0;
  94
  95         if (do_digit(str + pos, &addr, 1000, &pos, len, &started))
  96                 return str;
  97
  98         if (do_digit(str + pos, &addr, 100, &pos, len, &started))
  99                 return str;
 100
 101         if (do_digit(str + pos, &addr, 10, &pos, len, &started))
 102                 return str;
 103
 104         if (do_digit(str + pos, &addr, 1, &pos, len, &started))
 105                 return str;
 106
 107         if (pos == len)
 108                 return str;
 109
 110         *(str + pos) = 0;
 111
 112         return str;
 113 }
 114
 115 static int dnet_num(const char *src, uint16_t * dst)
 116 {
 117         int rv = 0;
 118         int tmp;
 119         *dst = 0;
 120
 121         while ((tmp = *src++) != 0) {
 122                 tmp -= '0';
 123                 if ((tmp < 0) || (tmp > 9))
 124                         return rv;
 125
 126                 rv++;
 127                 (*dst) *= 10;
 128                 (*dst) += tmp;
 129         }
 130
 131         return rv;
 132 }
 133
 134 static inline int dnet_pton(const char *src, char *addrbuf)
 135 {
 136         uint16_t area = 0;
 137         uint16_t node = 0;
 138         int pos;
 139
 140         pos = dnet_num(src, &area);
 141         if ((pos == 0) || (area > 63) ||
 142             ((*(src + pos) != '.') && (*(src + pos) != ',')))
 143                 return -EINVAL;
 144
 145         pos = dnet_num(src + pos + 1, &node);
 146         if ((pos == 0) || (node > 1023))
 147                 return -EINVAL;
 148
 149         *(uint16_t *)addrbuf = dn_ntohs((area << 10) | node);
 150
 151         return 1;
 152 }
 153
 154 /**
 155  * @name Creating Abstract Addresses
 156  * @{
 157  */
 158
 159 /**
 160  * Allocate new abstract address object.
 161  * @arg maxsize         Maximum size of the binary address.
 162  * @return Newly allocated address object or NULL
 163  */
 164 struct nl_addr *nl_addr_alloc(size_t maxsize)
 165 {
 166         struct nl_addr *addr;
 167
 168         addr = calloc(1, sizeof(*addr) + maxsize);
 169         if (!addr) {
 170                 nl_errno(ENOMEM);
 171                 return NULL;
 172         }
 173
 174         addr->a_refcnt = 1;
 175         addr->a_maxsize = maxsize;
 176
 177         return addr;
 178 }
 179
 180 /**
 181  * Allocate new abstract address object based on a binary address.
 182  * @arg family          Address family.
 183  * @arg buf             Buffer containing the binary address.
 184  * @arg size            Length of binary address buffer.
 185  * @return Newly allocated address handle or NULL
 186  */
 187 struct nl_addr *nl_addr_build(int family, void *buf, size_t size)
 188 {
 189         struct nl_addr *addr;
 190
 191         addr = nl_addr_alloc(size);
 192         if (!addr)
 193                 return NULL;
 194
 195         addr->a_family = family;
 196         addr->a_len = size;
 197         addr->a_prefixlen = size*8;
 198
 199         if (size)
 200                 memcpy(addr->a_addr, buf, size);
 201
 202         return addr;
 203 }
 204
 205 /**
 206  * Allocate abstract address object based on a character string
 207  * @arg addrstr         Address represented as character string.
 208  * @arg hint            Address family hint or AF_UNSPEC.
 209  *
 210  * Regognizes the following address formats:
 211  *@code
 212  *  Format                      Len                Family
 213  *  ----------------------------------------------------------------
 214  *  IPv6 address format         16                 AF_INET6
 215  *  ddd.ddd.ddd.ddd             4                  AF_INET
 216  *  HH:HH:HH:HH:HH:HH           6                  AF_LLC
 217  *  AA{.|,}NNNN                 2                  AF_DECnet
 218  *  HH:HH:HH:...                variable           AF_UNSPEC
 219  * @endcode
 220  *
 221  *  Special values:
 222  *    - none: All bits and length set to 0.
 223  *    - {default|all|any}: All bits set to 0, length based on hint or
 224  *                         AF_INET if no hint is given.
 225  *
 226  * The prefix length may be appened at the end prefixed with a
 227  * slash, e.g. 10.0.0.0/8.
 228  *
 229  * @return Newly allocated abstract address object or NULL.
 230  */
 231 struct nl_addr *nl_addr_parse(const char *addrstr, int hint)
 232 {
 233         int err, copy = 0, len = 0, family = AF_UNSPEC;
 234         char *str, *prefix, buf[32];
 235         struct nl_addr *addr = NULL; /* gcc ain't that smart */
 236
 237         str = strdup(addrstr);
 238         if (!str) {
 239                 err = nl_errno(ENOMEM);
 240                 goto errout;
 241         }
 242
 243         prefix = strchr(str, '/');
 244         if (prefix)
 245                 *prefix = '\0';
 246
 247         if (!strcasecmp(str, "none")) {
 248                 family = hint;
 249                 goto prefix;
 250         }
 251
 252         if (!strcasecmp(str, "default") ||
 253             !strcasecmp(str, "all") ||
 254             !strcasecmp(str, "any")) {
 255
 256                 switch (hint) {
 257                         case AF_INET:
 258                         case AF_UNSPEC:
 259                                 /* Kind of a hack, we assume that if there is
 260                                  * no hint given the user wants to have a IPv4
 261                                  * address given back. */
 262                                 family = AF_INET;
 263                                 len = 4;
 264                                 goto prefix;
 265
 266                         case AF_INET6:
 267                                 family = AF_INET6;
 268                                 len = 16;
 269                                 goto prefix;
 270
 271                         case AF_LLC:
 272                                 family = AF_LLC;
 273                                 len = 6;
 274                                 goto prefix;
 275
 276                         default:
 277                                 err = nl_error(EINVAL, "Unsuported address" \
 278                                     "family for default address");
 279                                 goto errout;
 280                 }
 281         }
 282
 283         copy = 1;
 284
 285         if (hint == AF_INET || hint == AF_UNSPEC) {
 286                 if (inet_pton(AF_INET, str, buf) > 0) {
 287                         family = AF_INET;
 288                         len = 4;
 289                         goto prefix;
 290                 }
 291                 if (hint == AF_INET) {
 292                         err = nl_error(EINVAL, "Invalid IPv4 address");
 293                         goto errout;
 294                 }
 295         }
 296
 297         if (hint == AF_INET6 || hint == AF_UNSPEC) {
 298                 if (inet_pton(AF_INET6, str, buf) > 0) {
 299                         family = AF_INET6;
 300                         len = 16;
 301                         goto prefix;
 302                 }
 303                 if (hint == AF_INET6) {
 304                         err = nl_error(EINVAL, "Invalid IPv6 address");
 305                         goto errout;
 306                 }
 307         }
 308
 309         if ((hint == AF_LLC || hint == AF_UNSPEC) && strchr(str, ':')) {
 310                 unsigned int a, b, c, d, e, f;
 311
 312                 if (sscanf(str, "%02x:%02x:%02x:%02x:%02x:%02x",
 313                     &a, &b, &c, &d, &e, &f) == 6) {
 314                         family = AF_LLC;
 315                         len = 6;
 316                         buf[0] = (unsigned char) a;
 317                         buf[1] = (unsigned char) b;
 318                         buf[2] = (unsigned char) c;
 319                         buf[3] = (unsigned char) d;
 320                         buf[4] = (unsigned char) e;
 321                         buf[5] = (unsigned char) f;
 322                         goto prefix;
 323                 }
 324
 325                 if (hint == AF_LLC) {
 326                         err = nl_error(EINVAL, "Invalid link layer address");
 327                         goto errout;
 328                 }
 329         }
 330
 331         if ((hint == AF_DECnet || hint == AF_UNSPEC) &&
 332             (strchr(str, '.') || strchr(str, ','))) {
 333                 if (dnet_pton(str, buf) > 0) {
 334                         family = AF_DECnet;
 335                         len = 2;
 336                         goto prefix;
 337                 }
 338                 if (hint == AF_DECnet) {
 339                         err = nl_error(EINVAL, "Invalid DECnet address");
 340                         goto errout;
 341                 }
 342         }
 343
 344         if (hint == AF_UNSPEC && strchr(str, ':')) {
 345                 int i = 0;
 346                 char *s = str, *p;
 347                 for (;;) {
 348                         long l = strtol(s, &p, 16);
 349
 350                         if (s == p || l > 0xff || i >= sizeof(buf)) {
 351                                 err = -EINVAL;
 352                                 goto errout;
 353                         }
 354
 355                         buf[i++] = (unsigned char) l;
 356                         if (*p == '\0')
 357                                 break;
 358                         s = ++p;
 359                 }
 360
 361                 len = i;
 362                 family = AF_UNSPEC;
 363                 goto prefix;
 364         }
 365
 366         err = nl_error(EINVAL, "Invalid address");
 367         goto errout;
 368
 369 prefix:
 370         addr = nl_addr_alloc(len);
 371         if (!addr) {
 372                 err = nl_errno(ENOMEM);
 373                 goto errout;
 374         }
 375
 376         nl_addr_set_family(addr, family);
 377
 378         if (copy)
 379                 nl_addr_set_binary_addr(addr, buf, len);
 380
 381         if (prefix) {
 382                 char *p;
 383                 long pl = strtol(++prefix, &p, 0);
 384                 if (p == prefix) {
 385                         nl_addr_destroy(addr);
 386                         err = -EINVAL;
 387                         goto errout;
 388                 }
 389                 nl_addr_set_prefixlen(addr, pl);
 390         } else
 391                 nl_addr_set_prefixlen(addr, len * 8);
 392
 393         err = 0;
 394 errout:
 395         free(str);
 396
 397         return err ? NULL : addr;
 398 }
 399
 400 /**
 401  * Clone existing abstract address object.
 402  * @arg addr            Abstract address object.
 403  * @return Newly allocated abstract address object being a duplicate of the
 404  *         specified address object or NULL if a failure occured.
 405  */
 406 struct nl_addr *nl_addr_clone(struct nl_addr *addr)
 407 {
 408         struct nl_addr *new;
 409
 410         new = nl_addr_build(addr->a_family, addr->a_addr, addr->a_len);
 411         if (new)
 412                 new->a_prefixlen = addr->a_prefixlen;
 413
 414         return new;
 415 }
 416
 417 /** @} */
 418
 419 /**
 420  * @name Destroying Abstract Addresses
 421  * @{
 422  */
 423
 424 /**
 425  * Destroy abstract address object.
 426  * @arg addr            Abstract address object.
 427  */
 428 void nl_addr_destroy(struct nl_addr *addr)
 429 {
 430         if (!addr)
 431                 return;
 432
 433         if (addr->a_refcnt != 1)
 434                 BUG();
 435
 436         free(addr);
 437 }
 438
 439 /** @} */
 440
 441 /**
 442  * @name Managing Usage References
 443  * @{
 444  */
 445
 446 /**
 447  * Request undestroyable reference of abstract address object.
 448  * @arg addr            Abstract address object.
 449  * @return Abstract address object of which the reference was given.
 450  */
 451 struct nl_addr *nl_addr_get(struct nl_addr *addr)
 452 {
 453         addr->a_refcnt++;
 454
 455         return addr;
 456 }
 457
 458 /**
 459  * Give back reference of abstract address object.
 460  * @arg addr            Abstract address object.
 461  *
 462  * Decrements the reference counter and destroys the object if the
 463  * last reference was given back.
 464  */
 465 void nl_addr_put(struct nl_addr *addr)
 466 {
 467         if (!addr)
 468                 return;
 469
 470         if (addr->a_refcnt == 1)
 471                 nl_addr_destroy(addr);
 472         else
 473                 addr->a_refcnt--;
 474 }
 475
 476 /**
 477  * Check whether an abstract address object is shared.
 478  * @arg addr            Abstract address object.
 479  * @return Non-zero if the abstract address object is shared, otherwise 0.
 480  */
 481 int nl_addr_shared(struct nl_addr *addr)
 482 {
 483         return addr->a_refcnt > 1;
 484 }
 485
 486 /** @} */
 487
 488 /**
 489  * @name Miscellaneous
 490  * @{
 491  */
 492
 493 /**
 494  * Compares two abstract address objects.
 495  * @arg a               A abstract address object.
 496  * @arg b               Another abstract address object.
 497  *
 498  * @return Integer less than, equal to or greather than zero if \c is found,
 499  *         respectively to be less than, to, or be greater than \c b.
 500  */
 501 int nl_addr_cmp(struct nl_addr *a, struct nl_addr *b)
 502 {
 503         int d = a->a_family - b->a_family;
 504
 505         if (d == 0) {
 506                 d = a->a_len - b->a_len;
 507
 508                 if (a->a_len && d == 0)
 509                         return memcmp(a->a_addr, b->a_addr, a->a_len);
 510         }
 511
 512         return d;
 513 }
 514
 515 /**
 516  * Check if an address matches a certain family.
 517  * @arg addr            Address represented as character string.
 518  * @arg family          Desired address family.
 519  *
 520  * @return 1 if the address is of the desired address family,
 521  *         otherwise 0 is returned.
 522  */
 523 int nl_addr_valid(char *addr, int family)
 524 {
 525         int ret;
 526         char buf[32];
 527
 528         switch (family) {
 529         case AF_INET:
 530         case AF_INET6:
 531                 ret = inet_pton(family, addr, buf);
 532                 if (ret <= 0)
 533                         return 0;
 534                 break;
 535
 536         case AF_DECnet:
 537                 ret = dnet_pton(addr, buf);
 538                 if (ret <= 0)
 539                         return 0;
 540                 break;
 541
 542         case AF_LLC:
 543                 if (sscanf(addr, "%*02x:%*02x:%*02x:%*02x:%*02x:%*02x") != 6)
 544                         return 0;
 545                 break;
 546         }
 547
 548         return 1;
 549 }
 550
 551 /**
 552  * Guess address family of an abstract address object based on address size.
 553  * @arg addr            Abstract address object.
 554  * @return Address family or AF_UNSPEC if guessing wasn't successful.
 555  */
 556 int nl_addr_guess_family(struct nl_addr *addr)
 557 {
 558         switch (addr->a_len) {
 559                 case 4:
 560                         return AF_INET;
 561                 case 6:
 562                         return AF_LLC;
 563                 case 16:
 564                         return AF_INET6;
 565                 default:
 566                         return AF_UNSPEC;
 567         }
 568 }
 569
 570 /**
 571  * Fill out sockaddr structure with values from abstract address object.
 572  * @arg addr            Abstract address object.
 573  * @arg sa              Destination sockaddr structure buffer.
 574  * @arg salen           Length of sockaddr structure buffer.
 575  *
 576  * Fills out the specified sockaddr structure with the data found in the
 577  * specified abstract address. The salen argument needs to be set to the
 578  * size of sa but will be modified to the actual size used during before
 579  * the function exits.
 580  *
 581  * @return 0 on success or a negative error code
 582  */
 583 int nl_addr_fill_sockaddr(struct nl_addr *addr, struct sockaddr *sa,
 584                           socklen_t *salen)
 585 {
 586         switch (addr->a_family) {
 587         case AF_INET: {
 588                 struct sockaddr_in *sai = (struct sockaddr_in *) sa;
 589
 590                 if (*salen < sizeof(*sai))
 591                         return -EINVAL;
 592
 593                 sai->sin_family = addr->a_family;
 594                 memcpy(&sai->sin_addr, addr->a_addr, 4);
 595                 *salen = sizeof(*sai);
 596         }
 597                 break;
 598
 599         case AF_INET6: {
 600                 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
 601
 602                 if (*salen < sizeof(*sa6))
 603                         return -EINVAL;
 604
 605                 sa6->sin6_family = addr->a_family;
 606                 memcpy(&sa6->sin6_addr, addr->a_addr, 16);
 607                 *salen = sizeof(*sa6);
 608         }
 609                 break;
 610
 611         default:
 612                 return -EINVAL;
 613         }
 614
 615         return 0;
 616 }
 617
 618
 619 /** @} */
 620
 621 /**
 622  * @name Getting Information About Addresses
 623  * @{
 624  */
 625
 626 /**
 627  * Call getaddrinfo() for an abstract address object.
 628  * @arg addr            Abstract address object.
 629  *
 630  * Calls getaddrinfo() for the specified abstract address in AI_NUMERICHOST
 631  * mode.
 632  *
 633  * @note The caller is responsible for freeing the linked list using the
 634  *       interface provided by getaddrinfo(3).
 635  *
 636  * @return A linked list of addrinfo handles or  NULL with an error message
 637  *         associated.
 638  */
 639 struct addrinfo *nl_addr_info(struct nl_addr *addr)
 640 {
 641         int err;
 642         struct addrinfo *res;
 643         char buf[INET6_ADDRSTRLEN+5];
 644         struct addrinfo hint = {
 645                 .ai_flags = AI_NUMERICHOST,
 646                 .ai_family = addr->a_family,
 647         };
 648
 649         nl_addr2str(addr, buf, sizeof(buf));
 650
 651         err = getaddrinfo(buf, NULL, &hint, &res);
 652         if (err != 0) {
 653                 nl_error(err, gai_strerror(err));
 654                 return NULL;
 655         }
 656
 657         return res;
 658 }
 659
 660 /**
 661  * Resolve abstract address object to a name using getnameinfo().
 662  * @arg addr            Abstract address object.
 663  * @arg host            Destination buffer for host name.
 664  * @arg hostlen         Length of destination buffer.
 665  *
 666  * Resolves the abstract address to a name and writes the looked up result
 667  * into the host buffer. getnameinfo() is used to perform the lookup and
 668  * is put into NI_NAMEREQD mode so the function will fail if the lookup
 669  * couldn't be performed.
 670  *
 671  * @return 0 on success or a negative error code.
 672  */
 673 int nl_addr_resolve(struct nl_addr *addr, char *host, size_t hostlen)
 674 {
 675         int err;
 676         struct sockaddr_in6 buf;
 677         socklen_t salen = sizeof(buf);
 678
 679         err = nl_addr_fill_sockaddr(addr, (struct sockaddr *) &buf, &salen);
 680         if (err < 0)
 681                 return err;
 682
 683         return getnameinfo((struct sockaddr *) &buf, salen,
 684                            host, hostlen, NULL, 0, NI_NAMEREQD);
 685 }
 686
 687 /** @} */
 688
 689 /**
 690  * @name Attribute Access
 691  * @{
 692  */
 693
 694 /**
 695  * Set address family of abstract address object.
 696  * @arg addr            Abstract address object.
 697  * @arg family          New address family.
 698  */
 699 void nl_addr_set_family(struct nl_addr *addr, int family)
 700 {
 701         addr->a_family = family;
 702 }
 703
 704 /**
 705  * Get address family of abstract address object.
 706  * @arg addr            Abstract address object.
 707  */
 708 int nl_addr_get_family(struct nl_addr *addr)
 709 {
 710         return addr->a_family;
 711 }
 712
 713 /**
 714  * Set binary address of abstract address object.
 715  * @arg addr            Abstract address object.
 716  * @arg buf             Buffer containing binary address.
 717  * @arg len             Length of buffer containing binary address.
 718  */
 719 int nl_addr_set_binary_addr(struct nl_addr *addr, void *buf, size_t len)
 720 {
 721         if (len > addr->a_maxsize)
 722                 return -ERANGE;
 723
 724         addr->a_len = len;
 725         memcpy(addr->a_addr, buf, len);
 726
 727         return 0;
 728 }
 729
 730 /**
 731  * Get binary address of abstract address object.
 732  * @arg addr            Abstract address object.
 733  */
 734 void *nl_addr_get_binary_addr(struct nl_addr *addr)
 735 {
 736         return addr->a_addr;
 737 }
 738
 739 /**
 740  * Get length of binary address of abstract address object.
 741  * @arg addr            Abstract address object.
 742  */
 743 unsigned int nl_addr_get_len(struct nl_addr *addr)
 744 {
 745         return addr->a_len;
 746 }
 747
 748 /**
 749  * Set prefix length of abstract address object.
 750  * @arg addr            Abstract address object.
 751  * @arg prefixlen       New prefix length.
 752  */
 753 void nl_addr_set_prefixlen(struct nl_addr *addr, int prefixlen)
 754 {
 755         addr->a_prefixlen = prefixlen;
 756 }
 757
 758 /**
 759  * Get prefix length of abstract address object.
 760  * @arg addr            Abstract address object.
 761  */
 762 unsigned int nl_addr_get_prefixlen(struct nl_addr *addr)
 763 {
 764         return addr->a_prefixlen;
 765 }
 766
 767 /** @} */
 768
 769 /**
 770  * @name Translations to Strings
 771  * @{
 772  */
 773
 774 /**
 775  * Convert abstract address object to character string.
 776  * @arg addr            Abstract address object.
 777  * @arg buf             Destination buffer.
 778  * @arg size            Size of destination buffer.
 779  *
 780  * Converts an abstract address to a character string and stores
 781  * the result in the specified destination buffer.
 782  *
 783  * @return Address represented in ASCII stored in destination buffer.
 784  */
 785 char *nl_addr2str(struct nl_addr *addr, char *buf, size_t size)
 786 {
 787         int i;
 788         char tmp[16];
 789
 790         if (!addr->a_len) {
 791                 snprintf(buf, size, "none");
 792                 goto prefix;
 793         }
 794
 795         switch (addr->a_family) {
 796                 case AF_INET:
 797                         inet_ntop(AF_INET, addr->a_addr, buf, size);
 798                         break;
 799
 800                 case AF_INET6:
 801                         inet_ntop(AF_INET6, addr->a_addr, buf, size);
 802                         break;
 803
 804                 case AF_DECnet:
 805                         dnet_ntop(addr->a_addr, addr->a_len, buf, size);
 806                         break;
 807
 808                 case AF_LLC:
 809                 default:
 810                         snprintf(buf, size, "%02x", addr->a_addr[0]);
 811                         for (i = 1; i < addr->a_len; i++) {
 812                                 snprintf(tmp, sizeof(tmp), ":%02x",
 813                                          addr->a_addr[i]);
 814                                 strncat(buf, tmp, size - strlen(buf) - 1);
 815                         }
 816                         break;
 817         }
 818
 819 prefix:
 820         if (addr->a_prefixlen != (8 * addr->a_len)) {
 821                 snprintf(tmp, sizeof(tmp), "/%u", addr->a_prefixlen);
 822                 strncat(buf, tmp, size - strlen(buf) - 1);
 823         }
 824
 825         return buf;
 826 }
 827
 828 /** @} */
 829
 830 /**
 831  * @name Address Family Transformations
 832  * @{
 833  */
 834
 835 static struct trans_tbl afs[] = {
 836         __ADD(AF_UNSPEC,unspec)
 837         __ADD(AF_UNIX,unix)
 838         __ADD(AF_LOCAL,local)
 839         __ADD(AF_INET,inet)
 840         __ADD(AF_AX25,ax25)
 841         __ADD(AF_IPX,ipx)
 842         __ADD(AF_APPLETALK,appletalk)
 843         __ADD(AF_NETROM,netrom)
 844         __ADD(AF_BRIDGE,bridge)
 845         __ADD(AF_ATMPVC,atmpvc)
 846         __ADD(AF_X25,x25)
 847         __ADD(AF_INET6,inet6)
 848         __ADD(AF_ROSE,rose)
 849         __ADD(AF_DECnet,decnet)
 850         __ADD(AF_NETBEUI,netbeui)
 851         __ADD(AF_SECURITY,security)
 852         __ADD(AF_KEY,key)
 853         __ADD(AF_NETLINK,netlink)
 854         __ADD(AF_ROUTE,route)
 855         __ADD(AF_PACKET,packet)
 856         __ADD(AF_ASH,ash)
 857         __ADD(AF_ECONET,econet)
 858         __ADD(AF_ATMSVC,atmsvc)
 859         __ADD(AF_SNA,sna)
 860         __ADD(AF_IRDA,irda)
 861         __ADD(AF_PPPOX,pppox)
 862         __ADD(AF_WANPIPE,wanpipe)
 863         __ADD(AF_LLC,llc)
 864         __ADD(AF_BLUETOOTH,bluetooth)
 865 };
 866
 867
 868 /**
 869  * Convert address family to character string.
 870  * @arg family          Address family.
 871  * @arg buf             Destination buffer.
 872  * @arg size            Size of destination buffer.
 873  *
 874  * Converts an address family to a character string and stores it in the
 875  * provided buffer.
 876  *
 877  * @return The destination buffer or the type encoded in hexidecimal form
 878  *         if no match was found.
 879  */
 880 char *nl_af2str(char family, char *buf, size_t size)
 881 {
 882         return __type2str(family, buf, size, afs, ARRAY_SIZE(afs));
 883 }
 884
 885 /**
 886  * Convert character string to address family.
 887  * @arg name            Name of address family.
 888  *
 889  * Converts the provided character string specifying an address family
 890  * to the corresponding numeric value.
 891  *
 892  * @return Address family as number or \c AF_UNSPEC.
 893  */
 894 char nl_str2af(const char *name)
 895 {
 896         char fam = __str2type(name, afs, ARRAY_SIZE(afs));
 897         return fam >= 0 ? fam : AF_UNSPEC;
 898 }
 899
 900 /** @} */
 901
 902 /** @} */