/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */

/*
 * Copyright 2006 Sun Microsystems, Inc.  All rights reserved.
 * Use is subject to license terms.
 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

#include	<stdio.h>
#include	<dlfcn.h>
#include	<libelf.h>
#include	<link.h>
#include	<debug.h>
#include	"msg.h"
#include	"_libld.h"

/*
 * Table which defines the default functions to be called by the library
 * SUPPORT (-S <libname>).  These functions can be redefined by the
 * ld_support_loadso() routine.
 */
static Support_list support[LDS_NUM] = {
	{MSG_ORIG(MSG_SUP_VERSION),	{ 0, 0 }},	/* LDS_VERSION */
	{MSG_ORIG(MSG_SUP_INPUT_DONE),	{ 0, 0 }},	/* LDS_INPUT_DONE */
#if	defined(_ELF64)
	{MSG_ORIG(MSG_SUP_START_64),	{ 0, 0 }},	/* LDS_START64 */
	{MSG_ORIG(MSG_SUP_ATEXIT_64),	{ 0, 0 }},	/* LDS_ATEXIT64 */
	{MSG_ORIG(MSG_SUP_FILE_64),	{ 0, 0 }},	/* LDS_FILE64 */
	{MSG_ORIG(MSG_SUP_INP_SECTION_64), { 0, 0 }},	/* LDS_INP_SECTION64 */
	{MSG_ORIG(MSG_SUP_SECTION_64),	{ 0, 0 }}	/* LDS_SECTION64 */
#else	/* Elf32 */
	{MSG_ORIG(MSG_SUP_START),	{ 0, 0 }},	/* LDS_START */
	{MSG_ORIG(MSG_SUP_ATEXIT),	{ 0, 0 }},	/* LDS_ATEXIT */
	{MSG_ORIG(MSG_SUP_FILE),	{ 0, 0 }},	/* LDS_FILE */
	{MSG_ORIG(MSG_SUP_INP_SECTION),	{ 0, 0 }},	/* LDS_INP_SECTION */
	{MSG_ORIG(MSG_SUP_SECTION),	{ 0, 0 }}	/* LDS_SECTION */
#endif
};

/*
 * Loads in a support shared object specified using the SGS_SUPPORT environment
 * variable or the -S ld option, and determines which interface functions are
 * provided by that object.
 */
uintptr_t
ld_sup_loadso(Ofl_desc *ofl, const char *obj)
{
	void		*handle;
	void		(*fptr)();
	Func_list	*flp;
	int 		i;
	uint_t		ver_level;

	/*
	 * Load the required support library.  If we are unable to load it fail
	 * with a fatal error.
	 */
	if ((handle = dlopen(obj, RTLD_LAZY)) == NULL) {
		eprintf(ofl->ofl_lml, ERR_FATAL, MSG_INTL(MSG_SUP_NOLOAD),
		    obj, dlerror());
		return (S_ERROR);
	}

	ver_level = LD_SUP_VERSION1;
	for (i = 0; i < LDS_NUM; i++) {
		if (fptr = (void (*)())dlsym(handle, support[i].sup_name)) {

			if ((flp = libld_malloc(sizeof (Func_list))) == NULL)
				return (S_ERROR);

			flp->fl_obj = obj;
			flp->fl_fptr = fptr;
			DBG_CALL(Dbg_support_load(ofl->ofl_lml, obj,
			    support[i].sup_name));

			if (i == LDS_VERSION) {
				DBG_CALL(Dbg_support_action(ofl->ofl_lml,
				    flp->fl_obj, support[LDS_VERSION].sup_name,
				    LDS_VERSION, 0));
				ver_level = ((uint_t(*)())
				    flp->fl_fptr)(LD_SUP_VCURRENT);
				if ((ver_level == LD_SUP_VNONE) ||
				    (ver_level > LD_SUP_VCURRENT)) {
					eprintf(ofl->ofl_lml, ERR_FATAL,
					    MSG_INTL(MSG_SUP_BADVERSION),
					    LD_SUP_VCURRENT, ver_level);
					(void) dlclose(handle);
					return (S_ERROR);
				}

			}
			flp->fl_version = ver_level;
			if (list_appendc(&support[i].sup_funcs, flp) == 0)
				return (S_ERROR);
		}
	}
	return (1);
}

