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