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