rpm  5.4.14
header-py.c
Go to the documentation of this file.
1 
5 #include "system.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);
263  return Py_None;
264 }
265 
268 static PyObject * hdrSetOrigin(hdrObject * s, PyObject * args, PyObject * kwds)
269  /*@*/
270 {
271  char * kwlist[] = {"origin", NULL};
272  const char * origin = NULL;
273 
274  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s:SetOrigin", kwlist, &origin))
275  return NULL;
276 
277  if (s->h != NULL && origin != NULL)
278  headerSetOrigin(s->h, origin);
279 
281  return Py_None;
282 }
283 
286 static PyObject * hdrSprintf(hdrObject * s, PyObject * args, PyObject * kwds)
287  /*@*/
288 {
289  char * fmt;
290  char * r;
291  errmsg_t err;
292  PyObject * result;
293  char * kwlist[] = {"format", NULL};
294 
295  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &fmt))
296  return NULL;
297 
298  r = headerSprintf(s->h, fmt, NULL, rpmHeaderFormats, &err);
299  if (!r) {
300  PyErr_SetString(pyrpmError, err);
301  return NULL;
302  }
303 
304  result = Py_BuildValue("s", r);
305  r = _free(r);
306 
307  return result;
308 }
309 
314 /*@unchecked@*/ /*@observer@*/
315 static struct PyMethodDef hdr_methods[] = {
316  {"keys", (PyCFunction) hdrKeyList, METH_NOARGS,
317  NULL },
318  {"unload", (PyCFunction) hdrUnload, METH_VARARGS|METH_KEYWORDS,
319  NULL },
320  {"getorigin", (PyCFunction) hdrGetOrigin, METH_NOARGS,
321  NULL },
322  {"setorigin", (PyCFunction) hdrSetOrigin, METH_VARARGS|METH_KEYWORDS,
323  NULL },
324  {"sprintf", (PyCFunction) hdrSprintf, METH_VARARGS|METH_KEYWORDS,
325  NULL },
326  {"isSource", (PyCFunction)hdrIsSource, METH_NOARGS,
327  NULL },
328 
329  {"dsOfHeader", (PyCFunction)hdr_dsOfHeader, METH_NOARGS,
330  NULL},
331  {"dsFromHeader", (PyCFunction)hdr_dsFromHeader, METH_VARARGS|METH_KEYWORDS,
332  NULL},
333  {"fiFromHeader", (PyCFunction)hdr_fiFromHeader, METH_VARARGS|METH_KEYWORDS,
334  NULL},
335 
336  {NULL, NULL} /* sentinel */
337 };
338 
341 static int hdr_compare(hdrObject * a, hdrObject * b)
342  /*@*/
343 {
344  return rpmVersionCompare(a->h, b->h);
345 }
346 
347 static long hdr_hash(PyObject * h)
348 {
349  return (long) h;
350 }
351 
354 static void hdr_dealloc(hdrObject * s)
355  /*@*/
356 {
357  if (s->h) (void ) headerFree(s->h);
358  s->h = NULL;
359  PyObject_Del(s);
360 }
361 
364 rpmTag tagNumFromPyObject (PyObject *item)
365 {
366  char * str;
367 
368  if (PyInt_Check(item)) {
369  return (rpmTag) PyInt_AsLong(item);
370  } else if (PyString_Check(item) || PyUnicode_Check(item)) {
371  str = PyString_AsString(item);
372  return tagValue(str);
373  }
374  return (rpmTag)0xffffffff;
375 }
376 
379 static PyObject * hdr_subscript(hdrObject * s, PyObject * item)
380  /*@*/
381 {
382  HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
383  rpmTag tag = (rpmTag)0xffffffff;
384  uint32_t i;
385  PyObject * o, * metao;
386  int forceArray = 0;
387  const struct headerSprintfExtension_s * ext = NULL;
388  int xx;
389 
390  if (PyCObject_Check (item))
391  ext = PyCObject_AsVoidPtr(item);
392  else
393  tag = tagNumFromPyObject (item);
394 
395  if (tag == (rpmTag)0xffffffff && (PyString_Check(item) || PyUnicode_Check(item))) {
396  const struct headerSprintfExtension_s * extensions = rpmHeaderFormats;
397  char * str;
398  /* if we still don't have the tag, go looking for the header
399  extensions */
400  str = PyString_AsString(item);
401  while (extensions->name) {
402  if (extensions->type == HEADER_EXT_TAG
403  && !xstrcasecmp(extensions->name + 7, str)) {
404  ext = extensions;
405  }
406  extensions++;
407  if (extensions->type == HEADER_EXT_MORE)
408  extensions = *extensions->u.more;
409  }
410  }
411 
412  /* Retrieve data from extension or header. */
413  if (ext) {
414  ext->u.tagFunction(s->h, he);
415  } else {
416  if (tag == (rpmTag)0xffffffff) {
417  PyErr_SetString(PyExc_KeyError, "unknown header tag");
418  return NULL;
419  }
420 
421  he->tag = tag;
422  xx = headerGet(s->h, he, 0);
423  if (!xx) {
424  he->p.ptr = _free(he->p.ptr);
425  switch (tag) {
426  case RPMTAG_EPOCH:
427  case RPMTAG_NAME:
428  case RPMTAG_VERSION:
429  case RPMTAG_RELEASE:
430  case RPMTAG_DISTEPOCH:
431  case RPMTAG_ARCH:
432  case RPMTAG_OS:
434  return Py_None;
435  break;
436  default:
437  return PyList_New(0);
438  break;
439  }
440  }
441  }
442 
443  switch (tag) {
444  case RPMTAG_FILEPATHS:
445  case RPMTAG_ORIGPATHS:
446  case RPMTAG_OLDFILENAMES:
447  case RPMTAG_FILESIZES:
448  case RPMTAG_FILESTATES:
449  case RPMTAG_FILEMODES:
450  case RPMTAG_FILEUIDS:
451  case RPMTAG_FILEGIDS:
452  case RPMTAG_FILERDEVS:
453  case RPMTAG_FILEMTIMES:
454  case RPMTAG_FILEMD5S:
455  case RPMTAG_FILELINKTOS:
456  case RPMTAG_FILEFLAGS:
457  case RPMTAG_ROOT:
458  case RPMTAG_FILEUSERNAME:
460  case RPMTAG_REQUIRENAME:
461  case RPMTAG_REQUIREFLAGS:
463  case RPMTAG_PROVIDENAME:
464  case RPMTAG_PROVIDEFLAGS:
466  case RPMTAG_OBSOLETENAME:
469  case RPMTAG_CONFLICTNAME:
474  forceArray = 1;
475  break;
476  default:
477  break;
478  }
479 
480  switch (he->t) {
481  case RPM_BIN_TYPE:
482  o = PyString_FromStringAndSize(he->p.str, he->c);
483  break;
484 
485  case RPM_UINT8_TYPE:
486  if (he->c != 1 || forceArray) {
487  metao = PyList_New(0);
488  if (!metao) {
489  return NULL;
490  }
491  for (i = 0; i < he->c; i++) {
492  o = PyInt_FromLong(he->p.ui8p[i]);
493  if (!o) {
494  Py_XDECREF(metao);
495  return NULL;
496  }
497  PyList_Append(metao, o);
498  Py_XDECREF(o);
499  }
500  o = metao;
501  } else {
502  o = PyInt_FromLong(he->p.ui8p[0]);
503  }
504  break;
505 
506  case RPM_UINT16_TYPE:
507  if (he->c != 1 || forceArray) {
508  metao = PyList_New(0);
509  if (!metao) {
510  return NULL;
511  }
512  for (i = 0; i < he->c; i++) {
513  o = PyInt_FromLong(he->p.ui16p[i]);
514  if (!o) {
515  Py_XDECREF(metao);
516  return NULL;
517  }
518  PyList_Append(metao, o);
519  Py_XDECREF(o);
520  }
521  o = metao;
522  } else {
523  o = PyInt_FromLong(he->p.ui16p[0]);
524  }
525  break;
526 
527  case RPM_UINT32_TYPE:
528  if (he->c != 1 || forceArray) {
529  metao = PyList_New(0);
530  if (!metao) {
531  return NULL;
532  }
533  for (i = 0; i < he->c; i++) {
534  o = PyInt_FromLong(he->p.ui32p[i]);
535  if (!o) {
536  Py_XDECREF(metao);
537  return NULL;
538  }
539  PyList_Append(metao, o);
540  Py_XDECREF(o);
541  }
542  o = metao;
543  } else {
544  o = PyInt_FromLong(he->p.ui32p[0]);
545  }
546  break;
547 
548  case RPM_UINT64_TYPE:
549  if (he->c != 1 || forceArray) {
550  metao = PyList_New(0);
551  if (!metao) {
552  return NULL;
553  }
554  for (i = 0; i < he->c; i++) {
555  o = PyInt_FromLong(he->p.ui64p[i]);
556  if (!o) {
557  Py_XDECREF(metao);
558  return NULL;
559  }
560  PyList_Append(metao, o);
561  Py_XDECREF(o);
562  }
563  o = metao;
564  } else {
565  o = PyInt_FromLong(he->p.ui64p[0]);
566  }
567  break;
568 
570  metao = PyList_New(0);
571  if (!metao) {
572  return NULL;
573  }
574  for (i = 0; i < he->c; i++) {
575  o = PyString_FromString(he->p.argv[i]);
576  if (!o) {
577  Py_XDECREF(metao);
578  return NULL;
579  }
580  PyList_Append(metao, o);
581  Py_XDECREF(o);
582  }
583  o = metao;
584  break;
585 
586  case RPM_STRING_TYPE:
587  if (he->p.str != NULL)
588  o = PyString_FromString(he->p.str);
589  else
590  o = PyString_FromString("");
591  break;
592 
593  default:
594  PyErr_SetString(PyExc_TypeError, "unsupported type in header");
595  return NULL;
596  }
597  if (he->freeData)
598  he->p.ptr = _free(he->p.ptr);
599 
600  return o;
601 }
602 
605 /*@unchecked@*/ /*@observer@*/
606 static PyMappingMethods hdr_as_mapping = {
607  (lenfunc) 0, /* mp_length */
608  (binaryfunc) hdr_subscript, /* mp_subscript */
609  (objobjargproc) 0, /* mp_ass_subscript */
610 };
611 
612 static PyObject * hdr_getattro(hdrObject * o, PyObject * n)
613  /*@*/
614 {
615  PyObject * res;
616  res = PyObject_GenericGetAttr((PyObject *)o, n);
617  if (res == NULL)
618  res = hdr_subscript(o, n);
619  return res;
620 }
621 
622 static int hdr_setattro(hdrObject * o, PyObject * n, PyObject * v)
623  /*@*/
624 {
625  return PyObject_GenericSetAttr((PyObject *)o, n, v);
626 }
627 
630 static char hdr_doc[] =
631 "";
632 
635 /*@unchecked@*/ /*@observer@*/
636 PyTypeObject hdr_Type = {
637  PyObject_HEAD_INIT(&PyType_Type)
638  0, /* ob_size */
639  "rpm.hdr", /* tp_name */
640  sizeof(hdrObject), /* tp_size */
641  0, /* tp_itemsize */
642  (destructor) hdr_dealloc, /* tp_dealloc */
643  0, /* tp_print */
644  (getattrfunc) 0, /* tp_getattr */
645  0, /* tp_setattr */
646  (cmpfunc) hdr_compare, /* tp_compare */
647  0, /* tp_repr */
648  0, /* tp_as_number */
649  0, /* tp_as_sequence */
650  &hdr_as_mapping, /* tp_as_mapping */
651  hdr_hash, /* tp_hash */
652  0, /* tp_call */
653  0, /* tp_str */
654  (getattrofunc) hdr_getattro, /* tp_getattro */
655  (setattrofunc) hdr_setattro, /* tp_setattro */
656  0, /* tp_as_buffer */
657  Py_TPFLAGS_DEFAULT, /* tp_flags */
658  hdr_doc, /* tp_doc */
659 #if Py_TPFLAGS_HAVE_ITER
660  0, /* tp_traverse */
661  0, /* tp_clear */
662  0, /* tp_richcompare */
663  0, /* tp_weaklistoffset */
664  0, /* tp_iter */
665  0, /* tp_iternext */
666  hdr_methods, /* tp_methods */
667  0, /* tp_members */
668  0, /* tp_getset */
669  0, /* tp_base */
670  0, /* tp_dict */
671  0, /* tp_descr_get */
672  0, /* tp_descr_set */
673  0, /* tp_dictoffset */
674  0, /* tp_init */
675  0, /* tp_alloc */
676  0, /* tp_new */
677  0, /* tp_free */
678  0, /* tp_is_gc */
679 #endif
680 };
681 
683 {
684  hdrObject * hdr = PyObject_New(hdrObject, &hdr_Type);
685  hdr->h = headerLink(h);
686  return hdr;
687 }
688 
690 {
691  return s->h;
692 }
693 
696 PyObject * hdrLoad(PyObject * self, PyObject * args, PyObject * kwds)
697 {
698  hdrObject * hdr;
699  char * copy = NULL;
700  char * obj;
701  Header h;
702  int len;
703  char * kwlist[] = {"headers", NULL};
704 
705  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", kwlist, &obj, &len))
706  return NULL;
707 
708  /* malloc is needed to avoid surprises from data swab in headerLoad(). */
709  copy = malloc(len);
710  if (copy == NULL) {
711  PyErr_SetString(pyrpmError, "out of memory");
712  return NULL;
713  }
714  memcpy (copy, obj, len);
715 
716  h = headerLoad(copy);
717  if (!h) {
718  PyErr_SetString(pyrpmError, "bad header");
719  return NULL;
720  }
721  headerAllocated(h);
722 
723  hdr = hdr_Wrap(h);
724  (void)headerFree(h); /* XXX ref held by hdr */
725  h = NULL;
726 
727  return (PyObject *) hdr;
728 }
729 
732 PyObject * rpmReadHeaders (FD_t fd)
733 {
734  PyObject * list;
735  Header h;
736  hdrObject * hdr;
737 
738  if (!fd) {
739  PyErr_SetFromErrno(pyrpmError);
740  return NULL;
741  }
742 
743  list = PyList_New(0);
744  if (!list) {
745  return NULL;
746  }
747  Py_BEGIN_ALLOW_THREADS
748  { const char item[] = "Header";
749  const char * msg = NULL;
750  rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
751  if(rc == RPMRC_NOTFOUND) {
753  list = Py_None;
754  }
755  else if (rc != RPMRC_OK)
756  rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
757  msg = _free(msg);
758  }
759  Py_END_ALLOW_THREADS
760 
761  while (h) {
762  hdr = hdr_Wrap(h);
763  if (PyList_Append(list, (PyObject *) hdr)) {
764  Py_XDECREF(list);
765  Py_XDECREF(hdr);
766  return NULL;
767  }
768  Py_XDECREF(hdr);
769 
770  (void)headerFree(h); /* XXX ref held by hdr */
771  h = NULL;
772 
773  Py_BEGIN_ALLOW_THREADS
774  { const char item[] = "Header";
775  const char * msg = NULL;
776  rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
777  if(rc == RPMRC_NOTFOUND) {
779  list = Py_None;
780  }
781  else if (rc != RPMRC_OK)
782  rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
783  msg = _free(msg);
784  }
785  Py_END_ALLOW_THREADS
786  }
787 
788  return list;
789 }
790 
793 PyObject * rpmHeaderFromFD(PyObject * self, PyObject * args,
794  PyObject * kwds)
795 {
796  FD_t fd;
797  int fileno;
798  PyObject * list;
799  char * kwlist[] = {"fd", NULL};
800 
801  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &fileno))
802  return NULL;
803 
804  fd = fdDup(fileno);
805 
806  list = rpmReadHeaders (fd);
807  Fclose(fd);
808 
809  return list;
810 }
811 
814 PyObject * rpmHeaderFromFile(PyObject * self, PyObject * args,
815  PyObject *kwds)
816 {
817  char * filespec;
818  FD_t fd;
819  PyObject * list;
820  char * kwlist[] = {"file", NULL};
821 
822  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &filespec))
823  return NULL;
824 
825  fd = Fopen(filespec, "r.fdio");
826 
827  if (!fd) {
828  PyErr_SetFromErrno(pyrpmError);
829  return NULL;
830  }
831 
832  list = rpmReadHeaders (fd);
833  Fclose(fd);
834 
835  return list;
836 }
837 
840 PyObject *
841 rpmSingleHeaderFromFD(PyObject * self, PyObject * args,
842  PyObject * kwds)
843 {
844  FD_t fd;
845  int fileno;
846  off_t offset;
847  PyObject * tuple;
848  Header h;
849  char * kwlist[] = {"fd", NULL};
850 
851  if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &fileno))
852  return NULL;
853 
854  offset = lseek(fileno, 0, SEEK_CUR);
855 
856  fd = fdDup(fileno);
857 
858  if (!fd) {
859  PyErr_SetFromErrno(pyrpmError);
860  return NULL;
861  }
862 
863  Py_BEGIN_ALLOW_THREADS
864  { const char item[] = "Header";
865  const char * msg = NULL;
866  rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
867  if(rc == RPMRC_NOTFOUND) {
869  tuple = Py_None;
870  }
871  else if (rc != RPMRC_OK)
872  rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
873  msg = _free(msg);
874  }
875  Py_END_ALLOW_THREADS
876 
877  Fclose(fd);
878 
879  tuple = PyTuple_New(2);
880 
881  if (h && tuple) {
882  PyTuple_SET_ITEM(tuple, 0, (PyObject *) hdr_Wrap(h));
883  PyTuple_SET_ITEM(tuple, 1, PyLong_FromLong(offset));
884  (void)headerFree(h);
885  h = NULL;
886  } else {
889  PyTuple_SET_ITEM(tuple, 0, Py_None);
890  PyTuple_SET_ITEM(tuple, 1, Py_None);
891  }
892 
893  return tuple;
894 }
895 
898 PyObject * rpmWriteHeaders (PyObject * list, FD_t fd)
899 {
900  int count;
901 
902  if (!fd) {
903  PyErr_SetFromErrno(pyrpmError);
904  return NULL;
905  }
906 
907  for(count = 0; count < PyList_Size(list); count++){
908  Py_BEGIN_ALLOW_THREADS
909  const char item[] = "Header";
910  const char * msg = NULL;
911  hdrObject * hdr = (hdrObject *)PyList_GetItem(list, count);
912  rpmRC rc = rpmpkgWrite(item, fd, hdr->h, &msg);
913  if (rc != RPMRC_OK)
914  rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgWrite", item, msg, rc);
915  msg = _free(msg);
916  Py_END_ALLOW_THREADS
917  }
918 
919  Py_RETURN_TRUE;
920 }
921 
924 PyObject * rpmHeaderToFD(PyObject * self, PyObject * args,
925  PyObject * kwds)
926 {
927  FD_t fd;
928  int fileno;
929  PyObject * list;
930  PyObject * ret;
931  char * kwlist[] = {"headers", "fd", NULL};
932 
933  if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oi", kwlist, &list, &fileno))
934  return NULL;
935 
936  fd = fdDup(fileno);
937 
938  ret = rpmWriteHeaders (list, fd);
939  Fclose(fd);
940 
941  return list;
942 }
943 
946 PyObject * rpmHeaderToFile(PyObject * self, PyObject * args,
947  PyObject *kwds)
948 {
949  char * filespec;
950  FD_t fd;
951  PyObject * list;
952  PyObject * ret;
953  char * kwlist[] = {"headers", "file", NULL};
954 
955  if (!PyArg_ParseTupleAndKeywords(args, kwds, "Os", kwlist, &list, &filespec))
956  return NULL;
957 
958  fd = Fopen(filespec, "w.fdio");
959  if (!fd) {
960  PyErr_SetFromErrno(pyrpmError);
961  return NULL;
962  }
963 
964  ret = rpmWriteHeaders (list, fd);
965  Fclose(fd);
966 
967  return ret;
968 }
969 
972 PyObject * versionCompare (PyObject * self, PyObject * args,
973  PyObject * kwds)
974 {
975  hdrObject * h1, * h2;
976  char * kwlist[] = {"version0", "version1", NULL};
977 
978  if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", kwlist, &hdr_Type,
979  &h1, &hdr_Type, &h2))
980  return NULL;
981 
982  return Py_BuildValue("i", hdr_compare(h1, h2));
983 }
984 
985 PyObject * labelCompare (PyObject * self, PyObject * args)
986 {
989  int rc;
990  PyObject *aTuple, *bTuple;
991 
992  if (!PyArg_ParseTuple(args, "OO", &aTuple, &bTuple) ||
993  !PyArg_ParseTuple(aTuple, "zzz|z",
994  &a->F[RPMEVR_E], &a->F[RPMEVR_V], &a->F[RPMEVR_R], &a->F[RPMEVR_D]) ||
995  !PyArg_ParseTuple(bTuple, "zzz|z",
996  &b->F[RPMEVR_E], &b->F[RPMEVR_V], &b->F[RPMEVR_R], &b->F[RPMEVR_D]))
997  {
998  a = rpmEVRfree(a);
999  b = rpmEVRfree(b);
1000  return NULL;
1001  }
1002 
1003  /* XXX HACK: postpone committing to single "missing" value for now. */
1004  if (a->F[RPMEVR_E] == NULL) a->F[RPMEVR_E] = "0";
1005  if (b->F[RPMEVR_E] == NULL) b->F[RPMEVR_E] = "0";
1006  if (a->F[RPMEVR_V] == NULL) a->F[RPMEVR_V] = "";
1007  if (b->F[RPMEVR_V] == NULL) b->F[RPMEVR_V] = "";
1008  if (a->F[RPMEVR_R] == NULL) a->F[RPMEVR_R] = "";
1009  if (b->F[RPMEVR_R] == NULL) b->F[RPMEVR_R] = "";
1010  if (a->F[RPMEVR_D] == NULL) a->F[RPMEVR_D] = "";
1011  if (b->F[RPMEVR_D] == NULL) b->F[RPMEVR_D] = "";
1012 
1013  rc = rpmEVRcompare(a, b);
1014 
1015  a = rpmEVRfree(a);
1016  b = rpmEVRfree(b);
1017 
1018  return Py_BuildValue("i", rc);
1019 }
1020 
1021 PyObject * evrCompare (PyObject * self, PyObject * args,
1022  PyObject * kwds)
1023 {
1024  EVR_t lEVR = NULL;
1025  EVR_t rEVR = NULL;
1026  int rc;
1027  char * evr1, * evr2;
1028  char * kwlist[] = {"evr0", "evr1", NULL};
1029 
1030  if (!PyArg_ParseTupleAndKeywords(args, kwds, "ss", kwlist, &evr1, &evr2))
1031  return NULL;
1032 
1033  lEVR = rpmEVRnew(RPMSENSE_EQUAL, 0);
1034  rEVR = rpmEVRnew(RPMSENSE_EQUAL, 0);
1035  rpmEVRparse(evr1, lEVR);
1036  rpmEVRparse(evr2, rEVR);
1037  rc = rpmEVRcompare(lEVR, rEVR);
1038  lEVR = rpmEVRfree(lEVR);
1039  rEVR = rpmEVRfree(rEVR);
1040 
1041  return PyLong_FromLong(rc);
1042 }
1043 
1044 PyObject * evrSplit (PyObject * self, PyObject * args, PyObject * kwds)
1045 {
1047  char * evr;
1048  char * kwlist[] = {"evr", NULL};
1049  PyObject * tuple = NULL;
1050 
1051  if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &evr))
1052  goto exit;
1053 
1054  rpmEVRparse(evr, EVR);
1055  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]);
1056 
1057 exit:
1058  EVR = rpmEVRfree(EVR);
1059 
1060  return tuple;
1061 }
rpmTagType t
Definition: rpmtag.h:502
int rpmEVRcompare(const EVR_t a, const EVR_t b)
Compare EVR containers for equality.
Definition: rpmevr.c:280
const char * str
Definition: rpmtag.h:73
int xx
Definition: spec.c:744
rpmTag tag
Definition: rpmtag.h:501
static PyObject * hdrGetOrigin(hdrObject *s)
Definition: header-py.c:253
const char ** argv
Definition: rpmtag.h:75
char * kwlist[]
Definition: rpmal-py.c:27
PyObject * rpmReadHeaders(FD_t fd)
Definition: header-py.c:732
#define headerFree(_h)
Definition: rpmtag.h:870
rpmlog(RPMLOG_ERR,"%s\n", buf)
#define RPMTAG_FILEMD5S
Definition: rpmtag.h:214
PyObject * rpmHeaderToFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:924
static PyObject * hdr_getattro(hdrObject *o, PyObject *n)
Definition: header-py.c:612
#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:1665
rpmuint32_t * ui32p
Definition: rpmtag.h:70
PyObject * rpmHeaderToFile(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:946
FD_t Fopen(const char *path, const char *_fmode)
fopen(3) clone.
Definition: rpmio.c:2831
return Py_None
Definition: rpmal-py.c:55
static char *size_t nb
fgets(3) analogue that reads \ continuations.
Definition: macro.c:409
PyObject * args
Definition: rpmts-py.c:200
static PyObject * hdrSetOrigin(hdrObject *s, PyObject *args, PyObject *kwds)
Definition: header-py.c:268
int rc
Definition: poptALL.c:670
PyObject * rpmHeaderFromFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:793
static PyObject * hdrUnload(hdrObject *s, PyObject *args, PyObject *keywords)
Definition: header-py.c:212
The Header data structure.
static long hdr_hash(PyObject *h)
Definition: header-py.c:347
headerSprintfExtension rpmHeaderFormats
Table of query format extensions.
Definition: formats.c:305
rpmuint16_t * ui16p
Definition: rpmtag.h:69
enum rpmTag_e rpmTag
Definition: rpmtag.h:468
PyObject * evrCompare(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:1021
#define HEADERFLAG_ALLOCATED
struct EVR_s * EVR_t
Definition: rpmevr.h:22
Header tag iterator data structure.
Definition: header.c:2128
FD_t fdDup(int fdno)
Definition: rpmio.c:264
EVR_t rpmEVRnew(uint32_t Flags, int initialize)
Create a new EVR container.
Definition: rpmevr.c:31
Header headerLink(Header h)
Reference a header instance.
Header h
Definition: spec.c:739
PyObject * rpmHeaderFromFile(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:814
HeaderIterator headerInit(Header h)
Create header tag iterator.
Definition: header.c:2143
pid_t result
Definition: rpmsq.c:737
PyTypeObject hdr_Type
Definition: header-py.c:636
rpmTag tagValue(const char *tagstr)
Return tag value from name.
Definition: tagname.c:446
int rpmEVRparse(const char *evrstr, EVR_t evr)
Split EVR string into epoch, version, and release components.
Definition: rpmevr.c:181
PyObject * list
Definition: rpmts-py.c:521
ret
Definition: macro.c:387
rpmdsObject * hdr_dsFromHeader(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmds-py.c:841
rpmRC res
Definition: signature.c:584
PyList_Append(s->keyList, key)
char * alloca()
enum rpmRC_e rpmRC
RPM return codes.
Definition: signature.c:616
goto exit
Definition: db3.c:1903
memset(_r, 0, sizeof(*_r))
int headerSetOrigin(Header h, const char *origin)
Store header origin (e.g path or URL).
Definition: header.c:1189
int count
Definition: rpmdb-py.c:157
PyObject * pyrpmError
Definition: rpmmodule.c:51
assert(key->size==sizeof(hdrNum))
void * ptr
Definition: rpmtag.h:67
static PyMappingMethods hdr_as_mapping
Definition: header-py.c:606
char * headerSprintf(Header h, const char *fmt, headerTagTableEntry tags, headerSprintfExtension exts, errmsg_t *errmsg)
Return formatted output string from header tags.
Definition: hdrfmt.c:6748
int headerIsEntry(Header h, rpmTag tag)
Check if tag is in header.
Definition: header.c:1438
struct hdrObject_s hdrObject
Definition: header-py.h:13
static int hdr_compare(hdrObject *a, hdrObject *b)
Definition: header-py.c:341
he tag
Definition: db3.c:1927
rpmTagData p
Definition: rpmtag.h:504
rpmTag tagNumFromPyObject(PyObject *item)
Definition: header-py.c:364
static int hdr_setattro(hdrObject *o, PyObject *n, PyObject *v)
Definition: header-py.c:622
PyObject_HEAD Header h
Definition: header-py.c:140
PyObject * labelCompare(PyObject *self, PyObject *args)
Definition: header-py.c:985
rpmfiObject * hdr_fiFromHeader(PyObject *s, PyObject *args, PyObject *kwds)
Definition: rpmfi-py.c:616
static PyObject * hdrSprintf(hdrObject *s, PyObject *args, PyObject *kwds)
Definition: header-py.c:286
int headerGet(Header h, HE_t he, unsigned int flags)
Retrieve extension or tag value from a header.
Definition: header.c:2230
Header headerLoad(void *uh)
Convert header to in-memory representation.
Definition: header.c:970
#define HEADER_I18NTABLE
Definition: rpmtag.h:120
char * o
Definition: macro.c:745
The FD_t File Handle data structure.
hdrObject * hdr_Wrap(Header h)
Definition: header-py.c:682
rpmTagCount c
Definition: rpmtag.h:505
PyObject * rpmWriteHeaders(PyObject *list, FD_t fd)
Definition: header-py.c:898
rpmuint8_t * ui8p
Definition: rpmtag.h:68
node fd
Definition: rpmfd-py.c:124
int Fclose(FD_t fd)
fclose(3) clone.
Definition: rpmio.c:2532
char * n
Definition: macro.c:744
Header headerCopy(Header h)
Duplicate a header.
Definition: header.c:2193
const char * errmsg_t
Definition: rpmtag.h:18
PyObject * hdrLoad(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:696
int headerNext(HeaderIterator hi, HE_t he, unsigned int flags)
Return next tag from header.
Definition: header.c:2157
PyObject * versionCompare(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:972
Definition: rpmtag.h:500
static Header headerAllocated(Header h)
Definition: header-py.c:145
PyObject * evrSplit(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:1044
EVR_t rpmEVRfree(EVR_t evr)
Destroy an EVR container.
Definition: rpmevr.c:47
return Py_BuildValue("i", pkgKey)
const char * s
Definition: poptALL.c:734
int xstrcasecmp(const char *s1, const char *s2)
Locale insensitive strcasecmp(3).
Definition: strcasecmp.c:9
unsigned int freeData
Definition: rpmtag.h:507
Py_XDECREF(cbInfo->dso)
Methods to handle package elements.
Header hdrGetHeader(hdrObject *s)
Definition: header-py.c:689
PyObject * rpmSingleHeaderFromFD(PyObject *self, PyObject *args, PyObject *kwds)
Definition: header-py.c:841
void * headerUnload(Header h, size_t *lenp)
headerUnload.
Definition: header.c:648
Structures and prototypes used for an &quot;rpmts&quot; transaction set.
PyObject_Del(s)
const char * msg
Definition: rpmts-py.c:976
static void hdr_dealloc(hdrObject *s)
Definition: header-py.c:354
static PyObject * hdr_subscript(hdrObject *s, PyObject *item)
Definition: header-py.c:379
rpmuint32_t flags
return NULL
Definition: poptALL.c:613
static struct PyMethodDef hdr_methods[]
Definition: header-py.c:315
static void
Print copy of spec file, filling in Group/Description/Summary from specspo.
Definition: spec.c:737
static PyObject * hdrIsSource(hdrObject *s)
Definition: header-py.c:152
char * buf
Parse (and execute) macro undefinition.
Definition: macro.c:703
char * b
Definition: macro.c:746
static char hdr_doc[]
Definition: header-py.c:630
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:1647
char * EVR
Definition: rpmds.c:2715
const char * headerGetOrigin(Header h)
Return header origin (e.g path or URL).
Definition: header.c:1184
offset
Definition: rpmdb-py.c:185
rpmdsObject * hdr_dsOfHeader(PyObject *s)
Definition: rpmds-py.c:864
static void * _free(const void *p)
Wrapper to free(3), hides const compilation noise, permit NULL, return NULL.
Definition: rpmiotypes.h:647
int i
Definition: spec.c:743
Py_INCREF(Py_None)
int rpmVersionCompare(Header A, Header B)
Definition: rpmevr.c:425
HeaderIterator headerFini(HeaderIterator hi)
Destroy header tag container iterator.
Definition: header.c:2133
int len
Definition: rpmdb-py.c:119
rpmuint64_t * ui64p
Definition: rpmtag.h:71