xref: /dports/irc/irc/irc2.11.2p3/ircd/s_bsd.c

/************************************************************************
 *   IRC - Internet Relay Chat, ircd/s_bsd.c
 *   Copyright (C) 1990 Jarkko Oikarinen and
 *                      University of Oulu, Computing Center
 *
 *   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 1, 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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

/* -- Jto -- 07 Jul 1990
 * Added jlp@hamblin.byu.edu's debugtty fix
 */

/* -- Armin -- Jun 18 1990
 * Added setdtablesize() for more socket connections
 * (sequent OS Dynix only) -- maybe select()-call must be changed ...
 */

/* -- Jto -- 13 May 1990
 * Added several fixes from msa:
 *   Better error messages
 *   Changes in check_access
 * Added SO_REUSEADDR fix from zessel@informatik.uni-kl.de
 */

#ifndef lint
static const volatile char rcsid[] = "@(#)$Id: s_bsd.c,v 1.187 2010/08/13 19:58:46 bif Exp $";
#endif

#include "os.h"
#include "s_defines.h"
#define S_BSD_C
#include "s_externs.h"
#undef S_BSD_C

#ifndef IN_LOOPBACKNET
#define IN_LOOPBACKNET	0x7f
#endif

aClient	*local[MAXCONNECTIONS];
FdAry	fdas, fdall;
int	highest_fd = 0, readcalls = 0, udpfd = -1, resfd = -1, adfd = -1;
time_t	timeofday;
static	struct	SOCKADDR_IN	mysk;
static	void	polludp(void);

static	struct	SOCKADDR *connect_inet (aConfItem *, aClient *, int *);
static	int	completed_connection (aClient *);
static	int	check_init (aClient *, char *);
static	int	check_ping (char *, int);
static	void	do_dns_async (void);
static	int	set_sock_opts (int, aClient *);
#ifdef	UNIXPORT
static	struct	SOCKADDR *connect_unix (aConfItem *, aClient *, int *);
static	aClient	*add_unixconnection (aClient *, int);
static	char	unixpath[256];
#endif
static	char	readbuf[READBUF_SIZE];

#define	CFLAG	(CONF_CONNECT_SERVER|CONF_ZCONNECT_SERVER)
#define	NFLAG	CONF_NOCONNECT_SERVER

/*
 * Try and find the correct name to use with getrlimit() for setting the max.
 * number of files allowed to be open by this process.
 */
#ifdef RLIMIT_FDMAX
# define RLIMIT_FD_MAX   RLIMIT_FDMAX
#else
# ifdef RLIMIT_NOFILE
#  define RLIMIT_FD_MAX RLIMIT_NOFILE
# else
#  ifdef RLIMIT_OPEN_MAX
#   define RLIMIT_FD_MAX RLIMIT_OPEN_MAX
#  else
#   undef RLIMIT_FD_MAX
#  endif
# endif
#endif

/*
** add_local_domain()
** Add the domain to hostname, if it is missing
** (as suggested by eps@TOASTER.SFSU.EDU)
** Note: size is the max we can append to hname!
*/

void	add_local_domain(char *hname, size_t size)
{
#ifdef RES_INIT
	/* some return plain hostname with ending dot, whoops. */
	if (hname[strlen(hname)-1] == '.')
	{
		hname[strlen(hname)-1] = '\0';
		size++;
	}
	/* try to fix up unqualified names */
	if (!index(hname, '.'))
	{
		if (!(ircd_res.options & RES_INIT))
		{
			Debug((DEBUG_DNS,"ircd_res_init()"));
			ircd_res_init();
		}
		/* Enough space in hname to append defdname? */
		/* "2" is dot and ending \0 */
		if (ircd_res.defdname[0] &&
			strlen(ircd_res.defdname) + 2 <= size)
		{
			/* no need for strncat with above check */
			(void)strcat(hname, ".");
			(void)strcat(hname, ircd_res.defdname);
		}
	}
#endif
	return;
}

/*
** Cannot use perror() within daemon. stderr is closed in
** ircd and cannot be used. And, worse yet, it might have
** been reassigned to a normal connection...
*/

/*
** report_error
**	This a replacement for perror(). Record error to log and
**	also send a copy to all *LOCAL* opers online.
**
**	text	is a *format* string for outputting error. It must
**		contain only two '%s', the first will be replaced
**		by the sockhost from the cptr, and the latter will
**		by strerror(errno).
**
**	cptr	if not NULL, is the *LOCAL* client associated with
**		the error.
*/
void	report_error(char *text, aClient *cptr)
{
	Reg	int	errtmp = errno; /* debug may change 'errno' */
	Reg	char	*host;
	int	err;
	SOCK_LEN_TYPE len = sizeof(err);
	char	fmbuf[BUFSIZE+1];
	aClient *bysptr = NULL;

	extern	char	*strerror(int);

	host = (cptr) ? get_client_name(cptr, FALSE) : "";

	Debug((DEBUG_ERROR, text, host, strerror(errtmp)));

	/*
	 * Get the *real* error from the socket (well try to anyway..).
	 * This may only work when SO_DEBUG is enabled but its worth the
	 * gamble anyway.
	 */
#ifdef	SO_ERROR
	if (cptr && !IsMe(cptr) && cptr->fd >= 0)
		if (!GETSOCKOPT(cptr->fd, SOL_SOCKET, SO_ERROR, &err, &len))
			if (err)
				errtmp = err;
#endif
	sendto_flag(SCH_ERROR, text, host, strerror(errtmp));
	if (cptr && (IsConnecting(cptr) || IsHandshake(cptr)) &&
		cptr->serv && cptr->serv->byuid[0])
	{
		bysptr = find_uid(cptr->serv->byuid, NULL);
		if (bysptr && !MyConnect(bysptr))
		{
			fmbuf[0] = '\0';
			strcpy(fmbuf, ":%s NOTICE %s :");
			strncat(fmbuf, text, BUFSIZE-strlen(fmbuf));
			sendto_one(bysptr, fmbuf, ME, bysptr->name,
				host, strerror(errtmp));
		}
	}
#ifdef USE_SYSLOG
	syslog(LOG_WARNING, text, host, strerror(errtmp));
#endif
	if (serverbooting)
	{
		fprintf(stderr,text,host,strerror(errtmp));
		fprintf(stderr,"\n");
	}
	return;
}

/*
 * inetport
 *
 * Create a socket in the AF_INET domain, bind it to the port given in
 * 'port' and listen to it. If 'ip' has a value, use it as vif to listen.
 * Connections are accepted to this socket depending on the IP# mask given
 * by 'ipmask'.  Returns the fd of the socket created or -1 on error.
 */
int	inetport(aClient *cptr, char *ip, char *ipmask, int port, int dolisten)
{
	static	struct SOCKADDR_IN server;
	int	ad[4];
	SOCK_LEN_TYPE len = sizeof(server);
	char	ipname[20];

	/* broken config? why allow such broken line to live?
	** XXX: fix initconf()? --B. */
	if (!ipmask)
	{
		sendto_flag(SCH_ERROR, "Invalid P-line");
		return -1;
	}
	ad[0] = ad[1] = ad[2] = ad[3] = 0;

	/*
	 * do it this way because building ip# from separate values for each
	 * byte requires endian knowledge or some nasty messing. Also means
	 * easy conversion of "*" to 0.0.0.0 or 134.* to 134.0.0.0 :-)
	 */
	(void)sscanf(ipmask, "%d.%d.%d.%d", &ad[0], &ad[1], &ad[2], &ad[3]);
	if (ad[0]>>8 || ad[1]>>8 || ad[2]>>8 || ad[3]>>8)
	{
		sendto_flag(SCH_ERROR, "Invalid ipmask %s", ipmask);
		return -1;
	}
	(void)sprintf(ipname, "%d.%d.%d.%d", ad[0], ad[1], ad[2], ad[3]);

	(void)sprintf(cptr->sockhost, "%-.42s.%u", ip ? ip : ME,
		      (unsigned int)port);
	DupString(cptr->auth, ipname);
	/*
	 * At first, open a new socket
	 */
	if (cptr->fd == -1)
		cptr->fd = socket(AFINET, SOCK_STREAM, 0);
	if (cptr->fd < 0)
	    {
		report_error("opening stream socket %s:%s", cptr);
		return -1;
	    }
	else if (cptr->fd >= MAXCLIENTS)
	    {
		sendto_flag(SCH_ERROR,
			    "No more connections allowed (%s)", cptr->name);
		(void)close(cptr->fd);
		return -1;
	    }
	(void)set_sock_opts(cptr->fd, cptr);
#if defined (__CYGWIN32__)
	/* Can anyone explain why setting nonblock here works and does not
	** in add_listener after we return from inetport()? --B. */
	(void)set_non_blocking(cptr->fd, cptr);
#endif
	/*
	 * Bind a port to listen for new connections if port is non-null,
	 * else assume it is already open and try get something from it.
	 */
	if (port)
	    {
		server.SIN_FAMILY = AFINET;
#ifdef INET6
		if (!ip || (!isxdigit(*ip) && *ip != ':'))
			server.sin6_addr = in6addr_any;
		else
			if(!inetpton(AF_INET6, ip, server.sin6_addr.s6_addr))
				bcopy(minus_one, server.sin6_addr.s6_addr,
				      IN6ADDRSZ);
#else
		if (!ip || !isdigit(*ip))
			server.sin_addr.s_addr = INADDR_ANY;
		else
			server.sin_addr.s_addr = inetaddr(ip);
#endif
		server.SIN_PORT = htons(port);
		/*
		 * Try 10 times to bind the socket with an interval of 20
		 * seconds. Do this so we don't have to keep trying manually
		 * to bind. Why ? Because a port that has closed often lingers
		 * around for a short time.
		 * This used to be the case.  Now it no longer is.
		 * Could cause the server to hang for too long - avalon
		 */
		if (bind(cptr->fd, (SAP)&server, sizeof(server)) == -1)
		    {
			report_error("binding stream socket %s:%s", cptr);
			(void)close(cptr->fd);
			return -1;
		    }
	    }

	if (getsockname(cptr->fd, (struct SOCKADDR *)&server, &len))
	    {
		report_error("getsockname failed for %s:%s",cptr);
		(void)close(cptr->fd);
		return -1;
	    }

	if (cptr == &me) /* KLUDGE to get it work... */
	    {
		char	buf[1024];

		(void)sprintf(buf, replies[RPL_MYPORTIS], ME, "*",
			ntohs(server.SIN_PORT));
		(void)write(0, buf, strlen(buf));
	    }

	if (cptr->fd > highest_fd)
		highest_fd = cptr->fd;
#ifdef INET6
	bcopy(server.sin6_addr.s6_addr, cptr->ip.s6_addr, IN6ADDRSZ);
#else
	cptr->ip.s_addr = server.sin_addr.s_addr; /* broken on linux at least*/
#endif
	cptr->port = port;
	local[cptr->fd] = cptr;
	if (dolisten)
	{
		listen(cptr->fd, LISTENQUEUE);
	}

	return 0;
}

/*
 * add_listener
 *
 * Create a new client which is essentially the stub like 'me' to be used
 * for a socket that is passive (listen'ing for connections to be accepted).
 */
int	add_listener(aConfItem *aconf)
{
	aClient	*cptr;

	cptr = make_client(NULL);
	cptr->flags = FLAGS_LISTEN;
	cptr->acpt = cptr;
	cptr->from = cptr;
	cptr->firsttime = time(NULL);
	cptr->name = ME;
	SetMe(cptr);


	cptr->confs = make_link();
	cptr->confs->next = NULL;
	cptr->confs->value.aconf = aconf;

	open_listener(cptr);
	/* Add to linked list */
	if (ListenerLL)
	{
		ListenerLL->prev = cptr;
	}
	cptr->next = ListenerLL;
	cptr->prev = NULL;
	ListenerLL = cptr;

	return 0;
}

#ifdef	UNIXPORT
/*
 * unixport
 *
 * Create a socket and bind it to a filename which is comprised of the path
 * (directory where file is placed) and port (actual filename created).
 * Set directory permissions as rwxr-xr-x so other users can connect to the
 * file which is 'forced' to rwxrwxrwx (different OS's have different need of
 * modes so users can connect to the socket).
 */
