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 /*
28 * Analyze the versioning information within a file.
29 *
30 * -C demangle C++ symbol names.
31 *
32 * -d dump version definitions.
33 *
34 * -l print reduced (local) symbols. Implies -s.
35 *
36 * -n normalize any version definitions.
37 *
38 * -o dump output in one-line fashion (more suitable for grep'ing
39 * and diff'ing).
40 *
41 * -r dump the version requirements on library dependencies
42 *
43 * -s display the symbols associated with each version definition.
44 *
45 * -v verbose output. With the -r and -d options any WEAK attribute
46 * is displayed. With the -d option, any version inheritance,
47 * and the base version are displayed. With the -r option,
48 * WEAK and INFO attributes are displayed. With the -s option
49 * the version symbol is displayed.
50 *
51 * -I index only print the specifed version index, or index range.
52 *
53 * -N name only print the specifed `name'.
54 */
55 #include <fcntl.h>
56 #include <stdio.h>
57 #include <libelf.h>
58 #include <link.h>
59 #include <stdlib.h>
60 #include <string.h>
61 #include <unistd.h>
62 #include <locale.h>
63 #include <errno.h>
64 #include <sgs.h>
65 #include <conv.h>
66 #include <gelf.h>
67 #include <debug.h>
68 #include <ctype.h>
69 #include <alist.h>
70 #include "msg.h"
71
72 /*
73 * Define Alist initialization sizes.
74 */
75 #define AL_CNT_MATCH_LIST 5 /* match_list initial alist count */
76 #define AL_CNT_GVER_DESC 25 /* version tracking descriptors */
77
78 typedef struct cache {
79 Elf_Scn *c_scn;
80 Elf_Data *c_data;
81 char *c_name;
82 } Cache;
83
84 typedef struct gver_desc {
85 const char *vd_name;
86 unsigned long vd_hash;
87 GElf_Half vd_ndx;
88 GElf_Half vd_flags;
89 APlist *vd_deps;
90 } GVer_desc;
91
92 /* Versym related data used by gvers_syms() */
93 typedef struct {
94 GElf_Versym *vsd_vsp; /* ptr to versym data */
95 Elf_Data *vsd_sym_data; /* ptr to symtab data */
96 Word vsd_symn; /* # of symbols in symtab */
97 const char *vsd_strs; /* string table data */
98 } Gver_sym_data;
99
100 /*
101 * Type used to manage -I and -N options:
102 *
103 * The -I option specifies a VERSYM index, or index range. The
104 * result is to select the VERDEF or VERNEED records with
105 * indexes that match those given.
106 *
107 * -N options come in two forms:
108 *
109 * 1) name
110 * 2) needobj (version)
111 *
112 * The meaning of the first case depends on the type of
113 * version record being matched:
114 *
115 * VERDEF - name is the name of a version defined
116 * by the object being processed (i.e. SUNW_1.1).
117 *
118 * VERNEED - name is the name of the object file
119 * on which the dependency exists (i.e. libc.so.1).
120 *
121 * -N options of the second form only apply to VERNEED records.
122 * They are used to specify a version from a needed object.
123 */
124 /* match_opt_t is used to note which match option was used */
125 typedef enum {
126 MATCH_OPT_NAME, /* Record contains a name */
127 MATCH_OPT_NEED_VER, /* Record contains needed object and version */
128 MATCH_OPT_NDX, /* Record contains a single index */
129 MATCH_OPT_RANGE, /* Record contains an index range */
130 } match_opt_t;
131
132 typedef struct {
133 match_opt_t opt_type;
134 union {
135 struct {
136 const char *version; /* MATCH_OPT_{NAME|NEED_VER} */
137 const char *needobj; /* MATCH_OPT_NEED_VER only */
138 } name;
139 struct {
140 int start; /* MATCH_OPT_{NDX|RANGE} */
141 int end; /* MATCH_OPT_RANGE only) */
142 } ndx;
143 } value;
144 } match_rec_t;
145
146
147
148 static const char *cname;
149 static int Cflag, dflag, lflag, nflag, oflag, rflag, sflag, vflag;
150 static Alist *match_list;
151
152 /* Used to track whether an option defaulted to on, or was explicitly set */
153 #define DEF_DEFINED 1
154 #define USR_DEFINED 2
155
156 /*
157 * Determine whether a symbol name should be demangled.
158 */
159 static const char *
160 demangle(const char *name)
161 {
162 if (Cflag)
163 return (Elf_demangle_name(name));
164 else
165 return (name);
166 }
167
168 /*
169 * Append an item to the specified list, and return a pointer to the list
170 * node created.
171 *
172 * exit:
173 * On success, a new list node is created and the item is
174 * added to the list. On failure, a fatal error is issued
175 * and the process exits.
176 */
177 static void
178 pvs_aplist_append(APlist **lst, const void *item, const char *file)
179 {
180 if (aplist_append(lst, item, AL_CNT_GVER_DESC) == NULL) {
181 int err = errno;
182 (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname, file,
183 strerror(err));
184 exit(1);
185 }
186 }
187
188 /*
189 * Add an entry to match_list for use by match(). This routine is for
190 * use during getopt() processing.
191 *
192 * entry:
193 * opt - One of 'N' or 'I', indicating the option
194 * str - Value string corresponding to opt
195 *
196 * exit:
197 * The new match record has been added. On error, a fatal
198 * error is issued and and the process exits.
199 */
200 static void
201 add_match_record(int opt, const char *str)
202 {
203 /*
204 * Macros for removing leading and trailing whitespace:
205 * WS_SKIP - Advance _str without passing the NULL termination,
206 * until the first character is not whitespace.
207 * WS_SKIP_LIMIT - Advance _str without passing _limit,
208 * until the first character is not whitespace.
209 * WS_RSKIP_LIMIT - Move _tail back without passing _str,
210 * until the character before it is not whitespace.
211 * Write a NULL termination at that point.
212 */
213 #define WS_SKIP(_str) for (; *(_str) && isspace(*(_str)); (_str)++)
214 #define WS_SKIP_LIMIT(_str, _limit) \
215 while (((_str) < s2) && isspace(*(_str))) \
216 (_str)++
217 #define WS_RSKIP_LIMIT(_str, _tail) \
218 while (((_tail) > (_str)) && isspace(*((_tail) - 1))) \
219 (_tail)--; \
220 *(_tail) = '\0'
221
222
223 match_rec_t *rec;
224 char *lstr, *s1, *s2;
225
226 rec = alist_append(&match_list, NULL, sizeof (match_rec_t),
227 AL_CNT_MATCH_LIST);
228 if (rec == NULL) {
229 int err = errno;
230 (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname,
231 MSG_INTL(MSG_STR_MATCH_RECORD), strerror(err));
232 exit(1);
233 }
234
235 if (opt == 'N') {
236 if ((lstr = strdup(str)) == NULL) {
237 int err = errno;
238 (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC),
239 cname, MSG_INTL(MSG_STR_MATCH_RECORD),
240 strerror(err));
241 exit(1);
242 }
243
244 /* Strip leading/trailing whitespace */
245 s2 = lstr + strlen(lstr);
246 WS_SKIP_LIMIT(lstr, s2);
247 WS_RSKIP_LIMIT(lstr, s2);
248
249 /* Assume this is a plain string */
250 rec->opt_type = MATCH_OPT_NAME;
251 rec->value.name.version = lstr;
252
253 /*
254 * If s2 points at a closing paren, then this might
255 * be a MATCH_OPT_NEED_VER case. Otherwise we're done.
256 */
257 if ((s2 == lstr) || (*(s2 - 1) != ')'))
258 return;
259
260 /* We have a closing paren. Locate the opening one. */
261 for (s1 = lstr; *s1 && (*s1 != '('); s1++)
262 ;
263 if (*s1 != '(')
264 return;
265
266 rec->opt_type = MATCH_OPT_NEED_VER;
267 rec->value.name.needobj = lstr;
268 rec->value.name.version = s1 + 1;
269 s2--; /* Points at closing paren */
270
271 /* Remove whitespace from head/tail of version */
272 WS_SKIP_LIMIT(rec->value.name.version, s2);
273 WS_RSKIP_LIMIT(rec->value.name.version, s2);
274
275 /* Terminate needobj, skipping trailing whitespace */
276 WS_RSKIP_LIMIT(rec->value.name.needobj, s1);
277
278 return;
279 }
280
281
282 /* If we get here, we are looking at a -I index option */
283 rec->value.ndx.start = strtol(str, &s2, 10);
284 /* Value must use some of the input, and be positive */
285 if ((str == s2) || (rec->value.ndx.start < 1))
286 goto syntax_error;
287 str = s2;
288
289 WS_SKIP(str);
290 if (*str != ':') {
291 rec->opt_type = MATCH_OPT_NDX;
292 } else {
293 str++; /* Skip the ':' */
294 rec->opt_type = MATCH_OPT_RANGE;
295 WS_SKIP(str);
296 if (*str == '\0') {
297 rec->value.ndx.end = -1; /* Indicates "to end" */
298 } else {
299 rec->value.ndx.end = strtol(str, &s2, 10);
300 if ((str == s2) || (rec->value.ndx.end < 0))
301 goto syntax_error;
302 str = s2;
303 WS_SKIP(str);
304 }
305 }
306
307 /* If we are successful, there is nothing left to parse */
308 if (*str == '\0')
309 return;
310
311 /*
312 * If we get here, there is leftover input. Fall through
313 * to issue a syntax error.
314 */
315 syntax_error:
316 (void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF), cname);
317 exit(1);
318
319 #undef WS_SKIP
320 #undef WS_SKIP_LIMIT
321 #undef WS_RSKIP_LIMIT
322 }
323
324 /*
325 * Returns True (1) if the version with the given name or index should
326 * be displayed, and False (0) if it should not be.
327 *
328 * entry:
329 * needobj - NULL for VERDEF records, the name of the
330 * needed object for VERNEED.
331 * version - NULL, or needed version
332 * ndx - Versym index of version under consideration, or a value less
333 * than 1 to indicate that no valid index is given.
334 *
335 * exit:
336 * True will be returned if the given name/index matches those given
337 * by one of the -I or -N command line options, or if no such option
338 * was used in the command invocation.
339 */
340 int
341 match(const char *needobj, const char *version, int ndx)
342 {
343 Aliste _idx;
344 match_rec_t *rec;
345 const char *str;
346
347 /* If there is no match list, then we approve everything */
348 if (alist_nitems(match_list) == 0)
349 return (1);
350
351 /* Run through the match records and check for a hit */
352 for (ALIST_TRAVERSE(match_list, _idx, rec)) {
353 switch (rec->opt_type) {
354 case MATCH_OPT_NAME:
355 if (needobj)
356 str = needobj;
357 else if (version)
358 str = version;
359 else
360 break;
361 if (strcmp(rec->value.name.version, str) == 0)
362 return (1);
363 break;
364 case MATCH_OPT_NEED_VER:
365 if (needobj && version &&
366 (strcmp(rec->value.name.needobj, needobj) == 0) &&
367 (strcmp(rec->value.name.version, version) == 0))
368 return (1);
369 break;
370 case MATCH_OPT_NDX:
371 if ((ndx > 0) && (ndx == rec->value.ndx.start))
372 return (1);
373 break;
374 case MATCH_OPT_RANGE:
375 /*
376 * A range end value less than 0 means that any value
377 * above the start is acceptible.
378 */
379 if ((ndx > 0) &&
380 (ndx >= rec->value.ndx.start) &&
381 ((rec->value.ndx.end < 0) ||
382 (ndx <= rec->value.ndx.end)))
383 return (1);
384 break;
385 }
386 }
387
388 /* Nothing matched */
389 return (0);
390 }
391
392 /*
393 * List the symbols that belong to a specified version
394 *
395 * entry:
396 * vsdata - VERSYM related data from the object
397 * vd_ndx - The VERSYM index for symbols to display
398 * vd_name - Version name
399 * needobj - NULL for symbols corresponding to a VERDEF
400 * record. Name of the needed object in the case
401 * of a VERNEED record.
402 * file - Object file
403 */
404 static void
405 gvers_syms(const Gver_sym_data *vsdata, GElf_Half vd_ndx,
406 const char *vd_name, const char *needobj, const char *file)
407 {
408 GElf_Sym sym;
409 int _symn;
410
411 for (_symn = 0; _symn < vsdata->vsd_symn; _symn++) {
412 size_t size = 0;
413 const char *name;
414
415 if (vsdata->vsd_vsp[_symn] != vd_ndx)
416 continue;
417
418 (void) gelf_getsym(vsdata->vsd_sym_data, _symn, &sym);
419 name = demangle(vsdata->vsd_strs + sym.st_name);
420
421 /*
422 * Symbols that reference a VERDEF record
423 * have some extra details to handle.
424 */
425 if (needobj == NULL) {
426 /*
427 * For data symbols defined by this object,
428 * determine the size.
429 */
430 if ((GELF_ST_TYPE(sym.st_info) == STT_OBJECT) ||
431 (GELF_ST_TYPE(sym.st_info) == STT_COMMON) ||
432 (GELF_ST_TYPE(sym.st_info) == STT_TLS))
433 size = (size_t)sym.st_size;
434
435 /*
436 * Only output the version symbol when the verbose
437 * flag is used.
438 */
439 if (!vflag && (sym.st_shndx == SHN_ABS) &&
440 (strcmp(name, vd_name) == 0))
441 continue;
442 }
443
444 if (oflag) {
445 if (needobj == NULL)
446 (void) printf(MSG_ORIG(MSG_FMT_SYM_OFIL),
447 file, vd_name);
448 else
449 (void) printf(MSG_ORIG(MSG_FMT_SYM_NEED_OFIL),
450 file, needobj, vd_name);
451
452 if (size)
453 (void) printf(MSG_ORIG(MSG_FMT_SYM_SZ_OFLG),
454 name, (ulong_t)size);
455 else
456 (void) printf(MSG_ORIG(MSG_FMT_SYM_OFLG), name);
457 } else {
458 if (size)
459 (void) printf(MSG_ORIG(MSG_FMT_SYM_SZ), name,
460 (ulong_t)size);
461 else
462 (void) printf(MSG_ORIG(MSG_FMT_SYM), name);
463 }
464 }
465 }
466
467 /*
468 * Print any reduced symbols. The convention is that reduced symbols exist as
469 * LOCL entries in the .symtab, between the FILE symbol for the output file and
470 * the first FILE symbol for any input file used to build the output file.
471 */
472 static void
473 sym_local(Cache *cache, Cache *csym, const char *file)
474 {
475 int symn, _symn, found = 0;
476 GElf_Shdr shdr;
477 GElf_Sym sym;
478 char *strs;
479
480 (void) gelf_getshdr(csym->c_scn, &shdr);
481 strs = (char *)cache[shdr.sh_link].c_data->d_buf;
482 /* LINTED */
483 symn = shdr.sh_info;
484
485 /*
486 * Verify symtab[1] is the output file symbol.
487 */
488 (void) gelf_getsym(csym->c_data, 1, &sym);
489 if (GELF_ST_TYPE(sym.st_info) != STT_FILE) {
490 (void) fprintf(stderr, MSG_INTL(MSG_VER_UNREDSYMS), cname,
491 file);
492 (void) fprintf(stderr, MSG_INTL(MSG_VER_NOTSTTFILE),
493 csym->c_name);
494 return;
495 }
496
497 /*
498 * Scan the remaining symbols until the next file symbol is found.
499 */
500 for (_symn = 2; _symn < symn; _symn++) {
501 const char *name;
502
503 (void) gelf_getsym(csym->c_data, _symn, &sym);
504 if (GELF_ST_TYPE(sym.st_info) == STT_SECTION)
505 continue;
506 if (GELF_ST_TYPE(sym.st_info) == STT_FILE)
507 break;
508
509 /*
510 * Its possible that section symbols are followed immediately
511 * by globals. This is the case if an object (filter) is
512 * generated exclusively from mapfile symbol definitions.
513 */
514 if (GELF_ST_BIND(sym.st_info) != STB_LOCAL)
515 break;
516
517 name = demangle(strs + sym.st_name);
518
519 if (oflag) {
520 (void) printf(MSG_ORIG(MSG_FMT_LOCSYM_OFLG),
521 file, name);
522 } else {
523 if (found == 0) {
524 found = 1;
525 (void) printf(MSG_ORIG(MSG_FMT_LOCSYM_HDR));
526 }
527 (void) printf(MSG_ORIG(MSG_FMT_LOCSYM), name);
528 }
529 }
530 }
531
532 /*
533 * Print data from the files VERNEED section.
534 *
535 * If we have been asked to display symbols, then the
536 * output format follows that used for verdef sections,
537 * with each version displayed separately. For instance:
538 *
539 * libc.so.1 (SUNW_1.7):
540 * sym1;
541 * sym2;
542 * libc.so.1 (SUNW_1.9):
543 * sym3;
544 *
545 * If we are not displaying symbols, then a terse format
546 * is used, which combines all the needed versions from
547 * a given object into a single line. In this case, the
548 * versions are shown whether or not they contribute symbols.
549 *
550 * libc.so.1 (SUNW_1.7, SUNW_1.9);
551 */
552 static int
553 gvers_need(Cache *cache, Cache *need, const Gver_sym_data *vsdata,
554 const char *file)
555 {
556 unsigned int num, _num;
557 char *strs;
558 GElf_Verneed *vnd = need->c_data->d_buf;
559 GElf_Shdr shdr;
560 int error = 0;
561 int show = vflag || (vsdata == NULL) || !oflag;
562
563
564 (void) gelf_getshdr(need->c_scn, &shdr);
565
566 /*
567 * Verify the version revision. We only check the first version
568 * structure as it is assumed all other version structures in this
569 * data section will be of the same revision.
570 */
571 if (vnd->vn_version > VER_DEF_CURRENT)
572 (void) fprintf(stderr, MSG_INTL(MSG_VER_HIGHREV), cname, file,
573 vnd->vn_version, VER_DEF_CURRENT);
574
575 /*
576 * Get the data buffer for the associated string table.
577 */
578 strs = (char *)cache[shdr.sh_link].c_data->d_buf;
579 num = shdr.sh_info;
580
581 for (_num = 1; _num <= num; _num++,
582 vnd = (GElf_Verneed *)((uintptr_t)vnd + vnd->vn_next)) {
583 GElf_Vernaux *vnap;
584 Word ndx;
585 const char *needobj, *dep;
586 int started = 0, listcnt = 0;
587
588 vnap = (GElf_Vernaux *) ((uintptr_t)vnd + vnd->vn_aux);
589
590 /* Obtain the needed object file name */
591 needobj = (char *)(strs + vnd->vn_file);
592
593 error = 1;
594
595 /* Process the versions needed from this object */
596 for (ndx = 0; ndx < vnd->vn_cnt; ndx++,
597 vnap = (GElf_Vernaux *)((uintptr_t)vnap + vnap->vna_next)) {
598 Conv_ver_flags_buf_t ver_flags_buf;
599
600 dep = (char *)(strs + vnap->vna_name);
601
602 if (!match(needobj, dep, vnap->vna_other))
603 continue;
604
605 if (show) {
606 if ((started == 0) || (vsdata != NULL)) {
607 /*
608 * If one-line ouput is called for
609 * display the filename being processed.
610 */
611 if (oflag && show)
612 (void) printf(
613 MSG_ORIG(MSG_FMT_OFIL),
614 file);
615
616 (void) printf(
617 MSG_ORIG(MSG_FMT_LIST_BEGIN),
618 needobj);
619 started = 1;
620 }
621
622 /*
623 * If not showing symbols, only show INFO
624 * versions in verbose mode. They don't
625 * actually contribute to the version
626 * interface as seen by rtld, so listing them
627 * without qualification can be misleading.
628 */
629 if (vflag || (vsdata != NULL) ||
630 (alist_nitems(match_list) != 0) ||
631 !(vnap->vna_flags & VER_FLG_INFO)) {
632 const char *fmt = (listcnt == 0) ?
633 MSG_ORIG(MSG_FMT_LIST_FIRST) :
634 MSG_ORIG(MSG_FMT_LIST_NEXT);
635
636 if (vsdata == NULL)
637 listcnt++;
638 (void) printf(fmt, dep);
639
640 /* Show non-zero flags */
641 if (vflag && (vnap->vna_flags != 0))
642 (void) printf(
643 MSG_ORIG(MSG_FMT_VER_FLG),
644 conv_ver_flags(
645 vnap->vna_flags,
646 CONV_FMT_NOBKT,
647 &ver_flags_buf));
648 }
649 if (vsdata != NULL)
650 (void) printf(oflag ?
651 MSG_ORIG(MSG_FMT_LIST_END_SEM) :
652 MSG_ORIG(MSG_FMT_LIST_END_COL));
653 }
654
655 /*
656 * If we are showing symbols, and vna_other is
657 * non-zero, list them here.
658 *
659 * A value of 0 means that this object uses
660 * traditional Solaris versioning rules, under
661 * which VERSYM does not contain indexes to VERNEED
662 * records. In this case, there is nothing to show.
663 */
664 if (vsdata && (vnap->vna_other > 0))
665 gvers_syms(vsdata, vnap->vna_other,
666 dep, needobj, file);
667 }
668 if (show && started && (vsdata == NULL))
669 (void) printf(MSG_ORIG(MSG_FMT_LIST_END_SEM));
670 }
671 return (error);
672 }
673
674 /*
675 * Return a GVer_desc descriptor for the given version if one
676 * exists.
677 *
678 * entry:
679 * name - Version name
680 * hash - ELF hash of name
681 * lst - APlist of existing descriptors.
682 * file - Object file containing the version
683 *
684 * exit:
685 * Return the corresponding GVer_desc struct if it
686 * exists, and NULL otherwise.
687 */
688 static GVer_desc *
689 gvers_find(const char *name, unsigned long hash, APlist *lst)
690 {
691 Aliste idx;
692 GVer_desc *vdp;
693
694 for (APLIST_TRAVERSE(lst, idx, vdp))
695 if ((vdp->vd_hash == hash) &&
696 (strcmp(vdp->vd_name, name) == 0))
697 return (vdp);
698
699 return (NULL);
700 }
701
702 /*
703 * Return a GVer_desc descriptor for the given version.
704 *
705 * entry:
706 * name - Version name
707 * hash - ELF hash of name
708 * lst - List of existing descriptors.
709 * file - Object file containing the version
710 *
711 * exit:
712 * Return the corresponding GVer_desc struct. If the
713 * descriptor does not already exist, it is created.
714 * On error, a fatal error is issued and the process exits.
715 */
716 static GVer_desc *
717 gvers_desc(const char *name, unsigned long hash, APlist **lst, const char *file)
718 {
719 GVer_desc *vdp;
720
721 if ((vdp = gvers_find(name, hash, *lst)) == NULL) {
722 if ((vdp = calloc(sizeof (GVer_desc), 1)) == NULL) {
723 int err = errno;
724 (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname,
725 file, strerror(err));
726 exit(1);
727 }
728
729 vdp->vd_name = name;
730 vdp->vd_hash = hash;
731
732 pvs_aplist_append(lst, vdp, file);
733 }
734 return (vdp);
735 }
736
737 /*
738 * Insert a version dependency for the given GVer_desc descriptor.
739 *
740 * entry:
741 * name - Dependency version name
742 * hash - ELF hash of name
743 * lst - List of existing descriptors.
744 * vdp - Existing version descriptor to which the dependency
745 * is to be added.
746 * file - Object file containing the version
747 *
748 * exit:
749 * A descriptor for the dependency version is looked up
750 * (created if necessary), and then added to the dependency
751 * list for vdp. Returns the dependency descriptor. On error,
752 * a fatal error is issued and the process exits.
753 */
754 static GVer_desc *
755 gvers_depend(const char *name, unsigned long hash, GVer_desc *vdp, APlist **lst,
756 const char *file)
757 {
758 GVer_desc *_vdp;
759
760 _vdp = gvers_desc(name, hash, lst, file);
761 pvs_aplist_append(&vdp->vd_deps, _vdp, file);
762 return (vdp);
763 }
764
765 static void
766 gvers_derefer(GVer_desc *vdp, int weak)
767 {
768 Aliste idx;
769 GVer_desc *_vdp;
770
771 /*
772 * If the head of the list was a weak then we only clear out
773 * weak dependencies, but if the head of the list was 'strong'
774 * we clear the REFER bit on all dependencies.
775 */
776 if ((weak && (vdp->vd_flags & VER_FLG_WEAK)) || (!weak))
777 vdp->vd_flags &= ~FLG_VER_AVAIL;
778
779 for (APLIST_TRAVERSE(vdp->vd_deps, idx, _vdp))
780 gvers_derefer(_vdp, weak);
781 }
782
783
784 static void
785 recurse_syms(const Gver_sym_data *vsdata, GVer_desc *vdp, const char *file)
786 {
787 Aliste idx;
788 GVer_desc *_vdp;
789
790 for (APLIST_TRAVERSE(vdp->vd_deps, idx, _vdp)) {
791 if (!oflag)
792 (void) printf(MSG_ORIG(MSG_FMT_TNCO), _vdp->vd_name);
793 gvers_syms(vsdata, _vdp->vd_ndx, _vdp->vd_name, NULL, file);
794 if (aplist_nitems(_vdp->vd_deps) != 0)
795 recurse_syms(vsdata, _vdp, file);
796 }
797 }
798
799
800 /*
801 * Print the files version definition sections.
802 */
803 static int
804 gvers_def(Cache *cache, Cache *def, const Gver_sym_data *vsdata,
805 const char *file)
806 {
807 unsigned int num, _num;
808 char *strs;
809 GElf_Verdef *vdf = def->c_data->d_buf;
810 GElf_Shdr shdr;
811 GVer_desc *vdp, *bvdp = NULL;
812 Aliste idx1;
813 APlist *verdefs = NULL;
814 int error = 0;
815
816 /*
817 * Verify the version revision. We only check the first version
818 * structure as it is assumed all other version structures in this
819 * data section will be of the same revision.
820 */
821 if (vdf->vd_version > VER_DEF_CURRENT) {
822 (void) fprintf(stderr, MSG_INTL(MSG_VER_HIGHREV), cname, file,
823 vdf->vd_version, VER_DEF_CURRENT);
824 }
825
826 /*
827 * Get the data buffer for the associated string table.
828 */
829 (void) gelf_getshdr(def->c_scn, &shdr);
830 strs = (char *)cache[shdr.sh_link].c_data->d_buf;
831 num = shdr.sh_info;
832
833 /*
834 * Process the version definitions placing each on a version dependency
835 * list.
836 */
837 for (_num = 1; _num <= num; _num++,
838 vdf = (GElf_Verdef *)((uintptr_t)vdf + vdf->vd_next)) {
839 GElf_Half cnt = vdf->vd_cnt;
840 GElf_Half ndx = vdf->vd_ndx;
841 GElf_Verdaux *vdap;
842 const char *_name;
843
844 vdap = (GElf_Verdaux *)((uintptr_t)vdf + vdf->vd_aux);
845
846 /*
847 * Determine the version name and any dependencies.
848 */
849 _name = (char *)(strs + vdap->vda_name);
850
851 vdp = gvers_desc(_name, elf_hash(_name), &verdefs, file);
852 vdp->vd_ndx = ndx;
853 vdp->vd_flags = vdf->vd_flags | FLG_VER_AVAIL;
854
855 vdap = (GElf_Verdaux *)((uintptr_t)vdap + vdap->vda_next);
856 for (cnt--; cnt; cnt--,
857 vdap = (GElf_Verdaux *)((uintptr_t)vdap + vdap->vda_next)) {
858 _name = (char *)(strs + vdap->vda_name);
859 if (gvers_depend(_name, elf_hash(_name), vdp,
860 &verdefs, file) == NULL)
861 return (0);
862 }
863
864 /*
865 * Remember the base version for possible later use.
866 */
867 if (ndx == VER_NDX_GLOBAL)
868 bvdp = vdp;
869 }
870
871 /*
872 * Normalize the dependency list if required.
873 */
874 if (nflag) {
875 for (APLIST_TRAVERSE(verdefs, idx1, vdp)) {
876 Aliste idx2;
877 GVer_desc *_vdp;
878 int type = vdp->vd_flags & VER_FLG_WEAK;
879
880 for (APLIST_TRAVERSE(vdp->vd_deps, idx2, _vdp))
881 gvers_derefer(_vdp, type);
882 }
883
884 /*
885 * Always dereference the base version.
886 */
887 if (bvdp)
888 bvdp->vd_flags &= ~FLG_VER_AVAIL;
889 }
890
891
892 /*
893 * Traverse the dependency list and print out the appropriate
894 * information.
895 */
896 for (APLIST_TRAVERSE(verdefs, idx1, vdp)) {
897 Aliste idx2;
898 GVer_desc *_vdp;
899 int count;
900
901 if (!match(NULL, vdp->vd_name, vdp->vd_ndx))
902 continue;
903 if ((alist_nitems(match_list) == 0) &&
904 !(vdp->vd_flags & FLG_VER_AVAIL))
905 continue;
906
907 error = 1;
908
909 if (vflag) {
910 /*
911 * If the verbose flag is set determine if this version
912 * has a `weak' attribute, and print any version
913 * dependencies this version inherits.
914 */
915 if (oflag)
916 (void) printf(MSG_ORIG(MSG_FMT_OFIL), file);
917 (void) printf(MSG_ORIG(MSG_FMT_VER_NAME), vdp->vd_name);
918 if ((vdp->vd_flags & MSK_VER_USER) != 0) {
919 Conv_ver_flags_buf_t ver_flags_buf;
920
921 (void) printf(MSG_ORIG(MSG_FMT_VER_FLG),
922 conv_ver_flags(
923 vdp->vd_flags & MSK_VER_USER,
924 CONV_FMT_NOBKT, &ver_flags_buf));
925 }
926
927 count = 1;
928 for (APLIST_TRAVERSE(vdp->vd_deps, idx2, _vdp)) {
929 const char *_name = _vdp->vd_name;
930
931 if (count++ == 1) {
932
933 if (oflag)
934 (void) printf(
935 MSG_ORIG(MSG_FMT_IN_OFLG),
936 _name);
937 else if (vdp->vd_flags & VER_FLG_WEAK)
938 (void) printf(
939 MSG_ORIG(MSG_FMT_IN_WEAK),
940 _name);
941 else
942 (void) printf(
943 MSG_ORIG(MSG_FMT_IN),
944 _name);
945 } else
946 (void) printf(
947 MSG_ORIG(MSG_FMT_LIST_NEXT), _name);
948 }
949
950 if (count != 1)
951 (void) printf(MSG_ORIG(MSG_FMT_IN_END));
952
953 if (vsdata && !oflag)
954 (void) printf(MSG_ORIG(MSG_FMT_COL_NL));
955 else
956 (void) printf(MSG_ORIG(MSG_FMT_SEM_NL));
957 } else {
958 if (vsdata && !oflag)
959 (void) printf(MSG_ORIG(MSG_FMT_TNCO),
960 vdp->vd_name);
961 else if (!vsdata) {
962 if (oflag)
963 (void) printf(MSG_ORIG(MSG_FMT_OFIL),
964 file);
965 (void) printf(MSG_ORIG(MSG_FMT_TNSE),
966 vdp->vd_name);
967 }
968 }
969
970 /* If we are not printing symbols, we're done */
971 if (vsdata == NULL)
972 continue;
973
974 /*
975 * If a specific version to match has been specified then
976 * display any of its own symbols plus any inherited from
977 * other versions. Otherwise simply print out the symbols
978 * for this version.
979 */
980 gvers_syms(vsdata, vdp->vd_ndx, vdp->vd_name, NULL, file);
981 if (alist_nitems(match_list) != 0) {
982 recurse_syms(vsdata, vdp, file);
983
984 /*
985 * If the verbose flag is set, and this is not
986 * the base version, then add the base version as a
987 * dependency.
988 */
989 if (vflag && bvdp &&
990 !match(NULL, bvdp->vd_name, bvdp->vd_ndx)) {
991 if (!oflag)
992 (void) printf(MSG_ORIG(MSG_FMT_TNCO),
993 bvdp->vd_name);
994 gvers_syms(vsdata, bvdp->vd_ndx,
995 bvdp->vd_name, NULL, file);
996 }
997 }
998 }
999 return (error);
1000 }
1001
1002 int
1003 main(int argc, char **argv, char **envp)
1004 {
1005 GElf_Shdr shdr;
1006 Elf *elf;
1007 Elf_Scn *scn;
1008 Elf_Data *data;
1009 GElf_Ehdr ehdr;
1010 int nfile, var;
1011 char *names;
1012 Cache *cache, *_cache;
1013 Cache *_cache_def, *_cache_need, *_cache_sym, *_cache_loc;
1014 int error = 0;
1015 Gver_sym_data vsdata_s;
1016 const Gver_sym_data *vsdata = NULL;
1017
1018 /*
1019 * Check for a binary that better fits this architecture.
1020 */
1021 (void) conv_check_native(argv, envp);
1022
1023 /*
1024 * Establish locale.
1025 */
1026 (void) setlocale(LC_MESSAGES, MSG_ORIG(MSG_STR_EMPTY));
1027 (void) textdomain(MSG_ORIG(MSG_SUNW_OST_SGS));
1028
1029 cname = argv[0];
1030 Cflag = dflag = lflag = nflag = oflag = rflag = sflag = vflag = 0;
1031
1032 opterr = 0;
1033 while ((var = getopt(argc, argv, MSG_ORIG(MSG_STR_OPTIONS))) != EOF) {
1034 switch (var) {
1035 case 'C':
1036 Cflag = USR_DEFINED;
1037 break;
1038 case 'd':
1039 dflag = USR_DEFINED;
1040 break;
1041 case 'l':
1042 lflag = sflag = USR_DEFINED;
1043 break;
1044 case 'n':
1045 nflag = USR_DEFINED;
1046 break;
1047 case 'o':
1048 oflag = USR_DEFINED;
1049 break;
1050 case 'r':
1051 rflag = USR_DEFINED;
1052 break;
1053 case 's':
1054 sflag = USR_DEFINED;
1055 break;
1056 case 'v':
1057 vflag = USR_DEFINED;
1058 break;
1059 case 'I':
1060 case 'N':
1061 add_match_record(var, optarg);
1062 break;
1063 case '?':
1064 (void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF),
1065 cname);
1066 (void) fprintf(stderr, MSG_INTL(MSG_USAGE_DETAIL));
1067 exit(1);
1068 default:
1069 break;
1070 }
1071 }
1072
1073 /*
1074 * No files specified on the command line?
1075 */
1076 if ((nfile = argc - optind) == 0) {
1077 (void) fprintf(stderr, MSG_INTL(MSG_USAGE_BRIEF), cname);
1078 exit(1);
1079 }
1080
1081 /*
1082 * By default print both version definitions and needed dependencies.
1083 */
1084 if ((dflag == 0) && (rflag == 0) && (lflag == 0))
1085 dflag = rflag = DEF_DEFINED;
1086
1087 /*
1088 * Open the input file and initialize the elf interface.
1089 */
1090 for (; optind < argc; optind++) {
1091 int derror = 0, nerror = 0, err;
1092 const char *file = argv[optind];
1093 size_t shnum = 0;
1094
1095 if ((var = open(file, O_RDONLY)) == -1) {
1096 err = errno;
1097 (void) fprintf(stderr, MSG_INTL(MSG_SYS_OPEN),
1098 cname, file, strerror(err));
1099 error = 1;
1100 continue;
1101 }
1102 (void) elf_version(EV_CURRENT);
1103 if ((elf = elf_begin(var, ELF_C_READ, NULL)) == NULL) {
1104 (void) fprintf(stderr, MSG_ORIG(MSG_ELF_BEGIN), cname,
1105 file, elf_errmsg(elf_errno()));
1106 error = 1;
1107 (void) close(var);
1108 continue;
1109 }
1110 if (elf_kind(elf) != ELF_K_ELF) {
1111 (void) fprintf(stderr, MSG_INTL(MSG_ELF_NOTELF), cname,
1112 file);
1113 error = 1;
1114 (void) close(var);
1115 (void) elf_end(elf);
1116 continue;
1117 }
1118 if (gelf_getehdr(elf, &ehdr) == NULL) {
1119 (void) fprintf(stderr, MSG_ORIG(MSG_ELF_GETEHDR), cname,
1120 file, elf_errmsg(elf_errno()));
1121 error = 1;
1122 (void) close(var);
1123 (void) elf_end(elf);
1124 continue;
1125 }
1126
1127 /*
1128 * Obtain the .shstrtab data buffer to provide the required
1129 * section name strings.
1130 */
1131 if ((scn = elf_getscn(elf, ehdr.e_shstrndx)) == NULL) {
1132 (void) fprintf(stderr, MSG_ORIG(MSG_ELF_GETSCN), cname,
1133 file, elf_errmsg(elf_errno()));
1134 error = 1;
1135 (void) close(var);
1136 (void) elf_end(elf);
1137 continue;
1138 }
1139 if ((data = elf_getdata(scn, NULL)) == NULL) {
1140 (void) fprintf(stderr, MSG_ORIG(MSG_ELF_GETDATA), cname,
1141 file, elf_errmsg(elf_errno()));
1142 error = 1;
1143 (void) close(var);
1144 (void) elf_end(elf);
1145 continue;
1146 }
1147 names = data->d_buf;
1148
1149 /*
1150 * Fill in the cache descriptor with information for each
1151 * section we might need. We probably only need to save
1152 * read-only allocable sections as this is where the version
1153 * structures and their associated symbols and strings live.
1154 * However, God knows what someone can do with a mapfile, and
1155 * as elf_begin has already gone through all the overhead we
1156 * might as well set up the cache for every section.
1157 */
1158 if (elf_getshdrnum(elf, &shnum) == -1) {
1159 (void) fprintf(stderr, MSG_ORIG(MSG_ELF_GETSHDRNUM),
1160 cname, file, elf_errmsg(elf_errno()));
1161 exit(1);
1162 }
1163
1164 if ((cache = calloc(shnum, sizeof (Cache))) == NULL) {
1165 int err = errno;
1166 (void) fprintf(stderr, MSG_INTL(MSG_SYS_MALLOC), cname,
1167 file, strerror(err));
1168 exit(1);
1169 }
1170
1171 _cache_def = _cache_need = _cache_sym = _cache_loc = NULL;
1172 _cache = cache;
1173 _cache++;
1174 for (scn = NULL; scn = elf_nextscn(elf, scn); _cache++) {
1175 if (gelf_getshdr(scn, &shdr) == NULL) {
1176 (void) fprintf(stderr,
1177 MSG_ORIG(MSG_ELF_GETSHDR), cname, file,
1178 elf_errmsg(elf_errno()));
1179 error = 1;
1180 continue;
1181 }
1182 if ((_cache->c_data = elf_getdata(scn, NULL)) ==
1183 NULL) {
1184 (void) fprintf(stderr,
1185 MSG_ORIG(MSG_ELF_GETDATA), cname, file,
1186 elf_errmsg(elf_errno()));
1187 error = 1;
1188 continue;
1189 }
1190 _cache->c_scn = scn;
1191 _cache->c_name = names + shdr.sh_name;
1192
1193 /*
1194 * Remember the version sections and symbol table.
1195 */
1196 switch (shdr.sh_type) {
1197 case SHT_SUNW_verdef:
1198 if (dflag)
1199 _cache_def = _cache;
1200 break;
1201 case SHT_SUNW_verneed:
1202 if (rflag)
1203 _cache_need = _cache;
1204 break;
1205 case SHT_SUNW_versym:
1206 if (sflag)
1207 _cache_sym = _cache;
1208 break;
1209 case SHT_SYMTAB:
1210 if (lflag)
1211 _cache_loc = _cache;
1212 break;
1213 }
1214 }
1215
1216 /*
1217 * Before printing anything out determine if any warnings are
1218 * necessary.
1219 */
1220 if (lflag && (_cache_loc == NULL)) {
1221 (void) fprintf(stderr, MSG_INTL(MSG_VER_UNREDSYMS),
1222 cname, file);
1223 (void) fprintf(stderr, MSG_INTL(MSG_VER_NOSYMTAB));
1224 }
1225
1226 /*
1227 * If there is more than one input file, and we're not printing
1228 * one-line output, display the filename being processed.
1229 */
1230 if ((nfile > 1) && !oflag)
1231 (void) printf(MSG_ORIG(MSG_FMT_FILE), file);
1232
1233 /*
1234 * If we're printing symbols, then collect the data
1235 * necessary to do that.
1236 */
1237 if (_cache_sym != NULL) {
1238 vsdata = &vsdata_s;
1239 (void) gelf_getshdr(_cache_sym->c_scn, &shdr);
1240 vsdata_s.vsd_vsp =
1241 (GElf_Versym *)_cache_sym->c_data->d_buf;
1242 vsdata_s.vsd_sym_data = cache[shdr.sh_link].c_data;
1243 (void) gelf_getshdr(cache[shdr.sh_link].c_scn, &shdr);
1244 vsdata_s.vsd_symn = shdr.sh_size / shdr.sh_entsize;
1245 vsdata_s.vsd_strs =
1246 (const char *)cache[shdr.sh_link].c_data->d_buf;
1247 }
1248
1249
1250 /*
1251 * Print the files version needed sections.
1252 */
1253 if (_cache_need)
1254 nerror = gvers_need(cache, _cache_need, vsdata, file);
1255
1256 /*
1257 * Print the files version definition sections.
1258 */
1259 if (_cache_def)
1260 derror = gvers_def(cache, _cache_def, vsdata, file);
1261
1262 /*
1263 * Print any local symbol reductions.
1264 */
1265 if (_cache_loc)
1266 sym_local(cache, _cache_loc, file);
1267
1268 /*
1269 * Determine the error return. There are three conditions that
1270 * may produce an error (a non-zero return):
1271 *
1272 * o if the user specified -d and no version definitions
1273 * were found.
1274 *
1275 * o if the user specified -r and no version requirements
1276 * were found.
1277 *
1278 * o if the user specified neither -d or -r, (thus both are
1279 * enabled by default), and no version definitions or
1280 * version dependencies were found.
1281 */
1282 if (((dflag == USR_DEFINED) && (derror == 0)) ||
1283 ((rflag == USR_DEFINED) && (nerror == 0)) ||
1284 (rflag && dflag && (derror == 0) && (nerror == 0)))
1285 error = 1;
1286
1287 (void) close(var);
1288 (void) elf_end(elf);
1289 free(cache);
1290 }
1291 return (error);
1292 }
1293
1294 const char *
1295 _pvs_msg(Msg mid)
1296 {
1297 return (gettext(MSG_ORIG(mid)));
1298 }