LUA_TCP网络

luaL_Buffer   从INIT开始到RESULT为止..栈的控制权在luaL_Buffer手里..不要动栈做修改..要修改也要平衡...添了就要删.

BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    WSADATA wsaData;
    WORD sockVersion;

    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
        sockVersion = MAKEWORD( 2, 2 );
        if ( WSAStartup( sockVersion, &wsaData ) != 0 )
        {
            return FALSE;
        }

        if ( wsaData.wVersion != sockVersion )
        {
            WSACleanup();
            return FALSE;;
        }
        break;
    case DLL_THREAD_ATTACH:
        break;
    case DLL_THREAD_DETACH:
        break;
    case DLL_PROCESS_DETACH:
        WSACleanup();
        break;
    }
    return TRUE;
}

#include "stdafx.h"
#include "LuaSocket.h"

#define RWBUFFLEN        (2048)

#define CON_TIMEO        (3000)
#define APT_TIMEO        (6000)

#define TIMEO_RCV        (0x01)
#define TIMEO_SND        (0x02)

#define SELECT_READ      (0x01)
#define SELECT_WRIT      (0x02)
#define SELECT_EXCE      (0x04)

typedef struct tag_socket
{
    SOCKET fd;
    int nonb;
} socket_t, *socket_ptr;

typedef struct tag_selectsets
{
    FD_SET readfds;
    FD_SET writefds;
    FD_SET exceptfds;
} selectsets_t, *selectsets_ptr;

typedef struct tag_selectfds
{
    selectsets_ptr pfds;
} selectfds_t, *selectfds_ptr;


int tcp_new( lua_State* lua )
{
    SOCKET fd;
    socket_ptr psocket;

    if ( ( fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) == INVALID_SOCKET )
    {
        perror( "socket" );
        return 0;
    }

    psocket = ( socket_ptr )lua_newuserdata( lua, sizeof( socket_t ) );
    psocket->fd = fd;
    psocket->nonb = 0;

    luaL_getmetatable( lua, "luasocket.metatable" );
    lua_setmetatable( lua, -2 );

    return 1;
}

int socket_equal( lua_State* lua )
{
    socket_ptr psocket1, psocket2;

    psocket1 = ( socket_ptr )lua_touserdata( lua, 1 );
    psocket2 = ( socket_ptr )lua_touserdata( lua, 2 );

    if ( psocket1->fd == psocket2->fd )
    {
        lua_pushboolean( lua, 1 );
        return 1;
    }

    lua_pushboolean( lua, 0 );
    return 1;
}

int table_readonly( lua_State* lua )
{
    return 0;
}

int socket_close_gc( lua_State* lua )
{
    socket_ptr psocket;

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd != INVALID_SOCKET )
    {
        closesocket( psocket->fd );
    }

    return 0;
}

int socket_close( lua_State* lua )
{
    socket_ptr psocket;

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd != INVALID_SOCKET )
    {
        closesocket( psocket->fd );
        psocket->fd = INVALID_SOCKET;
    }

    return 0;
}

int socket_settimeo( lua_State* lua )
{
    socket_ptr psocket;
    int msec, type;

    if ( lua_gettop( lua ) < 2 || lua_type( lua, 2 ) != LUA_TNUMBER )
    {
        goto err_exit;
    }

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    msec = ( int )lua_tointeger( lua, 2 );
    if ( psocket->fd == INVALID_SOCKET || msec <= 0 )
    {
        goto err_exit;
    }

    type = TIMEO_RCV;
    if ( lua_gettop( lua ) > 2 && lua_type( lua, 3 ) == LUA_TNUMBER )
    {
        type = ( int )lua_tointeger( lua, 3 );
    }

    if ( type & TIMEO_RCV )
    {
        if ( setsockopt( psocket->fd, SOL_SOCKET, SO_RCVTIMEO, ( const char* )&msec, sizeof( int ) ) != 0 )
        {
            perror( "setsockopt\t<SO_RCVTIMEO>" );
            goto err_exit;
        }
    }

    if ( type & TIMEO_SND )
    {
        if ( setsockopt( psocket->fd, SOL_SOCKET, SO_SNDTIMEO, ( const char* )&msec, sizeof( int ) ) != 0 )
        {
            perror( "setsockopt\t<SO_SNDTIMEO>" );
            goto err_exit;
        }
    }

    lua_pushboolean( lua, 1 );
    return 1;
err_exit:
    lua_pushboolean( lua, 0 );
    return 1;
}

