• Main Page
  • Related Pages
  • Modules
  • Data Structures
  • Files
  • File List
  • Globals

python/header-py.c

Go to the documentation of this file.
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"    /* XXX HEADERFLAG_ALLOCATED */
00013 #include "rpmtypes.h"
00014 #define _RPMEVR_INTERNAL
00015 #include "rpmevr.h"
00016 #include "pkgio.h"              /* XXX rpmpkgRead */
00017 
00018 #include "rpmts.h"      /* XXX rpmtsCreate/rpmtsFree */
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 /*@unused@*/ static inline Header headerAllocated(Header h)
00146         /*@modifies h @*/
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     /* XXX this legacy switch is a hack, needs to be removed. */
00210     if (legacy) {
00211         h = headerCopy(s->h);   /* XXX strip region tags, etc */
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;        /* XXX HEADER_MAGIC_NO */
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 /*@unchecked@*/ /*@observer@*/
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}           /* sentinel */
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         /* if we still don't have the tag, go looking for the header
00380            extensions */
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     /* Retrieve data from extension or header. */
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 /*@unchecked@*/ /*@observer@*/
00552 static PyMappingMethods hdr_as_mapping = {
00553         (lenfunc) 0,                    /* mp_length */
00554         (binaryfunc) hdr_subscript,     /* mp_subscript */
00555         (objobjargproc) 0,              /* mp_ass_subscript */
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 /*@unchecked@*/ /*@observer@*/
00582 PyTypeObject hdr_Type = {
00583         PyObject_HEAD_INIT(&PyType_Type)
00584         0,                              /* ob_size */
00585         "rpm.hdr",                      /* tp_name */
00586         sizeof(hdrObject),              /* tp_size */
00587         0,                              /* tp_itemsize */
00588         (destructor) hdr_dealloc,       /* tp_dealloc */
00589         0,                              /* tp_print */
00590         (getattrfunc) 0,                /* tp_getattr */
00591         0,                              /* tp_setattr */
00592         (cmpfunc) hdr_compare,          /* tp_compare */
00593         0,                              /* tp_repr */
00594         0,                              /* tp_as_number */
00595         0,                              /* tp_as_sequence */
00596         &hdr_as_mapping,                /* tp_as_mapping */
00597         hdr_hash,                       /* tp_hash */
00598         0,                              /* tp_call */
00599         0,                              /* tp_str */
00600         (getattrofunc) hdr_getattro,    /* tp_getattro */
00601         (setattrofunc) hdr_setattro,    /* tp_setattro */
00602         0,                              /* tp_as_buffer */
00603         Py_TPFLAGS_DEFAULT,             /* tp_flags */
00604         hdr_doc,                        /* tp_doc */
00605 #if Py_TPFLAGS_HAVE_ITER
00606         0,                              /* tp_traverse */
00607         0,                              /* tp_clear */
00608         0,                              /* tp_richcompare */
00609         0,                              /* tp_weaklistoffset */
00610         0,                              /* tp_iter */
00611         0,                              /* tp_iternext */
00612         hdr_methods,                    /* tp_methods */
00613         0,                              /* tp_members */
00614         0,                              /* tp_getset */
00615         0,                              /* tp_base */
00616         0,                              /* tp_dict */
00617         0,                              /* tp_descr_get */
00618         0,                              /* tp_descr_set */
00619         0,                              /* tp_dictoffset */
00620         0,                              /* tp_init */
00621         0,                              /* tp_alloc */
00622         0,                              /* tp_new */
00623         0,                              /* tp_free */
00624         0,                              /* tp_is_gc */
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     /* malloc is needed to avoid surprises from data swab in headerLoad(). */
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);        /* XXX ref held by hdr */
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);    /* XXX ref held by hdr */
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     /* XXX HACK: postpone committing to single "missing" value for now. */
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 }

Generated on Fri Dec 3 2010 20:53:49 for rpm by  doxygen 1.7.2