sock.h

Go to the documentation of this file.

/* 
 * Copyright (C) 2008-2011 Teluu Inc. (http://www.teluu.com)
 * Copyright (C) 2003-2008 Benny Prijono <benny@prijono.org>
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA 
 */
#ifndef __PJ_SOCK_H__
#define __PJ_SOCK_H__
 
#include <pj/types.h>
#include <pj/compat/socket.h>
 
PJ_BEGIN_DECL 
 
 
extern const pj_uint16_t PJ_AF_UNSPEC;
 
extern const pj_uint16_t PJ_AF_UNIX;
 
#define PJ_AF_LOCAL      PJ_AF_UNIX;
 
extern const pj_uint16_t PJ_AF_INET;
 
extern const pj_uint16_t PJ_AF_INET6;
 
extern const pj_uint16_t PJ_AF_PACKET;
 
extern const pj_uint16_t PJ_AF_IRDA;
 
/*
 * Accessor functions for various address family constants. These
 * functions are provided because Symbian doesn't allow exporting
 * global variables from a DLL.
 */
 
#if defined(PJ_DLL)
    PJ_DECL(pj_uint16_t) pj_AF_UNSPEC(void);
    PJ_DECL(pj_uint16_t) pj_AF_UNIX(void);
    PJ_DECL(pj_uint16_t) pj_AF_INET(void);
    PJ_DECL(pj_uint16_t) pj_AF_INET6(void);
    PJ_DECL(pj_uint16_t) pj_AF_PACKET(void);
    PJ_DECL(pj_uint16_t) pj_AF_IRDA(void);
#else
    /* When pjlib is not built as DLL, these accessor functions are
     * simply a macro to get their constants
     */
#   define pj_AF_UNSPEC()   PJ_AF_UNSPEC
#   define pj_AF_UNIX()     PJ_AF_UNIX
#   define pj_AF_INET()     PJ_AF_INET
#   define pj_AF_INET6()    PJ_AF_INET6
#   define pj_AF_PACKET()   PJ_AF_PACKET
#   define pj_AF_IRDA()     PJ_AF_IRDA
#endif
 
 
extern const pj_uint16_t PJ_SOCK_STREAM;
 
extern const pj_uint16_t PJ_SOCK_DGRAM;
 
extern const pj_uint16_t PJ_SOCK_RAW;
 
extern const pj_uint16_t PJ_SOCK_RDM;
 
 
/*
 * Accessor functions for various constants. These functions are provided
 * because Symbian doesn't allow exporting global variables from a DLL.
 */
 
#if defined(PJ_DLL)
    PJ_DECL(int) pj_SOCK_STREAM(void);
    PJ_DECL(int) pj_SOCK_DGRAM(void);
    PJ_DECL(int) pj_SOCK_RAW(void);
    PJ_DECL(int) pj_SOCK_RDM(void);
#else
#   define pj_SOCK_STREAM() PJ_SOCK_STREAM
#   define pj_SOCK_DGRAM()  PJ_SOCK_DGRAM
#   define pj_SOCK_RAW()    PJ_SOCK_RAW
#   define pj_SOCK_RDM()    PJ_SOCK_RDM
#endif
 
 
extern const pj_uint16_t PJ_SOL_SOCKET;
extern const pj_uint16_t PJ_SOL_IP;
extern const pj_uint16_t PJ_SOL_TCP;
extern const pj_uint16_t PJ_SOL_UDP;
extern const pj_uint16_t PJ_SOL_IPV6;
 
/*
 * Accessor functions for various constants. These functions are provided
 * because Symbian doesn't allow exporting global variables from a DLL.
 */
 
#if defined(PJ_DLL)
    PJ_DECL(pj_uint16_t) pj_SOL_SOCKET(void);
    PJ_DECL(pj_uint16_t) pj_SOL_IP(void);
    PJ_DECL(pj_uint16_t) pj_SOL_TCP(void);
    PJ_DECL(pj_uint16_t) pj_SOL_UDP(void);
    PJ_DECL(pj_uint16_t) pj_SOL_IPV6(void);
