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