1 /*************************************************************************** 2 * _ _ ____ _ 3 * Project ___| | | | _ \| | 4 * / __| | | | |_) | | 5 * | (__| |_| | _ <| |___ 6 * \___|\___/|_| \_\_____| 7 * 8 * Copyright (C) 1998 - 2015, Daniel Stenberg, <daniel (at) haxx.se>, et al. 9 * 10 * This software is licensed as described in the file COPYING, which 11 * you should have received as part of this distribution. The terms 12 * are also available at http://curl.haxx.se/docs/copyright.html. 13 * 14 * You may opt to use, copy, modify, merge, publish, distribute and/or sell 15 * copies of the Software, and permit persons to whom the Software is 16 * furnished to do so, under the terms of the COPYING file. 17 * 18 * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY 19 * KIND, either express or implied. 20 * 21 ***************************************************************************/ 22 23 #include "curl_setup.h" 24 25 #ifndef CURL_DISABLE_FTP 26 27 #ifdef HAVE_NETINET_IN_H 28 #include <netinet/in.h> 29 #endif 30 #ifdef HAVE_ARPA_INET_H 31 #include <arpa/inet.h> 32 #endif 33 #ifdef HAVE_UTSNAME_H 34 #include <sys/utsname.h> 35 #endif 36 #ifdef HAVE_NETDB_H 37 #include <netdb.h> 38 #endif 39 #ifdef __VMS 40 #include <in.h> 41 #include <inet.h> 42 #endif 43 44 #if (defined(NETWARE) && defined(__NOVELL_LIBC__)) 45 #undef in_addr_t 46 #define in_addr_t unsigned long 47 #endif 48 49 #include <curl/curl.h> 50 #include "urldata.h" 51 #include "sendf.h" 52 #include "if2ip.h" 53 #include "hostip.h" 54 #include "progress.h" 55 #include "transfer.h" 56 #include "escape.h" 57 #include "http.h" /* for HTTP proxy tunnel stuff */ 58 #include "socks.h" 59 #include "ftp.h" 60 #include "fileinfo.h" 61 #include "ftplistparser.h" 62 #include "curl_sec.h" 63 #include "strtoofft.h" 64 #include "strequal.h" 65 #include "vtls/vtls.h" 66 #include "connect.h" 67 #include "strerror.h" 68 #include "inet_ntop.h" 69 #include "inet_pton.h" 70 #include "select.h" 71 #include "parsedate.h" /* for the week day and month names */ 72 #include "sockaddr.h" /* required for Curl_sockaddr_storage */ 73 #include "multiif.h" 74 #include "url.h" 75 #include "rawstr.h" 76 #include "speedcheck.h" 77 #include "warnless.h" 78 #include "http_proxy.h" 79 #include "non-ascii.h" 80 #include "curl_printf.h" 81 82 #include "curl_memory.h" 83 /* The last #include file should be: */ 84 #include "memdebug.h" 85 86 #ifndef NI_MAXHOST 87 #define NI_MAXHOST 1025 88 #endif 89 #ifndef INET_ADDRSTRLEN 90 #define INET_ADDRSTRLEN 16 91 #endif 92 93 #ifdef CURL_DISABLE_VERBOSE_STRINGS 94 #define ftp_pasv_verbose(a,b,c,d) Curl_nop_stmt 95 #endif 96 97 /* Local API functions */ 98 #ifndef DEBUGBUILD 99 static void _state(struct connectdata *conn, 100 ftpstate newstate); 101 #define state(x,y) _state(x,y) 102 #else 103 static void _state(struct connectdata *conn, 104 ftpstate newstate, 105 int lineno); 106 #define state(x,y) _state(x,y,__LINE__) 107 #endif 108 109 static CURLcode ftp_sendquote(struct connectdata *conn, 110 struct curl_slist *quote); 111 static CURLcode ftp_quit(struct connectdata *conn); 112 static CURLcode ftp_parse_url_path(struct connectdata *conn); 113 static CURLcode ftp_regular_transfer(struct connectdata *conn, bool *done); 114 #ifndef CURL_DISABLE_VERBOSE_STRINGS 115 static void ftp_pasv_verbose(struct connectdata *conn, 116 Curl_addrinfo *ai, 117 char *newhost, /* ascii version */ 118 int port); 119 #endif 120 static CURLcode ftp_state_prepare_transfer(struct connectdata *conn); 121 static CURLcode ftp_state_mdtm(struct connectdata *conn); 122 static CURLcode ftp_state_quote(struct connectdata *conn, 123 bool init, ftpstate instate); 124 static CURLcode ftp_nb_type(struct connectdata *conn, 125 bool ascii, ftpstate newstate); 126 static int ftp_need_type(struct connectdata *conn, 127 bool ascii); 128 static CURLcode ftp_do(struct connectdata *conn, bool *done); 129 static CURLcode ftp_done(struct connectdata *conn, 130 CURLcode, bool premature); 131 static CURLcode ftp_connect(struct connectdata *conn, bool *done); 132 static CURLcode ftp_disconnect(struct connectdata *conn, bool dead_connection); 133 static CURLcode ftp_do_more(struct connectdata *conn, int *completed); 134 static CURLcode ftp_multi_statemach(struct connectdata *conn, bool *done); 135 static int ftp_getsock(struct connectdata *conn, curl_socket_t *socks, 136 int numsocks); 137 static int ftp_domore_getsock(struct connectdata *conn, curl_socket_t *socks, 138 int numsocks); 139 static CURLcode ftp_doing(struct connectdata *conn, 140 bool *dophase_done); 141 static CURLcode ftp_setup_connection(struct connectdata * conn); 142 143 static CURLcode init_wc_data(struct connectdata *conn); 144 static CURLcode wc_statemach(struct connectdata *conn); 145 146 static void wc_data_dtor(void *ptr); 147 148 static CURLcode ftp_state_retr(struct connectdata *conn, curl_off_t filesize); 149 150 static CURLcode ftp_readresp(curl_socket_t sockfd, 151 struct pingpong *pp, 152 int *ftpcode, 153 size_t *size); 154 static CURLcode ftp_dophase_done(struct connectdata *conn, 155 bool connected); 156 157 /* easy-to-use macro: */ 158 #define PPSENDF(x,y,z) if((result = Curl_pp_sendf(x,y,z))) \ 159 return result 160 161 162 /* 163 * FTP protocol handler. 164 */ 165 166 const struct Curl_handler Curl_handler_ftp = { 167 "FTP", /* scheme */ 168 ftp_setup_connection, /* setup_connection */ 169 ftp_do, /* do_it */ 170 ftp_done, /* done */ 171 ftp_do_more, /* do_more */ 172 ftp_connect, /* connect_it */ 173 ftp_multi_statemach, /* connecting */ 174 ftp_doing, /* doing */ 175 ftp_getsock, /* proto_getsock */ 176 ftp_getsock, /* doing_getsock */ 177 ftp_domore_getsock, /* domore_getsock */ 178 ZERO_NULL, /* perform_getsock */ 179 ftp_disconnect, /* disconnect */ 180 ZERO_NULL, /* readwrite */ 181 PORT_FTP, /* defport */ 182 CURLPROTO_FTP, /* protocol */ 183 PROTOPT_DUAL | PROTOPT_CLOSEACTION | PROTOPT_NEEDSPWD 184 | PROTOPT_NOURLQUERY /* flags */ 185 }; 186 187 188 #ifdef USE_SSL 189 /* 190 * FTPS protocol handler. 191 */ 192 193 const struct Curl_handler Curl_handler_ftps = { 194 "FTPS", /* scheme */ 195 ftp_setup_connection, /* setup_connection */ 196 ftp_do, /* do_it */ 197 ftp_done, /* done */ 198 ftp_do_more, /* do_more */ 199 ftp_connect, /* connect_it */ 200 ftp_multi_statemach, /* connecting */ 201 ftp_doing, /* doing */ 202 ftp_getsock, /* proto_getsock */ 203 ftp_getsock, /* doing_getsock */ 204 ftp_domore_getsock, /* domore_getsock */ 205 ZERO_NULL, /* perform_getsock */ 206 ftp_disconnect, /* disconnect */ 207 ZERO_NULL, /* readwrite */ 208 PORT_FTPS, /* defport */ 209 CURLPROTO_FTPS, /* protocol */ 210 PROTOPT_SSL | PROTOPT_DUAL | PROTOPT_CLOSEACTION | 211 PROTOPT_NEEDSPWD | PROTOPT_NOURLQUERY /* flags */ 212 }; 213 #endif 214 215 #ifndef CURL_DISABLE_HTTP 216 /* 217 * HTTP-proxyed FTP protocol handler. 218 */ 219 220 static const struct Curl_handler Curl_handler_ftp_proxy = { 221 "FTP", /* scheme */ 222 Curl_http_setup_conn, /* setup_connection */ 223 Curl_http, /* do_it */ 224 Curl_http_done, /* done */ 225 ZERO_NULL, /* do_more */ 226 ZERO_NULL, /* connect_it */ 227 ZERO_NULL, /* connecting */ 228 ZERO_NULL, /* doing */ 229 ZERO_NULL, /* proto_getsock */ 230 ZERO_NULL, /* doing_getsock */ 231 ZERO_NULL, /* domore_getsock */ 232 ZERO_NULL, /* perform_getsock */ 233 ZERO_NULL, /* disconnect */ 234 ZERO_NULL, /* readwrite */ 235 PORT_FTP, /* defport */ 236 CURLPROTO_HTTP, /* protocol */ 237 PROTOPT_NONE /* flags */ 238 }; 239 240 241 #ifdef USE_SSL 242 /* 243 * HTTP-proxyed FTPS protocol handler. 244 */ 245 246 static const struct Curl_handler Curl_handler_ftps_proxy = { 247 "FTPS", /* scheme */ 248 Curl_http_setup_conn, /* setup_connection */ 249 Curl_http, /* do_it */ 250 Curl_http_done, /* done */ 251 ZERO_NULL, /* do_more */ 252 ZERO_NULL, /* connect_it */ 253 ZERO_NULL, /* connecting */ 254 ZERO_NULL, /* doing */ 255 ZERO_NULL, /* proto_getsock */ 256 ZERO_NULL, /* doing_getsock */ 257 ZERO_NULL, /* domore_getsock */ 258 ZERO_NULL, /* perform_getsock */ 259 ZERO_NULL, /* disconnect */ 260 ZERO_NULL, /* readwrite */ 261 PORT_FTPS, /* defport */ 262 CURLPROTO_HTTP, /* protocol */ 263 PROTOPT_NONE /* flags */ 264 }; 265 #endif 266 #endif 267 268 269 /* 270 * NOTE: back in the old days, we added code in the FTP code that made NOBODY 271 * requests on files respond with headers passed to the client/stdout that 272 * looked like HTTP ones. 273 * 274 * This approach is not very elegant, it causes confusion and is error-prone. 275 * It is subject for removal at the next (or at least a future) soname bump. 276 * Until then you can test the effects of the removal by undefining the 277 * following define named CURL_FTP_HTTPSTYLE_HEAD. 278 */ 279 #define CURL_FTP_HTTPSTYLE_HEAD 1 280 281 static void freedirs(struct ftp_conn *ftpc) 282 { 283 int i; 284 if(ftpc->dirs) { 285 for(i=0; i < ftpc->dirdepth; i++) { 286 free(ftpc->dirs[i]); 287 ftpc->dirs[i]=NULL; 288 } 289 free(ftpc->dirs); 290 ftpc->dirs = NULL; 291 ftpc->dirdepth = 0; 292 } 293 Curl_safefree(ftpc->file); 294 295 /* no longer of any use */ 296 Curl_safefree(ftpc->newhost); 297 } 298 299 /* Returns non-zero if the given string contains CR (\r) or LF (\n), 300 which are not allowed within RFC 959 <string>. 301 Note: The input string is in the client's encoding which might 302 not be ASCII, so escape sequences \r & \n must be used instead 303 of hex values 0x0d & 0x0a. 304 */ 305 static bool isBadFtpString(const char *string) 306 { 307 return ((NULL != strchr(string, '\r')) || 308 (NULL != strchr(string, '\n'))) ? TRUE : FALSE; 309 } 310 311 /*********************************************************************** 312 * 313 * AcceptServerConnect() 314 * 315 * After connection request is received from the server this function is 316 * called to accept the connection and close the listening socket 317 * 318 */ 319 static CURLcode AcceptServerConnect(struct connectdata *conn) 320 { 321 struct SessionHandle *data = conn->data; 322 curl_socket_t sock = conn->sock[SECONDARYSOCKET]; 323 curl_socket_t s = CURL_SOCKET_BAD; 324 #ifdef ENABLE_IPV6 325 struct Curl_sockaddr_storage add; 326 #else 327 struct sockaddr_in add; 328 #endif 329 curl_socklen_t size = (curl_socklen_t) sizeof(add); 330 331 if(0 == getsockname(sock, (struct sockaddr *) &add, &size)) { 332 size = sizeof(add); 333 334 s=accept(sock, (struct sockaddr *) &add, &size); 335 } 336 Curl_closesocket(conn, sock); /* close the first socket */ 337 338 if(CURL_SOCKET_BAD == s) { 339 failf(data, "Error accept()ing server connect"); 340 return CURLE_FTP_PORT_FAILED; 341 } 342 infof(data, "Connection accepted from server\n"); 343 344 conn->sock[SECONDARYSOCKET] = s; 345 (void)curlx_nonblock(s, TRUE); /* enable non-blocking */ 346 conn->sock_accepted[SECONDARYSOCKET] = TRUE; 347 348 if(data->set.fsockopt) { 349 int error = 0; 350 351 /* activate callback for setting socket options */ 352 error = data->set.fsockopt(data->set.sockopt_client, 353 s, 354 CURLSOCKTYPE_ACCEPT); 355 356 if(error) { 357 Curl_closesocket(conn, s); /* close the socket and bail out */ 358 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; 359 return CURLE_ABORTED_BY_CALLBACK; 360 } 361 } 362 363 return CURLE_OK; 364 365 } 366 367 /* 368 * ftp_timeleft_accept() returns the amount of milliseconds left allowed for 369 * waiting server to connect. If the value is negative, the timeout time has 370 * already elapsed. 371 * 372 * The start time is stored in progress.t_acceptdata - as set with 373 * Curl_pgrsTime(..., TIMER_STARTACCEPT); 374 * 375 */ 376 static long ftp_timeleft_accept(struct SessionHandle *data) 377 { 378 long timeout_ms = DEFAULT_ACCEPT_TIMEOUT; 379 long other; 380 struct timeval now; 381 382 if(data->set.accepttimeout > 0) 383 timeout_ms = data->set.accepttimeout; 384 385 now = Curl_tvnow(); 386 387 /* check if the generic timeout possibly is set shorter */ 388 other = Curl_timeleft(data, &now, FALSE); 389 if(other && (other < timeout_ms)) 390 /* note that this also works fine for when other happens to be negative 391 due to it already having elapsed */ 392 timeout_ms = other; 393 else { 394 /* subtract elapsed time */ 395 timeout_ms -= Curl_tvdiff(now, data->progress.t_acceptdata); 396 if(!timeout_ms) 397 /* avoid returning 0 as that means no timeout! */ 398 return -1; 399 } 400 401 return timeout_ms; 402 } 403 404 405 /*********************************************************************** 406 * 407 * ReceivedServerConnect() 408 * 409 * After allowing server to connect to us from data port, this function 410 * checks both data connection for connection establishment and ctrl 411 * connection for a negative response regarding a failure in connecting 412 * 413 */ 414 static CURLcode ReceivedServerConnect(struct connectdata *conn, bool *received) 415 { 416 struct SessionHandle *data = conn->data; 417 curl_socket_t ctrl_sock = conn->sock[FIRSTSOCKET]; 418 curl_socket_t data_sock = conn->sock[SECONDARYSOCKET]; 419 struct ftp_conn *ftpc = &conn->proto.ftpc; 420 struct pingpong *pp = &ftpc->pp; 421 int result; 422 long timeout_ms; 423 ssize_t nread; 424 int ftpcode; 425 426 *received = FALSE; 427 428 timeout_ms = ftp_timeleft_accept(data); 429 infof(data, "Checking for server connect\n"); 430 if(timeout_ms < 0) { 431 /* if a timeout was already reached, bail out */ 432 failf(data, "Accept timeout occurred while waiting server connect"); 433 return CURLE_FTP_ACCEPT_TIMEOUT; 434 } 435 436 /* First check whether there is a cached response from server */ 437 if(pp->cache_size && pp->cache && pp->cache[0] > '3') { 438 /* Data connection could not be established, let's return */ 439 infof(data, "There is negative response in cache while serv connect\n"); 440 Curl_GetFTPResponse(&nread, conn, &ftpcode); 441 return CURLE_FTP_ACCEPT_FAILED; 442 } 443 444 result = Curl_socket_check(ctrl_sock, data_sock, CURL_SOCKET_BAD, 0); 445 446 /* see if the connection request is already here */ 447 switch (result) { 448 case -1: /* error */ 449 /* let's die here */ 450 failf(data, "Error while waiting for server connect"); 451 return CURLE_FTP_ACCEPT_FAILED; 452 case 0: /* Server connect is not received yet */ 453 break; /* loop */ 454 default: 455 456 if(result & CURL_CSELECT_IN2) { 457 infof(data, "Ready to accept data connection from server\n"); 458 *received = TRUE; 459 } 460 else if(result & CURL_CSELECT_IN) { 461 infof(data, "Ctrl conn has data while waiting for data conn\n"); 462 Curl_GetFTPResponse(&nread, conn, &ftpcode); 463 464 if(ftpcode/100 > 3) 465 return CURLE_FTP_ACCEPT_FAILED; 466 467 return CURLE_FTP_WEIRD_SERVER_REPLY; 468 } 469 470 break; 471 } /* switch() */ 472 473 return CURLE_OK; 474 } 475 476 477 /*********************************************************************** 478 * 479 * InitiateTransfer() 480 * 481 * After connection from server is accepted this function is called to 482 * setup transfer parameters and initiate the data transfer. 483 * 484 */ 485 static CURLcode InitiateTransfer(struct connectdata *conn) 486 { 487 struct SessionHandle *data = conn->data; 488 struct FTP *ftp = data->req.protop; 489 CURLcode result = CURLE_OK; 490 491 if(conn->ssl[SECONDARYSOCKET].use) { 492 /* since we only have a plaintext TCP connection here, we must now 493 * do the TLS stuff */ 494 infof(data, "Doing the SSL/TLS handshake on the data stream\n"); 495 result = Curl_ssl_connect(conn, SECONDARYSOCKET); 496 if(result) 497 return result; 498 } 499 500 if(conn->proto.ftpc.state_saved == FTP_STOR) { 501 *(ftp->bytecountp)=0; 502 503 /* When we know we're uploading a specified file, we can get the file 504 size prior to the actual upload. */ 505 506 Curl_pgrsSetUploadSize(data, data->state.infilesize); 507 508 /* set the SO_SNDBUF for the secondary socket for those who need it */ 509 Curl_sndbufset(conn->sock[SECONDARYSOCKET]); 510 511 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, /* no download */ 512 SECONDARYSOCKET, ftp->bytecountp); 513 } 514 else { 515 /* FTP download: */ 516 Curl_setup_transfer(conn, SECONDARYSOCKET, 517 conn->proto.ftpc.retr_size_saved, FALSE, 518 ftp->bytecountp, -1, NULL); /* no upload here */ 519 } 520 521 conn->proto.ftpc.pp.pending_resp = TRUE; /* expect server response */ 522 state(conn, FTP_STOP); 523 524 return CURLE_OK; 525 } 526 527 /*********************************************************************** 528 * 529 * AllowServerConnect() 530 * 531 * When we've issue the PORT command, we have told the server to connect to 532 * us. This function checks whether data connection is established if so it is 533 * accepted. 534 * 535 */ 536 static CURLcode AllowServerConnect(struct connectdata *conn, bool *connected) 537 { 538 struct SessionHandle *data = conn->data; 539 long timeout_ms; 540 CURLcode result = CURLE_OK; 541 542 *connected = FALSE; 543 infof(data, "Preparing for accepting server on data port\n"); 544 545 /* Save the time we start accepting server connect */ 546 Curl_pgrsTime(data, TIMER_STARTACCEPT); 547 548 timeout_ms = ftp_timeleft_accept(data); 549 if(timeout_ms < 0) { 550 /* if a timeout was already reached, bail out */ 551 failf(data, "Accept timeout occurred while waiting server connect"); 552 return CURLE_FTP_ACCEPT_TIMEOUT; 553 } 554 555 /* see if the connection request is already here */ 556 result = ReceivedServerConnect(conn, connected); 557 if(result) 558 return result; 559 560 if(*connected) { 561 result = AcceptServerConnect(conn); 562 if(result) 563 return result; 564 565 result = InitiateTransfer(conn); 566 if(result) 567 return result; 568 } 569 else { 570 /* Add timeout to multi handle and break out of the loop */ 571 if(!result && *connected == FALSE) { 572 if(data->set.accepttimeout > 0) 573 Curl_expire(data, data->set.accepttimeout); 574 else 575 Curl_expire(data, DEFAULT_ACCEPT_TIMEOUT); 576 } 577 } 578 579 return result; 580 } 581 582 /* macro to check for a three-digit ftp status code at the start of the 583 given string */ 584 #define STATUSCODE(line) (ISDIGIT(line[0]) && ISDIGIT(line[1]) && \ 585 ISDIGIT(line[2])) 586 587 /* macro to check for the last line in an FTP server response */ 588 #define LASTLINE(line) (STATUSCODE(line) && (' ' == line[3])) 589 590 static bool ftp_endofresp(struct connectdata *conn, char *line, size_t len, 591 int *code) 592 { 593 (void)conn; 594 595 if((len > 3) && LASTLINE(line)) { 596 *code = curlx_sltosi(strtol(line, NULL, 10)); 597 return TRUE; 598 } 599 600 return FALSE; 601 } 602 603 static CURLcode ftp_readresp(curl_socket_t sockfd, 604 struct pingpong *pp, 605 int *ftpcode, /* return the ftp-code if done */ 606 size_t *size) /* size of the response */ 607 { 608 struct connectdata *conn = pp->conn; 609 struct SessionHandle *data = conn->data; 610 #ifdef HAVE_GSSAPI 611 char * const buf = data->state.buffer; 612 #endif 613 CURLcode result = CURLE_OK; 614 int code; 615 616 result = Curl_pp_readresp(sockfd, pp, &code, size); 617 618 #if defined(HAVE_GSSAPI) 619 /* handle the security-oriented responses 6xx ***/ 620 /* FIXME: some errorchecking perhaps... ***/ 621 switch(code) { 622 case 631: 623 code = Curl_sec_read_msg(conn, buf, PROT_SAFE); 624 break; 625 case 632: 626 code = Curl_sec_read_msg(conn, buf, PROT_PRIVATE); 627 break; 628 case 633: 629 code = Curl_sec_read_msg(conn, buf, PROT_CONFIDENTIAL); 630 break; 631 default: 632 /* normal ftp stuff we pass through! */ 633 break; 634 } 635 #endif 636 637 /* store the latest code for later retrieval */ 638 data->info.httpcode=code; 639 640 if(ftpcode) 641 *ftpcode = code; 642 643 if(421 == code) { 644 /* 421 means "Service not available, closing control connection." and FTP 645 * servers use it to signal that idle session timeout has been exceeded. 646 * If we ignored the response, it could end up hanging in some cases. 647 * 648 * This response code can come at any point so having it treated 649 * generically is a good idea. 650 */ 651 infof(data, "We got a 421 - timeout!\n"); 652 state(conn, FTP_STOP); 653 return CURLE_OPERATION_TIMEDOUT; 654 } 655 656 return result; 657 } 658 659 /* --- parse FTP server responses --- */ 660 661 /* 662 * Curl_GetFTPResponse() is a BLOCKING function to read the full response 663 * from a server after a command. 664 * 665 */ 666 667 CURLcode Curl_GetFTPResponse(ssize_t *nreadp, /* return number of bytes read */ 668 struct connectdata *conn, 669 int *ftpcode) /* return the ftp-code */ 670 { 671 /* 672 * We cannot read just one byte per read() and then go back to select() as 673 * the OpenSSL read() doesn't grok that properly. 674 * 675 * Alas, read as much as possible, split up into lines, use the ending 676 * line in a response or continue reading. */ 677 678 curl_socket_t sockfd = conn->sock[FIRSTSOCKET]; 679 long timeout; /* timeout in milliseconds */ 680 long interval_ms; 681 struct SessionHandle *data = conn->data; 682 CURLcode result = CURLE_OK; 683 struct ftp_conn *ftpc = &conn->proto.ftpc; 684 struct pingpong *pp = &ftpc->pp; 685 size_t nread; 686 int cache_skip=0; 687 int value_to_be_ignored=0; 688 689 if(ftpcode) 690 *ftpcode = 0; /* 0 for errors */ 691 else 692 /* make the pointer point to something for the rest of this function */ 693 ftpcode = &value_to_be_ignored; 694 695 *nreadp=0; 696 697 while(!*ftpcode && !result) { 698 /* check and reset timeout value every lap */ 699 timeout = Curl_pp_state_timeout(pp); 700 701 if(timeout <=0 ) { 702 failf(data, "FTP response timeout"); 703 return CURLE_OPERATION_TIMEDOUT; /* already too little time */ 704 } 705 706 interval_ms = 1000; /* use 1 second timeout intervals */ 707 if(timeout < interval_ms) 708 interval_ms = timeout; 709 710 /* 711 * Since this function is blocking, we need to wait here for input on the 712 * connection and only then we call the response reading function. We do 713 * timeout at least every second to make the timeout check run. 714 * 715 * A caution here is that the ftp_readresp() function has a cache that may 716 * contain pieces of a response from the previous invoke and we need to 717 * make sure we don't just wait for input while there is unhandled data in 718 * that cache. But also, if the cache is there, we call ftp_readresp() and 719 * the cache wasn't good enough to continue we must not just busy-loop 720 * around this function. 721 * 722 */ 723 724 if(pp->cache && (cache_skip < 2)) { 725 /* 726 * There's a cache left since before. We then skipping the wait for 727 * socket action, unless this is the same cache like the previous round 728 * as then the cache was deemed not enough to act on and we then need to 729 * wait for more data anyway. 730 */ 731 } 732 else { 733 switch (Curl_socket_ready(sockfd, CURL_SOCKET_BAD, interval_ms)) { 734 case -1: /* select() error, stop reading */ 735 failf(data, "FTP response aborted due to select/poll error: %d", 736 SOCKERRNO); 737 return CURLE_RECV_ERROR; 738 739 case 0: /* timeout */ 740 if(Curl_pgrsUpdate(conn)) 741 return CURLE_ABORTED_BY_CALLBACK; 742 continue; /* just continue in our loop for the timeout duration */ 743 744 default: /* for clarity */ 745 break; 746 } 747 } 748 result = ftp_readresp(sockfd, pp, ftpcode, &nread); 749 if(result) 750 break; 751 752 if(!nread && pp->cache) 753 /* bump cache skip counter as on repeated skips we must wait for more 754 data */ 755 cache_skip++; 756 else 757 /* when we got data or there is no cache left, we reset the cache skip 758 counter */ 759 cache_skip=0; 760 761 *nreadp += nread; 762 763 } /* while there's buffer left and loop is requested */ 764 765 pp->pending_resp = FALSE; 766 767 return result; 768 } 769 770 #if defined(DEBUGBUILD) && !defined(CURL_DISABLE_VERBOSE_STRINGS) 771 /* for debug purposes */ 772 static const char * const ftp_state_names[]={ 773 "STOP", 774 "WAIT220", 775 "AUTH", 776 "USER", 777 "PASS", 778 "ACCT", 779 "PBSZ", 780 "PROT", 781 "CCC", 782 "PWD", 783 "SYST", 784 "NAMEFMT", 785 "QUOTE", 786 "RETR_PREQUOTE", 787 "STOR_PREQUOTE", 788 "POSTQUOTE", 789 "CWD", 790 "MKD", 791 "MDTM", 792 "TYPE", 793 "LIST_TYPE", 794 "RETR_TYPE", 795 "STOR_TYPE", 796 "SIZE", 797 "RETR_SIZE", 798 "STOR_SIZE", 799 "REST", 800 "RETR_REST", 801 "PORT", 802 "PRET", 803 "PASV", 804 "LIST", 805 "RETR", 806 "STOR", 807 "QUIT" 808 }; 809 #endif 810 811 /* This is the ONLY way to change FTP state! */ 812 static void _state(struct connectdata *conn, 813 ftpstate newstate 814 #ifdef DEBUGBUILD 815 , int lineno 816 #endif 817 ) 818 { 819 struct ftp_conn *ftpc = &conn->proto.ftpc; 820 821 #if defined(DEBUGBUILD) 822 823 #if defined(CURL_DISABLE_VERBOSE_STRINGS) 824 (void) lineno; 825 #else 826 if(ftpc->state != newstate) 827 infof(conn->data, "FTP %p (line %d) state change from %s to %s\n", 828 (void *)ftpc, lineno, ftp_state_names[ftpc->state], 829 ftp_state_names[newstate]); 830 #endif 831 #endif 832 833 ftpc->state = newstate; 834 } 835 836 static CURLcode ftp_state_user(struct connectdata *conn) 837 { 838 CURLcode result; 839 struct FTP *ftp = conn->data->req.protop; 840 /* send USER */ 841 PPSENDF(&conn->proto.ftpc.pp, "USER %s", ftp->user?ftp->user:""); 842 843 state(conn, FTP_USER); 844 conn->data->state.ftp_trying_alternative = FALSE; 845 846 return CURLE_OK; 847 } 848 849 static CURLcode ftp_state_pwd(struct connectdata *conn) 850 { 851 CURLcode result; 852 853 /* send PWD to discover our entry point */ 854 PPSENDF(&conn->proto.ftpc.pp, "%s", "PWD"); 855 state(conn, FTP_PWD); 856 857 return CURLE_OK; 858 } 859 860 /* For the FTP "protocol connect" and "doing" phases only */ 861 static int ftp_getsock(struct connectdata *conn, 862 curl_socket_t *socks, 863 int numsocks) 864 { 865 return Curl_pp_getsock(&conn->proto.ftpc.pp, socks, numsocks); 866 } 867 868 /* For the FTP "DO_MORE" phase only */ 869 static int ftp_domore_getsock(struct connectdata *conn, curl_socket_t *socks, 870 int numsocks) 871 { 872 struct ftp_conn *ftpc = &conn->proto.ftpc; 873 874 if(!numsocks) 875 return GETSOCK_BLANK; 876 877 /* When in DO_MORE state, we could be either waiting for us to connect to a 878 * remote site, or we could wait for that site to connect to us. Or just 879 * handle ordinary commands. 880 */ 881 882 if(FTP_STOP == ftpc->state) { 883 int bits = GETSOCK_READSOCK(0); 884 885 /* if stopped and still in this state, then we're also waiting for a 886 connect on the secondary connection */ 887 socks[0] = conn->sock[FIRSTSOCKET]; 888 889 if(!conn->data->set.ftp_use_port) { 890 int s; 891 int i; 892 /* PORT is used to tell the server to connect to us, and during that we 893 don't do happy eyeballs, but we do if we connect to the server */ 894 for(s=1, i=0; i<2; i++) { 895 if(conn->tempsock[i] != CURL_SOCKET_BAD) { 896 socks[s] = conn->tempsock[i]; 897 bits |= GETSOCK_WRITESOCK(s++); 898 } 899 } 900 } 901 else { 902 socks[1] = conn->sock[SECONDARYSOCKET]; 903 bits |= GETSOCK_WRITESOCK(1); 904 } 905 906 return bits; 907 } 908 else 909 return Curl_pp_getsock(&conn->proto.ftpc.pp, socks, numsocks); 910 } 911 912 /* This is called after the FTP_QUOTE state is passed. 913 914 ftp_state_cwd() sends the range of CWD commands to the server to change to 915 the correct directory. It may also need to send MKD commands to create 916 missing ones, if that option is enabled. 917 */ 918 static CURLcode ftp_state_cwd(struct connectdata *conn) 919 { 920 CURLcode result = CURLE_OK; 921 struct ftp_conn *ftpc = &conn->proto.ftpc; 922 923 if(ftpc->cwddone) 924 /* already done and fine */ 925 result = ftp_state_mdtm(conn); 926 else { 927 ftpc->count2 = 0; /* count2 counts failed CWDs */ 928 929 /* count3 is set to allow a MKD to fail once. In the case when first CWD 930 fails and then MKD fails (due to another session raced it to create the 931 dir) this then allows for a second try to CWD to it */ 932 ftpc->count3 = (conn->data->set.ftp_create_missing_dirs==2)?1:0; 933 934 if(conn->bits.reuse && ftpc->entrypath) { 935 /* This is a re-used connection. Since we change directory to where the 936 transfer is taking place, we must first get back to the original dir 937 where we ended up after login: */ 938 ftpc->count1 = 0; /* we count this as the first path, then we add one 939 for all upcoming ones in the ftp->dirs[] array */ 940 PPSENDF(&conn->proto.ftpc.pp, "CWD %s", ftpc->entrypath); 941 state(conn, FTP_CWD); 942 } 943 else { 944 if(ftpc->dirdepth) { 945 ftpc->count1 = 1; 946 /* issue the first CWD, the rest is sent when the CWD responses are 947 received... */ 948 PPSENDF(&conn->proto.ftpc.pp, "CWD %s", ftpc->dirs[ftpc->count1 -1]); 949 state(conn, FTP_CWD); 950 } 951 else { 952 /* No CWD necessary */ 953 result = ftp_state_mdtm(conn); 954 } 955 } 956 } 957 return result; 958 } 959 960 typedef enum { 961 EPRT, 962 PORT, 963 DONE 964 } ftpport; 965 966 static CURLcode ftp_state_use_port(struct connectdata *conn, 967 ftpport fcmd) /* start with this */ 968 969 { 970 CURLcode result = CURLE_OK; 971 struct ftp_conn *ftpc = &conn->proto.ftpc; 972 struct SessionHandle *data=conn->data; 973 curl_socket_t portsock= CURL_SOCKET_BAD; 974 char myhost[256] = ""; 975 976 struct Curl_sockaddr_storage ss; 977 Curl_addrinfo *res, *ai; 978 curl_socklen_t sslen; 979 char hbuf[NI_MAXHOST]; 980 struct sockaddr *sa=(struct sockaddr *)&ss; 981 struct sockaddr_in * const sa4 = (void *)sa; 982 #ifdef ENABLE_IPV6 983 struct sockaddr_in6 * const sa6 = (void *)sa; 984 #endif 985 char tmp[1024]; 986 static const char mode[][5] = { "EPRT", "PORT" }; 987 int rc; 988 int error; 989 char *host = NULL; 990 char *string_ftpport = data->set.str[STRING_FTPPORT]; 991 struct Curl_dns_entry *h=NULL; 992 unsigned short port_min = 0; 993 unsigned short port_max = 0; 994 unsigned short port; 995 bool possibly_non_local = TRUE; 996 997 char *addr = NULL; 998 999 /* Step 1, figure out what is requested, 1000 * accepted format : 1001 * (ipv4|ipv6|domain|interface)?(:port(-range)?)? 1002 */ 1003 1004 if(data->set.str[STRING_FTPPORT] && 1005 (strlen(data->set.str[STRING_FTPPORT]) > 1)) { 1006 1007 #ifdef ENABLE_IPV6 1008 size_t addrlen = INET6_ADDRSTRLEN > strlen(string_ftpport) ? 1009 INET6_ADDRSTRLEN : strlen(string_ftpport); 1010 #else 1011 size_t addrlen = INET_ADDRSTRLEN > strlen(string_ftpport) ? 1012 INET_ADDRSTRLEN : strlen(string_ftpport); 1013 #endif 1014 char *ip_start = string_ftpport; 1015 char *ip_end = NULL; 1016 char *port_start = NULL; 1017 char *port_sep = NULL; 1018 1019 addr = calloc(addrlen+1, 1); 1020 if(!addr) 1021 return CURLE_OUT_OF_MEMORY; 1022 1023 #ifdef ENABLE_IPV6 1024 if(*string_ftpport == '[') { 1025 /* [ipv6]:port(-range) */ 1026 ip_start = string_ftpport + 1; 1027 if((ip_end = strchr(string_ftpport, ']')) != NULL ) 1028 strncpy(addr, ip_start, ip_end - ip_start); 1029 } 1030 else 1031 #endif 1032 if(*string_ftpport == ':') { 1033 /* :port */ 1034 ip_end = string_ftpport; 1035 } 1036 else if((ip_end = strchr(string_ftpport, ':')) != NULL) { 1037 /* either ipv6 or (ipv4|domain|interface):port(-range) */ 1038 #ifdef ENABLE_IPV6 1039 if(Curl_inet_pton(AF_INET6, string_ftpport, sa6) == 1) { 1040 /* ipv6 */ 1041 port_min = port_max = 0; 1042 strcpy(addr, string_ftpport); 1043 ip_end = NULL; /* this got no port ! */ 1044 } 1045 else 1046 #endif 1047 /* (ipv4|domain|interface):port(-range) */ 1048 strncpy(addr, string_ftpport, ip_end - ip_start ); 1049 } 1050 else 1051 /* ipv4|interface */ 1052 strcpy(addr, string_ftpport); 1053 1054 /* parse the port */ 1055 if(ip_end != NULL) { 1056 if((port_start = strchr(ip_end, ':')) != NULL) { 1057 port_min = curlx_ultous(strtoul(port_start+1, NULL, 10)); 1058 if((port_sep = strchr(port_start, '-')) != NULL) { 1059 port_max = curlx_ultous(strtoul(port_sep + 1, NULL, 10)); 1060 } 1061 else 1062 port_max = port_min; 1063 } 1064 } 1065 1066 /* correct errors like: 1067 * :1234-1230 1068 * :-4711 , in this case port_min is (unsigned)-1, 1069 * therefore port_min > port_max for all cases 1070 * but port_max = (unsigned)-1 1071 */ 1072 if(port_min > port_max ) 1073 port_min = port_max = 0; 1074 1075 1076 if(*addr != '\0') { 1077 /* attempt to get the address of the given interface name */ 1078 switch(Curl_if2ip(conn->ip_addr->ai_family, 1079 Curl_ipv6_scope(conn->ip_addr->ai_addr), 1080 conn->scope_id, addr, hbuf, sizeof(hbuf))) { 1081 case IF2IP_NOT_FOUND: 1082 /* not an interface, use the given string as host name instead */ 1083 host = addr; 1084 break; 1085 case IF2IP_AF_NOT_SUPPORTED: 1086 return CURLE_FTP_PORT_FAILED; 1087 case IF2IP_FOUND: 1088 host = hbuf; /* use the hbuf for host name */ 1089 } 1090 } 1091 else 1092 /* there was only a port(-range) given, default the host */ 1093 host = NULL; 1094 } /* data->set.ftpport */ 1095 1096 if(!host) { 1097 /* not an interface and not a host name, get default by extracting 1098 the IP from the control connection */ 1099 1100 sslen = sizeof(ss); 1101 if(getsockname(conn->sock[FIRSTSOCKET], sa, &sslen)) { 1102 failf(data, "getsockname() failed: %s", 1103 Curl_strerror(conn, SOCKERRNO) ); 1104 free(addr); 1105 return CURLE_FTP_PORT_FAILED; 1106 } 1107 switch(sa->sa_family) { 1108 #ifdef ENABLE_IPV6 1109 case AF_INET6: 1110 Curl_inet_ntop(sa->sa_family, &sa6->sin6_addr, hbuf, sizeof(hbuf)); 1111 break; 1112 #endif 1113 default: 1114 Curl_inet_ntop(sa->sa_family, &sa4->sin_addr, hbuf, sizeof(hbuf)); 1115 break; 1116 } 1117 host = hbuf; /* use this host name */ 1118 possibly_non_local = FALSE; /* we know it is local now */ 1119 } 1120 1121 /* resolv ip/host to ip */ 1122 rc = Curl_resolv(conn, host, 0, &h); 1123 if(rc == CURLRESOLV_PENDING) 1124 (void)Curl_resolver_wait_resolv(conn, &h); 1125 if(h) { 1126 res = h->addr; 1127 /* when we return from this function, we can forget about this entry 1128 to we can unlock it now already */ 1129 Curl_resolv_unlock(data, h); 1130 } /* (h) */ 1131 else 1132 res = NULL; /* failure! */ 1133 1134 if(res == NULL) { 1135 failf(data, "failed to resolve the address provided to PORT: %s", host); 1136 free(addr); 1137 return CURLE_FTP_PORT_FAILED; 1138 } 1139 1140 free(addr); 1141 host = NULL; 1142 1143 /* step 2, create a socket for the requested address */ 1144 1145 portsock = CURL_SOCKET_BAD; 1146 error = 0; 1147 for(ai = res; ai; ai = ai->ai_next) { 1148 result = Curl_socket(conn, ai, NULL, &portsock); 1149 if(result) { 1150 error = SOCKERRNO; 1151 continue; 1152 } 1153 break; 1154 } 1155 if(!ai) { 1156 failf(data, "socket failure: %s", Curl_strerror(conn, error)); 1157 return CURLE_FTP_PORT_FAILED; 1158 } 1159 1160 /* step 3, bind to a suitable local address */ 1161 1162 memcpy(sa, ai->ai_addr, ai->ai_addrlen); 1163 sslen = ai->ai_addrlen; 1164 1165 for(port = port_min; port <= port_max;) { 1166 if(sa->sa_family == AF_INET) 1167 sa4->sin_port = htons(port); 1168 #ifdef ENABLE_IPV6 1169 else 1170 sa6->sin6_port = htons(port); 1171 #endif 1172 /* Try binding the given address. */ 1173 if(bind(portsock, sa, sslen) ) { 1174 /* It failed. */ 1175 error = SOCKERRNO; 1176 if(possibly_non_local && (error == EADDRNOTAVAIL)) { 1177 /* The requested bind address is not local. Use the address used for 1178 * the control connection instead and restart the port loop 1179 */ 1180 1181 infof(data, "bind(port=%hu) on non-local address failed: %s\n", port, 1182 Curl_strerror(conn, error) ); 1183 1184 sslen = sizeof(ss); 1185 if(getsockname(conn->sock[FIRSTSOCKET], sa, &sslen)) { 1186 failf(data, "getsockname() failed: %s", 1187 Curl_strerror(conn, SOCKERRNO) ); 1188 Curl_closesocket(conn, portsock); 1189 return CURLE_FTP_PORT_FAILED; 1190 } 1191 port = port_min; 1192 possibly_non_local = FALSE; /* don't try this again */ 1193 continue; 1194 } 1195 else if(error != EADDRINUSE && error != EACCES) { 1196 failf(data, "bind(port=%hu) failed: %s", port, 1197 Curl_strerror(conn, error) ); 1198 Curl_closesocket(conn, portsock); 1199 return CURLE_FTP_PORT_FAILED; 1200 } 1201 } 1202 else 1203 break; 1204 1205 port++; 1206 } 1207 1208 /* maybe all ports were in use already*/ 1209 if(port > port_max) { 1210 failf(data, "bind() failed, we ran out of ports!"); 1211 Curl_closesocket(conn, portsock); 1212 return CURLE_FTP_PORT_FAILED; 1213 } 1214 1215 /* get the name again after the bind() so that we can extract the 1216 port number it uses now */ 1217 sslen = sizeof(ss); 1218 if(getsockname(portsock, (struct sockaddr *)sa, &sslen)) { 1219 failf(data, "getsockname() failed: %s", 1220 Curl_strerror(conn, SOCKERRNO) ); 1221 Curl_closesocket(conn, portsock); 1222 return CURLE_FTP_PORT_FAILED; 1223 } 1224 1225 /* step 4, listen on the socket */ 1226 1227 if(listen(portsock, 1)) { 1228 failf(data, "socket failure: %s", Curl_strerror(conn, SOCKERRNO)); 1229 Curl_closesocket(conn, portsock); 1230 return CURLE_FTP_PORT_FAILED; 1231 } 1232 1233 /* step 5, send the proper FTP command */ 1234 1235 /* get a plain printable version of the numerical address to work with 1236 below */ 1237 Curl_printable_address(ai, myhost, sizeof(myhost)); 1238 1239 #ifdef ENABLE_IPV6 1240 if(!conn->bits.ftp_use_eprt && conn->bits.ipv6) 1241 /* EPRT is disabled but we are connected to a IPv6 host, so we ignore the 1242 request and enable EPRT again! */ 1243 conn->bits.ftp_use_eprt = TRUE; 1244 #endif 1245 1246 for(; fcmd != DONE; fcmd++) { 1247 1248 if(!conn->bits.ftp_use_eprt && (EPRT == fcmd)) 1249 /* if disabled, goto next */ 1250 continue; 1251 1252 if((PORT == fcmd) && sa->sa_family != AF_INET) 1253 /* PORT is IPv4 only */ 1254 continue; 1255 1256 switch(sa->sa_family) { 1257 case AF_INET: 1258 port = ntohs(sa4->sin_port); 1259 break; 1260 #ifdef ENABLE_IPV6 1261 case AF_INET6: 1262 port = ntohs(sa6->sin6_port); 1263 break; 1264 #endif 1265 default: 1266 continue; /* might as well skip this */ 1267 } 1268 1269 if(EPRT == fcmd) { 1270 /* 1271 * Two fine examples from RFC2428; 1272 * 1273 * EPRT |1|132.235.1.2|6275| 1274 * 1275 * EPRT |2|1080::8:800:200C:417A|5282| 1276 */ 1277 1278 result = Curl_pp_sendf(&ftpc->pp, "%s |%d|%s|%hu|", mode[fcmd], 1279 sa->sa_family == AF_INET?1:2, 1280 myhost, port); 1281 if(result) { 1282 failf(data, "Failure sending EPRT command: %s", 1283 curl_easy_strerror(result)); 1284 Curl_closesocket(conn, portsock); 1285 /* don't retry using PORT */ 1286 ftpc->count1 = PORT; 1287 /* bail out */ 1288 state(conn, FTP_STOP); 1289 return result; 1290 } 1291 break; 1292 } 1293 else if(PORT == fcmd) { 1294 char *source = myhost; 1295 char *dest = tmp; 1296 1297 /* translate x.x.x.x to x,x,x,x */ 1298 while(source && *source) { 1299 if(*source == '.') 1300 *dest=','; 1301 else 1302 *dest = *source; 1303 dest++; 1304 source++; 1305 } 1306 *dest = 0; 1307 snprintf(dest, 20, ",%d,%d", (int)(port>>8), (int)(port&0xff)); 1308 1309 result = Curl_pp_sendf(&ftpc->pp, "%s %s", mode[fcmd], tmp); 1310 if(result) { 1311 failf(data, "Failure sending PORT command: %s", 1312 curl_easy_strerror(result)); 1313 Curl_closesocket(conn, portsock); 1314 /* bail out */ 1315 state(conn, FTP_STOP); 1316 return result; 1317 } 1318 break; 1319 } 1320 } 1321 1322 /* store which command was sent */ 1323 ftpc->count1 = fcmd; 1324 1325 /* we set the secondary socket variable to this for now, it is only so that 1326 the cleanup function will close it in case we fail before the true 1327 secondary stuff is made */ 1328 if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET]) 1329 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]); 1330 conn->sock[SECONDARYSOCKET] = portsock; 1331 1332 /* this tcpconnect assignment below is a hackish work-around to make the 1333 multi interface with active FTP work - as it will not wait for a 1334 (passive) connect in Curl_is_connected(). 1335 1336 The *proper* fix is to make sure that the active connection from the 1337 server is done in a non-blocking way. Currently, it is still BLOCKING. 1338 */ 1339 conn->bits.tcpconnect[SECONDARYSOCKET] = TRUE; 1340 1341 state(conn, FTP_PORT); 1342 return result; 1343 } 1344 1345 static CURLcode ftp_state_use_pasv(struct connectdata *conn) 1346 { 1347 struct ftp_conn *ftpc = &conn->proto.ftpc; 1348 CURLcode result = CURLE_OK; 1349 /* 1350 Here's the excecutive summary on what to do: 1351 1352 PASV is RFC959, expect: 1353 227 Entering Passive Mode (a1,a2,a3,a4,p1,p2) 1354 1355 LPSV is RFC1639, expect: 1356 228 Entering Long Passive Mode (4,4,a1,a2,a3,a4,2,p1,p2) 1357 1358 EPSV is RFC2428, expect: 1359 229 Entering Extended Passive Mode (|||port|) 1360 1361 */ 1362 1363 static const char mode[][5] = { "EPSV", "PASV" }; 1364 int modeoff; 1365 1366 #ifdef PF_INET6 1367 if(!conn->bits.ftp_use_epsv && conn->bits.ipv6) 1368 /* EPSV is disabled but we are connected to a IPv6 host, so we ignore the 1369 request and enable EPSV again! */ 1370 conn->bits.ftp_use_epsv = TRUE; 1371 #endif 1372 1373 modeoff = conn->bits.ftp_use_epsv?0:1; 1374 1375 PPSENDF(&ftpc->pp, "%s", mode[modeoff]); 1376 1377 ftpc->count1 = modeoff; 1378 state(conn, FTP_PASV); 1379 infof(conn->data, "Connect data stream passively\n"); 1380 1381 return result; 1382 } 1383 1384 /* 1385 * ftp_state_prepare_transfer() starts PORT, PASV or PRET etc. 1386 * 1387 * REST is the last command in the chain of commands when a "head"-like 1388 * request is made. Thus, if an actual transfer is to be made this is where we 1389 * take off for real. 1390 */ 1391 static CURLcode ftp_state_prepare_transfer(struct connectdata *conn) 1392 { 1393 CURLcode result = CURLE_OK; 1394 struct FTP *ftp = conn->data->req.protop; 1395 struct SessionHandle *data = conn->data; 1396 1397 if(ftp->transfer != FTPTRANSFER_BODY) { 1398 /* doesn't transfer any data */ 1399 1400 /* still possibly do PRE QUOTE jobs */ 1401 state(conn, FTP_RETR_PREQUOTE); 1402 result = ftp_state_quote(conn, TRUE, FTP_RETR_PREQUOTE); 1403 } 1404 else if(data->set.ftp_use_port) { 1405 /* We have chosen to use the PORT (or similar) command */ 1406 result = ftp_state_use_port(conn, EPRT); 1407 } 1408 else { 1409 /* We have chosen (this is default) to use the PASV (or similar) command */ 1410 if(data->set.ftp_use_pret) { 1411 /* The user has requested that we send a PRET command 1412 to prepare the server for the upcoming PASV */ 1413 if(!conn->proto.ftpc.file) { 1414 PPSENDF(&conn->proto.ftpc.pp, "PRET %s", 1415 data->set.str[STRING_CUSTOMREQUEST]? 1416 data->set.str[STRING_CUSTOMREQUEST]: 1417 (data->set.ftp_list_only?"NLST":"LIST")); 1418 } 1419 else if(data->set.upload) { 1420 PPSENDF(&conn->proto.ftpc.pp, "PRET STOR %s", conn->proto.ftpc.file); 1421 } 1422 else { 1423 PPSENDF(&conn->proto.ftpc.pp, "PRET RETR %s", conn->proto.ftpc.file); 1424 } 1425 state(conn, FTP_PRET); 1426 } 1427 else { 1428 result = ftp_state_use_pasv(conn); 1429 } 1430 } 1431 return result; 1432 } 1433 1434 static CURLcode ftp_state_rest(struct connectdata *conn) 1435 { 1436 CURLcode result = CURLE_OK; 1437 struct FTP *ftp = conn->data->req.protop; 1438 struct ftp_conn *ftpc = &conn->proto.ftpc; 1439 1440 if((ftp->transfer != FTPTRANSFER_BODY) && ftpc->file) { 1441 /* if a "head"-like request is being made (on a file) */ 1442 1443 /* Determine if server can respond to REST command and therefore 1444 whether it supports range */ 1445 PPSENDF(&conn->proto.ftpc.pp, "REST %d", 0); 1446 1447 state(conn, FTP_REST); 1448 } 1449 else 1450 result = ftp_state_prepare_transfer(conn); 1451 1452 return result; 1453 } 1454 1455 static CURLcode ftp_state_size(struct connectdata *conn) 1456 { 1457 CURLcode result = CURLE_OK; 1458 struct FTP *ftp = conn->data->req.protop; 1459 struct ftp_conn *ftpc = &conn->proto.ftpc; 1460 1461 if((ftp->transfer == FTPTRANSFER_INFO) && ftpc->file) { 1462 /* if a "head"-like request is being made (on a file) */ 1463 1464 /* we know ftpc->file is a valid pointer to a file name */ 1465 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file); 1466 1467 state(conn, FTP_SIZE); 1468 } 1469 else 1470 result = ftp_state_rest(conn); 1471 1472 return result; 1473 } 1474 1475 static CURLcode ftp_state_list(struct connectdata *conn) 1476 { 1477 CURLcode result = CURLE_OK; 1478 struct SessionHandle *data = conn->data; 1479 1480 /* If this output is to be machine-parsed, the NLST command might be better 1481 to use, since the LIST command output is not specified or standard in any 1482 way. It has turned out that the NLST list output is not the same on all 1483 servers either... */ 1484 1485 /* 1486 if FTPFILE_NOCWD was specified, we are currently in 1487 the user's home directory, so we should add the path 1488 as argument for the LIST / NLST / or custom command. 1489 Whether the server will support this, is uncertain. 1490 1491 The other ftp_filemethods will CWD into dir/dir/ first and 1492 then just do LIST (in that case: nothing to do here) 1493 */ 1494 char *cmd, *lstArg, *slashPos; 1495 1496 lstArg = NULL; 1497 if((data->set.ftp_filemethod == FTPFILE_NOCWD) && 1498 data->state.path && 1499 data->state.path[0] && 1500 strchr(data->state.path, '/')) { 1501 1502 lstArg = strdup(data->state.path); 1503 if(!lstArg) 1504 return CURLE_OUT_OF_MEMORY; 1505 1506 /* Check if path does not end with /, as then we cut off the file part */ 1507 if(lstArg[strlen(lstArg) - 1] != '/') { 1508 1509 /* chop off the file part if format is dir/dir/file */ 1510 slashPos = strrchr(lstArg, '/'); 1511 if(slashPos) 1512 *(slashPos+1) = '\0'; 1513 } 1514 } 1515 1516 cmd = aprintf( "%s%s%s", 1517 data->set.str[STRING_CUSTOMREQUEST]? 1518 data->set.str[STRING_CUSTOMREQUEST]: 1519 (data->set.ftp_list_only?"NLST":"LIST"), 1520 lstArg? " ": "", 1521 lstArg? lstArg: "" ); 1522 1523 if(!cmd) { 1524 free(lstArg); 1525 return CURLE_OUT_OF_MEMORY; 1526 } 1527 1528 result = Curl_pp_sendf(&conn->proto.ftpc.pp, "%s", cmd); 1529 1530 free(lstArg); 1531 free(cmd); 1532 1533 if(result) 1534 return result; 1535 1536 state(conn, FTP_LIST); 1537 1538 return result; 1539 } 1540 1541 static CURLcode ftp_state_retr_prequote(struct connectdata *conn) 1542 { 1543 CURLcode result = CURLE_OK; 1544 1545 /* We've sent the TYPE, now we must send the list of prequote strings */ 1546 1547 result = ftp_state_quote(conn, TRUE, FTP_RETR_PREQUOTE); 1548 1549 return result; 1550 } 1551 1552 static CURLcode ftp_state_stor_prequote(struct connectdata *conn) 1553 { 1554 CURLcode result = CURLE_OK; 1555 1556 /* We've sent the TYPE, now we must send the list of prequote strings */ 1557 1558 result = ftp_state_quote(conn, TRUE, FTP_STOR_PREQUOTE); 1559 1560 return result; 1561 } 1562 1563 static CURLcode ftp_state_type(struct connectdata *conn) 1564 { 1565 CURLcode result = CURLE_OK; 1566 struct FTP *ftp = conn->data->req.protop; 1567 struct SessionHandle *data = conn->data; 1568 struct ftp_conn *ftpc = &conn->proto.ftpc; 1569 1570 /* If we have selected NOBODY and HEADER, it means that we only want file 1571 information. Which in FTP can't be much more than the file size and 1572 date. */ 1573 if(data->set.opt_no_body && ftpc->file && 1574 ftp_need_type(conn, data->set.prefer_ascii)) { 1575 /* The SIZE command is _not_ RFC 959 specified, and therefor many servers 1576 may not support it! It is however the only way we have to get a file's 1577 size! */ 1578 1579 ftp->transfer = FTPTRANSFER_INFO; 1580 /* this means no actual transfer will be made */ 1581 1582 /* Some servers return different sizes for different modes, and thus we 1583 must set the proper type before we check the size */ 1584 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_TYPE); 1585 if(result) 1586 return result; 1587 } 1588 else 1589 result = ftp_state_size(conn); 1590 1591 return result; 1592 } 1593 1594 /* This is called after the CWD commands have been done in the beginning of 1595 the DO phase */ 1596 static CURLcode ftp_state_mdtm(struct connectdata *conn) 1597 { 1598 CURLcode result = CURLE_OK; 1599 struct SessionHandle *data = conn->data; 1600 struct ftp_conn *ftpc = &conn->proto.ftpc; 1601 1602 /* Requested time of file or time-depended transfer? */ 1603 if((data->set.get_filetime || data->set.timecondition) && ftpc->file) { 1604 1605 /* we have requested to get the modified-time of the file, this is a white 1606 spot as the MDTM is not mentioned in RFC959 */ 1607 PPSENDF(&ftpc->pp, "MDTM %s", ftpc->file); 1608 1609 state(conn, FTP_MDTM); 1610 } 1611 else 1612 result = ftp_state_type(conn); 1613 1614 return result; 1615 } 1616 1617 1618 /* This is called after the TYPE and possible quote commands have been sent */ 1619 static CURLcode ftp_state_ul_setup(struct connectdata *conn, 1620 bool sizechecked) 1621 { 1622 CURLcode result = CURLE_OK; 1623 struct FTP *ftp = conn->data->req.protop; 1624 struct SessionHandle *data = conn->data; 1625 struct ftp_conn *ftpc = &conn->proto.ftpc; 1626 int seekerr = CURL_SEEKFUNC_OK; 1627 1628 if((data->state.resume_from && !sizechecked) || 1629 ((data->state.resume_from > 0) && sizechecked)) { 1630 /* we're about to continue the uploading of a file */ 1631 /* 1. get already existing file's size. We use the SIZE command for this 1632 which may not exist in the server! The SIZE command is not in 1633 RFC959. */ 1634 1635 /* 2. This used to set REST. But since we can do append, we 1636 don't another ftp command. We just skip the source file 1637 offset and then we APPEND the rest on the file instead */ 1638 1639 /* 3. pass file-size number of bytes in the source file */ 1640 /* 4. lower the infilesize counter */ 1641 /* => transfer as usual */ 1642 1643 if(data->state.resume_from < 0 ) { 1644 /* Got no given size to start from, figure it out */ 1645 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file); 1646 state(conn, FTP_STOR_SIZE); 1647 return result; 1648 } 1649 1650 /* enable append */ 1651 data->set.ftp_append = TRUE; 1652 1653 /* Let's read off the proper amount of bytes from the input. */ 1654 if(conn->seek_func) { 1655 seekerr = conn->seek_func(conn->seek_client, data->state.resume_from, 1656 SEEK_SET); 1657 } 1658 1659 if(seekerr != CURL_SEEKFUNC_OK) { 1660 if(seekerr != CURL_SEEKFUNC_CANTSEEK) { 1661 failf(data, "Could not seek stream"); 1662 return CURLE_FTP_COULDNT_USE_REST; 1663 } 1664 /* seekerr == CURL_SEEKFUNC_CANTSEEK (can't seek to offset) */ 1665 else { 1666 curl_off_t passed=0; 1667 do { 1668 size_t readthisamountnow = 1669 (data->state.resume_from - passed > CURL_OFF_T_C(BUFSIZE)) ? 1670 BUFSIZE : curlx_sotouz(data->state.resume_from - passed); 1671 1672 size_t actuallyread = 1673 data->set.fread_func(data->state.buffer, 1, readthisamountnow, 1674 data->set.in); 1675 1676 passed += actuallyread; 1677 if((actuallyread == 0) || (actuallyread > readthisamountnow)) { 1678 /* this checks for greater-than only to make sure that the 1679 CURL_READFUNC_ABORT return code still aborts */ 1680 failf(data, "Failed to read data"); 1681 return CURLE_FTP_COULDNT_USE_REST; 1682 } 1683 } while(passed < data->state.resume_from); 1684 } 1685 } 1686 /* now, decrease the size of the read */ 1687 if(data->state.infilesize>0) { 1688 data->state.infilesize -= data->state.resume_from; 1689 1690 if(data->state.infilesize <= 0) { 1691 infof(data, "File already completely uploaded\n"); 1692 1693 /* no data to transfer */ 1694 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL); 1695 1696 /* Set ->transfer so that we won't get any error in 1697 * ftp_done() because we didn't transfer anything! */ 1698 ftp->transfer = FTPTRANSFER_NONE; 1699 1700 state(conn, FTP_STOP); 1701 return CURLE_OK; 1702 } 1703 } 1704 /* we've passed, proceed as normal */ 1705 } /* resume_from */ 1706 1707 PPSENDF(&ftpc->pp, data->set.ftp_append?"APPE %s":"STOR %s", 1708 ftpc->file); 1709 1710 state(conn, FTP_STOR); 1711 1712 return result; 1713 } 1714 1715 static CURLcode ftp_state_quote(struct connectdata *conn, 1716 bool init, 1717 ftpstate instate) 1718 { 1719 CURLcode result = CURLE_OK; 1720 struct SessionHandle *data = conn->data; 1721 struct FTP *ftp = data->req.protop; 1722 struct ftp_conn *ftpc = &conn->proto.ftpc; 1723 bool quote=FALSE; 1724 struct curl_slist *item; 1725 1726 switch(instate) { 1727 case FTP_QUOTE: 1728 default: 1729 item = data->set.quote; 1730 break; 1731 case FTP_RETR_PREQUOTE: 1732 case FTP_STOR_PREQUOTE: 1733 item = data->set.prequote; 1734 break; 1735 case FTP_POSTQUOTE: 1736 item = data->set.postquote; 1737 break; 1738 } 1739 1740 /* 1741 * This state uses: 1742 * 'count1' to iterate over the commands to send 1743 * 'count2' to store wether to allow commands to fail 1744 */ 1745 1746 if(init) 1747 ftpc->count1 = 0; 1748 else 1749 ftpc->count1++; 1750 1751 if(item) { 1752 int i = 0; 1753 1754 /* Skip count1 items in the linked list */ 1755 while((i< ftpc->count1) && item) { 1756 item = item->next; 1757 i++; 1758 } 1759 if(item) { 1760 char *cmd = item->data; 1761 if(cmd[0] == '*') { 1762 cmd++; 1763 ftpc->count2 = 1; /* the sent command is allowed to fail */ 1764 } 1765 else 1766 ftpc->count2 = 0; /* failure means cancel operation */ 1767 1768 PPSENDF(&ftpc->pp, "%s", cmd); 1769 state(conn, instate); 1770 quote = TRUE; 1771 } 1772 } 1773 1774 if(!quote) { 1775 /* No more quote to send, continue to ... */ 1776 switch(instate) { 1777 case FTP_QUOTE: 1778 default: 1779 result = ftp_state_cwd(conn); 1780 break; 1781 case FTP_RETR_PREQUOTE: 1782 if(ftp->transfer != FTPTRANSFER_BODY) 1783 state(conn, FTP_STOP); 1784 else { 1785 if(ftpc->known_filesize != -1) { 1786 Curl_pgrsSetDownloadSize(data, ftpc->known_filesize); 1787 result = ftp_state_retr(conn, ftpc->known_filesize); 1788 } 1789 else { 1790 PPSENDF(&ftpc->pp, "SIZE %s", ftpc->file); 1791 state(conn, FTP_RETR_SIZE); 1792 } 1793 } 1794 break; 1795 case FTP_STOR_PREQUOTE: 1796 result = ftp_state_ul_setup(conn, FALSE); 1797 break; 1798 case FTP_POSTQUOTE: 1799 break; 1800 } 1801 } 1802 1803 return result; 1804 } 1805 1806 /* called from ftp_state_pasv_resp to switch to PASV in case of EPSV 1807 problems */ 1808 static CURLcode ftp_epsv_disable(struct connectdata *conn) 1809 { 1810 CURLcode result = CURLE_OK; 1811 1812 if(conn->bits.ipv6) { 1813 /* We can't disable EPSV when doing IPv6, so this is instead a fail */ 1814 failf(conn->data, "Failed EPSV attempt, exiting\n"); 1815 return CURLE_FTP_WEIRD_SERVER_REPLY; 1816 } 1817 1818 infof(conn->data, "Failed EPSV attempt. Disabling EPSV\n"); 1819 /* disable it for next transfer */ 1820 conn->bits.ftp_use_epsv = FALSE; 1821 conn->data->state.errorbuf = FALSE; /* allow error message to get 1822 rewritten */ 1823 PPSENDF(&conn->proto.ftpc.pp, "%s", "PASV"); 1824 conn->proto.ftpc.count1++; 1825 /* remain in/go to the FTP_PASV state */ 1826 state(conn, FTP_PASV); 1827 return result; 1828 } 1829 1830 /* 1831 * Perform the necessary magic that needs to be done once the TCP connection 1832 * to the proxy has completed. 1833 */ 1834 static CURLcode proxy_magic(struct connectdata *conn, 1835 char *newhost, unsigned short newport, 1836 bool *magicdone) 1837 { 1838 CURLcode result = CURLE_OK; 1839 struct SessionHandle *data = conn->data; 1840 1841 #if defined(CURL_DISABLE_PROXY) 1842 (void) newhost; 1843 (void) newport; 1844 #endif 1845 1846 *magicdone = FALSE; 1847 1848 switch(conn->proxytype) { 1849 case CURLPROXY_SOCKS5: 1850 case CURLPROXY_SOCKS5_HOSTNAME: 1851 result = Curl_SOCKS5(conn->proxyuser, conn->proxypasswd, newhost, 1852 newport, SECONDARYSOCKET, conn); 1853 *magicdone = TRUE; 1854 break; 1855 case CURLPROXY_SOCKS4: 1856 result = Curl_SOCKS4(conn->proxyuser, newhost, newport, 1857 SECONDARYSOCKET, conn, FALSE); 1858 *magicdone = TRUE; 1859 break; 1860 case CURLPROXY_SOCKS4A: 1861 result = Curl_SOCKS4(conn->proxyuser, newhost, newport, 1862 SECONDARYSOCKET, conn, TRUE); 1863 *magicdone = TRUE; 1864 break; 1865 case CURLPROXY_HTTP: 1866 case CURLPROXY_HTTP_1_0: 1867 /* do nothing here. handled later. */ 1868 break; 1869 default: 1870 failf(data, "unknown proxytype option given"); 1871 result = CURLE_COULDNT_CONNECT; 1872 break; 1873 } 1874 1875 if(conn->bits.tunnel_proxy && conn->bits.httpproxy) { 1876 /* BLOCKING */ 1877 /* We want "seamless" FTP operations through HTTP proxy tunnel */ 1878 1879 /* Curl_proxyCONNECT is based on a pointer to a struct HTTP at the 1880 * member conn->proto.http; we want FTP through HTTP and we have to 1881 * change the member temporarily for connecting to the HTTP proxy. After 1882 * Curl_proxyCONNECT we have to set back the member to the original 1883 * struct FTP pointer 1884 */ 1885 struct HTTP http_proxy; 1886 struct FTP *ftp_save = data->req.protop; 1887 memset(&http_proxy, 0, sizeof(http_proxy)); 1888 data->req.protop = &http_proxy; 1889 1890 result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, newhost, newport); 1891 1892 data->req.protop = ftp_save; 1893 1894 if(result) 1895 return result; 1896 1897 if(conn->tunnel_state[SECONDARYSOCKET] != TUNNEL_COMPLETE) { 1898 /* the CONNECT procedure is not complete, the tunnel is not yet up */ 1899 state(conn, FTP_STOP); /* this phase is completed */ 1900 return result; 1901 } 1902 else 1903 *magicdone = TRUE; 1904 } 1905 1906 return result; 1907 } 1908 1909 static char *control_address(struct connectdata *conn) 1910 { 1911 /* Returns the control connection IP address. 1912 If a proxy tunnel is used, returns the original host name instead, because 1913 the effective control connection address is the proxy address, 1914 not the ftp host. */ 1915 if(conn->bits.tunnel_proxy || 1916 conn->proxytype == CURLPROXY_SOCKS5 || 1917 conn->proxytype == CURLPROXY_SOCKS5_HOSTNAME || 1918 conn->proxytype == CURLPROXY_SOCKS4 || 1919 conn->proxytype == CURLPROXY_SOCKS4A) 1920 return conn->host.name; 1921 1922 return conn->ip_addr_str; 1923 } 1924 1925 static CURLcode ftp_state_pasv_resp(struct connectdata *conn, 1926 int ftpcode) 1927 { 1928 struct ftp_conn *ftpc = &conn->proto.ftpc; 1929 CURLcode result; 1930 struct SessionHandle *data=conn->data; 1931 struct Curl_dns_entry *addr=NULL; 1932 int rc; 1933 unsigned short connectport; /* the local port connect() should use! */ 1934 char *str=&data->state.buffer[4]; /* start on the first letter */ 1935 1936 /* if we come here again, make sure the former name is cleared */ 1937 Curl_safefree(ftpc->newhost); 1938 1939 if((ftpc->count1 == 0) && 1940 (ftpcode == 229)) { 1941 /* positive EPSV response */ 1942 char *ptr = strchr(str, '('); 1943 if(ptr) { 1944 unsigned int num; 1945 char separator[4]; 1946 ptr++; 1947 if(5 == sscanf(ptr, "%c%c%c%u%c", 1948 &separator[0], 1949 &separator[1], 1950 &separator[2], 1951 &num, 1952 &separator[3])) { 1953 const char sep1 = separator[0]; 1954 int i; 1955 1956 /* The four separators should be identical, or else this is an oddly 1957 formatted reply and we bail out immediately. */ 1958 for(i=1; i<4; i++) { 1959 if(separator[i] != sep1) { 1960 ptr=NULL; /* set to NULL to signal error */ 1961 break; 1962 } 1963 } 1964 if(num > 0xffff) { 1965 failf(data, "Illegal port number in EPSV reply"); 1966 return CURLE_FTP_WEIRD_PASV_REPLY; 1967 } 1968 if(ptr) { 1969 ftpc->newport = (unsigned short)(num & 0xffff); 1970 ftpc->newhost = strdup(control_address(conn)); 1971 if(!ftpc->newhost) 1972 return CURLE_OUT_OF_MEMORY; 1973 } 1974 } 1975 else 1976 ptr=NULL; 1977 } 1978 if(!ptr) { 1979 failf(data, "Weirdly formatted EPSV reply"); 1980 return CURLE_FTP_WEIRD_PASV_REPLY; 1981 } 1982 } 1983 else if((ftpc->count1 == 1) && 1984 (ftpcode == 227)) { 1985 /* positive PASV response */ 1986 int ip[4]; 1987 int port[2]; 1988 1989 /* 1990 * Scan for a sequence of six comma-separated numbers and use them as 1991 * IP+port indicators. 1992 * 1993 * Found reply-strings include: 1994 * "227 Entering Passive Mode (127,0,0,1,4,51)" 1995 * "227 Data transfer will passively listen to 127,0,0,1,4,51" 1996 * "227 Entering passive mode. 127,0,0,1,4,51" 1997 */ 1998 while(*str) { 1999 if(6 == sscanf(str, "%d,%d,%d,%d,%d,%d", 2000 &ip[0], &ip[1], &ip[2], &ip[3], 2001 &port[0], &port[1])) 2002 break; 2003 str++; 2004 } 2005 2006 if(!*str) { 2007 failf(data, "Couldn't interpret the 227-response"); 2008 return CURLE_FTP_WEIRD_227_FORMAT; 2009 } 2010 2011 /* we got OK from server */ 2012 if(data->set.ftp_skip_ip) { 2013 /* told to ignore the remotely given IP but instead use the host we used 2014 for the control connection */ 2015 infof(data, "Skip %d.%d.%d.%d for data connection, re-use %s instead\n", 2016 ip[0], ip[1], ip[2], ip[3], 2017 conn->host.name); 2018 ftpc->newhost = strdup(control_address(conn)); 2019 } 2020 else 2021 ftpc->newhost = aprintf("%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]); 2022 2023 if(!ftpc->newhost) 2024 return CURLE_OUT_OF_MEMORY; 2025 2026 ftpc->newport = (unsigned short)(((port[0]<<8) + port[1]) & 0xffff); 2027 } 2028 else if(ftpc->count1 == 0) { 2029 /* EPSV failed, move on to PASV */ 2030 return ftp_epsv_disable(conn); 2031 } 2032 else { 2033 failf(data, "Bad PASV/EPSV response: %03d", ftpcode); 2034 return CURLE_FTP_WEIRD_PASV_REPLY; 2035 } 2036 2037 if(conn->bits.proxy) { 2038 /* 2039 * This connection uses a proxy and we need to connect to the proxy again 2040 * here. We don't want to rely on a former host lookup that might've 2041 * expired now, instead we remake the lookup here and now! 2042 */ 2043 rc = Curl_resolv(conn, conn->proxy.name, (int)conn->port, &addr); 2044 if(rc == CURLRESOLV_PENDING) 2045 /* BLOCKING, ignores the return code but 'addr' will be NULL in 2046 case of failure */ 2047 (void)Curl_resolver_wait_resolv(conn, &addr); 2048 2049 connectport = 2050 (unsigned short)conn->port; /* we connect to the proxy's port */ 2051 2052 if(!addr) { 2053 failf(data, "Can't resolve proxy host %s:%hu", 2054 conn->proxy.name, connectport); 2055 return CURLE_FTP_CANT_GET_HOST; 2056 } 2057 } 2058 else { 2059 /* normal, direct, ftp connection */ 2060 rc = Curl_resolv(conn, ftpc->newhost, ftpc->newport, &addr); 2061 if(rc == CURLRESOLV_PENDING) 2062 /* BLOCKING */ 2063 (void)Curl_resolver_wait_resolv(conn, &addr); 2064 2065 connectport = ftpc->newport; /* we connect to the remote port */ 2066 2067 if(!addr) { 2068 failf(data, "Can't resolve new host %s:%hu", ftpc->newhost, connectport); 2069 return CURLE_FTP_CANT_GET_HOST; 2070 } 2071 } 2072 2073 conn->bits.tcpconnect[SECONDARYSOCKET] = FALSE; 2074 result = Curl_connecthost(conn, addr); 2075 2076 if(result) { 2077 Curl_resolv_unlock(data, addr); /* we're done using this address */ 2078 if(ftpc->count1 == 0 && ftpcode == 229) 2079 return ftp_epsv_disable(conn); 2080 2081 return result; 2082 } 2083 2084 2085 /* 2086 * When this is used from the multi interface, this might've returned with 2087 * the 'connected' set to FALSE and thus we are now awaiting a non-blocking 2088 * connect to connect. 2089 */ 2090 2091 if(data->set.verbose) 2092 /* this just dumps information about this second connection */ 2093 ftp_pasv_verbose(conn, addr->addr, ftpc->newhost, connectport); 2094 2095 Curl_resolv_unlock(data, addr); /* we're done using this address */ 2096 conn->bits.do_more = TRUE; 2097 state(conn, FTP_STOP); /* this phase is completed */ 2098 2099 return result; 2100 } 2101 2102 static CURLcode ftp_state_port_resp(struct connectdata *conn, 2103 int ftpcode) 2104 { 2105 struct SessionHandle *data = conn->data; 2106 struct ftp_conn *ftpc = &conn->proto.ftpc; 2107 ftpport fcmd = (ftpport)ftpc->count1; 2108 CURLcode result = CURLE_OK; 2109 2110 /* The FTP spec tells a positive response should have code 200. 2111 Be more permissive here to tolerate deviant servers. */ 2112 if(ftpcode / 100 != 2) { 2113 /* the command failed */ 2114 2115 if(EPRT == fcmd) { 2116 infof(data, "disabling EPRT usage\n"); 2117 conn->bits.ftp_use_eprt = FALSE; 2118 } 2119 fcmd++; 2120 2121 if(fcmd == DONE) { 2122 failf(data, "Failed to do PORT"); 2123 result = CURLE_FTP_PORT_FAILED; 2124 } 2125 else 2126 /* try next */ 2127 result = ftp_state_use_port(conn, fcmd); 2128 } 2129 else { 2130 infof(data, "Connect data stream actively\n"); 2131 state(conn, FTP_STOP); /* end of DO phase */ 2132 result = ftp_dophase_done(conn, FALSE); 2133 } 2134 2135 return result; 2136 } 2137 2138 static CURLcode ftp_state_mdtm_resp(struct connectdata *conn, 2139 int ftpcode) 2140 { 2141 CURLcode result = CURLE_OK; 2142 struct SessionHandle *data=conn->data; 2143 struct FTP *ftp = data->req.protop; 2144 struct ftp_conn *ftpc = &conn->proto.ftpc; 2145 2146 switch(ftpcode) { 2147 case 213: 2148 { 2149 /* we got a time. Format should be: "YYYYMMDDHHMMSS[.sss]" where the 2150 last .sss part is optional and means fractions of a second */ 2151 int year, month, day, hour, minute, second; 2152 char *buf = data->state.buffer; 2153 if(6 == sscanf(buf+4, "%04d%02d%02d%02d%02d%02d", 2154 &year, &month, &day, &hour, &minute, &second)) { 2155 /* we have a time, reformat it */ 2156 time_t secs=time(NULL); 2157 /* using the good old yacc/bison yuck */ 2158 snprintf(buf, sizeof(conn->data->state.buffer), 2159 "%04d%02d%02d %02d:%02d:%02d GMT", 2160 year, month, day, hour, minute, second); 2161 /* now, convert this into a time() value: */ 2162 data->info.filetime = (long)curl_getdate(buf, &secs); 2163 } 2164 2165 #ifdef CURL_FTP_HTTPSTYLE_HEAD 2166 /* If we asked for a time of the file and we actually got one as well, 2167 we "emulate" a HTTP-style header in our output. */ 2168 2169 if(data->set.opt_no_body && 2170 ftpc->file && 2171 data->set.get_filetime && 2172 (data->info.filetime>=0) ) { 2173 time_t filetime = (time_t)data->info.filetime; 2174 struct tm buffer; 2175 const struct tm *tm = &buffer; 2176 2177 result = Curl_gmtime(filetime, &buffer); 2178 if(result) 2179 return result; 2180 2181 /* format: "Tue, 15 Nov 1994 12:45:26" */ 2182 snprintf(buf, BUFSIZE-1, 2183 "Last-Modified: %s, %02d %s %4d %02d:%02d:%02d GMT\r\n", 2184 Curl_wkday[tm->tm_wday?tm->tm_wday-1:6], 2185 tm->tm_mday, 2186 Curl_month[tm->tm_mon], 2187 tm->tm_year + 1900, 2188 tm->tm_hour, 2189 tm->tm_min, 2190 tm->tm_sec); 2191 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0); 2192 if(result) 2193 return result; 2194 } /* end of a ridiculous amount of conditionals */ 2195 #endif 2196 } 2197 break; 2198 default: 2199 infof(data, "unsupported MDTM reply format\n"); 2200 break; 2201 case 550: /* "No such file or directory" */ 2202 failf(data, "Given file does not exist"); 2203 result = CURLE_FTP_COULDNT_RETR_FILE; 2204 break; 2205 } 2206 2207 if(data->set.timecondition) { 2208 if((data->info.filetime > 0) && (data->set.timevalue > 0)) { 2209 switch(data->set.timecondition) { 2210 case CURL_TIMECOND_IFMODSINCE: 2211 default: 2212 if(data->info.filetime <= data->set.timevalue) { 2213 infof(data, "The requested document is not new enough\n"); 2214 ftp->transfer = FTPTRANSFER_NONE; /* mark to not transfer data */ 2215 data->info.timecond = TRUE; 2216 state(conn, FTP_STOP); 2217 return CURLE_OK; 2218 } 2219 break; 2220 case CURL_TIMECOND_IFUNMODSINCE: 2221 if(data->info.filetime > data->set.timevalue) { 2222 infof(data, "The requested document is not old enough\n"); 2223 ftp->transfer = FTPTRANSFER_NONE; /* mark to not transfer data */ 2224 data->info.timecond = TRUE; 2225 state(conn, FTP_STOP); 2226 return CURLE_OK; 2227 } 2228 break; 2229 } /* switch */ 2230 } 2231 else { 2232 infof(data, "Skipping time comparison\n"); 2233 } 2234 } 2235 2236 if(!result) 2237 result = ftp_state_type(conn); 2238 2239 return result; 2240 } 2241 2242 static CURLcode ftp_state_type_resp(struct connectdata *conn, 2243 int ftpcode, 2244 ftpstate instate) 2245 { 2246 CURLcode result = CURLE_OK; 2247 struct SessionHandle *data=conn->data; 2248 2249 if(ftpcode/100 != 2) { 2250 /* "sasserftpd" and "(u)r(x)bot ftpd" both responds with 226 after a 2251 successful 'TYPE I'. While that is not as RFC959 says, it is still a 2252 positive response code and we allow that. */ 2253 failf(data, "Couldn't set desired mode"); 2254 return CURLE_FTP_COULDNT_SET_TYPE; 2255 } 2256 if(ftpcode != 200) 2257 infof(data, "Got a %03d response code instead of the assumed 200\n", 2258 ftpcode); 2259 2260 if(instate == FTP_TYPE) 2261 result = ftp_state_size(conn); 2262 else if(instate == FTP_LIST_TYPE) 2263 result = ftp_state_list(conn); 2264 else if(instate == FTP_RETR_TYPE) 2265 result = ftp_state_retr_prequote(conn); 2266 else if(instate == FTP_STOR_TYPE) 2267 result = ftp_state_stor_prequote(conn); 2268 2269 return result; 2270 } 2271 2272 static CURLcode ftp_state_retr(struct connectdata *conn, 2273 curl_off_t filesize) 2274 { 2275 CURLcode result = CURLE_OK; 2276 struct SessionHandle *data=conn->data; 2277 struct FTP *ftp = data->req.protop; 2278 struct ftp_conn *ftpc = &conn->proto.ftpc; 2279 2280 if(data->set.max_filesize && (filesize > data->set.max_filesize)) { 2281 failf(data, "Maximum file size exceeded"); 2282 return CURLE_FILESIZE_EXCEEDED; 2283 } 2284 ftp->downloadsize = filesize; 2285 2286 if(data->state.resume_from) { 2287 /* We always (attempt to) get the size of downloads, so it is done before 2288 this even when not doing resumes. */ 2289 if(filesize == -1) { 2290 infof(data, "ftp server doesn't support SIZE\n"); 2291 /* We couldn't get the size and therefore we can't know if there really 2292 is a part of the file left to get, although the server will just 2293 close the connection when we start the connection so it won't cause 2294 us any harm, just not make us exit as nicely. */ 2295 } 2296 else { 2297 /* We got a file size report, so we check that there actually is a 2298 part of the file left to get, or else we go home. */ 2299 if(data->state.resume_from< 0) { 2300 /* We're supposed to download the last abs(from) bytes */ 2301 if(filesize < -data->state.resume_from) { 2302 failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T 2303 ") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")", 2304 data->state.resume_from, filesize); 2305 return CURLE_BAD_DOWNLOAD_RESUME; 2306 } 2307 /* convert to size to download */ 2308 ftp->downloadsize = -data->state.resume_from; 2309 /* download from where? */ 2310 data->state.resume_from = filesize - ftp->downloadsize; 2311 } 2312 else { 2313 if(filesize < data->state.resume_from) { 2314 failf(data, "Offset (%" CURL_FORMAT_CURL_OFF_T 2315 ") was beyond file size (%" CURL_FORMAT_CURL_OFF_T ")", 2316 data->state.resume_from, filesize); 2317 return CURLE_BAD_DOWNLOAD_RESUME; 2318 } 2319 /* Now store the number of bytes we are expected to download */ 2320 ftp->downloadsize = filesize-data->state.resume_from; 2321 } 2322 } 2323 2324 if(ftp->downloadsize == 0) { 2325 /* no data to transfer */ 2326 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL); 2327 infof(data, "File already completely downloaded\n"); 2328 2329 /* Set ->transfer so that we won't get any error in ftp_done() 2330 * because we didn't transfer the any file */ 2331 ftp->transfer = FTPTRANSFER_NONE; 2332 state(conn, FTP_STOP); 2333 return CURLE_OK; 2334 } 2335 2336 /* Set resume file transfer offset */ 2337 infof(data, "Instructs server to resume from offset %" 2338 CURL_FORMAT_CURL_OFF_T "\n", data->state.resume_from); 2339 2340 PPSENDF(&ftpc->pp, "REST %" CURL_FORMAT_CURL_OFF_T, 2341 data->state.resume_from); 2342 2343 state(conn, FTP_RETR_REST); 2344 } 2345 else { 2346 /* no resume */ 2347 PPSENDF(&ftpc->pp, "RETR %s", ftpc->file); 2348 state(conn, FTP_RETR); 2349 } 2350 2351 return result; 2352 } 2353 2354 static CURLcode ftp_state_size_resp(struct connectdata *conn, 2355 int ftpcode, 2356 ftpstate instate) 2357 { 2358 CURLcode result = CURLE_OK; 2359 struct SessionHandle *data=conn->data; 2360 curl_off_t filesize; 2361 char *buf = data->state.buffer; 2362 2363 /* get the size from the ascii string: */ 2364 filesize = (ftpcode == 213)?curlx_strtoofft(buf+4, NULL, 0):-1; 2365 2366 if(instate == FTP_SIZE) { 2367 #ifdef CURL_FTP_HTTPSTYLE_HEAD 2368 if(-1 != filesize) { 2369 snprintf(buf, sizeof(data->state.buffer), 2370 "Content-Length: %" CURL_FORMAT_CURL_OFF_T "\r\n", filesize); 2371 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0); 2372 if(result) 2373 return result; 2374 } 2375 #endif 2376 Curl_pgrsSetDownloadSize(data, filesize); 2377 result = ftp_state_rest(conn); 2378 } 2379 else if(instate == FTP_RETR_SIZE) { 2380 Curl_pgrsSetDownloadSize(data, filesize); 2381 result = ftp_state_retr(conn, filesize); 2382 } 2383 else if(instate == FTP_STOR_SIZE) { 2384 data->state.resume_from = filesize; 2385 result = ftp_state_ul_setup(conn, TRUE); 2386 } 2387 2388 return result; 2389 } 2390 2391 static CURLcode ftp_state_rest_resp(struct connectdata *conn, 2392 int ftpcode, 2393 ftpstate instate) 2394 { 2395 CURLcode result = CURLE_OK; 2396 struct ftp_conn *ftpc = &conn->proto.ftpc; 2397 2398 switch(instate) { 2399 case FTP_REST: 2400 default: 2401 #ifdef CURL_FTP_HTTPSTYLE_HEAD 2402 if(ftpcode == 350) { 2403 char buffer[24]= { "Accept-ranges: bytes\r\n" }; 2404 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buffer, 0); 2405 if(result) 2406 return result; 2407 } 2408 #endif 2409 result = ftp_state_prepare_transfer(conn); 2410 break; 2411 2412 case FTP_RETR_REST: 2413 if(ftpcode != 350) { 2414 failf(conn->data, "Couldn't use REST"); 2415 result = CURLE_FTP_COULDNT_USE_REST; 2416 } 2417 else { 2418 PPSENDF(&ftpc->pp, "RETR %s", ftpc->file); 2419 state(conn, FTP_RETR); 2420 } 2421 break; 2422 } 2423 2424 return result; 2425 } 2426 2427 static CURLcode ftp_state_stor_resp(struct connectdata *conn, 2428 int ftpcode, ftpstate instate) 2429 { 2430 CURLcode result = CURLE_OK; 2431 struct SessionHandle *data = conn->data; 2432 2433 if(ftpcode>=400) { 2434 failf(data, "Failed FTP upload: %0d", ftpcode); 2435 state(conn, FTP_STOP); 2436 /* oops, we never close the sockets! */ 2437 return CURLE_UPLOAD_FAILED; 2438 } 2439 2440 conn->proto.ftpc.state_saved = instate; 2441 2442 /* PORT means we are now awaiting the server to connect to us. */ 2443 if(data->set.ftp_use_port) { 2444 bool connected; 2445 2446 state(conn, FTP_STOP); /* no longer in STOR state */ 2447 2448 result = AllowServerConnect(conn, &connected); 2449 if(result) 2450 return result; 2451 2452 if(!connected) { 2453 struct ftp_conn *ftpc = &conn->proto.ftpc; 2454 infof(data, "Data conn was not available immediately\n"); 2455 ftpc->wait_data_conn = TRUE; 2456 } 2457 2458 return CURLE_OK; 2459 } 2460 else 2461 return InitiateTransfer(conn); 2462 } 2463 2464 /* for LIST and RETR responses */ 2465 static CURLcode ftp_state_get_resp(struct connectdata *conn, 2466 int ftpcode, 2467 ftpstate instate) 2468 { 2469 CURLcode result = CURLE_OK; 2470 struct SessionHandle *data = conn->data; 2471 struct FTP *ftp = data->req.protop; 2472 char *buf = data->state.buffer; 2473 2474 if((ftpcode == 150) || (ftpcode == 125)) { 2475 2476 /* 2477 A; 2478 150 Opening BINARY mode data connection for /etc/passwd (2241 2479 bytes). (ok, the file is being transferred) 2480 2481 B: 2482 150 Opening ASCII mode data connection for /bin/ls 2483 2484 C: 2485 150 ASCII data connection for /bin/ls (137.167.104.91,37445) (0 bytes). 2486 2487 D: 2488 150 Opening ASCII mode data connection for [file] (0.0.0.0,0) (545 bytes) 2489 2490 E: 2491 125 Data connection already open; Transfer starting. */ 2492 2493 curl_off_t size=-1; /* default unknown size */ 2494 2495 2496 /* 2497 * It appears that there are FTP-servers that return size 0 for files when 2498 * SIZE is used on the file while being in BINARY mode. To work around 2499 * that (stupid) behavior, we attempt to parse the RETR response even if 2500 * the SIZE returned size zero. 2501 * 2502 * Debugging help from Salvatore Sorrentino on February 26, 2003. 2503 */ 2504 2505 if((instate != FTP_LIST) && 2506 !data->set.prefer_ascii && 2507 (ftp->downloadsize < 1)) { 2508 /* 2509 * It seems directory listings either don't show the size or very 2510 * often uses size 0 anyway. ASCII transfers may very well turn out 2511 * that the transferred amount of data is not the same as this line 2512 * tells, why using this number in those cases only confuses us. 2513 * 2514 * Example D above makes this parsing a little tricky */ 2515 char *bytes; 2516 bytes=strstr(buf, " bytes"); 2517 if(bytes--) { 2518 long in=(long)(bytes-buf); 2519 /* this is a hint there is size information in there! ;-) */ 2520 while(--in) { 2521 /* scan for the left parenthesis and break there */ 2522 if('(' == *bytes) 2523 break; 2524 /* skip only digits */ 2525 if(!ISDIGIT(*bytes)) { 2526 bytes=NULL; 2527 break; 2528 } 2529 /* one more estep backwards */ 2530 bytes--; 2531 } 2532 /* if we have nothing but digits: */ 2533 if(bytes++) { 2534 /* get the number! */ 2535 size = curlx_strtoofft(bytes, NULL, 0); 2536 } 2537 } 2538 } 2539 else if(ftp->downloadsize > -1) 2540 size = ftp->downloadsize; 2541 2542 if(size > data->req.maxdownload && data->req.maxdownload > 0) 2543 size = data->req.size = data->req.maxdownload; 2544 else if((instate != FTP_LIST) && (data->set.prefer_ascii)) 2545 size = -1; /* kludge for servers that understate ASCII mode file size */ 2546 2547 infof(data, "Maxdownload = %" CURL_FORMAT_CURL_OFF_T "\n", 2548 data->req.maxdownload); 2549 2550 if(instate != FTP_LIST) 2551 infof(data, "Getting file with size: %" CURL_FORMAT_CURL_OFF_T "\n", 2552 size); 2553 2554 /* FTP download: */ 2555 conn->proto.ftpc.state_saved = instate; 2556 conn->proto.ftpc.retr_size_saved = size; 2557 2558 if(data->set.ftp_use_port) { 2559 bool connected; 2560 2561 result = AllowServerConnect(conn, &connected); 2562 if(result) 2563 return result; 2564 2565 if(!connected) { 2566 struct ftp_conn *ftpc = &conn->proto.ftpc; 2567 infof(data, "Data conn was not available immediately\n"); 2568 state(conn, FTP_STOP); 2569 ftpc->wait_data_conn = TRUE; 2570 } 2571 } 2572 else 2573 return InitiateTransfer(conn); 2574 } 2575 else { 2576 if((instate == FTP_LIST) && (ftpcode == 450)) { 2577 /* simply no matching files in the dir listing */ 2578 ftp->transfer = FTPTRANSFER_NONE; /* don't download anything */ 2579 state(conn, FTP_STOP); /* this phase is over */ 2580 } 2581 else { 2582 failf(data, "RETR response: %03d", ftpcode); 2583 return instate == FTP_RETR && ftpcode == 550? 2584 CURLE_REMOTE_FILE_NOT_FOUND: 2585 CURLE_FTP_COULDNT_RETR_FILE; 2586 } 2587 } 2588 2589 return result; 2590 } 2591 2592 /* after USER, PASS and ACCT */ 2593 static CURLcode ftp_state_loggedin(struct connectdata *conn) 2594 { 2595 CURLcode result = CURLE_OK; 2596 2597 if(conn->ssl[FIRSTSOCKET].use) { 2598 /* PBSZ = PROTECTION BUFFER SIZE. 2599 2600 The 'draft-murray-auth-ftp-ssl' (draft 12, page 7) says: 2601 2602 Specifically, the PROT command MUST be preceded by a PBSZ 2603 command and a PBSZ command MUST be preceded by a successful 2604 security data exchange (the TLS negotiation in this case) 2605 2606 ... (and on page 8): 2607 2608 Thus the PBSZ command must still be issued, but must have a 2609 parameter of '0' to indicate that no buffering is taking place 2610 and the data connection should not be encapsulated. 2611 */ 2612 PPSENDF(&conn->proto.ftpc.pp, "PBSZ %d", 0); 2613 state(conn, FTP_PBSZ); 2614 } 2615 else { 2616 result = ftp_state_pwd(conn); 2617 } 2618 return result; 2619 } 2620 2621 /* for USER and PASS responses */ 2622 static CURLcode ftp_state_user_resp(struct connectdata *conn, 2623 int ftpcode, 2624 ftpstate instate) 2625 { 2626 CURLcode result = CURLE_OK; 2627 struct SessionHandle *data = conn->data; 2628 struct FTP *ftp = data->req.protop; 2629 struct ftp_conn *ftpc = &conn->proto.ftpc; 2630 (void)instate; /* no use for this yet */ 2631 2632 /* some need password anyway, and others just return 2xx ignored */ 2633 if((ftpcode == 331) && (ftpc->state == FTP_USER)) { 2634 /* 331 Password required for ... 2635 (the server requires to send the user's password too) */ 2636 PPSENDF(&ftpc->pp, "PASS %s", ftp->passwd?ftp->passwd:""); 2637 state(conn, FTP_PASS); 2638 } 2639 else if(ftpcode/100 == 2) { 2640 /* 230 User ... logged in. 2641 (the user logged in with or without password) */ 2642 result = ftp_state_loggedin(conn); 2643 } 2644 else if(ftpcode == 332) { 2645 if(data->set.str[STRING_FTP_ACCOUNT]) { 2646 PPSENDF(&ftpc->pp, "ACCT %s", data->set.str[STRING_FTP_ACCOUNT]); 2647 state(conn, FTP_ACCT); 2648 } 2649 else { 2650 failf(data, "ACCT requested but none available"); 2651 result = CURLE_LOGIN_DENIED; 2652 } 2653 } 2654 else { 2655 /* All other response codes, like: 2656 2657 530 User ... access denied 2658 (the server denies to log the specified user) */ 2659 2660 if(conn->data->set.str[STRING_FTP_ALTERNATIVE_TO_USER] && 2661 !conn->data->state.ftp_trying_alternative) { 2662 /* Ok, USER failed. Let's try the supplied command. */ 2663 PPSENDF(&conn->proto.ftpc.pp, "%s", 2664 conn->data->set.str[STRING_FTP_ALTERNATIVE_TO_USER]); 2665 conn->data->state.ftp_trying_alternative = TRUE; 2666 state(conn, FTP_USER); 2667 result = CURLE_OK; 2668 } 2669 else { 2670 failf(data, "Access denied: %03d", ftpcode); 2671 result = CURLE_LOGIN_DENIED; 2672 } 2673 } 2674 return result; 2675 } 2676 2677 /* for ACCT response */ 2678 static CURLcode ftp_state_acct_resp(struct connectdata *conn, 2679 int ftpcode) 2680 { 2681 CURLcode result = CURLE_OK; 2682 struct SessionHandle *data = conn->data; 2683 if(ftpcode != 230) { 2684 failf(data, "ACCT rejected by server: %03d", ftpcode); 2685 result = CURLE_FTP_WEIRD_PASS_REPLY; /* FIX */ 2686 } 2687 else 2688 result = ftp_state_loggedin(conn); 2689 2690 return result; 2691 } 2692 2693 2694 static CURLcode ftp_statemach_act(struct connectdata *conn) 2695 { 2696 CURLcode result; 2697 curl_socket_t sock = conn->sock[FIRSTSOCKET]; 2698 struct SessionHandle *data=conn->data; 2699 int ftpcode; 2700 struct ftp_conn *ftpc = &conn->proto.ftpc; 2701 struct pingpong *pp = &ftpc->pp; 2702 static const char ftpauth[][4] = { "SSL", "TLS" }; 2703 size_t nread = 0; 2704 2705 if(pp->sendleft) 2706 return Curl_pp_flushsend(pp); 2707 2708 result = ftp_readresp(sock, pp, &ftpcode, &nread); 2709 if(result) 2710 return result; 2711 2712 if(ftpcode) { 2713 /* we have now received a full FTP server response */ 2714 switch(ftpc->state) { 2715 case FTP_WAIT220: 2716 if(ftpcode == 230) 2717 /* 230 User logged in - already! */ 2718 return ftp_state_user_resp(conn, ftpcode, ftpc->state); 2719 else if(ftpcode != 220) { 2720 failf(data, "Got a %03d ftp-server response when 220 was expected", 2721 ftpcode); 2722 return CURLE_FTP_WEIRD_SERVER_REPLY; 2723 } 2724 2725 /* We have received a 220 response fine, now we proceed. */ 2726 #ifdef HAVE_GSSAPI 2727 if(data->set.krb) { 2728 /* If not anonymous login, try a secure login. Note that this 2729 procedure is still BLOCKING. */ 2730 2731 Curl_sec_request_prot(conn, "private"); 2732 /* We set private first as default, in case the line below fails to 2733 set a valid level */ 2734 Curl_sec_request_prot(conn, data->set.str[STRING_KRB_LEVEL]); 2735 2736 if(Curl_sec_login(conn)) 2737 infof(data, "Logging in with password in cleartext!\n"); 2738 else 2739 infof(data, "Authentication successful\n"); 2740 } 2741 #endif 2742 2743 if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) { 2744 /* We don't have a SSL/TLS connection yet, but FTPS is 2745 requested. Try a FTPS connection now */ 2746 2747 ftpc->count3=0; 2748 switch(data->set.ftpsslauth) { 2749 case CURLFTPAUTH_DEFAULT: 2750 case CURLFTPAUTH_SSL: 2751 ftpc->count2 = 1; /* add one to get next */ 2752 ftpc->count1 = 0; 2753 break; 2754 case CURLFTPAUTH_TLS: 2755 ftpc->count2 = -1; /* subtract one to get next */ 2756 ftpc->count1 = 1; 2757 break; 2758 default: 2759 failf(data, "unsupported parameter to CURLOPT_FTPSSLAUTH: %d", 2760 (int)data->set.ftpsslauth); 2761 return CURLE_UNKNOWN_OPTION; /* we don't know what to do */ 2762 } 2763 PPSENDF(&ftpc->pp, "AUTH %s", ftpauth[ftpc->count1]); 2764 state(conn, FTP_AUTH); 2765 } 2766 else { 2767 result = ftp_state_user(conn); 2768 if(result) 2769 return result; 2770 } 2771 2772 break; 2773 2774 case FTP_AUTH: 2775 /* we have gotten the response to a previous AUTH command */ 2776 2777 /* RFC2228 (page 5) says: 2778 * 2779 * If the server is willing to accept the named security mechanism, 2780 * and does not require any security data, it must respond with 2781 * reply code 234/334. 2782 */ 2783 2784 if((ftpcode == 234) || (ftpcode == 334)) { 2785 /* Curl_ssl_connect is BLOCKING */ 2786 result = Curl_ssl_connect(conn, FIRSTSOCKET); 2787 if(!result) { 2788 conn->ssl[SECONDARYSOCKET].use = FALSE; /* clear-text data */ 2789 result = ftp_state_user(conn); 2790 } 2791 } 2792 else if(ftpc->count3 < 1) { 2793 ftpc->count3++; 2794 ftpc->count1 += ftpc->count2; /* get next attempt */ 2795 result = Curl_pp_sendf(&ftpc->pp, "AUTH %s", ftpauth[ftpc->count1]); 2796 /* remain in this same state */ 2797 } 2798 else { 2799 if(data->set.use_ssl > CURLUSESSL_TRY) 2800 /* we failed and CURLUSESSL_CONTROL or CURLUSESSL_ALL is set */ 2801 result = CURLE_USE_SSL_FAILED; 2802 else 2803 /* ignore the failure and continue */ 2804 result = ftp_state_user(conn); 2805 } 2806 2807 if(result) 2808 return result; 2809 break; 2810 2811 case FTP_USER: 2812 case FTP_PASS: 2813 result = ftp_state_user_resp(conn, ftpcode, ftpc->state); 2814 break; 2815 2816 case FTP_ACCT: 2817 result = ftp_state_acct_resp(conn, ftpcode); 2818 break; 2819 2820 case FTP_PBSZ: 2821 PPSENDF(&ftpc->pp, "PROT %c", 2822 data->set.use_ssl == CURLUSESSL_CONTROL ? 'C' : 'P'); 2823 state(conn, FTP_PROT); 2824 2825 break; 2826 2827 case FTP_PROT: 2828 if(ftpcode/100 == 2) 2829 /* We have enabled SSL for the data connection! */ 2830 conn->ssl[SECONDARYSOCKET].use = 2831 (data->set.use_ssl != CURLUSESSL_CONTROL) ? TRUE : FALSE; 2832 /* FTP servers typically responds with 500 if they decide to reject 2833 our 'P' request */ 2834 else if(data->set.use_ssl > CURLUSESSL_CONTROL) 2835 /* we failed and bails out */ 2836 return CURLE_USE_SSL_FAILED; 2837 2838 if(data->set.ftp_ccc) { 2839 /* CCC - Clear Command Channel 2840 */ 2841 PPSENDF(&ftpc->pp, "%s", "CCC"); 2842 state(conn, FTP_CCC); 2843 } 2844 else { 2845 result = ftp_state_pwd(conn); 2846 if(result) 2847 return result; 2848 } 2849 break; 2850 2851 case FTP_CCC: 2852 if(ftpcode < 500) { 2853 /* First shut down the SSL layer (note: this call will block) */ 2854 result = Curl_ssl_shutdown(conn, FIRSTSOCKET); 2855 2856 if(result) { 2857 failf(conn->data, "Failed to clear the command channel (CCC)"); 2858 return result; 2859 } 2860 } 2861 2862 /* Then continue as normal */ 2863 result = ftp_state_pwd(conn); 2864 if(result) 2865 return result; 2866 break; 2867 2868 case FTP_PWD: 2869 if(ftpcode == 257) { 2870 char *ptr=&data->state.buffer[4]; /* start on the first letter */ 2871 char *dir; 2872 char *store; 2873 2874 dir = malloc(nread + 1); 2875 if(!dir) 2876 return CURLE_OUT_OF_MEMORY; 2877 2878 /* Reply format is like 2879 257<space>[rubbish]"<directory-name>"<space><commentary> and the 2880 RFC959 says 2881 2882 The directory name can contain any character; embedded 2883 double-quotes should be escaped by double-quotes (the 2884 "quote-doubling" convention). 2885 */ 2886 2887 /* scan for the first double-quote for non-standard responses */ 2888 while(ptr < &data->state.buffer[sizeof(data->state.buffer)] 2889 && *ptr != '\n' && *ptr != '\0' && *ptr != '"') 2890 ptr++; 2891 2892 if('\"' == *ptr) { 2893 /* it started good */ 2894 ptr++; 2895 for(store = dir; *ptr;) { 2896 if('\"' == *ptr) { 2897 if('\"' == ptr[1]) { 2898 /* "quote-doubling" */ 2899 *store = ptr[1]; 2900 ptr++; 2901 } 2902 else { 2903 /* end of path */ 2904 *store = '\0'; /* zero terminate */ 2905 break; /* get out of this loop */ 2906 } 2907 } 2908 else 2909 *store = *ptr; 2910 store++; 2911 ptr++; 2912 } 2913 2914 /* If the path name does not look like an absolute path (i.e.: it 2915 does not start with a '/'), we probably need some server-dependent 2916 adjustments. For example, this is the case when connecting to 2917 an OS400 FTP server: this server supports two name syntaxes, 2918 the default one being incompatible with standard pathes. In 2919 addition, this server switches automatically to the regular path 2920 syntax when one is encountered in a command: this results in 2921 having an entrypath in the wrong syntax when later used in CWD. 2922 The method used here is to check the server OS: we do it only 2923 if the path name looks strange to minimize overhead on other 2924 systems. */ 2925 2926 if(!ftpc->server_os && dir[0] != '/') { 2927 2928 result = Curl_pp_sendf(&ftpc->pp, "%s", "SYST"); 2929 if(result) { 2930 free(dir); 2931 return result; 2932 } 2933 Curl_safefree(ftpc->entrypath); 2934 ftpc->entrypath = dir; /* remember this */ 2935 infof(data, "Entry path is '%s'\n", ftpc->entrypath); 2936 /* also save it where getinfo can access it: */ 2937 data->state.most_recent_ftp_entrypath = ftpc->entrypath; 2938 state(conn, FTP_SYST); 2939 break; 2940 } 2941 2942 Curl_safefree(ftpc->entrypath); 2943 ftpc->entrypath = dir; /* remember this */ 2944 infof(data, "Entry path is '%s'\n", ftpc->entrypath); 2945 /* also save it where getinfo can access it: */ 2946 data->state.most_recent_ftp_entrypath = ftpc->entrypath; 2947 } 2948 else { 2949 /* couldn't get the path */ 2950 free(dir); 2951 infof(data, "Failed to figure out path\n"); 2952 } 2953 } 2954 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */ 2955 DEBUGF(infof(data, "protocol connect phase DONE\n")); 2956 break; 2957 2958 case FTP_SYST: 2959 if(ftpcode == 215) { 2960 char *ptr=&data->state.buffer[4]; /* start on the first letter */ 2961 char *os; 2962 char *store; 2963 2964 os = malloc(nread + 1); 2965 if(!os) 2966 return CURLE_OUT_OF_MEMORY; 2967 2968 /* Reply format is like 2969 215<space><OS-name><space><commentary> 2970 */ 2971 while(*ptr == ' ') 2972 ptr++; 2973 for(store = os; *ptr && *ptr != ' ';) 2974 *store++ = *ptr++; 2975 *store = '\0'; /* zero terminate */ 2976 2977 /* Check for special servers here. */ 2978 2979 if(strequal(os, "OS/400")) { 2980 /* Force OS400 name format 1. */ 2981 result = Curl_pp_sendf(&ftpc->pp, "%s", "SITE NAMEFMT 1"); 2982 if(result) { 2983 free(os); 2984 return result; 2985 } 2986 /* remember target server OS */ 2987 Curl_safefree(ftpc->server_os); 2988 ftpc->server_os = os; 2989 state(conn, FTP_NAMEFMT); 2990 break; 2991 } 2992 else { 2993 /* Nothing special for the target server. */ 2994 /* remember target server OS */ 2995 Curl_safefree(ftpc->server_os); 2996 ftpc->server_os = os; 2997 } 2998 } 2999 else { 3000 /* Cannot identify server OS. Continue anyway and cross fingers. */ 3001 } 3002 3003 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */ 3004 DEBUGF(infof(data, "protocol connect phase DONE\n")); 3005 break; 3006 3007 case FTP_NAMEFMT: 3008 if(ftpcode == 250) { 3009 /* Name format change successful: reload initial path. */ 3010 ftp_state_pwd(conn); 3011 break; 3012 } 3013 3014 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */ 3015 DEBUGF(infof(data, "protocol connect phase DONE\n")); 3016 break; 3017 3018 case FTP_QUOTE: 3019 case FTP_POSTQUOTE: 3020 case FTP_RETR_PREQUOTE: 3021 case FTP_STOR_PREQUOTE: 3022 if((ftpcode >= 400) && !ftpc->count2) { 3023 /* failure response code, and not allowed to fail */ 3024 failf(conn->data, "QUOT command failed with %03d", ftpcode); 3025 return CURLE_QUOTE_ERROR; 3026 } 3027 result = ftp_state_quote(conn, FALSE, ftpc->state); 3028 if(result) 3029 return result; 3030 3031 break; 3032 3033 case FTP_CWD: 3034 if(ftpcode/100 != 2) { 3035 /* failure to CWD there */ 3036 if(conn->data->set.ftp_create_missing_dirs && 3037 ftpc->count1 && !ftpc->count2) { 3038 /* try making it */ 3039 ftpc->count2++; /* counter to prevent CWD-MKD loops */ 3040 PPSENDF(&ftpc->pp, "MKD %s", ftpc->dirs[ftpc->count1 - 1]); 3041 state(conn, FTP_MKD); 3042 } 3043 else { 3044 /* return failure */ 3045 failf(data, "Server denied you to change to the given directory"); 3046 ftpc->cwdfail = TRUE; /* don't remember this path as we failed 3047 to enter it */ 3048 return CURLE_REMOTE_ACCESS_DENIED; 3049 } 3050 } 3051 else { 3052 /* success */ 3053 ftpc->count2=0; 3054 if(++ftpc->count1 <= ftpc->dirdepth) { 3055 /* send next CWD */ 3056 PPSENDF(&ftpc->pp, "CWD %s", ftpc->dirs[ftpc->count1 - 1]); 3057 } 3058 else { 3059 result = ftp_state_mdtm(conn); 3060 if(result) 3061 return result; 3062 } 3063 } 3064 break; 3065 3066 case FTP_MKD: 3067 if((ftpcode/100 != 2) && !ftpc->count3--) { 3068 /* failure to MKD the dir */ 3069 failf(data, "Failed to MKD dir: %03d", ftpcode); 3070 return CURLE_REMOTE_ACCESS_DENIED; 3071 } 3072 state(conn, FTP_CWD); 3073 /* send CWD */ 3074 PPSENDF(&ftpc->pp, "CWD %s", ftpc->dirs[ftpc->count1 - 1]); 3075 break; 3076 3077 case FTP_MDTM: 3078 result = ftp_state_mdtm_resp(conn, ftpcode); 3079 break; 3080 3081 case FTP_TYPE: 3082 case FTP_LIST_TYPE: 3083 case FTP_RETR_TYPE: 3084 case FTP_STOR_TYPE: 3085 result = ftp_state_type_resp(conn, ftpcode, ftpc->state); 3086 break; 3087 3088 case FTP_SIZE: 3089 case FTP_RETR_SIZE: 3090 case FTP_STOR_SIZE: 3091 result = ftp_state_size_resp(conn, ftpcode, ftpc->state); 3092 break; 3093 3094 case FTP_REST: 3095 case FTP_RETR_REST: 3096 result = ftp_state_rest_resp(conn, ftpcode, ftpc->state); 3097 break; 3098 3099 case FTP_PRET: 3100 if(ftpcode != 200) { 3101 /* there only is this one standard OK return code. */ 3102 failf(data, "PRET command not accepted: %03d", ftpcode); 3103 return CURLE_FTP_PRET_FAILED; 3104 } 3105 result = ftp_state_use_pasv(conn); 3106 break; 3107 3108 case FTP_PASV: 3109 result = ftp_state_pasv_resp(conn, ftpcode); 3110 break; 3111 3112 case FTP_PORT: 3113 result = ftp_state_port_resp(conn, ftpcode); 3114 break; 3115 3116 case FTP_LIST: 3117 case FTP_RETR: 3118 result = ftp_state_get_resp(conn, ftpcode, ftpc->state); 3119 break; 3120 3121 case FTP_STOR: 3122 result = ftp_state_stor_resp(conn, ftpcode, ftpc->state); 3123 break; 3124 3125 case FTP_QUIT: 3126 /* fallthrough, just stop! */ 3127 default: 3128 /* internal error */ 3129 state(conn, FTP_STOP); 3130 break; 3131 } 3132 } /* if(ftpcode) */ 3133 3134 return result; 3135 } 3136 3137 3138 /* called repeatedly until done from multi.c */ 3139 static CURLcode ftp_multi_statemach(struct connectdata *conn, 3140 bool *done) 3141 { 3142 struct ftp_conn *ftpc = &conn->proto.ftpc; 3143 CURLcode result = Curl_pp_statemach(&ftpc->pp, FALSE); 3144 3145 /* Check for the state outside of the Curl_socket_ready() return code checks 3146 since at times we are in fact already in this state when this function 3147 gets called. */ 3148 *done = (ftpc->state == FTP_STOP) ? TRUE : FALSE; 3149 3150 return result; 3151 } 3152 3153 static CURLcode ftp_block_statemach(struct connectdata *conn) 3154 { 3155 struct ftp_conn *ftpc = &conn->proto.ftpc; 3156 struct pingpong *pp = &ftpc->pp; 3157 CURLcode result = CURLE_OK; 3158 3159 while(ftpc->state != FTP_STOP) { 3160 result = Curl_pp_statemach(pp, TRUE); 3161 if(result) 3162 break; 3163 } 3164 3165 return result; 3166 } 3167 3168 /* 3169 * ftp_connect() should do everything that is to be considered a part of 3170 * the connection phase. 3171 * 3172 * The variable 'done' points to will be TRUE if the protocol-layer connect 3173 * phase is done when this function returns, or FALSE if not. 3174 * 3175 */ 3176 static CURLcode ftp_connect(struct connectdata *conn, 3177 bool *done) /* see description above */ 3178 { 3179 CURLcode result; 3180 struct ftp_conn *ftpc = &conn->proto.ftpc; 3181 struct pingpong *pp = &ftpc->pp; 3182 3183 *done = FALSE; /* default to not done yet */ 3184 3185 /* We always support persistent connections on ftp */ 3186 connkeep(conn, "FTP default"); 3187 3188 pp->response_time = RESP_TIMEOUT; /* set default response time-out */ 3189 pp->statemach_act = ftp_statemach_act; 3190 pp->endofresp = ftp_endofresp; 3191 pp->conn = conn; 3192 3193 if(conn->handler->flags & PROTOPT_SSL) { 3194 /* BLOCKING */ 3195 result = Curl_ssl_connect(conn, FIRSTSOCKET); 3196 if(result) 3197 return result; 3198 } 3199 3200 Curl_pp_init(pp); /* init the generic pingpong data */ 3201 3202 /* When we connect, we start in the state where we await the 220 3203 response */ 3204 state(conn, FTP_WAIT220); 3205 3206 result = ftp_multi_statemach(conn, done); 3207 3208 return result; 3209 } 3210 3211 /*********************************************************************** 3212 * 3213 * ftp_done() 3214 * 3215 * The DONE function. This does what needs to be done after a single DO has 3216 * performed. 3217 * 3218 * Input argument is already checked for validity. 3219 */ 3220 static CURLcode ftp_done(struct connectdata *conn, CURLcode status, 3221 bool premature) 3222 { 3223 struct SessionHandle *data = conn->data; 3224 struct FTP *ftp = data->req.protop; 3225 struct ftp_conn *ftpc = &conn->proto.ftpc; 3226 struct pingpong *pp = &ftpc->pp; 3227 ssize_t nread; 3228 int ftpcode; 3229 CURLcode result = CURLE_OK; 3230 bool was_ctl_valid = ftpc->ctl_valid; 3231 char *path; 3232 const char *path_to_use = data->state.path; 3233 3234 if(!ftp) 3235 /* When the easy handle is removed from the multi while libcurl is still 3236 * trying to resolve the host name, it seems that the ftp struct is not 3237 * yet initialized, but the removal action calls Curl_done() which calls 3238 * this function. So we simply return success if no ftp pointer is set. 3239 */ 3240 return CURLE_OK; 3241 3242 switch(status) { 3243 case CURLE_BAD_DOWNLOAD_RESUME: 3244 case CURLE_FTP_WEIRD_PASV_REPLY: 3245 case CURLE_FTP_PORT_FAILED: 3246 case CURLE_FTP_ACCEPT_FAILED: 3247 case CURLE_FTP_ACCEPT_TIMEOUT: 3248 case CURLE_FTP_COULDNT_SET_TYPE: 3249 case CURLE_FTP_COULDNT_RETR_FILE: 3250 case CURLE_PARTIAL_FILE: 3251 case CURLE_UPLOAD_FAILED: 3252 case CURLE_REMOTE_ACCESS_DENIED: 3253 case CURLE_FILESIZE_EXCEEDED: 3254 case CURLE_REMOTE_FILE_NOT_FOUND: 3255 case CURLE_WRITE_ERROR: 3256 /* the connection stays alive fine even though this happened */ 3257 /* fall-through */ 3258 case CURLE_OK: /* doesn't affect the control connection's status */ 3259 if(!premature) { 3260 ftpc->ctl_valid = was_ctl_valid; 3261 break; 3262 } 3263 /* until we cope better with prematurely ended requests, let them 3264 * fallback as if in complete failure */ 3265 default: /* by default, an error means the control connection is 3266 wedged and should not be used anymore */ 3267 ftpc->ctl_valid = FALSE; 3268 ftpc->cwdfail = TRUE; /* set this TRUE to prevent us to remember the 3269 current path, as this connection is going */ 3270 connclose(conn, "FTP ended with bad error code"); 3271 result = status; /* use the already set error code */ 3272 break; 3273 } 3274 3275 /* now store a copy of the directory we are in */ 3276 free(ftpc->prevpath); 3277 3278 if(data->set.wildcardmatch) { 3279 if(data->set.chunk_end && ftpc->file) { 3280 data->set.chunk_end(data->wildcard.customptr); 3281 } 3282 ftpc->known_filesize = -1; 3283 } 3284 3285 /* get the "raw" path */ 3286 path = curl_easy_unescape(data, path_to_use, 0, NULL); 3287 if(!path) { 3288 /* out of memory, but we can limp along anyway (and should try to 3289 * since we may already be in the out of memory cleanup path) */ 3290 if(!result) 3291 result = CURLE_OUT_OF_MEMORY; 3292 ftpc->ctl_valid = FALSE; /* mark control connection as bad */ 3293 connclose(conn, "FTP: out of memory!"); /* mark for connection closure */ 3294 ftpc->prevpath = NULL; /* no path remembering */ 3295 } 3296 else { 3297 size_t flen = ftpc->file?strlen(ftpc->file):0; /* file is "raw" already */ 3298 size_t dlen = strlen(path)-flen; 3299 if(!ftpc->cwdfail) { 3300 if(dlen && (data->set.ftp_filemethod != FTPFILE_NOCWD)) { 3301 ftpc->prevpath = path; 3302 if(flen) 3303 /* if 'path' is not the whole string */ 3304 ftpc->prevpath[dlen]=0; /* terminate */ 3305 } 3306 else { 3307 /* we never changed dir */ 3308 ftpc->prevpath=strdup(""); 3309 free(path); 3310 } 3311 if(ftpc->prevpath) 3312 infof(data, "Remembering we are in dir \"%s\"\n", ftpc->prevpath); 3313 } 3314 else { 3315 ftpc->prevpath = NULL; /* no path */ 3316 free(path); 3317 } 3318 } 3319 /* free the dir tree and file parts */ 3320 freedirs(ftpc); 3321 3322 /* shut down the socket to inform the server we're done */ 3323 3324 #ifdef _WIN32_WCE 3325 shutdown(conn->sock[SECONDARYSOCKET], 2); /* SD_BOTH */ 3326 #endif 3327 3328 if(conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD) { 3329 if(!result && ftpc->dont_check && data->req.maxdownload > 0) { 3330 /* partial download completed */ 3331 result = Curl_pp_sendf(pp, "%s", "ABOR"); 3332 if(result) { 3333 failf(data, "Failure sending ABOR command: %s", 3334 curl_easy_strerror(result)); 3335 ftpc->ctl_valid = FALSE; /* mark control connection as bad */ 3336 connclose(conn, "ABOR command failed"); /* connection closure */ 3337 } 3338 } 3339 3340 if(conn->ssl[SECONDARYSOCKET].use) { 3341 /* The secondary socket is using SSL so we must close down that part 3342 first before we close the socket for real */ 3343 Curl_ssl_close(conn, SECONDARYSOCKET); 3344 3345 /* Note that we keep "use" set to TRUE since that (next) connection is 3346 still requested to use SSL */ 3347 } 3348 if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET]) { 3349 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]); 3350 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; 3351 conn->bits.tcpconnect[SECONDARYSOCKET] = FALSE; 3352 } 3353 } 3354 3355 if(!result && (ftp->transfer == FTPTRANSFER_BODY) && ftpc->ctl_valid && 3356 pp->pending_resp && !premature) { 3357 /* 3358 * Let's see what the server says about the transfer we just performed, 3359 * but lower the timeout as sometimes this connection has died while the 3360 * data has been transferred. This happens when doing through NATs etc that 3361 * abandon old silent connections. 3362 */ 3363 long old_time = pp->response_time; 3364 3365 pp->response_time = 60*1000; /* give it only a minute for now */ 3366 pp->response = Curl_tvnow(); /* timeout relative now */ 3367 3368 result = Curl_GetFTPResponse(&nread, conn, &ftpcode); 3369 3370 pp->response_time = old_time; /* set this back to previous value */ 3371 3372 if(!nread && (CURLE_OPERATION_TIMEDOUT == result)) { 3373 failf(data, "control connection looks dead"); 3374 ftpc->ctl_valid = FALSE; /* mark control connection as bad */ 3375 connclose(conn, "Timeout or similar in FTP DONE operation"); /* close */ 3376 } 3377 3378 if(result) 3379 return result; 3380 3381 if(ftpc->dont_check && data->req.maxdownload > 0) { 3382 /* we have just sent ABOR and there is no reliable way to check if it was 3383 * successful or not; we have to close the connection now */ 3384 infof(data, "partial download completed, closing connection\n"); 3385 connclose(conn, "Partial download with no ability to check"); 3386 return result; 3387 } 3388 3389 if(!ftpc->dont_check) { 3390 /* 226 Transfer complete, 250 Requested file action okay, completed. */ 3391 if((ftpcode != 226) && (ftpcode != 250)) { 3392 failf(data, "server did not report OK, got %d", ftpcode); 3393 result = CURLE_PARTIAL_FILE; 3394 } 3395 } 3396 } 3397 3398 if(result || premature) 3399 /* the response code from the transfer showed an error already so no 3400 use checking further */ 3401 ; 3402 else if(data->set.upload) { 3403 if((-1 != data->state.infilesize) && 3404 (data->state.infilesize != *ftp->bytecountp) && 3405 !data->set.crlf && 3406 (ftp->transfer == FTPTRANSFER_BODY)) { 3407 failf(data, "Uploaded unaligned file size (%" CURL_FORMAT_CURL_OFF_T 3408 " out of %" CURL_FORMAT_CURL_OFF_T " bytes)", 3409 *ftp->bytecountp, data->state.infilesize); 3410 result = CURLE_PARTIAL_FILE; 3411 } 3412 } 3413 else { 3414 if((-1 != data->req.size) && 3415 (data->req.size != *ftp->bytecountp) && 3416 #ifdef CURL_DO_LINEEND_CONV 3417 /* Most FTP servers don't adjust their file SIZE response for CRLFs, so 3418 * we'll check to see if the discrepancy can be explained by the number 3419 * of CRLFs we've changed to LFs. 3420 */ 3421 ((data->req.size + data->state.crlf_conversions) != 3422 *ftp->bytecountp) && 3423 #endif /* CURL_DO_LINEEND_CONV */ 3424 (data->req.maxdownload != *ftp->bytecountp)) { 3425 failf(data, "Received only partial file: %" CURL_FORMAT_CURL_OFF_T 3426 " bytes", *ftp->bytecountp); 3427 result = CURLE_PARTIAL_FILE; 3428 } 3429 else if(!ftpc->dont_check && 3430 !*ftp->bytecountp && 3431 (data->req.size>0)) { 3432 failf(data, "No data was received!"); 3433 result = CURLE_FTP_COULDNT_RETR_FILE; 3434 } 3435 } 3436 3437 /* clear these for next connection */ 3438 ftp->transfer = FTPTRANSFER_BODY; 3439 ftpc->dont_check = FALSE; 3440 3441 /* Send any post-transfer QUOTE strings? */ 3442 if(!status && !result && !premature && data->set.postquote) 3443 result = ftp_sendquote(conn, data->set.postquote); 3444 3445 return result; 3446 } 3447 3448 /*********************************************************************** 3449 * 3450 * ftp_sendquote() 3451 * 3452 * Where a 'quote' means a list of custom commands to send to the server. 3453 * The quote list is passed as an argument. 3454 * 3455 * BLOCKING 3456 */ 3457 3458 static 3459 CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote) 3460 { 3461 struct curl_slist *item; 3462 ssize_t nread; 3463 int ftpcode; 3464 CURLcode result; 3465 struct ftp_conn *ftpc = &conn->proto.ftpc; 3466 struct pingpong *pp = &ftpc->pp; 3467 3468 item = quote; 3469 while(item) { 3470 if(item->data) { 3471 char *cmd = item->data; 3472 bool acceptfail = FALSE; 3473 3474 /* if a command starts with an asterisk, which a legal FTP command never 3475 can, the command will be allowed to fail without it causing any 3476 aborts or cancels etc. It will cause libcurl to act as if the command 3477 is successful, whatever the server reponds. */ 3478 3479 if(cmd[0] == '*') { 3480 cmd++; 3481 acceptfail = TRUE; 3482 } 3483 3484 PPSENDF(&conn->proto.ftpc.pp, "%s", cmd); 3485 3486 pp->response = Curl_tvnow(); /* timeout relative now */ 3487 3488 result = Curl_GetFTPResponse(&nread, conn, &ftpcode); 3489 if(result) 3490 return result; 3491 3492 if(!acceptfail && (ftpcode >= 400)) { 3493 failf(conn->data, "QUOT string not accepted: %s", cmd); 3494 return CURLE_QUOTE_ERROR; 3495 } 3496 } 3497 3498 item = item->next; 3499 } 3500 3501 return CURLE_OK; 3502 } 3503 3504 /*********************************************************************** 3505 * 3506 * ftp_need_type() 3507 * 3508 * Returns TRUE if we in the current situation should send TYPE 3509 */ 3510 static int ftp_need_type(struct connectdata *conn, 3511 bool ascii_wanted) 3512 { 3513 return conn->proto.ftpc.transfertype != (ascii_wanted?'A':'I'); 3514 } 3515 3516 /*********************************************************************** 3517 * 3518 * ftp_nb_type() 3519 * 3520 * Set TYPE. We only deal with ASCII or BINARY so this function 3521 * sets one of them. 3522 * If the transfer type is not sent, simulate on OK response in newstate 3523 */ 3524 static CURLcode ftp_nb_type(struct connectdata *conn, 3525 bool ascii, ftpstate newstate) 3526 { 3527 struct ftp_conn *ftpc = &conn->proto.ftpc; 3528 CURLcode result; 3529 char want = (char)(ascii?'A':'I'); 3530 3531 if(ftpc->transfertype == want) { 3532 state(conn, newstate); 3533 return ftp_state_type_resp(conn, 200, newstate); 3534 } 3535 3536 PPSENDF(&ftpc->pp, "TYPE %c", want); 3537 state(conn, newstate); 3538 3539 /* keep track of our current transfer type */ 3540 ftpc->transfertype = want; 3541 return CURLE_OK; 3542 } 3543 3544 /*************************************************************************** 3545 * 3546 * ftp_pasv_verbose() 3547 * 3548 * This function only outputs some informationals about this second connection 3549 * when we've issued a PASV command before and thus we have connected to a 3550 * possibly new IP address. 3551 * 3552 */ 3553 #ifndef CURL_DISABLE_VERBOSE_STRINGS 3554 static void 3555 ftp_pasv_verbose(struct connectdata *conn, 3556 Curl_addrinfo *ai, 3557 char *newhost, /* ascii version */ 3558 int port) 3559 { 3560 char buf[256]; 3561 Curl_printable_address(ai, buf, sizeof(buf)); 3562 infof(conn->data, "Connecting to %s (%s) port %d\n", newhost, buf, port); 3563 } 3564 #endif 3565 3566 /* 3567 Check if this is a range download, and if so, set the internal variables 3568 properly. 3569 */ 3570 3571 static CURLcode ftp_range(struct connectdata *conn) 3572 { 3573 curl_off_t from, to; 3574 char *ptr; 3575 char *ptr2; 3576 struct SessionHandle *data = conn->data; 3577 struct ftp_conn *ftpc = &conn->proto.ftpc; 3578 3579 if(data->state.use_range && data->state.range) { 3580 from=curlx_strtoofft(data->state.range, &ptr, 0); 3581 while(*ptr && (ISSPACE(*ptr) || (*ptr=='-'))) 3582 ptr++; 3583 to=curlx_strtoofft(ptr, &ptr2, 0); 3584 if(ptr == ptr2) { 3585 /* we didn't get any digit */ 3586 to=-1; 3587 } 3588 if((-1 == to) && (from>=0)) { 3589 /* X - */ 3590 data->state.resume_from = from; 3591 DEBUGF(infof(conn->data, "FTP RANGE %" CURL_FORMAT_CURL_OFF_T 3592 " to end of file\n", from)); 3593 } 3594 else if(from < 0) { 3595 /* -Y */ 3596 data->req.maxdownload = -from; 3597 data->state.resume_from = from; 3598 DEBUGF(infof(conn->data, "FTP RANGE the last %" CURL_FORMAT_CURL_OFF_T 3599 " bytes\n", -from)); 3600 } 3601 else { 3602 /* X-Y */ 3603 data->req.maxdownload = (to-from)+1; /* include last byte */ 3604 data->state.resume_from = from; 3605 DEBUGF(infof(conn->data, "FTP RANGE from %" CURL_FORMAT_CURL_OFF_T 3606 " getting %" CURL_FORMAT_CURL_OFF_T " bytes\n", 3607 from, data->req.maxdownload)); 3608 } 3609 DEBUGF(infof(conn->data, "range-download from %" CURL_FORMAT_CURL_OFF_T 3610 " to %" CURL_FORMAT_CURL_OFF_T ", totally %" 3611 CURL_FORMAT_CURL_OFF_T " bytes\n", 3612 from, to, data->req.maxdownload)); 3613 ftpc->dont_check = TRUE; /* dont check for successful transfer */ 3614 } 3615 else 3616 data->req.maxdownload = -1; 3617 return CURLE_OK; 3618 } 3619 3620 3621 /* 3622 * ftp_do_more() 3623 * 3624 * This function shall be called when the second FTP (data) connection is 3625 * connected. 3626 * 3627 * 'complete' can return 0 for incomplete, 1 for done and -1 for go back 3628 * (which basically is only for when PASV is being sent to retry a failed 3629 * EPSV). 3630 */ 3631 3632 static CURLcode ftp_do_more(struct connectdata *conn, int *completep) 3633 { 3634 struct SessionHandle *data=conn->data; 3635 struct ftp_conn *ftpc = &conn->proto.ftpc; 3636 CURLcode result = CURLE_OK; 3637 bool connected = FALSE; 3638 bool complete = FALSE; 3639 3640 /* the ftp struct is inited in ftp_connect() */ 3641 struct FTP *ftp = data->req.protop; 3642 3643 /* if the second connection isn't done yet, wait for it */ 3644 if(!conn->bits.tcpconnect[SECONDARYSOCKET]) { 3645 if(conn->tunnel_state[SECONDARYSOCKET] == TUNNEL_CONNECT) { 3646 /* As we're in TUNNEL_CONNECT state now, we know the proxy name and port 3647 aren't used so we blank their arguments. TODO: make this nicer */ 3648 result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, NULL, 0); 3649 3650 return result; 3651 } 3652 3653 result = Curl_is_connected(conn, SECONDARYSOCKET, &connected); 3654 3655 /* Ready to do more? */ 3656 if(connected) { 3657 DEBUGF(infof(data, "DO-MORE connected phase starts\n")); 3658 if(conn->bits.proxy) { 3659 infof(data, "Connection to proxy confirmed\n"); 3660 result = proxy_magic(conn, ftpc->newhost, ftpc->newport, &connected); 3661 } 3662 } 3663 else { 3664 if(result && (ftpc->count1 == 0)) { 3665 *completep = -1; /* go back to DOING please */ 3666 /* this is a EPSV connect failing, try PASV instead */ 3667 return ftp_epsv_disable(conn); 3668 } 3669 return result; 3670 } 3671 } 3672 3673 if(ftpc->state) { 3674 /* already in a state so skip the intial commands. 3675 They are only done to kickstart the do_more state */ 3676 result = ftp_multi_statemach(conn, &complete); 3677 3678 *completep = (int)complete; 3679 3680 /* if we got an error or if we don't wait for a data connection return 3681 immediately */ 3682 if(result || (ftpc->wait_data_conn != TRUE)) 3683 return result; 3684 3685 if(ftpc->wait_data_conn) 3686 /* if we reach the end of the FTP state machine here, *complete will be 3687 TRUE but so is ftpc->wait_data_conn, which says we need to wait for 3688 the data connection and therefore we're not actually complete */ 3689 *completep = 0; 3690 } 3691 3692 if(ftp->transfer <= FTPTRANSFER_INFO) { 3693 /* a transfer is about to take place, or if not a file name was given 3694 so we'll do a SIZE on it later and then we need the right TYPE first */ 3695 3696 if(ftpc->wait_data_conn == TRUE) { 3697 bool serv_conned; 3698 3699 result = ReceivedServerConnect(conn, &serv_conned); 3700 if(result) 3701 return result; /* Failed to accept data connection */ 3702 3703 if(serv_conned) { 3704 /* It looks data connection is established */ 3705 result = AcceptServerConnect(conn); 3706 ftpc->wait_data_conn = FALSE; 3707 if(!result) 3708 result = InitiateTransfer(conn); 3709 3710 if(result) 3711 return result; 3712 3713 *completep = 1; /* this state is now complete when the server has 3714 connected back to us */ 3715 } 3716 } 3717 else if(data->set.upload) { 3718 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_STOR_TYPE); 3719 if(result) 3720 return result; 3721 3722 result = ftp_multi_statemach(conn, &complete); 3723 *completep = (int)complete; 3724 } 3725 else { 3726 /* download */ 3727 ftp->downloadsize = -1; /* unknown as of yet */ 3728 3729 result = ftp_range(conn); 3730 if(result) 3731 ; 3732 else if(data->set.ftp_list_only || !ftpc->file) { 3733 /* The specified path ends with a slash, and therefore we think this 3734 is a directory that is requested, use LIST. But before that we 3735 need to set ASCII transfer mode. */ 3736 3737 /* But only if a body transfer was requested. */ 3738 if(ftp->transfer == FTPTRANSFER_BODY) { 3739 result = ftp_nb_type(conn, TRUE, FTP_LIST_TYPE); 3740 if(result) 3741 return result; 3742 } 3743 /* otherwise just fall through */ 3744 } 3745 else { 3746 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_RETR_TYPE); 3747 if(result) 3748 return result; 3749 } 3750 3751 result = ftp_multi_statemach(conn, &complete); 3752 *completep = (int)complete; 3753 } 3754 return result; 3755 } 3756 3757 if(!result && (ftp->transfer != FTPTRANSFER_BODY)) 3758 /* no data to transfer. FIX: it feels like a kludge to have this here 3759 too! */ 3760 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL); 3761 3762 if(!ftpc->wait_data_conn) { 3763 /* no waiting for the data connection so this is now complete */ 3764 *completep = 1; 3765 DEBUGF(infof(data, "DO-MORE phase ends with %d\n", (int)result)); 3766 } 3767 3768 return result; 3769 } 3770 3771 3772 3773 /*********************************************************************** 3774 * 3775 * ftp_perform() 3776 * 3777 * This is the actual DO function for FTP. Get a file/directory according to 3778 * the options previously setup. 3779 */ 3780 3781 static 3782 CURLcode ftp_perform(struct connectdata *conn, 3783 bool *connected, /* connect status after PASV / PORT */ 3784 bool *dophase_done) 3785 { 3786 /* this is FTP and no proxy */ 3787 CURLcode result=CURLE_OK; 3788 3789 DEBUGF(infof(conn->data, "DO phase starts\n")); 3790 3791 if(conn->data->set.opt_no_body) { 3792 /* requested no body means no transfer... */ 3793 struct FTP *ftp = conn->data->req.protop; 3794 ftp->transfer = FTPTRANSFER_INFO; 3795 } 3796 3797 *dophase_done = FALSE; /* not done yet */ 3798 3799 /* start the first command in the DO phase */ 3800 result = ftp_state_quote(conn, TRUE, FTP_QUOTE); 3801 if(result) 3802 return result; 3803 3804 /* run the state-machine */ 3805 result = ftp_multi_statemach(conn, dophase_done); 3806 3807 *connected = conn->bits.tcpconnect[SECONDARYSOCKET]; 3808 3809 infof(conn->data, "ftp_perform ends with SECONDARY: %d\n", *connected); 3810 3811 if(*dophase_done) 3812 DEBUGF(infof(conn->data, "DO phase is complete1\n")); 3813 3814 return result; 3815 } 3816 3817 static void wc_data_dtor(void *ptr) 3818 { 3819 struct ftp_wc_tmpdata *tmp = ptr; 3820 if(tmp) 3821 Curl_ftp_parselist_data_free(&tmp->parser); 3822 free(tmp); 3823 } 3824 3825 static CURLcode init_wc_data(struct connectdata *conn) 3826 { 3827 char *last_slash; 3828 char *path = conn->data->state.path; 3829 struct WildcardData *wildcard = &(conn->data->wildcard); 3830 CURLcode result = CURLE_OK; 3831 struct ftp_wc_tmpdata *ftp_tmp; 3832 3833 last_slash = strrchr(conn->data->state.path, '/'); 3834 if(last_slash) { 3835 last_slash++; 3836 if(last_slash[0] == '\0') { 3837 wildcard->state = CURLWC_CLEAN; 3838 result = ftp_parse_url_path(conn); 3839 return result; 3840 } 3841 else { 3842 wildcard->pattern = strdup(last_slash); 3843 if(!wildcard->pattern) 3844 return CURLE_OUT_OF_MEMORY; 3845 last_slash[0] = '\0'; /* cut file from path */ 3846 } 3847 } 3848 else { /* there is only 'wildcard pattern' or nothing */ 3849 if(path[0]) { 3850 wildcard->pattern = strdup(path); 3851 if(!wildcard->pattern) 3852 return CURLE_OUT_OF_MEMORY; 3853 path[0] = '\0'; 3854 } 3855 else { /* only list */ 3856 wildcard->state = CURLWC_CLEAN; 3857 result = ftp_parse_url_path(conn); 3858 return result; 3859 } 3860 } 3861 3862 /* program continues only if URL is not ending with slash, allocate needed 3863 resources for wildcard transfer */ 3864 3865 /* allocate ftp protocol specific temporary wildcard data */ 3866 ftp_tmp = calloc(1, sizeof(struct ftp_wc_tmpdata)); 3867 if(!ftp_tmp) { 3868 Curl_safefree(wildcard->pattern); 3869 return CURLE_OUT_OF_MEMORY; 3870 } 3871 3872 /* INITIALIZE parselist structure */ 3873 ftp_tmp->parser = Curl_ftp_parselist_data_alloc(); 3874 if(!ftp_tmp->parser) { 3875 Curl_safefree(wildcard->pattern); 3876 free(ftp_tmp); 3877 return CURLE_OUT_OF_MEMORY; 3878 } 3879 3880 wildcard->tmp = ftp_tmp; /* put it to the WildcardData tmp pointer */ 3881 wildcard->tmp_dtor = wc_data_dtor; 3882 3883 /* wildcard does not support NOCWD option (assert it?) */ 3884 if(conn->data->set.ftp_filemethod == FTPFILE_NOCWD) 3885 conn->data->set.ftp_filemethod = FTPFILE_MULTICWD; 3886 3887 /* try to parse ftp url */ 3888 result = ftp_parse_url_path(conn); 3889 if(result) { 3890 Curl_safefree(wildcard->pattern); 3891 wildcard->tmp_dtor(wildcard->tmp); 3892 wildcard->tmp_dtor = ZERO_NULL; 3893 wildcard->tmp = NULL; 3894 return result; 3895 } 3896 3897 wildcard->path = strdup(conn->data->state.path); 3898 if(!wildcard->path) { 3899 Curl_safefree(wildcard->pattern); 3900 wildcard->tmp_dtor(wildcard->tmp); 3901 wildcard->tmp_dtor = ZERO_NULL; 3902 wildcard->tmp = NULL; 3903 return CURLE_OUT_OF_MEMORY; 3904 } 3905 3906 /* backup old write_function */ 3907 ftp_tmp->backup.write_function = conn->data->set.fwrite_func; 3908 /* parsing write function */ 3909 conn->data->set.fwrite_func = Curl_ftp_parselist; 3910 /* backup old file descriptor */ 3911 ftp_tmp->backup.file_descriptor = conn->data->set.out; 3912 /* let the writefunc callback know what curl pointer is working with */ 3913 conn->data->set.out = conn; 3914 3915 infof(conn->data, "Wildcard - Parsing started\n"); 3916 return CURLE_OK; 3917 } 3918 3919 /* This is called recursively */ 3920 static CURLcode wc_statemach(struct connectdata *conn) 3921 { 3922 struct WildcardData * const wildcard = &(conn->data->wildcard); 3923 CURLcode result = CURLE_OK; 3924 3925 switch (wildcard->state) { 3926 case CURLWC_INIT: 3927 result = init_wc_data(conn); 3928 if(wildcard->state == CURLWC_CLEAN) 3929 /* only listing! */ 3930 break; 3931 else 3932 wildcard->state = result ? CURLWC_ERROR : CURLWC_MATCHING; 3933 break; 3934 3935 case CURLWC_MATCHING: { 3936 /* In this state is LIST response successfully parsed, so lets restore 3937 previous WRITEFUNCTION callback and WRITEDATA pointer */ 3938 struct ftp_wc_tmpdata *ftp_tmp = wildcard->tmp; 3939 conn->data->set.fwrite_func = ftp_tmp->backup.write_function; 3940 conn->data->set.out = ftp_tmp->backup.file_descriptor; 3941 ftp_tmp->backup.write_function = ZERO_NULL; 3942 ftp_tmp->backup.file_descriptor = NULL; 3943 wildcard->state = CURLWC_DOWNLOADING; 3944 3945 if(Curl_ftp_parselist_geterror(ftp_tmp->parser)) { 3946 /* error found in LIST parsing */ 3947 wildcard->state = CURLWC_CLEAN; 3948 return wc_statemach(conn); 3949 } 3950 else if(wildcard->filelist->size == 0) { 3951 /* no corresponding file */ 3952 wildcard->state = CURLWC_CLEAN; 3953 return CURLE_REMOTE_FILE_NOT_FOUND; 3954 } 3955 return wc_statemach(conn); 3956 } 3957 3958 case CURLWC_DOWNLOADING: { 3959 /* filelist has at least one file, lets get first one */ 3960 struct ftp_conn *ftpc = &conn->proto.ftpc; 3961 struct curl_fileinfo *finfo = wildcard->filelist->head->ptr; 3962 3963 char *tmp_path = aprintf("%s%s", wildcard->path, finfo->filename); 3964 if(!tmp_path) 3965 return CURLE_OUT_OF_MEMORY; 3966 3967 /* switch default "state.pathbuffer" and tmp_path, good to see 3968 ftp_parse_url_path function to understand this trick */ 3969 Curl_safefree(conn->data->state.pathbuffer); 3970 conn->data->state.pathbuffer = tmp_path; 3971 conn->data->state.path = tmp_path; 3972 3973 infof(conn->data, "Wildcard - START of \"%s\"\n", finfo->filename); 3974 if(conn->data->set.chunk_bgn) { 3975 long userresponse = conn->data->set.chunk_bgn( 3976 finfo, wildcard->customptr, (int)wildcard->filelist->size); 3977 switch(userresponse) { 3978 case CURL_CHUNK_BGN_FUNC_SKIP: 3979 infof(conn->data, "Wildcard - \"%s\" skipped by user\n", 3980 finfo->filename); 3981 wildcard->state = CURLWC_SKIP; 3982 return wc_statemach(conn); 3983 case CURL_CHUNK_BGN_FUNC_FAIL: 3984 return CURLE_CHUNK_FAILED; 3985 } 3986 } 3987 3988 if(finfo->filetype != CURLFILETYPE_FILE) { 3989 wildcard->state = CURLWC_SKIP; 3990 return wc_statemach(conn); 3991 } 3992 3993 if(finfo->flags & CURLFINFOFLAG_KNOWN_SIZE) 3994 ftpc->known_filesize = finfo->size; 3995 3996 result = ftp_parse_url_path(conn); 3997 if(result) 3998 return result; 3999 4000 /* we don't need the Curl_fileinfo of first file anymore */ 4001 Curl_llist_remove(wildcard->filelist, wildcard->filelist->head, NULL); 4002 4003 if(wildcard->filelist->size == 0) { /* remains only one file to down. */ 4004 wildcard->state = CURLWC_CLEAN; 4005 /* after that will be ftp_do called once again and no transfer 4006 will be done because of CURLWC_CLEAN state */ 4007 return CURLE_OK; 4008 } 4009 } break; 4010 4011 case CURLWC_SKIP: { 4012 if(conn->data->set.chunk_end) 4013 conn->data->set.chunk_end(conn->data->wildcard.customptr); 4014 Curl_llist_remove(wildcard->filelist, wildcard->filelist->head, NULL); 4015 wildcard->state = (wildcard->filelist->size == 0) ? 4016 CURLWC_CLEAN : CURLWC_DOWNLOADING; 4017 return wc_statemach(conn); 4018 } 4019 4020 case CURLWC_CLEAN: { 4021 struct ftp_wc_tmpdata *ftp_tmp = wildcard->tmp; 4022 result = CURLE_OK; 4023 if(ftp_tmp) 4024 result = Curl_ftp_parselist_geterror(ftp_tmp->parser); 4025 4026 wildcard->state = result ? CURLWC_ERROR : CURLWC_DONE; 4027 } break; 4028 4029 case CURLWC_DONE: 4030 case CURLWC_ERROR: 4031 break; 4032 } 4033 4034 return result; 4035 } 4036 4037 /*********************************************************************** 4038 * 4039 * ftp_do() 4040 * 4041 * This function is registered as 'curl_do' function. It decodes the path 4042 * parts etc as a wrapper to the actual DO function (ftp_perform). 4043 * 4044 * The input argument is already checked for validity. 4045 */ 4046 static CURLcode ftp_do(struct connectdata *conn, bool *done) 4047 { 4048 CURLcode result = CURLE_OK; 4049 struct ftp_conn *ftpc = &conn->proto.ftpc; 4050 4051 *done = FALSE; /* default to false */ 4052 ftpc->wait_data_conn = FALSE; /* default to no such wait */ 4053 4054 if(conn->data->set.wildcardmatch) { 4055 result = wc_statemach(conn); 4056 if(conn->data->wildcard.state == CURLWC_SKIP || 4057 conn->data->wildcard.state == CURLWC_DONE) { 4058 /* do not call ftp_regular_transfer */ 4059 return CURLE_OK; 4060 } 4061 if(result) /* error, loop or skipping the file */ 4062 return result; 4063 } 4064 else { /* no wildcard FSM needed */ 4065 result = ftp_parse_url_path(conn); 4066 if(result) 4067 return result; 4068 } 4069 4070 result = ftp_regular_transfer(conn, done); 4071 4072 return result; 4073 } 4074 4075 4076 CURLcode Curl_ftpsendf(struct connectdata *conn, 4077 const char *fmt, ...) 4078 { 4079 ssize_t bytes_written; 4080 #define SBUF_SIZE 1024 4081 char s[SBUF_SIZE]; 4082 size_t write_len; 4083 char *sptr=s; 4084 CURLcode result = CURLE_OK; 4085 #ifdef HAVE_GSSAPI 4086 enum protection_level data_sec = conn->data_prot; 4087 #endif 4088 4089 va_list ap; 4090 va_start(ap, fmt); 4091 write_len = vsnprintf(s, SBUF_SIZE-3, fmt, ap); 4092 va_end(ap); 4093 4094 strcpy(&s[write_len], "\r\n"); /* append a trailing CRLF */ 4095 write_len +=2; 4096 4097 bytes_written=0; 4098 4099 result = Curl_convert_to_network(conn->data, s, write_len); 4100 /* Curl_convert_to_network calls failf if unsuccessful */ 4101 if(result) 4102 return result; 4103 4104 for(;;) { 4105 #ifdef HAVE_GSSAPI 4106 conn->data_prot = PROT_CMD; 4107 #endif 4108 result = Curl_write(conn, conn->sock[FIRSTSOCKET], sptr, write_len, 4109 &bytes_written); 4110 #ifdef HAVE_GSSAPI 4111 DEBUGASSERT(data_sec > PROT_NONE && data_sec < PROT_LAST); 4112 conn->data_prot = data_sec; 4113 #endif 4114 4115 if(result) 4116 break; 4117 4118 if(conn->data->set.verbose) 4119 Curl_debug(conn->data, CURLINFO_HEADER_OUT, 4120 sptr, (size_t)bytes_written, conn); 4121 4122 if(bytes_written != (ssize_t)write_len) { 4123 write_len -= bytes_written; 4124 sptr += bytes_written; 4125 } 4126 else 4127 break; 4128 } 4129 4130 return result; 4131 } 4132 4133 /*********************************************************************** 4134 * 4135 * ftp_quit() 4136 * 4137 * This should be called before calling sclose() on an ftp control connection 4138 * (not data connections). We should then wait for the response from the 4139 * server before returning. The calling code should then try to close the 4140 * connection. 4141 * 4142 */ 4143 static CURLcode ftp_quit(struct connectdata *conn) 4144 { 4145 CURLcode result = CURLE_OK; 4146 4147 if(conn->proto.ftpc.ctl_valid) { 4148 result = Curl_pp_sendf(&conn->proto.ftpc.pp, "%s", "QUIT"); 4149 if(result) { 4150 failf(conn->data, "Failure sending QUIT command: %s", 4151 curl_easy_strerror(result)); 4152 conn->proto.ftpc.ctl_valid = FALSE; /* mark control connection as bad */ 4153 connclose(conn, "QUIT command failed"); /* mark for connection closure */ 4154 state(conn, FTP_STOP); 4155 return result; 4156 } 4157 4158 state(conn, FTP_QUIT); 4159 4160 result = ftp_block_statemach(conn); 4161 } 4162 4163 return result; 4164 } 4165 4166 /*********************************************************************** 4167 * 4168 * ftp_disconnect() 4169 * 4170 * Disconnect from an FTP server. Cleanup protocol-specific per-connection 4171 * resources. BLOCKING. 4172 */ 4173 static CURLcode ftp_disconnect(struct connectdata *conn, bool dead_connection) 4174 { 4175 struct ftp_conn *ftpc= &conn->proto.ftpc; 4176 struct pingpong *pp = &ftpc->pp; 4177 4178 /* We cannot send quit unconditionally. If this connection is stale or 4179 bad in any way, sending quit and waiting around here will make the 4180 disconnect wait in vain and cause more problems than we need to. 4181 4182 ftp_quit() will check the state of ftp->ctl_valid. If it's ok it 4183 will try to send the QUIT command, otherwise it will just return. 4184 */ 4185 if(dead_connection) 4186 ftpc->ctl_valid = FALSE; 4187 4188 /* The FTP session may or may not have been allocated/setup at this point! */ 4189 (void)ftp_quit(conn); /* ignore errors on the QUIT */ 4190 4191 if(ftpc->entrypath) { 4192 struct SessionHandle *data = conn->data; 4193 if(data->state.most_recent_ftp_entrypath == ftpc->entrypath) { 4194 data->state.most_recent_ftp_entrypath = NULL; 4195 } 4196 free(ftpc->entrypath); 4197 ftpc->entrypath = NULL; 4198 } 4199 4200 freedirs(ftpc); 4201 free(ftpc->prevpath); 4202 ftpc->prevpath = NULL; 4203 free(ftpc->server_os); 4204 ftpc->server_os = NULL; 4205 4206 Curl_pp_disconnect(pp); 4207 4208 #ifdef HAVE_GSSAPI 4209 Curl_sec_end(conn); 4210 #endif 4211 4212 return CURLE_OK; 4213 } 4214 4215 /*********************************************************************** 4216 * 4217 * ftp_parse_url_path() 4218 * 4219 * Parse the URL path into separate path components. 4220 * 4221 */ 4222 static 4223 CURLcode ftp_parse_url_path(struct connectdata *conn) 4224 { 4225 struct SessionHandle *data = conn->data; 4226 /* the ftp struct is already inited in ftp_connect() */ 4227 struct FTP *ftp = data->req.protop; 4228 struct ftp_conn *ftpc = &conn->proto.ftpc; 4229 const char *slash_pos; /* position of the first '/' char in curpos */ 4230 const char *path_to_use = data->state.path; 4231 const char *cur_pos; 4232 const char *filename = NULL; 4233 4234 cur_pos = path_to_use; /* current position in path. point at the begin 4235 of next path component */ 4236 4237 ftpc->ctl_valid = FALSE; 4238 ftpc->cwdfail = FALSE; 4239 4240 switch(data->set.ftp_filemethod) { 4241 case FTPFILE_NOCWD: 4242 /* fastest, but less standard-compliant */ 4243 4244 /* 4245 The best time to check whether the path is a file or directory is right 4246 here. so: 4247 4248 the first condition in the if() right here, is there just in case 4249 someone decides to set path to NULL one day 4250 */ 4251 if(data->state.path && 4252 data->state.path[0] && 4253 (data->state.path[strlen(data->state.path) - 1] != '/') ) 4254 filename = data->state.path; /* this is a full file path */ 4255 /* 4256 ftpc->file is not used anywhere other than for operations on a file. 4257 In other words, never for directory operations. 4258 So we can safely leave filename as NULL here and use it as a 4259 argument in dir/file decisions. 4260 */ 4261 break; 4262 4263 case FTPFILE_SINGLECWD: 4264 /* get the last slash */ 4265 if(!path_to_use[0]) { 4266 /* no dir, no file */ 4267 ftpc->dirdepth = 0; 4268 break; 4269 } 4270 slash_pos=strrchr(cur_pos, '/'); 4271 if(slash_pos || !*cur_pos) { 4272 size_t dirlen = slash_pos-cur_pos; 4273 4274 ftpc->dirs = calloc(1, sizeof(ftpc->dirs[0])); 4275 if(!ftpc->dirs) 4276 return CURLE_OUT_OF_MEMORY; 4277 4278 if(!dirlen) 4279 dirlen++; 4280 4281 ftpc->dirs[0] = curl_easy_unescape(conn->data, slash_pos ? cur_pos : "/", 4282 slash_pos ? curlx_uztosi(dirlen) : 1, 4283 NULL); 4284 if(!ftpc->dirs[0]) { 4285 freedirs(ftpc); 4286 return CURLE_OUT_OF_MEMORY; 4287 } 4288 ftpc->dirdepth = 1; /* we consider it to be a single dir */ 4289 filename = slash_pos ? slash_pos+1 : cur_pos; /* rest is file name */ 4290 } 4291 else 4292 filename = cur_pos; /* this is a file name only */ 4293 break; 4294 4295 default: /* allow pretty much anything */ 4296 case FTPFILE_MULTICWD: 4297 ftpc->dirdepth = 0; 4298 ftpc->diralloc = 5; /* default dir depth to allocate */ 4299 ftpc->dirs = calloc(ftpc->diralloc, sizeof(ftpc->dirs[0])); 4300 if(!ftpc->dirs) 4301 return CURLE_OUT_OF_MEMORY; 4302 4303 /* we have a special case for listing the root dir only */ 4304 if(strequal(path_to_use, "/")) { 4305 cur_pos++; /* make it point to the zero byte */ 4306 ftpc->dirs[0] = strdup("/"); 4307 ftpc->dirdepth++; 4308 } 4309 else { 4310 /* parse the URL path into separate path components */ 4311 while((slash_pos = strchr(cur_pos, '/')) != NULL) { 4312 /* 1 or 0 pointer offset to indicate absolute directory */ 4313 ssize_t absolute_dir = ((cur_pos - data->state.path > 0) && 4314 (ftpc->dirdepth == 0))?1:0; 4315 4316 /* seek out the next path component */ 4317 if(slash_pos-cur_pos) { 4318 /* we skip empty path components, like "x//y" since the FTP command 4319 CWD requires a parameter and a non-existent parameter a) doesn't 4320 work on many servers and b) has no effect on the others. */ 4321 int len = curlx_sztosi(slash_pos - cur_pos + absolute_dir); 4322 ftpc->dirs[ftpc->dirdepth] = 4323 curl_easy_unescape(conn->data, cur_pos - absolute_dir, len, NULL); 4324 if(!ftpc->dirs[ftpc->dirdepth]) { /* run out of memory ... */ 4325 failf(data, "no memory"); 4326 freedirs(ftpc); 4327 return CURLE_OUT_OF_MEMORY; 4328 } 4329 if(isBadFtpString(ftpc->dirs[ftpc->dirdepth])) { 4330 free(ftpc->dirs[ftpc->dirdepth]); 4331 freedirs(ftpc); 4332 return CURLE_URL_MALFORMAT; 4333 } 4334 } 4335 else { 4336 cur_pos = slash_pos + 1; /* jump to the rest of the string */ 4337 if(!ftpc->dirdepth) { 4338 /* path starts with a slash, add that as a directory */ 4339 ftpc->dirs[ftpc->dirdepth] = strdup("/"); 4340 if(!ftpc->dirs[ftpc->dirdepth++]) { /* run out of memory ... */ 4341 failf(data, "no memory"); 4342 freedirs(ftpc); 4343 return CURLE_OUT_OF_MEMORY; 4344 } 4345 } 4346 continue; 4347 } 4348 4349 cur_pos = slash_pos + 1; /* jump to the rest of the string */ 4350 if(++ftpc->dirdepth >= ftpc->diralloc) { 4351 /* enlarge array */ 4352 char **bigger; 4353 ftpc->diralloc *= 2; /* double the size each time */ 4354 bigger = realloc(ftpc->dirs, ftpc->diralloc * sizeof(ftpc->dirs[0])); 4355 if(!bigger) { 4356 freedirs(ftpc); 4357 return CURLE_OUT_OF_MEMORY; 4358 } 4359 ftpc->dirs = bigger; 4360 } 4361 } 4362 } 4363 filename = cur_pos; /* the rest is the file name */ 4364 break; 4365 } /* switch */ 4366 4367 if(filename && *filename) { 4368 ftpc->file = curl_easy_unescape(conn->data, filename, 0, NULL); 4369 if(NULL == ftpc->file) { 4370 freedirs(ftpc); 4371 failf(data, "no memory"); 4372 return CURLE_OUT_OF_MEMORY; 4373 } 4374 if(isBadFtpString(ftpc->file)) { 4375 freedirs(ftpc); 4376 return CURLE_URL_MALFORMAT; 4377 } 4378 } 4379 else 4380 ftpc->file=NULL; /* instead of point to a zero byte, we make it a NULL 4381 pointer */ 4382 4383 if(data->set.upload && !ftpc->file && (ftp->transfer == FTPTRANSFER_BODY)) { 4384 /* We need a file name when uploading. Return error! */ 4385 failf(data, "Uploading to a URL without a file name!"); 4386 return CURLE_URL_MALFORMAT; 4387 } 4388 4389 ftpc->cwddone = FALSE; /* default to not done */ 4390 4391 if(ftpc->prevpath) { 4392 /* prevpath is "raw" so we convert the input path before we compare the 4393 strings */ 4394 int dlen; 4395 char *path = curl_easy_unescape(conn->data, data->state.path, 0, &dlen); 4396 if(!path) { 4397 freedirs(ftpc); 4398 return CURLE_OUT_OF_MEMORY; 4399 } 4400 4401 dlen -= ftpc->file?curlx_uztosi(strlen(ftpc->file)):0; 4402 if((dlen == curlx_uztosi(strlen(ftpc->prevpath))) && 4403 strnequal(path, ftpc->prevpath, dlen)) { 4404 infof(data, "Request has same path as previous transfer\n"); 4405 ftpc->cwddone = TRUE; 4406 } 4407 free(path); 4408 } 4409 4410 return CURLE_OK; 4411 } 4412 4413 /* call this when the DO phase has completed */ 4414 static CURLcode ftp_dophase_done(struct connectdata *conn, 4415 bool connected) 4416 { 4417 struct FTP *ftp = conn->data->req.protop; 4418 struct ftp_conn *ftpc = &conn->proto.ftpc; 4419 4420 if(connected) { 4421 int completed; 4422 CURLcode result = ftp_do_more(conn, &completed); 4423 4424 if(result) { 4425 if(conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD) { 4426 /* close the second socket if it was created already */ 4427 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]); 4428 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD; 4429 } 4430 return result; 4431 } 4432 } 4433 4434 if(ftp->transfer != FTPTRANSFER_BODY) 4435 /* no data to transfer */ 4436 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL); 4437 else if(!connected) 4438 /* since we didn't connect now, we want do_more to get called */ 4439 conn->bits.do_more = TRUE; 4440 4441 ftpc->ctl_valid = TRUE; /* seems good */ 4442 4443 return CURLE_OK; 4444 } 4445 4446 /* called from multi.c while DOing */ 4447 static CURLcode ftp_doing(struct connectdata *conn, 4448 bool *dophase_done) 4449 { 4450 CURLcode result = ftp_multi_statemach(conn, dophase_done); 4451 4452 if(result) 4453 DEBUGF(infof(conn->data, "DO phase failed\n")); 4454 else if(*dophase_done) { 4455 result = ftp_dophase_done(conn, FALSE /* not connected */); 4456 4457 DEBUGF(infof(conn->data, "DO phase is complete2\n")); 4458 } 4459 return result; 4460 } 4461 4462 /*********************************************************************** 4463 * 4464 * ftp_regular_transfer() 4465 * 4466 * The input argument is already checked for validity. 4467 * 4468 * Performs all commands done before a regular transfer between a local and a 4469 * remote host. 4470 * 4471 * ftp->ctl_valid starts out as FALSE, and gets set to TRUE if we reach the 4472 * ftp_done() function without finding any major problem. 4473 */ 4474 static 4475 CURLcode ftp_regular_transfer(struct connectdata *conn, 4476 bool *dophase_done) 4477 { 4478 CURLcode result=CURLE_OK; 4479 bool connected=FALSE; 4480 struct SessionHandle *data = conn->data; 4481 struct ftp_conn *ftpc = &conn->proto.ftpc; 4482 data->req.size = -1; /* make sure this is unknown at this point */ 4483 4484 Curl_pgrsSetUploadCounter(data, 0); 4485 Curl_pgrsSetDownloadCounter(data, 0); 4486 Curl_pgrsSetUploadSize(data, -1); 4487 Curl_pgrsSetDownloadSize(data, -1); 4488 4489 ftpc->ctl_valid = TRUE; /* starts good */ 4490 4491 result = ftp_perform(conn, 4492 &connected, /* have we connected after PASV/PORT */ 4493 dophase_done); /* all commands in the DO-phase done? */ 4494 4495 if(!result) { 4496 4497 if(!*dophase_done) 4498 /* the DO phase has not completed yet */ 4499 return CURLE_OK; 4500 4501 result = ftp_dophase_done(conn, connected); 4502 4503 if(result) 4504 return result; 4505 } 4506 else 4507 freedirs(ftpc); 4508 4509 return result; 4510 } 4511 4512 static CURLcode ftp_setup_connection(struct connectdata *conn) 4513 { 4514 struct SessionHandle *data = conn->data; 4515 char *type; 4516 char command; 4517 struct FTP *ftp; 4518 4519 if(conn->bits.httpproxy && !data->set.tunnel_thru_httpproxy) { 4520 /* Unless we have asked to tunnel ftp operations through the proxy, we 4521 switch and use HTTP operations only */ 4522 #ifndef CURL_DISABLE_HTTP 4523 if(conn->handler == &Curl_handler_ftp) 4524 conn->handler = &Curl_handler_ftp_proxy; 4525 else { 4526 #ifdef USE_SSL 4527 conn->handler = &Curl_handler_ftps_proxy; 4528 #else 4529 failf(data, "FTPS not supported!"); 4530 return CURLE_UNSUPPORTED_PROTOCOL; 4531 #endif 4532 } 4533 /* set it up as a HTTP connection instead */ 4534 return conn->handler->setup_connection(conn); 4535 #else 4536 failf(data, "FTP over http proxy requires HTTP support built-in!"); 4537 return CURLE_UNSUPPORTED_PROTOCOL; 4538 #endif 4539 } 4540 4541 conn->data->req.protop = ftp = malloc(sizeof(struct FTP)); 4542 if(NULL == ftp) 4543 return CURLE_OUT_OF_MEMORY; 4544 4545 data->state.path++; /* don't include the initial slash */ 4546 data->state.slash_removed = TRUE; /* we've skipped the slash */ 4547 4548 /* FTP URLs support an extension like ";type=<typecode>" that 4549 * we'll try to get now! */ 4550 type = strstr(data->state.path, ";type="); 4551 4552 if(!type) 4553 type = strstr(conn->host.rawalloc, ";type="); 4554 4555 if(type) { 4556 *type = 0; /* it was in the middle of the hostname */ 4557 command = Curl_raw_toupper(type[6]); 4558 conn->bits.type_set = TRUE; 4559 4560 switch (command) { 4561 case 'A': /* ASCII mode */ 4562 data->set.prefer_ascii = TRUE; 4563 break; 4564 4565 case 'D': /* directory mode */ 4566 data->set.ftp_list_only = TRUE; 4567 break; 4568 4569 case 'I': /* binary mode */ 4570 default: 4571 /* switch off ASCII */ 4572 data->set.prefer_ascii = FALSE; 4573 break; 4574 } 4575 } 4576 4577 /* get some initial data into the ftp struct */ 4578 ftp->bytecountp = &conn->data->req.bytecount; 4579 ftp->transfer = FTPTRANSFER_BODY; 4580 ftp->downloadsize = 0; 4581 4582 /* No need to duplicate user+password, the connectdata struct won't change 4583 during a session, but we re-init them here since on subsequent inits 4584 since the conn struct may have changed or been replaced. 4585 */ 4586 ftp->user = conn->user; 4587 ftp->passwd = conn->passwd; 4588 if(isBadFtpString(ftp->user)) 4589 return CURLE_URL_MALFORMAT; 4590 if(isBadFtpString(ftp->passwd)) 4591 return CURLE_URL_MALFORMAT; 4592 4593 conn->proto.ftpc.known_filesize = -1; /* unknown size for now */ 4594 4595 return CURLE_OK; 4596 } 4597 4598 #endif /* CURL_DISABLE_FTP */ 4599