#else
#   define pj_SOL_SOCKET()  PJ_SOL_SOCKET
#   define pj_SOL_IP()      PJ_SOL_IP
#   define pj_SOL_TCP()     PJ_SOL_TCP
#   define pj_SOL_UDP()     PJ_SOL_UDP
#   define pj_SOL_IPV6()    PJ_SOL_IPV6
#endif
 
 
/* IP_TOS 
 *
 * Note:
 *  TOS CURRENTLY DOES NOT WORK IN Windows 2000 and above!
 *  See http://support.microsoft.com/kb/248611
 */
extern const pj_uint16_t PJ_IP_TOS;
 
/*
 * IP TOS related constats.
 *
 * Note:
 *  TOS CURRENTLY DOES NOT WORK IN Windows 2000 and above!
 *  See http://support.microsoft.com/kb/248611
 */
extern const pj_uint16_t PJ_IPTOS_LOWDELAY;
 
extern const pj_uint16_t PJ_IPTOS_THROUGHPUT;
 
extern const pj_uint16_t PJ_IPTOS_RELIABILITY;
 
extern const pj_uint16_t PJ_IPTOS_MINCOST;
 
 
#if defined(PJ_DLL)
    PJ_DECL(int) pj_IP_TOS(void);
 
    PJ_DECL(int) pj_IPTOS_LOWDELAY(void);
 
    PJ_DECL(int) pj_IPTOS_THROUGHPUT(void);
 
    PJ_DECL(int) pj_IPTOS_RELIABILITY(void);
 
    PJ_DECL(int) pj_IPTOS_MINCOST(void);
#else
#   define pj_IP_TOS()          PJ_IP_TOS
 
#   define pj_IPTOS_LOWDELAY()  PJ_IP_TOS_LOWDELAY
 
#   define pj_IPTOS_THROUGHPUT() PJ_IP_TOS_THROUGHPUT
 
#   define pj_IPTOS_RELIABILITY() PJ_IP_TOS_RELIABILITY
 
#   define pj_IPTOS_MINCOST()   PJ_IP_TOS_MINCOST
#endif
 
 
extern const pj_uint16_t PJ_IPV6_TCLASS;
 
 
#if defined(PJ_DLL)
    PJ_DECL(int) pj_IPV6_TCLASS(void);
#else
#   define pj_IPV6_TCLASS()     PJ_IPV6_TCLASS
#endif
 
 
extern const pj_uint16_t PJ_SO_TYPE;
 
extern const pj_uint16_t PJ_SO_RCVBUF;
 
extern const pj_uint16_t PJ_SO_SNDBUF;
 
extern const pj_uint16_t PJ_TCP_NODELAY;
 
extern const pj_uint16_t PJ_SO_REUSEADDR;
 
extern const pj_uint16_t PJ_SO_NOSIGPIPE;
 
extern const pj_uint16_t PJ_SO_PRIORITY;
 
extern const pj_uint16_t PJ_IP_MULTICAST_IF;
 
extern const pj_uint16_t PJ_IP_MULTICAST_TTL;
 
extern const pj_uint16_t PJ_IP_MULTICAST_LOOP;
 
extern const pj_uint16_t PJ_IP_ADD_MEMBERSHIP;
 
extern const pj_uint16_t PJ_IP_DROP_MEMBERSHIP;
 
 
#if defined(PJ_DLL)
    PJ_DECL(pj_uint16_t) pj_SO_TYPE(void);
 
    PJ_DECL(pj_uint16_t) pj_SO_RCVBUF(void);
 
    PJ_DECL(pj_uint16_t) pj_SO_SNDBUF(void);
 
    PJ_DECL(pj_uint16_t) pj_TCP_NODELAY(void);
 
    PJ_DECL(pj_uint16_t) pj_SO_REUSEADDR(void);
 
    PJ_DECL(pj_uint16_t) pj_SO_NOSIGPIPE(void);
 
    PJ_DECL(pj_uint16_t) pj_SO_PRIORITY(void);
 
    PJ_DECL(pj_uint16_t) pj_IP_MULTICAST_IF(void);
 
    PJ_DECL(pj_uint16_t) pj_IP_MULTICAST_TTL(void);
 
    PJ_DECL(pj_uint16_t) pj_IP_MULTICAST_LOOP(void);
 
    PJ_DECL(pj_uint16_t) pj_IP_ADD_MEMBERSHIP(void);
 
    PJ_DECL(pj_uint16_t) pj_IP_DROP_MEMBERSHIP(void);
