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 "rpmarchive-py.h"
  12 #include "rpmds-py.h"
  13 #include "rpmfd-py.h"
  14 #include "rpmfi-py.h"
  15 #include "rpmfiles-py.h"
  16 #include "rpmkeyring-py.h"
  17 #include "rpmmi-py.h"
  18 #include "rpmii-py.h"
  19 #include "rpmps-py.h"
  20 #include "rpmmacro-py.h"
  21 #include "rpmstrpool-py.h"
  22 #include "rpmtd-py.h"
  23 #include "rpmte-py.h"
  24 #include "rpmts-py.h"
  25
  26 /** \ingroup python
  27  * \name Module: rpm
  28  */
  29
  30 PyObject * pyrpmError;
  31
  32 static PyObject * archScore(PyObject * self, PyObject * arg)
  33 {
  34     const char * arch;
  35
  36     if (!PyArg_Parse(arg, "s", &arch))
  37         return NULL;
  38
  39     return Py_BuildValue("i", rpmMachineScore(RPM_MACHTABLE_INSTARCH, arch));
  40 }
  41
  42 static PyObject * signalCaught(PyObject *self, PyObject *o)
  43 {
  44     int signo;
  45     if (!PyArg_Parse(o, "i", &signo)) return NULL;
  46
  47     return PyBool_FromLong(rpmsqIsCaught(signo));
  48 }
  49
  50 static PyObject * checkSignals(PyObject * self)
  51 {
  52     return Py_BuildValue("i", rpmsqPoll());
  53 }
  54
  55 static PyObject * blockSignals(PyObject * self, PyObject *arg)
  56 {
  57     int block;
  58     if (!PyArg_Parse(arg, "p", &block)) return NULL;
  59
  60     return Py_BuildValue("i", rpmsqBlock(block ? SIG_BLOCK : SIG_UNBLOCK));
  61 }
  62
  63
  64 static PyObject * setLogFile (PyObject * self, PyObject *arg)
  65 {
  66     FILE *fp;
  67     int fdno = PyObject_AsFileDescriptor(arg);
  68
  69     if (fdno >= 0) {
  70         /* XXX we dont know the mode here.. guessing append for now */
  71         fp = fdopen(fdno, "a");
  72         if (fp == NULL) {
  73             PyErr_SetFromErrno(PyExc_IOError);
  74             return NULL;
  75         }
  76     } else if (arg == Py_None) {
  77         fp = NULL;
  78     } else {
  79         PyErr_SetString(PyExc_TypeError, "file object or None expected");
  80         return NULL;
  81     }
  82
  83     (void) rpmlogSetFile(fp);
  84     Py_RETURN_NONE;
  85 }
  86
  87 static PyObject *
  88 setVerbosity (PyObject * self, PyObject * arg)
  89 {
  90     int level;
  91
  92     if (!PyArg_Parse(arg, "i", &level))
  93         return NULL;
  94
  95     rpmSetVerbosity(level);
  96
  97     Py_RETURN_NONE;
  98 }
  99
 100 static PyObject *
 101 setEpochPromote (PyObject * self, PyObject * arg)
 102 {
 103     if (!PyArg_Parse(arg, "i", &_rpmds_nopromote))
 104         return NULL;
 105
 106     Py_RETURN_NONE;
 107 }
 108
 109 static PyObject * setStats (PyObject * self, PyObject * arg)
 110 {
 111     if (!PyArg_Parse(arg, "i", &_rpmts_stats))
 112         return NULL;
 113
 114     Py_RETURN_NONE;
 115 }
 116
 117 static PyObject * doLog(PyObject * self, PyObject * args, PyObject *kwds)
 118 {
 119     int code;
 120     const char *msg;
 121     char * kwlist[] = {"code", "msg", NULL};
 122     if (!PyArg_ParseTupleAndKeywords(args, kwds, "is", kwlist, &code, &msg))
 123         return NULL;
 124
 125     rpmlog(code, "%s", msg);
 126     Py_RETURN_NONE;
 127 }
 128
 129 static PyObject * reloadConfig(PyObject * self, PyObject * args, PyObject *kwds)
 130 {
 131     const char * target = NULL;
 132     char * kwlist[] = { "target", NULL };
 133     int rc;
 134
 135     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|s", kwlist, &target))
 136         return NULL;
 137
 138     rpmFreeMacros(NULL);
 139     rpmFreeRpmrc();
 140     rc = rpmReadConfigFiles(NULL, target) ;
 141
 142     return PyBool_FromLong(rc == 0);
 143 }
 144
 145 static PyObject * setInterruptSafety(PyObject * self, PyObject * args, PyObject *kwds)
 146 {
 147     int on = 1;
 148     PyObject * obj;
 149     char * kwlist[] = { "on", NULL };
 150     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O", kwlist, &obj))
 151         return NULL;
 152     if (obj) {
 153         on = PyObject_IsTrue(obj);
 154     }
 155     rpmsqSetInterruptSafety(on);
 156     Py_RETURN_NONE;
 157 }
 158
 159 static PyMethodDef rpmModuleMethods[] = {
 160     { "addMacro", (PyCFunction) rpmmacro_AddMacro, METH_VARARGS|METH_KEYWORDS,
 161       "rpmPushMacro(macro, value)\n"
 162     },
 163     { "delMacro", (PyCFunction) rpmmacro_DelMacro, METH_VARARGS|METH_KEYWORDS,
 164       "rpmPopMacro(macro)\n"
 165     },
 166     { "expandMacro", (PyCFunction) rpmmacro_ExpandMacro, METH_VARARGS|METH_KEYWORDS,
 167       "expandMacro(string, numeric=False) -- expands a string containing macros\n\n"
 168       "Returns an int if numeric is True. 'Y' or 'y' returns 1,\n'N' or 'n' returns 0\nAn undefined macro returns 0."},
 169
 170     { "archscore", (PyCFunction) archScore, METH_O,
 171       "archscore(archname) -- How well does an architecture fit on this machine\n\n"
 172       "0 for non matching arch names\n1 for best arch\nhigher numbers for less fitting arches\n(e.g. 2 for \"i586\" on an i686 machine)" },
 173
 174     { "signalCaught", (PyCFunction) signalCaught, METH_O,
 175         "signalCaught(signo) -- Returns True if signal was caught." },
 176     { "checkSignals", (PyCFunction) checkSignals, METH_NOARGS,
 177       "checkSignals() -- Check for and exit on termination signals."},
 178     { "blockSignals", (PyCFunction) blockSignals, METH_O,
 179       "blocksignals(True/False) -- Block/unblock signals, refcounted."},
 180
 181     { "mergeHeaderListFromFD", (PyCFunction) rpmMergeHeadersFromFD, METH_VARARGS|METH_KEYWORDS,
 182         NULL },
 183
 184     { "log",            (PyCFunction) doLog, METH_VARARGS|METH_KEYWORDS,
 185         "log(level, msg) -- Write msg to log if level is selected to be logged.\n\n"
 186     "level must be one of the RPMLOG_* constants."},
 187     { "setLogFile", (PyCFunction) setLogFile, METH_O,
 188         "setLogFile(file) -- set file to write log messages to or None." },
 189
 190     { "versionCompare", (PyCFunction) versionCompare, METH_VARARGS|METH_KEYWORDS,
 191       "versionCompare(version0, version1) -- compares two version strings\n\n"
 192       "Returns 1 if version0 > version1\n"
 193       "Returns 0 if version0 == version1\n"
 194       "Returns -1 if version0 < version1\n"},
 195     { "labelCompare", (PyCFunction) labelCompare, METH_VARARGS|METH_KEYWORDS,
 196       "labelCompare(version0, version1) -- as versionCompare()\n\n"
 197       "but arguments are tuples of of strings for (epoch, version, release)"},
 198     { "setVerbosity", (PyCFunction) setVerbosity, METH_O,
 199       "setVerbosity(level) -- Set log level. See RPMLOG_* constants." },
 200     { "setEpochPromote", (PyCFunction) setEpochPromote, METH_O,
 201         "setEpochPromote(bool) -- Set if no epoch shall be treated as epoch 0" },
 202     { "setStats", (PyCFunction) setStats, METH_O,
 203       "setStats(bool) -- Set if timing stats are printed after a transaction."},
 204     { "reloadConfig", (PyCFunction) reloadConfig, METH_VARARGS|METH_KEYWORDS,
 205       "reloadConfig(target=None) -- Reload config from files.\n\n"
 206       "Set all macros and settings accordingly."},
 207
 208     { "setInterruptSafety", (PyCFunction) setInterruptSafety,
 209       METH_VARARGS|METH_KEYWORDS,
 210       "setInterruptSafety(on=True) -- Set if various signals get intercepted.\n\n"
 211       "By default, librpm will trap various unix signals (like SIGINT and\n"
 212       "SIGTERM), in order to avoid process exit while locks are held or\n"
 213       "a transaction is being performed.\n\n"
 214       "If this is not the desired behaviour it's recommended to call this\n"
 215       "once only at process startup because currently signal handlers will\n"
 216       "not be retroactively applied if a database is open."
 217     },
 218     { NULL }
 219 } ;
 220
 221 static char rpm__doc__[] = "";
 222
 223 /*
 224  * Add rpm tag dictionaries to the module
 225  */
 226 static void addRpmTags(PyObject *module)
 227 {
 228     PyObject *pyval, *pyname, *dict = PyDict_New();
 229     rpmtd names = rpmtdNew();
 230     rpmTagGetNames(names, 1);
 231     const char *tagname, *shortname;
 232     rpmTagVal tagval;
 233
 234     while ((tagname = rpmtdNextString(names))) {
 235         shortname = tagname + strlen("RPMTAG_");
 236         tagval = rpmTagGetValue(shortname);
 237
 238         PyModule_AddIntConstant(module, tagname, tagval);
 239         pyval = PyInt_FromLong(tagval);
 240         pyname = Py_BuildValue("s", shortname);
 241         PyDict_SetItem(dict, pyval, pyname);
 242         Py_DECREF(pyval);
 243         Py_DECREF(pyname);
 244     }
 245     PyModule_AddObject(module, "tagnames", dict);
 246     rpmtdFree(names);
 247 }
 248
 249 /*
 250   Do any common preliminary work before python 2 vs python 3 module creation:
 251 */
 252 static int prepareInitModule(void)
 253 {
 254     if (PyType_Ready(&hdr_Type) < 0) return 0;
 255     if (PyType_Ready(&rpmarchive_Type) < 0) return 0;
 256     if (PyType_Ready(&rpmds_Type) < 0) return 0;
 257     if (PyType_Ready(&rpmfd_Type) < 0) return 0;
 258     if (PyType_Ready(&rpmfi_Type) < 0) return 0;
 259     if (PyType_Ready(&rpmfile_Type) < 0) return 0;
 260     if (PyType_Ready(&rpmfiles_Type) < 0) return 0;
 261     if (PyType_Ready(&rpmKeyring_Type) < 0) return 0;
 262     if (PyType_Ready(&rpmmi_Type) < 0) return 0;
 263     if (PyType_Ready(&rpmii_Type) < 0) return 0;
 264     if (PyType_Ready(&rpmProblem_Type) < 0) return 0;
 265     if (PyType_Ready(&rpmPubkey_Type) < 0) return 0;
 266     if (PyType_Ready(&rpmstrPool_Type) < 0) return 0;
 267 #if 0
 268     if (PyType_Ready(&rpmtd_Type) < 0) return 0;
 269 #endif
 270     if (PyType_Ready(&rpmte_Type) < 0) return 0;
 271     if (PyType_Ready(&rpmts_Type) < 0) return 0;
 272
 273     return 1;
 274 }
 275 static int initModule(PyObject *m);
 276
 277 #if PY_MAJOR_VERSION >= 3
 278 static int rpmModuleTraverse(PyObject *m, visitproc visit, void *arg) {
 279     Py_VISIT(pyrpmError);
 280     return 0;
 281 }
 282
 283 static int rpmModuleClear(PyObject *m) {
 284     Py_CLEAR(pyrpmError);
 285     return 0;
 286 }
 287
 288 static struct PyModuleDef moduledef = {
 289     PyModuleDef_HEAD_INIT,
 290     "_rpm",            /* m_name */
 291     rpm__doc__,        /* m_doc */
 292     0,                 /* m_size */
 293     rpmModuleMethods,
 294     NULL,              /* m_reload */
 295     rpmModuleTraverse,
 296     rpmModuleClear,
 297     NULL               /* m_free */
 298 };
 299
 300 PyObject *
 301 PyInit__rpm(void);
 302
 303 PyObject *
 304 PyInit__rpm(void)
 305 {
 306     PyObject * m;
 307     if (!prepareInitModule()) return NULL;
 308     m = PyModule_Create(&moduledef);
 309     initModule(m);
 310     return m;
 311 }
 312 #else
 313 void init_rpm(void);    /* XXX eliminate gcc warning */
 314 void init_rpm(void)
 315 {
 316     PyObject * m;
 317
 318     if (!prepareInitModule()) return;
 319     m = Py_InitModule3("_rpm", rpmModuleMethods, rpm__doc__);
 320     if (m == NULL)
 321         return;
 322     initModule(m);
 323 }
 324 #endif
 325
 326 /* Shared python2/3 module initialization: */
 327 static int initModule(PyObject *m)
 328 {
 329     PyObject * d;
 330
 331     /* failure to initialize rpm (crypto and all) is rather fatal too... */
 332     if (rpmReadConfigFiles(NULL, NULL) == -1)
 333         return 0;
 334
 335     d = PyModule_GetDict(m);
 336
 337     pyrpmError = PyErr_NewException("_rpm.error", NULL, NULL);
 338     if (pyrpmError != NULL)
 339         PyDict_SetItemString(d, "error", pyrpmError);
 340
 341     Py_INCREF(&hdr_Type);
 342     PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type);
 343
 344     Py_INCREF(&rpmarchive_Type);
 345     PyModule_AddObject(m, "archive", (PyObject *) &rpmarchive_Type);
 346
 347     Py_INCREF(&rpmds_Type);
 348     PyModule_AddObject(m, "ds", (PyObject *) &rpmds_Type);
 349
 350     Py_INCREF(&rpmfd_Type);
 351     PyModule_AddObject(m, "fd", (PyObject *) &rpmfd_Type);
 352
 353     Py_INCREF(&rpmfi_Type);
 354     PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_Type);
 355
 356     Py_INCREF(&rpmfile_Type);
 357     PyModule_AddObject(m, "file", (PyObject *) &rpmfile_Type);
 358
 359     Py_INCREF(&rpmfiles_Type);
 360     PyModule_AddObject(m, "files", (PyObject *) &rpmfiles_Type);
 361
 362     Py_INCREF(&rpmKeyring_Type);
 363     PyModule_AddObject(m, "keyring", (PyObject *) &rpmKeyring_Type);
 364
 365     Py_INCREF(&rpmmi_Type);
 366     PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type);
 367
 368     Py_INCREF(&rpmii_Type);
 369     PyModule_AddObject(m, "ii", (PyObject *) &rpmii_Type);
 370
 371     Py_INCREF(&rpmProblem_Type);
 372     PyModule_AddObject(m, "prob", (PyObject *) &rpmProblem_Type);
 373
 374     Py_INCREF(&rpmPubkey_Type);
 375     PyModule_AddObject(m, "pubkey", (PyObject *) &rpmPubkey_Type);
 376
 377     Py_INCREF(&rpmstrPool_Type);
 378     PyModule_AddObject(m, "strpool", (PyObject *) &rpmstrPool_Type);
 379
 380 #if 0
 381     Py_INCREF(&rpmtd_Type);
 382     PyModule_AddObject(m, "td", (PyObject *) &rpmtd_Type);
 383 #endif
 384
 385     Py_INCREF(&rpmte_Type);
 386     PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type);
 387
 388     Py_INCREF(&rpmts_Type);
 389     PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
 390
 391     addRpmTags(m);
 392
 393     PyModule_AddStringConstant(m, "__version__", RPMVERSION);
 394
 395     PyModule_AddObject(m, "header_magic",
 396                 PyBytes_FromStringAndSize((const char *)rpm_header_magic, 8));
 397
 398 #define REGISTER_ENUM(val) PyModule_AddIntConstant(m, #val, val)
 399
 400     REGISTER_ENUM(RPMTAG_NOT_FOUND);
 401
 402     REGISTER_ENUM(RPMRC_OK);
 403     REGISTER_ENUM(RPMRC_NOTFOUND);
 404     REGISTER_ENUM(RPMRC_FAIL);
 405     REGISTER_ENUM(RPMRC_NOTTRUSTED);
 406     REGISTER_ENUM(RPMRC_NOKEY);
 407
 408     REGISTER_ENUM(RPMFILE_STATE_NORMAL);
 409     REGISTER_ENUM(RPMFILE_STATE_REPLACED);
 410     REGISTER_ENUM(RPMFILE_STATE_NOTINSTALLED);
 411     REGISTER_ENUM(RPMFILE_STATE_NETSHARED);
 412     REGISTER_ENUM(RPMFILE_STATE_WRONGCOLOR);
 413
 414     REGISTER_ENUM(RPMFILE_CONFIG);
 415     REGISTER_ENUM(RPMFILE_DOC);
 416     REGISTER_ENUM(RPMFILE_ICON);
 417     REGISTER_ENUM(RPMFILE_MISSINGOK);
 418     REGISTER_ENUM(RPMFILE_NOREPLACE);
 419     REGISTER_ENUM(RPMFILE_SPECFILE);
 420     REGISTER_ENUM(RPMFILE_GHOST);
 421     REGISTER_ENUM(RPMFILE_LICENSE);
 422     REGISTER_ENUM(RPMFILE_README);
 423     REGISTER_ENUM(RPMFILE_PUBKEY);
 424     REGISTER_ENUM(RPMFILE_ARTIFACT);
 425
 426     REGISTER_ENUM(RPMDEP_SENSE_REQUIRES);
 427     REGISTER_ENUM(RPMDEP_SENSE_CONFLICTS);
 428
 429     REGISTER_ENUM(RPMSENSE_ANY);
 430     REGISTER_ENUM(RPMSENSE_LESS);
 431     REGISTER_ENUM(RPMSENSE_GREATER);
 432     REGISTER_ENUM(RPMSENSE_EQUAL);
 433     REGISTER_ENUM(RPMSENSE_POSTTRANS);
 434     REGISTER_ENUM(RPMSENSE_PREREQ);
 435     REGISTER_ENUM(RPMSENSE_PRETRANS);
 436     REGISTER_ENUM(RPMSENSE_INTERP);
 437     REGISTER_ENUM(RPMSENSE_SCRIPT_PRE);
 438     REGISTER_ENUM(RPMSENSE_SCRIPT_POST);
 439     REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN);
 440     REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN);
 441     REGISTER_ENUM(RPMSENSE_SCRIPT_VERIFY);
 442     REGISTER_ENUM(RPMSENSE_FIND_REQUIRES);
 443     REGISTER_ENUM(RPMSENSE_FIND_PROVIDES);
 444     REGISTER_ENUM(RPMSENSE_TRIGGERIN);
 445     REGISTER_ENUM(RPMSENSE_TRIGGERUN);
 446     REGISTER_ENUM(RPMSENSE_TRIGGERPOSTUN);
 447     REGISTER_ENUM(RPMSENSE_RPMLIB);
 448     REGISTER_ENUM(RPMSENSE_TRIGGERPREIN);
 449     REGISTER_ENUM(RPMSENSE_KEYRING);
 450     REGISTER_ENUM(RPMSENSE_STRONG);
 451     REGISTER_ENUM(RPMSENSE_CONFIG);
 452     REGISTER_ENUM(RPMSENSE_MISSINGOK);
 453
 454     REGISTER_ENUM(RPMTRANS_FLAG_TEST);
 455     REGISTER_ENUM(RPMTRANS_FLAG_BUILD_PROBS);
 456     REGISTER_ENUM(RPMTRANS_FLAG_NOSCRIPTS);
 457     REGISTER_ENUM(RPMTRANS_FLAG_JUSTDB);
 458     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERS);
 459     REGISTER_ENUM(RPMTRANS_FLAG_NODOCS);
 460     REGISTER_ENUM(RPMTRANS_FLAG_ALLFILES);
 461     REGISTER_ENUM(RPMTRANS_FLAG_NOPLUGINS);
 462     REGISTER_ENUM(RPMTRANS_FLAG_KEEPOBSOLETE);
 463     REGISTER_ENUM(RPMTRANS_FLAG_NOCONTEXTS);
 464     REGISTER_ENUM(RPMTRANS_FLAG_NOCAPS);
 465     REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE);
 466     REGISTER_ENUM(RPMTRANS_FLAG_REVERSE);
 467     REGISTER_ENUM(RPMTRANS_FLAG_NOPRE);
 468     REGISTER_ENUM(RPMTRANS_FLAG_NOPOST);
 469     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPREIN);
 470     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERIN);
 471     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERUN);
 472     REGISTER_ENUM(RPMTRANS_FLAG_NOPREUN);
 473     REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTUN);
 474     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPOSTUN);
 475     REGISTER_ENUM(RPMTRANS_FLAG_NOPRETRANS);
 476     REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTTRANS);
 477     REGISTER_ENUM(RPMTRANS_FLAG_NOMD5);
 478     REGISTER_ENUM(RPMTRANS_FLAG_NOFILEDIGEST);
 479     REGISTER_ENUM(RPMTRANS_FLAG_NOSUGGEST);
 480     REGISTER_ENUM(RPMTRANS_FLAG_ADDINDEPS);
 481     REGISTER_ENUM(RPMTRANS_FLAG_NOCONFIGS);
 482     REGISTER_ENUM(RPMTRANS_FLAG_DEPLOOPS);
 483
 484     REGISTER_ENUM(RPMPROB_FILTER_IGNOREOS);
 485     REGISTER_ENUM(RPMPROB_FILTER_IGNOREARCH);
 486     REGISTER_ENUM(RPMPROB_FILTER_REPLACEPKG);
 487     REGISTER_ENUM(RPMPROB_FILTER_FORCERELOCATE);
 488     REGISTER_ENUM(RPMPROB_FILTER_REPLACENEWFILES);
 489     REGISTER_ENUM(RPMPROB_FILTER_REPLACEOLDFILES);
 490     REGISTER_ENUM(RPMPROB_FILTER_OLDPACKAGE);
 491     REGISTER_ENUM(RPMPROB_FILTER_DISKSPACE);
 492     REGISTER_ENUM(RPMPROB_FILTER_DISKNODES);
 493
 494     REGISTER_ENUM(RPMCALLBACK_UNKNOWN);
 495     REGISTER_ENUM(RPMCALLBACK_INST_PROGRESS);
 496     REGISTER_ENUM(RPMCALLBACK_INST_START);
 497     REGISTER_ENUM(RPMCALLBACK_INST_OPEN_FILE);
 498     REGISTER_ENUM(RPMCALLBACK_INST_CLOSE_FILE);
 499     REGISTER_ENUM(RPMCALLBACK_TRANS_PROGRESS);
 500     REGISTER_ENUM(RPMCALLBACK_TRANS_START);
 501     REGISTER_ENUM(RPMCALLBACK_TRANS_STOP);
 502     REGISTER_ENUM(RPMCALLBACK_UNINST_PROGRESS);
 503     REGISTER_ENUM(RPMCALLBACK_UNINST_START);
 504     REGISTER_ENUM(RPMCALLBACK_UNINST_STOP);
 505     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_PROGRESS);
 506     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_START);
 507     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_STOP);
 508     REGISTER_ENUM(RPMCALLBACK_UNPACK_ERROR);
 509     REGISTER_ENUM(RPMCALLBACK_CPIO_ERROR);
 510     REGISTER_ENUM(RPMCALLBACK_SCRIPT_ERROR);
 511     REGISTER_ENUM(RPMCALLBACK_SCRIPT_START);
 512     REGISTER_ENUM(RPMCALLBACK_SCRIPT_STOP);
 513     REGISTER_ENUM(RPMCALLBACK_INST_STOP);
 514     REGISTER_ENUM(RPMCALLBACK_ELEM_PROGRESS);
 515
 516     REGISTER_ENUM(RPMPROB_BADARCH);
 517     REGISTER_ENUM(RPMPROB_BADOS);
 518     REGISTER_ENUM(RPMPROB_PKG_INSTALLED);
 519     REGISTER_ENUM(RPMPROB_BADRELOCATE);
 520     REGISTER_ENUM(RPMPROB_REQUIRES);
 521     REGISTER_ENUM(RPMPROB_CONFLICT);
 522     REGISTER_ENUM(RPMPROB_NEW_FILE_CONFLICT);
 523     REGISTER_ENUM(RPMPROB_FILE_CONFLICT);
 524     REGISTER_ENUM(RPMPROB_OLDPACKAGE);
 525     REGISTER_ENUM(RPMPROB_DISKSPACE);
 526     REGISTER_ENUM(RPMPROB_DISKNODES);
 527     REGISTER_ENUM(RPMPROB_OBSOLETES);
 528
 529     REGISTER_ENUM(VERIFY_DIGEST);
 530     REGISTER_ENUM(VERIFY_SIGNATURE);
 531
 532     REGISTER_ENUM(RPMLOG_EMERG);
 533     REGISTER_ENUM(RPMLOG_ALERT);
 534     REGISTER_ENUM(RPMLOG_CRIT);
 535     REGISTER_ENUM(RPMLOG_ERR);
 536     REGISTER_ENUM(RPMLOG_WARNING);
 537     REGISTER_ENUM(RPMLOG_NOTICE);
 538     REGISTER_ENUM(RPMLOG_INFO);
 539     REGISTER_ENUM(RPMLOG_DEBUG);
 540
 541     REGISTER_ENUM(RPMMIRE_DEFAULT);
 542     REGISTER_ENUM(RPMMIRE_STRCMP);
 543     REGISTER_ENUM(RPMMIRE_REGEX);
 544     REGISTER_ENUM(RPMMIRE_GLOB);
 545
 546     REGISTER_ENUM(RPMVSF_DEFAULT);
 547     REGISTER_ENUM(RPMVSF_NOHDRCHK);
 548     REGISTER_ENUM(RPMVSF_NEEDPAYLOAD);
 549     REGISTER_ENUM(RPMVSF_NOSHA1HEADER);
 550     REGISTER_ENUM(RPMVSF_NOSHA256HEADER);
 551     REGISTER_ENUM(RPMVSF_NODSAHEADER);
 552     REGISTER_ENUM(RPMVSF_NORSAHEADER);
 553     REGISTER_ENUM(RPMVSF_NOPAYLOAD);
 554     REGISTER_ENUM(RPMVSF_NOMD5);
 555     REGISTER_ENUM(RPMVSF_NODSA);
 556     REGISTER_ENUM(RPMVSF_NORSA);
 557     REGISTER_ENUM(_RPMVSF_NODIGESTS);
 558     REGISTER_ENUM(_RPMVSF_NOSIGNATURES);
 559     REGISTER_ENUM(_RPMVSF_NOHEADER);
 560     REGISTER_ENUM(_RPMVSF_NOPAYLOAD);
 561
 562     REGISTER_ENUM(TR_ADDED);
 563     REGISTER_ENUM(TR_REMOVED);
 564
 565     REGISTER_ENUM(RPMDBI_PACKAGES);
 566     REGISTER_ENUM(RPMDBI_LABEL);
 567     REGISTER_ENUM(RPMDBI_INSTFILENAMES);
 568     REGISTER_ENUM(RPMDBI_NAME);
 569     REGISTER_ENUM(RPMDBI_BASENAMES);
 570     REGISTER_ENUM(RPMDBI_GROUP);
 571     REGISTER_ENUM(RPMDBI_REQUIRENAME);
 572     REGISTER_ENUM(RPMDBI_PROVIDENAME);
 573     REGISTER_ENUM(RPMDBI_CONFLICTNAME);
 574     REGISTER_ENUM(RPMDBI_OBSOLETENAME);
 575     REGISTER_ENUM(RPMDBI_TRIGGERNAME);
 576     REGISTER_ENUM(RPMDBI_DIRNAMES);
 577     REGISTER_ENUM(RPMDBI_INSTALLTID);
 578     REGISTER_ENUM(RPMDBI_SIGMD5);
 579     REGISTER_ENUM(RPMDBI_SHA1HEADER);
 580
 581     REGISTER_ENUM(HEADERCONV_EXPANDFILELIST);
 582     REGISTER_ENUM(HEADERCONV_COMPRESSFILELIST);
 583     REGISTER_ENUM(HEADERCONV_RETROFIT_V3);
 584
 585     REGISTER_ENUM(RPMVERIFY_NONE);
 586     REGISTER_ENUM(RPMVERIFY_FILEDIGEST);
 587     REGISTER_ENUM(RPMVERIFY_FILESIZE);
 588     REGISTER_ENUM(RPMVERIFY_LINKTO);
 589     REGISTER_ENUM(RPMVERIFY_USER);
 590     REGISTER_ENUM(RPMVERIFY_GROUP);
 591     REGISTER_ENUM(RPMVERIFY_MTIME);
 592     REGISTER_ENUM(RPMVERIFY_MODE);
 593     REGISTER_ENUM(RPMVERIFY_RDEV);
 594     REGISTER_ENUM(RPMVERIFY_CAPS);
 595     REGISTER_ENUM(RPMVERIFY_READLINKFAIL);
 596     REGISTER_ENUM(RPMVERIFY_READFAIL);
 597     REGISTER_ENUM(RPMVERIFY_LSTATFAIL);
 598
 599     return 1;
 600 }
 601