recoll / Code / Diff of /src/utils/netcon.cpp

Diff of /src/utils/netcon.cpp [7876fb] .. [efa588]

Switch to unified view


/* Copyright (C) 2002 J.F. Dockes
 *   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 *
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 *
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the
 *   Free Software Foundation, Inc.,
 *   59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 */

// Wrapper classes for the socket interface


#ifndef TEST_NETCON
...
#endif // _AIX

#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>

#include <sys/socket.h>
#include <sys/un.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>

#include <map>


#ifdef RECOLL_DATADIR
#include "debuglog.h"

#else

#define LOGFATAL(X)
#define LOGERR(X)
#define LOGINFO(X)
#define LOGDEB(X)
#define LOGDEB0(X)
#define LOGDEB1(X)
#define LOGDEB2(X)
#define LOGDEB3(X)
#define LOGDEB4(X)
#endif

#include "netcon.h"

using namespace std;





#ifndef SOCKLEN_T
#define SOCKLEN_T socklen_t
#endif

// Size of path buffer in sockaddr_un (AF_UNIX socket
// addr). Mysteriously it's 108 (explicit value) under linux, no
// define accessible. Let's take a little margin as it appears that
// some systems use 92. I believe we could also malloc a variable size
// struct but why bother.
#ifndef UNIX_PATH_MAX
#define UNIX_PATH_MAX 90
#endif

// Need &one, &zero for setsockopt...
static const int one = 1;
static const int zero = 0;
...
    tv.tv_sec = timeo;
    tv.tv_usec =  0;
    FD_ZERO(&rd);
    FD_SET(fd, &rd);
    if (write) {
        ret = select(fd+1, 0, &rd, 0, &tv);
    } else {
        ret = select(fd+1, &rd, 0, 0, &tv);
    }
    if (!FD_ISSET(fd, &rd)) {
        LOGERR(("Netcon::select1: fd not ready after select ??\n"));
        return -1;
    }
    return ret;
}

void SelectLoop::setperiodichandler(int (*handler)(void *), void *p, int ms)
{
    m_periodichandler = handler;
    m_periodicparam = p;
    m_periodicmillis = ms;
    if (m_periodicmillis > 0) {
        gettimeofday(&m_lasthdlcall, 0);
    }
}

// Compute the appropriate timeout so that the select call returns in
// time to call the periodic routine.
void SelectLoop::periodictimeout(struct timeval *tv)
{
    // If periodic not set, the select call times out and we loop
    // after a very long time (we'd need to pass NULL to select for an
    // infinite wait, and I'm too lazy to handle it)
    if (m_periodicmillis <= 0) {
        tv->tv_sec = 10000;
        tv->tv_usec = 0;
        return;
    }

    struct timeval mtv;
    gettimeofday(&mtv, 0);
    int millis = m_periodicmillis - MILLIS(m_lasthdlcall, mtv);

    // millis <= 0 means we should have already done the thing. *dont* set the
    // tv to 0, which means no timeout at all !
    if (millis <= 0) {
        millis = 1;
    }
    tv->tv_sec = millis / 1000;
    tv->tv_usec = (millis % 1000) * 1000;
}

// Check if it's time to call the handler. selectloop will return to
// caller if it or we return 0
int SelectLoop::maybecallperiodic()
{
    if (m_periodicmillis <= 0) {
        return 1;
    }
    struct timeval mtv;
    gettimeofday(&mtv, 0);
    int millis = m_periodicmillis - MILLIS(m_lasthdlcall, mtv);
    if (millis <= 0) {
        gettimeofday(&m_lasthdlcall, 0);
        if (m_periodichandler) {
            return m_periodichandler(m_periodicparam);
        } else {
            return 0;
        }
    }
    return 1;
}

int SelectLoop::doLoop()
{
    for (;;) {
        if (m_selectloopDoReturn) {
            m_selectloopDoReturn = false;
            LOGDEB(("Netcon::selectloop: returning on request\n"));
            return m_selectloopReturnValue;
        }
        int nfds;
        fd_set rd, wd;
        FD_ZERO(&rd);
        FD_ZERO(&wd);

        // Walk the netcon map and set up the read and write fd_sets
        // for select()
        nfds = 0;
        for (map<int,NetconP>::iterator it = m_polldata.begin();
                it != m_polldata.end(); it++) {
            NetconP &pll = it->second;
            int fd  = it->first;
            LOGDEB2(("Selectloop: fd %d flags 0x%x\n",fd, pll->m_wantedEvents));
            if (pll->m_wantedEvents & Netcon::NETCONPOLL_READ) {
                FD_SET(fd, &rd);
                nfds = MAX(nfds, fd + 1);
            }
            if (pll->m_wantedEvents & Netcon::NETCONPOLL_WRITE) {
                FD_SET(fd, &wd);
                nfds = MAX(nfds, fd + 1);
            }
        }

        if (nfds == 0) {
            // This should never happen in a server as we should at least
            // always monitor the main listening server socket. For a
            // client, it's up to client code to avoid or process this
            // condition.

            // Just in case there would still be open fds in there
            // (with no r/w flags set). Should not be needed, but safer
            m_polldata.clear();
            LOGDEB1(("Netcon::selectloop: no fds\n"));
            return 0;
        }

        LOGDEB2(("Netcon::selectloop: selecting, nfds = %d\n", nfds));

        // Compute the next timeout according to what might need to be
        // done apart from waiting for data
        struct timeval tv;
        periodictimeout(&tv);
        // Wait for something to happen
        int ret = select(nfds, &rd, &wd, 0, &tv);
        LOGDEB2(("Netcon::selectloop: select returns %d\n", ret));
        if (ret < 0) {
            LOGSYSERR("Netcon::selectloop", "select", "");
            return -1;
        }
        if (m_periodicmillis > 0)
            if (maybecallperiodic() <= 0) {
                return 1;
            }

        // Timeout, do it again.
        if (ret == 0) {
            continue;
        }

        // We don't start the fd sweep at 0, else some fds would be advantaged.
        // Note that we do an fd sweep, not a map sweep. This is
        // inefficient because the fd array may be very sparse. Otoh, the
        // map may change between 2 sweeps, so that we'd have to be smart
        // with the iterator. As the cost per unused fd is low (just 2 bit
        // flag tests), we keep it like this for now
        if (m_placetostart >= nfds) {
            m_placetostart = 0;
        }
        int i, fd;
        for (i = 0, fd = m_placetostart; i < nfds; i++, fd++) {
            if (fd >= nfds) {
                fd = 0;
            }

            int canread = FD_ISSET(fd, &rd);
            int canwrite = FD_ISSET(fd, &wd);
            bool none = !canread && !canwrite;
            LOGDEB2(("Netcon::selectloop: fd %d %s %s %s\n", fd,
                     none ? "blocked" : "can" , canread ? "read" : "",
                     canwrite ? "write" : ""));
            if (none) {
                continue;
            }

            map<int,NetconP>::iterator it = m_polldata.find(fd);
            if (it == m_polldata.end()) {
                /// This should not happen actually
                LOGDEB2(("Netcon::selectloop: fd %d not found\n", fd));
                continue;
            }

            // Next start will be one beyond last serviced (modulo nfds)
            m_placetostart = fd + 1;
            NetconP &pll = it->second;
            if (canread && pll->cando(Netcon::NETCONPOLL_READ) <= 0) {
                pll->m_wantedEvents &= ~Netcon::NETCONPOLL_READ;
            }
            if (canwrite && pll->cando(Netcon::NETCONPOLL_WRITE) <= 0) {
                pll->m_wantedEvents &= ~Netcon::NETCONPOLL_WRITE;
            }
            if (!(pll->m_wantedEvents & (Netcon::NETCONPOLL_WRITE|Netcon::NETCONPOLL_READ))) {
                LOGDEB0(("Netcon::selectloop: fd %d has 0x%x mask, erasing\n",
                         it->first, it->second->m_wantedEvents));
                m_polldata.erase(it);
            }
        } // fd sweep

    } // forever loop
    LOGERR(("SelectLoop::doLoop: got out of loop !\n"));
    return -1;
}

// Add a connection to the monitored set.
int SelectLoop::addselcon(NetconP con, int events)
{
    if (!con) {
        return -1;
    }
    LOGDEB1(("Netcon::addselcon: fd %d\n", con->m_fd));
    con->set_nonblock(1);
    con->setselevents(events);
    m_polldata[con->m_fd] = con;
    con->setloop(this);
...
}

// Remove a connection from the monitored set.
int SelectLoop::remselcon(NetconP con)
{
    if (!con) {
        return -1;
    }
    LOGDEB1(("Netcon::remselcon: fd %d\n", con->m_fd));
    map<int,NetconP>::iterator it = m_polldata.find(con->m_fd);
    if (it == m_polldata.end()) {
        LOGDEB1(("Netcon::remselcon: con not found for fd %d\n", con->m_fd));
        return -1;
    }
    con->setloop(0);
    m_polldata.erase(it);
    return 0;
}

