summaryrefslogtreecommitdiff
path: root/ngircd/src/portab
diff options
context:
space:
mode:
Diffstat (limited to 'ngircd/src/portab')
-rw-r--r--ngircd/src/portab/Makefile.ng41
-rw-r--r--ngircd/src/portab/portab.h184
-rw-r--r--ngircd/src/portab/portabtest.c206
-rw-r--r--ngircd/src/portab/strdup.c34
-rw-r--r--ngircd/src/portab/strlcpy.c72
-rw-r--r--ngircd/src/portab/strndup.c34
-rw-r--r--ngircd/src/portab/strtok_r.c36
-rw-r--r--ngircd/src/portab/vsnprintf.c799
-rw-r--r--ngircd/src/portab/waitpid.c30
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
generated by cgit v1.0 at 2025-12-29 15:24:43 +0000