ssh.c elfhints.c \

/*-

 * Copyright (c) 1998 John D. Polstra

 * Copyright (c) 2012 Matthew Seaman <matthew@FreeBSD.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: stable/8/sbin/ldconfig/elfhints.c 76224 2001-05-02 23:56:21Z obrien $

 */

#include <bsd_compat.h>

#include "private/pkg_abi.h"

#include <sys/mman.h>

#include <sys/stat.h>

#ifdef HAVE_SYS_ENDIAN_H

#include <sys/endian.h>

#elif HAVE_ENDIAN_H

#include <endian.h>

#elif HAVE_MACHINE_ENDIAN_H

#include <machine/endian.h>

#endif

#ifdef __APPLE__

#include <libkern/OSByteOrder.h>

#define be32toh(n) OSSwapBigToHostInt32(n)

#define le32toh(n) OSSwapLittleToHostInt32(n)

#endif

#include <assert.h>

#include <ctype.h>

#include <dirent.h>

#include <err.h>

#include <errno.h>

#include <fcntl.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "pkg.h"

#include "private/pkg.h"

#include "private/ldconfig.h"

#define MAXDIRS		1024		/* Maximum directories in path */

#define MAXFILESIZE	(16*1024)	/* Maximum hints file size */

struct shlib {

	const char	*name;

	char		 path[];

};

static int	shlib_list_add(pkghash **shlib_list,

				const char *dir, const char *shlib_file);

static int	scan_dirs_for_shlibs(pkghash **shlib_list,

				     int numdirs, const char **dirlist,

	                             bool strictnames);

static void	add_dir(const char *, const char *, int);

static void	read_dirs_from_file(const char *, const char *);

static void	read_elf_hints(const char *, int);

static void	write_elf_hints(const char *);

static const char	*dirs[MAXDIRS];

static int		 ndirs;

static int		 is_be;

int			 insecure;

#define COND_SWAP(n) (is_be ? be32toh(n) : le32toh(n))

/* Known shlibs on the standard system search path.  Persistent,

   common to all applications */

static pkghash *shlibs = NULL;

/* Known shlibs on the specific RPATH or RUNPATH of one binary.

   Evanescent. */

static pkghash *rpath = NULL;

void

shlib_list_init(void)

{

	assert(pkghash_count(shlibs) == 0);

}

void

rpath_list_init(void)

{

	assert(pkghash_count(rpath) == 0);

}

static int

shlib_list_add(pkghash **shlib_list, const char *dir,

    const char *shlib_file)

{

	struct shlib	*sl;

	size_t path_len, dir_len;

	/* If shlib_file is already in the shlib_list table, don't try

	 * and add it again */

	if (pkghash_get(*shlib_list, shlib_file) != NULL)

		return (EPKG_OK);

	path_len = strlen(dir) + strlen(shlib_file) + 2;

	sl = xcalloc(1, sizeof(struct shlib) + path_len);

	strlcpy(sl->path, dir, path_len);

	dir_len = strlcat(sl->path, "/", path_len);

	strlcat(sl->path, shlib_file, path_len);

	sl->name = sl->path + dir_len;

	pkghash_safe_add(*shlib_list, sl->name, sl, free);

	return (EPKG_OK);

}

const char *

shlib_list_find_by_name(const char *shlib_file)

{

	struct shlib *sl;

	sl = pkghash_get_value(rpath, shlib_file);

	if (sl != NULL)

		return (sl->path);

	sl = pkghash_get_value(shlibs, shlib_file);

	if (sl != NULL)

		return (sl->path);

	return (NULL);

}

void

shlib_list_free(void)

{

	pkghash_destroy(shlibs);

	shlibs = NULL;

}

void

rpath_list_free(void)

{

	pkghash_destroy(rpath);

	rpath = NULL;

}

static void

add_dir(const char *hintsfile, const char *name, int trusted)

{

	struct stat 	stbuf;

	int		i;

	/* Do some security checks */

	if (!trusted && !insecure) {

		if (stat(name, &stbuf) == -1) {

			warn("%s", name);

			return;

		}

		if (stbuf.st_uid != 0) {

			warnx("%s: ignoring directory not owned by root", name);

			return;

		}

		if ((stbuf.st_mode & S_IWOTH) != 0) {

			warnx("%s: ignoring world-writable directory", name);

			return;

		}

		if ((stbuf.st_mode & S_IWGRP) != 0) {

			warnx("%s: ignoring group-writable directory", name);

			return;

		}

	}

	for (i = 0;  i < ndirs;  i++)

		if (STREQ(dirs[i], name))

			return;

	if (ndirs >= MAXDIRS)

		errx(1, "\"%s\": Too many directories in path", hintsfile);

	dirs[ndirs++] = name;

}

