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