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 }