socketTCP.h

Go to the documentation of this file.

// ----------------------------------------------------------------------------
//
// $Id$
//
// Copyright 2008, 2009, 2010, 2011, 2012  Antonio Franchi and Paolo Stegagno    
//
// This file is part of MIP.
//
// MIP 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 3 of the License, or
// (at your option) any later version.
//
// MIP 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 MIP. If not, see <http://www.gnu.org/licenses/>.
//
// Contact info: antonio.franchi@tuebingen.mpg.de stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



/* @{ */

#ifndef __SOCKET_TCP_
#define __SOCKET_TCP_

#ifdef MIP_HOST_APPLE
#include <applePatch.h>
#endif

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/signal.h>
#include <netinet/in.h>
#include <netdb.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include <iostream>
#include <sstream>

#include <Types.h>
#include <LogTrace.h>

using namespace std;

#define MAX_CODA 5
// #define TCP_MSG_SIZE 255
#define TCP_MSG_SIZE 15

class SocketTCP{
 
 protected:
 public:
  int  getInt(int &n);
  int  getDouble(Decimal &d);
  int  sendInt(int n);
  int  sendDouble(Decimal d);
  
  int  sendMessage(char * buf, int size);
  int  getMessage(char * buf, int size);
  int  waitMessage(char* msg);



  public:
  
    int m_port;
  int m_ds_sock_client;
    struct sockaddr_in my_addr;
  
  
    char m_buffer[TCP_MSG_SIZE+1];
  char *buffer;
  int bufsize;
  
    SocketTCP();
  
  void setBufSize(int a){
   if (buffer != NULL) delete buffer;
   bufsize = a;
   buffer = (char*) new char[bufsize+1];
  }
   
  void ack(){ sendMessage((char*)"ACK", TCP_MSG_SIZE);}
  void ok() { sendMessage((char*)"ok", TCP_MSG_SIZE);}
  void waitAck(){ waitMessage((char*)"ACK");}
  void waitOk() { waitMessage((char*)"ok");}
  
    int  checkMessagePresence(void);
    void closeConnection();
};


class ServerTCP : public SocketTCP{
 public:
   int m_port;
   int m_ds_sock;
   struct sockaddr_in m_server;

   ServerTCP(const int port);
   ServerTCP(const int port,const int endPort);
   
   void waitConnection();
   int  waitClient(char *msg);
   
   /*portare nella derivata*/
  bool send(string &msg, const int size);
};

class ClientTCP : public SocketTCP{
 public:
  int m_port;
  struct sockaddr_in m_client;
 
   ClientTCP(int &res, const int port, const char* server_addr);
    
  int receive(string *msg );
   
  int waitServer(char* msg);
};
 
 
class TCPClient : public MIPObject{
 private:
  int sockFileDescr, portNumber, n;
  struct sockaddr_in servAddr;
  struct hostent *server;
 
  static const int _packetSize = 1024;
  
  string getObjectName() const {
   return "TCPClient";
  }
 
 public:

  TCPClient(string ip,int port);
  
  int send(string& message);
  
  int receive(string& message);
  
  int checkMessagePresence(void);
};
 
 
#endif

/* @} */