libpurple/xmlnode.c

   1 /* purple
   2  *
   3  * Purple is the legal property of its developers, whose names are too numerous
   4  * to list here.  Please refer to the COPYRIGHT file distributed with this
   5  * source distribution.
   6  *
   7  * This program is free software; you can redistribute it and/or modify
   8  * it under the terms of the GNU General Public License as published by
   9  * the Free Software Foundation; either version 2 of the License, or
  10  * (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02111-1301  USA
  20  */
  21
  22 /* A lot of this code at least resembles the code in libxode, but since
  23  * libxode uses memory pools that we simply have no need for, I decided to
  24  * write my own stuff.  Also, re-writing this lets me be as lightweight
  25  * as I want to be.  Thank you libxode for giving me a good starting point */
  26
  27 #include "internal.h"
  28 #include "debug.h"
  29
  30 #include <libxml/parser.h>
  31 #include <string.h>
  32 #include <glib.h>
  33
  34 #include "util.h"
  35 #include "xmlnode.h"
  36
  37 #ifdef _WIN32
  38 # define NEWLINE_S "\r\n"
  39 #else
  40 # define NEWLINE_S "\n"
  41 #endif
  42
  43 static PurpleXmlNode*
  44 new_node(const char *name, PurpleXmlNodeType type)
  45 {
  46         PurpleXmlNode *node = g_new0(PurpleXmlNode, 1);
  47
  48         node->name = g_strdup(name);
  49         node->type = type;
  50
  51         return node;
  52 }
  53
  54 PurpleXmlNode*
  55 purple_xmlnode_new(const char *name)
  56 {
  57         g_return_val_if_fail(name != NULL && *name != '\0', NULL);
  58
  59         return new_node(name, PURPLE_XMLNODE_TYPE_TAG);
  60 }
  61
  62 PurpleXmlNode *
  63 purple_xmlnode_new_child(PurpleXmlNode *parent, const char *name)
  64 {
  65         PurpleXmlNode *node;
  66
  67         g_return_val_if_fail(parent != NULL, NULL);
  68         g_return_val_if_fail(name != NULL && *name != '\0', NULL);
  69
  70         node = new_node(name, PURPLE_XMLNODE_TYPE_TAG);
  71
  72         purple_xmlnode_insert_child(parent, node);
  73
  74         return node;
  75 }
  76
  77 void
  78 purple_xmlnode_insert_child(PurpleXmlNode *parent, PurpleXmlNode *child)
  79 {
  80         g_return_if_fail(parent != NULL);
  81         g_return_if_fail(child != NULL);
  82
  83         child->parent = parent;
  84
  85         if(parent->lastchild) {
  86                 parent->lastchild->next = child;
  87         } else {
  88                 parent->child = child;
  89         }
  90
  91         parent->lastchild = child;
  92 }
  93
  94 void
  95 purple_xmlnode_insert_data(PurpleXmlNode *node, const char *data, gssize size)
  96 {
  97         PurpleXmlNode *child;
  98         gsize real_size;
  99
 100         g_return_if_fail(node != NULL);
 101         g_return_if_fail(data != NULL);
 102         g_return_if_fail(size != 0);
 103
 104         real_size = size == -1 ? strlen(data) : (gsize)size;
 105
 106         child = new_node(NULL, PURPLE_XMLNODE_TYPE_DATA);
 107
 108         child->data = g_memdup(data, real_size);
 109         child->data_sz = real_size;
 110
 111         purple_xmlnode_insert_child(node, child);
 112 }
 113
 114 void
 115 purple_xmlnode_remove_attrib(PurpleXmlNode *node, const char *attr)
 116 {
 117         PurpleXmlNode *attr_node, *sibling = NULL;
 118
 119         g_return_if_fail(node != NULL);
 120         g_return_if_fail(attr != NULL);
 121
 122         attr_node = node->child;
 123         while (attr_node) {
 124                 if(attr_node->type == PURPLE_XMLNODE_TYPE_ATTRIB &&
 125                                 purple_strequal(attr_node->name, attr))
 126                 {
 127                         if (node->lastchild == attr_node) {
 128                                 node->lastchild = sibling;
 129                         }
 130                         if (sibling == NULL) {
 131                                 node->child = attr_node->next;
 132                                 purple_xmlnode_free(attr_node);
 133                                 attr_node = node->child;
 134                         } else {
 135                                 sibling->next = attr_node->next;
 136                                 sibling = attr_node->next;
 137                                 purple_xmlnode_free(attr_node);
 138                                 attr_node = sibling;
 139                         }
 140                 }
 141                 else
 142                 {
 143                         attr_node = attr_node->next;
 144                 }
 145                 sibling = attr_node;
 146         }
 147 }
 148
 149 void
 150 purple_xmlnode_remove_attrib_with_namespace(PurpleXmlNode *node, const char *attr, const char *xmlns)
 151 {
 152         PurpleXmlNode *attr_node, *sibling = NULL;
 153
 154         g_return_if_fail(node != NULL);
 155         g_return_if_fail(attr != NULL);
 156
 157         for(attr_node = node->child; attr_node; attr_node = attr_node->next)
 158         {
 159                 if(attr_node->type == PURPLE_XMLNODE_TYPE_ATTRIB &&
 160                    purple_strequal(attr,  attr_node->name) &&
 161                    purple_strequal(xmlns, attr_node->xmlns))
 162                 {
 163                         if(sibling == NULL) {
 164                                 node->child = attr_node->next;
 165                         } else {
 166                                 sibling->next = attr_node->next;
 167                         }
 168                         if (node->lastchild == attr_node) {
 169                                 node->lastchild = sibling;
 170                         }
 171                         purple_xmlnode_free(attr_node);
 172                         return;
 173                 }
 174                 sibling = attr_node;
 175         }
 176 }
 177
 178 void
 179 purple_xmlnode_set_attrib(PurpleXmlNode *node, const char *attr, const char *value)
 180 {
 181         purple_xmlnode_remove_attrib(node, attr);
 182         purple_xmlnode_set_attrib_full(node, attr, NULL, NULL, value);
 183 }
 184
 185 void
 186 purple_xmlnode_set_attrib_full(PurpleXmlNode *node, const char *attr, const char *xmlns, const char *prefix, const char *value)
 187 {
 188         PurpleXmlNode *attrib_node;
 189
 190         g_return_if_fail(node != NULL);
 191         g_return_if_fail(attr != NULL);
 192         g_return_if_fail(value != NULL);
 193
 194         purple_xmlnode_remove_attrib_with_namespace(node, attr, xmlns);
 195         attrib_node = new_node(attr, PURPLE_XMLNODE_TYPE_ATTRIB);
 196
 197         attrib_node->data = g_strdup(value);
 198         attrib_node->xmlns = g_strdup(xmlns);
 199         attrib_node->prefix = g_strdup(prefix);
 200
 201         purple_xmlnode_insert_child(node, attrib_node);
 202 }
 203
 204
 205 const char *
 206 purple_xmlnode_get_attrib(const PurpleXmlNode *node, const char *attr)
 207 {
 208         PurpleXmlNode *x;
 209
 210         g_return_val_if_fail(node != NULL, NULL);
 211         g_return_val_if_fail(attr != NULL, NULL);
 212
 213         for(x = node->child; x; x = x->next) {
 214                 if(x->type == PURPLE_XMLNODE_TYPE_ATTRIB && purple_strequal(attr, x->name)) {
 215                         return x->data;
 216                 }
 217         }
 218
 219         return NULL;
 220 }
 221
 222 const char *
 223 purple_xmlnode_get_attrib_with_namespace(const PurpleXmlNode *node, const char *attr, const char *xmlns)
 224 {
 225         const PurpleXmlNode *x;
 226
 227         g_return_val_if_fail(node != NULL, NULL);
 228         g_return_val_if_fail(attr != NULL, NULL);
 229
 230         for(x = node->child; x; x = x->next) {
 231                 if(x->type == PURPLE_XMLNODE_TYPE_ATTRIB &&
 232                    purple_strequal(attr,  x->name) &&
 233                    purple_strequal(xmlns, x->xmlns)) {
 234                         return x->data;
 235                 }
 236         }
 237
 238         return NULL;
 239 }
 240
 241
 242 void purple_xmlnode_set_namespace(PurpleXmlNode *node, const char *xmlns)
 243 {
 244         char *tmp;
 245         g_return_if_fail(node != NULL);
 246
 247         tmp = node->xmlns;
 248         node->xmlns = g_strdup(xmlns);
 249
 250         if (node->namespace_map) {
 251                 g_hash_table_insert(node->namespace_map,
 252                         g_strdup(""), g_strdup(xmlns));
 253         }
 254
 255         g_free(tmp);
 256 }
 257
 258 const char *purple_xmlnode_get_namespace(const PurpleXmlNode *node)
 259 {
 260         g_return_val_if_fail(node != NULL, NULL);
 261
 262         return node->xmlns;
 263 }
 264
 265 const char *purple_xmlnode_get_default_namespace(const PurpleXmlNode *node)
 266 {
 267         const PurpleXmlNode *current_node;
 268         const char *ns = NULL;
 269
 270         g_return_val_if_fail(node != NULL, NULL);
 271
 272         current_node = node;
 273         while (current_node) {
 274                 /* If this node does *not* have a prefix, node->xmlns is the default
 275                  * namespace.  Otherwise, it's the prefix namespace.
 276                  */
 277                 if (!current_node->prefix && current_node->xmlns) {
 278                         return current_node->xmlns;
 279                 } else if (current_node->namespace_map) {
 280                         ns = g_hash_table_lookup(current_node->namespace_map, "");
 281                         if (ns && *ns)
 282                                 return ns;
 283                 }
 284
 285                 current_node = current_node->parent;
 286         }
 287
 288         return ns;
 289 }
 290
 291 void purple_xmlnode_set_prefix(PurpleXmlNode *node, const char *prefix)
 292 {
 293         g_return_if_fail(node != NULL);
 294
 295         g_free(node->prefix);
 296         node->prefix = g_strdup(prefix);
 297 }
 298
 299 const char *purple_xmlnode_get_prefix(const PurpleXmlNode *node)
 300 {
 301         g_return_val_if_fail(node != NULL, NULL);
 302         return node->prefix;
 303 }
 304
 305 const char *purple_xmlnode_get_prefix_namespace(const PurpleXmlNode *node, const char *prefix)
 306 {
 307         const PurpleXmlNode *current_node;
 308
 309         g_return_val_if_fail(node != NULL, NULL);
 310         g_return_val_if_fail(prefix != NULL, purple_xmlnode_get_default_namespace(node));
 311
 312         current_node = node;
 313         while (current_node) {
 314                 if (current_node->prefix && g_str_equal(prefix, current_node->prefix) &&
 315                                 current_node->xmlns) {
 316                         return current_node->xmlns;
 317                 } else if (current_node->namespace_map) {
 318                         const char *ns = g_hash_table_lookup(current_node->namespace_map, prefix);
 319                         if (ns && *ns) {
 320                                 return ns;
 321                         }
 322                 }
 323
 324                 current_node = current_node->parent;
 325         }
 326
 327         return NULL;
 328 }
 329
 330 void purple_xmlnode_strip_prefixes(PurpleXmlNode *node)
 331 {
 332         PurpleXmlNode *child;
 333         const char *prefix;
 334
 335         g_return_if_fail(node != NULL);
 336
 337         for (child = node->child; child; child = child->next) {
 338                 if (child->type == PURPLE_XMLNODE_TYPE_TAG)
 339                         purple_xmlnode_strip_prefixes(child);
 340         }
 341
 342         prefix = purple_xmlnode_get_prefix(node);
 343         if (prefix) {
 344                 const char *ns = purple_xmlnode_get_prefix_namespace(node, prefix);
 345                 purple_xmlnode_set_namespace(node, ns);
 346                 purple_xmlnode_set_prefix(node, NULL);
 347         } else {
 348                 purple_xmlnode_set_namespace(node, purple_xmlnode_get_default_namespace(node));
 349         }
 350 }
 351
 352 PurpleXmlNode *purple_xmlnode_get_parent(const PurpleXmlNode *child)
 353 {
 354         g_return_val_if_fail(child != NULL, NULL);
 355         return child->parent;
 356 }
 357
 358 void
 359 purple_xmlnode_free(PurpleXmlNode *node)
 360 {
 361         PurpleXmlNode *x, *y;
 362
 363         g_return_if_fail(node != NULL);
 364
 365         /* if we're part of a tree, remove ourselves from the tree first */
 366         if(NULL != node->parent) {
 367                 if(node->parent->child == node) {
 368                         node->parent->child = node->next;
 369                         if (node->parent->lastchild == node)
 370                                 node->parent->lastchild = node->next;
 371                 } else {
 372                         PurpleXmlNode *prev = node->parent->child;
 373                         while(prev && prev->next != node) {
 374                                 prev = prev->next;
 375                         }
 376                         if(prev) {
 377                                 prev->next = node->next;
 378                                 if (node->parent->lastchild == node)
 379                                         node->parent->lastchild = prev;
 380                         }
 381                 }
 382         }
 383
 384         /* now free our children */
 385         x = node->child;
 386         while(x) {
 387                 y = x->next;
 388                 purple_xmlnode_free(x);
 389                 x = y;
 390         }
 391
 392         /* now dispose of ourselves */
 393         g_free(node->name);
 394         g_free(node->data);
 395         g_free(node->xmlns);
 396         g_free(node->prefix);
 397
 398         if(node->namespace_map)
 399                 g_hash_table_destroy(node->namespace_map);
 400
 401         g_free(node);
 402 }
 403
 404 PurpleXmlNode*
 405 purple_xmlnode_get_child(const PurpleXmlNode *parent, const char *name)
 406 {
 407         return purple_xmlnode_get_child_with_namespace(parent, name, NULL);
 408 }
 409
 410 PurpleXmlNode *
 411 purple_xmlnode_get_child_with_namespace(const PurpleXmlNode *parent, const char *name, const char *ns)
 412 {
 413         PurpleXmlNode *x, *ret = NULL;
 414         char **names;
 415         char *parent_name, *child_name;
 416
 417         g_return_val_if_fail(parent != NULL, NULL);
 418         g_return_val_if_fail(name != NULL, NULL);
 419
 420         names = g_strsplit(name, "/", 2);
 421         parent_name = names[0];
 422         child_name = names[1];
 423
 424         for(x = parent->child; x; x = x->next) {
 425                 /* XXX: Is it correct to ignore the namespace for the match if none was specified? */
 426                 const char *xmlns = NULL;
 427                 if(ns)
 428                         xmlns = purple_xmlnode_get_namespace(x);
 429
 430                 if(x->type == PURPLE_XMLNODE_TYPE_TAG && purple_strequal(parent_name, x->name)
 431                                 && purple_strequal(ns, xmlns)) {
 432                         ret = x;
 433                         break;
 434                 }
 435         }
 436
 437         if(child_name && ret)
 438                 ret = purple_xmlnode_get_child(ret, child_name);
 439
 440         g_strfreev(names);
 441         return ret;
 442 }
 443
 444 char *
 445 purple_xmlnode_get_data(const PurpleXmlNode *node)
 446 {
 447         GString *str = NULL;
 448         PurpleXmlNode *c;
 449
 450         g_return_val_if_fail(node != NULL, NULL);
 451
 452         for(c = node->child; c; c = c->next) {
 453                 if(c->type == PURPLE_XMLNODE_TYPE_DATA) {
 454                         if(!str)
 455                                 str = g_string_new_len(c->data, c->data_sz);
 456                         else
 457                                 str = g_string_append_len(str, c->data, c->data_sz);
 458                 }
 459         }
 460
 461         if (str == NULL)
 462                 return NULL;
 463
 464         return g_string_free(str, FALSE);
 465 }
 466
 467 char *
 468 purple_xmlnode_get_data_unescaped(const PurpleXmlNode *node)
 469 {
 470         char *escaped = purple_xmlnode_get_data(node);
 471
 472         char *unescaped = escaped ? purple_unescape_html(escaped) : NULL;
 473
 474         g_free(escaped);
 475
 476         return unescaped;
 477 }
 478
 479 static void
 480 purple_xmlnode_to_str_foreach_append_ns(const char *key, const char *value,
 481         GString *buf)
 482 {
 483         if (*key) {
 484                 g_string_append_printf(buf, " xmlns:%s='%s'", key, value);
 485         } else {
 486                 g_string_append_printf(buf, " xmlns='%s'", value);
 487         }
 488 }
 489
 490 static char *
 491 purple_xmlnode_to_str_helper(const PurpleXmlNode *node, int *len, gboolean formatting, int depth)
 492 {
 493         GString *text = g_string_new("");
 494         const char *prefix;
 495         const PurpleXmlNode *c;
 496         char *node_name, *esc, *esc2, *tab = NULL;
 497         gboolean need_end = FALSE, pretty = formatting;
 498
 499         g_return_val_if_fail(node != NULL, NULL);
 500
 501         if(pretty && depth) {
 502                 tab = g_strnfill(depth, '\t');
 503                 text = g_string_append(text, tab);
 504         }
 505
 506         node_name = g_markup_escape_text(node->name, -1);
 507         prefix = purple_xmlnode_get_prefix(node);
 508
 509         if (prefix) {
 510                 g_string_append_printf(text, "<%s:%s", prefix, node_name);
 511         } else {
 512                 g_string_append_printf(text, "<%s", node_name);
 513         }
 514
 515         if (node->namespace_map) {
 516                 g_hash_table_foreach(node->namespace_map,
 517                         (GHFunc)purple_xmlnode_to_str_foreach_append_ns, text);
 518         } else {
 519                 /* Figure out if this node has a different default namespace from parent */
 520                 const char *xmlns = NULL;
 521                 const char *parent_xmlns = NULL;
 522                 if (!prefix)
 523                         xmlns = node->xmlns;
 524
 525                 if (!xmlns)
 526                         xmlns = purple_xmlnode_get_default_namespace(node);
 527                 if (node->parent)
 528                         parent_xmlns = purple_xmlnode_get_default_namespace(node->parent);
 529                 if (!purple_strequal(xmlns, parent_xmlns))
 530                 {
 531                         char *escaped_xmlns = g_markup_escape_text(xmlns, -1);
 532                         g_string_append_printf(text, " xmlns='%s'", escaped_xmlns);
 533                         g_free(escaped_xmlns);
 534                 }
 535         }
 536         for(c = node->child; c; c = c->next)
 537         {
 538                 if(c->type == PURPLE_XMLNODE_TYPE_ATTRIB) {
 539                         const char *aprefix = purple_xmlnode_get_prefix(c);
 540                         esc = g_markup_escape_text(c->name, -1);
 541                         esc2 = g_markup_escape_text(c->data, -1);
 542                         if (aprefix) {
 543                                 g_string_append_printf(text, " %s:%s='%s'", aprefix, esc, esc2);
 544                         } else {
 545                                 g_string_append_printf(text, " %s='%s'", esc, esc2);
 546                         }
 547                         g_free(esc);
 548                         g_free(esc2);
 549                 } else if(c->type == PURPLE_XMLNODE_TYPE_TAG || c->type == PURPLE_XMLNODE_TYPE_DATA) {
 550                         if(c->type == PURPLE_XMLNODE_TYPE_DATA)
 551                                 pretty = FALSE;
 552                         need_end = TRUE;
 553                 }
 554         }
 555
 556         if(need_end) {
 557                 g_string_append_printf(text, ">%s", pretty ? NEWLINE_S : "");
 558
 559                 for(c = node->child; c; c = c->next)
 560                 {
 561                         if(c->type == PURPLE_XMLNODE_TYPE_TAG) {
 562                                 int esc_len;
 563                                 esc = purple_xmlnode_to_str_helper(c, &esc_len, pretty, depth+1);
 564                                 text = g_string_append_len(text, esc, esc_len);
 565                                 g_free(esc);
 566                         } else if(c->type == PURPLE_XMLNODE_TYPE_DATA && c->data_sz > 0) {
 567                                 esc = g_markup_escape_text(c->data, c->data_sz);
 568                                 text = g_string_append(text, esc);
 569                                 g_free(esc);
 570                         }
 571                 }
 572
 573                 if(tab && pretty)
 574                         text = g_string_append(text, tab);
 575                 if (prefix) {
 576                         g_string_append_printf(text, "</%s:%s>%s", prefix, node_name, formatting ? NEWLINE_S : "");
 577                 } else {
 578                         g_string_append_printf(text, "</%s>%s", node_name, formatting ? NEWLINE_S : "");
 579                 }
 580         } else {
 581                 g_string_append_printf(text, "/>%s", formatting ? NEWLINE_S : "");
 582         }
 583
 584         g_free(node_name);
 585
 586         g_free(tab);
 587
 588         if(len)
 589                 *len = text->len;
 590
 591         return g_string_free(text, FALSE);
 592 }
 593
 594 char *
 595 purple_xmlnode_to_str(const PurpleXmlNode *node, int *len)
 596 {
 597         return purple_xmlnode_to_str_helper(node, len, FALSE, 0);
 598 }
 599
 600 char *
 601 purple_xmlnode_to_formatted_str(const PurpleXmlNode *node, int *len)
 602 {
 603         char *xml, *xml_with_declaration;
 604
 605         g_return_val_if_fail(node != NULL, NULL);
 606
 607         xml = purple_xmlnode_to_str_helper(node, len, TRUE, 0);
 608         xml_with_declaration =
 609                 g_strdup_printf("<?xml version='1.0' encoding='UTF-8' ?>" NEWLINE_S NEWLINE_S "%s", xml);
 610         g_free(xml);
 611
 612         if (len)
 613                 *len += sizeof("<?xml version='1.0' encoding='UTF-8' ?>" NEWLINE_S NEWLINE_S) - 1;
 614
 615         return xml_with_declaration;
 616 }
 617
 618 struct _xmlnode_parser_data {
 619         PurpleXmlNode *current;
 620         gboolean error;
 621 };
 622
 623 static void
 624 purple_xmlnode_parser_element_start_libxml(void *user_data,
 625                                    const xmlChar *element_name, const xmlChar *prefix, const xmlChar *xmlns,
 626                                    int nb_namespaces, const xmlChar **namespaces,
 627                                    int nb_attributes, int nb_defaulted, const xmlChar **attributes)
 628 {
 629         struct _xmlnode_parser_data *xpd = user_data;
 630         PurpleXmlNode *node;
 631         int i, j;
 632
 633         if(!element_name || xpd->error) {
 634                 return;
 635         } else {
 636                 if(xpd->current)
 637                         node = purple_xmlnode_new_child(xpd->current, (const char*) element_name);
 638                 else
 639                         node = purple_xmlnode_new((const char *) element_name);
 640
 641                 purple_xmlnode_set_namespace(node, (const char *) xmlns);
 642                 purple_xmlnode_set_prefix(node, (const char *)prefix);
 643
 644                 if (nb_namespaces != 0) {
 645                         node->namespace_map = g_hash_table_new_full(
 646                                 g_str_hash, g_str_equal, g_free, g_free);
 647
 648                         for (i = 0, j = 0; i < nb_namespaces; i++, j += 2) {
 649                                 const char *key = (const char *)namespaces[j];
 650                                 const char *val = (const char *)namespaces[j + 1];
 651                                 g_hash_table_insert(node->namespace_map,
 652                                         g_strdup(key ? key : ""), g_strdup(val ? val : ""));
 653                         }
 654                 }
 655
 656                 for(i=0; i < nb_attributes * 5; i+=5) {
 657                         const char *name = (const char *)attributes[i];
 658                         const char *prefix = (const char *)attributes[i+1];
 659                         char *txt;
 660                         int attrib_len = attributes[i+4] - attributes[i+3];
 661                         char *attrib = g_strndup((const char *)attributes[i+3], attrib_len);
 662                         txt = attrib;
 663                         attrib = purple_unescape_text(txt);
 664                         g_free(txt);
 665                         purple_xmlnode_set_attrib_full(node, name, NULL, prefix, attrib);
 666                         g_free(attrib);
 667                 }
 668
 669                 xpd->current = node;
 670         }
 671 }
 672
 673 static void
 674 purple_xmlnode_parser_element_end_libxml(void *user_data, const xmlChar *element_name,
 675                                  const xmlChar *prefix, const xmlChar *xmlns)
 676 {
 677         struct _xmlnode_parser_data *xpd = user_data;
 678
 679         if(!element_name || !xpd->current || xpd->error)
 680                 return;
 681
 682         if(xpd->current->parent) {
 683                 if(!xmlStrcmp((xmlChar*) xpd->current->name, element_name))
 684                         xpd->current = xpd->current->parent;
 685         }
 686 }
 687
 688 static void
 689 purple_xmlnode_parser_element_text_libxml(void *user_data, const xmlChar *text, int text_len)
 690 {
 691         struct _xmlnode_parser_data *xpd = user_data;
 692
 693         if(!xpd->current || xpd->error)
 694                 return;
 695
 696         if(!text || !text_len)
 697                 return;
 698
 699         purple_xmlnode_insert_data(xpd->current, (const char*) text, text_len);
 700 }
 701
 702 static void
 703 purple_xmlnode_parser_error_libxml(void *user_data, const char *msg, ...)
 704 {
 705         struct _xmlnode_parser_data *xpd = user_data;
 706         char errmsg[2048];
 707         va_list args;
 708
 709         xpd->error = TRUE;
 710
 711         va_start(args, msg);
 712         vsnprintf(errmsg, sizeof(errmsg), msg, args);
 713         va_end(args);
 714
 715         purple_debug_error("xmlnode", "Error parsing xml file: %s", errmsg);
 716 }
 717
 718 static void
 719 purple_xmlnode_parser_structural_error_libxml(void *user_data, xmlErrorPtr error)
 720 {
 721         struct _xmlnode_parser_data *xpd = user_data;
 722
 723         if (error && (error->level == XML_ERR_ERROR ||
 724                       error->level == XML_ERR_FATAL)) {
 725                 xpd->error = TRUE;
 726                 purple_debug_error("xmlnode", "XML parser error for PurpleXmlNode %p: "
 727                                    "Domain %i, code %i, level %i: %s",
 728                                    user_data, error->domain, error->code, error->level,
 729                                    error->message ? error->message : "(null)\n");
 730         } else if (error)
 731                 purple_debug_warning("xmlnode", "XML parser error for PurpleXmlNode %p: "
 732                                      "Domain %i, code %i, level %i: %s",
 733                                      user_data, error->domain, error->code, error->level,
 734                                      error->message ? error->message : "(null)\n");
 735         else
 736                 purple_debug_warning("xmlnode", "XML parser error for PurpleXmlNode %p\n",
 737                                      user_data);
 738 }
 739
 740 static xmlSAXHandler purple_xmlnode_parser_libxml = {
 741         NULL, /* internalSubset */
 742         NULL, /* isStandalone */
 743         NULL, /* hasInternalSubset */
 744         NULL, /* hasExternalSubset */
 745         NULL, /* resolveEntity */
 746         NULL, /* getEntity */
 747         NULL, /* entityDecl */
 748         NULL, /* notationDecl */
 749         NULL, /* attributeDecl */
 750         NULL, /* elementDecl */
 751         NULL, /* unparsedEntityDecl */
 752         NULL, /* setDocumentLocator */
 753         NULL, /* startDocument */
 754         NULL, /* endDocument */
 755         NULL, /* startElement */
 756         NULL, /* endElement */
 757         NULL, /* reference */
 758         purple_xmlnode_parser_element_text_libxml, /* characters */
 759         NULL, /* ignorableWhitespace */
 760         NULL, /* processingInstruction */
 761         NULL, /* comment */
 762         NULL, /* warning */
 763         purple_xmlnode_parser_error_libxml, /* error */
 764         NULL, /* fatalError */
 765         NULL, /* getParameterEntity */
 766         NULL, /* cdataBlock */
 767         NULL, /* externalSubset */
 768         XML_SAX2_MAGIC, /* initialized */
 769         NULL, /* _private */
 770         purple_xmlnode_parser_element_start_libxml, /* startElementNs */
 771         purple_xmlnode_parser_element_end_libxml,   /* endElementNs   */
 772         purple_xmlnode_parser_structural_error_libxml, /* serror */
 773 };
 774
 775 PurpleXmlNode *
 776 purple_xmlnode_from_str(const char *str, gssize size)
 777 {
 778         struct _xmlnode_parser_data *xpd;
 779         PurpleXmlNode *ret;
 780         gsize real_size;
 781
 782         g_return_val_if_fail(str != NULL, NULL);
 783
 784         real_size = size < 0 ? strlen(str) : (gsize)size;
 785         xpd = g_new0(struct _xmlnode_parser_data, 1);
 786
 787         if (xmlSAXUserParseMemory(&purple_xmlnode_parser_libxml, xpd, str, real_size) < 0) {
 788                 while(xpd->current && xpd->current->parent)
 789                         xpd->current = xpd->current->parent;
 790                 if(xpd->current)
 791                         purple_xmlnode_free(xpd->current);
 792                 xpd->current = NULL;
 793         }
 794         ret = xpd->current;
 795         if (xpd->error) {
 796                 ret = NULL;
 797                 if (xpd->current)
 798                         purple_xmlnode_free(xpd->current);
 799         }
 800
 801         g_free(xpd);
 802         return ret;
 803 }
 804
 805 PurpleXmlNode *
 806 purple_xmlnode_from_file(const char *dir, const char *filename, const char *description, const char *process)
 807 {
 808         gchar *filename_full;
 809         GError *error = NULL;
 810         gchar *contents = NULL;
 811         gsize length;
 812         PurpleXmlNode *node = NULL;
 813
 814         g_return_val_if_fail(dir != NULL, NULL);
 815
 816         purple_debug_misc(process, "Reading file %s from directory %s\n",
 817                                         filename, dir);
 818
 819         filename_full = g_build_filename(dir, filename, NULL);
 820
 821         if (!g_file_test(filename_full, G_FILE_TEST_EXISTS))
 822         {
 823                 purple_debug_info(process, "File %s does not exist (this is not "
 824                                                 "necessarily an error)\n", filename_full);
 825                 g_free(filename_full);
 826                 return NULL;
 827         }
 828
 829         if (!g_file_get_contents(filename_full, &contents, &length, &error))
 830         {
 831                 purple_debug_error(process, "Error reading file %s: %s\n",
 832                                                  filename_full, error->message);
 833                 g_error_free(error);
 834         }
 835
 836         if ((contents != NULL) && (length > 0))
 837         {
 838                 node = purple_xmlnode_from_str(contents, length);
 839
 840                 /* If we were unable to parse the file then save its contents to a backup file */
 841                 if (node == NULL)
 842                 {
 843                         gchar *filename_temp, *filename_temp_full;
 844
 845                         filename_temp = g_strdup_printf("%s~", filename);
 846                         filename_temp_full = g_build_filename(dir, filename_temp, NULL);
 847
 848                         purple_debug_error("util", "Error parsing file %s.  Renaming old "
 849                                                          "file to %s\n", filename_full, filename_temp);
 850                         purple_util_write_data_to_file_absolute(filename_temp_full, contents, length);
 851
 852                         g_free(filename_temp_full);
 853                         g_free(filename_temp);
 854                 }
 855
 856                 g_free(contents);
 857         }
 858
 859         /* If we could not parse the file then show the user an error message */
 860         if (node == NULL)
 861         {
 862                 gchar *title, *msg;
 863                 title = g_strdup_printf(_("Error Reading %s"), filename);
 864                 msg = g_strdup_printf(_("An error was encountered reading your "
 865                                         "%s.  The file has not been loaded, and the old file "
 866                                         "has been renamed to %s~."), description, filename_full);
 867                 purple_notify_error(NULL, NULL, title, msg, NULL);
 868                 g_free(title);
 869                 g_free(msg);
 870         }
 871
 872         g_free(filename_full);
 873
 874         return node;
 875 }
 876
 877 static void
 878 purple_xmlnode_copy_foreach_ns(gpointer key, gpointer value, gpointer user_data)
 879 {
 880         GHashTable *ret = (GHashTable *)user_data;
 881         g_hash_table_insert(ret, g_strdup(key), g_strdup(value));
 882 }
 883
 884 PurpleXmlNode *
 885 purple_xmlnode_copy(const PurpleXmlNode *src)
 886 {
 887         PurpleXmlNode *ret;
 888         PurpleXmlNode *child;
 889         PurpleXmlNode *sibling = NULL;
 890
 891         g_return_val_if_fail(src != NULL, NULL);
 892
 893         ret = new_node(src->name, src->type);
 894         ret->xmlns = g_strdup(src->xmlns);
 895         if (src->data) {
 896                 if (src->data_sz) {
 897                         ret->data = g_memdup(src->data, src->data_sz);
 898                         ret->data_sz = src->data_sz;
 899                 } else {
 900                         ret->data = g_strdup(src->data);
 901                 }
 902         }
 903         ret->prefix = g_strdup(src->prefix);
 904         if (src->namespace_map) {
 905                 ret->namespace_map = g_hash_table_new_full(g_str_hash, g_str_equal,
 906                                                            g_free, g_free);
 907                 g_hash_table_foreach(src->namespace_map, purple_xmlnode_copy_foreach_ns, ret->namespace_map);
 908         }
 909
 910         for (child = src->child; child; child = child->next) {
 911                 if (sibling) {
 912                         sibling->next = purple_xmlnode_copy(child);
 913                         sibling = sibling->next;
 914                 } else {
 915                         ret->child = sibling = purple_xmlnode_copy(child);
 916                 }
 917                 sibling->parent = ret;
 918         }
 919
 920         ret->lastchild = sibling;
 921
 922         return ret;
 923 }
 924
 925 PurpleXmlNode *
 926 purple_xmlnode_get_next_twin(PurpleXmlNode *node)
 927 {
 928         PurpleXmlNode *sibling;
 929         const char *ns = purple_xmlnode_get_namespace(node);
 930
 931         g_return_val_if_fail(node != NULL, NULL);
 932         g_return_val_if_fail(node->type == PURPLE_XMLNODE_TYPE_TAG, NULL);
 933
 934         for(sibling = node->next; sibling; sibling = sibling->next) {
 935                 /* XXX: Is it correct to ignore the namespace for the match if none was specified? */
 936                 const char *xmlns = NULL;
 937                 if(ns)
 938                         xmlns = purple_xmlnode_get_namespace(sibling);
 939
 940                 if(sibling->type == PURPLE_XMLNODE_TYPE_TAG && purple_strequal(node->name, sibling->name) &&
 941                                 purple_strequal(ns, xmlns))
 942                         return sibling;
 943         }
 944
 945         return NULL;
 946 }
 947
 948 GType
 949 purple_xmlnode_get_type(void)
 950 {
 951         static GType type = 0;
 952
 953         if (type == 0) {
 954                 type = g_boxed_type_register_static("PurpleXmlNode",
 955                                 (GBoxedCopyFunc)purple_xmlnode_copy,
 956                                 (GBoxedFreeFunc)purple_xmlnode_free);
 957         }
 958
 959         return type;
 960 }