///////////////////////////////////////////////////////////
// Network.cpp
// Implementation of the Class Network
// Created on: 14-一月-2008 16:31:54
// Original author: Aitec
///////////////////////////////////////////////////////////

#include "Network.h"

int Network::MakeTCPServer ( u_int16_t port )
{
 int sockfd;
 struct sockaddr_in sin;

 memset ( &sin, 0, sizeof ( sin ) );

 sin.sin_addr.s_addr = INADDR_ANY;
 sin.sin_family = AF_INET;
 sin.sin_port = htons ( port );

 #ifdef __linux__

 if ( ( sockfd = socket ( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) < 0 )
 #elif _WIN32
 if ( ( sockfd = socket ( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) == INVALID_SOCKET )
 #else
 if ( ( sockfd = socket ( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) < 0 )
 #endif
 {
 return RET_ERROR;
 }

 int val = 1;
 setsockopt ( sockfd, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*> ( &val ), sizeof ( val ) );

 #ifdef __linux__

 if ( bind ( sockfd, reinterpret_cast<struct sockaddr*> ( &sin ), sizeof ( sin ) ) < 0 )
 #elif _WIN32
 if ( bind ( sockfd, reinterpret_cast<struct sockaddr*> ( &sin ), sizeof ( sin ) ) == SOCKET_ERROR )
 #else
 if ( bind ( sockfd, reinterpret_cast<struct sockaddr*> ( &sin ), sizeof ( sin ) ) < 0 )
 #endif
 {
 Close ( sockfd );
 return RET_ERROR;
 }

 listen ( sockfd, 128 );

 return sockfd;
}

int Network::MakeTCPClient ( const char* ipaddr, u_int16_t port )
{
 int msec = 3000;
 bool cancel = false;
 return Connect1 ( ipaddr, port, msec, cancel );
}

int Network::MakeTCPClient ( const char* ipaddr, u_int16_t port, bool const& cancel )
{
 int msec = 3000;
 return Connect1 ( ipaddr, port, msec, cancel );
}

int Network::MakeTCPClient ( const char* ipaddr, u_int16_t port, int msec )
{
 bool cancel = false;
 return Connect1 ( ipaddr, port, msec, cancel );
}

int Network::MakeTCPClient ( u_int32_t ipaddr, u_int16_t port )
{
 int msec = 3000;
 bool cancel = false;
 return Connect1 ( ipaddr, port, msec, cancel );
}

int Network::MakeTCPClient ( u_int32_t ipaddr, u_int16_t port, bool const& cancel )
{
 int msec = 3000;
 return Connect1 ( ipaddr, port, msec, cancel );
}

int Network::MakeTCPClient ( u_int32_t ipaddr, u_int16_t port, int msec )
{
 bool cancel = false;
 return Connect1 ( ipaddr, port, msec, cancel );
}

int Network::MakeAccept ( int listenfd, struct sockaddr* saddr )
{
 int clifd;
 socklen_t len;

 if ( !saddr )
 {
 return RET_ERROR;
 }

 len = sizeof ( *saddr );

 if ( ( clifd = accept ( listenfd, reinterpret_cast<struct sockaddr*> ( saddr ), &len ) ) < 0 )
 {
 return RET_ERROR;
 }

 return clifd;
}

int Network::MakeAccept ( int listenfd )
{
 #ifdef __linux__
 struct sockaddr_un saddr;
 #elif _WIN32
 struct sockaddr_in saddr;
 #else
 struct sockaddr_un saddr;
 #endif
 return MakeAccept ( listenfd, reinterpret_cast<struct sockaddr*> ( &saddr ) );
}

int Network::MakeUDPServer ( u_int16_t port )
{
 int sockfd = socket ( PF_INET, SOCK_DGRAM, 0 );

 if ( sockfd < 0 )
 {
 return RET_ERROR;
 }

 int loop = 1;

 if ( setsockopt ( sockfd, SOL_SOCKET, SO_REUSEADDR, reinterpret_cast<char*> ( &loop ), sizeof ( loop ) ) < 0 )
 {
 Close ( sockfd );
 return RET_ERROR;
 }

 struct sockaddr_in sin;

 memset ( &sin, 0, sizeof ( sin ) );

 sin.sin_family = AF_INET;

 sin.sin_addr.s_addr = htonl ( INADDR_ANY );

 sin.sin_port = htons ( port );

 if ( bind ( sockfd, reinterpret_cast<struct sockaddr*> ( &sin ), sizeof ( sin ) ) < 0 )
 {
 Close ( sockfd );
 return RET_ERROR;
 }

 return sockfd;
}

int Network::MakeUDPClient()
{
 int sockfd = socket ( PF_INET, SOCK_DGRAM, 0 );

 if ( sockfd < 0 )
 {
 return RET_ERROR;
 }

 return sockfd;
}

int Network::MakeBcClient()
{
 int sockfd = socket ( PF_INET, SOCK_DGRAM, 0 );

 if ( sockfd < 0 )
 {
 return RET_ERROR;
 }

 //设置套接字为广播
 int broadcastFlag = 1;

 if ( setsockopt ( sockfd, SOL_SOCKET, SO_BROADCAST,
 ( char* ) &broadcastFlag, sizeof ( broadcastFlag ) ) != 0 )
 {
 Network::Close ( sockfd );
 sockfd = -1;
 }

 return sockfd;
}

#ifdef __linux__
int Network::MakeUnixServer ( const char* filename )
{
 int sockfd;
 struct sockaddr_un saddr;
 int mode = S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH | S_IWOTH;

 bzero ( &saddr, sizeof ( saddr ) );

 if ( !filename || strlen ( filename ) > UNIX_PATH_MAX )
 {
 return RET_ERROR;
 }

 saddr.sun_family = AF_UNIX;
 strncpy ( saddr.sun_path, filename, UNIX_PATH_MAX );

 unlink ( filename );

 sockfd = socket ( AF_UNIX, SOCK_STREAM, 0 );

 if ( sockfd < 0 )
 {
 return RET_ERROR;
 }

 if ( bind ( sockfd, reinterpret_cast<struct sockaddr*> ( &saddr ), SUN_LEN ( &saddr ) ) != 0 )
 {
 Close ( sockfd );
 return RET_ERROR;
 }

 listen ( sockfd, 128 );

 chmod ( filename, mode );

 return sockfd;
}

int Network::MakeUnixClient ( const char* filename )
{
 int sockfd;
 sockaddr_un saddr;

 if ( ( sockfd = socket ( AF_LOCAL, SOCK_STREAM, 0 ) ) < 0 )
 {
 return RET_ERROR;
 }

 bzero ( &saddr, sizeof ( struct sockaddr_un ) );

 saddr.sun_family = AF_UNIX;
 strncpy ( saddr.sun_path, filename, UNIX_PATH_MAX );

 if ( connect ( sockfd, reinterpret_cast<struct sockaddr*> ( &saddr ), sizeof ( saddr ) ) )
 {
 Close ( sockfd );
 return RET_ERROR;
 }

 return sockfd;
}
#endif

int Network::Select ( int nfds, fd_set* readfds, fd_set* writefds, fd_set* exceptfds, struct timeval* tv )
{
 while ( true )
 {
 int nselect = select ( nfds, readfds, writefds, exceptfds, tv );
 #ifdef __linux__

 if ( nselect < 0 && errno == EINTR )
 #elif _WIN32
 if ( false )
 #else
 if ( nselect < 0 && errno == EINTR )
 #endif
 {
 continue;
 }

 return nselect;
 }
}

int Network::Close ( int sockfd )
{
 #ifdef __linux__
 close ( sockfd );
 #elif _WIN32
 closesocket ( sockfd );
 #else
 close ( sockfd );
 #endif
 return RET_SUCCESS;
}

ssize_t Network::Recvn ( int fd, void* vptr, ssize_t n )
{
 ssize_t nleft;
 ssize_t nread;
 char* ptr;
 fd_set fds;
 struct timeval tv;

 ptr = reinterpret_cast<char*> ( vptr );
 nleft = n;

 while ( nleft > 0 )
 {
 #ifdef __linux__
 nread = read ( fd, ptr, nleft );
 #elif _WIN32
 nread = recv ( fd, ptr, nleft, 0 );
 #else
 nread = read ( fd, ptr, nleft );
 #endif

 #ifdef __linux__

 if ( nread < 0 )
 #elif _WIN32
 if ( nread == SOCKET_ERROR )
 #else
 if ( nread < 0 )
 #endif
 {
 #ifdef __linux__

 if ( errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR )
 {
 return RET_ERROR;
 }

 #elif _WIN32
 int err = GetLastError();

 if ( err != WSAEWOULDBLOCK )
 {
 return RET_ERROR;
 }

 #else

 if ( errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR )
 {
 return RET_ERROR;
 }

 #endif

 FD_ZERO ( &fds );
 FD_SET ( fd, &fds );
 tv.tv_sec = 5;
 tv.tv_usec = 0;
 int nselect = Select ( fd + 1, &fds, NULL, NULL, &tv );

 if ( nselect <= 0 )
 {
 return RET_ERROR;
 }
 }
 else if ( nread == 0 )
 {
 return RET_ERROR;
 }
 else
 {
 nleft -= nread;
 ptr += nread;
 }
 }

 return ( n - nleft );
}


ssize_t Network::Sendn ( int fd, const void* vptr, ssize_t n )
{
 ssize_t nleft;
 ssize_t nwritten;
 const char* ptr;

 fd_set fds;
 struct timeval tv;

 ptr = reinterpret_cast<const char*> ( vptr );
 nleft = n;

 while ( nleft > 0 )
 {
 #ifdef __linux__
 nwritten = write ( fd, ptr, nleft );
 #elif _WIN32
 nwritten = send ( fd, ptr, nleft, 0 );
 #else
 nwritten = write ( fd, ptr, nleft );
 #endif

 #ifdef __linux__

 if ( nwritten < 0 )
 #elif _WIN32
 if ( nwritten == SOCKET_ERROR )
 #else
 if ( nwritten < 0 )
 #endif
 {
 #ifdef __linux__

 if ( errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR )
 {
 return RET_ERROR;
 }

 #elif _WIN32
 int err = GetLastError();

 if ( err != WSAEWOULDBLOCK )
 {
 return RET_ERROR;
 }

 #else

 if ( errno != EWOULDBLOCK && errno != EAGAIN && errno != EINTR )
 {
 return RET_ERROR;
 }

 #endif

 FD_ZERO ( &fds );
 FD_SET ( fd, &fds );
 tv.tv_sec = 5;
 tv.tv_usec = 0;

 int nselect = Select ( fd + 1, NULL, &fds, NULL, &tv );

 if ( nselect <= 0 )
 {
 return RET_ERROR;
 }
 }
 else if ( nwritten == 0 )
 {
 return RET_ERROR;
 }
 else
 {
 nleft -= nwritten;
 ptr += nwritten;
 }
 }

 return ( n - nleft );
}

ssize_t Network::SendTo ( int sockfd, const void* vptr, ssize_t n, int flags, const struct sockaddr* addr, socklen_t len )
{
 return sendto ( sockfd, reinterpret_cast<const char*> ( vptr ), n, flags, addr, len );
}

ssize_t Network::RecvFrom ( int sockfd, void* vptr, ssize_t n, int flags, struct sockaddr* addr, socklen_t* len )
{
 return recvfrom ( sockfd, reinterpret_cast<char*> ( vptr ), n, flags, addr, len );
}

ssize_t Network::RecvFrom ( int sockfd, void* vptr, ssize_t n, int flags )
{
 struct sockaddr addr;
 socklen_t len = sizeof ( struct sockaddr );
 return recvfrom ( sockfd, reinterpret_cast<char*> ( vptr ), n, flags, &addr, &len );
}

int Network::JoinMultiCast ( int sockfd, struct ip_mreq* command )
{
 int loop = 1;

 if ( setsockopt ( sockfd, IPPROTO_IP, IP_MULTICAST_LOOP, reinterpret_cast<char*> ( &loop ), sizeof ( loop ) ) < 0 )
 {
 return RET_ERROR;
 }

 if ( setsockopt ( sockfd, IPPROTO_IP, IP_ADD_MEMBERSHIP, reinterpret_cast<char*> ( command ), sizeof ( *command ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
}

int Network::QuitMultiCast ( int sockfd, struct ip_mreq* command )
{
 if ( setsockopt ( sockfd, IPPROTO_IP, IP_DROP_MEMBERSHIP, reinterpret_cast<char*> ( command ), sizeof ( *command ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
}

int Network::SetNonBlock ( int sockfd )
{
 #ifdef __linux__
 int flags;

 if ( ( flags = fcntl ( sockfd, F_GETFL, 0 ) ) < 0 )
 {
 return RET_ERROR;
 }

 if ( fcntl ( sockfd, F_SETFL, flags | O_NONBLOCK ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
 #elif _WIN32
 u_long nonblock = 1;

 if ( ioctlsocket ( sockfd, FIONBIO, &nonblock ) == 0 )
 {
 return RET_SUCCESS;
 }
 else
 {
 return RET_ERROR;
 }

 #else
 int flags;

 if ( ( flags = fcntl ( sockfd, F_GETFL, 0 ) ) < 0 )
 {
 return RET_ERROR;
 }

 if ( fcntl ( sockfd, F_SETFL, flags | O_NONBLOCK ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
 #endif
}

int Network::SetBlock ( int sockfd )
{
 #ifdef __linux__
 int flags;

 if ( ( flags = fcntl ( sockfd, F_GETFL, 0 ) ) < 0 )
 {
 return RET_ERROR;
 }

 if ( fcntl ( sockfd, F_SETFL, flags & ( ~O_NONBLOCK ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
 #elif _WIN32
 u_long block = 0;

 if ( ioctlsocket ( sockfd, FIONBIO, &block ) == 0 )
 {
 return RET_SUCCESS;
 }
 else
 {
 return RET_ERROR;
 }

 #else
 int flags;

 if ( ( flags = fcntl ( sockfd, F_GETFL, 0 ) ) < 0 )
 {
 return RET_ERROR;
 }

 if ( fcntl ( sockfd, F_SETFL, flags & ( ~O_NONBLOCK ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
 #endif
}

#ifdef _WIN32
 #include "mstcpip.h"
#endif

int Network::SetKeepLive ( int sockfd, int idle, int intvl, int cnt )
{
 int opt = 1;

 if ( setsockopt ( sockfd, SOL_SOCKET, SO_KEEPALIVE, reinterpret_cast<char*> ( &opt ), sizeof ( opt ) ) < 0 )
 {
 return RET_ERROR;
 }

 #ifdef __linux__

 if ( setsockopt ( sockfd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof ( idle ) ) < 0 ||
 setsockopt ( sockfd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof ( intvl ) ) < 0 ||
 setsockopt ( sockfd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof ( cnt ) ) < 0 )
 {
 return RET_ERROR;
 }

 #elif _WIN32
 unsigned long dw;
 tcp_keepalive live, liveout;

 live.onoff = 1;
 live.keepalivetime = idle * 1000;
 live.keepaliveinterval = intvl * 1000;

 if ( WSAIoctl ( sockfd, SIO_KEEPALIVE_VALS, &live, sizeof ( live ), &liveout, sizeof ( liveout ), &dw, NULL, NULL ) < 0 )
 {
 return RET_ERROR;
 }

 #else

 if ( setsockopt ( sockfd, IPPROTO_TCP, TCP_KEEPIDLE, &idle, sizeof ( idle ) ) < 0 ||
 setsockopt ( sockfd, IPPROTO_TCP, TCP_KEEPINTVL, &intvl, sizeof ( intvl ) ) < 0 ||
 setsockopt ( sockfd, IPPROTO_TCP, TCP_KEEPCNT, &cnt, sizeof ( cnt ) ) < 0 )
 {
 return RET_ERROR;
 }

 #endif

 return RET_SUCCESS;
}

int Network::SetNonKeepLive ( int sockfd )
{
 int opt = 0;

 if ( setsockopt ( sockfd, SOL_SOCKET, SO_KEEPALIVE, reinterpret_cast<char*> ( &opt ), sizeof ( opt ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
}

int Network::SetSendBuf ( int sockfd, int Size )
{
 int opt = Size;

 if ( setsockopt ( sockfd, SOL_SOCKET, SO_SNDBUF, reinterpret_cast<char*> ( &opt ), sizeof ( opt ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
}

int Network::SetRecvBuf ( int sockfd, int Size )
{
 int opt = Size;

 if ( setsockopt ( sockfd, SOL_SOCKET, SO_RCVBUF, reinterpret_cast<char*> ( &opt ), sizeof ( opt ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
}

int Network::SetNonDelay ( int sockfd )
{
 int opt = 1;

 if ( setsockopt ( sockfd, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*> ( &opt ), sizeof ( opt ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
}

int Network::SetDelay ( int sockfd )
{
 int opt = 0;

 if ( setsockopt ( sockfd, IPPROTO_TCP, TCP_NODELAY, reinterpret_cast<char*> ( &opt ), sizeof ( opt ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
}


int Network::SetLinger ( int sockfd )
{
 #ifdef _WIN32
 linger opt;
 opt.l_onoff = 1; // (在closesocket()调用,但是还有数据没发送完毕的时候容许逗留)
 opt.l_linger = 0; // (容许逗留的时间为0秒)

 if ( setsockopt ( sockfd, SOL_SOCKET, SO_LINGER, ( const char* ) &opt, sizeof ( linger ) ) < 0 )
 {
 return RET_ERROR;
 }

 return RET_SUCCESS;
 #else
 return RET_ERROR;
 #endif
}


int Network::SetSockAddr ( struct sockaddr_in* socketAddr, int port )
{
 char broadcastName[16] = "255.255.255.255";
 int addrLen = sizeof ( struct sockaddr_in );

 bzero ( ( char* ) socketAddr, addrLen );
 socketAddr->sin_family = AF_INET;
 socketAddr->sin_port = htons ( port );
 socketAddr->sin_addr.s_addr = inet_addr ( broadcastName );

 return RET_SUCCESS;
}


bool Network::GetLocalIp ( int sockfd, char* ipaddr )
{
 if ( sockfd <= 0 || NULL == ipaddr )
 {
 return false;
 }

 struct sockaddr_in inaddr;

 socklen_t len = sizeof ( inaddr );

 memset ( &inaddr, 0, sizeof ( inaddr ) );

 if ( getsockname ( sockfd, ( struct sockaddr* ) &inaddr, &len ) == 0 )
 {
 strncpy ( ipaddr, inet_ntoa ( inaddr.sin_addr ), IPADDR_LEN );
 return true;
 }
 else
 {
 return false;
 }
}


bool Network::GetRemoteIp ( int sockfd, char* ipaddr )
{
 if ( sockfd <= 0 || NULL == ipaddr )
 {
 return false;
 }

 struct sockaddr_in inaddr;

 socklen_t len = sizeof ( inaddr );

 memset ( &inaddr, 0, sizeof ( inaddr ) );

 if ( getpeername ( sockfd, ( struct sockaddr* ) &inaddr, &len ) == 0 )
 {
 strncpy ( ipaddr, inet_ntoa ( inaddr.sin_addr ), IPADDR_LEN );
 return true;
 }
 else
 {
 return false;
 }
}


int Network::Connect1 ( const char* ipaddr, u_int16_t port, int msec, const bool& cancel )
{
 return Connect2 ( inet_addr ( ipaddr ), htons ( port ), msec, cancel );
}

int Network::Connect1 ( u_int32_t ipaddr, u_int16_t port, int msec, const bool& cancel )
{
 return Connect2 ( htonl ( ipaddr ), htons ( port ), msec, cancel );
}

int Network::Connect2 ( u_int32_t ipaddr, u_int16_t port, int msec, const bool& cancel )
{
 struct sockaddr_in addr;
 int sockfd;

 memset ( &addr, 0, sizeof ( addr ) );

 addr.sin_addr.s_addr = ipaddr;
 addr.sin_family = AF_INET;
 addr.sin_port = port;

 if ( ( sockfd = socket ( AF_INET, SOCK_STREAM, IPPROTO_TCP ) ) < 0 )
 {
 return RET_ERROR;
 }

 if ( Connect3 ( sockfd, reinterpret_cast<struct sockaddr*> ( &addr ), sizeof ( addr ), msec, cancel ) < 0 )
 {
 Network::Close ( sockfd );
 return RET_ERROR;
 }
 else
 {
 return sockfd;
 }
}

int Network::Connect3 ( int sockfd, const struct sockaddr* saptr, socklen_t salen, int msec, const bool& cancel )
{
 int n;
 int unit = 10;

 SetNonBlock ( sockfd );

 #ifdef __linux__

 if ( ( n = connect ( sockfd, saptr, salen ) ) < 0 )
 #elif _WIN32
 if ( ( n = connect ( sockfd, saptr, salen ) ) == SOCKET_ERROR )
 #else
 if ( ( n = connect ( sockfd, saptr, salen ) ) < 0 )
 #endif
 {
 #ifdef __linux__

 if ( errno != EINPROGRESS )
 {
 goto done;
 }

 #elif _WIN32
 int err = GetLastError();

 if ( err != WSAEWOULDBLOCK )
 {
 goto done;
 }

 #else

 if ( errno != EINPROGRESS )
 {
 goto done;
 }

 #endif
 }

 if ( n == 0 )
 {
 SetBlock ( sockfd );
 return RET_SUCCESS;
 }

 while ( ( msec = msec - unit ) >= 0 && !cancel )
 {
 struct timeval tval;
 fd_set rset, wset;

 FD_ZERO ( &rset );
 FD_ZERO ( &wset );
 FD_SET ( sockfd, &rset );
 FD_SET ( sockfd, &wset );

 tval.tv_sec = 0;
 tval.tv_usec = unit * 1000;

 if ( ( n = Network::Select ( sockfd + 1, &rset, &wset, NULL, &tval ) ) <= 0 )
 {
 continue;
 }

 if ( FD_ISSET ( sockfd, &rset ) || FD_ISSET ( sockfd, &wset ) )
 {
 int error = 0;
 socklen_t len = sizeof ( error );

 if ( getsockopt ( sockfd, SOL_SOCKET, SO_ERROR, ( char* ) &error, &len ) < 0 || error )
 {
 goto done;
 }

 SetBlock ( sockfd );
 return RET_SUCCESS;
 }
 else
 {
 goto done;
 }
 }

done:
 SetBlock ( sockfd );
 return RET_ERROR;
}

int Network::MakeInetServer ( u_int16_t port )
{
 return MakeTCPServer ( port );
}

int Network::MakeInetClient ( char* ipaddr, u_int16_t port )
{
 return MakeTCPClient ( ipaddr, port );
}

int Network::MakeInetClient ( char* ipaddr, u_int16_t port, int const& cancel )
{
 int sockfd;
 int count = 300;
 int msec = 10;

 while ( count-- > 0 )
 {
 if ( cancel == 0 )
 {
 if ( ( sockfd = Network::MakeTCPClient ( ipaddr, port, msec ) ) < 0 )
 {
 continue;
 }
 else
 {
 return sockfd;
 }
 }
 else
 {
 return RET_ERROR;
 }
 }

 return RET_ERROR;
}

int Network::MakeInetClientFast ( char* ipaddr, u_int16_t port, int msec )
{
 return MakeTCPClient ( ipaddr, port, msec );
}

ssize_t Network::Readn ( int fd, void* vptr, ssize_t n )
{
 return Recvn ( fd, vptr, n );
}

ssize_t Network::Writen ( int fd, void* vptr, ssize_t n )
{
 return Sendn ( fd, vptr, n );
}