#ifndef connection_h
#define connection_h
-#include <sys/types.h>
-#include <sys/socket.h>
+#include "types.h"
#include <arpa/inet.h>
#include <netinet/in.h>
-#include <cstddef>
-#include <thread>
+#include "poll_mgr.h"
+#include "file.h"
-#include <map>
+constexpr size_t size_t_max = numeric_limits<size_t>::max();
-#include "pollmgr.h"
-
-class thread_exit_exception : std::exception {
-};
+class thread_exit_exception : exception {};
class connection;
-class chanmgr {
+class connection_delegate {
public:
- virtual bool got_pdu(connection *c, char *b, int 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 : public aio_callback, public enable_shared_from_this<connection> {
public:
struct charbuf {
- charbuf(): buf(NULL), sz(0), solong(0) {}
- charbuf (char *b, int s) : buf(b), sz(s), solong(0){}
- char *buf;
- int sz;
- int solong; //amount 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);
+ connection(connection_delegate *m1, socket_t && f1, int lossytest=0);
~connection();
int channo() { return fd_; }
- bool isdead();
+ bool isdead() { lock ml(m_); return dead_; }
void closeconn();
- bool send(char *b, int sz);
+ bool send(const string & b);
void write_cb(int s);
void read_cb(int s);
- void incref();
- void decref();
- int ref();
+ time_point<steady_clock> create_time() const { return create_time_; }
+
+ static shared_ptr<connection> to_dst(const sockaddr_in &dst, connection_delegate *mgr, int lossy=0);
- int compare(connection *another);
private:
bool readpdu();
bool writepdu();
- chanmgr *mgr_;
- const int fd_;
- bool dead_;
+ connection_delegate *mgr_;
+ const file_t fd_;
+ bool dead_ = false;
charbuf wpdu_;
charbuf rpdu_;
- struct timeval create_time_;
+ time_point<steady_clock> create_time_;
- int waiters_;
- int refno_;
- const int lossy_;
+ int waiters_ = 0;
+ int lossy_ = 0;
- std::mutex m_;
- std::mutex ref_m_;
- std::condition_variable send_complete_;
- std::condition_variable send_wait_;
+ mutex m_;
+ cond send_complete_;
+ cond send_wait_;
};
class tcpsconn {
public:
- tcpsconn(chanmgr *m1, int port, int lossytest=0);
+ tcpsconn(connection_delegate *m1, in_port_t port, int lossytest=0);
~tcpsconn();
- inline int port() { return port_; }
+ inline in_port_t port() { return port_; }
void accept_conn();
private:
- 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
- chanmgr *mgr_;
+ socket_t tcp_; // listens for connections
+ connection_delegate *mgr_;
int lossy_;
- std::map<int, connection *> conns_;
+ map<int, shared_ptr<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;
-};
-
-connection *connect_to_dst(const sockaddr_in &dst, chanmgr *mgr, int lossy=0);
#endif