github.com/Arquivotheca.AIX-4.1.3
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
Files
413
Arquivotheca.AIX-4.1.3/bldenv/pkgtools/ilverify.c
seta75D d6fe8fe829 Init
2021-10-11 22:19:34 -03:00

675 lines
21 KiB
C
Raw Permalink Blame History

static char sccsid[] = "@(#)06 1.13 src/bldenv/pkgtools/ilverify.c, pkgtools, bos412, GOLDA411a 8/30/94 15:15:33";
/*
* COMPONENT_NAME: PKGTOOLS
*
* FUNCTIONS: createPrqPaths
* createIlpaths
* find_inslist
* getOrderedList
* getPrereqs
* il_array
* main
* prereqMatch
*
* ORIGINS: 27
*
* IBM CONFIDENTIAL -- (IBM Confidential Restricted when
* combined with the aggregated modules for this product)
* SOURCE MATERIALS
*
* (C) COPYRIGHT International Business Machines Corp. 1993
* All Rights Reserved
* US Government Users Restricted Rights - Use, duplication or
* disclosure restricted by GSA ADP Schedule Contract with IBM Corp.
*/
#include <sys/stat.h>
#include "ins.h"
#include "ade.h"
extern char *optarg;
extern char *commandName;
main(int ac,char **av)
{
char *searchDir = '\0'; /* -p option */
char *dbFileOut = '\0'; /* -d option */
char *dbFileIn = '\0'; /* -n option */
char exceptList[MAXPATHLEN+1]; /* -e option */
char *idTableFile = '\0'; /* -t option */
char *ptr;
char insname[MAXPATHLEN+1];
char buf[ADE_BUFSIZE];
int dFlag=0, iFlag=0;
int arg, i=0, num_ilpaths=0;
char insLists[INS_MAXPATHS][MAXPATHLEN+1];
int rc=INS_SUCCESS, readrc=0;
InsEntry insentry;
struct stat statbuf;
FILE *ilpathsfp = NULL;
FILE *insfp = NULL;
FILE *id_ptr = NULL;
FILE *except_ptr = NULL;
FILE *dbout_ptr = NULL;
FILE *dbin_ptr = NULL;
/*-----------------------------------------------------------
| Remove old copies of ilpaths file and prqpaths file. |
-----------------------------------------------------------*/
if ( !stat ("ilpaths", &statbuf) )
unlink ("ilpaths");
if ( !stat ("prqpaths", &statbuf) )
unlink ("prqpaths");
while (( arg = getopt (ac, av, "p:e:i:t:d:n:")) != EOF)
{
switch (arg)
{
case 'i':
iFlag++;
ilpathsfp = openFile("ilpaths","w");
ptr = strtok(optarg,":");
do {
sprintf(insname,"%s\n",ptr);
fputs(insname,ilpathsfp);
ptr = strtok(NULL,":");
}
while (ptr != (char *)NULL);
fclose(ilpathsfp);
break;
case 'p':
searchDir = optarg;
break;
case 't':
idTableFile = optarg;
break;
case 'e':
strcpy (exceptList, optarg);
break;
case 'd':
dFlag++;
dbFileOut = optarg;
break;
case 'n':
dbFileIn = optarg;
break;
default:
usage();
break;
}
}
/*-------------------------------------------
| -d and -n are mutually exclusive. |
-------------------------------------------*/
if (*dbFileIn && *dbFileOut)
usage();
/*-------------------------------------------
| Open optional id table file. |
-------------------------------------------*/
if ( *idTableFile )
id_ptr = openFile(idTableFile,"r");
/*-------------------------------------------
| Open optional exception list file. |
-------------------------------------------*/
if ( !(*exceptList) )
if ( (ptr = getenv(EXCEPTION_LIST)) != NULL )
strcpy (exceptList, ptr);
if (*exceptList)
except_ptr = openFile(exceptList,"r");
/*-------------------------------------------
| Open optional output database file. |
-------------------------------------------*/
if ( dFlag )
dbout_ptr = openFile(dbFileOut,"w");
/*-------------------------------------------
| Open optional input database file. |
-------------------------------------------*/
if ( *dbFileIn )
dbin_ptr = openFile(dbFileIn,"r");
else
if ( dbFileIn = getenv(DB_FILE_IN) )
if ( dFlag )
fatal (dbFileError);
else
dbin_ptr = openFile(dbFileIn,"r");
num_ilpaths = createIlpaths (searchDir, iFlag, insLists, dbFileIn);
/*-------------------------------------------------------------------
| If we are verifying against a dabatase file we won't do the |
| requisite directory checking because we won't have all of the |
| prereq files available. |
-------------------------------------------------------------------*/
if ( *dbFileIn )
{
fprintf (stdout, "%s: Verification against an input database file\n",commandName);
fprintf (stdout, "\twill not include requisite directory checks.\n\n");
}
/*-------------------------------------------------------------------
| Otherwise, rewrite the ilpaths file from the ordered inslist |
| array so that dirCheck will process them in the correct order. |
-------------------------------------------------------------------*/
else
ilpathsfp = openFile ("ilpaths", "w");
/*-------------------------------------------------------------------
| Read each inslist in array and verify each inslist entry and |
| rewrite the ilpaths file if applicable. |
-------------------------------------------------------------------*/
fprintf (stdout, "\nPerforming syntax check and link verification:\n\n");
fflush (stdout);
for (i = 0; i < num_ilpaths; i++)
{
if ( (insfp = fopen (insLists[i], "r")) )
{
if ( !strlen(dbFileIn) )
fprintf (ilpathsfp, "%s\n", insLists[i]);
fprintf (stdout, "\n%s:\n",insLists[i]);
fflush (stdout);
/*-----------------------------------------------------------
| Write inslist header line to database output file. |
-----------------------------------------------------------*/
if ( dFlag )
{
sprintf (buf, "!!%s\n",insLists[i]);
fputs (buf, dbout_ptr);
}
/*-----------------------------------------------------------
| A non-zero value in the 3rd parm used to cause extra |
| verification checks for hard link entries, however this |
| is no longer necessary (so 3rd parm is always 0). |
-----------------------------------------------------------*/
while ( (readrc = readList (insfp, &insentry, 0)) != EOF )
{
rc |= readrc;
rc |= idTable (&insentry, id_ptr);
rc |= crossFileSys (&insentry);
if ( dFlag && (readrc == 0) )
writeDb (dbout_ptr, &insentry);
fflush (dbout_ptr);
}
fclose(insfp);
}
else
warning (insOpenFailed, insLists[i]);
}
if ( !strlen(dbFileIn) )
fclose (ilpathsfp);
/*-----------------------------------------------------------
| Build perl command. The format of the command is |
| dirCheck <ilfile> <exceptList> <inputDBFile> |
| where exceptList and inputDBFile are N if they do not |
| apply. |
-----------------------------------------------------------*/
if ( (ptr = getenv(ODE_TOOLS)) != NULL )
sprintf (buf, "%s/usr/bin/dirCheck ilpaths ", ptr);
else
sprintf (buf, "dirCheck ilpaths ");
if ( except_ptr )
strcat (buf, exceptList);
else
strcat (buf, "N");
strcat (buf, " ");
if ( dbin_ptr )
strcat (buf, dbFileIn);
else
strcat (buf, "N");
rc |= system (buf);
unlink("ilpaths");
if ( dFlag )
fclose (dbout_ptr);
if ( dbin_ptr )
fclose (dbin_ptr);
exit(rc);
}
/*-----------------------------------------------------------------------
| Create an inslist array. If dbFlag is set the array is not ordered. |
| Otherwise, check the prereq files for each inslist recursively and |
| list all prereq inslist files first. The prqpaths file has a list |
| of all of the prereq files. |
-----------------------------------------------------------------------*/
il_array(char insLists[][MAXPATHLEN+1], int dbFlag)
{
int inscount = 0;
int i;
int prqListIndex=0; /* Index to the lppOpt:prereq list */
int prqCount=0; /* Index to the ordered prereq list */
/* which contains individual lpp */
/* option names ordered by */
/* the prereq.S files */
FILE *pfilefp, *insfp;
char prqFileName[MAXPATHLEN+1];
char *prereqName;
char *ptr;
char prereqList[INS_MAXPATHS][2*MAXPATHLEN+2]; /* lppOpt:prereq list */
char orderedPrereqList[INS_MAXPATHS][MAXPATHLEN+1]; /* see prqCount */
/*-------------------------------------------------------------------
| Create an array of all the lpp option names and their prereqs. |
| The prereq file naming convention is lppOptionName.prereq.S. |
| The prereq file contains the name(s) of prereq lpps or lpp |
| options. The format of the array entry is: |
| lppOptName:prereqlppOptName |
-------------------------------------------------------------------*/
if ( !dbFlag )
{
if ( pfilefp = fopen("prqpaths", "r") )
{
while ( (fgets(prqFileName, ADE_BUFSIZE, pfilefp)) != NULL)
{
if ( ptr = strchr (prqFileName, '\n') )
*ptr = '\0';
getPrereqs (prqFileName, prereqList, &prqListIndex);
}
fclose(pfilefp);
unlink("prqpaths");
/*-----------------------------------------------------------
| Create an ordered array of prereqs, eliminating the dups. |
| This is done by recursively searching the prereq list |
| until the end of the prereq chain is found. |
-----------------------------------------------------------*/
for (i=0; i < prqListIndex; i++)
{
prereqName = strchr(prereqList[i],':');
prereqName++;
prereqMatch (prereqName, &prqCount, orderedPrereqList, prereqList, prqListIndex);
}
}
}
insfp = openFile("ilpaths", "r");
/*-----------------------------------------------------------
| If a database input file was specified the inslist do |
| not have to be ordered. |
-----------------------------------------------------------*/
if ( dbFlag )
{
while ( fgets(insLists[inscount], MAXPATHLEN+1, insfp) != NULL)
{
if ( ptr = strchr (insLists[inscount], '\n') )
*ptr = '\0';
inscount++;
if (inscount == INS_MAXPATHS)
fatal (numInslistsExceededLimit, INS_MAXPATHS);
}
return (inscount);
}
else
inscount = getOrderedList (insLists, insfp, prqCount, orderedPrereqList, prereqList, prqListIndex);
fclose(insfp);
return (inscount);
}
/*-----------------------------------------------------------------------
| Recursively search prereqList to get the prereq chain for an lpp |
| option. When the prereq chain stops write the lpp names to the |
| ordered prereq list. |
-----------------------------------------------------------------------*/
void
prereqMatch (char *prereqName, int *prqCount,
char orderedPrereqList[][MAXPATHLEN+1], char prereqList[][2*MAXPATHLEN+2],
int prqListIndex)
{
int i, index;
char *ptr;
char lppOptName[ADE_BUFSIZE];
for (i=0; i < prqListIndex; i++)
{
strcpy (lppOptName, prereqList[i]);
ptr = strchr(lppOptName,':');
*ptr = '\0';
ptr++;
if ( !strcmp(prereqName, lppOptName) )
prereqMatch(ptr,prqCount,orderedPrereqList,prereqList, prqListIndex);
}
/*-----------------------------------------------------------
| Check for dups as we add to the orderedPrereqList. |
-----------------------------------------------------------*/
for ( index=0; index < *prqCount; index++ )
if ( !strcmp (prereqName, orderedPrereqList[index]) )
return;
if (*prqCount < INS_MAXPATHS)
{
strcpy (orderedPrereqList[*prqCount], prereqName);
*prqCount = (*prqCount) + 1;
}
else
fatal (numOptionsExceededLimit, INS_MAXPATHS);
}
/*-----------------------------------------------------------------------
| Search the inslist array for a particular inslist. Return the index |
| if a match is found, otherwise -1. |
-----------------------------------------------------------------------*/
find_inslist(char iLists[][MAXPATHLEN+1], int inscount, char *ilname)
{
int i = 0;
char *tmpname;
while ( i < inscount )
{
if ( (tmpname = strrchr(iLists[i],'/')) != '\0' )
++tmpname;
else
tmpname = iLists[i];
if ( !strcmp(tmpname,ilname) )
return (i);
i++;
}
return (-1);
}
/*-----------------------------------------------------------------------
| Generate the prereq file name for inslists specified with the -i |
| option. If the prereq file exists then add it to prqpaths. |
-----------------------------------------------------------------------*/
void createPrqPaths()
{
char fName[ADE_BUFSIZE];
char *ptr;
struct stat statbuf;
FILE *ilpathfp;
FILE *prqpathfp;
ilpathfp = openFile("ilpaths","r");
prqpathfp = openFile("prqpaths","w");
while ( fgets(fName, ADE_BUFSIZE, ilpathfp) != NULL )
{
if ( (ptr = strrchr(fName,'.')) != NULL )
*ptr = '\0';
strcat (fName, "prereq.S");
if ( !stat (fName, &statbuf) )
{
fputs (fName, prqpathfp);
fputs ("\n", prqpathfp);
}
}
fclose(ilpathfp);
fclose(prqpathfp);
}
/*-----------------------------------------------------------------------
| Create ilpaths file and the prqpaths file. The ilpaths file is a list |
| of the inslist files (*.il) and the prqpaths file is a list of the |
| prereq files (*.prereq.S). The prereq files may not be located in |
| the same directory as the associated inslist. |
| |
| If -p and -i were not used on the command line, look for the |
| files in the current directory. |
-----------------------------------------------------------------------*/
createIlpaths ( char *searchDir, int iFlag, char insLists[][MAXPATHLEN+1],
char *dbFileIn )
{
int num_ilpaths, dbFlag=0;
char cmd[ADE_BUFSIZE];
char cmdPath[MAXPATHLEN+1];
struct stat statbuf;
char *ptr;
/*-----------------------------------------
| Set path name for find and ls commands. |
-----------------------------------------*/
strcpy (cmdPath, "/bin");
/*-----------------------------------------------------------
| If an input database file was specified there will |
| be no prerequisite directory checking. |
-----------------------------------------------------------*/
if ( strlen(dbFileIn) )
dbFlag++;
if ( (!*searchDir) && (!iFlag) )
{
sprintf(cmd, "%s/ls *.il > ilpaths 2>/dev/null", cmdPath);
system(cmd);
if ( stat ("ilpaths", &statbuf) )
fatal (statFailed);
else
if ( !statbuf.st_size )
fatal (noInsCurDir);
if ( !dbFlag )
{
sprintf(cmd, "%s/ls *.prereq.S > prqpaths 2>/dev/null", cmdPath);
system(cmd);
}
num_ilpaths = il_array(insLists, dbFlag);
}
else {
if ( iFlag && !dbFlag )
createPrqPaths();
/*---------------------------------------------------------------
| Get recursive list of inslist files from search directory. |
---------------------------------------------------------------*/
if ( *searchDir )
{
fprintf (stdout, "\nPerforming find command to get list of inslist files:\n\n");
fflush (stdout);
sprintf(cmd,"%s/find %s -name \"*.il\" -print >> ilpaths 2>/dev/null", cmdPath, searchDir);
system(cmd);
if ( !dbFlag )
{
fprintf (stdout, "\nPerforming find command to get list of prereq files:\n\n");
fflush (stdout);
sprintf(cmd,"%s/find %s -name \"*.prereq.S\" -print >> prqpaths 2>/dev/null", cmdPath, searchDir);
system(cmd);
}
}
if ( !(num_ilpaths = il_array(insLists, dbFlag)) )
fatal (noInsSearchDir, searchDir);
}
return (num_ilpaths);
}
/*---------------------------------------------------------------------
| NAME: getPrereqs
|
| DESCRIPTION: Get the prereqs from the prqFileName and add them to the
| prereq list
|
| PRE CONDITIONS: none
|
| POST CONDITIONS: none
|
| PARAMETERS:
| input: prqFileName - name for the file containing prereq infor-
| mation
| output: prereqList - array of prereqs with the following format
| option:prereq
| output: prqIndex - number of prereqs in the array
|
| NOTES: The prereqs in the file have the word prereq preceeding the name
|
| DATA STRUCTURES: none
|
| RETURNS: void
-----------------------------------------------------------------------*/
getPrereqs (char *prqFileName, char prereqList[][2*MAXPATHLEN+2], int *prqIndex)
{
char tmpFileName[MAXPATHLEN+1];
char prereqLine[ADE_BUFSIZE];
char lppOptName[ADE_BUFSIZE];
char *ptr;
FILE *prqfp;
strcpy(tmpFileName,prqFileName);
/*-----------------------------------------------
| Strip off leading path and .prereq.S suffix |
| to get lpp name from the prereq file path. |
-----------------------------------------------*/
ptr = strstr(tmpFileName,".prereq.S");
*ptr = '\0';
ptr = strrchr(tmpFileName,'/');
if ( ptr )
ptr++;
strcpy (lppOptName, ptr);
prqfp = fopen(prqFileName, "r");
if ( !prqfp )
{
warning (OpenError, prqFileName, 'r');
return;
}
/*-------------------------------------------------------
| Skip over the word prereq if it is there. We don't |
| need to keep track of coreqs, ifreqs or instreqs. |
-------------------------------------------------------*/
while (stripComments(prqfp, prereqLine) != EOF)
{
if (!(ptr = strstr(prereqLine, "prereq")))
continue;
/* parce up to the option name */
ptr = ptr + strlen("prereq") + 1;
while (isspace(*ptr))
{
ptr++;
}
/* get just the option name ( the option name may have junk
after it) */
ptr = strtok(ptr," \t");
if (*prqIndex < INS_MAXPATHS)
{
sprintf(prereqList[*prqIndex],"%s:%s",lppOptName,ptr);
*prqIndex = (*prqIndex)+1;
}
else
fatal (numOptionsExceededLimit, INS_MAXPATHS);
}
fclose (prqfp);
}
/*---------------------------------------------------------------
| NAME: getOrderedList
|
| DESCRIPTION: Order the *.il files according to the order in the
| prereq list. The bos.rte.il file should be first,
| followed by the inslists for the prereqs, followed
| by everything else. tmpLists is used to store the
| inslists in memory to speed up searching.
|
| PRE CONDITIONS: none
|
| POST CONDITIONS: none
|
| PARAMETERS:
| input: orderedPrereqList - list of options in prereq order
| input: prqCount - number if entries in orderedPrereqList
| input: prereqList - the list containing the option and its
| prereq information (format option:prereq)
| input: prqListIndex - number of entries in prereqList
| input: inspf - pointer to file containing list of *.il file
| names
| output: insLists - list of ordered *.il files
|
| NOTES:
|
| DATA STRUCTURES: none
|
| RETURNS: insindex - the number of entries (*.il files) in insLists
-----------------------------------------------------------------*/
static int
getOrderedList ( char insLists[][MAXPATHLEN+1], FILE *insfp,
int prqCount, char orderedPrereqList[][MAXPATHLEN+1],
char prereqList[][2*MAXPATHLEN+2],
int prqListIndex)
{
char tmpLists[INS_MAXPATHS][MAXPATHLEN+1];
int inscount=0, insindex = 0, i, j;
char ilname[MAXPATHLEN+1];
char *ptr;
int prqInsIndex;
char lppOptName[ADE_BUFSIZE];
while ( fgets(tmpLists[inscount], MAXPATHLEN+1, insfp) != NULL)
{
if ( ptr = strchr (tmpLists[inscount], '\n') )
*ptr = '\0';
inscount++;
if (inscount == INS_MAXPATHS)
fatal (numInslistsExceededLimit, INS_MAXPATHS);
}
if ( (prqInsIndex = find_inslist(tmpLists,inscount,"bos.rte.il")) != -1 )
strcpy(insLists[insindex++],tmpLists[prqInsIndex]);
else
inserror(BosNotFound);
/*-------------------------------------------------------------------
| Get the prereq inslists, skipping bos.rte since we've already |
| made sure it is there. |
-------------------------------------------------------------------*/
for ( i=0; i < prqCount; i++)
{
if ( !strcmp(orderedPrereqList[i], "bos.rte") )
break;
sprintf (ilname, "%s.il", orderedPrereqList[i]);
if ( (prqInsIndex = find_inslist(tmpLists,inscount,ilname)) != -1 )
strcpy(insLists[insindex++],tmpLists[prqInsIndex]);
else
for (j=0; j < prqListIndex; j++)
{
strcpy(lppOptName,prereqList[j]);
ptr = strchr(lppOptName,':');
*ptr = '\0';
ptr++;
if( !strcmp(ptr,orderedPrereqList[i]))
inserror (prereqInslistNotFound, orderedPrereqList[i], lppOptName);
}
}
/*----------------------------
| Get the remaining inslists |
----------------------------*/
for ( i=0; i < inscount; i++)
{
if ( (ptr = strrchr(tmpLists[i],'/')) != NULL)
{
++ptr;
strcpy (ilname, ptr);
}
else
strcpy (ilname, tmpLists[i]);
if ( find_inslist(insLists,inscount,ilname) == -1 )
strcpy(insLists[insindex++],tmpLists[i]);
}
return (insindex);
}
Reference in New Issue View Git Blame Copy Permalink