folkslinux
/
rpm
mirror of https://github.com/rpm-software-management/rpm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
rpm/tools/genhdlist.c

562 lines
13 KiB
C
Raw Blame History

#include <alloca.h>
#include <ctype.h>
#include <dirent.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <glob.h>
#include <dirent.h>
#include <popt.h>
#include <rpmlib.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <rpm/misc.h>
#include <rpm/rpmts.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <time.h>
#include <unistd.h>
#include "hash.h"
#define FILENAME_TAG 1000000
#define FILESIZE_TAG 1000001
#define CDNUM_TAG 1000002
#define ORDER_TAG 1000003
#define MATCHER_TAG 1000004
void expandFilelist(Header h);
void compressFilelist(Header h);
struct onePackageInfo {
char * name;
char * arch;
};
int pkgInfoCmp(const void * a, const void * b) {
const struct onePackageInfo * one = a;
const struct onePackageInfo * two = b;
int i;
i = strcmp(one->name, two->name);
if (i) return i;
return strcmp(one->arch, two->arch);
}
/*int tagsInList2[] = {
RPMTAG_FILESIZES, RPMTAG_FILEMODES, RPMTAG_FILEMD5S, RPMTAG_FILELINKTOS,
RPMTAG_FILEFLAGS, RPMTAG_FILELANGS,
RPMTAG_DIRNAMES, RPMTAG_DIRINDEXES, RPMTAG_BASENAMES,
-1
};*/
int tagsInList2[] = { -1 };
struct onePackageInfo * pkgList;
int pkgListItems = 0;
int pkgListAlloced = 0;
char ** depOrder = NULL;
hashTable requireTable;
/* make sure its <package>-<version>-<release> */
int sanityCheckDepOrderLine(char *line) {
char *r, *v;
r = strrchr(line, '-');
if (!r)
return -1;
v = strrchr(r, '-');
if (!v)
return -1;
return 0;
}
/* mmmm... linear search */
int getOrder (char * fn)
{
char *p;
int i;
if (!depOrder || !depOrder[0] || !depOrder[0][0]) {
return -1;
}
i = 0;
p = depOrder[i];
while (p && *p && strncmp (fn, p, strlen(p))) {
p = depOrder[++i];
}
if (p) {
return i;
}
fprintf (stderr, "WARNING: ordering not found for %s\n", fn);
return -1;
}
int onePrePass(const char * dirName) {
struct dirent * ent;
DIR * dir;
char * subdir = alloca(strlen(dirName) + 20);
FD_t fd;
int rc;
Header h;
char ** requires;
int c;
rpmts ts = rpmtsCreate();
rpmtsSetRootDir(ts, "/");
rpmtsSetVSFlags(ts, ~RPMVSF_NOHDRCHK);
rpmtsCloseDB(ts);
sprintf(subdir, "%s/RedHat/RPMS", dirName);
dir = opendir(subdir);
if (!dir) {
fprintf(stderr,"error opening directory %s: %s\n", subdir,
strerror(errno));
return 1;
}
chdir(subdir);
errno = 0;
ent = readdir(dir);
if (errno) {
perror("readdir");
return 1;
}
while (ent) {
int i = strlen (ent->d_name);
if (i > 4 && strcasecmp (&ent->d_name [i - 4], ".rpm") == 0) {
fd = Fopen(ent->d_name, "r");
if (!fd) {
perror("open");
exit(1);
}
rc = rpmReadPackageFile(ts, fd, ent->d_name, &h);
if (!rc) {
if (headerGetEntry(h, RPMTAG_REQUIRENAME, NULL,
(void **) &requires, &c)) {
while (c--)
if (*requires[c] == '/')
htAddToTable(requireTable, requires[c], ".");
}
headerFree(h);
/* XXX free requires */
}
Fclose(fd);
}
errno = 0;
ent = readdir(dir);
if (errno) {
perror("readdir");
return 1;
}
}
closedir(dir);
return 0;
}
int onePass(FD_t outfd, FD_t out2fd, const char * dirName, int cdNum) {
FD_t fd;
struct dirent * ent;
char * subdir = alloca(strlen(dirName) + 20);
int errno;
Header h, nh, h2;
int rc;
int_32 size;
DIR * dir;
struct stat sb;
int_32 * fileSizes;
int fileCount;
int order = -1;
char ** newFileList, ** fileNames;
uint_32 * newFileFlags, * fileFlags;
int newFileListCount;
int marker = time(NULL); /* good enough counter; we'll increment it */
rpmts ts = rpmtsCreate();
rpmtsSetRootDir(ts, "/");
rpmtsSetVSFlags(ts, ~RPMVSF_NOHDRCHK);
rpmtsCloseDB(ts);
sprintf(subdir, "%s/RedHat/RPMS", dirName);
dir = opendir(subdir);
if (!dir) {
fprintf(stderr,"error opening directory %s: %s\n", subdir,
strerror(errno));
return 1;
}
chdir(subdir);
errno = 0;
ent = readdir(dir);
if (errno) {
perror("readdir");
return 1;
}
while (ent) {
int i = strlen (ent->d_name);
if (i > 4 && strcasecmp (&ent->d_name [i - 4], ".rpm") == 0) {
fd = Fopen(ent->d_name, "r");
if (!fd) {
perror("open");
exit(1);
}
if (stat(ent->d_name, &sb)) {
perror("stat");
exit(1);
}
size = sb.st_size;
rc = rpmReadPackageFile(ts, fd, ent->d_name, &h);
if (!rc) {
if (pkgListItems == pkgListAlloced) {
pkgListAlloced += 100;
pkgList = realloc(pkgList,
sizeof(*pkgList) * pkgListAlloced);
}
headerGetEntry(h, RPMTAG_NAME, NULL,
(void **) &pkgList[pkgListItems].name, NULL);
headerGetEntry(h, RPMTAG_ARCH, NULL,
(void **) &pkgList[pkgListItems].arch, NULL);
pkgList[pkgListItems].name = strdup(pkgList[pkgListItems].name);
pkgList[pkgListItems].arch = strdup(pkgList[pkgListItems].arch);
pkgListItems++;
headerRemoveEntry(h, RPMTAG_POSTIN);
headerRemoveEntry(h, RPMTAG_POSTUN);
headerRemoveEntry(h, RPMTAG_PREIN);
headerRemoveEntry(h, RPMTAG_PREUN);
headerRemoveEntry(h, RPMTAG_FILEUSERNAME);
headerRemoveEntry(h, RPMTAG_FILEGROUPNAME);
headerRemoveEntry(h, RPMTAG_FILEVERIFYFLAGS);
headerRemoveEntry(h, RPMTAG_FILERDEVS);
headerRemoveEntry(h, RPMTAG_FILEMTIMES);
headerRemoveEntry(h, RPMTAG_FILEDEVICES);
headerRemoveEntry(h, RPMTAG_FILEINODES);
headerRemoveEntry(h, RPMTAG_TRIGGERSCRIPTS);
headerRemoveEntry(h, RPMTAG_TRIGGERVERSION);
headerRemoveEntry(h, RPMTAG_TRIGGERFLAGS);
headerRemoveEntry(h, RPMTAG_TRIGGERNAME);
headerRemoveEntry(h, RPMTAG_CHANGELOGTIME);
headerRemoveEntry(h, RPMTAG_CHANGELOGNAME);
headerRemoveEntry(h, RPMTAG_CHANGELOGTEXT);
headerRemoveEntry(h, RPMTAG_ICON);
headerRemoveEntry(h, RPMTAG_GIF);
headerRemoveEntry(h, RPMTAG_VENDOR);
headerRemoveEntry(h, RPMTAG_EXCLUDE);
headerRemoveEntry(h, RPMTAG_EXCLUSIVE);
headerRemoveEntry(h, RPMTAG_DISTRIBUTION);
headerRemoveEntry(h, RPMTAG_VERIFYSCRIPT);
/* new header sigs */
headerRemoveEntry(h, RPMTAG_SIGSIZE);
headerRemoveEntry(h, RPMTAG_SIGGPG);
headerRemoveEntry(h, RPMTAG_SIGPGP);
/* other stuff we don't need - msw */
headerRemoveEntry(h, RPMTAG_PACKAGER);
headerRemoveEntry(h, RPMTAG_LICENSE);
headerRemoveEntry(h, RPMTAG_BUILDTIME);
headerRemoveEntry(h, RPMTAG_BUILDHOST);
headerRemoveEntry(h, RPMTAG_RPMVERSION);
headerRemoveEntry(h, RPMTAG_POSTINPROG);
headerRemoveEntry(h, RPMTAG_POSTUNPROG);
headerRemoveEntry(h, RPMTAG_PREINPROG);
headerRemoveEntry(h, RPMTAG_PREUNPROG);
headerRemoveEntry(h, RPMTAG_COOKIE);
headerRemoveEntry(h, RPMTAG_OPTFLAGS);
headerRemoveEntry(h, RPMTAG_PAYLOADFORMAT);
headerRemoveEntry(h, RPMTAG_PAYLOADCOMPRESSOR);
headerRemoveEntry(h, RPMTAG_PAYLOADFLAGS);
headerAddEntry(h, FILENAME_TAG, RPM_STRING_TYPE, ent->d_name, 1);
headerAddEntry(h, FILESIZE_TAG, RPM_INT32_TYPE,
&size, 1);
/* Recaclulate the package size based on a 4k block size */
if (headerGetEntry(h, RPMTAG_FILESIZES, NULL,
(void **) &fileSizes, &fileCount)) {
int fileNum;
int newSize = 0;
int * p;
for (fileNum = 0; fileNum < fileCount; fileNum++)
newSize += ((fileSizes[fileNum] + 4093) / 4096) * 4096;
headerGetEntry(h, RPMTAG_SIZE, NULL, (void **) &p, NULL);
headerRemoveEntry(h, RPMTAG_SIZE);
headerAddEntry(h, RPMTAG_SIZE, RPM_INT32_TYPE,
&newSize, 1);
}
if (cdNum > -1)
headerAddEntry(h, CDNUM_TAG, RPM_INT32_TYPE,
&cdNum, 1);
if ((order = getOrder (ent->d_name)) > -1) {
headerAddEntry(h, ORDER_TAG, RPM_INT32_TYPE,
&order, 1);
}
expandFilelist(h);
newFileList = NULL;
if (headerGetEntry(h, RPMTAG_OLDFILENAMES, NULL,
(void **) &fileNames, &fileCount)) {
headerGetEntry(h, RPMTAG_FILEFLAGS, NULL,
(void **) &fileFlags, NULL);
newFileList = malloc(sizeof(*newFileList) * fileCount);
newFileFlags = malloc(sizeof(*newFileList) * fileCount);
newFileListCount = 0;
for (i = 0; i < fileCount; i++) {
if (htInTable(requireTable, fileNames[i], ".")) {
newFileList[newFileListCount] = strdup(fileNames[i]);
newFileFlags[newFileListCount] = fileFlags[i];
newFileListCount++;
}
}
if (!newFileListCount) {
free(newFileList);
free(newFileFlags);
newFileList = NULL;
}
/* XXX free fileNames */
}
compressFilelist(h);
h2 = headerNew();
for (i = 0; tagsInList2[i] > -1; i++) {
int_32 type, c;
void * p;
if (headerGetEntry(h, tagsInList2[i], &type, &p, &c)) {
headerAddEntry(h2, tagsInList2[i], type, p, c);
headerRemoveEntry(h, tagsInList2[i]);
}
/* XXX need to headerFreeData */
}
if (newFileList) {
headerAddEntry(h, RPMTAG_OLDFILENAMES,
RPM_STRING_ARRAY_TYPE,
newFileList, newFileListCount);
headerAddEntry(h, RPMTAG_FILEFLAGS,
RPM_INT32_TYPE,
&newFileFlags, newFileListCount);
compressFilelist(h);
while (newFileListCount--) {
free(newFileList[newFileListCount]);
}
free(newFileList);
free(newFileFlags);
newFileList = NULL;
}
headerAddEntry(h, MATCHER_TAG, RPM_INT32_TYPE, &marker, 1);
headerAddEntry(h2, MATCHER_TAG, RPM_INT32_TYPE, &marker, 1);
marker++;
nh = headerCopy (h);
headerWrite(outfd, nh, HEADER_MAGIC_YES);
headerWrite(out2fd, h2, HEADER_MAGIC_YES);
headerFree(h);
headerFree(nh);
headerFree(h2);
}
Fclose(fd);
}
errno = 0;
ent = readdir(dir);
if (errno) {
perror("readdir");
return 1;
}
}
closedir(dir);
return 0;
}
static void usage(void) {
fprintf(stderr, "genhdlist: genhdlist [--withnumbers] [--fileorder <path>] [--hdlist <path>] <paths>+\n");
exit(1);
}
int main(int argc, const char ** argv) {
char buf[300];
FD_t outfd, out2fd;
int cdNum = -1;
const char ** args;
int doNumber = 0;
int rc;
int i;
char * hdListFile = NULL;
char * hdListFile2 = NULL;
char * depOrderFile = NULL;
poptContext optCon;
struct poptOption options[] = {
{ "hdlist", '\0', POPT_ARG_STRING, &hdListFile, 0 },
{ "withnumbers", '\0', 0, &doNumber, 0 },
{ "fileorder", '\0', POPT_ARG_STRING, &depOrderFile, 0 },
{ 0, 0, 0, 0, 0 }
};
optCon = poptGetContext("genhdlist", argc, argv, options, 0);
poptReadDefaultConfig(optCon, 1);
if ((rc = poptGetNextOpt(optCon)) < -1) {
fprintf(stderr, "%s: bad argument %s: %s\n", "genhdlist",
poptBadOption(optCon, POPT_BADOPTION_NOALIAS),
poptStrerror(rc));
return 1;
}
args = poptGetArgs(optCon);
if (!args || !args[0] || !args[0][0])
usage();
if (depOrderFile) {
FILE *f;
int nalloced = 0;
int numpkgs = 0;
int len = 0;
char b[80];
if (!(f = fopen(depOrderFile, "r"))) {
fprintf (stderr, "Unable to read %s\n", depOrderFile);
usage();
}
while ((fgets(b, sizeof(b) - 1, f))) {
if (numpkgs == nalloced) {
depOrder = realloc (depOrder, sizeof (char *) * (nalloced + 6));
memset (depOrder + numpkgs, '\0', sizeof (char *) * 6);
nalloced += 5;
}
len = strlen(b);
/* chop */
b[--len] = '\0';
/* sanity check */
/* should have the format of a <package name>-<version>-<release> */
if (sanityCheckDepOrderLine(b)) {
fprintf(stderr, "genhdlist: FATAL ERROR -> \"%s\" is not a package name!!\n",b);
fprintf(stderr, "Your package list file %s is most likely CORRUPT!\n", depOrderFile);
exit(1);
}
depOrder[numpkgs] = malloc (len + 1);
strcpy (depOrder[numpkgs], b);
numpkgs++;
}
depOrder[numpkgs] = NULL; /* end with a null */
}
requireTable = htNewTable(1000);
if (!hdListFile) {
strcpy(buf, args[0]);
strcat(buf, "/RedHat/base/hdlist");
hdListFile = buf;
}
unlink(hdListFile);
hdListFile2 = malloc(strlen(hdListFile) + 2);
sprintf(hdListFile2, "%s2", hdListFile);
unlink (hdListFile);
unlink (hdListFile2);
outfd = Fopen(hdListFile, "w");
if (!outfd) {
fprintf(stderr,"error creating file %s: %s\n", hdListFile,
strerror(errno));
return 1;
}
out2fd = Fopen(hdListFile2, "w");
if (!out2fd) {
fprintf(stderr,"error creating file %s: %s\n", hdListFile2,
strerror(errno));
return 1;
}
if (doNumber)
cdNum = 1;
/* if (args > 1 && !doNumber) { */
/* fprintf(stderr, "error: building hdlist for multiple trees without numbers\n"); */
/* exit(1); */
/* } */
i = 0;
while (args[i]) {
if (onePrePass(args[i]))
return 1;
i++;
}
i = 0;
while (args[i]) {
if (onePass(outfd, out2fd, args[i], cdNum))
return 1;
if (doNumber) cdNum++;
i++;
}
Fclose(outfd);
Fclose(out2fd);
poptFreeContext(optCon);
qsort(pkgList, pkgListItems, sizeof(*pkgList), pkgInfoCmp);
rc = 0;
for (i = 1; i < pkgListItems; i++) {
if (!pkgInfoCmp(pkgList + i - 1, pkgList + i)) {
fprintf(stderr, "duplicate package for %s on %s\n",
pkgList[i].name, pkgList[i].arch);
rc = 1;
}
}
return rc;
}
Reference in New Issue View Git Blame Copy Permalink