/* $NetBSD: ftp.c,v 1.35 2010/03/21 16:48:43 joerg Exp $ */

/*-

* Copyright (c) 1998-2004 Dag-Erling Coïdan Smørgrav

* Copyright (c) 2008, 2009, 2010 Joerg Sonnenberger <joerg@NetBSD.org>

* All rights reserved.

*

* Redistribution and use in source and binary forms, with or without

* modification, are permitted provided that the following conditions

* are met:

* 1. Redistributions of source code must retain the above copyright

* notice, this list of conditions and the following disclaimer

* in this position and unchanged.

* 2. Redistributions in binary form must reproduce the above copyright

* notice, this list of conditions and the following disclaimer in the

* documentation and/or other materials provided with the distribution.

* 3. The name of the author may not be used to endorse or promote products

* derived from this software without specific prior written permission

*

* THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR

* IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES

* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.

* IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,

* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT

* NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,

* DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY

* THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF

* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

*

* $FreeBSD: ftp.c,v 1.101 2008/01/23 20:57:59 des Exp $

*/

/*

* Portions of this code were taken from or based on ftpio.c:

*

* ----------------------------------------------------------------------------

* "THE BEER-WARE LICENSE" (Revision 42):

* <phk@FreeBSD.org> wrote this file. As long as you retain this notice you

* can do whatever you want with this stuff. If we meet some day, and you think

* this stuff is worth it, you can buy me a beer in return. Poul-Henning Kamp

* ----------------------------------------------------------------------------

*

* Major Changelog:

*

* Dag-Erling Coïdan Smørgrav

* 9 Jun 1998

*

* Incorporated into libfetch

*

* Jordan K. Hubbard

* 17 Jan 1996

*

* Turned inside out. Now returns xfers as new file ids, not as a special

* `state' of FTP_t

*

* $ftpioId: ftpio.c,v 1.30 1998/04/11 07:28:53 phk Exp $

*

*/

#ifdef __linux__

/* Keep this down to Linux, it can create surprises else where. */

#define _GNU_SOURCE

#endif

#if HAVE_CONFIG_H

#include "config.h"

#endif

#if !defined(NETBSD) && !defined(__minix)

#include <nbcompat.h>

#endif

#include <sys/types.h>

#include <sys/socket.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <ctype.h>

#include <errno.h>

#include <fcntl.h>

#if defined(HAVE_INTTYPES_H) || defined(NETBSD)

#include <inttypes.h>

#endif

#include <stdarg.h>

#if !defined(NETBSD) && !defined(__minix)

#include <nbcompat/netdb.h>

#include <nbcompat/stdio.h>

#else

#include <netdb.h>

#include <stdio.h>

#endif

#include <stdlib.h>

#include <string.h>

#include <time.h>

#include <unistd.h>

#include "common.h"

#include "ftperr.h"

#define FTP_ANONYMOUS_USER "anonymous"

#define FTP_CONNECTION_ALREADY_OPEN 125

#define FTP_OPEN_DATA_CONNECTION 150

#define FTP_OK 200

#define FTP_FILE_STATUS 213

#define FTP_SERVICE_READY 220

#define FTP_TRANSFER_COMPLETE 226

#define FTP_PASSIVE_MODE 227

#define FTP_LPASSIVE_MODE 228

#define FTP_EPASSIVE_MODE 229

#define FTP_LOGGED_IN 230

#define FTP_FILE_ACTION_OK 250

#define FTP_DIRECTORY_CREATED 257 /* multiple meanings */

#define FTP_FILE_CREATED 257 /* multiple meanings */

#define FTP_WORKING_DIRECTORY 257 /* multiple meanings */

#define FTP_NEED_PASSWORD 331

#define FTP_NEED_ACCOUNT 332

#define FTP_FILE_OK 350

#define FTP_SYNTAX_ERROR 500

#define FTP_PROTOCOL_ERROR 999

#define isftpreply(foo) \

(isdigit((unsigned char)foo[0]) && \

isdigit((unsigned char)foo[1]) && \

isdigit((unsigned char)foo[2]) && \

(foo[3] == ' ' || foo[3] == '\0'))

