Changeset 6648

Timestamp:

11/05/10 15:16:05 (21 months ago)

Author:

westram

Message:

• stuffed all direct memory leaks in GB_open/GB_close
  • call gbcm_logout for main-user
  • free dates
  • gb_delete_main_entry -> gb_delete_dummy_father
  • free key data
  • free command hash
  • splitted up gb_delete_entry into GBDATA- and GBCONTAINER-version
  • destroy DB indices when destroying GBCONTAINER

Location:

trunk

Files:

• ARBDB/ad_core.cxx (modified) (5 diffs)
• ARBDB/ad_load.cxx (modified) (5 diffs)
• ARBDB/adcomm.cxx (modified) (4 diffs)
• ARBDB/adindex.cxx (modified) (1 diff)
• ARBDB/arbdb.cxx (modified) (3 diffs)
• ARBDB/gb_data.h (modified) (2 diffs)
• ARBDB/gb_main.h (modified) (2 diffs)
• ARBDB/gb_prot.h (modified) (3 diffs)
• Makefile (modified) (1 diff)

trunk/ARBDB/ad_core.cxx

@@ -268 +268 @@
 
 char *gb_destroy_main(GB_MAIN_TYPE *Main) {
+    gb_assert(!Main->dummy_father);
+    gb_assert(!Main->data);
+
     gb_destroy_cache(Main);
     gb_release_main_idx(Main);
-    if (Main->path) free(Main->path);
+
+    if (Main->command_hash) GBS_free_hash(Main->command_hash);
+
+    gb_free_all_keys(Main);
+    
+    if (Main->key_2_index_hash) GBS_free_hash(Main->key_2_index_hash);
+    freenull(Main->keys);
+
     gb_free_undo_stack(Main);
+
+    for (int j = 0; j<ALLOWED_DATES; ++j) freenull(Main->dates[j]);
+
+    free(Main->path);
+    free(Main->qs.quick_save_disabled);
+    
     gbm_free_mem((char *)Main, sizeof(*Main), 0);
 
@@ -419 +435 @@
 void gb_pre_delete_entry(GBDATA *gbd) {
     // Reduce an entry to its absolute minimum and remove it from database
-    GB_MAIN_TYPE   *Main = GB_MAIN(gbd);
-    long    type = GB_TYPE(gbd);
+    GB_MAIN_TYPE *Main = GB_MAIN_NO_FATHER(gbd);
+    long          type = GB_TYPE(gbd);
 
     struct gb_callback *cb, *cb2;
@@ -436 +452 @@
         gbm_free_mem((char *) cb, sizeof(struct gb_callback), gbm_index);
     }
-    gb_write_key(gbd, 0);
+
+    if (GB_FATHER(gbd)) {
+        gb_write_key(gbd, 0);
+    }
     gb_unlink_entry(gbd);
 
@@ -455 +474 @@
 
 void gb_delete_entry(GBDATA **gbd_ptr) {
-    GBDATA *gbd  = *gbd_ptr;
-    long    gbm_index;
-    long    type = GB_TYPE(gbd);
-
-    gbm_index = GB_GBM_INDEX(gbd);
+    GBDATA *gbd       = *gbd_ptr;
+    long    type      = GB_TYPE(gbd);
 
     if (type == GB_DB) {
-        int          index;
-        GBDATA      *gbd2;
-        GBCONTAINER *gbc = ((GBCONTAINER *) gbd);
-
-        for (index = 0; index < gbc->d.nheader; index++) {
-            if ((gbd2 = GBCONTAINER_ELEM(gbc, index))!=NULL) {
-                gb_delete_entry(&gbd2);
-            }
-        };
-    }
-    gb_pre_delete_entry(gbd);
-
-    // what is left now, is the core database entry!
-
-    if (type == GB_DB) {
-        GBCONTAINER                  *gbc = ((GBCONTAINER *) gbd);
-        struct gb_header_list_struct *hls;
-
-        if ((hls=GB_DATA_LIST_HEADER(gbc->d))!=NULL) {
-            gbm_free_mem((char *)hls,
-                         sizeof(struct gb_header_list_struct) * gbc->d.headermemsize,
-                         GBM_HEADER_INDEX);
-        }
-        gbm_free_mem((char *) gbd, sizeof(GBCONTAINER), gbm_index);
+        gb_delete_entry((GBCONTAINER**)gbd_ptr);
     }
     else {
+        long gbm_index = GB_GBM_INDEX(gbd);
+
+        gb_pre_delete_entry(gbd);
         if (type >= GB_BITS) GB_FREEDATA(gbd);
         gbm_free_mem((char *) gbd, sizeof(GBDATA), gbm_index);
-    }
-
-    *gbd_ptr = 0; // avoid further usage
-}
-
-void gb_delete_main_entry(GBDATA **gbd_ptr) {
-    GBDATA *gbd  = *gbd_ptr;
-    long    type = GB_TYPE(gbd);
-
-    gb_assert(type == GB_DB);
-    if (type == GB_DB) {
-        int          index;
-        int          pass;
-        GBDATA      *gbd2;
-        GBCONTAINER *gbc = ((GBCONTAINER *) gbd);
-
-        GBQUARK sys_quark = GB_key_2_quark(gbd, GB_SYSTEM_FOLDER);
-
-        for (pass = 1; pass <= 2; pass++) {
-            for (index = 0; index < gbc->d.nheader; index++) {
-                if ((gbd2 = GBCONTAINER_ELEM(gbc, index)) != NULL) {
-                    if (pass == 2 || GB_KEY_QUARK(gbd2) != sys_quark) { // delay deletion of system folder to pass 2
-#if defined(DEBUG) && 0
-                        fprintf(stderr, "Deleting root node '%s'\n", GB_get_db_path(gbd2));
-#endif // DEBUG
-                        gb_delete_entry(&gbd2);
-                    }
-                }
-            }
-        }
-        gb_delete_entry(gbd_ptr);
-    }
+        
+        *gbd_ptr = 0;                               // avoid further usage
+    }
+}
+
+void gb_delete_entry(GBCONTAINER **gbc_ptr) {
+    GBCONTAINER *gbc       = *gbc_ptr;
+    long         gbm_index = GB_GBM_INDEX(gbc);
+
+    gb_assert(GB_TYPE(gbc) == GB_DB);
+
+    for (long index = 0; index < gbc->d.nheader; index++) {
+        GBDATA *gbd = GBCONTAINER_ELEM(gbc, index);
+        if (gbd) {
+            gb_delete_entry(&gbd);
+            SET_GBCONTAINER_ELEM(gbc, index, NULL);
+        }
+    }
+
+    gb_pre_delete_entry((GBDATA*)gbc);
+
+    // what is left now, is the core database entry!
+
+    gb_destroy_indices(gbc);
+    struct gb_header_list_struct *hls;
+    
+    if ((hls=GB_DATA_LIST_HEADER(gbc->d)) != NULL) {
+        gbm_free_mem((char *)hls,
+                     sizeof(struct gb_header_list_struct) * gbc->d.headermemsize,
+                     GBM_HEADER_INDEX);
+    }
+    gbm_free_mem((char *) gbc, sizeof(GBCONTAINER), gbm_index);
+
+    *gbc_ptr = 0;                                   // avoid further usage
+}
+
+static void gb_delete_main_entry(GBCONTAINER **gb_main_ptr) {
+    GBCONTAINER *gb_main  = *gb_main_ptr;
+    
+    gb_assert(GB_TYPE(gb_main) == GB_DB);
+
+    GBQUARK sys_quark = GB_key_2_quark((GBDATA*)gb_main, GB_SYSTEM_FOLDER);
+
+    for (int pass = 1; pass <= 2; pass++) {
+        for (int index = 0; index < gb_main->d.nheader; index++) {
+            GBDATA *gbd = GBCONTAINER_ELEM(gb_main, index);
+            if (gbd) {
+                // delay deletion of system folder to pass 2:
+                if (pass == 2 || GB_KEY_QUARK(gbd) != sys_quark) { 
+                    gb_delete_entry(&gbd);
+                    SET_GBCONTAINER_ELEM(gb_main, index, NULL);
+                }
+            }
+        }
+    }
+    gb_delete_entry(gb_main_ptr);
+}
+
+void gb_delete_dummy_father(GBCONTAINER **dummy_father) {
+    GBCONTAINER  *gbc  = *dummy_father;
+    GB_MAIN_TYPE *Main = GB_MAIN(gbc);
+
+    gb_assert(GB_TYPE(gbc)   == GB_DB);
+    gb_assert(GB_FATHER(gbc) == NULL);
+
+    for (int index = 0; index < gbc->d.nheader; index++) {
+        GBCONTAINER *gb_main = (GBCONTAINER*)GBCONTAINER_ELEM(gbc, index);
+        if (gb_main) {
+            gb_assert(GB_TYPE(gb_main) == GB_DB);
+            gb_assert(gb_main == Main->data);
+            gb_delete_main_entry((GBCONTAINER**)&gb_main);
+
+            SET_GBCONTAINER_ELEM(gbc, index, NULL);
+            Main->data = NULL;
+        }
+    }
+
+    gb_delete_entry(dummy_father);
 }
 