int	unixport(aClient *cptr, char *path, int port)
{
	struct sockaddr_un un;
	struct stat buf;

	if ((cptr->fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
	    {
		report_error("error opening unix domain socket %s:%s", cptr);
		return -1;
	    }
	else if (cptr->fd >= MAXCLIENTS)
	    {
		sendto_flag(SCH_ERROR,
			    "No more connections allowed (%s)", path);
		(void)close(cptr->fd);
		return -1;
	    }

	un.sun_family = AF_UNIX;
	(void)mkdir(path, 0755);
	sprintf(unixpath, "%s/%d", path, port);
	get_sockhost(cptr, unixpath);
	if (stat(unixpath, &buf)==0)
	{
		report_error("unix domain socket %s:%s", cptr);
		(void)close(cptr->fd);
		return -1;
	}
	strncpyzt(un.sun_path, unixpath, sizeof(un.sun_path));
	errno = 0;

	if (bind(cptr->fd, (SAP)&un, strlen(unixpath)+2) == -1)
	    {
		report_error("error binding unix socket %s:%s", cptr);
		(void)close(cptr->fd);
		return -1;
	    }
	if (cptr->fd > highest_fd)
		highest_fd = cptr->fd;
	(void)listen(cptr->fd, LISTENQUEUE);
	(void)chmod(path, 0755);
	(void)chmod(unixpath, 0777);
	SetUnixSock(cptr);
	cptr->port = 0;
	local[cptr->fd] = cptr;

	return 0;
}
#endif

/*
 * close_listeners
 *
 * Close and free all clients which are marked as having their socket open
 * and in a state where they can accept connections.  Unix sockets have
 * the path to the socket unlinked for cleanliness.
 */
void	close_listeners(void)
{
	aClient	*acptr, *bcptr;
	aConfItem *aconf;

	/*
	 * close all 'extra' listening ports we have and unlink the file
	 * name if it was a unix socket.
	 */
	for (acptr = ListenerLL; acptr; acptr = bcptr)
	{
		aconf = acptr->confs->value.aconf;
		bcptr = acptr->next; /* might get deleted by close_connection
				      */

		if (IsIllegal(aconf))
		{
#ifdef	UNIXPORT
			if (IsUnixSocket(acptr))
			{
				sprintf(unixpath, "%s/%d",
					aconf->host, aconf->port);
				(void)unlink(unixpath);
			}
#endif
			if (aconf->clients > 0)
			{
				close_client_fd(acptr);
			}
			else
			{
				close_connection(acptr);
			}
		}
	}
}

/* Opens listening socket on given listener */
void	open_listener(aClient *cptr)
{
	aConfItem *aconf;
	int dolisten = 1;

	aconf = cptr->confs->value.aconf;

	if (!IsListener(cptr) || cptr->fd > 0)
	{
		return;
	}

#ifdef	UNIXPORT
	if (*aconf->host == '/')
	{
		if (unixport(cptr, aconf->host, aconf->port))
		{
			cptr->fd = -1;
		}
	}
	else
#endif
	{
		if (IsConfDelayed(aconf) && !firstrejoindone)
		{
			dolisten = 0;
			SetListenerInactive(cptr);
		}
		if (inetport(cptr, aconf->host, aconf->name, aconf->port,
			dolisten))
		{
			/* to allow further inetport calls */
			cptr->fd = -1;
		}
	}

	if (cptr->fd >= 0)
	{
		add_fd(cptr->fd, &fdas);
		add_fd(cptr->fd, &fdall);
		set_non_blocking(cptr->fd, cptr);
	}
}

/* Reopens listening sockets on all listeners */
void	reopen_listeners(void)
{
	aClient *acptr;
	aConfItem *aconf;
	for (acptr = ListenerLL; acptr; acptr = acptr->next)
	{
		aconf = acptr->confs->value.aconf;
		if (!IsIllegal(aconf) && acptr->fd < 0)
		{
			open_listener(acptr);
		}
	}
}

void	activate_delayed_listeners(void)
{
	int cnt = 0;
	aClient *acptr;

	for (acptr = ListenerLL; acptr; acptr = acptr->next)
	{
		if (IsListenerInactive(acptr))
		{
			listen(acptr->fd, LISTENQUEUE);
			ClearListenerInactive(acptr);
			cnt++;
		}
	}

	if (cnt > 0)
	{
		sendto_flag(SCH_NOTICE, "%d listeners activated", cnt);
	}
}

void	start_iauth(int rcvdsig)
{
#if defined(USE_IAUTH)
	static time_t last = 0;
	static char first = 1;
	int sp[2], fd, val;
	static pid_t iauth_pid = 0;

	if ((bootopt & BOOT_NOIAUTH) != 0)
		return;
	if (rcvdsig == 2)
	{
		sendto_flag(SCH_AUTH, "Killing iauth...");
		if (iauth_pid)
			kill(iauth_pid, SIGTERM);
		iauth_pid = 0;
	}
	else
	if (adfd >= 0)
	    {
		if (rcvdsig)
			sendto_flag(SCH_AUTH,
			    "iauth is already running, restart canceled");
		return;
	    }
	if ((time(NULL) - last) > 90 || rcvdsig)
	    {
		sendto_flag(SCH_AUTH, "Starting iauth...");
		last = time(NULL);
		read_iauth(); /* to reset olen */
		iauth_spawn += 1;
	    }
	else
		return;
	if (socketpair(AF_UNIX, SOCK_STREAM, 0, sp) < 0)
	    {
		sendto_flag(SCH_ERROR, "socketpair() failed!");
		sendto_flag(SCH_AUTH, "Failed to restart iauth!");
	    }
	adfd = sp[0];
	set_non_blocking(sp[0], NULL);
	set_non_blocking(sp[1], NULL); /* less to worry about in iauth */
	val = IAUTH_BUFFER;
	if (setsockopt(sp[0], SOL_SOCKET, SO_SNDBUF, (void *) &val,
	    sizeof(val)) < 0)
			sendto_flag(SCH_AUTH,
			    "IAUTH_BUFFER too big for sp0 sndbuf, using default");
	if (setsockopt(sp[1], SOL_SOCKET, SO_SNDBUF, (void *) &val,
	    sizeof(val)) < 0)
			sendto_flag(SCH_AUTH,
			    "IAUTH_BUFFER too big for sp1 sndbuf, using default");
	if (setsockopt(sp[0], SOL_SOCKET, SO_RCVBUF, (void *) &val,
	    sizeof(val)) < 0)
			sendto_flag(SCH_AUTH,
			    "IAUTH_BUFFER too big for sp0 rcvbuf, using default");
	if (setsockopt(sp[1], SOL_SOCKET, SO_RCVBUF, (void *) &val,
	    sizeof(val)) < 0)
			sendto_flag(SCH_AUTH,
			    "IAUTH_BUFFER too big for sp1 rcvbuf, using default");
	switch ((iauth_pid = vfork()))
	    {
		case -1:
			sendto_flag(SCH_ERROR, "vfork() failed!");
			sendto_flag(SCH_AUTH, "Failed to restart iauth!");
			close(sp[0]); close(sp[1]);
			adfd = -1;
			return;
		case 0:
			for (fd = 0; fd < MAXCONNECTIONS; fd++)
				if (fd != sp[1])
					(void)close(fd);
			if (sp[1] != 0)
			    {
				(void)dup2(sp[1], 0);
				close(sp[1]);
			    }
			if (execl(IAUTH_PATH, IAUTH, NULL) < 0)
				_exit(-1); /* should really not happen.. */
		default:
			close(sp[1]);
	    }

	if (first)
		first = 0;
	else
	{
		int i;
		aClient *cptr;
		char	abuf[BUFSIZ];	/* size of abuf in vsendto_iauth */
		/* 20 is biggest possible ending "%d O\n\0", which means
		** 16-digit fd -- very unlikely :> */
		char	*e = abuf + BUFSIZ - 20;
		char	*s = abuf;

		/* Build abuf to send big buffer once (or twice) to iauth,
		** which goes faster than many consecutive small writes.
		** BitKoenig claims it saves metadata overhead on Linux and
		** does not harm other systems --B. */
		for (i = 0; i <= highest_fd; i++)
		{
			if (!(cptr = local[i]))
				continue;
			if (IsServer(cptr) || IsService(cptr))
				continue;

			/* if not enough room in abuf, send whatever we have
			** now and start writing from begin of abuf again. */
			if (s > e)
			{
				/* sendto_iauth() appends "\n", so we
				** remove last one */
				*(s - 1) = '\0';
				sendto_iauth(abuf);
				s = abuf;
			}
			/* A little trick: we sprintf onto s and move s (which
			** points inside abuf) forward, at the end of s (number
			** of bytes returned by sprintf). This makes s always
			** point to the end of things written on abuf, which
			** allows both next sprintf at the end (no strcat!) and
			** removing last \n when needed. */
			s += sprintf(s, "%d O\n", i);
		}
		/* send the rest */
		if (s != abuf)
		{
			*(s - 1) = '\0';
			sendto_iauth(abuf);
		}
	}
#endif
}

/*
 * init_sys
 */
void	init_sys(void)
{
	Reg	int	fd;

#ifdef RLIMIT_FD_MAX
	struct rlimit limit;

	if (!getrlimit(RLIMIT_FD_MAX, &limit))
	    {
		if (limit.rlim_max < MAXCONNECTIONS)
		    {
			(void)fprintf(stderr, "ircd fd table is too big\n");
			(void)fprintf(stderr, "Hard Limit: %d IRC max: %d\n",
				      (int) limit.rlim_max, MAXCONNECTIONS);
			(void)fprintf(stderr,
				      "Fix MAXCONNECTIONS and recompile.\n");
			exit(-1);
		    }
		limit.rlim_cur = limit.rlim_max; /* make soft limit the max */
		if (setrlimit(RLIMIT_FD_MAX, &limit) == -1)
		    {
			(void)fprintf(stderr, "error setting max fd's to %d\n",
				      (int) limit.rlim_cur);
			exit(-1);
		    }
	    }
	/* Let's assume that if it has define for fd limit, then
	   it can do core limits, too. --B. */
	if (!getrlimit(RLIMIT_CORE, &limit))
	{
		limit.rlim_cur = limit.rlim_max;
		if (limit.rlim_cur != RLIM_INFINITY)
		{
			(void)fprintf(stderr, "warning: max core"
				" is not unlimited\n");
		}
		if (setrlimit(RLIMIT_CORE, &limit) == -1)
		{
			(void)fprintf(stderr, "error setting max core to %d\n",
				(int) limit.rlim_cur);
			exit(-1);
		}
	}
#endif
#if !defined(USE_POLL)
# ifdef sequent
#  ifndef	DYNIXPTX
	int	fd_limit;

	fd_limit = setdtablesize(MAXCONNECTIONS + 1);
	if (fd_limit < MAXCONNECTIONS)
	    {
		(void)fprintf(stderr,"ircd fd table too big\n");
		(void)fprintf(stderr,"Hard Limit: %d IRC max: %d\n",
			fd_limit, MAXCONNECTIONS);
		(void)fprintf(stderr,"Fix MAXCONNECTIONS\n");
		exit(-1);
	    }
#  endif
# endif
#endif /* USE_POLL */

#if defined(PCS) || defined(DYNIXPTX) || defined(SVR3)
	char	logbuf[BUFSIZ];

	(void)setvbuf(stderr,logbuf,_IOLBF,sizeof(logbuf));
#else
# if defined(HPUX)
	(void)setvbuf(stderr, NULL, _IOLBF, 0);
# else
#  if !defined(SVR4)
	(void)setlinebuf(stderr);
#  endif
# endif
#endif

	bzero((char *)&fdas, sizeof(fdas));
	bzero((char *)&fdall, sizeof(fdall));
	fdas.highest = fdall.highest = -1;
	/* we need stderr open, don't close() it, daemonize() will do it */
	/* after ircdwatch restarts ircd, we no longer have stderr, FIXME */
	local[0] = local[1] = local[2] = NULL;
	for (fd = 3; fd < MAXCONNECTIONS; fd++)
	{
		local[fd] = NULL;
		(void)close(fd);
	}
}

void	daemonize(void)
{
#ifdef TIOCNOTTY
	int fd;
#endif

	if (bootopt & BOOT_TTY)	/* debugging is going to a tty */
		goto init_dgram;

	(void)fclose(stdout);
	(void)close(1);

	if (!(bootopt & BOOT_DEBUG))
	{
		(void)fclose(stderr);
		(void)close(2);
	}

	if (((bootopt & BOOT_CONSOLE) || isatty(0)) &&
	    !(bootopt & BOOT_INETD))
	    {
		if (fork())
			exit(0);
#ifdef TIOCNOTTY
		if ((fd = open("/dev/tty", O_RDWR)) >= 0)
		    {
			(void)ioctl(fd, TIOCNOTTY, (char *)NULL);
			(void)close(fd);
		    }
#endif
#if defined(HPUX) || defined(SVR4) || defined(DYNIXPTX) || \
    defined(_POSIX_SOURCE) || defined(SGI)
		(void)setsid();
#elif defined (__CYGWIN32__) || defined(__APPLE__)
    		(void)setpgrp();
#else
		(void)setpgrp(0, (int)getpid());
#endif
		(void)fclose(stdin);
		(void)close(0);
	    }
init_dgram:
	resfd = init_resolver(0x1f);

	start_iauth(0);

}


void	write_pidfile(void)
{
	int fd;
	char buff[20];
	(void)truncate(IRCDPID_PATH, 0);
	if ((fd = open(IRCDPID_PATH, O_CREAT|O_WRONLY, 0600))>=0)
	    {
		bzero(buff, sizeof(buff));
		(void)sprintf(buff,"%5d\n", (int)getpid());
		if (write(fd, buff, strlen(buff)) == -1)
		{
			Debug((DEBUG_NOTICE,"Error writing to pid file %s",
			      IRCDPID_PATH));
		}
		(void)close(fd);
		return;
	    }
# ifdef	DEBUGMODE
	else
		Debug((DEBUG_NOTICE,"Error opening pid file %s",
			IRCDPID_PATH));
# endif
}

/*
 * Initialize the various name strings used to store hostnames. This is set
 * from either the server's sockhost (if client fd is a tty or localhost)
 * or from the ip# converted into a string. 0 = success, -1 = fail.
 */
static	int	check_init(aClient *cptr, char *sockn)
{
	struct	SOCKADDR_IN sk;
	SOCK_LEN_TYPE len = sizeof(struct SOCKADDR_IN);

#ifdef	UNIXPORT
	if (IsUnixSocket(cptr))
	    {
		strncpyzt(sockn, cptr->acpt->sockhost, HOSTLEN+1);
		get_sockhost(cptr, sockn);
		return 0;
	    }
#endif

	/* If descriptor is a tty, special checking... */
	if (isatty(cptr->fd))
	    {
		strncpyzt(sockn, me.sockhost, HOSTLEN);
		bzero((char *)&sk, sizeof(struct SOCKADDR_IN));
	    }
	else if (getpeername(cptr->fd, (SAP)&sk, &len) == -1)
	    {
		report_error("connect failure: %s %s", cptr);
		return -1;
	    }
#ifdef INET6
	inetntop(AF_INET6, (char *)&sk.sin6_addr, sockn, INET6_ADDRSTRLEN);
	Debug((DEBUG_DNS,"sockn %x",sockn));
	Debug((DEBUG_DNS,"sockn %s",sockn));
#else
	(void)strcpy(sockn, (char *)inetntoa((char *)&sk.sin_addr));
#endif
	bcopy((char *)&sk.SIN_ADDR, (char *)&cptr->ip, sizeof(struct IN_ADDR));
	cptr->port = ntohs(sk.SIN_PORT);

	return 0;
}

/*
 * Ordinary client access check. Look for conf lines which have the same
 * status as the flags passed.
 *  0 = Success
 * -1 = Bad socket.
 * -2 = Access denied
 */
int	check_client(aClient *cptr)
{
	char	sockname[HOSTLEN+1];
	Reg	struct	hostent *hp = NULL;
	Reg	int	i;

#ifdef INET6
	Debug((DEBUG_DNS, "ch_cl: check access for %s[%s]",
		cptr->name, inet_ntop(AF_INET6, (char *)&cptr->ip, ipv6string,
				      sizeof(ipv6string))));
#else
	Debug((DEBUG_DNS, "ch_cl: check access for %s[%s]",
		cptr->name, inetntoa((char *)&cptr->ip)));
#endif

	if (check_init(cptr, sockname))
		return -1;

#ifdef UNIXPORT
	if (!IsUnixSocket(cptr))
#endif
		hp = cptr->hostp;
	/*
	 * Verify that the host to ip mapping is correct both ways and that
	 * the ip#(s) for the socket is listed for the host.
	 */
	if (hp)
	    {
		for (i = 0; hp->h_addr_list[i]; i++)
			if (!bcmp(hp->h_addr_list[i], (char *)&cptr->ip,
				  sizeof(struct IN_ADDR)))
				break;
		if (!hp->h_addr_list[i])
		    {
#ifdef INET6
			sendto_flag(SCH_ERROR,
				    "IP# Mismatch: %s != %s[%08x%08x%08x%08x]",
				    inetntop(AF_INET6, (char *)&cptr->ip,
					      ipv6string,sizeof(ipv6string)), hp->h_name,
				    ((unsigned long *)hp->h_addr)[0],
				    ((unsigned long *)hp->h_addr)[1],
				    ((unsigned long *)hp->h_addr)[2],
				    ((unsigned long *)hp->h_addr)[3]);
#else
			sendto_flag(SCH_ERROR, "IP# Mismatch: %s != %s[%08x]",
				    inetntoa((char *)&cptr->ip), hp->h_name,
				    *((unsigned long *)hp->h_addr));
#endif
			hp = NULL;
			cptr->hostp = NULL;
		    }
	    }

	if ((i = attach_Iline(cptr, hp, sockname)))
	    {
		Debug((DEBUG_DNS,"ch_cl: access denied: %s[%s]",
			cptr->name, sockname));
		return i;
	    }

	Debug((DEBUG_DNS, "ch_cl: access ok: %s[%s]",
		cptr->name, sockname));

#ifdef NO_OPER_REMOTE
	if (
#ifdef UNIXPORT
		IsUnixSocket(cptr) ||
#endif
#ifdef INET6
		IN6_IS_ADDR_LOOPBACK(&cptr->ip) ||
		/* If s6_addr32 was standard, we could just compare them,
		 * not memcmp. --B. */
		!memcmp(cptr->ip.s6_addr, mysk.sin6_addr.s6_addr, 16)
#else
		inetnetof(cptr->ip) == IN_LOOPBACKNET ||
		cptr->ip.S_ADDR == mysk.SIN_ADDR.S_ADDR
#endif
		)
	{
		ircstp->is_loc++;
		cptr->flags |= FLAGS_LOCAL;
	}
#endif /* NO_OPER_REMOTE */
	return 0;
}

/*
 * check_server_init(), check_server()
 *	check access for a server given its name (passed in cptr struct).
 *	Must check for all C/N lines which have a name which matches the
 *	name given and a host which matches. A host alias which is the
 *	same as the server name is also acceptable in the host field of a
 *	C/N line.
 *  0 = Success
 * -1 = Access denied
 * -2 = Bad socket.
 */
int	check_server_init(aClient *cptr)
{
	Reg	char	*name;
	Reg	aConfItem *c_conf = NULL, *n_conf = NULL;
	struct	hostent	*hp = NULL;
	Link	*lp;

	name = cptr->name;
	Debug((DEBUG_DNS, "sv_cl: check access for %s[%s]",
		name, cptr->sockhost));

	if (IsUnknown(cptr) && !attach_confs(cptr, name, CFLAG|NFLAG))
	    {
		Debug((DEBUG_DNS,"No C/N lines for %s", name));
		return -1;
	    }
	lp = cptr->confs;
	/*
	 * We initiated this connection so the client should have a C and N
	 * line already attached after passing through the connec_server()
	 * function earlier.
	 */
	if (IsConnecting(cptr) || IsHandshake(cptr))
	    {
		c_conf = find_conf(lp, name, CFLAG);
		n_conf = find_conf(lp, name, NFLAG);
		if (!c_conf || !n_conf)
		    {
			sendto_flag(SCH_ERROR, "Connecting Error: %s[%s]",
				   name, cptr->sockhost);
			det_confs_butmask(cptr, 0);
			return -1;
		    }
	    }
#ifdef	UNIXPORT
	if (IsUnixSocket(cptr))
	    {
		if (!c_conf)
			c_conf = find_conf(lp, name, CFLAG);
		if (!n_conf)
			n_conf = find_conf(lp, name, NFLAG);
	    }
#endif

	/*
	** If the servername is a hostname, either an alias (CNAME) or
	** real name, then check with it as the host. Use gethostbyname()
	** to check for servername as hostname.
	*/
	if (!cptr->hostp
#ifdef UNIXPORT
		&& !IsUnixSocket(cptr)
#endif
		)
	    {
		Reg	aConfItem *aconf;

		aconf = count_cnlines(lp);
		if (aconf)
		    {
			Reg	char	*s;
			Link	lin;

			/*
			** Do a lookup for the CONF line *only* and not
			** the server connection else we get stuck in a
			** nasty state since it takes a SERVER message to
			** get us here and we can't interrupt that very
			** well.
			*/
			lin.value.aconf = aconf;
			lin.flags = ASYNC_CONF;
			nextdnscheck = 1;
			if ((s = index(aconf->host, '@')))
				s++;
			else
				s = aconf->host;
			Debug((DEBUG_DNS,"sv_ci:cache lookup (%s)",s));
			hp = gethost_byname(s, &lin);
		    }
	    }
	return check_server(cptr, hp, c_conf, n_conf);
}

int	check_server(aClient *cptr, struct hostent *hp,
		aConfItem *c_conf, aConfItem *n_conf)
{
	Reg	char	*name;
	char	abuff[HOSTLEN+USERLEN+2];
	char	sockname[HOSTLEN+1], fullname[HOSTLEN+1];
	Link	*lp = cptr->confs;
	int	i;

	if (check_init(cptr, sockname))
		return -2;

check_serverback:
	if (hp)
	    {
		for (i = 0; hp->h_addr_list[i]; i++)
			if (!bcmp(hp->h_addr_list[i], (char *)&cptr->ip,
				  sizeof(struct IN_ADDR)))
				break;
		if (!hp->h_addr_list[i])
		    {
#ifdef INET6
			sendto_flag(SCH_ERROR,
				    "IP# Mismatch: %s != %s[%08x%08x%08x%08x]",
				    inetntop(AF_INET6, (char *)&cptr->ip,
					      ipv6string, sizeof(ipv6string)),hp->h_name,
				    ((unsigned long *)hp->h_addr)[0],
				    ((unsigned long *)hp->h_addr)[1],
				    ((unsigned long *)hp->h_addr)[2],
				    ((unsigned long *)hp->h_addr)[3]);
#else
			sendto_flag(SCH_ERROR, "IP# Mismatch: %s != %s[%08x]",
				    inetntoa((char *)&cptr->ip), hp->h_name,
				    *((unsigned long *)hp->h_addr));
#endif
			hp = NULL;
		    }
	    }
	else if (cptr->hostp)
	    {
		hp = cptr->hostp;
		goto check_serverback;
	    }

	if (hp)
		/*
		 * if we are missing a C or N line from above, search for
		 * it under all known hostnames we have for this ip#.
		 */
		for (i=0,name = hp->h_name; name ; name = hp->h_aliases[i++])
		    {
			strncpyzt(fullname, name, sizeof(fullname));
			add_local_domain(fullname, HOSTLEN-strlen(fullname));
			Debug((DEBUG_DNS, "sv_cl: gethostbyaddr: %s->%s",
				sockname, fullname));
			sprintf(abuff, "%s@%s", cptr->username, fullname);
			if (!c_conf)
				c_conf = find_conf_host(lp, abuff, CFLAG);
			if (!n_conf)
				n_conf = find_conf_host(lp, abuff, NFLAG);
			if (c_conf && n_conf)
			    {
				get_sockhost(cptr, fullname);
				break;
			    }
		    }
	name = cptr->name;

	/*
	 * Check for C and N lines with the hostname portion the ip number
	 * of the host the server runs on. This also checks the case where
	 * there is a server connecting from 'localhost'.
	 */
	if (IsUnknown(cptr) && (!c_conf || !n_conf))
	    {
		sprintf(abuff, "%s@%s", cptr->username, sockname);
		if (!c_conf)
			c_conf = find_conf_host(lp, abuff, CFLAG);
		if (!n_conf)
			n_conf = find_conf_host(lp, abuff, NFLAG);
	    }
	/*
	 * Attach by IP# only if all other checks have failed.
	 * It is quite possible to get here with the strange things that can
	 * happen when using DNS in the way the irc server does. -avalon
	 */
	if (!hp)
	    {
		if (!c_conf)
			c_conf = find_conf_ip(lp, (char *)&cptr->ip,
					      cptr->username, CFLAG);
		if (!n_conf)
			n_conf = find_conf_ip(lp, (char *)&cptr->ip,
					      cptr->username, NFLAG);
	    }
	else
		for (i = 0; hp->h_addr_list[i]; i++)
		    {
			if (!c_conf)
				c_conf = find_conf_ip(lp, hp->h_addr_list[i],
						      cptr->username, CFLAG);
			if (!n_conf)
				n_conf = find_conf_ip(lp, hp->h_addr_list[i],
						      cptr->username, NFLAG);
		    }
	/*
	 * detach all conf lines that got attached by attach_confs()
	 */
	det_confs_butmask(cptr, 0);
	/*
	 * if no C or no N lines, then deny access
	 */
	if (!c_conf || !n_conf)
	    {
		get_sockhost(cptr, sockname);
		Debug((DEBUG_DNS, "sv_cl: access denied: %s[%s@%s] c %x n %x",
			name, cptr->auth, cptr->sockhost,
			c_conf, n_conf));
		return -1;
	    }
	/*
	 * attach the C and N lines to the client structure for later use.
	 */
	(void)attach_confs(cptr, name, CONF_HUB|CONF_LEAF);
	(void)attach_conf(cptr, n_conf);
	(void)attach_conf(cptr, c_conf);
	if (IsIllegal(n_conf) || IsIllegal(c_conf))
	{
		sendto_flag(SCH_DEBUG, "Illegal class!");
		return -2;
	}
	if (!n_conf->host || !c_conf->host)
	{
		sendto_flag(SCH_DEBUG, "Null host in class!");
		return -2;
	}

	if (
#ifdef INET6
		AND16(c_conf->ipnum.s6_addr) == 255
#else
		c_conf->ipnum.s_addr == -1
#endif
#ifdef UNIXPORT
		&& !IsUnixSocket(cptr)
#endif
		)
	{
		bcopy((char *)&cptr->ip, (char *)&c_conf->ipnum,
			sizeof(struct IN_ADDR));
	}
#ifdef UNIXPORT
	if (!IsUnixSocket(cptr))
#endif
		get_sockhost(cptr, c_conf->host);

	Debug((DEBUG_DNS,"sv_cl: access ok: %s[%s]",
		name, cptr->sockhost));
	return 0;
}

/*
** completed_connection
**	Complete non-blocking connect()-sequence. Check access and
**	terminate connection, if trouble detected.
**
**	Return	TRUE, if successfully completed
**		FALSE, if failed and ClientExit
*/
static	int completed_connection(aClient *cptr)
{
	aConfItem *aconf;

	SetHandshake(cptr);

	aconf = find_conf(cptr->confs, cptr->name, CFLAG);
	if (!aconf)
	    {
		sendto_flag(SCH_NOTICE,
			    "Lost C-Line for %s", get_client_name(cptr,FALSE));
		return -1;
	    }
	if (!BadPtr(aconf->passwd))
		sendto_one(cptr, "PASS %s %s IRC|%s %s%s%s", aconf->passwd,
			pass_version, serveropts,
			(bootopt & BOOT_STRICTPROT) ? "P" : "",
#ifdef JAPANESE
			"j",
#else
			"",
#endif
#ifdef ZIP_LINKS
			(aconf->status == CONF_ZCONNECT_SERVER) ? "Z" :
#endif
			""
			);

	aconf = find_conf(cptr->confs, cptr->name, CONF_NOCONNECT_SERVER);
	if (!aconf)
	    {
		sendto_flag(SCH_NOTICE,
			    "Lost N-Line for %s", get_client_name(cptr,FALSE));
		return -1;
	    }
	sendto_one(cptr, "SERVER %s 1 %s :%s",
		   my_name_for_link(ME, aconf->port), me.serv->sid, me.info);
	if (!IsDead(cptr))
	    {
		start_auth(cptr);
#if defined(USE_IAUTH)
		/*
		** This could become a bug.. but I don't think iauth needs the
		** hostname/aliases in this case. -kalt
		*/
		sendto_iauth("%d d", cptr->fd);
#endif
	    }

	return (IsDead(cptr)) ? -1 : 0;
}

/*
 * Closes FD in aClient structures.
 */
void close_client_fd(aClient *cptr)
{
	int i;

#ifdef SO_LINGER
	struct 	linger	sockling;

	sockling.l_onoff = 0;
#endif

	if (cptr->authfd >= 0)
	{
#ifdef	SO_LINGER
		if (cptr->exitc == EXITC_PING)
			if (SETSOCKOPT(cptr->authfd, SOL_SOCKET, SO_LINGER,
				       &sockling, sockling))
				report_error("setsockopt(SO_LINGER) %s:%s",
					     cptr);
#endif
		(void)close(cptr->authfd);

		cptr->authfd = -1;
	}

	if ((i = cptr->fd) >= 0)
	{
		flush_connections(i);
		if (IsServer(cptr) || IsListener(cptr))
		{
			del_fd(i, &fdas);
#ifdef	ZIP_LINKS
			/*
			** the connection might have zip data (even if
			** FLAGS_ZIP is not set)
			*/
			zip_free(cptr);
#endif
		}
		else if (IsClient(cptr))
		{
#ifdef	SO_LINGER
			if (cptr->exitc == EXITC_PING)
				if (SETSOCKOPT(i, SOL_SOCKET, SO_LINGER,
					       &sockling, sockling))
					report_error("setsockopt(SO_LINGER) %s:%s",
						     cptr);
#endif
		 }
		del_fd(i, &fdall);
		local[i] = NULL;
		(void)close(i);

		cptr->fd = -1;
		DBufClear(&cptr->sendQ);
		DBufClear(&cptr->recvQ);
		bzero(cptr->passwd, sizeof(cptr->passwd));
	}
}

/*
** close_connection
**	Close the physical connection. This function must make
**	MyConnect(cptr) == FALSE, and set cptr->from == NULL.
*/
void	close_connection(aClient *cptr)
{
	aConfItem *aconf;

	if (IsServer(cptr))
	{
		ircstp->is_sv++;
		ircstp->is_sbs += cptr->sendB;
		ircstp->is_sbr += cptr->receiveB;
		ircstp->is_sti += timeofday - cptr->firsttime;
	}
	else if (IsClient(cptr))
	{
		ircstp->is_cl++;
		ircstp->is_cbs += cptr->sendB;
		ircstp->is_cbr += cptr->receiveB;
		ircstp->is_cti += timeofday - cptr->firsttime;
	}
	else
	{
		ircstp->is_ni++;
	}

	/*
	 * remove outstanding DNS queries.
	 */
	del_queries((char *)cptr);
	/*
	 * If the server connection has been up for a long amount of time,
	 * schedule a 'quick' reconnect, else reset the next-connect cycle.
	 */
	if (IsServer(cptr) &&
		(aconf = find_conf_exact(cptr->name, cptr->username,
		cptr->sockhost, CFLAG)))
	{
		/*
		 * Reschedule a faster reconnect, if this was a automatically
		 * connected configuration entry. (Note that if we have had
		 * a rehash in between, the status has been changed to
		 * CONF_ILLEGAL). But only do this if it was a "good" link.
		 */
		aconf->hold = timeofday;
		aconf->hold += (aconf->hold - cptr->since > HANGONGOODLINK) ?
				HANGONRETRYDELAY : ConfConFreq(aconf);
		/* nextconnect could be 0 */
		if (nextconnect > aconf->hold || nextconnect == 0)
		{
			nextconnect = aconf->hold;
		}
	}

	if (nextconnect == 0 && (IsHandshake(cptr) || IsConnecting(cptr)))
	{
		nextconnect = timeofday + HANGONRETRYDELAY;
	}

	if (cptr->fd >= 0)
	{
#if defined(USE_IAUTH)
		if (!IsListener(cptr) && !IsConnecting(cptr))
		{
			/* iauth doesn't know about listening FD nor
			 * cancelled outgoing connections.
			 */
			sendto_iauth("%d D", cptr->fd);
		}
#endif
		/*
		 * clean up extra sockets from P-lines which have been
		 * discarded.
		 */
		if ((cptr->acpt != &me) && !(IsListener(cptr)))
		{
			aconf = cptr->acpt->confs->value.aconf;

			if (aconf->clients > 0)
			{
				aconf->clients--;
			}

			if (!aconf->clients && IsIllegal(aconf))
			{
				close_connection(cptr->acpt);
			}
		}
	}

	close_client_fd(cptr);

	/* Remove from Listener Linked list */
	if (IsListener(cptr) && cptr->confs && cptr->confs->value.aconf &&
		IsIllegal(cptr->confs->value.aconf) &&
		cptr->confs->value.aconf->clients <= 0)
	{
		if (cptr->prev)
		{
			cptr->prev->next = cptr->next;
		}
		else
		{
			/* we were 1st */
			ListenerLL = cptr->next;
		}
		if (cptr->next)
		{
			cptr->next->prev = cptr->prev;
		}
	}

	det_confs_butmask(cptr, 0);
	cptr->from = NULL; /* ...this should catch them! >:) --msa */
	return;
}

/*
** set_sock_opts
*/
static	int	set_sock_opts(int fd, aClient *cptr)
{
	int	opt, ret = 0;
#ifdef SO_REUSEADDR
	opt = 1;
	if (SETSOCKOPT(fd, SOL_SOCKET, SO_REUSEADDR, &opt, opt) < 0)
		report_error("setsockopt(SO_REUSEADDR) %s:%s", cptr);
#endif
#if  defined(SO_DEBUG) && defined(DEBUGMODE) && 0
/* Solaris 2.x with SO_DEBUG writes to syslog by default */
#if !defined(SOLARIS_2) || defined(USE_SYSLOG)
	opt = 1;
	if (SETSOCKOPT(fd, SOL_SOCKET, SO_DEBUG, &opt, opt) < 0)
		report_error("setsockopt(SO_DEBUG) %s:%s", cptr);
#endif /* SOLARIS_2 */
#endif
#if defined(SO_USELOOPBACK) && !defined(__CYGWIN32__)
	opt = 1;
	if (SETSOCKOPT(fd, SOL_SOCKET, SO_USELOOPBACK, &opt, opt) < 0)
		report_error("setsockopt(SO_USELOOPBACK) %s:%s", cptr);
#endif
#ifdef	SO_RCVBUF
	opt = 8192;
	if (SETSOCKOPT(fd, SOL_SOCKET, SO_RCVBUF, &opt, opt) < 0)
		report_error("setsockopt(SO_RCVBUF) %s:%s", cptr);
#endif
#ifdef	SO_SNDBUF
# ifdef	_SEQUENT_
/* seems that Sequent freezes up if the receving buffer is a different size
 * to the sending buffer (maybe a tcp window problem too).
 */
# endif
	opt = 8192;
	if (SETSOCKOPT(fd, SOL_SOCKET, SO_SNDBUF, &opt, opt) < 0)
		report_error("setsockopt(SO_SNDBUF) %s:%s", cptr);
# ifdef	SO_SNDLOWAT
	/*
	 * Setting the low water mark should improve performence by avoiding
	 * early returns from select()/poll().  It shouldn't delay sending
	 * data, provided that io_loop() combines read_message() and
	 * flush_fdary/connections() calls properly. -kalt
	 * This call isn't always implemented, even when defined.. so be quiet
	 * about errors. -kalt
	 */
	opt = 8192;
	SETSOCKOPT(fd, SOL_SOCKET, SO_SNDLOWAT, &opt, opt);
# endif
#endif
#if defined(IP_OPTIONS) && defined(IPPROTO_IP) && !defined(AIX) && \
    !defined(INET6)
	/*
	 * Mainly to turn off and alert us to source routing, here.
	 * Method borrowed from Wietse Venema's TCP wrapper.
	 */
	{
	    if (!IsListener(cptr)
#ifdef UNIXPORT
		&& !IsUnixSocket(cptr)
#endif
		)
		{
		    u_char	opbuf[256], *t = opbuf;
		    char	*s = readbuf;

		    opt = sizeof(opbuf);
		    if (GETSOCKOPT(fd, IPPROTO_IP, IP_OPTIONS, t, &opt) == -1)
			    report_error("getsockopt(IP_OPTIONS) %s:%s", cptr);
		    else if (opt > 0)
			{
			    for (; opt > 0; opt--, s+= 3)
				    (void)sprintf(s, " %02x", *t++);
			    *s = '\0';
			    sendto_flag(SCH_NOTICE,
					"Connection %s with IP opts%s",
					get_client_name(cptr, TRUE), readbuf);
			    Debug((DEBUG_NOTICE,
				   "Connection %s with IP opts%s",
				   get_client_name(cptr, TRUE), readbuf));
			    ret = -1;
			}
		}
	}
#endif
	return ret;
}

int	get_sockerr(aClient *cptr)
{
	int errtmp = errno, err = 0;
	SOCK_LEN_TYPE len = sizeof(err);

#ifdef	SO_ERROR
	if (cptr->fd >= 0)
		if (!GETSOCKOPT(cptr->fd, SOL_SOCKET, SO_ERROR, &err, &len))
			if (err)
				errtmp = err;
#endif
	return errtmp;
}

/*
** set_non_blocking
**	Set the client connection into non-blocking mode. If your
**	system doesn't support this, you can make this a dummy
**	function (and get all the old problems that plagued the
**	blocking version of IRC--not a problem if you are a
**	lightly loaded node...)
*/
void	set_non_blocking(int fd, aClient *cptr)
{
	int	res, nonb = 0;

	/*
	** NOTE: consult ALL your relevant manual pages *BEFORE* changing
	**	 these ioctl's.  There are quite a few variations on them,
	**	 as can be seen by the PCS one.  They are *NOT* all the same.
	**	 Heed this well. - Avalon.
	*/
#ifdef NBLOCK_POSIX
	nonb |= O_NONBLOCK;
#endif
#ifdef NBLOCK_BSD
	nonb |= O_NDELAY;
#endif
#ifdef NBLOCK_SYSV
	/* This portion of code might also apply to NeXT.  -LynX */
	res = 1;

	if (ioctl (fd, FIONBIO, &res) < 0)
		report_error("ioctl(fd,FIONBIO) failed for %s:%s", cptr);
#else
	if ((res = fcntl(fd, F_GETFL, 0)) == -1)
		report_error("fcntl(fd, F_GETFL) failed for %s:%s",cptr);
	else if (fcntl(fd, F_SETFL, res | nonb) == -1)
		report_error("fcntl(fd, F_SETL, nonb) failed for %s:%s",cptr);
#endif
	return;
}

#ifdef	CLONE_CHECK
/*
 * check_clones
 * adapted by jecete 4 IRC Ptnet
 */
static  int     check_clones(aClient *cptr)
{
	struct abacklog {
		struct  IN_ADDR ip;
		time_t  PT;
		struct abacklog *next;
	};
	static		struct abacklog *backlog = NULL;
	register	struct abacklog **blscn = &backlog,
					*blptr;
	register	int count = 0;

	/* First, ditch old entries */
	while (*blscn != NULL)
	    {
		if ((*blscn)->PT+CLONE_PERIOD < timeofday)
		    {
			blptr= *blscn;
			*blscn=blptr->next;
			MyFree(blptr);
		    }
		else
			blscn = &(*blscn)->next;
	    }
	/* Now add new item to the list */
	blptr = (struct abacklog *) MyMalloc(sizeof(struct abacklog));
#ifdef INET6
	bcopy(cptr->ip.s6_addr, blptr->ip.s6_addr, IN6ADDRSZ);
#else
	blptr->ip.s_addr = cptr->ip.s_addr;
#endif
	blptr->PT = timeofday;
	blptr->next = backlog;
	backlog = blptr;

	/* Count the number of entries from the same host */
	blptr = backlog;
	while (blptr != NULL)
	    {
#ifdef INET6
		if (bcmp(blptr->ip.s6_addr, cptr->ip.s6_addr, IN6ADDRSZ) == 0)
#else
		if (blptr->ip.s_addr == cptr->ip.s_addr)
#endif
			count++;
		blptr = blptr->next;
	    }
       return (count);
}
#endif

/* moved from inner blocks of add_connection to get rid of gotos */
void	add_connection_refuse(int fd, aClient *acptr, int delay)
{
#if !defined(DELAY_CLOSE)
	delay = 0;
#endif
	if (!delay)
	{
		(void)close(fd);
	}
	ircstp->is_ref++;
	acptr->fd = -2;
	free_client(acptr);
}

/*
 * Creates a client which has just connected to us on the given fd.
 * The sockhost field is initialized with the ip# of the host.
 * The client is added to the linked list of clients but isnt added to any
 * hash tables yet since it doesnt have a name.
 */
aClient	*add_connection(aClient *cptr, int fd)
{
	Link	lin;
	aClient *acptr;
	aConfItem *aconf = NULL;
	acptr = make_client(NULL);

	aconf = cptr->confs->value.aconf;
	acptr->acpt = cptr;

	/* Removed preliminary access check. Full check is performed in
	 * m_server and m_user instead. Also connection time out help to
	 * get rid of unwanted connections.
	 */
	if (isatty(fd)) /* If descriptor is a tty, special checking... */
		get_sockhost(acptr, cptr->sockhost);
	else
	    {
		struct	SOCKADDR_IN addr;
		SOCK_LEN_TYPE len = sizeof(struct SOCKADDR_IN);

		if (getpeername(fd, (SAP)&addr, &len) == -1)
		    {
#if defined(linux)
			if (errno != ENOTCONN)
#endif
				report_error("Failed in connecting to %s :%s",
					     cptr);
			add_connection_refuse(fd, acptr, 0);
			return NULL;
		    }
		/* don't want to add "Failed in connecting to" here.. */
		if (aconf && IsIllegal(aconf))
		{
			add_connection_refuse(fd, acptr, 0);
			return NULL;
		}
		/* Copy ascii address to 'sockhost' just in case. Then we
		 * have something valid to put into error messages...
		 */
#ifdef INET6
		inetntop(AF_INET6, (char *)&addr.sin6_addr, ipv6string,
			  sizeof(ipv6string));
		get_sockhost(acptr, (char *)ipv6string);
#else
		get_sockhost(acptr, (char *)inetntoa((char *)&addr.sin_addr));
#endif
		bcopy ((char *)&addr.SIN_ADDR, (char *)&acptr->ip,
			sizeof(struct IN_ADDR));
		acptr->port = ntohs(addr.SIN_PORT);

#ifdef	CLONE_CHECK
		if (check_clones(acptr) > CLONE_MAX)
		{
			sendto_flag(SCH_LOCAL, "Rejecting connection from %s.",
				acptr->sockhost);
			acptr->exitc = EXITC_CLONE;
			sendto_flog(acptr, EXITC_CLONE, "", acptr->sockhost);
#ifdef DELAY_CLOSE
			nextdelayclose = delay_close(fd);
#else
			(void)send(fd, "ERROR :Too rapid connections from your "
				"host\r\n", 46, 0);
#endif
			/* If DELAY_CLOSE is not defined, delay will
			** be changed to 0 inside. --B. */
			add_connection_refuse(fd, acptr, 1);
			return NULL;
		}
#endif
		lin.flags = ASYNC_CLIENT;
		lin.value.cptr = acptr;
		lin.next = NULL;
#ifdef INET6
		Debug((DEBUG_DNS, "lookup %s",
		       inet_ntop(AF_INET6, (char *)&addr.sin6_addr,
				 ipv6string, sizeof(ipv6string))));
#else
		Debug((DEBUG_DNS, "lookup %s",
		       inetntoa((char *)&addr.sin_addr)));
#endif
		acptr->hostp = gethost_byaddr((char *)&acptr->ip, &lin);
		if (!acptr->hostp)
			SetDNS(acptr);
		nextdnscheck = 1;
	    }

	acptr->fd = fd;
	set_non_blocking(acptr->fd, acptr);
	if (set_sock_opts(acptr->fd, acptr) == -1)
	{
		add_connection_refuse(fd, acptr, 0);
		return NULL;
	}
	if (aconf)
		aconf->clients++;
	if (fd > highest_fd)
		highest_fd = fd;
	local[fd] = acptr;
	add_fd(fd, &fdall);
	add_client_to_list(acptr);
	start_auth(acptr);
#if defined(USE_IAUTH)
	if (!isatty(fd) && !DoingDNS(acptr))
	    {
		int i = 0;

		while (acptr->hostp->h_aliases[i])
			sendto_iauth("%d A %s", acptr->fd,
				     acptr->hostp->h_aliases[i++]);
		if (acptr->hostp->h_name)
			sendto_iauth("%d N %s",acptr->fd,acptr->hostp->h_name);
		else if (acptr->hostp->h_aliases[0])
			sendto_iauth("%d n", acptr->fd);
	    }
#endif
	return acptr;
}

#ifdef	UNIXPORT
static	aClient	*add_unixconnection(aClient *cptr, int fd)
{
	aClient *acptr;
	aConfItem *aconf = NULL;

	acptr = make_client(NULL);

	/* Copy ascii address to 'sockhost' just in case. Then we
	 * have something valid to put into error messages...
	 */
	get_sockhost(acptr, me.sockhost);
	aconf = cptr->confs->value.aconf;
	if (aconf)
	    {
		if (IsIllegal(aconf))
		    {
			ircstp->is_ref++;
			acptr->fd = -2;
			free_client(acptr);
			(void)close(fd);
			return NULL;
		    }
		else
			aconf->clients++;
	    }
	acptr->fd = fd;
	if (fd > highest_fd)
		highest_fd = fd;
	local[fd] = acptr;
	add_fd(fd, &fdall);
	acptr->acpt = cptr;
	SetUnixSock(acptr);
	bcopy((char *)&me.ip, (char *)&acptr->ip, sizeof(struct IN_ADDR));

	add_client_to_list(acptr);
	set_non_blocking(acptr->fd, acptr);
	(void)set_sock_opts(acptr->fd, acptr);
# if defined(USE_IAUTH)
	/*
	** iauth protocol and iauth itself should be extended to alllow
	** dealing with this type of connection.
	*/
	sendto_iauth("%d O", acptr->fd);
	SetDoneXAuth(acptr);
# endif
	return acptr;
}
#endif

/*
** read_listener
**
** Accept incoming connections, extracted from read_message() 98/12 -kalt
** Up to LISTENER_MAXACCEPT connections will be accepted in one run.
*/
static	void	read_listener(aClient *cptr)
{
	int fdnew, max = LISTENER_MAXACCEPT;
	aClient	*acptr;

	while (max--)
	    {
		/*
		** There may be many reasons for error return, but in otherwise
		** correctly working environment the probable cause is running
		** out of file descriptors (EMFILE, ENFILE or others?). The
		** man pages for accept don't seem to list these as possible,
		** although it's obvious that it may happen here.
		** Thus no specific errors are tested at this point, just
		** assume that connections cannot be accepted until some old
		** is closed first.
		*/
		if ((fdnew = accept(cptr->fd, NULL, NULL)) < 0)
		    {
			if (errno != EWOULDBLOCK)
				report_error("Cannot accept connection %s:%s",
					     cptr);
			break;
		    }
		ircstp->is_ac++;
		if (fdnew >= MAXCLIENTS)
		    {
			ircstp->is_ref++;
			sendto_flag(SCH_ERROR, "All connections in use. (%s)",
				    get_client_name(cptr, TRUE));
			find_bounce(NULL, 0, fdnew);
			(void)send(fdnew, "ERROR :All connections in use\r\n",
				   32, 0);
			(void)close(fdnew);
			continue;
		    }

		/* Can cptr->confs->value.aconf be NULL? --B. */
		if ((iconf.caccept == 0 ||
			(iconf.caccept == 2 && iconf.split == 1))
			&& cptr->confs->value.aconf != NULL
			&& IsConfDelayed(cptr->confs->value.aconf))
		{
			/* Should we bother sendto_flag(SCH_ERROR...? --B. */
#ifdef CACCEPT_DELAYED_CLOSE
			nextdelayclose = delay_close(fdnew);
			ircstp->is_ref++;
#else
			(void)send(fdnew, "ERROR :All client connections are "
				"temporarily refused.\r\n", 56, 0);
			(void)close(fdnew);
#endif
			continue;
		}

#ifdef	UNIXPORT
		if (IsUnixSocket(cptr))
			acptr = add_unixconnection(cptr, fdnew);
		else
#endif
		acptr = add_connection(cptr, fdnew);

		if (acptr == NULL)
		{
			continue;
		}
		nextping = timeofday; /* isn't this abusive? -kalt */
		istat.is_unknown++;

		/* Notice on connect. */
		sendto_one(acptr, replies[RPL_HELLO], ME, HELLO_MSG);
	    }
}

/*
** client_packet
**
** Process data from receive buffer to client.
** Extracted from read_packet() 960804/291p3/Vesa
*/
static	int	client_packet(aClient *cptr)
{
	Reg	int	dolen = 0;

	while (DBufLength(&cptr->recvQ) && !NoNewLine(cptr) &&
	       ((cptr->status < STAT_UNKNOWN) ||
		(cptr->since - timeofday < MAXPENALTY)))
	    {
		/*
		** If it has become registered as a Service or Server
		** then skip the per-message parsing below.
		*/
		if (IsService(cptr) || IsServer(cptr))
		    {
			dolen = dbuf_get(&cptr->recvQ, readbuf,
					 sizeof(readbuf));
			if (dolen <= 0)
				break;
			dolen = dopacket(cptr, readbuf, dolen);
			if (dolen == 2 && cptr->since == cptr->lasttime)
				cptr->since += 5;
			if (dolen)
				return dolen;
			break;
		    }
		dolen = dbuf_getmsg(&cptr->recvQ, readbuf,
				    sizeof(readbuf));
		/*
		** Devious looking...whats it do ? well..if a client
		** sends a *long* message without any CR or LF, then
		** dbuf_getmsg fails and we pull it out using this
		** loop which just gets the next 512 bytes and then
		** deletes the rest of the buffer contents.
		** -avalon
		*/
		while (dolen <= 0)
		    {
			if (dolen < 0)
				return exit_client(cptr, cptr, &me,
						   "dbuf_getmsg fail");
			if (DBufLength(&cptr->recvQ) < 510)
			    {	/* hmm? */
				cptr->flags |= FLAGS_NONL;
				break;
			    }
			dolen = dbuf_get(&cptr->recvQ, readbuf, 511);
			if (dolen > 0 && DBufLength(&cptr->recvQ))
				DBufClear(&cptr->recvQ);
		    }

		/* Is it okay not to test for other return values? -krys */
		if (dolen > 0 &&
		    (dopacket(cptr, readbuf, dolen) == FLUSH_BUFFER))
			return FLUSH_BUFFER;
	    }
	return 1;
}

/*
** read_packet
**
** Read a 'packet' of data from a connection and process it.  Read in 8k
** chunks to give a better performance rating (for server connections).
** Do some tricky stuff for client connections to make sure they don't do
** any flooding >:-) -avalon
*/
static	int	read_packet(aClient *cptr, int msg_ready)
{
	Reg	int	length = 0, done;

	if (msg_ready &&
	    !(IsPerson(cptr) && DBufLength(&cptr->recvQ) > 6090))
	    {
		errno = 0;
#ifdef INET6
		length = recvfrom(cptr->fd, readbuf, sizeof(readbuf), 0, 0, 0);
#else
		length = recv(cptr->fd, readbuf, sizeof(readbuf), 0);
#endif
#if defined(DEBUGMODE) && defined(DEBUG_READ)
		if (length > 0)
			Debug((DEBUG_READ,
				"recv = %d bytes from %d[%s]:[%*.*s]\n",
				length, cptr->fd, cptr->name, length, length,
				readbuf));
#endif

		Debug((DEBUG_DEBUG, "Received %d(%d-%s) bytes from %d %s",
			length, errno, strerror(errno),
			cptr->fd, get_client_name(cptr, TRUE)));
		cptr->lasttime = timeofday;
		if (cptr->lasttime > cptr->since)
			cptr->since = cptr->lasttime;
		cptr->flags &= ~(FLAGS_PINGSENT|FLAGS_NONL);
		/*
		 * If not ready, fake it so it isnt closed
		 */
		if (length == -1 &&
			((errno == EWOULDBLOCK) || (errno == EAGAIN)))
			return 1;
		if (length <= 0)
			return length;
	    }
	else if (msg_ready)
		return exit_client(cptr, cptr, &me, "EOF From Client");

	/*
	** For server connections, we process as many as we can without
	** worrying about the time of day or anything :)
	*/
	if (IsServer(cptr) || IsConnecting(cptr) || IsHandshake(cptr) ||
	    IsService(cptr))
	    {
		if (length > 0)
		    {
			done = dopacket(cptr, readbuf, length);
			if (done && done != 2)
				return done;
		    }
	    }
	else
	    {
		/*
		** Before we even think of parsing what we just read, stick
		** it on the end of the receive queue and do it when its
		** turn comes around.
		*/
		/* why no poolsize increase here like in send? --B. */
		if (length && dbuf_put(&cptr->recvQ, readbuf, length) < 0)
			return exit_client(cptr, cptr, &me, "dbuf_put fail");

		if (IsPerson(cptr) &&
		    DBufLength(&cptr->recvQ) > CLIENT_FLOOD
		    && !is_allowed(cptr, ACL_CANFLOOD))
		    {
			cptr->exitc = EXITC_FLOOD;
			return exit_client(cptr, cptr, &me, "Excess Flood");
		    }

		return client_packet(cptr);
	    }
	return 1;
}


/*
 * Check all connections for new connections and input data that is to be
 * processed. Also check for connections with data queued and whether we can
 * write it out.
 *
 * Don't ever use ZERO for delay, unless you mean to poll and then
 * you have to have sleep/wait somewhere else in the code.--msa
 * Actually, ZERO is NOT ZERO anymore.. see below -kalt
 */
int	read_message(time_t delay, FdAry *fdp, int ro)
{
#if !defined(USE_POLL)
# define SET_READ_EVENT( thisfd )	FD_SET( thisfd, &read_set)
# define SET_WRITE_EVENT( thisfd )	FD_SET( thisfd, &write_set)
# define CLR_READ_EVENT( thisfd )	FD_CLR( thisfd, &read_set)
# define CLR_WRITE_EVENT( thisfd )	FD_CLR( thisfd, &write_set)
# define TST_READ_EVENT( thisfd )	FD_ISSET( thisfd, &read_set)
# define TST_WRITE_EVENT( thisfd )	FD_ISSET( thisfd, &write_set)

	fd_set	read_set, write_set;
	int	highfd = -1;
#else
/* most of the following use pfd */
# define POLLSETREADFLAGS	(POLLIN|POLLRDNORM)
# define POLLREADFLAGS		(POLLSETREADFLAGS|POLLHUP|POLLERR)
# define POLLSETWRITEFLAGS	(POLLOUT|POLLWRNORM)
# define POLLWRITEFLAGS		(POLLOUT|POLLWRNORM|POLLHUP|POLLERR)

# define SET_READ_EVENT( thisfd ){  CHECK_PFD( thisfd );\
				   pfd->events |= POLLSETREADFLAGS;}
# define SET_WRITE_EVENT( thisfd ){ CHECK_PFD( thisfd );\
				   pfd->events |= POLLSETWRITEFLAGS;}

# define CLR_READ_EVENT( thisfd )	pfd->revents &= ~POLLSETREADFLAGS
# define CLR_WRITE_EVENT( thisfd )	pfd->revents &= ~POLLSETWRITEFLAGS
# define TST_READ_EVENT( thisfd )	pfd->revents & POLLREADFLAGS
# define TST_WRITE_EVENT( thisfd )	pfd->revents & POLLWRITEFLAGS

# define CHECK_PFD( thisfd ) 			\
	if ( pfd->fd != thisfd ) {		\
		pfd = &poll_fdarray[nbr_pfds++];\
		pfd->fd     = thisfd;		\
		pfd->events = 0;		\
		pfd->revents = 0;		\
	}

	struct pollfd   poll_fdarray[MAXCONNECTIONS];
	struct pollfd * pfd     = poll_fdarray;
	struct pollfd * res_pfd = NULL;
	struct pollfd * udp_pfd = NULL;
	struct pollfd * ad_pfd = NULL;
	aClient	 * authclnts[MAXCONNECTIONS];	/* mapping of auth fds to client ptrs */
	int	   nbr_pfds = 0;
#endif

	aClient	*cptr;
	int	nfds, ret = 0;
	struct	timeval	wait;
	time_t	delay2 = delay;
	int	res, length, fd, i;
	int	auth;
	int	write_err = 0;

	for (res = 0;;)
	    {
#if !defined(USE_POLL)
		FD_ZERO(&read_set);
		FD_ZERO(&write_set);
#else
		/* set up such that CHECK_FD works */
		nbr_pfds = 0;
		pfd 	 = poll_fdarray;
		pfd->fd  = -1;
		res_pfd  = NULL;
		udp_pfd  = NULL;
		ad_pfd = NULL;
#endif	/* USE_POLL */
		auth = 0;

#if defined(USE_POLL)
		if ( auth == 0 )
			bzero((char *) authclnts, sizeof( authclnts ));
#endif
		for (i = fdp->highest; i >= 0; i--)
		    {
			fd = fdp->fd[i];
			if (!(cptr = local[fd]))
				continue;
			Debug((DEBUG_L11, "fd %d cptr %#x %d %#x %s",
				fd, cptr, cptr->status, cptr->flags,
				get_client_name(cptr,TRUE)));
			/* authentication fd's */
			if (DoingAuth(cptr))
			    {
				auth++;
				SET_READ_EVENT(cptr->authfd);
				Debug((DEBUG_NOTICE,"auth on %x %d", cptr,
					fd));
				if (cptr->flags & FLAGS_WRAUTH)
					SET_WRITE_EVENT(cptr->authfd);
#if defined(USE_POLL)
				authclnts[cptr->authfd] = cptr;
#else
				if (cptr->authfd > highfd)
					highfd = cptr->authfd;
#endif
			    }
			/*
			** if any of these is true, data won't be parsed
			** so no need to check for anything!
			*/
#if defined(USE_IAUTH)
			if (DoingDNS(cptr) || DoingAuth(cptr) ||
			    WaitingXAuth(cptr) ||
			    (DoingXAuth(cptr) &&
			     !(iauth_options & XOPT_EARLYPARSE)))
#else
			if (DoingDNS(cptr) || DoingAuth(cptr))
#endif
				continue;
#if !defined(USE_POLL)
			if (fd > highfd)
				highfd = fd;
#endif
			if (IsListener(cptr))
			    {
				if (
#ifdef LISTENER_DELAY
					/* Checking for new connections is only
					** done up to once per LD seconds. */
					timeofday >= cptr->lasttime +
						LISTENER_DELAY &&
#endif
					ro == 0)
				    {
					SET_READ_EVENT( fd );
				    }
				else if (delay2 > 1)
					delay2 = 1;
				continue;
			    }

			/*
			** This is very approximate, it should take
			** cptr->since into account. -kalt
			*/
			if (DBufLength(&cptr->recvQ) && delay2 > 2)
				delay2 = 1;

			if (IsRegisteredUser(cptr))
			    {
				if (cptr->since - timeofday < MAXPENALTY+1)
					SET_READ_EVENT( fd );
			    }
			else if (DBufLength(&cptr->recvQ) < 4088)
				SET_READ_EVENT( fd );

			/*
			** If we have anything in the sendQ, check if there is
			** room to write data.
			*/
			if (DBufLength(&cptr->sendQ) ||
#ifdef	ZIP_LINKS
			    ((cptr->flags & FLAGS_ZIP) &&
			     (cptr->zip->outcount > 0)) ||
#endif
			    IsConnecting(cptr))
			{
				if (IsServer(cptr) || IsConnecting(cptr) ||
					ro == 0)
				{
					SET_WRITE_EVENT(fd);
				}
			}
		    }

		if (udpfd >= 0)
		    {
			SET_READ_EVENT(udpfd);
#if !defined(USE_POLL)
			if (udpfd > highfd)
				highfd = udpfd;
#else
			udp_pfd = pfd;
#endif
		    }
		if (resfd >= 0)
		    {
			SET_READ_EVENT(resfd);
#if !defined(USE_POLL)
			if (resfd > highfd)
				highfd = resfd;
#else
			res_pfd = pfd;
#endif
		    }
#if defined(USE_IAUTH)
		if (adfd >= 0)
		    {
			SET_READ_EVENT(adfd);
# if ! USE_POLL
			if (adfd > highfd)
				highfd = adfd;
# else
			ad_pfd = pfd;
# endif
		    }
#endif
		Debug((DEBUG_L11, "udpfd %d resfd %d adfd %d", udpfd, resfd,
		       adfd));
#if !defined(USE_POLL)
		Debug((DEBUG_L11, "highfd %d", highfd));
#endif

		wait.tv_sec = MIN(delay2, delay);
		wait.tv_usec = (delay == 0) ? 200000 : 0;
#if !defined(USE_POLL)
		nfds = select(highfd + 1, (SELECT_FDSET_TYPE *)&read_set,
			      (SELECT_FDSET_TYPE *)&write_set, 0, &wait);
#else
		nfds = poll( poll_fdarray, nbr_pfds,
			     wait.tv_sec * 1000 + wait.tv_usec/1000 );
#endif
		ret = nfds;
		if (nfds == -1 && errno == EINTR)
			return -1;
		else if (nfds >= 0)
			break;
#if !defined(USE_POLL)
		report_error("select %s:%s", &me);
#else
		report_error("poll %s:%s", &me);
#endif
		res++;
		if (res > 5)
			restart("too many select()/poll() errors");
		sleep(10);
		timeofday = time(NULL);
	    } /* for(res=0;;) */

	timeofday = time(NULL);
	if (nfds > 0 &&
#if !defined(USE_POLL)
	    resfd >= 0 &&
#else
	    (pfd = res_pfd) &&
#endif
	    TST_READ_EVENT(resfd))
	    {
		CLR_READ_EVENT(resfd);
		nfds--;
		do_dns_async();
	    }
	if (nfds > 0 &&
#if !defined(USE_POLL)
	    udpfd >= 0 &&
#else
	    (pfd = udp_pfd) &&
#endif
	    TST_READ_EVENT(udpfd))
	    {
		CLR_READ_EVENT(udpfd);
		nfds--;
		polludp();
	    }
#if defined(USE_IAUTH)
	if (nfds > 0 &&
# if ! USE_POLL
	    adfd >= 0 &&
# else
	    (pfd = ad_pfd) &&
# endif
	    TST_READ_EVENT(adfd))
	    {
		CLR_READ_EVENT(adfd);
		nfds--;
		read_iauth();
	    }
#endif

#if !defined(USE_POLL)
	for (i = fdp->highest; i >= 0; i--)
#else
	for (pfd = poll_fdarray, i = 0; i < nbr_pfds; i++, pfd++ )
#endif
	    {
#if !defined(USE_POLL)
		fd = fdp->fd[i];
		if (!(cptr = local[fd]))
			continue;
#else
		fd = pfd->fd;
		if ((cptr = authclnts[fd]))
		    {
#endif
			/*
			 * check for the auth fd's
			 */
			if (auth > 0 && nfds > 0
#if !defined(USE_POLL)
			    && cptr->authfd >= 0
#endif
			    )
			    {
				auth--;
				if (TST_WRITE_EVENT(cptr->authfd))
				    {
					nfds--;
					send_authports(cptr);
				    }
				else if (TST_READ_EVENT(cptr->authfd))
				    {
					nfds--;
					read_authports(cptr);
				    }
				continue;
			    }
#if defined(USE_POLL)
		    }
		fd = pfd->fd;
		if (!(cptr = local[fd]))
			continue;
#else
		fd = cptr->fd;
#endif
		/*
		 * accept connections
		 */
		if (TST_READ_EVENT(fd) && IsListener(cptr) &&
			!IsListenerInactive(cptr))
		    {
			CLR_READ_EVENT(fd);
			cptr->lasttime = timeofday;
			read_listener(cptr);
			continue;
		    }
		if (IsMe(cptr))
			continue;
		if (TST_WRITE_EVENT(fd))
		    {
			write_err = 0;
			/*
			** ...room for writing, empty some queue then...
			*/
			if (IsConnecting(cptr))
				write_err = completed_connection(cptr);
			if (!write_err)
				(void)send_queued(cptr);
			if (IsDead(cptr) || write_err)
			    {
deadsocket:
				if (TST_READ_EVENT(fd))
					CLR_READ_EVENT(fd);
				if (cptr->exitc == EXITC_SENDQ)
				{
					(void)exit_client(cptr,cptr,&me,
						"Max SendQ exceeded");
				}
				else
				{
					/* Keep (primary) error or it will not
					 * be possible to discriminate socket
					 * error from mbuf error. --B. */
					if (cptr->exitc == EXITC_REG)
						cptr->exitc = EXITC_ERROR;
					(void)exit_client(cptr, cptr, &me,
						strerror(get_sockerr(cptr)));
				}
				continue;
			    }
		    }
		length = 1;	/* for fall through case */
		if (!NoNewLine(cptr) || TST_READ_EVENT(fd))
		    {
			if (!DoingAuth(cptr))
				length = read_packet(cptr, TST_READ_EVENT(fd));
		    }
		readcalls++;
		if (length == FLUSH_BUFFER)
			continue;
		else if (length > 0)
			flush_connections(cptr->fd);
		if (IsDead(cptr))
			goto deadsocket;
		if (length > 0)
			continue;

		/* Ghost! Unknown users are tagged in parse() since 2.9.
		 * Let's not drop the uplink but just the ghost's message.
		 */
		if (length == -3)
			continue;

		/*
		** NB: This following section has been modified to *expect*
		**     cptr to be valid (ie if (length == FLUSH_BUFFER) is
		**     above and stays there). - avalon 24/9/94
		*/
		/*
		** ...hmm, with non-blocking sockets we might get
		** here from quite valid reasons, although.. why
		** would select report "data available" when there
		** wasn't... so, this must be an error anyway...  --msa
		** actually, EOF occurs when read() returns 0 and
		** in due course, select() returns that fd as ready
		** for reading even though it ends up being an EOF. -avalon
		*/
		Debug((DEBUG_ERROR, "READ ERROR: fd = %d %d %d",
		       cptr->fd, errno, length));

		if (IsServer(cptr) || IsHandshake(cptr))
		    {
			int timeconnected = timeofday - cptr->firsttime;

			if (length == 0)
				sendto_flag(SCH_NOTICE,
		     "Server %s closed the connection (%d, %2d:%02d:%02d)",
					     get_client_name(cptr, FALSE),
					     timeconnected / 86400,
					     (timeconnected % 86400) / 3600,
					     (timeconnected % 3600)/60,
					     timeconnected % 60);
			else	/* this must be for -1 */
			    {
				report_error("Lost connection to %s:%s",cptr);
				sendto_flag(SCH_NOTICE,
			     "%s had been connected for %d, %2d:%02d:%02d",
					     get_client_name(cptr, FALSE),
					     timeconnected / 86400,
					     (timeconnected % 86400) / 3600,
					     (timeconnected % 3600)/60,
					     timeconnected % 60);
			    }
		    }
		(void)exit_client(cptr, cptr, &me, length >= 0 ?
				  "EOF From client" :
				  strerror(get_sockerr(cptr)));
	    } /* for(i) */
	return ret;
}