#define isftpinfo(foo) \

(isdigit((unsigned char)foo[0]) && \

isdigit((unsigned char)foo[1]) && \

isdigit((unsigned char)foo[2]) && \

foo[3] == '-')

#define MINBUFSIZE 4096

#ifdef INET6

/*

* Translate IPv4 mapped IPv6 address to IPv4 address

*/

static void

unmappedaddr(struct sockaddr_in6 *sin6, socklen_t *len)

{

struct sockaddr_in *sin4;

uint32_t addr;

int port;

if (sin6->sin6_family != AF_INET6 ||

!IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))

return;

sin4 = (struct sockaddr_in *)sin6;

addr = *(uint32_t *)&sin6->sin6_addr.s6_addr[12];

port = sin6->sin6_port;

memset(sin4, 0, sizeof(struct sockaddr_in));

sin4->sin_addr.s_addr = addr;

sin4->sin_port = port;

sin4->sin_family = AF_INET;

*len = sizeof(struct sockaddr_in);

#ifdef HAVE_SA_LEN

sin4->sin_len = sizeof(struct sockaddr_in);

#endif

}

#endif

/*

* Get server response

*/

static int

ftp_chkerr(conn_t *conn)

{

if (fetch_getln(conn) == -1) {

fetch_syserr();

return (-1);

}

if (isftpinfo(conn->buf)) {

while (conn->buflen && !isftpreply(conn->buf)) {

if (fetch_getln(conn) == -1) {

fetch_syserr();

return (-1);

}

}

}

while (conn->buflen &&

isspace((unsigned char)conn->buf[conn->buflen - 1]))

conn->buflen--;

conn->buf[conn->buflen] = '\0';

if (!isftpreply(conn->buf)) {

ftp_seterr(FTP_PROTOCOL_ERROR);

return (-1);

}

conn->err = (conn->buf[0] - '0') * 100

+ (conn->buf[1] - '0') * 10

+ (conn->buf[2] - '0');

return (conn->err);

}

/*

* Send a command and check reply

*/

#ifndef __minix

static int

ftp_cmd(conn_t *conn, const char *fmt, ...)

{

va_list ap;

size_t len;

char *msg;

int r;

va_start(ap, fmt);

len = vasprintf(&msg, fmt, ap);

va_end(ap);

if (msg == NULL) {

errno = ENOMEM;

fetch_syserr();

return (-1);

}

r = fetch_write(conn, msg, len);

free(msg);

if (r == -1) {

fetch_syserr();

return (-1);

}

return (ftp_chkerr(conn));

}

#else

static int

ftp_cmd(conn_t *conn, const char *fmt, ...)

{

va_list ap;

size_t len;

char msg[MINBUFSIZE];

int r;

va_start(ap, fmt);

len = vsnprintf(&msg[0], MINBUFSIZE, fmt, ap);

va_end(ap);

if (len >= MINBUFSIZE) {

errno = ENOMEM;

fetch_syserr();

return (-1);

}

r = fetch_write(conn, msg, len);

if (r == -1) {

fetch_syserr();

return (-1);

}

return (ftp_chkerr(conn));

}

#endif

/*

* Return a pointer to the filename part of a path

*/

static const char *

ftp_filename(const char *file, int *len, int *type, int subdir)

{

const char *s;

if ((s = strrchr(file, '/')) == NULL || subdir)

s = file;

else

s = s + 1;

*len = strlen(s);

if (*len > 7 && strncmp(s + *len - 7, ";type=", 6) == 0) {

*type = s[*len - 1];

*len -= 7;

} else {

*type = '\0';

}

return (s);

}

/*

* Get current working directory from the reply to a CWD, PWD or CDUP

* command.

*/

static int

ftp_pwd(conn_t *conn, char **pwd)

