 @@ -1,1311 +1,1312 @@
-/*	$NetBSD: ftp.c,v 1.6 2013/10/19 22:58:40 mrg Exp $	*/
+/*	$NetBSD: ftp.c,v 1.7 2014/01/07 02:13:00 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
 #ifndef NETBSD
 #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>
 #ifndef NETBSD
 #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 "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
 #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;
 	void *addrp;
 	uint32_t addr;
 	int port;
 	if (sin6->sin6_family != AF_INET6 ||
 	    !IN6_IS_ADDR_V4MAPPED(&sin6->sin6_addr))
 		return;
 	sin4 = (struct sockaddr_in *)(void *)sin6;
 	addrp = &sin6->sin6_addr.s6_addr[12];
 	addr = *(uint32_t *)addrp;
 	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
  */
 __printflike(2, 3)
 static int
 ftp_cmd(conn_t *conn, const char *fmt, ...)
+{
 	va_list ap;
 	size_t len;
 	char *msg;
 	ssize_t 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));
+}
 /*
  * Return a pointer to the filename part of a path
  */
 static const char *
 ftp_filename(const char *file, size_t *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;
 	size_t len;
 	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);
 	len = end - src + 1;
 	*pwd = malloc(len);
 	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;
 	size_t 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 {
 		asprintf(&dst, "%s/%s", conn->ftp_home, path);
+	}
 	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 <= (size_t)(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);
