search function is complete

diff --git a/citadel/server/ctdl_module.h b/citadel/server/ctdl_module.h
index 51470ddae79d8693c582ef4c8a70eac4d7e18142..54c8ed61b3ad89881bd403f739de1a7a6f8b3156 100644 (file)
--- a/citadel/server/ctdl_module.h
+++ b/citadel/server/ctdl_module.h
@@ -142,7 +142,7 @@ void CtdlUnregisterServiceHook(int tcp_port,
 void CtdlRegisterFixedOutputHook(char *content_type, void (*output_function) (char *supplied_data, int len));
 void CtdlUnRegisterFixedOutputHook(char *content_type);
 void CtdlRegisterMaintenanceThread(char *name, void *(*thread_proc) (void *arg));
-void CtdlRegisterSearchFuncHook(void (*fcn_ptr)(int *, long **, const char *), char *name);
+void CtdlRegisterSearchFuncHook(Array (*)(const char *), char *name);
 
 /*
  * if you say a) (which may take a while)

diff --git a/citadel/server/modules/fulltext/serv_fulltext.c b/citadel/server/modules/fulltext/serv_fulltext.c
index caa5f17e76a00a7e1a1dc1942a0ff846e02ffd2f..167e050d4598be91ad9e8a4bac34be22ee1135f6 100644 (file)
--- a/citadel/server/modules/fulltext/serv_fulltext.c
+++ b/citadel/server/modules/fulltext/serv_fulltext.c
@@ -116,7 +116,15 @@ void ft_index_message(long msgnum, int op) {
 
                        if (op == 1) {                                          // indexing, add this message to the bucket
                                memcpy(&newbucket[0], cdb_bucket.ptr, cdb_bucket.len);
-                               memcpy(&newbucket[nmsgs++], &msgnum, sizeof(long));
+                               int already_there = 0;
+                               for (j=0; j<nmsgs; ++j) {
+                                       if (newbucket[j] == msgnum) {
+                                               already_there = 1;
+                                       }
+                               }
+                               if (already_there == 0) {
+                                       memcpy(&newbucket[nmsgs++], &msgnum, sizeof(long));
+                               }
                        }
 
                        else if (op == 0) {                                     // deindexing, remove this message from the bucket
@@ -241,80 +249,61 @@ void do_fulltext_indexing(void) {
 // API call to perform searches.
 // (This one does the "all of these words" search.)
 // Caller is responsible for freeing the message list.
-void ft_search(int *fts_num_msgs, long **fts_msgs, const char *search_string) {
-       Array *t = NULL;
-       int i, j;
+Array *ft_search(const char *search_string) {
+       int i, j, tok;
        struct cdbdata cdb_bucket;
-       int num_all_msgs = 0;
-       long *all_msgs = NULL;
-       int num_ret_msgs = 0;
-       int num_ret_alloc = 0;
-       long *ret_msgs = NULL;
-       int tok;
+       long msgnum, smsgnum;
+       int count;
 
-#if 0
-       t = wordbreaker(search_string);
-       if (array_len(t) > 0) {
-               for (i=0; i<array_len(t); ++i) {
+       Array *r = array_new(sizeof(long));
+       if (!r) return(NULL);
+       Array *t = wordbreaker(search_string);
 
-                       // search for tokens[i]
+       if ((t != NULL) && (array_len(t) > 0)) {
+               for (i=0; i<array_len(t); ++i) {
                        memcpy(&tok, array_get_element_at(t, i), sizeof(int));
-
-                       // fetch the bucket, Liza
-                       if (ftc_msgs[tok] == NULL) {
-                               cdb_bucket = cdb_fetch(CDB_FULLTEXT, &tok, sizeof(int));
-                               if (cdb_bucket.ptr != NULL) {
-                                       ftc_num_msgs[tok] = cdb_bucket.len / sizeof(long);
-                                       ftc_msgs[tok] = (long *) malloc(cdb_bucket.len);
-                                       memcpy(ftc_msgs[tok], cdb_bucket.ptr, cdb_bucket.len);
-                               }
-                               else {
-                                       ftc_num_msgs[tok] = 0;
-                                       ftc_msgs[tok] = malloc(sizeof(long));
+                       cdb_bucket = cdb_fetch(CDB_FULLTEXT, &tok, sizeof(int));
+                       if (cdb_bucket.ptr != NULL) {
+                               for (j=0; j<(cdb_bucket.len / sizeof(long)); ++j) {
+                                       memcpy(&msgnum, cdb_bucket.ptr + (j*sizeof(long)), sizeof(long));
+                                       array_append(r, &msgnum);
                                }
                        }
+               }
+       }
 
-                       num_all_msgs += ftc_num_msgs[tok];
-                       if (num_all_msgs > 0) {
-                               all_msgs = realloc(all_msgs, num_all_msgs*sizeof(long) );
-                               memcpy(&all_msgs[num_all_msgs-ftc_num_msgs[tok]], ftc_msgs[tok], ftc_num_msgs[tok]*sizeof(long) );
+       // We need to return any message containing ALL of the tokens.
+       // If a message number appears in the array `n` times, where `n` is the number of search words,
+       // that means it matched all search words.
+       array_sort(r, longcmp);
+       for (i=0; i<array_len(r); ++i) {
+               memcpy(&msgnum, array_get_element_at(r, i), sizeof(long));
+               count = 1;
+               for (j=i+1; j<array_len(r); ++j) {
+                       memcpy(&smsgnum, array_get_element_at(r, j), sizeof(long));
+                       if (msgnum == smsgnum) {
+                               ++count;
+                               array_delete_element_at(r, j);
+                               --j;
                        }
-
                }
-               array_free(t);
-               if (all_msgs != NULL) {
-                       qsort(all_msgs, num_all_msgs, sizeof(long), longcmp);
-
-                       // At this point, if a message appears array_len(t) times in the
-                       // list, then it contains all of the search tokens.
-                       if (num_all_msgs >= array_len(t))
-                               for (j=0; j<(num_all_msgs-array_len(t)+1); ++j) {
-                                       if (all_msgs[j] == all_msgs[j+array_len(t)-1]) {
-                                               ++num_ret_msgs;
-                                               if (num_ret_msgs > num_ret_alloc) {
-                                                       num_ret_alloc += 64;
-                                                       ret_msgs = realloc(ret_msgs, (num_ret_alloc*sizeof(long)) );
-                                               }
-                                               ret_msgs[num_ret_msgs - 1] = all_msgs[j];
-                                               
-                                       }
-                               }
-                       free(all_msgs);
+               if (count != array_len(t)) {
+                       array_delete_element_at(r, i);
+                       --i;
                }
        }
 
-       *fts_num_msgs = num_ret_msgs;
-       *fts_msgs = ret_msgs;
-#endif
+       array_free(t);
+       return(r);
 }
 
 
 // This search command is for diagnostic purposes and may be removed or replaced.
 void cmd_srch(char *argbuf) {
-       int num_msgs = 0;
-       long *msgs = NULL;
        int i;
-       char search_string[256];
+       char search_string[SIZ];
+       Array *matches = NULL;
+       long msgnum;
 
        if (CtdlAccessCheck(ac_logged_in)) return;
 
@@ -324,15 +313,18 @@ void cmd_srch(char *argbuf) {
        }
 
        extract_token(search_string, argbuf, 0, '|', sizeof search_string);
-       ft_search(&num_msgs, &msgs, search_string);
+       matches = ft_search(search_string);
 
-       cprintf("%d %d msgs match all search words:\n", LISTING_FOLLOWS, num_msgs);
-       if (num_msgs > 0) {
-               for (i=0; i<num_msgs; ++i) {
-                       cprintf("%ld\n", msgs[i]);
+       cprintf("%d %d msgs match all search words:\n", LISTING_FOLLOWS, array_len(matches));
+       if ((matches != NULL) && (array_len(matches) > 0)) {
+               for (i=0; i<array_len(matches); ++i) {
+                       memcpy(&msgnum, array_get_element_at(matches, i), sizeof(long));
+                       cprintf("%ld\n", msgnum);
                }
        }
-       if (msgs != NULL) free(msgs);
+       if (matches != NULL) {
+               array_free(matches);
+       }
        cprintf("000\n");
 }
 

diff --git a/citadel/server/modules/fulltext/serv_fulltext.h b/citadel/server/modules/fulltext/serv_fulltext.h
index bc05c510f7afd106a29f57b7f332a12db8b58c28..449a4b8e6b7fb3421208d9a8373537c0884e7bb0 100644 (file)
--- a/citadel/server/modules/fulltext/serv_fulltext.h
+++ b/citadel/server/modules/fulltext/serv_fulltext.h
@@ -1,21 +1,7 @@
-/*
- * Copyright (c) 2005-2012 by the citadel.org team
- *
- *  This program is open source software; you can redistribute it and/or modify
- *  it under the terms of the GNU General Public License version 3.
- *  
- *  
- *
- *  This program is distributed in the hope that it will be useful,
- *  but WITHOUT ANY WARRANTY; without even the implied warranty of
- *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- *  GNU General Public License for more details.
- *
- *  
- *  
- *  
- */
+// Copyright (c) 2005-2023 by the citadel.org team
+// 
+// This program is open source software.  Use, duplication, or disclosure
+// is subject to the terms of the GNU General Public License, version 3.
 
 void ft_index_message(long msgnum, int op);
-void ft_search(int *fts_num_msgs, long **fts_msgs, const char *search_string);
-void *indexer_thread(void *arg);
+Array *ft_search(const char *search_string);

diff --git a/citadel/server/serv_extensions.c b/citadel/server/serv_extensions.c
index e92f7f931172a70481f1fd5d7eca2acb71756e6e..0763916ae60304d0983a845e961ec8e989df5301 100644 (file)
--- a/citadel/server/serv_extensions.c
+++ b/citadel/server/serv_extensions.c
@@ -712,15 +712,14 @@ void CtdlShutdownServiceHooks(void) {
 }
 
 
-void CtdlRegisterSearchFuncHook(void (*fcn_ptr)(int *, long **, const char *), char *name) {
+void CtdlRegisterSearchFuncHook(Array (*fcn_ptr)(const char *), char *name) {
        SearchFunctionHook *newfcn;
 
        if (!name || !fcn_ptr) {
                return;
        }
        
-       newfcn = (SearchFunctionHook *)
-           malloc(sizeof(SearchFunctionHook));
+       newfcn = (SearchFunctionHook *) malloc(sizeof(SearchFunctionHook));
        newfcn->next = SearchFunctionHookTable;
        newfcn->name = name;
        newfcn->fcn_ptr = fcn_ptr;