{

char *src, *dst, *end;

int q;

if (conn->err != FTP_WORKING_DIRECTORY &&

conn->err != FTP_FILE_ACTION_OK)

return (FTP_PROTOCOL_ERROR);

end = conn->buf + conn->buflen;

src = conn->buf + 4;

if (src >= end || *src++ != '"')

return (FTP_PROTOCOL_ERROR);

*pwd = malloc(end - src + 1);

if (*pwd == NULL)

return (FTP_PROTOCOL_ERROR);

for (q = 0, dst = *pwd; src < end; ++src) {

if (!q && *src == '"')

q = 1;

else if (q && *src != '"')

break;

else if (q)

*dst++ = '"', q = 0;

else

*dst++ = *src;

}

*dst = '\0';

if (**pwd != '/') {

free(*pwd);

*pwd = NULL;

return (FTP_PROTOCOL_ERROR);

}

return (FTP_OK);

}

/*

* Change working directory to the directory that contains the specified

* file.

*/

static int

ftp_cwd(conn_t *conn, const char *path, int subdir)

{

const char *beg, *end;

char *pwd, *dst;

int e, i, len;

if (*path != '/') {

ftp_seterr(501);

return (-1);

}

++path;

/* Simple case: still in the home directory and no directory change. */

if (conn->ftp_home == NULL && strchr(path, '/') == NULL &&

(!subdir || *path == '\0'))

return 0;

if ((e = ftp_cmd(conn, "PWD\r\n")) != FTP_WORKING_DIRECTORY ||

(e = ftp_pwd(conn, &pwd)) != FTP_OK) {

ftp_seterr(e);

return (-1);

}

if (conn->ftp_home == NULL && (conn->ftp_home = strdup(pwd)) == NULL) {

fetch_syserr();

free(pwd);

return (-1);

}

if (*path == '/') {

while (path[1] == '/')

++path;

dst = strdup(path);

} else if (strcmp(conn->ftp_home, "/") == 0) {

dst = strdup(path - 1);

} else {

#ifndef __minix

asprintf(&dst, "%s/%s", conn->ftp_home, path);

#else

if((dst = malloc(sizeof(char)*MINBUFSIZE)) != NULL) {

len = snprintf(dst, MINBUFSIZE, "%s/%s", conn->ftp_home, path);

if(len >= MINBUFSIZE) {

free(dst);

dst = NULL;

}

}

#endif

}

if (dst == NULL) {

fetch_syserr();

free(pwd);

return (-1);

}

if (subdir)

end = dst + strlen(dst);

else

end = strrchr(dst, '/');

for (;;) {

len = strlen(pwd);

/* Look for a common prefix between PWD and dir to fetch. */

for (i = 0; i <= len && i <= end - dst; ++i)

if (pwd[i] != dst[i])

break;

/* Keep going up a dir until we have a matching prefix. */

if (strcmp(pwd, "/") == 0)

break;

if (pwd[i] == '\0' && (dst[i - 1] == '/' || dst[i] == '/'))

break;

free(pwd);

if ((e = ftp_cmd(conn, "CDUP\r\n")) != FTP_FILE_ACTION_OK ||

(e = ftp_cmd(conn, "PWD\r\n")) != FTP_WORKING_DIRECTORY ||

(e = ftp_pwd(conn, &pwd)) != FTP_OK) {

ftp_seterr(e);

free(dst);

return (-1);

}

}

free(pwd);

#ifdef FTP_COMBINE_CWDS

/* Skip leading slashes, even "////". */

for (beg = dst + i; beg < end && *beg == '/'; ++beg, ++i)

/* nothing */ ;

/* If there is no trailing dir, we're already there. */

if (beg >= end) {

free(dst);

return (0);

}

/* Change to the directory all in one chunk (e.g., foo/bar/baz). */

e = ftp_cmd(conn, "CWD %.*s\r\n", (int)(end - beg), beg);

if (e == FTP_FILE_ACTION_OK) {

free(dst);

return (0);

}

#endif /* FTP_COMBINE_CWDS */

/* That didn't work so go back to legacy behavior (multiple CWDs). */

for (beg = dst + i; beg < end; beg = dst + i + 1) {

while (*beg == '/')

++beg, ++i;

for (++i; dst + i < end && dst[i] != '/'; ++i)

/* nothing */ ;

e = ftp_cmd(conn, "CWD %.*s\r\n", dst + i - beg, beg);

if (e != FTP_FILE_ACTION_OK) {

free(dst);

ftp_seterr(e);

return (-1);

}

}

free(dst);

return (0);

}

