0.8.6claws69
[claws.git] / src / common / nntp.c
1 /*
2  * Sylpheed -- a GTK+ based, lightweight, and fast e-mail client
3  * Copyright (C) 1999-2002 Hiroyuki Yamamoto
4  *
5  * This program is free software; you can redistribute it and/or modify
6  * it under the terms of the GNU General Public License as published by
7  * the Free Software Foundation; either version 2 of the License, or
8  * (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18  */
19
20 #ifdef HAVE_CONFIG_H
21 #  include "config.h"
22 #endif
23
24 #include <glib.h>
25 #include <stdio.h>
26 #include <string.h>
27
28 #include "intl.h"
29 #include "nntp.h"
30 #include "socket.h"
31 #include "utils.h"
32 #include "log.h"
33 #if USE_SSL
34 #  include "ssl.h"
35 #endif
36
37 static gint verbose = 1;
38
39 static void nntp_gen_send       (NNTPSockInfo   *sock,
40                                  const gchar    *format,
41                                  ...);
42 static gint nntp_gen_recv       (NNTPSockInfo   *sock,
43                                  gchar          *buf,
44                                  gint            size);
45 static gint nntp_gen_command    (NNTPSockInfo   *sock,
46                                  gchar          *argbuf,
47                                  const gchar    *format,
48                                  ...);
49
50 #if USE_SSL
51 NNTPSockInfo *nntp_open(const gchar *server, gushort port, gchar *buf,
52                         SSLType ssl_type)
53 #else
54 NNTPSockInfo *nntp_open(const gchar *server, gushort port, gchar *buf)
55 #endif
56 {
57         SockInfo *sock;
58         NNTPSockInfo *nntp_sock;
59
60         if ((sock = sock_connect(server, port)) == NULL) {
61                 log_warning(_("Can't connect to NNTP server: %s:%d\n"),
62                             server, port);
63                 return NULL;
64         }
65
66 #if USE_SSL
67         if (ssl_type == SSL_TUNNEL && !ssl_init_socket(sock)) {
68                 sock_close(sock);
69                 return NULL;
70         }
71 #endif
72
73         nntp_sock = g_new0(NNTPSockInfo, 1);
74         nntp_sock->sock = sock;
75
76         if (nntp_ok(nntp_sock, buf) == NN_SUCCESS)
77                 return nntp_sock;
78         else {
79                 sock_close(sock);
80                 g_free(nntp_sock);
81                 return NULL;
82         }
83 }
84
85 #if USE_SSL
86 NNTPSockInfo *nntp_open_auth(const gchar *server, gushort port, gchar *buf,
87                              const gchar *userid, const gchar *passwd,
88                              SSLType ssl_type)
89 #else
90 NNTPSockInfo *nntp_open_auth(const gchar *server, gushort port, gchar *buf,
91                              const gchar *userid, const gchar *passwd)
92 #endif
93 {
94         NNTPSockInfo *sock;
95
96 #if USE_SSL
97         sock = nntp_open(server, port, buf, ssl_type);
98 #else
99         sock = nntp_open(server, port, buf);
100 #endif
101
102         if (!sock) return NULL;
103
104         sock->userid = g_strdup(userid);
105         sock->passwd = g_strdup(passwd);
106
107         return sock;
108 }
109
110 void nntp_close(NNTPSockInfo *sock)
111 {
112         if (!sock) return;
113
114         sock_close(sock->sock);
115         g_free(sock->userid);
116         g_free(sock->passwd);
117         g_free(sock);
118 }
119
120 gint nntp_group(NNTPSockInfo *sock, const gchar *group,
121                 gint *num, gint *first, gint *last)
122 {
123         gint ok;
124         gint resp;
125         gchar buf[NNTPBUFSIZE];
126
127         ok = nntp_gen_command(sock, buf, "GROUP %s", group);
128
129         if (ok != NN_SUCCESS) {
130                 ok = nntp_mode(sock, FALSE);
131                 if (ok == NN_SUCCESS)
132                         ok = nntp_gen_command(sock, buf, "GROUP %s", group);
133         }
134
135         if (ok != NN_SUCCESS)
136                 return ok;
137
138         if (sscanf(buf, "%d %d %d %d", &resp, num, first, last)
139             != 4) {
140                 log_warning(_("protocol error: %s\n"), buf);
141                 return NN_PROTOCOL;
142         }
143
144         return NN_SUCCESS;
145 }
146
147 gint nntp_get_article(NNTPSockInfo *sock, const gchar *cmd, gint num,
148                       gchar **msgid)
149 {
150         gint ok;
151         gchar buf[NNTPBUFSIZE];
152
153         if (num > 0)
154                 ok = nntp_gen_command(sock, buf, "%s %d", cmd, num);
155         else
156                 ok = nntp_gen_command(sock, buf, cmd);
157
158         if (ok != NN_SUCCESS)
159                 return ok;
160
161         extract_parenthesis(buf, '<', '>');
162         if (buf[0] == '\0') {
163                 log_warning(_("protocol error\n"));
164                 return NN_PROTOCOL;
165         }
166         *msgid = g_strdup(buf);
167
168         return NN_SUCCESS;
169 }
170
171 gint nntp_article(NNTPSockInfo *sock, gint num, gchar **msgid)
172 {
173         return nntp_get_article(sock, "ARTICLE", num, msgid);
174 }
175
176 gint nntp_body(NNTPSockInfo *sock, gint num, gchar **msgid)
177 {
178         return nntp_get_article(sock, "BODY", num, msgid);
179 }
180
181 gint nntp_head(NNTPSockInfo *sock, gint num, gchar **msgid)
182 {
183         return nntp_get_article(sock, "HEAD", num, msgid);
184 }
185
186 gint nntp_stat(NNTPSockInfo *sock, gint num, gchar **msgid)
187 {
188         return nntp_get_article(sock, "STAT", num, msgid);
189 }
190
191 gint nntp_next(NNTPSockInfo *sock, gint *num, gchar **msgid)
192 {
193         gint ok;
194         gint resp;
195         gchar buf[NNTPBUFSIZE];
196
197         ok = nntp_gen_command(sock, buf, "NEXT");
198
199         if (ok != NN_SUCCESS)
200                 return ok;
201
202         if (sscanf(buf, "%d %d", &resp, num) != 2) {
203                 log_warning(_("protocol error: %s\n"), buf);
204                 return NN_PROTOCOL;
205         }
206
207         extract_parenthesis(buf, '<', '>');
208         if (buf[0] == '\0') {
209                 log_warning(_("protocol error\n"));
210                 return NN_PROTOCOL;
211         }
212         *msgid = g_strdup(buf);
213
214         return NN_SUCCESS;
215 }
216
217 gint nntp_xover(NNTPSockInfo *sock, gint first, gint last)
218 {
219         gint ok;
220         gchar buf[NNTPBUFSIZE];
221
222         ok = nntp_gen_command(sock, buf, "XOVER %d-%d", first, last);
223         if (ok != NN_SUCCESS)
224                 return ok;
225
226         return NN_SUCCESS;
227 }
228
229 gint nntp_xhdr(NNTPSockInfo *sock, const gchar *header, gint first, gint last)
230 {
231         gint ok;
232         gchar buf[NNTPBUFSIZE];
233
234         ok = nntp_gen_command(sock, buf, "XHDR %s %d-%d", header, first, last);
235         if (ok != NN_SUCCESS)
236                 return ok;
237
238         return NN_SUCCESS;
239 }
240
241 gint nntp_list(NNTPSockInfo *sock)
242 {
243         return nntp_gen_command(sock, NULL, "LIST");
244 }
245
246 gint nntp_post(NNTPSockInfo *sock, FILE *fp)
247 {
248         gint ok;
249         gchar buf[NNTPBUFSIZE];
250
251         ok = nntp_gen_command(sock, buf, "POST");
252         if (ok != NN_SUCCESS)
253                 return ok;
254
255         while (fgets(buf, sizeof(buf), fp) != NULL) {
256                 strretchomp(buf);
257                 if (buf[0] == '.') {
258                         if (sock_write(sock->sock, ".", 1) < 0) {
259                                 log_warning(_("Error occurred while posting\n"));
260                                 return NN_SOCKET;
261                         }
262                 }
263
264                 if (sock_puts(sock->sock, buf) < 0) {
265                         log_warning(_("Error occurred while posting\n"));
266                         return NN_SOCKET;
267                 }
268         }
269
270         sock_write(sock->sock, ".\r\n", 3);
271         if ((ok = nntp_ok(sock, buf)) != NN_SUCCESS)
272                 return ok;
273
274         return NN_SUCCESS;
275 }
276
277 gint nntp_newgroups(NNTPSockInfo *sock)
278 {
279         return NN_SUCCESS;
280 }
281
282 gint nntp_newnews(NNTPSockInfo *sock)
283 {
284         return NN_SUCCESS;
285 }
286
287 gint nntp_mode(NNTPSockInfo *sock, gboolean stream)
288 {
289         gint ok;
290
291         if (sock->auth_failed)
292                 return NN_AUTHREQ;
293
294         ok = nntp_gen_command(sock, NULL, "MODE %s",
295                               stream ? "STREAM" : "READER");
296
297         return ok;
298 }
299
300 gint nntp_ok(NNTPSockInfo *sock, gchar *argbuf)
301 {
302         gint ok;
303         gchar buf[NNTPBUFSIZE];
304
305         if ((ok = nntp_gen_recv(sock, buf, sizeof(buf))) == NN_SUCCESS) {
306                 if (strlen(buf) < 3)
307                         return NN_ERROR;
308
309                 if ((buf[0] == '1' || buf[0] == '2' || buf[0] == '3') &&
310                     (buf[3] == ' ' || buf[3] == '\0')) {
311                         if (argbuf)
312                                 strcpy(argbuf, buf);
313
314                         if (!strncmp(buf, "381", 3))
315                                 return NN_AUTHCONT;
316
317                         return NN_SUCCESS;
318                 } else if (!strncmp(buf, "480", 3))
319                         return NN_AUTHREQ;
320                 else
321                         return NN_ERROR;
322         }
323
324         return ok;
325 }
326
327 static void nntp_gen_send(NNTPSockInfo *sock, const gchar *format, ...)
328 {
329         gchar buf[NNTPBUFSIZE];
330         va_list args;
331
332         va_start(args, format);
333         g_vsnprintf(buf, sizeof(buf), format, args);
334         va_end(args);
335
336         if (verbose) {
337                 if (!g_strncasecmp(buf, "AUTHINFO PASS", 13))
338                         log_print("NNTP> AUTHINFO PASS ********\n");
339                 else
340                         log_print("NNTP> %s\n", buf);
341         }
342
343         strcat(buf, "\r\n");
344         sock_write(sock->sock, buf, strlen(buf));
345 }
346
347 static gint nntp_gen_recv(NNTPSockInfo *sock, gchar *buf, gint size)
348 {
349         if (sock_gets(sock->sock, buf, size) == -1)
350                 return NN_SOCKET;
351
352         strretchomp(buf);
353
354         if (verbose)
355                 log_print("NNTP< %s\n", buf);
356
357         return NN_SUCCESS;
358 }
359
360 static gint nntp_gen_command(NNTPSockInfo *sock, gchar *argbuf,
361                              const gchar *format, ...)
362 {
363         gchar buf[NNTPBUFSIZE];
364         va_list args;
365         gint ok;
366
367         va_start(args, format);
368         g_vsnprintf(buf, sizeof(buf), format, args);
369         va_end(args);
370
371         nntp_gen_send(sock, "%s", buf);
372         ok = nntp_ok(sock, argbuf);
373         if (ok == NN_AUTHREQ) {
374                 if (!sock->userid || !sock->passwd) {
375                         sock->auth_failed = TRUE;
376                         return ok;
377                 }
378
379                 nntp_gen_send(sock, "AUTHINFO USER %s", sock->userid);
380                 ok = nntp_ok(sock, NULL);
381                 if (ok == NN_AUTHCONT) {
382                         nntp_gen_send(sock, "AUTHINFO PASS %s", sock->passwd);
383                         ok = nntp_ok(sock, NULL);
384                 }
385                 if (ok != NN_SUCCESS) {
386                         sock->auth_failed = TRUE;
387                         return ok;
388                 }
389
390                 nntp_gen_send(sock, "%s", buf);
391                 ok = nntp_ok(sock, argbuf);
392         }
393
394         return ok;
395 }