/*
 * connect_server
 */
int	connect_server(aConfItem *aconf, aClient *by, struct hostent *hp)
{
	Reg	struct	SOCKADDR *svp;
	Reg	aClient *cptr, *c2ptr;
	Reg	char	*s;
	int	i, len;

#ifdef INET6
	Debug((DEBUG_NOTICE,"Connect to %s[%s] @%s",
	       aconf->name, aconf->host,
	       inet_ntop(AF_INET6, (char *)&aconf->ipnum, ipv6string,
			 sizeof(ipv6string))));
#else
	Debug((DEBUG_NOTICE,"Connect to %s[%s] @%s",
	       aconf->name, aconf->host,
	       inetntoa((char *)&aconf->ipnum)));
#endif

	if ((c2ptr = find_server(aconf->name, NULL)))
	    {
		sendto_flag(SCH_NOTICE, "Server %s already present from %s",
			    aconf->name, get_client_name(c2ptr, TRUE));
		if (by && IsPerson(by) && !MyClient(by))
		  sendto_one(by,
			     ":%s NOTICE %s :Server %s already present from %s",
			     ME, by->name, aconf->name,
			     get_client_name(c2ptr, TRUE));
		return -1;
	    }

	/*
	 * If we don't know the IP# for this host and it is a hostname and
	 * not a ip# string, then try and find the appropriate host record.
	 */
	if (!aconf->ipnum.S_ADDR && *aconf->host != '/')
	    {
		Link    lin;

		lin.flags = ASYNC_CONNECT;
		lin.value.aconf = aconf;
		nextdnscheck = 1;
		s = (char *)index(aconf->host, '@');
		s++; /* should NEVER be NULL */
#ifdef INET6
		if (!inetpton(AF_INET6, s, aconf->ipnum.s6_addr))
#else
		if ((aconf->ipnum.s_addr = inetaddr(s)) == -1)
#endif
		    {
#ifdef INET6
			bzero(aconf->ipnum.s6_addr, IN6ADDRSZ);
#else
			aconf->ipnum.s_addr = 0;
#endif
			hp = gethost_byname(s, &lin);
			Debug((DEBUG_NOTICE, "co_sv: hp %x ac %x na %s ho %s",
				hp, aconf, aconf->name, s));
			if (!hp)
				return 0;
			bcopy(hp->h_addr, (char *)&aconf->ipnum,
				sizeof(struct IN_ADDR));
		    }
	    }
	cptr = make_client(NULL);
	if ((make_server(cptr))==NULL)
	{
		free_client(cptr);
		return -1;
	}
	cptr->hostp = hp;
	/*
	 * Copy these in so we have something for error detection.
	 */
	strncpyzt(cptr->serv->namebuf, aconf->name, sizeof(cptr->serv->namebuf));
	strncpyzt(cptr->sockhost, aconf->host, HOSTLEN+1);

#ifdef	UNIXPORT
	if (*aconf->host == '/') /* (/ starts a 2), Unix domain -- dl*/
		svp = connect_unix(aconf, cptr, &len);
	else
#endif
	svp = connect_inet(aconf, cptr, &len);

	if (!svp)
	    {
free_server:
		if (cptr->fd >= 0)
			(void)close(cptr->fd);
		cptr->fd = -2;
		/* make_server() sets ->bcptr, clear it now or free_server()
		** complains. --B. */
		cptr->serv->bcptr = NULL;
		free_server(cptr->serv);
		free_client(cptr);
		return -1;
	    }

	set_non_blocking(cptr->fd, cptr);
	(void)set_sock_opts(cptr->fd, cptr);
	(void)signal(SIGALRM, dummy);
	(void)alarm(4);
	if (connect(cptr->fd, (SAP)svp, len) < 0 && errno != EINPROGRESS)
	    {
		i = errno; /* other system calls may eat errno */
		(void)alarm(0);
		report_error("Connect to host %s failed: %s",cptr);
		if (by && IsPerson(by) && !MyClient(by))
		  sendto_one(by,
			     ":%s NOTICE %s :Connect to host %s failed.",
			     ME, by->name, cptr->name);
		errno = i;
		if (errno == EINTR)
			errno = ETIMEDOUT;
		goto free_server;
	    }
	(void)alarm(0);

	/* Attach config entries to client here rather than in
	 * completed_connection. This to avoid null pointer references
	 * when name returned by gethostbyaddr matches no C lines
	 * (could happen in 2.6.1a when host and servername differ).
	 * No need to check access and do gethostbyaddr calls.
	 * There must at least be one as we got here C line...  meLazy
	 */
	(void)attach_confs_host(cptr, aconf->host, CFLAG|NFLAG);

	if (!find_conf_host(cptr->confs, aconf->host, NFLAG) ||
	    !find_conf_host(cptr->confs, aconf->host, CFLAG))
	    {
      		sendto_flag(SCH_NOTICE,
			    "Host %s is not enabled for connecting:no C/N-line",
			    aconf->host);
		if (by && IsPerson(by) && !MyClient(by))
		  sendto_one(by,
			     ":%s NOTICE %s :Connect to host %s failed.",
			     ME, by->name, cptr->name);
		det_confs_butmask(cptr, 0);
		goto free_server;
	    }
	/*
	** The socket has been connected or connect is in progress.
	*/
	if (by && IsPerson(by))
	    {
		(void)strcpy(cptr->serv->by, by->name);
		if (by->user)
		{
			strcpy(cptr->serv->byuid, by->user->uid);
		}
		cptr->serv->user = by->user;
		by->user->refcnt++;
	    }
	else
		(void)strcpy(cptr->serv->by, "AutoConn.");
	cptr->serv->up = &me;
	cptr->serv->maskedby = cptr;
	cptr->serv->nline = aconf;
	if (cptr->fd > highest_fd)
		highest_fd = cptr->fd;
	add_fd(cptr->fd, &fdall);
	local[cptr->fd] = cptr;
	cptr->acpt = &me;
	SetConnecting(cptr);

	get_sockhost(cptr, aconf->host);
	add_client_to_list(cptr);
	nextping = timeofday;
	istat.is_unknown++;

	return 0;
}

