]> Pileus Git - ~andy/fetchmail/blob - odmr.c
76891681a95943baccef2d0578a004c8ea242959
[~andy/fetchmail] / odmr.c
1 /*
2  * odmr.c -- ODMR protocol methods (see RFC 2645)
3  *
4  * For license terms, see the file COPYING in this directory.
5  */
6
7 #include  "config.h"
8 #ifdef ODMR_ENABLE
9 #include  <stdio.h>
10 #include  <stdlib.h>
11 #include  <assert.h>
12 #ifdef HAVE_STRING_H /* strcat() */
13 #include <string.h>
14 #endif
15 #ifdef HAVE_NET_SOCKET_H /* BeOS needs this */
16 #include <net/socket.h>
17 #endif
18 #include  <sys/types.h>
19 #include  <sys/time.h>
20 #ifdef HAVE_NET_SELECT_H /* AIX needs this */
21 #include <net/select.h>
22 #endif
23 #ifdef HAVE_SYS_SELECT_H /* AIX 4.1, at least, needs this */
24 #include  <sys/select.h>
25 #endif
26 #include  <netdb.h>
27 #include  <errno.h>
28 #include  <unistd.h>
29 #include  "i18n.h"
30 #include  "fetchmail.h"
31 #include  "smtp.h"
32 #include  "socket.h"
33
34 static int odmr_ok (int sock, char *argbuf)
35 /* parse command response */
36 {
37     int ok;
38
39     ok = SMTP_ok(sock);
40     if (ok == SM_UNRECOVERABLE)
41         return(PS_PROTOCOL);
42     else
43         return(ok);
44 }
45
46 static int odmr_getrange(int sock, struct query *ctl, const char *id, 
47                          int *countp, int *newp, int *bytes)
48 /* send ODMR and then run a reverse SMTP session */
49 {
50     int ok, opts, smtp_sock;
51     char buf [MSGBUFSIZE+1];
52     struct idlist *qnp;         /* pointer to Q names */
53
54     if ((ok = SMTP_ehlo(sock, fetchmailhost, 
55                         ctl->server.esmtp_name, ctl->server.esmtp_password,
56                         &opts)))
57     {
58         report(stderr, GT_("%s's SMTP listener does not support ESMTP\n"),
59               ctl->server.pollname);
60         return(ok);
61     }
62     else if (!(opts & ESMTP_ATRN))
63     {
64         report(stderr, GT_("%s's SMTP listener does not support ATRN\n"),
65               ctl->server.pollname);
66         return(PS_PROTOCOL);
67     }
68
69     /* make sure we don't enter the fetch loop */
70     *bytes = *countp = *newp = -1;
71
72     /* authenticate via CRAM-MD5 */
73     ok = do_cram_md5(sock, "AUTH", ctl, "334 ");
74     if (ok)
75         return(ok);
76
77     /*
78      * By default, the hostlist has a single entry, the fetchmail host's
79      * canonical DNS name.
80      */
81     buf[0] = '\0';
82     for (qnp = ctl->domainlist; qnp; qnp = qnp->next)
83         if (strlen(buf) + strlen(qnp->id) + 1 >= sizeof(buf))
84             break;
85         else
86         {
87             strcat(buf, qnp->id);
88             strcat(buf, ",");
89         }
90     buf[strlen(buf) - 1] = '\0';        /* nuke final comma */
91
92     /* ship the domain list and get turnaround */
93     gen_send(sock, "ATRN %s", buf);
94     if ((ok = gen_recv(sock, buf, sizeof(buf))))
95         return(ok);
96
97     /* this switch includes all response codes described in RFC2645 */
98     switch(atoi(buf))
99     {
100     case 250:   /* OK, turnaround is about to happe */
101         if (outlevel > O_SILENT)
102             report(stdout, GT_("Turnaround now...\n"));
103         break;
104
105     case 450:   /* ATRN request refused */
106         if (outlevel > O_SILENT)
107             report(stdout, GT_("ATRN request refused.\n"));
108         return(PS_PROTOCOL);
109
110     case 451:   /* Unable to process ATRN request now */
111         report(stderr, GT_("Unable to process ATRN request now\n"));
112         return(PS_EXCLUDE);
113
114     case 453:   /* You have no mail */
115         if (outlevel > O_SILENT)
116             report(stderr, GT_("You have no mail.\n"));
117         return(PS_NOMAIL);
118
119     case 502:   /* Command not implemented */
120         report(stderr, GT_("Command not implemented\n"));
121         return(PS_PROTOCOL);
122
123     case 530:   /* Authentication required */
124         report(stderr, GT_("Authentication required.\n"));
125         return(PS_AUTHFAIL);
126
127     default:
128         report(stderr, GT_("Unknown ODMR error %d\n"), atoi(buf));
129         return(PS_PROTOCOL);
130     }
131
132     /*
133      * OK, if we got here it's time to become a pipe between the ODMR
134      * remote server (sending) and the SMTP listener we've designated
135      * (receiving).  We're not going to try to be a protocol machine;
136      * instead, we'll use select(2) to watch the read sides of both
137      * sockets and just throw their data at each other.
138      */
139     if ((smtp_sock = smtp_open(ctl)) == -1)
140         return(PS_SOCKET);
141     else
142     {
143         int     maxfd = (sock > smtp_sock) ? sock : smtp_sock;
144
145         for (;;)
146         {
147             fd_set      readfds;
148             struct timeval timeout;
149             char        buf[MSGBUFSIZE];
150
151             FD_ZERO(&readfds);
152             FD_SET(sock, &readfds);
153             FD_SET(smtp_sock, &readfds);
154
155             timeout.tv_sec  = ctl->server.timeout;
156             timeout.tv_usec = 0;
157
158             if (select(maxfd+1, &readfds, NULL, NULL, &timeout) == -1)
159                 return(PS_PROTOCOL);            /* timeout */
160
161             if (FD_ISSET(sock, &readfds))
162             {
163                 int n = SockRead(sock, buf, sizeof(buf));
164                 if (n <= 0)
165                     break;
166
167                 SockWrite(smtp_sock, buf, n);
168                 if (outlevel >= O_MONITOR)
169                     report(stdout, "ODMR< %s", buf);
170             }
171             if (FD_ISSET(smtp_sock, &readfds))
172             {
173                 int n = SockRead(smtp_sock, buf, sizeof(buf));
174                 if (n <= 0)
175                     break;
176
177                 SockWrite(sock, buf, n);
178                 if (outlevel >= O_MONITOR)
179                     report(stdout, "ODMR> %s", buf);
180             }
181         }
182         SockClose(smtp_sock);
183     }
184
185     return(0);
186 }
187
188 static int odmr_logout(int sock, struct query *ctl)
189 /* send logout command */
190 {
191     /* if we have a smtp_socket, then we've turned around and the
192        local smtp server is in control of the connection (so we don't
193        send QUIT) */
194     if (ctl->smtp_socket == -1)
195        return(gen_transact(sock, "QUIT"));
196     else
197        return(PS_SUCCESS);
198 }
199
200 const static struct method odmr =
201 {
202     "ODMR",             /* ODMR protocol */
203 #if INET6_ENABLE
204     "odmr",             /* standard SMTP port */
205     "odmrs",            /* ssl SMTP port */
206 #else /* INET6_ENABLE */
207     366,                /* standard SMTP port */
208     2366,               /* ssl SMTP port (BOGUS! RANDOM VALUE) */
209 #endif /* INET6_ENABLE */
210     FALSE,              /* this is not a tagged protocol */
211     FALSE,              /* this does not use a message delimiter */
212     odmr_ok,            /* parse command response */
213     NULL,               /* no need to get authentication */
214     odmr_getrange,      /* initialize message sending */
215     NULL,               /* we cannot get a list of sizes */
216     NULL,               /* how do we tell a message is old? */
217     NULL,               /* no way to fetch headers */
218     NULL,               /* no way to fetch body */
219     NULL,               /* no message trailer */
220     NULL,               /* how to delete a message */
221     odmr_logout,        /* log out, we're done */
222     FALSE,              /* no, we can't re-poll */
223 };
224
225 int doODMR (struct query *ctl)
226 /* retrieve messages using ODMR */
227 {
228     int status;
229
230     if (ctl->keep) {
231         fprintf(stderr, GT_("Option --keep is not supported with ODMR\n"));
232         return(PS_SYNTAX);
233     }
234     if (ctl->flush) {
235         fprintf(stderr, GT_("Option --flush is not supported with ODMR\n"));
236         return(PS_SYNTAX);
237     }
238     if (ctl->mailboxes->id) {
239         fprintf(stderr, GT_("Option --remote is not supported with ODMR\n"));
240         return(PS_SYNTAX);
241     }
242     if (check_only) {
243         fprintf(stderr, GT_("Option --check is not supported with ODMR\n"));
244         return(PS_SYNTAX);
245     }
246     peek_capable = FALSE;
247
248     status = do_protocol(ctl, &odmr);
249     if (status == PS_NOMAIL)
250         status = PS_SUCCESS;
251     return(status);
252 }
253 #endif /* ODMR_ENABLE */
254
255 /* odmr.c ends here */