python/rpmfi-py.c

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