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