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 (c) 1990, 2010, Oracle and/or its affiliates. All rights reserved.
24  */
25 
26 /*	Copyright (c) 1988 AT&T	*/
27 /*	  All Rights Reserved  	*/
28 
29 #include <stdlib.h>
30 #include <errno.h>
31 #include <libelf.h>
32 #include "decl.h"
33 #include "msg.h"
34 
35 
36 /*
37  * Convert archive symbol table to memory format
38  *
39  * This takes a pointer to file's archive symbol table, alignment
40  * unconstrained.  Returns null terminated vector of Elf_Arsym
41  * structures. Elf_Arsym uses size_t to represent offsets, which
42  * will be 32-bit in 32-bit versions, and 64-bits otherwise.
43  *
44  * There are two forms of archive symbol table, the original 32-bit
45  * form, and a 64-bit form originally found in IRIX64. The two formats
46  * differ only in the width of the integer word:
47  *
48  *		# offsets	4/8-byte word
49  *		offset[0...]	4/8-byte word each
50  *		strings		null-terminated, for offset[x]
51  *
52  * By default, the 64-bit form is only used when the archive exceeds
53  * the limits of 32-bits (4GB) in size. However, this is not required,
54  * and the ar -S option can be used to create a 64-bit symbol table in
55  * an archive that is under 4GB.
56  *
57  * Both 32 and 64-bit versions of libelf can read the 32-bit format
58  * without loss of information. Similarly, a 64-bit version of libelf
59  * will have no problem reading a 64-bit symbol table. This leaves the
60  * case where a 32-bit libelf reads a 64-bit symbol table, which requires
61  * some explanation. The offsets in a 64-bit symbol table will have zeros
62  * in the upper half of the words until the size of the archive exceeds 4GB.
63  * However, 32-bit libelf is unable to read any files larger than 2GB
64  * (see comments in update.c). As such, any archive that the 32-bit version
65  * of this code will encounter will be under 4GB in size. The upper 4
66  * bytes of each word will be zero, and can be safely ignored.
67  */
68 
69 
70 /*
71  * Offsets in archive headers are written in MSB (large endian) order
72  * on all platforms, regardless of native byte order. These macros read
73  * 4 and 8 byte values from unaligned memory.
74  *
75  * note:
76  * -	The get8() macro for 32-bit code can ignore the first 4 bytes of
77  *	of the word, because they are known to be 0.
78  *
79  * -	The inner most value in these macros is cast to an unsigned integer
80  *	of the final width in order to prevent the C comilier from doing
81  *	unwanted sign extension when the topmost bit of a byte is set.
82  */
83 #define	get4(p)	(((((((uint32_t)p[0]<<8)+p[1])<<8)+p[2])<<8)+p[3])
84 
85 #ifdef _LP64
86 #define	get8(p)	(((((((((((((((uint64_t)p[0]<<8)+p[1])<<8)+p[2])<<8)+	\
87     p[3])<<8)+p[4])<<8)+p[5])<<8)+p[6])<<8)+p[7])
88 #else
89 #define	get8(p)	(((((((uint64_t)p[4]<<8)+p[5])<<8)+p[6])<<8)+p[7])
90 #endif
91 
92 
93 static Elf_Void *
94 arsym(Byte *off, size_t sz, size_t *e, int is64)
95 {
96 	char		*endstr = (char *)off + sz;
97 	register char	*str;
98 	Byte		*endoff;
99 	Elf_Void	*oas;
100 	size_t		eltsize = is64 ? 8 : 4;
101 
102 	{
103 		register size_t	n;
104 
105 		if (is64) {
106 			if (sz < 8 || (sz - 8) / 8 < (n = get8(off))) {
107 				_elf_seterr(EFMT_ARSYMSZ, 0);
108 				return (NULL);
109 			}
110 		} else {
111 			if (sz < 4 || (sz - 4) / 4 < (n = get4(off))) {
112 				_elf_seterr(EFMT_ARSYMSZ, 0);
113 				return (NULL);
114 			}
115 		}
116 		off += eltsize;
117 		endoff = off + n * eltsize;
118 
119 		/*
120 		 * If there are symbols in the symbol table, a
121 		 * string table must be present and NULL terminated.
122 		 *
123 		 * The format dictates that the string table must always be
124 		 * present, however in the case of an archive containing no
125 		 * symbols GNU ar will not create one.  We are permissive for
126 		 * the sake of compatibility.
127 		 */
128 		if ((n > 0) && (((str = (char *)endoff) >= endstr) ||
129 		    (*(endstr - 1) != '\0'))) {
130 			_elf_seterr(EFMT_ARSYM, 0);
131 			return (NULL);
132 		}
133 
134 		/*
135 		 * There is always at least one entry returned if a symtab
136 		 * exists since the table's last entry is an artificial one
137 		 * with a NULL as_name, but is included in the count.
138 		 *
139 		 * overflow can occur here, but not likely
140 		 */
141 		*e = n + 1;
142 		if ((oas = calloc(n + 1, sizeof (Elf_Arsym))) == NULL) {
143 			_elf_seterr(EMEM_ARSYM, errno);
144 			return (NULL);
145 		}
146 	}
147 	{
148 		register Elf_Arsym	*as = (Elf_Arsym *)oas;
149 
150 		while (off < endoff) {
151 			if (str >= endstr) {
152 				_elf_seterr(EFMT_ARSYMSTR, 0);
153 				free(oas);
154 				return (NULL);
155 			}
156 			if (is64)
157 				as->as_off = get8(off);
158 			else
159 				as->as_off = get4(off);
160 			as->as_name = str;
161 			as->as_hash = elf_hash(str);
162 			++as;
163 			off += eltsize;
164 			while (*str++ != '\0')
165 				/* LINTED */
166 				;
167 		}
168 		as->as_name = NULL;
169 		as->as_off = 0;
170 		as->as_hash = ~(unsigned long)0L;
171 	}
172 	return (oas);
173 }
174 
175 
176 Elf_Arsym *
177 elf_getarsym(Elf *elf, size_t *ptr)
178 {
179 	Byte		*as;
180 	size_t		sz;
181 	Elf_Arsym	*rc;
182 	int		is64;
183 
184 	if (ptr != 0)
185 		*ptr = 0;
186 	if (elf == NULL)
187 		return (0);
188 	ELFRLOCK(elf);
189 	if (elf->ed_kind != ELF_K_AR) {
190 		ELFUNLOCK(elf);
191 		_elf_seterr(EREQ_AR, 0);
192 		return (0);
193 	}
194 	if ((as = (Byte *)elf->ed_arsym) == 0) {
195 		ELFUNLOCK(elf);
196 		return (0);
197 	}
198 	if (elf->ed_myflags & EDF_ASALLOC) {
199 		if (ptr != 0)
200 			*ptr = elf->ed_arsymsz;
201 		ELFUNLOCK(elf);
202 		/* LINTED */
203 		return ((Elf_Arsym *)as);
204 	}
205 	is64 = (elf->ed_myflags & EDF_ARSYM64) != 0;
206 
207 	/*
208 	 * We're gonna need a write lock.
209 	 */
210 	ELFUNLOCK(elf)
211 	ELFWLOCK(elf)
212 	sz = elf->ed_arsymsz;
213 	if (_elf_vm(elf, (size_t)(as - (Byte *)elf->ed_ident), sz) !=
214 	    OK_YES) {
215 		ELFUNLOCK(elf);
216 		return (0);
217 	}
218 	if ((elf->ed_arsym = arsym(as, sz, &elf->ed_arsymsz, is64)) == 0) {
219 		ELFUNLOCK(elf);
220 		return (0);
221 	}
222 	elf->ed_myflags |= EDF_ASALLOC;
223 	if (ptr != 0)
224 		*ptr = elf->ed_arsymsz;
225 	rc = (Elf_Arsym *)elf->ed_arsym;
226 	ELFUNLOCK(elf);
227 	return (rc);
228 }
229 
230 /*
231  * Private function to obtain the value sizeof() would return
232  * for a word from the symbol table from the given archive. Normally,
233  * this is an unimportant implementation detail hidden within
234  * elf_getarsym(). However, it is useful to elfdump for formatting the
235  * output correctly, and for the file command.
236  *
237  * exit:
238  *	Returns 4 (32-bit) or 8 (64-bit) if a symbol table is present.
239  *	Returns 0 in all other cases.
240  */
241 size_t
242 _elf_getarsymwordsize(Elf *elf)
243 {
244 	size_t	size;
245 
246 	if (elf == NULL)
247 		return (0);
248 
249 	ELFRLOCK(elf);
250 	if ((elf->ed_kind == ELF_K_AR) && (elf->ed_arsym != 0))
251 		size = (elf->ed_myflags & EDF_ARSYM64) ? 8 : 4;
252 	else
253 		size = 0;
254 	ELFUNLOCK(elf);
255 
256 	return (size);
257 }
258