static	struct	SOCKADDR *connect_inet(aConfItem *aconf, aClient *cptr,
	int *lenp)
{
	static	struct	SOCKADDR_IN	server;
	struct SOCKADDR_IN outip;

	Reg	struct	hostent	*hp;
	aClient	*acptr;
	int	i;

	/*
	 * Might as well get sockhost from here, the connection is attempted
	 * with it so if it fails its useless.
	 */
	cptr->fd = socket(AFINET, SOCK_STREAM, 0);
	if (cptr->fd >= MAXCLIENTS)
	    {
		sendto_flag(SCH_NOTICE,
			    "No more connections allowed (%s)", cptr->name);
		return NULL;
	    }
	bzero((char *)&server, sizeof(server));
	server.SIN_FAMILY = AFINET;
	get_sockhost(cptr, aconf->host);

	if (!BadPtr(aconf->source_ip))
	{
		memset(&outip, 0, sizeof(outip));
		outip.SIN_PORT = 0;
		outip.SIN_FAMILY = AFINET;
#ifdef INET6
		if (!inetpton(AF_INET6, aconf->source_ip, outip.sin6_addr.s6_addr))
#else
		if ((outip.sin_addr.s_addr = inetaddr(aconf->source_ip)) == -1)
#endif
		{
			sendto_flag(SCH_ERROR, "Invalid source IP (%s) in C:line",
				aconf->source_ip);
			memcpy(&outip, &mysk, sizeof(mysk));
		}
	}
	else
	{
		memcpy(&outip, &mysk, sizeof(mysk));
	}
	if (cptr->fd == -1)
	    {
		report_error("opening stream socket to server %s:%s", cptr);
		return NULL;
	    }
	/*
	** Bind to a local IP# (with unknown port - let unix decide) so
	** we have some chance of knowing the IP# that gets used for a host
	** with more than one IP#.
	** With VIFs, M:line defines outgoing IP# and initialises mysk.
	*/
	if (bind(cptr->fd, (SAP)&outip, sizeof(outip)) == -1)
	    {
		report_error("error binding to local port for %s:%s", cptr);
		return NULL;
	    }
	/*
	 * By this point we should know the IP# of the host listed in the
	 * conf line, whether as a result of the hostname lookup or the ip#
	 * being present instead. If we don't know it, then the connect fails.
	 */
#ifdef INET6
	if (isdigit(*aconf->host) && (AND16(aconf->ipnum.s6_addr) == 255))
		if (!inetpton(AF_INET6, aconf->host,aconf->ipnum.s6_addr))
			bcopy(minus_one, aconf->ipnum.s6_addr, IN6ADDRSZ);
	if (AND16(aconf->ipnum.s6_addr) == 255)
#else
	if (isdigit(*aconf->host) && (aconf->ipnum.s_addr == -1))
		aconf->ipnum.s_addr = inetaddr(aconf->host);
	if (aconf->ipnum.s_addr == -1)
#endif
	    {
		hp = cptr->hostp;
		if (!hp)
		    {
			Debug((DEBUG_FATAL, "%s: unknown host", aconf->host));
			return NULL;
		    }
		bcopy(hp->h_addr, (char *)&aconf->ipnum,
		      sizeof(struct IN_ADDR));
 	    }
	bcopy((char *)&aconf->ipnum, (char *)&server.SIN_ADDR,
		sizeof(struct IN_ADDR));
	bcopy((char *)&aconf->ipnum, (char *)&cptr->ip,
		sizeof(struct IN_ADDR));
	cptr->port = (aconf->port > 0) ? aconf->port : portnum;
	server.SIN_PORT = htons(cptr->port);
	/*
	 * Look for a duplicate IP#,port pair among already open connections
	 * (This caters for unestablished connections).
	 */
	for (i = highest_fd; i >= 0; i--)
		if ((acptr = local[i]) &&
		    !bcmp((char *)&cptr->ip, (char *)&acptr->ip,
			  sizeof(cptr->ip)) && server.SIN_PORT == acptr->port)
			return NULL;
	*lenp = sizeof(server);
	return	(struct SOCKADDR *)&server;
}

