tris/recoll
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
recoll/src/utils/netcon.cpp
dockes 6bfdc232d1 Execmd: added count parameter to receive(), and new getline() function 
Netcon: fix receive() to properly handle the case where there is initially
   data in the line buffer
2009-10-09 13:34:18 +00:00

1193 lines
30 KiB
C++
Raw Blame History

#ifndef lint
static char rcsid [] = "@(#$Id: netcon.cpp,v 1.18 2009-02-06 06:27:08 dockes Exp $ (C) 2002 Jean-Francois Dockes";
#endif
// Wrapper classes for the socket interface
#ifndef TEST_NETCON
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#ifdef _AIX
#include <strings.h>
#endif // _AIX
#include <unistd.h>
#include <fcntl.h>
#include <sys/time.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <netdb.h>
#include <map>
#ifndef NO_NAMESPACES
using namespace std;
#endif
#include "debuglog.h"
#include "netcon.h"
#ifndef SOCKLEN_T
#define SOCKLEN_T socklen_t
#endif
// Need &one, &zero for setsockopt...
static const int one = 1;
static const int zero = 0;
#define LOGSYSERR(who, call, spar) \
LOGERR(("%s: %s(%s) errno %d (%s)\n", who, call, \
spar, errno, strerror(errno)))
#ifndef MIN
#define MIN(a,b) (a<b?a:b)
#endif
#ifndef MAX
#define MAX(a,b) (a>b?a:b)
#endif
#ifndef freeZ
#define freeZ(X) if (X) {free(X);X=0;}
#endif
#define MILLIS(OLD, NEW) ( (long)(((NEW).tv_sec - (OLD).tv_sec) * 1000 + \
((NEW).tv_usec - (OLD).tv_usec) / 1000))
// Static method
// Simplified interface to 'select()'. Only use one fd, for either
// reading or writing. This is only used when not using the
// selectloop() style of network i/o.
// Note that timeo == 0 does NOT mean wait forever but no wait at all.
int Netcon::select1(int fd, int timeo, int write)
{
int ret;
struct timeval tv;
fd_set rd;
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;
}
// The select loop mechanism allows several netcons to be used for io
// in a program without blocking as long as there is data to be read
// or written.
// Set by client callback to tell selectloop to return.
bool Netcon::o_selectloopDoReturn;
int Netcon::o_selectloopReturnValue;
// Other static data for the selectloop mecanism
// Could be declared as static members, but I don't see any advantage
// to it as all code in this file is in Netcon:: anyway.
// Map of NetconP indexed by fd
static map<int, NetconP> polldata;
// The last time we did the periodic thing
static struct timeval lasthdlcall;
// The call back function and its parameter
static int (*periodichandler)(void *);
static void *periodicparam;
// The periodic interval
static int periodicmillis;
void Netcon::setperiodichandler(int (*handler)(void *), void *p, int ms)
{
periodichandler = handler;
periodicparam = p;
periodicmillis = ms;
if (periodicmillis > 0)
gettimeofday(&lasthdlcall, 0);
}
// Compute the appropriate timeout so that the select call returns in
// time to call the periodic routine.
static void 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 (periodicmillis <= 0) {
tv->tv_sec = 10000;
tv->tv_usec = 0;
return;
}
struct timeval mtv;
gettimeofday(&mtv, 0);
int millis = periodicmillis - MILLIS(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
static int maybecallperiodic()
{
if (periodicmillis <= 0)
return 1;
struct timeval mtv;
gettimeofday(&mtv, 0);
int millis = periodicmillis - MILLIS(lasthdlcall, mtv);
if (millis <= 0) {
gettimeofday(&lasthdlcall, 0);
if (periodichandler)
return periodichandler(periodicparam);
else
return 0;
}
return 1;
}
int Netcon::selectloop()
{
static int placetostart;
for (;;) {
if (o_selectloopDoReturn) {
o_selectloopDoReturn = false;
LOGDEB(("Netcon::selectloop: returning on request\n"));
return o_selectloopReturnValue;
}
int nfds;
fd_set rd, wd;
FD_ZERO(&rd);
FD_ZERO(&wd);
// Look for all descriptors in the map and set up the read and
// write fd_sets for select()
nfds = 0;
for (map<int,NetconP>::iterator it = polldata.begin();
it != 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 & NETCONPOLL_READ) {
FD_SET(fd, &rd);
nfds = MAX(nfds, fd + 1);
}
if (pll->m_wantedEvents & 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
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 (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 (placetostart >= nfds)
placetostart = 0;
int i, fd;
for (i = 0, fd = 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 = polldata.find(fd);
if (it == 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)
placetostart = fd + 1;
NetconP &pll = it->second;
if (canread && pll->cando(NETCONPOLL_READ) <= 0)
pll->m_wantedEvents &= ~NETCONPOLL_READ;
if (canwrite && pll->cando(NETCONPOLL_WRITE) <= 0)
pll->m_wantedEvents &= ~NETCONPOLL_WRITE;
if (!(pll->m_wantedEvents & (NETCONPOLL_WRITE|NETCONPOLL_READ))) {
LOGDEB0(("Netcon::selectloop: fd %d has 0x%x mask, erasing\n",
it->first, it->second->m_wantedEvents));
polldata.erase(it);
}
} // fd sweep
} // forever loop
LOGERR(("Netcon::selectloop: got out of loop !\n"));
return -1;
}
// Add a connection to the monitored set.
int Netcon::addselcon(NetconP con, int events)
{
if (con.isNull()) return -1;
LOGDEB1(("Netcon::addselcon: fd %d\n", con->m_fd));
con->set_nonblock(1);
con->setselevents(events);
polldata[con->m_fd] = con;
return 0;
}
// Remove a connection from the monitored set.
int Netcon::remselcon(NetconP con)
{
if (con.isNull()) return -1;
LOGDEB1(("Netcon::remselcon: fd %d\n", con->m_fd));
map<int,NetconP>::iterator it = polldata.find(con->m_fd);
if (it == polldata.end()) {
LOGDEB1(("Netcon::remselcon: con not found for fd %d\n", con->m_fd));
return -1;
}
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;
}
char *Netcon::sterror()
{
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[10];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[10];sprintf(fdcbuf, "%d", m_fd);
LOGSYSERR("NetconData::receive", "read", fdcbuf);
return -1;
}
LOGDEB2(("NetconData::receive: normal return, cnt %d\n", cnt));
return fromibuf + cnt;
}
// Receive exactly cnt bytes (except for timeout)
int NetconData::doreceive(char *buf, int cnt, int timeo)
{
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
// null char at end of buffer and return.
// As we don't know where the newline will be and it would be inefficient to
// read a character at a time, we use a buffer
// Unlike fgets, we return an integer status:
// >0: number of characters returned, not including the final 0
// 0: EOF reached, no chars transferred
// -1: error
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.isNull()) {
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;
}
///////////////////////////////////////////////////////////////////////
// Methods for a client connection (NetconCli)
int NetconCli::openconn(const char *host, unsigned int port, int timeo)
{
int ret = -1;
LOGDEB2(("Netconcli::openconn: host %s, port %d\n", host, port));
closeconn();
struct sockaddr_in saddr;
memset(&saddr, 0, sizeof(saddr));
saddr.sin_family = AF_INET;
saddr.sin_port = htons(port);
// Server name may be host name or IP address
int addr;
if ((addr = inet_addr(host)) != -1) {
memcpy(&saddr.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(&saddr.sin_addr, hp->h_addr, hp->h_length);
}
if ((m_fd = socket(AF_INET, SOCK_STREAM, 0)) < 0) {
LOGSYSERR("NetconCli::openconn", "socket", "");
return -1;
}
if (timeo > 0)
set_nonblock(1);
if(connect(m_fd,(struct sockaddr *) &saddr, sizeof(saddr)) < 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, char *serv, int timeo)
{
LOGDEB2(("Netconcli::openconn: host %s, serv %s\n", host, serv));
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);
}
int NetconCli::setconn(int fd)
{
LOGDEB2(("Netconcli::setconn: fd %d\n", fd));
closeconn();
m_fd = fd;
m_ownfd = false;
setpeer("");
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(char *serv, int backlog)
{
int port;
struct servent *servp;
LOGDEB1(("NetconServLis::openservice: serv %s\n", serv));
#ifdef NETCON_ACCESSCONTROL
if (initperms(serv) < 0)
return -1;
#endif
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);
}
// 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(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;
}
#endif /* NETCON_ACCESSCONTROL */
// Sample cando routine for server master connection: delete newly
// accepted connection. What else ?
// This is to be overriden by a derived class method for an application
// using the selectloop thing
int NetconServLis::cando(Netcon::Event reason)
{
delete accept();
return 1;
}
NetconServCon *
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;
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
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
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);
}
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 */
#else /* !TEST_NETCON */
/////////////////////////////////////////////////////////////////////////
////////// TEST DRIVER
////////////////////////////////////////////////////////////////////////
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <signal.h>
#include "debuglog.h"
#include "netcon.h"
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);
}
static int op_flags;
#define OPT_MOINS 0x1
#define OPT_s 0x2 /* Server */
#define OPT_c 0x4 /* Client */
#define OPT_n 0x8 /* Client sleeps forever */
extern int trycli(char *host, char *serv);
extern int tryserv(char *serv);
int nloop = 10;
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(DEBINFO);
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 int buflen = 1023;
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");
Netcon::selectloopReturn(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.isNull()) {
fprintf(stderr, "new NetconCli failed\n");
return 1;
}
if (clicon->openconn(host, serv) < 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);
Netcon::addselcon(con, Netcon::NETCONPOLL_WRITE);
fprintf(stderr, "client ready\n");
int ret = Netcon::selectloop();
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 {
protected:
int cando(Netcon::Event reason) {
NetconServCon *con = accept();
if (con == 0)
return -1;
RefCntr<NetconWorker> worker =
RefCntr<NetconWorker>(new ServNetconWorker());
con->setcallback(worker);
addselcon(NetconP(con), NETCONPOLL_READ);
return 1;
}
};
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);
MyNetconServLis *servlis = new MyNetconServLis();
lis = NetconP(servlis);
if (lis.isNull()) {
fprintf(stderr, "new NetconServLis failed\n");
return 1;
}
// Prepare for cleanup
struct sigaction sa;
sa.sa_flags = 0;
sa.sa_handler = onexit;
sigemptyset(&sa.sa_mask);
sigaction(SIGINT, &sa, 0);
sigaction(SIGQUIT, &sa, 0);
sigaction(SIGTERM, &sa, 0);
if (servlis->openservice(serv) < 0) {
fprintf(stderr, "openservice(%s) failed\n", serv);
return 1;
}
Netcon::addselcon(lis, Netcon::NETCONPOLL_READ);
fprintf(stderr, "openservice(%s) Ok\n", serv);
if (Netcon::selectloop() < 0) {
fprintf(stderr, "selectloop failed\n");
exit(1);
}
return 0;
}
#endif /* TEST_NETCON */
Reference in New Issue View Git Blame Copy Permalink