int socket_setnonb( lua_State* lua )
{
    socket_ptr psocket;
    unsigned long nonb;

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        goto err_exit;
    }

    nonb = 1L;
    if ( lua_gettop( lua ) > 1 && lua_type( lua, 2 ) == LUA_TBOOLEAN )
    {
        nonb = ( lua_toboolean( lua, 2 ) == 0 ? 0L : 1L );
    }

    if ( psocket->nonb != ( int )nonb )
    {
        if ( ioctlsocket( psocket->fd, FIONBIO, &nonb ) != 0 )
        {
            perror( "ioctlsocket\t<FIONBIO>" );
            goto err_exit;
        }

        psocket->nonb = ( int )nonb;
    }

    lua_pushboolean( lua, 1 );
    return 1;
err_exit:
    lua_pushboolean( lua, 0 );
    return 1;
}

int socket_setlinger( lua_State* lua )
{
    socket_ptr psocket;
    struct linger lg;

    if ( lua_gettop( lua ) < 2 || lua_type( lua, 2 ) != LUA_TBOOLEAN )
    {
        goto err_exit;
    }

    lg.l_onoff = ( lua_toboolean( lua, 2 ) == 0 ? 0 : 1 );
    if ( lg.l_onoff == 1 )
    {
        if ( lua_gettop( lua ) < 3 || lua_type( lua, 3 ) != LUA_TNUMBER )
        {
            goto err_exit;
        }

        lg.l_linger = ( unsigned short )lua_tointeger( lua, 3 );
    }

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( setsockopt( psocket->fd, SOL_SOCKET, SO_LINGER, ( const char* )&lg, sizeof( struct linger ) ) != 0 )
    {
        perror( "setsockopt\t<SO_LINGER>" );
        goto err_exit;
    }

    lua_pushboolean( lua, 1 );
    return 1;
err_exit:
    lua_pushboolean( lua, 0 );
    return 1;
}

int tcp_setnodelay( lua_State* lua )
{
    socket_ptr psocket;
    int nodelay;

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        goto err_exit;
    }

    nodelay = 1;
    if ( lua_gettop( lua ) > 1 && lua_type( lua, 2 ) == LUA_TBOOLEAN )
    {
        nodelay = ( lua_toboolean( lua, 2 ) == 0 ? 0 : 1 );
    }

    if ( setsockopt( psocket->fd, IPPROTO_TCP, TCP_NODELAY, ( const char* )&nodelay, sizeof( int ) ) != 0 )
    {
        perror( "setsockopt\t<TCP_NODELAY>" );
        goto err_exit;
    }

    lua_pushboolean( lua, 1 );
    return 1;
err_exit:
    lua_pushboolean( lua, 0 );
    return 1;
}


int socket_peerip( lua_State* lua )
{
    socket_ptr psocket;
    int plen;
    struct sockaddr ipname;

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        return 0;
    }

    plen = sizeof( struct sockaddr );
    memset( &ipname, 0, sizeof( struct sockaddr ) );
    if ( getpeername( psocket->fd, &ipname, &plen ) !=  0 )
    {
        perror( "getpeername" );
        return 0;
    }

    lua_pushfstring( lua, "%d.%d.%d.%d", \
                     ( unsigned char )ipname.sa_data[2], \
                     ( unsigned char )ipname.sa_data[3], \
                     ( unsigned char )ipname.sa_data[4], \
                     ( unsigned char )ipname.sa_data[5] );
    lua_pushinteger( lua, ( int )ntohs( *( ( unsigned short* )( ipname.sa_data ) ) ) );
    return 2;
}