#ifdef	UNIXPORT
/* connect_unix
 *
 * Build a socket structure for cptr so that it can connet to the unix
 * socket defined by the conf structure aconf.
 */
static	struct	SOCKADDR *connect_unix(aConfItem *aconf, aClient *cptr,
	int *lenp)
{
	static	struct	sockaddr_un	sock;

	if ((cptr->fd = socket(AF_UNIX, SOCK_STREAM, 0)) == -1)
	    {
		report_error("Unix domain connect to host %s failed: %s", cptr);
		return NULL;
	    }
	else if (cptr->fd >= MAXCLIENTS)
	    {
		sendto_flag(SCH_NOTICE,
			    "No more connections allowed (%s)", cptr->name);
		return NULL;
	    }

	get_sockhost(cptr, aconf->host);
	strncpyzt(sock.sun_path, aconf->host + 2, sizeof(sock.sun_path));
	sock.sun_family = AF_UNIX;
	*lenp = strlen(sock.sun_path) + 2;

	SetUnixSock(cptr);
	return (struct sockaddr *)&sock;
}
#endif

/*
 * The following section of code performs summoning of users to irc.
 */
#if defined(ENABLE_SUMMON) || defined(USERS_SHOWS_UTMP)
int	utmp_open(void)
{
#ifdef O_NOCTTY
	return (open(UTMP, O_RDONLY|O_NOCTTY));
#else
	return (open(UTMP, O_RDONLY));
#endif
}

