bc59ce06f1244eb7b7680a2227ab1e706fa1aaea
[claws.git] / src / 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 #if USE_SSL
33 #  include "ssl.h"
34 #endif
35
36 static gint verbose = 1;
37
38 static void nntp_gen_send       (NNTPSockInfo   *sock,
39                                  const gchar    *format,
40                                  ...);
41 static gint nntp_gen_recv       (NNTPSockInfo   *sock,
42                                  gchar          *buf,
43                                  gint            size);
44 static gint nntp_gen_command    (NNTPSockInfo   *sock,
45                                  gchar          *argbuf,
46                                  const gchar    *format,
47                                  ...);
48
49 #if USE_SSL
50 NNTPSockInfo *nntp_open(const gchar *server, gushort port, gchar *buf,
51                         SSLType ssl_type)
52 #else
53 NNTPSockInfo *nntp_open(const gchar *server, gushort port, gchar *buf)
54 #endif
55 {
56         SockInfo *sock;
57         NNTPSockInfo *nntp_sock;
58
59         if ((sock = sock_connect(server, port)) == NULL) {
60                 log_warning(_("Can't connect to NNTP server: %s:%d\n"),
61                             server, port);
62                 return NULL;
63         }
64
65 #if USE_SSL
66         if (ssl_type == SSL_TUNNEL && !ssl_init_socket(sock)) {
67                 sock_close(sock);
68                 return NULL;
69         }
70 #endif
71
72         nntp_sock = g_new0(NNTPSockInfo, 1);
73         nntp_sock->sock = sock;
74
75         if (nntp_ok(nntp_sock, buf) == NN_SUCCESS)
76                 return nntp_sock;
77         else {
78                 sock_close(sock);
79                 g_free(nntp_sock);
80                 return NULL;
81         }
82 }
83
84 #if USE_SSL
85 NNTPSockInfo *nntp_open_auth(const gchar *server, gushort port, gchar *buf,
86                              const gchar *userid, const gchar *passwd,
87                              SSLType ssl_type)
88 #else
89 NNTPSockInfo *nntp_open_auth(const gchar *server, gushort port, gchar *buf,
90                              const gchar *userid, const gchar *passwd)
91 #endif
92 {
93         NNTPSockInfo *sock;
94
95 #if USE_SSL
96         sock = nntp_open(server, port, buf, ssl_type);
97 #else
98         sock = nntp_open(server, port, buf);
99 #endif
100
101         if (!sock) return NULL;
102
103         sock->userid = g_strdup(userid);
104         sock->passwd = g_strdup(passwd);
105
106         return sock;
107 }
108
109 void nntp_close(NNTPSockInfo *sock)
110 {
111         if (!sock) return;
112
113         sock_close(sock->sock);
114         g_free(sock->userid);
115         g_free(sock->passwd);
116         g_free(sock);
117 }
118
119 gint nntp_group(NNTPSockInfo *sock, const gchar *group,
120                 gint *num, gint *first, gint *last)
121 {
122         gint ok;
123         gint resp;
124         gchar buf[NNTPBUFSIZE];
125
126         ok = nntp_gen_command(sock, buf, "GROUP %s", group);
127
128         if (ok != NN_SUCCESS) {
129                 ok = nntp_mode(sock, FALSE);
130                 if (ok == NN_SUCCESS)
131                         ok = nntp_gen_command(sock, buf, "GROUP %s", group);
132         }
133
134         if (ok != NN_SUCCESS)
135                 return ok;
136
137         if (sscanf(buf, "%d %d %d %d", &resp, num, first, last)
138             != 4) {
139                 log_warning(_("protocol error: %s\n"), buf);
140                 return NN_PROTOCOL;
141         }
142
143         return NN_SUCCESS;
144 }
145
146 gint nntp_get_article(NNTPSockInfo *sock, const gchar *cmd, gint num,
147                       gchar **msgid)
148 {
149         gint ok;
150         gchar buf[NNTPBUFSIZE];
151
152         if (num > 0)
153                 ok = nntp_gen_command(sock, buf, "%s %d", cmd, num);
154         else
155                 ok = nntp_gen_command(sock, buf, cmd);
156
157         if (ok != NN_SUCCESS)
158                 return ok;
159
160         extract_parenthesis(buf, '<', '>');
161         if (buf[0] == '\0') {
162                 log_warning(_("protocol error\n"));
163                 return NN_PROTOCOL;
164         }
165         *msgid = g_strdup(buf);
166
167         return NN_SUCCESS;
168 }
169
170 gint nntp_article(NNTPSockInfo *sock, gint num, gchar **msgid)
171 {
172         return nntp_get_article(sock, "ARTICLE", num, msgid);
173 }
174
175 gint nntp_body(NNTPSockInfo *sock, gint num, gchar **msgid)
176 {
177         return nntp_get_article(sock, "BODY", num, msgid);
178 }
179
180 gint nntp_head(NNTPSockInfo *sock, gint num, gchar **msgid)
181 {
182         return nntp_get_article(sock, "HEAD", num, msgid);
183 }
184
185 gint nntp_stat(NNTPSockInfo *sock, gint num, gchar **msgid)
186 {
187         return nntp_get_article(sock, "STAT", num, msgid);
188 }
189
190 gint nntp_next(NNTPSockInfo *sock, gint *num, gchar **msgid)
191 {
192         gint ok;
193         gint resp;
194         gchar buf[NNTPBUFSIZE];
195
196         ok = nntp_gen_command(sock, buf, "NEXT");
197
198         if (ok != NN_SUCCESS)
199                 return ok;
200
201         if (sscanf(buf, "%d %d", &resp, num) != 2) {
202                 log_warning(_("protocol error: %s\n"), buf);
203                 return NN_PROTOCOL;
204         }
205
206         extract_parenthesis(buf, '<', '>');
207         if (buf[0] == '\0') {
208                 log_warning(_("protocol error\n"));
209                 return NN_PROTOCOL;
210         }
211         *msgid = g_strdup(buf);
212
213         return NN_SUCCESS;
214 }
215
216 gint nntp_xover(NNTPSockInfo *sock, gint first, gint last)
217 {
218         gint ok;
219         gchar buf[NNTPBUFSIZE];
220
221         ok = nntp_gen_command(sock, buf, "XOVER %d-%d", first, last);
222         if (ok != NN_SUCCESS)
223                 return ok;
224
225         return NN_SUCCESS;
226 }
227
228 gint nntp_xhdr(NNTPSockInfo *sock, const gchar *header, gint first, gint last)
229 {
230         gint ok;
231         gchar buf[NNTPBUFSIZE];
232
233         ok = nntp_gen_command(sock, buf, "XHDR %s %d-%d", header, first, last);
234         if (ok != NN_SUCCESS)
235                 return ok;
236
237         return NN_SUCCESS;
238 }
239
240 gint nntp_list(NNTPSockInfo *sock)
241 {
242         return nntp_gen_command(sock, NULL, "LIST");
243 }
244
245 gint nntp_post(NNTPSockInfo *sock, FILE *fp)
246 {
247         gint ok;
248         gchar buf[NNTPBUFSIZE];
249
250         ok = nntp_gen_command(sock, buf, "POST");
251         if (ok != NN_SUCCESS)
252                 return ok;
253
254         while (fgets(buf, sizeof(buf), fp) != NULL) {
255                 strretchomp(buf);
256                 if (buf[0] == '.') {
257                         if (sock_write(sock->sock, ".", 1) < 0) {
258                                 log_warning(_("Error occurred while posting\n"));
259                                 return NN_SOCKET;
260                         }
261                 }
262
263                 if (sock_puts(sock->sock, buf) < 0) {
264                         log_warning(_("Error occurred while posting\n"));
265                         return NN_SOCKET;
266                 }
267         }
268
269         sock_write(sock->sock, ".\r\n", 3);
270         if ((ok = nntp_ok(sock, buf)) != NN_SUCCESS)
271                 return ok;
272
273         return NN_SUCCESS;
274 }
275
276 gint nntp_newgroups(NNTPSockInfo *sock)
277 {
278         return NN_SUCCESS;
279 }
280
281 gint nntp_newnews(NNTPSockInfo *sock)
282 {
283         return NN_SUCCESS;
284 }
285
286 gint nntp_mode(NNTPSockInfo *sock, gboolean stream)
287 {
288         gint ok;
289
290         if (sock->auth_failed)
291                 return NN_AUTHREQ;
292
293         ok = nntp_gen_command(sock, NULL, "MODE %s",
294                               stream ? "STREAM" : "READER");
295
296         return ok;
297 }
298
299 gint nntp_ok(NNTPSockInfo *sock, gchar *argbuf)
300 {
301         gint ok;
302         gchar buf[NNTPBUFSIZE];
303
304         if ((ok = nntp_gen_recv(sock, buf, sizeof(buf))) == NN_SUCCESS) {
305                 if (strlen(buf) < 3)
306                         return NN_ERROR;
307
308                 if ((buf[0] == '1' || buf[0] == '2' || buf[0] == '3') &&
309                     (buf[3] == ' ' || buf[3] == '\0')) {
310                         if (argbuf)
311                                 strcpy(argbuf, buf);
312
313                         if (!strncmp(buf, "381", 3))
314                                 return NN_AUTHCONT;
315
316                         return NN_SUCCESS;
317                 } else if (!strncmp(buf, "480", 3))
318                         return NN_AUTHREQ;
319                 else
320                         return NN_ERROR;
321         }
322
323         return ok;
324 }
325
326 static void nntp_gen_send(NNTPSockInfo *sock, const gchar *format, ...)
327 {
328         gchar buf[NNTPBUFSIZE];
329         va_list args;
330
331         va_start(args, format);
332         g_vsnprintf(buf, sizeof(buf), format, args);
333         va_end(args);
334
335         if (verbose) {
336                 if (!g_strncasecmp(buf, "AUTHINFO PASS", 13))
337                         log_print("NNTP> AUTHINFO PASS ********\n");
338                 else
339                         log_print("NNTP> %s\n", buf);
340         }
341
342         strcat(buf, "\r\n");
343         sock_write(sock->sock, buf, strlen(buf));
344 }
345
346 static gint nntp_gen_recv(NNTPSockInfo *sock, gchar *buf, gint size)
347 {
348         if (sock_gets(sock->sock, buf, size) == -1)
349                 return NN_SOCKET;
350
351         strretchomp(buf);
352
353         if (verbose)
354                 log_print("NNTP< %s\n", buf);
355
356         return NN_SUCCESS;
357 }
358
359 static gint nntp_gen_command(NNTPSockInfo *sock, gchar *argbuf,
360                              const gchar *format, ...)
361 {
362         gchar buf[NNTPBUFSIZE];
363         va_list args;
364         gint ok;
365
366         va_start(args, format);
367         g_vsnprintf(buf, sizeof(buf), format, args);
368         va_end(args);
369
370         nntp_gen_send(sock, "%s", buf);
371         ok = nntp_ok(sock, argbuf);
372         if (ok == NN_AUTHREQ) {
373                 if (!sock->userid || !sock->passwd) {
374                         sock->auth_failed = TRUE;
375                         return ok;
376                 }
377
378                 nntp_gen_send(sock, "AUTHINFO USER %s", sock->userid);
379                 ok = nntp_ok(sock, NULL);
380                 if (ok == NN_AUTHCONT) {
381                         nntp_gen_send(sock, "AUTHINFO PASS %s", sock->passwd);
382                         ok = nntp_ok(sock, NULL);
383                 }
384                 if (ok != NN_SUCCESS) {
385                         sock->auth_failed = TRUE;
386                         return ok;
387                 }
388
389                 nntp_gen_send(sock, "%s", buf);
390                 ok = nntp_ok(sock, argbuf);
391         }
392
393         return ok;
394 }