src/utils/netcon.h

@@ -0,0 +1,262 @@
+#ifndef _NETCON_H_
+#define _NETCON_H_
+/* @(#$Id: netcon.h,v 1.11 2009-02-05 14:25:24 dockes Exp $  (C) 2002 Jean-Francois Dockes */
+#include "refcntr.h"
+
+/// A set of classes to manage client-server communication over a
+/// connection-oriented network, or a pipe.
+///
+/// Currently only uses TCP. The classes include client-side and
+/// server-side (accepting) endpoints, and server-side code to handle
+/// a set of client connections in parallel.
+/// 
+/// The client data transfer class can also be used for
+/// timeout-protected/asynchronous io using a given fd.
+
+/// Base class for all network endpoints:
+class Netcon;
+typedef RefCntr<Netcon> NetconP;
+
+class Netcon {
+public:
+    enum Event {NETCONPOLL_READ = 0x1, NETCONPOLL_WRITE=0x2};
+    Netcon() 
+	: m_peer(0), m_fd(-1), m_didtimo(0), m_wantedEvents(0)
+    {}
+    virtual ~Netcon();
+    /// Remember whom we're talking to. We let external code do this because 
+    /// the application may have a non-dns method to find the peer name.
+    virtual void setpeer(const char *hostname);
+    /// Retrieve the peer's hostname. Only works if it was set before !
+    virtual const char *getpeer() {
+	return m_peer ? (const char *)m_peer : "none";
+    }
+    /// Set or reset the TCP_NODELAY option. 
+    virtual int settcpnodelay(int on = 1); 
+    /// Did the last receive() call time out ? Resets the flag.
+    virtual int timedout() {int s = m_didtimo; m_didtimo = 0; return s;}
+    /// Return string version of last syscall error
+    virtual char *sterror();
+    /// Return the socket descriptor
+    virtual int getfd() {return m_fd;}
+    /// Close the current connection if it is open
+    virtual void closeconn();
+    /// Set/reset the non-blocking flag on the underlying fd. Returns
+    /// prev state The default is that sockets are blocking except
+    /// when added to the selectloop, or, transparently, to handle
+    /// connection timeout issues.
+    virtual int set_nonblock(int onoff);
+
+    /// Decide what events the connection will be looking for
+    /// (NETCONPOLL_READ, NETCONPOLL_WRITE)
+    int setselevents(int evs) {return m_wantedEvents = evs;}
+    /// Retrieve the connection's currently monitored set of events
+    int getselevents() {return m_wantedEvents;}
+    /// Add events to current set
+    int addselevents(int evs) {return m_wantedEvents |= evs;}
+    /// Clear events from current set
+    int clearselevents(int evs) {return m_wantedEvents &= ~evs;}
+
+    /// Utility function for a simplified select() interface: check one fd
+    /// for reading or writing, for a specified maximum number of seconds.
+    static int select1(int fd, int secs, int writing = 0);
+    
+    /// The selectloop interface is used to implement parallel servers. 
+    /// All the interface is static (independant of any given object).
+
+    /// Loop waiting for events on the connections and call the
+    /// cando() method on the object where something happens (this will in 
+    /// turn typically call the app callback set on the netcon). Possibly
+    /// call the periodic handler (if set) at regular intervals.
+    /// @return -1 for error. 0 if no descriptors left for i/o. 1 for periodic
+    ///  timeout (should call back in after processing)
+    static  int selectloop();
+    /// Call from data handler: make selectloop return the param value
+    static void selectloopReturn(int value) 
+    {
+	o_selectloopDoReturn = true;
+	o_selectloopReturnValue = value;
+    }
+    /// Add a connection to be monitored (this will usually be called
+    /// from the server's listen connection's accept callback)
+    static  int addselcon(NetconP con, int);
+    /// Remove a connection from the monitored set. Note that this is
+    /// automatically called from the Netcon destructor, and when EOF is
+    /// detected on a connection.
+    static  int remselcon(NetconP con);
+
+    /// Set a function to be called periodically, or a time before return.
+    /// @param handler the function to be called. 
+    ///  - if it is 0, selectloop() will return after ms mS (and can be called
+    ///    again
+    /// - if it is not 0, it will be called at ms mS intervals. If its return 
+    ///   value is <= 0, selectloop will return. 
+    /// @param clp client data to be passed to handler at every call.
+    /// @param ms  milliseconds interval between handler calls or before return.
+    ///   set ms to 0 for no periodic handler
+    static  void setperiodichandler(int (*handler)(void *), void *clp, int ms);
+
+protected:
+    static bool o_selectloopDoReturn;
+    static int  o_selectloopReturnValue;
+    char *m_peer;	// Name of the connected host
+    int  m_fd;
+    int m_didtimo;
+    // Used when part of the selectloop map.
+    short m_wantedEvents;
+    // Method called by the selectloop when something can be done with a netcon
+    virtual int cando(Netcon::Event reason) = 0;
+};
+
+
+///////////////////////
+class NetconData;
+
+/// Class for the application callback routine (when in
+/// selectloop). It would be nicer to override cando() in a subclass
+/// instead of setting a callback, but this can't be done conveniently
+/// because accept() always creates a base NetconData (another way
+/// would be to pass a factory function function to the listener, to create
+/// NetconData derivatives).
+class NetconWorker {
+public:
+    virtual ~NetconWorker() {}
+    // NetconP holds a NetconData oeuf corse
+    virtual int data(NetconData *con, Netcon::Event reason) = 0;
+};
+
+/// Base class for connections that actually transfer data.
+class NetconData : public Netcon {
+public:
+    NetconData() : m_buf(0), m_bufbase(0), m_bufbytes(0), m_bufsize(0)
+    {}
+    virtual ~NetconData();
+
+    /// Write data to the connection.
+    /// @param buf the data buffer
+    /// @param cnt the number of bytes we should try to send
+    /// @param expedited send data in as 'expedited' data.
+    /// @return the count of bytes actually transferred, -1 if an
+    ///  error occurred.
+    virtual int send(const char *buf, int cnt, int expedited = 0);
+
+    /// Read from the connection
+    /// @param buf the data buffer
+    /// @param cnt the number of bytes we should try to read
+    /// @param timeo maximum number of seconds we should be waiting for data.
+    /// @return the count of bytes actually read. 0 for timeout (call
+    ///        didtimo() to discriminate from EOF). -1 if an error occurred.
+    virtual int receive(char *buf, int cnt, int timeo = -1);
+    /// Loop on receive until cnt bytes are actually read or a timeout occurs
+    virtual int doreceive(char *buf, int cnt, int timeo = -1);
+    /// Check for data being available for reading
+    virtual int readready();
+    /// Check for data being available for writing
+    virtual int writeready();
+    /// Read a line of text on an ascii connection
+    virtual int getline(char *buf, int cnt, int timeo = -1);
+    /// Set handler to be called when the connection is placed in the
+    /// selectloop and an event occurs.
+    virtual void setcallback(RefCntr<NetconWorker> user) {m_user = user;}
+
+private:
+    char *m_buf;	// Buffer. Only used when doing getline()s
+    char *m_bufbase;    // Pointer to current 1st byte of useful data
+    int m_bufbytes;	// Bytes of data.
+    int m_bufsize;	// Total buffer size
+    RefCntr<NetconWorker> m_user;
+    virtual int cando(Netcon::Event reason);
+};
+
+/// Network endpoint, client side.
+class NetconCli : public NetconData {	
+public:
+    NetconCli(int silent = 0) {m_silentconnectfailure = silent;}
+    /// Open connection to specified host and named service. 
+    int openconn(const char *host, char *serv, int timeo = -1);
+    /// Open connection to specified host and numeric port. port is in
+    /// HOST byte order
+    int openconn(const char *host, unsigned int port, int timeo = -1);
+    /// Reuse existing fd. We DONT take ownership of the fd, and do no closin'
+    /// EVEN on an explicit closeconn() (use getfd(), close, setconn(-1)).
+    int setconn(int fd);
+    /// Do not log message if openconn() fails.
+    void setSilentFail(int onoff) {m_silentconnectfailure = onoff;}
+private:
+    int m_silentconnectfailure;	// No logging of connection failures if set
+};
+
+class NetconServCon;
+#ifdef NETCON_ACCESSCONTROL
+struct intarrayparam {
+    int len;
+    unsigned int *intarray;
+};
+#endif /* NETCON_ACCESSCONTROL */
+
+/// Server listening end point.
+///
+/// if NETCON_ACCESSCONTROL is defined during compilation,
+/// NetconServLis has primitive access control features: okaddrs holds
+/// the host addresses for the hosts which we allow to connect to
+/// us. okmasks holds the masks to be used for comparison.  okmasks
+/// can be shorter than okaddrs, in which case we use the last entry
+/// for all addrs beyond the masks array length. Both arrays are
+/// retrieved from the configuration file when we create the endpoint
+/// the key is either based on the service name (ex: cdpathdb_okaddrs,
+/// cdpathdb_okmasks), or "default" if the service name is not found
+/// (ex: default_okaddrs, default_okmasks)
+class NetconServLis : public Netcon {
+public:
+    NetconServLis() {
+#ifdef NETCON_ACCESSCONTROL
+	permsinit = 0;
+	okaddrs.len = okmasks.len = 0;
+	okaddrs.intarray = okmasks.intarray = 0;
+#endif /* NETCON_ACCESSCONTROL */
+    }
+    ~NetconServLis();
+    /// Open named service.
+    int openservice(char *serv, int backlog = 10);
+    /// Open service by port number.
+    int openservice(int port, int backlog = 10);
+    /// Wait for incoming connection. Returned connected Netcon 
+    NetconServCon *accept(int timeo = -1);
+
+protected:
+    /// This should be overriden in a derived class to handle incoming
+    /// connections. It will usually call NetconServLis::accept(), and
+    /// insert the new connection in the selectloop.
+    virtual int cando(Netcon::Event reason);
+
+private:
+#ifdef NETCON_ACCESSCONTROL
+    int permsinit;
+    struct intarrayparam okaddrs;
+    struct intarrayparam okmasks;
+    int initperms(char *servicename);
+    int initperms(int port);
+    int checkperms(void *cli, int clilen);
+#endif /* NETCON_ACCESSCONTROL */
+};
+
+/// Server-side accepted client connection. The only specific code
+/// allows closing the listening endpoint in the child process (in the
+/// case of a forking server)
+class NetconServCon : public NetconData {	
+public:
+    NetconServCon(int newfd, Netcon* lis = 0) 
+    { 
+	m_liscon = lis;
+	m_fd = newfd;
+    }
+    /// This is for forked servers that want to get rid of the main socket
+    void closeLisCon() {
+	if (m_liscon)
+	    m_liscon->closeconn();
+    }
+private:
+    Netcon* m_liscon;
+};
+
+#endif /* _NETCON_H_ */