00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackNetWinSocket.h"
00021
00022 namespace Jack
00023 {
00024
00025 SERVER_EXPORT int GetHostName ( char * name, int size )
00026 {
00027 if ( gethostname ( name, size ) == SOCKET_ERROR )
00028 {
00029 jack_error ( "Can't get 'hostname' : %s", strerror ( NET_ERROR_CODE ) );
00030 strcpy ( name, "default" );
00031 return -1;
00032 }
00033 return 0;
00034 }
00035
00036 win_net_error_t NetErrorList[] =
00037 {
00038 E ( 0, "No error" ),
00039 E ( WSAEINTR, "Interrupted system call" ),
00040 E ( WSAEBADF, "Bad file number" ),
00041 E ( WSAEACCES, "Permission denied" ),
00042 E ( WSAEFAULT, "Bad address" ),
00043 E ( WSAEINVAL, "Invalid argument" ),
00044 E ( WSAEMFILE, "Too many open sockets" ),
00045 E ( WSAEWOULDBLOCK, "Operation would block" ),
00046 E ( WSAEINPROGRESS, "Operation now in progress" ),
00047 E ( WSAEALREADY, "Operation already in progress" ),
00048 E ( WSAENOTSOCK, "Socket operation on non-socket" ),
00049 E ( WSAEDESTADDRREQ, "Destination address required" ),
00050 E ( WSAEMSGSIZE, "Message too long" ),
00051 E ( WSAEPROTOTYPE, "Protocol wrong type for socket" ),
00052 E ( WSAENOPROTOOPT, "Bad protocol option" ),
00053 E ( WSAEPROTONOSUPPORT, "Protocol not supported" ),
00054 E ( WSAESOCKTNOSUPPORT, "Socket type not supported" ),
00055 E ( WSAEOPNOTSUPP, "Operation not supported on socket" ),
00056 E ( WSAEPFNOSUPPORT, "Protocol family not supported" ),
00057 E ( WSAEAFNOSUPPORT, "Address family not supported" ),
00058 E ( WSAEADDRINUSE, "Address already in use" ),
00059 E ( WSAEADDRNOTAVAIL, "Can't assign requested address" ),
00060 E ( WSAENETDOWN, "Network is down" ),
00061 E ( WSAENETUNREACH, "Network is unreachable" ),
00062 E ( WSAENETRESET, "Net connection reset" ),
00063 E ( WSAECONNABORTED, "Software caused connection abort" ),
00064 E ( WSAECONNRESET, "Connection reset by peer" ),
00065 E ( WSAENOBUFS, "No buffer space available" ),
00066 E ( WSAEISCONN, "Socket is already connected" ),
00067 E ( WSAENOTCONN, "Socket is not connected" ),
00068 E ( WSAESHUTDOWN, "Can't send after socket shutdown" ),
00069 E ( WSAETOOMANYREFS, "Too many references, can't splice" ),
00070 E ( WSAETIMEDOUT, "Connection timed out" ),
00071 E ( WSAECONNREFUSED, "Connection refused" ),
00072 E ( WSAELOOP, "Too many levels of symbolic links" ),
00073 E ( WSAENAMETOOLONG, "File name too long" ),
00074 E ( WSAEHOSTDOWN, "Host is down" ),
00075 E ( WSAEHOSTUNREACH, "No route to host" ),
00076 E ( WSAENOTEMPTY, "Directory not empty" ),
00077 E ( WSAEPROCLIM, "Too many processes" ),
00078 E ( WSAEUSERS, "Too many users" ),
00079 E ( WSAEDQUOT, "Disc quota exceeded" ),
00080 E ( WSAESTALE, "Stale NFS file handle" ),
00081 E ( WSAEREMOTE, "Too many levels of remote in path" ),
00082 E ( WSASYSNOTREADY, "Network system is unavailable" ),
00083 E ( WSAVERNOTSUPPORTED, "Winsock version out of range" ),
00084 E ( WSANOTINITIALISED, "WSAStartup not yet called" ),
00085 E ( WSAEDISCON, "Graceful shutdown in progress" ),
00086 E ( WSAHOST_NOT_FOUND, "Host not found" ),
00087 E ( WSANO_DATA, "No host data of that type was found" ),
00088 { -1, NULL },
00089 };
00090
00091 SERVER_EXPORT const char* PrintError ( int error )
00092 {
00093 int i;
00094 for ( i = 0; NetErrorList[i].code >= 0; ++i )
00095 {
00096 if ( error == NetErrorList[i].code )
00097 return NetErrorList[i].msg;
00098 }
00099 return strerror ( error );
00100 }
00101
00102
00103 JackNetWinSocket::JackNetWinSocket()
00104 {
00105 fSockfd = 0;
00106 fSendAddr.sin_family = AF_INET;
00107 fSendAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00108 memset ( &fSendAddr.sin_zero, 0, 8 );
00109 fRecvAddr.sin_family = AF_INET;
00110 fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00111 memset ( &fRecvAddr.sin_zero, 0, 8 );
00112 }
00113
00114 JackNetWinSocket::JackNetWinSocket ( const char* ip, int port )
00115 {
00116 fSockfd = 0;
00117 fPort = port;
00118 fSendAddr.sin_family = AF_INET;
00119 fSendAddr.sin_port = htons ( port );
00120 fSendAddr.sin_addr.s_addr = inet_addr ( ip );
00121 memset ( &fSendAddr.sin_zero, 0, 8 );
00122 fRecvAddr.sin_family = AF_INET;
00123 fRecvAddr.sin_port = htons ( port );
00124 fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00125 memset ( &fRecvAddr.sin_zero, 0, 8 );
00126 }
00127
00128 JackNetWinSocket::JackNetWinSocket ( const JackNetWinSocket& socket )
00129 {
00130 fSockfd = 0;
00131 fPort = socket.fPort;
00132 fSendAddr = socket.fSendAddr;
00133 fRecvAddr = socket.fRecvAddr;
00134 }
00135
00136 JackNetWinSocket::~JackNetWinSocket()
00137 {
00138 Close();
00139 }
00140
00141 JackNetWinSocket& JackNetWinSocket::operator= ( const JackNetWinSocket& socket )
00142 {
00143 if ( this != &socket )
00144 {
00145 fSockfd = 0;
00146 fPort = socket.fPort;
00147 fSendAddr = socket.fSendAddr;
00148 fRecvAddr = socket.fRecvAddr;
00149 }
00150 return *this;
00151 }
00152
00153
00154 int JackNetWinSocket::NewSocket()
00155 {
00156 if ( fSockfd )
00157 {
00158 Close();
00159 Reset();
00160 }
00161 fSockfd = socket ( AF_INET, SOCK_DGRAM, 0 );
00162 return fSockfd;
00163 }
00164
00165 int JackNetWinSocket::Bind()
00166 {
00167 return bind ( fSockfd, reinterpret_cast<SOCKADDR*> ( &fRecvAddr ), sizeof ( SOCKADDR ) );
00168 }
00169
00170 int JackNetWinSocket::BindWith ( const char* ip )
00171 {
00172 fRecvAddr.sin_addr.s_addr = inet_addr ( ip );
00173 return Bind();
00174 }
00175
00176 int JackNetWinSocket::BindWith ( int port )
00177 {
00178 fRecvAddr.sin_port = htons ( port );
00179 return Bind();
00180 }
00181
00182 int JackNetWinSocket::Connect()
00183 {
00184 return connect ( fSockfd, reinterpret_cast<SOCKADDR*> ( &fSendAddr ), sizeof ( SOCKADDR ) );
00185 }
00186
00187 int JackNetWinSocket::ConnectTo ( const char* ip )
00188 {
00189 fSendAddr.sin_addr.s_addr = inet_addr ( ip );
00190 return Connect();
00191 }
00192
00193 void JackNetWinSocket::Close()
00194 {
00195 if ( fSockfd )
00196 closesocket ( fSockfd );
00197 fSockfd = 0;
00198 }
00199
00200 void JackNetWinSocket::Reset()
00201 {
00202 fSendAddr.sin_family = AF_INET;
00203 fSendAddr.sin_port = htons ( fPort );
00204 fSendAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00205 memset ( &fSendAddr.sin_zero, 0, 8 );
00206 fRecvAddr.sin_family = AF_INET;
00207 fRecvAddr.sin_port = htons ( fPort );
00208 fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00209 memset ( &fRecvAddr.sin_zero, 0, 8 );
00210 }
00211
00212 bool JackNetWinSocket::IsSocket()
00213 {
00214 return ( fSockfd ) ? true : false;
00215 }
00216
00217
00218 void JackNetWinSocket::SetPort ( int port )
00219 {
00220 fPort = port;
00221 fSendAddr.sin_port = htons ( port );
00222 fRecvAddr.sin_port = htons ( port );
00223 }
00224
00225 int JackNetWinSocket::GetPort()
00226 {
00227 return fPort;
00228 }
00229
00230
00231 int JackNetWinSocket::SetAddress ( const char* ip, int port )
00232 {
00233 fSendAddr.sin_addr.s_addr = inet_addr ( ip );
00234 fSendAddr.sin_port = htons ( port );
00235 return 0;
00236 }
00237
00238 char* JackNetWinSocket::GetSendIP()
00239 {
00240 return inet_ntoa ( fSendAddr.sin_addr );
00241 }
00242
00243 char* JackNetWinSocket::GetRecvIP()
00244 {
00245 return inet_ntoa ( fRecvAddr.sin_addr );
00246 }
00247
00248
00249 int JackNetWinSocket::GetName ( char* name )
00250 {
00251 return gethostname ( name, 255 );
00252 }
00253
00254 int JackNetWinSocket::JoinMCastGroup ( const char* ip )
00255 {
00256 struct ip_mreq multicast_req;
00257 multicast_req.imr_multiaddr.s_addr = inet_addr ( ip );
00258 multicast_req.imr_interface.s_addr = htonl ( INADDR_ANY );
00259
00260 return SetOption ( IPPROTO_IP, 12, &multicast_req, sizeof ( multicast_req ) );
00261 }
00262
00263
00264 int JackNetWinSocket::SetOption ( int level, int optname, const void* optval, SOCKLEN optlen )
00265 {
00266 return setsockopt ( fSockfd, level, optname, static_cast<const char*> ( optval ), optlen );
00267 }
00268
00269 int JackNetWinSocket::GetOption ( int level, int optname, void* optval, SOCKLEN* optlen )
00270 {
00271 return getsockopt ( fSockfd, level, optname, static_cast<char*> ( optval ), optlen );
00272 }
00273
00274
00275 int JackNetWinSocket::SetTimeOut ( int usec )
00276 {
00277 jack_log ( "JackNetWinSocket::SetTimeout %d usec", usec );
00278
00279
00280 if ( ( usec < 0 ) || ( usec > 10000000 ) )
00281 return SOCKET_ERROR;
00282 int time = usec / 1000;
00283 return SetOption ( SOL_SOCKET, SO_RCVTIMEO, &time, sizeof ( time ) );
00284 }
00285
00286
00287 int JackNetWinSocket::SetLocalLoop()
00288 {
00289
00290
00291
00292
00293
00294
00295 char disable = 1;
00296 return SetOption ( IPPROTO_IP, IP_MULTICAST_LOOP, &disable, sizeof ( disable ) );
00297 }
00298
00299
00300 int JackNetWinSocket::SendTo ( const void* buffer, size_t nbytes, int flags )
00301 {
00302 return sendto ( fSockfd, reinterpret_cast<const char*> ( buffer ), nbytes, flags, reinterpret_cast<SOCKADDR*> ( &fSendAddr ), sizeof ( SOCKADDR ) );
00303 }
00304
00305 int JackNetWinSocket::SendTo ( const void* buffer, size_t nbytes, int flags, const char* ip )
00306 {
00307 fSendAddr.sin_addr.s_addr = inet_addr ( ip );
00308 return SendTo ( buffer, nbytes, flags );
00309 }
00310
00311 int JackNetWinSocket::Send ( const void* buffer, size_t nbytes, int flags )
00312 {
00313 return send ( fSockfd, reinterpret_cast<const char*> ( buffer ), nbytes, flags );
00314 }
00315
00316 int JackNetWinSocket::RecvFrom ( void* buffer, size_t nbytes, int flags )
00317 {
00318 SOCKLEN addr_len = sizeof ( SOCKADDR );
00319 return recvfrom ( fSockfd, reinterpret_cast<char*> ( buffer ), nbytes, flags, reinterpret_cast<SOCKADDR*> ( &fRecvAddr ), &addr_len );
00320 }
00321
00322 int JackNetWinSocket::Recv ( void* buffer, size_t nbytes, int flags )
00323 {
00324 return recv ( fSockfd, reinterpret_cast<char*> ( buffer ), nbytes, flags );
00325 }
00326
00327 int JackNetWinSocket::CatchHost ( void* buffer, size_t nbytes, int flags )
00328 {
00329 SOCKLEN addr_len = sizeof ( SOCKADDR );
00330 return recvfrom ( fSockfd, reinterpret_cast<char*> ( buffer ), nbytes, flags, reinterpret_cast<SOCKADDR*> ( &fSendAddr ), &addr_len );
00331 }
00332
00333 net_error_t JackNetWinSocket::GetError()
00334 {
00335 switch ( NET_ERROR_CODE )
00336 {
00337 case WSABASEERR:
00338 return NET_NO_ERROR;
00339 case WSAETIMEDOUT:
00340 return NET_NO_DATA;
00341 case WSAEWOULDBLOCK:
00342 return NET_NO_DATA;
00343 case WSAECONNREFUSED:
00344 return NET_CONN_ERROR;
00345 case WSAECONNRESET:
00346 return NET_CONN_ERROR;
00347 case WSAEACCES:
00348 return NET_CONN_ERROR;
00349 case WSAECONNABORTED:
00350 return NET_CONN_ERROR;
00351 case WSAEHOSTDOWN:
00352 return NET_CONN_ERROR;
00353 case WSAEHOSTUNREACH:
00354 return NET_CONN_ERROR;
00355 default:
00356 return NET_OP_ERROR;
00357 }
00358 }
00359 }
00360