//////////////////////////////////////////////////////////
// Base class (Netcon) methods
Netcon::~Netcon() 
{
    closeconn();
    if (m_peer) {
        free(m_peer);
        m_peer = 0;
    }
}

void Netcon::closeconn()
{
    if (m_ownfd && m_fd >= 0) {
        close(m_fd);
    }
    m_fd = -1;
    m_ownfd = true;
}

...
    return strerror(errno);
}

void Netcon::setpeer(const char *hostname)
{
    if (m_peer) {
        free(m_peer);
    }
    m_peer = strdup(hostname);
}

int Netcon::settcpnodelay(int on)
{
    LOGDEB2(( "Netcon::settcpnodelay\n" ));
    if (m_fd < 0) {
        LOGERR(("Netcon::settcpnodelay: connection not opened\n"));
        return -1;
    }
    char *cp = on ? (char *)&one : (char *)&zero;
    if (setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, cp, sizeof(one)) < 0) {
        LOGSYSERR("NetconCli::settcpnodelay", "setsockopt", "TCP_NODELAY");
        return -1;
    }
    return 0;
}

// Set/reset non-blocking flag on fd
int Netcon::set_nonblock(int onoff)
{
    int  flags = fcntl(m_fd, F_GETFL, 0);
    if (flags != -1 )   {
        int newflags = onoff ? flags | O_NONBLOCK : flags & ~O_NONBLOCK;
        if (newflags != flags)
            if (fcntl(m_fd, F_SETFL, newflags) < 0) {
                return -1;
            }
    }
    return flags;
}

/////////////////////////////////////////////////////////////////////
// Data socket (NetconData) methods

NetconData::~NetconData() 
{
    freeZ(m_buf);
    m_bufbase = 0;
    m_bufbytes = m_bufsize = 0;
}

int NetconData::send(const char *buf, int cnt, int expedited)
{
    LOGDEB2(("NetconData::send: fd %d cnt %d expe %d\n", m_fd, cnt, expedited));
    int flag = 0;
    if (m_fd < 0) {
        LOGERR(("NetconData::send: connection not opened\n"));
        return -1;
    }
    if (expedited) {
        LOGDEB2(("NetconData::send: expedited data, count %d bytes\n", cnt));
        flag = MSG_OOB;
    }
    int ret;
    // There is a bug in the uthread version of sendto() in FreeBSD at
    // least up to 2.2.7, so avoid using it when possible
    if (flag) {
        ret = ::send(m_fd, buf, cnt, flag);
    } else {
        ret = ::write(m_fd, buf, cnt);
    }

    // Note: byte count may be different from cnt if fd is non-blocking
    if (ret < 0) {
        char fdcbuf[20];
        sprintf(fdcbuf, "%d", m_fd);
        LOGSYSERR("NetconData::send", "send", fdcbuf);
    }
    return ret;
}

// Test for data available
int NetconData::readready()
{
    LOGDEB2(("NetconData::readready\n"));
    if (m_fd < 0) {
        LOGERR(("NetconData::readready: connection not opened\n"));
        return -1;
    }
    return select1(m_fd, 0);
}

// Test for writable
int NetconData::writeready()
{
    LOGDEB2(("NetconData::writeready\n"));
    if (m_fd < 0) {
        LOGERR(("NetconData::writeready: connection not opened\n"));
        return -1;
    }
    return select1(m_fd, 0, 1);
}

// Receive at most cnt bytes (maybe less)
int NetconData::receive(char *buf, int cnt, int timeo)
{
    LOGDEB2(("NetconData::receive: cnt %d timeo %d m_buf 0x%x m_bufbytes %d\n",
             cnt, timeo, m_buf, m_bufbytes));
    if (m_fd < 0) {
        LOGERR(("NetconData::receive: connection not opened\n"));
        return -1;
    }
    int fromibuf = 0;
    // Get whatever might have been left in the buffer by a previous
    // getline, except if we're called to fill the buffer of course
    if (m_buf && m_bufbytes > 0 && (buf < m_buf || buf > m_buf + m_bufsize)) {
        fromibuf = MIN(m_bufbytes, cnt);
        memcpy(buf, m_bufbase, fromibuf);
        m_bufbytes -= fromibuf;
        m_bufbase += fromibuf;
        cnt -= fromibuf;
        LOGDEB2(("NetconData::receive: transferred %d from mbuf\n", fromibuf));
        if (cnt <= 0) {
            return fromibuf;
        }
    }
    if (timeo > 0) {
        int ret = select1(m_fd, timeo);
        if (ret == 0) {
            LOGDEB2(("NetconData::receive timed out\n"));
            m_didtimo = 1;
            return -1;
        }
        if (ret < 0) {
            LOGSYSERR("NetconData::receive", "select", "");
            return -1;
        }
    }
    m_didtimo = 0;
    if ((cnt = read(m_fd, buf + fromibuf, cnt)) < 0) {
        char fdcbuf[20];
        sprintf(fdcbuf, "%d", m_fd);
        LOGSYSERR("NetconData::receive", "read", fdcbuf);
        return -1;
    }
    LOGDEB2(("NetconData::receive: normal return, cnt %d\n", cnt));
    return fromibuf + cnt;
}

...
{
    int got, cur;
    LOGDEB2(("Netcon::doreceive: cnt %d, timeo %d\n", cnt, timeo));
    cur = 0;
    while (cnt > cur) {
        got = receive(buf, cnt-cur, timeo);
        LOGDEB2(("Netcon::doreceive: got %d\n", got));
        if (got < 0) {
            return -1;
        }
        if (got == 0) {
            return cur;
        }
        cur += got;
        buf += got;
    }
    return cur;
}

// Read data until cnt-1 characters are read or a newline is found. Add
...
static const int defbufsize = 200;
int NetconData::getline(char *buf, int cnt, int timeo)
{
    LOGDEB2(("NetconData::getline: cnt %d, timeo %d\n", cnt, timeo));
    if (m_buf == 0) {
        if ((m_buf = (char *)malloc(defbufsize)) == 0) {
            LOGSYSERR("NetconData::getline: Out of mem", "malloc", "");
            return -1;
        }
        m_bufsize = defbufsize;
        m_bufbase = m_buf;
        m_bufbytes = 0;
    }

    char *cp = buf;
    for (;;) {
        // Transfer from buffer. Have to take a lot of care to keep counts and
        // pointers consistant in all end cases
        int maxtransf = MIN(m_bufbytes, cnt-1);
        int nn = maxtransf;
        LOGDEB2(("Before loop, bufbytes %d, maxtransf %d, nn: %d\n",
                 m_bufbytes, maxtransf, nn));
        for (nn = maxtransf; nn > 0;) {
            // This is not pretty but we want nn to be decremented for
            // each byte copied (even newline), and not become -1 if
            // we go to the end. Better ways welcome!
            nn--;
            if ((*cp++ = *m_bufbase++) == '\n') {
                break;
            }
        }
        // Update counts
        maxtransf -= nn; // Actual count transferred
        m_bufbytes -= maxtransf;
        cnt -= maxtransf;
        LOGDEB2(("After transfer: actual transf %d cnt %d, m_bufbytes %d\n",
                 maxtransf, cnt, m_bufbytes));

        // Finished ?
        if (cnt <= 1 || (cp > buf && cp[-1] == '\n')) {
            *cp = 0;
            return cp - buf;
        }

        // Transfer from net
        m_bufbase = m_buf;
        m_bufbytes = receive(m_buf, m_bufsize, timeo);
        if (m_bufbytes == 0) {
            // EOF
            *cp = 0;
            return cp - buf;
        }
        if (m_bufbytes < 0) {
            m_bufbytes = 0;
            *cp = 0;
            return -1;
        }
    }
}

// Called when selectloop detects that data can be read or written on
// the connection. The user callback would normally have been set
// up. If it is, call it and return. Else, perform housecleaning: read
// and discard.
int NetconData::cando(Netcon::Event reason)
{
    LOGDEB2(("NetconData::cando\n"));
    if (m_user) {
        return m_user->data(this, reason);
    }

    // No user callback. Clean up by ourselves
    if (reason & NETCONPOLL_READ) {
#define BS 200
        char buf[BS];
        int n;
        if ((n = receive(buf, BS)) < 0) {
            LOGSYSERR("NetconData::cando", "receive", "");
            return -1;
        }
        if (n == 0) {
            // EOF
            return 0;
        }
    }
    clearselevents(NETCONPOLL_WRITE);
    return 1;
}

