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.
3642 Commits
8 Branches
339MB
Tree: 7125cada4c
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '7125cada4c'
${ noResults }
jack2/posix/JackNetUnixSocket.cpp

820 lines
29KB
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. // define IPV6_ADD_MEMBERSHIP for Mac OS X

  31. #ifndef IPV6_ADD_MEMBERSHIP

  32. #define IPV6_ADD_MEMBERSHIP IPV6_JOIN_GROUP

  33. #endif

  34. #ifndef IPV6_DROP_MEMBERSHIP

  35. #define IPV6_DROP_MEMBERSHIP IPV6_LEAVE_GROUP

  36. #endif

  37. 

  38. using namespace std;

  39. 

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

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

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

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

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

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

  46. #define JNS_UNSPEC 0x0

  47. #define JNS_PROBED 0x1

  48. #define JNS_BOUND  0x2

  49. #define JNS_CONNCD 0x4

  50. #define JNS_MCAST  0x10

  51. 

  52. namespace Jack

  53. {

  54.     //utility *********************************************************************************************************

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

  56.     {

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

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

  59.             strcpy(name, "default");

  60.             return SOCKET_ERROR;

  61.         }

  62.         return 0;

  63.     }

  64. 

  65.     //construct/destruct***********************************************************************************************

  66.     JackNetUnixSocket::JackNetUnixSocket()

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

  68.     {

  69.         Reset();

  70.     }

  71. 

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

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

  74.     {

  75.         Reset();

  76.         fPort = port;

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

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

  79.     }

  80. 

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

  82.     {

  83.         Clone(socket);

  84.     }

  85. 

  86.     JackNetUnixSocket::~JackNetUnixSocket()

  87.     {

  88.         Close();

  89.     }

  90. 

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

  92.     {

  93.         if (this != &socket)

  94.             Clone(socket);

  95.         return *this;

  96.     }

  97. 

  98.     //socket***********************************************************************************************************

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

  100.     {

  101.         fSockfd = 0;

  102.         fTimeOut = 0;

  103.         fPort = socket.fPort;

  104.         fFamily = socket.fFamily;

  105.         fState = socket.fState;

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

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

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

  109.     }

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

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

  112.     */

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

  114.     {

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

  116.         char sport[6];

  117.         int ret;

  118. 

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

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

  121.         hint.ai_family = fFamily;

  122.         hint.ai_socktype = SOCK_DGRAM;

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

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

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

  126.         if(ret) {

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

  128.             return ret;

  129.         }

  130. #define GLIBC_BUG

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

  132. #ifdef GLIBC_BUG

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

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

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

  136.             // Swapping first two entries

  137.             ri = res->ai_next;

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

  139.             ri->ai_next = res;

  140.             res = ri;

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

  142. #endif

  143.             ri = res;

  144.         do {

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

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

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

  148.             if(ret < 0)

  149.                 continue;

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

  151.                 break;

  152.             close(ret);

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

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

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

  156.         if(ri) {

  157.             fSockfd = ret;

  158.             fFamily = ri->ai_family;

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

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

  161.             fState |= JNS_PROBED;

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

  163.                 fState |= JNS_MCAST;

  164.         } else

  165.             ret = SOCKET_ERROR;

  166.         freeaddrinfo(res);

  167.         return ret;

  168.     }

  169. 

  170.     int JackNetUnixSocket::NewSocket()

  171.     {

  172.         return NewSocket(NULL);

  173.     }

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

  175.     {

  176.         if(fFamily == AF_UNSPEC) {

  177.             if(ip) {

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

  179.                     return SOCKET_ERROR;

  180.             } else {

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

  182.                     return SOCKET_ERROR;

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

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

  185.             }

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

  187.         }

  188.         if (fSockfd) {

  189.             Close();

  190.             Reset();

  191.         }

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

  193. 

  194.         /* Enable address reuse */

  195.         int res, on = 1;

  196.     #ifdef __APPLE__

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

  198.     #else

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

  200.     #endif

  201.             StrError(NET_ERROR_CODE);

  202.         }

  203.         

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

  205.         

  206.         /*

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

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

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

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

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

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

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

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

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

  216.         */

  217.         

  218.         socklen_t len = sizeof(tos);

  219.         

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

  221.         

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

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

  224. 

  225.         return fSockfd;

  226.     }

  227. 

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

  229.     {

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

  231.             return true;

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

  233.             return true;

  234. 

  235.         struct ifaddrs *ifas, *ifa;

  236.         socklen_t len;

  237. 

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

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

  240.                 return false;

  241.         }

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

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

  244.                     continue; // Address is mandatory

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

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

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

  248.                         break;

  249.         }

  250.         freeifaddrs(ifas);

  251.         return (ifa != NULL);

  252.     }

  253. 

  254.     int JackNetUnixSocket::Bind()

  255.     {

  256.         int yes=1;

  257.         if(fState & JNS_BOUND) return 0;

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

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

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

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

  262.         fState |= JNS_BOUND;

  263.         return 0;

  264.     }

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

  266.     {

  267.         int ret = Bind();

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

  269.             if(fFamily == AF_INET) {

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

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

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

  273.                 else

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

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

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

  277.                 if(if_ni) {

  278.                     int i;

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

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

  281.                             continue; // Skip loopback

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

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

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

  285.                             break;

  286.                         }

  287.                     }

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

  289.                     if_freenameindex(if_ni);

  290.                 }

  291.             }

  292.         }

  293.         return ret;

  294.     }

  295. 

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

  297.     {

  298.         if(fFamily == AF_UNSPEC) {

  299.             if(!fPort) return SOCKET_ERROR;

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

  301.             fState |= JNS_BOUND;

  302.             return 0;

  303.         } else {

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

  305.             return Bind();

  306.         }

  307.     }

  308. 

  309.     int JackNetUnixSocket::BindWith(int port)

  310.     {

  311.         if(fFamily == AF_UNSPEC) {

  312.             fPort = port;

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

  314.             fState |= JNS_BOUND;

  315.             return 0;

  316.         } else {

  317.             SetPort(port);

  318.             return Bind();

  319.         }

  320.     }

  321. 

  322.     int JackNetUnixSocket::Connect()

  323.     {

  324.         if(fFamily != AF_UNSPEC)

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

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

  327.         return SOCKET_ERROR;

  328.     }

  329. 

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

  331.     {

  332.         socklen_t l=sizeof(fRecvAddr);

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

  334.         if(fState & JNS_PROBED) {

  335.             Reset();

  336.             fFamily=AF_UNSPEC;

  337.         }

  338.         if(fSockfd)

  339.             Close();

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

  341.         fState |= JNS_CONNCD;

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

  343.     }

  344. 

  345.     void JackNetUnixSocket::Close()

  346.     {

  347.         if (fSockfd) {

  348.             close(fSockfd);

  349.         }

  350.         fSockfd = 0;

  351.         fState = JNS_UNSPEC;

  352.     }

  353. 

  354.     void JackNetUnixSocket::Reset()

  355.     {

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

  357.         fSendAddr.ss_family = fFamily;

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

  359.         fRecvAddr.ss_family = fFamily;

  360.         if(fPort)

  361.             SetPort(fPort);

  362.     }

  363. 

  364.     bool JackNetUnixSocket::IsSocket()

  365.     {

  366.         return(fSockfd) ? true : false;

  367.     }

  368. 

  369.     //IP/PORT***********************************************************************************************************

  370.     void JackNetUnixSocket::SetPort(int port)

  371.     {

  372.         fPort = port;

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

  374.             case AF_INET:

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

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

  377.                 break;

  378.             case AF_INET6:

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

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

  381.                 break;

  382.             default:

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

  384.         }

  385.     }

  386. 

  387.     int JackNetUnixSocket::GetPort()

  388.     {

  389.         return fPort;

  390.     }

  391. 

  392.     //address***********************************************************************************************************

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

  394.     {

  395.         if(fFamily == AF_UNSPEC) {

  396.             fPort=port;

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

  398.         } else {

  399.             SetPort(port);

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

  401.         }

  402.     }

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

  404.     {

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

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

  407.     }

  408. 

  409.     char* JackNetUnixSocket::GetSendIP()

  410.     {

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

  412.     }

  413. 

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

  415.     {

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

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

  418.     }

  419. 

  420.     char* JackNetUnixSocket::GetRecvIP()

  421.     {

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

  423.     }

  424. 

  425.     //utility************************************************************************************************************

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

  427.     {

  428.         return gethostname(name, 255);

  429.     }

  430. 

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

  432.     {

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

  434.     }

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

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

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

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

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

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

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

  442.     */

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

  444.     {

  445.         int level, option, length;

  446.         void *mreq;

  447.         char addr[sizeof(in6_addr)];

  448.         inet_pton(fFamily, ip, addr);

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

  450.             if(fFamily == AF_INET) {

  451.                 struct ip_mreq multicast_req;

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

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

  454.                 level = IPPROTO_IP;

  455.                 option = IP_ADD_MEMBERSHIP;

  456.                 mreq=&multicast_req;

  457.                 length = sizeof(ip_mreq);

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

  459.                 struct ipv6_mreq mreq6;

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

  461.                 mreq6.ipv6mr_interface = 0;

  462.                 level = IPPROTO_IPV6;

  463.                 option = IPV6_ADD_MEMBERSHIP;

  464.                 mreq = &mreq6;

  465.                 length = sizeof(ipv6_mreq);

  466.             } else {

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

  468.                 return -1;

  469.             }

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

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

  472.             if(fFamily == AF_INET)

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

  474.             else if(fFamily == AF_INET6)

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

  476.             else {

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

  478.                 return -1;

  479.             }

  480.         }

  481.     }

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

  483.     {

  484.         struct ifaddrs *ifas, *ifa;

  485.         struct ip_mreq mreq;

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

  487.         int ret=-1;

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

  489. 

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

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

  492.                 return -1;

  493.         }

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

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

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

  497.                     continue; // Address is mandatory

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

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

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

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

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

  503.                     continue; // And non-matching family

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

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

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

  507.                     if(ret)

  508.                         break;

  509.                     if_last = ifa->ifa_name;

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

  511.                 }

  512.         }

  513.         freeifaddrs(ifas);

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

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

  516.         return ret;

  517.     }

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

  519.     {

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

  521.         struct if_nameindex *if_ni = if_nameindex();

  522.         struct ipv6_mreq mreq;

  523.         if(if_ni) {

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

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

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

  527.                     continue; // Skip loopback

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

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

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

  531.                     if(ret < 0)

  532.                         break;

  533.                 }

  534.             }

  535.             if_freenameindex(if_ni);

  536.         }

  537.         return ret;

  538.     }

  539. 

  540.     //options************************************************************************************************************

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

  542.     {

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

  544.     }

  545. 

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

  547.     {

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

  549.     }

  550. 

  551.     //timeout************************************************************************************************************

  552. 

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

  554.     int JackNetUnixSocket::SetTimeOut(int us)

  555.     {

  556.         int     flags;

  557.         fTimeOut = us;

  558. 

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

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

  561.                     return -1;

  562.             }

  563. 

  564.             flags |= O_NONBLOCK;

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

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

  567.                     return 1;

  568.             }

  569. 

  570.         return 0;

  571.     }

  572. 

  573.     int JackNetUnixSocket::WaitRead()

  574.     {

  575.         if (fTimeOut > 0) {

  576. 

  577.             struct timeval tv;

  578.                 fd_set fdset;

  579.             ssize_t     res;

  580. 

  581.             tv.tv_sec = fTimeOut / 1000000;

  582.                 tv.tv_usec = fTimeOut % 1000000;

  583. 

  584.                 FD_ZERO(&fdset);

  585.                 FD_SET(fSockfd, &fdset);

  586. 

  587. 	        do {

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

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

  590. 

  591.                 if (res < 0) {

  592.                         return res;

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

  594.                 errno = ETIMEDOUT;

  595.                         return -1;

  596.                 }

  597.         }

  598. 

  599.         return 0;

  600.     }

  601. 

  602.     int JackNetUnixSocket::WaitWrite()

  603.     {

  604.         if (fTimeOut > 0) {

  605. 

  606.             struct timeval tv;

  607.                 fd_set fdset;

  608.             ssize_t     res;

  609. 

  610.             tv.tv_sec = fTimeOut / 1000000;

  611.             tv.tv_usec = fTimeOut % 1000000;

  612. 

  613.                 FD_ZERO(&fdset);

  614.                 FD_SET(fSockfd, &fdset);

  615. 

  616. 	        do {

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

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

  619. 

  620.                 if (res < 0) {

  621.                         return res;

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

  623.                 errno = ETIMEDOUT;

  624.                         return -1;

  625.                 }

  626.         }

  627. 

  628.         return 0;

  629.     }

  630. 

  631. #else

  632.     int JackNetUnixSocket::SetTimeOut(int us)

  633.     {

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

  635.         struct timeval timeout;

  636. 

  637.         //less than 1 sec

  638.         if (us < 1000000) {

  639.             timeout.tv_sec = 0;

  640.             timeout.tv_usec = us;

  641.         } else {

  642.         //more than 1 sec

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

  644.             timeout.tv_sec = (int)sec;

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

  646.             timeout.tv_usec =(int)usec;

  647.         }

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

  649.     }

  650. #endif

  651. 

  652.     //local loop**********************************************************************************************************

  653.     int JackNetUnixSocket::SetLocalLoop()

  654.     {

  655.         char disable = 0;

  656.         unsigned int dis6 = 0;

  657.         switch(fFamily) {

  658.         case AF_INET:

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

  660.         case AF_INET6:

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

  662.         default:

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

  664.             return -1;

  665.         }

  666.     }

  667. 

  668.     //network operations**************************************************************************************************

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

  670.     {

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

  672.         if (WaitWrite() < 0) {

  673.             return -1;

  674.         }

  675.     #endif

  676.         int res;

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

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

  679.         }

  680.         return res;

  681.     }

  682. 

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

  684.     {

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

  686.         if (addr_conv < 1) {

  687.             return addr_conv;

  688.         }

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

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

  691.         if (WaitWrite() < 0) {

  692.             return -1;

  693.         }

  694.     #endif

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

  696.     }

  697. 

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

  699.     {

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

  701.         if (WaitWrite() < 0) {

  702.             return -1;

  703.         }

  704.     #endif

  705.         int res;

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

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

  708.         }

  709.         return res;

  710.     }

  711. 

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

  713.     {

  714.         socklen_t addr_len = sizeof(fRecvAddr);

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

  716.         if (WaitRead() < 0) {

  717.             return -1;

  718.         }

  719.     #endif

  720.         int res;

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

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

  723.         }

  724.         return res;        

  725.     }

  726. 

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

  728.     {

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

  730.         if (WaitRead() < 0) {

  731.             return -1;

  732.         }

  733.     #endif

  734.         int res;

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

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

  737.         }

  738.         return res;        

  739.     }

  740. 

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

  742.     {

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

  744.         socklen_t addr_len = sizeof(fSendAddr);

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

  746.         if (WaitRead() < 0) {

  747.             return -1;

  748.         }

  749.     #endif

  750.         int res;

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

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

  753.         }

  754.         return res;                

  755.     }

  756. 

  757.     net_error_t JackNetUnixSocket::GetError()

  758.     {

  759.         switch (errno) {

  760.             case EAGAIN:

  761.             case ETIMEDOUT:

  762.                 return NET_NO_DATA;

  763. 

  764.             case ECONNABORTED:

  765.             case ECONNREFUSED:

  766.             case ECONNRESET:

  767.             case EINVAL:

  768.             case EHOSTDOWN:

  769.             case EHOSTUNREACH:

  770.             case ENETDOWN:

  771.             case ENETUNREACH:

  772.                 return NET_CONN_ERROR;

  773. 

  774.             default:

  775.                 //return NET_OP_ERROR;

  776.                 return NET_CONN_ERROR;

  777.         }

  778.     }

  779.         

  780.     void JackNetUnixSocket::PrintError()

  781.     {

  782.         switch (errno) {

  783.                 

  784.             case EAGAIN:

  785.                 jack_error("JackNetUnixSocket : EAGAIN");

  786.                 break;

  787.             case ETIMEDOUT:

  788.                 jack_error("JackNetUnixSocket : ETIMEDOUT");

  789.                 break;

  790.             case ECONNABORTED:

  791.                 jack_error("JackNetUnixSocket : ECONNABORTED");

  792.                 break;

  793.             case ECONNREFUSED:

  794.                 jack_error("JackNetUnixSocket : ECONNREFUSED");

  795.                 break;

  796.             case ECONNRESET:

  797.                 jack_error("JackNetUnixSocket : ECONNRESET");

  798.                 break;

  799.             case EINVAL:

  800.                 jack_error("JackNetUnixSocket : EINVAL");

  801.                 break;

  802.             case EHOSTDOWN:

  803.                 jack_error("JackNetUnixSocket : EHOSTDOWN");

  804.                 break;

  805.             case EHOSTUNREACH:

  806.                 jack_error("JackNetUnixSocket : EHOSTUNREACH");

  807.                 break;

  808.             case ENETDOWN:

  809.                 jack_error("JackNetUnixSocket : ENETDOWN");

  810.                 break;

  811.             case ENETUNREACH:

  812.                 jack_error("JackNetUnixSocket : ENETUNREACH");

  813.                 break;

  814.             default:

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

  816.                 break;

  817.         }

  818.     }    

  819. }