cleanup

diff --git a/ChangeLog b/ChangeLog
index cae1cdc0c781287897efabc6d1ff782115e22ff5..d18825b239ded023866d1b24b42efda22dbbeacf 100644 (file)
--- a/ChangeLog
+++ b/ChangeLog
@@ -1,6 +1,14 @@
 /***********************************************************************
 X3 ChangeLog
 
+2007-02-08  Alex Schumann  <rubin@afternet.org>
+
+        * src/x3ldap.c: cleaning up and switching adduser to use the new
+       crypted password scheme.
+
+        * src/nickserv.c: testing with ldap_enabled set to 0, and/or WITH_LDAP
+       not defined, uncovered some warnings etc.
+
 2007-02-08  Alex Schumann  <rubin@afternet.org>
 
         * src/nickserv.c: Filling in ldap support for all password related

diff --git a/src/nickserv.c b/src/nickserv.c
index 613bc66a25352e27b7478b74a291979e4b65db74..fa452d4ca323a12c2edcf149741597e44fdc1355 100644 (file)
--- a/src/nickserv.c
+++ b/src/nickserv.c
@@ -1864,7 +1864,9 @@ struct handle_info *loc_auth(char *handle, char *password)
     int wildmask = 0;
     struct handle_info *hi;
     struct userNode *other;
+#ifdef WITH_LDAP
     int ldap_result;
+#endif
 
     hi = dict_find(nickserv_handle_dict, handle, NULL);
     pw_arg = 2;
@@ -2487,7 +2489,9 @@ static NICKSERV_FUNC(cmd_pass)
 {
     struct handle_info *hi;
     char *old_pass, *new_pass;
+#ifdef WITH_LDAP
     int ldap_result;
+#endif
 
     NICKSERV_MIN_PARMS(3);
     hi = user->handle_info;

diff --git a/src/x3ldap.c b/src/x3ldap.c
index 67b4f5be0ec14fec8b007c7a5a7c237526cd17a8..18a93bb8005658ad7e8c36cd4c32bf8d115c7d13 100644 (file)
--- a/src/x3ldap.c
+++ b/src/x3ldap.c
@@ -32,34 +32,12 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <ldap.h>
-//#include <sys/select.h>
-
-#ifdef WITH_SSL
-#include <openssl/bio.h>
-#include <openssl/evp.h>
-#endif
 
 #include "conf.h"
 #include "global.h"
 #include "log.h"
 #include "x3ldap.h"
 
-#ifdef HAVE_FCNTL_H
-#include <fcntl.h>
-#endif
-#ifdef HAVE_SYS_SELECT_H
-#include <sys/select.h>
-#endif
-#ifdef HAVE_SYS_SOCKET_H
-#include <sys/socket.h>
-#endif
-
-
-/* char dn[] = "uid=%s,ou=Users,dc=afternet,dc=org";
-char password[] = "xxxxxxx";
-char base[] = "ou=Users,dc=afternet,dc=org";
-int ldap_version = 3;
-*/
 extern struct nickserv_config nickserv_conf;
 
 
@@ -93,7 +71,7 @@ unsigned int ldap_do_bind( const char *dn, const char *pass)
    while(1) {
       q = ldap_simple_bind_s(ld, dn, pass);
       if(q == LDAP_SUCCESS) {
-           log_module(MAIN_LOG, LOG_DEBUG, "bind() successfull! You are bound as %s\n", dn);
+           log_module(MAIN_LOG, LOG_DEBUG, "bind() successfull! You are bound as %s", dn);
            /* unbind now */
            return q;
       }
@@ -101,7 +79,7 @@ unsigned int ldap_do_bind( const char *dn, const char *pass)
         return q;
       }
       else {
-        log_module(MAIN_LOG, LOG_ERROR, "Bind failed: %s/******  (%d)\n", dn, q);
+        log_module(MAIN_LOG, LOG_ERROR, "Bind failed: %s/******  (%d)", dn, q);
         ldap_perror(ld, "ldap");
         ldap_do_init();
       }
@@ -178,6 +156,103 @@ LDAPMessage ldap_search_user(char uid)
 
 #endif
 
