2003-10-25 04:35:49 +04:00
|
|
|
/*
|
2004-08-08 23:13:40 +04:00
|
|
|
* Copyright 2004 James Bursa <bursa@users.sourceforge.net>
|
2003-10-25 04:35:49 +04:00
|
|
|
* Copyright 2003 Phil Mellor <monkeyson@users.sourceforge.net>
|
2009-02-20 14:39:25 +03:00
|
|
|
* Copyright 2005-9 John-Mark Bell <jmb@netsurf-browser.org>
|
2007-08-08 20:16:03 +04:00
|
|
|
*
|
|
|
|
* This file is part of NetSurf, http://www.netsurf-browser.org/
|
|
|
|
*
|
|
|
|
* NetSurf 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; version 2 of the License.
|
|
|
|
*
|
|
|
|
* NetSurf 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.
|
|
|
|
*
|
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program. If not, see <http://www.gnu.org/licenses/>.
|
2003-10-25 04:35:49 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
/** \file
|
|
|
|
* Form handling functions (implementation).
|
|
|
|
*/
|
|
|
|
|
2005-08-05 02:51:42 +04:00
|
|
|
#define _GNU_SOURCE /* for strndup */
|
2003-10-25 04:35:49 +04:00
|
|
|
#include <assert.h>
|
2005-06-26 05:55:20 +04:00
|
|
|
#include <ctype.h>
|
2007-03-12 02:48:29 +03:00
|
|
|
#include <limits.h>
|
2005-05-11 06:03:15 +04:00
|
|
|
#include <stdbool.h>
|
2004-03-21 23:07:14 +03:00
|
|
|
#include <stdio.h>
|
2003-10-25 04:35:49 +04:00
|
|
|
#include <string.h>
|
2007-05-31 02:39:54 +04:00
|
|
|
#include "render/box.h"
|
|
|
|
#include "render/form.h"
|
|
|
|
#include "utils/log.h"
|
|
|
|
#include "utils/url.h"
|
|
|
|
#include "utils/utf8.h"
|
|
|
|
#include "utils/utils.h"
|
2003-10-25 04:35:49 +04:00
|
|
|
|
|
|
|
|
2003-10-26 01:51:15 +04:00
|
|
|
static char *form_textarea_value(struct form_control *textarea);
|
2005-06-26 05:55:20 +04:00
|
|
|
static char *form_acceptable_charset(struct form *form);
|
2007-02-26 03:32:07 +03:00
|
|
|
static char *form_encode_item(const char *item, const char *charset,
|
|
|
|
const char *fallback);
|
2003-10-26 01:51:15 +04:00
|
|
|
|
2004-12-13 00:51:01 +03:00
|
|
|
/**
|
|
|
|
* Create a struct form.
|
|
|
|
*
|
2009-02-20 14:39:25 +03:00
|
|
|
* \param node DOM node associated with form
|
|
|
|
* \param action URL to submit form to, or NULL for default
|
|
|
|
* \param target Target frame of form, or NULL for default
|
2004-12-13 00:51:01 +03:00
|
|
|
* \param method method and enctype
|
2009-02-20 14:39:25 +03:00
|
|
|
* \param charset acceptable encodings for form submission, or NULL
|
2009-02-20 15:50:34 +03:00
|
|
|
* \param doc_charset encoding of containing document, or NULL
|
2009-02-20 14:39:25 +03:00
|
|
|
* \return a new structure, or NULL on memory exhaustion
|
2004-12-13 00:51:01 +03:00
|
|
|
*/
|
2009-02-20 14:39:25 +03:00
|
|
|
struct form *form_new(void *node, const char *action, const char *target,
|
|
|
|
form_method method, const char *charset,
|
|
|
|
const char *doc_charset)
|
2004-12-13 00:51:01 +03:00
|
|
|
{
|
|
|
|
struct form *form;
|
|
|
|
|
2009-02-20 14:39:25 +03:00
|
|
|
form = calloc(1, sizeof *form);
|
2004-12-13 00:51:01 +03:00
|
|
|
if (!form)
|
2009-02-20 14:39:25 +03:00
|
|
|
return NULL;
|
|
|
|
|
|
|
|
form->action = strdup(action != NULL ? action : "");
|
|
|
|
if (form->action == NULL) {
|
|
|
|
free(form);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
form->target = target != NULL ? strdup(target) : NULL;
|
|
|
|
if (target != NULL && form->target == NULL) {
|
|
|
|
free(form->action);
|
|
|
|
free(form);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2004-12-13 00:51:01 +03:00
|
|
|
form->method = method;
|
2009-02-20 14:39:25 +03:00
|
|
|
|
|
|
|
form->accept_charsets = charset != NULL ? strdup(charset) : NULL;
|
|
|
|
if (charset != NULL && form->accept_charsets == NULL) {
|
|
|
|
free(form->target);
|
|
|
|
free(form->action);
|
|
|
|
free(form);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2009-02-20 15:50:34 +03:00
|
|
|
form->document_charset = doc_charset != NULL ? strdup(doc_charset)
|
|
|
|
: NULL;
|
|
|
|
if (doc_charset && form->document_charset == NULL) {
|
2009-02-20 14:39:25 +03:00
|
|
|
free(form->accept_charsets);
|
|
|
|
free(form->target);
|
|
|
|
free(form->action);
|
|
|
|
free(form);
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
form->node = node;
|
|
|
|
|
2004-12-13 00:51:01 +03:00
|
|
|
return form;
|
|
|
|
}
|
|
|
|
|
2009-02-20 14:39:25 +03:00
|
|
|
/**
|
|
|
|
* Free a form, and any controls it owns.
|
|
|
|
*
|
|
|
|
* \param form The form to free
|
|
|
|
*
|
|
|
|
* \note There may exist controls attached to box tree nodes which are not
|
|
|
|
* associated with any form. These will leak at present. Ideally, they will
|
|
|
|
* be cleaned up when the box tree is destroyed. As that currently happens
|
|
|
|
* via talloc, this won't happen. These controls are distinguishable, as their
|
|
|
|
* form field will be NULL.
|
|
|
|
*/
|
|
|
|
void form_free(struct form *form)
|
|
|
|
{
|
|
|
|
struct form_control *c, *d;
|
|
|
|
|
|
|
|
for (c = form->controls; c != NULL; c = d) {
|
|
|
|
d = c->next;
|
|
|
|
|
|
|
|
form_free_control(c);
|
|
|
|
}
|
|
|
|
|
|
|
|
free(form->action);
|
|
|
|
free(form->target);
|
|
|
|
free(form->accept_charsets);
|
|
|
|
free(form->document_charset);
|
|
|
|
|
|
|
|
free(form);
|
|
|
|
}
|
2004-12-13 00:51:01 +03:00
|
|
|
|
2004-05-21 14:25:42 +04:00
|
|
|
/**
|
|
|
|
* Create a struct form_control.
|
|
|
|
*
|
2009-02-20 14:39:25 +03:00
|
|
|
* \param node Associated DOM node
|
2004-05-21 14:25:42 +04:00
|
|
|
* \param type control type
|
2009-02-20 14:39:25 +03:00
|
|
|
* \return a new structure, or NULL on memory exhaustion
|
2004-05-21 14:25:42 +04:00
|
|
|
*/
|
2009-02-20 14:39:25 +03:00
|
|
|
struct form_control *form_new_control(void *node, form_control_type type)
|
2004-05-21 14:25:42 +04:00
|
|
|
{
|
|
|
|
struct form_control *control;
|
|
|
|
|
2009-02-20 14:39:25 +03:00
|
|
|
control = calloc(1, sizeof *control);
|
|
|
|
if (control == NULL)
|
2004-07-20 00:40:11 +04:00
|
|
|
return NULL;
|
2009-02-20 14:39:25 +03:00
|
|
|
|
|
|
|
control->node = node;
|
2004-05-21 14:25:42 +04:00
|
|
|
control->type = type;
|
2009-02-20 14:39:25 +03:00
|
|
|
|
|
|
|
/* Default max length of input to something insane */
|
2007-03-12 02:48:29 +03:00
|
|
|
control->maxlength = UINT_MAX;
|
2009-02-20 14:39:25 +03:00
|
|
|
|
2004-05-21 14:25:42 +04:00
|
|
|
return control;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
/**
|
|
|
|
* Add a control to the list of controls in a form.
|
2005-06-26 05:55:20 +04:00
|
|
|
*
|
|
|
|
* \param form The form to add the control to
|
|
|
|
* \param control The control to add
|
2003-10-25 04:35:49 +04:00
|
|
|
*/
|
|
|
|
void form_add_control(struct form *form, struct form_control *control)
|
|
|
|
{
|
|
|
|
control->form = form;
|
2009-02-20 14:39:25 +03:00
|
|
|
|
2004-07-20 00:40:11 +04:00
|
|
|
if (form->controls != NULL) {
|
2003-10-25 04:35:49 +04:00
|
|
|
assert(form->last_control);
|
2009-02-20 14:39:25 +03:00
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
form->last_control->next = control;
|
2004-04-09 03:46:41 +04:00
|
|
|
control->prev = form->last_control;
|
2004-07-20 00:40:11 +04:00
|
|
|
control->next = NULL;
|
2003-10-25 04:35:49 +04:00
|
|
|
form->last_control = control;
|
|
|
|
} else {
|
|
|
|
form->controls = form->last_control = control;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-05-21 14:25:42 +04:00
|
|
|
/**
|
|
|
|
* Free a struct form_control.
|
|
|
|
*
|
|
|
|
* \param control structure to free
|
|
|
|
*/
|
|
|
|
void form_free_control(struct form_control *control)
|
|
|
|
{
|
|
|
|
free(control->name);
|
|
|
|
free(control->value);
|
|
|
|
free(control->initial_value);
|
2009-02-20 14:39:25 +03:00
|
|
|
|
2004-05-21 14:25:42 +04:00
|
|
|
if (control->type == GADGET_SELECT) {
|
|
|
|
struct form_option *option, *next;
|
2009-02-20 14:39:25 +03:00
|
|
|
|
2004-05-21 14:25:42 +04:00
|
|
|
for (option = control->data.select.items; option;
|
|
|
|
option = next) {
|
|
|
|
next = option->next;
|
|
|
|
free(option->text);
|
|
|
|
free(option->value);
|
|
|
|
free(option);
|
|
|
|
}
|
|
|
|
}
|
2009-02-20 14:39:25 +03:00
|
|
|
|
2004-05-21 14:25:42 +04:00
|
|
|
free(control);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2004-12-13 00:51:01 +03:00
|
|
|
/**
|
|
|
|
* Add an option to a form select control.
|
|
|
|
*
|
|
|
|
* \param control form control of type GADGET_SELECT
|
|
|
|
* \param value value of option, used directly (not copied)
|
|
|
|
* \param text text for option, used directly (not copied)
|
|
|
|
* \param selected this option is selected
|
|
|
|
* \return true on success, false on memory exhaustion
|
|
|
|
*/
|
|
|
|
bool form_add_option(struct form_control *control, char *value, char *text,
|
|
|
|
bool selected)
|
|
|
|
{
|
|
|
|
struct form_option *option;
|
|
|
|
|
|
|
|
assert(control);
|
|
|
|
assert(control->type == GADGET_SELECT);
|
|
|
|
|
2009-02-20 14:39:25 +03:00
|
|
|
option = calloc(1, sizeof *option);
|
2004-12-13 00:51:01 +03:00
|
|
|
if (!option)
|
|
|
|
return false;
|
2009-02-20 14:39:25 +03:00
|
|
|
|
2004-12-13 00:51:01 +03:00
|
|
|
option->value = value;
|
|
|
|
option->text = text;
|
|
|
|
|
|
|
|
/* add to linked list */
|
|
|
|
if (control->data.select.items == 0)
|
|
|
|
control->data.select.items = option;
|
|
|
|
else
|
|
|
|
control->data.select.last_item->next = option;
|
|
|
|
control->data.select.last_item = option;
|
|
|
|
|
|
|
|
/* set selected */
|
|
|
|
if (selected && (control->data.select.num_selected == 0 ||
|
|
|
|
control->data.select.multiple)) {
|
|
|
|
option->selected = option->initial_selected = true;
|
|
|
|
control->data.select.num_selected++;
|
|
|
|
control->data.select.current = option;
|
|
|
|
}
|
|
|
|
|
|
|
|
control->data.select.num_items++;
|
|
|
|
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
/**
|
|
|
|
* Identify 'successful' controls.
|
|
|
|
*
|
2007-02-26 03:32:07 +03:00
|
|
|
* All text strings in the successful controls list will be in the charset most
|
|
|
|
* appropriate for submission. Therefore, no utf8_to_* processing should be
|
|
|
|
* performed upon them.
|
|
|
|
*
|
|
|
|
* \todo The chosen charset needs to be made available such that it can be
|
|
|
|
* included in the submission request (e.g. in the fetch's Content-Type header)
|
|
|
|
*
|
2004-08-08 23:13:40 +04:00
|
|
|
* \param form form to search for successful controls
|
|
|
|
* \param submit_button control used to submit the form, if any
|
2006-01-02 16:20:01 +03:00
|
|
|
* \param successful_controls updated to point to linked list of
|
2004-08-08 23:13:40 +04:00
|
|
|
* form_successful_control, 0 if no controls
|
|
|
|
* \return true on success, false on memory exhaustion
|
|
|
|
*
|
2003-10-25 04:35:49 +04:00
|
|
|
* See HTML 4.01 section 17.13.2.
|
|
|
|
*/
|
2004-08-08 23:13:40 +04:00
|
|
|
bool form_successful_controls(struct form *form,
|
|
|
|
struct form_control *submit_button,
|
|
|
|
struct form_successful_control **successful_controls)
|
2003-10-25 04:35:49 +04:00
|
|
|
{
|
|
|
|
struct form_control *control;
|
|
|
|
struct form_option *option;
|
2004-08-08 23:13:40 +04:00
|
|
|
struct form_successful_control sentinel, *last_success, *success_new;
|
|
|
|
char *value;
|
2005-05-11 06:03:15 +04:00
|
|
|
bool had_submit = false;
|
2007-02-26 03:32:07 +03:00
|
|
|
char *charset;
|
2004-07-20 00:40:11 +04:00
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
last_success = &sentinel;
|
2004-04-01 22:29:42 +04:00
|
|
|
sentinel.next = 0;
|
2003-10-25 04:35:49 +04:00
|
|
|
|
2007-02-26 03:32:07 +03:00
|
|
|
charset = form_acceptable_charset(form);
|
|
|
|
if (!charset)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
#define ENCODE_ITEM(i) form_encode_item((i), charset, form->document_charset)
|
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
for (control = form->controls; control; control = control->next) {
|
|
|
|
/* ignore disabled controls */
|
|
|
|
if (control->disabled)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
/* ignore controls with no name */
|
|
|
|
if (!control->name)
|
|
|
|
continue;
|
|
|
|
|
2004-07-20 00:40:11 +04:00
|
|
|
switch (control->type) {
|
|
|
|
case GADGET_HIDDEN:
|
|
|
|
case GADGET_TEXTBOX:
|
|
|
|
case GADGET_PASSWORD:
|
2006-02-04 17:40:01 +03:00
|
|
|
if (control->value)
|
2007-02-26 03:32:07 +03:00
|
|
|
value = ENCODE_ITEM(control->value);
|
2006-02-04 17:40:01 +03:00
|
|
|
else
|
2007-02-26 03:32:07 +03:00
|
|
|
value = ENCODE_ITEM("");
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!value) {
|
|
|
|
LOG(("failed to duplicate value"
|
|
|
|
"'%s' for control %s",
|
|
|
|
control->value,
|
|
|
|
control->name));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-07-20 00:40:11 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GADGET_RADIO:
|
|
|
|
case GADGET_CHECKBOX:
|
|
|
|
/* ignore checkboxes and radio buttons which
|
2004-08-08 23:13:40 +04:00
|
|
|
* aren't selected */
|
|
|
|
if (!control->selected)
|
|
|
|
continue;
|
2005-05-11 05:34:41 +04:00
|
|
|
if (control->value)
|
2007-02-26 03:32:07 +03:00
|
|
|
value = ENCODE_ITEM(control->value);
|
2005-05-11 05:34:41 +04:00
|
|
|
else
|
2007-02-26 03:32:07 +03:00
|
|
|
value = ENCODE_ITEM("on");
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!value) {
|
2005-05-11 05:34:41 +04:00
|
|
|
LOG(("failed to duplicate"
|
|
|
|
"value '%s' for"
|
|
|
|
"control %s",
|
|
|
|
control->value,
|
|
|
|
control->name));
|
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-07-20 00:40:11 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GADGET_SELECT:
|
|
|
|
/* select */
|
|
|
|
for (option = control->data.select.items;
|
|
|
|
option != NULL;
|
|
|
|
option = option->next) {
|
2004-08-08 23:13:40 +04:00
|
|
|
if (!option->selected)
|
|
|
|
continue;
|
2007-02-26 03:32:07 +03:00
|
|
|
success_new =
|
|
|
|
malloc(sizeof(*success_new));
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!success_new) {
|
|
|
|
LOG(("malloc failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new->file = false;
|
2007-02-26 03:32:07 +03:00
|
|
|
success_new->name =
|
|
|
|
ENCODE_ITEM(control->name);
|
|
|
|
success_new->value =
|
|
|
|
ENCODE_ITEM(option->value);
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new->next = NULL;
|
|
|
|
last_success->next = success_new;
|
|
|
|
last_success = success_new;
|
|
|
|
if (!success_new->name ||
|
2004-08-18 05:36:39 +04:00
|
|
|
!success_new->value) {
|
|
|
|
LOG(("strdup failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2003-10-25 04:35:49 +04:00
|
|
|
}
|
|
|
|
|
2004-08-08 23:13:40 +04:00
|
|
|
continue;
|
2004-07-20 00:40:11 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GADGET_TEXTAREA:
|
2007-02-26 03:32:07 +03:00
|
|
|
{
|
|
|
|
char *v2;
|
|
|
|
|
2004-07-20 00:40:11 +04:00
|
|
|
/* textarea */
|
2004-08-08 23:13:40 +04:00
|
|
|
value = form_textarea_value(control);
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!value) {
|
|
|
|
LOG(("failed handling textarea"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-08-08 23:13:40 +04:00
|
|
|
if (value[0] == 0) {
|
|
|
|
free(value);
|
|
|
|
continue;
|
|
|
|
}
|
2007-02-26 03:32:07 +03:00
|
|
|
|
|
|
|
v2 = ENCODE_ITEM(value);
|
|
|
|
if (!v2) {
|
|
|
|
LOG(("failed handling textarea"));
|
|
|
|
free(value);
|
|
|
|
goto no_memory;
|
|
|
|
}
|
|
|
|
|
|
|
|
free(value);
|
|
|
|
value = v2;
|
|
|
|
}
|
2004-07-20 00:40:11 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GADGET_IMAGE: {
|
|
|
|
/* image */
|
2008-08-12 04:01:46 +04:00
|
|
|
size_t len;
|
2009-02-20 14:39:25 +03:00
|
|
|
char *name;
|
2008-08-12 04:01:46 +04:00
|
|
|
|
2005-09-01 00:29:11 +04:00
|
|
|
if (control != submit_button)
|
|
|
|
/* only the activated submit button
|
|
|
|
* is successful */
|
|
|
|
continue;
|
|
|
|
|
2009-02-20 14:39:25 +03:00
|
|
|
name = ENCODE_ITEM(control->name);
|
|
|
|
if (name == NULL)
|
|
|
|
goto no_memory;
|
|
|
|
|
|
|
|
len = strlen(name) + 3;
|
2004-07-20 00:40:11 +04:00
|
|
|
|
|
|
|
/* x */
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new = malloc(sizeof(*success_new));
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!success_new) {
|
2009-02-20 14:39:25 +03:00
|
|
|
free(name);
|
2004-08-18 05:36:39 +04:00
|
|
|
LOG(("malloc failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-07-20 00:40:11 +04:00
|
|
|
success_new->file = false;
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new->name = malloc(len);
|
|
|
|
success_new->value = malloc(20);
|
|
|
|
if (!success_new->name ||
|
|
|
|
!success_new->value) {
|
|
|
|
free(success_new->name);
|
|
|
|
free(success_new->value);
|
|
|
|
free(success_new);
|
2009-02-20 14:39:25 +03:00
|
|
|
free(name);
|
2004-08-18 05:36:39 +04:00
|
|
|
LOG(("malloc failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
|
|
|
}
|
2009-02-20 14:39:25 +03:00
|
|
|
sprintf(success_new->name, "%s.x", name);
|
2004-08-08 23:13:40 +04:00
|
|
|
sprintf(success_new->value, "%i",
|
|
|
|
control->data.image.mx);
|
2004-07-20 00:40:11 +04:00
|
|
|
success_new->next = 0;
|
|
|
|
last_success->next = success_new;
|
|
|
|
last_success = success_new;
|
|
|
|
|
|
|
|
/* y */
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new = malloc(sizeof(*success_new));
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!success_new) {
|
2009-02-20 14:39:25 +03:00
|
|
|
free(name);
|
2004-08-18 05:36:39 +04:00
|
|
|
LOG(("malloc failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-07-20 00:40:11 +04:00
|
|
|
success_new->file = false;
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new->name = malloc(len);
|
|
|
|
success_new->value = malloc(20);
|
|
|
|
if (!success_new->name ||
|
|
|
|
!success_new->value) {
|
|
|
|
free(success_new->name);
|
|
|
|
free(success_new->value);
|
|
|
|
free(success_new);
|
2009-02-20 14:39:25 +03:00
|
|
|
free(name);
|
2004-08-18 05:36:39 +04:00
|
|
|
LOG(("malloc failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
|
|
|
}
|
2009-02-20 14:39:25 +03:00
|
|
|
sprintf(success_new->name, "%s.y", name);
|
2004-08-08 23:13:40 +04:00
|
|
|
sprintf(success_new->value, "%i",
|
|
|
|
control->data.image.my);
|
2004-07-20 00:40:11 +04:00
|
|
|
success_new->next = 0;
|
|
|
|
last_success->next = success_new;
|
|
|
|
last_success = success_new;
|
|
|
|
|
2009-02-20 14:39:25 +03:00
|
|
|
free(name);
|
|
|
|
|
2004-08-08 23:13:40 +04:00
|
|
|
continue;
|
2004-07-20 00:40:11 +04:00
|
|
|
break;
|
|
|
|
}
|
2003-10-25 04:35:49 +04:00
|
|
|
|
2004-07-20 00:40:11 +04:00
|
|
|
case GADGET_SUBMIT:
|
2005-05-11 06:03:15 +04:00
|
|
|
if (!submit_button && !had_submit)
|
|
|
|
/* no submit button specified, so
|
|
|
|
* use first declared in form */
|
|
|
|
had_submit = true;
|
|
|
|
else if (control != submit_button)
|
|
|
|
/* only the activated submit button
|
|
|
|
* is successful */
|
2004-08-08 23:13:40 +04:00
|
|
|
continue;
|
2006-02-04 17:40:01 +03:00
|
|
|
if (control->value)
|
2007-02-26 03:32:07 +03:00
|
|
|
value = ENCODE_ITEM(control->value);
|
2006-02-04 17:40:01 +03:00
|
|
|
else
|
2007-02-26 03:32:07 +03:00
|
|
|
value = ENCODE_ITEM("");
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!value) {
|
|
|
|
LOG(("failed to duplicate value"
|
|
|
|
"'%s' for control %s",
|
|
|
|
control->value,
|
|
|
|
control->name));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-07-20 00:40:11 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GADGET_RESET:
|
|
|
|
/* ignore reset */
|
2004-08-08 23:13:40 +04:00
|
|
|
continue;
|
2004-07-20 00:40:11 +04:00
|
|
|
break;
|
|
|
|
|
|
|
|
case GADGET_FILE:
|
|
|
|
/* file */
|
2007-01-31 02:19:21 +03:00
|
|
|
/* Handling of blank file entries is
|
|
|
|
* implementation defined - we're perfectly
|
|
|
|
* within our rights to treat it as an
|
|
|
|
* unsuccessful control. Unfortunately, every
|
|
|
|
* other browser submits the field with
|
|
|
|
* a blank filename and no content. So,
|
|
|
|
* that's what we have to do, too.
|
|
|
|
*/
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new = malloc(sizeof(*success_new));
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!success_new) {
|
|
|
|
LOG(("malloc failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-07-20 00:40:11 +04:00
|
|
|
success_new->file = true;
|
2007-02-26 03:32:07 +03:00
|
|
|
success_new->name = ENCODE_ITEM(control->name);
|
2009-02-20 14:39:25 +03:00
|
|
|
success_new->value =
|
|
|
|
ENCODE_ITEM(control->value ?
|
2007-01-31 02:19:21 +03:00
|
|
|
control->value : "");
|
2004-07-20 00:40:11 +04:00
|
|
|
success_new->next = 0;
|
|
|
|
last_success->next = success_new;
|
|
|
|
last_success = success_new;
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!success_new->name ||
|
|
|
|
!success_new->value) {
|
|
|
|
LOG(("strdup failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-07-20 00:40:11 +04:00
|
|
|
|
2004-08-08 23:13:40 +04:00
|
|
|
continue;
|
2004-07-20 00:40:11 +04:00
|
|
|
break;
|
|
|
|
|
2009-02-20 14:39:25 +03:00
|
|
|
case GADGET_BUTTON:
|
|
|
|
/* Ignore it */
|
2009-02-20 15:55:50 +03:00
|
|
|
continue;
|
2009-02-20 14:39:25 +03:00
|
|
|
break;
|
|
|
|
|
2004-07-20 00:40:11 +04:00
|
|
|
default:
|
|
|
|
assert(0);
|
|
|
|
break;
|
2004-03-21 23:07:14 +03:00
|
|
|
}
|
|
|
|
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new = malloc(sizeof(*success_new));
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!success_new) {
|
|
|
|
LOG(("malloc failed"));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new->file = false;
|
2007-02-26 03:32:07 +03:00
|
|
|
success_new->name = ENCODE_ITEM(control->name);
|
2004-08-08 23:13:40 +04:00
|
|
|
success_new->value = value;
|
|
|
|
success_new->next = NULL;
|
|
|
|
last_success->next = success_new;
|
|
|
|
last_success = success_new;
|
2004-08-18 05:36:39 +04:00
|
|
|
if (!success_new->name) {
|
|
|
|
LOG(("failed to duplicate name '%s'",
|
|
|
|
control->name));
|
2004-08-08 23:13:40 +04:00
|
|
|
goto no_memory;
|
2004-08-18 05:36:39 +04:00
|
|
|
}
|
2003-10-25 04:35:49 +04:00
|
|
|
}
|
|
|
|
|
2004-08-08 23:13:40 +04:00
|
|
|
*successful_controls = sentinel.next;
|
|
|
|
return true;
|
|
|
|
|
|
|
|
no_memory:
|
|
|
|
warn_user("NoMemory", 0);
|
|
|
|
form_free_successful(sentinel.next);
|
|
|
|
return false;
|
2007-02-26 03:32:07 +03:00
|
|
|
|
|
|
|
#undef ENCODE_ITEM
|
2003-10-25 04:35:49 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-26 01:51:15 +04:00
|
|
|
/**
|
|
|
|
* Find the value for a textarea control.
|
2004-08-08 23:13:40 +04:00
|
|
|
*
|
|
|
|
* \param textarea control of type GADGET_TEXTAREA
|
|
|
|
* \return the value as a UTF-8 string on heap, or 0 on memory exhaustion
|
2003-10-26 01:51:15 +04:00
|
|
|
*/
|
|
|
|
char *form_textarea_value(struct form_control *textarea)
|
|
|
|
{
|
2004-08-08 23:13:40 +04:00
|
|
|
unsigned int len = 0;
|
2003-10-26 01:51:15 +04:00
|
|
|
char *value, *s;
|
2004-08-08 23:13:40 +04:00
|
|
|
struct box *text_box;
|
2003-10-26 01:51:15 +04:00
|
|
|
|
|
|
|
/* find required length */
|
2004-08-08 23:13:40 +04:00
|
|
|
for (text_box = textarea->box->children->children; text_box;
|
|
|
|
text_box = text_box->next) {
|
2005-05-26 03:06:26 +04:00
|
|
|
if (text_box->type == BOX_TEXT)
|
2003-10-26 01:51:15 +04:00
|
|
|
len += text_box->length + 1;
|
2004-08-08 23:13:40 +04:00
|
|
|
else /* BOX_BR */
|
|
|
|
len += 2;
|
2003-10-26 01:51:15 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* construct value */
|
2004-08-08 23:13:40 +04:00
|
|
|
s = value = malloc(len + 1);
|
|
|
|
if (!s)
|
|
|
|
return 0;
|
|
|
|
for (text_box = textarea->box->children->children; text_box;
|
|
|
|
text_box = text_box->next) {
|
2005-05-26 03:06:26 +04:00
|
|
|
if (text_box->type == BOX_TEXT) {
|
2003-10-26 01:51:15 +04:00
|
|
|
strncpy(s, text_box->text, text_box->length);
|
|
|
|
s += text_box->length;
|
2005-05-16 04:55:43 +04:00
|
|
|
if (text_box->next && text_box->next->type != BOX_BR)
|
|
|
|
/* only add space if this isn't
|
|
|
|
* the last box on a line (or in the area) */
|
2005-04-16 23:34:30 +04:00
|
|
|
*s++ = ' ';
|
2004-08-08 23:13:40 +04:00
|
|
|
} else { /* BOX_BR */
|
|
|
|
*s++ = '\r';
|
|
|
|
*s++ = '\n';
|
2003-10-26 01:51:15 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
*s = 0;
|
|
|
|
|
|
|
|
return value;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
/**
|
|
|
|
* Encode controls using application/x-www-form-urlencoded.
|
2004-08-08 23:13:40 +04:00
|
|
|
*
|
2005-04-16 09:09:33 +04:00
|
|
|
* \param form form to which successful controls relate
|
2004-08-08 23:13:40 +04:00
|
|
|
* \param control linked list of form_successful_control
|
|
|
|
* \return URL-encoded form, or 0 on memory exhaustion
|
2003-10-25 04:35:49 +04:00
|
|
|
*/
|
|
|
|
|
2005-04-16 09:09:33 +04:00
|
|
|
char *form_url_encode(struct form *form,
|
|
|
|
struct form_successful_control *control)
|
2003-10-25 04:35:49 +04:00
|
|
|
{
|
2007-02-26 03:32:07 +03:00
|
|
|
char *name, *value;
|
2004-08-08 23:13:40 +04:00
|
|
|
char *s = malloc(1), *s2;
|
2003-10-26 01:51:15 +04:00
|
|
|
unsigned int len = 0, len1;
|
2005-06-27 02:18:37 +04:00
|
|
|
url_func_result url_err;
|
2003-10-25 04:35:49 +04:00
|
|
|
|
2004-08-08 23:13:40 +04:00
|
|
|
if (!s)
|
|
|
|
return 0;
|
|
|
|
s[0] = 0;
|
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
for (; control; control = control->next) {
|
2008-04-02 04:43:51 +04:00
|
|
|
url_err = url_escape(control->name, 0, true, NULL, &name);
|
2005-06-27 02:18:37 +04:00
|
|
|
if (url_err == URL_FUNC_NOMEM) {
|
|
|
|
free(s);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
assert(url_err == URL_FUNC_OK);
|
|
|
|
|
2008-04-02 04:43:51 +04:00
|
|
|
url_err = url_escape(control->value, 0, true, NULL, &value);
|
2005-06-27 02:18:37 +04:00
|
|
|
if (url_err == URL_FUNC_NOMEM) {
|
|
|
|
free(name);
|
2005-04-16 09:09:33 +04:00
|
|
|
free(s);
|
|
|
|
return 0;
|
|
|
|
}
|
2005-06-27 02:18:37 +04:00
|
|
|
|
|
|
|
assert(url_err == URL_FUNC_OK);
|
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
len1 = len + strlen(name) + strlen(value) + 2;
|
2004-08-08 23:13:40 +04:00
|
|
|
s2 = realloc(s, len1 + 1);
|
|
|
|
if (!s2) {
|
2005-06-27 02:18:37 +04:00
|
|
|
free(value);
|
|
|
|
free(name);
|
2004-08-08 23:13:40 +04:00
|
|
|
free(s);
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
s = s2;
|
2003-10-25 04:35:49 +04:00
|
|
|
sprintf(s + len, "%s=%s&", name, value);
|
|
|
|
len = len1;
|
2005-06-27 02:18:37 +04:00
|
|
|
free(name);
|
|
|
|
free(value);
|
2003-10-25 04:35:49 +04:00
|
|
|
}
|
2005-06-26 05:55:20 +04:00
|
|
|
|
2003-10-25 04:35:49 +04:00
|
|
|
if (len)
|
|
|
|
s[len - 1] = 0;
|
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Free a linked list of form_successful_control.
|
2005-06-26 05:55:20 +04:00
|
|
|
*
|
|
|
|
* \param control Pointer to head of list to free
|
2003-10-25 04:35:49 +04:00
|
|
|
*/
|
|
|
|
|
|
|
|
void form_free_successful(struct form_successful_control *control)
|
|
|
|
{
|
|
|
|
struct form_successful_control *next;
|
|
|
|
for (; control; control = next) {
|
|
|
|
next = control->next;
|
|
|
|
free(control->name);
|
|
|
|
free(control->value);
|
|
|
|
free(control);
|
|
|
|
}
|
|
|
|
}
|
2005-06-26 05:55:20 +04:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Find an acceptable character set encoding with which to submit the form
|
|
|
|
*
|
|
|
|
* \param form The form
|
|
|
|
* \return Pointer to charset name (on heap, caller should free) or NULL
|
|
|
|
*/
|
|
|
|
char *form_acceptable_charset(struct form *form)
|
|
|
|
{
|
|
|
|
char *temp, *c;
|
|
|
|
|
|
|
|
if (!form)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
if (!form->accept_charsets) {
|
|
|
|
/* no accept-charsets attribute for this form */
|
|
|
|
if (form->document_charset)
|
|
|
|
/* document charset present, so use it */
|
|
|
|
return strdup(form->document_charset);
|
|
|
|
else
|
|
|
|
/* no document charset, so default to 8859-1 */
|
|
|
|
return strdup("ISO-8859-1");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* make temporary copy of accept-charsets attribute */
|
|
|
|
temp = strdup(form->accept_charsets);
|
|
|
|
if (!temp)
|
|
|
|
return NULL;
|
|
|
|
|
|
|
|
/* make it upper case */
|
|
|
|
for (c = temp; *c; c++)
|
2005-07-18 18:22:26 +04:00
|
|
|
*c = toupper(*c);
|
2005-06-26 05:55:20 +04:00
|
|
|
|
|
|
|
/* is UTF-8 specified? */
|
|
|
|
c = strstr(temp, "UTF-8");
|
|
|
|
if (c) {
|
|
|
|
free(temp);
|
|
|
|
return strdup("UTF-8");
|
|
|
|
}
|
|
|
|
|
|
|
|
/* dispense with temporary copy */
|
|
|
|
free(temp);
|
|
|
|
|
|
|
|
/* according to RFC2070, the accept-charsets attribute of the
|
|
|
|
* form element contains a space and/or comma separated list */
|
|
|
|
c = form->accept_charsets;
|
|
|
|
|
|
|
|
/* What would be an improvement would be to choose an encoding
|
|
|
|
* acceptable to the server which covers as much of the input
|
|
|
|
* values as possible. Additionally, we need to handle the case
|
|
|
|
* where none of the acceptable encodings cover all the textual
|
|
|
|
* input values.
|
|
|
|
* For now, we just extract the first element of the charset list
|
|
|
|
*/
|
|
|
|
while (*c && !isspace(*c)) {
|
|
|
|
if (*c == ',')
|
|
|
|
break;
|
|
|
|
c++;
|
|
|
|
}
|
|
|
|
|
|
|
|
return strndup(form->accept_charsets, c - form->accept_charsets);
|
|
|
|
}
|
2007-02-26 03:32:07 +03:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Convert a string from UTF-8 to the specified charset
|
|
|
|
* As a final fallback, this will attempt to convert to ISO-8859-1.
|
|
|
|
*
|
|
|
|
* \todo Return charset used?
|
|
|
|
*
|
|
|
|
* \param item String to convert
|
|
|
|
* \param charset Destination charset
|
|
|
|
* \param fallback Fallback charset (may be NULL),
|
|
|
|
* used iff converting to charset fails
|
|
|
|
* \return Pointer to converted string (on heap, caller frees), or NULL
|
|
|
|
*/
|
|
|
|
char *form_encode_item(const char *item, const char *charset,
|
|
|
|
const char *fallback)
|
|
|
|
{
|
|
|
|
utf8_convert_ret err;
|
|
|
|
char *ret = NULL;
|
2007-03-11 16:58:15 +03:00
|
|
|
char cset[256];
|
2007-02-26 03:32:07 +03:00
|
|
|
|
|
|
|
if (!item || !charset)
|
|
|
|
return NULL;
|
|
|
|
|
2007-03-11 16:58:15 +03:00
|
|
|
snprintf(cset, sizeof cset, "%s//TRANSLIT", charset);
|
2007-02-26 03:32:07 +03:00
|
|
|
|
2007-03-11 16:58:15 +03:00
|
|
|
err = utf8_to_enc(item, cset, 0, &ret);
|
2007-02-26 03:32:07 +03:00
|
|
|
if (err == UTF8_CONVERT_BADENC) {
|
2007-09-27 17:57:29 +04:00
|
|
|
/* charset not understood, try without transliteration */
|
|
|
|
snprintf(cset, sizeof cset, "%s", charset);
|
|
|
|
err = utf8_to_enc(item, cset, 0, &ret);
|
|
|
|
|
|
|
|
if (err == UTF8_CONVERT_BADENC) {
|
|
|
|
/* nope, try fallback charset (if any) */
|
|
|
|
if (fallback) {
|
|
|
|
snprintf(cset, sizeof cset,
|
|
|
|
"%s//TRANSLIT", fallback);
|
|
|
|
err = utf8_to_enc(item, cset, 0, &ret);
|
|
|
|
|
|
|
|
if (err == UTF8_CONVERT_BADENC) {
|
|
|
|
/* and without transliteration */
|
|
|
|
snprintf(cset, sizeof cset,
|
|
|
|
"%s", fallback);
|
|
|
|
err = utf8_to_enc(item, cset, 0, &ret);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
if (err == UTF8_CONVERT_BADENC) {
|
|
|
|
/* that also failed, use 8859-1 */
|
|
|
|
err = utf8_to_enc(item, "ISO-8859-1//TRANSLIT",
|
|
|
|
0, &ret);
|
|
|
|
if (err == UTF8_CONVERT_BADENC) {
|
|
|
|
/* and without transliteration */
|
|
|
|
err = utf8_to_enc(item, "ISO-8859-1",
|
|
|
|
0, &ret);
|
|
|
|
}
|
|
|
|
}
|
2007-03-11 16:58:15 +03:00
|
|
|
}
|
2007-02-26 03:32:07 +03:00
|
|
|
}
|
|
|
|
if (err == UTF8_CONVERT_NOMEM) {
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
2007-09-27 17:57:29 +04:00
|
|
|
|