/*

* Set transfer mode and data type

*/

static int

ftp_mode_type(conn_t *conn, int mode, int type)

{

int e;

switch (mode) {

case 0:

case 's':

mode = 'S';

case 'S':

break;

default:

return (FTP_PROTOCOL_ERROR);

}

if ((e = ftp_cmd(conn, "MODE %c\r\n", mode)) != FTP_OK) {

if (mode == 'S') {

/*

* Stream mode is supposed to be the default - so

* much so that some servers not only do not

* support any other mode, but do not support the

* MODE command at all.

*

* If "MODE S" fails, it is unlikely that we

* previously succeeded in setting a different

* mode. Therefore, we simply hope that the

* server is already in the correct mode, and

* silently ignore the failure.

*/

} else {

return (e);

}

}

switch (type) {

case 0:

case 'i':

type = 'I';

case 'I':

break;

case 'a':

type = 'A';

case 'A':

break;

case 'd':

type = 'D';

case 'D':

/* can't handle yet */

default:

return (FTP_PROTOCOL_ERROR);

}

if ((e = ftp_cmd(conn, "TYPE %c\r\n", type)) != FTP_OK)

return (e);

return (FTP_OK);

}

/*

* Request and parse file stats

*/

static int

ftp_stat(conn_t *conn, const char *file, struct url_stat *us)

{

char *ln;

const char *filename;

int filenamelen, type;

struct tm tm;

time_t t;

int e;

us->size = -1;

us->atime = us->mtime = 0;

filename = ftp_filename(file, &filenamelen, &type, 0);

if ((e = ftp_mode_type(conn, 0, type)) != FTP_OK) {

ftp_seterr(e);

return (-1);

}

e = ftp_cmd(conn, "SIZE %.*s\r\n", filenamelen, filename);

if (e != FTP_FILE_STATUS) {

ftp_seterr(e);

return (-1);

}

for (ln = conn->buf + 4; *ln && isspace((unsigned char)*ln); ln++)

/* nothing */ ;

for (us->size = 0; *ln && isdigit((unsigned char)*ln); ln++)

us->size = us->size * 10 + *ln - '0';

if (*ln && !isspace((unsigned char)*ln)) {

ftp_seterr(FTP_PROTOCOL_ERROR);

us->size = -1;

return (-1);

}

if (us->size == 0)

us->size = -1;

e = ftp_cmd(conn, "MDTM %.*s\r\n", filenamelen, filename);

if (e != FTP_FILE_STATUS) {

ftp_seterr(e);

return (-1);

}

for (ln = conn->buf + 4; *ln && isspace((unsigned char)*ln); ln++)

/* nothing */ ;

switch (strspn(ln, "0123456789")) {

case 14:

break;

case 15:

ln++;

ln[0] = '2';

ln[1] = '0';

break;

default:

ftp_seterr(FTP_PROTOCOL_ERROR);

return (-1);

}

if (sscanf(ln, "%04d%02d%02d%02d%02d%02d",

&tm.tm_year, &tm.tm_mon, &tm.tm_mday,

&tm.tm_hour, &tm.tm_min, &tm.tm_sec) != 6) {

ftp_seterr(FTP_PROTOCOL_ERROR);

return (-1);

}

tm.tm_mon--;

tm.tm_year -= 1900;

tm.tm_isdst = -1;

t = timegm(&tm);

if (t == (time_t)-1)

t = time(NULL);

us->mtime = t;

us->atime = t;

return (0);

}

/*

* I/O functions for FTP

*/

struct ftpio {

conn_t *cconn; /* Control connection */

conn_t *dconn; /* Data connection */

int dir; /* Direction */

int eof; /* EOF reached */

int err; /* Error code */

};

static ssize_t ftp_readfn(void *, void *, size_t);

