main/xml.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 2008, Eliel C. Sardanons (LU1ALY) <eliels@gmail.com>
   5  *
   6  * See http://www.asterisk.org for more information about
   7  * the Asterisk project. Please do not directly contact
   8  * any of the maintainers of this project for assistance;
   9  * the project provides a web site, mailing lists and IRC
  10  * channels for your use.
  11  *
  12  * This program is free software, distributed under the terms of
  13  * the GNU General Public License Version 2. See the LICENSE file
  14  * at the top of the source tree.
  15  */
  16
  17 /*! \file
  18  *
  19  * \brief XML abstraction layer
  20  *
  21  * \author Eliel C. Sardanons (LU1ALY) <eliels@gmail.com>
  22  */
  23
  24 #include "asterisk.h"
  25 #include "asterisk/xml.h"
  26 #include "asterisk/logger.h"
  27
  28 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  29
  30 #if defined(HAVE_LIBXML2)
  31 #include <libxml/parser.h>
  32 #include <libxml/tree.h>
  33 #include <libxml/xinclude.h>
  34 /* libxml2 ast_xml implementation. */
  35
  36
  37 int ast_xml_init(void)
  38 {
  39         LIBXML_TEST_VERSION
  40
  41         return 0;
  42 }
  43
  44 int ast_xml_finish(void)
  45 {
  46         xmlCleanupParser();
  47
  48         return 0;
  49 }
  50
  51 struct ast_xml_doc *ast_xml_open(char *filename)
  52 {
  53         xmlDoc *doc;
  54
  55         if (!filename) {
  56                 return NULL;
  57         }
  58
  59         doc = xmlReadFile(filename, NULL, XML_PARSE_RECOVER);
  60         if (doc) {
  61                 /* process xinclude elements. */
  62                 if (xmlXIncludeProcess(doc) < 0) {
  63                         xmlFreeDoc(doc);
  64                         return NULL;
  65                 }
  66         }
  67
  68         return (struct ast_xml_doc *) doc;
  69 }
  70
  71 struct ast_xml_doc *ast_xml_new(void)
  72 {
  73         xmlDoc *doc;
  74
  75         doc = xmlNewDoc((const xmlChar *) "1.0");
  76         return (struct ast_xml_doc *) doc;
  77 }
  78
  79 struct ast_xml_node *ast_xml_new_node(const char *name)
  80 {
  81         xmlNode *node;
  82         if (!name) {
  83                 return NULL;
  84         }
  85
  86         node = xmlNewNode(NULL, (const xmlChar *) name);
  87
  88         return (struct ast_xml_node *) node;
  89 }
  90
  91 struct ast_xml_node *ast_xml_new_child(struct ast_xml_node *parent, const char *child_name)
  92 {
  93         xmlNode *child;
  94
  95         if (!parent || !child_name) {
  96                 return NULL;
  97         }
  98
  99         child = xmlNewChild((xmlNode *) parent, NULL, (const xmlChar *) child_name, NULL);
 100         return (struct ast_xml_node *) child;
 101 }
 102
 103 struct ast_xml_node *ast_xml_add_child(struct ast_xml_node *parent, struct ast_xml_node *child)
 104 {
 105         if (!parent || !child) {
 106                 return NULL;
 107         }
 108         return (struct ast_xml_node *) xmlAddChild((xmlNode *) parent, (xmlNode *) child);
 109 }
 110
 111 struct ast_xml_doc *ast_xml_read_memory(char *buffer, size_t size)
 112 {
 113         xmlDoc *doc;
 114
 115         if (!buffer) {
 116                 return NULL;
 117         }
 118
 119         if (!(doc = xmlParseMemory(buffer, (int) size))) {
 120                 /* process xinclude elements. */
 121                 if (xmlXIncludeProcess(doc) < 0) {
 122                         xmlFreeDoc(doc);
 123                         return NULL;
 124                 }
 125         }
 126
 127         return (struct ast_xml_doc *) doc;
 128 }
 129
 130 void ast_xml_close(struct ast_xml_doc *doc)
 131 {
 132         if (!doc) {
 133                 return;
 134         }
 135
 136         xmlFreeDoc((xmlDoc *) doc);
 137         doc = NULL;
 138 }
 139
 140 void ast_xml_set_root(struct ast_xml_doc *doc, struct ast_xml_node *node)
 141 {
 142         if (!doc || !node) {
 143                 return;
 144         }
 145
 146         xmlDocSetRootElement((xmlDoc *) doc, (xmlNode *) node);
 147 }
 148
 149 struct ast_xml_node *ast_xml_get_root(struct ast_xml_doc *doc)
 150 {
 151         xmlNode *root_node;
 152
 153         if (!doc) {
 154                 return NULL;
 155         }
 156
 157         root_node = xmlDocGetRootElement((xmlDoc *) doc);
 158
 159         return (struct ast_xml_node *) root_node;
 160 }
 161
 162 void ast_xml_free_node(struct ast_xml_node *node)
 163 {
 164         if (!node) {
 165                 return;
 166         }
 167
 168         xmlFreeNode((xmlNode *) node);
 169         node = NULL;
 170 }
 171
 172 void ast_xml_free_attr(const char *attribute)
 173 {
 174         if (attribute) {
 175                 xmlFree((char *) attribute);
 176         }
 177 }
 178
 179 void ast_xml_free_text(const char *text)
 180 {
 181         if (text) {
 182                 xmlFree((char *) text);
 183         }
 184 }
 185
 186 const char *ast_xml_get_attribute(struct ast_xml_node *node, const char *attrname)
 187 {
 188         xmlChar *attrvalue;
 189
 190         if (!node) {
 191                 return NULL;
 192         }
 193
 194         if (!attrname) {
 195                 return NULL;
 196         }
 197
 198         attrvalue = xmlGetProp((xmlNode *) node, (xmlChar *) attrname);
 199
 200         return (const char *) attrvalue;
 201 }
 202
 203 int ast_xml_set_attribute(struct ast_xml_node *node, const char *name, const char *value)
 204 {
 205         if (!name || !value) {
 206                 return -1;
 207         }
 208
 209         if (!xmlSetProp((xmlNode *) node, (xmlChar *) name, (xmlChar *) value)) {
 210                 return -1;
 211         }
 212
 213         return 0;
 214 }
 215
 216 struct ast_xml_node *ast_xml_find_element(struct ast_xml_node *root_node, const char *name, const char *attrname, const char *attrvalue)
 217 {
 218         struct ast_xml_node *cur;
 219         const char *attr;
 220
 221         if (!root_node) {
 222                 return NULL;
 223         }
 224
 225         for (cur = root_node; cur; cur = ast_xml_node_get_next(cur)) {
 226                 /* Check if the name matchs */
 227                 if (strcmp(ast_xml_node_get_name(cur), name)) {
 228                         continue;
 229                 }
 230                 /* We need to check for a specific attribute name? */
 231                 if (!attrname || !attrvalue) {
 232                         return cur;
 233                 }
 234                 /* Get the attribute, we need to compare it. */
 235                 if ((attr = ast_xml_get_attribute(cur, attrname))) {
 236                         /* does attribute name/value matches? */
 237                         if (!strcmp(attr, attrvalue)) {
 238                                 ast_xml_free_attr(attr);
 239                                 return cur;
 240                         }
 241                         ast_xml_free_attr(attr);
 242                 }
 243         }
 244
 245         return NULL;
 246 }
 247
 248 struct ast_xml_doc *ast_xml_get_doc(struct ast_xml_node *node)
 249 {
 250         if (!node) {
 251                 return NULL;
 252         }
 253
 254         return (struct ast_xml_doc *) ((xmlNode *)node)->doc;
 255 }
 256
 257 struct ast_xml_ns *ast_xml_find_namespace(struct ast_xml_doc *doc, struct ast_xml_node *node, const char *ns_name) {
 258         xmlNsPtr ns = xmlSearchNs((xmlDocPtr) doc, (xmlNodePtr) node, (xmlChar *) ns_name);
 259         return (struct ast_xml_ns *) ns;
 260 }
 261
 262 const char *ast_xml_get_ns_href(struct ast_xml_ns *ns)
 263 {
 264         return (const char *) ((xmlNsPtr) ns)->href;
 265 }
 266
 267 const char *ast_xml_get_text(struct ast_xml_node *node)
 268 {
 269         if (!node) {
 270                 return NULL;
 271         }
 272
 273         return (const char *) xmlNodeGetContent((xmlNode *) node);
 274 }
 275
 276 void ast_xml_set_text(struct ast_xml_node *node, const char *content)
 277 {
 278         if (!node || !content) {
 279                 return;
 280         }
 281
 282         xmlNodeSetContent((xmlNode *) node, (const xmlChar *) content);
 283 }
 284
 285 int ast_xml_doc_dump_file(FILE *output, struct ast_xml_doc *doc)
 286 {
 287         return xmlDocDump(output, (xmlDocPtr)doc);
 288 }
 289
 290 const char *ast_xml_node_get_name(struct ast_xml_node *node)
 291 {
 292         return (const char *) ((xmlNode *) node)->name;
 293 }
 294
 295 struct ast_xml_node *ast_xml_node_get_children(struct ast_xml_node *node)
 296 {
 297         return (struct ast_xml_node *) ((xmlNode *) node)->children;
 298 }
 299
 300 struct ast_xml_node *ast_xml_node_get_next(struct ast_xml_node *node)
 301 {
 302         return (struct ast_xml_node *) ((xmlNode *) node)->next;
 303 }
 304
 305 struct ast_xml_node *ast_xml_node_get_prev(struct ast_xml_node *node)
 306 {
 307         return (struct ast_xml_node *) ((xmlNode *) node)->prev;
 308 }
 309
 310 struct ast_xml_node *ast_xml_node_get_parent(struct ast_xml_node *node)
 311 {
 312         return (struct ast_xml_node *) ((xmlNode *) node)->parent;
 313 }
 314
 315 #endif /* defined(HAVE_LIBXML2) */
 316