WOscLib: WOscClient.cpp


/** The network return address. Through multiple inheritance this object
 * inherits the functionality required by WOscLib to keep it alive until
 * all messages ob a bundle are processed (reference counting) and the
 * networking data structure which contains the actual ip/port information.
 *
 */
class TheNetReturnAddress:
    public WOscNetReturn 
{
public:
    struct sockaddr_in  m_addr;
};

///////////////////////////////////////////////////////////////////////////////

class WOscClient;

/** All methods used in WOscClient are derived from this class. In a real
 * project the methods should be implemented in a header file to inline them
 * and eliminate the c++ overhead.
 *
 * This class avoids some pointer-casting but wouldn't be necessary but makes
 * all methods used type-save.
 */
class WOscClientMethod:
    public WOscReceiverMethod
{
public:
    WOscClientMethod(
        WOscContainer* parent,
        WOscClient* receiverContext,
        const char* methodName,
        const char* methodDescription);
    virtual void Method(
        const WOscMessage *message,
        const WOscTimeTag& when,
        const TheNetReturnAddress* networkReturnAddress) = 0;
    virtual WOscClient* GetContext();
protected:
    virtual void Method(
        const WOscMessage *message,
        const WOscTimeTag& when,
        const WOscNetReturn* networkReturnAddress);
};

///////////////////////////////////////////////////////////////////////////////

/** A simple method which prints "hello world" on the console. Furthermore
 * All parameters send with a "/hello" message are printed on the console.
 *
 */
class TheOscEchoMethod:
    public WOscClientMethod
{
public:
    TheOscEchoMethod(
        WOscContainer* parent,
        WOscClient* receiverContext);
    virtual void Method(
        const WOscMessage *message,
        const WOscTimeTag& when,
        const TheNetReturnAddress* networkReturnAddress);
};

///////////////////////////////////////////////////////////////////////////////

/** This is the central class which implements a full featured OSC server
 * including the network-layer implementation.
 *
 */
class WOscClient:
    public WOscReceiver
{
public:
    WOscClient();
    virtual ~WOscClient();
    /** Errors which can occur in the network layer. */
    enum WOscClientErrors
    {
        WOS_ERR_NO_ERROR         =  0, /**< No error.                        */
        WOS_ERR_SOCKET_CREATE    = -1, /**< Error when creating the socket.  */
        WOS_ERR_SOCKET_BIND      = -2, /**< Error when binding the local
                                        * address and port to the socket.    */
        WOS_ERR_SOCKET_REUSE     = -3, /**< Error when setting the socket-
                                        * reuse option.                      */
        WOS_ERR_SOCKET_BROADCAST = -4, /**< Error when setting the socket-
                                        * broadcast option.                  */
        WOS_ERR_SOCKET_BLOCK     = -5, /**< Error when setting the socket to
                                        * the non-blocking mode.             */
        WOS_ERR_SOCKET_WSASTART  = -6, /**< Error when starting the Windoze
                                        * winsock subsystem (Windows builds
                                        * only).                             */
    };
    WOscClientErrors NetworkInit(int port);
    WOscClientErrors NetworkHalt();
    WOscClientErrors CheckForPackets();
    bool Exit() const ;
    void SetExit() ;

    virtual void NetworkSend(
        const char* data,
        int dataLen,
        const WOscNetReturn* networkReturnAddress);
        
protected:
    virtual void HandleOffendingPackets(
        const char* const data,
        int dataLen,
        const WOscException& exception);
    virtual void HandleNonmatchedMessages(
        const WOscMessage* msg,
        const WOscNetReturn* networkReturnAddress);

private:
    /** The network address of the server when initialized.                  */
    TheNetReturnAddress     m_serverAddr;
    /** Databuffer for received data.                                        */
    char*                   m_rxbuffer;
    /** The socket handler of this OSC server.                               */
    int                     m_hSocket;
    /** Flag set when termination of the application or server is desired.   */
    bool                    m_exit;
};

#include "config.h"
///////////////////////////////////////////////////////////////////////////////
// OS dependent includes
///////////////////////////////////////////////////////////////////////////////
   
