Open Source Projects Europe

 *   Free Software Foundation, Inc.,

 *   Free Software Foundation, Inc.,

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

 */

 */

#include <sys/time.h>

#include <sys/time.h>

#include <map>

#include <map>

#include "refcntr.h"

#include "refcntr.h"

/// A set of classes to manage client-server communication over a

/// A set of classes to manage client-server communication over a

/// connection-oriented network, or a pipe.

/// connection-oriented network, or a pipe.

///

///

/// The listening/connection-accepting code currently only uses

/// The listening/connection-accepting code currently only uses

class Netcon {

class Netcon {

public:

public:

    enum Event {NETCONPOLL_READ = 0x1, NETCONPOLL_WRITE=0x2};

    enum Event {NETCONPOLL_READ = 0x1, NETCONPOLL_WRITE=0x2};

    Netcon() 

    Netcon() 

    : m_peer(0), m_fd(-1), m_ownfd(true), m_didtimo(0), m_wantedEvents(0),

    : m_peer(0), m_fd(-1), m_ownfd(true), m_didtimo(0), m_wantedEvents(0),

      m_loop(0)

    }

    virtual ~Netcon();

    virtual ~Netcon();

    /// Remember whom we're talking to. We let external code do this because 

    /// 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.

    /// the application may have a non-dns method to find the peer name.

    virtual void setpeer(const char *hostname);

    virtual void setpeer(const char *hostname);

    /// Retrieve the peer's hostname. Only works if it was set before !

    /// Retrieve the peer's hostname. Only works if it was set before !

    return m_peer ? (const char *)m_peer : "none";

