X-Git-Url: http://xvm.mit.edu/gitweb/invirt/third/libt4.git/blobdiff_plain/eeab3e6cade87c1fe0a5f3d93522e12ccb9ec2ab..3abd3952c1f4441f0dd6eae9883b2d01ed9cd56b:/rpc/connection.h

diff --git a/rpc/connection.h b/rpc/connection.h
index f529a35..3e19a93 100644
--- a/rpc/connection.h
+++ b/rpc/connection.h
@@ -1,39 +1,30 @@
 #ifndef connection_h
 #define connection_h
 
+#include "types.h"
 #include <sys/types.h>
-#include <sys/socket.h>
 #include <arpa/inet.h>
 #include <netinet/in.h>
-#include <cstddef>
-#include <thread>
-
-#include <map>
-#include <limits>
-
 #include "pollmgr.h"
+#include "file.h"
 
-constexpr size_t size_t_max = std::numeric_limits<size_t>::max();
+constexpr size_t size_t_max = numeric_limits<size_t>::max();
 
-class thread_exit_exception : std::exception {
-};
+class thread_exit_exception : exception {};
 
 class connection;
 
 class chanmgr {
     public:
-        virtual bool got_pdu(connection *c, char *b, size_t sz) = 0;
+        virtual bool got_pdu(connection *c, const string & b) = 0;
         virtual ~chanmgr() {}
 };
 
 class connection : public aio_callback {
     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
+            string buf;
+            size_t solong = 0; // number of bytes written or read so far
         };
 
         connection(chanmgr *m1, int f1, int lossytest=0);
@@ -43,55 +34,56 @@ class connection : public aio_callback {
         bool isdead();
         void closeconn();
 
-        bool send(char *b, size_t sz);
+        bool send(const string & b);
         void write_cb(int s);
         void read_cb(int s);
 
         void incref();
         void decref();
-        int ref();
+        int ref() { lock rl(ref_m_); return refno_; }
 
         int compare(connection *another);
+
     private:
 
         bool readpdu();
         bool writepdu();
 
         chanmgr *mgr_;
-        const int fd_;
-        bool dead_;
+        const file_t fd_;
+        bool dead_ = false;
 
         charbuf wpdu_;
         charbuf rpdu_;
 
-        std::chrono::time_point<std::chrono::steady_clock> create_time_;
+        time_point<steady_clock> create_time_;
 
-        int waiters_;
-        int refno_;
-        const int lossy_;
+        int waiters_ = 0;
+        int refno_ = 1;
+        int lossy_ = 0;
 
-        std::mutex m_;
-        std::mutex ref_m_;
-        std::condition_variable send_complete_;
-        std::condition_variable send_wait_;
+        mutex m_;
+        mutex ref_m_;
+        cond send_complete_;
+        cond send_wait_;
 };
 
 class tcpsconn {
     public:
-        tcpsconn(chanmgr *m1, unsigned int port, int lossytest=0);
+        tcpsconn(chanmgr *m1, in_port_t port, int lossytest=0);
         ~tcpsconn();
-        inline unsigned int port() { return port_; }
+        inline in_port_t port() { return port_; }
         void accept_conn();
     private:
-        unsigned int port_;
-        std::mutex m_;
-        std::thread th_;
-        int pipe_[2];
+        in_port_t port_;
+        mutex m_;
+        thread th_;
+        file_t pipe_[2];
 
-        int tcp_; //file desciptor for accepting connection
+        socket_t tcp_; // listens for connections
         chanmgr *mgr_;
         int lossy_;
-        std::map<int, connection *> conns_;
+        map<int, connection *> conns_;
 
         void process_accept();
 };