+		e = ftp_cmd(conn, "CWD %.*s\r\n", (int)(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';
 		/*FALLTHROUGH*/
 	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';
 		/*FALLTHROUGH*/
 	case 'I':
 		break;
 	case 'a':
 		type = 'A';
 		/*FALLTHROUGH*/
 	case 'A':
 		break;
 	case 'd':
 		type = 'D';
 		/*FALLTHROUGH*/
 	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;
 	size_t filenamelen;
 	int 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);
+	e = ftp_cmd(conn, "SIZE %.*s\r\n", (int)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);
+	e = ftp_cmd(conn, "MDTM %.*s\r\n", (int)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;
 	ssize_t 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;
 	ssize_t 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;
 	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;
 	(void)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;
 	size_t filenamelen;
 	int 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;
 	if (u.ss.ss_family == AF_INET6)
 		unmappedaddr(&u.sin6, &l);
 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;
 		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;
 		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] = (unsigned char)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;
 		if (u.ss.ss_family == AF_INET6)
 			unmappedaddr(&u.sin6, &l);
 		switch (u.ss.ss_family) {
 		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;
 		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);
+			    (int)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 hname[INET6_ADDRSTRLEN];
 		switch (u.ss.ss_family) {
 		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,
 				&arg, (socklen_t)sizeof(arg)) == -1)
 				goto sysouch;
 #endif
 			break;
 		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,
 				&arg, (socklen_t)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,
 			    ((unsigned int)p >> 8) & 0xff, p & 0xff);
 			break;
 		case AF_INET6:
 			e = -1;
 			u.sin6.sin6_scope_id = 0;
 			if (getnameinfo(&u.sa, l,
 				hname, (socklen_t)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) {
 				uint8_t aa[sizeof(u.sin6.sin6_addr)];
 				memcpy(aa, &u.sin6.sin6_addr, sizeof(aa));
 				p = ntohs(u.sin6.sin6_port);
 				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",
 , 16,
 				    aa[ 0], aa[ 1], aa[ 2], aa[ 3],
 				    aa[ 4], aa[ 5], aa[ 6], aa[ 7],
 				    aa[ 8], aa[ 9], aa[10], aa[11],
 				    aa[12], aa[13], aa[14], aa[15],
 ,
 				    ((unsigned int)p >> 8) & 0xff, p & 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\r\n", (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\r\n", oper, *op_arg ? " " : "", op_arg);
 		else
 			e = ftp_cmd(conn, "%s %.*s\r\n", oper,
-			    filenamelen, filename);
+			    (int)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\r\n", user, url->host);
 	else if (purl)
 		e = ftp_cmd(conn, "USER %s@%s@%d\r\n", user, url->host, url->port);
 	else
 		e = ftp_cmd(conn, "USER %s\r\n", 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\r\n", 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! */
 		/* XXX connetion caching */
 		if (!purl->port)
 			purl->port = fetch_default_port(purl->scheme);
 		conn = fetch_connect(purl, af, verbose);
 	} else {
 		/* no proxy, go straight to target */
 		if (!url->port)
 			url->port = fetch_default_port(url->scheme);
 		while ((conn = fetch_cache_get(url, af)) != NULL) {
 			e = ftp_cmd(conn, "NOOP\r\n");
 			if (e == FTP_OK)
 				return conn;
 			fetch_close(conn);
+		}
 		conn = fetch_connect(url, 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);
 fouch:
 	if (e != -1)
 		ftp_seterr(e);
 	fetch_close(conn);
 	return (NULL);
+}
 /*
  * Check the proxy settings
  */
 static struct url *
 ftp_get_proxy(struct url * url, const char *flags)
+{
 	struct url *purl;
 	char *p, *fp, *FP, *hp, *HP;
 	if (flags != NULL && strchr(flags, 'd') != NULL)
 		return NULL;
 	if (fetch_no_proxy_match(url->host))
 		return NULL;
 	FP = getenv("FTP_PROXY");
 	fp = getenv("ftp_proxy");
 	HP = getenv("HTTP_PROXY");
 	hp = getenv("http_proxy");
 	if ((((p = FP) || (p = fp) || (p = HP) || (p = hp))) &&
 	    *p && (purl = fetchParseURL(p)) != NULL) {
 		if (!*purl->scheme) {
 			if (fp || FP)
 				strcpy(purl->scheme, SCHEME_FTP);
 			else
 				strcpy(purl->scheme, SCHEME_HTTP);
+		}
 		if (!purl->port)
 			purl->port = fetch_default_proxy_port(purl->scheme);
 		if (strcasecmp(purl->scheme, SCHEME_FTP) == 0 ||
 		    strcasecmp(purl->scheme, SCHEME_HTTP) == 0)
 			return purl;
 		fetchFreeURL(purl);
+	}
 	return NULL;
+}
 /*
  * Process an FTP request
  */
 fetchIO *
 ftp_request(struct url *url, const char *op, const char *op_arg,
     struct url_stat *us, struct url *purl, const char *flags)
+{
 	fetchIO *f;
 	char *path;
 	conn_t *conn;
 	int if_modified_since, oflag;
 	struct url_stat local_us;
 	/* check if we should use HTTP instead */
 	if (purl && strcasecmp(purl->scheme, SCHEME_HTTP) == 0) {
 		if (strcmp(op, "STAT") == 0)
 			return (http_request(url, "HEAD", us, purl, flags));
 		else if (strcmp(op, "RETR") == 0)
 			return (http_request(url, "GET", us, purl, flags));
 		/*
 		 * Our HTTP code doesn't support PUT requests yet, so try
 		 * a direct connection.
 		 */
+	}
 	/* connect to server */
 	conn = ftp_connect(url, purl, flags);
 	if (purl)
 		fetchFreeURL(purl);
 	if (conn == NULL)
 		return (NULL);
 	if ((path = fetchUnquotePath(url)) == NULL) {
 		fetch_syserr();
 		return NULL;
+	}
 	/* change directory */
 	if (ftp_cwd(conn, path, op_arg != NULL) == -1) {
 		free(path);
 		return (NULL);
+	}
 	if_modified_since = CHECK_FLAG('i');
 	if (if_modified_since && us == NULL)
 		us = &local_us;
 	/* stat file */
 	if (us && ftp_stat(conn, path, us) == -1
 	    && fetchLastErrCode != FETCH_PROTO
 	    && fetchLastErrCode != FETCH_UNAVAIL) {
 		free(path);
 		return (NULL);
+	}
 	if (if_modified_since && url->last_modified > 0 &&
 	    url->last_modified >= us->mtime) {
 		free(path);
 		fetchLastErrCode = FETCH_UNCHANGED;
 		snprintf(fetchLastErrString, MAXERRSTRING, "Unchanged");
 		return NULL;
+	}
 	/* just a stat */
 	if (strcmp(op, "STAT") == 0) {
 		free(path);
 		return fetchIO_unopen(NULL, NULL, NULL, NULL);
+	}
 	if (strcmp(op, "STOR") == 0 || strcmp(op, "APPE") == 0)
 		oflag = O_WRONLY;
 	else
 		oflag = O_RDONLY;
 	/* initiate the transfer */
 	f = (ftp_transfer(conn, op, path, op_arg, oflag, url->offset, flags));
 	free(path);
 	return f;
+}
 /*
  * Get and stat file
  */
 fetchIO *
 fetchXGetFTP(struct url *url, struct url_stat *us, const char *flags)
+{
 	return (ftp_request(url, "RETR", NULL, us, ftp_get_proxy(url, flags), flags));
+}
 /*
  * Get file
  */
 fetchIO *
 fetchGetFTP(struct url *url, const char *flags)
+{
 	return (fetchXGetFTP(url, NULL, flags));
+}
 /*
  * Put file
  */
 fetchIO *
 fetchPutFTP(struct url *url, const char *flags)
+{
 	return (ftp_request(url, CHECK_FLAG('a') ? "APPE" : "STOR", NULL, NULL,
 	    ftp_get_proxy(url, flags), flags));
+}
 /*
  * Get file stats
  */
 int
 fetchStatFTP(struct url *url, struct url_stat *us, const char *flags)
+{
 	fetchIO *f;
 	f = ftp_request(url, "STAT", NULL, us, ftp_get_proxy(url, flags), flags);
 	if (f == NULL)
 		return (-1);
 	fetchIO_close(f);
 	return (0);
+}
 /*
  * List a directory
  */
 int
 fetchListFTP(struct url_list *ue, struct url *url, const char *pattern, const char *flags)
+{
 	fetchIO *f;
 	char buf[2 * PATH_MAX], *eol, *eos;
 	ssize_t len;
 	size_t cur_off;
 	int ret;
 	/* XXX What about proxies? */
 	if (pattern == NULL || strcmp(pattern, "*") == 0)
 		pattern = "";
 	f = ftp_request(url, "NLST", pattern, NULL, ftp_get_proxy(url, flags), flags);
 	if (f == NULL)
 		return -1;
 	cur_off = 0;
 	ret = 0;
 	while ((len = fetchIO_read(f, buf + cur_off, sizeof(buf) - cur_off)) > 0) {
 		cur_off += len;
 		while ((eol = memchr(buf, '\n', cur_off)) != NULL) {
 			if (len == eol - buf)
 				break;
 			if (eol != buf) {
 				if (eol[-1] == '\r')
 					eos = eol - 1;
 				else
 					eos = eol;
 				*eos = '\0';
 				ret = fetch_add_entry(ue, url, buf, 0);
 				if (ret)
 					break;
 				cur_off -= eol - buf + 1;
 				memmove(buf, eol + 1, cur_off);
+			}
+		}
 		if (ret)
 			break;
+	}
 	if (cur_off != 0 || len < 0) {
 		/* Not RFC conform, bail out. */
 		fetchIO_close(f);
 		return -1;
+	}
 	fetchIO_close(f);
 	return ret;
+}

 @@ -1,1405 +1,1406 @@
-/*	$NetBSD: http.c,v 1.2 2011/06/25 20:27:01 christos Exp $	*/
+/*	$NetBSD: http.c,v 1.3 2014/01/07 02:13:00 joerg Exp $	*/
 /*-
  * Copyright (c) 2000-2004 Dag-Erling Coïdan Smørgrav
  * Copyright (c) 2003 Thomas Klausner <wiz@NetBSD.org>
  * Copyright (c) 2008, 2009 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: http.c,v 1.83 2008/02/06 11:39:55 des Exp $
  */
 /*
  * The following copyright applies to the base64 code:
+ *
  *-
  * Copyright 1997 Massachusetts Institute of Technology
+ *
  * Permission to use, copy, modify, and distribute this software and
  * its documentation for any purpose and without fee is hereby
  * granted, provided that both the above copyright notice and this
  * permission notice appear in all copies, that both the above
  * copyright notice and this permission notice appear in all
  * supporting documentation, and that the name of M.I.T. not be used
  * in advertising or publicity pertaining to distribution of the
  * software without specific, written prior permission.  M.I.T. makes
  * no representations about the suitability of this software for any
  * purpose.  It is provided "as is" without express or implied
  * warranty.
+ *
  * THIS SOFTWARE IS PROVIDED BY M.I.T. ``AS IS''.  M.I.T. DISCLAIMS
  * ALL EXPRESS OR IMPLIED WARRANTIES WITH REGARD TO THIS SOFTWARE,
  * INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
  * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT
  * SHALL M.I.T. 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.
  */
 #if defined(__linux__) || defined(__MINT__)
 /* Keep this down to Linux or MiNT, it can create surprises elsewhere. */
 #define _GNU_SOURCE
 #endif
 /* Needed for gmtime_r on Interix */
 #define _REENTRANT
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
 #ifndef NETBSD
 #include <nbcompat.h>
 #endif
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <ctype.h>
 #include <errno.h>
 #include <locale.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 <netinet/in.h>
 #include <netinet/tcp.h>
 #ifndef NETBSD
 #include <nbcompat/netdb.h>
 #else
 #include <netdb.h>
 #endif
 #include <arpa/inet.h>
 #include "fetch.h"
 #include "common.h"
 #include "httperr.h"
 /* Maximum number of redirects to follow */
 #define MAX_REDIRECT 5
 /* Symbolic names for reply codes we care about */
 #define HTTP_OK			200
 #define HTTP_PARTIAL		206
 #define HTTP_MOVED_PERM		301
 #define HTTP_MOVED_TEMP		302
 #define HTTP_SEE_OTHER		303
 #define HTTP_NOT_MODIFIED	304
 #define HTTP_TEMP_REDIRECT	307
 #define HTTP_NEED_AUTH		401
 #define HTTP_NEED_PROXY_AUTH	407
 #define HTTP_BAD_RANGE		416
 #define HTTP_PROTOCOL_ERROR	999
 #define HTTP_REDIRECT(xyz) ((xyz) == HTTP_MOVED_PERM \
 			    || (xyz) == HTTP_MOVED_TEMP \
 			    || (xyz) == HTTP_TEMP_REDIRECT \
 			    || (xyz) == HTTP_SEE_OTHER)
 #define HTTP_ERROR(xyz) ((xyz) > 400 && (xyz) < 599)
 /*****************************************************************************
  * I/O functions for decoding chunked streams
  */
 struct httpio
