tcpserver.cpp

Go to the documentation of this file.

// -*- mode: c++; indent-tabs-mode: nil; c-basic-offset: 4; coding: iso-8859-1; -*-

/*
ACT-CV - Machine Vision for Cognitive Modeling
Copyright (c) 2008 Marc Halbruegge

This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
*/


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

#ifndef _WINDOWS
// Linux dummy
#include "tcpserver.h"
ActCvServer* ActCvServer::singleInstance = nullptr;
struct ActCvServerAutoStop {
    ~ActCvServerAutoStop() {
        if (ActCvServer::singleInstance != nullptr) {
            delete ActCvServer::singleInstance;
            ActCvServer::singleInstance=nullptr;
        }
    }
} actCvServerAutoStop;

ActCvServer::ActCvServer() 
    : running(false) {}
ActCvServer::~ActCvServer() {}
void ActCvServer::SetupServerSocket(int portNum){}
SOCKET ActCvServer::WaitForIncoming() {return -1;}
void ActCvServer::WriteData(SOCKET handle) {}
void ActCvServer::SetData(const char *s) {};
void ActCvServer::ThreadFun(void*p) {}

#else
// Windows version
#include <winsock.h>
#include <process.h>
#include <windows.h>

#include <iostream>

#include "tcpserver.h"

using namespace std;

ActCvServer* ActCvServer::singleInstance = nullptr;

struct ActCvServerAutoStop {
    ~ActCvServerAutoStop() {
        if (ActCvServer::singleInstance != nullptr) {
            delete ActCvServer::singleInstance;
            ActCvServer::singleInstance=nullptr;
        }
    }
} actCvServerAutoStop;


ActCvServer::ActCvServer() 
    : running(false) {
    
    SetupServerSocket(ACTCVSERVER_PORTNUM);

    threadId = (HANDLE) _beginthread(ThreadFun,0,this);
}

ActCvServer::~ActCvServer() {
    TerminateThread(threadId,0);
    closesocket(fd);
}

void ActCvServer::SetupServerSocket(int portNum) {
    struct sockaddr_in srv; /* used by bind() */
    if((fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        perror("socket");
        return;
    }

    BOOL flag = 1;
    int result = setsockopt(fd,            /* socket affected */
                     IPPROTO_TCP,     /* set option at TCP level */
                     TCP_NODELAY,     /* name of option */
                     (char *) &flag,  /* the cast is historical
                                             cruft */
                     sizeof(flag));    /* length of option value */
    if (result < 0) {
        cerr << "error " << WSAGetLastError() << endl;
        perror("setsockopt");
        return;
    }

    srv.sin_family = AF_INET; /* use Internet addr family */
    srv.sin_port = htons(portNum); /* bind socket fd to port 8081*/
    
    /* bind: a client may connect to any of my addresses */
    srv.sin_addr.s_addr = htonl(INADDR_ANY);
    if(::bind(fd, (struct sockaddr*) &srv, sizeof(srv)) < 0) {
        perror("bind");
        return;
    }

    if(listen(fd, 5) < 0) {
        perror("listen");
        return;
    }
    printf ("Server wartet auf Verbindungen\n");

    running=true;
}

SOCKET ActCvServer::WaitForIncoming() {
    struct sockaddr_in client; /* used by accept() */
    int client_len = sizeof(client); /* used by accept() */
    SOCKET conn;
    conn = accept(fd, (struct sockaddr*) &client, &client_len);
    if(conn < 0) {
        throw ServerError("accept");
    }
    return conn;
}

void ActCvServer::WriteData(SOCKET handle) {
    mutex.Enter();

    if (&*data == nullptr) {
        int numBytes=0;
        if (send(handle, (const char*)&numBytes, sizeof(numBytes), 0) < 0) {
            mutex.Leave();
            throw ServerError("write");
        }

    } else {
        int numBytes=static_cast<int>(data->GetSize());
        if (send(handle, (const char*)&numBytes, sizeof(numBytes), 0) < 0) {
            mutex.Leave();
            throw ServerError("write");
        }

        if (send(handle, data->GetString(), numBytes, 0) < 0) {
            mutex.Leave();
            throw ServerError("write");
        }
    }

    mutex.Leave();
}

void ActCvServer::SetData(const char *s) {
    mutex.Enter();
    data = new GCString(s);
    mutex.Leave();
}

void ActCvServer::ThreadFun(void*p) {
    ActCvServer *_this = (ActCvServer*)p;
    
    while(true) { /* Der Server soll laufen bis er abgebrochen wird*/
        SOCKET newfd;
        try {
            newfd = _this->WaitForIncoming();
        } catch (const ServerError &e) {
            cerr << e.what() << endl;
            continue;
        }

        char c;
        int keyCode;

        for (;;) {
            try {
                if (recv(newfd, &c, 1, 0)<1) break;
                switch(c) {
                case 'X':
                    _this->WriteData(newfd);
                    break;
                case 'K':
                    if (recv(newfd, (char*)&keyCode, sizeof(int), 0)<1) break;
                    // 
                    _this->keyCodeQueue.push(keyCode);
                    break;
                default:
                    cerr << "server received unknown message" << endl;
                }
            } catch (const ServerError &e) {
                cerr << e.what() << endl;
                break;
            }
        }
        closesocket(newfd);
    }
    _endthread();
}


struct WSAAutoStart {
    WORD wVersionRequested;
    WSADATA wsaData;
    int err;
 
    WSAAutoStart() {
        wVersionRequested = MAKEWORD( 2, 2 );

        WSAStartup(wVersionRequested, &wsaData);
    }
    ~WSAAutoStart() {
        WSACleanup();
    }
} wsaAutoStart;

#endif // def _WINDOWS