int socket_localip( lua_State* lua )
{
    socket_ptr psocket;
    int plen;
    struct sockaddr ipname;

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        return 0;
    }

    plen = sizeof( struct sockaddr );
    memset( &ipname, 0, sizeof( struct sockaddr ) );
    if ( getsockname( psocket->fd, &ipname, &plen ) !=  0 )
    {
        perror( "getsockname" );
        return 0;
    }

    lua_pushfstring( lua, "%d.%d.%d.%d", \
                     ( unsigned char )ipname.sa_data[2], \
                     ( unsigned char )ipname.sa_data[3], \
                     ( unsigned char )ipname.sa_data[4], \
                     ( unsigned char )ipname.sa_data[5] );
    lua_pushinteger( lua, ( int )ntohs( *( ( unsigned short* )( ipname.sa_data ) ) ) );
    return 2;
}

int tcp_listen( lua_State* lua )
{
    int len;
    unsigned short port;
    int backlog;
    int on;
    struct sockaddr_in sin;
    socket_ptr psocket;

    len = lua_gettop( lua );
    if ( len < 2 )
    {
        goto err_exit;
    }

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        goto err_exit;
    }

    if ( len == 2 )
    {
        if ( lua_type( lua, 2 ) != LUA_TNUMBER )
        {
            goto err_exit;
        }

        port = ( unsigned short )lua_tointeger( lua, 2 );
        backlog = 64;
    }
    else
    {
        if ( lua_type( lua, 2 ) != LUA_TNUMBER || lua_type( lua, 3 ) != LUA_TNUMBER )
        {
            goto err_exit;
        }

        if ( ( backlog = lua_tointeger( lua, 3 ) ) < 1 )
        {
            goto err_exit;
        }

        port = ( unsigned short )lua_tointeger( lua, 2 );
    }


    on = 1;
    if ( setsockopt( psocket->fd, SOL_SOCKET, SO_REUSEADDR, ( const char* )&on, sizeof( int ) ) != 0 )
    {
        perror( "setsockopt\t<SO_REUSEADDR>" );
        goto err_exit;
    }

    memset( &sin, 0, sizeof( struct sockaddr_in ) );
    sin.sin_family = AF_INET;
    sin.sin_addr.s_addr = htonl( INADDR_ANY );
    sin.sin_port = htons( port );

    if ( bind( psocket->fd, ( const struct sockaddr* )&sin, sizeof( sin ) ) != 0 )
    {
        perror( "bind" );
        goto err_exit;
    }

    if ( listen( psocket->fd, backlog ) != 0 )
    {
        perror( "listen" );
        goto err_exit;
    }

    lua_pushboolean( lua, 1 );
    return 1;
err_exit:
    lua_pushboolean( lua, 0 );
    return 1;
}

int tcp_accept( lua_State* lua )
{
    SOCKET fd;
    socket_ptr psocket;
    struct sockaddr_in sin;
    int clilen;
    struct timeval tv;
    unsigned long nonb;
    fd_set fdset;
    int msec;
    int sign;

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        return 0;
    }

    msec = APT_TIMEO;
    if ( lua_gettop( lua ) > 1 && lua_type( lua, 2 ) == LUA_TNUMBER )
    {
        msec = lua_tointeger( lua, 2 );
        if ( msec < 3 )
        {
            msec = APT_TIMEO;
        }
    }

    sign = 0;
    if ( psocket->nonb == 0 )
    {
        nonb = 1L;
        if ( ioctlsocket( psocket->fd, FIONBIO, &nonb ) != 0 )
        {
            perror( "ioctlsocket\t<FIONBIO>" );
            return 0;
        }

        psocket->nonb = 1;
        sign = 1;
    }

    FD_ZERO( &fdset );
    FD_SET( psocket->fd, &fdset );

    tv.tv_sec = msec / 1000;
    tv.tv_usec = ( msec % 1000 ) * 1000;
    if ( select( 0, &fdset, 0, 0, &tv ) != 1 )
    {
        goto err_exit;
    }

    clilen = sizeof( sin );
    if ( ( fd = accept( psocket->fd, ( struct sockaddr* ) &sin, &clilen ) ) == INVALID_SOCKET )
    {
        perror( "accept" );
        goto err_exit;
    }

    psocket = ( socket_ptr )lua_newuserdata( lua, sizeof( socket_t ) );
    psocket->fd = fd;

    luaL_getmetatable( lua, "luasocket.metatable" );
    lua_setmetatable( lua, -2 );

    return 1;
