 @@ -1,840 +1,841 @@
-/*	$NetBSD: common.c,v 1.6 2008/04/05 02:51:14 joerg Exp $	*/
+/*	$NetBSD: common.c,v 1.7 2008/04/17 19:04:12 joerg Exp $	*/
 /*-
  * Copyright (c) 1998-2004 Dag-Erling Coïdan Smørgrav
  * Copyright (c) 2008 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: common.c,v 1.53 2007/12/19 00:26:36 des Exp $
  */
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/uio.h>
 #include <netinet/in.h>
 #include <ctype.h>
 #include <errno.h>
 #include <inttypes.h>
 #include <netdb.h>
 #include <pwd.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #include "fetch.h"
 #include "common.h"
 #define DECONST(x,y) ((x)(uintptr_t)(y))
 /*** Local data **************************************************************/
 /*
  * Error messages for resolver errors
  */
 static struct fetcherr netdb_errlist[] = {
 #ifdef EAI_NODATA
 	{ EAI_NODATA,	FETCH_RESOLV,	"Host not found" },
 #endif
 	{ EAI_AGAIN,	FETCH_TEMP,	"Transient resolver failure" },
 	{ EAI_FAIL,	FETCH_RESOLV,	"Non-recoverable resolver failure" },
 	{ EAI_NONAME,	FETCH_RESOLV,	"No address record" },
 	{ -1,		FETCH_UNKNOWN,	"Unknown resolver error" }
 };
 /* End-of-Line */
 static const char ENDL[2] = "\r\n";
 /*** Error-reporting functions ***********************************************/
 /*
  * Map error code to string
  */
 static struct fetcherr *
 fetch_finderr(struct fetcherr *p, int e)
+{
 	while (p->num != -1 && p->num != e)
 		p++;
 	return (p);
+}
 /*
  * Set error code
  */
 void
 fetch_seterr(struct fetcherr *p, int e)
+{
 	p = fetch_finderr(p, e);
 	fetchLastErrCode = p->cat;
 	snprintf(fetchLastErrString, MAXERRSTRING, "%s", p->string);
+}
 /*
  * Set error code according to errno
  */
 void
 fetch_syserr(void)
+{
 	switch (errno) {
 	case 0:
 		fetchLastErrCode = FETCH_OK;
 		break;
 	case EPERM:
 	case EACCES:
 	case EROFS:
 #ifdef EAUTH
 	case EAUTH:
 #endif
 #ifdef ENEEDAUTH
 	case ENEEDAUTH:
 #endif
 		fetchLastErrCode = FETCH_AUTH;
 		break;
 	case ENOENT:
 	case EISDIR: /* XXX */
 		fetchLastErrCode = FETCH_UNAVAIL;
 		break;
 	case ENOMEM:
 		fetchLastErrCode = FETCH_MEMORY;
 		break;
 	case EBUSY:
 	case EAGAIN:
 		fetchLastErrCode = FETCH_TEMP;
 		break;
 	case EEXIST:
 		fetchLastErrCode = FETCH_EXISTS;
 		break;
 	case ENOSPC:
 		fetchLastErrCode = FETCH_FULL;
 		break;
 	case EADDRINUSE:
 	case EADDRNOTAVAIL:
 	case ENETDOWN:
 	case ENETUNREACH:
 	case ENETRESET:
 	case EHOSTUNREACH:
 		fetchLastErrCode = FETCH_NETWORK;
 		break;
 	case ECONNABORTED:
 	case ECONNRESET:
 		fetchLastErrCode = FETCH_ABORT;
 		break;
 	case ETIMEDOUT:
 		fetchLastErrCode = FETCH_TIMEOUT;
 		break;
 	case ECONNREFUSED:
 	case EHOSTDOWN:
 		fetchLastErrCode = FETCH_DOWN;
 		break;
 default:
 		fetchLastErrCode = FETCH_UNKNOWN;
+	}
 	snprintf(fetchLastErrString, MAXERRSTRING, "%s", strerror(errno));
+}
 /*
  * Emit status message
  */
 void
 fetch_info(const char *fmt, ...)
+{
 	va_list ap;
 	va_start(ap, fmt);
 	vfprintf(stderr, fmt, ap);
 	va_end(ap);
 	fputc('\n', stderr);
+}
 /*** Network-related utility functions ***************************************/
 /*
  * Return the default port for a scheme
  */
 int
 fetch_default_port(const char *scheme)
+{
 	struct servent *se;
 	if ((se = getservbyname(scheme, "tcp")) != NULL)
 		return (ntohs(se->s_port));
 	if (strcasecmp(scheme, SCHEME_FTP) == 0)
 		return (FTP_DEFAULT_PORT);
 	if (strcasecmp(scheme, SCHEME_HTTP) == 0)
 		return (HTTP_DEFAULT_PORT);
 	return (0);
+}
 /*
  * Return the default proxy port for a scheme
  */
 int
 fetch_default_proxy_port(const char *scheme)
