python/rpmmodule.c

Go to the documentation of this file.
00001 
00005 #include "system.h"
00006 
00007 #include <rpmio_internal.h>
00008 #include <rpmcli.h>     /* XXX for rpmCheckSig */
00009 #include <rpmdb.h>
00010 #include <rpmsq.h>
00011 
00012 #include "legacy.h"
00013 #include "misc.h"
00014 #include "header_internal.h"
00015 
00016 #include "header-py.h"
00017 #include "rpmal-py.h"
00018 #include "rpmds-py.h"
00019 #include "rpmfd-py.h"
00020 #include "rpmfts-py.h"
00021 #include "rpmfi-py.h"
00022 #include "rpmmi-py.h"
00023 #include "rpmps-py.h"
00024 #include "rpmrc-py.h"
00025 #include "rpmte-py.h"
00026 #include "rpmts-py.h"
00027 #include "spec-py.h"
00028 
00029 #include "debug.h"
00030 
00031 #ifdef __LCLINT__
00032 #undef  PyObject_HEAD
00033 #define PyObject_HEAD   int _PyObjectHead
00034 #endif
00035 
00040 
00043 PyObject * pyrpmError;
00044 
00047 static PyObject * archScore(PyObject * self, PyObject * args, PyObject * kwds)
00048 {
00049     char * arch;
00050     int score;
00051     char * kwlist[] = {"arch", NULL};
00052 
00053     if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &arch))
00054         return NULL;
00055 
00056     score = rpmMachineScore(RPM_MACHTABLE_INSTARCH, arch);
00057 
00058     return Py_BuildValue("i", score);
00059 }
00060 
00063 static PyObject * signalsCaught(PyObject * self, PyObject * check)
00064 {
00065     PyObject *caught, *o;
00066     int llen;
00067     int signum, i;
00068     sigset_t newMask, oldMask;
00069 
00070     if (!PyList_Check(check)) {
00071         PyErr_SetString(PyExc_TypeError, "list expected");
00072         return NULL;
00073     }
00074 
00075     llen = PyList_Size(check);
00076     caught = PyList_New(0);
00077 
00078     /* block signals while checking for them */
00079     (void) sigfillset(&newMask);
00080     (void) sigprocmask(SIG_BLOCK, &newMask, &oldMask);
00081 
00082     for (i = 0; i < llen; i++) {
00083         o = PyList_GetItem(check, i);
00084         signum = PyInt_AsLong(o);
00085         if (sigismember(&rpmsqCaught, signum)) {
00086             PyList_Append(caught, o);
00087         }
00088     }
00089     (void) sigprocmask(SIG_SETMASK, &oldMask, NULL);
00090 
00091     return caught;
00092 }
00093 
00096 static PyObject * checkSignals(PyObject * self, PyObject * args)
00097 {
00098     if (!PyArg_ParseTuple(args, ":checkSignals")) return NULL;
00099     rpmdbCheckSignals();
00100     Py_INCREF(Py_None);
00101     return Py_None;
00102 }
00103 
00104 
00107 static PyObject * setLogFile (PyObject * self, PyObject * args, PyObject *kwds)
00108 {
00109     PyObject * fop = NULL;
00110     FILE * fp = NULL;
00111     char * kwlist[] = {"fileObject", NULL};
00112 
00113     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:logSetFile", kwlist, &fop))
00114         return NULL;
00115 
00116     if (fop) {
00117         if (!PyFile_Check(fop)) {
00118             PyErr_SetString(pyrpmError, "requires file object");
00119             return NULL;
00120         }
00121         fp = PyFile_AsFile(fop);
00122     }
00123 
00124     (void) rpmlogSetFile(fp);
00125 
00126     Py_INCREF(Py_None);
00127     return (PyObject *) Py_None;
00128 }
00129 
00132 static PyObject *
00133 setVerbosity (PyObject * self, PyObject * args, PyObject *kwds)
00134 {
00135     int level;
00136     char * kwlist[] = {"level", NULL};
00137 
00138     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &level))
00139         return NULL;
00140 
00141     rpmSetVerbosity(level);
00142 
00143     Py_INCREF(Py_None);
00144     return (PyObject *) Py_None;
00145 }
00146 
00149 static PyObject *
00150 setEpochPromote (PyObject * self, PyObject * args, PyObject * kwds)
00151 {
00152     char * kwlist[] = {"promote", NULL};
00153 
00154     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist,
00155             &_rpmds_nopromote))
00156         return NULL;
00157 
00158     Py_INCREF(Py_None);
00159     return (PyObject *) Py_None;
00160 }
00161 
00164 static PyObject * setStats (PyObject * self, PyObject * args, PyObject * kwds)
00165 {
00166     char * kwlist[] = {"stats", NULL};
00167 
00168     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmts_stats))
00169         return NULL;
00170 
00171     Py_INCREF(Py_None);
00172     return (PyObject *) Py_None;
00173 }
00174 
00177 static PyMethodDef rpmModuleMethods[] = {
00178     { "TransactionSet", (PyCFunction) rpmts_Create, METH_VARARGS|METH_KEYWORDS,
00179 "rpm.TransactionSet([rootDir, [db]]) -> ts\n\
00180 - Create a transaction set.\n" },
00181 
00182 #if Py_TPFLAGS_HAVE_ITER        /* XXX backport to python-1.5.2 */
00183     { "newrc", (PyCFunction) rpmrc_Create, METH_VARARGS|METH_KEYWORDS,
00184         NULL },
00185 #endif
00186     { "addMacro", (PyCFunction) rpmrc_AddMacro, METH_VARARGS|METH_KEYWORDS,
00187         NULL },
00188     { "delMacro", (PyCFunction) rpmrc_DelMacro, METH_VARARGS|METH_KEYWORDS,
00189         NULL },
00190 
00191     { "archscore", (PyCFunction) archScore, METH_VARARGS|METH_KEYWORDS,
00192         NULL },
00193 
00194     { "signalsCaught", (PyCFunction) signalsCaught, METH_O, 
00195         NULL },
00196     { "checkSignals", (PyCFunction) checkSignals, METH_VARARGS,
00197         NULL },
00198 
00199     { "headerLoad", (PyCFunction) hdrLoad, METH_VARARGS|METH_KEYWORDS,
00200         NULL },
00201     { "rhnLoad", (PyCFunction) rhnLoad, METH_VARARGS|METH_KEYWORDS,
00202         NULL },
00203     { "mergeHeaderListFromFD", (PyCFunction) rpmMergeHeadersFromFD, METH_VARARGS|METH_KEYWORDS,
00204         NULL },
00205     { "readHeaderListFromFD", (PyCFunction) rpmHeaderFromFD, METH_VARARGS|METH_KEYWORDS,
00206         NULL },
00207     { "readHeaderListFromFile", (PyCFunction) rpmHeaderFromFile, METH_VARARGS|METH_KEYWORDS,
00208         NULL },
00209     { "readHeaderFromFD", (PyCFunction) rpmSingleHeaderFromFD, METH_VARARGS|METH_KEYWORDS,
00210         NULL },
00211 
00212     { "setLogFile", (PyCFunction) setLogFile, METH_VARARGS|METH_KEYWORDS,
00213         NULL },
00214 
00215     { "versionCompare", (PyCFunction) versionCompare, METH_VARARGS|METH_KEYWORDS,
00216         NULL },
00217     { "labelCompare", (PyCFunction) labelCompare, METH_VARARGS|METH_KEYWORDS,
00218         NULL },
00219     { "setVerbosity", (PyCFunction) setVerbosity, METH_VARARGS|METH_KEYWORDS,
00220         NULL },
00221     { "setEpochPromote", (PyCFunction) setEpochPromote, METH_VARARGS|METH_KEYWORDS,
00222         NULL },
00223     { "setStats", (PyCFunction) setStats, METH_VARARGS|METH_KEYWORDS,
00224         NULL },
00225 
00226     { "dsSingle", (PyCFunction) rpmds_Single, METH_VARARGS|METH_KEYWORDS,
00227 "rpm.dsSingle(TagN, N, [EVR, [Flags]] -> ds\n\
00228 - Create a single element dependency set.\n" },
00229     { NULL }
00230 } ;
00231 
00232 /*
00233 * Force clean up of open iterators and dbs on exit.
00234 */
00235 static void rpm_exithook(void)
00236 {
00237    rpmdbCheckTerminate(1);
00238 }
00239 
00242 static char rpm__doc__[] =
00243 "";
00244 
00245 void init_rpm(void);    /* XXX eliminate gcc warning */
00248 void init_rpm(void)
00249 {
00250     PyObject * d, *o, * tag = NULL, * dict;
00251     int i;
00252     const struct headerSprintfExtension_s * extensions = rpmHeaderFormats;
00253     struct headerSprintfExtension_s * ext;
00254     PyObject * m;
00255 
00256 #if Py_TPFLAGS_HAVE_ITER        /* XXX backport to python-1.5.2 */
00257     if (PyType_Ready(&hdr_Type) < 0) return;
00258     if (PyType_Ready(&rpmal_Type) < 0) return;
00259     if (PyType_Ready(&rpmds_Type) < 0) return;
00260     if (PyType_Ready(&rpmfd_Type) < 0) return;
00261     if (PyType_Ready(&rpmfts_Type) < 0) return;
00262     if (PyType_Ready(&rpmfi_Type) < 0) return;
00263     if (PyType_Ready(&rpmmi_Type) < 0) return;
00264     if (PyType_Ready(&rpmps_Type) < 0) return;
00265 
00266     rpmrc_Type.tp_base = &PyDict_Type;
00267     if (PyType_Ready(&rpmrc_Type) < 0) return;
00268 
00269     if (PyType_Ready(&rpmte_Type) < 0) return;
00270     if (PyType_Ready(&rpmts_Type) < 0) return;
00271     if (PyType_Ready(&spec_Type) < 0) return;
00272 #endif
00273 
00274     m = Py_InitModule3("_rpm", rpmModuleMethods, rpm__doc__);
00275     if (m == NULL)
00276         return;
00277 
00278     /* 
00279      * treat error to register rpm cleanup hook as fatal, tracebacks
00280      * can and will leave stale locks around if we can't clean up
00281      */
00282     if (Py_AtExit(rpm_exithook) == -1)
00283         return;
00284 
00285     rpmReadConfigFiles(NULL, NULL);
00286 
00287     d = PyModule_GetDict(m);
00288 
00289 #ifdef  HACK
00290     pyrpmError = PyString_FromString("_rpm.error");
00291     PyDict_SetItemString(d, "error", pyrpmError);
00292     Py_DECREF(pyrpmError);
00293 #else
00294     pyrpmError = PyErr_NewException("_rpm.error", NULL, NULL);
00295     if (pyrpmError != NULL)
00296         PyDict_SetItemString(d, "error", pyrpmError);
00297 #endif
00298 
00299 #if Py_TPFLAGS_HAVE_ITER        /* XXX backport to python-1.5.2 */
00300     Py_INCREF(&hdr_Type);
00301     PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type);
00302 
00303     Py_INCREF(&rpmal_Type);
00304     PyModule_AddObject(m, "al", (PyObject *) &rpmal_Type);
00305 
00306     Py_INCREF(&rpmds_Type);
00307     PyModule_AddObject(m, "ds", (PyObject *) &rpmds_Type);
00308 
00309     Py_INCREF(&rpmfd_Type);
00310     PyModule_AddObject(m, "fd", (PyObject *) &rpmfd_Type);
00311 
00312     Py_INCREF(&rpmfts_Type);
00313     PyModule_AddObject(m, "fts", (PyObject *) &rpmfts_Type);
00314 
00315     Py_INCREF(&rpmfi_Type);
00316     PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_Type);
00317 
00318     Py_INCREF(&rpmmi_Type);
00319     PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type);
00320 
00321     Py_INCREF(&rpmps_Type);
00322     PyModule_AddObject(m, "ps", (PyObject *) &rpmps_Type);
00323 
00324     Py_INCREF(&rpmrc_Type);
00325     PyModule_AddObject(m, "rc", (PyObject *) &rpmrc_Type);
00326 
00327     Py_INCREF(&rpmte_Type);
00328     PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type);
00329 
00330     Py_INCREF(&rpmts_Type);
00331     PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
00332 
00333     Py_INCREF(&spec_Type);
00334     PyModule_AddObject(m, "spec", (PyObject *) &spec_Type);
00335 #else
00336     hdr_Type.ob_type = &PyType_Type;
00337     rpmal_Type.ob_type = &PyType_Type;
00338     rpmds_Type.ob_type = &PyType_Type;
00339     rpmfd_Type.ob_type = &PyType_Type;
00340     rpmfts_Type.ob_type = &PyType_Type;
00341     rpmfi_Type.ob_type = &PyType_Type;
00342     rpmmi_Type.ob_type = &PyType_Type;
00343     rpmps_Type.ob_type = &PyType_Type;
00344     rpmte_Type.ob_type = &PyType_Type;
00345     rpmts_Type.ob_type = &PyType_Type;
00346     spec_Type.ob_type =  &PyType_Type;
00347 #endif
00348 
00349     dict = PyDict_New();
00350 
00351     for (i = 0; i < rpmTagTableSize; i++) {
00352         tag = PyInt_FromLong(rpmTagTable[i].val);
00353         PyDict_SetItemString(d, (char *) rpmTagTable[i].name, tag);
00354         Py_DECREF(tag);
00355         PyDict_SetItem(dict, tag, o=PyString_FromString(rpmTagTable[i].name + 7));
00356         Py_DECREF(o);
00357     }
00358 
00359     while (extensions->name) {
00360         if (extensions->type == HEADER_EXT_TAG) {
00361             ext = extensions;
00362             PyDict_SetItemString(d, (char *) extensions->name, o=PyCObject_FromVoidPtr(ext, NULL));
00363             Py_DECREF(o);
00364             PyDict_SetItem(dict, tag, o=PyString_FromString(ext->name + 7));
00365             Py_DECREF(o);
00366         }
00367         extensions++;
00368     }
00369 
00370     PyDict_SetItemString(d, "tagnames", dict);
00371     Py_DECREF(dict);
00372 
00373 
00374 #define REGISTER_ENUM(val) \
00375     PyDict_SetItemString(d, #val, o=PyInt_FromLong( val )); \
00376     Py_DECREF(o);
00377 
00378     REGISTER_ENUM(RPMFILE_STATE_NORMAL);
00379     REGISTER_ENUM(RPMFILE_STATE_REPLACED);
00380     REGISTER_ENUM(RPMFILE_STATE_NOTINSTALLED);
00381     REGISTER_ENUM(RPMFILE_STATE_NETSHARED);
00382     REGISTER_ENUM(RPMFILE_STATE_WRONGCOLOR);
00383 
00384     REGISTER_ENUM(RPMFILE_CONFIG);
00385     REGISTER_ENUM(RPMFILE_DOC);
00386     REGISTER_ENUM(RPMFILE_ICON);
00387     REGISTER_ENUM(RPMFILE_MISSINGOK);
00388     REGISTER_ENUM(RPMFILE_NOREPLACE);
00389     REGISTER_ENUM(RPMFILE_GHOST);
00390     REGISTER_ENUM(RPMFILE_LICENSE);
00391     REGISTER_ENUM(RPMFILE_README);
00392     REGISTER_ENUM(RPMFILE_EXCLUDE);
00393     REGISTER_ENUM(RPMFILE_UNPATCHED);
00394     REGISTER_ENUM(RPMFILE_PUBKEY);
00395 
00396     REGISTER_ENUM(RPMDEP_SENSE_REQUIRES);
00397     REGISTER_ENUM(RPMDEP_SENSE_CONFLICTS);
00398 
00399     REGISTER_ENUM(RPMSENSE_SERIAL);
00400     REGISTER_ENUM(RPMSENSE_LESS);
00401     REGISTER_ENUM(RPMSENSE_GREATER);
00402     REGISTER_ENUM(RPMSENSE_EQUAL);
00403     REGISTER_ENUM(RPMSENSE_PREREQ);
00404     REGISTER_ENUM(RPMSENSE_INTERP);
00405     REGISTER_ENUM(RPMSENSE_SCRIPT_PRE);
00406     REGISTER_ENUM(RPMSENSE_SCRIPT_POST);
00407     REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN);
00408     REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN);
00409     REGISTER_ENUM(RPMSENSE_SCRIPT_VERIFY);
00410     REGISTER_ENUM(RPMSENSE_FIND_REQUIRES);
00411     REGISTER_ENUM(RPMSENSE_FIND_PROVIDES);
00412     REGISTER_ENUM(RPMSENSE_TRIGGERIN);
00413     REGISTER_ENUM(RPMSENSE_TRIGGERUN);
00414     REGISTER_ENUM(RPMSENSE_TRIGGERPOSTUN);
00415     REGISTER_ENUM(RPMSENSE_SCRIPT_PREP);
00416     REGISTER_ENUM(RPMSENSE_SCRIPT_BUILD);
00417     REGISTER_ENUM(RPMSENSE_SCRIPT_INSTALL);
00418     REGISTER_ENUM(RPMSENSE_SCRIPT_CLEAN);
00419     REGISTER_ENUM(RPMSENSE_RPMLIB);
00420     REGISTER_ENUM(RPMSENSE_TRIGGERPREIN);
00421     REGISTER_ENUM(RPMSENSE_KEYRING);
00422     REGISTER_ENUM(RPMSENSE_PATCHES);
00423     REGISTER_ENUM(RPMSENSE_CONFIG);
00424 
00425     REGISTER_ENUM(RPMTRANS_FLAG_TEST);
00426     REGISTER_ENUM(RPMTRANS_FLAG_BUILD_PROBS);
00427     REGISTER_ENUM(RPMTRANS_FLAG_NOSCRIPTS);
00428     REGISTER_ENUM(RPMTRANS_FLAG_JUSTDB);
00429     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERS);
00430     REGISTER_ENUM(RPMTRANS_FLAG_NODOCS);
00431     REGISTER_ENUM(RPMTRANS_FLAG_ALLFILES);
00432     REGISTER_ENUM(RPMTRANS_FLAG_KEEPOBSOLETE);
00433     REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE);
00434     REGISTER_ENUM(RPMTRANS_FLAG_REVERSE);
00435     REGISTER_ENUM(RPMTRANS_FLAG_NOPRE);
00436     REGISTER_ENUM(RPMTRANS_FLAG_NOPOST);
00437     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPREIN);
00438     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERIN);
00439     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERUN);
00440     REGISTER_ENUM(RPMTRANS_FLAG_NOPREUN);
00441     REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTUN);
00442     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPOSTUN);
00443     REGISTER_ENUM(RPMTRANS_FLAG_ANACONDA);
00444     REGISTER_ENUM(RPMTRANS_FLAG_NOMD5);
00445     REGISTER_ENUM(RPMTRANS_FLAG_NOSUGGEST);
00446     REGISTER_ENUM(RPMTRANS_FLAG_ADDINDEPS);
00447     REGISTER_ENUM(RPMTRANS_FLAG_NOCONFIGS);
00448 
00449     REGISTER_ENUM(RPMPROB_FILTER_IGNOREOS);
00450     REGISTER_ENUM(RPMPROB_FILTER_IGNOREARCH);
00451     REGISTER_ENUM(RPMPROB_FILTER_REPLACEPKG);
00452     REGISTER_ENUM(RPMPROB_FILTER_FORCERELOCATE);
00453     REGISTER_ENUM(RPMPROB_FILTER_REPLACENEWFILES);
00454     REGISTER_ENUM(RPMPROB_FILTER_REPLACEOLDFILES);
00455     REGISTER_ENUM(RPMPROB_FILTER_OLDPACKAGE);
00456     REGISTER_ENUM(RPMPROB_FILTER_DISKSPACE);
00457     REGISTER_ENUM(RPMPROB_FILTER_DISKNODES);
00458 
00459     REGISTER_ENUM(RPMCALLBACK_UNKNOWN);
00460     REGISTER_ENUM(RPMCALLBACK_INST_PROGRESS);
00461     REGISTER_ENUM(RPMCALLBACK_INST_START);
00462     REGISTER_ENUM(RPMCALLBACK_INST_OPEN_FILE);
00463     REGISTER_ENUM(RPMCALLBACK_INST_CLOSE_FILE);
00464     REGISTER_ENUM(RPMCALLBACK_TRANS_PROGRESS);
00465     REGISTER_ENUM(RPMCALLBACK_TRANS_START);
00466     REGISTER_ENUM(RPMCALLBACK_TRANS_STOP);
00467     REGISTER_ENUM(RPMCALLBACK_UNINST_PROGRESS);
00468     REGISTER_ENUM(RPMCALLBACK_UNINST_START);
00469     REGISTER_ENUM(RPMCALLBACK_UNINST_STOP);
00470     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_PROGRESS);
00471     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_START);
00472     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_STOP);
00473     REGISTER_ENUM(RPMCALLBACK_UNPACK_ERROR);
00474     REGISTER_ENUM(RPMCALLBACK_CPIO_ERROR);
00475 
00476     REGISTER_ENUM(RPMPROB_BADARCH);
00477     REGISTER_ENUM(RPMPROB_BADOS);
00478     REGISTER_ENUM(RPMPROB_PKG_INSTALLED);
00479     REGISTER_ENUM(RPMPROB_BADRELOCATE);
00480     REGISTER_ENUM(RPMPROB_REQUIRES);
00481     REGISTER_ENUM(RPMPROB_CONFLICT);
00482     REGISTER_ENUM(RPMPROB_NEW_FILE_CONFLICT);
00483     REGISTER_ENUM(RPMPROB_FILE_CONFLICT);
00484     REGISTER_ENUM(RPMPROB_OLDPACKAGE);
00485     REGISTER_ENUM(RPMPROB_DISKSPACE);
00486     REGISTER_ENUM(RPMPROB_DISKNODES);
00487     REGISTER_ENUM(RPMPROB_BADPRETRANS);
00488 
00489     REGISTER_ENUM(VERIFY_DIGEST);
00490     REGISTER_ENUM(VERIFY_SIGNATURE);
00491 
00492     REGISTER_ENUM(RPMLOG_EMERG);
00493     REGISTER_ENUM(RPMLOG_ALERT);
00494     REGISTER_ENUM(RPMLOG_CRIT);
00495     REGISTER_ENUM(RPMLOG_ERR);
00496     REGISTER_ENUM(RPMLOG_WARNING);
00497     REGISTER_ENUM(RPMLOG_NOTICE);
00498     REGISTER_ENUM(RPMLOG_INFO);
00499     REGISTER_ENUM(RPMLOG_DEBUG);
00500 
00501     REGISTER_ENUM(RPMMIRE_DEFAULT);
00502     REGISTER_ENUM(RPMMIRE_STRCMP);
00503     REGISTER_ENUM(RPMMIRE_REGEX);
00504     REGISTER_ENUM(RPMMIRE_GLOB);
00505 
00506     REGISTER_ENUM(RPMVSF_DEFAULT);
00507     REGISTER_ENUM(RPMVSF_NOHDRCHK);
00508     REGISTER_ENUM(RPMVSF_NEEDPAYLOAD);
00509     REGISTER_ENUM(RPMVSF_NOSHA1HEADER);
00510     REGISTER_ENUM(RPMVSF_NOMD5HEADER);
00511     REGISTER_ENUM(RPMVSF_NODSAHEADER);
00512     REGISTER_ENUM(RPMVSF_NORSAHEADER);
00513     REGISTER_ENUM(RPMVSF_NOSHA1);
00514     REGISTER_ENUM(RPMVSF_NOMD5);
00515     REGISTER_ENUM(RPMVSF_NODSA);
00516     REGISTER_ENUM(RPMVSF_NORSA);
00517     REGISTER_ENUM(_RPMVSF_NODIGESTS);
00518     REGISTER_ENUM(_RPMVSF_NOSIGNATURES);
00519     REGISTER_ENUM(_RPMVSF_NOHEADER);
00520     REGISTER_ENUM(_RPMVSF_NOPAYLOAD);
00521 
00522     REGISTER_ENUM(TR_ADDED);
00523     REGISTER_ENUM(TR_REMOVED);
00524 
00525     REGISTER_ENUM(RPMDBI_PACKAGES);
00526 
00527     REGISTER_ENUM(RPMAL_NOMATCH);
00528 }
00529 

Generated on Thu Oct 25 09:23:15 2007 for rpm by  doxygen 1.5.1