static int

scan_dirs_for_shlibs(pkghash **shlib_list, int numdirs,

		     const char **dirlist, bool strictnames)

{

	int	i;

	/* Expect shlibs to follow the name pattern libfoo.so.N if

	   strictnames is true -- ie. when searching the default

	   library search path.

	   Otherwise, allow any name ending in .so or .so.N --

	   ie. when searching RPATH or RUNPATH and assuming it

	   contains private shared libraries which can follow just

	   about any naming convention */

	for (i = 0;  i < numdirs;  i++) {

		DIR		*dirp;

		struct dirent	*dp;

		if ((dirp = opendir(dirlist[i])) == NULL)

			continue;

		while ((dp = readdir(dirp)) != NULL) {

			int		 len;

			int		 ret;

			const char	*vers;

			/* Only regular files and sym-links. On some

			   filesystems d_type is not set, on these the d_type

			   field will be DT_UNKNOWN. */

			if (dp->d_type != DT_REG && dp->d_type != DT_LNK &&

			    dp->d_type != DT_UNKNOWN)

				continue;

			len = strlen(dp->d_name);

			if (strictnames) {

				/* Name can't be shorter than "libx.so" */

				if (len < 7 ||

				    strncmp(dp->d_name, "lib", 3) != 0)

					continue;

			}

			vers = dp->d_name + len;

			while (vers > dp->d_name &&

			       (isdigit(*(vers-1)) || *(vers-1) == '.'))

				vers--;

			if (vers == dp->d_name + len) {

				if (strncmp(vers - 3, ".so", 3) != 0)

					continue;

			} else if (vers < dp->d_name + 3 ||

			    strncmp(vers - 3, ".so.", 4) != 0)

				continue;

			/* We have a valid shared library name. */

			ret = shlib_list_add(shlib_list, dirlist[i],

					      dp->d_name);

			if (ret != EPKG_OK) {

				closedir(dirp);

				return ret;

			}

		}

		closedir(dirp);

	}

	return 0;

}

#define ORIGIN	"$ORIGIN"

int shlib_list_from_rpath(const char *rpath_str, const char *dirpath)

{

	const char    **dirlist;

	char	       *buf;

	size_t		buflen;

	int		i, numdirs;

	int		ret;

	const char     *c, *cstart;

	/* The special token $ORIGIN should be replaced by the

	   dirpath: adjust buflen calculation to account for this */

	numdirs = 1;

	for (c = rpath_str; *c != '\0'; c++)

		if (*c == ':')

			numdirs++;

	buflen = numdirs * sizeof(char *) + strlen(rpath_str) + 1;

	i = strlen(dirpath) - strlen(ORIGIN);

	if (i > 0)

		buflen += i * numdirs;

	dirlist = xcalloc(1, buflen);

	buf = (char *)dirlist + numdirs * sizeof(char *);

	buf[0] = '\0';

	cstart = rpath_str;

	while ( (c = strstr(cstart, ORIGIN)) != NULL ) {

		strncat(buf, cstart, c - cstart);

		strlcat(buf, dirpath, buflen);

		cstart = c + strlen(ORIGIN);

	}

	strlcat(buf, cstart, buflen);

	i = 0;

	while ((c = strsep(&buf, ":")) != NULL) {

		if (strlen(c) > 0)

			dirlist[i++] = c;

	}

	assert(i <= numdirs);

	ret = scan_dirs_for_shlibs(&rpath, i, dirlist, false);

	free(dirlist);

	return (ret);

}

int

shlib_list_from_elf_hints(const char *hintsfile)

{

	if (ctx.abi.os == PKG_OS_FREEBSD || ctx.abi.os == PKG_OS_DRAGONFLY)

		read_elf_hints(hintsfile, false);

	return (scan_dirs_for_shlibs(&shlibs, ndirs, dirs, true));

}

