src/core/sipe-xml.c

   1 /**
   2  * @file sipe-xml.c
   3  *
   4  * pidgin-sipe
   5  *
   6  * Copyright (C) 2010-12 SIPE Project <http://sipe.sourceforge.net/>
   7  *
   8  * This program is free software; you can redistribute it and/or modify
   9  * it under the terms of the GNU General Public License as published by
  10  * the Free Software Foundation; either version 2 of the License, or
  11  * (at your option) any later version.
  12  *
  13  * This program is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16  * GNU General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU General Public License
  19  * along with this program; if not, write to the Free Software
  20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21  */
  22
  23 /*
  24  * This code is loosely based on libpurple xmlnode.c
  25  */
  26
  27 #include <stdarg.h>
  28 #include <string.h>
  29 #include <time.h>
  30
  31 #include "libxml/parser.h"
  32 #include "libxml/c14n.h"
  33 #include "libxml/xmlversion.h"
  34
  35 #include "glib.h"
  36
  37 #include "sipe-backend.h"
  38 #include "sipe-utils.h"
  39 #include "sipe-xml.h"
  40
  41 struct _sipe_xml {
  42         gchar *name;
  43         sipe_xml *parent;
  44         sipe_xml *sibling;
  45         sipe_xml *first;
  46         sipe_xml *last;
  47         GString *data;
  48         GHashTable *attributes;
  49 };
  50
  51 struct _parser_data {
  52         sipe_xml *root;
  53         sipe_xml *current;
  54         gboolean error;
  55 };
  56
  57 static void callback_start_element(void *user_data, const xmlChar *name, const xmlChar **attrs)
  58 {
  59         struct _parser_data *pd = user_data;
  60         const char *tmp;
  61         sipe_xml *node;
  62
  63         if (!name || pd->error) return;
  64
  65         node = g_new0(sipe_xml, 1);
  66
  67         if ((tmp = strchr((char *)name, ':')) != NULL) {
  68                 name = (xmlChar *)tmp + 1;
  69         }
  70         node->name = g_strdup((gchar *)name);
  71
  72         if (!pd->root) {
  73                 pd->root = node;
  74         } else {
  75                 sipe_xml *current = pd->current;
  76
  77                 node->parent = current;
  78                 if (current->last) {
  79                         current->last->sibling = node;
  80                 } else {
  81                         current->first = node;
  82                 }
  83                 current->last = node;
  84         }
  85
  86         if (attrs) {
  87                 const xmlChar *key;
  88
  89                 node->attributes = g_hash_table_new_full(g_str_hash,
  90                                                          (GEqualFunc) sipe_strcase_equal,
  91                                                          g_free, g_free);
  92                 while ((key = *attrs++) != NULL) {
  93                         if ((tmp = strchr((char *)key, ':')) != NULL) {
  94                                 key = (xmlChar *)tmp + 1;
  95                         }
  96                         /* libxml2 decodes all entities except &amp;.
  97                            &amp; is replaced by the equivalent &#38; */
  98                         g_hash_table_insert(node->attributes,
  99                                             g_strdup((gchar *) key),
 100                                             replace((gchar *) *attrs++, "&#38;", "&"));
 101                 }
 102         }
 103
 104         pd->current = node;
 105 }
 106
 107 static void callback_end_element(void *user_data, const xmlChar *name)
 108 {
 109         struct _parser_data *pd = user_data;
 110
 111         if (!name || !pd->current || pd->error) return;
 112
 113         if (pd->current->parent)
 114                 pd->current = pd->current->parent;
 115 }
 116
 117 static void callback_characters(void *user_data, const xmlChar *text, int text_len)
 118 {
 119         struct _parser_data *pd = user_data;
 120         sipe_xml *node;
 121
 122         if (!pd->current || pd->error || !text || !text_len) return;
 123
 124         node = pd->current;
 125         if (node->data)
 126                 node->data = g_string_append_len(node->data, (gchar *)text, text_len);
 127         else
 128                 node->data = g_string_new_len((gchar *)text, text_len);
 129 }
 130
 131 static void callback_error(void *user_data, const char *msg, ...)
 132 {
 133         struct _parser_data *pd = user_data;
 134         gchar *errmsg;
 135         va_list args;
 136
 137         pd->error = TRUE;
 138
 139         va_start(args, msg);
 140         errmsg = g_strdup_vprintf(msg, args);
 141         va_end(args);
 142
 143         SIPE_DEBUG_ERROR("error parsing xml string: %s", errmsg);
 144         g_free(errmsg);
 145 }
 146
 147 static void callback_serror(void *user_data, xmlErrorPtr error)
 148 {
 149         struct _parser_data *pd = user_data;
 150
 151         if (error && (error->level == XML_ERR_ERROR ||
 152                       error->level == XML_ERR_FATAL)) {
 153                 pd->error = TRUE;
 154                 SIPE_DEBUG_ERROR("XML parser error: Domain %i, code %i, level %i: %s",
 155                                  error->domain, error->code, error->level,
 156                                  error->message ? error->message : "(null)");
 157         } else if (error) {
 158                 SIPE_DEBUG_WARNING("XML parser error: Domain %i, code %i, level %i: %s",
 159                                    error->domain, error->code, error->level,
 160                                    error->message ? error->message : "(null)");
 161         } else {
 162                 /* *sigh* macro expects at least two parameters */
 163                 SIPE_DEBUG_WARNING_NOFORMAT("XML parser error");
 164         }
 165 }
 166
 167 /* API doesn't accept const data structure */
 168 static xmlSAXHandler parser = {
 169         NULL,                   /* internalSubset */
 170         NULL,                   /* isStandalone */
 171         NULL,                   /* hasInternalSubset */
 172         NULL,                   /* hasExternalSubset */
 173         NULL,                   /* resolveEntity */
 174         NULL,                   /* getEntity */
 175         NULL,                   /* entityDecl */
 176         NULL,                   /* notationDecl */
 177         NULL,                   /* attributeDecl */
 178         NULL,                   /* elementDecl */
 179         NULL,                   /* unparsedEntityDecl */
 180         NULL,                   /* setDocumentLocator */
 181         NULL,                   /* startDocument */
 182         NULL,                   /* endDocument */
 183         callback_start_element, /* startElement */
 184         callback_end_element,   /* endElement   */
 185         NULL,                   /* reference */
 186         callback_characters,    /* characters */
 187         NULL,                   /* ignorableWhitespace */
 188         NULL,                   /* processingInstruction */
 189         NULL,                   /* comment */
 190         NULL,                   /* warning */
 191         callback_error,         /* error */
 192         NULL,                   /* fatalError */
 193         NULL,                   /* getParameterEntity */
 194         NULL,                   /* cdataBlock */
 195         NULL,                   /* externalSubset */
 196         XML_SAX2_MAGIC,         /* initialized */
 197         NULL,                   /* _private */
 198         NULL,                   /* startElementNs */
 199         NULL,                   /* endElementNs   */
 200         callback_serror,        /* serror */
 201 };
 202
 203 sipe_xml *sipe_xml_parse(const gchar *string, gsize length)
 204 {
 205         sipe_xml *result = NULL;
 206
 207         if (string && length) {
 208                 struct _parser_data *pd = g_new0(struct _parser_data, 1);
 209
 210                 if (xmlSAXUserParseMemory(&parser, pd, string, length))
 211                         pd->error = TRUE;
 212
 213                 if (pd->error) {
 214                         sipe_xml_free(pd->root);
 215                 } else {
 216                         result = pd->root;
 217                 }
 218
 219                 g_free(pd);
 220         }
 221
 222         return result;
 223 }
 224
 225 void sipe_xml_free(sipe_xml *node)
 226 {
 227         sipe_xml *child;
 228
 229         if (!node) return;
 230
 231         /* we don't support partial tree deletion */
 232         if (node->parent != NULL) {
 233                 SIPE_DEBUG_ERROR_NOFORMAT("sipe_xml_free: partial delete attempt! Expect crash or memory leaks...");
 234         }
 235
 236         /* free children */
 237         child = node->first;
 238         while (child) {
 239                 sipe_xml *tmp = child->sibling;
 240                 child->parent = NULL; /* detach from tree, see above */
 241                 sipe_xml_free(child);
 242                 child = tmp;
 243         }
 244
 245         /* free node */
 246         g_free(node->name);
 247         if (node->data)       g_string_free(node->data, TRUE);
 248         if (node->attributes) g_hash_table_destroy(node->attributes);
 249         g_free(node);
 250 }
 251
 252 static void sipe_xml_stringify_attribute(gpointer key, gpointer value,
 253                                          gpointer user_data)
 254 {
 255         g_string_append_printf(user_data, " %s=\"%s\"",
 256                                (const gchar *) key, (const gchar *) value);
 257 }
 258
 259 static void sipe_xml_stringify_node(GString *s, const sipe_xml *node)
 260 {
 261         g_string_append_printf(s, "<%s", node->name);
 262
 263         if (node->attributes) {
 264                 g_hash_table_foreach(node->attributes,
 265                                      (GHFunc) sipe_xml_stringify_attribute,
 266                                      s);
 267         }
 268
 269         if (node->data || node->first) {
 270                 const sipe_xml *child;
 271
 272                 g_string_append_printf(s, ">%s",
 273                                        node->data ? node->data->str : "");
 274
 275                 for (child = node->first; child; child = child->sibling)
 276                         sipe_xml_stringify_node(s, child);
 277
 278                 g_string_append_printf(s, "</%s>", node->name);
 279         } else {
 280                 g_string_append(s, "/>");
 281         }
 282 }
 283
 284 gchar *sipe_xml_stringify(const sipe_xml *node)
 285 {
 286         GString *s;
 287
 288         if (!node) return NULL;
 289
 290         s = g_string_new("");
 291         sipe_xml_stringify_node(s, node);
 292         return g_string_free(s, FALSE);
 293 }
 294
 295 const sipe_xml *sipe_xml_child(const sipe_xml *parent, const gchar *name)
 296 {
 297         gchar **names;
 298         const sipe_xml *child = NULL;
 299
 300         if (!parent || !name) return NULL;
 301
 302         /* 0: child name */
 303         /* 1: trailing path (optional) */
 304         names = g_strsplit(name, "/", 2);
 305
 306         for (child = parent->first; child; child = child->sibling) {
 307                 if (sipe_strequal(names[0], child->name))
 308                         break;
 309         }
 310
 311         /* recurse into path */
 312         if (child && names[1])
 313                 child = sipe_xml_child(child, names[1]);
 314
 315         g_strfreev(names);
 316         return child;
 317 }
 318
 319 const sipe_xml *sipe_xml_twin(const sipe_xml *node)
 320 {
 321         sipe_xml *sibling;
 322
 323         if (!node) return NULL;
 324
 325         for (sibling = node->sibling; sibling; sibling = sibling->sibling) {
 326                 if (sipe_strequal(node->name, sibling->name))
 327                         return sibling;
 328         }
 329         return NULL;
 330 }
 331
 332 const gchar *sipe_xml_name(const sipe_xml *node)
 333 {
 334         return(node ? node->name : NULL);
 335 }
 336
 337 const gchar *sipe_xml_attribute(const sipe_xml *node, const gchar *attr)
 338 {
 339         if (!node || !attr || !node->attributes) return NULL;
 340         return(g_hash_table_lookup(node->attributes, attr));
 341 }
 342
 343 guint sipe_xml_int_attribute(const sipe_xml *node, const gchar *attr,
 344                              guint fallback)
 345 {
 346         const gchar *value = sipe_xml_attribute(node, attr);
 347         return(value ? g_ascii_strtoull(value, NULL, 10) : fallback);
 348 }
 349
 350 gchar *sipe_xml_data(const sipe_xml *node)
 351 {
 352         if (!node || !node->data || !node->data->str) return NULL;
 353         return g_strdup(node->data->str);
 354 }
 355
 356 /**
 357  * Set to 1 to enable debugging code and then add this line to your code:
 358  *
 359  *      sipe_xml_dump(node, NULL);
 360  */
 361 #if 0
 362 void sipe_xml_dump(const sipe_xml *node, const gchar *path)
 363 {
 364         const sipe_xml *child;
 365         gchar *new_path;
 366         if (!node) return;
 367         new_path = g_strdup_printf("%s/%s", path ? path : "", node->name);
 368         if (node->attributes) {
 369                 GList *attrs = g_hash_table_get_keys(node->attributes);
 370                 GString *buf = g_string_new("");
 371                 GList *entry = attrs;
 372                 while (entry) {
 373                         g_string_append_printf(buf, "%s ", (gchar *)entry->data);
 374                         entry = entry->next;
 375                 }
 376                 SIPE_DEBUG_INFO("%s [%s]", new_path, buf->str);
 377                 g_string_free(buf, TRUE);
 378                 g_list_free(attrs);
 379         } else {
 380                 SIPE_DEBUG_INFO_NOFORMAT(new_path);
 381         }
 382         for (child = node->first; child; child = child->sibling)
 383                 sipe_xml_dump(child, new_path);
 384         g_free(new_path);
 385 }
 386 #endif
 387
 388 /*
 389  * Other XML convenience functions not based on libpurple xmlnode.c
 390  */
 391
 392 gchar *sipe_xml_exc_c14n(const gchar *string)
 393 {
 394         /* Parse string to XML document */
 395         xmlDocPtr doc = xmlReadMemory(string, strlen(string), "", NULL, 0);
 396         gchar *canon = NULL;
 397
 398         if (doc) {
 399                 xmlChar *buffer;
 400                 int size;
 401
 402                 /* Apply canonicalization */
 403                 size = xmlC14NDocDumpMemory(doc,
 404                                             NULL,
 405 #if LIBXML_VERSION > 20703
 406                                             /* new API: int mode (a xmlC14NMode) */
 407                                             XML_C14N_EXCLUSIVE_1_0,
 408 #else
 409                                             /* old API: int exclusive */
 410                                             1,
 411 #endif
 412                                             NULL,
 413                                             0,
 414                                             &buffer);
 415                 xmlFreeDoc(doc);
 416
 417                 if (size >= 0) {
 418                         SIPE_DEBUG_INFO("sipe_xml_exc_c14n:\noriginal:      %s\ncanonicalized: %s",
 419                                         string, buffer);
 420                         canon = g_strndup((gchar *) buffer, size);
 421                         xmlFree(buffer);
 422                 } else {
 423                         SIPE_DEBUG_ERROR("sipe_xml_exc_c14n: failed to canonicalize xml string:\n%s",
 424                                          string);
 425                 }
 426         } else {
 427                 SIPE_DEBUG_ERROR("sipe_xml_exc_c14n: error parsing xml string:\n%s",
 428                                  string);
 429         }
 430
 431         return(canon);
 432 }
 433
 434 gchar *sipe_xml_extract_raw(const gchar *xml, const gchar *tag,
 435                             gboolean include_tag)
 436 {
 437         gchar *tag_start = g_strdup_printf("<%s", tag);
 438         gchar *tag_end = g_strdup_printf("</%s>", tag);
 439         gchar *data = NULL;
 440         const gchar *start = strstr(xml, tag_start);
 441
 442         if (start) {
 443                 const gchar *end = strstr(start + strlen(tag_start), tag_end);
 444                 if (end) {
 445                         if (include_tag) {
 446                                 data = g_strndup(start, end + strlen(tag_end) - start);
 447                         } else {
 448                                 const gchar *tmp = strchr(start + strlen(tag_start), '>') + 1;
 449                                 data = g_strndup(tmp, end - tmp);
 450                         }
 451                 }
 452         }
 453
 454         g_free(tag_end);
 455         g_free(tag_start);
 456         return data;
 457 }
 458
 459 /*
 460   Local Variables:
 461   mode: c
 462   c-file-style: "bsd"
 463   indent-tabs-mode: t
 464   tab-width: 8
 465   End:
 466 */