* Removed simple_sprintf's %D param and am calling int_to_base64() directly now

* Cleaned up all the vsnprintf() calls to use sizeof(buf) not sizeof(buf) - 1
* Raise sprintf() max size to 4096


svn: 1995

src/base64.c

@@ -28,6 +28,70 @@ static const char base64r[256] = {
   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
 };
 
+static char base64to[256] =
+{
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0,
+  0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
+  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 62, 0, 63, 0, 0, 0, 26, 27, 28,
+  29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
+  49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
+  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+};
+
+
+int base64_to_int(char *buf)
+{
+  int i = 0;
+
+  while (*buf) {
+    i = i << 6;
+    i += base64to[(int) *buf];
+    buf++;
+  }
+  return i;
+}
+
+
+/* Thank you ircu :) */
+static char tobase64array[64] =
+{
+  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
+  'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
+  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
+  'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
+  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+  '[', ']'
+};
+
+char *int_to_base64(unsigned int val)
+{
+  static char buf_base64[12] = "";
+
+  buf_base64[11] = 0;
+  if (!val) {
+    buf_base64[10] = 'A';
+    return buf_base64 + 10;
+  }
+
+  int i = 11;
+
+  while (val) {
+    i--;
+    buf_base64[i] = tobase64array[val & 0x3f];
+    val = val >> 6;
+  }
+
+  return buf_base64 + i;
+}
+
+
 char *
 b64enc(const unsigned char *data, size_t len)
 {

src/base64.h

@@ -3,6 +3,9 @@
 
 #include <sys/types.h>
 
+char *int_to_base64(unsigned int);
+int base64_to_int(char *);
+
 char *b64enc(const unsigned char *data, size_t len);
 void b64enc_buf(const unsigned char *data, size_t len, char *dest);
 

src/botcmd.c

@@ -29,36 +29,6 @@
 
 static char TBUF[1024] = "";		/* Static buffer for goofy bot stuff */
 
-static char base64to[256] =
-{
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 0, 0,
-  0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
-  15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 62, 0, 63, 0, 0, 0, 26, 27, 28,
-  29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
-  49, 50, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-  0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
-};
-
-
-int base64_to_int(char *buf)
-{
-  int i = 0;
-
-  while (*buf) {
-    i = i << 6;
-    i += base64to[(int) *buf];
-    buf++;
-  }
-  return i;
-}
-
 static void fake_alert(int idx, char *item, char *extra)
 {
   static time_t lastfake;	/* The last time fake_alert was used */

src/botmsg.c

@@ -10,6 +10,7 @@
 
 #include "common.h"
 #include "misc.h"
+#include "base64.h"
 #include "dcc.h"
 #include "userrec.h"
 #include "main.h"
@@ -103,9 +104,9 @@ void botnet_send_chan(int idx, char *botnick, char *user, int chan, char *data)
     size_t len;
 
     if (user) {
-      len = simple_sprintf(OBUF, "c %s@%s %D %s\n", user, botnick, chan, data);
+      len = simple_sprintf(OBUF, "c %s@%s %s %s\n", user, botnick, int_to_base64(chan), data);
     } else {
-      len = simple_sprintf(OBUF, "c %s %D %s\n", botnick, chan, data);
+      len = simple_sprintf(OBUF, "c %s %s %s\n", botnick, int_to_base64(chan), data);
     }
     send_tand_but(idx, OBUF, len);
   }
@@ -117,9 +118,9 @@ void botnet_send_act(int idx, char *botnick, char *user, int chan, char *data)
     size_t len;
 
     if (user) {
-      len = simple_sprintf(OBUF, "a %s@%s %D %s\n", user, botnick, chan, data);
+      len = simple_sprintf(OBUF, "a %s@%s %s %s\n", user, botnick, int_to_base64(chan), data);
     } else {
-      len = simple_sprintf(OBUF, "a %s %D %s\n", botnick, chan, data);
+      len = simple_sprintf(OBUF, "a %s %s %s\n", botnick, int_to_base64(chan), data);
     }
     send_tand_but(idx, OBUF, len);
   }
@@ -145,16 +146,15 @@ void botnet_send_pong(int idx)
   tputs(dcc[idx].sock, "po\n", 3);
 }
 
