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