rpm  5.4.15
header-py.c
Go to the documentation of this file.
1 
5 #include "system-py.h"
6 
7 #include "rpmio_internal.h"
8 #include <rpmcb.h>
9 
10 #include "legacy.h"
11 #define _RPMTAG_INTERNAL
12 #include "header_internal.h" /* XXX HEADERFLAG_ALLOCATED */
13 #include "rpmtypes.h"
14 #define _RPMEVR_INTERNAL
15 #include "rpmevr.h"
16 #include "pkgio.h" /* XXX rpmpkgRead */
17 
18 #include "rpmts.h" /* XXX rpmtsCreate/rpmtsFree */
19 
20 #include "rpmcli.h"
21 
22 #include "header-py.h"
23 #include "rpmds-py.h"
24 #include "rpmfi-py.h"
25 
26 #include "debug.h"
27 
138 struct hdrObject_s {
139  PyObject_HEAD
141 } ;
142 
145 /*@unused@*/ static inline Header headerAllocated(Header h)
146  /*@modifies h @*/
147 {
149  return 0;
150 }
151 
152 static PyObject *hdrIsSource(hdrObject *s)
153 {
154  int isSource = !headerIsEntry(s->h, RPMTAG_SOURCERPM);
155  return PyBool_FromLong(isSource);
156 }
157 
162 
165 static PyObject * hdrKeyList(hdrObject * s)
166  /*@*/
167 {
168  HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
169  PyObject * list, *o;
170  HeaderIterator hi;
171 
172  list = PyList_New(0);
173  if (!list) {
174  return NULL;
175  }
176  for (hi = headerInit(s->h);
177  headerNext(hi, he, 0);
178  he->p.ptr = _free(he->p.ptr))
179  {
180  if (he->tag == HEADER_I18NTABLE) continue;
181  switch (he->t) {
182  case RPM_I18NSTRING_TYPE:
183 #if !defined(SUPPORT_I18NSTRING_TYPE)
184 assert(0);
185 #endif
186  break;
187  case RPM_BIN_TYPE:
188  case RPM_UINT64_TYPE:
189  case RPM_UINT32_TYPE:
190  case RPM_UINT16_TYPE:
191  case RPM_UINT8_TYPE:
193  case RPM_STRING_TYPE:
194  o=PyInt_FromLong(he->tag);
195  if (!o) {
196  hi = headerFini(hi);
197  Py_XDECREF(list);
198  return NULL;
199  }
200  PyList_Append(list, o);
201  Py_XDECREF(o);
202  break;
203  }
204  }
205  hi = headerFini(hi);
206 
207  return list;
208 }
209 
212 static PyObject * hdrUnload(hdrObject * s, PyObject * args, PyObject *keywords)
213  /*@*/
214 {
215  char * buf;
216  PyObject * rc;
217  int legacy = 0;
218  int nb;
219  Header h;
220  static char *kwlist[] = { "legacyHeader", NULL};
221 
222  if (!PyArg_ParseTupleAndKeywords(args, keywords, "|i", kwlist, &legacy))
223  return NULL;
224 
225  h = headerLink(s->h);
226  /* XXX this legacy switch is a hack, needs to be removed. */
227  if (legacy) {
228  h = headerCopy(s->h); /* XXX strip region tags, etc */
229  (void)headerFree(s->h);
230  s->h = NULL;
231  }
232  { size_t len;
233  buf = headerUnload(h, &len);
234  nb = len;
235  nb -= 8; /* XXX HEADER_MAGIC_NO */
236  }
237  (void)headerFree(h);
238  h = NULL;
239 
240  if (buf == NULL || nb == 0) {
241  PyErr_SetString(pyrpmError, "can't unload bad header\n");
242  return NULL;
243  }
244 
245  rc = PyString_FromStringAndSize(buf, nb);
246  buf = _free(buf);
247 
248  return rc;
249 }
250 
253 static PyObject * hdrGetOrigin(hdrObject * s)
254  /*@*/
255 {
256  const char * origin = NULL;
257  if (s->h != NULL)
258 
259  origin = headerGetOrigin(s->h);
260  if (origin != NULL)
261  return Py_BuildValue("s", origin);
262  Py_RETURN_NONE;
263 }
264 
267 static PyObject * hdrSetOrigin(hdrObject * s, PyObject * args, PyObject * kwds)
268  /*@*/
269 {
270  char * kwlist[] = {"origin", NULL};
271  const char * origin = NULL;
272 
273  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s:SetOrigin", kwlist, &origin))
274  return NULL;
275 
276  if (s->h != NULL && origin != NULL)
277  headerSetOrigin(s->h, origin);
278 
279  Py_RETURN_NONE;
280 }
281 
284 static PyObject * hdrSprintf(hdrObject * s, PyObject * args, PyObject * kwds)
285  /*@*/
286 {
287  char * fmt;
288  char * r;
289  errmsg_t err;
290  PyObject * result;
291  char * kwlist[] = {"format", NULL};
292 
293  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &fmt))
294  return NULL;
295 
296  r = headerSprintf(s->h, fmt, NULL, rpmHeaderFormats, &err);
297  if (!r) {
298  PyErr_SetString(pyrpmError, err);
299  return NULL;
300  }
301 
302  result = Py_BuildValue("s", r);
303  r = _free(r);
304 
305  return result;
306 }
307 
312 /*@unchecked@*/ /*@observer@*/
313 static struct PyMethodDef hdr_methods[] = {
314  {"keys", (PyCFunction) hdrKeyList, METH_NOARGS,
315  NULL },
316  {"unload", (PyCFunction) hdrUnload, METH_VARARGS|METH_KEYWORDS,
317  NULL },
318  {"getorigin", (PyCFunction) hdrGetOrigin, METH_NOARGS,
319  NULL },
320  {"setorigin", (PyCFunction) hdrSetOrigin, METH_VARARGS|METH_KEYWORDS,
321  NULL },
322  {"sprintf", (PyCFunction) hdrSprintf, METH_VARARGS|METH_KEYWORDS,
323  NULL },
324  {"isSource", (PyCFunction)hdrIsSource, METH_NOARGS,
325  NULL },
326 
327  {"dsOfHeader", (PyCFunction)hdr_dsOfHeader, METH_NOARGS,
328  NULL},
329  {"dsFromHeader", (PyCFunction)hdr_dsFromHeader, METH_VARARGS|METH_KEYWORDS,
330  NULL},
331  {"fiFromHeader", (PyCFunction)hdr_fiFromHeader, METH_VARARGS|METH_KEYWORDS,
332  NULL},
333 
334  {NULL, NULL} /* sentinel */
335 };
336 
339 static int hdr_compare(hdrObject * a, hdrObject * b)
340  /*@*/
341 {
342  return rpmVersionCompare(a->h, b->h);
343 }
344 
345 static long hdr_hash(PyObject * h)
346 {
347  return (long) h;
348 }
349 
352 static void hdr_dealloc(hdrObject * s)
353  /*@*/
354 {
355  if (s->h) (void ) headerFree(s->h);
356  s->h = NULL;
357  PyObject_Del(s);
358 }
359 
362 rpmTag tagNumFromPyObject (PyObject *item)
363 {
364  char * str;
365 
366  if (PyInt_Check(item)) {
367  return (rpmTag) PyInt_AsLong(item);
368  } else if (PyString_Check(item) || PyUnicode_Check(item)) {
369  str = PyString_AsString(item);
370  return tagValue(str);
371  }
372  return (rpmTag)0xffffffff;
373 }
374 
377 static PyObject * hdr_subscript(hdrObject * s, PyObject * item)
378  /*@*/
379 {
380  HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
381  rpmTag tag = (rpmTag)0xffffffff;
382  uint32_t i;
383  PyObject * o, * metao;
384  int forceArray = 0;
385  const struct headerSprintfExtension_s * ext = NULL;
386  int xx;
387 
388  if (PyCObject_Check (item))
389  ext = PyCObject_AsVoidPtr(item);
390  else
391  tag = tagNumFromPyObject (item);
392 
393  if (tag == (rpmTag)0xffffffff && (PyString_Check(item) || PyUnicode_Check(item))) {
394  const struct headerSprintfExtension_s * extensions = rpmHeaderFormats;
395  char * str;
396  /* if we still don't have the tag, go looking for the header
397  extensions */
398  str = PyString_AsString(item);
399  while (extensions->name) {
400  if (extensions->type == HEADER_EXT_TAG
401  && !xstrcasecmp(extensions->name + 7, str)) {
402  ext = extensions;
403  }
404  extensions++;
405  if (extensions->type == HEADER_EXT_MORE)
406  extensions = *extensions->u.more;
407  }
408  }
409 
410  /* Retrieve data from extension or header. */
411  if (ext) {
412  ext->u.tagFunction(s->h, he);
413  } else {
414  if (tag == (rpmTag)0xffffffff) {
415  PyErr_SetString(PyExc_KeyError, "unknown header tag");
416  return NULL;
417  }
418 
419  he->tag = tag;
420  xx = headerGet(s->h, he, 0);
421  if (!xx) {
422  he->p.ptr = _free(he->p.ptr);
423  switch (tag) {
424  case RPMTAG_EPOCH:
425  case RPMTAG_NAME:
426  case RPMTAG_VERSION:
427  case RPMTAG_RELEASE:
428  case RPMTAG_DISTEPOCH:
429  case RPMTAG_ARCH:
430  case RPMTAG_OS:
431  Py_RETURN_NONE;
432  break;
433  default:
434  return PyList_New(0);
435  break;
436  }
437  }
438  }
439 
440  switch (tag) {
441  case RPMTAG_FILEPATHS:
442  case RPMTAG_ORIGPATHS:
443  case RPMTAG_OLDFILENAMES:
444  case RPMTAG_FILESIZES:
445  case RPMTAG_FILESTATES:
446  case RPMTAG_FILEMODES:
447  case RPMTAG_FILEUIDS:
448  case RPMTAG_FILEGIDS:
449  case RPMTAG_FILERDEVS:
450  case RPMTAG_FILEMTIMES:
451  case RPMTAG_FILEMD5S:
452  case RPMTAG_FILELINKTOS:
453  case RPMTAG_FILEFLAGS:
454  case RPMTAG_ROOT:
455  case RPMTAG_FILEUSERNAME:
457  case RPMTAG_REQUIRENAME:
458  case RPMTAG_REQUIREFLAGS:
460  case RPMTAG_PROVIDENAME:
461  case RPMTAG_PROVIDEFLAGS:
463  case RPMTAG_OBSOLETENAME:
466  case RPMTAG_CONFLICTNAME:
471  forceArray = 1;
472  break;
473  default:
474  break;
475  }
476 
477  switch (he->t) {
478  case RPM_BIN_TYPE:
479  o = PyString_FromStringAndSize(he->p.str, he->c);
480  break;
481 
482  case RPM_UINT8_TYPE:
483  if (he->c != 1 || forceArray) {
484  metao = PyList_New(0);
485  if (!metao) {
486  return NULL;
487  }
488  for (i = 0; i < he->c; i++) {
489  o = PyInt_FromLong(he->p.ui8p[i]);
490  if (!o) {
491  Py_XDECREF(metao);
492  return NULL;
493  }
494  PyList_Append(metao, o);
495  Py_XDECREF(o);
496  }
497  o = metao;
498  } else {
499  o = PyInt_FromLong(he->p.ui8p[0]);
500  }
501  break;
502 
503  case RPM_UINT16_TYPE:
504  if (he->c != 1 || forceArray) {
505  metao = PyList_New(0);
506  if (!metao) {
507  return NULL;
508  }
509  for (i = 0; i < he->c; i++) {
510  o = PyInt_FromLong(he->p.ui16p[i]);
511  if (!o) {
512  Py_XDECREF(metao);
513  return NULL;
514  }
515  PyList_Append(metao, o);
516  Py_XDECREF(o);
517  }
518  o = metao;
519  } else {
520  o = PyInt_FromLong(he->p.ui16p[0]);
521  }
522  break;
523 
524  case RPM_UINT32_TYPE:
525  if (he->c != 1 || forceArray) {
526  metao = PyList_New(0);
527  if (!metao) {
528  return NULL;
529  }
530  for (i = 0; i < he->c; i++) {
531  o = PyInt_FromLong(he->p.ui32p[i]);
532  if (!o) {
533  Py_XDECREF(metao);
534  return NULL;
535  }
536  PyList_Append(metao, o);
537  Py_XDECREF(o);
538  }
539  o = metao;
540  } else {
541  o = PyInt_FromLong(he->p.ui32p[0]);
542  }
543  break;
544 
545  case RPM_UINT64_TYPE:
546  if (he->c != 1 || forceArray) {
547  metao = PyList_New(0);
548  if (!metao) {
549  return NULL;
550  }
551  for (i = 0; i < he->c; i++) {
552  o = PyInt_FromLong(he->p.ui64p[i]);
553  if (!o) {
554  Py_XDECREF(metao);
555  return NULL;
556  }
557  PyList_Append(metao, o);
558  Py_XDECREF(o);
559  }
560  o = metao;
561  } else {
562  o = PyInt_FromLong(he->p.ui64p[0]);
563  }
564  break;
565 
567  metao = PyList_New(0);
568  if (!metao) {
569  return NULL;
570  }
571  for (i = 0; i < he->c; i++) {
572  o = PyString_FromString(he->p.argv[i]);
573  if (!o) {
574  Py_XDECREF(metao);
575  return NULL;
576  }
577  PyList_Append(metao, o);
578  Py_XDECREF(o);
579  }
580  o = metao;
581  break;
582 
583  case RPM_STRING_TYPE:
584  if (he->p.str != NULL)
585  o = PyString_FromString(he->p.str);
586  else
587  o = PyString_FromString("");
588  break;
589 
590  default:
591  PyErr_SetString(PyExc_TypeError, "unsupported type in header");
592  return NULL;
593  }
594  if (he->freeData)
595  he->p.ptr = _free(he->p.ptr);
596 
597  return o;
598 }
599 
602 /*@unchecked@*/ /*@observer@*/
603 static PyMappingMethods hdr_as_mapping = {
604  (lenfunc) 0, /* mp_length */
605  (binaryfunc) hdr_subscript, /* mp_subscript */
606  (objobjargproc) 0, /* mp_ass_subscript */
607 };
608 
609 static PyObject * hdr_getattro(hdrObject * o, PyObject * n)
610  /*@*/
611 {
612  PyObject * res;
613  res = PyObject_GenericGetAttr((PyObject *)o, n);
614  if (res == NULL)
615  res = hdr_subscript(o, n);
616  return res;
617 }
618 
619 static int hdr_setattro(hdrObject * o, PyObject * n, PyObject * v)
620  /*@*/
621 {
622  return PyObject_GenericSetAttr((PyObject *)o, n, v);
623 }
624 
627 static char hdr_doc[] =
628 "";
629 
632 /*@unchecked@*/ /*@observer@*/
633 PyTypeObject hdr_Type = {
634  PyVarObject_HEAD_INIT(&PyType_Type, 0)
635  "rpm.hdr", /* tp_name */
636  sizeof(hdrObject), /* tp_size */
637  0, /* tp_itemsize */
638  (destructor) hdr_dealloc, /* tp_dealloc */
639  0, /* tp_print */
640  (getattrfunc) 0, /* tp_getattr */
641  0, /* tp_setattr */
642  (cmpfunc) hdr_compare, /* tp_compare */
643  0, /* tp_repr */
644  0, /* tp_as_number */
645  0, /* tp_as_sequence */
646  &hdr_as_mapping, /* tp_as_mapping */
647  hdr_hash, /* tp_hash */
648  0, /* tp_call */
649  0, /* tp_str */
650  (getattrofunc) hdr_getattro, /* tp_getattro */
651  (setattrofunc) hdr_setattro, /* tp_setattro */
652  0, /* tp_as_buffer */
653  Py_TPFLAGS_DEFAULT, /* tp_flags */
654  hdr_doc, /* tp_doc */
655 #if Py_TPFLAGS_HAVE_ITER
656  0, /* tp_traverse */
657  0, /* tp_clear */
658  0, /* tp_richcompare */
659  0, /* tp_weaklistoffset */
660  0, /* tp_iter */
661  0, /* tp_iternext */
662  hdr_methods, /* tp_methods */
663  0, /* tp_members */
664  0, /* tp_getset */
665  0, /* tp_base */
666  0, /* tp_dict */
667  0, /* tp_descr_get */
668  0, /* tp_descr_set */
669  0, /* tp_dictoffset */
670  0, /* tp_init */
671  0, /* tp_alloc */
672  0, /* tp_new */
673  0, /* tp_free */
674  0, /* tp_is_gc */
675 #endif
676 };
677 
679 {
680  hdrObject * hdr = PyObject_New(hdrObject, &hdr_Type);
681  hdr->h = headerLink(h);
682  return hdr;
683 }
684 
686 {
687  return s->h;
688 }
689 
692 PyObject * hdrLoad(PyObject * self, PyObject * args, PyObject * kwds)
693 {
694  hdrObject * hdr;
695  char * copy = NULL;
696  char * obj;
697  Header h;
698  int len;
699  char * kwlist[] = {"headers", NULL};
700 
701  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", kwlist, &obj, &len))
702  return NULL;
703 
704  /* malloc is needed to avoid surprises from data swab in headerLoad(). */
705  copy = malloc(len);
706  if (copy == NULL) {
707  PyErr_SetString(pyrpmError, "out of memory");
708  return NULL;
709  }
710  memcpy (copy, obj, len);
711 
712  h = headerLoad(copy);
713  if (!h) {
714  PyErr_SetString(pyrpmError, "bad header");
715  return NULL;
716  }
717  headerAllocated(h);
718 
719  hdr = hdr_Wrap(h);
720  (void)headerFree(h); /* XXX ref held by hdr */
721  h = NULL;
722 
723  return (PyObject *) hdr;
724 }
725 
728 PyObject * rpmReadHeaders (FD_t fd)
729 {
730  PyObject * list;
731  Header h;
732  hdrObject * hdr;
733 
734  if (!fd) {
735  PyErr_SetFromErrno(pyrpmError);
736  return NULL;
737  }
738 
739  list = PyList_New(0);
740  if (!list) {
741  return NULL;
742  }
743  Py_BEGIN_ALLOW_THREADS
744  { const char item[] = "Header";
745  const char * msg = NULL;
746  rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
747  if(rc == RPMRC_NOTFOUND) {
748  Py_INCREF(Py_None);
749  list = Py_None;
750  }
751  else if (rc != RPMRC_OK)
752  rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
753  msg = _free(msg);
754  }
755  Py_END_ALLOW_THREADS
756 
757  while (h) {
758  hdr = hdr_Wrap(h);
759  if (PyList_Append(list, (PyObject *) hdr)) {
760  Py_XDECREF(list);
761  Py_XDECREF(hdr);
762  return NULL;
763  }
764  Py_XDECREF(hdr);
765 
766  (void)headerFree(h); /* XXX ref held by hdr */
767  h = NULL;
768 
769  Py_BEGIN_ALLOW_THREADS
770  { const char item[] = "Header";
771  const char * msg = NULL;
772  rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
773  if(rc == RPMRC_NOTFOUND) {
774  Py_INCREF(Py_None);
775  list = Py_None;
776  }
777  else if (rc != RPMRC_OK)
778  rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
779  msg = _free(msg);
780  }
781  Py_END_ALLOW_THREADS
782  }
783 
784  return list;
785 }
786 
789 PyObject * rpmHeaderFromFD(PyObject * self, PyObject * args,
790  PyObject * kwds)
791 {
792  FD_t fd;
793  int fileno;
794  PyObject * list;
795  char * kwlist[] = {"fd", NULL};
796 
797  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &fileno))
798  return NULL;
799 
800  fd = fdDup(fileno);
801 
802  list = rpmReadHeaders (fd);
803  Fclose(fd);
804 
805  return list;
806 }
807 
810 PyObject * rpmHeaderFromFile(PyObject * self, PyObject * args,
811  PyObject *kwds)
812 {
813  char * filespec;
814  FD_t fd;
815  PyObject * list;
816  char * kwlist[] = {"file", NULL};
817 
818  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &filespec))
819  return NULL;
820 
821  fd = Fopen(filespec, "r.fdio");
822 
823  if (!fd) {
824  PyErr_SetFromErrno(pyrpmError);
825  return NULL;
826  }
827 
828  list = rpmReadHeaders (fd);
829  Fclose(fd);
830 
831  return list;
832 }
833 
836 PyObject *
837 rpmSingleHeaderFromFD(PyObject * self, PyObject * args,
838  PyObject * kwds)
839 {
840  FD_t fd;
841  int fileno;
842  off_t offset;
843  PyObject * tuple;
844  Header h;
845  char * kwlist[] = {"fd", NULL};
846 
847  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &fileno))
848  return NULL;
849 
850  offset = lseek(fileno, 0, SEEK_CUR);
851 
852  fd = fdDup(fileno);
853 
854  if (!fd) {
855  PyErr_SetFromErrno(pyrpmError);
856  return NULL;
857  }
858 
859  Py_BEGIN_ALLOW_THREADS
860  { const char item[] = "Header";
861  const char * msg = NULL;
862  rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
863  if(rc == RPMRC_NOTFOUND) {
864  Py_INCREF(Py_None);
865  tuple = Py_None;
866  }
867  else if (rc != RPMRC_OK)
868  rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
869  msg = _free(msg);
870  }
871  Py_END_ALLOW_THREADS
872 
873  Fclose(fd);
874 
875  tuple = PyTuple_New(2);
876 
877  if (h && tuple) {
878  PyTuple_SET_ITEM(tuple, 0, (PyObject *) hdr_Wrap(h));
879  PyTuple_SET_ITEM(tuple, 1, PyLong_FromLong(offset));
880  (void)headerFree(h);
881  h = NULL;
882  } else {
883  Py_INCREF(Py_None);
884  Py_INCREF(Py_None);
885  PyTuple_SET_ITEM(tuple, 0, Py_None);
886  PyTuple_SET_ITEM(tuple, 1, Py_None);
887  }
888 
889  return tuple;
890 }
891 
894 PyObject * rpmWriteHeaders (PyObject * list, FD_t fd)
895 {
896  int count;
897 
898  if (!fd) {
899  PyErr_SetFromErrno(pyrpmError);
900  return NULL;
901  }
902 
903  for(count = 0; count < PyList_Size(list); count++){
904  Py_BEGIN_ALLOW_THREADS
905  const char item[] = "Header";
906  const char * msg = NULL;
907  hdrObject * hdr = (hdrObject *)PyList_GetItem(list, count);
908  rpmRC rc = rpmpkgWrite(item, fd, hdr->h, &msg);
909  if (rc != RPMRC_OK)
910  rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgWrite", item, msg, rc);
911  msg = _free(msg);
912  Py_END_ALLOW_THREADS
913  }
914 
915  Py_RETURN_TRUE;
916 }
917 
920 PyObject * rpmHeaderToFD(PyObject * self, PyObject * args,
921  PyObject * kwds)
922 {
923  FD_t fd;
924  int fileno;
925  PyObject * list;
926  PyObject * ret;
927  char * kwlist[] = {"headers", "fd", NULL};
928 
929  if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oi", kwlist, &list, &fileno))
930  return NULL;
931 
932  fd = fdDup(fileno);
933 
934  ret = rpmWriteHeaders (list, fd);
935  Fclose(fd);
936 
937  return list;
938 }
939 
942 PyObject * rpmHeaderToFile(PyObject * self, PyObject * args,
943  PyObject *kwds)
944 {
945  char * filespec;
946  FD_t fd;
947  PyObject * list;
948  PyObject * ret;
949  char * kwlist[] = {"headers", "file", NULL};
950 
951  if (!PyArg_ParseTupleAndKeywords(args, kwds, "Os", kwlist, &list, &filespec))
952  return NULL;
953 
954  fd = Fopen(filespec, "w.fdio");
955  if (!fd) {
956  PyErr_SetFromErrno(pyrpmError);
957  return NULL;
958  }
959 
960  ret = rpmWriteHeaders (list, fd);
961  Fclose(fd);
962 
963  return ret;
964 }
965 
968 PyObject * versionCompare (PyObject * self, PyObject * args,
969  PyObject * kwds)
970 {
971  hdrObject * h1, * h2;
972  char * kwlist[] = {"version0", "version1", NULL};
973 
974  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", kwlist, &hdr_Type,
975  &h1, &hdr_Type, &h2))
976  return NULL;
977 
978  return Py_BuildValue("i", hdr_compare(h1, h2));
979 }
980 
981 PyObject * labelCompare (PyObject * self, PyObject * args)
982 {
985  int rc;
986  PyObject *aTuple, *bTuple;
987 
988  if (!PyArg_ParseTuple(args, "OO", &aTuple, &bTuple) ||
989  !PyArg_ParseTuple(aTuple, "zzz|z",
990  &a->F[RPMEVR_E], &a->F[RPMEVR_V], &a->F[RPMEVR_R], &a->F[RPMEVR_D]) ||
991  !PyArg_ParseTuple(bTuple, "zzz|z",
992  &b->F[RPMEVR_E], &b->F[RPMEVR_V], &b->F[RPMEVR_R], &b->F[RPMEVR_D]))
993  {
994  a = rpmEVRfree(a);
995  b = rpmEVRfree(b);
996  return NULL;
997  }
998 
999  /* XXX HACK: postpone committing to single "missing" value for now. */
1000  if (a->F[RPMEVR_E] == NULL) a->F[RPMEVR_E] = "0";
1001  if (b->F[RPMEVR_E] == NULL) b->F[RPMEVR_E] = "0";
1002  if (a->F[RPMEVR_V] == NULL) a->F[RPMEVR_V] = "";
1003  if (b->F[RPMEVR_V] == NULL) b->F[RPMEVR_V] = "";
1004  if (a->F[RPMEVR_R] == NULL) a->F[RPMEVR_R] = "";
1005  if (b->F[RPMEVR_R] == NULL) b->F[RPMEVR_R] = "";
1006  if (a->F[RPMEVR_D] == NULL) a->F[RPMEVR_D] = "";
1007  if (b->F[RPMEVR_D] == NULL) b->F[RPMEVR_D] = "";
1008 
1009  rc = rpmEVRcompare(a, b);
1010 
1011  a = rpmEVRfree(a);
1012  b = rpmEVRfree(b);
1013 
1014  return Py_BuildValue("i", rc);
1015 }
1016 
1017 PyObject * evrCompare (PyObject * self, PyObject * args,
1018  PyObject * kwds)
1019 {
1020  EVR_t lEVR = NULL;
1021  EVR_t rEVR = NULL;
1022  int rc;
1023  char * evr1, * evr2;
1024  char * kwlist[] = {"evr0", "evr1", NULL};
1025 
1026  if (!PyArg_ParseTupleAndKeywords(args, kwds, "ss", kwlist, &evr1, &evr2))
1027  return NULL;
1028 
1029  lEVR = rpmEVRnew(RPMSENSE_EQUAL, 0);
1030  rEVR = rpmEVRnew(RPMSENSE_EQUAL, 0);
1031  rpmEVRparse(evr1, lEVR);
1032  rpmEVRparse(evr2, rEVR);
1033  rc = rpmEVRcompare(lEVR, rEVR);
1034  lEVR = rpmEVRfree(lEVR);
1035  rEVR = rpmEVRfree(rEVR);
1036 
1037  return PyLong_FromLong(rc);
1038 }
1039 
1040 PyObject * evrSplit (PyObject * self, PyObject * args, PyObject * kwds)
1041 {
1042  EVR_t EVR = rpmEVRnew(RPMSENSE_EQUAL, 0);
1043  char * evr;
1044  char * kwlist[] = {"evr", NULL};
1045  PyObject * tuple = NULL;
1046 
1047  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &evr))
1048  goto exit;
1049 
1050  rpmEVRparse(evr, EVR);
1051  tuple = Py_BuildValue("(Isss)", EVR->F[RPMEVR_E] ? atoi(EVR->F[RPMEVR_E]) : 0, EVR->F[RPMEVR_V], EVR->F[RPMEVR_R], EVR->F[RPMEVR_D]);
1052 
1053 exit:
1054  EVR = rpmEVRfree(EVR);
1055 
1056  return tuple;
1057 }
rpmTag tagNumFromPyObject(PyObject *item)
Definition: header-py.c:362
const bson * b
Definition: bson.h:280
rpmTagType t
Definition: rpmtag.h:504
hdrObject * hdr_Wrap(Header h)
Definition: header-py.c:678
const char * str
Definition: rpmtag.h:73
rpmTag tag
Definition: rpmtag.h:503
static PyObject * hdrGetOrigin(hdrObject *s)
Definition: header-py.c:253
PyObject * rpmHeaderToFile(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:942
const char ** argv
Definition: rpmtag.h:75
rpmfiObject * hdr_fiFromHeader(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmfi-py.c:598
int headerIsEntry(Header h, rpmTag tag)
Check if tag is in header.
Definition: header.c:1439
#define RPMTAG_FILEMD5S
Definition: rpmtag.h:215
const char const char size_t len
Definition: bson.h:823
static PyObject * hdr_getattro(hdrObject *o, PyObject *n)
Definition: header-py.c:609
#define SEEK_CUR
Definition: system.h:227
rpmRC rpmpkgWrite(const char *fn, FD_t fd, void *ptr, const char **msg)
Write item onto file descriptor.
Definition: pkgio.c:1692
PyObject * rpmWriteHeaders(PyObject *list, FD_t fd)
Definition: header-py.c:894
rpmdsObject * hdr_dsOfHeader(PyObject *s)
Definition: rpmds-py.c:853
rpmuint32_t * ui32p
Definition: rpmtag.h:70
PyObject * rpmHeaderFromFile(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:810
FD_t Fopen(const char *path, const char *_fmode)
fopen(3) clone.
Definition: rpmio.c:2833
static PyObject * hdr_subscript(hdrObject *s, PyObject *item)
Definition: header-py.c:377
const bson * obj
Definition: bson.h:269
int headerGet(Header h, HE_t he, unsigned int flags)
Retrieve extension or tag value from a header.
Definition: header.c:2231
PyObject * labelCompare(PyObject *self, PyObject *args)
Definition: header-py.c:981
static PyObject * hdrSetOrigin(hdrObject *s, PyObject *args, PyObject *kwds)
Definition: header-py.c:267
static PyObject * hdrUnload(hdrObject *s, PyObject *args, PyObject *keywords)
Definition: header-py.c:212
The Header data structure.
HeaderIterator headerFini(HeaderIterator hi)
Destroy header tag container iterator.
Definition: header.c:2134
static long hdr_hash(PyObject *h)
Definition: header-py.c:345
headerSprintfExtension rpmHeaderFormats
Table of query format extensions.
Definition: formats.c:305
rpmuint16_t * ui16p
Definition: rpmtag.h:69
int headerSetOrigin(Header h, const char *origin)
Store header origin (e.g path or URL).
Definition: header.c:1189
HeaderIterator headerInit(Header h)
Create header tag iterator.
Definition: header.c:2144
PyObject * rpmHeaderToFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:920
int rpmEVRparse(const char *evrstr, EVR_t evr)
Split EVR string into epoch, version, and release components.
Definition: rpmevr.c:181
#define HEADERFLAG_ALLOCATED
struct EVR_s * EVR_t
Definition: rpmevr.h:22
Header tag iterator data structure.
Definition: header.c:2129
static void rpmlog(int code, const char *fmt,...)
Definition: rpmlog.h:299
FD_t fdDup(int fdno)
Definition: rpmio.c:266
int headerNext(HeaderIterator hi, HE_t he, unsigned int flags)
Return next tag from header.
Definition: header.c:2158
PyObject * evrCompare(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:1017
char * headerSprintf(Header h, const char *fmt, headerTagTableEntry tags, headerSprintfExtension exts, errmsg_t *errmsg)
Return formatted output string from header tags.
Definition: hdrfmt.c:6730
int rpmEVRcompare(const EVR_t a, const EVR_t b)
Compare EVR containers for equality.
Definition: rpmevr.c:280
rpmTag tagValue(const char *tagstr)
Return tag value from name.
Definition: tagname.c:446
void * headerUnload(Header h, size_t *lenp)
headerUnload.
Definition: header.c:648
char * alloca()
Header hdrGetHeader(hdrObject *s)
Definition: header-py.c:685
PyObject * evrSplit(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:1040
const char * str
Definition: bson.h:593
void * ptr
Definition: rpmtag.h:67
const char const bson_bool_t v
Definition: bson.h:919
static PyMappingMethods hdr_as_mapping
Definition: header-py.c:603
rpmdsObject * hdr_dsFromHeader(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:830
mongo_error_t err
Definition: mongo.h:922
static int hdr_compare(hdrObject *a, hdrObject *b)
Definition: header-py.c:339
rpmTagData p
Definition: rpmtag.h:506
static int hdr_setattro(hdrObject *o, PyObject *n, PyObject *v)
Definition: header-py.c:619
PyObject_HEAD Header h
Definition: header-py.c:140
static PyObject * hdrSprintf(hdrObject *s, PyObject *args, PyObject *kwds)
Definition: header-py.c:284
#define HEADER_I18NTABLE
Definition: rpmtag.h:120
Header headerLoad(void *uh)
Convert header to in-memory representation.
Definition: header.c:970
The FD_t File Handle data structure.
rpmTagCount c
Definition: rpmtag.h:507
int xstrcasecmp(const char *s1, const char *s2)
Locale insensitive strcasecmp(3).
Definition: strcasecmp.c:9
Header headerFree(Header h)
Dereference a header instance.
const char * headerGetOrigin(Header h)
Return header origin (e.g path or URL).
Definition: header.c:1184
PyTypeObject hdr_Type
Definition: header-py.c:633
rpmuint8_t * ui8p
Definition: rpmtag.h:68
int Fclose(FD_t fd)
fclose(3) clone.
Definition: rpmio.c:2534
Header headerCopy(Header h)
Duplicate a header.
Definition: header.c:2194
Header headerLink(Header h)
Reference a header instance.
EVR_t rpmEVRnew(uint32_t Flags, int initialize)
Create a new EVR container.
Definition: rpmevr.c:31
PyObject * rpmReadHeaders(FD_t fd)
Definition: header-py.c:728
enum rpmRC_e rpmRC
RPM return codes.
const char * errmsg_t
Definition: rpmtag.h:18
Definition: rpmtag.h:502
static Header headerAllocated(Header h)
Definition: header-py.c:145
EVR_t rpmEVRfree(EVR_t evr)
Destroy an EVR container.
Definition: rpmevr.c:47
const char const int i
Definition: bson.h:778
unsigned int freeData
Definition: rpmtag.h:509
Methods to handle package elements.
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:756
Structures and prototypes used for an "rpmts" transaction set.
Structure(s) and routine(s) used for EVR parsing and comparison.
static struct PyMethodDef hdr_methods[]
Definition: header-py.c:313
rpmuint32_t flags
PyObject * pyrpmError
Definition: rpmmodule.c:51
static PyObject * hdrIsSource(hdrObject *s)
Definition: header-py.c:152
PyObject * versionCompare(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:968
struct hdrObject_s hdrObject
Definition: header-py.h:13
static char hdr_doc[]
Definition: header-py.c:627
static PyObject * hdrKeyList(hdrObject *s)
Definition: header-py.c:165
rpmRC rpmpkgRead(const char *fn, FD_t fd, void *ptr, const char **msg)
Read item from file descriptor.
Definition: pkgio.c:1674
enum rpmTag_e rpmTag
Definition: rpmtag.h:470
PyObject * rpmSingleHeaderFromFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:837
PyObject * rpmHeaderFromFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:789
int rpmVersionCompare(Header A, Header B)
Definition: rpmevr.c:425
PyObject * hdrLoad(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:692
rpmuint64_t * ui64p
Definition: rpmtag.h:71
static void hdr_dealloc(hdrObject *s)
Definition: header-py.c:352