#include #include #include #include #include #include #include /* XXX rpmio.h */ #include /* XXX rpmio.h */ #include "Python.h" #include "rpmlib.h" #include "misc.h" #include "rpmmacro.h" #include "upgrade.h" /* from lib/misc.c */ int rpmvercmp(const char * one, const char * two); /* Forward types */ typedef struct rpmdbObject_s rpmdbObject; typedef struct rpmtransObject_s rpmtransObject; typedef struct hdrObject_s hdrObject; /* Prototypes */ static void rpmdbDealloc(rpmdbObject * s); static PyObject * rpmdbGetAttr(rpmdbObject * s, char * name); static PyObject * rpmdbFirst(rpmdbObject * s, PyObject * args); static PyObject * rpmdbNext(rpmdbObject * s, PyObject * args); static PyObject * rpmdbByName(rpmdbObject * s, PyObject * args); static PyObject * rpmdbByProvides(rpmdbObject * s, PyObject * args); static PyObject * rpmdbByFile(rpmdbObject * s, PyObject * args); static int rpmdbLength(rpmdbObject * s); static hdrObject * rpmdbSubscript(rpmdbObject * s, PyObject * key); static void hdrDealloc(hdrObject * s); static PyObject * hdrGetAttr(hdrObject * s, char * name); static PyObject * hdrSubscript(hdrObject * s, PyObject * item); static PyObject * hdrKeyList(hdrObject * s, PyObject * args); static PyObject * hdrUnload(hdrObject * s, PyObject * args); static PyObject * hdrVerifyFile(hdrObject * s, PyObject * args); static PyObject * hdrCompressFilelist(hdrObject * s, PyObject * args); static PyObject * hdrExpandFilelist(hdrObject * s, PyObject * args); static PyObject * hdrFullFilelist(hdrObject * s, PyObject * args); void initrpm(void); static PyObject * doAddMacro(PyObject * self, PyObject * args); static PyObject * doDelMacro(PyObject * self, PyObject * args); static rpmdbObject * rpmOpenDB(PyObject * self, PyObject * args); static PyObject * hdrLoad(PyObject * self, PyObject * args); static PyObject * rpmHeaderFromPackage(PyObject * self, PyObject * args); static PyObject * rpmHeaderFromFile(PyObject * self, PyObject * args); static PyObject * archScore(PyObject * self, PyObject * args); static PyObject * rpmHeaderFromFD(PyObject * self, PyObject * args); static PyObject * findUpgradeSet(PyObject * self, PyObject * args); static PyObject * errorSetCallback (PyObject * self, PyObject * args); static PyObject * errorString (PyObject * self, PyObject * args); static PyObject * versionCompare (PyObject * self, PyObject * args); static PyObject * labelCompare (PyObject * self, PyObject * args); static PyObject * rebuildDB (PyObject * self, PyObject * args); static PyObject * rpmtransCreate(PyObject * self, PyObject * args); static PyObject * rpmtransAdd(rpmtransObject * s, PyObject * args); static PyObject * rpmtransDepCheck(rpmtransObject * s, PyObject * args); static PyObject * rpmtransRun(rpmtransObject * s, PyObject * args); static PyObject * rpmtransOrder(rpmtransObject * s, PyObject * args); static void rpmtransDealloc(PyObject * o); static PyObject * rpmtransGetAttr(rpmtransObject * o, char * name); static int rpmtransSetAttr(rpmtransObject * o, char * name, PyObject * val); static PyObject * doFopen(PyObject * self, PyObject * args); /* Types */ static PyMethodDef rpmModuleMethods[] = { { "TransactionSet", (PyCFunction) rpmtransCreate, METH_VARARGS, NULL }, { "addMacro", (PyCFunction) doAddMacro, METH_VARARGS, NULL }, { "delMacro", (PyCFunction) doDelMacro, METH_VARARGS, NULL }, { "archscore", (PyCFunction) archScore, METH_VARARGS, NULL }, { "findUpgradeSet", (PyCFunction) findUpgradeSet, METH_VARARGS, NULL }, { "headerFromPackage", (PyCFunction) rpmHeaderFromPackage, METH_VARARGS, NULL }, { "headerLoad", (PyCFunction) hdrLoad, METH_VARARGS, NULL }, { "opendb", (PyCFunction) rpmOpenDB, METH_VARARGS, NULL }, { "rebuilddb", (PyCFunction) rebuildDB, METH_VARARGS, NULL }, { "readHeaderListFromFD", (PyCFunction) rpmHeaderFromFD, METH_VARARGS, NULL }, { "readHeaderListFromFile", (PyCFunction) rpmHeaderFromFile, METH_VARARGS, NULL }, { "errorSetCallback", (PyCFunction) errorSetCallback, METH_VARARGS, NULL }, { "errorString", (PyCFunction) errorString, METH_VARARGS, NULL }, { "versionCompare", (PyCFunction) versionCompare, METH_VARARGS, NULL }, { "labelCompare", (PyCFunction) labelCompare, METH_VARARGS, NULL }, /* don't use me yet { "Fopen", (PyCFunction) doFopen, METH_VARARGS, NULL }, */ { NULL } } ; struct rpmdbObject_s { PyObject_HEAD; rpmdb db; } ; struct rpmtransObject_s { PyObject_HEAD; rpmdbObject * dbo; rpmTransactionSet ts; PyObject * keyList; /* keeps reference counts correct */ FD_t scriptFd; } ; struct hdrObject_s { PyObject_HEAD; Header h; char ** md5list; char ** fileList; char ** linkList; int_32 * fileSizes; int_32 * mtimes; int_32 * uids, * gids; unsigned short * rdevs; unsigned short * modes; } ; /* Data */ static PyObject * pyrpmError; static PyMappingMethods hdrAsMapping = { (inquiry) 0, /* mp_length */ (binaryfunc) hdrSubscript, /* mp_subscript */ (objobjargproc)0, /* mp_ass_subscript */ }; static PyTypeObject hdrType = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ "header", /* tp_name */ sizeof(hdrObject), /* tp_size */ 0, /* tp_itemsize */ (destructor) hdrDealloc, /* tp_dealloc */ 0, /* tp_print */ (getattrfunc) hdrGetAttr, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ &hdrAsMapping, /* tp_as_mapping */ }; static PyMappingMethods rpmdbAsMapping = { (inquiry) rpmdbLength, /* mp_length */ (binaryfunc) rpmdbSubscript, /* mp_subscript */ (objobjargproc)0, /* mp_ass_subscript */ }; static PyTypeObject rpmdbType = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ "rpmdb", /* tp_name */ sizeof(rpmdbObject), /* tp_size */ 0, /* tp_itemsize */ (destructor) rpmdbDealloc, /* tp_dealloc */ 0, /* tp_print */ (getattrfunc) rpmdbGetAttr, /* tp_getattr */ 0, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ &rpmdbAsMapping, /* tp_as_mapping */ }; static PyTypeObject rpmtransType = { PyObject_HEAD_INIT(&PyType_Type) 0, /* ob_size */ "rpmtrans", /* tp_name */ sizeof(rpmtransObject), /* tp_size */ 0, /* tp_itemsize */ (destructor) rpmtransDealloc, /* tp_dealloc */ 0, /* tp_print */ (getattrfunc) rpmtransGetAttr, /* tp_getattr */ (setattrfunc) rpmtransSetAttr, /* tp_setattr */ 0, /* tp_compare */ 0, /* tp_repr */ 0, /* tp_as_number */ 0, /* tp_as_sequence */ 0, /* tp_as_mapping */ }; static struct PyMethodDef rpmdbMethods[] = { {"firstkey", (PyCFunction) rpmdbFirst, 1 }, {"nextkey", (PyCFunction) rpmdbNext, 1 }, {"findbyfile", (PyCFunction) rpmdbByFile, 1 }, {"findbyname", (PyCFunction) rpmdbByName, 1 }, {"findbyprovides", (PyCFunction) rpmdbByProvides, 1 }, {NULL, NULL} /* sentinel */ }; static struct PyMethodDef rpmtransMethods[] = { {"add", (PyCFunction) rpmtransAdd, 1 }, {"depcheck", (PyCFunction) rpmtransDepCheck, 1 }, {"order", (PyCFunction) rpmtransOrder, 1 }, {"run", (PyCFunction) rpmtransRun, 1 }, {NULL, NULL} /* sentinel */ }; static struct PyMethodDef hdrMethods[] = { {"keys", (PyCFunction) hdrKeyList, 1 }, {"unload", (PyCFunction) hdrUnload, 1 }, {"verifyFile", (PyCFunction) hdrVerifyFile, 1 }, {"expandFilelist", (PyCFunction) hdrExpandFilelist, 1 }, {"compressFilelist", (PyCFunction) hdrCompressFilelist, 1 }, {"fullFilelist", (PyCFunction) hdrFullFilelist, 1 }, {NULL, NULL} /* sentinel */ }; /* External functions */ int mdfile(const char *fn, unsigned char *digest); /* Code */ extern int _rpmio_debug; void initrpm(void) { PyObject * m, * d, * tag, * dict; int i; const struct headerSprintfExtension * extensions = rpmHeaderFormats; struct headerSprintfExtension * ext; /* i18ndomains = "redhat-dist"; */ /* _rpmio_debug = -1; */ rpmReadConfigFiles(NULL, NULL); m = Py_InitModule("rpm", rpmModuleMethods); d = PyModule_GetDict(m); pyrpmError = PyString_FromString("rpm.error"); PyDict_SetItemString(d, "error", pyrpmError); dict = PyDict_New(); for (i = 0; i < rpmTagTableSize; i++) { tag = PyInt_FromLong(rpmTagTable[i].val); PyDict_SetItemString(d, (char *) rpmTagTable[i].name, tag); PyDict_SetItem(dict, tag, PyString_FromString(rpmTagTable[i].name + 7)); } while (extensions->name) { if (extensions->type == HEADER_EXT_TAG) { (const struct headerSprintfExtension *) ext = extensions; PyDict_SetItemString(d, extensions->name, PyCObject_FromVoidPtr(ext, NULL)); PyDict_SetItem(dict, tag, PyString_FromString(ext->name + 7)); } extensions++; } PyDict_SetItemString(d, "tagnames", dict); PyDict_SetItemString(d, "RPMFILE_STATE_NORMAL", PyInt_FromLong(RPMFILE_STATE_NORMAL)); PyDict_SetItemString(d, "RPMFILE_STATE_REPLACED", PyInt_FromLong(RPMFILE_STATE_REPLACED)); PyDict_SetItemString(d, "RPMFILE_STATE_NOTINSTALLED", PyInt_FromLong(RPMFILE_STATE_NOTINSTALLED)); PyDict_SetItemString(d, "RPMFILE_CONFIG", PyInt_FromLong(RPMFILE_CONFIG)); PyDict_SetItemString(d, "RPMFILE_MISSINGOK", PyInt_FromLong(RPMFILE_MISSINGOK)); PyDict_SetItemString(d, "RPMFILE_DOC", PyInt_FromLong(RPMFILE_DOC)); PyDict_SetItemString(d, "RPMDEP_SENSE_REQUIRES", PyInt_FromLong(RPMDEP_SENSE_REQUIRES)); PyDict_SetItemString(d, "RPMDEP_SENSE_CONFLICTS", PyInt_FromLong(RPMDEP_SENSE_CONFLICTS)); PyDict_SetItemString(d, "RPMSENSE_SERIAL", PyInt_FromLong(RPMSENSE_SERIAL)); PyDict_SetItemString(d, "RPMSENSE_LESS", PyInt_FromLong(RPMSENSE_LESS)); PyDict_SetItemString(d, "RPMSENSE_GREATER", PyInt_FromLong(RPMSENSE_GREATER)); PyDict_SetItemString(d, "RPMSENSE_EQUAL", PyInt_FromLong(RPMSENSE_EQUAL)); PyDict_SetItemString(d, "RPMSENSE_PREREQ", PyInt_FromLong(RPMSENSE_PREREQ)); PyDict_SetItemString(d, "RPMTRANS_FLAG_TEST", PyInt_FromLong(RPMTRANS_FLAG_TEST)); PyDict_SetItemString(d, "RPMTRANS_FLAG_BUILD_PROBS", PyInt_FromLong(RPMTRANS_FLAG_BUILD_PROBS)); PyDict_SetItemString(d, "RPMTRANS_FLAG_NOSCRIPTS", PyInt_FromLong(RPMTRANS_FLAG_NOSCRIPTS)); PyDict_SetItemString(d, "RPMTRANS_FLAG_JUSTDB", PyInt_FromLong(RPMTRANS_FLAG_JUSTDB)); PyDict_SetItemString(d, "RPMTRANS_FLAG_NOTRIGGERS", PyInt_FromLong(RPMTRANS_FLAG_NOTRIGGERS)); PyDict_SetItemString(d, "RPMTRANS_FLAG_NODOCS", PyInt_FromLong(RPMTRANS_FLAG_NODOCS)); PyDict_SetItemString(d, "RPMTRANS_FLAG_ALLFILES", PyInt_FromLong(RPMTRANS_FLAG_ALLFILES)); PyDict_SetItemString(d, "RPMTRANS_FLAG_KEEPOBSOLETE", PyInt_FromLong(RPMTRANS_FLAG_KEEPOBSOLETE)); PyDict_SetItemString(d, "RPMPROB_FILTER_IGNOREOS", PyInt_FromLong(RPMPROB_FILTER_IGNOREOS)); PyDict_SetItemString(d, "RPMPROB_FILTER_IGNOREARCH", PyInt_FromLong(RPMPROB_FILTER_IGNOREARCH)); PyDict_SetItemString(d, "RPMPROB_FILTER_REPLACEPKG", PyInt_FromLong(RPMPROB_FILTER_REPLACEPKG)); PyDict_SetItemString(d, "RPMPROB_FILTER_FORCERELOCATE", PyInt_FromLong(RPMPROB_FILTER_FORCERELOCATE)); PyDict_SetItemString(d, "RPMPROB_FILTER_REPLACENEWFILES", PyInt_FromLong(RPMPROB_FILTER_REPLACENEWFILES)); PyDict_SetItemString(d, "RPMPROB_FILTER_REPLACEOLDFILES", PyInt_FromLong(RPMPROB_FILTER_REPLACEOLDFILES)); PyDict_SetItemString(d, "RPMPROB_FILTER_OLDPACKAGE", PyInt_FromLong(RPMPROB_FILTER_OLDPACKAGE)); PyDict_SetItemString(d, "RPMPROB_FILTER_DISKSPACE", PyInt_FromLong(RPMPROB_FILTER_DISKSPACE)); PyDict_SetItemString(d, "RPMCALLBACK_INST_PROGRESS", PyInt_FromLong(RPMCALLBACK_INST_PROGRESS)); PyDict_SetItemString(d, "RPMCALLBACK_INST_START", PyInt_FromLong(RPMCALLBACK_INST_START)); PyDict_SetItemString(d, "RPMCALLBACK_INST_OPEN_FILE", PyInt_FromLong(RPMCALLBACK_INST_OPEN_FILE)); PyDict_SetItemString(d, "RPMCALLBACK_INST_CLOSE_FILE", PyInt_FromLong(RPMCALLBACK_INST_CLOSE_FILE)); PyDict_SetItemString(d, "RPMCALLBACK_TRANS_PROGRESS", PyInt_FromLong(RPMCALLBACK_TRANS_PROGRESS)); PyDict_SetItemString(d, "RPMCALLBACK_TRANS_START", PyInt_FromLong(RPMCALLBACK_TRANS_START)); PyDict_SetItemString(d, "RPMCALLBACK_TRANS_STOP", PyInt_FromLong(RPMCALLBACK_TRANS_STOP)); PyDict_SetItemString(d, "RPMCALLBACK_UNINST_PROGRESS", PyInt_FromLong(RPMCALLBACK_UNINST_PROGRESS)); PyDict_SetItemString(d, "RPMCALLBACK_UNINST_START", PyInt_FromLong(RPMCALLBACK_UNINST_START)); PyDict_SetItemString(d, "RPMCALLBACK_UNINST_STOP", PyInt_FromLong(RPMCALLBACK_UNINST_STOP)); PyDict_SetItemString(d, "RPMPROB_BADARCH", PyInt_FromLong(RPMPROB_BADARCH)); PyDict_SetItemString(d, "RPMPROB_BADOS", PyInt_FromLong(RPMPROB_BADOS)); PyDict_SetItemString(d, "RPMPROB_PKG_INSTALLED", PyInt_FromLong(RPMPROB_PKG_INSTALLED)); PyDict_SetItemString(d, "RPMPROB_BADRELOCATE", PyInt_FromLong(RPMPROB_BADRELOCATE)); PyDict_SetItemString(d, "RPMPROB_REQUIRES", PyInt_FromLong(RPMPROB_REQUIRES)); PyDict_SetItemString(d, "RPMPROB_CONFLICT", PyInt_FromLong(RPMPROB_CONFLICT)); PyDict_SetItemString(d, "RPMPROB_NEW_FILE_CONFLICT", PyInt_FromLong(RPMPROB_NEW_FILE_CONFLICT)); PyDict_SetItemString(d, "RPMPROB_FILE_CONFLICT", PyInt_FromLong(RPMPROB_FILE_CONFLICT)); PyDict_SetItemString(d, "RPMPROB_OLDPACKAGE", PyInt_FromLong(RPMPROB_OLDPACKAGE)); PyDict_SetItemString(d, "RPMPROB_DISKSPACE", PyInt_FromLong(RPMPROB_DISKSPACE)); } /* make a header with _all_ the tags we need */ void mungeFilelist(Header h) { const char ** fileNames = NULL; int count = 0; if (!headerIsEntry (h, RPMTAG_BASENAMES) || !headerIsEntry (h, RPMTAG_DIRNAMES) || !headerIsEntry (h, RPMTAG_DIRINDEXES)) compressFilelist(h); rpmBuildFileList(h, &fileNames, &count); if (fileNames == NULL || count <= 0) return; headerAddEntry(h, RPMTAG_OLDFILENAMES, RPM_STRING_ARRAY_TYPE, fileNames, count); xfree(fileNames); } static int psGetArchScore(Header h) { void * pkgArch; int type, count; if (!headerGetEntry(h, RPMTAG_ARCH, &type, (void **) &pkgArch, &count) || type == RPM_INT8_TYPE) return 150; else return rpmMachineScore(RPM_MACHTABLE_INSTARCH, pkgArch); } static int pkgCompareVer(void * first, void * second) { struct packageInfo ** a = first; struct packageInfo ** b = second; int ret, score1, score2; /* put packages w/o names at the end */ if (!(*a)->name) return 1; if (!(*b)->name) return -1; ret = strcasecmp((*a)->name, (*b)->name); if (ret) return ret; score1 = psGetArchScore((*a)->h); if (!score1) return 1; score2 = psGetArchScore((*b)->h); if (!score2) return -1; if (score1 < score2) return -1; if (score1 > score2) return 1; return rpmVersionCompare((*b)->h, (*a)->h); } static void pkgSort(struct pkgSet * psp) { int i; char *name; qsort(psp->packages, psp->numPackages, sizeof(*psp->packages), (void *) pkgCompareVer); name = psp->packages[0]->name; if (!name) { psp->numPackages = 0; return; } for (i = 1; i < psp->numPackages; i++) { if (!psp->packages[i]->name) break; if (!strcmp(psp->packages[i]->name, name)) psp->packages[i]->name = NULL; else name = psp->packages[i]->name; } qsort(psp->packages, psp->numPackages, sizeof(*psp->packages), (void *) pkgCompareVer); for (i = 0; i < psp->numPackages; i++) if (!psp->packages[i]->name) break; psp->numPackages = i; } static PyObject * findUpgradeSet(PyObject * self, PyObject * args) { PyObject * hdrList, * result; char * root = "/"; int i; struct pkgSet list; hdrObject * hdr; if (!PyArg_ParseTuple(args, "O|s", &hdrList, &root)) return NULL; if (!PyList_Check(hdrList)) { PyErr_SetString(PyExc_TypeError, "list of headers expected"); return NULL; } list.numPackages = PyList_Size(hdrList); list.packages = alloca(sizeof(list.packages) * list.numPackages); for (i = 0; i < list.numPackages; i++) { hdr = (hdrObject *) PyList_GetItem(hdrList, i); if (hdr->ob_type != &hdrType) { PyErr_SetString(PyExc_TypeError, "list of headers expected"); return NULL; } list.packages[i] = alloca(sizeof(struct packageInfo)); list.packages[i]->h = hdr->h; list.packages[i]->selected = 0; list.packages[i]->data = hdr; headerGetEntry(hdr->h, RPMTAG_NAME, NULL, (void **) &list.packages[i]->name, NULL); } pkgSort (&list); if (ugFindUpgradePackages(&list, root)) { PyErr_SetString(pyrpmError, "error during upgrade check"); return NULL; } result = PyList_New(0); for (i = 0; i < list.numPackages; i++) { if (list.packages[i]->selected) PyList_Append(result, list.packages[i]->data); } return result; } static rpmdbObject * rpmOpenDB(PyObject * self, PyObject * args) { rpmdbObject * o; char * root = ""; int forWrite = 0; if (!PyArg_ParseTuple(args, "|is", &forWrite, &root)) return NULL; o = PyObject_NEW(rpmdbObject, &rpmdbType); o->db = NULL; if (rpmdbOpen(root, &o->db, forWrite ? O_RDWR | O_CREAT: O_RDONLY, 0)) { char * errmsg = "cannot open database in %s"; char * errstr = NULL; int errsize; Py_DECREF(o); /* PyErr_SetString should take varargs... */ errsize = strlen(errmsg) + *root == '\0' ? 15 /* "/var/lib/rpm" */ : strlen(root); errstr = alloca(errsize); snprintf(errstr, errsize, errmsg, *root == '\0' ? "/var/lib/rpm" : root); PyErr_SetString(pyrpmError, errstr); return NULL; } return o; } static PyObject * rebuildDB (PyObject * self, PyObject * args) { char * root = ""; if (!PyArg_ParseTuple(args, "s", &root)) return NULL; return Py_BuildValue("i", rpmdbRebuild(root)); } static PyObject * rpmReadHeaders (FD_t fd) { PyObject * list; Header header; hdrObject * h; if (!fd) { PyErr_SetFromErrno(pyrpmError); return NULL; } list = PyList_New(0); Py_BEGIN_ALLOW_THREADS header = headerRead(fd, HEADER_MAGIC_YES); Py_END_ALLOW_THREADS while (header) { h = (hdrObject *) PyObject_NEW(PyObject, &hdrType); h->h = header; h->fileList = h->linkList = h->md5list = NULL; h->uids = h->gids = h->mtimes = h->fileSizes = NULL; h->modes = h->rdevs = NULL; if (PyList_Append(list, (PyObject *) h)) { Py_DECREF(list); Py_DECREF(h); return NULL; } Py_DECREF(h); Py_BEGIN_ALLOW_THREADS header = headerRead(fd, HEADER_MAGIC_YES); Py_END_ALLOW_THREADS } return list; } static PyObject * rpmHeaderFromFD(PyObject * self, PyObject * args) { FD_t fd; int fileno; PyObject * list; if (!PyArg_ParseTuple(args, "i", &fileno)) return NULL; fd = fdDup(fileno); list = rpmReadHeaders (fd); Fclose(fd); return list; } static PyObject * hdrLoad(PyObject * self, PyObject * args) { char * obj; Header hdr; hdrObject * h; int len; if (!PyArg_ParseTuple(args, "s#", &obj, &len)) return NULL; hdr = headerLoad(obj); if (!hdr) { PyErr_SetString(pyrpmError, "bad header"); return NULL; } h = (hdrObject *) PyObject_NEW(PyObject, &hdrType); h->h = hdr; h->fileList = h->linkList = h->md5list = NULL; h->uids = h->gids = h->mtimes = h->fileSizes = NULL; h->modes = h->rdevs = NULL; return (PyObject *) h; } static PyObject * rpmHeaderFromFile(PyObject * self, PyObject * args) { char * filespec; FD_t fd; PyObject * list; if (!PyArg_ParseTuple(args, "s", &filespec)) return NULL; fd = Fopen(filespec, "r.fdio"); if (!fd) { PyErr_SetFromErrno(pyrpmError); return NULL; } list = rpmReadHeaders (fd); Fclose(fd); return list; } static PyObject * errorCB = NULL, * errorData = NULL; static void errorcb (void) { PyObject * result, * args = NULL; if (errorData) args = Py_BuildValue("(O)", errorData); result = PyEval_CallObject(errorCB, args); Py_XDECREF(args); if (result == NULL) { PyErr_Print(); PyErr_Clear(); } Py_DECREF (result); } static PyObject * errorSetCallback (PyObject * self, PyObject * args) { if (errorCB != NULL) { Py_DECREF (errorCB); errorCB = NULL; } if (errorData != NULL) { Py_DECREF (errorData); errorData = NULL; } if (!PyArg_ParseTuple(args, "O|O", &errorCB, &errorData)) return NULL; /* if we're getting a void*, set the error callback to this. */ /* also, we can possibly decref any python callbacks we had */ /* and set them to NULL. */ if (PyCObject_Check (errorCB)) { rpmErrorSetCallback (PyCObject_AsVoidPtr(errorCB)); Py_XDECREF (errorCB); Py_XDECREF (errorData); errorCB = NULL; errorData = NULL; Py_INCREF(Py_None); return Py_None; } if (!PyCallable_Check (errorCB)) { PyErr_SetString(PyExc_TypeError, "parameter must be callable"); return NULL; } Py_INCREF (errorCB); Py_XINCREF (errorData); return PyCObject_FromVoidPtr(rpmErrorSetCallback (errorcb), NULL); } static PyObject * errorString (PyObject * self, PyObject * args) { return PyString_FromString(rpmErrorString ()); } static PyObject * versionCompare (PyObject * self, PyObject * args) { hdrObject * h1, * h2; if (!PyArg_ParseTuple(args, "O!O!", &hdrType, &h1, &hdrType, &h2)) return NULL; return Py_BuildValue("i", rpmVersionCompare(h1->h, h2->h)); } static PyObject * labelCompare (PyObject * self, PyObject * args) { char *v1, *r1, *e1, *v2, *r2, *e2; int rc; if (!PyArg_ParseTuple(args, "(zzz)(zzz)", &e1, &v1, &r1, &e2, &v2, &r2)) return NULL; if (e1 && !e2) return Py_BuildValue("i", 1); else if (!e1 && e2) return Py_BuildValue("i", -1); else if (e1 && e2) { int ep1, ep2; ep1 = atoi (e1); ep2 = atoi (e2); if (ep1 < ep2) return Py_BuildValue("i", -1); else if (ep1 > ep2) return Py_BuildValue("i", 1); } rc = rpmvercmp(v1, v2); if (rc) return Py_BuildValue("i", rc); return Py_BuildValue("i", rpmvercmp(r1, r2)); } static PyObject * rpmHeaderFromPackage(PyObject * self, PyObject * args) { hdrObject * h; Header header; int rc; FD_t fd; int rawFd; int isSource; if (!PyArg_ParseTuple(args, "i", &rawFd)) return NULL; fd = fdDup(rawFd); rc = rpmReadPackageHeader(fd, &header, &isSource, NULL, NULL); Fclose(fd); switch (rc) { case 0: h = (hdrObject *) PyObject_NEW(PyObject, &hdrType); h->h = header; h->fileList = h->linkList = h->md5list = NULL; h->uids = h->gids = h->mtimes = h->fileSizes = NULL; h->modes = h->rdevs = NULL; break; case 1: Py_INCREF(Py_None); h = (hdrObject *) Py_None; break; default: PyErr_SetString(pyrpmError, "error reading package"); return NULL; } return Py_BuildValue("(Oi)", h, isSource); } /* methods for rpmdb object */ static PyObject * rpmdbGetAttr(rpmdbObject * s, char * name) { return Py_FindMethod(rpmdbMethods, (PyObject * ) s, name); } static void rpmdbDealloc(rpmdbObject * s) { if (s->db) { rpmdbClose(s->db); } } static PyObject * rpmdbFirst(rpmdbObject * s, PyObject * args) { int first; if (!PyArg_ParseTuple (args, "")) return NULL; first = rpmdbFirstRecNum(s->db); if (!first) { PyErr_SetString(pyrpmError, "cannot find first entry in database\n"); return NULL; } return Py_BuildValue("i", first); } static PyObject * rpmdbNext(rpmdbObject * s, PyObject * args) { int where; if (!PyArg_ParseTuple (args, "i", &where)) return NULL; where = rpmdbNextRecNum(s->db, where); if (!where) { Py_INCREF(Py_None); return Py_None; } return Py_BuildValue("i", where); } static PyObject * handleDbResult(int rc, dbiIndexSet matches) { PyObject * list; int i; if (rc == -1) { PyErr_SetString(pyrpmError, "error reading from database"); return NULL; } list = PyList_New(0); if (!rc) { for (i = 0; i < matches.count; i++) PyList_Append(list, PyInt_FromLong(matches.recs[i].recOffset)); dbiFreeIndexRecord(matches); } return list; } static PyObject * rpmdbByName(rpmdbObject * s, PyObject * args) { char * str; dbiIndexSet matches; int rc; if (!PyArg_ParseTuple(args, "s", &str)) return NULL; rc = rpmdbFindPackage(s->db, str, &matches); return handleDbResult(rc, matches); } static PyObject * rpmdbByFile(rpmdbObject * s, PyObject * args) { char * str; dbiIndexSet matches; int rc; if (!PyArg_ParseTuple(args, "s", &str)) return NULL; rc = rpmdbFindByFile(s->db, str, &matches); return handleDbResult(rc, matches); } static PyObject * rpmdbByProvides(rpmdbObject * s, PyObject * args) { char * str; dbiIndexSet matches; int rc; if (!PyArg_ParseTuple(args, "s", &str)) return NULL; rc = rpmdbFindByProvides(s->db, str, &matches); return handleDbResult(rc, matches); } static int rpmdbLength(rpmdbObject * s) { int first; int count = 0; first = rpmdbFirstRecNum(s->db); if (!first) return 0; count++; while ((first = rpmdbNextRecNum(s->db, first))) { count++; } return count; } static hdrObject * rpmdbSubscript(rpmdbObject * s, PyObject * key) { int offset; hdrObject * h; if (!PyInt_Check(key)) { PyErr_SetString(PyExc_TypeError, "integer expected"); return NULL; } offset = (int) PyInt_AsLong(key); h = PyObject_NEW(hdrObject, &hdrType); h->h = NULL; h->h = rpmdbGetRecord(s->db, offset); h->fileList = h->linkList = h->md5list = NULL; h->uids = h->gids = h->mtimes = h->fileSizes = NULL; h->modes = h->rdevs = NULL; if (!h->h) { Py_DECREF(h); PyErr_SetString(pyrpmError, "cannot read rpmdb entry"); return NULL; } return h; } /* methods for header object */ static void hdrDealloc(hdrObject * s) { if (s->h) headerFree(s->h); if (s->md5list) free(s->md5list); if (s->fileList) free(s->fileList); if (s->linkList) free(s->linkList); } static PyObject * hdrGetAttr(hdrObject * s, char * name) { return Py_FindMethod(hdrMethods, (PyObject * ) s, name); } static PyObject * hdrSubscript(hdrObject * s, PyObject * item) { int type, count, i, tag = -1; void * data; PyObject * o, * metao; char ** stringArray; int forceArray = 0; int freeData = 0; char * str; struct headerSprintfExtension * ext = NULL; const struct headerSprintfExtension * extensions = rpmHeaderFormats; if (PyCObject_Check (item)) { ext = PyCObject_AsVoidPtr(item); } else if (PyInt_Check(item)) { tag = PyInt_AsLong(item); } else if (PyString_Check(item)) { str = PyString_AsString(item); for (i = 0; i < rpmTagTableSize; i++) if (!strcasecmp(rpmTagTable[i].name + 7, str)) break; if (i < rpmTagTableSize) tag = rpmTagTable[i].val; if (tag == -1) { /* if we still don't have the tag, go looking for the header extensions */ while (extensions->name) { if (extensions->type == HEADER_EXT_TAG && !strcasecmp(extensions->name + 7, str)) { (const struct headerSprintfExtension *) ext = extensions; } extensions++; } } } if (ext) { ext->u.tagFunction(s->h, &type, (const void **) &data, &count, &freeData); } else { if (tag == -1) { PyErr_SetString(PyExc_KeyError, "unknown header tag"); return NULL; } if (!rpmHeaderGetEntry(s->h, tag, &type, &data, &count)) { Py_INCREF(Py_None); return Py_None; } } switch (tag) { case RPMTAG_OLDFILENAMES: case RPMTAG_FILESIZES: case RPMTAG_FILESTATES: case RPMTAG_FILEMODES: case RPMTAG_FILEUIDS: case RPMTAG_FILEGIDS: case RPMTAG_FILERDEVS: case RPMTAG_FILEMTIMES: case RPMTAG_FILEMD5S: case RPMTAG_FILELINKTOS: case RPMTAG_FILEFLAGS: case RPMTAG_ROOT: case RPMTAG_FILEUSERNAME: case RPMTAG_FILEGROUPNAME: forceArray = 1; break; case RPMTAG_SUMMARY: case RPMTAG_GROUP: case RPMTAG_DESCRIPTION: freeData = 1; break; default: break; } switch (type) { case RPM_BIN_TYPE: o = PyString_FromStringAndSize(data, count); break; case RPM_INT32_TYPE: if (count != 1 || forceArray) { metao = PyList_New(0); for (i = 0; i < count; i++) { o = PyInt_FromLong(((int *) data)[i]); PyList_Append(metao, o); Py_DECREF(o); } o = metao; } else { o = PyInt_FromLong(*((int *) data)); } break; case RPM_CHAR_TYPE: case RPM_INT8_TYPE: if (count != 1 || forceArray) { metao = PyList_New(0); for (i = 0; i < count; i++) { o = PyInt_FromLong(((char *) data)[i]); PyList_Append(metao, o); Py_DECREF(o); } o = metao; } else { o = PyInt_FromLong(*((char *) data)); } break; case RPM_INT16_TYPE: if (count != 1 || forceArray) { metao = PyList_New(0); for (i = 0; i < count; i++) { o = PyInt_FromLong(((short *) data)[i]); PyList_Append(metao, o); Py_DECREF(o); } o = metao; } else { o = PyInt_FromLong(*((short *) data)); } break; case RPM_STRING_ARRAY_TYPE: stringArray = data; metao = PyList_New(0); for (i = 0; i < count; i++) { o = PyString_FromString(stringArray[i]); PyList_Append(metao, o); Py_DECREF(o); } o = metao; break; case RPM_STRING_TYPE: if (count != 1 || forceArray) { stringArray = data; metao = PyList_New(0); for (i=0; i < count; i++) { o = PyString_FromString(stringArray[i]); PyList_Append(metao, o); Py_DECREF(o); } o = metao; } else { o = PyString_FromString(data); if (freeData) free (data); } break; default: PyErr_SetString(PyExc_TypeError, "unsupported type in header"); return NULL; } return o; } static PyObject * hdrKeyList(hdrObject * s, PyObject * args) { PyObject * list; HeaderIterator iter; int tag, type; if (!PyArg_ParseTuple(args, "")) return NULL; list = PyList_New(0); iter = headerInitIterator(s->h); while (headerNextIterator(iter, &tag, &type, NULL, NULL)) { if (tag == HEADER_I18NTABLE) continue; switch (type) { case RPM_BIN_TYPE: case RPM_INT32_TYPE: case RPM_CHAR_TYPE: case RPM_INT8_TYPE: case RPM_INT16_TYPE: case RPM_STRING_ARRAY_TYPE: case RPM_STRING_TYPE: PyList_Append(list, PyInt_FromLong(tag)); } } headerFreeIterator(iter); return list; } static PyObject * hdrUnload(hdrObject * s, PyObject * args) { char * buf; int len; PyObject * rc; len = headerSizeof(s->h, 0); buf = headerUnload(s->h); rc = PyString_FromStringAndSize(buf, len); free(buf); return rc; } /* Returns a list of these tuple for each part which failed: (attr_name, correctValue, currentValue) It should be passwd the file number to verify. */ static PyObject * hdrVerifyFile(hdrObject * s, PyObject * args) { int fileNumber; int verifyResult; PyObject * list, * tuple, * attrName; int type, count; struct stat sb; char buf[2048]; int i; time_t timeInt; struct tm * timeStruct; if (!PyInt_Check(args)) { PyErr_SetString(PyExc_TypeError, "integer expected"); return NULL; } fileNumber = (int) PyInt_AsLong(args); if (rpmVerifyFile("", s->h, fileNumber, &verifyResult, 0)) { Py_INCREF(Py_None); return Py_None; } list = PyList_New(0); if (!verifyResult) return list; if (!s->fileList) { headerGetEntry(s->h, RPMTAG_OLDFILENAMES, &type, (void **) &s->fileList, &count); } lstat(s->fileList[fileNumber], &sb); if (verifyResult & RPMVERIFY_MD5) { if (!s->md5list) { headerGetEntry(s->h, RPMTAG_FILEMD5S, &type, (void **) &s->md5list, &count); } if (mdfile(s->fileList[fileNumber], buf)) { strcpy(buf, "(unknown)"); } tuple = PyTuple_New(3); attrName = PyString_FromString("checksum"); PyTuple_SetItem(tuple, 0, attrName); PyTuple_SetItem(tuple, 1, PyString_FromString(s->md5list[fileNumber])); PyTuple_SetItem(tuple, 2, PyString_FromString(buf)); PyList_Append(list, tuple); } if (verifyResult & RPMVERIFY_FILESIZE) { if (!s->fileSizes) { headerGetEntry(s->h, RPMTAG_FILESIZES, &type, (void **) &s->fileSizes, &count); } tuple = PyTuple_New(3); attrName = PyString_FromString("size"); PyTuple_SetItem(tuple, 0, attrName); sprintf(buf, "%d", 100); PyTuple_SetItem(tuple, 1, PyString_FromString(buf)); sprintf(buf, "%ld", sb.st_size); PyTuple_SetItem(tuple, 2, PyString_FromString(buf)); PyList_Append(list, tuple); } if (verifyResult & RPMVERIFY_LINKTO) { if (!s->linkList) { headerGetEntry(s->h, RPMTAG_FILELINKTOS, &type, (void **) &s->linkList, &count); } i = readlink(s->fileList[fileNumber], buf, sizeof(buf)); if (i <= 0) strcpy(buf, "(unknown)"); else buf[i] = '\0'; tuple = PyTuple_New(3); attrName = PyString_FromString("link"); PyTuple_SetItem(tuple, 0, attrName); PyTuple_SetItem(tuple, 1, PyString_FromString(s->linkList[fileNumber])); PyTuple_SetItem(tuple, 2, PyString_FromString(buf)); PyList_Append(list, tuple); } if (verifyResult & RPMVERIFY_MTIME) { if (!s->mtimes) { headerGetEntry(s->h, RPMTAG_FILEMTIMES, &type, (void **) &s->mtimes, &count); } tuple = PyTuple_New(3); attrName = PyString_FromString("time"); PyTuple_SetItem(tuple, 0, attrName); timeInt = sb.st_mtime; timeStruct = localtime(&timeInt); strftime(buf, sizeof(buf) - 1, "%c", timeStruct); PyTuple_SetItem(tuple, 1, PyString_FromString(buf)); timeInt = s->mtimes[fileNumber]; timeStruct = localtime(&timeInt); strftime(buf, sizeof(buf) - 1, "%c", timeStruct); PyTuple_SetItem(tuple, 2, PyString_FromString(buf)); PyList_Append(list, tuple); } if (verifyResult & RPMVERIFY_RDEV) { if (!s->rdevs) { headerGetEntry(s->h, RPMTAG_FILERDEVS, &type, (void **) &s->rdevs, &count); } tuple = PyTuple_New(3); attrName = PyString_FromString("device"); PyTuple_SetItem(tuple, 0, attrName); sprintf(buf, "0x%-4x", s->rdevs[fileNumber]); PyTuple_SetItem(tuple, 1, PyString_FromString(buf)); sprintf(buf, "0x%-4x", (unsigned int) sb.st_rdev); PyTuple_SetItem(tuple, 2, PyString_FromString(buf)); PyList_Append(list, tuple); } /* RPMVERIFY_USER and RPM_VERIFY_GROUP are handled wrong here, but rpmlib.a doesn't do these correctly either. At least this is consisten */ if (verifyResult & RPMVERIFY_USER) { if (!s->uids) { headerGetEntry(s->h, RPMTAG_FILEUIDS, &type, (void **) &s->uids, &count); } tuple = PyTuple_New(3); attrName = PyString_FromString("uid"); PyTuple_SetItem(tuple, 0, attrName); sprintf(buf, "%d", s->uids[fileNumber]); PyTuple_SetItem(tuple, 1, PyString_FromString(buf)); sprintf(buf, "%d", sb.st_uid); PyTuple_SetItem(tuple, 2, PyString_FromString(buf)); PyList_Append(list, tuple); } if (verifyResult & RPMVERIFY_GROUP) { if (!s->gids) { headerGetEntry(s->h, RPMTAG_FILEGIDS, &type, (void **) &s->gids, &count); } tuple = PyTuple_New(3); attrName = PyString_FromString("gid"); PyTuple_SetItem(tuple, 0, attrName); sprintf(buf, "%d", s->gids[fileNumber]); PyTuple_SetItem(tuple, 1, PyString_FromString(buf)); sprintf(buf, "%d", sb.st_gid); PyTuple_SetItem(tuple, 2, PyString_FromString(buf)); PyList_Append(list, tuple); } if (verifyResult & RPMVERIFY_MODE) { if (!s->modes) { headerGetEntry(s->h, RPMTAG_FILEMODES, &type, (void **) &s->modes, &count); } tuple = PyTuple_New(3); attrName = PyString_FromString("permissions"); PyTuple_SetItem(tuple, 0, attrName); sprintf(buf, "0%-4o", s->modes[fileNumber]); PyTuple_SetItem(tuple, 1, PyString_FromString(buf)); sprintf(buf, "0%-4o", sb.st_mode); PyTuple_SetItem(tuple, 2, PyString_FromString(buf)); PyList_Append(list, tuple); } return list; } static PyObject * hdrCompressFilelist(hdrObject * s, PyObject * args) { compressFilelist (s->h); Py_INCREF(Py_None); return Py_None; } static PyObject * hdrExpandFilelist(hdrObject * s, PyObject * args) { expandFilelist (s->h); Py_INCREF(Py_None); return Py_None; } static PyObject * hdrFullFilelist(hdrObject * s, PyObject * args) { mungeFilelist (s->h); Py_INCREF(Py_None); return Py_None; } static PyObject * rpmtransCreate(PyObject * self, PyObject * args) { rpmtransObject * o; rpmdbObject * db = NULL; char * rootPath = "/"; if (!PyArg_ParseTuple(args, "|sO", &rootPath, &db)) return NULL; if (db && db->ob_type != &rpmdbType) { PyErr_SetString(PyExc_TypeError, "bad type for database argument"); return NULL; } o = (void *) PyObject_NEW(rpmtransObject, &rpmtransType); Py_XINCREF(db); o->dbo = db; o->scriptFd = NULL; o->ts = rpmtransCreateSet(db ? db->db : NULL, rootPath); o->keyList = PyList_New(0); return (void *) o; } static void rpmtransDealloc(PyObject * o) { rpmtransObject * trans = (void *) o; rpmtransFree(trans->ts); if (trans->dbo) { Py_DECREF(trans->dbo); } if (trans->scriptFd) Fclose(trans->scriptFd); /* this will free the keyList, and decrement the ref count of all the items on the list as well :-) */ Py_DECREF(trans->keyList); } static PyObject * rpmtransGetAttr(rpmtransObject * o, char * name) { return Py_FindMethod(rpmtransMethods, (PyObject *) o, name); } static int rpmtransSetAttr(rpmtransObject * o, char * name, PyObject * val) { int i; if (!strcmp(name, "scriptFd")) { if (!PyArg_Parse(val, "i", &i)) return 0; if (i < 0) { PyErr_SetString(PyExc_TypeError, "bad file descriptor"); return -1; } else { o->scriptFd = fdDup(i); rpmtransSetScriptFd(o->ts, o->scriptFd); } } else { PyErr_SetString(PyExc_AttributeError, name); return -1; } return 0; } static PyObject * rpmtransAdd(rpmtransObject * s, PyObject * args) { hdrObject * h; PyObject * key; char * how = NULL; int isUpgrade = 0; if (!PyArg_ParseTuple(args, "OO|s", &h, &key, &how)) return NULL; if (h->ob_type != &hdrType) { PyErr_SetString(PyExc_TypeError, "bad type for header argument"); return NULL; } if (how && strcmp(how, "a") && strcmp(how, "u") && strcmp(how, "i")) { PyErr_SetString(PyExc_TypeError, "how argument must be \"u\", \"a\", or \"i\""); return NULL; } else if (how && !strcmp(how, "u")) isUpgrade = 1; if (how && !strcmp(how, "a")) rpmtransAvailablePackage(s->ts, h->h, key); else rpmtransAddPackage(s->ts, h->h, NULL, key, isUpgrade, NULL); /* This should increment the usage count for me */ if (key) PyList_Append(s->keyList, key); Py_INCREF(Py_None); return Py_None; } static PyObject * rpmtransOrder(rpmtransObject * s, PyObject * args) { if (!PyArg_ParseTuple(args, "")) return NULL; rpmdepOrder(s->ts); Py_INCREF(Py_None); return Py_None; } static PyObject * rpmtransDepCheck(rpmtransObject * s, PyObject * args) { struct rpmDependencyConflict * conflicts; int numConflicts; PyObject * list, * cf; int i; if (!PyArg_ParseTuple(args, "")) return NULL; rpmdepCheck(s->ts, &conflicts, &numConflicts); if (numConflicts) { list = PyList_New(0); for (i = 0; i < numConflicts; i++) { cf = Py_BuildValue("((sss)(ss)iOi)", conflicts[i].byName, conflicts[i].byVersion, conflicts[i].byRelease, conflicts[i].needsName, conflicts[i].needsVersion, conflicts[i].needsFlags, conflicts[i].suggestedPackage ? conflicts[i].suggestedPackage : Py_None, conflicts[i].sense); PyList_Append(list, (PyObject *) cf); Py_DECREF(cf); } rpmdepFreeConflicts(conflicts, numConflicts); return list; } Py_INCREF(Py_None); return Py_None; } struct tsCallbackType { PyObject * cb; PyObject * data; int pythonError; }; static void * tsCallback(const Header h, const rpmCallbackType what, const unsigned long amount, const unsigned long total, const void * pkgKey, void * data) { struct tsCallbackType * cbInfo = data; PyObject * args, * result; int fd; static FD_t fdt; if (cbInfo->pythonError) return NULL; if (!pkgKey) pkgKey = Py_None; args = Py_BuildValue("(illOO)", what, amount, total, pkgKey, cbInfo->data); result = PyEval_CallObject(cbInfo->cb, args); Py_DECREF(args); if (!result) { cbInfo->pythonError = 1; return NULL; } if (what == RPMCALLBACK_INST_OPEN_FILE) { if (!PyArg_Parse(result, "i", &fd)) { cbInfo->pythonError = 1; return NULL; } fdt = fdDup(fd); Py_DECREF(result); return fdt; } if (what == RPMCALLBACK_INST_CLOSE_FILE) { Fclose (fdt); } Py_DECREF(result); return NULL; } static PyObject * rpmtransRun(rpmtransObject * s, PyObject * args) { int flags, ignoreSet; int rc, i; PyObject * list, * prob; rpmProblemSet probs; struct tsCallbackType cbInfo; if (!PyArg_ParseTuple(args, "iiOO", &flags, &ignoreSet, &cbInfo.cb, &cbInfo.data)) return NULL; cbInfo.pythonError = 0; rc = rpmRunTransactions(s->ts, tsCallback, &cbInfo, NULL, &probs, flags, ignoreSet); if (cbInfo.pythonError) { if (rc > 0) rpmProblemSetFree(probs); return NULL; } if (rc < 0) { list = PyList_New(0); return list; } else if (!rc) { Py_INCREF(Py_None); return Py_None; } list = PyList_New(0); for (i = 0; i < probs->numProblems; i++) { prob = Py_BuildValue("s(isi)", rpmProblemString(probs->probs[i]), probs->probs[i].type, probs->probs[i].str1, probs->probs[i].ulong1); PyList_Append(list, prob); Py_DECREF(prob); } rpmProblemSetFree(probs); return list; } static PyObject * archScore(PyObject * self, PyObject * args) { char * arch; int score; if (!PyArg_ParseTuple(args, "s", &arch)) return NULL; score = rpmMachineScore(RPM_MACHTABLE_INSTARCH, arch); return Py_BuildValue("i", score); } static PyObject * doAddMacro(PyObject * self, PyObject * args) { char * name, * val; if (!PyArg_ParseTuple(args, "ss", &name, &val)) return NULL; addMacro(NULL, name, NULL, val, RMIL_DEFAULT); Py_INCREF(Py_None); return Py_None; } static PyObject * doDelMacro(PyObject * self, PyObject * args) { char * name; if (!PyArg_ParseTuple(args, "s", &name)) return NULL; delMacro(NULL, name); Py_INCREF(Py_None); return Py_None; } typedef struct FDlist_t FDlist; struct FDlist_t { FILE *f; FD_t fd; FDlist *next; } ; static FDlist *fdhead = NULL; static FDlist *fdtail = NULL; static int closeCallback(FILE * f) { FDlist *node, *last; node = fdhead; last = NULL; while (node) { if (node->f == f) break; last = node; node = node->next; } if (node) { if (last) last->next = node->next; else fdhead = node->next; printf ("closing\n"); node->fd = fdLink(node->fd, "closeCallback"); Fclose (node->fd); while (node->fd) node->fd = fdFree(node->fd, "closeCallback"); free (node); } return 0; } static PyObject * doFopen(PyObject * self, PyObject * args) { char * path, * mode; FDlist *node; if (!PyArg_ParseTuple(args, "ss", &path, &mode)) return NULL; node = malloc (sizeof(FDlist)); node->fd = Fopen(path, mode); node->fd = fdLink(node->fd, "doFopen"); if (!node->fd) { PyErr_SetFromErrno(pyrpmError); free (node); return NULL; } if (Ferror(node->fd)) { const char *err = Fstrerror(node->fd); free(node); if (err) { PyErr_SetString(pyrpmError, err); return NULL; } } node->f = fdGetFp(node->fd); if (!node->f) { PyErr_SetString(pyrpmError, "FD_t has no FILE*"); free(node); return NULL; } node->next = NULL; if (fdtail) { fdtail->next = node; } else { fdhead = node; } fdtail = node; return PyFile_FromFile (node->f, path, mode, closeCallback); }