 @@ -1,14 +1,14 @@
-/*	$NetBSD: arch.c,v 1.75 2020/07/26 20:21:31 rillig Exp $	*/
+/*	$NetBSD: arch.c,v 1.76 2020/07/27 19:06:45 rillig Exp $	*/
 /*
  * Copyright (c) 1988, 1989, 1990, 1993
  *	The Regents of the University of California.  All rights reserved.
+ *
  * This code is derived from software contributed to Berkeley by
  * Adam de Boor.
+ *
  * 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.
 @@ -59,34 +59,34 @@
  * 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.
  */
 #ifndef MAKE_NATIVE
-static char rcsid[] = "$NetBSD: arch.c,v 1.75 2020/07/26 20:21:31 rillig Exp $";
+static char rcsid[] = "$NetBSD: arch.c,v 1.76 2020/07/27 19:06:45 rillig Exp $";
 #else
 #include <sys/cdefs.h>
 #ifndef lint
 #if 0
 static char sccsid[] = "@(#)arch.c	8.2 (Berkeley) 1/2/94";
 #else
-__RCSID("$NetBSD: arch.c,v 1.75 2020/07/26 20:21:31 rillig Exp $");
+__RCSID("$NetBSD: arch.c,v 1.76 2020/07/27 19:06:45 rillig Exp $");
 #endif
 #endif /* not lint */
 #endif
 /*-
  * arch.c --
  *	Functions to manipulate libraries, archives and their members.
+ *
  *	Once again, cacheing/hashing comes into play in the manipulation
  * of archives. The first time an archive is referenced, all of its members'
  * headers are read and hashed and the archive closed again. All hashed
  * archives are kept on a list which is searched each time an archive member
  * is referenced.
 @@ -158,28 +158,29 @@ static Lst	  archives;   /* Lst of archi
 typedef struct Arch {
     char	  *name;      /* Name of archive */
     Hash_Table	  members;    /* All the members of the archive described
 			       * by <name, struct ar_hdr *> key/value pairs */
     char	  *fnametab;  /* Extended name table strings */
     size_t	  fnamesize;  /* Size of the string table */
 } Arch;
 static int ArchFindArchive(const void *, const void *);
 #ifdef CLEANUP
 static void ArchFree(void *);
 #endif
-static struct ar_hdr *ArchStatMember(char *, char *, Boolean);
+static struct ar_hdr *ArchStatMember(const char *, const char *, Boolean);
-static FILE *ArchFindMember(char *, char *, struct ar_hdr *, const char *);
+static FILE *ArchFindMember(const char *, const char *,
 			    struct ar_hdr *, const char *);
 #if defined(__svr4__) || defined(__SVR4) || defined(__ELF__)
 #define SVR4ARCHIVES
 static int ArchSVR4Entry(Arch *, char *, size_t, FILE *);
 #endif
 #ifdef CLEANUP
 /*-
  *-----------------------------------------------------------------------
  * ArchFree --
  *	Free memory used by an archive
+ *
  * Results:
  *	None.
 @@ -513,49 +514,48 @@ ArchFindArchive(const void *ar, const vo
+ *
  * Results:
  *	A pointer to the current struct ar_hdr structure for the member. Note
  *	That no position is returned, so this is not useful for touching
  *	archive members. This is mostly because we have no assurances that
  *	The archive will remain constant after we read all the headers, so
  *	there's not much point in remembering the position...
+ *
  * Side Effects:
+ *
  *-----------------------------------------------------------------------
  */
 static struct ar_hdr *
