socketUDP.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: franchi@diag.uniroma1.it stegagno@diag.uniroma1.it
//
// ----------------------------------------------------------------------------



/* @{ */

#ifndef __SOCKET_UDP_
#define __SOCKET_UDP_

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

#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <errno.h>
#include <string.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <netdb.h>

typedef unsigned char BYTE;

#include <net/if.h>
#include <sys/ioctl.h>

#ifndef SIOCGIFCONF
#include <linux/sockios.h>
#endif

#include <iostream>
#include <sstream>

#include <Types.h>
#include <LinuxShMem.h>
    

using namespace std;
 

// \todo FIXME da  calcolare con precisione*/
#define UDP_MSG_SIZE 40000
// #define MAX_LOCAL_AGENTS_NUMBER 10

     
class SocketUDP : public MIPObject{
 protected:
 
  stringstream _ssdebug;
  
  public:
  int m_sockfd; 
  struct sockaddr_in my_addr;    
  struct sockaddr_in their_addr; 
  struct hostent *he; 
  
  SocketUDP();
  
  ~SocketUDP();
  
  void closeConnection();
  
  virtual string getObjectName() const {
   return string("SocketUDP");
  }
};

class ParamsToWrapper{
 public:
  int local_port;
  int broadcast_port;
  char subnet_address[64];
};

class Wrapper: public SocketUDP{
 private:
  pthread_t wrapper_thread_id;
  
  int lastListNum;
  
  LinuxShMem shMem;
  
 public:
  int broadcast_port; 
  int local_port;     
  const char *subnet; 
  int numero_ip;      
  bool active;       
  
  Wrapper(int bp, int lp, const char*net);
  
  ~Wrapper(void);
  
  int findIP(const char *net);
  
  int Init(void);
  
  void run(void);
  
  void start(void);
  
  void stop(void);
  
  string getObjectName() const {
   return string("Wrapper");
  }
};

class ListenerUDP: public SocketUDP{
 private:
  ParamsToWrapper params;
  Wrapper *wrapper;
  
  LinuxShMem shMem;
 public:
  ListenerUDP(const int port);
  
  ListenerUDP(const int port, string& my_host);
  
  ListenerUDP(const int bp, const int lp, string& net_addr);
  
   ~ListenerUDP();
  
  int receive(string &buffe, string &senderAddr);
  
  void receive(char* buf, string &senderAddr, int numbytes);
  
  int receive(string &buffe);
  
  int lSelect();
  
  string getObjectName() const {
   return string("ListenerUDP");
  }
};

class  SenderUDP: public SocketUDP{

  public:
  
  SenderUDP(const int port, string& host);
  
  ~SenderUDP();
  
  int send(string &msg);
  
  int send(char * msg, int lsize);
 
  virtual string getObjectName() const {return string("SenderUDP");}
};

class BroadcasterUDP: public SenderUDP{
  public:
    int m_broadcast;
  
   BroadcasterUDP(const int port,string& host);

  ~BroadcasterUDP();
  
  virtual string getObjectName() const {return string("BroadcasterUDP");}
};

#endif


/* @} */