    return m_peer ? (const char *)m_peer : "none";

    }

    }

    /// Set or reset the TCP_NODELAY option. 

    /// Set or reset the TCP_NODELAY option. 

    virtual int settcpnodelay(int on = 1); 

    virtual int settcpnodelay(int on = 1); 

    /// Did the last receive() call time out ? Resets the flag.

    /// Did the last receive() call time out ? Resets the flag.

    /// Return string version of last syscall error

    /// Return string version of last syscall error

    virtual char *sterror();

    virtual char *sterror();

    /// Return the socket descriptor

    /// Return the socket descriptor

    virtual int getfd() {

    /// Close the current connection if it is open

    /// Close the current connection if it is open

    virtual void closeconn();

    virtual void closeconn();

    /// Set/reset the non-blocking flag on the underlying fd. Returns

    /// Set/reset the non-blocking flag on the underlying fd. Returns

    /// prev state The default is that sockets are blocking except

    /// prev state The default is that sockets are blocking except

    /// when added to the selectloop, or, transparently, to handle

    /// when added to the selectloop, or, transparently, to handle

    /// connection timeout issues.

    /// connection timeout issues.

    virtual int set_nonblock(int onoff);

    virtual int set_nonblock(int onoff);

    /// Decide what events the connection will be looking for

    /// Decide what events the connection will be looking for

    /// (NETCONPOLL_READ, NETCONPOLL_WRITE)

    /// (NETCONPOLL_READ, NETCONPOLL_WRITE)

    /// Retrieve the connection's currently monitored set of events

    /// Retrieve the connection's currently monitored set of events

    /// Add events to current set

    /// Add events to current set

    /// Clear events from current set

    /// Clear events from current set

    friend class SelectLoop;

    friend class SelectLoop;

    SelectLoop *getloop() {

    /// Utility function for a simplified select() interface: check one fd

    /// Utility function for a simplified select() interface: check one fd

    /// for reading or writing, for a specified maximum number of seconds.

    /// for reading or writing, for a specified maximum number of seconds.

    static int select1(int fd, int secs, int writing = 0);

    static int select1(int fd, int secs, int writing = 0);

    short m_wantedEvents;

    short m_wantedEvents;

    SelectLoop *m_loop;

    SelectLoop *m_loop;

    // Method called by the selectloop when something can be done with a netcon

    // Method called by the selectloop when something can be done with a netcon

    virtual int cando(Netcon::Event reason) = 0;

    virtual int cando(Netcon::Event reason) = 0;

    // Called when added to loop

    // Called when added to loop

    virtual void setloop(SelectLoop *loop) {

};

};

/// The selectloop interface is used to implement parallel servers. 

/// The selectloop interface is used to implement parallel servers. 

// The select loop mechanism allows several netcons to be used for io

// The select loop mechanism allows several netcons to be used for io

class SelectLoop {

class SelectLoop {

public:

public:

    SelectLoop()

    SelectLoop()

    : m_selectloopDoReturn(false), m_selectloopReturnValue(0),

    : m_selectloopDoReturn(false), m_selectloopReturnValue(0),

      m_placetostart(0), 

      m_placetostart(0), 

      m_periodichandler(0), m_periodicparam(0), m_periodicmillis(0)

    }

    /// Loop waiting for events on the connections and call the

    /// Loop waiting for events on the connections and call the

    /// cando() method on the object when something happens (this will in 

    /// cando() method on the object when something happens (this will in 

    /// turn typically call the app callback set on the netcon). Possibly

    /// turn typically call the app callback set on the netcon). Possibly

    /// call the periodic handler (if set) at regular intervals.

    /// call the periodic handler (if set) at regular intervals.

    /// @return -1 for error. 0 if no descriptors left for i/o. 1 for periodic

    /// @return -1 for error. 0 if no descriptors left for i/o. 1 for periodic

    ///  timeout (should call back in after processing)

    ///  timeout (should call back in after processing)

    int doLoop();

    int doLoop();

    /// Call from data handler: make selectloop return the param value

    /// Call from data handler: make selectloop return the param value

    void loopReturn(int value) 

    m_selectloopDoReturn = true;

    m_selectloopDoReturn = true;

    m_selectloopReturnValue = value;

    m_selectloopReturnValue = value;

    }

    }

    /// Add a connection to be monitored (this will usually be called

    /// Add a connection to be monitored (this will usually be called

    /// from the server's listen connection's accept callback)

    /// from the server's listen connection's accept callback)

    bool m_selectloopDoReturn;

    bool m_selectloopDoReturn;

    int  m_selectloopReturnValue;

    int  m_selectloopReturnValue;

    int  m_placetostart;

    int  m_placetostart;

    // Map of NetconP indexed by fd

    // Map of NetconP indexed by fd

    map<int, NetconP> m_polldata;

    // The last time we did the periodic thing. Initialized by setperiodic()

    // The last time we did the periodic thing. Initialized by setperiodic()

    struct timeval m_lasthdlcall;

    struct timeval m_lasthdlcall;

    // The call back function and its parameter

    // The call back function and its parameter

    int (*m_periodichandler)(void *);

    int (*m_periodichandler)(void *);

};

};

/// Base class for connections that actually transfer data. T

/// Base class for connections that actually transfer data. T

class NetconData : public Netcon {

class NetconData : public Netcon {

public:

public:

    NetconData() : m_buf(0), m_bufbase(0), m_bufbytes(0), m_bufsize(0)

    }

    virtual ~NetconData();

    virtual ~NetconData();

    /// Write data to the connection.

    /// Write data to the connection.

    /// @param buf the data buffer

    /// @param buf the data buffer

    /// @param cnt the number of bytes we should try to send

    /// @param cnt the number of bytes we should try to send

    virtual int doreceive(char *buf, int cnt, int timeo = -1);

    virtual int doreceive(char *buf, int cnt, int timeo = -1);

    /// Check for data being available for reading

    /// Check for data being available for reading

    virtual int readready();

    virtual int readready();

    /// Check for data being available for writing

    /// Check for data being available for writing

    virtual int writeready();

    virtual int writeready();

    /// Read a line of text on an ascii connection

    virtual int getline(char *buf, int cnt, int timeo = -1);

    virtual int getline(char *buf, int cnt, int timeo = -1);

    /// Set handler to be called when the connection is placed in the

    /// Set handler to be called when the connection is placed in the

    /// selectloop and an event occurs.

    /// selectloop and an event occurs.

