00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020 #include "JackNetUnixSocket.h"
00021
00022 namespace Jack
00023 {
00024
00025 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 SOCKET_ERROR;
00032 }
00033 return 0;
00034 }
00035
00036
00037 JackNetUnixSocket::JackNetUnixSocket()
00038 {
00039 fSockfd = 0;
00040 fPort = 0;
00041 fSendAddr.sin_family = AF_INET;
00042 fSendAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00043 memset ( &fSendAddr.sin_zero, 0, 8 );
00044 fRecvAddr.sin_family = AF_INET;
00045 fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00046 memset ( &fRecvAddr.sin_zero, 0, 8 );
00047 }
00048
00049 JackNetUnixSocket::JackNetUnixSocket ( const char* ip, int port )
00050 {
00051 fSockfd = 0;
00052 fPort = port;
00053 fSendAddr.sin_family = AF_INET;
00054 fSendAddr.sin_port = htons ( port );
00055 inet_aton ( ip, &fSendAddr.sin_addr );
00056 memset ( &fSendAddr.sin_zero, 0, 8 );
00057 fRecvAddr.sin_family = AF_INET;
00058 fRecvAddr.sin_port = htons ( port );
00059 fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00060 memset ( &fRecvAddr.sin_zero, 0, 8 );
00061 }
00062
00063 JackNetUnixSocket::JackNetUnixSocket ( const JackNetUnixSocket& socket )
00064 {
00065 fSockfd = 0;
00066 fPort = socket.fPort;
00067 fSendAddr = socket.fSendAddr;
00068 fRecvAddr = socket.fRecvAddr;
00069 }
00070
00071 JackNetUnixSocket::~JackNetUnixSocket()
00072 {
00073 Close();
00074 }
00075
00076 JackNetUnixSocket& JackNetUnixSocket::operator= ( const JackNetUnixSocket& socket )
00077 {
00078 if ( this != &socket )
00079 {
00080 fSockfd = 0;
00081 fPort = socket.fPort;
00082 fSendAddr = socket.fSendAddr;
00083 fRecvAddr = socket.fRecvAddr;
00084 }
00085 return *this;
00086 }
00087
00088
00089 int JackNetUnixSocket::NewSocket()
00090 {
00091 if ( fSockfd )
00092 {
00093 Close();
00094 Reset();
00095 }
00096 fSockfd = socket ( AF_INET, SOCK_DGRAM, 0 );
00097 return fSockfd;
00098 }
00099
00100 int JackNetUnixSocket::Bind()
00101 {
00102 return bind ( fSockfd, reinterpret_cast<socket_address_t*> ( &fRecvAddr ), sizeof ( socket_address_t ) );
00103 }
00104
00105 int JackNetUnixSocket::BindWith ( const char* ip )
00106 {
00107 int addr_conv = inet_aton ( ip, &fRecvAddr.sin_addr );
00108 if ( addr_conv < 0 )
00109 return addr_conv;
00110 return Bind();
00111 }
00112
00113 int JackNetUnixSocket::BindWith ( int port )
00114 {
00115 fRecvAddr.sin_port = htons ( port );
00116 return Bind();
00117 }
00118
00119 int JackNetUnixSocket::Connect()
00120 {
00121 return connect ( fSockfd, reinterpret_cast<socket_address_t*> ( &fSendAddr ), sizeof ( socket_address_t ) );
00122 }
00123
00124 int JackNetUnixSocket::ConnectTo ( const char* ip )
00125 {
00126 int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
00127 if ( addr_conv < 0 )
00128 return addr_conv;
00129 return Connect();
00130 }
00131
00132 void JackNetUnixSocket::Close()
00133 {
00134 if ( fSockfd )
00135 close ( fSockfd );
00136 fSockfd = 0;
00137 }
00138
00139 void JackNetUnixSocket::Reset()
00140 {
00141 fSendAddr.sin_family = AF_INET;
00142 fSendAddr.sin_port = htons ( fPort );
00143 fSendAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00144 memset ( &fSendAddr.sin_zero, 0, 8 );
00145 fRecvAddr.sin_family = AF_INET;
00146 fRecvAddr.sin_port = htons ( fPort );
00147 fRecvAddr.sin_addr.s_addr = htonl ( INADDR_ANY );
00148 memset ( &fRecvAddr.sin_zero, 0, 8 );
00149 }
00150
00151 bool JackNetUnixSocket::IsSocket()
00152 {
00153 return ( fSockfd ) ? true : false;
00154 }
00155
00156
00157 void JackNetUnixSocket::SetPort ( int port )
00158 {
00159 fPort = port;
00160 fSendAddr.sin_port = htons ( port );
00161 fRecvAddr.sin_port = htons ( port );
00162 }
00163
00164 int JackNetUnixSocket::GetPort()
00165 {
00166 return fPort;
00167 }
00168
00169
00170 int JackNetUnixSocket::SetAddress ( const char* ip, int port )
00171 {
00172 int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
00173 if ( addr_conv < 0 )
00174 return addr_conv;
00175 fSendAddr.sin_port = htons ( port );
00176 return 0;
00177 }
00178
00179 char* JackNetUnixSocket::GetSendIP()
00180 {
00181 return inet_ntoa ( fSendAddr.sin_addr );
00182 }
00183
00184 char* JackNetUnixSocket::GetRecvIP()
00185 {
00186 return inet_ntoa ( fRecvAddr.sin_addr );
00187 }
00188
00189
00190 int JackNetUnixSocket::GetName ( char* name )
00191 {
00192 return gethostname ( name, 255 );
00193 }
00194
00195 int JackNetUnixSocket::JoinMCastGroup ( const char* ip )
00196 {
00197 struct ip_mreq multicast_req;
00198 inet_aton ( ip, &multicast_req.imr_multiaddr );
00199 multicast_req.imr_interface.s_addr = htonl ( INADDR_ANY );
00200 return SetOption ( IPPROTO_IP, IP_ADD_MEMBERSHIP, &multicast_req, sizeof ( multicast_req ) );
00201 }
00202
00203
00204 int JackNetUnixSocket::SetOption ( int level, int optname, const void* optval, socklen_t optlen )
00205 {
00206 return setsockopt ( fSockfd, level, optname, optval, optlen );
00207 }
00208
00209 int JackNetUnixSocket::GetOption ( int level, int optname, void* optval, socklen_t* optlen )
00210 {
00211 return getsockopt ( fSockfd, level, optname, optval, optlen );
00212 }
00213
00214
00215 int JackNetUnixSocket::SetTimeOut ( int us )
00216 {
00217 jack_log ( "JackNetUnixSocket::SetTimeout %d usecs", us );
00218
00219
00220 if ( ( us < 0 ) || ( us > 10000000 ) )
00221 return SOCKET_ERROR;
00222 struct timeval timeout;
00223
00224
00225 if ( us < 1000000 )
00226 {
00227 timeout.tv_sec = 0;
00228 timeout.tv_usec = us;
00229 }
00230
00231 else
00232 {
00233 float sec = static_cast<float> ( us ) / 1000000.f;
00234 timeout.tv_sec = ( int ) sec;
00235 float usec = ( sec - static_cast<float> ( timeout.tv_sec ) ) * 1000000;
00236 timeout.tv_usec = ( int ) usec;
00237 }
00238 return SetOption ( SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof ( timeout ) );
00239 }
00240
00241
00242 int JackNetUnixSocket::SetLocalLoop()
00243 {
00244 char disable = 0;
00245 return SetOption ( IPPROTO_IP, IP_MULTICAST_LOOP, &disable, sizeof ( disable ) );
00246 }
00247
00248
00249 int JackNetUnixSocket::SendTo ( const void* buffer, size_t nbytes, int flags )
00250 {
00251 return sendto ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fSendAddr ), sizeof ( socket_address_t ) );
00252 }
00253
00254 int JackNetUnixSocket::SendTo ( const void* buffer, size_t nbytes, int flags, const char* ip )
00255 {
00256 int addr_conv = inet_aton ( ip, &fSendAddr.sin_addr );
00257 if ( addr_conv < 1 )
00258 return addr_conv;
00259 return SendTo ( buffer, nbytes, flags );
00260 }
00261
00262 int JackNetUnixSocket::Send ( const void* buffer, size_t nbytes, int flags )
00263 {
00264 return send ( fSockfd, buffer, nbytes, flags );
00265 }
00266
00267 int JackNetUnixSocket::RecvFrom ( void* buffer, size_t nbytes, int flags )
00268 {
00269 socklen_t addr_len = sizeof ( socket_address_t );
00270 return recvfrom ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fRecvAddr ), &addr_len );
00271 }
00272
00273 int JackNetUnixSocket::Recv ( void* buffer, size_t nbytes, int flags )
00274 {
00275 return recv ( fSockfd, buffer, nbytes, flags );
00276 }
00277
00278 int JackNetUnixSocket::CatchHost ( void* buffer, size_t nbytes, int flags )
00279 {
00280 socklen_t addr_len = sizeof ( socket_address_t );
00281 return recvfrom ( fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*> ( &fSendAddr ), &addr_len );
00282 }
00283
00284 net_error_t JackNetUnixSocket::GetError()
00285 {
00286 switch ( errno )
00287 {
00288 case EAGAIN:
00289 return NET_NO_DATA;
00290 case ECONNABORTED:
00291 return NET_CONN_ERROR;
00292 case EINVAL:
00293 return NET_CONN_ERROR;
00294 case ECONNREFUSED:
00295 return NET_CONN_ERROR;
00296 case ECONNRESET:
00297 return NET_CONN_ERROR;
00298 case EHOSTDOWN:
00299 return NET_CONN_ERROR;
00300 case EHOSTUNREACH:
00301 return NET_CONN_ERROR;
00302 default:
00303 return NET_OP_ERROR;
00304 }
00305 }
00306 }