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