Merge.

diff --git a/core/nsmalloc.h b/core/nsmalloc.h
index 47d69684174d743cfc9e068e427e0a6b4e20b756..9d77a147e78b46cae238b65b2b81e8bf4e85ee15 100644 (file)
--- a/core/nsmalloc.h
+++ b/core/nsmalloc.h
@@ -23,3 +23,4 @@ int nspoolstats(unsigned int poolid, size_t *size, unsigned long *count);
 #define POOL_PROXYSCAN         8
 #define POOL_LUA               9
 #define POOL_TROJANSCAN                10
+#define POOL_NTERFACER         11

diff --git a/lua/nterfacer_lua.c b/lua/nterfacer_lua.c
index 709db101277b3dc38e71bebb6ad1d72614b9d672..6822f0a7a0db371bab262978be6f8f0ada5e4b36 100644 (file)
--- a/lua/nterfacer_lua.c
+++ b/lua/nterfacer_lua.c
@@ -7,8 +7,8 @@
 
 #include "../lua/lua.h"
 
-#include "../nterface/library.h"
-#include "../nterface/nterfacer.h"
+#include "../nterfacer/library.h"
+#include "../nterfacer/nterfacer.h"
 
 MODULE_VERSION("");
 

diff --git a/nterface/Makefile b/nterfacer/Makefile
similarity index 100%
rename from nterface/Makefile
rename to nterfacer/Makefile

