e345a65d92bf8595c63b4687b9eafc4656032bce
[people/xl0/gpxe.git] / src / net / tcp / ftp.c
1 #include <stddef.h>
2 #include <stdlib.h>
3 #include <string.h>
4 #include <vsprintf.h>
5 #include <assert.h>
6 #include <errno.h>
7 #include <gpxe/async.h>
8 #include <gpxe/ftp.h>
9
10 /** @file
11  *
12  * File transfer protocol
13  *
14  */
15
16 /*****************************************************************************
17  *
18  * FTP control channel
19  *
20  */
21
22 /** An FTP control channel string */
23 struct ftp_string {
24         /** String format */
25         const char *format;
26         /** Offset to string data
27          *
28          * This is the offset within the struct ftp_request to the
29          * pointer to the string data.  Use ftp_string_data() to get a
30          * pointer to the actual data.
31          */
32         off_t data_offset;
33 };
34
35 /** FTP control channel strings */
36 static const struct ftp_string ftp_strings[] = {
37         [FTP_CONNECT]   = { "", 0 },
38         [FTP_USER]      = { "USER anonymous\r\n", 0 },
39         [FTP_PASS]      = { "PASS etherboot@etherboot.org\r\n", 0 },
40         [FTP_TYPE]      = { "TYPE I\r\n", 0 },
41         [FTP_PASV]      = { "PASV\r\n", 0 },
42         [FTP_RETR]      = { "RETR %s\r\n", 
43                             offsetof ( struct ftp_request, filename ) },
44         [FTP_QUIT]      = { "QUIT\r\n", 0 },
45         [FTP_DONE]      = { "", 0 },
46 };
47
48 /**
49  * Get data associated with an FTP control channel string
50  *
51  * @v ftp               FTP request
52  * @v data_offset       Data offset field from ftp_string structure
53  * @ret data            Pointer to data
54  */
55 static inline const void * ftp_string_data ( struct ftp_request *ftp,
56                                              off_t data_offset ) {
57         return * ( ( void ** ) ( ( ( void * ) ftp ) + data_offset ) );
58 }
59
60 /**
61  * Get FTP request from control TCP application
62  *
63  * @v app               TCP application
64  * @ret ftp             FTP request
65  */
66 static inline struct ftp_request * tcp_to_ftp ( struct tcp_application *app ) {
67         return container_of ( app, struct ftp_request, tcp );
68 }
69
70 /**
71  * Mark FTP operation as complete
72  *
73  * @v ftp               FTP request
74  * @v rc                Return status code
75  */
76 static void ftp_done ( struct ftp_request *ftp, int rc ) {
77
78         DBGC ( ftp, "FTP %p completed with status %d\n", ftp, rc );
79
80         /* Close both TCP connections */
81         tcp_close ( &ftp->tcp );
82         tcp_close ( &ftp->tcp_data );
83
84         /* Mark asynchronous operation as complete */
85         async_done ( &ftp->aop, rc );
86 }
87
88 /**
89  * Parse FTP byte sequence value
90  *
91  * @v text      Text string
92  * @v value     Value buffer
93  * @v len       Length of value buffer
94  *
95  * This parses an FTP byte sequence value (e.g. the "aaa,bbb,ccc,ddd"
96  * form for IP addresses in PORT commands) into a byte sequence.  @c
97  * *text will be updated to point beyond the end of the parsed byte
98  * sequence.
99  *
100  * This function is safe in the presence of malformed data, though the
101  * output is undefined.
102  */
103 static void ftp_parse_value ( char **text, uint8_t *value, size_t len ) {
104         do {
105                 *(value++) = strtoul ( *text, text, 10 );
106                 if ( **text )
107                         (*text)++;
108         } while ( --len );
109 }
110
111 /**
112  * Handle an FTP control channel response
113  *
114  * @v ftp       FTP request
115  *
116  * This is called once we have received a complete response line.
117  */
118 static void ftp_reply ( struct ftp_request *ftp ) {
119         char status_major = ftp->status_text[0];
120
121         DBGC ( ftp, "FTP %p received status %s\n", ftp, ftp->status_text );
122
123         /* Ignore "intermediate" responses (1xx codes) */
124         if ( status_major == '1' )
125                 return;
126
127         /* Anything other than success (2xx) or, in the case of a
128          * repsonse to a "USER" command, a password prompt (3xx), is a
129          * fatal error.
130          */
131         if ( ! ( ( status_major == '2' ) ||
132                  ( ( status_major == '3' ) && ( ftp->state == FTP_USER ) ) ) ){
133                 /* Flag protocol error and close connections */
134                 ftp_done ( ftp, -EPROTO );
135         }
136
137         /* Open passive connection when we get "PASV" response */
138         if ( ftp->state == FTP_PASV ) {
139                 char *ptr = ftp->passive_text;
140                 union {
141                         struct sockaddr_in sin;
142                         struct sockaddr_tcpip st;
143                 } sa;
144                 int rc;
145
146                 sa.sin.sin_family = AF_INET;
147                 ftp_parse_value ( &ptr, ( uint8_t * ) &sa.sin.sin_addr,
148                                   sizeof ( sa.sin.sin_addr ) );
149                 ftp_parse_value ( &ptr, ( uint8_t * ) &sa.sin.sin_port,
150                                   sizeof ( sa.sin.sin_port ) );
151                 if ( ( rc = tcp_connect ( &ftp->tcp_data, &sa.st, 0 ) ) != 0 ){
152                         DBGC ( ftp, "FTP %p could not make data connection\n",
153                                ftp );
154                         ftp_done ( ftp, rc );
155                         return;
156                 }
157         }
158
159         /* Move to next state */
160         if ( ftp->state < FTP_DONE )
161                 ftp->state++;
162         ftp->already_sent = 0;
163
164         if ( ftp->state < FTP_DONE ) {
165                 const struct ftp_string *string = &ftp_strings[ftp->state];
166                 DBGC ( ftp, "FTP %p sending ", ftp );
167                 DBGC ( ftp, string->format,
168                        ftp_string_data ( ftp, string->data_offset ) );
169         }
170
171         return;
172 }
173
174 /**
175  * Handle new data arriving on FTP control channel
176  *
177  * @v app       TCP application
178  * @v data      New data
179  * @v len       Length of new data
180  *
181  * Data is collected until a complete line is received, at which point
182  * its information is passed to ftp_reply().
183  */
184 static void ftp_newdata ( struct tcp_application *app,
185                           void *data, size_t len ) {
186         struct ftp_request *ftp = tcp_to_ftp ( app );
187         char *recvbuf = ftp->recvbuf;
188         size_t recvsize = ftp->recvsize;
189         char c;
190         
191         while ( len-- ) {
192                 c = * ( ( char * ) data++ );
193                 switch ( c ) {
194                 case '\r' :
195                 case '\n' :
196                         /* End of line: call ftp_reply() to handle
197                          * completed reply.  Avoid calling ftp_reply()
198                          * twice if we receive both \r and \n.
199                          */
200                         if ( recvsize == 0 )
201                                 ftp_reply ( ftp );
202                         /* Start filling up the status code buffer */
203                         recvbuf = ftp->status_text;
204                         recvsize = sizeof ( ftp->status_text ) - 1;
205                         break;
206                 case '(' :
207                         /* Start filling up the passive parameter buffer */
208                         recvbuf = ftp->passive_text;
209                         recvsize = sizeof ( ftp->passive_text ) - 1;
210                         break;
211                 case ')' :
212                         /* Stop filling the passive parameter buffer */
213                         recvsize = 0;
214                         break;
215                 default :
216                         /* Fill up buffer if applicable */
217                         if ( recvsize > 0 ) {
218                                 *(recvbuf++) = c;
219                                 recvsize--;
220                         }
221                         break;
222                 }
223         }
224
225         /* Store for next invocation */
226         ftp->recvbuf = recvbuf;
227         ftp->recvsize = recvsize;
228 }
229
230 /**
231  * Handle acknowledgement of data sent on FTP control channel
232  *
233  * @v app       TCP application
234  */
235 static void ftp_acked ( struct tcp_application *app, size_t len ) {
236         struct ftp_request *ftp = tcp_to_ftp ( app );
237         
238         /* Mark off ACKed portion of the currently-transmitted data */
239         ftp->already_sent += len;
240 }
241
242 /**
243  * Construct data to send on FTP control channel
244  *
245  * @v app       TCP application
246  * @v buf       Temporary data buffer
247  * @v len       Length of temporary data buffer
248  */
249 static void ftp_senddata ( struct tcp_application *app,
250                            void *buf, size_t len ) {
251         struct ftp_request *ftp = tcp_to_ftp ( app );
252         const struct ftp_string *string;
253
254         /* Send the as-yet-unACKed portion of the string for the
255          * current state.
256          */
257         string = &ftp_strings[ftp->state];
258         len = snprintf ( buf, len, string->format,
259                          ftp_string_data ( ftp, string->data_offset ) );
260         tcp_send ( app, buf + ftp->already_sent, len - ftp->already_sent );
261 }
262
263 /**
264  * Handle control channel being closed
265  *
266  * @v app               TCP application
267  *
268  * When the control channel is closed, the data channel must also be
269  * closed, if it is currently open.
270  */
271 static void ftp_closed ( struct tcp_application *app, int status ) {
272         struct ftp_request *ftp = tcp_to_ftp ( app );
273
274         DBGC ( ftp, "FTP %p control connection closed (status %d)\n",
275                ftp, status );
276
277         /* Complete FTP operation */
278         ftp_done ( ftp, status );
279 }
280
281 /** FTP control channel operations */
282 static struct tcp_operations ftp_tcp_operations = {
283         .closed         = ftp_closed,
284         .acked          = ftp_acked,
285         .newdata        = ftp_newdata,
286         .senddata       = ftp_senddata,
287 };
288
289 /*****************************************************************************
290  *
291  * FTP data channel
292  *
293  */
294
295 /**
296  * Get FTP request from data TCP application
297  *
298  * @v app               TCP application
299  * @ret ftp             FTP request
300  */
301 static inline struct ftp_request *
302 tcp_to_ftp_data ( struct tcp_application *app ) {
303         return container_of ( app, struct ftp_request, tcp_data );
304 }
305
306 /**
307  * Handle data channel being closed
308  *
309  * @v app               TCP application
310  *
311  * When the data channel is closed, the control channel should be left
312  * alone; the server will send a completion message via the control
313  * channel which we'll pick up.
314  *
315  * If the data channel is closed due to an error, we abort the request.
316  */
317 static void ftp_data_closed ( struct tcp_application *app, int status ) {
318         struct ftp_request *ftp = tcp_to_ftp_data ( app );
319
320         DBGC ( ftp, "FTP %p data connection closed (status %d)\n",
321                ftp, status );
322         
323         /* If there was an error, close control channel and record status */
324         if ( status )
325                 ftp_done ( ftp, status );
326 }
327
328 /**
329  * Handle new data arriving on the FTP data channel
330  *
331  * @v app       TCP application
332  * @v data      New data
333  * @v len       Length of new data
334  *
335  * Data is handed off to the callback registered in the FTP request.
336  */
337 static void ftp_data_newdata ( struct tcp_application *app,
338                                void *data, size_t len ) {
339         struct ftp_request *ftp = tcp_to_ftp_data ( app );
340
341         ftp->callback ( data, len );
342 }
343
344 /** FTP data channel operations */
345 static struct tcp_operations ftp_data_tcp_operations = {
346         .closed         = ftp_data_closed,
347         .newdata        = ftp_data_newdata,
348 };
349
350 /*****************************************************************************
351  *
352  * API
353  *
354  */
355
356 /**
357  * Initiate an FTP connection
358  *
359  * @v ftp       FTP request
360  */
361 struct async_operation * ftp_get ( struct ftp_request *ftp ) {
362         int rc;
363
364         DBGC ( ftp, "FTP %p fetching %s\n", ftp, ftp->filename );
365
366         ftp->tcp.tcp_op = &ftp_tcp_operations;
367         ftp->tcp_data.tcp_op = &ftp_data_tcp_operations;
368         ftp->recvbuf = ftp->status_text;
369         ftp->recvsize = sizeof ( ftp->status_text ) - 1;
370         if ( ( rc = tcp_connect ( &ftp->tcp, &ftp->server, 0 ) ) != 0 )
371                 ftp_done ( ftp, rc );
372
373         return &ftp->aop;
374 }