+/********* base64 stuff ***********/
+
+unsigned char *pack(char *str, unsigned int *len)
+{
+    int nibbleshift = 4;
+    int first = 1;
+    char *v;
+    static unsigned char buf[MAXLEN+1];
+    int outputpos = -1;
+
+    memset(buf, 0, MAXLEN+1);
+    v = str;
+    while(*v) {
+        char n = *(v++);
+
+        if((n >= '0') && (n <= '9')) {
+            n -= '0';
+        } else if ((n >= 'A') && (n <= 'F')) {
+                n -= ('A' - 10);
+        } else if ((n >= 'a') && (n <= 'f')) {
+                n -= ('a' - 10);
+        } else {
+                printf("pack type H: illegal hex digit %c", n);
+                n = 0;
+        }
+
+        if (first--) {
+                buf[++outputpos] = 0;
+        } else {
+                first = 1;
+        }
+
+        buf[outputpos] |= (n << nibbleshift);
+        nibbleshift = (nibbleshift + 4) & 7;
+    }
+    *len = outputpos+1;
+    return(buf);
+}
+
+
+/* from php5 sources */
+static char base64_table[] =
+        { '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', '+', '/', '\0'
+        };
+static char base64_pad = '=';
+
+char *base64_encode(const unsigned  char *str, int length, int *ret_length)
+{
+    const unsigned char *current = str;
+    char *p;
+    char *result;
+
+    if ((length + 2) < 0 || ((length + 2) / 3) >= (1 << (sizeof(int) * 8 - 2))) {
+        if (ret_length != NULL) {
+            *ret_length = 0;
+        }
+        return NULL;
+    }
+
+    result = (char *)calloc(((length + 2) / 3) * 4, sizeof(char));
+    p = result;
+
+    while (length > 2) { /* keep going until we have less than 24 bits */
+        *p++ = base64_table[current[0] >> 2];
+        *p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
+        *p++ = base64_table[((current[1] & 0x0f) << 2) + (current[2] >> 6)];
+        *p++ = base64_table[current[2] & 0x3f];
+
+        current += 3;
+        length -= 3; /* we just handle 3 octets of data */
+    }
+
+    /* now deal with the tail end of things */
+    if (length != 0) {
+        *p++ = base64_table[current[0] >> 2];
+        if (length > 1) {
+            *p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
+            *p++ = base64_table[(current[1] & 0x0f) << 2];
+            *p++ = base64_pad;
+        } else {
+            *p++ = base64_table[(current[0] & 0x03) << 4];
+            *p++ = base64_pad;
+            *p++ = base64_pad;
+        }
+    }
+    if (ret_length != NULL) {
+        *ret_length = (int)(p - result);
+    }
+    *p = '\0';
+    return result;
+}
+
+
 char **make_object_vals()
 {
     unsigned int y;
@@ -195,6 +270,26 @@ char **make_object_vals()
     return object_vals;
 }
 
+char *make_password(const char *password)
+{
+       char *base64pass;
+       char crypted[MD5_CRYPT_LENGTH+1];
+       unsigned char *packed;
+       unsigned int len;
+       char *passbuf;
+       cryptpass(password, crypted);
+
+       packed = pack(crypted, &len);
+       base64pass = base64_encode(packed, len, NULL);
+       passbuf = malloc(strlen(base64pass) + 1 + 5);
+       strcpy(passbuf, "{MD5}");
+       strcat(passbuf, base64pass);
+       //log_module(MAIN_LOG, LOG_DEBUG, "Encoded password is: '%s'", passbuf);
+       free(base64pass);
+       return passbuf;
+
+}
+
 LDAPMod **make_mods_add(const char *account, const char *password, const char *email, int *num_mods_ret)
 {
     static char *account_vals[] = { NULL, NULL };
@@ -264,12 +359,14 @@ int ldap_do_add(const char *account, const char *password, const char *email)
     LDAPMod **mods;
     int rc, i;
     int num_mods;
+    char *passbuf;
     
     if(LDAP_SUCCESS != ( rc = ldap_do_admin_bind())) {
        log_module(MAIN_LOG, LOG_ERROR, "failed to bind as admin");
        return rc;
     }
     
+    passbuf = make_password(password);
     snprintf(newdn, MAXLEN-1, nickserv_conf.ldap_dn_fmt, account);
     mods = make_mods_add(account, password, email, &num_mods);
     if(!mods) {
@@ -287,6 +384,7 @@ int ldap_do_add(const char *account, const char *password, const char *email)
        free(mods[i]);
     }
     free(mods);
+    free(passbuf);
     return rc;
 }
 
