command on subsequent requests on a re-used connection unless it has to.
Changelog
Daniel (19 August 2006)
+- Based on a patch by Armel Asselin, the FTP code no longer re-issues the TYPE
+ command on subsequent requests on a re-used connection unless it has to.
+
- Armel Asselin fixed a crash in the FTP code when using SINGLECWD mode and
files in the root directory.
This release includes the following changes:
+ o (FTP) libcurl avoids sending TYPE if the desired type was already set
o CURLOPT_PREQUOTE works even when CURLOPT_NOBODY is set true
This release includes the following bugfixes:
};
static CURLcode
-process_zlib_error(struct SessionHandle *data,
- z_stream *z)
+process_zlib_error(struct connectdata *conn, z_stream *z)
{
+ struct SessionHandle *data = conn->data;
if (z->msg)
failf (data, "Error while processing content unencoding: %s",
z->msg);
}
static CURLcode
-inflate_stream(struct SessionHandle *data,
+inflate_stream(struct connectdata *conn,
struct Curl_transfer_keeper *k)
{
int allow_restart = 1;
if (status == Z_OK || status == Z_STREAM_END) {
allow_restart = 0;
if(DSIZ - z->avail_out) {
- result = Curl_client_write(data, CLIENTWRITE_BODY, decomp,
+ result = Curl_client_write(conn, CLIENTWRITE_BODY, decomp,
DSIZ - z->avail_out);
/* if !CURLE_OK, clean up, return */
if (result) {
if (inflateEnd(z) == Z_OK)
return exit_zlib(z, &k->zlib_init, result);
else
- return exit_zlib(z, &k->zlib_init, process_zlib_error(data, z));
+ return exit_zlib(z, &k->zlib_init, process_zlib_error(conn, z));
}
/* Done with these bytes, exit */
inflateReset(z);
if (inflateInit2(z, -MAX_WBITS) != Z_OK) {
- return process_zlib_error(data, z);
+ return process_zlib_error(conn, z);
}
z->next_in = orig_in;
z->avail_in = nread;
}
else { /* Error; exit loop, handle below */
free(decomp);
- return exit_zlib(z, &k->zlib_init, process_zlib_error(data, z));
+ return exit_zlib(z, &k->zlib_init, process_zlib_error(conn, z));
}
}
/* Will never get here */
}
CURLcode
-Curl_unencode_deflate_write(struct SessionHandle *data,
+Curl_unencode_deflate_write(struct connectdata *conn,
struct Curl_transfer_keeper *k,
ssize_t nread)
{
z->next_in = NULL;
z->avail_in = 0;
if (inflateInit(z) != Z_OK)
- return process_zlib_error(data, z);
+ return process_zlib_error(conn, z);
k->zlib_init = ZLIB_INIT;
}
z->avail_in = (uInt)nread;
/* Now uncompress the data */
- return inflate_stream(data, k);
+ return inflate_stream(conn, k);
}
#ifdef OLD_ZLIB_SUPPORT
#endif
CURLcode
-Curl_unencode_gzip_write(struct SessionHandle *data,
+Curl_unencode_gzip_write(struct connectdata *conn,
struct Curl_transfer_keeper *k,
ssize_t nread)
{
if (strcmp(zlibVersion(), "1.2.0.4") >= 0) {
/* zlib ver. >= 1.2.0.4 supports transparent gzip decompressing */
if (inflateInit2(z, MAX_WBITS+32) != Z_OK) {
- return process_zlib_error(data, z);
+ return process_zlib_error(conn, z);
}
k->zlib_init = ZLIB_INIT_GZIP; /* Transparent gzip decompress state */
} else {
/* we must parse the gzip header ourselves */
if (inflateInit2(z, -MAX_WBITS) != Z_OK) {
- return process_zlib_error(data, z);
+ return process_zlib_error(conn, z);
}
k->zlib_init = ZLIB_INIT; /* Initial call state */
}
z->next_in = (Bytef *)k->str;
z->avail_in = (uInt)nread;
/* Now uncompress the data */
- return inflate_stream(data, k);
+ return inflate_stream(conn, k);
}
#ifndef OLD_ZLIB_SUPPORT
case GZIP_BAD:
default:
- return exit_zlib(z, &k->zlib_init, process_zlib_error(data, z));
+ return exit_zlib(z, &k->zlib_init, process_zlib_error(conn, z));
}
}
case GZIP_BAD:
default:
free(z->next_in);
- return exit_zlib(z, &k->zlib_init, process_zlib_error(data, z));
+ return exit_zlib(z, &k->zlib_init, process_zlib_error(conn, z));
}
}
}
/* We've parsed the header, now uncompress the data */
- return inflate_stream(data, k);
+ return inflate_stream(conn, k);
#endif
}
#endif /* HAVE_LIBZ */
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2004, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
#define ALL_CONTENT_ENCODINGS "identity"
#endif
-CURLcode Curl_unencode_deflate_write(struct SessionHandle *data,
+CURLcode Curl_unencode_deflate_write(struct connectdata *conn,
struct Curl_transfer_keeper *k,
ssize_t nread);
CURLcode
-Curl_unencode_gzip_write(struct SessionHandle *data,
+Curl_unencode_gzip_write(struct connectdata *conn,
struct Curl_transfer_keeper *k,
ssize_t nread);
CURLcode result;
snprintf(buf, sizeof(data->state.buffer),
"Content-Length: %" FORMAT_OFF_T "\r\n", expected_size);
- result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
+ result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
if(result)
return result;
- result = Curl_client_write(data, CLIENTWRITE_BOTH,
+ result = Curl_client_write(conn, CLIENTWRITE_BOTH,
(char *)"Accept-ranges: bytes\r\n", 0);
if(result)
return result;
tm->tm_hour,
tm->tm_min,
tm->tm_sec);
- result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
+ result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
}
return result;
}
bytecount += nread;
- res = Curl_client_write(data, CLIENTWRITE_BODY, buf, nread);
+ res = Curl_client_write(conn, CLIENTWRITE_BODY, buf, nread);
if(res)
return res;
static CURLcode ftp_state_post_cwd(struct connectdata *conn);
static CURLcode ftp_state_quote(struct connectdata *conn,
bool init, ftpstate instate);
+static CURLcode ftp_nb_type(struct connectdata *conn,
+ bool ascii, ftpstate state);
+static int ftp_need_type(struct connectdata *conn,
+ bool ascii);
/* easy-to-use macro: */
#define FTPSENDF(x,y,z) if((result = Curl_ftpsendf(x,y,z))) return result
* for "headers". The response lines can be seen as a kind of
* headers.
*/
- result = Curl_client_write(data, CLIENTWRITE_HEADER,
+ result = Curl_client_write(conn, CLIENTWRITE_HEADER,
ftp->linestart_resp, perline);
if(result)
return result;
* for "headers". The response lines can be seen as a kind of
* headers.
*/
- result = Curl_client_write(data, CLIENTWRITE_HEADER,
+ result = Curl_client_write(conn, CLIENTWRITE_HEADER,
line_start, perline);
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(conn->bits.no_body && data->set.include_header && ftp->file) {
+ if(conn->bits.no_body && data->set.include_header && ftp->file &&
+ ftp_need_type(conn, data->set.prefer_ascii)) {
/* 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! */
/* Some servers return different sizes for different modes, and thus we
must set the proper type before we check the size */
- NBFTPSENDF(conn, "TYPE %c",
- data->set.ftp_ascii?'A':'I');
- state(conn, FTP_TYPE);
- /* keep track of our current transfer type */
- data->ftp_in_ascii_mode = data->set.ftp_ascii;
+ result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_TYPE);
+ if (result)
+ return result;
}
else
result = ftp_state_post_type(conn);
tm->tm_hour,
tm->tm_min,
tm->tm_sec);
- result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
+ result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
if(result)
return result;
} /* end of a ridiculous amount of conditionals */
if(-1 != filesize) {
snprintf(buf, sizeof(data->state.buffer),
"Content-Length: %" FORMAT_OFF_T "\r\n", filesize);
- result = Curl_client_write(data, CLIENTWRITE_BOTH, buf, 0);
+ result = Curl_client_write(conn, CLIENTWRITE_BOTH, buf, 0);
if(result)
return result;
}
case FTP_REST:
default:
if (ftpcode == 350) {
- result = Curl_client_write(conn->data, CLIENTWRITE_BOTH,
+ result = Curl_client_write(conn, CLIENTWRITE_BOTH,
(char *)"Accept-ranges: bytes\r\n", 0);
if(result)
return result;
*/
if((instate != FTP_LIST) &&
- !data->set.ftp_ascii &&
+ !data->set.prefer_ascii &&
(ftp->downloadsize < 1)) {
/*
* It seems directory listings either don't show the size or very
ssize_t nread;
CURLcode result;
- FTPSENDF(conn, "TYPE %s", ascii?"A":"I");
+ FTPSENDF(conn, "TYPE %c", ascii?'A':'I');
result = Curl_GetFTPResponse(&nread, conn, &ftpcode);
if(result)
return ascii? CURLE_FTP_COULDNT_SET_ASCII:CURLE_FTP_COULDNT_SET_BINARY;
}
/* keep track of our current transfer type */
- data->ftp_in_ascii_mode = ascii;
+ conn->proto.ftp->transfertype = ascii?'A':'I';
+
+ return CURLE_OK;
+}
+
+
+/***********************************************************************
+ *
+ * ftp_need_type()
+ *
+ * Returns TRUE if we in the current situation should send TYPE
+ */
+static int ftp_need_type(struct connectdata *conn,
+ bool ascii_wanted)
+{
+ return conn->proto.ftp->transfertype != (ascii_wanted?'A':'I');
+}
+
+/***********************************************************************
+ *
+ * ftp_nb_type()
+ *
+ * Set TYPE. We only deal with ASCII or BINARY so this function
+ * sets one of them.
+ * If the transfer type is not sent, simulate on OK response in newstate
+ */
+static CURLcode ftp_nb_type(struct connectdata *conn,
+ bool ascii, ftpstate newstate)
+{
+ struct FTP *ftp = conn->proto.ftp;
+ CURLcode result;
+ int want = ascii?'A':'I';
+ if (ftp->transfertype == want) {
+ state(conn, newstate);
+ return ftp_state_type_resp(conn, 200, newstate);
+ }
+
+ NBFTPSENDF(conn, "TYPE %c", want);
+ state(conn, newstate);
+
+ /* keep track of our current transfer type */
+ ftp->transfertype = want;
return CURLE_OK;
}
/* a transfer is about to take place */
if(data->set.upload) {
- NBFTPSENDF(conn, "TYPE %c", data->set.ftp_ascii?'A':'I');
- state(conn, FTP_STOR_TYPE);
- /* keep track of our current transfer type */
- data->ftp_in_ascii_mode = data->set.ftp_ascii;
+ result = ftp_nb_type(conn, data->set.prefer_ascii,
+ FTP_STOR_TYPE);
+ if (result)
+ return result;
}
else {
/* download */
/* 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. */
- NBFTPSENDF(conn, "TYPE A", NULL);
- state(conn, FTP_LIST_TYPE);
- /* keep track of our current transfer type */
- data->ftp_in_ascii_mode = 1;
+ result = ftp_nb_type(conn, 1, FTP_LIST_TYPE);
+ if (result)
+ return result;
}
else {
- NBFTPSENDF(conn, "TYPE %c", data->set.ftp_ascii?'A':'I');
- state(conn, FTP_RETR_TYPE);
- /* keep track of our current transfer type */
- data->ftp_in_ascii_mode = data->set.ftp_ascii;
+ result = ftp_nb_type(conn, data->set.prefer_ascii, FTP_RETR_TYPE);
+ if (result)
+ return result;
}
}
result = ftp_easy_statemach(conn);
sec_conn->xfertype = SOURCE3RD;
/* sets transfer type */
- result = ftp_transfertype(conn, data->set.ftp_ascii);
+ result = ftp_transfertype(conn, data->set.prefer_ascii);
if (result)
return result;
- result = ftp_transfertype(sec_conn, data->set.ftp_ascii);
+ result = ftp_transfertype(sec_conn, data->set.prefer_ascii);
if (result)
return result;
if(data->set.include_header)
writetype |= CLIENTWRITE_BODY;
- result = Curl_client_write(data, writetype, line_start, perline);
+ result = Curl_client_write(conn, writetype, line_start, perline);
if(result)
return result;
* | (__| |_| | _ <| |___
* \___|\___/|_| \_\_____|
*
- * Copyright (C) 1998 - 2005, Daniel Stenberg, <daniel@haxx.se>, et al.
+ * Copyright (C) 1998 - 2006, Daniel Stenberg, <daniel@haxx.se>, et al.
*
* This software is licensed as described in the file COPYING, which
* you should have received as part of this distribution. The terms
case IDENTITY:
#endif
if(!k->ignorebody)
- result = Curl_client_write(conn->data, CLIENTWRITE_BODY, datap,
+ result = Curl_client_write(conn, CLIENTWRITE_BODY, datap,
piece);
#ifdef HAVE_LIBZ
break;
case DEFLATE:
/* update conn->keep.str to point to the chunk data. */
conn->keep.str = datap;
- result = Curl_unencode_deflate_write(conn->data, &conn->keep,
+ result = Curl_unencode_deflate_write(conn, &conn->keep,
(ssize_t)piece);
break;
case GZIP:
/* update conn->keep.str to point to the chunk data. */
conn->keep.str = datap;
- result = Curl_unencode_gzip_write(conn->data, &conn->keep,
+ result = Curl_unencode_gzip_write(conn, &conn->keep,
(ssize_t)piece);
break;
return CHUNKE_STOP;
}
else {
- Curl_client_write(conn->data, CLIENTWRITE_HEADER,
+ Curl_client_write(conn, CLIENTWRITE_HEADER,
conn->trailer, conn->trlPos);
}
ch->state = CHUNK_TRAILER;
char *dn = (*ldap_get_dn)(server, entryIterator);
int i;
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)"DN: ", 4);
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)dn, 0);
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)"\n", 1);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"DN: ", 4);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)dn, 0);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 1);
for (attribute = (*ldap_first_attribute)(server, entryIterator, &ber);
attribute;
{
for (i = 0; (vals[i] != NULL); i++)
{
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)"\t", 1);
- Curl_client_write(data, CLIENTWRITE_BODY, (char *) attribute, 0);
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)": ", 2);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\t", 1);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *) attribute, 0);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)": ", 2);
if ((strlen(attribute) > 7) &&
(strcmp(";binary",
(char *)attribute +
val_b64_sz = Curl_base64_encode(vals[i]->bv_val, vals[i]->bv_len,
&val_b64);
if (val_b64_sz > 0) {
- Curl_client_write(data, CLIENTWRITE_BODY, val_b64, val_b64_sz);
+ Curl_client_write(conn, CLIENTWRITE_BODY, val_b64, val_b64_sz);
free(val_b64);
}
} else
- Curl_client_write(data, CLIENTWRITE_BODY, vals[i]->bv_val,
+ Curl_client_write(conn, CLIENTWRITE_BODY, vals[i]->bv_val,
vals[i]->bv_len);
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)"\n", 0);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 0);
}
/* Free memory used to store values */
(*ldap_value_free_len)((void **)vals);
}
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)"\n", 1);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)"\n", 1);
(*ldap_memfree)(attribute);
}
The bit pattern defines to what "streams" to write to. Body and/or header.
The defines are in sendf.h of course.
*/
-CURLcode Curl_client_write(struct SessionHandle *data,
+CURLcode Curl_client_write(struct connectdata *conn,
int type,
char *ptr,
size_t len)
{
+ struct SessionHandle *data = conn->data;
size_t wrote;
if(0 == len)
len = strlen(ptr);
if(type & CLIENTWRITE_BODY) {
- if(data->ftp_in_ascii_mode) {
+ if((conn->protocol&PROT_FTP) && conn->proto.ftp->transfertype == 'A') {
#ifdef CURL_DOES_CONVERSIONS
/* convert from the network encoding */
size_t rc;
#define CLIENTWRITE_HEADER 2
#define CLIENTWRITE_BOTH (CLIENTWRITE_BODY|CLIENTWRITE_HEADER)
-CURLcode Curl_client_write(struct SessionHandle *data, int type, char *ptr,
+CURLcode Curl_client_write(struct connectdata *conn, int type, char *ptr,
size_t len);
/* internal read-function, does plain socket, SSL and krb4 */
break; /* Ignore \0 after CR */
}
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)&c, 1);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)&c, 1);
continue;
case CURL_TS_DATA:
tn->telrcv_state = CURL_TS_CR;
}
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)&c, 1);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)&c, 1);
continue;
case CURL_TS_IAC:
tn->telrcv_state = CURL_TS_SB;
continue;
case CURL_IAC:
- Curl_client_write(data, CLIENTWRITE_BODY, (char *)&c, 1);
+ Curl_client_write(conn, CLIENTWRITE_BODY, (char *)&c, 1);
break;
case CURL_DM:
case CURL_NOP:
CURLcode res = CURLE_OK;
/* Set ascii mode if -B flag was used */
- if(data->set.ftp_ascii)
+ if(data->set.prefer_ascii)
mode = "netascii";
switch(event) {
/* Don't pass to the client empty or retransmitted packets */
if (state->rbytes > 4 &&
((state->block+1) == getrpacketblock(&state->rpacket))) {
- code = Curl_client_write(data, CLIENTWRITE_BODY,
+ code = Curl_client_write(conn, CLIENTWRITE_BODY,
(char *)&state->rpacket.data[4],
state->rbytes-4);
if(code)
headerlen = k->p - data->state.headerbuff;
- result = Curl_client_write(data, writetype,
+ result = Curl_client_write(conn, writetype,
data->state.headerbuff,
headerlen);
if(result)
Curl_debug(data, CURLINFO_HEADER_IN,
k->p, k->hbuflen, conn);
- result = Curl_client_write(data, writetype, k->p, k->hbuflen);
+ result = Curl_client_write(conn, writetype, k->p, k->hbuflen);
if(result)
return result;
if(k->badheader && !k->ignorebody) {
/* we parsed a piece of data wrongly assuming it was a header
and now we output it as body instead */
- result = Curl_client_write(data, CLIENTWRITE_BODY,
+ result = Curl_client_write(conn, CLIENTWRITE_BODY,
data->state.headerbuff,
k->hbuflen);
if(result)
Content-Encoding header. See Curl_readwrite_init; the
memset() call initializes k->content_encoding to zero. */
if(!k->ignorebody)
- result = Curl_client_write(data, CLIENTWRITE_BODY, k->str,
+ result = Curl_client_write(conn, CLIENTWRITE_BODY, k->str,
nread);
#ifdef HAVE_LIBZ
break;
case DEFLATE:
/* Assume CLIENTWRITE_BODY; headers are not encoded. */
if(!k->ignorebody)
- result = Curl_unencode_deflate_write(data, k, nread);
+ result = Curl_unencode_deflate_write(conn, k, nread);
break;
case GZIP:
/* Assume CLIENTWRITE_BODY; headers are not encoded. */
if(!k->ignorebody)
- result = Curl_unencode_gzip_write(data, k, nread);
+ result = Curl_unencode_gzip_write(conn, k, nread);
break;
case COMPRESS:
/* convert LF to CRLF if so asked */
#ifdef CURL_DO_LINEEND_CONV
/* always convert if we're FTPing in ASCII mode */
- if ((data->set.crlf) || (data->ftp_in_ascii_mode)) {
+ if ((data->set.crlf) || (data->set.prefer_ascii)) {
#else
if (data->set.crlf) {
#endif /* CURL_DO_LINEEND_CONV */
*
* Transfer using ASCII (instead of BINARY).
*/
- data->set.ftp_ascii = va_arg(param, long)?TRUE:FALSE;
+ data->set.prefer_ascii = va_arg(param, long)?TRUE:FALSE;
break;
case CURLOPT_TIMECONDITION:
/*
command = (char)toupper((int)type[6]);
switch(command) {
case 'A': /* ASCII mode */
- data->set.ftp_ascii = 1;
+ data->set.prefer_ascii = TRUE;
break;
case 'D': /* directory mode */
- data->set.ftp_list_only = 1;
+ data->set.ftp_list_only = TRUE;
break;
case 'I': /* binary mode */
default:
/* switch off ASCII */
- data->set.ftp_ascii = 0;
+ data->set.prefer_ascii = FALSE;
break;
}
}
switch(command) {
case 'A': /* ASCII mode */
case 'N': /* NETASCII mode */
- data->set.ftp_ascii = 1;
+ data->set.prefer_ascii = TRUE;
break;
case 'O': /* octet mode */
case 'I': /* binary mode */
default:
/* switch off ASCII */
- data->set.ftp_ascii = 0;
+ data->set.prefer_ascii = FALSE;
break;
}
}
bool cwdfail; /* set TRUE if a CWD command fails, as then we must prevent
caching the current directory */
char *prevpath; /* conn->path from the previous transfer */
+ char transfertype; /* set by ftp_transfertype for use by Curl_client_write()a
+ and others (A/I or zero) */
size_t nread_resp; /* number of bytes currently read of a server response */
char *linestart_resp; /* line start pointer for the FTP server response
bool printhost; /* printing host name in debug info */
bool get_filetime;
bool tunnel_thru_httpproxy;
+ bool prefer_ascii; /* ASCII rather than binary */
bool ftp_append;
- bool ftp_ascii;
bool ftp_list_only;
bool ftp_create_missing_dirs;
bool ftp_use_port;
struct UrlState state; /* struct for fields used for state info and
other dynamic purposes */
struct PureInfo info; /* stats, reports and info data */
- /* set by ftp_transfertype for use by Curl_client_write and others */
- bool ftp_in_ascii_mode;
#if defined(CURL_DOES_CONVERSIONS) && defined(HAVE_ICONV)
iconv_t outbound_cd; /* for translating to the network encoding */
iconv_t inbound_cd; /* for translating from the network encoding */
RETR 146\r
CWD /nowhere/anywhere\r
EPSV\r
-TYPE I\r
SIZE 146\r
RETR 146\r
QUIT\r
CWD /nowhere/anywhere\r
CWD dir2\r
EPSV\r
-TYPE I\r
STOR 148\r
QUIT\r
</protocol>
SIZE 210\r
RETR 210\r
EPSV\r
-TYPE I\r
SIZE 210\r
RETR 210\r
QUIT\r
SIZE 211\r
RETR 211\r
PASV\r
-TYPE I\r
SIZE 211\r
RETR 211\r
QUIT\r
SIZE 212\r
RETR 212\r
PORT 127,0,0,1,
-TYPE I\r
SIZE 212\r
RETR 212\r
QUIT\r
TYPE A\r
LIST\r
EPSV\r
-TYPE A\r
LIST\r
QUIT\r
</protocol>
TYPE I\r
STOR upload.216\r
EPSV\r
-TYPE I\r
STOR ..anotherup\r
QUIT\r
</protocol>
projects / curl / commitdiff