err_exit:
    if ( sign == 1 )
    {
        nonb = 0L;
        if ( ioctlsocket( psocket->fd, FIONBIO, &nonb ) == 0 )
        {
            psocket->nonb = 0;
        }
    }

    return 0;
}

int tcp_connect( lua_State* lua )
{
    const char* host;
    unsigned short port;
    int msec;
    SOCKET fd;
    struct hostent* h;
    struct sockaddr_in sin;
    struct timeval tv;
    unsigned long nonb;
    fd_set fdset;
    socket_ptr psocket;

    if ( lua_gettop( lua ) < 2 )
    {
        return 0;
    }

    if ( lua_type( lua, 1 ) != LUA_TSTRING || ( host = lua_tostring( lua, 1 ) ) == NULL )
    {
        return 0;
    }

    if ( ( h = gethostbyname( host ) ) == NULL || h->h_addrtype != AF_INET )
    {
        return 0;
    }

    memset( &sin, 0, sizeof( sin ) );
    sin.sin_family = AF_INET;
    memcpy( &sin.sin_addr.s_addr, h->h_addr_list[0], h->h_length );

    if ( lua_type( lua, 2 ) != LUA_TNUMBER || ( port = ( unsigned short )lua_tointeger( lua, 2 ) ) == 0 )
    {
        return 0;
    }

    sin.sin_port = htons( port );

    msec = CON_TIMEO;
    if ( lua_gettop( lua ) > 2 && lua_type( lua, 3 ) == LUA_TNUMBER )
    {
        msec = lua_tointeger( lua, 3 );
        if ( msec < 3 )
        {
            msec = CON_TIMEO;
        }
    }

    if ( ( fd = socket( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) ==  INVALID_SOCKET )
    {
        perror( "socket" );
        return 0;
    }

    nonb = 1L;
    if ( ioctlsocket( fd, FIONBIO, &nonb ) != 0 )
    {
        closesocket( fd );
        return 0;
    }

    if ( connect( fd, ( const struct sockaddr* ) &sin, sizeof( sin ) ) != 0 )
    {
        FD_ZERO( &fdset );
        FD_SET( fd, &fdset );

        tv.tv_sec = msec / 1000;
        tv.tv_usec = ( msec % 1000 ) * 1000;
        if ( select( 0, 0, &fdset, 0, &tv ) != 1 )
        {
            closesocket( fd );
            return 0;
        }
    }

    nonb = 0L;
    if ( ioctlsocket( fd, FIONBIO, &nonb ) != 0 )
    {
        closesocket( fd );
        return 0;
    }

    psocket = ( socket_ptr )lua_newuserdata( lua, sizeof( socket_t ) );
    psocket->fd = fd;
    psocket->nonb = 0;

    luaL_getmetatable( lua, "luasocket.metatable" );
    lua_setmetatable( lua, -2 );

    return 1;
}


int tcp_read( lua_State* lua )
{
    socket_ptr psocket;
    luaL_Buffer b;
    unsigned char chunk[RWBUFFLEN];
    int nread;
    char* ptr;

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        return 0;
    }

    ptr = ( char* )chunk;
    luaL_buffinit( lua, &b );
    while ( 1 )
    {
        nread = recv( psocket->fd, ptr, ( int )RWBUFFLEN, 0 );
        if ( nread < 0 )
        {
            if ( WSAGetLastError() == WSAEINTR )
            {
                continue;
            }
            else if ( WSAGetLastError() == WSAEWOULDBLOCK )
            {
                break;
            }
            else
            {
                /*luaL_pushresult( &b );
                lua_settop( lua, -2 );
                return 0;*/
                break;
            }
        }
        else if ( nread == 0 )
        {
            break;
        }

        luaL_addlstring( &b, ptr, nread );
    }

    luaL_pushresult( &b );
    return 1;
}

