Index: head/usr.bin/ar/acpyacc.y =================================================================== --- head/usr.bin/ar/acpyacc.y (revision 339647) +++ head/usr.bin/ar/acpyacc.y (revision 339648) @@ -1,662 +1,663 @@ %{ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2008 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ar.h" #define TEMPLATE "arscp.XXXXXXXX" struct list { char *str; struct list *next; }; extern int yylex(void); static void yyerror(const char *); static void arscp_addlib(char *archive, struct list *list); static void arscp_addmod(struct list *list); static void arscp_clear(void); static int arscp_copy(int ifd, int ofd); static void arscp_create(char *in, char *out); static void arscp_delete(struct list *list); static void arscp_dir(char *archive, struct list *list, char *rlt); static void arscp_end(int eval); static void arscp_extract(struct list *list); static void arscp_free_argv(void); static void arscp_free_mlist(struct list *list); static void arscp_list(void); static struct list *arscp_mlist(struct list *list, char *str); static void arscp_mlist2argv(struct list *list); static int arscp_mlist_len(struct list *list); static void arscp_open(char *fname); static void arscp_prompt(void); static void arscp_replace(struct list *list); static void arscp_save(void); static int arscp_target_exist(void); extern int lineno; static struct bsdar *bsdar; static char *target; static char *tmpac; static int interactive; static int verbose; %} %token ADDLIB %token ADDMOD %token CLEAR %token CREATE %token DELETE %token DIRECTORY %token END %token EXTRACT %token LIST %token OPEN %token REPLACE %token VERBOSE %token SAVE %token LP %token RP %token COMMA %token EOL %token FNAME %type mod_list %union { char *str; struct list *list; } %% begin : { arscp_prompt(); } ar_script ; ar_script : cmd_list | ; mod_list : FNAME { $$ = arscp_mlist(NULL, $1); } | mod_list separator FNAME { $$ = arscp_mlist($1, $3); } ; separator : COMMA | ; cmd_list : rawcmd | cmd_list rawcmd ; rawcmd : cmd EOL { arscp_prompt(); } ; cmd : addlib_cmd | addmod_cmd | clear_cmd | create_cmd | delete_cmd | directory_cmd | end_cmd | extract_cmd | list_cmd | open_cmd | replace_cmd | verbose_cmd | save_cmd | invalid_cmd | empty_cmd | error ; addlib_cmd : ADDLIB FNAME LP mod_list RP { arscp_addlib($2, $4); } | ADDLIB FNAME { arscp_addlib($2, NULL); } ; addmod_cmd : ADDMOD mod_list { arscp_addmod($2); } ; clear_cmd : CLEAR { arscp_clear(); } ; create_cmd : CREATE FNAME { arscp_create(NULL, $2); } ; delete_cmd : DELETE mod_list { arscp_delete($2); } ; directory_cmd : DIRECTORY FNAME { arscp_dir($2, NULL, NULL); } | DIRECTORY FNAME LP mod_list RP { arscp_dir($2, $4, NULL); } | DIRECTORY FNAME LP mod_list RP FNAME { arscp_dir($2, $4, $6); } ; end_cmd : END { arscp_end(EX_OK); } ; extract_cmd : EXTRACT mod_list { arscp_extract($2); } ; list_cmd : LIST { arscp_list(); } ; open_cmd : OPEN FNAME { arscp_open($2); } ; replace_cmd : REPLACE mod_list { arscp_replace($2); } ; save_cmd : SAVE { arscp_save(); } ; verbose_cmd : VERBOSE { verbose = !verbose; } ; empty_cmd : ; invalid_cmd : FNAME { yyerror(NULL); } ; %% /* ARGSUSED */ static void yyerror(const char *s) { (void) s; printf("Syntax error in archive script, line %d\n", lineno); } /* * arscp_open first open an archive and check its validity. If the archive * format is valid, it calls arscp_create to create a temporary copy of * the archive. */ static void arscp_open(char *fname) { struct archive *a; struct archive_entry *entry; int r; if ((a = archive_read_new()) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_read_new failed"); archive_read_support_format_ar(a); AC(archive_read_open_filename(a, fname, DEF_BLKSZ)); if ((r = archive_read_next_header(a, &entry))) - bsdar_warnc(bsdar, 0, "%s", archive_error_string(a)); + bsdar_warnc(bsdar, archive_errno(a), "%s", + archive_error_string(a)); AC(archive_read_close(a)); AC(archive_read_free(a)); if (r != ARCHIVE_OK) return; arscp_create(fname, fname); } /* * Create archive. in != NULL indicate it's a OPEN cmd, and resulting * archive is based on modification of an existing one. If in == NULL, * we are in CREATE cmd and a new empty archive will be created. */ static void arscp_create(char *in, char *out) { struct archive *a; int ifd, ofd; /* Delete previously created temporary archive, if any. */ if (tmpac) { if (unlink(tmpac) < 0) bsdar_errc(bsdar, EX_IOERR, errno, "unlink failed"); free(tmpac); } tmpac = strdup(TEMPLATE); if (tmpac == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "strdup failed"); if ((ofd = mkstemp(tmpac)) < 0) bsdar_errc(bsdar, EX_IOERR, errno, "mkstemp failed"); if (in) { /* * Command OPEN creates a temporary copy of the * input archive. */ if ((ifd = open(in, O_RDONLY)) < 0) { bsdar_warnc(bsdar, errno, "open failed"); return; } if (arscp_copy(ifd, ofd)) { bsdar_warnc(bsdar, 0, "arscp_copy failed"); return; } close(ifd); close(ofd); } else { /* * Command CREATE creates an "empty" archive. * (archive with only global header) */ if ((a = archive_write_new()) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_write_new failed"); archive_write_set_format_ar_svr4(a); AC(archive_write_open_fd(a, ofd)); AC(archive_write_close(a)); AC(archive_write_free(a)); } /* Override previous target, if any. */ if (target) free(target); target = out; bsdar->filename = tmpac; } /* A file copying implementation using mmap. */ static int arscp_copy(int ifd, int ofd) { struct stat sb; char *buf, *p; ssize_t w; size_t bytes; if (fstat(ifd, &sb) < 0) { bsdar_warnc(bsdar, errno, "fstate failed"); return (1); } if ((p = mmap(NULL, sb.st_size, PROT_READ, MAP_SHARED, ifd, (off_t)0)) == MAP_FAILED) { bsdar_warnc(bsdar, errno, "mmap failed"); return (1); } for (buf = p, bytes = sb.st_size; bytes > 0; bytes -= w) { w = write(ofd, buf, bytes); if (w <= 0) { bsdar_warnc(bsdar, errno, "write failed"); break; } } if (munmap(p, sb.st_size) < 0) bsdar_errc(bsdar, EX_SOFTWARE, errno, "munmap failed"); if (bytes > 0) return (1); return (0); } /* * Add all modules of archive to current archive, if list != NULL, * only those modules specified in 'list' will be added. */ static void arscp_addlib(char *archive, struct list *list) { if (!arscp_target_exist()) return; arscp_mlist2argv(list); bsdar->addlib = archive; ar_mode_A(bsdar); arscp_free_argv(); arscp_free_mlist(list); } /* Add modules into current archive. */ static void arscp_addmod(struct list *list) { if (!arscp_target_exist()) return; arscp_mlist2argv(list); ar_mode_q(bsdar); arscp_free_argv(); arscp_free_mlist(list); } /* Delete modules from current archive. */ static void arscp_delete(struct list *list) { if (!arscp_target_exist()) return; arscp_mlist2argv(list); ar_mode_d(bsdar); arscp_free_argv(); arscp_free_mlist(list); } /* Extract modules from current archive. */ static void arscp_extract(struct list *list) { if (!arscp_target_exist()) return; arscp_mlist2argv(list); ar_mode_x(bsdar); arscp_free_argv(); arscp_free_mlist(list); } /* List modules of archive. (Simple Mode) */ static void arscp_list(void) { if (!arscp_target_exist()) return; bsdar->argc = 0; bsdar->argv = NULL; /* Always verbose. */ bsdar->options |= AR_V; ar_mode_t(bsdar); bsdar->options &= ~AR_V; } /* List modules of archive. (Advance Mode) */ static void arscp_dir(char *archive, struct list *list, char *rlt) { FILE *out; /* If rlt != NULL, redirect output to it */ out = NULL; if (rlt) { out = stdout; if ((stdout = fopen(rlt, "w")) == NULL) bsdar_errc(bsdar, EX_IOERR, errno, "fopen %s failed", rlt); } bsdar->filename = archive; if (list) arscp_mlist2argv(list); else { bsdar->argc = 0; bsdar->argv = NULL; } if (verbose) bsdar->options |= AR_V; ar_mode_t(bsdar); bsdar->options &= ~AR_V; if (rlt) { if (fclose(stdout) == EOF) bsdar_errc(bsdar, EX_IOERR, errno, "fclose %s failed", rlt); stdout = out; free(rlt); } free(archive); bsdar->filename = tmpac; arscp_free_argv(); arscp_free_mlist(list); } /* Replace modules of current archive. */ static void arscp_replace(struct list *list) { if (!arscp_target_exist()) return; arscp_mlist2argv(list); ar_mode_r(bsdar); arscp_free_argv(); arscp_free_mlist(list); } /* Rename the temporary archive to the target archive. */ static void arscp_save(void) { mode_t mask; if (target) { if (rename(tmpac, target) < 0) bsdar_errc(bsdar, EX_IOERR, errno, "rename failed"); /* * mkstemp creates temp files with mode 0600, here we * set target archive mode per process umask. */ mask = umask(0); umask(mask); if (chmod(target, 0666 & ~mask) < 0) bsdar_errc(bsdar, EX_IOERR, errno, "chmod failed"); free(tmpac); free(target); tmpac = NULL; target= NULL; bsdar->filename = NULL; } else bsdar_warnc(bsdar, 0, "no open output archive"); } /* * Discard all the contents of current archive. This is achieved by * invoking CREATE cmd on current archive. */ static void arscp_clear(void) { char *new_target; if (target) { new_target = strdup(target); if (new_target == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "strdup failed"); arscp_create(NULL, new_target); } } /* * Quit ar(1). Note that END cmd will not SAVE current archive * before exit. */ static void arscp_end(int eval) { if (target) free(target); if (tmpac) { if (unlink(tmpac) == -1) bsdar_errc(bsdar, EX_IOERR, errno, "unlink %s failed", tmpac); free(tmpac); } exit(eval); } /* * Check if target specified, i.e, whether OPEN or CREATE has been * issued by user. */ static int arscp_target_exist(void) { if (target) return (1); bsdar_warnc(bsdar, 0, "no open output archive"); return (0); } /* Construct module list. */ static struct list * arscp_mlist(struct list *list, char *str) { struct list *l; l = malloc(sizeof(*l)); if (l == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); l->str = str; l->next = list; return (l); } /* Calculate the length of a mlist. */ static int arscp_mlist_len(struct list *list) { int len; for(len = 0; list; list = list->next) len++; return (len); } /* Free the space allocated for mod_list. */ static void arscp_free_mlist(struct list *list) { struct list *l; /* Note that list->str was freed in arscp_free_argv. */ for(; list; list = l) { l = list->next; free(list); } } /* Convert mlist to argv array. */ static void arscp_mlist2argv(struct list *list) { char **argv; int i, n; n = arscp_mlist_len(list); argv = malloc(n * sizeof(*argv)); if (argv == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); /* Note that module names are stored in reverse order in mlist. */ for(i = n - 1; i >= 0; i--, list = list->next) { if (list == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "invalid mlist"); argv[i] = list->str; } bsdar->argc = n; bsdar->argv = argv; } /* Free space allocated for argv array and its elements. */ static void arscp_free_argv(void) { int i; for(i = 0; i < bsdar->argc; i++) free(bsdar->argv[i]); free(bsdar->argv); } /* Show a prompt if we are in interactive mode */ static void arscp_prompt(void) { if (interactive) { printf("AR >"); fflush(stdout); } } /* Main function for ar script mode. */ void ar_mode_script(struct bsdar *ar) { bsdar = ar; interactive = isatty(fileno(stdin)); while(yyparse()) { if (!interactive) arscp_end(1); } /* Script ends without END */ arscp_end(EX_OK); } Index: head/usr.bin/ar/ar.h =================================================================== --- head/usr.bin/ar/ar.h (revision 339647) +++ head/usr.bin/ar/ar.h (revision 339648) @@ -1,127 +1,127 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2007 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. * * $FreeBSD$ */ #define BSDAR_VERSION "1.1.0" /* * ar(1) options. */ #define AR_A 0x0001 /* position-after */ #define AR_B 0x0002 /* position-before */ #define AR_C 0x0004 /* creating new archive */ #define AR_CC 0x0008 /* do not overwrite when extracting */ #define AR_J 0x0010 /* bzip2 compression */ #define AR_O 0x0020 /* preserve original mtime when extracting */ #define AR_S 0x0040 /* write archive symbol table */ #define AR_SS 0x0080 /* do not write archive symbol table */ #define AR_TR 0x0100 /* only keep first 15 chars for member name */ #define AR_U 0x0200 /* only extract or update newer members.*/ #define AR_V 0x0400 /* verbose mode */ #define AR_Z 0x0800 /* gzip compression */ #define AR_D 0x1000 /* insert dummy mode, mtime, uid and gid */ #define DEF_BLKSZ 10240 /* default block size */ /* * Convenient wrapper for general libarchive error handling. */ -#define AC(CALL) do { \ - if ((CALL)) \ - bsdar_errc(bsdar, EX_SOFTWARE, 0, "%s", \ - archive_error_string(a)); \ +#define AC(CALL) do { \ + if ((CALL)) \ + bsdar_errc(bsdar, EX_SOFTWARE, archive_errno(a), "%s", \ + archive_error_string(a)); \ } while (0) /* * In-memory representation of archive member(object). */ struct ar_obj { char *name; /* member name */ void *maddr; /* mmap start address */ uid_t uid; /* user id */ gid_t gid; /* group id */ mode_t md; /* octal file permissions */ size_t size; /* member size */ time_t mtime; /* modification time */ int fd; /* file descriptor */ dev_t dev; /* inode's device */ ino_t ino; /* inode's number */ TAILQ_ENTRY(ar_obj) objs; }; /* * Structure encapsulates the "global" data for "ar" program. */ struct bsdar { const char *filename; /* archive name. */ const char *addlib; /* target of ADDLIB. */ const char *posarg; /* position arg for modifiers -a, -b. */ char mode; /* program mode */ int options; /* command line options */ const char *progname; /* program name */ int argc; char **argv; /* * Fields for the archive string table. */ char *as; /* buffer for archive string table. */ size_t as_sz; /* current size of as table. */ size_t as_cap; /* capacity of as table buffer. */ /* * Fields for the archive symbol table. */ uint32_t s_cnt; /* current number of symbols. */ uint32_t *s_so; /* symbol offset table. */ size_t s_so_cap; /* capacity of so table buffer. */ char *s_sn; /* symbol name table */ size_t s_sn_cap; /* capacity of sn table buffer. */ size_t s_sn_sz; /* current size of sn table. */ /* Current member's offset (relative to the end of pseudo members.) */ off_t rela_off; TAILQ_HEAD(, ar_obj) v_obj; /* object(member) list */ }; void bsdar_errc(struct bsdar *, int _eval, int _code, const char *fmt, ...) __dead2; void bsdar_warnc(struct bsdar *, int _code, const char *fmt, ...); void ar_mode_d(struct bsdar *bsdar); void ar_mode_m(struct bsdar *bsdar); void ar_mode_p(struct bsdar *bsdar); void ar_mode_q(struct bsdar *bsdar); void ar_mode_r(struct bsdar *bsdar); void ar_mode_s(struct bsdar *bsdar); void ar_mode_t(struct bsdar *bsdar); void ar_mode_x(struct bsdar *bsdar); void ar_mode_A(struct bsdar *bsdar); void ar_mode_script(struct bsdar *ar); Index: head/usr.bin/ar/read.c =================================================================== --- head/usr.bin/ar/read.c (revision 339647) +++ head/usr.bin/ar/read.c (revision 339648) @@ -1,214 +1,215 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2007 Kai Wang * Copyright (c) 2007 Tim Kientzle * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include "ar.h" static void read_archive(struct bsdar *bsdar, char mode); void ar_mode_p(struct bsdar *bsdar) { read_archive(bsdar, 'p'); } void ar_mode_t(struct bsdar *bsdar) { read_archive(bsdar, 't'); } void ar_mode_x(struct bsdar *bsdar) { read_archive(bsdar, 'x'); } /* * Handle read modes: 'x', 't' and 'p'. */ static void read_archive(struct bsdar *bsdar, char mode) { struct archive *a; struct archive_entry *entry; struct stat sb; struct tm *tp; const char *bname; const char *name; mode_t md; size_t size; time_t mtime; uid_t uid; gid_t gid; char **av; char buf[25]; char find; int flags, r, i; if ((a = archive_read_new()) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_read_new failed"); archive_read_support_format_ar(a); AC(archive_read_open_filename(a, bsdar->filename, DEF_BLKSZ)); for (;;) { r = archive_read_next_header(a, &entry); if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY || r == ARCHIVE_FATAL) - bsdar_warnc(bsdar, 0, "%s", archive_error_string(a)); + bsdar_warnc(bsdar, archive_errno(a), "%s", + archive_error_string(a)); if (r == ARCHIVE_EOF || r == ARCHIVE_FATAL) break; if (r == ARCHIVE_RETRY) { bsdar_warnc(bsdar, 0, "Retrying..."); continue; } if ((name = archive_entry_pathname(entry)) == NULL) break; /* Skip pseudo members. */ if (strcmp(name, "/") == 0 || strcmp(name, "//") == 0) continue; if (bsdar->argc > 0) { find = 0; for(i = 0; i < bsdar->argc; i++) { av = &bsdar->argv[i]; if (*av == NULL) continue; if ((bname = basename(*av)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "basename failed"); if (strcmp(bname, name) != 0) continue; *av = NULL; find = 1; break; } if (!find) continue; } if (mode == 't') { if (bsdar->options & AR_V) { md = archive_entry_mode(entry); uid = archive_entry_uid(entry); gid = archive_entry_gid(entry); size = archive_entry_size(entry); mtime = archive_entry_mtime(entry); (void)strmode(md, buf); (void)fprintf(stdout, "%s %6d/%-6d %8ju ", buf + 1, uid, gid, (uintmax_t)size); tp = localtime(&mtime); (void)strftime(buf, sizeof(buf), "%b %e %H:%M %Y", tp); (void)fprintf(stdout, "%s %s", buf, name); } else (void)fprintf(stdout, "%s", name); r = archive_read_data_skip(a); if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY || r == ARCHIVE_FATAL) { (void)fprintf(stdout, "\n"); - bsdar_warnc(bsdar, 0, "%s", + bsdar_warnc(bsdar, archive_errno(a), "%s", archive_error_string(a)); } if (r == ARCHIVE_FATAL) break; (void)fprintf(stdout, "\n"); } else { /* mode == 'x' || mode = 'p' */ if (mode == 'p') { if (bsdar->options & AR_V) { (void)fprintf(stdout, "\n<%s>\n\n", name); fflush(stdout); } r = archive_read_data_into_fd(a, 1); } else { /* mode == 'x' */ if (stat(name, &sb) != 0) { if (errno != ENOENT) { bsdar_warnc(bsdar, 0, "stat %s failed", bsdar->filename); continue; } } else { /* stat success, file exist */ if (bsdar->options & AR_CC) continue; if (bsdar->options & AR_U && archive_entry_mtime(entry) <= sb.st_mtime) continue; } if (bsdar->options & AR_V) (void)fprintf(stdout, "x - %s\n", name); /* Disallow absolute paths. */ if (name[0] == '/') { bsdar_warnc(bsdar, 0, "Absolute path '%s'", name); continue; } /* Basic path security flags. */ flags = ARCHIVE_EXTRACT_SECURE_SYMLINKS | ARCHIVE_EXTRACT_SECURE_NODOTDOT; if (bsdar->options & AR_O) flags |= ARCHIVE_EXTRACT_TIME; r = archive_read_extract(a, entry, flags); } if (r) - bsdar_warnc(bsdar, 0, "%s", + bsdar_warnc(bsdar, archive_errno(a), "%s", archive_error_string(a)); } } AC(archive_read_close(a)); AC(archive_read_free(a)); } Index: head/usr.bin/ar/write.c =================================================================== --- head/usr.bin/ar/write.c (revision 339647) +++ head/usr.bin/ar/write.c (revision 339648) @@ -1,921 +1,922 @@ /*- * SPDX-License-Identifier: BSD-2-Clause-FreeBSD * * Copyright (c) 2007 Kai Wang * All rights reserved. * * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the above copyright * notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright * notice, this list of conditions and the following disclaimer in the * documentation and/or other materials provided with the distribution. * * THIS SOFTWARE IS PROVIDED BY THE AUTHOR AND CONTRIBUTORS ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. */ #include __FBSDID("$FreeBSD$"); #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include "ar.h" #define _ARMAG_LEN 8 /* length of ar magic string */ #define _ARHDR_LEN 60 /* length of ar header */ #define _INIT_AS_CAP 128 /* initial archive string table size */ #define _INIT_SYMOFF_CAP (256*(sizeof(uint32_t))) /* initial so table size */ #define _INIT_SYMNAME_CAP 1024 /* initial sn table size */ #define _MAXNAMELEN_SVR4 15 /* max member name length in svr4 variant */ #define _TRUNCATE_LEN 15 /* number of bytes to keep for member name */ static void add_to_ar_str_table(struct bsdar *bsdar, const char *name); static void add_to_ar_sym_table(struct bsdar *bsdar, const char *name); static struct ar_obj *create_obj_from_file(struct bsdar *bsdar, const char *name, time_t mtime); static void create_symtab_entry(struct bsdar *bsdar, void *maddr, size_t size); static void free_obj(struct bsdar *bsdar, struct ar_obj *obj); static void insert_obj(struct bsdar *bsdar, struct ar_obj *obj, struct ar_obj *pos); static void prefault_buffer(const char *buf, size_t s); static void read_objs(struct bsdar *bsdar, const char *archive, int checkargv); static void write_archive(struct bsdar *bsdar, char mode); static void write_cleanup(struct bsdar *bsdar); static void write_data(struct bsdar *bsdar, struct archive *a, const void *buf, size_t s); static void write_objs(struct bsdar *bsdar); void ar_mode_d(struct bsdar *bsdar) { write_archive(bsdar, 'd'); } void ar_mode_m(struct bsdar *bsdar) { write_archive(bsdar, 'm'); } void ar_mode_q(struct bsdar *bsdar) { write_archive(bsdar, 'q'); } void ar_mode_r(struct bsdar *bsdar) { write_archive(bsdar, 'r'); } void ar_mode_s(struct bsdar *bsdar) { write_archive(bsdar, 's'); } void ar_mode_A(struct bsdar *bsdar) { write_archive(bsdar, 'A'); } /* * Create object from file, return created obj upon success, or NULL * when an error occurs or the member is not newer than existing * one while -u is specified. */ static struct ar_obj * create_obj_from_file(struct bsdar *bsdar, const char *name, time_t mtime) { struct ar_obj *obj; struct stat sb; const char *bname; char *tmpname; if (name == NULL) return (NULL); obj = malloc(sizeof(struct ar_obj)); if (obj == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); if ((obj->fd = open(name, O_RDONLY, 0)) < 0) { bsdar_warnc(bsdar, errno, "can't open file: %s", name); free(obj); return (NULL); } tmpname = strdup(name); if (tmpname == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "strdup failed"); if ((bname = basename(tmpname)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "basename failed"); if (bsdar->options & AR_TR && strlen(bname) > _TRUNCATE_LEN) { if ((obj->name = malloc(_TRUNCATE_LEN + 1)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); (void)strncpy(obj->name, bname, _TRUNCATE_LEN); obj->name[_TRUNCATE_LEN] = '\0'; } else if ((obj->name = strdup(bname)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "strdup failed"); free(tmpname); if (fstat(obj->fd, &sb) < 0) { bsdar_warnc(bsdar, errno, "can't fstat file: %s", obj->name); goto giveup; } if (!S_ISREG(sb.st_mode)) { bsdar_warnc(bsdar, 0, "%s is not an ordinary file", obj->name); goto giveup; } /* * When option '-u' is specified and member is not newer than the * existing one, the replace will not happen. While if mtime == 0, * which indicates that this is to "replace a none exist member", * the replace will proceed regardless of '-u'. */ if (mtime != 0 && bsdar->options & AR_U && sb.st_mtime <= mtime) goto giveup; /* * When option '-D' is specified, mtime and UID / GID from the file * will be replaced with 0, and file mode with 644. This ensures that * checksums will match for two archives containing the exact same * files. */ if (bsdar->options & AR_D) { obj->uid = 0; obj->gid = 0; obj->mtime = 0; obj->md = S_IFREG | 0644; } else { obj->uid = sb.st_uid; obj->gid = sb.st_gid; obj->mtime = sb.st_mtime; obj->md = sb.st_mode; } obj->size = sb.st_size; obj->dev = sb.st_dev; obj->ino = sb.st_ino; if (obj->size == 0) { obj->maddr = NULL; return (obj); } if ((obj->maddr = mmap(NULL, obj->size, PROT_READ, MAP_PRIVATE, obj->fd, (off_t)0)) == MAP_FAILED) { bsdar_warnc(bsdar, errno, "can't mmap file: %s", obj->name); goto giveup; } if (close(obj->fd) < 0) bsdar_errc(bsdar, EX_SOFTWARE, errno, "close failed: %s", obj->name); return (obj); giveup: if (close(obj->fd) < 0) bsdar_errc(bsdar, EX_SOFTWARE, errno, "close failed: %s", obj->name); free(obj->name); free(obj); return (NULL); } /* * Free object itself and its associated allocations. */ static void free_obj(struct bsdar *bsdar, struct ar_obj *obj) { if (obj->fd == -1) free(obj->maddr); else if (obj->maddr != NULL && munmap(obj->maddr, obj->size)) bsdar_warnc(bsdar, errno, "can't munmap file: %s", obj->name); free(obj->name); free(obj); } /* * Insert obj to the tail, or before/after the pos obj. */ static void insert_obj(struct bsdar *bsdar, struct ar_obj *obj, struct ar_obj *pos) { if (obj == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "try to insert a null obj"); if (pos == NULL || obj == pos) /* * If the object to move happens to be the position obj, * or if there is not a pos obj, move it to tail. */ goto tail; if (bsdar->options & AR_B) { TAILQ_INSERT_BEFORE(pos, obj, objs); return; } if (bsdar->options & AR_A) { TAILQ_INSERT_AFTER(&bsdar->v_obj, pos, obj, objs); return; } tail: TAILQ_INSERT_TAIL(&bsdar->v_obj, obj, objs); } /* * Read objects from archive into v_obj list. Note that checkargv is * set when read_objs is used to read objects from the target of * ADDLIB command (ar script mode), in this case argv array possibly * specifies the members ADDLIB want. */ static void read_objs(struct bsdar *bsdar, const char *archive, int checkargv) { struct archive *a; struct archive_entry *entry; struct ar_obj *obj; const char *name; const char *bname; char *buff; char **av; size_t size; int i, r, find; if ((a = archive_read_new()) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_read_new failed"); archive_read_support_format_ar(a); AC(archive_read_open_filename(a, archive, DEF_BLKSZ)); for (;;) { r = archive_read_next_header(a, &entry); if (r == ARCHIVE_FATAL) - bsdar_errc(bsdar, EX_DATAERR, 0, "%s", + bsdar_errc(bsdar, EX_DATAERR, archive_errno(a), "%s", archive_error_string(a)); if (r == ARCHIVE_EOF) break; if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY) - bsdar_warnc(bsdar, 0, "%s", archive_error_string(a)); + bsdar_warnc(bsdar, archive_errno(a), "%s", + archive_error_string(a)); if (r == ARCHIVE_RETRY) { bsdar_warnc(bsdar, 0, "Retrying..."); continue; } name = archive_entry_pathname(entry); /* * skip pseudo members. */ if (strcmp(name, "/") == 0 || strcmp(name, "//") == 0) continue; /* * If checkargv is set, only read those members specified * in argv. */ if (checkargv && bsdar->argc > 0) { find = 0; for(i = 0; i < bsdar->argc; i++) { av = &bsdar->argv[i]; if (*av == NULL) continue; if ((bname = basename(*av)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "basename failed"); if (strcmp(bname, name) != 0) continue; *av = NULL; find = 1; break; } if (!find) continue; } size = archive_entry_size(entry); if (size > 0) { if ((buff = malloc(size)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); if (archive_read_data(a, buff, size) != (ssize_t)size) { - bsdar_warnc(bsdar, 0, "%s", + bsdar_warnc(bsdar, archive_errno(a), "%s", archive_error_string(a)); free(buff); continue; } } else buff = NULL; obj = malloc(sizeof(struct ar_obj)); if (obj == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); obj->maddr = buff; if ((obj->name = strdup(name)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "strdup failed"); obj->size = size; obj->uid = archive_entry_uid(entry); obj->gid = archive_entry_gid(entry); obj->md = archive_entry_mode(entry); obj->mtime = archive_entry_mtime(entry); obj->dev = 0; obj->ino = 0; /* * Objects from archive have obj->fd set to -1, * for the ease of cleaning up. */ obj->fd = -1; TAILQ_INSERT_TAIL(&bsdar->v_obj, obj, objs); } AC(archive_read_close(a)); AC(archive_read_free(a)); } /* * Determine the constitution of resulting archive. */ static void write_archive(struct bsdar *bsdar, char mode) { struct ar_obj *nobj, *obj, *obj_temp, *pos; struct stat sb; const char *bname; char **av; int i; TAILQ_INIT(&bsdar->v_obj); nobj = NULL; pos = NULL; memset(&sb, 0, sizeof(sb)); /* * Test if the specified archive exists, to figure out * whether we are creating one here. */ if (stat(bsdar->filename, &sb) != 0) { if (errno != ENOENT) { bsdar_warnc(bsdar, 0, "stat %s failed", bsdar->filename); return; } /* We do not create archive in mode 'd', 'm' and 's'. */ if (mode != 'r' && mode != 'q') { bsdar_warnc(bsdar, 0, "%s: no such file", bsdar->filename); return; } /* Issue a warning if -c is not specified when creating. */ if (!(bsdar->options & AR_C)) bsdar_warnc(bsdar, 0, "creating %s", bsdar->filename); goto new_archive; } /* * First read members from existing archive. */ read_objs(bsdar, bsdar->filename, 0); /* * For mode 's', no member will be moved, deleted or replaced. */ if (mode == 's') goto write_objs; /* * For mode 'q', we don't need to adjust existing members either. * Also, -a, -b and -i are ignored in this mode. New members are * always inserted at tail. */ if (mode == 'q') goto new_archive; /* * Mode 'A' adds the contents of another archive to the tail of * current archive. Note that mode 'A' is a special mode for the * ADDLIB command of the ar script mode. Currently there is no * access to this function from the ar command line mode. */ if (mode == 'A') { /* * Read objects from the target archive of ADDLIB command. * If there are members specified in argv, read those members * only, otherwise the entire archive will be read. */ read_objs(bsdar, bsdar->addlib, 1); goto write_objs; } /* * Try to find the position member specified by user. */ if (bsdar->options & AR_A || bsdar->options & AR_B) { TAILQ_FOREACH(obj, &bsdar->v_obj, objs) { if (strcmp(obj->name, bsdar->posarg) == 0) { pos = obj; break; } } /* * If can't find `pos' specified by user, * silently insert objects at tail. */ if (pos == NULL) bsdar->options &= ~(AR_A | AR_B); } for (i = 0; i < bsdar->argc; i++) { av = &bsdar->argv[i]; TAILQ_FOREACH_SAFE(obj, &bsdar->v_obj, objs, obj_temp) { if ((bname = basename(*av)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "basename failed"); if (bsdar->options & AR_TR) { if (strncmp(bname, obj->name, _TRUNCATE_LEN)) continue; } else if (strcmp(bname, obj->name) != 0) continue; if (mode == 'r') { /* * if the new member is not qualified * to replace the old one, skip it. */ nobj = create_obj_from_file(bsdar, *av, obj->mtime); if (nobj == NULL) goto skip_obj; } if (bsdar->options & AR_V) (void)fprintf(stdout, "%c - %s\n", mode, *av); TAILQ_REMOVE(&bsdar->v_obj, obj, objs); if (mode == 'd' || mode == 'r') free_obj(bsdar, obj); if (mode == 'm') insert_obj(bsdar, obj, pos); if (mode == 'r') insert_obj(bsdar, nobj, pos); skip_obj: *av = NULL; break; } } new_archive: /* * When operating in mode 'r', directly add those user specified * objects which do not exist in current archive. When operating * in mode 'q', all objects specified in command line args are * appended to the archive, without comparing with existing ones. */ for (i = 0; i < bsdar->argc; i++) { av = &bsdar->argv[i]; if (*av != NULL && (mode == 'r' || mode == 'q')) { nobj = create_obj_from_file(bsdar, *av, 0); if (nobj != NULL) insert_obj(bsdar, nobj, pos); if (bsdar->options & AR_V && nobj != NULL) (void)fprintf(stdout, "a - %s\n", *av); *av = NULL; } } write_objs: write_objs(bsdar); write_cleanup(bsdar); } /* * Memory cleaning up. */ static void write_cleanup(struct bsdar *bsdar) { struct ar_obj *obj, *obj_temp; TAILQ_FOREACH_SAFE(obj, &bsdar->v_obj, objs, obj_temp) { TAILQ_REMOVE(&bsdar->v_obj, obj, objs); free_obj(bsdar, obj); } free(bsdar->as); free(bsdar->s_so); free(bsdar->s_sn); bsdar->as = NULL; bsdar->s_so = NULL; bsdar->s_sn = NULL; } /* * Fault in the buffer prior to writing as a workaround for poor performance * due to interaction with kernel fs deadlock avoidance code. See the comment * above vn_io_fault_doio() in sys/kern/vfs_vnops.c for details of the issue. */ static void prefault_buffer(const char *buf, size_t s) { volatile const char *p; size_t page_size; if (s == 0) return; page_size = sysconf(_SC_PAGESIZE); for (p = buf; p < buf + s; p += page_size) *p; /* * Ensure we touch the last page as well, in case the buffer is not * page-aligned. */ *(volatile const char *)(buf + s - 1); } /* * Wrapper for archive_write_data(). */ static void write_data(struct bsdar *bsdar, struct archive *a, const void *buf, size_t s) { ssize_t written; prefault_buffer(buf, s); while (s > 0) { written = archive_write_data(a, buf, s); if (written < 0) - bsdar_errc(bsdar, EX_SOFTWARE, 0, "%s", + bsdar_errc(bsdar, EX_SOFTWARE, archive_errno(a), "%s", archive_error_string(a)); buf = (const char *)buf + written; s -= written; } } /* * Write the resulting archive members. */ static void write_objs(struct bsdar *bsdar) { struct ar_obj *obj; struct archive *a; struct archive_entry *entry; size_t s_sz; /* size of archive symbol table. */ size_t pm_sz; /* size of pseudo members */ int i, nr; if (elf_version(EV_CURRENT) == EV_NONE) bsdar_errc(bsdar, EX_SOFTWARE, 0, "ELF library initialization failed: %s", elf_errmsg(-1)); bsdar->rela_off = 0; /* Create archive symbol table and archive string table, if need. */ TAILQ_FOREACH(obj, &bsdar->v_obj, objs) { if (!(bsdar->options & AR_SS) && obj->maddr != NULL) create_symtab_entry(bsdar, obj->maddr, obj->size); if (strlen(obj->name) > _MAXNAMELEN_SVR4) add_to_ar_str_table(bsdar, obj->name); bsdar->rela_off += _ARHDR_LEN + obj->size + obj->size % 2; } /* * Pad the symbol name string table. It is treated specially because * symbol name table should be padded by a '\0', not the common '\n' * for other members. The size of sn table includes the pad bit. */ if (bsdar->s_cnt != 0 && bsdar->s_sn_sz % 2 != 0) bsdar->s_sn[bsdar->s_sn_sz++] = '\0'; /* * Archive string table is padded by a "\n" as the normal members. * The difference is that the size of archive string table counts * in the pad bit, while normal members' size fileds do not. */ if (bsdar->as != NULL && bsdar->as_sz % 2 != 0) bsdar->as[bsdar->as_sz++] = '\n'; /* * If there is a symbol table, calculate the size of pseudo members, * convert previously stored relative offsets to absolute ones, and * then make them Big Endian. * * absolute_offset = htobe32(relative_offset + size_of_pseudo_members) */ if (bsdar->s_cnt != 0) { s_sz = (bsdar->s_cnt + 1) * sizeof(uint32_t) + bsdar->s_sn_sz; pm_sz = _ARMAG_LEN + (_ARHDR_LEN + s_sz); if (bsdar->as != NULL) pm_sz += _ARHDR_LEN + bsdar->as_sz; for (i = 0; (size_t)i < bsdar->s_cnt; i++) *(bsdar->s_so + i) = htobe32(*(bsdar->s_so + i) + pm_sz); } if ((a = archive_write_new()) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_write_new failed"); archive_write_set_format_ar_svr4(a); AC(archive_write_open_filename(a, bsdar->filename)); /* * write the archive symbol table, if there is one. * If options -s is explicitly specified or we are invoked * as ranlib, write the symbol table even if it is empty. */ if ((bsdar->s_cnt != 0 && !(bsdar->options & AR_SS)) || bsdar->options & AR_S) { entry = archive_entry_new(); if (entry == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_entry_new failed"); archive_entry_copy_pathname(entry, "/"); if ((bsdar->options & AR_D) == 0) archive_entry_set_mtime(entry, time(NULL), 0); archive_entry_set_size(entry, (bsdar->s_cnt + 1) * sizeof(uint32_t) + bsdar->s_sn_sz); AC(archive_write_header(a, entry)); nr = htobe32(bsdar->s_cnt); write_data(bsdar, a, &nr, sizeof(uint32_t)); write_data(bsdar, a, bsdar->s_so, sizeof(uint32_t) * bsdar->s_cnt); write_data(bsdar, a, bsdar->s_sn, bsdar->s_sn_sz); archive_entry_free(entry); } /* write the archive string table, if any. */ if (bsdar->as != NULL) { entry = archive_entry_new(); if (entry == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_entry_new failed"); archive_entry_copy_pathname(entry, "//"); archive_entry_set_size(entry, bsdar->as_sz); AC(archive_write_header(a, entry)); write_data(bsdar, a, bsdar->as, bsdar->as_sz); archive_entry_free(entry); } /* write normal members. */ TAILQ_FOREACH(obj, &bsdar->v_obj, objs) { entry = archive_entry_new(); if (entry == NULL) bsdar_errc(bsdar, EX_SOFTWARE, 0, "archive_entry_new failed"); archive_entry_copy_pathname(entry, obj->name); archive_entry_set_uid(entry, obj->uid); archive_entry_set_gid(entry, obj->gid); archive_entry_set_mode(entry, obj->md); archive_entry_set_size(entry, obj->size); archive_entry_set_mtime(entry, obj->mtime, 0); archive_entry_set_dev(entry, obj->dev); archive_entry_set_ino(entry, obj->ino); archive_entry_set_filetype(entry, AE_IFREG); AC(archive_write_header(a, entry)); write_data(bsdar, a, obj->maddr, obj->size); archive_entry_free(entry); } AC(archive_write_close(a)); AC(archive_write_free(a)); } /* * Extract global symbols from ELF binary members. */ static void create_symtab_entry(struct bsdar *bsdar, void *maddr, size_t size) { Elf *e; Elf_Scn *scn; GElf_Shdr shdr; GElf_Sym sym; Elf_Data *data; char *name; size_t n, shstrndx; int elferr, tabndx, len, i; if ((e = elf_memory(maddr, size)) == NULL) { bsdar_warnc(bsdar, 0, "elf_memory() failed: %s", elf_errmsg(-1)); return; } if (elf_kind(e) != ELF_K_ELF) { /* Silently ignore non-elf member. */ elf_end(e); return; } if (elf_getshstrndx(e, &shstrndx) == 0) { bsdar_warnc(bsdar, EX_SOFTWARE, 0, "elf_getshstrndx failed: %s", elf_errmsg(-1)); elf_end(e); return; } tabndx = -1; scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &shdr) != &shdr) { bsdar_warnc(bsdar, 0, "elf_getshdr failed: %s", elf_errmsg(-1)); continue; } if ((name = elf_strptr(e, shstrndx, shdr.sh_name)) == NULL) { bsdar_warnc(bsdar, 0, "elf_strptr failed: %s", elf_errmsg(-1)); continue; } if (strcmp(name, ".strtab") == 0) { tabndx = elf_ndxscn(scn); break; } } elferr = elf_errno(); if (elferr != 0) bsdar_warnc(bsdar, 0, "elf_nextscn failed: %s", elf_errmsg(elferr)); if (tabndx == -1) { bsdar_warnc(bsdar, 0, "can't find .strtab section"); elf_end(e); return; } scn = NULL; while ((scn = elf_nextscn(e, scn)) != NULL) { if (gelf_getshdr(scn, &shdr) != &shdr) { bsdar_warnc(bsdar, EX_SOFTWARE, 0, "elf_getshdr failed: %s", elf_errmsg(-1)); continue; } if (shdr.sh_type != SHT_SYMTAB) continue; data = NULL; n = 0; while (n < shdr.sh_size && (data = elf_getdata(scn, data)) != NULL) { len = data->d_size / shdr.sh_entsize; for (i = 0; i < len; i++) { if (gelf_getsym(data, i, &sym) != &sym) { bsdar_warnc(bsdar, EX_SOFTWARE, 0, "gelf_getsym failed: %s", elf_errmsg(-1)); continue; } /* keep only global or weak symbols */ if (GELF_ST_BIND(sym.st_info) != STB_GLOBAL && GELF_ST_BIND(sym.st_info) != STB_WEAK) continue; /* keep only defined symbols */ if (sym.st_shndx == SHN_UNDEF) continue; if ((name = elf_strptr(e, tabndx, sym.st_name)) == NULL) { bsdar_warnc(bsdar, EX_SOFTWARE, 0, "elf_strptr failed: %s", elf_errmsg(-1)); continue; } add_to_ar_sym_table(bsdar, name); } } } elferr = elf_errno(); if (elferr != 0) bsdar_warnc(bsdar, EX_SOFTWARE, 0, "elf_nextscn failed: %s", elf_errmsg(elferr)); elf_end(e); } /* * Append to the archive string table buffer. */ static void add_to_ar_str_table(struct bsdar *bsdar, const char *name) { if (bsdar->as == NULL) { bsdar->as_cap = _INIT_AS_CAP; bsdar->as_sz = 0; if ((bsdar->as = malloc(bsdar->as_cap)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); } /* * The space required for holding one member name in as table includes: * strlen(name) + (1 for '/') + (1 for '\n') + (possibly 1 for padding). */ while (bsdar->as_sz + strlen(name) + 3 > bsdar->as_cap) { bsdar->as_cap *= 2; bsdar->as = realloc(bsdar->as, bsdar->as_cap); if (bsdar->as == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "realloc failed"); } strncpy(&bsdar->as[bsdar->as_sz], name, strlen(name)); bsdar->as_sz += strlen(name); bsdar->as[bsdar->as_sz++] = '/'; bsdar->as[bsdar->as_sz++] = '\n'; } /* * Append to the archive symbol table buffer. */ static void add_to_ar_sym_table(struct bsdar *bsdar, const char *name) { if (bsdar->s_so == NULL) { if ((bsdar->s_so = malloc(_INIT_SYMOFF_CAP)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); bsdar->s_so_cap = _INIT_SYMOFF_CAP; bsdar->s_cnt = 0; } if (bsdar->s_sn == NULL) { if ((bsdar->s_sn = malloc(_INIT_SYMNAME_CAP)) == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "malloc failed"); bsdar->s_sn_cap = _INIT_SYMNAME_CAP; bsdar->s_sn_sz = 0; } if (bsdar->s_cnt * sizeof(uint32_t) >= bsdar->s_so_cap) { bsdar->s_so_cap *= 2; bsdar->s_so = realloc(bsdar->s_so, bsdar->s_so_cap); if (bsdar->s_so == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "realloc failed"); } bsdar->s_so[bsdar->s_cnt] = bsdar->rela_off; bsdar->s_cnt++; /* * The space required for holding one symbol name in sn table includes: * strlen(name) + (1 for '\n') + (possibly 1 for padding). */ while (bsdar->s_sn_sz + strlen(name) + 2 > bsdar->s_sn_cap) { bsdar->s_sn_cap *= 2; bsdar->s_sn = realloc(bsdar->s_sn, bsdar->s_sn_cap); if (bsdar->s_sn == NULL) bsdar_errc(bsdar, EX_SOFTWARE, errno, "realloc failed"); } strncpy(&bsdar->s_sn[bsdar->s_sn_sz], name, strlen(name)); bsdar->s_sn_sz += strlen(name); bsdar->s_sn[bsdar->s_sn_sz++] = '\0'; }