Modify eu-strip option to perform strip in post script of rpm package & add option...
[platform/upstream/rpm.git] / python / rpmfi-py.c
1 #include "rpmsystem-py.h"
2
3 #include <rpm/rpmtypes.h>
4 #include <rpm/rpmpgp.h>
5
6 #include "header-py.h"
7 #include "rpmfi-py.h"
8
9 struct rpmfiObject_s {
10     PyObject_HEAD
11     PyObject *md_dict;          /*!< to look like PyModuleObject */
12     int active;
13     rpmfi fi;
14 };
15
16 static PyObject *
17 rpmfi_FC(rpmfiObject * s, PyObject * unused)
18 {
19     return Py_BuildValue("i", rpmfiFC(s->fi));
20 }
21
22 static PyObject *
23 rpmfi_FX(rpmfiObject * s, PyObject * unused)
24 {
25     return Py_BuildValue("i", rpmfiFX(s->fi));
26 }
27
28 static PyObject *
29 rpmfi_DC(rpmfiObject * s, PyObject * unused)
30 {
31     return Py_BuildValue("i", rpmfiDC(s->fi));
32 }
33
34 static PyObject *
35 rpmfi_DX(rpmfiObject * s, PyObject * unused)
36 {
37     return Py_BuildValue("i", rpmfiDX(s->fi));
38 }
39
40 static PyObject *
41 rpmfi_BN(rpmfiObject * s, PyObject * unused)
42 {
43     return Py_BuildValue("s", rpmfiBN(s->fi));
44 }
45
46 static PyObject *
47 rpmfi_DN(rpmfiObject * s, PyObject * unused)
48 {
49     return Py_BuildValue("s", rpmfiDN(s->fi));
50 }
51
52 static PyObject *
53 rpmfi_FN(rpmfiObject * s, PyObject * unused)
54 {
55     return Py_BuildValue("s", rpmfiFN(s->fi));
56 }
57
58 static PyObject *
59 rpmfi_FFlags(rpmfiObject * s, PyObject * unused)
60 {
61     return Py_BuildValue("i", rpmfiFFlags(s->fi));
62 }
63
64 static PyObject *
65 rpmfi_VFlags(rpmfiObject * s, PyObject * unused)
66 {
67     return Py_BuildValue("i", rpmfiVFlags(s->fi));
68 }
69
70 static PyObject *
71 rpmfi_FMode(rpmfiObject * s, PyObject * unused)
72 {
73     return Py_BuildValue("i", rpmfiFMode(s->fi));
74 }
75
76 static PyObject *
77 rpmfi_FState(rpmfiObject * s, PyObject * unused)
78 {
79     return Py_BuildValue("i", rpmfiFState(s->fi));
80 }
81
82 /* XXX rpmfiFDigest */
83 static PyObject *
84 rpmfi_Digest(rpmfiObject * s, PyObject * unused)
85 {
86     char *digest = rpmfiFDigestHex(s->fi, NULL);
87     if (digest) {
88         PyObject *dig = Py_BuildValue("s", digest);
89         free(digest);
90         return dig;
91     } else {
92         Py_RETURN_NONE;
93     }
94 }
95
96 static PyObject *
97 rpmfi_FLink(rpmfiObject * s, PyObject * unused)
98 {
99     return Py_BuildValue("s", rpmfiFLink(s->fi));
100 }
101
102 static PyObject *
103 rpmfi_FSize(rpmfiObject * s, PyObject * unused)
104 {
105     return Py_BuildValue("L", rpmfiFSize(s->fi));
106 }
107
108 static PyObject *
109 rpmfi_FRdev(rpmfiObject * s, PyObject * unused)
110 {
111     return Py_BuildValue("i", rpmfiFRdev(s->fi));
112 }
113
114 static PyObject *
115 rpmfi_FMtime(rpmfiObject * s, PyObject * unused)
116 {
117     return Py_BuildValue("i", rpmfiFMtime(s->fi));
118 }
119
120 static PyObject *
121 rpmfi_FUser(rpmfiObject * s, PyObject * unused)
122 {
123     return Py_BuildValue("s", rpmfiFUser(s->fi));
124 }
125
126 static PyObject *
127 rpmfi_FGroup(rpmfiObject * s, PyObject * unused)
128 {
129     return Py_BuildValue("s", rpmfiFGroup(s->fi));
130 }
131
132 static PyObject *
133 rpmfi_FColor(rpmfiObject * s, PyObject * unused)
134 {
135     return Py_BuildValue("i", rpmfiFColor(s->fi));
136 }
137
138 static PyObject *
139 rpmfi_FClass(rpmfiObject * s, PyObject * unused)
140 {
141     const char * FClass;
142
143     if ((FClass = rpmfiFClass(s->fi)) == NULL)
144         FClass = "";
145     return Py_BuildValue("s", FClass);
146 }
147
148 static PyObject *
149 rpmfi_iternext(rpmfiObject * s)
150 {
151     PyObject * result = NULL;
152
153     /* Reset loop indices on 1st entry. */
154     if (!s->active) {
155         s->fi = rpmfiInit(s->fi, 0);
156         s->active = 1;
157     }
158
159     /* If more to do, return the file tuple. */
160     if (rpmfiNext(s->fi) >= 0) {
161         const char * FN = rpmfiFN(s->fi);
162         rpm_loff_t FSize = rpmfiFSize(s->fi);
163         int FMode = rpmfiFMode(s->fi);
164         int FMtime = rpmfiFMtime(s->fi);
165         int FFlags = rpmfiFFlags(s->fi);
166         int FRdev = rpmfiFRdev(s->fi);
167         int FInode = rpmfiFInode(s->fi);
168         int FNlink = rpmfiFNlink(s->fi);
169         int FState = rpmfiFState(s->fi);
170         int VFlags = rpmfiVFlags(s->fi);
171         const char * FUser = rpmfiFUser(s->fi);
172         const char * FGroup = rpmfiFGroup(s->fi);
173
174         result = PyTuple_New(13);
175         if (FN == NULL) {
176             Py_INCREF(Py_None);
177             PyTuple_SET_ITEM(result, 0, Py_None);
178         } else
179             PyTuple_SET_ITEM(result,  0, Py_BuildValue("s", FN));
180         PyTuple_SET_ITEM(result,  1, PyLong_FromLongLong(FSize));
181         PyTuple_SET_ITEM(result,  2, PyInt_FromLong(FMode));
182         PyTuple_SET_ITEM(result,  3, PyInt_FromLong(FMtime));
183         PyTuple_SET_ITEM(result,  4, PyInt_FromLong(FFlags));
184         PyTuple_SET_ITEM(result,  5, PyInt_FromLong(FRdev));
185         PyTuple_SET_ITEM(result,  6, PyInt_FromLong(FInode));
186         PyTuple_SET_ITEM(result,  7, PyInt_FromLong(FNlink));
187         PyTuple_SET_ITEM(result,  8, PyInt_FromLong(FState));
188         PyTuple_SET_ITEM(result,  9, PyInt_FromLong(VFlags));
189         if (FUser == NULL) {
190             Py_INCREF(Py_None);
191             PyTuple_SET_ITEM(result, 10, Py_None);
192         } else
193             PyTuple_SET_ITEM(result, 10, Py_BuildValue("s", FUser));
194         if (FGroup == NULL) {
195             Py_INCREF(Py_None);
196             PyTuple_SET_ITEM(result, 11, Py_None);
197         } else
198             PyTuple_SET_ITEM(result, 11, Py_BuildValue("s", FGroup));
199         PyTuple_SET_ITEM(result, 12, rpmfi_Digest(s, NULL));
200
201     } else
202         s->active = 0;
203
204     return result;
205 }
206
207 static struct PyMethodDef rpmfi_methods[] = {
208  {"FC",         (PyCFunction)rpmfi_FC,          METH_NOARGS,
209         NULL},
210  {"FX",         (PyCFunction)rpmfi_FX,          METH_NOARGS,
211         NULL},
212  {"DC",         (PyCFunction)rpmfi_DC,          METH_NOARGS,
213         NULL},
214  {"DX",         (PyCFunction)rpmfi_DX,          METH_NOARGS,
215         NULL},
216  {"BN",         (PyCFunction)rpmfi_BN,          METH_NOARGS,
217         NULL},
218  {"DN",         (PyCFunction)rpmfi_DN,          METH_NOARGS,
219         NULL},
220  {"FN",         (PyCFunction)rpmfi_FN,          METH_NOARGS,
221         NULL},
222  {"FFlags",     (PyCFunction)rpmfi_FFlags,      METH_NOARGS,
223         NULL},
224  {"VFlags",     (PyCFunction)rpmfi_VFlags,      METH_NOARGS,
225         NULL},
226  {"FMode",      (PyCFunction)rpmfi_FMode,       METH_NOARGS,
227         NULL},
228  {"FState",     (PyCFunction)rpmfi_FState,      METH_NOARGS,
229         NULL},
230  {"MD5",        (PyCFunction)rpmfi_Digest,      METH_NOARGS,
231         NULL},
232  {"Digest",     (PyCFunction)rpmfi_Digest,      METH_NOARGS,
233         NULL},
234  {"FLink",      (PyCFunction)rpmfi_FLink,       METH_NOARGS,
235         NULL},
236  {"FSize",      (PyCFunction)rpmfi_FSize,       METH_NOARGS,
237         NULL},
238  {"FRdev",      (PyCFunction)rpmfi_FRdev,       METH_NOARGS,
239         NULL},
240  {"FMtime",     (PyCFunction)rpmfi_FMtime,      METH_NOARGS,
241         NULL},
242  {"FUser",      (PyCFunction)rpmfi_FUser,       METH_NOARGS,
243         NULL},
244  {"FGroup",     (PyCFunction)rpmfi_FGroup,      METH_NOARGS,
245         NULL},
246  {"FColor",     (PyCFunction)rpmfi_FColor,      METH_NOARGS,
247         NULL},
248  {"FClass",     (PyCFunction)rpmfi_FClass,      METH_NOARGS,
249         NULL},
250  {NULL,         NULL}           /* sentinel */
251 };
252
253 /* ---------- */
254
255 static void
256 rpmfi_dealloc(rpmfiObject * s)
257 {
258     s->fi = rpmfiFree(s->fi);
259     Py_TYPE(s)->tp_free((PyObject *)s);
260 }
261
262 static int
263 rpmfi_length(rpmfiObject * s)
264 {
265     return rpmfiFC(s->fi);
266 }
267
268 static PyObject *
269 rpmfi_subscript(rpmfiObject * s, PyObject * key)
270 {
271     int ix;
272
273     if (!PyInt_Check(key)) {
274         PyErr_SetString(PyExc_TypeError, "integer expected");
275         return NULL;
276     }
277
278     ix = (int) PyInt_AsLong(key);
279     rpmfiSetFX(s->fi, ix);
280     return Py_BuildValue("s", rpmfiFN(s->fi));
281 }
282
283 static PyMappingMethods rpmfi_as_mapping = {
284         (lenfunc) rpmfi_length,         /* mp_length */
285         (binaryfunc) rpmfi_subscript,   /* mp_subscript */
286         (objobjargproc)0,               /* mp_ass_subscript */
287 };
288
289 static int rpmfi_init(rpmfiObject * s, PyObject *args, PyObject *kwds)
290 {
291     s->active = 0;
292     return 0;
293 }
294
295 static PyObject * rpmfi_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
296 {
297     PyObject * to = NULL;
298     Header h = NULL;
299     rpmfi fi = NULL;
300     rpmTagVal tagN = RPMTAG_BASENAMES;
301     int flags = 0;
302     char * kwlist[] = {"header", "tag", "flags", NULL};
303
304     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O&|Oi:rpmfi_init", kwlist,
305                                 hdrFromPyObject, &h, &to, &flags))
306         return NULL;
307
308     fi = rpmfiNew(NULL, h, tagN, flags);
309
310     if (fi == NULL) {
311         PyErr_SetString(PyExc_ValueError, "invalid file data in header");
312         return NULL;
313     }
314
315     return rpmfi_Wrap(subtype, fi);
316 }
317
318 static char rpmfi_doc[] =
319 "";
320
321 PyTypeObject rpmfi_Type = {
322         PyVarObject_HEAD_INIT(&PyType_Type, 0)
323         "rpm.fi",                       /* tp_name */
324         sizeof(rpmfiObject),            /* tp_basicsize */
325         0,                              /* tp_itemsize */
326         /* methods */
327         (destructor) rpmfi_dealloc,     /* tp_dealloc */
328         0,                              /* tp_print */
329         (getattrfunc)0,                 /* tp_getattr */
330         (setattrfunc)0,                 /* tp_setattr */
331         0,                              /* tp_compare */
332         (reprfunc)0,                    /* tp_repr */
333         0,                              /* tp_as_number */
334         0,                              /* tp_as_sequence */
335         &rpmfi_as_mapping,              /* tp_as_mapping */
336         (hashfunc)0,                    /* tp_hash */
337         (ternaryfunc)0,                 /* tp_call */
338         (reprfunc)0,                    /* tp_str */
339         PyObject_GenericGetAttr,        /* tp_getattro */
340         PyObject_GenericSetAttr,        /* tp_setattro */
341         0,                              /* tp_as_buffer */
342         Py_TPFLAGS_DEFAULT|Py_TPFLAGS_BASETYPE, /* tp_flags */
343         rpmfi_doc,                      /* tp_doc */
344         0,                              /* tp_traverse */
345         0,                              /* tp_clear */
346         0,                              /* tp_richcompare */
347         0,                              /* tp_weaklistoffset */
348         PyObject_SelfIter,              /* tp_iter */
349         (iternextfunc) rpmfi_iternext,  /* tp_iternext */
350         rpmfi_methods,                  /* tp_methods */
351         0,                              /* tp_members */
352         0,                              /* tp_getset */
353         0,                              /* tp_base */
354         0,                              /* tp_dict */
355         0,                              /* tp_descr_get */
356         0,                              /* tp_descr_set */
357         0,                              /* tp_dictoffset */
358         (initproc) rpmfi_init,          /* tp_init */
359         0,                              /* tp_alloc */
360         (newfunc) rpmfi_new,            /* tp_new */
361         0,                              /* tp_free */
362         0,                              /* tp_is_gc */
363 };
364
365 /* ---------- */
366
367 rpmfi fiFromFi(rpmfiObject * s)
368 {
369     return s->fi;
370 }
371
372 PyObject * rpmfi_Wrap(PyTypeObject *subtype, rpmfi fi)
373 {
374     rpmfiObject *s = (rpmfiObject *)subtype->tp_alloc(subtype, 0);
375     if (s == NULL) return NULL;
376
377     s->fi = fi;
378     s->active = 0;
379     return (PyObject *) s;
380 }
381