compilers/linux86-0.16.17/ar/ar.c

   1 /* ar.c - Archive modify and extract.
   2    Copyright (C) 1988, 1990 Free Software Foundation, Inc.
   3    ar86 changes by Greg Haerr <greg@censoft.com>
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 1, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software
  17    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  18
  19
  20 #include <stdio.h>
  21 #include <stdlib.h>
  22 #ifdef __STDC__
  23 #include <unistd.h>
  24 #include <string.h>
  25 #include <utime.h>
  26 #include <sys/time.h>
  27 #endif
  28 #include <fcntl.h>
  29 #include <time.h>
  30 #include <sys/types.h>
  31 #include <sys/stat.h>
  32 #include <errno.h>
  33 #include "ar.h"
  34 #include "rel_aout.h"
  35
  36 #if defined(__BCC__) || defined(__HP_cc)
  37 #define HAVE_RENAME
  38 #undef  HAVE_FSYNC
  39 #define SHORT_FILENAME
  40 #else
  41 #define HAVE_FCHMOD
  42 #define HAVE_RENAME
  43 #undef  HAVE_FSYNC
  44 #endif
  45 #define HAVE_TRAILING_SLASH_IN_NAME
  46
  47 #ifdef  __GNUC__
  48 # ifndef alloca
  49 #  define       alloca  __builtin_alloca
  50 # endif
  51 #else
  52 # if defined(sparc) || defined(HAVE_ALLOCA_H)
  53 #  include <alloca.h>
  54 # endif
  55 #endif
  56
  57 #ifdef  USG
  58 #define bcopy(source, dest, size)       memcpy((dest), (source), (size))
  59 #define bcmp(a, b, size)                memcmp((a), (b), (size))
  60 #define bzero(s, size)                  memset((s), 0, (size))
  61 #endif
  62
  63 /* Locking is normally disabled because fcntl hangs on the Sun
  64    and it isn't supported properly across NFS anyway.  */
  65
  66 /* This structure is used internally to represent the info
  67    on a member of an archive.  This is to make it easier to change format.  */
  68
  69 struct member_desc
  70   {
  71     /* Name of member.  */
  72     char *name;
  73
  74     /* The following fields are stored in the member header as decimal or octal
  75        numerals, but in this structure they are stored as machine numbers.  */
  76     int mode;           /* Protection mode from member header.  */
  77     long int date;      /* Last modify date as stored in member header.  */
  78     unsigned int size;  /* Bytes of member's data, from member header.  */
  79     int uid, gid;       /* UID and GID fields copied from member header.  */
  80     unsigned int offset;/* Offset in archive of the header of this member.  */
  81     unsigned int data_offset;/* Offset of first data byte of the member.  */
  82
  83     /* The next field does not describe where the member was in the
  84        old archive, but rather where it will be in the modified archive.
  85        It is set up by write_archive.  */
  86     unsigned int new_offset;    /* Offset of this member in new archive */
  87
  88     /* Symdef data for member.  Used only for files being inserted.  */
  89     struct symdef *symdefs;
  90     unsigned int nsymdefs;      /* Number of entries of symdef data.  */
  91     unsigned int string_size;   /* Size of strings needed by symdef data.  */
  92   };
  93
  94 /* Each symbol is recorded by something like this.  */
  95
  96 struct symdef
  97   {
  98     union
  99       {
 100         unsigned long int stringoffset;
 101         char *name;
 102       } s;
 103     unsigned long int offset;
 104   };
 105
 106 /* Nonzero means it's the name of an existing member;
 107    position new or moved files with respect to this one.  */
 108
 109 char *posname;
 110
 111 /* How to use `posname':
 112    POS_BEFORE means position before that member.
 113    POS_AFTER means position after that member.
 114    POS_DEFAULT if position by default; then `posname' should also be zero. */
 115
 116 enum { POS_DEFAULT, POS_BEFORE, POS_AFTER } postype;
 117
 118 /* Nonzero means describe each action performed.  */
 119
 120 int verbose;
 121
 122 /* Nonzero means don't warn about creating the archive file if necessary.  */
 123
 124 int silent_create;
 125
 126 /* Nonzero means don't replace existing members whose
 127    dates are more recent than the corresponding files.  */
 128
 129 int newer_only;
 130
 131 /* Nonzero means preserve dates of members when extracting them.  */
 132
 133 int preserve_dates;
 134
 135 /* Operation to be performed.  */
 136
 137 #define DELETE 1
 138 #define REPLACE 2
 139 #define PRINT_TABLE 3
 140 #define PRINT_FILES 4
 141 #define EXTRACT 5
 142 #define MOVE 6
 143 #define QUICK_APPEND 7
 144
 145 int operation;
 146
 147 /* Name of archive file.  */
 148
 149 char *archive;
 150
 151 /* Descriptor on which we have locked the original archive file,
 152    or -1 if this has not been done.  */
 153
 154 int lock_indesc;
 155
 156 /* Pointer to tail of `argv', at first subfile name argument,
 157  or zero if no such were specified.  */
 158
 159 char **files;
 160
 161 /* Nonzero means write a __.SYMDEF member into the modified archive.  */
 162 int symdef_flag;
 163
 164 /* Nonzero means __.SYMDEF member exists in old archive.  */
 165 int symdef_exists;
 166
 167 /* Nonzero means don't update __.SYMDEF unless the flag was given.  */
 168 int ignore_symdef;
 169
 170 /* Total number of symdef entries we will have. */
 171 unsigned long int nsymdefs;
 172
 173 /* Symdef data from old archive (set up only if we need it) */
 174 struct symdef *old_symdefs;
 175
 176 /* Number of symdefs in remaining in old_symdefs.  */
 177 unsigned int num_old_symdefs;
 178
 179 /* Number of symdefs old_symdefs had when it was read in.  */
 180 unsigned long int original_num_symdefs;
 181
 182 /* String table from old __.SYMDEF member.  */
 183 char *old_strings;
 184
 185 /* Size of old_strings */
 186 unsigned long int old_strings_size;
 187
 188 /* String table to be written into __.SYMDEF member.  */
 189 char *new_strings;
 190
 191 /* Size of new_strings */
 192 unsigned long int new_strings_size;
 193
 194 /* An archive map is a chain of these structures.
 195   Each structure describes one member of the archive.
 196   The chain is in the same order as the members are.  */
 197
 198 struct mapelt
 199 {
 200   struct member_desc info;
 201   struct mapelt *next;
 202 };
 203
 204 struct mapelt *maplast;
 205
 206 /* If nonzero, this is the map-element for the __.SYMDEF member
 207    and we should update the time of that member just before finishing.  */
 208 struct mapelt *symdef_mapelt;
 209
 210 /* Header that we wrote for the __.SYMDEF member.  */
 211 struct ar_hdr symdef_header;
 212
 213 /* Name this program was run with. */
 214 char *program_name;
 215 \f
 216 #ifndef __STDC__
 217 char *xmalloc (), *xrealloc ();
 218 void free ();
 219
 220 void add_to_map (), delete_from_map ();
 221 int insert_in_map ();
 222 void print_descr ();
 223 char *concat ();
 224 void scan ();
 225 void extract_members ();
 226 void extract_member ();
 227 void print_contents ();
 228 void write_symdef_member ();
 229 void read_old_symdefs ();
 230 void two_operations ();
 231 void usage (), fatal (), error (), error3(), error_with_file ();
 232 void perror_with_name (), pfatal_with_name ();
 233 void write_archive ();
 234 void touch_symdef_member ();
 235 void update_symdefs ();
 236 void delete_members (), move_members (), replace_members ();
 237 void quick_append ();
 238 char *basename ();
 239 void print_modes ();
 240 char *make_tempname ();
 241 void copy_out_member ();
 242 #define const
 243 #else
 244 /* Grrr. */
 245 extern void error (char * s1, char * s2);
 246 extern void error3 (char * s1, char * s2, char * s3);
 247
 248 extern void fatal (char * s1, char * s2);
 249 extern void extract_members (void (*function) (struct member_desc member, FILE *istream));
 250 extern void scan (void (*function) (struct member_desc member, FILE *istream), int crflag);
 251 extern char *basename (char *path);
 252 extern char *concat (const char *s1, const char *s2, const char *s3);
 253 extern char *make_tempname (char *name);
 254 extern char *xmalloc (unsigned int size);
 255 extern char *xrealloc (char *ptr, unsigned int size);
 256 extern int filter_symbols (struct nlist *syms, unsigned int symcount);
 257 extern int insert_in_map (char *name, struct mapelt *map, struct mapelt *after);
 258 extern int main (int argc, char **argv);
 259 extern int move_in_map (char *name, struct mapelt *map, struct mapelt *after);
 260 extern int read_header_info (struct mapelt *mapelt, int desc, long int offset, long int *syms_offset, unsigned int *syms_size, long int *strs_offset, unsigned int *strs_size);
 261 extern struct mapelt *find_mapelt (struct mapelt *map, char *name);
 262 extern struct mapelt *find_mapelt_noerror (struct mapelt *map, register char *name);
 263 extern struct mapelt *last_mapelt (struct mapelt *map);
 264 extern struct mapelt *make_map (int nonexistent_ok);
 265 extern struct mapelt *prev_mapelt (struct mapelt *map, struct mapelt *elt);
 266 extern void add_to_map (struct member_desc member, FILE * istream);
 267 extern void close_archive (void);
 268 extern void copy_out_member (struct mapelt *mapelt, int archive_indesc, int outdesc, char *outname);
 269 extern void delete_from_map (char *name, struct mapelt *map);
 270 extern void delete_members (void);
 271 extern void error_with_file (char *string, struct mapelt *mapelt);
 272 extern void extract_member (struct member_desc member, FILE *istream);
 273 extern void header_from_map (struct ar_hdr *header, struct mapelt *mapelt);
 274 extern void lock_for_update (void);
 275 extern void make_new_symdefs (struct mapelt *mapelt, int archive_indesc);
 276 extern void move_members (void);
 277 extern void mywrite (int desc, void *buf, int bytes, char *file);
 278 extern void perror_with_name (char *name);
 279 extern void pfatal_with_name (char *name);
 280 extern void print_contents (struct member_desc member, FILE *istream);
 281 extern void print_descr (struct member_desc member, FILE * instream);
 282 extern void print_modes (int modes);
 283 extern void quick_append (void);
 284 extern void read_old_symdefs (struct mapelt *map, int archive_indesc);
 285 extern void replace_members (void);
 286 extern void touch_symdef_member (int outdesc, char *outname);
 287 extern void two_operations (void);
 288 extern void update_symdefs (struct mapelt *map, int archive_indesc);
 289 extern void usage (char *s1, int val);
 290 extern void write_archive (struct mapelt *map, int appendflag);
 291 extern void write_symdef_member (struct mapelt *mapelt, struct mapelt *map, int outdesc, char *outname);
 292 #endif
 293 \f
 294 /* Output BYTES of data at BUF to the descriptor DESC.
 295    FILE is the name of the file (for error messages).  */
 296
 297 void
 298 mywrite (desc, pbuf, bytes, file)
 299      int desc;
 300      void *pbuf;
 301      int bytes;
 302      char *file;
 303 {
 304   register int val;
 305   register char * buf = pbuf;
 306
 307   while (bytes > 0)
 308     {
 309       val = write (desc, buf, bytes);
 310       if (val <= 0)
 311         perror_with_name (file);
 312       buf += val;
 313       bytes -= val;
 314     }
 315 }
 316
 317 int
 318 main (argc, argv)
 319      int argc;
 320      char **argv;
 321 {
 322   int i;
 323
 324   operation = 0;
 325   verbose = 0;
 326   newer_only = 0;
 327   silent_create = 0;
 328   posname = 0;
 329   postype = POS_DEFAULT;
 330   preserve_dates = 0;
 331   symdef_flag = 0;
 332   symdef_exists = 0;
 333   ignore_symdef = 0;
 334   symdef_mapelt = 0;
 335   files = 0;
 336   lock_indesc = -1;
 337
 338   program_name = argv[0];
 339
 340   if (argc < 2)
 341     usage ("too few command arguments", 0);
 342
 343   {
 344     char *key = argv[1];
 345     char *p = key;
 346     char c;
 347
 348     if (*p == '-')
 349       p++;
 350    while ((c = *p++))
 351       {
 352         switch (c)
 353           {
 354           case 'a':
 355             postype = POS_AFTER;
 356             break;
 357
 358           case 'b':
 359             postype = POS_BEFORE;
 360             break;
 361
 362           case 'c':
 363             silent_create = 1;
 364             break;
 365
 366           case 'd':
 367             if (operation)
 368               two_operations ();
 369
 370             operation = DELETE;
 371             break;
 372
 373           case 'i':
 374             postype = POS_BEFORE;
 375             break;
 376
 377           case 'l':
 378             break;
 379
 380           case 'm':
 381             if (operation)
 382               two_operations ();
 383             operation = MOVE;
 384             break;
 385
 386           case 'o':
 387             preserve_dates = 1;
 388             break;
 389
 390           case 'p':
 391             if (operation)
 392               two_operations ();
 393             operation = PRINT_FILES;
 394             break;
 395
 396           case 'q':
 397             if (operation)
 398               two_operations ();
 399             operation = QUICK_APPEND;
 400             break;
 401
 402           case 'r':
 403             if (operation)
 404               two_operations ();
 405             operation = REPLACE;
 406             break;
 407
 408           case 's':
 409             symdef_flag = 1;
 410             break;
 411
 412           case 't':
 413             if (operation)
 414               two_operations ();
 415             operation = PRINT_TABLE;
 416             break;
 417
 418           case 'u':
 419             operation = REPLACE;
 420             newer_only = 1;
 421             break;
 422
 423           case 'v':
 424             verbose = 1;
 425             break;
 426
 427           case 'x':
 428             if (operation)
 429               two_operations ();
 430             operation = EXTRACT;
 431             break;
 432           }
 433       }
 434
 435   }
 436
 437   if (operation == 0 && symdef_flag)
 438     operation = REPLACE;
 439
 440   if (operation == 0)
 441     usage ("no operation specified", 0);
 442
 443   i = 2;
 444
 445   if (postype != POS_DEFAULT)
 446   {
 447     if (i < argc)
 448       posname = argv[i++];
 449     else
 450       usage ("no position operand", 0);
 451   }
 452
 453   if (i >= argc)
 454     usage ("no archive specified", 0);
 455   archive = argv[i++];
 456
 457   if (i < argc)
 458     {
 459       files = &argv[i];
 460       while (i < argc)
 461         if (!strcmp (argv[i++], "__.SYMDEF"))
 462           {
 463             ignore_symdef = 1;
 464             break;
 465           }
 466     }
 467
 468   switch (operation)
 469     {
 470     case EXTRACT:
 471         extract_members (extract_member);
 472         break;
 473
 474     case PRINT_TABLE:
 475         extract_members (print_descr);
 476         break;
 477
 478     case PRINT_FILES:
 479         extract_members (print_contents);
 480         break;
 481
 482     case DELETE:
 483         if (files != 0)
 484           delete_members ();
 485         break;
 486
 487     case MOVE:
 488         if (files != 0)
 489           move_members ();
 490         break;
 491
 492     case REPLACE:
 493         if (files != 0 || symdef_flag)
 494           replace_members ();
 495         break;
 496
 497     case QUICK_APPEND:
 498         if (files != 0)
 499           quick_append ();
 500         break;
 501
 502     default:
 503         usage ("invalid operation %d", operation);
 504     }
 505
 506   exit (0);
 507 }
 508
 509 void
 510 two_operations ()
 511 {
 512   usage ("two different operation switches specified", 0);
 513 }
 514 \f
 515 void
 516 scan (function, crflag)
 517 #ifdef __STDC__
 518      void (*function) (struct member_desc member, FILE *istream);
 519 #else
 520      void (*function) ();
 521 #endif
 522      int crflag;
 523 {
 524   FILE *arcstream = fopen (archive, "r");
 525
 526   if (arcstream == 0 && crflag)
 527     /* Creation-warning, if desired, will happen later.  */
 528     return;
 529
 530   if (arcstream == 0)
 531     {
 532       perror_with_name (archive);
 533       exit (1);
 534     }
 535   {
 536     char buf[SARMAG];
 537     int nread = fread (buf, 1, SARMAG, arcstream);
 538     if (nread != SARMAG || bcmp (buf, ARMAG, SARMAG))
 539       fatal ("file %s not a valid archive", archive);
 540   }
 541
 542   /* Now find the members one by one.  */
 543   {
 544     int member_offset = SARMAG;
 545     while (1)
 546       {
 547         int nread;
 548         struct ar_hdr member_header;
 549         struct member_desc member_desc;
 550         char name [1 + sizeof member_header.ar_name];
 551
 552         if (fseek (arcstream, member_offset, 0) < 0)
 553           perror_with_name (archive);
 554
 555         nread = fread (&member_header, 1, sizeof (struct ar_hdr), arcstream);
 556         if (nread == 0)
 557           /* No data left means end of file; that is OK.  */
 558           break;
 559
 560         if (nread != sizeof (member_header)
 561             || bcmp (member_header.ar_fmag, ARFMAG, 2))
 562           fatal ("file %s not a valid archive", archive);
 563         bcopy (member_header.ar_name, name, sizeof member_header.ar_name);
 564         {
 565           char *p = name + sizeof member_header.ar_name;
 566           *p = '\0';
 567           while (p > name && *--p == ' ')
 568             *p = '\0';
 569 #if defined(USG) || defined(HAVE_TRAILING_SLASH_IN_NAME)
 570           if (*p == '/')        /* Since V.2, names are terminated with '/' */
 571             *p = '\0';
 572 #endif
 573         }
 574         member_desc.name = name;
 575         sscanf (member_header.ar_mode, "%o", &member_desc.mode);
 576         member_desc.date = atoi (member_header.ar_date);
 577         member_desc.size = atoi (member_header.ar_size);
 578         member_desc.uid = atoi (member_header.ar_uid);
 579         member_desc.gid = atoi (member_header.ar_gid);
 580         member_desc.offset = member_offset;
 581         member_desc.data_offset = member_offset + sizeof (member_header);
 582
 583         member_desc.new_offset = 0;
 584         member_desc.symdefs = 0;
 585         member_desc.nsymdefs = 0;
 586         member_desc.string_size = 0;
 587
 588         if (!ignore_symdef && !strcmp (name, "__.SYMDEF"))
 589           symdef_exists = 1;
 590
 591         function (member_desc, arcstream);
 592
 593         member_offset += sizeof (member_header) + member_desc.size;
 594         if (member_offset & 1)
 595           ++member_offset;
 596       }
 597   }
 598
 599
 600   fclose (arcstream);
 601 }
 602 \f
 603 void
 604 print_descr (member, instream)
 605      struct member_desc member;
 606      FILE * instream;
 607 {
 608   char *timestring;
 609   if (!verbose)
 610     {
 611       puts (member.name);
 612       return;
 613     }
 614   print_modes (member.mode);
 615   timestring = ctime (&member.date);
 616   printf (" %2d/%2d %6d %12.12s %4.4s %s\n",
 617           member.uid, member.gid,
 618           member.size, timestring + 4, timestring + 20,
 619           member.name);
 620 }
 621
 622 void
 623 print_modes (modes)
 624      int modes;
 625 {
 626   putchar (modes & 0400 ? 'r' : '-');
 627   putchar (modes & 0200 ? 'w' : '-');
 628   putchar (modes & 0100 ? 'x' : '-');
 629   putchar (modes & 040 ? 'r' : '-');
 630   putchar (modes & 020 ? 'w' : '-');
 631   putchar (modes & 010 ? 'x' : '-');
 632   putchar (modes & 04 ? 'r' : '-');
 633   putchar (modes & 02 ? 'w' : '-');
 634   putchar (modes & 01 ? 'x' : '-');
 635 }
 636 \f
 637 #define BUFSIZE 1024
 638
 639 void
 640 extract_member (member, istream)
 641      struct member_desc member;
 642      FILE *istream;
 643 {
 644   int ncopied = 0;
 645   FILE *ostream;
 646
 647   fseek (istream, member.data_offset, 0);
 648   ostream = fopen (member.name, "w");
 649   if (!ostream)
 650     {
 651       perror_with_name (member.name);
 652       return;
 653     }
 654
 655   if (verbose)
 656     printf ("x - %s\n", member.name);
 657
 658   while (ncopied < member.size)
 659     {
 660       char buf [BUFSIZE];
 661       int tocopy = member.size - ncopied;
 662       int nread;
 663       if (tocopy > BUFSIZE) tocopy = BUFSIZE;
 664       nread = fread (buf, 1, tocopy, istream);
 665       if (nread != tocopy)
 666         fatal ("error reading archive %s", archive);
 667       fwrite (buf, 1, nread, ostream);
 668       ncopied += tocopy;
 669     }
 670
 671 #ifdef HAVE_FCHMOD
 672   fchmod (fileno (ostream), member.mode);
 673 #else
 674   chmod (member.name, member.mode);
 675 #endif
 676   if (ferror (ostream) || fclose (ostream) != 0)
 677     error ("%s: I/O error", member.name);
 678
 679   if (preserve_dates)
 680     {
 681 #if defined(USG) || defined(__BCC__)
 682       long tv[2];
 683       tv[0] = member.date;
 684       tv[1] = member.date;
 685       utime (member.name, tv);
 686 #else
 687       struct timeval tv[2];
 688       tv[0].tv_sec = member.date;
 689       tv[0].tv_usec = 0;
 690       tv[1].tv_sec = member.date;
 691       tv[1].tv_usec = 0;
 692       utimes (member.name, tv);
 693 #endif
 694     }
 695 }
 696 \f
 697 void
 698 print_contents (member, istream)
 699      struct member_desc member;
 700      FILE *istream;
 701 {
 702   int ncopied = 0;
 703
 704   fseek (istream, member.data_offset, 0);
 705
 706   if (verbose)
 707   printf ("\n<member %s>\n\n", member.name);
 708
 709   while (ncopied < member.size)
 710     {
 711       char buf [BUFSIZE];
 712       int tocopy = member.size - ncopied;
 713       int nread;
 714       if (tocopy > BUFSIZE) tocopy = BUFSIZE;
 715       nread = fread (buf, 1, tocopy, istream);
 716       if (nread != tocopy)
 717         fatal ("file %s not a valid archive", archive);
 718       fwrite (buf, 1, nread, stdout);
 719       ncopied += tocopy;
 720     }
 721 }
 722 \f
 723 /* Make a map of the existing members of the archive: their names,
 724  positions and sizes.  */
 725
 726 /* If `nonexistent_ok' is nonzero,
 727  just return 0 for an archive that does not exist.
 728  This will cause the ordinary supersede procedure to
 729  create a new archive.  */
 730
 731 struct mapelt *
 732 make_map (nonexistent_ok)
 733      int nonexistent_ok;
 734 {
 735   struct mapelt mapstart;
 736   mapstart.next = 0;
 737   maplast = &mapstart;
 738   scan (add_to_map, nonexistent_ok);
 739   return mapstart.next;
 740 }
 741
 742 void
 743 add_to_map (member, istream)
 744      struct member_desc member;
 745      FILE * istream;
 746 {
 747   struct mapelt *mapelt = (struct mapelt *) xmalloc (sizeof (struct mapelt));
 748   mapelt->info = member;
 749   mapelt->info.name = concat (mapelt->info.name, "", "");
 750   maplast->next = mapelt;
 751   mapelt->next = 0;
 752   maplast = mapelt;
 753 }
 754
 755 /* Return the last element of the specified map.  */
 756
 757 struct mapelt *
 758 last_mapelt (map)
 759      struct mapelt *map;
 760 {
 761   struct mapelt *tail = map;
 762   while (tail->next) tail = tail->next;
 763   return tail;
 764 }
 765
 766 /* Return the element of the specified map which precedes elt.  */
 767
 768 struct mapelt *
 769 prev_mapelt (map, elt)
 770      struct mapelt *map, *elt;
 771 {
 772   struct mapelt *tail = map;
 773   while (tail->next && tail->next != elt)
 774     tail = tail->next;
 775   if (tail->next) return tail;
 776   return 0;
 777 }
 778
 779 /* Return the element of the specified map which has the specified name.  */
 780
 781 struct mapelt *
 782 find_mapelt_noerror (map, name)
 783      struct mapelt *map;
 784      register char *name;
 785 {
 786   register struct mapelt *tail;
 787   unsigned int len;
 788   int dot_o;
 789
 790   name = basename (name);
 791   len = strlen (name);
 792   dot_o = name[len - 2] == '.' && name[len - 1] == 'o';
 793
 794   for (tail = map; tail != 0; tail = tail->next)
 795     {
 796       if (tail->info.name == 0)
 797         continue;
 798       if (!strncmp (tail->info.name, name, 13))
 799         {
 800           unsigned int eltlen = strlen (tail->info.name);
 801           if (len <= 13 || eltlen <= 13)
 802             return tail;
 803           else
 804             {
 805               char *p = tail->info.name + 13;
 806               if (dot_o && p[0] == '.' && p[1] == 'o' && p[2] == '\0')
 807                 return tail;
 808               else if (!strncmp (p, name + 13,
 809                                  (len > eltlen ? len : eltlen) - 13))
 810                 return tail;
 811             }
 812         }
 813     }
 814
 815   return 0;
 816 }
 817
 818 struct mapelt *
 819 find_mapelt (map, name)
 820      struct mapelt *map;
 821      char *name;
 822 {
 823   register struct mapelt *found = find_mapelt_noerror (map, name);
 824   if (found == 0)
 825     error ("no member named `%s'", name);
 826   return found;
 827 }
 828 \f
 829 /* Before looking at the archive, if we are going to update it
 830    based on looking at its current contents, make an exclusive lock on it.
 831    The lock is released when `write_archive' is called.  */
 832
 833 void
 834 lock_for_update ()
 835 {
 836   /* Open the existing archive file; if that fails, create an empty one.  */
 837
 838   lock_indesc = open (archive, O_RDWR, 0);
 839
 840   if (lock_indesc < 0)
 841     {
 842       int outdesc;
 843
 844       if (!silent_create)
 845         printf ("Creating archive file `%s'\n", archive);
 846       outdesc = open (archive, O_WRONLY | O_APPEND | O_CREAT, 0666);
 847       if (outdesc < 0)
 848         pfatal_with_name (archive);
 849       mywrite (outdesc, ARMAG, SARMAG, archive);
 850       close (outdesc);
 851
 852       /* Now we had better be able to open for update!  */
 853
 854       lock_indesc = open (archive, O_RDWR, 0);
 855       if (lock_indesc < 0)
 856         {
 857           unlink (archive);
 858           pfatal_with_name (archive);
 859         }
 860     }
 861
 862 #ifdef LOCKS
 863   /* Lock the old file so that it won't be updated by two programs at once.
 864      This uses the fcntl locking facility found on Sun systems
 865      which is also in POSIX.  (Perhaps it comes from sysV.)
 866
 867      Note that merely reading an archive does not require a lock,
 868      because we use `rename' to update the whole file atomically.  */
 869
 870   {
 871     struct flock lock;
 872
 873     lock.l_type = F_WRLCK;
 874     lock.l_whence = 0;
 875     lock.l_start = 0;
 876     lock.l_len = 0;
 877
 878     while (1)
 879       {
 880         int value = fcntl (lock_indesc, F_SETLKW, &lock);
 881         if (value >= 0)
 882           break;
 883         else if (errno == EINTR)
 884           continue;
 885         else
 886           pfatal_with_name ("locking archive");
 887       }
 888   }
 889 #endif
 890 }
 891
 892 /* Unlock archive and close the file descriptor.  */
 893
 894 void
 895 close_archive ()
 896 {
 897 #ifdef LOCKS
 898   {
 899     struct flock lock;
 900
 901     /* Unlock the old archive.  */
 902
 903     lock.l_type = F_UNLCK;
 904     lock.l_whence = 0;
 905     lock.l_start = 0;
 906     lock.l_len = 0;
 907
 908     fcntl (lock_indesc, F_SETLK, &lock);
 909   }
 910 #endif
 911
 912   /* Close the archive.  If we renamed a new one, the old one disappears.  */
 913   close (lock_indesc);
 914 }
 915 \f
 916 /* Write a new archive file from a given map.  */
 917 /* When a map is used as the pattern for a new archive,
 918  each element represents one member to put in it, and
 919  the order of elements controls the order of writing.
 920
 921  Ordinarily, the element describes a member of the old
 922  archive, to be copied into the new one.
 923
 924  If the `offset' field of the element's info is 0,
 925  then the element describes a file to be copied into the
 926  new archive.  The `name' field is the file's name.
 927
 928  If the `name' field of an element is 0, the element is ignored.
 929  This makes it easy to specify deletion of archive members.
 930
 931  Every operation that will eventually call `write_archive'
 932  should call `lock_for_update' before beginning
 933  to do any I/O on the archive file.
 934 */
 935
 936 void
 937 write_archive (map, appendflag)
 938      struct mapelt *map;
 939      int appendflag;
 940 {
 941   char *tempname = make_tempname (archive);
 942   int indesc = lock_indesc;
 943   int outdesc;
 944   char *outname;
 945   struct mapelt *tail;
 946
 947   /* Now open the output.  */
 948
 949   if (!appendflag)
 950     {
 951       /* Updating an existing archive normally.
 952          Write output as TEMPNAME and rename at the end.
 953          There can never be two invocations trying to do this at once,
 954          because of the lock made on the old archive file.  */
 955
 956       outdesc = open (tempname, O_WRONLY | O_CREAT, 0666);
 957       if (outdesc < 0)
 958         pfatal_with_name (tempname);
 959       outname = tempname;
 960       mywrite (outdesc, ARMAG, SARMAG, outname);
 961     }
 962   else
 963     {
 964       /* Fast-append to existing archive.  */
 965
 966       outdesc = open (archive, O_WRONLY | O_APPEND, 0);
 967       if (outdesc < 0)
 968         pfatal_with_name (archive);
 969       outname = archive;
 970     }
 971
 972   /* If archive has or should have a __.SYMDEF member,
 973      compute the contents for it.  */
 974
 975   if (symdef_flag || symdef_exists)
 976     {
 977       if (symdef_exists)
 978         read_old_symdefs (map, indesc);
 979       else
 980         {
 981           struct mapelt *this = (struct mapelt *)
 982             xmalloc (sizeof (struct mapelt));
 983           this->info.name = "__.SYMDEF";
 984           this->info.offset = SARMAG;
 985           this->info.data_offset = SARMAG + sizeof (struct ar_hdr);
 986           this->info.new_offset = 0;
 987           this->info.date = 0;
 988           this->info.size = 0;
 989           this->info.uid = 0;
 990           this->info.gid = 0;
 991           this->info.mode = 0666;
 992           this->info.symdefs = 0;
 993           this->info.nsymdefs = 0;
 994           this->info.string_size = 0;
 995           this->next = map;
 996           map = this;
 997           original_num_symdefs = 0;
 998           old_strings_size = 0;
 999         }
1000
1001       update_symdefs (map, indesc);
1002     }
1003
1004   /* Copy the members into the output, either from the old archive
1005      or from specified files.  */
1006
1007   for (tail = map; tail != 0; tail = tail->next)
1008     {
1009       if ((symdef_flag || symdef_exists) && tail->info.name
1010           && !strcmp (tail->info.name, "__.SYMDEF")
1011 #if 0
1012           && tail->info.date==0
1013 #endif
1014           )
1015         write_symdef_member (tail, map, outdesc, outname);
1016       else
1017         copy_out_member (tail, indesc, outdesc, outname);
1018     }
1019
1020   if (symdef_mapelt != 0)
1021     {
1022       /* Check for members whose data offsets weren't
1023          known when the symdef member was first written.  */
1024       int doneany = 0;
1025       for (tail = map; tail != 0; tail = tail->next)
1026         if (tail->info.offset == 0)
1027           {
1028             /* Fix up the symdefs.  */
1029             register unsigned int i;
1030             for (i = 0; i < tail->info.nsymdefs; ++i)
1031               tail->info.symdefs[i].offset = tail->info.new_offset;
1032             doneany = 1;
1033           }
1034       if (doneany)
1035         {
1036           /* Some files had bad symdefs; rewrite the symdef member.  */
1037           lseek (outdesc, symdef_mapelt->info.offset, 0);
1038           write_symdef_member (symdef_mapelt, map, outdesc, outname);
1039         }
1040     }
1041
1042   /* Mark the __.SYMDEF member as up to date.  */
1043
1044   if (symdef_mapelt != 0)
1045     touch_symdef_member (outdesc, outname);
1046
1047   /* Install the new output under the intended name.  */
1048
1049 #ifdef HAVE_FSYNC
1050   fsync (outdesc);
1051 #endif
1052   close (outdesc);
1053
1054   if (!appendflag)
1055     if (rename (tempname, archive))
1056       pfatal_with_name (tempname);
1057
1058   close_archive ();
1059 }
1060
1061 void
1062 header_from_map (header, mapelt)
1063      struct ar_hdr *header;
1064      struct mapelt *mapelt;
1065 {
1066   unsigned int namelen;
1067   char *p;
1068
1069   /* Zero the header, then store in the data as text.  */
1070   bzero ((char *) header, sizeof (*header));
1071
1072   p = basename (mapelt->info.name);
1073   strncpy (header->ar_name, p, sizeof (header->ar_name));
1074   namelen = strlen (p);
1075   if (namelen >= sizeof (header->ar_name))
1076     {
1077       if (mapelt->info.name[namelen - 2] == '.' &&
1078           mapelt->info.name[namelen - 1] == 'o')
1079         {
1080           header->ar_name[sizeof (header->ar_name) - 3] = '.';
1081           header->ar_name[sizeof (header->ar_name) - 2] = 'o';
1082         }
1083       header->ar_name[sizeof (header->ar_name) - 1] = '\0';
1084       error3 ("member name `%s' truncated to `%s'",
1085              mapelt->info.name, header->ar_name);
1086     }
1087 #if defined(USG) || defined(HAVE_TRAILING_SLASH_IN_NAME)
1088   {
1089     /* System V tacks a trailing '/' onto the end of the name */
1090     char *p = header->ar_name;
1091     char *end = p + sizeof (header->ar_name);
1092
1093     while (p < end && *p)
1094       p++;
1095     *p = '/';
1096   }
1097 #endif
1098
1099   sprintf (header->ar_date, "%ld", mapelt->info.date);
1100   sprintf (header->ar_size, "%d", mapelt->info.size);
1101   sprintf (header->ar_uid, "%d", mapelt->info.uid);
1102   sprintf (header->ar_gid, "%d", mapelt->info.gid);
1103   sprintf (header->ar_mode, "%o", mapelt->info.mode);
1104   strncpy (header->ar_fmag, ARFMAG, sizeof (header->ar_fmag));
1105
1106   /* Change all remaining nulls in the header into spaces.  */
1107   {
1108     char *end = (char *) &header[1];
1109     register char *p;
1110     for (p = (char *) header; p < end; ++p)
1111       if (*p == '\0')
1112         *p = ' ';
1113   }
1114 }
1115
1116 /* gets just the file part of name */
1117
1118 char *
1119 basename (path)
1120      char *path;
1121 {
1122   char *save, *start;
1123   for (start = save = path; *path; path++)
1124     if (*path == '/')
1125       save = path + 1;
1126
1127   if (save != start)
1128     return save;
1129   else
1130     return start;
1131 }
1132
1133 /* writes to file open on OUTDESC with name OUTNAME.  */
1134 void
1135 copy_out_member (mapelt, archive_indesc, outdesc, outname)
1136      struct mapelt *mapelt;
1137      int archive_indesc;
1138      int outdesc;
1139      char *outname;
1140 {
1141   struct ar_hdr header;
1142   int indesc;
1143
1144   if (mapelt->info.name == 0)
1145     /* This element was cancelled.  */
1146     return;
1147
1148   header_from_map (&header, mapelt);
1149
1150   if (mapelt->info.offset != 0)
1151     {
1152       indesc = archive_indesc;
1153       lseek (indesc, mapelt->info.data_offset, 0);
1154     }
1155   else
1156     {
1157       indesc = open (mapelt->info.name, 0, 0);
1158       if (indesc < 0)
1159         {
1160           perror_with_name (mapelt->info.name);
1161           return;
1162         }
1163     }
1164
1165   mywrite (outdesc, &header, sizeof (header), outname);
1166
1167   if (mapelt->info.data_offset == 0)
1168     mapelt->info.data_offset = lseek (outdesc, 0L, 1);
1169
1170   {
1171     char buf[BUFSIZE];
1172     int tocopy = mapelt->info.size;
1173     while (tocopy > 0)
1174       {
1175         int thistime = tocopy;
1176         if (thistime > BUFSIZE) thistime = BUFSIZE;
1177         read (indesc, buf, thistime);
1178         mywrite (outdesc, buf, thistime, outname);
1179         tocopy -= thistime;
1180       }
1181   }
1182
1183   if (indesc != archive_indesc)
1184     close (indesc);
1185
1186   if (mapelt->info.size & 1)
1187     mywrite (outdesc, "\n", 1, outname);
1188 }
1189
1190 /* Update the time of the __.SYMDEF member; done when we updated
1191    that member, just before we close the new archive file.
1192    It is open on OUTDESC and its name is OUTNAME.  */
1193
1194 void
1195 touch_symdef_member (outdesc, outname)
1196      int outdesc;
1197      char *outname;
1198 {
1199   struct stat statbuf;
1200   int i;
1201
1202   /* See what mtime the archive file has as a result of our writing it.  */
1203   fstat (outdesc, &statbuf);
1204
1205   /* Advance member's time to that time.  */
1206   bzero (symdef_header.ar_date, sizeof symdef_header.ar_date);
1207   sprintf (symdef_header.ar_date, "%ld", statbuf.st_mtime);
1208   for (i = 0; i < sizeof symdef_header.ar_date; i++)
1209     if (symdef_header.ar_date[i] == 0)
1210       symdef_header.ar_date[i] = ' ';
1211
1212   /* Write back this member's header with the new time.  */
1213   if (lseek (outdesc, symdef_mapelt->info.new_offset, 0) >= 0)
1214     mywrite (outdesc, &symdef_header, sizeof symdef_header, outname);
1215 }
1216
1217 char *
1218 make_tempname (name)
1219      char *name;
1220 {
1221 #if defined(USG) || defined(SHORT_FILENAME)
1222   /* sigh. 14 character filenames are *wonderful*, just *wonderful*. */
1223   char *p = basename (name);
1224   char *q, *r;
1225
1226   if (p != name)
1227     {
1228       q = concat (name, "", "");        /* get a fresh copy */
1229       r = basename (q); /* r points just after last '/' */
1230       *--r = '\0';
1231       return concat (q, "/t_", p);
1232     }
1233   else if (strlen (name) >= 14)
1234     return concat ("t_", name, "");
1235   else
1236 #endif
1237   return concat (name, "", "_supersede");
1238 }
1239 \f
1240 void
1241 delete_members ()
1242 {
1243   struct mapelt *map = make_map (0);
1244   struct mapelt mapstart;
1245   char **p;
1246
1247   mapstart.info.name = 0;
1248   mapstart.next = map;
1249   map = &mapstart;
1250
1251   lock_for_update ();
1252
1253   if (files)
1254     for (p = files; *p; p++)
1255       {
1256         /* If user says to delete the __.SYMDEF member,
1257            don't make a new one to replace it.  */
1258         if (!strcmp (*p, "__.SYMDEF"))
1259           symdef_exists = 0;
1260         delete_from_map (*p, map);
1261       }
1262
1263   write_archive (map->next, 0);
1264 }
1265
1266 void
1267 delete_from_map (name, map)
1268      char *name;
1269      struct mapelt *map;
1270 {
1271   struct mapelt *this = find_mapelt (map, name);
1272
1273   if (!this) return;
1274   this->info.name = 0;
1275   if (verbose)
1276     printf ("d - %s\n", name);
1277 }
1278 \f
1279 void
1280 move_members ()
1281 {
1282   struct mapelt *map = make_map (0);
1283   char **p;
1284   struct mapelt *after_mapelt = 0;
1285   struct mapelt mapstart;
1286   struct mapelt *change_map;
1287
1288   mapstart.info.name = 0;
1289   mapstart.next = map;
1290   change_map = &mapstart;
1291
1292   lock_for_update ();
1293
1294   switch (postype)
1295     {
1296     case POS_DEFAULT:
1297       after_mapelt = last_mapelt (change_map);
1298       break;
1299
1300     case POS_AFTER:
1301       after_mapelt = find_mapelt (map, posname);
1302       break;
1303
1304     case POS_BEFORE:
1305       after_mapelt = prev_mapelt (change_map, find_mapelt (map, posname));
1306     }
1307
1308   /* Failure to find specified "before" or "after" member
1309      is a fatal error; message has already been printed.  */
1310
1311   if (!after_mapelt) exit (1);
1312
1313   if (files)
1314     for (p = files; *p; p++)
1315       {
1316         if (move_in_map (*p, change_map, after_mapelt))
1317           after_mapelt = after_mapelt->next;
1318       }
1319
1320   write_archive (map, 0);
1321 }
1322
1323 int
1324 move_in_map (name, map, after)
1325      char *name;
1326      struct mapelt *map, *after;
1327 {
1328   struct mapelt *this = find_mapelt (map, name);
1329   struct mapelt *prev;
1330
1331   if (!this) return 0;
1332   prev = prev_mapelt (map, this);
1333   prev->next = this->next;
1334   this->next = after->next;
1335   after->next = this;
1336   return 1;
1337 }
1338 \f
1339 /* Insert files into the archive.  */
1340
1341 void
1342 replace_members ()
1343 {
1344   struct mapelt *map = make_map (1);
1345   struct mapelt mapstart;
1346   struct mapelt *after_mapelt = 0;
1347   struct mapelt *change_map;
1348   char **p;
1349   int changed;
1350
1351   mapstart.info.name = 0;
1352   mapstart.next = map;
1353   change_map = &mapstart;
1354
1355   lock_for_update ();
1356
1357   switch (postype)
1358     {
1359     case POS_DEFAULT:
1360       after_mapelt = last_mapelt (change_map);
1361       break;
1362
1363     case POS_AFTER:
1364       after_mapelt = find_mapelt (map, posname);
1365       break;
1366
1367     case POS_BEFORE:
1368       after_mapelt = prev_mapelt (change_map, find_mapelt (map, posname));
1369     }
1370
1371   /* Failure to find specified "before" or "after" member
1372      is a fatal error; the message has already been printed.  */
1373   if (after_mapelt == 0)
1374     exit (1);
1375
1376   changed = 0;
1377   if (files != 0)
1378     for (p = files; *p != 0; ++p)
1379       if (insert_in_map (*p, change_map, after_mapelt))
1380         {
1381           after_mapelt = after_mapelt->next;
1382           changed = 1;
1383         }
1384
1385   change_map = change_map->next;
1386   if (!changed && (!symdef_flag || symdef_exists))
1387     /* Nothing changed.  */
1388     close_archive ();
1389   else
1390     write_archive (change_map, 0);
1391 }
1392 \f
1393 /* Handle the "quick insert" operation.  */
1394
1395 void
1396 quick_append ()
1397 {
1398   struct mapelt *map;
1399   struct mapelt *after;
1400   struct mapelt mapstart;
1401   char **p;
1402
1403   mapstart.info.name = 0;
1404   mapstart.next = 0;
1405   map = &mapstart;
1406   after = map;
1407
1408   lock_for_update ();
1409
1410   /* Insert the specified files into the "map",
1411      but is a map of the inserted files only,
1412      and starts out empty.  */
1413   if (files)
1414     for (p = files; *p; p++)
1415       {
1416         if (insert_in_map (*p, map, after))
1417           after = after->next;
1418       }
1419
1420   /* Append these files to the end of the existing archive file.  */
1421
1422   write_archive (map->next, 1);
1423 }
1424 \f
1425 /* Insert an entry for name NAME into the map MAP after the map entry AFTER.
1426    Delete an old entry for NAME.
1427    MAP is assumed to start with a dummy entry, which facilitates
1428    insertion at the beginning of the list.
1429    Return 1 if successful, 0 if did nothing because file NAME doesn't
1430    exist or (optionally) is older.  */
1431
1432 int
1433 insert_in_map (name, map, after)
1434      char *name;
1435      struct mapelt *map, *after;
1436 {
1437   struct mapelt *old = find_mapelt_noerror (map, name);
1438   struct mapelt *this;
1439   struct stat status;
1440
1441   if (stat (name, &status))
1442     {
1443       perror_with_name (name);
1444       return 0;
1445     }
1446   if (old && newer_only && status.st_mtime <= old->info.date)
1447     return 0;
1448   if (old)
1449     /* Delete the old one.  */
1450     old->info.name = 0;
1451   this = (struct mapelt *) xmalloc (sizeof (struct mapelt));
1452   this->info.name = name;
1453   this->info.offset = 0;
1454   this->info.data_offset = 0;
1455   this->info.date = status.st_mtime;
1456   this->info.size = status.st_size;
1457   this->info.uid = status.st_uid;
1458   this->info.gid = status.st_gid;
1459   this->info.mode = status.st_mode;
1460   /* Always place a __.SYMDEF member first in the archive, regardless
1461      of any position specifications.  */
1462   if (! strcmp (name, "__.SYMDEF"))
1463     this->next = map->next, map->next = this;
1464   else
1465     this->next = after->next, after->next = this;
1466
1467   if (verbose)
1468     printf ("%c - %s\n", old == 0 ? 'a' : 'r', this->info.name);
1469
1470   return 1;
1471 }
1472 \f
1473 /* Apply a function to each of the specified members.
1474 */
1475
1476 void
1477 extract_members (function)
1478 #ifdef __STDC__
1479      void (*function) (struct member_desc member, FILE *istream);
1480 #else
1481      void (*function) ();
1482 #endif
1483 {
1484   struct mapelt *map;
1485   FILE *arcstream;
1486   char **p;
1487
1488   if (!files)
1489     {
1490       /* Handle case where we want to operate on every member.
1491          No need to make a map and search it for this.  */
1492       scan (function, 0);
1493       return;
1494     }
1495
1496   arcstream = fopen (archive, "r");
1497   if (!arcstream)
1498     fatal ("failure opening archive %s for the second time", archive);
1499   map = make_map (0);
1500
1501   for (p = files; *p; p++)
1502     {
1503       struct mapelt *this = find_mapelt (map, *p);
1504       if (!this) continue;
1505       function (this->info, arcstream);
1506     }
1507
1508   fclose (arcstream);
1509 }
1510 \f
1511
1512 /* Write the __.SYMDEF member from data in core.  OUTDESC and OUTNAME
1513    are descriptor and name of file to write to.  */
1514
1515 void
1516 write_symdef_member (mapelt, map, outdesc, outname)
1517      struct mapelt *mapelt;
1518      struct mapelt *map;
1519      int outdesc;
1520      char *outname;
1521 {
1522   struct ar_hdr header;
1523   struct mapelt *mapptr;
1524   unsigned long int symdefs_size;
1525
1526   if (mapelt->info.name == 0)
1527     /* This element was cancelled.  */
1528     return;
1529
1530   header_from_map (&header, mapelt);
1531
1532   bcopy (&header, &symdef_header, sizeof header);
1533
1534   mywrite (outdesc, &header, sizeof (header), outname);
1535
1536   /* Write the number of symdefs.  */
1537   symdefs_size = nsymdefs * sizeof (struct symdef);
1538 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1539   md_number_to_chars (symdefs_size, sizeof symdefs_size,
1540                       (unsigned char *) &symdefs_size);
1541 #endif
1542   mywrite (outdesc, &symdefs_size, sizeof symdefs_size, outname);
1543
1544   /* Write symdefs surviving from old archive.  */
1545 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1546   md_symdefs_to_chars ((struct md_symdef *) old_symdefs, num_old_symdefs,
1547                        (unsigned char *) old_symdefs);
1548 #endif
1549   mywrite (outdesc, old_symdefs, num_old_symdefs * sizeof (struct symdef),
1550            outname);
1551 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1552   md_chars_to_symdefs ((unsigned char *) old_symdefs,
1553                        (struct md_symdef *) old_symdefs, num_old_symdefs);
1554 #endif
1555
1556   /* Write symdefs for new members.  */
1557   for (mapptr = map; mapptr != 0; mapptr = mapptr->next)
1558     if (mapptr->info.nsymdefs != 0)
1559       {
1560 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1561         md_symdefs_to_chars ((struct md_symdef *) mapptr->info.symdefs,
1562                              mapptr->info.nsymdefs,
1563                              (unsigned char *) mapptr->info.symdefs);
1564 #endif
1565         write (outdesc, mapptr->info.symdefs,
1566                mapptr->info.nsymdefs * sizeof (struct symdef));
1567 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1568         md_chars_to_symdefs ((unsigned char *) mapptr->info.symdefs,
1569                              (struct md_symdef *) mapptr->info.symdefs,
1570                              mapptr->info.nsymdefs);
1571 #endif
1572       }
1573
1574   /* Write the string table size.  */
1575 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1576   md_number_to_chars (new_strings_size, sizeof new_strings_size,
1577                       (unsigned char *) &new_strings_size);
1578 #endif
1579   mywrite (outdesc, &new_strings_size, sizeof new_strings_size, outname);
1580 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1581   new_strings_size = md_chars_to_number ((unsigned char *) &new_strings_size,
1582                                          sizeof new_strings_size);
1583 #endif
1584
1585   /* Write the string table.  */
1586   mywrite (outdesc, new_strings, new_strings_size, outname);
1587
1588   if (mapelt->info.size & 1)
1589     mywrite (outdesc, "", 1, outname);
1590 }
1591 \f
1592 void
1593 read_old_symdefs (map, archive_indesc)
1594      struct mapelt *map;
1595      int archive_indesc;
1596 {
1597   struct mapelt *mapelt;
1598   char *data;
1599   int val;
1600   int symdefs_size;
1601
1602   mapelt = find_mapelt_noerror (map, "__.SYMDEF");
1603   if (!mapelt)
1604     abort ();                   /* Only call here if an old one exists */
1605
1606   data  = (char *) xmalloc (mapelt->info.size);
1607   lseek (archive_indesc, mapelt->info.data_offset, 0);
1608   val = read (archive_indesc, data, mapelt->info.size);
1609
1610 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1611   symdefs_size = md_chars_to_number ((unsigned char *) data,
1612                                      sizeof symdefs_size);
1613 #else
1614   symdefs_size = *(unsigned long int *) data;
1615 #endif
1616   original_num_symdefs = symdefs_size / sizeof (struct symdef);
1617   old_symdefs = (struct symdef *) (data + sizeof (symdefs_size));
1618 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1619   md_chars_to_symdefs ((unsigned char *) old_symdefs,
1620                        (struct md_symdef *) old_symdefs, original_num_symdefs);
1621 #endif
1622   old_strings = ((char *) (old_symdefs + original_num_symdefs)
1623                  + sizeof (symdefs_size));
1624 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1625   old_strings_size
1626     = md_chars_to_number ((unsigned char *) (old_symdefs
1627                                              + original_num_symdefs),
1628                           sizeof old_strings_size);
1629 #else
1630   old_strings_size
1631     = *(unsigned long int *) (old_symdefs + original_num_symdefs);
1632 #endif
1633 }
1634 \f
1635 /* Read various information from the header of an object file.
1636    Return 0 for failure or 1 for success.  */
1637
1638 int
1639 read_header_info (mapelt, desc, offset, syms_offset, syms_size, strs_offset, strs_size)
1640      struct mapelt *mapelt;
1641      int desc;
1642      long int offset;
1643      long int *syms_offset;
1644      unsigned int *syms_size;
1645      long int *strs_offset;
1646      unsigned int *strs_size;
1647 {
1648     struct exec hdr;
1649     int len;
1650
1651     lseek (desc, offset, 0);
1652 #ifdef HEADER_SEEK_FD
1653     HEADER_SEEK_FD (desc);
1654 #endif
1655
1656     len = read (desc, (char *) &hdr, sizeof hdr);
1657 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1658     md_chars_to_hdr ((unsigned char *) &hdr, &hdr);
1659 #endif
1660     if (len == sizeof hdr && !N_BADMAG(hdr))
1661       {
1662         *syms_offset = N_SYMOFF (hdr);
1663         *syms_size = hdr.a_syms;
1664         *strs_offset = N_STROFF (hdr);
1665         lseek (desc, N_STROFF (hdr) + offset, 0);
1666         if (read (desc, (char *) strs_size, sizeof *strs_size) != sizeof *strs_size)
1667           {
1668             error_with_file ("failure reading string table size in ", mapelt);
1669             return 0;
1670           }
1671 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1672         *strs_size = md_chars_to_number ((unsigned char *) strs_size,
1673                                          sizeof *strs_size);
1674 #endif
1675         return 1;
1676       }
1677
1678   error_with_file ("bad format (not an object file) in ", mapelt);
1679   return 0;
1680 }
1681 \f
1682 /* Create the info.symdefs for a new member
1683    by reading the file it is coming from.  */
1684
1685 void
1686 make_new_symdefs (mapelt, archive_indesc)
1687      struct mapelt *mapelt;
1688      int archive_indesc;
1689 {
1690   int indesc;
1691   char *name = mapelt->info.name;
1692   long int syms_offset, strs_offset;
1693   unsigned int syms_size, strs_size;
1694   struct nlist *symbols;
1695   int symcount;
1696   char *strings;
1697   register unsigned int i;
1698   unsigned long int offset;
1699
1700   if (name == 0)
1701     /* Deleted member.  */
1702     abort ();
1703
1704   if (mapelt->info.offset != 0)
1705     {
1706       indesc = archive_indesc;
1707       lseek (indesc, mapelt->info.data_offset, 0);
1708       offset = mapelt->info.data_offset;
1709     }
1710   else
1711     {
1712       indesc = open (mapelt->info.name, 0, 0);
1713       if (indesc < 0)
1714         {
1715           perror_with_name (mapelt->info.name);
1716           return;
1717         }
1718       offset = 0;
1719     }
1720
1721   if (!read_header_info (mapelt, indesc, offset, &syms_offset, &syms_size, &strs_offset, &strs_size))
1722     {
1723       if (mapelt->info.offset == 0)
1724         close (indesc);
1725       return;
1726     }
1727
1728   /* Number of symbol entries in the file.  */
1729   symcount = syms_size / sizeof (struct nlist);
1730   /* Allocate temporary space for the symbol entries.  */
1731   symbols = (struct nlist *) alloca (syms_size);
1732   /* Read in the symbols.  */
1733   lseek (indesc, syms_offset + offset, 0);
1734   if (read (indesc, (char *) symbols, syms_size) != syms_size)
1735     {
1736       error_with_file ("premature end of file in symbols of ", mapelt);
1737       if (mapelt->info.offset == 0)
1738         (void) close (indesc);
1739       return;
1740     }
1741 #ifdef HOST_TARGET_ENDIANESS_DIFFERS
1742   md_chars_to_nlist ((unsigned char *) symbols, symbols, symcount);
1743 #endif
1744
1745   /* The string table size includes the size word.  */
1746   if (strs_size < sizeof (strs_size))
1747     {
1748       error_with_file ("bad string table size in ", mapelt);
1749       if (mapelt->info.offset == 0)
1750         (void) close (indesc);
1751       return;
1752     }
1753   strs_size -= sizeof (strs_size);
1754
1755   /* Allocate permanent space for the string table.  */
1756   strings = (char *) xmalloc (strs_size);
1757
1758   /* Read in the strings.  */
1759   lseek (indesc, offset + strs_offset + sizeof strs_size, 0);
1760   if (read (indesc, strings, strs_size) != strs_size)
1761     {
1762       error_with_file ("premature end of file in strings of ", mapelt);
1763       if (mapelt->info.offset == 0)
1764         (void) close (indesc);
1765       return;
1766     }
1767
1768   if (indesc != archive_indesc)
1769     (void) close (indesc);
1770
1771   /* Discard the symbols we don't want to mention; compact the rest down.  */
1772   symcount = filter_symbols (symbols, symcount);
1773
1774   mapelt->info.symdefs = (struct symdef *)
1775     xmalloc (symcount * sizeof (struct symdef));
1776   mapelt->info.nsymdefs = symcount;
1777   mapelt->info.string_size = 0;
1778
1779   for (i = 0; i < symcount; ++i)
1780     {
1781       unsigned long int stroff = symbols[i].n_un.n_strx - sizeof (strs_size);
1782       char *symname = strings + stroff;
1783       if (stroff > strs_size)
1784         {
1785           char buf[100];
1786           sprintf (buf, "ridiculous string offset %lu in symbol %u of ",
1787                    stroff + sizeof (strs_size), i);
1788           error_with_file (buf, mapelt);
1789           return;
1790         }
1791       mapelt->info.symdefs[i].s.name = symname;
1792       mapelt->info.string_size += strlen (symname) + 1;
1793     }
1794 }
1795 \f
1796 /* Choose which symbol entries to mention in __.SYMDEF;
1797    compact them downward to get rid of the rest.
1798    Return the number of symbols left.  */
1799
1800 int
1801 filter_symbols (syms, symcount)
1802      struct nlist *syms;
1803      unsigned int symcount;
1804 {
1805   struct nlist *from, *to;
1806   struct nlist *end = syms + symcount;
1807
1808   for (to = from = syms; from < end; ++from)
1809     if ((from->n_type & N_EXT)
1810         && (from->n_type != N_EXT || from->n_value != 0))
1811       *to++ = *from;
1812
1813   return to - syms;
1814 }
1815
1816 \f
1817 /* Update the __.SYMDEF data before writing a new archive.  */
1818
1819 void
1820 update_symdefs (map, archive_indesc)
1821      struct mapelt *map;
1822      int archive_indesc;
1823 {
1824   struct mapelt *tail;
1825   int pos;
1826   register unsigned int i;
1827   unsigned int len;
1828   struct symdef *s;
1829   unsigned long int deleted_strings_size = 0;
1830
1831   nsymdefs = original_num_symdefs;
1832   num_old_symdefs = original_num_symdefs;
1833   new_strings_size = old_strings_size;
1834
1835   if (nsymdefs != 0)
1836     {
1837       /* We already had a __.SYMDEF member, so just update it.  */
1838
1839       /* Mark as canceled any old symdefs for members being deleted.  */
1840
1841       for (tail = map; tail != 0; tail = tail->next)
1842         {
1843           if (tail->info.name == 0)
1844             {
1845               /* Old member being deleted.  Delete its symdef entries too.  */
1846               for (i = 0; i < original_num_symdefs; i++)
1847                 if (old_symdefs[i].offset == tail->info.offset)
1848                   {
1849                     old_symdefs[i].offset = 0;
1850                     --nsymdefs;
1851                     deleted_strings_size
1852                       += strlen (old_strings
1853                                  + old_symdefs[i].s.stringoffset) + 1;
1854                   }
1855             }
1856         }
1857
1858       /* Compactify old symdefs.  */
1859       {
1860         register unsigned int j = 0;
1861         for (i = 0; i < num_old_symdefs; ++i)
1862           {
1863             if (j != i)
1864               old_symdefs[j] = old_symdefs[i];
1865             if (old_symdefs[i].offset != 0)
1866               ++j;
1867           }
1868         num_old_symdefs -= i - j;
1869       }
1870
1871       /* Create symdef data for any new members.  */
1872       for (tail = map; tail != 0; tail = tail->next)
1873         {
1874           if (tail->info.offset != 0
1875               || tail->info.name == 0
1876               || !strcmp (tail->info.name, "__.SYMDEF"))
1877             continue;
1878           make_new_symdefs (tail, archive_indesc);
1879           nsymdefs += tail->info.nsymdefs;
1880           new_strings_size += tail->info.string_size;
1881         }
1882     }
1883   else
1884     {
1885       /* Create symdef data for all existing members.  */
1886
1887       for (tail = map; tail != 0; tail = tail->next)
1888         {
1889           if (tail->info.name == 0
1890               || !strcmp (tail->info.name, "__.SYMDEF"))
1891             continue;
1892           make_new_symdefs (tail, archive_indesc);
1893           nsymdefs += tail->info.nsymdefs;
1894           new_strings_size += tail->info.string_size;
1895         }
1896     }
1897
1898   new_strings_size -= deleted_strings_size;
1899   old_strings_size -= deleted_strings_size;
1900
1901   /* Now we know the size of __.SYMDEF,
1902      so assign the positions of all the members.  */
1903
1904   tail = find_mapelt_noerror (map, "__.SYMDEF");
1905   tail->info.size = (sizeof (nsymdefs) + (nsymdefs * sizeof (struct symdef))
1906                      + sizeof (new_strings_size) + new_strings_size);
1907   symdef_mapelt = tail;
1908
1909   pos = SARMAG;
1910   for (tail = map; tail != 0; tail = tail->next)
1911     {
1912       if (tail->info.name == 0)
1913         /* Ignore deleted members.  */
1914         continue;
1915       tail->info.new_offset = pos;
1916       pos += sizeof (struct ar_hdr) + tail->info.size;
1917       if (tail->info.size & 1)
1918         ++pos;
1919     }
1920
1921   /* Now update the offsets in the symdef data
1922      to be the new offsets rather than the old ones.  */
1923
1924   for (tail = map; tail != 0; tail = tail->next)
1925     {
1926       if (tail->info.name == 0)
1927         continue;
1928       if (tail->info.symdefs == 0)
1929         /* Member without new symdef data.
1930            Check the old symdef data; it may be included there. */
1931         for (i = 0; i < num_old_symdefs; i++)
1932           {
1933             if (old_symdefs[i].offset == tail->info.offset)
1934               old_symdefs[i].offset = tail->info.new_offset;
1935           }
1936       else
1937         for (i = 0; i < tail->info.nsymdefs; i++)
1938           tail->info.symdefs[i].offset = tail->info.new_offset;
1939     }
1940
1941   /* Generate new, combined string table and put each string's offset into the
1942      symdef that refers to it.  Note that old symdefs ref their strings by
1943      offsets into old_strings but new symdefs contain addresses of strings.  */
1944
1945   new_strings = (char *) xmalloc (new_strings_size);
1946   pos = 0;
1947
1948   /* Write the strings of the old symdefs and update the structures
1949      to contain indices into the string table instead of strings.  */
1950   for (i = 0; i < num_old_symdefs; i++)
1951     {
1952       strcpy (new_strings + pos, old_strings + old_symdefs[i].s.stringoffset);
1953       old_symdefs[i].s.stringoffset = pos;
1954       pos += strlen (new_strings + pos) + 1;
1955     }
1956   if (pos < old_strings_size)
1957     {
1958       unsigned int d = old_strings_size - pos;
1959       /* Correct the string table size.  */
1960       new_strings_size -= d;
1961       /* Correct the size of the `__.SYMDEF' member,
1962          since it contains the string table.  */
1963       symdef_mapelt->info.size -= d;
1964     }
1965   else if (pos > old_strings_size)
1966     fatal ("Old archive's string size was %u too small.",
1967            (void*)(pos - old_strings_size));
1968
1969   for (tail = map; tail != 0; tail = tail->next)
1970     if (tail->info.symdefs)
1971       {
1972         len = tail->info.nsymdefs;
1973         s = tail->info.symdefs;
1974
1975         for (i = 0; i < len; i++)
1976           {
1977             strcpy (new_strings + pos, s[i].s.name);
1978             s[i].s.stringoffset = pos;
1979             pos += strlen (new_strings + pos) + 1;
1980           }
1981       }
1982   if (pos != new_strings_size)
1983     fatal ("internal error: inconsistency in new_strings_size", 0);
1984 }
1985
1986 \f
1987 /* Print error message and usage message, and exit.  */
1988
1989 void
1990 usage (s1, val)
1991      char *s1;
1992      int val;
1993 {
1994   char vbuf[16];
1995   sprintf(vbuf, "%d", val);
1996   error (s1, vbuf);
1997   fprintf (stderr, "\
1998 Usage: %s [d|m|p|q|r|t|x [[abi [position-name] [cilouv]] archive file...\n",
1999            program_name);
2000   exit (1);
2001 }
2002
2003 /* Print error message and exit.  */
2004
2005 void
2006 fatal (s1, s2)
2007      char *s1, *s2;
2008 {
2009   error (s1, s2);
2010   exit (1);
2011 }
2012
2013 /* Print error message.  `s1' is printf control string, the rest are args.  */
2014
2015 void
2016 error (s1, s2)
2017      char *s1, *s2;
2018 {
2019   fprintf (stderr, "%s: ", program_name);
2020   fprintf (stderr, s1, s2);
2021   fprintf (stderr, "\n");
2022 }
2023
2024 void
2025 error3 (s1, s2, s3)
2026      char *s1, *s2, *s3;
2027 {
2028   fprintf (stderr, "%s: ", program_name);
2029   fprintf (stderr, s1, s2, s3);
2030   fprintf (stderr, "\n");
2031 }
2032
2033 void
2034 error_with_file (string, mapelt)
2035      char *string;
2036      struct mapelt *mapelt;
2037 {
2038   fprintf (stderr, "%s: ", program_name);
2039   fprintf (stderr, string);
2040   if (mapelt->info.offset != 0)
2041     fprintf (stderr, "%s(%s)", archive, mapelt->info.name);
2042   else
2043     fprintf (stderr, "%s", mapelt->info.name);
2044   fprintf (stderr, "\n");
2045 }
2046
2047 void
2048 perror_with_name (name)
2049      char *name;
2050 {
2051   error (concat ("", strerror(errno), " for %s"), name);
2052 }
2053
2054 void
2055 pfatal_with_name (name)
2056      char *name;
2057 {
2058   fatal (concat ("", strerror(errno), " for %s"), name);
2059 }
2060
2061 /* Return a newly-allocated string whose contents
2062    concatenate those of S1, S2, and S3.  */
2063
2064 char *
2065 concat (s1, s2, s3)
2066      const char *s1, *s2, *s3;
2067 {
2068   int len1 = strlen (s1), len2 = strlen (s2), len3 = strlen (s3);
2069   char *result = (char *) xmalloc (len1 + len2 + len3 + 1);
2070
2071   strcpy (result, s1);
2072   strcpy (result + len1, s2);
2073   strcpy (result + len1 + len2, s3);
2074   *(result + len1 + len2 + len3) = 0;
2075
2076   return result;
2077 }
2078
2079 /* Like malloc but get fatal error if memory is exhausted.  */
2080
2081 char *
2082 xmalloc (size)
2083      unsigned int size;
2084 {
2085 #ifdef MALLOC_0_RETURNS_NULL
2086   char *result = malloc (size ? size : 1);
2087 #else
2088   char *result = malloc (size);
2089 #endif
2090   if (result == 0)
2091     fatal ("virtual memory exhausted", 0);
2092   return result;
2093 }
2094
2095 char *
2096 xrealloc (ptr, size)
2097      char *ptr;
2098      unsigned int size;
2099 {
2100   char *result = realloc (ptr, size);
2101   if (result == 0)
2102     fatal ("virtual memory exhausted", 0);
2103   return result;
2104 }
2105
2106 \f
2107 #ifndef HAVE_RENAME
2108 int
2109 rename (from, to)
2110      char *from, *to;
2111 {
2112   (void)unlink (to);
2113   if (link (from, to) < 0
2114       || unlink (from) < 0)
2115     return -1;
2116   else
2117     return 0;
2118 }
2119 #else
2120 #ifdef ATT
2121 int Error;
2122 #endif
2123 #endif