fc3a0c005f0ca58816de5581bed130061d3535d4
[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  * \since 16.0
442  *
443  * \brief
444  * Return the first entry from ast_sockaddr_resolve filtered by address family
445  *
446  * \details
447  * Parses a string containing a host name or an IPv4 or IPv6 address followed
448  * by an optional port (separated by a colon).  This function only returns the
449  * first address into the ast_sockaddr. Allowed formats for name are the following:
450  *
451  * hostname:port
452  * host.example.com:port
453  * a.b.c.d
454  * a.b.c.d:port
455  * a:b:c:...:d
456  * [a:b:c:...:d]
457  * [a:b:c:...:d]:port
458  *
459  * \param[out] addr The resulting ast_sockaddr
460  * \param name The string to parse
461  * \param flags If set to zero, a port MAY be present. If set to
462  * PARSE_PORT_IGNORE, a port MAY be present but will be ignored. If set to
463  * PARSE_PORT_REQUIRE, a port MUST be present. If set to PARSE_PORT_FORBID, a
464  * port MUST NOT be present.
465  *
466  * \param family Only addresses of the given family will be returned. Use 0 or
467  * AST_AF_UNSPEC to specify any address family.  Behavior is ultimately determined
468  * by getaddrinfo in how it orders return results.  First result is selected to
469  * be returned.
470  *
471  * \retval 0 Success
472  * \retval non-zero Failure
473  * \warning Using this function potentially means you have a faulty design.
474  */
475 int ast_sockaddr_resolve_first_af(struct ast_sockaddr *addr,
476                                       const char* name, int flag, int family);
477
478 /*!
479  * \brief
480  * Apply a netmask to an address and store the result in a separate structure.
481  *
482  * When dealing with IPv6 addresses, one cannot apply a netmask with a simple
483  * logical AND operation.  Futhermore, the incoming address may be an IPv4
484  * address and needs to be mapped properly before attempting to apply a rule.
485  *
486  * \param addr The IP address to apply the mask to.
487  * \param netmask The netmask configured in the host access rule.
488  * \param result The resultant address after applying the netmask to the given address
489  * \retval 0 Successfully applied netmask
490  * \retval -1 Failed to apply netmask
491  */
492 int ast_sockaddr_apply_netmask(const struct ast_sockaddr *addr, const struct ast_sockaddr *netmask,
493                 struct ast_sockaddr *result);
494
495 /*!
496  * \since 1.8
497  *
498  * \brief
499  * Get the port number of a socket address.
500  *
501  * \warning Do not use this function unless you really know what you are doing.
502  * And "I want the port number" is not knowing what you are doing.
503  *
504  * \retval 0 Address is null
505  * \retval non-zero The port number of the ast_sockaddr
506  */
507 #define ast_sockaddr_port(addr) _ast_sockaddr_port(addr, __FILE__, __LINE__, __PRETTY_FUNCTION__)
508 uint16_t _ast_sockaddr_port(const struct ast_sockaddr *addr, const char *file, int line, const char *func);
509
510 /*!
511  * \since 1.8
512  *
513  * \brief
514  * Sets the port number of a socket address.
515  *
516  * \warning Do not use this function unless you really know what you are doing.
517  * And "I want the port number" is not knowing what you are doing.
518  *
519  * \param addr Address on which to set the port
520  * \param port The port you wish to set the address to use
521  * \retval void
522  */
523 #define ast_sockaddr_set_port(addr,port)        _ast_sockaddr_set_port(addr,port,__FILE__,__LINE__,__PRETTY_FUNCTION__)
524 void _ast_sockaddr_set_port(struct ast_sockaddr *addr, uint16_t port, const char *file, int line, const char *func);
525
526 /*!
527  * \since 1.8
528  *
529  * \brief
530  * Get an IPv4 address of an ast_sockaddr
531  *
532  * \warning You should rarely need this function. Only use if you know what
533  * you're doing.
534  * \return IPv4 address in network byte order
535  */
536 uint32_t ast_sockaddr_ipv4(const struct ast_sockaddr *addr);
537
538 /*!
539  * \since 1.8
540  *
541  * \brief
542  * Determine if the address is an IPv4 address
543  *
544  * \warning You should rarely need this function. Only use if you know what
545  * you're doing.
546  * \retval 1 This is an IPv4 address
547  * \retval 0 This is an IPv6 or IPv4-mapped IPv6 address
548  */
549 int ast_sockaddr_is_ipv4(const struct ast_sockaddr *addr);
550
551 /*!
552  * \since 1.8
553  *
554  * \brief
555  * Determine if this is an IPv4-mapped IPv6 address
556  *
557  * \warning You should rarely need this function. Only use if you know what
558  * you're doing.
559  *
560  * \retval 1 This is an IPv4-mapped IPv6 address.
561  * \retval 0 This is not an IPv4-mapped IPv6 address.
562  */
563 int ast_sockaddr_is_ipv4_mapped(const struct ast_sockaddr *addr);
564
565 /*!
566  * \since 10.0
567  *
568  * \brief
569  * Determine if an IPv4 address is a multicast address
570  *
571  * \param addr the address to check
572  *
573  * This function checks if an address is in the 224.0.0.0/4 network block.
574  *
575  * \return non-zero if this is a multicast address
576  */
577 int ast_sockaddr_is_ipv4_multicast(const struct ast_sockaddr *addr);
578
579 /*!
580  * \since 1.8
581  *
582  * \brief
583  * Determine if this is a link-local IPv6 address
584  *
585  * \warning You should rarely need this function. Only use if you know what
586  * you're doing.
587  *
588  * \retval 1 This is a link-local IPv6 address.
589  * \retval 0 This is link-local IPv6 address.
590  */
591 int ast_sockaddr_is_ipv6_link_local(const struct ast_sockaddr *addr);
592
593 /*!
594  * \since 1.8
595  *
596  * \brief
597  * Determine if this is an IPv6 address
598  *
599  * \warning You should rarely need this function. Only use if you know what
600  * you're doing.
601  *
602  * \retval 1 This is an IPv6 or IPv4-mapped IPv6 address.
603  * \retval 0 This is an IPv4 address.
604  */
605 int ast_sockaddr_is_ipv6(const struct ast_sockaddr *addr);
606
607 /*!
608  * \since 1.8
609  *
610  * \brief
611  * Determine if the address type is unspecified, or "any" address.
612  *
613  * \details
614  * For IPv4, this would be the address 0.0.0.0, and for IPv6,
615  * this would be the address ::. The port number is ignored.
616  *
617  * \retval 1 This is an "any" address
618  * \retval 0 This is not an "any" address
619  */
620 int ast_sockaddr_is_any(const struct ast_sockaddr *addr);
621
622 /*!
623  * \since 1.8
624  *
625  * \brief
626  * Computes a hash value from the address. The port is ignored.
627  *
628  * \retval 0 Unknown address family
629  * \retval other A 32-bit hash derived from the address
630  */
631 int ast_sockaddr_hash(const struct ast_sockaddr *addr);
632
633 /*!
634  * \since 12.3
635  *
636  * \brief
637  * Returns a string representation of an ast_transport
638  *
639  * \retval Name of the tranpsort if it is defined
640  * \retval Undefined if the transport is undefined
641  */
642 const char *ast_transport2str(enum ast_transport transport);
643
644 /*!
645  * \since 1.8
646  *
647  * \brief
648  * Wrapper around accept(2) that uses struct ast_sockaddr.
649  *
650  * \details
651  * For parameter and return information, see the man page for
652  * accept(2).
653  */
654 int ast_accept(int sockfd, struct ast_sockaddr *addr);
655
656 /*!
657  * \since 1.8
658  *
659  * \brief
660  * Wrapper around bind(2) that uses struct ast_sockaddr.
661  *
662  * \details
663  * For parameter and return information, see the man page for
664  * bind(2).
665  */
666 int ast_bind(int sockfd, const struct ast_sockaddr *addr);
667
668 /*!
669  * \since 1.8
670  *
671  * \brief
672  * Wrapper around connect(2) that uses struct ast_sockaddr.
673  *
674  * \details
675  * For parameter and return information, see the man page for
676  * connect(2).
677  */
678 int ast_connect(int sockfd, const struct ast_sockaddr *addr);
679
680 /*!
681  * \since 1.8
682  *
683  * \brief
684  * Wrapper around getsockname(2) that uses struct ast_sockaddr.
685  *
686  * \details
687  * For parameter and return information, see the man page for
688  * getsockname(2).
689  */
690 int ast_getsockname(int sockfd, struct ast_sockaddr *addr);
691
692 /*!
693  * \since 1.8
694  *
695  * \brief
696  * Wrapper around recvfrom(2) that uses struct ast_sockaddr.
697  *
698  * \details
699  * For parameter and return information, see the man page for
700  * recvfrom(2).
701  */
702 ssize_t ast_recvfrom(int sockfd, void *buf, size_t len, int flags,
703                      struct ast_sockaddr *src_addr);
704
705 /*!
706  * \since 1.8
707  *
708  * \brief
709  * Wrapper around sendto(2) that uses ast_sockaddr.
710  *
711  * \details
712  * For parameter and
713  * return information, see the man page for sendto(2)
714  */
715 ssize_t ast_sendto(int sockfd, const void *buf, size_t len, int flags,
716                    const struct ast_sockaddr *dest_addr);
717
718 /*!
719  * \since 1.8
720  *
721  * \brief
722  * Set type of service
723  *
724  * \details
725  * Set ToS ("Type of Service for IPv4 and "Traffic Class for IPv6) and
726  * CoS (Linux's SO_PRIORITY)
727  *
728  * \param sockfd File descriptor for socket on which to set the parameters
729  * \param tos The type of service for the socket
730  * \param cos The cost of service for the socket
731  * \param desc A text description of the socket in question.
732  * \retval 0 Success
733  * \retval -1 Error, with errno set to an appropriate value
734  */
735 int ast_set_qos(int sockfd, int tos, int cos, const char *desc);
736
737 /*!
738  * These are backward compatibility functions that may be used by subsystems
739  * that have not yet been converted to IPv6. They will be removed when all
740  * subsystems are IPv6-ready.
741  */
742 /*@{*/
743
744 /*!
745  * \since 1.8
746  *
747  * \brief
748  * Converts a struct ast_sockaddr to a struct sockaddr_in.
749  *
750  * \param addr The ast_sockaddr to convert
751  * \param[out] sin The resulting sockaddr_in struct
752  * \retval nonzero Success
753  * \retval zero Failure
754  */
755 #define ast_sockaddr_to_sin(addr,sin)   _ast_sockaddr_to_sin(addr,sin, __FILE__, __LINE__, __PRETTY_FUNCTION__)
756 int _ast_sockaddr_to_sin(const struct ast_sockaddr *addr,
757                         struct sockaddr_in *sin, const char *file, int line, const char *func);
758
759 /*!
760  * \since 1.8
761  *
762  * \brief Converts a struct sockaddr_in to a struct ast_sockaddr.
763  *
764  * \param addr
765  * \param sin The sockaddr_in to convert
766  * \return an ast_sockaddr structure
767  */
768 #define ast_sockaddr_from_sin(addr,sin) _ast_sockaddr_from_sin(addr,sin, __FILE__, __LINE__, __PRETTY_FUNCTION__)
769 void _ast_sockaddr_from_sin(struct ast_sockaddr *addr, const struct sockaddr_in *sin,
770                 const char *file, int line, const char *func);
771
772 /*@}*/
773
774 #if defined(__cplusplus) || defined(c_plusplus)
775 }
776 #endif
777
778 #endif /* _ASTERISK_NETSOCK2_H */