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