int	utmp_read(int fd, char *name, char *line, char *host, int hlen)
{
	struct	utmp	ut;
	while (read(fd, (char *)&ut, sizeof (struct utmp))
	       == sizeof (struct utmp))
	    {
		strncpyzt(name, ut.ut_name, 9);
		strncpyzt(line, ut.ut_line, 10);
#ifdef USER_PROCESS
#  if defined(HPUX) || defined(AIX)
		strncpyzt(host,(ut.ut_host[0]) ? (ut.ut_host) : ME, 16);
#  else
		strncpyzt(host, ME, 9);
#  endif
		if (ut.ut_type == USER_PROCESS)
			return 0;
#else
		strncpyzt(host, (ut.ut_host[0]) ? (ut.ut_host) : ME,
			hlen);
		if (ut.ut_name[0])
			return 0;
#endif
	    }
	return -1;
}

int	utmp_close(int fd)
{
	return(close(fd));
}

#ifdef ENABLE_SUMMON
void	summon(aClient *who, char *namebuf, char *linebuf, char *chname)
{
	static	char	wrerr[] = "NOTICE %s :Write error. Couldn't summon.";
	int	fd;
	char	line[512];
	struct	tm	*tp;

	tp = localtime(&timeofday);
	if (strlen(linebuf) > (size_t) 9)
	    {
		sendto_one(who,"NOTICE %s :Serious fault in SUMMON.",
			   who->name);
		sendto_one(who,
			   "NOTICE %s :linebuf too long. Inform Administrator",
			   who->name);
		return;
	    }
	/*
	 * Following line added to prevent cracking to e.g. /dev/kmem if
	 * UTMP is for some silly reason writable to everyone...
	 */
	if ((linebuf[0] != 't' || linebuf[1] != 't' || linebuf[2] != 'y')
	    && (linebuf[0] != 'c' || linebuf[1] != 'o' || linebuf[2] != 'n')
	    && (linebuf[0] != 'p' || linebuf[1] != 't' || linebuf[2] != 's')
#ifdef HPUX
	    && (linebuf[0] != 'p' || linebuf[1] != 't' || linebuf[2] != 'y' ||
		linebuf[3] != '/')
#endif
	    )
	    {
		sendto_one(who,
		      "NOTICE %s :Looks like mere mortal souls are trying to",
			   who->name);
		sendto_one(who,"NOTICE %s :enter the twilight zone... ",
			   who->name);
		Debug((0, "%s (%s@%s, nick %s, %s)",
		      "FATAL: major security hack. Notify Administrator !",
		      who->username, who->user->host,
		      who->name, who->info));
		return;
	    }

	sprintf(line,"/dev/%s", linebuf);
	(void)alarm(5);
#ifdef	O_NOCTTY
	if ((fd = open(line, O_WRONLY | O_NDELAY | O_NOCTTY)) == -1)
#else
	if ((fd = open(line, O_WRONLY | O_NDELAY)) == -1)
#endif
	    {
		(void)alarm(0);
		sendto_one(who,
			   "NOTICE %s :%s seems to have disabled summoning...",
			   who->name, namebuf);
		return;
	    }
#if !defined(O_NOCTTY) && defined(TIOCNOTTY)
	(void)ioctl(fd, TIOCNOTTY, NULL);
#endif
	(void)alarm(0);
	(void)sprintf(line,"\n\r\007Message from IRC_Daemon@%s at %d:%02d\n\r",
			ME, tp->tm_hour, tp->tm_min);
	if (write(fd, line, strlen(line)) != strlen(line))
	    {
		(void)alarm(0);
		(void)close(fd);
		sendto_one(who, wrerr, who->name);
		return;
	    }
	(void)alarm(0);
	(void)strcpy(line, "ircd: You are being summoned to Internet Relay \
Chat on\n\r");
	(void)alarm(5);
	if (write(fd, line, strlen(line)) != strlen(line))
	    {
		(void)alarm(0);
		(void)close(fd);
		sendto_one(who, wrerr, who->name);
		return;
	    }
	(void)alarm(0);
	sprintf(line, "ircd: Channel %s, by %s@%s (%s) %s\n\r", chname,
		who->user->username, who->user->host, who->name, who->info);
	(void)alarm(5);
	if (write(fd, line, strlen(line)) != strlen(line))
	    {
		(void)alarm(0);
		(void)close(fd);
		sendto_one(who, wrerr, who->name);
		return;
	    }
	(void)alarm(0);
	(void)strcpy(line,"ircd: Respond with irc\n\r");
	(void)alarm(5);
	if (write(fd, line, strlen(line)) != strlen(line))
	    {
		(void)alarm(0);
		(void)close(fd);
		sendto_one(who, wrerr, who->name);
		return;
	    }
	(void)close(fd);
	(void)alarm(0);
	sendto_one(who, replies[RPL_SUMMONING], ME, BadTo(who->name), namebuf);
	return;
}
#  endif
#endif /* ENABLE_SUMMON */

