- apk add musl-dev gcc g++ make kyua pkgconf gcompat tcl musl-fts-dev libbsd-dev libarchive-dev openssl-dev bzip2-dev xz-dev zlib-dev m4

scripts/periodic/405.pkg-base-audit

/tests/lua

/tests/metalog

/tests/packing

/tests/ssh

/tests/utils

Changes from 1.18.99.5 to1.18.99.6

- reduce the number of filedescriptors opened at the same time

- update sqlite to 3.40.0

- fix regression in pkg lock

- fix annotate --modify

Changes from 1.18.99.5 to1.18.99.6

- remove backup command, do backup pkg shell .dump should be preferred

  as already done via periodic script

- (r)query: stricter command line validation

- (r)query: new operators: =~ ==~ and !=~

- fix merging of config files accross split upgrades

- fix a regression when executing a shell script

Changes from 1.18.99.4 to 1.18.99.5

- delete: now handles properly provides/requipres

Changes from 1.18.99.3 to 1.18.99.4

- Accept '~' in the version or name of a package

- Autoremove will not remove anything which is required

  by another installed package (via provides or via shlibs_provides)

- Update linenoise to latest version

- Update sqlite to 3.39.3

- Update lua to 5.4.4

- doc: add example on how to restore a package

- query: fix unicity issue

Changes from 1.18.99.2 to 1.18.99.3

- fix regression creating hardlinks

Changes from 1.18.99.1 to 1.18.99.2

- fix directory path matching in the new extraction code

Changes from 1.17.99.11 to 1.18.99.1

- rework the extraction process to fix the case when a file becomes a directory

  during an upgrade

- fix a crash in pkg create

- fix a crash in pkg version -PvL=

- allow to deal with 240 character long filenames

- fix an issue when disabling a repository resulting in breakage of the

  repository list

- fix querying licenses

- fix packaging the lua deinstall scripts

- add pkg.symlink to allow creating symlinks from lua scripts

- performance improvements

- sync libfetch with base bringing in socks proxy support

set med_ver 18

set dev_ver 7

make-config-header external/sqlite/sqlite_cfg.h

.Dd July 27, 2022

The following functions have been added:

.It Fn pkg.symlink "source" "destination"

Create a symbolic link

.Va destination

pointing at

.Va source

.Dd October 06, 2022

.It Va var Cm = Ns Oo = Oc Oo Ar num | Ar string Oc

The value of

is equal to the given number or string.

.It Va var Cm =~ Oo Ar num | Ar string Oc

The value of

.Va var

is equal (case insensitive) to the given number or string.

.It Va var Cm != Oo Ar num | Ar string Oc

The value of

.Va var

is not equal to the given number or string.

.It Va var Cm !=~  Oo Ar num | Ar string Oc

The value of

is not equal case insensitive to the given number or string.

.Dd October 06, 2022

.It Va var Cm = Ns Oo = Oc Oo Ar num | Ar string Oc

The value of

is equal to the given number or string.

.It Va var Cm =~ Oo Ar num | Ar string Oc

The value of

.Va var

is equal (case insensitive) to the given number or string.

.It Va var Cm != Oo Ar num | Ar string Oc

The value of

.Va var

is not equal to the given number or string.

.It Va var Cm !=~  Oo Ar num | Ar string Oc

The value of

is not equal case insensitive to the given number or string.

.\" 1. Redistributions of source code must retain the above copyright

.Dd July 29, 2022

.Bl -tag -width /usr/ports/UPDATING

.It Pa /usr/ports/UPDATING

The default location of the

.Pa UPDATING

file.

.El

.It Fl I Oo Ar index Oc , Fl -index Oo Ar index Oc

.Pp

Restore a backup database:

.Dl % rm /var/db/pkg/local.sqlite

.Dl % xzcat /var/backups/pkg.sql.xz | pkg shell

.Xr pkg-repository 5

