2002-09-03 07:52:59 -04:00
|
|
|
/***************************************************************************
|
1999-12-29 09:20:26 -05:00
|
|
|
* _ _ ____ _
|
|
|
|
* Project ___| | | | _ \| |
|
|
|
|
* / __| | | | |_) | |
|
|
|
|
* | (__| |_| | _ <| |___
|
|
|
|
* \___|\___/|_| \_\_____|
|
|
|
|
*
|
2002-03-19 02:54:55 -05:00
|
|
|
* Copyright (C) 1998 - 2002, 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.
|
|
|
|
*
|
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__)
|
|
|
|
#include <winsock.h>
|
|
|
|
#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
|
|
|
|
|
|
|
|
#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
|
|
|
|
2000-09-21 04:47:20 -04:00
|
|
|
#ifdef KRB4
|
|
|
|
#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
|
|
|
|
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"
|
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: */
|
|
|
|
#ifdef MALLOCDEBUG
|
|
|
|
#include "memdebug.h"
|
|
|
|
#endif
|
2000-09-21 04:47:20 -04:00
|
|
|
|
2001-08-15 03:14:51 -04:00
|
|
|
/* Local API functions */
|
2001-09-28 04:58:18 -04:00
|
|
|
static CURLcode ftp_sendquote(struct connectdata *conn, struct curl_slist *quote);
|
|
|
|
static CURLcode ftp_cwd(struct connectdata *conn, char *path);
|
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
|
|
|
|
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.
|
|
|
|
*
|
|
|
|
*/
|
2001-08-30 18:48:34 -04:00
|
|
|
static CURLcode AllowServerConnect(struct SessionHandle *data,
|
2001-02-20 12:35:51 -05:00
|
|
|
struct connectdata *conn,
|
1999-12-29 09:20:26 -05:00
|
|
|
int sock)
|
|
|
|
{
|
|
|
|
fd_set rdset;
|
|
|
|
struct timeval dt;
|
|
|
|
|
|
|
|
FD_ZERO(&rdset);
|
|
|
|
|
|
|
|
FD_SET(sock, &rdset);
|
|
|
|
|
|
|
|
/* we give the server 10 seconds to connect to us */
|
|
|
|
dt.tv_sec = 10;
|
|
|
|
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 */
|
|
|
|
{
|
|
|
|
int s;
|
|
|
|
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 */
|
|
|
|
|
2001-09-04 22:49:04 -04:00
|
|
|
if (-1 == s) {
|
|
|
|
/* 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");
|
|
|
|
|
2001-02-20 12:35:51 -05:00
|
|
|
conn->secondarysocket = s;
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
break;
|
|
|
|
}
|
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
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
int Curl_GetFTPResponse(char *buf,
|
2001-04-26 06:29:24 -04:00
|
|
|
struct connectdata *conn,
|
|
|
|
int *ftpcode)
|
|
|
|
{
|
|
|
|
/* 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
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
int sockfd = conn->firstsocket;
|
2001-04-26 06:29:24 -04:00
|
|
|
int nread; /* total size read */
|
|
|
|
int perline; /* count bytes per line */
|
|
|
|
bool keepon=TRUE;
|
|
|
|
ssize_t gotbytes;
|
|
|
|
char *ptr;
|
|
|
|
int timeout = 3600; /* default timeout in seconds */
|
|
|
|
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;
|
2001-06-19 02:04:21 -04:00
|
|
|
int code=0; /* default "error code" to return */
|
2001-04-26 06:29:24 -04:00
|
|
|
|
2002-01-04 04:03:11 -05:00
|
|
|
#define SELECT_OK 0
|
|
|
|
#define SELECT_ERROR 1 /* select() problems */
|
|
|
|
#define SELECT_TIMEOUT 2 /* took too long */
|
|
|
|
#define SELECT_MEMORY 3 /* no available memory */
|
|
|
|
#define SELECT_CALLBACK 4 /* aborted by callback */
|
|
|
|
|
2001-04-26 06:29:24 -04:00
|
|
|
int error = SELECT_OK;
|
|
|
|
|
2001-12-03 08:48:59 -05:00
|
|
|
struct FTP *ftp = conn->proto.ftp;
|
|
|
|
|
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;
|
|
|
|
|
|
|
|
nread=0;
|
|
|
|
perline=0;
|
|
|
|
keepon=TRUE;
|
|
|
|
|
|
|
|
while((nread<BUFSIZE) && (keepon && !error)) {
|
2002-04-27 09:24:06 -04:00
|
|
|
/* check and reset timeout value every lap */
|
|
|
|
if(data->set.timeout) {
|
|
|
|
/* 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 */
|
|
|
|
if(timeout <=0 ) {
|
|
|
|
failf(data, "Transfer aborted due to timeout");
|
|
|
|
return -SELECT_TIMEOUT; /* already too little time */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2002-04-27 09:09:37 -04:00
|
|
|
if(!ftp->cache) {
|
|
|
|
readfd = rkeepfd; /* set every lap */
|
|
|
|
interval.tv_sec = timeout;
|
|
|
|
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 */
|
|
|
|
error = SELECT_ERROR;
|
|
|
|
failf(data, "Transfer aborted due to select() error");
|
|
|
|
break;
|
|
|
|
case 0: /* timeout */
|
|
|
|
error = SELECT_TIMEOUT;
|
|
|
|
failf(data, "Transfer aborted due to timeout");
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
error = SELECT_OK;
|
|
|
|
break;
|
|
|
|
}
|
2002-04-27 09:09:37 -04:00
|
|
|
}
|
2001-12-03 08:48:59 -05:00
|
|
|
if(SELECT_OK == error) {
|
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
|
|
|
|
read */
|
|
|
|
memcpy(ptr, ftp->cache, ftp->cache_size);
|
|
|
|
gotbytes = ftp->cache_size;
|
|
|
|
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 {
|
|
|
|
int res = Curl_read(conn, sockfd, ptr,
|
|
|
|
BUFSIZE-nread, &gotbytes);
|
|
|
|
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;
|
|
|
|
error = SELECT_ERROR;
|
|
|
|
failf(data, "Connection aborted");
|
|
|
|
}
|
|
|
|
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;
|
|
|
|
|
|
|
|
nread += 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 */
|
2002-01-04 04:03:11 -05:00
|
|
|
CURLcode result;
|
2001-04-26 06:29:24 -04:00
|
|
|
|
|
|
|
/* output debug output if that is requested */
|
2002-04-12 03:21:11 -04:00
|
|
|
if(data->set.verbose)
|
|
|
|
Curl_debug(data, CURLINFO_HEADER_IN, line_start, perline);
|
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)
|
|
|
|
return -SELECT_CALLBACK;
|
|
|
|
|
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;
|
|
|
|
ftp->cache = (char *)malloc(ftp->cache_size);
|
|
|
|
if(ftp->cache)
|
|
|
|
memcpy(ftp->cache, line_start, ftp->cache_size);
|
|
|
|
else
|
2002-01-04 04:03:11 -05:00
|
|
|
return -SELECT_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 */
|
|
|
|
|
|
|
|
if(!error)
|
|
|
|
code = atoi(buf);
|
|
|
|
|
2002-01-18 08:04:48 -05:00
|
|
|
#ifdef 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(error)
|
|
|
|
return -error;
|
|
|
|
|
|
|
|
if(ftpcode)
|
|
|
|
*ftpcode=code; /* return the initial number like this */
|
|
|
|
|
|
|
|
return nread; /* total amount of bytes read */
|
|
|
|
}
|
|
|
|
|
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 */
|
2000-07-25 08:12:29 -04:00
|
|
|
int 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;
|
2000-11-22 07:50:41 -05:00
|
|
|
int ftpcode;
|
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
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
/* no need to duplicate them, the data struct won't change */
|
|
|
|
ftp->user = data->state.user;
|
|
|
|
ftp->passwd = data->state.passwd;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if (data->set.tunnel_thru_httpproxy) {
|
2000-09-14 10:05:01 -04:00
|
|
|
/* We want "seamless" FTP operations through HTTP proxy tunnel */
|
2001-02-20 12:35:51 -05:00
|
|
|
result = Curl_ConnectHTTPProxyTunnel(conn, conn->firstsocket,
|
|
|
|
conn->hostname, conn->remote_port);
|
2000-09-14 10:05:01 -04:00
|
|
|
if(CURLE_OK != result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
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 */
|
2001-05-12 05:30:42 -04:00
|
|
|
result = Curl_SSLConnect(conn);
|
|
|
|
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: */
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2000-07-25 08:12:29 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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
|
|
|
}
|
|
|
|
|
2000-09-21 04:47:20 -04:00
|
|
|
#ifdef KRB4
|
|
|
|
/* 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
|
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* send USER */
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "USER %s", ftp->user);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
/* wait for feedback */
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2000-07-25 08:12:29 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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) */
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "PASS %s", ftp->passwd);
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2000-07-25 08:12:29 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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) */
|
|
|
|
|
|
|
|
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");
|
2000-09-21 04:47:20 -04:00
|
|
|
#ifdef KRB4
|
|
|
|
/* we are logged in (with Kerberos)
|
|
|
|
* now set the requested protection level
|
|
|
|
*/
|
|
|
|
if(conn->sec_complete)
|
2001-08-17 06:14:06 -04:00
|
|
|
Curl_sec_set_protection_level(conn);
|
2000-09-21 04:47:20 -04:00
|
|
|
|
|
|
|
/* we may need to issue a KAUTH here to have access to the files
|
|
|
|
* do it if user supplied a password
|
|
|
|
*/
|
2001-08-30 18:59:58 -04:00
|
|
|
if(data->state.passwd && *data->state.passwd)
|
2001-08-17 06:14:06 -04:00
|
|
|
Curl_krb_kauth(conn);
|
2000-09-21 04:47:20 -04:00
|
|
|
#endif
|
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;
|
|
|
|
}
|
|
|
|
|
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 */
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2001-03-02 02:44:05 -05:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
|
|
|
|
|
|
|
if(ftpcode == 257) {
|
|
|
|
char *dir = (char *)malloc(nread+1);
|
|
|
|
char *store=dir;
|
|
|
|
char *ptr=&buf[4]; /* start on the first letter */
|
|
|
|
|
|
|
|
/* 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).
|
|
|
|
*/
|
2002-12-02 02:18:24 -05:00
|
|
|
if(dir && ('\"' == *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.
|
|
|
|
*/
|
2001-01-05 05:11:41 -05:00
|
|
|
CURLcode Curl_ftp_done(struct connectdata *conn)
|
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;
|
2001-08-30 18:48:34 -04:00
|
|
|
char *buf = data->state.buffer; /* this is our buffer */
|
2000-11-22 07:50:41 -05:00
|
|
|
int ftpcode;
|
2001-11-13 07:09:05 -05:00
|
|
|
CURLcode result=CURLE_OK;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
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) {
|
|
|
|
failf(data, "Uploaded unaligned file size (%d out of %d bytes)",
|
2001-08-30 18:48:34 -04:00
|
|
|
*ftp->bytecountp, data->set.infilesize);
|
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)) {
|
2001-09-13 08:52:58 -04:00
|
|
|
failf(data, "Received only partial file: %d bytes", *ftp->bytecountp);
|
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
|
|
|
}
|
|
|
|
}
|
2001-05-11 07:38:13 -04:00
|
|
|
|
2000-09-25 18:15:28 -04:00
|
|
|
#ifdef KRB4
|
2001-08-17 06:14:06 -04:00
|
|
|
Curl_sec_fflush_fd(conn, conn->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 */
|
2001-02-20 12:35:51 -05:00
|
|
|
sclose(conn->secondarysocket);
|
|
|
|
conn->secondarysocket = -1;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
2002-06-14 02:57:00 -04:00
|
|
|
if(!ftp->no_transfer) {
|
2002-06-12 18:05:28 -04:00
|
|
|
/* now let's see what the server says about the transfer we just
|
|
|
|
performed: */
|
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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;
|
2002-06-13 18:22:59 -04:00
|
|
|
ftp->dont_check = FALSE;
|
2001-05-11 07:38:13 -04:00
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
/* Send any post-transfer QUOTE strings? */
|
2001-11-12 17:27:05 -05:00
|
|
|
if(!result && data->set.postquote)
|
|
|
|
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
|
|
|
|
2001-08-15 03:14:51 -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
|
|
|
|
2001-11-15 09:16:13 -05:00
|
|
|
nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, &ftpcode);
|
2001-08-15 02:52:42 -04:00
|
|
|
if (nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
|
|
|
|
|
|
|
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_cwd()
|
|
|
|
*
|
|
|
|
* Send 'CWD' to the remote server to Change Working Directory.
|
|
|
|
* It is the ftp version of the unix 'cd' command.
|
|
|
|
*/
|
2001-08-15 03:14:51 -04:00
|
|
|
static
|
2001-09-28 04:58:18 -04:00
|
|
|
CURLcode ftp_cwd(struct connectdata *conn, char *path)
|
2001-08-15 03:14:51 -04:00
|
|
|
{
|
|
|
|
ssize_t nread;
|
|
|
|
int ftpcode;
|
2001-10-31 09:56:12 -05:00
|
|
|
CURLcode result;
|
2001-08-15 03:14:51 -04:00
|
|
|
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "CWD %s", path);
|
2002-08-26 19:13:25 -04:00
|
|
|
nread = Curl_GetFTPResponse(conn->data->state.buffer, conn, &ftpcode);
|
2001-08-15 03:14:51 -04:00
|
|
|
if (nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
|
|
|
|
|
|
|
if (ftpcode != 250) {
|
2001-09-14 08:18:46 -04:00
|
|
|
failf(conn->data, "Couldn't cd to %s", path);
|
2001-08-15 03:14:51 -04:00
|
|
|
return CURLE_FTP_ACCESS_DENIED;
|
|
|
|
}
|
2001-08-15 03:21:21 -04:00
|
|
|
|
|
|
|
return CURLE_OK;
|
2001-08-15 03:14:51 -04:00
|
|
|
}
|
|
|
|
|
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
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2001-08-23 02:10:01 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
|
|
|
|
|
|
|
if(ftpcode == 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);
|
|
|
|
sprintf(buf, "%04d%02d%02d %02d:%02d:%02d",
|
|
|
|
year, month, day, hour, minute, second);
|
|
|
|
/* now, convert this into a time() value: */
|
2001-08-30 18:48:34 -04:00
|
|
|
conn->data->info.filetime = curl_getdate(buf, &secs);
|
2001-08-23 02:10:01 -04:00
|
|
|
}
|
|
|
|
else {
|
|
|
|
infof(conn->data, "unsupported MDTM reply format\n");
|
|
|
|
}
|
|
|
|
}
|
|
|
|
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-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, "TYPE %s", ascii?"A":"I");
|
2001-08-23 02:10:01 -04:00
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2001-08-23 02:10:01 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
|
|
|
|
|
|
|
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,
|
2001-08-23 02:10:01 -04:00
|
|
|
ssize_t *size)
|
|
|
|
{
|
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);
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2001-08-23 02:10:01 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
|
|
|
|
|
|
|
if(ftpcode == 213) {
|
|
|
|
/* get the size from the ascii string: */
|
|
|
|
*size = atoi(buf+4);
|
|
|
|
}
|
|
|
|
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,
|
2001-10-02 05:40:06 -04:00
|
|
|
Curl_ipconnect *addr,
|
2001-09-28 04:58:18 -04:00
|
|
|
char *newhost, /* ascii version */
|
|
|
|
int port)
|
2001-09-28 03:46:39 -04:00
|
|
|
{
|
|
|
|
#ifndef ENABLE_IPV6
|
|
|
|
/*****************************************************************
|
|
|
|
*
|
|
|
|
* IPv4-only code section
|
|
|
|
*/
|
|
|
|
|
|
|
|
struct in_addr in;
|
|
|
|
struct hostent * answer;
|
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
#ifdef HAVE_INET_NTOA_R
|
2001-09-28 03:46:39 -04:00
|
|
|
char ntoa_buf[64];
|
|
|
|
#endif
|
2002-01-04 04:17:52 -05:00
|
|
|
/* The array size trick below is to make this a large chunk of memory
|
|
|
|
suitably 8-byte aligned on 64-bit platforms. This was thoughtfully
|
|
|
|
suggested by Philip Gladstone. */
|
|
|
|
long bigbuf[9000 / sizeof(long)];
|
2001-09-28 03:46:39 -04:00
|
|
|
|
|
|
|
#if defined(HAVE_INET_ADDR)
|
2001-11-28 07:16:52 -05:00
|
|
|
in_addr_t address;
|
2001-09-28 03:46:39 -04:00
|
|
|
# if defined(HAVE_GETHOSTBYADDR_R)
|
|
|
|
int h_errnop;
|
|
|
|
# endif
|
2002-01-04 04:17:52 -05:00
|
|
|
char *hostent_buf = (char *)bigbuf; /* get a char * to the buffer */
|
2001-09-28 03:46:39 -04:00
|
|
|
|
|
|
|
address = inet_addr(newhost);
|
|
|
|
# ifdef HAVE_GETHOSTBYADDR_R
|
|
|
|
|
|
|
|
# ifdef HAVE_GETHOSTBYADDR_R_5
|
2001-11-28 18:20:14 -05:00
|
|
|
/* AIX, Digital Unix (OSF1, Tru64) style:
|
2001-09-28 03:46:39 -04:00
|
|
|
extern int gethostbyaddr_r(char *addr, size_t len, int type,
|
|
|
|
struct hostent *htent, struct hostent_data *ht_data); */
|
|
|
|
|
|
|
|
/* Fred Noz helped me try this out, now it at least compiles! */
|
|
|
|
|
2001-11-28 18:20:14 -05:00
|
|
|
/* Bjorn Reese (November 28 2001):
|
|
|
|
The Tru64 man page on gethostbyaddr_r() says that
|
|
|
|
the hostent struct must be filled with zeroes before the call to
|
2002-09-20 10:40:14 -04:00
|
|
|
gethostbyaddr_r().
|
2001-11-28 18:20:14 -05:00
|
|
|
|
2002-09-20 10:40:14 -04:00
|
|
|
... as must be struct hostent_data Craig Markwardt 19 Sep 2002. */
|
|
|
|
|
|
|
|
memset(hostent_buf, 0, sizeof(struct hostent)+sizeof(struct hostent_data));
|
2001-11-28 18:20:14 -05:00
|
|
|
|
2001-09-28 03:46:39 -04:00
|
|
|
if(gethostbyaddr_r((char *) &address,
|
|
|
|
sizeof(address), AF_INET,
|
|
|
|
(struct hostent *)hostent_buf,
|
2002-04-04 01:07:56 -05:00
|
|
|
(struct hostent_data *)(hostent_buf + sizeof(*answer))))
|
2001-09-28 03:46:39 -04:00
|
|
|
answer=NULL;
|
2002-04-04 01:07:56 -05:00
|
|
|
else
|
|
|
|
answer=(struct hostent *)hostent_buf;
|
2001-09-28 03:46:39 -04:00
|
|
|
|
|
|
|
# endif
|
|
|
|
# ifdef HAVE_GETHOSTBYADDR_R_7
|
|
|
|
/* Solaris and IRIX */
|
|
|
|
answer = gethostbyaddr_r((char *) &address, sizeof(address), AF_INET,
|
2002-01-18 07:56:10 -05:00
|
|
|
(struct hostent *)bigbuf,
|
2001-09-28 03:46:39 -04:00
|
|
|
hostent_buf + sizeof(*answer),
|
2002-03-16 11:59:47 -05:00
|
|
|
sizeof(bigbuf) - sizeof(*answer),
|
2001-09-28 03:46:39 -04:00
|
|
|
&h_errnop);
|
|
|
|
# endif
|
|
|
|
# ifdef HAVE_GETHOSTBYADDR_R_8
|
|
|
|
/* Linux style */
|
|
|
|
if(gethostbyaddr_r((char *) &address, sizeof(address), AF_INET,
|
|
|
|
(struct hostent *)hostent_buf,
|
|
|
|
hostent_buf + sizeof(*answer),
|
2002-03-16 11:59:47 -05:00
|
|
|
sizeof(bigbuf) - sizeof(*answer),
|
2001-09-28 03:46:39 -04:00
|
|
|
&answer,
|
|
|
|
&h_errnop))
|
|
|
|
answer=NULL; /* error */
|
|
|
|
# endif
|
|
|
|
|
|
|
|
# else
|
|
|
|
answer = gethostbyaddr((char *) &address, sizeof(address), AF_INET);
|
|
|
|
# endif
|
|
|
|
#else
|
|
|
|
answer = NULL;
|
|
|
|
#endif
|
2001-10-02 05:40:06 -04:00
|
|
|
(void) memcpy(&in.s_addr, addr, sizeof (Curl_ipconnect));
|
2001-09-28 03:46:39 -04:00
|
|
|
infof(conn->data, "Connecting to %s (%s) port %u\n",
|
|
|
|
answer?answer->h_name:newhost,
|
|
|
|
#if defined(HAVE_INET_NTOA_R)
|
2001-09-28 04:58:18 -04:00
|
|
|
inet_ntoa_r(in, ntoa_buf, sizeof(ntoa_buf)),
|
2001-09-28 03:46:39 -04:00
|
|
|
#else
|
2001-09-28 04:58:18 -04:00
|
|
|
inet_ntoa(in),
|
2001-09-28 03:46:39 -04:00
|
|
|
#endif
|
2001-09-28 04:58:18 -04:00
|
|
|
port);
|
2001-09-28 03:46:39 -04:00
|
|
|
|
|
|
|
#else
|
|
|
|
/*****************************************************************
|
|
|
|
*
|
|
|
|
* IPv6-only code section
|
|
|
|
*/
|
|
|
|
char hbuf[NI_MAXHOST]; /* ~1KB */
|
|
|
|
char nbuf[NI_MAXHOST]; /* ~1KB */
|
|
|
|
char sbuf[NI_MAXSERV]; /* around 32 */
|
|
|
|
#ifdef NI_WITHSCOPEID
|
|
|
|
const int niflags = NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;
|
|
|
|
#else
|
|
|
|
const int niflags = NI_NUMERICHOST | NI_NUMERICSERV;
|
|
|
|
#endif
|
2001-09-28 05:02:57 -04:00
|
|
|
port = 0; /* unused, prevent warning */
|
2001-09-28 04:58:18 -04:00
|
|
|
if (getnameinfo(addr->ai_addr, addr->ai_addrlen,
|
2001-09-28 03:46:39 -04:00
|
|
|
nbuf, sizeof(nbuf), sbuf, sizeof(sbuf), niflags)) {
|
|
|
|
snprintf(nbuf, sizeof(nbuf), "?");
|
|
|
|
snprintf(sbuf, sizeof(sbuf), "?");
|
|
|
|
}
|
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
if (getnameinfo(addr->ai_addr, addr->ai_addrlen,
|
2001-09-28 03:46:39 -04:00
|
|
|
hbuf, sizeof(hbuf), NULL, 0, 0)) {
|
2001-09-28 05:02:57 -04:00
|
|
|
infof(conn->data, "Connecting to %s (%s) port %s\n", nbuf, newhost, sbuf);
|
|
|
|
}
|
2001-09-28 03:46:39 -04:00
|
|
|
else {
|
|
|
|
infof(conn->data, "Connecting to %s (%s) port %s\n", hbuf, nbuf, sbuf);
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
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;
|
2000-05-22 10:12:12 -04:00
|
|
|
int portsock=-1;
|
2001-09-28 04:58:18 -04:00
|
|
|
ssize_t nread;
|
|
|
|
char *buf = data->state.buffer; /* this is our buffer */
|
|
|
|
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;
|
2001-02-05 18:04:44 -05:00
|
|
|
#ifdef NI_WITHSCOPEID
|
2001-09-28 04:58:18 -04:00
|
|
|
const int niflags = NI_NUMERICHOST | NI_NUMERICSERV | NI_WITHSCOPEID;
|
2001-02-05 18:04:44 -05:00
|
|
|
#else
|
2001-09-28 04:58:18 -04:00
|
|
|
const int niflags = NI_NUMERICHOST | NI_NUMERICSERV;
|
2001-02-05 18:04:44 -05:00
|
|
|
#endif
|
2001-09-28 04:58:18 -04:00
|
|
|
unsigned char *ap;
|
|
|
|
unsigned char *pp;
|
|
|
|
char portmsgbuf[4096], tmp[4096];
|
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;
|
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);
|
|
|
|
if (getsockname(conn->firstsocket, (struct sockaddr *)&ss, &sslen) < 0)
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
|
|
|
|
if (getnameinfo((struct sockaddr *)&ss, sslen, hbuf, sizeof(hbuf), NULL, 0,
|
|
|
|
niflags))
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
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;
|
|
|
|
this way can be used if sockaddr_storage is properly defined, as glibc
|
|
|
|
2.1.X doesn't do*/
|
|
|
|
hints.ai_socktype = SOCK_STREAM;
|
|
|
|
hints.ai_flags = AI_PASSIVE;
|
2001-10-04 09:25:12 -04:00
|
|
|
|
|
|
|
if (getaddrinfo(hbuf, (char *)"0", &hints, &res))
|
2001-09-28 04:58:18 -04:00
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
|
|
|
|
portsock = -1;
|
|
|
|
for (ai = res; ai; ai = ai->ai_next) {
|
|
|
|
portsock = socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
|
|
|
|
if (portsock < 0)
|
|
|
|
continue;
|
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) {
|
|
|
|
sclose(portsock);
|
|
|
|
portsock = -1;
|
|
|
|
continue;
|
2001-02-05 18:04:44 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
|
|
|
|
if (listen(portsock, 1) < 0) {
|
|
|
|
sclose(portsock);
|
|
|
|
portsock = -1;
|
|
|
|
continue;
|
2001-02-05 18:04:44 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2001-10-04 09:25:12 -04:00
|
|
|
freeaddrinfo(res);
|
2001-09-28 04:58:18 -04:00
|
|
|
if (portsock < 0) {
|
2002-06-12 03:44:22 -04:00
|
|
|
failf(data, "%s", strerror(errno));
|
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) {
|
2002-06-12 03:44:22 -04:00
|
|
|
failf(data, "%s", strerror(errno));
|
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
|
|
|
for (modep = (char **)mode; modep && *modep; modep++) {
|
|
|
|
int lprtaf, eprtaf;
|
2002-10-28 14:20:59 -05:00
|
|
|
int alen=0, plen=0;
|
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,
|
|
|
|
portmsgbuf, sizeof(portmsgbuf), tmp, sizeof(tmp), niflags))
|
|
|
|
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, '%');
|
2001-09-04 22:49:04 -04: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;
|
2001-09-28 04:58:18 -04:00
|
|
|
} else if (strcmp(*modep, "LPRT") == 0 ||
|
|
|
|
strcmp(*modep, "PORT") == 0) {
|
|
|
|
int i;
|
|
|
|
|
|
|
|
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]);
|
|
|
|
|
|
|
|
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
|
|
|
}
|
|
|
|
|
|
|
|
if (strcmp(*modep, "LPRT") == 0) {
|
|
|
|
snprintf(tmp, sizeof(tmp), ",%d", plen);
|
|
|
|
|
|
|
|
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]);
|
|
|
|
|
|
|
|
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
|
|
|
}
|
2001-09-28 04:58:18 -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
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2001-09-28 04:58:18 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
|
|
|
|
|
|
|
if (ftpcode != 200) {
|
|
|
|
failf(data, "Server does not grok %s", *modep);
|
|
|
|
continue;
|
2001-02-05 18:04:44 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
else
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!*modep) {
|
|
|
|
sclose(portsock);
|
|
|
|
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 */
|
|
|
|
conn->secondarysocket = portsock;
|
|
|
|
|
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;
|
2002-11-05 06:07:49 -05:00
|
|
|
struct Curl_dns_entry *h=NULL;
|
2001-09-28 04:58:18 -04:00
|
|
|
unsigned short porttouse;
|
|
|
|
char myhost[256] = "";
|
2002-08-01 10:25:12 -04:00
|
|
|
bool sa_filled_in = FALSE;
|
2001-09-28 04:58:18 -04:00
|
|
|
|
|
|
|
if(data->set.ftpport) {
|
|
|
|
if(Curl_if2ip(data->set.ftpport, myhost, sizeof(myhost))) {
|
2002-04-25 15:26:29 -04:00
|
|
|
h = Curl_resolv(data, myhost, 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
else {
|
2002-01-03 05:22:59 -05:00
|
|
|
int len = strlen(data->set.ftpport);
|
|
|
|
if(len>1)
|
2002-04-25 15:26:29 -04:00
|
|
|
h = Curl_resolv(data, data->set.ftpport, 0);
|
2001-09-28 04:58:18 -04:00
|
|
|
if(h)
|
|
|
|
strcpy(myhost, data->set.ftpport); /* buffer overflow risk */
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
|
|
|
if(! *myhost) {
|
2002-08-01 10:25:12 -04:00
|
|
|
/* pick a suitable default here */
|
|
|
|
|
|
|
|
socklen_t sslen;
|
|
|
|
|
|
|
|
sslen = sizeof(sa);
|
2002-08-01 10:30:42 -04:00
|
|
|
if (getsockname(conn->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
|
|
|
|
2002-11-05 05:51:41 -05:00
|
|
|
if(h)
|
2002-11-11 17:36:00 -05:00
|
|
|
/* when we return from here, we can forget about this */
|
|
|
|
Curl_resolv_unlock(h);
|
2002-11-05 05:51:41 -05:00
|
|
|
|
2002-08-01 10:25:12 -04:00
|
|
|
if ( h || sa_filled_in) {
|
2001-09-28 04:58:18 -04:00
|
|
|
if( (portsock = socket(AF_INET, SOCK_STREAM, 0)) >= 0 ) {
|
2002-01-02 19:51:33 -05:00
|
|
|
int size;
|
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 */
|
|
|
|
conn->secondarysocket = portsock;
|
|
|
|
|
2002-08-01 10:25:12 -04:00
|
|
|
if(!sa_filled_in) {
|
|
|
|
memset((char *)&sa, 0, sizeof(sa));
|
|
|
|
memcpy((char *)&sa.sin_addr,
|
2002-11-05 06:07:49 -05:00
|
|
|
h->addr->h_addr,
|
|
|
|
h->addr->h_length);
|
2002-08-01 10:25:12 -04:00
|
|
|
sa.sin_family = AF_INET;
|
|
|
|
sa.sin_addr.s_addr = INADDR_ANY;
|
|
|
|
}
|
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
sa.sin_port = 0;
|
|
|
|
size = sizeof(sa);
|
|
|
|
|
|
|
|
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);
|
|
|
|
|
|
|
|
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 {
|
|
|
|
failf(data, "could't find my own IP address (%s)", myhost);
|
|
|
|
return CURLE_FTP_PORT_FAILED;
|
|
|
|
}
|
|
|
|
{
|
|
|
|
#ifdef HAVE_INET_NTOA_R
|
|
|
|
char ntoa_buf[64];
|
|
|
|
#endif
|
|
|
|
struct in_addr in;
|
|
|
|
unsigned short ip[5];
|
2002-08-01 10:25:12 -04:00
|
|
|
(void) memcpy(&in.s_addr,
|
2002-11-05 06:07:49 -05:00
|
|
|
h?*h->addr->h_addr_list:(char *)&sa.sin_addr.s_addr,
|
2002-08-01 10:30:42 -04:00
|
|
|
sizeof (in.s_addr));
|
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
#ifdef HAVE_INET_NTOA_R
|
|
|
|
/* ignore the return code from inet_ntoa_r() as it is int or
|
|
|
|
char * depending on system */
|
|
|
|
inet_ntoa_r(in, ntoa_buf, sizeof(ntoa_buf));
|
|
|
|
sscanf( ntoa_buf, "%hu.%hu.%hu.%hu",
|
|
|
|
&ip[0], &ip[1], &ip[2], &ip[3]);
|
2000-05-29 18:51:13 -04:00
|
|
|
#else
|
2001-09-28 04:58:18 -04:00
|
|
|
sscanf( inet_ntoa(in), "%hu.%hu.%hu.%hu",
|
|
|
|
&ip[0], &ip[1], &ip[2], &ip[3]);
|
2000-05-29 18:51:13 -04:00
|
|
|
#endif
|
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);
|
|
|
|
|
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;
|
2001-09-28 04:58:18 -04:00
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2001-09-28 04:58:18 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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;
|
2001-11-26 19:48:45 -05:00
|
|
|
Curl_ipconnect *conninfo;
|
|
|
|
|
|
|
|
/*
|
|
|
|
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
|
|
|
#if 1
|
|
|
|
const char *mode[] = { "EPSV", "PASV", NULL };
|
|
|
|
int results[] = { 229, 227, 0 };
|
|
|
|
#else
|
2001-02-05 18:04:44 -05:00
|
|
|
#if 0
|
2001-09-28 04:58:18 -04:00
|
|
|
char *mode[] = { "EPSV", "LPSV", "PASV", NULL };
|
|
|
|
int results[] = { 229, 228, 227, 0 };
|
2001-02-05 18:04:44 -05:00
|
|
|
#else
|
2001-09-28 04:58:18 -04:00
|
|
|
const char *mode[] = { "PASV", NULL };
|
|
|
|
int results[] = { 227, 0 };
|
2001-11-28 08:05:39 -05:00
|
|
|
#endif
|
2001-02-05 18:04:44 -05:00
|
|
|
#endif
|
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 */
|
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;
|
2001-09-28 04:58:18 -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;
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2001-09-28 04:58:18 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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"
|
|
|
|
*/
|
1999-12-29 09:20:26 -05: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
|
|
|
|
2001-09-28 04:58:18 -04:00
|
|
|
sprintf(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-28 08:05:39 -05:00
|
|
|
#if 1
|
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])) {
|
|
|
|
/* the four separators should be identical */
|
|
|
|
newport = num;
|
|
|
|
|
|
|
|
/* we should use the same host we already are connected to */
|
2001-11-28 08:05:39 -05:00
|
|
|
newhostp = conn->name;
|
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
|
|
|
}
|
|
|
|
#endif
|
|
|
|
else
|
|
|
|
return CURLE_FTP_CANT_RECONNECT;
|
|
|
|
|
|
|
|
if(data->change.proxy) {
|
|
|
|
/*
|
|
|
|
* 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
|
|
|
*/
|
2002-04-25 15:00:57 -04:00
|
|
|
addr = Curl_resolv(data, conn->proxyhost, conn->port);
|
2001-11-26 19:48:45 -05:00
|
|
|
connectport =
|
2002-04-25 15:00:57 -04:00
|
|
|
(unsigned short)conn->port; /* we connect to the proxy's port */
|
|
|
|
|
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 */
|
2002-04-25 15:00:57 -04:00
|
|
|
addr = Curl_resolv(data, newhostp, newport);
|
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 */
|
|
|
|
}
|
2001-09-28 04:58:18 -04:00
|
|
|
|
2001-11-26 19:48:45 -05:00
|
|
|
result = Curl_connecthost(conn,
|
|
|
|
addr,
|
|
|
|
connectport,
|
|
|
|
&conn->secondarysocket,
|
2002-08-12 05:43:20 -04:00
|
|
|
&conninfo,
|
|
|
|
connected);
|
|
|
|
|
2002-11-11 17:36:00 -05:00
|
|
|
Curl_resolv_unlock(addr); /* we're done using this address */
|
2002-11-05 05:51:41 -05:00
|
|
|
|
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.
|
|
|
|
*/
|
2001-11-26 19:48:45 -05:00
|
|
|
|
|
|
|
if((CURLE_OK == result) &&
|
|
|
|
data->set.verbose)
|
|
|
|
/* this just dumps information about this second connection */
|
2002-03-20 05:52:24 -05:00
|
|
|
ftp_pasv_verbose(conn, conninfo, newhostp, connectport);
|
2001-11-26 19:48:45 -05:00
|
|
|
|
|
|
|
if(CURLE_OK != result)
|
|
|
|
return result;
|
2001-10-02 05:40:06 -04:00
|
|
|
|
2001-11-26 19:48:45 -05:00
|
|
|
if (data->set.tunnel_thru_httpproxy) {
|
|
|
|
/* We want "seamless" FTP operations through HTTP proxy tunnel */
|
|
|
|
result = Curl_ConnectHTTPProxyTunnel(conn, 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
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
|
|
|
|
/* the ftp struct is already inited in ftp_connect() */
|
|
|
|
struct FTP *ftp = conn->proto.ftp;
|
|
|
|
long *bytecountp = ftp->bytecountp;
|
|
|
|
|
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 */
|
2001-11-13 07:46:29 -05:00
|
|
|
ssize_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? */
|
|
|
|
int passed=0;
|
|
|
|
/* 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 {
|
2001-04-18 03:25:11 -04:00
|
|
|
int readthisamountnow = (conn->resume_from - passed);
|
1999-12-29 09:20:26 -05:00
|
|
|
int actuallyread;
|
|
|
|
|
|
|
|
if(readthisamountnow > BUFSIZE)
|
|
|
|
readthisamountnow = BUFSIZE;
|
|
|
|
|
|
|
|
actuallyread =
|
2001-08-30 18:48:34 -04:00
|
|
|
data->set.fread(data->state.buffer, 1, readthisamountnow,
|
|
|
|
data->set.in);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
|
|
|
passed += actuallyread;
|
|
|
|
if(actuallyread != readthisamountnow) {
|
2001-12-11 08:13:01 -05:00
|
|
|
failf(data, "Could only read %d 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);
|
|
|
|
|
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! */
|
|
|
|
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 */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
/* Send everything on data->set.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
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2000-07-25 08:12:29 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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. */
|
2001-09-28 04:58:18 -04:00
|
|
|
result = AllowServerConnect(data, conn, conn->secondarysocket);
|
1999-12-29 09:20:26 -05:00
|
|
|
if( result )
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
*bytecountp=0;
|
|
|
|
|
|
|
|
/* When we know we're uploading a specified file, we can get the file
|
|
|
|
size prior to the actual upload. */
|
|
|
|
|
2001-08-30 18:48:34 -04: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 */
|
2001-02-20 12:35:51 -05:00
|
|
|
conn->secondarysocket, bytecountp);
|
1999-12-29 09:20:26 -05:00
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
|
|
|
|
}
|
2001-12-20 06:22:01 -05:00
|
|
|
else if(!data->set.no_body) {
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Retrieve file or directory */
|
|
|
|
bool dirlist=FALSE;
|
|
|
|
long downloadsize=-1;
|
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
if(conn->bits.use_range && conn->range) {
|
2000-05-22 10:12:12 -04:00
|
|
|
long from, to;
|
1999-12-29 09:20:26 -05:00
|
|
|
int totalsize=-1;
|
|
|
|
char *ptr;
|
|
|
|
char *ptr2;
|
|
|
|
|
2001-04-18 03:25:11 -04:00
|
|
|
from=strtol(conn->range, &ptr, 0);
|
1999-12-29 09:20:26 -05:00
|
|
|
while(ptr && *ptr && (isspace((int)*ptr) || (*ptr=='-')))
|
|
|
|
ptr++;
|
|
|
|
to=strtol(ptr, &ptr2, 0);
|
|
|
|
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;
|
2000-05-22 10:12:12 -04:00
|
|
|
infof(data, "FTP RANGE %d 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;
|
2000-05-22 10:12:12 -04:00
|
|
|
infof(data, "FTP RANGE the last %d 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;
|
|
|
|
infof(data, "FTP RANGE from %d getting %d bytes\n", from,
|
|
|
|
conn->maxdownload);
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
infof(data, "range-download from %d to %d, totally %d bytes\n",
|
|
|
|
from, to, totalsize);
|
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 {
|
2001-11-28 08:05:39 -05:00
|
|
|
ssize_t foundsize;
|
|
|
|
|
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-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);
|
|
|
|
if(CURLE_OK == result)
|
|
|
|
downloadsize = foundsize;
|
|
|
|
|
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) {
|
2000-05-22 10:12:12 -04:00
|
|
|
failf(data, "Offset (%d) was beyond file size (%d)",
|
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) {
|
2000-05-22 10:12:12 -04:00
|
|
|
failf(data, "Offset (%d) was beyond file size (%d)",
|
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;
|
|
|
|
}
|
2001-04-17 09:21:13 -04:00
|
|
|
|
1999-12-29 09:20:26 -05:00
|
|
|
/* Set resume file transfer offset */
|
|
|
|
infof(data, "Instructs server to resume from offset %d\n",
|
2001-04-18 03:25:11 -04:00
|
|
|
conn->resume_from);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-10-31 09:56:12 -05:00
|
|
|
FTPSENDF(conn, "REST %d", conn->resume_from);
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2000-07-25 08:12:29 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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
|
|
|
}
|
|
|
|
|
2001-09-28 05:15:19 -04:00
|
|
|
nread = Curl_GetFTPResponse(buf, conn, &ftpcode);
|
2000-07-25 08:12:29 -04:00
|
|
|
if(nread < 0)
|
|
|
|
return CURLE_OPERATION_TIMEOUTED;
|
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)
|
|
|
|
|
|
|
|
B:
|
|
|
|
150 Opening ASCII mode data connection for /bin/ls
|
|
|
|
|
|
|
|
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).
|
|
|
|
|
|
|
|
E:
|
|
|
|
125 Data connection already open; Transfer starting. */
|
|
|
|
|
|
|
|
int size=-1; /* default unknown size */
|
|
|
|
|
2000-07-25 08:12:29 -04:00
|
|
|
if(!dirlist &&
|
2001-08-30 18:48:34 -04:00
|
|
|
!data->set.ftp_ascii &&
|
2000-07-25 08:12:29 -04:00
|
|
|
(-1 == downloadsize)) {
|
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--) {
|
|
|
|
int index=bytes-buf;
|
|
|
|
/* this is a hint there is size information in there! ;-) */
|
|
|
|
while(--index) {
|
|
|
|
/* 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! */
|
|
|
|
size = atoi(bytes);
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else if(downloadsize > -1)
|
|
|
|
size = downloadsize;
|
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
if(data->set.ftp_use_port) {
|
2001-09-28 04:58:18 -04:00
|
|
|
result = AllowServerConnect(data, conn, conn->secondarysocket);
|
1999-12-29 09:20:26 -05:00
|
|
|
if( result )
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
infof(data, "Getting file with size: %d\n", size);
|
|
|
|
|
|
|
|
/* FTP download: */
|
2001-02-20 12:35:51 -05:00
|
|
|
result=Curl_Transfer(conn, 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 {
|
|
|
|
failf(data, "%s", buf+4);
|
2000-05-22 10:12:12 -04:00
|
|
|
return CURLE_FTP_COULDNT_RETR_FILE;
|
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 */
|
|
|
|
|
|
|
|
/* the ftp struct is already inited in ftp_connect() */
|
|
|
|
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;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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) {
|
2002-08-12 05:43:20 -04:00
|
|
|
if ((result = ftp_cwd(conn, ftp->entrypath)) != CURLE_OK)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* change directory first! */
|
|
|
|
if(ftp->dir && ftp->dir[0]) {
|
|
|
|
if ((result = ftp_cwd(conn, ftp->dir)) != CURLE_OK)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Requested time of file? */
|
|
|
|
if(data->set.get_filetime && ftp->file) {
|
|
|
|
result = ftp_getfiletime(conn, ftp->file);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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. */
|
|
|
|
if(data->set.no_body && data->set.include_header && ftp->file) {
|
|
|
|
/* 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! */
|
|
|
|
ssize_t filesize;
|
|
|
|
|
|
|
|
ftp->no_transfer = TRUE; /* this means no actual transfer is made */
|
|
|
|
|
|
|
|
/* 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) {
|
|
|
|
sprintf(buf, "Content-Length: %d\r\n", filesize);
|
|
|
|
result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* 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
|
|
|
|
if(data->set.get_filetime && data->info.filetime) {
|
|
|
|
struct tm *tm;
|
|
|
|
#ifdef HAVE_LOCALTIME_R
|
|
|
|
struct tm buffer;
|
|
|
|
tm = (struct tm *)localtime_r(&data->info.filetime, &buffer);
|
|
|
|
#else
|
|
|
|
tm = localtime((unsigned long *)&data->info.filetime);
|
|
|
|
#endif
|
|
|
|
/* format: "Tue, 15 Nov 1994 12:45:26 GMT" */
|
|
|
|
strftime(buf, BUFSIZE-1, "Last-Modified: %a, %d %b %Y %H:%M:%S %Z\r\n",
|
|
|
|
tm);
|
|
|
|
result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
|
|
|
|
if(result)
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
return CURLE_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
if(data->set.no_body)
|
|
|
|
/* 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);
|
|
|
|
if(connected)
|
|
|
|
infof(data, "Connected the data stream with PASV!\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
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
|
|
|
{
|
2000-05-22 10:12:12 -04:00
|
|
|
CURLcode retcode;
|
2002-08-12 05:43:20 -04:00
|
|
|
bool connected;
|
1999-12-29 09:20:26 -05:00
|
|
|
|
2001-08-30 18:48:34 -04:00
|
|
|
struct SessionHandle *data = conn->data;
|
2000-05-22 10:12:12 -04:00
|
|
|
struct FTP *ftp;
|
|
|
|
int dirlength=0; /* 0 forces strlen() */
|
|
|
|
|
|
|
|
/* the ftp struct is already inited in ftp_connect() */
|
2001-02-20 12:35:51 -05:00
|
|
|
ftp = conn->proto.ftp;
|
2000-05-22 10:12:12 -04:00
|
|
|
|
|
|
|
/* We split the path into dir and file parts *before* we URLdecode
|
|
|
|
it */
|
|
|
|
ftp->file = strrchr(conn->ppath, '/');
|
|
|
|
if(ftp->file) {
|
2000-11-21 14:04:25 -05:00
|
|
|
if(ftp->file != conn->ppath)
|
|
|
|
dirlength=ftp->file-conn->ppath; /* don't count the traling slash */
|
|
|
|
|
2000-05-22 10:12:12 -04:00
|
|
|
ftp->file++; /* point to the first letter in the file name part or
|
|
|
|
remain NULL */
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
ftp->file = conn->ppath; /* there's only a file part */
|
|
|
|
}
|
|
|
|
|
|
|
|
if(*ftp->file) {
|
|
|
|
ftp->file = curl_unescape(ftp->file, 0);
|
|
|
|
if(NULL == ftp->file) {
|
|
|
|
failf(data, "no memory");
|
|
|
|
return CURLE_OUT_OF_MEMORY;
|
|
|
|
}
|
1999-12-29 09:20:26 -05:00
|
|
|
}
|
|
|
|
else
|
2000-05-22 10:12:12 -04:00
|
|
|
ftp->file=NULL; /* instead of point to a zero byte, we make it a NULL
|
|
|
|
pointer */
|
|
|
|
|
|
|
|
ftp->urlpath = conn->ppath;
|
|
|
|
if(dirlength) {
|
|
|
|
ftp->dir = curl_unescape(ftp->urlpath, dirlength);
|
|
|
|
if(NULL == ftp->dir) {
|
|
|
|
if(ftp->file)
|
|
|
|
free(ftp->file);
|
|
|
|
failf(data, "no memory");
|
|
|
|
return CURLE_OUT_OF_MEMORY; /* failure */
|
|
|
|
}
|
|
|
|
}
|
|
|
|
else
|
|
|
|
ftp->dir = NULL;
|
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
retcode = ftp_perform(conn, &connected);
|
2000-11-21 14:04:25 -05:00
|
|
|
|
2002-08-12 05:43:20 -04:00
|
|
|
if(CURLE_OK == retcode) {
|
|
|
|
if(connected)
|
|
|
|
retcode = Curl_ftp_nextconnect(conn);
|
|
|
|
else
|
|
|
|
/* since we didn't connect now, we want do_more to get called */
|
2002-11-11 18:03:03 -05:00
|
|
|
conn->bits.do_more = TRUE;
|
2002-08-12 05:43:20 -04:00
|
|
|
}
|
2000-11-21 14:04:25 -05: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];
|
2002-01-16 09:46:00 -05:00
|
|
|
ssize_t write_len;
|
|
|
|
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);
|
2002-04-12 03:21:11 -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
|
|
|
|
2002-01-16 09:46:00 -05:00
|
|
|
do {
|
|
|
|
res = Curl_write(conn, conn->firstsocket, sptr, write_len,
|
|
|
|
&bytes_written);
|
|
|
|
|
|
|
|
if(CURLE_OK != res)
|
|
|
|
break;
|
|
|
|
|
2002-04-12 03:21:11 -04:00
|
|
|
if(conn->data->set.verbose)
|
|
|
|
Curl_debug(conn->data, CURLINFO_HEADER_OUT, sptr, bytes_written);
|
|
|
|
|
2002-01-16 09:46:00 -05:00
|
|
|
if(bytes_written != write_len) {
|
|
|
|
write_len -= bytes_written;
|
|
|
|
sptr += bytes_written;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
break;
|
|
|
|
} while(1);
|
|
|
|
|
|
|
|
return res;
|
2001-01-05 05:11:41 -05:00
|
|
|
}
|
|
|
|
|
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;
|
|
|
|
|
2001-04-03 06:20:23 -04:00
|
|
|
/* The FTP session may or may not have been allocated/setup at this point! */
|
|
|
|
if(ftp) {
|
|
|
|
if(ftp->entrypath)
|
|
|
|
free(ftp->entrypath);
|
2001-12-03 08:48:59 -05:00
|
|
|
if(ftp->cache)
|
|
|
|
free(ftp->cache);
|
2002-08-12 05:43:20 -04:00
|
|
|
if(ftp->file)
|
|
|
|
free(ftp->file);
|
|
|
|
if(ftp->dir)
|
|
|
|
free(ftp->dir);
|
|
|
|
|
|
|
|
ftp->file = ftp->dir = NULL; /* zero */
|
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
|
|
|
|
|
|
|
/*
|
2001-09-06 23:30:30 -04:00
|
|
|
* local variables:
|
|
|
|
* eval: (load-file "../curl-mode.el")
|
|
|
|
* end:
|
2001-10-11 05:32:19 -04:00
|
|
|
* vim600: fdm=marker
|
|
|
|
* vim: et sw=2 ts=2 sts=2 tw=78
|
2001-09-04 22:49:04 -04:00
|
|
|
*/
|
2002-06-11 07:13:01 -04:00
|
|
|
|
|
|
|
#endif /* CURL_DISABLE_FTP */
|