libs/midi++2/ipmidi_port.cc

   1 /*
   2     Copyright (C) 2012 Paul Davis
   3
   4     Using code from Rui Nuno Capela's qmidinet as inspiration.
   5
   6     This program is free software; you can redistribute it and/or modify
   7     it under the terms of the GNU General Public License as published by
   8     the Free Software Foundation; either version 2 of the License, or
   9     (at your option) any later version.
  10
  11     This program is distributed in the hope that it will be useful,
  12     but WITHOUT ANY WARRANTY; without even the implied warranty of
  13     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14     GNU General Public License for more details.
  15
  16     You should have received a copy of the GNU General Public License
  17     along with this program; if not, write to the Free Software
  18     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  19
  20     $Id: port.cc 12065 2012-04-23 16:23:48Z paul $
  21 */
  22 #include <iostream>
  23 #include <cstdio>
  24 #include <fcntl.h>
  25 #include <errno.h>
  26 #include <stdlib.h>
  27 #include <string.h>
  28 #ifdef   COMPILER_MSVC
  29 #undef   O_NONBLOCK
  30 #define  O_NONBLOCK 0
  31 #endif
  32 #if defined(PLATFORM_WINDOWS)
  33 #include <winsock2.h>
  34 #include <ws2tcpip.h>
  35 #else
  36 #include <netdb.h>
  37 #endif
  38
  39 #if defined(PLATFORM_WINDOWS)
  40 typedef int socklen_t;
  41 #else
  42 #include <unistd.h>
  43 #include <sys/ioctl.h>
  44 inline void closesocket(int s) { ::close(s); }
  45 #endif
  46
  47 #include "pbd/xml++.h"
  48 #include "pbd/error.h"
  49 #include "pbd/failed_constructor.h"
  50 #include "pbd/convert.h"
  51 #include "pbd/compose.h"
  52
  53 #include "midi++/types.h"
  54 #include "midi++/ipmidi_port.h"
  55 #include "midi++/channel.h"
  56
  57 using namespace MIDI;
  58 using namespace std;
  59 using namespace PBD;
  60
  61 IPMIDIPort::IPMIDIPort (int base_port, const string& iface)
  62         : Port (string_compose ("IPmidi@%1", base_port), Port::Flags (Port::IsInput|Port::IsOutput))
  63         , sockin (-1)
  64         , sockout (-1)
  65 {
  66         if (!open_sockets (base_port, iface)) {
  67                 throw (failed_constructor ());
  68         }
  69 }
  70
  71 IPMIDIPort::IPMIDIPort (const XMLNode& node)
  72         : Port (node)
  73 {
  74         /* base class does not class set_state() */
  75         set_state (node);
  76 }
  77
  78 IPMIDIPort::~IPMIDIPort ()
  79 {
  80         close_sockets ();
  81 }
  82
  83 int
  84 IPMIDIPort::selectable () const
  85 {
  86         return sockin;
  87 }
  88
  89 XMLNode&
  90 IPMIDIPort::get_state () const
  91 {
  92         return Port::get_state ();
  93 }
  94
  95 void
  96 IPMIDIPort::set_state (const XMLNode& node)
  97 {
  98         Port::set_state (node);
  99 }
 100
 101 void
 102 IPMIDIPort::close_sockets ()
 103 {
 104         if (sockin >= 0) {
 105                 ::closesocket (sockin);
 106                 sockin = -1;
 107         }
 108
 109         if (sockout >= 0) {
 110                 ::closesocket (sockout);
 111                 sockout = -1;
 112         }
 113 }
 114
 115 #ifndef PLATFORM_WINDOWS
 116 static bool
 117 get_address (int sock, struct in_addr *inaddr, const string& ifname )
 118 {
 119         // Get interface address from supplied name.
 120
 121         struct ifreq ifr;
 122         ::strncpy(ifr.ifr_name, ifname.c_str(), sizeof(ifr.ifr_name));
 123
 124         if (::ioctl(sock, SIOCGIFFLAGS, (char *) &ifr)) {
 125                 ::perror("ioctl(SIOCGIFFLAGS)");
 126                 return false;
 127         }
 128
 129         if ((ifr.ifr_flags & IFF_UP) == 0) {
 130                 error << string_compose ("interface %1 is down", ifname) << endmsg;
 131                 return false;
 132         }
 133
 134         if (::ioctl(sock, SIOCGIFADDR, (char *) &ifr)) {
 135                 ::perror("ioctl(SIOCGIFADDR)");
 136                 return false;
 137         }
 138
 139         struct sockaddr_in sa;
 140         ::memcpy(&sa, &ifr.ifr_addr, sizeof(struct sockaddr_in));
 141         inaddr->s_addr = sa.sin_addr.s_addr;
 142
 143         return true;
 144 }
 145 #endif
 146
 147 bool
 148 IPMIDIPort::open_sockets (int base_port, const string& ifname)
 149 {
 150         int protonum = 0;
 151         struct protoent *proto = ::getprotobyname("IP");
 152
 153         if (proto) {
 154                 protonum = proto->p_proto;
 155         }
 156
 157         sockin = ::socket (PF_INET, SOCK_DGRAM, protonum);
 158         if (sockin < 0) {
 159                 ::perror("socket(in)");
 160                 return false;
 161         }
 162
 163         struct sockaddr_in addrin;
 164         ::memset(&addrin, 0, sizeof(addrin));
 165         addrin.sin_family = AF_INET;
 166         addrin.sin_addr.s_addr = htonl(INADDR_ANY);
 167         addrin.sin_port = htons(base_port);
 168
 169         if (::bind(sockin, (struct sockaddr *) (&addrin), sizeof(addrin)) < 0) {
 170                 ::perror("bind");
 171                 return false;
 172         }
 173
 174         // Will Hall, 2007
 175         // INADDR_ANY will bind to default interface,
 176         // specify alternate interface nameon which to bind...
 177         struct in_addr if_addr_in;
 178 #ifndef PLATFORM_WINDOWS
 179         if (!ifname.empty()) {
 180                 if (!get_address(sockin, &if_addr_in, ifname)) {
 181                         error << string_compose ("socket(in): could not find interface address for %1", ifname) << endmsg;
 182                         return false;
 183                 }
 184                 if (::setsockopt(sockin, IPPROTO_IP, IP_MULTICAST_IF,
 185                                  (char *) &if_addr_in, sizeof(if_addr_in))) {
 186                         ::perror("setsockopt(IP_MULTICAST_IF)");
 187                         return false;
 188                 }
 189         } else {
 190                 if_addr_in.s_addr = htonl (INADDR_ANY);
 191         }
 192 #else
 193         if_addr_in.s_addr = htonl (INADDR_ANY);
 194 #endif
 195
 196         struct ip_mreq mreq;
 197         mreq.imr_multiaddr.s_addr = ::inet_addr("225.0.0.37"); /* ipMIDI group multicast address */
 198         mreq.imr_interface.s_addr = if_addr_in.s_addr;
 199         if(::setsockopt (sockin, IPPROTO_IP, IP_ADD_MEMBERSHIP, (char *) &mreq, sizeof(mreq)) < 0) {
 200                 ::perror("setsockopt(IP_ADD_MEMBERSHIP)");
 201                 fprintf(stderr, "socket(in): your kernel is probably missing multicast support.\n");
 202                 return false;
 203         }
 204
 205         // Output socket...
 206
 207         sockout = ::socket (AF_INET, SOCK_DGRAM, protonum);
 208
 209         if (sockout < 0) {
 210                 ::perror("socket(out)");
 211                 return false;
 212         }
 213
 214         // Will Hall, Oct 2007
 215 #ifndef PLATFORM_WINDOWS
 216         if (!ifname.empty()) {
 217                 struct in_addr if_addr_out;
 218                 if (!get_address(sockout, &if_addr_out, ifname)) {
 219                         error << string_compose ("socket(out): could not find interface address for %1", ifname) << endmsg;
 220                         return false;
 221                 }
 222                 if (::setsockopt(sockout, IPPROTO_IP, IP_MULTICAST_IF, (char *) &if_addr_out, sizeof(if_addr_out))) {
 223                         ::perror("setsockopt(IP_MULTICAST_IF)");
 224                         return false;
 225                 }
 226         }
 227 #endif
 228
 229         ::memset(&addrout, 0, sizeof(struct sockaddr_in));
 230         addrout.sin_family = AF_INET;
 231         addrout.sin_addr.s_addr = ::inet_addr("225.0.0.37");
 232         addrout.sin_port = htons (base_port);
 233
 234         // Turn off loopback...
 235         int loop = 0;
 236
 237 #ifdef PLATFORM_WINDOWS
 238
 239         /* https://msdn.microsoft.com/en-us/library/windows/desktop/ms739161%28v=vs.85%29.aspx
 240          *
 241          * ------------------------------------------------------------------------------
 242          * Note The Winsock version of the IP_MULTICAST_LOOP option is
 243          * semantically different than the UNIX version of the
 244          * IP_MULTICAST_LOOP option:
 245          *
 246          * In Winsock, the IP_MULTICAST_LOOP option applies only to the receive path.
 247          * In the UNIX version, the IP_MULTICAST_LOOP option applies to the send path.
 248          *
 249          * For example, applications ON and OFF (which are easier to track than
 250          * X and Y) join the same group on the same interface; application ON
 251          * sets the IP_MULTICAST_LOOP option on, application OFF sets the
 252          * IP_MULTICAST_LOOP option off. If ON and OFF are Winsock
 253          * applications, OFF can send to ON, but ON cannot sent to OFF. In
 254          * contrast, if ON and OFF are UNIX applications, ON can send to OFF,
 255          * but OFF cannot send to ON.
 256          * ------------------------------------------------------------------------------
 257          *
 258          * Alles klar? Gut!
 259          */
 260
 261         const int target_sock = sockin;
 262 #else
 263         const int target_sock = sockout;
 264 #endif
 265
 266         if (::setsockopt (target_sock, IPPROTO_IP, IP_MULTICAST_LOOP, (char *) &loop, sizeof (loop)) < 0) {
 267                 ::perror("setsockopt(IP_MULTICAST_LOOP)");
 268                 return false;
 269         }
 270
 271 #ifndef PLATFORM_WINDOWS
 272
 273         if (fcntl (sockin, F_SETFL, O_NONBLOCK)) {
 274                 error << "cannot set non-blocking mode for IP MIDI input socket (" << ::strerror (errno) << ')' << endmsg;
 275                 return false;
 276         }
 277
 278         if (fcntl (sockout, F_SETFL, O_NONBLOCK)) {
 279                 error << "cannot set non-blocking mode for IP MIDI output socket (" << ::strerror (errno) << ')' << endmsg;
 280                 return false;
 281         }
 282
 283 #else
 284         // If imode !=0, non-blocking mode is enabled.
 285         u_long mode=1;
 286         if (ioctlsocket(sockin,FIONBIO,&mode)) {
 287                 error << "cannot set non-blocking mode for IP MIDI input socket (" << ::strerror (errno) << ')' << endmsg;
 288                 return false;
 289         }
 290         mode = 1; /* just in case it was modified in the previous call */
 291         if (ioctlsocket(sockout,FIONBIO,&mode)) {
 292                 error << "cannot set non-blocking mode for IP MIDI output socket (" << ::strerror (errno) << ')' << endmsg;
 293                 return false;
 294         }
 295 #endif
 296
 297         return true;
 298 }
 299
 300 int
 301 IPMIDIPort::write (const MIDI::byte* msg, size_t msglen, timestamp_t /* ignored */) {
 302
 303         if (sockout) {
 304                 Glib::Threads::Mutex::Lock lm (write_lock);
 305                 if (::sendto (sockout, (const char *) msg, msglen, 0, (struct sockaddr *) &addrout, sizeof(struct sockaddr_in)) < 0) {
 306                         ::perror("sendto");
 307                         return -1;
 308                 }
 309                 return msglen;
 310         }
 311         return 0;
 312 }
 313
 314 int
 315 IPMIDIPort::read (MIDI::byte* /*buf*/, size_t /*bufsize*/)
 316 {
 317         /* nothing to do here - all handled by parse() */
 318         return 0;
 319 }
 320
 321 void
 322 IPMIDIPort::parse (samplecnt_t timestamp)
 323 {
 324         /* input was detected on the socket, so go get it and hand it to the
 325          * parser. This will emit appropriate signals that will be handled
 326          * by anyone who cares.
 327          */
 328
 329         unsigned char buf[1024];
 330         struct sockaddr_in sender;
 331         socklen_t slen = sizeof(sender);
 332         int r = ::recvfrom (sockin, (char *) buf, sizeof(buf), 0, (struct sockaddr *) &sender, &slen);
 333
 334         if (r >= 0) {
 335
 336                 _parser->set_timestamp (timestamp);
 337
 338                 for (int i = 0; i < r; ++i) {
 339                         _parser->scanner (buf[i]);
 340                 }
 341         } else {
 342                 ::perror ("failed to recv from socket");
 343         }
 344 }