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