add ircd

9 files changed, 1436 insertions, 0 deletions

diff --git a/ngircd/src/portab/Makefile.ng b/ngircd/src/portab/Makefile.ng
new file mode 100644
index 0000000..9be5f56
--- /dev/null
+++ b/ngircd/src/portab/Makefile.ng
@@ -0,0 +1,41 @@
+#
+# ngIRCd -- The Next Generation IRC Daemon
+# Copyright (c)2001-2024 Alexander Barton (alex@barton.de) and Contributors
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+# Please read the file COPYING, README and AUTHORS for more information.
+#
+
+__ng_Makefile_am_template__
+
+EXTRA_DIST = Makefile.ng
+
+noinst_LIBRARIES = libngportab.a
+
+libngportab_a_SOURCES = \
+	strdup.c \
+	strlcpy.c \
+	strndup.c \
+	strtok_r.c \
+	vsnprintf.c \
+	waitpid.c
+
+check_PROGRAMS = portabtest
+
+portabtest_SOURCES = portabtest.c
+
+portabtest_LDFLAGS = -L.
+
+portabtest_LDADD = -lngportab
+
+noinst_HEADERS = portab.h
+
+maintainer-clean-local:
+	rm -f Makefile Makefile.in Makefile.am
+
+TESTS = portabtest
+
+# -eof-
diff --git a/ngircd/src/portab/portab.h b/ngircd/src/portab/portab.h
new file mode 100644
index 0000000..e0ec3e1
--- /dev/null
+++ b/ngircd/src/portab/portab.h
@@ -0,0 +1,184 @@
+/*
+ * ngIRCd -- The Next Generation IRC Daemon
+ * Copyright (c)2001-2014 Alexander Barton (alex@barton.de) and Contributors.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * Please read the file COPYING, README and AUTHORS for more information.
+ */
+
+#ifndef __PORTAB__
+#define __PORTAB__
+
+/**
+ * @file
+ * Portability functions and declarations (header)
+ */
+
+#include "config.h"
+
+/* remove assert() macro at compile time if DEBUG is not set. */
+
+#ifndef DEBUG
+# define NDEBUG
+#endif
+
+/* compiler features */
+
+#if (__GNUC__ > 2 || (__GNUC__ == 2 && __GNUC_MINOR__ > 7))
+# define PUNUSED(x) __attribute__ ((unused)) x
+# define UNUSED     __attribute__ ((unused))
+#else
+# define PUNUSED(x) x
+# define UNUSED
+#endif
+
+#ifndef PARAMS
+# if PROTOTYPES
+#  define PARAMS(args) args
+# else
+#  define PARAMS(args) ()
+# endif
+#endif
+
+/* datatypes */
+
+#include <sys/types.h>
+
+#ifdef HAVE_STDDEF_H
+# include <stddef.h>
+#endif
+
+#ifdef HAVE_INTTYPES_H
+# include <inttypes.h>
+# define NGIRC_GOT_INTTYPES
+#else
+# ifdef HAVE_STDINT_H
+#  include <stdint.h>
+#  define NGIRC_GOT_INTTYPES
+# endif
+#endif
+
+#ifndef PROTOTYPES
+# ifndef signed
+#  define signed
+# endif
+#endif
+
+typedef void POINTER;
+
+#ifdef NGIRC_GOT_INTTYPES
+typedef uint8_t UINT8;
+typedef uint16_t UINT16;
+typedef uint32_t UINT32;
+#else
+typedef unsigned char UINT8;
+typedef unsigned short UINT16;
+typedef unsigned int UINT32;
+#endif
+
+#ifdef HAVE_STDBOOL_H
+# include <stdbool.h>
+#else
+typedef unsigned char bool;
+# define true (bool)1
+# define false (bool)0
+#endif
+
+#ifndef NULL
+# ifdef PROTOTYPES
+#  define NULL (void *)0
+# else
+#  define NULL 0L
+# endif
+#endif
+
+#ifdef NeXT
+# define S_IRUSR 0000400		/* read permission, owner */
+# define S_IWUSR 0000200		/* write permission, owner */
+# define S_IRGRP 0000040		/* read permission, group */
+# define S_IROTH 0000004		/* read permission, other */
+# define ssize_t int
+#endif
+
+#undef GLOBAL
+#ifdef GLOBAL_INIT
+#define GLOBAL
+#else
+#define GLOBAL extern
+#endif
+
+/* target constants  */
+
+#ifndef HOST_OS
+# define HOST_OS "unknown"
+#endif
+
+#ifndef HOST_CPU
+# define HOST_CPU "unknown"
+#endif
+
+#ifndef HOST_VENDOR
+# define HOST_VENDOR "unknown"
+#endif
+
+#ifdef __HAIKU__
+# define SINGLE_USER_OS
+#endif
+
+/* configure options */
+
+#ifndef HAVE_socklen_t
+typedef int socklen_t;			/* for Mac OS X, amongst others */
+#endif
+
+#ifndef HAVE_SNPRINTF
+extern int snprintf PARAMS(( char *str, size_t count, const char *fmt, ... ));
+#endif
+
+#ifndef HAVE_STRLCAT
+extern size_t strlcat PARAMS(( char *dst, const char *src, size_t size ));
+#endif
+
+#ifndef HAVE_STRLCPY
+extern size_t strlcpy PARAMS(( char *dst, const char *src, size_t size ));
+#endif
+
+#ifndef HAVE_STRDUP
+extern char * strdup PARAMS(( const char *s ));
+#endif
+
+#ifndef HAVE_STRNDUP
+extern char * strndup PARAMS((const char *s, size_t maxlen));
+#endif
+
+#ifndef HAVE_STRTOK_R
+extern char * strtok_r PARAMS((char *str, const char *delim, char **saveptr));
+#endif
+
+#ifndef HAVE_VSNPRINTF
+#include <stdarg.h>
+extern int vsnprintf PARAMS(( char *str, size_t count, const char *fmt, va_list args ));
+#endif
+
+#ifndef HAVE_GAI_STRERROR
+# define gai_strerror(r) "unknown error"
+#endif
+
+#ifndef PACKAGE_NAME
+# define PACKAGE_NAME PACKAGE
+#endif
+
+#ifndef PACKAGE_VERSION
+# define PACKAGE_VERSION VERSION
+#endif
+
+#ifndef SYSCONFDIR
+# define SYSCONFDIR "/etc"
+#endif
+
+#endif
+
+/* -eof- */
diff --git a/ngircd/src/portab/portabtest.c b/ngircd/src/portab/portabtest.c
new file mode 100644
index 0000000..5ad37b9
--- /dev/null
+++ b/ngircd/src/portab/portabtest.c
@@ -0,0 +1,206 @@
+/*
+ * ngIRCd -- The Next Generation IRC Daemon
+ * Copyright (c)2001-2014 Alexander Barton (alex@barton.de) and Contributors.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * Please read the file COPYING, README and AUTHORS for more information.
+ */
+
+#include "portab.h"
+
+/**
+ * @file
+ * Test program for portab.h and friends ;-)
+ */
+
+#include <stdarg.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+int allow_severity = 0, deny_severity = 0;
+
+static void
+Panic(char *Reason)
+{
+	/* Oops, something failed!? */
+	fprintf(stderr, "Oops, test for %s failed!?\n", Reason);
+	exit(1);
+} /* Panic */
+
+static void
+Check_snprintf(void)
+{
+	char str[5];
+
+	snprintf(str, sizeof(str), "%s", "1234567890");
+	if (str[4] != '\0')
+		Panic("snprintf NULL byte");
+	if (strlen(str) != 4)
+		Panic("snprintf string length");
+}
+
+static void
+Check_strdup(void)
+{
+	char *ptr;
+
+	ptr = strdup("1234567890");
+	if (!ptr)
+		Panic("strdup");
+	if (ptr[10] != '\0')
+		Panic("strdup NULL byte");
+	if (strlen(ptr) != 10)
+		Panic("strdup string length");
+	free(ptr);
+}
+
+static void
+Check_strndup(void)
+{
+	char *ptr;
+
+	ptr = strndup("1234567890", 5);
+	if (!ptr)
+		Panic("strndup");
+	if (ptr[5] != '\0')
+		Panic("strndup NULL byte");
+	if (strlen(ptr) != 5)
+		Panic("strndup string length");
+	free(ptr);
+}
+
+static void
+Check_strlcpy(void)
+{
+	char str[5];
+
+	if (strlcpy(str, "1234567890", sizeof(str)) != 10)
+		Panic("strlcpy return code");
+	if (str[4] != '\0')
+		Panic("strlcpy NULL byte");
+	if (strlen(str) != 4)
+		Panic("strlcpy string length");
+}
+
+static void
+Check_strlcat(void)
+{
+	char str[5];
+
+	if (strlcpy(str, "12", sizeof(str)) != 2)
+		Panic("strlcpy for strlcat");
+	if (strlcat(str, "1234567890", sizeof(str)) != 12)
+		Panic("strlcat return code");
+	if (str[4] != '\0')
+		Panic("strlcat NULL byte");
+	if (strlen(str) != 4)
+		Panic("strlcat string length");
+}
+
+static void
+Check_strtok_r(void)
+{
+	char *str, *ptr, *last;
+
+	ptr = strdup("12,abc");
+	str = ptr;
+
+	ptr = strtok_r(ptr, ",", &last);
+	if (!ptr)
+		Panic("strtok_r result #1");
+	if (strcmp(ptr, "12") != 0)
+		Panic("strtok_r token #1");
+
+	ptr = strtok_r(NULL, ",", &last);
+	if (!ptr)
+		Panic("strtok_r result #2");
+	if (strcmp(ptr, "abc") != 0)
+		Panic("strtok_r token #2");
+
+	ptr = strtok_r(NULL, ",", &last);
+	if (ptr)
+		Panic("strtok_r result #3");
+
+	free(str);
+}
+
+#ifdef PROTOTYPES
+static void
+Check_vsnprintf(const int Len, const char *Format, ...)
+#else
+static void
+Check_vsnprintf(Len, Format, va_alist)
+const int Len;
+const char *Format;
+va_dcl
+#endif
+{
+	char str[5];
+	va_list ap;
+	int r;
+
+#ifdef PROTOTYPES
+	va_start(ap, Format);
+#else
+	va_start(ap);
+#endif
+	r = vsnprintf(str, sizeof(str), Format, ap);
+	va_end(ap);
+	if (r != Len) {
+		/* C99 states that vsnprintf() "returns the number of
+		 * characters that would have been printed if the n were
+		 * unlimited", but according to the Linux manual page "glibc
+		 * until 2.0.6 would return -1 when the output was truncated",
+		 * and other implementations (libUTIL on A/UX) even return the
+		 * number of characters processed ... so we only test our own
+		 * implementation and warn on errors otherwise :-/ */
+#ifdef HAVE_VSNPRINTF
+		fprintf(stderr,
+			"\n ** WARNING: The vsnprintf() function of this system isn't standard\n");
+		fprintf(stderr,
+			" ** conformant and returns a WRONG result: %d (should be %d)! The test\n",
+			r, Len);
+		fprintf(stderr,
+			" ** result has been ignored but may lead to errors during execution!\n\n");
+#else
+		Panic("vsnprintf return code");
+#endif
+	}
+	if (str[4] != '\0')
+		Panic("vsnprintf NULL byte");
+	if (strlen(str) != 4)
+		Panic("vsnprintf string length");
+}
+
+GLOBAL int
+main(void)
+{
+	/* validate datatypes */
+	if (false != 0)
+		Panic("false");
+	if (true != 1)
+		Panic("true");
+	if (sizeof(UINT8) != 1)
+		Panic("UINT8");
+	if (sizeof(UINT16) != 2)
+		Panic("UINT16");
+	if (sizeof(UINT32) != 4)
+		Panic("UINT32");
+
+	/* check functions */
+	Check_snprintf();
+	Check_strdup();
+	Check_strndup();
+	Check_strlcpy();
+	Check_strlcat();
+	Check_strtok_r();
+	Check_vsnprintf(2+10, "%s%s", "ab", "1234567890");
+
+	return 0;
+}
+
+/* -eof- */
diff --git a/ngircd/src/portab/strdup.c b/ngircd/src/portab/strdup.c
new file mode 100644
index 0000000..adb19e7
--- /dev/null
+++ b/ngircd/src/portab/strdup.c
@@ -0,0 +1,34 @@
+/*
+ * ngIRCd -- The Next Generation IRC Daemon
+ */
+
+#include "portab.h"
+
+/**
+ * @file
+ * strdup() implementation. Public domain.
+ */
+
+#ifndef HAVE_STRDUP
+
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+GLOBAL char *
+strdup(const char *s)
+{
+	char *dup;
+	size_t len = strlen(s);
+	size_t alloc = len + 1;
+
+	if (len >= alloc)
+		return NULL;
+	dup = malloc(alloc);
+	if (dup)
+		strlcpy(dup, s, alloc );
+
+	return dup;
+}
+
+#endif
diff --git a/ngircd/src/portab/strlcpy.c b/ngircd/src/portab/strlcpy.c
new file mode 100644
index 0000000..1f86a93
--- /dev/null
+++ b/ngircd/src/portab/strlcpy.c
@@ -0,0 +1,72 @@
+/*
+ * ngIRCd -- The Next Generation IRC Daemon
+ * Copyright (c)2001-2014 Alexander Barton (alex@barton.de) and Contributors.
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * Please read the file COPYING, README and AUTHORS for more information.
+ */
+
+#include "portab.h"
+
+/**
+ * @file
+ * strlcpy() and strlcat() replacement functions.
+ *
+ * See <http://www.openbsd.org/papers/strlcpy-paper.ps> for details.
+ *
+ * Code partially borrowed from compat.c of rsync, written by Andrew
+ * Tridgell (1998) and Martin Pool (2002):
+ * <http://cvs.samba.org/cgi-bin/cvsweb/rsync/lib/compat.c>
+ */
+
+#include <string.h>
+#include <sys/types.h>
+
+#ifndef HAVE_STRLCAT
+
+GLOBAL size_t
+strlcat( char *dst, const char *src, size_t size )
+{
+	/* Like strncat() but does not 0 fill the buffer and
+	 * always null terminates. */
+
+	size_t len1 = strlen( dst );
+	size_t len2 = strlen( src );
+	size_t ret = len1 + len2;
+
+	if( size && ( len1 < size - 1 )) {
+		if( len2 >= size - len1 )
+			len2 = size - len1 - 1;
+		memcpy( dst + len1, src, len2 );
+		dst[len1 + len2] = 0;
+	}
+	return ret;
+} /* strlcat */
+
+#endif
+
+#ifndef HAVE_STRLCPY
+
+GLOBAL size_t
+strlcpy( char *dst, const char *src, size_t size )
+{
+	/* Like strncpy but does not 0 fill the buffer and
+	 * always null terminates. */
+
+	size_t len = strlen( src );
+	size_t ret = len;
+
+	if( size > 0 ) {
+		if( len >= size ) len = size - 1;
+		memcpy( dst, src, len );
+		dst[len] = 0;
+	}
+	return ret;
+} /* strlcpy */
+
+#endif
+
+/* -eof- */
diff --git a/ngircd/src/portab/strndup.c b/ngircd/src/portab/strndup.c
new file mode 100644
index 0000000..d63b972
--- /dev/null
+++ b/ngircd/src/portab/strndup.c
@@ -0,0 +1,34 @@
+/*
+ * ngIRCd -- The Next Generation IRC Daemon
+ */
+
+#include "portab.h"
+
+/**
+ * @file
+ * strndup() implementation. Public domain.
+ */
+
+#ifndef HAVE_STRNDUP
+
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+GLOBAL char *
+strndup(const char *s, size_t maxlen)
+{
+	char *dup;
+	size_t len = strlen(s);
+
+	if (len > maxlen)
+		len = maxlen;
+	len++;
+	dup = malloc(len);
+	if (dup)
+		strlcpy(dup, s, len);
+
+	return dup;
+}
+
+#endif
diff --git a/ngircd/src/portab/strtok_r.c b/ngircd/src/portab/strtok_r.c
new file mode 100644
index 0000000..4d00772
--- /dev/null
+++ b/ngircd/src/portab/strtok_r.c
@@ -0,0 +1,36 @@
+/*
+ * ngIRCd -- The Next Generation IRC Daemon
+ */
+
+#include "portab.h"
+
+/**
+ * @file
+ * Implementation of strtok_r()
+ */
+
+#ifndef HAVE_STRTOK_R
+
+#include <string.h>
+
+char *
+strtok_r(char *str, const char *delim, char **saveptr)
+{
+	char *tmp;
+
+	if (!str)
+		str = *saveptr;
+	str += strspn(str, delim);
+	if (*str == 0)
+		return NULL;
+
+	tmp = str + strcspn(str, delim); /* get end of token */
+	if (*tmp) { /* another delimiter */
+		*tmp = 0;
+		tmp++;
+	}
+	*saveptr = tmp;
+	return str;
+}
+
+#endif
diff --git a/ngircd/src/portab/vsnprintf.c b/ngircd/src/portab/vsnprintf.c
new file mode 100644
index 0000000..d3b2a88
--- /dev/null
+++ b/ngircd/src/portab/vsnprintf.c
@@ -0,0 +1,799 @@
+/*
+ * ngIRCd -- The Next Generation IRC Daemon
+ * Copyright (c)2001,2002 by Alexander Barton (alex@barton.de)
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ * Please read the file COPYING, README and AUTHORS for more information.
+ */
+
+#include "portab.h"
+
+/**
+ * @file
+ * snprintf() and vsnprintf() replacement functions
+ */
+
+/*
+ * snprintf.c: Copyright Patrick Powell 1995
+ * This code is based on code written by Patrick Powell (papowell@astart.com)
+ * It may be used for any purpose as long as this notice remains intact
+ * on all source code distributions
+ *
+ * Original: Patrick Powell Tue Apr 11 09:48:21 PDT 1995
+ * A bombproof version of doprnt (dopr) included.
+ * Sigh. This sort of thing is always nasty do deal with. Note that
+ * the version here does not include floating point...
+ *
+ * snprintf() is used instead of sprintf() as it does limit checks
+ * for string length. This covers a nasty loophole.
+ *
+ * The other functions are there to prevent NULL pointers from
+ * causing nast effects.
+ *
+ * More Recently:
+ *  Brandon Long <blong@fiction.net> 9/15/96 for mutt 0.43
+ *  This was ugly. It is still ugly. I opted out of floating point
+ *  numbers, but the formatter understands just about everything
+ *  from the normal C string format, at least as far as I can tell from
+ *  the Solaris 2.5 printf(3S) man page.
+ *
+ * Brandon Long <blong@fiction.net> 10/22/97 for mutt 0.87.1
+ *  Ok, added some minimal floating point support, which means this
+ *  probably requires libm on most operating systems. Don't yet
+ *  support the exponent (e,E) and sigfig (g,G). Also, fmtint()
+ *  was pretty badly broken, it just wasn't being exercised in ways
+ *  which showed it, so that's been fixed. Also, formatted the code
+ *  to mutt conventions, and removed dead code left over from the
+ *  original. Also, there is now a builtin-test, just compile with:
+ *    gcc -DTEST_SNPRINTF -o snprintf snprintf.c -lm
+ *  and run snprintf for results.
+ *
+ * Thomas Roessler <roessler@guug.de> 01/27/98 for mutt 0.89i
+ *  The PGP code was using unsigned hexadecimal formats.
+ *  Unfortunately, unsigned formats simply didn't work.
+ *
+ * Michael Elkins <me@cs.hmc.edu> 03/05/98 for mutt 0.90.8
+ *  The original code assumed that both snprintf() and vsnprintf() were
+ *  missing. Some systems only have snprintf() but not vsnprintf(), so
+ *  the code is now broken down under HAVE_SNPRINTF and HAVE_VSNPRINTF.
+ *
+ * Andrew Tridgell <tridge@samba.org>, October 1998
+ *  fixed handling of %.0f
+ *  added test for HAVE_LONG_DOUBLE
+ *
+ * tridge@samba.org, idra@samba.org, April 2001
+ *  got rid of fcvt code (twas buggy and made testing harder)
+ *  added C99 semantics
+ *
+ * Alexander Barton, <alex@barton.de>, 2002-05-19
+ *  removed [v]asprintf() and C99 tests: not needed by ngIRCd.
+ */
+
+#ifdef HAVE_STRING_H
+#include <string.h>
+#endif
+#ifdef HAVE_STRINGS_H
+#include <strings.h>
+#endif
+#ifdef HAVE_CTYPE_H
+#include <ctype.h>
+#endif
+#include <sys/types.h>
+#include <stdarg.h>
+#ifdef HAVE_STDLIB_H
+#include <stdlib.h>
+#endif
+
+#if defined(HAVE_SNPRINTF) && defined(HAVE_VSNPRINTF)
+/* only include stdio.h if we are not re-defining snprintf or vsnprintf */
+#include <stdio.h>
+/* make the compiler happy with an empty file */
+void dummy_snprintf PARAMS(( void ));
+void dummy_snprintf PARAMS(( void )) { }
+#else
+
+#ifdef HAVE_LONG_DOUBLE
+#define LDOUBLE long double
+#else
+#define LDOUBLE double
+#endif
+
+#ifdef HAVE_LONG_LONG
+#define LLONG long long
+#else
+#define LLONG long
+#endif
+
+static size_t dopr PARAMS((char *buffer, size_t maxlen, const char *format,
+			   va_list args));
+static void fmtstr PARAMS((char *buffer, size_t *currlen, size_t maxlen,
+			   char *value, int flags, int min, int max));
+static void fmtint PARAMS((char *buffer, size_t *currlen, size_t maxlen,
+			   long value, int base, int min, int max, int flags));
+static void fmtfp PARAMS((char *buffer, size_t *currlen, size_t maxlen,
+			  LDOUBLE fvalue, int min, int max, int flags));
+static void dopr_outch PARAMS((char *buffer, size_t *currlen, size_t maxlen,
+			       char c));
+
+/*
+ * dopr(): poor man's version of doprintf
+ */
+
+/* format read states */
+#define DP_S_DEFAULT 0
+#define DP_S_FLAGS   1
+#define DP_S_MIN     2
+#define DP_S_DOT     3
+#define DP_S_MAX     4
+#define DP_S_MOD     5
+#define DP_S_CONV    6
+#define DP_S_DONE    7
+
+/* format flags - Bits */
+#define DP_F_MINUS      (1 << 0)
+#define DP_F_PLUS       (1 << 1)
+#define DP_F_SPACE      (1 << 2)
+#define DP_F_NUM	(1 << 3)
+#define DP_F_ZERO       (1 << 4)
+#define DP_F_UP	 (1 << 5)
+#define DP_F_UNSIGNED   (1 << 6)
+
+/* Conversion Flags */
+#define DP_C_SHORT   1
+#define DP_C_LONG    2
+#define DP_C_LDOUBLE 3
+#define DP_C_LLONG   4
+
+#define char_to_int(p) ((p)- '0')
+#ifndef MAX
+#define MAX(p,q) (((p) >= (q)) ? (p) : (q))
+#endif
+
+static size_t
+dopr(char *buffer, size_t maxlen, const char *format, va_list args)
+{
+	char ch;
+	LLONG value;
+	LDOUBLE fvalue;
+	char *strvalue;
+	int min;
+	int max;
+	int state;
+	int flags;
+	int cflags;
+	size_t currlen;
+
+	state = DP_S_DEFAULT;
+	currlen = flags = cflags = min = 0;
+	max = -1;
+	ch = *format++;
+
+	while (state != DP_S_DONE) {
+		if (ch == '\0')
+			state = DP_S_DONE;
+
+		switch(state) {
+		case DP_S_DEFAULT:
+			if (ch == '%')
+				state = DP_S_FLAGS;
+			else
+				dopr_outch (buffer, &currlen, maxlen, ch);
+			ch = *format++;
+			break;
+		case DP_S_FLAGS:
+			switch (ch) {
+			case '-':
+				flags |= DP_F_MINUS;
+				ch = *format++;
+				break;
+			case '+':
+				flags |= DP_F_PLUS;
+				ch = *format++;
+				break;
+			case ' ':
+				flags |= DP_F_SPACE;
+				ch = *format++;
+				break;
+			case '#':
+				flags |= DP_F_NUM;
+				ch = *format++;
+				break;
+			case '0':
+				flags |= DP_F_ZERO;
+				ch = *format++;
+				break;
+			default:
+				state = DP_S_MIN;
+				break;
+			}
+			break;
+		case DP_S_MIN:
+			if (isdigit((unsigned char)ch)) {
+				min = 10*min + char_to_int (ch);
+				ch = *format++;
+			} else if (ch == '*') {
+				min = va_arg (args, int);
+				ch = *format++;
+				state = DP_S_DOT;
+			} else {
+				state = DP_S_DOT;
+			}
+			break;
+		case DP_S_DOT:
+			if (ch == '.') {
+				state = DP_S_MAX;
+				ch = *format++;
+			} else {
+				state = DP_S_MOD;
+			}
+			break;
+		case DP_S_MAX:
+			if (isdigit((unsigned char)ch)) {
+				if (max < 0)
+					max = 0;
+				max = 10*max + char_to_int (ch);
+				ch = *format++;
+			} else if (ch == '*') {
+				max = va_arg (args, int);
+				ch = *format++;
+				state = DP_S_MOD;
+			} else {
+				state = DP_S_MOD;
+			}
+			break;
+		case DP_S_MOD:
+			switch (ch) {
+			case 'h':
+				cflags = DP_C_SHORT;
+				ch = *format++;
+				break;
+			case 'l':
+				cflags = DP_C_LONG;
+				ch = *format++;
+				if (ch == 'l') {	/* It's a long long */
+					cflags = DP_C_LLONG;
+					ch = *format++;
+				}
+				break;
+			case 'L':
+				cflags = DP_C_LDOUBLE;
+				ch = *format++;
+				break;
+			default:
+				break;
+			}
+			state = DP_S_CONV;
+			break;
+		case DP_S_CONV:
+			switch (ch) {
+			case 'd':
+			case 'i':
+				if (cflags == DP_C_SHORT)
+					value = va_arg (args, int);
+				else if (cflags == DP_C_LONG)
+					value = va_arg (args, long int);
+				else if (cflags == DP_C_LLONG)
+					value = va_arg (args, LLONG);
+				else
+					value = va_arg (args, int);
+				fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+				break;
+			case 'o':
+				flags |= DP_F_UNSIGNED;
+				if (cflags == DP_C_SHORT)
+					value = va_arg (args, unsigned int);
+				else if (cflags == DP_C_LONG)
+					value = (long)va_arg (args, unsigned long int);
+				else if (cflags == DP_C_LLONG)
+					value = (long)va_arg (args, unsigned LLONG);
+				else
+					value = (long)va_arg (args, unsigned int);
+				fmtint (buffer, &currlen, maxlen, value, 8, min, max, flags);
+				break;
+			case 'u':
+				flags |= DP_F_UNSIGNED;
+				if (cflags == DP_C_SHORT)
+					value = va_arg (args, unsigned int);
+				else if (cflags == DP_C_LONG)
+					value = (long)va_arg (args, unsigned long int);
+				else if (cflags == DP_C_LLONG)
+					value = (LLONG)va_arg (args, unsigned LLONG);
+				else
+					value = (long)va_arg (args, unsigned int);
+				fmtint (buffer, &currlen, maxlen, value, 10, min, max, flags);
+				break;
+			case 'X':
+				flags |= DP_F_UP;
+			case 'x':
+				flags |= DP_F_UNSIGNED;
+				if (cflags == DP_C_SHORT)
+					value = va_arg (args, unsigned int);
+				else if (cflags == DP_C_LONG)
+					value = (long)va_arg (args, unsigned long int);
+				else if (cflags == DP_C_LLONG)
+					value = (LLONG)va_arg (args, unsigned LLONG);
+				else
+					value = (long)va_arg (args, unsigned int);
+				fmtint (buffer, &currlen, maxlen, value, 16, min, max, flags);
+				break;
+			case 'f':
+				if (cflags == DP_C_LDOUBLE)
+					fvalue = va_arg (args, LDOUBLE);
+				else
+					fvalue = va_arg (args, double);
+				/* um, floating point? */
+				fmtfp (buffer, &currlen, maxlen, fvalue, min, max, flags);
+				break;
+			case 'E':
+				flags |= DP_F_UP;
+			case 'e':
+				if (cflags == DP_C_LDOUBLE)
+					fvalue = va_arg (args, LDOUBLE);
+				else
+					fvalue = va_arg (args, double);
+				break;
+			case 'G':
+				flags |= DP_F_UP;
+			case 'g':
+				if (cflags == DP_C_LDOUBLE)
+					fvalue = va_arg (args, LDOUBLE);
+				else
+					fvalue = va_arg (args, double);
+				break;
+			case 'c':
+				dopr_outch (buffer, &currlen, maxlen, va_arg (args, int));
+				break;
+			case 's':
+				strvalue = va_arg (args, char *);
+				if (max == -1) {
+					max = strlen(strvalue);
+				}
+				if (min > 0 && max >= 0 && min > max) max = min;
+				fmtstr (buffer, &currlen, maxlen, strvalue, flags, min, max);
+				break;
+			case 'p':
+				strvalue = va_arg (args, void *);
+				fmtint (buffer, &currlen, maxlen, (long) strvalue, 16, min, max, flags);
+				break;
+			case 'n':
+				if (cflags == DP_C_SHORT) {
+					short int *num;
+					num = va_arg (args, short int *);
+					*num = currlen;
+				} else if (cflags == DP_C_LONG) {
+					long int *num;
+					num = va_arg (args, long int *);
+					*num = (long int)currlen;
+				} else if (cflags == DP_C_LLONG) {
+					LLONG *num;
+					num = va_arg (args, LLONG *);
+					*num = (LLONG)currlen;
+				} else {
+					int *num;
+					num = va_arg (args, int *);
+					*num = currlen;
+				}
+				break;
+			case '%':
+				dopr_outch (buffer, &currlen, maxlen, ch);
+				break;
+			case 'w':
+				/* not supported yet, treat as next char */
+				ch = *format++;
+				break;
+			default:
+				/* Unknown, skip */
+				break;
+			}
+			ch = *format++;
+			state = DP_S_DEFAULT;
+			flags = cflags = min = 0;
+			max = -1;
+			break;
+		case DP_S_DONE:
+			break;
+		default:
+			/* hmm? */
+			break; /* some picky compilers need this */
+		}
+	}
+	if (maxlen != 0) {
+		if (currlen < maxlen - 1)
+			buffer[currlen] = '\0';
+		else if (maxlen > 0)
+			buffer[maxlen - 1] = '\0';
+	}
+
+	return currlen;
+}
+
+static void
+fmtstr(char *buffer, size_t *currlen, size_t maxlen, char *value, int flags,
+       int min, int max)
+{
+	int padlen, strln;     /* amount to pad */
+	int cnt = 0;
+
+#ifdef DEBUG_SNPRINTF
+	printf("fmtstr min=%d max=%d s=[%s]\n", min, max, value);
+#endif
+	if (value == 0) {
+		value = "<NULL>";
+	}
+
+	for (strln = 0; value[strln]; ++strln); /* strlen */
+	padlen = min - strln;
+	if (padlen < 0)
+		padlen = 0;
+	if (flags & DP_F_MINUS)
+		padlen = -padlen; /* Left Justify */
+
+	while ((padlen > 0) && (cnt < max)) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		--padlen;
+		++cnt;
+	}
+	while (*value && (cnt < max)) {
+		dopr_outch (buffer, currlen, maxlen, *value++);
+		++cnt;
+	}
+	while ((padlen < 0) && (cnt < max)) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		++padlen;
+		++cnt;
+	}
+}
+
+/* Have to handle DP_F_NUM (ie 0x and 0 alternates) */
+
+static void
+fmtint(char *buffer, size_t *currlen, size_t maxlen, long value, int base,
+       int min, int max, int flags)
+{
+	int signvalue = 0;
+	unsigned long uvalue;
+	char convert[20];
+	int place = 0;
+	int spadlen = 0; /* amount to space pad */
+	int zpadlen = 0; /* amount to zero pad */
+	int caps = 0;
+
+	if (max < 0)
+		max = 0;
+
+	uvalue = value;
+
+	if(!(flags & DP_F_UNSIGNED)) {
+		if( value < 0 ) {
+			signvalue = '-';
+			uvalue = -value;
+		} else {
+			if (flags & DP_F_PLUS)  /* Do a sign (+/i) */
+				signvalue = '+';
+			else if (flags & DP_F_SPACE)
+				signvalue = ' ';
+		}
+	}
+
+	if (flags & DP_F_UP) caps = 1; /* Should characters be upper case? */
+
+	do {
+		convert[place++] =
+			(caps? "0123456789ABCDEF":"0123456789abcdef")
+			[uvalue % (unsigned)base  ];
+		uvalue = (uvalue / (unsigned)base );
+	} while(uvalue && (place < 20));
+	if (place == 20) place--;
+	convert[place] = 0;
+
+	zpadlen = max - place;
+	spadlen = min - MAX (max, place) - (signvalue ? 1 : 0);
+	if (zpadlen < 0) zpadlen = 0;
+	if (spadlen < 0) spadlen = 0;
+	if (flags & DP_F_ZERO) {
+		zpadlen = MAX(zpadlen, spadlen);
+		spadlen = 0;
+	}
+	if (flags & DP_F_MINUS)
+		spadlen = -spadlen; /* Left Justifty */
+
+#ifdef DEBUG_SNPRINTF
+	printf("zpad: %d, spad: %d, min: %d, max: %d, place: %d\n",
+	       zpadlen, spadlen, min, max, place);
+#endif
+
+	/* Spaces */
+	while (spadlen > 0) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		--spadlen;
+	}
+
+	/* Sign */
+	if (signvalue)
+		dopr_outch (buffer, currlen, maxlen, signvalue);
+
+	/* Zeros */
+	if (zpadlen > 0) {
+		while (zpadlen > 0) {
+			dopr_outch (buffer, currlen, maxlen, '0');
+			--zpadlen;
+		}
+	}
+
+	/* Digits */
+	while (place > 0)
+		dopr_outch (buffer, currlen, maxlen, convert[--place]);
+
+	/* Left Justified spaces */
+	while (spadlen < 0) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		++spadlen;
+	}
+}
+
+static LDOUBLE
+abs_val(LDOUBLE value)
+{
+	LDOUBLE result = value;
+
+	if (value < 0)
+		result = -value;
+
+	return result;
+}
+
+static LDOUBLE
+POW10(int exp)
+{
+	LDOUBLE result = 1;
+
+	while (exp) {
+		result *= 10;
+		exp--;
+	}
+
+	return result;
+}
+
+static LLONG
+ROUND(LDOUBLE value)
+{
+	LLONG intpart;
+
+	intpart = (LLONG)value;
+	value = value - intpart;
+	if (value >= 0.5) intpart++;
+
+	return intpart;
+}
+
+/* a replacement for modf that doesn't need the math library. Should
+   be portable, but slow */
+static double
+my_modf(double x0, double *iptr)
+{
+	int i;
+	long l;
+	double x = x0;
+	double f = 1.0;
+
+	for (i=0;i<100;i++) {
+		l = (long)x;
+		if (l <= (x+1) && l >= (x-1)) break;
+		x *= 0.1;
+		f *= 10.0;
+	}
+
+	if (i == 100) {
+		/* yikes! the number is beyond what we can handle. What do we do? */
+		(*iptr) = 0;
+		return 0;
+	}
+
+	if (i != 0) {
+		double i2;
+		double ret;
+
+		ret = my_modf(x0-l*f, &i2);
+		(*iptr) = l*f + i2;
+		return ret;
+	}
+
+	(*iptr) = l;
+	return x - (*iptr);
+}
+
+
+static void
+fmtfp (char *buffer, size_t *currlen, size_t maxlen, LDOUBLE fvalue,
+       int min, int max, int flags)
+{
+	int signvalue = 0;
+	double ufvalue;
+	char iconvert[311];
+	char fconvert[311];
+	int iplace = 0;
+	int fplace = 0;
+	int padlen = 0; /* amount to pad */
+	int zpadlen = 0;
+	int caps = 0;
+	int index;
+	double intpart;
+	double fracpart;
+	double temp;
+
+	/*
+	 * AIX manpage says the default is 0, but Solaris says the default
+	 * is 6, and sprintf on AIX defaults to 6
+	 */
+	if (max < 0)
+		max = 6;
+
+	ufvalue = abs_val (fvalue);
+
+	if (fvalue < 0) {
+		signvalue = '-';
+	} else {
+		if (flags & DP_F_PLUS) { /* Do a sign (+/i) */
+			signvalue = '+';
+		} else {
+			if (flags & DP_F_SPACE)
+				signvalue = ' ';
+		}
+	}
+
+	/*
+	 * Sorry, we only support 16 digits past the decimal because of our
+	 * conversion method
+	 */
+	if (max > 16)
+		max = 16;
+
+	/* We "cheat" by converting the fractional part to integer by
+	 * multiplying by a factor of 10
+	 */
+
+	temp = ufvalue;
+	my_modf(temp, &intpart);
+
+	fracpart = ROUND((POW10(max)) * (ufvalue - intpart));
+
+	if (fracpart >= POW10(max)) {
+		intpart++;
+		fracpart -= POW10(max);
+	}
+
+
+	/* Convert integer part */
+	do {
+		temp = intpart;
+		my_modf(intpart*0.1, &intpart);
+		temp = temp*0.1;
+		index = (int) ((temp -intpart +0.05)* 10.0);
+		/* index = (int) (((double)(temp*0.1) -intpart +0.05) *10.0); */
+		/* printf ("%llf, %f, %x\n", temp, intpart, index); */
+		iconvert[iplace++] =
+			(caps? "0123456789ABCDEF":"0123456789abcdef")[index];
+	} while (intpart && (iplace < 311));
+	if (iplace == 311) iplace--;
+	iconvert[iplace] = 0;
+
+	/* Convert fractional part */
+	if (fracpart)
+	{
+		do {
+			temp = fracpart;
+			my_modf(fracpart*0.1, &fracpart);
+			temp = temp*0.1;
+			index = (int) ((temp -fracpart +0.05)* 10.0);
+			/* index = (int) ((((temp/10) -fracpart) +0.05) *10); */
+			/* printf ("%lf, %lf, %ld\n", temp, fracpart, index); */
+			fconvert[fplace++] =
+			(caps? "0123456789ABCDEF":"0123456789abcdef")[index];
+		} while(fracpart && (fplace < 311));
+		if (fplace == 311) fplace--;
+	}
+	fconvert[fplace] = 0;
+
+	/* -1 for decimal point, another -1 if we are printing a sign */
+	padlen = min - iplace - max - 1 - ((signvalue) ? 1 : 0);
+	zpadlen = max - fplace;
+	if (zpadlen < 0) zpadlen = 0;
+	if (padlen < 0)
+		padlen = 0;
+	if (flags & DP_F_MINUS)
+		padlen = -padlen; /* Left Justifty */
+
+	if ((flags & DP_F_ZERO) && (padlen > 0)) {
+		if (signvalue) {
+			dopr_outch (buffer, currlen, maxlen, signvalue);
+			--padlen;
+			signvalue = 0;
+		}
+		while (padlen > 0) {
+			dopr_outch (buffer, currlen, maxlen, '0');
+			--padlen;
+		}
+	}
+	while (padlen > 0) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		--padlen;
+	}
+	if (signvalue)
+		dopr_outch (buffer, currlen, maxlen, signvalue);
+
+	while (iplace > 0)
+		dopr_outch (buffer, currlen, maxlen, iconvert[--iplace]);
+
+#ifdef DEBUG_SNPRINTF
+	printf("fmtfp: fplace=%d zpadlen=%d\n", fplace, zpadlen);
+#endif
+
+	/*
+	 * Decimal point.  This should probably use locale to find the correct
+	 * char to print out.
+	 */
+	if (max > 0) {
+		dopr_outch (buffer, currlen, maxlen, '.');
+
+		while (fplace > 0)
+			dopr_outch (buffer, currlen, maxlen, fconvert[--fplace]);
+	}
+
+	while (zpadlen > 0) {
+		dopr_outch (buffer, currlen, maxlen, '0');
+		--zpadlen;
+	}
+
+	while (padlen < 0) {
+		dopr_outch (buffer, currlen, maxlen, ' ');
+		++padlen;
+	}
+}
+
+static void
+dopr_outch(char *buffer, size_t *currlen, size_t maxlen, char c)
+{
+	if (*currlen < maxlen) {
+		buffer[(*currlen)] = c;
+	}
+	(*currlen)++;
+}
+
+#if !defined(HAVE_VSNPRINTF)
+int
+vsnprintf (char *str, size_t count, const char *fmt, va_list args)
+{
+	return dopr(str, count, fmt, args);
+}
+#endif
+
+#if !defined(HAVE_SNPRINTF)
+#ifdef PROTOTYPES
+int
+snprintf(char *str, size_t count, const char *fmt, ...)
+#else
+int
+snprintf(str, count, fmt, va_alist)
+char *str;
+size_t count;
+const char *fmt;
+va_dcl
+#endif
+{
+	size_t ret;
+	va_list ap;
+
+	va_start(ap, fmt);
+	ret = vsnprintf(str, count, fmt, ap);
+	va_end(ap);
+	return ret;
+}
+#endif
+
+#endif
+
+/* -eof- */
diff --git a/ngircd/src/portab/waitpid.c b/ngircd/src/portab/waitpid.c
new file mode 100644
index 0000000..921dd3d
--- /dev/null
+++ b/ngircd/src/portab/waitpid.c
@@ -0,0 +1,30 @@
+/*
+ * ngIRCd -- The Next Generation IRC Daemon
+ */
+
+#include "portab.h"
+
+/**
+ * @file
+ * waitpid() implementation. Public domain.
+ * Written by Steven D. Blackford for the NeXT system.
+ */
+
+#ifndef HAVE_WAITPID
+
+#include <string.h>
+#include <stdlib.h>
+#include <sys/types.h>
+
+GLOBAL int
+waitpid(pid, stat_loc, options)
+int pid, *stat_loc, options;
+{
+	for (;;) {
+		int wpid = wait(stat_loc);
+		if (wpid == pid || wpid == -1)
+			return wpid;
+	}
+}
+
+#endif