rpm  5.4.14
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;
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 
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 
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 
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 
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 
396 
397  d = PyModule_GetDict(m);
398 
399 #ifdef HACK
400  pyrpmError = PyString_FromString("_rpm.error");
401  PyDict_SetItemString(d, "error", 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 */
411  PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type);
412 
414  PyModule_AddObject(m, "al", (PyObject *) &rpmal_Type);
415 
417  PyModule_AddObject(m, "ds", (PyObject *) &rpmds_Type);
418 
420  PyModule_AddObject(m, "fd", (PyObject *) &rpmfd_Type);
421 
423  PyModule_AddObject(m, "fts", (PyObject *) &rpmfts_Type);
424 
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 
434  PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type);
435 
437  PyModule_AddObject(m, "ps", (PyObject *) &rpmps_Type);
438 
439  Py_INCREF(&rpmtd_Type);
440  PyModule_AddObject(m, "td", (PyObject *) &rpmtd_Type);
441 
443  PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type);
444 
446  PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
447 
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) || defined(RPM_VENDOR_PLD)
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 #if defined(RPM_VENDOR_PLD)
504  REGISTER_ENUM(RPMSENSE_MISSINGOK);
505 #endif
506 
517 
537 
547 
565 
578 
581 
590 
595 
607 
610 
612 
614 }
PyTypeObject spec_Type
Definition: spec-py.c:216
char * kwlist[]
Definition: rpmal-py.c:27
headerTagTableEntry rpmTagTable
Automatically generated table of tag name/value pairs.
Definition: tagtbl.c:238
PyTypeObject rpmfts_Type
Definition: rpmfts-py.c:543
PyObject * rpmHeaderToFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:924
return tagname
Definition: rpmrepo.c:1053
PyObject * rpmHeaderToFile(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:946
static PyObject * archScore(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmmodule.c:57
int rpmReadConfigFiles(const char *file, const char *target)
Definition: rpmrc.c:1095
return Py_None
Definition: rpmal-py.c:55
PyTypeObject rpmds_Type
Definition: rpmds-py.c:745
PyObject * args
Definition: rpmts-py.c:200
int rpmPlatformScore(const char *platform, void *mi_re, int mi_nre)
Definition: rpmrc.c:653
PyObject * rpmHeaderFromFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:793
headerSprintfExtension rpmHeaderFormats
Table of query format extensions.
Definition: formats.c:305
fts m
Definition: rpmmtree.c:3827
enum rpmTag_e rpmTag
Definition: rpmtag.h:468
PyObject * evrCompare(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:1021
PyTypeObject rpmfi_Type
Definition: rpmfi-py.c:548
static PyMethodDef rpmModuleMethods[]
Definition: rpmmodule.c:216
static PyObject * setStats(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmmodule.c:201
PyObject * rpmHeaderFromFile(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:814
PyTypeObject hdr_Type
Definition: header-py.c:636
FILE * rpmlogSetFile(FILE *fp)
Set rpmlog file handle.
Definition: rpmlog.c:165
PyObject * rpmts_Create(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmts-py.c:1709
static PyObject * signalsCaught(PyObject *s, PyObject *check)
Definition: rpmmodule.c:98
PyList_Append(s->keyList, key)
#define RPMSENSE_NOTEQUAL
Definition: rpmevr.h:78
PyObject * pyrpmError
Definition: rpmmodule.c:51
static PyObject * setEpochPromote(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmmodule.c:187
PyTypeObject rpmps_Type
Definition: rpmps-py.c:353
#define RPMAL_NOMATCH
Definition: rpmal.h:17
PyObject * labelCompare(PyObject *self, PyObject *args)
Definition: header-py.c:985
void init_rpm(void)
Definition: rpmmodule.c:361
static void rpm_exithook(void)
Definition: rpmmodule.c:281
char * o
Definition: macro.c:745
rpmSetVerbosity(RPMLOG_NOTICE)
int rpmdbCheckSignals(void)
Check for and exit on termination signals.
Definition: rpmdb.c:523
char * rpmExpand(const char *arg,...)
Return (malloc&#39;ed) concatenated macro expansion(s).
Definition: macro.c:3178
static PyObject * setLogFile(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmmodule.c:143
PyTypeObject rpmts_Type
Definition: rpmts-py.c:1659
Definition: rpmte.h:37
PyObject * hdrLoad(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:696
sigset_t rpmsqCaught
Definition: rpmsq.c:352
int _rpmts_stats
Definition: rpmts.c:96
static char rpm__doc__[]
Definition: rpmmodule.c:355
static PyObject * checkSignals(PyObject *s, PyObject *args)
Definition: rpmmodule.c:133
PyTypeObject rpmmi_Type
Definition: rpmmi-py.c:228
PyObject * versionCompare(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:972
rpmdsObject * rpmds_Single(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:815
PyObject * evrSplit(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:1044
return Py_BuildValue("i", pkgKey)
const char * s
Definition: poptALL.c:734
char * t
Definition: rpmds.c:2716
Py_XDECREF(cbInfo->dso)
sigset_t newMask
Definition: rpmsq.c:738
PyObject * rpmSingleHeaderFromFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:841
#define REGISTER_ENUM(val)
PyTypeObject rpmal_Type
Definition: rpmal-py.c:140
return NULL
Definition: poptALL.c:613
PyTypeObject rpmfd_Type
Definition: rpmfd-py.c:294
int _rpmds_nopromote
Definition: rpmds.c:126
int rpmdbCheckTerminate(int terminate)
Check rpmdb signal handler for trapped signal and/or requested exit.
Definition: rpmdb.c:476
static void
Print copy of spec file, filling in Group/Description/Summary from specspo.
Definition: spec.c:737
static PyObject * platformScore(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmmodule.c:81
sigset_t oldMask
Definition: rpmsq.c:738
int extNum
Definition: hdrfmt.c:6711
Access RPM indices using Berkeley DB interface(s).
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:647
static const char * platform
Definition: rpmrc.c:41
int i
Definition: spec.c:743
#define RPMDBI_PACKAGES
Pseudo-tags used by the rpmdb and rpmgi iterator API&#39;s.
Definition: rpmtag.h:477
Py_INCREF(Py_None)
struct headerSprintfExtension_s * headerSprintfExtension
Definition: rpmtag.h:134
static PyObject * setVerbosity(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmmodule.c:170
PyTypeObject rpmte_Type
Definition: rpmte-py.c:454
static void addRpmTags(PyObject *module)
Definition: rpmmodule.c:289