static ssize_t ftp_writefn(void *, const void *, size_t);

static void ftp_closefn(void *);

static ssize_t

ftp_readfn(void *v, void *buf, size_t len)

{

struct ftpio *io;

int r;

io = (struct ftpio *)v;

if (io == NULL) {

errno = EBADF;

return (-1);

}

if (io->cconn == NULL || io->dconn == NULL || io->dir == O_WRONLY) {

errno = EBADF;

return (-1);

}

if (io->err) {

errno = io->err;

return (-1);

}

if (io->eof)

return (0);

r = fetch_read(io->dconn, buf, len);

if (r > 0)

return (r);

if (r == 0) {

io->eof = 1;

return (0);

}

if (errno != EINTR)

io->err = errno;

return (-1);

}

static ssize_t

ftp_writefn(void *v, const void *buf, size_t len)

{

struct ftpio *io;

int w;

io = (struct ftpio *)v;

if (io == NULL) {

errno = EBADF;

return (-1);

}

if (io->cconn == NULL || io->dconn == NULL || io->dir == O_RDONLY) {

errno = EBADF;

return (-1);

}

if (io->err) {

errno = io->err;

return (-1);

}

w = fetch_write(io->dconn, buf, len);

if (w >= 0)

return (w);

if (errno != EINTR)

io->err = errno;

return (-1);

}

static int

ftp_disconnect(conn_t *conn)

{

ftp_cmd(conn, "QUIT\r\n");

return fetch_close(conn);

}

static void

ftp_closefn(void *v)

{

struct ftpio *io;

int r;

io = (struct ftpio *)v;

if (io == NULL) {

errno = EBADF;

return;

}

if (io->dir == -1)

return;

if (io->cconn == NULL || io->dconn == NULL) {

errno = EBADF;

return;

}

fetch_close(io->dconn);

io->dconn = NULL;

io->dir = -1;

r = ftp_chkerr(io->cconn);

fetch_cache_put(io->cconn, ftp_disconnect);

free(io);

return;

}

static fetchIO *

ftp_setup(conn_t *cconn, conn_t *dconn, int mode)

{

struct ftpio *io;

fetchIO *f;

if (cconn == NULL || dconn == NULL)

return (NULL);

if ((io = malloc(sizeof(*io))) == NULL)

return (NULL);

io->cconn = cconn;

io->dconn = dconn;

io->dir = mode;

io->eof = io->err = 0;

f = fetchIO_unopen(io, ftp_readfn, ftp_writefn, ftp_closefn);

if (f == NULL)

free(io);

return (f);

}

/*

* Transfer file

*/

static fetchIO *

ftp_transfer(conn_t *conn, const char *oper, const char *file, const char *op_arg,

int mode, off_t offset, const char *flags)

