python/rpmmodule.c

   1 #include "rpmsystem-py.h"
   2
   3 #include <rpm/rpmlib.h>         /* rpmMachineScore, rpmReadConfigFiles */
   4 #include <rpm/rpmtag.h>
   5 #include <rpm/rpmdb.h>
   6 #include <rpm/rpmsq.h>
   7 #include <rpm/rpmlog.h>
   8 #include <rpm/rpmmacro.h>
   9
  10 #include "header-py.h"
  11 #include "rpmds-py.h"
  12 #include "rpmfd-py.h"
  13 #include "rpmfi-py.h"
  14 #include "rpmkeyring-py.h"
  15 #include "rpmmi-py.h"
  16 #include "rpmii-py.h"
  17 #include "rpmps-py.h"
  18 #include "rpmmacro-py.h"
  19 #include "rpmtd-py.h"
  20 #include "rpmte-py.h"
  21 #include "rpmts-py.h"
  22
  23 /** \ingroup python
  24  * \name Module: rpm
  25  */
  26
  27 PyObject * pyrpmError;
  28
  29 static PyObject * archScore(PyObject * self, PyObject * arg)
  30 {
  31     const char * arch;
  32
  33     if (!PyArg_Parse(arg, "s", &arch))
  34         return NULL;
  35
  36     return Py_BuildValue("i", rpmMachineScore(RPM_MACHTABLE_INSTARCH, arch));
  37 }
  38
  39 static PyObject * signalCaught(PyObject *self, PyObject *o)
  40 {
  41     int signo;
  42     if (!PyArg_Parse(o, "i", &signo)) return NULL;
  43
  44     return PyBool_FromLong(rpmsqIsCaught(signo));
  45 }
  46
  47 static PyObject * checkSignals(PyObject * self)
  48 {
  49     rpmdbCheckSignals();
  50     Py_RETURN_NONE;
  51 }
  52
  53 static PyObject * setLogFile (PyObject * self, PyObject *arg)
  54 {
  55     FILE *fp;
  56     int fdno = PyObject_AsFileDescriptor(arg);
  57
  58     if (fdno >= 0) {
  59         /* XXX we dont know the mode here.. guessing append for now */
  60         fp = fdopen(fdno, "a");
  61         if (fp == NULL) {
  62             PyErr_SetFromErrno(PyExc_IOError);
  63             return NULL;
  64         }
  65     } else if (arg == Py_None) {
  66         fp = NULL;
  67     } else {
  68         PyErr_SetString(PyExc_TypeError, "file object or None expected");
  69         return NULL;
  70     }
  71
  72     (void) rpmlogSetFile(fp);
  73     Py_RETURN_NONE;
  74 }
  75
  76 static PyObject *
  77 setVerbosity (PyObject * self, PyObject * arg)
  78 {
  79     int level;
  80
  81     if (!PyArg_Parse(arg, "i", &level))
  82         return NULL;
  83
  84     rpmSetVerbosity(level);
  85
  86     Py_RETURN_NONE;
  87 }
  88
  89 static PyObject *
  90 setEpochPromote (PyObject * self, PyObject * arg)
  91 {
  92     if (!PyArg_Parse(arg, "i", &_rpmds_nopromote))
  93         return NULL;
  94
  95     Py_RETURN_NONE;
  96 }
  97
  98 static PyObject * setStats (PyObject * self, PyObject * arg)
  99 {
 100     if (!PyArg_Parse(arg, "i", &_rpmts_stats))
 101         return NULL;
 102
 103     Py_RETURN_NONE;
 104 }
 105
 106 static PyObject * doLog(PyObject * self, PyObject * args, PyObject *kwds)
 107 {
 108     int code;
 109     const char *msg;
 110     char * kwlist[] = {"code", "msg", NULL};
 111     if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &code, &msg))
 112         return NULL;
 113
 114     rpmlog(code, "%s", msg);
 115     Py_RETURN_NONE;
 116 }
 117
 118 static PyObject * reloadConfig(PyObject * self, PyObject * args, PyObject *kwds)
 119 {
 120     const char * target = NULL;
 121     char * kwlist[] = { "target", NULL };
 122     int rc;
 123
 124     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s", kwlist, &target))
 125         return NULL;
 126
 127     rpmFreeMacros(NULL);
 128     rpmFreeRpmrc();
 129     rc = rpmReadConfigFiles(NULL, target) ;
 130
 131     return PyBool_FromLong(rc == 0);
 132 }
 133
 134 static PyMethodDef rpmModuleMethods[] = {
 135     { "addMacro", (PyCFunction) rpmmacro_AddMacro, METH_VARARGS|METH_KEYWORDS,
 136         NULL },
 137     { "delMacro", (PyCFunction) rpmmacro_DelMacro, METH_VARARGS|METH_KEYWORDS,
 138         NULL },
 139     { "expandMacro", (PyCFunction) rpmmacro_ExpandMacro, METH_VARARGS|METH_KEYWORDS,
 140         NULL },
 141
 142     { "archscore", (PyCFunction) archScore, METH_O,
 143         NULL },
 144
 145     { "signalCaught", (PyCFunction) signalCaught, METH_O,
 146         NULL },
 147     { "checkSignals", (PyCFunction) checkSignals, METH_NOARGS,
 148         NULL },
 149
 150     { "mergeHeaderListFromFD", (PyCFunction) rpmMergeHeadersFromFD, METH_VARARGS|METH_KEYWORDS,
 151         NULL },
 152
 153     { "log",            (PyCFunction) doLog, METH_VARARGS|METH_KEYWORDS,
 154         NULL },
 155     { "setLogFile", (PyCFunction) setLogFile, METH_O,
 156         NULL },
 157
 158     { "versionCompare", (PyCFunction) versionCompare, METH_VARARGS|METH_KEYWORDS,
 159         NULL },
 160     { "labelCompare", (PyCFunction) labelCompare, METH_VARARGS|METH_KEYWORDS,
 161         NULL },
 162     { "setVerbosity", (PyCFunction) setVerbosity, METH_O,
 163         NULL },
 164     { "setEpochPromote", (PyCFunction) setEpochPromote, METH_O,
 165         NULL },
 166     { "setStats", (PyCFunction) setStats, METH_O,
 167         NULL },
 168     { "reloadConfig", (PyCFunction) reloadConfig, METH_VARARGS|METH_KEYWORDS,
 169         NULL },
 170
 171     { NULL }
 172 } ;
 173
 174 /*
 175 * Force clean up of open iterators and dbs on exit.
 176 */
 177 static void rpm_exithook(void)
 178 {
 179    rpmdbCheckTerminate(1);
 180 }
 181
 182 static char rpm__doc__[] =
 183 "";
 184
 185 /*
 186  * Add rpm tag dictionaries to the module
 187  */
 188 static void addRpmTags(PyObject *module)
 189 {
 190     PyObject *pyval, *pyname, *dict = PyDict_New();
 191     rpmtd names = rpmtdNew();
 192     rpmTagGetNames(names, 1);
 193     const char *tagname, *shortname;
 194     rpmTagVal tagval;
 195
 196     while ((tagname = rpmtdNextString(names))) {
 197         shortname = tagname + strlen("RPMTAG_");
 198         tagval = rpmTagGetValue(shortname);
 199
 200         PyModule_AddIntConstant(module, tagname, tagval);
 201         pyval = PyInt_FromLong(tagval);
 202         pyname = Py_BuildValue("s", shortname);
 203         PyDict_SetItem(dict, pyval, pyname);
 204         Py_DECREF(pyval);
 205         Py_DECREF(pyname);
 206     }
 207     PyModule_AddObject(module, "tagnames", dict);
 208     rpmtdFreeData(names);
 209     rpmtdFree(names);
 210 }
 211
 212 /*
 213   Do any common preliminary work before python 2 vs python 3 module creation:
 214 */
 215 static int prepareInitModule(void)
 216 {
 217     if (PyType_Ready(&hdr_Type) < 0) return 0;
 218     if (PyType_Ready(&rpmds_Type) < 0) return 0;
 219     if (PyType_Ready(&rpmfd_Type) < 0) return 0;
 220     if (PyType_Ready(&rpmfi_Type) < 0) return 0;
 221     if (PyType_Ready(&rpmKeyring_Type) < 0) return 0;
 222     if (PyType_Ready(&rpmmi_Type) < 0) return 0;
 223     if (PyType_Ready(&rpmii_Type) < 0) return 0;
 224     if (PyType_Ready(&rpmProblem_Type) < 0) return 0;
 225     if (PyType_Ready(&rpmPubkey_Type) < 0) return 0;
 226 #if 0
 227     if (PyType_Ready(&rpmtd_Type) < 0) return 0;
 228 #endif
 229     if (PyType_Ready(&rpmte_Type) < 0) return 0;
 230     if (PyType_Ready(&rpmts_Type) < 0) return 0;
 231
 232     return 1;
 233 }
 234 static int initModule(PyObject *m);
 235
 236 #if PY_MAJOR_VERSION >= 3
 237 static int rpmModuleTraverse(PyObject *m, visitproc visit, void *arg) {
 238     Py_VISIT(pyrpmError);
 239     return 0;
 240 }
 241
 242 static int rpmModuleClear(PyObject *m) {
 243     Py_CLEAR(pyrpmError);
 244     return 0;
 245 }
 246
 247 static struct PyModuleDef moduledef = {
 248     PyModuleDef_HEAD_INIT,
 249     "_rpm",            /* m_name */
 250     rpm__doc__,        /* m_doc */
 251     0,                 /* m_size */
 252     rpmModuleMethods,
 253     NULL,              /* m_reload */
 254     rpmModuleTraverse,
 255     rpmModuleClear,
 256     NULL               /* m_free */
 257 };
 258
 259 PyObject *
 260 PyInit__rpm(void);
 261
 262 PyObject *
 263 PyInit__rpm(void)
 264 {
 265     PyObject * m;
 266     if (!prepareInitModule()) return NULL;
 267     m = PyModule_Create(&moduledef);
 268     initModule(m);
 269     return m;
 270 }
 271 #else
 272 void init_rpm(void);    /* XXX eliminate gcc warning */
 273 void init_rpm(void)
 274 {
 275     PyObject * m;
 276
 277     if (!prepareInitModule()) return;
 278     m = Py_InitModule3("_rpm", rpmModuleMethods, rpm__doc__);
 279     if (m == NULL)
 280         return;
 281     initModule(m);
 282 }
 283 #endif
 284
 285 /* Shared python2/3 module initialization: */
 286 static int initModule(PyObject *m)
 287 {
 288     PyObject * d;
 289
 290     /*
 291      * treat error to register rpm cleanup hook as fatal, tracebacks
 292      * can and will leave stale locks around if we can't clean up
 293      */
 294     if (Py_AtExit(rpm_exithook) == -1)
 295         return 0;
 296
 297     rpmReadConfigFiles(NULL, NULL);
 298
 299     d = PyModule_GetDict(m);
 300
 301     pyrpmError = PyErr_NewException("_rpm.error", NULL, NULL);
 302     if (pyrpmError != NULL)
 303         PyDict_SetItemString(d, "error", pyrpmError);
 304
 305     Py_INCREF(&hdr_Type);
 306     PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type);
 307
 308     Py_INCREF(&rpmds_Type);
 309     PyModule_AddObject(m, "ds", (PyObject *) &rpmds_Type);
 310
 311     Py_INCREF(&rpmfd_Type);
 312     PyModule_AddObject(m, "fd", (PyObject *) &rpmfd_Type);
 313
 314     Py_INCREF(&rpmfi_Type);
 315     PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_Type);
 316
 317     Py_INCREF(&rpmKeyring_Type);
 318     PyModule_AddObject(m, "keyring", (PyObject *) &rpmKeyring_Type);
 319
 320     Py_INCREF(&rpmmi_Type);
 321     PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type);
 322
 323     Py_INCREF(&rpmii_Type);
 324     PyModule_AddObject(m, "ii", (PyObject *) &rpmii_Type);
 325
 326     Py_INCREF(&rpmProblem_Type);
 327     PyModule_AddObject(m, "prob", (PyObject *) &rpmProblem_Type);
 328
 329     Py_INCREF(&rpmPubkey_Type);
 330     PyModule_AddObject(m, "pubkey", (PyObject *) &rpmPubkey_Type);
 331
 332 #if 0
 333     Py_INCREF(&rpmtd_Type);
 334     PyModule_AddObject(m, "td", (PyObject *) &rpmtd_Type);
 335 #endif
 336
 337     Py_INCREF(&rpmte_Type);
 338     PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type);
 339
 340     Py_INCREF(&rpmts_Type);
 341     PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
 342
 343     addRpmTags(m);
 344
 345     PyModule_AddStringConstant(m, "__version__", RPMVERSION);
 346
 347 #define REGISTER_ENUM(val) PyModule_AddIntConstant(m, #val, val)
 348
 349     REGISTER_ENUM(RPMTAG_NOT_FOUND);
 350
 351     REGISTER_ENUM(RPMRC_OK);
 352     REGISTER_ENUM(RPMRC_NOTFOUND);
 353     REGISTER_ENUM(RPMRC_FAIL);
 354     REGISTER_ENUM(RPMRC_NOTTRUSTED);
 355     REGISTER_ENUM(RPMRC_NOKEY);
 356
 357     REGISTER_ENUM(RPMFILE_STATE_NORMAL);
 358     REGISTER_ENUM(RPMFILE_STATE_REPLACED);
 359     REGISTER_ENUM(RPMFILE_STATE_NOTINSTALLED);
 360     REGISTER_ENUM(RPMFILE_STATE_NETSHARED);
 361     REGISTER_ENUM(RPMFILE_STATE_WRONGCOLOR);
 362
 363     REGISTER_ENUM(RPMFILE_CONFIG);
 364     REGISTER_ENUM(RPMFILE_DOC);
 365     REGISTER_ENUM(RPMFILE_MISSINGOK);
 366     REGISTER_ENUM(RPMFILE_NOREPLACE);
 367     REGISTER_ENUM(RPMFILE_GHOST);
 368     REGISTER_ENUM(RPMFILE_LICENSE);
 369     REGISTER_ENUM(RPMFILE_README);
 370     REGISTER_ENUM(RPMFILE_PUBKEY);
 371
 372     REGISTER_ENUM(RPMDEP_SENSE_REQUIRES);
 373     REGISTER_ENUM(RPMDEP_SENSE_CONFLICTS);
 374
 375     REGISTER_ENUM(RPMSENSE_ANY);
 376     REGISTER_ENUM(RPMSENSE_LESS);
 377     REGISTER_ENUM(RPMSENSE_GREATER);
 378     REGISTER_ENUM(RPMSENSE_EQUAL);
 379     REGISTER_ENUM(RPMSENSE_POSTTRANS);
 380     REGISTER_ENUM(RPMSENSE_PREREQ);
 381     REGISTER_ENUM(RPMSENSE_PRETRANS);
 382     REGISTER_ENUM(RPMSENSE_INTERP);
 383     REGISTER_ENUM(RPMSENSE_SCRIPT_PRE);
 384     REGISTER_ENUM(RPMSENSE_SCRIPT_POST);
 385     REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN);
 386     REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN);
 387     REGISTER_ENUM(RPMSENSE_SCRIPT_VERIFY);
 388     REGISTER_ENUM(RPMSENSE_FIND_REQUIRES);
 389     REGISTER_ENUM(RPMSENSE_FIND_PROVIDES);
 390     REGISTER_ENUM(RPMSENSE_TRIGGERIN);
 391     REGISTER_ENUM(RPMSENSE_TRIGGERUN);
 392     REGISTER_ENUM(RPMSENSE_TRIGGERPOSTUN);
 393     REGISTER_ENUM(RPMSENSE_RPMLIB);
 394     REGISTER_ENUM(RPMSENSE_TRIGGERPREIN);
 395     REGISTER_ENUM(RPMSENSE_KEYRING);
 396     REGISTER_ENUM(RPMSENSE_STRONG);
 397     REGISTER_ENUM(RPMSENSE_CONFIG);
 398
 399     REGISTER_ENUM(RPMTRANS_FLAG_TEST);
 400     REGISTER_ENUM(RPMTRANS_FLAG_BUILD_PROBS);
 401     REGISTER_ENUM(RPMTRANS_FLAG_NOSCRIPTS);
 402     REGISTER_ENUM(RPMTRANS_FLAG_JUSTDB);
 403     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERS);
 404     REGISTER_ENUM(RPMTRANS_FLAG_NODOCS);
 405     REGISTER_ENUM(RPMTRANS_FLAG_ALLFILES);
 406     REGISTER_ENUM(RPMTRANS_FLAG_KEEPOBSOLETE);
 407     REGISTER_ENUM(RPMTRANS_FLAG_NOCONTEXTS);
 408     REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE);
 409     REGISTER_ENUM(RPMTRANS_FLAG_REVERSE);
 410     REGISTER_ENUM(RPMTRANS_FLAG_NOPRE);
 411     REGISTER_ENUM(RPMTRANS_FLAG_NOPOST);
 412     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPREIN);
 413     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERIN);
 414     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERUN);
 415     REGISTER_ENUM(RPMTRANS_FLAG_NOPREUN);
 416     REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTUN);
 417     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPOSTUN);
 418     REGISTER_ENUM(RPMTRANS_FLAG_NOMD5);
 419     REGISTER_ENUM(RPMTRANS_FLAG_NOFILEDIGEST);
 420     REGISTER_ENUM(RPMTRANS_FLAG_NOSUGGEST);
 421     REGISTER_ENUM(RPMTRANS_FLAG_ADDINDEPS);
 422     REGISTER_ENUM(RPMTRANS_FLAG_NOCONFIGS);
 423
 424     REGISTER_ENUM(RPMPROB_FILTER_IGNOREOS);
 425     REGISTER_ENUM(RPMPROB_FILTER_IGNOREARCH);
 426     REGISTER_ENUM(RPMPROB_FILTER_REPLACEPKG);
 427     REGISTER_ENUM(RPMPROB_FILTER_FORCERELOCATE);
 428     REGISTER_ENUM(RPMPROB_FILTER_REPLACENEWFILES);
 429     REGISTER_ENUM(RPMPROB_FILTER_REPLACEOLDFILES);
 430     REGISTER_ENUM(RPMPROB_FILTER_OLDPACKAGE);
 431     REGISTER_ENUM(RPMPROB_FILTER_DISKSPACE);
 432     REGISTER_ENUM(RPMPROB_FILTER_DISKNODES);
 433
 434     REGISTER_ENUM(RPMCALLBACK_UNKNOWN);
 435     REGISTER_ENUM(RPMCALLBACK_INST_PROGRESS);
 436     REGISTER_ENUM(RPMCALLBACK_INST_START);
 437     REGISTER_ENUM(RPMCALLBACK_INST_OPEN_FILE);
 438     REGISTER_ENUM(RPMCALLBACK_INST_CLOSE_FILE);
 439     REGISTER_ENUM(RPMCALLBACK_TRANS_PROGRESS);
 440     REGISTER_ENUM(RPMCALLBACK_TRANS_START);
 441     REGISTER_ENUM(RPMCALLBACK_TRANS_STOP);
 442     REGISTER_ENUM(RPMCALLBACK_UNINST_PROGRESS);
 443     REGISTER_ENUM(RPMCALLBACK_UNINST_START);
 444     REGISTER_ENUM(RPMCALLBACK_UNINST_STOP);
 445     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_PROGRESS);
 446     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_START);
 447     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_STOP);
 448     REGISTER_ENUM(RPMCALLBACK_UNPACK_ERROR);
 449     REGISTER_ENUM(RPMCALLBACK_CPIO_ERROR);
 450     REGISTER_ENUM(RPMCALLBACK_SCRIPT_ERROR);
 451     REGISTER_ENUM(RPMCALLBACK_SCRIPT_START);
 452     REGISTER_ENUM(RPMCALLBACK_SCRIPT_STOP);
 453     REGISTER_ENUM(RPMCALLBACK_INST_STOP);
 454
 455     REGISTER_ENUM(RPMPROB_BADARCH);
 456     REGISTER_ENUM(RPMPROB_BADOS);
 457     REGISTER_ENUM(RPMPROB_PKG_INSTALLED);
 458     REGISTER_ENUM(RPMPROB_BADRELOCATE);
 459     REGISTER_ENUM(RPMPROB_REQUIRES);
 460     REGISTER_ENUM(RPMPROB_CONFLICT);
 461     REGISTER_ENUM(RPMPROB_NEW_FILE_CONFLICT);
 462     REGISTER_ENUM(RPMPROB_FILE_CONFLICT);
 463     REGISTER_ENUM(RPMPROB_OLDPACKAGE);
 464     REGISTER_ENUM(RPMPROB_DISKSPACE);
 465     REGISTER_ENUM(RPMPROB_DISKNODES);
 466     REGISTER_ENUM(RPMPROB_OBSOLETES);
 467
 468     REGISTER_ENUM(VERIFY_DIGEST);
 469     REGISTER_ENUM(VERIFY_SIGNATURE);
 470
 471     REGISTER_ENUM(RPMLOG_EMERG);
 472     REGISTER_ENUM(RPMLOG_ALERT);
 473     REGISTER_ENUM(RPMLOG_CRIT);
 474     REGISTER_ENUM(RPMLOG_ERR);
 475     REGISTER_ENUM(RPMLOG_WARNING);
 476     REGISTER_ENUM(RPMLOG_NOTICE);
 477     REGISTER_ENUM(RPMLOG_INFO);
 478     REGISTER_ENUM(RPMLOG_DEBUG);
 479
 480     REGISTER_ENUM(RPMMIRE_DEFAULT);
 481     REGISTER_ENUM(RPMMIRE_STRCMP);
 482     REGISTER_ENUM(RPMMIRE_REGEX);
 483     REGISTER_ENUM(RPMMIRE_GLOB);
 484
 485     REGISTER_ENUM(RPMVSF_DEFAULT);
 486     REGISTER_ENUM(RPMVSF_NOHDRCHK);
 487     REGISTER_ENUM(RPMVSF_NEEDPAYLOAD);
 488     REGISTER_ENUM(RPMVSF_NOSHA1HEADER);
 489     REGISTER_ENUM(RPMVSF_NOMD5HEADER);
 490     REGISTER_ENUM(RPMVSF_NODSAHEADER);
 491     REGISTER_ENUM(RPMVSF_NORSAHEADER);
 492     REGISTER_ENUM(RPMVSF_NOSHA1);
 493     REGISTER_ENUM(RPMVSF_NOMD5);
 494     REGISTER_ENUM(RPMVSF_NODSA);
 495     REGISTER_ENUM(RPMVSF_NORSA);
 496     REGISTER_ENUM(_RPMVSF_NODIGESTS);
 497     REGISTER_ENUM(_RPMVSF_NOSIGNATURES);
 498     REGISTER_ENUM(_RPMVSF_NOHEADER);
 499     REGISTER_ENUM(_RPMVSF_NOPAYLOAD);
 500
 501     REGISTER_ENUM(TR_ADDED);
 502     REGISTER_ENUM(TR_REMOVED);
 503
 504     REGISTER_ENUM(RPMDBI_PACKAGES);
 505     REGISTER_ENUM(RPMDBI_LABEL);
 506     REGISTER_ENUM(RPMDBI_INSTFILENAMES);
 507     REGISTER_ENUM(RPMDBI_NAME);
 508     REGISTER_ENUM(RPMDBI_BASENAMES);
 509     REGISTER_ENUM(RPMDBI_GROUP);
 510     REGISTER_ENUM(RPMDBI_REQUIRENAME);
 511     REGISTER_ENUM(RPMDBI_PROVIDENAME);
 512     REGISTER_ENUM(RPMDBI_CONFLICTNAME);
 513     REGISTER_ENUM(RPMDBI_OBSOLETENAME);
 514     REGISTER_ENUM(RPMDBI_TRIGGERNAME);
 515     REGISTER_ENUM(RPMDBI_DIRNAMES);
 516     REGISTER_ENUM(RPMDBI_INSTALLTID);
 517     REGISTER_ENUM(RPMDBI_SIGMD5);
 518     REGISTER_ENUM(RPMDBI_SHA1HEADER);
 519
 520     REGISTER_ENUM(HEADERCONV_EXPANDFILELIST);
 521     REGISTER_ENUM(HEADERCONV_COMPRESSFILELIST);
 522     REGISTER_ENUM(HEADERCONV_RETROFIT_V3);
 523
 524     return 1;
 525 }
 526