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