int tcp_readn( lua_State* lua )
{
    socket_ptr psocket;
    luaL_Buffer b;
    unsigned char chunk[RWBUFFLEN];
    int nleft, nread;
    char* ptr;

    if ( lua_gettop( lua ) < 2  || lua_type( lua, 2 ) != LUA_TNUMBER )
    {
        return 0;
    }

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        return 0;
    }

    nleft = ( int )lua_tointeger( lua, 2 );

    ptr = ( char* )chunk;
    luaL_buffinit( lua, &b );
    while ( nleft > 0 )
    {
        if ( nleft >= RWBUFFLEN )
        {
            nread = recv( psocket->fd, ptr, ( int )RWBUFFLEN, 0 );
        }
        else
        {
            nread = recv( psocket->fd, ptr, nleft, 0 );
        }

        if ( nread < 0 )
        {
            if ( WSAGetLastError() == WSAEINTR )
            {
                continue;
            }
            else if ( WSAGetLastError() == WSAEWOULDBLOCK )
            {
                continue;
            }
            else
            {
                luaL_pushresult( &b );
                lua_settop( lua, -2 );
                return 0;
            }
        }
        else if ( nread == 0 )
        {
            break;
        }

        luaL_addlstring( &b, ptr, nread );
        nleft -= nread;
    }

    luaL_pushresult( &b );
    return 1;
}

int tcp_write( lua_State* lua )
{
    socket_ptr psocket;
    size_t nleft;
    const char* ptr;
    int nwritten, nwrittens;

    if ( lua_gettop( lua ) < 2 || lua_type( lua, 2 ) != LUA_TSTRING )
    {
        return 0;
    }

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        return 0;
    }

    ptr = lua_tolstring( lua, 2, &nleft );
    if ( ptr == NULL )
    {
        return 0;
    }

    nwrittens = 0;
    while ( ( int )nleft > 0 )
    {
        nwritten = send( psocket->fd, ptr, ( int )nleft, 0 );
        if ( nwritten < 0 )
        {
            if ( WSAGetLastError() == WSAEINTR )
            {
                continue;
            }
            else if ( WSAGetLastError() == WSAEWOULDBLOCK )
            {
                break;
            }

            return 0;
        }
        else if ( nwritten == 0 )
        {
            break;
        }

        nleft -= nwritten;
        ptr += nwritten;
        nwrittens += nwritten;
    }

    lua_pushinteger( lua, nwrittens );
    return 1;
}

int tcp_writen( lua_State* lua )
{
    socket_ptr psocket;
    size_t nleft;
    const char* ptr;
    int nwritten, nwrittens;

    if ( lua_gettop( lua ) < 2 || lua_type( lua, 2 ) != LUA_TSTRING )
    {
        return 0;
    }

    psocket = ( socket_ptr )lua_touserdata( lua, 1 );
    if ( psocket->fd == INVALID_SOCKET )
    {
        return 0;
    }

    ptr = lua_tolstring( lua, 2, &nleft );
    if ( ptr == NULL )
    {
        return 0;
    }

    nwrittens = 0;
    while ( ( int )nleft > 0 )
    {
        nwritten = send( psocket->fd, ptr, ( int )nleft, 0 );
        if ( nwritten < 0 )
        {
            if ( WSAGetLastError() == WSAEINTR )
            {
                continue;
            }
            else if ( WSAGetLastError() == WSAEWOULDBLOCK )
            {
                continue;
            }

            return 0;
        }
        else if ( nwritten == 0 )
        {
            break;
        }

        nleft -= nwritten;
        ptr += nwritten;
        nwrittens += nwritten;
    }

    lua_pushinteger( lua, nwrittens );
    return 1;
}

int select_new( lua_State* lua )
{
    selectfds_ptr psel;

    psel = ( selectfds_ptr )lua_newuserdata( lua, sizeof( selectfds_t ) );

    psel->pfds = ( selectsets_ptr )malloc( sizeof( selectsets_t ) );
    if ( psel->pfds == NULL )
    {
        return 0;
    }

    FD_ZERO( &psel->pfds->readfds );
    FD_ZERO( &psel->pfds->writefds );
    FD_ZERO( &psel->pfds->exceptfds );

    luaL_getmetatable( lua, "luasocket.select.metatable" );
    lua_setmetatable( lua, -2 );

    return 1;
}

int select_destroy( lua_State* lua )
{
    selectfds_ptr psel;

    psel = ( selectfds_ptr )lua_touserdata( lua, 1 );
    if ( psel->pfds != NULL )
    {
        free( psel->pfds );
    }

    return 0;
}

