mirror of
https://github.com/openbsd/src.git
synced 2025-01-04 15:25:38 -08:00
1a5078e916
rpki-client: https://testbed.krill.cloud/rrdp/notification.xml: pulling from network rpki-client: https://testbed.krill.cloud/rrdp/notification.xml: downloading snapshot (bfb0a57e-d16b-44a1-9502-f15b4bc1ce1a#110135) rpki-client: parse failed, snapshot element for rsync://testbed.krill.cloud/repo/testbed/0/DDAF321520EE4817D716FA047FC05FE2934204DB.crl too big rpki-client: https://testbed.krill.cloud/rrdp/notification.xml: parse error at line 135: parsing aborted rpki-client: https://testbed.krill.cloud/rrdp/notification.xml: load from network failed, fallback to rsync OK tb@ claudio@
260 lines
6.8 KiB
C
260 lines
6.8 KiB
C
/* $OpenBSD: rrdp_snapshot.c,v 1.10 2024/05/30 09:54:59 job Exp $ */
|
|
/*
|
|
* Copyright (c) 2020 Nils Fisher <nils_fisher@hotmail.com>
|
|
* Copyright (c) 2021 Claudio Jeker <claudio@openbsd.org>
|
|
*
|
|
* Permission to use, copy, modify, and distribute this software for any
|
|
* purpose with or without fee is hereby granted, provided that the above
|
|
* copyright notice and this permission notice appear in all copies.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
|
|
* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
|
|
* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
|
|
* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
|
|
* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
|
|
* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
|
|
* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
|
|
*/
|
|
|
|
#include <err.h>
|
|
#include <limits.h>
|
|
#include <stdlib.h>
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <unistd.h>
|
|
|
|
#include <expat.h>
|
|
|
|
#include "extern.h"
|
|
#include "rrdp.h"
|
|
|
|
enum snapshot_scope {
|
|
SNAPSHOT_SCOPE_NONE,
|
|
SNAPSHOT_SCOPE_SNAPSHOT,
|
|
SNAPSHOT_SCOPE_PUBLISH,
|
|
SNAPSHOT_SCOPE_END
|
|
};
|
|
|
|
struct snapshot_xml {
|
|
XML_Parser parser;
|
|
struct rrdp_session *current;
|
|
struct rrdp *rrdp;
|
|
struct publish_xml *pxml;
|
|
char *session_id;
|
|
long long serial;
|
|
int version;
|
|
enum snapshot_scope scope;
|
|
};
|
|
|
|
static void
|
|
start_snapshot_elem(struct snapshot_xml *sxml, const char **attr)
|
|
{
|
|
XML_Parser p = sxml->parser;
|
|
int has_xmlns = 0;
|
|
int i;
|
|
|
|
if (sxml->scope != SNAPSHOT_SCOPE_NONE)
|
|
PARSE_FAIL(p,
|
|
"parse failed - entered snapshot elem unexpectedely");
|
|
for (i = 0; attr[i]; i += 2) {
|
|
const char *errstr;
|
|
if (strcmp("xmlns", attr[i]) == 0 &&
|
|
strcmp(RRDP_XMLNS, attr[i + 1]) == 0) {
|
|
has_xmlns = 1;
|
|
continue;
|
|
}
|
|
if (strcmp("version", attr[i]) == 0) {
|
|
sxml->version = strtonum(attr[i + 1],
|
|
1, MAX_VERSION, &errstr);
|
|
if (errstr == NULL)
|
|
continue;
|
|
}
|
|
if (strcmp("session_id", attr[i]) == 0 &&
|
|
valid_uuid(attr[i + 1])) {
|
|
sxml->session_id = xstrdup(attr[i + 1]);
|
|
continue;
|
|
}
|
|
if (strcmp("serial", attr[i]) == 0) {
|
|
sxml->serial = strtonum(attr[i + 1],
|
|
1, LLONG_MAX, &errstr);
|
|
if (errstr == NULL)
|
|
continue;
|
|
}
|
|
PARSE_FAIL(p,
|
|
"parse failed - non conforming "
|
|
"attribute '%s' found in snapshot elem", attr[i]);
|
|
}
|
|
if (!(has_xmlns && sxml->version && sxml->session_id && sxml->serial))
|
|
PARSE_FAIL(p,
|
|
"parse failed - incomplete snapshot attributes");
|
|
if (strcmp(sxml->current->session_id, sxml->session_id) != 0)
|
|
PARSE_FAIL(p, "parse failed - session_id mismatch");
|
|
if (sxml->current->serial != sxml->serial)
|
|
PARSE_FAIL(p, "parse failed - serial mismatch");
|
|
|
|
sxml->scope = SNAPSHOT_SCOPE_SNAPSHOT;
|
|
}
|
|
|
|
static void
|
|
end_snapshot_elem(struct snapshot_xml *sxml)
|
|
{
|
|
XML_Parser p = sxml->parser;
|
|
|
|
if (sxml->scope != SNAPSHOT_SCOPE_SNAPSHOT)
|
|
PARSE_FAIL(p, "parse failed - exited snapshot "
|
|
"elem unexpectedely");
|
|
sxml->scope = SNAPSHOT_SCOPE_END;
|
|
}
|
|
|
|
static void
|
|
start_publish_elem(struct snapshot_xml *sxml, const char **attr)
|
|
{
|
|
XML_Parser p = sxml->parser;
|
|
char *uri = NULL;
|
|
int i, hasUri = 0;
|
|
|
|
if (sxml->scope != SNAPSHOT_SCOPE_SNAPSHOT)
|
|
PARSE_FAIL(p,
|
|
"parse failed - entered publish elem unexpectedely");
|
|
for (i = 0; attr[i]; i += 2) {
|
|
if (strcmp("uri", attr[i]) == 0 && hasUri++ == 0) {
|
|
if (valid_uri(attr[i + 1], strlen(attr[i + 1]),
|
|
RSYNC_PROTO)) {
|
|
uri = xstrdup(attr[i + 1]);
|
|
continue;
|
|
}
|
|
}
|
|
/*
|
|
* XXX it seems people can not write proper XML, ignore
|
|
* bogus xmlns attribute on publish elements.
|
|
*/
|
|
if (strcmp("xmlns", attr[i]) == 0)
|
|
continue;
|
|
PARSE_FAIL(p, "parse failed - non conforming"
|
|
" attribute '%s' found in publish elem", attr[i]);
|
|
}
|
|
if (hasUri != 1)
|
|
PARSE_FAIL(p, "parse failed - incomplete publish attributes");
|
|
sxml->pxml = new_publish_xml(PUB_ADD, uri, NULL, 0);
|
|
sxml->scope = SNAPSHOT_SCOPE_PUBLISH;
|
|
}
|
|
|
|
static void
|
|
end_publish_elem(struct snapshot_xml *sxml)
|
|
{
|
|
XML_Parser p = sxml->parser;
|
|
|
|
if (sxml->scope != SNAPSHOT_SCOPE_PUBLISH)
|
|
PARSE_FAIL(p, "parse failed - exited publish "
|
|
"elem unexpectedely");
|
|
|
|
if (publish_done(sxml->rrdp, sxml->pxml) != 0)
|
|
PARSE_FAIL(p, "parse failed - bad publish elem");
|
|
sxml->pxml = NULL;
|
|
|
|
sxml->scope = SNAPSHOT_SCOPE_SNAPSHOT;
|
|
}
|
|
|
|
static void
|
|
snapshot_xml_elem_start(void *data, const char *el, const char **attr)
|
|
{
|
|
struct snapshot_xml *sxml = data;
|
|
XML_Parser p = sxml->parser;
|
|
|
|
/*
|
|
* Can only enter here once as we should have no ways to get back to
|
|
* NONE scope
|
|
*/
|
|
if (strcmp("snapshot", el) == 0)
|
|
start_snapshot_elem(sxml, attr);
|
|
/*
|
|
* Will enter here multiple times, BUT never nested. will start
|
|
* collecting character data in that handler mem is cleared in end
|
|
* block, (TODO or on parse failure)
|
|
*/
|
|
else if (strcmp("publish", el) == 0)
|
|
start_publish_elem(sxml, attr);
|
|
else
|
|
PARSE_FAIL(p, "parse failed - unexpected elem exit found");
|
|
}
|
|
|
|
static void
|
|
snapshot_xml_elem_end(void *data, const char *el)
|
|
{
|
|
struct snapshot_xml *sxml = data;
|
|
XML_Parser p = sxml->parser;
|
|
|
|
if (strcmp("snapshot", el) == 0)
|
|
end_snapshot_elem(sxml);
|
|
else if (strcmp("publish", el) == 0)
|
|
end_publish_elem(sxml);
|
|
else
|
|
PARSE_FAIL(p, "parse failed - unexpected elem exit found");
|
|
}
|
|
|
|
static void
|
|
snapshot_content_handler(void *data, const char *content, int length)
|
|
{
|
|
struct snapshot_xml *sxml = data;
|
|
XML_Parser p = sxml->parser;
|
|
|
|
if (sxml->scope == SNAPSHOT_SCOPE_PUBLISH)
|
|
if (publish_add_content(sxml->pxml, content, length) == -1)
|
|
PARSE_FAIL(p, "parse failed, snapshot element for %s "
|
|
"too big", sxml->pxml->uri);
|
|
}
|
|
|
|
static void
|
|
snapshot_doctype_handler(void *data, const char *doctypeName,
|
|
const char *sysid, const char *pubid, int subset)
|
|
{
|
|
struct snapshot_xml *sxml = data;
|
|
XML_Parser p = sxml->parser;
|
|
|
|
PARSE_FAIL(p, "parse failed - DOCTYPE not allowed");
|
|
}
|
|
|
|
struct snapshot_xml *
|
|
new_snapshot_xml(XML_Parser p, struct rrdp_session *rs, struct rrdp *r)
|
|
{
|
|
struct snapshot_xml *sxml;
|
|
|
|
if ((sxml = calloc(1, sizeof(*sxml))) == NULL)
|
|
err(1, "%s", __func__);
|
|
sxml->parser = p;
|
|
sxml->current = rs;
|
|
sxml->rrdp = r;
|
|
|
|
if (XML_ParserReset(sxml->parser, "US-ASCII") != XML_TRUE)
|
|
errx(1, "%s: XML_ParserReset failed", __func__);
|
|
|
|
XML_SetElementHandler(sxml->parser, snapshot_xml_elem_start,
|
|
snapshot_xml_elem_end);
|
|
XML_SetCharacterDataHandler(sxml->parser, snapshot_content_handler);
|
|
XML_SetUserData(sxml->parser, sxml);
|
|
XML_SetDoctypeDeclHandler(sxml->parser, snapshot_doctype_handler,
|
|
NULL);
|
|
|
|
return sxml;
|
|
}
|
|
|
|
void
|
|
free_snapshot_xml(struct snapshot_xml *sxml)
|
|
{
|
|
if (sxml == NULL)
|
|
return;
|
|
|
|
free(sxml->session_id);
|
|
free_publish_xml(sxml->pxml);
|
|
free(sxml);
|
|
}
|
|
|
|
/* Used in regress. */
|
|
void
|
|
log_snapshot_xml(struct snapshot_xml *sxml)
|
|
{
|
|
logx("scope: %d", sxml->scope);
|
|
logx("version: %d", sxml->version);
|
|
logx("session_id: %s serial: %lld", sxml->session_id, sxml->serial);
|
|
}
|