+{
 	conn_t		*conn;		/* connection */
 	int		 chunked;	/* chunked mode */
 	int		 keep_alive;	/* keep-alive mode */
 	char		*buf;		/* chunk buffer */
 	size_t		 bufsize;	/* size of chunk buffer */
 	ssize_t		 buflen;	/* amount of data currently in buffer */
 	size_t		 bufpos;	/* current read offset in buffer */
 	int		 eof;		/* end-of-file flag */
 	int		 error;		/* error flag */
 	size_t		 chunksize;	/* remaining size of current chunk */
 	off_t		 contentlength;	/* remaining size of the content */
 };
 /*
  * Get next chunk header
  */
 static ssize_t
 http_new_chunk(struct httpio *io)
+{
 	char *p;
 	if (fetch_getln(io->conn) == -1)
 		return (-1);
 	if (io->conn->buflen < 2 || !isxdigit((unsigned char)*io->conn->buf))
 		return (-1);
 	for (p = io->conn->buf; *p && !isspace((unsigned char)*p); ++p) {
 		if (*p == ';')
 			break;
 		if (!isxdigit((unsigned char)*p))
 			return (-1);
 		if (isdigit((unsigned char)*p)) {
 			io->chunksize = io->chunksize * 16 +
 			    *p - '0';
 		} else {
 			io->chunksize = io->chunksize * 16 +
 + tolower((unsigned char)*p) - 'a';
+		}
+	}
 	return (io->chunksize);
+}
 /*
  * Grow the input buffer to at least len bytes
  */
 static int
 http_growbuf(struct httpio *io, size_t len)
+{
 	char *tmp;
 	if (io->bufsize >= len)
 		return (0);
 	if ((tmp = realloc(io->buf, len)) == NULL)
 		return (-1);
 	io->buf = tmp;
 	io->bufsize = len;
 	return (0);
+}
 /*
  * Fill the input buffer, do chunk decoding on the fly
  */
 static ssize_t
 http_fillbuf(struct httpio *io, size_t len)
+{
 	if (io->error)
 		return (-1);
 	if (io->eof)
 		return (0);
 	if (io->contentlength >= 0 && (off_t)len > io->contentlength)
 		len = io->contentlength;
 	if (io->chunked == 0) {
 		if (http_growbuf(io, len) == -1)
 			return (-1);
 		if ((io->buflen = fetch_read(io->conn, io->buf, len)) == -1) {
 			io->error = 1;
 			return (-1);
+		}
 		if (io->contentlength)
 			io->contentlength -= io->buflen;
 		io->bufpos = 0;
 		return (io->buflen);
+	}
 	if (io->chunksize == 0) {
 		switch (http_new_chunk(io)) {
 		case -1:
 			io->error = 1;
 			return (-1);
 		case 0:
 			io->eof = 1;
 			if (fetch_getln(io->conn) == -1)
 				return (-1);
 			return (0);
+		}
+	}
 	if (len > io->chunksize)
 		len = io->chunksize;
 	if (http_growbuf(io, len) == -1)
 		return (-1);
 	if ((io->buflen = fetch_read(io->conn, io->buf, len)) == -1) {
 		io->error = 1;
 		return (-1);
+	}
 	io->chunksize -= io->buflen;
 	if (io->contentlength >= 0)
 		io->contentlength -= io->buflen;
 	if (io->chunksize == 0) {
 		char endl[2];
 		ssize_t len2;
 		len2 = fetch_read(io->conn, endl, 2);
 		if (len2 == 1 && fetch_read(io->conn, endl + 1, 1) != 1)
 			return (-1);
 		if (len2 == -1 || endl[0] != '\r' || endl[1] != '\n')
 			return (-1);
+	}
 	io->bufpos = 0;
 	return (io->buflen);
+}
 /*
  * Read function
  */
 static ssize_t
 http_readfn(void *v, void *buf, size_t len)
+{
 	struct httpio *io = (struct httpio *)v;
 	size_t l, pos;
 	if (io->error)
 		return (-1);
 	if (io->eof)
 		return (0);
 	for (pos = 0; len > 0; pos += l, len -= l) {
 		/* empty buffer */
 		if (!io->buf || (ssize_t)io->bufpos == io->buflen)
 			if (http_fillbuf(io, len) < 1)
 				break;
 		l = io->buflen - io->bufpos;
 		if (len < l)
 			l = len;
 		memcpy((char *)buf + pos, io->buf + io->bufpos, l);
 		io->bufpos += l;
+	}
 	if (!pos && io->error)
 		return (-1);
 	return (pos);
+}
 /*
  * Write function
  */
 static ssize_t
 http_writefn(void *v, const void *buf, size_t len)