@@ -740 +782 @@
 
 void gb_free_all_keys(GB_MAIN_TYPE *Main) {
-    long index;
-    if (!Main->keys) return;
-    for (index = 1; index < Main->keycnt; index++) {
-        if (Main->keys[index].key) {
-            GBS_write_hash(Main->key_2_index_hash, Main->keys[index].key, 0);
-            freenull(Main->keys[index].key);
-        }
-        Main->keys[index].nref = 0;
-        Main->keys[index].next_free_key = 0;
-    }
-    Main->first_free_key = 0;
-    Main->keycnt = 1;
+    if (Main->keys) {
+        for (long index = 1; index < Main->keycnt; index++) {
+            if (Main->keys[index].key) {
+                GBS_write_hash(Main->key_2_index_hash, Main->keys[index].key, 0);
+                freenull(Main->keys[index].key);
+            }
+            Main->keys[index].nref = 0;
+            Main->keys[index].next_free_key = 0;
+        }
+        freenull(Main->keys[0].key); // "main"
+        Main->first_free_key = 0;
+        Main->keycnt         = 1;
+    }
 }
 

trunk/ARBDB/ad_load.cxx

@@ -369 +369 @@
 
         for (i=Main->last_updated; i<=lu; ++i) {
-            Main->dates[i] = strdup("unknown date");
+            gb_assert(i<ALLOWED_DATES);
+            Main->dates[i]     = strdup("unknown date");
             Main->last_updated = lu+1;
         }
