socket.c File Reference

Single-Threaded Socket Server implementation. More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include "ctl/ctldef.h"
#include "ctl/pool.h"
#include "ctl/ctlnew.h"
#include "ctl/socket.h"
#include <fcntl.h>
#include <stropts.h>

Include dependency graph for socket.c:

Go to the source code of this file.

Functions
uint32	SocketID (const Socket *sock)
	Get a socket ID from its pointer.
Socket *	SocketLut (uint32 id)
	Get a socket pointer from its ID.
Socket *	SocketFind (const char *label)
	Get a socket pointer from its label Will only find the first one, if several are named the same. Linear search; don't use it in inner loops and such.
NewSocketCallback	SocketsSetLogin (NewSocketCallback callback)
	Set a callback handler for new login socket creation.
NewSocketCallback	SocketsSetUser (NewSocketCallback callback)
	Set a callback handler for new user socket creation.
bool	SocketsInit (size_t input, size_t output, size_t heap)
	Start up sockets connections.
void	SocketsShutdown (void)
	Shut down sockets connections.
bool	SocketsCycle (unsigned ms)
	Sockets heartbeat.
const char *	SocketsLastErrorString (void)
	Retrieve the system error message for the last-error code.
void	SocketsLogLastError (unsigned mask, const char *fmt,...)
	Log information about socket errors.
struct addrinfo *	SocketsParseAddress (const char *szAddress)
void	SocketsLogHostent (uint32 logmask, const char *name)
	Tell us about an address we're running on.
Socket *	Socket_Create_Client (const char *address)
Socket *	Socket_Create_Listener (const char *label, const char *address)
	Make a listener. You'll need to make at least one to accept connections.
MLCallback	SocketsSetHTTP (MLCallback callback)
	Setup what to tell web browsers that hit this server.
MLCallback	SocketsSetFlashPolicy (MLCallback callback)
	Setup what to tell Flash clients that they can connect.
Socket *	Socket_Create_Login (SOCKET isock)
	Make a Login handler from an accepted connection Should filter various kinds of 'bad' connections and hang up before making an appropriate user connection.
Socket *	Socket_Create_User (Socket *sock, const char *label)
	Initialize a user connection from Login.
const uint8 *	Socket_Raw_Consume (Socket *sock, size_t size)
	After receiving 'appReceived' callback from Raw socket, call this to consume some of the input data CAUTION: If this is not a RAW socket, you'll most likely bugger it.
Socket *	Socket_Create_Raw (Socket *sock)
	Initialize a RAW connection.
Socket *	Socket_Create (void)
	Allocate, initialize and register a new socket.
Socket *	Socket_Customize (Socket *sock, size_t input, size_t output, size_t heap)
	Allow default buffering to be modified for special cases.
void	Socket_LogError (Socket *sock, unsigned mask, const char *fmt,...)
	Log information about a naughty socket after an error is detected.
void	Socket_Close (Socket *sock)
	Mark a socket for cleanup.
bool	Socket_Write (Socket *sock, const void *buff, size_t count)
	Write some raw data into the output queue.
bool	Socket_Alloc_Serial (Socket *sock, ctl_serial *serial, size_t size)
	Allocate space for serial packet in output buffer to write into, put size and id on it.
bool	Socket_Write_Serial (Socket *sock, const ctl_serial *serial)
	Write a fully formed and filled-in serial packet into output buffer; ignores 'curr'.

---

Detailed Description

Single-Threaded Socket Server implementation.

Author:

David Mace Implement lightweight socket handling with minimal dynamic memory use at runtime. That which is not allocated, can not leak. Data is read into buffers in such a way that it is seldom moved around.

NOT MULTITHREADED. This implements a single-threaded server solution because it's much easier and more efficient to build multi-player game projects on a single thread. There is generally too much inter-related data to work with in a multithreaded game environment. You spend all your time locking and unlocking things, and virtually all the threads end up blocked to the point where it IS single-threaded. You're far better off with one select loop, breaking down time-consuming operations, and moving file operations to external processes (i.e. another server).

Ultimately this will have a very slim web server (pseudo-web server) with just enough brains to serve certain cached files back at web browsers and Flash.

This will allow a single lightweight server to 'do everything' through one HTTP socket, with all of the things you'd typically expect to 'script' being hard-coded into the the server in C. You can use dynamically linked code (.so/.dll) to 'customize', but either way, it's a make, and too many people make their code complicated enough to fail by trying to add too many dynamically configurable things in an attempt not to compile and test. As if you didn't need to test your scripted code. KISS.

This works differently for Winsock versus BSD sockets. Visit the select (and not-select) loop in SocketsCycle() to see why.

Definition in file socket.c.

---

Function Documentation

bool Socket_Alloc_Serial	(	Socket *	sock,
		ctl_serial *	serial,
		size_t	size
	)

Allocate space for serial packet in output buffer to write into, put size and id on it.

Parameters:

	sock	Instance to work with
	serial	Returns a serial packet to work with if function retuens true
	size	Amount of space we want in the serial packet