+{
 	if (strcasecmp(scheme, SCHEME_FTP) == 0)
 		return (FTP_DEFAULT_PROXY_PORT);
 	if (strcasecmp(scheme, SCHEME_HTTP) == 0)
 		return (HTTP_DEFAULT_PROXY_PORT);
 	return (0);
+}
 /*
  * Create a connection for an existing descriptor.
  */
 conn_t *
 fetch_reopen(int sd)
+{
 	conn_t *conn;
 	/* allocate and fill connection structure */
 	if ((conn = calloc(1, sizeof(*conn))) == NULL)
 		return (NULL);
 	conn->sd = sd;
 	++conn->ref;
 	return (conn);
+}
 /*
  * Bump a connection's reference count.
  */
 conn_t *
 fetch_ref(conn_t *conn)
+{
 	++conn->ref;
 	return (conn);
+}
 /*
  * Bind a socket to a specific local address
  */
 int
 fetch_bind(int sd, int af, const char *addr)
+{
 	struct addrinfo hints, *res, *res0;
 	int err;
 	memset(&hints, 0, sizeof(hints));
 	hints.ai_family = af;
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_protocol = 0;
 	if ((err = getaddrinfo(addr, NULL, &hints, &res0)) != 0)
 		return (-1);
 	for (res = res0; res; res = res->ai_next)
 		if (bind(sd, res->ai_addr, res->ai_addrlen) == 0)
 			return (0);
 	return (-1);
+}
 /*
  * Establish a TCP connection to the specified port on the specified host.
  */
 conn_t *
 fetch_connect(const char *host, int port, int af, int verbose)
+{
 	conn_t *conn;
 	char pbuf[10];
 	const char *bindaddr;
 	struct addrinfo hints, *res, *res0;
 	int sd, err;
 	if (verbose)
 		fetch_info("looking up %s", host);
 	/* look up host name and set up socket address structure */
 	snprintf(pbuf, sizeof(pbuf), "%d", port);
 	memset(&hints, 0, sizeof(hints));
 	hints.ai_family = af;
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_protocol = 0;
 	if ((err = getaddrinfo(host, pbuf, &hints, &res0)) != 0) {
 		netdb_seterr(err);
 		return (NULL);
+	}
 	bindaddr = getenv("FETCH_BIND_ADDRESS");
 	if (verbose)
 		fetch_info("connecting to %s:%d", host, port);
 	/* try to connect */
 	for (sd = -1, res = res0; res; sd = -1, res = res->ai_next) {
 		if ((sd = socket(res->ai_family, res->ai_socktype,
 			 res->ai_protocol)) == -1)
 			continue;
 		if (bindaddr != NULL && *bindaddr != '\0' &&
 		    fetch_bind(sd, res->ai_family, bindaddr) != 0) {
 			fetch_info("failed to bind to '%s'", bindaddr);
 			close(sd);
 			continue;
+		}
 		if (connect(sd, res->ai_addr, res->ai_addrlen) == 0)
 			break;
 		close(sd);
+	}
 	freeaddrinfo(res0);
 	if (sd == -1) {
 		fetch_syserr();
 		return (NULL);
+	}
 	if ((conn = fetch_reopen(sd)) == NULL) {
 		fetch_syserr();
 		close(sd);
+	}
 	return (conn);
+}
 /*
  * Enable SSL on a connection.
  */
 int
 fetch_ssl(conn_t *conn, int verbose)
+{
 #ifdef WITH_SSL
 	/* Init the SSL library and context */
 	if (!SSL_library_init()){
 		fprintf(stderr, "SSL library init failed\n");
 		return (-1);
+	}
 	SSL_load_error_strings();
 	conn->ssl_meth = SSLv23_client_method();
 	conn->ssl_ctx = SSL_CTX_new(conn->ssl_meth);
 	SSL_CTX_set_mode(conn->ssl_ctx, SSL_MODE_AUTO_RETRY);
 	conn->ssl = SSL_new(conn->ssl_ctx);
 	if (conn->ssl == NULL){
 		fprintf(stderr, "SSL context creation failed\n");
 		return (-1);
+	}
 	SSL_set_fd(conn->ssl, conn->sd);
 	if (SSL_connect(conn->ssl) == -1){
 		ERR_print_errors_fp(stderr);
 		return (-1);
+	}
 	if (verbose) {
 		X509_NAME *name;
 		char *str;
 		fprintf(stderr, "SSL connection established using %s\n",
 		    SSL_get_cipher(conn->ssl));
 		conn->ssl_cert = SSL_get_peer_certificate(conn->ssl);
 		name = X509_get_subject_name(conn->ssl_cert);
 		str = X509_NAME_oneline(name, 0, 0);
 		printf("Certificate subject: %s\n", str);
 		free(str);
 		name = X509_get_issuer_name(conn->ssl_cert);
 		str = X509_NAME_oneline(name, 0, 0);
 		printf("Certificate issuer: %s\n", str);
 		free(str);
+	}
 	return (0);
 #else
 	(void)conn;
 	(void)verbose;
 	fprintf(stderr, "SSL support disabled\n");
 	return (-1);
 #endif
+}
 /*
  * Read a character from a connection w/ timeout
  */
 ssize_t
 fetch_read(conn_t *conn, char *buf, size_t len)
