2 * \file python/rpmfi-py.c
7 #include <rpm/rpmtag.h>
16 rpmfi_Debug(rpmfiObject * s, PyObject * args, PyObject * kwds)
18 char * kwlist[] = {"debugLevel", NULL};
20 if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmfi_debug))
28 rpmfi_FC(rpmfiObject * s)
30 return Py_BuildValue("i", rpmfiFC(s->fi));
34 rpmfi_FX(rpmfiObject * s)
36 return Py_BuildValue("i", rpmfiFX(s->fi));
40 rpmfi_DC(rpmfiObject * s)
42 return Py_BuildValue("i", rpmfiDC(s->fi));
46 rpmfi_DX(rpmfiObject * s)
48 return Py_BuildValue("i", rpmfiDX(s->fi));
52 rpmfi_BN(rpmfiObject * s)
54 return Py_BuildValue("s", xstrdup(rpmfiBN(s->fi)));
58 rpmfi_DN(rpmfiObject * s)
60 return Py_BuildValue("s", xstrdup(rpmfiDN(s->fi)));
64 rpmfi_FN(rpmfiObject * s)
66 return Py_BuildValue("s", xstrdup(rpmfiFN(s->fi)));
70 rpmfi_FFlags(rpmfiObject * s)
72 return Py_BuildValue("i", rpmfiFFlags(s->fi));
76 rpmfi_VFlags(rpmfiObject * s)
78 return Py_BuildValue("i", rpmfiVFlags(s->fi));
82 rpmfi_FMode(rpmfiObject * s)
84 return Py_BuildValue("i", rpmfiFMode(s->fi));
88 rpmfi_FState(rpmfiObject * s)
90 return Py_BuildValue("i", rpmfiFState(s->fi));
95 rpmfi_MD5(rpmfiObject * s)
97 const unsigned char * MD5;
102 MD5 = rpmfiMD5(s->fi);
105 for (i = 0; i < 16; i++, t += 2)
106 sprintf(t, "%02x", MD5[i]);
108 return Py_BuildValue("s", xstrdup(fmd5));
112 rpmfi_FLink(rpmfiObject * s)
114 return Py_BuildValue("s", xstrdup(rpmfiFLink(s->fi)));
118 rpmfi_FSize(rpmfiObject * s)
120 return Py_BuildValue("i", rpmfiFSize(s->fi));
124 rpmfi_FRdev(rpmfiObject * s)
126 return Py_BuildValue("i", rpmfiFRdev(s->fi));
130 rpmfi_FMtime(rpmfiObject * s)
132 return Py_BuildValue("i", rpmfiFMtime(s->fi));
136 rpmfi_FUser(rpmfiObject * s)
138 return Py_BuildValue("s", xstrdup(rpmfiFUser(s->fi)));
142 rpmfi_FGroup(rpmfiObject * s)
144 return Py_BuildValue("s", xstrdup(rpmfiFGroup(s->fi)));
148 rpmfi_FColor(rpmfiObject * s)
150 return Py_BuildValue("i", rpmfiFColor(s->fi));
154 rpmfi_FClass(rpmfiObject * s)
158 if ((FClass = rpmfiFClass(s->fi)) == NULL)
160 return Py_BuildValue("s", xstrdup(FClass));
163 #if Py_TPFLAGS_HAVE_ITER
165 rpmfi_iter(rpmfiObject * s)
168 return (PyObject *)s;
173 rpmfi_iternext(rpmfiObject * s)
175 PyObject * result = NULL;
177 /* Reset loop indices on 1st entry. */
179 s->fi = rpmfiInit(s->fi, 0);
183 /* If more to do, return the file tuple. */
184 if (rpmfiNext(s->fi) >= 0) {
185 const char * FN = rpmfiFN(s->fi);
186 int FSize = rpmfiFSize(s->fi);
187 int FMode = rpmfiFMode(s->fi);
188 int FMtime = rpmfiFMtime(s->fi);
189 int FFlags = rpmfiFFlags(s->fi);
190 int FRdev = rpmfiFRdev(s->fi);
191 int FInode = rpmfiFInode(s->fi);
192 int FNlink = rpmfiFNlink(s->fi);
193 int FState = rpmfiFState(s->fi);
194 int VFlags = rpmfiVFlags(s->fi);
195 const char * FUser = rpmfiFUser(s->fi);
196 const char * FGroup = rpmfiFGroup(s->fi);
197 const unsigned char * MD5 = rpmfiMD5(s->fi), *s = MD5;
198 char FMD5[2*16+1], *t = FMD5;
199 static const char hex[] = "0123456789abcdef";
204 for (i = 0; i < 16; i++) {
206 *t++ = hex[ (*s >> 4) & 0xf ];
207 *t++ = hex[ (*s++ ) & 0xf ];
211 result = PyTuple_New(13);
214 PyTuple_SET_ITEM(result, 0, Py_None);
216 PyTuple_SET_ITEM(result, 0, Py_BuildValue("s", FN));
217 PyTuple_SET_ITEM(result, 1, PyInt_FromLong(FSize));
218 PyTuple_SET_ITEM(result, 2, PyInt_FromLong(FMode));
219 PyTuple_SET_ITEM(result, 3, PyInt_FromLong(FMtime));
220 PyTuple_SET_ITEM(result, 4, PyInt_FromLong(FFlags));
221 PyTuple_SET_ITEM(result, 5, PyInt_FromLong(FRdev));
222 PyTuple_SET_ITEM(result, 6, PyInt_FromLong(FInode));
223 PyTuple_SET_ITEM(result, 7, PyInt_FromLong(FNlink));
224 PyTuple_SET_ITEM(result, 8, PyInt_FromLong(FState));
225 PyTuple_SET_ITEM(result, 9, PyInt_FromLong(VFlags));
228 PyTuple_SET_ITEM(result, 10, Py_None);
230 PyTuple_SET_ITEM(result, 10, Py_BuildValue("s", FUser));
231 if (FGroup == NULL) {
233 PyTuple_SET_ITEM(result, 11, Py_None);
235 PyTuple_SET_ITEM(result, 11, Py_BuildValue("s", FGroup));
238 PyTuple_SET_ITEM(result, 12, Py_None);
240 PyTuple_SET_ITEM(result, 12, Py_BuildValue("s", FMD5));
249 rpmfi_Next(rpmfiObject * s)
251 PyObject * result = NULL;
253 result = rpmfi_iternext(s);
255 if (result == NULL) {
265 rpmfi_NextD(rpmfiObject * s)
272 rpmfi_InitD(rpmfiObject * s)
279 static struct PyMethodDef rpmfi_methods[] = {
280 {"Debug", (PyCFunction)rpmfi_Debug, METH_VARARGS|METH_KEYWORDS,
282 {"FC", (PyCFunction)rpmfi_FC, METH_NOARGS,
284 {"FX", (PyCFunction)rpmfi_FX, METH_NOARGS,
286 {"DC", (PyCFunction)rpmfi_DC, METH_NOARGS,
288 {"DX", (PyCFunction)rpmfi_DX, METH_NOARGS,
290 {"BN", (PyCFunction)rpmfi_BN, METH_NOARGS,
292 {"DN", (PyCFunction)rpmfi_DN, METH_NOARGS,
294 {"FN", (PyCFunction)rpmfi_FN, METH_NOARGS,
296 {"FFlags", (PyCFunction)rpmfi_FFlags, METH_NOARGS,
298 {"VFlags", (PyCFunction)rpmfi_VFlags, METH_NOARGS,
300 {"FMode", (PyCFunction)rpmfi_FMode, METH_NOARGS,
302 {"FState", (PyCFunction)rpmfi_FState, METH_NOARGS,
304 {"MD5", (PyCFunction)rpmfi_MD5, METH_NOARGS,
306 {"FLink", (PyCFunction)rpmfi_FLink, METH_NOARGS,
308 {"FSize", (PyCFunction)rpmfi_FSize, METH_NOARGS,
310 {"FRdev", (PyCFunction)rpmfi_FRdev, METH_NOARGS,
312 {"FMtime", (PyCFunction)rpmfi_FMtime, METH_NOARGS,
314 {"FUser", (PyCFunction)rpmfi_FUser, METH_NOARGS,
316 {"FGroup", (PyCFunction)rpmfi_FGroup, METH_NOARGS,
318 {"FColor", (PyCFunction)rpmfi_FColor, METH_NOARGS,
320 {"FClass", (PyCFunction)rpmfi_FClass, METH_NOARGS,
322 {"next", (PyCFunction)rpmfi_Next, METH_NOARGS,
323 "fi.next() -> (FN, FSize, FMode, FMtime, FFlags, FRdev, FInode, FNlink, FState, VFlags, FUser, FGroup, FMD5))\n\
324 - Retrieve next file info tuple.\n" },
326 {"NextD", (PyCFunction)rpmfi_NextD, METH_NOARGS,
328 {"InitD", (PyCFunction)rpmfi_InitD, METH_NOARGS,
331 {NULL, NULL} /* sentinel */
337 rpmfi_dealloc(rpmfiObject * s)
340 s->fi = rpmfiFree(s->fi);
346 rpmfi_print(rpmfiObject * s, FILE * fp, int flags)
351 s->fi = rpmfiInit(s->fi, 0);
352 while (rpmfiNext(s->fi) >= 0)
353 fprintf(fp, "%s\n", rpmfiFN(s->fi));
357 static PyObject * rpmfi_getattro(PyObject * o, PyObject * n)
359 return PyObject_GenericGetAttr(o, n);
362 static int rpmfi_setattro(PyObject * o, PyObject * n, PyObject * v)
364 return PyObject_GenericSetAttr(o, n, v);
368 rpmfi_length(rpmfiObject * s)
370 return rpmfiFC(s->fi);
374 rpmfi_subscript(rpmfiObject * s, PyObject * key)
378 if (!PyInt_Check(key)) {
379 PyErr_SetString(PyExc_TypeError, "integer expected");
383 ix = (int) PyInt_AsLong(key);
384 rpmfiSetFX(s->fi, ix);
385 return Py_BuildValue("s", xstrdup(rpmfiFN(s->fi)));
388 static PyMappingMethods rpmfi_as_mapping = {
389 (lenfunc) rpmfi_length, /* mp_length */
390 (binaryfunc) rpmfi_subscript, /* mp_subscript */
391 (objobjargproc)0, /* mp_ass_subscript */
396 static int rpmfi_init(rpmfiObject * s, PyObject *args, PyObject *kwds)
398 hdrObject * ho = NULL;
399 PyObject * to = NULL;
400 rpmts ts = NULL; /* XXX FIXME: fiFromHeader should be a ts method. */
401 rpm_tag_t tagN = RPMTAG_BASENAMES;
403 char * kwlist[] = {"header", "tag", "flags", NULL};
405 if (_rpmfi_debug < 0)
406 fprintf(stderr, "*** rpmfi_init(%p,%p,%p)\n", s, args, kwds);
408 if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oi:rpmfi_init", kwlist,
409 &hdr_Type, &ho, &to, &flags))
413 tagN = tagNumFromPyObject(to);
415 PyErr_SetString(PyExc_KeyError, "unknown header tag");
419 s->fi = rpmfiNew(ts, hdrGetHeader(ho), tagN, flags);
427 static void rpmfi_free(rpmfiObject * s)
430 fprintf(stderr, "%p -- fi %p\n", s, s->fi);
431 s->fi = rpmfiFree(s->fi);
433 PyObject_Del((PyObject *)s);
438 static PyObject * rpmfi_alloc(PyTypeObject * subtype, int nitems)
440 PyObject * s = PyType_GenericAlloc(subtype, nitems);
442 if (_rpmfi_debug < 0)
443 fprintf(stderr, "*** rpmfi_alloc(%p,%d) ret %p\n", subtype, nitems, s);
449 static PyObject * rpmfi_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
451 rpmfiObject * s = (void *) PyObject_New(rpmfiObject, subtype);
453 /* Perform additional initialization. */
454 if (rpmfi_init(s, args, kwds) < 0) {
460 fprintf(stderr, "%p ++ fi %p\n", s, s->fi);
462 return (PyObject *)s;
467 static char rpmfi_doc[] =
470 PyTypeObject rpmfi_Type = {
471 PyObject_HEAD_INIT(&PyType_Type)
473 "rpm.fi", /* tp_name */
474 sizeof(rpmfiObject), /* tp_basicsize */
477 (destructor) rpmfi_dealloc, /* tp_dealloc */
478 (printfunc) rpmfi_print, /* tp_print */
479 (getattrfunc)0, /* tp_getattr */
480 (setattrfunc)0, /* tp_setattr */
481 (cmpfunc)0, /* tp_compare */
482 (reprfunc)0, /* tp_repr */
483 0, /* tp_as_number */
484 0, /* tp_as_sequence */
485 &rpmfi_as_mapping, /* tp_as_mapping */
486 (hashfunc)0, /* tp_hash */
487 (ternaryfunc)0, /* tp_call */
488 (reprfunc)0, /* tp_str */
489 (getattrofunc) rpmfi_getattro, /* tp_getattro */
490 (setattrofunc) rpmfi_setattro, /* tp_setattro */
491 0, /* tp_as_buffer */
492 Py_TPFLAGS_DEFAULT, /* tp_flags */
493 rpmfi_doc, /* tp_doc */
494 #if Py_TPFLAGS_HAVE_ITER
497 0, /* tp_richcompare */
498 0, /* tp_weaklistoffset */
499 (getiterfunc) rpmfi_iter, /* tp_iter */
500 (iternextfunc) rpmfi_iternext, /* tp_iternext */
501 rpmfi_methods, /* tp_methods */
506 0, /* tp_descr_get */
507 0, /* tp_descr_set */
508 0, /* tp_dictoffset */
509 (initproc) rpmfi_init, /* tp_init */
510 (allocfunc) rpmfi_alloc, /* tp_alloc */
511 (newfunc) rpmfi_new, /* tp_new */
512 (freefunc) rpmfi_free, /* tp_free */
519 rpmfi fiFromFi(rpmfiObject * s)
527 rpmfiObject *s = PyObject_New(rpmfiObject, &rpmfi_Type);
537 hdr_fiFromHeader(PyObject * s, PyObject * args, PyObject * kwds)
539 hdrObject * ho = (hdrObject *)s;
540 PyObject * to = NULL;
541 rpmts ts = NULL; /* XXX FIXME: fiFromHeader should be a ts method. */
542 rpm_tag_t tagN = RPMTAG_BASENAMES;
544 char * kwlist[] = {"tag", "flags", NULL};
546 if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:fiFromHeader", kwlist,
551 tagN = tagNumFromPyObject(to);
553 PyErr_SetString(PyExc_KeyError, "unknown header tag");
557 return rpmfi_Wrap( rpmfiNew(ts, hdrGetHeader(ho), tagN, flags) );