Branch netjack_squashed_interface_selection_plus_ipv6

Original PR:
https://github.com/jackaudio/jack2/pull/27
by rufferson, first comment Mar 3, 2013

Commits on Mar 12, 2017

    Add interface selection for NetJack components

@rufferson
rufferson committed on Mar 3, 2013

 * Multicast interface selection to UnixSocket - added methods
   Bind and JoinMCastGroup with <char *if_name> argument
 * Interface handling to NetInterface class tree - new field and
   its initialization/usage in Slave branch.
 * Multicast interface selection to NetSlaves (Adapter/Driver)
   and NetMaster, where master can now listen all interfaces.

Commits on Mar 15, 2017

    Add IPv6 support to UnixSocket and NetInterfaces

@rufferson
rufferson committed on Feb 21, 2013

 * Cleaned up direct references to sockaddr_in
 * Changed fRecvAddr & fSendAddr to sockaddr_storage
 * Added field fFamily indicating current probed AF.
 * Added protected method ProbeAF accepting IP to probe
   and addr to fill in. As well as final call to test
   which should be either connect or bind.
 * Reworked protocol specific methods to act on fFamily
 * IsLocal now checks assigned interface addresses
 * Introduced internal state tracker to avoid double bind
 * Workaround for GLIBC bug returning wrong order of AFs
   http://sourceware.org/bugzilla/show_bug.cgi?id=14967
 * Corrected interface selection for Slaves - only one
   interface could be used to multicast the packet
 * Retab changes

This branch has conflicts that must be resolved
to resolve conflicts before continuing.
Conflicting files
common/JackNetDriver.h
posix/JackNetUnixSocket.cpp

wget https://github.com/jackaudio/jack2/pull/27.diff

$ patch -p 1 < 27.diff
patching file common/JackNetAdapter.cpp
patching file common/JackNetDriver.cpp
patching file common/JackNetDriver.h
Hunk #1 FAILED at 79.
1 out of 1 hunk FAILED -- saving rejects to file common/JackNetDriver.h.rej
patching file common/JackNetInterface.cpp
patching file common/JackNetInterface.h
patching file common/JackNetManager.cpp
patching file common/JackNetManager.h
patching file common/JackNetTool.h
patching file posix/JackNetUnixSocket.cpp
Hunk #4 FAILED at 229.
Hunk #5 succeeded at 281 (offset -8 lines).
Hunk #6 succeeded at 303 (offset -8 lines).
Hunk #7 succeeded at 325 (offset -8 lines).
Hunk #8 succeeded at 363 (offset -8 lines).
Hunk #9 succeeded at 486 (offset -8 lines).
Hunk #10 succeeded at 508 (offset -8 lines).
Hunk #11 succeeded at 537 (offset -8 lines).
Hunk #12 succeeded at 586 (offset -8 lines).
Hunk #13 succeeded at 607 (offset -8 lines).
Hunk #14 succeeded at 615 (offset -8 lines).
Hunk #15 succeeded at 644 (offset -8 lines).
Hunk #16 succeeded at 673 (offset -8 lines).
1 out of 16 hunks FAILED -- saving rejects to file posix/JackNetUnixSocket.cpp.rej

 find|grep rej
./posix/JackNetUnixSocket.cpp.rej
./common/JackNetDriver.h.rej

--- posix/JackNetUnixSocket.cpp
+++ posix/JackNetUnixSocket.cpp
@@ -229,58 +311,117 @@
     {
         if (strcmp(ip, "127.0.0.1") == 0) {
             return true;
-        }
+        } else if(!strcmp(ip,"::1"))
+            return true;

-        char host_name[32];
-        gethostname(host_name, sizeof(host_name));
+        struct ifaddrs *ifas, *ifa;
+        socklen_t len;