@@ -1135 +1136 @@
         return 1;
     }
-    for (j=0; j<255; j++) {         // read times
+    for (j=0; j<(ALLOWED_DATES-1); j++) {         // read times
         p = buffer;
         for (k=0; k<256; k++) {
@@ -1150 +1151 @@
         freedup(Main->dates[j], buffer);
     }
-    if (j>=255) {
-        gb_read_bin_error(in, (GBDATA *)gbd, "more than 255 dates are not allowed");
+    if (j>=(ALLOWED_DATES-1)) {
+        gb_read_bin_error(in, (GBDATA *)gbd, "too many date entries");
         return 1;
     }
@@ -1456 +1457 @@
     if (strchr(opent, 'R')) Main->allow_corrupt_file_recovery = 1;
 
-    gb_create_key(Main, "main", false);
+    ASSERT_RESULT(long, gb_create_key(Main, "main", false), 0);
 
     Main->dummy_father            = gb_make_container(NULL, 0, -1, 0); // create "main"
@@ -1632 +1633 @@
 
     if (error) {
-        gb_release_main_idx(Main);
+        gbcm_logout(Main, user);
+        gb_delete_dummy_father(&Main->dummy_father);
+        gbd        = NULL;
+        gb_destroy_main(Main);
+
         GB_export_error(error);
-        gbd = 0;
     }
     else {

trunk/ARBDB/adcomm.cxx

@@ -1191 +1191 @@
 }
 
-static GB_ERROR gbcm_logout(GBCONTAINER *gb_main, char *user)
-{
-    long i;
-    GB_MAIN_TYPE *Main = GBCONTAINER_MAIN(gb_main);
-
-    for (i = 0; i<GB_MAX_USERS; i++) {
-        if (!Main->users[i]) continue;
-        if (!strcmp(user, Main->users[i]->username)) {
-            Main->users[i]->nusers--;
-            if (Main->users[i]->nusers<=0) { // kill user and his projects
-                free(Main->users[i]->username);
-                freenull(Main->users[i]);
-                fprintf(stdout, "The User %s has logged out\n", user);
-            }
-            return 0;
-        }
-    }
-    return GB_export_errorf("User '%s' not logged in", user);
-}
-
 bool GBCMS_accept_calls(GBDATA *gbd, bool wait_extra_time) {
     // returns true if served
@@ -1314 +1294 @@
                 }
                 if (si->username) {
-                    gbcm_logout((GBCONTAINER *)hs->gb_main, si->username);
+                    gbcm_logout(Main, si->username);
                 }
                 g_bcms_delete_Socinf(si);
@@ -1903 +1883 @@
 
 
-GB_ERROR gbcm_login(GBCONTAINER *gb_main, const char *user)
+GB_ERROR gbcm_login(GBCONTAINER *gb_main, const char *loginname) {
      // look for any free user and set this_user
-{
     int i;
     GB_MAIN_TYPE *Main = GBCONTAINER_MAIN(gb_main);
 
     for (i = 0; i<GB_MAX_USERS; i++) {
-        if (!Main->users[i]) continue;
-        if (!strcmp(user, Main->users[i]->username)) {
-            Main->this_user = Main->users[i];
-            Main->users[i]->nusers++;
+        gb_user_struct *user = Main->users[i];
+        if (user && strcmp(loginname, user->username) == 0) {
+            Main->this_user = user;
+            user->nusers++;
             return 0;
         }
     }
     for (i = 0; i<GB_MAX_USERS; i++) {
-        if (Main->users[i]) continue;
-        Main->users[i] = (struct gb_user_struct *) GB_calloc(sizeof(struct gb_user_struct), 1);
-        Main->users[i]->username = strdup(user);
-        Main->users[i]->userid = i;
-        Main->users[i]->userbit = 1<<i;
-        Main->users[i]->nusers = 1;
-        Main->this_user = Main->users[i];
-        return 0;
-    }
-    return GB_export_errorf("Too many users in this database: User '%s' ", user);
+        gb_user_struct*& user = Main->users[i];
+        if (!user) {
+            user = (gb_user_struct *) GB_calloc(sizeof(gb_user_struct), 1);
+            
+            user->username = strdup(loginname);
+            user->userid   = i;
+            user->userbit  = 1<<i;
+            user->nusers   = 1;
+
+            Main->this_user = user;
+
+            return 0;
+        }
+    }
+    return GB_export_errorf("Too many users in this database: User '%s' ", loginname);
 }
 
@@ -1949 +1933 @@
     return GBCM_SERVER_OK;
 }
+
+GB_ERROR gbcm_logout(GB_MAIN_TYPE *Main, const char *loginname) {
+    // if 'loginname' is NULL, the first logged-in user will be logged out
+
+    if (!loginname) {
+        loginname = Main->users[0]->username;
+        gb_assert(loginname);
+    }
+
+    for (long i = 0; i<GB_MAX_USERS; i++) {
+        gb_user_struct*& user = Main->users[i];
+        if (user && strcmp(loginname, user->username) == 0) {
+            user->nusers--;
+            if (user->nusers<=0) { // kill user and his projects
+                if (i) fprintf(stdout, "User '%s' has logged out\n", loginname);
+                free(user->username);
+                freenull(user);
+            }
+            return 0;
+        }
+    }
+    return GB_export_errorf("User '%s' not logged in", loginname);
+}
+
 
 GB_CSTR GB_get_hostname() {

trunk/ARBDB/adindex.cxx

@@ -173 +173 @@
     }
     return error;
+}
+
+void gb_destroy_indices(GBCONTAINER *gbc) {
+    gb_index_files_struct *ifs = GBCONTAINER_IFS(gbc);
+
+    while (ifs) {
+        GB_REL_IFES *if_entries = GB_INDEX_FILES_ENTRIES(ifs);
+
+        for (int index = 0; index<ifs->hash_table_size; index++) {
+            gb_if_entries *ifes = GB_ENTRIES_ENTRY(if_entries, index);
+
+            while (ifes) {
+                gb_if_entries *ifes_next = GB_IF_ENTRIES_NEXT(ifes);
+
+                gbm_free_mem((char*)ifes, sizeof(*ifes), GB_GBM_INDEX(gbc));
+                ifes = ifes_next;
+            }
+        }
+        free(if_entries);
+
+        gb_index_files_struct *ifs_next = GB_INDEX_FILES_NEXT(ifs);
+        free(ifs);
+        ifs = ifs_next;
+    }
 }
 

trunk/ARBDB/arbdb.cxx

@@ -413 +413 @@
 
     if (!Main->local_mode) {
-        long result = gbcmc_close(Main->c_link);
+        long result            = gbcmc_close(Main->c_link);
         if (result != 0) error = GBS_global_string("gbcmc_close returns %li", result);
     }
 
+    gbcm_logout(Main, NULL);                        // logout default user
+    
     if (!error) {
         gb_assert((GBDATA*)Main->data == gbd);
@@ -423 +425 @@
         Main->close_callbacks = 0;
 
-        gb_delete_main_entry(&gbd);
+        gb_delete_dummy_father(&Main->dummy_father);
+        Main->data = NULL;
 
         /* ARBDB applications using awars easily crash in gb_do_callback_list(),
@@ -431 +434 @@
          * If that doesn't help, test Main->data (often aka as GLOBAL_gb_main)
          */
-        Main->data = NULL;
         gb_do_callback_list(Main);                  // do all callbacks
-
         gb_destroy_main(Main);
     }

trunk/ARBDB/gb_data.h

@@ -160 +160 @@
 
 inline GB_TYPES GB_TYPE(GBDATA *gbd)      { return GB_TYPES(gbd->flags.type); }
-inline GB_TYPES GB_TYPE(GBCONTAINER *gbd) { return GB_TYPES(gbd->flags.type); }
+inline GB_TYPES GB_TYPE(GBCONTAINER *gbc) { return GB_TYPES(gbc->flags.type); }
 
 // ----------------------
@@ -179 +179 @@
 inline GB_MAIN_TYPE *GB_MAIN(GBDATA *gbd)               { return GBCONTAINER_MAIN(GB_FATHER(gbd)); }
 inline GB_MAIN_TYPE *GB_MAIN(GBCONTAINER *gbc)          { return GBCONTAINER_MAIN(gbc); }
+inline GB_MAIN_TYPE *GB_MAIN_NO_FATHER(GBDATA *gbd)     { return GB_TYPE(gbd) == GB_DB ? GBCONTAINER_MAIN((GBCONTAINER*)gbd) : GB_MAIN(gbd); }
 
 // -----------------------

trunk/ARBDB/gb_main.h

@@ -76 +76 @@
 //      root structure (one for each database)
 
-#define ALLOWED_KEYS 15000
+#define ALLOWED_KEYS  15000
+#define ALLOWED_DATES 256
 
 struct GB_MAIN_TYPE {
@@ -116 +117 @@
     g_b_undo_mgr_struct *undo;
 
-    char         *dates[256];
+    char         *dates[ALLOWED_DATES];           // @@@ saved to DB, but never used
     unsigned int  security_level;
     int           old_security_level;

trunk/ARBDB/gb_prot.h

@@ -69 +69 @@
 GB_ERROR gbcmc_send_undo_commands(GBDATA *gbd, enum gb_undo_commands command) __ATTR__USERESULT;
 char *gbcmc_send_undo_info_commands(GBDATA *gbd, enum gb_undo_commands command);
-GB_ERROR gbcm_login(GBCONTAINER *gb_main, const char *user);
+GB_ERROR gbcm_login(GBCONTAINER *gb_main, const char *loginname);
 GBCM_ServerResult gbcmc_close(struct gbcmc_comm *link);
+GB_ERROR gbcm_logout(GB_MAIN_TYPE *Main, const char *loginname);
 
 /* adhash.cxx */
@@ -155 +156 @@
 void gb_pre_delete_entry(GBDATA *gbd);
 void gb_delete_entry(GBDATA **gbd_ptr);
-void gb_delete_main_entry(GBDATA **gbd_ptr);
+void gb_delete_entry(GBCONTAINER **gbc_ptr);
+void gb_delete_dummy_father(GBCONTAINER **dummy_father);
 struct gb_transaction_save *gb_new_gb_transaction_save(GBDATA *gbd);
 void gb_add_ref_gb_transaction_save(struct gb_transaction_save *ts);
@@ -193 +195 @@
 char *gb_index_check_in(GBDATA *gbd);
 void gb_index_check_out(GBDATA *gbd);
+void gb_destroy_indices(GBCONTAINER *gbc);
 GBDATA *gb_index_find(GBCONTAINER *gbf, struct gb_index_files_struct *ifs, GBQUARK quark, const char *val, GB_CASE case_sens, int after_index);
 void gb_init_undo_stack(GB_MAIN_TYPE *Main);

trunk/Makefile

@@ -1579 +1579 @@
         @echo "$(SEP) Running unit tests"
         $(MAKE) $(TESTED_UNITS)
-        @echo "All unit tests passed" 
+        @echo "$(SEP) All unit tests passed" 
 
 ut: unit_tests