/*
 * Wrapper routines for the ld support library calls.
 */
void
ld_sup_start(Ofl_desc *ofl, const Half etype, const char *caller)
{
	Func_list	*flp;
	Listnode	*lnp;

	for (LIST_TRAVERSE(&support[LDS_START].sup_funcs, lnp, flp)) {
		DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
		    support[LDS_START].sup_name, LDS_START, ofl->ofl_name));
		(*flp->fl_fptr)(ofl->ofl_name, etype, caller);
	}
}

void
ld_sup_atexit(Ofl_desc *ofl, int ecode)
{
	Func_list	*flp;
	Listnode	*lnp;

	for (LIST_TRAVERSE(&support[LDS_ATEXIT].sup_funcs, lnp, flp)) {
		DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
		    support[LDS_ATEXIT].sup_name, LDS_ATEXIT, 0));
		(*flp->fl_fptr)(ecode);
	}
}

void
ld_sup_file(Ofl_desc *ofl, const char *ifile, const Elf_Kind ekind, int flags,
    Elf *elf)
{
	Func_list	*flp;
	Listnode	*lnp;

	for (LIST_TRAVERSE(&support[LDS_FILE].sup_funcs, lnp, flp)) {
		int	_flags = 0;

		if (!(flags & FLG_IF_CMDLINE))
			_flags |= LD_SUP_DERIVED;
		if (!(flags & FLG_IF_NEEDED))
			_flags |= LD_SUP_INHERITED;
		if (flags & FLG_IF_EXTRACT)
			_flags |= LD_SUP_EXTRACTED;

		DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
		    support[LDS_FILE].sup_name, LDS_FILE, ifile));
		(*flp->fl_fptr)(ifile, ekind, _flags, elf);
	}
}

uintptr_t
ld_sup_input_section(Ofl_desc * ofl, const char *scnname, Shdr **shdr, Word ndx,
    const char *file, Elf_Scn *scn, Elf *elf)
{
	Func_list	*flp;
	Listnode	*lnp;
	uint_t		flags = 0;
	Elf_Data	*data = NULL;

	for (LIST_TRAVERSE(&support[LDS_INP_SECTION].sup_funcs, lnp, flp)) {
		/*
		 * This interface was introduced in VERSION2 - so only call it
		 * for libraries reporting support for * version 2 or above.
		 */
		if (flp->fl_version < LD_SUP_VERSION2)
			continue;
		if ((data == NULL) &&
		    ((data = elf_getdata(scn, NULL)) == NULL)) {
			eprintf(ofl->ofl_lml, ERR_ELF,
			    MSG_INTL(MSG_ELF_GETDATA), file);
			ofl->ofl_flags |= FLG_OF_FATAL;
			return (S_ERROR);
		}

		DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
		    support[LDS_INP_SECTION].sup_name, LDS_INP_SECTION,
		    scnname));
		(*flp->fl_fptr)(scnname, shdr, ndx, data, elf, &flags);
	}
	return (0);
}

void
ld_sup_section(Ofl_desc *ofl, const char *scn, Shdr *shdr, Word ndx,
    Elf_Data *data, Elf *elf)
{
	Func_list	*flp;
	Listnode	*lnp;

	for (LIST_TRAVERSE(&support[LDS_SECTION].sup_funcs, lnp, flp)) {
		DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
		    support[LDS_SECTION].sup_name, LDS_SECTION, scn));
		(*flp->fl_fptr)(scn, shdr, ndx, data, elf);
	}
}

void
ld_sup_input_done(Ofl_desc *ofl)
{
	Func_list	*flp;
	Listnode	*lnp;
	uint_t		flags = 0;

	for (LIST_TRAVERSE(&support[LDS_INPUT_DONE].sup_funcs, lnp, flp)) {
		/*
		 * This interface was introduced in VERSION2 - so only call it
		 * for libraries reporting support for version 2 or above.
		 */
		if (flp->fl_version < LD_SUP_VERSION2)
			continue;
		DBG_CALL(Dbg_support_action(ofl->ofl_lml, flp->fl_obj,
		    support[LDS_INPUT_DONE].sup_name, LDS_INPUT_DONE, 0));
		(*flp->fl_fptr)(&flags);
	}
}