C99 ANSIfying fixes; Some code formatting style changes.
authorMatthew Mondor <mmondor@pulsar-zone.net>
Wed, 5 Dec 2007 23:47:57 +0000 (23:47 +0000)
committerMatthew Mondor <mmondor@pulsar-zone.net>
Wed, 5 Dec 2007 23:47:57 +0000 (23:47 +0000)
76 files changed:
mmsoftware/apache-mmstat/apache-mmstat.c
mmsoftware/bot/newbot.c
mmsoftware/bot/zenbot.c
mmsoftware/js/classes/js_dir.c
mmsoftware/js/classes/js_gcroot.c
mmsoftware/mmanoncvs/mmanoncvs.c
mmsoftware/mmftpd/src/mmftpd.c
mmsoftware/mmftpd/src/mmftpd.h
mmsoftware/mmidentd/mmidentd.c
mmsoftware/mmlib/mm_pth_pool.c
mmsoftware/mmlib/mmalarm.3
mmsoftware/mmlib/mmalarm.c
mmsoftware/mmlib/mmalarm.h
mmsoftware/mmlib/mmarch.c
mmsoftware/mmlib/mmarch.h
mmsoftware/mmlib/mmbstring.c
mmsoftware/mmlib/mmbstring.h
mmsoftware/mmlib/mmfd.3
mmsoftware/mmlib/mmfd.c
mmsoftware/mmlib/mmfd.h
mmsoftware/mmlib/mmfifo.3
mmsoftware/mmlib/mmfifo.c
mmsoftware/mmlib/mmfifo.h
mmsoftware/mmlib/mmhash.3
mmsoftware/mmlib/mmhash.c
mmsoftware/mmlib/mmhash.h
mmsoftware/mmlib/mmheap.c
mmsoftware/mmlib/mmlifo.3
mmsoftware/mmlib/mmlifo.h
mmsoftware/mmlib/mmlimitrate.c
mmsoftware/mmlib/mmlimitrate.h
mmsoftware/mmlib/mmlist.3
mmsoftware/mmlib/mmlist.h
mmsoftware/mmlib/mmlog.c
mmsoftware/mmlib/mmlog.h
mmsoftware/mmlib/mmpath.c
mmsoftware/mmlib/mmpath.h
mmsoftware/mmlib/mmpool.3
mmsoftware/mmlib/mmpool.c
mmsoftware/mmlib/mmpool.h
mmsoftware/mmlib/mmrc4.c
mmsoftware/mmlib/mmrc4.h
mmsoftware/mmlib/mmrc4util.c
mmsoftware/mmlib/mmreadcfg.c
mmsoftware/mmlib/mmreadcfg.h
mmsoftware/mmlib/mmserver.c
mmsoftware/mmlib/mmserver.h
mmsoftware/mmlib/mmserver2.3
mmsoftware/mmlib/mmserver2.c
mmsoftware/mmlib/mmserver2.h
mmsoftware/mmlib/mmsql.c
mmsoftware/mmlib/mmsql.h
mmsoftware/mmlib/mmstat.c
mmsoftware/mmlib/mmstat.h
mmsoftware/mmlib/mmstr.c
mmsoftware/mmlib/mmstr.h
mmsoftware/mmlib/mmstring.c
mmsoftware/mmlib/mmstring.h
mmsoftware/mmlib/mmtypes.h
mmsoftware/mmmail/src/mmpop3d/mmpop3d.c
mmsoftware/mmmail/src/mmpop3d/mmpop3d.h
mmsoftware/mmmail/src/mmsmtpd/mmsmtpd.c
mmsoftware/mmmail/src/mmsmtpd/mmsmtpd.h
mmsoftware/mmsendmail/mmsendmail.c
mmsoftware/mmspawnd/mmspawnd.c
mmsoftware/mmspawnd2/mmspawnd.c
mmsoftware/mmstatd/src/mmstat.c
mmsoftware/mmstatd/src/mmstatd.c
mmsoftware/mmstatd/src/mmstatd.h
mmsoftware/mmsucom/mmsucom.c
mmsoftware/mmsucom/mmsucomd.c
mmsoftware/mystic_ships/server/src/client.c
mmsoftware/mystic_ships/server/src/client.h
mmsoftware/pthread_util/mm_pthread_msg.h
mmsoftware/stringtest/stringtest.c
mmsoftware/util/stripcp.c

index 40b2979..ec02735 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: apache-mmstat.c,v 1.4 2004/09/28 20:59:11 mmondor Exp $ */
+/* $Id: apache-mmstat.c,v 1.5 2007/12/05 23:47:55 mmondor Exp $ */
 
 /*
  * Copyright (C) 2003, Matthew Mondor
@@ -40,7 +40,9 @@
 #include <stdlib.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <stdbool.h>
 #include <stdio.h>
+#include <string.h>
 #include <syslog.h>
 #include <signal.h>
 
index 78e9fc5..e53c142 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: newbot.c,v 1.10 2004/07/24 17:48:21 mmondor Exp $ */
+/* $Id: newbot.c,v 1.11 2007/12/05 23:47:55 mmondor Exp $ */
 
 /*
  * Copyright (C) 2002-2003, Matthew Mondor
@@ -47,6 +47,8 @@
 /* HEADERS */
 
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <fcntl.h>
@@ -76,7 +78,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2002-2003\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: newbot.c,v 1.10 2004/07/24 17:48:21 mmondor Exp $");
+MMRCSID("$Id: newbot.c,v 1.11 2007/12/05 23:47:55 mmondor Exp $");
 
 
 
@@ -134,7 +136,7 @@ struct network {
     /* When running through servers to connect, and connected server. */
     struct server *server;
     char nick[32];             /* Our nickname on this network */
-    u_int32_t mode;            /* Our user mode on this network */
+    uint32_t mode;             /* Our user mode on this network */
     struct freqtable freq_nick, freq_ident, freq_host;
 };
 
