Annotation of embedaddon/quagga/lib/sockunion.c, revision 1.1
1.1 ! misho 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: int
! 531: sockopt_cork (int sock, int onoff)
! 532: {
! 533: #ifdef TCP_CORK
! 534: return setsockopt (sock, IPPROTO_TCP, TCP_CORK, &onoff, sizeof(onoff));
! 535: #else
! 536: return 0;
! 537: #endif
! 538: }
! 539:
! 540: int
! 541: sockopt_minttl (int family, int sock, int minttl)
! 542: {
! 543: #ifdef IP_MINTTL
! 544: if (family == AF_INET)
! 545: {
! 546: int ret = setsockopt (sock, IPPROTO_IP, IP_MINTTL, &minttl, sizeof(minttl));
! 547: if (ret < 0)
! 548: zlog (NULL, LOG_WARNING,
! 549: "can't set sockopt IP_MINTTL to %d on socket %d: %s",
! 550: minttl, sock, safe_strerror (errno));
! 551: return ret;
! 552: }
! 553: #endif /* IP_MINTTL */
! 554: #ifdef IPV6_MINHOPCNT
! 555: if (family == AF_INET6)
! 556: {
! 557: int ret = setsockopt (sock, IPPROTO_IPV6, IPV6_MINHOPCNT, &minttl, sizeof(minttl));
! 558: if (ret < 0)
! 559: zlog (NULL, LOG_WARNING,
! 560: "can't set sockopt IPV6_MINHOPCNT to %d on socket %d: %s",
! 561: minttl, sock, safe_strerror (errno));
! 562: return ret;
! 563: }
! 564: #endif
! 565:
! 566: errno = EOPNOTSUPP;
! 567: return -1;
! 568: }
! 569:
! 570: /* If same family and same prefix return 1. */
! 571: int
! 572: sockunion_same (union sockunion *su1, union sockunion *su2)
! 573: {
! 574: int ret = 0;
! 575:
! 576: if (su1->sa.sa_family != su2->sa.sa_family)
! 577: return 0;
! 578:
! 579: switch (su1->sa.sa_family)
! 580: {
! 581: case AF_INET:
! 582: ret = memcmp (&su1->sin.sin_addr, &su2->sin.sin_addr,
! 583: sizeof (struct in_addr));
! 584: break;
! 585: #ifdef HAVE_IPV6
! 586: case AF_INET6:
! 587: ret = memcmp (&su1->sin6.sin6_addr, &su2->sin6.sin6_addr,
! 588: sizeof (struct in6_addr));
! 589: break;
! 590: #endif /* HAVE_IPV6 */
! 591: }
! 592: if (ret == 0)
! 593: return 1;
! 594: else
! 595: return 0;
! 596: }
! 597:
! 598: /* After TCP connection is established. Get local address and port. */
! 599: union sockunion *
! 600: sockunion_getsockname (int fd)
! 601: {
! 602: int ret;
! 603: socklen_t len;
! 604: union
! 605: {
! 606: struct sockaddr sa;
! 607: struct sockaddr_in sin;
! 608: #ifdef HAVE_IPV6
! 609: struct sockaddr_in6 sin6;
! 610: #endif /* HAVE_IPV6 */
! 611: char tmp_buffer[128];
! 612: } name;
! 613: union sockunion *su;
! 614:
! 615: memset (&name, 0, sizeof name);
! 616: len = sizeof name;
! 617:
! 618: ret = getsockname (fd, (struct sockaddr *)&name, &len);
! 619: if (ret < 0)
! 620: {
! 621: zlog_warn ("Can't get local address and port by getsockname: %s",
! 622: safe_strerror (errno));
! 623: return NULL;
! 624: }
! 625:
! 626: if (name.sa.sa_family == AF_INET)
! 627: {
! 628: su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
! 629: memcpy (su, &name, sizeof (struct sockaddr_in));
! 630: return su;
! 631: }
! 632: #ifdef HAVE_IPV6
! 633: if (name.sa.sa_family == AF_INET6)
! 634: {
! 635: su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
! 636: memcpy (su, &name, sizeof (struct sockaddr_in6));
! 637: sockunion_normalise_mapped (su);
! 638: return su;
! 639: }
! 640: #endif /* HAVE_IPV6 */
! 641: return NULL;
! 642: }
! 643:
! 644: /* After TCP connection is established. Get remote address and port. */
! 645: union sockunion *
! 646: sockunion_getpeername (int fd)
! 647: {
! 648: int ret;
! 649: socklen_t len;
! 650: union
! 651: {
! 652: struct sockaddr sa;
! 653: struct sockaddr_in sin;
! 654: #ifdef HAVE_IPV6
! 655: struct sockaddr_in6 sin6;
! 656: #endif /* HAVE_IPV6 */
! 657: char tmp_buffer[128];
! 658: } name;
! 659: union sockunion *su;
! 660:
! 661: memset (&name, 0, sizeof name);
! 662: len = sizeof name;
! 663: ret = getpeername (fd, (struct sockaddr *)&name, &len);
! 664: if (ret < 0)
! 665: {
! 666: zlog (NULL, LOG_WARNING, "Can't get remote address and port: %s",
! 667: safe_strerror (errno));
! 668: return NULL;
! 669: }
! 670:
! 671: if (name.sa.sa_family == AF_INET)
! 672: {
! 673: su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
! 674: memcpy (su, &name, sizeof (struct sockaddr_in));
! 675: return su;
! 676: }
! 677: #ifdef HAVE_IPV6
! 678: if (name.sa.sa_family == AF_INET6)
! 679: {
! 680: su = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
! 681: memcpy (su, &name, sizeof (struct sockaddr_in6));
! 682: sockunion_normalise_mapped (su);
! 683: return su;
! 684: }
! 685: #endif /* HAVE_IPV6 */
! 686: return NULL;
! 687: }
! 688:
! 689: /* Print sockunion structure */
! 690: static void __attribute__ ((unused))
! 691: sockunion_print (union sockunion *su)
! 692: {
! 693: if (su == NULL)
! 694: return;
! 695:
! 696: switch (su->sa.sa_family)
! 697: {
! 698: case AF_INET:
! 699: printf ("%s\n", inet_ntoa (su->sin.sin_addr));
! 700: break;
! 701: #ifdef HAVE_IPV6
! 702: case AF_INET6:
! 703: {
! 704: char buf [SU_ADDRSTRLEN];
! 705:
! 706: printf ("%s\n", inet_ntop (AF_INET6, &(su->sin6.sin6_addr),
! 707: buf, sizeof (buf)));
! 708: }
! 709: break;
! 710: #endif /* HAVE_IPV6 */
! 711:
! 712: #ifdef AF_LINK
! 713: case AF_LINK:
! 714: {
! 715: struct sockaddr_dl *sdl;
! 716:
! 717: sdl = (struct sockaddr_dl *)&(su->sa);
! 718: printf ("link#%d\n", sdl->sdl_index);
! 719: }
! 720: break;
! 721: #endif /* AF_LINK */
! 722: default:
! 723: printf ("af_unknown %d\n", su->sa.sa_family);
! 724: break;
! 725: }
! 726: }
! 727:
! 728: #ifdef HAVE_IPV6
! 729: static int
! 730: in6addr_cmp (struct in6_addr *addr1, struct in6_addr *addr2)
! 731: {
! 732: unsigned int i;
! 733: u_char *p1, *p2;
! 734:
! 735: p1 = (u_char *)addr1;
! 736: p2 = (u_char *)addr2;
! 737:
! 738: for (i = 0; i < sizeof (struct in6_addr); i++)
! 739: {
! 740: if (p1[i] > p2[i])
! 741: return 1;
! 742: else if (p1[i] < p2[i])
! 743: return -1;
! 744: }
! 745: return 0;
! 746: }
! 747: #endif /* HAVE_IPV6 */
! 748:
! 749: int
! 750: sockunion_cmp (union sockunion *su1, union sockunion *su2)
! 751: {
! 752: if (su1->sa.sa_family > su2->sa.sa_family)
! 753: return 1;
! 754: if (su1->sa.sa_family < su2->sa.sa_family)
! 755: return -1;
! 756:
! 757: if (su1->sa.sa_family == AF_INET)
! 758: {
! 759: if (ntohl (su1->sin.sin_addr.s_addr) == ntohl (su2->sin.sin_addr.s_addr))
! 760: return 0;
! 761: if (ntohl (su1->sin.sin_addr.s_addr) > ntohl (su2->sin.sin_addr.s_addr))
! 762: return 1;
! 763: else
! 764: return -1;
! 765: }
! 766: #ifdef HAVE_IPV6
! 767: if (su1->sa.sa_family == AF_INET6)
! 768: return in6addr_cmp (&su1->sin6.sin6_addr, &su2->sin6.sin6_addr);
! 769: #endif /* HAVE_IPV6 */
! 770: return 0;
! 771: }
! 772:
! 773: /* Duplicate sockunion. */
! 774: union sockunion *
! 775: sockunion_dup (union sockunion *su)
! 776: {
! 777: union sockunion *dup = XCALLOC (MTYPE_SOCKUNION, sizeof (union sockunion));
! 778: memcpy (dup, su, sizeof (union sockunion));
! 779: return dup;
! 780: }
! 781:
! 782: void
! 783: sockunion_free (union sockunion *su)
! 784: {
! 785: XFREE (MTYPE_SOCKUNION, su);
! 786: }
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to sockunion.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / quagga / lib