1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25 
  26 /*
  27  *      ar.c
  28  *
  29  *      Deal with the lib.a(member.o) and lib.a((entry-point)) notations
  30  *
  31  * Look inside archives for notations a(b) and a((b))
  32  *      a(b)    is file member   b  in archive a
  33  *      a((b))  is entry point   b  in object archive a
  34  *
  35  * For 6.0, create a make which can understand all archive
  36  * formats.  This is kind of tricky, and <ar.h> isnt any help.
  37  */
  38 
  39 /*
  40  * Included files
  41  */
  42 #include <alloca.h>               /* alloca() */
  43 #include <ar.h>
  44 #include <errno.h>                /* errno */
  45 #include <fcntl.h>                /* open() */
  46 #include <libintl.h>
  47 #include <mk/defs.h>
  48 #include <mksh/misc.h>            /* retmem_mb() */
  49 
  50 struct ranlib {
  51         union {
  52                 off_t   ran_strx;       /* string table index of */
  53                 char    *ran_name;      /* symbol defined by */
  54         }       ran_un;
  55         off_t   ran_off;                /* library member at this offset */
  56 };
  57 
  58 #include <unistd.h>               /* close() */
  59 
  60 
  61 /*
  62  * Defined macros
  63  */
  64 #ifndef S5EMUL
  65 #undef BITSPERBYTE
  66 #define BITSPERBYTE     8
  67 #endif
  68 
  69 /*
  70  * Defines for all the different archive formats.  See next comment
  71  * block for justification for not using <ar.h>s versions.
  72  */
  73 #define AR_5_MAGIC              "<ar>"            /* 5.0 format magic string */
  74 #define AR_5_MAGIC_LENGTH       4               /* 5.0 format string length */
  75 
  76 #define AR_PORT_MAGIC           "!<arch>\n"       /* Port. (6.0) magic string */
  77 #define AR_PORT_MAGIC_LENGTH    8               /* Port. (6.0) string length */
  78 #define AR_PORT_END_MAGIC       "`\n"           /* Port. (6.0) end of header */
  79 #define AR_PORT_WORD            4               /* Port. (6.0) 'word' length */
  80 
  81 /*
  82  * typedefs & structs
  83  */
  84 /*
  85  * These are the archive file headers for the formats.  Note
  86  * that it really doesnt matter if these structures are defined
  87  * here.  They are correct as of the respective archive format
  88  * releases.  If the archive format is changed, then since backwards
  89  * compatability is the desired behavior, a new structure is added
  90  * to the list.
  91  */
  92 typedef struct {        /* 5.0 ar header format: vax family; 3b family */
  93         char                    ar_magic[AR_5_MAGIC_LENGTH];    /* AR_5_MAGIC*/
  94         char                    ar_name[16];    /* Space terminated */
  95         char                    ar_date[AR_PORT_WORD];  /* sgetl() accessed */
  96         char                    ar_syms[AR_PORT_WORD];  /* sgetl() accessed */
  97 }                       Arh_5;
  98 
  99 typedef struct {        /* 5.0 ar symbol format: vax family; 3b family */
 100         char                    sym_name[8];    /* Space terminated */
 101         char                    sym_ptr[AR_PORT_WORD];  /* sgetl() accessed */
 102 }                       Ars_5;
 103 
 104 typedef struct {        /* 5.0 ar member format: vax family; 3b family */
 105         char                    arf_name[16];   /* Space terminated */
 106         char                    arf_date[AR_PORT_WORD]; /* sgetl() accessed */
 107         char                    arf_uid[AR_PORT_WORD];  /* sgetl() accessed */
 108         char                    arf_gid[AR_PORT_WORD];  /* sgetl() accessed */
 109         char                    arf_mode[AR_PORT_WORD]; /* sgetl() accessed */
 110         char                    arf_size[AR_PORT_WORD]; /* sgetl() accessed */
 111 }                       Arf_5;
 112 
 113 typedef struct {        /* Portable (6.0) ar format: vax family; 3b family */
 114         char                    ar_name[16];    /* Space terminated */
 115         /* left-adjusted fields; decimal ascii; blank filled */
 116         char                    ar_date[12];    
 117         char                    ar_uid[6];
 118         char                    ar_gid[6];
 119         char                    ar_mode[8];     /* octal ascii */
 120         char                    ar_size[10];
 121         /* special end-of-header string (AR_PORT_END_MAGIC) */
 122         char                    ar_fmag[2];     
 123 }                       Ar_port;
 124 
 125 enum ar_type {
 126                 AR_5,
 127                 AR_PORT
 128 };
 129 
 130 typedef unsigned int ar_port_word; // must be 4-bytes long
 131 
 132 typedef struct {
 133         FILE                    *fd;
 134         /* to distiguish ar format */
 135         enum ar_type            type;
 136         /* where first ar member header is at */
 137         long                    first_ar_mem;
 138         /* where the symbol lookup starts */
 139         long                    sym_begin;
 140         /* the number of symbols available */
 141         long                    num_symbols;
 142         /* length of symbol directory file */
 143         long                    sym_size;
 144         Arh_5                   arh_5;
 145         Ars_5                   ars_5;
 146         Arf_5                   arf_5;
 147         Ar_port                 ar_port;
 148 }                       Ar;
 149 
 150 /*
 151  * Static variables
 152  */
 153 
 154 /*
 155  * File table of contents
 156  */
 157 extern  timestruc_t&        read_archive(register Name target);
 158 static  Boolean         open_archive(char *filename, register Ar *arp);
 159 static  void            close_archive(register Ar *arp);
 160 static  Boolean         read_archive_dir(register Ar *arp, Name library, char **long_names_table);
 161 static  void            translate_entry(register Ar *arp, Name target, register Property member, char **long_names_table);
 162 static  long            sgetl(char *);
 163 
 164 /*
 165  *      read_archive(target)
 166  *
 167  *      Read the contents of an ar file.
 168  *
 169  *      Return value:
 170  *                              The time the member was created
 171  *
 172  *      Parameters:
 173  *              target          The member to find time for
 174  *
 175  *      Global variables used:
 176  *              empty_name      The Name ""
 177  */
 178 
 179 int read_member_header (Ar_port *header, FILE *fd, char* filename);
 180 int process_long_names_member (register Ar *arp, char **long_names_table, char *filename);
 181 
 182 timestruc_t&
 183 read_archive(register Name target)
 184 {
 185         register Property       member;
 186         wchar_t                 *slash;
 187         String_rec              true_member_name;
 188         wchar_t                 buffer[STRING_BUFFER_LENGTH];
 189         register Name           true_member = NULL;
 190         Ar                      ar;
 191         char                    *long_names_table = NULL; /* Table of long
 192                                                              member names */
 193 
 194         member = get_prop(target->prop, member_prop);
 195         /*
 196          * Check if the member has directory component.
 197          * If so, remove the dir and see if we know the date.
 198          */
 199         if (member->body.member.member != NULL) {
 200                 Wstring member_string(member->body.member.member);
 201                 wchar_t * wcb = member_string.get_string();
 202                 if((slash = (wchar_t *) wsrchr(wcb, (int) slash_char)) != NULL) {
 203                         INIT_STRING_FROM_STACK(true_member_name, buffer);
 204                         append_string(member->body.member.library->string_mb,
 205                                       &true_member_name,
 206                                       FIND_LENGTH);
 207                         append_char((int) parenleft_char, &true_member_name);
 208                         append_string(slash + 1, &true_member_name, FIND_LENGTH);
 209                         append_char((int) parenright_char, &true_member_name);
 210                         true_member = GETNAME(true_member_name.buffer.start,
 211                                               FIND_LENGTH);
 212                         if (true_member->stat.time != file_no_time) {
 213                                 target->stat.time = true_member->stat.time;
 214                                 return target->stat.time;
 215                         }
 216                 }
 217         }
 218         if (open_archive(member->body.member.library->string_mb, &ar) == failed) {
 219                 if (errno == ENOENT) {
 220                         target->stat.stat_errno = ENOENT;
 221                         close_archive(&ar);
 222                         if (member->body.member.member == NULL) {
 223                                 member->body.member.member = empty_name;
 224                         }
 225                         return target->stat.time = file_doesnt_exist;
 226                 } else {
 227                         fatal(gettext("Can't access archive `%s': %s"),
 228                               member->body.member.library->string_mb,
 229                               errmsg(errno));
 230                 }
 231         }
 232         if (target->stat.time == file_no_time) {
 233                 if (read_archive_dir(&ar, member->body.member.library, 
 234                                      &long_names_table)
 235                     == failed){
 236                         fatal(gettext("Can't access archive `%s': %s"),
 237                               member->body.member.library->string_mb,
 238                               errmsg(errno));
 239                 }
 240         }
 241         if (member->body.member.entry != NULL) {
 242                 translate_entry(&ar, target, member,&long_names_table);
 243         }
 244         close_archive(&ar);
 245         if (long_names_table) {
 246                 retmem_mb(long_names_table);
 247         }
 248         if (true_member != NULL) {
 249                 target->stat.time = true_member->stat.time;
 250         }
 251         if (target->stat.time == file_no_time) {
 252                 target->stat.time = file_doesnt_exist;
 253         }
 254         return target->stat.time;
 255 }
 256 
 257 /*
 258  *      open_archive(filename, arp)
 259  *
 260  *      Return value:
 261  *                              Indicates if open failed or not
 262  *
 263  *      Parameters:
 264  *              filename        The name of the archive we need to read
 265  *              arp             Pointer to ar file description block
 266  *
 267  *      Global variables used:
 268  */
 269 static Boolean
 270 open_archive(char *filename, register Ar *arp)
 271 {
 272         int                     fd;
 273         char                    mag_5[AR_5_MAGIC_LENGTH];
 274         char                    mag_port[AR_PORT_MAGIC_LENGTH];
 275         char                    buffer[4];
 276 
 277         arp->fd = NULL;
 278         fd = open_vroot(filename, O_RDONLY, 0, NULL, VROOT_DEFAULT);
 279         if ((fd < 0) || ((arp->fd = fdopen(fd, "r")) == NULL)) {
 280                 return failed;
 281         }
 282         (void) fcntl(fileno(arp->fd), F_SETFD, 1);
 283 
 284         if (fread(mag_port, AR_PORT_MAGIC_LENGTH, 1, arp->fd) != 1) {
 285                 return failed;
 286         }
 287         if (IS_EQUALN(mag_port, AR_PORT_MAGIC, AR_PORT_MAGIC_LENGTH)) {
 288                 arp->type = AR_PORT;
 289                 /*
 290                  * Read in first member header to find out if there is 
 291                  * a symbol definition table.
 292                  */
 293 
 294                 int ret = read_member_header(&arp->ar_port, arp->fd, filename);
 295                 if (ret == failed) {
 296                         return failed;
 297                 } else if(ret == -1) {
 298                         /* There is no member header - empty archive */
 299                         arp->sym_size = arp->num_symbols = arp->sym_begin = 0L;
 300                         arp->first_ar_mem = ftell(arp->fd);
 301                         return succeeded;
 302                 }
 303                 /*
 304                  * The following values are the default if there is 
 305                  * no symbol directory and long member names.
 306                  */
 307                 arp->sym_size = arp->num_symbols = arp->sym_begin = 0L;
 308                 arp->first_ar_mem = ftell(arp->fd) - (long) sizeof (Ar_port);
 309 
 310                 /*
 311                  * Do we have a symbol table? A symbol table is always
 312                  * the first member in an archive. In 4.1.x it has the 
 313                  * name __.SYMDEF, in SVr4, it has the name "/        "
 314                  */
 315 /*
 316                 MBSTOWCS(wcs_buffer, "/               ");
 317                 if (IS_WEQUALN(arp->ar_port.ar_name, wcs_buffer, 16)) {
 318  */
 319                 if (IS_EQUALN(arp->ar_port.ar_name,
 320                               "/               ",
 321                               16)) {
 322                         if (sscanf(arp->ar_port.ar_size,
 323                                    "%ld",
 324                                    &arp->sym_size) != 1) {
 325                                 return failed;
 326                         }
 327                         arp->sym_size += (arp->sym_size & 1); /* round up */
 328                         if (fread(buffer, sizeof buffer, 1, arp->fd) != 1) {
 329                                 return failed;
 330                         }
 331                         arp->num_symbols = sgetl(buffer);
 332                         arp->sym_begin = ftell(arp->fd);
 333                         arp->first_ar_mem = arp->sym_begin +
 334                                                 arp->sym_size - sizeof buffer;
 335                 }
 336                 return succeeded;
 337         }
 338         fatal(gettext("`%s' is not an archive"), filename);
 339         /* NOTREACHED */
 340         return failed;
 341 }
 342 
 343 
 344 /*
 345  *      close_archive(arp)
 346  *
 347  *      Parameters:
 348  *              arp             Pointer to ar file description block
 349  *
 350  *      Global variables used:
 351  */
 352 static void
 353 close_archive(register Ar *arp)
 354 {
 355         if (arp->fd != NULL) {
 356                 (void) fclose(arp->fd);
 357         }
 358 }
 359 
 360 /*
 361  *      read_archive_dir(arp, library, long_names_table)
 362  *
 363  *      Reads the directory of an archive and enters all
 364  *      the members into the make symboltable in lib(member) format
 365  *      with their dates.
 366  *
 367  *      Parameters:
 368  *              arp             Pointer to ar file description block
 369  *              library         Name of lib to enter members for.
 370  *                              Used to form "lib(member)" string.
 371  *              long_names_table table that contains list of members
 372  *                              with names > 15 characters long
 373  *
 374  *      Global variables used:
 375  */
 376 static Boolean
 377 read_archive_dir(register Ar *arp, Name library, char **long_names_table)
 378 {
 379         wchar_t                 *name_string;
 380         wchar_t                 *member_string;
 381         register long           len;
 382         register wchar_t        *p;
 383         register char           *q;
 384         register Name           name;
 385         Property                member;
 386         long                    ptr;
 387         long                    date;
 388 
 389         int                     offset;
 390 
 391         /*
 392          * If any of the members has a name > 15 chars,
 393          * it will be found here.
 394          */
 395         if (process_long_names_member(arp, long_names_table, library->string_mb) == failed) {
 396                 return failed;
 397         }
 398         name_string = ALLOC_WC((int) (library->hash.length +
 399                                       (int) ar_member_name_len * 2));
 400         (void) mbstowcs(name_string, library->string_mb, (int) library->hash.length);
 401         member_string = name_string + library->hash.length;
 402         *member_string++ = (int) parenleft_char;
 403 
 404         if (fseek(arp->fd, arp->first_ar_mem, 0) != 0) {
 405                 goto read_error;
 406         }
 407         /* Read the directory using the appropriate format */
 408         switch (arp->type) {
 409         case AR_5:
 410             for (;;) {
 411                 if (fread((char *) &arp->arf_5, sizeof arp->arf_5, 1, arp->fd)
 412                     != 1) {
 413                         if (feof(arp->fd)) {
 414                                 return succeeded;
 415                         }
 416                         break;
 417                 }
 418                 len = sizeof arp->arf_5.arf_name;
 419                 for (p = member_string, q = arp->arf_5.arf_name;
 420                      (len > 0) && (*q != (int) nul_char) && !isspace(*q);
 421                      ) {
 422                         MBTOWC(p, q);
 423                         p++;
 424                         q++;
 425                 }
 426                 *p++ = (int) parenright_char;
 427                 *p = (int) nul_char;
 428                 name = GETNAME(name_string, FIND_LENGTH);
 429                 /*
 430                  * [tolik] Fix for dmake bug 1234018.
 431                  * If name->stat.time is already set, then it should not
 432                  * be changed. (D)make propogates time stamp for one
 433                  * member, and when it calls exists() for another member,
 434                  * the first one may be changed.
 435                  */
 436                 if(name->stat.time == file_no_time) {
 437                         name->stat.time.tv_sec = sgetl(arp->arf_5.arf_date);
 438                         name->stat.time.tv_nsec = LONG_MAX;
 439                 }
 440                 name->is_member = library->is_member;
 441                 member = maybe_append_prop(name, member_prop);
 442                 member->body.member.library = library;
 443                 *--p = (int) nul_char;
 444                 if (member->body.member.member == NULL) {
 445                         member->body.member.member =
 446                           GETNAME(member_string, FIND_LENGTH);
 447                 }
 448                 ptr = sgetl(arp->arf_5.arf_size);
 449                 ptr += (ptr & 1);
 450                 if (fseek(arp->fd, ptr, 1) != 0) {
 451                         goto read_error;
 452                 }
 453             }
 454             break;
 455         case AR_PORT:
 456             for (;;) {
 457                     if ((fread((char *) &arp->ar_port,
 458                                sizeof arp->ar_port,
 459                                1,
 460                                arp->fd) != 1) ||
 461                         !IS_EQUALN(arp->ar_port.ar_fmag,
 462                                    AR_PORT_END_MAGIC,
 463                                    sizeof arp->ar_port.ar_fmag)) {
 464                             if (feof(arp->fd)) {
 465                                     return succeeded;
 466                             }
 467                             fatal(
 468                                 gettext("Read error in archive `%s': invalid archive file member header at 0x%x"),
 469                                 library->string_mb,
 470                                 ftell(arp->fd)
 471                             );
 472                     }
 473                     /* If it's a long name, retrieve it from long name table */
 474                     if (arp->ar_port.ar_name[0] == '/') {
 475                             /*
 476                              * "len" is used for hashing the string.
 477                              * We're using "ar_member_name_len" instead of
 478                              * the actual name length since it's the longest
 479                              * string the "ar" command can handle at this
 480                              * point.
 481                              */
 482                             len = ar_member_name_len;
 483                             sscanf(arp->ar_port.ar_name + 1,
 484                                    "%ld",
 485                                    &offset);
 486                             q = *long_names_table + offset;
 487                     } else {
 488                             q = arp->ar_port.ar_name;        
 489                             len = sizeof arp->ar_port.ar_name;
 490                     }
 491                     
 492                     for (p = member_string;
 493                          (len > 0) &&
 494                          (*q != (int) nul_char) &&
 495                          !isspace(*q) &&
 496                          (*q != (int) slash_char);
 497                          ) {
 498                             MBTOWC(p, q);
 499                             p++;
 500                             q++;
 501                     }
 502                     *p++ = (int) parenright_char;
 503                     *p = (int) nul_char;
 504                     name = GETNAME(name_string, FIND_LENGTH);
 505                     name->is_member = library->is_member;
 506                     member = maybe_append_prop(name, member_prop);
 507                     member->body.member.library = library;
 508                     *--p = (int) nul_char;
 509                     if (member->body.member.member == NULL) {
 510                             member->body.member.member =
 511                               GETNAME(member_string, FIND_LENGTH);
 512                     }
 513                     if (sscanf(arp->ar_port.ar_date, "%ld", &date) != 1) {
 514                             WCSTOMBS(mbs_buffer, name_string);
 515                             fatal(gettext("Bad date field for member `%s' in archive `%s'"),
 516                                   mbs_buffer,
 517                                   library->string_mb);
 518                     }
 519                     /*
 520                      * [tolik] Fix for dmake bug 1234018.
 521                      */
 522                     if(name->stat.time == file_no_time) {
 523                         name->stat.time.tv_sec = date;
 524                         name->stat.time.tv_nsec = LONG_MAX;
 525                     }
 526                     if (sscanf(arp->ar_port.ar_size, "%ld", &ptr) != 1) {
 527                             WCSTOMBS(mbs_buffer, name_string);
 528                             fatal(gettext("Bad size field for member `%s' in archive `%s'"),
 529                                   mbs_buffer,
 530                                   library->string_mb);
 531                     }
 532                     ptr += (ptr & 1);
 533                     if (fseek(arp->fd, ptr, 1) != 0) {
 534                             goto read_error;
 535                     }   
 536             }
 537             break;
 538         }
 539 
 540         /* Only here if fread() [or IS_EQUALN()] failed and not at EOF */
 541 read_error:
 542         fatal(gettext("Read error in archive `%s': %s"),
 543               library->string_mb,
 544               errmsg(errno));
 545             /* NOTREACHED */
 546 }
 547 
 548 
 549 /*
 550  *      process_long_names_member(arp)
 551  *
 552  *      If the archive contains members with names longer
 553  *      than 15 characters, then it has a special member
 554  *      with the name "//        " that contains a table
 555  *      of null-terminated long names. This member
 556  *      is always the first member, after the symbol table
 557  *      if it exists.
 558  *
 559  *      Parameters:
 560  *              arp             Pointer to ar file description block
 561  *
 562  *      Global variables used:
 563  */
 564 int
 565 process_long_names_member(register Ar *arp, char **long_names_table, char *filename)
 566 {  
 567         Ar_port                 *ar_member_header;
 568         int                     table_size;
 569 
 570         if (fseek(arp->fd, arp->first_ar_mem, 0) != 0) {
 571                 return failed;
 572         }
 573         if ((ar_member_header = 
 574              (Ar_port *) alloca((int) sizeof(Ar_port))) == NULL){
 575                 perror(gettext("memory allocation failure"));
 576                 return failed;
 577         } 
 578         int ret = read_member_header(ar_member_header, arp->fd, filename);
 579         if (ret == failed) {
 580                 return failed;
 581         } else if(ret == -1) {
 582                 /* There is no member header - empty archive */
 583                 return succeeded;
 584         }
 585         /* Do we have special member containing long names? */
 586         if (IS_EQUALN(ar_member_header->ar_name, 
 587                       "//              ",
 588                       16)){
 589                 if (sscanf(ar_member_header->ar_size,
 590                            "%ld",
 591                            &table_size) != 1) {
 592                         return failed;
 593                 }
 594                 *long_names_table = (char *) malloc(table_size);
 595                 /* Read the list of long member names into the table */
 596                 if (fread(*long_names_table, table_size, 1, arp->fd) != 1) {
 597                         return failed;
 598                 }
 599                 arp->first_ar_mem = ftell(arp->fd);
 600         }
 601         return succeeded;
 602 }
 603 
 604 /*
 605  *      translate_entry(arp, target, member)
 606  *
 607  *      Finds the member for one lib.a((entry))
 608  *
 609  *      Parameters:
 610  *              arp             Pointer to ar file description block
 611  *              target          Target to find member name for
 612  *              member          Property to fill in with info
 613  *
 614  *      Global variables used:
 615  */
 616 static void
 617 translate_entry(register Ar *arp, Name target, register Property member, char **long_names_table)
 618 {
 619         register int            len;
 620         register int            i;
 621         wchar_t                 *member_string;
 622         ar_port_word            *offs;
 623         int                     strtablen;
 624         char                    *syms;           /* string table */
 625         char                    *csym;           /* string table */
 626         ar_port_word            *offend;         /* end of offsets table */
 627         int                     date;
 628         register wchar_t        *ap;
 629         register char           *hp;
 630         int                     maxs;
 631         int                     offset;
 632         char            buffer[4];
 633 
 634         if (arp->sym_begin == 0L || arp->num_symbols == 0L) {
 635                 fatal(gettext("Cannot find symbol `%s' in archive `%s'"),
 636                       member->body.member.entry->string_mb,
 637                       member->body.member.library->string_mb);
 638         }
 639 
 640         if (fseek(arp->fd, arp->sym_begin, 0) != 0) {
 641                 goto read_error;
 642         }
 643         member_string = ALLOC_WC((int) ((int) ar_member_name_len * 2));
 644 
 645         switch (arp->type) {
 646         case AR_5:
 647                 if ((len = member->body.member.entry->hash.length) > 8) {
 648                         len = 8;
 649                 }
 650                 for (i = 0; i < arp->num_symbols; i++) {
 651                         if (fread((char *) &arp->ars_5,
 652                                   sizeof arp->ars_5,
 653                                   1,
 654                                   arp->fd) != 1) {
 655                                 goto read_error;
 656                         }
 657                         if (IS_EQUALN(arp->ars_5.sym_name,
 658                                       member->body.member.entry->string_mb,
 659                                       len)) {
 660                                 if ((fseek(arp->fd,
 661                                            sgetl(arp->ars_5.sym_ptr),
 662                                            0) != 0) ||
 663                                     (fread((char *) &arp->arf_5,
 664                                            sizeof arp->arf_5,
 665                                            1,
 666                                            arp->fd) != 1)) {
 667                                         goto read_error;
 668                                 }
 669                                 MBSTOWCS(wcs_buffer, arp->arf_5.arf_name);
 670                                 (void) wsncpy(member_string,
 671                                               wcs_buffer,
 672                                               wslen(wcs_buffer));
 673                                 member_string[sizeof(arp->arf_5.arf_name)] =
 674                                                                 (int) nul_char;
 675                                 member->body.member.member =
 676                                         GETNAME(member_string, FIND_LENGTH);
 677                                 target->stat.time.tv_sec = sgetl(arp->arf_5.arf_date);
 678                                 target->stat.time.tv_nsec = LONG_MAX;
 679                                 return;
 680                         }
 681                 }
 682                 break;
 683         case AR_PORT:
 684                 offs = (ar_port_word *) alloca((int) (arp->num_symbols * AR_PORT_WORD));
 685                 if (fread((char *) offs,
 686                           AR_PORT_WORD,
 687                           (int) arp->num_symbols,
 688                           arp->fd) != arp->num_symbols) {
 689                         goto read_error;
 690                 }
 691 
 692                 for(i=0;i<arp->num_symbols;i++) {
 693                         *((int*)buffer)=offs[i];
 694                         offs[i]=(ar_port_word)sgetl(buffer);
 695                 }
 696 
 697                 strtablen=arp->sym_size-4-(int) (arp->num_symbols * AR_PORT_WORD);
 698                 syms = (char *) alloca(strtablen);
 699                 if (fread(syms,
 700                           sizeof (char),
 701                           strtablen,
 702                           arp->fd) != strtablen) {
 703                         goto read_error;
 704                 }
 705                 offend = &offs[arp->num_symbols];
 706                 while (offs < offend) {
 707                         maxs = strlen(member->body.member.entry->string_mb);
 708                         if(strlen(syms) > maxs)
 709                                 maxs = strlen(syms);
 710                         if (IS_EQUALN(syms,
 711                                       member->body.member.entry->string_mb,
 712                                       maxs)) {
 713                                 if (fseek(arp->fd,
 714                                           (long) *offs,
 715                                           0) != 0) {
 716                                         goto read_error;
 717                                 }
 718                                 if ((fread((char *) &arp->ar_port,
 719                                            sizeof arp->ar_port,
 720                                            1,
 721                                            arp->fd) != 1) ||
 722                                     !IS_EQUALN(arp->ar_port.ar_fmag,
 723                                                AR_PORT_END_MAGIC,
 724                                                sizeof arp->ar_port.ar_fmag)) {
 725                                         goto read_error;
 726                                 }
 727                                 if (sscanf(arp->ar_port.ar_date,
 728                                            "%ld",
 729                                            &date) != 1) {
 730                                         fatal(gettext("Bad date field for member `%s' in archive `%s'"),
 731                                               arp->ar_port.ar_name,
 732                                               target->string_mb);
 733                                 }
 734                     /* If it's a long name, retrieve it from long name table */
 735                     if (arp->ar_port.ar_name[0] == '/') {
 736                             sscanf(arp->ar_port.ar_name + 1,
 737                                    "%ld",
 738                                    &offset);
 739                             len = ar_member_name_len;
 740                             hp = *long_names_table + offset;
 741                     } else {
 742                             len = sizeof arp->ar_port.ar_name;
 743                             hp = arp->ar_port.ar_name;       
 744                     }
 745                                 ap = member_string;
 746                                 while (*hp &&
 747                                        (*hp != (int) slash_char) &&
 748                                        (ap < &member_string[len])) {
 749                                         MBTOWC(ap, hp);
 750                                         ap++;
 751                                         hp++;
 752                                 }
 753                                 *ap = (int) nul_char;
 754                                 member->body.member.member =
 755                                         GETNAME(member_string, FIND_LENGTH);
 756                                 target->stat.time.tv_sec = date;
 757                                 target->stat.time.tv_nsec = LONG_MAX;
 758                                 return;
 759                         }
 760                         offs++;
 761                         while(*syms!='\0') syms++;
 762                         syms++;
 763                 }
 764         }
 765         fatal(gettext("Cannot find symbol `%s' in archive `%s'"),
 766               member->body.member.entry->string_mb,
 767               member->body.member.library->string_mb);
 768         /*NOTREACHED*/
 769 
 770 read_error:
 771         if (ferror(arp->fd)) {
 772                 fatal(gettext("Read error in archive `%s': %s"),
 773                       member->body.member.library->string_mb,
 774                       errmsg(errno));
 775         } else {
 776                 fatal(gettext("Read error in archive `%s': Premature EOF"),
 777                       member->body.member.library->string_mb);
 778         }
 779 }
 780 
 781 /*
 782  *      sgetl(buffer)
 783  *
 784  *      The intent here is to provide a means to make the value of
 785  *      bytes in an io-buffer correspond to the value of a long
 786  *      in the memory while doing the io a long at a time.
 787  *      Files written and read in this way are machine-independent.
 788  *
 789  *      Return value:
 790  *                              Long int read from buffer
 791  *      Parameters:
 792  *              buffer          buffer we need to read long int from
 793  *
 794  *      Global variables used:
 795  */
 796 static long
 797 sgetl(register char *buffer)
 798 {
 799         register long           w = 0;
 800         register int            i = BITSPERBYTE * AR_PORT_WORD;
 801 
 802         while ((i -= BITSPERBYTE) >= 0) {
 803                 w |= (long) ((unsigned char) *buffer++) << i;
 804         }
 805         return w;
 806 }
 807 
 808 
 809 /*
 810  *      read_member_header(header, fd, filename)
 811  *
 812  *      reads the member header for the 4.1.x and SVr4 archives.
 813  *
 814  *      Return value:
 815  *                              fails if read error or member
 816  *                              header is not the right format
 817  *      Parameters:
 818  *              header          There's one before each archive member
 819  *              fd              file descriptor for the archive file.
 820  *
 821  *      Global variables used:
 822  */
 823 int 
 824 read_member_header(Ar_port *header, FILE *fd, char* filename)
 825 {
 826         int num = fread((char *) header, sizeof (Ar_port), 1, fd);
 827         if (num != 1 && feof(fd)) {
 828                 /* There is no member header - empty archive */
 829                 return -1;
 830         }
 831         if ((num != 1) ||
 832             !IS_EQUALN(
 833                 AR_PORT_END_MAGIC,
 834                 header->ar_fmag,
 835                 sizeof (header->ar_fmag)
 836             )
 837         ) {
 838                 fatal(
 839                         gettext("Read error in archive `%s': invalid archive file member header at 0x%x"),
 840                         filename,
 841                         ftell(fd)
 842                 );
 843         }
 844         return succeeded;
 845 }
 846