Returns:

true on success

Definition at line 1605 of file socket.c.

References assertobjptr, Socket::label, Socket::output, RingBuff_AddSerial(), Socket_Close(), Socket_ShouldIgnore, and SocketsLogLastError().

{
    assertobjptr(sock);
    assertobjptr(serial);
    if( Socket_ShouldIgnore(sock) )
    {
        return false;
    }
    else
    {
        bool bRet = RingBuff_AddSerial( &sock->output, serial, size + 2 );
        if( bRet )
        {
            return true;
        }
        else
        {   /* Not enough room left! */
            SocketsLogLastError( LOG_ERROR, "Socket_Alloc_Serial(%s,%u) failed\n", sock->label, size );
            Socket_Close( sock );
            return false;
        }
    }
}

Here is the call graph for this function:

void Socket_Close

(

Socket *

sock

)

Mark a socket for cleanup.

Parameters:

sock

Instance to work with

Definition at line 1539 of file socket.c.

References Socket::appDisconnect, Socket::appReceived, assertcodeptr, assertobjptr, SockVTAB::Close, Socket::id, Socket::label, Socket::socket, SocketsLogLastError(), trace, Socket::type, and Socket::vtab.

Referenced by Socket_Alloc_Serial(), Socket_Create_Listener(), Socket_Write(), Socket_Write_Serial(), SocketsCycle(), and SocketsShutdown().

{
    assertobjptr(sock);
    trace(( "Socket_Close(%s)\n", sock->label ));
    /* Debug: See if socket got shredded */
    Socket_Validate(sock);
    sock->type = stUninitialized;
    sock->id = 0;

    /* Close socket handle */
    if( INVALID_SOCKET != sock->socket )
    {
        if( SOCKET_ERROR == closesocket(sock->socket) )
            SocketsLogLastError( LOG_ERROR, "Socket_Close(%d,%s) closesocket failed.\n", sock->socket, sock->label );
        sock->socket = INVALID_SOCKET;
    }
    
    /* Tell app to clean up after its self */
    assertcodeptr(sock->appDisconnect);
    sock->appDisconnect(sock);

    /* Tell Socket to clean up after its self */
    assertcodeptr(sock->vtab->Close);
    sock->vtab->Close(sock);

    /* Restore default application callbacks. */
    /* App will receive nothing more about this instance. */
    sock->appReceived = Socket_DefaultReceived;
    sock->appDisconnect = Socket_DefaultCallback;
}

Here is the call graph for this function:

Socket* Socket_Create

(

void

)

Allocate, initialize and register a new socket.

Returns:

New socket ready to be initialized

Definition at line 1330 of file socket.c.

References Socket::appDisconnect, Socket::appReceived, countof, Socket::created, ctl_fp_calloc, ctl_fp_index, ctl_mstime(), dll_push_back, Socket::id, Socket::label, Socket::lastmsg, Socket::socket, Socket_Customize(), Socket::timeout, and Socket::type.

Referenced by Socket_Create_Client(), Socket_Create_Listener(), and Socket_Create_Login().

{
    Socket* sock;
    size_t index;
    /* Allocate & clear it; all values should be zero */
    ctl_fp_calloc(SocketPool, sockPool, sock );
    if( NULL == sock )
        return NULL;
    sock->type = stUninitialized;
    sock->timeout = 5000;
    ++cSockActive;
    --cSockFree;
    sock->created = sock->lastmsg = ctl_mstime();

    {   
        /*
         * Confusion reduction (or confusion enhancement)
         * Socket->id is 16 bits AND a 16 bit sequence counter.  
         *
         * This will reduce the likelihood that a socket ID freed and reused 
         * will end up being the same ID, and help spot slightly stale identifier 
         * references.
         *
         * Very, very stale identifiers may not be identified because there's still 
         * a very small chance that the counter will wrap around and make an old 
         * identifier look valid again.
         */
        static uint32 seq = 0;
        index = ctl_fp_index(SocketPool, sockPool, sock );
        sock->id = index | (seq++&0xffff)<<16;
    }


    /* Add to active list */
    dll_push_back(Socket,active, socksActive, sock );
        
    /* Set socket to invalid value */
    sock->socket = INVALID_SOCKET;

    /* Give it a default label */
    strncpy(sock->label, "Socket", countof(sock->label) );

    /* Alocate socket storage separately */
    /* Keep the socket structure data small because it's iterated */
    /* Preallocate everything ONCE to keep server from dying at some odd time due to insufficient resources.  Die immediately, please. */
    /* Allocated from pool we initialized at startup */
    Socket_Customize( sock, 0,0,0 );

    /* Setup default application callbacks */
    sock->appReceived = Socket_DefaultReceived;
    sock->appDisconnect = Socket_DefaultCallback;
    return sock;
}

Here is the call graph for this function:

Socket* Socket_Create_Client

(

const char *

address

)

Initialize a client connection Address is in form of "address:port" or "address:port" In this case, the ':port' on the end is required

Definition at line 849 of file socket.c.

