* Setup the read/write encrypt/decrypt functions to work through the new link encryption system

svn: 1647

src/dcc.c

@@ -298,7 +298,12 @@ cont_link(int idx, char *buf, int ii)
   if (ii == 2) {
     dprintf(idx, "%s\n", conf.bot->nick);
 
-    enclink_call(idx, LINK_GHOST, TO);
+    int snum = findanysnum(dcc[idx].sock);
+
+    if (snum >= 0) {
+      socklist[snum].enclink = link_find_by_type(LINK_GHOST);
+      link_link(idx, LINK_GHOST, TO);
+    }
 
     /* wait for "elink" now */
   } else if (ii == 3) {			/* new hub response */
@@ -347,27 +352,25 @@ dcc_bot_new(int idx, char *buf, int x)
     int snum = findanysnum(dcc[idx].sock);
 
     if (snum >= 0) {
-      int i = 0, type = 0;
       char *tmp = strdup(buf), *tmpp = tmp, *p = NULL;
+      int i = -1;
 
-      while ((p = strchr(buf, ' ')) && !type) {
+      while ((p = strchr(buf, ' ')) && i == -1) {
         *p = 0;
 
         /* pick the first (lowest num) one that we share */
-        for (i = 0; enclink[i].name; i++) {
-          if (atoi(tmp) == enclink[i].type) {
-            type = i;
-            break;
-          }
-        }
+        if ((i = link_find_by_type(atoi(tmp))) != -1)
+          break;
+
         tmp = p++;
       }
       free(tmpp);
 
-      sdprintf("Choosing '%s' for link", enclink[type].name);
-      dprintf(idx, "neg %d\n", type);
-      socklist[snum].enctype = type;
-      (enclink[type].func) (idx, TO);	
+      sdprintf("Choosing '%s' for link", enclink[i].name);
+      dprintf(idx, "neg %d\n", enclink[i].type);
+      socklist[snum].enclink = i;
+      if (enclink[i].link)
+        (enclink[i].link) (idx, TO);	
     }
   } else if (!egg_strcasecmp(code, "error")) {
     putlog(LOG_MISC, "*", "ERROR linking %s: %s", dcc[idx].nick, buf);
@@ -933,24 +936,18 @@ dcc_chat_pass(int idx, char *buf, int atr)
       int snum = findanysnum(dcc[idx].sock);
 
       if (snum >= 0) {
-        int type = atoi(newsplit(&buf)), i = 0;
-        bool found = 0;
+        int type = atoi(newsplit(&buf)), i = -1;
 
         /* verify we have that type and then initiate it */
-        for (i = 0; enclink[i].name; i++) {
-          if (type == enclink[i].type) {
-            found = 1;
-            break;
-          }
-        }
-        if (!found) {
+        if ((i = link_find_by_type(type)) == -1) {
           putlog(LOG_WARN, "*", "%s attempted to link with an invalid encryption.", dcc[idx].nick);
           killsock(dcc[idx].sock);
           lostdcc(idx);
           return;
         }
-        socklist[snum].enctype = type;
-        (enclink[i].func) (idx, FROM);
+        socklist[snum].enclink = i;
+        if (enclink[i].link)
+          (enclink[i].link) (idx, FROM);
       }
     } else {
       /* Invalid password/digest on hub */
@@ -1641,7 +1638,7 @@ dcc_telnet_pass(int idx, int atr)
   if (glob_bot(fr)) {
     /* FIXME: remove after 1.2.2 */
     if (!dcc[idx].newbot) {
-      enclink_call(idx, LINK_GHOST, FROM);
+      link_call(idx, LINK_GHOST, FROM);
     } else {
       /* negotiate a new linking scheme */
       int i = 0;

src/enclink.c

@@ -8,7 +8,18 @@
 #include "net.h"
 #include "misc.h"
 
-static void link_ghost(int idx, direction_t direction)
+int link_find_by_type(int type)
+{
+  int i = 0;
+
+  for (i = 0; enclink[i].name; i++)
+    if (type == enclink[i].type)
+      return i;
+
+  return -1;
+}
+
+static void ghost_link(int idx, direction_t direction)
 {
   int snum = findanysnum(dcc[idx].sock);
 
@@ -71,20 +82,123 @@ static void link_ghost(int idx, direction_t direction)
   }
 }
 
-void enclink_call(int idx, int type, direction_t direction)
+static int
+prand(int *seed, int range)
+{
+  long long i1 = *seed;
+
+  i1 = (i1 * 0x08088405 + 1) & 0xFFFFFFFF;
+  *seed = i1;
+  return ((i1 * range) >> 32);
+}
+
+static int ghost_read(int snum, char *src, size_t *len)
+{
+  char *line = decrypt_string(socklist[snum].ikey, src);
+
+  strcpy(src, line);
+  free(line);
+  if (socklist[snum].iseed) {
+    *(dword *) & socklist[snum].ikey[0] = prand(&socklist[snum].iseed, 0xFFFFFFFF);
+    *(dword *) & socklist[snum].ikey[4] = prand(&socklist[snum].iseed, 0xFFFFFFFF);
+    *(dword *) & socklist[snum].ikey[8] = prand(&socklist[snum].iseed, 0xFFFFFFFF);
+    *(dword *) & socklist[snum].ikey[12] = prand(&socklist[snum].iseed, 0xFFFFFFFF);
+
+    if (!socklist[snum].iseed)
+      socklist[snum].iseed++;
+  }
+//  *len = strlen(src);
+  return OK;
+}
+
+static char *ghost_write(int snum, char *src, size_t *len)
+{
+  char *srcbuf = NULL, *buf = NULL, *line = NULL, *eol = NULL, *eline = NULL;
+  size_t bufpos = 0;
+
+  srcbuf = (char *) my_calloc(1, *len + 9 + 1);
+  strcpy(srcbuf, src);
+  line = srcbuf;
+
+  eol = strchr(line, '\n');
+  while (eol) {
+    *eol++ = 0;
+    eline = encrypt_string(socklist[snum].okey, line);
+    if (socklist[snum].oseed) {
+      *(dword *) & socklist[snum].okey[0] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
+      *(dword *) & socklist[snum].okey[4] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
+      *(dword *) & socklist[snum].okey[8] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
+      *(dword *) & socklist[snum].okey[12] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
+
+      if (!socklist[snum].oseed)
+        socklist[snum].oseed++;
+    }
+    buf = (char *) my_realloc(buf, bufpos + strlen(eline) + 1 + 9);
+    strcpy((char *) &buf[bufpos], eline);
+    free(eline);
+    strcat(buf, "\n");
+    bufpos = strlen(buf);
+    line = eol;
+    eol = strchr(line, '\n');
+  }
+  if (line[0]) {
+    eline = encrypt_string(socklist[snum].okey, line);
+    if (socklist[snum].oseed) {
+      *(dword *) & socklist[snum].okey[0] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
+      *(dword *) & socklist[snum].okey[4] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
+      *(dword *) & socklist[snum].okey[8] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
+      *(dword *) & socklist[snum].okey[12] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
+
+      if (!socklist[snum].oseed)
+        socklist[snum].oseed++;
+    }
+    buf = (char *) my_realloc(buf, bufpos + strlen(eline) + 1 + 9);
+    strcpy((char *) &buf[bufpos], eline);
+    free(eline);
+    strcat(buf, "\n");
+  }
+  free(srcbuf);
+
+  *len = strlen(buf);
+  return buf;
+}
+
+
+
+void link_link(int idx, int type, direction_t direction)
 {
   int i = 0;
 
   for (i = 0; enclink[i].name; i++) {
-    if (enclink[i].type == type) {
-      (enclink[i].func) (idx, direction);
+    if (enclink[i].link && enclink[i].type == type) {
+      (enclink[i].link) (idx, direction);
       return;
     }
   }
   return;
 }
 
+int link_read(int snum, char *buf, size_t *len)
+{
+  int i = socklist[snum].enclink;
+
+  if (i != -1 && enclink[i].read)
+    return (enclink[i].read) (snum, buf, len);
+
+  return -1;
+}
+
+char *link_write(int snum, char *buf, size_t *len)
+{
+  int i = socklist[snum].enclink;
+
+  if (i != -1 && enclink[i].write)
+    return ((enclink[i].write) (snum, buf, len));
+
+  return buf;
+}
+
 struct enc_link enclink[] = {
-  { "ghost", LINK_GHOST, link_ghost },
-  { NULL, 0, NULL }
+  { "ghost", LINK_GHOST, ghost_link, ghost_write, ghost_read },
+  { NULL, 0, NULL, NULL, NULL }
 };

src/enclink.h

@@ -5,6 +5,8 @@
 #ifndef _ENCLINK_H
 #define _ENCLINK_H
 
+#include <sys/types.h>
+
 enum {
         LINK_GHOST = 0,
         LINK_GHOSTSHA1,
@@ -19,13 +21,19 @@ enum direction_t {
 struct enc_link {
   const char *name;
   int type;
-  void (*func) (int, direction_t);
+  void (*link) (int, direction_t);
+  char *(*write) (int, char *, size_t *);
+  int (*read) (int, char *, size_t *);
 };
 
 
 extern struct enc_link enclink[];
 
 
-extern void enclink_call(int, int, direction_t);
+extern int link_find_by_type(int);
+
+extern void link_link(int, int, direction_t);
+extern char *link_write(int, char *, size_t *);
+extern int link_read(int, char *, size_t *);
 
 #endif /* !_ENCLINK_H */

src/net.c

@@ -12,7 +12,7 @@
 #include "main.h"
 #include "debug.h"
 #include "dccutil.h"
-#include "crypt.h"
+#include "enclink.h"
 #include "egg_timer.h"
 #include "traffic.h"
 #include "adns.h"
@@ -367,6 +367,7 @@ int allocsock(int sock, int options)
       socklist[i].flags = options;
       socklist[i].sock = sock;
       socklist[i].encstatus = 0;
+      socklist[i].enclink = -1;
       socklist[i].gz = 0;
       egg_bzero(&socklist[i].okey, sizeof(socklist[i].okey));
       egg_bzero(&socklist[i].ikey, sizeof(socklist[i].ikey));
@@ -1172,86 +1173,6 @@ static int sockread(char *s, int *len)
   return -3;
 }
 
-inline static int 
-prand(int *seed, int range)
-{
-  long long i1 = *seed;
-
-  i1 = (i1 * 0x08088405 + 1) & 0xFFFFFFFF;
-  *seed = i1;
-  return ((i1 * range) >> 32);
-}
-
-char *botlink_decrypt(int snum, char *src)
-{
-  char *line = decrypt_string(socklist[snum].ikey, src);
-
-  strcpy(src, line);
-  free(line);
-  if (socklist[snum].iseed) {
-    *(dword *) & socklist[snum].ikey[0] = prand(&socklist[snum].iseed, 0xFFFFFFFF);
-    *(dword *) & socklist[snum].ikey[4] = prand(&socklist[snum].iseed, 0xFFFFFFFF);
-    *(dword *) & socklist[snum].ikey[8] = prand(&socklist[snum].iseed, 0xFFFFFFFF);
-    *(dword *) & socklist[snum].ikey[12] = prand(&socklist[snum].iseed, 0xFFFFFFFF);
-
-    if (!socklist[snum].iseed)
-      socklist[snum].iseed++;
-  }
-  return src;
-}
-
-char *botlink_encrypt(int snum, char *src, size_t *len)
-{
-  char *srcbuf = NULL, *buf = NULL, *line = NULL, *eol = NULL, *eline = NULL;
-  size_t bufpos = 0;
-
-  srcbuf = (char *) my_calloc(1, *len + 9 + 1);
-  strcpy(srcbuf, src);
-  line = srcbuf;
-
-  eol = strchr(line, '\n');
-  while (eol) {
-    *eol++ = 0;
-    eline = encrypt_string(socklist[snum].okey, line);
-    if (socklist[snum].oseed) {
-      *(dword *) & socklist[snum].okey[0] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
-      *(dword *) & socklist[snum].okey[4] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
-      *(dword *) & socklist[snum].okey[8] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
-      *(dword *) & socklist[snum].okey[12] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
-
-      if (!socklist[snum].oseed)
-        socklist[snum].oseed++;
-    }
-    buf = (char *) my_realloc(buf, bufpos + strlen(eline) + 1 + 9);
-    strcpy((char *) &buf[bufpos], eline);
-    free(eline);
-    strcat(buf, "\n");
-    bufpos = strlen(buf);
-    line = eol;
-    eol = strchr(line, '\n');
-  }
-  if (line[0]) {
-    eline = encrypt_string(socklist[snum].okey, line);
-    if (socklist[snum].oseed) {
-      *(dword *) & socklist[snum].okey[0] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
-      *(dword *) & socklist[snum].okey[4] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
-      *(dword *) & socklist[snum].okey[8] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
-      *(dword *) & socklist[snum].okey[12] = prand(&socklist[snum].oseed, 0xFFFFFFFF);
-
-      if (!socklist[snum].oseed)
-        socklist[snum].oseed++;
-    }
-    buf = (char *) my_realloc(buf, bufpos + strlen(eline) + 1 + 9);
-    strcpy((char *) &buf[bufpos], eline);
-    free(eline);
-    strcat(buf, "\n");
-  }
-  free(srcbuf);
-
-  *len = strlen(buf);
-  return buf;
-}
-
 /* sockgets: buffer and read from sockets
  * 
  * Attempts to read from all registered sockets for up to one second.  if
@@ -1304,9 +1225,12 @@ int sockgets(char *s, int *len)
 	  /* Strip CR if this was CR/LF combo */
 	  if (s[strlen(s) - 1] == '\r')
 	    s[strlen(s) - 1] = 0;
-          if (socklist[i].encstatus && s[0])
-            botlink_decrypt(i, s);
-	  *len = strlen(s);
+
+          if (s[0] && socklist[i].encstatus)
+            link_read(i, s, (size_t *) len);
+            
+          *len = strlen(s);
+
 	  return socklist[i].sock;
 	}
       } else {
@@ -1427,9 +1351,11 @@ int sockgets(char *s, int *len)
       data = 1;
     }
   }
-  if (socklist[ret].encstatus && s[0])
-    botlink_decrypt(ret, s);
+  if (s[0] && socklist[ret].encstatus)
+    link_read(ret, s, (size_t *) len);
+
   *len = strlen(s);
+
   /* Anything left that needs to be saved? */
   if (!xx[0]) {
     if (data)
@@ -1495,8 +1421,8 @@ void tputs(register int z, char *s, size_t len)
         }
       }
 
-      if (socklist[i].encstatus && (len > 0))
-        s = botlink_encrypt(i, s, &len);		/* will modify len */
+      if (len && socklist[i].encstatus)
+        s = link_write(i, s, &len);
       
       if (socklist[i].outbuf != NULL) {
 	/* Already queueing: just add it */

src/net.h

@@ -107,7 +107,7 @@ typedef struct {
   int oseed;                            /* botlink out seed */
   int iseed;                            /* botlink in seed */
   int gz; /* gzip compression */
-  int enctype;				/* new encrypted botlink type */
+  int enclink;				/* new encrypted botlink type */
 #ifdef HAVE_SSL
   SSL           *ssl;
 #endif /* HAVE_SSL */