#define tll_sort(list, cmp)                                                 \

    do {                                                                    \

	__typeof((list).head) __p;                                          \

	__typeof((list).head) __q;                                          \

	__typeof((list).head) __e;                                          \

	__typeof((list).head) __t;                                          \

        int __insize, __nmerges, __p_size, __q_size;                        \

	if ((list).head == NULL)                                            \

	    break;                                                          \

        __insize = 1;                                                       \

        while (1) {                                                         \

		__p = (list).head;                                          \

		(list).head = NULL;                                         \

                __t = NULL;                                                 \

		__nmerges = 0;                                              \

		while (__p != NULL) {                                       \

	            __nmerges++;                                            \

	            __q = __p;                                              \

		    __p_size = 0;                                           \

		    for (int _i = 0; _i < __insize; _i++) {                 \

			    __p_size++;                                     \

			    __q = __q->next;                                \

			    if (__q == NULL)                                \

			        break;                                      \

		    }                                                       \

	            __q_size = __insize;                                    \

		    while (__p_size > 0 || (__q_size > 0 && __q != NULL)) { \

			    if (__p_size == 0) {                            \

				    __e = __q;                              \

				    __q = __q->next;                        \

				    __q_size--;                             \

			    } else if (__q_size == 0 || __q == NULL) {      \

				    __e = __p;                              \

				    __p = __p->next;                        \

				    __p_size--;                             \

			    } else if (cmp(__p->item, __q->item) <= 0) {    \

				    __e = __p;                              \

				    __p = __p->next;                        \

				    __p_size--;                             \

			    } else {                                        \

				    __e = __q;                              \

				    __q = __q->next;                        \

				    __q_size--;                             \

			    }                                               \

			    if (__t != NULL) {                              \

				    __t->next = __e;                        \

			    } else {                                        \

				    (list).head = __e;                      \

			    }                                               \

			    __e->prev = __t;                                \

			    __t = __e;                                      \

		    }                                                       \

	            __p = __q;                                              \

		}                                                           \

		(list).tail = __t;                                          \

		__t->next = NULL;                                           \

		__insize *= 2;                                              \

		if (__nmerges <= 1)                                         \

			break;                                              \

	}                                                                   \

    } while (0)

__FBSDID("$FreeBSD$");

#include <inttypes.h>

#include <paths.h>

/*

 * SOCKS5 error enumerations

 */

enum SOCKS5_ERR {

/* Protocol errors */

	SOCKS5_ERR_SELECTION,

	SOCKS5_ERR_READ_METHOD,

	SOCKS5_ERR_VER5_ONLY,

	SOCKS5_ERR_NOMETHODS,

	SOCKS5_ERR_NOTIMPLEMENTED,

	SOCKS5_ERR_HOSTNAME_SIZE,

	SOCKS5_ERR_REQUEST,

	SOCKS5_ERR_REPLY,

	SOCKS5_ERR_NON_VER5_RESP,

	SOCKS5_ERR_GENERAL,

	SOCKS5_ERR_NOT_ALLOWED,

	SOCKS5_ERR_NET_UNREACHABLE,

	SOCKS5_ERR_HOST_UNREACHABLE,

	SOCKS5_ERR_CONN_REFUSED,

	SOCKS5_ERR_TTL_EXPIRED,

	SOCKS5_ERR_COM_UNSUPPORTED,

	SOCKS5_ERR_ADDR_UNSUPPORTED,

	SOCKS5_ERR_UNSPECIFIED,

/* Configuration errors */

	SOCKS5_ERR_BAD_HOST,

	SOCKS5_ERR_BAD_PROXY_FORMAT,

	SOCKS5_ERR_BAD_PORT

};

/*

 * Error messages for SOCKS5 errors

 */

static struct fetcherr socks5_errlist[] = {

/* SOCKS5 protocol errors */

	{ SOCKS5_ERR_SELECTION,		FETCH_ABORT,	"SOCKS5: Failed to send selection method" },

	{ SOCKS5_ERR_READ_METHOD,	FETCH_ABORT,	"SOCKS5: Failed to read method" },

	{ SOCKS5_ERR_VER5_ONLY,		FETCH_PROTO,	"SOCKS5: Only version 5 is implemented" },

	{ SOCKS5_ERR_NOMETHODS,		FETCH_PROTO,	"SOCKS5: No acceptable methods" },

	{ SOCKS5_ERR_NOTIMPLEMENTED,	FETCH_PROTO,	"SOCKS5: Method currently not implemented" },

	{ SOCKS5_ERR_HOSTNAME_SIZE,	FETCH_PROTO,	"SOCKS5: Hostname size is above 256 bytes" },

