20 #include "JackNetUnixSocket.h" 21 #include "JackError.h" 31 int GetHostName(
char * name,
int size)
33 if (gethostname(name, size) == SOCKET_ERROR) {
34 jack_error(
"Can't get 'hostname' : %s", strerror(NET_ERROR_CODE));
35 strcpy(name,
"default");
42 JackNetUnixSocket::JackNetUnixSocket()
47 fSendAddr.sin_family = AF_INET;
48 fSendAddr.sin_addr.s_addr = htonl(INADDR_ANY);
49 memset(&fSendAddr.sin_zero, 0, 8);
50 fRecvAddr.sin_family = AF_INET;
51 fRecvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
52 memset(&fRecvAddr.sin_zero, 0, 8);
55 JackNetUnixSocket::JackNetUnixSocket(
const char* ip,
int port)
60 fSendAddr.sin_family = AF_INET;
61 fSendAddr.sin_port = htons(port);
62 inet_aton(ip, &fSendAddr.sin_addr);
63 memset(&fSendAddr.sin_zero, 0, 8);
64 fRecvAddr.sin_family = AF_INET;
65 fRecvAddr.sin_port = htons(port);
66 fRecvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
67 memset(&fRecvAddr.sin_zero, 0, 8);
70 JackNetUnixSocket::JackNetUnixSocket(
const JackNetUnixSocket& socket)
75 fSendAddr = socket.fSendAddr;
76 fRecvAddr = socket.fRecvAddr;
79 JackNetUnixSocket::~JackNetUnixSocket()
84 JackNetUnixSocket& JackNetUnixSocket::operator=(
const JackNetUnixSocket& socket)
86 if (
this != &socket) {
89 fSendAddr = socket.fSendAddr;
90 fRecvAddr = socket.fRecvAddr;
96 int JackNetUnixSocket::NewSocket()
102 fSockfd = socket(AF_INET, SOCK_DGRAM, 0);
107 if ((res = setsockopt(fSockfd, SOL_SOCKET, SO_REUSEPORT, &on,
sizeof(on))) < 0) {
109 if ((res = setsockopt(fSockfd, SOL_SOCKET, SO_REUSEADDR, &on,
sizeof(on))) < 0) {
111 StrError(NET_ERROR_CODE);
146 bool JackNetUnixSocket::IsLocal(
char* ip)
148 if (strcmp(ip,
"127.0.0.1") == 0) {
153 gethostname(host_name,
sizeof(host_name));
155 struct hostent* host = gethostbyname(host_name);
157 for (
int i = 0; host->h_addr_list[i] != 0; ++i) {
159 memcpy(&addr, host->h_addr_list[i],
sizeof(
struct in_addr));
160 if (strcmp(inet_ntoa(addr), ip) == 0) {
170 int JackNetUnixSocket::Bind()
172 return bind(fSockfd, reinterpret_cast<socket_address_t*>(&fRecvAddr),
sizeof(socket_address_t));
175 int JackNetUnixSocket::BindWith(
const char* ip)
177 int addr_conv = inet_aton(ip, &fRecvAddr.sin_addr);
184 int JackNetUnixSocket::BindWith(
int port)
186 fRecvAddr.sin_port = htons(port);
190 int JackNetUnixSocket::Connect()
192 return connect(fSockfd, reinterpret_cast<socket_address_t*>(&fSendAddr),
sizeof(socket_address_t));
195 int JackNetUnixSocket::ConnectTo(
const char* ip)
197 int addr_conv = inet_aton(ip, &fSendAddr.sin_addr);
204 void JackNetUnixSocket::Close()
212 void JackNetUnixSocket::Reset()
214 fSendAddr.sin_family = AF_INET;
215 fSendAddr.sin_port = htons(fPort);
216 fSendAddr.sin_addr.s_addr = htonl(INADDR_ANY);
217 memset(&fSendAddr.sin_zero, 0, 8);
218 fRecvAddr.sin_family = AF_INET;
219 fRecvAddr.sin_port = htons(fPort);
220 fRecvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
221 memset(&fRecvAddr.sin_zero, 0, 8);
224 bool JackNetUnixSocket::IsSocket()
226 return(fSockfd) ? true :
false;
230 void JackNetUnixSocket::SetPort(
int port)
233 fSendAddr.sin_port = htons(port);
234 fRecvAddr.sin_port = htons(port);
237 int JackNetUnixSocket::GetPort()
243 int JackNetUnixSocket::SetAddress(
const char* ip,
int port)
245 int addr_conv = inet_aton(ip, &fSendAddr.sin_addr);
249 fSendAddr.sin_port = htons(port);
253 char* JackNetUnixSocket::GetSendIP()
255 return inet_ntoa(fSendAddr.sin_addr);
258 char* JackNetUnixSocket::GetRecvIP()
260 return inet_ntoa(fRecvAddr.sin_addr);
264 int JackNetUnixSocket::GetName(
char* name)
266 return gethostname(name, 255);
269 int JackNetUnixSocket::JoinMCastGroup(
const char* ip)
271 struct ip_mreq multicast_req;
272 inet_aton(ip, &multicast_req.imr_multiaddr);
273 multicast_req.imr_interface.s_addr = htonl(INADDR_ANY);
274 return SetOption(IPPROTO_IP, IP_ADD_MEMBERSHIP, &multicast_req,
sizeof(multicast_req));
278 int JackNetUnixSocket::SetOption(
int level,
int optname,
const void* optval, socklen_t optlen)
280 return setsockopt(fSockfd, level, optname, optval, optlen);
283 int JackNetUnixSocket::GetOption(
int level,
int optname,
void* optval, socklen_t* optlen)
285 return getsockopt(fSockfd, level, optname, optval, optlen);
290 #if defined(__sun__) || defined(sun) 291 int JackNetUnixSocket::SetTimeOut(
int us)
296 if ((flags = fcntl(fSockfd, F_GETFL, 0)) < 0) {
297 jack_error(
"JackNetUnixSocket::SetTimeOut error in fcntl F_GETFL");
302 if (fcntl(fSockfd, F_SETFL, flags) < 0) {
303 jack_error(
"JackNetUnixSocket::SetTimeOut error in fcntl F_SETFL");
310 int JackNetUnixSocket::WaitRead()
318 tv.tv_sec = fTimeOut / 1000000;
319 tv.tv_usec = fTimeOut % 1000000;
322 FD_SET(fSockfd, &fdset);
325 res = select(fSockfd + 1, &fdset, NULL, NULL, &tv);
326 }
while (res < 0 && errno == EINTR);
330 }
else if (res == 0) {
339 int JackNetUnixSocket::WaitWrite()
347 tv.tv_sec = fTimeOut / 1000000;
348 tv.tv_usec = fTimeOut % 1000000;
351 FD_SET(fSockfd, &fdset);
354 res = select(fSockfd + 1, NULL, &fdset, NULL, &tv);
355 }
while (res < 0 && errno == EINTR);
359 }
else if (res == 0) {
369 int JackNetUnixSocket::SetTimeOut(
int us)
371 jack_log(
"JackNetUnixSocket::SetTimeout %d usecs", us);
372 struct timeval timeout;
377 timeout.tv_usec = us;
380 float sec = float(us) / 1000000.f;
381 timeout.tv_sec = (int)sec;
382 float usec = (sec - float(timeout.tv_sec)) * 1000000;
383 timeout.tv_usec =(int)usec;
385 return SetOption(SOL_SOCKET, SO_RCVTIMEO, &timeout,
sizeof(timeout));
390 int JackNetUnixSocket::SetLocalLoop()
393 return SetOption(IPPROTO_IP, IP_MULTICAST_LOOP, &disable,
sizeof(disable));
397 int JackNetUnixSocket::SendTo(
const void* buffer,
size_t nbytes,
int flags)
399 #if defined(__sun__) || defined(sun) 400 if (WaitWrite() < 0) {
405 if ((res = sendto(fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*>(&fSendAddr),
sizeof(socket_address_t))) < 0) {
406 jack_error(
"SendTo fd = %ld err = %s", fSockfd, strerror(errno));
411 int JackNetUnixSocket::SendTo(
const void* buffer,
size_t nbytes,
int flags,
const char* ip)
413 int addr_conv = inet_aton(ip, &fSendAddr.sin_addr);
417 fSendAddr.sin_port = htons(fPort);
418 #if defined(__sun__) || defined(sun) 419 if (WaitWrite() < 0) {
423 return SendTo(buffer, nbytes, flags);
426 int JackNetUnixSocket::Send(
const void* buffer,
size_t nbytes,
int flags)
428 #if defined(__sun__) || defined(sun) 429 if (WaitWrite() < 0) {
434 if ((res = send(fSockfd, buffer, nbytes, flags)) < 0) {
435 jack_error(
"Send fd = %ld err = %s", fSockfd, strerror(errno));
440 int JackNetUnixSocket::RecvFrom(
void* buffer,
size_t nbytes,
int flags)
442 socklen_t addr_len =
sizeof(socket_address_t);
443 #if defined(__sun__) || defined(sun) 444 if (WaitRead() < 0) {
449 if ((res = recvfrom(fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*>(&fRecvAddr), &addr_len)) < 0) {
450 jack_error(
"RecvFrom fd = %ld err = %s", fSockfd, strerror(errno));
455 int JackNetUnixSocket::Recv(
void* buffer,
size_t nbytes,
int flags)
457 #if defined(__sun__) || defined(sun) 458 if (WaitRead() < 0) {
463 if ((res = recv(fSockfd, buffer, nbytes, flags)) < 0) {
464 jack_error(
"Recv fd = %ld err = %s", fSockfd, strerror(errno));
469 int JackNetUnixSocket::CatchHost(
void* buffer,
size_t nbytes,
int flags)
471 socklen_t addr_len =
sizeof(socket_address_t);
472 #if defined(__sun__) || defined(sun) 473 if (WaitRead() < 0) {
478 if ((res = recvfrom(fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*>(&fSendAddr), &addr_len)) < 0) {
479 jack_log(
"CatchHost fd = %ld err = %s", fSockfd, strerror(errno));
484 net_error_t JackNetUnixSocket::GetError()
499 return NET_CONN_ERROR;
503 return NET_CONN_ERROR;
507 void JackNetUnixSocket::PrintError()
518 jack_error(
"JackNetUnixSocket : ECONNABORTED");
521 jack_error(
"JackNetUnixSocket : ECONNREFUSED");
533 jack_error(
"JackNetUnixSocket : EHOSTUNREACH");
539 jack_error(
"JackNetUnixSocket : ENETUNREACH");
SERVER_EXPORT void jack_error(const char *fmt,...)
SERVER_EXPORT void jack_log(const char *fmt,...)