+{
 	struct timeval now, timeout, waittv;
 	fd_set readfds;
 	ssize_t rlen, total;
 	int r;
 	if (fetchTimeout) {
 		FD_ZERO(&readfds);
 		gettimeofday(&timeout, NULL);
 		timeout.tv_sec += fetchTimeout;
+	}
 	total = 0;
 	while (len > 0) {
 		while (fetchTimeout && !FD_ISSET(conn->sd, &readfds)) {
 			FD_SET(conn->sd, &readfds);
 			gettimeofday(&now, NULL);
 			waittv.tv_sec = timeout.tv_sec - now.tv_sec;
 			waittv.tv_usec = timeout.tv_usec - now.tv_usec;
 			if (waittv.tv_usec < 0) {
 				waittv.tv_usec += 1000000;
 				waittv.tv_sec--;
+			}
 			if (waittv.tv_sec < 0) {
 				errno = ETIMEDOUT;
 				fetch_syserr();
 				return (-1);
+			}
 			errno = 0;
 			r = select(conn->sd + 1, &readfds, NULL, NULL, &waittv);
 			if (r == -1) {
 				if (errno == EINTR && fetchRestartCalls)
 					continue;
 				fetch_syserr();
 				return (-1);
+			}
+		}
 #ifdef WITH_SSL
 		if (conn->ssl != NULL)
 			rlen = SSL_read(conn->ssl, buf, len);
 		else
 #endif
 			rlen = read(conn->sd, buf, len);
 		if (rlen == 0)
 			break;
 		if (rlen < 0) {
 			if (errno == EINTR && fetchRestartCalls)
 				continue;
 			return (-1);
+		}
 		len -= rlen;
 		buf += rlen;
 		total += rlen;
+	}
 	return (total);
+}
 /*
  * Read a line of text from a connection w/ timeout
  */
 #define MIN_BUF_SIZE 1024
 int
 fetch_getln(conn_t *conn)
+{
 	char *tmp;
 	size_t tmpsize;
 	ssize_t len;
 	char c;
 	if (conn->buf == NULL) {
 		if ((conn->buf = malloc(MIN_BUF_SIZE)) == NULL) {
 			errno = ENOMEM;
 			return (-1);
+		}
 		conn->bufsize = MIN_BUF_SIZE;
+	}
 	conn->buf[0] = '\0';
 	conn->buflen = 0;
 	do {
 		len = fetch_read(conn, &c, 1);
 		if (len == -1)
 			return (-1);
 		if (len == 0)
 			break;
 		conn->buf[conn->buflen++] = c;
 		if (conn->buflen == conn->bufsize) {
 			tmp = conn->buf;
 			tmpsize = conn->bufsize * 2 + 1;
 			if ((tmp = realloc(tmp, tmpsize)) == NULL) {
 				errno = ENOMEM;
 				return (-1);
+			}
 			conn->buf = tmp;
 			conn->bufsize = tmpsize;
+		}
 	} while (c != '\n');
 	conn->buf[conn->buflen] = '\0';
 	return (0);
+}
 /*
  * Write to a connection w/ timeout
  */
 ssize_t
 fetch_write(conn_t *conn, const char *buf, size_t len)
+{
 	struct iovec iov;
 	iov.iov_base = DECONST(char *, buf);
 	iov.iov_len = len;
 	return fetch_writev(conn, &iov, 1);
+}
 /*
  * Write a vector to a connection w/ timeout
  * Note: can modify the iovec.
  */
 ssize_t
 fetch_writev(conn_t *conn, struct iovec *iov, int iovcnt)
