python/rpmfi-py.c

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