 @@ -1,1085 +1,1095 @@
-/*	$NetBSD: common.c,v 1.31 2016/10/20 21:25:57 joerg Exp $	*/
+/*	$NetBSD: common.c,v 1.31.58.1 2024/01/13 12:49:09 bsiegert Exp $	*/
 /*-
  * Copyright (c) 1998-2004 Dag-Erling Coïdan Smørgrav
  * Copyright (c) 2008, 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: common.c,v 1.53 2007/12/19 00:26:36 des Exp $
  */
 #if HAVE_CONFIG_H
 #include "config.h"
 #endif
 #ifndef NETBSD
 #include <nbcompat.h>
 #endif
 #ifdef __NetBSD__
 #include <sys/param.h>		/* __NetBSD_Version__ */
 #endif
 #include <sys/types.h>
 #include <sys/socket.h>
 #include <sys/time.h>
 #include <sys/uio.h>
 #if HAVE_POLL_H
 #include <poll.h>
 #elif HAVE_SYS_POLL_H
 #include <sys/poll.h>
 #endif
 #include <netinet/in.h>
 #include <arpa/inet.h>
 #include <ctype.h>
 #include <errno.h>
 #if defined(HAVE_INTTYPES_H) || defined(NETBSD)
 #include <inttypes.h>
 #endif
 #ifndef NETBSD
 #include <nbcompat/netdb.h>
 #else
 #include <netdb.h>
 #endif
 #include <pwd.h>
 #include <stdarg.h>
 #include <stdlib.h>
 #include <stdio.h>
 #include <string.h>
 #include <unistd.h>
 #ifndef MSG_NOSIGNAL
 #include <signal.h>
 #endif
 #include "fetch.h"
 #include "common.h"
 /*** 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" }
 };
 /*** 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->ftp_home = NULL;
 	conn->cache_url = NULL;
 	conn->next_buf = NULL;
 	conn->next_len = 0;
 	conn->sd = sd;
 	conn->buf_events = POLLIN;
 	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;
 	memset(&hints, 0, sizeof(hints));
 	hints.ai_family = af;
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_protocol = 0;
 	if (getaddrinfo(addr, NULL, &hints, &res0))
 		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(struct url *url, int af, int verbose)
+{
 	conn_t *conn;
 	char pbuf[10];
 	const char *bindaddr;
 	struct addrinfo hints, *res, *res0;
 	int sd, error;
 	if (verbose)
 		fetch_info("looking up %s", url->host);
 	/* look up host name and set up socket address structure */
 	snprintf(pbuf, sizeof(pbuf), "%d", url->port);
 	memset(&hints, 0, sizeof(hints));
 	hints.ai_family = af;
 	hints.ai_socktype = SOCK_STREAM;
 	hints.ai_protocol = 0;
 	if ((error = getaddrinfo(url->host, pbuf, &hints, &res0)) != 0) {
 		netdb_seterr(error);
 		return (NULL);
+	}
 	bindaddr = getenv("FETCH_BIND_ADDRESS");
 	if (verbose)
 		fetch_info("connecting to %s:%d", url->host, url->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 (NULL);
+	}
 	conn->cache_url = fetchCopyURL(url);
 	conn->cache_af = af;
 	return (conn);
+}
 static conn_t *connection_cache;
 static int cache_global_limit = 0;
 static int cache_per_host_limit = 0;
 /*
  * Initialise cache with the given limits.
  */
 void
 fetchConnectionCacheInit(int global_limit, int per_host_limit)
+{
 	if (global_limit < 0)
 		cache_global_limit = INT_MAX;
 	else if (per_host_limit > global_limit)
 		cache_global_limit = per_host_limit;
 	else
 		cache_global_limit = global_limit;
 	if (per_host_limit < 0)
 		cache_per_host_limit = INT_MAX;
 	else
 		cache_per_host_limit = per_host_limit;
+}
 /*
  * Flush cache and free all associated resources.
  */
 void
 fetchConnectionCacheClose(void)
+{
 	conn_t *conn;
 	while ((conn = connection_cache) != NULL) {
 		connection_cache = conn->next_cached;
 		(*conn->cache_close)(conn);
+	}
+}
 /*
  * Check connection cache for an existing entry matching
  * protocol/host/port/user/password/family.
  */
 conn_t *
 fetch_cache_get(const struct url *url, int af)
+{
 	conn_t *conn, *last_conn = NULL;
 	for (conn = connection_cache; conn; conn = conn->next_cached) {
 		if (conn->cache_url->port == url->port &&
 		    strcmp(conn->cache_url->scheme, url->scheme) == 0 &&
 		    strcmp(conn->cache_url->host, url->host) == 0 &&
 		    strcmp(conn->cache_url->user, url->user) == 0 &&
 		    strcmp(conn->cache_url->pwd, url->pwd) == 0 &&
 		    (conn->cache_af == AF_UNSPEC || af == AF_UNSPEC ||
 		     conn->cache_af == af)) {
 			if (last_conn != NULL)
 				last_conn->next_cached = conn->next_cached;
 			else
 				connection_cache = conn->next_cached;
 			return conn;
+		}
+	}
 	return NULL;
+}
 /*
  * Put the connection back into the cache for reuse.
  * If the connection is freed due to LRU or if the cache
  * is explicitly closed, the given callback is called.
  */
 void
 fetch_cache_put(conn_t *conn, int (*closecb)(conn_t *))
+{
 	conn_t *iter, *last;
 	int global_count, host_count;
 	if (conn->cache_url == NULL || cache_global_limit == 0) {
 		(*closecb)(conn);
 		return;
+	}
 	global_count = host_count = 0;
 	last = NULL;
 	for (iter = connection_cache; iter;
 	    last = iter, iter = iter->next_cached) {
 		++global_count;
 		if (strcmp(conn->cache_url->host, iter->cache_url->host) == 0)
 			++host_count;
 		if (global_count < cache_global_limit &&
 		    host_count < cache_per_host_limit)
 			continue;
 		--global_count;
 		if (last != NULL)
 			last->next_cached = iter->next_cached;
 		else
 			connection_cache = iter->next_cached;
 		(*iter->cache_close)(iter);
+	}
 	conn->cache_close = closecb;
 	conn->next_cached = connection_cache;
 	connection_cache = conn;
+}
 /*
  * Enable SSL on a connection.
  */
 int
 fetch_ssl(conn_t *conn, const struct url *URL, 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);
 #if defined(__NetBSD__) && __NetBSD_Version__ >= 1000000000
 	if (getenv("SSL_NO_VERIFY_PEER") == NULL) {
 		SSL_CTX_set_default_verify_paths(conn->ssl_ctx);
 		SSL_CTX_set_verify(conn->ssl_ctx, SSL_VERIFY_PEER, NULL);
+	}
 #endif
 	conn->ssl = SSL_new(conn->ssl_ctx);
 	if (conn->ssl == NULL){
 		fprintf(stderr, "SSL context creation failed\n");
 		return (-1);
+	}
 	conn->buf_events = 0;
 	SSL_set_fd(conn->ssl, conn->sd);
 #if OPENSSL_VERSION_NUMBER >= 0x0090806fL && !defined(OPENSSL_NO_TLSEXT)
 	if (!SSL_set_tlsext_host_name(conn->ssl, (char *)(uintptr_t)URL->host)) {
 		fprintf(stderr,
 		    "TLS server name indication extension failed for host %s\n",
 		    URL->host);
 		return (-1);
+	}
 #endif
 	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
+}
 static int
 compute_timeout(const struct timeval *tv)