@@ -366,102 +464,6 @@ LDAPMod **make_mods_modify(const char *password, const char *email, int *num_mod
     return mods;
 }
 
-/********* base64 stuff ***********/
-
-unsigned char *pack(char *str, unsigned int *len)
-{
-    int nibbleshift = 4;
-    int first = 1;
-    char *v;
-    static unsigned char buf[MAXLEN+1];
-    int outputpos = -1;
-
-    memset(buf, 0, MAXLEN+1);
-    v = str;
-    while(*v) {
-        char n = *(v++);
-
-        if((n >= '0') && (n <= '9')) {
-            n -= '0';
-        } else if ((n >= 'A') && (n <= 'F')) {
-                n -= ('A' - 10);
-        } else if ((n >= 'a') && (n <= 'f')) {
-                n -= ('a' - 10);
-        } else {
-                printf("pack type H: illegal hex digit %c", n);
-                n = 0;
-        }
-
-        if (first--) {
-                buf[++outputpos] = 0;
-        } else {
-                first = 1;
-        }
-
-        buf[outputpos] |= (n << nibbleshift);
-        nibbleshift = (nibbleshift + 4) & 7;
-    }
-    *len = outputpos+1;
-    return(buf);
-}
-
-
-/* from php5 sources */
-static char base64_table[] =
-        { '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', '+', '/', '\0'
-        };
-static char base64_pad = '=';
-
-char *base64_encode(const unsigned  char *str, int length, int *ret_length)
-{
-    const unsigned char *current = str;
-    char *p;
-    char *result;
-
-    if ((length + 2) < 0 || ((length + 2) / 3) >= (1 << (sizeof(int) * 8 - 2))) {
-        if (ret_length != NULL) {
-            *ret_length = 0;
-        }
-        return NULL;
-    }
-
-    result = (char *)calloc(((length + 2) / 3) * 4, sizeof(char));
-    p = result;
-
-    while (length > 2) { /* keep going until we have less than 24 bits */
-        *p++ = base64_table[current[0] >> 2];
-        *p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
-        *p++ = base64_table[((current[1] & 0x0f) << 2) + (current[2] >> 6)];
-        *p++ = base64_table[current[2] & 0x3f];
-
-        current += 3;
-        length -= 3; /* we just handle 3 octets of data */
-    }
-
-    /* now deal with the tail end of things */
-    if (length != 0) {
-        *p++ = base64_table[current[0] >> 2];
-        if (length > 1) {
-            *p++ = base64_table[((current[0] & 0x03) << 4) + (current[1] >> 4)];
-            *p++ = base64_table[(current[1] & 0x0f) << 2];
-            *p++ = base64_pad;
-        } else {
-            *p++ = base64_table[(current[0] & 0x03) << 4];
-            *p++ = base64_pad;
-            *p++ = base64_pad;
-        }
-    }
-    if (ret_length != NULL) {
-        *ret_length = (int)(p - result);
-    }
-    *p = '\0';
-    return result;
-}
-
 
 /* Save email or password to server
  *
@@ -484,28 +486,7 @@ int ldap_do_modify(const char *account, const char *password, const char *email)
     }
 
     if(password) {
-/* If we have the ssl lib, (and thus the base64 libraries) save the passwords as ldap md5 */
-       char *base64pass;
-       char crypted[MD5_CRYPT_LENGTH+1];
-       unsigned char *packed;
-       unsigned int len, i;
-       unsigned char c;
-       cryptpass(password, crypted);
-       
-//       printf("Crypted pass is: '%s'\n", crypted);
-       packed = pack(crypted, &len);
-       base64pass = base64_encode(packed, len, NULL);
-//       printf("base64pass is: '%s'\n", base64pass);
-//       for(i = 0; i<=len; i++) {
-//          c = packed[i];
-//          printf("%d ", packed[i]);
-//       }
-
-       passbuf = malloc(strlen(base64pass) + 1 + 5);
-       strcpy(passbuf, "{MD5}");
-       strcat(passbuf, base64pass);
-       log_module(MAIN_LOG, LOG_DEBUG, "Encoded password is: '%s'", passbuf);
-       free(base64pass);
+       passbuf = make_password(password);
     }
     
     snprintf(dn, MAXLEN-1, nickserv_conf.ldap_dn_fmt, account);