	{ SOCKS5_ERR_REQUEST,		FETCH_PROTO,	"SOCKS5: Failed to request" },

	{ SOCKS5_ERR_REPLY,		FETCH_PROTO,	"SOCKS5: Failed to receive reply" },

	{ SOCKS5_ERR_NON_VER5_RESP,	FETCH_PROTO,	"SOCKS5: Server responded with a non-version 5 response" },

	{ SOCKS5_ERR_GENERAL,		FETCH_ABORT,	"SOCKS5: General server failure" },

	{ SOCKS5_ERR_NOT_ALLOWED,	FETCH_AUTH,	"SOCKS5: Connection not allowed by ruleset" },

	{ SOCKS5_ERR_NET_UNREACHABLE,	FETCH_NETWORK,	"SOCKS5: Network unreachable" },

	{ SOCKS5_ERR_HOST_UNREACHABLE,	FETCH_ABORT,	"SOCKS5: Host unreachable" },

	{ SOCKS5_ERR_CONN_REFUSED,	FETCH_ABORT,	"SOCKS5: Connection refused" },

	{ SOCKS5_ERR_TTL_EXPIRED,	FETCH_TIMEOUT,	"SOCKS5: TTL expired" },

	{ SOCKS5_ERR_COM_UNSUPPORTED,	FETCH_PROTO,	"SOCKS5: Command not supported" },

	{ SOCKS5_ERR_ADDR_UNSUPPORTED,	FETCH_ABORT,	"SOCKS5: Address type not supported" },

	{ SOCKS5_ERR_UNSPECIFIED,	FETCH_UNKNOWN,	"SOCKS5: Unspecified error" },

/* Configuration error */

	{ SOCKS5_ERR_BAD_HOST,		FETCH_ABORT,	"SOCKS5: Bad proxy host" },

	{ SOCKS5_ERR_BAD_PROXY_FORMAT,	FETCH_ABORT,	"SOCKS5: Bad proxy format" },

	{ SOCKS5_ERR_BAD_PORT,		FETCH_ABORT,	"SOCKS5: Bad port" }

};

 * SOCKS5 connection initiation, based on RFC 1928

 * Default DNS resolution over SOCKS5

 */

int

fetch_socks5_init(conn_t *conn, const char *host, int port, int verbose)

