path: root/usr/src/cmd/make/bin/ar.cc

/*
 * CDDL HEADER START
 *
 * The contents of this file are subject to the terms of the
 * Common Development and Distribution License (the "License").
 * You may not use this file except in compliance with the License.
 *
 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
 * or http://www.opensolaris.org/os/licensing.
 * See the License for the specific language governing permissions
 * and limitations under the License.
 *
 * When distributing Covered Code, include this CDDL HEADER in each
 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
 * If applicable, add the following below this CDDL HEADER, with the
 * fields enclosed by brackets "[]" replaced with your own identifying
 * information: Portions Copyright [yyyy] [name of copyright owner]
 *
 * CDDL HEADER END
 */
/*
 * Copyright 2004 Sun Microsystems, Inc. All rights reserved.
 * Use is subject to license terms.
 */

/*
 *	ar.c
 *
 *	Deal with the lib.a(member.o) and lib.a((entry-point)) notations
 *
 * Look inside archives for notations a(b) and a((b))
 *	a(b)	is file member   b  in archive a
 *	a((b))	is entry point   b  in object archive a
 *
 * For 6.0, create a make which can understand all archive
 * formats.  This is kind of tricky, and <ar.h> isnt any help.
 */

/*
 * Included files
 */
#include <alloca.h>		/* alloca() */
#include <ar.h>
#include <errno.h>		/* errno */
#include <fcntl.h>		/* open() */
#include <libintl.h>
#include <mk/defs.h>
#include <mksh/misc.h>		/* retmem_mb() */

struct ranlib {
	union {
		off_t	ran_strx;	/* string table index of */
		char	*ran_name;	/* symbol defined by */
	}	ran_un;
	off_t	ran_off;		/* library member at this offset */
};

#include <unistd.h>		/* close() */


/*
 * Defined macros
 */
#ifndef S5EMUL
#undef BITSPERBYTE
#define BITSPERBYTE	8
#endif

/*
 * Defines for all the different archive formats.  See next comment
 * block for justification for not using <ar.h>s versions.
 */
#define AR_5_MAGIC		"<ar>"		/* 5.0 format magic string */
#define AR_5_MAGIC_LENGTH	4		/* 5.0 format string length */

#define AR_PORT_MAGIC		"!<arch>\n"	/* Port. (6.0) magic string */
#define AR_PORT_MAGIC_LENGTH	8		/* Port. (6.0) string length */
#define AR_PORT_END_MAGIC	"`\n"		/* Port. (6.0) end of header */
#define AR_PORT_WORD		4		/* Port. (6.0) 'word' length */

/*
 * typedefs & structs
 */
/*
 * These are the archive file headers for the formats.  Note
 * that it really doesnt matter if these structures are defined
 * here.  They are correct as of the respective archive format
 * releases.  If the archive format is changed, then since backwards
 * compatability is the desired behavior, a new structure is added
 * to the list.
 */
typedef struct {	/* 5.0 ar header format: vax family; 3b family */
	char			ar_magic[AR_5_MAGIC_LENGTH];	/* AR_5_MAGIC*/
	char			ar_name[16];	/* Space terminated */
	char			ar_date[AR_PORT_WORD];	/* sgetl() accessed */
	char			ar_syms[AR_PORT_WORD];	/* sgetl() accessed */
}			Arh_5;

typedef struct {	/* 5.0 ar symbol format: vax family; 3b family */
	char			sym_name[8];	/* Space terminated */
	char			sym_ptr[AR_PORT_WORD];	/* sgetl() accessed */
}			Ars_5;

typedef struct {	/* 5.0 ar member format: vax family; 3b family */
	char			arf_name[16];	/* Space terminated */
	char			arf_date[AR_PORT_WORD];	/* sgetl() accessed */
	char			arf_uid[AR_PORT_WORD];	/* sgetl() accessed */
	char			arf_gid[AR_PORT_WORD];	/* sgetl() accessed */
	char			arf_mode[AR_PORT_WORD];	/* sgetl() accessed */
	char			arf_size[AR_PORT_WORD];	/* sgetl() accessed */
}			Arf_5;

