/*

 * 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 2010 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * Analyze the versioning information within a file.

 *

 *   -C		demangle C++ symbol names.

 *

 *   -d		dump version definitions.

 *

 *   -l		print reduced (local) symbols. Implies -s.

 *

 *   -n		normalize any version definitions.

 *

 *   -o		dump output in one-line fashion	(more suitable for grep'ing

 *		and diff'ing).

 *

 *   -r		dump the version requirements on library dependencies

 *

 *   -s		display the symbols associated with each version definition.

 *

 *   -v		verbose output.  With the -r and -d options any WEAK attribute

 *		is displayed.  With the -d option, any version inheritance,

 *		and the base version are displayed.  With the -r option,

 *		WEAK and INFO attributes are displayed. With the -s option

 *		the version symbol is displayed.

 *

 *   -I index	only print the specifed version index, or index range.

 *

 *   -N name	only print the specifed `name'.

 */

#include	<fcntl.h>

#include	<stdio.h>

#include	<libelf.h>

#include	<link.h>

#include	<stdlib.h>

#include	<string.h>

#include	<unistd.h>

#include	<locale.h>

#include	<errno.h>

#include	<sgs.h>

#include	<conv.h>

#include	<gelf.h>

#include	<debug.h>

#include	<ctype.h>

#include	<alist.h>

#include	"msg.h"

/*

 * Define Alist initialization sizes.

 */

#define	AL_CNT_MATCH_LIST	5	/* match_list initial alist count */

#define	AL_CNT_GVER_DESC	25	/* version tracking descriptors */

typedef struct cache {

	Elf_Scn		*c_scn;

	Elf_Data	*c_data;

	char		*c_name;

} Cache;

typedef struct gver_desc {

	const char	*vd_name;

	unsigned long	vd_hash;

	GElf_Half	vd_ndx;

	GElf_Half	vd_flags;

	APlist		*vd_deps;

} GVer_desc;

/* Versym related data used by gvers_syms() */

typedef struct {

	GElf_Versym	*vsd_vsp;   	/* ptr to versym data */

	Elf_Data	*vsd_sym_data;	/* ptr to symtab data */

	Word		vsd_symn;	/* # of symbols in symtab */

	const char	*vsd_strs;	/* string table data */

} Gver_sym_data;

/*

 * Type used to manage -I and -N options:

 *

 * The -I option specifies a VERSYM index, or index range. The

 * result is to select the VERDEF or VERNEED records with

 * indexes that match those given.

 *

 * -N options come in two forms:

 *

 *	1) name

 *	2) needobj (version)

 *

 * The meaning of the first case depends on the type of

 * version record being matched:

 *

 *	VERDEF - name is the name of a version defined

 *		by the object being processed (i.e. SUNW_1.1).

 *

 *	VERNEED - name is the name of the object file

 *		on which the dependency exists (i.e. libc.so.1).

 *

 * -N options of the second form only apply to VERNEED records.

 * They are used to specify a version from a needed object.

 */

/* match_opt_t is  used to note which match option was used */

typedef enum {

	MATCH_OPT_NAME,		/* Record contains a name */

	MATCH_OPT_NEED_VER,	/* Record contains needed object and version */

	MATCH_OPT_NDX,		/* Record contains a single index */

	MATCH_OPT_RANGE,	/* Record contains an index range */

} match_opt_t;

typedef struct {

	match_opt_t	opt_type;

	union {

		struct {

			const char *version;	/* MATCH_OPT_{NAME|NEED_VER} */

			const char *needobj;	/* MATCH_OPT_NEED_VER only */

		} name;

		struct {

			int start;		/* MATCH_OPT_{NDX|RANGE} */

			int end;		/* MATCH_OPT_RANGE only) */

		} ndx;

	} value;

} match_rec_t;

static const char	*cname;

static int		Cflag, dflag, lflag, nflag, oflag, rflag, sflag, vflag;

static Alist		*match_list;

/* Used to track whether an option defaulted to on, or was explicitly set */

#define	DEF_DEFINED	1

#define	USR_DEFINED	2

/*

 * Determine whether a symbol name should be demangled.

 */

static const char *

demangle(const char *name)

{

	if (Cflag)

		return (Elf_demangle_name(name));

	else

		return (name);

}

/*

 * Append an item to the specified list, and return a pointer to the list

 * node created.

 *

 * exit:

 *	On success, a new list node is created and the item is

 *	added to the list. On failure, a fatal error is issued

 *	and the process exits.

 */

static void

pvs_aplist_append(APlist **lst, const void *item, const char *file)

{

	if (aplist_append(lst, item, AL_CNT_GVER_DESC) == NULL) {

		int err = errno;

		(void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname, file,

		    strerror(err));

		exit(1);

	}

}

/*

 * Add an entry to match_list for use by match(). This routine is for

 * use during getopt() processing.

 *

 * entry:

 *	opt - One of 'N' or 'I', indicating the option

 *	str - Value string corresponding to opt

 *

 * exit:

 *	The new match record has been added. On error, a fatal

 *	error is issued and and the process exits.

 */