+{
 	struct timeval cur;
 	int timeout;
 	gettimeofday(&cur, NULL);
 	timeout = (tv->tv_sec - cur.tv_sec) * 1000 + (tv->tv_usec - cur.tv_usec) / 1000;
 	return timeout;
+}
 /*
  * Read a character from a connection w/ timeout
  */
 ssize_t
 fetch_read(conn_t *conn, char *buf, size_t len)
+{
 	struct timeval timeout_end;
 	struct pollfd pfd;
 	int timeout_cur;
 	ssize_t rlen;
 	int r;
 	if (len == 0)
 		return 0;
 	if (conn->next_len != 0) {
 		if (conn->next_len < len)
 			len = conn->next_len;
 		memmove(buf, conn->next_buf, len);
 		conn->next_len -= len;
 		conn->next_buf += len;
 		return len;
+	}
 	if (fetchTimeout) {
 		gettimeofday(&timeout_end, NULL);
 		timeout_end.tv_sec += fetchTimeout;
+	}
 	pfd.fd = conn->sd;
 	for (;;) {
 		pfd.events = conn->buf_events;
 		if (fetchTimeout && pfd.events) {
 			do {
 				timeout_cur = compute_timeout(&timeout_end);
 				if (timeout_cur < 0) {
 					errno = ETIMEDOUT;
 					fetch_syserr();
 					return (-1);
+				}
 				errno = 0;
 				r = poll(&pfd, 1, timeout_cur);
 				if (r == -1) {
 					if (errno == EINTR && fetchRestartCalls)
 						continue;
 					fetch_syserr();
 					return (-1);
+				}
 			} while (pfd.revents == 0);
+		}
 #ifdef WITH_SSL
 		if (conn->ssl != NULL) {
 			rlen = SSL_read(conn->ssl, buf, len);
 			if (rlen == -1) {
 				switch (SSL_get_error(conn->ssl, rlen)) {
 				case SSL_ERROR_WANT_READ:
 					conn->buf_events = POLLIN;
 					break;
 				case SSL_ERROR_WANT_WRITE:
 					conn->buf_events = POLLOUT;
 					break;
 				default:
 					errno = EIO;
 					fetch_syserr();
 					return -1;
+				}
 			} else {
 				/* Assume buffering on the SSL layer. */
 				conn->buf_events = 0;
+			}
 		} else
 #endif
 			rlen = read(conn->sd, buf, len);
 		if (rlen >= 0)
 			break;
 		if (errno != EINTR || !fetchRestartCalls)
 			return (-1);
+	}
 	return (rlen);
+}
 /*
  * Read a line of text from a connection w/ timeout
  */
 #define MIN_BUF_SIZE 1024
 int
 fetch_getln(conn_t *conn)
+{
 	char *tmp, *next;
 	size_t tmpsize;
 	ssize_t len;
 	if (conn->buf == NULL) {
 		if ((conn->buf = malloc(MIN_BUF_SIZE)) == NULL) {
 			errno = ENOMEM;
 			return (-1);
+		}
 		conn->bufsize = MIN_BUF_SIZE;
+	}
 	conn->buflen = 0;
 	next = NULL;
 	do {
 		/*
 		 * conn->bufsize != conn->buflen at this point,
 		 * so the buffer can be NUL-terminated below for
 		 * the case of len == 0.
 		 */
 		len = fetch_read(conn, conn->buf + conn->buflen,
 		    conn->bufsize - conn->buflen);
 		if (len == -1)
 			return (-1);
 		if (len == 0)
 			break;
 		next = memchr(conn->buf + conn->buflen, '\n', len);
 		conn->buflen += len;
 		if (conn->buflen == conn->bufsize && next == NULL) {
 			tmp = conn->buf;
 			tmpsize = conn->bufsize * 2;
 			if (tmpsize < conn->bufsize) {
 				errno = ENOMEM;
 				return (-1);
+			}
 			if ((tmp = realloc(tmp, tmpsize)) == NULL) {
 				errno = ENOMEM;
 				return (-1);
+			}
 			conn->buf = tmp;
 			conn->bufsize = tmpsize;
+		}
 	} while (next == NULL);
 	if (next != NULL) {
 		*next = '\0';
 		conn->next_buf = next + 1;
 		conn->next_len = conn->buflen - (conn->next_buf - conn->buf);
 		conn->buflen = next - conn->buf;
 	} else {
 		conn->buf[conn->buflen] = '\0';
 		conn->next_len = 0;
+	}
 	return (0);
+}
 /*
  * Write a vector to a connection w/ timeout
  * Note: can modify the iovec.
  */
 ssize_t
 fetch_write(conn_t *conn, const void *buf, size_t len)
+{
 	struct timeval now, timeout, waittv;
 	fd_set writefds;
 	ssize_t wlen, total;
 	int r;
 #ifndef MSG_NOSIGNAL
 	static int killed_sigpipe;
 #endif
 #ifndef MSG_NOSIGNAL
 	if (!killed_sigpipe) {
 		signal(SIGPIPE, SIG_IGN);
 		killed_sigpipe = 1;
+	}
 #endif
 	if (fetchTimeout) {
 		FD_ZERO(&writefds);
 		gettimeofday(&timeout, NULL);
 		timeout.tv_sec += fetchTimeout;
+	}
 	total = 0;
 	while (len) {
 		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, buf, len);
 		else
 #endif
 #ifndef MSG_NOSIGNAL
 			wlen = send(conn->sd, buf, len, 0);
 #else
 			wlen = send(conn->sd, buf, len, MSG_NOSIGNAL);
 #endif
 		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;
 		buf = (const char *)buf + wlen;
 		len -= wlen;
+	}
 	return (total);
+}
 /*
  * Close connection
  */
 int
 fetch_close(conn_t *conn)
+{
 	int ret;
 	ret = close(conn->sd);
 	if (conn->cache_url)
 		fetchFreeURL(conn->cache_url);
 	free(conn->ftp_home);
 	free(conn->buf);
 	free(conn);
 	return (ret);
+}
 /*** Directory-related utility functions *************************************/
 int
 fetch_add_entry(struct url_list *ue, struct url *base, const char *name,
     int pre_quoted)
+{
 	struct url *tmp;
 	char *tmp_name;
 	size_t base_doc_len, name_len, i;
 	unsigned char c;
 	if (strchr(name, '/') != NULL ||
 	    strcmp(name, "..") == 0 ||
 	    strcmp(name, ".") == 0)
 		return 0;
 	if (strcmp(base->doc, "/") == 0)
 		base_doc_len = 0;
 	else
 		base_doc_len = strlen(base->doc);
 	name_len = 1;
 	for (i = 0; name[i] != '\0'; ++i) {
 		if ((!pre_quoted && name[i] == '%') ||
 		    !fetch_urlpath_safe(name[i]))
 			name_len += 3;
 		else
 			++name_len;
+	}
 	tmp_name = malloc( base_doc_len + name_len + 1);
 	if (tmp_name == NULL) {
 		errno = ENOMEM;
 		fetch_syserr();
 		return (-1);
+	}
 	if (ue->length + 1 >= ue->alloc_size) {
 		tmp = realloc(ue->urls, (ue->alloc_size * 2 + 1) * sizeof(*tmp));
 		if (tmp == NULL) {
 			free(tmp_name);
 			errno = ENOMEM;
 			fetch_syserr();
 			return (-1);
+		}
 		ue->alloc_size = ue->alloc_size * 2 + 1;
 		ue->urls = tmp;
+	}
 	tmp = ue->urls + ue->length;
 	strcpy(tmp->scheme, base->scheme);
 	strcpy(tmp->user, base->user);
 	strcpy(tmp->pwd, base->pwd);
 	strcpy(tmp->host, base->host);
 	tmp->port = base->port;
 	tmp->doc = tmp_name;
 	memcpy(tmp->doc, base->doc, base_doc_len);
 	tmp->doc[base_doc_len] = '/';
 	for (i = base_doc_len + 1; *name != '\0'; ++name) {
 		if ((!pre_quoted && *name == '%') ||
 		    !fetch_urlpath_safe(*name)) {
 			tmp->doc[i++] = '%';
 			c = (unsigned char)*name / 16;
 			if (c < 10)
 				tmp->doc[i++] = '0' + c;
 			else
 				tmp->doc[i++] = 'a' - 10 + c;
 			c = (unsigned char)*name % 16;
 			if (c < 10)
 				tmp->doc[i++] = '0' + c;
 			else
 				tmp->doc[i++] = 'a' - 10 + c;
 		} else {
 			tmp->doc[i++] = *name;
+		}
+	}
 	tmp->doc[i] = '\0';
 	tmp->offset = 0;
 	tmp->length = 0;
 	tmp->last_modified = -1;
 	++ue->length;
 	return (0);
+}
 void
 fetchInitURLList(struct url_list *ue)