    virtual void setcallback(RefCntr<NetconWorker> user) {

private:

private:

    char *m_buf;    // Buffer. Only used when doing getline()s

    char *m_buf;    // Buffer. Only used when doing getline()s

    char *m_bufbase;    // Pointer to current 1st byte of useful data

    char *m_bufbase;    // Pointer to current 1st byte of useful data

    int m_bufbytes; // Bytes of data.

    int m_bufbytes; // Bytes of data.

};

};

/// Network endpoint, client side.

/// Network endpoint, client side.

class NetconCli : public NetconData {   

class NetconCli : public NetconData {   

public:

public:

    /// 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

    /// Open connection to specified host and numeric port. port is in

    int openconn(const char *host, unsigned int port, int timeo = -1);

    int openconn(const char *host, unsigned int port, int timeo = -1);

    /// Reuse existing fd. 

    /// Reuse existing fd. 

    /// We DONT take ownership of the fd, and do no closin' EVEN on an

    /// We DONT take ownership of the fd, and do no closin' EVEN on an

    /// explicit closeconn() or setconn() (use getfd(), close,

    /// explicit closeconn() or setconn() (use getfd(), close,

    /// setconn(-1) if you need to really close the fd and have no

    /// setconn(-1) if you need to really close the fd and have no

    /// other copy).

    /// other copy).

    int setconn(int fd);

    int setconn(int fd);

    /// Do not log message if openconn() fails.

    /// Do not log message if openconn() fails.

private:

private:

    int m_silentconnectfailure; // No logging of connection failures if set

    int m_silentconnectfailure; // No logging of connection failures if set

};

};

    okaddrs.len = okmasks.len = 0;

    okaddrs.len = okmasks.len = 0;

    okaddrs.intarray = okmasks.intarray = 0;

    okaddrs.intarray = okmasks.intarray = 0;

#endif /* NETCON_ACCESSCONTROL */

#endif /* NETCON_ACCESSCONTROL */

    }

    }

    ~NetconServLis();

    ~NetconServLis();

    int openservice(char *serv, int backlog = 10);

    /// Open service by port number.

    /// Open service by port number.

    int openservice(int port, int backlog = 10);

    int openservice(int port, int backlog = 10);

    /// Wait for incoming connection. Returned connected Netcon 

    /// Wait for incoming connection. Returned connected Netcon 

    NetconServCon *accept(int timeo = -1);

    NetconServCon *accept(int timeo = -1);

    /// This should be overriden in a derived class to handle incoming

    /// This should be overriden in a derived class to handle incoming

    /// connections. It will usually call NetconServLis::accept(), and

    /// connections. It will usually call NetconServLis::accept(), and

    /// insert the new connection in the selectloop.

    /// insert the new connection in the selectloop.

    virtual int cando(Netcon::Event reason);

    virtual int cando(Netcon::Event reason);

private:

private:

#ifdef NETCON_ACCESSCONTROL

#ifdef NETCON_ACCESSCONTROL

    int permsinit;

    int permsinit;

    struct intarrayparam okaddrs;

    struct intarrayparam okaddrs;

    struct intarrayparam okmasks;

    struct intarrayparam okmasks;

    int initperms(char *servicename);

    int initperms(int port);

    int initperms(int port);

    int checkperms(void *cli, int clilen);

    int checkperms(void *cli, int clilen);

#endif /* NETCON_ACCESSCONTROL */

#endif /* NETCON_ACCESSCONTROL */

};

};

/// Server-side accepted client connection. The only specific code

/// Server-side accepted client connection. The only specific code

/// allows closing the listening endpoint in the child process (in the

/// allows closing the listening endpoint in the child process (in the

/// case of a forking server)

/// case of a forking server)

class NetconServCon : public NetconData {   

class NetconServCon : public NetconData {   

public:

public:

    NetconServCon(int newfd, Netcon* lis = 0) 

    m_liscon = lis;

    m_liscon = lis;

    m_fd = newfd;

    m_fd = newfd;

    }

    }

    /// This is for forked servers that want to get rid of the main socket

    /// This is for forked servers that want to get rid of the main socket

    void closeLisCon() {

    void closeLisCon() {

    if (m_liscon)

        m_liscon->closeconn();

        m_liscon->closeconn();

    }

    }

private:

private:

    Netcon* m_liscon;

    Netcon* m_liscon;

};

};