|
0
|
1 /*
|
|
|
2 <URL:http://gcc.gnu.org/ml/gcc/1999-04n/msg01105.html>
|
|
|
3
|
|
|
4 Re: changing embedded RPATH in existing executables.
|
|
|
5
|
|
|
6 To: geoffk@ozemail.com.au
|
|
|
7 Subject: Re: changing embedded RPATH in existing executables.
|
|
|
8 From: <peeter_joot@VNET.IBM.COM> (peeter joot)
|
|
|
9 Date: Fri, 30 Apr 1999 16:14:44 -0400 (EDT)
|
|
|
10 Cc: peeterj@ca.ibm.com, egcs@cygnus.com, libc-hacker@cygnus.com, linux-gcc@vger.rutgers.edu
|
|
|
11 Reply-To: <peeter_joot@VNET.IBM.COM>
|
|
|
12
|
|
|
13 > _Changing_ is a little tricky, but the attached program strips rpaths
|
|
|
14 > from executables (I find it essential for debugging the binutils).
|
|
|
15 > It's endian-dependent, if you want this for x86 you can just change
|
|
|
16 > the occurrences of 'MSB' to 'LSB' and compile (I should really fix
|
|
|
17 > that).
|
|
|
18
|
|
|
19 Hi Geoff,
|
|
|
20
|
|
|
21 With your program as a guide (and some peeks into libbfd, elf.h, a bit
|
|
|
22 of the glibc dynamic loader code, objdump, and a hex-editor) I was able to
|
|
|
23 figure out enough to find and change the rpath string. That was fun!
|
|
|
24
|
|
|
25 This program assumes (unlike your original program) that there is only
|
|
|
26 one DT_RPATH tag in the dynamic section as even with multiple '-Wl,-rpath,'
|
|
|
27 commands in the link this seems to occur (they all get concatonated into
|
|
|
28 a : separated path).
|
|
|
29
|
|
|
30 Thanks for your help. If you want to use this on non-x86 you have to change
|
|
|
31 the occurances of LSB back to MSB:)
|
|
|
32
|
|
|
33 Peeter
|
|
|
34 --
|
|
|
35 */
|
|
|
36
|
|
|
37 #ifdef HAVE_CONFIG_H
|
|
|
38 # include "config.h"
|
|
|
39 #endif
|
|
|
40
|
|
|
41 #include <stdio.h>
|
|
|
42 #include <unistd.h>
|
|
|
43 #include <fcntl.h>
|
|
|
44 #include <elf.h>
|
|
|
45 #if defined(HAVE_LINK_H)
|
|
|
46 # include <link.h>
|
|
|
47 #endif /* HAVE_LINK_H */
|
|
|
48 #include <stdlib.h>
|
|
|
49 #include <string.h>
|
|
|
50 #include <sys/stat.h>
|
|
|
51 #include "protos.h"
|
|
|
52
|
|
|
53 /**
|
|
|
54 * Reads an ELF file, and reads or alters the RPATH setting.
|
|
|
55 *
|
|
|
56 * TODO:
|
|
|
57 * modify to add RPATH setting if none exists.
|
|
|
58 */
|
|
|
59
|
|
|
60
|
|
|
61 int
|
|
|
62 chrpath(const char *filename, const char *newpath, int convert)
|
|
|
63 {
|
|
|
64 int fd;
|
|
|
65 Elf_Ehdr ehdr;
|
|
|
66 int i;
|
|
|
67 Elf_Phdr phdr;
|
|
|
68 Elf_Shdr shdr;
|
|
|
69 Elf_Dyn *dyns;
|
|
|
70 int rpathoff;
|
|
|
71 char * strtab;
|
|
|
72 char * rpath;
|
|
|
73 unsigned int rpathlen;
|
|
|
74 int oflags;
|
|
|
75 int rpath_dyns_index;
|
|
|
76
|
|
|
77 if (NULL == newpath && 0 == convert)
|
|
|
78 oflags = O_RDONLY;
|
|
|
79 else
|
|
|
80 oflags = O_RDWR;
|
|
|
81
|
|
|
82 fd = elf_open(filename, oflags, &ehdr);
|
|
|
83 if (fd == -1)
|
|
|
84 {
|
|
|
85 perror ("elf_open");
|
|
|
86 return 1;
|
|
|
87 }
|
|
|
88
|
|
|
89 if (0 != elf_find_dynamic_section(fd, &ehdr, &phdr))
|
|
|
90 {
|
|
|
91 perror("found no dynamic section");
|
|
|
92 return 1;
|
|
|
93 }
|
|
|
94
|
|
|
95 dyns = malloc(phdr.p_filesz);
|
|
|
96 if (dyns == NULL)
|
|
|
97 {
|
|
|
98 perror ("allocating memory for dynamic section");
|
|
|
99 return 1;
|
|
|
100 }
|
|
|
101 memset(dyns, 0, phdr.p_filesz);
|
|
|
102 if (lseek(fd, phdr.p_offset, SEEK_SET) == -1
|
|
|
103 || read(fd, dyns, phdr.p_filesz) != (int)phdr.p_filesz)
|
|
|
104 {
|
|
|
105 perror ("reading dynamic section");
|
|
|
106 free(dyns);
|
|
|
107 return 1;
|
|
|
108 }
|
|
|
109
|
|
|
110 rpathoff = -1;
|
|
|
111 for ( rpath_dyns_index = 0; dyns[rpath_dyns_index].d_tag != DT_NULL;
|
|
|
112 ++rpath_dyns_index )
|
|
|
113 {
|
|
|
114 if ( elf_dynpath_tag(dyns[rpath_dyns_index].d_tag) )
|
|
|
115 {
|
|
|
116 rpathoff = dyns[rpath_dyns_index].d_un.d_ptr;
|
|
|
117 break;
|
|
|
118 }
|
|
|
119 }
|
|
|
120 if (rpathoff == -1)
|
|
|
121 {
|
|
|
122 printf("%s: no rpath or runpath tag found.\n", filename);
|
|
|
123 free(dyns);
|
|
|
124 return 2;
|
|
|
125 }
|
|
|
126
|
|
|
127 if (lseek(fd, ehdr.e_shoff, SEEK_SET) == -1)
|
|
|
128 {
|
|
|
129 perror ("positioning for sections");
|
|
|
130 free(dyns);
|
|
|
131 return 1;
|
|
|
132 }
|
|
|
133
|
|
|
134 for (i = 0; i < ehdr.e_shnum; i++)
|
|
|
135 {
|
|
|
136 if (read(fd, &shdr, sizeof(shdr)) != sizeof(shdr))
|
|
|
137 {
|
|
|
138 perror ("reading section header");
|
|
|
139 free(dyns);
|
|
|
140 return 1;
|
|
|
141 }
|
|
|
142 if (shdr.sh_type == SHT_STRTAB)
|
|
|
143 break;
|
|
|
144 }
|
|
|
145 if (i == ehdr.e_shnum)
|
|
|
146 {
|
|
|
147 fprintf (stderr, "No string table found.\n");
|
|
|
148 free(dyns);
|
|
|
149 return 2;
|
|
|
150 }
|
|
|
151 strtab = (char *)malloc(shdr.sh_size);
|
|
|
152 if (strtab == NULL)
|
|
|
153 {
|
|
|
154 perror ("allocating memory for string table");
|
|
|
155 free(dyns);
|
|
|
156 return 1;
|
|
|
157 }
|
|
|
158 memset(strtab, 0, shdr.sh_size);
|
|
|
159
|
|
|
160 if (lseek(fd, shdr.sh_offset, SEEK_SET) == -1)
|
|
|
161 {
|
|
|
162 perror ("positioning for string table");
|
|
|
163 free(strtab);
|
|
|
164 free(dyns);
|
|
|
165 return 1;
|
|
|
166 }
|
|
|
167 if (read(fd, strtab, shdr.sh_size) != (int)shdr.sh_size)
|
|
|
168 {
|
|
|
169 perror ("reading string table");
|
|
|
170 free(strtab);
|
|
|
171 free(dyns);
|
|
|
172 return 1;
|
|
|
173 }
|
|
|
174
|
|
|
175 if ((int)shdr.sh_size < rpathoff)
|
|
|
176 {
|
|
|
177 fprintf(stderr, "%s string offset not contained in string table",
|
|
|
178 elf_tagname(dyns[rpath_dyns_index].d_tag));
|
|
|
179 free(strtab);
|
|
|
180 free(dyns);
|
|
|
181 return 5;
|
|
|
182 }
|
|
|
183 rpath = strtab+rpathoff;
|
|
|
184
|
|
|
185 #if defined(DT_RUNPATH)
|
|
|
186 if (convert && dyns[rpath_dyns_index].d_tag == DT_RPATH)
|
|
|
187 {
|
|
|
188 dyns[rpath_dyns_index].d_tag = DT_RUNPATH;
|
|
|
189 if (lseek(fd, phdr.p_offset, SEEK_SET) == -1
|
|
|
190 || write(fd, dyns, phdr.p_filesz) != (int)phdr.p_filesz)
|
|
|
191 {
|
|
|
192 perror ("converting RPATH to RUNPATH");
|
|
|
193 return 1;
|
|
|
194 }
|
|
|
195 printf("%s: RPATH converted to RUNPATH\n", filename);
|
|
|
196 }
|
|
|
197 #endif /* DT_RUNPATH */
|
|
|
198
|
|
|
199 printf("%s: %s=%s\n", filename, elf_tagname(dyns[rpath_dyns_index].d_tag),
|
|
|
200 rpath);
|
|
|
201
|
|
|
202 if (NULL == newpath)
|
|
|
203 {
|
|
|
204 free(dyns);
|
|
|
205 free(strtab);
|
|
|
206 return 0;
|
|
|
207 }
|
|
|
208
|
|
|
209 rpathlen = strlen(rpath);
|
|
|
210
|
|
|
211 /*
|
|
|
212 * Calculate the maximum rpath length (will be equal to rpathlen unless
|
|
|
213 * we have previously truncated it).
|
|
|
214 */
|
|
|
215 for ( i = rpathoff + rpathlen ; (i < (int)shdr.sh_size
|
|
|
216 && strtab[i] == '\0') ; i++ )
|
|
|
217 ;
|
|
|
218 i--;
|
|
|
219
|
|
|
220 if (i > (int)(rpathoff + rpathlen))
|
|
|
221 rpathlen = i - rpathoff;
|
|
|
222
|
|
|
223 if (strlen(newpath) > rpathlen)
|
|
|
224 {
|
|
|
225 fprintf(stderr, "new rpath '%s' too large; maximum length %i\n",
|
|
|
226 newpath, rpathlen);
|
|
|
227 free(dyns);
|
|
|
228 free(strtab);
|
|
|
229 return 7;
|
|
|
230 }
|
|
|
231
|
|
|
232 memset(rpath, 0, rpathlen);
|
|
|
233 strcpy(rpath, newpath);
|
|
|
234
|
|
|
235 if (lseek(fd, shdr.sh_offset+rpathoff, SEEK_SET) == -1)
|
|
|
236 {
|
|
|
237 perror ("positioning for RPATH");
|
|
|
238 free(dyns);
|
|
|
239 free(strtab);
|
|
|
240 return 1;
|
|
|
241 }
|
|
|
242 if (write(fd, rpath, rpathlen) != (int)rpathlen)
|
|
|
243 {
|
|
|
244 perror ("writing RPATH");
|
|
|
245 free(dyns);
|
|
|
246 free(strtab);
|
|
|
247 return 1;
|
|
|
248 }
|
|
|
249 printf("%s: new %s: %s\n", filename,
|
|
|
250 elf_tagname(dyns[rpath_dyns_index].d_tag), rpath);
|
|
|
251
|
|
|
252 elf_close(fd);
|
|
|
253
|
|
|
254 free(dyns);
|
|
|
255 dyns = NULL;
|
|
|
256
|
|
|
257 free(strtab);
|
|
|
258
|
|
|
259 return 0;
|
|
|
260 }
|
