mirror of
https://github.com/rkd77/elinks.git
synced 2024-12-04 14:46:47 -05:00
66305fcb50
Now, only meson was changed. -Dnls=true -Dgettext=true
455 lines
11 KiB
C
455 lines
11 KiB
C
/* Global history */
|
|
|
|
#ifndef _GNU_SOURCE
|
|
#define _GNU_SOURCE /* XXX: we _WANT_ strcasestr() ! */
|
|
#endif
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#include "elinks.h"
|
|
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#include "bfu/dialog.h"
|
|
#include "config/home.h"
|
|
#include "config/options.h"
|
|
#include "globhist/dialogs.h"
|
|
#include "globhist/globhist.h"
|
|
#include "intl/libintl.h"
|
|
#include "main/module.h"
|
|
#include "main/object.h"
|
|
#include "main/select.h"
|
|
#include "util/conv.h"
|
|
#include "util/file.h"
|
|
#include "util/hash.h"
|
|
#include "util/memory.h"
|
|
#include "util/secsave.h"
|
|
#include "util/string.h"
|
|
#include "util/lists.h"
|
|
#include "util/time.h"
|
|
|
|
#define GLOBAL_HISTORY_FILENAME "globhist"
|
|
|
|
|
|
INIT_INPUT_HISTORY(global_history);
|
|
INIT_LIST_OF(struct global_history_item, global_history_reap_list);
|
|
|
|
|
|
/* GUI stuff. Declared here because done_global_history() frees it. */
|
|
char *gh_last_searched_title = NULL;
|
|
char *gh_last_searched_url = NULL;
|
|
|
|
enum global_history_options {
|
|
GLOBHIST_TREE,
|
|
|
|
GLOBHIST_ENABLE,
|
|
GLOBHIST_MAX_ITEMS,
|
|
GLOBHIST_DISPLAY_TYPE,
|
|
|
|
GLOBHIST_OPTIONS,
|
|
};
|
|
|
|
static union option_info global_history_options[] = {
|
|
INIT_OPT_TREE("document.history", N_("Global history"),
|
|
"global", 0,
|
|
N_("Global history options.")),
|
|
|
|
INIT_OPT_BOOL("document.history.global", N_("Enable"),
|
|
"enable", 0, 1,
|
|
N_("Enable global history (\"history of all pages "
|
|
"visited\").")),
|
|
|
|
INIT_OPT_INT("document.history.global", N_("Maximum number of entries"),
|
|
"max_items", 0, 1, INT_MAX, 1024,
|
|
N_("Maximum number of entries in the global history.")),
|
|
|
|
INIT_OPT_INT("document.history.global", N_("Display style"),
|
|
"display_type", 0, 0, 1, 0,
|
|
N_("What to display in global history dialog:\n"
|
|
"0 is URLs\n"
|
|
"1 is page titles")),
|
|
|
|
/* Compatibility alias: added by jonas at 2004-07-16, 0.9.CVS. */
|
|
INIT_OPT_ALIAS("document.history.global", "write_interval", 0,
|
|
"infofiles.save_interval"),
|
|
|
|
NULL_OPTION_INFO,
|
|
};
|
|
|
|
#define get_opt_globhist(which) global_history_options[(which)].option.value
|
|
#define get_globhist_enable() get_opt_globhist(GLOBHIST_ENABLE).number
|
|
#define get_globhist_max_items() get_opt_globhist(GLOBHIST_MAX_ITEMS).number
|
|
#define get_globhist_display_type() get_opt_globhist(GLOBHIST_DISPLAY_TYPE).number
|
|
|
|
static struct hash *globhist_cache = NULL;
|
|
static int globhist_cache_entries = 0;
|
|
|
|
|
|
static void
|
|
remove_item_from_global_history(struct global_history_item *history_item)
|
|
{
|
|
del_from_history_list(&global_history, history_item);
|
|
|
|
if (globhist_cache) {
|
|
struct hash_item *item;
|
|
|
|
item = get_hash_item(globhist_cache, history_item->url, strlen(history_item->url));
|
|
if (item) {
|
|
del_hash_item(globhist_cache, item);
|
|
globhist_cache_entries--;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
reap_deleted_globhist_items(void)
|
|
{
|
|
struct global_history_item *history_item, *next;
|
|
|
|
foreachsafe(history_item, next, global_history_reap_list) {
|
|
if (!is_object_used(history_item)) {
|
|
del_from_list(history_item);
|
|
mem_free(history_item->title);
|
|
mem_free(history_item->url);
|
|
mem_free(history_item);
|
|
}
|
|
}
|
|
}
|
|
|
|
static void
|
|
done_global_history_item(struct global_history_item *history_item)
|
|
{
|
|
done_listbox_item(&globhist_browser, history_item->box_item);
|
|
|
|
history_item->box_item = NULL;
|
|
|
|
add_to_list(global_history_reap_list, history_item);
|
|
}
|
|
|
|
void
|
|
delete_global_history_item(struct global_history_item *history_item)
|
|
{
|
|
remove_item_from_global_history(history_item);
|
|
|
|
done_global_history_item(history_item);
|
|
}
|
|
|
|
/* Search global history for item matching url. */
|
|
struct global_history_item *
|
|
get_global_history_item(char *url)
|
|
{
|
|
struct hash_item *item;
|
|
|
|
if (!url || !globhist_cache) return NULL;
|
|
|
|
/* Search for cached entry. */
|
|
|
|
item = get_hash_item(globhist_cache, url, strlen(url));
|
|
|
|
return item ? (struct global_history_item *) item->value : NULL;
|
|
}
|
|
|
|
#if 0
|
|
/* Search global history for certain item. There must be full match with the
|
|
* parameter or the parameter must be NULL/zero. */
|
|
struct global_history_item *
|
|
multiget_global_history_item(char *url, char *title, time_t time)
|
|
{
|
|
struct global_history_item *history_item;
|
|
|
|
/* Code duplication vs performance, since this function is called most
|
|
* of time for url matching only... Execution time is divided by 2. */
|
|
if (url && !title && !time) {
|
|
return get_global_history_item(url);
|
|
} else {
|
|
foreach (history_item, global_history.items) {
|
|
if ((!url || !strcmp(history_item->url, url)) &&
|
|
(!title || !strcmp(history_item->title, title)) &&
|
|
(!time || history_item->last_visit == time)) {
|
|
return history_item;
|
|
}
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
#endif
|
|
|
|
static struct global_history_item *
|
|
init_global_history_item(char *url, char *title, time_t vtime)
|
|
{
|
|
struct global_history_item *history_item;
|
|
|
|
history_item = mem_calloc(1, sizeof(*history_item));
|
|
if (!history_item)
|
|
return NULL;
|
|
|
|
history_item->last_visit = vtime;
|
|
history_item->title = stracpy(empty_string_or_(title));
|
|
if (!history_item->title) {
|
|
mem_free(history_item);
|
|
return NULL;
|
|
}
|
|
sanitize_title(history_item->title);
|
|
|
|
history_item->url = stracpy(url);
|
|
if (!history_item->url || !sanitize_url(history_item->url)) {
|
|
mem_free_if(history_item->url);
|
|
mem_free(history_item->title);
|
|
mem_free(history_item);
|
|
return NULL;
|
|
}
|
|
|
|
history_item->box_item = add_listbox_leaf(&globhist_browser, NULL,
|
|
history_item);
|
|
if (!history_item->box_item) {
|
|
mem_free(history_item->url);
|
|
mem_free(history_item->title);
|
|
mem_free(history_item);
|
|
return NULL;
|
|
}
|
|
|
|
object_nolock(history_item, "globhist");
|
|
|
|
return history_item;
|
|
}
|
|
|
|
static int
|
|
cap_global_history(int max_globhist_items)
|
|
{
|
|
while (global_history.size >= max_globhist_items) {
|
|
struct global_history_item *history_item;
|
|
|
|
history_item = global_history.entries.prev;
|
|
|
|
if ((void *) history_item == &global_history.entries) {
|
|
INTERNAL("global history is empty");
|
|
global_history.size = 0;
|
|
return 0;
|
|
}
|
|
|
|
delete_global_history_item(history_item);
|
|
}
|
|
|
|
return 1;
|
|
}
|
|
|
|
static void
|
|
add_item_to_global_history(struct global_history_item *history_item,
|
|
int max_globhist_items)
|
|
{
|
|
add_to_history_list(&global_history, history_item);
|
|
|
|
/* Hash creation if needed. */
|
|
if (!globhist_cache)
|
|
globhist_cache = init_hash8();
|
|
|
|
if (globhist_cache && globhist_cache_entries < max_globhist_items) {
|
|
int urllen = strlen(history_item->url);
|
|
|
|
/* Create a new entry. */
|
|
if (add_hash_item(globhist_cache, history_item->url, urllen, history_item)) {
|
|
globhist_cache_entries++;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Add a new entry in history list, take care of duplicate, respect history
|
|
* size limit, and update any open history dialogs. */
|
|
void
|
|
add_global_history_item(char *url, char *title, time_t vtime)
|
|
{
|
|
struct global_history_item *history_item;
|
|
int max_globhist_items;
|
|
|
|
if (!url || !get_globhist_enable()) return;
|
|
|
|
max_globhist_items = get_globhist_max_items();
|
|
|
|
history_item = get_global_history_item(url);
|
|
if (history_item) delete_global_history_item(history_item);
|
|
|
|
if (!cap_global_history(max_globhist_items)) return;
|
|
|
|
reap_deleted_globhist_items();
|
|
|
|
history_item = init_global_history_item(url, title, vtime);
|
|
if (!history_item) return;
|
|
|
|
add_item_to_global_history(history_item, max_globhist_items);
|
|
}
|
|
|
|
|
|
int
|
|
globhist_simple_search(char *search_url, char *search_title)
|
|
{
|
|
struct global_history_item *history_item;
|
|
|
|
if (!search_title || !search_url)
|
|
return 0;
|
|
|
|
/* Memorize last searched title */
|
|
mem_free_set(&gh_last_searched_title, stracpy(search_title));
|
|
if (!gh_last_searched_title) return 0;
|
|
|
|
/* Memorize last searched url */
|
|
mem_free_set(&gh_last_searched_url, stracpy(search_url));
|
|
if (!gh_last_searched_url) return 0;
|
|
|
|
if (!*search_title && !*search_url) {
|
|
/* No search terms, make all entries visible. */
|
|
foreach (history_item, global_history.entries) {
|
|
history_item->box_item->visible = 1;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
foreach (history_item, global_history.entries) {
|
|
/* Make matching entries visible, hide others. */
|
|
if ((*search_title
|
|
&& strcasestr((const char *)history_item->title, (const char *)search_title))
|
|
|| (*search_url
|
|
&& c_strcasestr((const char *)history_item->url, (const char *)search_url))) {
|
|
history_item->box_item->visible = 1;
|
|
} else {
|
|
history_item->box_item->visible = 0;
|
|
}
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
|
|
static void
|
|
read_global_history(void)
|
|
{
|
|
char in_buffer[MAX_STR_LEN * 3];
|
|
char *file_name = GLOBAL_HISTORY_FILENAME;
|
|
char *title;
|
|
FILE *f;
|
|
|
|
if (!get_globhist_enable()
|
|
|| get_cmd_opt_bool("anonymous"))
|
|
return;
|
|
|
|
if (elinks_home) {
|
|
file_name = straconcat(elinks_home, file_name,
|
|
(char *) NULL);
|
|
if (!file_name) return;
|
|
}
|
|
f = fopen(file_name, "rb");
|
|
if (elinks_home) mem_free(file_name);
|
|
if (!f) return;
|
|
|
|
title = in_buffer;
|
|
global_history.nosave = 1;
|
|
|
|
while (fgets(in_buffer, sizeof(in_buffer), f)) {
|
|
char *url, *last_visit, *eol;
|
|
|
|
url = strchr((const char *)title, '\t');
|
|
if (!url) continue;
|
|
*url++ = '\0'; /* Now url points to the character after \t. */
|
|
|
|
last_visit = strchr((const char *)url, '\t');
|
|
if (!last_visit) continue;
|
|
*last_visit++ = '\0';
|
|
|
|
eol = strchr((const char *)last_visit, '\n');
|
|
if (!eol) continue;
|
|
*eol = '\0'; /* Drop ending '\n'. */
|
|
|
|
add_global_history_item(url, title, str_to_time_t(last_visit));
|
|
}
|
|
|
|
global_history.nosave = 0;
|
|
fclose(f);
|
|
}
|
|
|
|
static void
|
|
write_global_history(void)
|
|
{
|
|
struct global_history_item *history_item;
|
|
char *file_name;
|
|
struct secure_save_info *ssi;
|
|
|
|
if (!global_history.dirty || !elinks_home
|
|
|| !get_globhist_enable()
|
|
|| get_cmd_opt_bool("anonymous"))
|
|
return;
|
|
|
|
file_name = straconcat(elinks_home, GLOBAL_HISTORY_FILENAME,
|
|
(char *) NULL);
|
|
if (!file_name) return;
|
|
|
|
ssi = secure_open(file_name);
|
|
mem_free(file_name);
|
|
if (!ssi) return;
|
|
|
|
foreachback (history_item, global_history.entries) {
|
|
if (secure_fprintf(ssi, "%s\t%s\t%"TIME_PRINT_FORMAT"\n",
|
|
history_item->title,
|
|
history_item->url,
|
|
(time_print_T) history_item->last_visit) < 0)
|
|
break;
|
|
}
|
|
|
|
if (!secure_close(ssi)) global_history.dirty = 0;
|
|
}
|
|
|
|
static void
|
|
free_global_history(void)
|
|
{
|
|
if (globhist_cache) {
|
|
free_hash(&globhist_cache);
|
|
globhist_cache_entries = 0;
|
|
}
|
|
|
|
while (!list_empty(global_history.entries))
|
|
delete_global_history_item(global_history.entries.next);
|
|
|
|
reap_deleted_globhist_items();
|
|
}
|
|
|
|
static enum evhook_status
|
|
global_history_write_hook(va_list ap, void *data)
|
|
{
|
|
write_global_history();
|
|
return EVENT_HOOK_STATUS_NEXT;
|
|
}
|
|
|
|
struct event_hook_info global_history_hooks[] = {
|
|
{ "periodic-saving", 0, global_history_write_hook, NULL },
|
|
|
|
NULL_EVENT_HOOK_INFO,
|
|
};
|
|
|
|
static void
|
|
init_global_history(struct module *module)
|
|
{
|
|
read_global_history();
|
|
}
|
|
|
|
static void
|
|
done_global_history(struct module *module)
|
|
{
|
|
write_global_history();
|
|
free_global_history();
|
|
mem_free_if(gh_last_searched_title);
|
|
mem_free_if(gh_last_searched_url);
|
|
}
|
|
|
|
struct module global_history_module = struct_module(
|
|
/* name: */ N_("Global History"),
|
|
/* options: */ global_history_options,
|
|
/* events: */ global_history_hooks,
|
|
/* submodules: */ NULL,
|
|
/* data: */ NULL,
|
|
/* init: */ init_global_history,
|
|
/* done: */ done_global_history
|
|
);
|