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