{

	/*

	 * Size is based on largest packet prefix (4 bytes) +

	 * Largest FQDN (256) + one byte size (1) +

	 * Port (2)

	 */

	unsigned char buf[BUFF_SIZE];

	unsigned char *ptr;

	int ret = 1;

	if (verbose)

		fetch_info("Initializing SOCKS5 connection: %s:%d", host, port);

	/* Connection initialization */

	ptr = buf;

	*ptr++ = SOCKS_VERSION_5;

	*ptr++ = SOCKS_CONNECTION;

	*ptr++ = SOCKS_RSV;

	if (fetch_write(conn, buf, 3) != 3) {

		ret = SOCKS5_ERR_SELECTION;

		goto fail;

	}

	/* Verify response from SOCKS5 server */

	if (fetch_read(conn, buf, 2) != 2) {

		ret = SOCKS5_ERR_READ_METHOD;

		goto fail;

	}

	ptr = buf;

	if (ptr[0] != SOCKS_VERSION_5) {

		ret = SOCKS5_ERR_VER5_ONLY;

		goto fail;

	}

	if (ptr[1] == SOCKS_NOMETHODS) {

		ret = SOCKS5_ERR_NOMETHODS;

		goto fail;

	}

	else if (ptr[1] != SOCKS5_NOTIMPLEMENTED) {

		ret = SOCKS5_ERR_NOTIMPLEMENTED;

		goto fail;

	}

	/* Send Request */

	*ptr++ = SOCKS_VERSION_5;

	*ptr++ = SOCKS_CONNECTION;

	*ptr++ = SOCKS_RSV;

	/* Encode all targets as a hostname to avoid DNS leaks */

	*ptr++ = SOCKS_ATYP_DOMAINNAME;

	if (strlen(host) > FQDN_SIZE) {

		ret = SOCKS5_ERR_HOSTNAME_SIZE;

		goto fail;

	}

	*ptr++ = strlen(host);

	strncpy(ptr, host, strlen(host));

	ptr = ptr + strlen(host);

	port = htons(port);

	*ptr++ = port & 0x00ff;

	*ptr++ = (port & 0xff00) >> 8;

	if (fetch_write(conn, buf, ptr - buf) != ptr - buf) {

		ret = SOCKS5_ERR_REQUEST;

		goto fail;

	}

	/* BND.ADDR is variable length, read the largest on non-blocking socket */

	if (!fetch_read(conn, buf, BUFF_SIZE)) {

		ret = SOCKS5_ERR_REPLY;

		goto fail;

	}

	ptr = buf;

	if (*ptr++ != SOCKS_VERSION_5) {

		ret = SOCKS5_ERR_NON_VER5_RESP;

		goto fail;

	}

	switch(*ptr++) {

	case SOCKS_SUCCESS:

		break;

	case SOCKS_GENERAL_FAILURE:

		ret = SOCKS5_ERR_GENERAL;

		goto fail;

	case SOCKS_CONNECTION_NOT_ALLOWED:

		ret = SOCKS5_ERR_NOT_ALLOWED;

		goto fail;

	case SOCKS_NETWORK_UNREACHABLE:

		ret = SOCKS5_ERR_NET_UNREACHABLE;

		goto fail;

	case SOCKS_HOST_UNREACHABLE:

		ret = SOCKS5_ERR_HOST_UNREACHABLE;

		goto fail;

	case SOCKS_CONNECTION_REFUSED:

		ret = SOCKS5_ERR_CONN_REFUSED;

		goto fail;

	case SOCKS_TTL_EXPIRED:

		ret = SOCKS5_ERR_TTL_EXPIRED;

		goto fail;

	case SOCKS_COMMAND_NOT_SUPPORTED:

		ret = SOCKS5_ERR_COM_UNSUPPORTED;

		goto fail;

	case SOCKS_ADDRESS_NOT_SUPPORTED:

		ret = SOCKS5_ERR_ADDR_UNSUPPORTED;

		goto fail;

	default:

		ret = SOCKS5_ERR_UNSPECIFIED;

		goto fail;

	}

	return (ret);

fail:

	socks5_seterr(ret);

	return (0);

}

/*

 * Perform SOCKS5 initialization

 */

int

fetch_socks5_getenv(char **host, int *port)

{

	char *socks5env, *endptr, *ext;

	const char *portDelim;

	size_t slen;

	portDelim = ":";

	if ((socks5env = getenv("SOCKS5_PROXY")) == NULL || *socks5env == '\0') {

		*host = NULL;

		*port = -1;

		return (-1);

	}

	/*

	 * IPv6 addresses begin and end in brackets.  Set the port delimiter

	 * accordingly and search for it so we can do appropriate validation.

	 */

	if (socks5env[0] == '[')

		portDelim = "]:";

	slen = strlen(socks5env);

	ext = strstr(socks5env, portDelim);

	if (socks5env[0] == '[') {

		if (socks5env[slen - 1] == ']') {

			*host = strndup(socks5env, slen);

		} else if (ext != NULL) {

			*host = strndup(socks5env, ext - socks5env + 1);

		} else {

			socks5_seterr(SOCKS5_ERR_BAD_PROXY_FORMAT);

			return (0);

		}

	} else {

		*host = strndup(socks5env, ext - socks5env);

	}

	if (*host == NULL) {

		fprintf(stderr, "Failure to allocate memory, exiting.\n");

		return (-1);

	}

	if (ext == NULL) {

		*port = 1080; /* Default port as defined in RFC1928 */

	} else {

		ext += strlen(portDelim);

		errno = 0;

		*port = strtoimax(ext, (char **)&endptr, 10);

		if (*endptr != '\0' || errno != 0 || *port < 0 ||

		    *port > 65535) {

			free(*host);

			*host = NULL;

			socks5_seterr(SOCKS5_ERR_BAD_PORT);

			return (0);

		}

	}

	return (2);

}