typedef struct {	/* Portable (6.0) ar format: vax family; 3b family */
	char			ar_name[16];	/* Space terminated */
	/* left-adjusted fields; decimal ascii; blank filled */
	char			ar_date[12];
	char			ar_uid[6];
	char			ar_gid[6];
	char			ar_mode[8];	/* octal ascii */
	char			ar_size[10];
	/* special end-of-header string (AR_PORT_END_MAGIC) */
	char			ar_fmag[2];
}			Ar_port;

enum ar_type {
		AR_5,
		AR_PORT
};

typedef unsigned int ar_port_word; // must be 4-bytes long

typedef struct {
	FILE			*fd;
	/* to distiguish ar format */
	enum ar_type		type;
	/* where first ar member header is at */
	long			first_ar_mem;
	/* where the symbol lookup starts */
	long			sym_begin;
	/* the number of symbols available */
	long			num_symbols;
	/* length of symbol directory file */
	long			sym_size;
	Arh_5			arh_5;
	Ars_5			ars_5;
	Arf_5			arf_5;
	Ar_port			ar_port;
}			Ar;

/*
 * Static variables
 */

/*
 * File table of contents
 */
extern	timestruc_t&	read_archive(register Name target);
static	Boolean		open_archive(char *filename, register Ar *arp);
static	void		close_archive(register Ar *arp);
static	Boolean		read_archive_dir(register Ar *arp, Name library, char **long_names_table);
static	void		translate_entry(register Ar *arp, Name target, register Property member, char **long_names_table);
static	long		sgetl(char *);

/*
 *	read_archive(target)
 *
 *	Read the contents of an ar file.
 *
 *	Return value:
 *				The time the member was created
 *
 *	Parameters:
 *		target		The member to find time for
 *
 *	Global variables used:
 *		empty_name	The Name ""
 */

int read_member_header (Ar_port *header, FILE *fd, char* filename);
int process_long_names_member (register Ar *arp, char **long_names_table, char *filename);

timestruc_t&
read_archive(register Name target)
{
	register Property       member;
	wchar_t			*slash;
	String_rec		true_member_name;
	wchar_t			buffer[STRING_BUFFER_LENGTH];
	register Name		true_member = NULL;
	Ar                      ar;
	char			*long_names_table = NULL; /* Table of long
							     member names */

	member = get_prop(target->prop, member_prop);
	/*
	 * Check if the member has directory component.
	 * If so, remove the dir and see if we know the date.
	 */
	if (member->body.member.member != NULL) {
		Wstring member_string(member->body.member.member);
		wchar_t * wcb = member_string.get_string();
		if((slash = (wchar_t *) wcsrchr(wcb, (int) slash_char)) != NULL) {
			INIT_STRING_FROM_STACK(true_member_name, buffer);
			append_string(member->body.member.library->string_mb,
				      &true_member_name,
				      FIND_LENGTH);
			append_char((int) parenleft_char, &true_member_name);
			append_string(slash + 1, &true_member_name, FIND_LENGTH);
			append_char((int) parenright_char, &true_member_name);
			true_member = GETNAME(true_member_name.buffer.start,
					      FIND_LENGTH);
			if (true_member->stat.time != file_no_time) {
				target->stat.time = true_member->stat.time;
				return target->stat.time;
			}
		}
	}
	if (open_archive(member->body.member.library->string_mb, &ar) == failed) {
		if (errno == ENOENT) {
			target->stat.stat_errno = ENOENT;
			close_archive(&ar);
			if (member->body.member.member == NULL) {
				member->body.member.member = empty_name;
			}
			return target->stat.time = file_doesnt_exist;
		} else {
			fatal(gettext("Can't access archive `%s': %s"),
			      member->body.member.library->string_mb,
			      errmsg(errno));
		}
	}
	if (target->stat.time == file_no_time) {
		if (read_archive_dir(&ar, member->body.member.library,
				     &long_names_table)
		    == failed){
			fatal(gettext("Can't access archive `%s': %s"),
			      member->body.member.library->string_mb,
			      errmsg(errno));
		}
	}
	if (member->body.member.entry != NULL) {
		translate_entry(&ar, target, member,&long_names_table);
	}
	close_archive(&ar);
	if (long_names_table) {
		retmem_mb(long_names_table);
	}
	if (true_member != NULL) {
		target->stat.time = true_member->stat.time;
	}
	if (target->stat.time == file_no_time) {
		target->stat.time = file_doesnt_exist;
	}
	return target->stat.time;
}