-void botnet_send_priv (int idx, char *from, char *to, char *tobot, char *format, ...)
+void botnet_send_priv (int idx, char *from, char *to, char *tobot, const char *format, ...)
 {
   size_t len;
   char tbuf[1024] = "";
   va_list va;
 
   va_start(va, format);
-  egg_vsnprintf(tbuf, 450, format, va);
+  egg_vsnprintf(tbuf, sizeof(tbuf), format, va);
   va_end(va);
-  tbuf[sizeof(tbuf)-1] = 0;
 
   if (tobot) {
     len = simple_sprintf(OBUF, "p %s %s@%s %s\n", from, to, tobot, tbuf);
@@ -166,7 +166,7 @@ void botnet_send_priv (int idx, char *from, char *to, char *tobot, char *format,
 
 void botnet_send_who(int idx, char *from, char *to, int chan)
 {
-  size_t len = simple_sprintf(OBUF, "w %s %s %D\n", from, to, chan);
+  size_t len = simple_sprintf(OBUF, "w %s %s %s\n", from, to, int_to_base64(chan));
 
   tputs(dcc[idx].sock, OBUF, len);
 }
@@ -198,7 +198,7 @@ void botnet_send_nlinked(int idx, char *bot, char *next, char flag, int vlocalhu
 {
   if (tands > 0) {
     size_t len = simple_sprintf(OBUF, "n %s %s %cD0gc %d %d %s\n", bot, next, flag, 
-                                       vlocalhub, vbuildts, vversion ? vversion : "");
+                                       vlocalhub, (int) vbuildts, vversion ? vversion : "");
     send_tand_but(idx, OBUF, len);
   }
 }
@@ -222,7 +222,7 @@ void botnet_send_update(int idx, tand_t * ptr)
   if (tands > 0) {
     /* the D0gc is a lingering hack which probably will never be able to come out. */
     size_t len = simple_sprintf(OBUF, "u %s %cD0gc %d %d %s\n", ptr->bot, ptr->share, ptr->localhub, 
-                                                          ptr->buildts, ptr->version ? ptr->version : "");
+                                                          (int) ptr->buildts, ptr->version ? ptr->version : "");
     send_tand_but(idx, OBUF, len);
   }
 }
@@ -298,7 +298,7 @@ void botnet_send_cfg_broad(int idx, struct cfg_entry * entry) {
 void botnet_send_idle(int idx, char *bot, int sock, int idle, char *away)
 {
   if (tands > 0) {
-    size_t len = simple_sprintf(OBUF, "i %s %D %D %s\n", bot, sock, idle, away ? away : "");
+    size_t len = simple_sprintf(OBUF, "i %s %s %ss%s\n", bot, int_to_base64(sock), int_to_base64(idle), away ? away : "");
 
     send_tand_but(idx, OBUF, len);
   }
@@ -307,7 +307,8 @@ void botnet_send_idle(int idx, char *bot, int sock, int idle, char *away)
 void botnet_send_away(int idx, char *bot, int sock, char *msg, int linking)
 {
   if (tands > 0) {
-    size_t len = simple_sprintf(OBUF, "aw %s%s %D %s\n", ((idx >= 0) && linking) ? "!" : "", bot, sock, msg ? msg : "");
+    size_t len = simple_sprintf(OBUF, "aw %s%s %s %s\n", ((idx >= 0) && linking) ? "!" : "", bot, int_to_base64(sock), 
+                                msg ? msg : "");
 
     send_tand_but(idx, OBUF, len);
   }
@@ -316,12 +317,12 @@ void botnet_send_away(int idx, char *bot, int sock, char *msg, int linking)
 void botnet_send_join_idx(int useridx)
 {
   if (tands > 0) {
-    size_t len = simple_sprintf(OBUF, "j %s %s %D %c%D %s\n",
+    size_t len = simple_sprintf(OBUF, "j %s %s %s %c%s %s\n",
 		       conf.bot->nick, dcc[useridx].nick,
 		       dcc[useridx].type && dcc[useridx].type == &DCC_RELAYING ? 
-                         dcc[useridx].u.relay->chat->channel : 
-                         dcc[useridx].u.chat->channel, geticon(useridx),
-		       dcc[useridx].sock, dcc[useridx].host);
+                         int_to_base64(dcc[useridx].u.relay->chat->channel) : 
+                         int_to_base64(dcc[useridx].u.chat->channel), geticon(useridx),
+		         int_to_base64(dcc[useridx].sock), dcc[useridx].host);
 
     send_tand_but(-1, OBUF, len);
   }
@@ -330,10 +331,10 @@ void botnet_send_join_idx(int useridx)
 void botnet_send_join_party(int idx, int linking, int useridx)
 {
   if (tands > 0) {
-    size_t len = simple_sprintf(OBUF, "j %s%s %s %D %c%D %s\n", linking ? "!" : "",
+    size_t len = simple_sprintf(OBUF, "j %s%s %s %s %c%s %s\n", linking ? "!" : "",
 		       party[useridx].bot, party[useridx].nick,
-		       party[useridx].chan, party[useridx].flag,
-		       party[useridx].sock,
+		       int_to_base64(party[useridx].chan), party[useridx].flag,
+		       int_to_base64(party[useridx].sock),
 		       party[useridx].from ? party[useridx].from : "");
 
     send_tand_but(idx, OBUF, len);
@@ -343,8 +344,8 @@ void botnet_send_join_party(int idx, int linking, int useridx)
 void botnet_send_part_idx(int useridx, char *reason)
 {
   if (tands > 0) {
-    size_t len = simple_sprintf(OBUF, "pt %s %s %D %s\n", conf.bot->nick,
-			 dcc[useridx].nick, dcc[useridx].sock,
+    size_t len = simple_sprintf(OBUF, "pt %s %s %s %s\n", conf.bot->nick,
+			 dcc[useridx].nick, int_to_base64(dcc[useridx].sock),
 			 reason ? reason : "");
 
     send_tand_but(-1, OBUF, len);
@@ -354,9 +355,9 @@ void botnet_send_part_idx(int useridx, char *reason)
 void botnet_send_part_party(int idx, int partyidx, char *reason, int silent)
 {
   if (tands > 0) {
-    size_t len = simple_sprintf(OBUF, "pt %s%s %s %D %s\n",
+    size_t len = simple_sprintf(OBUF, "pt %s%s %s %s %s\n",
 		       silent ? "!" : "", party[partyidx].bot,
-		       party[partyidx].nick, party[partyidx].sock,
+		       party[partyidx].nick, int_to_base64(party[partyidx].sock),
 		       reason ? reason : "");
 
     send_tand_but(idx, OBUF, len);
@@ -366,7 +367,7 @@ void botnet_send_part_party(int idx, int partyidx, char *reason, int silent)
 void botnet_send_nkch(int useridx, char *oldnick)
 {
   if (tands > 0) {
-    size_t len = simple_sprintf(OBUF, "nc %s %D %s\n", conf.bot->nick, dcc[useridx].sock, dcc[useridx].nick);
+    size_t len = simple_sprintf(OBUF, "nc %s %s %s\n", conf.bot->nick, int_to_base64(dcc[useridx].sock), dcc[useridx].nick);
 
     send_tand_but(-1, OBUF, len);
   }
@@ -375,7 +376,7 @@ void botnet_send_nkch(int useridx, char *oldnick)
 void botnet_send_nkch_part(int butidx, int useridx, char *oldnick)
 {
   if (tands > 0) {
-    size_t len = simple_sprintf(OBUF, "nc %s %D %s\n", party[useridx].bot, party[useridx].sock, party[useridx].nick);
+    size_t len = simple_sprintf(OBUF, "nc %s %s %s\n", party[useridx].bot, int_to_base64(party[useridx].sock), party[useridx].nick);
 
     send_tand_but(butidx, OBUF, len);
   }

src/botnet.c

@@ -12,6 +12,7 @@
 
 #include "common.h"
 #include "botnet.h"
+#include "base64.h"
 #include "color.h"
 #include "chanprog.h"
 #include "net.h"
@@ -771,7 +772,7 @@ void dump_links(int z)
         p = bot->uplink->bot;
 
       l = simple_sprintf(x, "n %s %s %cD0gc %d %d %s\n", bot->bot, p, bot->share, bot->localhub, 
-                                                        bot->buildts, bot->version ? bot->version : "");
+                                                        (int) bot->buildts, bot->version ? bot->version : "");
       tputs(dcc[z].sock, x, l);
     }
   }
@@ -780,18 +781,28 @@ void dump_links(int z)
   for (i = 0; i < dcc_total; i++) {
     if (dcc[i].type && dcc[i].type == &DCC_CHAT && !dcc[i].simul) {
       if ((dcc[i].u.chat->channel >= 0) && (dcc[i].u.chat->channel < GLOBAL_CHANS)) {
-        l = simple_sprintf(x, "j !%s %s %D %c%D %s\n", conf.bot->nick, dcc[i].nick, dcc[i].u.chat->channel, geticon(i), dcc[i].sock, dcc[i].host);
+        l = simple_sprintf(x, "j !%s %s %s %c%s %s\n", conf.bot->nick, dcc[i].nick, 
+                               int_to_base64(dcc[i].u.chat->channel), geticon(i), 
+                               int_to_base64(dcc[i].sock), dcc[i].host);
 	tputs(dcc[z].sock, x, l);
-        l = simple_sprintf(x, "i %s %D %D %s\n", conf.bot->nick, dcc[i].sock, now - dcc[i].timeval, dcc[i].u.chat->away ? dcc[i].u.chat->away : "");
+        l = simple_sprintf(x, "i %s %s %s %s\n", conf.bot->nick, 
+                              int_to_base64(dcc[i].sock), 
+                              int_to_base64(now - dcc[i].timeval), 
+                              dcc[i].u.chat->away ? dcc[i].u.chat->away : "");
 	tputs(dcc[z].sock, x, l);
       }
     }
   }
   for (i = 0; i < parties; i++) {
-    l = simple_sprintf(x, "j %s %s %D %c%D %s\n", party[i].bot, party[i].nick, party[i].chan, party[i].flag, party[i].sock, party[i].from);
+    l = simple_sprintf(x, "j %s %s %s %c%s %s\n", party[i].bot, party[i].nick, 
+                          int_to_base64(party[i].chan), party[i].flag, 
+                          int_to_base64(party[i].sock), party[i].from);
     tputs(dcc[z].sock, x, l);
     if ((party[i].status & PLSTAT_AWAY) || (party[i].timer != 0)) {
-      l = simple_sprintf(x, "i %s %D %D %s\n", party[i].bot, party[i].sock, now - party[i].timer, party[i].away ? party[i].away : "");
+      l = simple_sprintf(x, "i %s %s %s %s\n", party[i].bot, 
+                             int_to_base64(party[i].sock), 
+                             int_to_base64(now - party[i].timer), 
+                             party[i].away ? party[i].away : "");
       tputs(dcc[z].sock, x, l);
     }
   }

src/cmds.c

@@ -2111,7 +2111,7 @@ static void cmd_trace(int idx, char *par)
 
   putlog(LOG_CMDS, "*", "#%s# trace %s", dcc[idx].nick, par);
   simple_sprintf(x, "%d:%s@%s", dcc[idx].sock, dcc[idx].nick, conf.bot->nick);
-  simple_sprintf(y, ":%d", now);
+  sprintf(y, ":%li", now);
   botnet_send_trace(i, x, par, y);
 }
 

src/dccutil.c

@@ -223,7 +223,7 @@ dprintf(int idx, const char *format, ...)
   va_list va;
 
   va_start(va, format);
-  egg_vsnprintf(buf, 1023, format, va);
+  egg_vsnprintf(buf, sizeof(buf), format, va);
   va_end(va);
   /* We can not use the return value vsnprintf() to determine where
    * to null terminate. The C99 standard specifies that vsnprintf()
@@ -233,7 +233,6 @@ dprintf(int idx, const char *format, ...)
   /* We actually can, since if it's < 0 or >= sizeof(buf), we know it wrote
    * sizeof(buf) bytes. But we're not doing that anyway.
    */
-  buf[sizeof(buf) - 1] = 0;
   len = strlen(buf);
 
 /* this is for color on dcc :P */
@@ -310,11 +309,11 @@ dprintf(int idx, const char *format, ...)
 void
 chatout(const char *format, ...)
 {
-  char s[1025] = "", *p = NULL;
+  char s[1024] = "", *p = NULL;
   va_list va;
 
   va_start(va, format);
-  egg_vsnprintf(s, 1024, format, va);
+  egg_vsnprintf(s, sizeof(s), format, va);
   va_end(va);
 
   if ((p = strrchr(s, '\n')))
@@ -331,11 +330,11 @@ chatout(const char *format, ...)
 void
 chanout_but(int x, int chan, const char *format, ...)
 {
-  char s[1025] = "", *p = NULL;
+  char s[1024] = "", *p = NULL;
   va_list va;
 
   va_start(va, format);
-  egg_vsnprintf(s, 1024, format, va);
+  egg_vsnprintf(s, sizeof(s), format, va);
   va_end(va);
 
   if ((p = strrchr(s, '\n')))

src/debug.c

@@ -85,14 +85,14 @@ void init_debug()
 #endif /* DEBUG_CONTEXT */
 }
 
-void sdprintf (char *format, ...)
+void sdprintf (const char *format, ...)
 {
   if (sdebug) {
     char s[2001] = "";
     va_list va;
 
     va_start(va, format);
-    egg_vsnprintf(s, 2000, format, va);
+    egg_vsnprintf(s, sizeof(s), format, va);
     va_end(va);
     
     remove_crlf(s);

src/debug.h

@@ -34,7 +34,7 @@ extern bool		sdebug;
 
 void stackdump(int);
 void setlimits();
-void sdprintf (char *, ...) __attribute__((format(printf, 1, 2)));
+void sdprintf (const char *, ...) __attribute__((format(printf, 1, 2)));
 void init_signals();
 void init_debug();
 void eggContext(const char *, int);

src/enclink.c

@@ -240,7 +240,7 @@ void ghost_parse(int idx, int snum, char *buf)
   }
 }
 
-void link_send(int idx, char *format, ...)
+void link_send(int idx, const char *format, ...)
 {
   char s[2001] = "";
   va_list va;

src/enclink.h

@@ -40,7 +40,7 @@ extern void link_link(int, int, int, direction_t);
 extern char *link_write(int, char *, size_t *);
 extern int link_read(int, char *, size_t *);
 extern void link_hash(int, char *);
-extern void link_send(int, char *, ...) __attribute__((format(printf, 2, 3)));
+extern void link_send(int, const char *, ...) __attribute__((format(printf, 2, 3)));
 extern void link_done(int);
 extern void link_parse(int, char *);
 

src/log.c

@@ -123,7 +123,7 @@ void logidx(int idx, const char *format, ...)
   va_list va;
 
   va_start(va, format);
-  egg_vsnprintf(va_out, LOGLINEMAX, format, va);
+  egg_vsnprintf(va_out, sizeof(va_out), format, va);
   va_end(va);
 
   if (idx < 0)
@@ -142,11 +142,7 @@ void putlog(int type, const char *chname, const char *format, ...)
   va_list va;
 
   va_start(va, format);
-
-  /* No need to check if out should be null-terminated here,
-   * just do it! <cybah>
-   */
-  egg_vsnprintf(va_out, LOGLINEMAX, format, va);
+  egg_vsnprintf(va_out, sizeof(va_out), format, va);
   va_end(va);
 
   if (!va_out[0]) {
@@ -219,7 +215,7 @@ irc_log(struct chanset_t *chan, const char *format, ...)
   va_list va;
 
   va_start(va, format);
-  egg_vsnprintf(va_out, LOGLINEMAX, format, va);
+  egg_vsnprintf(va_out, sizeof(va_out), format, va);
   va_end(va);
 
   if ((chan && egg_strcasecmp(chan->dname, "#!obs")) || !chan)

src/mod/irc.mod/msgcmds.c

@@ -192,9 +192,9 @@ static int msg_invite(char *nick, char *host, struct userrec *u, char *par)
   return BIND_RET_BREAK;
 }
 
-static void reply(char *, struct chanset_t *, char *, ...) __attribute__((format(printf, 3, 4)));
+static void reply(char *, struct chanset_t *, const char *, ...) __attribute__((format(printf, 3, 4)));
 
-static void reply(char *nick, struct chanset_t *chan, char *format, ...)
+static void reply(char *nick, struct chanset_t *chan, const char *format, ...)
 {
   va_list va;
   char buf[1024] = "";

src/mod/server.mod/servmsg.c

@@ -1065,10 +1065,10 @@ static int whoispenalty(char *from, char *msg)
   return 0;
 }
 
-static void irc_whois(char *, char *, ...) __attribute__((format(printf, 2, 3)));
+static void irc_whois(char *, const char *, ...) __attribute__((format(printf, 2, 3)));
 
 static void
-irc_whois(char *nick, char *format, ...)
+irc_whois(char *nick, const char *format, ...)
 {
   char va_out[2001] = "";
   va_list va;

src/sprintf.c

@@ -7,39 +7,6 @@
 #include "sprintf.h"
 #include <stdarg.h>
 
-
-/* Thank you ircu :) */
-static char tobase64array[64] =
-{
-  'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
-  'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
-  'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
-  'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
-  '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-  '[', ']'
-};
-
-static char *int_to_base64(unsigned int val)
-{
-  static char buf_base64[12] = "";
-
-  buf_base64[11] = 0;
-  if (!val) {
-    buf_base64[10] = 'A';
-    return buf_base64 + 10;
-  }
-
-  int i = 11;
-
-  while (val) {
-    i--;
-    buf_base64[i] = tobase64array[val & 0x3f];
-    val = val >> 6;
-  }
-
-  return buf_base64 + i;
-}
-
 static char *int_to_base10(int val)
 {
   static char buf_base10[17] = "";
@@ -89,14 +56,14 @@ static char *unsigned_int_to_base10(unsigned int val)
   return buf_base10 + i;
 }
 
-static size_t simple_vsnprintf(char *buf, size_t size, const char *format, va_list va)
+size_t simple_vsnprintf(char *buf, size_t size, const char *format, va_list va)
 {
   char *s = NULL;
   char *fp = (char *) format;
   size_t c = 0;
   unsigned int i;
 
-  while (*fp && c < size) {
+  while (*fp && c < size - 1) {
     if (*fp == '%') {
       fp++;
       switch (*fp) {
@@ -108,10 +75,6 @@ static size_t simple_vsnprintf(char *buf, size_t size, const char *format, va_li
         i = va_arg(va, int);
         s = int_to_base10(i);
         break;
-      case 'D':
-        i = va_arg(va, int);
-        s = int_to_base64((unsigned int) i);
-        break;
       case 'u':
         i = va_arg(va, unsigned int);
         s = unsigned_int_to_base10(i);
@@ -127,7 +90,7 @@ static size_t simple_vsnprintf(char *buf, size_t size, const char *format, va_li
         continue;
       }
       if (s)
-        while (*s && c < size)
+        while (*s && c < size - 1)
           buf[c++] = *s++;
       fp++;
     } else
@@ -138,9 +101,9 @@ static size_t simple_vsnprintf(char *buf, size_t size, const char *format, va_li
   return c;
 }
 
-static size_t simple_vsprintf(char *buf, const char *format, va_list va)
+size_t simple_vsprintf(char *buf, const char *format, va_list va)
 {
-  return simple_vsnprintf(buf, VSPRINTF_SIZE, format, va);
+  return simple_vsnprintf(buf, VSPRINTF_MAXSIZE, format, va);
 }
 
 size_t simple_sprintf (char *buf, const char *format, ...)

src/sprintf.h

@@ -3,13 +3,13 @@
 
 
 #include <sys/types.h>
+#include <stdarg.h>
 
-#define VSPRINTF_SIZE		2047
+#define VSPRINTF_MAXSIZE		4096
 
-size_t simple_sprintf (char *, const char *, ...);
-size_t simple_snprintf (char *, size_t, const char *, ...);
-//char *int_to_base10(int);
-//char *unsigned_int_to_base10(unsigned int);
-//char *int_to_base64(unsigned int);
+size_t simple_vsnprintf(char *, size_t, const char *, va_list);
+size_t simple_vsprintf(char *, const char *, va_list);
+size_t simple_sprintf (char *, const char *, ...) __attribute__((format(printf, 2, 3)));
+size_t simple_snprintf (char *, size_t, const char *, ...) __attribute__((format(printf, 3, 4)));
 
 #endif /* _SPRINTF_H */

src/tandem.h

@@ -48,7 +48,7 @@ void botnet_send_chat(int, char *, char *);
 void botnet_send_act(int, char *, char *, int, char *);
 void botnet_send_ping(int);
 void botnet_send_pong(int);
-void botnet_send_priv (int, char *, char *, char *, char *, ...) __attribute__((format(printf, 5, 6)));
+void botnet_send_priv (int, char *, char *, char *, const char *, ...) __attribute__((format(printf, 5, 6)));
 void botnet_send_who(int, char *, char *, int);
 void botnet_send_unlinked(int, char *, char *);
 void botnet_send_traced(int, char *, char *);