Source: ext_socket.h


Annotated List
Files
Globals
Hierarchy
Index
/*
 *  $Id: ext__socket_h.html,v 1.4 2001/11/30 14:02:34 dreibh Exp $
 *
 * SCTP implementation according to RFC 2960.
 * Copyright (C) 1999-2001 by Thomas Dreibholz
 *
 * Realized in co-operation between Siemens AG
 * and University of Essen, Institute of Computer Networking Technology.
 *
 * 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.
 *
 * There are two mailinglists available at www.sctp.de which should be used for
 * any discussion related to this implementation.
 *
 * Contact: discussion@sctp.de
 *          dreibh@exp-math.uni-essen.de
 *
 * Purpose: Extended Socket API
 *
 */


#ifndef EXTSOCKET_H
#define EXTSOCKET_H


#ifndef HAVE_KERNEL_SCTP

#include <sys/socket.h>
#include <fcntl.h>
#include <inttypes.h>

#ifndef IPPROTO_SCTP
#define IPPROTO_SCTP 132
#endif

#if defined(__APPLE__)
 typedef int socklen_t;
#endif



#define MSG_UNORDERED    (1 << 31)
#define MSG_UNBUNDLED    (1 << 30)
#define MSG_ADDR_OVER    (1 << 29)
#define MSG_NOTIFICATION (1 << 28)
#define MSG_ABORT        (1 << 27)
#ifndef MSG_EOF
#define MSG_EOF          (1 << 26)
#endif
#define MSG_SHUTDOWN     MSG_EOF



typedef unsigned int   sctp_assoc_t;
typedef unsigned short sctp_stream_t;


#define SCTP_UNDEFINED 0

#define SCTP_INIT 1
struct sctp_initmsg {
   uint16_t sinit_num_ostreams;
   uint16_t sinit_max_instreams;
   uint16_t sinit_max_attempts;
   uint16_t sinit_max_init_timeo;
};

#define SCTP_SNDRCV 2
struct sctp_sndrcvinfo
{
   uint16_t     sinfo_stream;
   uint16_t     sinfo_ssn;
   // !!! 32 bits instead of 16 bits !!!
   uint32_t     sinfo_flags;
   uint32_t     sinfo_ppid;
   uint32_t     sinfo_context;
   sctp_assoc_t sinfo_assoc_id;
};




#define SCTP_ASSOC_CHANGE 1
struct sctp_assoc_change
{
   uint16_t     sac_type;
   uint16_t     sac_flags;
   uint32_t     sac_length;
   uint16_t     sac_state;
   uint16_t     sac_error;
   uint16_t     sac_outbound_streams;
   uint16_t     sac_inbound_streams;
   sctp_assoc_t sac_assoc_id;
};
#define COMMUNICATION_UP    11
#define COMMUNICATION_LOST  12
#define RESTART             13
#define SHUTDOWN_COMPLETE   14
#define CANT_START_ASSOC    15

#define SCTP_PEER_ADDR_CHANGE 2
struct sctp_paddr_change
{
    uint16_t                spc_type;
    uint16_t                spc_flags;
    uint32_t                spc_length;
    struct sockaddr_storage spc_aaddr;
    int                     spc_state;
    int                     spc_error;
};
#define ADDRESS_AVAILABLE   21
#define ADDRESS_UNREACHABLE 22
#define ADDRESS_REMOVED     23
#define ADDRESS_ADDED       24
#define ADDRESS_MADE_PRIM   25


#define SCTP_REMOTE_ERROR 3
struct sctp_remote_error
{
   uint16_t     sre_type;
   uint16_t     sre_flags;
   uint32_t     sre_length;
   uint16_t     sre_error;
   uint16_t     sre_len;
   sctp_assoc_t sre_assoc_id;
   uint8_t      sre_data[0];
};

#define SCTP_SEND_FAILED 4
struct sctp_send_failed
{
   uint16_t               ssf_type;
   uint16_t               ssf_flags;
   uint32_t               ssf_length;
   uint32_t               ssf_error;
   struct sctp_sndrcvinfo ssf_info;
   sctp_assoc_t           ssf_assoc_id;
   uint8_t                ssf_data[0];
};
#define SCTP_DATA_UNSENT 41
#define SCTP_DATA_SENT   42


#define SCTP_SHUTDOWN_EVENT 5
struct sctp_shutdown_event
{
   uint16_t     sse_type;
   uint16_t     sse_flags;
   uint32_t     sse_length;
   sctp_assoc_t sse_assoc_id;
};


#define SCTP_DATA_ARRIVE 6
#define SCTP_ARRIVE_UNORDERED (1 << 0)
struct sctp_data_arrive
{
   uint16_t      sda_type;
   uint16_t      sda_flags;
   uint32_t      sda_length;
   sctp_assoc_t  sda_assoc_id;
   sctp_stream_t sda_stream;
   uint32_t      sda_ppid;
   uint32_t      sda_bytes_arrived;
};


