static int rpm_query_file(rpmts *ts, rpmdbMatchIterator *iter, Header *header, const char *filename, const char *rootdir_or_NULL) { const char *queryname = filename; *ts = rpmtsCreate(); if (rootdir_or_NULL) { if (rpmtsSetRootDir(*ts, rootdir_or_NULL) != 0) { rpmtsFree(*ts); return -1; } unsigned len = strlen(rootdir_or_NULL); /* remove 'chroot' prefix */ if (strncmp(filename, rootdir_or_NULL, len) == 0 && filename[len] == '/') queryname += len; } *iter = rpmtsInitIterator(*ts, RPMTAG_BASENAMES, queryname, 0); *header = rpmdbNextIterator(*iter); if (!(*header) && rootdir_or_NULL) { rpmdbFreeIterator(*iter); rpmtsFree(*ts); return rpm_query_file(ts, iter, header, filename, NULL); } return 0; }
int verifyRpmPackage(char *filename) { int ret = 0; rpmts ts; //rpm transaction FD_t fd; //file descriptor char error[1024]; QVA_t ka = malloc(sizeof(rpmQVKArgs)); memcpy(ka, &rpmQVKArgs, sizeof(rpmQVKArgs)); rpmcliConfigured(); //creating query set rpmVerifyFlags verifyFlags = (VERIFY_MD5|VERIFY_DIGEST); verifyFlags &= ~ka->qva_flags; ka->qva_flags = (rpmQueryFlags) verifyFlags; //error is also used to pass the input file name //dangerous strcpy(error, filename); //trasaction set ts = rpmtsCreate(); //file descriptor fd = Fopen(filename, "r.ufdio"); if (fd == NULL) { logmsg("verifyRpmPackage:Error opening file %s\n", filename); free(ka); return -1; } ret = rpmVerifySignatures(ka, ts, fd, error); if (ret != 0) { //package is corrupted logmsg("verifyRpmPackage:Package corrupted %s\n", error); ts = rpmtsFree(ts); Fclose(fd); free(ka); return -1; } //package is correct return 0 ts = rpmtsFree(ts); Fclose(fd); free(ka); return 0; }
static rpmRC inst(const char *fn) { rpmRC rc = RPMRC_FAIL; rpmts ts = rpmtsCreate(); FD_t fd = Fopen(fn, "r"); Header h = NULL; int upgrade = 1; rpmRelocation relocs = NULL; rpmps ps = NULL; rpmprobFilterFlags probFilter = 0; assert(ts); (void) rpmtsSetNotifyCallback(ts, rpmShowProgress, (void *) ((long)0)); if (fd == NULL || Ferror(fd)) goto exit; (void) rpmReadPackageFile(ts, fd, fn, &h); if ((rc = rpmtsAddInstallElement(ts, h, fn, upgrade, relocs)) != 0 || (rc = rpmcliInstallCheck(ts)) != 0 || (rc = rpmcliInstallOrder(ts)) != 0 || (rc = rpmcliInstallRun(ts, ps, probFilter)) != 0) goto exit; exit: h = headerFree(h); if (fd) (void) Fclose(fd); fd = NULL; ts = rpmtsFree(ts); if (rc) fprintf(stderr, "<== %s(%s) rc %d\n", __FUNCTION__, fn, rc); return rc; }
int main(int argc, char *argv[]) { int rc; xsetprogname(argv[0]); /* Portability call -- see system.h */ rpmReadConfigFiles(NULL, NULL); char * filename; if (argc == 1) filename = "-"; else { if (rstreq(argv[1], "-h") || rstreq(argv[1], "--help")) { fprintf(stderr, "Usage: rpm2archive file.rpm\n"); exit(EXIT_FAILURE); } else { filename = argv[1]; } } rpmts ts = rpmtsCreate(); rpmVSFlags vsflags = 0; /* XXX retain the ageless behavior of rpm2cpio */ vsflags |= _RPMVSF_NODIGESTS; vsflags |= _RPMVSF_NOSIGNATURES; vsflags |= RPMVSF_NOHDRCHK; (void) rpmtsSetVSFlags(ts, vsflags); rc = process_package(ts, filename); ts = rpmtsFree(ts); return rc; }
char* rpm_get_component(const char *filename, const char *rootdir_or_NULL) { #ifdef HAVE_LIBRPM char *ret = NULL; char *srpm = NULL; rpmts ts; rpmdbMatchIterator iter; Header header; if (rpm_query_file(&ts, &iter, &header, filename, rootdir_or_NULL) < 0) return NULL; if (!header) goto error; const char *errmsg = NULL; srpm = headerFormat(header, "%{SOURCERPM}", &errmsg); if (!srpm && errmsg) { error_msg("cannot get srpm. reason: %s", errmsg); goto error; } ret = get_package_name_from_NVR_or_NULL(srpm); free(srpm); error: rpmdbFreeIterator(iter); rpmtsFree(ts); return ret; #else return NULL; #endif }
char *rpm_get_fingerprint(const char *pkg) { #ifdef HAVE_LIBRPM char *fingerprint = NULL; char *pgpsig = NULL; const char *errmsg = NULL; rpmts ts = rpmtsCreate(); rpmdbMatchIterator iter = rpmtsInitIterator(ts, RPMTAG_NAME, pkg, 0); Header header = rpmdbNextIterator(iter); if (!header) goto error; pgpsig = headerFormat(header, "%|SIGGPG?{%{SIGGPG:pgpsig}}:{%{SIGPGP:pgpsig}}|", &errmsg); if (!pgpsig && errmsg) { log_notice("cannot get siggpg:pgpsig. reason: %s", errmsg); goto error; } char *pgpsig_tmp = strstr(pgpsig, " Key ID "); if (pgpsig_tmp) fingerprint = xstrdup(pgpsig_tmp + sizeof(" Key ID ") - 1); error: free(pgpsig); rpmdbFreeIterator(iter); rpmtsFree(ts); return fingerprint; #else return NULL; #endif }
static char *rpm_get_nvr_by_pkg_name(const char *pkg_name) { int status = rpmReadConfigFiles((const char *) NULL, (const char *) NULL); if (status) error_msg_and_die("error reading RPM rc files"); char *nvr = NULL; rpmts ts = rpmtsCreate(); rpmdbMatchIterator iter = rpmtsInitIterator(ts, RPMTAG_NAME, pkg_name, 0); Header header = rpmdbNextIterator(iter); if (!header) goto error; const char *errmsg = NULL; nvr = headerFormat(header, "%{name}-%{version}-%{release}", &errmsg); if (!nvr && errmsg) error_msg("cannot get nvr. reason: %s", errmsg); error: rpmdbFreeIterator(iter); rpmtsFree(ts); rpmFreeRpmrc(); rpmFreeCrypto(); rpmFreeMacros(NULL); return nvr; }
/*@-mustmod@*/ static void rpmgiFini(void * _gi) /*@modifies _gi @*/ { rpmgi gi = _gi; int xx; gi->hdrPath = _free(gi->hdrPath); (void)headerFree(gi->h); gi->h = NULL; gi->argv = argvFree(gi->argv); if (gi->ftsp != NULL) { xx = Fts_close(gi->ftsp); gi->ftsp = NULL; gi->fts = NULL; } if (gi->fd != NULL) { xx = Fclose(gi->fd); gi->fd = NULL; } gi->tsi = rpmtsiFree(gi->tsi); gi->mi = rpmmiFree(gi->mi); (void)rpmtsFree(gi->ts); gi->ts = NULL; }
/** * @todo Create transaction set *much* earlier. */ static rpmRC cpio_doio(FD_t fdo, Header h, CSA_t csa, const char * fmodeMacro) { rpmts ts = rpmtsCreate(); rpmfi fi = csa->cpioList; rpmte te = NULL; rpmfs fs = NULL; char *failedFile = NULL; FD_t cfd; rpmRC rc = RPMRC_OK; int xx, i; { char *fmode = rpmExpand(fmodeMacro, NULL); if (!(fmode && fmode[0] == 'w')) fmode = xstrdup("w9.gzdio"); (void) Fflush(fdo); cfd = Fdopen(fdDup(Fileno(fdo)), fmode); fmode = _free(fmode); } if (cfd == NULL) return RPMRC_FAIL; /* make up a transaction element for passing to fsm */ rpmtsAddInstallElement(ts, h, NULL, 0, NULL); te = rpmtsElement(ts, 0); fs = rpmteGetFileStates(te); fi = rpmfiInit(fi, 0); while ((i = rpmfiNext(fi)) >= 0) { if (rpmfiFFlags(fi) & RPMFILE_GHOST) rpmfsSetAction(fs, i, FA_SKIP); else rpmfsSetAction(fs, i, FA_COPYOUT); } xx = fsmSetup(rpmfiFSM(fi), FSM_PKGBUILD, ts, te, fi, cfd, &csa->cpioArchiveSize, &failedFile); if (xx) rc = RPMRC_FAIL; (void) Fclose(cfd); xx = fsmTeardown(rpmfiFSM(fi)); if (rc == RPMRC_OK && xx) rc = RPMRC_FAIL; if (rc) { if (failedFile) rpmlog(RPMLOG_ERR, _("create archive failed on file %s: %s\n"), failedFile, cpioStrerror(rc)); else rpmlog(RPMLOG_ERR, _("create archive failed: %s\n"), cpioStrerror(rc)); rc = RPMRC_FAIL; } rpmtsEmpty(ts); failedFile = _free(failedFile); ts = rpmtsFree(ts); return rc; }
/************************************************************************* * FUNCTION : RPMTransaction_Set::~RPMTransaction_Set * * ARGUMENTS : none * * RETURNS : none * * EXCEPTIONS : none * * PURPOSE : Destroy an RPM transaction set * *************************************************************************/ RPMTransaction_Set::~RPMTransaction_Set() { // Free any RPM headers we have created to hand to the transaction list if (header_list) Tcl_DecrRefCount(header_list); header_list = 0; rpmtsFree(transaction); }
rpmtxn rpmtxnEnd(rpmtxn txn) { if (txn) { rpmlockRelease(txn->lock); rpmtsFree(txn->ts); free(txn); } return NULL; }
rpmtsi rpmtsiFree(rpmtsi tsi) { /* XXX watchout: a funky recursion segfaults here iff nrefs is wrong. */ if (tsi) { tsi->ts = rpmtsFree(tsi->ts); _free(tsi); } return NULL; }
static void rpmts_dtor(JSContext *cx, JSObject *obj) { void * ptr = JS_GetInstancePrivate(cx, obj, &rpmtsClass, NULL); rpmts ts = ptr; _DTOR_DEBUG_ENTRY(_debug); (void) rpmtsFree(ts); }
static rpmpsm rpmpsmFree(rpmpsm psm) { if (psm) { rpmfilesFree(psm->files); rpmtsFree(psm->ts), /* XXX rpmte not refcounted yet */ memset(psm, 0, sizeof(*psm)); /* XXX trash and burn */ free(psm); } return NULL; }
int main(int argc, char *argv[]) { rpmts ts = NULL; enum modes bigMode = MODE_INSTALL; struct rpmInstallArguments_s *ia = &rpmIArgs; poptContext optCon; int ec = 0; int ret = 0; char rpmFile[1][PATH_MAX]; memset(&rpmFile,0,PATH_MAX); snprintf(rpmFile[0],PATH_MAX,"%s",argv[1]); char *p[2]; p[0] = ""; p[1] = (char *)&rpmFile[0]; optCon = rpmcliInit(2, p, optionsTable); printf("\n argc[%d],bigmode[%s]\n",argc,bigMode == MODE_UNKNOWN?"unknow":"others"); ia->installInterfaceFlags = INSTALL_INSTALL | INSTALL_LABEL | INSTALL_PERCENT; ts = rpmtsCreate(); rpmtsSetRootDir(ts, rpmcliRootDir); if (!ia->incldocs) { if (rpmExpandNumeric("%{_excludedocs}")) ia->transFlags |= RPMTRANS_FLAG_NODOCS; } if (ia->noDeps) ia->installInterfaceFlags |= INSTALL_NODEPS; if (ia->prefix) { ia->relocations = malloc(2 * sizeof(*ia->relocations)); ia->relocations[0].oldPath = NULL; /* special case magic */ ia->relocations[0].newPath = ia->prefix; ia->relocations[1].oldPath = NULL; ia->relocations[1].newPath = NULL; } else if (ia->relocations) { ia->relocations = realloc(ia->relocations, sizeof(*ia->relocations) * (ia->numRelocations + 1)); ia->relocations[ia->numRelocations].oldPath = NULL; ia->relocations[ia->numRelocations].newPath = NULL; } ret= rpmInstall(ts, ia, (ARGV_t) poptGetArgs(optCon)); printf("\n ret[%d]\n",ret); rpmtsFree(ts); ts = NULL; rpmcliFini(optCon); return 0; }
rpmRC rpmReadPackageInfo(FD_t fd, Header * sigp, Header * hdrp) { rpmRC rc; rpmts ts = rpmtsCreate(); rc = rpmReadPackageFile(ts, fd, "readRPM", hdrp); ts = rpmtsFree(ts); if (sigp) *sigp = NULL; /* XXX HACK */ return rc; }
QueryData genRpmPackages(QueryContext& context) { QueryData results; auto dropper = DropPrivileges::get(); if (!dropper->dropTo("nobody") && isUserAdmin()) { LOG(WARNING) << "Cannot drop privileges for rpm_packages"; return results; } // Isolate RPM/package inspection to the canonical: /usr/lib/rpm. RpmEnvironmentManager env_manager; // The following implementation uses http://rpm.org/api/4.11.1/ rpmInitCrypto(); if (rpmReadConfigFiles(nullptr, nullptr) != 0) { TLOG << "Cannot read RPM configuration files"; return results; } rpmts ts = rpmtsCreate(); rpmdbMatchIterator matches; if (context.constraints["name"].exists(EQUALS)) { auto name = (*context.constraints["name"].getAll(EQUALS).begin()); matches = rpmtsInitIterator(ts, RPMTAG_NAME, name.c_str(), name.size()); } else { matches = rpmtsInitIterator(ts, RPMTAG_NAME, nullptr, 0); } Header header; while ((header = rpmdbNextIterator(matches)) != nullptr) { Row r; rpmtd td = rpmtdNew(); r["name"] = getRpmAttribute(header, RPMTAG_NAME, td); r["version"] = getRpmAttribute(header, RPMTAG_VERSION, td); r["release"] = getRpmAttribute(header, RPMTAG_RELEASE, td); r["source"] = getRpmAttribute(header, RPMTAG_SOURCERPM, td); r["size"] = getRpmAttribute(header, RPMTAG_SIZE, td); r["sha1"] = getRpmAttribute(header, RPMTAG_SHA1HEADER, td); r["arch"] = getRpmAttribute(header, RPMTAG_ARCH, td); rpmtdFree(td); results.push_back(r); } rpmdbFreeIterator(matches); rpmtsFree(ts); rpmFreeCrypto(); rpmFreeRpmrc(); return results; }
/* --- Object ctors/dtors */ static rpmts rpmts_init(JSContext *cx, JSObject *obj) { rpmts ts; if ((ts = rpmtsCreate()) == NULL) return NULL; if (!JS_SetPrivate(cx, obj, (void *)ts)) { /* XXX error msg */ (void) rpmtsFree(ts); return NULL; } return ts; }
void End_HR_SWInst(void) { SWI_t *swi = &_myswi; /* XXX static for now */ #ifdef HAVE_LIBRPM rpmtsFree(swi->swi_rpmts); /* or only on finishing ? */ swi->swi_rpmts = NULL; #else if (swi->swi_dp != NULL) closedir(swi->swi_dp); swi->swi_dp = NULL; #endif }
static void transaction_free(rpm_trans_t* trans) { if (trans->script_fd) Fclose(trans->script_fd); #if RPM_VERSION_CODE < RPM_VERSION(4,1,0) rpmtransFree(trans->ts); #else rpmtsFree(trans->ts); #endif #if RPM_VERSION_CODE < RPM_VERSION(4,9,0) || RPM_VERSION_CODE >= RPM_VERSION(5,0,0) db_unref(trans->db); #endif free(trans); }
void probe_fini (void *ptr) { struct rpm_probe_global *r = (struct rpm_probe_global *)ptr; rpmFreeCrypto(); rpmFreeRpmrc(); rpmFreeMacros(NULL); rpmlogClose(); // If probe_init() failed r->rpmts and r->mutex were not initialized if (r == NULL) return; rpmtsFree(r->rpmts); pthread_mutex_destroy (&(r->mutex)); return; }
int main(int argc, char *argv[]) { poptContext optCon = rpmcliInit(argc, argv, optionsTable); rpmts ts = rpmtsCreate(); int rc = rpmtsOpenDB(ts, O_RDONLY); fprintf(stderr, " DSA"); rc = doit(ts, "DSA"); fprintf(stderr, " RSA"); rc = doit(ts, "RSA"); fprintf(stderr, "\n"); (void) rpmtsFree(ts); ts = NULL; optCon = rpmcliFini(optCon); return rc; }
QueryData genRpmPackages(QueryContext& context) { QueryData results; // The following implementation uses http://rpm.org/api/4.11.1/ rpmInitCrypto(); if (rpmReadConfigFiles(nullptr, nullptr) != 0) { TLOG << "Cannot read RPM configuration files."; return results; } rpmts ts = rpmtsCreate(); rpmdbMatchIterator matches; if (context.constraints["name"].exists()) { auto name = (*context.constraints["name"].getAll(EQUALS).begin()); matches = rpmtsInitIterator(ts, RPMTAG_NAME, name.c_str(), name.size()); } else { matches = rpmtsInitIterator(ts, RPMTAG_NAME, nullptr, 0); } Header header; while ((header = rpmdbNextIterator(matches)) != nullptr) { Row r; rpmtd td = rpmtdNew(); r["name"] = getRpmAttribute(header, RPMTAG_NAME, td); r["version"] = getRpmAttribute(header, RPMTAG_VERSION, td); r["release"] = getRpmAttribute(header, RPMTAG_RELEASE, td); r["source"] = getRpmAttribute(header, RPMTAG_SOURCERPM, td); r["size"] = getRpmAttribute(header, RPMTAG_SIZE, td); r["sha1"] = getRpmAttribute(header, RPMTAG_SHA1HEADER, td); r["arch"] = getRpmAttribute(header, RPMTAG_ARCH, td); rpmtdFree(td); results.push_back(r); } rpmdbFreeIterator(matches); rpmtsFree(ts); rpmFreeCrypto(); rpmFreeRpmrc(); return results; }
int main(int argc, char *argv[]) { int ec = EXIT_FAILURE; poptContext optCon = rpmcliInit(argc, argv, optionsTable); rpmts ts = rpmtsCreate(); ARGV_const_t args = NULL; if (argc < 2) { printUsage(optCon, stderr, 0); goto exit; } args = (ARGV_const_t) poptGetArgs(optCon); if (mode != MODE_LISTKEY && args == NULL) argerror(_("no arguments given")); rpmtsSetRootDir(ts, rpmcliRootDir); switch (mode) { case MODE_CHECKSIG: ec = rpmcliVerifySignatures(ts, args); break; case MODE_IMPORTKEY: ec = rpmcliImportPubkeys(ts, args); break; /* XXX TODO: actually implement these... */ case MODE_DELKEY: case MODE_LISTKEY: break; default: argerror(_("only one major mode may be specified")); } exit: rpmtsFree(ts); rpmcliFini(optCon); return ec; }
string_list * rpm_file_list(const char * pkg) { rpmReadConfigFiles(NULL, NULL); FD_t fd = Fopen(pkg, "r.ufdio"); rpmts ts = rpmtsCreate(); Header h; rpmReadPackageFile(ts, fd, NULL, &h); rpmtsFree(ts); string_list * sl = string_list_new(); rpmfi fi = rpmfiNew(NULL, h, RPMTAG_BASENAMES, RPMFI_KEEPHEADER); if (fi) { while (rpmfiNext(fi) != -1) { string_list_append(sl, rpmfiFN(fi)); } fi = rpmfiFree(fi); } return sl; }
uint32_t VerifyRpmSig( rpmKeyring pKeyring, const char* pszPkgFile ) { uint32_t dwError = 0; FD_t pFD_t = NULL; rpmts pTS = NULL; rpmtd pTD = NULL; Header pPkgHeader = NULL; pgpDig pDigest = NULL; if(!pKeyring || IsNullOrEmptyString(pszPkgFile)) { dwError = ERROR_TDNF_INVALID_PARAMETER; BAIL_ON_TDNF_ERROR(dwError); } pFD_t = Fopen(pszPkgFile, "r.fdio"); if(!pFD_t) { dwError = errno; BAIL_ON_TDNF_SYSTEM_ERROR(dwError); } pTS = rpmtsCreate(); if(!pTS) { dwError = ERROR_TDNF_RPMTS_CREATE_FAILED; BAIL_ON_TDNF_RPM_ERROR(dwError); } rpmtsSetVSFlags (pTS, _RPMVSF_NOSIGNATURES); pTD = rpmtdNew(); if(!pTD) { dwError = ERROR_TDNF_RPMTD_CREATE_FAILED; BAIL_ON_TDNF_RPM_ERROR(dwError); } dwError = rpmReadPackageFile(pTS, pFD_t, pszPkgFile, &pPkgHeader); BAIL_ON_TDNF_RPM_ERROR(dwError); if(!headerConvert(pPkgHeader, HEADERCONV_RETROFIT_V3)) { dwError = ERROR_TDNF_RPM_HEADER_CONVERT_FAILED; BAIL_ON_TDNF_RPM_ERROR(dwError); } if(!headerGet(pPkgHeader, RPMTAG_RSAHEADER, pTD, HEADERGET_MINMEM)) { dwError = ERROR_TDNF_RPM_GET_RSAHEADER_FAILED; BAIL_ON_TDNF_ERROR(dwError); } pDigest = pgpNewDig(); if(pgpPrtPkts(pTD->data, pTD->count, pDigest, 0)) { dwError = ERROR_TDNF_RPM_GPG_PARSE_FAILED; BAIL_ON_TDNF_ERROR(dwError); } if(rpmKeyringLookup(pKeyring, pDigest) != RPMRC_OK) { dwError = ERROR_TDNF_RPM_GPG_NO_MATCH; BAIL_ON_TDNF_ERROR(dwError); } cleanup: if(pFD_t) { Fclose(pFD_t); } if(pDigest) { pgpFreeDig(pDigest); } if(pPkgHeader) { headerFree(pPkgHeader); } if(pTD) { rpmtdFree(pTD); } if(pTS) { rpmtsFree(pTS); } return dwError; error: goto cleanup; }
/* --------------------------------------------------------------------- */ int netsnmp_swinst_arch_load( netsnmp_container *container, u_int flags) { rpmts ts; rpmdbMatchIterator mi; Header h; char *n, *v, *r, *g; int32_t *t; time_t install_time; size_t date_len; int i = 1; netsnmp_swinst_entry *entry; ts = rpmtsCreate(); rpmtsSetVSFlags( ts, (_RPMVSF_NOSIGNATURES|_RPMVSF_NODIGESTS)); mi = rpmtsInitIterator( ts, RPMDBI_PACKAGES, NULL, 0); if (mi == NULL) NETSNMP_LOGONCE((LOG_ERR, "rpmdbOpen() failed\n")); while (NULL != (h = rpmdbNextIterator( mi ))) { const u_char *dt; entry = netsnmp_swinst_entry_create( i++ ); if (NULL == entry) continue; /* error already logged by function */ CONTAINER_INSERT(container, entry); h = headerLink( h ); headerGetEntry( h, RPMTAG_NAME, NULL, (void**)&n, NULL); headerGetEntry( h, RPMTAG_VERSION, NULL, (void**)&v, NULL); headerGetEntry( h, RPMTAG_RELEASE, NULL, (void**)&r, NULL); headerGetEntry( h, RPMTAG_GROUP, NULL, (void**)&g, NULL); headerGetEntry( h, RPMTAG_INSTALLTIME, NULL, (void**)&t, NULL); entry->swName_len = snprintf( entry->swName, sizeof(entry->swName), "%s-%s-%s", n, v, r); if (entry->swName_len > sizeof(entry->swName)) entry->swName_len = sizeof(entry->swName); entry->swType = (NULL != strstr( g, "System Environment")) ? 2 /* operatingSystem */ : 4; /* application */ install_time = *t; dt = date_n_time( &install_time, &date_len ); if (date_len != 8 && date_len != 11) { snmp_log(LOG_ERR, "Bogus length from date_n_time for %s", entry->swName); entry->swDate_len = 0; } else { entry->swDate_len = date_len; memcpy(entry->swDate, dt, entry->swDate_len); } headerFree( h ); } rpmdbFreeIterator( mi ); rpmtsFree( ts ); DEBUGMSGTL(("swinst:load:arch", "loaded %d entries\n", (int)CONTAINER_SIZE(container))); return 0; }
/* * explode source RPM into the current directory * use filters to skip packages and files we do not need */ int explodeRPM(const char *source, filterfunc filter, dependencyfunc provides, dependencyfunc deps, void* userptr) { char buffer[BUFFERSIZE+1]; /* make space for trailing \0 */ FD_t fdi; Header h; char * rpmio_flags = NULL; rpmRC rc; FD_t gzdi; struct archive *cpio; struct archive_entry *cpio_entry; struct cpio_mydata cpio_mydata; rpmts ts; rpmVSFlags vsflags; const char *compr; if (strcmp(source, "-") == 0) fdi = fdDup(STDIN_FILENO); else fdi = Fopen(source, "r.ufdio"); if (Ferror(fdi)) { const char *srcname = (strcmp(source, "-") == 0) ? "<stdin>" : source; logMessage(ERROR, "%s: %s\n", srcname, Fstrerror(fdi)); return EXIT_FAILURE; } rpmReadConfigFiles(NULL, NULL); /* Initialize RPM transaction */ ts = rpmtsCreate(); vsflags = 0; /* Do not check digests, signatures or headers */ vsflags |= _RPMVSF_NODIGESTS; vsflags |= _RPMVSF_NOSIGNATURES; vsflags |= RPMVSF_NOHDRCHK; (void) rpmtsSetVSFlags(ts, vsflags); rc = rpmReadPackageFile(ts, fdi, "rpm2dir", &h); ts = rpmtsFree(ts); switch (rc) { case RPMRC_OK: case RPMRC_NOKEY: case RPMRC_NOTTRUSTED: break; case RPMRC_NOTFOUND: logMessage(ERROR, "%s is not an RPM package", source); return EXIT_FAILURE; break; case RPMRC_FAIL: default: logMessage(ERROR, "error reading header from %s package\n", source); return EXIT_FAILURE; break; } /* Retrieve all dependencies and run them through deps function */ while (deps) { struct rpmtd_s td; const char *depname; if (!headerGet(h, RPMTAG_REQUIRENAME, &td, HEADERGET_MINMEM)) break; /* iterator */ while ((depname = rpmtdNextString(&td))) { if (deps(depname, userptr)) { Fclose(fdi); return EXIT_BADDEPS; } } rpmtdFreeData(&td); break; } /* Retrieve all provides and run them through provides function */ while (provides) { struct rpmtd_s td; const char *depname; int found = 0; if (!headerGet(h, RPMTAG_PROVIDES, &td, HEADERGET_MINMEM)) break; /* iterator */ while ((depname = rpmtdNextString(&td))) { if (!provides(depname, userptr)) { found++; } } rpmtdFreeData(&td); if (found<=0) return EXIT_BADDEPS; break; } /* Retrieve type of payload compression. */ compr = headerGetString(h, RPMTAG_PAYLOADCOMPRESSOR); if (compr && strcmp(compr, "gzip")) { checked_asprintf(&rpmio_flags, "r.%sdio", compr); } else { checked_asprintf(&rpmio_flags, "r.gzdio"); } /* Open uncompressed cpio stream */ gzdi = Fdopen(fdi, rpmio_flags); free(rpmio_flags); if (gzdi == NULL) { logMessage(ERROR, "cannot re-open payload: %s\n", Fstrerror(gzdi)); return EXIT_FAILURE; } /* initialize cpio decompressor */ cpio = archive_read_new(); if (cpio==NULL) { Fclose(gzdi); return -1; } cpio_mydata.gzdi = gzdi; cpio_mydata.buffer = buffer; archive_read_support_compression_all(cpio); archive_read_support_format_all(cpio); rc = archive_read_open(cpio, &cpio_mydata, NULL, rpm_myread, rpm_myclose); /* check the status of archive_open */ if (rc != ARCHIVE_OK){ Fclose(gzdi); return -1; } /* read all files in cpio archive */ while ((rc = archive_read_next_header(cpio, &cpio_entry)) == ARCHIVE_OK){ const struct stat *fstat; int64_t fsize; const char* filename; int needskip = 1; /* do we need to read the data to get to the next header? */ int offset = 0; int towrite = 0; filename = archive_entry_pathname(cpio_entry); fstat = archive_entry_stat(cpio_entry); fsize = archive_entry_size(cpio_entry); /* Strip leading slashes */ while (filename[offset] == '/') offset+=1; /* Strip leading ./ */ while (filename[offset] == '.' && filename[offset+1] == '/') offset+=2; /* Other file type - we do not care except special cases */ if (!S_ISREG(fstat->st_mode)) towrite = 1; else towrite = 2; if (filter && filter(filename+offset, fstat, userptr)) { /* filter this file */ towrite = 0; } /* Create directories */ char* dirname = strdup(filename+offset); /* If the dup fails, let's hope the dirs already exist */ if (dirname){ char* dirptr = dirname; while (dirptr && *dirptr) { dirptr = strchr(dirptr, '/'); if (dirptr) { *dirptr = 0; mkdir(dirname, 0700); *dirptr = '/'; dirptr++; } } free(dirname); } /* Regular file */ if (towrite>=2) { FILE *fdout = fopen(filename+offset, "w"); if (fdout==NULL){ rc = 33; break; } rc = archive_read_data_into_fd(cpio, fileno(fdout)); if (rc!=ARCHIVE_OK) { /* XXX We didn't get the file.. well.. */ needskip = 0; } else { needskip = 0; fclose(fdout); } } /* symlink, we assume that the path contained in symlink * is shorter than BUFFERSIZE */ while (towrite && S_ISLNK(fstat->st_mode)) { char symlinkbuffer[BUFFERSIZE-1]; needskip = 0; if ((rc = archive_read_data(cpio, symlinkbuffer, fsize))!=ARCHIVE_OK) { /* XXX We didn't get the file.. well.. */ break; } if (symlink(buffer, filename+offset)) { logMessage(ERROR, "Failed to create symlink %s -> %s", filename+offset, buffer); } break; } if(needskip) archive_read_data_skip(cpio); } archive_read_finish(cpio); return rc != ARCHIVE_OK; }
int main(int argc, char *argv[]) { FD_t fdi, fdo; Header h; char * rpmio_flags = NULL; rpmRC rc; FD_t gzdi; setprogname(argv[0]); /* Retrofit glibc __progname */ rpmReadConfigFiles(NULL, NULL); if (argc == 1) fdi = fdDup(STDIN_FILENO); else { if (rstreq(argv[1], "-h") || rstreq(argv[1], "--help")) { fprintf(stderr, "Usage: rpm2cpio file.rpm\n"); exit(EXIT_FAILURE); } fdi = Fopen(argv[1], "r.ufdio"); } if (Ferror(fdi)) { fprintf(stderr, "%s: %s: %s\n", argv[0], (argc == 1 ? "<stdin>" : argv[1]), Fstrerror(fdi)); exit(EXIT_FAILURE); } fdo = fdDup(STDOUT_FILENO); { rpmts ts = rpmtsCreate(); rpmVSFlags vsflags = 0; /* XXX retain the ageless behavior of rpm2cpio */ vsflags |= _RPMVSF_NODIGESTS; vsflags |= _RPMVSF_NOSIGNATURES; vsflags |= RPMVSF_NOHDRCHK; (void) rpmtsSetVSFlags(ts, vsflags); rc = rpmReadPackageFile(ts, fdi, "rpm2cpio", &h); ts = rpmtsFree(ts); } switch (rc) { case RPMRC_OK: case RPMRC_NOKEY: case RPMRC_NOTTRUSTED: break; case RPMRC_NOTFOUND: fprintf(stderr, _("argument is not an RPM package\n")); exit(EXIT_FAILURE); break; case RPMRC_FAIL: default: fprintf(stderr, _("error reading header from package\n")); exit(EXIT_FAILURE); break; } /* Retrieve type of payload compression. */ { const char *compr = headerGetString(h, RPMTAG_PAYLOADCOMPRESSOR); rpmio_flags = rstrscat(NULL, "r.", compr ? compr : "gzip", NULL); } gzdi = Fdopen(fdi, rpmio_flags); /* XXX gzdi == fdi */ free(rpmio_flags); if (gzdi == NULL) { fprintf(stderr, _("cannot re-open payload: %s\n"), Fstrerror(gzdi)); exit(EXIT_FAILURE); } rc = ufdCopy(gzdi, fdo); rc = (rc <= 0) ? EXIT_FAILURE : EXIT_SUCCESS; Fclose(fdo); Fclose(gzdi); /* XXX gzdi == fdi */ return rc; }
int main(int argc, char *argv[]) { rpmts ts = NULL; struct rpmInstallArguments_s *ia = &rpmIArgs; poptContext optCon = NULL; int ec = 0; int ret = 0; char **arg = NULL; arg = malloc(sizeof(char *) * argc); memset(arg, 0, sizeof(char *) * argc); for (int i = 0; i < argc; i++) { arg[i] = malloc(sizeof(char) * PATH_MAX); memset(arg[i], 0, sizeof(char) * PATH_MAX); snprintf(arg[i], strlen(arg[i]) - 1, argv[i]); } optCon = rpmcliInit(argc, arg, optionsTable); ia->installInterfaceFlags = INSTALL_INSTALL | INSTALL_LABEL | INSTALL_PERCENT; ts = rpmtsCreate(); rpmtsSetRootDir(ts, rpmcliRootDir); if (!ia->incldocs) { if (rpmExpandNumeric("%{_excludedocs}")) ia->transFlags |= RPMTRANS_FLAG_NODOCS; } if (ia->noDeps) ia->installInterfaceFlags |= INSTALL_NODEPS; if (ia->prefix) { ia->relocations = malloc(2 * sizeof(*ia->relocations)); ia->relocations[0].oldPath = NULL; /* special case magic */ ia->relocations[0].newPath = ia->prefix; ia->relocations[1].oldPath = NULL; ia->relocations[1].newPath = NULL; } else if (ia->relocations) { ia->relocations = realloc(ia->relocations, sizeof(*ia->relocations) * (ia->numRelocations + 1)); ia->relocations[ia->numRelocations].oldPath = NULL; ia->relocations[ia->numRelocations].newPath = NULL; } rpmInstallISoftApp(ts, ia, (ARGV_t) poptGetArgs(optCon), NULL); rpmtsFree(ts); ts = NULL; rpmcliFini(optCon); optCon = NULL; if (arg) { for (int i = 0; i < argc; i++) { if (arg[i]) { free(arg[i]); arg[i] = NULL; } } free(arg); arg = NULL; } return 0; }