lib/sockunion.c

   1 /* Socket union related function.
   2  * Copyright (c) 1997, 98 Kunihiro Ishiguro
   3  *
   4  * This file is part of GNU Zebra.
   5  *
   6  * GNU Zebra is free software; you can redistribute it and/or modify it
   7  * under the terms of the GNU General Public License as published by the
   8  * Free Software Foundation; either version 2, or (at your option) any
   9  * later version.
  10  *
  11  * GNU Zebra is distributed in the hope that it will be useful, but
  12  * WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU General Public License
  17  * along with GNU Zebra; see the file COPYING.  If not, write to the Free
  18  * Software Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
  19  * 02111-1307, USA.
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "prefix.h"
  25 #include "vty.h"
  26 #include "sockunion.h"
  27 #include "memory.h"
  28 #include "str.h"
  29 #include "log.h"
  30
  31 #ifndef HAVE_INET_ATON
  32 int
  33 inet_aton (const char *cp, struct in_addr *inaddr)
  34 {
  35   int dots = 0;
  36   register u_long addr = 0;
  37   register u_long val = 0, base = 10;
  38
  39   do
  40     {
  41       register char c = *cp;
  42
  43       switch (c)
  44         {
  45         case '0': case '1': case '2': case '3': case '4': case '5':
  46         case '6': case '7': case '8': case '9':
  47           val = (val * base) + (c - '0');
  48           break;
  49         case '.':
  50           if (++dots > 3)
  51             return 0;
  52         case '\0':
  53           if (val > 255)
  54             return 0;
  55           addr = addr << 8 | val;
  56           val = 0;
  57           break;
  58         default:
  59           return 0;
  60         }
  61     } while (*cp++) ;
  62
  63   if (dots < 3)
  64     addr <<= 8 * (3 - dots);
  65   if (inaddr)
  66     inaddr->s_addr = htonl (addr);
  67   return 1;
  68 }
  69 #endif /* ! HAVE_INET_ATON */
  70
  71
  72 #ifndef HAVE_INET_PTON
  73 int
  74 inet_pton (int family, const char *strptr, void *addrptr)
  75 {
  76   if (family == AF_INET)
  77     {
  78       struct in_addr in_val;
  79
  80       if (inet_aton (strptr, &in_val))
  81         {
  82           memcpy (addrptr, &in_val, sizeof (struct in_addr));
  83           return 1;
  84         }
  85       return 0;
  86     }
  87   errno = EAFNOSUPPORT;
  88   return -1;
  89 }
  90 #endif /* ! HAVE_INET_PTON */
  91
  92 #ifndef HAVE_INET_NTOP
  93 const char *
  94 inet_ntop (int family, const void *addrptr, char *strptr, size_t len)
  95 {
  96   unsigned char *p = (unsigned char *) addrptr;
  97
  98   if (family == AF_INET)
  99     {
 100       char temp[INET_ADDRSTRLEN];
 101
 102       snprintf(temp, sizeof(temp), "%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
 103
 104       if (strlen(temp) >= len)
 105         {
 106           errno = ENOSPC;
 107           return NULL;
 108         }
 109       strcpy(strptr, temp);
 110       return strptr;
 111     }
 112
 113   errno = EAFNOSUPPORT;
 114   return NULL;
 115 }
 116 #endif /* ! HAVE_INET_NTOP */
 117
 118 const char *
 119 inet_sutop (union sockunion *su, char *str)
 120 {
 121   switch (su->sa.sa_family)
 122     {
 123     case AF_INET:
 124       inet_ntop (AF_INET, &su->sin.sin_addr, str, INET_ADDRSTRLEN);
 125       break;
 126 #ifdef HAVE_IPV6
 127     case AF_INET6:
 128       inet_ntop (AF_INET6, &su->sin6.sin6_addr, str, INET6_ADDRSTRLEN);
 129       break;
 130 #endif /* HAVE_IPV6 */
 131     }
 132   return str;
 133 }
 134
 135 int
 136 str2sockunion (const char *str, union sockunion *su)
 137 {
 138   int ret;
 139
 140   memset (su, 0, sizeof (union sockunion));
 141
 142   ret = inet_pton (AF_INET, str, &su->sin.sin_addr);
 143   if (ret > 0)                  /* Valid IPv4 address format. */
 144     {
 145       su->sin.sin_family = AF_INET;
 146 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 147       su->sin.sin_len = sizeof(struct sockaddr_in);
 148 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 149       return 0;
 150     }
 151 #ifdef HAVE_IPV6
 152   ret = inet_pton (AF_INET6, str, &su->sin6.sin6_addr);
 153   if (ret > 0)                  /* Valid IPv6 address format. */
 154     {
 155       su->sin6.sin6_family = AF_INET6;
 156 #ifdef SIN6_LEN
 157       su->sin6.sin6_len = sizeof(struct sockaddr_in6);
 158 #endif /* SIN6_LEN */
 159       return 0;
 160     }
 161 #endif /* HAVE_IPV6 */
 162   return -1;
 163 }
 164
 165 const char *
 166 sockunion2str (union sockunion *su, char *buf, size_t len)
 167 {
 168   if  (su->sa.sa_family == AF_INET)
 169     return inet_ntop (AF_INET, &su->sin.sin_addr, buf, len);
 170 #ifdef HAVE_IPV6
 171   else if (su->sa.sa_family == AF_INET6)
 172     return inet_ntop (AF_INET6, &su->sin6.sin6_addr, buf, len);
 173 #endif /* HAVE_IPV6 */
 174   return NULL;
 175 }
 176
 177 union sockunion *
 178 sockunion_str2su (const char *str)
 179 {
 180   int ret;
 181   union sockunion *su;
 182
 183   su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
 184
 185   ret = inet_pton (AF_INET, str, &su->sin.sin_addr);
 186   if (ret > 0)                  /* Valid IPv4 address format. */
 187     {
 188       su->sin.sin_family = AF_INET;
 189 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 190       su->sin.sin_len = sizeof(struct sockaddr_in);
 191 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 192       return su;
 193     }
 194 #ifdef HAVE_IPV6
 195   ret = inet_pton (AF_INET6, str, &su->sin6.sin6_addr);
 196   if (ret > 0)                  /* Valid IPv6 address format. */
 197     {
 198       su->sin6.sin6_family = AF_INET6;
 199 #ifdef SIN6_LEN
 200       su->sin6.sin6_len = sizeof(struct sockaddr_in6);
 201 #endif /* SIN6_LEN */
 202       return su;
 203     }
 204 #endif /* HAVE_IPV6 */
 205
 206   XFREE (MTYPE_SOCKUNION, su);
 207   return NULL;
 208 }
 209
 210 char *
 211 sockunion_su2str (union sockunion *su)
 212 {
 213   char str[SU_ADDRSTRLEN];
 214
 215   switch (su->sa.sa_family)
 216     {
 217     case AF_INET:
 218       inet_ntop (AF_INET, &su->sin.sin_addr, str, sizeof (str));
 219       break;
 220 #ifdef HAVE_IPV6
 221     case AF_INET6:
 222       inet_ntop (AF_INET6, &su->sin6.sin6_addr, str, sizeof (str));
 223       break;
 224 #endif /* HAVE_IPV6 */
 225     }
 226   return XSTRDUP (MTYPE_TMP, str);
 227 }
 228
 229 /* Convert IPv4 compatible IPv6 address to IPv4 address. */
 230 static void
 231 sockunion_normalise_mapped (union sockunion *su)
 232 {
 233   struct sockaddr_in sin;
 234
 235 #ifdef HAVE_IPV6
 236   if (su->sa.sa_family == AF_INET6
 237       && IN6_IS_ADDR_V4MAPPED (&su->sin6.sin6_addr))
 238     {
 239       memset (&sin, 0, sizeof (struct sockaddr_in));
 240       sin.sin_family = AF_INET;
 241       sin.sin_port = su->sin6.sin6_port;
 242       memcpy (&sin.sin_addr, ((char *)&su->sin6.sin6_addr) + 12, 4);
 243       memcpy (su, &sin, sizeof (struct sockaddr_in));
 244     }
 245 #endif /* HAVE_IPV6 */
 246 }
 247
 248 /* Return socket of sockunion. */
 249 int
 250 sockunion_socket (union sockunion *su)
 251 {
 252   int sock;
 253
 254   sock = socket (su->sa.sa_family, SOCK_STREAM, 0);
 255   if (sock < 0)
 256     {
 257       zlog (NULL, LOG_WARNING, "Can't make socket : %s", safe_strerror (errno));
 258       return -1;
 259     }
 260
 261   return sock;
 262 }
 263
 264 /* Return accepted new socket file descriptor. */
 265 int
 266 sockunion_accept (int sock, union sockunion *su)
 267 {
 268   socklen_t len;
 269   int client_sock;
 270
 271   len = sizeof (union sockunion);
 272   client_sock = accept (sock, (struct sockaddr *) su, &len);
 273
 274   sockunion_normalise_mapped (su);
 275   return client_sock;
 276 }
 277
 278 /* Return sizeof union sockunion.  */
 279 static int
 280 sockunion_sizeof (union sockunion *su)
 281 {
 282   int ret;
 283
 284   ret = 0;
 285   switch (su->sa.sa_family)
 286     {
 287     case AF_INET:
 288       ret = sizeof (struct sockaddr_in);
 289       break;
 290 #ifdef HAVE_IPV6
 291     case AF_INET6:
 292       ret = sizeof (struct sockaddr_in6);
 293       break;
 294 #endif /* AF_INET6 */
 295     }
 296   return ret;
 297 }
 298
 299 /* return sockunion structure : this function should be revised. */
 300 static char *
 301 sockunion_log (union sockunion *su)
 302 {
 303   static char buf[SU_ADDRSTRLEN];
 304
 305   switch (su->sa.sa_family)
 306     {
 307     case AF_INET:
 308       snprintf (buf, SU_ADDRSTRLEN, "%s", inet_ntoa (su->sin.sin_addr));
 309       break;
 310 #ifdef HAVE_IPV6
 311     case AF_INET6:
 312       snprintf (buf, SU_ADDRSTRLEN, "%s",
 313                 inet_ntop (AF_INET6, &(su->sin6.sin6_addr), buf, SU_ADDRSTRLEN));
 314       break;
 315 #endif /* HAVE_IPV6 */
 316     default:
 317       snprintf (buf, SU_ADDRSTRLEN, "af_unknown %d ", su->sa.sa_family);
 318       break;
 319     }
 320   return (XSTRDUP (MTYPE_TMP, buf));
 321 }
 322
 323 /* sockunion_connect returns
 324    -1 : error occured
 325    0 : connect success
 326    1 : connect is in progress */
 327 enum connect_result
 328 sockunion_connect (int fd, union sockunion *peersu, unsigned short port,
 329                    unsigned int ifindex)
 330 {
 331   int ret;
 332   int val;
 333   union sockunion su;
 334
 335   memcpy (&su, peersu, sizeof (union sockunion));
 336
 337   switch (su.sa.sa_family)
 338     {
 339     case AF_INET:
 340       su.sin.sin_port = port;
 341       break;
 342 #ifdef HAVE_IPV6
 343     case AF_INET6:
 344       su.sin6.sin6_port  = port;
 345 #ifdef KAME
 346       if (IN6_IS_ADDR_LINKLOCAL(&su.sin6.sin6_addr) && ifindex)
 347         {
 348 #ifdef HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID
 349           /* su.sin6.sin6_scope_id = ifindex; */
 350 #ifdef MUSICA
 351           su.sin6.sin6_scope_id = ifindex;
 352 #endif
 353 #endif /* HAVE_STRUCT_SOCKADDR_IN6_SIN6_SCOPE_ID */
 354 #ifndef MUSICA
 355           SET_IN6_LINKLOCAL_IFINDEX (su.sin6.sin6_addr, ifindex);
 356 #endif
 357         }
 358 #endif /* KAME */
 359       break;
 360 #endif /* HAVE_IPV6 */
 361     }
 362
 363   /* Make socket non-block. */
 364   val = fcntl (fd, F_GETFL, 0);
 365   fcntl (fd, F_SETFL, val|O_NONBLOCK);
 366
 367   /* Call connect function. */
 368   ret = connect (fd, (struct sockaddr *) &su, sockunion_sizeof (&su));
 369
 370   /* Immediate success */
 371   if (ret == 0)
 372     {
 373       fcntl (fd, F_SETFL, val);
 374       return connect_success;
 375     }
 376
 377   /* If connect is in progress then return 1 else it's real error. */
 378   if (ret < 0)
 379     {
 380       if (errno != EINPROGRESS)
 381         {
 382           zlog_info ("can't connect to %s fd %d : %s",
 383                      sockunion_log (&su), fd, safe_strerror (errno));
 384           return connect_error;
 385         }
 386     }
 387
 388   fcntl (fd, F_SETFL, val);
 389
 390   return connect_in_progress;
 391 }
 392
 393 /* Make socket from sockunion union. */
 394 int
 395 sockunion_stream_socket (union sockunion *su)
 396 {
 397   int sock;
 398
 399   if (su->sa.sa_family == 0)
 400     su->sa.sa_family = AF_INET_UNION;
 401
 402   sock = socket (su->sa.sa_family, SOCK_STREAM, 0);
 403
 404   if (sock < 0)
 405     zlog (NULL, LOG_WARNING, "can't make socket sockunion_stream_socket");
 406
 407   return sock;
 408 }
 409
 410 /* Bind socket to specified address. */
 411 int
 412 sockunion_bind (int sock, union sockunion *su, unsigned short port,
 413                 union sockunion *su_addr)
 414 {
 415   int size = 0;
 416   int ret;
 417
 418   if (su->sa.sa_family == AF_INET)
 419     {
 420       size = sizeof (struct sockaddr_in);
 421       su->sin.sin_port = htons (port);
 422 #ifdef HAVE_STRUCT_SOCKADDR_IN_SIN_LEN
 423       su->sin.sin_len = size;
 424 #endif /* HAVE_STRUCT_SOCKADDR_IN_SIN_LEN */
 425       if (su_addr == NULL)
 426         su->sin.sin_addr.s_addr = htonl (INADDR_ANY);
 427     }
 428 #ifdef HAVE_IPV6
 429   else if (su->sa.sa_family == AF_INET6)
 430     {
 431       size = sizeof (struct sockaddr_in6);
 432       su->sin6.sin6_port = htons (port);
 433 #ifdef SIN6_LEN
 434       su->sin6.sin6_len = size;
 435 #endif /* SIN6_LEN */
 436       if (su_addr == NULL)
 437         {
 438 #if defined(LINUX_IPV6) || defined(NRL)
 439           memset (&su->sin6.sin6_addr, 0, sizeof (struct in6_addr));
 440 #else
 441           su->sin6.sin6_addr = in6addr_any;
 442 #endif /* LINUX_IPV6 */
 443         }
 444     }
 445 #endif /* HAVE_IPV6 */
 446
 447
 448   ret = bind (sock, (struct sockaddr *)su, size);
 449   if (ret < 0)
 450     zlog (NULL, LOG_WARNING, "can't bind socket : %s", safe_strerror (errno));
 451
 452   return ret;
 453 }
 454
 455 int
 456 sockopt_reuseaddr (int sock)
 457 {
 458   int ret;
 459   int on = 1;
 460
 461   ret = setsockopt (sock, SOL_SOCKET, SO_REUSEADDR,
 462                     (void *) &on, sizeof (on));
 463   if (ret < 0)
 464     {
 465       zlog (NULL, LOG_WARNING, "can't set sockopt SO_REUSEADDR to socket %d", sock);
 466       return -1;
 467     }
 468   return 0;
 469 }
 470
 471 #ifdef SO_REUSEPORT
 472 int
 473 sockopt_reuseport (int sock)
 474 {
 475   int ret;
 476   int on = 1;
 477
 478   ret = setsockopt (sock, SOL_SOCKET, SO_REUSEPORT,
 479                     (void *) &on, sizeof (on));
 480   if (ret < 0)
 481     {
 482       zlog (NULL, LOG_WARNING, "can't set sockopt SO_REUSEPORT to socket %d", sock);
 483       return -1;
 484     }
 485   return 0;
 486 }
 487 #else
 488 int
 489 sockopt_reuseport (int sock)
 490 {
 491   return 0;
 492 }
 493 #endif /* 0 */
 494
 495 int
 496 sockopt_ttl (int family, int sock, int ttl)
 497 {
 498   int ret;
 499
 500 #ifdef IP_TTL
 501   if (family == AF_INET)
 502     {
 503       ret = setsockopt (sock, IPPROTO_IP, IP_TTL,
 504                         (void *) &ttl, sizeof (int));
 505       if (ret < 0)
 506         {
 507           zlog (NULL, LOG_WARNING, "can't set sockopt IP_TTL %d to socket %d", ttl, sock);
 508           return -1;
 509         }
 510       return 0;
 511     }
 512 #endif /* IP_TTL */
 513 #ifdef HAVE_IPV6
 514   if (family == AF_INET6)
 515     {
 516       ret = setsockopt (sock, IPPROTO_IPV6, IPV6_UNICAST_HOPS,
 517                         (void *) &ttl, sizeof (int));
 518       if (ret < 0)
 519         {
 520           zlog (NULL, LOG_WARNING, "can't set sockopt IPV6_UNICAST_HOPS %d to socket %d",
 521                     ttl, sock);
 522           return -1;
 523         }
 524       return 0;
 525     }
 526 #endif /* HAVE_IPV6 */
 527   return 0;
 528 }
 529
 530 /* If same family and same prefix return 1. */
 531 int
 532 sockunion_same (union sockunion *su1, union sockunion *su2)
 533 {
 534   int ret = 0;
 535
 536   if (su1->sa.sa_family != su2->sa.sa_family)
 537     return 0;
 538
 539   switch (su1->sa.sa_family)
 540     {
 541     case AF_INET:
 542       ret = memcmp (&su1->sin.sin_addr, &su2->sin.sin_addr,
 543                     sizeof (struct in_addr));
 544       break;
 545 #ifdef HAVE_IPV6
 546     case AF_INET6:
 547       ret = memcmp (&su1->sin6.sin6_addr, &su2->sin6.sin6_addr,
 548                     sizeof (struct in6_addr));
 549       break;
 550 #endif /* HAVE_IPV6 */
 551     }
 552   if (ret == 0)
 553     return 1;
 554   else
 555     return 0;
 556 }
 557
 558 /* After TCP connection is established.  Get local address and port. */
 559 union sockunion *
 560 sockunion_getsockname (int fd)
 561 {
 562   int ret;
 563   socklen_t len;
 564   union
 565   {
 566     struct sockaddr sa;
 567     struct sockaddr_in sin;
 568 #ifdef HAVE_IPV6
 569     struct sockaddr_in6 sin6;
 570 #endif /* HAVE_IPV6 */
 571     char tmp_buffer[128];
 572   } name;
 573   union sockunion *su;
 574
 575   memset (&name, 0, sizeof name);
 576   len = sizeof name;
 577
 578   ret = getsockname (fd, (struct sockaddr *)&name, &len);
 579   if (ret < 0)
 580     {
 581       zlog_warn ("Can't get local address and port by getsockname: %s",
 582                  safe_strerror (errno));
 583       return NULL;
 584     }
 585
 586   if (name.sa.sa_family == AF_INET)
 587     {
 588       su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
 589       memcpy (su, &name, sizeof (struct sockaddr_in));
 590       return su;
 591     }
 592 #ifdef HAVE_IPV6
 593   if (name.sa.sa_family == AF_INET6)
 594     {
 595       su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
 596       memcpy (su, &name, sizeof (struct sockaddr_in6));
 597       sockunion_normalise_mapped (su);
 598       return su;
 599     }
 600 #endif /* HAVE_IPV6 */
 601   return NULL;
 602 }
 603
 604 /* After TCP connection is established.  Get remote address and port. */
 605 union sockunion *
 606 sockunion_getpeername (int fd)
 607 {
 608   int ret;
 609   socklen_t len;
 610   union
 611   {
 612     struct sockaddr sa;
 613     struct sockaddr_in sin;
 614 #ifdef HAVE_IPV6
 615     struct sockaddr_in6 sin6;
 616 #endif /* HAVE_IPV6 */
 617     char tmp_buffer[128];
 618   } name;
 619   union sockunion *su;
 620
 621   memset (&name, 0, sizeof name);
 622   len = sizeof name;
 623   ret = getpeername (fd, (struct sockaddr *)&name, &len);
 624   if (ret < 0)
 625     {
 626       zlog (NULL, LOG_WARNING, "Can't get remote address and port: %s",
 627             safe_strerror (errno));
 628       return NULL;
 629     }
 630
 631   if (name.sa.sa_family == AF_INET)
 632     {
 633       su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
 634       memcpy (su, &name, sizeof (struct sockaddr_in));
 635       return su;
 636     }
 637 #ifdef HAVE_IPV6
 638   if (name.sa.sa_family == AF_INET6)
 639     {
 640       su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
 641       memcpy (su, &name, sizeof (struct sockaddr_in6));
 642       sockunion_normalise_mapped (su);
 643       return su;
 644     }
 645 #endif /* HAVE_IPV6 */
 646   return NULL;
 647 }
 648
 649 /* Print sockunion structure */
 650 static void __attribute__ ((unused))
 651 sockunion_print (union sockunion *su)
 652 {
 653   if (su == NULL)
 654     return;
 655
 656   switch (su->sa.sa_family)
 657     {
 658     case AF_INET:
 659       printf ("%s\n", inet_ntoa (su->sin.sin_addr));
 660       break;
 661 #ifdef HAVE_IPV6
 662     case AF_INET6:
 663       {
 664         char buf [SU_ADDRSTRLEN];
 665
 666         printf ("%s\n", inet_ntop (AF_INET6, &(su->sin6.sin6_addr),
 667                                  buf, sizeof (buf)));
 668       }
 669       break;
 670 #endif /* HAVE_IPV6 */
 671
 672 #ifdef AF_LINK
 673     case AF_LINK:
 674       {
 675         struct sockaddr_dl *sdl;
 676
 677         sdl = (struct sockaddr_dl *)&(su->sa);
 678         printf ("link#%d\n", sdl->sdl_index);
 679       }
 680       break;
 681 #endif /* AF_LINK */
 682     default:
 683       printf ("af_unknown %d\n", su->sa.sa_family);
 684       break;
 685     }
 686 }
 687
 688 #ifdef HAVE_IPV6
 689 static int
 690 in6addr_cmp (struct in6_addr *addr1, struct in6_addr *addr2)
 691 {
 692   unsigned int i;
 693   u_char *p1, *p2;
 694
 695   p1 = (u_char *)addr1;
 696   p2 = (u_char *)addr2;
 697
 698   for (i = 0; i < sizeof (struct in6_addr); i++)
 699     {
 700       if (p1[i] > p2[i])
 701         return 1;
 702       else if (p1[i] < p2[i])
 703         return -1;
 704     }
 705   return 0;
 706 }
 707 #endif /* HAVE_IPV6 */
 708
 709 int
 710 sockunion_cmp (union sockunion *su1, union sockunion *su2)
 711 {
 712   if (su1->sa.sa_family > su2->sa.sa_family)
 713     return 1;
 714   if (su1->sa.sa_family < su2->sa.sa_family)
 715     return -1;
 716
 717   if (su1->sa.sa_family == AF_INET)
 718     {
 719       if (ntohl (su1->sin.sin_addr.s_addr) == ntohl (su2->sin.sin_addr.s_addr))
 720         return 0;
 721       if (ntohl (su1->sin.sin_addr.s_addr) > ntohl (su2->sin.sin_addr.s_addr))
 722         return 1;
 723       else
 724         return -1;
 725     }
 726 #ifdef HAVE_IPV6
 727   if (su1->sa.sa_family == AF_INET6)
 728     return in6addr_cmp (&su1->sin6.sin6_addr, &su2->sin6.sin6_addr);
 729 #endif /* HAVE_IPV6 */
 730   return 0;
 731 }
 732
 733 /* Duplicate sockunion. */
 734 union sockunion *
 735 sockunion_dup (union sockunion *su)
 736 {
 737   union sockunion *dup = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
 738   memcpy (dup, su, sizeof (union sockunion));
 739   return dup;
 740 }
 741
 742 void
 743 sockunion_free (union sockunion *su)
 744 {
 745   XFREE (MTYPE_SOCKUNION, su);
 746 }