sock.h

Go to the documentation of this file.

/* $Id$ */
/* 
 * 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 http://trac.pjsip.org/repos/ticket/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
{
    /* The number of options to be applied. */
    unsigned cnt;

    /* Array of options to be applied. */
    struct {
        /* The level at which the option is defined. */
        int level;

        /* Option name. */
        int optname;

        /* Pointer to the buffer in which the option is specified. */
        void *optval;

        /* Buffer size of the buffer pointed by 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);

/*
 * If the source's and desired address family matches, copy the address,
 * otherwise synthesize a new address with the desired address family,
 * from the source address. This can be useful to generate an IPv4-mapped
 * IPv6 address.
 *
 * @param dst_af    Desired address family.
 * @param dst       Destination socket address, invalid if synthesis is
 *                  required and failed.
 * @param src       Source socket address.
 *
 * @return          PJ_SUCCESS on success, or the error status
 *                  if synthesis is required and failed.
 */
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_END_DECL

#endif  /* __PJ_SOCK_H__ */