8dfbdd06b635e9d62bf56e0b75a7871d825e33af
[cascardo/atompub.git] / 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     g_free (content->content);
143   if (content->xmlcontent)
144     xmlFreeNode (content->xmlcontent);
145   content->src = g_strdup (src);
146 }
147
148 void
149 atom_content_content (AtomContent *content, char **buffer, size_t *len)
150 {
151   if (content->content == NULL)
152     {
153       if (buffer)
154         *buffer = NULL;
155       if (len)
156         *len = 0;
157     }
158   else
159     {
160       if (buffer)
161         {
162           *buffer = g_malloc (content->content_len);
163           memcpy (*buffer, content->content, content->content_len);
164         }
165       if (len)
166         *len = content->content_len;
167     }
168 }
169
170 void
171 atom_content_content_set (AtomContent *content, char *buffer, size_t len)
172 {
173   if (content->content)
174     g_free (content->content);
175   if (content->src)
176     g_free (content->src);
177   if (content->xmlcontent)
178     xmlFreeNode (content->xmlcontent);
179   content->content = g_malloc (len);
180   memcpy (content->content, buffer, len);
181 }
182
183 void
184 atom_content_string (AtomContent *content, char **buffer, size_t *len)
185 {
186   xmlDocPtr doc;
187   xmlNodePtr node;
188   node = atom_content_to_xmlnode (content);
189   if (node == NULL)
190     {
191       if (buffer)
192         *buffer = NULL;
193       if (len)
194         *len = 0;
195       return;
196     }
197   doc = xmlNewDoc ("1.0");
198   xmlDocSetRootElement (doc, node);
199   xmlDocDumpMemory (doc, buffer, len);
200   xmlFreeDoc (doc);
201 }
202
203 AtomContent *
204 atom_content_new_xmlnode (char *type, xmlNodePtr node)
205 {
206   AtomContent *content;
207   content = g_slice_new0 (AtomContent);
208   content->type = g_strdup (type);
209   content->xmlcontent = xmlCopyNodeList (node);
210   return content;
211 }
212
213 xmlNodePtr
214 atom_content_to_xmlnode (AtomContent *content)
215 {
216   xmlNodePtr node;
217   node = xmlNewNode (NULL, "content");
218   xmlNewProp (node, "type", content->type);
219   if (content->src)
220     {
221       xmlNewProp (node, "src", content->src);
222       return node;
223     }
224   else if (content->content)
225     {
226       xmlNodeSetContentLen (node, content->content, content->content_len);
227       return node;
228     }
229   else if (content->xmlcontent)
230     {
231       xmlAddChild (node, xmlCopyNodeList (content->xmlcontent));
232       return node;
233     }
234   return node;
235 }
236
237 xmlNodePtr
238 atom_content_content_xmlnode (AtomContent *content)
239 {
240   return content->xmlcontent;
241 }
242
243 void
244 atom_content_content_set_xmlnode (AtomContent *content, xmlNodePtr node)
245 {
246   if (content->xmlcontent)
247     xmlFreeNode (content->xmlcontent);
248   if (content->content)
249     g_free (content->content);
250   if (content->src)
251     g_free (content->src);
252   content->xmlcontent = xmlCopyNodeList (node);
253 }