69dc99d pkg_dbg: now accept both flags and level — HardenedBSD-pkg

modified libpkg/fetch.c

@@ -249,7 +249,7 @@ pkg_fetch_file_to_fd(struct pkg_repo *repo, int dest, struct fetch_item *fi,

 	 * Error if using plain http://, https:// etc with SRV
 	 */
 	pkg_dbg(PKG_DBG_FETCH, "Request to fetch %s", fi->url);
 	pkg_dbg(PKG_DBG_FETCH, 1, "Request to fetch %s", fi->url);
 	if (repo == NULL) {
 		fakerepo = xcalloc(1, sizeof(struct pkg_repo));
 		fakerepo->url = xstrdup(fi->url);

@@ -292,7 +292,7 @@ pkg_fetch_file_to_fd(struct pkg_repo *repo, int dest, struct fetch_item *fi,

 	if ((retcode = repo->fetcher->open(repo, fi)) != EPKG_OK)
 		goto cleanup;
 	pkg_dbg(PKG_DBG_FETCH, "Fetch: fetcher used: %s", repo->fetcher->scheme);
 	pkg_dbg(PKG_DBG_FETCH, 1, "Fetch: fetcher used: %s", repo->fetcher->scheme);
 	retcode = repo->fetcher->fetch(repo, dest, fi);
 	if (retcode == EPKG_OK)

modified libpkg/fetch_file.c

@@ -95,9 +95,9 @@ stdio_fetch(struct pkg_repo *repo, int dest, struct fetch_item *fi)

 		done += r;
 		if (fi->size > 0) {
 			left -= r;
 			pkg_dbg(PKG_DBG_FETCH, "Read status: %jd over %jd", (intmax_t)done, (intmax_t)fi->size);
 			pkg_dbg(PKG_DBG_FETCH, 1, "Read status: %jd over %jd", (intmax_t)done, (intmax_t)fi->size);
 		} else
 			pkg_dbg(PKG_DBG_FETCH, "Read status: %jd", (intmax_t)done);
 			pkg_dbg(PKG_DBG_FETCH, 1,  "Read status: %jd", (intmax_t)done);
 		if (fi->size > 0)
 			pkg_emit_progress_tick(done, fi->size);
 	}

modified libpkg/fetch_libcurl.c

@@ -149,9 +149,9 @@ curl_do_fetch(struct curl_userdata *data, CURL *cl, struct curl_repodata *cr)

 	curl_easy_setopt(cl, CURLOPT_FOLLOWLOCATION, 1L);
 	curl_easy_setopt(cl, CURLOPT_PRIVATE, &data);
 	if (ctx.debug_flags & PKG_DBG_FETCH)
 	if (ctx.debug_flags & PKG_DBG_FETCH && ctx.debug_level >= 1)
 		curl_easy_setopt(cl, CURLOPT_VERBOSE, 1L);
 	if (ctx.debug_flags & PKG_DBG_FETCH)
 	if (ctx.debug_flags & PKG_DBG_FETCH && ctx.debug_level >= 1)
 		curl_easy_setopt(cl, CURLOPT_DEBUGFUNCTION, my_trace);
 	/* compat with libfetch */

@@ -212,7 +212,7 @@ http_getmirrors(struct pkg_repo *r, struct curl_repodata *cr)

 	size_t cap = 0;
 	struct http_mirror *m, *mirrors = NULL;
 	CURLU *url;
 	pkg_dbg(PKG_DBG_FETCH, "CURL> fetching http mirror list if any");
 	pkg_dbg(PKG_DBG_FETCH, 2, "CURL> fetching http mirror list if any");
 	cl = curl_easy_init();
 	data.fh = open_memstream(& buf, &cap);

@@ -247,7 +247,7 @@ http_getmirrors(struct pkg_repo *r, struct curl_repodata *cr)

 		}
 		m = xmalloc(sizeof(*m));
 		m->url = url;
 		pkg_dbg(PKG_DBG_FETCH, "CURL> appending an http mirror: %s", line);
 		pkg_dbg(PKG_DBG_FETCH, 2, "CURL> appending an http mirror: %s", line);
 		LL_APPEND(mirrors, m);
 	}
 	free(buf);