References assertconst, countof, Socket::label, Socket_Create(), Socket::timeout, Socket::type, and Socket::vtab.

{
    Socket* sock;
    assertconst(address,1);
    sock = Socket_Create();
    if( NULL == sock )
        return NULL;
    sock->type = stClient;
    sock->timeout = int64_max;
    LOG( LOG_INFO, "Socket_Create_Client(%s)\n", address );
    sock->vtab = &ClientVTAB;
    strncpy(sock->label, "Client", countof(sock->label) );
    return sock;
}

Here is the call graph for this function:

Socket* Socket_Create_Listener	(	const char *	label,
		const char *	address
	)

Make a listener. You'll need to make at least one to accept connections.

Parameters:

	label	Something to call this listener
	address	"127.0.0.1:port", port ID to listen on, i.e. "1000" or "myport" 127.0.0.1 != computername Address must point at localhost, because we can't bind to other computers

Definition at line 944 of file socket.c.

References assertconst, countof, Socket::ip, Socket::label, Socket::socka_buff, Socket::socket, Socket_Close(), Socket_Create(), SocketsLogLastError(), SocketsParseAddress(), Socket::timeout, Socket::type, and Socket::vtab.

{
    Socket* sock;
    struct addrinfo * service;
    assertconst(label,1);
    assertconst(address,1);
    LOG(LOG_STARTUP,"Socket_Create_Listener(%s,%s)\n", label, address );
    service = SocketsParseAddress( address );
    if( NULL == service )
        return NULL;
    sock = Socket_Create();
    if( NULL == sock )
        return NULL;
    sock->vtab = &ListenerVTAB;
    sock->type = stListener;
    sock->timeout = int64_max;
    strncpy( sock->label, label, countof(sock->label) );
    sock->socket = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP);
    if( sock->socket == INVALID_SOCKET ) 
    {
        SocketsLogLastError( LOG_ERROR, "Socket_Create_Listener(%s,%s) socket failed\n", sock->label,address );
        Socket_Close( sock );
        return NULL;
    }
    /* Setup socket */
    Socket_Options( sock );
    {
        /* Resolve port and listen */
        memcpy( &sock->socka_buff, service->ai_addr, min(service->ai_addrlen,sizeof(sock->socka_buff)) );
        LOG( LOG_STARTUP, "Listen: %s\n", service->ai_canonname );
        freeaddrinfo(service);
        SocketLogIP(sock,LOG_INFO,"Address: ");
        if( SOCKET_ERROR == bind( sock->socket, (struct sockaddr*)&sock->ip, sizeof(sock->ip)) ) 
        {
            SocketsLogLastError( LOG_ERROR, "Socket_Create_Listener(%s,%s) bind failed.\n", sock->label,address );
            Socket_Close( sock );
            return NULL;
        }
    }
    /* Listen for connections, and allow a back-log of half the users trying to get on at once */
    if( SOCKET_ERROR == listen( sock->socket, MAX_SOCKETS/2 ) )
    {
        SocketsLogLastError( LOG_ERROR, "Socket_Create_Listener(%s,%s) listen failed.\n", sock->label,address );
        Socket_Close( sock );
        return NULL;
    }
    return sock;
}

Here is the call graph for this function:

Socket* Socket_Create_Login

(

SOCKET

isock

)

Make a Login handler from an accepted connection Should filter various kinds of 'bad' connections and hang up before making an appropriate user connection.

Parameters:

isock

Socket handle from accept to create from

Definition at line 1168 of file socket.c.

References Socket::address, assertcodeptr, countof, Socket::label, Socket::socka_buff, Socket::socket, Socket_Create(), Socket::timeout, Socket::type, and Socket::vtab.

{
    Socket* sock = Socket_Create();
    if( NULL == sock )
        return NULL;
    sock->vtab = &LoginVTAB;
    sock->type = stLogin;
    sock->socket = isock;
    sock->timeout = 5000; /* We expect a messages immediately upon connection */
    {
        /* Grab address from connecting client */
        size_t addrlen = sizeof(sock->socka_buff);
        getpeername( sock->socket, &sock->address, &addrlen );
    }
    cstrncpy(char)( sock->label, "Login", countof(sock->label) );
    /*traceip("Socket_Create_Login:",&sock->address); */
    /* Setup socket */
    Socket_Options( sock );
    /* Call application callback for dynamically created Login socket */
    assertcodeptr(login_callback);
    login_callback(sock);
    return sock;
}

Here is the call graph for this function:

Socket* Socket_Create_Raw

(

Socket *

sock

)

Initialize a RAW connection.

Parameters:

sock

A Login socket to be transformed into a user. Similar to a User connection, but you get serialdata bounded only by what is received. If you don't consume the data, it's left on the input stack until it overflows. Support 'other' protocols besides 16 bit length-encoded data

Definition at line 1312 of file socket.c.

References assertcodeptr, assertobjptr, countof, Socket::label, Socket::timeout, Socket::type, and Socket::vtab.