diff --git a/nterface/esockets.c b/nterfacer/esockets.c
similarity index 94%
rename from nterface/esockets.c
rename to nterfacer/esockets.c
index 95a09b2a6f1f7e4c6cd95cc0e235105253cb4308..9f66679f93e8b71fc6839377ff21f04d40605437 100644 (file)
--- a/nterface/esockets.c
+++ b/nterfacer/esockets.c
@@ -29,7 +29,7 @@ unsigned short esocket_token(void) {
 
 struct esocket *esocket_add(int fd, char socket_type, struct esocket_events *events, unsigned short token) {
   int flags;
-  struct esocket *newsock = (struct esocket *)malloc(sizeof(struct esocket));
+  struct esocket *newsock = (struct esocket *)ntmalloc(sizeof(struct esocket));
   if(!newsock)
     return NULL;
 
@@ -182,17 +182,17 @@ void esocket_disconnect(struct esocket *active) {
 
       for(;pkt;) {
         npkt = pkt->next;
-        free(pkt->line);
-        free(pkt);
+        ntfree(pkt->line);
+        ntfree(pkt);
         pkt = npkt;
       }
 
       if(p->in.data)
-        free(p->in.data);
+        ntfree(p->in.data);
       if(p->in.cryptobuf)
-        free(p->in.cryptobuf);
+        ntfree(p->in.cryptobuf);
 
-      free(p);
+      ntfree(p);
       break;
     }  
 }
@@ -250,7 +250,7 @@ int crypto_newblock(struct esocket *sock, unsigned char *block) {
     sock->clientseqno++;
 
     ret = sock->events.on_line(sock, (char *)buf->cryptobuf);
-    free(buf->cryptobuf);
+    ntfree(buf->cryptobuf);
     buf->cryptobuf = NULL;
     buf->cryptobufsize = 0;
     buf->mac = 0;
@@ -267,9 +267,9 @@ int crypto_newblock(struct esocket *sock, unsigned char *block) {
     }
   }
 
-  p2 = realloc(buf->cryptobuf, buf->cryptobufsize + 16);
+  p2 = ntrealloc(buf->cryptobuf, buf->cryptobufsize + 16);
   if(!p2)
-    Error("nterface", ERR_STOP, "realloc() failed in crypto_newblock (esockets.c)");
+    Error("nterface", ERR_STOP, "ntrealloc() failed in crypto_newblock (esockets.c)");
   buf->cryptobuf = p2;
 
   memcpy(p2 + buf->cryptobufsize, p, 16);
@@ -304,9 +304,9 @@ int esocket_read(struct esocket *sock) {
   if((bytesread == -1) && (errno == EAGAIN))
     return 0;
 
-  p = realloc(buf->data, buf->size + bytesread);
+  p = ntrealloc(buf->data, buf->size + bytesread);
   if(!p)
-    Error("nterface", ERR_STOP, "realloc() failed in esocket_read (esockets.c)");
+    Error("nterface", ERR_STOP, "ntrealloc() failed in esocket_read (esockets.c)");
 
   buf->data = p;
   memcpy(buf->data + buf->size, bufd, bytesread);
@@ -321,13 +321,13 @@ int esocket_read(struct esocket *sock) {
 
     if(strip > 0) {
       if(buf->size - strip == 0) {
-        free(buf->data);
+        ntfree(buf->data);
         buf->data = NULL;
       } else {
         memmove(buf->data, buf->data + strip, buf->size - strip);
-        p = realloc(buf->data, buf->size - strip);
+        p = ntrealloc(buf->data, buf->size - strip);
         if(!p)
-          Error("nterface", ERR_STOP, "realloc() failed in esocket_read (esockets.c)");
+          Error("nterface", ERR_STOP, "ntrealloc() failed in esocket_read (esockets.c)");
 
         buf->data = p;
       }
@@ -348,13 +348,13 @@ struct esocket_packet *esocket_new_packet(struct esocket_out_buffer *buf, char *
   if(buf->count == MAX_OUT_QUEUE_SIZE)
     return NULL;
 
-  nw = malloc(sizeof(struct esocket_packet));
+  nw = ntmalloc(sizeof(struct esocket_packet));
   if(!nw)
     return NULL;
 
-  nw->line = malloc(bytes);
+  nw->line = ntmalloc(bytes);
   if(!nw->line) {
-    free(nw);
+    ntfree(nw);
     return NULL;
   }
 
@@ -426,8 +426,8 @@ int esocket_raw_write(struct esocket *sock, char *buffer, int bytes) {
         struct esocket_packet *p = buf->head;
         buf->head = buf->head->next;
 
-        free(p->line);
-        free(p);
+        ntfree(p->line);
+        ntfree(p);
 
         buf->count--;
         if(!buf->head) { /* if we've exhausted the buffer */

diff --git a/nterface/esockets.h b/nterfacer/esockets.h
similarity index 100%
rename from nterface/esockets.h
rename to nterfacer/esockets.h

diff --git a/nterface/library.c b/nterfacer/library.c
similarity index 98%
rename from nterface/library.c
rename to nterfacer/library.c
index dbc8b3e880da020f51b84ebfafc1ce5404acf34d..b43faa17425ef71035a9a71360769498d93e65fb 100644 (file)
--- a/nterface/library.c
+++ b/nterfacer/library.c
@@ -205,7 +205,7 @@ char *request_error(int errn) {
 }
 
 rijndaelcbc *rijndaelcbc_init(unsigned char *key, int keybits, unsigned char *iv, int decrypt) {
-  rijndaelcbc *ret = (rijndaelcbc *)malloc(sizeof(rijndaelcbc) + RKLENGTH(keybits) * sizeof(unsigned long));
+  rijndaelcbc *ret = (rijndaelcbc *)ntmalloc(sizeof(rijndaelcbc) + RKLENGTH(keybits) * sizeof(unsigned long));
   if(!ret)
     return NULL;
 
@@ -222,7 +222,7 @@ rijndaelcbc *rijndaelcbc_init(unsigned char *key, int keybits, unsigned char *iv
 }
 
 void rijndaelcbc_free(rijndaelcbc *c) {
-  free(c);
+  ntfree(c);
 }
 
 unsigned char *rijndaelcbc_encrypt(rijndaelcbc *c, unsigned char *ptblock) {

diff --git a/nterface/library.h b/nterfacer/library.h
similarity index 94%
rename from nterface/library.h
rename to nterfacer/library.h
index d35ca0aa6b80ed06ebc2d512fbb46ce2e67bb3fe..7922e81f83c2ebb7b94e93df288030da61fd7ae6 100644 (file)
--- a/nterface/library.h
+++ b/nterfacer/library.h
@@ -7,6 +7,7 @@
 #define __nterface_library_H
 
 #include "../core/error.h"
+#include "../core/nsmalloc.h"
 
 #include "../lib/sha2.h"
 
@@ -67,4 +68,8 @@ unsigned char *rijndaelcbc_encrypt(rijndaelcbc *c, unsigned char *ptblock);
 void rijndaelcbc_free(rijndaelcbc *c);
 rijndaelcbc *rijndaelcbc_init(unsigned char *key, int keybits, unsigned char *iv, int decrypt);
 
+#define ntmalloc(x)  nsmalloc(POOL_NTERFACER, x)
+#define ntfree(x)    nsfree(POOL_NTERFACER, x)
+#define ntrealloc(x, y) nsrealloc(POOL_NTERFACER, x, y)
+
 #endif

diff --git a/nterface/logging.c b/nterfacer/logging.c
similarity index 95%
rename from nterface/logging.c
rename to nterfacer/logging.c
index c7b9d7fd22c5da19b8567dfe78e752f1152885a3..693bdaeb2033c745548dc80926b507b2063ff38d 100644 (file)
--- a/nterface/logging.c
+++ b/nterfacer/logging.c
@@ -70,12 +70,12 @@ void nterface_rotate_log(void *arg) {
   if(!us)
     return;
 
-  filename = malloc(filenamelen);
+  filename = ntmalloc(filenamelen);
   MemCheck(filename);
-  filename2 = malloc(filenamelen);
+  filename2 = ntmalloc(filenamelen);
   if(!filename2) {
     MemError();
-    free(filename);
+    ntfree(filename);
     return;
   }
 
@@ -128,8 +128,8 @@ void nterface_rotate_log(void *arg) {
     unlink(filename);
   }
 
-  free(filename);
-  free(filename2);
+  ntfree(filename);
+  ntfree(filename2);
 }
 
 int direxists(char *filename) {
@@ -140,7 +140,7 @@ int direxists(char *filename) {
 
   if(lastp) {
     int ret = 0;
-    char *newp = malloc(lastp - filename + 1);
+    char *newp = ntmalloc(lastp - filename + 1);
     if(!newp) {
       MemError();
       return 0;
@@ -155,7 +155,7 @@ int direxists(char *filename) {
       ret = mkdir(newp, DIR_PERMISSIONS);
     }
 
-    free(newp);
+    ntfree(newp);
     if(ret)
       return 0;
   }
@@ -163,20 +163,20 @@ int direxists(char *filename) {
 }
 
 struct nterface_auto_log *nterface_open_log(char *name, char *filename, int debug) {
-  struct nterface_auto_log *us = malloc(sizeof(struct nterface_auto_log));
+  struct nterface_auto_log *us = ntmalloc(sizeof(struct nterface_auto_log));
   MemCheckR(us, NULL);
 
   us->filename = getsstring(filename, strlen(filename));
   if(!us->filename) {
     MemError();
-    free(us);
+    ntfree(us);
   }
 
   us->name = getsstring(name, strlen(name));
   if(!us->name) {
     MemError();
     freesstring(us->filename);
-    free(us);
+    ntfree(us);
   }
 
   if(direxists(filename)) {
@@ -209,7 +209,7 @@ struct nterface_auto_log *nterface_close_log(struct nterface_auto_log *ourlog) {
     nterface_log(ourlog, NL_SYSTEM, "Log closed");
     if(ourlog->log)
       fclose(ourlog->log);
-    free(ourlog);
+    ntfree(ourlog);
   }
   return NULL;
 }

diff --git a/nterface/logging.h b/nterfacer/logging.h
similarity index 100%
rename from nterface/logging.h
rename to nterfacer/logging.h

diff --git a/nterface/nterfacer.c b/nterfacer/nterfacer.c
similarity index 95%
rename from nterface/nterfacer.c
rename to nterfacer/nterfacer.c
index 7a3513a32871fa8582b7c12a06d70adb58a4a6f8..cf95e8f86a4fbab2040defbf6f39cf9801567471 100644 (file)
--- a/nterface/nterfacer.c
+++ b/nterfacer/nterfacer.c
@@ -81,7 +81,7 @@ void _init(void) {
 
 void free_handler(struct handler *hp) {
   freesstring(hp->command);
-  free(hp);
+  ntfree(hp);
 }
 
 void free_handlers(struct service_node *tp) {
@@ -107,7 +107,7 @@ void _fini(void) {
     lp = tp;
     tp = tp->next;
     free_handlers(lp);
-    free(lp);
+    ntfree(lp);
   }
   tree = NULL;
 
@@ -122,7 +122,7 @@ void _fini(void) {
       freesstring(permits[i].hostname);
       freesstring(permits[i].password);
     }
-    free(permits);
+    ntfree(permits);
     permit_count = 0;
     permits = NULL;
   }
@@ -151,7 +151,8 @@ int load_permits(void) {
   hostnames = (sstring **)hostnamesa->content;
   passwords = (sstring **)passwordsa->content;
 
-  new_permits = calloc(hostnamesa->cursi, sizeof(struct permitted));
+  new_permits = ntmalloc(hostnamesa->cursi * sizeof(struct permitted));
+  memset(new_permits, 0, hostnamesa->cursi * sizeof(struct permitted));
   item = new_permits;
 
   for(i=0;i<hostnamesa->cursi;i++) {
@@ -185,14 +186,14 @@ int load_permits(void) {
   }
 
   if(!loaded_lines) {
-    free(new_permits);
+    ntfree(new_permits);
     return 0;
   }
 
-  resized = realloc(new_permits, sizeof(struct permitted) * loaded_lines);
+  resized = ntrealloc(new_permits, sizeof(struct permitted) * loaded_lines);
   if(!resized) {
     MemError();
-    free(new_permits);
+    ntfree(new_permits);
     return 0;
   }
   permits = resized;
@@ -240,13 +241,13 @@ int setup_listening_socket(void) {
 }
 
 struct service_node *register_service(char *name) {
-  struct service_node *np = malloc(sizeof(service_node));
+  struct service_node *np = ntmalloc(sizeof(service_node));
   MemCheckR(np, NULL);
 
   np->name = getsstring(name, strlen(name));
   if(!np->name) {
     MemError();
-    free(np);
+    ntfree(np);
     return NULL;
   }
 
@@ -258,13 +259,13 @@ struct service_node *register_service(char *name) {
 }
 
 struct handler *register_handler(struct service_node *service, char *command, int args, handler_function fp) {
-  struct handler *hp = malloc(sizeof(handler));
+  struct handler *hp = ntmalloc(sizeof(handler));
   MemCheckR(hp, NULL);
 
   hp->command = getsstring(command, strlen(command));
   if(!hp->command) {
     MemError();
-    free(hp);
+    ntfree(hp);
     return NULL;
   }
 
@@ -318,11 +319,11 @@ void deregister_service(struct service_node *service) {
     if(li->service == service) {
       if(pi) {
         pi->next = li->next;
-        free(li);
+        ntfree(li);
         li = pi->next;
       } else {
         rlines = li->next;
-        free(li);
+        ntfree(li);
         li = rlines;
       }
     } else {
@@ -331,7 +332,7 @@ void deregister_service(struct service_node *service) {
   }
   freesstring(service->name);
 
-  free(service);
+  ntfree(service);
 }
 
 void nterfacer_accept_event(struct esocket *socket) {
@@ -367,7 +368,7 @@ void nterfacer_accept_event(struct esocket *socket) {
     return;
   }
 
-  temp = (struct sconnect *)malloc(sizeof(struct sconnect));
+  temp = (struct sconnect *)ntmalloc(sizeof(struct sconnect));
   if(!temp) {
     MemError();
     close(newfd);
@@ -378,7 +379,7 @@ void nterfacer_accept_event(struct esocket *socket) {
 
   newsocket = esocket_add(newfd, ESOCKET_UNIX_DOMAIN_CONNECTED, &nterfacer_events, nterfacer_token);
   if(!newsocket) {
-    free(temp);
+    ntfree(temp);
     close(newfd);
     return;
   }
@@ -592,7 +593,7 @@ int nterfacer_new_rline(char *line, struct esocket *socket, int *number) {
     return RE_COMMAND_NOT_FOUND;
 
   if(argcount) {
-    parsebuf = (char *)malloc(strlen(pp) + 1);
+    parsebuf = (char *)ntmalloc(strlen(pp) + 1);
     MemCheckR(parsebuf, RE_MEM_ERROR);
     newp = parsebuf;
   
@@ -608,7 +609,7 @@ int nterfacer_new_rline(char *line, struct esocket *socket, int *number) {
         *newp++ = '\0';
         args[argcount++] = newp;
         if(argcount > MAX_ARGS) {
-          free(parsebuf);
+          ntfree(parsebuf);
           return RE_TOO_MANY_ARGS;
         }
       } else {
@@ -619,15 +620,15 @@ int nterfacer_new_rline(char *line, struct esocket *socket, int *number) {
   }
   if(argcount < hl->args) {
     if(argcount && parsebuf)
-      free(parsebuf);
+      ntfree(parsebuf);
     return RE_WRONG_ARG_COUNT;
   }
 
-  prequest = (struct rline *)malloc(sizeof(struct rline));
+  prequest = (struct rline *)ntmalloc(sizeof(struct rline));
   if(!prequest) {
     MemError();
     if(argcount && parsebuf)
-      free(parsebuf);
+      ntfree(parsebuf);
     return RE_MEM_ERROR;
   }
 
@@ -644,7 +645,7 @@ int nterfacer_new_rline(char *line, struct esocket *socket, int *number) {
   re = (hl->function)(prequest, argcount, args);
   
   if(argcount && parsebuf)
-    free(parsebuf);
+    ntfree(parsebuf);
 
   return re;
 }
@@ -661,7 +662,7 @@ void nterfacer_disconnect_event(struct esocket *sock) {
     if(li->socket->tag == socket)
       li->socket = NULL;
 
-  free(socket);
+  ntfree(socket);
 }
 
 int ri_append(struct rline *li, char *format, ...) {
@@ -723,7 +724,7 @@ int ri_error(struct rline *li, int error_code, char *format, ...) {
       } else {
         rlines = li->next;
       }
-      free(li);
+      ntfree(li);
       break;
     }
   }
@@ -746,7 +747,7 @@ int ri_final(struct rline *li) {
       } else {
         rlines = li->next;
       }
-      free(li);
+      ntfree(li);
       break;
     }
   }

diff --git a/nterface/nterfacer.h b/nterfacer/nterfacer.h
similarity index 100%
rename from nterface/nterfacer.h
rename to nterfacer/nterfacer.h

diff --git a/nterface/nterfacer_chanstats.c b/nterfacer/nterfacer_chanstats.c
similarity index 100%
rename from nterface/nterfacer_chanstats.c
rename to nterfacer/nterfacer_chanstats.c

diff --git a/nterface/nterfacer_control.c b/nterfacer/nterfacer_control.c
similarity index 100%
rename from nterface/nterfacer_control.c
rename to nterfacer/nterfacer_control.c

diff --git a/nterface/nterfacer_control.h b/nterfacer/nterfacer_control.h
similarity index 100%
rename from nterface/nterfacer_control.h
rename to nterfacer/nterfacer_control.h

diff --git a/nterface/nterfacer_country.c b/nterfacer/nterfacer_country.c
similarity index 100%
rename from nterface/nterfacer_country.c
rename to nterfacer/nterfacer_country.c

diff --git a/nterface/nterfacer_relay.c b/nterfacer/nterfacer_relay.c
similarity index 98%
rename from nterface/nterfacer_relay.c
rename to nterfacer/nterfacer_relay.c
index d526f1ab56ecab214872c5008d8195e4f231d413..988dcddeb1c66c7d879e195b1faffff55c2fc51b 100644 (file)
--- a/nterface/nterfacer_relay.c
+++ b/nterfacer/nterfacer_relay.c
@@ -213,7 +213,7 @@ int relay_handler(struct rline *ri, int argc, char **argv) {
     if(strchr(argv[i], '\r'))
       return ri_error(ri, RELAY_INVALID_CHARS, "Invalid character in input");
 
-  np = malloc(sizeof(struct rld));
+  np = ntmalloc(sizeof(struct rld));
   MemCheckR(np, ri_error(ri, RELAY_MEMORY_ERROR, "Memory error"));
 
   np->rline = ri;
@@ -221,13 +221,13 @@ int relay_handler(struct rline *ri, int argc, char **argv) {
      np->termination.pcre.phrase = pcre_compile(argv[1], PCRE_FLAGS, &rerror, &erroroffset, NULL);
     if(!np->termination.pcre.phrase) {
       MemError();
-      free(np);
+      ntfree(np);
       return ri_error(ri, RELAY_REGEX_ERROR, "Regex compliation error");
     }
     np->termination.pcre.hint = pcre_study(np->termination.pcre.phrase, 0, &rerror);
     if(rerror) {
       pcre_free(np->termination.pcre.phrase);
-      free(np);
+      ntfree(np);
       return ri_error(ri, RELAY_REGEX_HINT_ERROR, "Regex hint error");
     }
 
@@ -243,7 +243,7 @@ int relay_handler(struct rline *ri, int argc, char **argv) {
       if(np->termination.pcre.hint)
         pcre_free(np->termination.pcre.hint);
     }
-    free(np);
+    ntfree(np);
     return ri_error(ri, RELAY_NICK_ERROR, "Unable to get a nickname!");
   }
 
@@ -256,7 +256,7 @@ int relay_handler(struct rline *ri, int argc, char **argv) {
         pcre_free(np->termination.pcre.hint);
     }
     deregisterlocaluser(np->nick, NULL);
-    free(np);
+    ntfree(np);
     return ri_error(ri, RELAY_MEMORY_ERROR, "Memory error");
   }
 
@@ -296,7 +296,7 @@ int stats_handler(struct rline *ri, int argc, char **argv) {
     more = NULL;
   }
 
-  np = malloc(sizeof(struct rld));
+  np = ntmalloc(sizeof(struct rld));
   MemCheckR(np, ri_error(ri, RELAY_MEMORY_ERROR, "Memory error"));
 
   np->rline = ri;
@@ -304,7 +304,7 @@ int stats_handler(struct rline *ri, int argc, char **argv) {
   np->dest = NULL;
 
   if(!(np->nick = relay_getnick())) {
-    free(np);
+    ntfree(np);
     return ri_error(ri, RELAY_NICK_ERROR, "Unable to get a nickname!");
   }
 
@@ -312,7 +312,7 @@ int stats_handler(struct rline *ri, int argc, char **argv) {
   if(!np->schedule) {
     MemError();
     deregisterlocaluser(np->nick, NULL);
-    free(np);
+    ntfree(np);
   }
 
   np->next = list;
@@ -419,7 +419,7 @@ void dispose_rld_dontquit(struct rld *item, int dontquit) {
     if(item->termination.pcre.hint)
       pcre_free(item->termination.pcre.hint);
   }
-  free(item);
+  ntfree(item);
 }
 
 void relay_timeout(void *arg) {

diff --git a/nterface/nterfacer_relay.h b/nterfacer/nterfacer_relay.h
similarity index 100%
rename from nterface/nterfacer_relay.h
rename to nterfacer/nterfacer_relay.h

diff --git a/nterface/nterfacer_spamscan2.c b/nterfacer/nterfacer_spamscan2.c
similarity index 100%
rename from nterface/nterfacer_spamscan2.c
rename to nterfacer/nterfacer_spamscan2.c