#if OS_IS_LINUX == 1 || OS_IS_MACOSX == 1 || OS_IS_CYGWIN == 1
#   include <unistd.h>      //  usleep
#   include <fcntl.h>
#   include <netinet/in.h>
#   include <arpa/inet.h>
#   include <sys/socket.h>
#elif OS_IS_WIN32 == 1
#   include "windows.h"
#   include "winsock2.h"
#   define socklen_t    int
#else
#   error "Invalid Platform"
#endif

///////////////////////////////////////////////////////////////////////////////
// general includes
///////////////////////////////////////////////////////////////////////////////

#include <iostream>
#include <stdlib.h>
#include <string.h>

#include "WOscReceiver.h"
#include "WOscNetReturn.h"
#include "WOscReceiverMethod.h"

#include "WOscClient.h"

///////////////////////////////////////////////////////////////////////////////
// defines
///////////////////////////////////////////////////////////////////////////////
   
#define OSC_SERVER_PORT         10000
#define PROTOCOL_UDP            17
#define WOS_MAX_RX_UDP_PACKET   2048

const char* WOSC_CLIENT_HELP_STR = 
        "\n"
        " WOscClient 1.00 help\n"
        "\n"
        " Invoking \"woscclient\":\n"
        " woscclient [local port] [remote port] [remote IP]\n"
        "\n"
        " Commands controlling \"woscclient\":\n"
        "\n"
        " exit           Terminate \"woscclient\".\n"
        " slp [port]     Set local UDP port to [port]\n"
        " srp [port]     Set remote server UDP destination port to [port].\n"
        " srip [ip]      Set remote server UDP destination IP to [ip].\n"
        "                  whereas [ip] is an IP string in dotted decimal notation\n"
        "                  (127.0.0.1).\n"
        "\n"
        " /[msg] [prms]  Send an OSC message \"/msg\" to remote OSC server with\n"
        "                  parameters [params]. [params] can be a space separated\n"
        "                  list containing integers ( 666 ), floats ( 3.14 ) and\n"
        "                  strings ( hello_world ).\n"
        "\n"
        " [              Start a bundle (currently no nesting). Messages can be\n"
        "                  added to the bundle afterwards as depicted above.\n"
        " ]              Close a bundle and transmit it.\n"
        "\n";

#if OS_IS_LINUX == 1 || OS_IS_MACOSX == 1 || OS_IS_CYGWIN == 1
socklen_t WOS_SIZE_NRA = sizeof(sockaddr_in);
#else
int WOS_SIZE_NRA = sizeof(sockaddr_in);
#endif

///////////////////////////////////////////////////////////////////////////////
// WOscClientMethod
///////////////////////////////////////////////////////////////////////////////

/** Constructor. Initializes WOscReceiverMethod base class. */
WOscClientMethod::WOscClientMethod(WOscContainer* parent,
        WOscClient* receiverContext, const char* methodName,
        const char* methodDescription) :
    WOscReceiverMethod(parent, (WOscReceiver*) receiverContext, methodName,
            methodDescription)
{
}

/** Type-save access to receiver object, which is owning this object. */
WOscClient* WOscClientMethod::GetContext()
{
    return (WOscClient*)WOscReceiverMethod::GetContext();
}

/** Type-save method interface. All methods inherited from this class get
 * the correct TheNetReturnAddress pointers without caring about the
 * system below.
 */
void WOscClientMethod::Method(const WOscMessage *message,
        const WOscTimeTag& when, const WOscNetReturn* networkReturnAddress)
{
    Method(message, when, (TheNetReturnAddress*) networkReturnAddress);
}

///////////////////////////////////////////////////////////////////////////////
// TheOscEchoMethod
///////////////////////////////////////////////////////////////////////////////

/** Constructor. Sets the method name and info in the base class. */
TheOscEchoMethod::TheOscEchoMethod(WOscContainer* parent,
        WOscClient* receiverContext) :
    WOscClientMethod(parent, receiverContext, "echo", "")
{
}

/** The echo method. Echoes the message back to its origin. The "origin" can be
 * modified by passing an integer and string parameter with the message. The
 * integer modifies the return port and the string the return IP.
 */