+{
 	struct httpio *io = (struct httpio *)v;
 	return (fetch_write(io->conn, buf, len));
+}
 /*
  * Close function
  */
 static void
 http_closefn(void *v)
+{
 	struct httpio *io = (struct httpio *)v;
 	if (io->keep_alive) {
 		int val;
 		val = 0;
 		setsockopt(io->conn->sd, IPPROTO_TCP, TCP_NODELAY, &val,
 			   (socklen_t)sizeof(val));
 			  fetch_cache_put(io->conn, fetch_close);
 #ifdef TCP_NOPUSH
 		val = 1;
 		setsockopt(io->conn->sd, IPPROTO_TCP, TCP_NOPUSH, &val,
 		    sizeof(val));
 #endif
 	} else {
 		fetch_close(io->conn);
+	}
 	free(io->buf);
 	free(io);
+}
 /*
  * Wrap a file descriptor up
  */
 static fetchIO *
 http_funopen(conn_t *conn, int chunked, int keep_alive, off_t clength)
+{
 	struct httpio *io;
 	fetchIO *f;
 	if ((io = calloc(1, sizeof(*io))) == NULL) {
 		fetch_syserr();
 		return (NULL);
+	}
 	io->conn = conn;
 	io->chunked = chunked;
 	io->contentlength = clength;
 	io->keep_alive = keep_alive;
 	f = fetchIO_unopen(io, http_readfn, http_writefn, http_closefn);
 	if (f == NULL) {
 		fetch_syserr();
 		free(io);
 		return (NULL);
+	}
 	return (f);
+}
 /*****************************************************************************
  * Helper functions for talking to the server and parsing its replies
  */
 /* Header types */
 typedef enum {
 	hdr_syserror = -2,
 	hdr_error = -1,
 	hdr_end = 0,
 	hdr_unknown = 1,
 	hdr_connection,
 	hdr_content_length,
 	hdr_content_range,
 	hdr_last_modified,
 	hdr_location,
 	hdr_transfer_encoding,
 	hdr_www_authenticate
 } hdr_t;
 /* Names of interesting headers */
 static struct {
 	hdr_t		 num;
 	const char	*name;
 } hdr_names[] = {
 	{ hdr_connection,		"Connection" },
 	{ hdr_content_length,		"Content-Length" },
 	{ hdr_content_range,		"Content-Range" },
 	{ hdr_last_modified,		"Last-Modified" },
 	{ hdr_location,			"Location" },
 	{ hdr_transfer_encoding,	"Transfer-Encoding" },
 	{ hdr_www_authenticate,		"WWW-Authenticate" },
 	{ hdr_unknown,			NULL },
 };
 /*
  * Send a formatted line; optionally echo to terminal
  */
 __printflike(2, 3)
 static int
 http_cmd(conn_t *conn, const char *fmt, ...)
+{
 	va_list ap;
 	size_t len;
 	char *msg;
 	ssize_t 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 (0);
+}
 /*
  * Get and parse status line
  */
 static int
 http_get_reply(conn_t *conn)
+{
 	char *p;
 	if (fetch_getln(conn) == -1)
 		return (-1);
 	/*
 	 * A valid status line looks like "HTTP/m.n xyz reason" where m
 	 * and n are the major and minor protocol version numbers and xyz
 	 * is the reply code.
 	 * Unfortunately, there are servers out there (NCSA 1.5.1, to name
 	 * just one) that do not send a version number, so we can't rely
 	 * on finding one, but if we do, insist on it being 1.0 or 1.1.
 	 * We don't care about the reason phrase.
 	 */
 	if (strncmp(conn->buf, "HTTP", 4) != 0)
 		return (HTTP_PROTOCOL_ERROR);
 	p = conn->buf + 4;
 	if (*p == '/') {
 		if (p[1] != '1' || p[2] != '.' || (p[3] != '0' && p[3] != '1'))
 			return (HTTP_PROTOCOL_ERROR);
 		p += 4;
+	}
 	if (*p != ' ' ||
 	    !isdigit((unsigned char)p[1]) ||
 	    !isdigit((unsigned char)p[2]) ||
 	    !isdigit((unsigned char)p[3]))
 		return (HTTP_PROTOCOL_ERROR);
 	conn->err = (p[1] - '0') * 100 + (p[2] - '0') * 10 + (p[3] - '0');
 	return (conn->err);
+}
 /*
  * Check a header; if the type matches the given string, return a pointer
  * to the beginning of the value.
  */
 static const char *
 http_match(const char *str, const char *hdr)
+{
 	while (*str && *hdr &&
 	    tolower((unsigned char)*str++) == tolower((unsigned char)*hdr++))
 		/* nothing */;
 	if (*str || *hdr != ':')
 		return (NULL);
 	while (*hdr && isspace((unsigned char)*++hdr))
 		/* nothing */;
 	return (hdr);
+}
 /*
  * Get the next header and return the appropriate symbolic code.
  */
 static hdr_t
 http_next_header(conn_t *conn, const char **p)
+{
 	int i;
 	if (fetch_getln(conn) == -1)
 		return (hdr_syserror);
 	while (conn->buflen && isspace((unsigned char)conn->buf[conn->buflen - 1]))
 		conn->buflen--;
 	conn->buf[conn->buflen] = '\0';
 	if (conn->buflen == 0)
 		return (hdr_end);
 	/*
 	 * We could check for malformed headers but we don't really care.
 	 * A valid header starts with a token immediately followed by a
 	 * colon; a token is any sequence of non-control, non-whitespace
 	 * characters except "()<>@,;:\\\"{}".
 	 */
 	for (i = 0; hdr_names[i].num != hdr_unknown; i++)
 		if ((*p = http_match(hdr_names[i].name, conn->buf)) != NULL)
 			return (hdr_names[i].num);
 	return (hdr_unknown);
+}
 /*
  * Parse a last-modified header
  */
 static int
 http_parse_mtime(const char *p, time_t *mtime)
+{
 	char locale[64], *r;
 	struct tm tm;
 	strncpy(locale, setlocale(LC_TIME, NULL), sizeof(locale));
 	setlocale(LC_TIME, "C");
 	r = strptime(p, "%a, %d %b %Y %H:%M:%S GMT", &tm);
 	/* XXX should add support for date-2 and date-3 */
 	setlocale(LC_TIME, locale);
 	if (r == NULL)
 		return (-1);
 	*mtime = timegm(&tm);
 	return (0);
+}
 /*
  * Parse a content-length header
  */
 static int
 http_parse_length(const char *p, off_t *length)