#else
#   define pj_SO_TYPE()     PJ_SO_TYPE
 
#   define pj_SO_RCVBUF()   PJ_SO_RCVBUF
 
#   define pj_SO_SNDBUF()   PJ_SO_SNDBUF
 
#   define pj_TCP_NODELAY() PJ_TCP_NODELAY
 
#   define pj_SO_REUSEADDR() PJ_SO_REUSEADDR
 
#   define pj_SO_NOSIGPIPE() PJ_SO_NOSIGPIPE
 
#   define pj_SO_PRIORITY() PJ_SO_PRIORITY
 
#   define pj_IP_MULTICAST_IF()    PJ_IP_MULTICAST_IF
 
#   define pj_IP_MULTICAST_TTL()   PJ_IP_MULTICAST_TTL
 
#   define pj_IP_MULTICAST_LOOP()  PJ_IP_MULTICAST_LOOP
 
#   define pj_IP_ADD_MEMBERSHIP()  PJ_IP_ADD_MEMBERSHIP
 
#   define pj_IP_DROP_MEMBERSHIP() PJ_IP_DROP_MEMBERSHIP
#endif
 
 
/*
 * Flags to be specified in #pj_sock_recv, #pj_sock_send, etc.
 */
 
extern const int PJ_MSG_OOB;
 
extern const int PJ_MSG_PEEK;
 
extern const int PJ_MSG_DONTROUTE;
 
 
#if defined(PJ_DLL)
    PJ_DECL(int) pj_MSG_OOB(void);
 
    PJ_DECL(int) pj_MSG_PEEK(void);
 
    PJ_DECL(int) pj_MSG_DONTROUTE(void);
#else
#   define pj_MSG_OOB()         PJ_MSG_OOB
 
#   define pj_MSG_PEEK()        PJ_MSG_PEEK
 
#   define pj_MSG_DONTROUTE()   PJ_MSG_DONTROUTE
#endif
 
 
typedef enum pj_socket_sd_type
{
    PJ_SD_RECEIVE   = 0,    
    PJ_SHUT_RD      = 0,    
    PJ_SD_SEND      = 1,    
    PJ_SHUT_WR      = 1,    
    PJ_SD_BOTH      = 2,    
    PJ_SHUT_RDWR    = 2     
} pj_socket_sd_type;
 
 
 
#define PJ_INADDR_ANY       ((pj_uint32_t)0)
 
#define PJ_INADDR_NONE      ((pj_uint32_t)0xffffffff)
 
#define PJ_INADDR_BROADCAST ((pj_uint32_t)0xffffffff)
 
 
#if !defined(PJ_SOMAXCONN)
#  define PJ_SOMAXCONN  5
#endif
 
 
#define PJ_INVALID_SOCKET   (-1)
 
/* Undefining UNIX standard library macro such as s_addr is not
 * recommended as it may cause build issues for anyone who uses
 * the macro. See #2311 for more details.
 */
#if 0
/* Must undefine s_addr because of pj_in_addr below */
#undef s_addr
 
typedef struct pj_in_addr
{
    pj_uint32_t s_addr;         
} pj_in_addr;
 
#else
typedef struct in_addr pj_in_addr;
#endif
 
#define PJ_INET_ADDRSTRLEN      16
 
#define PJ_INET6_ADDRSTRLEN     46
 
#ifndef PJ_SOCKADDR_IN_SIN_ZERO_LEN
#   define PJ_SOCKADDR_IN_SIN_ZERO_LEN  8
#endif
 
