00001
00005 #include "system.h"
00006
00007 #include "rpmio_internal.h"
00008 #include <rpmcb.h>
00009
00010 #include "legacy.h"
00011 #define _RPMTAG_INTERNAL
00012 #include "header_internal.h"
00013 #include "rpmtypes.h"
00014 #define _RPMEVR_INTERNAL
00015 #include "rpmevr.h"
00016 #include "pkgio.h"
00017
00018 #include "rpmts.h"
00019
00020 #include "rpmcli.h"
00021
00022 #include "header-py.h"
00023 #include "rpmds-py.h"
00024 #include "rpmfi-py.h"
00025
00026 #include "debug.h"
00027
00138 struct hdrObject_s {
00139 PyObject_HEAD
00140 Header h;
00141 } ;
00142
00145 static inline Header headerAllocated(Header h)
00146
00147 {
00148 h->flags |= HEADERFLAG_ALLOCATED;
00149 return 0;
00150 }
00151
00156
00159 static PyObject * hdrKeyList(hdrObject * s)
00160
00161 {
00162 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00163 PyObject * list, *o;
00164 HeaderIterator hi;
00165
00166 list = PyList_New(0);
00167
00168 for (hi = headerInit(s->h);
00169 headerNext(hi, he, 0);
00170 he->p.ptr = _free(he->p.ptr))
00171 {
00172 if (he->tag == HEADER_I18NTABLE) continue;
00173 switch (he->t) {
00174 case RPM_I18NSTRING_TYPE:
00175 break;
00176 case RPM_BIN_TYPE:
00177 case RPM_UINT64_TYPE:
00178 case RPM_UINT32_TYPE:
00179 case RPM_UINT16_TYPE:
00180 case RPM_UINT8_TYPE:
00181 case RPM_STRING_ARRAY_TYPE:
00182 case RPM_STRING_TYPE:
00183 PyList_Append(list, o=PyInt_FromLong(he->tag));
00184 Py_DECREF(o);
00185 break;
00186 }
00187 }
00188 hi = headerFini(hi);
00189
00190 return list;
00191 }
00192
00195 static PyObject * hdrUnload(hdrObject * s, PyObject * args, PyObject *keywords)
00196
00197 {
00198 char * buf;
00199 PyObject * rc;
00200 int legacy = 0;
00201 int nb;
00202 Header h;
00203 static char *kwlist[] = { "legacyHeader", NULL};
00204
00205 if (!PyArg_ParseTupleAndKeywords(args, keywords, "|i", kwlist, &legacy))
00206 return NULL;
00207
00208 h = headerLink(s->h);
00209
00210 if (legacy) {
00211 h = headerCopy(s->h);
00212 (void)headerFree(s->h);
00213 s->h = NULL;
00214 }
00215 { size_t len;
00216 buf = headerUnload(h, &len);
00217 nb = len;
00218 nb -= 8;
00219 }
00220 (void)headerFree(h);
00221 h = NULL;
00222
00223 if (buf == NULL || nb == 0) {
00224 PyErr_SetString(pyrpmError, "can't unload bad header\n");
00225 return NULL;
00226 }
00227
00228 rc = PyString_FromStringAndSize(buf, nb);
00229 buf = _free(buf);
00230
00231 return rc;
00232 }
00233
00236 static PyObject * hdrGetOrigin(hdrObject * s)
00237
00238 {
00239 const char * origin = NULL;
00240 if (s->h != NULL)
00241
00242 origin = headerGetOrigin(s->h);
00243 if (origin != NULL)
00244 return Py_BuildValue("s", origin);
00245 Py_INCREF(Py_None);
00246 return Py_None;
00247 }
00248
00251 static PyObject * hdrSetOrigin(hdrObject * s, PyObject * args, PyObject * kwds)
00252
00253 {
00254 char * kwlist[] = {"origin", NULL};
00255 const char * origin = NULL;
00256
00257 if (!PyArg_ParseTupleAndKeywords(args, kwds, "s:SetOrigin", kwlist, &origin))
00258 return NULL;
00259
00260 if (s->h != NULL && origin != NULL)
00261 headerSetOrigin(s->h, origin);
00262
00263 Py_INCREF(Py_None);
00264 return Py_None;
00265 }
00266
00269 static PyObject * hdrSprintf(hdrObject * s, PyObject * args, PyObject * kwds)
00270
00271 {
00272 char * fmt;
00273 char * r;
00274 errmsg_t err;
00275 PyObject * result;
00276 char * kwlist[] = {"format", NULL};
00277
00278 if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &fmt))
00279 return NULL;
00280
00281 r = headerSprintf(s->h, fmt, NULL, rpmHeaderFormats, &err);
00282 if (!r) {
00283 PyErr_SetString(pyrpmError, err);
00284 return NULL;
00285 }
00286
00287 result = Py_BuildValue("s", r);
00288 r = _free(r);
00289
00290 return result;
00291 }
00292
00297
00298 static struct PyMethodDef hdr_methods[] = {
00299 {"keys", (PyCFunction) hdrKeyList, METH_NOARGS,
00300 NULL },
00301 {"unload", (PyCFunction) hdrUnload, METH_VARARGS|METH_KEYWORDS,
00302 NULL },
00303 {"getorigin", (PyCFunction) hdrGetOrigin, METH_NOARGS,
00304 NULL },
00305 {"setorigin", (PyCFunction) hdrSetOrigin, METH_NOARGS,
00306 NULL },
00307 {"sprintf", (PyCFunction) hdrSprintf, METH_VARARGS|METH_KEYWORDS,
00308 NULL },
00309
00310 {"dsOfHeader", (PyCFunction)hdr_dsOfHeader, METH_NOARGS,
00311 NULL},
00312 {"dsFromHeader", (PyCFunction)hdr_dsFromHeader, METH_VARARGS|METH_KEYWORDS,
00313 NULL},
00314 {"fiFromHeader", (PyCFunction)hdr_fiFromHeader, METH_VARARGS|METH_KEYWORDS,
00315 NULL},
00316
00317 {NULL, NULL}
00318 };
00319
00322 static int hdr_compare(hdrObject * a, hdrObject * b)
00323
00324 {
00325 return rpmVersionCompare(a->h, b->h);
00326 }
00327
00328 static long hdr_hash(PyObject * h)
00329 {
00330 return (long) h;
00331 }
00332
00335 static void hdr_dealloc(hdrObject * s)
00336
00337 {
00338 if (s->h) headerFree(s->h);
00339 s->h = NULL;
00340 PyObject_Del(s);
00341 }
00342
00345 rpmTag tagNumFromPyObject (PyObject *item)
00346 {
00347 char * str;
00348
00349 if (PyInt_Check(item)) {
00350 return (rpmTag) PyInt_AsLong(item);
00351 } else if (PyString_Check(item) || PyUnicode_Check(item)) {
00352 str = PyString_AsString(item);
00353 return tagValue(str);
00354 }
00355 return (rpmTag)0xffffffff;
00356 }
00357
00360 static PyObject * hdr_subscript(hdrObject * s, PyObject * item)
00361
00362 {
00363 HE_t he = memset(alloca(sizeof(*he)), 0, sizeof(*he));
00364 rpmTag tag = (rpmTag)0xffffffff;
00365 uint32_t i;
00366 PyObject * o, * metao;
00367 int forceArray = 0;
00368 const struct headerSprintfExtension_s * ext = NULL;
00369 int xx;
00370
00371 if (PyCObject_Check (item))
00372 ext = PyCObject_AsVoidPtr(item);
00373 else
00374 tag = tagNumFromPyObject (item);
00375
00376 if (tag == (rpmTag)0xffffffff && (PyString_Check(item) || PyUnicode_Check(item))) {
00377 const struct headerSprintfExtension_s * extensions = rpmHeaderFormats;
00378 char * str;
00379
00380
00381 str = PyString_AsString(item);
00382 while (extensions->name) {
00383 if (extensions->type == HEADER_EXT_TAG
00384 && !xstrcasecmp(extensions->name + 7, str)) {
00385 ext = extensions;
00386 }
00387 extensions++;
00388 if (extensions->type == HEADER_EXT_MORE)
00389 extensions = *extensions->u.more;
00390 }
00391 }
00392
00393
00394 if (ext) {
00395 ext->u.tagFunction(s->h, he);
00396 } else {
00397 if (tag == (rpmTag)0xffffffff) {
00398 PyErr_SetString(PyExc_KeyError, "unknown header tag");
00399 return NULL;
00400 }
00401
00402 he->tag = tag;
00403 xx = headerGet(s->h, he, 0);
00404 if (!xx) {
00405 he->p.ptr = _free(he->p.ptr);
00406 switch (tag) {
00407 case RPMTAG_EPOCH:
00408 case RPMTAG_NAME:
00409 case RPMTAG_VERSION:
00410 case RPMTAG_RELEASE:
00411 case RPMTAG_DISTEPOCH:
00412 case RPMTAG_ARCH:
00413 case RPMTAG_OS:
00414 Py_INCREF(Py_None);
00415 return Py_None;
00416 break;
00417 default:
00418 return PyList_New(0);
00419 break;
00420 }
00421 }
00422 }
00423
00424 switch (tag) {
00425 case RPMTAG_FILEPATHS:
00426 case RPMTAG_ORIGPATHS:
00427 case RPMTAG_OLDFILENAMES:
00428 case RPMTAG_FILESIZES:
00429 case RPMTAG_FILESTATES:
00430 case RPMTAG_FILEMODES:
00431 case RPMTAG_FILEUIDS:
00432 case RPMTAG_FILEGIDS:
00433 case RPMTAG_FILERDEVS:
00434 case RPMTAG_FILEMTIMES:
00435 case RPMTAG_FILEMD5S:
00436 case RPMTAG_FILELINKTOS:
00437 case RPMTAG_FILEFLAGS:
00438 case RPMTAG_ROOT:
00439 case RPMTAG_FILEUSERNAME:
00440 case RPMTAG_FILEGROUPNAME:
00441 case RPMTAG_REQUIRENAME:
00442 case RPMTAG_REQUIREFLAGS:
00443 case RPMTAG_REQUIREVERSION:
00444 case RPMTAG_PROVIDENAME:
00445 case RPMTAG_PROVIDEFLAGS:
00446 case RPMTAG_PROVIDEVERSION:
00447 case RPMTAG_OBSOLETENAME:
00448 case RPMTAG_OBSOLETEFLAGS:
00449 case RPMTAG_OBSOLETEVERSION:
00450 case RPMTAG_CONFLICTNAME:
00451 case RPMTAG_CONFLICTFLAGS:
00452 case RPMTAG_CONFLICTVERSION:
00453 case RPMTAG_CHANGELOGTIME:
00454 case RPMTAG_FILEVERIFYFLAGS:
00455 forceArray = 1;
00456 break;
00457 default:
00458 break;
00459 }
00460
00461 switch (he->t) {
00462 case RPM_BIN_TYPE:
00463 o = PyString_FromStringAndSize(he->p.str, he->c);
00464 break;
00465
00466 case RPM_UINT8_TYPE:
00467 if (he->c != 1 || forceArray) {
00468 metao = PyList_New(0);
00469 for (i = 0; i < he->c; i++) {
00470 o = PyInt_FromLong(he->p.ui8p[i]);
00471 PyList_Append(metao, o);
00472 Py_DECREF(o);
00473 }
00474 o = metao;
00475 } else {
00476 o = PyInt_FromLong(he->p.ui8p[0]);
00477 }
00478 break;
00479
00480 case RPM_UINT16_TYPE:
00481 if (he->c != 1 || forceArray) {
00482 metao = PyList_New(0);
00483 for (i = 0; i < he->c; i++) {
00484 o = PyInt_FromLong(he->p.ui16p[i]);
00485 PyList_Append(metao, o);
00486 Py_DECREF(o);
00487 }
00488 o = metao;
00489 } else {
00490 o = PyInt_FromLong(he->p.ui16p[0]);
00491 }
00492 break;
00493
00494 case RPM_UINT32_TYPE:
00495 if (he->c != 1 || forceArray) {
00496 metao = PyList_New(0);
00497 for (i = 0; i < he->c; i++) {
00498 o = PyInt_FromLong(he->p.ui32p[i]);
00499 PyList_Append(metao, o);
00500 Py_DECREF(o);
00501 }
00502 o = metao;
00503 } else {
00504 o = PyInt_FromLong(he->p.ui32p[0]);
00505 }
00506 break;
00507
00508 case RPM_UINT64_TYPE:
00509 if (he->c != 1 || forceArray) {
00510 metao = PyList_New(0);
00511 for (i = 0; i < he->c; i++) {
00512 o = PyInt_FromLong(he->p.ui64p[i]);
00513 PyList_Append(metao, o);
00514 Py_DECREF(o);
00515 }
00516 o = metao;
00517 } else {
00518 o = PyInt_FromLong(he->p.ui64p[0]);
00519 }
00520 break;
00521
00522 case RPM_STRING_ARRAY_TYPE:
00523 metao = PyList_New(0);
00524 for (i = 0; i < he->c; i++) {
00525 o = PyString_FromString(he->p.argv[i]);
00526 PyList_Append(metao, o);
00527 Py_DECREF(o);
00528 }
00529 o = metao;
00530 break;
00531
00532 case RPM_STRING_TYPE:
00533 if (he->p.str != NULL)
00534 o = PyString_FromString(he->p.str);
00535 else
00536 o = PyString_FromString("");
00537 break;
00538
00539 default:
00540 PyErr_SetString(PyExc_TypeError, "unsupported type in header");
00541 return NULL;
00542 }
00543 if (he->freeData)
00544 he->p.ptr = _free(he->p.ptr);
00545
00546 return o;
00547 }
00548
00551
00552 static PyMappingMethods hdr_as_mapping = {
00553 (lenfunc) 0,
00554 (binaryfunc) hdr_subscript,
00555 (objobjargproc) 0,
00556 };
00557
00558 static PyObject * hdr_getattro(hdrObject * o, PyObject * n)
00559
00560 {
00561 PyObject * res;
00562 res = PyObject_GenericGetAttr((PyObject *)o, n);
00563 if (res == NULL)
00564 res = hdr_subscript(o, n);
00565 return res;
00566 }
00567
00568 static int hdr_setattro(hdrObject * o, PyObject * n, PyObject * v)
00569
00570 {
00571 return PyObject_GenericSetAttr((PyObject *)o, n, v);
00572 }
00573
00576 static char hdr_doc[] =
00577 "";
00578
00581
00582 PyTypeObject hdr_Type = {
00583 PyObject_HEAD_INIT(&PyType_Type)
00584 0,
00585 "rpm.hdr",
00586 sizeof(hdrObject),
00587 0,
00588 (destructor) hdr_dealloc,
00589 0,
00590 (getattrfunc) 0,
00591 0,
00592 (cmpfunc) hdr_compare,
00593 0,
00594 0,
00595 0,
00596 &hdr_as_mapping,
00597 hdr_hash,
00598 0,
00599 0,
00600 (getattrofunc) hdr_getattro,
00601 (setattrofunc) hdr_setattro,
00602 0,
00603 Py_TPFLAGS_DEFAULT,
00604 hdr_doc,
00605 #if Py_TPFLAGS_HAVE_ITER
00606 0,
00607 0,
00608 0,
00609 0,
00610 0,
00611 0,
00612 hdr_methods,
00613 0,
00614 0,
00615 0,
00616 0,
00617 0,
00618 0,
00619 0,
00620 0,
00621 0,
00622 0,
00623 0,
00624 0,
00625 #endif
00626 };
00627
00628 hdrObject * hdr_Wrap(Header h)
00629 {
00630 hdrObject * hdr = PyObject_New(hdrObject, &hdr_Type);
00631 hdr->h = headerLink(h);
00632 return hdr;
00633 }
00634
00635 Header hdrGetHeader(hdrObject * s)
00636 {
00637 return s->h;
00638 }
00639
00642 PyObject * hdrLoad(PyObject * self, PyObject * args, PyObject * kwds)
00643 {
00644 hdrObject * hdr;
00645 char * copy = NULL;
00646 char * obj;
00647 Header h;
00648 int len;
00649 char * kwlist[] = {"headers", NULL};
00650
00651 if (!PyArg_ParseTupleAndKeywords(args, kwds, "s#", kwlist, &obj, &len))
00652 return NULL;
00653
00654
00655 copy = malloc(len);
00656 if (copy == NULL) {
00657 PyErr_SetString(pyrpmError, "out of memory");
00658 return NULL;
00659 }
00660 memcpy (copy, obj, len);
00661
00662 h = headerLoad(copy);
00663 if (!h) {
00664 PyErr_SetString(pyrpmError, "bad header");
00665 return NULL;
00666 }
00667 headerAllocated(h);
00668
00669 hdr = hdr_Wrap(h);
00670 (void)headerFree(h);
00671 h = NULL;
00672
00673 return (PyObject *) hdr;
00674 }
00675
00678 PyObject * rpmReadHeaders (FD_t fd)
00679 {
00680 PyObject * list;
00681 Header h;
00682 hdrObject * hdr;
00683
00684 if (!fd) {
00685 PyErr_SetFromErrno(pyrpmError);
00686 return NULL;
00687 }
00688
00689 list = PyList_New(0);
00690 Py_BEGIN_ALLOW_THREADS
00691 { const char item[] = "Header";
00692 const char * msg = NULL;
00693 rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
00694 if(rc == RPMRC_NOTFOUND) {
00695 Py_INCREF(Py_None);
00696 list = Py_None;
00697 }
00698 else if (rc != RPMRC_OK)
00699 rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
00700 msg = _free(msg);
00701 }
00702 Py_END_ALLOW_THREADS
00703
00704 while (h) {
00705 hdr = hdr_Wrap(h);
00706 if (PyList_Append(list, (PyObject *) hdr)) {
00707 Py_DECREF(list);
00708 Py_DECREF(hdr);
00709 return NULL;
00710 }
00711 Py_DECREF(hdr);
00712
00713 (void)headerFree(h);
00714 h = NULL;
00715
00716 Py_BEGIN_ALLOW_THREADS
00717 { const char item[] = "Header";
00718 const char * msg = NULL;
00719 rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
00720 if(rc == RPMRC_NOTFOUND) {
00721 Py_INCREF(Py_None);
00722 list = Py_None;
00723 }
00724 else if (rc != RPMRC_OK)
00725 rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
00726 msg = _free(msg);
00727 }
00728 Py_END_ALLOW_THREADS
00729 }
00730
00731 return list;
00732 }
00733
00736 PyObject * rpmHeaderFromFD(PyObject * self, PyObject * args,
00737 PyObject * kwds)
00738 {
00739 FD_t fd;
00740 int fileno;
00741 PyObject * list;
00742 char * kwlist[] = {"fd", NULL};
00743
00744 if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &fileno))
00745 return NULL;
00746
00747 fd = fdDup(fileno);
00748
00749 list = rpmReadHeaders (fd);
00750 Fclose(fd);
00751
00752 return list;
00753 }
00754
00757 PyObject * rpmHeaderFromFile(PyObject * self, PyObject * args,
00758 PyObject *kwds)
00759 {
00760 char * filespec;
00761 FD_t fd;
00762 PyObject * list;
00763 char * kwlist[] = {"file", NULL};
00764
00765 if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &filespec))
00766 return NULL;
00767
00768 fd = Fopen(filespec, "r.fdio");
00769
00770 if (!fd) {
00771 PyErr_SetFromErrno(pyrpmError);
00772 return NULL;
00773 }
00774
00775 list = rpmReadHeaders (fd);
00776 Fclose(fd);
00777
00778 return list;
00779 }
00780
00783 PyObject *
00784 rpmSingleHeaderFromFD(PyObject * self, PyObject * args,
00785 PyObject * kwds)
00786 {
00787 FD_t fd;
00788 int fileno;
00789 off_t offset;
00790 PyObject * tuple;
00791 Header h;
00792 char * kwlist[] = {"fd", NULL};
00793
00794 if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &fileno))
00795 return NULL;
00796
00797 offset = lseek(fileno, 0, SEEK_CUR);
00798
00799 fd = fdDup(fileno);
00800
00801 if (!fd) {
00802 PyErr_SetFromErrno(pyrpmError);
00803 return NULL;
00804 }
00805
00806 Py_BEGIN_ALLOW_THREADS
00807 { const char item[] = "Header";
00808 const char * msg = NULL;
00809 rpmRC rc = rpmpkgRead(item, fd, &h, &msg);
00810 if(rc == RPMRC_NOTFOUND) {
00811 Py_INCREF(Py_None);
00812 tuple = Py_None;
00813 }
00814 else if (rc != RPMRC_OK)
00815 rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgRead", item, msg, rc);
00816 msg = _free(msg);
00817 }
00818 Py_END_ALLOW_THREADS
00819
00820 Fclose(fd);
00821
00822 tuple = PyTuple_New(2);
00823
00824 if (h && tuple) {
00825 PyTuple_SET_ITEM(tuple, 0, (PyObject *) hdr_Wrap(h));
00826 PyTuple_SET_ITEM(tuple, 1, PyLong_FromLong(offset));
00827 (void)headerFree(h);
00828 h = NULL;
00829 } else {
00830 Py_INCREF(Py_None);
00831 Py_INCREF(Py_None);
00832 PyTuple_SET_ITEM(tuple, 0, Py_None);
00833 PyTuple_SET_ITEM(tuple, 1, Py_None);
00834 }
00835
00836 return tuple;
00837 }
00838
00841 PyObject * rpmWriteHeaders (PyObject * list, FD_t fd)
00842 {
00843 int count;
00844
00845 if (!fd) {
00846 PyErr_SetFromErrno(pyrpmError);
00847 return NULL;
00848 }
00849
00850 for(count = 0; count < PyList_Size(list); count++){
00851 Py_BEGIN_ALLOW_THREADS
00852 const char item[] = "Header";
00853 const char * msg = NULL;
00854 hdrObject * hdr = (hdrObject *)PyList_GetItem(list, count);
00855 rpmRC rc = rpmpkgWrite(item, fd, hdr->h, &msg);
00856 if (rc != RPMRC_OK)
00857 rpmlog(RPMLOG_ERR, "%s: %s: %s : error code: %d\n", "rpmpkgWrite", item, msg, rc);
00858 msg = _free(msg);
00859 Py_END_ALLOW_THREADS
00860 }
00861
00862 Py_RETURN_TRUE;
00863 }
00864
00867 PyObject * rpmHeaderToFD(PyObject * self, PyObject * args,
00868 PyObject * kwds)
00869 {
00870 FD_t fd;
00871 int fileno;
00872 PyObject * list;
00873 PyObject * ret;
00874 char * kwlist[] = {"headers", "fd", NULL};
00875
00876 if (!PyArg_ParseTupleAndKeywords(args, kwds, "Oi", kwlist, &list, &fileno))
00877 return NULL;
00878
00879 fd = fdDup(fileno);
00880
00881 ret = rpmWriteHeaders (list, fd);
00882 Fclose(fd);
00883
00884 return list;
00885 }
00886
00889 PyObject * rpmHeaderToFile(PyObject * self, PyObject * args,
00890 PyObject *kwds)
00891 {
00892 char * filespec;
00893 FD_t fd;
00894 PyObject * list;
00895 PyObject * ret;
00896 char * kwlist[] = {"headers", "file", NULL};
00897
00898 if (!PyArg_ParseTupleAndKeywords(args, kwds, "Os", kwlist, &list, &filespec))
00899 return NULL;
00900
00901 fd = Fopen(filespec, "w.fdio");
00902 if (!fd) {
00903 PyErr_SetFromErrno(pyrpmError);
00904 return NULL;
00905 }
00906
00907 ret = rpmWriteHeaders (list, fd);
00908 Fclose(fd);
00909
00910 return ret;
00911 }
00912
00915 PyObject * versionCompare (PyObject * self, PyObject * args,
00916 PyObject * kwds)
00917 {
00918 hdrObject * h1, * h2;
00919 char * kwlist[] = {"version0", "version1", NULL};
00920
00921 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!O!", kwlist, &hdr_Type,
00922 &h1, &hdr_Type, &h2))
00923 return NULL;
00924
00925 return Py_BuildValue("i", hdr_compare(h1, h2));
00926 }
00927
00928 PyObject * labelCompare (PyObject * self, PyObject * args)
00929 {
00930 EVR_t a = rpmEVRnew(RPMSENSE_EQUAL, 1);
00931 EVR_t b = rpmEVRnew(RPMSENSE_EQUAL, 1);
00932 int rc;
00933 PyObject *aTuple, *bTuple;
00934
00935 if (!PyArg_ParseTuple(args, "OO", &aTuple, &bTuple) ||
00936 !PyArg_ParseTuple(aTuple, "zzz|z",
00937 &a->F[RPMEVR_E], &a->F[RPMEVR_V], &a->F[RPMEVR_R], &a->F[RPMEVR_D]) ||
00938 !PyArg_ParseTuple(bTuple, "zzz|z",
00939 &b->F[RPMEVR_E], &b->F[RPMEVR_V], &b->F[RPMEVR_R], &b->F[RPMEVR_D]))
00940 {
00941 a = rpmEVRfree(a);
00942 b = rpmEVRfree(b);
00943 return NULL;
00944 }
00945
00946
00947 if (a->F[RPMEVR_E] == NULL) a->F[RPMEVR_E] = "0";
00948 if (b->F[RPMEVR_E] == NULL) b->F[RPMEVR_E] = "0";
00949 if (a->F[RPMEVR_V] == NULL) a->F[RPMEVR_V] = "";
00950 if (b->F[RPMEVR_V] == NULL) b->F[RPMEVR_V] = "";
00951 if (a->F[RPMEVR_R] == NULL) a->F[RPMEVR_R] = "";
00952 if (b->F[RPMEVR_R] == NULL) b->F[RPMEVR_R] = "";
00953 if (a->F[RPMEVR_D] == NULL) a->F[RPMEVR_D] = "";
00954 if (b->F[RPMEVR_D] == NULL) b->F[RPMEVR_D] = "";
00955
00956 rc = rpmEVRcompare(a, b);
00957
00958 a = rpmEVRfree(a);
00959 b = rpmEVRfree(b);
00960
00961 return Py_BuildValue("i", rc);
00962 }