int select_clear( lua_State* lua )
{
    selectfds_ptr psel;
    int type;

    psel = ( selectfds_ptr )lua_touserdata( lua, 1 );

    type = SELECT_READ | SELECT_WRIT | SELECT_EXCE;
    if ( lua_gettop( lua ) > 1 && lua_type( lua, 2 ) == LUA_TNUMBER )
    {
        type = ( int )lua_tointeger( lua, 2 );
    }

    if ( type & SELECT_READ )
    {
        FD_ZERO( &psel->pfds->readfds );
    }

    if ( type & SELECT_WRIT )
    {
        FD_ZERO( &psel->pfds->writefds );
    }

    if ( type & SELECT_EXCE )
    {
        FD_ZERO( &psel->pfds->exceptfds );
    }

    lua_pushboolean( lua, 1 );
    return 1;
}

int select_addfd( lua_State* lua )
{
    socket_ptr psocket;
    selectfds_ptr psel;
    int type;

    if ( lua_gettop( lua ) < 2 || lua_type( lua, 2 ) != LUA_TUSERDATA )
    {
        lua_pushboolean( lua, 0 );
        return 1;
    }

    psel = ( selectfds_ptr )lua_touserdata( lua, 1 );
    psocket = ( socket_ptr )lua_touserdata( lua, 2 );

    type = SELECT_READ | SELECT_WRIT | SELECT_EXCE;
    if ( lua_gettop( lua ) > 2 && lua_type( lua, 3 ) == LUA_TNUMBER )
    {
        type = ( int )lua_tointeger( lua, 3 );
    }

    if ( type & SELECT_READ )
    {
        FD_SET( psocket->fd, &psel->pfds->readfds );
    }

    if ( type & SELECT_WRIT )
    {
        FD_SET( psocket->fd, &psel->pfds->writefds );
    }

    if ( type & SELECT_EXCE )
    {
        FD_SET( psocket->fd, &psel->pfds->exceptfds );
    }

    lua_pushboolean( lua, 1 );
    return 1;
}

int select_delfd( lua_State* lua )
{
    socket_ptr psocket;
    selectfds_ptr psel;
    int type;

    if ( lua_gettop( lua ) < 2 || lua_type( lua, 2 ) != LUA_TUSERDATA )
    {
        lua_pushboolean( lua, 0 );
        return 1;
    }

    psel = ( selectfds_ptr )lua_touserdata( lua, 1 );
    psocket = ( socket_ptr )lua_touserdata( lua, 2 );

    type = SELECT_READ | SELECT_WRIT | SELECT_EXCE;
    if ( lua_gettop( lua ) > 2 && lua_type( lua, 3 ) == LUA_TNUMBER )
    {
        type = ( int )lua_tointeger( lua, 3 );
    }

    if ( type & SELECT_READ )
    {
        FD_CLR( psocket->fd, &psel->pfds->readfds );
    }

    if ( type & SELECT_WRIT )
    {
        FD_CLR( psocket->fd, &psel->pfds->writefds );
    }

    if ( type & SELECT_EXCE )
    {
        FD_CLR( psocket->fd, &psel->pfds->exceptfds );
    }

    lua_pushboolean( lua, 1 );
    return 1;
}

int select_isset( lua_State* lua )
{
    selectfds_ptr psel;
    socket_ptr psocket;
    int type;

    if ( lua_gettop( lua ) < 2 || lua_type( lua, 2 ) != LUA_TUSERDATA )
    {
        lua_pushboolean( lua, 0 );
        return 1;
    }

    psel = ( selectfds_ptr )lua_touserdata( lua, 1 );
    psocket = ( socket_ptr )lua_touserdata( lua, 2 );

    type = SELECT_READ;
    if ( lua_gettop( lua ) > 2 && lua_type( lua, 3 ) == LUA_TNUMBER )
    {
        type = ( int )lua_tointeger( lua, 3 );
    }

    if ( type & SELECT_READ )
    {
        if ( FD_ISSET( psocket->fd, &psel->pfds->readfds ) )
        {
            lua_pushboolean( lua, 1 );
            return 1;
        }
    }
    else if ( type & SELECT_WRIT )
    {
        if ( FD_ISSET( psocket->fd, &psel->pfds->writefds ) )
        {
            lua_pushboolean( lua, 1 );
            return 1;
        }
    }
    else if ( type & SELECT_EXCE )
    {
        if ( FD_ISSET( psocket->fd, &psel->pfds->exceptfds ) )
        {
            lua_pushboolean( lua, 1 );
            return 1;
        }
    }

    lua_pushboolean( lua, 0 );
    return 1;
}