{
    assertobjptr(sock);
    sock->vtab = &RawVTAB;
    sock->type = stRaw;
    sock->timeout = 15000;
    cstrncpy(char)( sock->label, "Raw", countof(sock->label) );
    /*trace(("Socket_Create_Raw(%s)\n", sock->label )); */
    /* Call application callback for dynamically created Raw socket */
    assertcodeptr(user_callback);
    user_callback(sock);
    return sock;
}

Socket* Socket_Create_User	(	Socket *	sock,
		const char *	label
	)

Initialize a user connection from Login.

Parameters:

	sock	A Login socket to be transformed into a user.
	label	What to call this socket from now on (such as user's name). All we're doing is transforming from a stateful socket that validates new connections to a socket that handles what the server expects in normal transactions; it doesn't mean we TRUST it, only that a subset of graceful checks can be ignored from now on, and the server app can begin initializing user information.

Definition at line 1214 of file socket.c.

References assertcodeptr, assertconst, assertobjptr, countof, Socket::label, Socket::timeout, Socket::type, and Socket::vtab.

{
    assertobjptr(sock);
    assertconst(label,1);
    sock->vtab = &UserVTAB;
    sock->type = stUser;
    sock->timeout = (15*60*1000); /* Let user go idle for 15 minutes */
    cstrncpy(char)(sock->label, label, countof(sock->label));
    /*trace(("Socket_Create_User(%s)\n", sock->label )); */
    /* Call application callback for dynamically created User socket */
    assertcodeptr(user_callback);
    user_callback(sock);
    return sock;
}

Socket* Socket_Customize	(	Socket *	sock,
		size_t	input,
		size_t	output,
		size_t	heap
	)

Allow default buffering to be modified for special cases.

Parameters:

	sock	Socket to modify
	input	New input size; 0 to restore default buffer
	input	New output size; 0 to restore default buffer
	input	New heap size; 0 to restore default buffer

Returns:

Socket passed in For special case connections, like a database, where normal input/output buffering limits may need to be extended. Invoking this when there is already data in the I/O buffers will bugger things. Best times would be in Login callback (before sending challenge) or after creating a Client, but also before sending anything.

Definition at line 1421 of file socket.c.

References Socket::appheap, assert, assertobjptr, ctl_fp_index, ctl_free, ctl_heap_init, ctl_malloc, Socket::input, Socket::output, Socket::pAppHeap, Socket::pInput, Socket::pOutput, and RingBuff_Init().

Referenced by Socket_Create().

{
    size_t index;
    assertobjptr(sock);
    index = ctl_fp_index(SocketPool, sockPool, sock );
    assert( index >= 0 && index < MAX_SOCKETS );
    /* Free previously customized buffers (I don't wanna leak even if you're doing it wrong) */
    if( NULL != sock->pInput && SOCK_INPUT_DEFAULTPTR(index) != sock->pInput )
        ctl_free( sock->pInput );
    if( NULL != sock->pOutput && SOCK_OUTPUT_DEFAULTPTR(index) != sock->pOutput )
        ctl_free( sock->pOutput );
    if( NULL != sock->pAppHeap && SOCK_HEAP_DEFAULTPTR(index) != sock->pAppHeap )
        ctl_free( sock->pAppHeap );
    if( input > sockInSize )
    {
        ctl_malloc( sock->pInput, input + sizeof(uint32));
    }
    else
    {
        input = sockInSize;
        sock->pInput = SOCK_INPUT_DEFAULTPTR(index);
    }
    if( output > sockOutSize )
    {
        ctl_malloc( sock->pOutput, output + sizeof(uint32) );
    }
    else
    {
        output = sockOutSize;
        sock->pOutput= SOCK_OUTPUT_DEFAULTPTR(index);
    }
    if( heap > sockHeapSize )
    {
        ctl_malloc( sock->pAppHeap, heap + sizeof(uint32) );
    }
    else
    {
        heap = sockHeapSize;
        sock->pAppHeap = SOCK_HEAP_DEFAULTPTR(index);
    }
    /* Setup input/output ring buffers */
    memset( sock->pInput, 0, input );
    RingBuff_Init( &sock->input, sock->pInput, sockInSize );
    memset( sock->pInput, 0, output );
    RingBuff_Init( &sock->output, sock->pOutput, sockOutSize );
    /* Setup application heap */
    memset( sock->pAppHeap, 0, heap );
    ctl_heap_init( &sock->appheap, sock->pAppHeap, sockHeapSize );
    /* Initialize guard bytes whether we're checking them or not (memory dump friendly) */
    *((uint32*)(sock->pInput + input)) = GUARD_BYTES;
    *((uint32*)(sock->pOutput + output)) = GUARD_BYTES;
    *((uint32*)(sock->pAppHeap + heap)) = GUARD_BYTES;
    return sock;
}

Here is the call graph for this function:

void Socket_LogError	(	Socket *	sock,
		unsigned	mask,
		const char *	fmt,
			...
	)

Log information about a naughty socket after an error is detected.

Parameters:

	sock	Instance to check
	mask	LOG mask
	fmt	Format for printf

Definition at line 1483 of file socket.c.

References assertconst, debug_vlog(), and SocketsLastErrorString().

Referenced by SocketsCycle().

{
    va_list args;
    va_start( args, fmt );
    int save_errno = SocketError();
    assertconst(fmt,1);
    debug_vlog(mask, fmt, args );
    SocketLogIP(sock,mask,"");
    SocketSetError(save_errno);
    LOG( mask, "%s\n", SocketsLastErrorString() );
}

Here is the call graph for this function:

const uint8* Socket_Raw_Consume	(	Socket *	sock,
		size_t	size
	)

After receiving 'appReceived' callback from Raw socket, call this to consume some of the input data CAUTION: If this is not a RAW socket, you'll most likely bugger it.

Parameters:

	sock	A Login socket to be transformed into a user.
	size	Number of bytes to consume

Definition at line 1284 of file socket.c.

References assertobjptr, Socket::input, and RingBuff_Pop().

{
    const uint8* data;
    assertobjptr(sock);
    RingBuff_Pop( &sock->input, &data, size );
    return data;
}

Here is the call graph for this function:

bool Socket_Write	(	Socket *	sock,
		const void *	buff,
		size_t	count
	)

Write some raw data into the output queue.

Parameters:

	sock	Instance to work with
	buff	Pointer to data to write
	count	Length of data to write

Returns:

true on success

Definition at line 1577 of file socket.c.

References assertconst, assertobjptr, Socket::label, Socket::output, RingBuff_CopyTo(), Socket_Close(), Socket_ShouldIgnore, and SocketsLogLastError().

{
    assertobjptr(sock);
    assertconst(buff,count);
    if( Socket_ShouldIgnore(sock) )
    {
        return false;
    }
    else
    {
        bool bRet = RingBuff_CopyTo( &sock->output, buff, count );
        if( !bRet )
        {
            SocketsLogLastError( LOG_ERROR, "Socket_Write(%s,%u) failed\n", sock->label, count );
            Socket_Close( sock );
            return false;
        }
        return true;
    }
}

Here is the call graph for this function:

bool Socket_Write_Serial	(	Socket *	sock,
		const ctl_serial *	serial
	)

Write a fully formed and filled-in serial packet into output buffer; ignores 'curr'.

Parameters:

	sock	Instance to work with
	serial	Returns a serial packet to work with if function retuens true

Returns:

true on success

Definition at line 1635 of file socket.c.

References assertobjconst, assertobjptr, ctl_serial::begin, ctl_serial_total, Socket::label, Socket::output, RingBuff_CopyTo(), Socket_Close(), Socket_ShouldIgnore, and SocketsLogLastError().

{
    assertobjptr(sock);
    assertobjconst(serial);
    if( Socket_ShouldIgnore(sock) )
    {
        return false;
    }
    else
    {
        size_t length = ctl_serial_total( serial );
        bool bRet = RingBuff_CopyTo( &sock->output, serial->begin, length );
        if( !bRet )
        {   /* Not enough room left! */
            SocketsLogLastError( LOG_ERROR, "Socket_Write_Serial(%s,%u) failed\n", sock->label, length );
            Socket_Close( sock );
            return false;
        }
        return true;
    }
}

Here is the call graph for this function:

Socket* SocketFind

(

const char *

label

)

Get a socket pointer from its label Will only find the first one, if several are named the same. Linear search; don't use it in inner loops and such.

Parameters:

label

Name of socket

Returns:

Pointer to socket, NULL if socket isn't valid/found

Definition at line 138 of file socket.c.

References assertconst, assertobjptr, socket_foreach, and Socket_ShouldIgnore.

{
    assertconst(label,1);
    {
        socket_foreach( sock )
        {
            assertobjptr(sock);
            if( !Socket_ShouldIgnore(sock) && !strcmp(sock->label,label) )
            {
                return sock;
            }
        }
    }
    return NULL;
}

uint32 SocketID

(

const Socket *

sock

)

Get a socket ID from its pointer.

Parameters:

sock

Instance to look up

Returns:

id if found, 0 if socket isn't a valid index

Definition at line 104 of file socket.c.

References assertobjconst, ctl_fp_valid, Socket::id, and Socket_ShouldIgnore.

{
    assertobjconst(sock);
    if( !ctl_fp_valid(SocketPool, sockPool, sock ) )
        return 0;
    if( Socket_ShouldIgnore(sock) )
        return 0;
    return sock->id;
}

Socket* SocketLut

(

uint32

id

)

Get a socket pointer from its ID.

Parameters:

id

Socket ID to lookup

Returns:

Pointer to socket, NULL if socket isn't valid

Definition at line 119 of file socket.c.

References ctl_fp_lut, Socket::id, and Socket_ShouldIgnore.

{
    Socket* sock = ctl_fp_lut(SocketPool, sockPool, id&0xffff );
    if( NULL == sock )
        return NULL;
    if( sock->id != id )
        return NULL;
    if( Socket_ShouldIgnore(sock) )
        return NULL;
    return sock;
}

bool SocketsCycle

(

unsigned

ms

)

Sockets heartbeat.

Parameters:

ms

Milliseconds to time-out waiting for activity

Returns:

true if everything is OK, false if there was some (probably fatal) problem - this means select() failed

Definition at line 288 of file socket.c.

References assertcodeptr, assertobjptr, ctl_mstime(), Socket_Close(), socket_foreach, socket_foreach_deletable, Socket_LogError(), Socket_ShouldIgnore, and SocketsLogLastError().

{
    mstime tick = ctl_mstime();
#ifdef WIN32
    /*
     * Under Windows, select() SUCKS.  Under WinSock, fd_set is an array of  
     * handles that is searched linearly.  A call to FD_SET in that case could  
     * scan through hundreds, even thousands of handles every time, times  
     * hundreds, even thousands of handles.  It makes it much more efficient to  
     * poll every socket and Sleep(1), even with the OS context switches.   
     * The replacement in the Winsock API is to set up threads for every  
     * socket, or have a WindowProc receive a message, or there's one that will 
     * check up to 64 handles at a time....  Just ugly.
     * 
     * For WIN32, we yield up time to the rest of the OS, since this will 
     * otherwise be a hard loop.  Makes CPU usage (on a given core) go from 
     * 100% to around 3%, so though not quite as good as select, it will do 
     * to keep the system running for testing in a Windows environment.
     */
    Sleep( 1 );

    /* Free dead sockets */
    {
        socket_foreach_deletable( sock )
        {
            assertobjptr(sock);
            if( tick - sock->lastmsg > sock->timeout )
            {   /* Close timed-out sockets */
                SocketLogIP(sock,LOG_INFO,"Timed out:");
                Socket_Close(sock);
            }
            if( stUninitialized == sock->type )
            {
                Socket_Free(sock);
            }
        }
    }
#else
    /*
     * Under Linux/Unix/etc. select() is THE way to go.  The server can go to 
     * sleep nicely when there's nothing to do, and you don't have to do  
     * thousands of context switches between application and OS to see if  
     * anything needs to happen.  The fd_set structure and macros under a BSD  
     * implementation are a set of bit masks.  Accessing the list is an indexed
     * lookup with some masking, and entries in the list are one bit, so the 
     * data is 1/32 the size of the list of handles you get in Windows, too.
     */
    static fd_set fdreads;
    static fd_set fdwrites;
    /* Maybe see about cacheing fd_set data...? */
    FD_ZERO(&fdreads);
    FD_ZERO(&fdwrites);
    {
        int nfds = -1;
        socket_foreach_deletable( sock )
        {
            assertobjptr(sock);
            if( stUninitialized != sock->type && INVALID_SOCKET != sock->socket )
            {
                if( tick - sock->lastmsg > sock->timeout )
                {   /* Close timed-out sockets */
                    SocketLogIP(sock,LOG_INFO,"Timed out:");
                    Socket_Close(sock);
                }
                else
                {
                    SOCKET sockCurr = sock->socket;
                    if( stSendingFinal != sock->type )
                    {
                        /* Don't listen for more incoming messages from closing sockets */
                        FD_SET( sockCurr, &fdreads );
                    }
                    if( !RingBuff_IsEmpty(&sock->output) )
                    {
                        FD_SET( sockCurr, &fdwrites );
                    }
                    if( sock->socket > nfds )
                    {
                        nfds = sockCurr;
                    }
                }
            }
            if( stUninitialized == sock->type )
            {
                Socket_Free(sock);
            }
        }
        /* Do select on all sockets, time-out appropriately as passed in */
        {
            struct timeval timeout = { ms/1000, (ms%1000)*1000 };
            nfds = select( 1+nfds, &fdreads, &fdwrites, NULL, 0 == ms ? NULL : &timeout );
        }
        if( 0 == nfds )
        {
            return true;
        }
        else if( SOCKET_ERROR == nfds )
        {
            int save_errno = SocketError();
            switch( save_errno )
            {
            case EBADF:
                /*
                 * One handle might be invalid - scan them all
                 * Shouldn't ever happen, but if one fd somehow becomes invalid,
                 * should we crash & nuke everyone, or just the 'invalid' one?
                 * I'll just assume you want to close the invalid one.
                 */
                {
                    SocketsLogLastError( LOG_ERROR, "select() EBADF.\n" );
                    bool bFound = false;
                    socket_foreach_deletable( suspect )
                    {
                        int tmp;
                        int ret = ioctl( suspect->socket, I_GETSIG, &tmp );
                        if( (-1 == ret) && (EBADF == SocketError()) )
                        {
                            Socket_LogError( suspect, LOG_ERROR, "select() BAD HANDLE: %d.\n", suspect->socket );
                            Socket_Close( suspect );
                            bFound = true;
                        }
                    }
                    /* If we couldn't find the 'bad' socket, something else is 
                     * wrong, and that's probably fatal. */
                    return bFound;
                }
                break;
            case EAGAIN:
            case EINTR:
                /* Time-out. */
                break;
            case EINVAL:
                
                /* nfds arg might be <0 or >FD_SETSIZE */
                if( (1+nfds < 0) || (1+nfds > FD_SETSIZE) )
                {
                    SocketsLogLastError( LOG_ERROR, "select() nfds out of range.\n" );
                    return false;
                }
                
                /* Invalid timeout interval (not likely, and a bug, anyways) */

                /* STREAM or multiplexer downstream from multiplexer */
                
                /* Fall-through to default error handler */
            default:
                SocketsLogLastError( LOG_ERROR, "select() failed.\n" );
                // Make sure previous function(s) don't overwrite error status
                SocketSetError(save_errno);
                return false;
            }
        }
    }

#endif

    /* Attempt to write sockets first, to make room for side-effects of reading sockets */
    {
        socket_foreach( sock )
        {
            assertobjptr(sock);
            if( stUninitialized != sock->type ppNotWindows(&& FD_ISSET(sock->socket,&fdwrites)) )
            {
                assertcodeptr(sock->vtab->WriteCycle);
                sock->vtab->WriteCycle(sock);
            }
        }
    }

    /* Attempt to read sockets */
    {
        socket_foreach( sock )
        {
            assertobjptr(sock);
            if( !Socket_ShouldIgnore(sock) ppNotWindows(&& FD_ISSET(sock->socket,&fdreads)) )
            {
                assertcodeptr(sock->vtab->ReadCycle);
                sock->vtab->ReadCycle(sock);
            }
        }
    }

    /* Normal-looking status */
    return true;
}

Here is the call graph for this function:

bool SocketsInit	(	size_t	input,
		size_t	output,
		size_t	heap
	)

Start up sockets connections.

Parameters:

	input	Size of socket input buffers
	output	Size of socket output buffers (larger than input)
	heap	Size of scratch heap attached to each socket

Returns:

true for success, false for failure You will need: ((input+output+heap)*MAX_SOCKETS) bytes of RAM for buffers Underlying the system, MAX_SOCKETS * whatever sockets needs

Definition at line 205 of file socket.c.

References ctl_alloctype, ctl_fp_init, ctl_malloc, SocketsLogLastError(), and trace.

{
    trace(("SocketsInit()\n"));
    sockInSize = input;
    sockOutSize = output;
    sockHeapSize = heap;
    sockBufferSize = (sockInSize + sockOutSize + (2*sizeof(uint32)));
    sockOffsetOut = sockInSize + sizeof(uint32);
    sockOffsetEnd = sockOffsetOut + sizeof(uint32);
    bufferSize = MAX_SOCKETS * sockBufferSize;
    sockUserSize = sockHeapSize + sizeof(uint32);
    userSize = MAX_SOCKETS * sockUserSize;

#ifdef WIN32
    {
        /* Setup Winsock */
        int iResult = WSAStartup(MAKEWORD(2,2), &wsaData);
        if (iResult != 0) 
        {
            SocketsLogLastError( LOG_ERROR, "WSAStartup failed: %d\n", iResult );
            return false;
        }
        LOG( LOG_STARTUP,"%s - %s\n", wsaData.szDescription, wsaData.szSystemStatus  );
    }
#endif

    /* Initialize socket pool */
    ctl_alloctype(sockPool,SocketPool);
    ctl_fp_init( SocketPool, sockPool );
    /* 
     * Allocate all the socket storage at once
     * I'd rather die right away for insufficient space than at 2:00am when the 834th user logs in
     */
    ctl_malloc( bufferSpace, bufferSize );
    ctl_malloc( userSpace, userSize );
    return true;
}

Here is the call graph for this function:

const char* SocketsLastErrorString

(

void

)

Retrieve the system error message for the last-error code.

Returns:

String pointer describing the error

Definition at line 478 of file socket.c.

Referenced by Socket_LogError(), and SocketsLogLastError().

{
#ifdef WIN32
    static char szError[512]; // <- Multithread risk
    DWORD dw = SocketError(); 
    FormatMessage(
        FORMAT_MESSAGE_FROM_SYSTEM | 
        FORMAT_MESSAGE_IGNORE_INSERTS |
        FORMAT_MESSAGE_MAX_WIDTH_MASK,
        NULL, 
        dw, 
        MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
        szError, sizeof(szError)/sizeof(*szError), 
        NULL);
    return szError;
#else
    return strerror(SocketError());
#endif
}

void SocketsLogLastError	(	unsigned	mask,
		const char *	fmt,
			...
	)

Log information about socket errors.

Parameters:

	mask	LOG mask
	fmt	Format for printf

Definition at line 503 of file socket.c.

References assertconst, debug_vlog(), and SocketsLastErrorString().

Referenced by Socket_Alloc_Serial(), Socket_Close(), Socket_Create_Listener(), Socket_Write(), Socket_Write_Serial(), SocketsCycle(), SocketsInit(), SocketsLogHostent(), and SocketsParseAddress().

{
    va_list args;
    va_start( args, fmt );
    assertconst(fmt,1);
    debug_vlog(mask, fmt, args );
    LOG( mask, "%s\n", SocketsLastErrorString() );
}

Here is the call graph for this function:

struct addrinfo* SocketsParseAddress

(

const char *

szAddress

)

[read]

Parse an ip:port address into a sockaddr_in list. Does not handle character escapes or embedded parameters like a web url. Potentially very time-consuming (does a blocking namespace lookup, possibly all the way to internet DNS) Use only at startup when opening listeners and dedicated client connections Handles 'friendly' names like, 'localhost' and 'www-http', so named ports or computers work

Parameters:

szAddress

String containing ip:port (:port is REQUIRED)

Returns:

List from getaddrinfo(3), or NULL if there was a problem; USE freeaddrinfo();

Definition at line 521 of file socket.c.

References assertconst, SocketsLogHostent(), SocketsLogLastError(), and trace.

Referenced by Socket_Create_Listener().

{
    char ipbuff[256];
    const char* port;
    const char* address;
    const char* scan;
    assertconst(szAddress,1);
    scan = address = szAddress;
    /* Look for colon */
    while( ':' != *scan )
    {
        if( 0 == *scan )
            return NULL;
        scan++;
    }
    /* If we found '://', skip over protocol and search for ':' */
    if( *scan == '/' )
    {
        ++scan;
        if( *scan == '/' )
        {
            address = ++scan;
            while( ':' != *scan )
            {
                if( 0 == *scan )
                {
                    LOG( LOG_ERROR, "SocketsParseAddress(%s) no ':port'.\n", szAddress );
                    return NULL;
                }
                scan++;
            }
        }
        else
        {
            LOG( LOG_ERROR, "SocketsParseAddress(%s) found ':/' instead of '://'.\n", szAddress );
            return NULL;
        }
    }
    if( *scan == ':' )
    {
        size_t address_len;
        port = scan+1;
        address_len = (scan-address);
        if( address_len > sizeof(ipbuff) )
        {
            LOG( LOG_ERROR, "SocketsParseAddress(%s) address too long.\n", szAddress );
            return NULL;
        }
        memcpy(ipbuff,address,address_len);
        ipbuff[address_len] = 0;
        SocketsLogHostent( LOG_INFO, ipbuff );
        {
            struct addrinfo aiHints;
            struct addrinfo *aiList = NULL;
            memset(&aiHints, 0, sizeof(aiHints));
            aiHints.ai_family = AF_INET;
            aiHints.ai_socktype = SOCK_STREAM;
            aiHints.ai_flags = AI_CANONNAME;
            aiHints.ai_protocol = IPPROTO_TCP;
            if( 0 != getaddrinfo(ipbuff, port, &aiHints, &aiList) )
            {
                SocketsLogLastError( LOG_ERROR, "SocketsParseAddress(%s) failed.\n", szAddress );
                return NULL;
            }
#if 1
            {
                struct addrinfo *ai = aiList;
                while( NULL != ai )
                {
                    trace(( "%s: ", ai->ai_canonname ));
                    traceip("Address:",ai->ai_addr);
                    ai = ai->ai_next;
                }
            }
#endif
            return aiList;
        }
    }
    return NULL;
}

Here is the call graph for this function:

MLCallback SocketsSetFlashPolicy

(

MLCallback

callback

)

Setup what to tell Flash clients that they can connect.

Returns:

String containing XML text.

Definition at line 1046 of file socket.c.

References assertcodeptr.

{
    MLCallback prev = cbFlashPolicy;
    cbFlashPolicy = NULL == callback ? defcbFlashPolicy: callback;
    assertcodeptr(cbFlashPolicy);
    return prev;
}

MLCallback SocketsSetHTTP

(

MLCallback

callback

)

Setup what to tell web browsers that hit this server.

Returns:

String containing HTML page. Should auto-refresh to REAL home page.

Definition at line 1035 of file socket.c.

References assertcodeptr.

{
    MLCallback prev = cbHTTP;
    cbHTTP = NULL == callback ? defcbHTTP: callback;
    assertcodeptr(cbHTTP);
    return prev;
}

NewSocketCallback SocketsSetLogin

(

NewSocketCallback

callback

)

Set a callback handler for new login socket creation.

Parameters:

callback

Callback function, or NULL for no callback

Returns:

old callback

Definition at line 174 of file socket.c.

References assertcodeptr.

{
    NewSocketCallback cb_old = login_callback;
    login_callback = NULL == callback ? Socket_DefaultCallback : callback;
    assertcodeptr(login_callback);
    return cb_old;
}

NewSocketCallback SocketsSetUser

(

NewSocketCallback

callback

)

Set a callback handler for new user socket creation.

Parameters:

callback

Callback function, or NULL for no callback

Returns:

old callback

Definition at line 187 of file socket.c.

References assertcodeptr.

{
    NewSocketCallback cb_old = user_callback;
    user_callback = NULL == callback ? Socket_DefaultCallback : callback;
    assertcodeptr(user_callback);
    return cb_old;
}