jackaudio
/
jack2
mirror of https://github.com/jackaudio/jack2
1
0
Fork 0
Code Releases 45 Activity
jack2 codebase
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
3643 Commits
8 Branches
67MB
Tree: bafeb31894
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'bafeb31894'
${ noResults }
jack2/posix/JackNetUnixSocket.cpp

812 lines
28KB
Raw Blame History 

  1. /*

  2. Copyright (C) 2008-2011 Romain Moret at Grame

  3. 

  4. This program is free software; you can redistribute it and/or modify

  5. it under the terms of the GNU General Public License as published by

  6. the Free Software Foundation; either version 2 of the License, or

  7. (at your option) any later version.

  8. 

  9. This program is distributed in the hope that it will be useful,

  10. but WITHOUT ANY WARRANTY; without even the implied warranty of

  11. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

  12. GNU General Public License for more details.

  13. 

  14. You should have received a copy of the GNU General Public License

  15. along with this program; if not, write to the Free Software

  16. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

  17. 

  18. */

  19. 

  20. #include "JackNetUnixSocket.h"

  21. #include "JackError.h"

  22. 

  23. #include <arpa/inet.h>

  24. #include <sys/socket.h>

  25. #include <ifaddrs.h>

  26. #include <net/if.h>

  27. #include <unistd.h>

  28. #include <fcntl.h>

  29. 

  30. using namespace std;

  31. 

  32. // See RFC 3493; The Open Group Base Specifications Issue 6 IEEE Std 1003.1, 2004 Edition

  33. #define _sock4(x) (*(struct sockaddr_in *)&x)

  34. #define _sock6(x) (*(struct sockaddr_in6*)&x)

  35. #define _ss_addr_p(x) ((fFamily==AF_INET6) ? \

  36.         (void*)&(((struct sockaddr_in6*)&x)->sin6_addr) \

  37.       : (void*)&(((struct sockaddr_in *)&x)->sin_addr))

  38. #define JNS_UNSPEC 0x0

  39. #define JNS_PROBED 0x1

  40. #define JNS_BOUND  0x2

  41. #define JNS_CONNCD 0x4

  42. #define JNS_MCAST  0x10

  43. 

  44. namespace Jack

  45. {

  46.     //utility *********************************************************************************************************

  47.     int GetHostName(char * name, int size)

  48.     {

  49.         if (gethostname(name, size) == SOCKET_ERROR) {

  50.             jack_error("Can't get 'hostname' : %s", strerror(NET_ERROR_CODE));

  51.             strcpy(name, "default");

  52.             return SOCKET_ERROR;

  53.         }

  54.         return 0;

  55.     }

  56. 

  57.     //construct/destruct***********************************************************************************************

  58.     JackNetUnixSocket::JackNetUnixSocket()

  59.     : fFamily(AF_UNSPEC), fSockfd(0), fState(JNS_UNSPEC), fPort(0), fTimeOut(0)

  60.     {

  61.         Reset();

  62.     }

  63. 

  64.     JackNetUnixSocket::JackNetUnixSocket(const char* ip, int port)

  65.     : fFamily(AF_UNSPEC), fSockfd(0), fState(JNS_UNSPEC), fPort(0), fTimeOut(0)

  66.     {

  67.         Reset();

  68.         fPort = port;

  69.         if(NewSocket(ip)==SOCKET_ERROR)

  70.             jack_error("JackNetUnixSocket::JackNetUnixSocket Cannot initialize (%s:%d): %s",ip,port,strerror(NET_ERROR_CODE));

  71.     }

  72. 

  73.     JackNetUnixSocket::JackNetUnixSocket(const JackNetUnixSocket& socket)

  74.     {

  75.         Clone(socket);

  76.     }

  77. 

  78.     JackNetUnixSocket::~JackNetUnixSocket()

  79.     {

  80.         Close();

  81.     }

  82. 

  83.     JackNetUnixSocket& JackNetUnixSocket::operator=(const JackNetUnixSocket& socket)

  84.     {

  85.         if (this != &socket)

  86.             Clone(socket);

  87.         return *this;

  88.     }

  89. 

  90.     //socket***********************************************************************************************************

  91.     void JackNetUnixSocket::Clone(const JackNetUnixSocket& socket)

  92.     {

  93.         fSockfd = 0;

  94.         fTimeOut = 0;

  95.         fPort = socket.fPort;

  96.         fFamily = socket.fFamily;

  97.         fState = socket.fState;

  98.         fState &= (JNS_MCAST | JNS_PROBED); // Reset all fields except mcast and probed

  99.         memcpy(&fSendAddr, & socket.fSendAddr, sizeof(fSendAddr));

  100.         memcpy(&fRecvAddr, & socket.fRecvAddr, sizeof(fRecvAddr));

  101.     }

  102.     /* When using Multicast always create socket with new (mip,port) or call NewSocket(mip) for autoinitialized sockets first.

  103.     *  This makes sure proper workarounds for Multicast incompatibility will be activated while setting up address family.

  104.     */

  105.     int JackNetUnixSocket::ProbeAF(const char* ip, struct sockaddr_storage *addr, int (*call)(int,const struct sockaddr*,socklen_t))

  106.     {

  107.         struct addrinfo hint,*res, *ri;

  108.         char sport[6];

  109.         int ret;

  110. 

  111.         snprintf(sport,6,"%d",fPort);

  112.         memset(&hint,0,sizeof(hint));

  113.         hint.ai_family = fFamily;

  114.         hint.ai_socktype = SOCK_DGRAM;

  115.         hint.ai_flags = AI_V4MAPPED | AI_ADDRCONFIG | AI_NUMERICSERV;

  116.         if(ip == NULL) hint.ai_flags |= AI_PASSIVE;

  117.         ret = getaddrinfo(ip,sport,&hint,&res);

  118.         if(ret) {

  119.             jack_error("JackNetUnixSocket::ProbeAF getaddrinfo(%s:%s): %s",ip,sport,gai_strerror(ret));

  120.             return ret;

  121.         }

  122. #define GLIBC_BUG

  123.         // An ugly GLIBC bug, which one may argue to be RFC bug. See http://sourceware.org/bugzilla/show_bug.cgi?id=14967

  124. #ifdef GLIBC_BUG

  125.         // Of course gai configuration can say to have v4 having precedence explicitly but... here we prefer ipv6. period

  126.         if(!ip && res->ai_family == AF_INET && res->ai_next && res->ai_next->ai_family == AF_INET6) {

  127.             jack_log("JackNetUnixSocket::ProbeAF swapping addrinfo entries to work around GLIBC getaddrinfo bug: AF_INET<->AF_INET6");

  128.             // Swapping first two entries

  129.             ri = res->ai_next;

  130.             res->ai_next = ri->ai_next;

  131.             ri->ai_next = res;

  132.             res = ri;

  133.         } else // << Remove up to this very line including once GLIBC is fixed <<

  134. #endif

  135.             ri = res;

  136.         do {

  137.             jack_log("JackNetUnixSocket::ProbeAF trying AF[%d], TYPE[%d], PROTO[%d]",

  138.                                                 ri->ai_family,ri->ai_socktype,ri->ai_protocol);

  139.             ret = socket(ri->ai_family, ri->ai_socktype, ri->ai_protocol);

  140.             if(ret < 0)

  141.                 continue;

  142.             if(!(*call)(ret, ri->ai_addr, ri->ai_addrlen))

  143.                 break;

  144.             close(ret);

  145.             jack_log("JackNetUnixSocket::ProbeAF failed for AF[%d], %s",ri->ai_family,(ri->ai_next)?"trying next":"giving up");

  146.         } while((ri = ri->ai_next) != NULL);

  147.         // probe successfully made a *call on socket for ip represented by ri

  148.         if(ri) {

  149.             fSockfd = ret;

  150.             fFamily = ri->ai_family;

  151.             memcpy(addr,ri->ai_addr,ri->ai_addrlen);

  152.             jack_log("JackNetUnixSocket::ProbeAF probed[%d] AF[%d] for %s",ret,fFamily,ip);

  153.             fState |= JNS_PROBED;

  154.             if(fFamily == AF_INET6 && IN6_IS_ADDR_MULTICAST(&((struct sockaddr_in6*)addr)->sin6_addr))

  155.                 fState |= JNS_MCAST;

  156.         } else

  157.             ret = SOCKET_ERROR;

  158.         freeaddrinfo(res);

  159.         return ret;

  160.     }

  161. 

  162.     int JackNetUnixSocket::NewSocket()

  163.     {

  164.         return NewSocket(NULL);

  165.     }

  166.     int JackNetUnixSocket::NewSocket(const char *ip)

  167.     {

  168.         if(fFamily == AF_UNSPEC) {

  169.             if(ip) {

  170.                 if(ProbeAF(ip,&fSendAddr,connect)<0)

  171.                     return SOCKET_ERROR;

  172.             } else {

  173.                 if(ProbeAF(ip,&fRecvAddr,bind)<0)

  174.                     return SOCKET_ERROR;

  175.                 // It should be with AF/port/ANY after bind

  176.                 memcpy(&fSendAddr,&fRecvAddr,sizeof(fRecvAddr));

  177.             }

  178.             // Now re-create the fd to get a brand-new unnamed socket

  179.         }

  180.         if (fSockfd) {

  181.             Close();

  182.             Reset();

  183.         }

  184.         fSockfd = socket(fFamily, SOCK_DGRAM, 0);

  185. 

  186.         /* Enable address reuse */

  187.         int res, on = 1;

  188.     #ifdef __APPLE__

  189.         if ((res = setsockopt(fSockfd, SOL_SOCKET, SO_REUSEPORT, &on, sizeof(on))) < 0) {

  190.     #else

  191.         if ((res = setsockopt(fSockfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on))) < 0) {

  192.     #endif

  193.             StrError(NET_ERROR_CODE);

  194.         }

  195.         

  196.         int tos = 0;       /* see <netinet/in.h> */

  197.         

  198.         /*

  199.         DSCP Field Hex/Bin/Dec	Layer 2 Prio	Traffic Type	Acronym	WMM Access Category

  200.         0x38 / 111000 / 56	7	Network Control	NC	AC_VO

  201.         0x30 / 110000 / 48	6	Voice	VO	AC_VO

  202.         0x28 / 101000 / 40	5	Video	VI	AC_VI

  203.         0x20 / 100000 / 32	4	Controlled Load	CL	AC_VI

  204.         0x18 / 011000 / 24	3	Excellent Effort	EE	AC_BE

  205.         0x10 / 010000 / 16	2	Spare	--	AC_BK

  206.         0x08 / 001000 / 8	1	Background	BK	AC_BK

  207.         0x00 / 000000 / 0	0	Best Effort	BE	AC_BE

  208.         */

  209.         

  210.         socklen_t len = sizeof(tos);

  211.         

  212.         res = getsockopt(fSockfd, IPPROTO_IP, IP_TOS, &tos, &len);

  213.         

  214.         tos = 46 * 4;       // see <netinet/in.h> 

  215.         res = setsockopt(fSockfd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));

  216. 

  217.         return fSockfd;

  218.     }

  219. 

  220.     bool JackNetUnixSocket::IsLocal(char* ip)

  221.     {

  222.         if (strcmp(ip, "127.0.0.1") == 0) {

  223.             return true;

  224.         } else if(!strcmp(ip,"::1"))

  225.             return true;

  226. 

  227.         struct ifaddrs *ifas, *ifa;

  228.         socklen_t len;

  229. 

  230.         if (getifaddrs(&ifas) == -1) {

  231.                 jack_error("JackNetUnixSocket::IsLocal error in getifaddrs");

  232.                 return false;

  233.         }

  234.         for (ifa = ifas; ifa != NULL; ifa = ifa->ifa_next) {

  235.                 if (ifa->ifa_addr == NULL)

  236.                     continue; // Address is mandatory

  237.                 len = (ifa->ifa_addr->sa_family==AF_INET)?sizeof(struct sockaddr_in):sizeof(struct sockaddr_in6);

  238.                 if(!getnameinfo(ifa->ifa_addr, len, f_addr_buff, INET6_ADDRSTRLEN, NULL,0, NI_NUMERICSERV | NI_DGRAM | NI_NUMERICSERV | NI_DGRAM | NI_NUMERICHOST))

  239.                     if(!strcmp(f_addr_buff,ip))

  240.                         break;

  241.         }

  242.         freeifaddrs(ifas);

  243.         return (ifa != NULL);

  244.     }

  245. 

  246.     int JackNetUnixSocket::Bind()

  247.     {

  248.         int yes=1;

  249.         if(fState & JNS_BOUND) return 0;

  250.         // Multicast is incompatible with V4MAPPED or V4COMPAT addresses, if probe detected MC we need V6ONLY

  251.         if(fFamily == AF_INET6 && IN6_IS_ADDR_UNSPECIFIED(&_sock6(fRecvAddr).sin6_addr) && fState & JNS_MCAST)

  252.             if(SetOption(IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof(yes))) return SOCKET_ERROR;

  253.         if(::bind(fSockfd, reinterpret_cast<struct sockaddr*>(&fRecvAddr), sizeof(fRecvAddr))) return SOCKET_ERROR;

  254.         fState |= JNS_BOUND;

  255.         return 0;

  256.     }

  257.     int JackNetUnixSocket::Bind(const char *if_name)

  258.     {

  259.         int ret = Bind();

  260.         if(!ret && strcmp(if_name,"any")) {

  261.             if(fFamily == AF_INET) {

  262.                 // 'all' for this case will lead to 'last valid interface', which is not that one might expect

  263.                 if(strcmp(if_name,"all"))

  264.                     ret = BindMCastIface(if_name, IP_MULTICAST_IF, &_sock4(fSendAddr).sin_addr);

  265.                 else

  266.                     jack_error("Multicast Interface all not found, sending from default");

  267.             } else if(fFamily == AF_INET6) {

  268.                 struct if_nameindex *if_ni = if_nameindex(); // In V6 world we do everything differently.

  269.                 if(if_ni) {

  270.                     int i;

  271.                     for (i=0; if_ni[i].if_index > 0; i++) {

  272.                         if(if_ni[i].if_index == 1)

  273.                             continue; // Skip loopback

  274.                         if(!strcmp(if_ni[i].if_name,if_name)) {

  275.                             ret = SetOption(IPPROTO_IPV6, IPV6_MULTICAST_IF, &if_ni[i].if_index, sizeof(if_ni[i].if_index));

  276.                             jack_log("JackNetUnixSocket::Bind Multicasting from %s",if_ni[i].if_name);

  277.                             break;

  278.                         }

  279.                     }

  280.                     if(if_ni[i].if_index == 0) jack_error("Multicast Interface %s not found, sending from default",if_name);

  281.                     if_freenameindex(if_ni);

  282.                 }

  283.             }

  284.         }

  285.         return ret;

  286.     }

  287. 

  288.     int JackNetUnixSocket::BindWith(const char* ip)

  289.     {

  290.         if(fFamily == AF_UNSPEC) {

  291.             if(!fPort) return SOCKET_ERROR;

  292.             if(ProbeAF(ip,&fRecvAddr,&bind)<0) return SOCKET_ERROR;

  293.             fState |= JNS_BOUND;

  294.             return 0;

  295.         } else {

  296.             if(SetRecvIP(ip)==-1) return SOCKET_ERROR;

  297.             return Bind();

  298.         }

  299.     }

  300. 

  301.     int JackNetUnixSocket::BindWith(int port)

  302.     {

  303.         if(fFamily == AF_UNSPEC) {

  304.             fPort = port;

  305.             if(ProbeAF(NULL,&fRecvAddr,&bind)<0) return SOCKET_ERROR;

  306.             fState |= JNS_BOUND;

  307.             return 0;

  308.         } else {

  309.             SetPort(port);

  310.             return Bind();

  311.         }

  312.     }

  313. 

  314.     int JackNetUnixSocket::Connect()

  315.     {

  316.         if(fFamily != AF_UNSPEC)

  317.             return connect(fSockfd, (struct sockaddr*)&fSendAddr,sizeof(fSendAddr));

  318.         jack_error("JackNetUnixSocket::Connect Family not initialized");

  319.         return SOCKET_ERROR;

  320.     }

  321. 

  322.     int JackNetUnixSocket::ConnectTo(const char* ip)

  323.     {

  324.         socklen_t l=sizeof(fRecvAddr);

  325.         if(fPort==0) return SOCKET_ERROR;

  326.         if(fState & JNS_PROBED) {

  327.             Reset();

  328.             fFamily=AF_UNSPEC;

  329.         }

  330.         if(fSockfd)

  331.             Close();

  332.         if(ProbeAF(ip,&fSendAddr,&connect)<0) return SOCKET_ERROR;

  333.         fState |= JNS_CONNCD;

  334.         return getsockname(fSockfd, (struct sockaddr *)&fRecvAddr, &l);

  335.     }

  336. 

  337.     void JackNetUnixSocket::Close()

  338.     {

  339.         if (fSockfd) {

  340.             close(fSockfd);

  341.         }

  342.         fSockfd = 0;

  343.         fState = JNS_UNSPEC;

  344.     }

  345. 

  346.     void JackNetUnixSocket::Reset()

  347.     {

  348.         memset(&fSendAddr, 0, sizeof(fSendAddr));

  349.         fSendAddr.ss_family = fFamily;

  350.         memset(&fRecvAddr, 0, sizeof(fRecvAddr));

  351.         fRecvAddr.ss_family = fFamily;

  352.         if(fPort)

  353.             SetPort(fPort);

  354.     }

  355. 

  356.     bool JackNetUnixSocket::IsSocket()

  357.     {

  358.         return(fSockfd) ? true : false;

  359.     }

  360. 

  361.     //IP/PORT***********************************************************************************************************

  362.     void JackNetUnixSocket::SetPort(int port)

  363.     {

  364.         fPort = port;

  365.         switch(fFamily) { // Playing dumb here, in fact port section of both sockaddrs is compatible

  366.             case AF_INET:

  367.                 _sock4(fSendAddr).sin_port = htons(port);

  368.                 _sock4(fRecvAddr).sin_port = htons(port);

  369.                 break;

  370.             case AF_INET6:

  371.                 _sock6(fSendAddr).sin6_port = htons(port);

  372.                 _sock6(fRecvAddr).sin6_port = htons(port);

  373.                 break;

  374.             default:

  375.                 jack_info("JackNetUnixSocket::SetPort: Family not initialized");

  376.         }

  377.     }

  378. 

  379.     int JackNetUnixSocket::GetPort()

  380.     {

  381.         return fPort;

  382.     }

  383. 

  384.     //address***********************************************************************************************************

  385.     int JackNetUnixSocket::SetAddress(const char* ip, int port)

  386.     {

  387.         if(fFamily == AF_UNSPEC) {

  388.             fPort=port;

  389.             return ProbeAF(ip,&fSendAddr,&connect);

  390.         } else {

  391.             SetPort(port);

  392.             return inet_pton(fFamily, ip, _ss_addr_p(fSendAddr));

  393.         }

  394.     }

  395.     int JackNetUnixSocket::SetSendIP(const char *ip)

  396.     {

  397.         if(fFamily == AF_UNSPEC) return -1;

  398.         return inet_pton(fFamily, ip, _ss_addr_p(fSendAddr));

  399.     }

  400. 

  401.     char* JackNetUnixSocket::GetSendIP()

  402.     {

  403.         return (char*)inet_ntop(fFamily, _ss_addr_p(fSendAddr),f_addr_buff,INET6_ADDRSTRLEN);

  404.     }

  405. 

  406.     int JackNetUnixSocket::SetRecvIP(const char *ip)

  407.     {

  408.         if(fFamily == AF_UNSPEC) return -1;

  409.         return inet_pton(fFamily, ip, _ss_addr_p(fRecvAddr));

  410.     }

  411. 

  412.     char* JackNetUnixSocket::GetRecvIP()

  413.     {

  414.         return (char*)inet_ntop(fFamily, _ss_addr_p(fRecvAddr),f_addr_buff,INET6_ADDRSTRLEN);

  415.     }

  416. 

  417.     //utility************************************************************************************************************

  418.     int JackNetUnixSocket::GetName(char* name)

  419.     {

  420.         return gethostname(name, 255);

  421.     }

  422. 

  423.     int JackNetUnixSocket::JoinMCastGroup(const char* ip)

  424.     {

  425.         return JoinMCastGroup(ip,"any");

  426.     }

  427.     /** Glory and shame of IPv6 interoperability: Multicast

  428.     * Not only API is completely incompatible, but even socket is incompatible. I.e. you cannot use V4MAPPED/COMPATIBLE

  429.     * sockets/sockaddress for Multicast. Any V4 address is just a legacy unicast socket for IPv6. Moreover, IPv6 API

  430.     * implementation itself is a big mess even though there's no time anymore and way back. Here we're using POSIX API.

  431.     * When dealing with Multicast - Address Family should be set once and forever for used multicast address. This

  432.     * implies we cannot use V4 addresses on V6 sockets. So multicast should have V6ONLY soscket option set to allow v6

  433.     * adapter, master or manager coexist on the same host. See ProbeAF/Bind for these tricks.

  434.     */

  435.     int JackNetUnixSocket::JoinMCastGroup(const char* ip, const char *if_name)

  436.     {

  437.         int level, option, length;

  438.         void *mreq;

  439.         char addr[sizeof(in6_addr)];

  440.         inet_pton(fFamily, ip, addr);

  441.         if(!strcmp(if_name,"any")) { // UNSPEC binding we can do in-place using void pointers

  442.             if(fFamily == AF_INET) {

  443.                 struct ip_mreq multicast_req;

  444.                 multicast_req.imr_multiaddr.s_addr = *(uint32_t*)(addr);

  445.                 multicast_req.imr_interface.s_addr = htonl(INADDR_ANY);

  446.                 level = IPPROTO_IP;

  447.                 option = IP_ADD_MEMBERSHIP;

  448.                 mreq=&multicast_req;

  449.                 length = sizeof(ip_mreq);

  450.             } else if(fFamily == AF_INET6) {

  451.                 struct ipv6_mreq mreq6;

  452.                 memcpy(&mreq6.ipv6mr_multiaddr,addr,sizeof(in6_addr));

  453.                 mreq6.ipv6mr_interface = 0;

  454.                 level = IPPROTO_IPV6;

  455.                 option = IPV6_JOIN_GROUP;

  456.                 mreq = &mreq6;

  457.                 length = sizeof(ipv6_mreq);

  458.             } else {

  459.                 jack_error("Unsupported family[%d]",fFamily);

  460.                 return -1;

  461.             }

  462.             return SetOption(level, option, mreq, length);

  463.         } else { // For anything more complex need to call family-specific routine

  464.             if(fFamily == AF_INET)

  465.                 return BindMCastIface(if_name, IP_ADD_MEMBERSHIP, (struct in_addr *)addr);

  466.             else if(fFamily == AF_INET6)

  467.                 return BindMCast6Iface(if_name, (struct in6_addr *)addr);

  468.             else {

  469.                 jack_error("Unsupported family[%d]",fFamily);

  470.                 return -1;

  471.             }

  472.         }

  473.     }

  474.     int JackNetUnixSocket::BindMCastIface(const char *if_name, const int option, struct in_addr *addr)

  475.     {

  476.         struct ifaddrs *ifas, *ifa;

  477.         struct ip_mreq mreq;

  478.         int specific = strcmp("all",if_name);

  479.         int ret=-1;

  480.         char *if_last=(char *)"any";

  481. 

  482.         if (getifaddrs(&ifas) == -1) {

  483.                 jack_error("JackNetUnixSocket::BindMCastIface error in getifaddrs");

  484.                 return -1;

  485.         }

  486.         mreq.imr_multiaddr.s_addr = addr->s_addr;

  487.         for (ifa = ifas; ifa != NULL; ifa = ifa->ifa_next) {

  488.                 if (ifa->ifa_addr == NULL)

  489.                     continue; // Address is mandatory

  490.                 if(!ifa->ifa_name || !strcmp(if_last,ifa->ifa_name))

  491.                     continue; // Name as well, also skip already enabled interface

  492.                 if(!(ifa->ifa_flags & IFF_MULTICAST) || !(ifa->ifa_flags & IFF_RUNNING))

  493.                     continue; // And non multicast or down interface

  494.                 if(ifa->ifa_addr->sa_family != AF_INET)

  495.                     continue; // And non-matching family

  496.                 if(!specific || !strcmp(ifa->ifa_name,if_name)) {

  497.                     mreq.imr_interface.s_addr = ((struct sockaddr_in *)(ifa->ifa_addr))->sin_addr.s_addr;

  498.                     ret = SetOption(IPPROTO_IP, option, &mreq, sizeof(struct ip_mreq));

  499.                     if(ret)

  500.                         break;

  501.                     if_last = ifa->ifa_name;

  502.                     jack_log("JackNetUnixSocket::BindMCastIface attaching to %s", if_last);

  503.                 }

  504.         }

  505.         freeifaddrs(ifas);

  506.         if(!strcmp(if_last,"any"))

  507.                 jack_error("JackNetUnixSocket::BindMCastIface cannot find valid interface");

  508.         return ret;

  509.     }

  510.     int JackNetUnixSocket::BindMCast6Iface(const char *if_name, struct in6_addr *mip)

  511.     {

  512.         int i, ret=-1, specific=strcmp("all",if_name);

  513.         struct if_nameindex *if_ni = if_nameindex();

  514.         struct ipv6_mreq mreq;

  515.         if(if_ni) {

  516.             memcpy(&mreq.ipv6mr_multiaddr, mip, sizeof(struct in6_addr));

  517.             for (i=0; if_ni[i].if_index > 0; i++) {

  518.                 if(if_ni[i].if_index == 1)

  519.                     continue; // Skip loopback

  520.                 mreq.ipv6mr_interface = if_ni[i].if_index;

  521.                 if(!specific || !strcmp(if_ni[i].if_name,if_name)) {

  522.                     ret = SetOption(IPPROTO_IPV6, IPV6_JOIN_GROUP, &mreq, sizeof(mreq));

  523.                     if(ret < 0)

  524.                         break;

  525.                 }

  526.             }

  527.             if_freenameindex(if_ni);

  528.         }

  529.         return ret;

  530.     }

  531. 

  532.     //options************************************************************************************************************

  533.     int JackNetUnixSocket::SetOption(int level, int optname, const void* optval, socklen_t optlen)

  534.     {

  535.         return setsockopt(fSockfd, level, optname, optval, optlen);

  536.     }

  537. 

  538.     int JackNetUnixSocket::GetOption(int level, int optname, void* optval, socklen_t* optlen)

  539.     {

  540.         return getsockopt(fSockfd, level, optname, optval, optlen);

  541.     }

  542. 

  543.     //timeout************************************************************************************************************

  544. 

  545. #if defined(__sun__) || defined(sun)

  546.     int JackNetUnixSocket::SetTimeOut(int us)

  547.     {

  548.         int     flags;

  549.         fTimeOut = us;

  550. 

  551.         if ((flags = fcntl(fSockfd, F_GETFL, 0)) < 0) {

  552.                     jack_error("JackNetUnixSocket::SetTimeOut error in fcntl F_GETFL");

  553.                     return -1;

  554.             }

  555. 

  556.             flags |= O_NONBLOCK;

  557.             if (fcntl(fSockfd, F_SETFL, flags) < 0) {

  558.                     jack_error("JackNetUnixSocket::SetTimeOut error in fcntl F_SETFL");

  559.                     return 1;

  560.             }

  561. 

  562.         return 0;

  563.     }

  564. 

  565.     int JackNetUnixSocket::WaitRead()

  566.     {

  567.         if (fTimeOut > 0) {

  568. 

  569.             struct timeval tv;

  570.                 fd_set fdset;

  571.             ssize_t     res;

  572. 

  573.             tv.tv_sec = fTimeOut / 1000000;

  574.                 tv.tv_usec = fTimeOut % 1000000;

  575. 

  576.                 FD_ZERO(&fdset);

  577.                 FD_SET(fSockfd, &fdset);

  578. 

  579. 	        do {

  580. 		        res = select(fSockfd + 1, &fdset, NULL, NULL, &tv);

  581. 	        } while (res < 0 && errno == EINTR);

  582. 

  583.                 if (res < 0) {

  584.                         return res;

  585.             } else if (res == 0) {

  586.                 errno = ETIMEDOUT;

  587.                         return -1;

  588.                 }

  589.         }

  590. 

  591.         return 0;

  592.     }

  593. 

  594.     int JackNetUnixSocket::WaitWrite()

  595.     {

  596.         if (fTimeOut > 0) {

  597. 

  598.             struct timeval tv;

  599.                 fd_set fdset;

  600.             ssize_t     res;

  601. 

  602.             tv.tv_sec = fTimeOut / 1000000;

  603.             tv.tv_usec = fTimeOut % 1000000;

  604. 

  605.                 FD_ZERO(&fdset);

  606.                 FD_SET(fSockfd, &fdset);

  607. 

  608. 	        do {

  609. 		        res = select(fSockfd + 1, NULL, &fdset, NULL, &tv);

  610. 	        } while (res < 0 && errno == EINTR);

  611. 

  612.                 if (res < 0) {

  613.                         return res;

  614.             } else if (res == 0) {

  615.                 errno = ETIMEDOUT;

  616.                         return -1;

  617.                 }

  618.         }

  619. 

  620.         return 0;

  621.     }

  622. 

  623. #else

  624.     int JackNetUnixSocket::SetTimeOut(int us)

  625.     {

  626.         jack_log("JackNetUnixSocket::SetTimeout %d usecs", us);

  627.         struct timeval timeout;

  628. 

  629.         //less than 1 sec

  630.         if (us < 1000000) {

  631.             timeout.tv_sec = 0;

  632.             timeout.tv_usec = us;

  633.         } else {

  634.         //more than 1 sec

  635.             float sec = float(us) / 1000000.f;

  636.             timeout.tv_sec = (int)sec;

  637.             float usec = (sec - float(timeout.tv_sec)) * 1000000;

  638.             timeout.tv_usec =(int)usec;

  639.         }

  640.         return SetOption(SOL_SOCKET, SO_RCVTIMEO, &timeout, sizeof(timeout));

  641.     }

  642. #endif

  643. 

  644.     //local loop**********************************************************************************************************

  645.     int JackNetUnixSocket::SetLocalLoop()

  646.     {

  647.         char disable = 0;

  648.         unsigned int dis6 = 0;

  649.         switch(fFamily) {

  650.         case AF_INET:

  651.             return SetOption(IPPROTO_IP, IP_MULTICAST_LOOP, &disable, sizeof(disable));

  652.         case AF_INET6:

  653.             return SetOption(IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &dis6, sizeof(dis6));

  654.         default:

  655.             jack_error("JackNetUnixSocket::SetLocalLoop: Family not initialized");

  656.             return -1;

  657.         }

  658.     }

  659. 

  660.     //network operations**************************************************************************************************

  661.     int JackNetUnixSocket::SendTo(const void* buffer, size_t nbytes, int flags)

  662.     {

  663.     #if defined(__sun__) || defined(sun)

  664.         if (WaitWrite() < 0) {

  665.             return -1;

  666.         }

  667.     #endif

  668.         int res;

  669.         if ((res = sendto(fSockfd, buffer, nbytes, flags, reinterpret_cast<struct sockaddr *>(&fSendAddr), sizeof(fSendAddr))) < 0) {

  670.             jack_error("SendTo fd = %ld err = %s", fSockfd, strerror(errno));

  671.         }

  672.         return res;

  673.     }

  674. 

  675.     int JackNetUnixSocket::SendTo(const void* buffer, size_t nbytes, int flags, const char* ip)

  676.     {

  677.         int addr_conv = inet_pton(fFamily, ip, _ss_addr_p(fSendAddr));

  678.         if (addr_conv < 1) {

  679.             return addr_conv;

  680.         }

  681. 	//fSendAddr.sin_port = htons(fPort);

  682.     #if defined(__sun__) || defined(sun)

  683.         if (WaitWrite() < 0) {

  684.             return -1;

  685.         }

  686.     #endif

  687.         return SendTo(buffer, nbytes, flags);

  688.     }

  689. 

  690.     int JackNetUnixSocket::Send(const void* buffer, size_t nbytes, int flags)

  691.     {

  692.     #if defined(__sun__) || defined(sun)

  693.         if (WaitWrite() < 0) {

  694.             return -1;

  695.         }

  696.     #endif

  697.         int res;

  698.         if ((res = send(fSockfd, buffer, nbytes, flags)) < 0) {

  699.             jack_error("Send fd = %ld err = %s", fSockfd, strerror(errno));

  700.         }

  701.         return res;

  702.     }

  703. 

  704.     int JackNetUnixSocket::RecvFrom(void* buffer, size_t nbytes, int flags)

  705.     {

  706.         socklen_t addr_len = sizeof(fRecvAddr);

  707.     #if defined(__sun__) || defined(sun)

  708.         if (WaitRead() < 0) {

  709.             return -1;

  710.         }

  711.     #endif

  712.         int res;

  713.         if ((res = recvfrom(fSockfd, buffer, nbytes, flags, reinterpret_cast<struct sockaddr *>(&fRecvAddr), &addr_len)) < 0) {

  714.             jack_error("RecvFrom fd = %ld err = %s", fSockfd, strerror(errno));

  715.         }

  716.         return res;        

  717.     }

  718. 

  719.     int JackNetUnixSocket::Recv(void* buffer, size_t nbytes, int flags)

  720.     {

  721.     #if defined(__sun__) || defined(sun)

  722.         if (WaitRead() < 0) {

  723.             return -1;

  724.         }

  725.     #endif

  726.         int res;

  727.         if ((res = recv(fSockfd, buffer, nbytes, flags)) < 0) {

  728.             jack_error("Recv fd = %ld err = %s", fSockfd, strerror(errno));

  729.         }

  730.         return res;        

  731.     }

  732. 

  733.     int JackNetUnixSocket::CatchHost(void* buffer, size_t nbytes, int flags)

  734.     {

  735.         jack_log("JackNetUnixSocket::CatchHost");

  736.         socklen_t addr_len = sizeof(fSendAddr);

  737.     #if defined(__sun__) || defined(sun)

  738.         if (WaitRead() < 0) {

  739.             return -1;

  740.         }

  741.     #endif

  742.         int res;

  743.         if ((res = recvfrom(fSockfd, buffer, nbytes, flags, reinterpret_cast<struct sockaddr *>(&fSendAddr), &addr_len)) < 0) {

  744.             jack_log("CatchHost fd = %ld err = %s", fSockfd, strerror(errno));

  745.         }

  746.         return res;                

  747.     }

  748. 

  749.     net_error_t JackNetUnixSocket::GetError()

  750.     {

  751.         switch (errno) {

  752.             case EAGAIN:

  753.             case ETIMEDOUT:

  754.                 return NET_NO_DATA;

  755. 

  756.             case ECONNABORTED:

  757.             case ECONNREFUSED:

  758.             case ECONNRESET:

  759.             case EINVAL:

  760.             case EHOSTDOWN:

  761.             case EHOSTUNREACH:

  762.             case ENETDOWN:

  763.             case ENETUNREACH:

  764.                 return NET_CONN_ERROR;

  765. 

  766.             default:

  767.                 //return NET_OP_ERROR;

  768.                 return NET_CONN_ERROR;

  769.         }

  770.     }

  771.         

  772.     void JackNetUnixSocket::PrintError()

  773.     {

  774.         switch (errno) {

  775.                 

  776.             case EAGAIN:

  777.                 jack_error("JackNetUnixSocket : EAGAIN");

  778.                 break;

  779.             case ETIMEDOUT:

  780.                 jack_error("JackNetUnixSocket : ETIMEDOUT");

  781.                 break;

  782.             case ECONNABORTED:

  783.                 jack_error("JackNetUnixSocket : ECONNABORTED");

  784.                 break;

  785.             case ECONNREFUSED:

  786.                 jack_error("JackNetUnixSocket : ECONNREFUSED");

  787.                 break;

  788.             case ECONNRESET:

  789.                 jack_error("JackNetUnixSocket : ECONNRESET");

  790.                 break;

  791.             case EINVAL:

  792.                 jack_error("JackNetUnixSocket : EINVAL");

  793.                 break;

  794.             case EHOSTDOWN:

  795.                 jack_error("JackNetUnixSocket : EHOSTDOWN");

  796.                 break;

  797.             case EHOSTUNREACH:

  798.                 jack_error("JackNetUnixSocket : EHOSTUNREACH");

  799.                 break;

  800.             case ENETDOWN:

  801.                 jack_error("JackNetUnixSocket : ENETDOWN");

  802.                 break;

  803.             case ENETUNREACH:

  804.                 jack_error("JackNetUnixSocket : ENETUNREACH");

  805.                 break;

  806.             default:

  807.                 jack_error("JackNetUnixSocket : %d", errno);

  808.                 break;

  809.         }

  810.     }    

  811. }