InetOSC.h

/* Open SoundControl kit in C++                                              */
/* Copyright (C) 2002-2004 libOSC++ contributors. See AUTHORS                */
/*                                                                           */
/* This library is free software; you can redistribute it and/or             */
/* modify it under the terms of the GNU Lesser General Public                */
/* License as published by the Free Software Foundation; either              */
/* version 2.1 of the License, or (at your option) any later version.        */
/*                                                                           */
/* This library is distributed in the hope that it will be useful,           */
/* but WITHOUT ANY WARRANTY; without even the implied warranty of            */
/* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU         */
/* Lesser General Public License for more details.                           */
/*                                                                           */
/* You should have received a copy of the GNU Lesser General Public          */
/* License along with this library; if not, write to the Free Software       */
/* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
/*                                                                           */
/* For questions regarding this program contact                              */
/* Daniel Holth <dholth@fastmail.fm> or visit                                */
/* http://wiretap.stetson.edu/                                               */

/*
 * This class was written by Martin Rumori (martin@rumori.de)
 */

#ifndef LIBOSC_INETOSC_H
#define LIBOSC_INETOSC_H

#ifdef    __CYGWIN__
#include <w32api/winsock2.h>
#include <w32api/ws2tcpip.h>
#include <poll.h>
#include <unistd.h>

#else  // __CYGWIN__
#include <stdlib.h>
#include <errno.h>
#include <string.h>
#include <unistd.h>
#include <netdb.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <sys/poll.h>
#include <netinet/in.h>
#endif // __CYGWIN__

#include <fcntl.h>

#include <iostream>
#include <string>

// defines

// The maximum datagram length for udp packets
#define OSC_DGRAM_MAXLENGTH 65536

// The maximum length for TCP OSC messages
#define OSC_STREAM_MAXLENGTH 65536

// The maximum number of pending TCP connections
#define OSC_STREAM_MAXCONN 12


class InetOSC
{

public:
  InetOSC ();

  virtual ~InetOSC ();

  typedef enum
    {
      OSC_IN_IPv4,
      OSC_IN_IPv6
    } InetOSCAddrType;

  typedef enum
    {
      OSC_IN_UDP,
      OSC_IN_TCP
    } InetOSCProto;

  typedef enum
    {
      OSC_IN_SUCCESS = 0x0000,
      OSC_IN_UNKNOWN = 0x0001,
      OSC_IN_NOT_IDLE = 0x0002,
      OSC_IN_WOULDBLOCK = 0x0003,
      OSC_IN_MAXCYCLES = 0x0004,
      OSC_IN_CLOSED_CONN = 0x0005,
      OSC_IN_PROTO_UNKNOWN = 0x0100,
      OSC_IN_ADDR_UNKNOWN = 0x0101,
      OSC_IN_NO_PROCESSOR = 0x0200,
      OSC_IN_NO_TRANSMGR = 0x0201,
      OSC_IN_NO_TCPMASTER = 0x0202,
      OSC_IN_ALREADY_SLAVE = 0x0203,
      OSC_IN_NOT_SLAVE =  0x0204,
      OSC_IN_GETHOST_ERRNO = 0xC000,
      OSC_IN_GETPROTO_ERRNO = 0xC001,
      OSC_IN_SOCKET_ERRNO = 0xC002,
      OSC_IN_SETSOCKOPT_ERRNO = 0xC003,
      OSC_IN_FCNTL_ERRNO = 0xC004,
      OSC_IN_BIND_ERRNO = 0xC005,
      OSC_IN_LISTEN_ERRNO = 0xC006,
      OSC_IN_CONNECT_ERRNO = 0xC007,
      OSC_IN_SHUTDOWN_ERRNO = 0xC008,
      OSC_IN_CLOSE_ERRNO = 0xC009,
      OSC_IN_RECV_ERRNO = 0xC00A,
      OSC_IN_SEND_ERRNO = 0xC00B,
      OSC_IN_POLL_ERRNO = 0xC00C,
      OSC_IN_ACCEPT_ERRNO = 0xC00D,
      OSC_IN_MALLOC_ERRNO = 0xC00E,
    } InetOSCError;

  const InetOSCError getError () const;

  const int getLastErrno () const;

  static const bool getErrorString (const InetOSCError err,
                                    std::string& errString);

  const InetOSCAddrType getAddrType (void) const;

  void setMaxHandleCycles (const int cycles = -1);

  const int getMaxHandleCycles (void) const;


protected :

  bool createSocket (int *const sd,
                     const InetOSCProto proto,
                     const InetOSCAddrType addrType);

  bool bindSocketToAny (int *const sd,
                        const short port,
                        const InetOSCAddrType addrType);

  bool closeSocket (int *const sd, const bool setError = true);

  bool allocSockAddr (const InetOSCAddrType addrType,
                      struct sockaddr * *const addr,
                      socklen_t *const addrlen);

  bool setRemoteAddr (const std::string& host,
                      const short port,
                      const InetOSCAddrType addrType,
                      struct sockaddr *const addr);

  bool setRemotePort (const short port,
                      const InetOSCAddrType addrType,
                      struct sockaddr *const addr);

  std::string getHostAddress (const InetOSCAddrType addrType,
                         const struct sockaddr *const addr);

  std::string getHostName (const InetOSCAddrType addrType,
                      const struct sockaddr *const addr);

  short getPortNumber (const InetOSCAddrType addrType,
                       const struct sockaddr *const addr);

  bool setSocketNonBlock (int *const sd);

  bool setSocketReuseAddr (int *const sd, bool reuse = true);


  /* protected members */

  InetOSCAddrType _addrType;

  InetOSCError _error;

  int _lasterrno;

  int _socket;

  int _maxHandleCycles;

};

#endif // #ifndef LIBOSC_INETOSC_H

---