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_data_len (char *buffer, size_t len)
  60 {
  61   AtomContent *content;
  62   xmlDocPtr doc;
  63   xmlNodePtr root;
  64   xmlNodePtr child;
  65   doc = xmlReadMemory (buffer, len, NULL, NULL,
  66                        XML_PARSE_RECOVER | XML_PARSE_NOERROR);
  67   if (doc == NULL || (root = xmlDocGetRootElement (doc)) == NULL)
  68     return NULL;
  69   if (xmlStrcmp (root->name, "content"))
  70     {
  71       xmlFreeDoc (doc);
  72       return NULL;
  73     }
  74   content = g_slice_new0 (AtomContent);
  75   if ((content->type = xmlGetProp (root, "type")) == NULL)
  76     {
  77       g_slice_free (AtomContent, content);
  78       xmlFreeDoc (doc);
  79       return NULL;
  80     }
  81   content->src = xmlGetProp (root, "src");
  82   if (content->src == NULL)
  83     {
  84       /* libxml2 does not help a lot here. We must decide between a
  85          XML child or a content child. Using the type attribute might
  86          be a good idead. Let's just ask that the current method
  87          works. */
  88       if (root->children && root->children->type == XML_ELEMENT_NODE)
  89         {
  90           content->xmlcontent = xmlCopyNodeList (root->children);
  91         }
  92       else
  93         {
  94           content->content = xmlNodeGetContent (root);
  95           content->content_len = xmlStrlen (content->content);
  96         }
  97     }
  98   xmlFreeDoc (doc);
  99   return content;
 100 }
 101
 102 void
 103 atom_content_delete (AtomContent *content)
 104 {
 105   if (content->type)
 106     g_free (content->type);
 107   if (content->src)
 108     g_free (content->src);
 109   if (content->content)
 110     g_free (content->content);
 111   if (content->xmlcontent)
 112     xmlFreeNode (content->xmlcontent);
 113   g_slice_free (AtomContent, content);
 114 }
 115
 116 char *
 117 atom_content_type (AtomContent *content)
 118 {
 119   return content->type;
 120 }
 121
 122 void
 123 atom_content_type_set (AtomContent *content, char *type)
 124 {
 125   if (content->type)
 126     g_free (content->type);
 127   content->type = g_strdup (type);
 128 }
 129
 130 char *
 131 atom_content_src (AtomContent *content)
 132 {
 133   return content->src;
 134 }
 135
 136 void
 137 atom_content_src_set (AtomContent *content, char *src)
 138 {
 139   if (content->src)
 140     g_free (content->src);
 141   if (content->content)
 142     {
 143       g_free (content->content);
 144       content->content = NULL;
 145     }
 146   if (content->xmlcontent)
 147     {
 148       xmlFreeNode (content->xmlcontent);
 149       content->xmlcontent = NULL;
 150     }
 151   content->src = g_strdup (src);
 152 }
 153
 154 void
 155 atom_content_content (AtomContent *content, char **buffer, size_t *len)
 156 {
 157   if (content->content == NULL)
 158     {
 159       if (buffer)
 160         *buffer = NULL;
 161       if (len)
 162         *len = 0;
 163     }
 164   else
 165     {
 166       if (buffer)
 167         {
 168           *buffer = g_malloc (content->content_len);
 169           memcpy (*buffer, content->content, content->content_len);
 170         }
 171       if (len)
 172         *len = content->content_len;
 173     }
 174 }
 175
 176 void
 177 atom_content_content_set (AtomContent *content, char *buffer, size_t len)
 178 {
 179   if (content->content)
 180     g_free (content->content);
 181   if (content->src)
 182     {
 183       g_free (content->src);
 184       content->src = NULL;
 185     }
 186   if (content->xmlcontent)
 187     {
 188       xmlFreeNode (content->xmlcontent);
 189       content->xmlcontent = NULL;
 190     }
 191   content->content = g_malloc (len);
 192   memcpy (content->content, buffer, len);
 193   content->content_len = len;
 194 }
 195
 196 void
 197 atom_content_string (AtomContent *content, char **buffer, size_t *len)
 198 {
 199   xmlDocPtr doc;
 200   xmlNodePtr node;
 201   node = atom_content_to_xmlnode (content);
 202   if (node == NULL)
 203     {
 204       if (buffer)
 205         *buffer = NULL;
 206       if (len)
 207         *len = 0;
 208       return;
 209     }
 210   doc = xmlNewDoc ("1.0");
 211   xmlDocSetRootElement (doc, node);
 212   xmlDocDumpMemory (doc, buffer, len);
 213   xmlFreeDoc (doc);
 214 }
 215
 216 AtomContent *
 217 atom_content_new_xmlnode (char *type, xmlNodePtr node)
 218 {
 219   AtomContent *content;
 220   content = g_slice_new0 (AtomContent);
 221   content->type = g_strdup (type);
 222   content->xmlcontent = xmlCopyNodeList (node);
 223   return content;
 224 }
 225
 226 xmlNodePtr
 227 atom_content_to_xmlnode (AtomContent *content)
 228 {
 229   xmlNodePtr node;
 230   node = xmlNewNode (NULL, "content");
 231   xmlNewProp (node, "type", content->type);
 232   if (content->src)
 233     {
 234       xmlNewProp (node, "src", content->src);
 235       return node;
 236     }
 237   else if (content->content)
 238     {
 239       xmlNodeSetContentLen (node, content->content, content->content_len);
 240       return node;
 241     }
 242   else if (content->xmlcontent)
 243     {
 244       xmlAddChild (node, xmlCopyNodeList (content->xmlcontent));
 245       return node;
 246     }
 247   return node;
 248 }
 249
 250 xmlNodePtr
 251 atom_content_content_xmlnode (AtomContent *content)
 252 {
 253   return content->xmlcontent;
 254 }
 255
 256 void
 257 atom_content_content_set_xmlnode (AtomContent *content, xmlNodePtr node)
 258 {
 259   if (content->xmlcontent)
 260     xmlFreeNode (content->xmlcontent);
 261   if (content->content)
 262     {
 263       g_free (content->content);
 264       content->content = NULL;
 265     }
 266   if (content->src)
 267     {
 268       g_free (content->src);
 269       content->src = NULL;
 270     }
 271   content->xmlcontent = xmlCopyNodeList (node);
 272 }