{

union anonymous {

struct sockaddr_storage ss;

struct sockaddr sa;

struct sockaddr_in6 sin6;

struct sockaddr_in sin4;

} u;

const char *bindaddr;

const char *filename;

int filenamelen, type;

int low, pasv, verbose;

int e, sd = -1;

socklen_t l;

char *s;

fetchIO *df;

/* check flags */

low = CHECK_FLAG('l');

pasv = !CHECK_FLAG('a');

verbose = CHECK_FLAG('v');

/* passive mode */

if (!pasv)

pasv = ((s = getenv("FTP_PASSIVE_MODE")) != NULL &&

strncasecmp(s, "no", 2) != 0);

/* isolate filename */

filename = ftp_filename(file, &filenamelen, &type, op_arg != NULL);

/* set transfer mode and data type */

if ((e = ftp_mode_type(conn, 0, type)) != FTP_OK)

goto ouch;

/* find our own address, bind, and listen */

l = sizeof(u.ss);

if (getsockname(conn->sd, &u.sa, &l) == -1)

goto sysouch;

#ifdef INET6

if (u.ss.ss_family == AF_INET6)

unmappedaddr(&u.sin6, &l);

#endif

retry_mode:

/* open data socket */

if ((sd = socket(u.ss.ss_family, SOCK_STREAM, IPPROTO_TCP)) == -1) {

fetch_syserr();

return (NULL);

}

if (pasv) {

unsigned char addr[64];

char *ln, *p;

unsigned int i;

int port;

/* send PASV command */

if (verbose)

fetch_info("setting passive mode");

switch (u.ss.ss_family) {

case AF_INET:

if ((e = ftp_cmd(conn, "PASV\r\n")) != FTP_PASSIVE_MODE)

goto ouch;

break;

#ifdef INET6

case AF_INET6:

if ((e = ftp_cmd(conn, "EPSV\r\n")) != FTP_EPASSIVE_MODE) {

if (e == -1)

goto ouch;

if ((e = ftp_cmd(conn, "LPSV\r\n")) !=

FTP_LPASSIVE_MODE)

goto ouch;

}

break;

#endif

default:

e = FTP_PROTOCOL_ERROR; /* XXX: error code should be prepared */

goto ouch;

}

/*

* Find address and port number. The reply to the PASV command

* is IMHO the one and only weak point in the FTP protocol.

*/

ln = conn->buf;

switch (e) {

case FTP_PASSIVE_MODE:

case FTP_LPASSIVE_MODE:

for (p = ln + 3; *p && !isdigit((unsigned char)*p); p++)

/* nothing */ ;

if (!*p) {

e = FTP_PROTOCOL_ERROR;

goto ouch;

}

l = (e == FTP_PASSIVE_MODE ? 6 : 21);

for (i = 0; *p && i < l; i++, p++)

addr[i] = strtol(p, &p, 10);

if (i < l) {

e = FTP_PROTOCOL_ERROR;

goto ouch;

}

break;

case FTP_EPASSIVE_MODE:

for (p = ln + 3; *p && *p != '('; p++)

/* nothing */ ;

if (!*p) {

e = FTP_PROTOCOL_ERROR;

goto ouch;

}

++p;

if (sscanf(p, "%c%c%c%d%c", &addr[0], &addr[1], &addr[2],

&port, &addr[3]) != 5 ||

addr[0] != addr[1] ||

addr[0] != addr[2] || addr[0] != addr[3]) {

e = FTP_PROTOCOL_ERROR;

goto ouch;

}

break;

case FTP_SYNTAX_ERROR:

if (verbose)

fetch_info("passive mode failed");

/* Close socket and retry with passive mode. */

pasv = 0;

close(sd);

sd = -1;

goto retry_mode;

}

/* seek to required offset */

if (offset)

if (ftp_cmd(conn, "REST %lu\r\n", (unsigned long)offset) != FTP_FILE_OK)

goto sysouch;

/* construct sockaddr for data socket */

l = sizeof(u.ss);

if (getpeername(conn->sd, &u.sa, &l) == -1)

goto sysouch;

#ifdef INET6

if (u.ss.ss_family == AF_INET6)

unmappedaddr(&u.sin6, &l);

#endif

switch (u.ss.ss_family) {

#ifdef INET6

case AF_INET6:

if (e == FTP_EPASSIVE_MODE)

u.sin6.sin6_port = htons(port);

else {

memcpy(&u.sin6.sin6_addr, addr + 2, 16);

memcpy(&u.sin6.sin6_port, addr + 19, 2);

}

break;

#endif

case AF_INET:

if (e == FTP_EPASSIVE_MODE)

u.sin4.sin_port = htons(port);

else {

memcpy(&u.sin4.sin_addr, addr, 4);

memcpy(&u.sin4.sin_port, addr + 4, 2);

}

break;

default:

e = FTP_PROTOCOL_ERROR; /* XXX: error code should be prepared */

break;

}

/* connect to data port */

if (verbose)

fetch_info("opening data connection");

bindaddr = getenv("FETCH_BIND_ADDRESS");

if (bindaddr != NULL && *bindaddr != '\0' &&

fetch_bind(sd, u.ss.ss_family, bindaddr) != 0)

goto sysouch;

if (connect(sd, &u.sa, l) == -1)

goto sysouch;

/* make the server initiate the transfer */

if (verbose)

fetch_info("initiating transfer");

if (op_arg)

e = ftp_cmd(conn, "%s%s%s\r\n", oper, *op_arg ? " " : "", op_arg);

else

e = ftp_cmd(conn, "%s %.*s\r\n", oper,

filenamelen, filename);

if (e != FTP_CONNECTION_ALREADY_OPEN && e != FTP_OPEN_DATA_CONNECTION)

goto ouch;

} else {

uint32_t a;

uint16_t p;

#if defined(IPV6_PORTRANGE) || defined(IP_PORTRANGE)

int arg;

#endif

int d;

#ifdef INET6

char *ap;

char hname[INET6_ADDRSTRLEN];

#endif

switch (u.ss.ss_family) {

#ifdef INET6

case AF_INET6:

u.sin6.sin6_port = 0;

#ifdef IPV6_PORTRANGE

arg = low ? IPV6_PORTRANGE_DEFAULT : IPV6_PORTRANGE_HIGH;

if (setsockopt(sd, IPPROTO_IPV6, IPV6_PORTRANGE,

(char *)&arg, sizeof(arg)) == -1)

goto sysouch;

#endif

break;

#endif

case AF_INET:

u.sin4.sin_port = 0;

#ifdef IP_PORTRANGE

arg = low ? IP_PORTRANGE_DEFAULT : IP_PORTRANGE_HIGH;

if (setsockopt(sd, IPPROTO_IP, IP_PORTRANGE,

(char *)&arg, sizeof(arg)) == -1)

goto sysouch;

#endif

break;

}

if (verbose)

fetch_info("binding data socket");

if (bind(sd, &u.sa, l) == -1)

goto sysouch;

if (listen(sd, 1) == -1)

goto sysouch;

/* find what port we're on and tell the server */

if (getsockname(sd, &u.sa, &l) == -1)

goto sysouch;

switch (u.ss.ss_family) {

case AF_INET:

a = ntohl(u.sin4.sin_addr.s_addr);

p = ntohs(u.sin4.sin_port);

e = ftp_cmd(conn, "PORT %d,%d,%d,%d,%d,%d\r\n",

(a >> 24) & 0xff, (a >> 16) & 0xff,

(a >> 8) & 0xff, a & 0xff,

(p >> 8) & 0xff, p & 0xff);

break;

#ifdef INET6

case AF_INET6:

#define UC(b) (((int)b)&0xff)

e = -1;

u.sin6.sin6_scope_id = 0;

if (getnameinfo(&u.sa, l,

hname, sizeof(hname),

NULL, 0, NI_NUMERICHOST) == 0) {

e = ftp_cmd(conn, "EPRT |%d|%s|%d|\r\n", 2, hname,

htons(u.sin6.sin6_port));

if (e == -1)

goto ouch;

}

if (e != FTP_OK) {

ap = (char *)&u.sin6.sin6_addr;

e = ftp_cmd(conn,

"LPRT %d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d,%d\r\n",

6, 16,

UC(ap[0]), UC(ap[1]), UC(ap[2]), UC(ap[3]),

UC(ap[4]), UC(ap[5]), UC(ap[6]), UC(ap[7]),

UC(ap[8]), UC(ap[9]), UC(ap[10]), UC(ap[11]),

UC(ap[12]), UC(ap[13]), UC(ap[14]), UC(ap[15]),

2,

(ntohs(u.sin6.sin6_port) >> 8) & 0xff,

ntohs(u.sin6.sin6_port) & 0xff);

}

break;

#endif

default:

e = FTP_PROTOCOL_ERROR; /* XXX: error code should be prepared */

goto ouch;

}

if (e != FTP_OK)

goto ouch;

#ifndef __minix

/* seek to required offset */

if (offset)

if (ftp_cmd(conn, "REST %llu\r\n", (unsigned long long)offset) != FTP_FILE_OK)

goto sysouch;

#else

/* seek to required offset */

if (offset)

if (ftp_cmd(conn, "REST %lu\r\n", (unsigned long)offset) != FTP_FILE_OK)

goto sysouch;

#endif

/* make the server initiate the transfer */

if (verbose)