+{
 	off_t len;
 	for (len = 0; *p && isdigit((unsigned char)*p); ++p)
 		len = len * 10 + (*p - '0');
 	if (*p)
 		return (-1);
 	*length = len;
 	return (0);
+}
 /*
  * Parse a content-range header
  */
 static int
 http_parse_range(const char *p, off_t *offset, off_t *length, off_t *size)
+{
 	off_t first, last, len;
 	if (strncasecmp(p, "bytes ", 6) != 0)
 		return (-1);
 	p += 6;
 	if (*p == '*') {
 		first = last = -1;
 		++p;
 	} else {
 		for (first = 0; *p && isdigit((unsigned char)*p); ++p)
 			first = first * 10 + *p - '0';
 		if (*p != '-')
 			return (-1);
 		for (last = 0, ++p; *p && isdigit((unsigned char)*p); ++p)
 			last = last * 10 + *p - '0';
+	}
 	if (first > last || *p != '/')
 		return (-1);
 	for (len = 0, ++p; *p && isdigit((unsigned char)*p); ++p)
 		len = len * 10 + *p - '0';
 	if (*p || len < last - first + 1)
 		return (-1);
 	if (first == -1)
 		*length = 0;
 	else
 		*length = last - first + 1;
 	*offset = first;
 	*size = len;
 	return (0);
+}
 /*****************************************************************************
  * Helper functions for authorization
  */
 /*
  * Base64 encoding
  */
 static char *
 http_base64(const char *src)
+{
 	static const char base64[] =
 	    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
 	    "abcdefghijklmnopqrstuvwxyz"
 	    "0123456789+/";
 	char *str, *dst;
 	size_t l;
 	unsigned int t, r;
 	l = strlen(src);
 	if ((str = malloc(((l + 2) / 3) * 4 + 1)) == NULL)
 		return (NULL);
 	dst = str;
 	r = 0;
 	while (l >= 3) {
 		t = (src[0] << 16) | (src[1] << 8) | src[2];
 		dst[0] = base64[(t >> 18) & 0x3f];
 		dst[1] = base64[(t >> 12) & 0x3f];
 		dst[2] = base64[(t >> 6) & 0x3f];
 		dst[3] = base64[(t >> 0) & 0x3f];
 		src += 3; l -= 3;
 		dst += 4; r += 4;
+	}
 	switch (l) {
 	case 2:
 		t = (src[0] << 16) | (src[1] << 8);
 		dst[0] = base64[(t >> 18) & 0x3f];
 		dst[1] = base64[(t >> 12) & 0x3f];
 		dst[2] = base64[(t >> 6) & 0x3f];
 		dst[3] = '=';
 		dst += 4;
 		r += 4;
 		break;
 	case 1:
 		t = src[0] << 16;
 		dst[0] = base64[(t >> 18) & 0x3f];
 		dst[1] = base64[(t >> 12) & 0x3f];
 		dst[2] = dst[3] = '=';
 		dst += 4;
 		r += 4;
 		break;
 	case 0:
 		break;
+	}
 	*dst = 0;
 	return (str);
+}
 /*
  * Encode username and password
  */
 static int
 http_basic_auth(conn_t *conn, const char *hdr, const char *usr, const char *pwd)
+{
 	char *upw, *auth;
 	int r;
 	if (asprintf(&upw, "%s:%s", usr, pwd) == -1)
 		return (-1);
 	auth = http_base64(upw);
 	free(upw);
 	if (auth == NULL)
 		return (-1);
 	r = http_cmd(conn, "%s: Basic %s\r\n", hdr, auth);
 	free(auth);
 	return (r);
+}
 /*
  * Send an authorization header
  */
 static int
 http_authorize(conn_t *conn, const char *hdr, const char *p)
+{
 	/* basic authorization */
 	if (strncasecmp(p, "basic:", 6) == 0) {
 		char *user, *pwd, *str;
 		int r;
 		/* skip realm */
 		for (p += 6; *p && *p != ':'; ++p)
 			/* nothing */ ;
 		if (!*p || strchr(++p, ':') == NULL)
 			return (-1);
 		if ((str = strdup(p)) == NULL)
 			return (-1); /* XXX */
 		user = str;
 		pwd = strchr(str, ':');
 		*pwd++ = '\0';
 		r = http_basic_auth(conn, hdr, user, pwd);
 		free(str);
 		return (r);
+	}
 	return (-1);
+}
 /*****************************************************************************
  * Helper functions for connecting to a server or proxy
  */
 /*
  * Connect to the correct HTTP server or proxy.
  */
 static conn_t *
 http_connect(struct url *URL, struct url *purl, const char *flags, int *cached)
+{
 	conn_t *conn;
 	int af, verbose;
 #ifdef TCP_NOPUSH
 	int val;
 #endif
 	*cached = 1;
 #ifdef INET6
 	af = AF_UNSPEC;
 #else
 	af = AF_INET;
 #endif
 	verbose = CHECK_FLAG('v');
 	if (CHECK_FLAG('4'))
 		af = AF_INET;
 #ifdef INET6
 	else if (CHECK_FLAG('6'))
 		af = AF_INET6;
 #endif
 	if (purl && strcasecmp(URL->scheme, SCHEME_HTTPS) != 0) {
 		URL = purl;
 	} else if (strcasecmp(URL->scheme, SCHEME_FTP) == 0) {
 		/* can't talk http to an ftp server */
 		/* XXX should set an error code */
 		return (NULL);
+	}
 	if ((conn = fetch_cache_get(URL, af)) != NULL) {
 		*cached = 1;
 		return (conn);
+	}
 	if ((conn = fetch_connect(URL, af, verbose)) == NULL)
 		/* fetch_connect() has already set an error code */
 		return (NULL);
 	if (strcasecmp(URL->scheme, SCHEME_HTTPS) == 0 &&
 	    fetch_ssl(conn, verbose) == -1) {
 		fetch_close(conn);
 		/* grrr */
 #ifdef EAUTH
 		errno = EAUTH;
 #else
 		errno = EPERM;
 #endif
 		fetch_syserr();
 		return (NULL);
+	}
 #ifdef TCP_NOPUSH
 	val = 1;
 	setsockopt(conn->sd, IPPROTO_TCP, TCP_NOPUSH, &val, sizeof(val));
 #endif
 	return (conn);
+}
 static struct url *
 http_get_proxy(struct url * url, const char *flags)
