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         1433 :         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 datawaiting(int sock) const;
     117              : 
     118              :                 std::string host_;
     119              :                 int port_;
     120              :                 int socket_;
     121              :                 int server_socket_;
     122              :                 bool blocking_;
     123              : 
     124              :                 bool verbose_;
     125              : #ifdef WIN32
     126              :                 static bool init_windows_sockets_;
     127              :                 static bool windows_sockets_initialized_;
     128              :                 static int instance_count_;
     129              : #endif
     130              :         };
     131              : 
     132              : }       // namespace tcpip
     133              : 
     134              : #endif // BUILD_TCPIP