@@ -287,7 +287,7 @@ int

 curl_open(struct pkg_repo *repo, struct fetch_item *fi __unused)
 {
 	struct curl_repodata *cr;
 	pkg_dbg(PKG_DBG_FETCH, "curl_open");
 	pkg_dbg(PKG_DBG_FETCH, 2, "curl_open");
 	if (repo->fetch_priv != NULL)
 		return (EPKG_OK);

@@ -378,7 +378,7 @@ curl_fetch(struct pkg_repo *repo, int dest, struct fetch_item *fi)

 	data.totalsize = fi->size;
 	data.url = fi->url;
 	pkg_dbg(PKG_DBG_FETCH, "curl> fetching %s\n", fi->url);
 	pkg_dbg(PKG_DBG_FETCH, 2, "curl> fetching %s\n", fi->url);
 	retry = pkg_object_int(pkg_config_get("FETCH_RETRY"));
 	if (repo->mirror_type == SRV || repo->mirror_type == HTTP) {
 		CURLU *cu = curl_url();

@@ -435,16 +435,16 @@ do_retry:

 		free(p);
 		char *lurl;
 		curl_url_get(hu, CURLUPART_URL, &lurl, 0);
 		pkg_dbg(PKG_DBG_FETCH, "CURL> new http mirror url: %s", lurl);
 		pkg_dbg(PKG_DBG_FETCH, 2, "CURL> new http mirror url: %s", lurl);
 		curl_easy_setopt(cl, CURLOPT_CURLU, hu);
 	} else {
 		pkg_dbg(PKG_DBG_FETCH, "CURL> No mirror set url to %s\n", fi->url);
 		pkg_dbg(PKG_DBG_FETCH, 2, "CURL> No mirror set url to %s\n", fi->url);
 		curl_easy_setopt(cl, CURLOPT_URL, fi->url);
 	}
 	if (ctx.debug_flags & PKG_DBG_FETCH) {
 	if (ctx.debug_flags & PKG_DBG_FETCH && ctx.debug_level >= 1) {
 		const char *lurl = NULL;
 		curl_easy_getinfo(cl, CURLINFO_EFFECTIVE_URL, &lurl);
 		pkg_dbg(PKG_DBG_FETCH, "CURL> attempting to fetch from %s, left retry %ld\n",
 		pkg_dbg(PKG_DBG_FETCH, 2, "CURL> attempting to fetch from %s, left retry %ld\n",
 				lurl, retry);
 	}
 	curl_easy_setopt(cl, CURLOPT_HTTPAUTH, (long)CURLAUTH_ANY);

modified libpkg/fetch_ssh.c

@@ -64,7 +64,7 @@ tcp_connect(struct pkg_repo *repo, struct yuarel *u)

 	int sd = -1;
 	int retcode;
 	pkg_dbg(PKG_DBG_FETCH, "TCP> tcp_connect");
 	pkg_dbg(PKG_DBG_FETCH, 1, "TCP> tcp_connect");
 	memset(&hints, 0, sizeof(hints));
 	hints.ai_family = PF_UNSPEC;
 	if (repo->ip == IPV4)

@@ -114,12 +114,12 @@ tcp_connect(struct pkg_repo *repo, struct yuarel *u)

 	if (getline(&line, &linecap, repo->fh) > 0) {
 		if (strncmp(line, "ok:", 3) != 0) {
 			pkg_dbg(PKG_DBG_FETCH, "SSH> server rejected, got: %s", line);
 			pkg_dbg(PKG_DBG_FETCH, 1, "SSH> server rejected, got: %s", line);
 			goto tcp_cleanup;
 		}
 		pkg_dbg(PKG_DBG_FETCH, "SSH> server is: %s", line +4);
 		pkg_dbg(PKG_DBG_FETCH, 1, "SSH> server is: %s", line +4);
 	} else {
 		pkg_dbg(PKG_DBG_FETCH, "SSH> nothing to read, got: %s", line);
 		pkg_dbg(PKG_DBG_FETCH, 1, "SSH> nothing to read, got: %s", line);
 		goto tcp_cleanup;
 	}
 	retcode = EPKG_OK;

@@ -182,7 +182,7 @@ ssh_connect(struct pkg_repo *repo, struct yuarel *u)

 			fprintf(cmd->fp, "%s@", u->username);
 		fprintf(cmd->fp, "%s pkg ssh", u->host);
 		cmdline = xstring_get(cmd);
 		pkg_dbg(PKG_DBG_FETCH, "Fetch: running '%s'", cmdline);
 		pkg_dbg(PKG_DBG_FETCH, 1, "Fetch: running '%s'", cmdline);
 		argv[0] = _PATH_BSHELL;
 		argv[1] = "-c";
 		argv[2] = cmdline;

@@ -201,7 +201,7 @@ ssh_connect(struct pkg_repo *repo, struct yuarel *u)

 		goto ssh_cleanup;
 	}
 	pkg_dbg(PKG_DBG_FETCH, "SSH> connected");
 	pkg_dbg(PKG_DBG_FETCH, 1, "SSH> connected");
 	repo->sshio.in = sshout[0];
 	repo->sshio.out = sshin[1];

@@ -215,12 +215,12 @@ ssh_connect(struct pkg_repo *repo, struct yuarel *u)

 	if (getline(&line, &linecap, repo->fh) > 0) {
 		if (strncmp(line, "ok:", 3) != 0) {
 			pkg_dbg(PKG_DBG_FETCH, "SSH> server rejected, got: %s", line);
 			pkg_dbg(PKG_DBG_FETCH, 1, "SSH> server rejected, got: %s", line);
 			goto ssh_cleanup;
 		}
 		pkg_dbg(PKG_DBG_FETCH, "SSH> server is: %s", line +4);
 		pkg_dbg(PKG_DBG_FETCH, 1, "SSH> server is: %s", line +4);
 	} else {
 		pkg_dbg(PKG_DBG_FETCH, "SSH> nothing to read, got: %s", line);
 		pkg_dbg(PKG_DBG_FETCH, 1, "SSH> nothing to read, got: %s", line);
 		goto ssh_cleanup;
 	}
 	retcode = EPKG_OK;

@@ -252,7 +252,7 @@ pkgprotocol_open(struct pkg_repo *repo, struct fetch_item *fi,

 		return (EPKG_FATAL);
 	}
 	pkg_dbg(PKG_DBG_FETCH, "SSH> tcp_open");
 	pkg_dbg(PKG_DBG_FETCH, 1, "SSH> tcp_open");
 	if (repo->fh == NULL)
 		retcode = proto_connect(repo, &url);
 	else

@@ -261,13 +261,13 @@ pkgprotocol_open(struct pkg_repo *repo, struct fetch_item *fi,

 	if (retcode != EPKG_OK)
 		return (retcode);
 	pkg_dbg(PKG_DBG_FETCH, "SSH> get %s %" PRIdMAX "", url.path, (intmax_t)fi->mtime);
 	pkg_dbg(PKG_DBG_FETCH, 1, "SSH> get %s %" PRIdMAX "", url.path, (intmax_t)fi->mtime);
 	fprintf(repo->fh, "get %s %" PRIdMAX "\n", url.path, (intmax_t)fi->mtime);
 	if ((linelen = getline(&line, &linecap, repo->fh)) > 0) {
 		if (line[linelen -1 ] == '\n')
 			line[linelen -1 ] = '\0';
 		pkg_dbg(PKG_DBG_FETCH, "SSH> recv: %s", line);
 		pkg_dbg(PKG_DBG_FETCH, 1, "SSH> recv: %s", line);
 		if (strncmp(line, "ok:", 3) == 0) {
 			fi->size = strtonum(line + 4, 0, LONG_MAX, &errstr);
 			if (errstr) {

@@ -414,7 +414,7 @@ ssh_write(void *data, const char *buf, int l)

 	iov.iov_base = __DECONST(char *, buf);
 	iov.iov_len = l;
 	pkg_dbg(PKG_DBG_FETCH, "writing data");
 	pkg_dbg(PKG_DBG_FETCH, 1, "SSH> writing data");
 	return (ssh_writev(repo->sshio.out, &iov, 1, repo->fetcher->timeout));
 }

@@ -428,7 +428,7 @@ ssh_read(void *data, char *buf, int len)

 	ssize_t rlen;
 	int deltams;
 	pkg_dbg(PKG_DBG_FETCH, "ssh: start reading");
 	pkg_dbg(PKG_DBG_FETCH, 1, "SSH> start reading");
 	if (repo->fetcher->timeout > 0) {
 		gettimeofday(&timeout, NULL);

@@ -442,7 +442,7 @@ ssh_read(void *data, char *buf, int len)

 	for (;;) {
 		rlen = read(pfd.fd, buf, len);
 		pkg_dbg(PKG_DBG_FETCH, "read %jd", (intmax_t)rlen);
 		pkg_dbg(PKG_DBG_FETCH, 1, "SSH> read %jd", (intmax_t)rlen);
 		if (rlen >= 0) {
 			break;
 		} else if (rlen == -1) {

@@ -468,17 +468,17 @@ ssh_read(void *data, char *buf, int len)

 		errno = 0;
 		pfd.revents = 0;
 		pkg_dbg(PKG_DBG_FETCH, "begin poll()");
 		pkg_dbg(PKG_DBG_FETCH, 2, "SSH> begin poll()");
 		if (poll(&pfd, 1, deltams) < 0) {
 			if (errno == EINTR)
 				continue;
 			return (-1);
 		}
 		pkg_dbg(PKG_DBG_FETCH, "end poll()");
 		pkg_dbg(PKG_DBG_FETCH, 2, "SSH> end poll()");
 	}
 	pkg_dbg(PKG_DBG_FETCH, "ssh: have read %jd bytes", (intmax_t)rlen);
 	pkg_dbg(PKG_DBG_FETCH, 1, "SSH> have read %jd bytes", (intmax_t)rlen);
 	return (rlen);
 }

modified libpkg/pkg_config.c

@@ -619,7 +619,7 @@ add_repo(const ucl_object_t *obj, struct pkg_repo *r, const char *rname, pkg_ini

 	int use_ipvx = 0;
 	int priority = 0;
 	pkg_dbg(PKG_DBG_CONFIG, "parsing repository object %s", rname);
 	pkg_dbg(PKG_DBG_CONFIG, 1, "parsing repository object %s", rname);
 	env = NULL;
 	enabled = ucl_object_find_key(obj, "enabled");

@@ -632,7 +632,7 @@ add_repo(const ucl_object_t *obj, struct pkg_repo *r, const char *rname, pkg_ini

 			 * We basically want to remove the existing repo r and
 			 * forget all stuff parsed
 			 */
 			pkg_dbg(PKG_DBG_CONFIG,"PkgConfig: disabling repo %s", rname);
 			pkg_dbg(PKG_DBG_CONFIG, 1, "disabling repo %s", rname);
 			DL_DELETE(repos, r);
 			pkg_repo_free(r);
 			return;

@@ -721,7 +721,7 @@ add_repo(const ucl_object_t *obj, struct pkg_repo *r, const char *rname, pkg_ini

 	}
 	if (r == NULL && url == NULL) {
 		pkg_dbg(PKG_DBG_CONFIG,"No repo and no url for %s", rname);
 		pkg_dbg(PKG_DBG_CONFIG, 1, "No repo and no url for %s", rname);
 		return;
 	}

@@ -792,10 +792,10 @@ add_repo_obj(const ucl_object_t *obj, const char *file, pkg_init_flags flags)

 	const char *key;
 	key = ucl_object_key(obj);
 	pkg_dbg(PKG_DBG_CONFIG,"PkgConfig: parsing repo key '%s' in file '%s'", key, file);
 	pkg_dbg(PKG_DBG_CONFIG, 1, "parsing repo key '%s' in file '%s'", key, file);
 	r = pkg_repo_find(key);
 	if (r != NULL)
 		pkg_dbg(PKG_DBG_CONFIG,"PkgConfig: overwriting repository %s", key);
 		pkg_dbg(PKG_DBG_CONFIG, 1, "overwriting repository %s", key);
        add_repo(obj, r, key, flags);
 }

@@ -810,10 +810,10 @@ walk_repo_obj(const ucl_object_t *obj, const char *file, pkg_init_flags flags)

 	while ((cur = ucl_iterate_object(obj, &it, true))) {
 		key = ucl_object_key(cur);
 		pkg_dbg(PKG_DBG_CONFIG,"PkgConfig: parsing key '%s'", key);
 		pkg_dbg(PKG_DBG_CONFIG, 1, "parsing key '%s'", key);
 		r = pkg_repo_find(key);
 		if (r != NULL)
 			pkg_dbg(PKG_DBG_CONFIG,"PkgConfig: overwriting repository %s", key);
 			pkg_dbg(PKG_DBG_CONFIG, 1, "overwriting repository %s", key);
 		if (cur->type == UCL_OBJECT)
 			add_repo(cur, r, key, flags);
 		else {

@@ -864,7 +864,7 @@ load_repo_file(int dfd, const char *repodir, const char *repofile,

 	errno = 0;
 	obj = NULL;
 	pkg_dbg(PKG_DBG_CONFIG,"PKgConfig: loading %s/%s", repodir, repofile);
 	pkg_dbg(PKG_DBG_CONFIG, 1, "loading %s/%s", repodir, repofile);
 	fd = openat(dfd, repofile, O_RDONLY);
 	if (fd == -1) {
 		pkg_errno("Unable to open '%s/%s'", repodir, repofile);

@@ -917,7 +917,7 @@ load_repo_files(const char *repodir, pkg_init_flags flags, struct os_info *oi)

 	struct dirent **ent;
 	int nents, i, fd;
 	pkg_dbg(PKG_DBG_CONFIG,"PkgConfig: loading repositories in %s", repodir);
 	pkg_dbg(PKG_DBG_CONFIG, 1, "loading repositories in %s", repodir);
 	if ((fd = open(repodir, O_DIRECTORY|O_CLOEXEC)) == -1)
 		return;

@@ -1374,7 +1374,7 @@ pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags)

 		goto out;
 	}
 	pkg_dbg(PKG_DBG_CONFIG,"%s", "pkg initialized");
 	pkg_dbg(PKG_DBG_CONFIG, 1, "%s", "pkg initialized");
 #ifdef __FreeBSD__
 	ctx.osversion = pkg_object_int(pkg_config_get("OSVERSION"));

@@ -1404,7 +1404,7 @@ pkg_ini(const char *path, const char *reposdir, pkg_init_flags flags)

 	object = ucl_object_find_key(config, "PKG_ENV");
 	while ((cur = ucl_iterate_object(object, &it, true))) {
 		evkey = ucl_object_key(cur);
 		pkg_dbg(PKG_DBG_CONFIG,"Setting env var: %s", evkey);
 		pkg_dbg(PKG_DBG_CONFIG, 1, "Setting env var: %s", evkey);
 		if (evkey != NULL && evkey[0] != '\0')
 			setenv(evkey, ucl_object_tostring_forced(cur), 1);
 	}

modified libpkg/pkg_event.c

@@ -993,22 +993,38 @@ pkg_debug(int level, const char *fmt, ...)

 }
 void
 pkg_dbg(uint64_t flags, const char *fmt, ...)
 pkg_dbg(uint64_t flags, int level, const char *fmt, ...)
 {
 	struct pkg_event ev;
 	va_list ap;
 	xstring *string_fmt = xstring_new();
 	char *nfmt;
 	if (ctx.debug_level < level)
 		return;
 	if ((ctx.debug_flags & (flags|PKG_DBG_ALL)) == 0)
 		return;
 	ev.type = PKG_EVENT_DEBUG;
 	ev.e_debug.level = 1;
 	ev.e_debug.level = level;
 	for (size_t i = 0; i < NELEM(debug_flags); i++) {
 		if (ctx.debug_flags & debug_flags[i].flag) {
 			if (string_fmt->size == 0)
 				fprintf(string_fmt->fp, "(%s", debug_flags[i].name);
 			else
 				fprintf(string_fmt->fp, "|%s", debug_flags[i].name);
 		}
 	}
 	fprintf(string_fmt->fp, ") %s", fmt);
 	nfmt = xstring_get(string_fmt);
 	va_start(ap, fmt);
 	vasprintf(&ev.e_debug.msg, fmt, ap);
 	vasprintf(&ev.e_debug.msg, nfmt, ap);
 	va_end(ap);
 	pkg_emit_event(&ev);
 	free(ev.e_debug.msg);
 	free(nfmt);
 }

modified libpkg/private/event.h

@@ -98,7 +98,7 @@ void pkg_emit_incremental_update(const char *reponame, int processed);

 void pkg_emit_backup(void);
 void pkg_emit_restore(void);
 void pkg_debug(int level, const char *fmt, ...) PKG_FORMAT_ATTRIBUTE(2, 3);
 void pkg_dbg(uint64_t flag, const char *fmt, ...) PKG_FORMAT_ATTRIBUTE(2, 3);
 void pkg_dbg(uint64_t flag, int level, const char *fmt, ...) PKG_FORMAT_ATTRIBUTE(3, 4);
 int pkg_emit_sandbox_call(pkg_sandbox_cb call, int fd, void *ud);
 int pkg_emit_sandbox_get_string(pkg_sandbox_cb call, void *ud, char **str, int64_t *len);