struct pj_sockaddr_in
{
#if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
    pj_uint8_t  sin_zero_len;   
    pj_uint8_t  sin_family;     
#else
    pj_uint16_t sin_family;     
#endif
    pj_uint16_t sin_port;       
    pj_in_addr  sin_addr;       
    char        sin_zero_pad[PJ_SOCKADDR_IN_SIN_ZERO_LEN]; 
};
 
 
/* Undefining C standard library macro such as s6_addr is not
 * recommended as it may cause build issues for anyone who uses
 * the macro. See #2311 for more details.
 */
#if 0
#undef s6_addr
 
typedef union pj_in6_addr
{
    /* This is the main entry */
    pj_uint8_t  s6_addr[16];   
    /* While these are used for proper alignment */
    pj_uint32_t u6_addr32[4];
 
    /* Do not use this with Winsock2, as this will align pj_sockaddr_in6
     * to 64-bit boundary and Winsock2 doesn't like it!
     * Update 26/04/2010:
     *  This is now disabled, see https://github.com/pjsip/pjproject/issues/1058
     */
#if 0 && defined(PJ_HAS_INT64) && PJ_HAS_INT64!=0 && \
    (!defined(PJ_WIN32) || PJ_WIN32==0)
    pj_int64_t  u6_addr64[2];
#endif
 
} pj_in6_addr;
#else
typedef struct in6_addr pj_in6_addr;
#endif
 
 
#define PJ_IN6ADDR_ANY_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0 } } }
 
#define PJ_IN6ADDR_LOOPBACK_INIT { { { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,1 } } }
 
typedef struct pj_sockaddr_in6
{
#if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
    pj_uint8_t  sin6_zero_len;      
    pj_uint8_t  sin6_family;        
#else
    pj_uint16_t sin6_family;        
#endif
    pj_uint16_t sin6_port;          
    pj_uint32_t sin6_flowinfo;      
    pj_in6_addr sin6_addr;          
    pj_uint32_t sin6_scope_id;      
} pj_sockaddr_in6;
 
 
typedef struct pj_addr_hdr
{
#if defined(PJ_SOCKADDR_HAS_LEN) && PJ_SOCKADDR_HAS_LEN!=0
    pj_uint8_t  sa_zero_len;
    pj_uint8_t  sa_family;
#else
    pj_uint16_t sa_family;      
#endif
} pj_addr_hdr;
 
 
typedef union pj_sockaddr
{
    pj_addr_hdr     addr;       
    pj_sockaddr_in  ipv4;       
    pj_sockaddr_in6 ipv6;       
} pj_sockaddr;
 
 
typedef struct pj_ip_mreq {
    pj_in_addr imr_multiaddr;   
    pj_in_addr imr_interface;   
} pj_ip_mreq;
 
 
typedef struct pj_sockopt_params
{
    unsigned cnt;
 
    struct {
        int level;
 
        int optname;
 
        void *optval;
 
        int optlen;
    } options[PJ_MAX_SOCKOPT_PARAMS];
} pj_sockopt_params;
 
/*****************************************************************************
 *
 * SOCKET ADDRESS MANIPULATION.
 *
 *****************************************************************************
 */
 
PJ_DECL(pj_uint16_t) pj_ntohs(pj_uint16_t netshort);
 
PJ_DECL(pj_uint16_t) pj_htons(pj_uint16_t hostshort);
 
PJ_DECL(pj_uint32_t) pj_ntohl(pj_uint32_t netlong);
 
PJ_DECL(pj_uint32_t) pj_htonl(pj_uint32_t hostlong);
 
PJ_DECL(char*) pj_inet_ntoa(pj_in_addr inaddr);
 
PJ_DECL(int) pj_inet_aton(const pj_str_t *cp, pj_in_addr *inp);
 
PJ_DECL(pj_status_t) pj_inet_pton(int af, const pj_str_t *src, void *dst);
 
PJ_DECL(pj_status_t) pj_inet_ntop(int af, const void *src,
                                  char *dst, int size);
 