/*

fetch_connect(const char *host, int port, int af, int verbose)

	char *sockshost;

	int socksport;

	DEBUGF("---> %s:%d\n", host, port);

	/*

	 * Check if SOCKS5_PROXY env variable is set.  fetch_socks5_getenv

	 * will either set sockshost = NULL or allocate memory in all cases.

	 */

	sockshost = NULL;

	if (!fetch_socks5_getenv(&sockshost, &socksport))

	/* Not using SOCKS5 proxy */

	if (sockshost == NULL) {

		/* resolve server address */

		if (verbose)

			fetch_info("resolving server address: %s:%d", host,

			    port);

		if ((sais = fetch_resolve(host, port, af)) == NULL)

			goto fail;

		/* resolve client address */

		bindaddr = getenv("FETCH_BIND_ADDRESS");

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

			if (verbose)

				fetch_info("resolving client address: %s",

				    bindaddr);

			if ((cais = fetch_resolve(bindaddr, 0, af)) == NULL)

				goto fail;

		}

	} else {

		/* resolve socks5 proxy address */

			fetch_info("resolving SOCKS5 server address: %s:%d",

			    sockshost, socksport);

		if ((sais = fetch_resolve(sockshost, socksport, af)) == NULL) {

			socks5_seterr(SOCKS5_ERR_BAD_HOST);

		}

		if (verbose && sockshost == NULL) {

			fetch_info("failed to connect to %s:%d", host, port);

			goto syserr;

		} else if (sockshost != NULL) {

			if (verbose)

				fetch_info(

				    "failed to connect to SOCKS5 server %s:%d",

				    sockshost, socksport);

			socks5_seterr(SOCKS5_ERR_CONN_REFUSED);

			goto fail;

		}

	if (sockshost)

		if (!fetch_socks5_init(conn, host, port, verbose))

			goto fail;

	free(sockshost);

	free(sockshost);

	/* Fully close if it was opened; otherwise just don't leak the fd. */

	if (conn != NULL)

		fetch_close(conn);

	else if (sd >= 0)

	ssl_ctx_options = SSL_OP_ALL | SSL_OP_NO_SSLv3 | SSL_OP_NO_TICKET;

/* For SOCKS header size */

#define HEAD_SIZE	4

#define FQDN_SIZE	256

#define PACK_SIZE	1

#define PORT_SIZE	2

#define BUFF_SIZE	HEAD_SIZE + FQDN_SIZE + PACK_SIZE + PORT_SIZE

/* SOCKS5 Request Header */

#define SOCKS_VERSION_5		0x05

/* SOCKS5 CMD */

#define SOCKS_CONNECTION	0x01

#define SOCKS_BIND		0x02

#define SOCKS_UDP		0x03

#define SOCKS_NOMETHODS		0xFF

#define SOCKS5_NOTIMPLEMENTED	0x00

/* SOCKS5 Reserved */

#define SOCKS_RSV		0x00

/* SOCKS5 Address Type */

#define SOCKS_ATYP_IPV4		0x01

#define SOCKS_ATYP_DOMAINNAME	0x03

#define SOCKS_ATYP_IPV6		0x04

/* SOCKS5 Reply Field */

#define SOCKS_SUCCESS			0x00

#define SOCKS_GENERAL_FAILURE		0x01

#define SOCKS_CONNECTION_NOT_ALLOWED	0x02

#define SOCKS_NETWORK_UNREACHABLE	0x03

#define SOCKS_HOST_UNREACHABLE		0x04

#define SOCKS_CONNECTION_REFUSED	0x05

#define SOCKS_TTL_EXPIRED		0x06

#define SOCKS_COMMAND_NOT_SUPPORTED	0x07

#define SOCKS_ADDRESS_NOT_SUPPORTED	0x08

int		 fetch_socks5_getenv(char **host, int *port);

int		 fetch_socks5_init(conn_t *conn, const char *host,

		     int port, int verbose);

conn_t		*fetch_connect(const char *, int, int, int);

#define socks5_seterr(n) fetch_seterr(socks5_errlist, n)

#include <stdbool.h>

	int r;

	r = fetch_close(io->conn);

	if (io->buf)

		free(io->buf);

http_funopen(conn_t *conn, int chunked)

	int t;

		dst += 4;

http_connect(struct url *URL, struct url *purl, const char *flags)

	bool isproxyauth = false;

	http_auth_challenges_t proxy_challenges;