socket.h

Go to the documentation of this file.

#ifndef CTL_SOCKET_H
#define CTL_SOCKET_H

/*
 * Tinker with these a bit, find how big or small they should be
 * Generally, expect little input and much output, size buffers accordingly
 */
#ifndef MAX_SOCKETS
#define MAX_SOCKETS         1024    /* FD_SETSIZE */ /* How many sockets can be open and connected (thousands) */
#endif
#if !defined(FD_SETSIZE) || (FD_SETSIZE < MAX_SOCKETS)
#define FD_SETSIZE          MAX_SOCKETS
#endif

#ifdef WIN32
#include <winsock2.h>
#else
#include <netdb.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>
#include <errno.h>
typedef int SOCKET;
#endif
#ifndef RINGBUFF_H
#include "ctl/ringbuff.h"
#endif
#ifndef LL_H
#include "ctl/ll.h"
#endif
#ifndef CTL_MSTIME_H
#include "ctl/mstime.h"
#endif
#ifndef CTL_HEAP_H
#include "ctl/heap.h"
#endif

ppCPP(extern "C" {)

struct Socket;

typedef struct SockVTAB
{
    void (*ReadCycle)(struct Socket*);  
    void (*WriteCycle)(struct Socket*); 
    void (*Close)(struct Socket*);      
} SockVTAB;

typedef enum Socket_Type
{
    stUninitialized,    /* Socket is closed or uninitialized */
    stSendingFinal,     /* Socket is waiting for outbound data to close */
    stListener,         /* Socket is listening for incoming connections */
    stLogin,            /* Socket is handling a login */
    stUser,             /* Socket is handling a user */
    stClient,           /* Socket is handling a client connection */
    stRaw,              /* Socket is handling a raw connection */
} Socket_Type;

typedef struct Socket
{
    const SockVTAB* vtab; 
    Socket_Type     type; 
    char            label[32];  
    uint32          id;         
    SOCKET          socket;     
    mstime          created;    
    mstime          lastmsg;    
    mstime          timeout;    
    dll_decllink( struct Socket, active );  
    /*
     * Standard socket trivia
     * Everything we can glean from a socket at runtime
     */
    union 
    {
        struct  sockaddr        address;
        struct  sockaddr_in     ip;
        //struct    sockaddr_in6    ip6;
        uint8   socka_buff[64];
    };

    /*
     * Output buffering: Write to ring buffer and try to keep it clear
     * Reuse single, fixed buffer and stop writing if it's full.
     * Backed up packets are stored as straight serial spew for write.
     */
    uint8*          pOutput;    
    RingBuff        output;     
    /*
     * Input buffering: Only one input packet handled per app cycle
     * So, we only need to get size, and then current packet.
     * Read NEXT packet size, if available
     */
    uint8*          pInput;     
    RingBuff        input;      
    /*
     * Callbacks and data for application
     */
    uint8*          pAppHeap;   
    ctl_heap        appheap;    
    void (*appReceived)( struct Socket* sock, ctl_serial* serial );

    void (*appDisconnect)( struct Socket* sock);
} Socket;
#define Socket_ShouldIgnore(sock) ( (sock)->type <= stSendingFinal )


/*
 * Start up, shut down, operate networking subsystem
 */
bool SocketsInit( size_t input, size_t output, size_t heap );
void SocketsShutdown(void);
bool SocketsCycle( unsigned ms );
const char* SocketsLastErrorString(void);
void SocketsLogLastError( unsigned mask, const char*fmt, ... );
struct addrinfo *SocketsParseAddress( const char* szAddress );
void SocketsLogHostent( uint32 logmask, const char* name );
typedef void (*NewSocketCallback)( Socket* socket );
NewSocketCallback SocketsSetLogin( NewSocketCallback callback );
NewSocketCallback SocketsSetUser( NewSocketCallback callback );
typedef const char* (*MLCallback)(void);
MLCallback SocketsSetHTTP( MLCallback callback );
MLCallback SocketsSetFlashPolicy( MLCallback callback );

/*
 * Socket lookup information
 */
uint32 SocketID( const Socket* sock );
Socket* SocketLut( uint32 id );
Socket* SocketFind( const char* label );

/*
 * Convenient socket iterators
 */
dll_externlist(Socket,active, socksActive);
#define socket_foreach( sock )              dll_foreach(Socket,active, socksActive, sock ) 

#define socket_foreach_const( sock )        dll_foreach_const(Socket,active, socksActive, sock )

#define socket_foreach_deletable( sock )    dll_foreach_deletable(Socket,active, socksActive, sock )

#define socket_foreach_type( sock, stype )  dll_foreach_deletable(Socket,active, socksActive, sock ) if( sock->type == (stype) ) 

/*
 * Manufacture various connection types
 */
Socket* Socket_Create_Client( const char* address );
Socket* Socket_Create_Listener( const char* label, const char* address );
Socket* Socket_Create_Login( SOCKET isock );    /* SocketsSetLogin callback */
Socket* Socket_Create_User( Socket* sock, const char* label );  /* SocketsSetUser callback */
Socket* Socket_Create_Raw( Socket* sock );      /* SocketsSetUser callback */
void Socket_Close( Socket* sock );
Socket* Socket_Create(void);
Socket* Socket_Customize( Socket* sock, size_t input, size_t output, size_t heap );
void Socket_LogError( Socket* sock, unsigned mask, const char*fmt, ... );

#ifdef DEBUG
void Socket_Validate( Socket* sock );
#else
#define Socket_Validate(sock)
#endif

/*
 * Put things into output buffer
 */
bool Socket_Write( Socket* sock, const void* buff, size_t length );
bool Socket_Alloc_Serial( Socket* sock, ctl_serial* serial, size_t length );
bool Socket_Write_Serial( Socket* sock, const ctl_serial* serial );


#define IP_FORMAT               "%s:%u"
#define IP_ARGS_SOCK(sock)      inet_ntoa((sock)->ip.sin_addr), ntohs((sock)->ip.sin_port)
#define IP_ARGS_SADDR(saddr)    inet_ntoa(((struct sockaddr_in*)(saddr))->sin_addr), ntohs(((struct sockaddr_in*)(saddr))->sin_port)
#ifdef NDEBUG
#define traceip(msg,saddr)
#else
#define traceip(msg,saddr) trace(( msg IP_FORMAT "\n", IP_ARGS_SADDR(saddr) ))
#endif
#define SocketLogIP(sock,mask,msg) debug_log( (mask), msg IP_FORMAT " (%s)\n", IP_ARGS_SOCK(sock), (sock)->label )

ppCPP(})

#endif /* CTL_SOCKET_H */