static void

add_match_record(int opt, const char *str)

{

	/*

	 * Macros for removing leading and trailing whitespace:

	 *	WS_SKIP - Advance _str without passing the NULL termination,

	 *		until the first character is not whitespace.

	 *	WS_SKIP_LIMIT - Advance _str without passing _limit,

	 *		until the first character is not whitespace.

	 *	WS_RSKIP_LIMIT - Move _tail back without passing _str,

	 *		until the character before it is not whitespace.

	 *		Write a NULL termination at that point.

	 */

#define	WS_SKIP(_str) for (; *(_str) && isspace(*(_str)); (_str)++)

#define	WS_SKIP_LIMIT(_str, _limit) \

	while (((_str) < s2) && isspace(*(_str))) \

		(_str)++

#define	WS_RSKIP_LIMIT(_str, _tail) \

	while (((_tail) > (_str)) && isspace(*((_tail) - 1)))	\

		(_tail)--;					\

	*(_tail) = '\0'

	match_rec_t	*rec;

	char		*lstr, *s1, *s2;

	rec = alist_append(&match_list, NULL, sizeof (match_rec_t),

	    AL_CNT_MATCH_LIST);

	if (rec == NULL) {

		int err = errno;

		(void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname,

		    MSG_INTL(MSG_STR_MATCH_RECORD), strerror(err));

		exit(1);

	}

	if (opt == 'N') {

		if ((lstr = strdup(str)) == NULL) {

			int err = errno;

			(void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC),

			    cname, MSG_INTL(MSG_STR_MATCH_RECORD),

			    strerror(err));

			exit(1);

		}

		/* Strip leading/trailing whitespace */

		s2 = lstr + strlen(lstr);

		WS_SKIP_LIMIT(lstr, s2);

		WS_RSKIP_LIMIT(lstr, s2);

		/* Assume this is a plain string */

		rec->opt_type = MATCH_OPT_NAME;

		rec->value.name.version = lstr;

		/*

		 * If s2 points at a closing paren, then this might

		 * be a MATCH_OPT_NEED_VER case. Otherwise we're done.

		 */

		if ((s2 == lstr) || (*(s2 - 1) != ')'))

			return;

		/* We have a closing paren. Locate the opening one. */

		for (s1 = lstr; *s1 && (*s1 != '('); s1++)

			;

		if (*s1 != '(')

			return;

		rec->opt_type = MATCH_OPT_NEED_VER;

		rec->value.name.needobj = lstr;

		rec->value.name.version = s1 + 1;

		s2--;		/* Points at closing paren */

		/* Remove whitespace from head/tail of version */

		WS_SKIP_LIMIT(rec->value.name.version, s2);

		WS_RSKIP_LIMIT(rec->value.name.version, s2);

		/* Terminate needobj, skipping trailing whitespace */

		WS_RSKIP_LIMIT(rec->value.name.needobj, s1);

		return;

	}

	/* If we get here, we are looking at a -I index option */

	rec->value.ndx.start = strtol(str, &s2, 10);

	/* Value must use some of the input, and be positive */

	if ((str == s2) || (rec->value.ndx.start < 1))

		goto syntax_error;

	str = s2;

	WS_SKIP(str);

	if (*str != ':') {

		rec->opt_type = MATCH_OPT_NDX;

	} else {

		str++;					/* Skip the ':' */

		rec->opt_type = MATCH_OPT_RANGE;

		WS_SKIP(str);

		if (*str == '\0') {

			rec->value.ndx.end = -1;	/* Indicates "to end" */

		} else {

			rec->value.ndx.end = strtol(str, &s2, 10);

			if ((str == s2) || (rec->value.ndx.end < 0))

				goto syntax_error;

			str = s2;

			WS_SKIP(str);

		}

	}

	/* If we are successful, there is nothing left to parse */

	if (*str == '\0')

		return;

	/*

	 * If we get here, there is leftover input. Fall through

	 * to issue a syntax error.

	 */

syntax_error:

	(void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF), cname);

	exit(1);

#undef	WS_SKIP

#undef	WS_SKIP_LIMIT

#undef	WS_RSKIP_LIMIT

}

/*

 * Returns True (1) if the version with the given name or index should

 * be displayed, and False (0) if it should not be.

 *

 * entry:

 *	needobj - NULL for VERDEF records, the name of the

 *		needed object for VERNEED.

 *	version - NULL, or needed version

 *	ndx - Versym index of version under consideration, or a value less

 *		than 1 to indicate that no valid index is given.

 *

 * exit:

 *	True will be returned if the given name/index matches those given

 *	by one of the -I or -N command line options, or if no such option

 *	was used in the command invocation.

 */

int

match(const char *needobj, const char *version, int ndx)