...
    int ret = -1;
    LOGDEB2(("Netconcli::openconn: host %s, port %d\n", host, port));

    closeconn();

    struct sockaddr *saddr;
    socklen_t addrsize;

    struct sockaddr_in ip_addr;
    struct sockaddr_un unix_addr;
    if (host[0] != '/') {
        memset(&ip_addr, 0, sizeof(ip_addr));
        ip_addr.sin_family = AF_INET;
        ip_addr.sin_port = htons(port);

        // Server name may be host name or IP address
        int addr;
        if ((addr = inet_addr(host)) != -1) {
            memcpy(&ip_addr.sin_addr, &addr, sizeof(addr));
        } else {
            struct hostent *hp;
            if ((hp = gethostbyname(host)) == 0) {
                LOGERR(("NetconCli::openconn: gethostbyname(%s) failed\n", 
                        host));
                return -1;
            }
            memcpy(&ip_addr.sin_addr, hp->h_addr, hp->h_length);
        }

        if ((m_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
            LOGSYSERR("NetconCli::openconn", "socket", "");
            return -1;
        }
        addrsize = sizeof(ip_addr);
        saddr = (sockaddr*)&ip_addr;
    } else {
        memset(&unix_addr, 0, sizeof(unix_addr));
        unix_addr.sun_family = AF_UNIX;
        if (strlen(host) > UNIX_PATH_MAX - 1) {
            LOGERR(("NetconCli::openconn: name too long: %s\n", host));
            return -1;


        }
        strcpy(unix_addr.sun_path, host);

        if ((m_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
            LOGSYSERR("NetconCli::openconn", "socket", "");
            return -1;
        }
        addrsize = sizeof(unix_addr);
        saddr = (sockaddr*)&unix_addr;
    }
    if (timeo > 0) {
        set_nonblock(1);
    }

    if (connect(m_fd, saddr, addrsize) < 0) {
        if (timeo > 0) {
            if (errno != EINPROGRESS) {
                goto out;
            }
            if (select1(m_fd, timeo, 1) == 1) {
                goto connectok;
            }
        }
        if (m_silentconnectfailure == 0) {
            LOGSYSERR("NetconCli", "connect", "");


        }
        goto out;
    }
connectok:
    if (timeo > 0) {
        set_nonblock(0);
    }

    LOGDEB2(("NetconCli::connect: setting keepalive\n"));
    if (setsockopt(m_fd, SOL_SOCKET, SO_KEEPALIVE,
                   (char *)&one, sizeof(one)) < 0) {
        LOGSYSERR("NetconCli::connect", "setsockopt", "KEEPALIVE");
    }
    setpeer(host);
    LOGDEB2(("NetconCli::openconn: connection opened ok\n"));
    ret = 0;
out:
    if (ret < 0) {
        closeconn();
    }
    return ret;
}

// Same as previous, but get the port number from services
int NetconCli::openconn(const char *host, const char *serv, int timeo)
{
    LOGDEB2(("Netconcli::openconn: host %s, serv %s\n", host, serv));

    if (host[0]  != '/') {
        struct servent *sp;
        if ((sp = getservbyname(serv, "tcp")) == 0) {
            LOGERR(("NetconCli::openconn: getservbyname failed for %s\n",serv));
            return -1;
        }
        // Callee expects the port number in host byte order
        return openconn(host, ntohs(sp->s_port), timeo);
    } else {
        return openconn(host, (unsigned int)0, timeo);
    }
}


int NetconCli::setconn(int fd)
{
...

    return 0;
}

///////////////////////////////////////////////////////////////////////
// Methods for the main (listening) server connection

NetconServLis::~NetconServLis() 
{
#ifdef NETCON_ACCESSCONTROL
    freeZ(okaddrs.intarray);
    freeZ(okmasks.intarray);
#endif
}

#if 0
// code for dumping a struct servent
static void dump_servent(struct servent *servp) 
{
    fprintf(stderr, "Official name %s\n", servp->s_name);
    for (char **cpp = servp->s_aliases; *cpp; cpp++) {
        fprintf(stderr, "Nickname %s\n", *cpp);
    }
    fprintf(stderr, "Port %d\n", (int)ntohs((short)servp->s_port));
    fprintf(stderr, "Proto %s\n", servp->s_proto);
}
#endif

// Set up service.
int NetconServLis::openservice(const char *serv, int backlog)
{
    int port;
    struct servent  *servp;
    if (!serv) {
        LOGERR(("NetconServLis::openservice: null serv??\n"));
        return -1;
    }
    LOGDEB1(("NetconServLis::openservice: serv %s\n", serv));
#ifdef NETCON_ACCESSCONTROL
    if (initperms(serv) < 0) {
        return -1;
    }
#endif

    m_serv = serv;
    if (serv[0] != '/') {
        if ((servp = getservbyname(serv, "tcp")) == 0) {
            LOGERR(("NetconServLis::openservice: getservbyname failed for %s\n",
                    serv));
            return -1;
        }
        port = (int)ntohs((short)servp->s_port);
        return openservice(port, backlog);
    } else {
        if (strlen(serv) > UNIX_PATH_MAX - 1) {
            LOGERR(("NetconServLis::openservice: too long for AF_UNIX: %s\n",
                    serv));
            return -1;
        }
        int ret = -1;
        struct sockaddr_un  addr;
        if ((m_fd = socket(AF_UNIX, SOCK_STREAM, 0)) < 0) {
            LOGSYSERR("NetconServLis", "socket", "");
            return -1;
        }
        memset(&addr, 0, sizeof(addr));
        addr.sun_family = AF_UNIX;
        strcpy(addr.sun_path, serv);

        if (::bind(m_fd, (struct sockaddr *)&addr, sizeof(addr)) < 0) {
            LOGSYSERR("NetconServLis", "bind", "");
            goto out;
        }
        if (listen(m_fd, backlog) < 0) {
            LOGSYSERR("NetconServLis", "listen", "");
            goto out;
        }

        LOGDEB1(("NetconServLis::openservice: service opened ok\n"));
        ret = 0;
    out:
        if (ret < 0 && m_fd >= 0) {
            close(m_fd);
            m_fd = -1;
        }
        return ret;
    }
}

// Port is a natural host integer value
int NetconServLis::openservice(int port, int backlog)
{
    LOGDEB1(("NetconServLis::openservice: port %d\n", port));
#ifdef NETCON_ACCESSCONTROL
    if (initperms(port) < 0) {
        return -1;
    }
#endif
    int ret = -1;
    struct sockaddr_in  ipaddr;
    if ((m_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
        LOGSYSERR("NetconServLis", "socket", "");
        return -1;
    }
    (void) setsockopt(m_fd, SOL_SOCKET, SO_REUSEADDR,(char *)&one, sizeof(one));
#ifdef SO_REUSEPORT
    (void) setsockopt(m_fd, SOL_SOCKET, SO_REUSEPORT,(char *)&one, sizeof(one));
#endif /*SO_REUSEPORT*/
    memset(&ipaddr, 0, sizeof(ipaddr));
    ipaddr.sin_family = AF_INET;
    ipaddr.sin_addr.s_addr = htonl(INADDR_ANY);
    ipaddr.sin_port = htons((short)port);
    if (::bind(m_fd, (struct sockaddr *)&ipaddr, sizeof(ipaddr)) < 0) {
        LOGSYSERR("NetconServLis", "bind", "");
        goto out;
    }
    if (listen(m_fd, backlog) < 0) {
        LOGSYSERR("NetconServLis", "listen", "");
        goto out;
    }

    LOGDEB1(("NetconServLis::openservice: service opened ok\n"));
    ret = 0;
out:
    if (ret < 0 && m_fd >= 0) {
        close(m_fd);
        m_fd = -1;
    }
    return ret;
}

#ifdef NETCON_ACCESSCONTROL
int NetconServLis::initperms(int port)
{
    if (permsinit) {
        return 0;
    }

    char sport[30];
    sprintf(sport, "%d", port);
    return initperms(sport);
}

// Get authorized address lists from parameter file. This is disabled for now
int NetconServLis::initperms(const char *serv)
{
    if (permsinit) {
        return 0;
    }

    if (serv == 0 || *serv == 0 || strlen(serv) > 80) {
        LOGERR(("NetconServLis::initperms: bad service name %s\n", serv));
        return -1;
    }

    char keyname[100];
    sprintf(keyname, "%s_okaddrs", serv);
    if (genparams->getparam(keyname, &okaddrs, 1) < 0) {
        serv = "default";
        sprintf(keyname, "%s_okaddrs", serv);
        if (genparams->getparam(keyname, &okaddrs) < 0) {
            LOGERR(("NetconServLis::initperms: no okaddrs found in config file\n"));
            return -1;
        }
    }
    sprintf(keyname, "%s_okmasks", serv);
    if (genparams->getparam(keyname, &okmasks)) {
        LOGERR(("NetconServLis::initperms: okmasks not found\n"));
        return -1;
    }
    if (okaddrs.len == 0 || okmasks.len == 0) {
        LOGERR(("NetconServLis::initperms: len 0 for okmasks or okaddrs\n"));
        return -1;
    }

    permsinit = 1;
    return 0;
}
...
NetconServLis::accept(int timeo)
{
    LOGDEB(("NetconServLis::accept\n"));

    if (timeo > 0) {
        int ret = select1(m_fd, timeo);
        if (ret == 0) {
            LOGDEB2(("NetconServLis::accept timed out\n"));
            m_didtimo = 1;
            return 0;
        }
        if (ret < 0) {
            LOGSYSERR("NetconServLis::accept", "select", "");
            return 0;
        }
    }
    m_didtimo = 0;

    NetconServCon *con = 0;
    int newfd = -1;
    struct sockaddr_in who;
    struct sockaddr_un uwho;
    if (m_serv.empty() || m_serv[0] != '/') {
        SOCKLEN_T clilen = (SOCKLEN_T)sizeof(who);
        if ((newfd = ::accept(m_fd, (struct sockaddr *)&who, &clilen)) < 0) {
            LOGSYSERR("NetconServCon::accept", "accept", "");
            goto out;
        }
#ifdef NETCON_ACCESSCONTROL
        if (checkperms(&who, clilen) < 0) {
            goto out;
        }
#endif
    } else {
        SOCKLEN_T clilen = (SOCKLEN_T)sizeof(uwho);
        if ((newfd = ::accept(m_fd, (struct sockaddr *)&uwho, &clilen)) < 0) {
            LOGSYSERR("NetconServCon::accept", "accept", "");
            goto out;
        }
    }

    con = new NetconServCon(newfd);
    if (con == 0) {
        LOGERR(("NetconServLis::accept: new NetconServCon failed\n"));
        goto out;
    }

    // Retrieve peer's host name. Errors are non fatal
    if (m_serv.empty() || m_serv[0] != '/') {
        struct hostent *hp;
        if ((hp = gethostbyaddr((char *) & (who.sin_addr), 
                                sizeof(struct in_addr), AF_INET)) == 0) {
            LOGERR(("NetconServLis::accept: gethostbyaddr failed for addr 0x%lx\n",
                who.sin_addr.s_addr));
            con->setpeer(inet_ntoa(who.sin_addr));
        } else {
            con->setpeer(hp->h_name);
        }
    } else {
        con->setpeer(m_serv.c_str());
    }

    LOGDEB2(("NetconServLis::accept: setting keepalive\n"));
    if (setsockopt(newfd, SOL_SOCKET, SO_KEEPALIVE,
                   (char *)&one, sizeof(one)) < 0) {
        LOGSYSERR("NetconServLis::accept", "setsockopt", "KEEPALIVE");
    }
    LOGDEB2(("NetconServLis::accept: got connect from %s\n", con->getpeer()));

out:
    if (con == 0 && newfd >= 0) {
        close(newfd);
    }
    return con;
}

#ifdef NETCON_ACCESSCONTROL
int
NetconServLis::checkperms(void *cl, int)
{
    // If okmasks and addrs were not initialized, the default is allow to all
    if (okmasks.len <= 0 || okaddrs.len <= 0) {
        return 0;
    }

    struct sockaddr *addr = (struct sockaddr *)cl;
    unsigned long ip_addr;

    if (addr->sa_family != AF_INET) {
        LOGERR(("NetconServLis::checkperms: connection from non-INET addr !\n"));
        return -1;
    }

    ip_addr = ntohl(((struct sockaddr_in *)addr)->sin_addr.s_addr);
    LOGDEB2(("checkperms: ip_addr: 0x%x\n", ip_addr));
    for (int i = 0; i < okaddrs.len; i++) {
        unsigned int mask;
        if (i < okmasks.len) {
            mask = okmasks.intarray[i];
        } else {
            mask = okmasks.intarray[okmasks.len-1];
        }
        LOGDEB2(("checkperms: trying okaddr 0x%x, mask 0x%x\n",
                 okaddrs.intarray[i], mask));
        if ((ip_addr & mask) == (okaddrs.intarray[i] & mask)) {
            return (0);
        }
    }
    LOGERR(("NetconServLis::checkperm: connection from bad address 0x%x\n",
            ip_addr));
    return -1;
}
#endif /* NETCON_ACCESSCONTROL */


...
#include <signal.h>
#include <string.h>

#include "debuglog.h"
#include "netcon.h"

using namespace std;

static char *thisprog;
static char usage[] =
    "-c <host> <service>: Connects to trnetcon server, exchange message, then\n"
    "  sleeps 10 S, except if option -n is given (sleep forever)\n"
    "\n"
    "-s <service>: open service <service>\n"
    ;
static void
Usage()
{
    fprintf(stderr, "Usage : %s:\n %s", thisprog, usage);
    exit(1);
}
...
int main(int argc, char **argv)
{
    char *host, *serv;

    thisprog = argv[0];
    argc--;
    argv++;

    while (argc > 0 && **argv == '-') {
        (*argv)++;
        if (!(**argv))
            /* Cas du "adb - core" */
        {
            Usage();
        }
        while (**argv)
            switch (*(*argv)++) {
            case 's':
                op_flags |= OPT_s;
                break;
            case 'c':
                op_flags |= OPT_c;
                break;
            case 'n':
                op_flags |= OPT_n;
                break;
            default:
                Usage();
                break;
        }
        argc--;
        argv++;
    }
    DebugLog::setfilename("stderr");
    DebugLog::getdbl()->setloglevel(DEBDEB2);

    if (op_flags & OPT_c) {
        if (argc != 2) {
            Usage();
        }
        host = *argv++;
        argc--;
        serv = *argv++;
        argc--;
        exit(trycli(host, serv));
    } else if (op_flags & OPT_s) {
        if (argc != 1) {
            Usage();
        }
        serv = *argv++;
        argc--;
        exit(tryserv(serv));
    } else {
        Usage();
    }
}


static char buf[1024];
...
static char fromcli[200];

class CliNetconWorker : public NetconWorker {
public:
    CliNetconWorker()  : m_count(0) {}
    int data(NetconData *con, Netcon::Event reason) {

        LOGDEB(("clientdata\n"));
        if (reason & Netcon::NETCONPOLL_WRITE) {
            sprintf(fromcli, "Bonjour Bonjour client %d, count %d",
                    getpid(), m_count);
            con->setselevents(Netcon::NETCONPOLL_READ);
            if (con->send(fromcli, strlen(fromcli) + 1) < 0) {
                fprintf(stderr, "send failed\n");
                return -1;
            }
            m_count++;
        }

        if (reason & Netcon::NETCONPOLL_READ) {
            con->setselevents(Netcon::NETCONPOLL_WRITE);
            int n;
            if ((n = con->receive(buf, buflen)) < 0) {
                fprintf(stderr, "receive failed\n");
                return -1;
            }
            if (n == 0) {
                // EOF, close connection
                return -1;
            }
            buf[n] = 0;
            fprintf(stderr, "%d received \"%s\"\n", getpid(), buf);
            if (op_flags & OPT_n) {
                pause();
            } else {
                sleep(1);
            }
        }
        if (m_count >= 10) {
            fprintf(stderr, "Did 10, enough\n");
            if (con->getloop()) {
                con->getloop()->loopReturn(0);
            }
        }
        return 0;
    }








private:
    int m_count;
};

int trycli(char *host, char *serv)
{
    sprintf(fromcli, "Bonjour Bonjour je suis le client %d", getpid());

    NetconCli *clicon = new NetconCli();
    NetconP con(clicon);
    if (!con) {
        fprintf(stderr, "new NetconCli failed\n");
        return 1;
    }
    int port = atoi(serv);
    int ret = port > 0 ? 
        clicon->openconn(host, port) : clicon->openconn(host, serv);
    if (ret < 0) {
        fprintf(stderr, "openconn(%s, %s) failed\n", host, serv);
        return 1;
    }
    fprintf(stderr, "openconn(%s, %s) ok\n", host, serv);
#ifdef NOSELLOOP
    for (int i = 0; i < nloop; i++) {
        if (con->send(fromcli, strlen(fromcli) + 1) < 0) {
            fprintf(stderr, "%d: Send failed\n", getpid());
            return 1;
        }
        if (con->receive(buf, buflen) < 0) {
            perror("receive:");
            fprintf(stderr, "%d: Receive failed\n", getpid());
            return 1;
        }
        fprintf(stderr, "%d Received \"%s\"\n", getpid(), buf);
        if (op_flags & OPT_n) {
            pause();
        } else {
            sleep(1);
        }
    }
#else
    RefCntr<NetconWorker> worker =
        RefCntr<NetconWorker>(new CliNetconWorker());
    clicon->setcallback(worker);
    SelectLoop myloop;
    myloop.addselcon(con, Netcon::NETCONPOLL_WRITE);
    fprintf(stderr, "client ready\n");
    ret = myloop.doLoop();
    if (ret < 0) {
        fprintf(stderr, "selectloop failed\n");
        exit(1);
    }
    fprintf(stderr, "selectloop returned %d\n", ret);
#endif
    return 0;
}
...
//////////////////////////////////////////////////////////////////
// Server-side sample code
class ServNetconWorker : public NetconWorker {
public:
    ServNetconWorker() : m_count(0) {}
    int data(NetconData *con, Netcon::Event reason) {

        LOGDEB(("serverdata\n"));
        if (reason & Netcon::NETCONPOLL_WRITE) {
            con->setselevents(Netcon::NETCONPOLL_READ);
            char fromserv[200];
            sprintf(fromserv,
                    "Du serveur: mon fd pour ce client est  %d, mon compte %d",
                    con->getfd(), ++m_count);
            if (con->send(fromserv, strlen(fromserv) + 1) < 0) {
                fprintf(stderr, "send failed\n");
                return -1;
            }
        }
        if (reason & Netcon::NETCONPOLL_READ) {
#define LL 200
            char buf[LL+1];
            int n;
            if ((n = con->receive(buf, LL)) < 0) {
                fprintf(stderr, "receive failed\n");
                return -1;
            }
            if (n == 0) {
                return -1;
            }
            buf[n] = 0;
            fprintf(stderr, "%d received \"%s\"\n", getpid(), buf);
            con->setselevents(Netcon::NETCONPOLL_READ|Netcon::NETCONPOLL_WRITE);
        }
        return 0;
    }
private:
    int m_count;
};

class MyNetconServLis : public NetconServLis {
public:
    MyNetconServLis(SelectLoop &loop)
        : NetconServLis(), m_loop(loop) {

    }
protected:
    int cando(Netcon::Event reason) {
        NetconServCon *con = accept();
        if (con == 0) {
            return -1;
        }
        RefCntr<NetconWorker> worker =
            RefCntr<NetconWorker>(new ServNetconWorker());
        con->setcallback(worker);
        m_loop.addselcon(NetconP(con), NETCONPOLL_READ);
        return 1;
    }
    SelectLoop& m_loop;
};

NetconP lis;

void
onexit(int sig)
{
    fprintf(stderr, "Onexit: ");
    if (sig == SIGQUIT) {
        kill(getpid(), SIGKILL);
    }
    fprintf(stderr, "Exiting\n");
    exit(0);
}

int tryserv(char *serv)
{
    signal(SIGCHLD, SIG_IGN);
    SelectLoop myloop;
    MyNetconServLis *servlis = new MyNetconServLis(myloop);
    lis = NetconP(servlis);
    if (!lis) {
        fprintf(stderr, "new NetconServLis failed\n");
        return 1;
    }

    // Prepare for cleanup
    struct sigaction sa;
    sa.sa_flags = 0;
...
    sigemptyset(&sa.sa_mask);
    sigaction(SIGINT, &sa, 0);
    sigaction(SIGQUIT, &sa, 0);
    sigaction(SIGTERM, &sa, 0);

    int port = atoi(serv);
    int ret = port > 0 ? 
        servlis->openservice(port) : servlis->openservice(serv);
    if (ret < 0) {
        fprintf(stderr, "openservice(%s) failed\n", serv);
        return 1;
    }
    myloop.addselcon(lis, Netcon::NETCONPOLL_READ);
    fprintf(stderr, "openservice(%s) Ok\n", serv);
    if (myloop.doLoop() < 0) {
        fprintf(stderr, "selectloop failed\n");
        exit(1);
    }
    return 0;
}

#endif /* TEST_NETCON */

	a/src/utils/netcon.cpp		b/src/utils/netcon.cpp
1	/* Copyright (C) 2002 Jean-Francois Dockes */	1	/* Copyright (C) 2002 J.F. Dockes
		2	* This program is free software; you can redistribute it and/or modify
		3	* it under the terms of the GNU General Public License as published by
		4	* the Free Software Foundation; either version 2 of the License, or
		5	* (at your option) any later version.
		6	*
		7	* This program is distributed in the hope that it will be useful,
		8	* but WITHOUT ANY WARRANTY; without even the implied warranty of
		9	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
		10	* GNU General Public License for more details.
		11	*
		12	* You should have received a copy of the GNU General Public License
		13	* along with this program; if not, write to the
		14	* Free Software Foundation, Inc.,
		15	* 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
		16	*/
2		17
3	// Wrapper classes for the socket interface	18	// Wrapper classes for the socket interface
4		19
5		20
6	#ifndef TEST_NETCON	21	#ifndef TEST_NETCON
	...		...
14	#endif // _AIX	29	#endif // _AIX
15		30
16	#include <unistd.h>	31	#include <unistd.h>
17	#include <fcntl.h>	32	#include <fcntl.h>
18	#include <sys/time.h>	33	#include <sys/time.h>
19
20	#include <sys/socket.h>	34	#include <sys/socket.h>
		35	#include <sys/un.h>
21	#include <netinet/in.h>	36	#include <netinet/in.h>
22	#include <netinet/tcp.h>	37	#include <netinet/tcp.h>
23	#include <arpa/inet.h>	38	#include <arpa/inet.h>
24	#include <netdb.h>	39	#include <netdb.h>
25		40
26	#include <map>	41	#include <map>
27		42
28	#ifndef NO_NAMESPACES	43
		44	#ifdef RECOLL_DATADIR
		45	#include "debuglog.h"
		46
		47	#else
		48
		49	#define LOGFATAL(X)
		50	#define LOGERR(X)
		51	#define LOGINFO(X)
		52	#define LOGDEB(X)
		53	#define LOGDEB0(X)
		54	#define LOGDEB1(X)
		55	#define LOGDEB2(X)
		56	#define LOGDEB3(X)
		57	#define LOGDEB4(X)
		58	#endif
		59
		60	#include "netcon.h"
		61
29	using namespace std;	62	using namespace std;
30	#endif
31
32	#include "debuglog.h"
33	#include "netcon.h"
34		63
35	#ifndef SOCKLEN_T	64	#ifndef SOCKLEN_T
36	#define SOCKLEN_T socklen_t	65	#define SOCKLEN_T socklen_t
		66	#endif
		67
		68	// Size of path buffer in sockaddr_un (AF_UNIX socket
		69	// addr). Mysteriously it's 108 (explicit value) under linux, no
		70	// define accessible. Let's take a little margin as it appears that
		71	// some systems use 92. I believe we could also malloc a variable size
		72	// struct but why bother.
		73	#ifndef UNIX_PATH_MAX
		74	#define UNIX_PATH_MAX 90
37	#endif	75	#endif
38		76
39	// Need &one, &zero for setsockopt...	77	// Need &one, &zero for setsockopt...
40	static const int one = 1;	78	static const int one = 1;
41	static const int zero = 0;	79	static const int zero = 0;
	...		...
70	tv.tv_sec = timeo;	108	tv.tv_sec = timeo;
71	tv.tv_usec = 0;	109	tv.tv_usec = 0;
72	FD_ZERO(&rd);	110	FD_ZERO(&rd);
73	FD_SET(fd, &rd);	111	FD_SET(fd, &rd);
74	if (write) {	112	if (write) {
75	ret = select(fd+1, 0, &rd, 0, &tv);	113	ret = select(fd+1, 0, &rd, 0, &tv);
76	} else {	114	} else {
77	ret = select(fd+1, &rd, 0, 0, &tv);	115	ret = select(fd+1, &rd, 0, 0, &tv);
78	}	116	}
79	if (!FD_ISSET(fd, &rd)) {	117	if (!FD_ISSET(fd, &rd)) {
80	LOGERR(("Netcon::select1: fd not ready after select ??\n"));	118	LOGERR(("Netcon::select1: fd not ready after select ??\n"));
81	return -1;	119	return -1;
82	}	120	}
83	return ret;	121	return ret;
84	}	122	}
85		123
86	void SelectLoop::setperiodichandler(int (handler)(void ), void *p, int ms)	124	void SelectLoop::setperiodichandler(int (handler)(void ), void *p, int ms)
87	{	125	{
88	m_periodichandler = handler;	126	m_periodichandler = handler;
89	m_periodicparam = p;	127	m_periodicparam = p;
90	m_periodicmillis = ms;	128	m_periodicmillis = ms;
91	if (m_periodicmillis > 0)	129	if (m_periodicmillis > 0) {
92	gettimeofday(&m_lasthdlcall, 0);	130	gettimeofday(&m_lasthdlcall, 0);
		131	}
93	}	132	}
94		133
95	// Compute the appropriate timeout so that the select call returns in	134	// Compute the appropriate timeout so that the select call returns in
96	// time to call the periodic routine.	135	// time to call the periodic routine.
97	void SelectLoop::periodictimeout(struct timeval *tv)	136	void SelectLoop::periodictimeout(struct timeval *tv)
98	{	137	{
99	// If periodic not set, the select call times out and we loop	138	// If periodic not set, the select call times out and we loop
100	// after a very long time (we'd need to pass NULL to select for an	139	// after a very long time (we'd need to pass NULL to select for an
101	// infinite wait, and I'm too lazy to handle it)	140	// infinite wait, and I'm too lazy to handle it)
102	if (m_periodicmillis <= 0) {	141	if (m_periodicmillis <= 0) {
103	tv->tv_sec = 10000;	142	tv->tv_sec = 10000;
104	tv->tv_usec = 0;	143	tv->tv_usec = 0;
105	return;	144	return;
106	}	145	}
107		146
108	struct timeval mtv;	147	struct timeval mtv;
109	gettimeofday(&mtv, 0);	148	gettimeofday(&mtv, 0);
110	int millis = m_periodicmillis - MILLIS(m_lasthdlcall, mtv);	149	int millis = m_periodicmillis - MILLIS(m_lasthdlcall, mtv);
111		150
112	// millis <= 0 means we should have already done the thing. dont set the	151	// millis <= 0 means we should have already done the thing. dont set the
113	// tv to 0, which means no timeout at all !	152	// tv to 0, which means no timeout at all !
114	if (millis <= 0)	153	if (millis <= 0) {
115	millis = 1;	154	millis = 1;
		155	}
116	tv->tv_sec = millis / 1000;	156	tv->tv_sec = millis / 1000;
117	tv->tv_usec = (millis % 1000) * 1000;	157	tv->tv_usec = (millis % 1000) * 1000;
118	}	158	}
119		159
120	// Check if it's time to call the handler. selectloop will return to	160	// Check if it's time to call the handler. selectloop will return to
121	// caller if it or we return 0	161	// caller if it or we return 0
122	int SelectLoop::maybecallperiodic()	162	int SelectLoop::maybecallperiodic()
123	{	163	{
124	if (m_periodicmillis <= 0)	164	if (m_periodicmillis <= 0) {
125	return 1;	165	return 1;
		166	}
126	struct timeval mtv;	167	struct timeval mtv;
127	gettimeofday(&mtv, 0);	168	gettimeofday(&mtv, 0);
128	int millis = m_periodicmillis - MILLIS(m_lasthdlcall, mtv);	169	int millis = m_periodicmillis - MILLIS(m_lasthdlcall, mtv);
129	if (millis <= 0) {	170	if (millis <= 0) {
130	gettimeofday(&m_lasthdlcall, 0);	171	gettimeofday(&m_lasthdlcall, 0);
131	if (m_periodichandler)	172	if (m_periodichandler) {
132	return m_periodichandler(m_periodicparam);	173	return m_periodichandler(m_periodicparam);
133	else	174	} else {
134	return 0;	175	return 0;
		176	}
135	}	177	}
136	return 1;	178	return 1;
137	}	179	}
138		180
139	int SelectLoop::doLoop()	181	int SelectLoop::doLoop()
140	{	182	{
141	for (;;) {	183	for (;;) {
142	if (m_selectloopDoReturn) {	184	if (m_selectloopDoReturn) {
143	m_selectloopDoReturn = false;	185	m_selectloopDoReturn = false;
144	LOGDEB(("Netcon::selectloop: returning on request\n"));	186	LOGDEB(("Netcon::selectloop: returning on request\n"));
145	return m_selectloopReturnValue;	187	return m_selectloopReturnValue;
146	}	188	}
147	int nfds;	189	int nfds;
148	fd_set rd, wd;	190	fd_set rd, wd;
149	FD_ZERO(&rd);	191	FD_ZERO(&rd);
150	FD_ZERO(&wd);	192	FD_ZERO(&wd);
151		193
152	// Walk the netcon map and set up the read and write fd_sets	194	// Walk the netcon map and set up the read and write fd_sets
153	// for select()	195	// for select()
154	nfds = 0;	196	nfds = 0;
155	for (map<int,NetconP>::iterator it = m_polldata.begin();	197	for (map<int,NetconP>::iterator it = m_polldata.begin();
156	it != m_polldata.end(); it++) {	198	it != m_polldata.end(); it++) {
157	NetconP &pll = it->second;	199	NetconP &pll = it->second;
158	int fd = it->first;	200	int fd = it->first;
159	LOGDEB2(("Selectloop: fd %d flags 0x%x\n",fd, pll->m_wantedEvents));	201	LOGDEB2(("Selectloop: fd %d flags 0x%x\n",fd, pll->m_wantedEvents));
160	if (pll->m_wantedEvents & Netcon::NETCONPOLL_READ) {	202	if (pll->m_wantedEvents & Netcon::NETCONPOLL_READ) {
161	FD_SET(fd, &rd);	203	FD_SET(fd, &rd);
162	nfds = MAX(nfds, fd + 1);	204	nfds = MAX(nfds, fd + 1);
163	}	205	}
164	if (pll->m_wantedEvents & Netcon::NETCONPOLL_WRITE) {	206	if (pll->m_wantedEvents & Netcon::NETCONPOLL_WRITE) {
165	FD_SET(fd, &wd);	207	FD_SET(fd, &wd);
166	nfds = MAX(nfds, fd + 1);	208	nfds = MAX(nfds, fd + 1);
167	}	209	}
168	}	210	}
169		211
170	if (nfds == 0) {	212	if (nfds == 0) {
171	// This should never happen in a server as we should at least	213	// This should never happen in a server as we should at least
172	// always monitor the main listening server socket. For a	214	// always monitor the main listening server socket. For a
173	// client, it's up to client code to avoid or process this	215	// client, it's up to client code to avoid or process this
174	// condition.	216	// condition.
175		217
176	// Just in case there would still be open fds in there	218	// Just in case there would still be open fds in there
177	// (with no r/w flags set). Should not be needed, but safer	219	// (with no r/w flags set). Should not be needed, but safer
178	m_polldata.clear();	220	m_polldata.clear();
179	LOGDEB1(("Netcon::selectloop: no fds\n"));	221	LOGDEB1(("Netcon::selectloop: no fds\n"));
180	return 0;	222	return 0;
181	}	223	}
182		224
183	LOGDEB2(("Netcon::selectloop: selecting, nfds = %d\n", nfds));	225	LOGDEB2(("Netcon::selectloop: selecting, nfds = %d\n", nfds));
184		226
185	// Compute the next timeout according to what might need to be	227	// Compute the next timeout according to what might need to be
186	// done apart from waiting for data	228	// done apart from waiting for data
187	struct timeval tv;	229	struct timeval tv;
188	periodictimeout(&tv);	230	periodictimeout(&tv);
189	// Wait for something to happen	231	// Wait for something to happen
190	int ret = select(nfds, &rd, &wd, 0, &tv);	232	int ret = select(nfds, &rd, &wd, 0, &tv);
191	LOGDEB2(("Netcon::selectloop: select returns %d\n", ret));	233	LOGDEB2(("Netcon::selectloop: select returns %d\n", ret));
192	if (ret < 0) {	234	if (ret < 0) {
193	LOGSYSERR("Netcon::selectloop", "select", "");	235	LOGSYSERR("Netcon::selectloop", "select", "");
194	return -1;	236	return -1;
195	}	237	}
196	if (m_periodicmillis > 0)	238	if (m_periodicmillis > 0)
197	if (maybecallperiodic() <= 0)	239	if (maybecallperiodic() <= 0) {
198	return 1;	240	return 1;
		241	}
199		242
200	// Timeout, do it again.	243	// Timeout, do it again.
201	if (ret == 0)	244	if (ret == 0) {
202	continue;	245	continue;
		246	}
203		247
204	// We don't start the fd sweep at 0, else some fds would be advantaged.	248	// We don't start the fd sweep at 0, else some fds would be advantaged.
205	// Note that we do an fd sweep, not a map sweep. This is	249	// Note that we do an fd sweep, not a map sweep. This is
206	// inefficient because the fd array may be very sparse. Otoh, the	250	// inefficient because the fd array may be very sparse. Otoh, the
207	// map may change between 2 sweeps, so that we'd have to be smart	251	// map may change between 2 sweeps, so that we'd have to be smart
208	// with the iterator. As the cost per unused fd is low (just 2 bit	252	// with the iterator. As the cost per unused fd is low (just 2 bit
209	// flag tests), we keep it like this for now	253	// flag tests), we keep it like this for now
210	if (m_placetostart >= nfds)	254	if (m_placetostart >= nfds) {
211	m_placetostart = 0;	255	m_placetostart = 0;
212	int i, fd;	256	}
		257	int i, fd;
213	for (i = 0, fd = m_placetostart; i < nfds;i++, fd++) {	258	for (i = 0, fd = m_placetostart; i < nfds; i++, fd++) {
214	if (fd >= nfds)	259	if (fd >= nfds) {
215	fd = 0;	260	fd = 0;
		261	}
216		262
217	int canread = FD_ISSET(fd, &rd);	263	int canread = FD_ISSET(fd, &rd);
218	int canwrite = FD_ISSET(fd, &wd);	264	int canwrite = FD_ISSET(fd, &wd);
219	bool none = !canread && !canwrite;	265	bool none = !canread && !canwrite;
220	LOGDEB2(("Netcon::selectloop: fd %d %s %s %s\n", fd,	266	LOGDEB2(("Netcon::selectloop: fd %d %s %s %s\n", fd,
221	none ? "blocked" : "can" , canread ? "read" : "",	267	none ? "blocked" : "can" , canread ? "read" : "",
222	canwrite ? "write" : ""));	268	canwrite ? "write" : ""));
223	if (none)	269	if (none) {
224	continue;	270	continue;
		271	}
225		272
226	map<int,NetconP>::iterator it = m_polldata.find(fd);	273	map<int,NetconP>::iterator it = m_polldata.find(fd);
227	if (it == m_polldata.end()) {	274	if (it == m_polldata.end()) {
228	/// This should not happen actually	275	/// This should not happen actually
229	LOGDEB2(("Netcon::selectloop: fd %d not found\n", fd));	276	LOGDEB2(("Netcon::selectloop: fd %d not found\n", fd));
230	continue;	277	continue;
231	}	278	}
232		279
233	// Next start will be one beyond last serviced (modulo nfds)	280	// Next start will be one beyond last serviced (modulo nfds)
234	m_placetostart = fd + 1;	281	m_placetostart = fd + 1;
235	NetconP &pll = it->second;	282	NetconP &pll = it->second;
236	if (canread && pll->cando(Netcon::NETCONPOLL_READ) <= 0)	283	if (canread && pll->cando(Netcon::NETCONPOLL_READ) <= 0) {
237	pll->m_wantedEvents &= ~Netcon::NETCONPOLL_READ;	284	pll->m_wantedEvents &= ~Netcon::NETCONPOLL_READ;
		285	}
238	if (canwrite && pll->cando(Netcon::NETCONPOLL_WRITE) <= 0)	286	if (canwrite && pll->cando(Netcon::NETCONPOLL_WRITE) <= 0) {
239	pll->m_wantedEvents &= ~Netcon::NETCONPOLL_WRITE;	287	pll->m_wantedEvents &= ~Netcon::NETCONPOLL_WRITE;
		288	}
240	if (!(pll->m_wantedEvents & (Netcon::NETCONPOLL_WRITE\|Netcon::NETCONPOLL_READ))) {	289	if (!(pll->m_wantedEvents & (Netcon::NETCONPOLL_WRITE\|Netcon::NETCONPOLL_READ))) {
241	LOGDEB0(("Netcon::selectloop: fd %d has 0x%x mask, erasing\n",	290	LOGDEB0(("Netcon::selectloop: fd %d has 0x%x mask, erasing\n",
242	it->first, it->second->m_wantedEvents));	291	it->first, it->second->m_wantedEvents));
243	m_polldata.erase(it);	292	m_polldata.erase(it);
244	}	293	}
245	} // fd sweep	294	} // fd sweep
246		295
247	} // forever loop	296	} // forever loop
248	LOGERR(("SelectLoop::doLoop: got out of loop !\n"));	297	LOGERR(("SelectLoop::doLoop: got out of loop !\n"));
249	return -1;	298	return -1;
250	}	299	}
251		300
252	// Add a connection to the monitored set.	301	// Add a connection to the monitored set.
253	int SelectLoop::addselcon(NetconP con, int events)	302	int SelectLoop::addselcon(NetconP con, int events)
254	{	303	{
255	if (con.isNull()) return -1;	304	if (!con) {
		305	return -1;
		306	}
256	LOGDEB1(("Netcon::addselcon: fd %d\n", con->m_fd));	307	LOGDEB1(("Netcon::addselcon: fd %d\n", con->m_fd));
257	con->set_nonblock(1);	308	con->set_nonblock(1);
258	con->setselevents(events);	309	con->setselevents(events);
259	m_polldata[con->m_fd] = con;	310	m_polldata[con->m_fd] = con;
260	con->setloop(this);	311	con->setloop(this);
	...		...
262	}	313	}
263		314
264	// Remove a connection from the monitored set.	315	// Remove a connection from the monitored set.
265	int SelectLoop::remselcon(NetconP con)	316	int SelectLoop::remselcon(NetconP con)
266	{	317	{
267	if (con.isNull()) return -1;	318	if (!con) {
		319	return -1;
		320	}
268	LOGDEB1(("Netcon::remselcon: fd %d\n", con->m_fd));	321	LOGDEB1(("Netcon::remselcon: fd %d\n", con->m_fd));
269	map<int,NetconP>::iterator it = m_polldata.find(con->m_fd);	322	map<int,NetconP>::iterator it = m_polldata.find(con->m_fd);
270	if (it == m_polldata.end()) {	323	if (it == m_polldata.end()) {
271	LOGDEB1(("Netcon::remselcon: con not found for fd %d\n", con->m_fd));	324	LOGDEB1(("Netcon::remselcon: con not found for fd %d\n", con->m_fd));
272	return -1;	325	return -1;
273	}	326	}
274	con->setloop(0);	327	con->setloop(0);
275	m_polldata.erase(it);	328	m_polldata.erase(it);
276	return 0;	329	return 0;
277	}	330	}
278		331
279	//////////////////////////////////////////////////////////	332	//////////////////////////////////////////////////////////
280	// Base class (Netcon) methods	333	// Base class (Netcon) methods
281	Netcon::~Netcon() {	334	Netcon::~Netcon()
		335	{
282	closeconn();	336	closeconn();
283	if (m_peer) {	337	if (m_peer) {
284	free(m_peer);	338	free(m_peer);
285	m_peer = 0;	339	m_peer = 0;
286	}	340	}
287	}	341	}
288		342
289	void Netcon::closeconn()	343	void Netcon::closeconn()
290	{	344	{
291	if (m_ownfd && m_fd >= 0) {	345	if (m_ownfd && m_fd >= 0) {
292	close(m_fd);	346	close(m_fd);
293	}	347	}
294	m_fd = -1;	348	m_fd = -1;
295	m_ownfd = true;	349	m_ownfd = true;
296	}	350	}
297		351
	...		...
300	return strerror(errno);	354	return strerror(errno);
301	}	355	}
302		356
303	void Netcon::setpeer(const char *hostname)	357	void Netcon::setpeer(const char *hostname)
304	{	358	{
305	if (m_peer)	359	if (m_peer) {
306	free(m_peer);	360	free(m_peer);
		361	}
307	m_peer = strdup(hostname);	362	m_peer = strdup(hostname);
308	}	363	}
309		364
310	int Netcon::settcpnodelay(int on)	365	int Netcon::settcpnodelay(int on)
311	{	366	{
312	LOGDEB2(( "Netcon::settcpnodelay\n" ));	367	LOGDEB2(( "Netcon::settcpnodelay\n" ));
313	if (m_fd < 0) {	368	if (m_fd < 0) {
314	LOGERR(("Netcon::settcpnodelay: connection not opened\n"));	369	LOGERR(("Netcon::settcpnodelay: connection not opened\n"));
315	return -1;	370	return -1;
316	}	371	}
317	char cp = on ? (char )&one : (char *)&zero;	372	char cp = on ? (char )&one : (char *)&zero;
318	if (setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, cp, sizeof(one)) < 0) {	373	if (setsockopt(m_fd, IPPROTO_TCP, TCP_NODELAY, cp, sizeof(one)) < 0) {
319	LOGSYSERR("NetconCli::settcpnodelay", "setsockopt", "TCP_NODELAY");	374	LOGSYSERR("NetconCli::settcpnodelay", "setsockopt", "TCP_NODELAY");
320	return -1;	375	return -1;
321	}	376	}
322	return 0;	377	return 0;
323	}	378	}
324		379
325	// Set/reset non-blocking flag on fd	380	// Set/reset non-blocking flag on fd
326	int Netcon::set_nonblock(int onoff)	381	int Netcon::set_nonblock(int onoff)
327	{	382	{
328	int flags = fcntl(m_fd, F_GETFL, 0);	383	int flags = fcntl(m_fd, F_GETFL, 0);
329	if (flags != -1 ) {	384	if (flags != -1 ) {
330	int newflags = onoff ? flags \| O_NONBLOCK : flags & ~O_NONBLOCK;	385	int newflags = onoff ? flags \| O_NONBLOCK : flags & ~O_NONBLOCK;
331	if (newflags != flags)	386	if (newflags != flags)
332	if (fcntl(m_fd, F_SETFL, newflags)< 0)	387	if (fcntl(m_fd, F_SETFL, newflags) < 0) {
333	return -1;	388	return -1;
		389	}
334	}	390	}
335	return flags;	391	return flags;
336	}	392	}
337		393
338	/////////////////////////////////////////////////////////////////////	394	/////////////////////////////////////////////////////////////////////
339	// Data socket (NetconData) methods	395	// Data socket (NetconData) methods
340		396
341	NetconData::~NetconData() {	397	NetconData::~NetconData()
		398	{
342	freeZ(m_buf);	399	freeZ(m_buf);
343	m_bufbase = 0;	400	m_bufbase = 0;
344	m_bufbytes = m_bufsize = 0;	401	m_bufbytes = m_bufsize = 0;
345	}	402	}
346		403
347	int NetconData::send(const char *buf, int cnt, int expedited)	404	int NetconData::send(const char *buf, int cnt, int expedited)
348	{	405	{
349	LOGDEB2(("NetconData::send: fd %d cnt %d expe %d\n", m_fd, cnt, expedited));	406	LOGDEB2(("NetconData::send: fd %d cnt %d expe %d\n", m_fd, cnt, expedited));
350	int flag = 0;	407	int flag = 0;
351	if (m_fd < 0) {	408	if (m_fd < 0) {
352	LOGERR(("NetconData::send: connection not opened\n"));	409	LOGERR(("NetconData::send: connection not opened\n"));
353	return -1;	410	return -1;
354	}	411	}
355	if (expedited) {	412	if (expedited) {
356	LOGDEB2(("NetconData::send: expedited data, count %d bytes\n", cnt));	413	LOGDEB2(("NetconData::send: expedited data, count %d bytes\n", cnt));
357	flag = MSG_OOB;	414	flag = MSG_OOB;
358	}	415	}
359	int ret;	416	int ret;
360	// There is a bug in the uthread version of sendto() in FreeBSD at	417	// There is a bug in the uthread version of sendto() in FreeBSD at
361	// least up to 2.2.7, so avoid using it when possible	418	// least up to 2.2.7, so avoid using it when possible
362	if (flag)	419	if (flag) {
363	ret = ::send(m_fd, buf, cnt, flag);	420	ret = ::send(m_fd, buf, cnt, flag);
364	else	421	} else {
365	ret = ::write(m_fd, buf, cnt);	422	ret = ::write(m_fd, buf, cnt);
		423	}
366		424
367	// Note: byte count may be different from cnt if fd is non-blocking	425	// Note: byte count may be different from cnt if fd is non-blocking
368	if (ret < 0) {	426	if (ret < 0) {
369	char fdcbuf[20];sprintf(fdcbuf, "%d", m_fd);	427	char fdcbuf[20];
		428	sprintf(fdcbuf, "%d", m_fd);
370	LOGSYSERR("NetconData::send", "send", fdcbuf);	429	LOGSYSERR("NetconData::send", "send", fdcbuf);
371	}	430	}
372	return ret;	431	return ret;
373	}	432	}
374		433
375	// Test for data available	434	// Test for data available
376	int NetconData::readready()	435	int NetconData::readready()
377	{	436	{
378	LOGDEB2(("NetconData::readready\n"));	437	LOGDEB2(("NetconData::readready\n"));
379	if (m_fd < 0) {	438	if (m_fd < 0) {
380	LOGERR(("NetconData::readready: connection not opened\n"));	439	LOGERR(("NetconData::readready: connection not opened\n"));
381	return -1;	440	return -1;
382	}	441	}
383	return select1(m_fd, 0);	442	return select1(m_fd, 0);
384	}	443	}
385		444
386	// Test for writable	445	// Test for writable
387	int NetconData::writeready()	446	int NetconData::writeready()
388	{	447	{
389	LOGDEB2(("NetconData::writeready\n"));	448	LOGDEB2(("NetconData::writeready\n"));
390	if (m_fd < 0) {	449	if (m_fd < 0) {
391	LOGERR(("NetconData::writeready: connection not opened\n"));	450	LOGERR(("NetconData::writeready: connection not opened\n"));
392	return -1;	451	return -1;
393	}	452	}
394	return select1(m_fd, 0, 1);	453	return select1(m_fd, 0, 1);
395	}	454	}
396		455
397	// Receive at most cnt bytes (maybe less)	456	// Receive at most cnt bytes (maybe less)
398	int NetconData::receive(char *buf, int cnt, int timeo)	457	int NetconData::receive(char *buf, int cnt, int timeo)
399	{	458	{
400	LOGDEB2(("NetconData::receive: cnt %d timeo %d m_buf 0x%x m_bufbytes %d\n",	459	LOGDEB2(("NetconData::receive: cnt %d timeo %d m_buf 0x%x m_bufbytes %d\n",
401	cnt, timeo, m_buf, m_bufbytes));	460	cnt, timeo, m_buf, m_bufbytes));
402	if (m_fd < 0) {	461	if (m_fd < 0) {
403	LOGERR(("NetconData::receive: connection not opened\n"));	462	LOGERR(("NetconData::receive: connection not opened\n"));
404	return -1;	463	return -1;
405	}	464	}
406	int fromibuf = 0;	465	int fromibuf = 0;
407	// Get whatever might have been left in the buffer by a previous	466	// Get whatever might have been left in the buffer by a previous
408	// getline, except if we're called to fill the buffer of course	467	// getline, except if we're called to fill the buffer of course
409	if (m_buf && m_bufbytes > 0 && (buf < m_buf \|\| buf > m_buf + m_bufsize)) {	468	if (m_buf && m_bufbytes > 0 && (buf < m_buf \|\| buf > m_buf + m_bufsize)) {
410	fromibuf = MIN(m_bufbytes, cnt);	469	fromibuf = MIN(m_bufbytes, cnt);
411	memcpy(buf, m_bufbase, fromibuf);	470	memcpy(buf, m_bufbase, fromibuf);
412	m_bufbytes -= fromibuf;	471	m_bufbytes -= fromibuf;
413	m_bufbase += fromibuf;	472	m_bufbase += fromibuf;
414	cnt -= fromibuf;	473	cnt -= fromibuf;
415	LOGDEB2(("NetconData::receive: transferred %d from mbuf\n", fromibuf));	474	LOGDEB2(("NetconData::receive: transferred %d from mbuf\n", fromibuf));
416	if (cnt <= 0)	475	if (cnt <= 0) {
417	return fromibuf;	476	return fromibuf;
		477	}
418	}	478	}
419	if (timeo > 0) {	479	if (timeo > 0) {
420	int ret = select1(m_fd, timeo);	480	int ret = select1(m_fd, timeo);
421	if (ret == 0) {	481	if (ret == 0) {
422	LOGDEB2(("NetconData::receive timed out\n"));	482	LOGDEB2(("NetconData::receive timed out\n"));
423	m_didtimo = 1;	483	m_didtimo = 1;
424	return -1;	484	return -1;
425	}	485	}
426	if (ret < 0) {	486	if (ret < 0) {
427	LOGSYSERR("NetconData::receive", "select", "");	487	LOGSYSERR("NetconData::receive", "select", "");
428	return -1;	488	return -1;
429	}	489	}
430	}	490	}
431	m_didtimo = 0;	491	m_didtimo = 0;
432	if ((cnt = read(m_fd, buf + fromibuf, cnt)) < 0) {	492	if ((cnt = read(m_fd, buf + fromibuf, cnt)) < 0) {
433	char fdcbuf[20];sprintf(fdcbuf, "%d", m_fd);	493	char fdcbuf[20];
		494	sprintf(fdcbuf, "%d", m_fd);
434	LOGSYSERR("NetconData::receive", "read", fdcbuf);	495	LOGSYSERR("NetconData::receive", "read", fdcbuf);
435	return -1;	496	return -1;
436	}	497	}
437	LOGDEB2(("NetconData::receive: normal return, cnt %d\n", cnt));	498	LOGDEB2(("NetconData::receive: normal return, cnt %d\n", cnt));
438	return fromibuf + cnt;	499	return fromibuf + cnt;
439	}	500	}
440		501
	...		...
