RSSyl: Allow use of .netrc by libcurl. Bug/enhancement #3309, by Vincent Pelletier
[claws.git] / src / plugins / rssyl / libfeed / parser.c
1 /*
2  * Copyright (C) 2006 Andrej Kacian <andrej@kacian.sk>
3  *
4  * This program is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU General Public License as
6  * published by the Free Software Foundation; either version 2 of the
7  * License, or (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 GNU
12  * General Public License for more details.
13  *
14  * You should have received a copy of the GNU General Public
15  * License along with this program; if not, write to the
16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17  * Boston, MA 02111-1307, USA.
18  */
19
20 #include <glib.h>
21 #include <curl/curl.h>
22 #include <expat.h>
23 #include <string.h>
24 #include <ctype.h>
25 #include <errno.h>
26
27 #include <codeconv.h>
28
29 #include "feed.h"
30
31 #include "parser.h"
32
33 static void _handler_set(XML_Parser parser, guint type)
34 {
35         if( parser == NULL )
36                 return;
37
38         switch(type) {
39                 case FEED_TYPE_RSS_20:
40                         XML_SetElementHandler(parser,
41                                         feed_parser_rss20_start,
42                                         feed_parser_rss20_end);
43                         break;
44
45                 case FEED_TYPE_RDF:
46                         XML_SetElementHandler(parser,
47                                         feed_parser_rdf_start,
48                                         feed_parser_rdf_end);
49                         break;
50
51                 case FEED_TYPE_ATOM_10:
52                         XML_SetElementHandler(parser,
53                                         feed_parser_atom10_start,
54                                         feed_parser_atom10_end);
55                         break;
56         }
57 }
58
59 static void _elparse_start_chooser(void *data,
60                 const gchar *el, const gchar **attr)
61 {
62         FeedParserCtx *ctx = (FeedParserCtx *)data;
63         guint feedtype = FEED_TYPE_NONE;
64         gchar *version;
65
66         if( ctx->depth == 0 ) {
67
68                 /* RSS 2.0 detected */
69                 if( !strcmp(el, "rss") ) {
70                         feedtype = FEED_TYPE_RSS_20;
71                 } else if( !strcmp(el, "rdf:RDF") ) {
72                         feedtype = FEED_TYPE_RDF;
73                 } else if( !strcmp(el, "feed") ) {
74
75                         /* ATOM feed detected, let's check version */
76                         version = feed_parser_get_attribute_value(attr, "xmlns");
77                         if( !strcmp(version, "http://www.w3.org/2005/Atom") ||
78                                         !strcmp(version, "https://www.w3.org/2005/Atom") )
79                                 feedtype = FEED_TYPE_ATOM_10;
80                         else
81                                 feedtype = FEED_TYPE_ATOM_03;
82                 }
83         }
84
85         _handler_set(ctx->parser, feedtype);
86
87         ctx->depth++;
88 }
89
90 static void _elparse_end_dummy(void *data, const gchar *el)
91 {
92         FeedParserCtx *ctx = (FeedParserCtx *)data;
93
94         if( ctx->str != NULL ) {
95                 g_string_free(ctx->str, TRUE);
96                 ctx->str = NULL;
97         }
98
99         ctx->depth--;
100 }
101
102 void libfeed_expat_chparse(void *data, const gchar *s, gint len)
103 {
104         FeedParserCtx *ctx = (FeedParserCtx *)data;
105         gchar *buf = NULL;
106         gint i, xblank = 1;
107
108         buf = malloc(len+1);
109         strncpy(buf, s, len);
110         buf[len] = '\0';
111
112         /* check if the string is blank, ... */
113         for( i = 0; i < strlen(buf); i++ )
114                 if( !isspace(buf[i]) )
115                         xblank = 0;
116
117         /* ...because we do not want the blanks if we're just starting new GString */
118         if( xblank > 0 && ctx->str == NULL ) {
119                 g_free(buf);
120                 return;
121         }
122
123         if( ctx->str == NULL ) {
124                 ctx->str = g_string_sized_new(len + 1);
125         }
126
127         g_string_append(ctx->str, buf);
128         g_free(buf);
129 }
130
131
132 void feed_parser_set_expat_handlers(FeedParserCtx *ctx)
133 {
134         XML_SetUserData(ctx->parser, (void *)ctx);
135
136         XML_SetElementHandler(ctx->parser,
137                         _elparse_start_chooser,
138                         _elparse_end_dummy);
139
140         XML_SetCharacterDataHandler(ctx->parser,
141                 libfeed_expat_chparse);
142
143         XML_SetUnknownEncodingHandler(ctx->parser, feed_parser_unknown_encoding_handler,
144                         NULL);
145 }
146
147 size_t feed_writefunc(void *ptr, size_t size, size_t nmemb, void *data)
148 {
149         gint len = size * nmemb;
150         FeedParserCtx *ctx = (FeedParserCtx *)data;
151         gint status, err;
152
153         status = XML_Parse(ctx->parser, ptr, len, FALSE);
154
155         if( status == XML_STATUS_ERROR ) {
156                 err = XML_GetErrorCode(ctx->parser);
157                 printf("\nExpat: --- %s\n\n", XML_ErrorString(err));
158         }
159
160         return len;
161 }
162
163 gchar *feed_parser_get_attribute_value(const gchar **attr, const gchar *name)
164 {
165         guint i;
166
167         if( attr == NULL || name == NULL )
168                 return NULL;
169
170         for( i = 0; attr[i] != NULL && attr[i+1] != NULL; i += 2 ) {
171                 if( !strcmp( attr[i], name) )
172                         return (gchar *)attr[i+1];
173         }
174
175         /* We haven't found anything. */
176         return NULL;
177 }
178
179 #define CHARSIZEUTF32   4
180
181 enum {
182         LEP_ICONV_OK,
183         LEP_ICONV_FAILED,
184         LEP_ICONV_ILSEQ,
185         LEP_ICONV_INVAL,
186         LEP_ICONV_UNKNOWN
187 };
188
189 static gint giconv_utf32_char(GIConv cd, const gchar *inbuf, size_t insize,
190                 guint32 *p_value)
191 {
192 #ifdef HAVE_ICONV
193         size_t outsize;
194         guchar outbuf[CHARSIZEUTF32];
195         gchar *outbufp;
196         gint r, errno;
197
198         outsize = sizeof(outbuf);
199         outbufp = (gchar *)outbuf;
200 #ifdef HAVE_ICONV_PROTO_CONST
201         r = g_iconv(cd, (const gchar **)&inbuf, &insize,
202                         &outbufp, &outsize);
203 #else
204         r = g_iconv(cd, (gchar **)&inbuf, &insize,
205                         &outbufp, &outsize);
206 #endif
207         if( r == -1 ) {
208                 g_iconv(cd, 0, 0, 0, 0);
209                 switch(errno) {
210                 case EILSEQ:
211                         return LEP_ICONV_ILSEQ;
212                 case EINVAL:
213                         return LEP_ICONV_INVAL;
214                 default:
215                         return LEP_ICONV_UNKNOWN;
216                 }
217         } else {
218                 guint32 value;
219                 guint i;
220
221                 if( (insize > 0) || (outsize > 0) )
222                         return LEP_ICONV_FAILED;
223
224                 value = 0;
225                 for( i = 0; i < sizeof(outbuf); i++ ) {
226                         value = (value << 8) + outbuf[i];
227                 }
228                 *p_value = value;
229                 return LEP_ICONV_OK;
230         }
231 #else
232         return LEP_ICONV_FAILED;
233 #endif
234 }
235
236 static gint feed_parser_setup_unknown_encoding(const gchar *charset,
237                 XML_Encoding *info)
238 {
239         GIConv cd;
240         gint flag, r;
241         gchar buf[4];
242         guint i, j, k;
243         guint32 value;
244
245         cd = g_iconv_open("UTF-32BE", charset);
246         if( cd == (GIConv) -1 )
247                 return -1;
248
249         flag = 0;
250         for( i = 0; i < 256; i++ ) {
251                 /* first char */
252                 buf[0] = i;
253                 info->map[i] = 0;
254                 r = giconv_utf32_char(cd, buf, 1, &value);
255                 if( r == LEP_ICONV_OK) {
256                         info->map[i] = value;
257                 } else if( r != LEP_ICONV_INVAL ) {
258                 } else {
259                         for( j = 0; j < 256; j++ ) {
260                                 /* second char */
261                                 buf[1] = j;
262                                 r = giconv_utf32_char(cd, buf, 2, &value);
263                                 if( r == LEP_ICONV_OK ) {
264                                         flag = 1;
265                                         info->map[i] = -2;
266                                 } else if( r != LEP_ICONV_INVAL ) {
267                                 } else {
268                                         for( k = 0; k < 256; k++ ) {
269                                                 /* third char */
270                                                 buf[2] = k;
271                                                 r = giconv_utf32_char(cd, buf, 3, &value);
272                                                 if( r == LEP_ICONV_OK) {
273                                                         info->map[i] = -3;
274                                                 }
275                                         }
276                                 }
277                         }
278                 }
279         }
280
281         g_iconv_close(cd);
282
283         return flag;
284 }
285
286 struct FeedParserUnknownEncoding {
287         gchar *charset;
288         GIConv cd;
289 };
290
291 static gint feed_parser_unknown_encoding_convert(void *data, const gchar *s)
292 {
293         gint r;
294         struct FeedParserUnknownEncoding *enc_data;
295         size_t insize;
296         guint32 value;
297
298         enc_data = data;
299         insize = 4;
300
301         if( s == NULL )
302                 return -1;
303
304         r = giconv_utf32_char(enc_data->cd, s, insize, &value);
305         if( r != LEP_ICONV_OK )
306                 return -1;
307
308         return 0;
309 }
310
311 static void feed_parser_unknown_encoding_data_free(void *data)
312 {
313         struct FeedParserUnknownEncoding *enc_data;
314
315         enc_data = data;
316         free(enc_data->charset);
317         g_iconv_close(enc_data->cd);
318         free(enc_data);
319 }
320
321 int feed_parser_unknown_encoding_handler(void *encdata, const XML_Char *name,
322                 XML_Encoding *info)
323 {
324         GIConv cd;
325         struct FeedParserUnknownEncoding *data;
326         int result;
327
328         result = feed_parser_setup_unknown_encoding(name, info);
329         if( result == 0 ) {
330                 info->data = NULL;
331                 info->convert = NULL;
332                 info->release = NULL;
333                 return XML_STATUS_OK;
334         }
335
336         cd = g_iconv_open("UTF-32BE", name);
337         if( cd == (GIConv)-1 )
338                 return XML_STATUS_ERROR;
339
340         data = malloc( sizeof(*data) );
341         if( data == NULL ) {
342                 g_iconv_close(cd);
343                 return XML_STATUS_ERROR;
344         }
345
346         data->charset = strdup(name);
347         if( data->charset == NULL ) {
348                 free(data);
349                 g_iconv_close(cd);
350                 return XML_STATUS_ERROR;
351         }
352
353         data->cd = cd;
354         info->data = data;
355         info->convert = feed_parser_unknown_encoding_convert;
356         info->release = feed_parser_unknown_encoding_data_free;
357
358         return XML_STATUS_OK;
359 }