@@ -149,7 +151,7 @@ struct channel {
     hashtable_t users_table;
     bool joined;
     char name[64];
-    u_int32_t mode;
+    uint32_t mode;
     int window;
     /* Channel l and k mode parameters */
     int mode_limit;
@@ -159,7 +161,7 @@ struct channel {
 struct user {
     hashnode_t node;
     char name[64];
-    u_int32_t mode;
+    uint32_t mode;
 };
 
 struct freqtable {
@@ -238,7 +240,7 @@ struct state {
 #define PING_RATE              10
 #define ALLOW_VER              1
 #define VER_RATE               10
-#define VER_STRING "$Id: newbot.c,v 1.10 2004/07/24 17:48:21 mmondor Exp $"
+#define VER_STRING "$Id: newbot.c,v 1.11 2007/12/05 23:47:55 mmondor Exp $"
 #define ANSWER_RATE            120     /* For zenbot replies frequency */
 #define INITIAL_UMODE          "+iw"
 
@@ -651,7 +653,7 @@ static void main_quitted(struct info *data)
 
 static void main_nick(struct info *data)
 {
-    u_int64_t hash, nhash;
+    uint64_t hash, nhash;
     struct channel *ch;
     struct user *us;
 
@@ -958,7 +960,7 @@ static int
 allow_entry(pool_t *pool, list_t *lst, char *entry, unsigned long max,
        int secs, long igndelay)
 {
-    u_int64_t hash = mm_strhash64(entry);
+    uint64_t hash = mm_strhash64(entry);
     int ret = 0;
     struct freq *node, *tmp;
     time_t t = time(NULL);
@@ -1110,7 +1112,7 @@ static void irc_parse(struct info *data)
  */
 static void user_add(char *chan, char *nick)
 {
-    u_int64_t chanhash, nickhash;
+    uint64_t chanhash, nickhash;
     struct channel *ch;
     struct user *us;
     int mode;
@@ -1156,7 +1158,7 @@ static void user_add(char *chan, char *nick)
  */
 static struct channel *user_del(char *chan, char *nick)
 {
-    u_int64_t chanhash, nickhash;
+    uint64_t chanhash, nickhash;
     struct channel *ch;
     struct user *us;
 
index a71ecd2..dfb7043 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: zenbot.c,v 1.12 2004/10/22 14:28:26 mmondor Exp $ */
+/* $Id: zenbot.c,v 1.13 2007/12/05 23:47:55 mmondor Exp $ */
 
 /*
  * Copyright (C) 2002-2003, Matthew Mondor
@@ -37,6 +37,8 @@
 /* HEADERS */
 
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <fcntl.h>
@@ -66,7 +68,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2002-2003\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: zenbot.c,v 1.12 2004/10/22 14:28:26 mmondor Exp $");
+MMRCSID("$Id: zenbot.c,v 1.13 2007/12/05 23:47:55 mmondor Exp $");
 
 
 
@@ -78,7 +80,7 @@ struct freq {
     pnode_t node;
     time_t expires;
     bool ignore;
-    u_int64_t hash;
+    uint64_t hash;
     unsigned long freq;
 };
 
@@ -92,7 +94,7 @@ struct cron {
 /* A channel we joined */
 struct channel {
     pnode_t node;
-    u_int64_t channel_hash;
+    uint64_t channel_hash;
     pool_t pchannel_users;
     list_t channel_users;
     int channel_limit, channel_mode;
@@ -102,7 +104,7 @@ struct channel {
 /* A user on a channel */
 struct user {
     pnode_t node;
-    u_int64_t user_hash;
+    uint64_t user_hash;
     int user_mode;
     char user_nick[64];
 };
@@ -161,7 +163,7 @@ struct state {
 #define PING_RATE              10
 #define ALLOW_VER              1
 #define VER_RATE               10
-#define VER_STRING "$Id: zenbot.c,v 1.12 2004/10/22 14:28:26 mmondor Exp $"
+#define VER_STRING "$Id: zenbot.c,v 1.13 2007/12/05 23:47:55 mmondor Exp $"
 #define ANSWER_RATE            120     /* For zenbot replies frequency */
 #define INITIAL_UMODE          "+iw"
 
@@ -497,7 +499,7 @@ static void main_quitted(struct info *data)
 
 static void main_nick(struct info *data)
 {
-    u_int64_t hash, nhash;
+    uint64_t hash, nhash;
     struct channel *ch;
     struct user *us;
 
@@ -804,7 +806,7 @@ static int
 allow_entry(pool_t *pool, list_t *lst, char *entry, unsigned long max,
        int secs, long igndelay)
 {
-    u_int64_t hash = mm_strhash64(entry);
+    uint64_t hash = mm_strhash64(entry);
     int ret = 0;
     struct freq *node, *tmp;
     time_t t = time(NULL);
@@ -956,7 +958,7 @@ static void irc_parse(struct info *data)
  */
 static void user_add(char *chan, char *nick)
 {
-    u_int64_t chanhash, nickhash;
+    uint64_t chanhash, nickhash;
     struct channel *ch;
     struct user *us;
     int mode;
@@ -1002,7 +1004,7 @@ static void user_add(char *chan, char *nick)
  */
 static struct channel *user_del(char *chan, char *nick)
 {
-    u_int64_t chanhash, nickhash;
+    uint64_t chanhash, nickhash;
     struct channel *ch;
     struct user *us;
 
index edb8223..27ab18a 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: js_dir.c,v 1.15 2007/10/23 06:50:35 mmondor Exp $ */
+/* $Id: js_dir.c,v 1.16 2007/12/05 23:47:55 mmondor Exp $ */
 
 /*
  * Copyright (c) 2006, Matthew Mondor
@@ -315,7 +315,7 @@ dir_m_read(JSContext *cx, JSObject *obj, uintN argc, jsval *argv, jsval *rval)
        }
        *rval = OBJECT_TO_JSVAL(o);
 
-       /* d_fileno is u_int32_t and so could exceed a JS int, so use this */
+       /* d_fileno is uint32_t and so could exceed a JS int, so use this */
        if (!JS_NewNumberValue(cx, (jsdouble)de->d_fileno, &val) ||
            !JS_DefineProperty(cx, o, "fileno", val, NULL, NULL,
            JSPROP_ENUMERATE)) {
index 211e451..d66e47f 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: js_gcroot.c,v 1.4 2007/10/21 02:11:09 mmondor Exp $ */
+/* $Id: js_gcroot.c,v 1.5 2007/12/05 23:47:55 mmondor Exp $ */
 
 /*
  * Copyright (c) 2006, Matthew Mondor
@@ -106,7 +106,7 @@ typedef struct cxspec {
  * Static functions prototypes
  */
 static int             omap_keycmp(const void *, const void *, size_t);
-static u_int32_t       omap_keyhash(const void *, size_t);
+static uint32_t                omap_keyhash(const void *, size_t);
 
 
 
@@ -330,10 +330,10 @@ omap_keycmp(const void *a, const void *b, size_t s)
        return (int)(da - db);
 }
 
-static u_int32_t
+static uint32_t
 omap_keyhash(const void *a, size_t s)
 {
        long    d = (long)*(long *)a;
 
-       return (u_int32_t)(d & 0xffffffff);
+       return (uint32_t)(d & 0xffffffff);
 }
index 1d23017..be103cc 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmanoncvs.c,v 1.28 2004/10/05 15:39:04 mmondor Exp $ */
+/* $Id: mmanoncvs.c,v 1.29 2007/12/05 23:47:55 mmondor Exp $ */
 
 /*
  * Copyright (C) 2003-2004, Matthew Mondor
@@ -53,6 +53,7 @@
 #include <sys/stat.h>
 #include <sys/file.h>
 #include <unistd.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <stdio.h>
@@ -72,7 +73,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2003\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmanoncvs.c,v 1.28 2004/10/05 15:39:04 mmondor Exp $");
+MMRCSID("$Id: mmanoncvs.c,v 1.29 2007/12/05 23:47:55 mmondor Exp $");
 
 
 
index 120233d..1821636 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmftpd.c,v 1.69 2007/06/28 12:36:49 mmondor Exp $ */
+/* $Id: mmftpd.c,v 1.70 2007/12/05 23:47:55 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
@@ -40,6 +40,8 @@
 #include <sys/stat.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #ifdef __GLIBC__
@@ -88,7 +90,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmftpd.c,v 1.69 2007/06/28 12:36:49 mmondor Exp $");
+MMRCSID("$Id: mmftpd.c,v 1.70 2007/12/05 23:47:55 mmondor Exp $");
 
 
 
@@ -348,13 +350,13 @@ all_help(clientenv *clenv)
 
     if ((mm_straspl(args, clenv->buffer, 2)) == 2) {
        register struct commandnode *nod;
-       u_int32_t chash;
+       uint32_t chash;
 
        /* Help requested on a topic */
        nod = NULL;
        if ((chash = mm_strpack32(args[1], 3)) != 0)
            nod = (struct commandnode *)hashtable_lookup(&command_table,
-                           &chash, sizeof(u_int32_t));
+                           &chash, sizeof(uint32_t));
        if (nod != NULL) {
            tmp = nod->command->name;
            if ((tmp2 = nod->command->args) == NULL) {
@@ -788,10 +790,10 @@ static int
 main_port(clientenv *clenv)
 {
     int i;
-    u_int16_t port;
+    uint16_t port;
     fdbuf *fdb = clenv->fdb;
     char *args[7], ipaddr[16];
-    u_int8_t p[7];
+    uint8_t p[7];
     transfermsg *msg = &(clenv->tmsg);
 
     /* PORT 127,0,0,1,255,26 */
@@ -801,7 +803,7 @@ main_port(clientenv *clenv)
        /* Now make sure that the second section holds 6 values */
        if ((mm_strspl(args, args[1], 6, ',')) == 6) {
            for (i = 0; i < 6; i++)
-               p[i] = (u_int8_t)atoi(args[i]);
+               p[i] = (uint8_t)atoi(args[i]);
            /* Get port number */
            port = BYTEORDER_HOST16(p[4] | (p[5] << 8));
            /* port = (256 * p[4]) + p[5]; */
@@ -857,10 +859,10 @@ static int
 main_lprt(clientenv *clenv)
 {
     int i;
-    u_int16_t port;
+    uint16_t port;
     fdbuf *fdb = clenv->fdb;
     char *args[10], ipaddr[16];
-    u_int8_t p[10];
+    uint8_t p[10];
     transfermsg *msg = &(clenv->tmsg);
 
     /* LPRT 4,4,127,0,0,1,2,204,36 */
@@ -870,7 +872,7 @@ main_lprt(clientenv *clenv)
        /* Now make sure that the second section holds 9 values */
        if ((mm_strspl(args, args[1], 9, ',')) == 9) {
            for (i = 0; i < 9; i++)
-               p[i] = (u_int8_t)atoi(args[i]);
+               p[i] = (uint8_t)atoi(args[i]);
            if (p[0] == 4 && p[1] == 4 && p[6] == 2) {
                /* Get port number */
                port = BYTEORDER_HOST16(p[7] | (p[8] << 8));
@@ -957,7 +959,7 @@ main_eprt(clientenv *clenv)
                    if (transfer_request(REQ_STATUS, TRUE, clenv)) {
                        if (!msg->ongoing) {
                            /* Send our PORT transfer request */
-                           msg->port = (u_int16_t)port;
+                           msg->port = (uint16_t)port;
                            msg->ipaddr = args[2];
                            msg->passive = FALSE;
                            if (transfer_request(REQ_NEWPORT, TRUE, clenv))
@@ -1008,7 +1010,7 @@ main_pasv(clientenv *clenv)
 {
     fdbuf *fdb = clenv->fdb;
     transfermsg *msg = &(clenv->tmsg);
-    u_int8_t a, b;
+    uint8_t a, b;
 
     if (!clenv->buffer[4]) {
        /* Make sure no transfers are in progress */
@@ -1017,7 +1019,7 @@ main_pasv(clientenv *clenv)
                /* Send our PASV transfer request */
                msg->passive = TRUE;
                if (transfer_request(REQ_NEWPORT, TRUE, clenv)) {
-                   u_int16_t v = BYTEORDER_NETWORK16(msg->port);
+                   uint16_t v = BYTEORDER_NETWORK16(msg->port);
 
                    a = (v & 0x00FF);
                    b = (v & 0xFF00) >> 8;
@@ -1057,7 +1059,7 @@ main_lpsv(clientenv *clenv)
 {
     fdbuf *fdb = clenv->fdb;
     transfermsg *msg = &(clenv->tmsg);
-    u_int8_t a, b;
+    uint8_t a, b;
 
     if (!clenv->buffer[4]) {
        /* Make sure no transfers are in progress */
@@ -1066,7 +1068,7 @@ main_lpsv(clientenv *clenv)
                /* Send our PASV transfer request */
                msg->passive = TRUE;
                if (transfer_request(REQ_NEWPORT, TRUE, clenv)) {
-                   u_int16_t v = BYTEORDER_NETWORK16(msg->port);
+                   uint16_t v = BYTEORDER_NETWORK16(msg->port);
 
                    a = (v & 0x00FF);
                    b = (v & 0xFF00) >> 8;
@@ -2575,7 +2577,7 @@ main(int argc, char **argv)
     if (*CONF.DISPLAY_FILE)
        pool_init(&fifos_pool, "fifos_pool", malloc, free, NULL, NULL,
                sizeof(struct fifonode) +
-               (CONF.REMEMBER_CWDS * sizeof(u_int64_t)),
+               (CONF.REMEMBER_CWDS * sizeof(uint64_t)),
                CONF.ALLOC_BUFFERS * 64, 0, 0);
     /* Tree size cache */
     pool_init(&quota_pool, "quota_pool", malloc, free, NULL, NULL,
@@ -2653,7 +2655,7 @@ hash_commands(struct command *cmd, size_t min)
        nod->command = cmd;
        nod->index = i;
        if (!hashtable_link(&command_table, (hashnode_t *)nod, &nod->hash,
-                   sizeof(u_int32_t), TRUE)) {
+                   sizeof(uint32_t), TRUE)) {
            DEBUG_PRINTF("hash_commands", "hashtable_link(%s)", cmd->name);
            return FALSE;
        }
@@ -2667,10 +2669,10 @@ hash_commands(struct command *cmd, size_t min)
  * 32-bit values
  */
 /* ARGSUSED */
-static u_int32_t
+static uint32_t
 commandnode_keyhash(const void *data, size_t len)
 {
-    return *((u_int32_t *)data);
+    return *((uint32_t *)data);
 }
 
 
@@ -2680,7 +2682,7 @@ commandnode_keyhash(const void *data, size_t len)
 static int
 commandnode_keycmp(const void *src, const void *dst, size_t len)
 {
-    return *((u_int32_t *)src) - *((u_int32_t *)dst);
+    return *((uint32_t *)src) - *((uint32_t *)dst);
 }
 
 
@@ -3201,14 +3203,14 @@ directory_message(clientenv *clenv, int code)
 {
     bool res = TRUE;
     char path[MMPATH_MAX];
-    u_int64_t dhash;
+    uint64_t dhash;
 
     if (*CONF.DISPLAY_FILE) {
        if (path_valid(path, NULL, clenv->home, clenv->cwd,
                    CONF.DISPLAY_FILE, FALSE, FALSE, FALSE)
                && path_exists(path, NULL, NULL, clenv->checkowner)
                == MMPATH_FILE) {
-           u_int64_t *ptr;
+           uint64_t *ptr;
 
            /* Make sure that this directory was not visited recently. */
            dhash = mm_strhash64(clenv->cwd);
@@ -3377,7 +3379,7 @@ pasv_remap_parse(void)
  * remapped, or FALSE otherwise. <bind> and <advertize> are set if remapped.
  */
 static bool
-pasv_remap(u_int32_t *bind, char **advertize, const char *client)
+pasv_remap(uint32_t *bind, char **advertize, const char *client)
 {
     int                        i, cur, max;
     struct pasv_remap  *entry = NULL;
@@ -3544,7 +3546,7 @@ handleclient(unsigned long cid, int fd, clientlistnode *clientlnode,
                    for (;;) {
                        register ssize_t len;
                        register struct commandnode *nod;
-                       u_int32_t chash;
+                       uint32_t chash;
 
                        fdbflushw(fdb);
                        if ((len = fdbgets(fdb, buffer, 1000, TRUE)) > -1) {
@@ -3561,7 +3563,7 @@ handleclient(unsigned long cid, int fd, clientlistnode *clientlnode,
                            if ((chash = mm_strpack32(buffer, 3)) != 0)
                                nod = (struct commandnode *)hashtable_lookup(
                                        &command_table, &chash,
-                                       sizeof(u_int32_t));
+                                       sizeof(uint32_t));
                            if (nod != NULL) {
                                register int (*func)(clientenv *);
 
@@ -3986,7 +3988,7 @@ transferthread_main(clientenv *clenv, fdbuf *fdb)
                            msg->result = TRUE;
                            break;
                        case REQ_STATUS:
-                           msg->port = (u_int16_t)port;
+                           msg->port = (uint16_t)port;
                            msg->passive = passive;
                            msg->ongoing = ongoing;
                            msg->download = download;
@@ -4019,7 +4021,7 @@ transferthread_main(clientenv *clenv, fdbuf *fdb)
                                msg->result = FALSE;    /* Default */
                                if (pasv_bind(clenv, &server, &fdpasv,
                                            &port)) {
-                                   msg->port = (u_int16_t)port;
+                                   msg->port = (uint16_t)port;
                                    passive = msg->result = TRUE;
                                    break;
                                }
@@ -4184,7 +4186,7 @@ transferthread_main(clientenv *clenv, fdbuf *fdb)
                        state = TTSTATE_INITIAL;
                        break;
                    case REQ_STATUS:
-                       msg->port = (u_int16_t)port;
+                       msg->port = (uint16_t)port;
                        msg->passive = passive;
                        msg->ongoing = ongoing;
                        msg->download = download;
@@ -4377,7 +4379,7 @@ transferthread_main(clientenv *clenv, fdbuf *fdb)
                                reason = TR_ABORTED;
                                break;
                            case REQ_STATUS:
-                               msg->port = (u_int16_t)port;
+                               msg->port = (uint16_t)port;
                                msg->passive = passive;
                                msg->ongoing = ongoing;
                                msg->download = download;
@@ -4528,7 +4530,7 @@ transferthread_main(clientenv *clenv, fdbuf *fdb)
                                reason = TR_ABORTED;
                                break;
                            case REQ_STATUS:
-                               msg->port = (u_int16_t)port;
+                               msg->port = (uint16_t)port;
                                msg->passive = passive;
                                msg->ongoing = ongoing;
                                msg->download = download;
index 1b48d1b..5d3ac64 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmftpd.h,v 1.28 2007/03/19 08:58:50 mmondor Exp $ */
+/* $Id: mmftpd.h,v 1.29 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
@@ -43,6 +43,8 @@
 /* HEADERS */
 
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <pthread.h>
 
 #include <mmfd.h>
@@ -175,7 +177,7 @@ typedef struct transfermsg {
     pthread_msg_t msg;           /* Internal message node */
     int request;                 /* Request to send to device */
     bool result;                 /* Result status after device request */
-    u_int16_t port;              /* PORT or PASV port for next transfer */
+    uint16_t port;               /* PORT or PASV port for next transfer */
     int file;                    /* File descriptor to read/write from/to */
     int rrate, wrate;            /* Transfer dl/ul rate */
     char *ipaddr;                /* If PORT, address to connect to */
@@ -230,8 +232,8 @@ typedef struct clientenv {
     bool checkowner;             /* If we should check for file ownership */
     unsigned char type;                  /* Current transfer TYPE */
     fifo64_t visited;             /* FIFO buffer of visited dirs hashes */
-    u_int32_t uipaddr;           /* Used for bind() on passive ports */
-    u_int32_t cipaddr;           /* Client's IP address */
+    uint32_t uipaddr;            /* Used for bind() on passive ports */
+    uint32_t cipaddr;            /* Client's IP address */
     struct fifonode *fifobuf;    /* Internal buffer for visited */
     struct iface *iface;         /* To obtain our server hostname */
     struct async_clenv *aclenv;          /* Thread context for async_call() support */
@@ -264,7 +266,7 @@ typedef struct quotanode {
 /* This serves for fast command lookup */
 struct commandnode {
     hashnode_t node;
-    u_int32_t hash;
+    uint32_t hash;
     int index;
     struct command *command;
 };
@@ -279,7 +281,7 @@ struct mutexnode {
 */
 struct fifonode {
     pnode_t node;
-    u_int64_t buf[1];
+    uint64_t buf[1];
     /* Will be expanded here */
 };
 
@@ -347,7 +349,7 @@ struct async_getuserline_msg {
 struct pasv_remap {
     const char *pattern;
     const char *advertize;
-    u_int32_t  bind;
+    uint32_t   bind;
 };
 
 
@@ -398,7 +400,7 @@ static int main_stat(clientenv *);
 int main(int, char **);
 
 static bool hash_commands(struct command *, size_t);
-static u_int32_t commandnode_keyhash(const void *, size_t);
+static uint32_t commandnode_keyhash(const void *, size_t);
 static int commandnode_keycmp(const void *, const void *, size_t);
 static bool reply(fdbuf *, int, bool, char *, ...);
 static int readconfline(char *, fdbuf *, int, int, char **);
@@ -417,7 +419,7 @@ static bool directory_message(clientenv *, int);
 static int best_match(const char *, const char *);
 static bool valid_ipaddress(const char *);
 static bool pasv_remap_parse(void);
-static bool pasv_remap(u_int32_t *, char **, const char *);
+static bool pasv_remap(uint32_t *, char **, const char *);
 
 static int handleclient(unsigned long, int, clientlistnode *, struct iface *,
        struct async_clenv *, void *);
index 042f732..45aca74 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmidentd.c,v 1.3 2004/04/30 00:01:18 mmondor Exp $ */
+/* $Id: mmidentd.c,v 1.4 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2003, Matthew Mondor
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <poll.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <fcntl.h>
 #include <unistd.h>
@@ -161,11 +162,11 @@ int main(int argc, char **argv)
      */
     if (argc == 2 && (fd = open(argv[1], O_RDONLY)) != -1) {
        struct stat st;
-       u_int32_t fsize;
+       uint32_t fsize;
        char *dict;
 
        if (fstat(fd, &st) == 0) {
-           fsize = (u_int32_t)st.st_size;
+           fsize = (uint32_t)st.st_size;
            if ((dict = mmap(NULL, (size_t)fsize, PROT_READ,
                            MAP_FILE | MAP_PRIVATE, fd, (off_t)0))
                    != MAP_FAILED) {
@@ -191,11 +192,13 @@ int main(int argc, char **argv)
                    /* Slice the file randomly with cptr */
                    cptr = dict + (random() % fsize);
                    /* Run left from cptr with sptr */
-                   for (sptr = cptr; sptr >= dict && ISCHAR(*sptr); sptr--) ;
-                   if (!ISCHAR(*sptr))
+                   for (sptr = cptr; sptr >= dict && ISCHAR((int)*sptr);
+                        sptr--) ;
+                   if (!ISCHAR((int)*sptr))
                        sptr++;
                    /* And right from cptr with eptr */
-                   for (eptr = cptr; eptr < tptr && ISCHAR(*eptr); eptr++) ;
+                   for (eptr = cptr; eptr < tptr && ISCHAR((int)*eptr);
+                        eptr++) ;
                    /* We now have a word, evaluate it's length. */
                    len = eptr - sptr;
                }
@@ -241,10 +244,11 @@ int main(int argc, char **argv)
             * decimal convertion.
             */
            tptr = buf + len;
-           for (ptr = buf; ptr < tptr && !isdigit(*ptr); ptr++) ;
-           for (aptr = ptr; ptr < tptr && isdigit(*ptr); ptr++) ;
-           for (alen = ptr - aptr; ptr < tptr && !isdigit(*ptr); ptr++) ;
-           for (bptr = ptr; ptr < tptr && isdigit(*ptr); ptr++) ;
+           for (ptr = buf; ptr < tptr && !isdigit((int)*ptr); ptr++) ;
+           for (aptr = ptr; ptr < tptr && isdigit((int)*ptr); ptr++) ;
+           for (alen = ptr - aptr; ptr < tptr && !isdigit((int)*ptr);
+                ptr++) ;
+           for (bptr = ptr; ptr < tptr && isdigit((int)*ptr); ptr++) ;
            blen = ptr - bptr;
 
            /* Now generate our very authentic output response, and send it.
@@ -311,7 +315,7 @@ static void strrevtolower(char *str)
     register char *p1, *p2, t;
 
     for (p1 = p2 = str; *p2 != '\0'; p2++)
-       *p2 = (char)tolower(*p2);
+       *p2 = (char)tolower((int)*p2);
     if (p2 > p1)
        p2--;
 
index 39f3c90..6cfa594 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mm_pth_pool.c,v 1.10 2004/08/07 23:08:56 mmondor Exp $ */
+/* $Id: mm_pth_pool.c,v 1.11 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2004, Matthew Mondor
@@ -71,6 +71,7 @@
 
 /* HEADERFILES */
 
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include <mm_pth_pool.h>
@@ -79,7 +80,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mm_pth_pool.c,v 1.10 2004/08/07 23:08:56 mmondor Exp $");
+MMRCSID("$Id: mm_pth_pool.c,v 1.11 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
index dbb2dd4..8d7d535 100644 (file)
@@ -1,4 +1,4 @@
-.\" $Id: mmalarm.3,v 1.6 2004/05/05 23:59:55 mmondor Exp $
+.\" $Id: mmalarm.3,v 1.7 2007/12/05 23:47:56 mmondor Exp $
 .\"
 .\" Copyright (C) 2003-2004, Matthew Mondor
 .\" All rights reserved.
@@ -48,7 +48,7 @@
 .Ft void
 .Fn timer_ctx_destroy "timerctx_t *ctx"
 .Ft timerid_t
-.Fn timer_init "timerctx_t *ctx" "time_t now" "u_int32_t delay" \
+.Fn timer_init "timerctx_t *ctx" "time_t now" "uint32_t delay" \
 "void (*func)(timerid_t, void *)" "void *udata" "bool repeat"
 .Ft void
 .Fn timer_destroy "timerctx_t *ctx" "time_t now" "timerid_t timer"
@@ -106,7 +106,7 @@ Aborts and destroys any current timers pending into the specified
 .Fa ctx
 context, and invalidates the context, freeing any internal resources which it
 was using.
-.It timerid_t Fn timer_init "timerctx_t *ctx" "time_t now" "u_int32_t delay" \
+.It timerid_t Fn timer_init "timerctx_t *ctx" "time_t now" "uint32_t delay" \
 "void (*func)(timerid_t, void *)" "void *udata" "bool repeat"
 Creates and attaches a new timer to the specified
 .Fa ctx
index 22d086d..4750d67 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmalarm.c,v 1.10 2004/06/04 01:02:32 mmondor Exp $ */
+/* $Id: mmalarm.c,v 1.11 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2003-2004, Matthew Mondor
+ * Copyright (C) 2003, 2004, 2007, Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  */
 
 
-
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <syslog.h>
 
+#include <mmtypes.h>
 #include <mmalarm.h>
 #include <mmlog.h>
 
 
-
 MMCOPYRIGHT("@(#) Copyright (c) 2003-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmalarm.c,v 1.10 2004/06/04 01:02:32 mmondor Exp $");
-
+MMRCSID("$Id: mmalarm.c,v 1.11 2007/12/05 23:47:56 mmondor Exp $");
 
 
 struct timer_ctx_execute_iterator_udata {
-    timerctx_t *ctx;
-    time_t current, soonest;
+       timerctx_t      *ctx;
+       time_t          current, soonest;
 };
 
 
+static bool            timer_ctx_execute_iterator(hashnode_t *, void *);
+static uint32_t                key_hash32(const void *, size_t);
+static int             key_cmp32(const void *, const void *, size_t);
 
-static bool timer_ctx_execute_iterator(hashnode_t *, void *);
-static u_int32_t key_hash32(const void *, size_t);
-static int key_cmp32(const void *, const void *, size_t);
 
+bool
+timer_ctx_init(timerctx_t *ctx, void *(*mallocfunc)(size_t),
+    void (*freefunc)(void *), time_t (*timefunc)(time_t *),
+    unsigned int (*alarmfunc)(unsigned int))
+{
 
+       if ((pool_init(&ctx->pool, "alarm_pool", mallocfunc, freefunc,
+           NULL, NULL, sizeof(struct timer_node),
+           4096 / sizeof(struct timer_node), 0, 0))) {
 
-bool timer_ctx_init(timerctx_t *ctx, void *(*mallocfunc)(size_t),
-       void (*freefunc)(void *), time_t (*timefunc)(time_t *),
-       unsigned int (*alarmfunc)(unsigned int))
-{
-    if ((pool_init(&ctx->pool, "alarm_pool", mallocfunc, freefunc,
-                   NULL, NULL, sizeof(struct timer_node),
-                   4096 / sizeof(struct timer_node), 0, 0))) {
-       if ((hashtable_init(&ctx->table, "alarm_table", 16, HT_DEFAULT_FACTOR,
-                       mallocfunc, freefunc, key_cmp32, key_hash32, TRUE))) {
-           ctx->magic = MAGIC_TIMER_CTX;
-           ctx->id = 0;
-           ctx->time = timefunc;
-           ctx->alarm = alarmfunc;
-           alarmfunc(0);
-           return TRUE;
-       } else
-           syslog(LOG_NOTICE, "timer_ctx_init() - hashtable_init()");
-       pool_destroy(&ctx->pool);
-    } else
-       syslog(LOG_NOTICE, "timer_ctx_init() -  pool_init()");
+               if ((hashtable_init(&ctx->table, "alarm_table", 16,
+                   HT_DEFAULT_FACTOR, mallocfunc, freefunc, key_cmp32,
+                   key_hash32, true))) {
 
-    return FALSE;
-}
+                       ctx->magic = MAGIC_TIMER_CTX;
+                       ctx->id = 0;
+                       ctx->time = timefunc;
+                       ctx->alarm = alarmfunc;
+                       alarmfunc(0);
 
+                       return true;
+               } else
+                       syslog(LOG_NOTICE,
+                           "timer_ctx_init() - hashtable_init()");
 
-void timer_ctx_destroy(timerctx_t *ctx)
-{
-    if (DEBUG_TRUE(TIMER_CTX_VALID(ctx))) {
-       ctx->alarm(0);
-       if (DEBUG_TRUE(HASHTABLE_VALID(&ctx->table)))
-           hashtable_destroy(&ctx->table, FALSE);
-       if (DEBUG_TRUE(POOL_VALID(&ctx->pool)))
-           pool_destroy(&ctx->pool);
-    } else
-       DEBUG_PRINTF("timer_ctx_destroy", "Wrong ctx pointer %p", ctx);
-}
+               pool_destroy(&ctx->pool);
+       } else
+               syslog(LOG_NOTICE, "timer_ctx_init() -  pool_init()");
 
+       return false;
+}
 
-timerid_t timer_init(timerctx_t *ctx, time_t now, u_int32_t delay,
-       void (*func)(timerid_t, void *), void *udata, bool repeat)
+void
+timer_ctx_destroy(timerctx_t *ctx)
 {
-    struct timer_node *tn;
-    timerid_t t = 0;
-
-    if (now == 0)
-       now = ctx->time(NULL);
-
-    if ((tn = (struct timer_node *)pool_alloc(&ctx->pool, FALSE)) != NULL) {
-       t = tn->id = ++(ctx->id);
-       tn->delay = delay;
-       tn->expiration = now + delay;
-       tn->function = func;
-       tn->udata = udata;
-       tn->repeat = repeat;
-       if (!hashtable_link(&ctx->table, (hashnode_t *)tn, &tn->id,
-               sizeof(timerid_t), TRUE))
-           DEBUG_PRINTF("timer_init", "hashtable_link()");
-       timer_ctx_execute(ctx, now);
-    } else
-       syslog(LOG_NOTICE, "timer_init() -  pool_alloc()");
-
-    return t;
-}
 
+       if (DEBUG_TRUE(TIMER_CTX_VALID(ctx))) {
+               ctx->alarm(0);
+               if (DEBUG_TRUE(HASHTABLE_VALID(&ctx->table)))
+                       hashtable_destroy(&ctx->table, false);
+               if (DEBUG_TRUE(POOL_VALID(&ctx->pool)))
+                       pool_destroy(&ctx->pool);
+       } else
+               DEBUG_PRINTF("Wrong ctx pointer %p", ctx);
+}
 
-void timer_destroy(timerctx_t *ctx, time_t now, timerid_t t)
+timerid_t
+timer_init(timerctx_t *ctx, time_t now, uint32_t delay,
+    void (*func)(timerid_t, void *), void *udata, bool repeat)
 {
-    struct timer_node *tn;
+       struct timer_node       *tn;
+       timerid_t               t = 0;
 
-    if ((tn = (struct timer_node *)hashtable_lookup(&ctx->table, &t,
-                   sizeof(timerid_t))) != NULL) {
-       ctx->alarm(0);
-       hashtable_unlink(&ctx->table, (hashnode_t *)tn);
-       pool_free((pnode_t *)tn);
        if (now == 0)
-           now = ctx->time(NULL);
-       timer_ctx_execute(ctx, now);
-    }
+               now = ctx->time(NULL);
+
+       if ((tn = (struct timer_node *)pool_alloc(&ctx->pool, false))
+           != NULL) {
+               t = tn->id = ++(ctx->id);
+               tn->delay = delay;
+               tn->expiration = now + delay;
+               tn->function = func;
+               tn->udata = udata;
+               tn->repeat = repeat;
+               if (!hashtable_link(&ctx->table, (hashnode_t *)tn, &tn->id,
+                   sizeof(timerid_t), true))
+                       DEBUG_PRINTF("hashtable_link()");
+               timer_ctx_execute(ctx, now);
+       } else
+               syslog(LOG_NOTICE, "timer_init() -  pool_alloc()");
+
+       return t;
 }
 
+void
+timer_destroy(timerctx_t *ctx, time_t now, timerid_t t)
+{
+       struct timer_node       *tn;
+
+       if ((tn = (struct timer_node *)hashtable_lookup(&ctx->table, &t,
+           sizeof(timerid_t))) != NULL) {
+               ctx->alarm(0);
+               hashtable_unlink(&ctx->table, (hashnode_t *)tn);
+               pool_free((pnode_t *)tn);
+               if (now == 0)
+                       now = ctx->time(NULL);
+               timer_ctx_execute(ctx, now);
+       }
+}
 
-/* Runs through all registered timers. For each which expired, run their
- * associated handler function, then reset or expunge the timer. Also
+/*
+ * Runs through all registered timers. For each which expired, run their
+ * associated handler function, then reset or expunge the timer.  Also
  * determines which timer will expire the soonest, and calls alarm(3)
  * which is expected to trigger a SIGALRM signal as soon as a timer expires.
  * Generally, the SIGALRM signal handler for the process (setup using
  * 4.0BSD signal(3) or POSIX sigaction(2)) executes this function and
  * returns.
  */
-void timer_ctx_execute(timerctx_t *ctx, time_t now)
+void
+timer_ctx_execute(timerctx_t *ctx, time_t now)
 {
-    struct timer_ctx_execute_iterator_udata data;
-
-    if (now == 0)
-       now = ctx->time(NULL);
-    ctx->alarm(0);
-
-    /* Run through timers. For each which expired, run their handler function,
-     * and reset or expunge it. For the others, we determine which should
-     * next expire so that we can set the new timer alarm.
-     */
-    data.ctx = ctx;
-    data.current = now;
-    data.soonest = now + 259200;       /* 72 hours maximum delay */
-    if (HASHTABLE_NODES(&ctx->table))
-       hashtable_iterate(&ctx->table, timer_ctx_execute_iterator, &data);
-    ctx->alarm((unsigned int)(data.soonest - now));
-}
+       struct timer_ctx_execute_iterator_udata data;
 
+       if (now == 0)
+               now = ctx->time(NULL);
+       ctx->alarm(0);
+
+       /*
+        * Run through timers. For each which expired, run their handler
+        * function, and reset or expunge it.  For the others, we determine
+        * which should next expire so that we can set the new timer alarm.
+        */
+       data.ctx = ctx;
+       data.current = now;
+       data.soonest = now + 259200;    /* 72 hours maximum delay */
+       if (HASHTABLE_NODES(&ctx->table) > 0)
+               hashtable_iterate(&ctx->table, timer_ctx_execute_iterator,
+                   &data);
+       ctx->alarm((unsigned int)(data.soonest - now));
+}
 
 /* Internally used by the timer_ctx_execute() function. */
-static bool timer_ctx_execute_iterator(hashnode_t *hnod, void *udata)
+static bool
+timer_ctx_execute_iterator(hashnode_t *hnod, void *udata)
 {
-    struct timer_ctx_execute_iterator_udata *data = udata;
-    struct timer_node *tn = (struct timer_node *)hnod;
-
-    if (tn->expiration <= data->current) {
-       /* Expired entry, call handler, then reset or delete. */
-       tn->function(tn->id, tn->udata);
-       if (tn->repeat)
-           tn->expiration = data->current + tn->delay;
-       else {
-           hashtable_unlink(&(data->ctx->table), (hashnode_t *)tn);
-           pool_free((pnode_t *)tn);
-           tn = NULL;
+       struct timer_ctx_execute_iterator_udata *data = udata;
+       struct timer_node               *tn = (struct timer_node *)hnod;
+
+       if (tn->expiration <= data->current) {
+               /* Expired entry, call handler, then reset or delete. */
+               tn->function(tn->id, tn->udata);
+               if (tn->repeat)
+                       tn->expiration = data->current + tn->delay;
+               else {
+                       hashtable_unlink(&(data->ctx->table),
+                           (hashnode_t *)tn);
+                       pool_free((pnode_t *)tn);
+                       tn = NULL;
+               }
+       }
+       if (tn != NULL) {
+               /* Determine next to expire timer */
+               if (data->soonest > tn->expiration)
+                       data->soonest = tn->expiration;
        }
-    }
-    if (tn != NULL) {
-       /* Determine next to expire timer */
-       if (data->soonest > tn->expiration)
-           data->soonest = tn->expiration;
-    }
-
-    return TRUE;
-}
 
+       return true;
+}
 
-/* A quick hashtable_hash() replacement which already deals with unique
+/*
+ * A quick hashtable_hash() replacement which already deals with unique
  * 32-bit values.
  */ 
 /* ARGSUSED */
-static u_int32_t key_hash32(const void *data, size_t len)
+static uint32_t
+key_hash32(const void *data, size_t len)
 {
-    return *((u_int32_t *)data);
-}
 
+       return *((uint32_t *)data);
+}
 
-/* A quick memcmp() replacement which only needs to compare two 32-bit values.
+/*
+ * A quick memcmp() replacement which only needs to compare two 32-bit values.
  */
 /* ARGSUSED */
-static int key_cmp32(const void *src, const void *dst, size_t len)
+static int
+key_cmp32(const void *src, const void *dst, size_t len)
 {
-    return *((u_int32_t *)src) - *((u_int32_t *)dst);
+
+       return *((uint32_t *)src) - *((uint32_t *)dst);
 }
index 3be5d58..4678371 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmalarm.h,v 1.4 2004/06/01 19:11:56 mmondor Exp $ */
+/* $Id: mmalarm.h,v 1.5 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2003-2004, Matthew Mondor
+ * Copyright (C) 2003, 2004, 2007,  Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+
 #ifndef MM_ALARM_H
 #define MM_ALARM_H
 
 
-
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 
-#include <mmtypes.h>
 #include <mmpool.h>
 #include <mmhash.h>
 
 
-
-typedef struct timer_context timerctx_t;
-typedef u_int32_t timerid_t;
-
+typedef struct timer_context   timerctx_t;
+typedef uint32_t               timerid_t;
 
 
 #define MAGIC_TIMER_CTX                0x54435458      /* TCTX */
 #define TIMER_CTX_VALID(c)     ((c) != NULL && (c)->magic == MAGIC_TIMER_CTX)
 
 
-
 struct timer_context {
-    u_int32_t magic;
-    pool_t pool;
-    hashtable_t table;
-    timerid_t id;
-    time_t (*time)(time_t *);
-    unsigned int (*alarm)(unsigned int);
+       uint32_t        magic;
+       pool_t          pool;
+       hashtable_t     table;
+       timerid_t       id;
+       time_t          (*time)(time_t *);
+       unsigned int    (*alarm)(unsigned int);
 };
 
 struct timer_node {
-    hashnode_t node;
-    timerid_t id;
-    u_int32_t delay;
-    time_t expiration;
-    void (*function)(timerid_t, void *);
-    void *udata;
-    bool repeat;
+       hashnode_t      node;
+       timerid_t       id;
+       uint32_t        delay;
+       time_t          expiration;
+       void            (*function)(timerid_t, void *);
+       void            *udata;
+       bool            repeat;
 };
 
 
-
 extern bool            timer_ctx_init(timerctx_t *, void *(*)(size_t),
-                               void (*)(void *), time_t (*)(time_t *),
-                               unsigned int (*)(unsigned int));
+                           void (*)(void *), time_t (*)(time_t *),
+                           unsigned int (*)(unsigned int));
 extern void            timer_ctx_destroy(timerctx_t *);
-extern timerid_t       timer_init(timerctx_t *, time_t, u_int32_t,
-                               void (*)(timerid_t, void *), void *, bool);
+extern timerid_t       timer_init(timerctx_t *, time_t, uint32_t,
+                           void (*)(timerid_t, void *), void *, bool);
 extern void            timer_destroy(timerctx_t *, time_t, timerid_t);
 extern void            timer_ctx_execute(timerctx_t *, time_t);
 
 
-
 #endif
index 8fb9acf..1031f2b 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmarch.c,v 1.2 2004/08/06 15:20:27 mmondor Exp $ */
+/* $Id: mmarch.c,v 1.3 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2004, Matthew Mondor
+ * Copyright (C) 2004, 2007, Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -35,7 +35,7 @@
 
 
 
-#include <sys/types.h>
+#include <stdint.h>
 
 #include "mmtypes.h"
 #include "mmarch.h"
 
 #if defined(ARCH_LITTLE_ENDIAN)
 
-inline u_int16_t byteorder_bswap16(u_int16_t w)
+inline uint16_t
+byteorder_bswap16(uint16_t w)
 {
-    register u_int8_t *p = (u_int8_t *)&w;
+       register uint8_t        *p = (uint8_t *)&w;
 
-    return (u_int16_t)(p[0] << 8 | p[1]);
+       return (uint16_t)(p[0] << 8 | p[1]);
 }
 
-inline u_int32_t byteorder_bswap32(u_int32_t w)
+inline uint32_t
+byteorder_bswap32(uint32_t w)
 {
-    register u_int8_t *p = (u_int8_t *)&w;
+       register uint8_t        *p = (uint8_t *)&w;
 
-    return (u_int32_t)(p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3]);
+       return (uint32_t)(p[0] << 24 | p[1] << 16 | p[2] << 8 | p[3]);
 }
 
-inline u_int64_t byteorder_bswap64(u_int64_t w)
+inline uint64_t
+byteorder_bswap64(uint64_t w)
 {
-    /* To not break strict aliasing rules with GCC 3 */
-    register u_int8_t *tp = (u_int8_t *)&w;
-    register u_int32_t *p = (u_int32_t *)tp, t;
+       /* To not break strict aliasing rules */
+       register uint8_t *tp = (uint8_t *)&w;
+       register uint32_t *p = (uint32_t *)tp, t;
 
-    t = byteorder_bswap32(p[0]);
-    p[0] = byteorder_bswap32(p[1]);
-    p[1] = t;
+       t = byteorder_bswap32(p[0]);
+       p[0] = byteorder_bswap32(p[1]);
+       p[1] = t;
 
-    return w;
+       return w;
 }
 
 #endif
index a9420fb..accf91e 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmarch.h,v 1.3 2005/01/31 18:11:57 mmondor Exp $ */
+/* $Id: mmarch.h,v 1.4 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2004, Matthew Mondor
@@ -40,7 +40,7 @@
 
 
 
-#include <sys/types.h>
+#include <stdint.h>
 
 
 
@@ -101,9 +101,9 @@ error "Undefined ARCH_LONG_BITS (8, 16, 32, 64)";
 #define BYTEORDER_NETWORK64    byteorder_bswap64
 #define BYTEORDER_HOST64       byteorder_bswap64
 
-extern u_int16_t       byteorder_bswap16(u_int16_t);
-extern u_int32_t       byteorder_bswap32(u_int32_t);
-extern u_int64_t       byteorder_bswap64(u_int64_t);
+extern uint16_t                byteorder_bswap16(uint16_t);
+extern uint32_t                byteorder_bswap32(uint32_t);
+extern uint64_t                byteorder_bswap64(uint64_t);
 
 #elif defined(ARCH_BIG_ENDIAN)
 
index c25fe76..d40eb77 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmbstring.c,v 1.3 2004/03/22 06:59:34 mmondor Exp $ */
+/* $Id: mmbstring.c,v 1.4 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
@@ -42,6 +42,7 @@
 
 
 #include <sys/types.h>
+#include <stdbool.h>
 #include <stdlib.h>
 
 #include <mmtypes.h>
@@ -53,7 +54,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmbstring.c,v 1.3 2004/03/22 06:59:34 mmondor Exp $");
+MMRCSID("$Id: mmbstring.c,v 1.4 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
index ecf3b84..6d20c5c 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmbstring.h,v 1.4 2004/06/01 19:11:56 mmondor Exp $ */
+/* $Id: mmbstring.h,v 1.5 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
@@ -43,6 +43,8 @@
 
 
 #include <sys/types.h>
+#include <stdbool.h>
+
 #include <mmtypes.h>
 
 
index 12701f5..7f682d2 100644 (file)
@@ -1,4 +1,4 @@
-.\" $Id: mmfd.3,v 1.12 2004/11/12 16:26:01 mmondor Exp $
+.\" $Id: mmfd.3,v 1.13 2007/12/05 23:47:56 mmondor Exp $
 .\"
 .\" Copyright (C) 2001-2004, Matthew Mondor
 .\" All rights reserved.
 .Fn FDBERRNO "fdbuf *fdb"
 .Ft char *
 .Fn FDBERRSTR "int fdberrno"
-.Ft u_int64_t
+.Ft uint64_t
 .Fn microtime "void"
 .Sh DESCRIPTION
 This library mainly consists of a more powerful stdio replacement and is
index 834db4b..a7e0943 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmfd.c,v 1.23 2005/09/12 12:04:25 mmondor Exp $ */
+/* $Id: mmfd.c,v 1.24 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
 
 /* HEADERS */
 
-#include <sys/types.h>
 #include <sys/unistd.h>
 #include <sys/time.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <fcntl.h>
@@ -59,7 +60,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmfd.c,v 1.23 2005/09/12 12:04:25 mmondor Exp $");
+MMRCSID("$Id: mmfd.c,v 1.24 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -79,13 +80,13 @@ const char *fdberrstrings[] = {
 
 /* FUNCTIONS */
 
-u_int64_t
+uint64_t
 microtime(void)
 {
     struct timeval tv;
 
     return (gettimeofday(&tv, NULL) == 0 ?
-           (u_int64_t)(tv.tv_sec * 1000000) + tv.tv_usec
+           (uint64_t)(tv.tv_sec * 1000000) + tv.tv_usec
            : 0);
 }
 
@@ -489,7 +490,7 @@ fdbrread(fdbuf *fdb, void *buf, size_t size)
     ssize_t err = FDB_OK;
     size_t csize;
     ssize_t cur, ocur;
-    u_int64_t ms;
+    uint64_t ms;
     char *ptr = buf;
 
     MUTEX_LOCK(&fdb->context, rlock);
@@ -590,7 +591,7 @@ fdbrwrite(fdbuf *fdb, const void *buf, size_t size)
     ssize_t err = FDB_OK;
     size_t csize;
     ssize_t cur;
-    u_int64_t ms;
+    uint64_t ms;
     const char *ptr = buf;
 
     MUTEX_LOCK(&fdb->context, wlock);
index 9e51716..da3f1fa 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmfd.h,v 1.16 2004/11/12 16:26:02 mmondor Exp $ */
+/* $Id: mmfd.h,v 1.17 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
@@ -47,6 +47,8 @@
 #include <sys/types.h>
 #include <stdio.h>
 #include <stdarg.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <unistd.h>
 #include <poll.h>
 #include <unistd.h>
@@ -151,7 +153,7 @@ typedef struct fdbcontext {
     void (*mutex_unlock)(void *);
     void (*thread_yield)(void);
     void *rlock, *wlock;
-    u_int64_t ortime, owtime;
+    uint64_t ortime, owtime;
     int64_t rbytes, wbytes;
     size_t rrate, wrate, orbytes, owbytes;
 } fdbcontext;
@@ -193,7 +195,7 @@ extern const char *fdberrstrings[];
 
 /* PROTOTYPES */
 
-extern u_int64_t       microtime(void);
+extern uint64_t        microtime(void);
 extern int             fddataready(fdfuncs *, int, int, bool);
 extern int             fdcleartosend(fdfuncs *, int, int, bool);
 extern int             fdputs(fdfuncs *, int, const char *);
index ffb6c21..fffb852 100644 (file)
@@ -1,4 +1,4 @@
-.\" $Id: mmfifo.3,v 1.8 2004/05/05 23:59:56 mmondor Exp $
+.\" $Id: mmfifo.3,v 1.9 2007/12/05 23:47:56 mmondor Exp $
 .\"
 .\" Copyright (C) 2000-2004, Matthew Mondor
 .\" All rights reserved.
 .Ft void
 .Fn FIFO_DEFINE "fifotype_t" "objecttype"
 .Ft void
-.Fn FIFO_INIT "fifotype_t *fifo" "void *buffer" "u_int32_t size"
+.Fn FIFO_INIT "fifotype_t *fifo" "void *buffer" "uint32_t size"
 .Ft bool
 .Fn FIFO_FULL "fifotype_t *fifo"
 .Ft bool
 .Fn FIFO_EMPTY "fifotype_t *fifo"
-.Ft u_int32_t
+.Ft uint32_t
 .Fn FIFO_STAT "fifotype_t *fifo"
-.Ft u_int32_t
+.Ft uint32_t
 .Fn FIFO_AVAIL "fifotype_t *fifo"
 .Ft void
 .Fn FIFO_FLUSH "fifotype_t *fifo"
 .Ft void
 .Fn FIFO_FIND "fifotype_t *fifo" "objecttype **pointer" "objecttype *element"
 .Ft void
-.Fn FIFO_ALLOC "fifotype_t *fifo" "objecttype **pointer" "u_int32_t *actual" \
-"u_int32_t size"
+.Fn FIFO_ALLOC "fifotype_t *fifo" "objecttype **pointer" "uint32_t *actual" \
+"uint32_t size"
 .Ft void
-.Fn FIFO_FREE "fifotype_t *fifo" "objecttype **pointer" "u_int32_t *actual" \
-"u_int32_t size"
+.Fn FIFO_FREE "fifotype_t *fifo" "objecttype **pointer" "uint32_t *actual" \
+"uint32_t size"
 .Sh DESCRIPTION
 FIFO buffers (First In First Out) are especially useful when
 implementing asynchronous systems. For instance in the implementation of
@@ -123,13 +123,13 @@ Predefined FIFO buffer types are
 and
 .Nm fifo64_t ,
 to hold objects of type
-.Nm u_int8_t ,
-.Nm u_int16_t ,
-.Nm u_int32_t
+.Nm uint8_t ,
+.Nm uint16_t ,
+.Nm uint32_t
 and
-.Nm u_int64_t ,
+.Nm uint64_t ,
 respectively.
-.It void Fn FIFO_INIT "fifotype_t *fifo" "void *buffer" "u_int32_t size"
+.It void Fn FIFO_INIT "fifotype_t *fifo" "void *buffer" "uint32_t size"
 Allows to initialize a FIFO buffer.
 .Fa fifo
 consists of a pointer to the FIFO buffer to initialize,
@@ -154,12 +154,12 @@ is used.
 .It bool Fn FIFO_EMPTY "fifotype_t *fifo"
 allows to determine if a FIFO buffer is currently empty, that is, does not hold
 any elements.
-.It u_int32_t Fn FIFO_STAT "fifotype_t *fifo"
+.It uint32_t Fn FIFO_STAT "fifotype_t *fifo"
 permits to know how many elements are currently buffered into the specified
 .Fa fifo
 buffer, which can be read using
 .Fn FIFO_GET .
-.It u_int32_t Fn FIFO_AVAIL "fifotype_t *fifo"
+.It uint32_t Fn FIFO_AVAIL "fifotype_t *fifo"
 evaluates the number of free elements in the buffer and returns it.
 .It void Fn FIFO_FLUSH "fifotype_t *fifo"
 allows to get rid of all the current contents, if any, of the specified
@@ -198,7 +198,7 @@ buffer contents, and fills
 .Fa pointer
 with the element pointer if found, or NULL if the element could not be found.
 .It void Fn FIFO_ALLOC "fifotype_t *fifo" "objecttype **pointer" \
-"u_int32_t *actual" "u_int32_t size"
+"uint32_t *actual" "uint32_t size"
 macro is useful for operations which need to insert several elements at once,
 as it allows them to allocate the required room and use
 .Xr memcpy 3
@@ -219,7 +219,7 @@ calls will be required to this macro to complete the operation. 2) The buffer
 did not contain enough room for the requested number of elements. The caller
 should not attempt to use the returned pointer if the returned size is zero.
 .It void Fn FIFO_FREE "fifotype_t *fifo" "objecttype **pointer" \
-"u_int32_t *actual" "u_int32_t size"
+"uint32_t *actual" "uint32_t size"
 contrary to
 .Fn FIFO_ALLOC ,
 permits to free back a certain number of elements at once from the buffer.
index d7d9b65..41b234f 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmfifo.c,v 1.4 2004/03/22 06:59:34 mmondor Exp $ */
+/* $Id: mmfifo.c,v 1.5 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -37,6 +37,7 @@
 
 
 #include <sys/types.h>
+#include <stdint.h>
 
 #include <mmtypes.h>
 #include <mmstring.h>
@@ -47,7 +48,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2000-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmfifo.c,v 1.4 2004/03/22 06:59:34 mmondor Exp $");
+MMRCSID("$Id: mmfifo.c,v 1.5 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -58,9 +59,9 @@ MMRCSID("$Id: mmfifo.c,v 1.4 2004/03/22 06:59:34 mmondor Exp $");
  * were successfully read.
  */
 size_t
-getnfifo8(u_int8_t *buffer, fifo8_t *fifo, size_t max)
+getnfifo8(uint8_t *buffer, fifo8_t *fifo, size_t max)
 {
-    register u_int8_t *pos;
+    register uint8_t *pos;
     register size_t len, len2, done;
 
     if (max == 1) {
@@ -104,9 +105,9 @@ getnfifo8(u_int8_t *buffer, fifo8_t *fifo, size_t max)
  * It returns the number of elements that could be inserted.
  */
 size_t
-putnfifo8(fifo8_t *fifo, u_int8_t *buffer, size_t size)
+putnfifo8(fifo8_t *fifo, uint8_t *buffer, size_t size)
 {
-    u_int8_t *pos;
+    uint8_t *pos;
     size_t len, len2, done;
 
     if (size == 1) {
index efe8c3e..2a1f3d9 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmfifo.h,v 1.7 2004/06/04 19:13:24 mmondor Exp $ */
+/* $Id: mmfifo.h,v 1.8 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -41,6 +41,7 @@
 
 
 
+#include <stdint.h>
 
 #include <mmtypes.h>
 
 /* Allows to create a new fifo_t type structure, to fit any data type */
 #define FIFO_DEFINE(n, o)      typedef struct n {                      \
     o *top, *bottom, *head, *tail;                                     \
-    u_int32_t size;                                                    \
+    uint32_t size;                                                     \
 } n
 
-FIFO_DEFINE(fifo8_t, u_int8_t);
-FIFO_DEFINE(fifo16_t, u_int16_t);
-FIFO_DEFINE(fifo32_t, u_int32_t);
-FIFO_DEFINE(fifo64_t, u_int64_t);
+FIFO_DEFINE(fifo8_t, uint8_t);
+FIFO_DEFINE(fifo16_t, uint16_t);
+FIFO_DEFINE(fifo32_t, uint32_t);
+FIFO_DEFINE(fifo64_t, uint64_t);
 
 
 
index 75f3fe1..f51bdce 100644 (file)
@@ -1,4 +1,4 @@
-.\" $Id: mmhash.3,v 1.12 2004/05/23 01:50:06 mmondor Exp $
+.\" $Id: mmhash.3,v 1.13 2007/12/05 23:47:56 mmondor Exp $
 .\"
 .\" Copyright (C) 2001-2004, Matthew Mondor
 .\" All rights reserved.
@@ -51,7 +51,7 @@
 .Ft void
 .Fn hashtable_init2 "hashtable_t *table" "const char *label" "list_t *array" \
 "unsigned int capacity" "int (*keycmp)(const void *, const void *, size_t)" \
-"u_int32_t (*keyhash)(const void *, size_t)"
+"uint32_t (*keyhash)(const void *, size_t)"
 .Ft void
 .Fn hashtable_destroy "hashtable_t *table" "bool freeall"
 .Ft hashnode_t *
@@ -66,7 +66,7 @@
 .Ft void
 .Fn hashtable_iterate "hashtable_t *table" \
 "bool (*func)(hashnode_t *, void *)" "void *udata"
-.Ft u_int32_t
+.Ft uint32_t
 .Fn hashtable_hash "const void *data" "size_t size"
 .Ft unsigned int
 .Fn HASHTABLE_NODES "hashtable_t *table"
@@ -242,7 +242,7 @@ doing so will slow down linking (insert) and find (lookup) operations.
 .It void Fn hashtable_init2 "hashtable_t *table" "const char *label" \
 "list_t *array" "unsigned int capacity" \
 "int (*keycmp)(const void *, const void *, size_t)" \
-"u_int32_t (*keyhash)(const void *, size_t)"
+"uint32_t (*keyhash)(const void *, size_t)"
 Initializes an
 .Dv hashtable_t
 like
@@ -437,7 +437,7 @@ on the other hand, could cause an entry to be located in a next-to-iterate
 location, and should therefore only be called with care if on the same table
 when iterating, because the same entry could possibly be processed again
 during the same iteration.
-.It u_int32_t Fn hashtable_hash "const void *data" "size_t size"
+.It uint32_t Fn hashtable_hash "const void *data" "size_t size"
 is provided as a generic case-sensitive and bit alignment independant
 hashing function to be specified at
 .Fn hashtable_init .
index a80b1be..3b941c0 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmhash.c,v 1.25 2004/06/04 01:02:32 mmondor Exp $ */
+/* $Id: mmhash.c,v 1.26 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2001-2004, Matthew Mondor
+ * Copyright (C) 2001, 2004, 2007, Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  */
 
 
-
-#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <syslog.h>
 
 #include <mmhash.h>
 #include <mmlog.h>
 
 
-
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmhash.c,v 1.25 2004/06/04 01:02:32 mmondor Exp $");
-
+MMRCSID("$Id: mmhash.c,v 1.26 2007/12/05 23:47:56 mmondor Exp $");
 
 
-/* This system is safe to use 32-bit hashes internally, despite the possibility
+/*
+ * This system is safe to use 32-bit hashes internally, despite the possibility
  * for collisions. We maintain an array or buckets, within which the entries
  * are distributed. A 32-bit hash collision entry will end up on the same
  * bucket. We however also make sure to not allow to store exact duplicate
@@ -80,357 +79,378 @@ MMRCSID("$Id: mmhash.c,v 1.25 2004/06/04 01:02:32 mmondor Exp $");
  * through buckets when the total number of mappings have been scanned already.
  * Lookups using the absolute key of the node will be much faster in the case
  * where the hash table grows considerably, however.
+ *
+ * TODO:
+ * - Statistics should ideally be done based on time rather than on a number
+ *   of recent operations.  A function should be provided for this purpose,
+ *   which the library user could call at regular intervals or occasionally.
  */
 
 
-
 #define HASH_INDEX(h, s)       ((h) % (s))
 
 
+static void                    hashtable_rehash(hashtable_t *, unsigned int);
 
-static void hashtable_rehash(hashtable_t *, unsigned int);
 
+bool
+hashtable_init(hashtable_t *t, const char *label, unsigned int initialcapacity,
+    float loadfactor, void *(*allocfunc)(size_t), void (*freefunc)(void *),
+    int (*keycomp)(const void *, const void *, size_t),
+    uint32_t (*keyhash)(const void *, size_t), bool dynamic)
+{
 
+       if (DEBUG_FALSE(HASHTABLE_VALID(t))) {
+               DEBUG_PRINTF("Table (%p = %s) already initialized",
+                   t, t->label);
+               return false;
+       }
 
-bool hashtable_init(hashtable_t *t, const char *label,
-       unsigned int initialcapacity, float loadfactor,
-       void *(*allocfunc)(size_t), void (*freefunc)(void *),
-       int (*keycomp)(const void *, const void *, size_t),
-       u_int32_t (*keyhash)(const void *, size_t), bool dynamic)
-{
-    if (DEBUG_FALSE(HASHTABLE_VALID(t))) {
-       DEBUG_PRINTF("hashtable_init", "Table (%p = %s) already initialized",
-               t, t->label);
-       return FALSE;
-    }
+       if ((t->array = allocfunc(sizeof(list_t) * initialcapacity)) != NULL) {
+               unsigned int    i;
+
+               t->magic = MAGIC_HASHTABLE;
+               t->label = label;
+               t->malloc = allocfunc;
+               t->free = freefunc;
+               t->keycomp = keycomp;
+               t->keyhash = keyhash;
+               t->nodes = 0;
+               t->initial = t->capacity = initialcapacity;
+               t->loadfactor = loadfactor;
+               t->threshold = (unsigned int)(((float)initialcapacity) *
+                   loadfactor);
+               t->avgtotal = t->avgcnt = initialcapacity;
+               t->dynamic = dynamic;
+               t->iterating = false;
+               for (i = 0; i < initialcapacity; i++)
+                       DLIST_INIT(&(t->array[i]));
+
+               return true;
+       } else
+               syslog(LOG_NOTICE,
+                   "hashtable_init() - Table (%p = %s) - malloc(%d)",
+                   t, label, (int)sizeof(list_t) * initialcapacity);
 
-    if ((t->array = allocfunc(sizeof(list_t) * initialcapacity)) != NULL) {
+       return false;
+}
+
+void
+hashtable_init2(hashtable_t *t, const char *label, list_t *array,
+    unsigned int capacity,
+    int (*keycomp)(const void *, const void *, size_t),
+    uint32_t (*keyhash)(const void *, size_t))
+{
        unsigned int i;
 
+       if (DEBUG_FALSE(HASHTABLE_VALID(t))) {
+               DEBUG_PRINTF("Table (%p = %s) already initialized",
+                   t, t->label);
+               return;
+       }
+
        t->magic = MAGIC_HASHTABLE;
        t->label = label;
-       t->malloc = allocfunc;
-       t->free = freefunc;
+       t->array = array;
+       t->malloc = NULL;
+       t->free = NULL;
        t->keycomp = keycomp;
        t->keyhash = keyhash;
        t->nodes = 0;
-       t->initial = t->capacity = initialcapacity;
-       t->loadfactor = loadfactor;
-       t->threshold = (unsigned int)(((float)initialcapacity) *
-               loadfactor);
-       t->avgtotal = t->avgcnt = initialcapacity;
-       t->dynamic = dynamic;
-       t->iterating = FALSE;
-       for (i = 0; i < initialcapacity; i++)
-           DLIST_INIT(&(t->array[i]));
-
-       return TRUE;
-    } else
-       syslog(LOG_NOTICE, "hashtable_init() - Table (%p = %s) - malloc(%d)",
-               t, label, (int)sizeof(list_t) * initialcapacity);
-
-    return FALSE;
+       t->initial = t->capacity = capacity;
+       t->loadfactor = 0;
+       t->threshold = 0;
+       t->avgtotal = t->avgcnt = capacity;
+       t->dynamic = false;
+       t->iterating = false;
+       for (i = 0; i < capacity; i++)
+               DLIST_INIT(&(t->array[i]));
 }
 
-
-void hashtable_init2(hashtable_t *t, const char *label, list_t *array,
-       unsigned int capacity,
-       int (*keycomp)(const void *, const void *, size_t),
-       u_int32_t (*keyhash)(const void *, size_t))
+void
+hashtable_destroy(hashtable_t *t, bool freeall)
 {
-    unsigned int i;
-
-    if (DEBUG_FALSE(HASHTABLE_VALID(t))) {
-       DEBUG_PRINTF("hashtable_init2", "Table (%p = %s) already initialized",
-               t, t->label);
-       return;
-    }
-
-    t->magic = MAGIC_HASHTABLE;
-    t->label = label;
-    t->array = array;
-    t->malloc = NULL;
-    t->free = NULL;
-    t->keycomp = keycomp;
-    t->keyhash = keyhash;
-    t->nodes = 0;
-    t->initial = t->capacity = capacity;
-    t->loadfactor = 0;
-    t->threshold = 0;
-    t->avgtotal = t->avgcnt = capacity;
-    t->dynamic = FALSE;
-    t->iterating = FALSE;
-    for (i = 0; i < capacity; i++)
-       DLIST_INIT(&(t->array[i]));
-}
-
+       if (DEBUG_FALSE(!HASHTABLE_VALID(t))) {
+               DEBUG_PRINTF("Invalid hashtable_t pointer (%p)", t);
+               return;
+       }
 
-void hashtable_destroy(hashtable_t *t, bool freeall)
-{
-    if (DEBUG_TRUE(HASHTABLE_VALID(t))) {
        if (t->array != NULL) {
-           if (freeall) {
-               register unsigned int i, done;
-               register list_t *l;
-               register hashnode_t *k, *kt;
-
-               for (i = done = 0; done < t->nodes && i < t->capacity; i++) {
-                   l = &(t->array[i]);
-                   if (DLIST_NODES(l) > 0) {
-                       for (k = DLIST_TOP(l); k != NULL; k = kt) {
-                           kt = DLIST_NEXT(k);
-                           pool_free((pnode_t *)k);
-                           done++;
+               if (freeall) {
+                       register unsigned int   i, done;
+                       register list_t         *l;
+                       register hashnode_t     *k, *kt;
+
+                       for (i = done = 0; done < t->nodes && i < t->capacity;
+                           i++) {
+                               l = &(t->array[i]);
+                               if (DLIST_NODES(l) > 0) {
+                                       for (k = DLIST_TOP(l); k != NULL;
+                                           k = kt) {
+                                               kt = DLIST_NEXT(k);
+                                               pool_free((pnode_t *)k);
+                                               done++;
+                                       }
+                               }
                        }
-                   }
                }
-           }
-           t->free(t->array);
+               t->free(t->array);
        }
        t->magic = 0;
-    } else
-       DEBUG_PRINTF("hashtable_destroy",
-               "Invalid hashtable_t pointer (%p)", t);
 }
 
-
-hashnode_t *hashtable_lookup(hashtable_t *t, const void *key, size_t keysize)
+hashnode_t *
+hashtable_lookup(hashtable_t *t, const void *key, size_t keysize)
 {
-    register u_int32_t hash;
-    register unsigned int i;
-    register list_t *l;
-    register hashnode_t *k = NULL;
+       register uint32_t       hash;
+       register unsigned int   i;
+       register list_t         *l;
+       register hashnode_t     *k = NULL;
+
+       if (DEBUG_FALSE(!HASHTABLE_VALID(t))) {
+               DEBUG_PRINTF("Invalid hashtable_t pointer (%p)", t);
+               return NULL;
+       }
 
-    if (DEBUG_TRUE(HASHTABLE_VALID(t))) {
        hash = t->keyhash(key, keysize);
        i = HASH_INDEX(hash, t->capacity);
        l = &(t->array[i]);
        if (DLIST_NODES(l) > 0) {
-           DLIST_FOREACH(l, k) {
-               if (k->hash == hash && k->keysize == keysize &&
-                       t->keycomp(k->key, key, keysize) == 0)
-                   break;
-           }
+               DLIST_FOREACH(l, k) {
+                       if (k->hash == hash && k->keysize == keysize &&
+                           t->keycomp(k->key, key, keysize) == 0)
+                               break;
+               }
        }
-    } else
-       DEBUG_PRINTF("hashtable_lookup",
-               "Invalid hashtable_t pointer (%p)", t);
 
-    return k;
+       return k;
 }
 
-
-bool hashtable_link(hashtable_t *t, hashnode_t *k, const void *key,
-       size_t keysize, bool check)
+bool
+hashtable_link(hashtable_t *t, hashnode_t *k, const void *key,
+    size_t keysize, bool check)
 {
-    register u_int32_t hash;
-    register unsigned int i;
-    register list_t *l;
-    bool ok = TRUE;
-
-    if (DEBUG_FALSE(!(HASHTABLE_VALID(t)))) {
-       DEBUG_PRINTF("hashtable_link",
-               "Invalid hashtable_t pointer (%p)", t);
-       return FALSE;
-    }
-    if (DEBUG_FALSE(k == NULL)) {
-       DEBUG_PRINTF("hashtable_link", "Invalid hashnode_t pointer (NULL)");
-       return FALSE;
-    }
-
-    hash = t->keyhash(key, keysize);
-    i = HASH_INDEX(hash, t->capacity);
-    l = &(t->array[i]);
-    if (check) {
-       /* We do not allow exact duplicates, so verify first. Duplicate
-        * hashes are fine, however, as long as the key data is not identical.
-        */
-       if (DLIST_NODES(l) > 0) {
-           register hashnode_t *tk;
+       register uint32_t        hash;
+       register unsigned int   i;
+       register list_t         *l;
+       bool                    ok = true;
+
+       if (DEBUG_FALSE(!HASHTABLE_VALID(t))) {
+               DEBUG_PRINTF("Invalid hashtable_t pointer (%p)", t);
+               return false;
+       }
+       if (DEBUG_FALSE(k == NULL)) {
+               DEBUG_PRINTF("Invalid hashnode_t pointer (NULL)");
+               return false;
+       }
 
-           DLIST_FOREACH(l, tk) {
-               if (tk == k || (tk->hash == hash && tk->keysize == keysize &&
-                           t->keycomp(tk->key, key, keysize) == 0)) {
-                   ok = FALSE;
-                   break;
+       hash = t->keyhash(key, keysize);
+       i = HASH_INDEX(hash, t->capacity);
+       l = &(t->array[i]);
+       if (check) {
+               /*
+                * We do not allow exact duplicates, so verify first.
+                * Duplicate hashes are fine, however, as long as the key data
+                * is not identical.
+                */
+               if (DLIST_NODES(l) > 0) {
+                       register hashnode_t     *tk;
+
+                       DLIST_FOREACH(l, tk) {
+                               if (tk == k ||
+                                   (tk->hash == hash &&
+                                   tk->keysize == keysize &&
+                                   t->keycomp(tk->key, key, keysize) == 0)) {
+                                       ok = false;
+                                       break;
+                               }
+                       }
                }
-           }
        }
-    }
-    if (ok) {
-       k->magic = MAGIC_HASHNODE;
-       k->hash = hash;
-       k->list = l;
-       k->key = key;
-       k->keysize = keysize;
-       DLIST_INSERT(l, (node_t *)k);
-       /* Grow capacity if necessary */
-       t->nodes++;
-       if (t->dynamic && !t->iterating) {
-           if (t->nodes > t->threshold)
-               hashtable_rehash(t, t->capacity * 2);
+       if (ok) {
+               k->magic = MAGIC_HASHNODE;
+               k->hash = hash;
+               k->list = l;
+               k->key = key;
+               k->keysize = keysize;
+               DLIST_INSERT(l, (node_t *)k);
+               /* Grow capacity if necessary */
+               t->nodes++;
+               if (t->dynamic && !t->iterating) {
+                       if (t->nodes > t->threshold)
+                               hashtable_rehash(t, t->capacity * 2);
+               }
        }
-    }
 
-    return ok;
+       return ok;
 }
 
-
-void hashtable_unlink(hashtable_t *t, hashnode_t *k)
+void
+hashtable_unlink(hashtable_t *t, hashnode_t *k)
 {
-    if (DEBUG_TRUE(HASHTABLE_VALID(t))) {
-       if (DEBUG_TRUE(k != NULL && k->magic == MAGIC_HASHNODE)) {
-           int exceeding;
-
-           k->magic = 0;
-           DLIST_UNLINK(k->list, (node_t *)k);
-           k->list = NULL;
-           t->nodes--;
-
-           /* Verify if the capacity should be reduced, using statistics */
-           t->avgtotal += t->capacity;
-           t->avgcnt++;
-           if (t->avgcnt > t->capacity / (t->initial * 3)) {
+       int     exceeding;
+
+       if (DEBUG_FALSE(!HASHTABLE_VALID(t))) {
+               DEBUG_PRINTF("Invalid hashtable_t pointer (%p)", t);
+               return;
+       }
+       if (DEBUG_FALSE(k == NULL || k->magic != MAGIC_HASHNODE)) {
+               DEBUG_PRINTF("Invalid hashtnode_t pointer (%p)", k);
+               return;
+       }
+
+       k->magic = 0;
+       DLIST_UNLINK(k->list, (node_t *)k);
+       k->list = NULL;
+       t->nodes--;
+
+       /* Verify if the capacity should be reduced, using statistics */
+       t->avgtotal += t->capacity;
+       t->avgcnt++;
+       if (t->avgcnt > t->capacity / (t->initial * 3)) {
                t->avgcnt = 1;
                t->avgtotal = t->capacity;
-           }
-           /* Rehash with a smaller capacity if necessary */
-           if (t->dynamic && !t->iterating) {
+       }
+       /* Rehash with a smaller capacity if necessary */
+       if (t->dynamic && !t->iterating) {
                if ((exceeding = t->capacity - (t->avgtotal / t->avgcnt)) > 0)
-                   hashtable_rehash(t, t->capacity - exceeding);
-           }
-       } else
-           DEBUG_PRINTF("hashtable_unlink",
-                   "Invalid hashtnode_t pointer (%p)", k);
-    } else
-       DEBUG_PRINTF("hashtable_unlink",
-               "Invalid hashtable_t pointer (%p)", t);
+                       hashtable_rehash(t, t->capacity - exceeding);
+       }
 }
 
-
-/* Note that as the user generally has a pool_t dedicated to the hashnode_t
+/*
+ * Note that as the user generally has a pool_t dedicated to the hashnode_t
  * elements for a particular table, it may be more efficient to not use
  * the <freeall> option and to pool_free() which does not need to iterate
  * through nodes. This function has to however, because it obviously cannot
  * assume that the caller wishes to free all nodes of the origin pool_t, or
  * that all entries origin from the same pool_t.
  */
-void hashtable_empty(hashtable_t *t, bool freeall)
+void
+hashtable_empty(hashtable_t *t, bool freeall)
 {
-    register unsigned int i;
-    register list_t *l;
-    register hashnode_t *k, *kt;
+       register unsigned int   i;
+       register list_t         *l;
+       register hashnode_t     *k, *kt;
+
+       if (DEBUG_FALSE(!HASHTABLE_VALID(t))) {
+               DEBUG_PRINTF("Invalid hashtable_t pointer (%p)", t);
+               return;
+       }
 
-    if (DEBUG_TRUE(HASHTABLE_VALID(t))) {
        if (freeall) {
-           for (i = 0; i < t->capacity; i++) {
-               l = &(t->array[i]);
-               if (DLIST_NODES(l) > 0) {
-                   for (k = DLIST_TOP(l); k != NULL; k = kt) {
-                       kt = DLIST_NEXT(k);
-                       pool_free((pnode_t *)k);
-                   }
+               for (i = 0; i < t->capacity; i++) {
+                       l = &(t->array[i]);
+                       if (DLIST_NODES(l) > 0) {
+                               for (k = DLIST_TOP(l); k != NULL; k = kt) {
+                                       kt = DLIST_NEXT(k);
+                                       pool_free((pnode_t *)k);
+                               }
+                       }
                }
-           }
        } else {
-           for (i = 0; i < t->capacity; i++)
-               DLIST_INIT(&(t->array[i]));
+               for (i = 0; i < t->capacity; i++)
+                       DLIST_INIT(&(t->array[i]));
        }
+
        if (t->dynamic && !t->iterating)
-           hashtable_rehash(t, t->initial);
-    } else
-       DEBUG_PRINTF("hashtable_empty",
-               "Invalid hashtable_t pointer (%p)", t);
+               hashtable_rehash(t, t->initial);
 }
 
-
-void hashtable_iterate(hashtable_t *t,
-       bool (*func)(hashnode_t *, void *), void *udata)
+void
+hashtable_iterate(hashtable_t *t, bool (*func)(hashnode_t *, void *),
+    void *udata)
 {
-    register unsigned int i;
-    register list_t *l;
-    register hashnode_t *k, *kt;
-
-    if (DEBUG_TRUE(HASHTABLE_VALID(t))) {
-       if (t->nodes > 0) {
-           t->iterating = TRUE;
-           for (i = 0; i < t->capacity; i++) {
+       register unsigned int   i;
+       register list_t         *l;
+       register hashnode_t     *k, *kt;
+
+       if (DEBUG_FALSE(!HASHTABLE_VALID(t))) {
+               DEBUG_PRINTF("Invalid hashtable_t pointer (%p)", t);
+               return;
+       }
+
+       if (t->nodes < 1)
+               return;
+
+       t->iterating = true;
+       for (i = 0; i < t->capacity; i++) {
                l = &(t->array[i]);
                if (DLIST_NODES(l) > 0) {
-                   /* Note that we use a temporary variable to hold the next
-                    * key, in case the user function alters the key node
-                    * (i.e. unlinks it)
-                    */
-                   for (k = DLIST_TOP(l); k != NULL; k = kt) {
-                       kt = DLIST_NEXT(k);
-                       if (!func(k, udata)) {
-                           t->iterating = FALSE;
-                           return;
+                       /*
+                        * Note that we use a temporary variable to hold the
+                        * next key, in case the user function alters the key
+                        * node (i.e. unlinks it).
+                        */
+                       for (k = DLIST_TOP(l); k != NULL; k = kt) {
+                               kt = DLIST_NEXT(k);
+                               if (!func(k, udata)) {
+                                       t->iterating = false;
+                                       return;
+                               }
                        }
-                   }
                }
-           }
-           t->iterating = FALSE;
        }
-    } else
-       DEBUG_PRINTF("hashtable_iterate",
-               "Invalid hashtable_t pointer (%p)", t);
+       t->iterating = false;
 }
 
-
-/* Rehashes the whole hashtable so that the capacity may be changed to the
+/*
+ * Rehashes the whole hashtable so that the capacity may be changed to the
  * specified one. The memory area is also automatically changed. Ideally,
  * this only occurs rarely. If it fails because of a lack of memory, the
  * hash table will simply not be affected, but lookups will become slower.
  */
-static void hashtable_rehash(hashtable_t *t, unsigned int newcapacity)
+static void
+hashtable_rehash(hashtable_t *t, unsigned int newcapacity)
 {
-    list_t *newarray;
-
-    if ((newarray = t->malloc(sizeof(list_t) * newcapacity)) != NULL) {
-       register unsigned int i, done;
+       list_t                  *newarray;
+       register unsigned int   i, done;
+
+       if ((newarray = t->malloc(sizeof(list_t) * newcapacity)) == NULL) {
+               syslog(LOG_NOTICE, "hashtable_rehash() - Table (%p = %s) - "
+                   "Out of memory, not rehashing from %u to %u buckets",
+                   t, t->label, t->capacity, newcapacity);
+               return;
+       }
 
        for (i = 0; i < newcapacity; i++)
-           DLIST_INIT(&newarray[i]);
+               DLIST_INIT(&newarray[i]);
 
        for (i = done = 0; done < t->nodes && i < t->capacity; i++) {
-           register hashnode_t *k, *kt;
-           register list_t *l, *newl;
-
-           l = &(t->array[i]);
-           if (DLIST_NODES(l) > 0) {
-               for (k = DLIST_TOP(l); k != NULL; k = kt) {
-                   kt = DLIST_NEXT(k);
-                   newl = &newarray[HASH_INDEX(k->hash, newcapacity)];
-                   DLIST_SWAP(newl, l, (node_t *)k, TRUE);
-                   k->list = newl;
-                   done++;
+               register hashnode_t     *k, *kt;
+               register list_t         *l, *newl;
+
+               l = &(t->array[i]);
+               if (DLIST_NODES(l) > 0) {
+                       for (k = DLIST_TOP(l); k != NULL; k = kt) {
+                               kt = DLIST_NEXT(k);
+                               newl = &newarray[HASH_INDEX(k->hash,
+                                   newcapacity)];
+                               DLIST_SWAP(newl, l, (node_t *)k, true);
+                               k->list = newl;
+                               done++;
+                       }
                }
-           }
        }
 
        t->capacity = newcapacity;
        t->threshold = (unsigned int)(((float)newcapacity) * t->loadfactor);
        t->free(t->array);
        t->array = newarray;
-    } else
-       syslog(LOG_NOTICE, "hashtable_rehash() - Table (%p = %s) - "
-               "Out of memory, not rehashing from %u to %u buckets",
-               t, t->label, t->capacity, newcapacity);
 }
 
-
-u_int32_t hashtable_hash(const void *mem, size_t size)
+/*
+ * Generic 32-bit hashing functionality, which may be used by default.
+ */
+uint32_t
+hashtable_hash(const void *mem, size_t size)
 {
-    register u_int32_t hash;
-    register const unsigned char *curmem, *tomem;
-
-    hash = 0;
-    curmem = tomem = mem;
-    tomem += size;
+       register uint32_t       hash;
+       register const uint8_t  *curmem, *tomem;
 
-    for (; curmem < tomem; curmem++)
-       hash = *curmem + (31 * hash);
+       for (hash = 0, tomem = curmem = mem, tomem += size;
+           curmem < tomem; curmem++)
+               hash = *curmem + (31 * hash);
 
-    return hash;
+       return hash;
 }
index 3d4bcdc..6cf7ee5 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmhash.h,v 1.9 2004/05/23 02:17:27 mmondor Exp $ */
+/* $Id: mmhash.h,v 1.10 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2001-2004, Matthew Mondor
+ * Copyright (C) 2001, 2004, 2007, Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40,7 +40,8 @@
 
 
 
-#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 
 #include <mmtypes.h>
 #include <mmlist.h>
 
 
 
-typedef struct hashnode hashnode_t;
-typedef struct hashtable hashtable_t;
+typedef struct hashnode                hashnode_t;
+typedef struct hashtable       hashtable_t;
 
 
 
 struct hashnode {
-    pnode_t node;
-    u_int32_t magic;
-    list_t *list;
-    u_int32_t hash;
-    const void *key;
-    size_t keysize;
-    /* Custom user data will follow, uncluding the key element to which the
-     * previous key pointer is expected to point.
-     */
+       pnode_t                 node;
+       uint32_t                magic;
+       list_t                  *list;
+       uint32_t                hash;
+       const void              *key;
+       size_t                  keysize;
+       /*
+        * Custom user data will follow, uncluding the key element to which
+        * the previous key pointer is expected to point.
+        */
 };
 
 struct hashtable {
-    pnode_t node;      /* In case we want a pool_t of hashtable_t */
-    u_int32_t magic;
-    const char *label;
-    unsigned int initial, capacity, threshold, nodes;
-    float loadfactor;
-    list_t *array;
-    void *(*malloc)(size_t);
-    void (*free)(void *);
-    int (*keycomp)(const void *, const void *, size_t);
-    u_int32_t (*keyhash)(const void *, size_t);
-    unsigned int avgtotal, avgcnt;
-    bool dynamic, iterating;
+       pnode_t                 node;   /* Allows a pool_t of hashtable_t */
+       uint32_t                magic;
+       const char              *label;
+       unsigned int            initial, capacity,
+                               threshold, nodes;
+       float                   loadfactor;
+       list_t                  *array;
+       void                    *(*malloc)(size_t);
+       void                    (*free)(void *);
+       int                     (*keycomp)(const void *, const void *,
+                                   size_t);
+       uint32_t                (*keyhash)(const void *, size_t);
+       unsigned int            avgtotal, avgcnt;
+       bool                    dynamic, iterating;
 };
 
 
@@ -93,23 +97,23 @@ struct hashtable {
 
 
 extern bool            hashtable_init(hashtable_t *, const char *,
-                               unsigned int, float, void *(*)(size_t),
-                               void (*)(void *),
-                               int (*)(const void *, const void *, size_t),
-                               u_int32_t (*)(const void *, size_t), bool);
+                           unsigned int, float, void *(*)(size_t),
+                           void (*)(void *),
+                           int (*)(const void *, const void *, size_t),
+                           uint32_t (*)(const void *, size_t), bool);
 extern void            hashtable_init2(hashtable_t *, const char *,
-                               list_t *, unsigned int,
-                               int (*)(const void *, const void *, size_t),
-                               u_int32_t (*)(const void *, size_t));
+                           list_t *, unsigned int,
+                           int (*)(const void *, const void *, size_t),
+                           uint32_t (*)(const void *, size_t));
 extern void            hashtable_destroy(hashtable_t *, bool);
-extern hashnode_t *    hashtable_lookup(hashtable_t *, const void *, size_t);
+extern hashnode_t      *hashtable_lookup(hashtable_t *, const void *, size_t);
 extern bool            hashtable_link(hashtable_t *, hashnode_t *,
-                               const void *, size_t, bool);
+                           const void *, size_t, bool);
 extern void            hashtable_unlink(hashtable_t *, hashnode_t *);
 extern void            hashtable_empty(hashtable_t *, bool);
 extern void            hashtable_iterate(hashtable_t *,
-                               bool (*)(hashnode_t *, void *), void *);
-extern u_int32_t       hashtable_hash(const void *, size_t);
+                           bool (*)(hashnode_t *, void *), void *);
+extern uint32_t                hashtable_hash(const void *, size_t);
 
 
 
index 09b3031..f9f7fdd 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmheap.c,v 1.22 2004/06/04 01:02:32 mmondor Exp $ */
+/* $Id: mmheap.c,v 1.23 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2003-2004, Matthew Mondor
@@ -41,6 +41,8 @@
 #include <sys/stat.h>
 #endif
 #include <stdio.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <string.h>
@@ -56,7 +58,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2003-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmheap.c,v 1.22 2004/06/04 01:02:32 mmondor Exp $");
+MMRCSID("$Id: mmheap.c,v 1.23 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -88,7 +90,7 @@ struct memhdr {
 
 
 static bool init(void);
-static u_int32_t key_hash32(const void *, size_t);
+static uint32_t key_hash32(const void *, size_t);
 static int key_cmp32(const void *, const void *, size_t);
 static bool freeall_iterator(hashnode_t *, void *);
 
@@ -128,15 +130,15 @@ static bool init(void)
 }
 
 /* ARGSUSED */
-static u_int32_t key_hash32(const void *data, size_t len)
+static uint32_t key_hash32(const void *data, size_t len)
 {
-    return *((u_int32_t *)data);
+    return *((uint32_t *)data);
 }
 
 /* ARGSUSED */
 static int key_cmp32(const void *src, const void *dst, size_t len)
 {
-    return *((u_int32_t *)src) - *((u_int32_t *)dst);
+    return *((uint32_t *)src) - *((uint32_t *)dst);
 }
 
 static bool freeall_iterator(hashnode_t *hnod, void *udata)
@@ -160,7 +162,7 @@ int shlocks_init(const char *path, int *locks, int many,
     int i, ret;
 
     if (path == NULL || *path == '\0' || locks == NULL || many < 1) {
-       DEBUG_PRINTF("shlocks_init", "Invalid arguments");
+       DEBUG_PRINTF("Invalid arguments");
        errno = EINVAL;
        return -1;
     }
@@ -173,21 +175,20 @@ int shlocks_init(const char *path, int *locks, int many,
            (void) sprintf(file, "%s.%02d", path, i);
            if ((locks[i] = open(file, O_CREAT | O_TRUNC | O_WRONLY, mode))
                    == -1) {
-               DEBUG_PRINTF("shlocks_init", "open(%s) - %s",
-                       file, strerror(errno));
+               DEBUG_PRINTF("open(%s) - %s", file, strerror(errno));
                goto err;
            }
            if (uid == my_uid)
                uid = -1;
            if (uid != -1 || gid != -1) {
                if (fchown(locks[i], uid, gid) == -1) {
-                   DEBUG_PRINTF("shlocks_init", "chown(%s, %d, %d) - %s",
+                   DEBUG_PRINTF("chown(%s, %d, %d) - %s",
                            file, uid, gid, strerror(errno));
                    goto err;
                }
                /* Since mode parameter may depend on umask */
                if (fchmod(locks[i], mode) == -1) {
-                   DEBUG_PRINTF("shlocks_init", "chmod(%s, 0%03o) - %s",
+                   DEBUG_PRINTF("chmod(%s, 0%03o) - %s",
                            file, mode, strerror(errno));
                    goto err;
                }
@@ -196,7 +197,7 @@ int shlocks_init(const char *path, int *locks, int many,
            if (ret == 0)
                (void) flock(locks[i], LOCK_UN);
            else {
-               DEBUG_PRINTF("shlocks_init", "flock(%s) - %s",
+               DEBUG_PRINTF("flock(%s) - %s",
                        file, strerror(errno));
                goto err;
            }
@@ -228,7 +229,7 @@ int shlocks_reopen(const char *path, int *locks, int many)
     int i, cnt;
 
     if (path == NULL || *path == '\0' || locks == NULL || many < 1) {
-       DEBUG_PRINTF("shlocks_reopen", "Invalid arguments");
+       DEBUG_PRINTF("Invalid arguments");
        errno = EINVAL;
        return -1;
     }
@@ -241,7 +242,7 @@ int shlocks_reopen(const char *path, int *locks, int many)
        }
     }
     if (cnt != many) {
-       DEBUG_PRINTF("shlocks_reopen", "Supplied invalid locks array");
+       DEBUG_PRINTF("Supplied invalid locks array");
        errno = EINVAL;
        return -1;
     }
@@ -250,8 +251,7 @@ int shlocks_reopen(const char *path, int *locks, int many)
        for (i = 0; i < many; i++) {
            (void) sprintf(file, "%s.%02d", path, i);
            if ((locks[i] = open(file, O_RDONLY)) == -1) {
-               DEBUG_PRINTF("shlocks_reopen", "open(%s) - %s",
-                       file, strerror(errno));
+               DEBUG_PRINTF("open(%s) - %s", file, strerror(errno));
                goto err;
            }
        }
@@ -281,7 +281,7 @@ int shlocks_destroy(const char *path, int *locks, int many, bool delete)
     char *file;
 
     if (path == NULL || *path == '\0' || locks == NULL || many < 1) {
-       DEBUG_PRINTF("shlocks_destroy", "Invalid arguments");
+       DEBUG_PRINTF("Invalid arguments");
        errno = EINVAL;
        return -1;
     }
@@ -336,7 +336,7 @@ void *shmem_malloc(size_t size)
     rsize = BALIGN_CEIL(sizeof(struct memhdr) + size, pagesize);
     if ((mem = mmap(NULL, rsize, PROT_READ | PROT_WRITE,
                    MAP_ANON | MAP_SHARED, -1, 0)) == MAP_FAILED) {
-       DEBUG_PRINTF("shmem_malloc", "mmap(%d)", (int)rsize);
+       DEBUG_PRINTF("mmap(%d)", (int)rsize);
        mem = NULL;
     } else {
        struct memhdr *hdr, *rhdr;
@@ -346,7 +346,7 @@ void *shmem_malloc(size_t size)
        rhdr->size = rsize;
        if (!hashtable_link(&shmem_table, (hashnode_t *)rhdr, &rhdr->addr,
                sizeof(void *), TRUE)) {
-           DEBUG_PRINTF("shmem_malloc", "hashtable_link()");
+           DEBUG_PRINTF("hashtable_link()");
            munmap(rhdr, rsize);
            mem = NULL;
        }
@@ -372,12 +372,9 @@ void shmem_free(void *mem)
                        sizeof(void *))) != NULL) {
            hashtable_unlink(&shmem_table, (hashnode_t *)hdr);
            if ((munmap(hdr, hdr->size)) == -1)
-               DEBUG_PRINTF("shmem_free", "munmap(%p, %d)",
-                       hdr, (int)hdr->size);
+               DEBUG_PRINTF("munmap(%p, %d)", hdr, (int)hdr->size);
        } else
-           DEBUG_PRINTF("shmem_free",
-                   "%p not allocated using shmem_malloc()!",
-                   mem);
+           DEBUG_PRINTF("%p not allocated using shmem_malloc()!", mem);
     }
 }
 
@@ -395,8 +392,7 @@ bool shmem_getregion(void **raddr, size_t *rsize, void *mem)
        *rsize = hdr->size;
        return TRUE;
     } else
-       DEBUG_PRINTF("shmem_getregion",
-               "%p not allocated using shmem_malloc()!", mem);
+       DEBUG_PRINTF("%p not allocated using shmem_malloc()!", mem);
     return FALSE;
 }
 
@@ -430,8 +426,7 @@ void *shmem_realloc(void *mem, size_t size)
                } else
                    return mem;
            } else {
-               DEBUG_PRINTF("shmem_realloc",
-                       "%p not allocated using shmem_malloc()!", mem);
+               DEBUG_PRINTF("%p not allocated using shmem_malloc()!", mem);
                return NULL;
            }
        } else {
@@ -477,7 +472,7 @@ void *secure_malloc(size_t size)
     rsize = BALIGN_CEIL(sizeof(struct memhdr) + size, pagesize);
     if ((mem = mmap(NULL, rsize, PROT_READ | PROT_WRITE, MAP_ANON, -1, 0))
            == MAP_FAILED) {
-       DEBUG_PRINTF("secure_malloc", "mmap(%d)", (int)rsize);
+       DEBUG_PRINTF("mmap(%d)", (int)rsize);
        mem = NULL;
     } else {
        /* We lock down the pages in physical memory so that cryptographic
@@ -486,10 +481,9 @@ void *secure_malloc(size_t size)
         */
        if (mlock(mem, rsize) != 0) {
            /* This important step failed, return an error. */
-           DEBUG_PRINTF("secure_malloc", "mlock(%p, %d)", mem, (int)rsize);
+           DEBUG_PRINTF("mlock(%p, %d)", mem, (int)rsize);
            if (munmap(mem, rsize) == -1)
-               DEBUG_PRINTF("secure_malloc",
-                       "munmap(%p, %d)", mem, (int)rsize);
+               DEBUG_PRINTF("munmap(%p, %d)", mem, (int)rsize);
            mem = NULL;
        } else {
            struct memhdr *hdr, *rhdr;
@@ -499,7 +493,7 @@ void *secure_malloc(size_t size)
            rhdr->size = rsize;
            if (!hashtable_link(&secure_table, (hashnode_t *)rhdr, &rhdr->addr,
                        sizeof(void *), TRUE)) {
-               DEBUG_PRINTF("secure_malloc", "hashtable_link()");
+               DEBUG_PRINTF("hashtable_link()");
                munlock(rhdr, rsize);
                munmap(rhdr, rsize);
                mem = NULL;
@@ -534,14 +528,11 @@ void secure_free(void *mem)
             */
            mm_memclr(mem, rsize);
            if ((munlock(hdr, hdr->size)) != 0)
-               DEBUG_PRINTF("secure_free",
-                       "munlock(%p, %d)", hdr, (int)hdr->size);
+               DEBUG_PRINTF("munlock(%p, %d)", hdr, (int)hdr->size);
            if ((munmap(hdr, hdr->size)) == -1)
-               DEBUG_PRINTF("secure_free",
-                       "munmap(%p, %d)", hdr, (int)hdr->size);
+               DEBUG_PRINTF("munmap(%p, %d)", hdr, (int)hdr->size);
        } else
-           DEBUG_PRINTF("secure_free",
-                   "%p not allocated using secure_malloc()!", mem);
+           DEBUG_PRINTF("%p not allocated using secure_malloc()!", mem);
     }
 }
 
@@ -580,8 +571,7 @@ void *secure_realloc(void *mem, size_t size)
                    return mem;
                }
            } else {
-               DEBUG_PRINTF("secure_realloc",
-                       "%p not allocated using secure_malloc()!", mem);
+               DEBUG_PRINTF("%p not allocated using secure_malloc()!", mem);
                return NULL;
            }
        } else {
index 12613a4..2088465 100644 (file)
@@ -1,4 +1,4 @@
-.\" $Id: mmlifo.3,v 1.6 2004/05/05 23:59:56 mmondor Exp $
+.\" $Id: mmlifo.3,v 1.7 2007/12/05 23:47:56 mmondor Exp $
 .\"
 .\" Copyright (C) 2000-2004, Matthew Mondor
 .\" All rights reserved.
 .Ft void
 .Fn LIFO_DEFINE "lifotype_t" "objecttype"
 .Ft void
-.Fn LIFO_INIT "lifotype_t *lifo" "void *buffer" "u_int32_t size"
+.Fn LIFO_INIT "lifotype_t *lifo" "void *buffer" "uint32_t size"
 .Ft bool
 .Fn LIFO_FULL "lifotype_t *lifo"
 .Ft bool
 .Fn LIFO_EMPTY "lifotype_t *lifo"
-.Ft u_int32_t
+.Ft uint32_t
 .Fn LIFO_STAT "lifotype_t *lifo"
-.Ft u_int32_t
+.Ft uint32_t
 .Fn LIFO_AVAIL "lifotype_t *lifo"
 .Ft void
 .Fn LIFO_FLUSH "lifotype_t *lifo"
 .Ft void
 .Fn LIFO_FIND "lifotype_t *lifo" "objecttype **pointer" "objecttype *element"
 .Ft void
-.Fn LIFO_ALLOC "lifotype_t *lifo" "objecttype **pointer" "u_int32_t *actual" \
-"u_int32_t size"
+.Fn LIFO_ALLOC "lifotype_t *lifo" "objecttype **pointer" "uint32_t *actual" \
+"uint32_t size"
 .Ft void
-.Fn LIFO_FREE "lifotype_t *lifo" "objecttype **pointer" "u_int32_t *actual" \
-"u_int32_t size"
+.Fn LIFO_FREE "lifotype_t *lifo" "objecttype **pointer" "uint32_t *actual" \
+"uint32_t size"
 .Sh DESCRIPTION
 LIFO buffers (Last In First Out) are usually useful to implement stacks
 when the processor stack is not desired to use, for temporary storage, or to
@@ -110,13 +110,13 @@ Predefined LIFO buffer types are
 and
 .Nm lifo64_t ,
 to hold objects of type
-.Nm u_int8_t ,
-.Nm u_int16_t ,
-.Nm u_int32_t
+.Nm uint8_t ,
+.Nm uint16_t ,
+.Nm uint32_t
 and
-.Nm u_int64_t ,
+.Nm uint64_t ,
 respectively.
-.It void Fn LIFO_INIT "lifotype_t *lifo" "void *buffer" "u_int32_t size"
+.It void Fn LIFO_INIT "lifotype_t *lifo" "void *buffer" "uint32_t size"
 allows to initialize a LIFO buffer.
 .Fa lifo
 consists of a pointer to the LIFO buffer to initialize,
@@ -145,12 +145,12 @@ should be used first.
 returns true if the supplied
 .Ft lifo
 buffer currently holds no elements.
-.It u_int32_t Fn LIFO_STAT "lifotype_t *lifo"
+.It uint32_t Fn LIFO_STAT "lifotype_t *lifo"
 permits to know how many elements are currently buffered into the specified
 .Fa lifo
 buffer, and which can be read using
 .Fn LIFO_GET .
-.It u_int32_t Fn LIFO_AVAIL "lifotype_t *lifo"
+.It uint32_t Fn LIFO_AVAIL "lifotype_t *lifo"
 tells the number of additional entries which the supplied buffer can hold.
 .It void Fn LIFO_FLUSH "lifotype_t *lifo"
 allows to get rid of all the current contents, if any, of the specified
index 2096708..58652e5 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmlifo.h,v 1.5 2004/06/04 19:13:24 mmondor Exp $ */
+/* $Id: mmlifo.h,v 1.6 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
 
 
 
+#include <stdbool.h>
+#include <stdint.h>
+
 #include <mmtypes.h>
 
 
 
 /* LIFO_DEFINE(lifotypename, objecttype); */
 #define LIFO_DEFINE(n, o)      typedef struct n {                      \
-    u_int32_t size, elements;                                          \
+    uint32_t size, elements;                                           \
     o *buffer, *endbuffer, *head;                                      \
 } n
 
 /* Because of the way this is implemented using macros, it would also be
  * possible to provide lifo types to hold structures.
  */
-LIFO_DEFINE(lifo8_t, u_int8_t);
-LIFO_DEFINE(lifo16_t, u_int16_t);
-LIFO_DEFINE(lifo32_t, u_int32_t);
-LIFO_DEFINE(lifo64_t, u_int64_t);
+LIFO_DEFINE(lifo8_t, uint8_t);
+LIFO_DEFINE(lifo16_t, uint16_t);
+LIFO_DEFINE(lifo32_t, uint32_t);
+LIFO_DEFINE(lifo64_t, uint64_t);
 
 
 
 /* XXX Although it's great to use macros for these operations, it also
  * prevents assembly functions to be provided to replace them.
  */
-/* void LIFO_INIT(lifo*_t *, u_int*_t *, u_int32_t); */
+/* void LIFO_INIT(lifo*_t *, uint*_t *, uint32_t); */
 #define LIFO_INIT(f, b, s)     do {                                    \
     (f)->size = (s);                                                   \
     (f)->elements = 0;                                                 \
@@ -73,7 +76,7 @@ LIFO_DEFINE(lifo64_t, u_int64_t);
 /* bool LIFO_FULL(lifo*_t *); */
 #define LIFO_FULL(f)   ((f)->elements == (f)->size)
 
-/* u_int32_t LIFO_STAT(lifo*_t *); */
+/* uint32_t LIFO_STAT(lifo*_t *); */
 #define LIFO_STAT(f)   ((f)->elements)
 
 /* void LIFO_FLUSH(lifo*_t *); */
@@ -82,7 +85,7 @@ LIFO_DEFINE(lifo64_t, u_int64_t);
     (f)->elements = 0;                                                 \
 } while (/* CONSTCOND */0)
 
-/* void LIFO_PUT(lifo*_t *, u_int*_t *); */
+/* void LIFO_PUT(lifo*_t *, uint*_t *); */
 #define LIFO_PUT(s, e) do {                                            \
     if ((s)->elements < (s)->size) {                                   \
        *((s)->head++) = *(e);                                          \
@@ -90,7 +93,7 @@ LIFO_DEFINE(lifo64_t, u_int64_t);
     }                                                                  \
 } while (/* CONSTCOND */0)
 
-/* void LIFO_GET(lifo*_t *, u_int*_t *); */
+/* void LIFO_GET(lifo*_t *, uint*_t *); */
 #define LIFO_GET(s, e) do {                                            \
     if ((s)->elements > 0) {                                           \
        *(e) = *(--(s)->head);                                          \
@@ -98,9 +101,9 @@ LIFO_DEFINE(lifo64_t, u_int64_t);
     }                                                                  \
 } while (/* CONSTCOND */0)
 
-/* LIFO_ALLOC(lifo*_t *, u_int*_t **, size_t *); */
+/* LIFO_ALLOC(lifo*_t *, uint*_t **, size_t *); */
 
-/* LIFO_FREE(lifo*_t, u_int*_t **, size_t *); */
+/* LIFO_FREE(lifo*_t, uint*_t **, size_t *); */
 
 
 
index b483321..9f226f1 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmlimitrate.c,v 1.4 2004/03/22 06:59:35 mmondor Exp $ */
+/* $Id: mmlimitrate.c,v 1.5 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
@@ -35,7 +35,7 @@
 
 
 
-#include <sys/types.h>
+#include <stdbool.h>
 #include <time.h>
 
 #include <mmtypes.h>
@@ -45,7 +45,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmlimitrate.c,v 1.4 2004/03/22 06:59:35 mmondor Exp $");
+MMRCSID("$Id: mmlimitrate.c,v 1.5 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
index 274737b..1b5068d 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmlimitrate.h,v 1.7 2004/06/04 19:20:32 mmondor Exp $ */
+/* $Id: mmlimitrate.h,v 1.8 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
@@ -40,7 +40,7 @@
 
 
 
-#include <sys/types.h>
+#include <stdbool.h>
 
 #include <mmtypes.h>
 
index eb0073f..4b0f7ee 100644 (file)
@@ -1,4 +1,4 @@
-.\" $Id: mmlist.3,v 1.12 2004/05/05 23:59:56 mmondor Exp $
+.\" $Id: mmlist.3,v 1.13 2007/12/05 23:47:56 mmondor Exp $
 .\"
 .\" Copyright (C) 2001-2004, Matthew Mondor
 .\" All rights reserved.
@@ -53,7 +53,7 @@
 .Fn DLIST_SWAP "list_t *dest" "list_t *source" "node_t *node" "bool insert"
 .Ft void
 .Fn DLIST_UNLINK "list_t *list" "node_t *node"
-.Ft u_int32_t
+.Ft uint32_t
 .Fn DLIST_NODES "list_t *list"
 .Ft node_t *
 .Fn DLIST_TOP "list_t *list"
@@ -83,7 +83,7 @@ struct node {
 
 struct list {
     node_t *top, *bottom;
-    u_int32_t nodes;
+    uint32_t nodes;
 };
 .Ed
 .Pp
@@ -141,7 +141,7 @@ unlinks node
 .Fa node
 from
 .Fa list .
-.It u_int32_t Fn DLIST_NODES "list_t *list"
+.It uint32_t Fn DLIST_NODES "list_t *list"
 returns the number of currently linked nodes into the
 .Fa list
 list_t.
index ce464fd..9582433 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmlist.h,v 1.11 2004/06/04 19:13:24 mmondor Exp $ */
+/* $Id: mmlist.h,v 1.12 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2001-2004, Matthew Mondor
+ * Copyright (C) 2001, 2004, 2007, Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -40,7 +40,7 @@
 
 
 
-#include <sys/types.h>
+#include <stdint.h>
 #include <mmtypes.h>
 
 
@@ -51,117 +51,117 @@ typedef struct node       node_t;
 
 
 struct node {
-    node_t *prev, *next;
+       node_t          *prev, *next;
 };
 
 struct list {
-    node_t *top, *bottom;
-    u_int32_t nodes;
+       node_t          *top, *bottom;
+       uint32_t        nodes;
 };
 
 
 
 /* Some macros to optimize operations on doubly linked lists */
-#define DLIST_INITIALIZER      {NULL, NULL, 0}
+#define DLIST_INITIALIZER      { NULL, NULL, 0 }
 
 #define DLIST_INIT(lst)                do {                                    \
-    (lst)->top = (lst)->bottom = NULL;                                 \
-    (lst)->nodes = 0;                                                  \
+       (lst)->top = (lst)->bottom = NULL;                              \
+       (lst)->nodes = 0;                                               \
 } while (/* CONSTCOND */0)
 
 #define DLIST_UNLINK(lst, nod) do {                                    \
-    register node_t *prev = (nod)->prev, *next = (nod)->next;          \
+       register node_t *prev = (nod)->prev, *next = (nod)->next;       \
                                                                        \
-    if (prev != NULL)                                                  \
-       prev->next = next;                                              \
-    else                                                               \
-       (lst)->top = next;                                              \
-    if (next != NULL)                                                  \
-       next->prev = prev;                                              \
-    else                                                               \
-       (lst)->bottom = prev;                                           \
-    (lst)->nodes--;                                                    \
+       if (prev != NULL)                                               \
+               prev->next = next;                                      \
+       else                                                            \
+               (lst)->top = next;                                      \
+       if (next != NULL)                                               \
+               next->prev = prev;                                      \
+       else                                                            \
+               (lst)->bottom = prev;                                   \
+       (lst)->nodes--;                                                 \
 } while (/* CONSTCOND */0)
 
 #define DLIST_APPEND(lst, nod) do {                                    \
-    register node_t *tmp = (lst)->bottom;                              \
+       register node_t *tmp = (lst)->bottom;                           \
                                                                        \
-    if (tmp != NULL) {                                                 \
-       tmp->next = (nod);                                              \
-       (nod)->prev = tmp;                                              \
-       (nod)->next = NULL;                                             \
-       (lst)->bottom = (nod);                                          \
-    } else {                                                           \
-       (lst)->bottom = (lst)->top = (nod);                             \
-       (nod)->next = (nod)->prev = NULL;                               \
-    }                                                                  \
-    (lst)->nodes++;                                                    \
+       if (tmp != NULL) {                                              \
+               tmp->next = (nod);                                      \
+               (nod)->prev = tmp;                                      \
+               (nod)->next = NULL;                                     \
+               (lst)->bottom = (nod);                                  \
+       } else {                                                        \
+               (lst)->bottom = (lst)->top = (nod);                     \
+               (nod)->next = (nod)->prev = NULL;                       \
+       }                                                               \
+       (lst)->nodes++;                                                 \
 } while (/* CONSTCOND */0)
 
 #define DLIST_INSERT(lst, nod) do {                                    \
-    register node_t *tmp = (lst)->top;                                 \
+       register node_t *tmp = (lst)->top;                              \
                                                                        \
-    if (tmp != NULL) {                                                 \
-       tmp->prev = (nod);                                              \
-       (nod)->prev = NULL;                                             \
-       (nod)->next = tmp;                                              \
-       (lst)->top = (nod);                                             \
-    } else {                                                           \
-       (lst)->top = (lst)->bottom = (nod);                             \
-       (nod)->next = (nod)->prev = NULL;                               \
-    }                                                                  \
-    (lst)->nodes++;                                                    \
+       if (tmp != NULL) {                                              \
+               tmp->prev = (nod);                                      \
+               (nod)->prev = NULL;                                     \
+               (nod)->next = tmp;                                      \
+               (lst)->top = (nod);                                     \
+       } else {                                                        \
+               (lst)->top = (lst)->bottom = (nod);                     \
+               (nod)->next = (nod)->prev = NULL;                       \
+       }                                                               \
+       (lst)->nodes++;                                                 \
 } while (/* CONSTCOND */0)
 
 #define DLIST_INSERTAT(lst, atnode, nod) do {                          \
-    register node_t *prev = (atnode)->prev, *next = (atnode);          \
+       register node_t *prev = (atnode)->prev, *next = (atnode);       \
                                                                        \
-    (nod)->next = next;                                                        \
-    next->prev = (nod);                                                        \
-    if (prev != NULL) {                                                        \
-       prev->next = (nod);                                             \
-       (nod)->prev = prev;                                             \
-    } else {                                                           \
-       (lst)->top = (nod);                                             \
-       (nod)->prev = NULL;                                             \
-    }                                                                  \
-    (lst)->nodes++;                                                    \
+       (nod)->next = next;                                             \
+       next->prev = (nod);                                             \
+       if (prev != NULL) {                                             \
+               prev->next = (nod);                                     \
+               (nod)->prev = prev;                                     \
+       } else {                                                        \
+               (lst)->top = (nod);                                     \
+               (nod)->prev = NULL;                                     \
+       }                                                               \
+       (lst)->nodes++;                                                 \
 } while (/* CONSTCOND */0)
 
 #define DLIST_SWAP(dst, src, nod, ins) do {                            \
     register node_t *prev = (nod)->prev, *next = (nod)->next;          \
                                                                        \
-    if (prev != NULL)                                                  \
-       prev->next = next;                                              \
-    else                                                               \
-       (src)->top = next;                                              \
-    if (next != NULL)                                                  \
-       next->prev = prev;                                              \
-    else                                                               \
-       (src)->bottom = prev;                                           \
-    (src)->nodes--;                                                    \
-    if ((ins)) {                                                       \
-       if ((prev = (dst)->top) != NULL) {                              \
-           prev->prev = (nod);                                         \
-           (nod)->prev = NULL;                                         \
-           (nod)->next = prev;                                         \
-           (dst)->top = (nod);                                         \
-       } else {                                                        \
-           (dst)->top = (dst)->bottom = (nod);                         \
-           (nod)->next = (nod)->prev = NULL;                           \
-       }                                                               \
-    } else {                                                           \
-       if ((prev = (dst)->bottom) != NULL) {                           \
-           prev->next = (nod);                                         \
-           (nod)->prev = prev;                                         \
-           (nod)->next = NULL;                                         \
-           (dst)->bottom = (nod);                                      \
+       if (prev != NULL)                                               \
+               prev->next = next;                                      \
+       else                                                            \
+               (src)->top = next;                                      \
+       if (next != NULL)                                               \
+               next->prev = prev;                                      \
+       else                                                            \
+               (src)->bottom = prev;                                   \
+       (src)->nodes--;                                                 \
+       if ((ins)) {                                                    \
+               if ((prev = (dst)->top) != NULL) {                      \
+                       prev->prev = (nod);                             \
+                       (nod)->prev = NULL;                             \
+                       (nod)->next = prev;                             \
+                       (dst)->top = (nod);                             \
+               } else {                                                \
+                       (dst)->top = (dst)->bottom = (nod);             \
+                       (nod)->next = (nod)->prev = NULL;               \
+               }                                                       \
        } else {                                                        \
-           (dst)->bottom = (dst)->top = (nod);                         \
-           (nod)->next = (nod)->prev = NULL;                           \
+               if ((prev = (dst)->bottom) != NULL) {                   \
+                       prev->next = (nod);                             \
+                       (nod)->prev = prev;                             \
+                       (nod)->next = NULL;                             \
+                       (dst)->bottom = (nod);                          \
+               } else {                                                \
+                       (dst)->bottom = (dst)->top = (nod);             \
+                       (nod)->next = (nod)->prev = NULL;               \
+               }                                                       \
        }                                                               \
-    }                                                                  \
-    (dst)->nodes++;                                                    \
+       (dst)->nodes++;                                                 \
 } while (/* CONSTCOND */0)
 
 #define DLIST_TOP(lst)         ((void *)((list_t *)(lst))->top)
index 1cf2ebe..f2c16ae 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmlog.c,v 1.6 2005/09/21 10:33:59 mmondor Exp $ */
+/* $Id: mmlog.c,v 1.7 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -34,9 +34,6 @@
  */
 
 
-
-
-#include <sys/types.h>
 #include <syslog.h>
 #include <stdio.h>
 #include <stdlib.h>
 #include <mmlog.h>
 
 
-
-
 MMCOPYRIGHT("@(#) Copyright (c) 2000-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmlog.c,v 1.6 2005/09/21 10:33:59 mmondor Exp $");
+MMRCSID("$Id: mmlog.c,v 1.7 2007/12/05 23:47:56 mmondor Exp $");
 
 
-    
-    
 void
 mmsyslog(int level, int loglevel, const char *fmt, ...)
 {
-    va_list lst;
-    char buf[1024];
-
-    if (!level || level <= loglevel) {
-       va_start(lst, fmt);
-       vsnprintf(buf, 1023, fmt, lst);
-       va_end(lst);
-       syslog(LOG_NOTICE, "%s", buf);
-    }
+       va_list lst;
+       char    buf[1024];
+
+       if (level == 0 || level <= loglevel) {
+               va_start(lst, fmt);
+               (void) vsnprintf(buf, 1023, fmt, lst);
+               va_end(lst);
+               syslog(LOG_NOTICE, "%s", buf);
+       }
 }
 
 
@@ -74,26 +67,26 @@ mmsyslog(int level, int loglevel, const char *fmt, ...)
 void
 mmdebug(const char *file, const char *func, int line, const char *fmt, ...)
 {
-    va_list lst;
-    char buf[1024];
+       va_list lst;
+       char    buf[1024];
 
-    va_start(lst, fmt);
-    vsnprintf(buf, 1023, fmt, lst);
-    va_end(lst);
-    syslog(LOG_NOTICE, "%s:%s():%d - %s", file, func, line, buf);
+       va_start(lst, fmt);
+       (void) vsnprintf(buf, 1023, fmt, lst);
+       va_end(lst);
+       syslog(LOG_NOTICE, "%s:%s():%d - %s", file, func, line, buf);
 }
 
 void
 mmdebug2(const char *file, const char *func, int line, const char *fmt, ...)
 {
-    va_list lst;
-    char buf[1024];
+       va_list lst;
+       char    buf[1024];
 
-    va_start(lst, fmt);
-    vsnprintf(buf, 1023, fmt, lst);
-    va_end(lst);
-    syslog(LOG_NOTICE, "%s:%s():%d - %s", file, func, line, buf);
+       va_start(lst, fmt);
+       (void) vsnprintf(buf, 1023, fmt, lst);
+       va_end(lst);
+       syslog(LOG_NOTICE, "%s:%s():%d - %s", file, func, line, buf);
 
-    abort();
+       abort();
 }
 #endif
index 250359d..2e4e97b 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmlog.h,v 1.16 2005/09/21 10:33:59 mmondor Exp $ */
+/* $Id: mmlog.h,v 1.17 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2000-2004, Matthew Mondor
+ * Copyright (C) 2000, 2004, 2007, Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  */
 
 
-
-
 #ifndef MMLOG_H
 #define MMLOG_H
 
 
-
-
-#include <sys/types.h>
-
-#include <mmtypes.h>
-
-
-
-
-/* So that debugging messages can use DEBUG_PRINTF() and not be included when
- * we don't need them. Note: Use of __func__ seems specific to the latest
- * GCC releases, it is thus discouraged.
+/*
+ * So that debugging messages can use DEBUG_PRINTF() and not be included when
+ * we don't need them.
  */
 #ifdef DEBUG
 
 /* Allows to print a debugging message */
-#define DEBUG_PRINTF(f, s...)  mmdebug(__FILE__, f, __LINE__, s)
+#define DEBUG_PRINTF(s...)     mmdebug(__FILE__, __func__, __LINE__, s)
 
-/* Similar to assert, but won't exit the application, just evaluates to TRUE
+/*
+ * Similar to assert, but won't exit the application, just evaluates to TRUE
  * if condition is TRUE, or always to TRUE if debugging is disabled.
  * I.E. if (DEBUG_TRUE(condition)) ...
  */
 #define DEBUG_TRUE(c)          (c)
 
-/* Similar to DEBUG_TRUE(), but evaluates to TRUE if condition is TRUE, or
+/*
+ * Similar to DEBUG_TRUE(), but evaluates to TRUE if condition is TRUE, or
  * always to FALSE if debugging is disabled.
  * I.E. if (DEBUG_FALSE(condition)) ...
  */
 #define DEBUG_FALSE(c)         (c)
 
-/* Macro similar to assert(3) but which does not exit the application. Will
+/*
+ * Macro similar to assert(3) but which does not exit the application. Will
  * instead log the condition.
  */
 #ifdef DEBUG_ASSERT_ABORT
 #endif
 
 
-
-
 extern void    mmsyslog(int, int, const char *, ...);
 extern void    mmdebug(const char *, const char *, int, const char *, ...);
 
 
-
-
 #endif
index 7e75d9a..e242d6d 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmpath.c,v 1.19 2006/06/13 17:17:02 mmondor Exp $ */
+/* $Id: mmpath.c,v 1.20 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
 
 /* HEADERS */
 
-#include <sys/types.h>
 #include <sys/stat.h>
 #include <unistd.h>
 #include <ctype.h>
+#include <stdbool.h>
 #include <stdio.h>
 #include <syslog.h>
 #include <stdarg.h>
@@ -66,7 +66,7 @@ static bool path_ls2(fdbuf *, const char *, const char *, const char *,
 
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmpath.c,v 1.19 2006/06/13 17:17:02 mmondor Exp $");
+MMRCSID("$Id: mmpath.c,v 1.20 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
index da1683f..f0f42db 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmpath.h,v 1.8 2004/06/01 19:11:57 mmondor Exp $ */
+/* $Id: mmpath.h,v 1.9 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2004, Matthew Mondor
@@ -44,7 +44,7 @@
 
 /* HEADERS */
 
-#include <sys/types.h>
+#include <stdbool.h>
 
 #include <mmtypes.h>
 #include <mmfd.h>
index c56bc5f..58602f4 100644 (file)
@@ -1,4 +1,4 @@
-.\" $Id: mmpool.3,v 1.7 2004/05/22 17:43:59 mmondor Exp $
+.\" $Id: mmpool.3,v 1.8 2007/12/05 23:47:56 mmondor Exp $
 .\"
 .\" Copyright (C) 2001-2004, Matthew Mondor
 .\" All rights reserved.
@@ -46,7 +46,7 @@
 .Fa "pool_t *pool" "const char *label" "void *(*malloc)(void)"
 .Fa "void (*free)(void *)" "bool (*create)(pnode_t *)"
 .Fa "void (*destroy)(pnode_t *)" "size_t nodesize"
-.Fa "u_int32_t nodesperpage" "u_int32_t minpages" "u_int32_t maxpages"
+.Fa "uint32_t nodesperpage" "uint32_t minpages" "uint32_t maxpages"
 .Fc
 .Ft bool
 .Fn pool_destroy "pool_t *pool"
@@ -114,9 +114,9 @@ struct myobject {
 .Fa "bool (*create)(pnode_t *)"
 .Fa "void (*destroy)(pnode_t *)"
 .Fa "size_t nodesize"
-.Fa "u_int32_t nodesperpage"
-.Fa "u_int32_t minpages"
-.Fa "u_int32_t maxpages"
+.Fa "uint32_t nodesperpage"
+.Fa "uint32_t minpages"
+.Fa "uint32_t maxpages"
 .Fc
 .Xc
 is necessary to use before a
index 5b1d22d..ef41808 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmpool.c,v 1.29 2004/09/22 06:23:54 mmondor Exp $ */
+/* $Id: mmpool.c,v 1.30 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2001-2004, Matthew Mondor
+ * Copyright (C) 2001, 2004, 2007, Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
+/*
+ * TODO:
+ * - The usage average statistics should be based on time rather than on a
+ *   number of recent operations.  A function should probably be provided for
+ *   user code to call at regular intervals.
+ */
 
 
-#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
+#include <string.h>
 #include <syslog.h>
 
 #include <mmtypes.h>
-#include <mmstring.h>
 #include <mmlist.h>
 #include <mmpool.h>
 #include <mmlog.h>
 
 
-
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmpool.c,v 1.29 2004/09/22 06:23:54 mmondor Exp $");
-
+MMRCSID("$Id: mmpool.c,v 1.30 2007/12/05 23:47:56 mmondor Exp $");
 
 
 /* DEFINITIONS */
@@ -65,118 +70,126 @@ MMRCSID("$Id: mmpool.c,v 1.29 2004/09/22 06:23:54 mmondor Exp $");
 #endif
 
 
-
 /* STATIC FUNCTION PROTOTYPES */
 
-static bpage_t *       pool_page_create(const char *, pool_t *);
-static bpage_t *       pool_page_destroy(bpage_t *);
-
+static bpage_t         *pool_page_create(const char *, pool_t *);
+static bpage_t         *pool_page_destroy(bpage_t *);
 
 
 /* STATIC FUNCTIONS */
 
-/* Creates a new page of objects, and calls the constructor function for each
- * object of the new page if needed. Returns NULL on failure, or the new
+/*
+ * Creates a new page of objects, and calls the constructor function for each
+ * object of the new page if needed.  Returns NULL on failure, or the new
  * bpage_t pointer on success.
  */
 static bpage_t *
 pool_page_create(const char *func, pool_t *pool)
 {
-    register size_t    nodesize = pool->nodesize;
-    register u_int8_t  *ptr, *toptr;
-    register bpage_t   *page;
-    register list_t    *list;
-
-    if ((page = pool->malloc(pool->pagesize)) == NULL) {
-       syslog(LOG_NOTICE,
-               "%s - Out of memory allocating page for pool_t (%s)",
-               func, pool->label);
-       return NULL;
-    }
-
-    /* Initialize bpage_t */
-    page->magic = MAGIC_PAGE;
-    page->pool = pool;
-    DLIST_INIT(&page->objects);
-
-    /* Create all objects of that bpage_t, inserting them into it's list_t.
-     * If any object creation fails (it's optional construtor function can
-     * fail), destroy the page and return NULL.
-     */
-    if (pool->create != NULL) {
-       for (ptr = toptr = (u_int8_t *)page, ptr += BPAGE_SIZE,
-               toptr += pool->pagesize, list = &page->objects;
-               ptr + nodesize < toptr; ptr += nodesize) {
-           ((pnode_t *)ptr)->magic = 0;
-           ((pnode_t *)ptr)->page = page;
-           if (!pool->create((pnode_t *)ptr)) {
-               syslog(LOG_NOTICE, "%s - Page object constructor function "
-                       "returned error for pool_t (%s)",
-                       func, pool->label);
-               return pool_page_destroy(page);
-           }
-           DLIST_APPEND(list, (node_t *)ptr);
+       register size_t         nodesize = pool->nodesize;
+       register uint8_t        *ptr, *toptr;
+       register bpage_t        *page;
+       register list_t         *list;
+
+       if ((page = pool->malloc(pool->pagesize)) == NULL) {
+               syslog(LOG_NOTICE,
+                   "%s - Out of memory allocating page for pool_t (%s)",
+                   func, pool->label);
+               return NULL;
        }
-    } else {
-       for (ptr = toptr = (u_int8_t *)page, ptr += BPAGE_SIZE,
-               toptr += pool->pagesize, list = &page->objects;
-               ptr + nodesize < toptr; ptr += nodesize) {
-           ((pnode_t *)ptr)->magic = 0;
-           ((pnode_t *)ptr)->page = page;
-           DLIST_APPEND(list, (node_t *)ptr);
+
+       /* Initialize bpage_t */
+       page->magic = MAGIC_PAGE;
+       page->pool = pool;
+       DLIST_INIT(&page->objects);
+
+       /*
+        * Create all objects of that bpage_t, inserting them into its list_t.
+        * If any object creation fails (its optional construtor function can
+        * fail), destroy the page and return NULL.
+        */
+       if (pool->create != NULL) {
+               for (ptr = toptr = (uint8_t *)page, ptr += BPAGE_SIZE,
+                   toptr += pool->pagesize, list = &page->objects;
+                   ptr + nodesize < toptr; ptr += nodesize) {
+                       ((pnode_t *)ptr)->magic = 0;
+                       ((pnode_t *)ptr)->page = page;
+                       if (!pool->create((pnode_t *)ptr)) {
+                               syslog(LOG_NOTICE,
+                                   "%s - Page object constructor function "
+                                   "returned error for pool_t (%s)",
+                                   func, pool->label);
+                               return pool_page_destroy(page);
+                       }
+                       DLIST_APPEND(list, (node_t *)ptr);
+               }
+       } else {
+               for (ptr = toptr = (uint8_t *)page, ptr += BPAGE_SIZE,
+                   toptr += pool->pagesize, list = &page->objects;
+                   ptr + nodesize < toptr; ptr += nodesize) {
+                       ((pnode_t *)ptr)->magic = 0;
+                       ((pnode_t *)ptr)->page = page;
+                       DLIST_APPEND(list, (node_t *)ptr);
+               }
        }
-    }
 
-    return page;
+       return page;
 }
 
-/* Destroys a page previously created using pool_page_create(), calling the
- * destructor function for each object of the page if necessary. Returns NULL.
+/*
+ * Destroys a page previously created using pool_page_create(), calling the
+ * destructor function for each object of the page if necessary.
+ * Returns NULL.
  */
 static bpage_t *
 pool_page_destroy(bpage_t *page)
 {
-    register pnode_t   *pnode;
-    register void      (*destroy)(pnode_t *);
+       register pnode_t        *pnode;
+       register void           (*destroy)(pnode_t *);
 
-    if ((destroy = (page->pool->destroy)) != NULL) {
-       /* We need to destroy all objects */
-       DLIST_FOREACH(&page->objects, pnode)
-           destroy(pnode);
-    }
+       if ((destroy = (page->pool->destroy)) != NULL) {
+               /* We need to destroy all objects */
+               DLIST_FOREACH(&page->objects, pnode)
+                       destroy(pnode);
+       }
 
-    page->pool->free(page);
+       page->pool->free(page);
 
-    return NULL;
+       return NULL;
 }
 
 
-
 /* PUBLIC FUNCTIONS */
 
-/* Initializes a memory pool for efficient management of fixed sized nodes.
- * returns TRUE on success or FALSE on failure.
+/*
+ * Initializes a memory pool for efficient management of fixed sized nodes.
+ * returns true on success or false on failure.
  */
 bool
 pool_init(pool_t *pool, const char *label, void *(*mallocfunc)(size_t),
-       void (*freefunc)(void *), bool (*create)(pnode_t *),
-       void (*destroy)(pnode_t *), size_t nodesize, u_int32_t nodesperpage,
-       u_int32_t minpages, u_int32_t maxpages)
+    void (*freefunc)(void *), bool (*create)(pnode_t *),
+    void (*destroy)(pnode_t *), size_t nodesize, uint32_t nodesperpage,
+    uint32_t minpages, uint32_t maxpages)
 {
-    bool       ok = FALSE;
+       bool            ok = false;
+       register size_t ns, ps;
 
-    if (DEBUG_FALSE(POOL_VALID(pool))) {
-       DEBUG_PRINTF("pool_init", "Pool already initialized (%p = %s)",
-               pool, pool->label);
-       return FALSE;
-    }
+       if (DEBUG_FALSE(POOL_VALID(pool))) {
+               DEBUG_PRINTF("Pool already initialized (%p = %s)",
+                   pool, pool->label);
+               return false;
+       }
 
-    if (DEBUG_TRUE(pool != NULL && mallocfunc != NULL && freefunc != NULL &&
-               ((create != NULL && destroy != NULL) ||
-                (void *)create == (void *)destroy) &&
-               nodesize != 0 && nodesperpage > 0)) {
-       register size_t ns = (size_t)OALIGN_CEIL(nodesize, long);
-       register size_t ps = (BPAGE_SIZE + ((nodesperpage + 1) * ns));
+       if (DEBUG_FALSE(pool == NULL || mallocfunc == NULL ||
+           freefunc == NULL || ((create == NULL || destroy == NULL) &&
+           (void *)create != (void *)destroy) || nodesize == 0 ||
+           nodesperpage == 0)) {
+               DEBUG_PRINTF("Invalid parameters");
+               return false;
+       }
+
+       ns = (size_t)OALIGN_CEIL(nodesize, long);
+       ps = (BPAGE_SIZE + ((nodesperpage + 1) * ns));
 
        pool->magic = 0;
        pool->label = label;
@@ -194,182 +207,181 @@ pool_init(pool_t *pool, const char *label, void *(*mallocfunc)(size_t),
        DLIST_INIT(&pool->fpages);
        DLIST_INIT(&pool->epages);
 
-       /* Allocate minimum number of pages, if needed. We insert them into
+       /*
+        * Allocate minimum number of pages, if needed.  We insert them into
         * the empty pages list, but minpages will be honored as such to
         * never free pages below it.
         */
        for (; minpages > 0; minpages--) {
-           register bpage_t    *p;
+               register bpage_t        *p;
 
-           if ((p = pool_page_create("pool_init", pool)) == NULL)
-               break;
-           DLIST_APPEND(&pool->epages, (node_t *)p);
+               if ((p = pool_page_create("pool_init", pool)) == NULL)
+                       break;
+               DLIST_APPEND(&pool->epages, (node_t *)p);
        }
 
        /* Validate this pool */
        pool->magic = MAGIC_POOL;
 
-       /* Have we failed to allocate any needed pages? If so, destroy pool
-        * and return FALSE.
+       /*
+        * Have we failed to allocate any needed pages?  If so, destroy pool
+        * and return false.
         */
        if (minpages == 0)
-           ok = TRUE;
+               ok = true;
        else if (minpages < pool->minpages)
-           (void) pool_destroy(pool);
-
-    } else
-       DEBUG_PRINTF("pool_init", "Invalid parameters");
+               (void) pool_destroy(pool);
 
-    if (ok)
-       POOL_DEBUG("pool_init", "(%p = %s) initialized", pool, pool->label);
+       if (ok)
+               POOL_DEBUG("(%p = %s) initialized", pool, pool->label);
 
-    return ok;
+       return ok;
 }
 
-
-/* Destroys a pool which previously has been created by pool_init(), and frees
+/*
+ * Destroys a pool which previously has been created by pool_init(), and frees
  * any resources it uses (all the nodes it created become invalid).
- * Returns TRUE on success, or FALSE if the pool pointer is invalid.
+ * Returns true on success, or false if the pool pointer is invalid.
  */
 bool
 pool_destroy(pool_t *pool)
 {
-    bool       ok = FALSE;
-
-    /* Make sure pool_t is valid */
-    if (DEBUG_TRUE(POOL_VALID(pool))) {
        register bpage_t        *p, *t;
 
-       POOL_DEBUG("pool_destroy", "(%p = %s) destroying", pool, pool->label);
+       /* Make sure pool_t is valid */
+       if (DEBUG_FALSE(!POOL_VALID(pool))) {
+               DEBUG_PRINTF("Invalid pool_t pointer (%p)", pool);
+               return false;
+       }
+
+       POOL_DEBUG("(%p = %s) destroying", pool, pool->label);
 
        /* Destroy all pages of all lists */
        for (p = DLIST_TOP(&pool->pages); p != NULL; p = t) {
-           t = DLIST_NEXT(p);
-           (void) pool_page_destroy(p);
+               t = DLIST_NEXT(p);
+               (void) pool_page_destroy(p);
        }
        for (p = DLIST_TOP(&pool->fpages); p != NULL; p = t) {
-           t = DLIST_NEXT(p);
-           (void) pool_page_destroy(p);
+               t = DLIST_NEXT(p);
+               (void) pool_page_destroy(p);
        }
        for (p = DLIST_TOP(&pool->epages); p != NULL; p = t) {
-           t = DLIST_NEXT(p);
-           (void) pool_page_destroy(p);
+               t = DLIST_NEXT(p);
+               (void) pool_page_destroy(p);
        }
 
        /* Invalidate pool_t */
        pool->magic = 0;
 
-       ok = TRUE;
-    } else
-       DEBUG_PRINTF("pool_destroy", "Invalid pool_t pointer (%p)", pool);
-
-    return ok;
+       return true;
 }
 
-
-/* Allows to very efficiently allocate a single node from the specified pool,
- * optionally initializing it's memory to zeros. Returns the newly allocated
+/*
+ * Allows to very efficiently allocate a single node from the specified pool,
+ * optionally initializing it's memory to zeros.  Returns the newly allocated
  * node pointer on success, or NULL on error.
  */
 pnode_t *
 pool_alloc(pool_t *pool, bool zero)
 {
-    pnode_t    *pnode = NULL;
+       pnode_t                 *pnode = NULL;
+               register bpage_t        *page;
 
-    if (DEBUG_TRUE(POOL_VALID(pool))) {
-       if (DEBUG_TRUE(!zero || pool->create == NULL)) {
-           register bpage_t    *page;
+       if (DEBUG_FALSE(!POOL_VALID(pool))) {
+               DEBUG_PRINTF("Invalid pool_t pointer (%p)", pool);
+               return NULL;
+       }
+
+       if (DEBUG_FALSE(zero && pool->create != NULL)) {
+               DEBUG_PRINTF("Will not zero a constructed object of pool (%s)",
+                   pool->label);
+               return NULL;
+       }
 
-           /* Are there any partially used pages? */
-           if ((page = DLIST_TOP(&pool->pages)) == NULL) {
-               /* No, we thus attempt to move a page from our empty pages
-                * cache back into our usable pages list. The order of the
+       /* Are there any partially used pages? */
+       if ((page = DLIST_TOP(&pool->pages)) == NULL) {
+               /*
+                * No, we thus attempt to move a page from our empty pages
+                * cache back into our usable pages list.  The order of the
                 * usable page list becomes irrelevant at DLIST_SWAP() since
                 * it will be the only node.
                 */
-               POOL_DEBUG("pool_alloc", "(%p = %s) No usable page",
-                       pool, pool->label);
+               POOL_DEBUG("(%p = %s) No usable page", pool, pool->label);
                if ((page = DLIST_TOP(&pool->epages)) == NULL) {
-                   /* No more free pages in our cache neither. If maxpages is
-                    * set and not yet reached, we need to create a new page.
-                    * If we can't, return NULL for error.
-                    */
-                   POOL_DEBUG("pool_alloc",
-                           "(%p = %s) No empty page", pool, pool->label);
-                   if (pool->maxpages == 0 ||
+                       /*
+                        * No more free pages in our cache either.
+                        * If maxpages is set and not yet reached, we need to
+                        * create a new page.
+                        * If we can't, return NULL for error.
+                        */
+                       POOL_DEBUG("(%p = %s) No empty page",
+                           pool, pool->label);
+                       if (pool->maxpages == 0 ||
                            DLIST_NODES(&pool->fpages) < pool->maxpages) {
-                       POOL_DEBUG("pool_alloc",
-                               "(%p = %s) Creating new usable page",
-                               pool, pool->label);
-                       if ((page = pool_page_create("pool_alloc", pool))
-                               == NULL)
-                           return NULL;
-                       DLIST_APPEND(&pool->pages, (node_t *)page);
-                   } else
-                       return NULL;
+                               POOL_DEBUG(
+                                   "(%p = %s) Creating new usable page",
+                                   pool, pool->label);
+                               if ((page = pool_page_create("pool_alloc",
+                                   pool)) == NULL)
+                                       return NULL;
+                               DLIST_APPEND(&pool->pages, (node_t *)page);
+                       } else
+                               return NULL;
                } else {
-                   POOL_DEBUG("pool_alloc", "(%p = %s) swapping page "
-                           "(%p) from empty to usable",
-                           pool, pool->label, page);
-                   DLIST_SWAP(&pool->pages, &pool->epages, (node_t *)page,
-                           FALSE);
+                       POOL_DEBUG("(%p = %s) swapping page (%p) from empty "
+                           "to usable", pool, pool->label, page);
+                       DLIST_SWAP(&pool->pages, &pool->epages,
+                           (node_t *)page, false);
                }
-           } else {
-               POOL_DEBUG("pool_alloc",
-                       "(%p = %s) Allocating from usable page",
-                       pool, pool->label);
-           }
-
-           /* <page> now points to a page we know we can at least get a free
-            * object node from. Obtain one and unlink it.
-            */
-           pnode = DLIST_TOP(&page->objects);
-           DLIST_UNLINK(&page->objects, (node_t *)pnode);
-
-           /* Have we obtained the last available object from this page?
-            * If so, move the page to the full pages list. The order of the
-            * full pages list nodes is irrelevant, since we don't know which
-            * of those pages are more likely to be swapped to the usable
-            * pages list first, and we won't run through that list, except at
-            * pool_destroy().
-            */
-           if (DLIST_NODES(&page->objects) == 0) {
-               POOL_DEBUG("pool_alloc", "(%p = %s) swapping page (%p) "
-                       "from usable to full list",
-                       pool, pool->label, page);
+       } else {
+               POOL_DEBUG("(%p = %s) Allocating from usable page",
+                   pool, pool->label);
+       }
+
+       /*
+        * <page> now points to a page we know we can at least get a free
+        * object node from. Obtain one and unlink it.
+        */
+       pnode = DLIST_TOP(&page->objects);
+       DLIST_UNLINK(&page->objects, (node_t *)pnode);
+
+       /*
+        * Have we obtained the last available object from this page?
+        * If so, move the page to the full pages list.  The order of the
+        * full pages list nodes is irrelevant, since we don't know which
+        * of those pages are more likely to be swapped to the usable
+        * pages list first, and we won't run through that list, except at
+        * pool_destroy().
+        */
+       if (DLIST_NODES(&page->objects) == 0) {
+               POOL_DEBUG("(%p = %s) swapping page (%p) from usable to "
+                   "full list", pool, pool->label, page);
                DLIST_SWAP(&pool->fpages, &pool->pages, (node_t *)page,
-                       FALSE);
-           }
+                   false);
+       }
 
-           /* If requested, zero object. This is stupid if a constructor and
-            * destructor are used, but can be useful otherwise.
-            */
-           if (zero) {
+       /*
+        * If requested, zero object. This is stupid if a constructor and
+        * destructor are used, but can be useful otherwise.
+        */
+       if (zero) {
                page = pnode->page;
-               mm_memclr(pnode, pool->nodesize);
+               (void) memset(pnode, 0x00, pool->nodesize);
                pnode->page = page;
-           }
-
-           /* Mark this node as a valid allocated object */
-           pnode->magic = MAGIC_PNODE;
+       }
 
-           POOL_DEBUG("pool_alloc",
-                   "(%p = %s) got object (%p) from page (%p)",
-                   pool, pool->label, pnode, page);
+       /* Mark this node as a valid allocated object */
+       pnode->magic = MAGIC_PNODE;
 
-       } else
-           DEBUG_PRINTF("pool_alloc",
-                   "Will not zero a constructed object of pool (%s)",
-                   pool->label);
-    } else
-       DEBUG_PRINTF("pool_alloc", "Invalid pool_t pointer (%p)", pool);
+       POOL_DEBUG("(%p = %s) got object (%p) from page (%p)",
+           pool, pool->label, pnode, page);
 
-    return pnode;
+       return pnode;
 }
 
-
-/* Efficiently frees the specified node back to the pool it was allocated from.
- * Returns NULL. Uses heuristics keeping statistics to determine when to
+/*
+ * Efficiently frees the specified node back to the pool it was allocated from.
+ * Returns NULL.  Uses heuristics keeping statistics to determine when to
  * actually shrink the memory blocks internally used by the pool, so that
  * frequently growing and shrinking pools will remain large for scalability.
  * This also makes a big difference when constructors and destructors are used
@@ -378,116 +390,129 @@ pool_alloc(pool_t *pool, bool zero)
 pnode_t *
 pool_free(pnode_t *pnode)
 {
+       register bpage_t        *page;
+       register pool_t         *pool;
+       register uint32_t       count;
 
-    if (DEBUG_TRUE(PNODE_VALID(pnode))) {
-       register bpage_t        *page = pnode->page;
-       register pool_t         *pool = page->pool;
-       register u_int32_t      count;
+       if (DEBUG_FALSE(!PNODE_VALID(pnode))) {
+               DEBUG_PRINTF("Invalid pnode_t pointer (%p)", pnode);
+               return NULL;
+       }
 
-       POOL_DEBUG("pool_free",
-               "(%p = %s) freeing object (%p) from page (%p)",
-               pool, pool->label, pnode, page);
+       page = pnode->page;
+       pool = page->pool;
+
+       POOL_DEBUG("(%p = %s) freeing object (%p) from page (%p)",
+           pool, pool->label, pnode, page);
 
        /* Invalidate object */
        pnode->magic = 0;
 
-       /* Record how many nodes there currently are in our page's object
-        * list, to be used later on
+       /*
+        * Record how many nodes there currently are in our page's object
+        * list, to be used later on.
         */
        count = DLIST_NODES(&page->objects);
 
-       /* Add node back to it's page's object list. Insert it so that we
+       /*
+        * Add node back to it's page's object list.  Insert it so that we
         * favor reuse of recently used objects soon.
         */
        DLIST_INSERT(&page->objects, (node_t *)pnode);
 
-       /* Was this page full before we inserted our node? If so, page is in
-        * full pages list. Move it to the usable pages list. Insert it to
+       /*
+        * Was this page full before we inserted our node?  If so, page is in
+        * full pages list, move it to the usable pages list.  Insert it to
         * favor reuse of recently used pages soon (this page will soon return
         * back to the full pages list).
         */
        if (count == 0) {
-           POOL_DEBUG("pool_free",
+               POOL_DEBUG(
                    "(%p = %s) swapping page (%p) from full to usable list",
                    pool, pool->label, page);
-           DLIST_SWAP(&pool->pages, &pool->fpages, (node_t *)page, TRUE);
+               DLIST_SWAP(&pool->pages, &pool->fpages, (node_t *)page, true);
        } else {
-           /* Did we cause our node insertion to totally free back the page?
-            * If so, the page is on the usable free list, but move it back to
-            * the empty pages list. Insert it to favor reuse of recently used
-            * pages soon (this page will be the first to get used again when
-            * the usable pages list needs pages).
-            */
-           if (++count == pool->nodesperpage) {
-               POOL_DEBUG("pool_free", "(%p = %s) swapping page (%p) "
-                       "from usable to empty list",
-                       pool, pool->label, page);
-               DLIST_SWAP(&pool->epages, &pool->pages, (node_t *)page, TRUE);
-           }
+               /*
+                * Did we cause our node insertion to totally free back the
+                * page?  If so, the page is on the usable free list, move it
+                * back to the empty pages list.  Insert it to favor reuse of
+                * recently used pages soon (this page will be the first to
+                * get used again when the usable pages list needs pages).
+                */
+               if (++count == pool->nodesperpage) {
+                       POOL_DEBUG("(%p = %s) swapping page (%p) from usable "
+                           "to empty list", pool, pool->label, page);
+                       DLIST_SWAP(&pool->epages, &pool->pages, (node_t *)page,
+                           true);
+               }
        }
 
        if ((pool->minpages < pool->maxpages) ||
-               (pool->minpages == 0 && pool->maxpages == 0)) {
-           register int exceeding;
-
-           /* This pool_t is allowed to shrink. Maintain average pages usage
-            * to prevent destroying our pages in the empty pages list unless
-            * we should.
-            */
-           count = DLIST_NODES(&pool->pages) + DLIST_NODES(&pool->fpages);
-           pool->avgtotal += count;
-           pool->avgcnt++;
-
-           /* Using * 8 here means that pool_free() needs to at least be
-            * called to release as much objects as can fit into eight full
-            * pages in order to execute the following block. But of course,
-            * this does not mean that eight pages will recently have been
-            * freed, since allocations probably also occured meanwhile.
-            * XXX
-            * It would actually be nice to perhaps use a time delay here
-            * instead of this. However, since nodes can be freed quite often,
-            * it would be a burden to use a syscall all the time. What we
-            * could do, however, is update the current time every second via
-            * setitimer(2) or such, however this can clobber application
-            * timers. We perhaps could let the application call a function to
-            * update the time once in a while when it judges it adequate,
-            * however...
-            */
-           if (pool->avgcnt > pool->nodesperpage * 8) {
-               /* Do statistics suggest that we should shrink the pool?
-                * If so, free pages from our empty pages cache back to the
-                * system, destroying their objects if necessary. We'll make
-                * sure to at least leave a one page hysterisis for better
-                * performance.
+           (pool->minpages == 0 && pool->maxpages == 0)) {
+               register int    exceeding;
+
+               /*
+                * This pool_t is allowed to shrink.  Maintain average pages
+                * usage to prevent destroying our pages in the empty pages
+                * list unless we should.
+                */
+               count = DLIST_NODES(&pool->pages) + DLIST_NODES(&pool->fpages);
+               pool->avgtotal += count;
+               pool->avgcnt++;
+
+               /*
+                * Using * 8 here means that pool_free() needs to at least be
+                * called to release as much objects as can fit into eight full
+                * pages in order to execute the following block.  But of
+                * course, this does not mean that eight pages will recently
+                * have been freed, since allocations probably also occured
+                * meanwhile.
+                * XXX
+                * It would actually be nice to use a time delay here instead
+                * of this.  However, since nodes can be freed quite often,
+                * it would be a burden to use a syscall all the time.  What we
+                * could do, however, is update the current time every second
+                * via setitimer(2) or such, however this can clobber
+                * application timers.  We perhaps could let the application
+                * call a function to update the time once in a while when it
+                * judges it adequate.
                 */
-               if ((exceeding = (count + DLIST_NODES(&pool->epages) - 1) -
-                           (pool->avgtotal / pool->avgcnt)) > 0) {
-                   register list_t     *epages = &pool->epages;
-
-                   POOL_DEBUG("pool_alloc()",
-                           "(%p = %s) Destroying %d exceeding pages",
-                           pool, pool->label, exceeding);
-
-                   /* Preferably free pages which haven't been used
-                    * recently
-                    */
-                   for (; exceeding > 0 &&
-                           (page = DLIST_BOTTOM(epages)) != NULL;
-                           exceeding--) {
-                       POOL_DEBUG("pool_free",
-                               "(%p = %s) destroying page (%p)",
-                               pool, pool->label, page);
-                       DLIST_UNLINK(epages, (node_t *)page);
-                       (void) pool_page_destroy(page);
-                   }
+               if (pool->avgcnt > pool->nodesperpage * 8) {
+                       /*
+                        * Do statistics suggest that we should shrink the
+                        * pool?  If so, free pages from our empty pages cache
+                        * back to the system, destroying their objects if
+                        * necessary.  We'll make sure to at least leave a one
+                        * page hysterisis for better performance.
+                        */
+                       if ((exceeding = (count + DLIST_NODES(&pool->epages)
+                           - 1) - (pool->avgtotal / pool->avgcnt)) > 0) {
+                               register list_t *epages = &pool->epages;
+
+                               POOL_DEBUG(
+                                   "(%p = %s) Destroying %d exceeding pages",
+                                   pool, pool->label, exceeding);
+
+                               /*
+                                * Preferably free pages which haven't been
+                                * used recently, thus, those at the bottom
+                                * of the list.
+                                */
+                               for (; exceeding > 0 &&
+                                   (page = DLIST_BOTTOM(epages)) != NULL;
+                                   exceeding--) {
+                                       POOL_DEBUG(
+                                           "(%p = %s) destroying page (%p)",
+                                           pool, pool->label, page);
+                                       DLIST_UNLINK(epages, (node_t *)page);
+                                       (void) pool_page_destroy(page);
+                               }
+                       }
+                       /* Reset statistics */
+                       pool->avgcnt = 1;
+                       pool->avgtotal = count;
                }
-               /* Reset statistics */
-               pool->avgcnt = 1;
-               pool->avgtotal = count;
-           }
        }
-    } else
-       DEBUG_PRINTF("pool_free", "Invalid pnode_t pointer (%p)", pnode);
 
-    return NULL;
+       return NULL;
 }
index a5e60f0..0c90c82 100644 (file)
@@ -1,7 +1,7 @@
-/* $Id: mmpool.h,v 1.5 2004/09/07 06:20:41 mmondor Exp $ */
+/* $Id: mmpool.h,v 1.6 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
- * Copyright (C) 2001-2004, Matthew Mondor
+ * Copyright (C) 2001, 2004, 2007, Matthew Mondor
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
@@ -41,7 +41,8 @@
 
 
 
-#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <mmtypes.h>
 #include <mmlist.h>
 
@@ -66,42 +67,42 @@ typedef struct pool pool_t;
 
 /* Header structure of internally allocated/prepared page/blocks */
 struct bpage {
-    node_t             node;
-    u_int32_t          magic;
-    pool_t             *pool;
-    list_t             objects;
+       node_t          node;
+       uint32_t        magic;
+       pool_t          *pool;
+       list_t          objects;
 };
 
 /* Header structure of individual pool objects */
 struct pnode {
-    node_t             node;
-    u_int32_t          magic;
-    bpage_t            *page;
+       node_t          node;
+       uint32_t        magic;
+       bpage_t         *page;
 };
 
 /* Pool control structure */
 struct pool {
-    pnode_t            node;   /* Hey, we never know, a pool_t of pool_t */
-    u_int32_t          magic;
-    const char         *label;
-    void               *(*malloc)(size_t);
-    void               (*free)(void *);
-    int                        (*create)(pnode_t *);
-    void               (*destroy)(pnode_t *);
-    size_t             nodesize, pagesize;
-    u_int32_t          minpages, maxpages, nodesperpage;
-    u_int32_t          avgtotal, avgcnt;
-    /* Usable pages, totally full/busy pages, totally empty/free pages */
-    list_t             pages, fpages, epages;
+       pnode_t         node;   /* Allows a pool_t of pool_t */
+       uint32_t        magic;
+       const char      *label;
+       void            *(*malloc)(size_t);
+       void            (*free)(void *);
+       bool            (*create)(pnode_t *);
+       void            (*destroy)(pnode_t *);
+       size_t          nodesize, pagesize;
+       uint32_t        minpages, maxpages, nodesperpage;
+       uint32_t        avgtotal, avgcnt;
+       /* Usable pages, totally full/busy pages, totally empty/free pages */
+       list_t          pages, fpages, epages;
 };
 
 
 
 /* Public API prototypes */
 extern bool            pool_init(pool_t *, const char *, void *(*)(size_t),
-                               void (*)(void *), bool (*)(pnode_t *),
-                               void (*)(pnode_t *), size_t,
-                               u_int32_t, u_int32_t, u_int32_t);
+                           void (*)(void *), bool (*)(pnode_t *),
+                           void (*)(pnode_t *), size_t,
+                           uint32_t, uint32_t, uint32_t);
 extern bool            pool_destroy(pool_t *);
 extern pnode_t *       pool_alloc(pool_t *, bool);
 extern pnode_t *       pool_free(pnode_t *);
index e884e8c..aca07ae 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmrc4.c,v 1.12 2006/07/24 20:51:02 mmondor Exp $ */
+/* $Id: mmrc4.c,v 1.13 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*        This code illustrates a sample implementation
  *                 of the Arcfour algorithm
@@ -64,6 +64,7 @@
 
 
 #include <sys/types.h>
+#include <stdint.h>
 #include <stdlib.h>
 
 #include <mmtypes.h>
@@ -76,7 +77,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2000-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmrc4.c,v 1.12 2006/07/24 20:51:02 mmondor Exp $");
+MMRCSID("$Id: mmrc4.c,v 1.13 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
index f3f2d06..8e062d2 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmrc4.h,v 1.9 2006/06/13 16:26:21 mmondor Exp $ */
+/* $Id: mmrc4.h,v 1.10 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -43,6 +43,7 @@
 
 
 #include <sys/types.h>
+#include <stdint.h>
 
 #include <mmtypes.h>
 #include <mmpool.h>
@@ -60,7 +61,7 @@
 typedef struct rc4 rc4_t;
 struct rc4 {
     pnode_t node;
-    u_int32_t magic;
+    uint32_t magic;
     int x, y, state[256];
 };
 
index d08d31c..3d3d5a4 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmrc4util.c,v 1.14 2006/06/13 17:17:02 mmondor Exp $ */
+/* $Id: mmrc4util.c,v 1.15 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2003-2004, Matthew Mondor
@@ -39,6 +39,8 @@
 #include <sys/mman.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <errno.h>
 #include <syslog.h>
@@ -53,7 +55,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2003-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmrc4util.c,v 1.14 2006/06/13 17:17:02 mmondor Exp $");
+MMRCSID("$Id: mmrc4util.c,v 1.15 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -100,7 +102,7 @@ void rc4_load(RC4_KEY **key, void **data, const char *file, size_t size)
     rsize = (size_t)BALIGN_CEIL(size, pagesize);
 
     if (DEBUG_FALSE(file == NULL)) {
-       DEBUG_PRINTF("rc4_load", "file == NULL");
+       DEBUG_PRINTF("file == NULL");
        return;
     }
 
@@ -265,7 +267,7 @@ ssize_t rc4_read(RC4_KEY *key, fdbuf *fdb, void *cryptbuf, void *buf,
 
     if (size > 0) {
        if (key != NULL) {
-           u_int32_t header[2];
+           uint32_t header[2];
 
            /* Obtain header which rc4_write() setup for us. This assumes
             * that we generally write and read blocks of a similar size at
@@ -275,17 +277,17 @@ ssize_t rc4_read(RC4_KEY *key, fdbuf *fdb, void *cryptbuf, void *buf,
             * so that the next read operation would still obtain the header
             * of the next written block.
             */
-           if (rc4_bread(fd, cryptbuf, sizeof(u_int32_t) * 2) ==
-                   sizeof(u_int32_t) * 2) {
-               RC4(key, sizeof(u_int32_t) * 2, cryptbuf, (void *)header);
-               *header = (u_int32_t)ntohl(*header);
-               header[1] = (u_int32_t)ntohl(header[1]);
+           if (rc4_bread(fd, cryptbuf, sizeof(uint32_t) * 2) ==
+                   sizeof(uint32_t) * 2) {
+               RC4(key, sizeof(uint32_t) * 2, cryptbuf, (void *)header);
+               *header = (uint32_t)ntohl(*header);
+               header[1] = (uint32_t)ntohl(header[1]);
                /* Verify size */
                if (header[1] <= size) {
                    size = header[1];
                    if ((ret = rc4_bread(fd, cryptbuf, size)) == size) {
                        size_t i;
-                       u_int32_t csum;
+                       uint32_t csum;
                        const unsigned char *b;
 
                        RC4(key, size, cryptbuf, buf);
@@ -308,9 +310,9 @@ ssize_t rc4_read(RC4_KEY *key, fdbuf *fdb, void *cryptbuf, void *buf,
            }
            if (ret > 0) {
                /* Update fdb context for extraneous bytes */
-               fdb->context.rbytes += sizeof(u_int32_t) * 2;
+               fdb->context.rbytes += sizeof(uint32_t) * 2;
                if (fdb->gcontext != NULL)
-                   fdb->gcontext->rbytes += sizeof(u_int32_t) * 2;
+                   fdb->gcontext->rbytes += sizeof(uint32_t) * 2;
            }
        } else
            ret = read(fd, buf, size);
@@ -328,7 +330,7 @@ ssize_t rc4_write(RC4_KEY *key, fdbuf *fdb, void *cryptbuf, const void *buf,
 
     if (size > 0) {
        if (key != NULL) {
-           u_int32_t header[2];
+           uint32_t header[2];
            size_t i;
            const unsigned char *b;
 
@@ -337,11 +339,11 @@ ssize_t rc4_write(RC4_KEY *key, fdbuf *fdb, void *cryptbuf, const void *buf,
             */
            for (b = buf, *header = 0, i = 0; i < size; i++)
                *header += b[i];
-           *header = (u_int32_t)htonl(*header);
-           header[1] = (u_int32_t)htonl(size);
-           RC4(key, sizeof(u_int32_t) * 2, (void *)header, cryptbuf);
-           if (rc4_bwrite(fd, cryptbuf, sizeof(u_int32_t) * 2) !=
-                   sizeof(u_int32_t) * 2) {
+           *header = (uint32_t)htonl(*header);
+           header[1] = (uint32_t)htonl(size);
+           RC4(key, sizeof(uint32_t) * 2, (void *)header, cryptbuf);
+           if (rc4_bwrite(fd, cryptbuf, sizeof(uint32_t) * 2) !=
+                   sizeof(uint32_t) * 2) {
                syslog(LOG_NOTICE, "rc4_write() - Error writing header!");
                ret = -1;
            } else {
@@ -351,9 +353,9 @@ ssize_t rc4_write(RC4_KEY *key, fdbuf *fdb, void *cryptbuf, const void *buf,
            }
            if (ret > 0) {
                /* Update fdb context for extraneous bytes */
-               fdb->context.wbytes += sizeof(u_int32_t) * 2;
+               fdb->context.wbytes += sizeof(uint32_t) * 2;
                if (fdb->gcontext != NULL)
-                   fdb->gcontext->wbytes += sizeof(u_int32_t) * 2;
+                   fdb->gcontext->wbytes += sizeof(uint32_t) * 2;
            }
        } else
            ret = write(fd, buf, size);
index d6b420f..bdf9031 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmreadcfg.c,v 1.21 2007/03/13 20:28:22 mmondor Exp $ */
+/* $Id: mmreadcfg.c,v 1.22 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 1991-2004, Matthew Mondor
@@ -42,6 +42,7 @@
 #include <sys/mman.h>
 #include <fcntl.h>
 #include <unistd.h>
+#include <stdbool.h>
 #include <stdlib.h>
 #include <limits.h>
 #include <pwd.h>
@@ -61,7 +62,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 1991-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmreadcfg.c,v 1.21 2007/03/13 20:28:22 mmondor Exp $");
+MMRCSID("$Id: mmreadcfg.c,v 1.22 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -146,8 +147,7 @@ mmreadcfg(cres_t *res, carg_t *arg, const char *cfg)
            /* Programming bug */
            res->CR_Err = CRE_MULT_DEF_KEYWD;
            res->CR_Keyword = argptr;
-           DEBUG_PRINTF("mmreadcfg",
-                   "Duplicate keyword! (%s)", nod->keyword);
+           DEBUG_PRINTF("Duplicate keyword! (%s)", nod->keyword);
            goto end;
        }
     }
@@ -315,7 +315,7 @@ mmreadcfg(cres_t *res, carg_t *arg, const char *cfg)
                }
                break;
            default:
-               DEBUG_PRINTF("mmreadcfg", "Unknown data type for '%s': %d",
+               DEBUG_PRINTF("Unknown data type for '%s': %d",
                        nod->keyword, nod->args->CA_Type);
            }
 
index 9ea437f..5468d0d 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmreadcfg.h,v 1.9 2005/01/27 09:07:15 mmondor Exp $ */
+/* $Id: mmreadcfg.h,v 1.10 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 1991-2004, Matthew Mondor
@@ -45,6 +45,7 @@
 #include <sys/types.h>
 #include <pwd.h>
 #include <grp.h>
+#include <stdbool.h>
 
 #include <mmtypes.h>
 #include <mmhash.h>
index 0e2cd46..3871d03 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmserver.c,v 1.38 2007/06/13 09:36:31 mmondor Exp $ */
+/* $Id: mmserver.c,v 1.39 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -42,6 +42,8 @@
 #include <sys/wait.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdio.h>
@@ -86,7 +88,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2000-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmserver.c,v 1.38 2007/06/13 09:36:31 mmondor Exp $");
+MMRCSID("$Id: mmserver.c,v 1.39 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -113,7 +115,7 @@ static bool                         spawn_async_procs(uid_t, gid_t *, int,
 static void                    async_proc_main(int);
 static void                    async_resolvehostname(struct async_msg *);
 
-static u_int32_t               clnode_keyhash(const void *, size_t);
+static uint32_t                        clnode_keyhash(const void *, size_t);
 static int                     clnode_keycmp(const void *, const void *,
                                        size_t);
 static void *                  clnode_expire_thread(void *);
@@ -250,35 +252,31 @@ tcp_server(char *message, char *server_names, char *listen_ips, uid_t uid,
            opt = 1;
            if ((setsockopt(tif->sock, SOL_SOCKET, SO_REUSEADDR, &opt,
                            sizeof(int))) == -1)
-               DEBUG_PRINTF("tcp_server",
-                       "Error on setsockopt(%s:%d, SO_REUSEADDR) - (%s)",
+               DEBUG_PRINTF("Error on setsockopt(%s:%d, SO_REUSEADDR) - (%s)",
                        tif->address_str, port, tif->hostname);
            if ((setsockopt(tif->sock, SOL_SOCKET, SO_KEEPALIVE, &opt,
                            sizeof(int))) == -1)
-               DEBUG_PRINTF("tcp_server",
-                       "Error on setsockopt(%s:%d, SO_KEEPALIVE) - (%s)",
+               DEBUG_PRINTF("Error on setsockopt(%s:%d, SO_KEEPALIVE) - (%s)",
                        tif->address_str, port, tif->hostname);
 
            linger.l_onoff = 0;
            linger.l_linger = 0;
            if ((setsockopt(tif->sock, SOL_SOCKET, SO_LINGER, &linger,
                            sizeof(struct linger))) == -1)
-               DEBUG_PRINTF("tcp_server",
-                       "Error on setsockopt(%s:%d, SO_LINGER) - (%s)",
+               DEBUG_PRINTF("Error on setsockopt(%s:%d, SO_LINGER) - (%s)",
                        tif->address_str, port, tif->hostname);
 
            opt = 65536;
            if ((setsockopt(tif->sock, SOL_SOCKET, SO_SNDBUF, &opt,
                            sizeof(int))) == -1)
-               DEBUG_PRINTF("tcp_server",
-                       "Error on setsockopt(%s:%d, SO_SNDBUF) - (%s)",
+               DEBUG_PRINTF("Error on setsockopt(%s:%d, SO_SNDBUF) - (%s)",
                        tif->address_str, port, tif->hostname);
 
            if (tcp_proto != -1) {
                opt = 1;
                if ((setsockopt(tif->sock, tcp_proto, TCP_NODELAY, &opt,
                                sizeof(int))) == -1)
-                   DEBUG_PRINTF("tcp_server",
+                   DEBUG_PRINTF(
                            "Error on setsockopt(%s:%d, TCP_NODELAY) - (%s)",
                            tif->address_str, port, tif->hostname);
            }
@@ -385,7 +383,7 @@ tcp_server(char *message, char *server_names, char *listen_ips, uid_t uid,
                        pthread_mutex_lock(&ctable_lock);
                        if ((clnode = (clientlistnode *)hashtable_lookup(
                                        &ctable, &sinaddr->sin_addr.s_addr,
-                                       sizeof(u_int32_t))) == NULL) {
+                                       sizeof(uint32_t))) == NULL) {
                            /* Create new node */
                            if (HASHTABLE_NODES(&ctable) < maxips) {
                                if ((clnode = (clientlistnode *)pool_alloc(
@@ -402,7 +400,7 @@ tcp_server(char *message, char *server_names, char *listen_ips, uid_t uid,
                                            (hashnode_t *)clnode,
                                            &((struct sockaddr_in *)&clnode->
                                             client)->sin_addr.s_addr,
-                                           sizeof(u_int32_t), FALSE);
+                                           sizeof(uint32_t), FALSE);
                                } else
                                    syslog(LOG_NOTICE,
                                            "tcp_server() - Out of memory");
@@ -837,8 +835,7 @@ async_thread(void *args)
                        syslog(LOG_NOTICE, "async_thread() - send(%d:%d)",
                                p->sock, (int)len);
                } else
-                   DEBUG_PRINTF("async_thread",
-                           "Unknown function %u", m->func_id);
+                   DEBUG_PRINTF("Unknown function %u", m->func_id);
                DLIST_UNLINK(&queue, (node_t *)m);
            }
        }
@@ -1029,7 +1026,7 @@ async_init_pthread(void)
        }
 
     } else
-       DEBUG_PRINTF("async_init_pthread", "Call async_init() first");
+       DEBUG_PRINTF("Call async_init() first");
 
     return (res);
 }
@@ -1050,8 +1047,7 @@ async_open_clenv(void)
        aclenv = (struct async_clenv *)pool_alloc(&async->apool, FALSE);
        pthread_mutex_unlock(&async->apool_lock);
     } else
-       DEBUG_PRINTF("async_open_clenv",
-               "Call async_init() and async_init_pth() first");
+       DEBUG_PRINTF("Call async_init() and async_init_pth() first");
 
     return aclenv;
 }
@@ -1166,7 +1162,7 @@ spawn_async_procs(uid_t uid, gid_t *gids, int ngids, size_t msg_len)
                            sizeof(int)) == -1 ||
                        setsockopt(s[1], SOL_SOCKET, SO_RCVBUF, &opt,
                            sizeof(int)) == -1)
-                   DEBUG_PRINTF("spawn_async_procs", "setsockopt(SO_*BUF)");
+                   DEBUG_PRINTF("setsockopt(SO_*BUF)");
 
                aproc->sock = s[0];
                /* Create new process */
@@ -1280,7 +1276,7 @@ async_resolvehostname(struct async_msg *msg)
 
     if ((getnameinfo(saddr, sizeof(struct sockaddr_in), amsg->un.res.hostname,
                    255, NULL, 0, 0)) != 0) {
-       DEBUG_PRINTF("async_resolvehostname", "getnameinfo()");
+       DEBUG_PRINTF("getnameinfo()");
        mm_strcpy(amsg->un.res.hostname, "unknown");
     }
 }
@@ -1317,10 +1313,10 @@ resolve_hostname(struct async_clenv *aclenv, struct sockaddr *saddr)
  * 32-bit values
  */
 /* ARGSUSED */
-static u_int32_t
+static uint32_t
 clnode_keyhash(const void *data, size_t len)
 {
-    return *((u_int32_t *)data);
+    return *((uint32_t *)data);
 }
 
 
@@ -1330,7 +1326,7 @@ clnode_keyhash(const void *data, size_t len)
 static int
 clnode_keycmp(const void *src, const void *dst, size_t len)
 {
-    return *((u_int32_t *)src) - *((u_int32_t *)dst);
+    return *((uint32_t *)src) - *((uint32_t *)dst);
 }
 
 
index fdf5cb4..3783f73 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmserver.h,v 1.13 2007/03/19 08:58:18 mmondor Exp $ */
+/* $Id: mmserver.h,v 1.14 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -42,7 +42,8 @@
 
 
 
-#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <pthread.h>
 
 #include <mmtypes.h>
index 0095968..f582108 100644 (file)
@@ -1,4 +1,4 @@
-.\" $Id: mmserver2.3,v 1.17 2006/07/24 20:51:59 mmondor Exp $
+.\" $Id: mmserver2.3,v 1.18 2007/12/05 23:47:56 mmondor Exp $
 .\"
 .\" Copyright (C) 2004, Matthew Mondor
 .\" All rights reserved.
@@ -331,7 +331,7 @@ this server socket (TRUE or FALSE). Should always be FALSE for AF_LOCAL
 sockets.
 .Nm address_cache_concurrency_limit
 should be 0 if FALSE is specified.
-.It u_int32_t address_cache_size;
+.It uint32_t address_cache_size;
 Specifies the maximum number of unique addresses which can be stored into
 the rate limit sanity checking cache. This means that this socket can serve
 at most this number of concurrently different addresses at once. It therefore
@@ -341,14 +341,14 @@ should generally be high enough. Should be 0 if
 and
 .Nm address_concurrency_limits
 are all FALSE. Will be used otherwise.
-.It u_int32_t address_cache_rate_limit;
+.It uint32_t address_cache_rate_limit;
 The maximum number of requests which each IP address can perform within
 .Nm address_cache_rate_period
 seconds. Exceeding requests are delegated to the reject handler (if any)
 rather than to the request handler. Should be 0 if
 .Nm address_rate_limits
 is FALSE.
-.It u_int32_t address_cache_rate_period;
+.It uint32_t address_cache_rate_period;
 The number of seconds in which a maximum of
 .Nm address_cache_rate_limit
 requests are allowed from each IP address. Setting a low value here will
@@ -366,7 +366,7 @@ decreased. If the reference count becomes zero for the hostname node, it
 can be freed. This value should be 0 if
 .Nm address_cache_size
 is 0.
-.It u_int32_t address_cache_concurrency_limit;
+.It uint32_t address_cache_concurrency_limit;
 The maximum number of concurrent requests which each IP address is allowed
 to perform at once. Exceeding requests are sent to the reject handler rather
 than to the request handler. Should be 0 if
@@ -556,12 +556,12 @@ from the tty.
 The full path to the filename used to store the process ID (pid_t) of the
 parent process. This will be used by other software to know which pid to
 signal using SIGTERM or SIGHUP afterwards.
-.It u_int32_t children_initial;
+.It uint32_t children_initial;
 The number of children processes to initially startup at application launch.
 This number will usually consist of
 .Nm children_minspare
 but it can be set higher if it is known that high load is immediately expected.
-.It u_int32_t children_minspare;
+.It uint32_t children_minspare;
 Specifies the minimum number of spare processes (ready, unclobbered processes)
 which should be available to answer extraneous imminent client requests.
 Every second, the system verifies if this number is met and if not, new
@@ -569,7 +569,7 @@ children processes are started in the pool to meet the requirement.
 In the case of an HTTP server, this for instance allows to make sure that
 there be enough processes to answer requests from browsers which perform
 multiple simultaneous requests to load images of a page (like Netscape).
-.It u_int32_t children_maxspare;
+.It uint32_t children_maxspare;
 The maximum unused children processes in the pool that may exist. This permits
 to shrink the pool of processes when it is known that we are wasting resources
 with too many of them. The system maintains an average of unused processes
@@ -577,7 +577,7 @@ number so that it may only shrink the pool when it establishes that the current
 load allows it. It would be unefficient to shrink this pool too fast in the
 case of bursts of many client requests followed by short moments of inactivity
 when other bursts are known to occur soon. The system avoids this.
-.It u_int32_t children_maximum;
+.It uint32_t children_maximum;
 The maximum number of total processes (busy or not) in the pool. Note that
 this should be high enough to handle the maximum expected loads. Because
 each process can only handle one particular request at a time, this represents
@@ -587,7 +587,7 @@ are busy (it also depends on the backlog set for each listening socket), it
 is a possible event. In the case of AF_INET or AF_INET6 SOCK_DGRAM sockets,
 because of the unreliable nature of UDP, packets may be lost if this value is
 too low (I.E. there are many more clients than number of processes).
-.It u_int32_t children_average_seconds;
+.It uint32_t children_average_seconds;
 We previously described the way in which we shrink the size of the pool as
 needed maintaining an average count of ready processes in
 .Nm children_maxspare .
@@ -595,7 +595,7 @@ This value specifies the number of seconds over which this average is
 calculated before deciding to shrink the pool. A number of 300 seconds
 will cause the pool to only be shrinked if it is known that too many processes
 were ideling for nothing during 5 minutes.
-.It u_int32_t children_maxrequests;
+.It uint32_t children_maxrequests;
 Specifies the maximum number of consecutive client requests which each children
 process may serve before recycling. Recycling causes the process to exit and
 to be immediately replaced by another new process. This can be especially
@@ -603,7 +603,7 @@ useful in the cases where memory leaks are observed into the system libraries
 and the processes tend to grow overtime. This limit should be rather high
 for performance considerations. 1000 or more is generally a good value.
 Although this feature cannot be disabled, it is allowed to set a very high
-value (u_int32_t)-1 if wanted.
+value (uint32_t)-1 if wanted.
 .It bool serialization_lock;
 If TRUE, a synchronization lock will be used to more evenly distribute requests
 among the chilren processes in the pool. This also may be required on some
@@ -698,7 +698,7 @@ satisfied by such a function hook which needs to return quite fast, it is
 recommended to launch an application-specific process which can serve better
 the tasks at hand. This can be done through
 .Nm parent_init_hook .
-.It u_int32_t parent_timer_seconds;
+.It uint32_t parent_timer_seconds;
 If
 .Nm parent_timer_hook
 is set a pointer, this must hold a value larger than 0, specifying the interval
@@ -789,7 +789,7 @@ The pointer supplied at the
 .Nm user_data
 parameter for this server socket. May be used for any application-specific
 data.
-.It u_int32_t client_address_concurrency;
+.It uint32_t client_address_concurrency;
 The number of concurrent simultaneous requests from this client address.
 Always 0 in the case of AF_LOCAL sockets or for ones which do not have any
 address based limits enabled nor hostname resolution.
index 60fc713..91dc8c2 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmserver2.c,v 1.55 2007/10/14 18:01:00 mmondor Exp $ */
+/* $Id: mmserver2.c,v 1.56 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2004-2007, Matthew Mondor
@@ -68,6 +68,8 @@
 #include <sys/time.h>
 #include <time.h>
 #include <unistd.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
 
 MMCOPYRIGHT("@(#) Copyright (c) 2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmserver2.c,v 1.55 2007/10/14 18:01:00 mmondor Exp $");
+MMRCSID("$Id: mmserver2.c,v 1.56 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -126,7 +128,7 @@ struct child_process_node {
        pnode_t                         node;
        pid_t                           pid;
        volatile enum process_status    status;
-       u_int32_t                       served;
+       uint32_t                        served;
        /*
         * The following are only used for using_execve == TRUE applications,
         * for use by the SIGCHLD signal handler of the parent process.
@@ -168,7 +170,7 @@ enum shlocks {
        int     err;                                                    \
        while ((err = flock((fd), LOCK_EX)) == -1 && errno == EINTR) ;  \
        if (DEBUG_FALSE(err == -1))                                     \
-               DEBUG_PRINTF("FLOCK", "flock(%d, LOCK_EX) == -1", (fd));\
+               DEBUG_PRINTF("flock(%d, LOCK_EX) == -1", (fd));         \
 } while (/* CONSTCOND */0)
 
 #define UNLOCK(fd) \
@@ -192,14 +194,14 @@ struct parent {
        /* Timers */
        timerctx_t                      timer_ctx;
        /* PSTAT_READY average */
-       u_int32_t                       ready_avg_cnt, ready_avg;
+       uint32_t                        ready_avg_cnt, ready_avg;
        /*
         * Flag we set if we already warned because reaching the maximum
         * number of processes.
         */
        bool                            maximum_processes_reached;
        /* Number of children processes lanched so far */
-       u_int32_t                       launched;
+       uint32_t                        launched;
 };
 
 /*
@@ -289,7 +291,7 @@ struct address_node {
        hashnode_t                      node;
        struct server_sockaddr          address;        /* Key */
        struct limitrate                lr;
-       u_int32_t                       concurrent;
+       uint32_t                        concurrent;
        /*
         * The following is used to speed up hostname cache lookups when
         * frequent connections occur from the same address, where the lookup
@@ -312,14 +314,14 @@ struct address_node {
 struct hostname_node {
        hashnode_t                      node;
        struct server_sockaddr          address;        /* Key */
-       u_int32_t                       refcount;
+       uint32_t                        refcount;
        char                            hostname[256];
 };
 
 /* Used to share information with the iterator */
 struct expire_iterator_udata {
        time_t                          current;
-       u_int32_t                       soonest;
+       uint32_t                        soonest;
        hashtable_t                     *table;
 };
 
@@ -328,10 +330,10 @@ struct expire_iterator_udata {
 /* STATIC FUNCTIONS PROTOTYPES */
 
 static void *          i_shmem_malloc(size_t);
-static u_int32_t       server_sockaddr_hash(const void *, size_t);
+static uint32_t                server_sockaddr_hash(const void *, size_t);
 static int             server_sockaddr_cmp(const void *, const void *,
                            size_t);
-static u_int32_t       server_pid_hash(const void *, size_t);
+static uint32_t                server_pid_hash(const void *, size_t);
 static int             server_pid_cmp(const void *, const void *, size_t);
 static void            pidfile_write(const char *);
 static int             perms(struct perms *, const char *, const char *,
@@ -609,46 +611,41 @@ server_socket_bind(struct server_socket_config *config)
         */
        if (config->family != AF_INET && config->family != AF_INET6 &&
            config->family != AF_LOCAL) {
-               DEBUG_PRINTF("server_socket_bind",
-                   "Invalid address family %d", config->family);
+               DEBUG_PRINTF("Invalid address family %d", config->family);
                return -1;
        }
        if (config->type != SOCK_STREAM && config->type != SOCK_DGRAM) {
-               DEBUG_PRINTF("server_socket_bind", "Invalid socket type %d",
-                   config->type);
+               DEBUG_PRINTF("Invalid socket type %d", config->type);
                return -1;
        }
        if (config->family == AF_LOCAL) {
                if (config->port != 0) {
-                       DEBUG_PRINTF("server_socket_bind",
-                           "Port number not allowed for AF_LOCAL");
+                       DEBUG_PRINTF("Port number not allowed for AF_LOCAL");
                        return -1;
                }
                if (config->address_resolve) {
-                       DEBUG_PRINTF("server_socket_bind",
+                       DEBUG_PRINTF(
                            "Hostname resolution not allowed for AF_LOCAL");
                        return -1;
                }
                if (config->address_rate_limits) {
-                       DEBUG_PRINTF("server_socket_bind",
+                       DEBUG_PRINTF(
                            "Address limits not allowed for AF_LOCAL");
                        return -1;
                }
                if (config->address_concurrency_limits) {
-                       DEBUG_PRINTF("server_socket_bind",
-                           "Address concurrency limits not allowed for "
-                           "AF_LOCAL");
+                       DEBUG_PRINTF("Address concurrency limits not allowed "
+                           "for AF_LOCAL");
                        return -1;
                }
                if (config->address_cache_size != 0) {
-                       DEBUG_PRINTF("server_socket_bind",
+                       DEBUG_PRINTF(
                            "Address cache size should be 0 for AF_LOCAL");
                        return -1;
                }
                if (config->reject_handler != NULL) {
-                       DEBUG_PRINTF("server_socket_bind",
-                           "Reject handler should be NULL for AF_LOCAL "
-                           "sockets");
+                       DEBUG_PRINTF("Reject handler should be NULL for "
+                           "AF_LOCAL sockets");
                        return -1;
                }
                if (perms(&creds, "server_socket_bind()", config->socket_user,
@@ -657,31 +654,29 @@ server_socket_bind(struct server_socket_config *config)
                }
        } else {
                if (config->port < 1 || config->port > 65535) {
-                   DEBUG_PRINTF("server_socket_bind",
-                       "Invalid port number %d", config->port);
+                   DEBUG_PRINTF("Invalid port number %d", config->port);
                    return -1;
                }
        }
        if (*(config->bind_address) == '\0') {
-               DEBUG_PRINTF("server_socket_bind", "No address supplied");
+               DEBUG_PRINTF("No address supplied");
                return -1;
        }
        if (config->request_handler == NULL) {
-               DEBUG_PRINTF("server_socket_bind",
-                   "No request_handler() supplied");
+               DEBUG_PRINTF("No request_handler() supplied");
                return -1;
        }
        if (config->address_rate_limits || config->address_resolve ||
            config->address_concurrency_limits) {
                if (config->address_cache_size == 0) {
-                       DEBUG_PRINTF("server_socket_bind",
+                       DEBUG_PRINTF(
                            "Address cache size should be specified if limits"
                            " or hostname resolution is required");
                        return -1;
                }
        } else {
                if (config->address_cache_size != 0) {
-                       DEBUG_PRINTF("server_socket_bind",
+                       DEBUG_PRINTF(
                            "Address cache size should be 0 when no limits "
                            "nor hostname resolution is needed");
                        return -1;
@@ -689,14 +684,14 @@ server_socket_bind(struct server_socket_config *config)
        }
        if (config->address_rate_limits) {
                if (config->address_cache_rate_limit == 0) {
-                       DEBUG_PRINTF("server_socket_bind",
+                       DEBUG_PRINTF(
                            "Address rate limits enabled but no limit "
                            "specified");
                        return -1;
                }
        } else {
                if (config->address_cache_rate_limit != 0) {
-                       DEBUG_PRINTF("server_socket_bind",
+                       DEBUG_PRINTF(
                            "Address rate limits disabled but a limit was "
                            "specified");
                        return -1;
@@ -704,33 +699,31 @@ server_socket_bind(struct server_socket_config *config)
        }
        if (config->address_cache_size != 0 &&
            config->address_cache_rate_period < 1) {
-               DEBUG_PRINTF("server_socket_bind",
+               DEBUG_PRINTF(
                    "Address cache period should be specified with cache "
                    "size");
                return -1;
        }
        if (config->address_concurrency_limits) {
                if (config->address_cache_concurrency_limit == 0) {
-                       DEBUG_PRINTF("server_socket_bind",
-                           "Address concurrency limits "
+                       DEBUG_PRINTF("Address concurrency limits "
                            "enabled without specified limit");
                        return -1;
                }
        } else {
                if (config->address_cache_concurrency_limit != 0) {
-                       DEBUG_PRINTF("server_socket_bind",
-                           "Address concurrency limits "
+                       DEBUG_PRINTF("Address concurrency limits "
                            "disabled but a limit was specified");
                        return -1;
                }
        }
        if (config->type == SOCK_DGRAM && config->packet_size == 0) {
-               DEBUG_PRINTF("server_socket_bind",
+               DEBUG_PRINTF(
                    "Packet size must be specified for SOCKET_DGRAM sockets");
                return -1;
        }
        if (config->type == SOCK_STREAM && config->packet_size != 0) {
-               DEBUG_PRINTF("server_socket_bind",
+               DEBUG_PRINTF(
                    "Packet size should be 0 for SOCKET_STREAM sockets");
                return -1;
        }
@@ -879,7 +872,7 @@ server_start(struct server_config *config)
        int                     i, *slocks = NULL;
        struct pollfd           *fds = NULL;
        struct socket_node      **socks = NULL, *snode;
-       u_int32_t               resolve_cache_size;
+       uint32_t                resolve_cache_size;
        struct perms            creds;
 
        if (!initialized || global.started ||
@@ -1387,8 +1380,8 @@ i_shmem_malloc(size_t size)
 
                        if (shmem_getregion(&raddr, &rsize, mem)) {
                                if (madvise(raddr, rsize, MADV_RANDOM) == -1)
-                                   DEBUG_PRINTF("i_shmem_malloc",
-                                       "madvise() - %s", strerror(errno));
+                                   DEBUG_PRINTF("madvise() - %s",
+                                       strerror(errno));
                        }
                }
 #endif /* ! __Linux__ */
@@ -1399,20 +1392,20 @@ i_shmem_malloc(size_t size)
 
 /* Used to efficiently hash to 32-bit the supplied server_sockaddr keys */
 /* ARGSUSED */
-static u_int32_t
+static uint32_t
 server_sockaddr_hash(const void *d, size_t len)
 {
        const struct server_sockaddr    *sa = d;
-       u_int32_t                       hash = 0, *words;
+       uint32_t                        hash = 0, *words;
 
        switch (sa->ss_family) {
        case AF_INET:
                /* Very fast, already stored internally as a 32-bit value */
-               hash = (u_int32_t)sa->u.sockaddr_in.sin_addr.s_addr;
+               hash = (uint32_t)sa->u.sockaddr_in.sin_addr.s_addr;
                break;
        case AF_INET6:
                /* Requires hashing 4 32-bit words, rather fast */
-               words = (u_int32_t *)&sa->u.sockaddr_in6.sin6_addr;
+               words = (uint32_t *)&sa->u.sockaddr_in6.sin6_addr;
                /* hash = words[0] ^ words[1] ^ words[2] ^ words[3]; */
                hash = words[0] + (67306411U * hash);
                hash = words[1] + (67306411U * hash);
@@ -1420,8 +1413,7 @@ server_sockaddr_hash(const void *d, size_t len)
                hash = words[3] + (67306411U * hash);
                break;
        default:
-               DEBUG_PRINTF("server_sockaddr_hash",
-                   "Invalid family %d!", sa->ss_family);
+               DEBUG_PRINTF("Invalid family %d!", sa->ss_family);
        }
 
        return hash;
@@ -1433,7 +1425,7 @@ static int
 server_sockaddr_cmp(const void *s, const void *d, size_t len)
 {
        const struct server_sockaddr    *sa = s, *da = d;
-       u_int32_t                       *sawords, *dawords;
+       uint32_t                        *sawords, *dawords;
 
        if (sa->ss_family != da->ss_family)
                return -1;
@@ -1447,15 +1439,14 @@ server_sockaddr_cmp(const void *s, const void *d, size_t len)
                break;
        case AF_INET6:
                /* 4 32-bit words */
-               sawords = (u_int32_t *)&sa->u.sockaddr_in6.sin6_addr;
-               dawords = (u_int32_t *)&da->u.sockaddr_in6.sin6_addr;
+               sawords = (uint32_t *)&sa->u.sockaddr_in6.sin6_addr;
+               dawords = (uint32_t *)&da->u.sockaddr_in6.sin6_addr;
                if (sawords[0] != dawords[0] || sawords[1] != dawords[1] ||
                    sawords[2] != dawords[2] || sawords[3] != dawords[3])
                        return -1;
                break;
        default:
-               DEBUG_PRINTF("server_sockaddr_cmp",
-                   "Invalid family %d!", sa->ss_family);
+               DEBUG_PRINTF("Invalid family %d!", sa->ss_family);
                return -1;
        }
 
@@ -1464,11 +1455,11 @@ server_sockaddr_cmp(const void *s, const void *d, size_t len)
 
 /* To efficiently hash pid_t */
 /* ARGSUSED */
-static u_int32_t
+static uint32_t
 server_pid_hash(const void *d, size_t len)
 {
 
-       return (u_int32_t)(*(pid_t *)d);
+       return (uint32_t)(*(pid_t *)d);
 }
 
 /* And efficiently compare pid_t */
@@ -1688,7 +1679,7 @@ parent_main(void)
        sigset_t                        set;
        struct expire_iterator_udata    data;
        struct socket_node              *snode;
-       u_int32_t                       maxperiod, old_launched;
+       uint32_t                        maxperiod, old_launched;
        volatile bool                   node_expired;
        time_t                          tim;
 
@@ -1730,7 +1721,7 @@ parent_main(void)
         * status.
         */
        {
-               u_int32_t       i;
+               uint32_t        i;
 
                for (i = 0; i < global.config.children_initial; i++) {
                        if (child_launch() == -1) {
@@ -1902,7 +1893,7 @@ static void
 parent_main_pool_manager(timerid_t tid, void *udata)
 {
        sigset_t                        set, oset;
-       u_int32_t                       ready, busy, dead, recycle, total;
+       uint32_t                        ready, busy, dead, recycle, total;
        int                             i, to;
        struct child_process_node       *node, *tmp;
 
index 43e3f6d..065e379 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmserver2.h,v 1.15 2007/10/14 18:01:00 mmondor Exp $ */
+/* $Id: mmserver2.h,v 1.16 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2004-2007, Matthew Mondor
  */
 
 
-
 #ifndef MMLIB_MMSERVER2_H
 #define MMLIB_MMSERVER2_H
 
 
-
 /* HEADERFILES */
 
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdio.h>
 #include <signal.h>
 #include <sys/time.h>
@@ -62,7 +62,6 @@
 #include <mmtypes.h>
 
 
-
 /* DEFINITIONS */
 
 /* Used to map REASON_* to strings */
@@ -85,7 +84,6 @@ enum server_reject_reasons {
 };
 
 
-
 /* STRUCTURES */
 
 /* Configuration structure for server_start() */
@@ -100,7 +98,7 @@ struct server_config {
        mode_t          locks_mode;
        char            null_path[256];
        char            pid_path[256];
-       u_int32_t       children_initial, children_minspare, children_maxspare,
+       uint32_t        children_initial, children_minspare, children_maxspare,
                        children_maximum, children_average_seconds,
                        children_maxrequests;
        bool            serialization_lock, exit_interrupt_requests,
@@ -109,7 +107,7 @@ struct server_config {
        void            (*parent_exit_hook)(void);
        void            (*parent_sighup_hook)(void);
        void            (*parent_timer_hook)(void);
-       u_int32_t       parent_timer_seconds;
+       uint32_t        parent_timer_seconds;
        int             (*child_init_hook)(void);
        void            (*child_exit_hook)(void);
        void            (*child_sigalrm_hook)(void);
@@ -174,7 +172,7 @@ struct server_request {
                                        *client_address_name,
                                        *client_address_hostname;
        void                            *socket_user_data;
-       u_int32_t                       client_address_concurrency;
+       uint32_t                        client_address_concurrency;
        const void                      *packet_data;
        size_t                          packet_size;
 };
@@ -184,7 +182,7 @@ struct server_socket_config {
        int             family, type, port, backlog;
        bool            create_stream, address_resolve, address_rate_limits,
                        address_concurrency_limits;
-       u_int32_t       address_cache_size, address_cache_rate_limit,
+       uint32_t        address_cache_size, address_cache_rate_limit,
                        address_cache_rate_period,
                        address_cache_concurrency_limit;
        size_t          packet_size;
@@ -200,7 +198,6 @@ struct server_socket_config {
 };
 
 
-
 /* PROTOTYPES */
 
 extern void            server_init(void);
@@ -218,5 +215,4 @@ extern int          server_execve(const char *, char * const *,
                            char * const *);
 
 
-
 #endif
index 37e47f3..853b98e 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmsql.c,v 1.14 2007/03/13 20:28:22 mmondor Exp $ */
+/* $Id: mmsql.c,v 1.15 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -52,6 +52,8 @@
 #include <sys/file.h>
 #include <unistd.h>
 #include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <syslog.h>
@@ -69,7 +71,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2000-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmsql.c,v 1.14 2007/03/13 20:28:22 mmondor Exp $");
+MMRCSID("$Id: mmsql.c,v 1.15 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -115,7 +117,7 @@ mmsql_open(const char *host, const char *user, const char *pw, const char *db)
 {
     if (DEBUG_FALSE(mysql != NULL)) {
        mmsql_close();
-       DEBUG_PRINTF("mmsql_open", "Called again before mmsql_close()");
+       DEBUG_PRINTF("Called again before mmsql_close()");
     }
 
     if ((mysql = mysql_init(NULL)) != NULL) {
@@ -139,7 +141,7 @@ mmsql_close(void)
        mysql_close(mysql);
        mysql = NULL;
     } else
-       DEBUG_PRINTF("mmsql_close", "Called before mmsql_open()");
+       DEBUG_PRINTF("Called before mmsql_open()");
 }
 
 
@@ -180,7 +182,7 @@ mmsql_glock(const char *name)
            syslog(LOG_NOTICE, "mmsql_glock() - mmsql_query(%s)", query);
 
        if (res == 1) break;
-       DEBUG_PRINTF("mmsql_glock", "GET_LOCK(%s)", name);
+       DEBUG_PRINTF("GET_LOCK(%s)", name);
 
        /* Make sure to not loop taking 100% CPU time, and to
         * eventually exit loop, the SQL server seens down so
@@ -215,8 +217,7 @@ mmsql_gunlock(const char *name)
                    mm_memcpy(line, row[0], lengths[0]);
                    line[lengths[0]] = 0;
                    if ((atoi(line)) != 1)
-                       DEBUG_PRINTF("mmsql_gunlock",
-                               "RELEASE_LOCK(%s)", name);
+                       DEBUG_PRINTF("RELEASE_LOCK(%s)", name);
                }
            } else
                syslog(LOG_NOTICE, "mmsql_gunlock() - mysql_num_fields()");
@@ -237,7 +238,7 @@ mmsql_ping(void)
     int res;
 
     if ((res = mysql_ping(mysql)) != 0)
-       DEBUG_PRINTF("mmsql_ping", "mysql_ping() - (%s)", mysql_error(mysql));
+       DEBUG_PRINTF("mysql_ping() - (%s)", mysql_error(mysql));
 }
 
 
@@ -318,10 +319,10 @@ mmsql_command(const char *query, long len)
 }
 
 
-u_int64_t
+uint64_t
 mmsql_last_auto_id(void)
 {
-    u_int64_t id;
+    uint64_t id;
 
     if (mmsql_lock != NULL)
        thrfuncs.mutex_lock(mmsql_lock);
index 16de574..19be217 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmsql.h,v 1.9 2007/03/13 20:28:22 mmondor Exp $ */
+/* $Id: mmsql.h,v 1.10 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -45,6 +45,8 @@
 /* HEADERS */
 
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 
 #include <mmtypes.h>
 
@@ -79,7 +81,7 @@ extern void           mmsql_ping(void);
 extern MYSQL_RES *     mmsql_query(const char *, long);
 extern MYSQL_RES *     mmsql_free_result(MYSQL_RES *);
 extern bool            mmsql_command(const char *, long);
-extern u_int64_t       mmsql_last_auto_id(void);
+extern uint64_t                mmsql_last_auto_id(void);
 
 
 
index 08ffd5a..bfbdbf5 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmstat.c,v 1.23 2007/07/08 09:28:21 mmondor Exp $ */
+/* $Id: mmstat.c,v 1.24 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2002-2004, Matthew Mondor
@@ -43,6 +43,8 @@
 #include <sys/un.h>
 #include <sys/uio.h>
 #include <sys/poll.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <unistd.h>
 #include <stdio.h>
@@ -63,7 +65,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2002-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmstat.c,v 1.23 2007/07/08 09:28:21 mmondor Exp $");
+MMRCSID("$Id: mmstat.c,v 1.24 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -127,8 +129,8 @@ mmstat(mmstat_t *mms, enum stat_type type, int64_t value, const char *fmt, ...)
            /* Now simply fill new log entry */
            mm_memclr(entry, sizeof(struct log_entry));
            entry->type = (int32_t)type;
-           entry->persistent = (u_int16_t)mms->persistent;
-           entry->autoflush = (u_int16_t)mms->autoflush;
+           entry->persistent = (uint16_t)mms->persistent;
+           entry->autoflush = (uint16_t)mms->autoflush;
            if (fmt != NULL) {
                va_start(arg_ptr, fmt);
                vsnprintf(entry->key, KEY_SIZE - 1, fmt, arg_ptr);
@@ -140,11 +142,9 @@ mmstat(mmstat_t *mms, enum stat_type type, int64_t value, const char *fmt, ...)
                entry->un.reset.value = value;
            ok = TRUE;
        } else
-           DEBUG_PRINTF("mmstat",
-                   "Exceeded number of entries in transaction");
+           DEBUG_PRINTF("Exceeded number of entries in transaction");
     } else
-       DEBUG_PRINTF("mmstat",
-               "Type not one of STAT_RESET | STAT_UPDATE | STAT_DELETE");
+       DEBUG_PRINTF("Type not one of STAT_RESET | STAT_UPDATE | STAT_DELETE");
     if (ok && !mms->transaction) {
        /* Not in transaction mode, flush packet to mmstatd immediately */
        ok = i_mmstat_send(mms->entries, 1);
@@ -167,7 +167,7 @@ mmstat_transact(mmstat_t *mms, bool lock)
            mms->transact_pos = 0;
            ok = TRUE;
        } else
-           DEBUG_PRINTF("mmstat_transact", "Transaction already started");
+           DEBUG_PRINTF("Transaction already started");
     } else {
        if (DEBUG_TRUE(mms->transaction)) {
            /* End transaction mode, flush transaction queue to mmstatd */
@@ -176,7 +176,7 @@ mmstat_transact(mmstat_t *mms, bool lock)
            mms->transaction = FALSE;
            mms->transact_pos = 0;
        } else
-           DEBUG_PRINTF("mmstat_transact", "Transaction already ended");
+           DEBUG_PRINTF("Transaction already ended");
     }
 
     return (ok);
@@ -249,7 +249,7 @@ mmstatres_t *
 mmstat_freeres(mmstatres_t *res)
 {
     if (DEBUG_FALSE(res == NULL || res->fd == -1)) {
-       DEBUG_PRINTF("mmstat_freeres", "NULL prameter or fd already closed!");
+       DEBUG_PRINTF("NULL prameter or fd already closed!");
        return NULL;
     }
 
@@ -314,8 +314,7 @@ i_mmstat_send(struct log_entry *entries, int len)
                ok = TRUE;
            else {
                if (DEBUG_FALSE(errno == EMSGSIZE))
-                   DEBUG_PRINTF("i_mmstat_send",
-                           "Your kernel has a broken setsockopt(2)");
+                   DEBUG_PRINTF("Your kernel has a broken setsockopt(2)");
                close(lsock);
                lsock = -1;
            }
@@ -324,8 +323,7 @@ i_mmstat_send(struct log_entry *entries, int len)
            /* Attempt to re-establish connection to mmstatd(8), but stop
             * trying if it fails. Stats update will be lost!
             */
-           DEBUG_PRINTF("i_mmstat_send",
-                   "Re-establishing lost connection to mmstatd(8)");
+           DEBUG_PRINTF("Re-establishing lost connection to mmstatd(8)");
            if (!mmstat_initialize())
                break;
        }
@@ -411,8 +409,7 @@ mmstat_initialize(void)
                        1024);
                if (setsockopt(lsock, SOL_SOCKET, SO_SNDBUF, &opt, sizeof(int))
                        == -1)
-                   DEBUG_PRINTF("mmstat_initialize",
-                           "setsockopt(SO_SNDBUF)");
+                   DEBUG_PRINTF("setsockopt(SO_SNDBUF)");
 
                mm_memclr(&laddr, sizeof(struct sockaddr_un));
                mm_strncpy(laddr.sun_path, CONF.LOG_SOCKET, 100);
index f08805b..d75d4fc 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmstat.h,v 1.11 2004/06/01 23:52:43 mmondor Exp $ */
+/* $Id: mmstat.h,v 1.12 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2002-2004, Matthew Mondor
@@ -42,7 +42,8 @@
 
 
 
-#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 
 #include <mmtypes.h>
 #include <mmlist.h>
@@ -87,16 +88,16 @@ struct mmstat_entry {
  */
 struct log_entry {
     int32_t type;                      /* enum stat_type */
-    u_int32_t uid;                     /* uid_t */
-    u_int32_t time;                    /* time_t */
-    u_int16_t persistent, autoflush;   /* booleans */
+    uint32_t uid;                      /* uid_t */
+    uint32_t time;                     /* time_t */
+    uint16_t persistent, autoflush;    /* booleans */
     char key[KEY_SIZE];
     union {
        struct {
-           u_int32_t begin;            /* boolean */
+           uint32_t begin;             /* boolean */
        } transact;
        struct {
-           u_int32_t lognum;
+           uint32_t lognum;
        } newfile;
        struct {
            int64_t modifier;
index 3eb5598..6069494 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmstr.c,v 1.9 2007/03/13 20:28:22 mmondor Exp $ */
+/* $Id: mmstr.c,v 1.10 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -39,6 +39,7 @@
 /* INCLUDES */
 
 #include <sys/types.h>
+#include <stdbool.h>
 #include <pthread.h>
 
 #include <mmtypes.h>
@@ -51,7 +52,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2000-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmstr.c,v 1.9 2007/03/13 20:28:22 mmondor Exp $");
+MMRCSID("$Id: mmstr.c,v 1.10 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
index 69fac14..ef6f616 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmstr.h,v 1.6 2004/06/01 19:11:57 mmondor Exp $ */
+/* $Id: mmstr.h,v 1.7 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
@@ -45,6 +45,7 @@
 /* INCLUDES */
 
 #include <sys/types.h>
+#include <stdbool.h>
 
 #include <mmtypes.h>
 #include <mmpool.h>
index ab7a60a..b047e89 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmstring.c,v 1.31 2005/01/31 18:11:57 mmondor Exp $ */
+/* $Id: mmstring.c,v 1.32 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 1989-2004, Matthew Mondor
  */
 
 
-
-
-#include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 
 #include <mmtypes.h>
 #include <mmstring.h>
 
 
-
-
 MMCOPYRIGHT("@(#) Copyright (c) 1989-2004\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmstring.c,v 1.31 2005/01/31 18:11:57 mmondor Exp $");
+MMRCSID("$Id: mmstring.c,v 1.32 2007/12/05 23:47:56 mmondor Exp $");
 
 static const unsigned char toupper_table[] = {
     0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 
@@ -169,10 +166,10 @@ mm_strasplq(char **argv, char *str, int maxcols)
        for (; *ptr == ' ' || *ptr == '\t'; ptr++) ;
        if (*ptr != '\0' && *ptr != '\n' && *ptr != '\r') {
            if (*ptr == '\'') {
-               quoted = TRUE;
+               quoted = true;
                ptr++;
            } else
-               quoted = FALSE;
+               quoted = false;
            for (sptr = ptr; *ptr != '\0' && *ptr != '\n' && *ptr != '\r' &&
                    ((!quoted && *ptr != ' ' && *ptr != '\t') ||
                     (quoted && *ptr != '\'')); ptr++) ;
@@ -197,12 +194,12 @@ mm_strasplq(char **argv, char *str, int maxcols)
 
 /* Parses the supplied command line <cmd>, of which the first word/element
  * is expected to contain the absolute fullpath of an executable. Following
- * may be optional arguments. On success, TRUE is returned, and the executable
+ * may be optional arguments. On success, true is returned, and the executable
  * fullpath is set in <path>, the arguments in <argv>, as well as the argument
  * count in <argc> (which includes the first argument, argv[0] which consists
  * of the executable name (without the directory elements)).
  * Very useful prior to using execve(2).
- * FALSE is returned if a parsing error occurs (mismatched quote,
+ * false is returned if a parsing error occurs (mismatched quote,
  * first element not an absolute fullpath, etc) in which case the supplied
  * pointers and <cmd> should be considered in an undefined state.
  * <cmd> is modified, and the pointers will point to locations within it.
@@ -218,13 +215,13 @@ mm_cmdparse(char **path, int *argc, char **argv, char *cmd, int max)
 
     /* Not enough space in argv? */
     if (max < 2)
-       return FALSE;
+       return false;
     /* Failed parsing (unmatched quote?) */
     if ((i = mm_strasplq(argv, cmd, max - 1)) == -1)
-       return FALSE;
+       return false;
     /* Command not an absolute fullpath? */
     if (*argv[0] != '/')
-       return FALSE;
+       return false;
 
     *argc = i;
     argv[i] = NULL;
@@ -234,14 +231,14 @@ mm_cmdparse(char **path, int *argc, char **argv, char *cmd, int max)
     for (ptr = *path; *ptr != '\0'; ptr++) ;
     /* Find last '/' in command */
     for (; ptr > *path && *ptr != '/'; ptr--) ;
-    /* If only '/' is at first column, no command specified, return FALSE.
+    /* If only '/' is at first column, no command specified, return false.
      * Otherwise, split command at last '/' and set argv[0] to command.
      */
     if (ptr == *path || *(++ptr) == '\0')
-       return FALSE;
+       return false;
     argv[0] = ptr;
 
-    return TRUE;
+    return true;
 }
 
 
@@ -555,11 +552,11 @@ mm_strupper(char *str)
  * only perform this for 4 bytes. It will stop at either end of string '\0'
  * or space ' '. If the string has more than 4 characters 0 is returned.
  */
-u_int32_t
+uint32_t
 mm_strpack32(const char *str, size_t min)
 {
     register unsigned const char *ustr;
-    register u_int32_t hash = 0;
+    register uint32_t hash = 0;
     size_t i;
 
     for (ustr = (unsigned const char *)str, i = 0; *ustr > 32 && i < 5; i++) {
@@ -641,10 +638,10 @@ mm_strrevto(char *dst, const char *src)
  * cat /usr/share/dict/words
  * XXX Could be unrolled a little
  */
-u_int64_t
+uint64_t
 mm_strhash64(const char *str)
 {   
-    u_int64_t hash;
+    uint64_t hash;
     register const unsigned char *ptr;
 
     for (hash = 0, ptr = (const unsigned char *)str; *ptr != '\0'; ptr++)
@@ -655,10 +652,10 @@ mm_strhash64(const char *str)
 
 
 /* Variant of hash64 on memory buffer */
-u_int64_t
+uint64_t
 mm_memhash64(const void *mem, size_t size)
 {   
-    u_int64_t hash;
+    uint64_t hash;
     register const unsigned char *curmem, *tomem;
 
     for (hash = 0, curmem = tomem = (const unsigned char *)mem, tomem += size;
@@ -669,10 +666,10 @@ mm_memhash64(const void *mem, size_t size)
 }
 
 
-u_int32_t
+uint32_t
 mm_memhash32(const void *mem, size_t size)
 {
-    register u_int32_t hash;
+    register uint32_t hash;
     register const unsigned char *curmem, *tomem;
 
     hash = 0;
@@ -707,10 +704,10 @@ mm_memhash32(const void *mem, size_t size)
  * records storage must be preserved.
  */
 
-u_int32_t
+uint32_t
 mm_memcasehash32(const void *mem, size_t size)
 {
-    register u_int32_t hash;
+    register uint32_t hash;
     register const unsigned char *curmem, *tomem;
 
     hash = 0;
@@ -1208,8 +1205,8 @@ mm_memmove(void *dest, const void *src, size_t len)
                *dptr++ = *ptr++;
        } else if (dest > src) {
            /* Reverse order */
-           register const long *lptr, *ltoptr;
-           register long *ldptr, *ldtoptr;
+           register const unsigned long *lptr, *ltoptr;
+           register unsigned long *ldptr, *ldtoptr;
            register char *dtoptr;
 
            ptr = toptr = (const unsigned char *)src;
@@ -1271,7 +1268,7 @@ void *
 mm_memset(void *mem, int fill, size_t len)
 {
     register unsigned char *ptr, *toptr;
-    u_int8_t byte = (u_int8_t)fill;
+    uint8_t byte = (uint8_t)fill;
 
     ptr = toptr = mem;
     toptr += len;
@@ -1344,7 +1341,7 @@ mm_memset(void *mem, int fill, size_t len)
            /* Creating a 16-bit word from the 8-bit one, then the 32-bit word
             * from the 16-bit one require less instructions.
             */
-           register u_int16_t tmp;
+           register uint16_t tmp;
 
            tmp = ((byte << 8) & 0xff00) | (byte & 0x00ff);
            lword = ((tmp << 16) & 0xffff0000) | (tmp & 0x0000ffff);
@@ -1353,8 +1350,8 @@ mm_memset(void *mem, int fill, size_t len)
             * the 16-bit one and a 64-bit word from the 32-bit one require
             * less instructions.
             */
-           register u_int32_t tmp2;
-           register u_int16_t tmp;
+           register uint32_t tmp2;
+           register uint16_t tmp;
 
            tmp = ((byte << 8) & 0xff00) | (byte & 0x00ff);
            tmp2 = ((tmp << 16) & 0xffff0000) | (tmp & 0x0000ffff);
index 430edbb..453724c 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmstring.h,v 1.17 2005/01/27 09:07:15 mmondor Exp $ */
+/* $Id: mmstring.h,v 1.18 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 1989-2004, Matthew Mondor
  */
 
 
-
-
 #ifndef MMSTRING_H
 #define MMSTRING_H
 
 
+#include <stdbool.h>
+#include <stdint.h>
 
 
-#include <sys/types.h>
-#include <mmtypes.h>
-
-
-
-
-#define mm_memclr(a, l)                mm_memset((a), 0, (l))
-
-
+#define mm_memclr(a, l)                (void) mm_memset((a), 0, (l))
 
 
 extern size_t          mm_strlen(const char *);
@@ -83,15 +75,15 @@ extern int          mm_strspl(char **, char *, int, char);
 
 extern void            mm_strlower(char *);
 extern void            mm_strupper(char *);
-extern u_int32_t       mm_strpack32(const char *, size_t);
+extern uint32_t                mm_strpack32(const char *, size_t);
 extern unsigned long   mm_htol(const char *);
 extern void            mm_strrev(char *);
 extern void            mm_strrevto(char *, const char *);
-extern u_int64_t       mm_strhash64(const char *);
-extern u_int64_t       mm_memhash64(const void *, size_t);
+extern uint64_t                mm_strhash64(const char *);
+extern uint64_t                mm_memhash64(const void *, size_t);
 
-extern u_int32_t       mm_memhash32(const void *, size_t);
-extern u_int32_t       mm_memcasehash32(const void *, size_t);
+extern uint32_t                mm_memhash32(const void *, size_t);
+extern uint32_t                mm_memcasehash32(const void *, size_t);
 extern int             mm_memcasecmp(const void *, const void *, size_t);
 
 extern int             mm_memcmp(const void *, const void *, size_t);
@@ -101,6 +93,4 @@ extern void *                mm_memset(void *, int, size_t);
 /*extern void          mm_memclr(void *, size_t);*/
 
 
-
-
 #endif
index 0059e1f..31005e3 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmtypes.h,v 1.7 2004/06/01 19:11:43 mmondor Exp $ */
+/* $Id: mmtypes.h,v 1.8 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2000-2004, Matthew Mondor
 
 
 
-/* This eventually has to go away or to be changed to another name, since it
- * conflicts with curses, which also defines it as a 8-bit type.
- * XXX
- */
-typedef int            bool;
-
-
-
 #ifndef NULL
 #define NULL           ((void *)0)
 #endif
index 2123cbb..8e1657f 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmpop3d.c,v 1.54 2007/07/23 17:12:11 mmondor Exp $ */
+/* $Id: mmpop3d.c,v 1.55 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2007, Matthew Mondor
@@ -40,6 +40,8 @@
 #include <sys/stat.h>
 #include <sys/mman.h>
 #include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <unistd.h>
@@ -83,7 +85,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2007\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmpop3d.c,v 1.54 2007/07/23 17:12:11 mmondor Exp $");
+MMRCSID("$Id: mmpop3d.c,v 1.55 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -1093,7 +1095,7 @@ hash_commands(struct command *cmd, size_t min)
        nod->command = cmd;
        nod->index = i;
        if (!hashtable_link(&command_table, (hashnode_t *)nod, &nod->hash,
-                   sizeof(u_int32_t), TRUE)) {
+                   sizeof(uint32_t), TRUE)) {
            DEBUG_PRINTF("hash_commands", "hashtable_link(%s)", cmd->name);
            return FALSE;
        }
@@ -1107,10 +1109,10 @@ hash_commands(struct command *cmd, size_t min)
  * 32-bit values
  */
 /* ARGSUSED */
-static u_int32_t
+static uint32_t
 commandnode_keyhash(const void *data, size_t len)
 {   
-    return *((u_int32_t *)data);
+    return *((uint32_t *)data);
 }
 
 
@@ -1120,7 +1122,7 @@ commandnode_keyhash(const void *data, size_t len)
 static int
 commandnode_keycmp(const void *src, const void *dst, size_t len)
 {
-    return *((u_int32_t *)src) - *((u_int32_t *)dst);
+    return *((uint32_t *)src) - *((uint32_t *)dst);
 }
 
 
@@ -1625,7 +1627,7 @@ handleclient(unsigned long id, int fd, clientlistnode *clientlnode,
            /* Main state switcher loop */
            for (;;) {
                register struct commandnode *nod;
-               u_int32_t chash;
+               uint32_t chash;
 
                fdbflushw(fdb);
                if ((len = fdbgets(fdb, buffer, 1023, FALSE)) > -1) {
@@ -1640,7 +1642,7 @@ handleclient(unsigned long id, int fd, clientlistnode *clientlnode,
                    nod = NULL;
                    if ((chash = mm_strpack32(buffer, 3)) != 0)
                        nod = (struct commandnode *)hashtable_lookup(
-                               &command_table, &chash, sizeof(u_int32_t));
+                               &command_table, &chash, sizeof(uint32_t));
                    if (nod != NULL) {
                        register int (*func)(clientenv *);
 
index 8d1f1d8..e697843 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmpop3d.h,v 1.24 2007/09/17 04:03:56 mmondor Exp $ */
+/* $Id: mmpop3d.h,v 1.25 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2007, Matthew Mondor
@@ -43,6 +43,8 @@
 /* HEADERS */
 
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 
 #include <pthread.h>
 
@@ -163,7 +165,7 @@ typedef struct command {
 /* Used for fast command lookup */
 struct commandnode {
     hashnode_t node;
-    u_int32_t hash;
+    uint32_t hash;
     int index;
     struct command *command;
 };
@@ -207,7 +209,7 @@ static int main_page(clientenv *);
 
 static int lock_check(const char *);
 static bool hash_commands(struct command *, size_t);
-static u_int32_t commandnode_keyhash(const void *, size_t);
+static uint32_t commandnode_keyhash(const void *, size_t);
 static int commandnode_keycmp(const void *, const void *, size_t);
 static bool do_buildindex(clientenv *);
 static bool do_message_load(msgdata *, msgnode *);
index 86074df..21b9fb7 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmsmtpd.c,v 1.91 2007/09/17 06:08:11 mmondor Exp $ */
+/* $Id: mmsmtpd.c,v 1.92 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2007, Matthew Mondor
@@ -39,6 +39,8 @@
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <fcntl.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <errno.h>
@@ -82,7 +84,7 @@
 
 MMCOPYRIGHT("@(#) Copyright (c) 2001-2007\n\
 \tMatthew Mondor. All rights reserved.\n");
-MMRCSID("$Id: mmsmtpd.c,v 1.91 2007/09/17 06:08:11 mmondor Exp $");
+MMRCSID("$Id: mmsmtpd.c,v 1.92 2007/12/05 23:47:56 mmondor Exp $");
 
 
 
@@ -629,14 +631,14 @@ all_help(clientenv *clenv)
 
     /* First check if a topic was specified */
     if ((col = mm_straspl(args, cmdline, 2)) == 2) {
-       u_int32_t chash;
+       uint32_t chash;
        struct commandnode *nod;
 
        /* Help requested on a topic */
        nod = NULL;
        if ((chash = mm_strpack32(args[1], 4)) != 0)
            nod = (struct commandnode *)hashtable_lookup(&command_table,
-                   &chash, sizeof(u_int32_t));
+                   &chash, sizeof(uint32_t));
        col = 0;
        if (nod != NULL) {
            reply(fdb, 214, TRUE, nod->command->args);
@@ -781,7 +783,7 @@ all_rcpt(clientenv *clenv)
     char addr[64], foraddr[64], *line = clenv->buffer;
     int reason;
     struct box_info boxinfo;
-    u_int64_t ahash;
+    uint64_t ahash;
     bool valid, relay;
 
     /* I have opted for an elimination process here as there are many cases
@@ -1075,7 +1077,7 @@ hash_commands(struct command *cmd, size_t min)
        nod->command = cmd;
        nod->index = i;
        if (!hashtable_link(&command_table, (hashnode_t *)nod, &nod->hash,
-                   sizeof(u_int32_t), TRUE)) {
+                   sizeof(uint32_t), TRUE)) {
            DEBUG_PRINTF("hash_commands", "hashtable_link(%s)", cmd->name);
            return FALSE;
        }
@@ -1089,10 +1091,10 @@ hash_commands(struct command *cmd, size_t min)
  * 32-bit values                
  */     
 /* ARGSUSED */  
-static u_int32_t
+static uint32_t
 commandnode_keyhash(const void *data, size_t len)
 {       
-    return *((u_int32_t *)data);
+    return *((uint32_t *)data);
 }       
 
 
@@ -1102,7 +1104,7 @@ commandnode_keyhash(const void *data, size_t len)
 static int
 commandnode_keycmp(const void *src, const void *dst, size_t len)
 {
-    return *((u_int32_t *)src) - *((u_int32_t *)dst);
+    return *((uint32_t *)src) - *((uint32_t *)dst);
 }
 
 
@@ -2027,7 +2029,7 @@ message_write(char *path, const char *recvline, size_t recvlen,
     bool       ok = FALSE;
     char       filetime[16];
     int                i, fd;
-    u_int32_t  r;
+    uint32_t   r;
 
     fd = -1;
 
@@ -2046,7 +2048,7 @@ message_write(char *path, const char *recvline, size_t recvlen,
      */
     iso_time(filetime);
     for (i = 0; i < 64; i++) {
-       r = (u_int32_t)random();
+       r = (uint32_t)random();
        (void) snprintf(path, 255, "%s/%s/%s.%08X", CONF.MAIL_DIR,
                        box, filetime, r);
        if ((fd = open(path, O_CREAT | O_EXCL | O_WRONLY, 00640)) != -1)
@@ -2393,7 +2395,7 @@ handleclient(unsigned long id, int fd, clientlistnode *clientlnode,
 
            /* Main state switcher loop */
            for (;;) {
-               u_int32_t chash;
+               uint32_t chash;
                register struct commandnode *nod;
 
                fdbflushw(fdb);
@@ -2409,7 +2411,7 @@ handleclient(unsigned long id, int fd, clientlistnode *clientlnode,
                    nod = NULL;
                    if ((chash = mm_strpack32(buffer, 4)) != 0)
                        nod = (struct commandnode *)hashtable_lookup(
-                               &command_table, &chash, sizeof(u_int32_t));
+                               &command_table, &chash, sizeof(uint32_t));
                    if (nod != NULL) {
                        register int (*func)(clientenv *);
 
@@ -2583,7 +2585,7 @@ async_resquery(struct async_msg *msg)
     struct async_resquery_msg *amsg = (void *)msg;
 
     amsg->un.res.res = res_query(amsg->un.args.host, amsg->un.args.r_class,
-           amsg->un.args.r_type, amsg->un.res.answer, 127);
+           amsg->un.args.r_type, (u_char *)amsg->un.res.answer, 127);
 }
 
 
@@ -2592,7 +2594,7 @@ async_resquery(struct async_msg *msg)
 
 static int
 a_res_query(clientenv *clenv, const char *dname, int class, int type,
-       u_char *answer, int anslen)
+       char *answer, int anslen)
 {
     struct async_resquery_msg *amsg = (void *)clenv->aclenv->msg;
     int res;
index 936b21b..69c8cf7 100644 (file)
@@ -1,4 +1,4 @@
-/* $Id: mmsmtpd.h,v 1.43 2007/09/17 06:08:11 mmondor Exp $ */
+/* $Id: mmsmtpd.h,v 1.44 2007/12/05 23:47:56 mmondor Exp $ */
 
 /*
  * Copyright (C) 2001-2007, Matthew Mondor
@@ -43,6 +43,8 @@
 /* HEADERS */
 
 #include <sys/types.h>
+#include <stdbool.h>
+#include <stdint.h>
 #include <time.h>
 
 #include <pthread.h>
@@ -171,7 +173,7 @@ typedef struct clientenv {
 typedef struct rcptnode {
     pnode_t node;
     char address[64], foraddress[64];
-    u_int64_t hash;
+    uint64_t hash;
     bool relay;                /* Non-local */
 } rcptnode;
 
@@ -217,7 +219,7 @@ struct box_info {
 /* For fast command lookup */
 struct commandnode {
     hashnode_t node;
-    u_int32_t hash;
+    uint32_t hash;
     struct command *command;
     int index;
 };
@@ -275,7 +277,7 @@ static int all_data(clientenv *);
 static int all_beer(clientenv *);
 
 static bool hash_commands(struct command *, size_t);
-static u_int32_t commandnode_keyhash(const void *, size_t);
+static uint32_t commandnode_keyhash(const void *, size_t);
 static int commandnode_keycmp(const void *, const void *, size_t);
 static bool reply(fdbuf *, int, bool, const char *, ...);
 
@@ -327,7 +329,7 @@ static void thread_mutex_unlock(void *);
 static bool thread_eintr(void);
 
 static void async_resquery(struct async_msg *);
-static int a_res_query(clientenv *, const char *, int, int, u_char *, int);
+static int a_res_query(clientenv *, const char *, int, int, char *, int);
 
 static void *hosts_expire_thread(void *);
 static bool hosts_expire_thread_iterator(hashnode_t *, void *);