443	{	504	{
444	int got, cur;	505	int got, cur;
445	LOGDEB2(("Netcon::doreceive: cnt %d, timeo %d\n", cnt, timeo));	506	LOGDEB2(("Netcon::doreceive: cnt %d, timeo %d\n", cnt, timeo));
446	cur = 0;	507	cur = 0;
447	while (cnt > cur) {	508	while (cnt > cur) {
448	got = receive(buf, cnt-cur, timeo);	509	got = receive(buf, cnt-cur, timeo);
449	LOGDEB2(("Netcon::doreceive: got %d\n", got));	510	LOGDEB2(("Netcon::doreceive: got %d\n", got));
450	if (got < 0) {	511	if (got < 0) {
451	return -1;	512	return -1;
452	}	513	}
453	if (got == 0) {	514	if (got == 0) {
454	return cur;	515	return cur;
455	}	516	}
456	cur += got;	517	cur += got;
457	buf += got;	518	buf += got;
458	}	519	}
459	return cur;	520	return cur;
460	}	521	}
461		522
462	// Read data until cnt-1 characters are read or a newline is found. Add	523	// Read data until cnt-1 characters are read or a newline is found. Add
	...		...
470	static const int defbufsize = 200;	531	static const int defbufsize = 200;
471	int NetconData::getline(char *buf, int cnt, int timeo)	532	int NetconData::getline(char *buf, int cnt, int timeo)
472	{	533	{
473	LOGDEB2(("NetconData::getline: cnt %d, timeo %d\n", cnt, timeo));	534	LOGDEB2(("NetconData::getline: cnt %d, timeo %d\n", cnt, timeo));
474	if (m_buf == 0) {	535	if (m_buf == 0) {
475	if ((m_buf = (char *)malloc(defbufsize)) == 0) {	536	if ((m_buf = (char *)malloc(defbufsize)) == 0) {