PJ_DECL(char*) pj_inet_ntop2(int af, const void *src,
                             char *dst, int size);
 
PJ_DECL(char*) pj_sockaddr_print(const pj_sockaddr_t *addr,
                                 char *buf, int size,
                                 unsigned flags);
 
PJ_DECL(pj_in_addr) pj_inet_addr(const pj_str_t *cp);
 
PJ_DECL(pj_in_addr) pj_inet_addr2(const char *cp);
 
PJ_DECL(pj_status_t) pj_sockaddr_in_init( pj_sockaddr_in *addr,
                                          const pj_str_t *cp,
                                          pj_uint16_t port);
 
PJ_DECL(pj_status_t) pj_sockaddr_init(int af, 
                                      pj_sockaddr *addr,
                                      const pj_str_t *cp,
                                      pj_uint16_t port);
 
PJ_DECL(int) pj_sockaddr_cmp(const pj_sockaddr_t *addr1,
                             const pj_sockaddr_t *addr2);
 
PJ_DECL(void*) pj_sockaddr_get_addr(const pj_sockaddr_t *addr);
 
PJ_DECL(pj_bool_t) pj_sockaddr_has_addr(const pj_sockaddr_t *addr);
 
PJ_DECL(unsigned) pj_sockaddr_get_addr_len(const pj_sockaddr_t *addr);
 
PJ_DECL(unsigned) pj_sockaddr_get_len(const pj_sockaddr_t *addr);
 
PJ_DECL(void) pj_sockaddr_copy_addr(pj_sockaddr *dst,
                                    const pj_sockaddr *src);
PJ_DECL(void) pj_sockaddr_cp(pj_sockaddr_t *dst, const pj_sockaddr_t *src);
 
PJ_DECL(pj_status_t) pj_sockaddr_synthesize(int dst_af,
                                            pj_sockaddr_t *dst,
                                            const pj_sockaddr_t *src);
 
PJ_DECL(pj_in_addr) pj_sockaddr_in_get_addr(const pj_sockaddr_in *addr);
 
PJ_DECL(void) pj_sockaddr_in_set_addr(pj_sockaddr_in *addr,
                                      pj_uint32_t hostaddr);
 
PJ_DECL(pj_status_t) pj_sockaddr_in_set_str_addr( pj_sockaddr_in *addr,
                                                  const pj_str_t *cp);
 
PJ_DECL(pj_status_t) pj_sockaddr_set_str_addr(int af,
                                              pj_sockaddr *addr,
                                              const pj_str_t *cp);
 
PJ_DECL(pj_uint16_t) pj_sockaddr_get_port(const pj_sockaddr_t *addr);
 
PJ_DECL(pj_uint16_t) pj_sockaddr_in_get_port(const pj_sockaddr_in *addr);
 
PJ_DECL(pj_status_t) pj_sockaddr_set_port(pj_sockaddr *addr, 
                                          pj_uint16_t hostport);
 
PJ_DECL(void) pj_sockaddr_in_set_port(pj_sockaddr_in *addr, 
                                      pj_uint16_t hostport);
 
PJ_DECL(pj_status_t) pj_sockaddr_parse(int af, unsigned options,
                                       const pj_str_t *str,
                                       pj_sockaddr *addr);
 
PJ_DECL(pj_status_t) pj_sockaddr_parse2(int af, unsigned options,
                                        const pj_str_t *str,
                                        pj_str_t *hostpart,
                                        pj_uint16_t *port,
                                        int *raf);
 
/*****************************************************************************
 *
 * HOST NAME AND ADDRESS.
 *
 *****************************************************************************
 */
 
PJ_DECL(const pj_str_t*) pj_gethostname(void);
 
PJ_DECL(pj_in_addr) pj_gethostaddr(void);
 
 
/*****************************************************************************
 *
 * SOCKET API.
 *
 *****************************************************************************
 */
 
PJ_DECL(pj_status_t) pj_sock_socket(int family, 
                                    int type, 
                                    int protocol,
                                    pj_sock_t *sock);
 