{

	Aliste		_idx;

	match_rec_t	*rec;

	const char	*str;

	/* If there is no match list, then we approve everything */

	if (alist_nitems(match_list) == 0)

		return (1);

	/* Run through the match records and check for a hit */

	for (ALIST_TRAVERSE(match_list, _idx, rec)) {

		switch (rec->opt_type) {

		case MATCH_OPT_NAME:

			if (needobj)

				str = needobj;

			else if (version)

				str = version;

			else

				break;

			if (strcmp(rec->value.name.version, str) == 0)

				return (1);

			break;

		case MATCH_OPT_NEED_VER:

			if (needobj && version &&

			    (strcmp(rec->value.name.needobj, needobj) == 0) &&

			    (strcmp(rec->value.name.version, version) == 0))

				return (1);

			break;

		case MATCH_OPT_NDX:

			if ((ndx > 0) && (ndx == rec->value.ndx.start))

				return (1);

			break;

		case MATCH_OPT_RANGE:

			/*

			 * A range end value less than 0 means that any value

			 * above the start is acceptible.

			 */

			if ((ndx > 0) &&

			    (ndx >= rec->value.ndx.start) &&

			    ((rec->value.ndx.end < 0) ||

			    (ndx <= rec->value.ndx.end)))

				return (1);

			break;

		}

	}

	/* Nothing matched */

	return (0);

}

/*

 * List the symbols that belong to a specified version

 *

 * entry:

 *	vsdata - VERSYM related data from the object

 *	vd_ndx - The VERSYM index for symbols to display

 *	vd_name - Version name

 *	needobj - NULL for symbols corresponding to a VERDEF

 *		record. Name of the needed object in the case

 *		of a VERNEED record.

 *	file - Object file

 */

static void

gvers_syms(const Gver_sym_data *vsdata, GElf_Half vd_ndx,

    const char *vd_name, const char *needobj, const char *file)

{

	GElf_Sym	sym;

	int		_symn;

	for (_symn = 0; _symn < vsdata->vsd_symn; _symn++) {

		size_t		size =	0;

		const char	*name;

		if (vsdata->vsd_vsp[_symn] != vd_ndx)

			continue;

		(void) gelf_getsym(vsdata->vsd_sym_data, _symn, &sym);

		name = demangle(vsdata->vsd_strs + sym.st_name);

		/*

		 * Symbols that reference a VERDEF record

		 * have some extra details to handle.

		 */

		if (needobj == NULL) {

			/*

			 * For data symbols defined by this object,

			 * determine the size.

			 */

			if ((GELF_ST_TYPE(sym.st_info) == STT_OBJECT) ||

			    (GELF_ST_TYPE(sym.st_info) == STT_COMMON) ||

			    (GELF_ST_TYPE(sym.st_info) == STT_TLS))

				size = (size_t)sym.st_size;

			/*

			 * Only output the version symbol when the verbose

			 * flag is used.

			 */

			if (!vflag && (sym.st_shndx == SHN_ABS) &&

			    (strcmp(name, vd_name) == 0))

				continue;

		}

		if (oflag) {

			if (needobj == NULL)

				(void) printf(MSG_ORIG(MSG_FMT_SYM_OFIL),

				    file, vd_name);

			else

				(void) printf(MSG_ORIG(MSG_FMT_SYM_NEED_OFIL),

				    file, needobj, vd_name);

			if (size)

				(void) printf(MSG_ORIG(MSG_FMT_SYM_SZ_OFLG),

				    name, (ulong_t)size);

			else

				(void) printf(MSG_ORIG(MSG_FMT_SYM_OFLG), name);

		} else {

			if (size)

				(void) printf(MSG_ORIG(MSG_FMT_SYM_SZ), name,

				    (ulong_t)size);

			else

				(void) printf(MSG_ORIG(MSG_FMT_SYM), name);

		}

	}

}

/*

 * Print any reduced symbols.  The convention is that reduced symbols exist as

 * LOCL entries in the .symtab, between the FILE symbol for the output file and

 * the first FILE symbol for any input file used to build the output file.

 */

static void

sym_local(Cache *cache, Cache *csym, const char *file)

{

	int		symn, _symn, found = 0;

	GElf_Shdr	shdr;

	GElf_Sym	sym;

	char		*strs;

	(void) gelf_getshdr(csym->c_scn, &shdr);

	strs = (char *)cache[shdr.sh_link].c_data->d_buf;

	/* LINTED */

	symn = shdr.sh_info;

	/*

	 * Verify symtab[1] is the output file symbol.

	 */

	(void) gelf_getsym(csym->c_data, 1, &sym);

	if (GELF_ST_TYPE(sym.st_info) != STT_FILE) {

		(void) fprintf(stderr, MSG_INTL(MSG_VER_UNREDSYMS), cname,

		    file);

		(void) fprintf(stderr, MSG_INTL(MSG_VER_NOTSTTFILE),

		    csym->c_name);

		return;

	}

	/*

	 * Scan the remaining symbols until the next file symbol is found.

	 */

	for (_symn = 2; _symn < symn; _symn++) {

		const char	*name;