static const char *stage_dirs[] = {

	"/lib",

	"/usr/lib",

};

void

shlib_list_from_stage(const char *stage)

{

	int i;

	char *dir;

	if (stage == NULL)

		return;

	for (i = 0; i < NELEM(stage_dirs); i++) {

		xasprintf(&dir, "%s%s", stage, stage_dirs[i]);

		scan_dirs_for_shlibs(&shlibs, 1, (const char **)&dir, true);

		free(dir);

	}

}

void

list_elf_hints(const char *hintsfile)

{

	int	i;

	int	nlibs;

	read_elf_hints(hintsfile, 1);

	printf("%s:\n", hintsfile);

	printf("\tsearch directories:");

	for (i = 0;  i < ndirs;  i++)

		printf("%c%s", i == 0 ? ' ' : ':', dirs[i]);

	putchar('\n');

	nlibs = 0;

	for (i = 0;  i < ndirs;  i++) {

		DIR		*dirp;

		struct dirent	*dp;

		if ((dirp = opendir(dirs[i])) == NULL)

			continue;

		while ((dp = readdir(dirp)) != NULL) {

			int		 len;

			int		 namelen;

			const char	*name;

			const char	*vers;

			/* Name can't be shorter than "libx.so.0" */

			if ((len = strlen(dp->d_name)) < 9 ||

			    strncmp(dp->d_name, "lib", 3) != 0)

				continue;

			name = dp->d_name + 3;

			vers = dp->d_name + len;

			while (vers > dp->d_name && isdigit(*(vers-1)))

				vers--;

			if (vers == dp->d_name + len)

				continue;

			if (vers < dp->d_name + 4 ||

			    strncmp(vers - 4, ".so.", 4) != 0)

				continue;

			/* We have a valid shared library name. */

			namelen = (vers - 4) - name;

			printf("\t%d:-l%.*s.%s => %s/%s\n", nlibs,

			    namelen, name, vers, dirs[i], dp->d_name);

			nlibs++;

		}

		closedir(dirp);

	}

}

static void

read_dirs_from_file(const char *hintsfile, const char *listfile)

{

	FILE	*fp;

	char	 buf[MAXPATHLEN];

	int	 linenum;

	if ((fp = fopen(listfile, "re")) == NULL)

		err(1, "%s", listfile);

	linenum = 0;

	while (fgets(buf, sizeof buf, fp) != NULL) {

		char	*cp, *sp;

		linenum++;

		cp = buf;

		/* Skip leading white space. */

		while (isspace(*cp))

			cp++;

		if (*cp == '#' || *cp == '\0')

			continue;

		sp = cp;

		/* Advance over the directory name. */

		while (!isspace(*cp) && *cp != '\0')

			cp++;

		/* Terminate the string and skip trailing white space. */

		if (*cp != '\0') {

			*cp++ = '\0';

			while (isspace(*cp))

				cp++;

		}

		/* Now we had better be at the end of the line. */

		if (*cp != '\0')

			warnx("%s:%d: trailing characters ignored",

			    listfile, linenum);

		sp = xstrdup(sp);

		add_dir(hintsfile, sp, 0);

	}

	fclose(fp);

}

static void

read_elf_hints(const char *hintsfile, int must_exist)

{

	int	 		 fd;

	struct stat		 s;

	void			*mapbase;

	struct elfhints_hdr	*hdr;

	char			*strtab;

	char			*dirlist;

	char			*p;

	if ((fd = open(hintsfile, O_RDONLY)) == -1) {

		if (errno == ENOENT && !must_exist)

			return;

		err(1, "Cannot open \"%s\"", hintsfile);

	}

	if (fstat(fd, &s) == -1)

		err(1, "Cannot stat \"%s\"", hintsfile);

	if (s.st_size > MAXFILESIZE)

		errx(1, "\"%s\" is unreasonably large", hintsfile);

	/*

	 * We use a read-write, private mapping so that we can null-terminate

	 * some strings in it without affecting the underlying file.

	 */

	mapbase = mmap(NULL, s.st_size, PROT_READ|PROT_WRITE,

	    MAP_PRIVATE, fd, 0);

	if (mapbase == MAP_FAILED)

		err(1, "Cannot mmap \"%s\"", hintsfile);

	close(fd);

	hdr = (struct elfhints_hdr *)mapbase;

	is_be = be32toh(hdr->magic) == ELFHINTS_MAGIC;

	if (COND_SWAP(hdr->magic) != ELFHINTS_MAGIC)

		errx(1, "\"%s\": invalid file format", hintsfile);

	if (COND_SWAP(hdr->version) != 1)

		errx(1, "\"%s\": unrecognized file version (%d)", hintsfile,

		    COND_SWAP(hdr->version));

	strtab = (char *)mapbase + COND_SWAP(hdr->strtab);

	dirlist = strtab + COND_SWAP(hdr->dirlist);

	if (*dirlist != '\0')

		while ((p = strsep(&dirlist, ":")) != NULL)

			add_dir(hintsfile, p, 1);

}

