1
0
mirror of https://github.com/rkd77/elinks.git synced 2024-12-04 14:46:47 -05:00
elinks/src/session/session.cpp
Witold Filipczyk 361b8f661d [long] long -> intptr_t . Refs #8304
AFAIK on Windows long is sizeof 4, while void * is sizeof 8.
intptr_t is the same sizeof as void *.
2022-08-17 20:48:58 +02:00

1678 lines
42 KiB
C++

/** Sessions managment - you'll find things here which you wouldn't expect
* @file */
#ifdef HAVE_CONFIG_H
#include "config.h"
#endif
#ifdef HAVE_STDINT_H
#include <stdint.h>
#endif
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "elinks.h"
#include "bfu/dialog.h"
#include "bookmarks/bookmarks.h"
#include "cache/cache.h"
#include "config/home.h"
#include "config/options.h"
#include "dialogs/menu.h"
#include "dialogs/status.h"
#include "document/document.h"
#include "document/html/frames.h"
#include "document/html/iframes.h"
#include "document/refresh.h"
#include "document/renderer.h"
#include "document/view.h"
#include "globhist/globhist.h"
#include "intl/libintl.h"
#include "main/event.h"
#include "main/object.h"
#include "main/timer.h"
#include "network/connection.h"
#include "network/state.h"
#include "osdep/newwin.h"
#include "protocol/http/blacklist.h"
#include "protocol/protocol.h"
#include "protocol/uri.h"
#ifdef CONFIG_SCRIPTING_SPIDERMONKEY
# include "scripting/smjs/smjs.h"
#endif
#include "session/download.h"
#include "session/history.h"
#include "session/location.h"
#include "session/session.h"
#include "session/task.h"
#include "terminal/tab.h"
#include "terminal/terminal.h"
#include "terminal/window.h"
#include "util/conv.h"
#include "util/error.h"
#include "util/memlist.h"
#include "util/memory.h"
#include "util/string.h"
#include "util/time.h"
#include "viewer/text/draw.h"
#include "viewer/text/form.h"
#include "viewer/text/link.h"
#include "viewer/text/view.h"
#include "viewer/text/search.h"
struct file_to_load {
LIST_HEAD(struct file_to_load);
struct session *ses;
unsigned int req_sent:1;
int pri;
struct cache_entry *cached;
char *target_frame;
struct uri *uri;
struct download download;
};
/** This structure and related functions are used to maintain information
* for instances opened in new windows. We store all related session info like
* URI and base session to clone from so that when the new instance connects
* we can look up this information. In case of failure the session information
* has a timeout */
struct session_info {
LIST_HEAD(struct session_info);
int id;
timer_id_T timer;
struct session *ses;
struct uri *uri;
struct uri *referrer;
enum task_type task;
cache_mode_T cache_mode;
};
#define file_to_load_is_active(ftl) ((ftl)->req_sent && is_in_progress_state((ftl)->download.state))
INIT_LIST_OF(struct session, sessions);
remote_session_flags_T remote_session_flags;
static struct file_to_load *request_additional_file(struct session *,
const char *,
struct uri *, int);
static window_handler_T tabwin_func;
static INIT_LIST_OF(struct session_info, session_info);
static int session_info_id = 1;
static struct session_info *
get_session_info(int id)
{
struct session_info *info;
foreach (info, session_info) {
struct session *ses;
if (info->id != id) continue;
/* Make sure the info->ses session is still with us. */
foreach (ses, sessions)
if (ses == info->ses)
return info;
info->ses = NULL;
return info;
}
return NULL;
}
static void
done_session_info(struct session_info *info)
{
del_from_list(info);
kill_timer(&info->timer);
if (info->uri) done_uri(info->uri);
if (info->referrer) done_uri(info->referrer);
mem_free(info);
}
void
done_saved_session_info(void)
{
while (!list_empty(session_info))
done_session_info((struct session_info *)session_info.next);
}
/** Timer callback for session_info.timer. As explained in install_timer(),
* this function must erase the expired timer ID from all variables. */
static void
session_info_timeout(int id)
{
struct session_info *info = get_session_info(id);
if (!info) return;
info->timer = TIMER_ID_UNDEF;
/* The expired timer ID has now been erased. */
done_session_info(info);
}
int
add_session_info(struct session *ses, struct uri *uri, struct uri *referrer,
cache_mode_T cache_mode, enum task_type task)
{
struct session_info *info = (struct session_info *)mem_calloc(1, sizeof(*info));
if (!info) return -1;
info->id = session_info_id++;
/* I don't know what a reasonable start up time for a new instance is
* but it won't hurt to have a few seconds atleast. --jonas */
install_timer(&info->timer, (milliseconds_T) 10000,
(void (*)(void *)) session_info_timeout,
(void *) (intptr_t) info->id);
info->ses = ses;
info->task = task;
info->cache_mode = cache_mode;
if (uri) info->uri = get_uri_reference(uri);
if (referrer) info->referrer = get_uri_reference(referrer);
add_to_list(session_info, info);
return info->id;
}
static struct session *
init_saved_session(struct terminal *term, int id)
{
struct session_info *info = get_session_info(id);
struct session *ses;
if (!info) return NULL;
ses = init_session(info->ses, term, info->uri, 0);
if (!ses) {
done_session_info(info);
return ses;
}
/* Only do the ses_goto()-thing for target=_blank. */
if (info->uri && info->task != TASK_NONE) {
/* The init_session() call would have started the download but
* not with the requested cache mode etc. so interrupt that
* download . */
abort_loading(ses, 1);
ses->reloadlevel = info->cache_mode;
set_session_referrer(ses, info->referrer);
ses_goto(ses, info->uri, NULL, NULL, info->cache_mode,
info->task, 0);
}
done_session_info(info);
return ses;
}
static struct session *
get_master_session(void)
{
struct session *ses;
foreach (ses, sessions)
if (ses->tab->term->master) {
struct window *current_tab = get_current_tab(ses->tab->term);
return (struct session *)(current_tab ? current_tab->data : NULL);
}
return NULL;
}
/** @relates session */
struct download *
get_current_download(struct session *ses)
{
struct download *download = NULL;
if (!ses) return NULL;
if (ses->task.type)
download = &ses->loading;
else if (have_location(ses))
download = &cur_loc(ses)->download;
if (download && is_in_state(download->state, S_OK)) {
struct file_to_load *ftl;
foreach (ftl, ses->more_files)
if (file_to_load_is_active(ftl))
return &ftl->download;
}
/* Note that @download isn't necessarily NULL here,
* if @ses->more_files is empty. -- Miciah */
return download;
}
static void
done_retry_connection_without_verification(void *data)
{
struct delayed_open *deo = (struct delayed_open *)data;
if (deo) {
done_uri(deo->uri);
mem_free(deo);
}
}
static void
retry_connection_without_verification(void *data)
{
struct delayed_open *deo = (struct delayed_open *)data;
if (deo) {
if (deo->uri->hostlen) {
add_blacklist_entry(deo->uri, SERVER_BLACKLIST_NO_CERT_VERIFY);
}
goto_uri(deo->ses, deo->uri);
done_uri(deo->uri);
mem_free(deo);
}
}
void
print_error_dialog(struct session *ses, struct connection_state state,
struct uri *uri, connection_priority_T priority)
{
struct string msg;
char *uristring;
/* Don't show error dialogs for missing CSS stylesheets */
if (priority == PRI_CSS
|| !init_string(&msg))
return;
uristring = uri ? get_uri_string(uri, URI_PUBLIC) : NULL;
if (uristring) {
#ifdef CONFIG_UTF8
if (ses->tab->term->utf8_cp)
decode_uri(uristring);
else
#endif /* CONFIG_UTF8 */
decode_uri_for_display(uristring);
add_format_to_string(&msg,
_("Unable to retrieve %s", ses->tab->term),
uristring);
mem_free(uristring);
add_to_string(&msg, ":\n\n");
}
add_to_string(&msg, get_state_message(state, ses->tab->term));
if (!uri || (uri->protocol != PROTOCOL_HTTPS && uri->protocol != PROTOCOL_GEMINI)) {
info_box(ses->tab->term, MSGBOX_FREE_TEXT,
N_("Error"), ALIGN_CENTER,
msg.source);
} else {
struct delayed_open *deo = (struct delayed_open *)mem_calloc(1, sizeof(*deo));
if (!deo) return;
add_to_string(&msg, "\n\n");
add_to_string(&msg, N_("Retry without verification?"));
deo->ses = ses;
deo->uri = get_uri_reference(uri);
msg_box(ses->tab->term, NULL, MSGBOX_FREE_TEXT,
N_("Error"), ALIGN_CENTER,
msg.source,
deo, 2,
MSG_BOX_BUTTON(N_("~Yes"), retry_connection_without_verification, B_ENTER),
MSG_BOX_BUTTON(N_("~No"), done_retry_connection_without_verification, B_ESC));
}
/* TODO: retry */
}
static void
abort_files_load(struct session *ses, int interrupt)
{
while (1) {
struct file_to_load *ftl;
int more = 0;
foreach (ftl, ses->more_files) {
if (!file_to_load_is_active(ftl))
continue;
more = 1;
cancel_download(&ftl->download, interrupt);
}
if (!more) break;
};
}
void
free_files(struct session *ses)
{
struct file_to_load *ftl;
abort_files_load(ses, 0);
foreach (ftl, ses->more_files) {
if (ftl->cached) object_unlock(ftl->cached);
if (ftl->uri) done_uri(ftl->uri);
mem_free_if(ftl->target_frame);
}
free_list(ses->more_files);
}
static void request_frameset(struct session *, struct frameset_desc *, int);
static void
request_frame(struct session *ses, char *name,
struct uri *uri, int depth)
{
struct location *loc = cur_loc(ses);
struct frame *frame;
assertm(have_location(ses), "request_frame: no location");
if_assert_failed return;
foreach (frame, loc->frames) {
struct document_view *doc_view;
if (c_strcasecmp(frame->name, name))
continue;
foreach (doc_view, ses->scrn_frames) {
if (doc_view->vs == &frame->vs && doc_view->document->frame_desc) {
request_frameset(ses, doc_view->document->frame_desc, depth);
return;
}
}
request_additional_file(ses, name, frame->vs.uri, PRI_FRAME);
return;
}
frame = (struct frame *)mem_calloc(1, sizeof(*frame));
if (!frame) return;
frame->name = stracpy(name);
if (!frame->name) {
mem_free(frame);
return;
}
init_vs(&frame->vs, uri, -1);
add_to_list(loc->frames, frame);
request_additional_file(ses, name, frame->vs.uri, PRI_FRAME);
}
static void
request_iframe(struct session *ses, char *name,
struct uri *uri, int depth)
{
struct location *loc = cur_loc(ses);
struct frame *iframe;
assertm(have_location(ses), "request_frame: no location");
if_assert_failed return;
foreach (iframe, loc->iframes) {
if (c_strcasecmp(iframe->name, name))
continue;
request_additional_file(ses, name, iframe->vs.uri, PRI_IFRAME);
return;
}
iframe = (struct frame *)mem_calloc(1, sizeof(*iframe));
if (!iframe) return;
iframe->name = stracpy(name);
if (!iframe->name) {
mem_free(iframe);
return;
}
init_vs(&iframe->vs, uri, -1);
add_to_list(loc->iframes, iframe);
request_additional_file(ses, name, iframe->vs.uri, PRI_IFRAME);
}
static void
request_frameset(struct session *ses, struct frameset_desc *frameset_desc, int depth)
{
int i;
if (depth > HTML_MAX_FRAME_DEPTH) return;
depth++; /* Inheritation counter (recursion brake ;) */
for (i = 0; i < frameset_desc->n; i++) {
struct frame_desc *frame_desc = &frameset_desc->frame_desc[i];
if (frame_desc->subframe) {
request_frameset(ses, frame_desc->subframe, depth);
} else if (frame_desc->name && frame_desc->uri) {
request_frame(ses, frame_desc->name,
frame_desc->uri, depth);
}
}
}
static void
request_iframes(struct session *ses, struct iframeset_desc *iframeset_desc, int depth)
{
int i;
if (depth > HTML_MAX_FRAME_DEPTH) return;
depth++; /* Inheritation counter (recursion brake ;) */
for (i = 0; i < iframeset_desc->n; i++) {
struct iframe_desc *iframe_desc = &iframeset_desc->iframe_desc[i];
if (iframe_desc->uri) {
request_iframe(ses, iframe_desc->name,
iframe_desc->uri, depth);
}
}
}
#ifdef CONFIG_CSS
static inline void
load_css_imports(struct session *ses, struct document_view *doc_view)
{
struct document *document = doc_view->document;
struct uri *uri;
int index;
if (!document) return;
foreach_uri (uri, index, &document->css_imports) {
request_additional_file(ses, "", uri, PRI_CSS);
}
}
#else
#define load_css_imports(ses, doc_view)
#endif
#ifdef CONFIG_ECMASCRIPT
static inline void
load_ecmascript_imports(struct session *ses, struct document_view *doc_view)
{
struct document *document = doc_view->document;
struct uri *uri;
int index;
if (!document) return;
foreach_uri (uri, index, &document->ecmascript_imports) {
request_additional_file(ses, "", uri, /* XXX */ PRI_CSS);
}
}
#else
#define load_ecmascript_imports(ses, doc_view)
#endif
static void
load_iframes(struct session *ses, struct document_view *doc_view)
{
struct document *document = doc_view->document;
if (!document || !document->iframe_desc) return;
request_iframes(ses, document->iframe_desc, 0);
}
NONSTATIC_INLINE void
load_frames(struct session *ses, struct document_view *doc_view)
{
struct document *document = doc_view->document;
if (!document || !document->frame_desc) return;
request_frameset(ses, document->frame_desc, 0);
foreach (doc_view, ses->scrn_frames) {
load_css_imports(ses, doc_view);
load_ecmascript_imports(ses, doc_view);
}
}
/** Timer callback for session.display_timer. As explained in install_timer(),
* this function must erase the expired timer ID from all variables. */
void
display_timer(struct session *ses)
{
timeval_T start, stop, duration;
milliseconds_T t;
timeval_now(&start);
draw_formatted(ses, 3);
timeval_now(&stop);
timeval_sub(&duration, &start, &stop);
t = mult_ms(timeval_to_milliseconds(&duration), DISPLAY_TIME);
if (t < DISPLAY_TIME_MIN) t = DISPLAY_TIME_MIN;
install_timer(&ses->display_timer, t,
(void (*)(void *)) display_timer,
ses);
/* The expired timer ID has now been erased. */
load_frames(ses, ses->doc_view);
load_css_imports(ses, ses->doc_view);
load_ecmascript_imports(ses, ses->doc_view);
load_iframes(ses, ses->doc_view);
process_file_requests(ses);
}
struct questions_entry {
LIST_HEAD(struct questions_entry);
void (*callback)(struct session *, void *);
void *data;
};
INIT_LIST_OF(struct questions_entry, questions_queue);
void
check_questions_queue(struct session *ses)
{
while (!list_empty(questions_queue)) {
struct questions_entry *q = (struct questions_entry *)questions_queue.next;
q->callback(ses, q->data);
del_from_list(q);
mem_free(q);
}
}
void
add_questions_entry(void (*callback)(struct session *, void *), void *data)
{
struct questions_entry *q = (struct questions_entry *)mem_alloc(sizeof(*q));
if (!q) return;
q->callback = callback;
q->data = data;
add_to_list(questions_queue, q);
}
#ifdef CONFIG_SCRIPTING
void
maybe_pre_format_html(struct cache_entry *cached, struct session *ses)
{
struct fragment *fragment;
static int pre_format_html_event = EVENT_NONE;
if (!cached || cached->preformatted)
return;
/* The script called from here may indirectly call
* garbage_collection(). If the refcount of the cache entry
* were 0, it could then be freed, and the
* cached->preformatted assignment at the end of this function
* would crash. Normally, the document has a reference to the
* cache entry, and that suffices. However, if the cache
* entry was loaded to satisfy e.g. USEMAP="imgmap.html#map",
* then cached->object.refcount == 0 here, and must be
* incremented.
*
* cached->object.refcount == 0 is safe while the cache entry
* is being loaded, because garbage_collection() calls
* is_entry_used(), which checks whether any connection is
* using the cache entry. But loading has ended before this
* point. */
object_lock(cached);
fragment = get_cache_fragment(cached);
if (!fragment) goto unlock_and_return;
/* We cannot do anything if the data are fragmented. */
if (!list_is_singleton(cached->frag)) goto unlock_and_return;
set_event_id(pre_format_html_event, "pre-format-html");
trigger_event(pre_format_html_event, ses, cached);
/* XXX: Keep this after the trigger_event, because hooks might call
* normalize_cache_entry()! */
cached->preformatted = 1;
unlock_and_return:
object_unlock(cached);
}
#endif
static int
check_incomplete_redirects(struct cache_entry *cached)
{
assert(cached);
cached = follow_cached_redirects(cached);
if (cached && !cached->redirect) {
/* XXX: This is not quite true, but does that difference
* matter here? */
return cached->incomplete;
}
return 0;
}
int
session_is_loading(struct session *ses)
{
struct download *download = get_current_download(ses);
if (!download) return 0;
if (!is_in_result_state(download->state))
return 1;
/* The validness of download->cached (especially the download struct in
* ses->loading) is hard to maintain so check before using it.
* Related to bug 559. */
if (download->cached
&& cache_entry_is_valid(download->cached)
&& check_incomplete_redirects(download->cached))
return 1;
return 0;
}
#ifdef CONFIG_ECMASCRIPT
void
doc_rerender_after_document_update(struct session *ses) {
/** This is really not nice. But that's the way
** how to display the final Javascript render
** taken from toggle_plain_html(ses, ses->doc_view, 0);
** This is toggled */
assert(ses && ses->doc_view && ses->tab && ses->tab->term);
if_assert_failed {
return;
}
if (ses->doc_view->document->ecmascript_counter > 0) {
if (ses->doc_view->vs) {
draw_formatted(ses, 3);
//DBG("REDRAWING...");
}
}
}
#endif
void
doc_loading_callback(struct download *download, struct session *ses)
{
int submit = 0;
if (is_in_result_state(download->state)) {
#ifdef CONFIG_SCRIPTING
maybe_pre_format_html(download->cached, ses);
#endif
kill_timer(&ses->display_timer);
draw_formatted(ses, 1);
#ifdef CONFIG_ECMASCRIPT
/* This is implemented to rerender the document
* in case it was modified by document.replace
* or document write */
doc_rerender_after_document_update(ses);
#endif
if (get_cmd_opt_bool("auto-submit")) {
if (!list_empty(ses->doc_view->document->forms)) {
get_cmd_opt_bool("auto-submit") = 0;
submit = 1;
}
}
load_frames(ses, ses->doc_view);
load_css_imports(ses, ses->doc_view);
load_ecmascript_imports(ses, ses->doc_view);
process_file_requests(ses);
start_document_refreshes(ses);
if (!is_in_state(download->state, S_OK)) {
print_error_dialog(ses, download->state,
ses->doc_view->document->uri,
download->pri);
}
} else if (is_in_transfering_state(download->state)
&& ses->display_timer == TIMER_ID_UNDEF) {
display_timer(ses);
}
check_questions_queue(ses);
print_screen_status(ses);
#ifdef CONFIG_GLOBHIST
if (download->pri != PRI_CSS) {
char *title = ses->doc_view->document->title;
struct uri *uri;
if (download->conn)
uri = download->conn->proxied_uri;
else if (download->cached)
uri = download->cached->uri;
else
uri = NULL;
if (uri)
add_global_history_item(struri(uri), title, time(NULL));
}
#endif
if (submit) auto_submit_form(ses);
}
static void
file_loading_callback(struct download *download, struct file_to_load *ftl)
{
if (ftl->download.cached && ftl->cached != ftl->download.cached) {
if (ftl->cached) object_unlock(ftl->cached);
ftl->cached = ftl->download.cached;
object_lock(ftl->cached);
}
/* FIXME: We need to do content-type check here! However, we won't
* handle properly the "Choose action" dialog now :(. */
if (ftl->cached && !ftl->cached->redirect_get && download->pri != PRI_CSS) {
struct session *ses = ftl->ses;
struct uri *loading_uri = ses->loading_uri;
char *target_frame = null_or_stracpy(ses->task.target.frame);
ses->loading_uri = ftl->uri;
mem_free_set(&ses->task.target.frame, null_or_stracpy(ftl->target_frame));
setup_download_handler(ses, &ftl->download, ftl->cached, 1 + (download->pri == PRI_IFRAME));
ses->loading_uri = loading_uri;
mem_free_set(&ses->task.target.frame, target_frame);
}
doc_loading_callback(download, ftl->ses);
}
static struct file_to_load *
request_additional_file(struct session *ses, const char *name, struct uri *uri, int pri)
{
struct file_to_load *ftl;
if (uri->protocol == PROTOCOL_UNKNOWN) {
return NULL;
}
/* XXX: We cannot run the external handler here, because
* request_additional_file() is called many times for a single URL
* (normally the foreach() right below catches them all). Anyway,
* having <frame src="mailto:foo"> would be just weird, wouldn't it?
* --pasky */
if (get_protocol_external_handler(ses->tab->term, uri)) {
return NULL;
}
foreach (ftl, ses->more_files) {
if (compare_uri(ftl->uri, uri, URI_BASE)) {
if (ftl->pri > pri) {
ftl->pri = pri;
move_download(&ftl->download, &ftl->download, pri);
}
return NULL;
}
}
ftl = (struct file_to_load *)mem_calloc(1, sizeof(*ftl));
if (!ftl) return NULL;
ftl->uri = get_uri_reference(uri);
ftl->target_frame = stracpy(name);
ftl->download.callback = (download_callback_T *) file_loading_callback;
ftl->download.data = ftl;
ftl->pri = pri;
ftl->ses = ses;
add_to_list(ses->more_files, ftl);
return ftl;
}
static void
load_additional_file(struct file_to_load *ftl, cache_mode_T cache_mode)
{
struct document_view *doc_view = current_frame(ftl->ses);
struct uri *referrer = doc_view && doc_view->document
? doc_view->document->uri : NULL;
load_uri(ftl->uri, referrer, &ftl->download, ftl->pri, cache_mode, -1);
}
void
process_file_requests(struct session *ses)
{
if (ses->status.processing_file_requests) return;
ses->status.processing_file_requests = 1;
while (1) {
struct file_to_load *ftl;
int more = 0;
foreach (ftl, ses->more_files) {
if (ftl->req_sent)
continue;
ftl->req_sent = 1;
load_additional_file(ftl, CACHE_MODE_NORMAL);
more = 1;
}
if (!more) break;
};
ses->status.processing_file_requests = 0;
}
static void
dialog_goto_url_open(void *data)
{
dialog_goto_url((struct session *) data, NULL);
}
/** @returns 0 if the first session was not properly initialized and
* setup_session() should be called on the session as well. */
static int
setup_first_session(struct session *ses, struct uri *uri)
{
/* [gettext_accelerator_context(setup_first_session)] */
struct terminal *term = ses->tab->term;
if (!*get_opt_str("protocol.http.user_agent", NULL)) {
info_box(term, 0,
N_("Warning"), ALIGN_CENTER,
N_("You have an empty string in protocol.http.user_agent - "
"this was a default value in the past, substituted by "
"default ELinks User-Agent string. However, currently "
"this means that NO User-Agent HEADER "
"WILL BE SENT AT ALL - if this is really what you want, "
"set its value to \" \", otherwise please delete the line "
"with this setting from your configuration file (if you "
"have no idea what I'm talking about, just do this), so "
"that the correct default setting will be used. Apologies for "
"any inconvience caused."));
}
if (!get_opt_bool("config.saving_style_w", NULL)) {
struct option *opt = get_opt_rec(config_options, "config.saving_style_w");
opt->value.number = 1;
option_changed(ses, opt);
if (get_opt_int("config.saving_style", NULL) != 3) {
info_box(term, 0,
N_("Warning"), ALIGN_CENTER,
N_("You have option config.saving_style set to "
"a de facto obsolete value. The configuration "
"saving algorithms of ELinks were changed from "
"the last time you upgraded ELinks. Now, only "
"those options which you actually changed are "
"saved to the configuration file, instead of "
"all the options. This simplifies our "
"situation greatly when we see that some option "
"has an inappropriate default value or we need to "
"change the semantics of some option in a subtle way. "
"Thus, we recommend you change the value of "
"config.saving_style option to 3 in order to get "
"the \"right\" behaviour. Apologies for any "
"inconvience caused."));
}
}
if (first_use) {
/* Only open the goto URL dialog if no URI was passed on the
* command line. */
void (*handler)(void *) = uri ? NULL : dialog_goto_url_open;
first_use = 0;
msg_box(term, NULL, 0,
N_("Welcome"), ALIGN_CENTER,
N_("Welcome to ELinks!\n\n"
"Press ESC for menu. Documentation is available in "
"Help menu."),
ses, 1,
MSG_BOX_BUTTON(N_("~OK"), (void (*)(void *))handler, B_ENTER | B_ESC));
/* If there is no URI the goto dialog will pop up so there is
* no need to call setup_session(). */
if (!uri) return 1;
#ifdef CONFIG_BOOKMARKS
} else if (!uri && get_opt_bool("ui.sessions.auto_restore", NULL)) {
char *folder; /* UTF-8 */
folder = get_auto_save_bookmark_foldername_utf8();
if (folder) {
open_bookmark_folder(ses, folder);
mem_free(folder);
}
return 1;
#endif
}
/* If there's a URI to load we have to call */
return 0;
}
/** First load the current URI of the base session. In most cases it will just
* be fetched from the cache so that the new tab will not appear ``empty' while
* loading the real URI or showing the goto URL dialog. */
static void
setup_session(struct session *ses, struct uri *uri, struct session *base)
{
if (base && !get_opt_bool("document.browse.search.reset", NULL)) {
ses->search_word = null_or_stracpy(base->search_word);
}
if (base && have_location(base)) {
ses_load(ses, get_uri_reference(cur_loc(base)->vs.uri),
NULL, NULL, CACHE_MODE_ALWAYS, TASK_FORWARD);
if (ses->doc_view && ses->doc_view->vs
&& base->doc_view && base->doc_view->vs) {
struct view_state *vs = ses->doc_view->vs;
destroy_vs(vs, 1);
copy_vs(vs, base->doc_view->vs);
ses->doc_view->vs = vs;
}
}
if (uri) {
goto_uri(ses, uri);
} else if (!goto_url_home(ses)) {
if (get_opt_bool("ui.startup_goto_dialog", NULL)) {
dialog_goto_url_open(ses);
}
}
}
/** @relates session */
struct session *
init_session(struct session *base_session, struct terminal *term,
struct uri *uri, int in_background)
{
struct session *ses = (struct session *)mem_calloc(1, sizeof(*ses));
if (!ses) return NULL;
ses->tab = init_tab(term, ses, tabwin_func);
if (!ses->tab) {
mem_free(ses);
return NULL;
}
ses->option = copy_option(config_options,
CO_SHALLOW | CO_NO_LISTBOX_ITEM);
create_history(&ses->history);
init_list(ses->scrn_frames);
init_list(ses->scrn_iframes);
init_list(ses->more_files);
init_list(ses->type_queries);
ses->task.type = TASK_NONE;
ses->display_timer = TIMER_ID_UNDEF;
#ifdef CONFIG_LEDS
init_led_panel(&ses->status.leds);
ses->status.ssl_led = register_led(ses, 0);
ses->status.insert_mode_led = register_led(ses, 1);
ses->status.ecmascript_led = register_led(ses, 2);
ses->status.popup_led = register_led(ses, 3);
ses->status.download_led = register_led(ses, 5);
#endif
ses->status.force_show_status_bar = -1;
ses->status.force_show_title_bar = -1;
add_to_list(sessions, ses);
/* Update the status -- most importantly the info about whether to the
* show the title, tab and status bar -- _before_ loading the URI so
* the document cache is not filled with useless documents if the
* content is already cached.
*
* For big document it also reduces memory usage quite a bit because
* (atleast that is my interpretation --jonas) the old document will
* have a chance to be released before rendering a new one. A few
* numbers when opening a new tab while viewing debians package list
* for unstable:
*
* 9307 jonas 15 0 34252 30m 5088 S 0.0 12.2 0:03.63 elinks-old
* 9305 jonas 15 0 17060 13m 5088 S 0.0 5.5 0:02.07 elinks-new
*/
update_status();
/* Check if the newly inserted session is the only in the list and do
* the special setup for the first session, */
if (!list_is_singleton(sessions) || !setup_first_session(ses, uri)) {
setup_session(ses, uri, base_session);
}
if (!in_background)
switch_to_tab(term, get_tab_number(ses->tab), -1);
if (!term->main_menu) activate_bfu_technology(ses, -1);
return ses;
}
static void
init_remote_session(struct session *ses, remote_session_flags_T *remote_ptr,
struct uri *uri)
{
remote_session_flags_T remote = *remote_ptr;
if (remote & SES_REMOTE_CURRENT_TAB) {
goto_uri(ses, uri);
/* Mask out the current tab flag */
*remote_ptr = remote & ~SES_REMOTE_CURRENT_TAB;
/* Remote session was masked out. Open all following URIs in
* new tabs, */
if (!*remote_ptr)
*remote_ptr = SES_REMOTE_NEW_TAB;
} else if (remote & SES_REMOTE_NEW_TAB) {
/* FIXME: This is not perfect. Doing multiple -remote
* with no URLs will make the goto dialogs
* inaccessible. Maybe we should not support this kind
* of thing or make the window focus detecting code
* more intelligent. --jonas */
open_uri_in_new_tab(ses, uri, 0, 0);
if (remote & SES_REMOTE_PROMPT_URL) {
dialog_goto_url_open(ses);
}
} else if (remote & SES_REMOTE_NEW_WINDOW) {
/* FIXME: It is quite rude because we just take the first
* possibility and should maybe make it possible to specify
* new-screen etc via -remote "openURL(..., new-*)" --jonas */
if (!can_open_in_new(ses->tab->term))
return;
open_uri_in_new_window(ses, uri, NULL,
ses->tab->term->environment,
CACHE_MODE_NORMAL, TASK_NONE);
} else if (remote & SES_REMOTE_ADD_BOOKMARK) {
#ifdef CONFIG_BOOKMARKS
int uri_cp;
if (!uri) return;
/** @todo Bug 1066: What is the encoding of struri()?
* This code currently assumes the system charset.
* It might be best to keep URIs in plain ASCII and
* then have a function that reversibly converts them
* to IRIs for display in a given encoding. */
uri_cp = get_cp_index("System");
add_bookmark_cp(NULL, 1, uri_cp, struri(uri), struri(uri));
#endif
} else if (remote & SES_REMOTE_INFO_BOX) {
char *text;
if (!uri) return;
text = memacpy(uri->data, uri->datalen);
if (!text) return;
info_box(ses->tab->term, MSGBOX_FREE_TEXT,
N_("Error"), ALIGN_CENTER,
text);
} else if (remote & SES_REMOTE_PROMPT_URL) {
dialog_goto_url_open(ses);
} else if (remote & SES_REMOTE_RELOAD) {
reload(ses, CACHE_MODE_FORCE_RELOAD);
} else if (remote & SES_REMOTE_SEARCH) {
if (!uri)
return;
if (strncmp(uri->string, "search:", sizeof("search:") - 1)) {
info_box(ses->tab->term, MSGBOX_FREE_TEXT,
N_("Incorrect search uri"), ALIGN_CENTER,
uri->string);
return;
}
search_for(ses, uri->data);
}
}
struct string *
encode_session_info(struct string *info,
LIST_OF(struct string_list_item) *url_list)
{
struct string_list_item *url;
if (!init_string(info)) return NULL;
foreach (url, *url_list) {
struct string *str = &url->string;
add_bytes_to_string(info, str->source, str->length + 1);
}
return info;
}
/** Older elinks versions (up to and including 0.9.1) sends no magic variable and if
* this is detected we fallback to the old session info format. For this format
* the magic member of terminal_info hold the length of the URI string. The
* old format is handled by the default label in the switch.
*
* The new session info format supports extraction of multiple URIS from the
* terminal_info data member. The magic variable controls how to interpret
* the fields:
*
* - INTERLINK_NORMAL_MAGIC means use the terminal_info session_info
* variable as an id for a saved session.
*
* - INTERLINK_REMOTE_MAGIC means use the terminal_info session_info
* variable as the remote session flags. */
int
decode_session_info(struct terminal *term, struct terminal_info *info)
{
int len = info->length;
struct session *base_session = NULL;
remote_session_flags_T remote = 0;
char *str;
switch (info->magic) {
case INTERLINK_NORMAL_MAGIC:
/* Lookup if there are any saved sessions that should be
* resumed using the session_info as an id. The id is derived
* from the value of -base-session command line option in the
* connecting instance.
*
* At the moment it is only used when opening instances in new
* window to figure out how to initialize it when the new
* instance connects to the master.
*
* We don't need to handle it for the old format since new
* instances connecting this way will always be of the same
* origin as the master. */
if (init_saved_session(term, info->session_info))
return 1;
break;
case INTERLINK_REMOTE_MAGIC:
/* This could mean some fatal bug but I am unsure if we can
* actually assert it since people could pour all kinds of crap
* down the socket. */
if (!info->session_info) {
INTERNAL("Remote magic with no remote flags");
return 0;
}
remote = info->session_info;
/* If processing session info from a -remote instance we want
* to hook up with the master so we can handle request for
* stuff in current tab. */
base_session = (struct session *)(get_master_session() ?: sessions.next);
if (!base_session) {
return 0;
}
break;
default:
/* The old format calculates the session_info and magic members
* as part of the data that should be decoded so we have to
* substract it to get the size of the actual URI data. */
len -= sizeof(info->session_info) + sizeof(info->magic);
/* Extract URI containing @magic bytes */
if (info->magic <= 0 || info->magic > len)
len = 0;
else
len = info->magic;
}
if (len <= 0) {
if (!remote)
return !!init_session(base_session, term, NULL, 0);
/* Even though there are no URIs we still have to
* handle remote stuff. */
init_remote_session(base_session, &remote, NULL);
return 0;
}
str = info->data;
/* Extract multiple (possible) NUL terminated URIs */
while (len > 0) {
char *end = (char *)memchr(str, 0, len);
int urilength = end ? end - str : len;
struct uri *uri = NULL;
char *uristring = memacpy(str, urilength);
if (uristring) {
uri = get_hooked_uri(uristring, base_session, term->cwd);
mem_free(uristring);
}
len -= urilength + 1;
str += urilength + 1;
if (remote) {
if (!uri) continue;
init_remote_session(base_session, &remote, uri);
} else {
int backgrounded = !list_empty(term->windows);
int bad_url = !uri;
struct session *ses;
static char about_blank[] = "about:blank";
if (!uri)
uri = get_uri(about_blank, URI_NONE);
ses = init_session(base_session, term, uri, backgrounded);
if (!ses) {
/* End loop if initialization fails */
len = 0;
} else if (bad_url) {
print_error_dialog(ses, connection_state(S_BAD_URL),
NULL, PRI_MAIN);
}
}
if (uri) done_uri(uri);
}
/* If we only initialized remote sessions or didn't manage to add any
* new tabs return zero so the terminal will be destroyed ASAP. */
return remote ? 0 : !list_empty(term->windows);
}
void
abort_loading(struct session *ses, int interrupt)
{
if (have_location(ses)) {
struct location *loc = cur_loc(ses);
cancel_download(&loc->download, interrupt);
abort_files_load(ses, interrupt);
}
abort_preloading(ses, interrupt);
}
static void
destroy_session(struct session *ses)
{
struct document_view *doc_view;
assert(ses);
if_assert_failed return;
#ifdef CONFIG_SCRIPTING_SPIDERMONKEY
smjs_detach_session_object(ses);
#endif
destroy_downloads(ses);
abort_loading(ses, 0);
free_files(ses);
if (ses->doc_view) {
detach_formatted(ses->doc_view);
mem_free(ses->doc_view);
}
foreach (doc_view, ses->scrn_frames)
detach_formatted(doc_view);
free_list(ses->scrn_frames);
foreach (doc_view, ses->scrn_iframes)
detach_formatted(doc_view);
free_list(ses->scrn_iframes);
destroy_history(&ses->history);
set_session_referrer(ses, NULL);
if (ses->loading_uri) done_uri(ses->loading_uri);
kill_timer(&ses->display_timer);
while (!list_empty(ses->type_queries))
done_type_query((struct type_query *)ses->type_queries.next);
if (ses->download_uri) done_uri(ses->download_uri);
mem_free_if(ses->search_word);
mem_free_if(ses->last_search_word);
mem_free_if(ses->status.last_title);
mem_free_if(ses->status.window_status);
if (ses->option) {
delete_option(ses->option);
ses->option = NULL;
}
del_from_list(ses);
}
void
reload(struct session *ses, cache_mode_T cache_mode)
{
reload_frame(ses, NULL, cache_mode);
}
void
reload_frame(struct session *ses, char *name,
cache_mode_T cache_mode)
{
abort_loading(ses, 0);
if (cache_mode == CACHE_MODE_INCREMENT) {
cache_mode = CACHE_MODE_NEVER;
if (ses->reloadlevel < CACHE_MODE_NEVER)
cache_mode = ++ses->reloadlevel;
} else {
ses->reloadlevel = cache_mode;
}
if (have_location(ses)) {
struct location *loc = cur_loc(ses);
struct file_to_load *ftl;
#ifdef CONFIG_ECMASCRIPT
loc->vs.ecmascript_fragile = 1;
#endif
/* FIXME: When reloading use loading_callback and set up a
* session task so that the reloading will work even when the
* reloaded document contains redirects. This is needed atleast
* when reloading HTTP auth document after the user has entered
* credentials. */
loc->download.data = ses;
loc->download.callback = (download_callback_T *) doc_loading_callback;
mem_free_set(&ses->task.target.frame, null_or_stracpy(name));
load_uri(loc->vs.uri, ses->referrer, &loc->download, PRI_MAIN, cache_mode, -1);
foreach (ftl, ses->more_files) {
if (file_to_load_is_active(ftl))
continue;
ftl->download.data = ftl;
ftl->download.callback = (download_callback_T *) file_loading_callback;
load_additional_file(ftl, cache_mode);
}
}
}
struct frame *
ses_find_frame(struct session *ses, const char *name)
{
struct location *loc = cur_loc(ses);
struct frame *frame;
assertm(have_location(ses), "ses_request_frame: no location yet");
if_assert_failed return NULL;
foreachback (frame, loc->frames)
if (!c_strcasecmp(frame->name, name))
return frame;
return NULL;
}
struct frame *
ses_find_iframe(struct session *ses, char *name)
{
struct location *loc = cur_loc(ses);
struct frame *iframe;
assertm(have_location(ses), "ses_request_frame: no location yet");
if_assert_failed return NULL;
foreachback (iframe, loc->iframes)
if (!c_strcasecmp(iframe->name, name))
return iframe;
return NULL;
}
void
set_session_referrer(struct session *ses, struct uri *referrer)
{
if (ses->referrer) done_uri(ses->referrer);
ses->referrer = referrer ? get_uri_reference(referrer) : NULL;
}
static void
tabwin_func(struct window *tab, struct term_event *ev)
{
struct session *ses = (struct session *)tab->data;
switch (ev->ev) {
case EVENT_ABORT:
if (ses) destroy_session(ses);
if (!list_empty(sessions)) update_status();
break;
case EVENT_INIT:
case EVENT_RESIZE:
tab->resize = 1;
/* fall-through */
case EVENT_REDRAW:
if (!ses || ses->tab != get_current_tab(ses->tab->term))
break;
draw_formatted(ses, tab->resize);
if (tab->resize) {
load_frames(ses, ses->doc_view);
process_file_requests(ses);
tab->resize = 0;
}
print_screen_status(ses);
break;
case EVENT_KBD:
case EVENT_MOUSE:
if (!ses) break;
/* This check is related to bug 296 */
assert(ses->tab == get_current_tab(ses->tab->term));
send_event(ses, ev);
break;
}
}
/**
* Gets the url being viewed by this session. Writes it into @a str.
* A maximum of @a str_size bytes (including null) will be written.
* @relates session
*/
char *
get_current_url(struct session *ses, char *str, size_t str_size)
{
struct uri *uri;
int length;
assert(str && str_size > 0);
uri = have_location(ses) ? cur_loc(ses)->vs.uri : ses->loading_uri;
/* Not looking or loading anything */
if (!uri) return NULL;
/* Ensure that the url size is not greater than str_size.
* We can't just happily strncpy(str, here, str_size)
* because we have to stop at POST_CHAR, not only at NULL. */
length = int_min(get_real_uri_length(uri), str_size - 1);
return safe_strncpy(str, struri(uri), length + 1);
}
/**
* Gets the title of the page being viewed by this session. Writes it into
* @a str. A maximum of @a str_size bytes (including null) will be written.
* @relates session
*/
char *
get_current_title(struct session *ses, char *str, size_t str_size)
{
struct document_view *doc_view = current_frame(ses);
assert(str && str_size > 0);
/* Ensure that the title is defined */
/* TODO: Try globhist --jonas */
if (doc_view && doc_view->document->title)
return safe_strncpy(str, doc_view->document->title, str_size);
return NULL;
}
/**
* Gets the url of the link currently selected. Writes it into @a str.
* A maximum of @a str_size bytes (including null) will be written.
* @relates session
*/
char *
get_current_link_url(struct session *ses, char *str, size_t str_size)
{
struct link *link = get_current_session_link(ses);
assert(str && str_size > 0);
if (!link) return NULL;
return safe_strncpy(str, link->where ? link->where : link->where_img, str_size);
}
/** get_current_link_name: returns the name of the current link
* (the text between @<A> and @</A>), @a str is a preallocated string,
* @a str_size includes the null char.
* @relates session */
char *
get_current_link_name(struct session *ses, char *str, size_t str_size)
{
struct link *link = get_current_session_link(ses);
char *where, *name = NULL;
assert(str && str_size > 0);
if (!link) return NULL;
where = link->where ? link->where : link->where_img;
#ifdef CONFIG_GLOBHIST
{
struct global_history_item *item;
item = get_global_history_item(where);
if (item) name = item->title;
}
#endif
if (!name) name = get_link_name(link);
if (!name) name = where;
return safe_strncpy(str, name, str_size);
}
struct link *
get_current_link_in_view(struct document_view *doc_view)
{
struct link *link = get_current_link(doc_view);
return link && !link_is_form(link) ? link : NULL;
}
/** @relates session */
struct link *
get_current_session_link(struct session *ses)
{
return get_current_link_in_view(current_frame(ses));
}
/** @relates session */
int
eat_kbd_repeat_count(struct session *ses)
{
int count = ses->kbdprefix.repeat_count;
set_kbd_repeat_count(ses, 0);
/* Clear status bar when prefix is eaten (bug 930) */
print_screen_status(ses);
return count;
}
/** @relates session */
int
set_kbd_repeat_count(struct session *ses, int new_count)
{
int old_count = ses->kbdprefix.repeat_count;
if (new_count == old_count)
return old_count;
ses->kbdprefix.repeat_count = new_count;
/* Update the status bar. */
print_screen_status(ses);
/* Clear the old link highlighting. */
draw_formatted(ses, 0);
if (new_count != 0) {
struct document_view *doc_view = current_frame(ses);
highlight_links_with_prefixes_that_start_with_n(ses->tab->term,
doc_view,
new_count);
}
return new_count;
}
char *
get_ui_clipboard_file(void)
{
return get_opt_str("ui.clipboard_file", NULL);
}