rpm  5.4.15
rpmds-py.c
Go to the documentation of this file.
1 
5 #include "system-py.h"
6 
7 #include <rpmio.h>
8 #include <rpmiotypes.h> /* XXX fnpyKey */
9 #include <rpmtypes.h>
10 #include <rpmtag.h>
11 
12 #include "header-py.h"
13 #include "rpmds-py.h"
14 
15 #include "debug.h"
16 
17 /*@access rpmds @*/
18 
26 static
27 void rpmds_ParseEVR(char * evr,
28  /*@exposed@*/ /*@out@*/ const char ** ep,
29  /*@exposed@*/ /*@out@*/ const char ** vp,
30  /*@exposed@*/ /*@out@*/ const char ** rp)
31  /*@modifies *ep, *vp, *rp @*/
32  /*@requires maxSet(ep) >= 0 /\ maxSet(vp) >= 0 /\ maxSet(rp) >= 0 @*/
33 {
34  const char *epoch;
35  const char *version; /* assume only version is present */
36  const char *release;
37  char *s, *se;
38 
39  s = evr;
40  while (*s && xisdigit(*s)) s++; /* s points to epoch terminator */
41  se = strrchr(s, '-'); /* se points to version terminator */
42 
43  if (*s == ':') {
44  epoch = evr;
45  *s++ = '\0';
46  version = s;
47  /*@-branchstate@*/
48  if (*epoch == '\0') epoch = "0";
49  /*@=branchstate@*/
50  } else {
51  epoch = NULL; /* XXX disable epoch compare if missing */
52  version = evr;
53  }
54  if (se) {
55 /*@-boundswrite@*/
56  *se++ = '\0';
57 /*@=boundswrite@*/
58  release = se;
59  } else {
60  release = NULL;
61  }
62 
63  if (ep) *ep = epoch;
64  if (vp) *vp = version;
65  if (rp) *rp = release;
66 }
67 
70 static int compare_values(const char *str1, const char *str2)
71 {
72  if (!str1 && !str2)
73  return 0;
74  else if (str1 && !str2)
75  return 1;
76  else if (!str1 && str2)
77  return -1;
78  return rpmvercmp(str1, str2);
79 }
80 
81 static int
83  /*@*/
84 {
85  char *aEVR = xstrdup(rpmdsEVR(a->ds));
86  const char *aE, *aV, *aR;
87  char *bEVR = xstrdup(rpmdsEVR(b->ds));
88  const char *bE, *bV, *bR;
89  int rc;
90 
91  /* XXX W2DO? should N be compared? */
92  rpmds_ParseEVR(aEVR, &aE, &aV, &aR);
93  rpmds_ParseEVR(bEVR, &bE, &bV, &bR);
94 
95  rc = compare_values(aE, bE);
96  if (!rc) {
97  rc = compare_values(aV, bV);
98  if (!rc)
99  rc = compare_values(aR, bR);
100  }
101 
102  aEVR = _free(aEVR);
103  bEVR = _free(bEVR);
104 
105  return rc;
106 }
107 
108 static PyObject *
110  /*@*/
111 {
112  int rc;
113 
114  switch (op) {
115  case Py_NE:
116  /* XXX map ranges overlap boolean onto '!=' python syntax. */
117  rc = rpmdsCompare(a->ds, b->ds);
118  rc = (rc < 0 ? -1 : (rc == 0 ? 1 : 0));
119  break;
120  case Py_LT:
121  case Py_LE:
122  case Py_GT:
123  case Py_GE:
124  case Py_EQ:
125  /*@fallthrough@*/
126  default:
127  rc = -1;
128  break;
129  }
130  return Py_BuildValue("i", rc);
131 }
132 
133 static PyObject *
135  /*@*/
136 {
137  Py_INCREF(s);
138  return (PyObject *)s;
139 }
140 
141 /*@null@*/
142 static PyObject *
144  /*@modifies s @*/
145 {
146  PyObject * result = NULL;
147 
148  /* Reset loop indices on 1st entry. */
149  if (!s->active) {
150  s->ds = rpmdsInit(s->ds);
151  s->active = 1;
152  }
153 
154  /* If more to do, return a (N, EVR, Flags) tuple. */
155  if (rpmdsNext(s->ds) >= 0) {
156  const char * N = rpmdsN(s->ds);
157  const char * EVR = rpmdsEVR(s->ds);
158  rpmTag tagN = rpmdsTagN(s->ds);
159  rpmsenseFlags Flags = rpmdsFlags(s->ds);
160 
161 /*@-branchstate@*/
162  if (N != NULL) N = xstrdup(N);
163  if (EVR != NULL) EVR = xstrdup(EVR);
164 /*@=branchstate@*/
165  result = (PyObject *)rpmds_Wrap( rpmdsSingle(tagN, N, EVR, Flags) );
166  } else
167  s->active = 0;
168 
169  return result;
170 }
171 
176 
177 /*@null@*/
178 static PyObject *
180  /*@globals _Py_NoneStruct @*/
181  /*@modifies s, _Py_NoneStruct @*/
182 {
183  PyObject * result;
184 
185  result = rpmds_iternext(s);
186 
187  if (result == NULL) {
188  Py_RETURN_NONE;
189  }
190  return result;
191 }
192 
193 /*@null@*/
194 static PyObject *
195 rpmds_Debug(/*@unused@*/ rpmdsObject * s, PyObject * args,
196  PyObject * kwds)
197  /*@globals _Py_NoneStruct @*/
198  /*@modifies _Py_NoneStruct @*/
199 {
200  char * kwlist[] = {"debugLevel", NULL};
201 
202  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmds_debug))
203  return NULL;
204 
205  Py_RETURN_NONE;
206 }
207 
208 /*@null@*/
209 static PyObject *
211  /*@*/
212 {
213  DEPRECATED_METHOD("use len(ds) instead");
214  return Py_BuildValue("i", rpmdsCount(s->ds));
215 }
216 
217 /*@null@*/
218 static PyObject *
220  /*@*/
221 {
222  return Py_BuildValue("i", rpmdsIx(s->ds));
223 }
224 
225 /*@null@*/
226 static PyObject *
228  /*@*/
229 {
230  return Py_BuildValue("s", rpmdsDNEVR(s->ds));
231 }
232 
233 /*@null@*/
234 static PyObject *
236  /*@*/
237 {
238  return Py_BuildValue("s", rpmdsN(s->ds));
239 }
240 
241 /*@null@*/
242 static PyObject *
244  /*@*/
245 {
246  return Py_BuildValue("s", rpmdsEVR(s->ds));
247 }
248 
249 /*@null@*/
250 static PyObject *
252  /*@*/
253 {
254  return Py_BuildValue("i", rpmdsFlags(s->ds));
255 }
256 
257 /*@null@*/
258 static PyObject *
260  /*@*/
261 {
262  return Py_BuildValue("i", (int) rpmdsBT(s->ds));
263 }
264 
265 /*@null@*/
266 static PyObject *
268  /*@*/
269 {
270  return Py_BuildValue("i", rpmdsTagN(s->ds));
271 }
272 
273 /*@null@*/
274 static PyObject *
276  /*@*/
277 {
278  return Py_BuildValue("i", rpmdsColor(s->ds));
279 }
280 
281 /*@null@*/
282 static PyObject *
284  /*@*/
285 {
286  return Py_BuildValue("i", rpmdsRefs(s->ds));
287 }
288 
289 /*@null@*/
290 static PyObject *
292  /*@*/
293 {
294  return Py_BuildValue("i", rpmdsResult(s->ds));
295 }
296 /*@null@*/
297 static PyObject *
298 rpmds_SetNoPromote(rpmdsObject * s, PyObject * args, PyObject * kwds)
299  /*@modifies s @*/
300 {
301  int nopromote;
302  char * kwlist[] = {"noPromote", NULL};
303 
304  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i:SetNoPromote", kwlist,
305  &nopromote))
306  return NULL;
307 
308  return Py_BuildValue("i", rpmdsSetNoPromote(s->ds, nopromote));
309 }
310 
311 /*@null@*/
312 static PyObject *
313 rpmds_Notify(rpmdsObject * s, PyObject * args, PyObject * kwds)
314  /*@globals _Py_NoneStruct @*/
315  /*@modifies _Py_NoneStruct @*/
316 {
317  const char * where;
318  int rc;
319  char * kwlist[] = {"location", "returnCode", NULL};
320 
321  if (!PyArg_ParseTupleAndKeywords(args, kwds, "si:Notify", kwlist,
322  &where, &rc))
323  return NULL;
324 
325  rpmdsNotify(s->ds, where, rc);
326  Py_RETURN_NONE;
327 }
328 
329 /* XXX rpmdsFind uses bsearch on s->ds, so a sort is needed. */
330 /*@null@*/
331 static PyObject *
333  /*@globals _Py_NoneStruct @*/
334  /*@modifies _Py_NoneStruct @*/
335 {
336  rpmds nds = NULL;
337 
338  if (rpmdsMerge(&nds, s->ds) >= 0) {
339  (void)rpmdsFree(s->ds);
340  s->ds = NULL;
341  s->ds = nds;
342  }
343  Py_RETURN_NONE;
344 }
345 
346 /*@null@*/
347 static PyObject *
348 rpmds_Find(rpmdsObject * s, PyObject * args, PyObject * kwds)
349  /*@modifies s @*/
350 {
351  PyObject * to = NULL;
352  rpmdsObject * o;
353  char * kwlist[] = {"element", NULL};
354 
355  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Find", kwlist, &to))
356  return NULL;
357 
358  /* XXX ds type check needed. */
359  o = (rpmdsObject *)to;
360 
361  /* XXX make sure ods index is valid, real fix in lib/rpmds.c. */
362  if (rpmdsIx(o->ds) == -1) rpmdsSetIx(o->ds, 0);
363 
364  return Py_BuildValue("i", rpmdsFind(s->ds, o->ds));
365 }
366 
367 /*@null@*/
368 static PyObject *
369 rpmds_Merge(rpmdsObject * s, PyObject * args, PyObject * kwds)
370  /*@modifies s @*/
371 {
372  PyObject * to = NULL;
373  rpmdsObject * o;
374  char * kwlist[] = {"element", NULL};
375 
376  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Merge", kwlist, &to))
377  return NULL;
378 
379  /* XXX ds type check needed. */
380  o = (rpmdsObject *)to;
381  return Py_BuildValue("i", rpmdsMerge(&s->ds, o->ds));
382 }
383 
384 /*@null@*/
385 static PyObject *
386 rpmds_Search(rpmdsObject * s, PyObject * args, PyObject * kwds)
387  /*@modifies s @*/
388 {
389  PyObject * to = NULL;
390  rpmdsObject * o;
391  char * kwlist[] = {"element", NULL};
392 
393  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Merge", kwlist, &to))
394  return NULL;
395 
396  /* XXX ds type check needed. */
397  o = (rpmdsObject *)to;
398  return Py_BuildValue("i", rpmdsSearch(s->ds, o->ds));
399 }
400 
401 #ifdef NOTYET
402 static PyObject *
403 rpmds_Compare(rpmdsObject * s, PyObject * args, PyObject * kwds)
404  /*@modifies s @*/
405 {
406  PyObject * to = NULL;
407  rpmdsObject * o;
408  char * kwlist[] = {"other", NULL};
409 
410  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O:Compare", kwlist, &to))
411  return NULL;
412 
413  /* XXX ds type check needed. */
414  o = (rpmdsObject *)to;
415  return Py_BuildValue("i", rpmdsCompare(s->ds, o->ds));
416 }
417 
418 static PyObject *rpmds_Instance(rpmdsObject * s)
419 {
420  return Py_BuildValue("i", rpmdsInstance(s->ds));
421 }
422 
423 /*@null@*/
424 static PyObject *
425 rpmds_Problem(rpmdsObject * s)
426  /*@*/
427 {
428  if (!PyArg_ParseTuple(args, ":Problem"))
429  return NULL;
430  Py_RETURN_NONE;
431 }
432 #endif
433 
434 static PyObject *
436  /*@*/
437 {
438  rpmds ds = NULL;
439  int xx;
440 
441  /* XXX check return code, permit arg (NULL uses system default). */
442  xx = rpmdsCpuinfo(&ds, NULL);
443 
444  return (PyObject *) rpmds_Wrap( ds );
445 }
446 
447 static PyObject *
449  /*@*/
450 {
451  rpmds ds = NULL;
452  int xx;
453 
454  /* XXX check return code, permit arg (NULL uses system default). */
455  xx = rpmdsRpmlib(&ds, NULL);
456 
457  return (PyObject *) rpmds_Wrap( ds );
458 }
459 
460 static PyObject *
462  /*@*/
463 {
464  rpmPRCO PRCO = rpmdsNewPRCO(NULL);
465  rpmds P = NULL;
466  int xx;
467 
468  /* XXX check return code, permit arg (NULL uses system default). */
469  xx = rpmdsSysinfo(PRCO, NULL);
470  P = rpmdsLink(rpmdsFromPRCO(PRCO, RPMTAG_PROVIDENAME), "rpmds_Sysinfo");
471  PRCO = rpmdsFreePRCO(PRCO);
472 
473  return (PyObject *) rpmds_Wrap( P );
474 }
475 
476 static PyObject *
478  /*@*/
479 {
480  rpmds ds = NULL;
481  int xx;
482 
483  /* XXX check return code, permit arg (NULL uses system default). */
484  xx = rpmdsGetconf(&ds, NULL);
485 
486  return (PyObject *) rpmds_Wrap( ds );
487 }
488 
489 static PyObject *
491  /*@*/
492 {
493  rpmPRCO PRCO = rpmdsNewPRCO(NULL);
494  rpmds P = NULL;
495  int xx;
496 
497  /* XXX check return code, permit arg (NULL uses system default). */
498  xx = rpmdsLdconfig(PRCO, NULL);
499 
500  P = rpmdsLink(rpmdsFromPRCO(PRCO, RPMTAG_PROVIDENAME), "rpmds_Ldconfig");
501  PRCO = rpmdsFreePRCO(PRCO);
502  return (PyObject *) rpmds_Wrap( P );
503 }
504 
505 static PyObject *
507  /*@*/
508 {
509  rpmds ds = NULL;
510  int xx;
511 
512  /* XXX check return code, permit arg (NULL uses system default). */
513  xx = rpmdsUname(&ds, NULL);
514 
515  return (PyObject *) rpmds_Wrap( ds );
516 }
517 
520 /*@-fullinitblock@*/
521 /*@unchecked@*/ /*@observer@*/
522 static struct PyMethodDef rpmds_methods[] = {
523  {"Debug", (PyCFunction)rpmds_Debug, METH_VARARGS|METH_KEYWORDS,
524  NULL},
525  {"Count", (PyCFunction)rpmds_Count, METH_NOARGS,
526  "ds.Count -> Count - Return no. of elements.\n" },
527  {"Ix", (PyCFunction)rpmds_Ix, METH_NOARGS,
528  "ds.Ix -> Ix - Return current element index.\n" },
529  {"DNEVR", (PyCFunction)rpmds_DNEVR, METH_NOARGS,
530  "ds.DNEVR -> DNEVR - Return current DNEVR.\n" },
531  {"N", (PyCFunction)rpmds_N, METH_NOARGS,
532  "ds.N -> N - Return current N.\n" },
533  {"EVR", (PyCFunction)rpmds_EVR, METH_NOARGS,
534  "ds.EVR -> EVR - Return current EVR.\n" },
535  {"Flags", (PyCFunction)rpmds_Flags, METH_NOARGS,
536  "ds.Flags -> Flags - Return current Flags.\n" },
537  {"BT", (PyCFunction)rpmds_BT, METH_NOARGS,
538  "ds.BT -> BT - Return build time.\n" },
539  {"TagN", (PyCFunction)rpmds_TagN, METH_NOARGS,
540  "ds.TagN -> TagN - Return current TagN.\n" },
541  {"Color", (PyCFunction)rpmds_Color, METH_NOARGS,
542  "ds.Color -> Color - Return current Color.\n" },
543  {"Refs", (PyCFunction)rpmds_Refs, METH_NOARGS,
544  "ds.Refs -> Refs - Return current Refs.\n" },
545  {"Result", (PyCFunction)rpmds_Result, METH_NOARGS,
546  "ds.Result -> Result - Return current Result.\n" },
547  {"next", (PyCFunction)rpmds_Next, METH_NOARGS,
548 "ds.next() -> (N, EVR, Flags)\n\
549 - Retrieve next dependency triple.\n" },
550  {"SetNoPromote",(PyCFunction)rpmds_SetNoPromote, METH_VARARGS|METH_KEYWORDS,
551  NULL},
552  {"Notify", (PyCFunction)rpmds_Notify, METH_VARARGS|METH_KEYWORDS,
553  NULL},
554  {"Sort", (PyCFunction)rpmds_Sort, METH_NOARGS,
555 "ds.Sort() -> None\n\
556 - Sort the (N,EVR,Flags) elements in ds\n" },
557  {"Find", (PyCFunction)rpmds_Find, METH_VARARGS|METH_KEYWORDS,
558 "ds.Find(element) -> matching ds index (-1 on failure)\n\
559 - Check for an exactly matching element in ds.\n\
560 The current index in ds is positioned at matching member upon success.\n" },
561  {"Merge", (PyCFunction)rpmds_Merge, METH_VARARGS|METH_KEYWORDS,
562 "ds.Merge(elements) -> 0 on success\n\
563 - Merge elements into ds, maintaining (N,EVR,Flags) sort order.\n" },
564  {"Search", (PyCFunction)rpmds_Search, METH_VARARGS|METH_KEYWORDS,
565 "ds.Search(element) -> matching ds index (-1 on failure)\n\
566 - Check that element dependency range overlaps some member of ds.\n\
567 The current index in ds is positioned at overlapping member upon success.\n" },
568  {"Rpmlib", (PyCFunction)rpmds_Rpmlib, METH_NOARGS|METH_STATIC,
569  "ds.Rpmlib -> nds - Return internal rpmlib dependency set.\n"},
570 #ifdef NOTYET
571  {"Compare", (PyCFunction)rpmds_Compare, METH_VARARGS|METH_KEYWORDS,
572  NULL},
573  {"Instance", (PyCFunction)rpmds_Instance, METH_NOARGS,
574  NULL},
575  {"Problem", (PyCFunction)rpmds_Problem, METH_NOARGS,
576  NULL},
577 #endif
578  {"Cpuinfo", (PyCFunction)rpmds_Cpuinfo, METH_NOARGS|METH_STATIC,
579  "ds.Cpuinfo -> nds - Return /proc/cpuinfo dependency set.\n"},
580  {"Sysinfo", (PyCFunction)rpmds_Sysinfo, METH_NOARGS|METH_STATIC,
581  "ds.Sysinfo -> nds - Return /etc/rpm/sysinfo dependency set.\n"},
582  {"Getconf", (PyCFunction)rpmds_Getconf, METH_NOARGS|METH_STATIC,
583  "ds.Getconf -> nds - Return getconf(1) dependency set.\n"},
584  {"Ldconfig", (PyCFunction)rpmds_Ldconfig, METH_NOARGS|METH_STATIC,
585  "ds.Ldconfig -> nds - Return /etc/ld.so.cache dependency set.\n"},
586  {"Uname", (PyCFunction)rpmds_Uname, METH_NOARGS|METH_STATIC,
587  "ds.Uname -> nds - Return uname(2) dependency set.\n"},
588  {NULL, NULL} /* sentinel */
589 };
590 /*@=fullinitblock@*/
591 
592 /* ---------- */
593 
594 static void
596  /*@modifies s @*/
597 {
598  if (s) {
599  (void)rpmdsFree(s->ds);
600  s->ds = NULL;
601  PyObject_Del(s);
602  }
603 }
604 
605 static int
606 rpmds_print(rpmdsObject * s, FILE * fp, /*@unused@*/ int flags)
607  /*@globals fileSystem @*/
608  /*@modifies s, fp, fileSystem @*/
609 {
610  if (!(s && s->ds))
611  return -1;
612 
613  s->ds = rpmdsInit(s->ds);
614  while (rpmdsNext(s->ds) >= 0)
615  fprintf(fp, "%s\n", rpmdsDNEVR(s->ds));
616  return 0;
617 }
618 
619 static int
621  /*@*/
622 {
623  return rpmdsCount(s->ds);
624 }
625 
626 /*@null@*/
627 static PyObject *
629  /*@modifies s @*/
630 {
631  int ix;
632 
633  if (!PyInt_Check(key)) {
634  PyErr_SetString(PyExc_TypeError, "integer expected");
635  return NULL;
636  }
637 
638  ix = (int) PyInt_AsLong(key);
639  /* XXX make sure that DNEVR exists. */
640  rpmdsSetIx(s->ds, ix-1);
641  (void) rpmdsNext(s->ds);
642  return Py_BuildValue("s", rpmdsDNEVR(s->ds));
643 }
644 
645 static PyMappingMethods rpmds_as_mapping = {
646  (lenfunc) rpmds_length, /* mp_length */
647  (binaryfunc) rpmds_subscript, /* mp_subscript */
648  (objobjargproc)0, /* mp_ass_subscript */
649 };
650 
653 static int rpmds_init(rpmdsObject * s, PyObject *args, PyObject *kwds)
654  /*@globals rpmGlobalMacroContext @*/
655  /*@modifies s, rpmGlobalMacroContext @*/
656 {
657  hdrObject * ho = NULL;
658  PyObject * to = NULL;
659  rpmTag tagN = RPMTAG_REQUIRENAME;
660  rpmsenseFlags flags = 0;
661  char * kwlist[] = {"header", "tag", "flags", NULL};
662 
663 if (_rpmds_debug < 0)
664 fprintf(stderr, "*** rpmds_init(%p,%p,%p)\n", s, args, kwds);
665 
666  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oi:rpmds_init", kwlist,
667  &hdr_Type, &ho, &to, &flags))
668  return -1;
669 
670  if (to != NULL) {
671  tagN = tagNumFromPyObject(to);
672  if (tagN == (rpmTag)0xffffffff) {
673  PyErr_SetString(PyExc_KeyError, "unknown header tag");
674  return -1;
675  }
676  }
677  s->ds = rpmdsNew(hdrGetHeader(ho), tagN, flags);
678  s->active = 0;
679 
680  return 0;
681 }
682 
685 static void rpmds_free(/*@only@*/ rpmdsObject * s)
686  /*@modifies s @*/
687 {
688 if (_rpmds_debug)
689 fprintf(stderr, "%p -- ds %p\n", s, s->ds);
690  (void)rpmdsFree(s->ds);
691  s->ds = NULL;
692 
693  PyObject_Del((PyObject *)s);
694 }
695 
698 static PyObject * rpmds_alloc(PyTypeObject * subtype, int nitems)
699  /*@*/
700 {
701  PyObject * s = PyType_GenericAlloc(subtype, nitems);
702 
703 if (_rpmds_debug < 0)
704 fprintf(stderr, "*** rpmds_alloc(%p,%d) ret %p\n", subtype, nitems, s);
705  return s;
706 }
707 
710 /*@null@*/
711 static PyObject * rpmds_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
712  /*@globals rpmGlobalMacroContext @*/
713  /*@modifies rpmGlobalMacroContext @*/
714 {
715  rpmdsObject * s = (void *) PyObject_New(rpmdsObject, subtype);
716 
717  /* Perform additional initialization. */
718  if (rpmds_init(s, args, kwds) < 0) {
719  rpmds_free(s);
720  return NULL;
721  }
722 
723 if (_rpmds_debug)
724 fprintf(stderr, "%p ++ ds %p\n", s, s->ds);
725 
726  return (PyObject *)s;
727 }
728 
731 /*@unchecked@*/ /*@observer@*/
732 static char rpmds_doc[] =
733 "";
734 
735 /*@-fullinitblock@*/
736 PyTypeObject rpmds_Type = {
737  PyVarObject_HEAD_INIT(&PyType_Type, 0)
738  "rpm.ds", /* tp_name */
739  sizeof(rpmdsObject), /* tp_basicsize */
740  0, /* tp_itemsize */
741  /* methods */
742  (destructor) rpmds_dealloc, /* tp_dealloc */
743  (printfunc) rpmds_print, /* tp_print */
744  (getattrfunc)0, /* tp_getattr */
745  (setattrfunc)0, /* tp_setattr */
746  (cmpfunc) rpmds_compare, /* tp_compare */
747  (reprfunc)0, /* tp_repr */
748  0, /* tp_as_number */
749  0, /* tp_as_sequence */
750  &rpmds_as_mapping, /* tp_as_mapping */
751  (hashfunc)0, /* tp_hash */
752  (ternaryfunc)0, /* tp_call */
753  (reprfunc)0, /* tp_str */
754  PyObject_GenericGetAttr, /* tp_getattro */
755  PyObject_GenericSetAttr, /* tp_setattro */
756  0, /* tp_as_buffer */
757  Py_TPFLAGS_DEFAULT | /* tp_flags */
758  Py_TPFLAGS_HAVE_RICHCOMPARE,
759  rpmds_doc, /* tp_doc */
760 #if Py_TPFLAGS_HAVE_ITER
761  0, /* tp_traverse */
762  0, /* tp_clear */
763  (richcmpfunc) rpmds_richcompare,/* tp_richcompare */
764  0, /* tp_weaklistoffset */
765  (getiterfunc) rpmds_iter, /* tp_iter */
766  (iternextfunc) rpmds_iternext, /* tp_iternext */
767  rpmds_methods, /* tp_methods */
768  0, /* tp_members */
769  0, /* tp_getset */
770  0, /* tp_base */
771  0, /* tp_dict */
772  0, /* tp_descr_get */
773  0, /* tp_descr_set */
774  0, /* tp_dictoffset */
775  (initproc) rpmds_init, /* tp_init */
776  (allocfunc) rpmds_alloc, /* tp_alloc */
777  (newfunc) rpmds_new, /* tp_new */
778  (freefunc) rpmds_free, /* tp_free */
779  0, /* tp_is_gc */
780 #endif
781 };
782 /*@=fullinitblock@*/
783 
784 /* ---------- */
785 
787 {
788  return s->ds;
789 }
790 
791 rpmdsObject *
793 {
794  rpmdsObject * s = PyObject_New(rpmdsObject, &rpmds_Type);
795 
796  if (s == NULL)
797  return NULL;
798  s->ds = ds;
799  s->active = 0;
800  return s;
801 }
802 
803 rpmdsObject *
804 rpmds_Single(/*@unused@*/ PyObject * s, PyObject * args, PyObject * kwds)
805 {
806  PyObject * to = NULL;
807  rpmTag tagN = RPMTAG_PROVIDENAME;
808  const char * N;
809  const char * EVR = NULL;
810  rpmsenseFlags Flags = 0;
811  char * kwlist[] = {"to", "name", "evr", "flags", NULL};
812 
813  if (!PyArg_ParseTupleAndKeywords(args, kwds, "Os|si:Single", kwlist,
814  &to, &N, &EVR, &Flags))
815  return NULL;
816 
817  if (to != NULL) {
818  tagN = tagNumFromPyObject(to);
819  if (tagN == (rpmTag)0xffffffff) {
820  PyErr_SetString(PyExc_KeyError, "unknown header tag");
821  return NULL;
822  }
823  }
824  if (N != NULL) N = xstrdup(N);
825  if (EVR != NULL) EVR = xstrdup(EVR);
826  return rpmds_Wrap( rpmdsSingle(tagN, N, EVR, Flags) );
827 }
828 
829 rpmdsObject *
830 hdr_dsFromHeader(PyObject * s, PyObject * args, PyObject * kwds)
831 {
832  hdrObject * ho = (hdrObject *)s;
833  PyObject * to = NULL;
834  rpmTag tagN = RPMTAG_REQUIRENAME;
835  int flags = 0;
836  char * kwlist[] = {"to", "flags", NULL};
837 
838  if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:dsFromHeader", kwlist,
839  &to, &flags))
840  return NULL;
841 
842  if (to != NULL) {
843  tagN = tagNumFromPyObject(to);
844  if (tagN == (rpmTag)0xffffffff) {
845  PyErr_SetString(PyExc_KeyError, "unknown header tag");
846  return NULL;
847  }
848  }
849  return rpmds_Wrap( rpmdsNew(hdrGetHeader(ho), tagN, flags) );
850 }
851 
852 rpmdsObject *
853 hdr_dsOfHeader(PyObject * s)
854 {
855  hdrObject * ho = (hdrObject *)s;
856  int tagN = RPMTAG_PROVIDENAME;
857  int Flags = RPMSENSE_EQUAL;
858 
859  return rpmds_Wrap( rpmdsThis(hdrGetHeader(ho), tagN, Flags) );
860 }
rpmTag tagNumFromPyObject(PyObject *item)
Definition: header-py.c:362
rpmds rpmdsSingle(rpmTag tagN, const char *N, const char *EVR, evrFlags Flags)
Create, load and initialize a dependency set of size 1.
Definition: rpmds.c:609
const bson * b
Definition: bson.h:280
evrFlags rpmdsFlags(const rpmds ds)
Return current dependency flags.
Definition: rpmds.c:691
static void rpmds_ParseEVR(char *evr, const char **ep, const char **vp, const char **rp)
Split EVR into epoch, version, and release components.
Definition: rpmds-py.c:27
rpmds rpmdsInit(rpmds ds)
Initialize dependency set iterator.
Definition: rpmds.c:943
static PyObject * rpmds_Notify(rpmdsObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:313
static int compare_values(const char *str1, const char *str2)
Definition: rpmds-py.c:70
rpmPRCO rpmdsFreePRCO(rpmPRCO PRCO)
Free dependency set(s) container.
Definition: rpmds.c:2851
static char rpmds_doc[]
Definition: rpmds-py.c:732
static int rpmds_length(rpmdsObject *s)
Definition: rpmds-py.c:620
char * xstrdup(const char *str)
Definition: rpmmalloc.c:321
static PyObject * rpmds_Next(rpmdsObject *s)
Definition: rpmds-py.c:179
rpmdsObject * hdr_dsOfHeader(PyObject *s)
Definition: rpmds-py.c:853
static int rpmds_init(rpmdsObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:653
PyTypeObject rpmds_Type
Definition: rpmds-py.c:736
int rpmdsGetconf(rpmds *dsp, const char *path)
Load getconf provides into a dependency set.
Definition: rpmds.c:2716
int(* rpmvercmp)(const char *a, const char *b)
Segmented string compare vector.
Definition: rpmevr.c:379
static int rpmds_print(rpmdsObject *s, FILE *fp, int flags)
Definition: rpmds-py.c:606
static int rpmds_compare(rpmdsObject *a, rpmdsObject *b)
Definition: rpmds-py.c:82
static PyObject * rpmds_N(rpmdsObject *s)
Definition: rpmds-py.c:235
static PyObject * rpmds_Count(rpmdsObject *s)
Definition: rpmds-py.c:210
rpmTag rpmdsTagN(const rpmds ds)
Return current dependency type.
Definition: rpmds.c:702
static PyObject * rpmds_Sysinfo(rpmdsObject *s)
Definition: rpmds-py.c:461
static void rpmds_dealloc(rpmdsObject *s)
Definition: rpmds-py.c:595
static PyObject * rpmds_Refs(rpmdsObject *s)
Definition: rpmds-py.c:283
const char * rpmdsDNEVR(const rpmds ds)
Return current formatted dependency string.
Definition: rpmds.c:657
static PyObject * rpmds_Find(rpmdsObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:348
struct rpmds_s * rpmds
Dependency tag sets from a header, so that a header can be discarded early.
Definition: rpmtypes.h:28
struct rpmPRCO_s * rpmPRCO
Container for commonly extracted dependency set(s).
Definition: rpmtypes.h:33
rpmds rpmdsFree(rpmds ds)
Destroy a dependency set.
static PyObject * rpmds_iter(rpmdsObject *s)
Definition: rpmds-py.c:134
Header hdrGetHeader(hdrObject *s)
Definition: header-py.c:685
rpmPRCO rpmdsNewPRCO(Header h)
Create dependency set(s) container.
Definition: rpmds.c:2876
rpmint32_t rpmdsResult(const rpmds ds)
Return current dependency comparison result.
Definition: rpmds.c:869
int rpmdsSysinfo(rpmPRCO PRCO, const char *fn)
Load sysinfo dependencies into a dependency set.
Definition: rpmds.c:1756
time_t rpmdsBT(const rpmds ds)
Return dependency build time.
Definition: rpmds.c:720
int rpmdsRpmlib(rpmds *dsp, void *tblp)
Load rpmlib provides into a dependency set.
Definition: rpmds.c:1587
struct rpmdsObject_s rpmdsObject
int rpmdsCompare(const rpmds A, const rpmds B)
Compare two versioned dependency ranges, looking for overlap.
Definition: rpmds.c:4035
rpmdsObject * hdr_dsFromHeader(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:830
static PyObject * rpmds_Getconf(rpmdsObject *s)
Definition: rpmds-py.c:477
int rpmdsFind(rpmds ds, const rpmds ods)
Find a dependency set element using binary search.
Definition: rpmds.c:998
enum evrFlags_e rpmsenseFlags
Definition: rpmevr.h:74
static PyMappingMethods rpmds_as_mapping
Definition: rpmds-py.c:645
static PyObject * rpmds_iternext(rpmdsObject *s)
Definition: rpmds-py.c:143
void rpmdsNotify(rpmds ds, const char *where, int rc)
Notify of results of dependency match.
Definition: rpmds.c:899
const char * rpmdsEVR(const rpmds ds)
Return current dependency epoch-version-release.
Definition: rpmds.c:680
int rpmdsNext(rpmds ds)
Return next dependency set iterator index.
Definition: rpmds.c:912
rpmds dsFromDs(rpmdsObject *s)
Definition: rpmds-py.c:786
static void rpmds_free(rpmdsObject *s)
Definition: rpmds-py.c:685
static PyObject * rpmds_new(PyTypeObject *subtype, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:711
rpmdsObject * rpmds_Wrap(rpmds ds)
Definition: rpmds-py.c:792
rpmds ds
Definition: rpmds-py.h:20
static PyObject * rpmds_richcompare(rpmdsObject *a, rpmdsObject *b, int op)
Definition: rpmds-py.c:109
static struct PyMethodDef rpmds_methods[]
Definition: rpmds-py.c:522
const char const bson const bson * op
Definition: mongo.h:505
int rpmdsCount(const rpmds ds)
Return dependency set count.
Definition: rpmds.c:636
static PyObject * rpmds_alloc(PyTypeObject *subtype, int nitems)
Definition: rpmds-py.c:698
PyTypeObject hdr_Type
Definition: header-py.c:633
static PyObject * rpmds_Rpmlib(rpmdsObject *s)
Definition: rpmds-py.c:448
const char * rpmdsN(const rpmds ds)
Return current dependency name.
Definition: rpmds.c:668
const char const bson int mongo_write_concern int flags
Definition: mongo.h:485
static PyObject * rpmds_Ix(rpmdsObject *s)
Definition: rpmds-py.c:219
rpmdsObject * rpmds_Single(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:804
static PyObject * rpmds_SetNoPromote(rpmdsObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:298
static int xisdigit(int c)
Definition: rpmiotypes.h:546
static PyObject * rpmds_Result(rpmdsObject *s)
Definition: rpmds-py.c:291
const char const bson * key
Definition: mongo.h:717
rpmds rpmdsLink(rpmds ds, const char *msg)
Reference a dependency set instance.
static PyObject * rpmds_Merge(rpmdsObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:369
static PyObject * rpmds_BT(rpmdsObject *s)
Definition: rpmds-py.c:259
int rpmdsMerge(rpmds *dsp, rpmds ods)
Merge a dependency set maintaining (N,EVR,Flags) sorted order.
Definition: rpmds.c:1030
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:756
static PyObject * rpmds_Cpuinfo(rpmdsObject *s)
Definition: rpmds-py.c:435
int rpmdsCpuinfo(rpmds *dsp, const char *fn)
Load /proc/cpuinfo provides into a dependency set.
Definition: rpmds.c:1316
int rpmdsLdconfig(rpmPRCO PRCO, const char *fn)
Load /etc/ld.so.cache provides into a dependency set.
Definition: rpmds.c:3501
int _rpmds_debug
Definition: rpmds.c:123
int rpmdsUname(rpmds *dsp, const struct utsname *un)
Definition: rpmds.c:3805
static PyObject * rpmds_Flags(rpmdsObject *s)
Definition: rpmds-py.c:251
static PyObject * rpmds_Sort(rpmdsObject *s)
Definition: rpmds-py.c:332
int rpmdsSearch(rpmds ds, rpmds ods)
Search a sorted dependency set for an element that overlaps.
Definition: rpmds.c:1108
static PyObject * rpmds_EVR(rpmdsObject *s)
Definition: rpmds-py.c:243
int rpmdsIx(const rpmds ds)
Return dependency set index.
Definition: rpmds.c:641
rpmuint32_t rpmdsColor(const rpmds ds)
Return current dependency color.
Definition: rpmds.c:789
static PyObject * rpmds_DNEVR(rpmdsObject *s)
Definition: rpmds-py.c:227
enum rpmTag_e rpmTag
Definition: rpmtag.h:470
rpmuint32_t rpmdsRefs(const rpmds ds)
Return current dependency file refs.
Definition: rpmds.c:839
static PyObject * rpmds_Search(rpmdsObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:386
rpmds rpmdsNew(Header h, rpmTag tagN, int flags)
Create and load a dependency set.
Definition: rpmds.c:238
int rpmdsSetNoPromote(rpmds ds, int nopromote)
Set "Don't promote Epoch:" flag.
Definition: rpmds.c:755
static PyObject * rpmds_Ldconfig(rpmdsObject *s)
Definition: rpmds-py.c:490
int rpmdsSetIx(rpmds ds, int ix)
Set dependency set index.
Definition: rpmds.c:646
static PyObject * rpmds_Debug(rpmdsObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:195
static PyObject * rpmds_Color(rpmdsObject *s)
Definition: rpmds-py.c:275
rpmds rpmdsThis(Header h, rpmTag tagN, evrFlags Flags)
Create, load and initialize a dependency for this header.
Definition: rpmds.c:513
static PyObject * rpmds_subscript(rpmdsObject *s, PyObject *key)
Definition: rpmds-py.c:628
static int nitems
Definition: rpmcache.c:81
static PyObject * rpmds_Uname(rpmdsObject *s)
Definition: rpmds-py.c:506
static PyObject * rpmds_TagN(rpmdsObject *s)
Definition: rpmds-py.c:267
rpmds rpmdsFromPRCO(rpmPRCO PRCO, rpmTag tagN)
Retrieve a dependency set from container.
Definition: rpmds.c:2901