]> pd.if.org Git - zpackage/blob - elf/libelf.c
fix uninitialized memory use
[zpackage] / elf / libelf.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 #if 0
26 Elf64_Shdr *libelf_shdr(void *elf, int n) {
27         return 0;
28 }
29 #endif
30
31 Elf64_Shdr *libelf_sht_strtab(void *elf) {
32         int i;
33         Elf64_Ehdr *hdr;
34         Elf64_Shdr *shdr;
35
36         hdr = libelf_header(elf);
37
38         for (i = 0; i < hdr->e_shnum; i++) {
39                 shdr = (Elf64_Shdr *)((char *)elf + hdr->e_shoff + i * hdr->e_shentsize);
40                 if (shdr->sh_type == SHT_STRTAB && i == hdr->e_shstrndx) {
41                         return shdr;
42                 }
43         }
44         return 0;
45 }
46
47 char *libelf_sectionname(Elf64_Shdr *section, Elf64_Shdr *strtab) {
48         return (char *)strtab + section->sh_name;
49 }
50
51 Elf64_Shdr *libelf_section_n(void *elf, int n) {
52         Elf64_Ehdr *hdr;
53
54         hdr = libelf_header(elf);
55
56         if (n > hdr->e_shnum) {
57                 return 0;
58         }
59
60         return (Elf64_Shdr *)((char *)elf + hdr->e_shoff + n * hdr->e_shentsize);
61 }
62
63 Elf64_Shdr *libelf_section(void *elf, unsigned int type) {
64         int i;
65         Elf64_Ehdr *hdr;
66         Elf64_Shdr *shdr;
67
68         hdr = libelf_header(elf);
69
70         for (i = 0; i < hdr->e_shnum; i++) {
71                 shdr = (Elf64_Shdr *)((char *)elf + hdr->e_shoff + i * hdr->e_shentsize);
72                 if (shdr->sh_type == type) {
73                         return shdr;
74                 }
75         }
76         return 0;
77 }
78
79 int libelf_type(void *elf) {
80         return libelf_iself(elf) ? libelf_header(elf)->e_type : 0;
81 }
82
83 int libelf_iself(void *elf) {
84         Elf64_Ehdr *hdr;
85         hdr = elf;
86         if (hdr->e_ident[EI_MAG0] != ELFMAG0
87                         || hdr->e_ident[EI_MAG1] != ELFMAG1
88                         || hdr->e_ident[EI_MAG2] != ELFMAG2
89                         || hdr->e_ident[EI_MAG3] != ELFMAG3
90            ) {
91                 return 0;
92         }
93         return 1;
94 }
95
96 void *libelf_map(char *path, size_t *fsize) {
97         int elffd;
98         struct stat sbuf;
99         void *elfbase;
100
101         errno = 0;
102
103         elffd = open(path, O_RDONLY);
104         if (elffd == -1) {
105                 perror("open");
106                 return NULL;
107         }
108         if (fstat(elffd, &sbuf) == -1) {
109                 close(elffd);
110                 return NULL;
111         }
112         /* not a regular file? */
113         if (!S_ISREG(sbuf.st_mode)) {
114                 close(elffd);
115                 return NULL;
116         }
117         /* not at least the size of the elf header? */
118         if ((size_t)sbuf.st_size < sizeof(Elf64_Ehdr)) {
119                 close(elffd);
120                 return NULL;
121         }
122
123         elfbase = mmap(0, sbuf.st_size, PROT_READ,MAP_PRIVATE, elffd, 0);
124         close(elffd);
125         if (!elfbase) {
126                 return NULL;
127         }
128
129         if (!libelf_iself(elfbase)) {
130                 munmap(elfbase, sbuf.st_size);
131                 return NULL;
132         }
133
134         *fsize = sbuf.st_size;
135
136         return elfbase;
137 }
138
139 char *libelf_soname(void *elfbase) {
140         Elf64_Ehdr *hdr;
141         int i;
142         Elf64_Shdr *shdr;
143         Elf64_Shdr *dynsect = 0;
144         Elf64_Shdr *strtab = 0, *dyntab = 0;
145         char *name, *dynname;
146         Elf64_Dyn *dent;
147
148         if (!libelf_iself(elfbase)) {
149                 return 0;
150         }
151         hdr = libelf_header(elfbase);
152
153         /* only dynamic files will have an soname */
154         if (hdr->e_type != ET_DYN) {
155                 return 0;
156         }
157
158         switch (hdr->e_ident[EI_CLASS]) {
159                 case ELFCLASS64:
160                 case ELFCLASS32:
161                 case ELFCLASSNONE:
162                         break;
163                 default: return 0; break;
164         }
165
166         /* check endian ness */
167         switch (hdr->e_ident[EI_DATA]) {
168                 case ELFDATA2LSB: break;
169                 case ELFDATA2MSB: break;
170                 default: return 0; break;
171         }
172         
173         /* find the section header table */
174         for (i = 0; i < hdr->e_shnum; i++) {
175                 shdr = (Elf64_Shdr *)((char *)elfbase + hdr->e_shoff + i * hdr->e_shentsize);
176                 if (shdr->sh_type == SHT_DYNAMIC) {
177                         dynsect = shdr;
178                 } else if (shdr->sh_type == SHT_STRTAB && i == hdr->e_shstrndx) {
179                         strtab = shdr;
180                 }
181         }
182         if (!strtab) {
183                 return 0;
184         }
185         if (!dynsect) {
186                 return 0;
187         }
188
189         name = (char *) elfbase + strtab->sh_offset;
190         for (i = 0; i < hdr->e_shnum; i++) {
191                 shdr = (Elf64_Shdr *)((char *)elfbase + hdr->e_shoff + i * hdr->e_shentsize);
192                 if (shdr->sh_type == SHT_STRTAB && !strcmp(".dynstr", name+shdr->sh_name)) {
193                         dyntab = shdr;
194                 }
195         }
196         if (!dyntab) {
197                 return 0;
198         }
199
200         dynname = (char *) elfbase + dyntab->sh_offset;
201         for (dent = (Elf64_Dyn *)((char *)elfbase + dynsect->sh_offset); dent->d_tag != DT_NULL; dent++) {
202                 if (dent->d_tag == DT_SONAME) {
203                         return dynname + dent->d_un.d_val;
204                 }
205         }
206
207         return 0;
208 }