+{
 	ue->length = ue->alloc_size = 0;
 	ue->urls = NULL;
+}
 int
 fetchAppendURLList(struct url_list *dst, const struct url_list *src)
+{
 	size_t i, j, len;
 	len = dst->length + src->length;
 	if (len > dst->alloc_size) {
 		struct url *tmp;
 		tmp = realloc(dst->urls, len * sizeof(*tmp));
 		if (tmp == NULL) {
 			errno = ENOMEM;
 			fetch_syserr();
 			return (-1);
+		}
 		dst->alloc_size = len;
 		dst->urls = tmp;
+	}
 	for (i = 0, j = dst->length; i < src->length; ++i, ++j) {
 		dst->urls[j] = src->urls[i];
 		dst->urls[j].doc = strdup(src->urls[i].doc);
 		if (dst->urls[j].doc == NULL) {
 			while (i-- > 0)
 				free(dst->urls[j].doc);
 			fetch_syserr();
 			return -1;
+		}
+	}
 	dst->length = len;
 	return 0;
+}
 void
 fetchFreeURLList(struct url_list *ue)
+{
 	size_t i;
 	for (i = 0; i < ue->length; ++i)
 		free(ue->urls[i].doc);
 	free(ue->urls);
 	ue->length = ue->alloc_size = 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,781 +1,785 @@
 .\"-
 .\" Copyright (c) 1998-2004 Dag-Erling Coïdan Smørgrav
 .\" Copyright (c) 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.
 .\" 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.
 .\"
 .\" THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``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 OR CONTRIBUTORS 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: fetch.3,v 1.64 2007/12/18 11:03:26 des Exp $
-.\" $NetBSD: fetch.3,v 1.17 2016/05/31 18:02:36 abhinav Exp $
+.\" $NetBSD: fetch.3,v 1.17.62.1 2024/01/13 12:49:09 bsiegert Exp $
 .\"
-.Dd January 22, 2010
+.Dd December 22, 2023
 .Dt FETCH 3
 .Os
 .Sh NAME
 .Nm fetchMakeURL ,
 .Nm fetchParseURL ,
 .Nm fetchCopyURL ,
 .Nm fetchFreeURL ,
 .Nm fetchXGetURL ,
 .Nm fetchGetURL ,
 .Nm fetchPutURL ,
 .Nm fetchStatURL ,
 .Nm fetchListURL ,
 .Nm fetchXGet ,
 .Nm fetchGet ,
 .Nm fetchPut ,
 .Nm fetchStat ,
 .Nm fetchList ,
 .Nm fetchXGetFile ,
 .Nm fetchGetFile ,
 .Nm fetchPutFile ,
 .Nm fetchStatFile ,
 .Nm fetchListFile ,
 .Nm fetchXGetHTTP ,
 .Nm fetchGetHTTP ,
 .Nm fetchPutHTTP ,
 .Nm fetchStatHTTP ,
 .Nm fetchListHTTP ,
 .Nm fetchXGetFTP ,
 .Nm fetchGetFTP ,
 .Nm fetchPutFTP ,
 .Nm fetchStatFTP ,
 .Nm fetchListFTP
 .Nm fetchInitURLList ,
 .Nm fetchFreeURLList ,
 .Nm fetchUnquotePath ,
 .Nm fetchUnquoteFilename ,
 .Nm fetchStringifyURL ,
 .Nm fetchConnectionCacheInit ,
 .Nm fetchConnectionCacheClose ,
 .Nm fetch
 .Nd file transfer functions
 .Sh LIBRARY
 .Lb libfetch
 .Sh SYNOPSIS
 .In stdio.h
 .In fetch.h
 .Ft struct url *
 .Fn fetchMakeURL "const char *scheme" "const char *host" "int port" "const char *doc" "const char *user" "const char *pwd"
 .Ft struct url *
 .Fn fetchParseURL "const char *URL"
 .Ft struct url *
 .Fn fetchCopyURL "const struct url *u"
 .Ft void
 .Fn fetchFreeURL "struct url *u"
 .Ft fetchIO *
 .Fn fetchXGetURL "const char *URL" "struct url_stat *us" "const char *flags"
 .Ft fetchIO *
 .Fn fetchGetURL "const char *URL" "const char *flags"
 .Ft fetchIO *
 .Fn fetchPutURL "const char *URL" "const char *flags"
 .Ft int
 .Fn fetchStatURL "const char *URL" "struct url_stat *us" "const char *flags"
 .Ft int
 .Fn fetchListURL "struct url_list *list" "const char *URL" "const char *pattern" "const char *flags"
 .Ft fetchIO *
 .Fn fetchXGet "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft fetchIO *
 .Fn fetchGet "struct url *u" "const char *flags"
 .Ft fetchIO *
 .Fn fetchPut "struct url *u" "const char *flags"
 .Ft int
 .Fn fetchStat "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft int
 .Fn fetchList "struct url_list *list" "struct url *u" "const char *pattern" "const char *flags"
 .Ft fetchIO *
 .Fn fetchXGetFile "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft fetchIO *
 .Fn fetchGetFile "struct url *u" "const char *flags"
 .Ft fetchIO *
 .Fn fetchPutFile "struct url *u" "const char *flags"
 .Ft int
 .Fn fetchStatFile "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft int
 .Fn fetchListFile "struct url_list *list" "struct url *u" "const char *pattern" "const char *flags"
 .Ft fetchIO *
 .Fn fetchXGetHTTP "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft fetchIO *
 .Fn fetchGetHTTP "struct url *u" "const char *flags"
 .Ft fetchIO *
 .Fn fetchPutHTTP "struct url *u" "const char *flags"
 .Ft int
 .Fn fetchStatHTTP "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft int
 .Fn fetchListHTTP "struct url_list *list" "struct url *u" "const char *pattern" "const char *flags"
 .Ft fetchIO *
 .Fn fetchXGetFTP "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft fetchIO *
 .Fn fetchGetFTP "struct url *u" "const char *flags"
 .Ft fetchIO *
 .Fn fetchPutFTP "struct url *u" "const char *flags"
 .Ft int
 .Fn fetchStatFTP "struct url *u" "struct url_stat *us" "const char *flags"
 .Ft int
 .Fn fetchListFTP "struct url_list *list" "struct url *u" "const char *pattern" "const char *flags"
 .Ft void
 .Fn fetchInitURLList "struct url_list *ul"
 .Ft int
 .Fn fetchAppendURLList "struct url_list *dst" "const struct url_list *src"
 .Ft void
 .Fn fetchFreeURLList "struct url_list *ul"
 .Ft char *
 .Fn fetchUnquotePath "struct url *u"
 .Ft char *
 .Fn fetchUnquoteFilename "struct url *u"
 .Ft char *
 .Fn fetchStringifyURL "const struct url *u"
 .Ft void
 .Fn fetchConnectionCacheInit "int global" "int per_host"
 .Ft void
 .Fn fetchConnectionCacheClose "void"
 .Sh DESCRIPTION
 These functions implement a high-level library for retrieving and
 uploading files using Uniform Resource Locators (URLs).
 .Pp
 .Fn fetchParseURL
 takes a URL in the form of a null-terminated string and splits it into
 its components function according to the Common Internet Scheme Syntax
 detailed in RFC 1738.
 A regular expression which produces this syntax is:
 .Bd -literal -offset indent
 \*[Lt]scheme\*[Gt]:(//(\*[Lt]user\*[Gt](:\*[Lt]pwd\*[Gt])?@)?\*[Lt]host\*[Gt](:\*[Lt]port\*[Gt])?)?/(\*[Lt]doc\*[Gt])?
 .Ed
 .Pp
 If the URL does not seem to begin with a scheme name, it is assumed to be a local path.
 Only absolute path names are accepted.
 .Pp
 Note that some components of the URL are not necessarily relevant to
 all URL schemes.
 For instance, the file scheme only needs the
 .Aq scheme
 and
 .Aq doc
 components.
 .Fn fetchParseURL
 quotes any unsafe character in the URL automatically.
 This is not done by
 .Fn fetchMakeURL .
 .Fn fetchCopyURL
 copies an existing
 .Vt url
 structure.
 .Pp
 .Fn fetchMakeURL ,
 .Fn fetchParseURL ,
 and
 .Fn fetchCopyURL
 return a pointer to a
 .Vt url
 structure, which is defined as follows in
 .In fetch.h :
 .Bd -literal
 #define URL_SCHEMELEN 16
 #define URL_USERLEN 256
 #define URL_PWDLEN 256
 #define URL_HOSTLEN 255
 struct url {
     char	 scheme[URL_SCHEMELEN + 1];
     char	 user[URL_USERLEN + 1];
     char	 pwd[URL_PWDLEN + 1];
     char	 host[URL_HOSTLEN + 1];
     int		 port;
     char	*doc;
     off_t	 offset;
     size_t	 length;
     time_t	 last_modified;
 };
 .Ed
 .Pp
 The pointer returned by
 .Fn fetchMakeURL ,
 .Fn fetchCopyURL ,
 and
 .Fn fetchParseURL
 should be freed using
 .Fn fetchFreeURL .
 The size of
 .Vt struct URL
 is not part of the ABI.
 .Pp
 .Fn fetchXGetURL ,
 .Fn fetchGetURL ,
 and
 .Fn fetchPutURL
 constitute the recommended interface to the
 .Nm fetch
 library.
 They examine the URL passed to them to determine the transfer
 method, and call the appropriate lower-level functions to perform the
 actual transfer.
 .Fn fetchXGetURL
 also returns the remote document's metadata in the
 .Vt url_stat
 structure pointed to by the
 .Fa us
 argument.
 .Pp
 The
 .Fa flags
 argument is a string of characters which specify transfer options.
 The
 meaning of the individual flags is scheme-dependent, and is detailed
 in the appropriate section below.
 .Pp
 .Fn fetchStatURL
 attempts to obtain the requested document's metadata and fill in the
 structure pointed to by its second argument.
 The
 .Vt url_stat
 structure is defined as follows in
 .In fetch.h :
 .Bd -literal
 struct url_stat {
     off_t	 size;
     time_t	 atime;
     time_t	 mtime;
 };
 .Ed
 .Pp
 If the size could not be obtained from the server, the
 .Fa size
 field is set to \-1.
 If the modification time could not be obtained from the server, the
 .Fa mtime
 field is set to the epoch.
 If the access time could not be obtained from the server, the
 .Fa atime
 field is set to the modification time.
 .Pp
 .Fn fetchListURL
 attempts to list the contents of the directory pointed to by the URL provided.
 The pattern can be a simple glob-like expression as hint.
 Callers should not depend on the server to filter names.
 If successful, it appends the list of entries to the
 .Vt url_list
 structure.
 The
 .Vt url_list
 structure is defined as follows in
 .In fetch.h :
 .Bd -literal
 struct url_list {
     size_t	length;
     size_t	alloc_size;
     struct url	*urls;
 };
 .Ed
 .Pp
 The list should be initialized by calling
 .Fn fetchInitURLList
 and the entries be freed by calling
 .Fn fetchFreeURLList .
 The function
 .Fn fetchAppendURLList
 can be used to append one URL lists to another.
 If the
 .Ql c
 (cache result) flag is specified, the library is allowed to internally
 cache the result.
 .Pp
 .Fn fetchStringifyURL
 returns the URL as string.
 .Fn fetchUnquotePath
 returns the path name part of the URL with any quoting undone.
 Query arguments and fragment identifiers are not included.
 .Fn fetchUnquoteFilename
 returns the last component of the path name as returned by
 .Fn fetchUnquotePath .
 .Fn fetchStringifyURL ,
 .Fn fetchUnquotePath ,
 and
 .Fn fetchUnquoteFilename
 return a string that should be deallocated with
 .Fn free
 after use.
 .Pp
 .Fn fetchConnectionCacheInit
 enables the connection cache.
 The first argument specifies the global limit on cached connections.
 The second argument specifies the host limit.
 Entries are considered to specify the same host, if the host name
 from the URL is identical, indepent of the address or address family.
 .Fn fetchConnectionCacheClose
 flushed the connection cache and closes all cached connections.
 .Pp
 .Fn fetchXGet ,
 .Fn fetchGet ,
 .Fn fetchPut ,
 and
 .Fn fetchStat
 are similar to
 .Fn fetchXGetURL ,
 .Fn fetchGetURL ,
 .Fn fetchPutURL ,
 and
 .Fn fetchStatURL ,
 except that they expect a pre-parsed URL in the form of a pointer to
+a
 .Vt struct url
 rather than a string.
 .Pp
 All of the
 .Fn fetchXGetXXX ,
 .Fn fetchGetXXX ,
 and
 .Fn fetchPutXXX
 functions return a pointer to a stream which can be used to read or
 write data from or to the requested document, respectively.
 Note that
 although the implementation details of the individual access methods
 vary, it can generally be assumed that a stream returned by one of the
 .Fn fetchXGetXXX
 or
 .Fn fetchGetXXX
 functions is read-only, and that a stream returned by one of the
 .Fn fetchPutXXX
 functions is write-only.
 .Sh PROTOCOL INDEPENDENT FLAGS
 If the
 .Ql i
 (if-modified-since) flag is specified, the library will try to fetch
 the content only if it is newer than
 .Va last_modified .
 For HTTP an
 .Li If-Modified-Since
 HTTP header is sent.
 For FTP a
 .Li MTDM
 command is sent first and compared locally.
 For FILE the source file is compared.
 .Sh FILE SCHEME
 .Fn fetchXGetFile ,
 .Fn fetchGetFile ,
 and
 .Fn fetchPutFile
 provide access to documents which are files in a locally mounted file
 system.
 Only the
 .Aq document
 component of the URL is used.
 .Pp
 .Fn fetchXGetFile
 and
 .Fn fetchGetFile
 do not accept any flags.
 .Pp
 .Fn fetchPutFile
 accepts the
 .Ql a
 (append to file) flag.
 If that flag is specified, the data written to
 the stream returned by
 .Fn fetchPutFile
 will be appended to the previous contents of the file, instead of
 replacing them.
 .Sh FTP SCHEME
 .Fn fetchXGetFTP ,
 .Fn fetchGetFTP ,
 and
 .Fn fetchPutFTP
 implement the FTP protocol as described in RFC 959.
 .Pp
 By default
 .Nm libfetch
 will attempt to use passive mode first and only fallback to active mode
 if the server reports a syntax error.
 If the
 .Ql a
 (active) flag is specified, a passive connection is not tried and active mode
 is used directly.
 .Pp
 If the
 .Ql l
 (low) flag is specified, data sockets will be allocated in the low (or
 default) port range instead of the high port range (see
 .Xr ip 4 ) .
 .Pp
 If the
 .Ql d
 (direct) flag is specified,
 .Fn fetchXGetFTP ,
 .Fn fetchGetFTP ,
 and
 .Fn fetchPutFTP
 will use a direct connection even if a proxy server is defined.
 .Pp
 If no user name or password is given, the
 .Nm fetch
 library will attempt an anonymous login, with user name "anonymous"
 and password "anonymous@\*[Lt]hostname\*[Gt]".
 .Sh HTTP SCHEME
 The
 .Fn fetchXGetHTTP ,
 .Fn fetchGetHTTP ,
 and
 .Fn fetchPutHTTP
 functions implement the HTTP/1.1 protocol.
 With a little luck, there is
 even a chance that they comply with RFC 2616 and RFC 2617.
 .Pp
 If the
 .Ql d
 (direct) flag is specified,
 .Fn fetchXGetHTTP ,
 .Fn fetchGetHTTP ,
 and
 .Fn fetchPutHTTP
 will use a direct connection even if a proxy server is defined.
 .Pp
 Since there seems to be no good way of implementing the HTTP PUT
 method in a manner consistent with the rest of the
 .Nm fetch
 library,
 .Fn fetchPutHTTP
 is currently unimplemented.
 .Sh AUTHENTICATION
 Apart from setting the appropriate environment variables and
 specifying the user name and password in the URL or the
 .Vt struct url ,
 the calling program has the option of defining an authentication
 function with the following prototype:
 .Pp
 .Ft int
 .Fn myAuthMethod "struct url *u"
 .Pp
 The callback function should fill in the
 .Fa user
 and
 .Fa pwd
 fields in the provided
 .Vt struct url
 and return 0 on success, or any other value to indicate failure.
 .Pp
 To register the authentication callback, simply set
 .Va fetchAuthMethod
 to point at it.
 The callback will be used whenever a site requires authentication and
 the appropriate environment variables are not set.
 .Pp
 This interface is experimental and may be subject to change.
 .Sh RETURN VALUES
 .Fn fetchParseURL
 returns a pointer to a
 .Vt struct url
 containing the individual components of the URL.
 If it is
 unable to allocate memory, or the URL is syntactically incorrect,
 .Fn fetchParseURL
 returns a
 .Dv NULL
 pointer.
 .Pp
 The
 .Fn fetchStat
 functions return 0 on success and \-1 on failure.
 .Pp
 All other functions return a stream pointer which may be used to
 access the requested document, or
 .Dv NULL
 if an error occurred.
 .Pp
 The following error codes are defined in
 .In fetch.h :
 .Bl -tag -width 18n
 .It Bq Er FETCH_ABORT
 Operation aborted
 .It Bq Er FETCH_AUTH
 Authentication failed
 .It Bq Er FETCH_DOWN
 Service unavailable
 .It Bq Er FETCH_EXISTS
 File exists
 .It Bq Er FETCH_FULL
 File system full
 .It Bq Er FETCH_INFO
 Informational response
 .It Bq Er FETCH_MEMORY
 Insufficient memory
 .It Bq Er FETCH_MOVED
 File has moved
 .It Bq Er FETCH_NETWORK
 Network error
 .It Bq Er FETCH_OK
 No error
 .It Bq Er FETCH_PROTO
 Protocol error
 .It Bq Er FETCH_RESOLV
 Resolver error
 .It Bq Er FETCH_SERVER
 Server error
 .It Bq Er FETCH_TEMP
 Temporary error
 .It Bq Er FETCH_TIMEOUT
 Operation timed out
 .It Bq Er FETCH_UNAVAIL
 File is not available
 .It Bq Er FETCH_UNKNOWN
 Unknown error
 .It Bq Er FETCH_URL
 Invalid URL
 .El
 .Pp
 The accompanying error message includes a protocol-specific error code
 and message, e.g.\& "File is not available (404 Not Found)"
 .Sh ENVIRONMENT
 .Bl -tag -width ".Ev FETCH_BIND_ADDRESS"
 .It Ev FETCH_BIND_ADDRESS
 Specifies a host name or IP address to which sockets used for outgoing
 connections will be bound.
 .It Ev FTP_LOGIN
 Default FTP login if none was provided in the URL.
 .It Ev FTP_PASSIVE_MODE
 If set to anything but
 .Ql no ,
 forces the FTP code to use passive mode.
 .It Ev FTP_PASSWORD
 Default FTP password if the remote server requests one and none was
 provided in the URL.
 .It Ev FTP_PROXY
 URL of the proxy to use for FTP requests.
 The document part is ignored.
 FTP and HTTP proxies are supported; if no scheme is specified, FTP is
 assumed.
 If the proxy is an FTP proxy,
 .Nm libfetch
 will send
 .Ql user@host
 as user name to the proxy, where
 .Ql user
 is the real user name, and
 .Ql host
 is the name of the FTP server.
 .Pp
 If this variable is set to an empty string, no proxy will be used for
 FTP requests, even if the
 .Ev HTTP_PROXY
 variable is set.
 .It Ev ftp_proxy
 Same as
 .Ev FTP_PROXY ,
 for compatibility.
 .It Ev HTTP_AUTH
 Specifies HTTP authorization parameters as a colon-separated list of
 items.
 The first and second item are the authorization scheme and realm
 respectively; further items are scheme-dependent.
 Currently, only basic authorization is supported.
 .Pp
 Basic authorization requires two parameters: the user name and
 password, in that order.
 .Pp
 This variable is only used if the server requires authorization and
 no user name or password was specified in the URL.
 .It Ev HTTP_PROXY
 URL of the proxy to use for HTTP requests.
 The document part is ignored.
 Only HTTP proxies are supported for HTTP requests.
 If no port number is specified, the default is 3128.
 .Pp
 Note that this proxy will also be used for FTP documents, unless the
 .Ev FTP_PROXY
 variable is set.
 .It Ev http_proxy
 Same as
 .Ev HTTP_PROXY ,
 for compatibility.
 .It Ev HTTP_PROXY_AUTH
 Specifies authorization parameters for the HTTP proxy in the same
 format as the
 .Ev HTTP_AUTH
 variable.
 .Pp
 This variable is used if and only if connected to an HTTP proxy, and
 is ignored if a user and/or a password were specified in the proxy
 URL.
 .It Ev HTTP_REFERER
 Specifies the referrer URL to use for HTTP requests.
 If set to
 .Dq auto ,
 the document URL will be used as referrer URL.
 .It Ev HTTP_USER_AGENT
 Specifies the User-Agent string to use for HTTP requests.
 This can be useful when working with HTTP origin or proxy servers that
 differentiate between user agents.
 .It Ev NETRC
 Specifies a file to use instead of
 .Pa ~/.netrc
 to look up login names and passwords for FTP sites.
 See
 .Xr ftp 1
 for a description of the file format.
 This feature is experimental.
 .It Ev NO_PROXY
 Either a single asterisk, which disables the use of proxies
 altogether, or a comma- or whitespace-separated list of hosts for
 which proxies should not be used.
 .It Ev no_proxy
 Same as
 .Ev NO_PROXY ,
 for compatibility.
 .It Ev SSL_NO_VERIFY_PEER
 If defined,
 .Nm
 will skip validating certificates when fetching HTTPS URLs.
 .El
 .Sh EXAMPLES
 To access a proxy server on
 .Pa proxy.example.com
 port 8080, set the
 .Ev HTTP_PROXY
 environment variable in a manner similar to this:
 .Pp
 .Dl HTTP_PROXY=http://proxy.example.com:8080
 .Pp
 If the proxy server requires authentication, there are
 two options available for passing the authentication data.
 The first method is by using the proxy URL:
 .Pp
 .Dl HTTP_PROXY=http://\*[Lt]user\*[Gt]:\*[Lt]pwd\*[Gt]@proxy.example.com:8080
 .Pp
 The second method is by using the
 .Ev HTTP_PROXY_AUTH
 environment variable:
 .Bd -literal -offset indent
 HTTP_PROXY=http://proxy.example.com:8080
 HTTP_PROXY_AUTH=basic:*:\*[Lt]user\*[Gt]:\*[Lt]pwd\*[Gt]
 .Ed
 .Pp
 To disable the use of a proxy for an HTTP server running on the local
 host, define
 .Ev NO_PROXY
 as follows:
 .Bd -literal -offset indent
 NO_PROXY=localhost,127.0.0.1
 .Ed
 .Sh SEE ALSO
 .\" .Xr fetch 1 ,
 .\" .Xr ftpio 3 ,
 .Xr ftp 1 ,
 .Xr ip 4
 .Rs
 .%A J. Postel
 .%A J. K. Reynolds
 .%D October 1985
 .%B File Transfer Protocol
 .%O RFC 959
 .Re
 .Rs
 .%A P. Deutsch
 .%A A. Emtage
 .%A A. Marine
 .%D May 1994
 .%T How to Use Anonymous FTP
 .%O RFC 1635
 .Re
 .Rs
 .%A T. Berners-Lee
 .%A L. Masinter
 .%A M. McCahill
 .%D December 1994
 .%T Uniform Resource Locators (URL)
 .%O RFC 1738
 .Re
 .Rs
 .%A R. Fielding
 .%A J. Gettys
 .%A J. Mogul
 .%A H. Frystyk
 .%A L. Masinter
 .%A P. Leach
 .%A T. Berners-Lee
 .%D January 1999
 .%B Hypertext Transfer Protocol -- HTTP/1.1
 .%O RFC 2616
 .Re
 .Rs
 .%A J. Franks
 .%A P. Hallam-Baker
 .%A J. Hostetler
 .%A S. Lawrence
 .%A P. Leach
 .%A A. Luotonen
 .%A L. Stewart
 .%D June 1999
 .%B HTTP Authentication: Basic and Digest Access Authentication
 .%O RFC 2617
 .Re
 .Sh HISTORY
 The
 .Nm fetch
 library first appeared in
 .Fx 3.0 .
 .Sh AUTHORS
 .An -nosplit
 The
 .Nm fetch
 library was mostly written by
 .An Dag-Erling Sm\(/orgrav Aq Mt des@FreeBSD.org
 with numerous suggestions from
 .An Jordan K. Hubbard Aq Mt jkh@FreeBSD.org ,
 .An Eugene Skepner Aq Mt eu@qub.com
 and other
 .Fx
 developers.
 It replaces the older
 .Nm ftpio
 library written by
 .An Poul-Henning Kamp Aq Mt phk@FreeBSD.org
 and
 .An Jordan K. Hubbard Aq Mt jkh@FreeBSD.org .
 .Pp
 This manual page was written by
 .An Dag-Erling Sm\(/orgrav Aq Mt des@FreeBSD.org .
 .Sh BUGS
 Some parts of the library are not yet implemented.
 The most notable
 examples of this are
 .Fn fetchPutHTTP
 and FTP proxy support.
 .Pp
 There is no way to select a proxy at run-time other than setting the
 .Ev HTTP_PROXY
 or
 .Ev FTP_PROXY
 environment variables as appropriate.
 .Pp
 .Nm libfetch
 does not understand or obey 305 (Use Proxy) replies.
 .Pp
 Error numbers are unique only within a certain context; the error
 codes used for FTP and HTTP overlap, as do those used for resolver and
 system errors.
 For instance, error code 202 means "Command not
 implemented, superfluous at this site" in an FTP context and
 "Accepted" in an HTTP context.
 .Pp
 .Fn fetchStatFTP
 does not check that the result of an MDTM command is a valid date.
 .Pp
 The man page is incomplete, poorly written and produces badly
 formatted text.
 .Pp
 The error reporting mechanism is unsatisfactory.
 .Pp
 Some parts of the code are not fully reentrant.

 @@ -1,236 +1,236 @@
-# $NetBSD: Makefile,v 1.237 2023/10/24 22:10:40 wiz Exp $
+# $NetBSD: Makefile,v 1.237.2.1 2024/01/13 12:49:09 bsiegert Exp $
 # Notes to package maintainers:
+#
 # Updating this package does not automatically necessitate bumping
 # PKGTOOLS_REQD in bsd.pkg.mk. Do so if and only if there is a critical
 # change in the pkg_* tools that pkgsrc relies on for proper operation.
 PKGNAME=		pkg_install-${VERSION}
-PKGREVISION=		1
+PKGREVISION=		2
 CATEGORIES=		pkgtools
 MAINTAINER=		agc@NetBSD.org
 HOMEPAGE=		https://www.pkgsrc.org/
 COMMENT=		Package management and administration tools for pkgsrc
 LICENSE=		modified-bsd
 BOOTSTRAP_PKG=		yes
 SKIP_LICENSE_CHECK=	yes
 CONFLICTS+=		audit-packages-[0-9]*
 GNU_CONFIGURE=		yes
 CONFIGURE_ARGS+=	--sysconfdir=${PKG_SYSCONFDIR}
 CONFIGURE_ARGS+=	--with-pkgdbdir=${PKG_DBDIR}
 USE_FEATURES=		nbcompat
 NBCOMPAT_CONFIGURE_ARGS+=	--enable-bsd-getopt --enable-db
 SKIP_AUDIT_PACKAGES=	yes
 NO_PKGTOOLS_REQD_CHECK=	yes
 PKG_PRESERVE=		yes
 CHECK_PERMS_SKIP=	*
 # These are needed to solve a chicken-and-egg problem where pkgsrc uses
 # newer features of pkg_install, but older NetBSD installations won't
 # support them.  In this case, we explicitly use the native GCC
 # compiler to avoid problems with depending on pkgsrc GCC for building
 # pkg_install.
+#
 # We also use the newly built pkg_{add,create,delete} since upgrading
 # from an older pkg_install might required features of the new
 # program, provided that we are not cross-compiling.  (XXX If we are
 # cross-compiling, we should maybe have a host build dependency on
 # ourselves...)
+#
 # Note that the definitions are only overriden for the phases that are
 # supposed to use them.  pkg_admin pmatch might be used when looking for
 # dependencies. If that is ever changed in a incompatible way, this has to
 # be rethought.
 USE_NATIVE_GCC=		yes
 .include "../../mk/bsd.prefs.mk"
 .if ${OS_VARIANT} == "SCOOSR5"
 # SCO OpenServer 5.0.7/3.2's strings.h defines strcasecmp with
 # "unsigned size_t". We cannot use -Werror for net/libfetch.
 MAKE_FLAGS+=	NOGCCERROR=yes
 .endif
 .if defined(_PKGSRC_BARRIER) && empty(USE_CROSS_COMPILE:M[yY][eE][sS])
 PKG_ADD_CMD=		${WRKSRC}/add/pkg_add
 PKG_CREATE_CMD=		${WRKSRC}/create/pkg_create
 PKG_DELETE_CMD=		${WRKSRC}/delete/pkg_delete
+#
 #  Special case for dependency checking in 'non-bootstrap' builds:
 #  don't redefine 'pkg_info' if it already exists.
+#
 .  if defined(PKG_INFO_CMD) && !exists(${PKG_INFO_CMD})
 PKG_INFO_CMD=		${WRKSRC}/info/pkg_info
 .  endif
 .endif
 CPPFLAGS+=		-D_LARGEFILE_SOURCE -D_LARGE_FILES
 CPPFLAGS+=		-D_FILE_OFFSET_BITS=64
 CPPFLAGS+=		-DDEF_UMASK=${DEF_UMASK}
 MAKE_ENV+=		PKGSRC_MACHINE_ARCH=${MACHINE_ARCH}
 MAKE_ENV+=		OPSYS=${OPSYS}
 MAKE_ENV+=		CATMAN_SECTION_SUFFIX=${CATMAN_SECTION_SUFFIX:Q}
 MAKE_ENV+=		MANINSTALL=${MANINSTALL:Q}
 PKG_DBDIR?=		${PREFIX}/pkgdb
 EGDIR=			${PREFIX}/share/examples/pkg_install
 PLIST_SUBST+=		PKG_DBDIR=${PKG_DBDIR}
 DEINSTALL_SRC=		${PKGDIR}/DEINSTALL
 INSTALL_SRC=		${PKGDIR}/INSTALL
 FILES_SUBST+=		PKG_DBDIR=${PKG_DBDIR}			\
 			PKG_TOOLS_BIN=${PKG_TOOLS_BIN:Q}	\
 			MKDIR=${MKDIR:Q}
 .include "../../mk/compiler.mk"
 .if !empty(CC_VERSION:Mclang*)
 MAKE_FLAGS+=		ACTIVE_CC=clang
 .endif
 VERSION!=		${AWK} '/PKGTOOLS_VERSION/ {print $$3}' \
 			${FILESDIR}/lib/version.h
 # Requires 3.x filter API and bugfixes.
 BUILDLINK_API_DEPENDS.libarchive+=	libarchive>=3.3.1
 .include "../../archivers/bzip2/builtin.mk"
 .include "../../archivers/xz/builtin.mk"
 .include "../../archivers/libarchive/builtin.mk"
 .include "../../devel/zlib/builtin.mk"
 .include "../../security/openssl/builtin.mk"
 .include "options.mk"
 .if empty(USE_BUILTIN.bzip2:M[yY][eE][sS]) || \
     empty(USE_BUILTIN.zlib:M[yY][eE][sS])
 USE_BUILTIN.libarchive=	no
 .endif
 FILESDIR.bzip2?=	${.CURDIR}/../../archivers/bzip2/files
 FILESDIR.libarchive?=	${.CURDIR}/../../archivers/libarchive/files
 FILESDIR.zlib?=		${.CURDIR}/../../devel/zlib/files
 FILESDIR.libfetch?=	${.CURDIR}/../../net/libfetch/files
 FILESDIR.netpgpverify?=	${.CURDIR}/../../security/netpgpverify/files
 .if empty(USE_BUILTIN.bzip2:M[yY][eE][sS])
 CPPFLAGS+=	-I${WRKDIR}/bzip2
 LDFLAGS+=	-L${WRKDIR}/bzip2
 .endif
 .if empty(USE_BUILTIN.zlib:M[yY][eE][sS])
 CPPFLAGS+=	-I${WRKDIR}/zlib
 LDFLAGS+=	-L${WRKDIR}/zlib
 .endif
 .if empty(USE_BUILTIN.libarchive:M[yY][eE][sS])
 CPPFLAGS+=	-I${WRKDIR}/libarchive/libarchive
 LDFLAGS+=	-L${WRKDIR}/libarchive/.libs
 # Only use XZ if we actually have builtin support for it. Some systems
 # install the header, but without usable library or prefer to not use
 # the system version, so give them some control.
 .  if empty(USE_BUILTIN.xz:M[Yy][Ee][Ss])
 LIBARCHIVE_CONFIGURE_ARGS+=	--without-lzma
 .  endif
 LIBARCHIVE_LIBS=	${SED} -n -e 's/^Libs.private://p' \
 			${WRKDIR}/libarchive/build/pkgconfig/libarchive.pc 2>/dev/null || echo
 LIBS+=			${LIBARCHIVE_LIBS:sh}
 CONFIG_GUESS_OVERRIDE+=	${WRKDIR}/libarchive/build/autoconf/config.guess \
 			${WRKSRC}/config.guess
 CONFIG_SUB_OVERRIDE+=	${WRKDIR}/libarchive/build/autoconf/config.sub \
 			${WRKSRC}/config.sub
 CPPFLAGS.Cygwin+=	-DLIBARCHIVE_STATIC
 # Make sure that the linker used our static library instead of the
 # (outdated) dynamic library "/usr/lib/libarchive.dylib".
 LDFLAGS.Darwin+=	-Wl,-search_paths_first
 # workaround for pkg/45491
 CONFIGURE_ENV.SunOS+=	ac_cv_header_ext2fs_ext2_fs_h=no
 # Hack to make sure that the libarchive version is replaced
 pre-configure: config-guess-override config-sub-override
 .endif
 CPPFLAGS+=	-I${WRKDIR}/libfetch
 LDFLAGS+=	-L${WRKDIR}/libfetch
 # Avoid duplicate and conflicting headers, pull in any we need
 # directly with <netpgpg/*.h>
 CPPFLAGS+=	-I${WRKDIR}
 LDFLAGS+=	-L${WRKDIR}/netpgp
 CONFIGURE_ENV+=	LIBS=${LIBS:Q}
 do-extract:
 	@${CP} -R ${FILESDIR} ${WRKSRC}
 .if empty(USE_BUILTIN.bzip2:M[yY][eE][sS])
 	@${CP} -R ${FILESDIR.bzip2} ${WRKDIR}/bzip2
 .endif
 .if empty(USE_BUILTIN.zlib:M[yY][eE][sS])
 	@${CP} -R ${FILESDIR.zlib} ${WRKDIR}/zlib
 .endif
 .if empty(USE_BUILTIN.libarchive:M[yY][eE][sS])
 	@${CP} -R ${FILESDIR.libarchive} ${WRKDIR}/libarchive
 .endif
 	@${CP} -R ${FILESDIR.libfetch} ${WRKDIR}/libfetch
 	@${CP} -R ${FILESDIR.netpgpverify} ${WRKDIR}/netpgp
 pre-configure:
 .if empty(USE_BUILTIN.bzip2:M[yY][eE][sS])
 	cd ${WRKDIR}/bzip2 && ${BUILD_MAKE_CMD} libbz2.a
 .endif
 .if empty(USE_BUILTIN.zlib:M[yY][eE][sS])
 	cd ${WRKDIR}/zlib && ${BUILD_MAKE_CMD} libz.a
 .endif
 .if empty(USE_BUILTIN.libarchive:M[yY][eE][sS])
 	cd ${WRKDIR}/libarchive && ${SETENV} ${_CONFIGURE_SCRIPT_ENV}	\
 		${CONFIG_SHELL} ${CONFIG_SHELL_FLAGS} ./configure	\
 		--disable-bsdcpio --disable-bsdtar --disable-shared	\
 		--disable-dependency-tracking --without-expat		\
 		--disable-maintainer-mode				\
 		--without-iconv --without-lzo2 --without-nettle		\
 		--without-xml2 --without-lz4 --without-zstd		\
 		${LIBARCHIVE_CONFIGURE_ARGS}
 	cd ${WRKDIR}/libarchive && ${BUILD_MAKE_CMD}
 .endif
 	cd ${WRKDIR}/libfetch && ${TOUCH} fetch.cat3 &&			\
 		${SETENV} ${MAKE_ENV} ${BSD_MAKE_ENV}			\
 		${MAKE_PROGRAM} ${MAKE_FLAGS} ${BUILD_MAKE_FLAGS}	\
 			-f ${MAKE_FILE} depend all
 	cd ${WRKDIR}/netpgp && ${CP} Makefile.lib.in Makefile.in &&	\
 	${CONFIG_SHELL} ${CONFIG_SHELL_FLAGS} ./configure &&		\
 	${SETENV} ${MAKE_ENV} ${BSD_MAKE_ENV} ${MAKE_PROGRAM}		\
 		${MAKE_FLAGS} ${BUILD_MAKE_FLAGS} -f ${MAKE_FILE} all
 # XXX Reverse the order that update does things since
 # XXX we need pkg_delete built before we can deinstall.
 # XXX This should probably be the default order for all packages.
 update:
 	${MAKE}
 	${MAKE} deinstall _UPDATE_RUNNING=YES
 	${MAKE} ${UPDATE_TARGET}
 	${MAKE} clean
 update-catpages:
 	for f in lib/pkgsrc.7 add/pkg_add.1 admin/pkg_admin.1 \
 	    create/pkg_create.1 delete/pkg_delete.1 info/pkg_info.1 \
 	    lib/pkg_summary.5 lib/pkgsrc.7; do \
 	    mandoc -I os=pkgsrc -Tascii ${FILESDIR}/$$f > \
 		    ${FILESDIR}/$${f%%.[157]}.cat; \
 	done
 	mandoc -I os=pkgsrc -Tascii ${FILESDIR}/lib/pkg_install.conf.5.in > \
 	    ${FILESDIR}/lib/pkg_install.conf.cat.in
 .include "../../mk/bsd.pkg.mk"

 @@ -1,73 +1,73 @@
-# $NetBSD: Makefile,v 1.128 2023/11/08 13:20:39 wiz Exp $
+# $NetBSD: Makefile,v 1.128.2.1 2024/01/13 12:49:09 bsiegert Exp $
 DISTNAME=		pkgin-23.8.1
-PKGREVISION=		2
+PKGREVISION=		3
 CATEGORIES=		pkgtools
 MASTER_SITES=		${MASTER_SITE_GITHUB:=NetBSDfr/}
 GITHUB_TAG=		v${PKGVERSION_NOREV}
 MAINTAINER=		jperkin@pkgsrc.org
 HOMEPAGE=		http://pkgin.net/
 COMMENT=		Apt / yum like tool for managing pkgsrc binary packages
 LICENSE=		modified-bsd
 EGDIR=			${PREFIX}/share/examples/${PKGBASE}
 CONF_FILES=		${EGDIR}/repositories.conf.example		\
 			${PKG_SYSCONFDIR}/${PKGBASE}/repositories.conf
 OWN_DIRS+=		${PKG_SYSCONFDIR}/${PKGBASE}
 OWN_DIRS+=		${VARBASE}/db/pkgin
 INSTALLATION_DIRS+=	bin ${PKGMANDIR}/man1 ${EGDIR}
 BUILD_DEFS+=		PKGIN_REPOSITORY_URL
 BUILD_DEFS+=		VARBASE
 GNU_CONFIGURE=		yes
 CONFIGURE_ARGS+=	--disable-maintainer-mode
 CONFIGURE_ARGS+=	--sysconfdir=${PKG_SYSCONFDIR}
 CONFIGURE_ARGS+=	--with-dbdir=${VARBASE}/db/pkgin
 CONFIGURE_ARGS+=	--with-machine-arch=${MACHINE_ARCH}
 CONFIGURE_ARGS+=	--with-pkg-install=${PKG_TOOLS_BIN}
 CONFIGURE_ARGS+=	--with-libarchive=${BUILDLINK_PREFIX.libarchive}
 CONFIGURE_ARGS+=	--with-libfetch=${BUILDLINK_PREFIX.libfetch}
 CONFIGURE_ARGS+=	--with-openssl=${BUILDLINK_PREFIX.openssl}
 CONFIGURE_ARGS+=	--with-sqlite3=${BUILDLINK_PREFIX.sqlite3}
 USE_FEATURES=		nbcompat
 .include "../../mk/bsd.prefs.mk"
 SUBST_CLASSES.NetBSD+=	osrel
 SUBST_STAGE.osrel=	pre-configure
 SUBST_MESSAGE.osrel=	Adjusting repository OS release
 SUBST_FILES.osrel=	REPOSITORIES
 SUBST_SED.osrel=	-e "s|@OSREL@|${OS_VERSION:C/_.*//}|"
 CFLAGS.SunOS+=		-D_FILE_OFFSET_BITS=64
 DEPENDS+=		pkg_install>=20200701:../../pkgtools/pkg_install
 .include "options.mk"
 # those have official repositories
 .if !empty(PKGIN_REPOSITORY_URL)
 pre-install:
 	${ECHO} ${PKGIN_REPOSITORY_URL} >> ${WRKSRC}/repositories.conf
 .elif ${OPSYS} == "NetBSD" || ${OPSYS} == "DragonFly" || ${OPSYS} == "Minix"
 pre-install:
 	${GREP} -i ${OPSYS} ${WRKSRC}/REPOSITORIES >> 			\
 		${WRKSRC}/repositories.conf
 .endif
 post-install:
 	${INSTALL_DATA} ${WRKSRC}/repositories.conf			\
 		${DESTDIR}${EGDIR}/repositories.conf.example
 	${INSTALL_DATA} ${WRKSRC}/preferred.conf			\
 		${DESTDIR}${EGDIR}/preferred.conf.example
 .include "../../archivers/libarchive/buildlink3.mk"
 .include "../../databases/sqlite3/buildlink3.mk"
 .include "../../net/libfetch/buildlink3.mk"
 .include "../../security/openssl/buildlink3.mk"
 .include "../../mk/bsd.pkg.mk"

 @@ -1,34 +1,34 @@
-# $NetBSD: Makefile,v 1.64 2023/10/24 22:10:22 wiz Exp $
+# $NetBSD: Makefile,v 1.64.2.1 2024/01/13 12:49:09 bsiegert Exp $
 DISTNAME=	libfetch-2.39
-PKGREVISION=	2
+PKGREVISION=	3
 CATEGORIES=	net
 MASTER_SITES=	# empty
 DISTFILES=	# empty
 MAINTAINER=	pkgsrc-users@NetBSD.org
 HOMEPAGE=	https://www.FreeBSD.org/
 COMMENT=	Library to access HTTP/FTP server
 LICENSE=	modified-bsd
 USE_FEATURES=		nbcompat
 USE_BSD_MAKEFILE=	yes
 .include "../../mk/bsd.prefs.mk"
 .if !empty(FETCH_USING:Mfetch)
 CHECK_PERMS=		no
 .endif
 INSTALLATION_DIRS=	include lib ${PKGMANDIR}/cat3 ${PKGMANDIR}/man3
 BUILD_TARGET=	depend all
 INSTALL_TARGET=	install includes
 do-extract:
 	${CP} -r ${FILESDIR} ${WRKSRC}
 	${TOUCH} ${WRKSRC}/fetch.cat3
 .include "options.mk"
 .include "../../mk/bsd.pkg.mk"