rpm 5.3.12
python/rpmmodule.c
Go to the documentation of this file.
00001 
00005 #include "system.h"
00006 
00007 #include <rpmio_internal.h>
00008 #include <rpmcb.h>
00009 #include <rpmsq.h>
00010 #include <argv.h>
00011 
00012 #define _RPMTAG_INTERNAL
00013 #include <rpmtag.h>
00014 #define _RPMEVR_INTERNAL
00015 #include <rpmevr.h>
00016 #include <rpmdb.h>
00017 #include <rpmcli.h>     /* XXX for rpmCheckSig */
00018 
00019 #include "legacy.h"
00020 #include "misc.h"
00021 
00022 #include "header-py.h"
00023 #include "rpmal-py.h"
00024 #include "rpmds-py.h"
00025 #include "rpmfd-py.h"
00026 #include "rpmfts-py.h"
00027 #include "rpmfi-py.h"
00028 #include "rpmkeyring-py.h"
00029 #include "rpmmacro-py.h"
00030 #include "rpmmi-py.h"
00031 #include "rpmps-py.h"
00032 #include "rpmtd-py.h"
00033 #include "rpmte-py.h"
00034 #include "rpmts-py.h"
00035 #include "spec-py.h"
00036 
00037 #include "debug.h"
00038 
00039 #ifdef __LCLINT__
00040 #undef  PyObject_HEAD
00041 #define PyObject_HEAD   int _PyObjectHead
00042 #endif
00043 
00048 
00051 PyObject * pyrpmError;
00052 
00053 extern sigset_t rpmsqCaught;
00054 
00057 static PyObject * archScore(PyObject * s, PyObject * args,
00058                 PyObject * kwds)
00059 {
00060     char * arch;
00061     char * platform;
00062     int score;
00063     char * kwlist[] = {"arch", NULL};
00064 
00065     if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &arch))
00066         return NULL;
00067 
00068 #if defined(RPM_VENDOR_WINDRIVER)
00069     platform = rpmExpand(arch, "-%{_host_vendor}", "-%{_host_os}%{?_gnu}", NULL);
00070 #else
00071     platform = rpmExpand(arch, "-", "%{_vendor}", "-", "%{_os}", NULL);
00072 #endif
00073     score = rpmPlatformScore(platform, NULL, 0);
00074     platform = _free(platform);
00075 
00076     return Py_BuildValue("i", score);
00077 }
00078 
00081 static PyObject * platformScore(PyObject * s, PyObject * args,
00082                 PyObject * kwds)
00083 {
00084     char * platform;
00085     int score;
00086     char * kwlist[] = {"platform", NULL};
00087 
00088     if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &platform))
00089         return NULL;
00090 
00091     score = rpmPlatformScore(platform, NULL, 0);
00092 
00093     return Py_BuildValue("i", score);
00094 }
00095 
00098 static PyObject * signalsCaught(PyObject * s, PyObject * check)
00099 {
00100     PyObject *caught, *o;
00101     Py_ssize_t llen;
00102     int signum, i;
00103     sigset_t newMask, oldMask;
00104 
00105     if (!PyList_Check(check)) {
00106         PyErr_SetString(PyExc_TypeError, "list expected");
00107         return NULL;
00108     }
00109 
00110     llen = PyList_Size(check);
00111     caught = PyList_New(0);
00112 
00113     /* block signals while checking for them */
00114     (void) sigfillset(&newMask);
00115     (void) sigprocmask(SIG_BLOCK, &newMask, &oldMask);
00116 
00117     for (i = 0; i < llen; i++) {
00118         o = PyList_GetItem(check, i);
00119         signum = PyInt_AsLong(o);
00120         if (sigismember(&rpmsqCaught, signum)) {
00121             PyList_Append(caught, o);
00122         }
00123     }
00124     (void) sigprocmask(SIG_SETMASK, &oldMask, NULL);
00125 
00126     return caught;
00127 }
00128 
00131 static PyObject * checkSignals(PyObject * s, PyObject * args)
00132 {
00133     if (!PyArg_ParseTuple(args, ":checkSignals")) return NULL;
00134     rpmdbCheckSignals();
00135     Py_INCREF(Py_None);
00136     return Py_None;
00137 }
00138 
00141 static PyObject * setLogFile (PyObject * s, PyObject * args,
00142                 PyObject *kwds)
00143 {
00144     PyObject * fop = NULL;
00145     FILE * fp = NULL;
00146     char * kwlist[] = {"fileObject", NULL};
00147 
00148     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:logSetFile", kwlist, &fop))
00149         return NULL;
00150 
00151     if (fop) {
00152         if (!PyFile_Check(fop)) {
00153             PyErr_SetString(pyrpmError, "requires file object");
00154             return NULL;
00155         }
00156         fp = PyFile_AsFile(fop);
00157     }
00158 
00159     (void) rpmlogSetFile(fp);
00160 
00161     Py_INCREF(Py_None);
00162     return (PyObject *) Py_None;
00163 }
00164 
00167 static PyObject *
00168 setVerbosity (PyObject * s, PyObject * args, PyObject *kwds)
00169 {
00170     int level;
00171     char * kwlist[] = {"level", NULL};
00172 
00173     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &level))
00174         return NULL;
00175 
00176     rpmSetVerbosity(level);
00177 
00178     Py_INCREF(Py_None);
00179     return (PyObject *) Py_None;
00180 }
00181 
00184 static PyObject *
00185 setEpochPromote (PyObject * s, PyObject * args, PyObject * kwds)
00186 {
00187     char * kwlist[] = {"promote", NULL};
00188 
00189     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist,
00190             &_rpmds_nopromote))
00191         return NULL;
00192 
00193     Py_INCREF(Py_None);
00194     return (PyObject *) Py_None;
00195 }
00196 
00199 static PyObject * setStats (PyObject * s, PyObject * args,
00200                 PyObject * kwds)
00201 {
00202     char * kwlist[] = {"stats", NULL};
00203 
00204     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmts_stats))
00205         return NULL;
00206 
00207     Py_INCREF(Py_None);
00208     return (PyObject *) Py_None;
00209 }
00214 static PyMethodDef rpmModuleMethods[] = {
00215     { "TransactionSet", (PyCFunction) rpmts_Create, METH_VARARGS|METH_KEYWORDS,
00216 "rpm.TransactionSet([rootDir, [db]]) -> ts\n\
00217 - Create a transaction set.\n" },
00218 
00219     { "addMacro", (PyCFunction) rpmmacro_AddMacro, METH_VARARGS|METH_KEYWORDS,
00220         NULL },
00221     { "delMacro", (PyCFunction) rpmmacro_DelMacro, METH_VARARGS|METH_KEYWORDS,
00222         NULL },
00223     { "expandMacro", (PyCFunction)rpmmacro_ExpandMacro, METH_VARARGS|METH_KEYWORDS,
00224         NULL },
00225     { "getMacros", (PyCFunction) rpmmacro_GetMacros, METH_VARARGS|METH_KEYWORDS,
00226         NULL },
00227 
00228     { "archscore", (PyCFunction) archScore, METH_VARARGS|METH_KEYWORDS,
00229         NULL },
00230     { "platformscore", (PyCFunction) platformScore, METH_VARARGS|METH_KEYWORDS,
00231         NULL },
00232 
00233     { "signalsCaught", (PyCFunction) signalsCaught, METH_O,
00234         NULL },
00235     { "checkSignals", (PyCFunction) checkSignals, METH_VARARGS,
00236         NULL },
00237 
00238     { "headerLoad", (PyCFunction) hdrLoad, METH_VARARGS|METH_KEYWORDS,
00239         NULL },
00240 
00241     { "readHeaderListFromFD", (PyCFunction) rpmHeaderFromFD, METH_VARARGS|METH_KEYWORDS,
00242         NULL },
00243     { "readHeaderListFromFile", (PyCFunction) rpmHeaderFromFile, METH_VARARGS|METH_KEYWORDS,
00244         NULL },
00245     { "readHeaderFromFD", (PyCFunction) rpmSingleHeaderFromFD, METH_VARARGS|METH_KEYWORDS,
00246         NULL },
00247     { "writeHeaderListToFD", (PyCFunction) rpmHeaderToFD, METH_VARARGS|METH_KEYWORDS,
00248         NULL },
00249     { "writeHeaderListToFile", (PyCFunction) rpmHeaderToFile, METH_VARARGS|METH_KEYWORDS,
00250         NULL },
00251 
00252     { "setLogFile", (PyCFunction) setLogFile, METH_VARARGS|METH_KEYWORDS,
00253         NULL },
00254 
00255     { "versionCompare", (PyCFunction) versionCompare, METH_VARARGS|METH_KEYWORDS,
00256         NULL },
00257     { "labelCompare", (PyCFunction) labelCompare, METH_VARARGS|METH_KEYWORDS,
00258         NULL },
00259     { "evrCompare", (PyCFunction) evrCompare, METH_VARARGS|METH_KEYWORDS,
00260         NULL },
00261     { "evrSplit", (PyCFunction) evrSplit, METH_VARARGS|METH_KEYWORDS,
00262         NULL },
00263     { "setVerbosity", (PyCFunction) setVerbosity, METH_VARARGS|METH_KEYWORDS,
00264         NULL },
00265     { "setEpochPromote", (PyCFunction) setEpochPromote, METH_VARARGS|METH_KEYWORDS,
00266         NULL },
00267     { "setStats", (PyCFunction) setStats, METH_VARARGS|METH_KEYWORDS,
00268         NULL },
00269 
00270     { "dsSingle", (PyCFunction) rpmds_Single, METH_VARARGS|METH_KEYWORDS,
00271 "rpm.dsSingle(TagN, N, [EVR, [Flags]] -> ds\n\
00272 - Create a single element dependency set.\n" },
00273     { NULL }
00274 } ;
00275 
00276 /*
00277  * Force clean up of open iterators and dbs on exit.
00278  */
00279 static void rpm_exithook(void)
00280 {
00281    rpmdbCheckTerminate(1);
00282 }
00283 
00284 /*
00285  * Add rpm tag dictionaries to the module
00286  */
00287 static void addRpmTags(PyObject *module)
00288 {
00289     PyObject * dict = PyDict_New();
00290 
00291 #ifdef  NOTYET
00292 
00293     PyObject *pyval, *pyname;
00294     rpmtd names = rpmtdNew();
00295     rpmTagGetNames(names, 1);
00296     const char *tagname, *shortname;
00297     rpmTag tagval;
00298 
00299     while ((tagname = rpmtdNextString(names))) {
00300         shortname = tagname + strlen("RPMTAG_");
00301         tagval = rpmTagGetValue(shortname);
00302 
00303         PyModule_AddIntConstant(module, tagname, tagval);
00304         pyval = PyInt_FromLong(tagval);
00305         pyname = PyString_FromString(shortname);
00306         PyDict_SetItem(dict, pyval, pyname);
00307         Py_DECREF(pyval);
00308         Py_DECREF(pyname);
00309     }
00310     PyModule_AddObject(module, "tagnames", dict);
00311     rpmtdFreeData(names);
00312     rpmtdFree(names);
00313 
00314 #else
00315 
00316     PyObject * d = PyModule_GetDict(module);
00317     PyObject * o;
00318 
00319  {  const struct headerTagTableEntry_s * t;
00320     PyObject * to;
00321     for (t = rpmTagTable; t && t->name; t++) {
00322         PyDict_SetItemString(d, (char *) t->name, to=PyInt_FromLong(t->val));
00323         Py_DECREF(to);
00324         PyDict_SetItem(dict, to, o=PyString_FromString(t->name + 7));
00325         Py_DECREF(o);
00326     }
00327  }
00328 
00329  {  headerSprintfExtension exts = rpmHeaderFormats;
00330     headerSprintfExtension ext;
00331     PyObject * to;
00332     int extNum;
00333     for (ext = exts, extNum = 0; ext != NULL && ext->type != HEADER_EXT_LAST;
00334         ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1), extNum++)
00335     {
00336         if (ext->name == NULL || ext->type != HEADER_EXT_TAG)
00337             continue;
00338         PyDict_SetItemString(d, (char *) ext->name, to=PyCObject_FromVoidPtr((void *)ext, NULL));
00339         Py_DECREF(to);
00340         PyDict_SetItem(dict, to, o=PyString_FromString(ext->name + 7));
00341         Py_DECREF(o);
00342     }
00343  }
00344 
00345     PyDict_SetItemString(d, "tagnames", dict);
00346     Py_DECREF(dict);
00347 
00348 #endif
00349 }
00350 
00353 static char rpm__doc__[] =
00354 "";
00355 
00356 void init_rpm(void);    /* XXX eliminate gcc warning */
00359 void init_rpm(void)
00360 {
00361     PyObject * d, * o, * m;
00362 
00363 #if Py_TPFLAGS_HAVE_ITER        /* XXX backport to python-1.5.2 */
00364     if (PyType_Ready(&hdr_Type) < 0) return;
00365     if (PyType_Ready(&rpmal_Type) < 0) return;
00366     if (PyType_Ready(&rpmds_Type) < 0) return;
00367     if (PyType_Ready(&rpmfd_Type) < 0) return;
00368     if (PyType_Ready(&rpmfts_Type) < 0) return;
00369     if (PyType_Ready(&rpmfi_Type) < 0) return;
00370     if (PyType_Ready(&rpmmi_Type) < 0) return;
00371     if (PyType_Ready(&rpmps_Type) < 0) return;
00372 
00373     if (PyType_Ready(&rpmtd_Type) < 0) return;
00374     if (PyType_Ready(&rpmKeyring_Type) < 0) return;
00375     if (PyType_Ready(&rpmPubkey_Type) < 0) return;
00376 
00377     if (PyType_Ready(&rpmte_Type) < 0) return;
00378     if (PyType_Ready(&rpmts_Type) < 0) return;
00379     if (PyType_Ready(&spec_Type) < 0) return;
00380 #endif
00381 
00382     m = Py_InitModule3("_rpm", rpmModuleMethods, rpm__doc__);
00383     if (m == NULL)
00384         return;
00385 
00386     /* 
00387      * treat error to register rpm cleanup hook as fatal, tracebacks
00388      * can and will leave stale locks around if we can't clean up
00389      */
00390     if (Py_AtExit(rpm_exithook) == -1)
00391         return;
00392 
00393     rpmReadConfigFiles(NULL, NULL);
00394 
00395     d = PyModule_GetDict(m);
00396 
00397 #ifdef  HACK
00398     pyrpmError = PyString_FromString("_rpm.error");
00399     PyDict_SetItemString(d, "error", pyrpmError);
00400     Py_DECREF(pyrpmError);
00401 #else
00402     pyrpmError = PyErr_NewException("_rpm.error", NULL, NULL);
00403     if (pyrpmError != NULL)
00404         PyDict_SetItemString(d, "error", pyrpmError);
00405 #endif
00406 
00407 #if Py_TPFLAGS_HAVE_ITER        /* XXX backport to python-1.5.2 */
00408     Py_INCREF(&hdr_Type);
00409     PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type);
00410 
00411     Py_INCREF(&rpmal_Type);
00412     PyModule_AddObject(m, "al", (PyObject *) &rpmal_Type);
00413 
00414     Py_INCREF(&rpmds_Type);
00415     PyModule_AddObject(m, "ds", (PyObject *) &rpmds_Type);
00416 
00417     Py_INCREF(&rpmfd_Type);
00418     PyModule_AddObject(m, "fd", (PyObject *) &rpmfd_Type);
00419 
00420     Py_INCREF(&rpmfts_Type);
00421     PyModule_AddObject(m, "fts", (PyObject *) &rpmfts_Type);
00422 
00423     Py_INCREF(&rpmfi_Type);
00424     PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_Type);
00425 
00426     Py_INCREF(&rpmKeyring_Type);
00427     PyModule_AddObject(m, "Keyring", (PyObject *) &rpmKeyring_Type);
00428     Py_INCREF(&rpmPubkey_Type);
00429     PyModule_AddObject(m, "Pubkey", (PyObject *) &rpmPubkey_Type);
00430 
00431     Py_INCREF(&rpmmi_Type);
00432     PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type);
00433 
00434     Py_INCREF(&rpmps_Type);
00435     PyModule_AddObject(m, "ps", (PyObject *) &rpmps_Type);
00436 
00437     Py_INCREF(&rpmtd_Type);
00438     PyModule_AddObject(m, "td", (PyObject *) &rpmtd_Type);
00439 
00440     Py_INCREF(&rpmte_Type);
00441     PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type);
00442 
00443     Py_INCREF(&rpmts_Type);
00444     PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
00445 
00446     Py_INCREF(&spec_Type);
00447     PyModule_AddObject(m, "spec", (PyObject *) &spec_Type);
00448 #else
00449     hdr_Type.ob_type = &PyType_Type;
00450     rpmal_Type.ob_type = &PyType_Type;
00451     rpmds_Type.ob_type = &PyType_Type;
00452     rpmfd_Type.ob_type = &PyType_Type;
00453     rpmfts_Type.ob_type = &PyType_Type;
00454     rpmfi_Type.ob_type = &PyType_Type;
00455     rpmmi_Type.ob_type = &PyType_Type;
00456     rpmps_Type.ob_type = &PyType_Type;
00457     rpmte_Type.ob_type = &PyType_Type;
00458     rpmts_Type.ob_type = &PyType_Type;
00459     spec_Type.ob_type =  &PyType_Type;
00460 #endif
00461 
00462     addRpmTags(m);
00463 
00464 #define REGISTER_ENUM(val) \
00465     PyDict_SetItemString(d, #val, o=PyInt_FromLong( val )); \
00466     Py_DECREF(o);
00467 
00468     REGISTER_ENUM(RPMFILE_STATE_NORMAL);
00469     REGISTER_ENUM(RPMFILE_STATE_REPLACED);
00470     REGISTER_ENUM(RPMFILE_STATE_NOTINSTALLED);
00471     REGISTER_ENUM(RPMFILE_STATE_NETSHARED);
00472     REGISTER_ENUM(RPMFILE_STATE_WRONGCOLOR);
00473 
00474     REGISTER_ENUM(RPMFILE_CONFIG);
00475     REGISTER_ENUM(RPMFILE_DOC);
00476     REGISTER_ENUM(RPMFILE_ICON);
00477     REGISTER_ENUM(RPMFILE_MISSINGOK);
00478     REGISTER_ENUM(RPMFILE_NOREPLACE);
00479     REGISTER_ENUM(RPMFILE_GHOST);
00480     REGISTER_ENUM(RPMFILE_LICENSE);
00481     REGISTER_ENUM(RPMFILE_README);
00482     REGISTER_ENUM(RPMFILE_EXCLUDE);
00483     REGISTER_ENUM(RPMFILE_UNPATCHED);
00484     REGISTER_ENUM(RPMFILE_PUBKEY);
00485 
00486     REGISTER_ENUM(RPMDEP_SENSE_REQUIRES);
00487     REGISTER_ENUM(RPMDEP_SENSE_CONFLICTS);
00488 
00489     REGISTER_ENUM(RPMSENSE_LESS);
00490     REGISTER_ENUM(RPMSENSE_GREATER);
00491     REGISTER_ENUM(RPMSENSE_EQUAL);
00492     REGISTER_ENUM(RPMSENSE_NOTEQUAL);
00493     REGISTER_ENUM(RPMSENSE_FIND_REQUIRES);
00494 #if defined(RPM_VENDOR_MANDRIVA)
00495     REGISTER_ENUM(RPMSENSE_PREREQ);
00496     REGISTER_ENUM(RPMSENSE_SCRIPT_PRE);
00497     REGISTER_ENUM(RPMSENSE_SCRIPT_POST);
00498     REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN);
00499     REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN)
00500 #endif
00501 
00502     REGISTER_ENUM(RPMDEPS_FLAG_NOUPGRADE);
00503     REGISTER_ENUM(RPMDEPS_FLAG_NOREQUIRES);
00504     REGISTER_ENUM(RPMDEPS_FLAG_NOCONFLICTS);
00505     REGISTER_ENUM(RPMDEPS_FLAG_NOOBSOLETES);
00506     REGISTER_ENUM(RPMDEPS_FLAG_NOPARENTDIRS);
00507     REGISTER_ENUM(RPMDEPS_FLAG_NOLINKTOS);
00508     REGISTER_ENUM(RPMDEPS_FLAG_ANACONDA);
00509     REGISTER_ENUM(RPMDEPS_FLAG_NOSUGGEST);
00510     REGISTER_ENUM(RPMDEPS_FLAG_ADDINDEPS);
00511     REGISTER_ENUM(RPMDEPS_FLAG_DEPLOOPS);
00512 
00513     REGISTER_ENUM(RPMTRANS_FLAG_TEST);
00514     REGISTER_ENUM(RPMTRANS_FLAG_BUILD_PROBS);
00515     REGISTER_ENUM(RPMTRANS_FLAG_NOSCRIPTS);
00516     REGISTER_ENUM(RPMTRANS_FLAG_JUSTDB);
00517     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERS);
00518     REGISTER_ENUM(RPMTRANS_FLAG_NODOCS);
00519     REGISTER_ENUM(RPMTRANS_FLAG_ALLFILES);
00520     REGISTER_ENUM(RPMTRANS_FLAG_NORPMDB);
00521     REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE);
00522     REGISTER_ENUM(RPMTRANS_FLAG_NOPRE);
00523     REGISTER_ENUM(RPMTRANS_FLAG_NOPOST);
00524     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPREIN);
00525     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERIN);
00526     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERUN);
00527     REGISTER_ENUM(RPMTRANS_FLAG_NOPREUN);
00528     REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTUN);
00529     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPOSTUN);
00530     REGISTER_ENUM(RPMTRANS_FLAG_NOFDIGESTS);
00531     REGISTER_ENUM(RPMTRANS_FLAG_NOCONFIGS);
00532 
00533     REGISTER_ENUM(RPMPROB_FILTER_IGNOREOS);
00534     REGISTER_ENUM(RPMPROB_FILTER_IGNOREARCH);
00535     REGISTER_ENUM(RPMPROB_FILTER_REPLACEPKG);
00536     REGISTER_ENUM(RPMPROB_FILTER_FORCERELOCATE);
00537     REGISTER_ENUM(RPMPROB_FILTER_REPLACENEWFILES);
00538     REGISTER_ENUM(RPMPROB_FILTER_REPLACEOLDFILES);
00539     REGISTER_ENUM(RPMPROB_FILTER_OLDPACKAGE);
00540     REGISTER_ENUM(RPMPROB_FILTER_DISKSPACE);
00541     REGISTER_ENUM(RPMPROB_FILTER_DISKNODES);
00542 
00543     REGISTER_ENUM(RPMCALLBACK_UNKNOWN);
00544     REGISTER_ENUM(RPMCALLBACK_INST_PROGRESS);
00545     REGISTER_ENUM(RPMCALLBACK_INST_START);
00546     REGISTER_ENUM(RPMCALLBACK_INST_OPEN_FILE);
00547     REGISTER_ENUM(RPMCALLBACK_INST_CLOSE_FILE);
00548     REGISTER_ENUM(RPMCALLBACK_TRANS_PROGRESS);
00549     REGISTER_ENUM(RPMCALLBACK_TRANS_START);
00550     REGISTER_ENUM(RPMCALLBACK_TRANS_STOP);
00551     REGISTER_ENUM(RPMCALLBACK_UNINST_PROGRESS);
00552     REGISTER_ENUM(RPMCALLBACK_UNINST_START);
00553     REGISTER_ENUM(RPMCALLBACK_UNINST_STOP);
00554     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_PROGRESS);
00555     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_START);
00556     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_STOP);
00557     REGISTER_ENUM(RPMCALLBACK_UNPACK_ERROR);
00558     REGISTER_ENUM(RPMCALLBACK_CPIO_ERROR);
00559     REGISTER_ENUM(RPMCALLBACK_SCRIPT_ERROR);
00560 
00561     REGISTER_ENUM(RPMPROB_BADARCH);
00562     REGISTER_ENUM(RPMPROB_BADOS);
00563     REGISTER_ENUM(RPMPROB_PKG_INSTALLED);
00564     REGISTER_ENUM(RPMPROB_BADRELOCATE);
00565     REGISTER_ENUM(RPMPROB_REQUIRES);
00566     REGISTER_ENUM(RPMPROB_CONFLICT);
00567     REGISTER_ENUM(RPMPROB_NEW_FILE_CONFLICT);
00568     REGISTER_ENUM(RPMPROB_FILE_CONFLICT);
00569     REGISTER_ENUM(RPMPROB_OLDPACKAGE);
00570     REGISTER_ENUM(RPMPROB_DISKSPACE);
00571     REGISTER_ENUM(RPMPROB_DISKNODES);
00572     REGISTER_ENUM(RPMPROB_BADPRETRANS);
00573 
00574     REGISTER_ENUM(VERIFY_DIGEST);
00575     REGISTER_ENUM(VERIFY_SIGNATURE);
00576 
00577     REGISTER_ENUM(RPMLOG_EMERG);
00578     REGISTER_ENUM(RPMLOG_ALERT);
00579     REGISTER_ENUM(RPMLOG_CRIT);
00580     REGISTER_ENUM(RPMLOG_ERR);
00581     REGISTER_ENUM(RPMLOG_WARNING);
00582     REGISTER_ENUM(RPMLOG_NOTICE);
00583     REGISTER_ENUM(RPMLOG_INFO);
00584     REGISTER_ENUM(RPMLOG_DEBUG);
00585 
00586     REGISTER_ENUM(RPMMIRE_DEFAULT);
00587     REGISTER_ENUM(RPMMIRE_STRCMP);
00588     REGISTER_ENUM(RPMMIRE_REGEX);
00589     REGISTER_ENUM(RPMMIRE_GLOB);
00590 
00591     REGISTER_ENUM(RPMVSF_DEFAULT);
00592     REGISTER_ENUM(RPMVSF_NOHDRCHK);
00593     REGISTER_ENUM(RPMVSF_NEEDPAYLOAD);
00594     REGISTER_ENUM(RPMVSF_NOSHA1HEADER);
00595     REGISTER_ENUM(RPMVSF_NOMD5HEADER);
00596     REGISTER_ENUM(RPMVSF_NODSAHEADER);
00597     REGISTER_ENUM(RPMVSF_NORSAHEADER);
00598     REGISTER_ENUM(RPMVSF_NOSHA1);
00599     REGISTER_ENUM(RPMVSF_NOMD5);
00600     REGISTER_ENUM(RPMVSF_NODSA);
00601     REGISTER_ENUM(RPMVSF_NORSA);
00602     REGISTER_ENUM(_RPMVSF_NODIGESTS);
00603     REGISTER_ENUM(_RPMVSF_NOSIGNATURES);
00604     REGISTER_ENUM(_RPMVSF_NOHEADER);
00605     REGISTER_ENUM(_RPMVSF_NOPAYLOAD);
00606 
00607     REGISTER_ENUM(TR_ADDED);
00608     REGISTER_ENUM(TR_REMOVED);
00609 
00610     REGISTER_ENUM(RPMDBI_PACKAGES);
00611 
00612     REGISTER_ENUM((long)RPMAL_NOMATCH);
00613 }