void TheOscEchoMethod::Method(const WOscMessage *message,
        const WOscTimeTag& when,
        const TheNetReturnAddress* networkReturnAddress)
{
    std::cout << "Echo received from:\n" 
        << "Port: " << ntohs(networkReturnAddress->m_addr.sin_port) << "\n"
        << "IP:   " << inet_ntoa( networkReturnAddress->m_addr.sin_addr ) <<std::endl;
}

///////////////////////////////////////////////////////////////////////////////
// WOscClient
///////////////////////////////////////////////////////////////////////////////

/** Constructor. Sets up the OSC address space, allocates an UDP receive buffer
 * and initializes the exit flag to "false".
 */
WOscClient::WOscClient()
{
    // setup OSC address space //

    // containers
    WOscContainerInfo infoRoot("root");
    WOscContainer* cntRoot = new WOscContainer(&infoRoot);
    WOscContainerInfo rootInfo("root");
    WOscContainerInfo infoTest("test");
    WOscContainer* cntTest = new WOscContainer(&infoTest, cntRoot, "test");
    
    // "root" methods
    WOscMethod* msgEcho = new TheOscEchoMethod(cntRoot, this);
    msgEcho->AddMethodAlias(cntTest, "echo");
    
    // add alias of method to same container where the original resides (to test the clean up)
    msgEcho->AddMethodAlias(cntTest, "echo2");

    // add alias of container to same container where the original resides (to test the clean up)
    cntTest->AddContainerAlias(cntRoot, "test2");

    SetAddressSpace(cntRoot);

    WOscString addressSpaceStr = cntRoot->GetAddressSpace();
    std::cout<<"Client address space:\n"<<addressSpaceStr.GetBuffer()<<std::flush;

    // allocate RX buffer
    m_rxbuffer = new char[WOS_MAX_RX_UDP_PACKET];

    m_exit = false;
}

/** Destructor. Removes the address space and deallocates the UDP receive
 * buffer.
 */
WOscClient::~WOscClient()
{
    // remove address space //
    WOscContainer* as = GetAddressSpace();
    if ( as ) as->RemoveAll();
}

/** Checks the exit flag.
 * \returns
 * True if application/serve exit is requested.
 */
bool WOscClient::Exit() const
{
    return m_exit;
}

/** Sets the exit flag, which is used to check for server termination.       */
void WOscClient::SetExit()
{
    m_exit = true;
}

/** Sends data over the network.
 * \param data
 * Pointer to buffer containing the data to be sent.
 *
 * \param dataLen
 * Number of bytes in the data buffer.
 *
 * \param networkReturnAddress
 * The destination network address.
 */
void WOscClient::NetworkSend(
    const char* data,
    int dataLen,
    const WOscNetReturn* networkReturnAddress)
{
    const TheNetReturnAddress* nra = (const TheNetReturnAddress*)networkReturnAddress;
    int actSend = sendto(
        m_hSocket,
        data,
        dataLen,
        0,
        (struct sockaddr*)&nra->m_addr,
        WOS_SIZE_NRA ) ;
    
    // check if transmission was successful
    if ( dataLen != actSend )
        std::cout << "Error sending packet."<<std::endl ;
}

/** Callback for OSC packets which have caused an exception in the OSC 
 * receiver.
 * \param data
 * Pointer to buffer containing the packet data.
 * \param dataLen
 * Length of the packet data in the buffer.
 * \exception
 * Exception that caused this handler to be called.
 */
void
WOscClient::HandleOffendingPackets(const char* const data, int dataLen,
        const WOscException& exception)
{
    std::cout<<"HandleOffendingPackets."<<std::endl;
}

/** Callback for messages not matching any address in the local OSC address
 * space.
 * \param msg
 * Message which hasn't been processed.
 * \param networkReturnAddress
 * Network origin of the message.
 */
