[tcp] Ignore duplicate ACKs in TCP ESTABLISHED state
[people/oremanj/gpxe.git] / src / net / tcp / ftp.c
1 #include <stdint.h>
2 #include <stdlib.h>
3 #include <stdio.h>
4 #include <string.h>
5 #include <assert.h>
6 #include <errno.h>
7 #include <byteswap.h>
8 #include <gpxe/socket.h>
9 #include <gpxe/tcpip.h>
10 #include <gpxe/in.h>
11 #include <gpxe/xfer.h>
12 #include <gpxe/open.h>
13 #include <gpxe/uri.h>
14 #include <gpxe/features.h>
15 #include <gpxe/ftp.h>
16
17 /** @file
18  *
19  * File transfer protocol
20  *
21  */
22
23 FEATURE ( FEATURE_PROTOCOL, "FTP", DHCP_EB_FEATURE_FTP, 1 );
24
25 /**
26  * FTP states
27  *
28  * These @b must be sequential, i.e. a successful FTP session must
29  * pass through each of these states in order.
30  */
31 enum ftp_state {
32         FTP_CONNECT = 0,
33         FTP_USER,
34         FTP_PASS,
35         FTP_TYPE,
36         FTP_PASV,
37         FTP_RETR,
38         FTP_WAIT,
39         FTP_QUIT,
40         FTP_DONE,
41 };
42
43 /**
44  * An FTP request
45  *
46  */
47 struct ftp_request {
48         /** Reference counter */
49         struct refcnt refcnt;
50         /** Data transfer interface */
51         struct xfer_interface xfer;
52
53         /** URI being fetched */
54         struct uri *uri;
55         /** FTP control channel interface */
56         struct xfer_interface control;
57         /** FTP data channel interface */
58         struct xfer_interface data;
59
60         /** Current state */
61         enum ftp_state state;
62         /** Buffer to be filled with data received via the control channel */
63         char *recvbuf;
64         /** Remaining size of recvbuf */
65         size_t recvsize;
66         /** FTP status code, as text */
67         char status_text[5];
68         /** Passive-mode parameters, as text */
69         char passive_text[24]; /* "aaa,bbb,ccc,ddd,eee,fff" */
70 };
71
72 /**
73  * Free FTP request
74  *
75  * @v refcnt            Reference counter
76  */
77 static void ftp_free ( struct refcnt *refcnt ) {
78         struct ftp_request *ftp =
79                 container_of ( refcnt, struct ftp_request, refcnt );
80
81         DBGC ( ftp, "FTP %p freed\n", ftp );
82
83         uri_put ( ftp->uri );
84         free ( ftp );
85 }
86
87 /**
88  * Mark FTP operation as complete
89  *
90  * @v ftp               FTP request
91  * @v rc                Return status code
92  */
93 static void ftp_done ( struct ftp_request *ftp, int rc ) {
94
95         DBGC ( ftp, "FTP %p completed (%s)\n", ftp, strerror ( rc ) );
96
97         /* Close all data transfer interfaces */
98         xfer_nullify ( &ftp->xfer );
99         xfer_close ( &ftp->xfer, rc );
100         xfer_nullify ( &ftp->control );
101         xfer_close ( &ftp->control, rc );
102         xfer_nullify ( &ftp->data );
103         xfer_close ( &ftp->data, rc );
104 }
105
106 /*****************************************************************************
107  *
108  * FTP control channel
109  *
110  */
111
112 /** An FTP control channel string */
113 struct ftp_control_string {
114         /** Literal portion */
115         const char *literal;
116         /** Variable portion
117          *
118          * @v ftp       FTP request
119          * @ret string  Variable portion of string
120          */
121         const char * ( *variable ) ( struct ftp_request *ftp );
122 };
123
124 /**
125  * Retrieve FTP pathname
126  *
127  * @v ftp               FTP request
128  * @ret path            FTP pathname
129  */
130 static const char * ftp_uri_path ( struct ftp_request *ftp ) {
131         return ftp->uri->path;
132 }
133
134 /** FTP control channel strings */
135 static struct ftp_control_string ftp_strings[] = {
136         [FTP_CONNECT]   = { NULL, NULL },
137         [FTP_USER]      = { "USER anonymous", NULL },
138         [FTP_PASS]      = { "PASS etherboot@etherboot.org", NULL },
139         [FTP_TYPE]      = { "TYPE I", NULL },
140         [FTP_PASV]      = { "PASV", NULL },
141         [FTP_RETR]      = { "RETR ", ftp_uri_path },
142         [FTP_WAIT]      = { NULL, NULL },
143         [FTP_QUIT]      = { "QUIT", NULL },
144         [FTP_DONE]      = { NULL, NULL },
145 };
146
147 /**
148  * Handle control channel being closed
149  *
150  * @v control           FTP control channel interface
151  * @v rc                Reason for close
152  *
153  * When the control channel is closed, the data channel must also be
154  * closed, if it is currently open.
155  */
156 static void ftp_control_close ( struct xfer_interface *control, int rc ) {
157         struct ftp_request *ftp =
158                 container_of ( control, struct ftp_request, control );
159
160         DBGC ( ftp, "FTP %p control connection closed: %s\n",
161                ftp, strerror ( rc ) );
162
163         /* Complete FTP operation */
164         ftp_done ( ftp, rc );
165 }
166
167 /**
168  * Parse FTP byte sequence value
169  *
170  * @v text              Text string
171  * @v value             Value buffer
172  * @v len               Length of value buffer
173  *
174  * This parses an FTP byte sequence value (e.g. the "aaa,bbb,ccc,ddd"
175  * form for IP addresses in PORT commands) into a byte sequence.  @c
176  * *text will be updated to point beyond the end of the parsed byte
177  * sequence.
178  *
179  * This function is safe in the presence of malformed data, though the
180  * output is undefined.
181  */
182 static void ftp_parse_value ( char **text, uint8_t *value, size_t len ) {
183         do {
184                 *(value++) = strtoul ( *text, text, 10 );
185                 if ( **text )
186                         (*text)++;
187         } while ( --len );
188 }
189
190 /**
191  * Move to next state and send the appropriate FTP control string
192  *
193  * @v ftp               FTP request
194  *
195  */
196 static void ftp_next_state ( struct ftp_request *ftp ) {
197         struct ftp_control_string *ftp_string;
198         const char *literal;
199         const char *variable;
200
201         /* Move to next state */
202         if ( ftp->state < FTP_DONE )
203                 ftp->state++;
204
205         /* Send control string if needed */
206         ftp_string = &ftp_strings[ftp->state];
207         literal = ftp_string->literal;
208         variable = ( ftp_string->variable ?
209                      ftp_string->variable ( ftp ) : "" );
210         if ( literal ) {
211                 DBGC ( ftp, "FTP %p sending %s%s\n", ftp, literal, variable );
212                 xfer_printf ( &ftp->control, "%s%s\r\n", literal, variable );
213         }
214 }
215
216 /**
217  * Handle an FTP control channel response
218  *
219  * @v ftp               FTP request
220  *
221  * This is called once we have received a complete response line.
222  */
223 static void ftp_reply ( struct ftp_request *ftp ) {
224         char status_major = ftp->status_text[0];
225         char separator = ftp->status_text[3];
226
227         DBGC ( ftp, "FTP %p received status %s\n", ftp, ftp->status_text );
228
229         /* Ignore malformed lines */
230         if ( separator != ' ' )
231                 return;
232
233         /* Ignore "intermediate" responses (1xx codes) */
234         if ( status_major == '1' )
235                 return;
236
237         /* Anything other than success (2xx) or, in the case of a
238          * repsonse to a "USER" command, a password prompt (3xx), is a
239          * fatal error.
240          */
241         if ( ! ( ( status_major == '2' ) ||
242                  ( ( status_major == '3' ) && ( ftp->state == FTP_USER ) ) ) ){
243                 /* Flag protocol error and close connections */
244                 ftp_done ( ftp, -EPROTO );
245                 return;
246         }
247
248         /* Open passive connection when we get "PASV" response */
249         if ( ftp->state == FTP_PASV ) {
250                 char *ptr = ftp->passive_text;
251                 union {
252                         struct sockaddr_in sin;
253                         struct sockaddr sa;
254                 } sa;
255                 int rc;
256
257                 sa.sin.sin_family = AF_INET;
258                 ftp_parse_value ( &ptr, ( uint8_t * ) &sa.sin.sin_addr,
259                                   sizeof ( sa.sin.sin_addr ) );
260                 ftp_parse_value ( &ptr, ( uint8_t * ) &sa.sin.sin_port,
261                                   sizeof ( sa.sin.sin_port ) );
262                 if ( ( rc = xfer_open_socket ( &ftp->data, SOCK_STREAM,
263                                                &sa.sa, NULL ) ) != 0 ) {
264                         DBGC ( ftp, "FTP %p could not open data connection\n",
265                                ftp );
266                         ftp_done ( ftp, rc );
267                         return;
268                 }
269         }
270
271         /* Move to next state and send control string */
272         ftp_next_state ( ftp );
273         
274 }
275
276 /**
277  * Handle new data arriving on FTP control channel
278  *
279  * @v control           FTP control channel interface
280  * @v data              New data
281  * @v len               Length of new data
282  *
283  * Data is collected until a complete line is received, at which point
284  * its information is passed to ftp_reply().
285  */
286 static int ftp_control_deliver_raw ( struct xfer_interface *control,
287                                      const void *data, size_t len ) {
288         struct ftp_request *ftp =
289                 container_of ( control, struct ftp_request, control );
290         char *recvbuf = ftp->recvbuf;
291         size_t recvsize = ftp->recvsize;
292         char c;
293         
294         while ( len-- ) {
295                 c = * ( ( char * ) data++ );
296                 switch ( c ) {
297                 case '\r' :
298                 case '\n' :
299                         /* End of line: call ftp_reply() to handle
300                          * completed reply.  Avoid calling ftp_reply()
301                          * twice if we receive both \r and \n.
302                          */
303                         if ( recvsize == 0 )
304                                 ftp_reply ( ftp );
305                         /* Start filling up the status code buffer */
306                         recvbuf = ftp->status_text;
307                         recvsize = sizeof ( ftp->status_text ) - 1;
308                         break;
309                 case '(' :
310                         /* Start filling up the passive parameter buffer */
311                         recvbuf = ftp->passive_text;
312                         recvsize = sizeof ( ftp->passive_text ) - 1;
313                         break;
314                 case ')' :
315                         /* Stop filling the passive parameter buffer */
316                         recvsize = 0;
317                         break;
318                 default :
319                         /* Fill up buffer if applicable */
320                         if ( recvsize > 0 ) {
321                                 *(recvbuf++) = c;
322                                 recvsize--;
323                         }
324                         break;
325                 }
326         }
327
328         /* Store for next invocation */
329         ftp->recvbuf = recvbuf;
330         ftp->recvsize = recvsize;
331
332         return 0;
333 }
334
335 /** FTP control channel operations */
336 static struct xfer_interface_operations ftp_control_operations = {
337         .close          = ftp_control_close,
338         .vredirect      = xfer_vreopen,
339         .window         = unlimited_xfer_window,
340         .alloc_iob      = default_xfer_alloc_iob,
341         .deliver_iob    = xfer_deliver_as_raw,
342         .deliver_raw    = ftp_control_deliver_raw,
343 };
344
345 /*****************************************************************************
346  *
347  * FTP data channel
348  *
349  */
350
351 /**
352  * Handle FTP data channel being closed
353  *
354  * @v data              FTP data channel interface
355  * @v rc                Reason for closure
356  *
357  * When the data channel is closed, the control channel should be left
358  * alone; the server will send a completion message via the control
359  * channel which we'll pick up.
360  *
361  * If the data channel is closed due to an error, we abort the request.
362  */
363 static void ftp_data_closed ( struct xfer_interface *data, int rc ) {
364         struct ftp_request *ftp =
365                 container_of ( data, struct ftp_request, data );
366
367         DBGC ( ftp, "FTP %p data connection closed: %s\n",
368                ftp, strerror ( rc ) );
369         
370         /* If there was an error, close control channel and record status */
371         if ( rc ) {
372                 ftp_done ( ftp, rc );
373         } else {
374                 ftp_next_state ( ftp );
375         }
376 }
377
378 /**
379  * Handle data delivery via FTP data channel
380  *
381  * @v xfer              FTP data channel interface
382  * @v iobuf             I/O buffer
383  * @v meta              Data transfer metadata
384  * @ret rc              Return status code
385  */
386 static int ftp_data_deliver_iob ( struct xfer_interface *data,
387                                   struct io_buffer *iobuf,
388                                   struct xfer_metadata *meta __unused ) {
389         struct ftp_request *ftp =
390                 container_of ( data, struct ftp_request, data );
391         int rc;
392
393         if ( ( rc = xfer_deliver_iob ( &ftp->xfer, iobuf ) ) != 0 ) {
394                 DBGC ( ftp, "FTP %p failed to deliver data: %s\n",
395                        ftp, strerror ( rc ) );
396                 return rc;
397         }
398
399         return 0;
400 }
401
402 /** FTP data channel operations */
403 static struct xfer_interface_operations ftp_data_operations = {
404         .close          = ftp_data_closed,
405         .vredirect      = xfer_vreopen,
406         .window         = unlimited_xfer_window,
407         .alloc_iob      = default_xfer_alloc_iob,
408         .deliver_iob    = ftp_data_deliver_iob,
409         .deliver_raw    = xfer_deliver_as_iob,
410 };
411
412 /*****************************************************************************
413  *
414  * Data transfer interface
415  *
416  */
417
418 /**
419  * Close FTP data transfer interface
420  *
421  * @v xfer              FTP data transfer interface
422  * @v rc                Reason for close
423  */
424 static void ftp_xfer_closed ( struct xfer_interface *xfer, int rc ) {
425         struct ftp_request *ftp =
426                 container_of ( xfer, struct ftp_request, xfer );
427
428         DBGC ( ftp, "FTP %p data transfer interface closed: %s\n",
429                ftp, strerror ( rc ) );
430         
431         ftp_done ( ftp, rc );
432 }
433
434 /** FTP data transfer interface operations */
435 static struct xfer_interface_operations ftp_xfer_operations = {
436         .close          = ftp_xfer_closed,
437         .vredirect      = ignore_xfer_vredirect,
438         .window         = unlimited_xfer_window,
439         .alloc_iob      = default_xfer_alloc_iob,
440         .deliver_iob    = xfer_deliver_as_raw,
441         .deliver_raw    = ignore_xfer_deliver_raw,
442 };
443
444 /*****************************************************************************
445  *
446  * URI opener
447  *
448  */
449
450 /**
451  * Initiate an FTP connection
452  *
453  * @v xfer              Data transfer interface
454  * @v uri               Uniform Resource Identifier
455  * @ret rc              Return status code
456  */
457 static int ftp_open ( struct xfer_interface *xfer, struct uri *uri ) {
458         struct ftp_request *ftp;
459         struct sockaddr_tcpip server;
460         int rc;
461
462         /* Sanity checks */
463         if ( ! uri->path )
464                 return -EINVAL;
465         if ( ! uri->host )
466                 return -EINVAL;
467
468         /* Allocate and populate structure */
469         ftp = zalloc ( sizeof ( *ftp ) );
470         if ( ! ftp )
471                 return -ENOMEM;
472         ftp->refcnt.free = ftp_free;
473         xfer_init ( &ftp->xfer, &ftp_xfer_operations, &ftp->refcnt );
474         ftp->uri = uri_get ( uri );
475         xfer_init ( &ftp->control, &ftp_control_operations, &ftp->refcnt );
476         xfer_init ( &ftp->data, &ftp_data_operations, &ftp->refcnt );
477         ftp->recvbuf = ftp->status_text;
478         ftp->recvsize = sizeof ( ftp->status_text ) - 1;
479
480         DBGC ( ftp, "FTP %p fetching %s\n", ftp, ftp->uri->path );
481
482         /* Open control connection */
483         memset ( &server, 0, sizeof ( server ) );
484         server.st_port = htons ( uri_port ( uri, FTP_PORT ) );
485         if ( ( rc = xfer_open_named_socket ( &ftp->control, SOCK_STREAM,
486                                              ( struct sockaddr * ) &server,
487                                              uri->host, NULL ) ) != 0 )
488                 goto err;
489
490         /* Attach to parent interface, mortalise self, and return */
491         xfer_plug_plug ( &ftp->xfer, xfer );
492         ref_put ( &ftp->refcnt );
493         return 0;
494
495  err:
496         DBGC ( ftp, "FTP %p could not create request: %s\n", 
497                ftp, strerror ( rc ) );
498         ftp_done ( ftp, rc );
499         ref_put ( &ftp->refcnt );
500         return rc;
501 }
502
503 /** FTP URI opener */
504 struct uri_opener ftp_uri_opener __uri_opener = {
505         .scheme = "ftp",
506         .open   = ftp_open,
507 };