struct sctp_notification_header
{
   uint16_t snh_type;
   uint16_t snh_flags;
   uint32_t snh_length;
};


union sctp_notification {
   uint16_t                        sn_type;           /* Notification type. */
   struct sctp_assoc_change        sn_assoc_change;
   struct sctp_paddr_change        sn_paddr_change;
   struct sctp_remote_error        sn_remote_error;
   struct sctp_send_failed         sn_send_failed;
   struct sctp_shutdown_event      sn_shutdown_event;
   struct sctp_data_arrive         sn_data_arrive;
   struct sctp_notification_header sn_notification_header;
};





struct sctp_rtoinfo
{
   uint32_t     srto_initial;
   uint32_t     srto_max;
   uint32_t     srto_min;
   sctp_assoc_t srto_assoc_id;
};


struct sctp_assocparams
{
   uint16_t     sasoc_assocmaxrxt;
   sctp_assoc_t sasoc_assoc_id;
};


struct sctp_setprim
{
   struct sockaddr_storage ssp_addr;
   sctp_assoc_t            ssp_assoc_id;
};


struct sctp_setpeerprim
{
   struct sockaddr_storage sspp_addr;
   sctp_assoc_t            sspp_assoc_id;
};


struct sctp_paddrparams {
   struct sockaddr_storage spp_address;
   uint32_t                spp_hbinterval;
   uint16_t                spp_pathmaxrxt;
   sctp_assoc_t            spp_assoc_id;
};


struct sctp_paddrinfo {
   struct sockaddr_storage spinfo_address;
   int32_t         spinfo_state;
   uint32_t        spinfo_cwnd;
   uint32_t        spinfo_srtt;
   uint32_t        spinfo_rto;
   sctp_assoc_t    spinfo_assoc_id;
};


struct sctp_status
{
   int32_t               sstat_state;
   uint32_t              sstat_rwnd;
   uint16_t              sstat_unackdata;
   uint16_t              sstat_penddata;
   struct sctp_paddrinfo sstat_primary;
   sctp_assoc_t          sstat_assoc_id;
};


/*
   Already defined in sctp.h.
#define SCTP_CLOSED                     0
#define SCTP_COOKIE_WAIT                1
#define SCTP_COOKIE_ECHOED              2
#define SCTP_ESTABLISHED                3
#define SCTP_SHUTDOWN_PENDING           4
#define SCTP_SHUTDOWN_RECEIVED          5
#define SCTP_SHUTDOWN_SENT              6
#define SCTP_SHUTDOWNACK_SENT           7
*/
/*
#define SCTP_SHUTDOWN_ACK_SENT SCTP_SHUTDOWNACK_SENT
#define SCTP_BOUND             108
#define SCTP_LISTEN            109
*/



#define SCTP_RECVDATAIOEVNT        (1 << 31)
#define SCTP_RECVASSOCEVNT         (1 << 30)
#define SCTP_RECVPADDREVNT         (1 << 29)
#define SCTP_RECVPEERERR           (1 << 28)
#define SCTP_RECVSENDFAILEVNT      (1 << 27)
#define SCTP_RECVSHUTDOWNEVNT      (1 << 26)
#define SCTP_INITMSG               1000
#define SCTP_AUTOCLOSE             1001
#define SCTP_SET_PRIMARY_ADDR      1002
#define SCTP_SET_PEER_PRIMARY_ADDR 1003
#define SCTP_STATUS                1004
#define SCTP_NODELAY               1005
#define SCTP_RTOINFO               1006
#define SCTP_ASSOCRXTINFO          1007

#define SCTP_SET_PEER_ADDR_PARAMS  1100
#define SCTP_GET_PEER_ADDR_PARAMS  1101
#define SCTP_GET_PEER_ADDR_INFO    1102


