Lines Matching defs:conn
101 static void _state(struct connectdata *conn,
105 static void _state(struct connectdata *conn,
111 static CURLcode ftp_sendquote(struct connectdata *conn,
113 static CURLcode ftp_quit(struct connectdata *conn);
114 static CURLcode ftp_parse_url_path(struct connectdata *conn);
115 static CURLcode ftp_regular_transfer(struct connectdata *conn, bool *done);
117 static void ftp_pasv_verbose(struct connectdata *conn,
122 static CURLcode ftp_state_prepare_transfer(struct connectdata *conn);
123 static CURLcode ftp_state_mdtm(struct connectdata *conn);
124 static CURLcode ftp_state_quote(struct connectdata *conn,
126 static CURLcode ftp_nb_type(struct connectdata *conn,
128 static int ftp_need_type(struct connectdata *conn,
130 static CURLcode ftp_do(struct connectdata *conn, bool *done);
131 static CURLcode ftp_done(struct connectdata *conn,
133 static CURLcode ftp_connect(struct connectdata *conn, bool *done);
134 static CURLcode ftp_disconnect(struct connectdata *conn, bool dead_connection);
135 static CURLcode ftp_do_more(struct connectdata *conn, int *completed);
136 static CURLcode ftp_multi_statemach(struct connectdata *conn, bool *done);
137 static int ftp_getsock(struct connectdata *conn, curl_socket_t *socks,
139 static int ftp_domore_getsock(struct connectdata *conn, curl_socket_t *socks,
141 static CURLcode ftp_doing(struct connectdata *conn,
143 static CURLcode ftp_setup_connection(struct connectdata * conn);
145 static CURLcode init_wc_data(struct connectdata *conn);
146 static CURLcode wc_statemach(struct connectdata *conn);
150 static CURLcode ftp_state_retr(struct connectdata *conn, curl_off_t filesize);
156 static CURLcode ftp_dophase_done(struct connectdata *conn,
323 static CURLcode AcceptServerConnect(struct connectdata *conn)
325 struct SessionHandle *data = conn->data;
326 curl_socket_t sock = conn->sock[SECONDARYSOCKET];
340 Curl_closesocket(conn, sock); /* close the first socket */
348 conn->sock[SECONDARYSOCKET] = s;
350 conn->sock_accepted[SECONDARYSOCKET] = TRUE;
361 Curl_closesocket(conn, s); /* close the socket and bail out */
362 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
418 static CURLcode ReceivedServerConnect(struct connectdata *conn, bool *received)
420 struct SessionHandle *data = conn->data;
421 curl_socket_t ctrl_sock = conn->sock[FIRSTSOCKET];
422 curl_socket_t data_sock = conn->sock[SECONDARYSOCKET];
423 struct ftp_conn *ftpc = &conn->proto.ftpc;
444 Curl_GetFTPResponse(&nread, conn, &ftpcode);
465 infof(data, "Ctrl conn has data while waiting for data conn\n");
466 Curl_GetFTPResponse(&nread, conn, &ftpcode);
489 static CURLcode InitiateTransfer(struct connectdata *conn)
491 struct SessionHandle *data = conn->data;
495 if(conn->ssl[SECONDARYSOCKET].use) {
499 result = Curl_ssl_connect(conn, SECONDARYSOCKET);
504 if(conn->proto.ftpc.state_saved == FTP_STOR) {
513 Curl_sndbufset(conn->sock[SECONDARYSOCKET]);
515 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, /* no download */
520 Curl_setup_transfer(conn, SECONDARYSOCKET,
521 conn->proto.ftpc.retr_size_saved, FALSE,
525 conn->proto.ftpc.pp.pending_resp = TRUE; /* expect server response */
526 state(conn, FTP_STOP);
540 static CURLcode AllowServerConnect(struct connectdata *conn, bool *connected)
542 struct SessionHandle *data = conn->data;
560 ret = ReceivedServerConnect(conn, connected);
565 ret = AcceptServerConnect(conn);
569 ret = InitiateTransfer(conn);
594 static bool ftp_endofresp(struct connectdata *conn, char *line, size_t len,
597 (void)conn;
612 struct connectdata *conn = pp->conn;
613 struct SessionHandle *data = conn->data;
627 code = Curl_sec_read_msg(conn, buf, PROT_SAFE);
630 code = Curl_sec_read_msg(conn, buf, PROT_PRIVATE);
633 code = Curl_sec_read_msg(conn, buf, PROT_CONFIDENTIAL);
656 state(conn, FTP_STOP);
672 struct connectdata *conn,
682 curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
685 struct SessionHandle *data = conn->data;
687 struct ftp_conn *ftpc = &conn->proto.ftpc;
744 if(Curl_pgrsUpdate(conn))
816 static void _state(struct connectdata *conn,
823 struct ftp_conn *ftpc = &conn->proto.ftpc;
826 infof(conn->data, "FTP %p (line %d) state change from %s to %s\n",
833 static CURLcode ftp_state_user(struct connectdata *conn)
836 struct FTP *ftp = conn->data->req.protop;
838 PPSENDF(&conn->proto.ftpc.pp, "USER %s", ftp->user?ftp->user:"");
840 state(conn, FTP_USER);
841 conn->data->state.ftp_trying_alternative = FALSE;
846 static CURLcode ftp_state_pwd(struct connectdata *conn)
851 PPSENDF(&conn->proto.ftpc.pp, "%s", "PWD");
852 state(conn, FTP_PWD);
858 static int ftp_getsock(struct connectdata *conn,
862 return Curl_pp_getsock(&conn->proto.ftpc.pp, socks, numsocks);
866 static int ftp_domore_getsock(struct connectdata *conn, curl_socket_t *socks,
869 struct ftp_conn *ftpc = &conn->proto.ftpc;
882 socks[0] = conn->sock[FIRSTSOCKET];
883 socks[1] = conn->sock[SECONDARYSOCKET];
889 return Curl_pp_getsock(&conn->proto.ftpc.pp, socks, numsocks);
898 static CURLcode ftp_state_cwd(struct connectdata *conn)
901 struct ftp_conn *ftpc = &conn->proto.ftpc;
905 result = ftp_state_mdtm(conn);
912 ftpc->count3 = (conn->data->set.ftp_create_missing_dirs==2)?1:0;
914 if(conn->bits.reuse && ftpc->entrypath) {
920 PPSENDF(&conn->proto.ftpc.pp, "CWD %s", ftpc->entrypath);
921 state(conn, FTP_CWD);
928 PPSENDF(&conn->proto.ftpc.pp, "CWD %s", ftpc->dirs[ftpc->count1 -1]);
929 state(conn, FTP_CWD);
933 result = ftp_state_mdtm(conn);
946 static CURLcode ftp_state_use_port(struct connectdata *conn,
951 struct ftp_conn *ftpc = &conn->proto.ftpc;
952 struct SessionHandle *data=conn->data;
1058 switch(Curl_if2ip(conn->ip_addr->ai_family, conn->scope, addr,
1080 if(getsockname(conn->sock[FIRSTSOCKET], sa, &sslen)) {
1082 Curl_strerror(conn, SOCKERRNO) );
1101 rc = Curl_resolv(conn, host, 0, &h);
1103 (void)Curl_resolver_wait_resolv(conn, &h);
1127 result = Curl_socket(conn, ai, NULL, &portsock);
1135 failf(data, "socket failure: %s", Curl_strerror(conn, error));
1161 Curl_strerror(conn, error) );
1164 if(getsockname(conn->sock[FIRSTSOCKET], sa, &sslen)) {
1166 Curl_strerror(conn, SOCKERRNO) );
1167 Curl_closesocket(conn, portsock);
1176 Curl_strerror(conn, error) );
1177 Curl_closesocket(conn, portsock);
1190 Curl_closesocket(conn, portsock);
1199 Curl_strerror(conn, SOCKERRNO) );
1200 Curl_closesocket(conn, portsock);
1207 failf(data, "socket failure: %s", Curl_strerror(conn, SOCKERRNO));
1208 Curl_closesocket(conn, portsock);
1219 if(!conn->bits.ftp_use_eprt && conn->bits.ipv6)
1222 conn->bits.ftp_use_eprt = TRUE;
1227 if(!conn->bits.ftp_use_eprt && (EPRT == fcmd))
1263 Curl_closesocket(conn, portsock);
1267 state(conn, FTP_STOP);
1292 Curl_closesocket(conn, portsock);
1294 state(conn, FTP_STOP);
1307 if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET])
1308 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
1309 conn->sock[SECONDARYSOCKET] = portsock;
1318 conn->bits.tcpconnect[SECONDARYSOCKET] = TRUE;
1320 state(conn, FTP_PORT);
1324 static CURLcode ftp_state_use_pasv(struct connectdata *conn)
1326 struct ftp_conn *ftpc = &conn->proto.ftpc;
1346 if(!conn->bits.ftp_use_epsv && conn->bits.ipv6)
1349 conn->bits.ftp_use_epsv = TRUE;
1352 modeoff = conn->bits.ftp_use_epsv?0:1;
1357 state(conn, FTP_PASV);
1358 infof(conn->data, "Connect data stream passively\n");
1370 static CURLcode ftp_state_prepare_transfer(struct connectdata *conn)
1373 struct FTP *ftp = conn->data->req.protop;
1374 struct SessionHandle *data = conn->data;
1380 state(conn, FTP_RETR_PREQUOTE);
1381 result = ftp_state_quote(conn, TRUE, FTP_RETR_PREQUOTE);
1385 result = ftp_state_use_port(conn, EPRT);
1392 if(!conn->proto.ftpc.file) {
1393 PPSENDF(&conn->proto.ftpc.pp, "PRET %s",
1399 PPSENDF(&conn->proto.ftpc.pp, "PRET STOR %s", conn->proto.ftpc.file);
1402 PPSENDF(&conn->proto.ftpc.pp, "PRET RETR %s", conn->proto.ftpc.file);
1404 state(conn, FTP_PRET);
1407 result = ftp_state_use_pasv(conn);
1413 static CURLcode ftp_state_rest(struct connectdata *conn)
1416 struct FTP *ftp = conn->data->req.protop;
1417 struct ftp_conn *ftpc = &conn->proto.ftpc;
1424 PPSENDF(&conn->proto.ftpc.pp, "REST %d", 0);
1426 state(conn, FTP_REST);
1429 result = ftp_state_prepare_transfer(conn);
1434 static CURLcode ftp_state_size(struct connectdata *conn)
1437 struct FTP *ftp = conn->data->req.protop;
1438 struct ftp_conn *ftpc = &conn->proto.ftpc;
1446 state(conn, FTP_SIZE);
1449 result = ftp_state_rest(conn);
1454 static CURLcode ftp_state_list(struct connectdata *conn)
1457 struct SessionHandle *data = conn->data;
1508 result = Curl_pp_sendf(&conn->proto.ftpc.pp, "%s", cmd);
1518 state(conn, FTP_LIST);
1523 static CURLcode ftp_state_retr_prequote(struct connectdata *conn)
1529 result = ftp_state_quote(conn, TRUE, FTP_RETR_PREQUOTE);
1534 static CURLcode ftp_state_stor_prequote(struct connectdata *conn)
1540 result = ftp_state_quote(conn, TRUE, FTP_STOR_PREQUOTE);
1545 static CURLcode ftp_state_type(struct connectdata *conn)
1548 struct FTP *ftp = conn->data->req.protop;
1549 struct SessionHandle *data = conn->data;
1550 struct ftp_conn *ftpc = &conn->proto.ftpc;
1556 ftp_need_type(conn, data->set.prefer_ascii)) {
1566 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_TYPE);
1571 result = ftp_state_size(conn);
1578 static CURLcode ftp_state_mdtm(struct connectdata *conn)
1581 struct SessionHandle *data = conn->data;
1582 struct ftp_conn *ftpc = &conn->proto.ftpc;
1591 state(conn, FTP_MDTM);
1594 result = ftp_state_type(conn);
1601 static CURLcode ftp_state_ul_setup(struct connectdata *conn,
1605 struct FTP *ftp = conn->data->req.protop;
1606 struct SessionHandle *data = conn->data;
1607 struct ftp_conn *ftpc = &conn->proto.ftpc;
1628 state(conn, FTP_STOR_SIZE);
1636 if(conn->seek_func) {
1637 seekerr = conn->seek_func(conn->seek_client, data->state.resume_from,
1655 conn->fread_func(data->state.buffer, 1, readthisamountnow,
1656 conn->fread_in);
1676 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
1682 state(conn, FTP_STOP);
1692 state(conn, FTP_STOR);
1697 static CURLcode ftp_state_quote(struct connectdata *conn,
1702 struct SessionHandle *data = conn->data;
1704 struct ftp_conn *ftpc = &conn->proto.ftpc;
1751 state(conn, instate);
1761 result = ftp_state_cwd(conn);
1765 state(conn, FTP_STOP);
1769 result = ftp_state_retr(conn, ftpc->known_filesize);
1773 state(conn, FTP_RETR_SIZE);
1778 result = ftp_state_ul_setup(conn, FALSE);
1790 static CURLcode ftp_epsv_disable(struct connectdata *conn)
1793 infof(conn->data, "Failed EPSV attempt. Disabling EPSV\n");
1795 conn->bits.ftp_use_epsv = FALSE;
1796 conn->data->state.errorbuf = FALSE; /* allow error message to get
1798 PPSENDF(&conn->proto.ftpc.pp, "%s", "PASV");
1799 conn->proto.ftpc.count1++;
1801 state(conn, FTP_PASV);
1809 static CURLcode proxy_magic(struct connectdata *conn,
1814 struct SessionHandle *data=conn->data;
1817 switch(conn->proxytype) {
1820 result = Curl_SOCKS5(conn->proxyuser, conn->proxypasswd, newhost,
1821 newport, SECONDARYSOCKET, conn);
1825 result = Curl_SOCKS4(conn->proxyuser, newhost, newport,
1826 SECONDARYSOCKET, conn, FALSE);
1830 result = Curl_SOCKS4(conn->proxyuser, newhost, newport,
1831 SECONDARYSOCKET, conn, TRUE);
1844 if(conn->bits.tunnel_proxy && conn->bits.httpproxy) {
1849 * member conn->proto.http; we want FTP through HTTP and we have to
1859 result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, newhost, newport);
1866 if(conn->tunnel_state[SECONDARYSOCKET] != TUNNEL_COMPLETE) {
1868 state(conn, FTP_STOP); /* this phase is completed */
1877 static CURLcode ftp_state_pasv_resp(struct connectdata *conn,
1880 struct ftp_conn *ftpc = &conn->proto.ftpc;
1882 struct SessionHandle *data=conn->data;
1920 if(conn->bits.tunnel_proxy ||
1921 conn->proxytype == CURLPROXY_SOCKS5 ||
1922 conn->proxytype == CURLPROXY_SOCKS5_HOSTNAME ||
1923 conn->proxytype == CURLPROXY_SOCKS4 ||
1924 conn->proxytype == CURLPROXY_SOCKS4A)
1928 conn->host.name);
1931 snprintf(ftpc->newhost, NEWHOST_BUFSIZE, "%s", conn->ip_addr_str);
1976 conn->ip_addr_str);
1977 if(conn->bits.tunnel_proxy ||
1978 conn->proxytype == CURLPROXY_SOCKS5 ||
1979 conn->proxytype == CURLPROXY_SOCKS5_HOSTNAME ||
1980 conn->proxytype == CURLPROXY_SOCKS4 ||
1981 conn->proxytype == CURLPROXY_SOCKS4A)
1984 snprintf(ftpc->newhost, sizeof(ftpc->newhost), "%s", conn->host.name);
1987 conn->ip_addr_str);
1996 return ftp_epsv_disable(conn);
2003 if(conn->bits.proxy) {
2009 rc = Curl_resolv(conn, conn->proxy.name, (int)conn->port, &addr);
2013 (void)Curl_resolver_wait_resolv(conn, &addr);
2016 (unsigned short)conn->port; /* we connect to the proxy's port */
2020 conn->proxy.name, connectport);
2026 rc = Curl_resolv(conn, ftpc->newhost, ftpc->newport, &addr);
2029 (void)Curl_resolver_wait_resolv(conn, &addr);
2039 conn->bits.tcpconnect[SECONDARYSOCKET] = FALSE;
2040 result = Curl_connecthost(conn, addr);
2046 return ftp_epsv_disable(conn);
2060 ftp_pasv_verbose(conn, conn->ip_addr, ftpc->newhost, connectport);
2062 conn->bits.do_more = TRUE;
2063 state(conn, FTP_STOP); /* this phase is completed */
2068 static CURLcode ftp_state_port_resp(struct connectdata *conn,
2071 struct SessionHandle *data = conn->data;
2072 struct ftp_conn *ftpc = &conn->proto.ftpc;
2081 conn->bits.ftp_use_eprt = FALSE;
2091 result = ftp_state_use_port(conn, fcmd);
2095 state(conn, FTP_STOP); /* end of DO phase */
2096 result = ftp_dophase_done(conn, FALSE);
2102 static CURLcode ftp_state_mdtm_resp(struct connectdata *conn,
2106 struct SessionHandle *data=conn->data;
2108 struct ftp_conn *ftpc = &conn->proto.ftpc;
2122 snprintf(buf, sizeof(conn->data->state.buffer),
2155 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
2180 state(conn, FTP_STOP);
2189 state(conn, FTP_STOP);
2201 result = ftp_state_type(conn);
2206 static CURLcode ftp_state_type_resp(struct connectdata *conn,
2211 struct SessionHandle *data=conn->data;
2225 result = ftp_state_size(conn);
2227 result = ftp_state_list(conn);
2229 result = ftp_state_retr_prequote(conn);
2231 result = ftp_state_stor_prequote(conn);
2236 static CURLcode ftp_state_retr(struct connectdata *conn,
2240 struct SessionHandle *data=conn->data;
2242 struct ftp_conn *ftpc = &conn->proto.ftpc;
2290 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
2296 state(conn, FTP_STOP);
2307 state(conn, FTP_RETR_REST);
2312 state(conn, FTP_RETR);
2318 static CURLcode ftp_state_size_resp(struct connectdata *conn,
2323 struct SessionHandle *data=conn->data;
2335 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
2341 result = ftp_state_rest(conn);
2345 result = ftp_state_retr(conn, filesize);
2349 result = ftp_state_ul_setup(conn, TRUE);
2355 static CURLcode ftp_state_rest_resp(struct connectdata *conn,
2360 struct ftp_conn *ftpc = &conn->proto.ftpc;
2368 result = Curl_client_write(conn, CLIENTWRITE_BOTH, buffer, 0);
2373 result = ftp_state_prepare_transfer(conn);
2378 failf(conn->data, "Couldn't use REST");
2383 state(conn, FTP_RETR);
2391 static CURLcode ftp_state_stor_resp(struct connectdata *conn,
2395 struct SessionHandle *data = conn->data;
2399 state(conn, FTP_STOP);
2404 conn->proto.ftpc.state_saved = instate;
2410 state(conn, FTP_STOP); /* no longer in STOR state */
2412 result = AllowServerConnect(conn, &connected);
2417 struct ftp_conn *ftpc = &conn->proto.ftpc;
2418 infof(data, "Data conn was not available immediately\n");
2425 return InitiateTransfer(conn);
2429 static CURLcode ftp_state_get_resp(struct connectdata *conn,
2434 struct SessionHandle *data = conn->data;
2519 conn->proto.ftpc.state_saved = instate;
2520 conn->proto.ftpc.retr_size_saved = size;
2525 result = AllowServerConnect(conn, &connected);
2530 struct ftp_conn *ftpc = &conn->proto.ftpc;
2531 infof(data, "Data conn was not available immediately\n");
2532 state(conn, FTP_STOP);
2537 return InitiateTransfer(conn);
2543 state(conn, FTP_STOP); /* this phase is over */
2557 static CURLcode ftp_state_loggedin(struct connectdata *conn)
2561 if(conn->ssl[FIRSTSOCKET].use) {
2576 PPSENDF(&conn->proto.ftpc.pp, "PBSZ %d", 0);
2577 state(conn, FTP_PBSZ);
2580 result = ftp_state_pwd(conn);
2586 static CURLcode ftp_state_user_resp(struct connectdata *conn,
2591 struct SessionHandle *data = conn->data;
2593 struct ftp_conn *ftpc = &conn->proto.ftpc;
2601 state(conn, FTP_PASS);
2606 result = ftp_state_loggedin(conn);
2611 state(conn, FTP_ACCT);
2624 if(conn->data->set.str[STRING_FTP_ALTERNATIVE_TO_USER] &&
2625 !conn->data->state.ftp_trying_alternative) {
2627 PPSENDF(&conn->proto.ftpc.pp, "%s",
2628 conn->data->set.str[STRING_FTP_ALTERNATIVE_TO_USER]);
2629 conn->data->state.ftp_trying_alternative = TRUE;
2630 state(conn, FTP_USER);
2642 static CURLcode ftp_state_acct_resp(struct connectdata *conn,
2646 struct SessionHandle *data = conn->data;
2652 result = ftp_state_loggedin(conn);
2658 static CURLcode ftp_statemach_act(struct connectdata *conn)
2661 curl_socket_t sock = conn->sock[FIRSTSOCKET];
2662 struct SessionHandle *data=conn->data;
2664 struct ftp_conn *ftpc = &conn->proto.ftpc;
2682 return ftp_state_user_resp(conn, ftpcode, ftpc->state);
2695 Curl_sec_request_prot(conn, "private");
2698 Curl_sec_request_prot(conn, data->set.str[STRING_KRB_LEVEL]);
2700 if(Curl_sec_login(conn) != CURLE_OK)
2707 if(data->set.use_ssl && !conn->ssl[FIRSTSOCKET].use) {
2728 state(conn, FTP_AUTH);
2731 result = ftp_state_user(conn);
2750 result = Curl_ssl_connect(conn, FIRSTSOCKET);
2752 conn->ssl[SECONDARYSOCKET].use = FALSE; /* clear-text data */
2753 result = ftp_state_user(conn);
2768 result = ftp_state_user(conn);
2777 result = ftp_state_user_resp(conn, ftpcode, ftpc->state);
2781 result = ftp_state_acct_resp(conn, ftpcode);
2787 state(conn, FTP_PROT);
2794 conn->ssl[SECONDARYSOCKET].use =
2806 state(conn, FTP_CCC);
2809 result = ftp_state_pwd(conn);
2818 result = Curl_ssl_shutdown(conn, FIRSTSOCKET);
2821 failf(conn->data, "Failed to clear the command channel (CCC)");
2827 result = ftp_state_pwd(conn);
2902 state(conn, FTP_SYST);
2918 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2953 state(conn, FTP_NAMEFMT);
2967 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2974 ftp_state_pwd(conn);
2978 state(conn, FTP_STOP); /* we are done with the CONNECT phase! */
2988 failf(conn->data, "QUOT command failed with %03d", ftpcode);
2991 result = ftp_state_quote(conn, FALSE, ftpc->state);
3000 if(conn->data->set.ftp_create_missing_dirs &&
3005 state(conn, FTP_MKD);
3023 result = ftp_state_mdtm(conn);
3036 state(conn, FTP_CWD);
3042 result = ftp_state_mdtm_resp(conn, ftpcode);
3049 result = ftp_state_type_resp(conn, ftpcode, ftpc->state);
3055 result = ftp_state_size_resp(conn, ftpcode, ftpc->state);
3060 result = ftp_state_rest_resp(conn, ftpcode, ftpc->state);
3069 result = ftp_state_use_pasv(conn);
3073 result = ftp_state_pasv_resp(conn, ftpcode);
3077 result = ftp_state_port_resp(conn, ftpcode);
3082 result = ftp_state_get_resp(conn, ftpcode, ftpc->state);
3086 result = ftp_state_stor_resp(conn, ftpcode, ftpc->state);
3093 state(conn, FTP_STOP);
3103 static CURLcode ftp_multi_statemach(struct connectdata *conn,
3106 struct ftp_conn *ftpc = &conn->proto.ftpc;
3117 static CURLcode ftp_block_statemach(struct connectdata *conn)
3119 struct ftp_conn *ftpc = &conn->proto.ftpc;
3140 static CURLcode ftp_connect(struct connectdata *conn,
3144 struct ftp_conn *ftpc = &conn->proto.ftpc;
3150 conn->bits.close = FALSE;
3155 pp->conn = conn;
3157 if(conn->handler->flags & PROTOPT_SSL) {
3159 result = Curl_ssl_connect(conn, FIRSTSOCKET);
3168 state(conn, FTP_WAIT220);
3170 result = ftp_multi_statemach(conn, done);
3184 static CURLcode ftp_done(struct connectdata *conn, CURLcode status,
3187 struct SessionHandle *data = conn->data;
3189 struct ftp_conn *ftpc = &conn->proto.ftpc;
3234 conn->bits.close = TRUE; /* marked for closure */
3258 conn->bits.close = TRUE; /* mark for connection closure */
3290 shutdown(conn->sock[SECONDARYSOCKET],2); /* SD_BOTH */
3293 if(conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD) {
3301 conn->bits.close = TRUE; /* mark for connection closure */
3305 if(conn->ssl[SECONDARYSOCKET].use) {
3308 Curl_ssl_close(conn, SECONDARYSOCKET);
3313 if(CURL_SOCKET_BAD != conn->sock[SECONDARYSOCKET]) {
3314 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
3315 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
3316 conn->bits.tcpconnect[SECONDARYSOCKET] = FALSE;
3333 result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
3340 conn->bits.close = TRUE; /* mark for closure */
3350 conn->bits.close = TRUE; /* mark for closure */
3408 result = ftp_sendquote(conn, data->set.postquote);
3424 CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
3430 struct ftp_conn *ftpc = &conn->proto.ftpc;
3449 PPSENDF(&conn->proto.ftpc.pp, "%s", cmd);
3453 result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
3458 failf(conn->data, "QUOT string not accepted: %s", cmd);
3475 static int ftp_need_type(struct connectdata *conn,
3478 return conn->proto.ftpc.transfertype != (ascii_wanted?'A':'I');
3489 static CURLcode ftp_nb_type(struct connectdata *conn,
3492 struct ftp_conn *ftpc = &conn->proto.ftpc;
3497 state(conn, newstate);
3498 return ftp_state_type_resp(conn, 200, newstate);
3502 state(conn, newstate);
3520 ftp_pasv_verbose(struct connectdata *conn,
3527 infof(conn->data, "Connecting to %s (%s) port %d\n", newhost, buf, port);
3536 static CURLcode ftp_range(struct connectdata *conn)
3541 struct SessionHandle *data = conn->data;
3542 struct ftp_conn *ftpc = &conn->proto.ftpc;
3556 DEBUGF(infof(conn->data, "FTP RANGE %" CURL_FORMAT_CURL_OFF_T
3563 DEBUGF(infof(conn->data, "FTP RANGE the last %" CURL_FORMAT_CURL_OFF_T
3570 DEBUGF(infof(conn->data, "FTP RANGE from %" CURL_FORMAT_CURL_OFF_T
3574 DEBUGF(infof(conn->data, "range-download from %" CURL_FORMAT_CURL_OFF_T
3597 static CURLcode ftp_do_more(struct connectdata *conn, int *completep)
3599 struct SessionHandle *data=conn->data;
3600 struct ftp_conn *ftpc = &conn->proto.ftpc;
3609 if(!conn->bits.tcpconnect[SECONDARYSOCKET]) {
3610 if(conn->tunnel_state[SECONDARYSOCKET] == TUNNEL_CONNECT) {
3613 result = Curl_proxyCONNECT(conn, SECONDARYSOCKET, NULL, 0);
3618 result = Curl_is_connected(conn, SECONDARYSOCKET, &connected);
3623 if(conn->bits.proxy) {
3625 result = proxy_magic(conn, ftpc->newhost, ftpc->newport, &connected);
3632 return ftp_epsv_disable(conn);
3641 result = ftp_multi_statemach(conn, &complete);
3664 result = ReceivedServerConnect(conn, &serv_conned);
3670 result = AcceptServerConnect(conn);
3673 result = InitiateTransfer(conn);
3683 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_STOR_TYPE);
3687 result = ftp_multi_statemach(conn, &complete);
3694 result = ftp_range(conn);
3704 result = ftp_nb_type(conn, TRUE, FTP_LIST_TYPE);
3711 result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_RETR_TYPE);
3716 result = ftp_multi_statemach(conn, &complete);
3725 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
3747 CURLcode ftp_perform(struct connectdata *conn,
3754 DEBUGF(infof(conn->data, "DO phase starts\n"));
3756 if(conn->data->set.opt_no_body) {
3758 struct FTP *ftp = conn->data->req.protop;
3765 result = ftp_state_quote(conn, TRUE, FTP_QUOTE);
3770 result = ftp_multi_statemach(conn, dophase_done);
3772 *connected = conn->bits.tcpconnect[SECONDARYSOCKET];
3774 infof(conn->data, "ftp_perform ends with SECONDARY: %d\n", *connected);
3777 DEBUGF(infof(conn->data, "DO phase is complete1\n"));
3790 static CURLcode init_wc_data(struct connectdata *conn)
3793 char *path = conn->data->state.path;
3794 struct WildcardData *wildcard = &(conn->data->wildcard);
3798 last_slash = strrchr(conn->data->state.path, '/');
3803 ret = ftp_parse_url_path(conn);
3822 ret = ftp_parse_url_path(conn);
3849 if(conn->data->set.ftp_filemethod == FTPFILE_NOCWD)
3850 conn->data->set.ftp_filemethod = FTPFILE_MULTICWD;
3853 ret = ftp_parse_url_path(conn);
3862 wildcard->path = strdup(conn->data->state.path);
3872 ftp_tmp->backup.write_function = conn->data->set.fwrite_func;
3874 conn->data->set.fwrite_func = Curl_ftp_parselist;
3876 ftp_tmp->backup.file_descriptor = conn->data->set.out;
3878 conn->data->set.out = conn;
3880 infof(conn->data, "Wildcard - Parsing started\n");
3885 static CURLcode wc_statemach(struct connectdata *conn)
3887 struct WildcardData * const wildcard = &(conn->data->wildcard);
3892 ret = init_wc_data(conn);
3904 conn->data->set.fwrite_func = ftp_tmp->backup.write_function;
3905 conn->data->set.out = ftp_tmp->backup.file_descriptor;
3913 return wc_statemach(conn);
3920 return wc_statemach(conn);
3925 struct ftp_conn *ftpc = &conn->proto.ftpc;
3934 Curl_safefree(conn->data->state.pathbuffer);
3935 conn->data->state.pathbuffer = tmp_path;
3936 conn->data->state.path = tmp_path;
3938 infof(conn->data, "Wildcard - START of \"%s\"\n", finfo->filename);
3939 if(conn->data->set.chunk_bgn) {
3940 long userresponse = conn->data->set.chunk_bgn(
3944 infof(conn->data, "Wildcard - \"%s\" skipped by user\n",
3947 return wc_statemach(conn);
3955 return wc_statemach(conn);
3961 ret = ftp_parse_url_path(conn);
3978 if(conn->data->set.chunk_end)
3979 conn->data->set.chunk_end(conn->data->wildcard.customptr);
3983 return wc_statemach(conn);
4012 static CURLcode ftp_do(struct connectdata *conn, bool *done)
4015 struct ftp_conn *ftpc = &conn->proto.ftpc;
4020 if(conn->data->set.wildcardmatch) {
4021 retcode = wc_statemach(conn);
4022 if(conn->data->wildcard.state == CURLWC_SKIP ||
4023 conn->data->wildcard.state == CURLWC_DONE) {
4031 retcode = ftp_parse_url_path(conn);
4036 retcode = ftp_regular_transfer(conn, done);
4042 CURLcode Curl_ftpsendf(struct connectdata *conn,
4052 enum protection_level data_sec = conn->data_prot;
4065 res = Curl_convert_to_network(conn->data, s, write_len);
4072 conn->data_prot = PROT_CMD;
4074 res = Curl_write(conn, conn->sock[FIRSTSOCKET], sptr, write_len,
4078 conn->data_prot = data_sec;
4084 if(conn->data->set.verbose)
4085 Curl_debug(conn->data, CURLINFO_HEADER_OUT,
4086 sptr, (size_t)bytes_written, conn);
4109 static CURLcode ftp_quit(struct connectdata *conn)
4113 if(conn->proto.ftpc.ctl_valid) {
4114 result = Curl_pp_sendf(&conn->proto.ftpc.pp, "%s", "QUIT");
4116 failf(conn->data, "Failure sending QUIT command: %s",
4118 conn->proto.ftpc.ctl_valid = FALSE; /* mark control connection as bad */
4119 conn->bits.close = TRUE; /* mark for connection closure */
4120 state(conn, FTP_STOP);
4124 state(conn, FTP_QUIT);
4126 result = ftp_block_statemach(conn);
4139 static CURLcode ftp_disconnect(struct connectdata *conn, bool dead_connection)
4141 struct ftp_conn *ftpc= &conn->proto.ftpc;
4155 (void)ftp_quit(conn); /* ignore errors on the QUIT */
4158 struct SessionHandle *data = conn->data;
4179 Curl_sec_end(conn);
4193 CURLcode ftp_parse_url_path(struct connectdata *conn)
4195 struct SessionHandle *data = conn->data;
4198 struct ftp_conn *ftpc = &conn->proto.ftpc;
4251 ftpc->dirs[0] = curl_easy_unescape(conn->data, slash_pos ? cur_pos : "/",
4293 curl_easy_unescape(conn->data, cur_pos - absolute_dir, len, NULL);
4338 ftpc->file = curl_easy_unescape(conn->data, filename, 0, NULL);
4365 char *path = curl_easy_unescape(conn->data, data->state.path, 0, &dlen);
4384 static CURLcode ftp_dophase_done(struct connectdata *conn,
4387 struct FTP *ftp = conn->data->req.protop;
4388 struct ftp_conn *ftpc = &conn->proto.ftpc;
4392 CURLcode result = ftp_do_more(conn, &completed);
4395 if(conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD) {
4397 Curl_closesocket(conn, conn->sock[SECONDARYSOCKET]);
4398 conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
4406 Curl_setup_transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
4409 conn->bits.do_more = TRUE;
4417 static CURLcode ftp_doing(struct connectdata *conn,
4420 CURLcode result = ftp_multi_statemach(conn, dophase_done);
4423 DEBUGF(infof(conn->data, "DO phase failed\n"));
4425 result = ftp_dophase_done(conn, FALSE /* not connected */);
4427 DEBUGF(infof(conn->data, "DO phase is complete2\n"));
4445 CURLcode ftp_regular_transfer(struct connectdata *conn,
4450 struct SessionHandle *data = conn->data;
4451 struct ftp_conn *ftpc = &conn->proto.ftpc;
4461 result = ftp_perform(conn,
4471 result = ftp_dophase_done(conn, connected);
4482 static CURLcode ftp_setup_connection(struct connectdata *conn)
4484 struct SessionHandle *data = conn->data;
4489 if(conn->bits.httpproxy && !data->set.tunnel_thru_httpproxy) {
4493 if(conn->handler == &Curl_handler_ftp)
4494 conn->handler = &Curl_handler_ftp_proxy;
4497 conn->handler = &Curl_handler_ftps_proxy;
4504 return conn->handler->setup_connection(conn);
4511 conn->data->req.protop = ftp = malloc(sizeof(struct FTP));
4523 type = strstr(conn->host.rawalloc, ";type=");
4528 conn->bits.type_set = TRUE;
4548 ftp->bytecountp = &conn->data->req.bytecount;
4554 since the conn struct may have changed or been replaced.
4556 ftp->user = conn->user;
4557 ftp->passwd = conn->passwd;
4563 conn->proto.ftpc.known_filesize = -1; /* unknown size for now */