+{
 	struct timeval now, timeout, waittv;
 	fd_set writefds;
 	ssize_t wlen, total;
 	int r;
 	if (fetchTimeout) {
 		FD_ZERO(&writefds);
 		gettimeofday(&timeout, NULL);
 		timeout.tv_sec += fetchTimeout;
+	}
 	total = 0;
 	while (iovcnt > 0) {
 		while (fetchTimeout && !FD_ISSET(conn->sd, &writefds)) {
 			FD_SET(conn->sd, &writefds);
 			gettimeofday(&now, NULL);
 			waittv.tv_sec = timeout.tv_sec - now.tv_sec;
 			waittv.tv_usec = timeout.tv_usec - now.tv_usec;
 			if (waittv.tv_usec < 0) {
 				waittv.tv_usec += 1000000;
 				waittv.tv_sec--;
+			}
 			if (waittv.tv_sec < 0) {
 				errno = ETIMEDOUT;
 				fetch_syserr();
 				return (-1);
+			}
 			errno = 0;
 			r = select(conn->sd + 1, NULL, &writefds, NULL, &waittv);
 			if (r == -1) {
 				if (errno == EINTR && fetchRestartCalls)
 					continue;
 				return (-1);
+			}
+		}
 		errno = 0;
 #ifdef WITH_SSL
 		if (conn->ssl != NULL)
 			wlen = SSL_write(conn->ssl,
 			    iov->iov_base, iov->iov_len);
 		else
 #endif
 			wlen = writev(conn->sd, iov, iovcnt);
 		if (wlen == 0) {
 			/* we consider a short write a failure */
 			errno = EPIPE;
 			fetch_syserr();
 			return (-1);
+		}
 		if (wlen < 0) {
 			if (errno == EINTR && fetchRestartCalls)
 				continue;
 			return (-1);
+		}
 		total += wlen;
 		while (iovcnt > 0 && wlen >= (ssize_t)iov->iov_len) {
 			wlen -= iov->iov_len;
 			iov++;
 			iovcnt--;
+		}
 		if (iovcnt > 0) {
 			iov->iov_len -= wlen;
 			iov->iov_base = DECONST(char *, iov->iov_base) + wlen;
+		}
+	}
 	return (total);
+}
 /*
  * Write a line of text to a connection w/ timeout
  */
 int
 fetch_putln(conn_t *conn, const char *str, size_t len)
+{
 	struct iovec iov[2];
 	int ret;
 	iov[0].iov_base = DECONST(char *, str);
 	iov[0].iov_len = len;
 	iov[1].iov_base = DECONST(char *, ENDL);
 	iov[1].iov_len = sizeof(ENDL);
 	if (len == 0)
 		ret = fetch_writev(conn, &iov[1], 1);
 	else
 		ret = fetch_writev(conn, iov, 2);
 	if (ret == -1)
 		return (-1);
 	return (0);
+}
 /*
  * Close connection
  */
 int
 fetch_close(conn_t *conn)
+{
 	int ret;
 	if (--conn->ref > 0)
 		return (0);
 	ret = close(conn->sd);
 	free(conn->buf);
 	free(conn);
 	return (ret);
+}
 /*** Directory-related utility functions *************************************/
 int
 fetch_add_entry(struct url_ent **p, int *size, int *len,
     const char *name, struct url_stat *us)
+{
 	struct url_ent *tmp;
 	if (*p == NULL) {
 		*size = 0;
 		*len = 0;
+	}
 	if (*len >= *size - 1) {
 		tmp = realloc(*p, (*size * 2 + 1) * sizeof(**p));
 		if (tmp == NULL) {
 			errno = ENOMEM;
 			fetch_syserr();
 			return (-1);
+		}
 		*size = (*size * 2 + 1);
 		*p = tmp;
+	}
 	tmp = *p + *len;
 	snprintf(tmp->name, PATH_MAX, "%s", name);
 	if (us)
 		memcpy(&tmp->stat, us, sizeof(*us));
 	else
 		memset(&tmp->stat, 0, sizeof(*us));
 	(*len)++;
 	(++tmp)->name[0] = 0;
 	return (0);
+}
 /*** Authentication-related utility functions ********************************/
 static const char *
 fetch_read_word(FILE *f)
+{
 	static char word[1024];
 	if (fscanf(f, " %1023s ", word) != 1)
 		return (NULL);
 	return (word);
+}
 /*
  * Get authentication data for a URL from .netrc
  */
 int
 fetch_netrc_auth(struct url *url)
