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);
116 bool JackNetUnixSocket::IsLocal(
char* ip)
118 if (strcmp(ip,
"127.0.0.1") == 0) {
123 gethostname(host_name,
sizeof(host_name));
125 struct hostent* host = gethostbyname(host_name);
127 for (
int i = 0; host->h_addr_list[i] != 0; ++i) {
129 memcpy(&addr, host->h_addr_list[i],
sizeof(
struct in_addr));
130 if (strcmp(inet_ntoa(addr), ip) == 0) {
140 int JackNetUnixSocket::Bind()
142 return bind(fSockfd, reinterpret_cast<socket_address_t*>(&fRecvAddr),
sizeof(socket_address_t));
145 int JackNetUnixSocket::BindWith(
const char* ip)
147 int addr_conv = inet_aton(ip, &fRecvAddr.sin_addr);
154 int JackNetUnixSocket::BindWith(
int port)
156 fRecvAddr.sin_port = htons(port);
160 int JackNetUnixSocket::Connect()
162 return connect(fSockfd, reinterpret_cast<socket_address_t*>(&fSendAddr),
sizeof(socket_address_t));
165 int JackNetUnixSocket::ConnectTo(
const char* ip)
167 int addr_conv = inet_aton(ip, &fSendAddr.sin_addr);
174 void JackNetUnixSocket::Close()
182 void JackNetUnixSocket::Reset()
184 fSendAddr.sin_family = AF_INET;
185 fSendAddr.sin_port = htons(fPort);
186 fSendAddr.sin_addr.s_addr = htonl(INADDR_ANY);
187 memset(&fSendAddr.sin_zero, 0, 8);
188 fRecvAddr.sin_family = AF_INET;
189 fRecvAddr.sin_port = htons(fPort);
190 fRecvAddr.sin_addr.s_addr = htonl(INADDR_ANY);
191 memset(&fRecvAddr.sin_zero, 0, 8);
194 bool JackNetUnixSocket::IsSocket()
196 return(fSockfd) ?
true :
false;
200 void JackNetUnixSocket::SetPort(
int port)
203 fSendAddr.sin_port = htons(port);
204 fRecvAddr.sin_port = htons(port);
207 int JackNetUnixSocket::GetPort()
213 int JackNetUnixSocket::SetAddress(
const char* ip,
int port)
215 int addr_conv = inet_aton(ip, &fSendAddr.sin_addr);
219 fSendAddr.sin_port = htons(port);
223 char* JackNetUnixSocket::GetSendIP()
225 return inet_ntoa(fSendAddr.sin_addr);
228 char* JackNetUnixSocket::GetRecvIP()
230 return inet_ntoa(fRecvAddr.sin_addr);
234 int JackNetUnixSocket::GetName(
char* name)
236 return gethostname(name, 255);
239 int JackNetUnixSocket::JoinMCastGroup(
const char* ip)
241 struct ip_mreq multicast_req;
242 inet_aton(ip, &multicast_req.imr_multiaddr);
243 multicast_req.imr_interface.s_addr = htonl(INADDR_ANY);
244 return SetOption(IPPROTO_IP, IP_ADD_MEMBERSHIP, &multicast_req,
sizeof(multicast_req));
248 int JackNetUnixSocket::SetOption(
int level,
int optname,
const void* optval, socklen_t optlen)
250 return setsockopt(fSockfd, level, optname, optval, optlen);
253 int JackNetUnixSocket::GetOption(
int level,
int optname,
void* optval, socklen_t* optlen)
255 return getsockopt(fSockfd, level, optname, optval, optlen);
260 #if defined(__sun__) || defined(sun)
261 int JackNetUnixSocket::SetTimeOut(
int us)
266 if ((flags = fcntl(fSockfd, F_GETFL, 0)) < 0) {
267 jack_error(
"JackNetUnixSocket::SetTimeOut error in fcntl F_GETFL");
272 if (fcntl(fSockfd, F_SETFL, flags) < 0) {
273 jack_error(
"JackNetUnixSocket::SetTimeOut error in fcntl F_SETFL");
280 int JackNetUnixSocket::WaitRead()
288 tv.tv_sec = fTimeOut / 1000000;
289 tv.tv_usec = fTimeOut % 1000000;
292 FD_SET(fSockfd, &fdset);
295 res = select(fSockfd + 1, &fdset, NULL, NULL, &tv);
296 }
while (res < 0 && errno == EINTR);
300 }
else if (res == 0) {
309 int JackNetUnixSocket::WaitWrite()
317 tv.tv_sec = fTimeOut / 1000000;
318 tv.tv_usec = fTimeOut % 1000000;
321 FD_SET(fSockfd, &fdset);
324 res = select(fSockfd + 1, NULL, &fdset, NULL, &tv);
325 }
while (res < 0 && errno == EINTR);
329 }
else if (res == 0) {
339 int JackNetUnixSocket::SetTimeOut(
int us)
341 jack_log(
"JackNetUnixSocket::SetTimeout %d usecs", us);
342 struct timeval timeout;
347 timeout.tv_usec = us;
350 float sec = float(us) / 1000000.f;
351 timeout.tv_sec = (int)sec;
352 float usec = (sec - float(timeout.tv_sec)) * 1000000;
353 timeout.tv_usec =(int)usec;
355 return SetOption(SOL_SOCKET, SO_RCVTIMEO, &timeout,
sizeof(timeout));
360 int JackNetUnixSocket::SetLocalLoop()
363 return SetOption(IPPROTO_IP, IP_MULTICAST_LOOP, &disable,
sizeof(disable));
367 int JackNetUnixSocket::SendTo(
const void* buffer,
size_t nbytes,
int flags)
369 #if defined(__sun__) || defined(sun)
370 if (WaitWrite() < 0) {
375 if ((res = sendto(fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*>(&fSendAddr),
sizeof(socket_address_t))) < 0) {
376 jack_error(
"SendTo fd = %ld err = %s", fSockfd, strerror(errno));
381 int JackNetUnixSocket::SendTo(
const void* buffer,
size_t nbytes,
int flags,
const char* ip)
383 int addr_conv = inet_aton(ip, &fSendAddr.sin_addr);
387 #if defined(__sun__) || defined(sun)
388 if (WaitWrite() < 0) {
392 return SendTo(buffer, nbytes, flags);
395 int JackNetUnixSocket::Send(
const void* buffer,
size_t nbytes,
int flags)
397 #if defined(__sun__) || defined(sun)
398 if (WaitWrite() < 0) {
403 if ((res = send(fSockfd, buffer, nbytes, flags)) < 0) {
404 jack_error(
"Send fd = %ld err = %s", fSockfd, strerror(errno));
409 int JackNetUnixSocket::RecvFrom(
void* buffer,
size_t nbytes,
int flags)
411 socklen_t addr_len =
sizeof(socket_address_t);
412 #if defined(__sun__) || defined(sun)
413 if (WaitRead() < 0) {
418 if ((res = recvfrom(fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*>(&fRecvAddr), &addr_len)) < 0) {
419 jack_error(
"RecvFrom fd = %ld err = %s", fSockfd, strerror(errno));
424 int JackNetUnixSocket::Recv(
void* buffer,
size_t nbytes,
int flags)
426 #if defined(__sun__) || defined(sun)
427 if (WaitRead() < 0) {
432 if ((res = recv(fSockfd, buffer, nbytes, flags)) < 0) {
433 jack_error(
"Recv fd = %ld err = %s", fSockfd, strerror(errno));
438 int JackNetUnixSocket::CatchHost(
void* buffer,
size_t nbytes,
int flags)
440 socklen_t addr_len =
sizeof(socket_address_t);
441 #if defined(__sun__) || defined(sun)
442 if (WaitRead() < 0) {
447 if ((res = recvfrom(fSockfd, buffer, nbytes, flags, reinterpret_cast<socket_address_t*>(&fSendAddr), &addr_len)) < 0) {
448 jack_log(
"CatchHost fd = %ld err = %s", fSockfd, strerror(errno));
453 net_error_t JackNetUnixSocket::GetError()
468 return NET_CONN_ERROR;
472 return NET_CONN_ERROR;
476 void JackNetUnixSocket::PrintError()
487 jack_error(
"JackNetUnixSocket : ECONNABORTED");
490 jack_error(
"JackNetUnixSocket : ECONNREFUSED");
502 jack_error(
"JackNetUnixSocket : EHOSTUNREACH");
508 jack_error(
"JackNetUnixSocket : ENETUNREACH");
SERVER_EXPORT void jack_error(const char *fmt,...)
SERVER_EXPORT void jack_log(const char *fmt,...)