|
111
|
1 // import-archive.cc -- Go frontend read import data from an archive file.
|
|
|
2
|
|
|
3 // Copyright 2009 The Go Authors. All rights reserved.
|
|
|
4 // Use of this source code is governed by a BSD-style
|
|
|
5 // license that can be found in the LICENSE file.
|
|
|
6
|
|
|
7 #include "go-system.h"
|
|
|
8
|
|
|
9 #include "go-diagnostics.h"
|
|
|
10 #include "import.h"
|
|
|
11
|
|
|
12 #ifndef O_BINARY
|
|
|
13 #define O_BINARY 0
|
|
|
14 #endif
|
|
|
15
|
|
|
16 // Archive magic numbers.
|
|
|
17
|
|
|
18 static const char armag[] =
|
|
|
19 {
|
|
|
20 '!', '<', 'a', 'r', 'c', 'h', '>', '\n'
|
|
|
21 };
|
|
|
22
|
|
|
23 static const char armagt[] =
|
|
|
24 {
|
|
|
25 '!', '<', 't', 'h', 'i', 'n', '>', '\n'
|
|
|
26 };
|
|
|
27
|
|
|
28 static const char armagb[] =
|
|
|
29 {
|
|
|
30 '<', 'b', 'i', 'g', 'a', 'f', '>', '\n'
|
|
|
31 };
|
|
|
32
|
|
|
33 static const char arfmag[2] = { '`', '\n' };
|
|
|
34
|
|
|
35 // Archive fixed length header for AIX big format.
|
|
|
36
|
|
|
37 struct Archive_fl_header
|
|
|
38 {
|
|
|
39 // Archive magic string.
|
|
|
40 char fl_magic[8];
|
|
|
41 // Offset to member table.
|
|
|
42 char fl_memoff[20];
|
|
|
43 // Offset to global symbol table.
|
|
|
44 char fl_gstoff[20];
|
|
|
45 // Offset to global symbol table for 64-bit objects.
|
|
|
46 char fl_gst64off[20];
|
|
|
47 // Offset to first archive member.
|
|
|
48 char fl_fstmoff[20];
|
|
|
49 // Offset to last archive member.
|
|
|
50 char fl_lstmoff[20];
|
|
|
51 // Offset to first member on free list.
|
|
|
52 char fl_freeoff[20];
|
|
|
53 };
|
|
|
54
|
|
|
55 // The header of an entry in an archive. This is all readable text,
|
|
|
56 // padded with spaces where necesary.
|
|
|
57
|
|
|
58 struct Archive_header
|
|
|
59 {
|
|
|
60 // The entry name.
|
|
|
61 char ar_name[16];
|
|
|
62 // The file modification time.
|
|
|
63 char ar_date[12];
|
|
|
64 // The user's UID in decimal.
|
|
|
65 char ar_uid[6];
|
|
|
66 // The user's GID in decimal.
|
|
|
67 char ar_gid[6];
|
|
|
68 // The file mode in octal.
|
|
|
69 char ar_mode[8];
|
|
|
70 // The file size in decimal.
|
|
|
71 char ar_size[10];
|
|
|
72 // The final magic code.
|
|
|
73 char ar_fmag[2];
|
|
|
74 };
|
|
|
75
|
|
|
76 // The header of an entry in an AIX big archive.
|
|
|
77 // This is followed by ar_namlen bytes + 2 bytes for arfmag.
|
|
|
78
|
|
|
79 struct Archive_big_header
|
|
|
80 {
|
|
|
81 // The file size in decimal.
|
|
|
82 char ar_size[20];
|
|
|
83 // The next member offset in decimal.
|
|
|
84 char ar_nxtmem[20];
|
|
|
85 // The previous member offset in decimal.
|
|
|
86 char ar_prvmem[20];
|
|
|
87 // The file modification time in decimal.
|
|
|
88 char ar_date[12];
|
|
|
89 // The user's UID in decimal.
|
|
|
90 char ar_uid[12];
|
|
|
91 // The user's GID in decimal.
|
|
|
92 char ar_gid[12];
|
|
|
93 // The file mode in octal.
|
|
|
94 char ar_mode[12];
|
|
|
95 // The file name length in decimal.
|
|
|
96 char ar_namlen[4];
|
|
|
97 };
|
|
|
98
|
|
|
99 // The functions in this file extract Go export data from an archive.
|
|
|
100
|
|
|
101 const int Import::archive_magic_len;
|
|
|
102
|
|
|
103 // Return true if BYTES, which are from the start of the file, are an
|
|
|
104 // archive magic number.
|
|
|
105
|
|
|
106 bool
|
|
|
107 Import::is_archive_magic(const char* bytes)
|
|
|
108 {
|
|
|
109 return (memcmp(bytes, armag, Import::archive_magic_len) == 0
|
|
|
110 || memcmp(bytes, armagt, Import::archive_magic_len) == 0
|
|
|
111 || memcmp(bytes, armagb, Import::archive_magic_len) == 0);
|
|
|
112 }
|
|
|
113
|
|
|
114 // An object used to read an archive file.
|
|
|
115
|
|
|
116 class Archive_file
|
|
|
117 {
|
|
|
118 public:
|
|
|
119 Archive_file(const std::string& filename, int fd, Location location)
|
|
|
120 : filename_(filename), fd_(fd), filesize_(-1), first_member_offset_(0),
|
|
|
121 extended_names_(), is_thin_archive_(false), is_big_archive_(false),
|
|
|
122 location_(location), nested_archives_()
|
|
|
123 { }
|
|
|
124
|
|
|
125 // Initialize.
|
|
|
126 bool
|
|
|
127 initialize();
|
|
|
128
|
|
|
129 // Return the file name.
|
|
|
130 const std::string&
|
|
|
131 filename() const
|
|
|
132 { return this->filename_; }
|
|
|
133
|
|
|
134 // Get the file size.
|
|
|
135 off_t
|
|
|
136 filesize() const
|
|
|
137 { return this->filesize_; }
|
|
|
138
|
|
|
139 // Return the offset of the first member.
|
|
|
140 off_t
|
|
|
141 first_member_offset() const
|
|
|
142 { return this->first_member_offset_; }
|
|
|
143
|
|
|
144 // Return whether this is a thin archive.
|
|
|
145 bool
|
|
|
146 is_thin_archive() const
|
|
|
147 { return this->is_thin_archive_; }
|
|
|
148
|
|
|
149 // Return whether this is a big archive.
|
|
|
150 bool
|
|
|
151 is_big_archive() const
|
|
|
152 { return this->is_big_archive_; }
|
|
|
153
|
|
|
154 // Return the location of the import statement.
|
|
|
155 Location
|
|
|
156 location() const
|
|
|
157 { return this->location_; }
|
|
|
158
|
|
|
159 // Read bytes.
|
|
|
160 bool
|
|
|
161 read(off_t offset, off_t size, char*);
|
|
|
162
|
|
|
163 // Parse a decimal in readable text.
|
|
|
164 bool
|
|
|
165 parse_decimal(const char* str, off_t size, long* res) const;
|
|
|
166
|
|
|
167 // Read the archive header at OFF, setting *PNAME, *SIZE,
|
|
|
168 // *NESTED_OFF and *NEXT_OFF.
|
|
|
169 bool
|
|
|
170 read_header(off_t off, std::string* pname, off_t* size, off_t* nested_off,
|
|
|
171 off_t* next_off);
|
|
|
172
|
|
|
173 // Interpret the header of HDR, the header of the archive member at
|
|
|
174 // file offset OFF. Return whether it succeeded. Set *SIZE to the
|
|
|
175 // size of the member. Set *PNAME to the name of the member. Set
|
|
|
176 // *NESTED_OFF to the offset in a nested archive.
|
|
|
177 bool
|
|
|
178 interpret_header(const Archive_header* hdr, off_t off,
|
|
|
179 std::string* pname, off_t* size, off_t* nested_off) const;
|
|
|
180
|
|
|
181 // Get the file and offset for an archive member.
|
|
|
182 bool
|
|
|
183 get_file_and_offset(off_t off, const std::string& hdrname,
|
|
|
184 off_t nested_off, int* memfd, off_t* memoff,
|
|
|
185 std::string* memname);
|
|
|
186
|
|
|
187 private:
|
|
|
188 // Initialize a big archive (AIX)
|
|
|
189 bool
|
|
|
190 initialize_big_archive();
|
|
|
191
|
|
|
192 // Initialize a normal archive
|
|
|
193 bool
|
|
|
194 initialize_archive();
|
|
|
195
|
|
|
196 // Read the big archive header at OFF, setting *PNAME, *SIZE and *NEXT_OFF.
|
|
|
197 bool
|
|
|
198 read_big_archive_header(off_t off, std::string* pname,
|
|
|
199 off_t* size, off_t* next_off);
|
|
|
200
|
|
|
201 // Read the normal archive header at OFF, setting *PNAME, *SIZE,
|
|
|
202 // *NESTED_OFF and *NEXT_OFF.
|
|
|
203 bool
|
|
|
204 read_archive_header(off_t off, std::string* pname, off_t* size,
|
|
|
205 off_t* nested_off, off_t* next_off);
|
|
|
206
|
|
|
207 // For keeping track of open nested archives in a thin archive file.
|
|
|
208 typedef std::map<std::string, Archive_file*> Nested_archive_table;
|
|
|
209
|
|
|
210 // The name of the file.
|
|
|
211 std::string filename_;
|
|
|
212 // The file descriptor.
|
|
|
213 int fd_;
|
|
|
214 // The file size;
|
|
|
215 off_t filesize_;
|
|
|
216 // The first member offset;
|
|
|
217 off_t first_member_offset_;
|
|
|
218 // The extended name table.
|
|
|
219 std::string extended_names_;
|
|
|
220 // Whether this is a thin archive.
|
|
|
221 bool is_thin_archive_;
|
|
|
222 // Whether this is a big archive.
|
|
|
223 bool is_big_archive_;
|
|
|
224 // The location of the import statements.
|
|
|
225 Location location_;
|
|
|
226 // Table of nested archives.
|
|
|
227 Nested_archive_table nested_archives_;
|
|
|
228 };
|
|
|
229
|
|
|
230 bool
|
|
|
231 Archive_file::initialize()
|
|
|
232 {
|
|
|
233 struct stat st;
|
|
|
234 if (fstat(this->fd_, &st) < 0)
|
|
|
235 {
|
|
|
236 go_error_at(this->location_, "%s: %m", this->filename_.c_str());
|
|
|
237 return false;
|
|
|
238 }
|
|
|
239 this->filesize_ = st.st_size;
|
|
|
240
|
|
|
241 char buf[sizeof(armagt)];
|
|
|
242 if (::lseek(this->fd_, 0, SEEK_SET) < 0
|
|
|
243 || ::read(this->fd_, buf, sizeof(armagt)) != sizeof(armagt))
|
|
|
244 {
|
|
|
245 go_error_at(this->location_, "%s: %m", this->filename_.c_str());
|
|
|
246 return false;
|
|
|
247 }
|
|
|
248 if (memcmp(buf, armagt, sizeof(armagt)) == 0)
|
|
|
249 this->is_thin_archive_ = true;
|
|
|
250 else if (memcmp(buf, armagb, sizeof(armagb)) == 0)
|
|
|
251 this->is_big_archive_ = true;
|
|
|
252
|
|
|
253 if (this->is_big_archive_)
|
|
|
254 return this->initialize_big_archive();
|
|
|
255 else
|
|
|
256 return this->initialize_archive();
|
|
|
257 }
|
|
|
258
|
|
|
259 // Initialize a big archive (AIX).
|
|
|
260
|
|
|
261 bool
|
|
|
262 Archive_file::initialize_big_archive()
|
|
|
263 {
|
|
|
264 Archive_fl_header flhdr;
|
|
|
265
|
|
|
266 // Read the fixed length header.
|
|
|
267 if (::lseek(this->fd_, 0, SEEK_SET) < 0
|
|
|
268 || ::read(this->fd_, &flhdr, sizeof(flhdr)) != sizeof(flhdr))
|
|
|
269 {
|
|
|
270 go_error_at(this->location_, "%s: could not read archive header",
|
|
|
271 this->filename_.c_str());
|
|
|
272 return false;
|
|
|
273 }
|
|
|
274
|
|
|
275 // Parse offset of the first member.
|
|
|
276 long off;
|
|
|
277 if (!this->parse_decimal(flhdr.fl_fstmoff, sizeof(flhdr.fl_fstmoff), &off))
|
|
|
278 {
|
|
|
279 char* buf = new char[sizeof(flhdr.fl_fstmoff) + 1];
|
|
|
280 memcpy(buf, flhdr.fl_fstmoff, sizeof(flhdr.fl_fstmoff));
|
|
|
281 go_error_at(this->location_,
|
|
|
282 ("%s: malformed first member offset in archive header"
|
|
|
283 " (expected decimal, got %s)"),
|
|
|
284 this->filename_.c_str(), buf);
|
|
|
285 delete[] buf;
|
|
|
286 return false;
|
|
|
287 }
|
|
|
288 if (off == 0) // Empty archive.
|
|
|
289 this->first_member_offset_ = this->filesize_;
|
|
|
290 else
|
|
|
291 this->first_member_offset_ = off;
|
|
|
292 return true;
|
|
|
293 }
|
|
|
294
|
|
|
295 // Initialize a normal archive.
|
|
|
296
|
|
|
297 bool
|
|
|
298 Archive_file::initialize_archive()
|
|
|
299 {
|
|
|
300 this->first_member_offset_ = sizeof(armag);
|
|
|
301 if (this->first_member_offset_ == this->filesize_)
|
|
|
302 {
|
|
|
303 // Empty archive.
|
|
|
304 return true;
|
|
|
305 }
|
|
|
306
|
|
|
307 // Look for the extended name table.
|
|
|
308 std::string filename;
|
|
|
309 off_t size;
|
|
|
310 off_t next_off;
|
|
|
311 if (!this->read_header(this->first_member_offset_, &filename,
|
|
|
312 &size, NULL, &next_off))
|
|
|
313 return false;
|
|
|
314 if (filename.empty())
|
|
|
315 {
|
|
|
316 // We found the symbol table.
|
|
|
317 if (!this->read_header(next_off, &filename, &size, NULL, NULL))
|
|
|
318 filename.clear();
|
|
|
319 }
|
|
|
320 if (filename == "/")
|
|
|
321 {
|
|
|
322 char* rdbuf = new char[size];
|
|
|
323 if (::read(this->fd_, rdbuf, size) != size)
|
|
|
324 {
|
|
|
325 go_error_at(this->location_, "%s: could not read extended names",
|
|
|
326 filename.c_str());
|
|
|
327 delete[] rdbuf;
|
|
|
328 return false;
|
|
|
329 }
|
|
|
330 this->extended_names_.assign(rdbuf, size);
|
|
|
331 delete[] rdbuf;
|
|
|
332 }
|
|
|
333
|
|
|
334 return true;
|
|
|
335 }
|
|
|
336
|
|
|
337 // Read bytes from the file.
|
|
|
338
|
|
|
339 bool
|
|
|
340 Archive_file::read(off_t offset, off_t size, char* buf)
|
|
|
341 {
|
|
|
342 if (::lseek(this->fd_, offset, SEEK_SET) < 0
|
|
|
343 || ::read(this->fd_, buf, size) != size)
|
|
|
344 {
|
|
|
345 go_error_at(this->location_, "%s: %m", this->filename_.c_str());
|
|
|
346 return false;
|
|
|
347 }
|
|
|
348 return true;
|
|
|
349 }
|
|
|
350
|
|
|
351 // Parse a decimal in readable text.
|
|
|
352
|
|
|
353 bool
|
|
|
354 Archive_file::parse_decimal(const char* str, off_t size, long* res) const
|
|
|
355 {
|
|
|
356 char* buf = new char[size + 1];
|
|
|
357 memcpy(buf, str, size);
|
|
|
358 char* ps = buf + size;
|
|
|
359 while (ps > buf && ps[-1] == ' ')
|
|
|
360 --ps;
|
|
|
361 *ps = '\0';
|
|
|
362
|
|
|
363 errno = 0;
|
|
|
364 char* end;
|
|
|
365 *res = strtol(buf, &end, 10);
|
|
|
366 if (*end != '\0'
|
|
|
367 || *res < 0
|
|
|
368 || (*res == LONG_MAX && errno == ERANGE))
|
|
|
369 {
|
|
|
370 delete[] buf;
|
|
|
371 return false;
|
|
|
372 }
|
|
|
373 delete[] buf;
|
|
|
374 return true;
|
|
|
375 }
|
|
|
376
|
|
|
377 // Read the header at OFF. Set *PNAME to the name, *SIZE to the size,
|
|
|
378 // *NESTED_OFF to the nested offset, and *NEXT_OFF to the next member offset.
|
|
|
379
|
|
|
380 bool
|
|
|
381 Archive_file::read_header(off_t off, std::string* pname, off_t* size,
|
|
|
382 off_t* nested_off, off_t* next_off)
|
|
|
383 {
|
|
|
384 if (::lseek(this->fd_, off, SEEK_SET) < 0)
|
|
|
385 {
|
|
|
386 go_error_at(this->location_, "%s: %m", this->filename_.c_str());
|
|
|
387 return false;
|
|
|
388 }
|
|
|
389 if (this->is_big_archive_)
|
|
|
390 return this->read_big_archive_header(off, pname, size, next_off);
|
|
|
391 else
|
|
|
392 return this->read_archive_header(off, pname, size, nested_off, next_off);
|
|
|
393 }
|
|
|
394
|
|
|
395 // Read the big archive header at OFF, setting *PNAME, *SIZE and *NEXT_OFF.
|
|
|
396
|
|
|
397 bool
|
|
|
398 Archive_file::read_big_archive_header(off_t off, std::string* pname,
|
|
|
399 off_t* size, off_t* next_off)
|
|
|
400 {
|
|
|
401 Archive_big_header hdr;
|
|
|
402 ssize_t got;
|
|
|
403
|
|
|
404 got = ::read(this->fd_, &hdr, sizeof hdr);
|
|
|
405 if (got != sizeof hdr)
|
|
|
406 {
|
|
|
407 if (got < 0)
|
|
|
408 go_error_at(this->location_, "%s: %m", this->filename_.c_str());
|
|
|
409 else if (got > 0)
|
|
|
410 go_error_at(this->location_, "%s: short entry header at %ld",
|
|
|
411 this->filename_.c_str(), static_cast<long>(off));
|
|
|
412 else
|
|
|
413 go_error_at(this->location_, "%s: unexpected EOF at %ld",
|
|
|
414 this->filename_.c_str(), static_cast<long>(off));
|
|
|
415 }
|
|
|
416
|
|
|
417 long local_size;
|
|
|
418 if (!this->parse_decimal(hdr.ar_size, sizeof(hdr.ar_size), &local_size))
|
|
|
419 {
|
|
|
420 char* buf = new char[sizeof(hdr.ar_size) + 1];
|
|
|
421 memcpy(buf, hdr.ar_size, sizeof(hdr.ar_size));
|
|
|
422 go_error_at(this->location_,
|
|
|
423 ("%s: malformed ar_size in entry header at %ld"
|
|
|
424 " (expected decimal, got %s)"),
|
|
|
425 this->filename_.c_str(), static_cast<long>(off), buf);
|
|
|
426 delete[] buf;
|
|
|
427 return false;
|
|
|
428 }
|
|
|
429 *size = local_size;
|
|
|
430
|
|
|
431 long namlen;
|
|
|
432 if (!this->parse_decimal(hdr.ar_namlen, sizeof(hdr.ar_namlen), &namlen))
|
|
|
433 {
|
|
|
434 char* buf = new char[sizeof(hdr.ar_namlen) + 1];
|
|
|
435 memcpy(buf, hdr.ar_namlen, sizeof(hdr.ar_namlen));
|
|
|
436 go_error_at(this->location_,
|
|
|
437 ("%s: malformed ar_namlen in entry header at %ld"
|
|
|
438 " (expected decimal, got %s)"),
|
|
|
439 this->filename_.c_str(), static_cast<long>(off), buf);
|
|
|
440 delete[] buf;
|
|
|
441 return false;
|
|
|
442 }
|
|
|
443 // Read member name following member header.
|
|
|
444 char* rdbuf = new char[namlen];
|
|
|
445 got = ::read(this->fd_, rdbuf, namlen);
|
|
|
446 if (got != namlen)
|
|
|
447 {
|
|
|
448 go_error_at(this->location_,
|
|
|
449 "%s: malformed member name in entry header at %ld",
|
|
|
450 this->filename_.c_str(), static_cast<long>(off));
|
|
|
451 delete[] rdbuf;
|
|
|
452 return false;
|
|
|
453 }
|
|
|
454 pname->assign(rdbuf, namlen);
|
|
|
455 delete[] rdbuf;
|
|
|
456
|
|
|
457 long local_next_off;
|
|
|
458 if (!this->parse_decimal(hdr.ar_nxtmem, sizeof(hdr.ar_nxtmem), &local_next_off))
|
|
|
459 {
|
|
|
460 char* buf = new char[sizeof(hdr.ar_nxtmem) + 1];
|
|
|
461 memcpy(buf, hdr.ar_nxtmem, sizeof(hdr.ar_nxtmem));
|
|
|
462 go_error_at(this->location_,
|
|
|
463 ("%s: malformed ar_nxtmem in entry header at %ld"
|
|
|
464 " (expected decimal, got %s)"),
|
|
|
465 this->filename_.c_str(), static_cast<long>(off), buf);
|
|
|
466 delete[] buf;
|
|
|
467 return false;
|
|
|
468 }
|
|
|
469 if (next_off != NULL)
|
|
|
470 {
|
|
|
471 if (local_next_off == 0) // Last member.
|
|
|
472 *next_off = this->filesize_;
|
|
|
473 else
|
|
|
474 *next_off = local_next_off;
|
|
|
475 }
|
|
|
476 return true;
|
|
|
477 }
|
|
|
478
|
|
|
479 // Read the normal archive header at OFF, setting *PNAME, *SIZE,
|
|
|
480 // *NESTED_OFF and *NEXT_OFF.
|
|
|
481
|
|
|
482 bool
|
|
|
483 Archive_file::read_archive_header(off_t off, std::string* pname, off_t* size,
|
|
|
484 off_t* nested_off, off_t* next_off)
|
|
|
485 {
|
|
|
486 Archive_header hdr;
|
|
|
487 ssize_t got = ::read(this->fd_, &hdr, sizeof hdr);
|
|
|
488 if (got != sizeof hdr)
|
|
|
489 {
|
|
|
490 if (got < 0)
|
|
|
491 go_error_at(this->location_, "%s: %m", this->filename_.c_str());
|
|
|
492 else if (got > 0)
|
|
|
493 go_error_at(this->location_, "%s: short archive header at %ld",
|
|
|
494 this->filename_.c_str(), static_cast<long>(off));
|
|
|
495 else
|
|
|
496 go_error_at(this->location_, "%s: unexpected EOF at %ld",
|
|
|
497 this->filename_.c_str(), static_cast<long>(off));
|
|
|
498 }
|
|
|
499 off_t local_nested_off;
|
|
|
500 if (!this->interpret_header(&hdr, off, pname, size, &local_nested_off))
|
|
|
501 return false;
|
|
|
502 if (nested_off != NULL)
|
|
|
503 *nested_off = local_nested_off;
|
|
|
504
|
|
|
505 off_t local_next_off;
|
|
|
506 local_next_off = off + sizeof(Archive_header);
|
|
|
507 if (!this->is_thin_archive_ || pname->empty() || *pname == "/")
|
|
|
508 local_next_off += *size;
|
|
|
509 if ((local_next_off & 1) != 0)
|
|
|
510 ++local_next_off;
|
|
|
511 if (local_next_off > this->filesize_) // Last member.
|
|
|
512 local_next_off = this->filesize_;
|
|
|
513 if (next_off != NULL)
|
|
|
514 *next_off = local_next_off;
|
|
|
515 return true;
|
|
|
516 }
|
|
|
517
|
|
|
518 // Interpret the header of HDR, the header of the archive member at
|
|
|
519 // file offset OFF.
|
|
|
520
|
|
|
521 bool
|
|
|
522 Archive_file::interpret_header(const Archive_header* hdr, off_t off,
|
|
|
523 std::string* pname, off_t* size,
|
|
|
524 off_t* nested_off) const
|
|
|
525 {
|
|
|
526 if (memcmp(hdr->ar_fmag, arfmag, sizeof arfmag) != 0)
|
|
|
527 {
|
|
|
528 go_error_at(this->location_, "%s: malformed archive header at %lu",
|
|
|
529 this->filename_.c_str(), static_cast<unsigned long>(off));
|
|
|
530 return false;
|
|
|
531 }
|
|
|
532
|
|
|
533 long local_size;
|
|
|
534 if (!this->parse_decimal(hdr->ar_size, sizeof hdr->ar_size, &local_size))
|
|
|
535 {
|
|
|
536 go_error_at(this->location_, "%s: malformed archive header size at %lu",
|
|
|
537 this->filename_.c_str(), static_cast<unsigned long>(off));
|
|
|
538 return false;
|
|
|
539 }
|
|
|
540 *size = local_size;
|
|
|
541
|
|
|
542 *nested_off = 0;
|
|
|
543 if (hdr->ar_name[0] != '/')
|
|
|
544 {
|
|
|
545 const char* name_end = strchr(hdr->ar_name, '/');
|
|
|
546 if (name_end == NULL
|
|
|
547 || name_end - hdr->ar_name >= static_cast<int>(sizeof hdr->ar_name))
|
|
|
548 {
|
|
|
549 go_error_at(this->location_,
|
|
|
550 "%s: malformed archive header name at %lu",
|
|
|
551 this->filename_.c_str(), static_cast<unsigned long>(off));
|
|
|
552 return false;
|
|
|
553 }
|
|
|
554 pname->assign(hdr->ar_name, name_end - hdr->ar_name);
|
|
|
555 }
|
|
|
556 else if (hdr->ar_name[1] == ' ')
|
|
|
557 {
|
|
|
558 // This is the symbol table.
|
|
|
559 pname->clear();
|
|
|
560 }
|
|
|
561 else if (hdr->ar_name[1] == 'S' && hdr->ar_name[2] == 'Y'
|
|
|
562 && hdr->ar_name[3] == 'M' && hdr->ar_name[4] == '6'
|
|
|
563 && hdr->ar_name[5] == '4' && hdr->ar_name[6] == '/'
|
|
|
564 && hdr->ar_name[7] == ' '
|
|
|
565 )
|
|
|
566 {
|
|
|
567 // 64-bit symbol table.
|
|
|
568 pname->clear();
|
|
|
569 }
|
|
|
570 else if (hdr->ar_name[1] == '/')
|
|
|
571 {
|
|
|
572 // This is the extended name table.
|
|
|
573 pname->assign(1, '/');
|
|
|
574 }
|
|
|
575 else
|
|
|
576 {
|
|
|
577 char* end;
|
|
|
578 errno = 0;
|
|
|
579 long x = strtol(hdr->ar_name + 1, &end, 10);
|
|
|
580 long y = 0;
|
|
|
581 if (*end == ':')
|
|
|
582 y = strtol(end + 1, &end, 10);
|
|
|
583 if (*end != ' '
|
|
|
584 || x < 0
|
|
|
585 || (x == LONG_MAX && errno == ERANGE)
|
|
|
586 || static_cast<size_t>(x) >= this->extended_names_.size())
|
|
|
587 {
|
|
|
588 go_error_at(this->location_, "%s: bad extended name index at %lu",
|
|
|
589 this->filename_.c_str(), static_cast<unsigned long>(off));
|
|
|
590 return false;
|
|
|
591 }
|
|
|
592
|
|
|
593 const char* name = this->extended_names_.data() + x;
|
|
|
594 const char* name_end = strchr(name, '\n');
|
|
|
595 if (static_cast<size_t>(name_end - name) > this->extended_names_.size()
|
|
|
596 || name_end[-1] != '/')
|
|
|
597 {
|
|
|
598 go_error_at(this->location_,
|
|
|
599 "%s: bad extended name entry at header %lu",
|
|
|
600 this->filename_.c_str(), static_cast<unsigned long>(off));
|
|
|
601 return false;
|
|
|
602 }
|
|
|
603 pname->assign(name, name_end - 1 - name);
|
|
|
604 *nested_off = y;
|
|
|
605 }
|
|
|
606
|
|
|
607 return true;
|
|
|
608 }
|
|
|
609
|
|
|
610 // Get the file and offset for an archive member.
|
|
|
611
|
|
|
612 bool
|
|
|
613 Archive_file::get_file_and_offset(off_t off, const std::string& hdrname,
|
|
|
614 off_t nested_off, int* memfd, off_t* memoff,
|
|
|
615 std::string* memname)
|
|
|
616 {
|
|
|
617 if (this->is_big_archive_)
|
|
|
618 {
|
|
|
619 *memfd = this->fd_;
|
|
|
620 *memoff = (off + sizeof(Archive_big_header) + hdrname.length()
|
|
|
621 + sizeof(arfmag));
|
|
|
622 if ((*memoff & 1) != 0)
|
|
|
623 ++*memoff;
|
|
|
624 *memname = this->filename_ + '(' + hdrname + ')';
|
|
|
625 return true;
|
|
|
626 }
|
|
|
627 else if (!this->is_thin_archive_)
|
|
|
628 {
|
|
|
629 *memfd = this->fd_;
|
|
|
630 *memoff = off + sizeof(Archive_header);
|
|
|
631 *memname = this->filename_ + '(' + hdrname + ')';
|
|
|
632 return true;
|
|
|
633 }
|
|
|
634
|
|
|
635 std::string filename = hdrname;
|
|
|
636 if (!IS_ABSOLUTE_PATH(filename.c_str()))
|
|
|
637 {
|
|
|
638 const char* archive_path = this->filename_.c_str();
|
|
|
639 const char* basename = lbasename(archive_path);
|
|
|
640 if (basename > archive_path)
|
|
|
641 filename.replace(0, 0,
|
|
|
642 this->filename_.substr(0, basename - archive_path));
|
|
|
643 }
|
|
|
644
|
|
|
645 if (nested_off > 0)
|
|
|
646 {
|
|
|
647 // This is a member of a nested archive.
|
|
|
648 Archive_file* nfile;
|
|
|
649 Nested_archive_table::const_iterator p =
|
|
|
650 this->nested_archives_.find(filename);
|
|
|
651 if (p != this->nested_archives_.end())
|
|
|
652 nfile = p->second;
|
|
|
653 else
|
|
|
654 {
|
|
|
655 int nfd = open(filename.c_str(), O_RDONLY | O_BINARY);
|
|
|
656 if (nfd < 0)
|
|
|
657 {
|
|
|
658 go_error_at(this->location_, "%s: can't open nested archive %s",
|
|
|
659 this->filename_.c_str(), filename.c_str());
|
|
|
660 return false;
|
|
|
661 }
|
|
|
662 nfile = new Archive_file(filename, nfd, this->location_);
|
|
|
663 if (!nfile->initialize())
|
|
|
664 {
|
|
|
665 delete nfile;
|
|
|
666 return false;
|
|
|
667 }
|
|
|
668 this->nested_archives_[filename] = nfile;
|
|
|
669 }
|
|
|
670
|
|
|
671 std::string nname;
|
|
|
672 off_t nsize;
|
|
|
673 off_t nnested_off;
|
|
|
674 if (!nfile->read_header(nested_off, &nname, &nsize, &nnested_off, NULL))
|
|
|
675 return false;
|
|
|
676 return nfile->get_file_and_offset(nested_off, nname, nnested_off,
|
|
|
677 memfd, memoff, memname);
|
|
|
678 }
|
|
|
679
|
|
|
680 // An external member of a thin archive.
|
|
|
681 *memfd = open(filename.c_str(), O_RDONLY | O_BINARY);
|
|
|
682 if (*memfd < 0)
|
|
|
683 {
|
|
|
684 go_error_at(this->location_, "%s: %m", filename.c_str());
|
|
|
685 return false;
|
|
|
686 }
|
|
|
687 *memoff = 0;
|
|
|
688 *memname = filename;
|
|
|
689 return true;
|
|
|
690 }
|
|
|
691
|
|
|
692 // An archive member iterator. This is more-or-less copied from gold.
|
|
|
693
|
|
|
694 class Archive_iterator
|
|
|
695 {
|
|
|
696 public:
|
|
|
697 // The header of an archive member. This is what this iterator
|
|
|
698 // points to.
|
|
|
699 struct Header
|
|
|
700 {
|
|
|
701 // The name of the member.
|
|
|
702 std::string name;
|
|
|
703 // The file offset of the member.
|
|
|
704 off_t off;
|
|
|
705 // The file offset of a nested archive member.
|
|
|
706 off_t nested_off;
|
|
|
707 // The size of the member.
|
|
|
708 off_t size;
|
|
|
709 };
|
|
|
710
|
|
|
711 Archive_iterator(Archive_file* afile, off_t off)
|
|
|
712 : afile_(afile), off_(off)
|
|
|
713 { this->read_next_header(); }
|
|
|
714
|
|
|
715 const Header&
|
|
|
716 operator*() const
|
|
|
717 { return this->header_; }
|
|
|
718
|
|
|
719 const Header*
|
|
|
720 operator->() const
|
|
|
721 { return &this->header_; }
|
|
|
722
|
|
|
723 Archive_iterator&
|
|
|
724 operator++()
|
|
|
725 {
|
|
|
726 if (this->off_ == this->afile_->filesize())
|
|
|
727 return *this;
|
|
|
728 this->off_ = this->next_off_;
|
|
|
729 this->read_next_header();
|
|
|
730 return *this;
|
|
|
731 }
|
|
|
732
|
|
|
733 Archive_iterator
|
|
|
734 operator++(int)
|
|
|
735 {
|
|
|
736 Archive_iterator ret = *this;
|
|
|
737 ++*this;
|
|
|
738 return ret;
|
|
|
739 }
|
|
|
740
|
|
|
741 bool
|
|
|
742 operator==(const Archive_iterator& p) const
|
|
|
743 { return this->off_ == p->off; }
|
|
|
744
|
|
|
745 bool
|
|
|
746 operator!=(const Archive_iterator& p) const
|
|
|
747 { return this->off_ != p->off; }
|
|
|
748
|
|
|
749 private:
|
|
|
750 void
|
|
|
751 read_next_header();
|
|
|
752
|
|
|
753 // The underlying archive file.
|
|
|
754 Archive_file* afile_;
|
|
|
755 // The current offset in the file.
|
|
|
756 off_t off_;
|
|
|
757 // The offset of the next member.
|
|
|
758 off_t next_off_;
|
|
|
759 // The current archive header.
|
|
|
760 Header header_;
|
|
|
761 };
|
|
|
762
|
|
|
763 // Read the next archive header.
|
|
|
764
|
|
|
765 void
|
|
|
766 Archive_iterator::read_next_header()
|
|
|
767 {
|
|
|
768 off_t filesize = this->afile_->filesize();
|
|
|
769 while (true)
|
|
|
770 {
|
|
|
771 if (this->off_ == filesize)
|
|
|
772 {
|
|
|
773 this->header_.off = filesize;
|
|
|
774 return;
|
|
|
775 }
|
|
|
776
|
|
|
777 if (!this->afile_->read_header(this->off_, &this->header_.name,
|
|
|
778 &this->header_.size,
|
|
|
779 &this->header_.nested_off,
|
|
|
780 &this->next_off_))
|
|
|
781 {
|
|
|
782 this->header_.off = filesize;
|
|
|
783 return;
|
|
|
784 }
|
|
|
785 this->header_.off = this->off_;
|
|
|
786
|
|
|
787 // Skip special members.
|
|
|
788 if (!this->header_.name.empty() && this->header_.name != "/")
|
|
|
789 return;
|
|
|
790
|
|
|
791 this->off_ = this->next_off_;
|
|
|
792 }
|
|
|
793 }
|
|
|
794
|
|
|
795 // Initial iterator.
|
|
|
796
|
|
|
797 Archive_iterator
|
|
|
798 archive_begin(Archive_file* afile)
|
|
|
799 {
|
|
|
800 return Archive_iterator(afile, afile->first_member_offset());
|
|
|
801 }
|
|
|
802
|
|
|
803 // Final iterator.
|
|
|
804
|
|
|
805 Archive_iterator
|
|
|
806 archive_end(Archive_file* afile)
|
|
|
807 {
|
|
|
808 return Archive_iterator(afile, afile->filesize());
|
|
|
809 }
|
|
|
810
|
|
|
811 // A type of Import_stream which concatenates other Import_streams
|
|
|
812 // together.
|
|
|
813
|
|
|
814 class Stream_concatenate : public Import::Stream
|
|
|
815 {
|
|
|
816 public:
|
|
|
817 Stream_concatenate()
|
|
|
818 : inputs_()
|
|
|
819 { }
|
|
|
820
|
|
|
821 // Add a new stream.
|
|
|
822 void
|
|
|
823 add(Import::Stream* is)
|
|
|
824 { this->inputs_.push_back(is); }
|
|
|
825
|
|
|
826 protected:
|
|
|
827 bool
|
|
|
828 do_peek(size_t, const char**);
|
|
|
829
|
|
|
830 void
|
|
|
831 do_advance(size_t);
|
|
|
832
|
|
|
833 private:
|
|
|
834 std::list<Import::Stream*> inputs_;
|
|
|
835 };
|
|
|
836
|
|
|
837 // Peek ahead.
|
|
|
838
|
|
|
839 bool
|
|
|
840 Stream_concatenate::do_peek(size_t length, const char** bytes)
|
|
|
841 {
|
|
|
842 while (true)
|
|
|
843 {
|
|
|
844 if (this->inputs_.empty())
|
|
|
845 return false;
|
|
|
846 if (this->inputs_.front()->peek(length, bytes))
|
|
|
847 return true;
|
|
|
848 delete this->inputs_.front();
|
|
|
849 this->inputs_.pop_front();
|
|
|
850 }
|
|
|
851 }
|
|
|
852
|
|
|
853 // Advance.
|
|
|
854
|
|
|
855 void
|
|
|
856 Stream_concatenate::do_advance(size_t skip)
|
|
|
857 {
|
|
|
858 while (true)
|
|
|
859 {
|
|
|
860 if (this->inputs_.empty())
|
|
|
861 return;
|
|
|
862 if (!this->inputs_.front()->at_eof())
|
|
|
863 {
|
|
|
864 // We just assume that this will do the right thing. It
|
|
|
865 // should be OK since we should never want to skip past
|
|
|
866 // multiple streams.
|
|
|
867 this->inputs_.front()->advance(skip);
|
|
|
868 return;
|
|
|
869 }
|
|
|
870 delete this->inputs_.front();
|
|
|
871 this->inputs_.pop_front();
|
|
|
872 }
|
|
|
873 }
|
|
|
874
|
|
|
875 // Import data from an archive. We walk through the archive and
|
|
|
876 // import data from each member.
|
|
|
877
|
|
|
878 Import::Stream*
|
|
|
879 Import::find_archive_export_data(const std::string& filename, int fd,
|
|
|
880 Location location)
|
|
|
881 {
|
|
|
882 Archive_file afile(filename, fd, location);
|
|
|
883 if (!afile.initialize())
|
|
|
884 return NULL;
|
|
|
885
|
|
|
886 Stream_concatenate* ret = new Stream_concatenate;
|
|
|
887
|
|
|
888 bool any_data = false;
|
|
|
889 bool any_members = false;
|
|
|
890 Archive_iterator pend = archive_end(&afile);
|
|
|
891 for (Archive_iterator p = archive_begin(&afile); p != pend; p++)
|
|
|
892 {
|
|
|
893 any_members = true;
|
|
|
894 int member_fd;
|
|
|
895 off_t member_off;
|
|
|
896 std::string member_name;
|
|
|
897 if (!afile.get_file_and_offset(p->off, p->name, p->nested_off,
|
|
|
898 &member_fd, &member_off, &member_name))
|
|
|
899 return NULL;
|
|
|
900
|
|
|
901 Import::Stream* is = Import::find_object_export_data(member_name,
|
|
|
902 member_fd,
|
|
|
903 member_off,
|
|
|
904 location);
|
|
|
905 if (is != NULL)
|
|
|
906 {
|
|
|
907 ret->add(is);
|
|
|
908 any_data = true;
|
|
|
909 }
|
|
|
910 }
|
|
|
911
|
|
|
912 if (!any_members)
|
|
|
913 {
|
|
|
914 // It's normal to have an empty archive file when using gobuild.
|
|
|
915 return new Stream_from_string("");
|
|
|
916 }
|
|
|
917
|
|
|
918 if (!any_data)
|
|
|
919 {
|
|
|
920 delete ret;
|
|
|
921 return NULL;
|
|
|
922 }
|
|
|
923
|
|
|
924 return ret;
|
|
|
925 }
|