+{
 	char fn[PATH_MAX];
 	const char *word;
 	char *p;
 	FILE *f;
 	if ((p = getenv("NETRC")) != NULL) {
 		if (snprintf(fn, sizeof(fn), "%s", p) >= (int)sizeof(fn)) {
 			fetch_info("$NETRC specifies a file name "
 			    "longer than PATH_MAX");
 			return (-1);
+		}
 	} else {
 		if ((p = getenv("HOME")) != NULL) {
 			struct passwd *pwd;
 			if ((pwd = getpwuid(getuid())) == NULL ||
 			    (p = pwd->pw_dir) == NULL)
 				return (-1);
+		}
 		if (snprintf(fn, sizeof(fn), "%s/.netrc", p) >= (int)sizeof(fn))
 			return (-1);
+	}
 	if ((f = fopen(fn, "r")) == NULL)
 		return (-1);
 	while ((word = fetch_read_word(f)) != NULL) {
 		if (strcmp(word, "default") == 0)
 			break;
 		if (strcmp(word, "machine") == 0 &&
 		    (word = fetch_read_word(f)) != NULL &&
 		    strcasecmp(word, url->host) == 0) {
 			break;
+		}
+	}
 	if (word == NULL)
 		goto ferr;
 	while ((word = fetch_read_word(f)) != NULL) {
 		if (strcmp(word, "login") == 0) {
 			if ((word = fetch_read_word(f)) == NULL)
 				goto ferr;
 			if (snprintf(url->user, sizeof(url->user),
 				"%s", word) > (int)sizeof(url->user)) {
 				fetch_info("login name in .netrc is too long");
 				url->user[0] = '\0';
+			}
 		} else if (strcmp(word, "password") == 0) {
 			if ((word = fetch_read_word(f)) == NULL)
 				goto ferr;
 			if (snprintf(url->pwd, sizeof(url->pwd),
 				"%s", word) > (int)sizeof(url->pwd)) {
 				fetch_info("password in .netrc is too long");
 				url->pwd[0] = '\0';
+			}
 		} else if (strcmp(word, "account") == 0) {
 			if ((word = fetch_read_word(f)) == NULL)
 				goto ferr;
 			/* XXX not supported! */
 		} else {
 			break;
+		}
+	}
 	fclose(f);
 	return (0);
  ferr:
 	fclose(f);
 	return (-1);
+}
 /*
  * The no_proxy environment variable specifies a set of domains for
  * which the proxy should not be consulted; the contents is a comma-,
  * or space-separated list of domain names.  A single asterisk will
  * override all proxy variables and no transactions will be proxied
  * (for compatability with lynx and curl, see the discussion at
  * <http://curl.haxx.se/mail/archive_pre_oct_99/0009.html>).
  */
 int
 fetch_no_proxy_match(const char *host)
+{
 	const char *no_proxy, *p, *q;
 	size_t h_len, d_len;
 	if ((no_proxy = getenv("NO_PROXY")) == NULL &&
 	    (no_proxy = getenv("no_proxy")) == NULL)
 		return (0);
 	/* asterisk matches any hostname */
 	if (strcmp(no_proxy, "*") == 0)
 		return (1);
 	h_len = strlen(host);
 	p = no_proxy;
 	do {
 		/* position p at the beginning of a domain suffix */
 		while (*p == ',' || isspace((unsigned char)*p))
 			p++;
 		/* position q at the first separator character */
 		for (q = p; *q; ++q)
 			if (*q == ',' || isspace((unsigned char)*q))
 				break;
 		d_len = q - p;
 		if (d_len > 0 && h_len > d_len &&
 		    strncasecmp(host + h_len - d_len,
 			p, d_len) == 0) {
 			/* domain name matches */
 			return (1);
+		}
 		p = q + 1;
 	} while (*q);
 	return (0);
+}
 struct fetchIO {
 	void *io_cookie;
 	ssize_t (*io_read)(void *, void *, size_t);
 	ssize_t (*io_write)(void *, const void *, size_t);
 	void (*io_close)(void *);
 };
 void
 fetchIO_close(fetchIO *f)
+{
 	if (f->io_close != NULL)
 		(*f->io_close)(f->io_cookie);
 	free(f);
+}
 fetchIO *
 fetchIO_unopen(void *io_cookie, ssize_t (*io_read)(void *, void *, size_t),
     ssize_t (*io_write)(void *, const void *, size_t),
     void (*io_close)(void *))
+{
 	fetchIO *f;
 	f = malloc(sizeof(*f));
 	if (f == NULL)
 		return f;
 	f->io_cookie = io_cookie;
 	f->io_read = io_read;
 	f->io_write = io_write;
 	f->io_close = io_close;
 	return f;
+}
 ssize_t
 fetchIO_read(fetchIO *f, void *buf, size_t len)
+{
 	if (f->io_read == NULL)
 		return EBADF;
 	return (*f->io_read)(f->io_cookie, buf, len);
+}
 ssize_t
 fetchIO_write(fetchIO *f, const void *buf, size_t len)
+{
 	if (f->io_read == NULL)
 		return EBADF;
 	return (*f->io_write)(f->io_cookie, buf, len);
+}

 @@ -1,1002 +1,1003 @@
