Working on g++ compatibility

[invirt/third/libt4.git] / rpc / connection.h

diff --git a/rpc/connection.h b/rpc/connection.h
index 2a01e46..8f7d494 100644 (file)
--- a/rpc/connection.h
+++ b/rpc/connection.h
@@ -2,11 +2,10 @@
 #define connection_h
 
 #include "types.h"
 #define connection_h
 
 #include "types.h"

-#include <sys/types.h>

 #include <arpa/inet.h>
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>

-#include <cstddef>
-#include "pollmgr.h"
+#include "poll_mgr.h"
+#include "file.h"

 
 constexpr size_t size_t_max = numeric_limits<size_t>::max();
 
 
 constexpr size_t size_t_max = numeric_limits<size_t>::max();
 

@@ -14,88 +13,67 @@ class thread_exit_exception : exception {};
 
 class connection;
 
 
 class connection;
 

-class chanmgr {
+class connection_delegate {

     public:
     public:

-        virtual bool got_pdu(connection *c, char *b, size_t sz) = 0;
-        virtual ~chanmgr() {}
+        virtual bool got_pdu(const shared_ptr<connection> & c, const string & b) = 0;
+        virtual ~connection_delegate() {}

 };
 
 };
 

-class connection : public aio_callback {
+class connection : private aio_callback, public enable_shared_from_this<connection> {

     public:
     public:

-        struct charbuf {
-            charbuf(): buf(NULL), sz(0), solong(0) {}
-            charbuf (char *b, size_t s) : buf(b), sz(s), solong(0){}
-            char *buf;
-            size_t sz;
-            size_t solong; // number of bytes written or read so far
-        };
-
-        connection(chanmgr *m1, int f1, int lossytest=0);
+        connection(connection_delegate * delegate, socket_t && f1, int lossytest=0);

         ~connection();
 
         ~connection();
 

-        int channo() { return fd_; }
-        bool isdead();
-        void closeconn();
+        bool isdead() { return dead_; }

 
 

-        bool send(char *b, size_t sz);
-        void write_cb(int s);
-        void read_cb(int s);
+        bool send(const string & b);

 
 

-        void incref();
-        void decref();
-        int ref() { lock rl(ref_m_); return refno_; }
+        static shared_ptr<connection> to_dst(const sockaddr_in &dst, connection_delegate *mgr, int lossy=0);
+
+        const time_point<steady_clock> create_time = steady_clock::now();
+        const file_t fd;

 
 

-        int compare(connection *another);

     private:
     private:

+        void write_cb(int s);
+        void read_cb(int s);

 
         bool readpdu();
         bool writepdu();
 
 
         bool readpdu();
         bool writepdu();
 

-        chanmgr *mgr_;
-        const int fd_;
+        connection_delegate * delegate_;

         bool dead_ = false;
 
         bool dead_ = false;
 

+        struct charbuf {
+            string buf;
+            size_t solong = 0; // number of bytes written or read so far
+        };
+

         charbuf wpdu_;
         charbuf rpdu_;
 
         charbuf wpdu_;
         charbuf rpdu_;
 

-        time_point<steady_clock> create_time_;
-

         int waiters_ = 0;
         int waiters_ = 0;

-        int refno_ = 1;
-        const int lossy_;
+        int lossy_ = 0;

 
         mutex m_;
 
         mutex m_;

-        mutex ref_m_;

         cond send_complete_;
         cond send_wait_;
 };
 
         cond send_complete_;
         cond send_wait_;
 };
 

-class tcpsconn {
+class connection_listener : private aio_callback {

     public:
     public:

-        tcpsconn(chanmgr *m1, unsigned int port, int lossytest=0);
-        ~tcpsconn();
-        inline unsigned int port() { return port_; }
-        void accept_conn();
+        connection_listener(connection_delegate * delegate, in_port_t port, int lossytest=0);
+        ~connection_listener();
+        inline in_port_t port() { return port_; }

     private:
     private:

-        unsigned int port_;
+        void write_cb(int) {}
+        void read_cb(int s);
+
+        in_port_t port_;

         mutex m_;
         mutex m_;

-        thread th_;
-        int pipe_[2];

 
 

-        int tcp_; //file desciptor for accepting connection
-        chanmgr *mgr_;
+        socket_t tcp_; // listens for connections
+        connection_delegate * delegate_;

         int lossy_;
         int lossy_;

-        map<int, connection *> conns_;
-
-        void process_accept();
-};
-
-struct bundle {
-    bundle(chanmgr *m, int s, int l):mgr(m),tcp(s),lossy(l) {}
-    chanmgr *mgr;
-    int tcp;
-    int lossy;
+        map<int, shared_ptr<connection>> conns_;

 };
 };

-
-connection *connect_to_dst(const sockaddr_in &dst, chanmgr *mgr, int lossy=0);

 #endif
 #endif