void

update_elf_hints(const char *hintsfile, int argc, char **argv, int merge)

{

	int	i;

	if (merge)

		read_elf_hints(hintsfile, 0);

	else

		// remove when FreeBSD switches to LE for all architectures

		is_be = be32toh(1) == 1;

	for (i = 0;  i < argc;  i++) {

		struct stat	s;

		if (stat(argv[i], &s) == -1)

			warn("warning: %s", argv[i]);

		else if (S_ISREG(s.st_mode))

			read_dirs_from_file(hintsfile, argv[i]);

		else

			add_dir(hintsfile, argv[i], 0);

	}

	write_elf_hints(hintsfile);

}

static void

write_elf_hints(const char *hintsfile)

{

	struct elfhints_hdr	 hdr;

	char			*tempname;

	int			 fd;

	FILE			*fp;

	int			 i;

	xasprintf(&tempname, "%s.XXXXXX", hintsfile);

	if ((fd = mkstemp(tempname)) ==  -1)

		err(1, "mkstemp(%s)", tempname);

	if (fchmod(fd, 0444) == -1)

		err(1, "fchmod(%s)", tempname);

	if ((fp = fdopen(fd, "wb")) == NULL)

		err(1, "fdopen(%s)", tempname);

	hdr.magic = COND_SWAP(ELFHINTS_MAGIC);

	hdr.version = COND_SWAP(1);

	hdr.strtab = COND_SWAP(sizeof hdr);

	hdr.strsize = 0;

	hdr.dirlist = 0;

	memset(hdr.spare, 0, sizeof hdr.spare);

	/* Count up the size of the string table. */

	if (ndirs > 0) {

		hdr.strsize += strlen(dirs[0]);

		for (i = 1;  i < ndirs;  i++)

			hdr.strsize += 1 + strlen(dirs[i]);

	}

	hdr.dirlistlen = COND_SWAP(hdr.strsize);

	hdr.strsize++;	/* For the null terminator */

	hdr.strsize = COND_SWAP(hdr.strsize);

	/* Write the header. */

	if (fwrite(&hdr, 1, sizeof hdr, fp) != sizeof hdr)

		err(1, "%s: write error", tempname);

	/* Write the strings. */

	if (ndirs > 0) {

		if (fputs(dirs[0], fp) == EOF)

			err(1, "%s: write error", tempname);

		for (i = 1;  i < ndirs;  i++)

			if (fprintf(fp, ":%s", dirs[i]) < 0)

				err(1, "%s: write error", tempname);

	}

	if (putc('\0', fp) == EOF || fclose(fp) == EOF)

		err(1, "%s: write error", tempname);

	if (rename(tempname, hintsfile) == -1)

		err(1, "rename %s to %s", tempname, hintsfile);

	free(tempname);

}

	int (*pkg_analyse)(const bool developer_mode, struct pkg *pkg,

	    const char *fpath);

 * Supports getting struct pkg_abi from the binary's load commands. 

static const char * const system_dylib_prefixes[] = {

	"/System/",

	"/usr/lib/",

	"/lib/",

};

static bool

system_dylib(const char *libname)

{

	const char * const *p = system_dylib_prefixes;

	const char * const *p_end = p + NELEM(system_dylib_prefixes);

	while (p < p_end) {

		if (strncmp(libname, *p, strlen(*p)) == 0) {

			return true;

		}

		p++;

	}

	return false;

}