-/*	$NetBSD: ftp.c,v 1.16 2008/04/17 08:35:20 joerg Exp $	*/
+/*	$NetBSD: ftp.c,v 1.17 2008/04/17 19:04:12 joerg Exp $	*/
 /*-
  * Copyright (c) 1998-2004 Dag-Erling Coïdan Smørgrav
  * Copyright (c) 2008 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 $
+ *
  */
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
 #include <nbcompat.h>
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <netinet/in.h>
 #include <ctype.h>
 #include <errno.h>
 #include <fcntl.h>
 #include <inttypes.h>
 #include <netdb.h>
 #include <stdarg.h>
 #ifndef NETBSD
 #include <nbcompat/stdio.h>
 #else
 #include <stdio.h>
 #endif
 #include <stdlib.h>
 #include <string.h>
 #include <time.h>
 #include <unistd.h>
 #include "fetch.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
 static struct url cached_host;
 static conn_t	*cached_connection;
 #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] == '-')
 /*
  * 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
+}
 /*
  * 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
  */
 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_putln(conn, msg, len);
 	free(msg);
 	if (r == -1) {
 		fetch_syserr();
 		return (-1);
+	}
 	return (ftp_chkerr(conn));
+}
 /*
  * 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, size_t pwdlen)
+{
 	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);
 	for (q = 0, dst = pwd; src < end && pwdlen--; ++src) {
 		if (!q && *src == '"')
 			q = 1;
 		else if (q && *src != '"')
 			break;
 		else if (q)
 			*dst++ = '"', q = 0;
 		else
 			*dst++ = *src;
+	}
 	if (!pwdlen)
 		return (FTP_PROTOCOL_ERROR);
 	*dst = '\0';
 	return (FTP_OK);
+}
 /*
  * Change working directory to the directory that contains the specified
  * file.
  */
 static int
 ftp_cwd(conn_t *conn, const char *file, int subdir)
+{
 	const char *beg, *end;
 	char pwd[PATH_MAX];
 	int e, i, len;
 	/* If no slashes in name, no need to change dirs. */
 	if (subdir)
 		end = file + strlen(file);
 	else if ((end = strrchr(file, '/')) == NULL)
 		return (0);
 	if ((e = ftp_cmd(conn, "PWD")) != FTP_WORKING_DIRECTORY ||
 	    (e = ftp_pwd(conn, pwd, sizeof(pwd))) != FTP_OK) {
 		ftp_seterr(e);
 		return (-1);
+	}
 	for (;;) {
 		len = strlen(pwd);
 		/* Look for a common prefix between PWD and dir to fetch. */
 		for (i = 0; i <= len && i <= end - file; ++i)
 			if (pwd[i] != file[i])
 				break;
 		/* Keep going up a dir until we have a matching prefix. */
 		if (strcmp(pwd, "/") == 0)
 			break;
 		if (pwd[i] == '\0' && (file[i - 1] == '/' || file[i] == '/'))
 			break;
 		if ((e = ftp_cmd(conn, "CDUP")) != FTP_FILE_ACTION_OK ||
 		    (e = ftp_cmd(conn, "PWD")) != FTP_WORKING_DIRECTORY ||
 		    (e = ftp_pwd(conn, pwd, sizeof(pwd))) != FTP_OK) {
 			ftp_seterr(e);
 			return (-1);
+		}
+	}
 #ifdef FTP_COMBINE_CWDS
 	/* Skip leading slashes, even "////". */
 	for (beg = file + i; beg < end && *beg == '/'; ++beg, ++i)
 		/* nothing */ ;
 	/* If there is no trailing dir, we're already there. */
 	if (beg >= end)
 		return (0);
 	/* Change to the directory all in one chunk (e.g., foo/bar/baz). */
 	e = ftp_cmd(conn, "CWD %.*s", (int)(end - beg), beg);
 	if (e == FTP_FILE_ACTION_OK)
 		return (0);
 #endif /* FTP_COMBINE_CWDS */
 	/* That didn't work so go back to legacy behavior (multiple CWDs). */
 	for (beg = file + i; beg < end; beg = file + i + 1) {
 		while (*beg == '/')
 			++beg, ++i;
 		for (++i; file + i < end && file[i] != '/'; ++i)
 			/* nothing */ ;
 		e = ftp_cmd(conn, "CWD %.*s", file + i - beg, beg);
 		if (e != FTP_FILE_ACTION_OK) {
 			ftp_seterr(e);
 			return (-1);
+		}
+	}
 	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", 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", 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", 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", 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 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->dir = -1;
 	io->dconn = NULL;
 	r = ftp_chkerr(io->cconn);
 	if (io->cconn == cached_connection && io->cconn->ref == 1)
 		cached_connection = NULL;
 	fetch_close(io->cconn);
 	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)
