main/netsock2.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2010, Digium, Inc.
   5  *
   6  * Viagénie <asteriskv6@viagenie.ca>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief Network socket handling
  22  *
  23  * \author Viagénie <asteriskv6@viagenie.ca>
  24  */
  25
  26 /*** MODULEINFO
  27         <support_level>core</support_level>
  28  ***/
  29
  30 #include "asterisk.h"
  31
  32 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  33
  34 #include "asterisk/config.h"
  35 #include "asterisk/netsock2.h"
  36 #include "asterisk/utils.h"
  37 #include "asterisk/threadstorage.h"
  38
  39 int ast_sockaddr_ipv4_mapped(const struct ast_sockaddr *addr, struct ast_sockaddr *ast_mapped)
  40 {
  41         const struct sockaddr_in6 *sin6;
  42         struct sockaddr_in sin4;
  43
  44         if (!ast_sockaddr_is_ipv6(addr)) {
  45                 return 0;
  46         }
  47
  48         if (!ast_sockaddr_is_ipv4_mapped(addr)) {
  49                 return 0;
  50         }
  51
  52         sin6 = (const struct sockaddr_in6*)&addr->ss;
  53
  54         memset(&sin4, 0, sizeof(sin4));
  55         sin4.sin_family = AF_INET;
  56         sin4.sin_port = sin6->sin6_port;
  57         sin4.sin_addr.s_addr = ((uint32_t *)&sin6->sin6_addr)[3];
  58
  59         ast_sockaddr_from_sin(ast_mapped, &sin4);
  60
  61         return 1;
  62 }
  63
  64
  65 AST_THREADSTORAGE(ast_sockaddr_stringify_buf);
  66
  67 char *ast_sockaddr_stringify_fmt(const struct ast_sockaddr *sa, int format)
  68 {
  69         struct ast_sockaddr sa_ipv4;
  70         const struct ast_sockaddr *sa_tmp;
  71         char host[NI_MAXHOST];
  72         char port[NI_MAXSERV];
  73         struct ast_str *str;
  74         int e;
  75         static const size_t size = sizeof(host) - 1 + sizeof(port) - 1 + 4;
  76
  77
  78         if (ast_sockaddr_isnull(sa)) {
  79                 return "(null)";
  80         }
  81
  82         if (!(str = ast_str_thread_get(&ast_sockaddr_stringify_buf, size))) {
  83                 return "";
  84         }
  85
  86         if (ast_sockaddr_ipv4_mapped(sa, &sa_ipv4)) {
  87                 sa_tmp = &sa_ipv4;
  88         } else {
  89                 sa_tmp = sa;
  90         }
  91
  92         if ((e = getnameinfo((struct sockaddr *)&sa_tmp->ss, sa_tmp->len,
  93                              format & AST_SOCKADDR_STR_ADDR ? host : NULL,
  94                              format & AST_SOCKADDR_STR_ADDR ? sizeof(host) : 0,
  95                              format & AST_SOCKADDR_STR_PORT ? port : 0,
  96                              format & AST_SOCKADDR_STR_PORT ? sizeof(port): 0,
  97                              NI_NUMERICHOST | NI_NUMERICSERV))) {
  98                 ast_log(LOG_ERROR, "getnameinfo(): %s\n", gai_strerror(e));
  99                 return "";
 100         }
 101
 102         if ((format & AST_SOCKADDR_STR_REMOTE) == AST_SOCKADDR_STR_REMOTE) {
 103                 char *p;
 104                 if (ast_sockaddr_is_ipv6_link_local(sa) && (p = strchr(host, '%'))) {
 105                         *p = '\0';
 106                 }
 107         }
 108
 109         switch ((format & AST_SOCKADDR_STR_FORMAT_MASK))  {
 110         case AST_SOCKADDR_STR_DEFAULT:
 111                 ast_str_set(&str, 0, sa_tmp->ss.ss_family == AF_INET6 ?
 112                                 "[%s]:%s" : "%s:%s", host, port);
 113                 break;
 114         case AST_SOCKADDR_STR_ADDR:
 115                 ast_str_set(&str, 0, "%s", host);
 116                 break;
 117         case AST_SOCKADDR_STR_HOST:
 118                 ast_str_set(&str, 0,
 119                             sa_tmp->ss.ss_family == AF_INET6 ? "[%s]" : "%s", host);
 120                 break;
 121         case AST_SOCKADDR_STR_PORT:
 122                 ast_str_set(&str, 0, "%s", port);
 123                 break;
 124         default:
 125                 ast_log(LOG_ERROR, "Invalid format\n");
 126                 return "";
 127         }
 128
 129         return ast_str_buffer(str);
 130 }
 131
 132 int ast_sockaddr_split_hostport(char *str, char **host, char **port, int flags)
 133 {
 134         char *s = str;
 135         char *orig_str = str;/* Original string in case the port presence is incorrect. */
 136         char *host_end = NULL;/* Delay terminating the host in case the port presence is incorrect. */
 137
 138         ast_debug(5, "Splitting '%s' into...\n", str);
 139         *host = NULL;
 140         *port = NULL;
 141         if (*s == '[') {
 142                 *host = ++s;
 143                 for (; *s && *s != ']'; ++s) {
 144                 }
 145                 if (*s == ']') {
 146                         host_end = s;
 147                         ++s;
 148                 }
 149                 if (*s == ':') {
 150                         *port = s + 1;
 151                 }
 152         } else {
 153                 *host = s;
 154                 for (; *s; ++s) {
 155                         if (*s == ':') {
 156                                 if (*port) {
 157                                         *port = NULL;
 158                                         break;
 159                                 } else {
 160                                         *port = s;
 161                                 }
 162                         }
 163                 }
 164                 if (*port) {
 165                         host_end = *port;
 166                         ++*port;
 167                 }
 168         }
 169
 170         switch (flags & PARSE_PORT_MASK) {
 171         case PARSE_PORT_IGNORE:
 172                 *port = NULL;
 173                 break;
 174         case PARSE_PORT_REQUIRE:
 175                 if (*port == NULL) {
 176                         ast_log(LOG_WARNING, "Port missing in %s\n", orig_str);
 177                         return 0;
 178                 }
 179                 break;
 180         case PARSE_PORT_FORBID:
 181                 if (*port != NULL) {
 182                         ast_log(LOG_WARNING, "Port disallowed in %s\n", orig_str);
 183                         return 0;
 184                 }
 185                 break;
 186         }
 187
 188         /* Can terminate the host string now if needed. */
 189         if (host_end) {
 190                 *host_end = '\0';
 191         }
 192         ast_debug(5, "...host '%s' and port '%s'.\n", *host, *port ? *port : "");
 193         return 1;
 194 }
 195
 196
 197
 198 int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags)
 199 {
 200         struct addrinfo hints;
 201         struct addrinfo *res;
 202         char *s;
 203         char *host;
 204         char *port;
 205         int     e;
 206
 207         s = ast_strdupa(str);
 208         if (!ast_sockaddr_split_hostport(s, &host, &port, flags)) {
 209                 return 0;
 210         }
 211
 212         memset(&hints, 0, sizeof(hints));
 213         /* Hint to get only one entry from getaddrinfo */
 214         hints.ai_socktype = SOCK_DGRAM;
 215
 216 #ifdef AI_NUMERICSERV
 217         hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
 218 #else
 219         hints.ai_flags = AI_NUMERICHOST;
 220 #endif
 221         if ((e = getaddrinfo(host, port, &hints, &res))) {
 222                 if (e != EAI_NONAME) { /* if this was just a host name rather than a ip address, don't print error */
 223                         ast_log(LOG_ERROR, "getaddrinfo(\"%s\", \"%s\", ...): %s\n",
 224                                 host, S_OR(port, "(null)"), gai_strerror(e));
 225                 }
 226                 return 0;
 227         }
 228
 229         /*
 230          * I don't see how this could be possible since we're not resolving host
 231          * names. But let's be careful...
 232          */
 233         if (res->ai_next != NULL) {
 234                 ast_log(LOG_WARNING, "getaddrinfo() returned multiple "
 235                         "addresses. Ignoring all but the first.\n");
 236         }
 237
 238         if (addr) {
 239                 addr->len = res->ai_addrlen;
 240                 memcpy(&addr->ss, res->ai_addr, addr->len);
 241         }
 242
 243         freeaddrinfo(res);
 244
 245         return 1;
 246 }
 247
 248 int ast_sockaddr_resolve(struct ast_sockaddr **addrs, const char *str,
 249                          int flags, int family)
 250 {
 251         struct addrinfo hints, *res, *ai;
 252         char *s, *host, *port;
 253         int     e, i, res_cnt;
 254
 255         if (!str) {
 256                 return 0;
 257         }
 258
 259         s = ast_strdupa(str);
 260         if (!ast_sockaddr_split_hostport(s, &host, &port, flags)) {
 261                 return 0;
 262         }
 263
 264         memset(&hints, 0, sizeof(hints));
 265         hints.ai_family = family;
 266         hints.ai_socktype = SOCK_DGRAM;
 267
 268         if ((e = getaddrinfo(host, port, &hints, &res))) {
 269                 ast_log(LOG_ERROR, "getaddrinfo(\"%s\", \"%s\", ...): %s\n",
 270                         host, S_OR(port, "(null)"), gai_strerror(e));
 271                 return 0;
 272         }
 273
 274         res_cnt = 0;
 275         for (ai = res; ai; ai = ai->ai_next) {
 276                 res_cnt++;
 277         }
 278
 279         if (res_cnt == 0) {
 280                 goto cleanup;
 281         }
 282
 283         if ((*addrs = ast_malloc(res_cnt * sizeof(struct ast_sockaddr))) == NULL) {
 284                 res_cnt = 0;
 285                 goto cleanup;
 286         }
 287
 288         i = 0;
 289         for (ai = res; ai; ai = ai->ai_next) {
 290                 (*addrs)[i].len = ai->ai_addrlen;
 291                 memcpy(&(*addrs)[i].ss, ai->ai_addr, ai->ai_addrlen);
 292                 ++i;
 293         }
 294
 295 cleanup:
 296         freeaddrinfo(res);
 297         return res_cnt;
 298 }
 299
 300 int ast_sockaddr_apply_netmask(const struct ast_sockaddr *addr, const struct ast_sockaddr *netmask,
 301                 struct ast_sockaddr *result)
 302 {
 303         int res = 0;
 304
 305         if (ast_sockaddr_is_ipv4(addr)) {
 306                 struct sockaddr_in result4 = { 0, };
 307                 struct sockaddr_in *addr4 = (struct sockaddr_in *) &addr->ss;
 308                 struct sockaddr_in *mask4 = (struct sockaddr_in *) &netmask->ss;
 309                 result4.sin_family = AF_INET;
 310                 result4.sin_addr.s_addr = addr4->sin_addr.s_addr & mask4->sin_addr.s_addr;
 311                 ast_sockaddr_from_sin(result, &result4);
 312         } else if (ast_sockaddr_is_ipv6(addr)) {
 313                 struct sockaddr_in6 result6 = { 0, };
 314                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) &addr->ss;
 315                 struct sockaddr_in6 *mask6 = (struct sockaddr_in6 *) &netmask->ss;
 316                 int i;
 317                 result6.sin6_family = AF_INET6;
 318                 for (i = 0; i < 4; ++i) {
 319                         V6_WORD(&result6, i) = V6_WORD(addr6, i) & V6_WORD(mask6, i);
 320                 }
 321                 memcpy(&result->ss, &result6, sizeof(result6));
 322                 result->len = sizeof(result6);
 323         } else {
 324                 /* Unsupported address scheme */
 325                 res = -1;
 326         }
 327
 328         return res;
 329 }
 330
 331 int ast_sockaddr_cmp(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
 332 {
 333         const struct ast_sockaddr *a_tmp, *b_tmp;
 334         struct ast_sockaddr ipv4_mapped;
 335
 336         a_tmp = a;
 337         b_tmp = b;
 338
 339         if (a_tmp->len != b_tmp->len) {
 340                 if (ast_sockaddr_ipv4_mapped(a, &ipv4_mapped)) {
 341                         a_tmp = &ipv4_mapped;
 342                 } else if (ast_sockaddr_ipv4_mapped(b, &ipv4_mapped)) {
 343                         b_tmp = &ipv4_mapped;
 344                 }
 345         }
 346
 347         if (a_tmp->len < b_tmp->len) {
 348                 return -1;
 349         } else if (a_tmp->len > b_tmp->len) {
 350                 return 1;
 351         }
 352
 353         return memcmp(&a_tmp->ss, &b_tmp->ss, a_tmp->len);
 354 }
 355
 356 int ast_sockaddr_cmp_addr(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
 357 {
 358         const struct ast_sockaddr *a_tmp, *b_tmp;
 359         struct ast_sockaddr ipv4_mapped;
 360         const struct in_addr *ip4a, *ip4b;
 361         const struct in6_addr *ip6a, *ip6b;
 362         int ret = -1;
 363
 364         a_tmp = a;
 365         b_tmp = b;
 366
 367         if (a_tmp->len != b_tmp->len) {
 368                 if (ast_sockaddr_ipv4_mapped(a, &ipv4_mapped)) {
 369                         a_tmp = &ipv4_mapped;
 370                 } else if (ast_sockaddr_ipv4_mapped(b, &ipv4_mapped)) {
 371                         b_tmp = &ipv4_mapped;
 372                 }
 373         }
 374
 375         if (a->len < b->len) {
 376                 ret = -1;
 377         } else if (a->len > b->len) {
 378                 ret = 1;
 379         }
 380
 381         switch (a_tmp->ss.ss_family) {
 382         case AF_INET:
 383                 ip4a = &((const struct sockaddr_in*)&a_tmp->ss)->sin_addr;
 384                 ip4b = &((const struct sockaddr_in*)&b_tmp->ss)->sin_addr;
 385                 ret = memcmp(ip4a, ip4b, sizeof(*ip4a));
 386                 break;
 387         case AF_INET6:
 388                 ip6a = &((const struct sockaddr_in6*)&a_tmp->ss)->sin6_addr;
 389                 ip6b = &((const struct sockaddr_in6*)&b_tmp->ss)->sin6_addr;
 390                 ret = memcmp(ip6a, ip6b, sizeof(*ip6a));
 391                 break;
 392         }
 393         return ret;
 394 }
 395
 396 uint16_t _ast_sockaddr_port(const struct ast_sockaddr *addr, const char *file, int line, const char *func)
 397 {
 398         if (addr->ss.ss_family == AF_INET &&
 399             addr->len == sizeof(struct sockaddr_in)) {
 400                 return ntohs(((struct sockaddr_in *)&addr->ss)->sin_port);
 401         } else if (addr->ss.ss_family == AF_INET6 &&
 402                  addr->len == sizeof(struct sockaddr_in6)) {
 403                 return ntohs(((struct sockaddr_in6 *)&addr->ss)->sin6_port);
 404         }
 405         if (option_debug >= 1) {
 406                 ast_log(__LOG_DEBUG, file, line, func, "Not an IPv4 nor IPv6 address, cannot get port.\n");
 407         }
 408         return 0;
 409 }
 410
 411 void _ast_sockaddr_set_port(struct ast_sockaddr *addr, uint16_t port, const char *file, int line, const char *func)
 412 {
 413         if (addr->ss.ss_family == AF_INET &&
 414             addr->len == sizeof(struct sockaddr_in)) {
 415                 ((struct sockaddr_in *)&addr->ss)->sin_port = htons(port);
 416         } else if (addr->ss.ss_family == AF_INET6 &&
 417                  addr->len == sizeof(struct sockaddr_in6)) {
 418                 ((struct sockaddr_in6 *)&addr->ss)->sin6_port = htons(port);
 419         } else if (option_debug >= 1) {
 420                 ast_log(__LOG_DEBUG, file, line, func,
 421                         "Not an IPv4 nor IPv6 address, cannot set port.\n");
 422         }
 423 }
 424
 425 uint32_t ast_sockaddr_ipv4(const struct ast_sockaddr *addr)
 426 {
 427         const struct sockaddr_in *sin = (struct sockaddr_in *)&addr->ss;
 428         return ntohl(sin->sin_addr.s_addr);
 429 }
 430
 431 int ast_sockaddr_is_ipv4(const struct ast_sockaddr *addr)
 432 {
 433         return addr->ss.ss_family == AF_INET &&
 434             addr->len == sizeof(struct sockaddr_in);
 435 }
 436
 437 int ast_sockaddr_is_ipv4_mapped(const struct ast_sockaddr *addr)
 438 {
 439         const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&addr->ss;
 440         return addr->len && IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr);
 441 }
 442
 443 int ast_sockaddr_is_ipv4_multicast(const struct ast_sockaddr *addr)
 444 {
 445         return ((ast_sockaddr_ipv4(addr) & 0xf0000000) == 0xe0000000);
 446 }
 447
 448 int ast_sockaddr_is_ipv6_link_local(const struct ast_sockaddr *addr)
 449 {
 450         const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&addr->ss;
 451         return ast_sockaddr_is_ipv6(addr) && IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr);
 452 }
 453
 454 int ast_sockaddr_is_ipv6(const struct ast_sockaddr *addr)
 455 {
 456         return addr->ss.ss_family == AF_INET6 &&
 457             addr->len == sizeof(struct sockaddr_in6);
 458 }
 459
 460 int ast_sockaddr_is_any(const struct ast_sockaddr *addr)
 461 {
 462         union {
 463                 struct sockaddr_storage ss;
 464                 struct sockaddr_in sin;
 465                 struct sockaddr_in6 sin6;
 466         } tmp_addr = {
 467                 .ss = addr->ss,
 468         };
 469
 470         return (ast_sockaddr_is_ipv4(addr) && (tmp_addr.sin.sin_addr.s_addr == INADDR_ANY)) ||
 471             (ast_sockaddr_is_ipv6(addr) && IN6_IS_ADDR_UNSPECIFIED(&tmp_addr.sin6.sin6_addr));
 472 }
 473
 474 int ast_sockaddr_hash(const struct ast_sockaddr *addr)
 475 {
 476         /*
 477          * For IPv4, return the IP address as-is. For IPv6, return the last 32
 478          * bits.
 479          */
 480         switch (addr->ss.ss_family) {
 481         case AF_INET:
 482                 return ((const struct sockaddr_in *)&addr->ss)->sin_addr.s_addr;
 483         case AF_INET6:
 484                 return ((uint32_t *)&((const struct sockaddr_in6 *)&addr->ss)->sin6_addr)[3];
 485         default:
 486                 ast_log(LOG_ERROR, "Unknown address family '%d'.\n",
 487                         addr->ss.ss_family);
 488                 return 0;
 489         }
 490 }
 491
 492 const char *ast_transport2str(enum ast_transport transport)
 493 {
 494         switch (transport) {
 495         case AST_TRANSPORT_TLS:
 496                 return "TLS";
 497         case AST_TRANSPORT_UDP:
 498                 return "UDP";
 499         case AST_TRANSPORT_TCP:
 500                 return "TCP";
 501         case AST_TRANSPORT_WS:
 502                 return "WS";
 503         case AST_TRANSPORT_WSS:
 504                 return "WSS";
 505         }
 506
 507         return "Undefined";
 508 }
 509
 510 int ast_accept(int sockfd, struct ast_sockaddr *addr)
 511 {
 512         addr->len = sizeof(addr->ss);
 513         return accept(sockfd, (struct sockaddr *)&addr->ss, &addr->len);
 514 }
 515
 516 int ast_bind(int sockfd, const struct ast_sockaddr *addr)
 517 {
 518         return bind(sockfd, (const struct sockaddr *)&addr->ss, addr->len);
 519 }
 520
 521 int ast_connect(int sockfd, const struct ast_sockaddr *addr)
 522 {
 523         return connect(sockfd, (const struct sockaddr *)&addr->ss, addr->len);
 524 }
 525
 526 int ast_getsockname(int sockfd, struct ast_sockaddr *addr)
 527 {
 528         addr->len = sizeof(addr->ss);
 529         return getsockname(sockfd, (struct sockaddr *)&addr->ss, &addr->len);
 530 }
 531
 532 ssize_t ast_recvfrom(int sockfd, void *buf, size_t len, int flags,
 533                      struct ast_sockaddr *src_addr)
 534 {
 535         src_addr->len = sizeof(src_addr->ss);
 536         return recvfrom(sockfd, buf, len, flags,
 537                         (struct sockaddr *)&src_addr->ss, &src_addr->len);
 538 }
 539
 540 ssize_t ast_sendto(int sockfd, const void *buf, size_t len, int flags,
 541                    const struct ast_sockaddr *dest_addr)
 542 {
 543         return sendto(sockfd, buf, len, flags,
 544                       (const struct sockaddr *)&dest_addr->ss, dest_addr->len);
 545 }
 546
 547 int ast_set_qos(int sockfd, int tos, int cos, const char *desc)
 548 {
 549         int res = 0;
 550         int set_tos;
 551         int set_tclass;
 552         struct ast_sockaddr addr;
 553
 554         /* If the sock address is IPv6, the TCLASS field must be set. */
 555         set_tclass = !ast_getsockname(sockfd, &addr) && ast_sockaddr_is_ipv6(&addr) ? 1 : 0;
 556
 557         /* If the the sock address is IPv4 or (IPv6 set to any address [::]) set TOS bits */
 558         set_tos = (!set_tclass || (set_tclass && ast_sockaddr_is_any(&addr))) ? 1 : 0;
 559
 560         if (set_tos) {
 561                 if ((res = setsockopt(sockfd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) {
 562                         ast_log(LOG_WARNING, "Unable to set %s DSCP TOS value to %d (may be you have no "
 563                                 "root privileges): %s\n", desc, tos, strerror(errno));
 564                 } else if (tos) {
 565                         ast_verb(2, "Using %s TOS bits %d\n", desc, tos);
 566                 }
 567         }
 568
 569 #if defined(IPV6_TCLASS) && defined(IPPROTO_IPV6)
 570         if (set_tclass) {
 571                 if (!ast_getsockname(sockfd, &addr) && ast_sockaddr_is_ipv6(&addr)) {
 572                         if ((res = setsockopt(sockfd, IPPROTO_IPV6, IPV6_TCLASS, &tos, sizeof(tos)))) {
 573                                 ast_log(LOG_WARNING, "Unable to set %s DSCP TCLASS field to %d (may be you have no "
 574                                         "root privileges): %s\n", desc, tos, strerror(errno));
 575                         } else if (tos) {
 576                                 ast_verb(2, "Using %s TOS bits %d in TCLASS field.\n", desc, tos);
 577                         }
 578                 }
 579         }
 580 #endif
 581
 582 #ifdef linux
 583         if (setsockopt(sockfd, SOL_SOCKET, SO_PRIORITY, &cos, sizeof(cos))) {
 584                 ast_log(LOG_WARNING, "Unable to set %s CoS to %d: %s\n", desc, cos,
 585                         strerror(errno));
 586         } else if (cos) {
 587                 ast_verb(2, "Using %s CoS mark %d\n", desc, cos);
 588         }
 589 #endif
 590
 591         return res;
 592 }
 593
 594 int _ast_sockaddr_to_sin(const struct ast_sockaddr *addr,
 595                         struct sockaddr_in *sin, const char *file, int line, const char *func)
 596 {
 597         if (ast_sockaddr_isnull(addr)) {
 598                 memset(sin, 0, sizeof(*sin));
 599                 return 1;
 600         }
 601
 602         if (addr->len != sizeof(*sin)) {
 603                 ast_log(__LOG_ERROR, file, line, func, "Bad address cast to IPv4\n");
 604                 return 0;
 605         }
 606
 607         if (addr->ss.ss_family != AF_INET && option_debug >= 1) {
 608                 ast_log(__LOG_DEBUG, file, line, func, "Address family is not AF_INET\n");
 609         }
 610
 611         *sin = *(struct sockaddr_in *)&addr->ss;
 612         return 1;
 613 }
 614
 615 void _ast_sockaddr_from_sin(struct ast_sockaddr *addr, const struct sockaddr_in *sin,
 616                 const char *file, int line, const char *func)
 617 {
 618         memcpy(&addr->ss, sin, sizeof(*sin));
 619
 620         if (addr->ss.ss_family != AF_INET && option_debug >= 1) {
 621                 ast_log(__LOG_DEBUG, file, line, func, "Address family is not AF_INET\n");
 622         }
 623
 624         addr->len = sizeof(*sin);
 625 }