void WOscClient::HandleNonmatchedMessages(
    const WOscMessage* msg,
    const WOscNetReturn* networkReturnAddress)
{
    int nStr = msg->GetNumStrings();
    int nInt = msg->GetNumInts();
    int nFlt = msg->GetNumFloats();

    if ( !nStr && !nInt && !nFlt )
        std::cout << "OSC message \"" << msg->GetOscAddress().GetBuffer()
            << "\" received."<< std::endl;
    else
        std::cout << "OSC message \"" << msg->GetOscAddress().GetBuffer()
            << "\" contains:"<<std::endl;

    for (int i = 0; i < nStr; i++ )
        std::cout << "  str["<<i<<"]\t" << 
            msg->GetString(i).GetBuffer()<< std::endl ;
    for (int i = 0; i < nInt; i++ )
        std::cout << "  int["<<i<<"]\t" << 
            msg->GetInt(i) << std::endl ;
    for (int i = 0; i < nFlt; i++ )
        std::cout << "  flt["<<i<<"]\t" << 
            msg->GetFloat(i) << std::endl ;
}

/** Initializes the underlying UDP network layer.
 * \param port
 * Port at which WOscClient should listen for OSC data.
 * \returns
 * Error code on error, WOS_ERR_NO_ERROR on success.
 */
WOscClient::WOscClientErrors WOscClient::NetworkInit(int port)
{
    int err;
    const int REUSE_TRUE = 1, BROADCAST_TRUE = 1;
    
#if OS_IS_WIN32 == 1
    // fucking windows winsock startup
    WSADATA wsa;
    err = WSAStartup(MAKEWORD(2,0),&wsa);
    if ( err != 0 ) {
        std::cout << "Error starting Windows socket subsystem."<<std::endl ;
        return WOS_ERR_SOCKET_WSASTART;
    }
#endif  // #if OS_IS_WIN32 == 1

    // create socket
    m_hSocket = socket (AF_INET, SOCK_DGRAM, PROTOCOL_UDP);
    if (m_hSocket < 0) {
        std::cout << "Create socket error."<<std::endl;
        return WOS_ERR_SOCKET_CREATE;
    }
    
    // initialize server address to localhost:port
    m_serverAddr.m_addr.sin_family         = AF_INET;
    m_serverAddr.m_addr.sin_addr.s_addr    = htonl (INADDR_ANY);
    m_serverAddr.m_addr.sin_port           = htons (port);
    
    // set socket to reuse the address
    err = setsockopt(
        m_hSocket,
        SOL_SOCKET,
        SO_REUSEADDR,
        (const char*)&REUSE_TRUE,
        sizeof(REUSE_TRUE));
    if ( err != 0 ) {
        std::cout << "Error setting socket reuse."<<std::endl ;
        return WOS_ERR_SOCKET_REUSE;
    }
    // enable broadcasting for this socket
    setsockopt(
        m_hSocket,
        SOL_SOCKET,
        SO_BROADCAST,
        (const char*)&BROADCAST_TRUE,
        sizeof(BROADCAST_TRUE));
    if ( err != 0 ) {
        std::cout << "Error setting socket broadcast."<<std::endl ;
        return WOS_ERR_SOCKET_BROADCAST;
    }
    
    // disable blocking, polling is used in this example.
#if OS_IS_LINUX == 1 || OS_IS_MACOSX == 1 || OS_IS_CYGWIN == 1
    err = fcntl(m_hSocket, F_SETFL, O_NONBLOCK);
#elif OS_IS_WIN32 == 1
    // disable blocking (for this example)
    unsigned long val = 1;
    err = ioctlsocket(m_hSocket, FIONBIO , &val);
#endif
    if ( err != 0 ) {
        std::cout << "Error setting socket unblock."<<std::endl ;
        return WOS_ERR_SOCKET_BLOCK;
    }
    
    // bind for listening
    err = bind (
        m_hSocket,
        (struct sockaddr *)&m_serverAddr.m_addr,
        WOS_SIZE_NRA );
    if ( err != 0 ) {
        std::cout << "Error socket bind."<<std::endl ;
        return WOS_ERR_SOCKET_BIND;
    }

    return WOS_ERR_NO_ERROR;
}

/** Stops the network interface.
 * \returns
 * WOS_ERR_NO_ERROR on success.
 */