+{
 	struct sockaddr_storage sa;
 	struct sockaddr_in6 *sin6;
 	struct sockaddr_in *sin4;
 	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('p');
 	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(sa);
 	if (getsockname(conn->sd, (struct sockaddr *)&sa, &l) == -1)
 		goto sysouch;
 	if (sa.ss_family == AF_INET6)
 		unmappedaddr((struct sockaddr_in6 *)&sa, &l);
 	/* open data socket */
 	if ((sd = socket(sa.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 (sa.ss_family) {
 		case AF_INET:
 			if ((e = ftp_cmd(conn, "PASV")) != FTP_PASSIVE_MODE)
 				goto ouch;
 			break;
 		case AF_INET6:
 			if ((e = ftp_cmd(conn, "EPSV")) != FTP_EPASSIVE_MODE) {
 				if (e == -1)
 					goto ouch;
 				if ((e = ftp_cmd(conn, "LPSV")) !=
 				    FTP_LPASSIVE_MODE)
 					goto ouch;
+			}
 			break;
 		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;
+		}
 		/* seek to required offset */
 		if (offset)
 			if (ftp_cmd(conn, "REST %lu", (unsigned long)offset) != FTP_FILE_OK)
 				goto sysouch;
 		/* construct sockaddr for data socket */
 		l = sizeof(sa);
 		if (getpeername(conn->sd, (struct sockaddr *)&sa, &l) == -1)
 			goto sysouch;
 		if (sa.ss_family == AF_INET6)
 			unmappedaddr((struct sockaddr_in6 *)&sa, &l);
 		switch (sa.ss_family) {
 		case AF_INET6:
 			sin6 = (struct sockaddr_in6 *)&sa;
 			if (e == FTP_EPASSIVE_MODE)
 				sin6->sin6_port = htons(port);
 			else {
 				memcpy(&sin6->sin6_addr, addr + 2, 16);
 				memcpy(&sin6->sin6_port, addr + 19, 2);
+			}
 			break;
 		case AF_INET:
 			sin4 = (struct sockaddr_in *)&sa;
 			if (e == FTP_EPASSIVE_MODE)
 				sin4->sin_port = htons(port);
 			else {
 				memcpy(&sin4->sin_addr, addr, 4);
 				memcpy(&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, sa.ss_family, bindaddr) != 0)
 			goto sysouch;
 		if (connect(sd, (struct sockaddr *)&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", oper, *op_arg ? " " : "", op_arg);
 		else
 			e = ftp_cmd(conn, "%s %.*s", 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;
 		char *ap;
 		char hname[INET6_ADDRSTRLEN];
 		switch (sa.ss_family) {
 		case AF_INET6:
 			((struct sockaddr_in6 *)&sa)->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;
 		case AF_INET:
 			((struct sockaddr_in *)&sa)->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, (struct sockaddr *)&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, (struct sockaddr *)&sa, &l) == -1)
 			goto sysouch;
 		switch (sa.ss_family) {
 		case AF_INET:
 			sin4 = (struct sockaddr_in *)&sa;
 			a = ntohl(sin4->sin_addr.s_addr);
 			p = ntohs(sin4->sin_port);
 			e = ftp_cmd(conn, "PORT %d,%d,%d,%d,%d,%d",
 			    (a >> 24) & 0xff, (a >> 16) & 0xff,
 			    (a >> 8) & 0xff, a & 0xff,
 			    (p >> 8) & 0xff, p & 0xff);
 			break;
 		case AF_INET6:
 #define UC(b)	(((int)b)&0xff)
 			e = -1;
 			sin6 = (struct sockaddr_in6 *)&sa;
 			sin6->sin6_scope_id = 0;
 			if (getnameinfo((struct sockaddr *)&sa, l,
 				hname, sizeof(hname),
 				NULL, 0, NI_NUMERICHOST) == 0) {
 				e = ftp_cmd(conn, "EPRT |%d|%s|%d|", 2, hname,
 				    htons(sin6->sin6_port));
 				if (e == -1)
 					goto ouch;
+			}
 			if (e != FTP_OK) {
 				ap = (char *)&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",
 , 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]),
 ,
 				    (ntohs(sin6->sin6_port) >> 8) & 0xff,
 				    ntohs(sin6->sin6_port)        & 0xff);
+			}
 			break;
 		default:
 			e = FTP_PROTOCOL_ERROR; /* XXX: error code should be prepared */
 			goto ouch;
+		}
 		if (e != FTP_OK)
 			goto ouch;
 		/* seek to required offset */
 		if (offset)
 			if (ftp_cmd(conn, "REST %llu", (unsigned long long)offset) != FTP_FILE_OK)
 				goto sysouch;
 		/* make the server initiate the transfer */
 		if (verbose)
 			fetch_info("initiating transfer");
 		if (op_arg)
 			e = ftp_cmd(conn, "%s%s%s", oper, *op_arg ? " " : "", op_arg);
 		else
 			e = ftp_cmd(conn, "%s %.*s", oper,
 			    filenamelen, filename);
 		if (e != FTP_CONNECTION_ALREADY_OPEN && e != FTP_OPEN_DATA_CONNECTION)
 			goto ouch;
 		/* accept the incoming connection and go to town */
 		if ((d = accept(sd, NULL, NULL)) == -1)
 			goto sysouch;
 		close(sd);
 		sd = d;
+	}
 	if ((df = ftp_setup(conn, fetch_reopen(sd), mode)) == NULL)
 		goto sysouch;
 	return (df);
 sysouch:
 	fetch_syserr();
 	if (sd >= 0)
 		close(sd);
 	return (NULL);
 ouch:
 	if (e != -1)
 		ftp_seterr(e);
 	if (sd >= 0)
 		close(sd);
 	return (NULL);
+}
 /*
  * Authenticate
  */
 static int
 ftp_authenticate(conn_t *conn, struct url *url, struct url *purl)
+{
 	const char *user, *pwd, *login_name;
 	char pbuf[URL_USERLEN + 1 + URL_HOSTLEN + 1];
 	int e, len;
 	/* XXX FTP_AUTH, and maybe .netrc */
 	/* send user name and password */
 	if (url->user[0] == '\0')
 		fetch_netrc_auth(url);
 	user = url->user;
 	if (*user == '\0')
 		user = getenv("FTP_LOGIN");
 	if (user == NULL || *user == '\0')
 		user = FTP_ANONYMOUS_USER;
 	if (purl && url->port == fetch_default_port(url->scheme))
 		e = ftp_cmd(conn, "USER %s@%s", user, url->host);
 	else if (purl)
 		e = ftp_cmd(conn, "USER %s@%s@%d", user, url->host, url->port);
 	else
 		e = ftp_cmd(conn, "USER %s", user);
 	/* did the server request a password? */
 	if (e == FTP_NEED_PASSWORD) {
 		pwd = url->pwd;
 		if (*pwd == '\0')
 			pwd = getenv("FTP_PASSWORD");
 		if (pwd == NULL || *pwd == '\0') {
 			if ((login_name = getlogin()) == 0)
 				login_name = FTP_ANONYMOUS_USER;
 			if ((len = snprintf(pbuf, URL_USERLEN + 2, "%s@", login_name)) < 0)
 				len = 0;
 			else if (len > URL_USERLEN + 1)
 				len = URL_USERLEN + 1;
 			gethostname(pbuf + len, sizeof(pbuf) - len);
 			/* MAXHOSTNAMELEN can differ from URL_HOSTLEN + 1 */
 			pbuf[sizeof(pbuf) - 1] = '\0';
 			pwd = pbuf;
+		}
 		e = ftp_cmd(conn, "PASS %s", pwd);
+	}
 	return (e);
+}
 /*
  * Log on to FTP server
  */
 static conn_t *
 ftp_connect(struct url *url, struct url *purl, const char *flags)
+{
 	conn_t *conn;
 	int e, direct, verbose;
 #ifdef INET6
 	int af = AF_UNSPEC;
 #else
 	int af = AF_INET;
 #endif
 	direct = CHECK_FLAG('d');
 	verbose = CHECK_FLAG('v');
 	if (CHECK_FLAG('4'))
 		af = AF_INET;
 	else if (CHECK_FLAG('6'))
 		af = AF_INET6;
 	if (direct)
 		purl = NULL;
 	/* check for proxy */
 	if (purl) {
 		/* XXX proxy authentication! */
 		conn = fetch_connect(purl->host, purl->port, af, verbose);
 	} else {
 		/* no proxy, go straight to target */
 		conn = fetch_connect(url->host, url->port, af, verbose);
 		purl = NULL;
+	}
 	/* check connection */
 	if (conn == NULL)
 		/* fetch_connect() has already set an error code */
 		return (NULL);
 	/* expect welcome message */
 	if ((e = ftp_chkerr(conn)) != FTP_SERVICE_READY)
 		goto fouch;
 	/* authenticate */
 	if ((e = ftp_authenticate(conn, url, purl)) != FTP_LOGGED_IN)
 		goto fouch;
 	/* TODO: Request extended features supported, if any (RFC 3659). */
 	/* done */
 	return (conn);