]> pd.if.org Git - zpackage/blob - elf/needed.c
fix uninitialized memory use
[zpackage] / elf / needed.c
1 #define _POSIX_C_SOURCE 200112L
2 #include <sys/types.h>
3 #include <sys/stat.h>
4 #include <sys/mman.h>
5 #include <fcntl.h>
6 #include <unistd.h>
7 #include <limits.h>
8 #include <errno.h>
9
10 #include <stdio.h>
11 #include <stdlib.h>
12 #include <string.h>
13
14 #include "elf.h"
15
16 void *libelf_map(char *path, size_t *fsize);
17 int libelf_iself(void *elf);
18 char *libelf_soname(void *elf);
19 int libelf_type(void *elf);
20
21 Elf64_Ehdr *libelf_header(void *elf) {
22         return elf;
23 }
24
25 Elf64_Shdr *libelf_shdr(void *elf, int n) {
26         return (Elf64_Shdr*)(char *)elf + n;
27 }
28
29 Elf64_Shdr *libelf_sht_strtab(void *elf) {
30         int i;
31         Elf64_Ehdr *hdr;
32         Elf64_Shdr *shdr;
33
34         hdr = libelf_header(elf);
35
36         for (i = 0; i < hdr->e_shnum; i++) {
37                 shdr = (Elf64_Shdr *)((char *)elf + hdr->e_shoff + i * hdr->e_shentsize);
38                 if (shdr->sh_type == SHT_STRTAB && i == hdr->e_shstrndx) {
39                         return shdr;
40                 }
41         }
42         return 0;
43 }
44
45 char *libelf_sectionname(Elf64_Shdr *section, Elf64_Shdr *strtab) {
46         return (char *)strtab + section->sh_name;
47 }
48
49 Elf64_Shdr *libelf_section_n(void *elf, int n) {
50         Elf64_Ehdr *hdr;
51
52         hdr = libelf_header(elf);
53
54         if (n > hdr->e_shnum) {
55                 return 0;
56         }
57
58         return (Elf64_Shdr *)((char *)elf + hdr->e_shoff + n * hdr->e_shentsize);
59 }
60
61 Elf64_Shdr *libelf_section(void *elf, unsigned int type) {
62         int i;
63         Elf64_Ehdr *hdr;
64         Elf64_Shdr *shdr;
65
66         hdr = libelf_header(elf);
67
68         for (i = 0; i < hdr->e_shnum; i++) {
69                 shdr = (Elf64_Shdr *)((char *)elf + hdr->e_shoff + i * hdr->e_shentsize);
70                 if (shdr->sh_type == type) {
71                         return shdr;
72                 }
73         }
74         return 0;
75 }
76
77 int libelf_type(void *elf) {
78         return ((Elf64_Ehdr *)elf)->e_type;
79 }
80
81 int libelf_iself(void *elf) {
82         Elf64_Ehdr *hdr;
83         hdr = elf;
84         if (hdr->e_ident[EI_MAG0] != ELFMAG0
85                         || hdr->e_ident[EI_MAG1] != ELFMAG1
86                         || hdr->e_ident[EI_MAG2] != ELFMAG2
87                         || hdr->e_ident[EI_MAG3] != ELFMAG3
88            ) {
89                 return 0;
90         }
91         return 1;
92 }
93
94 void *libelf_map(char *path, size_t *fsize) {
95         int elffd;
96         struct stat sbuf;
97         void *elfbase;
98
99         errno = 0;
100
101         elffd = open(path, O_RDONLY);
102         if (elffd == -1) {
103                 perror("open");
104                 return NULL;
105         }
106         if (fstat(elffd, &sbuf) == -1) {
107                 close(elffd);
108                 return NULL;
109         }
110         /* not a regular file? */
111         if (!S_ISREG(sbuf.st_mode)) {
112                 close(elffd);
113                 return NULL;
114         }
115         /* not at least the size of the elf header? */
116         if ((size_t)sbuf.st_size < sizeof(Elf64_Ehdr)) {
117                 close(elffd);
118                 return NULL;
119         }
120
121         elfbase = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, elffd, 0);
122         close(elffd);
123         if (!elfbase) {
124                 return NULL;
125         }
126
127         if (!libelf_iself(elfbase)) {
128                 munmap(elfbase, sbuf.st_size);
129                 return NULL;
130         }
131
132         *fsize = sbuf.st_size;
133
134         return elfbase;
135 }
136
137 int main(int ac, char **av) {
138         void *elf;
139         size_t fsize;
140         int i;
141         Elf64_Ehdr *hdr;
142         char *strtab;
143         Elf64_Phdr *phdr;
144         Elf64_Dyn *dyn = 0;
145         int opt, flags = 0;
146
147         while ((opt = getopt(ac, av, "e")) != -1) {
148                 flags = 1;
149         }
150
151         elf = libelf_map(av[optind], &fsize);
152         if (!elf) {
153                 exit(1);
154         }
155
156         /* only dynamic files will have an soname */
157         if (libelf_type(elf) != ET_DYN && libelf_type(elf) != ET_EXEC) {
158                 exit(4);
159         }
160         
161         hdr = libelf_header(elf);
162
163         switch (hdr->e_ident[EI_CLASS]) {
164                 case ELFCLASS64:
165                 case ELFCLASS32:
166                 case ELFCLASSNONE:
167                         break;
168                 default:
169                         exit(5);
170         }
171
172         /* check endian ness */
173         switch (hdr->e_ident[EI_DATA]) {
174                 case ELFDATA2LSB: break;
175                 case ELFDATA2MSB: break;
176                 default:
177                         exit(6);
178         }
179
180         Elf64_Shdr *dsect = 0;
181         /* find program header table */
182         for (i = 0; i < hdr->e_phnum; i++) {
183                 phdr = (Elf64_Phdr *)((char *)elf + hdr->e_phoff + i * hdr->e_phentsize);
184                 if (phdr->p_type == PT_DYNAMIC) {
185                         dsect = (Elf64_Shdr *)((char *)elf + phdr->p_offset);
186                 }
187         }
188         if (!dsect) {
189                 /* no dsect, statically linked? */
190                 exit(7);
191         }
192
193         dyn = (Elf64_Dyn *)((char *)elf + dsect->sh_offset);
194         if (!dyn) {
195                 exit(9);
196         }
197         dyn = (Elf64_Dyn *)dsect;
198
199         dsect = libelf_section(elf, SHT_DYNAMIC);
200         Elf64_Shdr *strsect;
201
202         strsect = libelf_section_n(elf, dsect->sh_link);
203         strtab = (char *)elf + strsect->sh_offset;
204
205         while (dyn->d_tag != DT_NULL) {
206                 if (dyn->d_tag == DT_NEEDED) {
207                         if (flags) {
208                                 printf("%s ", av[optind]);
209                         }
210                         printf("%s\n", strtab + dyn->d_un.d_val);
211                 }
212                 dyn++;
213         }
214
215         return 0;
216 }