417 lines
12 KiB
C++
417 lines
12 KiB
C++
#include "stdafx.h"
|
|
#include "L2Packet_NetLayer.h"
|
|
|
|
// keeps result of inet_ntoa
|
|
char l2pnet_static_inet_ntoa_buffer[32];
|
|
|
|
int L2PNet_InitDefault()
|
|
{
|
|
l2pnet_static_inet_ntoa_buffer[0] = 0;
|
|
return 1;
|
|
}
|
|
|
|
/** Closes winsock (wrapper around WSACleanup() **/
|
|
int L2PNet_Cleanup()
|
|
{
|
|
// does nothing
|
|
return 1;
|
|
}
|
|
|
|
/** Creates TCP socket
|
|
** returns 0xFFFFFFFF on error, on success - [1..0xFFFFFFFE] :) */
|
|
unsigned int L2PNet_TCPsocket_create( bool bUse_NonBlock_IO_Mode )
|
|
{
|
|
int sock = socket( PF_INET, SOCK_STREAM, IPPROTO_TCP );
|
|
if( sock == -1 ) return 0xFFFFFFFF;
|
|
if( bUse_NonBlock_IO_Mode )
|
|
{
|
|
int fl = fcntl( sock, F_GETFL, 0 );
|
|
fl |= O_NONBLOCK;
|
|
fcntl( sock, F_SETFL, fl );
|
|
}
|
|
return sock;
|
|
}
|
|
|
|
/** Waits for socket to be ready for read or write
|
|
** returns 1 on success, 0 on timeout, -1 on error */
|
|
int L2PNet_select( unsigned int sock, // socket descriptor
|
|
unsigned int dwSelFlags, // flags what to wait for: L2PNET_SELECT_READ/WRITE
|
|
long lWaitMilliSecs, // wait timeout in milliseconds
|
|
int *pbReadyForRead, // will be 1, if ready to read, 0 otherwise (may be NULL)
|
|
int *pbReadyForWrite ) // will be 1, if ready to write, 0 otherwise (may be NULL)
|
|
{
|
|
// L2PNet_select_dumb
|
|
if( dwSelFlags == 0 ) return -1;
|
|
if( pbReadyForRead ) (*pbReadyForRead) = 0;
|
|
if( pbReadyForWrite ) (*pbReadyForWrite) = 0;
|
|
fd_set readFds;
|
|
fd_set writeFds;
|
|
fd_set *prfds = NULL, *pwfds = NULL;
|
|
FD_ZERO(&readFds);
|
|
FD_ZERO(&writeFds);
|
|
if( dwSelFlags & L2PNET_SELECT_READ )
|
|
{
|
|
FD_SET( sock, &readFds );
|
|
prfds = &readFds;
|
|
}
|
|
if( dwSelFlags & L2PNET_SELECT_WRITE )
|
|
{
|
|
FD_SET( sock, &writeFds );
|
|
pwfds = &writeFds;
|
|
}
|
|
long microsecs = lWaitMilliSecs * 1000; // 1 millisec = 1 000 microsec
|
|
long secs = microsecs / 1000000; // 1 000 000
|
|
microsecs -= secs * 1000000;
|
|
struct timeval tv;
|
|
tv.tv_sec = secs;
|
|
tv.tv_usec = microsecs;
|
|
int ret = select( sock+1, prfds, pwfds, NULL, &tv );
|
|
if( ret == 0 ) return 0; // timeout failed
|
|
if( ret == -1 ) return -1; // select error
|
|
if( L2PNet_FD_ISSET( sock, &readFds ) && pbReadyForRead ) (*pbReadyForRead) = 1; // ready to recv
|
|
if( L2PNet_FD_ISSET( sock, &writeFds ) && pbReadyForWrite ) (*pbReadyForWrite) = 1; // ready to write
|
|
//
|
|
return ret;
|
|
}
|
|
|
|
/** Check state for multiple sockets */
|
|
int L2PNet_select_multi( unsigned int *socks_array, // socket descriptors array
|
|
unsigned int socks_count, // socket descriptors array item count
|
|
unsigned int dwSelFlags, // flags what to wait for: L2PNET_SELECT_READ/WRITE
|
|
long lWaitMilliSecs, // wait timeout in milliseconds
|
|
int *pbReadyForRead, // array! will be 1, if ready to read, 0 otherwise
|
|
int *pbReadyForWrite ) // array! will be 1, if ready to write, 0 otherwise
|
|
{
|
|
if( (!socks_array) || (socks_count==0) || (dwSelFlags == 0) ) return -1;
|
|
if( pbReadyForRead ) memset( pbReadyForRead, 0, sizeof(int)*socks_count );
|
|
if( pbReadyForWrite ) memset( pbReadyForWrite, 0, sizeof(int)*socks_count );
|
|
fd_set readFds;
|
|
fd_set writeFds;
|
|
fd_set *prfds = NULL, *pwfds = NULL;
|
|
FD_ZERO(&readFds);
|
|
FD_ZERO(&writeFds);
|
|
unsigned int i = 0;
|
|
int ret = 0;
|
|
if( dwSelFlags & L2PNET_SELECT_READ )
|
|
{
|
|
for( i=0; i<socks_count; i++ ) FD_SET( socks_array[i], &readFds );
|
|
prfds = &readFds;
|
|
}
|
|
if( dwSelFlags & L2PNET_SELECT_WRITE )
|
|
{
|
|
for( i=0; i<socks_count; i++ ) FD_SET( socks_array[i], &writeFds );
|
|
pwfds = &writeFds;
|
|
}
|
|
// calc nfds - get max socket fd
|
|
int nfds = socks_array[0];
|
|
for( i=0; i<socks_count; i++ ) if( nfds > (int)(socks_array[i]) ) nfds = (int)(socks_array[i]);
|
|
// init timeval
|
|
long microsecs = lWaitMilliSecs * 1000; // 1 millisec = 1 000 microsec
|
|
long secs = microsecs / 1000000; // 1 second = 1 000 000 microseconds
|
|
microsecs -= secs * 1000000;
|
|
struct timeval tv;
|
|
tv.tv_sec = secs;
|
|
tv.tv_usec = microsecs;
|
|
ret = select( nfds+1, prfds, pwfds, NULL, &tv );
|
|
if( ret == 0 ) return 0; // timeout failed
|
|
if( ret == -1 ) return -1; // select error
|
|
// results
|
|
for( i=0; i<socks_count; i++ )
|
|
{
|
|
if( L2PNet_FD_ISSET( socks_array[i], &readFds ) && pbReadyForRead ) pbReadyForRead[i] = 1;
|
|
if( L2PNet_FD_ISSET( socks_array[i], &writeFds ) && pbReadyForWrite ) pbReadyForWrite[i] = 1;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/** Receives data from socket.
|
|
** returns number of bytes read, 0 on connection closed, -1 on error */
|
|
int L2PNet_recv( unsigned int sock, unsigned char *pucRecvBuffer, unsigned int uBufferSizeBytes )
|
|
{
|
|
int ret = -1;
|
|
ret = recv( sock, pucRecvBuffer, (int)uBufferSizeBytes, 0 );
|
|
return ret;
|
|
}
|
|
|
|
/** Writes data to socket.
|
|
** returns number of bytes sent, -1 on error */
|
|
int L2PNet_send( unsigned int sock, const unsigned char *pucSendBuffer, unsigned int uNumberOfBytesToSend )
|
|
{
|
|
int ret = -1;
|
|
ret = send( sock, pucSendBuffer, (int)uNumberOfBytesToSend, 0 );
|
|
return ret;
|
|
}
|
|
|
|
/** Stops data transfer on socket, preparing to close. */
|
|
int L2PNet_shutdown( unsigned int sock )
|
|
{
|
|
int ret = -1;
|
|
ret = shutdown( sock, 0 );
|
|
return ret;
|
|
}
|
|
|
|
/** Closes socket and frees its resources from system. */
|
|
int L2PNet_closesocket( unsigned int sock )
|
|
{
|
|
int ret = -1;
|
|
ret = close( sock );
|
|
return ret;
|
|
}
|
|
|
|
/** Connects socket to specified address
|
|
** returns -1 on error/timeout, 0 on error */
|
|
int L2PNet_connect( unsigned int sock, const char *ip, unsigned short port )
|
|
{
|
|
if( !ip || (port == 0) ) return -1;
|
|
int ret = -1;
|
|
sockaddr_in addr;
|
|
memset( &addr, 0, sizeof(addr) );
|
|
addr.sin_family = AF_INET;
|
|
addr.sin_port = L2PNet_htons( port );
|
|
addr.sin_addr.s_addr = L2PNet_inet_addr( ip );
|
|
if( addr.sin_addr.s_addr == INADDR_NONE )
|
|
{
|
|
// try to resolve
|
|
L2PNet_resolveHostname( ip, &addr.sin_addr );
|
|
}
|
|
ret = connect( sock, (const sockaddr *)&addr, sizeof(addr) );
|
|
return ret;
|
|
}
|
|
|
|
/** Binds socket to specified address
|
|
** returns 0 on ok, -1 on error */
|
|
int L2PNet_bind( unsigned int sock, const char *ip, unsigned short port )
|
|
{
|
|
sockaddr_in addr;
|
|
memset( &addr, 0, sizeof(addr) );
|
|
addr.sin_family = AF_INET;
|
|
addr.sin_port = L2PNet_htons( port );
|
|
addr.sin_addr.s_addr = L2PNet_inet_addr( ip );
|
|
if( addr.sin_addr.s_addr == INADDR_NONE )
|
|
{
|
|
// try to resolve
|
|
L2PNet_resolveHostname( ip, &addr.sin_addr );
|
|
}
|
|
int ret = bind( sock, (const sockaddr *)&addr, sizeof(addr) );
|
|
return ret;
|
|
}
|
|
|
|
/** Starts listening on socket to aceept incoming connections
|
|
** returns 0 on ok, -1 on error */
|
|
int L2PNet_listen( unsigned int sock )
|
|
{
|
|
int ret = -1;
|
|
ret = listen( sock, 1 );
|
|
return ret;
|
|
}
|
|
|
|
/** Accepts incoming connection from socket
|
|
** returns accepted socket on OK, -1 on error */
|
|
unsigned int L2PNet_accept( unsigned int sock, char *acceptedIP, unsigned short *acceptedPort )
|
|
{
|
|
sockaddr_in addr;
|
|
memset( &addr, 0, sizeof(addr) );
|
|
socklen_t addrlen = sizeof(addr);
|
|
int ret = accept( sock, (sockaddr *)&addr, &addrlen );
|
|
if( ret != -1 )
|
|
{
|
|
sprintf( acceptedIP, "%d.%d.%d.%d",
|
|
(int)( (addr.sin_addr.s_addr & 0x000000FF) ),
|
|
(int)( (addr.sin_addr.s_addr & 0x0000FF00) >> 8),
|
|
(int)( (addr.sin_addr.s_addr & 0x00FF0000) >> 16),
|
|
(int)( (addr.sin_addr.s_addr & 0xFF000000) >> 24)
|
|
);
|
|
(*acceptedPort) = L2PNet_ntohs( addr.sin_port );
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/** Wrapper around standard select() function **/
|
|
/** !!! CANNOT BE OVERRIDED !!! **/
|
|
int L2PNet_select_wrapper_DUMB( int nfds,
|
|
fd_set *readFds,
|
|
fd_set *writeFds,
|
|
fd_set *exceptFds,
|
|
const struct timeval *timeout )
|
|
{
|
|
timeval *tv_noconst = const_cast<timeval *>(timeout);
|
|
int ret = select( nfds, readFds, writeFds, exceptFds, tv_noconst );
|
|
return ret;
|
|
}
|
|
|
|
/** Wrapper around WSAGetLastError() **/
|
|
int L2PNet_WSAGetLastError(void)
|
|
{
|
|
int ret = errno;
|
|
return ret;
|
|
}
|
|
|
|
/** Wrapper around WSASetLastError() **/
|
|
void L2PNet_WSASetLastError( int iError )
|
|
{
|
|
iError = 0;
|
|
// does nothing
|
|
return;
|
|
}
|
|
|
|
/** Prints Winsock error code as string to specified file **/
|
|
// incomplete errors list!!!!
|
|
int L2PNet_WSAPrintLastError( FILE *f, int wsaerr )
|
|
{
|
|
if( !f ) return -1;
|
|
return fprintf( f, "%d: %s", wsaerr, strerror( wsaerr ) );
|
|
}
|
|
|
|
|
|
|
|
//
|
|
// from reactos's ws2_32.dll
|
|
//
|
|
|
|
/* WORD network to host order conversion for little endian machines */
|
|
#define WN2H(w) \
|
|
((((w) & 0xFF00) >> 8) | \
|
|
(((w) & 0x00FF) << 8))
|
|
|
|
/* WORD host to network byte order conversion for little endian machines */
|
|
#define WH2N(w) \
|
|
((((w) & 0xFF00) >> 8) | \
|
|
(((w) & 0x00FF) << 8))
|
|
|
|
/* DWORD network to host byte order conversion for little endian machines */
|
|
#define DN2H(dw) \
|
|
((((dw) & 0xFF000000L) >> 24) | \
|
|
(((dw) & 0x00FF0000L) >> 8) | \
|
|
(((dw) & 0x0000FF00L) << 8) | \
|
|
(((dw) & 0x000000FFL) << 24))
|
|
|
|
/* DWORD host to network byte order conversion for little endian machines */
|
|
#define DH2N(dw) \
|
|
((((dw) & 0xFF000000L) >> 24) | \
|
|
(((dw) & 0x00FF0000L) >> 8) | \
|
|
(((dw) & 0x0000FF00L) << 8) | \
|
|
(((dw) & 0x000000FFL) << 24))
|
|
|
|
unsigned long L2PNet_htonl( unsigned long hostlong )
|
|
{
|
|
return DH2N(hostlong);
|
|
}
|
|
|
|
|
|
unsigned short L2PNet_htons( unsigned short hostshort )
|
|
{
|
|
return WH2N(hostshort);
|
|
}
|
|
|
|
|
|
unsigned long L2PNet_ntohl( unsigned long netlong )
|
|
{
|
|
return DN2H(netlong);
|
|
}
|
|
|
|
|
|
unsigned short L2PNet_ntohs( unsigned short netshort )
|
|
{
|
|
return WN2H(netshort);
|
|
}
|
|
|
|
/*
|
|
* FUNCTION: Converts a string containing an IPv4 address to an unsigned long
|
|
* ARGUMENTS:
|
|
* cp = Pointer to string with address to convert
|
|
* RETURNS:
|
|
* Binary representation of IPv4 address, or INADDR_NONE
|
|
*/
|
|
unsigned long L2PNet_inet_addr( const char *cp )
|
|
{
|
|
unsigned int i;
|
|
char *p;
|
|
unsigned long u = 0;
|
|
p = (char *)cp;
|
|
if( !p ) return INADDR_NONE;
|
|
if( strlen( p ) == 0 ) return INADDR_NONE;
|
|
if( p[0] == 0 ) return INADDR_NONE;
|
|
if( strcmp( p, " " ) == 0 ) return 0;
|
|
|
|
for( i = 0; i <= 3; i++ )
|
|
{
|
|
u += ( strtoul( p, &p, 0 ) << (i * 8) );
|
|
if( strlen( p ) == 0 ) return u;
|
|
if( p[0] != '.' ) return INADDR_NONE;
|
|
p++;
|
|
}
|
|
|
|
return u;
|
|
}
|
|
|
|
|
|
char *L2PNet_inet_ntoa( struct in_addr in )
|
|
{
|
|
char b[10];
|
|
char *p = l2pnet_static_inet_ntoa_buffer;
|
|
//itoa( in.s_addr & 0xFF, b, 10 );
|
|
sprintf( b, "%d", (int)(in.s_addr & 0xFF) );
|
|
strcpy( p, b );
|
|
//itoa( (in.s_addr >> 8) & 0xFF, b, 10 );
|
|
sprintf( b, "%d", (int)((in.s_addr >> 8) & 0xFF) );
|
|
strcat( p, "." );
|
|
strcat( p, b );
|
|
//itoa( (in.s_addr >> 16) & 0xFF, b, 10 );
|
|
sprintf( b, "%d", (int)((in.s_addr >> 16) & 0xFF) );
|
|
strcat( p, "." );
|
|
strcat( p, b );
|
|
//itoa( (in.s_addr >> 24) & 0xFF, b, 10 );
|
|
sprintf( b, "%d", (int)((in.s_addr >> 24) & 0xFF) );
|
|
strcat( p, "." );
|
|
strcat( p, b );
|
|
|
|
return l2pnet_static_inet_ntoa_buffer;
|
|
}
|
|
|
|
// :(((
|
|
int L2PNet_FD_ISSET( unsigned int sock, fd_set *set )
|
|
{
|
|
int ret = FD_ISSET( sock, set );
|
|
return ret;
|
|
}
|
|
|
|
|
|
bool L2PNet_resolveHostname( const char *hostname, struct in_addr *pinAddr )
|
|
{
|
|
in_addr addr;
|
|
addr.s_addr = L2PNet_inet_addr( hostname );
|
|
if( addr.s_addr == INADDR_NONE )
|
|
{
|
|
addrinfo addr_hints;
|
|
memset( &addr_hints, 0, sizeof(addr_hints) );
|
|
addr_hints.ai_family = AF_INET;
|
|
addr_hints.ai_socktype = SOCK_STREAM;
|
|
addrinfo *retAddr = NULL;
|
|
int ret = getaddrinfo( hostname, NULL, &addr_hints, &retAddr );
|
|
if( ret == 0 ) // OK
|
|
{
|
|
if( retAddr )
|
|
{
|
|
pinAddr->s_addr = ((sockaddr_in *)retAddr->ai_addr)->sin_addr.s_addr;
|
|
freeaddrinfo( retAddr );
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
pinAddr->s_addr = INADDR_NONE;
|
|
return false;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pinAddr->s_addr = INADDR_NONE;
|
|
return false;
|
|
}
|
|
}
|
|
else // hostname is already IP address
|
|
{
|
|
pinAddr->s_addr = addr.s_addr;
|
|
}
|
|
return true;
|
|
}
|