/* documented in html_internal.h */
struct form_control *html_forms_get_control_for_node(struct form *forms,
dom_node *node)
{
struct form *f;
struct form_control *ctl = NULL;
dom_exception err;
dom_string *ds_name = NULL;
/* Step one, see if we already have a control */
for (f = forms; f != NULL; f = f->prev) {
for (ctl = f->controls; ctl != NULL; ctl = ctl->next) {
if (ctl->node == node)
return ctl;
}
}
/* Step two, extract the node's name so we can construct a gadget. */
err = dom_element_get_tag_name(node, &ds_name);
if (err == DOM_NO_ERR && ds_name != NULL) {
/* Step three, attempt to work out what gadget to make */
if (dom_string_caseless_lwc_isequal(ds_name,
corestring_lwc_button)) {
ctl = parse_button_element(forms,
(dom_html_button_element *) node);
} else if (dom_string_caseless_lwc_isequal(ds_name,
corestring_lwc_input)) {
ctl = parse_input_element(forms,
(dom_html_input_element *) node);
} else if (dom_string_caseless_lwc_isequal(ds_name,
corestring_lwc_textarea)) {
ctl = parse_textarea_element(forms,
(dom_html_text_area_element *) node);
} else if (dom_string_caseless_lwc_isequal(ds_name,
corestring_lwc_select)) {
ctl = parse_select_element(forms,
(dom_html_select_element *) node);
}
}
/* If all else fails, fake gadget time */
if (ctl == NULL)
ctl = invent_fake_gadget(node);
if (ds_name != NULL)
dom_string_unref(ds_name);
return ctl;
}
/**
* Callback to determine if a node is a linking element.
*
* \param pw HTML document
* \param n DOM node
* \param match Pointer to location to receive result
* \return CSS_OK.
*
* \post \a match will contain true if the node matches and false otherwise.
*/
css_error node_is_link(void *pw, void *n, bool *match)
{
dom_node *node = n;
dom_exception exc;
dom_string *node_name = NULL;
exc = dom_node_get_node_name(node, &node_name);
if ((exc != DOM_NO_ERR) || (node_name == NULL)) {
return CSS_NOMEM;
}
if (dom_string_caseless_lwc_isequal(node_name, corestring_lwc_a)) {
bool has_href;
exc = dom_element_has_attribute(node, corestring_dom_href,
&has_href);
if ((exc == DOM_NO_ERR) && (has_href)) {
*match = true;
} else {
*match = false;
}
} else {
*match = false;
}
dom_string_unref(node_name);
return CSS_OK;
}
/**
* Callback to determine if a node is a linking element whose target has been
* visited.
*
* \param pw HTML document
* \param node DOM node
* \param match Pointer to location to receive result
* \return CSS_OK.
*
* \post \a match will contain true if the node matches and false otherwise.
*/
css_error node_is_visited(void *pw, void *node, bool *match)
{
nscss_select_ctx *ctx = pw;
nsurl *url;
nserror error;
const struct url_data *data;
dom_exception exc;
dom_node *n = node;
dom_string *s = NULL;
*match = false;
exc = dom_node_get_node_name(n, &s);
if ((exc != DOM_NO_ERR) || (s == NULL)) {
return CSS_NOMEM;
}
if (!dom_string_caseless_lwc_isequal(s, corestring_lwc_a)) {
/* Can't be visited; not ancher element */
dom_string_unref(s);
return CSS_OK;
}
/* Finished with node name string */
dom_string_unref(s);
s = NULL;
exc = dom_element_get_attribute(n, corestring_dom_href, &s);
if ((exc != DOM_NO_ERR) || (s == NULL)) {
/* Can't be visited; not got a URL */
return CSS_OK;
}
/* Make href absolute */
/* TODO: this duplicates what we do for box->href
* should we put the absolute URL on the dom node? */
error = nsurl_join(ctx->base_url, dom_string_data(s), &url);
/* Finished with href string */
dom_string_unref(s);
if (error != NSERROR_OK) {
/* Couldn't make nsurl object */
return CSS_NOMEM;
}
data = urldb_get_url_data(url);
/* Visited if in the db and has
* non-zero visit count */
if (data != NULL && data->visits > 0)
*match = true;
nsurl_unref(url);
return CSS_OK;
}
/**
* Callback to determine if a node has an attribute with the given name whose
* value contains the substring given.
*
* \param pw HTML document
* \param node DOM node
* \param qname Name to match
* \param value Value to match
* \param match Pointer to location to receive result
* \return CSS_OK on success,
* CSS_NOMEM on memory exhaustion.
*
* \post \a match will contain true if the node matches and false otherwise.
*/
css_error node_has_attribute_substring(void *pw, void *node,
const css_qname *qname, lwc_string *value,
bool *match)
{
dom_node *n = node;
dom_string *name;
dom_string *atr_val;
dom_exception err;
size_t vlen = lwc_string_length(value);
if (vlen == 0) {
*match = false;
return CSS_OK;
}
err = dom_string_create_interned(
(const uint8_t *) lwc_string_data(qname->name),
lwc_string_length(qname->name), &name);
if (err != DOM_NO_ERR)
return CSS_NOMEM;
err = dom_element_get_attribute(n, name, &atr_val);
if ((err != DOM_NO_ERR) || (atr_val == NULL)) {
dom_string_unref(name);
*match = false;
return CSS_OK;
}
dom_string_unref(name);
/* check for exact match */
*match = dom_string_caseless_lwc_isequal(atr_val, value);
/* check for prefix match */
if (*match == false) {
const char *vdata = lwc_string_data(value);
const char *start = (const char *) dom_string_data(atr_val);
size_t len = dom_string_byte_length(atr_val);
const char *last_start = start + len - vlen;
if (len >= vlen) {
while (start <= last_start) {
if (strncasecmp(start, vdata,
vlen) == 0) {
*match = true;
break;
}
start++;
}
}
}
dom_string_unref(atr_val);
return CSS_OK;
}
/**
* Callback to find a named sibling node.
*
* \param pw HTML document
* \param node DOM node
* \param qname Node name to search for
* \param sibling Pointer to location to receive sibling
* \return CSS_OK.
*
* \post \a sibling will contain the result, or NULL if there is no match
*/
css_error named_sibling_node(void *pw, void *node,
const css_qname *qname, void **sibling)
{
dom_node *n = node;
dom_node *prev;
dom_exception err;
*sibling = NULL;
/* Find sibling element */
err = dom_node_get_previous_sibling(n, &n);
if (err != DOM_NO_ERR)
return CSS_OK;
while (n != NULL) {
dom_node_type type;
err = dom_node_get_node_type(n, &type);
if (err != DOM_NO_ERR) {
dom_node_unref(n);
return CSS_OK;
}
if (type == DOM_ELEMENT_NODE)
break;
err = dom_node_get_previous_sibling(n, &prev);
if (err != DOM_NO_ERR) {
dom_node_unref(n);
return CSS_OK;
}
dom_node_unref(n);
n = prev;
}
if (n != NULL) {
dom_string *name;
err = dom_node_get_node_name(n, &name);
if (err != DOM_NO_ERR) {
dom_node_unref(n);
return CSS_OK;
}
dom_node_unref(n);
if (dom_string_caseless_lwc_isequal(name, qname->name)) {
*sibling = n;
}
dom_string_unref(name);
}
return CSS_OK;
}
/**
* Callback to determine if a node has an attribute with the given name whose
* value dashmatches that given.
*
* \param pw HTML document
* \param node DOM node
* \param qname Name to match
* \param value Value to match
* \param match Pointer to location to receive result
* \return CSS_OK on success,
* CSS_NOMEM on memory exhaustion.
*
* \post \a match will contain true if the node matches and false otherwise.
*/
css_error node_has_attribute_dashmatch(void *pw, void *node,
const css_qname *qname, lwc_string *value,
bool *match)
{
dom_node *n = node;
dom_string *name;
dom_string *atr_val;
dom_exception err;
size_t vlen = lwc_string_length(value);
if (vlen == 0) {
*match = false;
return CSS_OK;
}
err = dom_string_create_interned(
(const uint8_t *) lwc_string_data(qname->name),
lwc_string_length(qname->name), &name);
if (err != DOM_NO_ERR)
return CSS_NOMEM;
err = dom_element_get_attribute(n, name, &atr_val);
if ((err != DOM_NO_ERR) || (atr_val == NULL)) {
dom_string_unref(name);
*match = false;
return CSS_OK;
}
dom_string_unref(name);
/* check for exact match */
*match = dom_string_caseless_lwc_isequal(atr_val, value);
/* check for dashmatch */
if (*match == false) {
const char *vdata = lwc_string_data(value);
const char *data = (const char *) dom_string_data(atr_val);
size_t len = dom_string_byte_length(atr_val);
if (len > vlen && data[vlen] == '-' &&
strncasecmp(data, vdata, vlen) == 0) {
*match = true;
}
}
dom_string_unref(atr_val);
return CSS_OK;
}
static struct html_stylesheet *
html_create_style_element(html_content *c, dom_node *style)
{
dom_string *val;
dom_exception exc;
struct html_stylesheet *stylesheets;
/* type='text/css', or not present (invalid but common) */
exc = dom_element_get_attribute(style, corestring_dom_type, &val);
if (exc == DOM_NO_ERR && val != NULL) {
if (!dom_string_caseless_lwc_isequal(val,
corestring_lwc_text_css)) {
dom_string_unref(val);
return NULL;
}
dom_string_unref(val);
}
/* media contains 'screen' or 'all' or not present */
exc = dom_element_get_attribute(style, corestring_dom_media, &val);
if (exc == DOM_NO_ERR && val != NULL) {
if (strcasestr(dom_string_data(val), "screen") == NULL &&
strcasestr(dom_string_data(val),
"all") == NULL) {
dom_string_unref(val);
return NULL;
}
dom_string_unref(val);
}
/* Extend array */
stylesheets = realloc(c->stylesheets,
sizeof(struct html_stylesheet) *
(c->stylesheet_count + 1));
if (stylesheets == NULL) {
content_broadcast_errorcode(&c->base, NSERROR_NOMEM);
return false;
}
c->stylesheets = stylesheets;
c->stylesheets[c->stylesheet_count].node = dom_node_ref(style);
c->stylesheets[c->stylesheet_count].sheet = NULL;
c->stylesheets[c->stylesheet_count].modified = false;
c->stylesheet_count++;
return c->stylesheets + (c->stylesheet_count - 1);
}
/**
* Callback to determine if a node has the given name.
*
* \param pw HTML document
* \param node DOM node
* \param qname Name to match
* \param match Pointer to location to receive result
* \return CSS_OK.
*
* \post \a match will contain true if the node matches and false otherwise.
*/
css_error node_has_name(void *pw, void *node,
const css_qname *qname, bool *match)
{
nscss_select_ctx *ctx = pw;
dom_node *n = node;
if (lwc_string_isequal(qname->name, ctx->universal, match) ==
lwc_error_ok && *match == false) {
dom_string *name;
dom_exception err;
err = dom_node_get_node_name(n, &name);
if (err != DOM_NO_ERR)
return CSS_OK;
/* Element names are case insensitive in HTML */
*match = dom_string_caseless_lwc_isequal(name, qname->name);
dom_string_unref(name);
}
return CSS_OK;
}
/**
* Callback to determine if a node has an attribute with given name and value.
*
* \param pw HTML document
* \param node DOM node
* \param qname Name to match
* \param value Value to match
* \param match Pointer to location to receive result
* \return CSS_OK on success,
* CSS_NOMEM on memory exhaustion.
*
* \post \a match will contain true if the node matches and false otherwise.
*/
css_error node_has_attribute_equal(void *pw, void *node,
const css_qname *qname, lwc_string *value,
bool *match)
{
dom_node *n = node;
dom_string *name;
dom_string *atr_val;
dom_exception err;
size_t vlen = lwc_string_length(value);
if (vlen == 0) {
*match = false;
return CSS_OK;
}
err = dom_string_create_interned(
(const uint8_t *) lwc_string_data(qname->name),
lwc_string_length(qname->name), &name);
if (err != DOM_NO_ERR)
return CSS_NOMEM;
err = dom_element_get_attribute(n, name, &atr_val);
if ((err != DOM_NO_ERR) || (atr_val == NULL)) {
dom_string_unref(name);
*match = false;
return CSS_OK;
}
dom_string_unref(name);
*match = dom_string_caseless_lwc_isequal(atr_val, value);
dom_string_unref(atr_val);
return CSS_OK;
}
svgtiny_code svgtiny_parse_dom(const char *buffer, size_t size, const char *url, dom_document **output_dom)
{
dom_document *document;
dom_exception exc;
dom_xml_parser *parser;
dom_xml_error err;
dom_element *svg;
dom_string *svg_name;
lwc_string *svg_name_lwc;
assert(buffer);
assert(url);
UNUSED(url);
parser = dom_xml_parser_create(NULL, NULL,
ignore_msg, NULL, &document);
if (parser == NULL)
return svgtiny_LIBDOM_ERROR;
err = dom_xml_parser_parse_chunk(parser, (uint8_t *)buffer, size);
if (err != DOM_XML_OK) {
dom_node_unref(document);
dom_xml_parser_destroy(parser);
return svgtiny_LIBDOM_ERROR;
}
err = dom_xml_parser_completed(parser);
if (err != DOM_XML_OK) {
dom_node_unref(document);
dom_xml_parser_destroy(parser);
return svgtiny_LIBDOM_ERROR;
}
/* We're done parsing, drop the parser.
* We now own the document entirely.
*/
dom_xml_parser_destroy(parser);
/* find root <svg> element */
exc = dom_document_get_document_element(document, &svg);
if (exc != DOM_NO_ERR) {
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
exc = dom_node_get_node_name(svg, &svg_name);
if (exc != DOM_NO_ERR) {
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
if (lwc_intern_string("svg", 3 /* SLEN("svg") */,
&svg_name_lwc) != lwc_error_ok) {
dom_string_unref(svg_name);
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
if (!dom_string_caseless_lwc_isequal(svg_name, svg_name_lwc)) {
lwc_string_unref(svg_name_lwc);
dom_string_unref(svg_name);
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_NOT_SVG;
}
dom_node_unref(svg);
lwc_string_unref(svg_name_lwc);
dom_string_unref(svg_name);
*output_dom = document;
return svgtiny_OK;
}
/**
* process form element from dom
*/
static struct form *
parse_form_element(const char *docenc, dom_node *node)
{
dom_string *ds_action = NULL;
dom_string *ds_charset = NULL;
dom_string *ds_target = NULL;
dom_string *ds_method = NULL;
dom_string *ds_enctype = NULL;
char *action = NULL, *charset = NULL, *target = NULL;
form_method method;
dom_html_form_element *formele = (dom_html_form_element *)(node);
struct form * ret = NULL;
/* Retrieve the attributes from the node */
if (dom_html_form_element_get_action(formele,
&ds_action) != DOM_NO_ERR)
goto out;
if (dom_html_form_element_get_accept_charset(formele,
&ds_charset) != DOM_NO_ERR)
goto out;
if (dom_html_form_element_get_target(formele,
&ds_target) != DOM_NO_ERR)
goto out;
if (dom_html_form_element_get_method(formele,
&ds_method) != DOM_NO_ERR)
goto out;
if (dom_html_form_element_get_enctype(formele,
&ds_enctype) != DOM_NO_ERR)
goto out;
/* Extract the plain attributes ready for use. We have to do this
* because we cannot guarantee that the dom_strings are NULL terminated
* and thus we copy them.
*/
if (ds_action != NULL)
action = strndup(dom_string_data(ds_action),
dom_string_byte_length(ds_action));
if (ds_charset != NULL)
charset = strndup(dom_string_data(ds_charset),
dom_string_byte_length(ds_charset));
if (ds_target != NULL)
target = strndup(dom_string_data(ds_target),
dom_string_byte_length(ds_target));
/* Determine the method */
method = method_GET;
if (ds_method != NULL) {
if (dom_string_caseless_lwc_isequal(ds_method,
corestring_lwc_post)) {
method = method_POST_URLENC;
if (ds_enctype != NULL) {
if (dom_string_caseless_lwc_isequal(ds_enctype,
corestring_lwc_multipart_form_data)) {
method = method_POST_MULTIPART;
}
}
}
}
/* Construct the form object */
ret = form_new(node, action, target, method, charset, docenc);
out:
if (ds_action != NULL)
dom_string_unref(ds_action);
if (ds_charset != NULL)
dom_string_unref(ds_charset);
if (ds_target != NULL)
dom_string_unref(ds_target);
if (ds_method != NULL)
dom_string_unref(ds_method);
if (ds_enctype != NULL)
dom_string_unref(ds_enctype);
if (action != NULL)
free(action);
if (charset != NULL)
free(charset);
if (target != NULL)
free(target);
return ret;
}
static struct form_control *
parse_input_element(struct form *forms, dom_html_input_element *input)
{
struct form_control *control = NULL;
dom_html_form_element *form = NULL;
dom_string *ds_type = NULL;
dom_string *ds_name = NULL;
dom_string *ds_value = NULL;
char *name = NULL;
if (dom_html_input_element_get_form(input, &form) != DOM_NO_ERR)
goto out;
if (dom_html_input_element_get_type(input, &ds_type) != DOM_NO_ERR)
goto out;
if (dom_html_input_element_get_name(input, &ds_name) != DOM_NO_ERR)
goto out;
if (ds_name != NULL)
name = strndup(dom_string_data(ds_name),
dom_string_byte_length(ds_name));
if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_password)) {
control = form_new_control(input, GADGET_PASSWORD);
} else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_file)) {
control = form_new_control(input, GADGET_FILE);
} else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_hidden)) {
control = form_new_control(input, GADGET_HIDDEN);
} else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_checkbox)) {
control = form_new_control(input, GADGET_CHECKBOX);
} else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_radio)) {
control = form_new_control(input, GADGET_RADIO);
} else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_submit)) {
control = form_new_control(input, GADGET_SUBMIT);
} else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_reset)) {
control = form_new_control(input, GADGET_RESET);
} else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_button)) {
control = form_new_control(input, GADGET_BUTTON);
} else if (ds_type != NULL && dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_image)) {
control = form_new_control(input, GADGET_IMAGE);
} else {
control = form_new_control(input, GADGET_TEXTBOX);
}
if (control == NULL)
goto out;
if (name != NULL) {
/* Hand the name string over */
control->name = name;
name = NULL;
}
if (control->type == GADGET_CHECKBOX || control->type == GADGET_RADIO) {
bool selected;
if (dom_html_input_element_get_checked(
input, &selected) == DOM_NO_ERR) {
control->selected = selected;
}
}
if (control->type == GADGET_PASSWORD ||
control->type == GADGET_TEXTBOX) {
int32_t maxlength;
if (dom_html_input_element_get_max_length(
input, &maxlength) != DOM_NO_ERR) {
maxlength = -1;
}
if (maxlength >= 0) {
/* Got valid maxlength */
control->maxlength = maxlength;
} else {
/* Input has no maxlength attr, or
* dom_html_input_element_get_max_length failed.
*
* Set it to something insane. */
control->maxlength = UINT_MAX;
}
}
if (control->type != GADGET_FILE && control->type != GADGET_IMAGE) {
if (dom_html_input_element_get_value(
input, &ds_value) == DOM_NO_ERR) {
if (ds_value != NULL) {
control->value = strndup(
dom_string_data(ds_value),
dom_string_byte_length(ds_value));
if (control->value == NULL) {
form_free_control(control);
control = NULL;
goto out;
}
control->length = strlen(control->value);
}
}
if (control->type == GADGET_TEXTBOX ||
control->type == GADGET_PASSWORD) {
if (control->value == NULL) {
control->value = strdup("");
if (control->value == NULL) {
form_free_control(control);
control = NULL;
goto out;
}
control->length = 0;
}
control->initial_value = strdup(control->value);
if (control->initial_value == NULL) {
form_free_control(control);
control = NULL;
goto out;
}
}
}
if (form != NULL && control != NULL)
form_add_control(find_form(forms, form), control);
out:
if (form != NULL)
dom_node_unref(form);
if (ds_type != NULL)
dom_string_unref(ds_type);
if (ds_name != NULL)
dom_string_unref(ds_name);
if (ds_value != NULL)
dom_string_unref(ds_value);
if (name != NULL)
free(name);
return control;
}
static struct form_control *
parse_button_element(struct form *forms, dom_html_button_element *button)
{
struct form_control *control = NULL;
dom_exception err;
dom_html_form_element *form = NULL;
dom_string *ds_type = NULL;
dom_string *ds_value = NULL;
dom_string *ds_name = NULL;
err = dom_html_button_element_get_form(button, &form);
if (err != DOM_NO_ERR)
goto out;
err = dom_html_button_element_get_type(button, &ds_type);
if (err != DOM_NO_ERR)
goto out;
if (ds_type == NULL) {
control = form_new_control(button, GADGET_SUBMIT);
} else {
if (dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_submit)) {
control = form_new_control(button, GADGET_SUBMIT);
} else if (dom_string_caseless_lwc_isequal(ds_type,
corestring_lwc_reset)) {
control = form_new_control(button, GADGET_RESET);
} else {
control = form_new_control(button, GADGET_BUTTON);
}
}
if (control == NULL)
goto out;
err = dom_html_button_element_get_value(button, &ds_value);
if (err != DOM_NO_ERR)
goto out;
err = dom_html_button_element_get_name(button, &ds_name);
if (err != DOM_NO_ERR)
goto out;
if (ds_value != NULL) {
control->value = strndup(
dom_string_data(ds_value),
dom_string_byte_length(ds_value));
if (control->value == NULL) {
form_free_control(control);
control = NULL;
goto out;
}
}
if (ds_name != NULL) {
control->name = strndup(
dom_string_data(ds_name),
dom_string_byte_length(ds_name));
if (control->name == NULL) {
form_free_control(control);
control = NULL;
goto out;
}
}
if (form != NULL && control != NULL)
form_add_control(find_form(forms, form), control);
out:
if (form != NULL)
dom_node_unref(form);
if (ds_type != NULL)
dom_string_unref(ds_type);
if (ds_value != NULL)
dom_string_unref(ds_value);
if (ds_name != NULL)
dom_string_unref(ds_name);
return control;
}
bool html_css_process_link(html_content *htmlc, dom_node *node)
{
dom_string *rel, *type_attr, *media, *href;
struct html_stylesheet *stylesheets;
nsurl *joined;
dom_exception exc;
nserror ns_error;
hlcache_child_context child;
/* rel=<space separated list, including 'stylesheet'> */
exc = dom_element_get_attribute(node, corestring_dom_rel, &rel);
if (exc != DOM_NO_ERR || rel == NULL)
return true;
if (strcasestr(dom_string_data(rel), "stylesheet") == 0) {
dom_string_unref(rel);
return true;
} else if (strcasestr(dom_string_data(rel), "alternate") != 0) {
/* Ignore alternate stylesheets */
dom_string_unref(rel);
return true;
}
dom_string_unref(rel);
/* type='text/css' or not present */
exc = dom_element_get_attribute(node, corestring_dom_type, &type_attr);
if (exc == DOM_NO_ERR && type_attr != NULL) {
if (!dom_string_caseless_lwc_isequal(type_attr,
corestring_lwc_text_css)) {
dom_string_unref(type_attr);
return true;
}
dom_string_unref(type_attr);
}
/* media contains 'screen' or 'all' or not present */
exc = dom_element_get_attribute(node, corestring_dom_media, &media);
if (exc == DOM_NO_ERR && media != NULL) {
if (strcasestr(dom_string_data(media), "screen") == NULL &&
strcasestr(dom_string_data(media), "all") == NULL) {
dom_string_unref(media);
return true;
}
dom_string_unref(media);
}
/* href='...' */
exc = dom_element_get_attribute(node, corestring_dom_href, &href);
if (exc != DOM_NO_ERR || href == NULL)
return true;
/* TODO: only the first preferred stylesheets (ie.
* those with a title attribute) should be loaded
* (see HTML4 14.3) */
ns_error = nsurl_join(htmlc->base_url, dom_string_data(href), &joined);
if (ns_error != NSERROR_OK) {
dom_string_unref(href);
goto no_memory;
}
dom_string_unref(href);
LOG("linked stylesheet %i '%s'", htmlc->stylesheet_count, nsurl_access(joined));
/* extend stylesheets array to allow for new sheet */
stylesheets = realloc(htmlc->stylesheets,
sizeof(struct html_stylesheet) *
(htmlc->stylesheet_count + 1));
if (stylesheets == NULL) {
nsurl_unref(joined);
ns_error = NSERROR_NOMEM;
goto no_memory;
}
htmlc->stylesheets = stylesheets;
htmlc->stylesheets[htmlc->stylesheet_count].node = NULL;
htmlc->stylesheets[htmlc->stylesheet_count].modified = false;
/* start fetch */
child.charset = htmlc->encoding;
child.quirks = htmlc->base.quirks;
ns_error = hlcache_handle_retrieve(joined, 0,
content_get_url(&htmlc->base),
NULL, html_convert_css_callback,
htmlc, &child, CONTENT_CSS,
&htmlc->stylesheets[htmlc->stylesheet_count].sheet);
nsurl_unref(joined);
if (ns_error != NSERROR_OK)
goto no_memory;
htmlc->stylesheet_count++;
htmlc->base.active++;
LOG("%d fetches active", htmlc->base.active);
return true;
no_memory:
content_broadcast_errorcode(&htmlc->base, ns_error);
return false;
}
/**
* Adds an imagemap entry to the list
*
* \param c The html content that the imagemap belongs to
* \param n The xmlNode representing the entry to add
* \param base_url Base URL for resolving relative URLs
* \param entry Pointer to list of entries
* \param tagtype The type of tag
* \return false on memory exhaustion, true otherwise
*/
static bool
imagemap_addtolist(const struct html_content *c, dom_node *n, nsurl *base_url,
struct mapentry **entry, dom_string *tagtype)
{
dom_exception exc;
dom_string *href = NULL, *target = NULL, *shape = NULL;
dom_string *coords = NULL;
struct mapentry *new_map, *temp;
bool ret = true;
if (dom_string_caseless_isequal(tagtype, corestring_dom_area)) {
bool nohref = false;
exc = dom_element_has_attribute(n,
corestring_dom_nohref, &nohref);
if ((exc != DOM_NO_ERR) || nohref)
/* Skip <area nohref="anything" /> */
goto ok_out;
}
exc = dom_element_get_attribute(n, corestring_dom_href, &href);
if (exc != DOM_NO_ERR || href == NULL) {
/* No href="" attribute, skip this element */
goto ok_out;
}
exc = dom_element_get_attribute(n, corestring_dom_target, &target);
if (exc != DOM_NO_ERR) {
goto ok_out;
}
exc = dom_element_get_attribute(n, corestring_dom_shape, &shape);
if (exc != DOM_NO_ERR) {
goto ok_out;
}
/* If there's no shape, we default to rectangles */
if (shape == NULL)
shape = dom_string_ref(corestring_dom_rect);
if (!dom_string_caseless_lwc_isequal(shape, corestring_lwc_default)) {
/* If not 'default' and there's no 'coords' give up */
exc = dom_element_get_attribute(n, corestring_dom_coords,
&coords);
if (exc != DOM_NO_ERR || coords == NULL) {
goto ok_out;
}
}
new_map = calloc(1, sizeof(*new_map));
if (new_map == NULL) {
goto bad_out;
}
if (dom_string_caseless_lwc_isequal(shape, corestring_lwc_rect) ||
dom_string_caseless_lwc_isequal(shape, corestring_lwc_rectangle))
new_map->type = IMAGEMAP_RECT;
else if (dom_string_caseless_lwc_isequal(shape, corestring_lwc_circle))
new_map->type = IMAGEMAP_CIRCLE;
else if (dom_string_caseless_lwc_isequal(shape, corestring_lwc_poly) ||
dom_string_caseless_lwc_isequal(shape, corestring_lwc_polygon))
new_map->type = IMAGEMAP_POLY;
else if (dom_string_caseless_lwc_isequal(shape, corestring_lwc_default))
new_map->type = IMAGEMAP_DEFAULT;
else
goto bad_out;
if (box_extract_link(c, href, base_url, &new_map->url) == false)
goto bad_out;
if (new_map->url == NULL) {
/* non-fatal error -> ignore this */
goto ok_free_map_out;
}
if (target != NULL) {
/* Copy target into the map */
new_map->target = malloc(dom_string_byte_length(target) + 1);
if (new_map->target == NULL)
goto bad_out;
/* Safe, but relies on dom_strings being NULL terminated */
/* \todo Do this better */
strcpy(new_map->target, dom_string_data(target));
}
if (new_map->type != IMAGEMAP_DEFAULT) {
int x, y;
float *xcoords, *ycoords;
/* coordinates are a comma-separated list of values */
char *val = strtok((char *)dom_string_data(coords), ",");
int num = 1;
switch (new_map->type) {
case IMAGEMAP_RECT:
/* (left, top, right, bottom) */
while (val != NULL && num <= 4) {
switch (num) {
case 1:
new_map->bounds.rect.x0 = atoi(val);
break;
case 2:
new_map->bounds.rect.y0 = atoi(val);
break;
case 3:
new_map->bounds.rect.x1 = atoi(val);
break;
case 4:
new_map->bounds.rect.y1 = atoi(val);
break;
}
num++;
val = strtok(NULL, ",");
}
break;
case IMAGEMAP_CIRCLE:
/* (x, y, radius ) */
while (val != NULL && num <= 3) {
switch (num) {
case 1:
new_map->bounds.circle.x = atoi(val);
break;
case 2:
new_map->bounds.circle.y = atoi(val);
break;
case 3:
new_map->bounds.circle.r = atoi(val);
break;
}
num++;
val = strtok(NULL, ",");
}
break;
case IMAGEMAP_POLY:
new_map->bounds.poly.xcoords = NULL;
new_map->bounds.poly.ycoords = NULL;
while (val != NULL) {
x = atoi(val);
val = strtok(NULL, ",");
if (val == NULL)
break;
y = atoi(val);
xcoords = realloc(new_map->bounds.poly.xcoords,
num * sizeof(float));
if (xcoords == NULL) {
goto bad_out;
}
new_map->bounds.poly.xcoords = xcoords;
ycoords = realloc(new_map->bounds.poly.ycoords,
num * sizeof(float));
if (ycoords == NULL) {
goto bad_out;
}
new_map->bounds.poly.ycoords = ycoords;
new_map->bounds.poly.xcoords[num - 1] = x;
new_map->bounds.poly.ycoords[num - 1] = y;
num++;
val = strtok(NULL, ",");
}
new_map->bounds.poly.num = num - 1;
break;
default:
break;
}
}
new_map->next = NULL;
if (*entry) {
/* add to END of list */
for (temp = (*entry); temp->next != NULL; temp = temp->next)
;
temp->next = new_map;
} else {
(*entry) = new_map;
}
/* All good, linked in, let's clean up */
goto ok_out;
bad_out:
ret = false;
ok_free_map_out:
if (new_map != NULL) {
if (new_map->url != NULL)
nsurl_unref(new_map->url);
if (new_map->type == IMAGEMAP_POLY &&
new_map->bounds.poly.ycoords != NULL)
free(new_map->bounds.poly.ycoords);
if (new_map->type == IMAGEMAP_POLY &&
new_map->bounds.poly.xcoords != NULL)
free(new_map->bounds.poly.xcoords);
if (new_map->target != NULL)
free(new_map->target);
free(new_map);
}
ok_out:
if (href != NULL)
dom_string_unref(href);
if (target != NULL)
dom_string_unref(target);
if (shape != NULL)
dom_string_unref(shape);
if (coords != NULL)
dom_string_unref(coords);
return ret;
}
svgtiny_code svgtiny_parse(struct svgtiny_diagram *diagram,
const char *buffer, size_t size, const char *url,
int viewport_width, int viewport_height)
{
dom_document *document;
dom_exception exc;
dom_xml_parser *parser;
dom_xml_error err;
dom_element *svg;
dom_string *svg_name;
lwc_string *svg_name_lwc;
struct svgtiny_parse_state state;
float x, y, width, height;
svgtiny_code code;
assert(diagram);
assert(buffer);
assert(url);
UNUSED(url);
state.gradient_x1 = NULL;
state.gradient_y1 = NULL;
state.gradient_x2 = NULL;
state.gradient_y2 = NULL;
parser = dom_xml_parser_create(NULL, NULL,
ignore_msg, NULL, &document);
if (parser == NULL)
return svgtiny_LIBDOM_ERROR;
err = dom_xml_parser_parse_chunk(parser, (uint8_t *)buffer, size);
if (err != DOM_XML_OK) {
dom_node_unref(document);
dom_xml_parser_destroy(parser);
return svgtiny_LIBDOM_ERROR;
}
err = dom_xml_parser_completed(parser);
if (err != DOM_XML_OK) {
dom_node_unref(document);
dom_xml_parser_destroy(parser);
return svgtiny_LIBDOM_ERROR;
}
/* We're done parsing, drop the parser.
* We now own the document entirely.
*/
dom_xml_parser_destroy(parser);
/* find root <svg> element */
exc = dom_document_get_document_element(document, &svg);
if (exc != DOM_NO_ERR) {
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
exc = dom_node_get_node_name(svg, &svg_name);
if (exc != DOM_NO_ERR) {
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
if (lwc_intern_string("svg", 3 /* SLEN("svg") */,
&svg_name_lwc) != lwc_error_ok) {
dom_string_unref(svg_name);
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_LIBDOM_ERROR;
}
if (!dom_string_caseless_lwc_isequal(svg_name, svg_name_lwc)) {
lwc_string_unref(svg_name_lwc);
dom_string_unref(svg_name);
dom_node_unref(svg);
dom_node_unref(document);
return svgtiny_NOT_SVG;
}
lwc_string_unref(svg_name_lwc);
dom_string_unref(svg_name);
/* get graphic dimensions */
memset(&state, 0, sizeof(state));
state.diagram = diagram;
state.document = document;
state.viewport_width = viewport_width;
state.viewport_height = viewport_height;
#define SVGTINY_STRING_ACTION2(s,n) \
if (dom_string_create_interned((const uint8_t *) #n, \
strlen(#n), &state.interned_##s) \
!= DOM_NO_ERR) { \
code = svgtiny_LIBDOM_ERROR; \
goto cleanup; \
}
#include "svgtiny_strings.h"
#undef SVGTINY_STRING_ACTION2
svgtiny_parse_position_attributes(svg, state, &x, &y, &width, &height);
diagram->width = width;
diagram->height = height;
/* set up parsing state */
state.viewport_width = width;
state.viewport_height = height;
state.ctm.a = 1; /*(float) viewport_width / (float) width;*/
state.ctm.b = 0;
state.ctm.c = 0;
state.ctm.d = 1; /*(float) viewport_height / (float) height;*/
state.ctm.e = 0; /*x;*/
state.ctm.f = 0; /*y;*/
/*state.style = css_base_style;
state.style.font_size.value.length.value = option_font_size * 0.1;*/
state.fill = 0x000000;
state.stroke = svgtiny_TRANSPARENT;
state.stroke_width = 1;
state.linear_gradient_stop_count = 0;
/* parse tree */
code = svgtiny_parse_svg(svg, state);
dom_node_unref(svg);
dom_node_unref(document);
cleanup:
svgtiny_cleanup_state_local(&state);
#define SVGTINY_STRING_ACTION2(s,n) \
if (state.interned_##s != NULL) \
dom_string_unref(state.interned_##s);
#include "svgtiny_strings.h"
#undef SVGTINY_STRING_ACTION2
return code;
}