/*
 *	open_archive(filename, arp)
 *
 *	Return value:
 *				Indicates if open failed or not
 *
 *	Parameters:
 *		filename	The name of the archive we need to read
 *		arp		Pointer to ar file description block
 *
 *	Global variables used:
 */
static Boolean
open_archive(char *filename, register Ar *arp)
{
	int			fd;
	char			mag_5[AR_5_MAGIC_LENGTH];
	char			mag_port[AR_PORT_MAGIC_LENGTH];
	char			buffer[4];

	arp->fd = NULL;
	fd = open_vroot(filename, O_RDONLY, 0, NULL, VROOT_DEFAULT);
	if ((fd < 0) || ((arp->fd = fdopen(fd, "r")) == NULL)) {
		return failed;
	}
	(void) fcntl(fileno(arp->fd), F_SETFD, 1);

	if (fread(mag_port, AR_PORT_MAGIC_LENGTH, 1, arp->fd) != 1) {
		return failed;
	}
	if (IS_EQUALN(mag_port, AR_PORT_MAGIC, AR_PORT_MAGIC_LENGTH)) {
		arp->type = AR_PORT;
		/*
		 * Read in first member header to find out if there is
		 * a symbol definition table.
		 */

		int ret = read_member_header(&arp->ar_port, arp->fd, filename);
		if (ret == failed) {
			return failed;
		} else if(ret == -1) {
			/* There is no member header - empty archive */
			arp->sym_size = arp->num_symbols = arp->sym_begin = 0L;
			arp->first_ar_mem = ftell(arp->fd);
			return succeeded;
		}
		/*
		 * The following values are the default if there is
		 * no symbol directory and long member names.
		 */
		arp->sym_size = arp->num_symbols = arp->sym_begin = 0L;
		arp->first_ar_mem = ftell(arp->fd) - (long) sizeof (Ar_port);

		/*
		 * Do we have a symbol table? A symbol table is always
		 * the first member in an archive. In 4.1.x it has the
		 * name __.SYMDEF, in SVr4, it has the name "/        "
		 */
/*
		MBSTOWCS(wcs_buffer, "/               ");
		if (IS_WEQUALN(arp->ar_port.ar_name, wcs_buffer, 16)) {
 */
		if (IS_EQUALN(arp->ar_port.ar_name,
			      "/               ",
			      16)) {
			if (sscanf(arp->ar_port.ar_size,
				   "%ld",
				   &arp->sym_size) != 1) {
				return failed;
			}
			arp->sym_size += (arp->sym_size & 1); /* round up */
			if (fread(buffer, sizeof buffer, 1, arp->fd) != 1) {
				return failed;
			}
			arp->num_symbols = sgetl(buffer);
			arp->sym_begin = ftell(arp->fd);
			arp->first_ar_mem = arp->sym_begin +
						arp->sym_size - sizeof buffer;
		}
		return succeeded;
	}
	fatal(gettext("`%s' is not an archive"), filename);
	/* NOTREACHED */
	return failed;
}


