1 /*
2  * CDDL HEADER START
3  *
4  * The contents of this file are subject to the terms of the
5  * Common Development and Distribution License (the "License").
6  * You may not use this file except in compliance with the License.
7  *
8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
9  * or http://www.opensolaris.org/os/licensing.
10  * See the License for the specific language governing permissions
11  * and limitations under the License.
12  *
13  * When distributing Covered Code, include this CDDL HEADER in each
14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
15  * If applicable, add the following below this CDDL HEADER, with the
16  * fields enclosed by brackets "[]" replaced with your own identifying
17  * information: Portions Copyright [yyyy] [name of copyright owner]
18  *
19  * CDDL HEADER END
20  */
21 
22 /*
23  * Copyright 2010 Sun Microsystems, Inc.  All rights reserved.
24  * Use is subject to license terms.
25  */
26 
27 #include	<stdlib.h>
28 #include	<stdio.h>
29 #include	<_elfedit.h>
30 #include	<conv.h>
31 #include	<msg.h>
32 
33 
34 
35 /*
36  * This file contains support for mapping well known ELF constants
37  * to their numeric values. It is a layer on top of the elfedit_atoui()
38  * routines defined in util.c. The idea is that centralizing all the
39  * support for such constants will improve consistency between modules,
40  * allow for sharing of commonly needed items, and make the modules
41  * simpler.
42  */
43 
44 
45 
46 
47 /*
48  * elfedit output style, with and without leading -o
49  */
50 static elfedit_atoui_sym_t sym_outstyle[] = {
51 	{ MSG_ORIG(MSG_STR_DEFAULT),		ELFEDIT_OUTSTYLE_DEFAULT },
52 	{ MSG_ORIG(MSG_STR_SIMPLE),		ELFEDIT_OUTSTYLE_SIMPLE },
53 	{ MSG_ORIG(MSG_STR_NUM),		ELFEDIT_OUTSTYLE_NUM },
54 	{ NULL }
55 };
56 static elfedit_atoui_sym_t sym_minus_o_outstyle[] = {
57 	{ MSG_ORIG(MSG_STR_MINUS_O_DEFAULT),	ELFEDIT_OUTSTYLE_DEFAULT },
58 	{ MSG_ORIG(MSG_STR_MINUS_O_SIMPLE),	ELFEDIT_OUTSTYLE_SIMPLE },
59 	{ MSG_ORIG(MSG_STR_MINUS_O_NUM),	ELFEDIT_OUTSTYLE_NUM },
60 	{ NULL }
61 };
62 
63 
64 /*
65  * Booleans
66  */
67 static elfedit_atoui_sym_t sym_bool[] = {
68 	{ MSG_ORIG(MSG_STR_T),			1 },
69 	{ MSG_ORIG(MSG_STR_F),			0 },
70 	{ MSG_ORIG(MSG_STR_TRUE),		1 },
71 	{ MSG_ORIG(MSG_STR_FALSE),		0 },
72 	{ MSG_ORIG(MSG_STR_ON),			1 },
73 	{ MSG_ORIG(MSG_STR_OFF),		0 },
74 	{ MSG_ORIG(MSG_STR_YES),		1 },
75 	{ MSG_ORIG(MSG_STR_NO),			0 },
76 	{ MSG_ORIG(MSG_STR_Y),			1 },
77 	{ MSG_ORIG(MSG_STR_N),			0 },
78 	{ NULL }
79 };
80 
81 /*
82  * ELF strings for SHT_STRTAB
83  */
84 static elfedit_atoui_sym_t sym_sht_strtab[] = {
85 	{ MSG_ORIG(MSG_SHT_STRTAB),		SHT_STRTAB },
86 	{ MSG_ORIG(MSG_SHT_STRTAB_ALT1),	SHT_STRTAB },
87 
88 	{ NULL }
89 };
90 
91 
92 /*
93  * Strings for SHT_SYMTAB
94  */
95 static elfedit_atoui_sym_t sym_sht_symtab[] = {
96 	{ MSG_ORIG(MSG_SHT_SYMTAB),		SHT_SYMTAB },
97 	{ MSG_ORIG(MSG_SHT_SYMTAB_ALT1),	SHT_SYMTAB },
98 
99 	{ NULL }
100 };
101 
102 /*
103  * Strings for SHT_DYNSYM
104  */
105 static elfedit_atoui_sym_t sym_sht_dynsym[] = {
106 	{ MSG_ORIG(MSG_SHT_DYNSYM),		SHT_DYNSYM },
107 	{ MSG_ORIG(MSG_SHT_DYNSYM_ALT1),	SHT_DYNSYM },
108 
109 	{ NULL }
110 };
111 
112 /*
113  * Strings for SHT_SUNW_LDYNSYM
114  */
115 static elfedit_atoui_sym_t sym_sht_ldynsym[] = {
116 	{ MSG_ORIG(MSG_SHT_SUNW_LDYNSYM),	SHT_SUNW_LDYNSYM },
117 	{ MSG_ORIG(MSG_SHT_SUNW_LDYNSYM_ALT1),	SHT_SUNW_LDYNSYM },
118 
119 	{ NULL }
120 };
121 
122 
123 
124 /*
125  * Types of items found in sym_table[]. All items other than STE_STATIC
126  * pulls strings from libconv, differing in the interface required by
127  * the libconv iteration function used.
128  */
129 typedef enum {
130 	STE_STATIC =		0,	/* Constants are statically defined */
131 	STE_LC =		1,	/* Libconv, pull once */
132 	STE_LC_OS =		2,	/* From libconv, osabi dependency */
133 	STE_LC_MACH =		3,	/* From libconv, mach dependency */
134 	STE_LC_OS_MACH =	4	/* From libconv, osabi/mach dep. */
135 } ste_type_t;
136 
137 /*
138  * Interface of functions called to fill strings from libconv
139  */
140 typedef conv_iter_ret_t	(* libconv_iter_func_simple_t)(
141 			    Conv_fmt_flags_t, conv_iter_cb_t, void *);
142 typedef conv_iter_ret_t	(* libconv_iter_func_os_t)(conv_iter_osabi_t,
143 			    Conv_fmt_flags_t, conv_iter_cb_t, void *);
144 typedef conv_iter_ret_t	(* libconv_iter_func_mach_t)(Half,
145 			    Conv_fmt_flags_t, conv_iter_cb_t, void *);
146 typedef conv_iter_ret_t	(* libconv_iter_func_os_mach_t)(conv_iter_osabi_t, Half,
147 			    Conv_fmt_flags_t, conv_iter_cb_t, void *);
148 typedef union {
149 	libconv_iter_func_simple_t	simple;
150 	libconv_iter_func_os_t		osabi;
151 	libconv_iter_func_mach_t	mach;
152 	libconv_iter_func_os_mach_t	osabi_mach;
153 } libconv_iter_func_t;
154 
155 /*
156  * State for each type of constant
157  */
158 typedef struct {
159 	ste_type_t		ste_type;	/* Type of entry */
160 	elfedit_atoui_sym_t	*ste_arr;	/* NULL, or atoui array */
161 	void			*ste_alloc;	/* Current memory allocation */
162 	size_t			ste_nelts;	/* # items in ste_alloc */
163 	libconv_iter_func_t	ste_conv_func;	/* libconv fill function */
164 } sym_table_ent_t;
165 
166 
167 /*
168  * Array of state for each constant type, including the array of atoui
169  * pointers, for each constant type, indexed by elfedit_const_t value.
170  * The number and order of entries in this table must agree with the
171  * definition of elfedit_const_t in elfedit.h.
172  *
173  * note:
174  * -	STE_STATIC items must supply a statically allocated buffer here.
175  * -	The non-STE_STATIC items use libconv strings. These items are
176  *	initialized by init_libconv_strings() at runtime, and are represented
177  *	by a simple { 0 } here. The memory used for these arrays is dynamic,
178  *	and can be released and rebuilt at runtime as necessary to keep up
179  *	with changes in osabi or machine type.
180  */
181 static sym_table_ent_t sym_table[ELFEDIT_CONST_NUM] = {
182 						/* #: ELFEDIT_CONST_xxx */
183 	{ STE_STATIC, sym_outstyle },		/* 0: OUTSTYLE */
184 	{ STE_STATIC, sym_minus_o_outstyle },	/* 1: OUTSTYLE_MO */
185 	{ STE_STATIC, sym_bool },		/* 2: BOOL */
186 	{ STE_STATIC, sym_sht_strtab },		/* 3: SHT_STRTAB */
187 	{ STE_STATIC, sym_sht_symtab },		/* 4: SHT_SYMTAB */
188 	{ STE_STATIC, sym_sht_dynsym },		/* 5: SHT_DYNSYM */
189 	{ STE_STATIC, sym_sht_ldynsym },	/* 6: SHT_LDYNSYM */
190 	{ 0 },					/* 7: SHN */
191 	{ 0 },					/* 8: SHT */
192 	{ 0 },					/* 9: SHT_ALLSYMTAB */
193 	{ 0 },					/* 10: DT */
194 	{ 0 },					/* 11: DF */
195 	{ 0 },					/* 12: DF_P1 */
196 	{ 0 },					/* 13: DF_1 */
197 	{ 0 },					/* 14: DTF_1 */
198 	{ 0 },					/* 15: EI */
199 	{ 0 },					/* 16: ET */
200 	{ 0 },					/* 17: ELFCLASS */
201 	{ 0 },					/* 18: ELFDATA */
202 	{ 0 },					/* 19: EF */
203 	{ 0 },					/* 20: EV */
204 	{ 0 },					/* 21: EM */
205 	{ 0 },					/* 22: ELFOSABI */
206 	{ 0 },					/* 23: EAV osabi version */
207 	{ 0 },					/* 24: PT */
208 	{ 0 },					/* 25: PF */
209 	{ 0 },					/* 26: SHF */
210 	{ 0 },					/* 27: STB */
211 	{ 0 },					/* 28: STT */
212 	{ 0 },					/* 29: STV */
213 	{ 0 },					/* 30: SYMINFO_BT */
214 	{ 0 },					/* 31: SYMINFO_FLG */
215 	{ 0 },					/* 32: CA */
216 	{ 0 },					/* 33: AV */
217 	{ 0 },					/* 34: SF1_SUNW */
218 };
219 #if ELFEDIT_CONST_NUM != (ELFEDIT_CONST_SF1_SUNW)
220 error "ELFEDIT_CONST_NUM has grown. Update sym_table[]"
221 #endif
222 
223 
224 
225 
226 /*
227  * Used to count the number of descriptors that will be needed to hold
228  * strings from libconv.
229  */
230 /*ARGSUSED*/
231 static conv_iter_ret_t
232 libconv_count_cb(const char *str, Conv_elfvalue_t value, void *uvalue)
233 {
234 	size_t *cnt = (size_t *)uvalue;
235 
236 	(*cnt)++;
237 	return (CONV_ITER_CONT);
238 }
239 
240 /*
241  * Used to fill in the descriptors with strings from libconv.
242  */
243 typedef struct {
244 	size_t			cur;	/* Index of next descriptor */
245 	size_t			cnt;	/* # of descriptors */
246 	elfedit_atoui_sym_t	*desc;	/* descriptors */
247 } libconv_fill_state_t;
248 
249 static conv_iter_ret_t
libconv_fill_cb(const char * str,Conv_elfvalue_t value,void * uvalue)250 libconv_fill_cb(const char *str, Conv_elfvalue_t value, void *uvalue)
251 {
252 	libconv_fill_state_t	*fill_state = (libconv_fill_state_t *)uvalue;
253 	elfedit_atoui_sym_t	*sym = &fill_state->desc[fill_state->cur++];
254 
255 	sym->sym_name = str;
256 	sym->sym_value = value;
257 	return (CONV_ITER_CONT);
258 }
259 
260 
261 /*
262  * Call the iteration function using the correct calling sequence for
263  * the libconv routine.
264  */
265 static void
libconv_fill_iter(sym_table_ent_t * sym,conv_iter_osabi_t osabi,Half mach,conv_iter_cb_t func,void * uvalue)266 libconv_fill_iter(sym_table_ent_t *sym, conv_iter_osabi_t osabi, Half mach,
267     conv_iter_cb_t func, void *uvalue)
268 {
269 	switch (sym->ste_type) {
270 	case STE_LC:
271 		(void) (* sym->ste_conv_func.simple)(
272 		    CONV_FMT_ALT_CF, func, uvalue);
273 		(void) (* sym->ste_conv_func.simple)(
274 		    CONV_FMT_ALT_NF, func, uvalue);
275 		break;
276 
277 	case STE_LC_OS:
278 		(void) (* sym->ste_conv_func.osabi)(osabi,
279 		    CONV_FMT_ALT_CF, func, uvalue);
280 		(void) (* sym->ste_conv_func.osabi)(osabi,
281 		    CONV_FMT_ALT_NF, func, uvalue);
282 		break;
283 
284 	case STE_LC_MACH:
285 		(void) (* sym->ste_conv_func.mach)(mach,
286 		    CONV_FMT_ALT_CF, func, uvalue);
287 		(void) (* sym->ste_conv_func.mach)(mach,
288 		    CONV_FMT_ALT_NF, func, uvalue);
289 		break;
290 
291 	case STE_LC_OS_MACH:
292 		(void) (* sym->ste_conv_func.osabi_mach)(osabi, mach,
293 		    CONV_FMT_ALT_CF, func, uvalue);
294 		(void) (* sym->ste_conv_func.osabi_mach)(osabi, mach,
295 		    CONV_FMT_ALT_NF, func, uvalue);
296 		break;
297 	}
298 }
299 
300 /*
301  * Allocate/Fill an atoui array for the specified constant.
302  */
303 static void
libconv_fill(sym_table_ent_t * sym,conv_iter_osabi_t osabi,Half mach)304 libconv_fill(sym_table_ent_t *sym, conv_iter_osabi_t osabi, Half mach)
305 {
306 	libconv_fill_state_t	fill_state;
307 
308 	/* How many descriptors will we need? */
309 	fill_state.cnt = 1;		/* Extra for NULL termination */
310 	libconv_fill_iter(sym, osabi, mach, libconv_count_cb, &fill_state.cnt);
311 
312 	/*
313 	 * If there is an existing allocation, and it is not large enough,
314 	 * release it.
315 	 */
316 	if ((sym->ste_alloc != NULL) && (fill_state.cnt > sym->ste_nelts)) {
317 		free(sym->ste_alloc);
318 		sym->ste_alloc = NULL;
319 		sym->ste_nelts = 0;
320 	}
321 
322 	/* Allocate memory if don't already have an allocation */
323 	if (sym->ste_alloc == NULL) {
324 		sym->ste_alloc = elfedit_malloc(MSG_INTL(MSG_ALLOC_ELFCONDESC),
325 		    fill_state.cnt * sizeof (*fill_state.desc));
326 		sym->ste_nelts = fill_state.cnt;
327 	}
328 
329 	/* Fill the array */
330 	fill_state.desc = sym->ste_alloc;
331 	fill_state.cur = 0;
332 	libconv_fill_iter(sym, osabi, mach, libconv_fill_cb, &fill_state);
333 
334 	/* Add null termination */
335 	fill_state.desc[fill_state.cur].sym_name = NULL;
336 	fill_state.desc[fill_state.cur].sym_value = 0;
337 
338 	/* atoui array for this item is now available */
339 	sym->ste_arr = fill_state.desc;
340 }
341 
342 /*
343  * Should be called on first call to elfedit_const_to_atoui(). Does the
344  * runtime initialization of sym_table.
345  */
346 static void
init_libconv_strings(conv_iter_osabi_t * osabi,Half * mach)347 init_libconv_strings(conv_iter_osabi_t *osabi, Half *mach)
348 {
349 	/*
350 	 * It is critical that the ste_type and ste_conv_func values
351 	 * agree. Since the libconv iteration function signatures can
352 	 * change (gain or lose an osabi or mach argument), we want to
353 	 * ensure that the compiler will catch such changes.
354 	 *
355 	 * The compiler will catch an attempt to assign a function of
356 	 * the wrong type to ste_conv_func. Using these macros, we ensure
357 	 * that the ste_type and function assignment happen as a unit.
358 	 */
359 #define	LC(_ndx, _func) sym_table[_ndx].ste_type = STE_LC; \
360 	sym_table[_ndx].ste_conv_func.simple = _func;
361 #define	LC_OS(_ndx, _func) sym_table[_ndx].ste_type = STE_LC_OS; \
362 	sym_table[_ndx].ste_conv_func.osabi = _func;
363 #define	LC_MACH(_ndx, _func) sym_table[_ndx].ste_type = STE_LC_MACH; \
364 	sym_table[_ndx].ste_conv_func.mach = _func;
365 #define	LC_OS_MACH(_ndx, _func) sym_table[_ndx].ste_type = STE_LC_OS_MACH; \
366 	sym_table[_ndx].ste_conv_func.osabi_mach = _func;
367 
368 
369 	if (!state.file.present) {
370 		/*
371 		 * No input file: Supply the maximal set of strings for
372 		 * all osabi and mach values understood by libconv.
373 		 */
374 		*osabi = CONV_OSABI_ALL;
375 		*mach = CONV_MACH_ALL;
376 	} else if (state.elf.elfclass == ELFCLASS32) {
377 		*osabi = state.elf.obj_state.s32->os_ehdr->e_ident[EI_OSABI];
378 		*mach = state.elf.obj_state.s32->os_ehdr->e_machine;
379 	} else {
380 		*osabi = state.elf.obj_state.s64->os_ehdr->e_ident[EI_OSABI];
381 		*mach = state.elf.obj_state.s64->os_ehdr->e_machine;
382 	}
383 
384 	/* Set up non- STE_STATIC libconv fill functions */
385 	LC_OS_MACH(ELFEDIT_CONST_SHN,		conv_iter_sym_shndx);
386 	LC_OS_MACH(ELFEDIT_CONST_SHT,		conv_iter_sec_type);
387 	LC_OS(ELFEDIT_CONST_SHT_ALLSYMTAB,	conv_iter_sec_symtab);
388 	LC_OS_MACH(ELFEDIT_CONST_DT,		conv_iter_dyn_tag);
389 	LC(ELFEDIT_CONST_DF,			conv_iter_dyn_flag);
390 	LC(ELFEDIT_CONST_DF_P1,			conv_iter_dyn_posflag1);
391 	LC(ELFEDIT_CONST_DF_1,			conv_iter_dyn_flag1);
392 	LC(ELFEDIT_CONST_DTF_1,			conv_iter_dyn_feature1);
393 	LC(ELFEDIT_CONST_EI,			conv_iter_ehdr_eident);
394 	LC_OS(ELFEDIT_CONST_ET,			conv_iter_ehdr_type);
395 	LC(ELFEDIT_CONST_ELFCLASS,		conv_iter_ehdr_class);
396 	LC(ELFEDIT_CONST_ELFDATA,		conv_iter_ehdr_data);
397 	LC_MACH(ELFEDIT_CONST_EF,		conv_iter_ehdr_flags);
398 	LC(ELFEDIT_CONST_EV,			conv_iter_ehdr_vers);
399 	LC(ELFEDIT_CONST_EM,			conv_iter_ehdr_mach);
400 	LC(ELFEDIT_CONST_ELFOSABI,		conv_iter_ehdr_osabi);
401 	LC_OS(ELFEDIT_CONST_EAV,		conv_iter_ehdr_abivers);
402 	LC_OS(ELFEDIT_CONST_PT,			conv_iter_phdr_type);
403 	LC_OS(ELFEDIT_CONST_PF,			conv_iter_phdr_flags);
404 	LC_OS_MACH(ELFEDIT_CONST_SHF,		conv_iter_sec_flags);
405 	LC(ELFEDIT_CONST_STB,			conv_iter_sym_info_bind);
406 	LC_MACH(ELFEDIT_CONST_STT,		conv_iter_sym_info_type);
407 	LC(ELFEDIT_CONST_STV,			conv_iter_sym_other_vis);
408 	LC(ELFEDIT_CONST_SYMINFO_BT,		conv_iter_syminfo_boundto);
409 	LC(ELFEDIT_CONST_SYMINFO_FLG,		conv_iter_syminfo_flags);
410 	LC(ELFEDIT_CONST_CA,			conv_iter_cap_tags);
411 	LC_MACH(ELFEDIT_CONST_HW1_SUNW,		conv_iter_cap_val_hw1);
412 	LC(ELFEDIT_CONST_SF1_SUNW,		conv_iter_cap_val_sf1);
413 	LC_MACH(ELFEDIT_CONST_HW2_SUNW,		conv_iter_cap_val_hw2);
414 
415 #undef LC
416 #undef LC_OS
417 #undef LC_MACH
418 #undef LC_OS_MACH
419 }
420 
421 /*
422  * If the user has changed the osabi or machine type of the object,
423  * then we need to discard the strings we've loaded from libconv
424  * that are dependent on these values.
425  */
426 static void
invalidate_libconv_strings(conv_iter_osabi_t * osabi,Half * mach)427 invalidate_libconv_strings(conv_iter_osabi_t *osabi, Half *mach)
428 {
429 	uchar_t		cur_osabi;
430 	Half		cur_mach;
431 	sym_table_ent_t	*sym;
432 	int		osabi_change, mach_change;
433 	int		i;
434 
435 
436 	/* Reset the ELF header change notification */
437 	state.elf.elfconst_ehdr_change = 0;
438 
439 	if (state.elf.elfclass == ELFCLASS32) {
440 		cur_osabi = state.elf.obj_state.s32->os_ehdr->e_ident[EI_OSABI];
441 		cur_mach = state.elf.obj_state.s32->os_ehdr->e_machine;
442 	} else {
443 		cur_osabi = state.elf.obj_state.s64->os_ehdr->e_ident[EI_OSABI];
444 		cur_mach = state.elf.obj_state.s64->os_ehdr->e_machine;
445 	}
446 
447 	/* What has changed? */
448 	mach_change = *mach != cur_mach;
449 	osabi_change = *osabi != cur_osabi;
450 	if (!(mach_change || osabi_change))
451 		return;
452 
453 	/*
454 	 * Set the ste_arr pointer to NULL for any items that
455 	 * depend on the things that have changed. Note that we
456 	 * do not release the allocated memory --- it may turn
457 	 * out to be large enough to hold the new strings, so we
458 	 * keep the allocation and leave that decision to the fill
459 	 * routine, which will run the next time those strings are
460 	 * needed.
461 	 */
462 	for (i = 0, sym = sym_table;
463 	    i < (sizeof (sym_table) / sizeof (sym_table[0])); i++, sym++) {
464 		if (sym->ste_arr == NULL)
465 			continue;
466 
467 		switch (sym->ste_type) {
468 		case STE_LC_OS:
469 			if (osabi_change)
470 				sym->ste_arr = NULL;
471 			break;
472 
473 		case STE_LC_MACH:
474 			if (mach_change)
475 				sym->ste_arr = NULL;
476 			break;
477 
478 		case STE_LC_OS_MACH:
479 			if (osabi_change || mach_change)
480 				sym->ste_arr = NULL;
481 			break;
482 		}
483 	}
484 
485 	*mach = cur_mach;
486 	*osabi = cur_osabi;
487 }
488 
489 
490 
491 /*
492  * Given an elfedit_const_t value, return the array of elfedit_atoui_sym_t
493  * entries that it represents.
494  */
495 elfedit_atoui_sym_t *
elfedit_const_to_atoui(elfedit_const_t const_type)496 elfedit_const_to_atoui(elfedit_const_t const_type)
497 {
498 	static int			first = 1;
499 	static conv_iter_osabi_t	osabi;
500 	static Half			mach;
501 
502 	sym_table_ent_t	*sym;
503 
504 	if (first) {
505 		init_libconv_strings(&osabi, &mach);
506 		first = 0;
507 	}
508 
509 	if ((const_type < 0) ||
510 	    (const_type >= (sizeof (sym_table) / sizeof (sym_table[0]))))
511 		elfedit_msg(ELFEDIT_MSG_ERR, MSG_INTL(MSG_ERR_BADCONST));
512 	sym = &sym_table[const_type];
513 
514 	/*
515 	 * If the constant is not STE_STATIC, then we may need to fetch
516 	 * the strings from libconv.
517 	 */
518 	if (sym->ste_type != STE_STATIC) {
519 		/*
520 		 * If the ELF header has changed since the last
521 		 * time we were called, then we need to invalidate any
522 		 * strings previously pulled from libconv that have
523 		 * an osabi or machine dependency.
524 		 */
525 		if (state.elf.elfconst_ehdr_change)
526 			invalidate_libconv_strings(&osabi, &mach);
527 
528 		/* If we don't already have the strings, get them */
529 		if (sym->ste_arr == NULL)
530 			libconv_fill(sym, osabi, mach);
531 	}
532 
533 	return (sym->ste_arr);
534 }
535