2002-09-03 07:52:59 -04:00
|
|
|
/***************************************************************************
|
2004-06-03 07:41:05 -04:00
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
1999-12-29 09:20:26 -05:00
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2004-01-07 04:19:33 -05:00
|
|
|
* Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2002-09-03 07:52:59 -04:00
|
|
|
* This software is licensed as described in the file COPYING, which
|
|
|
|
* you should have received as part of this distribution. The terms
|
|
|
|
* are also available at http://curl.haxx.se/docs/copyright.html.
|
2004-06-03 07:41:05 -04:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* You may opt to use, copy, modify, merge, publish, distribute and/or sell
|
|
|
|
* copies of the Software, and permit persons to whom the Software is
|
2002-09-03 07:52:59 -04:00
|
|
|
* furnished to do so, under the terms of the COPYING file.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
|
|
|
|
* KIND, either express or implied.
|
1999-12-29 09:20:26 -05:00
|
|
|
*
|
2001-01-03 04:29:33 -05:00
|
|
|
* $Id$
|
2002-09-03 07:52:59 -04:00
|
|
|
***************************************************************************/
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-08-24 10:26:06 -04:00
|
|
|
#include "setup.h"
|
|
|
|
|
2002-06-11 07:13:01 -04:00
|
|
|
#ifndef CURL_DISABLE_FTP
|
1999-12-29 09:20:26 -05:00
|
|
|
#include <stdio.h>
|
|
|
|
#include <string.h>
|
|
|
|
#include <stdlib.h>
|
2001-01-08 05:00:14 -05:00
|
|
|
#include <stdarg.h>
|
1999-12-29 09:20:26 -05:00
|
|
|
#include <ctype.h>
|
|
|
|
#include <errno.h>
|
|
|
|
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
|
|
#include <unistd.h>
|
|
|
|
#endif
|
|
|
|
#ifdef HAVE_SYS_SELECT_H
|
|
|
|
#include <sys/select.h>
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#if defined(WIN32) && !defined(__GNUC__) || defined(__MINGW32__)
|
2003-10-14 08:00:45 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#else /* some kind of unix */
|
2000-05-29 18:51:13 -04:00
|
|
|
#ifdef HAVE_SYS_SOCKET_H
|
1999-12-29 09:20:26 -05:00
|
|
|
#include <sys/socket.h>
|
2000-05-29 18:51:13 -04:00
|
|
|
#endif
|
|
|
|
#include <sys/types.h>
|
2000-08-23 03:23:42 -04:00
|
|
|
#ifdef HAVE_NETINET_IN_H
|
1999-12-29 09:20:26 -05:00
|
|
|
#include <netinet/in.h>
|
2000-08-23 03:23:42 -04:00
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
#ifdef HAVE_ARPA_INET_H
|
|
|
|
#include <arpa/inet.h>
|
|
|
|
#endif
|
|
|
|
#include <sys/utsname.h>
|
2000-08-23 03:23:42 -04:00
|
|
|
#ifdef HAVE_NETDB_H
|
1999-12-29 09:20:26 -05:00
|
|
|
#include <netdb.h>
|
|
|
|
#endif
|
2001-08-06 08:47:39 -04:00
|
|
|
#ifdef VMS
|
2002-02-20 08:46:53 -05:00
|
|
|
#include <in.h>
|
2001-08-06 08:47:39 -04:00
|
|
|
#include <inet.h>
|
|
|
|
#endif
|
2000-08-23 03:23:42 -04:00
|
|
|
#endif
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
#if defined(WIN32) && defined(__GNUC__) || defined(__MINGW32__)
|
|
|
|
#include <errno.h>
|
|
|
|
#endif
|
|
|
|
|
2004-03-17 07:46:42 -05:00
|
|
|
#if (defined(NETWARE) && defined(__NOVELL_LIBC__))
|
|
|
|
#undef in_addr_t
|
|
|
|
#define in_addr_t unsigned long
|
|
|
|
#endif
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
#include <curl/curl.h>
|
|
|
|
#include "urldata.h"
|
|
|
|
#include "sendf.h"
|
|
|
|
|
|
|
|
#include "if2ip.h"
|
|
|
|
#include "hostip.h"
|
|
|
|
#include "progress.h"
|
2001-01-17 08:23:01 -05:00
|
|
|
#include "transfer.h"
|
2000-01-10 18:36:14 -05:00
|
|
|
#include "escape.h"
|
2000-11-21 04:30:07 -05:00
|
|
|
#include "http.h" /* for HTTP proxy tunnel stuff */
|
2001-01-05 05:11:41 -05:00
|
|
|
#include "ftp.h"
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2003-12-02 08:27:29 -05:00
|
|
|
#ifdef HAVE_KRB4
|
2000-09-21 04:47:20 -04:00
|
|
|
#include "security.h"
|
2001-01-05 05:11:41 -05:00
|
|
|
#include "krb4.h"
|
2000-09-21 04:47:20 -04:00
|
|
|
#endif
|
2001-01-05 05:11:41 -05:00
|
|
|
|
2004-01-05 17:29:29 -05:00
|
|
|
#include "strtoofft.h"
|
2001-03-14 13:24:07 -05:00
|
|
|
#include "strequal.h"
|
2001-03-29 03:16:55 -05:00
|
|
|
#include "ssluse.h"
|
2001-10-02 05:40:06 -04:00
|
|
|
#include "connect.h"
|
2004-03-25 08:42:23 -05:00
|
|
|
#include "strerror.h"
|
2004-05-11 07:30:23 -04:00
|
|
|
#include "memory.h"
|
2004-06-24 03:43:48 -04:00
|
|
|
#include "inet_ntop.h"
|
2001-03-14 13:24:07 -05:00
|
|
|
|
2002-01-04 04:35:23 -05:00
|
|
|
#if defined(HAVE_INET_NTOA_R) && !defined(HAVE_INET_NTOA_R_DECL)
|
|
|
|
#include "inet_ntoa_r.h"
|
|
|
|
#endif
|
|
|
|
|
2001-01-08 11:22:55 -05:00
|
|
|
#define _MPRINTF_REPLACE /* use our functions only */
|
|
|
|
#include <curl/mprintf.h>
|
|
|
|
|
2000-10-09 07:12:34 -04:00
|
|
|
/* The last #include file should be: */
|
2003-06-26 02:52:48 -04:00
|
|
|
#ifdef CURLDEBUG
|
2000-10-09 07:12:34 -04:00
|
|
|
#include "memdebug.h"
|
|
|
|
#endif
|
2000-09-21 04:47:20 -04:00
|
|
|
|
2004-03-31 16:33:52 -05:00
|
|
|
#ifdef HAVE_NI_WITHSCOPEID
|
2004-03-31 05:59:48 -05:00
|
|
|
#define NIFLAGS NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID
|
|
|
|
#else
|
|
|
|
#define NIFLAGS NI_NUMERICHOST | NI_NUMERICSERV
|
|
|
|
#endif
|
|
|
|
|
2001-08-15 03:14:51 -04:00
|
|
|
/* Local API functions */
|
2003-08-08 05:13:19 -04:00
|
|
|
static CURLcode ftp_sendquote(struct connectdata *conn,
|
|
|
|
struct curl_slist *quote);
|
2001-09-28 04:58:18 -04:00
|
|
|
static CURLcode ftp_cwd(struct connectdata *conn, char *path);
|
2003-08-08 05:13:19 -04:00
|
|
|
static CURLcode ftp_mkd(struct connectdata *conn, char *path);
|
2003-08-22 08:35:18 -04:00
|
|
|
static CURLcode ftp_cwd_and_mkd(struct connectdata *conn, char *path);
|
2004-04-22 09:09:00 -04:00
|
|
|
static CURLcode ftp_quit(struct connectdata *conn);
|
2004-06-03 07:41:05 -04:00
|
|
|
static CURLcode ftp_3rdparty_pretransfer(struct connectdata *conn);
|
|
|
|
static CURLcode ftp_3rdparty_transfer(struct connectdata *conn);
|
|
|
|
static CURLcode ftp_regular_transfer(struct connectdata *conn);
|
|
|
|
static CURLcode ftp_3rdparty(struct connectdata *conn);
|
2001-08-15 02:58:56 -04:00
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
/* easy-to-use macro: */
|
2001-10-31 09:56:12 -05:00
|
|
|
#define FTPSENDF(x,y,z) if((result = Curl_ftpsendf(x,y,z))) return result
|
2001-01-05 05:11:41 -05:00
|
|
|
|
2003-08-05 09:04:10 -04:00
|
|
|
static void freedirs(struct FTP *ftp)
|
|
|
|
{
|
|
|
|
int i;
|
2004-04-15 03:52:39 -04:00
|
|
|
if(ftp->dirs) {
|
|
|
|
for (i=0; i < ftp->dirdepth; i++){
|
|
|
|
if(ftp->dirs[i]) {
|
|
|
|
free(ftp->dirs[i]);
|
|
|
|
ftp->dirs[i]=NULL;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
free(ftp->dirs);
|
|
|
|
ftp->dirs = NULL;
|
|
|
|
}
|
|
|
|
if(ftp->file) {
|
|
|
|
free(ftp->file);
|
|
|
|
ftp->file = NULL;
|
2003-08-05 09:04:10 -04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* AllowServerConnect()
|
|
|
|
*
|
|
|
|
* When we've issue the PORT command, we have told the server to connect
|
|
|
|
* to us. This function will sit and wait here until the server has
|
|
|
|
* connected.
|
|
|
|
*
|
|
|
|
*/
|
2003-11-24 02:15:37 -05:00
|
|
|
static CURLcode AllowServerConnect(struct connectdata *conn)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
fd_set rdset;
|
|
|
|
struct timeval dt;
|
2003-11-24 02:15:37 -05:00
|
|
|
struct SessionHandle *data = conn->data;
|
2004-03-09 17:52:50 -05:00
|
|
|
curl_socket_t sock = conn->sock[SECONDARYSOCKET];
|
2004-02-05 04:26:01 -05:00
|
|
|
struct timeval now = Curl_tvnow();
|
2004-02-26 08:40:43 -05:00
|
|
|
long timespent = Curl_tvdiff(Curl_tvnow(), now)/1000;
|
|
|
|
long timeout = data->set.connecttimeout?data->set.connecttimeout:
|
2004-02-05 04:26:01 -05:00
|
|
|
(data->set.timeout?data->set.timeout: 0);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
FD_ZERO(&rdset);
|
|
|
|
|
|
|
|
FD_SET(sock, &rdset);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2004-02-05 04:26:01 -05:00
|
|
|
if(timeout) {
|
|
|
|
timeout -= timespent;
|
|
|
|
if(timeout<=0) {
|
|
|
|
failf(data, "Timed out before server could connect to us");
|
|
|
|
return CURLE_OPERATION_TIMEDOUT;
|
|
|
|
}
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2004-02-05 04:26:01 -05:00
|
|
|
/* we give the server 60 seconds to connect to us, or a custom timeout */
|
2004-03-03 08:17:44 -05:00
|
|
|
dt.tv_sec = (int)(timeout?timeout:60);
|
1999-12-29 09:20:26 -05:00
|
|
|
dt.tv_usec = 0;
|
|
|
|
|
2001-08-17 22:42:23 -04:00
|
|
|
switch (select(sock+1, &rdset, NULL, NULL, &dt)) {
|
1999-12-29 09:20:26 -05:00
|
|
|
case -1: /* error */
|
|
|
|
/* let's die here */
|
|
|
|
failf(data, "Error while waiting for server connect");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
1999-12-29 09:20:26 -05:00
|
|
|
case 0: /* timeout */
|
|
|
|
/* let's die here */
|
|
|
|
failf(data, "Timeout while waiting for server connect");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
1999-12-29 09:20:26 -05:00
|
|
|
default:
|
|
|
|
/* we have received data here */
|
|
|
|
{
|
2004-03-11 08:13:35 -05:00
|
|
|
curl_socket_t s;
|
1999-12-29 09:20:26 -05:00
|
|
|
size_t size = sizeof(struct sockaddr_in);
|
|
|
|
struct sockaddr_in add;
|
|
|
|
|
2001-03-09 10:12:22 -05:00
|
|
|
getsockname(sock, (struct sockaddr *) &add, (socklen_t *)&size);
|
|
|
|
s=accept(sock, (struct sockaddr *) &add, (socklen_t *)&size);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-12-18 11:13:37 -05:00
|
|
|
sclose(sock); /* close the first socket */
|
|
|
|
|
2004-03-11 08:13:35 -05:00
|
|
|
if (CURL_SOCKET_BAD == s) {
|
2001-09-04 22:49:04 -04:00
|
|
|
/* DIE! */
|
|
|
|
failf(data, "Error accept()ing server connect");
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
infof(data, "Connection accepted from server\n");
|
|
|
|
|
2003-11-24 02:15:37 -05:00
|
|
|
conn->sock[SECONDARYSOCKET] = s;
|
2003-05-12 08:37:35 -04:00
|
|
|
Curl_nonblock(s, TRUE); /* enable non-blocking */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
2003-12-01 05:14:39 -05:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_OK;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/* --- parse FTP server responses --- */
|
|
|
|
|
2001-08-23 02:10:01 -04:00
|
|
|
/*
|
|
|
|
* Curl_GetFTPResponse() is supposed to be invoked after each command sent to
|
|
|
|
* a remote FTP server. This function will wait and read all lines of the
|
|
|
|
* response and extract the relevant return code for the invoking function.
|
|
|
|
*/
|
2001-04-26 06:29:24 -04:00
|
|
|
|
2003-03-11 13:58:21 -05:00
|
|
|
CURLcode Curl_GetFTPResponse(ssize_t *nreadp, /* return number of bytes read */
|
2002-12-03 05:25:31 -05:00
|
|
|
struct connectdata *conn,
|
|
|
|
int *ftpcode) /* return the ftp-code */
|
2001-04-26 06:29:24 -04:00
|
|
|
{
|
|
|
|
/* Brand new implementation.
|
|
|
|
* We cannot read just one byte per read() and then go back to select()
|
|
|
|
* as it seems that the OpenSSL read() stuff doesn't grok that properly.
|
|
|
|
*
|
|
|
|
* Alas, read as much as possible, split up into lines, use the ending
|
2001-08-23 02:10:01 -04:00
|
|
|
* line in a response or continue reading. */
|
2001-04-26 06:29:24 -04:00
|
|
|
|
2004-03-09 17:52:50 -05:00
|
|
|
curl_socket_t sockfd = conn->sock[FIRSTSOCKET];
|
2001-04-26 06:29:24 -04:00
|
|
|
int perline; /* count bytes per line */
|
|
|
|
bool keepon=TRUE;
|
|
|
|
ssize_t gotbytes;
|
|
|
|
char *ptr;
|
2004-03-03 08:17:44 -05:00
|
|
|
long timeout; /* timeout in seconds */
|
2001-04-26 06:29:24 -04:00
|
|
|
struct timeval interval;
|
|
|
|
fd_set rkeepfd;
|
|
|
|
fd_set readfd;
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data = conn->data;
|
2001-04-26 06:29:24 -04:00
|
|
|
char *line_start;
|
2002-12-03 05:25:31 -05:00
|
|
|
int code=0; /* default ftp "error code" to return */
|
|
|
|
char *buf = data->state.buffer;
|
|
|
|
CURLcode result = CURLE_OK;
|
2001-12-03 08:48:59 -05:00
|
|
|
struct FTP *ftp = conn->proto.ftp;
|
2002-12-03 05:25:31 -05:00
|
|
|
struct timeval now = Curl_tvnow();
|
2001-12-03 08:48:59 -05:00
|
|
|
|
2001-09-04 22:49:04 -04:00
|
|
|
if (ftpcode)
|
|
|
|
*ftpcode = 0; /* 0 for errors */
|
2001-04-26 06:29:24 -04:00
|
|
|
|
|
|
|
FD_ZERO (&readfd); /* clear it */
|
|
|
|
FD_SET (sockfd, &readfd); /* read socket */
|
|
|
|
|
|
|
|
/* get this in a backup variable to be able to restore it on each lap in the
|
|
|
|
select() loop */
|
|
|
|
rkeepfd = readfd;
|
|
|
|
|
|
|
|
ptr=buf;
|
|
|
|
line_start = buf;
|
|
|
|
|
2002-12-04 03:56:55 -05:00
|
|
|
*nreadp=0;
|
2001-04-26 06:29:24 -04:00
|
|
|
perline=0;
|
|
|
|
keepon=TRUE;
|
|
|
|
|
2002-12-04 03:56:55 -05:00
|
|
|
while((*nreadp<BUFSIZE) && (keepon && !result)) {
|
2002-04-27 09:24:06 -04:00
|
|
|
/* check and reset timeout value every lap */
|
2003-09-03 18:02:40 -04:00
|
|
|
if(data->set.ftp_response_timeout )
|
|
|
|
/* if CURLOPT_FTP_RESPONSE_TIMEOUT is set, use that to determine
|
|
|
|
remaining time. Also, use "now" as opposed to "conn->now"
|
|
|
|
because ftp_response_timeout is only supposed to govern
|
|
|
|
the response for any given ftp response, not for the time
|
|
|
|
from connect to the given ftp response. */
|
|
|
|
timeout = data->set.ftp_response_timeout - /* timeout time */
|
|
|
|
Curl_tvdiff(Curl_tvnow(), now)/1000; /* spent time */
|
|
|
|
else if(data->set.timeout)
|
2002-04-27 09:24:06 -04:00
|
|
|
/* if timeout is requested, find out how much remaining time we have */
|
|
|
|
timeout = data->set.timeout - /* timeout time */
|
|
|
|
Curl_tvdiff(Curl_tvnow(), conn->now)/1000; /* spent time */
|
2002-12-03 05:25:31 -05:00
|
|
|
else
|
|
|
|
/* Even without a requested timeout, we only wait response_time
|
|
|
|
seconds for the full response to arrive before we bail out */
|
|
|
|
timeout = ftp->response_time -
|
|
|
|
Curl_tvdiff(Curl_tvnow(), now)/1000; /* spent time */
|
|
|
|
|
|
|
|
if(timeout <=0 ) {
|
2004-03-05 04:37:48 -05:00
|
|
|
failf(data, "FTP response timeout");
|
2002-12-03 05:25:31 -05:00
|
|
|
return CURLE_OPERATION_TIMEDOUT; /* already too little time */
|
2002-04-27 09:24:06 -04:00
|
|
|
}
|
|
|
|
|
2002-04-27 09:09:37 -04:00
|
|
|
if(!ftp->cache) {
|
|
|
|
readfd = rkeepfd; /* set every lap */
|
2003-05-14 02:31:00 -04:00
|
|
|
interval.tv_sec = 1; /* use 1 second timeout intervals */
|
2002-04-27 09:09:37 -04:00
|
|
|
interval.tv_usec = 0;
|
2001-04-26 06:29:24 -04:00
|
|
|
|
2001-12-03 08:48:59 -05:00
|
|
|
switch (select (sockfd+1, &readfd, NULL, NULL, &interval)) {
|
|
|
|
case -1: /* select() error, stop reading */
|
2002-12-03 05:25:31 -05:00
|
|
|
result = CURLE_RECV_ERROR;
|
2004-03-05 04:37:48 -05:00
|
|
|
failf(data, "FTP response aborted due to select() error: %d", errno);
|
2001-12-03 08:48:59 -05:00
|
|
|
break;
|
|
|
|
case 0: /* timeout */
|
2003-05-14 02:31:00 -04:00
|
|
|
if(Curl_pgrsUpdate(conn))
|
|
|
|
return CURLE_ABORTED_BY_CALLBACK;
|
|
|
|
continue; /* just continue in our loop for the timeout duration */
|
|
|
|
|
2001-12-03 08:48:59 -05:00
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2002-04-27 09:09:37 -04:00
|
|
|
}
|
2002-12-03 05:25:31 -05:00
|
|
|
if(CURLE_OK == result) {
|
2001-04-26 06:29:24 -04:00
|
|
|
/*
|
|
|
|
* This code previously didn't use the kerberos sec_read() code
|
|
|
|
* to read, but when we use Curl_read() it may do so. Do confirm
|
|
|
|
* that this is still ok and then remove this comment!
|
|
|
|
*/
|
2001-12-03 08:48:59 -05:00
|
|
|
if(ftp->cache) {
|
|
|
|
/* we had data in the "cache", copy that instead of doing an actual
|
2004-01-05 17:29:29 -05:00
|
|
|
* read
|
|
|
|
*
|
|
|
|
* Dave Meyer, December 2003:
|
|
|
|
* ftp->cache_size is cast to int here. This should be safe,
|
|
|
|
* because it would have been populated with something of size
|
|
|
|
* int to begin with, even though its datatype may be larger
|
|
|
|
* than an int.
|
|
|
|
*/
|
|
|
|
memcpy(ptr, ftp->cache, (int)ftp->cache_size);
|
|
|
|
gotbytes = (int)ftp->cache_size;
|
2001-12-03 08:48:59 -05:00
|
|
|
free(ftp->cache); /* free the cache */
|
|
|
|
ftp->cache = NULL; /* clear the pointer */
|
|
|
|
ftp->cache_size = 0; /* zero the size just in case */
|
|
|
|
}
|
2002-01-14 18:14:59 -05:00
|
|
|
else {
|
2002-12-04 03:56:55 -05:00
|
|
|
int res = Curl_read(conn, sockfd, ptr, BUFSIZE-*nreadp, &gotbytes);
|
2002-01-14 18:14:59 -05:00
|
|
|
if(res < 0)
|
|
|
|
/* EWOULDBLOCK */
|
|
|
|
continue; /* go looping again */
|
|
|
|
|
|
|
|
if(CURLE_OK != res)
|
|
|
|
keepon = FALSE;
|
|
|
|
}
|
2001-12-03 08:48:59 -05:00
|
|
|
|
|
|
|
if(!keepon)
|
|
|
|
;
|
2001-04-26 06:29:24 -04:00
|
|
|
else if(gotbytes <= 0) {
|
|
|
|
keepon = FALSE;
|
2002-12-03 05:25:31 -05:00
|
|
|
result = CURLE_RECV_ERROR;
|
2003-12-08 08:06:08 -05:00
|
|
|
failf(data, "FTP response reading failed");
|
2001-04-26 06:29:24 -04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* we got a whole chunk of data, which can be anything from one
|
|
|
|
* byte to a set of lines and possible just a piece of the last
|
|
|
|
* line */
|
|
|
|
int i;
|
|
|
|
|
2004-04-21 04:47:57 -04:00
|
|
|
conn->headerbytecount += gotbytes;
|
|
|
|
|
2002-12-04 03:56:55 -05:00
|
|
|
*nreadp += gotbytes;
|
2001-09-04 22:49:04 -04:00
|
|
|
for(i = 0; i < gotbytes; ptr++, i++) {
|
2001-04-26 06:29:24 -04:00
|
|
|
perline++;
|
|
|
|
if(*ptr=='\n') {
|
|
|
|
/* a newline is CRLF in ftp-talk, so the CR is ignored as
|
|
|
|
the line isn't really terminated until the LF comes */
|
|
|
|
|
|
|
|
/* output debug output if that is requested */
|
2002-04-12 03:21:11 -04:00
|
|
|
if(data->set.verbose)
|
2004-06-03 07:41:05 -04:00
|
|
|
Curl_debug(data, CURLINFO_HEADER_IN, line_start, perline, conn->host.dispname);
|
2001-04-26 06:29:24 -04:00
|
|
|
|
2002-01-04 04:03:11 -05:00
|
|
|
/*
|
|
|
|
* We pass all response-lines to the callback function registered
|
|
|
|
* for "headers". The response lines can be seen as a kind of
|
|
|
|
* headers.
|
|
|
|
*/
|
|
|
|
result = Curl_client_write(data, CLIENTWRITE_HEADER,
|
|
|
|
line_start, perline);
|
|
|
|
if(result)
|
2002-12-03 05:25:31 -05:00
|
|
|
return result;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-08-23 02:10:01 -04:00
|
|
|
#define lastline(line) (isdigit((int)line[0]) && isdigit((int)line[1]) && \
|
|
|
|
isdigit((int)line[2]) && (' ' == line[3]))
|
|
|
|
|
2001-04-26 06:29:24 -04:00
|
|
|
if(perline>3 && lastline(line_start)) {
|
|
|
|
/* This is the end of the last line, copy the last
|
|
|
|
* line to the start of the buffer and zero terminate,
|
|
|
|
* for old times sake (and krb4)! */
|
2001-08-17 22:42:23 -04:00
|
|
|
char *meow;
|
2001-12-03 08:48:59 -05:00
|
|
|
int n;
|
|
|
|
for(meow=line_start, n=0; meow<ptr; meow++, n++)
|
|
|
|
buf[n] = *meow;
|
2001-11-22 04:40:34 -05:00
|
|
|
*meow=0; /* zero terminate */
|
2001-04-26 06:29:24 -04:00
|
|
|
keepon=FALSE;
|
2001-12-03 08:48:59 -05:00
|
|
|
line_start = ptr+1; /* advance pointer */
|
|
|
|
i++; /* skip this before getting out */
|
2001-04-26 06:29:24 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
perline=0; /* line starts over here */
|
|
|
|
line_start = ptr+1;
|
|
|
|
}
|
|
|
|
}
|
2001-12-03 08:48:59 -05:00
|
|
|
if(!keepon && (i != gotbytes)) {
|
|
|
|
/* We found the end of the response lines, but we didn't parse the
|
|
|
|
full chunk of data we have read from the server. We therefore
|
|
|
|
need to store the rest of the data to be checked on the next
|
|
|
|
invoke as it may actually contain another end of response
|
|
|
|
already! Cleverly figured out by Eric Lavigne in December
|
|
|
|
2001. */
|
|
|
|
ftp->cache_size = gotbytes - i;
|
2004-01-05 17:29:29 -05:00
|
|
|
ftp->cache = (char *)malloc((int)ftp->cache_size);
|
2001-12-03 08:48:59 -05:00
|
|
|
if(ftp->cache)
|
2004-01-05 17:29:29 -05:00
|
|
|
memcpy(ftp->cache, line_start, (int)ftp->cache_size);
|
2001-12-03 08:48:59 -05:00
|
|
|
else
|
2002-12-03 05:25:31 -05:00
|
|
|
return CURLE_OUT_OF_MEMORY; /**BANG**/
|
2001-12-03 08:48:59 -05:00
|
|
|
}
|
|
|
|
} /* there was data */
|
|
|
|
} /* if(no error) */
|
2001-04-26 06:29:24 -04:00
|
|
|
} /* while there's buffer left and loop is requested */
|
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
if(!result)
|
2001-04-26 06:29:24 -04:00
|
|
|
code = atoi(buf);
|
|
|
|
|
2003-12-02 08:27:29 -05:00
|
|
|
#ifdef HAVE_KRB4
|
2001-04-26 06:29:24 -04:00
|
|
|
/* handle the security-oriented responses 6xx ***/
|
|
|
|
/* FIXME: some errorchecking perhaps... ***/
|
|
|
|
switch(code) {
|
|
|
|
case 631:
|
2001-08-17 06:14:06 -04:00
|
|
|
Curl_sec_read_msg(conn, buf, prot_safe);
|
2001-04-26 06:29:24 -04:00
|
|
|
break;
|
|
|
|
case 632:
|
2001-08-17 06:14:06 -04:00
|
|
|
Curl_sec_read_msg(conn, buf, prot_private);
|
2001-04-26 06:29:24 -04:00
|
|
|
break;
|
|
|
|
case 633:
|
2001-08-17 06:14:06 -04:00
|
|
|
Curl_sec_read_msg(conn, buf, prot_confidential);
|
2001-04-26 06:29:24 -04:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
/* normal ftp stuff we pass through! */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
if(ftpcode)
|
|
|
|
*ftpcode=code; /* return the initial number like this */
|
|
|
|
|
2003-08-20 11:41:45 -04:00
|
|
|
/* store the latest code for later retrieval */
|
|
|
|
conn->data->info.httpcode=code;
|
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
return result;
|
2001-04-26 06:29:24 -04:00
|
|
|
}
|
|
|
|
|
2003-12-02 08:40:12 -05:00
|
|
|
static const char *ftpauth[]= {
|
2003-12-02 08:21:53 -05:00
|
|
|
"SSL", "TLS", NULL
|
|
|
|
};
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
/*
|
|
|
|
* Curl_ftp_connect() should do everything that is to be considered a part of
|
|
|
|
* the connection phase.
|
|
|
|
*/
|
2001-01-05 05:11:41 -05:00
|
|
|
CURLcode Curl_ftp_connect(struct connectdata *conn)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
|
|
|
/* this is FTP and no proxy */
|
2003-03-11 13:58:21 -05:00
|
|
|
ssize_t nread;
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data=conn->data;
|
|
|
|
char *buf = data->state.buffer; /* this is our buffer */
|
2000-05-22 10:12:12 -04:00
|
|
|
struct FTP *ftp;
|
2000-09-14 10:05:01 -04:00
|
|
|
CURLcode result;
|
2003-12-02 08:21:53 -05:00
|
|
|
int ftpcode, try;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
ftp = (struct FTP *)malloc(sizeof(struct FTP));
|
|
|
|
if(!ftp)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
|
|
|
|
memset(ftp, 0, sizeof(struct FTP));
|
2001-02-20 12:35:51 -05:00
|
|
|
conn->proto.ftp = ftp;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2001-03-05 08:40:08 -05:00
|
|
|
/* We always support persistant connections on ftp */
|
|
|
|
conn->bits.close = FALSE;
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
/* get some initial data into the ftp struct */
|
|
|
|
ftp->bytecountp = &conn->bytecount;
|
2001-03-02 02:44:05 -05:00
|
|
|
|
2003-07-19 19:56:33 -04:00
|
|
|
/* no need to duplicate them, this connectdata struct won't change */
|
|
|
|
ftp->user = conn->user;
|
|
|
|
ftp->passwd = conn->passwd;
|
2002-12-04 03:56:55 -05:00
|
|
|
ftp->response_time = 3600; /* set default response time-out */
|
2002-12-03 05:25:31 -05:00
|
|
|
|
2004-06-09 04:23:55 -04:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2004-05-26 04:54:36 -04:00
|
|
|
if (conn->bits.tunnel_proxy) {
|
2000-09-14 10:05:01 -04:00
|
|
|
/* We want "seamless" FTP operations through HTTP proxy tunnel */
|
2003-11-24 02:15:37 -05:00
|
|
|
result = Curl_ConnectHTTPProxyTunnel(conn, FIRSTSOCKET,
|
2004-04-27 09:56:23 -04:00
|
|
|
conn->host.name, conn->remote_port);
|
2000-09-14 10:05:01 -04:00
|
|
|
if(CURLE_OK != result)
|
|
|
|
return result;
|
|
|
|
}
|
2004-06-09 04:23:55 -04:00
|
|
|
#endif /* CURL_DISABLE_HTTP */
|
2000-09-14 10:05:01 -04:00
|
|
|
|
2001-03-29 03:16:55 -05:00
|
|
|
if(conn->protocol & PROT_FTPS) {
|
|
|
|
/* FTPS is simply ftp with SSL for the control channel */
|
|
|
|
/* now, perform the SSL initialization for this socket */
|
2003-11-24 02:15:37 -05:00
|
|
|
result = Curl_SSLConnect(conn, FIRSTSOCKET);
|
2001-05-12 05:30:42 -04:00
|
|
|
if(result)
|
|
|
|
return result;
|
2001-03-29 03:16:55 -05:00
|
|
|
}
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* The first thing we do is wait for the "220*" line: */
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2000-11-22 07:50:41 -05:00
|
|
|
|
|
|
|
if(ftpcode != 220) {
|
1999-12-29 09:20:26 -05:00
|
|
|
failf(data, "This doesn't seem like a nice ftp-server response");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_WEIRD_SERVER_REPLY;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2003-12-02 08:27:29 -05:00
|
|
|
#ifdef HAVE_KRB4
|
2000-09-21 04:47:20 -04:00
|
|
|
/* if not anonymous login, try a secure login */
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.krb4) {
|
2000-09-21 04:47:20 -04:00
|
|
|
|
|
|
|
/* request data protection level (default is 'clear') */
|
2001-08-17 06:14:06 -04:00
|
|
|
Curl_sec_request_prot(conn, "private");
|
2000-09-21 04:47:20 -04:00
|
|
|
|
|
|
|
/* We set private first as default, in case the line below fails to
|
|
|
|
set a valid level */
|
2001-08-30 18:48:34 -04:00
|
|
|
Curl_sec_request_prot(conn, data->set.krb4_level);
|
2000-09-21 04:47:20 -04:00
|
|
|
|
2001-08-17 06:14:06 -04:00
|
|
|
if(Curl_sec_login(conn) != 0)
|
2000-09-21 04:47:20 -04:00
|
|
|
infof(data, "Logging in with password in cleartext!\n");
|
|
|
|
else
|
|
|
|
infof(data, "Authentication successful\n");
|
|
|
|
}
|
|
|
|
#endif
|
2003-11-24 02:15:37 -05:00
|
|
|
|
|
|
|
if(data->set.ftp_ssl && !conn->ssl[FIRSTSOCKET].use) {
|
2003-12-02 08:21:53 -05:00
|
|
|
/* we don't have a SSL/TLS connection, try a FTPS connection now */
|
2003-11-24 02:15:37 -05:00
|
|
|
|
2003-12-02 08:21:53 -05:00
|
|
|
for (try = 0; ftpauth[try]; try++) {
|
2003-11-24 02:15:37 -05:00
|
|
|
|
2003-12-02 08:21:53 -05:00
|
|
|
FTPSENDF(conn, "AUTH %s", ftpauth[try]);
|
|
|
|
|
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
2003-11-24 02:15:37 -05:00
|
|
|
|
|
|
|
if(result)
|
|
|
|
return result;
|
2003-12-02 08:21:53 -05:00
|
|
|
|
|
|
|
/* RFC2228 (page 5) says:
|
|
|
|
*
|
|
|
|
* If the server is willing to accept the named security mechanism, and
|
|
|
|
* does not require any security data, it must respond with reply code
|
|
|
|
* 234/334.
|
|
|
|
*/
|
|
|
|
|
|
|
|
if((ftpcode == 234) || (ftpcode == 334)) {
|
|
|
|
result = Curl_SSLConnect(conn, FIRSTSOCKET);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
conn->protocol |= PROT_FTPS;
|
|
|
|
conn->ssl[SECONDARYSOCKET].use = FALSE; /* clear-text data */
|
|
|
|
break;
|
|
|
|
}
|
2003-11-24 02:15:37 -05:00
|
|
|
}
|
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* send USER */
|
2003-10-17 05:26:28 -04:00
|
|
|
FTPSENDF(conn, "USER %s", ftp->user?ftp->user:"");
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* wait for feedback */
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-11-22 07:50:41 -05:00
|
|
|
if(ftpcode == 530) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* 530 User ... access denied
|
|
|
|
(the server denies to log the specified user) */
|
|
|
|
failf(data, "Access denied: %s", &buf[4]);
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_ACCESS_DENIED;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2000-11-22 07:50:41 -05:00
|
|
|
else if(ftpcode == 331) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* 331 Password required for ...
|
|
|
|
(the server requires to send the user's password too) */
|
2003-10-17 05:26:28 -04:00
|
|
|
FTPSENDF(conn, "PASS %s", ftp->passwd?ftp->passwd:"");
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-11-22 07:50:41 -05:00
|
|
|
if(ftpcode == 530) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* 530 Login incorrect.
|
|
|
|
(the username and/or the password are incorrect) */
|
|
|
|
failf(data, "the username and/or the password are incorrect");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_USER_PASSWORD_INCORRECT;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2000-11-22 07:50:41 -05:00
|
|
|
else if(ftpcode == 230) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* 230 User ... logged in.
|
|
|
|
(user successfully logged in) */
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
infof(data, "We have successfully logged in\n");
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
failf(data, "Odd return code after PASS");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_WEIRD_PASS_REPLY;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
2000-11-22 07:50:41 -05:00
|
|
|
else if(buf[0] == '2') {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* 230 User ... logged in.
|
|
|
|
(the user logged in without password) */
|
|
|
|
infof(data, "We have successfully logged in\n");
|
2003-12-02 08:21:53 -05:00
|
|
|
if (conn->ssl[FIRSTSOCKET].use) {
|
2003-12-02 08:27:29 -05:00
|
|
|
#ifdef HAVE_KRB4
|
2004-04-22 09:09:00 -04:00
|
|
|
/* We are logged in with Kerberos, now set the requested protection
|
|
|
|
* level
|
|
|
|
*/
|
|
|
|
if(conn->sec_complete)
|
|
|
|
Curl_sec_set_protection_level(conn);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2004-04-22 09:09:00 -04:00
|
|
|
/* We may need to issue a KAUTH here to have access to the files
|
|
|
|
* do it if user supplied a password
|
|
|
|
*/
|
|
|
|
if(conn->passwd && *conn->passwd) {
|
|
|
|
result = Curl_krb_kauth(conn);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
2000-09-21 04:47:20 -04:00
|
|
|
#endif
|
2004-04-22 09:09:00 -04:00
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
failf(data, "Odd return code after USER");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_WEIRD_USER_REPLY;
|
|
|
|
}
|
|
|
|
|
2003-12-01 05:14:39 -05:00
|
|
|
if(conn->ssl[FIRSTSOCKET].use) {
|
|
|
|
/* PBSZ = PROTECTION BUFFER SIZE.
|
|
|
|
|
|
|
|
The 'draft-murray-auth-ftp-ssl' (draft 12, page 7) says:
|
|
|
|
|
|
|
|
Specifically, the PROT command MUST be preceded by a PBSZ command
|
|
|
|
and a PBSZ command MUST be preceded by a successful security data
|
|
|
|
exchange (the TLS negotiation in this case)
|
|
|
|
|
|
|
|
... (and on page 8):
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2003-12-01 05:14:39 -05:00
|
|
|
Thus the PBSZ command must still be issued, but must have a parameter
|
|
|
|
of '0' to indicate that no buffering is taking place and the data
|
|
|
|
connection should not be encapsulated.
|
|
|
|
*/
|
|
|
|
FTPSENDF(conn, "PBSZ %d", 0);
|
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
/* For TLS, the data connection can have one of two security levels.
|
|
|
|
|
|
|
|
1)Clear (requested by 'PROT C')
|
|
|
|
|
|
|
|
2)Private (requested by 'PROT P')
|
|
|
|
*/
|
|
|
|
if(!conn->ssl[SECONDARYSOCKET].use) {
|
|
|
|
FTPSENDF(conn, "PROT %c", 'P');
|
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2003-12-01 05:14:39 -05:00
|
|
|
if(ftpcode == 200)
|
|
|
|
/* We have enabled SSL for the data connection! */
|
|
|
|
conn->ssl[SECONDARYSOCKET].use = TRUE;
|
|
|
|
|
|
|
|
/* FTP servers typically responds with 500 if they decide to reject
|
|
|
|
our 'P' request */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-03-02 02:44:05 -05:00
|
|
|
/* send PWD to discover our entry point */
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "PWD", NULL);
|
2001-03-02 02:44:05 -05:00
|
|
|
|
|
|
|
/* wait for feedback */
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2001-03-02 02:44:05 -05:00
|
|
|
|
|
|
|
if(ftpcode == 257) {
|
|
|
|
char *dir = (char *)malloc(nread+1);
|
|
|
|
char *store=dir;
|
|
|
|
char *ptr=&buf[4]; /* start on the first letter */
|
2003-10-24 08:58:59 -04:00
|
|
|
|
|
|
|
if(!dir)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-03-02 02:44:05 -05:00
|
|
|
/* Reply format is like
|
|
|
|
257<space>"<directory-name>"<space><commentary> and the RFC959 says
|
|
|
|
|
|
|
|
The directory name can contain any character; embedded double-quotes
|
|
|
|
should be escaped by double-quotes (the "quote-doubling" convention).
|
|
|
|
*/
|
2003-10-24 08:58:59 -04:00
|
|
|
if('\"' == *ptr) {
|
2001-03-02 02:44:05 -05:00
|
|
|
/* it started good */
|
|
|
|
ptr++;
|
|
|
|
while(ptr && *ptr) {
|
|
|
|
if('\"' == *ptr) {
|
|
|
|
if('\"' == ptr[1]) {
|
|
|
|
/* "quote-doubling" */
|
|
|
|
*store = ptr[1];
|
|
|
|
ptr++;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* end of path */
|
|
|
|
*store = '\0'; /* zero terminate */
|
|
|
|
break; /* get out of this loop */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
*store = *ptr;
|
|
|
|
store++;
|
|
|
|
ptr++;
|
|
|
|
}
|
|
|
|
ftp->entrypath =dir; /* remember this */
|
|
|
|
infof(data, "Entry path is '%s'\n", ftp->entrypath);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* couldn't get the path */
|
2002-12-02 02:18:24 -05:00
|
|
|
free(dir);
|
|
|
|
infof(data, "Failed to figure out path\n");
|
2001-03-02 02:44:05 -05:00
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* We couldn't read the PWD response! */
|
|
|
|
}
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Curl_ftp_done()
|
|
|
|
*
|
|
|
|
* The DONE function. This does what needs to be done after a single DO has
|
|
|
|
* performed.
|
|
|
|
*
|
|
|
|
* Input argument is already checked for validity.
|
|
|
|
*/
|
2004-05-12 08:06:39 -04:00
|
|
|
CURLcode Curl_ftp_done(struct connectdata *conn, CURLcode status)
|
2000-05-22 10:12:12 -04:00
|
|
|
{
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data = conn->data;
|
2001-02-20 12:35:51 -05:00
|
|
|
struct FTP *ftp = conn->proto.ftp;
|
2001-08-14 04:24:37 -04:00
|
|
|
ssize_t nread;
|
2000-11-22 07:50:41 -05:00
|
|
|
int ftpcode;
|
2001-11-13 07:09:05 -05:00
|
|
|
CURLcode result=CURLE_OK;
|
2004-05-12 08:06:39 -04:00
|
|
|
|
2004-04-22 09:09:00 -04:00
|
|
|
bool was_ctl_valid = ftp->ctl_valid;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2004-04-15 03:52:39 -04:00
|
|
|
/* free the dir tree and file parts */
|
2003-08-05 09:04:10 -04:00
|
|
|
freedirs(ftp);
|
|
|
|
|
2004-04-22 09:09:00 -04:00
|
|
|
ftp->ctl_valid = FALSE;
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.upload) {
|
2002-03-20 05:52:24 -05:00
|
|
|
if((-1 != data->set.infilesize) &&
|
|
|
|
(data->set.infilesize != *ftp->bytecountp) &&
|
|
|
|
!data->set.crlf) {
|
2004-03-02 04:31:18 -05:00
|
|
|
failf(data, "Uploaded unaligned file size (%" FORMAT_OFF_T
|
|
|
|
" out of %" FORMAT_OFF_T " bytes)",
|
2004-01-05 17:29:29 -05:00
|
|
|
*ftp->bytecountp, data->set.infilesize);
|
2003-11-19 09:36:42 -05:00
|
|
|
conn->bits.close = TRUE; /* close this connection since we don't
|
|
|
|
know what state this error leaves us in */
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_PARTIAL_FILE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
if((-1 != conn->size) && (conn->size != *ftp->bytecountp) &&
|
2001-02-22 18:32:02 -05:00
|
|
|
(conn->maxdownload != *ftp->bytecountp)) {
|
2004-03-02 04:31:18 -05:00
|
|
|
failf(data, "Received only partial file: %" FORMAT_OFF_T " bytes",
|
2004-01-05 17:29:29 -05:00
|
|
|
*ftp->bytecountp);
|
2003-11-19 09:36:42 -05:00
|
|
|
conn->bits.close = TRUE; /* close this connection since we don't
|
|
|
|
know what state this error leaves us in */
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_PARTIAL_FILE;
|
|
|
|
}
|
2002-06-13 05:21:08 -04:00
|
|
|
else if(!ftp->dont_check &&
|
|
|
|
!*ftp->bytecountp &&
|
|
|
|
(conn->size>0)) {
|
2001-11-12 17:27:05 -05:00
|
|
|
/* We consider this an error, but there's no true FTP error received
|
|
|
|
why we need to continue to "read out" the server response too.
|
|
|
|
We don't want to leave a "waiting" server reply if we'll get told
|
|
|
|
to make a second request on this same connection! */
|
2000-05-22 10:12:12 -04:00
|
|
|
failf(data, "No data was received!");
|
2001-11-12 17:27:05 -05:00
|
|
|
result = CURLE_FTP_COULDNT_RETR_FILE;
|
2000-05-22 10:12:12 -04:00
|
|
|
}
|
|
|
|
}
|
2004-05-12 08:06:39 -04:00
|
|
|
|
|
|
|
switch(status) {
|
|
|
|
case CURLE_BAD_DOWNLOAD_RESUME:
|
|
|
|
case CURLE_FTP_WEIRD_PASV_REPLY:
|
|
|
|
case CURLE_FTP_PORT_FAILED:
|
|
|
|
case CURLE_FTP_COULDNT_SET_BINARY:
|
|
|
|
case CURLE_FTP_COULDNT_RETR_FILE:
|
|
|
|
case CURLE_FTP_ACCESS_DENIED:
|
|
|
|
/* the connection stays alive fine even though this happened */
|
|
|
|
/* fall-through */
|
|
|
|
case CURLE_OK: /* doesn't affect the control connection's status */
|
|
|
|
ftp->ctl_valid = was_ctl_valid;
|
|
|
|
break;
|
|
|
|
default: /* by default, an error means the control connection is
|
|
|
|
wedged and should not be used anymore */
|
|
|
|
ftp->ctl_valid = FALSE;
|
|
|
|
break;
|
|
|
|
}
|
2001-05-11 07:38:13 -04:00
|
|
|
|
2003-12-02 08:27:29 -05:00
|
|
|
#ifdef HAVE_KRB4
|
2003-11-24 04:04:09 -05:00
|
|
|
Curl_sec_fflush_fd(conn, conn->sock[SECONDARYSOCKET]);
|
2000-09-25 18:15:28 -04:00
|
|
|
#endif
|
2000-05-22 10:12:12 -04:00
|
|
|
/* shut down the socket to inform the server we're done */
|
2003-11-24 02:15:37 -05:00
|
|
|
sclose(conn->sock[SECONDARYSOCKET]);
|
2004-03-11 08:13:35 -05:00
|
|
|
conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2004-05-12 08:06:39 -04:00
|
|
|
if(!ftp->no_transfer && !status) {
|
2002-12-04 03:56:55 -05:00
|
|
|
/* Let's see what the server says about the transfer we just performed,
|
2004-05-12 08:06:39 -04:00
|
|
|
* but lower the timeout as sometimes this connection has died while the
|
|
|
|
* data has been transfered. This happens when doing through NATs etc that
|
|
|
|
* abandon old silent connections.
|
|
|
|
*/
|
2002-12-04 03:56:55 -05:00
|
|
|
ftp->response_time = 60; /* give it only a minute for now */
|
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
2002-12-04 03:56:55 -05:00
|
|
|
|
|
|
|
ftp->response_time = 3600; /* set this back to one hour waits */
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2002-12-04 03:56:55 -05:00
|
|
|
if(!nread && (CURLE_OPERATION_TIMEDOUT == result)) {
|
|
|
|
failf(data, "control connection looks dead");
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
if(result)
|
|
|
|
return result;
|
2000-08-31 08:04:55 -04:00
|
|
|
|
2002-06-14 02:57:00 -04:00
|
|
|
if(!ftp->dont_check) {
|
|
|
|
/* 226 Transfer complete, 250 Requested file action okay, completed. */
|
|
|
|
if((ftpcode != 226) && (ftpcode != 250)) {
|
|
|
|
failf(data, "server did not report OK, got %d", ftpcode);
|
|
|
|
return CURLE_FTP_WRITE_ERROR;
|
|
|
|
}
|
2000-08-31 08:04:55 -04:00
|
|
|
}
|
2000-05-22 10:12:12 -04:00
|
|
|
}
|
|
|
|
|
2002-06-14 02:57:00 -04:00
|
|
|
/* clear these for next connection */
|
|
|
|
ftp->no_transfer = FALSE;
|
2004-06-03 07:41:05 -04:00
|
|
|
ftp->dont_check = FALSE;
|
|
|
|
|
|
|
|
if (!result && conn->sec_conn) { /* 3rd party transfer */
|
|
|
|
/* "done" with the secondary connection */
|
|
|
|
result = Curl_ftp_done(conn->sec_conn, status);
|
|
|
|
}
|
2001-05-11 07:38:13 -04:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
/* Send any post-transfer QUOTE strings? */
|
2004-06-03 07:41:05 -04:00
|
|
|
if(!status && !result && data->set.postquote)
|
2001-11-12 17:27:05 -05:00
|
|
|
result = ftp_sendquote(conn, data->set.postquote);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-11-12 17:27:05 -05:00
|
|
|
return result;
|
2000-05-22 10:12:12 -04:00
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_sendquote()
|
|
|
|
*
|
|
|
|
* Where a 'quote' means a list of custom commands to send to the server.
|
|
|
|
* The quote list is passed as an argument.
|
|
|
|
*/
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2004-06-03 07:41:05 -04:00
|
|
|
static
|
2001-09-28 04:58:18 -04:00
|
|
|
CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote)
|
2001-08-15 02:52:42 -04:00
|
|
|
{
|
|
|
|
struct curl_slist *item;
|
2001-10-31 09:56:12 -05:00
|
|
|
ssize_t nread;
|
|
|
|
int ftpcode;
|
|
|
|
CURLcode result;
|
2001-08-15 02:52:42 -04:00
|
|
|
|
|
|
|
item = quote;
|
|
|
|
while (item) {
|
|
|
|
if (item->data) {
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "%s", item->data);
|
2001-08-15 02:52:42 -04:00
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if (result)
|
|
|
|
return result;
|
2001-08-15 02:52:42 -04:00
|
|
|
|
|
|
|
if (ftpcode >= 400) {
|
|
|
|
failf(conn->data, "QUOT string not accepted: %s", item->data);
|
|
|
|
return CURLE_FTP_QUOTE_ERROR;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-15 08:26:34 -04:00
|
|
|
item = item->next;
|
2001-08-15 02:52:42 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_getfiletime()
|
|
|
|
*
|
|
|
|
* Get the timestamp of the given file.
|
|
|
|
*/
|
2001-08-23 02:10:01 -04:00
|
|
|
static
|
2001-09-28 04:58:18 -04:00
|
|
|
CURLcode ftp_getfiletime(struct connectdata *conn, char *file)
|
2001-08-23 02:10:01 -04:00
|
|
|
{
|
|
|
|
CURLcode result=CURLE_OK;
|
|
|
|
int ftpcode; /* for ftp status */
|
|
|
|
ssize_t nread;
|
2001-08-30 18:48:34 -04:00
|
|
|
char *buf = conn->data->state.buffer;
|
2001-08-23 02:10:01 -04:00
|
|
|
|
|
|
|
/* we have requested to get the modified-time of the file, this is yet
|
|
|
|
again a grey area as the MDTM is not kosher RFC959 */
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "MDTM %s", file);
|
2001-08-23 02:10:01 -04:00
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2001-08-23 02:10:01 -04:00
|
|
|
|
2003-01-07 06:25:44 -05:00
|
|
|
switch(ftpcode) {
|
|
|
|
case 213:
|
|
|
|
{
|
|
|
|
/* we got a time. Format should be: "YYYYMMDDHHMMSS[.sss]" where the
|
|
|
|
last .sss part is optional and means fractions of a second */
|
|
|
|
int year, month, day, hour, minute, second;
|
|
|
|
if(6 == sscanf(buf+4, "%04d%02d%02d%02d%02d%02d",
|
|
|
|
&year, &month, &day, &hour, &minute, &second)) {
|
|
|
|
/* we have a time, reformat it */
|
|
|
|
time_t secs=time(NULL);
|
2004-06-24 07:54:11 -04:00
|
|
|
snprintf(buf, sizeof(conn->data->state.buffer),
|
|
|
|
"%04d%02d%02d %02d:%02d:%02d GMT",
|
|
|
|
year, month, day, hour, minute, second);
|
2003-01-07 06:25:44 -05:00
|
|
|
/* now, convert this into a time() value: */
|
|
|
|
conn->data->info.filetime = curl_getdate(buf, &secs);
|
|
|
|
}
|
2001-08-23 02:10:01 -04:00
|
|
|
}
|
2003-01-07 06:25:44 -05:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
infof(conn->data, "unsupported MDTM reply format\n");
|
|
|
|
break;
|
|
|
|
case 550: /* "No such file or directory" */
|
|
|
|
failf(conn->data, "Given file does not exist");
|
|
|
|
result = CURLE_FTP_COULDNT_RETR_FILE;
|
|
|
|
break;
|
2001-08-23 02:10:01 -04:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_transfertype()
|
|
|
|
*
|
|
|
|
* Set transfer type. We only deal with ASCII or BINARY so this function
|
|
|
|
* sets one of them.
|
|
|
|
*/
|
2001-09-28 04:58:18 -04:00
|
|
|
static CURLcode ftp_transfertype(struct connectdata *conn,
|
2001-08-23 02:10:01 -04:00
|
|
|
bool ascii)
|
|
|
|
{
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data = conn->data;
|
2001-08-23 02:10:01 -04:00
|
|
|
int ftpcode;
|
|
|
|
ssize_t nread;
|
2001-10-31 09:56:12 -05:00
|
|
|
CURLcode result;
|
2001-08-23 02:10:01 -04:00
|
|
|
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "TYPE %s", ascii?"A":"I");
|
2001-08-23 02:10:01 -04:00
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-08-23 02:10:01 -04:00
|
|
|
if(ftpcode != 200) {
|
|
|
|
failf(data, "Couldn't set %s mode",
|
|
|
|
ascii?"ASCII":"binary");
|
|
|
|
return ascii? CURLE_FTP_COULDNT_SET_ASCII:CURLE_FTP_COULDNT_SET_BINARY;
|
|
|
|
}
|
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_getsize()
|
|
|
|
*
|
|
|
|
* Returns the file size (in bytes) of the given remote file.
|
|
|
|
*/
|
|
|
|
|
2001-08-23 02:10:01 -04:00
|
|
|
static
|
2001-09-28 04:58:18 -04:00
|
|
|
CURLcode ftp_getsize(struct connectdata *conn, char *file,
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t *size)
|
2001-08-23 02:10:01 -04:00
|
|
|
{
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data = conn->data;
|
2001-08-23 02:10:01 -04:00
|
|
|
int ftpcode;
|
|
|
|
ssize_t nread;
|
2001-08-30 18:48:34 -04:00
|
|
|
char *buf=data->state.buffer;
|
2001-10-31 09:56:12 -05:00
|
|
|
CURLcode result;
|
2001-08-23 02:10:01 -04:00
|
|
|
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "SIZE %s", file);
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2001-08-23 02:10:01 -04:00
|
|
|
|
|
|
|
if(ftpcode == 213) {
|
|
|
|
/* get the size from the ascii string: */
|
2004-04-07 03:30:40 -04:00
|
|
|
*size = curlx_strtoofft(buf+4, NULL, 0);
|
2001-08-23 02:10:01 -04:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return CURLE_FTP_COULDNT_GET_SIZE;
|
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2001-09-28 03:46:39 -04:00
|
|
|
/***************************************************************************
|
|
|
|
*
|
|
|
|
* ftp_pasv_verbose()
|
|
|
|
*
|
|
|
|
* This function only outputs some informationals about this second connection
|
|
|
|
* when we've issued a PASV command before and thus we have connected to a
|
|
|
|
* possibly new IP address.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static void
|
|
|
|
ftp_pasv_verbose(struct connectdata *conn,
|
2004-06-24 03:43:48 -04:00
|
|
|
Curl_addrinfo *ai,
|
2001-09-28 04:58:18 -04:00
|
|
|
char *newhost, /* ascii version */
|
|
|
|
int port)
|
2001-09-28 03:46:39 -04:00
|
|
|
{
|
2004-06-24 03:43:48 -04:00
|
|
|
char buf[256];
|
|
|
|
Curl_printable_address(ai, buf, sizeof(buf));
|
|
|
|
infof(conn->data, "Connecting to %s (%s) port %d\n", newhost, buf, port);
|
2001-09-28 03:46:39 -04:00
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_use_port()
|
|
|
|
*
|
|
|
|
* Send the proper PORT command. PORT is the ftp client's way of telling the
|
|
|
|
* server that *WE* open a port that we listen on an awaits the server to
|
|
|
|
* connect to. This is the opposite of PASV.
|
2001-09-28 04:58:18 -04:00
|
|
|
*/
|
2001-08-23 02:10:01 -04:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
static
|
2001-09-28 04:58:18 -04:00
|
|
|
CURLcode ftp_use_port(struct connectdata *conn)
|
2000-05-22 10:12:12 -04:00
|
|
|
{
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data=conn->data;
|
2004-03-09 17:52:50 -05:00
|
|
|
curl_socket_t portsock= CURL_SOCKET_BAD;
|
2001-09-28 04:58:18 -04:00
|
|
|
ssize_t nread;
|
|
|
|
int ftpcode; /* receive FTP response codes in this */
|
2001-10-31 09:56:12 -05:00
|
|
|
CURLcode result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-02-05 18:04:44 -05:00
|
|
|
#ifdef ENABLE_IPV6
|
2001-09-28 04:58:18 -04:00
|
|
|
/******************************************************************
|
|
|
|
*
|
|
|
|
* Here's a piece of IPv6-specific code coming up
|
|
|
|
*
|
|
|
|
*/
|
2001-03-14 13:24:07 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
struct addrinfo hints, *res, *ai;
|
|
|
|
struct sockaddr_storage ss;
|
|
|
|
socklen_t sslen;
|
|
|
|
char hbuf[NI_MAXHOST];
|
|
|
|
|
|
|
|
struct sockaddr *sa=(struct sockaddr *)&ss;
|
|
|
|
unsigned char *ap;
|
|
|
|
unsigned char *pp;
|
2004-06-30 08:04:37 -04:00
|
|
|
char portmsgbuf[1024], tmp[1024];
|
2001-03-14 13:24:07 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
const char *mode[] = { "EPRT", "LPRT", "PORT", NULL };
|
|
|
|
char **modep;
|
2004-02-05 04:26:01 -05:00
|
|
|
int rc;
|
2004-03-24 17:45:37 -05:00
|
|
|
int error;
|
2001-02-05 18:04:44 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
/*
|
|
|
|
* we should use Curl_if2ip? given pickiness of recent ftpd,
|
|
|
|
* I believe we should use the same address as the control connection.
|
|
|
|
*/
|
|
|
|
sslen = sizeof(ss);
|
2004-02-05 04:26:01 -05:00
|
|
|
rc = getsockname(conn->sock[FIRSTSOCKET], (struct sockaddr *)&ss, &sslen);
|
|
|
|
if(rc < 0) {
|
|
|
|
failf(data, "getsockname() returned %d\n", rc);
|
2001-09-28 04:58:18 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
2004-02-05 04:26:01 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2004-02-05 04:26:01 -05:00
|
|
|
rc = getnameinfo((struct sockaddr *)&ss, sslen, hbuf, sizeof(hbuf), NULL, 0,
|
2004-03-10 10:24:56 -05:00
|
|
|
NIFLAGS);
|
2004-02-05 04:26:01 -05:00
|
|
|
if(rc) {
|
|
|
|
failf(data, "getnameinfo() returned %d\n", rc);
|
2001-09-28 04:58:18 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
2004-02-05 04:26:01 -05:00
|
|
|
}
|
2001-02-05 18:04:44 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
memset(&hints, 0, sizeof(hints));
|
|
|
|
hints.ai_family = sa->sa_family;
|
|
|
|
/*hints.ai_family = ss.ss_family;
|
2004-06-03 07:41:05 -04:00
|
|
|
this way can be used if sockaddr_storage is properly defined, as glibc
|
2001-09-28 04:58:18 -04:00
|
|
|
2.1.X doesn't do*/
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
hints.ai_flags = AI_PASSIVE;
|
2001-10-04 09:25:12 -04:00
|
|
|
|
2004-02-05 04:26:01 -05:00
|
|
|
rc = getaddrinfo(hbuf, NULL, &hints, &res);
|
|
|
|
if(rc) {
|
|
|
|
failf(data, "getaddrinfo() returned %d\n", rc);
|
2001-09-28 04:58:18 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
2004-02-05 04:26:01 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2004-03-09 17:52:50 -05:00
|
|
|
portsock = CURL_SOCKET_BAD;
|
2004-03-24 17:45:37 -05:00
|
|
|
error = 0;
|
2001-09-28 04:58:18 -04:00
|
|
|
for (ai = res; ai; ai = ai->ai_next) {
|
2004-02-09 02:52:36 -05:00
|
|
|
/*
|
|
|
|
* Workaround for AIX5 getaddrinfo() problem (it doesn't set ai_socktype):
|
|
|
|
*/
|
|
|
|
if (ai->ai_socktype == 0)
|
|
|
|
ai->ai_socktype = hints.ai_socktype;
|
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
portsock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
|
2004-03-24 17:45:37 -05:00
|
|
|
if (portsock == CURL_SOCKET_BAD) {
|
|
|
|
error = Curl_ourerrno();
|
2001-09-28 04:58:18 -04:00
|
|
|
continue;
|
2004-03-24 17:45:37 -05:00
|
|
|
}
|
2001-02-05 18:04:44 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (bind(portsock, ai->ai_addr, ai->ai_addrlen) < 0) {
|
2004-03-24 17:45:37 -05:00
|
|
|
error = Curl_ourerrno();
|
2001-09-28 04:58:18 -04:00
|
|
|
sclose(portsock);
|
2004-03-09 17:52:50 -05:00
|
|
|
portsock = CURL_SOCKET_BAD;
|
2001-09-28 04:58:18 -04:00
|
|
|
continue;
|
2001-02-05 18:04:44 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (listen(portsock, 1) < 0) {
|
2004-03-24 17:45:37 -05:00
|
|
|
error = Curl_ourerrno();
|
2001-09-28 04:58:18 -04:00
|
|
|
sclose(portsock);
|
2004-03-09 17:52:50 -05:00
|
|
|
portsock = CURL_SOCKET_BAD;
|
2001-09-28 04:58:18 -04:00
|
|
|
continue;
|
2001-02-05 18:04:44 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
break;
|
|
|
|
}
|
2001-10-04 09:25:12 -04:00
|
|
|
freeaddrinfo(res);
|
2004-03-09 17:52:50 -05:00
|
|
|
if (portsock == CURL_SOCKET_BAD) {
|
2004-03-24 17:45:37 -05:00
|
|
|
failf(data, "%s", Curl_strerror(conn,error));
|
2001-09-28 04:58:18 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
}
|
2001-02-05 18:04:44 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
sslen = sizeof(ss);
|
|
|
|
if (getsockname(portsock, sa, &sslen) < 0) {
|
2004-03-24 17:45:37 -05:00
|
|
|
failf(data, "%s", Curl_strerror(conn,Curl_ourerrno()));
|
2001-09-28 04:58:18 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
}
|
2001-02-05 18:04:44 -05:00
|
|
|
|
2003-05-09 03:39:29 -04:00
|
|
|
for (modep = (char **)(data->set.ftp_use_eprt?&mode[0]:&mode[2]);
|
|
|
|
modep && *modep; modep++) {
|
2001-09-28 04:58:18 -04:00
|
|
|
int lprtaf, eprtaf;
|
2002-10-28 14:20:59 -05:00
|
|
|
int alen=0, plen=0;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
switch (sa->sa_family) {
|
|
|
|
case AF_INET:
|
|
|
|
ap = (unsigned char *)&((struct sockaddr_in *)&ss)->sin_addr;
|
|
|
|
alen = sizeof(((struct sockaddr_in *)&ss)->sin_addr);
|
|
|
|
pp = (unsigned char *)&((struct sockaddr_in *)&ss)->sin_port;
|
|
|
|
plen = sizeof(((struct sockaddr_in *)&ss)->sin_port);
|
|
|
|
lprtaf = 4;
|
|
|
|
eprtaf = 1;
|
|
|
|
break;
|
|
|
|
case AF_INET6:
|
|
|
|
ap = (unsigned char *)&((struct sockaddr_in6 *)&ss)->sin6_addr;
|
|
|
|
alen = sizeof(((struct sockaddr_in6 *)&ss)->sin6_addr);
|
|
|
|
pp = (unsigned char *)&((struct sockaddr_in6 *)&ss)->sin6_port;
|
|
|
|
plen = sizeof(((struct sockaddr_in6 *)&ss)->sin6_port);
|
|
|
|
lprtaf = 6;
|
|
|
|
eprtaf = 2;
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
ap = pp = NULL;
|
|
|
|
lprtaf = eprtaf = -1;
|
|
|
|
break;
|
|
|
|
}
|
2001-02-05 18:04:44 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (strcmp(*modep, "EPRT") == 0) {
|
|
|
|
if (eprtaf < 0)
|
|
|
|
continue;
|
|
|
|
if (getnameinfo((struct sockaddr *)&ss, sslen,
|
2004-03-10 10:24:56 -05:00
|
|
|
portmsgbuf, sizeof(portmsgbuf), tmp, sizeof(tmp),
|
|
|
|
NIFLAGS))
|
2001-09-28 04:58:18 -04:00
|
|
|
continue;
|
2001-09-04 22:49:04 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
/* do not transmit IPv6 scope identifier to the wire */
|
|
|
|
if (sa->sa_family == AF_INET6) {
|
|
|
|
char *q = strchr(portmsgbuf, '%');
|
2004-03-24 17:45:37 -05:00
|
|
|
if (q)
|
|
|
|
*q = '\0';
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2001-09-04 22:49:04 -04:00
|
|
|
|
2001-10-31 15:59:24 -05:00
|
|
|
result = Curl_ftpsendf(conn, "%s |%d|%s|%s|", *modep, eprtaf,
|
|
|
|
portmsgbuf, tmp);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2004-03-24 17:45:37 -05:00
|
|
|
}
|
|
|
|
else if (strcmp(*modep, "LPRT") == 0 ||
|
|
|
|
strcmp(*modep, "PORT") == 0) {
|
2001-09-28 04:58:18 -04:00
|
|
|
int i;
|
2004-03-24 17:45:37 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (strcmp(*modep, "LPRT") == 0 && lprtaf < 0)
|
|
|
|
continue;
|
|
|
|
if (strcmp(*modep, "PORT") == 0 && sa->sa_family != AF_INET)
|
|
|
|
continue;
|
2001-02-05 18:04:44 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
portmsgbuf[0] = '\0';
|
|
|
|
if (strcmp(*modep, "LPRT") == 0) {
|
|
|
|
snprintf(tmp, sizeof(tmp), "%d,%d", lprtaf, alen);
|
|
|
|
if (strlcat(portmsgbuf, tmp, sizeof(portmsgbuf)) >=
|
|
|
|
sizeof(portmsgbuf)) {
|
2001-09-04 22:49:04 -04:00
|
|
|
continue;
|
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2001-09-04 22:49:04 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
for (i = 0; i < alen; i++) {
|
|
|
|
if (portmsgbuf[0])
|
|
|
|
snprintf(tmp, sizeof(tmp), ",%u", ap[i]);
|
|
|
|
else
|
|
|
|
snprintf(tmp, sizeof(tmp), "%u", ap[i]);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (strlcat(portmsgbuf, tmp, sizeof(portmsgbuf)) >=
|
|
|
|
sizeof(portmsgbuf)) {
|
|
|
|
continue;
|
2001-09-04 22:49:04 -04:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (strcmp(*modep, "LPRT") == 0) {
|
|
|
|
snprintf(tmp, sizeof(tmp), ",%d", plen);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (strlcat(portmsgbuf, tmp, sizeof(portmsgbuf)) >= sizeof(portmsgbuf))
|
|
|
|
continue;
|
|
|
|
}
|
2001-09-04 22:49:04 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
for (i = 0; i < plen; i++) {
|
|
|
|
snprintf(tmp, sizeof(tmp), ",%u", pp[i]);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (strlcat(portmsgbuf, tmp, sizeof(portmsgbuf)) >=
|
|
|
|
sizeof(portmsgbuf)) {
|
|
|
|
continue;
|
2001-09-04 22:49:04 -04:00
|
|
|
}
|
2001-02-05 18:04:44 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-10-31 15:59:24 -05:00
|
|
|
result = Curl_ftpsendf(conn, "%s %s", *modep, portmsgbuf);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2001-02-05 18:04:44 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (ftpcode != 200) {
|
|
|
|
continue;
|
2001-02-05 18:04:44 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (!*modep) {
|
|
|
|
sclose(portsock);
|
2003-05-23 07:14:09 -04:00
|
|
|
failf(data, "PORT command attempts failed");
|
2001-09-28 04:58:18 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
}
|
|
|
|
/* we set the secondary socket variable to this for now, it
|
|
|
|
is only so that the cleanup function will close it in case
|
|
|
|
we fail before the true secondary stuff is made */
|
2003-11-24 02:15:37 -05:00
|
|
|
conn->sock[SECONDARYSOCKET] = portsock;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-02-05 18:04:44 -05:00
|
|
|
#else
|
2001-09-28 04:58:18 -04:00
|
|
|
/******************************************************************
|
|
|
|
*
|
|
|
|
* Here's a piece of IPv4-specific code coming up
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
struct sockaddr_in sa;
|
|
|
|
unsigned short porttouse;
|
|
|
|
char myhost[256] = "";
|
2002-08-01 10:25:12 -04:00
|
|
|
bool sa_filled_in = FALSE;
|
2004-06-24 03:43:48 -04:00
|
|
|
Curl_addrinfo *addr = NULL;
|
|
|
|
unsigned short ip[4];
|
2001-09-28 04:58:18 -04:00
|
|
|
|
|
|
|
if(data->set.ftpport) {
|
2003-05-13 08:11:31 -04:00
|
|
|
in_addr_t in;
|
|
|
|
|
|
|
|
/* First check if the given name is an IP address */
|
|
|
|
in=inet_addr(data->set.ftpport);
|
|
|
|
|
2004-06-24 03:43:48 -04:00
|
|
|
if(in != CURL_INADDR_NONE)
|
|
|
|
/* this is an IPv4 address */
|
|
|
|
addr = Curl_ip2addr(in, data->set.ftpport, 0);
|
2001-09-28 04:58:18 -04:00
|
|
|
else {
|
2004-06-24 03:43:48 -04:00
|
|
|
if(Curl_if2ip(data->set.ftpport, myhost, sizeof(myhost))) {
|
|
|
|
/* The interface to IP conversion provided a dotted address */
|
|
|
|
in=inet_addr(myhost);
|
|
|
|
addr = Curl_ip2addr(in, myhost, 0);
|
|
|
|
}
|
|
|
|
else if(strlen(data->set.ftpport)> 1) {
|
|
|
|
/* might be a host name! */
|
|
|
|
struct Curl_dns_entry *h=NULL;
|
|
|
|
int rc = Curl_resolv(conn, myhost, 0, &h);
|
2004-04-26 10:18:00 -04:00
|
|
|
if(rc == CURLRESOLV_PENDING)
|
2003-08-05 10:40:59 -04:00
|
|
|
rc = Curl_wait_for_resolv(conn, &h);
|
2004-06-24 03:43:48 -04:00
|
|
|
if(h) {
|
|
|
|
addr = h->addr;
|
|
|
|
/* when we return from this function, we can forget about this entry
|
|
|
|
to we can unlock it now already */
|
|
|
|
Curl_resolv_unlock(data, h);
|
|
|
|
} /* (h) */
|
|
|
|
} /* strlen */
|
|
|
|
} /* CURL_INADDR_NONE */
|
|
|
|
} /* data->set.ftpport */
|
|
|
|
|
|
|
|
if(!addr) {
|
2002-08-01 10:25:12 -04:00
|
|
|
/* pick a suitable default here */
|
|
|
|
|
|
|
|
socklen_t sslen;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2002-08-01 10:25:12 -04:00
|
|
|
sslen = sizeof(sa);
|
2003-11-24 02:15:37 -05:00
|
|
|
if (getsockname(conn->sock[FIRSTSOCKET],
|
|
|
|
(struct sockaddr *)&sa, &sslen) < 0) {
|
2002-08-01 10:25:12 -04:00
|
|
|
failf(data, "getsockname() failed");
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
sa_filled_in = TRUE; /* the sa struct is filled in */
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2002-08-01 10:25:12 -04:00
|
|
|
|
2004-06-24 03:43:48 -04:00
|
|
|
if (addr || sa_filled_in) {
|
|
|
|
portsock = socket(AF_INET, SOCK_STREAM, 0);
|
|
|
|
if(CURL_SOCKET_BAD != portsock) {
|
2002-01-02 19:51:33 -05:00
|
|
|
int size;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
/* we set the secondary socket variable to this for now, it
|
|
|
|
is only so that the cleanup function will close it in case
|
|
|
|
we fail before the true secondary stuff is made */
|
2003-11-24 04:04:09 -05:00
|
|
|
conn->sock[SECONDARYSOCKET] = portsock;
|
2001-09-28 04:58:18 -04:00
|
|
|
|
2002-08-01 10:25:12 -04:00
|
|
|
if(!sa_filled_in) {
|
2004-06-24 03:43:48 -04:00
|
|
|
memcpy(&sa, addr->ai_addr, sizeof(sa));
|
2002-08-01 10:25:12 -04:00
|
|
|
sa.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
}
|
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
sa.sin_port = 0;
|
|
|
|
size = sizeof(sa);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if(bind(portsock, (struct sockaddr *)&sa, size) >= 0) {
|
|
|
|
/* we succeeded to bind */
|
|
|
|
struct sockaddr_in add;
|
2002-01-02 05:06:47 -05:00
|
|
|
socklen_t socksize = sizeof(add);
|
2001-09-28 04:58:18 -04:00
|
|
|
|
|
|
|
if(getsockname(portsock, (struct sockaddr *) &add,
|
2002-01-02 05:06:47 -05:00
|
|
|
&socksize)<0) {
|
2001-09-28 04:58:18 -04:00
|
|
|
failf(data, "getsockname() failed");
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
porttouse = ntohs(add.sin_port);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if ( listen(portsock, 1) < 0 ) {
|
|
|
|
failf(data, "listen(2) failed on socket");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2001-09-28 04:58:18 -04:00
|
|
|
failf(data, "bind(2) failed on socket");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
2001-09-28 04:58:18 -04:00
|
|
|
failf(data, "socket(2) failed (%s)");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
|
|
|
else {
|
2004-06-24 03:43:48 -04:00
|
|
|
failf(data, "could't find IP address to use");
|
2001-09-28 04:58:18 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
}
|
2004-06-24 03:43:48 -04:00
|
|
|
|
|
|
|
if(sa_filled_in)
|
|
|
|
Curl_inet_ntop(AF_INET, &((struct sockaddr_in *)&sa)->sin_addr,
|
|
|
|
myhost, sizeof(myhost));
|
|
|
|
else
|
|
|
|
Curl_printable_address(addr, myhost, sizeof(myhost));
|
|
|
|
|
|
|
|
if(4 == sscanf(myhost, "%hu.%hu.%hu.%hu",
|
|
|
|
&ip[0], &ip[1], &ip[2], &ip[3])) {
|
|
|
|
|
2002-08-01 10:25:12 -04:00
|
|
|
infof(data, "Telling server to connect to %d.%d.%d.%d:%d\n",
|
|
|
|
ip[0], ip[1], ip[2], ip[3], porttouse);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-10-31 09:56:12 -05:00
|
|
|
result=Curl_ftpsendf(conn, "PORT %d,%d,%d,%d,%d,%d",
|
|
|
|
ip[0], ip[1], ip[2], ip[3],
|
|
|
|
porttouse >> 8,
|
|
|
|
porttouse & 255);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2004-06-24 03:43:48 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2004-06-24 03:43:48 -04:00
|
|
|
else
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
|
|
|
|
Curl_freeaddrinfo(addr);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if(ftpcode != 200) {
|
|
|
|
failf(data, "Server does not grok PORT, try without it!");
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
#endif /* end of ipv4-specific code */
|
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_use_pasv()
|
|
|
|
*
|
|
|
|
* Send the PASV command. PASV is the ftp client's way of asking the server to
|
|
|
|
* open a second port that we can connect to (for the data transfer). This is
|
|
|
|
* the opposite of PORT.
|
2001-09-28 04:58:18 -04:00
|
|
|
*/
|
|
|
|
|
|
|
|
static
|
2002-08-12 05:43:20 -04:00
|
|
|
CURLcode ftp_use_pasv(struct connectdata *conn,
|
|
|
|
bool *connected)
|
2001-09-28 04:58:18 -04:00
|
|
|
{
|
|
|
|
struct SessionHandle *data = conn->data;
|
|
|
|
ssize_t nread;
|
|
|
|
char *buf = data->state.buffer; /* this is our buffer */
|
|
|
|
int ftpcode; /* receive FTP response codes in this */
|
|
|
|
CURLcode result;
|
2002-11-05 05:51:41 -05:00
|
|
|
struct Curl_dns_entry *addr=NULL;
|
2004-06-24 03:43:48 -04:00
|
|
|
Curl_addrinfo *conninfo;
|
2003-08-05 10:40:59 -04:00
|
|
|
int rc;
|
2001-11-26 19:48:45 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
Here's the excecutive summary on what to do:
|
|
|
|
|
|
|
|
PASV is RFC959, expect:
|
|
|
|
227 Entering Passive Mode (a1,a2,a3,a4,p1,p2)
|
|
|
|
|
|
|
|
LPSV is RFC1639, expect:
|
|
|
|
228 Entering Long Passive Mode (4,4,a1,a2,a3,a4,2,p1,p2)
|
|
|
|
|
|
|
|
EPSV is RFC2428, expect:
|
|
|
|
229 Entering Extended Passive Mode (|||port|)
|
|
|
|
|
|
|
|
*/
|
2001-09-28 04:58:18 -04:00
|
|
|
|
2001-11-28 08:05:39 -05:00
|
|
|
const char *mode[] = { "EPSV", "PASV", NULL };
|
|
|
|
int results[] = { 229, 227, 0 };
|
2001-09-28 04:58:18 -04:00
|
|
|
int modeoff;
|
2001-11-26 19:48:45 -05:00
|
|
|
unsigned short connectport; /* the local port connect() should use! */
|
2002-10-28 14:20:59 -05:00
|
|
|
unsigned short newport=0; /* remote port, not necessary the local one */
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-11-26 19:48:45 -05:00
|
|
|
/* newhost must be able to hold a full IP-style address in ASCII, which
|
|
|
|
in the IPv6 case means 5*8-1 = 39 letters */
|
|
|
|
char newhost[48];
|
2001-11-28 08:05:39 -05:00
|
|
|
char *newhostp=NULL;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-11-28 18:20:14 -05:00
|
|
|
for (modeoff = (data->set.ftp_use_epsv?0:1);
|
|
|
|
mode[modeoff]; modeoff++) {
|
2002-06-12 03:44:22 -04:00
|
|
|
result = Curl_ftpsendf(conn, "%s", mode[modeoff]);
|
2001-11-28 08:05:39 -05:00
|
|
|
if(result)
|
|
|
|
return result;
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2001-11-28 08:05:39 -05:00
|
|
|
if (ftpcode == results[modeoff])
|
|
|
|
break;
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2001-09-28 03:05:26 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (!mode[modeoff]) {
|
|
|
|
failf(data, "Odd return code after PASV");
|
|
|
|
return CURLE_FTP_WEIRD_PASV_REPLY;
|
|
|
|
}
|
2001-11-26 19:48:45 -05:00
|
|
|
else if (227 == results[modeoff]) {
|
2001-09-28 04:58:18 -04:00
|
|
|
int ip[4];
|
|
|
|
int port[2];
|
|
|
|
char *str=buf;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
/*
|
|
|
|
* New 227-parser June 3rd 1999.
|
|
|
|
* It now scans for a sequence of six comma-separated numbers and
|
|
|
|
* will take them as IP+port indicators.
|
|
|
|
*
|
|
|
|
* Found reply-strings include:
|
|
|
|
* "227 Entering Passive Mode (127,0,0,1,4,51)"
|
|
|
|
* "227 Data transfer will passively listen to 127,0,0,1,4,51"
|
|
|
|
* "227 Entering passive mode. 127,0,0,1,4,51"
|
|
|
|
*/
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
while(*str) {
|
|
|
|
if (6 == sscanf(str, "%d,%d,%d,%d,%d,%d",
|
|
|
|
&ip[0], &ip[1], &ip[2], &ip[3],
|
|
|
|
&port[0], &port[1]))
|
|
|
|
break;
|
|
|
|
str++;
|
|
|
|
}
|
2001-09-04 22:49:04 -04:00
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if(!*str) {
|
|
|
|
failf(data, "Couldn't interpret this 227-reply: %s", buf);
|
|
|
|
return CURLE_FTP_WEIRD_227_FORMAT;
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2004-06-24 07:54:11 -04:00
|
|
|
snprintf(newhost, sizeof(newhost),
|
|
|
|
"%d.%d.%d.%d", ip[0], ip[1], ip[2], ip[3]);
|
2001-11-28 08:05:39 -05:00
|
|
|
newhostp = newhost;
|
2001-09-28 04:58:18 -04:00
|
|
|
newport = (port[0]<<8) + port[1];
|
2001-11-26 19:48:45 -05:00
|
|
|
}
|
2001-11-26 19:50:52 -05:00
|
|
|
else if (229 == results[modeoff]) {
|
2001-11-26 19:48:45 -05:00
|
|
|
char *ptr = strchr(buf, '(');
|
|
|
|
if(ptr) {
|
|
|
|
unsigned int num;
|
|
|
|
char separator[4];
|
|
|
|
ptr++;
|
|
|
|
if(5 == sscanf(ptr, "%c%c%c%u%c",
|
|
|
|
&separator[0],
|
|
|
|
&separator[1],
|
|
|
|
&separator[2],
|
|
|
|
&num,
|
|
|
|
&separator[3])) {
|
2003-11-10 03:12:53 -05:00
|
|
|
char sep1 = separator[0];
|
|
|
|
int i;
|
2001-11-26 19:48:45 -05:00
|
|
|
|
2003-11-10 03:12:53 -05:00
|
|
|
/* The four separators should be identical, or else this is an oddly
|
|
|
|
formatted reply and we bail out immediately. */
|
|
|
|
for(i=1; i<4; i++) {
|
|
|
|
if(separator[i] != sep1) {
|
|
|
|
ptr=NULL; /* set to NULL to signal error */
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if(ptr) {
|
|
|
|
newport = num;
|
|
|
|
|
|
|
|
/* we should use the same host we already are connected to */
|
2004-04-27 09:56:23 -04:00
|
|
|
newhostp = conn->host.name;
|
2003-11-10 03:12:53 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
}
|
2001-11-26 19:48:45 -05:00
|
|
|
else
|
|
|
|
ptr=NULL;
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2001-11-26 19:48:45 -05:00
|
|
|
if(!ptr) {
|
|
|
|
failf(data, "Weirdly formatted EPSV reply");
|
|
|
|
return CURLE_FTP_WEIRD_PASV_REPLY;
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2001-11-26 19:48:45 -05:00
|
|
|
}
|
|
|
|
else
|
|
|
|
return CURLE_FTP_CANT_RECONNECT;
|
|
|
|
|
2003-09-11 18:05:23 -04:00
|
|
|
if(data->change.proxy && *data->change.proxy) {
|
2001-11-26 19:48:45 -05:00
|
|
|
/*
|
|
|
|
* This is a tunnel through a http proxy and we need to connect to the
|
2002-04-25 15:00:57 -04:00
|
|
|
* proxy again here.
|
|
|
|
*
|
|
|
|
* We don't want to rely on a former host lookup that might've expired
|
|
|
|
* now, instead we remake the lookup here and now!
|
2001-11-26 19:48:45 -05:00
|
|
|
*/
|
2004-07-04 17:35:12 -04:00
|
|
|
rc = Curl_resolv(conn, conn->proxy.name, (int)conn->port, &addr);
|
2004-04-26 10:18:00 -04:00
|
|
|
if(rc == CURLRESOLV_PENDING)
|
2003-08-05 10:40:59 -04:00
|
|
|
rc = Curl_wait_for_resolv(conn, &addr);
|
|
|
|
|
2001-11-26 19:48:45 -05:00
|
|
|
connectport =
|
2004-06-03 07:41:05 -04:00
|
|
|
(unsigned short)conn->port; /* we connect to the proxy's port */
|
2002-04-25 15:00:57 -04:00
|
|
|
|
2001-11-26 19:48:45 -05:00
|
|
|
}
|
2001-11-28 08:05:39 -05:00
|
|
|
else {
|
2001-11-26 19:48:45 -05:00
|
|
|
/* normal, direct, ftp connection */
|
2003-08-05 10:40:59 -04:00
|
|
|
rc = Curl_resolv(conn, newhostp, newport, &addr);
|
2004-04-26 10:18:00 -04:00
|
|
|
if(rc == CURLRESOLV_PENDING)
|
2003-08-05 10:40:59 -04:00
|
|
|
rc = Curl_wait_for_resolv(conn, &addr);
|
|
|
|
|
2001-11-26 19:48:45 -05:00
|
|
|
if(!addr) {
|
2002-03-20 05:52:24 -05:00
|
|
|
failf(data, "Can't resolve new host %s:%d", newhostp, newport);
|
2001-11-26 19:48:45 -05:00
|
|
|
return CURLE_FTP_CANT_GET_HOST;
|
|
|
|
}
|
|
|
|
connectport = newport; /* we connect to the remote port */
|
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-11-26 19:48:45 -05:00
|
|
|
result = Curl_connecthost(conn,
|
|
|
|
addr,
|
2003-11-24 02:15:37 -05:00
|
|
|
&conn->sock[SECONDARYSOCKET],
|
2002-08-12 05:43:20 -04:00
|
|
|
&conninfo,
|
|
|
|
connected);
|
|
|
|
|
2003-02-04 18:48:46 -05:00
|
|
|
Curl_resolv_unlock(data, addr); /* we're done using this address */
|
2002-11-05 05:51:41 -05:00
|
|
|
|
2003-09-03 17:44:59 -04:00
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
/*
|
|
|
|
* When this is used from the multi interface, this might've returned with
|
|
|
|
* the 'connected' set to FALSE and thus we are now awaiting a non-blocking
|
|
|
|
* connect to connect and we should not be "hanging" here waiting.
|
|
|
|
*/
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2003-09-03 17:44:59 -04:00
|
|
|
if(data->set.verbose)
|
2001-11-26 19:48:45 -05:00
|
|
|
/* this just dumps information about this second connection */
|
2002-03-20 05:52:24 -05:00
|
|
|
ftp_pasv_verbose(conn, conninfo, newhostp, connectport);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2004-06-09 04:23:55 -04:00
|
|
|
#ifndef CURL_DISABLE_HTTP
|
2004-05-26 04:54:36 -04:00
|
|
|
if(conn->bits.tunnel_proxy) {
|
2001-11-26 19:48:45 -05:00
|
|
|
/* We want "seamless" FTP operations through HTTP proxy tunnel */
|
2003-11-24 02:15:37 -05:00
|
|
|
result = Curl_ConnectHTTPProxyTunnel(conn, SECONDARYSOCKET,
|
2002-03-20 05:52:24 -05:00
|
|
|
newhostp, newport);
|
2001-10-02 05:40:06 -04:00
|
|
|
if(CURLE_OK != result)
|
|
|
|
return result;
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
2004-06-09 04:23:55 -04:00
|
|
|
#endif /* CURL_DISABLE_HTTP */
|
2001-09-28 04:58:18 -04:00
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
/*
|
|
|
|
* Curl_ftp_nextconnect()
|
2001-11-01 07:47:22 -05:00
|
|
|
*
|
2002-08-12 05:43:20 -04:00
|
|
|
* This function shall be called when the second FTP connection has been
|
|
|
|
* established and is confirmed connected.
|
2001-11-01 07:47:22 -05:00
|
|
|
*/
|
2001-09-28 04:58:18 -04:00
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
CURLcode Curl_ftp_nextconnect(struct connectdata *conn)
|
2001-09-28 04:58:18 -04:00
|
|
|
{
|
|
|
|
struct SessionHandle *data=conn->data;
|
|
|
|
char *buf = data->state.buffer; /* this is our buffer */
|
2002-08-12 05:43:20 -04:00
|
|
|
CURLcode result;
|
|
|
|
ssize_t nread;
|
|
|
|
int ftpcode; /* for ftp status */
|
2001-09-28 04:58:18 -04:00
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
/* the ftp struct is already inited in Curl_ftp_connect() */
|
2001-09-28 04:58:18 -04:00
|
|
|
struct FTP *ftp = conn->proto.ftp;
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t *bytecountp = ftp->bytecountp;
|
2001-09-28 04:58:18 -04:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.upload) {
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* Set type to binary (unless specified ASCII) */
|
2001-09-28 04:58:18 -04:00
|
|
|
result = ftp_transfertype(conn, data->set.ftp_ascii);
|
2001-08-23 02:10:01 -04:00
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2002-02-28 18:31:23 -05:00
|
|
|
/* Send any PREQUOTE strings after transfer type is set? (Wesley Laxton)*/
|
|
|
|
if(data->set.prequote) {
|
|
|
|
if ((result = ftp_sendquote(conn, data->set.prequote)) != CURLE_OK)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
if(conn->resume_from) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* we're about to continue the uploading of a file */
|
|
|
|
/* 1. get already existing file's size. We use the SIZE
|
|
|
|
command for this which may not exist in the server!
|
|
|
|
The SIZE command is not in RFC959. */
|
|
|
|
|
|
|
|
/* 2. This used to set REST. But since we can do append, we
|
|
|
|
don't another ftp command. We just skip the source file
|
|
|
|
offset and then we APPEND the rest on the file instead */
|
|
|
|
|
|
|
|
/* 3. pass file-size number of bytes in the source file */
|
|
|
|
/* 4. lower the infilesize counter */
|
|
|
|
/* => transfer as usual */
|
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
if(conn->resume_from < 0 ) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* we could've got a specified offset from the command line,
|
|
|
|
but now we know we didn't */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t gottensize;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-11-13 07:46:29 -05:00
|
|
|
if(CURLE_OK != ftp_getsize(conn, ftp->file, &gottensize)) {
|
2001-08-23 02:10:01 -04:00
|
|
|
failf(data, "Couldn't get remote file size");
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_COULDNT_GET_SIZE;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-11-13 07:46:29 -05:00
|
|
|
conn->resume_from = gottensize;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
if(conn->resume_from) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* do we still game? */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t passed=0;
|
1999-12-29 09:20:26 -05:00
|
|
|
/* enable append instead */
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.ftp_append = 1;
|
2000-11-29 03:19:23 -05:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Now, let's read off the proper amount of bytes from the
|
|
|
|
input. If we knew it was a proper file we could've just
|
|
|
|
fseek()ed but we only have a stream here */
|
|
|
|
do {
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t readthisamountnow = (conn->resume_from - passed);
|
|
|
|
curl_off_t actuallyread;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
if(readthisamountnow > BUFSIZE)
|
|
|
|
readthisamountnow = BUFSIZE;
|
|
|
|
|
|
|
|
actuallyread =
|
2004-01-05 17:29:29 -05:00
|
|
|
conn->fread(data->state.buffer, 1, (size_t)readthisamountnow,
|
2002-12-09 10:37:54 -05:00
|
|
|
conn->fread_in);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
passed += actuallyread;
|
|
|
|
if(actuallyread != readthisamountnow) {
|
2004-03-02 04:31:18 -05:00
|
|
|
failf(data, "Could only read %" FORMAT_OFF_T
|
|
|
|
" bytes from the input", passed);
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_COULDNT_USE_REST;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
2001-04-18 03:25:11 -04:00
|
|
|
while(passed != conn->resume_from);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* now, decrease the size of the read */
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.infilesize>0) {
|
|
|
|
data->set.infilesize -= conn->resume_from;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.infilesize <= 0) {
|
2001-05-11 07:38:13 -04:00
|
|
|
infof(data, "File already completely uploaded\n");
|
|
|
|
|
|
|
|
/* no data to transfer */
|
|
|
|
result=Curl_Transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2002-06-14 02:57:00 -04:00
|
|
|
/* Set no_transfer so that we won't get any error in
|
|
|
|
* Curl_ftp_done() because we didn't transfer anything! */
|
2004-06-03 07:41:05 -04:00
|
|
|
ftp->no_transfer = TRUE;
|
2001-05-11 07:38:13 -04:00
|
|
|
|
|
|
|
return CURLE_OK;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
/* we've passed, proceed as normal */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-12-09 10:37:54 -05:00
|
|
|
/* Send everything on data->state.in to the socket */
|
2001-10-31 09:56:12 -05:00
|
|
|
if(data->set.ftp_append) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* we append onto the file instead of rewriting it */
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "APPE %s", ftp->file);
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
FTPSENDF(conn, "STOR %s", ftp->file);
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-11-22 07:50:41 -05:00
|
|
|
if(ftpcode>=400) {
|
1999-12-29 09:20:26 -05:00
|
|
|
failf(data, "Failed FTP upload:%s", buf+3);
|
|
|
|
/* oops, we never close the sockets! */
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_COULDNT_STOR_FILE;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.ftp_use_port) {
|
2001-08-23 02:10:01 -04:00
|
|
|
/* PORT means we are now awaiting the server to connect to us. */
|
2003-11-24 02:15:37 -05:00
|
|
|
result = AllowServerConnect(conn);
|
1999-12-29 09:20:26 -05:00
|
|
|
if( result )
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2003-12-01 05:14:39 -05:00
|
|
|
if(conn->ssl[SECONDARYSOCKET].use) {
|
|
|
|
/* since we only have a plaintext TCP connection here, we must now
|
|
|
|
do the TLS stuff */
|
2003-12-02 08:21:53 -05:00
|
|
|
infof(data, "Doing the SSL/TLS handshake on the data stream\n");
|
2003-12-01 05:14:39 -05:00
|
|
|
result = Curl_SSLConnect(conn, SECONDARYSOCKET);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
*bytecountp=0;
|
|
|
|
|
|
|
|
/* When we know we're uploading a specified file, we can get the file
|
|
|
|
size prior to the actual upload. */
|
|
|
|
|
2004-03-10 11:20:33 -05:00
|
|
|
Curl_pgrsSetUploadSize(data, data->set.infilesize);
|
2000-11-29 03:19:23 -05:00
|
|
|
|
2001-01-17 08:23:01 -05:00
|
|
|
result = Curl_Transfer(conn, -1, -1, FALSE, NULL, /* no download */
|
2003-11-24 02:15:37 -05:00
|
|
|
SECONDARYSOCKET, bytecountp);
|
1999-12-29 09:20:26 -05:00
|
|
|
if(result)
|
|
|
|
return result;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2004-04-06 11:14:10 -04:00
|
|
|
else if(!conn->bits.no_body) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Retrieve file or directory */
|
|
|
|
bool dirlist=FALSE;
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t downloadsize=-1;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
if(conn->bits.use_range && conn->range) {
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t from, to;
|
|
|
|
curl_off_t totalsize=-1;
|
1999-12-29 09:20:26 -05:00
|
|
|
char *ptr;
|
|
|
|
char *ptr2;
|
|
|
|
|
2004-04-07 03:30:40 -04:00
|
|
|
from=curlx_strtoofft(conn->range, &ptr, 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
while(ptr && *ptr && (isspace((int)*ptr) || (*ptr=='-')))
|
|
|
|
ptr++;
|
2004-04-07 03:30:40 -04:00
|
|
|
to=curlx_strtoofft(ptr, &ptr2, 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
if(ptr == ptr2) {
|
|
|
|
/* we didn't get any digit */
|
|
|
|
to=-1;
|
|
|
|
}
|
2000-05-22 10:12:12 -04:00
|
|
|
if((-1 == to) && (from>=0)) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* X - */
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->resume_from = from;
|
2004-03-02 04:31:18 -05:00
|
|
|
infof(data, "FTP RANGE %" FORMAT_OFF_T " to end of file\n", from);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
else if(from < 0) {
|
|
|
|
/* -Y */
|
2000-05-22 10:12:12 -04:00
|
|
|
totalsize = -from;
|
2001-02-22 18:32:02 -05:00
|
|
|
conn->maxdownload = -from;
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->resume_from = from;
|
2004-03-02 04:31:18 -05:00
|
|
|
infof(data, "FTP RANGE the last %" FORMAT_OFF_T " bytes\n", totalsize);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
else {
|
2000-05-22 10:12:12 -04:00
|
|
|
/* X-Y */
|
1999-12-29 09:20:26 -05:00
|
|
|
totalsize = to-from;
|
2001-02-22 18:32:02 -05:00
|
|
|
conn->maxdownload = totalsize+1; /* include the last mentioned byte */
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->resume_from = from;
|
2004-03-02 04:31:18 -05:00
|
|
|
infof(data, "FTP RANGE from %" FORMAT_OFF_T
|
|
|
|
" getting %" FORMAT_OFF_T " bytes\n", from, conn->maxdownload);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2004-03-02 04:31:18 -05:00
|
|
|
infof(data, "range-download from %" FORMAT_OFF_T
|
|
|
|
" to %" FORMAT_OFF_T ", totally %" FORMAT_OFF_T " bytes\n",
|
2004-01-05 17:29:29 -05:00
|
|
|
from, to, conn->maxdownload);
|
2002-06-13 05:21:08 -04:00
|
|
|
ftp->dont_check = TRUE; /* dont check for successful transfer */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2000-11-29 03:19:23 -05:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if((data->set.ftp_list_only) || !ftp->file) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* The specified path ends with a slash, and therefore we think this
|
|
|
|
is a directory that is requested, use LIST. But before that we
|
|
|
|
need to set ASCII transfer mode. */
|
|
|
|
dirlist = TRUE;
|
|
|
|
|
|
|
|
/* Set type to ASCII */
|
2001-09-28 04:58:18 -04:00
|
|
|
result = ftp_transfertype(conn, TRUE /* ASCII enforced */);
|
2001-08-23 02:10:01 -04:00
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* if this output is to be machine-parsed, the NLST command will be
|
|
|
|
better used since the LIST command output is not specified or
|
|
|
|
standard in any way */
|
|
|
|
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "%s",
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.customrequest?data->set.customrequest:
|
|
|
|
(data->set.ftp_list_only?"NLST":"LIST"));
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
else {
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t foundsize;
|
2001-11-28 08:05:39 -05:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Set type to binary (unless specified ASCII) */
|
2001-09-28 04:58:18 -04:00
|
|
|
result = ftp_transfertype(conn, data->set.ftp_ascii);
|
2001-08-23 02:10:01 -04:00
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2003-08-08 05:13:19 -04:00
|
|
|
/* Send any PREQUOTE strings after transfer type is set? */
|
2002-02-28 18:31:23 -05:00
|
|
|
if(data->set.prequote) {
|
|
|
|
if ((result = ftp_sendquote(conn, data->set.prequote)) != CURLE_OK)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2001-11-28 08:05:39 -05:00
|
|
|
/* Attempt to get the size, it'll be useful in some cases: for resumed
|
|
|
|
downloads and when talking to servers that don't give away the size
|
|
|
|
in the RETR response line. */
|
|
|
|
result = ftp_getsize(conn, ftp->file, &foundsize);
|
2003-10-17 09:11:00 -04:00
|
|
|
if(CURLE_OK == result) {
|
|
|
|
if (data->set.max_filesize && foundsize > data->set.max_filesize) {
|
|
|
|
failf(data, "Maximum file size exceeded");
|
|
|
|
return CURLE_FILESIZE_EXCEEDED;
|
|
|
|
}
|
2001-11-28 08:05:39 -05:00
|
|
|
downloadsize = foundsize;
|
2003-10-17 09:11:00 -04:00
|
|
|
}
|
2001-11-28 08:05:39 -05:00
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
if(conn->resume_from) {
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* Daniel: (August 4, 1999)
|
|
|
|
*
|
|
|
|
* We start with trying to use the SIZE command to figure out the size
|
|
|
|
* of the file we're gonna get. If we can get the size, this is by far
|
2001-11-28 08:05:39 -05:00
|
|
|
* the best way to know if we're trying to resume beyond the EOF.
|
|
|
|
*
|
|
|
|
* Daniel, November 28, 2001. We *always* get the size on downloads
|
|
|
|
* now, so it is done before this even when not doing resumes. I saved
|
|
|
|
* the comment above for nostalgical reasons! ;-)
|
|
|
|
*/
|
2001-08-23 02:10:01 -04:00
|
|
|
if(CURLE_OK != result) {
|
2001-09-13 08:52:58 -04:00
|
|
|
infof(data, "ftp server doesn't support SIZE\n");
|
1999-12-29 09:20:26 -05:00
|
|
|
/* We couldn't get the size and therefore we can't know if there
|
|
|
|
really is a part of the file left to get, although the server
|
|
|
|
will just close the connection when we start the connection so it
|
|
|
|
won't cause us any harm, just not make us exit as nicely. */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* We got a file size report, so we check that there actually is a
|
|
|
|
part of the file left to get, or else we go home. */
|
2001-04-18 03:25:11 -04:00
|
|
|
if(conn->resume_from< 0) {
|
2000-05-22 10:12:12 -04:00
|
|
|
/* We're supposed to download the last abs(from) bytes */
|
2001-04-18 03:25:11 -04:00
|
|
|
if(foundsize < -conn->resume_from) {
|
2004-03-02 04:31:18 -05:00
|
|
|
failf(data, "Offset (%" FORMAT_OFF_T
|
|
|
|
") was beyond file size (%" FORMAT_OFF_T ")",
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->resume_from, foundsize);
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_BAD_DOWNLOAD_RESUME;
|
|
|
|
}
|
|
|
|
/* convert to size to download */
|
2001-04-18 03:25:11 -04:00
|
|
|
downloadsize = -conn->resume_from;
|
2000-05-22 10:12:12 -04:00
|
|
|
/* download from where? */
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->resume_from = foundsize - downloadsize;
|
2000-05-22 10:12:12 -04:00
|
|
|
}
|
|
|
|
else {
|
2001-04-18 03:25:11 -04:00
|
|
|
if(foundsize < conn->resume_from) {
|
2004-03-02 04:31:18 -05:00
|
|
|
failf(data, "Offset (%" FORMAT_OFF_T
|
|
|
|
") was beyond file size (%" FORMAT_OFF_T ")",
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->resume_from, foundsize);
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_BAD_DOWNLOAD_RESUME;
|
|
|
|
}
|
|
|
|
/* Now store the number of bytes we are expected to download */
|
2001-04-18 03:25:11 -04:00
|
|
|
downloadsize = foundsize-conn->resume_from;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-09-04 22:49:04 -04:00
|
|
|
if (downloadsize == 0) {
|
2001-05-11 07:38:13 -04:00
|
|
|
/* no data to transfer */
|
|
|
|
result=Curl_Transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
|
2001-09-04 22:49:04 -04:00
|
|
|
infof(data, "File already completely downloaded\n");
|
2001-05-11 07:38:13 -04:00
|
|
|
|
2002-06-14 02:57:00 -04:00
|
|
|
/* Set no_transfer so that we won't get any error in Curl_ftp_done()
|
|
|
|
* because we didn't transfer the any file */
|
|
|
|
ftp->no_transfer = TRUE;
|
2001-09-04 22:49:04 -04:00
|
|
|
return CURLE_OK;
|
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Set resume file transfer offset */
|
2004-03-02 04:31:18 -05:00
|
|
|
infof(data, "Instructs server to resume from offset %" FORMAT_OFF_T
|
|
|
|
"\n",
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->resume_from);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2004-03-02 04:31:18 -05:00
|
|
|
FTPSENDF(conn, "REST %" FORMAT_OFF_T, conn->resume_from);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-11-22 07:50:41 -05:00
|
|
|
if(ftpcode != 350) {
|
1999-12-29 09:20:26 -05:00
|
|
|
failf(data, "Couldn't use REST: %s", buf+4);
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_COULDNT_USE_REST;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "RETR %s", ftp->file);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2000-11-22 07:50:41 -05:00
|
|
|
if((ftpcode == 150) || (ftpcode == 125)) {
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
A;
|
|
|
|
150 Opening BINARY mode data connection for /etc/passwd (2241
|
|
|
|
bytes). (ok, the file is being transfered)
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
B:
|
2004-06-03 07:41:05 -04:00
|
|
|
150 Opening ASCII mode data connection for /bin/ls
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
C:
|
|
|
|
150 ASCII data connection for /bin/ls (137.167.104.91,37445) (0 bytes).
|
|
|
|
|
|
|
|
D:
|
|
|
|
150 Opening ASCII mode data connection for /linux/fisk/kpanelrc (0.0.0.0,0) (545 bytes).
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
E:
|
|
|
|
125 Data connection already open; Transfer starting. */
|
|
|
|
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t size=-1; /* default unknown size */
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2003-02-27 07:50:54 -05:00
|
|
|
|
|
|
|
/*
|
|
|
|
* It appears that there are FTP-servers that return size 0 for files
|
|
|
|
* when SIZE is used on the file while being in BINARY mode. To work
|
|
|
|
* around that (stupid) behavior, we attempt to parse the RETR response
|
|
|
|
* even if the SIZE returned size zero.
|
|
|
|
*
|
|
|
|
* Debugging help from Salvatore Sorrentino on February 26, 2003.
|
|
|
|
*/
|
|
|
|
|
2000-07-25 08:12:29 -04:00
|
|
|
if(!dirlist &&
|
2001-08-30 18:48:34 -04:00
|
|
|
!data->set.ftp_ascii &&
|
2003-02-27 07:50:54 -05:00
|
|
|
(downloadsize < 1)) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/*
|
|
|
|
* It seems directory listings either don't show the size or very
|
2000-07-25 08:12:29 -04:00
|
|
|
* often uses size 0 anyway. ASCII transfers may very well turn out
|
|
|
|
* that the transfered amount of data is not the same as this line
|
|
|
|
* tells, why using this number in those cases only confuses us.
|
|
|
|
*
|
|
|
|
* Example D above makes this parsing a little tricky */
|
1999-12-29 09:20:26 -05:00
|
|
|
char *bytes;
|
|
|
|
bytes=strstr(buf, " bytes");
|
|
|
|
if(bytes--) {
|
2004-03-03 08:24:14 -05:00
|
|
|
long in=bytes-buf;
|
1999-12-29 09:20:26 -05:00
|
|
|
/* this is a hint there is size information in there! ;-) */
|
2003-10-18 16:14:33 -04:00
|
|
|
while(--in) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* scan for the parenthesis and break there */
|
|
|
|
if('(' == *bytes)
|
|
|
|
break;
|
|
|
|
/* if only skip digits, or else we're in deep trouble */
|
|
|
|
if(!isdigit((int)*bytes)) {
|
|
|
|
bytes=NULL;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
/* one more estep backwards */
|
|
|
|
bytes--;
|
|
|
|
}
|
|
|
|
/* only if we have nothing but digits: */
|
|
|
|
if(bytes++) {
|
|
|
|
/* get the number! */
|
2004-04-07 03:30:40 -04:00
|
|
|
size = curlx_strtoofft(bytes, NULL, 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(downloadsize > -1)
|
|
|
|
size = downloadsize;
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.ftp_use_port) {
|
2003-11-24 02:15:37 -05:00
|
|
|
result = AllowServerConnect(conn);
|
1999-12-29 09:20:26 -05:00
|
|
|
if( result )
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2003-11-24 02:15:37 -05:00
|
|
|
if(conn->ssl[SECONDARYSOCKET].use) {
|
2003-12-01 05:14:39 -05:00
|
|
|
/* since we only have a plaintext TCP connection here, we must now
|
|
|
|
do the TLS stuff */
|
2003-12-02 08:21:53 -05:00
|
|
|
infof(data, "Doing the SSL/TLS handshake on the data stream\n");
|
2003-12-01 05:14:39 -05:00
|
|
|
result = Curl_SSLConnect(conn, SECONDARYSOCKET);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2003-11-24 02:15:37 -05:00
|
|
|
}
|
2003-12-01 05:14:39 -05:00
|
|
|
|
2004-01-05 17:29:29 -05:00
|
|
|
if(size > conn->maxdownload && conn->maxdownload > 0)
|
2003-12-03 03:26:31 -05:00
|
|
|
size = conn->size = conn->maxdownload;
|
|
|
|
|
2004-03-02 04:31:18 -05:00
|
|
|
infof(data, "Getting file with size: %" FORMAT_OFF_T "\n", size);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* FTP download: */
|
2003-11-24 02:15:37 -05:00
|
|
|
result=Curl_Transfer(conn, SECONDARYSOCKET, size, FALSE,
|
2001-09-13 08:52:58 -04:00
|
|
|
bytecountp,
|
|
|
|
-1, NULL); /* no upload here */
|
1999-12-29 09:20:26 -05:00
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
else {
|
2003-05-23 07:14:09 -04:00
|
|
|
if(dirlist && (ftpcode == 450)) {
|
|
|
|
/* simply no matching files */
|
|
|
|
ftp->no_transfer = TRUE; /* don't think we should download anything */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
failf(data, "%s", buf+4);
|
|
|
|
return CURLE_FTP_COULDNT_RETR_FILE;
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
/* end of transfer */
|
2000-01-10 18:36:14 -05:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_OK;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_perform()
|
|
|
|
*
|
|
|
|
* This is the actual DO function for FTP. Get a file/directory according to
|
|
|
|
* the options previously setup.
|
|
|
|
*/
|
|
|
|
|
|
|
|
static
|
|
|
|
CURLcode ftp_perform(struct connectdata *conn,
|
|
|
|
bool *connected) /* for the TCP connect status after
|
|
|
|
PASV / PORT */
|
|
|
|
{
|
|
|
|
/* this is FTP and no proxy */
|
|
|
|
CURLcode result=CURLE_OK;
|
|
|
|
struct SessionHandle *data=conn->data;
|
|
|
|
char *buf = data->state.buffer; /* this is our buffer */
|
|
|
|
|
2002-12-03 05:25:31 -05:00
|
|
|
/* the ftp struct is already inited in Curl_ftp_connect() */
|
2002-08-12 05:43:20 -04:00
|
|
|
struct FTP *ftp = conn->proto.ftp;
|
|
|
|
|
|
|
|
/* Send any QUOTE strings? */
|
|
|
|
if(data->set.quote) {
|
|
|
|
if ((result = ftp_sendquote(conn, data->set.quote)) != CURLE_OK)
|
|
|
|
return result;
|
|
|
|
}
|
2003-08-08 05:13:19 -04:00
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
/* This is a re-used connection. Since we change directory to where the
|
|
|
|
transfer is taking place, we must now get back to the original dir
|
|
|
|
where we ended up after login: */
|
2002-08-26 18:00:01 -04:00
|
|
|
if (conn->bits.reuse && ftp->entrypath) {
|
2003-08-22 08:35:18 -04:00
|
|
|
if ((result = ftp_cwd_and_mkd(conn, ftp->entrypath)) != CURLE_OK)
|
2002-08-12 05:43:20 -04:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2003-04-30 12:59:42 -04:00
|
|
|
{
|
|
|
|
int i; /* counter for loop */
|
2004-04-15 06:43:40 -04:00
|
|
|
for (i=0; i < ftp->dirdepth; i++) {
|
2003-08-08 05:13:19 -04:00
|
|
|
/* RFC 1738 says empty components should be respected too, but
|
|
|
|
that is plain stupid since CWD can't be used with an empty argument */
|
2003-08-22 08:35:18 -04:00
|
|
|
if ((result = ftp_cwd_and_mkd(conn, ftp->dirs[i])) != CURLE_OK)
|
2002-08-12 05:43:20 -04:00
|
|
|
return result;
|
2003-04-30 12:59:42 -04:00
|
|
|
}
|
2002-08-12 05:43:20 -04:00
|
|
|
}
|
|
|
|
|
2003-04-09 07:56:31 -04:00
|
|
|
/* Requested time of file or time-depended transfer? */
|
|
|
|
if((data->set.get_filetime || data->set.timecondition) &&
|
|
|
|
ftp->file) {
|
2002-08-12 05:43:20 -04:00
|
|
|
result = ftp_getfiletime(conn, ftp->file);
|
2003-08-08 05:13:19 -04:00
|
|
|
switch( result )
|
|
|
|
{
|
|
|
|
case CURLE_FTP_COULDNT_RETR_FILE:
|
|
|
|
case CURLE_OK:
|
|
|
|
if(data->set.timecondition) {
|
|
|
|
if((data->info.filetime > 0) && (data->set.timevalue > 0)) {
|
|
|
|
switch(data->set.timecondition) {
|
2004-01-21 03:50:08 -05:00
|
|
|
case CURL_TIMECOND_IFMODSINCE:
|
2003-08-08 05:13:19 -04:00
|
|
|
default:
|
|
|
|
if(data->info.filetime < data->set.timevalue) {
|
|
|
|
infof(data, "The requested document is not new enough\n");
|
|
|
|
ftp->no_transfer = TRUE; /* mark this to not transfer data */
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
break;
|
2004-01-21 03:50:08 -05:00
|
|
|
case CURL_TIMECOND_IFUNMODSINCE:
|
2003-08-08 05:13:19 -04:00
|
|
|
if(data->info.filetime > data->set.timevalue) {
|
|
|
|
infof(data, "The requested document is not old enough\n");
|
|
|
|
ftp->no_transfer = TRUE; /* mark this to not transfer data */
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
break;
|
|
|
|
} /* switch */
|
2003-04-09 07:56:31 -04:00
|
|
|
}
|
2003-08-08 05:13:19 -04:00
|
|
|
else {
|
|
|
|
infof(data, "Skipping time comparison\n");
|
2003-04-09 07:56:31 -04:00
|
|
|
}
|
2003-08-08 05:13:19 -04:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
return result;
|
|
|
|
} /* switch */
|
2002-08-12 05:43:20 -04:00
|
|
|
}
|
|
|
|
|
|
|
|
/* If we have selected NOBODY and HEADER, it means that we only want file
|
|
|
|
information. Which in FTP can't be much more than the file size and
|
|
|
|
date. */
|
2004-04-06 11:14:10 -04:00
|
|
|
if(conn->bits.no_body && data->set.include_header && ftp->file) {
|
2002-08-12 05:43:20 -04:00
|
|
|
/* The SIZE command is _not_ RFC 959 specified, and therefor many servers
|
|
|
|
may not support it! It is however the only way we have to get a file's
|
|
|
|
size! */
|
2004-01-22 07:45:50 -05:00
|
|
|
curl_off_t filesize;
|
2003-07-30 03:51:33 -04:00
|
|
|
ssize_t nread;
|
|
|
|
int ftpcode;
|
2002-08-12 05:43:20 -04:00
|
|
|
|
|
|
|
ftp->no_transfer = TRUE; /* this means no actual transfer is made */
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
/* Some servers return different sizes for different modes, and thus we
|
|
|
|
must set the proper type before we check the size */
|
|
|
|
result = ftp_transfertype(conn, data->set.ftp_ascii);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
/* failing to get size is not a serious error */
|
|
|
|
result = ftp_getsize(conn, ftp->file, &filesize);
|
|
|
|
|
|
|
|
if(CURLE_OK == result) {
|
2004-06-24 07:54:11 -04:00
|
|
|
snprintf(buf, sizeof(data->state.buffer),
|
|
|
|
"Content-Length: %" FORMAT_OFF_T "\r\n", filesize);
|
2002-08-12 05:43:20 -04:00
|
|
|
result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2003-07-30 03:51:33 -04:00
|
|
|
/* Determine if server can respond to REST command and therefore
|
|
|
|
whether it can do a range */
|
|
|
|
FTPSENDF(conn, "REST 0", NULL);
|
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
|
|
|
|
if ((CURLE_OK == result) && (ftpcode == 350)) {
|
|
|
|
result = Curl_client_write(data, CLIENTWRITE_BOTH,
|
|
|
|
(char *)"Accept-ranges: bytes\r\n", 0);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
/* If we asked for a time of the file and we actually got one as
|
|
|
|
well, we "emulate" a HTTP-style header in our output. */
|
|
|
|
|
|
|
|
#ifdef HAVE_STRFTIME
|
2003-01-07 06:25:44 -05:00
|
|
|
if(data->set.get_filetime && (data->info.filetime>=0) ) {
|
2002-08-12 05:43:20 -04:00
|
|
|
struct tm *tm;
|
2004-02-13 01:59:49 -05:00
|
|
|
time_t clock = (time_t)data->info.filetime;
|
2003-10-31 16:36:43 -05:00
|
|
|
#ifdef HAVE_GMTIME_R
|
2002-08-12 05:43:20 -04:00
|
|
|
struct tm buffer;
|
2004-02-13 01:59:49 -05:00
|
|
|
tm = (struct tm *)gmtime_r(&clock, &buffer);
|
2002-08-12 05:43:20 -04:00
|
|
|
#else
|
2004-02-13 01:59:49 -05:00
|
|
|
tm = gmtime(&clock);
|
2002-08-12 05:43:20 -04:00
|
|
|
#endif
|
2003-10-30 04:06:24 -05:00
|
|
|
/* format: "Tue, 15 Nov 1994 12:45:26" */
|
2003-10-31 16:36:43 -05:00
|
|
|
strftime(buf, BUFSIZE-1, "Last-Modified: %a, %d %b %Y %H:%M:%S GMT\r\n",
|
2002-08-12 05:43:20 -04:00
|
|
|
tm);
|
|
|
|
result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
2004-04-06 11:14:10 -04:00
|
|
|
if(conn->bits.no_body)
|
2002-08-12 05:43:20 -04:00
|
|
|
/* doesn't really transfer any data */
|
|
|
|
ftp->no_transfer = TRUE;
|
|
|
|
/* Get us a second connection up and connected */
|
|
|
|
else if(data->set.ftp_use_port) {
|
|
|
|
/* We have chosen to use the PORT command */
|
|
|
|
result = ftp_use_port(conn);
|
|
|
|
if(CURLE_OK == result) {
|
|
|
|
/* we have the data connection ready */
|
|
|
|
infof(data, "Ordered connect of the data stream with PORT!\n");
|
|
|
|
*connected = TRUE; /* mark us "still connected" */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
/* We have chosen (this is default) to use the PASV command */
|
|
|
|
result = ftp_use_pasv(conn, connected);
|
2003-12-02 08:21:53 -05:00
|
|
|
if(CURLE_OK == result && *connected)
|
2002-08-12 05:43:20 -04:00
|
|
|
infof(data, "Connected the data stream with PASV!\n");
|
|
|
|
}
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Curl_ftp()
|
|
|
|
*
|
|
|
|
* This function is registered as 'curl_do' function. It decodes the path
|
|
|
|
* parts etc as a wrapper to the actual DO function (ftp_perform).
|
|
|
|
*
|
|
|
|
* The input argument is already checked for validity.
|
|
|
|
*/
|
2001-01-05 05:11:41 -05:00
|
|
|
CURLcode Curl_ftp(struct connectdata *conn)
|
1999-12-29 09:20:26 -05:00
|
|
|
{
|
2004-06-03 07:41:05 -04:00
|
|
|
CURLcode retcode = CURLE_OK;
|
2003-07-19 20:18:11 -04:00
|
|
|
|
2004-06-03 07:41:05 -04:00
|
|
|
if (conn->sec_conn) /* 3rd party transfer */
|
|
|
|
retcode = ftp_3rdparty(conn);
|
1999-12-29 09:20:26 -05:00
|
|
|
else
|
2004-06-03 07:41:05 -04:00
|
|
|
retcode = ftp_regular_transfer(conn);
|
2004-04-22 09:09:00 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
return retcode;
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Curl_ftpsendf()
|
|
|
|
*
|
|
|
|
* Sends the formated string as a ftp command to a ftp server
|
2001-01-05 05:11:41 -05:00
|
|
|
*
|
|
|
|
* NOTE: we build the command in a fixed-length buffer, which sets length
|
|
|
|
* restrictions on the command!
|
|
|
|
*/
|
2001-10-31 09:56:12 -05:00
|
|
|
CURLcode Curl_ftpsendf(struct connectdata *conn,
|
|
|
|
const char *fmt, ...)
|
2001-01-05 05:11:41 -05:00
|
|
|
{
|
2002-01-16 09:46:00 -05:00
|
|
|
ssize_t bytes_written;
|
2001-01-05 05:11:41 -05:00
|
|
|
char s[256];
|
2004-03-03 08:24:14 -05:00
|
|
|
size_t write_len;
|
2002-01-16 09:46:00 -05:00
|
|
|
char *sptr=s;
|
|
|
|
CURLcode res = CURLE_OK;
|
2001-01-05 05:11:41 -05:00
|
|
|
|
|
|
|
va_list ap;
|
|
|
|
va_start(ap, fmt);
|
|
|
|
vsnprintf(s, 250, fmt, ap);
|
|
|
|
va_end(ap);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2001-01-05 05:11:41 -05:00
|
|
|
strcat(s, "\r\n"); /* append a trailing CRLF */
|
|
|
|
|
2001-03-29 03:16:55 -05:00
|
|
|
bytes_written=0;
|
2001-10-31 09:56:12 -05:00
|
|
|
write_len = strlen(s);
|
2001-03-29 03:16:55 -05:00
|
|
|
|
2004-01-29 08:56:45 -05:00
|
|
|
while(1) {
|
2003-11-24 02:15:37 -05:00
|
|
|
res = Curl_write(conn, conn->sock[FIRSTSOCKET], sptr, write_len,
|
2002-01-16 09:46:00 -05:00
|
|
|
&bytes_written);
|
|
|
|
|
|
|
|
if(CURLE_OK != res)
|
|
|
|
break;
|
|
|
|
|
2002-04-12 03:21:11 -04:00
|
|
|
if(conn->data->set.verbose)
|
2004-06-03 07:41:05 -04:00
|
|
|
Curl_debug(conn->data, CURLINFO_HEADER_OUT, sptr, bytes_written, conn->host.dispname);
|
2002-04-12 03:21:11 -04:00
|
|
|
|
2004-03-03 08:24:14 -05:00
|
|
|
if(bytes_written != (ssize_t)write_len) {
|
2002-01-16 09:46:00 -05:00
|
|
|
write_len -= bytes_written;
|
|
|
|
sptr += bytes_written;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
break;
|
2004-01-29 08:56:45 -05:00
|
|
|
}
|
2002-01-16 09:46:00 -05:00
|
|
|
|
|
|
|
return res;
|
2001-01-05 05:11:41 -05:00
|
|
|
}
|
|
|
|
|
2004-01-21 03:50:08 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
2004-04-22 09:09:00 -04:00
|
|
|
* ftp_quit()
|
2004-01-21 03:50:08 -05:00
|
|
|
*
|
|
|
|
* This should be called before calling sclose() on an ftp control connection
|
2004-06-03 07:41:05 -04:00
|
|
|
* (not data connections). We should then wait for the response from the
|
2004-01-21 03:50:08 -05:00
|
|
|
* server before returning. The calling code should then try to close the
|
|
|
|
* connection.
|
|
|
|
*
|
|
|
|
*/
|
2004-04-22 09:09:00 -04:00
|
|
|
static CURLcode ftp_quit(struct connectdata *conn)
|
2004-01-21 03:50:08 -05:00
|
|
|
{
|
2004-02-03 04:52:32 -05:00
|
|
|
ssize_t nread;
|
2004-01-21 03:50:08 -05:00
|
|
|
int ftpcode;
|
2004-02-27 02:08:37 -05:00
|
|
|
CURLcode ret = CURLE_OK;
|
2004-01-21 03:50:08 -05:00
|
|
|
|
2004-02-27 02:08:37 -05:00
|
|
|
if(conn->proto.ftp->ctl_valid) {
|
|
|
|
ret = Curl_ftpsendf(conn, "%s", "QUIT");
|
|
|
|
if(CURLE_OK == ret)
|
|
|
|
ret = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
}
|
2004-01-21 03:50:08 -05:00
|
|
|
|
|
|
|
return ret;
|
|
|
|
}
|
|
|
|
|
2001-11-01 07:47:22 -05:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* Curl_ftp_disconnect()
|
|
|
|
*
|
|
|
|
* Disconnect from an FTP server. Cleanup protocol-specific per-connection
|
|
|
|
* resources
|
|
|
|
*/
|
2001-03-02 02:44:05 -05:00
|
|
|
CURLcode Curl_ftp_disconnect(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
struct FTP *ftp= conn->proto.ftp;
|
|
|
|
|
2004-01-21 03:50:08 -05:00
|
|
|
/* We cannot send quit unconditionally. If this connection is stale or
|
|
|
|
bad in any way, sending quit and waiting around here will make the
|
|
|
|
disconnect wait in vain and cause more problems than we need to.
|
2004-02-27 02:08:37 -05:00
|
|
|
|
2004-04-22 09:09:00 -04:00
|
|
|
ftp_quit() will check the state of ftp->ctl_valid. If it's ok it
|
2004-02-27 02:08:37 -05:00
|
|
|
will try to send the QUIT command, otherwise it will just return.
|
2004-01-21 03:50:08 -05:00
|
|
|
*/
|
|
|
|
|
2001-04-03 06:20:23 -04:00
|
|
|
/* The FTP session may or may not have been allocated/setup at this point! */
|
|
|
|
if(ftp) {
|
2004-04-22 09:09:00 -04:00
|
|
|
(void)ftp_quit(conn); /* ignore errors on the QUIT */
|
2004-03-01 02:59:25 -05:00
|
|
|
|
2001-04-03 06:20:23 -04:00
|
|
|
if(ftp->entrypath)
|
|
|
|
free(ftp->entrypath);
|
2003-08-05 09:04:10 -04:00
|
|
|
if(ftp->cache) {
|
2001-12-03 08:48:59 -05:00
|
|
|
free(ftp->cache);
|
2003-08-05 09:04:10 -04:00
|
|
|
ftp->cache = NULL;
|
|
|
|
}
|
|
|
|
freedirs(ftp);
|
2001-04-03 06:20:23 -04:00
|
|
|
}
|
2001-03-02 02:44:05 -05:00
|
|
|
return CURLE_OK;
|
|
|
|
}
|
2001-09-04 22:49:04 -04:00
|
|
|
|
2003-08-08 05:13:19 -04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_mkd()
|
|
|
|
*
|
|
|
|
* Makes a directory on the FTP server.
|
2003-08-08 05:55:16 -04:00
|
|
|
*
|
|
|
|
* Calls failf()
|
2003-08-08 05:13:19 -04:00
|
|
|
*/
|
2004-06-02 07:34:53 -04:00
|
|
|
static CURLcode ftp_mkd(struct connectdata *conn, char *path)
|
2003-08-08 05:13:19 -04:00
|
|
|
{
|
|
|
|
CURLcode result=CURLE_OK;
|
|
|
|
int ftpcode; /* for ftp status */
|
|
|
|
ssize_t nread;
|
|
|
|
|
|
|
|
/* Create a directory on the remote server */
|
|
|
|
FTPSENDF(conn, "MKD %s", path);
|
|
|
|
|
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if(result)
|
|
|
|
return result;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2003-08-08 05:13:19 -04:00
|
|
|
switch(ftpcode) {
|
|
|
|
case 257:
|
|
|
|
/* success! */
|
2003-08-08 05:55:16 -04:00
|
|
|
infof( conn->data , "Created remote directory %s\n" , path );
|
|
|
|
break;
|
|
|
|
case 550:
|
|
|
|
failf(conn->data, "Permission denied to make directory %s", path);
|
|
|
|
result = CURLE_FTP_ACCESS_DENIED;
|
2003-08-08 05:13:19 -04:00
|
|
|
break;
|
|
|
|
default:
|
2003-08-08 05:55:16 -04:00
|
|
|
failf(conn->data, "unrecognized MKD response: %d", ftpcode );
|
|
|
|
result = CURLE_FTP_ACCESS_DENIED;
|
2003-08-08 05:13:19 -04:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2003-08-08 05:55:16 -04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_cwd()
|
|
|
|
*
|
|
|
|
* Send 'CWD' to the remote server to Change Working Directory. It is the ftp
|
|
|
|
* version of the unix 'cd' command. This function is only called from the
|
2003-08-22 08:35:18 -04:00
|
|
|
* ftp_cwd_and_mkd() function these days.
|
2003-08-08 05:55:16 -04:00
|
|
|
*
|
|
|
|
* This function does NOT call failf().
|
|
|
|
*/
|
2004-06-03 07:41:05 -04:00
|
|
|
static
|
2003-08-08 05:55:16 -04:00
|
|
|
CURLcode ftp_cwd(struct connectdata *conn, char *path)
|
|
|
|
{
|
|
|
|
ssize_t nread;
|
|
|
|
int ftpcode;
|
|
|
|
CURLcode result;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2003-08-08 05:55:16 -04:00
|
|
|
FTPSENDF(conn, "CWD %s", path);
|
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if (!result) {
|
|
|
|
/* According to RFC959, CWD is supposed to return 250 on success, but
|
|
|
|
there seem to be non-compliant FTP servers out there that return 200,
|
|
|
|
so we accept any '2xy' code here. */
|
|
|
|
if (ftpcode/100 != 2)
|
|
|
|
result = CURLE_FTP_ACCESS_DENIED;
|
|
|
|
}
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2003-08-08 05:13:19 -04:00
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_cwd_and_mkd()
|
|
|
|
*
|
|
|
|
* Change to the given directory. If the directory is not present, and we
|
|
|
|
* have been told to allow it, then create the directory and cd to it.
|
2003-08-08 05:55:16 -04:00
|
|
|
*
|
2003-08-08 05:13:19 -04:00
|
|
|
*/
|
2003-08-22 08:35:18 -04:00
|
|
|
static CURLcode ftp_cwd_and_mkd(struct connectdata *conn, char *path)
|
2003-08-08 05:13:19 -04:00
|
|
|
{
|
|
|
|
CURLcode result;
|
2004-06-03 07:41:05 -04:00
|
|
|
|
2003-08-08 05:13:19 -04:00
|
|
|
result = ftp_cwd(conn, path);
|
2003-08-08 05:55:16 -04:00
|
|
|
if (result) {
|
|
|
|
if(conn->data->set.ftp_create_missing_dirs) {
|
|
|
|
result = ftp_mkd(conn, path);
|
|
|
|
if (result)
|
|
|
|
/* ftp_mkd() calls failf() itself */
|
|
|
|
return result;
|
|
|
|
result = ftp_cwd(conn, path);
|
|
|
|
}
|
|
|
|
if(result)
|
|
|
|
failf(conn->data, "Couldn't cd to %s", path);
|
2003-08-08 05:13:19 -04:00
|
|
|
}
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
2004-06-03 07:41:05 -04:00
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_3rdparty_pretransfer()
|
|
|
|
*
|
|
|
|
* Preparation for 3rd party transfer.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static CURLcode ftp_3rdparty_pretransfer(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
struct SessionHandle *data = conn->data;
|
|
|
|
struct connectdata *sec_conn = conn->sec_conn;
|
|
|
|
|
|
|
|
/* sets transfer type */
|
|
|
|
result = ftp_transfertype(conn, data->set.ftp_ascii);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
result = ftp_transfertype(sec_conn, data->set.ftp_ascii);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
/* Send any PREQUOTE strings after transfer type is set? */
|
|
|
|
if (data->set.source_prequote) {
|
|
|
|
/* sends command(s) to source server before file transfer */
|
|
|
|
result = ftp_sendquote(sec_conn, data->set.source_prequote);
|
|
|
|
}
|
|
|
|
if (!result && data->set.prequote)
|
|
|
|
result = ftp_sendquote(conn, data->set.prequote);
|
|
|
|
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_3rdparty_transfer()
|
|
|
|
*
|
|
|
|
* Performs 3rd party transfer.
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
static CURLcode ftp_3rdparty_transfer(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
CURLcode result = CURLE_OK;
|
|
|
|
ssize_t nread;
|
|
|
|
int ftpcode, ip[4], port[2];
|
|
|
|
struct SessionHandle *data = conn->data;
|
|
|
|
struct connectdata *sec_conn = conn->sec_conn;
|
|
|
|
char *buf = data->state.buffer; /* this is our buffer */
|
|
|
|
char *str = buf;
|
|
|
|
char pasv_port[50];
|
|
|
|
const char *stor_cmd;
|
|
|
|
struct connectdata *pasv_conn;
|
|
|
|
struct connectdata *port_conn;
|
|
|
|
|
|
|
|
if (data->set.pasvHost == CURL_TARGET_PASV) {
|
|
|
|
pasv_conn = conn;
|
|
|
|
port_conn = sec_conn;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
pasv_conn = sec_conn;
|
|
|
|
port_conn = conn;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* sets the passive mode */
|
|
|
|
FTPSENDF(pasv_conn, "%s", "PASV");
|
|
|
|
result = Curl_GetFTPResponse(&nread, pasv_conn, &ftpcode);
|
|
|
|
if (result) return result;
|
|
|
|
if (ftpcode != 227) {
|
|
|
|
failf(data, "Odd return code after PASV:%s", buf + 3);
|
|
|
|
return CURLE_FTP_WEIRD_PASV_REPLY;
|
|
|
|
}
|
|
|
|
|
|
|
|
while (*str) {
|
|
|
|
if (6 == sscanf(str, "%d,%d,%d,%d,%d,%d",
|
|
|
|
&ip[0], &ip[1], &ip[2], &ip[3], &port[0], &port[1]))
|
|
|
|
break;
|
|
|
|
str++;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*str) {
|
|
|
|
failf(pasv_conn->data, "Couldn't interpret this 227-reply: %s", buf);
|
|
|
|
return CURLE_FTP_WEIRD_227_FORMAT;
|
|
|
|
}
|
|
|
|
|
|
|
|
snprintf(pasv_port, sizeof(pasv_port), "%d,%d,%d,%d,%d,%d", ip[0], ip[1],
|
|
|
|
ip[2], ip[3], port[0], port[1]);
|
|
|
|
|
|
|
|
/* sets data connection between remote hosts */
|
|
|
|
FTPSENDF(port_conn, "PORT %s", pasv_port);
|
|
|
|
result = Curl_GetFTPResponse(&nread, port_conn, &ftpcode);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (ftpcode != 200) {
|
|
|
|
failf(data, "PORT command attempts failed:%s", buf + 3);
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* we might append onto the file instead of overwriting it */
|
|
|
|
stor_cmd = data->set.ftp_append?"APPE":"STOR";
|
|
|
|
|
|
|
|
/* transfers file between remote hosts */
|
|
|
|
FTPSENDF(sec_conn, "RETR %s", data->set.source_path);
|
|
|
|
|
|
|
|
if(data->set.pasvHost == CURL_TARGET_PASV) {
|
|
|
|
|
|
|
|
result = Curl_GetFTPResponse(&nread, sec_conn, &ftpcode);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (ftpcode != 150) {
|
|
|
|
failf(data, "Failed RETR: %s", buf + 4);
|
|
|
|
return CURLE_FTP_COULDNT_RETR_FILE;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = Curl_ftpsendf(conn, "%s %s", stor_cmd, conn->path);
|
|
|
|
if(CURLE_OK == result)
|
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (ftpcode != 150) {
|
|
|
|
failf(data, "Failed FTP upload: %s", buf + 4);
|
|
|
|
return CURLE_FTP_COULDNT_STOR_FILE;
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
|
|
|
|
result = Curl_ftpsendf(conn, "%s %s", stor_cmd, conn->path);
|
|
|
|
if(CURLE_OK == result)
|
|
|
|
result = Curl_GetFTPResponse(&nread, sec_conn, &ftpcode);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (ftpcode != 150) {
|
|
|
|
failf(data, "Failed FTP upload: %s", buf + 4);
|
|
|
|
return CURLE_FTP_COULDNT_STOR_FILE;
|
|
|
|
}
|
|
|
|
|
|
|
|
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
|
|
|
|
if (result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
if (ftpcode != 150) {
|
|
|
|
failf(data, "Failed FTP upload: %s", buf + 4);
|
|
|
|
return CURLE_FTP_COULDNT_STOR_FILE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_regular_transfer()
|
|
|
|
*
|
|
|
|
* The input argument is already checked for validity.
|
|
|
|
* Performs a regular transfer between local and remote hosts.
|
|
|
|
*
|
|
|
|
* ftp->ctl_valid starts out as FALSE, and gets set to TRUE if we reach the
|
|
|
|
* Curl_ftp_done() function without finding any major problem.
|
|
|
|
*/
|
|
|
|
static
|
|
|
|
CURLcode ftp_regular_transfer(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
CURLcode retcode=CURLE_OK;
|
|
|
|
bool connected=0;
|
|
|
|
struct SessionHandle *data = conn->data;
|
|
|
|
struct FTP *ftp;
|
|
|
|
|
|
|
|
char *slash_pos; /* position of the first '/' char in curpos */
|
|
|
|
char *cur_pos=conn->path; /* current position in ppath. point at the begin
|
|
|
|
of next path component */
|
|
|
|
|
|
|
|
/* the ftp struct is already inited in ftp_connect() */
|
|
|
|
ftp = conn->proto.ftp;
|
|
|
|
ftp->ctl_valid = FALSE;
|
|
|
|
conn->size = -1; /* make sure this is unknown at this point */
|
|
|
|
|
|
|
|
Curl_pgrsSetUploadCounter(data, 0);
|
|
|
|
Curl_pgrsSetDownloadCounter(data, 0);
|
|
|
|
Curl_pgrsSetUploadSize(data, 0);
|
|
|
|
Curl_pgrsSetDownloadSize(data, 0);
|
|
|
|
|
|
|
|
ftp->dirdepth = 0;
|
|
|
|
ftp->diralloc = 5; /* default dir depth to allocate */
|
|
|
|
ftp->dirs = (char **)malloc(ftp->diralloc * sizeof(ftp->dirs[0]));
|
|
|
|
if(!ftp->dirs)
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
ftp->dirs[0] = NULL; /* to start with */
|
|
|
|
|
|
|
|
/* parse the URL path into separate path components */
|
|
|
|
while((slash_pos=strchr(cur_pos, '/'))) {
|
|
|
|
/* 1 or 0 to indicate absolute directory */
|
|
|
|
bool absolute_dir = (cur_pos - conn->path > 0) && (ftp->dirdepth == 0);
|
|
|
|
|
|
|
|
/* seek out the next path component */
|
|
|
|
if (slash_pos-cur_pos) {
|
|
|
|
/* we skip empty path components, like "x//y" since the FTP command CWD
|
|
|
|
requires a parameter and a non-existant parameter a) doesn't work on
|
|
|
|
many servers and b) has no effect on the others. */
|
2004-07-01 03:43:20 -04:00
|
|
|
int len = (int)(slash_pos - cur_pos + absolute_dir);
|
|
|
|
ftp->dirs[ftp->dirdepth] = curl_unescape(cur_pos - absolute_dir, len);
|
2004-06-03 07:41:05 -04:00
|
|
|
|
|
|
|
if (!ftp->dirs[ftp->dirdepth]) { /* run out of memory ... */
|
|
|
|
failf(data, "no memory");
|
|
|
|
freedirs(ftp);
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
cur_pos = slash_pos + 1; /* jump to the rest of the string */
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(!retcode) {
|
|
|
|
cur_pos = slash_pos + 1; /* jump to the rest of the string */
|
|
|
|
if(++ftp->dirdepth >= ftp->diralloc) {
|
|
|
|
/* enlarge array */
|
|
|
|
char *bigger;
|
|
|
|
ftp->diralloc *= 2; /* double the size each time */
|
|
|
|
bigger = realloc(ftp->dirs, ftp->diralloc * sizeof(ftp->dirs[0]));
|
|
|
|
if(!bigger) {
|
|
|
|
freedirs(ftp);
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
ftp->dirs = (char **)bigger;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
ftp->file = cur_pos; /* the rest is the file name */
|
|
|
|
|
|
|
|
if(*ftp->file) {
|
|
|
|
ftp->file = curl_unescape(ftp->file, 0);
|
|
|
|
if(NULL == ftp->file) {
|
|
|
|
freedirs(ftp);
|
|
|
|
failf(data, "no memory");
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ftp->file=NULL; /* instead of point to a zero byte, we make it a NULL
|
|
|
|
pointer */
|
|
|
|
|
|
|
|
retcode = ftp_perform(conn, &connected);
|
|
|
|
|
|
|
|
if(CURLE_OK == retcode) {
|
|
|
|
if(connected)
|
|
|
|
retcode = Curl_ftp_nextconnect(conn);
|
|
|
|
|
|
|
|
if(retcode && (conn->sock[SECONDARYSOCKET] != CURL_SOCKET_BAD)) {
|
|
|
|
/* Failure detected, close the second socket if it was created already */
|
|
|
|
sclose(conn->sock[SECONDARYSOCKET]);
|
|
|
|
conn->sock[SECONDARYSOCKET] = CURL_SOCKET_BAD;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(ftp->no_transfer)
|
|
|
|
/* no data to transfer */
|
|
|
|
retcode=Curl_Transfer(conn, -1, -1, FALSE, NULL, -1, NULL);
|
|
|
|
else if(!connected)
|
|
|
|
/* since we didn't connect now, we want do_more to get called */
|
|
|
|
conn->bits.do_more = TRUE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
freedirs(ftp);
|
|
|
|
|
|
|
|
ftp->ctl_valid = TRUE; /* seems good */
|
|
|
|
|
|
|
|
return retcode;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
/***********************************************************************
|
|
|
|
*
|
|
|
|
* ftp_3rdparty()
|
|
|
|
*
|
|
|
|
* The input argument is already checked for validity.
|
|
|
|
* Performs a 3rd party transfer between two remote hosts.
|
|
|
|
*/
|
|
|
|
static CURLcode ftp_3rdparty(struct connectdata *conn)
|
|
|
|
{
|
|
|
|
CURLcode retcode = CURLE_OK;
|
|
|
|
|
|
|
|
conn->proto.ftp->ctl_valid = conn->sec_conn->proto.ftp->ctl_valid = TRUE;
|
|
|
|
conn->size = conn->sec_conn->size = -1;
|
|
|
|
|
|
|
|
retcode = ftp_3rdparty_pretransfer(conn);
|
|
|
|
if (!retcode)
|
|
|
|
retcode = ftp_3rdparty_transfer(conn);
|
|
|
|
|
|
|
|
return retcode;
|
|
|
|
}
|
|
|
|
|
2002-06-11 07:13:01 -04:00
|
|
|
#endif /* CURL_DISABLE_FTP */
|