CScommServer.cpp

/* 
This file is part of the BIAS library (Basic ImageAlgorithmS).

Copyright (C) 2003-2009    (see file CONTACT for details)
Multimediale Systeme der Informationsverarbeitung
Institut fuer Informatik
Christian-Albrechts-Universitaet Kiel


BIAS 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.

BIAS 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 BIAS; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/

#ifdef WIN32
#  define _CRT_SECURE_NO_DEPRECATE // vs8
#  pragma warning (disable: 4251)  // STL MAP DLL warning noise (JW)
#endif

#include "CScommServer.hh"

#ifdef WIN32
#  include <winsock.h>
//#  include <winsock2.h>
#else //WIN32
#  include <sys/poll.h>
#  include <netinet/in.h>
#  include <sys/socket.h>
#  include <netdb.h>
#  include <unistd.h>
#  include <netinet/tcp.h>
#endif //WIN32

#include <Base/Debug/Error.hh>
#include <sys/types.h>
#include <errno.h>
#include <cstdio>
#include <cstdlib>
#include <cstring>

using namespace std;
using namespace BIAS;

CScommServer::CScommServer(bool threaded) : CScommBase(threaded)
{
  isServer_=true; 
  terminateListener_=false; 
  listenThreadActive_=false;
}


CScommServer::~CScommServer()
{
  if (listenThreadActive_) {
    terminateListener_=true;
    //  pthread_exit(pthreadListener_,NULL);
    listenThreadActive_=false; 
  }
}

void CScommServer::CreateListenThread_()
{
  if (listenThreadActive_) return;
  int res;
  BIASDOUT(D_CS_LISTENER,mygetpid() << ": Starting listener on port " << 
    connectPort_);
  terminateListener_ = false;
  res = pthread_create(&pthreadListener_, NULL, listenthread, this);
  if (res!=0) {
    BIASERR("cant crete listen thread");
  }
  listenThreadActive_=true;
}

void CScommServer::WaitForConnections(unsigned int port) {
  connectPort_= port;
  CreateListenThread_(); 
}

void *BIAS::listenthread(void *data)
{
  struct sockaddr_in client_addr;

#ifdef WIN32
  int clilen;
#else //WIN32
  socklen_t clilen;
#endif //WIN32

  int listenfd, newclientfd;
  int res;
  CScommServer *comm;

  comm = (CScommServer*)data;

  listenfd=(int)socket (AF_INET, SOCK_STREAM, 0);

  // int reuse_option = 1;
  //   res = setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, 
  //                    (char*) &reuse_option, sizeof(reuse_option));
  //   if (res<0) {
  //     BIASERR("Erorr:'"<<strerror(errno)<<"' while setting socket option:"
  //             <<comm->connectPort_);
  //     pthread_exit(NULL);
  //   }

  memset(&client_addr, 0, sizeof(client_addr));
  client_addr.sin_family = AF_INET;
  client_addr.sin_addr.s_addr = INADDR_ANY;

  //turn off Nagle-Algorithm for immediatly sending short msgs
  bool * flag = new bool(true);
  int length = sizeof(bool);
  setsockopt(listenfd, IPPROTO_TCP, TCP_NODELAY, (char *) flag, length);   

  int maxTries=1;
  if (comm->portChange_) 
    maxTries=10;
  int tries=0;
  res=-1;
  while ((res<0) && tries<maxTries) {    
    client_addr.sin_port = htons((u_short) comm->connectPort_);
    // Use ::bind to distinguish C socket bind from C++ std::bind
    res = ::bind(listenfd,(struct sockaddr *) &client_addr, 
      sizeof(client_addr));
    tries++;
    if (res<0) {
      cout<<"res<0"<<" Erorr:'"<<strerror(errno)<<endl;
      comm->connectPort_++;
    }
  }

  if ( (res<0) && (tries>maxTries) ) {    
    BIASERR("Erorr:'"<<strerror(errno)<<"' for ports:"
      <<D_CS_DEFAULT_PORT<<" to "<<comm->connectPort_);    
    pthread_exit(NULL);    
  }

  if (comm->verbose_)
    comm->verboseOut_<<mygetpid()
    <<": Listening on port "<<comm->connectPort_<<endl;

  while (!comm->terminateListener_) {
    // now listen
    res = listen(listenfd,1);
    if (res <0) {
      perror("Listening for clients");
#ifdef WIN32
      Sleep(1000);
#else //WIN32
      sleep(1);
#endif //WIN32
      break;
    }
    clilen = sizeof(client_addr);
    newclientfd = (int)accept(listenfd,(struct sockaddr *)&client_addr,&clilen);

    if ((comm->GetDebugLevel() & D_CS_LISTENER) >0) 
      cout << mygetpid() << ": Listener got something"<<endl;

    if (newclientfd < 0)
      perror("Error accepting connection from client");
    else {        
      res = comm->AcceptConn_(newclientfd);
      // all channels are busy, close and wait for a while
      if (res <0) {
#ifdef WIN32
        closesocket(newclientfd);
        Sleep(1000);
#else //WIN32
        close(newclientfd);
        sleep(1);
#endif //WIN32
      } 
      else
        if ((comm->GetDebugLevel() & D_CS_LISTENER) >0) 
          cout <<"Client accepted, relistening"<<endl;
    }
  }
  pthread_exit(NULL);

  return NULL;
}