gpxe/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 };