static void log_stream(int level, VSTREAM *fp)
{
VSTRING *buf = vstring_alloc(100);
while (vstring_get_nonl(buf, fp) != VSTREAM_EOF)
msg_text(level, vstring_str(buf));
vstring_free(buf);
}
static void log_argv(int level, char **argv)
{
VSTRING *buf = vstring_alloc(100);
while (*argv) {
vstring_strcat(buf, *argv++);
if (*argv)
vstring_strcat(buf, " ");
}
msg_text(level, vstring_str(buf));
vstring_free(buf);
}
void msg_vprintf(int level, const char *format, va_list ap)
{
if (msg_vprintf_lock == 0) {
msg_vprintf_lock = 1;
/* On-the-fly initialization for debugging test programs only. */
if (msg_output_fn_count == 0)
msg_vstream_init("unknown", VSTREAM_ERR);
/* OK if terminating signal handler hijacks control before next stmt. */
vstring_vsprintf(msg_buffer, percentm(format, errno), ap);
msg_text(level, vstring_str(msg_buffer));
msg_vprintf_lock = 0;
}
}
void FormEfficiencyCalibration::update_detector_calibs()
{
std::string msg_text("Propagating calibration ");
msg_text += "<nobr>" + new_calibration_.to_string() + "</nobr><br/>";
std::string question_text("Do you want to save this calibration to ");
question_text += current_detector_ + " in detector database?";
QMessageBox msgBox;
msgBox.setText(QString::fromStdString(msg_text));
msgBox.setInformativeText(QString::fromStdString(question_text));
msgBox.setStandardButtons(QMessageBox::Yes | QMessageBox::No);
msgBox.setDefaultButton(QMessageBox::No);
msgBox.setIcon(QMessageBox::Question);
int ret = msgBox.exec();
Qpx::Detector modified;
if (ret == QMessageBox::Yes) {
if (!detectors_.has_a(Qpx::Detector(current_detector_))) {
bool ok;
QString text = QInputDialog::getText(this, "New Detector",
"Detector name:", QLineEdit::Normal,
QString::fromStdString(current_detector_),
&ok);
if (!ok)
return;
if (!text.isEmpty()) {
modified = Qpx::Detector(current_detector_);
if (detectors_.has_a(modified)) {
QMessageBox::warning(this, "Already exists", "Detector " + text + " already exists. Will not save to database.", QMessageBox::Ok);
modified = Qpx::Detector();
}
}
} else
modified = detectors_.get(Qpx::Detector(current_detector_));
if (modified != Qpx::Detector())
{
PL_INFO << " applying new calibrations for " << modified.name_ << " in detector database";
modified.efficiency_calibration_ = new_calibration_;
detectors_.replace(modified);
emit detectorsChanged();
}
}
}
void
menu_copying(struct terminal *term, void *xxx, void *xxxx)
{
info_box(term, MSGBOX_FREE_TEXT,
N_("Copying"), ALIGN_CENTER,
msg_text(term, N_("ELinks %s\n"
"\n"
"%s"
"et al.\n"
"\n"
"This program is free software; you can redistribute it "
"and/or modify it under the terms of the GNU General Public "
"License as published by the Free Software Foundation, "
"specifically version 2 of the License."),
VERSION_STRING, COPYRIGHT_STRING));
}
void
ses_goto(struct session *ses, struct uri *uri, unsigned char *target_frame,
struct location *target_location, enum cache_mode cache_mode,
enum task_type task_type, int redir)
{
/* [gettext_accelerator_context(ses_goto)] */
struct task *task;
int referrer_incomplete = 0;
int malicious_uri = 0;
int confirm_submit = uri->form && get_opt_bool("document.browse.forms"
".confirm_submit", ses);
unsigned char *m1 = NULL, *message = NULL;
struct memory_list *mlist = NULL;
if (ses->doc_view
&& ses->doc_view->document
&& ses->doc_view->document->refresh) {
kill_document_refresh(ses->doc_view->document->refresh);
}
assertm(!ses->loading_uri, "Buggy URI reference counting");
/* Reset the redirect counter if this is not a redirect. */
if (!redir) {
ses->redirect_cnt = 0;
}
/* Figure out whether to confirm submit or not */
/* Only confirm submit if we are posting form data or a misleading URI
* was detected. */
/* Note uri->post might be empty here but we are still supposely
* posting form data so this should be more correct. */
if (uri->user && uri->userlen
&& get_opt_bool("document.browse.links.warn_malicious", ses)
&& check_malicious_uri(uri)) {
malicious_uri = 1;
confirm_submit = 1;
} else if (uri->form) {
/* First check if the referring URI was incomplete. It
* indicates that the posted form data might be incomplete too.
* See bug 460. */
if (ses->referrer) {
struct cache_entry *cached;
cached = find_in_cache(ses->referrer);
referrer_incomplete = (cached && cached->incomplete);
}
if (referrer_incomplete) {
confirm_submit = 1;
} else if (get_validated_cache_entry(uri, cache_mode)) {
confirm_submit = 0;
}
}
if (!confirm_submit) {
ses_load(ses, get_uri_reference(uri), target_frame,
target_location, cache_mode, task_type);
return;
}
task = mem_alloc(sizeof(*task));
if (!task) return;
task->ses = ses;
task->uri = get_uri_reference(uri);
task->cache_mode = cache_mode;
task->session_task.type = task_type;
task->session_task.target.frame = null_or_stracpy(target_frame);
task->session_task.target.location = target_location;
if (malicious_uri) {
unsigned char *host = memacpy(uri->host, uri->hostlen);
unsigned char *user = memacpy(uri->user, uri->userlen);
unsigned char *uristring = get_uri_string(uri, URI_PUBLIC);
message = msg_text(ses->tab->term,
N_("The URL you are about to follow might be maliciously "
"crafted in order to confuse you. By following the URL "
"you will be connecting to host \"%s\" as user \"%s\".\n\n"
"Do you want to go to URL %s?"), host, user, uristring);
mem_free_if(host);
mem_free_if(user);
mem_free_if(uristring);
} else if (redir) {
m1 = N_("Do you want to follow the redirect and post form data "
"to URL %s?");
} else if (referrer_incomplete) {
m1 = N_("The form data you are about to post might be incomplete.\n"
"Do you want to post to URL %s?");
} else if (task_type == TASK_FORWARD) {
m1 = N_("Do you want to post form data to URL %s?");
} else {
m1 = N_("Do you want to repost form data to URL %s?");
}
if (!message && m1) {
unsigned char *uristring = get_uri_string(uri, URI_PUBLIC);
message = msg_text(ses->tab->term, m1, uristring);
mem_free_if(uristring);
}
add_to_ml(&mlist, task, (void *) NULL);
if (task->session_task.target.frame)
add_to_ml(&mlist, task->session_task.target.frame, (void *) NULL);
msg_box(ses->tab->term, mlist, MSGBOX_FREE_TEXT,
N_("Warning"), ALIGN_CENTER,
message,
task, 2,
MSG_BOX_BUTTON(N_("~Yes"), post_yes, B_ENTER),
MSG_BOX_BUTTON(N_("~No"), post_no, B_ESC));
}
void
textarea_edit(int op, struct terminal *term_, struct form_state *fs_,
struct document_view *doc_view_, struct link *link_)
{
struct textarea_data *td = NULL;
assert ((op == 0 || op == 1) && term_);
if_assert_failed return;
if (op == 0 && get_cmd_opt_bool("anonymous")) {
info_box(term_, 0, N_("Error"), ALIGN_CENTER,
N_("You cannot launch an external"
" editor in the anonymous mode."));
return;
}
if (op == 0) {
unsigned char *ed;
unsigned char *ex;
assert(fs_ && doc_view_ && link_ && term_);
td = init_textarea_data(term_, fs_, doc_view_, link_);
if (!td)
return;
ed = get_opt_str("document.browse.forms.editor",
doc_view_->session);
if (!ed || !*ed) {
ed = getenv("EDITOR");
if (!ed || !*ed) ed = "vi";
}
ex = straconcat(ed, " ", td->fn, (unsigned char *) NULL);
if (!ex) {
unlink(td->fn);
done_textarea_data(td);
return;
}
td->term->textarea_data = td;
exec_on_terminal(td->term, ex, "", TERM_EXEC_FG);
mem_free(ex);
return;
} else if (op == 1) {
struct string file;
td = term_->textarea_data;
term_->textarea_data = NULL;
assert(td);
if (!td->fs || !init_string(&file)
|| !add_file_to_string(&file, td->fn)) {
done_textarea_data(td);
return;
}
if (file.length > td->fc_maxlength) {
file.source[td->fc_maxlength] = '\0';
/* Casting size_t fc_maxlength to unsigned int
* and formatting it with "%u" is safe,
* because fc_maxlength is smaller than
* file.length, which is an int. */
info_box(td->term, MSGBOX_FREE_TEXT, N_("Warning"),
ALIGN_CENTER,
msg_text(td->term,
N_("You have exceeded the textarea's"
" size limit: your input is %d"
" bytes, but the maximum is %u"
" bytes.\n\n"
"Your input has been truncated,"
" but you can still recover the"
" text that you entered from"
" this file: %s"), file.length,
(unsigned int) td->fc_maxlength, td->fn));
} else {
unlink(td->fn);
}
mem_free(td->fs->value);
td->fs->value = file.source;
td->fs->state = file.length;
if (td->doc_view && td->link)
draw_form_entry(td->term, td->doc_view, td->link);
}
done_textarea_data(td);
}