2d2cfdf5aec498ffcf33f1d4f1d5d82393183c3e
[asterisk/asterisk.git] / include / asterisk / netsock2.h
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  * \brief Network socket handling
21  */
22
23 #ifndef _ASTERISK_NETSOCK2_H
24 #define _ASTERISK_NETSOCK2_H
25
26 #if defined(__cplusplus) || defined(c_plusplus)
27 extern "C" {
28 #endif
29
30 #include <sys/socket.h>
31
32 #include <netinet/in.h>
33
34 /*!
35  * Values for address families that we support. This is reproduced from socket.h
36  * because we do not want users to include that file. Only netsock2.c should
37  * ever include socket.h.
38  */
39 enum {
40         AST_AF_UNSPEC = AF_UNSPEC,
41         AST_AF_INET   = AF_INET,
42         AST_AF_INET6  = AF_INET6,
43 };
44
45 enum ast_transport {
46         AST_TRANSPORT_UDP   = 1,
47         AST_TRANSPORT_TCP   = 1 << 1,
48         AST_TRANSPORT_TLS   = 1 << 2,
49         AST_TRANSPORT_WS    = 1 << 3,
50         AST_TRANSPORT_WSS   = 1 << 4,
51 };
52
53 /*!
54  * \brief
55  * Isolate a 32-bit section of an IPv6 address
56  *
57  * An IPv6 address can be divided into 4 32-bit chunks. This gives
58  * easy access to one of these chunks.
59  *
60  * \param sin6 A pointer to a struct sockaddr_in6
61  * \param index Which 32-bit chunk to operate on. Must be in the range 0-3.
62  */
63 #define V6_WORD(sin6, index) ((uint32_t *)&((sin6)->sin6_addr))[(index)]
64
65 /*!
66  * \brief Socket address structure.
67  *
68  * \details
69  * The first member is big enough to contain addresses of any
70  * family. The second member contains the length (in bytes) used
71  * in the first member.
72  *
73  * \note
74  * Some BSDs have the length embedded in sockaddr structs. We
75  * ignore them. (This is the right thing to do.)
76  *
77  * \note
78  * It is important to always initialize ast_sockaddr before use
79  * -- even if they are passed to ast_sockaddr_copy() as the
80  * underlying storage could be bigger than what ends up being
81  * copied -- leaving part of the data unitialized.
82  */
83 struct ast_sockaddr {
84         struct sockaddr_storage  ss;
85         socklen_t len;
86 };
87
88 /*!
89  * \brief
90  * Convert an IPv4-mapped IPv6 address into an IPv4 address.
91  *
92  * \warning You should rarely need this function. Only call this
93  * if you know what you're doing.
94  *
95  * \param addr The IPv4-mapped address to convert
96  * \param ast_mapped The resulting IPv4 address
97  * \retval 0 Unable to make the conversion
98  * \retval 1 Successful conversion
99  */
100 int ast_sockaddr_ipv4_mapped(const struct ast_sockaddr *addr, struct ast_sockaddr *ast_mapped);
101
102 /*!
103  * \since 1.8
104  *
105  * \brief
106  * Checks if the ast_sockaddr is null. "null" in this sense essentially
107  * means uninitialized, or having a 0 length.
108  *
109  * \param addr Pointer to the ast_sockaddr we wish to check
110  * \retval 1 \a addr is null
111  * \retval 0 \a addr is non-null.
112  */
113 static inline int ast_sockaddr_isnull(const struct ast_sockaddr *addr)
114 {
115         return !addr || addr->len == 0;
116 }
117
118 /*!
119  * \since 1.8
120  *
121  * \brief
122  * Sets address \a addr to null.
123  *
124  * \retval void
125  */
126 static inline void ast_sockaddr_setnull(struct ast_sockaddr *addr)
127 {
128         addr->len = 0;
129 }
130
131 /*!
132  * \brief
133  * Copies the data from a sockaddr to an ast_sockaddr
134  *
135  * \param dst The destination ast_sockaddr
136  * \param src The source sockaddr
137  * \param len Length of the value stored in sockaddr
138  * \retval void
139  */
140 static inline void ast_sockaddr_copy_sockaddr(struct ast_sockaddr *dst,
141                 struct sockaddr *src, socklen_t len)
142 {
143         memcpy(dst, src, len);
144         dst->len = len;
145 }
146
147 /*!
148  * \since 1.8
149  *
150  * \brief
151  * Copies the data from one ast_sockaddr to another
152  *
153  * \param dst The destination ast_sockaddr
154  * \param src The source ast_sockaddr
155  * \retval void
156  */
157 static inline void ast_sockaddr_copy(struct ast_sockaddr *dst,
158                 const struct ast_sockaddr *src)
159 {
160         memcpy(dst, src, src->len);
161         dst->len = src->len;
162 };
163
164 /*!
165  * \since 1.8
166  *
167  * \brief
168  * Compares two ast_sockaddr structures
169  *
170  * \retval -1 \a a is lexicographically smaller than \a b
171  * \retval 0 \a a is equal to \a b
172  * \retval 1 \a b is lexicographically smaller than \a a
173  */
174 int ast_sockaddr_cmp(const struct ast_sockaddr *a, const struct ast_sockaddr *b);
175
176 /*!
177  * \since 1.8
178  *
179  * \brief
180  * Compares the addresses of two ast_sockaddr structures.
181  *
182  * \retval -1 \a a is lexicographically smaller than \a b
183  * \retval 0 \a a is equal to \a b
184  * \retval 1 \a b is lexicographically smaller than \a a
185  */
186 int ast_sockaddr_cmp_addr(const struct ast_sockaddr *a, const struct ast_sockaddr *b);
187
188 #define AST_SOCKADDR_STR_ADDR           (1 << 0)
189 #define AST_SOCKADDR_STR_PORT           (1 << 1)
190 #define AST_SOCKADDR_STR_BRACKETS       (1 << 2)
191 #define AST_SOCKADDR_STR_REMOTE         (1 << 3)
192 #define AST_SOCKADDR_STR_HOST           (AST_SOCKADDR_STR_ADDR | AST_SOCKADDR_STR_BRACKETS)
193 #define AST_SOCKADDR_STR_DEFAULT        (AST_SOCKADDR_STR_ADDR | AST_SOCKADDR_STR_PORT)
194 #define AST_SOCKADDR_STR_ADDR_REMOTE     (AST_SOCKADDR_STR_ADDR | AST_SOCKADDR_STR_REMOTE)
195 #define AST_SOCKADDR_STR_HOST_REMOTE     (AST_SOCKADDR_STR_HOST | AST_SOCKADDR_STR_REMOTE)
196 #define AST_SOCKADDR_STR_DEFAULT_REMOTE  (AST_SOCKADDR_STR_DEFAULT | AST_SOCKADDR_STR_REMOTE)
197 #define AST_SOCKADDR_STR_FORMAT_MASK     (AST_SOCKADDR_STR_ADDR | AST_SOCKADDR_STR_PORT | AST_SOCKADDR_STR_BRACKETS)
198
199 /*!
200  * \since 1.8
201  *
202  * \brief
203  * Convert a socket address to a string.
204  *
205  * \details
206  * This will be of the form a.b.c.d:xyz
207  * for IPv4 and [a:b:c:...:d]:xyz for IPv6.
208  *
209  * This function is thread-safe. The returned string is on static
210  * thread-specific storage.
211  *
212  * \param addr The input to be stringified
213  * \param format one of the following:
214  * AST_SOCKADDR_STR_DEFAULT:
215  *    a.b.c.d:xyz for IPv4
216  *    [a:b:c:...:d]:xyz for IPv6.
217  * AST_SOCKADDR_STR_ADDR: address only
218  *    a.b.c.d for IPv4
219  *    a:b:c:...:d for IPv6.
220  * AST_SOCKADDR_STR_HOST: address only, suitable for a URL
221  *    a.b.c.d for IPv4
222  *    [a:b:c:...:d] for IPv6.
223  * AST_SOCKADDR_STR_PORT: port only
224  *
225  * \note The string pointer returned by this function will point to a string that
226  * will be changed whenever any form of ast_sockaddr_stringify_fmt is called on that
227  * thread. Because of this, it is important that if you use this function, you use the
228  * string before another use of this function is made elsewhere in the same thread.
229  * The easiest way to accomplish this is by immediately copying the string to a buffer
230  * with something like ast_strdupa.
231  *
232  * \retval "(null)" \a addr is null
233  * \retval "" An error occurred during processing
234  * \retval string The stringified form of the address
235  */
236 char *ast_sockaddr_stringify_fmt(const struct ast_sockaddr *addr, int format);
237
238 /*!
239  * \since 1.8
240  *
241  * \brief
242  * Wrapper around ast_sockaddr_stringify_fmt() with default format
243  *
244  * \return same as ast_sockaddr_stringify_fmt()
245  */
246 static inline char *ast_sockaddr_stringify(const struct ast_sockaddr *addr)
247 {
248         return ast_sockaddr_stringify_fmt(addr, AST_SOCKADDR_STR_DEFAULT);
249 }
250
251 /*!
252  * \since 1.8
253  *
254  * \brief
255  * Wrapper around ast_sockaddr_stringify_fmt() with default format
256  *
257  * \note This address will be suitable for passing to a remote machine via the
258  * application layer. For example, the scope-id on a link-local IPv6 address
259  * will be stripped.
260  *
261  * \return same as ast_sockaddr_stringify_fmt()
262  */
263 static inline char *ast_sockaddr_stringify_remote(const struct ast_sockaddr *addr)
264 {
265         return ast_sockaddr_stringify_fmt(addr, AST_SOCKADDR_STR_DEFAULT_REMOTE);
266 }
267
268 /*!
269  * \since 1.8
270  *
271  * \brief
272  * Wrapper around ast_sockaddr_stringify_fmt() to return an address only
273  *
274  * \return same as ast_sockaddr_stringify_fmt()
275  */
276 static inline char *ast_sockaddr_stringify_addr(const struct ast_sockaddr *addr)
277 {
278         return ast_sockaddr_stringify_fmt(addr, AST_SOCKADDR_STR_ADDR);
279 }
280
281 /*!
282  * \since 12.4
283  *
284  * \brief
285  * Count the 1 bits in a netmask
286  *
287  * \return number of 1 bits
288  */
289 int ast_sockaddr_cidr_bits(const struct ast_sockaddr *sa);
290
291 /*!
292  * \since 1.8
293  *
294  * \brief
295  * Wrapper around ast_sockaddr_stringify_fmt() to return an address only
296  *
297  * \note This address will be suitable for passing to a remote machine via the
298  * application layer. For example, the scope-id on a link-local IPv6 address
299  * will be stripped.
300  *
301  * \return same as ast_sockaddr_stringify_fmt()
302  */
303 static inline char *ast_sockaddr_stringify_addr_remote(const struct ast_sockaddr *addr)
304 {
305         return ast_sockaddr_stringify_fmt(addr, AST_SOCKADDR_STR_ADDR_REMOTE);
306 }
307
308 /*!
309  * \since 1.8
310  *
311  * \brief
312  * Wrapper around ast_sockaddr_stringify_fmt() to return an address only,
313  * suitable for a URL (with brackets for IPv6).
314  *
315  * \return same as ast_sockaddr_stringify_fmt()
316  */
317 static inline char *ast_sockaddr_stringify_host(const struct ast_sockaddr *addr)
318 {
319         return ast_sockaddr_stringify_fmt(addr, AST_SOCKADDR_STR_HOST);
320 }
321
322 /*!
323  * \since 1.8
324  *
325  * \brief
326  * Wrapper around ast_sockaddr_stringify_fmt() to return an address only,
327  * suitable for a URL (with brackets for IPv6).
328  *
329  * \note This address will be suitable for passing to a remote machine via the
330  * application layer. For example, the scope-id on a link-local IPv6 address
331  * will be stripped.
332  *
333  * \return same as ast_sockaddr_stringify_fmt()
334  */
335 static inline char *ast_sockaddr_stringify_host_remote(const struct ast_sockaddr *addr)
336 {
337         return ast_sockaddr_stringify_fmt(addr, AST_SOCKADDR_STR_HOST_REMOTE);
338 }
339
340 /*!
341  * \since 1.8
342  *
343  * \brief
344  * Wrapper around ast_sockaddr_stringify_fmt() to return a port only
345  *
346  * \return same as ast_sockaddr_stringify_fmt()
347  */
348 static inline char *ast_sockaddr_stringify_port(const struct ast_sockaddr *addr)
349 {
350         return ast_sockaddr_stringify_fmt(addr, AST_SOCKADDR_STR_PORT);
351 }
352
353 /*!
354  * \since 1.8
355  *
356  * \brief
357  * Splits a string into its host and port components
358  *
359  * \param[in] str The string to parse. May be modified by writing a NUL at the end of
360  *                  the host part.
361  * \param[out] host Pointer to the host component within \a str.
362  * \param[out] port Pointer to the port component within \a str.
363  * \param flags     If set to zero, a port MAY be present. If set to PARSE_PORT_IGNORE, a
364  *                  port MAY be present but will be ignored. If set to PARSE_PORT_REQUIRE,
365  *                  a port MUST be present. If set to PARSE_PORT_FORBID, a port MUST NOT
366  *                  be present.
367  *
368  * \retval 1 Success
369  * \retval 0 Failure
370  */
371 int ast_sockaddr_split_hostport(char *str, char **host, char **port, int flags);
372
373 /*!
374  * \since 1.8
375  *
376  * \brief
377  * Parse an IPv4 or IPv6 address string.
378  *
379  * \details
380  * Parses a string containing an IPv4 or IPv6 address followed by an optional
381  * port (separated by a colon) into a struct ast_sockaddr. The allowed formats
382  * are the following:
383  *
384  * a.b.c.d
385  * a.b.c.d:port
386  * a:b:c:...:d
387  * [a:b:c:...:d]
388  * [a:b:c:...:d]:port
389  *
390  * Host names are NOT allowed.
391  *
392  * \param[out] addr The resulting ast_sockaddr. This MAY be NULL from
393  * functions that are performing validity checks only, e.g. ast_parse_arg().
394  * \param str The string to parse
395  * \param flags If set to zero, a port MAY be present. If set to
396  * PARSE_PORT_IGNORE, a port MAY be present but will be ignored. If set to
397  * PARSE_PORT_REQUIRE, a port MUST be present. If set to PARSE_PORT_FORBID, a
398  * port MUST NOT be present.
399  *
400  * \retval 1 Success
401  * \retval 0 Failure
402  */
403 int ast_sockaddr_parse(struct ast_sockaddr *addr, const char *str, int flags);
404
405 /*!
406  * \since 1.8
407  *
408  * \brief
409  * Parses a string with an IPv4 or IPv6 address and place results into an array
410  *
411  * \details
412  * Parses a string containing a host name or an IPv4 or IPv6 address followed
413  * by an optional port (separated by a colon).  The result is returned into a
414  * array of struct ast_sockaddr. Allowed formats for str are the following:
415  *
416  * hostname:port
417  * host.example.com:port
418  * a.b.c.d
419  * a.b.c.d:port
420  * a:b:c:...:d
421  * [a:b:c:...:d]
422  * [a:b:c:...:d]:port
423  *
424  * \param[out] addrs The resulting array of ast_sockaddrs
425  * \param str The string to parse
426  * \param flags If set to zero, a port MAY be present. If set to
427  * PARSE_PORT_IGNORE, a port MAY be present but will be ignored. If set to
428  * PARSE_PORT_REQUIRE, a port MUST be present. If set to PARSE_PORT_FORBID, a
429  * port MUST NOT be present.
430  *
431  * \param family Only addresses of the given family will be returned. Use 0 or
432  * AST_AF_UNSPEC to get addresses of all families.
433  *
434  * \retval 0 Failure
435  * \retval non-zero The number of elements in addrs array.
436  */
437 int ast_sockaddr_resolve(struct ast_sockaddr **addrs, const char *str,
438                          int flags, int family);
439
440 /*!
441  * \brief
442  * Apply a netmask to an address and store the result in a separate structure.
443  *
444  * When dealing with IPv6 addresses, one cannot apply a netmask with a simple
445  * logical AND operation.  Futhermore, the incoming address may be an IPv4
446  * address and needs to be mapped properly before attempting to apply a rule.
447  *
448  * \param addr The IP address to apply the mask to.
449  * \param netmask The netmask configured in the host access rule.
450  * \param result The resultant address after applying the netmask to the given address
451  * \retval 0 Successfully applied netmask
452  * \retval -1 Failed to apply netmask
453  */
454 int ast_sockaddr_apply_netmask(const struct ast_sockaddr *addr, const struct ast_sockaddr *netmask,
455                 struct ast_sockaddr *result);
456
457 /*!
458  * \since 1.8
459  *
460  * \brief
461  * Get the port number of a socket address.
462  *
463  * \warning Do not use this function unless you really know what you are doing.
464  * And "I want the port number" is not knowing what you are doing.
465  *
466  * \retval 0 Address is null
467  * \retval non-zero The port number of the ast_sockaddr
468  */
469 #define ast_sockaddr_port(addr) _ast_sockaddr_port(addr, __FILE__, __LINE__, __PRETTY_FUNCTION__)
470 uint16_t _ast_sockaddr_port(const struct ast_sockaddr *addr, const char *file, int line, const char *func);
471
472 /*!
473  * \since 1.8
474  *
475  * \brief
476  * Sets the port number of a socket address.
477  *
478  * \warning Do not use this function unless you really know what you are doing.
479  * And "I want the port number" is not knowing what you are doing.
480  *
481  * \param addr Address on which to set the port
482  * \param port The port you wish to set the address to use
483  * \retval void
484  */
485 #define ast_sockaddr_set_port(addr,port)        _ast_sockaddr_set_port(addr,port,__FILE__,__LINE__,__PRETTY_FUNCTION__)
486 void _ast_sockaddr_set_port(struct ast_sockaddr *addr, uint16_t port, const char *file, int line, const char *func);
487
488 /*!
489  * \since 1.8
490  *
491  * \brief
492  * Get an IPv4 address of an ast_sockaddr
493  *
494  * \warning You should rarely need this function. Only use if you know what
495  * you're doing.
496  * \return IPv4 address in network byte order
497  */
498 uint32_t ast_sockaddr_ipv4(const struct ast_sockaddr *addr);
499
500 /*!
501  * \since 1.8
502  *
503  * \brief
504  * Determine if the address is an IPv4 address
505  *
506  * \warning You should rarely need this function. Only use if you know what
507  * you're doing.
508  * \retval 1 This is an IPv4 address
509  * \retval 0 This is an IPv6 or IPv4-mapped IPv6 address
510  */
511 int ast_sockaddr_is_ipv4(const struct ast_sockaddr *addr);
512
513 /*!
514  * \since 1.8
515  *
516  * \brief
517  * Determine if this is an IPv4-mapped IPv6 address
518  *
519  * \warning You should rarely need this function. Only use if you know what
520  * you're doing.
521  *
522  * \retval 1 This is an IPv4-mapped IPv6 address.
523  * \retval 0 This is not an IPv4-mapped IPv6 address.
524  */
525 int ast_sockaddr_is_ipv4_mapped(const struct ast_sockaddr *addr);
526
527 /*!
528  * \since 10.0
529  *
530  * \brief
531  * Determine if an IPv4 address is a multicast address
532  *
533  * \param addr the address to check
534  *
535  * This function checks if an address is in the 224.0.0.0/4 network block.
536  *
537  * \return non-zero if this is a multicast address
538  */
539 int ast_sockaddr_is_ipv4_multicast(const struct ast_sockaddr *addr);
540
541 /*!
542  * \since 1.8
543  *
544  * \brief
545  * Determine if this is a link-local IPv6 address
546  *
547  * \warning You should rarely need this function. Only use if you know what
548  * you're doing.
549  *
550  * \retval 1 This is a link-local IPv6 address.
551  * \retval 0 This is link-local IPv6 address.
552  */
553 int ast_sockaddr_is_ipv6_link_local(const struct ast_sockaddr *addr);
554
555 /*!
556  * \since 1.8
557  *
558  * \brief
559  * Determine if this is an IPv6 address
560  *
561  * \warning You should rarely need this function. Only use if you know what
562  * you're doing.
563  *
564  * \retval 1 This is an IPv6 or IPv4-mapped IPv6 address.
565  * \retval 0 This is an IPv4 address.
566  */
567 int ast_sockaddr_is_ipv6(const struct ast_sockaddr *addr);
568
569 /*!
570  * \since 1.8
571  *
572  * \brief
573  * Determine if the address type is unspecified, or "any" address.
574  *
575  * \details
576  * For IPv4, this would be the address 0.0.0.0, and for IPv6,
577  * this would be the address ::. The port number is ignored.
578  *
579  * \retval 1 This is an "any" address
580  * \retval 0 This is not an "any" address
581  */
582 int ast_sockaddr_is_any(const struct ast_sockaddr *addr);
583
584 /*!
585  * \since 1.8
586  *
587  * \brief
588  * Computes a hash value from the address. The port is ignored.
589  *
590  * \retval 0 Unknown address family
591  * \retval other A 32-bit hash derived from the address
592  */
593 int ast_sockaddr_hash(const struct ast_sockaddr *addr);
594
595 /*!
596  * \since 12.3
597  *
598  * \brief
599  * Returns a string representation of an ast_transport
600  *
601  * \retval Name of the tranpsort if it is defined
602  * \retval Undefined if the transport is undefined
603  */
604 const char *ast_transport2str(enum ast_transport transport);
605
606 /*!
607  * \since 1.8
608  *
609  * \brief
610  * Wrapper around accept(2) that uses struct ast_sockaddr.
611  *
612  * \details
613  * For parameter and return information, see the man page for
614  * accept(2).
615  */
616 int ast_accept(int sockfd, struct ast_sockaddr *addr);
617
618 /*!
619  * \since 1.8
620  *
621  * \brief
622  * Wrapper around bind(2) that uses struct ast_sockaddr.
623  *
624  * \details
625  * For parameter and return information, see the man page for
626  * bind(2).
627  */
628 int ast_bind(int sockfd, const struct ast_sockaddr *addr);
629
630 /*!
631  * \since 1.8
632  *
633  * \brief
634  * Wrapper around connect(2) that uses struct ast_sockaddr.
635  *
636  * \details
637  * For parameter and return information, see the man page for
638  * connect(2).
639  */
640 int ast_connect(int sockfd, const struct ast_sockaddr *addr);
641
642 /*!
643  * \since 1.8
644  *
645  * \brief
646  * Wrapper around getsockname(2) that uses struct ast_sockaddr.
647  *
648  * \details
649  * For parameter and return information, see the man page for
650  * getsockname(2).
651  */
652 int ast_getsockname(int sockfd, struct ast_sockaddr *addr);
653
654 /*!
655  * \since 1.8
656  *
657  * \brief
658  * Wrapper around recvfrom(2) that uses struct ast_sockaddr.
659  *
660  * \details
661  * For parameter and return information, see the man page for
662  * recvfrom(2).
663  */
664 ssize_t ast_recvfrom(int sockfd, void *buf, size_t len, int flags,
665                      struct ast_sockaddr *src_addr);
666
667 /*!
668  * \since 1.8
669  *
670  * \brief
671  * Wrapper around sendto(2) that uses ast_sockaddr.
672  *
673  * \details
674  * For parameter and
675  * return information, see the man page for sendto(2)
676  */
677 ssize_t ast_sendto(int sockfd, const void *buf, size_t len, int flags,
678                    const struct ast_sockaddr *dest_addr);
679
680 /*!
681  * \since 1.8
682  *
683  * \brief
684  * Set type of service
685  *
686  * \details
687  * Set ToS ("Type of Service for IPv4 and "Traffic Class for IPv6) and
688  * CoS (Linux's SO_PRIORITY)
689  *
690  * \param sockfd File descriptor for socket on which to set the parameters
691  * \param tos The type of service for the socket
692  * \param cos The cost of service for the socket
693  * \param desc A text description of the socket in question.
694  * \retval 0 Success
695  * \retval -1 Error, with errno set to an appropriate value
696  */
697 int ast_set_qos(int sockfd, int tos, int cos, const char *desc);
698
699 /*!
700  * These are backward compatibility functions that may be used by subsystems
701  * that have not yet been converted to IPv6. They will be removed when all
702  * subsystems are IPv6-ready.
703  */
704 /*@{*/
705
706 /*!
707  * \since 1.8
708  *
709  * \brief
710  * Converts a struct ast_sockaddr to a struct sockaddr_in.
711  *
712  * \param addr The ast_sockaddr to convert
713  * \param[out] sin The resulting sockaddr_in struct
714  * \retval nonzero Success
715  * \retval zero Failure
716  */
717 #define ast_sockaddr_to_sin(addr,sin)   _ast_sockaddr_to_sin(addr,sin, __FILE__, __LINE__, __PRETTY_FUNCTION__)
718 int _ast_sockaddr_to_sin(const struct ast_sockaddr *addr,
719                         struct sockaddr_in *sin, const char *file, int line, const char *func);
720
721 /*!
722  * \since 1.8
723  *
724  * \brief Converts a struct sockaddr_in to a struct ast_sockaddr.
725  *
726  * \param addr
727  * \param sin The sockaddr_in to convert
728  * \return an ast_sockaddr structure
729  */
730 #define ast_sockaddr_from_sin(addr,sin) _ast_sockaddr_from_sin(addr,sin, __FILE__, __LINE__, __PRETTY_FUNCTION__)
731 void _ast_sockaddr_from_sin(struct ast_sockaddr *addr, const struct sockaddr_in *sin,
732                 const char *file, int line, const char *func);
733
734 /*@}*/
735
736 #if defined(__cplusplus) || defined(c_plusplus)
737 }
738 #endif
739
740 #endif /* _ASTERISK_NETSOCK2_H */