rpm  5.4.10
rpmmodule.c
Go to the documentation of this file.
1 
5 #include "system.h"
6 
7 #include <rpmio_internal.h>
8 #include <rpmcb.h>
9 #include <rpmsq.h>
10 #include <argv.h>
11 
12 #define _RPMTAG_INTERNAL
13 #include <rpmtag.h>
14 #define _RPMEVR_INTERNAL
15 #include <rpmevr.h>
16 #include <rpmdb.h>
17 #include <rpmcli.h> /* XXX for rpmCheckSig */
18 
19 #include "legacy.h"
20 #include "misc.h"
21 
22 #include "header-py.h"
23 #include "rpmal-py.h"
24 #include "rpmds-py.h"
25 #include "rpmfd-py.h"
26 #include "rpmfts-py.h"
27 #include "rpmfi-py.h"
28 #include "rpmkeyring-py.h"
29 #include "rpmmacro-py.h"
30 #include "rpmmi-py.h"
31 #include "rpmps-py.h"
32 #include "rpmtd-py.h"
33 #include "rpmte-py.h"
34 #include "rpmts-py.h"
35 #include "spec-py.h"
36 
37 #include "debug.h"
38 
39 #ifdef __LCLINT__
40 #undef PyObject_HEAD
41 #define PyObject_HEAD int _PyObjectHead
42 #endif
43 
48 
51 PyObject * pyrpmError;
52 
53 extern sigset_t rpmsqCaught;
54 
57 static PyObject * archScore(PyObject * s, PyObject * args,
58  PyObject * kwds)
59 {
60  char * arch;
61  char * platform;
62  int score;
63  char * kwlist[] = {"arch", NULL};
64 
65  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &arch))
66  return NULL;
67 
68 #if defined(RPM_VENDOR_WINDRIVER)
69  platform = rpmExpand(arch, "-%{_host_vendor}", "-%{_host_os}%{?_gnu}", NULL);
70 #else
71  platform = rpmExpand(arch, "-", "%{_vendor}", "-", "%{_os}", NULL);
72 #endif
73  score = rpmPlatformScore(platform, NULL, 0);
74  platform = _free(platform);
75 
76  return Py_BuildValue("i", score);
77 }
78 
81 static PyObject * platformScore(PyObject * s, PyObject * args,
82  PyObject * kwds)
83 {
84  char * platform;
85  int score;
86  char * kwlist[] = {"platform", NULL};
87 
88  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &platform))
89  return NULL;
90 
91  score = rpmPlatformScore(platform, NULL, 0);
92 
93  return Py_BuildValue("i", score);
94 }
95 
98 static PyObject * signalsCaught(PyObject * s, PyObject * check)
99 {
100  PyObject *caught, *o;
101  Py_ssize_t llen;
102  int signum, i;
103  sigset_t newMask, oldMask;
104 
105  if (!PyList_Check(check)) {
106  PyErr_SetString(PyExc_TypeError, "list expected");
107  return NULL;
108  }
109 
110  llen = PyList_Size(check);
111  caught = PyList_New(0);
112  if (!caught) {
113  return NULL;
114  }
115  /* block signals while checking for them */
116  (void) sigfillset(&newMask);
117  (void) sigprocmask(SIG_BLOCK, &newMask, &oldMask);
118 
119  for (i = 0; i < llen; i++) {
120  o = PyList_GetItem(check, i);
121  signum = PyInt_AsLong(o);
122  if (sigismember(&rpmsqCaught, signum)) {
123  PyList_Append(caught, o);
124  }
125  }
126  (void) sigprocmask(SIG_SETMASK, &oldMask, NULL);
127 
128  return caught;
129 }
130 
133 static PyObject * checkSignals(PyObject * s, PyObject * args)
134 {
135  if (!PyArg_ParseTuple(args, ":checkSignals")) return NULL;
137  Py_INCREF(Py_None);
138  return Py_None;
139 }
140 
143 static PyObject * setLogFile (PyObject * s, PyObject * args,
144  PyObject *kwds)
145 {
146  PyObject * fop = NULL;
147  FILE * fp = NULL;
148  char * kwlist[] = {"fileObject", NULL};
149 
150  if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:logSetFile", kwlist, &fop))
151  return NULL;
152 
153  if (fop) {
154  if (!PyFile_Check(fop)) {
155  PyErr_SetString(pyrpmError, "requires file object");
156  return NULL;
157  }
158  fp = PyFile_AsFile(fop);
159  }
160 
161  (void) rpmlogSetFile(fp);
162 
163  Py_INCREF(Py_None);
164  return (PyObject *) Py_None;
165 }
166 
169 static PyObject *
170 setVerbosity (PyObject * s, PyObject * args, PyObject *kwds)
171 {
172  int level;
173  char * kwlist[] = {"level", NULL};
174 
175  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &level))
176  return NULL;
177 
178  rpmSetVerbosity(level);
179 
180  Py_INCREF(Py_None);
181  return (PyObject *) Py_None;
182 }
183 
186 static PyObject *
187 setEpochPromote (PyObject * s, PyObject * args, PyObject * kwds)
188 {
189  char * kwlist[] = {"promote", NULL};
190 
191  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist,
193  return NULL;
194 
195  Py_INCREF(Py_None);
196  return (PyObject *) Py_None;
197 }
198 
201 static PyObject * setStats (PyObject * s, PyObject * args,
202  PyObject * kwds)
203 {
204  char * kwlist[] = {"stats", NULL};
205 
206  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmts_stats))
207  return NULL;
208 
209  Py_INCREF(Py_None);
210  return (PyObject *) Py_None;
211 }
216 static PyMethodDef rpmModuleMethods[] = {
217  { "TransactionSet", (PyCFunction) rpmts_Create, METH_VARARGS|METH_KEYWORDS,
218 "rpm.TransactionSet([rootDir, [db]]) -> ts\n\
219 - Create a transaction set.\n" },
220 
221  { "addMacro", (PyCFunction) rpmmacro_AddMacro, METH_VARARGS|METH_KEYWORDS,
222  NULL },
223  { "delMacro", (PyCFunction) rpmmacro_DelMacro, METH_VARARGS|METH_KEYWORDS,
224  NULL },
225  { "expandMacro", (PyCFunction)rpmmacro_ExpandMacro, METH_VARARGS|METH_KEYWORDS,
226  NULL },
227  { "getMacros", (PyCFunction) rpmmacro_GetMacros, METH_VARARGS|METH_KEYWORDS,
228  NULL },
229 
230  { "archscore", (PyCFunction) archScore, METH_VARARGS|METH_KEYWORDS,
231  NULL },
232  { "platformscore", (PyCFunction) platformScore, METH_VARARGS|METH_KEYWORDS,
233  NULL },
234 
235  { "signalsCaught", (PyCFunction) signalsCaught, METH_O,
236  NULL },
237  { "checkSignals", (PyCFunction) checkSignals, METH_VARARGS,
238  NULL },
239 
240  { "headerLoad", (PyCFunction) hdrLoad, METH_VARARGS|METH_KEYWORDS,
241  NULL },
242 
243  { "readHeaderListFromFD", (PyCFunction) rpmHeaderFromFD, METH_VARARGS|METH_KEYWORDS,
244  NULL },
245  { "readHeaderListFromFile", (PyCFunction) rpmHeaderFromFile, METH_VARARGS|METH_KEYWORDS,
246  NULL },
247  { "readHeaderFromFD", (PyCFunction) rpmSingleHeaderFromFD, METH_VARARGS|METH_KEYWORDS,
248  NULL },
249  { "writeHeaderListToFD", (PyCFunction) rpmHeaderToFD, METH_VARARGS|METH_KEYWORDS,
250  NULL },
251  { "writeHeaderListToFile", (PyCFunction) rpmHeaderToFile, METH_VARARGS|METH_KEYWORDS,
252  NULL },
253 
254  { "setLogFile", (PyCFunction) setLogFile, METH_VARARGS|METH_KEYWORDS,
255  NULL },
256 
257  { "versionCompare", (PyCFunction) versionCompare, METH_VARARGS|METH_KEYWORDS,
258  NULL },
259  { "labelCompare", (PyCFunction) labelCompare, METH_VARARGS|METH_KEYWORDS,
260  NULL },
261  { "evrCompare", (PyCFunction) evrCompare, METH_VARARGS|METH_KEYWORDS,
262  NULL },
263  { "evrSplit", (PyCFunction) evrSplit, METH_VARARGS|METH_KEYWORDS,
264  NULL },
265  { "setVerbosity", (PyCFunction) setVerbosity, METH_VARARGS|METH_KEYWORDS,
266  NULL },
267  { "setEpochPromote", (PyCFunction) setEpochPromote, METH_VARARGS|METH_KEYWORDS,
268  NULL },
269  { "setStats", (PyCFunction) setStats, METH_VARARGS|METH_KEYWORDS,
270  NULL },
271 
272  { "dsSingle", (PyCFunction) rpmds_Single, METH_VARARGS|METH_KEYWORDS,
273 "rpm.dsSingle(TagN, N, [EVR, [Flags]] -> ds\n\
274 - Create a single element dependency set.\n" },
275  { NULL }
276 } ;
277 
278 /*
279  * Force clean up of open iterators and dbs on exit.
280  */
281 static void rpm_exithook(void)
282 {
284 }
285 
286 /*
287  * Add rpm tag dictionaries to the module
288  */
289 static void addRpmTags(PyObject *module)
290 {
291  PyObject * dict = PyDict_New();
292 
293 #ifdef NOTYET
294 
295  PyObject *pyval, *pyname;
296  rpmtd names = rpmtdNew();
297  rpmTagGetNames(names, 1);
298  const char *tagname, *shortname;
299  rpmTag tagval;
300 
301  while ((tagname = rpmtdNextString(names))) {
302  shortname = tagname + strlen("RPMTAG_");
303  tagval = rpmTagGetValue(shortname);
304 
305  PyModule_AddIntConstant(module, tagname, tagval);
306  pyval = PyInt_FromLong(tagval);
307  pyname = PyString_FromString(shortname);
308  PyDict_SetItem(dict, pyval, pyname);
309  Py_XDECREF(pyval);
310  Py_XDECREF(pyname);
311  }
312  PyModule_AddObject(module, "tagnames", dict);
313  rpmtdFreeData(names);
314  rpmtdFree(names);
315 
316 #else
317 
318  PyObject * d = PyModule_GetDict(module);
319  PyObject * o;
320 
321  { const struct headerTagTableEntry_s * t;
322  PyObject * to;
323  for (t = rpmTagTable; t && t->name; t++) {
324  PyDict_SetItemString(d, (char *) t->name, to=PyInt_FromLong(t->val));
325  Py_XDECREF(to);
326  PyDict_SetItem(dict, to, o=PyString_FromString(t->name + 7));
327  Py_XDECREF(o);
328  }
329  }
330 
333  PyObject * to;
334  int extNum;
335  for (ext = exts, extNum = 0; ext != NULL && ext->type != HEADER_EXT_LAST;
336  ext = (ext->type == HEADER_EXT_MORE ? *ext->u.more : ext+1), extNum++)
337  {
338  if (ext->name == NULL || ext->type != HEADER_EXT_TAG)
339  continue;
340  PyDict_SetItemString(d, (char *) ext->name, to=PyCObject_FromVoidPtr((void *)ext, NULL));
341  Py_XDECREF(to);
342  PyDict_SetItem(dict, to, o=PyString_FromString(ext->name + 7));
343  Py_XDECREF(o);
344  }
345  }
346 
347  PyDict_SetItemString(d, "tagnames", dict);
348  Py_XDECREF(dict);
349 
350 #endif
351 }
352 
355 static char rpm__doc__[] =
356 "";
357 
358 void init_rpm(void); /* XXX eliminate gcc warning */
361 void init_rpm(void)
362 {
363  PyObject * d, * o, * m;
364 
365 #if Py_TPFLAGS_HAVE_ITER /* XXX backport to python-1.5.2 */
366  if (PyType_Ready(&hdr_Type) < 0) return;
367  if (PyType_Ready(&rpmal_Type) < 0) return;
368  if (PyType_Ready(&rpmds_Type) < 0) return;
369  if (PyType_Ready(&rpmfd_Type) < 0) return;
370  if (PyType_Ready(&rpmfts_Type) < 0) return;
371  if (PyType_Ready(&rpmfi_Type) < 0) return;
372  if (PyType_Ready(&rpmmi_Type) < 0) return;
373  if (PyType_Ready(&rpmps_Type) < 0) return;
374 
375  if (PyType_Ready(&rpmtd_Type) < 0) return;
376  if (PyType_Ready(&rpmKeyring_Type) < 0) return;
377  if (PyType_Ready(&rpmPubkey_Type) < 0) return;
378 
379  if (PyType_Ready(&rpmte_Type) < 0) return;
380  if (PyType_Ready(&rpmts_Type) < 0) return;
381  if (PyType_Ready(&spec_Type) < 0) return;
382 #endif
383 
384  m = Py_InitModule3("_rpm", rpmModuleMethods, rpm__doc__);
385  if (m == NULL)
386  return;
387 
388  /*
389  * treat error to register rpm cleanup hook as fatal, tracebacks
390  * can and will leave stale locks around if we can't clean up
391  */
392  if (Py_AtExit(rpm_exithook) == -1)
393  return;
394 
395  rpmReadConfigFiles(NULL, NULL);
396 
397  d = PyModule_GetDict(m);
398 
399 #ifdef HACK
400  pyrpmError = PyString_FromString("_rpm.error");
401  PyDict_SetItemString(d, "error", pyrpmError);
402  Py_XDECREF(pyrpmError);
403 #else
404  pyrpmError = PyErr_NewException("_rpm.error", NULL, NULL);
405  if (pyrpmError != NULL)
406  PyDict_SetItemString(d, "error", pyrpmError);
407 #endif
408 
409 #if Py_TPFLAGS_HAVE_ITER /* XXX backport to python-1.5.2 */
410  Py_INCREF(&hdr_Type);
411  PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type);
412 
413  Py_INCREF(&rpmal_Type);
414  PyModule_AddObject(m, "al", (PyObject *) &rpmal_Type);
415 
416  Py_INCREF(&rpmds_Type);
417  PyModule_AddObject(m, "ds", (PyObject *) &rpmds_Type);
418 
419  Py_INCREF(&rpmfd_Type);
420  PyModule_AddObject(m, "fd", (PyObject *) &rpmfd_Type);
421 
422  Py_INCREF(&rpmfts_Type);
423  PyModule_AddObject(m, "fts", (PyObject *) &rpmfts_Type);
424 
425  Py_INCREF(&rpmfi_Type);
426  PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_Type);
427 
428  Py_INCREF(&rpmKeyring_Type);
429  PyModule_AddObject(m, "Keyring", (PyObject *) &rpmKeyring_Type);
430  Py_INCREF(&rpmPubkey_Type);
431  PyModule_AddObject(m, "Pubkey", (PyObject *) &rpmPubkey_Type);
432 
433  Py_INCREF(&rpmmi_Type);
434  PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type);
435 
436  Py_INCREF(&rpmps_Type);
437  PyModule_AddObject(m, "ps", (PyObject *) &rpmps_Type);
438 
439  Py_INCREF(&rpmtd_Type);
440  PyModule_AddObject(m, "td", (PyObject *) &rpmtd_Type);
441 
442  Py_INCREF(&rpmte_Type);
443  PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type);
444 
445  Py_INCREF(&rpmts_Type);
446  PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
447 
448  Py_INCREF(&spec_Type);
449  PyModule_AddObject(m, "spec", (PyObject *) &spec_Type);
450 #else
451  hdr_Type.ob_type = &PyType_Type;
452  rpmal_Type.ob_type = &PyType_Type;
453  rpmds_Type.ob_type = &PyType_Type;
454  rpmfd_Type.ob_type = &PyType_Type;
455  rpmfts_Type.ob_type = &PyType_Type;
456  rpmfi_Type.ob_type = &PyType_Type;
457  rpmmi_Type.ob_type = &PyType_Type;
458  rpmps_Type.ob_type = &PyType_Type;
459  rpmte_Type.ob_type = &PyType_Type;
460  rpmts_Type.ob_type = &PyType_Type;
461  spec_Type.ob_type = &PyType_Type;
462 #endif
463 
464  addRpmTags(m);
465 
466 #define REGISTER_ENUM(val) \
467  PyDict_SetItemString(d, #val, o=PyInt_FromLong( val )); \
468  Py_XDECREF(o);
469 
475 
487 
490 
495  REGISTER_ENUM(RPMSENSE_FIND_REQUIRES);
496 #if defined(RPM_VENDOR_MANDRIVA)
498  REGISTER_ENUM(RPMSENSE_SCRIPT_PRE);
499  REGISTER_ENUM(RPMSENSE_SCRIPT_POST);
500  REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN);
501  REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN)
502 #endif
503 
505  REGISTER_ENUM(RPMDEPS_FLAG_NOREQUIRES);
506  REGISTER_ENUM(RPMDEPS_FLAG_NOCONFLICTS);
507  REGISTER_ENUM(RPMDEPS_FLAG_NOOBSOLETES);
508  REGISTER_ENUM(RPMDEPS_FLAG_NOPARENTDIRS);
509  REGISTER_ENUM(RPMDEPS_FLAG_NOLINKTOS);
510  REGISTER_ENUM(RPMDEPS_FLAG_ANACONDA);
511  REGISTER_ENUM(RPMDEPS_FLAG_NOSUGGEST);
512  REGISTER_ENUM(RPMDEPS_FLAG_ADDINDEPS);
513  REGISTER_ENUM(RPMDEPS_FLAG_DEPLOOPS);
514 
515  REGISTER_ENUM(RPMTRANS_FLAG_TEST);
516  REGISTER_ENUM(RPMTRANS_FLAG_BUILD_PROBS);
517  REGISTER_ENUM(RPMTRANS_FLAG_NOSCRIPTS);
518  REGISTER_ENUM(RPMTRANS_FLAG_JUSTDB);
519  REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERS);
520  REGISTER_ENUM(RPMTRANS_FLAG_NODOCS);
521  REGISTER_ENUM(RPMTRANS_FLAG_ALLFILES);
522  REGISTER_ENUM(RPMTRANS_FLAG_NORPMDB);
523  REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE);
524  REGISTER_ENUM(RPMTRANS_FLAG_NOPRE);
525  REGISTER_ENUM(RPMTRANS_FLAG_NOPOST);
526  REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPREIN);
527  REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERIN);
528  REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERUN);
529  REGISTER_ENUM(RPMTRANS_FLAG_NOPREUN);
530  REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTUN);
531  REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPOSTUN);
532  REGISTER_ENUM(RPMTRANS_FLAG_NOFDIGESTS);
533  REGISTER_ENUM(RPMTRANS_FLAG_NOCONFIGS);
534 
535  REGISTER_ENUM(RPMPROB_FILTER_IGNOREOS);
536  REGISTER_ENUM(RPMPROB_FILTER_IGNOREARCH);
537  REGISTER_ENUM(RPMPROB_FILTER_REPLACEPKG);
538  REGISTER_ENUM(RPMPROB_FILTER_FORCERELOCATE);
539  REGISTER_ENUM(RPMPROB_FILTER_REPLACENEWFILES);
540  REGISTER_ENUM(RPMPROB_FILTER_REPLACEOLDFILES);
541  REGISTER_ENUM(RPMPROB_FILTER_OLDPACKAGE);
542  REGISTER_ENUM(RPMPROB_FILTER_DISKSPACE);
543  REGISTER_ENUM(RPMPROB_FILTER_DISKNODES);
544 
545  REGISTER_ENUM(RPMCALLBACK_UNKNOWN);
546  REGISTER_ENUM(RPMCALLBACK_INST_PROGRESS);
547  REGISTER_ENUM(RPMCALLBACK_INST_START);
548  REGISTER_ENUM(RPMCALLBACK_INST_OPEN_FILE);
549  REGISTER_ENUM(RPMCALLBACK_INST_CLOSE_FILE);
550  REGISTER_ENUM(RPMCALLBACK_TRANS_PROGRESS);
551  REGISTER_ENUM(RPMCALLBACK_TRANS_START);
552  REGISTER_ENUM(RPMCALLBACK_TRANS_STOP);
553  REGISTER_ENUM(RPMCALLBACK_UNINST_PROGRESS);
554  REGISTER_ENUM(RPMCALLBACK_UNINST_START);
555  REGISTER_ENUM(RPMCALLBACK_UNINST_STOP);
556  REGISTER_ENUM(RPMCALLBACK_REPACKAGE_PROGRESS);
557  REGISTER_ENUM(RPMCALLBACK_REPACKAGE_START);
558  REGISTER_ENUM(RPMCALLBACK_REPACKAGE_STOP);
559  REGISTER_ENUM(RPMCALLBACK_UNPACK_ERROR);
560  REGISTER_ENUM(RPMCALLBACK_CPIO_ERROR);
561  REGISTER_ENUM(RPMCALLBACK_SCRIPT_ERROR);
562 
563  REGISTER_ENUM(RPMPROB_BADARCH);
564  REGISTER_ENUM(RPMPROB_BADOS);
565  REGISTER_ENUM(RPMPROB_PKG_INSTALLED);
566  REGISTER_ENUM(RPMPROB_BADRELOCATE);
567  REGISTER_ENUM(RPMPROB_REQUIRES);
568  REGISTER_ENUM(RPMPROB_CONFLICT);
569  REGISTER_ENUM(RPMPROB_NEW_FILE_CONFLICT);
570  REGISTER_ENUM(RPMPROB_FILE_CONFLICT);
571  REGISTER_ENUM(RPMPROB_OLDPACKAGE);
572  REGISTER_ENUM(RPMPROB_DISKSPACE);
573  REGISTER_ENUM(RPMPROB_DISKNODES);
574  REGISTER_ENUM(RPMPROB_BADPRETRANS);
575 
576  REGISTER_ENUM(VERIFY_DIGEST);
577  REGISTER_ENUM(VERIFY_SIGNATURE);
578 
579  REGISTER_ENUM(RPMLOG_EMERG);
580  REGISTER_ENUM(RPMLOG_ALERT);
581  REGISTER_ENUM(RPMLOG_CRIT);
582  REGISTER_ENUM(RPMLOG_ERR);
583  REGISTER_ENUM(RPMLOG_WARNING);
584  REGISTER_ENUM(RPMLOG_NOTICE);
585  REGISTER_ENUM(RPMLOG_INFO);
586  REGISTER_ENUM(RPMLOG_DEBUG);
587 
588  REGISTER_ENUM(RPMMIRE_DEFAULT);
589  REGISTER_ENUM(RPMMIRE_STRCMP);
590  REGISTER_ENUM(RPMMIRE_REGEX);
591  REGISTER_ENUM(RPMMIRE_GLOB);
592 
593  REGISTER_ENUM(RPMVSF_DEFAULT);
594  REGISTER_ENUM(RPMVSF_NOHDRCHK);
595  REGISTER_ENUM(RPMVSF_NEEDPAYLOAD);
596  REGISTER_ENUM(RPMVSF_NOSHA1HEADER);
597  REGISTER_ENUM(RPMVSF_NOMD5HEADER);
598  REGISTER_ENUM(RPMVSF_NODSAHEADER);
599  REGISTER_ENUM(RPMVSF_NORSAHEADER);
600  REGISTER_ENUM(RPMVSF_NOSHA1);
601  REGISTER_ENUM(RPMVSF_NOMD5);
602  REGISTER_ENUM(RPMVSF_NODSA);
603  REGISTER_ENUM(RPMVSF_NORSA);
604 
605  REGISTER_ENUM(TR_ADDED);
606  REGISTER_ENUM(TR_REMOVED);
607 
608  REGISTER_ENUM(RPMDBI_PACKAGES);
609 
610  REGISTER_ENUM((long)RPMAL_NOMATCH);
611 }