/* $RCSfile: arlib.c,v $
-- $Revision: 1.5 $
-- last change: $Author: hr $ $Date: 2006/04/20 12:18:37 $
--
-- SYNOPSIS
-- Unix archive manipulation code.
--
-- DESCRIPTION
-- Originally this code was provided by Eric Gisin of MKS. I took
-- his code and completely rewrote it adding cacheing of lib members
-- and other various optimizations. I kept the overal functional
-- idea of the library routines as they are similar to those in GNU
-- make and felt it advantageous to maintain a similar interface.
--
-- AUTHOR
-- Dennis Vadura, dvadura@dmake.wticorp.com
--
-- WWW
-- http://dmake.wticorp.com/
--
-- COPYRIGHT
-- Copyright (c) 1996,1997 by WTI Corp. All rights reserved.
--
-- This program is NOT free software; you can redistribute it and/or
-- modify it under the terms of the Software License Agreement Provided
-- in the file <distribution-root>/readme/license.txt.
--
-- LOG
-- Use cvs log to obtain detailed change logs.
*/
/* Sun unix on 386i's has a broken ar.h that does not assume PORTAR format
* by default, so we fix it here. */
#if defined(i386) || defined(__DGUX__)
#define PORTAR 1
#endif
#if !defined (COHERENT) && !defined(__COHERENT__)
#include <ar.h>
#else
#include <arcoff.h>
#endif /* COHERENT, __COHERENT__ */
#include "extern.h"
#include "sysintf.h"
/* By defining the defines below it is possible to configure the library
* code for library cacheing/non-cacheing, ASCII archive headers, and a full
* decode of the ar_hdr fields in the scan_ar function. */
#ifndef ASCARCH
#define ASCARCH 1 /* ASCII time stored in archive */
#endif
#ifndef LC
#define LC 1 /* Turn on library cacheing */
#endif
#ifndef CHECKELF
#define CHECKELF 1 /* Enable Elf long member names */
#endif
#ifndef DECODE_ALL_AR_FIELDS
#define DECODE_ALL_AR_FIELDS 0 /* decode only fields make needs*/
#endif
#ifndef AR_TRUNCATE_MEMBER_NAMES
#define AR_TRUNCATE_MEMBER_NAMES 0 /* truncate member names for */
#endif /* comparison. */
#if LC
# define FOUND_MEMBER FALSE
#else
# define FOUND_MEMBER TRUE
# define _cache_member(a, b, c)
# define _check_cache(a, b, c, d) FALSE
#endif
#define MAXFNAME 255 /* Max length of member name */
#define MAXMNAME 8 /* Max module name < MAXFNAME */
/* This struct is used to pass the library and member inrmation about the
* routines that perform the library seeking/cacheing */
struct ar_args {
char *lib;
char *member;
time_t time;
};
typedef struct AR {
char ar_name[MAXFNAME+1]; /* File name */
long ar_size; /* Size in bytes */
time_t ar_time; /* Modification time */
#ifdef DOS
char ar_modname[MAXMNAME+1]; /* DOS module name */
#endif
#if DECODE_ALL_AR_FIELDS
uint16 ar_mode; /* File mode */
uint16 ar_uid; /* File owner */
uint16 ar_gid; /* File group owner */
#endif
} AR, *ARPTR;
static int ar_scan ANSI((FILE *,
int (*) ANSI((FILE *, struct AR *,struct ar_args *)),
struct ar_args *));
static int ar_touch ANSI(( FILE *, time_t ));
static int time_function ANSI(( FILE *, struct AR *, struct ar_args * ));
static int touch_function ANSI(( FILE *, struct AR *, struct ar_args * ));
static int ar_name_equal ANSI((char *, char *));
#if LC
static int _cache_member ANSI((char *, char *, time_t));
static int _check_cache ANSI((char *, char *, time_t *, int));
#endif
/* decoded archive header */
static AR _ar;
static off_t arhdroffset; /* member seek offset */
PUBLIC time_t
seek_arch(name, lib)/*
======================
Look for module 'name' inside 'lib'. If compiled with cacheing then first
check to see if the specified lib is cached. If so then return that time
stamp instead of looking into the library. */
char *name;
char *lib;
{
FILE *f;
int rv;
time_t mtime;
struct ar_args args;
/* Check the cache first (if there is a cache) */
if( _check_cache(name, lib, &mtime, FALSE) ) return( mtime );
/* Open the lib file and perform the scan of the members, looking
* for our particular member. If cacheing is enabled it will be
* taken care of automatically during the scan. */
args.lib = lib;
args.member = name;
args.time = (time_t)0L;
if( (f = fopen(lib, "r")) == NIL(FILE) ) return( (time_t)0L );
rv = ar_scan(f, time_function, &args );
fclose( f );
if( rv < 0 ) Fatal("(%s): Invalid library format", lib);
return( args.time );
}
PUBLIC int
touch_arch(name, lib)/*
=======================
Look for module 'name' inside 'lib'. If compiled with cacheing then first
check to see if the specified lib is cached. If so then set that time
stamp and write it into the library. Returns 0 on success, non-zero
on failure. */
char *name;
char *lib;
{
FILE *f;
int rv;
struct ar_args args;
/* Open the lib file and perform the scan of the members, looking
* for our particular member. If cacheing is enabled it will be
* taken care of automatically during the scan. */
args.lib = lib;
args.member = name;
args.time = (time_t)0L;
if( (f = fopen(lib, "r+")) == NIL(FILE) ) return( (time_t)1L );
rv = ar_scan(f, touch_function, &args );
fclose( f );
if( rv < 0 ) Fatal("(%s): Invalid library format", lib);
return( 0 );
}
static int
time_function(f, arp, argp)/*
=============================
get library member's time, if it matches than return it in argp, if
cacheing is enabled than cache the library members also. */
FILE *f; /* library file */
struct AR *arp; /* library member header */
struct ar_args *argp;
{
int rv = _cache_member( arp->ar_name, argp->lib, arp->ar_time );
if( ar_name_equal (argp->member, arp->ar_name)) {
argp->time = arp->ar_time;
if( arp->ar_time == 0 && !(Glob_attr & A_SILENT) )
Warning( "(%s): Can't extract library member timestamp; using EPOCH",
argp->member);
return( rv ); /* 1 => no cacheing, 0 => cacheing */
}
return( FALSE ); /* continue scan */
}
static int
touch_function(f, arp, argp)/*
==============================
Update library member's time stamp, and write new time value into cache
if required. */
FILE *f; /* library file */
struct AR *arp; /* library member header */
struct ar_args *argp;
{
extern time_t time ANSI(( time_t * ));
time_t now = time((time_t*) NULL); /* Current time. */
if( ar_name_equal(argp->member, arp->ar_name) ) {
_check_cache( argp->member, argp->lib, &now, TRUE );
ar_touch(f, now );
return( TRUE );
}
return( FALSE ); /* continue scan */
}
static int
ar_name_equal (char * name1, char * name2)
{
int equal;
#if AR_TRUNCATE_MEMBER_NAMES
struct ar_hdr hdr;
equal = !strncmp (name1, name2, sizeof (hdr.ar_name)-1);
#else
equal = !strcmp (name1, name2);
#endif
return equal;
}
static int
ar_scan(f, function, arg)/*
===========================
Scan the opened archive, and call the given function for each member found.
The function will be called with the file positioned at the beginning of
the member and it can read up to arp->ar_size bytes of the archive member.
If the function returns 1, we stop and return 1. We return 0 at the end
of the archive, or -1 if the archive has invalid format. This interface
is more general than required by "make", but it can be used by other
utilities. */
register FILE *f;
int (*function) ANSI((FILE *, struct AR *, struct ar_args *));
struct ar_args *arg;
{
extern long atol ();
register char *p;
struct ar_hdr arhdr; /* archive member header */
long nsize; /* size of member name */
long arind=0; /* archive index offset */
int process;
#if defined(_AIX)
struct fl_hdr flhdr; /* archive file header */
char magic[SAIAMAG]; /* size of magic string */
#else
#if ASCARCH
char magic[SARMAG];
#else
unsigned short word;
#endif
#endif
fseek( f, 0L, 0 ); /* Start at the beginning of the archive file */
#if ASCARCH
#if defined(_AIX)
fread( (char *)&flhdr, sizeof(flhdr), 1, f );
if( strncmp(flhdr.fl_magic,AIAMAG, SAIAMAG) != 0 ) return(-1);
fseek(f, atol(flhdr.fl_fstmoff), 0 ); /* postition to first member */
#else
fread( magic, sizeof(magic), 1, f );
if( strncmp(magic, ARMAG, SARMAG) != 0 ) return( -1 );
#endif
#else
fread( (char*)&word, sizeof(word), 1, f );
if( word != ARMAG ) return( -1 );
#endif
/* scan the library, calling `function' for each member
*/
while( 1 ) {
arhdroffset = ftell(f);
#if defined(_AIX)
if( fread((char*)&arhdr,sizeof(arhdr)-sizeof(arhdr._ar_name),1,f)!=1)
break;
nsize = atoi(arhdr.ar_namlen);
fseek(f, arhdroffset+(unsigned long)(((struct ar_hdr *)0)->_ar_name.ar_name), 0);
if( fread((char*)_ar.ar_name,nsize,1,f)!=1)
break;
_ar.ar_name[nsize]='\0';
#else
if( fread((char*) &arhdr, sizeof(arhdr), 1, f) != 1 ) break;
strncpy(_ar.ar_name, arhdr.ar_name, nsize = sizeof(arhdr.ar_name));
#endif
for( p = &_ar.ar_name[nsize];
--p >= _ar.ar_name && *p == ' ';);
p[1] = '\0';
if( *p == '/' ) *p = 0; /* SysV has trailing '/' */
/* check to see if this is an archive index using SsysV Index scheme.
* see ar(4) man page for more info */
#if CHECKELF
if( _ar.ar_name[0] == '/' && _ar.ar_name[1] == '\0' ) {
arind = arhdroffset+sizeof(arhdr);
process = 0;
}
else
#endif
process = 1;
#if !defined(_AIX)
#if ASCARCH
if( strncmp(arhdr.ar_fmag, ARFMAG, sizeof(arhdr.ar_fmag)) != 0 )
return( -1 );
_ar.ar_time = atol(arhdr.ar_date);
_ar.ar_size = atol(arhdr.ar_size);
#else
_ar.ar_time = arhdr.ar_date;
_ar.ar_size = arhdr.ar_size;
#endif
#if CHECKELF
/* check for names of the form /xxxx where xxxx is an offset into the
* name table pointed at by arind. */
if(arind && _ar.ar_name[0] == '/') {
long offset = atol(_ar.ar_name+1);
long here = ftell(f);
int c;
fseek(f, arind+offset, 0);
p = _ar.ar_name;
while((c=fgetc(f)) != EOF) {
*p++ = c;
if(c == '/') {
p[-1] = '\0';
break;
}
}
if (c==EOF) return(-1); /* 'c' should never be EOF */
fseek(f, here, 0);
}
#endif
#else
#if ASCARCH
_ar.ar_time = atol(arhdr.ar_date);
_ar.ar_size = atol(arhdr.ar_nxtmem);
#else
_ar.ar_time = arhdr.ar_date;
_ar.ar_size = arhdr.ar_nxtmem;
#endif
#endif
#if DECODE_ALL_AR_FIELDS
#if ASCARCH
_ar.ar_mode = atoi(arhdr.ar_mode);
_ar.ar_uid = atoi(arhdr.ar_uid);
_ar.ar_gid = atoi(arhdr.ar_gid);
#else
_ar.ar_mode = arhdr.ar_mode;
_ar.ar_uid = arhdr.ar_uid;
_ar.ar_gid = arhdr.ar_gid;
#endif
#endif
if( process && (*function)(f, &_ar, arg) ) return( 1 );
#if defined(_AIX)
if( _ar.ar_size == 0L ) break;
fseek( f, (long) _ar.ar_size, 0 );
#else
fseek( f, arhdroffset + sizeof(arhdr) + ((_ar.ar_size+1) & ~1L), 0 );
#endif
}
#if !defined(_AIX)
if( !feof(f) ) return( -1 );
#endif
return 0;
}
static int
ar_touch( f, now )/*
====================
touch module header timestamp. */
FILE *f;
time_t now;
{
fseek(f, arhdroffset + (unsigned long)(((struct ar_hdr *)0)->ar_date), 0);
#if ASCARCH
fprintf(f, "%lu", now);
#else
fwrite((char *)now, sizeof(now), 1, f);
#endif
return( ferror(f) ? 0 : 1 );
}
#if LC
typedef struct mem {
time_t m_time; /* modify time of member*/
struct mem *m_next; /* next member in lib */
char m_valid; /* valid cache entry */
char m_name[1]; /* lib member name */
} MEM, *MEMPTR;
typedef struct lib {
struct lib *lb_next; /* next library in list */
struct mem *lb_members; /* list of lib members */
char lb_valid; /* valid cache entry */
char *lb_name; /* library name */
} LIB, *LIBPTR;
static LIBPTR _cache = NIL(LIB);
static MEMPTR _find_member ANSI(( LIBPTR, char * ));
static int
_check_cache( name, lib, pmtime, touch )/*
==========================================
Check to see if we have cached member in lib, if so return time in pmtime
and return TRUE, otherwise return FALSE, if touch is TRUE then touch
the archive member instead. */
char *name;
char *lib;
time_t *pmtime;
int touch;
{
register MEMPTR mp;
register LIBPTR lp;
for( lp=_cache; lp != NIL(LIB) && lp->lb_name != lib; lp=lp->lb_next );
if( lp == NIL(LIB) ) return( FALSE );
mp = _find_member( lp, name );
if( mp == NIL(MEM) || !mp->m_valid ) return( FALSE );
if( touch == TRUE )
{
mp->m_time = *pmtime;
mp->m_valid = 1;
}
else
*pmtime = mp->m_time;
lp->lb_valid = 1;
lp->lb_members = mp;
return( TRUE );
}
static int
_cache_member( name, lib, mtime )/*
===================================
Cache name in lib along with it's time */
char *name;
char *lib;
time_t mtime;
{
register MEMPTR mp;
register LIBPTR lp;
for( lp=_cache;
lp != NIL(LIB) && lp->lb_name != NIL(char) && lp->lb_name != lib;
lp=lp->lb_next);
if( lp == NIL(LIB) )
{
lp = (LIBPTR) malloc(sizeof(LIB));
if( lp == NIL(LIB) ) No_ram();
lp->lb_name = lib;
lp->lb_members = NIL(MEM);
lp->lb_next = _cache;
lp->lb_valid = 0;
_cache = lp;
}
/* On UNIX ar does not allow multiple copies of the same .o file to live
* in the same AR file. If this is not TRUE then use the commented out
* version to set the value of mp. */
/*mp = _find_member(lp, name);*/
mp = NIL(MEM);
if( mp == NIL(MEM) )
{
mp = (MEMPTR) malloc(sizeof(char)*offsetof(MEM,m_name[strlen(name)+1]));
if( mp == NIL(MEM) ) No_ram();
strcpy( mp->m_name, name );
mp->m_time = mtime;
if( lp->lb_members == NIL(MEM) ) {
mp->m_next = mp;
lp->lb_members = mp;
}
else {
mp->m_next = lp->lb_members->m_next;
lp->lb_members->m_next = mp;
lp->lb_members = mp;
}
}
else
mp->m_time = mtime;
mp->m_valid = 1;
return( lp->lb_valid );
}
static MEMPTR
_find_member( lp, name )
LIBPTR lp;
char *name;
{
register MEMPTR mp = lp->lb_members;
if( mp == NIL(MEM) ) return(mp);
do {
if( !strcmp(mp->m_name, name ) ) return( mp );
mp = mp->m_next;
}
while( mp != lp->lb_members );
return( NIL(MEM) );
}
#endif
PUBLIC void
void_lcache( lib, member )/*
============================
Void the library cache for lib. If member is NIL(char) then nuke all
of the members, if member is NOT NIL(char) then invalidate only that
member. */
char *lib;
char *member;
{
#if LC
register LIBPTR lp;
register MEMPTR mp;
register MEMPTR tmp;
for( lp=_cache; lp != NIL(LIB) && lp->lb_name != lib; lp=lp->lb_next );
if( lp == NIL(LIB) ) return;
if( member == NIL(char) ) {
mp = lp->lb_members;
do {
tmp = mp->m_next;
(void) free( mp );
mp = tmp;
} while( mp != lp->lb_members );
lp->lb_valid = 0;
lp->lb_members = NIL(MEM);
lp->lb_name = NIL(char);
}
else {
mp=lp->lb_members;
do {
if( strcmp( member, mp->m_name) == 0 ) {
lp->lb_members = mp->m_next;
mp->m_valid = 0;
}
mp=mp->m_next;
} while( mp != lp->lb_members );
}
#endif
}
syntax highlighted by Code2HTML, v. 0.9.1