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,...)