#ifdef __cplusplus
extern "C" {
#endif

int ext_socket(int domain, int type, int protocol);
int ext_open(const char* pathname, int flags, mode_t mode);
int ext_creat(const char* pathname, mode_t mode);
int ext_bind(int sockfd, struct sockaddr* my_addr, socklen_t addrlen);
int ext_connect(int sockfd, const struct sockaddr* serv_addr,
               socklen_t addrlen);
int ext_listen(int s, int backlog);
int ext_accept(int s,  struct  sockaddr * addr,  socklen_t* addrlen);
int ext_shutdown(int s, int how);
int ext_close(int fd);
int ext_getsockname(int sockfd, struct sockaddr* name, socklen_t* namelen);
int ext_getpeername(int sockfd, struct sockaddr* name, socklen_t* namelen);
int ext_fcntl(int fd, int cmd, ...);
int ext_ioctl(int d, int request, const void* argp);
int ext_getsockopt(int sockfd, int level, int optname, void* optval, socklen_t* optlen);
int ext_setsockopt(int sockfd, int level, int optname, const void* optval, socklen_t optlen);
int ext_recv(int s, void* buf, size_t len, int flags);
int ext_recvfrom(int  s,  void * buf,  size_t len, int flags,
                struct sockaddr* from, socklen_t* fromlen);
int ext_recvmsg(int s, struct msghdr* msg, int flags);
int ext_send(int s, const void* msg, size_t len, int flags);
int ext_sendto(int s, const void* msg, size_t len, int flags,
              const struct sockaddr* to, socklen_t tolen);
int ext_sendmsg(int s, const struct msghdr* msg, int flags);
ssize_t ext_read(int fd, void* buf, size_t count);
ssize_t ext_write(int fd, const void* buf, size_t count);
int ext_select(int             n,
               fd_set*         readfds,
               fd_set*         writefds,
               fd_set*         exceptfds,
               struct timeval* timeout);
               
#if defined(__APPLE__)
#define POLLIN     0x001
#define POLLPRI    0x002
#define POLLOUT    0x004
#define POLLERR    0x008
#define POLLHUP    0x010

struct pollfd {
	int fd;	
  short int events;
  short int revents;
};
#endif

int ext_poll(struct pollfd* fdlist, long unsigned int count, int time);


// For internal usage only!
int ext_recvmsg2(int sockfd, struct msghdr* msg, int flags,
                 const int receiveNotifications);


#define SCTP_BINDX_ADD_ADDR 1
#define SCTP_BINDX_REM_ADDR 2

int ext_bindx(int                      sockfd,
             struct sockaddr_storage* addrs,
             int                      addrcnt,
             int                      flags);
#define sctp_bindx ext_bindx


int sctp_peeloff(int sockfd, sctp_assoc_t* id, struct sockaddr* addr, socklen_t* addrlen);

int sctp_getpaddrs(int sockfd, sctp_assoc_t id, struct sockaddr_storage** addrs);
void sctp_freepaddrs(struct sockaddr_storage* addrs);

int sctp_getladdrs(int sockfd, sctp_assoc_t id, struct sockaddr_storage** addrs);
void sctp_freeladdrs(struct sockaddr_storage* addrs);

int sctp_opt_info(int sd, sctp_assoc_t id, int opt, void* arg);


/**
  * Check, if SCTP support is available.
  *
  * @return true, if SCTP is available; false otherwise.
  */
int sctp_isavailable();


#ifdef __cplusplus
}
#endif


#else

#warning You have kernel SCTP! This file probably has to be updated to use it!

#define ext_socket(a,b,c) ::socket(a,b,c)
#define ext_bind(a,b,c) ::bind(a,b,c)
#define ext_bindx(a,b,c,d) ::bindx(a,b,c,d)
#define sctp_bindx ext_bindx
#define ext_connect(a,b,c) ::connect(a,b,c)
#define ext_listen(a,b) ::listen(a,b)
#define ext_accept(a,b,c) ::accept(a,b,c)
#define ext_shutdown(a,b) ::shutdown(a,b)
#define ext_close(a) ::close(a)
#define ext_getsockname(a,b,c) ::getsockname(a,b,c)
#define ext_getpeername(a,b,c) ::getpeername(a,b,c)
#define ext_fcntl(a,b,c) ::fcntl(a,b,c)
#define ext_ioctl(a,b,c) ::ioctl(a,b,c)
#define ext_getsockopt(a,b,c,d,e) ::getsockopt(a,b,c,d,e)
#define ext_setsockopt(a,b,c,d,e) ::setsockopt(a,b,c,d,e)
#define ext_recv(a,b,c,d) ::recv(a,b,c,d)
#define ext_recvfrom(a,b,c,d,e,f) ::recvfrom(a,b,c,d,e,f)
#define ext_recvmsg(a,b,c) ::recvmsg(a,b,c)
#define ext_send(a,b,c,d) ::send(a,b,c,d)
#define ext_sendto(a,b,c,d,e,f) ::sendto(a,b,c,d,e,f)
#define ext_sendmsg(a,b,c) ::sendmsg(a,b,c)
#define ext_read(a,b,c) ::read(a,b,c)
#define ext_write(a,b,c) ::write(a,b,c)
#define ext_select(a,b,c,d,e) ::select(a,b,c,d,e)
#define ext_poll(a,b,c,d,e) ::poll(a,b,c,d,e)

int bindx(int                      sockfd,
          struct sockaddr_storage* addrs,
          int                      addrcnt,
          int                      flags);

#endif


#define SCTP_MAXADDRESSES 20


#endif

Generated by: dreibh@kappes on Fri Nov 30 14:03:21 2001, using kdoc 2.0a53.