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_iter(rpmfiObject * s)
 167 {
 168     Py_INCREF(s);
 169     return (PyObject *)s;
 170 }
 171
 172 static PyObject *
 173 rpmfi_iternext(rpmfiObject * s)
 174 {
 175     PyObject * result = NULL;
 176
 177     /* Reset loop indices on 1st entry. */
 178     if (!s->active) {
 179         s->fi = rpmfiInit(s->fi, 0);
 180         s->active = 1;
 181     }
 182
 183     /* If more to do, return the file tuple. */
 184     if (rpmfiNext(s->fi) >= 0) {
 185         const char * FN = rpmfiFN(s->fi);
 186         rpm_loff_t FSize = rpmfiFSize(s->fi);
 187         int FMode = rpmfiFMode(s->fi);
 188         int FMtime = rpmfiFMtime(s->fi);
 189         int FFlags = rpmfiFFlags(s->fi);
 190         int FRdev = rpmfiFRdev(s->fi);
 191         int FInode = rpmfiFInode(s->fi);
 192         int FNlink = rpmfiFNlink(s->fi);
 193         int FState = rpmfiFState(s->fi);
 194         int VFlags = rpmfiVFlags(s->fi);
 195         const char * FUser = rpmfiFUser(s->fi);
 196         const char * FGroup = rpmfiFGroup(s->fi);
 197
 198         result = PyTuple_New(13);
 199         if (FN == NULL) {
 200             Py_INCREF(Py_None);
 201             PyTuple_SET_ITEM(result, 0, Py_None);
 202         } else
 203             PyTuple_SET_ITEM(result,  0, Py_BuildValue("s", FN));
 204         PyTuple_SET_ITEM(result,  1, PyLong_FromLongLong(FSize));
 205         PyTuple_SET_ITEM(result,  2, PyInt_FromLong(FMode));
 206         PyTuple_SET_ITEM(result,  3, PyInt_FromLong(FMtime));
 207         PyTuple_SET_ITEM(result,  4, PyInt_FromLong(FFlags));
 208         PyTuple_SET_ITEM(result,  5, PyInt_FromLong(FRdev));
 209         PyTuple_SET_ITEM(result,  6, PyInt_FromLong(FInode));
 210         PyTuple_SET_ITEM(result,  7, PyInt_FromLong(FNlink));
 211         PyTuple_SET_ITEM(result,  8, PyInt_FromLong(FState));
 212         PyTuple_SET_ITEM(result,  9, PyInt_FromLong(VFlags));
 213         if (FUser == NULL) {
 214             Py_INCREF(Py_None);
 215             PyTuple_SET_ITEM(result, 10, Py_None);
 216         } else
 217             PyTuple_SET_ITEM(result, 10, Py_BuildValue("s", FUser));
 218         if (FGroup == NULL) {
 219             Py_INCREF(Py_None);
 220             PyTuple_SET_ITEM(result, 11, Py_None);
 221         } else
 222             PyTuple_SET_ITEM(result, 11, Py_BuildValue("s", FGroup));
 223         PyTuple_SET_ITEM(result, 12, rpmfi_Digest(s));
 224
 225     } else
 226         s->active = 0;
 227
 228     return result;
 229 }
 230
 231 static PyObject *
 232 rpmfi_Next(rpmfiObject * s)
 233 {
 234     PyObject * result = NULL;
 235
 236     result = rpmfi_iternext(s);
 237
 238     if (result == NULL) {
 239         Py_RETURN_NONE;
 240     }
 241
 242     return result;
 243 }
 244
 245 #ifdef  NOTYET
 246 static PyObject *
 247 rpmfi_NextD(rpmfiObject * s)
 248 {
 249     Py_RETURN_NONE;
 250 }
 251
 252 static PyObject *
 253 rpmfi_InitD(rpmfiObject * s)
 254 {
 255     Py_RETURN_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 int
 340 rpmfi_length(rpmfiObject * s)
 341 {
 342     return rpmfiFC(s->fi);
 343 }
 344
 345 static PyObject *
 346 rpmfi_subscript(rpmfiObject * s, PyObject * key)
 347 {
 348     int ix;
 349
 350     if (!PyInt_Check(key)) {
 351         PyErr_SetString(PyExc_TypeError, "integer expected");
 352         return NULL;
 353     }
 354
 355     ix = (int) PyInt_AsLong(key);
 356     rpmfiSetFX(s->fi, ix);
 357     return Py_BuildValue("s", xstrdup(rpmfiFN(s->fi)));
 358 }
 359
 360 static PyMappingMethods rpmfi_as_mapping = {
 361         (lenfunc) rpmfi_length,         /* mp_length */
 362         (binaryfunc) rpmfi_subscript,   /* mp_subscript */
 363         (objobjargproc)0,               /* mp_ass_subscript */
 364 };
 365
 366 /** \ingroup py_c
 367  */
 368 static int rpmfi_init(rpmfiObject * s, PyObject *args, PyObject *kwds)
 369 {
 370     s->active = 0;
 371     return 0;
 372 }
 373
 374 /** \ingroup py_c
 375  */
 376 static void rpmfi_free(rpmfiObject * s)
 377 {
 378 if (_rpmfi_debug)
 379 fprintf(stderr, "%p -- fi %p\n", s, s->fi);
 380     s->fi = rpmfiFree(s->fi);
 381
 382     PyObject_Del((PyObject *)s);
 383 }
 384
 385 /** \ingroup py_c
 386  */
 387 static PyObject * rpmfi_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
 388 {
 389     rpmfiObject * s = (void *) PyObject_New(rpmfiObject, subtype);
 390
 391     hdrObject * ho = NULL;
 392     PyObject * to = NULL;
 393     rpmTag tagN = RPMTAG_BASENAMES;
 394     int flags = 0;
 395     char * kwlist[] = {"header", "tag", "flags", NULL};
 396
 397     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oi:rpmfi_init", kwlist,
 398             &hdr_Type, &ho, &to, &flags))
 399         return NULL;
 400
 401     if (to != NULL) {
 402         tagN = tagNumFromPyObject(to);
 403         if (tagN == RPMTAG_NOT_FOUND) return NULL;
 404     }
 405     s->fi = rpmfiNew(NULL, hdrGetHeader(ho), tagN, flags);
 406
 407     return (PyObject *)s;
 408 }
 409
 410 /**
 411  */
 412 static char rpmfi_doc[] =
 413 "";
 414
 415 PyTypeObject rpmfi_Type = {
 416         PyObject_HEAD_INIT(&PyType_Type)
 417         0,                              /* ob_size */
 418         "rpm.fi",                       /* tp_name */
 419         sizeof(rpmfiObject),            /* tp_basicsize */
 420         0,                              /* tp_itemsize */
 421         /* methods */
 422         (destructor) rpmfi_dealloc,     /* tp_dealloc */
 423         (printfunc) rpmfi_print,        /* tp_print */
 424         (getattrfunc)0,                 /* tp_getattr */
 425         (setattrfunc)0,                 /* tp_setattr */
 426         (cmpfunc)0,                     /* tp_compare */
 427         (reprfunc)0,                    /* tp_repr */
 428         0,                              /* tp_as_number */
 429         0,                              /* tp_as_sequence */
 430         &rpmfi_as_mapping,              /* tp_as_mapping */
 431         (hashfunc)0,                    /* tp_hash */
 432         (ternaryfunc)0,                 /* tp_call */
 433         (reprfunc)0,                    /* tp_str */
 434         PyObject_GenericGetAttr,        /* tp_getattro */
 435         PyObject_GenericSetAttr,        /* tp_setattro */
 436         0,                              /* tp_as_buffer */
 437         Py_TPFLAGS_DEFAULT,             /* tp_flags */
 438         rpmfi_doc,                      /* tp_doc */
 439         0,                              /* tp_traverse */
 440         0,                              /* tp_clear */
 441         0,                              /* tp_richcompare */
 442         0,                              /* tp_weaklistoffset */
 443         (getiterfunc) rpmfi_iter,       /* tp_iter */
 444         (iternextfunc) rpmfi_iternext,  /* tp_iternext */
 445         rpmfi_methods,                  /* tp_methods */
 446         0,                              /* tp_members */
 447         0,                              /* tp_getset */
 448         0,                              /* tp_base */
 449         0,                              /* tp_dict */
 450         0,                              /* tp_descr_get */
 451         0,                              /* tp_descr_set */
 452         0,                              /* tp_dictoffset */
 453         (initproc) rpmfi_init,          /* tp_init */
 454         0,                              /* tp_alloc */
 455         (newfunc) rpmfi_new,            /* tp_new */
 456         (freefunc) rpmfi_free,          /* tp_free */
 457         0,                              /* tp_is_gc */
 458 };
 459
 460 /* ---------- */
 461
 462 rpmfi fiFromFi(rpmfiObject * s)
 463 {
 464     return s->fi;
 465 }
 466
 467 rpmfiObject *
 468 rpmfi_Wrap(rpmfi fi)
 469 {
 470     rpmfiObject *s = PyObject_New(rpmfiObject, &rpmfi_Type);
 471
 472     if (s == NULL)
 473         return NULL;
 474     s->fi = fi;
 475     s->active = 0;
 476     return s;
 477 }
 478
 479 rpmfiObject *
 480 hdr_fiFromHeader(PyObject * s, PyObject * args, PyObject * kwds)
 481 {
 482     hdrObject * ho = (hdrObject *)s;
 483     PyObject * to = NULL;
 484     rpmts ts = NULL;    /* XXX FIXME: fiFromHeader should be a ts method. */
 485     rpmTag tagN = RPMTAG_BASENAMES;
 486     int flags = 0;
 487     char * kwlist[] = {"tag", "flags", NULL};
 488
 489     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|Oi:fiFromHeader", kwlist,
 490             &to, &flags))
 491         return NULL;
 492
 493     if (to != NULL) {
 494         tagN = tagNumFromPyObject(to);
 495         if (tagN == RPMTAG_NOT_FOUND) return NULL;
 496     }
 497     return rpmfi_Wrap( rpmfiNew(ts, hdrGetHeader(ho), tagN, flags) );
 498 }