00001
00005 #include "system.h"
00006
00007 #include "rpmio_internal.h"
00008 #include "rpmcli.h"
00009
00010 #include "legacy.h"
00011 #include "misc.h"
00012 #include "header_internal.h"
00013
00014 #include "rpmts.h"
00015
00016 #include "header-py.h"
00017 #include "rpmds-py.h"
00018 #include "rpmfi-py.h"
00019
00020 #include "debug.h"
00021
00135
00138 struct hdrObject_s {
00139 PyObject_HEAD
00140 Header h;
00141 char ** md5list;
00142 char ** fileList;
00143 char ** linkList;
00144 int_32 * fileSizes;
00145 int_32 * mtimes;
00146 int_32 * uids, * gids;
00147 unsigned short * rdevs;
00148 unsigned short * modes;
00149 } ;
00150
00151 static inline Header headerAllocated(Header h)
00152
00153 {
00154 h->flags |= HEADERFLAG_ALLOCATED;
00155 return 0;
00156 }
00157
00160 static PyObject * hdrKeyList(hdrObject * s, PyObject * args)
00161
00162 {
00163 PyObject * list, *o;
00164 HeaderIterator hi;
00165 int tag, type;
00166
00167 if (!PyArg_ParseTuple(args, "")) return NULL;
00168
00169 list = PyList_New(0);
00170
00171 hi = headerInitIterator(s->h);
00172 while (headerNextIterator(hi, &tag, &type, NULL, NULL)) {
00173 if (tag == HEADER_I18NTABLE) continue;
00174
00175 switch (type) {
00176 case RPM_BIN_TYPE:
00177 case RPM_INT32_TYPE:
00178 case RPM_CHAR_TYPE:
00179 case RPM_INT8_TYPE:
00180 case RPM_INT16_TYPE:
00181 case RPM_STRING_ARRAY_TYPE:
00182 case RPM_STRING_TYPE:
00183 PyList_Append(list, o=PyInt_FromLong(tag));
00184 Py_DECREF(o);
00185 }
00186 }
00187 headerFreeIterator(hi);
00188
00189 return list;
00190 }
00191
00194 static PyObject * hdrUnload(hdrObject * s, PyObject * args, PyObject *keywords)
00195
00196 {
00197 char * buf;
00198 PyObject * rc;
00199 int len, legacy = 0;
00200 Header h;
00201 static char *kwlist[] = { "legacyHeader", NULL};
00202
00203 if (!PyArg_ParseTupleAndKeywords(args, keywords, "|i", kwlist, &legacy))
00204 return NULL;
00205
00206 h = headerLink(s->h);
00207
00208 if (legacy) {
00209 h = headerCopy(s->h);
00210 headerFree(s->h);
00211 }
00212 len = headerSizeof(h, 0);
00213 buf = headerUnload(h);
00214 h = headerFree(h);
00215
00216 if (buf == NULL || len == 0) {
00217 PyErr_SetString(pyrpmError, "can't unload bad header\n");
00218 return NULL;
00219 }
00220
00221 rc = PyString_FromStringAndSize(buf, len);
00222 buf = _free(buf);
00223
00224 return rc;
00225 }
00226
00229 static PyObject * hdrExpandFilelist(hdrObject * s, PyObject * args)
00230
00231 {
00232 expandFilelist (s->h);
00233
00234 Py_INCREF(Py_None);
00235 return Py_None;
00236 }
00237
00240 static PyObject * hdrCompressFilelist(hdrObject * s, PyObject * args)
00241
00242 {
00243 compressFilelist (s->h);
00244
00245 Py_INCREF(Py_None);
00246 return Py_None;
00247 }
00248
00249
00252 static void mungeFilelist(Header h)
00253
00254 {
00255 const char ** fileNames = NULL;
00256 int count = 0;
00257
00258 if (!headerIsEntry (h, RPMTAG_BASENAMES)
00259 || !headerIsEntry (h, RPMTAG_DIRNAMES)
00260 || !headerIsEntry (h, RPMTAG_DIRINDEXES))
00261 compressFilelist(h);
00262
00263 rpmfiBuildFNames(h, RPMTAG_BASENAMES, &fileNames, &count);
00264
00265 if (fileNames == NULL || count <= 0)
00266 return;
00267
00268
00269 headerAddEntry(h, RPMTAG_OLDFILENAMES, RPM_STRING_ARRAY_TYPE,
00270 fileNames, count);
00271
00272 fileNames = _free(fileNames);
00273 }
00274
00277 static PyObject * rhnUnload(hdrObject * s, PyObject * args)
00278
00279 {
00280 int len;
00281 char * uh;
00282 PyObject * rc;
00283 Header h;
00284
00285 if (!PyArg_ParseTuple(args, ""))
00286 return NULL;
00287
00288 h = headerLink(s->h);
00289
00290
00291 if (!headerIsEntry(h, RPMTAG_RHNPLATFORM)) {
00292 const char * arch;
00293 int_32 at;
00294 if (headerGetEntry(h, RPMTAG_ARCH, &at, (void **)&arch, NULL))
00295 headerAddEntry(h, RPMTAG_RHNPLATFORM, at, arch, 1);
00296 }
00297
00298
00299 if (!headerIsEntry(h, RPMTAG_HEADERIMMUTABLE)) {
00300 Header nh = headerReload(h, RPMTAG_HEADERIMMUTABLE);
00301
00302 uh = headerUnload(nh);
00303 headerFree(nh);
00304 h = headerLoad(uh);
00305 headerAllocated(h);
00306 }
00307
00308
00309 if (!headerIsEntry(h, RPMTAG_SHA1HEADER)) {
00310 int_32 uht, uhc;
00311 const char * digest;
00312 size_t digestlen;
00313 DIGEST_CTX ctx;
00314
00315 headerGetEntry(h, RPMTAG_HEADERIMMUTABLE, &uht, (void **)&uh, &uhc);
00316
00317 ctx = rpmDigestInit(PGPHASHALGO_SHA1, RPMDIGEST_NONE);
00318 rpmDigestUpdate(ctx, uh, uhc);
00319 rpmDigestFinal(ctx, (void **)&digest, &digestlen, 1);
00320
00321 headerAddEntry(h, RPMTAG_SHA1RHN, RPM_STRING_TYPE, digest, 1);
00322
00323 uh = headerFreeData(uh, uht);
00324 digest = _free(digest);
00325 }
00326
00327 len = headerSizeof(h, 0);
00328 uh = headerUnload(h);
00329 headerFree(h);
00330
00331 rc = PyString_FromStringAndSize(uh, len);
00332 uh = _free(uh);
00333
00334 return rc;
00335 }
00336
00339 static PyObject * hdrFullFilelist(hdrObject * s, PyObject * args)
00340
00341 {
00342 if (!PyArg_ParseTuple(args, ""))
00343 return NULL;
00344
00345 mungeFilelist (s->h);
00346
00347 Py_INCREF(Py_None);
00348 return Py_None;
00349 }
00350
00353 static PyObject * hdrSprintf(hdrObject * s, PyObject * args)
00354
00355 {
00356 char * fmt;
00357 char * r;
00358 errmsg_t err;
00359 PyObject * result;
00360
00361 if (!PyArg_ParseTuple(args, "s", &fmt))
00362 return NULL;
00363
00364 r = headerSprintf(s->h, fmt, rpmTagTable, rpmHeaderFormats, &err);
00365 if (!r) {
00366 PyErr_SetString(pyrpmError, err);
00367 return NULL;
00368 }
00369
00370 result = Py_BuildValue("s", r);
00371 r = _free(r);
00372
00373 return result;
00374 }
00375
00378 static int hdr_compare(hdrObject * a, hdrObject * b)
00379
00380 {
00381 return rpmVersionCompare(a->h, b->h);
00382 }
00383
00384 static long hdr_hash(PyObject * h)
00385 {
00386 return (long) h;
00387 }
00388
00391
00392 static struct PyMethodDef hdr_methods[] = {
00393 {"keys", (PyCFunction) hdrKeyList, METH_VARARGS,
00394 NULL },
00395 {"unload", (PyCFunction) hdrUnload, METH_VARARGS|METH_KEYWORDS,
00396 NULL },
00397 {"expandFilelist", (PyCFunction) hdrExpandFilelist,METH_VARARGS,
00398 NULL },
00399 {"compressFilelist",(PyCFunction) hdrCompressFilelist,METH_VARARGS,
00400 NULL },
00401 {"fullFilelist", (PyCFunction) hdrFullFilelist, METH_VARARGS,
00402 NULL },
00403 {"rhnUnload", (PyCFunction) rhnUnload, METH_VARARGS,
00404 NULL },
00405 {"sprintf", (PyCFunction) hdrSprintf, METH_VARARGS,
00406 NULL },
00407
00408 {"dsOfHeader", (PyCFunction)hdr_dsOfHeader, METH_VARARGS,
00409 NULL},
00410 {"dsFromHeader", (PyCFunction)hdr_dsFromHeader, METH_VARARGS,
00411 NULL},
00412 {"fiFromHeader", (PyCFunction)hdr_fiFromHeader, METH_VARARGS,
00413 NULL},
00414
00415 {NULL, NULL}
00416 };
00417
00418 static PyObject * hdr_getattro(PyObject * o, PyObject * n)
00419
00420 {
00421 return PyObject_GenericGetAttr(o, n);
00422 }
00423
00424 static int hdr_setattro(PyObject * o, PyObject * n, PyObject * v)
00425
00426 {
00427 return PyObject_GenericSetAttr(o, n, v);
00428 }
00429
00430
00433 static void hdr_dealloc(hdrObject * s)
00434
00435 {
00436 if (s->h) headerFree(s->h);
00437 s->md5list = _free(s->md5list);
00438 s->fileList = _free(s->fileList);
00439 s->linkList = _free(s->linkList);
00440 PyObject_Del(s);
00441 }
00442
00445 long tagNumFromPyObject (PyObject *item)
00446 {
00447 char * str;
00448 int i;
00449
00450 if (PyInt_Check(item)) {
00451 return PyInt_AsLong(item);
00452 } else if (PyString_Check(item)) {
00453 str = PyString_AsString(item);
00454 for (i = 0; i < rpmTagTableSize; i++)
00455 if (!xstrcasecmp(rpmTagTable[i].name + 7, str)) break;
00456 if (i < rpmTagTableSize) return rpmTagTable[i].val;
00457 }
00458 return -1;
00459 }
00460
00463 static PyObject * hdr_subscript(hdrObject * s, PyObject * item)
00464
00465 {
00466 int type, count, i, tag = -1;
00467 void * data;
00468 PyObject * o, * metao;
00469 char ** stringArray;
00470 int forceArray = 0;
00471 int freeData = 0;
00472 char * str;
00473 struct headerSprintfExtension_s * ext = NULL;
00474 const struct headerSprintfExtension_s * extensions = rpmHeaderFormats;
00475
00476 if (PyCObject_Check (item))
00477 ext = PyCObject_AsVoidPtr(item);
00478 else
00479 tag = tagNumFromPyObject (item);
00480 if (tag == -1 && PyString_Check(item)) {
00481
00482
00483 str = PyString_AsString(item);
00484 while (extensions->name) {
00485 if (extensions->type == HEADER_EXT_TAG
00486 && !xstrcasecmp(extensions->name + 7, str)) {
00487 (const struct headerSprintfExtension *) ext = extensions;
00488 }
00489 extensions++;
00490 }
00491 }
00492
00493
00494 if (ext) {
00495 ext->u.tagFunction(s->h, &type, (const void **) &data, &count, &freeData);
00496 } else {
00497 if (tag == -1) {
00498 PyErr_SetString(PyExc_KeyError, "unknown header tag");
00499 return NULL;
00500 }
00501
00502 if (!rpmHeaderGetEntry(s->h, tag, &type, &data, &count)) {
00503 switch (tag) {
00504 case RPMTAG_EPOCH:
00505 case RPMTAG_NAME:
00506 case RPMTAG_VERSION:
00507 case RPMTAG_RELEASE:
00508 case RPMTAG_ARCH:
00509 case RPMTAG_OS:
00510 Py_INCREF(Py_None);
00511 return Py_None;
00512 break;
00513 default:
00514 return PyList_New(0);
00515 break;
00516 }
00517 }
00518 }
00519
00520 switch (tag) {
00521 case RPMTAG_OLDFILENAMES:
00522 case RPMTAG_FILESIZES:
00523 case RPMTAG_FILESTATES:
00524 case RPMTAG_FILEMODES:
00525 case RPMTAG_FILEUIDS:
00526 case RPMTAG_FILEGIDS:
00527 case RPMTAG_FILERDEVS:
00528 case RPMTAG_FILEMTIMES:
00529 case RPMTAG_FILEMD5S:
00530 case RPMTAG_FILELINKTOS:
00531 case RPMTAG_FILEFLAGS:
00532 case RPMTAG_ROOT:
00533 case RPMTAG_FILEUSERNAME:
00534 case RPMTAG_FILEGROUPNAME:
00535 case RPMTAG_REQUIRENAME:
00536 case RPMTAG_REQUIREFLAGS:
00537 case RPMTAG_REQUIREVERSION:
00538 case RPMTAG_PROVIDENAME:
00539 case RPMTAG_PROVIDEFLAGS:
00540 case RPMTAG_PROVIDEVERSION:
00541 case RPMTAG_OBSOLETENAME:
00542 case RPMTAG_OBSOLETEFLAGS:
00543 case RPMTAG_OBSOLETEVERSION:
00544 case RPMTAG_CONFLICTNAME:
00545 case RPMTAG_CONFLICTFLAGS:
00546 case RPMTAG_CONFLICTVERSION:
00547 case RPMTAG_CHANGELOGTIME:
00548 forceArray = 1;
00549 break;
00550 case RPMTAG_SUMMARY:
00551 case RPMTAG_GROUP:
00552 case RPMTAG_DESCRIPTION:
00553 freeData = 1;
00554 break;
00555 default:
00556 break;
00557 }
00558
00559 switch (type) {
00560 case RPM_BIN_TYPE:
00561 o = PyString_FromStringAndSize(data, count);
00562 break;
00563
00564 case RPM_INT32_TYPE:
00565 if (count != 1 || forceArray) {
00566 metao = PyList_New(0);
00567 for (i = 0; i < count; i++) {
00568 o = PyInt_FromLong(((int *) data)[i]);
00569 PyList_Append(metao, o);
00570 Py_DECREF(o);
00571 }
00572 o = metao;
00573 } else {
00574 o = PyInt_FromLong(*((int *) data));
00575 }
00576 break;
00577
00578 case RPM_CHAR_TYPE:
00579 case RPM_INT8_TYPE:
00580 if (count != 1 || forceArray) {
00581 metao = PyList_New(0);
00582 for (i = 0; i < count; i++) {
00583 o = PyInt_FromLong(((char *) data)[i]);
00584 PyList_Append(metao, o);
00585 Py_DECREF(o);
00586 }
00587 o = metao;
00588 } else {
00589 o = PyInt_FromLong(*((char *) data));
00590 }
00591 break;
00592
00593 case RPM_INT16_TYPE:
00594 if (count != 1 || forceArray) {
00595 metao = PyList_New(0);
00596 for (i = 0; i < count; i++) {
00597 o = PyInt_FromLong(((short *) data)[i]);
00598 PyList_Append(metao, o);
00599 Py_DECREF(o);
00600 }
00601 o = metao;
00602 } else {
00603 o = PyInt_FromLong(*((short *) data));
00604 }
00605 break;
00606
00607 case RPM_STRING_ARRAY_TYPE:
00608 stringArray = data;
00609
00610 metao = PyList_New(0);
00611 for (i = 0; i < count; i++) {
00612 o = PyString_FromString(stringArray[i]);
00613 PyList_Append(metao, o);
00614 Py_DECREF(o);
00615 }
00616 free (stringArray);
00617 o = metao;
00618 break;
00619
00620 case RPM_STRING_TYPE:
00621 if (count != 1 || forceArray) {
00622 stringArray = data;
00623
00624 metao = PyList_New(0);
00625 for (i=0; i < count; i++) {
00626 o = PyString_FromString(stringArray[i]);
00627 PyList_Append(metao, o);
00628 Py_DECREF(o);
00629 }
00630 o = metao;
00631 } else {
00632 o = PyString_FromString(data);
00633 if (freeData)
00634 free (data);
00635 }
00636 break;
00637
00638 default:
00639 PyErr_SetString(PyExc_TypeError, "unsupported type in header");
00640 return NULL;
00641 }
00642
00643 return o;
00644 }
00645
00648
00649 static PyMappingMethods hdr_as_mapping = {
00650 (inquiry) 0,
00651 (binaryfunc) hdr_subscript,
00652 (objobjargproc)0,
00653 };
00654
00657 static char hdr_doc[] =
00658 "";
00659
00662
00663 PyTypeObject hdr_Type = {
00664 PyObject_HEAD_INIT(&PyType_Type)
00665 0,
00666 "rpm.hdr",
00667 sizeof(hdrObject),
00668 0,
00669 (destructor) hdr_dealloc,
00670 0,
00671 (getattrfunc) 0,
00672 0,
00673 (cmpfunc) hdr_compare,
00674 0,
00675 0,
00676 0,
00677 &hdr_as_mapping,
00678 hdr_hash,
00679 0,
00680 0,
00681 (getattrofunc) hdr_getattro,
00682 (setattrofunc) hdr_setattro,
00683 0,
00684 Py_TPFLAGS_DEFAULT,
00685 hdr_doc,
00686 #if Py_TPFLAGS_HAVE_ITER
00687 0,
00688 0,
00689 0,
00690 0,
00691 0,
00692 0,
00693 hdr_methods,
00694 0,
00695 0,
00696 0,
00697 0,
00698 0,
00699 0,
00700 0,
00701 0,
00702 0,
00703 0,
00704 0,
00705 0,
00706 #endif
00707 };
00708
00709 hdrObject * hdr_Wrap(Header h)
00710 {
00711 hdrObject * hdr = PyObject_New(hdrObject, &hdr_Type);
00712 hdr->h = headerLink(h);
00713 hdr->fileList = hdr->linkList = hdr->md5list = NULL;
00714 hdr->uids = hdr->gids = hdr->mtimes = hdr->fileSizes = NULL;
00715 hdr->modes = hdr->rdevs = NULL;
00716 return hdr;
00717 }
00718
00719 Header hdrGetHeader(hdrObject * s)
00720 {
00721 return s->h;
00722 }
00723
00726 PyObject * hdrLoad(PyObject * self, PyObject * args)
00727 {
00728 hdrObject * hdr;
00729 char * copy = NULL;
00730 char * obj;
00731 Header h;
00732 int len;
00733
00734 if (!PyArg_ParseTuple(args, "s#", &obj, &len)) return NULL;
00735
00736
00737 copy = malloc(len);
00738 if (copy == NULL) {
00739 PyErr_SetString(pyrpmError, "out of memory");
00740 return NULL;
00741 }
00742 memcpy (copy, obj, len);
00743
00744 h = headerLoad(copy);
00745 if (!h) {
00746 PyErr_SetString(pyrpmError, "bad header");
00747 return NULL;
00748 }
00749 headerAllocated(h);
00750 compressFilelist (h);
00751 providePackageNVR (h);
00752
00753 hdr = hdr_Wrap(h);
00754 h = headerFree(h);
00755
00756 return (PyObject *) hdr;
00757 }
00758
00761 PyObject * rhnLoad(PyObject * self, PyObject * args)
00762 {
00763 char * obj, * copy=NULL;
00764 Header h;
00765 int len;
00766
00767 if (!PyArg_ParseTuple(args, "s#", &obj, &len)) return NULL;
00768
00769
00770 copy = malloc(len);
00771 if (copy == NULL) {
00772 PyErr_SetString(pyrpmError, "out of memory");
00773 return NULL;
00774 }
00775 memcpy (copy, obj, len);
00776
00777 h = headerLoad(copy);
00778 if (!h) {
00779 PyErr_SetString(pyrpmError, "bad header");
00780 return NULL;
00781 }
00782 headerAllocated(h);
00783
00784
00785 if (!headerIsEntry(h, RPMTAG_HEADERIMMUTABLE)) {
00786 PyErr_SetString(pyrpmError, "bad header, not immutable");
00787 headerFree(h);
00788 return NULL;
00789 }
00790
00791
00792 if (!headerIsEntry(h, RPMTAG_SHA1HEADER)
00793 && !headerIsEntry(h, RPMTAG_SHA1RHN)) {
00794 PyErr_SetString(pyrpmError, "bad header, no digest");
00795 headerFree(h);
00796 return NULL;
00797 }
00798
00799
00800 if (!headerIsEntry(h, RPMTAG_RHNPLATFORM)) {
00801 const char * arch;
00802 int_32 at;
00803 if (headerGetEntry(h, RPMTAG_ARCH, &at, (void **)&arch, NULL))
00804 headerAddEntry(h, RPMTAG_RHNPLATFORM, at, arch, 1);
00805 }
00806
00807 return (PyObject *) hdr_Wrap(h);
00808 }
00809
00812 PyObject * rpmReadHeaders (FD_t fd)
00813 {
00814 PyObject * list;
00815 Header h;
00816 hdrObject * hdr;
00817
00818 if (!fd) {
00819 PyErr_SetFromErrno(pyrpmError);
00820 return NULL;
00821 }
00822
00823 list = PyList_New(0);
00824 Py_BEGIN_ALLOW_THREADS
00825 h = headerRead(fd, HEADER_MAGIC_YES);
00826 Py_END_ALLOW_THREADS
00827
00828 while (h) {
00829 compressFilelist(h);
00830 providePackageNVR(h);
00831 hdr = hdr_Wrap(h);
00832 if (PyList_Append(list, (PyObject *) hdr)) {
00833 Py_DECREF(list);
00834 Py_DECREF(hdr);
00835 return NULL;
00836 }
00837 Py_DECREF(hdr);
00838
00839 h = headerFree(h);
00840
00841 Py_BEGIN_ALLOW_THREADS
00842 h = headerRead(fd, HEADER_MAGIC_YES);
00843 Py_END_ALLOW_THREADS
00844 }
00845
00846 return list;
00847 }
00848
00851 PyObject * rpmHeaderFromFD(PyObject * self, PyObject * args)
00852 {
00853 FD_t fd;
00854 int fileno;
00855 PyObject * list;
00856
00857 if (!PyArg_ParseTuple(args, "i", &fileno)) return NULL;
00858 fd = fdDup(fileno);
00859
00860 list = rpmReadHeaders (fd);
00861 Fclose(fd);
00862
00863 return list;
00864 }
00865
00868 PyObject * rpmHeaderFromFile(PyObject * self, PyObject * args)
00869 {
00870 char * filespec;
00871 FD_t fd;
00872 PyObject * list;
00873
00874 if (!PyArg_ParseTuple(args, "s", &filespec)) return NULL;
00875 fd = Fopen(filespec, "r.fdio");
00876
00877 if (!fd) {
00878 PyErr_SetFromErrno(pyrpmError);
00879 return NULL;
00880 }
00881
00882 list = rpmReadHeaders (fd);
00883 Fclose(fd);
00884
00885 return list;
00886 }
00887
00892 int rpmMergeHeaders(PyObject * list, FD_t fd, int matchTag)
00893 {
00894 Header h;
00895 HeaderIterator hi;
00896 int_32 * newMatch;
00897 int_32 * oldMatch;
00898 hdrObject * hdr;
00899 int count = 0;
00900 int type, c, tag;
00901 void * p;
00902
00903 Py_BEGIN_ALLOW_THREADS
00904 h = headerRead(fd, HEADER_MAGIC_YES);
00905 Py_END_ALLOW_THREADS
00906
00907 while (h) {
00908 if (!headerGetEntry(h, matchTag, NULL, (void **) &newMatch, NULL)) {
00909 PyErr_SetString(pyrpmError, "match tag missing in new header");
00910 return 1;
00911 }
00912
00913 hdr = (hdrObject *) PyList_GetItem(list, count++);
00914 if (!hdr) return 1;
00915
00916 if (!headerGetEntry(hdr->h, matchTag, NULL, (void **) &oldMatch, NULL)) {
00917 PyErr_SetString(pyrpmError, "match tag missing in new header");
00918 return 1;
00919 }
00920
00921 if (*newMatch != *oldMatch) {
00922 PyErr_SetString(pyrpmError, "match tag mismatch");
00923 return 1;
00924 }
00925
00926 hdr->md5list = _free(hdr->md5list);
00927 hdr->fileList = _free(hdr->fileList);
00928 hdr->linkList = _free(hdr->linkList);
00929
00930 for (hi = headerInitIterator(h);
00931 headerNextIterator(hi, &tag, &type, (void *) &p, &c);
00932 p = headerFreeData(p, type))
00933 {
00934
00935 headerRemoveEntry(hdr->h, tag);
00936 headerAddEntry(hdr->h, tag, type, p, c);
00937 }
00938
00939 headerFreeIterator(hi);
00940 h = headerFree(h);
00941
00942 Py_BEGIN_ALLOW_THREADS
00943 h = headerRead(fd, HEADER_MAGIC_YES);
00944 Py_END_ALLOW_THREADS
00945 }
00946
00947 return 0;
00948 }
00949
00950 PyObject * rpmMergeHeadersFromFD(PyObject * self, PyObject * args)
00951 {
00952 FD_t fd;
00953 int fileno;
00954 PyObject * list;
00955 int rc;
00956 int matchTag;
00957
00958 if (!PyArg_ParseTuple(args, "Oii", &list, &fileno, &matchTag))
00959 return NULL;
00960
00961 if (!PyList_Check(list)) {
00962 PyErr_SetString(PyExc_TypeError, "first parameter must be a list");
00963 return NULL;
00964 }
00965
00966 fd = fdDup(fileno);
00967
00968 rc = rpmMergeHeaders (list, fd, matchTag);
00969 Fclose(fd);
00970
00971 if (rc) {
00972 return NULL;
00973 }
00974
00975 Py_INCREF(Py_None);
00976 return Py_None;
00977 }
00978
00981 PyObject * versionCompare (PyObject * self, PyObject * args)
00982 {
00983 hdrObject * h1, * h2;
00984
00985 if (!PyArg_ParseTuple(args, "O!O!", &hdr_Type, &h1, &hdr_Type, &h2))
00986 return NULL;
00987
00988 return Py_BuildValue("i", hdr_compare(h1, h2));
00989 }
00990
00993 static int compare_values(const char *str1, const char *str2)
00994 {
00995 if (!str1 && !str2)
00996 return 0;
00997 else if (str1 && !str2)
00998 return 1;
00999 else if (!str1 && str2)
01000 return -1;
01001 return rpmvercmp(str1, str2);
01002 }
01003
01004 PyObject * labelCompare (PyObject * self, PyObject * args)
01005 {
01006 char *v1, *r1, *e1, *v2, *r2, *e2;
01007 int rc;
01008
01009 if (!PyArg_ParseTuple(args, "(zzz)(zzz)",
01010 &e1, &v1, &r1, &e2, &v2, &r2))
01011 return NULL;
01012
01013 rc = compare_values(e1, e2);
01014 if (!rc) {
01015 rc = compare_values(v1, v2);
01016 if (!rc)
01017 rc = compare_values(r1, r2);
01018 }
01019 return Py_BuildValue("i", rc);
01020 }
01021