int select_select( lua_State* lua )
{
    selectfds_ptr psel;
    struct timeval tv;
    int msec;
    int ret;

    psel = ( selectfds_ptr )lua_touserdata( lua, 1 );

    msec = 0;
    if ( lua_gettop( lua ) > 1 && lua_type( lua, 2 ) == LUA_TNUMBER )
    {
        msec = ( int )lua_tointeger( lua, 2 );
    }

    if ( msec > 0 )
    {
        tv.tv_sec = msec / 1000;
        tv.tv_usec = ( msec % 1000 ) * 1000;
        ret = select( 0, &psel->pfds->readfds, &psel->pfds->writefds, &psel->pfds->exceptfds, &tv );
    }
    else
    {
        ret = select( 0, &psel->pfds->readfds, &psel->pfds->writefds, &psel->pfds->exceptfds, NULL );
    }

    lua_pushinteger( lua, ret );
    return 1;
}

static luaL_Reg _mylibs[] =
{
    {"tcp", tcp_new},
    {"connect", tcp_connect},
    {"newsel", select_new},
    {NULL, NULL}
};

int luaopen_LuaSocket( lua_State* lua )
{
    /****************************************************/
    luaL_newmetatable( lua, "luasocket.metatable" );

    lua_pushstring( lua, "__index" );
    lua_pushvalue( lua, -2 );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "__newindex" );
    lua_pushcfunction( lua, table_readonly );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "__gc" );
    lua_pushcfunction( lua, socket_close_gc );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "__eq" );
    lua_pushcfunction( lua, socket_equal );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "close" );
    lua_pushcfunction( lua, socket_close );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "timeout" );
    lua_pushcfunction( lua, socket_settimeo );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "nonb" );
    lua_pushcfunction( lua, socket_setnonb );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "linger" );
    lua_pushcfunction( lua, socket_setlinger );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "nodelay" );
    lua_pushcfunction( lua, tcp_setnodelay );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "peerip" );
    lua_pushcfunction( lua, socket_peerip );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "localip" );
    lua_pushcfunction( lua, socket_localip );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "listen" );
    lua_pushcfunction( lua, tcp_listen );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "accept" );
    lua_pushcfunction( lua, tcp_accept );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "readn" );
    lua_pushcfunction( lua, tcp_readn );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "writen" );
    lua_pushcfunction( lua, tcp_writen );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "read" );
    lua_pushcfunction( lua, tcp_read );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "write" );
    lua_pushcfunction( lua, tcp_write );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "MSK_TIMEO_RCV" );
    lua_pushinteger( lua, TIMEO_RCV );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "MSK_TIMEO_SND" );
    lua_pushinteger( lua, TIMEO_SND );
    lua_rawset( lua, -3 );

    /****************************************************/
    luaL_newmetatable( lua, "luasocket.select.metatable" );

    lua_pushstring( lua, "__index" );
    lua_pushvalue( lua, -2 );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "__newindex" );
    lua_pushcfunction( lua, table_readonly );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "__gc" );
    lua_pushcfunction( lua, select_destroy );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "clear" );
    lua_pushcfunction( lua, select_clear );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "add" );
    lua_pushcfunction( lua, select_addfd );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "del" );
    lua_pushcfunction( lua, select_delfd );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "isset" );
    lua_pushcfunction( lua, select_isset );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "select" );
    lua_pushcfunction( lua, select_select );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "MSK_SEL_READ" );
    lua_pushinteger( lua, SELECT_READ );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "MSK_SEL_WRIT" );
    lua_pushinteger( lua, SELECT_WRIT );
    lua_rawset( lua, -3 );

    lua_pushstring( lua, "MSK_SEL_EXCE" );
    lua_pushinteger( lua, SELECT_EXCE );
    lua_rawset( lua, -3 );

    /****************************************************/

    luaL_newlib( lua, _mylibs );
    return 1;
}