2 * \file python/rpmfi-py.c
7 #include <rpm/rpmtypes.h>
8 #include <rpm/rpmpgp.h>
10 #include "header-py.h"
17 rpmfi_Debug(rpmfiObject * s, PyObject * args, PyObject * kwds)
19 char * kwlist[] = {"debugLevel", NULL};
21 if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmfi_debug))
29 rpmfi_FC(rpmfiObject * s)
31 return Py_BuildValue("i", rpmfiFC(s->fi));
35 rpmfi_FX(rpmfiObject * s)
37 return Py_BuildValue("i", rpmfiFX(s->fi));
41 rpmfi_DC(rpmfiObject * s)
43 return Py_BuildValue("i", rpmfiDC(s->fi));
47 rpmfi_DX(rpmfiObject * s)
49 return Py_BuildValue("i", rpmfiDX(s->fi));
53 rpmfi_BN(rpmfiObject * s)
55 return Py_BuildValue("s", xstrdup(rpmfiBN(s->fi)));
59 rpmfi_DN(rpmfiObject * s)
61 return Py_BuildValue("s", xstrdup(rpmfiDN(s->fi)));
65 rpmfi_FN(rpmfiObject * s)
67 return Py_BuildValue("s", xstrdup(rpmfiFN(s->fi)));
71 rpmfi_FFlags(rpmfiObject * s)
73 return Py_BuildValue("i", rpmfiFFlags(s->fi));
77 rpmfi_VFlags(rpmfiObject * s)
79 return Py_BuildValue("i", rpmfiVFlags(s->fi));
83 rpmfi_FMode(rpmfiObject * s)
85 return Py_BuildValue("i", rpmfiFMode(s->fi));
89 rpmfi_FState(rpmfiObject * s)
91 return Py_BuildValue("i", rpmfiFState(s->fi));
96 rpmfi_MD5(rpmfiObject * s)
98 const unsigned char * MD5;
103 MD5 = rpmfiMD5(s->fi);
106 for (i = 0; i < 16; i++, t += 2)
107 sprintf(t, "%02x", MD5[i]);
109 return Py_BuildValue("s", xstrdup(fmd5));
113 rpmfi_FLink(rpmfiObject * s)
115 return Py_BuildValue("s", xstrdup(rpmfiFLink(s->fi)));
119 rpmfi_FSize(rpmfiObject * s)
121 return Py_BuildValue("i", rpmfiFSize(s->fi));
125 rpmfi_FRdev(rpmfiObject * s)
127 return Py_BuildValue("i", rpmfiFRdev(s->fi));
131 rpmfi_FMtime(rpmfiObject * s)
133 return Py_BuildValue("i", rpmfiFMtime(s->fi));
137 rpmfi_FUser(rpmfiObject * s)
139 return Py_BuildValue("s", xstrdup(rpmfiFUser(s->fi)));
143 rpmfi_FGroup(rpmfiObject * s)
145 return Py_BuildValue("s", xstrdup(rpmfiFGroup(s->fi)));
149 rpmfi_FColor(rpmfiObject * s)
151 return Py_BuildValue("i", rpmfiFColor(s->fi));
155 rpmfi_FClass(rpmfiObject * s)
159 if ((FClass = rpmfiFClass(s->fi)) == NULL)
161 return Py_BuildValue("s", xstrdup(FClass));
164 #if Py_TPFLAGS_HAVE_ITER
166 rpmfi_iter(rpmfiObject * s)
169 return (PyObject *)s;
174 rpmfi_iternext(rpmfiObject * s)
176 PyObject * result = NULL;
178 /* Reset loop indices on 1st entry. */
180 s->fi = rpmfiInit(s->fi, 0);
184 /* If more to do, return the file tuple. */
185 if (rpmfiNext(s->fi) >= 0) {
186 const char * FN = rpmfiFN(s->fi);
187 int FSize = rpmfiFSize(s->fi);
188 int FMode = rpmfiFMode(s->fi);
189 int FMtime = rpmfiFMtime(s->fi);
190 int FFlags = rpmfiFFlags(s->fi);
191 int FRdev = rpmfiFRdev(s->fi);
192 int FInode = rpmfiFInode(s->fi);
193 int FNlink = rpmfiFNlink(s->fi);
194 int FState = rpmfiFState(s->fi);
195 int VFlags = rpmfiVFlags(s->fi);
196 const char * FUser = rpmfiFUser(s->fi);
197 const char * FGroup = rpmfiFGroup(s->fi);
198 const unsigned char * MD5 = rpmfiMD5(s->fi);
202 FMD5 = pgpHexStr(MD5, rpmDigestLength(PGPHASHALGO_MD5));
204 result = PyTuple_New(13);
207 PyTuple_SET_ITEM(result, 0, Py_None);
209 PyTuple_SET_ITEM(result, 0, Py_BuildValue("s", FN));
210 PyTuple_SET_ITEM(result, 1, PyInt_FromLong(FSize));
211 PyTuple_SET_ITEM(result, 2, PyInt_FromLong(FMode));
212 PyTuple_SET_ITEM(result, 3, PyInt_FromLong(FMtime));
213 PyTuple_SET_ITEM(result, 4, PyInt_FromLong(FFlags));
214 PyTuple_SET_ITEM(result, 5, PyInt_FromLong(FRdev));
215 PyTuple_SET_ITEM(result, 6, PyInt_FromLong(FInode));
216 PyTuple_SET_ITEM(result, 7, PyInt_FromLong(FNlink));
217 PyTuple_SET_ITEM(result, 8, PyInt_FromLong(FState));
218 PyTuple_SET_ITEM(result, 9, PyInt_FromLong(VFlags));
221 PyTuple_SET_ITEM(result, 10, Py_None);
223 PyTuple_SET_ITEM(result, 10, Py_BuildValue("s", FUser));
224 if (FGroup == NULL) {
226 PyTuple_SET_ITEM(result, 11, Py_None);
228 PyTuple_SET_ITEM(result, 11, Py_BuildValue("s", FGroup));
231 PyTuple_SET_ITEM(result, 12, Py_None);
233 PyTuple_SET_ITEM(result, 12, Py_BuildValue("s", FMD5));
242 rpmfi_Next(rpmfiObject * s)
244 PyObject * result = NULL;
246 result = rpmfi_iternext(s);
248 if (result == NULL) {
258 rpmfi_NextD(rpmfiObject * s)
265 rpmfi_InitD(rpmfiObject * s)
272 static struct PyMethodDef rpmfi_methods[] = {
273 {"Debug", (PyCFunction)rpmfi_Debug, METH_VARARGS|METH_KEYWORDS,
275 {"FC", (PyCFunction)rpmfi_FC, METH_NOARGS,
277 {"FX", (PyCFunction)rpmfi_FX, METH_NOARGS,
279 {"DC", (PyCFunction)rpmfi_DC, METH_NOARGS,
281 {"DX", (PyCFunction)rpmfi_DX, METH_NOARGS,
283 {"BN", (PyCFunction)rpmfi_BN, METH_NOARGS,
285 {"DN", (PyCFunction)rpmfi_DN, METH_NOARGS,
287 {"FN", (PyCFunction)rpmfi_FN, METH_NOARGS,
289 {"FFlags", (PyCFunction)rpmfi_FFlags, METH_NOARGS,
291 {"VFlags", (PyCFunction)rpmfi_VFlags, METH_NOARGS,
293 {"FMode", (PyCFunction)rpmfi_FMode, METH_NOARGS,
295 {"FState", (PyCFunction)rpmfi_FState, METH_NOARGS,
297 {"MD5", (PyCFunction)rpmfi_MD5, METH_NOARGS,
299 {"FLink", (PyCFunction)rpmfi_FLink, METH_NOARGS,
301 {"FSize", (PyCFunction)rpmfi_FSize, METH_NOARGS,
303 {"FRdev", (PyCFunction)rpmfi_FRdev, METH_NOARGS,
305 {"FMtime", (PyCFunction)rpmfi_FMtime, METH_NOARGS,
307 {"FUser", (PyCFunction)rpmfi_FUser, METH_NOARGS,
309 {"FGroup", (PyCFunction)rpmfi_FGroup, METH_NOARGS,
311 {"FColor", (PyCFunction)rpmfi_FColor, METH_NOARGS,
313 {"FClass", (PyCFunction)rpmfi_FClass, METH_NOARGS,
315 {"next", (PyCFunction)rpmfi_Next, METH_NOARGS,
316 "fi.next() -> (FN, FSize, FMode, FMtime, FFlags, FRdev, FInode, FNlink, FState, VFlags, FUser, FGroup, FMD5))\n\
317 - Retrieve next file info tuple.\n" },
319 {"NextD", (PyCFunction)rpmfi_NextD, METH_NOARGS,
321 {"InitD", (PyCFunction)rpmfi_InitD, METH_NOARGS,
324 {NULL, NULL} /* sentinel */
330 rpmfi_dealloc(rpmfiObject * s)
333 s->fi = rpmfiFree(s->fi);
339 rpmfi_print(rpmfiObject * s, FILE * fp, int flags)
344 s->fi = rpmfiInit(s->fi, 0);
345 while (rpmfiNext(s->fi) >= 0)
346 fprintf(fp, "%s\n", rpmfiFN(s->fi));
350 static PyObject * rpmfi_getattro(PyObject * o, PyObject * n)
352 return PyObject_GenericGetAttr(o, n);
355 static int rpmfi_setattro(PyObject * o, PyObject * n, PyObject * v)
357 return PyObject_GenericSetAttr(o, n, v);
361 rpmfi_length(rpmfiObject * s)
363 return rpmfiFC(s->fi);
367 rpmfi_subscript(rpmfiObject * s, PyObject * key)
371 if (!PyInt_Check(key)) {
372 PyErr_SetString(PyExc_TypeError, "integer expected");
376 ix = (int) PyInt_AsLong(key);
377 rpmfiSetFX(s->fi, ix);
378 return Py_BuildValue("s", xstrdup(rpmfiFN(s->fi)));
381 static PyMappingMethods rpmfi_as_mapping = {
382 (lenfunc) rpmfi_length, /* mp_length */
383 (binaryfunc) rpmfi_subscript, /* mp_subscript */
384 (objobjargproc)0, /* mp_ass_subscript */
389 static int rpmfi_init(rpmfiObject * s, PyObject *args, PyObject *kwds)
391 hdrObject * ho = NULL;
392 PyObject * to = NULL;
393 rpmts ts = NULL; /* XXX FIXME: fiFromHeader should be a ts method. */
394 rpmTag tagN = RPMTAG_BASENAMES;
396 char * kwlist[] = {"header", "tag", "flags", NULL};
398 if (_rpmfi_debug < 0)
399 fprintf(stderr, "*** rpmfi_init(%p,%p,%p)\n", s, args, kwds);
401 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oi:rpmfi_init", kwlist,
402 &hdr_Type, &ho, &to, &flags))
406 tagN = tagNumFromPyObject(to);
408 PyErr_SetString(PyExc_KeyError, "unknown header tag");
412 s->fi = rpmfiNew(ts, hdrGetHeader(ho), tagN, flags);
420 static void rpmfi_free(rpmfiObject * s)
423 fprintf(stderr, "%p -- fi %p\n", s, s->fi);
424 s->fi = rpmfiFree(s->fi);
426 PyObject_Del((PyObject *)s);
431 static PyObject * rpmfi_alloc(PyTypeObject * subtype, int nitems)
433 PyObject * s = PyType_GenericAlloc(subtype, nitems);
435 if (_rpmfi_debug < 0)
436 fprintf(stderr, "*** rpmfi_alloc(%p,%d) ret %p\n", subtype, nitems, s);
442 static PyObject * rpmfi_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
444 rpmfiObject * s = (void *) PyObject_New(rpmfiObject, subtype);
446 /* Perform additional initialization. */
447 if (rpmfi_init(s, args, kwds) < 0) {
453 fprintf(stderr, "%p ++ fi %p\n", s, s->fi);
455 return (PyObject *)s;
460 static char rpmfi_doc[] =
463 PyTypeObject rpmfi_Type = {
464 PyObject_HEAD_INIT(&PyType_Type)
466 "rpm.fi", /* tp_name */
467 sizeof(rpmfiObject), /* tp_basicsize */
470 (destructor) rpmfi_dealloc, /* tp_dealloc */
471 (printfunc) rpmfi_print, /* tp_print */
472 (getattrfunc)0, /* tp_getattr */
473 (setattrfunc)0, /* tp_setattr */
474 (cmpfunc)0, /* tp_compare */
475 (reprfunc)0, /* tp_repr */
476 0, /* tp_as_number */
477 0, /* tp_as_sequence */
478 &rpmfi_as_mapping, /* tp_as_mapping */
479 (hashfunc)0, /* tp_hash */
480 (ternaryfunc)0, /* tp_call */
481 (reprfunc)0, /* tp_str */
482 (getattrofunc) rpmfi_getattro, /* tp_getattro */
483 (setattrofunc) rpmfi_setattro, /* tp_setattro */
484 0, /* tp_as_buffer */
485 Py_TPFLAGS_DEFAULT, /* tp_flags */
486 rpmfi_doc, /* tp_doc */
487 #if Py_TPFLAGS_HAVE_ITER
490 0, /* tp_richcompare */
491 0, /* tp_weaklistoffset */
492 (getiterfunc) rpmfi_iter, /* tp_iter */
493 (iternextfunc) rpmfi_iternext, /* tp_iternext */
494 rpmfi_methods, /* tp_methods */
499 0, /* tp_descr_get */
500 0, /* tp_descr_set */
501 0, /* tp_dictoffset */
502 (initproc) rpmfi_init, /* tp_init */
503 (allocfunc) rpmfi_alloc, /* tp_alloc */
504 (newfunc) rpmfi_new, /* tp_new */
505 (freefunc) rpmfi_free, /* tp_free */
512 rpmfi fiFromFi(rpmfiObject * s)
520 rpmfiObject *s = PyObject_New(rpmfiObject, &rpmfi_Type);
530 hdr_fiFromHeader(PyObject * s, PyObject * args, PyObject * kwds)
532 hdrObject * ho = (hdrObject *)s;
533 PyObject * to = NULL;
534 rpmts ts = NULL; /* XXX FIXME: fiFromHeader should be a ts method. */
535 rpmTag tagN = RPMTAG_BASENAMES;
537 char * kwlist[] = {"tag", "flags", NULL};
539 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:fiFromHeader", kwlist,
544 tagN = tagNumFromPyObject(to);
546 PyErr_SetString(PyExc_KeyError, "unknown header tag");
550 return rpmfi_Wrap( rpmfiNew(ts, hdrGetHeader(ho), tagN, flags) );