-        struct hostent* host = gethostbyname(host_name);
-        if (host) {
-            for (int i = 0; host->h_addr_list[i] != 0; ++i) {
-                struct in_addr addr;
-                memcpy(&addr, host->h_addr_list[i], sizeof(struct in_addr));
-                if (strcmp(inet_ntoa(addr), ip) == 0) {
-                    return true;
-                }
-            }
-            return false;
-        } else {
-            return false;
+        if (getifaddrs(&ifas) == -1) {
+                jack_error("JackNetUnixSocket::IsLocal error in getifaddrs");
+                return false;
         }
+        for (ifa = ifas; ifa != NULL; ifa = ifa->ifa_next) {
+                if (ifa->ifa_addr == NULL)
+                    continue; // Address is mandatory
+                len = (ifa->ifa_addr->sa_family==AF_INET)?sizeof(struct sockaddr_in):sizeof(struct sockaddr_in6);
+                if(!getnameinfo(ifa->ifa_addr, len, f_addr_buff, INET6_ADDRSTRLEN, NULL,0, NI_NUMERICSERV | NI_DGRAM | NI_NUMERICHOST))
+                    if(!strcmp(f_addr_buff,ip))
+                        break;
+        }
+        freeifaddrs(ifas);
+        return (ifa != NULL);
     }

     int JackNetUnixSocket::Bind()
     {
-        return bind(fSockfd, reinterpret_cast<socket_address_t*>(&fRecvAddr), sizeof(socket_address_t));
+        int yes=1;
+        if(fState & JNS_BOUND) return 0;
+        // Multicast is incompatible with V4MAPPED or V4COMPAT addresses, if probe detected MC we need V6ONLY
+        if(fFamily == AF_INET6 && IN6_IS_ADDR_UNSPECIFIED(&_sock6(fRecvAddr).sin6_addr) && fState & JNS_MCAST)
+            if(SetOption(IPPROTO_IPV6, IPV6_V6ONLY, &yes, sizeof(yes))) return SOCKET_ERROR;
+        if(bind(fSockfd, reinterpret_cast<struct sockaddr*>(&fRecvAddr), sizeof(fRecvAddr))) return SOCKET_ERROR;
+        fState |= JNS_BOUND;
+        return 0;
+    }
+    int JackNetUnixSocket::Bind(const char *if_name)
+    {
+        int ret = Bind();
+        if(!ret && strcmp(if_name,"any")) {
+            if(fFamily == AF_INET) {
+                // 'all' for this case will lead to 'last valid interface', which is not that one might expect
+                if(strcmp(if_name,"all"))
+                    ret = BindMCastIface(if_name, IP_MULTICAST_IF, &_sock4(fSendAddr).sin_addr);
+                else
+                    jack_error("Multicast Interface all not found, sending from default");
+            } else if(fFamily == AF_INET6) {
+                struct if_nameindex *if_ni = if_nameindex(); // In V6 world we do everything differently.
+                if(if_ni) {
+                    int i;
+                    for (i=0; if_ni[i].if_index > 0; i++) {
+                        if(if_ni[i].if_index == 1)
+                            continue; // Skip loopback
+                        if(!strcmp(if_ni[i].if_name,if_name)) {
+                            ret = SetOption(IPPROTO_IPV6, IPV6_MULTICAST_IF, &if_ni[i].if_index, sizeof(if_ni[i].if_index));
+                            jack_log("JackNetUnixSocket::Bind Multicasting from %s",if_ni[i].if_name);
+                            break;
+                        }
+                    }
+                    if(if_ni[i].if_index == 0) jack_error("Multicast Interface %s not found, sending from default",if_name);
+                    if_freenameindex(if_ni);
+                }
+            }
+        }
+        return ret;
     }

     int JackNetUnixSocket::BindWith(const char* ip)
     {
-        int addr_conv = inet_aton(ip, &fRecvAddr.sin_addr);
-        if (addr_conv < 0) {
-            return addr_conv;
+        if(fFamily == AF_UNSPEC) {
+            if(!fPort) return SOCKET_ERROR;
+            if(ProbeAF(ip,&fRecvAddr,&bind)<0) return SOCKET_ERROR;
+            fState |= JNS_BOUND;
+            return 0;
+        } else {
+            if(SetRecvIP(ip)==-1) return SOCKET_ERROR;
+            return Bind();
         }
-        return Bind();
     }

     int JackNetUnixSocket::BindWith(int port)
     {
-        fRecvAddr.sin_port = htons(port);
-        return Bind();
+        if(fFamily == AF_UNSPEC) {
+            fPort = port;
+            if(ProbeAF(NULL,&fRecvAddr,&bind)<0) return SOCKET_ERROR;
+            fState |= JNS_BOUND;
+            return 0;
+        } else {
+            SetPort(port);
+            return Bind();
+        }
     }

     int JackNetUnixSocket::Connect()
     {
-        return connect(fSockfd, reinterpret_cast<socket_address_t*>(&fSendAddr), sizeof(socket_address_t));
+        if(fFamily != AF_UNSPEC)
+            return connect(fSockfd, (struct sockaddr*)&fSendAddr,sizeof(fSendAddr));
+        jack_error("JackNetUnixSocket::Connect Family not initialized");
+        return SOCKET_ERROR;
     }

     int JackNetUnixSocket::ConnectTo(const char* ip)
     {
-        int addr_conv = inet_aton(ip, &fSendAddr.sin_addr);
-        if (addr_conv < 0) {
-            return addr_conv;
+        socklen_t l=sizeof(fRecvAddr);
+        if(fPort==0) return SOCKET_ERROR;
+        if(fState & JNS_PROBED) {
+            Reset();
+            fFamily=AF_UNSPEC;
         }
-        return Connect();
+        if(fSockfd)
+            Close();
+        if(ProbeAF(ip,&fSendAddr,&connect)<0) return SOCKET_ERROR;
+        fState |= JNS_CONNCD;
+        return getsockname(fSockfd, (struct sockaddr *)&fRecvAddr, &l);
     }

     void JackNetUnixSocket::Close()

--- common/JackNetDriver.h
+++ common/JackNetDriver.h
@@ -79,7 +79,7 @@
         public:

             JackNetDriver(const char* name, const char* alias, JackLockedEngine* engine, JackSynchro* table,
-                        const char* ip, int port, int mtu, int midi_input_ports, int midi_output_ports,
+                        const char* ip, int port, const char* mcif, int mtu, int midi_input_ports, int midi_output_ports,
                         char* net_name, uint transport_sync, int network_latency, int celt_encoding,
                         int opus_encoding, bool auto_save);
             virtual ~JackNetDriver();

Problem:

#set two properties for UUID 4294967296

$ jack_property -s 4294967296 "a" 1
$ jack_property -s 4294967296 b "2"

#-l lists them

$ jack_property -l
4294967296
key: b value: 2
key: a value: 1

#-l for UUID doesn't list them  <<<<<<

$ jack_property -l 4294967296
$ jack_property -l 4294967296 a
Value not found for a of 4294967296
$ jack_property -l 4294967296 b
Value not found for b of 4294967296

#it seems that 3 chars is the minimum length for value when querying for UUID

$ jack_property -s 4294967296 a 123
$ jack_property -l 4294967296
key: a value: 123
$ jack_property -l 4294967296 a
123

In example-clients/property.c:

/* list all properties for a given UUID */

                        if ((cnt = jack_get_properties (uuid, &description)) < 0) {
                                fprintf (stderr, "could not retrieve properties for %s\n", subject);
                                exit (1);
                        }

cnt is always 0 for values < 3 chars. Why?

In common/JackMetadata.cpp:

int JackMetadata::GetProperty(jack_uuid_t subject, const char* key, char** value, char** type)
int JackMetadata::GetProperties(jack_uuid_t subject, jack_description_t* desc)

This loop gets results:
while ((ret = cursor->get (cursor, &key, &data, DB_NEXT)) == 0) {

but are dropped because of this check:

/* result must have at least 2 chars plus 2 nulls to be valid
if (data.size < 4) {

This rule isn't understood. Explanations are welcome!
Reducing the check to 2 (1 char + null) will consider single char values.
This makes listing properties for a given UUID the same keys as when listing all UUIDs and keys.
No side-effects of lowering the value has been detected (yet).

Note: there is no problem getting "short" values in this method:
int JackMetadata::GetAllProperties(jack_description_t** descriptions)
(as used by jack_property -l without UUID)

jack_property output after change to (data.size < 2):

$ jack_property -s 4294967296 "a" 1
$ jack_property -s 4294967296 b "2"
$ jack_property -l
4294967296
key: b value: 2
key: a value: 1
$ jack_property -l 4294967296
key: b value: 2
key: a value: 1
$ jack_property -l 4294967296 a
1
$ jack_property -l 4294967296 b
2

Note: This change should be considered also for JACK1 (libjack/metadata.c)
to keep implementations in sync.

See https://github.com/jackaudio/jack2/issues/413

Due to inlining and enabled optimization the compiler will not create
machine instructions for the if-clauses and left shift for
sample_move_dS_s32s() and sample_move_dS_s32().

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

Due to the optimization of the compiler this commit does not introduce any
differences in the machine instructions.
Tested with GCC version 6.2.0 on ARM64 and x86_64.

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

ALSA expects right-aligned samples (0x00******) as mentioned in the
source code for SND_PCM_FORMAT_S24_LE:
Signed 24 bit Little Endian using low three bytes in 32-bit word
See http://git.alsa-project.org/?p=alsa-
lib.git;a=blob;f=include/pcm.h;h=5b0782315585de1d5ab82c9f2036b62c168f5a48;hb=HEAD#l140

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

ALSA expects right-aligned samples (0x00******) as mentioned in the
source code for SND_PCM_FORMAT_S24_LE:
Signed 24 bit Little Endian using low three bytes in 32-bit word
See http://git.alsa-project.org/?p=alsa-
lib.git;a=blob;f=include/pcm.h;h=5b0782315585de1d5ab82c9f2036b62c168f5a48;hb=HEAD#l140

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

GCC defines __ARM_NEON__ for asimd on ARMv7 and __ARM_NEON for simd on
ARMv8. Therefore also check for __ARM_NEON.

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

When building with MXE, the macro expansion of PRIu64 fails:

../common/JackAPI.cpp: In function 'int jack_uuid_parse(const char*, jack_uuid_t*)':
../common/JackAPI.cpp:2119:24: error: expected ')' before 'PRIu64'
     if (sscanf (b, "%" PRIu64, u) == 1) {
                        ^
../common/JackAPI.cpp:2119:33: warning: spurious trailing '%' in format [-Wformat=]
     if (sscanf (b, "%" PRIu64, u) == 1) {
                                 ^
../common/JackAPI.cpp:2119:33: warning: too many arguments for format [-Wformat-extra-args]
../common/JackAPI.cpp: In function 'void jack_uuid_unparse(jack_uuid_t, char*)':
../common/JackAPI.cpp:2134:45: error: expected ')' before 'PRIu64'
     snprintf (b, JACK_UUID_STRING_SIZE, "%" PRIu64, u);
                                             ^
../common/JackAPI.cpp:2134:54: warning: spurious trailing '%' in format [-Wformat=]
     snprintf (b, JACK_UUID_STRING_SIZE, "%" PRIu64, u);
                                                      ^
../common/JackAPI.cpp:2134:54: warning: too many arguments for format [-Wformat-extra-args]

This could be resolved by adding those two lines:

#define __STDC_FORMAT_MACROS 1
#include <inttypes.h>

References:
https://stackoverflow.com/questions/14535556/why-doesnt-priu64-work-in-this-code
https://stackoverflow.com/questions/8132399/how-to-printf-uint64-t-fails-with-spurious-trailing-in-format

Signed-off-by: falkTX <falktx@gmail.com>

* [metadata] Metadata properties implementation.

* [metadata] Fixed for shared server metadata-base accessor; alsofixed coding/naming style.

* [metadata] Fixed a tab for space.

* [metadata] Use of Berkeley DB is now truly optional on configure time.

* [metadata] Fixed tabs for spaces, again.

* [metadata] Fixed for shared metadata-base initialization and external clients.

* [metadata] Blind-fix for windows codebase.

* [metadata] Metadata API moved into client-side library only.

* [metadata] Fixed jack_port_uuid() stubbiness, now returning a proper UUID from port index.

* [metadata] Uniform method names.

* [metadata] Fixed PropertyChangeNotify through server async call.

Signed-off-by: falkTX <falktx@gmail.com>

This adds missing includes for alloca. The man page of alloca(3) states
that alloca.h should be #include'd to use alloca.

Also work around missing alloca.h header on Windows by adding a
compatibility module.

Closes: #197

This reverts commit dde9f29a8e.

The commit introduced the following compiler error:

[100/255] Compiling posix/JackNetUnixSocket.cpp
../posix/JackNetUnixSocket.cpp: In member function 'int Jack::JackNetUnixSocket::NewSocket()':
../posix/JackNetUnixSocket.cpp:126:32: error: 'tos' was not declared in this scope
         socklen_t len = sizeof(tos);

A bit late...

With this patch it is possibly to start the JACK daemon with a systemd
service file of type notify. The following provides an example service
file:

[Service]
Type=notify
ExecStart=/usr/bin/jackd -d alsa

[Install]
WantedBy=multi-user.target

Signed-off-by: Timo Wischer <twischer@de.adit-jv.com>

Flagged by the Debian QA tool.

Mostly automatic search-n-replace of the mistakes flagged.

Fixes #288

Thanks to Timo Wischer for the initial work

Adjusts the permissions of shared memory segments when promiscuous mode is
enabled.

The jack_group2gid() function does a thread-safe lookup of a unix gid from a
unix group name.

The jack_promiscuous_perms() function adjusts the permissions of a shared
resource (socket, semaphore, shm segment, ...) referenced by a fd and/or a
path so it can be used by any member of the provided unix group.

By using those functions it will be possible to enable a secure promiscuous
mode. 'Secure' meaning here that one is not forced to launch every clients
with a (way) too permissive 0000 umask.

Includes optimizations for internal clients, but not enabled yet.

Signed-off-by: Andreas Müller <schnitzeltony@googlemail.com>

a leading 1 was missing [1]

[1] http://www.musicdsp.org/showone.php?id=59

Signed-off-by: Andreas Müller <schnitzeltony@googlemail.com>

* detect version option before all other oprion parsing

jackd now checks its arguments for "-V" and "--version" before all other
option parsing happens.

* remove some dead code from option parsing

Version options are detected before optparse runs, the removed code
paths thus became obsolete.

* remove rest of version option from optparse

Detection of the version option is now handled outside of optparse, thus
left over stings and variables are removed.

* switch to string comparison for detection version option

Demanding an exact match for the option strings reflects the original
behavior more closely than a search for substrings.

If configured with --clients=512 (translates to CLIENT_NUM), we exceed
the maximum stack size. CLIENT_NUM==500 still works, but let's allocate
the matrix on the heap to be safe.

Kudos to Markus Seeber for the initial bug triage.

Fixes #212