arscan.c

   1 /* Library function for scanning an archive file.
   2 Copyright (C) 1987,89,91,92,93,94,95,97 Free Software Foundation, Inc.
   3
   4 This program is free software; you can redistribute it and/or modify
   5 it under the terms of the GNU General Public License as published by
   6 the Free Software Foundation; either version 2, or (at your option)
   7 any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12 GNU General Public License for more details.
  13
  14 You should have received a copy of the GNU General Public License
  15 along with this program; if not, write to the Free Software
  16 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  17
  18 #include "make.h"
  19
  20 #ifdef HAVE_FCNTL_H
  21 #include <fcntl.h>
  22 #else
  23 #include <sys/file.h>
  24 #endif
  25
  26 #ifndef NO_ARCHIVES
  27 \f
  28 #ifdef VMS
  29 #include <lbrdef.h>
  30 #include <mhddef.h>
  31 #include <credef.h>
  32 #include <descrip.h>
  33 #include <ctype.h>
  34 #if __DECC
  35 #include <unixlib.h>
  36 #include <lbr$routines.h>
  37 #endif
  38
  39 #define uppercasify(str) {char *str1; for (str1 = str; *str1; str1++) *str1 = _toupper(*str1);}
  40
  41 static void *VMS_lib_idx;
  42
  43 static char *VMS_saved_memname;
  44
  45 static time_t VMS_member_date;
  46
  47 static long int (*VMS_function) ();
  48
  49 static int
  50 VMS_get_member_info (module, rfa)
  51      struct dsc$descriptor_s *module;
  52      unsigned long *rfa;
  53 {
  54   int status, i;
  55   long int fnval;
  56
  57   time_t val;
  58
  59   static struct dsc$descriptor_s bufdesc =
  60     { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
  61
  62   struct mhddef *mhd;
  63   char filename[128];
  64
  65   bufdesc.dsc$a_pointer = filename;
  66   bufdesc.dsc$w_length = sizeof (filename);
  67
  68   status = lbr$set_module (&VMS_lib_idx, rfa, &bufdesc,
  69                            &bufdesc.dsc$w_length, 0);
  70   if (! status)
  71     {
  72       error ("lbr$set_module failed to extract module info, status = %d",
  73              status);
  74
  75       lbr$close (&VMS_lib_idx);
  76
  77       return 0;
  78     }
  79
  80   mhd = (struct mhddef *) filename;
  81
  82   val = decc$fix_time (&mhd->mhd$l_datim);
  83
  84   for (i = 0; i < module->dsc$w_length; i++)
  85     filename[i] = _tolower (module->dsc$a_pointer[i]);
  86
  87   filename[i] = '\0';
  88
  89   VMS_member_date = (time_t) -1;
  90
  91   fnval =
  92     (*VMS_function) (-1, filename, 0, 0, 0, 0, val, 0, 0, 0,
  93                      VMS_saved_memname);
  94
  95   if (fnval)
  96     {
  97       VMS_member_date = fnval;
  98       return 0;
  99     }
 100   else
 101     return 1;
 102 }
 103
 104 /* Takes three arguments ARCHIVE, FUNCTION and ARG.
 105
 106    Open the archive named ARCHIVE, find its members one by one,
 107    and for each one call FUNCTION with the following arguments:
 108      archive file descriptor for reading the data,
 109      member name,
 110      member name might be truncated flag,
 111      member header position in file,
 112      member data position in file,
 113      member data size,
 114      member date,
 115      member uid,
 116      member gid,
 117      member protection mode,
 118      ARG.
 119
 120    NOTE: on VMS systems, only name, date, and arg are meaningful!
 121
 122    The descriptor is poised to read the data of the member
 123    when FUNCTION is called.  It does not matter how much
 124    data FUNCTION reads.
 125
 126    If FUNCTION returns nonzero, we immediately return
 127    what FUNCTION returned.
 128
 129    Returns -1 if archive does not exist,
 130    Returns -2 if archive has invalid format.
 131    Returns 0 if have scanned successfully.  */
 132
 133 long int
 134 ar_scan (archive, function, arg)
 135      char *archive;
 136      long int (*function) ();
 137      long int arg;
 138 {
 139   char *p;
 140
 141   static struct dsc$descriptor_s libdesc =
 142     { 0, DSC$K_DTYPE_T, DSC$K_CLASS_S, NULL };
 143
 144   unsigned long func = LBR$C_READ;
 145   unsigned long type = LBR$C_TYP_UNK;
 146   unsigned long index = 1;
 147
 148   int status;
 149
 150   status = lbr$ini_control (&VMS_lib_idx, &func, &type, 0);
 151
 152   if (! status)
 153     {
 154       error ("lbr$ini_control failed with status = %d",status);
 155       return -2;
 156     }
 157
 158   libdesc.dsc$a_pointer = archive;
 159   libdesc.dsc$w_length = strlen (archive);
 160
 161   status = lbr$open (&VMS_lib_idx, &libdesc, 0, 0, 0, 0, 0);
 162
 163   if (! status)
 164     {
 165       error ("unable to open library `%s' to lookup member `%s'",
 166              archive, (char *)arg);
 167       return -1;
 168     }
 169
 170   VMS_saved_memname = (char *)arg;
 171
 172   /* For comparison, delete .obj from arg name.  */
 173
 174   p = rindex (VMS_saved_memname, '.');
 175   if (p)
 176     *p = '\0';
 177
 178   VMS_function = function;
 179
 180   lbr$get_index (&VMS_lib_idx, &index, VMS_get_member_info, 0);
 181
 182   /* Undo the damage.  */
 183   if (p)
 184     *p = '.';
 185
 186   lbr$close (&VMS_lib_idx);
 187
 188   return VMS_member_date > 0 ? VMS_member_date : 0;
 189 }
 190
 191 #else /* !VMS */
 192
 193 /* SCO Unix's compiler defines both of these.  */
 194 #ifdef  M_UNIX
 195 #undef  M_XENIX
 196 #endif
 197
 198 /* On the sun386i and in System V rel 3, ar.h defines two different archive
 199    formats depending upon whether you have defined PORTAR (normal) or PORT5AR
 200    (System V Release 1).  There is no default, one or the other must be defined
 201    to have a nonzero value.  */
 202
 203 #if (!defined (PORTAR) || PORTAR == 0) && (!defined (PORT5AR) || PORT5AR == 0)
 204 #undef  PORTAR
 205 #ifdef M_XENIX
 206 /* According to Jim Sievert <jas1@rsvl.unisys.com>, for SCO XENIX defining
 207    PORTAR to 1 gets the wrong archive format, and defining it to 0 gets the
 208    right one.  */
 209 #define PORTAR 0
 210 #else
 211 #define PORTAR 1
 212 #endif
 213 #endif
 214
 215 #include <ar.h>
 216
 217 /* Cray's <ar.h> apparently defines this.  */
 218 #ifndef AR_HDR_SIZE
 219 #define AR_HDR_SIZE     (sizeof (struct ar_hdr))
 220 #endif
 221 \f
 222 /* Takes three arguments ARCHIVE, FUNCTION and ARG.
 223
 224    Open the archive named ARCHIVE, find its members one by one,
 225    and for each one call FUNCTION with the following arguments:
 226      archive file descriptor for reading the data,
 227      member name,
 228      member name might be truncated flag,
 229      member header position in file,
 230      member data position in file,
 231      member data size,
 232      member date,
 233      member uid,
 234      member gid,
 235      member protection mode,
 236      ARG.
 237
 238    The descriptor is poised to read the data of the member
 239    when FUNCTION is called.  It does not matter how much
 240    data FUNCTION reads.
 241
 242    If FUNCTION returns nonzero, we immediately return
 243    what FUNCTION returned.
 244
 245    Returns -1 if archive does not exist,
 246    Returns -2 if archive has invalid format.
 247    Returns 0 if have scanned successfully.  */
 248
 249 long int
 250 ar_scan (archive, function, arg)
 251      char *archive;
 252      long int (*function) ();
 253      long int arg;
 254 {
 255 #ifdef AIAMAG
 256   FL_HDR fl_header;
 257 #else
 258   int long_name = 0;
 259 #endif
 260   char *namemap = 0;
 261   register int desc = open (archive, O_RDONLY, 0);
 262   if (desc < 0)
 263     return -1;
 264 #ifdef SARMAG
 265   {
 266     char buf[SARMAG];
 267     register int nread = read (desc, buf, SARMAG);
 268     if (nread != SARMAG || bcmp (buf, ARMAG, SARMAG))
 269       {
 270         (void) close (desc);
 271         return -2;
 272       }
 273   }
 274 #else
 275 #ifdef AIAMAG
 276   {
 277     register int nread = read (desc, (char *) &fl_header, FL_HSZ);
 278     if (nread != FL_HSZ || bcmp (fl_header.fl_magic, AIAMAG, SAIAMAG))
 279       {
 280         (void) close (desc);
 281         return -2;
 282       }
 283   }
 284 #else
 285   {
 286 #ifndef M_XENIX
 287     int buf;
 288 #else
 289     unsigned short int buf;
 290 #endif
 291     register int nread = read(desc, &buf, sizeof (buf));
 292     if (nread != sizeof (buf) || buf != ARMAG)
 293       {
 294         (void) close (desc);
 295         return -2;
 296       }
 297   }
 298 #endif
 299 #endif
 300
 301   /* Now find the members one by one.  */
 302   {
 303 #ifdef SARMAG
 304     register long int member_offset = SARMAG;
 305 #else
 306 #ifdef AIAMAG
 307     long int member_offset;
 308     long int last_member_offset;
 309
 310     sscanf (fl_header.fl_fstmoff, "%12ld", &member_offset);
 311     sscanf (fl_header.fl_lstmoff, "%12ld", &last_member_offset);
 312
 313     if (member_offset == 0)
 314       {
 315         /* Empty archive.  */
 316         close (desc);
 317         return 0;
 318       }
 319 #else
 320 #ifndef M_XENIX
 321     register long int member_offset = sizeof (int);
 322 #else   /* Xenix.  */
 323     register long int member_offset = sizeof (unsigned short int);
 324 #endif  /* Not Xenix.  */
 325 #endif
 326 #endif
 327
 328     while (1)
 329       {
 330         register int nread;
 331         struct ar_hdr member_header;
 332 #ifdef AIAMAG
 333         char name[256];
 334         int name_len;
 335         long int dateval;
 336         int uidval, gidval;
 337         long int data_offset;
 338 #else
 339         char namebuf[sizeof member_header.ar_name + 1];
 340         char *name;
 341         int is_namemap;         /* Nonzero if this entry maps long names.  */
 342 #endif
 343         long int eltsize;
 344         int eltmode;
 345         long int fnval;
 346
 347         if (lseek (desc, member_offset, 0) < 0)
 348           {
 349             (void) close (desc);
 350             return -2;
 351           }
 352
 353 #ifdef AIAMAG
 354 #define AR_MEMHDR       (AR_HDR_SIZE - sizeof (member_header._ar_name))
 355         nread = read (desc, (char *) &member_header, AR_MEMHDR);
 356
 357         if (nread != AR_MEMHDR)
 358           {
 359             (void) close (desc);
 360             return -2;
 361           }
 362
 363         sscanf (member_header.ar_namlen, "%4d", &name_len);
 364         nread = read (desc, name, name_len);
 365
 366         if (nread != name_len)
 367           {
 368             (void) close (desc);
 369             return -2;
 370           }
 371
 372         name[name_len] = 0;
 373
 374         sscanf (member_header.ar_date, "%12ld", &dateval);
 375         sscanf (member_header.ar_uid, "%12d", &uidval);
 376         sscanf (member_header.ar_gid, "%12d", &gidval);
 377         sscanf (member_header.ar_mode, "%12o", &eltmode);
 378         sscanf (member_header.ar_size, "%12ld", &eltsize);
 379
 380         if ((data_offset = member_offset + AR_MEMHDR + name_len + 2) % 2)
 381             ++data_offset;
 382
 383         fnval =
 384           (*function) (desc, name, 0,
 385                        member_offset, data_offset, eltsize,
 386                        dateval, uidval, gidval,
 387                        eltmode, arg);
 388
 389 #else   /* Not AIAMAG.  */
 390         nread = read (desc, (char *) &member_header, AR_HDR_SIZE);
 391         if (nread == 0)
 392           /* No data left means end of file; that is OK.  */
 393           break;
 394
 395         if (nread != AR_HDR_SIZE
 396 #ifdef ARFMAG
 397             || bcmp (member_header.ar_fmag, ARFMAG, 2)
 398 #endif
 399             )
 400           {
 401             (void) close (desc);
 402             return -2;
 403           }
 404
 405         name = namebuf;
 406         bcopy (member_header.ar_name, name, sizeof member_header.ar_name);
 407         {
 408           register char *p = name + sizeof member_header.ar_name;
 409           do
 410             *p = '\0';
 411           while (p > name && *--p == ' ');
 412
 413 #ifndef AIAMAG
 414           /* If the member name is "//" or "ARFILENAMES/" this may be
 415              a list of file name mappings.  The maximum file name
 416              length supported by the standard archive format is 14
 417              characters.  This member will actually always be the
 418              first or second entry in the archive, but we don't check
 419              that.  */
 420           is_namemap = (!strcmp (name, "//")
 421                         || !strcmp (name, "ARFILENAMES/"));
 422 #endif  /* Not AIAMAG. */
 423           /* On some systems, there is a slash after each member name.  */
 424           if (*p == '/')
 425             *p = '\0';
 426
 427 #ifndef AIAMAG
 428           /* If the member name starts with a space or a slash, this
 429              is an index into the file name mappings (used by GNU ar).
 430              Otherwise if the member name looks like #1/NUMBER the
 431              real member name appears in the element data (used by
 432              4.4BSD).  */
 433           if (! is_namemap
 434               && (name[0] == ' ' || name[0] == '/')
 435               && namemap != 0)
 436             {
 437               name = namemap + atoi (name + 1);
 438               long_name = 1;
 439             }
 440           else if (name[0] == '#'
 441                    && name[1] == '1'
 442                    && name[2] == '/')
 443             {
 444               int namesize = atoi (name + 3);
 445
 446               name = (char *) alloca (namesize + 1);
 447               nread = read (desc, name, namesize);
 448               if (nread != namesize)
 449                 {
 450                   close (desc);
 451                   return -2;
 452                 }
 453               name[namesize] = '\0';
 454
 455               long_name = 1;
 456             }
 457 #endif /* Not AIAMAG. */
 458         }
 459
 460 #ifndef M_XENIX
 461         sscanf (member_header.ar_mode, "%o", &eltmode);
 462         eltsize = atol (member_header.ar_size);
 463 #else   /* Xenix.  */
 464         eltmode = (unsigned short int) member_header.ar_mode;
 465         eltsize = member_header.ar_size;
 466 #endif  /* Not Xenix.  */
 467
 468         fnval =
 469           (*function) (desc, name, ! long_name, member_offset,
 470                        member_offset + AR_HDR_SIZE, eltsize,
 471 #ifndef M_XENIX
 472                        atol (member_header.ar_date),
 473                        atoi (member_header.ar_uid),
 474                        atoi (member_header.ar_gid),
 475 #else   /* Xenix.  */
 476                        member_header.ar_date,
 477                        member_header.ar_uid,
 478                        member_header.ar_gid,
 479 #endif  /* Not Xenix.  */
 480                        eltmode, arg);
 481
 482 #endif  /* AIAMAG.  */
 483
 484         if (fnval)
 485           {
 486             (void) close (desc);
 487             return fnval;
 488           }
 489
 490 #ifdef AIAMAG
 491         if (member_offset == last_member_offset)
 492           /* End of the chain.  */
 493           break;
 494
 495         sscanf (member_header.ar_nxtmem, "%12ld", &member_offset);
 496
 497         if (lseek (desc, member_offset, 0) != member_offset)
 498           {
 499             (void) close (desc);
 500             return -2;
 501           }
 502 #else
 503
 504         /* If this member maps archive names, we must read it in.  The
 505            name map will always precede any members whose names must
 506            be mapped.  */
 507         if (is_namemap)
 508           {
 509             char *clear;
 510             char *limit;
 511
 512             namemap = (char *) alloca (eltsize);
 513             nread = read (desc, namemap, eltsize);
 514             if (nread != eltsize)
 515               {
 516                 (void) close (desc);
 517                 return -2;
 518               }
 519
 520             /* The names are separated by newlines.  Some formats have
 521                a trailing slash.  Null terminate the strings for
 522                convenience.  */
 523             limit = namemap + eltsize;
 524             for (clear = namemap; clear < limit; clear++)
 525               {
 526                 if (*clear == '\n')
 527                   {
 528                     *clear = '\0';
 529                     if (clear[-1] == '/')
 530                       clear[-1] = '\0';
 531                   }
 532               }
 533
 534             is_namemap = 0;
 535           }
 536
 537         member_offset += AR_HDR_SIZE + eltsize;
 538         if (member_offset % 2 != 0)
 539           member_offset++;
 540 #endif
 541       }
 542   }
 543
 544   close (desc);
 545   return 0;
 546 }
 547 #endif /* !VMS */
 548 \f
 549 /* Return nonzero iff NAME matches MEM.
 550    If TRUNCATED is nonzero, MEM may be truncated to
 551    sizeof (struct ar_hdr.ar_name) - 1.  */
 552
 553 int
 554 ar_name_equal (name, mem, truncated)
 555      char *name, *mem;
 556      int truncated;
 557 {
 558   char *p;
 559
 560   p = rindex (name, '/');
 561   if (p != 0)
 562     name = p + 1;
 563
 564   /* We no longer use this kludge, since we
 565      now support long archive member names.  */
 566
 567 #if 0 && !defined (AIAMAG) && !defined (APOLLO)
 568
 569   {
 570     /* `reallylongname.o' matches `reallylongnam.o'.
 571        If member names have a trailing slash, that's `reallylongna.o'.  */
 572
 573     struct ar_hdr h;
 574     unsigned int max = sizeof (h.ar_name);
 575     unsigned int namelen, memlen;
 576
 577     if (strncmp (name, mem, max - 3))
 578       return 0;
 579
 580     namelen = strlen (name);
 581     memlen = strlen (mem);
 582
 583     if (namelen > memlen && memlen >= max - 1
 584         && name[namelen - 2] == '.' && name[namelen - 1] == 'o'
 585         && mem[memlen - 2] == '.' && mem[memlen - 1] == 'o')
 586       return 1;
 587
 588     if (namelen != memlen)
 589       return 0;
 590
 591     return (namelen < max - 3 || !strcmp (name + max - 3, mem + max - 3));
 592   }
 593
 594 #else   /* AIX or APOLLO.  */
 595 #ifndef VMS
 596   if (truncated)
 597     {
 598 #ifdef AIAMAG
 599       /* TRUNCATED should never be set on this system.  */
 600       abort ();
 601 #else
 602       struct ar_hdr hdr;
 603       return !strncmp (name, mem,
 604                        sizeof (hdr.ar_name) -
 605 #if !defined (__hpux) && !defined (cray)
 606                        1
 607 #else
 608                        2
 609 #endif /* !__hpux && !cray */
 610                        );
 611 #endif
 612     }
 613 #endif /* !VMS */
 614
 615   return !strcmp (name, mem);
 616
 617 #endif
 618 }
 619 \f
 620 #ifndef VMS
 621 /* ARGSUSED */
 622 static long int
 623 ar_member_pos (desc, mem, truncated,
 624                hdrpos, datapos, size, date, uid, gid, mode, name)
 625      int desc;
 626      char *mem;
 627      int truncated;
 628      long int hdrpos, datapos, size, date;
 629      int uid, gid, mode;
 630      char *name;
 631 {
 632   if (!ar_name_equal (name, mem, truncated))
 633     return 0;
 634   return hdrpos;
 635 }
 636
 637 /* Set date of member MEMNAME in archive ARNAME to current time.
 638    Returns 0 if successful,
 639    -1 if file ARNAME does not exist,
 640    -2 if not a valid archive,
 641    -3 if other random system call error (including file read-only),
 642    1 if valid but member MEMNAME does not exist.  */
 643
 644 int
 645 ar_member_touch (arname, memname)
 646      char *arname, *memname;
 647 {
 648   register long int pos = ar_scan (arname, ar_member_pos, (long int) memname);
 649   register int fd;
 650   struct ar_hdr ar_hdr;
 651   register int i;
 652   struct stat statbuf;
 653
 654   if (pos < 0)
 655     return (int) pos;
 656   if (!pos)
 657     return 1;
 658
 659   fd = open (arname, O_RDWR, 0666);
 660   if (fd < 0)
 661     return -3;
 662   /* Read in this member's header */
 663   if (lseek (fd, pos, 0) < 0)
 664     goto lose;
 665   if (AR_HDR_SIZE != read (fd, (char *) &ar_hdr, AR_HDR_SIZE))
 666     goto lose;
 667   /* Write back the header, thus touching the archive file.  */
 668   if (lseek (fd, pos, 0) < 0)
 669     goto lose;
 670   if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE))
 671     goto lose;
 672   /* The file's mtime is the time we we want.  */
 673 #ifdef EINTR
 674   while (fstat (fd, &statbuf) < 0 && errno == EINTR);
 675 #else
 676   fstat (fd, &statbuf);
 677 #endif
 678 #if defined(ARFMAG) || defined(AIAMAG)
 679   /* Advance member's time to that time */
 680   for (i = 0; i < sizeof ar_hdr.ar_date; i++)
 681     ar_hdr.ar_date[i] = ' ';
 682   sprintf (ar_hdr.ar_date, "%ld", (long int) statbuf.st_mtime);
 683 #ifdef AIAMAG
 684   ar_hdr.ar_date[strlen(ar_hdr.ar_date)] = ' ';
 685 #endif
 686 #else
 687   ar_hdr.ar_date = statbuf.st_mtime;
 688 #endif
 689   /* Write back this member's header */
 690   if (lseek (fd, pos, 0) < 0)
 691     goto lose;
 692   if (AR_HDR_SIZE != write (fd, (char *) &ar_hdr, AR_HDR_SIZE))
 693     goto lose;
 694   close (fd);
 695   return 0;
 696
 697  lose:
 698   i = errno;
 699   close (fd);
 700   errno = i;
 701   return -3;
 702 }
 703 #endif
 704 \f
 705 #ifdef TEST
 706
 707 long int
 708 describe_member (desc, name, truncated,
 709                  hdrpos, datapos, size, date, uid, gid, mode)
 710      int desc;
 711      char *name;
 712      int truncated;
 713      long int hdrpos, datapos, size, date;
 714      int uid, gid, mode;
 715 {
 716   extern char *ctime ();
 717
 718   printf ("Member `%s'%s: %ld bytes at %ld (%ld).\n",
 719           name, truncated ? " (name might be truncated)" : "",
 720           size, hdrpos, datapos);
 721   printf ("  Date %s", ctime (&date));
 722   printf ("  uid = %d, gid = %d, mode = 0%o.\n", uid, gid, mode);
 723
 724   return 0;
 725 }
 726
 727 main (argc, argv)
 728      int argc;
 729      char **argv;
 730 {
 731   ar_scan (argv[1], describe_member);
 732   return 0;
 733 }
 734
 735 #endif  /* TEST.  */
 736 \f
 737 #endif  /* NO_ARCHIVES.  */