src/globhist/globhist.c

   1 /* Global history */
   2
   3 #ifndef _GNU_SOURCE
   4 #define _GNU_SOURCE /* XXX: we _WANT_ strcasestr() ! */
   5 #endif
   6
   7 #ifdef HAVE_CONFIG_H
   8 #include "config.h"
   9 #endif
  10
  11 #include "elinks.h"
  12
  13 #include <stdio.h>
  14 #include <stdlib.h>
  15 #include <string.h>
  16 #ifdef HAVE_TIME_H
  17 #include <time.h>
  18 #endif
  19
  20 #include "bfu/dialog.h"
  21 #include "config/home.h"
  22 #include "config/options.h"
  23 #include "globhist/dialogs.h"
  24 #include "globhist/globhist.h"
  25 #include "intl/gettext/libintl.h"
  26 #include "main/module.h"
  27 #include "main/object.h"
  28 #include "main/select.h"
  29 #include "util/conv.h"
  30 #include "util/file.h"
  31 #include "util/hash.h"
  32 #include "util/memory.h"
  33 #include "util/secsave.h"
  34 #include "util/string.h"
  35 #include "util/lists.h"
  36 #include "util/time.h"
  37
  38 #define GLOBAL_HISTORY_FILENAME         "globhist"
  39
  40
  41 INIT_INPUT_HISTORY(global_history);
  42 INIT_LIST_OF(struct global_history_item, global_history_reap_list);
  43
  44
  45 /* GUI stuff. Declared here because done_global_history() frees it. */
  46 unsigned char *gh_last_searched_title = NULL;
  47 unsigned char *gh_last_searched_url = NULL;
  48
  49 enum global_history_options {
  50         GLOBHIST_TREE,
  51
  52         GLOBHIST_ENABLE,
  53         GLOBHIST_MAX_ITEMS,
  54         GLOBHIST_DISPLAY_TYPE,
  55
  56         GLOBHIST_OPTIONS,
  57 };
  58
  59 static struct option_info global_history_options[] = {
  60         INIT_OPT_TREE("document.history", N_("Global history"),
  61                 "global", 0,
  62                 N_("Global history options.")),
  63
  64         INIT_OPT_BOOL("document.history.global", N_("Enable"),
  65                 "enable", 0, 1,
  66                 N_("Enable global history (\"history of all pages visited\").")),
  67
  68         INIT_OPT_INT("document.history.global", N_("Maximum number of entries"),
  69                 "max_items", 0, 1, INT_MAX, 1024,
  70                 N_("Maximum number of entries in the global history.")),
  71
  72         INIT_OPT_INT("document.history.global", N_("Display style"),
  73                 "display_type", 0, 0, 1, 0,
  74                 N_("What to display in global history dialog:\n"
  75                 "0 is URLs\n"
  76                 "1 is page titles")),
  77
  78         /* Compatibility alias: added by jonas at 2004-07-16, 0.9.CVS. */
  79         INIT_OPT_ALIAS("document.history.global", "write_interval", 0,
  80                 "infofiles.save_interval"),
  81
  82         NULL_OPTION_INFO,
  83 };
  84
  85 #define get_opt_globhist(which)         global_history_options[(which)].option.value
  86 #define get_globhist_enable()           get_opt_globhist(GLOBHIST_ENABLE).number
  87 #define get_globhist_max_items()        get_opt_globhist(GLOBHIST_MAX_ITEMS).number
  88 #define get_globhist_display_type()     get_opt_globhist(GLOBHIST_DISPLAY_TYPE).number
  89
  90 static struct hash *globhist_cache = NULL;
  91 static int globhist_cache_entries = 0;
  92
  93
  94 static void
  95 remove_item_from_global_history(struct global_history_item *history_item)
  96 {
  97         del_from_history_list(&global_history, history_item);
  98
  99         if (globhist_cache) {
 100                 struct hash_item *item;
 101
 102                 item = get_hash_item(globhist_cache, history_item->url, strlen(history_item->url));
 103                 if (item) {
 104                         del_hash_item(globhist_cache, item);
 105                         globhist_cache_entries--;
 106                 }
 107         }
 108 }
 109
 110 static void
 111 reap_deleted_globhist_items(void)
 112 {
 113         struct global_history_item *history_item, *next;
 114
 115         foreachsafe(history_item, next, global_history_reap_list) {
 116                 if (!is_object_used(history_item)) {
 117                         del_from_list(history_item);
 118                         mem_free(history_item->title);
 119                         mem_free(history_item->url);
 120                         mem_free(history_item);
 121                 }
 122         }
 123 }
 124
 125 static void
 126 done_global_history_item(struct global_history_item *history_item)
 127 {
 128         done_listbox_item(&globhist_browser, history_item->box_item);
 129
 130         history_item->box_item = NULL;
 131
 132         add_to_list(global_history_reap_list, history_item);
 133 }
 134
 135 void
 136 delete_global_history_item(struct global_history_item *history_item)
 137 {
 138         remove_item_from_global_history(history_item);
 139
 140         done_global_history_item(history_item);
 141 }
 142
 143 /* Search global history for item matching url. */
 144 struct global_history_item *
 145 get_global_history_item(unsigned char *url)
 146 {
 147         struct hash_item *item;
 148
 149         if (!url || !globhist_cache) return NULL;
 150
 151         /* Search for cached entry. */
 152
 153         item = get_hash_item(globhist_cache, url, strlen(url));
 154
 155         return item ? (struct global_history_item *) item->value : NULL;
 156 }
 157
 158 #if 0
 159 /* Search global history for certain item. There must be full match with the
 160  * parameter or the parameter must be NULL/zero. */
 161 struct global_history_item *
 162 multiget_global_history_item(unsigned char *url, unsigned char *title, time_t time)
 163 {
 164         struct global_history_item *history_item;
 165
 166         /* Code duplication vs performance, since this function is called most
 167          * of time for url matching only... Execution time is divided by 2. */
 168         if (url && !title && !time) {
 169                 return get_global_history_item(url);
 170         } else {
 171                 foreach (history_item, global_history.items) {
 172                         if ((!url || !strcmp(history_item->url, url)) &&
 173                             (!title || !strcmp(history_item->title, title)) &&
 174                             (!time || history_item->last_visit == time)) {
 175                                 return history_item;
 176                         }
 177                 }
 178         }
 179
 180         return NULL;
 181 }
 182 #endif
 183
 184 static struct global_history_item *
 185 init_global_history_item(unsigned char *url, unsigned char *title, time_t vtime)
 186 {
 187         struct global_history_item *history_item;
 188
 189         history_item = mem_calloc(1, sizeof(*history_item));
 190         if (!history_item)
 191                 return NULL;
 192
 193         history_item->last_visit = vtime;
 194         history_item->title = stracpy(empty_string_or_(title));
 195         if (!history_item->title) {
 196                 mem_free(history_item);
 197                 return NULL;
 198         }
 199         sanitize_title(history_item->title);
 200
 201         history_item->url = stracpy(url);
 202         if (!history_item->url || !sanitize_url(history_item->url)) {
 203                 mem_free_if(history_item->url);
 204                 mem_free(history_item->title);
 205                 mem_free(history_item);
 206                 return NULL;
 207         }
 208
 209         history_item->box_item = add_listbox_leaf(&globhist_browser, NULL,
 210                                                   history_item);
 211         if (!history_item->box_item) {
 212                 mem_free(history_item->url);
 213                 mem_free(history_item->title);
 214                 mem_free(history_item);
 215                 return NULL;
 216         }
 217
 218         object_nolock(history_item, "globhist");
 219
 220         return history_item;
 221 }
 222
 223 static int
 224 cap_global_history(int max_globhist_items)
 225 {
 226         while (global_history.size >= max_globhist_items) {
 227                 struct global_history_item *history_item;
 228
 229                 history_item = global_history.entries.prev;
 230
 231                 if ((void *) history_item == &global_history.entries) {
 232                         INTERNAL("global history is empty");
 233                         global_history.size = 0;
 234                         return 0;
 235                 }
 236
 237                 delete_global_history_item(history_item);
 238         }
 239
 240         return 1;
 241 }
 242
 243 static void
 244 add_item_to_global_history(struct global_history_item *history_item,
 245                            int max_globhist_items)
 246 {
 247         add_to_history_list(&global_history, history_item);
 248
 249         /* Hash creation if needed. */
 250         if (!globhist_cache)
 251                 globhist_cache = init_hash8();
 252
 253         if (globhist_cache && globhist_cache_entries < max_globhist_items) {
 254                 int urllen = strlen(history_item->url);
 255
 256                 /* Create a new entry. */
 257                 if (add_hash_item(globhist_cache, history_item->url, urllen, history_item)) {
 258                         globhist_cache_entries++;
 259                 }
 260         }
 261 }
 262
 263 /* Add a new entry in history list, take care of duplicate, respect history
 264  * size limit, and update any open history dialogs. */
 265 void
 266 add_global_history_item(unsigned char *url, unsigned char *title, time_t vtime)
 267 {
 268         struct global_history_item *history_item;
 269         int max_globhist_items;
 270
 271         if (!url || !get_globhist_enable()) return;
 272
 273         max_globhist_items = get_globhist_max_items();
 274
 275         history_item = get_global_history_item(url);
 276         if (history_item) delete_global_history_item(history_item);
 277
 278         if (!cap_global_history(max_globhist_items)) return;
 279
 280         reap_deleted_globhist_items();
 281
 282         history_item = init_global_history_item(url, title, vtime);
 283         if (!history_item) return;
 284
 285         add_item_to_global_history(history_item, max_globhist_items);
 286 }
 287
 288
 289 int
 290 globhist_simple_search(unsigned char *search_url, unsigned char *search_title)
 291 {
 292         struct global_history_item *history_item;
 293
 294         if (!search_title || !search_url)
 295                 return 0;
 296
 297         /* Memorize last searched title */
 298         mem_free_set(&gh_last_searched_title, stracpy(search_title));
 299         if (!gh_last_searched_title) return 0;
 300
 301         /* Memorize last searched url */
 302         mem_free_set(&gh_last_searched_url, stracpy(search_url));
 303         if (!gh_last_searched_url) {
 304                 mem_free(gh_last_searched_title);
 305                 return 0;
 306         }
 307
 308         if (!*search_title && !*search_url) {
 309                 /* No search terms, make all entries visible. */
 310                 foreach (history_item, global_history.entries) {
 311                         history_item->box_item->visible = 1;
 312                 }
 313                 return 1;
 314         }
 315
 316         foreach (history_item, global_history.entries) {
 317                 /* Make matching entries visible, hide others. */
 318                 if ((*search_title
 319                      && strcasestr(history_item->title, search_title))
 320                     || (*search_url
 321                         && strcasestr(history_item->url, search_url))) {
 322                         history_item->box_item->visible = 1;
 323                 } else {
 324                         history_item->box_item->visible = 0;
 325                 }
 326         }
 327         return 1;
 328 }
 329
 330
 331 static void
 332 read_global_history(void)
 333 {
 334         unsigned char in_buffer[MAX_STR_LEN * 3];
 335         unsigned char *file_name = GLOBAL_HISTORY_FILENAME;
 336         unsigned char *title;
 337         FILE *f;
 338
 339         if (!get_globhist_enable()
 340             || get_cmd_opt_bool("anonymous"))
 341                 return;
 342
 343         if (elinks_home) {
 344                 file_name = straconcat(elinks_home, file_name,
 345                                        (unsigned char *) NULL);
 346                 if (!file_name) return;
 347         }
 348         f = fopen(file_name, "rb");
 349         if (elinks_home) mem_free(file_name);
 350         if (!f) return;
 351
 352         title = in_buffer;
 353         global_history.nosave = 1;
 354
 355         while (fgets(in_buffer, sizeof(in_buffer), f)) {
 356                 unsigned char *url, *last_visit, *eol;
 357
 358                 url = strchr(title, '\t');
 359                 if (!url) continue;
 360                 *url++ = '\0'; /* Now url points to the character after \t. */
 361
 362                 last_visit = strchr(url, '\t');
 363                 if (!last_visit) continue;
 364                 *last_visit++ = '\0';
 365
 366                 eol = strchr(last_visit, '\n');
 367                 if (!eol) continue;
 368                 *eol = '\0'; /* Drop ending '\n'. */
 369
 370                 add_global_history_item(url, title, str_to_time_t(last_visit));
 371         }
 372
 373         global_history.nosave = 0;
 374         fclose(f);
 375 }
 376
 377 static void
 378 write_global_history(void)
 379 {
 380         struct global_history_item *history_item;
 381         unsigned char *file_name;
 382         struct secure_save_info *ssi;
 383
 384         if (!global_history.dirty || !elinks_home
 385             || !get_globhist_enable()
 386             || get_cmd_opt_bool("anonymous"))
 387                 return;
 388
 389         file_name = straconcat(elinks_home, GLOBAL_HISTORY_FILENAME,
 390                                (unsigned char *) NULL);
 391         if (!file_name) return;
 392
 393         ssi = secure_open(file_name);
 394         mem_free(file_name);
 395         if (!ssi) return;
 396
 397         foreachback (history_item, global_history.entries) {
 398                 if (secure_fprintf(ssi, "%s\t%s\t%"TIME_PRINT_FORMAT"\n",
 399                                    history_item->title,
 400                                    history_item->url,
 401                                    (time_print_T) history_item->last_visit) < 0)
 402                         break;
 403         }
 404
 405         if (!secure_close(ssi)) global_history.dirty = 0;
 406 }
 407
 408 static void
 409 free_global_history(void)
 410 {
 411         if (globhist_cache) {
 412                 free_hash(&globhist_cache);
 413                 globhist_cache_entries = 0;
 414         }
 415
 416         while (!list_empty(global_history.entries))
 417                 delete_global_history_item(global_history.entries.next);
 418
 419         reap_deleted_globhist_items();
 420 }
 421
 422 static enum evhook_status
 423 global_history_write_hook(va_list ap, void *data)
 424 {
 425         write_global_history();
 426         return EVENT_HOOK_STATUS_NEXT;
 427 }
 428
 429 struct event_hook_info global_history_hooks[] = {
 430         { "periodic-saving", 0, global_history_write_hook, NULL },
 431
 432         NULL_EVENT_HOOK_INFO,
 433 };
 434
 435 static void
 436 init_global_history(struct module *module)
 437 {
 438         read_global_history();
 439 }
 440
 441 static void
 442 done_global_history(struct module *module)
 443 {
 444         write_global_history();
 445         free_global_history();
 446         mem_free_if(gh_last_searched_title);
 447         mem_free_if(gh_last_searched_url);
 448 }
 449
 450 struct module global_history_module = struct_module(
 451         /* name: */             N_("Global History"),
 452         /* options: */          global_history_options,
 453         /* events: */           global_history_hooks,
 454         /* submodules: */       NULL,
 455         /* data: */             NULL,
 456         /* init: */             init_global_history,
 457         /* done: */             done_global_history
 458 );