Open Source Projects Europe

#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_ */