-ArchStatMember(char *archive, char *member, Boolean hash)
+ArchStatMember(const char *archive, const char *member, Boolean hash)
+{
 #define AR_MAX_NAME_LEN	    (sizeof(arh.ar_name)-1)
     FILE *	  arch;	      /* Stream to archive */
     int		  size;       /* Size of archive member */
     char	  *cp;	      /* Useful character pointer */
     char	  magic[SARMAG];
     LstNode	  ln;	      /* Lst member containing archive descriptor */
     Arch	  *ar;	      /* Archive descriptor */
     Hash_Entry	  *he;	      /* Entry containing member's description */
     struct ar_hdr arh;        /* archive-member header for reading archive */
     char	  memName[MAXPATHLEN+1];
     	    	    	    /* Current member name while hashing. */
     /*
      * Because of space constraints and similar things, files are archived
      * using their final path components, not the entire thing, so we need
      * to point 'member' to the final component, if there is one, to make
      * the comparisons easier...
      */
-    cp = strrchr(member, '/');
+    const char *base = strrchr(member, '/');
-    if (cp != NULL) {
+    if (base != NULL) {
-	member = cp + 1;
+	member = base + 1;
+    }
     ln = Lst_Find(archives, archive, ArchFindArchive);
     if (ln != NULL) {
 	ar = (Arch *)Lst_Datum(ln);
 	he = Hash_FindEntry(&ar->members, member);
 	if (he != NULL) {
 	    return (struct ar_hdr *)Hash_GetValue(he);
 	} else {
 	    /* Try truncated name */
 	    char copy[AR_MAX_NAME_LEN+1];
 @@ -626,51 +626,52 @@ ArchStatMember(char *archive, char *memb
 	     */
 	    goto badarch;
 	} else {
 	    /*
 	     * We need to advance the stream's pointer to the start of the
 	     * next header. Files are padded with newlines to an even-byte
 	     * boundary, so we need to extract the size of the file from the
 	     * 'size' field of the header and round it up during the seek.
 	     */
 	    arh.ar_size[sizeof(arh.ar_size)-1] = '\0';
 	    size = (int)strtol(arh.ar_size, NULL, 10);
 	    memcpy(memName, arh.ar_name, sizeof(arh.ar_name));
-	    for (cp = &memName[AR_MAX_NAME_LEN]; *cp == ' '; cp--) {
+	    char *nameend = memName + AR_MAX_NAME_LEN;
-		continue;
+	    while (*nameend == ' ') {
 		nameend--;
+	    }
-	    cp[1] = '\0';
+	    nameend[1] = '\0';
 #ifdef SVR4ARCHIVES
 	    /*
 	     * svr4 names are slash terminated. Also svr4 extended AR format.
 	     */
 	    if (memName[0] == '/') {
 		/*
 		 * svr4 magic mode; handle it
 		 */
 		switch (ArchSVR4Entry(ar, memName, size, arch)) {
 		case -1:  /* Invalid data */
 		    goto badarch;
 		case 0:	  /* List of files entry */
 		    continue;
 		default:  /* Got the entry */
 		    break;
+		}
+	    }
 	    else {
-		if (cp[0] == '/')
+		if (nameend[0] == '/')
-		    cp[0] = '\0';
+		    nameend[0] = '\0';
+	    }
 #endif
 #ifdef AR_EFMT1
 	    /*
 	     * BSD 4.4 extended AR format: #1/<namelen>, with name as the
 	     * first <namelen> bytes of the file
 	     */
 	    if (strncmp(memName, AR_EFMT1, sizeof(AR_EFMT1) - 1) == 0 &&
 		isdigit((unsigned char)memName[sizeof(AR_EFMT1) - 1])) {
 		unsigned int elen = atoi(&memName[sizeof(AR_EFMT1)-1]);
 @@ -836,59 +837,58 @@ ArchSVR4Entry(Arch *ar, char *name, size
  *	mode		The mode for opening the stream
+ *
  * Results:
  *	An FILE *, opened for reading and writing, positioned at the
  *	start of the member's struct ar_hdr, or NULL if the member was
  *	nonexistent. The current struct ar_hdr for member.
+ *
  * Side Effects:
  *	The passed struct ar_hdr structure is filled in.
+ *
  *-----------------------------------------------------------------------
  */
 static FILE *
-ArchFindMember(char *archive, char *member, struct ar_hdr *arhPtr,
+ArchFindMember(const char *archive, const char *member, struct ar_hdr *arhPtr,
     const char *mode)
+{
     FILE *	  arch;	      /* Stream to archive */
     int		  size;       /* Size of archive member */
     char	  *cp;	      /* Useful character pointer */
     char	  magic[SARMAG];
     size_t	  len, tlen;
     arch = fopen(archive, mode);
     if (arch == NULL) {
 	return NULL;
+    }
     /*
      * We use the ARMAG string to make sure this is an archive we
      * can handle...
      */
     if ((fread(magic, SARMAG, 1, arch) != 1) ||
     	(strncmp(magic, ARMAG, SARMAG) != 0)) {
 	    fclose(arch);
 	    return NULL;
+    }
     /*
      * Because of space constraints and similar things, files are archived
      * using their final path components, not the entire thing, so we need
      * to point 'member' to the final component, if there is one, to make
      * the comparisons easier...
      */
-    cp = strrchr(member, '/');
+    const char *base = strrchr(member, '/');
-    if (cp != NULL) {
+    if (base != NULL) {
-	member = cp + 1;
+	member = base + 1;
+    }
     len = tlen = strlen(member);
     if (len > sizeof(arhPtr->ar_name)) {
 	tlen = sizeof(arhPtr->ar_name);
+    }
     while (fread((char *)arhPtr, sizeof(struct ar_hdr), 1, arch) == 1) {
 	if (strncmp(arhPtr->ar_fmag, ARFMAG, sizeof(arhPtr->ar_fmag) ) != 0) {
 	     /*
 	      * The header is bogus, so the archive is bad
 	      * and there's no way we can recover...
 	      */
 	     fclose(arch);