Line data    Source code

       1             : /************************************************************************
       2             :  ** This file is part of the network simulator Shawn.                  **
       3             :  ** Copyright (C) 2004-2007 by the SwarmNet (www.swarmnet.de) project  **
       4             :  ** Shawn is free software; you can redistribute it and/or modify it   **
       5             :  ** under the terms of the BSD License. Refer to the shawn-licence.txt **
       6             :  ** file in the root of the Shawn source tree for further details.     **
       7             :  ************************************************************************/
       8             : 
       9             : #pragma once
      10             : #include <config.h>
      11             : 
      12             : #ifdef SHAWN
      13             :      #include <shawn_config.h>
      14             :      #include "_apps_enable_cmake.h"
      15             :      #ifdef ENABLE_TCPIP
      16             :             #define BUILD_TCPIP
      17             :      #endif
      18             : #else
      19             :      #define BUILD_TCPIP
      20             : #endif
      21             : 
      22             : 
      23             : #ifdef BUILD_TCPIP
      24             : 
      25             : // Get Storage
      26             : #ifdef SHAWN
      27             :         #include <apps/tcpip/storage.h>
      28             : #else
      29             :         #include "storage.h"
      30             : #endif
      31             : 
      32             : #ifdef SHAWN
      33             :      namespace shawn
      34             :       { class SimulationController; }
      35             : 
      36             :      // Dummy function is called when Shawn Simulation starts. Does nothing up to now.
      37             :      extern "C" void init_tcpip( shawn::SimulationController& );
      38             : #endif
      39             : 
      40             : #include <string>
      41             : #include <map>
      42             : #include <vector>
      43             : #include <list>
      44             : #include <deque>
      45             : #include <iostream>
      46             : #include <cstddef>
      47             : 
      48             : 
      49             : struct sockaddr_in;
      50             : 
      51             : namespace tcpip
      52             : {
      53             : 
      54             :         class SocketException: public std::runtime_error
      55             :         {
      56             :         public:
      57        1369 :         SocketException(std::string what) : std::runtime_error(what.c_str()) {}
      58             :         };
      59             : 
      60             :         class Socket
      61             :         {
      62             :                 friend class Response;
      63             :         public:
      64             :                 /// Constructor that prepare to connect to host:port
      65             :                 Socket(std::string host, int port);
      66             : 
      67             :                 /// Constructor that prepare for accepting a connection on given port
      68             :                 Socket(int port);
      69             : 
      70             :                 /// Destructor
      71             :                 ~Socket();
      72             : 
      73             :                 /// @brief Returns an free port on the system
      74             :                 /// @note This is done by binding a socket with port=0, getting the assigned port, and closing the socket again
      75             :                 static int getFreeSocketPort();
      76             : 
      77             :                 /// Connects to host_:port_
      78             :                 void connect();
      79             : 
      80             :                 /// Wait for a incoming connection to port_
      81             :         Socket* accept(const bool create = false);
      82             : 
      83             :                 void send( const std::vector<unsigned char> &buffer);
      84             :                 void sendExact( const Storage & );
      85             :                 /// Receive up to \p bufSize available bytes from Socket::socket_
      86             :                 std::vector<unsigned char> receive( int bufSize = 2048 );
      87             :                 /// Receive a complete TraCI message from Socket::socket_
      88             :                 bool receiveExact( Storage &);
      89             :                 void close();
      90             :                 int port();
      91             :                 void set_blocking(bool);
      92             :                 bool is_blocking();
      93             :                 bool has_client_connection() const;
      94             : 
      95             :                 // If verbose, each send and received data is written to stderr
      96             :                 bool verbose() { return verbose_; }
      97             :                 void set_verbose(bool newVerbose) { verbose_ = newVerbose; }
      98             : 
      99             :         protected:
     100             :                 /// Length of the message length part of a TraCI message
     101             :                 static const int lengthLen;
     102             : 
     103             :                 /// Receive \p len bytes from Socket::socket_
     104             :                 void receiveComplete(unsigned char * const buffer, std::size_t len) const;
     105             :                 /// Receive up to \p len available bytes from Socket::socket_
     106             :                 size_t recvAndCheck(unsigned char * const buffer, std::size_t len) const;
     107             :                 /// Print \p label and \p buffer to stderr if Socket::verbose_ is set
     108             :                 void printBufferOnVerbose(const std::vector<unsigned char> buffer, const std::string &label) const;
     109             : 
     110             :         private:
     111             :                 void init();
     112             :                 static void BailOnSocketError(std::string context);
     113             : #ifdef WIN32
     114             :                 static std::string GetWinsockErrorString(int err);
     115             : #endif
     116             :                 bool atoaddr(std::string, struct sockaddr_in& addr);
     117             :                 bool datawaiting(int sock) const;
     118             : 
     119             :                 std::string host_;
     120             :                 int port_;
     121             :                 int socket_;
     122             :                 int server_socket_;
     123             :                 bool blocking_;
     124             : 
     125             :                 bool verbose_;
     126             : #ifdef WIN32
     127             :                 static bool init_windows_sockets_;
     128             :                 static bool windows_sockets_initialized_;
     129             :                 static int instance_count_;
     130             : #endif
     131             :         };
     132             : 
     133             : }       // namespace tcpip
     134             : 
     135             : #endif // BUILD_TCPIP