diff --git a/usr.bin/ar/acpyacc.y b/usr.bin/ar/acpyacc.y index f6bfbd7957b5..34156e1d2d58 100644 --- a/usr.bin/ar/acpyacc.y +++ b/usr.bin/ar/acpyacc.y @@ -1,659 +1,659 @@ %{ /*- * 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 "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(EXIT_SUCCESS); } ; 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, 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, 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, errno, "unlink failed"); free(tmpac); } tmpac = strdup(TEMPLATE); if (tmpac == NULL) bsdar_errc(bsdar, errno, "strdup failed"); if ((ofd = mkstemp(tmpac)) < 0) bsdar_errc(bsdar, 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, 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, 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); + ar_write_archive(bsdar, 'A'); 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); + ar_write_archive(bsdar, 'q'); 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); + ar_write_archive(bsdar, 'd'); 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); + ar_read_archive(bsdar, 'x'); 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); + ar_read_archive(bsdar, 't'); 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, 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); + ar_read_archive(bsdar, 't'); bsdar->options &= ~AR_V; if (rlt) { if (fclose(stdout) == EOF) bsdar_errc(bsdar, 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); + ar_write_archive(bsdar, 'r'); 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, 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, 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, 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, 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, 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, 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, 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(EXIT_FAILURE); } /* Script ends without END */ arscp_end(EXIT_SUCCESS); } diff --git a/usr.bin/ar/ar.c b/usr.bin/ar/ar.c index aceb4d7f8487..fdfebb8eb459 100644 --- a/usr.bin/ar/ar.c +++ b/usr.bin/ar/ar.c @@ -1,421 +1,406 @@ /*- * SPDX-License-Identifier: BSD-3-Clause * * Copyright (c) 2007 Kai Wang * Copyright (c) 2007 Tim Kientzle * Copyright (c) 2007 Joseph Koshy * 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. */ /*- * Copyright (c) 1990, 1993, 1994 * The Regents of the University of California. All rights reserved. * * This code is derived from software contributed to Berkeley by * Hugh Smith at The University of Guelph. * * 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. * 3. Neither the name of the University nor the names of its contributors * may be used to endorse or promote products derived from this software * without specific prior written permission. * * THIS SOFTWARE IS PROVIDED BY THE REGENTS 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 REGENTS 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" enum options { OPTION_HELP }; static struct option longopts[] = { {"help", no_argument, NULL, OPTION_HELP}, {"version", no_argument, NULL, 'V'}, {NULL, 0, NULL, 0} }; static void bsdar_usage(void); static void ranlib_usage(void); static void set_mode(struct bsdar *bsdar, char opt); static void only_mode(struct bsdar *bsdar, const char *opt, const char *valid_modes); static void bsdar_version(void); static void ranlib_version(void); int main(int argc, char **argv) { struct bsdar *bsdar, bsdar_storage; char *p; size_t len; int exitcode, i, opt, Dflag, Uflag; bsdar = &bsdar_storage; memset(bsdar, 0, sizeof(*bsdar)); exitcode = EXIT_SUCCESS; Dflag = 0; Uflag = 0; if ((bsdar->progname = getprogname()) == NULL) bsdar->progname = "ar"; /* Act like ranlib if our name ends in "ranlib"; this * accommodates arm-freebsd7.1-ranlib, bsdranlib, etc. */ len = strlen(bsdar->progname); if (len >= strlen("ranlib") && strcmp(bsdar->progname + len - strlen("ranlib"), "ranlib") == 0) { while ((opt = getopt_long(argc, argv, "tDUV", longopts, NULL)) != -1) { switch(opt) { case 't': /* Ignored. */ break; case 'D': Dflag = 1; Uflag = 0; break; case 'U': Uflag = 1; Dflag = 0; break; case 'V': ranlib_version(); break; case OPTION_HELP: ranlib_usage(); default: ranlib_usage(); } } argv += optind; argc -= optind; if (*argv == NULL) ranlib_usage(); /* Enable determinstic mode unless -U is set. */ if (Uflag == 0) bsdar->options |= AR_D; bsdar->options |= AR_S; while ((bsdar->filename = *argv++) != NULL) - if (ar_mode_s(bsdar)) + if (ar_write_archive(bsdar, 's')) exitcode = EXIT_FAILURE; exit(exitcode); } else { if (argc < 2) bsdar_usage(); if (*argv[1] != '-') { len = strlen(argv[1]) + 2; if ((p = malloc(len)) == NULL) bsdar_errc(bsdar, errno, "malloc failed"); *p = '-'; (void)strlcpy(p + 1, argv[1], len - 1); argv[1] = p; } } while ((opt = getopt_long(argc, argv, "abCcdDfijlMmopqrSsTtUuVvxz", longopts, NULL)) != -1) { switch(opt) { case 'a': bsdar->options |= AR_A; break; case 'b': case 'i': bsdar->options |= AR_B; break; case 'C': bsdar->options |= AR_CC; break; case 'c': bsdar->options |= AR_C; break; case 'd': set_mode(bsdar, opt); break; case 'D': Dflag = 1; Uflag = 0; break; case 'f': case 'T': bsdar->options |= AR_TR; break; case 'j': /* ignored */ break; case 'l': /* ignored, for GNU ar comptibility */ break; case 'M': set_mode(bsdar, opt); break; case 'm': set_mode(bsdar, opt); break; case 'o': bsdar->options |= AR_O; break; case 'p': set_mode(bsdar, opt); break; case 'q': set_mode(bsdar, opt); break; case 'r': set_mode(bsdar, opt); break; case 'S': bsdar->options |= AR_SS; break; case 's': bsdar->options |= AR_S; break; case 't': set_mode(bsdar, opt); break; case 'U': Uflag = 1; Dflag = 0; break; case 'u': bsdar->options |= AR_U; break; case 'V': bsdar_version(); break; case 'v': bsdar->options |= AR_V; break; case 'x': set_mode(bsdar, opt); break; case 'z': /* ignored */ break; case OPTION_HELP: bsdar_usage(); default: bsdar_usage(); } } argv += optind; argc -= optind; if (*argv == NULL && bsdar->mode != 'M') bsdar_usage(); if (bsdar->options & AR_A && bsdar->options & AR_B) bsdar_errc(bsdar, 0, "only one of -a and -[bi] options allowed"); if (bsdar->options & AR_J && bsdar->options & AR_Z) bsdar_errc(bsdar, 0, "only one of -j and -z options allowed"); if (bsdar->options & AR_S && bsdar->options & AR_SS) bsdar_errc(bsdar, 0, "only one of -s and -S options allowed"); if (bsdar->options & (AR_A | AR_B)) { if (*argv == NULL) bsdar_errc(bsdar, 0, "no position operand specified"); if ((bsdar->posarg = basename(*argv)) == NULL) bsdar_errc(bsdar, errno, "basename failed"); argc--; argv++; } /* Set determinstic mode for -D, and by default without -U. */ if (Dflag || (Uflag == 0 && (bsdar->mode == 'q' || bsdar->mode == 'r' || (bsdar->mode == '\0' && bsdar->options & AR_S)))) bsdar->options |= AR_D; if (bsdar->options & AR_A) only_mode(bsdar, "-a", "mqr"); if (bsdar->options & AR_B) only_mode(bsdar, "-b", "mqr"); if (bsdar->options & AR_C) only_mode(bsdar, "-c", "qr"); if (bsdar->options & AR_CC) only_mode(bsdar, "-C", "x"); if (Dflag) only_mode(bsdar, "-D", "qr"); if (Uflag) only_mode(bsdar, "-U", "qr"); if (bsdar->options & AR_O) only_mode(bsdar, "-o", "x"); if (bsdar->options & AR_SS) only_mode(bsdar, "-S", "mqr"); if (bsdar->options & AR_U) only_mode(bsdar, "-u", "qrx"); if (bsdar->mode == 'M') { ar_mode_script(bsdar); exit(EXIT_SUCCESS); } if ((bsdar->filename = *argv) == NULL) bsdar_usage(); bsdar->argc = --argc; bsdar->argv = ++argv; if ((!bsdar->mode || strchr("ptx", bsdar->mode)) && bsdar->options & AR_S) { - exitcode = ar_mode_s(bsdar); + exitcode = ar_write_archive(bsdar, 's'); if (!bsdar->mode) exit(exitcode); } switch(bsdar->mode) { - case 'd': - exitcode = ar_mode_d(bsdar); + case 'd': case 'm': case 'q': case 'r': + exitcode = ar_write_archive(bsdar, bsdar->mode); break; - case 'm': - exitcode = ar_mode_m(bsdar); - break; - case 'p': - exitcode = ar_mode_p(bsdar); - break; - case 'q': - exitcode = ar_mode_q(bsdar); - break; - case 'r': - exitcode = ar_mode_r(bsdar); - break; - case 't': - exitcode = ar_mode_t(bsdar); - break; - case 'x': - exitcode = ar_mode_x(bsdar); + case 'p': case 't': case 'x': + exitcode = ar_read_archive(bsdar, bsdar->mode); break; default: bsdar_usage(); /* NOTREACHED */ } for (i = 0; i < bsdar->argc; i++) { if (bsdar->argv[i] != NULL) { bsdar_warnc(bsdar, 0, "%s: not found in archive", bsdar->argv[i]); exitcode = EXIT_FAILURE; } } exit(exitcode); } static void set_mode(struct bsdar *bsdar, char opt) { if (bsdar->mode != '\0' && bsdar->mode != opt) bsdar_errc(bsdar, 0, "Can't specify both -%c and -%c", opt, bsdar->mode); bsdar->mode = opt; } static void only_mode(struct bsdar *bsdar, const char *opt, const char *valid_modes) { if (strchr(valid_modes, bsdar->mode) == NULL) bsdar_errc(bsdar, 0, "Option %s is not permitted in mode -%c", opt, bsdar->mode); } static void bsdar_usage(void) { (void)fprintf(stderr, "usage: ar -d [-Tjsvz] archive file ...\n"); (void)fprintf(stderr, "\tar -m [-Tjsvz] archive file ...\n"); (void)fprintf(stderr, "\tar -m [-Tabijsvz] position archive file ...\n"); (void)fprintf(stderr, "\tar -p [-Tv] archive [file ...]\n"); (void)fprintf(stderr, "\tar -q [-TcDjsUvz] archive file ...\n"); (void)fprintf(stderr, "\tar -r [-TcDjsUuvz] archive file ...\n"); (void)fprintf(stderr, "\tar -r [-TabcDijsUuvz] position archive file ...\n"); (void)fprintf(stderr, "\tar -s [-jz] archive\n"); (void)fprintf(stderr, "\tar -t [-Tv] archive [file ...]\n"); (void)fprintf(stderr, "\tar -x [-CTouv] archive [file ...]\n"); (void)fprintf(stderr, "\tar -V\n"); exit(EXIT_FAILURE); } static void ranlib_usage(void) { (void)fprintf(stderr, "usage: ranlib [-DtU] archive ...\n"); (void)fprintf(stderr, "\tranlib -V\n"); exit(EXIT_FAILURE); } static void bsdar_version(void) { (void)printf("BSD ar %s - %s\n", BSDAR_VERSION, archive_version_string()); exit(EXIT_SUCCESS); } static void ranlib_version(void) { (void)printf("ranlib %s - %s\n", BSDAR_VERSION, archive_version_string()); exit(EXIT_SUCCESS); } diff --git a/usr.bin/ar/ar.h b/usr.bin/ar/ar.h index 321680fed804..c8705e20eb45 100644 --- a/usr.bin/ar/ar.h +++ b/usr.bin/ar/ar.h @@ -1,128 +1,122 @@ /*- * 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, 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. */ uint64_t s_cnt; /* current number of symbols. */ uint64_t *s_so; /* symbol offset table. */ uint64_t s_so_max; /* maximum symbol offset. */ 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 _code, const char *fmt, ...) __dead2; -void bsdar_warnc(struct bsdar *, int _code, const char *fmt, ...); -int ar_mode_d(struct bsdar *bsdar); -int ar_mode_m(struct bsdar *bsdar); -int ar_mode_p(struct bsdar *bsdar); -int ar_mode_q(struct bsdar *bsdar); -int ar_mode_r(struct bsdar *bsdar); -int ar_mode_s(struct bsdar *bsdar); -int ar_mode_t(struct bsdar *bsdar); -int ar_mode_x(struct bsdar *bsdar); -int ar_mode_A(struct bsdar *bsdar); void ar_mode_script(struct bsdar *ar); +int ar_read_archive(struct bsdar *ar, int mode); +int ar_write_archive(struct bsdar *ar, int mode); +void bsdar_errc(struct bsdar *, int _code, const char *fmt, ...) __dead2; +void bsdar_warnc(struct bsdar *, int _code, const char *fmt, ...); diff --git a/usr.bin/ar/read.c b/usr.bin/ar/read.c index 15044ab57a93..81e0bfce1b7e 100644 --- a/usr.bin/ar/read.c +++ b/usr.bin/ar/read.c @@ -1,226 +1,206 @@ /*- * 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 #include "ar.h" -static int read_archive(struct bsdar *bsdar, char mode); - -int -ar_mode_p(struct bsdar *bsdar) -{ - - return (read_archive(bsdar, 'p')); -} - -int -ar_mode_t(struct bsdar *bsdar) -{ - - return (read_archive(bsdar, 't')); -} - -int -ar_mode_x(struct bsdar *bsdar) -{ - - return (read_archive(bsdar, 'x')); -} - /* * Handle read modes: 'x', 't' and 'p'. */ -static int -read_archive(struct bsdar *bsdar, char mode) +int +ar_read_archive(struct bsdar *bsdar, int 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 exitcode, flags, r, i; + assert(mode == 'p' || mode == 't' || mode == 'x'); + if ((a = archive_read_new()) == NULL) bsdar_errc(bsdar, 0, "archive_read_new failed"); archive_read_support_format_ar(a); AC(archive_read_open_filename(a, bsdar->filename, DEF_BLKSZ)); exitcode = EXIT_SUCCESS; for (;;) { r = archive_read_next_header(a, &entry); if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY || r == ARCHIVE_FATAL) 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 || strcmp(name, "/SYM64/") == 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, 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, 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, archive_errno(a), "%s", archive_error_string(a)); exitcode = EXIT_FAILURE; } } } if (r == ARCHIVE_FATAL) exitcode = EXIT_FAILURE; AC(archive_read_close(a)); AC(archive_read_free(a)); return (exitcode); } diff --git a/usr.bin/ar/write.c b/usr.bin/ar/write.c index 3c4b20e305da..1b9ff18b155b 100644 --- a/usr.bin/ar/write.c +++ b/usr.bin/ar/write.c @@ -1,955 +1,916 @@ /*- * 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(uint64_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 int 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); -int -ar_mode_d(struct bsdar *bsdar) -{ - - return (write_archive(bsdar, 'd')); -} - -int -ar_mode_m(struct bsdar *bsdar) -{ - - return (write_archive(bsdar, 'm')); -} - -int -ar_mode_q(struct bsdar *bsdar) -{ - - return (write_archive(bsdar, 'q')); -} - -int -ar_mode_r(struct bsdar *bsdar) -{ - - return (write_archive(bsdar, 'r')); -} - -int -ar_mode_s(struct bsdar *bsdar) -{ - - return (write_archive(bsdar, 's')); -} - -int -ar_mode_A(struct bsdar *bsdar) -{ - - return (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, 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, errno, "strdup failed"); if ((bname = basename(tmpname)) == NULL) bsdar_errc(bsdar, errno, "basename failed"); if (bsdar->options & AR_TR && strlen(bname) > _TRUNCATE_LEN) { if ((obj->name = malloc(_TRUNCATE_LEN + 1)) == NULL) bsdar_errc(bsdar, 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, 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, errno, "close failed: %s", obj->name); return (obj); giveup: if (close(obj->fd) < 0) bsdar_errc(bsdar, 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, 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, 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, archive_errno(a), "%s", archive_error_string(a)); if (r == ARCHIVE_EOF) break; if (r == ARCHIVE_WARN || r == ARCHIVE_RETRY) 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, 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, errno, "malloc failed"); if (archive_read_data(a, buff, size) != (ssize_t)size) { 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, errno, "malloc failed"); obj->maddr = buff; if ((obj->name = strdup(name)) == NULL) bsdar_errc(bsdar, 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 int -write_archive(struct bsdar *bsdar, char mode) +int +ar_write_archive(struct bsdar *bsdar, int mode) { struct ar_obj *nobj, *obj, *obj_temp, *pos; struct stat sb; const char *bname; char **av; int exitcode, i; TAILQ_INIT(&bsdar->v_obj); exitcode = EXIT_SUCCESS; nobj = NULL; pos = NULL; memset(&sb, 0, sizeof(sb)); + assert(mode == 'A' || mode == 'd' || mode == 'm' || mode == 'q' || + mode == 'r' || mode == 's'); + /* * 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 (EXIT_FAILURE); } /* 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 (EXIT_FAILURE); } /* 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, 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) { exitcode = EXIT_FAILURE; 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) { exitcode = EXIT_FAILURE; *av = NULL; continue; } 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); return (exitcode); } /* * 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_so_max = 0; 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, 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 */ size_t w_sz; /* size of words in symbol table */ size_t i; uint64_t nr; uint32_t nr32; if (elf_version(EV_CURRENT) == EV_NONE) bsdar_errc(bsdar, 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 fields 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) */ w_sz = sizeof(uint32_t); 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; /* Use the 64-bit word size format if necessary. */ if (bsdar->s_so_max > UINT32_MAX - pm_sz) { w_sz = sizeof(uint64_t); pm_sz -= s_sz; s_sz = (bsdar->s_cnt + 1) * sizeof(uint64_t) + bsdar->s_sn_sz; pm_sz += s_sz; /* Convert to big-endian. */ for (i = 0; i < bsdar->s_cnt; i++) bsdar->s_so[i] = htobe64(bsdar->s_so[i] + pm_sz); } else { /* * Convert to big-endian and shuffle in-place to * the front of the allocation. XXX UB */ for (i = 0; i < bsdar->s_cnt; i++) ((uint32_t *)(bsdar->s_so))[i] = htobe32(bsdar->s_so[i] + pm_sz); } } if ((a = archive_write_new()) == NULL) bsdar_errc(bsdar, 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, 0, "archive_entry_new failed"); if (w_sz == sizeof(uint64_t)) archive_entry_copy_pathname(entry, "/SYM64/"); else 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) * w_sz + bsdar->s_sn_sz); AC(archive_write_header(a, entry)); if (w_sz == sizeof(uint64_t)) { nr = htobe64(bsdar->s_cnt); write_data(bsdar, a, &nr, sizeof(nr)); } else { nr32 = htobe32((uint32_t)bsdar->s_cnt); write_data(bsdar, a, &nr32, sizeof(nr32)); } write_data(bsdar, a, bsdar->s_so, w_sz * 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, errno, "malloc failed"); bsdar->s_sn_cap = _INIT_SYMNAME_CAP; bsdar->s_sn_sz = 0; } if (bsdar->s_cnt * sizeof(uint64_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, errno, "realloc failed"); } bsdar->s_so[bsdar->s_cnt] = bsdar->rela_off; if ((uint64_t)bsdar->rela_off > bsdar->s_so_max) bsdar->s_so_max = (uint64_t)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, 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'; }