WOscClient::WOscClientErrors WOscClient::NetworkHalt()
{
    // close socket... 
#if OS_IS_LINUX == 1 || OS_IS_MACOSX == 1 || OS_IS_CYGWIN == 1
    close(m_hSocket);
#elif OS_IS_WIN32 == 1
    closesocket(m_hSocket);
    WSACleanup();
#endif
    return WOS_ERR_NO_ERROR;
}

/** Check if there is an UDP packet. On packet arrival it will be passed 
 * to the OSC receiver. It returns if there are no more packets available.
 * \returns
 * WOS_ERR_NO_ERROR if no error occurred.
 */
WOscClient::WOscClientErrors WOscClient::CheckForPackets()
{
    // as long there are packets waiting
    bool morePackets = 1;
    while(morePackets)
    {
        // has to be allocated on heap, because is reference
        // counted
        TheNetReturnAddress* nra = new TheNetReturnAddress;
        nra->m_addr.sin_family         = AF_INET;
        nra->m_addr.sin_addr.s_addr    = htonl (INADDR_ANY);
        nra->m_addr.sin_port           = htons (0);
    
        // receive from network
        int nReceived = recvfrom(
            m_hSocket,
            m_rxbuffer,
            WOS_MAX_RX_UDP_PACKET,
            0,
            (struct sockaddr*)&nra->m_addr,
            (socklen_t*)&WOS_SIZE_NRA);
    
        // nReceived is the number of bytes actually read from 
        // network interface
        if (nReceived > 0) {
            NetworkReceive (m_rxbuffer, nReceived, nra);

            // test fast bundle parser
#if 1
            WOscBundleParser bundleParser;
            try {
                bundleParser.Parse(m_rxbuffer, nReceived);
                std::cout<<"Bundle time: "<<bundleParser.GetTimeTag().GetRawTimeTag()<<", bundle items: "<<bundleParser.GetItemCount()<<std::endl;
            } catch (const WOscException& exp) {
                std::cout<<"Error parsing raw bundle ("<<exp.GetErrStr()<<")."<<std::endl;
            }
#endif

        } else {
            delete nra;
            morePackets = false;    // stop receiving process
        }
    }
    return WOS_ERR_NO_ERROR;
}

///////////////////////////////////////////////////////////////////////////////
// main
///////////////////////////////////////////////////////////////////////////////

/** The program's main function of WOscClient.
 * Arguments:
 *  - 1. Local port at which the client listens.
 *  - 2. Remote port at which the remote server listens.
 *  - 3. Remote IP at which the remote server listens.
 *
 * When started, it accepts commandline input:
 *
 *  - "/message [params]" whereas "message" can be any OSC message as "/hello"
 *    and [params] can be some parameters (float, integer and string)
 *  - "exit" to exit WOscClient.
 *  - "slp port" to set local port to "port".
 */