/*
** find the real hostname for the host running the server (or one which
** matches the server's name) and its primary IP#.  Hostname is stored
** in the client structure passed as a pointer.
*/
void	get_my_name(aClient *cptr, char *name, int len)
{
	static	char tmp[HOSTLEN+1];
	struct	hostent	*hp;
	char	*cname = cptr->name;
	aConfItem	*aconf;
#ifdef HAVE_GETIPNODEBYNAME
	int	error_num1, error_num2;
	struct	hostent	*hp1, *hp2;
#endif

	/*
	** Setup local socket structure to use for binding to.
	*/
	bzero((char *)&mysk, sizeof(mysk));
	mysk.SIN_FAMILY = AFINET;
	mysk.SIN_PORT = 0;

	if ((aconf = find_me())->passwd && isdigit(*aconf->passwd))
#ifdef INET6
		if(!inetpton(AF_INET6, aconf->passwd, mysk.sin6_addr.s6_addr))
			bcopy(minus_one, mysk.sin6_addr.s6_addr, IN6ADDRSZ);
#else
		mysk.sin_addr.s_addr = inetaddr(aconf->passwd);
#endif

	if (gethostname(name, len) == -1)
		return;
	name[len] = '\0';

	add_local_domain(name, len - strlen(name));

	/*
	** If hostname gives another name than cname, then check if there is
	** a CNAME record for cname pointing to hostname. If so accept
	** cname as our name.   meLazy
	*/
	if (BadPtr(cname))
		return;
#ifdef HAVE_GETIPNODEBYNAME
	hp1 = getipnodebyname(cname, AF_INET6, AI_DEFAULT, &error_num1);
	hp2 = getipnodebyname(name, AF_INET6, AI_DEFAULT, &error_num2);
	if (! error_num1) hp=hp1; else hp=hp2;
	if ((! error_num1) || (! error_num2))
#else
	if ((hp = gethostbyname(cname)) || (hp = gethostbyname(name)))
#endif
	    {
		char	*hname;
		int	i = 0;

		for (hname = hp->h_name; hname; hname = hp->h_aliases[i++])
  		    {
			strncpyzt(tmp, hname, sizeof(tmp));
			add_local_domain(tmp, sizeof(tmp) - strlen(tmp));

			/*
			** Copy the matching name over and store the
			** 'primary' IP# as 'myip' which is used
			** later for making the right one is used
			** for connecting to other hosts.
			*/
			if (!mycmp(ME, tmp))
				break;
 		    }
		if (mycmp(ME, tmp))
			strncpyzt(name, hp->h_name, len);
		else
			strncpyzt(name, tmp, len);
#if 0
/* If someone puts IP in M:, fine, use it as outgoing ip, but using
resolved M: name for outgoing ip is... troublesome. It can resolve to IP of
some other host or 127.0.0.1 (in which case we'd be getting strange errors
from connect()); if left empty, OS will decide itself what IP to use;
if someone wants to control this, use M: or C: adequate fields. --B. */
		if (BadPtr(aconf->passwd))
			bcopy(hp->h_addr, (char *)&mysk.SIN_ADDR,
			      sizeof(struct IN_ADDR));
#endif
		Debug((DEBUG_DEBUG,"local name is %s",
				get_client_name(&me,TRUE)));
	    }
#ifdef HAVE_GETIPNODEBYNAME
	freehostent(hp1);
	freehostent(hp2);
#endif
	return;
}

