void
serialize_test (char *buf, int len)
{
unsigned long time;
iks *x;
iksparser *prs;
char *xml;
int err;
prs = iks_dom_new (&x);
err = iks_parse (prs, buf, len, 1);
switch (err) {
case IKS_OK:
break;
case IKS_NOMEM:
exit (2);
case IKS_BADXML:
fprintf (stderr, "Invalid xml at byte %ld, line %ld\n",
iks_nr_bytes (prs), iks_nr_lines (prs));
exit (1);
case IKS_HOOK:
exit (1);
}
iks_parser_delete (prs);
t_reset ();
xml = iks_string (iks_stack (x), x);
time = t_elapsed ();
printf ("Serialize: serializing the tree took %ld milliseconds.\n", time);
iks_delete (x);
}
void
document (char *xml)
{
enum ikserror err;
iksparser *p;
nr_tests++;
if (my_x) iks_delete (my_x);
p = iks_dom_new (&my_x);
err = iks_parse (p, xml, 0, 1);
switch (err) {
case IKS_OK:
break;
case IKS_NOMEM:
PR_TEST;
puts ("Not enough memory.");
exit (1);
case IKS_BADXML:
PR_TEST;
printf ("Invalid xml at byte %ld in\n[%s]\n", iks_nr_bytes (p), xml);
exit (1);
case IKS_HOOK:
PR_TEST;
puts ("Hook.");
}
iks_parser_delete (p);
}
static void test_rayo_test_srgs(void)
{
iks *grammar = NULL;
iksparser *p = iks_dom_new(&grammar);
ASSERT_EQUALS(IKS_OK, iks_parse(p, rayo_test_srgs, 0, 1));
iks_parser_delete(p);
iks_delete(grammar);
}
static void test_empty_cdata(void)
{
iks *iq = NULL;
iks *input = NULL;
iksparser *p = iks_dom_new(&iq);
const char *cdata;
ASSERT_EQUALS(IKS_OK, iks_parse(p, empty_cdata, 0, 1));
iks_parser_delete(p);
ASSERT_NOT_NULL((input = iks_find(iq, "input")));
ASSERT_NULL((cdata = iks_find_cdata(input, "grammar")));
iks_delete(iq);
}
static void test_repeating_bracket(void)
{
iks *iq = NULL;
iks *input = NULL;
iksparser *p = iks_dom_new(&iq);
const char *cdata;
ASSERT_EQUALS(IKS_OK, iks_parse(p, repeating_bracket, 0, 1));
iks_parser_delete(p);
ASSERT_NOT_NULL((input = iks_find(iq, "input")));
ASSERT_NOT_NULL((cdata = iks_find_cdata(input, "grammar")));
ASSERT_STRING_EQUALS("[1 DIGITS]>]]]]]]]]] ]] ", cdata);
iks_delete(iq);
}
void dom_test (char *buf, int len)
{
int bs, i, err;
iksparser *prs;
unsigned long time;
iks *x;
size_t allocated, used;
bs = block_size;
if (0 == bs) bs = len;
t_reset ();
prs = iks_dom_new (&x);
iks_set_size_hint (prs, len);
i = 0;
while (i < len) {
if (i + bs > len) bs = len - i;
err = iks_parse (prs, buf + i, bs, 0);
switch (err) {
case IKS_OK:
break;
case IKS_NOMEM:
exit (2);
case IKS_BADXML:
fprintf (stderr, "Invalid xml at byte %ld, line %ld\n",
iks_nr_bytes (prs), iks_nr_lines (prs));
exit (1);
case IKS_HOOK:
exit (1);
}
i += bs;
}
time = t_elapsed ();
iks_stack_stat (iks_stack (x), &allocated, &used);
printf ("DOM: parsing and building the tree took %ld milliseconds.\n", time);
printf ("DOM: ikstack: %d bytes allocated, %d bytes used.\n", allocated, used);
t_reset ();
iks_delete (x);
time = t_elapsed ();
printf ("DOM: deleting the tree took %ld milliseconds.\n", time);
iks_parser_delete (prs);
}
/**
* Makes NLSML result to conform to mrcpv2
* @param result the potentially non-conforming result
* @return the conforming result
*/
iks *nlsml_normalize(const char *result)
{
iks *result_xml = NULL;
iksparser *p = iks_dom_new(&result_xml);
if (iks_parse(p, result, 0, 1) == IKS_OK && result_xml) {
/* for now, all that is needed is to set the proper namespace */
iks_insert_attrib(result_xml, "xmlns", NLSML_NS);
} else {
/* unexpected ... */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_INFO, "Failed to normalize NLSML result: %s\n", result);
if (result_xml) {
iks_delete(result_xml);
}
}
iks_parser_delete(p);
return result_xml;
}
iks *
zip_load_xml (zip *z, const char *name, int *err)
{
iksparser *prs;
char *real_buf;
iks *x;
struct zipfile *zfile;
*err = ZIP_OK;
zfile = find_file (z, name);
if (!zfile) {
*err = ZIP_NOFILE;
return NULL;
}
seek_file (z, zfile);
real_buf = malloc (zfile->real_size + 1);
if (zfile->zip_size < zfile->real_size) {
char *zip_buf;
z_stream zs;
zs.zalloc = NULL;
zs.zfree = NULL;
zs.opaque = NULL;
zip_buf = malloc (zfile->zip_size);
fread (zip_buf, zfile->zip_size, 1, z->f);
zs.next_in = zip_buf;
zs.avail_in = zfile->zip_size;
zs.next_out = real_buf;
zs.avail_out = zfile->real_size;
inflateInit2 (&zs, -MAX_WBITS);
inflate (&zs, Z_FINISH);
inflateEnd (&zs);
free (zip_buf);
} else {
fread (real_buf, zfile->real_size, 1, z->f);
}
real_buf[zfile->real_size] = '\0';
prs = iks_dom_new (&x);
iks_parse (prs, real_buf, zfile->real_size, 1);
iks_parser_delete (prs);
free (real_buf);
return x;
}
/**
* Send rayo complete
*/
void rayo_component_send_complete_with_metadata_string(struct rayo_component *component, const char *reason, const char *reason_namespace, const char *meta, int child_of_complete)
{
iks *meta_xml = NULL;
iksparser *p = iks_dom_new(&meta_xml);
if (iks_parse(p, meta, 0, 1) != IKS_OK) {
/* unexpected ... */
switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "%s Failed to parse metadata for complete event: %s\n",
RAYO_JID(component), meta);
/* send without... */
rayo_component_send_complete(component, reason, reason_namespace);
} else {
rayo_component_send_complete_with_metadata(component, reason, reason_namespace, meta_xml, child_of_complete);
}
if (meta_xml) {
iks_delete(meta_xml);
}
iks_parser_delete(p);
}