/*
 *	close_archive(arp)
 *
 *	Parameters:
 *		arp		Pointer to ar file description block
 *
 *	Global variables used:
 */
static void
close_archive(register Ar *arp)
{
	if (arp->fd != NULL) {
		(void) fclose(arp->fd);
	}
}

/*
 *	read_archive_dir(arp, library, long_names_table)
 *
 *	Reads the directory of an archive and enters all
 *	the members into the make symboltable in lib(member) format
 *	with their dates.
 *
 *	Parameters:
 *		arp		Pointer to ar file description block
 *		library		Name of lib to enter members for.
 *				Used to form "lib(member)" string.
 *		long_names_table table that contains list of members
 *				with names > 15 characters long
 *
 *	Global variables used:
 */
static Boolean
read_archive_dir(register Ar *arp, Name library, char **long_names_table)
{
	wchar_t			*name_string;
	wchar_t			*member_string;
	register long		len;
	register wchar_t	*p;
	register char		*q;
	register Name		name;
	Property		member;
	long			ptr;
	long			date;

	int			offset;

	/*
	 * If any of the members has a name > 15 chars,
	 * it will be found here.
	 */
	if (process_long_names_member(arp, long_names_table, library->string_mb) == failed) {
		return failed;
	}
	name_string = ALLOC_WC((int) (library->hash.length +
				      (int) ar_member_name_len * 2));
	(void) mbstowcs(name_string, library->string_mb, (int) library->hash.length);
	member_string = name_string + library->hash.length;
	*member_string++ = (int) parenleft_char;

	if (fseek(arp->fd, arp->first_ar_mem, 0) != 0) {
		goto read_error;
	}
	/* Read the directory using the appropriate format */
	switch (arp->type) {
	case AR_5:
	    for (;;) {
		if (fread((char *) &arp->arf_5, sizeof arp->arf_5, 1, arp->fd)
		    != 1) {
			if (feof(arp->fd)) {
				return succeeded;
			}
			break;
		}
		len = sizeof arp->arf_5.arf_name;
		for (p = member_string, q = arp->arf_5.arf_name;
		     (len > 0) && (*q != (int) nul_char) && !isspace(*q);
		     ) {
			MBTOWC(p, q);
			p++;
			q++;
		}
		*p++ = (int) parenright_char;
		*p = (int) nul_char;
		name = GETNAME(name_string, FIND_LENGTH);
		/*
		 * [tolik] Fix for dmake bug 1234018.
		 * If name->stat.time is already set, then it should not
		 * be changed. (D)make propogates time stamp for one
		 * member, and when it calls exists() for another member,
		 * the first one may be changed.
		 */
		if(name->stat.time == file_no_time) {
			name->stat.time.tv_sec = sgetl(arp->arf_5.arf_date);
			name->stat.time.tv_nsec = LONG_MAX;
		}
		name->is_member = library->is_member;
		member = maybe_append_prop(name, member_prop);
		member->body.member.library = library;
		*--p = (int) nul_char;
		if (member->body.member.member == NULL) {
			member->body.member.member =
			  GETNAME(member_string, FIND_LENGTH);
		}
		ptr = sgetl(arp->arf_5.arf_size);
		ptr += (ptr & 1);
		if (fseek(arp->fd, ptr, 1) != 0) {
			goto read_error;
		}
	    }
	    break;
	case AR_PORT:
	    for (;;) {
		    if ((fread((char *) &arp->ar_port,
			       sizeof arp->ar_port,
			       1,
			       arp->fd) != 1) ||
			!IS_EQUALN(arp->ar_port.ar_fmag,
				   AR_PORT_END_MAGIC,
				   sizeof arp->ar_port.ar_fmag)) {
			    if (feof(arp->fd)) {
				    return succeeded;
			    }
			    fatal(
				gettext("Read error in archive `%s': invalid archive file member header at 0x%x"),
				library->string_mb,
				ftell(arp->fd)
			    );
		    }
		    /* If it's a long name, retrieve it from long name table */
		    if (arp->ar_port.ar_name[0] == '/') {
			    /*
			     * "len" is used for hashing the string.
			     * We're using "ar_member_name_len" instead of
			     * the actual name length since it's the longest
			     * string the "ar" command can handle at this
			     * point.
			     */
			    len = ar_member_name_len;
			    sscanf(arp->ar_port.ar_name + 1,
				   "%ld",
				   &offset);
			    q = *long_names_table + offset;
		    } else {
			    q = arp->ar_port.ar_name;
			    len = sizeof arp->ar_port.ar_name;
		    }

		    for (p = member_string;
			 (len > 0) &&
			 (*q != (int) nul_char) &&
			 !isspace(*q) &&
			 (*q != (int) slash_char);
			 ) {
			    MBTOWC(p, q);
			    p++;
			    q++;
		    }
		    *p++ = (int) parenright_char;
		    *p = (int) nul_char;
		    name = GETNAME(name_string, FIND_LENGTH);
		    name->is_member = library->is_member;
		    member = maybe_append_prop(name, member_prop);
		    member->body.member.library = library;
		    *--p = (int) nul_char;
		    if (member->body.member.member == NULL) {
			    member->body.member.member =
			      GETNAME(member_string, FIND_LENGTH);
		    }
		    if (sscanf(arp->ar_port.ar_date, "%ld", &date) != 1) {
			    WCSTOMBS(mbs_buffer, name_string);
			    fatal(gettext("Bad date field for member `%s' in archive `%s'"),
				  mbs_buffer,
				  library->string_mb);
		    }
		    /*
		     * [tolik] Fix for dmake bug 1234018.
		     */
		    if(name->stat.time == file_no_time) {
			name->stat.time.tv_sec = date;
			name->stat.time.tv_nsec = LONG_MAX;
		    }
		    if (sscanf(arp->ar_port.ar_size, "%ld", &ptr) != 1) {
			    WCSTOMBS(mbs_buffer, name_string);
			    fatal(gettext("Bad size field for member `%s' in archive `%s'"),
				  mbs_buffer,
				  library->string_mb);
		    }
		    ptr += (ptr & 1);
		    if (fseek(arp->fd, ptr, 1) != 0) {
			    goto read_error;
		    }
	    }
	    break;
	}

	/* Only here if fread() [or IS_EQUALN()] failed and not at EOF */
read_error:
	fatal(gettext("Read error in archive `%s': %s"),
	      library->string_mb,
	      errmsg(errno));
	    /* NOTREACHED */
}


