python/rpmfi-py.c

   1 #include "rpmsystem-py.h"
   2
   3 #include <rpm/rpmtypes.h>
   4 #include <rpm/rpmpgp.h>
   5
   6 #include "header-py.h"
   7 #include "rpmfi-py.h"
   8
   9 #include "debug.h"
  10
  11 struct rpmfiObject_s {
  12     PyObject_HEAD
  13     PyObject *md_dict;          /*!< to look like PyModuleObject */
  14     int active;
  15     rpmfi fi;
  16 };
  17
  18 static PyObject *
  19 rpmfi_Debug(rpmfiObject * s, PyObject * args, PyObject * kwds)
  20 {
  21     char * kwlist[] = {"debugLevel", NULL};
  22
  23     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmfi_debug))
  24         return NULL;
  25
  26     Py_RETURN_NONE;
  27 }
  28
  29 static PyObject *
  30 rpmfi_FC(rpmfiObject * s)
  31 {
  32     return Py_BuildValue("i", rpmfiFC(s->fi));
  33 }
  34
  35 static PyObject *
  36 rpmfi_FX(rpmfiObject * s)
  37 {
  38     return Py_BuildValue("i", rpmfiFX(s->fi));
  39 }
  40
  41 static PyObject *
  42 rpmfi_DC(rpmfiObject * s)
  43 {
  44     return Py_BuildValue("i", rpmfiDC(s->fi));
  45 }
  46
  47 static PyObject *
  48 rpmfi_DX(rpmfiObject * s)
  49 {
  50     return Py_BuildValue("i", rpmfiDX(s->fi));
  51 }
  52
  53 static PyObject *
  54 rpmfi_BN(rpmfiObject * s)
  55 {
  56     return Py_BuildValue("s", xstrdup(rpmfiBN(s->fi)));
  57 }
  58
  59 static PyObject *
  60 rpmfi_DN(rpmfiObject * s)
  61 {
  62     return Py_BuildValue("s", xstrdup(rpmfiDN(s->fi)));
  63 }
  64
  65 static PyObject *
  66 rpmfi_FN(rpmfiObject * s)
  67 {
  68     return Py_BuildValue("s", xstrdup(rpmfiFN(s->fi)));
  69 }
  70
  71 static PyObject *
  72 rpmfi_FFlags(rpmfiObject * s)
  73 {
  74     return Py_BuildValue("i", rpmfiFFlags(s->fi));
  75 }
  76
  77 static PyObject *
  78 rpmfi_VFlags(rpmfiObject * s)
  79 {
  80     return Py_BuildValue("i", rpmfiVFlags(s->fi));
  81 }
  82
  83 static PyObject *
  84 rpmfi_FMode(rpmfiObject * s)
  85 {
  86     return Py_BuildValue("i", rpmfiFMode(s->fi));
  87 }
  88
  89 static PyObject *
  90 rpmfi_FState(rpmfiObject * s)
  91 {
  92     return Py_BuildValue("i", rpmfiFState(s->fi));
  93 }
  94
  95 /* XXX rpmfiFDigest */
  96 static PyObject *
  97 rpmfi_Digest(rpmfiObject * s)
  98 {
  99     char *digest = rpmfiFDigestHex(s->fi, NULL);
 100     if (digest) {
 101         PyObject *dig = Py_BuildValue("s", digest);
 102         free(digest);
 103         return dig;
 104     } else {
 105         Py_RETURN_NONE;
 106     }
 107 }
 108
 109 static PyObject *
 110 rpmfi_FLink(rpmfiObject * s)
 111 {
 112     return Py_BuildValue("s", xstrdup(rpmfiFLink(s->fi)));
 113 }
 114
 115 static PyObject *
 116 rpmfi_FSize(rpmfiObject * s)
 117 {
 118     return Py_BuildValue("L", rpmfiFSize(s->fi));
 119 }
 120
 121 static PyObject *
 122 rpmfi_FRdev(rpmfiObject * s)
 123 {
 124     return Py_BuildValue("i", rpmfiFRdev(s->fi));
 125 }
 126
 127 static PyObject *
 128 rpmfi_FMtime(rpmfiObject * s)
 129 {
 130     return Py_BuildValue("i", rpmfiFMtime(s->fi));
 131 }
 132
 133 static PyObject *
 134 rpmfi_FUser(rpmfiObject * s)
 135 {
 136     return Py_BuildValue("s", xstrdup(rpmfiFUser(s->fi)));
 137 }
 138
 139 static PyObject *
 140 rpmfi_FGroup(rpmfiObject * s)
 141 {
 142     return Py_BuildValue("s", xstrdup(rpmfiFGroup(s->fi)));
 143 }
 144
 145 static PyObject *
 146 rpmfi_FColor(rpmfiObject * s)
 147 {
 148     return Py_BuildValue("i", rpmfiFColor(s->fi));
 149 }
 150
 151 static PyObject *
 152 rpmfi_FClass(rpmfiObject * s)
 153 {
 154     const char * FClass;
 155
 156     if ((FClass = rpmfiFClass(s->fi)) == NULL)
 157         FClass = "";
 158     return Py_BuildValue("s", xstrdup(FClass));
 159 }
 160
 161 static PyObject *
 162 rpmfi_iternext(rpmfiObject * s)
 163 {
 164     PyObject * result = NULL;
 165
 166     /* Reset loop indices on 1st entry. */
 167     if (!s->active) {
 168         s->fi = rpmfiInit(s->fi, 0);
 169         s->active = 1;
 170     }
 171
 172     /* If more to do, return the file tuple. */
 173     if (rpmfiNext(s->fi) >= 0) {
 174         const char * FN = rpmfiFN(s->fi);
 175         rpm_loff_t FSize = rpmfiFSize(s->fi);
 176         int FMode = rpmfiFMode(s->fi);
 177         int FMtime = rpmfiFMtime(s->fi);
 178         int FFlags = rpmfiFFlags(s->fi);
 179         int FRdev = rpmfiFRdev(s->fi);
 180         int FInode = rpmfiFInode(s->fi);
 181         int FNlink = rpmfiFNlink(s->fi);
 182         int FState = rpmfiFState(s->fi);
 183         int VFlags = rpmfiVFlags(s->fi);
 184         const char * FUser = rpmfiFUser(s->fi);
 185         const char * FGroup = rpmfiFGroup(s->fi);
 186
 187         result = PyTuple_New(13);
 188         if (FN == NULL) {
 189             Py_INCREF(Py_None);
 190             PyTuple_SET_ITEM(result, 0, Py_None);
 191         } else
 192             PyTuple_SET_ITEM(result,  0, Py_BuildValue("s", FN));
 193         PyTuple_SET_ITEM(result,  1, PyLong_FromLongLong(FSize));
 194         PyTuple_SET_ITEM(result,  2, PyInt_FromLong(FMode));
 195         PyTuple_SET_ITEM(result,  3, PyInt_FromLong(FMtime));
 196         PyTuple_SET_ITEM(result,  4, PyInt_FromLong(FFlags));
 197         PyTuple_SET_ITEM(result,  5, PyInt_FromLong(FRdev));
 198         PyTuple_SET_ITEM(result,  6, PyInt_FromLong(FInode));
 199         PyTuple_SET_ITEM(result,  7, PyInt_FromLong(FNlink));
 200         PyTuple_SET_ITEM(result,  8, PyInt_FromLong(FState));
 201         PyTuple_SET_ITEM(result,  9, PyInt_FromLong(VFlags));
 202         if (FUser == NULL) {
 203             Py_INCREF(Py_None);
 204             PyTuple_SET_ITEM(result, 10, Py_None);
 205         } else
 206             PyTuple_SET_ITEM(result, 10, Py_BuildValue("s", FUser));
 207         if (FGroup == NULL) {
 208             Py_INCREF(Py_None);
 209             PyTuple_SET_ITEM(result, 11, Py_None);
 210         } else
 211             PyTuple_SET_ITEM(result, 11, Py_BuildValue("s", FGroup));
 212         PyTuple_SET_ITEM(result, 12, rpmfi_Digest(s));
 213
 214     } else
 215         s->active = 0;
 216
 217     return result;
 218 }
 219
 220 static struct PyMethodDef rpmfi_methods[] = {
 221  {"Debug",      (PyCFunction)rpmfi_Debug,       METH_VARARGS|METH_KEYWORDS,
 222         NULL},
 223  {"FC",         (PyCFunction)rpmfi_FC,          METH_NOARGS,
 224         NULL},
 225  {"FX",         (PyCFunction)rpmfi_FX,          METH_NOARGS,
 226         NULL},
 227  {"DC",         (PyCFunction)rpmfi_DC,          METH_NOARGS,
 228         NULL},
 229  {"DX",         (PyCFunction)rpmfi_DX,          METH_NOARGS,
 230         NULL},
 231  {"BN",         (PyCFunction)rpmfi_BN,          METH_NOARGS,
 232         NULL},
 233  {"DN",         (PyCFunction)rpmfi_DN,          METH_NOARGS,
 234         NULL},
 235  {"FN",         (PyCFunction)rpmfi_FN,          METH_NOARGS,
 236         NULL},
 237  {"FFlags",     (PyCFunction)rpmfi_FFlags,      METH_NOARGS,
 238         NULL},
 239  {"VFlags",     (PyCFunction)rpmfi_VFlags,      METH_NOARGS,
 240         NULL},
 241  {"FMode",      (PyCFunction)rpmfi_FMode,       METH_NOARGS,
 242         NULL},
 243  {"FState",     (PyCFunction)rpmfi_FState,      METH_NOARGS,
 244         NULL},
 245  {"MD5",        (PyCFunction)rpmfi_Digest,      METH_NOARGS,
 246         NULL},
 247  {"Digest",     (PyCFunction)rpmfi_Digest,      METH_NOARGS,
 248         NULL},
 249  {"FLink",      (PyCFunction)rpmfi_FLink,       METH_NOARGS,
 250         NULL},
 251  {"FSize",      (PyCFunction)rpmfi_FSize,       METH_NOARGS,
 252         NULL},
 253  {"FRdev",      (PyCFunction)rpmfi_FRdev,       METH_NOARGS,
 254         NULL},
 255  {"FMtime",     (PyCFunction)rpmfi_FMtime,      METH_NOARGS,
 256         NULL},
 257  {"FUser",      (PyCFunction)rpmfi_FUser,       METH_NOARGS,
 258         NULL},
 259  {"FGroup",     (PyCFunction)rpmfi_FGroup,      METH_NOARGS,
 260         NULL},
 261  {"FColor",     (PyCFunction)rpmfi_FColor,      METH_NOARGS,
 262         NULL},
 263  {"FClass",     (PyCFunction)rpmfi_FClass,      METH_NOARGS,
 264         NULL},
 265  {NULL,         NULL}           /* sentinel */
 266 };
 267
 268 /* ---------- */
 269
 270 static void
 271 rpmfi_dealloc(rpmfiObject * s)
 272 {
 273     if (s) {
 274         s->fi = rpmfiFree(s->fi);
 275         PyObject_Del(s);
 276     }
 277 }
 278
 279 static int
 280 rpmfi_print(rpmfiObject * s, FILE * fp, int flags)
 281 {
 282     if (!(s && s->fi))
 283         return -1;
 284
 285     s->fi = rpmfiInit(s->fi, 0);
 286     while (rpmfiNext(s->fi) >= 0)
 287         fprintf(fp, "%s\n", rpmfiFN(s->fi));
 288     return 0;
 289 }
 290
 291 static int
 292 rpmfi_length(rpmfiObject * s)
 293 {
 294     return rpmfiFC(s->fi);
 295 }
 296
 297 static PyObject *
 298 rpmfi_subscript(rpmfiObject * s, PyObject * key)
 299 {
 300     int ix;
 301
 302     if (!PyInt_Check(key)) {
 303         PyErr_SetString(PyExc_TypeError, "integer expected");
 304         return NULL;
 305     }
 306
 307     ix = (int) PyInt_AsLong(key);
 308     rpmfiSetFX(s->fi, ix);
 309     return Py_BuildValue("s", xstrdup(rpmfiFN(s->fi)));
 310 }
 311
 312 static PyMappingMethods rpmfi_as_mapping = {
 313         (lenfunc) rpmfi_length,         /* mp_length */
 314         (binaryfunc) rpmfi_subscript,   /* mp_subscript */
 315         (objobjargproc)0,               /* mp_ass_subscript */
 316 };
 317
 318 static int rpmfi_init(rpmfiObject * s, PyObject *args, PyObject *kwds)
 319 {
 320     s->active = 0;
 321     return 0;
 322 }
 323
 324 static void rpmfi_free(rpmfiObject * s)
 325 {
 326 if (_rpmfi_debug)
 327 fprintf(stderr, "%p -- fi %p\n", s, s->fi);
 328     s->fi = rpmfiFree(s->fi);
 329
 330     PyObject_Del((PyObject *)s);
 331 }
 332
 333 static PyObject * rpmfi_new(PyTypeObject * subtype, PyObject *args, PyObject *kwds)
 334 {
 335     hdrObject * ho = NULL;
 336     PyObject * to = NULL;
 337     rpmfi fi = NULL;
 338     rpmTag tagN = RPMTAG_BASENAMES;
 339     int flags = 0;
 340     char * kwlist[] = {"header", "tag", "flags", NULL};
 341
 342     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O!|Oi:rpmfi_init", kwlist,
 343             &hdr_Type, &ho, &to, &flags))
 344         return NULL;
 345
 346     if (to != NULL) {
 347         tagN = tagNumFromPyObject(to);
 348         if (tagN == RPMTAG_NOT_FOUND) return NULL;
 349     }
 350     fi = rpmfiNew(NULL, hdrGetHeader(ho), tagN, flags);
 351
 352     return rpmfi_Wrap(fi);
 353 }
 354
 355 static char rpmfi_doc[] =
 356 "";
 357
 358 PyTypeObject rpmfi_Type = {
 359         PyObject_HEAD_INIT(&PyType_Type)
 360         0,                              /* ob_size */
 361         "rpm.fi",                       /* tp_name */
 362         sizeof(rpmfiObject),            /* tp_basicsize */
 363         0,                              /* tp_itemsize */
 364         /* methods */
 365         (destructor) rpmfi_dealloc,     /* tp_dealloc */
 366         (printfunc) rpmfi_print,        /* tp_print */
 367         (getattrfunc)0,                 /* tp_getattr */
 368         (setattrfunc)0,                 /* tp_setattr */
 369         (cmpfunc)0,                     /* tp_compare */
 370         (reprfunc)0,                    /* tp_repr */
 371         0,                              /* tp_as_number */
 372         0,                              /* tp_as_sequence */
 373         &rpmfi_as_mapping,              /* tp_as_mapping */
 374         (hashfunc)0,                    /* tp_hash */
 375         (ternaryfunc)0,                 /* tp_call */
 376         (reprfunc)0,                    /* tp_str */
 377         PyObject_GenericGetAttr,        /* tp_getattro */
 378         PyObject_GenericSetAttr,        /* tp_setattro */
 379         0,                              /* tp_as_buffer */
 380         Py_TPFLAGS_DEFAULT,             /* tp_flags */
 381         rpmfi_doc,                      /* tp_doc */
 382         0,                              /* tp_traverse */
 383         0,                              /* tp_clear */
 384         0,                              /* tp_richcompare */
 385         0,                              /* tp_weaklistoffset */
 386         PyObject_SelfIter,              /* tp_iter */
 387         (iternextfunc) rpmfi_iternext,  /* tp_iternext */
 388         rpmfi_methods,                  /* tp_methods */
 389         0,                              /* tp_members */
 390         0,                              /* tp_getset */
 391         0,                              /* tp_base */
 392         0,                              /* tp_dict */
 393         0,                              /* tp_descr_get */
 394         0,                              /* tp_descr_set */
 395         0,                              /* tp_dictoffset */
 396         (initproc) rpmfi_init,          /* tp_init */
 397         0,                              /* tp_alloc */
 398         (newfunc) rpmfi_new,            /* tp_new */
 399         (freefunc) rpmfi_free,          /* tp_free */
 400         0,                              /* tp_is_gc */
 401 };
 402
 403 /* ---------- */
 404
 405 rpmfi fiFromFi(rpmfiObject * s)
 406 {
 407     return s->fi;
 408 }
 409
 410 PyObject * rpmfi_Wrap(rpmfi fi)
 411 {
 412     rpmfiObject *s = PyObject_New(rpmfiObject, &rpmfi_Type);
 413     if (s == NULL) return PyErr_NoMemory();
 414
 415     s->fi = fi;
 416     s->active = 0;
 417     return (PyObject *) s;
 418 }
 419