ForEachUser() now uses a linked list

[citadel.git] / citadel / user_ops.c

diff --git a/citadel/user_ops.c b/citadel/user_ops.c
index 0a74759ae9ba3653a99e70c8029f6a23ecc29569..9a39b06b6754b7b4c940fbd0e06acf0959476411 100644 (file)
--- a/citadel/user_ops.c
+++ b/citadel/user_ops.c
@@ -31,6 +31,7 @@
 int chkpwd_write_pipe[2];
 int chkpwd_read_pipe[2];
 
+
 /*
  * Trim a string down to the maximum username size and return the new length
  */
@@ -49,18 +50,22 @@ long cutusername(char *username) {
 
 /*
  * makeuserkey() - convert a username into the format used as a database key
- *              (it's just the username converted into lower case)
+ *                 (Key format is the username with all non-alphanumeric characters removed, and converted to lower case.)
  */
 void makeuserkey(char *key, const char *username, long len) {
        int i;
+       int keylen = 0;
 
        if (len >= USERNAME_SIZE) {
                syslog(LOG_INFO, "Username too long: %s", username);
                len = USERNAME_SIZE - 1; 
        }
        for (i=0; i<=len; ++i) {
-               key[i] = tolower(username[i]);
+               if (isalnum((username[i]))) {
+                       key[keylen++] = tolower(username[i]);
+               }
        }
+       key[keylen++] = 0;
 }
 
 
@@ -198,6 +203,57 @@ int rename_user(char *oldname, char *newname) {
 }
 
 
+/*
+ * Convert a username into the format used as a database key prior to version 928
+ * This only gets called by reindex_user_928()
+ */
+void makeuserkey_pre928(char *key, const char *username, long len) {
+       int i;
+
+       if (len >= USERNAME_SIZE) {
+               syslog(LOG_INFO, "Username too long: %s", username);
+               len = USERNAME_SIZE - 1; 
+       }
+       for (i=0; i<=len; ++i) {
+               key[i] = tolower(username[i]);
+       }
+}
+
+
+/*
+ * Read a user record using the pre-v928 index format, and write it back using the v928-and-higher index format.
+ * This ONLY gets called during an upgrade from version <928 to version >=928.
+ */
+void reindex_user_928(char *username, void *out_data) {
+
+       char oldkey[USERNAME_SIZE];
+       char newkey[USERNAME_SIZE];
+       struct cdbdata *cdbus;
+       long len = cutusername(username);
+       struct ctdluser usbuf;
+
+       makeuserkey_pre928(oldkey, username, len);
+       makeuserkey(newkey, username, len);
+
+       syslog(LOG_DEBUG, "user_ops: reindex_user_928: %s <%s> --> <%s>", username, oldkey, newkey);
+
+       // Fetch the user record using the old index format
+       cdbus = cdb_fetch(CDB_USERS, oldkey, strlen(oldkey));
+       if (cdbus == NULL) {
+               syslog(LOG_INFO, "user_ops: <%s> not found, were they already reindexed?", username);
+               return;
+       }
+       memcpy(&usbuf, cdbus->ptr, ((cdbus->len > sizeof(struct ctdluser)) ? sizeof(struct ctdluser) : cdbus->len));
+       cdb_free(cdbus);
+
+       // delete the old record
+       cdb_delete(CDB_USERS, oldkey, strlen(oldkey));
+
+       // write the new record
+       cdb_store(CDB_USERS, newkey, strlen(newkey), &usbuf, sizeof(struct ctdluser));
+}
+
+
 /*
  * Index-generating function used by Ctdl[Get|Set]Relationship
  */
@@ -1139,17 +1195,15 @@ int CtdlForgetThisRoom(void) {
  */
 void ForEachUser(void (*CallBack) (char *, void *out_data), void *in_data)
 {
+       struct cdbdata *cdbus;
+       struct ctdluser *usptr;
+
        struct feu {
+               struct feu *next;
                char username[USERNAME_SIZE];
-               int version;
        };
-
-       struct cdbdata *cdbus;
-       struct ctdluser *usptr;
-       int i = 0;
        struct feu *usernames = NULL;
-       int num_users = 0;
-       int num_users_alloc = 0;
+       struct feu *f = NULL;
 
        cdb_rewind(CDB_USERS);
 
@@ -1158,22 +1212,19 @@ void ForEachUser(void (*CallBack) (char *, void *out_data), void *in_data)
                usptr = (struct ctdluser *) cdbus->ptr;
 
                if (strlen(usptr->fullname) > 0) {
-                       ++num_users;
-                       if (num_users > num_users_alloc) {
-                               num_users_alloc = ((num_users_alloc == 0) ? 1 : (num_users_alloc * 2));
-                               usernames = realloc(usernames, num_users_alloc * sizeof(struct feu));
-                       }
-                       strcpy(usernames[num_users-1].username, usptr->fullname);
-                       usernames[num_users-1].version = usptr->version;
+                       f = malloc(sizeof(struct feu));
+                       f->next = usernames;
+                       strncpy(f->username, usptr->fullname, USERNAME_SIZE);
+                       usernames = f;
                }
        }
 
        // Phase 2 : perform the callback for each username
-       for (i=0; i<num_users; ++i) {
-               //if (usernames[i].version < 927) {
-                       // FIXME This is where we will do the reindexing stuff
-               //}
-               (*CallBack) (usernames[i].username, in_data);
+       while (usernames != NULL) {
+               (*CallBack) (usernames->username, in_data);
+               f = usernames;
+               usernames = usernames->next;
+               free(f);
        }
 
        free(usernames);