3b88f7b6bb0c7dc5d2a75484bfe88666a7cdc907
[people/mcb30/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 /**
113  * FTP control channel strings
114  *
115  * These are used as printf() format strings.  Since only one of them
116  * (RETR) takes an argument, we always supply that argument to the
117  * snprintf() call.
118  */
119 static const char * ftp_strings[] = {
120         [FTP_CONNECT]   = NULL,
121         [FTP_USER]      = "USER anonymous\r\n",
122         [FTP_PASS]      = "PASS etherboot@etherboot.org\r\n",
123         [FTP_TYPE]      = "TYPE I\r\n",
124         [FTP_PASV]      = "PASV\r\n",
125         [FTP_RETR]      = "RETR %s\r\n",
126         [FTP_WAIT]      = NULL,
127         [FTP_QUIT]      = "QUIT\r\n",
128         [FTP_DONE]      = NULL,
129 };
130
131 /**
132  * Handle control channel being closed
133  *
134  * @v control           FTP control channel interface
135  * @v rc                Reason for close
136  *
137  * When the control channel is closed, the data channel must also be
138  * closed, if it is currently open.
139  */
140 static void ftp_control_close ( struct xfer_interface *control, int rc ) {
141         struct ftp_request *ftp =
142                 container_of ( control, struct ftp_request, control );
143
144         DBGC ( ftp, "FTP %p control connection closed: %s\n",
145                ftp, strerror ( rc ) );
146
147         /* Complete FTP operation */
148         ftp_done ( ftp, rc );
149 }
150
151 /**
152  * Parse FTP byte sequence value
153  *
154  * @v text              Text string
155  * @v value             Value buffer
156  * @v len               Length of value buffer
157  *
158  * This parses an FTP byte sequence value (e.g. the "aaa,bbb,ccc,ddd"
159  * form for IP addresses in PORT commands) into a byte sequence.  @c
160  * *text will be updated to point beyond the end of the parsed byte
161  * sequence.
162  *
163  * This function is safe in the presence of malformed data, though the
164  * output is undefined.
165  */
166 static void ftp_parse_value ( char **text, uint8_t *value, size_t len ) {
167         do {
168                 *(value++) = strtoul ( *text, text, 10 );
169                 if ( **text )
170                         (*text)++;
171         } while ( --len );
172 }
173
174 /**
175  * Move to next state and send the appropriate FTP control string
176  *
177  * @v ftp               FTP request
178  *
179  */
180 static void ftp_next_state ( struct ftp_request *ftp ) {
181
182         /* Move to next state */
183         if ( ftp->state < FTP_DONE )
184                 ftp->state++;
185
186         /* Send control string if needed */
187         if ( ftp_strings[ftp->state] != NULL ) {
188                 DBGC ( ftp, "FTP %p sending ", ftp );
189                 DBGC ( ftp, ftp_strings[ftp->state], ftp->uri->path );
190                 xfer_printf ( &ftp->control, ftp_strings[ftp->state],
191                               ftp->uri->path );
192         }       
193 }
194
195 /**
196  * Handle an FTP control channel response
197  *
198  * @v ftp               FTP request
199  *
200  * This is called once we have received a complete response line.
201  */
202 static void ftp_reply ( struct ftp_request *ftp ) {
203         char status_major = ftp->status_text[0];
204         char separator = ftp->status_text[3];
205
206         DBGC ( ftp, "FTP %p received status %s\n", ftp, ftp->status_text );
207
208         /* Ignore malformed lines */
209         if ( separator != ' ' )
210                 return;
211
212         /* Ignore "intermediate" responses (1xx codes) */
213         if ( status_major == '1' )
214                 return;
215
216         /* Anything other than success (2xx) or, in the case of a
217          * repsonse to a "USER" command, a password prompt (3xx), is a
218          * fatal error.
219          */
220         if ( ! ( ( status_major == '2' ) ||
221                  ( ( status_major == '3' ) && ( ftp->state == FTP_USER ) ) ) ){
222                 /* Flag protocol error and close connections */
223                 ftp_done ( ftp, -EPROTO );
224                 return;
225         }
226
227         /* Open passive connection when we get "PASV" response */
228         if ( ftp->state == FTP_PASV ) {
229                 char *ptr = ftp->passive_text;
230                 union {
231                         struct sockaddr_in sin;
232                         struct sockaddr sa;
233                 } sa;
234                 int rc;
235
236                 sa.sin.sin_family = AF_INET;
237                 ftp_parse_value ( &ptr, ( uint8_t * ) &sa.sin.sin_addr,
238                                   sizeof ( sa.sin.sin_addr ) );
239                 ftp_parse_value ( &ptr, ( uint8_t * ) &sa.sin.sin_port,
240                                   sizeof ( sa.sin.sin_port ) );
241                 if ( ( rc = xfer_open_socket ( &ftp->data, SOCK_STREAM,
242                                                &sa.sa, NULL ) ) != 0 ) {
243                         DBGC ( ftp, "FTP %p could not open data connection\n",
244                                ftp );
245                         ftp_done ( ftp, rc );
246                         return;
247                 }
248         }
249
250         /* Move to next state and send control string */
251         ftp_next_state ( ftp );
252         
253 }
254
255 /**
256  * Handle new data arriving on FTP control channel
257  *
258  * @v control           FTP control channel interface
259  * @v data              New data
260  * @v len               Length of new data
261  *
262  * Data is collected until a complete line is received, at which point
263  * its information is passed to ftp_reply().
264  */
265 static int ftp_control_deliver_raw ( struct xfer_interface *control,
266                                      const void *data, size_t len ) {
267         struct ftp_request *ftp =
268                 container_of ( control, struct ftp_request, control );
269         char *recvbuf = ftp->recvbuf;
270         size_t recvsize = ftp->recvsize;
271         char c;
272         
273         while ( len-- ) {
274                 c = * ( ( char * ) data++ );
275                 switch ( c ) {
276                 case '\r' :
277                 case '\n' :
278                         /* End of line: call ftp_reply() to handle
279                          * completed reply.  Avoid calling ftp_reply()
280                          * twice if we receive both \r and \n.
281                          */
282                         if ( recvsize == 0 )
283                                 ftp_reply ( ftp );
284                         /* Start filling up the status code buffer */
285                         recvbuf = ftp->status_text;
286                         recvsize = sizeof ( ftp->status_text ) - 1;
287                         break;
288                 case '(' :
289                         /* Start filling up the passive parameter buffer */
290                         recvbuf = ftp->passive_text;
291                         recvsize = sizeof ( ftp->passive_text ) - 1;
292                         break;
293                 case ')' :
294                         /* Stop filling the passive parameter buffer */
295                         recvsize = 0;
296                         break;
297                 default :
298                         /* Fill up buffer if applicable */
299                         if ( recvsize > 0 ) {
300                                 *(recvbuf++) = c;
301                                 recvsize--;
302                         }
303                         break;
304                 }
305         }
306
307         /* Store for next invocation */
308         ftp->recvbuf = recvbuf;
309         ftp->recvsize = recvsize;
310
311         return 0;
312 }
313
314 /** FTP control channel operations */
315 static struct xfer_interface_operations ftp_control_operations = {
316         .close          = ftp_control_close,
317         .vredirect      = xfer_vopen,
318         .window         = unlimited_xfer_window,
319         .alloc_iob      = default_xfer_alloc_iob,
320         .deliver_iob    = xfer_deliver_as_raw,
321         .deliver_raw    = ftp_control_deliver_raw,
322 };
323
324 /*****************************************************************************
325  *
326  * FTP data channel
327  *
328  */
329
330 /**
331  * Handle FTP data channel being closed
332  *
333  * @v data              FTP data channel interface
334  * @v rc                Reason for closure
335  *
336  * When the data channel is closed, the control channel should be left
337  * alone; the server will send a completion message via the control
338  * channel which we'll pick up.
339  *
340  * If the data channel is closed due to an error, we abort the request.
341  */
342 static void ftp_data_closed ( struct xfer_interface *data, int rc ) {
343         struct ftp_request *ftp =
344                 container_of ( data, struct ftp_request, data );
345
346         DBGC ( ftp, "FTP %p data connection closed: %s\n",
347                ftp, strerror ( rc ) );
348         
349         /* If there was an error, close control channel and record status */
350         if ( rc ) {
351                 ftp_done ( ftp, rc );
352         } else {
353                 ftp_next_state ( ftp );
354         }
355 }
356
357 /**
358  * Handle data delivery via FTP data channel
359  *
360  * @v xfer              FTP data channel interface
361  * @v iobuf             I/O buffer
362  * @v meta              Data transfer metadata, or NULL
363  * @ret rc              Return status code
364  */
365 static int ftp_data_deliver_iob ( struct xfer_interface *data,
366                                   struct io_buffer *iobuf,
367                                   struct xfer_metadata *meta __unused ) {
368         struct ftp_request *ftp =
369                 container_of ( data, struct ftp_request, data );
370         int rc;
371
372         if ( ( rc = xfer_deliver_iob ( &ftp->xfer, iobuf ) ) != 0 ) {
373                 DBGC ( ftp, "FTP %p failed to deliver data: %s\n",
374                        ftp, strerror ( rc ) );
375                 return rc;
376         }
377
378         return 0;
379 }
380
381 /** FTP data channel operations */
382 static struct xfer_interface_operations ftp_data_operations = {
383         .close          = ftp_data_closed,
384         .vredirect      = xfer_vopen,
385         .window         = unlimited_xfer_window,
386         .alloc_iob      = default_xfer_alloc_iob,
387         .deliver_iob    = ftp_data_deliver_iob,
388         .deliver_raw    = xfer_deliver_as_iob,
389 };
390
391 /*****************************************************************************
392  *
393  * Data transfer interface
394  *
395  */
396
397 /**
398  * Close FTP data transfer interface
399  *
400  * @v xfer              FTP data transfer interface
401  * @v rc                Reason for close
402  */
403 static void ftp_xfer_closed ( struct xfer_interface *xfer, int rc ) {
404         struct ftp_request *ftp =
405                 container_of ( xfer, struct ftp_request, xfer );
406
407         DBGC ( ftp, "FTP %p data transfer interface closed: %s\n",
408                ftp, strerror ( rc ) );
409         
410         ftp_done ( ftp, rc );
411 }
412
413 /** FTP data transfer interface operations */
414 static struct xfer_interface_operations ftp_xfer_operations = {
415         .close          = ftp_xfer_closed,
416         .vredirect      = ignore_xfer_vredirect,
417         .window         = unlimited_xfer_window,
418         .alloc_iob      = default_xfer_alloc_iob,
419         .deliver_iob    = xfer_deliver_as_raw,
420         .deliver_raw    = ignore_xfer_deliver_raw,
421 };
422
423 /*****************************************************************************
424  *
425  * URI opener
426  *
427  */
428
429 /**
430  * Initiate an FTP connection
431  *
432  * @v xfer              Data transfer interface
433  * @v uri               Uniform Resource Identifier
434  * @ret rc              Return status code
435  */
436 static int ftp_open ( struct xfer_interface *xfer, struct uri *uri ) {
437         struct ftp_request *ftp;
438         struct sockaddr_tcpip server;
439         int rc;
440
441         /* Sanity checks */
442         if ( ! uri->path )
443                 return -EINVAL;
444         if ( ! uri->host )
445                 return -EINVAL;
446
447         /* Allocate and populate structure */
448         ftp = zalloc ( sizeof ( *ftp ) );
449         if ( ! ftp )
450                 return -ENOMEM;
451         ftp->refcnt.free = ftp_free;
452         xfer_init ( &ftp->xfer, &ftp_xfer_operations, &ftp->refcnt );
453         ftp->uri = uri_get ( uri );
454         xfer_init ( &ftp->control, &ftp_control_operations, &ftp->refcnt );
455         xfer_init ( &ftp->data, &ftp_data_operations, &ftp->refcnt );
456         ftp->recvbuf = ftp->status_text;
457         ftp->recvsize = sizeof ( ftp->status_text ) - 1;
458
459         DBGC ( ftp, "FTP %p fetching %s\n", ftp, ftp->uri->path );
460
461         /* Open control connection */
462         memset ( &server, 0, sizeof ( server ) );
463         server.st_port = htons ( uri_port ( uri, FTP_PORT ) );
464         if ( ( rc = xfer_open_named_socket ( &ftp->control, SOCK_STREAM,
465                                              ( struct sockaddr * ) &server,
466                                              uri->host, NULL ) ) != 0 )
467                 goto err;
468
469         /* Attach to parent interface, mortalise self, and return */
470         xfer_plug_plug ( &ftp->xfer, xfer );
471         ref_put ( &ftp->refcnt );
472         return 0;
473
474  err:
475         DBGC ( ftp, "FTP %p could not create request: %s\n", 
476                ftp, strerror ( rc ) );
477         ftp_done ( ftp, rc );
478         ref_put ( &ftp->refcnt );
479         return rc;
480 }
481
482 /** FTP URI opener */
483 struct uri_opener ftp_uri_opener __uri_opener = {
484         .scheme = "ftp",
485         .open   = ftp_open,
486 };