/*
 *	process_long_names_member(arp)
 *
 *	If the archive contains members with names longer
 *	than 15 characters, then it has a special member
 *	with the name "//        " that contains a table
 *	of null-terminated long names. This member
 *	is always the first member, after the symbol table
 *	if it exists.
 *
 *	Parameters:
 *		arp		Pointer to ar file description block
 *
 *	Global variables used:
 */
int
process_long_names_member(register Ar *arp, char **long_names_table, char *filename)
{
	Ar_port			*ar_member_header;
	int			table_size;

	if (fseek(arp->fd, arp->first_ar_mem, 0) != 0) {
		return failed;
	}
	if ((ar_member_header =
	     (Ar_port *) alloca((int) sizeof(Ar_port))) == NULL){
		perror(gettext("memory allocation failure"));
		return failed;
	}
	int ret = read_member_header(ar_member_header, arp->fd, filename);
	if (ret == failed) {
		return failed;
	} else if(ret == -1) {
		/* There is no member header - empty archive */
		return succeeded;
	}
	/* Do we have special member containing long names? */
	if (IS_EQUALN(ar_member_header->ar_name,
		      "//              ",
		      16)){
		if (sscanf(ar_member_header->ar_size,
			   "%ld",
			   &table_size) != 1) {
			return failed;
		}
		*long_names_table = (char *) malloc(table_size);
		/* Read the list of long member names into the table */
		if (fread(*long_names_table, table_size, 1, arp->fd) != 1) {
			return failed;
		}
		arp->first_ar_mem = ftell(arp->fd);
	}
	return succeeded;
}

