S3FC project page

S3FC home page

---

               

---

s3_txport_tcp.h

Go to the documentation of this file.

/*
 * Stone Three Foundation Class (s3fc) provides a number of utility classes.
 * Copyright (C) 2001 by Stone Three Signal Processing (Pty) Ltd.
 *
 * Authored by Stone Three Signal Processing (Pty) Ltd.
 *
 * This library 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.
 * 
 * This library 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 this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 * 
 * Please see the file 'COPYING' in the source root directory.
 */

#ifndef S3_TXPORT_TCP_H
#define S3_TXPORT_TCP_H

#include <map>
#include <string>
#include <s3fc/s3_macros.h>
#include <s3fc/s3_semaphore.h>
#include <s3fc/s3_thread_base.h>
#include <s3fc/s3_txport_base.h>
#include <s3fc/s3_streamable.h>
#include <s3fc/s3_growable_fifo_queue.h>
#include <s3fc/s3_socket_tcp.h>
#ifndef _WIN32
#include <s3fc/s3_socket_tcp_ssl.h>
#endif

template<typename T_Data, typename T_Socket> class s3_txport_tcp_tx_task;
template<typename T_Data, typename T_Socket> class s3_txport_tcp_rx_task;

template<class T_Data, class T_Socket=s3_socket_tcp>
class s3_txport_tcp : public s3_thread_base, public s3_txport_base<T_Data>
{
   unsigned int port;
   
   s3_fifo_queue<s3_txport_data<T_Data> > rx_queue;
   
   s3_fifo_queue<s3_txport_data<T_Data> > tx_queue;
   
   s3_txport_client_id connect_id;
   
   T_Socket sock;
   
   s3_growable_fifo_queue<s3_txport_client_id> dying_tasklets;
   
   typedef std::map<s3_txport_client_id,
          s3_txport_tcp_rx_task<T_Data, T_Socket>*>
   thread_map;
   
   thread_map connections;

   s3_txport_tcp_tx_task<T_Data, T_Socket> tx_thread;

   s3_mutex connection_mutex;

   s3_mutex reap_mutex;

   struct metadata_type
   {
      s3_txport_client_id id;
      std::string metadata;
      metadata_type(s3_txport_client_id a_id, const std::string& md) :
         id(a_id), metadata(md){};
      metadata_type(){};
   };

   s3_growable_fifo_queue<metadata_type> meta_queue;

   s3_semaphore terminate;

   unsigned int network_mask;

   unsigned int network_number;
 
  protected:
   void set_critical_by_id(s3_txport_client_id id);

   void clear_critical_by_id(s3_txport_client_id id);

   T_Socket* get_socket_by_id(s3_txport_client_id id);
   
   void cleanup();

   void reap();

   s3_txport_client_id next_id()
   {
      // Arbitrary limit on the number of connections
      if (connect_id > 10000000)
      {
    connect_id = 1;
      }
      else
      {
    connect_id++;
      }
      return connect_id;
   }
   s3_txport_client_id spawn_handler(T_Socket* active_socket,
                 std::string hostname);
   
   void set_terminate()
   {
      terminate.post();
   }

  public:
   s3_txport_tcp( int queue_size = 4, std::string network = "0.0.0.0",
        std::string mask = "0.0.0.0");
   
   ~s3_txport_tcp();

   s3_fifo_queue<s3_txport_data<T_Data> >& get_rx_queue()
   {
      return rx_queue;
   }

   s3_fifo_queue<s3_txport_data<T_Data> >& get_tx_queue()
   {
      return tx_queue;
   }

   void send_metadata(s3_txport_client_id id, const std::string& mdata);

   std::list<s3_txport_client_id> get_client_id_list() const;

   bool is_connected_by_id(s3_txport_client_id id);

   std::string get_ip_address_by_id(s3_txport_client_id id);
   
   bool listen(const unsigned int port);
  
   s3_txport_client_id connect(const std::string& IP_addr,
                const unsigned int port);

   bool disconnect_by_id(s3_txport_client_id id);

   void disconnect_all();

   void main_loop();

   int num_connections() const;

   T_Socket& get_socket()
   {
      return sock;
   }
   
   bool listening() const
   {
      return is_running();
   }

   void stop();

   void restart();

   // The rx and tx task threads are friends.
   friend class s3_txport_tcp_tx_task<T_Data, T_Socket>;
   friend class s3_txport_tcp_rx_task<T_Data, T_Socket>;
};

#include <s3fc/s3_txport_tcp.tcc>

#endif

---

Send comments to: s3fc@stonethree.com