pjsip cli: Change Identify to show CIDR notation instead of netmasks.
[asterisk/asterisk.git] / 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_cidr_bits(const struct ast_sockaddr *sa)
133 {
134         struct ast_sockaddr sa_ipv4;
135         const struct ast_sockaddr *sa_tmp;
136         int bits = 0;
137         int bytes;
138         int i;
139         int j;
140         char *addr;
141
142         if (ast_sockaddr_isnull(sa)) {
143                 return 0;
144         }
145
146         if (ast_sockaddr_ipv4_mapped(sa, &sa_ipv4)) {
147                 sa_tmp = &sa_ipv4;
148         } else {
149                 sa_tmp = sa;
150         }
151
152         bytes = sa_tmp->len;
153         addr = ((struct sockaddr *)&sa_tmp->ss)->sa_data;
154
155         for (i = 0; i < bytes ; ++i) {
156                 for (j = 0; j < 8; ++j) {
157                         if ((addr[i] >> j) & 1) {
158                                 bits++;
159                         }
160                 }
161         }
162
163         return bits;
164 }
165
166 int ast_sockaddr_split_hostport(char *str, char **host, char **port, int flags)
167 {
168         char *s = str;
169         char *orig_str = str;/* Original string in case the port presence is incorrect. */
170         char *host_end = NULL;/* Delay terminating the host in case the port presence is incorrect. */
171
172         ast_debug(5, "Splitting '%s' into...\n", str);
173         *host = NULL;
174         *port = NULL;
175         if (*s == '[') {
176                 *host = ++s;
177                 for (; *s && *s != ']'; ++s) {
178                 }
179                 if (*s == ']') {
180                         host_end = s;
181                         ++s;
182                 }
183                 if (*s == ':') {
184                         *port = s + 1;
185                 }
186         } else {
187                 *host = s;
188                 for (; *s; ++s) {
189                         if (*s == ':') {
190                                 if (*port) {
191                                         *port = NULL;
192                                         break;
193                                 } else {
194                                         *port = s;
195                                 }
196                         }
197                 }
198                 if (*port) {
199                         host_end = *port;
200                         ++*port;
201                 }
202         }
203
204         switch (flags & PARSE_PORT_MASK) {
205         case PARSE_PORT_IGNORE:
206                 *port = NULL;
207                 break;
208         case PARSE_PORT_REQUIRE:
209                 if (*port == NULL) {
210                         ast_log(LOG_WARNING, "Port missing in %s\n", orig_str);
211                         return 0;
212                 }
213                 break;
214         case PARSE_PORT_FORBID:
215                 if (*port != NULL) {
216                         ast_log(LOG_WARNING, "Port disallowed in %s\n", orig_str);
217                         return 0;
218                 }
219                 break;
220         }
221
222         /* Can terminate the host string now if needed. */
223         if (host_end) {
224                 *host_end = '\0';
225         }
226         ast_debug(5, "...host '%s' and port '%s'.\n", *host, *port ? *port : "");
227         return 1;
228 }
229
230
231
232 int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags)
233 {
234         struct addrinfo hints;
235         struct addrinfo *res;
236         char *s;
237         char *host;
238         char *port;
239         int     e;
240
241         s = ast_strdupa(str);
242         if (!ast_sockaddr_split_hostport(s, &host, &port, flags)) {
243                 return 0;
244         }
245
246         memset(&hints, 0, sizeof(hints));
247         /* Hint to get only one entry from getaddrinfo */
248         hints.ai_socktype = SOCK_DGRAM;
249
250 #ifdef AI_NUMERICSERV
251         hints.ai_flags = AI_NUMERICHOST | AI_NUMERICSERV;
252 #else
253         hints.ai_flags = AI_NUMERICHOST;
254 #endif
255         if ((e = getaddrinfo(host, port, &hints, &res))) {
256                 if (e != EAI_NONAME) { /* if this was just a host name rather than a ip address, don't print error */
257                         ast_log(LOG_ERROR, "getaddrinfo(\"%s\", \"%s\", ...): %s\n",
258                                 host, S_OR(port, "(null)"), gai_strerror(e));
259                 }
260                 return 0;
261         }
262
263         /*
264          * I don't see how this could be possible since we're not resolving host
265          * names. But let's be careful...
266          */
267         if (res->ai_next != NULL) {
268                 ast_log(LOG_WARNING, "getaddrinfo() returned multiple "
269                         "addresses. Ignoring all but the first.\n");
270         }
271
272         if (addr) {
273                 addr->len = res->ai_addrlen;
274                 memcpy(&addr->ss, res->ai_addr, addr->len);
275         }
276
277         freeaddrinfo(res);
278
279         return 1;
280 }
281
282 int ast_sockaddr_resolve(struct ast_sockaddr **addrs, const char *str,
283                          int flags, int family)
284 {
285         struct addrinfo hints, *res, *ai;
286         char *s, *host, *port;
287         int     e, i, res_cnt;
288
289         if (!str) {
290                 return 0;
291         }
292
293         s = ast_strdupa(str);
294         if (!ast_sockaddr_split_hostport(s, &host, &port, flags)) {
295                 return 0;
296         }
297
298         memset(&hints, 0, sizeof(hints));
299         hints.ai_family = family;
300         hints.ai_socktype = SOCK_DGRAM;
301
302         if ((e = getaddrinfo(host, port, &hints, &res))) {
303                 ast_log(LOG_ERROR, "getaddrinfo(\"%s\", \"%s\", ...): %s\n",
304                         host, S_OR(port, "(null)"), gai_strerror(e));
305                 return 0;
306         }
307
308         res_cnt = 0;
309         for (ai = res; ai; ai = ai->ai_next) {
310                 res_cnt++;
311         }
312
313         if (res_cnt == 0) {
314                 goto cleanup;
315         }
316
317         if ((*addrs = ast_malloc(res_cnt * sizeof(struct ast_sockaddr))) == NULL) {
318                 res_cnt = 0;
319                 goto cleanup;
320         }
321
322         i = 0;
323         for (ai = res; ai; ai = ai->ai_next) {
324                 (*addrs)[i].len = ai->ai_addrlen;
325                 memcpy(&(*addrs)[i].ss, ai->ai_addr, ai->ai_addrlen);
326                 ++i;
327         }
328
329 cleanup:
330         freeaddrinfo(res);
331         return res_cnt;
332 }
333
334 int ast_sockaddr_apply_netmask(const struct ast_sockaddr *addr, const struct ast_sockaddr *netmask,
335                 struct ast_sockaddr *result)
336 {
337         int res = 0;
338
339         if (ast_sockaddr_is_ipv4(addr)) {
340                 struct sockaddr_in result4 = { 0, };
341                 struct sockaddr_in *addr4 = (struct sockaddr_in *) &addr->ss;
342                 struct sockaddr_in *mask4 = (struct sockaddr_in *) &netmask->ss;
343                 result4.sin_family = AF_INET;
344                 result4.sin_addr.s_addr = addr4->sin_addr.s_addr & mask4->sin_addr.s_addr;
345                 ast_sockaddr_from_sin(result, &result4);
346         } else if (ast_sockaddr_is_ipv6(addr)) {
347                 struct sockaddr_in6 result6 = { 0, };
348                 struct sockaddr_in6 *addr6 = (struct sockaddr_in6 *) &addr->ss;
349                 struct sockaddr_in6 *mask6 = (struct sockaddr_in6 *) &netmask->ss;
350                 int i;
351                 result6.sin6_family = AF_INET6;
352                 for (i = 0; i < 4; ++i) {
353                         V6_WORD(&result6, i) = V6_WORD(addr6, i) & V6_WORD(mask6, i);
354                 }
355                 memcpy(&result->ss, &result6, sizeof(result6));
356                 result->len = sizeof(result6);
357         } else {
358                 /* Unsupported address scheme */
359                 res = -1;
360         }
361
362         return res;
363 }
364
365 int ast_sockaddr_cmp(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
366 {
367         const struct ast_sockaddr *a_tmp, *b_tmp;
368         struct ast_sockaddr ipv4_mapped;
369
370         a_tmp = a;
371         b_tmp = b;
372
373         if (a_tmp->len != b_tmp->len) {
374                 if (ast_sockaddr_ipv4_mapped(a, &ipv4_mapped)) {
375                         a_tmp = &ipv4_mapped;
376                 } else if (ast_sockaddr_ipv4_mapped(b, &ipv4_mapped)) {
377                         b_tmp = &ipv4_mapped;
378                 }
379         }
380
381         if (a_tmp->len < b_tmp->len) {
382                 return -1;
383         } else if (a_tmp->len > b_tmp->len) {
384                 return 1;
385         }
386
387         return memcmp(&a_tmp->ss, &b_tmp->ss, a_tmp->len);
388 }
389
390 int ast_sockaddr_cmp_addr(const struct ast_sockaddr *a, const struct ast_sockaddr *b)
391 {
392         const struct ast_sockaddr *a_tmp, *b_tmp;
393         struct ast_sockaddr ipv4_mapped;
394         const struct in_addr *ip4a, *ip4b;
395         const struct in6_addr *ip6a, *ip6b;
396         int ret = -1;
397
398         a_tmp = a;
399         b_tmp = b;
400
401         if (a_tmp->len != b_tmp->len) {
402                 if (ast_sockaddr_ipv4_mapped(a, &ipv4_mapped)) {
403                         a_tmp = &ipv4_mapped;
404                 } else if (ast_sockaddr_ipv4_mapped(b, &ipv4_mapped)) {
405                         b_tmp = &ipv4_mapped;
406                 }
407         }
408
409         if (a->len < b->len) {
410                 ret = -1;
411         } else if (a->len > b->len) {
412                 ret = 1;
413         }
414
415         switch (a_tmp->ss.ss_family) {
416         case AF_INET:
417                 ip4a = &((const struct sockaddr_in*)&a_tmp->ss)->sin_addr;
418                 ip4b = &((const struct sockaddr_in*)&b_tmp->ss)->sin_addr;
419                 ret = memcmp(ip4a, ip4b, sizeof(*ip4a));
420                 break;
421         case AF_INET6:
422                 ip6a = &((const struct sockaddr_in6*)&a_tmp->ss)->sin6_addr;
423                 ip6b = &((const struct sockaddr_in6*)&b_tmp->ss)->sin6_addr;
424                 ret = memcmp(ip6a, ip6b, sizeof(*ip6a));
425                 break;
426         }
427         return ret;
428 }
429
430 uint16_t _ast_sockaddr_port(const struct ast_sockaddr *addr, const char *file, int line, const char *func)
431 {
432         if (addr->ss.ss_family == AF_INET &&
433             addr->len == sizeof(struct sockaddr_in)) {
434                 return ntohs(((struct sockaddr_in *)&addr->ss)->sin_port);
435         } else if (addr->ss.ss_family == AF_INET6 &&
436                  addr->len == sizeof(struct sockaddr_in6)) {
437                 return ntohs(((struct sockaddr_in6 *)&addr->ss)->sin6_port);
438         }
439         if (option_debug >= 1) {
440                 ast_log(__LOG_DEBUG, file, line, func, "Not an IPv4 nor IPv6 address, cannot get port.\n");
441         }
442         return 0;
443 }
444
445 void _ast_sockaddr_set_port(struct ast_sockaddr *addr, uint16_t port, const char *file, int line, const char *func)
446 {
447         if (addr->ss.ss_family == AF_INET &&
448             addr->len == sizeof(struct sockaddr_in)) {
449                 ((struct sockaddr_in *)&addr->ss)->sin_port = htons(port);
450         } else if (addr->ss.ss_family == AF_INET6 &&
451                  addr->len == sizeof(struct sockaddr_in6)) {
452                 ((struct sockaddr_in6 *)&addr->ss)->sin6_port = htons(port);
453         } else if (option_debug >= 1) {
454                 ast_log(__LOG_DEBUG, file, line, func,
455                         "Not an IPv4 nor IPv6 address, cannot set port.\n");
456         }
457 }
458
459 uint32_t ast_sockaddr_ipv4(const struct ast_sockaddr *addr)
460 {
461         const struct sockaddr_in *sin = (struct sockaddr_in *)&addr->ss;
462         return ntohl(sin->sin_addr.s_addr);
463 }
464
465 int ast_sockaddr_is_ipv4(const struct ast_sockaddr *addr)
466 {
467         return addr->ss.ss_family == AF_INET &&
468             addr->len == sizeof(struct sockaddr_in);
469 }
470
471 int ast_sockaddr_is_ipv4_mapped(const struct ast_sockaddr *addr)
472 {
473         const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&addr->ss;
474         return addr->len && IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr);
475 }
476
477 int ast_sockaddr_is_ipv4_multicast(const struct ast_sockaddr *addr)
478 {
479         return ((ast_sockaddr_ipv4(addr) & 0xf0000000) == 0xe0000000);
480 }
481
482 int ast_sockaddr_is_ipv6_link_local(const struct ast_sockaddr *addr)
483 {
484         const struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *)&addr->ss;
485         return ast_sockaddr_is_ipv6(addr) && IN6_IS_ADDR_LINKLOCAL(&sin6->sin6_addr);
486 }
487
488 int ast_sockaddr_is_ipv6(const struct ast_sockaddr *addr)
489 {
490         return addr->ss.ss_family == AF_INET6 &&
491             addr->len == sizeof(struct sockaddr_in6);
492 }
493
494 int ast_sockaddr_is_any(const struct ast_sockaddr *addr)
495 {
496         union {
497                 struct sockaddr_storage ss;
498                 struct sockaddr_in sin;
499                 struct sockaddr_in6 sin6;
500         } tmp_addr = {
501                 .ss = addr->ss,
502         };
503
504         return (ast_sockaddr_is_ipv4(addr) && (tmp_addr.sin.sin_addr.s_addr == INADDR_ANY)) ||
505             (ast_sockaddr_is_ipv6(addr) && IN6_IS_ADDR_UNSPECIFIED(&tmp_addr.sin6.sin6_addr));
506 }
507
508 int ast_sockaddr_hash(const struct ast_sockaddr *addr)
509 {
510         /*
511          * For IPv4, return the IP address as-is. For IPv6, return the last 32
512          * bits.
513          */
514         switch (addr->ss.ss_family) {
515         case AF_INET:
516                 return ((const struct sockaddr_in *)&addr->ss)->sin_addr.s_addr;
517         case AF_INET6:
518                 return ((uint32_t *)&((const struct sockaddr_in6 *)&addr->ss)->sin6_addr)[3];
519         default:
520                 ast_log(LOG_ERROR, "Unknown address family '%d'.\n",
521                         addr->ss.ss_family);
522                 return 0;
523         }
524 }
525
526 const char *ast_transport2str(enum ast_transport transport)
527 {
528         switch (transport) {
529         case AST_TRANSPORT_TLS:
530                 return "TLS";
531         case AST_TRANSPORT_UDP:
532                 return "UDP";
533         case AST_TRANSPORT_TCP:
534                 return "TCP";
535         case AST_TRANSPORT_WS:
536                 return "WS";
537         case AST_TRANSPORT_WSS:
538                 return "WSS";
539         }
540
541         return "Undefined";
542 }
543
544 int ast_accept(int sockfd, struct ast_sockaddr *addr)
545 {
546         addr->len = sizeof(addr->ss);
547         return accept(sockfd, (struct sockaddr *)&addr->ss, &addr->len);
548 }
549
550 int ast_bind(int sockfd, const struct ast_sockaddr *addr)
551 {
552         return bind(sockfd, (const struct sockaddr *)&addr->ss, addr->len);
553 }
554
555 int ast_connect(int sockfd, const struct ast_sockaddr *addr)
556 {
557         return connect(sockfd, (const struct sockaddr *)&addr->ss, addr->len);
558 }
559
560 int ast_getsockname(int sockfd, struct ast_sockaddr *addr)
561 {
562         addr->len = sizeof(addr->ss);
563         return getsockname(sockfd, (struct sockaddr *)&addr->ss, &addr->len);
564 }
565
566 ssize_t ast_recvfrom(int sockfd, void *buf, size_t len, int flags,
567                      struct ast_sockaddr *src_addr)
568 {
569         src_addr->len = sizeof(src_addr->ss);
570         return recvfrom(sockfd, buf, len, flags,
571                         (struct sockaddr *)&src_addr->ss, &src_addr->len);
572 }
573
574 ssize_t ast_sendto(int sockfd, const void *buf, size_t len, int flags,
575                    const struct ast_sockaddr *dest_addr)
576 {
577         return sendto(sockfd, buf, len, flags,
578                       (const struct sockaddr *)&dest_addr->ss, dest_addr->len);
579 }
580
581 int ast_set_qos(int sockfd, int tos, int cos, const char *desc)
582 {
583         int res = 0;
584         int set_tos;
585         int set_tclass;
586         struct ast_sockaddr addr;
587
588         /* If the sock address is IPv6, the TCLASS field must be set. */
589         set_tclass = !ast_getsockname(sockfd, &addr) && ast_sockaddr_is_ipv6(&addr) ? 1 : 0;
590
591         /* If the the sock address is IPv4 or (IPv6 set to any address [::]) set TOS bits */
592         set_tos = (!set_tclass || (set_tclass && ast_sockaddr_is_any(&addr))) ? 1 : 0;
593
594         if (set_tos) {
595                 if ((res = setsockopt(sockfd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos)))) {
596                         ast_log(LOG_WARNING, "Unable to set %s DSCP TOS value to %d (may be you have no "
597                                 "root privileges): %s\n", desc, tos, strerror(errno));
598                 } else if (tos) {
599                         ast_verb(2, "Using %s TOS bits %d\n", desc, tos);
600                 }
601         }
602
603 #if defined(IPV6_TCLASS) && defined(IPPROTO_IPV6)
604         if (set_tclass) {
605                 if (!ast_getsockname(sockfd, &addr) && ast_sockaddr_is_ipv6(&addr)) {
606                         if ((res = setsockopt(sockfd, IPPROTO_IPV6, IPV6_TCLASS, &tos, sizeof(tos)))) {
607                                 ast_log(LOG_WARNING, "Unable to set %s DSCP TCLASS field to %d (may be you have no "
608                                         "root privileges): %s\n", desc, tos, strerror(errno));
609                         } else if (tos) {
610                                 ast_verb(2, "Using %s TOS bits %d in TCLASS field.\n", desc, tos);
611                         }
612                 }
613         }
614 #endif
615
616 #ifdef linux
617         if (setsockopt(sockfd, SOL_SOCKET, SO_PRIORITY, &cos, sizeof(cos))) {
618                 ast_log(LOG_WARNING, "Unable to set %s CoS to %d: %s\n", desc, cos,
619                         strerror(errno));
620         } else if (cos) {
621                 ast_verb(2, "Using %s CoS mark %d\n", desc, cos);
622         }
623 #endif
624
625         return res;
626 }
627
628 int _ast_sockaddr_to_sin(const struct ast_sockaddr *addr,
629                         struct sockaddr_in *sin, const char *file, int line, const char *func)
630 {
631         if (ast_sockaddr_isnull(addr)) {
632                 memset(sin, 0, sizeof(*sin));
633                 return 1;
634         }
635
636         if (addr->len != sizeof(*sin)) {
637                 ast_log(__LOG_ERROR, file, line, func, "Bad address cast to IPv4\n");
638                 return 0;
639         }
640
641         if (addr->ss.ss_family != AF_INET && option_debug >= 1) {
642                 ast_log(__LOG_DEBUG, file, line, func, "Address family is not AF_INET\n");
643         }
644
645         *sin = *(struct sockaddr_in *)&addr->ss;
646         return 1;
647 }
648
649 void _ast_sockaddr_from_sin(struct ast_sockaddr *addr, const struct sockaddr_in *sin,
650                 const char *file, int line, const char *func)
651 {
652         memcpy(&addr->ss, sin, sizeof(*sin));
653
654         if (addr->ss.ss_family != AF_INET && option_debug >= 1) {
655                 ast_log(__LOG_DEBUG, file, line, func, "Address family is not AF_INET\n");
656         }
657
658         addr->len = sizeof(*sin);
659 }