atom/content.c

   1 /*
   2  *  Copyright (C) 2009  Thadeu Lima de Souza Cascardo <cascardo@holoscopio.com>
   3  *
   4  *  This program is free software; you can redistribute it and/or modify
   5  *  it under the terms of the GNU General Public License as published by
   6  *  the Free Software Foundation; either version 2 of the License, or
   7  *  (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  *  GNU General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License along
  15  *  with this program; if not, write to the Free Software Foundation, Inc.,
  16  *  51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
  17  */
  18
  19
  20 #include <atompub/content.h>
  21 #include <atompub/content-xml.h>
  22
  23 #include <glib.h>
  24 #include <libxml/tree.h>
  25 #include <string.h>
  26
  27 struct _atom_content
  28 {
  29   char *type;
  30   char *src;
  31   char *content;
  32   size_t content_len;
  33   xmlNodePtr xmlcontent;
  34 };
  35
  36 AtomContent *
  37 atom_content_new (char *type, char *buffer, size_t len)
  38 {
  39   AtomContent *content;
  40   content = g_slice_new0 (AtomContent);
  41   content->type = g_strdup (type);
  42   content->content = g_malloc (len);
  43   memcpy (content->content, buffer, len);
  44   content->content_len = len;
  45   return content;
  46 }
  47
  48 AtomContent *
  49 atom_content_new_src (char *type, char *src)
  50 {
  51   AtomContent *content;
  52   content = g_slice_new0 (AtomContent);
  53   content->type = g_strdup (type);
  54   content->src = g_strdup (src);
  55   return content;
  56 }
  57
  58 AtomContent *
  59 atom_content_new_from_xmlnode (xmlNodePtr root)
  60 {
  61   AtomContent *content;
  62   xmlNodePtr child;
  63   if (xmlStrcmp (root->name, "content"))
  64     {
  65       return NULL;
  66     }
  67   content = g_slice_new0 (AtomContent);
  68   if ((content->type = xmlGetProp (root, "type")) == NULL)
  69     {
  70       g_slice_free (AtomContent, content);
  71       return NULL;
  72     }
  73   content->src = xmlGetProp (root, "src");
  74   if (content->src == NULL)
  75     {
  76       /* libxml2 does not help a lot here. We must decide between a
  77          XML child or a content child. Using the type attribute might
  78          be a good idead. Let's just ask that the current method
  79          works. */
  80       if (root->children && root->children->type == XML_ELEMENT_NODE)
  81         {
  82           content->xmlcontent = xmlCopyNodeList (root->children);
  83         }
  84       else
  85         {
  86           content->content = xmlNodeGetContent (root);
  87           content->content_len = xmlStrlen (content->content);
  88         }
  89     }
  90   return content;
  91 }
  92
  93 AtomContent *
  94 atom_content_new_data_len (char * buffer, size_t len)
  95 {
  96   AtomContent *content;
  97   xmlDocPtr doc;
  98   xmlNodePtr root;
  99   doc = xmlReadMemory (buffer, len, NULL, NULL,
 100                        XML_PARSE_RECOVER | XML_PARSE_NOERROR);
 101   if (doc == NULL || (root = xmlDocGetRootElement (doc)) == NULL)
 102     return NULL;
 103   content = atom_content_new_from_xmlnode (root);
 104   xmlFreeDoc (doc);
 105   return content;
 106 }
 107
 108 void
 109 atom_content_delete (AtomContent *content)
 110 {
 111   if (content->type)
 112     g_free (content->type);
 113   if (content->src)
 114     g_free (content->src);
 115   if (content->content)
 116     g_free (content->content);
 117   if (content->xmlcontent)
 118     xmlFreeNode (content->xmlcontent);
 119   g_slice_free (AtomContent, content);
 120 }
 121
 122 char *
 123 atom_content_type (AtomContent *content)
 124 {
 125   return content->type;
 126 }
 127
 128 void
 129 atom_content_type_set (AtomContent *content, char *type)
 130 {
 131   if (content->type)
 132     g_free (content->type);
 133   content->type = g_strdup (type);
 134 }
 135
 136 char *
 137 atom_content_src (AtomContent *content)
 138 {
 139   return content->src;
 140 }
 141
 142 void
 143 atom_content_src_set (AtomContent *content, char *src)
 144 {
 145   if (content->src)
 146     g_free (content->src);
 147   if (content->content)
 148     {
 149       g_free (content->content);
 150       content->content = NULL;
 151     }
 152   if (content->xmlcontent)
 153     {
 154       xmlFreeNode (content->xmlcontent);
 155       content->xmlcontent = NULL;
 156     }
 157   content->src = g_strdup (src);
 158 }
 159
 160 void
 161 atom_content_content (AtomContent *content, char **buffer, size_t *len)
 162 {
 163   if (content->content == NULL)
 164     {
 165       if (buffer)
 166         *buffer = NULL;
 167       if (len)
 168         *len = 0;
 169     }
 170   else
 171     {
 172       if (buffer)
 173         {
 174           *buffer = g_malloc (content->content_len);
 175           memcpy (*buffer, content->content, content->content_len);
 176         }
 177       if (len)
 178         *len = content->content_len;
 179     }
 180 }
 181
 182 void
 183 atom_content_content_set (AtomContent *content, char *buffer, size_t len)
 184 {
 185   if (content->content)
 186     g_free (content->content);
 187   if (content->src)
 188     {
 189       g_free (content->src);
 190       content->src = NULL;
 191     }
 192   if (content->xmlcontent)
 193     {
 194       xmlFreeNode (content->xmlcontent);
 195       content->xmlcontent = NULL;
 196     }
 197   content->content = g_malloc (len);
 198   memcpy (content->content, buffer, len);
 199   content->content_len = len;
 200 }
 201
 202 void
 203 atom_content_string (AtomContent *content, char **buffer, size_t *len)
 204 {
 205   xmlDocPtr doc;
 206   xmlNodePtr node;
 207   node = atom_content_to_xmlnode (content);
 208   if (node == NULL)
 209     {
 210       if (buffer)
 211         *buffer = NULL;
 212       if (len)
 213         *len = 0;
 214       return;
 215     }
 216   doc = xmlNewDoc ("1.0");
 217   xmlDocSetRootElement (doc, node);
 218   xmlDocDumpMemory (doc, buffer, len);
 219   xmlFreeDoc (doc);
 220 }
 221
 222 AtomContent *
 223 atom_content_new_xmlnode (char *type, xmlNodePtr node)
 224 {
 225   AtomContent *content;
 226   content = g_slice_new0 (AtomContent);
 227   content->type = g_strdup (type);
 228   content->xmlcontent = xmlCopyNodeList (node);
 229   return content;
 230 }
 231
 232 xmlNodePtr
 233 atom_content_to_xmlnode (AtomContent *content)
 234 {
 235   xmlNodePtr node;
 236   node = xmlNewNode (NULL, "content");
 237   xmlNewProp (node, "type", content->type);
 238   if (content->src)
 239     {
 240       xmlNewProp (node, "src", content->src);
 241       return node;
 242     }
 243   else if (content->content)
 244     {
 245       xmlNodeSetContentLen (node, content->content, content->content_len);
 246       return node;
 247     }
 248   else if (content->xmlcontent)
 249     {
 250       xmlAddChild (node, xmlCopyNodeList (content->xmlcontent));
 251       return node;
 252     }
 253   return node;
 254 }
 255
 256 xmlNodePtr
 257 atom_content_xmlcontent (AtomContent *content)
 258 {
 259   return content->xmlcontent;
 260 }
 261
 262 void
 263 atom_content_xmlcontent_set (AtomContent *content, xmlNodePtr node)
 264 {
 265   if (content->xmlcontent)
 266     xmlFreeNode (content->xmlcontent);
 267   if (content->content)
 268     {
 269       g_free (content->content);
 270       content->content = NULL;
 271     }
 272   if (content->src)
 273     {
 274       g_free (content->src);
 275       content->src = NULL;
 276     }
 277   content->xmlcontent = xmlCopyNodeList (node);
 278 }