/*
** setup a UDP socket and listen for incoming packets
*/
int	setup_ping(aConfItem *aconf)
{
	struct	SOCKADDR_IN	from;
	int	on = 1;

	if (udpfd != -1)
		return udpfd;
	bzero((char *)&from, sizeof(from));
	if (aconf->passwd && isdigit(*aconf->passwd))
#ifdef INET6
	    {
		if (!inetpton(AF_INET6, aconf->passwd,from.sin6_addr.s6_addr))
			bcopy(minus_one, from.sin6_addr.s6_addr, IN6ADDRSZ);
	    }
#else
	  from.sin_addr.s_addr = inetaddr(aconf->passwd);
#endif
	else
#ifdef INET6
	  from.SIN_ADDR = in6addr_any;
#else
	  from.sin_addr.s_addr = htonl(INADDR_ANY); /* hmmpf */
#endif
	from.SIN_PORT = htons((u_short) aconf->port);
	from.SIN_FAMILY = AFINET;

	if ((udpfd = socket(AFINET, SOCK_DGRAM, 0)) == -1)
	    {
		Debug((DEBUG_ERROR, "socket udp : %s", strerror(errno)));
		return -1;
	    }
	if (SETSOCKOPT(udpfd, SOL_SOCKET, SO_REUSEADDR, &on, on) == -1)
	    {
#ifdef	USE_SYSLOG
		syslog(LOG_ERR, "setsockopt udp fd %d : %m", udpfd);
#endif
		Debug((DEBUG_ERROR, "setsockopt so_reuseaddr : %s",
			strerror(errno)));
		(void)close(udpfd);
		return udpfd = -1;
	    }
	on = 0;
	(void) SETSOCKOPT(udpfd, SOL_SOCKET, SO_BROADCAST, &on, on);
	if (bind(udpfd, (SAP)&from, sizeof(from))==-1)
	    {
#ifdef	USE_SYSLOG
		syslog(LOG_ERR, "bind udp.%d fd %d : %m",
		       ntohs(from.SIN_PORT), udpfd);
#endif
		Debug((DEBUG_ERROR, "bind : %s", strerror(errno)));
		(void)close(udpfd);
		return udpfd = -1;
	    }
	if (fcntl(udpfd, F_SETFL, FNDELAY)==-1)
	    {
		Debug((DEBUG_ERROR, "fcntl fndelay : %s", strerror(errno)));
		(void)close(udpfd);
		return udpfd = -1;
	    }
	Debug((DEBUG_INFO, "udpfd = %d, port %d", udpfd,ntohs(from.SIN_PORT)));
	return udpfd;
}


void	send_ping(aConfItem *aconf)
{
	Ping	pi;
	struct	SOCKADDR_IN	sin;
	aCPing	*cp = aconf->ping;

#ifdef INET6
	if (!aconf->ipnum.s6_addr || AND16(aconf->ipnum.s6_addr) == 255 || !cp->port)
#else
	if (!aconf->ipnum.s_addr || aconf->ipnum.s_addr == -1 || !cp->port)
#endif
		return;
	if (aconf->class->conFreq == 0) /* avoid flooding */
		return;
	pi.pi_cp = aconf;
	pi.pi_id = htonl(PING_CPING);
	pi.pi_seq = cp->lseq++;
	cp->seq++;
	/*
	 * Only recognise stats from the last 20 minutes as significant...
	 * Try and fake sliding along a "window" here.
	 */
	if (cp->seq > 1 && cp->seq * aconf->class->conFreq > 1200)
	    {
		if (cp->recvd)
		    {
			cp->ping -= (cp->ping / cp->recvd);
			if (cp->recvd == cp->seq)
				cp->recvd--;
		    }
		else
			cp->ping = 0;
		cp->seq--;
	    }

	bzero((char *)&sin, sizeof(sin));
#ifdef INET6
	bcopy(aconf->ipnum.s6_addr, sin.sin6_addr.s6_addr, IN6ADDRSZ);
#else
	sin.sin_addr.s_addr = aconf->ipnum.s_addr;
#endif
	sin.SIN_PORT = htons(cp->port);
	sin.SIN_FAMILY = AFINET;
	(void)gettimeofday(&pi.pi_tv, NULL);
#ifdef INET6
	Debug((DEBUG_SEND,"Send ping to %s,%d fd %d, %d bytes",
	       inet_ntop(AF_INET6, (char *)&aconf->ipnum, ipv6string, sizeof(ipv6string)),
	       cp->port, udpfd, sizeof(pi)));
#else
	Debug((DEBUG_SEND,"Send ping to %s,%d fd %d, %d bytes",
	       inetntoa((char *)&aconf->ipnum),
	       cp->port, udpfd, sizeof(pi)));
#endif
	(void)sendto(udpfd, (char *)&pi, sizeof(pi), 0,(SAP)&sin,sizeof(sin));
}

static	int	check_ping(char *buf, int len)
{
	Ping	pi;
	aConfItem	*aconf;
	struct	timeval	tv;
	double	d;
	aCPing	*cp = NULL;
	u_long	rtt;

	(void)gettimeofday(&tv, NULL);

	if (len < sizeof(pi) + 8)
		return -1;

	bcopy(buf, (char *)&pi, sizeof(pi));	/* ensure nice byte align. */

	for (aconf = conf; aconf; aconf = aconf->next)
		if (pi.pi_cp == aconf && (cp = aconf->ping))
			break;
	if (!aconf || match(aconf->name, buf + sizeof(pi)))
		return -1;

	cp->recvd++;
	cp->lrecvd++;
	rtt = ((tv.tv_sec - pi.pi_tv.tv_sec) * 1000 +
		(tv.tv_usec - pi.pi_tv.tv_usec) / 1000);
	cp->ping += rtt;
	cp->rtt += rtt;
	if (cp->rtt > 1000000)
	    {
		cp->ping = (cp->rtt /= cp->lrecvd);
		cp->recvd = cp->lrecvd = 1;
		cp->seq = cp->lseq = 1;
	    }
	d = (double)cp->recvd / (double)cp->seq;
	d = pow(d, (double)20.0);
	d = (double)cp->ping / (double)cp->recvd / d;
	if (d > 10000.0)
		d = 10000.0;
	aconf->pref = (int) (d * 100.0);

	return 0;
}

/*
 * max # of pings set to 15/sec.
 */
static	void	polludp(void)
{
	static	time_t	last = 0;
	static	int	cnt = 0, mlen = 0, lasterr = 0;
	Reg	char	*s;
	struct	SOCKADDR_IN	from;
	Ping	pi;
	int	n;
	SOCK_LEN_TYPE fromlen = sizeof(from);

	/*
	 * find max length of data area of packet.
	 */
	if (!mlen)
	    {
		mlen = sizeof(readbuf) - strlen(ME) - strlen(version);
		mlen -= 6;
		if (mlen < 0)
			mlen = 0;
	    }
	Debug((DEBUG_DEBUG,"udp poll"));

	memset(&from, 0, fromlen);
	n = recvfrom(udpfd, readbuf, mlen, 0, (SAP)&from, &fromlen);
	if (n == -1)
	    {
		ircstp->is_udperr++;
		if ((errno == EWOULDBLOCK) || (errno == EAGAIN))
			return;
		else
		    {
#if 0
/* seems to create more confusion than it's worth */
			char buf[100];

			sprintf(buf, "udp port recvfrom() from %s to %%s: %%s",
#ifdef INET6
				from.sin6_addr.s6_addr
#else
				from.sin_addr.s_addr
#endif
				== 0 ? "unknown" :
#ifdef INET6
				inetntop(AF_INET6, (char *)&from.sin6_addr,
					ipv6string, sizeof(ipv6string))
#else
				inetntoa((char *)&from.sin_addr)
#endif
				);
			report_error(buf, &me);
#endif /* confusion */
			return;
		    }
	    }

	if (timeofday == last)
	    {
		if (++cnt > 14)
		    {
			if (timeofday > lasterr + 30)
			    {
				sendto_flag(SCH_NOTICE,
				    "udp packet dropped: %d bytes from %s.%d",
#ifdef INET6
					    n, inetntop(AF_INET6,
					 (char *)&from.sin6_addr, ipv6string,
							 sizeof(ipv6string)),
#else
					    n,inetntoa((char *)&from.sin_addr),
#endif
					    ntohs(from.SIN_PORT));
				lasterr = timeofday;
			    }
			ircstp->is_udpdrop++;
			return;
		    }
	    }
	else
		cnt = 0, last = timeofday;

#ifdef INET6
	Debug((DEBUG_NOTICE, "udp (%d) %d bytes from %s,%d", cnt, n,
	       inet_ntop(AF_INET6, (char *)&from.sin6_addr, ipv6string,
			 sizeof(ipv6string)),
	       ntohs(from.SIN_PORT)));
#else
	Debug((DEBUG_NOTICE, "udp (%d) %d bytes from %s,%d", cnt, n,
	       inetntoa((char *)&from.sin_addr),
	       ntohs(from.SIN_PORT)));
#endif

	readbuf[n] = '\0';
	ircstp->is_udpok++;
	if (n  < 8)
		return;

	bcopy(s = readbuf, (char *)&pi, MIN(n, sizeof(pi)));
	pi.pi_id = ntohl(pi.pi_id);
	Debug((DEBUG_INFO, "\tpi_id %#x pi_seq %d pi_cp %#x",
		pi.pi_id, pi.pi_seq, pi.pi_cp));

	if ((pi.pi_id == (PING_CPING|PING_REPLY) ||
	     pi.pi_id == (PING_CPING|(PING_REPLY << 24))) && n >= sizeof(pi))
	    {
		check_ping(s, n);
		return;
	    }
	else if (pi.pi_id & PING_REPLY)
		return;
	/*
	 * attach my name and version for the reply
	 */
	pi.pi_id |= PING_REPLY;
	pi.pi_id = htonl(pi.pi_id);
	bcopy((char *)&pi, s, MIN(n, sizeof(pi)));
	s += n;
	(void)strcpy(s, ME);
	s += strlen(s)+1;
	(void)strcpy(s, version);
	s += strlen(s);
	(void)sendto(udpfd, readbuf, s-readbuf, 0, (SAP)&from ,sizeof(from));
	return;
}

/*
 * do_dns_async
 *
 * Called when the fd returned from init_resolver() has been selected for
 * reading.
 */
static	void	do_dns_async(void)
{
	static	Link	ln;
	aClient	*cptr;
	aConfItem	*aconf;
	struct	hostent	*hp;
	int	bytes, pkts;

	pkts = 0;

	do {
		ln.flags = -1;
		hp = get_res((char *)&ln);

		Debug((DEBUG_DNS,"%#x = get_res(%d,%#x)", hp, ln.flags,
			ln.value.cptr));

		switch (ln.flags)
		{
		case ASYNC_NONE :
			/*
			 * no reply was processed that was outstanding or
			 * had a client still waiting.
			 */
			break;
		case ASYNC_CLIENT :
			if ((cptr = ln.value.cptr))
			    {
				del_queries((char *)cptr);
				ClearDNS(cptr);
				cptr->hostp = hp;
#if defined(USE_IAUTH)
				if (hp)
				    {
					int i = 0;

					while (hp->h_aliases[i])
						sendto_iauth("%d A %s",
							     cptr->fd,
							hp->h_aliases[i++]);
					if (hp->h_name)
						sendto_iauth("%d N %s",
							cptr->fd, hp->h_name);
					else if (hp->h_aliases[0])
						sendto_iauth("%d n", cptr->fd);
				    }
				else
					sendto_iauth("%d d", cptr->fd);
				if (iauth_options & XOPT_EXTWAIT)
					cptr->lasttime = timeofday;
#endif
			    }
			break;
		case ASYNC_CONNECT :
			aconf = ln.value.aconf;
			if (hp && aconf)
			    {
				bcopy(hp->h_addr, (char *)&aconf->ipnum,
				      sizeof(struct IN_ADDR));
				(void)connect_server(aconf, NULL, hp);
			    }
			else
				sendto_flag(SCH_ERROR,
					    "Connect to %s failed: host lookup",
					   (aconf) ? aconf->host : "unknown");
			break;
		case ASYNC_CONF :
			aconf = ln.value.aconf;
			if (hp && aconf)
				bcopy(hp->h_addr, (char *)&aconf->ipnum,
				      sizeof(struct IN_ADDR));
			break;
		default :
			break;
		}
		pkts++;
		if (ioctl(resfd, FIONREAD, &bytes) == -1)
			bytes = 0;
	} while ((bytes > 0) && (pkts < 10));
}

#ifdef DELAY_CLOSE
/*
 * Delaying close(2) on too rapid connections reduces cpu
 * and bandwidth usage. Not mentioning disk space, if you
 * log such crap.
 *
 * Based on Ari `DLR' Heikkinen <aheikin@dlr.pspt.fi> irce0.9.1
 * by Piotr `Beeth' Kucharski <chopin@42.pl>
 *
 * Note: calling with fd == -2 closes all delayed fds.
 */

time_t	delay_close(int fd)
{
	struct	fdlog
	{
		struct	fdlog	*next;
		int	fd;
		time_t	time;
	};
	static	struct	fdlog	*first = NULL, *last = NULL;
	struct	fdlog	*next = first, *tmp;
	int	tmpdel = 0;

	if (fd == -2)
	{
		/* special case used in m_close() -- close all! */
		tmpdel = istat.is_delayclosewait;
	}
	else
	/* Make sure we don't delay close() on too many fds. If we have
	 * kept more than half (possibly) available fds for clients
	 * waiting to be closed, release quarter oldest of them.
	 * >>1, >>2 are faster equivalents of /2, /4 --B. */
	if (istat.is_delayclosewait > (MAXCLIENTS-istat.is_localc) >> 1)
	{
		tmpdel = istat.is_delayclosewait >> 2;
	}

	while ((tmp = next))
	{
		if (tmp->time < timeofday || tmpdel-- > 0)
		{
			next = tmp->next;
			(void)send(fd, "ERROR :Too rapid connections "
				"from your host\r\n", 46, 0);
			close(tmp->fd);
			MyFree(tmp);
			istat.is_delayclosewait--;
			if (!next)
			{
				last = NULL;
			}
			first = next;
		}
		else
		{
			/* This linked list has entries chronologically
			 * sorted, so if tmp is not old enough, all next
			 * would also be not old enough to close. */
			break;
		}
	}

	if (fd >= 0)
	{
		/* set socket in nonblocking state (just in case) */
		set_non_blocking(fd, NULL);

		/* disallow further receives */
		shutdown(fd, SHUT_RD);

		/* create a new entry with fd and time of close */
		tmp = (struct fdlog *)MyMalloc(sizeof(*tmp));
		tmp->next = NULL;
		tmp->fd = fd;
		tmp->time = timeofday + DELAY_CLOSE;
		istat.is_delayclosewait++;
		istat.is_delayclose++;

		/* then add it to the list */
		if (last)
		{
			last->next = tmp;
			last = tmp;
		}
		else
		{
			first = last = tmp;
		}
	}

	return first ? first->time : 0;
}
#endif