+{
 	struct url *purl;
 	char *p;
 	if (flags != NULL && strchr(flags, 'd') != NULL)
 		return (NULL);
 	if (fetch_no_proxy_match(url->host))
 		return (NULL);
 	if (((p = getenv("HTTP_PROXY")) || (p = getenv("http_proxy"))) &&
 	    *p && (purl = fetchParseURL(p))) {
 		if (!*purl->scheme)
 			strcpy(purl->scheme, SCHEME_HTTP);
 		if (!purl->port)
 			purl->port = fetch_default_proxy_port(purl->scheme);
 		if (strcasecmp(purl->scheme, SCHEME_HTTP) == 0)
 			return (purl);
 		fetchFreeURL(purl);
+	}
 	return (NULL);
+}
 static void
 set_if_modified_since(conn_t *conn, time_t last_modified)
+{
 	static const char weekdays[] = "SunMonTueWedThuFriSat";
 	static const char months[] = "JanFebMarAprMayJunJulAugSepOctNovDec";
 	struct tm tm;
 	char buf[80];
 	gmtime_r(&last_modified, &tm);
 	snprintf(buf, sizeof(buf), "%.3s, %02d %.3s %4d %02d:%02d:%02d GMT",
 	    weekdays + tm.tm_wday * 3, tm.tm_mday, months + tm.tm_mon * 3,
 	    tm.tm_year + 1900, tm.tm_hour, tm.tm_min, tm.tm_sec);
 	http_cmd(conn, "If-Modified-Since: %s\r\n", buf);
+}
 /*****************************************************************************
  * Core
  */
 /*
  * Send a request and process the reply
+ *
  * XXX This function is way too long, the do..while loop should be split
  * XXX off into a separate function.
  */
 fetchIO *
 http_request(struct url *URL, const char *op, struct url_stat *us,
     struct url *purl, const char *flags)
