source/viewer/NetworkViewer.cpp

Go to the documentation of this file.

/*
 *  NetworkViewer.cpp
 *
 * Copyright (c) 2007, 2008, 2009, University of Karlsruhe (for members see AUTHORS file)
 * Copyright (c) 2012, Karlsruhe Institute of Technology (for members see AUTHORS file)
 *
 * ISC License
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 *
 * Created by Julian Schill on 26.11.07.
 */

#include "../include/IPSA/ipsaclasses.h"
#include "../include/IPSA/network/TCPSocket.h"
#include "../include/IPSA/viewer/NetworkViewer.h"
#include "../include/IPSA/viewer/instructions/NVInstructions.h"

#include <Inventor/threads/SbThread.h>

#include <cstdio>
#include <iostream>
#include <sstream>
#include <vector>

NetworkViewer::NetworkViewer(std::string filename, SO_WINDOW parent/*=NULL*/, const char *name/*=NULL*/, SbBool embed/*=TRUE*/)
: IpsaViewer(filename, parent, name, embed),
networkThread(NULL),
LISTEN_PORT(12345)
{
                instructionMap.clear();
//              instructionMap = NVInstructions::CreateInstructionMap(this);

                commands.clear();

                // create server socket
                tcp_socket = new CTCPSocket("", LISTEN_PORT, true);

                networkReceiveSensor.setFunction(NetworkViewer::ReadDatagrams);
                networkReceiveSensor.setData(this);
                networkReceiveSensor.setInterval(0.0001);

                this->setTitle("IPSRV");

                this->setupNetworkThread();
}


NetworkViewer::~NetworkViewer()
{
                delete tcp_socket; // also closes the connection
                tcp_socket = NULL;
                SbThread::destroy(networkThread);
}


void NetworkViewer::ReadDatagrams(void* data, SoSensor*)
{
                std::vector< std::vector<std::string> > instructions; // instruction list
                NetworkViewer* networkViewer = (NetworkViewer*) data;
                if (NULL == networkViewer)
                                return;

                if (!networkViewer->tcp_socket->isConnected())
                                return;

                char recvbuf[4096];
                int ret = networkViewer->tcp_socket->receive(recvbuf, 4096 * sizeof(char));

                if (ret == SOCKET_ERROR)
                {
                                //perror("NetworkViewer::ReadDatagrams() -> tcp_socket->receive()");
                                return;
                }
                else if (ret == 0)
                {
                                //remote connection was closed
                                printf("IPSRV - Remote connection was closed, waiting for a new one.\n");
                                networkViewer->tcp_socket->closeSocket();
                                networkViewer->setupNetworkThread();
                                return;
                }
                else
                {
                                for (int i=0; i<ret; i++)
                                {
                                                if (recvbuf[i] != 0x0A)
                                                {
                                                                if (recvbuf[i] != 0x0D) // don't store CR
                                                                                networkViewer->commands += recvbuf[i];
                                                }
                                                else
                                                {
                                                                //parse instructions in (n->commands)and execute
                                                                //printf("Instructionstring: %s\n",n->commands.c_str());
                                                                std::string::size_type j = networkViewer->commands.find_first_not_of(";");
                                                                while ((j != networkViewer->commands.npos) && (j != networkViewer->commands.size() ) )
                                                                {
                                                                                std::string::size_type k = networkViewer->commands.find(";",j);
                                                                                if (k == networkViewer->commands.npos)
                                                                                                k = networkViewer->commands.size();
                                                                                // subcommand found, now parse as instruction code and parameters
                                                                                std::string cmd(networkViewer->commands.substr(j,k-j));
                                                                                std::vector<std::string> singleInstr;
                                                                                std::string::size_type l = cmd.find_first_not_of(" ");
                                                                                while ( (l != cmd.npos) && (l != cmd.size()) )
                                                                                {
                                                                                                std::string::size_type m = cmd.find(" ",l);
                                                                                                if (m == cmd.npos)
                                                                                                                m = cmd.size();
                                                                                                singleInstr.push_back(cmd.substr(l,m-l));
                                                                                                l = cmd.find_first_not_of(" ",m);
                                                                                }
                                                                                instructions.push_back(singleInstr);
                                                                                j = networkViewer->commands.find_first_not_of(";",k);
                                                                }
                                                                networkViewer->executeCommands(instructions);
                                                                networkViewer->commands.clear();
                                                }
                                }
                }
}


void NetworkViewer::setupNetworkThread()
{
                if (NULL != networkThread)
                                SbThread::destroy(networkThread);

                networkThread = SbThread::create(NetworkViewer::NetworkSetup, (void*)this);
}


void NetworkViewer::executeCommands(std::vector< std::vector<std::string> >& Instr)
{
                std::ostringstream answer;
                for(unsigned int i = 0; i < Instr.size(); i++)
                {
                                bool foundinstr = (instructionMap.end() != instructionMap.find(Instr[i][0]));
                                if(!foundinstr)
                                {
                                                printf("ERROR: instruction \"%s\" doesn't exist!\n", Instr[i][0].c_str());
                                                continue;
                                }

                                answer.str().clear();
                                unsigned int numberOfReturnValues;
                                instructionMap[ (Instr[i][0]) ]->findAndExecute(Instr[i], answer, numberOfReturnValues);

                                // always send at least '\n' to prevent hangs while
                                // reading from a socket on the client side
                                if (0 >= answer.str().length())
                                                answer << std::endl;
                                if (-1 == tcp_socket->send(answer.str()))
                                                printf("Error could not send via socket!\n");
                                else answer.str("");
                }
}


void* NetworkViewer::NetworkSetup(void* data)
{
                NetworkViewer* networkViewer = static_cast<NetworkViewer*> (data);
                if (NULL == networkViewer)
                                return NULL;

                if (networkViewer->tcp_socket->isConnected())
                                return NULL;

                printf("IPSRV - Inventor Physics Simulation Remote Viewer\n");
                printf("Establishing server at TCP/IP connection localhost:port %d.\n", networkViewer->tcp_socket->PORT);
                printf("Type <help> for instruction list.\n\n");

                networkViewer->networkReceiveSensor.unschedule();

                if (!networkViewer->tcp_socket->openSocket())
                {
                                printf("IPSRV - failed to establish a connection\n");
                                return NULL;
                }

    networkViewer->networkReceiveSensor.schedule();

    return NULL;
}

---