/*
 *	translate_entry(arp, target, member)
 *
 *	Finds the member for one lib.a((entry))
 *
 *	Parameters:
 *		arp		Pointer to ar file description block
 *		target		Target to find member name for
 *		member		Property to fill in with info
 *
 *	Global variables used:
 */
static void
translate_entry(register Ar *arp, Name target, register Property member, char **long_names_table)
{
	register int		len;
	register int		i;
	wchar_t			*member_string;
	ar_port_word		*offs;
	int			strtablen;
	char			*syms;		 /* string table */
	char			*csym;		 /* string table */
	ar_port_word		*offend;	 /* end of offsets table */
	int			date;
	register wchar_t	*ap;
	register char		*hp;
	int			maxs;
	int			offset;
	char		buffer[4];

	if (arp->sym_begin == 0L || arp->num_symbols == 0L) {
		fatal(gettext("Cannot find symbol `%s' in archive `%s'"),
		      member->body.member.entry->string_mb,
		      member->body.member.library->string_mb);
	}

	if (fseek(arp->fd, arp->sym_begin, 0) != 0) {
		goto read_error;
	}
	member_string = ALLOC_WC((int) ((int) ar_member_name_len * 2));

	switch (arp->type) {
	case AR_5:
		if ((len = member->body.member.entry->hash.length) > 8) {
			len = 8;
		}
		for (i = 0; i < arp->num_symbols; i++) {
			if (fread((char *) &arp->ars_5,
				  sizeof arp->ars_5,
				  1,
				  arp->fd) != 1) {
				goto read_error;
			}
			if (IS_EQUALN(arp->ars_5.sym_name,
				      member->body.member.entry->string_mb,
				      len)) {
				if ((fseek(arp->fd,
					   sgetl(arp->ars_5.sym_ptr),
					   0) != 0) ||
				    (fread((char *) &arp->arf_5,
					   sizeof arp->arf_5,
					   1,
					   arp->fd) != 1)) {
					goto read_error;
				}
				MBSTOWCS(wcs_buffer, arp->arf_5.arf_name);
				(void) wcsncpy(member_string,
					      wcs_buffer,
					      wcslen(wcs_buffer));
				member_string[sizeof(arp->arf_5.arf_name)] =
								(int) nul_char;
				member->body.member.member =
					GETNAME(member_string, FIND_LENGTH);
				target->stat.time.tv_sec = sgetl(arp->arf_5.arf_date);
				target->stat.time.tv_nsec = LONG_MAX;
				return;
			}
		}
		break;
	case AR_PORT:
		offs = (ar_port_word *) alloca((int) (arp->num_symbols * AR_PORT_WORD));
		if (fread((char *) offs,
			  AR_PORT_WORD,
			  (int) arp->num_symbols,
			  arp->fd) != arp->num_symbols) {
			goto read_error;
		}

		for(i=0;i<arp->num_symbols;i++) {
			*((int*)buffer)=offs[i];
			offs[i]=(ar_port_word)sgetl(buffer);
		}

		strtablen=arp->sym_size-4-(int) (arp->num_symbols * AR_PORT_WORD);
		syms = (char *) alloca(strtablen);
		if (fread(syms,
			  sizeof (char),
			  strtablen,
			  arp->fd) != strtablen) {
			goto read_error;
		}
		offend = &offs[arp->num_symbols];
		while (offs < offend) {
			maxs = strlen(member->body.member.entry->string_mb);
			if(strlen(syms) > maxs)
				maxs = strlen(syms);
			if (IS_EQUALN(syms,
				      member->body.member.entry->string_mb,
				      maxs)) {
				if (fseek(arp->fd,
					  (long) *offs,
					  0) != 0) {
					goto read_error;
				}
				if ((fread((char *) &arp->ar_port,
					   sizeof arp->ar_port,
					   1,
					   arp->fd) != 1) ||
				    !IS_EQUALN(arp->ar_port.ar_fmag,
					       AR_PORT_END_MAGIC,
					       sizeof arp->ar_port.ar_fmag)) {
					goto read_error;
				}
				if (sscanf(arp->ar_port.ar_date,
					   "%ld",
					   &date) != 1) {
					fatal(gettext("Bad date field for member `%s' in archive `%s'"),
					      arp->ar_port.ar_name,
					      target->string_mb);
				}
		    /* If it's a long name, retrieve it from long name table */
		    if (arp->ar_port.ar_name[0] == '/') {
			    sscanf(arp->ar_port.ar_name + 1,
				   "%ld",
				   &offset);
			    len = ar_member_name_len;
			    hp = *long_names_table + offset;
		    } else {
			    len = sizeof arp->ar_port.ar_name;
			    hp = arp->ar_port.ar_name;
		    }
				ap = member_string;
				while (*hp &&
				       (*hp != (int) slash_char) &&
				       (ap < &member_string[len])) {
					MBTOWC(ap, hp);
					ap++;
					hp++;
				}
				*ap = (int) nul_char;
				member->body.member.member =
					GETNAME(member_string, FIND_LENGTH);
				target->stat.time.tv_sec = date;
				target->stat.time.tv_nsec = LONG_MAX;
				return;
			}
			offs++;
			while(*syms!='\0') syms++;
			syms++;
		}
	}
	fatal(gettext("Cannot find symbol `%s' in archive `%s'"),
	      member->body.member.entry->string_mb,
	      member->body.member.library->string_mb);
	/*NOTREACHED*/

read_error:
	if (ferror(arp->fd)) {
		fatal(gettext("Read error in archive `%s': %s"),
		      member->body.member.library->string_mb,
		      errmsg(errno));
	} else {
		fatal(gettext("Read error in archive `%s': Premature EOF"),
		      member->body.member.library->string_mb);
	}
}