+{
 	conn_t *conn;
 	struct url *url, *new;
 	int chunked, direct, if_modified_since, need_auth, noredirect;
 	int keep_alive, verbose, cached;
 	int e, i, n, val;
 	off_t offset, clength, length, size;
 	time_t mtime;
 	const char *p;
 	fetchIO *f;
 	hdr_t h;
 	char hbuf[URL_HOSTLEN + 7], *host;
 	direct = CHECK_FLAG('d');
 	noredirect = CHECK_FLAG('A');
 	verbose = CHECK_FLAG('v');
 	if_modified_since = CHECK_FLAG('i');
 	keep_alive = 0;
 	if (direct && purl) {
 		fetchFreeURL(purl);
 		purl = NULL;
+	}
 	/* try the provided URL first */
 	url = URL;
 	/* if the A flag is set, we only get one try */
 	n = noredirect ? 1 : MAX_REDIRECT;
 	i = 0;
 	e = HTTP_PROTOCOL_ERROR;
 	need_auth = 0;
 	do {
 		new = NULL;
 		chunked = 0;
 		offset = 0;
 		clength = -1;
 		length = -1;
 		size = -1;
 		mtime = 0;
 		/* check port */
 		if (!url->port)
 			url->port = fetch_default_port(url->scheme);
 		/* were we redirected to an FTP URL? */
 		if (purl == NULL && strcmp(url->scheme, SCHEME_FTP) == 0) {
 			if (strcmp(op, "GET") == 0)
 				return (ftp_request(url, "RETR", NULL, us, purl, flags));
 			else if (strcmp(op, "HEAD") == 0)
 				return (ftp_request(url, "STAT", NULL, us, purl, flags));
+		}
 		/* connect to server or proxy */
 		if ((conn = http_connect(url, purl, flags, &cached)) == NULL)
 			goto ouch;
 		host = url->host;
 #ifdef INET6
 		if (strchr(url->host, ':')) {
 			snprintf(hbuf, sizeof(hbuf), "[%s]", url->host);
 			host = hbuf;
+		}
 #endif
 		if (url->port != fetch_default_port(url->scheme)) {
 			if (host != hbuf) {
 				strcpy(hbuf, host);
 				host = hbuf;
+			}
 			snprintf(hbuf + strlen(hbuf),
 			    sizeof(hbuf) - strlen(hbuf), ":%d", url->port);
+		}
 		/* send request */
 		if (verbose)
 			fetch_info("requesting %s://%s%s",
 			    url->scheme, host, url->doc);
 		if (purl) {
 			http_cmd(conn, "%s %s://%s%s HTTP/1.1\r\n",
 			    op, url->scheme, host, url->doc);
 		} else {
 			http_cmd(conn, "%s %s HTTP/1.1\r\n",
 			    op, url->doc);
+		}
 		if (if_modified_since && url->last_modified > 0)
 			set_if_modified_since(conn, url->last_modified);
 		/* virtual host */
 		http_cmd(conn, "Host: %s\r\n", host);
 		/* proxy authorization */
 		if (purl) {
 			if (*purl->user || *purl->pwd)
 				http_basic_auth(conn, "Proxy-Authorization",
 				    purl->user, purl->pwd);
 			else if ((p = getenv("HTTP_PROXY_AUTH")) != NULL && *p != '\0')
 				http_authorize(conn, "Proxy-Authorization", p);
+		}
 		/* server authorization */
 		if (need_auth || *url->user || *url->pwd) {
 			if (*url->user || *url->pwd)
 				http_basic_auth(conn, "Authorization", url->user, url->pwd);
 			else if ((p = getenv("HTTP_AUTH")) != NULL && *p != '\0')
 				http_authorize(conn, "Authorization", p);
 			else if (fetchAuthMethod && fetchAuthMethod(url) == 0) {
 				http_basic_auth(conn, "Authorization", url->user, url->pwd);
 			} else {
 				http_seterr(HTTP_NEED_AUTH);
 				goto ouch;
+			}
+		}
 		/* other headers */
 		if ((p = getenv("HTTP_REFERER")) != NULL && *p != '\0') {
 			if (strcasecmp(p, "auto") == 0)
 				http_cmd(conn, "Referer: %s://%s%s\r\n",
 				    url->scheme, host, url->doc);
 			else
 				http_cmd(conn, "Referer: %s\r\n", p);
+		}
 		if ((p = getenv("HTTP_USER_AGENT")) != NULL && *p != '\0')
 			http_cmd(conn, "User-Agent: %s\r\n", p);
 		else
 			http_cmd(conn, "User-Agent: %s\r\n", _LIBFETCH_VER);
 		if (url->offset > 0)
 			http_cmd(conn, "Range: bytes=%lld-\r\n", (long long)url->offset);
 		http_cmd(conn, "\r\n");
 		/*
 		 * Force the queued request to be dispatched.  Normally, one
 		 * would do this with shutdown(2) but squid proxies can be
 		 * configured to disallow such half-closed connections.  To
 		 * be compatible with such configurations, fiddle with socket
 		 * options to force the pending data to be written.
 		 */
 #ifdef TCP_NOPUSH
 		val = 0;
 		setsockopt(conn->sd, IPPROTO_TCP, TCP_NOPUSH, &val,
 			   sizeof(val));
 #endif
 		val = 1;
 		setsockopt(conn->sd, IPPROTO_TCP, TCP_NODELAY, &val,
 		    (socklen_t)sizeof(val));
 		/* get reply */
 		switch (http_get_reply(conn)) {
 		case HTTP_OK:
 		case HTTP_PARTIAL:
 		case HTTP_NOT_MODIFIED:
 			/* fine */
 			break;
 		case HTTP_MOVED_PERM:
 		case HTTP_MOVED_TEMP:
 		case HTTP_SEE_OTHER:
 			/*
 			 * Not so fine, but we still have to read the
 			 * headers to get the new location.
 			 */
 			break;
 		case HTTP_NEED_AUTH:
 			if (need_auth) {
 				/*
 				 * We already sent out authorization code,
 				 * so there's nothing more we can do.
 				 */
 				http_seterr(conn->err);
 				goto ouch;
+			}
 			/* try again, but send the password this time */
 			if (verbose)
 				fetch_info("server requires authorization");
 			break;
 		case HTTP_NEED_PROXY_AUTH:
 			/*
 			 * If we're talking to a proxy, we already sent
 			 * our proxy authorization code, so there's
 			 * nothing more we can do.
 			 */
 			http_seterr(conn->err);
 			goto ouch;
 		case HTTP_BAD_RANGE:
 			/*
 			 * This can happen if we ask for 0 bytes because
 			 * we already have the whole file.  Consider this
 			 * a success for now, and check sizes later.
 			 */
 			break;
 		case HTTP_PROTOCOL_ERROR:
 			/* fall through */
 		case -1:
 			--i;
 			if (cached)
 				continue;
 			fetch_syserr();
 			goto ouch;
 		default:
 			http_seterr(conn->err);
 			if (!verbose)
 				goto ouch;
 			/* fall through so we can get the full error message */
+		}
 		/* get headers */
 		do {
 			switch ((h = http_next_header(conn, &p))) {
 			case hdr_syserror:
 				fetch_syserr();
 				goto ouch;
 			case hdr_error:
 				http_seterr(HTTP_PROTOCOL_ERROR);
 				goto ouch;
 			case hdr_connection:
 				/* XXX too weak? */
 				keep_alive = (strcasecmp(p, "keep-alive") == 0);
 				break;
 			case hdr_content_length:
 				http_parse_length(p, &clength);
 				break;
 			case hdr_content_range:
 				http_parse_range(p, &offset, &length, &size);
 				break;
 			case hdr_last_modified:
 				http_parse_mtime(p, &mtime);
 				break;
 			case hdr_location:
 				if (!HTTP_REDIRECT(conn->err))
 					break;
 				if (new)
 					free(new);
 				if (verbose)
 					fetch_info("%d redirect to %s", conn->err, p);
 				if (*p == '/')
 					/* absolute path */
 					new = fetchMakeURL(url->scheme, url->host, url->port, p,
 					    url->user, url->pwd);
 				else
 					new = fetchParseURL(p);
 				if (new == NULL) {
 					/* XXX should set an error code */
 					goto ouch;
+				}
 				if (!*new->user && !*new->pwd) {
 					strcpy(new->user, url->user);
 					strcpy(new->pwd, url->pwd);
+				}
 				new->offset = url->offset;
 				new->length = url->length;
 				break;
 			case hdr_transfer_encoding:
 				/* XXX weak test*/
 				chunked = (strcasecmp(p, "chunked") == 0);
 				break;
 			case hdr_www_authenticate:
 				if (conn->err != HTTP_NEED_AUTH)
 					break;
 				/* if we were smarter, we'd check the method and realm */
 				break;
 			case hdr_end:
 				/* fall through */
 			case hdr_unknown:
 				/* ignore */
 				break;
+			}
 		} while (h > hdr_end);
 		/* we need to provide authentication */
 		if (conn->err == HTTP_NEED_AUTH) {
 			e = conn->err;
 			need_auth = 1;
 			fetch_close(conn);
 			conn = NULL;
 			continue;
+		}
 		/* requested range not satisfiable */
 		if (conn->err == HTTP_BAD_RANGE) {
 			if (url->offset == size && url->length == 0) {
 				/* asked for 0 bytes; fake it */
 				offset = url->offset;
 				conn->err = HTTP_OK;
 				break;
 			} else {
 				http_seterr(conn->err);
 				goto ouch;
+			}
+		}
 		/* we have a hit or an error */
 		if (conn->err == HTTP_OK ||
 		    conn->err == HTTP_PARTIAL ||
 		    conn->err == HTTP_NOT_MODIFIED ||
 		    HTTP_ERROR(conn->err))
 			break;
 		/* all other cases: we got a redirect */
 		e = conn->err;
 		need_auth = 0;
 		fetch_close(conn);
 		conn = NULL;
 		if (!new)
 			break;
 		if (url != URL)
 			fetchFreeURL(url);
 		url = new;
 	} while (++i < n);
 	/* we failed, or ran out of retries */
 	if (conn == NULL) {
 		http_seterr(e);
 		goto ouch;
+	}
 	/* check for inconsistencies */
 	if (clength != -1 && length != -1 && clength != length) {
 		http_seterr(HTTP_PROTOCOL_ERROR);
 		goto ouch;
+	}
 	if (clength == -1)
 		clength = length;
 	if (clength != -1)
 		length = offset + clength;
 	if (length != -1 && size != -1 && length != size) {
 		http_seterr(HTTP_PROTOCOL_ERROR);
 		goto ouch;
+	}
 	if (size == -1)
 		size = length;
 	/* fill in stats */
 	if (us) {
 		us->size = size;
 		us->atime = us->mtime = mtime;
+	}
 	/* too far? */
 	if (URL->offset > 0 && offset > URL->offset) {
 		http_seterr(HTTP_PROTOCOL_ERROR);
 		goto ouch;
+	}
 	/* report back real offset and size */
 	URL->offset = offset;
 	URL->length = clength;
 	if (clength == -1 && !chunked)
 		keep_alive = 0;
 	if (conn->err == HTTP_NOT_MODIFIED) {
 		http_seterr(HTTP_NOT_MODIFIED);
 		if (keep_alive) {
 			fetch_cache_put(conn, fetch_close);
 			conn = NULL;
+		}
 		goto ouch;
+	}
 	/* wrap it up in a fetchIO */
 	if ((f = http_funopen(conn, chunked, keep_alive, clength)) == NULL) {
 		fetch_syserr();
 		goto ouch;
+	}
 	if (url != URL)
 		fetchFreeURL(url);
 	if (purl)
 		fetchFreeURL(purl);
 	if (HTTP_ERROR(conn->err)) {
 		if (keep_alive) {
 			char buf[512];
 			do {
 			} while (fetchIO_read(f, buf, sizeof(buf)) > 0);
+		}
 		fetchIO_close(f);
 		f = NULL;
+	}
 	return (f);
 ouch:
 	if (url != URL)
 		fetchFreeURL(url);
 	if (purl)
 		fetchFreeURL(purl);
 	if (conn != NULL)
 		fetch_close(conn);
 	return (NULL);
+}
 /*****************************************************************************
  * Entry points
  */
 /*
  * Retrieve and stat a file by HTTP
  */
 fetchIO *
 fetchXGetHTTP(struct url *URL, struct url_stat *us, const char *flags)