PJ_DECL(pj_status_t) pj_sock_close(pj_sock_t sockfd);
 
 
PJ_DECL(pj_status_t) pj_sock_bind( pj_sock_t sockfd, 
                                   const pj_sockaddr_t *my_addr,
                                   int addrlen);
 
PJ_DECL(pj_status_t) pj_sock_bind_in( pj_sock_t sockfd, 
                                      pj_uint32_t addr,
                                      pj_uint16_t port);
 
PJ_DECL(pj_status_t) pj_sock_bind_random( pj_sock_t sockfd,
                                          const pj_sockaddr_t *addr,
                                          pj_uint16_t port_range,
                                          pj_uint16_t max_try);
 
#if PJ_HAS_TCP
PJ_DECL(pj_status_t) pj_sock_listen( pj_sock_t sockfd, 
                                     int backlog );
 
PJ_DECL(pj_status_t) pj_sock_accept( pj_sock_t serverfd,
                                     pj_sock_t *newsock,
                                     pj_sockaddr_t *addr,
                                     int *addrlen);
#endif
 
PJ_DECL(pj_status_t) pj_sock_connect( pj_sock_t sockfd,
                                      const pj_sockaddr_t *serv_addr,
                                      int addrlen);
 
PJ_DECL(pj_status_t) pj_sock_getpeername(pj_sock_t sockfd,
                                          pj_sockaddr_t *addr,
                                          int *namelen);
 
PJ_DECL(pj_status_t) pj_sock_getsockname( pj_sock_t sockfd,
                                          pj_sockaddr_t *addr,
                                          int *namelen);
 
PJ_DECL(pj_status_t) pj_sock_getsockopt( pj_sock_t sockfd,
                                         pj_uint16_t level,
                                         pj_uint16_t optname,
                                         void *optval,
                                         int *optlen);
PJ_DECL(pj_status_t) pj_sock_setsockopt( pj_sock_t sockfd,
                                         pj_uint16_t level,
                                         pj_uint16_t optname,
                                         const void *optval,
                                         int optlen);
 
PJ_DECL(pj_status_t) pj_sock_setsockopt_params( pj_sock_t sockfd,
                                               const pj_sockopt_params *params);                                               
 
PJ_DECL(pj_status_t) pj_sock_setsockopt_sobuf( pj_sock_t sockfd,
                                               pj_uint16_t optname,
                                               pj_bool_t auto_retry,
                                               unsigned *buf_size);
 
 
PJ_DECL(pj_status_t) pj_sock_recv(pj_sock_t sockfd,
                                  void *buf,
                                  pj_ssize_t *len,
                                  unsigned flags);
 
PJ_DECL(pj_status_t) pj_sock_recvfrom( pj_sock_t sockfd,
                                      void *buf,
                                      pj_ssize_t *len,
                                      unsigned flags,
                                      pj_sockaddr_t *from,
                                      int *fromlen);
 
PJ_DECL(pj_status_t) pj_sock_send(pj_sock_t sockfd,
                                  const void *buf,
                                  pj_ssize_t *len,
                                  unsigned flags);
 
PJ_DECL(pj_status_t) pj_sock_sendto(pj_sock_t sockfd,
                                    const void *buf,
                                    pj_ssize_t *len,
                                    unsigned flags,
                                    const pj_sockaddr_t *to,
                                    int tolen);
 
#if PJ_HAS_TCP
PJ_DECL(pj_status_t) pj_sock_shutdown( pj_sock_t sockfd,
                                       int how);
#endif
 
/*****************************************************************************
 *
 * Utilities.
 *
 *****************************************************************************
 */
 
PJ_DECL(char *) pj_addr_str_print( const pj_str_t *host_str, int port, 
                                   char *buf, int size, unsigned flag);
 
PJ_DECL(pj_status_t) pj_sock_socketpair(int family,
                                        int type,
                                        int protocol,
                                        pj_sock_t sv[2]);
 
PJ_END_DECL
 
#endif  /* __PJ_SOCK_H__ */