int main(int argc, char *argv[])
{
    WOscClient client;
    int localport = OSC_SERVER_PORT + 1;
    int remoteport = OSC_SERVER_PORT;
    char remoteIP[32];
    
    strcpy(remoteIP, "127.0.0.1");

    // process arguments
    if ( argc > 1 )
        localport = atoi( argv[1] );
    if ( argc > 2 )
        remoteport = atoi( argv[2] );
    if ( argc > 3 )
        strcpy(remoteIP, argv[3]);
    
#if OS_IS_LINUX == 1 || OS_IS_MACOSX == 1 || OS_IS_CYGWIN == 1
    std::cout << "WOscClient 1.00 (UNIX/POSIX build)."<<std::endl ;
#elif OS_IS_WIN32 == 1
    std::cout << "WOscClient 1.00 (Windows build)."<<std::endl ;
#endif

    std::cout << "Setting up network layer:\n" <<
        "  local port:  " << localport << "\n" <<
        "  remote port: " << remoteport << "\n" <<
        "  remote IP:   " << remoteIP <<std::endl;

    if ( client.NetworkInit( localport ) != WOscClient::WOS_ERR_NO_ERROR ) {
        std::cout << "Exit."<<std::endl ;
        return -1;
    }
    
    std::cout << "Please enter some commands..."<<std::endl ;
    
    WOscBundle theBundle;
    bool bundleOpen = false;

    // run osc server as long the "exit" flag isn't set.
    while ( ! client.Exit() ) {
        char input[1024];
        std::cin.getline(input,1024,'\n');
        
        if ( input[0] == '/' ) {
            // message assembly
            try {
                // parse parameters
                char* params[100];
                int nParams = 0;
                char* next = strchr ( input, ' ' );
                while ( next != 0 || nParams >= 100 ) {
                    // add parameter to list 
                    params[nParams] = next + 1;
                    // and zero-terminate previous
                    *next = 0;
                    // try to find new parameter
                    next = strchr ( params[nParams++], ' ' );
                }
                
                // assemble message
                WOscMessage msg(input);
                // add parameters
                for ( int i = 0; i < nParams; i++ ) {
                    int parInt = atoi(params[i]);
                    float parFlt = atof(params[i]);
                    // check if float
                    if ( strchr ( params[i], '.' ) ) {
                        msg.Add( parFlt );
                    } else if ( parInt != 0 ) {
                        msg.Add( parInt );
                    } else {
                        msg.Add( params[i] );
                    }
                }
                // we pack message into bundle when open
                if ( bundleOpen ) {
                    theBundle.Add(new WOscMessage(msg));
                } else {
                    // set destination address
                    TheNetReturnAddress ra;
                    ra.m_addr.sin_family         = AF_INET;
                    ra.m_addr.sin_addr.s_addr    = inet_addr(remoteIP);
                    ra.m_addr.sin_port           = htons(remoteport);
                    client.NetworkSend(msg.GetBuffer(), msg.GetBufferLen(), &ra);
                }
            } catch(const WOscException& e ) {
                std::cout<<"Exception: " << e.GetErrStr() <<std::endl;
            }
        }
        // open bundle
        else if (input[0] == '[') {
            if ( bundleOpen ) {
                std::cout<<"Bundle already open."<<std::endl;
            } else {
                theBundle = WOscBundle();
                bundleOpen = true;
            }
        }
        // open bundle
        else if (input[0] == ']') {
            if ( bundleOpen ) {
                // set destination address
                TheNetReturnAddress ra;
                ra.m_addr.sin_family         = AF_INET;
                ra.m_addr.sin_addr.s_addr    = inet_addr(remoteIP);
                ra.m_addr.sin_port           = htons(remoteport);
                client.NetworkSend(theBundle.GetBuffer(), theBundle.GetBufferLen(), &ra);
                bundleOpen = false;
            } else {
                std::cout<<"No bundle to close."<<std::endl;
            }
        }
        // other commands
        else {
            // exit command
            if ( strcmp("exit",input) == 0 ) {
                break;
            }
            // help command
            else if ( strcmp("help",input) == 0 ) {
                std::cout << WOSC_CLIENT_HELP_STR ;
            }
            // set local port (slp)
            else if  ( strncmp("slp",input,3) == 0 ) {
                localport = atoi( &input[4] );
                std::cout << "  Trying to set local port to " << localport << "."<<std::endl ;
                client.NetworkHalt();
                if ( client.NetworkInit( localport ) != WOscClient::WOS_ERR_NO_ERROR ) {
                    std::cout << "Exit."<<std::endl ;
                    return -1;
                }
                std::cout << "  Port successfully changed and network restarted."<<std::endl ;
            }
            // set remote port (srp)
            else if  ( strncmp("srp",input,3) == 0 ) {
                remoteport = atoi( &input[4] );
                std::cout << "  Remote port set to " << remoteport << "."<<std::endl ;
            }
            // set remote IP (srip)
            else if  ( strncmp("srip",input,4) == 0 )
            {
                strcpy(remoteIP, &input[5]);
                std::cout << "  Remote IP set to " << remoteIP << "."<<std::endl ;
            }
        }
#if OS_IS_LINUX == 1 || OS_IS_MACOSX == 1 || OS_IS_CYGWIN == 1
        usleep(100000);
#elif OS_IS_WIN32 == 1
        Sleep(100);
#endif
        client.CheckForPackets();
    }

    // stop network layer
    client.NetworkHalt();
    
    std::cout << "Exiting. Bye." <<std::endl;
    return 0;
}