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 struct nl_addr *nl_addr_get(struct nl_addr *addr)
 447 {
 448         addr->a_refcnt++;
 449
 450         return addr;
 451 }
 452
 453 void nl_addr_put(struct nl_addr *addr)
 454 {
 455         if (!addr)
 456                 return;
 457
 458         if (addr->a_refcnt == 1)
 459                 nl_addr_destroy(addr);
 460         else
 461                 addr->a_refcnt--;
 462 }
 463
 464 /**
 465  * Check whether an abstract address object is shared.
 466  * @arg addr            Abstract address object.
 467  * @return Non-zero if the abstract address object is shared, otherwise 0.
 468  */
 469 int nl_addr_shared(struct nl_addr *addr)
 470 {
 471         return addr->a_refcnt > 1;
 472 }
 473
 474 /** @} */
 475
 476 /**
 477  * @name Miscellaneous
 478  * @{
 479  */
 480
 481 /**
 482  * Compares two abstract address objects.
 483  * @arg a               A abstract address object.
 484  * @arg b               Another abstract address object.
 485  *
 486  * @return Integer less than, equal to or greather than zero if \c is found,
 487  *         respectively to be less than, to, or be greater than \c b.
 488  */
 489 int nl_addr_cmp(struct nl_addr *a, struct nl_addr *b)
 490 {
 491         int d = a->a_family - b->a_family;
 492
 493         if (d == 0) {
 494                 d = a->a_len - b->a_len;
 495
 496                 if (a->a_len && d == 0)
 497                         return memcmp(a->a_addr, b->a_addr, a->a_len);
 498         }
 499
 500         return d;
 501 }
 502
 503 /**
 504  * Compares the prefix of two abstract address objects.
 505  * @arg a               A abstract address object.
 506  * @arg b               Another abstract address object.
 507  *
 508  * @return Integer less than, equal to or greather than zero if \c is found,
 509  *         respectively to be less than, to, or be greater than \c b.
 510  */
 511 int nl_addr_cmp_prefix(struct nl_addr *a, struct nl_addr *b)
 512 {
 513         int d = a->a_family - b->a_family;
 514
 515         if (d == 0) {
 516                 int len = min(a->a_prefixlen, b->a_prefixlen);
 517                 int bytes = len / 8;
 518
 519                 d = memcmp(a->a_addr, b->a_addr, bytes);
 520                 if (d == 0) {
 521                         int mask = (1UL << (len % 8)) - 1UL;
 522
 523                         d = (a->a_addr[bytes] & mask) -
 524                             (b->a_addr[bytes] & mask);
 525                 }
 526         }
 527
 528         return d;
 529 }
 530
 531 /**
 532  * Returns true if the address consists of all zeros
 533  * @arg addr            Address to look at.
 534  */
 535 int nl_addr_iszero(struct nl_addr *addr)
 536 {
 537         int i;
 538
 539         for (i = 0; i < addr->a_len; i++)
 540                 if (addr->a_addr[i])
 541                         return 0;
 542
 543         return 1;
 544 }
 545
 546 /**
 547  * Check if an address matches a certain family.
 548  * @arg addr            Address represented as character string.
 549  * @arg family          Desired address family.
 550  *
 551  * @return 1 if the address is of the desired address family,
 552  *         otherwise 0 is returned.
 553  */
 554 int nl_addr_valid(char *addr, int family)
 555 {
 556         int ret;
 557         char buf[32];
 558
 559         switch (family) {
 560         case AF_INET:
 561         case AF_INET6:
 562                 ret = inet_pton(family, addr, buf);
 563                 if (ret <= 0)
 564                         return 0;
 565                 break;
 566
 567         case AF_DECnet:
 568                 ret = dnet_pton(addr, buf);
 569                 if (ret <= 0)
 570                         return 0;
 571                 break;
 572
 573         case AF_LLC:
 574                 if (sscanf(addr, "%*02x:%*02x:%*02x:%*02x:%*02x:%*02x") != 6)
 575                         return 0;
 576                 break;
 577         }
 578
 579         return 1;
 580 }
 581
 582 /**
 583  * Guess address family of an abstract address object based on address size.
 584  * @arg addr            Abstract address object.
 585  * @return Address family or AF_UNSPEC if guessing wasn't successful.
 586  */
 587 int nl_addr_guess_family(struct nl_addr *addr)
 588 {
 589         switch (addr->a_len) {
 590                 case 4:
 591                         return AF_INET;
 592                 case 6:
 593                         return AF_LLC;
 594                 case 16:
 595                         return AF_INET6;
 596                 default:
 597                         return AF_UNSPEC;
 598         }
 599 }
 600
 601 /**
 602  * Fill out sockaddr structure with values from abstract address object.
 603  * @arg addr            Abstract address object.
 604  * @arg sa              Destination sockaddr structure buffer.
 605  * @arg salen           Length of sockaddr structure buffer.
 606  *
 607  * Fills out the specified sockaddr structure with the data found in the
 608  * specified abstract address. The salen argument needs to be set to the
 609  * size of sa but will be modified to the actual size used during before
 610  * the function exits.
 611  *
 612  * @return 0 on success or a negative error code
 613  */
 614 int nl_addr_fill_sockaddr(struct nl_addr *addr, struct sockaddr *sa,
 615                           socklen_t *salen)
 616 {
 617         switch (addr->a_family) {
 618         case AF_INET: {
 619                 struct sockaddr_in *sai = (struct sockaddr_in *) sa;
 620
 621                 if (*salen < sizeof(*sai))
 622                         return -EINVAL;
 623
 624                 sai->sin_family = addr->a_family;
 625                 memcpy(&sai->sin_addr, addr->a_addr, 4);
 626                 *salen = sizeof(*sai);
 627         }
 628                 break;
 629
 630         case AF_INET6: {
 631                 struct sockaddr_in6 *sa6 = (struct sockaddr_in6 *) sa;
 632
 633                 if (*salen < sizeof(*sa6))
 634                         return -EINVAL;
 635
 636                 sa6->sin6_family = addr->a_family;
 637                 memcpy(&sa6->sin6_addr, addr->a_addr, 16);
 638                 *salen = sizeof(*sa6);
 639         }
 640                 break;
 641
 642         default:
 643                 return -EINVAL;
 644         }
 645
 646         return 0;
 647 }
 648
 649
 650 /** @} */
 651
 652 /**
 653  * @name Getting Information About Addresses
 654  * @{
 655  */
 656
 657 /**
 658  * Call getaddrinfo() for an abstract address object.
 659  * @arg addr            Abstract address object.
 660  *
 661  * Calls getaddrinfo() for the specified abstract address in AI_NUMERICHOST
 662  * mode.
 663  *
 664  * @note The caller is responsible for freeing the linked list using the
 665  *       interface provided by getaddrinfo(3).
 666  *
 667  * @return A linked list of addrinfo handles or  NULL with an error message
 668  *         associated.
 669  */
 670 struct addrinfo *nl_addr_info(struct nl_addr *addr)
 671 {
 672         int err;
 673         struct addrinfo *res;
 674         char buf[INET6_ADDRSTRLEN+5];
 675         struct addrinfo hint = {
 676                 .ai_flags = AI_NUMERICHOST,
 677                 .ai_family = addr->a_family,
 678         };
 679
 680         nl_addr2str(addr, buf, sizeof(buf));
 681
 682         err = getaddrinfo(buf, NULL, &hint, &res);
 683         if (err != 0) {
 684                 nl_error(err, gai_strerror(err));
 685                 return NULL;
 686         }
 687
 688         return res;
 689 }
 690
 691 /**
 692  * Resolve abstract address object to a name using getnameinfo().
 693  * @arg addr            Abstract address object.
 694  * @arg host            Destination buffer for host name.
 695  * @arg hostlen         Length of destination buffer.
 696  *
 697  * Resolves the abstract address to a name and writes the looked up result
 698  * into the host buffer. getnameinfo() is used to perform the lookup and
 699  * is put into NI_NAMEREQD mode so the function will fail if the lookup
 700  * couldn't be performed.
 701  *
 702  * @return 0 on success or a negative error code.
 703  */
 704 int nl_addr_resolve(struct nl_addr *addr, char *host, size_t hostlen)
 705 {
 706         int err;
 707         struct sockaddr_in6 buf;
 708         socklen_t salen = sizeof(buf);
 709
 710         err = nl_addr_fill_sockaddr(addr, (struct sockaddr *) &buf, &salen);
 711         if (err < 0)
 712                 return err;
 713
 714         return getnameinfo((struct sockaddr *) &buf, salen,
 715                            host, hostlen, NULL, 0, NI_NAMEREQD);
 716 }
 717
 718 /** @} */
 719
 720 /**
 721  * @name Attributes
 722  * @{
 723  */
 724
 725 void nl_addr_set_family(struct nl_addr *addr, int family)
 726 {
 727         addr->a_family = family;
 728 }
 729
 730 int nl_addr_get_family(struct nl_addr *addr)
 731 {
 732         return addr->a_family;
 733 }
 734
 735 /**
 736  * Set binary address of abstract address object.
 737  * @arg addr            Abstract address object.
 738  * @arg buf             Buffer containing binary address.
 739  * @arg len             Length of buffer containing binary address.
 740  */
 741 int nl_addr_set_binary_addr(struct nl_addr *addr, void *buf, size_t len)
 742 {
 743         if (len > addr->a_maxsize)
 744                 return -ERANGE;
 745
 746         addr->a_len = len;
 747         memcpy(addr->a_addr, buf, len);
 748
 749         return 0;
 750 }
 751
 752 /**
 753  * Get binary address of abstract address object.
 754  * @arg addr            Abstract address object.
 755  */
 756 void *nl_addr_get_binary_addr(struct nl_addr *addr)
 757 {
 758         return addr->a_addr;
 759 }
 760
 761 /**
 762  * Get length of binary address of abstract address object.
 763  * @arg addr            Abstract address object.
 764  */
 765 unsigned int nl_addr_get_len(struct nl_addr *addr)
 766 {
 767         return addr->a_len;
 768 }
 769
 770 void nl_addr_set_prefixlen(struct nl_addr *addr, int prefixlen)
 771 {
 772         addr->a_prefixlen = prefixlen;
 773 }
 774
 775 /**
 776  * Get prefix length of abstract address object.
 777  * @arg addr            Abstract address object.
 778  */
 779 unsigned int nl_addr_get_prefixlen(struct nl_addr *addr)
 780 {
 781         return addr->a_prefixlen;
 782 }
 783
 784 /** @} */
 785
 786 /**
 787  * @name Translations to Strings
 788  * @{
 789  */
 790
 791 /**
 792  * Convert abstract address object to character string.
 793  * @arg addr            Abstract address object.
 794  * @arg buf             Destination buffer.
 795  * @arg size            Size of destination buffer.
 796  *
 797  * Converts an abstract address to a character string and stores
 798  * the result in the specified destination buffer.
 799  *
 800  * @return Address represented in ASCII stored in destination buffer.
 801  */
 802 char *nl_addr2str(struct nl_addr *addr, char *buf, size_t size)
 803 {
 804         int i;
 805         char tmp[16];
 806
 807         if (!addr->a_len) {
 808                 snprintf(buf, size, "none");
 809                 goto prefix;
 810         }
 811
 812         switch (addr->a_family) {
 813                 case AF_INET:
 814                         inet_ntop(AF_INET, addr->a_addr, buf, size);
 815                         break;
 816
 817                 case AF_INET6:
 818                         inet_ntop(AF_INET6, addr->a_addr, buf, size);
 819                         break;
 820
 821                 case AF_DECnet:
 822                         dnet_ntop(addr->a_addr, addr->a_len, buf, size);
 823                         break;
 824
 825                 case AF_LLC:
 826                 default:
 827                         snprintf(buf, size, "%02x",
 828                                  (unsigned char) addr->a_addr[0]);
 829                         for (i = 1; i < addr->a_len; i++) {
 830                                 snprintf(tmp, sizeof(tmp), ":%02x",
 831                                          (unsigned char) addr->a_addr[i]);
 832                                 strncat(buf, tmp, size - strlen(buf) - 1);
 833                         }
 834                         break;
 835         }
 836
 837 prefix:
 838         if (addr->a_prefixlen != (8 * addr->a_len)) {
 839                 snprintf(tmp, sizeof(tmp), "/%u", addr->a_prefixlen);
 840                 strncat(buf, tmp, size - strlen(buf) - 1);
 841         }
 842
 843         return buf;
 844 }
 845
 846 /** @} */
 847
 848 /**
 849  * @name Address Family Transformations
 850  * @{
 851  */
 852
 853 static struct trans_tbl afs[] = {
 854         __ADD(AF_UNSPEC,unspec)
 855         __ADD(AF_UNIX,unix)
 856         __ADD(AF_LOCAL,local)
 857         __ADD(AF_INET,inet)
 858         __ADD(AF_AX25,ax25)
 859         __ADD(AF_IPX,ipx)
 860         __ADD(AF_APPLETALK,appletalk)
 861         __ADD(AF_NETROM,netrom)
 862         __ADD(AF_BRIDGE,bridge)
 863         __ADD(AF_ATMPVC,atmpvc)
 864         __ADD(AF_X25,x25)
 865         __ADD(AF_INET6,inet6)
 866         __ADD(AF_ROSE,rose)
 867         __ADD(AF_DECnet,decnet)
 868         __ADD(AF_NETBEUI,netbeui)
 869         __ADD(AF_SECURITY,security)
 870         __ADD(AF_KEY,key)
 871         __ADD(AF_NETLINK,netlink)
 872         __ADD(AF_ROUTE,route)
 873         __ADD(AF_PACKET,packet)
 874         __ADD(AF_ASH,ash)
 875         __ADD(AF_ECONET,econet)
 876         __ADD(AF_ATMSVC,atmsvc)
 877         __ADD(AF_SNA,sna)
 878         __ADD(AF_IRDA,irda)
 879         __ADD(AF_PPPOX,pppox)
 880         __ADD(AF_WANPIPE,wanpipe)
 881         __ADD(AF_LLC,llc)
 882         __ADD(AF_BLUETOOTH,bluetooth)
 883 };
 884
 885 char *nl_af2str(int family, char *buf, size_t size)
 886 {
 887         return __type2str(family, buf, size, afs, ARRAY_SIZE(afs));
 888 }
 889
 890 int nl_str2af(const char *name)
 891 {
 892         int fam = __str2type(name, afs, ARRAY_SIZE(afs));
 893         return fam >= 0 ? fam : AF_UNSPEC;
 894 }
 895
 896 /** @} */
 897
 898 /** @} */