/*
 *	sgetl(buffer)
 *
 *	The intent here is to provide a means to make the value of
 *	bytes in an io-buffer correspond to the value of a long
 *	in the memory while doing the io a long at a time.
 *	Files written and read in this way are machine-independent.
 *
 *	Return value:
 *				Long int read from buffer
 *	Parameters:
 *		buffer		buffer we need to read long int from
 *
 *	Global variables used:
 */
static long
sgetl(register char *buffer)
{
	register long		w = 0;
	register int		i = BITSPERBYTE * AR_PORT_WORD;

	while ((i -= BITSPERBYTE) >= 0) {
		w |= (long) ((unsigned char) *buffer++) << i;
	}
	return w;
}


/*
 *	read_member_header(header, fd, filename)
 *
 *	reads the member header for the 4.1.x and SVr4 archives.
 *
 *	Return value:
 *				fails if read error or member
 *				header is not the right format
 *	Parameters:
 *		header		There's one before each archive member
 *		fd		file descriptor for the archive file.
 *
 *	Global variables used:
 */
int
read_member_header(Ar_port *header, FILE *fd, char* filename)
{
	int num = fread((char *) header, sizeof (Ar_port), 1, fd);
	if (num != 1 && feof(fd)) {
		/* There is no member header - empty archive */
		return -1;
	}
	if ((num != 1) ||
	    !IS_EQUALN(
		AR_PORT_END_MAGIC,
		header->ar_fmag,
		sizeof (header->ar_fmag)
	    )
	) {
		fatal(
			gettext("Read error in archive `%s': invalid archive file member header at 0x%x"),
			filename,
			ftell(fd)
		);
	}
	return succeeded;
}