- (internal) move osdep to libbbsutil

git-svn-id: http://opensvn.csie.org/pttbbs/trunk/pttbbs@4026 63ad8ddf-47c3-0310-b6dd-a9e9d9715204

3 files changed, 630 insertions, 1 deletions

diff --git a/src/libbbsutil/Makefile b/src/libbbsutil/Makefile
index d5b20637..aaaf62d2 100644
--- a/src/libbbsutil/Makefile
+++ b/src/libbbsutil/Makefile
@@ -4,7 +4,7 @@ SRCROOT=	../..
 
 CFLAGS+=	-I$(SRCROOT)/include
 
-OBJS=	file.o lock.o log.o net.o sort.o string.o time.o crypt.o
+OBJS=	file.o lock.o log.o net.o sort.o string.o time.o crypt.o osdep.o
 TARGET=	libbbsutil.a
 
 
diff --git a/src/libbbsutil/alloc.c b/src/libbbsutil/alloc.c
new file mode 100644
index 00000000..de676ce4
--- /dev/null
+++ b/src/libbbsutil/alloc.c
@@ -0,0 +1,254 @@
+/*
+ * malloc/free by O.Dreesen
+ *
+ * first TRY:
+ *   lists w/magics
+ * and now the second TRY
+ *   let the kernel map all the stuff (if there is something to do)
+ */
+
+#include <unistd.h>
+#include <sys/mman.h>
+#include <errno.h>
+
+#include <sys/cdefs.h>
+#include <sys/types.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include <sys/shm.h>	/* for PAGE_SIZE */
+
+
+/* -- HELPER CODE --------------------------------------------------------- */
+
+#ifndef MAP_FAILED
+#define MAP_FAILED ((void*)-1)
+#endif
+
+#ifndef NULL
+#define NULL ((void*)0)
+#endif
+
+typedef struct {
+  void*  next;
+  size_t size;
+} __alloc_t;
+
+#define BLOCK_START(b)	(((void*)(b))-sizeof(__alloc_t))
+#define BLOCK_RET(b)	(((void*)(b))+sizeof(__alloc_t))
+
+#define MEM_BLOCK_SIZE	PAGE_SIZE
+#define PAGE_ALIGN(s)	(((s)+MEM_BLOCK_SIZE-1)&(unsigned long)(~(MEM_BLOCK_SIZE-1)))
+
+/* a simple mmap :) */
+#if defined(__i386__)
+#define REGPARM(x) __attribute__((regparm(x)))
+#else
+#define REGPARM(x)
+#endif
+
+static void REGPARM(1) *do_mmap(size_t size) {
+  return mmap(0, size, PROT_READ|PROT_WRITE, MAP_ANONYMOUS|MAP_PRIVATE, -1, (size_t)0);
+}
+
+/* -- SMALL MEM ----------------------------------------------------------- */
+
+static __alloc_t* __small_mem[8];
+
+static int smallalloc[8];
+static int smallalloc_max[8];
+
+#define __SMALL_NR(i)		(MEM_BLOCK_SIZE/(i))
+
+#define __MIN_SMALL_SIZE	__SMALL_NR(256)		/*   16 /   32 */
+#define __MAX_SMALL_SIZE	__SMALL_NR(2)		/* 2048 / 4096 */
+
+#define GET_SIZE(s)		(__MIN_SMALL_SIZE<<get_index((s)))
+
+#define FIRST_SMALL(p)		(((unsigned long)(p))&(~(MEM_BLOCK_SIZE-1)))
+
+static inline int __ind_shift() { return (MEM_BLOCK_SIZE==4096)?4:5; }
+
+static size_t REGPARM(1) get_index(size_t _size) {
+  register size_t idx=0;
+//  if (_size) {	/* we already check this in the callers */
+    register size_t size=((_size-1)&(MEM_BLOCK_SIZE-1))>>__ind_shift();
+    while(size) { size>>=1; ++idx; }
+//  }
+  return idx;
+}
+
+/* small mem */
+static void __small_free(void*_ptr,size_t _size) REGPARM(2);
+
+static void REGPARM(2) __small_free(void*_ptr,size_t _size) {
+  __alloc_t* ptr=BLOCK_START(_ptr);
+  size_t size=_size;
+  size_t idx=get_index(size);
+
+  memset(ptr,0,size);	/* allways zero out small mem */
+
+  ptr->next=__small_mem[idx];
+  __small_mem[idx]=ptr;
+
+  smallalloc[idx]--;
+
+  if (MEM_BLOCK_SIZE == PAGE_SIZE &&
+	  smallalloc[idx] == 0 &&
+	  smallalloc_max[idx] < __SMALL_NR(size)) {
+      __alloc_t* p = __small_mem[idx];
+      __alloc_t* ph = p - (size_t)p%PAGE_SIZE;
+      munmap(ph, MEM_BLOCK_SIZE);
+      __small_mem[idx] = 0;
+  }
+}
+
+static void* REGPARM(1) __small_malloc(size_t _size) {
+  __alloc_t *ptr;
+  size_t size=_size;
+  size_t idx;
+
+  idx=get_index(size);
+  ptr=__small_mem[idx];
+
+  if (ptr==0)  {	/* no free blocks ? */
+    register int i,nr;
+    ptr=do_mmap(MEM_BLOCK_SIZE);
+    if (ptr==MAP_FAILED) return MAP_FAILED;
+
+    __small_mem[idx]=ptr;
+
+    nr=__SMALL_NR(size)-1;
+    for (i=0;i<nr;i++) {
+      ptr->next=(((void*)ptr)+size);
+      ptr=ptr->next;
+    }
+    ptr->next=0;
+
+    ptr=__small_mem[idx];
+  }
+
+  /* get a free block */
+  __small_mem[idx]=ptr->next;
+  ptr->next=0;
+
+  smallalloc[idx]++;
+  if(smallalloc[idx] > smallalloc_max[idx])
+      smallalloc_max[idx] = smallalloc[idx];
+
+  return ptr;
+}
+
+/* -- PUBLIC FUNCTIONS ---------------------------------------------------- */
+
+static void _alloc_libc_free(void *ptr) {
+  register size_t size;
+  if (ptr) {
+    size=((__alloc_t*)BLOCK_START(ptr))->size;
+    if (size) {
+      if (size<=__MAX_SMALL_SIZE)
+	__small_free(ptr,size);
+      else
+	munmap(BLOCK_START(ptr),size);
+    }
+  }
+}
+void __libc_free(void *ptr) __attribute__((alias("_alloc_libc_free")));
+void free(void *ptr) __attribute__((weak,alias("_alloc_libc_free")));
+void if_freenameindex(void* ptr) __attribute__((alias("free")));
+
+#ifdef WANT_MALLOC_ZERO
+static __alloc_t zeromem[2];
+#endif
+
+static void* _alloc_libc_malloc(size_t size) {
+  __alloc_t* ptr;
+  size_t need;
+#ifdef WANT_MALLOC_ZERO
+  if (!size) return BLOCK_RET(zeromem);
+#else
+  if (!size) goto err_out;
+#endif
+  size+=sizeof(__alloc_t);
+  if (size<sizeof(__alloc_t)) goto err_out;
+  if (size<=__MAX_SMALL_SIZE) {
+    need=GET_SIZE(size);
+    ptr=__small_malloc(need);
+  }
+  else {
+    need=PAGE_ALIGN(size);
+    if (!need) ptr=MAP_FAILED; else ptr=do_mmap(need);
+  }
+  if (ptr==MAP_FAILED) goto err_out;
+  ptr->size=need;
+  return BLOCK_RET(ptr);
+err_out:
+  (*__errno_location())=ENOMEM;
+  return 0;
+}
+void* __libc_malloc(size_t size) __attribute__((alias("_alloc_libc_malloc")));
+void* malloc(size_t size) __attribute__((weak,alias("_alloc_libc_malloc")));
+
+void* __libc_calloc(size_t nmemb, size_t _size);
+void* __libc_calloc(size_t nmemb, size_t _size) {
+  register size_t size=_size*nmemb;
+  if (nmemb && size/nmemb!=_size) {
+    (*__errno_location())=ENOMEM;
+    return 0;
+  }
+  return malloc(size);
+}
+void* calloc(size_t nmemb, size_t _size) __attribute__((weak,alias("__libc_calloc")));
+
+void* __libc_realloc(void* ptr, size_t _size);
+void* __libc_realloc(void* ptr, size_t _size) {
+  register size_t size=_size;
+  if (ptr) {
+    if (size) {
+      __alloc_t* tmp=BLOCK_START(ptr);
+      size+=sizeof(__alloc_t);
+      if (size<sizeof(__alloc_t)) goto retzero;
+      size=(size<=__MAX_SMALL_SIZE)?GET_SIZE(size):PAGE_ALIGN(size);
+      if (tmp->size!=size) {
+	if ((tmp->size<=__MAX_SMALL_SIZE)) {
+	  void *new=_alloc_libc_malloc(_size);
+	  if (new) {
+	    register __alloc_t* foo=BLOCK_START(new);
+	    size=foo->size;
+	    if (size>tmp->size) size=tmp->size;
+	    if (size) memcpy(new,ptr,size-sizeof(__alloc_t));
+	    _alloc_libc_free(ptr);
+	  }
+	  ptr=new;
+	}
+	else {
+	  register __alloc_t* foo;
+	  size=PAGE_ALIGN(size);
+	  foo=mremap(tmp,tmp->size,size,MREMAP_MAYMOVE);
+	  if (foo==MAP_FAILED) {
+retzero:
+	    (*__errno_location())=ENOMEM;
+	    ptr=0;
+	  }
+	  else {
+	    foo->size=size;
+	    ptr=BLOCK_RET(foo);
+	  }
+	}
+      }
+    }
+    else { /* size==0 */
+      _alloc_libc_free(ptr);
+      ptr = NULL;
+    }
+  }
+  else { /* ptr==0 */
+    if (size) {
+      ptr=_alloc_libc_malloc(size);
+    }
+  }
+  return ptr;
+}
+void* realloc(void* ptr, size_t size) __attribute__((weak,alias("__libc_realloc")));
+
diff --git a/src/libbbsutil/osdep.c b/src/libbbsutil/osdep.c
new file mode 100644
index 00000000..f4d68ead
--- /dev/null
+++ b/src/libbbsutil/osdep.c
@@ -0,0 +1,375 @@
+/* $Id$ */
+#include "osdep.h"
+#include <stdio.h>
+#include <stdlib.h>
+#include <stdarg.h>
+
+#ifdef NEED_STRLCAT
+
+#include <sys/types.h>
+#include <string.h>
+
+/*   size_t
+ *   strlcat(char *dst, const char *src, size_t size);
+ */
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Appends src to string dst of size siz (unlike strncat, siz is the
+ * full size of dst, not space left).  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz <= strlen(dst)).
+ * Returns strlen(src) + MIN(siz, strlen(initial dst)).
+ * If retval >= siz, truncation occurred.
+ */
+size_t
+strlcat(dst, src, siz)
+    char *dst;
+    const char *src;
+    size_t siz;
+{
+    char *d = dst;
+    const char *s = src;
+    size_t n = siz;
+    size_t dlen;
+
+    /* Find the end of dst and adjust bytes left but don't go past end */
+    while (n-- != 0 && *d != '\0')
+	d++;
+    dlen = d - dst;
+    n = siz - dlen;
+
+    if (n == 0)
+	return(dlen + strlen(s));
+    while (*s != '\0') {
+	if (n != 1) {
+	    *d++ = *s;
+	    n--;
+	}
+	s++;
+    }
+    *d = '\0';
+
+    return(dlen + (s - src));	/* count does not include NUL */
+}
+
+#endif
+
+#ifdef NEED_TIMEGM
+
+#include <time.h>
+#include <stdlib.h>
+
+time_t timegm (struct tm *tm)
+{
+    time_t ret;
+    char *tz;
+
+    tz = getenv("TZ");
+    putenv("TZ=");
+    tzset();
+    ret = mktime(tm);
+
+    if (tz){
+	char *buff = malloc( strlen(tz) + 10);
+	sprintf( buff, "TZ=%s", tz);
+	putenv(buff);
+	free(buff);
+    }
+    else
+	unsetenv("TZ");
+    tzset();
+
+    return ret;
+}
+
+#endif
+
+#ifdef NEED_STRLCPY
+
+/* ------------------------------------------------------------------------ */
+
+/*   size_t
+ *   strlcpy(char *dst, const char *src, size_t size);
+ */
+
+/*
+ * Copyright (c) 1998 Todd C. Miller <Todd.Miller@courtesan.com>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 1. Redistributions of source code must retain the above copyright
+ *    notice, this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES,
+ * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY
+ * AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL
+ * THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+/*
+ * Copy src to string dst of size siz.  At most siz-1 characters
+ * will be copied.  Always NUL terminates (unless siz == 0).
+ * Returns strlen(src); if retval >= siz, truncation occurred.
+ */
+size_t strlcpy(dst, src, siz)
+    char *dst;
+    const char *src;
+    size_t siz;
+{
+    char *d = dst;
+    const char *s = src;
+    size_t n = siz;
+
+    /* Copy as many bytes as will fit */
+    if (n != 0 && --n != 0) {
+	do {
+	    if ((*d++ = *s++) == 0)
+		break;
+	} while (--n != 0);
+    }
+
+    /* Not enough room in dst, add NUL and traverse rest of src */
+    if (n == 0) {
+	if (siz != 0)
+	    *d = '\0';		/* NUL-terminate dst */
+	while (*s++)
+	    ;
+    }
+
+    return(s - src - 1);	/* count does not include NUL */
+}
+
+#endif
+
+#ifdef NEED_BSD_SIGNAL
+
+void (*bsd_signal(int sig, void (*func)(int)))(int)
+{
+    struct sigaction act, oact;
+
+    act.sa_handler = func;
+    act.sa_flags = SA_RESTART;
+    sigemptyset(&act.sa_mask);
+    sigaddset(&act.sa_mask, sig);
+    if (sigaction(sig, &act, &oact) == -1)
+	return(SIG_ERR);
+    return(oact.sa_handler);
+}
+
+
+#endif
+
+#ifdef HAVE_SETPROCTITLE
+
+void
+initsetproctitle(int argc, char **argv, char **envp)
+{
+}
+
+#else
+
+
+static char **Argv = NULL;	/* pointer to argument vector */
+static int argv_size;		/* end of argv */
+
+extern char **environ;
+
+void
+initsetproctitle(int argc, char **argv, char **envp)
+{
+    register int    i;
+    int len=0,nenv=0;
+
+
+    /*
+     * Move the environment so setproctitle can use the space at the top of
+     * memory.
+     */
+    for (i = 0; envp[i]; i++)
+      len+=strlen(envp[i])+1;
+    nenv=i+1;
+    len+=sizeof(char*)*nenv;
+    environ = malloc(len);
+    len=0;
+    for (i = 0; envp[i]; i++) {
+        environ[i] = (char*)environ+nenv*sizeof(char*)+len;
+	strcpy(environ[i], envp[i]);
+	len+=strlen(envp[i])+1;
+    }
+    environ[i] = NULL;
+
+    /* Save start and extent of argv for setproctitle. */
+    Argv = argv;
+    if (i > 0)
+	argv_size = envp[i - 1] + strlen(envp[i - 1]) - Argv[0];
+    else
+	argv_size = argv[argc - 1] + strlen(argv[argc - 1]) - Argv[0];
+}
+
+static void
+do_setproctitle(const char *cmdline)
+{
+    int             len;
+
+    len = strlen(cmdline) + 1; // +1 for '\0'
+    if(len > argv_size - 2) // 2 ??
+        len = argv_size - 2;
+    memset(Argv[0], 0, argv_size);
+    strlcpy(Argv[0], cmdline, len);
+    Argv[1] = NULL;
+}
+
+void
+setproctitle(const char *format,...)
+{
+    char            buf[256];
+    va_list         args;
+    va_start(args, format);
+    vsnprintf(buf, sizeof(buf), format, args);
+    do_setproctitle(buf);
+    va_end(args);
+}
+
+#endif
+
+#if __FreeBSD__
+
+int
+cpuload(char *str)
+{
+    double          l[3] = {-1, -1, -1};
+    if (getloadavg(l, 3) != 3)
+	l[0] = -1;
+
+    if (str) {
+	if (l[0] != -1)
+	    sprintf(str, " %.2f %.2f %.2f", l[0], l[1], l[2]);
+	else
+	    strcpy(str, " (unknown) ");
+    }
+    return (int)l[0];
+}
+#endif
+
+
+#ifdef Solaris
+
+#include <kstat.h>
+#include <sys/param.h>
+
+#define loaddouble(la) ((double)(la) / FSCALE)
+
+int
+cpuload(char *str)
+{
+    kstat_ctl_t *kc;
+    kstat_t *ks;
+    kstat_named_t *kn;
+    double l[3] = {-1, -1, -1};
+
+    kc = kstat_open();
+
+    if( !kc ){
+	strcpy(str, "(unknown) ");
+	return -1;
+    }
+
+    ks = kstat_lookup( kc, "unix", 0, "system_misc");
+
+    if( kstat_read( kc, ks, 0) == -1){
+	strcpy( str, "( unknown ");
+	return -1;
+    }
+
+    kn = kstat_data_lookup( ks, "avenrun_1min" );
+
+    if( kn ) {
+	l[0] = loaddouble(kn->value.ui32);
+    }
+
+    kn = kstat_data_lookup( ks, "avenrun_5min" );
+
+    if( kn ) {
+	l[1] = loaddouble(kn->value.ui32);
+    }
+
+    kn = kstat_data_lookup( ks, "avenrun_15min" );
+
+    if( kn ) {
+	l[2] = loaddouble(kn->value.ui32);
+    }
+
+    if (str) {
+
+	if (l[0] != -1)
+	    sprintf(str, " %.2f %.2f %.2f", l[0], l[1], l[2]);
+	else
+	    strcpy(str, " (unknown) ");
+    }
+
+    kstat_close(kc);
+    return (int)l[0];
+}
+
+#endif
+
+#ifdef __linux__
+int
+cpuload(char *str)
+{
+    double          l[3] = {-1, -1, -1};
+    FILE           *fp;
+
+    if ((fp = fopen("/proc/loadavg", "r"))) {
+	if (fscanf(fp, "%lf %lf %lf", &l[0], &l[1], &l[2]) != 3)
+	    l[0] = -1;
+	fclose(fp);
+    }
+    if (str) {
+	if (l[0] != -1)
+	    sprintf(str, " %.2f %.2f %.2f", l[0], l[1], l[2]);
+	else
+	    strcpy(str, " (unknown) ");
+    }
+    return (int)l[0];
+}
+
+#endif