+{
 	return (http_request(URL, "GET", us, http_get_proxy(URL, flags), flags));
+}
 /*
  * Retrieve a file by HTTP
  */
 fetchIO *
 fetchGetHTTP(struct url *URL, const char *flags)
+{
 	return (fetchXGetHTTP(URL, NULL, flags));
+}
 /*
  * Store a file by HTTP
  */
 fetchIO *
 /*ARGSUSED*/
 fetchPutHTTP(struct url *URL __unused, const char *flags __unused)
+{
 	fprintf(stderr, "fetchPutHTTP(): not implemented\n");
 	return (NULL);
+}
 /*
  * Get an HTTP document's metadata
  */
 int
 fetchStatHTTP(struct url *URL, struct url_stat *us, const char *flags)
+{
 	fetchIO *f;
 	f = http_request(URL, "HEAD", us, http_get_proxy(URL, flags), flags);
 	if (f == NULL)
 		return (-1);
 	fetchIO_close(f);
 	return (0);
+}
 enum http_states {
 	ST_NONE,
 	ST_LT,
 	ST_LTA,
 	ST_TAGA,
 	ST_H,
 	ST_R,
 	ST_E,
 	ST_F,
 	ST_HREF,
 	ST_HREFQ,
 	ST_TAG,
 	ST_TAGAX,
 	ST_TAGAQ
 };
 struct index_parser {
 	struct url_list *ue;
 	struct url *url;
 	enum http_states state;
 };
 static ssize_t
 parse_index(struct index_parser *parser, const char *buf, size_t len)
+{
 	char *end_attr, p = *buf;
 	switch (parser->state) {
 	case ST_NONE:
 		/* Plain text, not in markup */
 		if (p == '<')
 			parser->state = ST_LT;
 		return 1;
 	case ST_LT:
 		/* In tag -- "<" already found */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == 'a' || p == 'A')
 			parser->state = ST_LTA;
 		else if (!isspace((unsigned char)p))
 			parser->state = ST_TAG;
 		return 1;
 	case ST_LTA:
 		/* In tag -- "<a" already found */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_TAGAQ;
 		else if (isspace((unsigned char)p))
 			parser->state = ST_TAGA;
 		else
 			parser->state = ST_TAG;
 		return 1;
 	case ST_TAG:
 		/* In tag, but not "<a" -- disregard */
 		if (p == '>')
 			parser->state = ST_NONE;
 		return 1;
 	case ST_TAGA:
 		/* In a-tag -- "<a " already found */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_TAGAQ;
 		else if (p == 'h' || p == 'H')
 			parser->state = ST_H;
 		else if (!isspace((unsigned char)p))
 			parser->state = ST_TAGAX;
 		return 1;
 	case ST_TAGAX:
 		/* In unknown keyword in a-tag */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_TAGAQ;
 		else if (isspace((unsigned char)p))
 			parser->state = ST_TAGA;
 		return 1;
 	case ST_TAGAQ:
 		/* In a-tag, unknown argument for keys. */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_TAGA;
 		return 1;
 	case ST_H:
 		/* In a-tag -- "<a h" already found */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_TAGAQ;
 		else if (p == 'r' || p == 'R')
 			parser->state = ST_R;
 		else if (isspace((unsigned char)p))
 			parser->state = ST_TAGA;
 		else
 			parser->state = ST_TAGAX;
 		return 1;
 	case ST_R:
 		/* In a-tag -- "<a hr" already found */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_TAGAQ;
 		else if (p == 'e' || p == 'E')
 			parser->state = ST_E;
 		else if (isspace((unsigned char)p))
 			parser->state = ST_TAGA;
 		else
 			parser->state = ST_TAGAX;
 		return 1;
 	case ST_E:
 		/* In a-tag -- "<a hre" already found */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_TAGAQ;
 		else if (p == 'f' || p == 'F')
 			parser->state = ST_F;
 		else if (isspace((unsigned char)p))
 			parser->state = ST_TAGA;
 		else
 			parser->state = ST_TAGAX;
 		return 1;
 	case ST_F:
 		/* In a-tag -- "<a href" already found */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_TAGAQ;
 		else if (p == '=')
 			parser->state = ST_HREF;
 		else if (!isspace((unsigned char)p))
 			parser->state = ST_TAGAX;
 		return 1;
 	case ST_HREF:
 		/* In a-tag -- "<a href=" already found */
 		if (p == '>')
 			parser->state = ST_NONE;
 		else if (p == '"')
 			parser->state = ST_HREFQ;
 		else if (!isspace((unsigned char)p))
 			parser->state = ST_TAGA;