analyse_macho(int fd, struct pkg *pkg, const bool baselibs)

			if (!baselibs && system_dylib(dylib->path)) {

				pkg_debug(3,

					"Skipping System dynamic library path: %s ts %"PRIu32" current(%"PRIuFAST16", %"PRIuFAST16", %"PRIuFAST16") compat(%"PRIuFAST16", %"PRIuFAST16", %"PRIuFAST16")\n",

					dylib->path, dylib->timestamp,

					dylib->current_version.major,

					dylib->current_version.minor,

					dylib->current_version.patch,

					dylib->compatibility_version.major,

					dylib->compatibility_version.minor,

					dylib->compatibility_version.patch);

				// while under Darwin full path references are recommended and ubiquitous,

				// we align with pkg native environment and use only the basename

				// this also strips off any @executable_path, @loader_path, @rpath components

				const char * basename = strrchr(dylib->path, '/');

				basename = basename ? basename + 1 : dylib->path;

				pkg_debug(3,

					"Adding dynamic library path: %s ts %"PRIu32" current(%"PRIuFAST16", %"PRIuFAST16", %"PRIuFAST16") compat(%"PRIuFAST16", %"PRIuFAST16", %"PRIuFAST16")\n",

					dylib->path, dylib->timestamp,

					dylib->current_version.major,

					dylib->current_version.minor,

					dylib->current_version.patch,

					dylib->compatibility_version.major,

					dylib->compatibility_version.minor,

					dylib->compatibility_version.patch);

				char *lib_with_version;

				if (dylib->current_version.patch) {

					xasprintf(&lib_with_version, "%s-%"PRIuFAST16".%"PRIuFAST16".%"PRIuFAST16, basename, dylib->current_version.major, dylib->current_version.minor, dylib->current_version.patch);

				} else {

					xasprintf(&lib_with_version, "%s-%"PRIuFAST16".%"PRIuFAST16, basename, dylib->current_version.major, dylib->current_version.minor);

				}

				if (LC_ID_DYLIB == loadcmd) {

					pkg_addshlib_provided(pkg, lib_with_version);

				} else {

					pkg_addshlib_required(pkg, lib_with_version);

				}

				free(lib_with_version);

	bool baselibs = pkg_object_bool(pkg_config_get("ALLOW_BASE_SHLIBS"));

	pkg_debug(1, "Analysing Mach-O %s %d", fpath, baselibs);

		ret = analyse_macho(fd, pkg, baselibs);

		PKG_BOOL,

		"ALLOW_BASE_SHLIBS",

		"NO",

	},

	{

#include "private/ldconfig.h"

/* FFR: when we support installing a 32bit package on a 64bit host */

#define _PATH_ELF32_HINTS       "/var/run/ld-elf32.so.hints"

static int

filter_system_shlibs(const char *name, char *path, size_t pathlen)

{

	const char *shlib_path;

	shlib_path = shlib_list_find_by_name(name);

	if (shlib_path == NULL) {

		/* dynamic linker could not resolve */

		return (EPKG_FATAL);

	}

	if (pkg_object_bool(pkg_config_get("ALLOW_BASE_SHLIBS"))) {

		if (strstr(shlib_path, "/lib32/") != NULL)

			return (EPKG_END);

	} else {

		/* match /lib, /lib32, /usr/lib and /usr/lib32 */

		if (strncmp(shlib_path, "/lib", 4) == 0 ||

		    strncmp(shlib_path, "/usr/lib", 8) == 0)

			return (EPKG_END); /* ignore libs from base */

	}

	if (path != NULL)

		strncpy(path, shlib_path, pathlen);

	return (EPKG_OK);

}

/* ARGSUSED */

static int

add_shlibs_to_pkg(struct pkg *pkg, const char *fpath, const char *name,

    bool is_shlib)

{

	struct pkg_file *file = NULL;

	const char *filepath;

	size_t fsz, nsz;

	switch(filter_system_shlibs(name, NULL, 0)) {

	case EPKG_OK:		/* A non-system library */

		pkg_addshlib_required(pkg, name);

		return (EPKG_OK);

	case EPKG_END:		/* A system library */

		return (EPKG_OK);

	default:

		/* Ignore link resolution errors if we're analysing a

		   shared library. */

		if (is_shlib)

			return (EPKG_OK);

		while (pkg_files(pkg, &file) == EPKG_OK) {

			filepath = file->path;

			fsz = strlen(filepath);

			nsz = strlen(name);

			if (fsz >= nsz &&

			    STREQ(&filepath[fsz - nsz], name)) {

				pkg_addshlib_required(pkg, name);

				return (EPKG_OK);

			}

		}

		pkg_emit_notice("(%s-%s) %s - required shared library %s not "

		    "found", pkg->name, pkg->version, fpath, name);

		return (EPKG_FATAL);

	}

}

	const char *shlib;

	char *rpath = NULL;

	bool is_shlib = false;

	/* First, scan through the data from the .dynamic section to

	   find any RPATH or RUNPATH settings.  These are colon

	   separated paths to prepend to the ld.so search paths from

	   the ELF hints file.  These always seem to come right after

	   the NEEDED shared library entries.

	   NEEDED entries should resolve to a filename for installed

	   executables, but need not resolve for installed shared

	   libraries -- additional info from the apps that link

	   against them would be required.  Shared libraries are

	   distinguished by a DT_SONAME tag */

	rpath_list_init();

		if (dyn->d_tag == DT_SONAME) {

			is_shlib = true;

			/* The file being scanned is a shared library

			   *provided* by the package. Record this if

			   appropriate */

			shlib = elf_strptr(e, sh_link, dyn->d_un.d_val);

			if (shlib != NULL && *shlib != '\0')

				pkg_addshlib_provided(pkg, shlib);

		if ((dyn->d_tag == DT_RPATH || dyn->d_tag == DT_RUNPATH) &&

		    rpath == NULL)

			rpath = elf_strptr(e, sh_link, dyn->d_un.d_val);

	}

	if (rpath != NULL) {

		char *p = xstrdup(fpath);

		shlib_list_from_rpath(rpath, get_dirname(p));

		free(p);

	}

	/* Now find all of the NEEDED shared libraries. */

	for (dynidx = 0; dynidx < numdyn; dynidx++) {

		if ((dyn = gelf_getdyn(data, dynidx, &dyn_mem)) == NULL) {

			ret = EPKG_FATAL;

			pkg_emit_error("getdyn() failed for %s: %s", fpath,

			    elf_errmsg(-1));

			goto cleanup;

		if (dyn->d_tag != DT_NEEDED)

			continue;

		shlib = elf_strptr(e, sh_link, dyn->d_un.d_val);

		add_shlibs_to_pkg(pkg, fpath, shlib, is_shlib);

	rpath_list_free();

int pkg_analyse_init_elf(const char* stage) {

	shlib_list_init();

	if (stage != NULL && pkg_object_bool(pkg_config_get("ALLOW_BASE_SHLIBS"))) {

		/* Do not check the return */

		shlib_list_from_stage(stage);

	}

	int ret = shlib_list_from_elf_hints(_PATH_ELF_HINTS);

	return ret;

int pkg_analyse_elf(const bool developer_mode, struct pkg *pkg, const char *fpath) {

		int ret = analyse_elf(pkg, fpath);

		if (developer_mode) {

			if (ret != EPKG_OK && ret != EPKG_END) {

				return EPKG_WARN;

			}

			analyse_fpath(pkg, fpath);

		return ret;

	shlib_list_free();

	int ret = pkg_jobs_run_solver(j);

/*-

 * Copyright (c) 1998 John D. Polstra

 * 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: stable/8/sbin/ldconfig/ldconfig.h 92882 2002-03-21 13:14:21Z imp $

 */

#ifndef LDCONFIG_H

#define LDCONFIG_H 1

#ifdef HAVE_CONFIG_H

#include "pkg_config.h"

#endif

#include <sys/cdefs.h>

#ifdef HAVE_ELF_HINTS_H

#include <elf-hints.h>

#else

/*

 * Hints file produced by ldconfig.

 */

struct elfhints_hdr

{

	u_int32_t magic; /* Magic number */

	u_int32_t version; /* File version (1) */

	u_int32_t strtab; /* Offset of string table in file */

	u_int32_t strsize; /* Size of string table */

	u_int32_t dirlist; /* Offset of directory list in

	 string table */

	u_int32_t dirlistlen; /* strlen(dirlist) */

	u_int32_t spare[26]; /* Room for expansion */

};

#define ELFHINTS_MAGIC  0x746e6845

# ifdef __NetBSD__

#define _PATH_ELF_HINTS "/var/run/ld.so.hints"

# else

#define _PATH_ELF_HINTS "/var/run/ld-elf.so.hints"

# endif

#endif

extern int	insecure;	/* -i flag, needed here for elfhints.c */

__BEGIN_DECLS

void		shlib_list_init(void);

void		rpath_list_init(void);

const char     *shlib_list_find_by_name(const char *);

void		shlib_list_free(void);

void		rpath_list_free(void);

int		shlib_list_from_elf_hints(const char *);

int		shlib_list_from_rpath(const char *, const char *);

void		shlib_list_from_stage(const char *);

void		list_elf_hints(const char *);

void		update_elf_hints(const char *, int, char **, int);

__END_DECLS

#endif

		'ALLOW_BASE_SHLIBS[enable base libraries analysis]:boolean:(yes no)' \

	create_from_bin \

    create_from_machobinbase \

    create_from_elfbinbase

    if [ x"${ALLOW_BASE_SHLIBS}" = xyes ]; then

        Xshlibs_required="${Xshlibs_required_base}"

    fi 

    ALLOW_BASE_SHLIBS=$1

    local PKG_NAME=$2

    local file1=$(atf_get_srcdir)/$3

    atf_check \

        -o inline:"${ALLOW_BASE_SHLIBS}\n" \

        pkg -o IGNORE_OSMAJOR=1 -o ABI_FILE=${file1} -o ALLOW_BASE_SHLIBS=${ALLOW_BASE_SHLIBS} config allow_base_shlibs

        pkg -o IGNORE_OSMAJOR=1 -o ABI_FILE=${file1} -o ALLOW_BASE_SHLIBS=${ALLOW_BASE_SHLIBS} create -M ./${PKG_NAME}.manifest -r ${TMPDIR}

        do_check no testbin $bin

create_from_machobinbase_body() {

    for bin in \

        macos.bin macos106.bin macos150.bin \

        macosfat.bin "macosfat.bin#x86_64" "macosfat.bin#aarch64" \

        macosfatlib.bin "macosfatlib.bin#x86_64" "macosfatlib.bin#aarch64" 

    do

        do_check yes machobinbase $bin

    done

}

create_from_elfbinbase_body() {

    atf_skip_on Linux Test fails on Linux

    atf_skip_on Darwin Test fails on Darwin

    # FIXME: All ELF readers are failing on non-native runs.

    for bin in \

        freebsd-aarch64.bin freebsd-amd64.bin freebsd-armv6.bin freebsd-armv7.bin \

        freebsd-i386.bin freebsd-powerpc.bin freebsd-powerpc64.bin freebsd-powerpc64le.bin \

        freebsd-riscv64.bin \

        linux.bin dfly.bin

    do

        do_check yes elfbinbase $bin

    done

}

	Xshlibs_required_base=""

			Xshlibs_required_base="libc.so.7"

			Xshlibs_required_base="libc.so.7"

			Xshlibs_required_base="libgcc_s.so.1 libc.so.7"

			Xshlibs_required_base="libgcc_s.so.1 libc.so.7"

			Xshlibs_required_base="libc.so.7"

			Xshlibs_required_base="libc.so.7"

			Xshlibs_required_base="libc.so.7"

			Xshlibs_required_base="libc.so.7"

#			Xshlibs_required_base="libc.so.7"

#			Xshlibs_required_base="libc.so.8"

#			Xshlibs_required_base="libc.so.6"

			Xshlibs_required_base="libSystem.B.dylib-1351.0"

			Xshlibs_required_base="libSystem.B.dylib-125.2.11"

			Xshlibs_required_base="libSystem.B.dylib-1351.0"

			Xshlibs_required="libAnswer.A.dylib-1.2"

			Xshlibs_required_base="libAnswer.A.dylib-1.2 libSystem.B.dylib-1319.0"

			Xshlibs_required="libAnswer.A.dylib-1.1"

			Xshlibs_required_base="libAnswer.A.dylib-1.1 libSystem.B.dylib-1319.0"

			Xshlibs_required_base="libSystem.B.dylib-1319.0"

			Xshlibs_required_base="libSystem.B.dylib-1319.0"

	ATF_REQUIRE_EQ(tll_length(p->shlibs_required), 0);

	ATF_REQUIRE_EQ(tll_length(p->shlibs_required), 1);

	ATF_REQUIRE_STREQ(tll_front(p->shlibs_required), "libfoo.so.1");