rpmRC rpmReadHeader(rpmts ts, FD_t fd, Header *hdrp, char ** msg)
{
rpmRC rc;
rpmKeyring keyring = rpmtsGetKeyring(ts, 1);
rpmVSFlags vsflags = rpmtsVSFlags(ts);
rc = rpmpkgReadHeader(keyring, vsflags, fd, hdrp, msg);
rpmKeyringFree(keyring);
return rc;
}
rpmRC rpmReadPackageFile(rpmts ts, FD_t fd, const char * fn, Header * hdrp)
{
rpmRC rc;
rpmVSFlags vsflags = rpmtsVSFlags(ts);
rpmKeyring keyring = rpmtsGetKeyring(ts, 1);
rc = rpmpkgRead(keyring, vsflags, fd, fn, hdrp);
rpmKeyringFree(keyring);
return rc;
}
rpmRC headerCheck(rpmts ts, const void * uh, size_t uc, char ** msg)
{
rpmRC rc;
rpmVSFlags vsflags = rpmtsVSFlags(ts);
rpmKeyring keyring = rpmtsGetKeyring(ts, 1);
rpmswEnter(rpmtsOp(ts, RPMTS_OP_DIGEST), 0);
rc = headerVerify(keyring, vsflags, uh, uc, msg);
rpmswExit(rpmtsOp(ts, RPMTS_OP_DIGEST), uc);
rpmKeyringFree(keyring);
return rc;
}
static void loadKeyring(rpmts ts)
{
/* Never load the keyring if signature checking is disabled */
if ((rpmtsVSFlags(ts) & _RPMVSF_NOSIGNATURES) != _RPMVSF_NOSIGNATURES) {
ts->keyring = rpmKeyringNew();
if (loadKeyringFromFiles(ts) == 0) {
if (loadKeyringFromDB(ts) > 0) {
/* XXX make this a warning someday... */
rpmlog(RPMLOG_DEBUG, "Using legacy gpg-pubkey(s) from rpmdb\n");
}
}
}
}
rpmRC rpmtsImportPubkey(const rpmts ts, const unsigned char * pkt, size_t pktlen)
{
Header h = NULL;
rpmRC rc = RPMRC_FAIL; /* assume failure */
rpmPubkey pubkey = NULL;
rpmVSFlags oflags = rpmtsVSFlags(ts);
rpmKeyring keyring;
rpmtxn txn = rpmtxnBegin(ts, RPMTXN_WRITE);
int krc;
if (txn == NULL)
return rc;
/* XXX keyring wont load if sigcheck disabled, force it temporarily */
rpmtsSetVSFlags(ts, (oflags & ~_RPMVSF_NOSIGNATURES));
keyring = rpmtsGetKeyring(ts, 1);
rpmtsSetVSFlags(ts, oflags);
if ((pubkey = rpmPubkeyNew(pkt, pktlen)) == NULL)
goto exit;
krc = rpmKeyringAddKey(keyring, pubkey);
if (krc < 0)
goto exit;
/* If we dont already have the key, make a persistent record of it */
if (krc == 0) {
rpm_tid_t tid = rpmtsGetTid(ts);
if (makePubkeyHeader(ts, pubkey, &h) != 0)
goto exit;
headerPutUint32(h, RPMTAG_INSTALLTIME, &tid, 1);
headerPutUint32(h, RPMTAG_INSTALLTID, &tid, 1);
/* Add header to database. */
if (!(rpmtsFlags(ts) & RPMTRANS_FLAG_TEST)) {
rc = rpmtsImportHeader(txn, h, 0);
}
}
rc = RPMRC_OK;
exit:
/* Clean up. */
headerFree(h);
rpmPubkeyFree(pubkey);
rpmKeyringFree(keyring);
rpmtxnEnd(txn);
return rc;
}
int rpmInstallSource(rpmts ts, const char * arg,
char ** specFilePtr, char ** cookie)
{
FD_t fd;
int rc;
fd = Fopen(arg, "r.ufdio");
if (fd == NULL || Ferror(fd)) {
rpmlog(RPMLOG_ERR, _("cannot open %s: %s\n"), arg, Fstrerror(fd));
if (fd != NULL) (void) Fclose(fd);
return 1;
}
if (rpmIsVerbose() && specFilePtr != NULL)
fprintf(stdout, _("Installing %s\n"), arg);
{
rpmVSFlags ovsflags =
rpmtsSetVSFlags(ts, (specFilePtr) ? (rpmtsVSFlags(ts) | RPMVSF_NEEDPAYLOAD) : rpmtsVSFlags(ts));
rpmRC rpmrc = rpmInstallSourcePackage(ts, fd, specFilePtr, cookie);
rc = (rpmrc == RPMRC_OK ? 0 : 1);
rpmtsSetVSFlags(ts, ovsflags);
}
if (rc != 0) {
rpmlog(RPMLOG_ERR, _("%s cannot be installed\n"), arg);
if (specFilePtr && *specFilePtr)
*specFilePtr = _free(*specFilePtr);
if (cookie && *cookie)
*cookie = _free(*cookie);
}
(void) Fclose(fd);
return rc;
}
rpmRC rpmReadPackageFile(rpmts ts, FD_t fd, const char * fn, Header * hdrp)
{
rpmRC rc;
rpmVSFlags vsflags = rpmtsVSFlags(ts);
rpmKeyring keyring = 0;
if ((vsflags & _RPMVSF_NOSIGNATURES) != _RPMVSF_NOSIGNATURES)
keyring = rpmtsGetKeyring(ts, 1);
rc = rpmpkgRead(keyring, vsflags, fd, fn, hdrp);
if (keyring)
rpmKeyringFree(keyring);
return rc;
}
rpmRC headerCheck(rpmts ts, const void * uh, size_t uc, char ** msg)
{
rpmRC rc = RPMRC_FAIL;
rpmVSFlags vsflags = rpmtsVSFlags(ts);
rpmKeyring keyring = rpmtsGetKeyring(ts, 1);
struct hdrblob_s blob;
if (hdrblobInit(uh, uc, 0, 0, &blob, msg) == RPMRC_OK) {
rpmswEnter(rpmtsOp(ts, RPMTS_OP_DIGEST), 0);
rc = headerSigVerify(keyring, vsflags, &blob, msg);
rpmswExit(rpmtsOp(ts, RPMTS_OP_DIGEST), uc);
if (rc == RPMRC_NOTFOUND && msg != NULL && *msg == NULL)
rasprintf(msg, "Header sanity check: OK");
}
rpmKeyringFree(keyring);
return rc;
}
rpmRC rpmReadPackageFile(rpmts ts, FD_t fd, const char * fn, Header * hdrp)
{
rpmRC rc;
rpmVSFlags vsflags = rpmtsVSFlags(ts);
rpmKeyring keyring = rpmtsGetKeyring(ts, 1);
unsigned int keyid = 0;
char *msg = NULL;
if (fn == NULL)
fn = Fdescr(fd);
rc = rpmpkgRead(keyring, vsflags, fd, hdrp, &keyid, &msg);
switch (rc) {
case RPMRC_OK: /* Signature is OK. */
rpmlog(RPMLOG_DEBUG, "%s: %s\n", fn, msg);
break;
case RPMRC_NOTTRUSTED: /* Signature is OK, but key is not trusted. */
case RPMRC_NOKEY: /* Public key is unavailable. */
/* XXX Print NOKEY/NOTTRUSTED warning only once. */
{ int lvl = (stashKeyid(keyid) ? RPMLOG_DEBUG : RPMLOG_WARNING);
rpmlog(lvl, "%s: %s\n", fn, msg);
} break;
case RPMRC_NOTFOUND: /* Signature is unknown type or manifest. */
/* msg == NULL is probably a manifest */
if (msg)
rpmlog(RPMLOG_WARNING, "%s: %s\n", fn, msg);
break;
default:
case RPMRC_FAIL: /* Signature does not verify. */
rpmlog(RPMLOG_ERR, "%s: %s\n", fn, msg);
break;
}
rpmKeyringFree(keyring);
free(msg);
return rc;
}
static PyObject *rpmts_get_vsflags(rpmtsObject *s, void *closure)
{
return Py_BuildValue("i", rpmtsVSFlags(s->ts));
}
static JSBool
rpmts_getprop(JSContext *cx, JSObject *obj, jsval id, jsval *vp)
{
void * ptr = JS_GetInstancePrivate(cx, obj, &rpmtsClass, NULL);
rpmts ts = ptr;
jsint tiny = JSVAL_TO_INT(id);
_PROP_DEBUG_ENTRY(_debug < 0);
/* XXX the class has ptr == NULL, instances have ptr != NULL. */
if (ptr == NULL)
return JS_TRUE;
switch (tiny) {
case _DEBUG:
*vp = INT_TO_JSVAL(_debug);
break;
case _LENGTH:
*vp = INT_TO_JSVAL(rpmtsNElements(ts));
break;
case _VSFLAGS:
*vp = INT_TO_JSVAL((jsint)rpmtsVSFlags(ts));
break;
case _TYPE:
*vp = INT_TO_JSVAL((jsint)rpmtsType(ts));
break;
case _ARBGOAL:
*vp = INT_TO_JSVAL((jsint)rpmtsARBGoal(ts));
break;
case _ROOTDIR:
*vp = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, rpmtsRootDir(ts)));
break;
case _CURRDIR:
*vp = STRING_TO_JSVAL(JS_NewStringCopyZ(cx, rpmtsCurrDir(ts)));
break;
case _SELINUX:
*vp = INT_TO_JSVAL((jsint)rpmtsSELinuxEnabled(ts));
break;
case _CHROOTDONE:
*vp = INT_TO_JSVAL((jsint)rpmtsChrootDone(ts));
break;
case _TID:
*vp = INT_TO_JSVAL((jsint)rpmtsGetTid(ts));
break;
case _NELEMENTS:
*vp = INT_TO_JSVAL((jsint)rpmtsNElements(ts));
break;
case _PROBFILTER:
*vp = INT_TO_JSVAL((jsint)rpmtsFilterFlags(ts));
break;
case _FLAGS:
*vp = INT_TO_JSVAL((jsint)rpmtsFlags(ts));
break;
case _DFLAGS:
*vp = INT_TO_JSVAL((jsint)rpmtsDFlags(ts));
break;
case _GOAL:
*vp = INT_TO_JSVAL((jsint)rpmtsGoal(ts));
break;
case _DBMODE:
*vp = INT_TO_JSVAL((jsint)rpmtsDBMode(ts));
break;
case _COLOR:
*vp = INT_TO_JSVAL((jsint)rpmtsColor(ts));
break;
case _PREFCOLOR:
*vp = INT_TO_JSVAL((jsint)rpmtsPrefColor(ts));
break;
default:
if (JSVAL_IS_INT(id)) {
int oc = JSVAL_TO_INT(id);
JSObject *teo = NULL;
rpmte te = NULL;
/* XXX rpmteLink/rpmteUnlink are no-ops */
if ((te = rpmtsElement(ts, oc)) != NULL
&& (teo = JS_NewObject(cx, &rpmteClass, NULL, NULL)) != NULL
&& JS_SetPrivate(cx, teo, rpmteLink(te)))
{
*vp = OBJECT_TO_JSVAL(teo);
}
break;
}
#ifdef DYING
if (JSVAL_IS_STRING(id)) {
JSString * str = JS_ValueToString(cx, id);
const char * name = JS_GetStringBytes(str);
if (!strcmp(name, "NVRA")) {
JSObject * NVRA = rpmtsLoadNVRA(cx, obj);
*vp = OBJECT_TO_JSVAL(NVRA);
}
break;
}
#endif
break;
}
return JS_TRUE;
}
