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