python/rpmmodule.c

   1 /** \ingroup py_c
   2  * \file python/rpmmodule.c
   3  */
   4
   5 #include "system.h"
   6
   7 #include <rpm/rpmlib.h>         /* rpmMachineScore, rpmReadConfigFiles */
   8 #include <rpm/rpmtag.h>
   9 #include <rpm/rpmdb.h>
  10 #include <rpm/rpmsq.h>
  11 #include <rpm/rpmlog.h>
  12
  13 #include "header-py.h"
  14 #include "rpmds-py.h"
  15 #include "rpmfd-py.h"
  16 #include "rpmfi-py.h"
  17 #include "rpmmi-py.h"
  18 #include "rpmps-py.h"
  19 #include "rpmmacro-py.h"
  20 #include "rpmte-py.h"
  21 #include "rpmts-py.h"
  22 #include "spec-py.h"
  23
  24 #include "debug.h"
  25
  26 /** \ingroup python
  27  * \name Module: rpm
  28  */
  29
  30 /**
  31  */
  32 PyObject * pyrpmError;
  33
  34 /**
  35  */
  36 static PyObject * archScore(PyObject * self, PyObject * args, PyObject * kwds)
  37 {
  38     char * arch;
  39     int score;
  40     char * kwlist[] = {"arch", NULL};
  41
  42     if (!PyArg_ParseTupleAndKeywords(args, kwds, "s", kwlist, &arch))
  43         return NULL;
  44
  45     score = rpmMachineScore(RPM_MACHTABLE_INSTARCH, arch);
  46
  47     return Py_BuildValue("i", score);
  48 }
  49
  50 /**
  51  *  */
  52 static PyObject * signalsCaught(PyObject * self, PyObject * check)
  53 {
  54     PyObject *caught, *o;
  55     int llen;
  56     int signum, i;
  57     sigset_t newMask, oldMask;
  58
  59     if (!PyList_Check(check)) {
  60         PyErr_SetString(PyExc_TypeError, "list expected");
  61         return NULL;
  62     }
  63
  64     llen = PyList_Size(check);
  65     caught = PyList_New(0);
  66
  67     /* block signals while checking for them */
  68     (void) sigfillset(&newMask);
  69     (void) sigprocmask(SIG_BLOCK, &newMask, &oldMask);
  70
  71     for (i = 0; i < llen; i++) {
  72         o = PyList_GetItem(check, i);
  73         signum = PyInt_AsLong(o);
  74         if (rpmsqIsCaught(signum) > 0) {
  75             PyList_Append(caught, o);
  76         }
  77     }
  78     (void) sigprocmask(SIG_SETMASK, &oldMask, NULL);
  79
  80     return caught;
  81 }
  82
  83 /**
  84  *  */
  85 static PyObject * checkSignals(PyObject * self, PyObject * args)
  86 {
  87     if (!PyArg_ParseTuple(args, ":checkSignals")) return NULL;
  88     rpmdbCheckSignals();
  89     Py_INCREF(Py_None);
  90     return Py_None;
  91 }
  92
  93
  94 /**
  95  */
  96 static PyObject * setLogFile (PyObject * self, PyObject * args, PyObject *kwds)
  97 {
  98     PyObject * fop = NULL;
  99     FILE * fp = NULL;
 100     char * kwlist[] = {"fileObject", NULL};
 101
 102     if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:logSetFile", kwlist, &fop))
 103         return NULL;
 104
 105     if (fop) {
 106         if (!PyFile_Check(fop)) {
 107             PyErr_SetString(pyrpmError, "requires file object");
 108             return NULL;
 109         }
 110         fp = PyFile_AsFile(fop);
 111     }
 112
 113     (void) rpmlogSetFile(fp);
 114
 115     Py_INCREF(Py_None);
 116     return (PyObject *) Py_None;
 117 }
 118
 119 /**
 120  */
 121 static PyObject *
 122 setVerbosity (PyObject * self, PyObject * args, PyObject *kwds)
 123 {
 124     int level;
 125     char * kwlist[] = {"level", NULL};
 126
 127     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &level))
 128         return NULL;
 129
 130     rpmSetVerbosity(level);
 131
 132     Py_INCREF(Py_None);
 133     return (PyObject *) Py_None;
 134 }
 135
 136 /**
 137  */
 138 static PyObject *
 139 setEpochPromote (PyObject * self, PyObject * args, PyObject * kwds)
 140 {
 141     char * kwlist[] = {"promote", NULL};
 142
 143     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist,
 144             &_rpmds_nopromote))
 145         return NULL;
 146
 147     Py_INCREF(Py_None);
 148     return (PyObject *) Py_None;
 149 }
 150
 151 /**
 152  */
 153 static PyObject * setStats (PyObject * self, PyObject * args, PyObject * kwds)
 154 {
 155     char * kwlist[] = {"stats", NULL};
 156
 157     if (!PyArg_ParseTupleAndKeywords(args, kwds, "i", kwlist, &_rpmts_stats))
 158         return NULL;
 159
 160     Py_INCREF(Py_None);
 161     return (PyObject *) Py_None;
 162 }
 163
 164 /**
 165  */
 166 static PyMethodDef rpmModuleMethods[] = {
 167     { "TransactionSet", (PyCFunction) rpmts_Create, METH_VARARGS|METH_KEYWORDS,
 168 "rpm.TransactionSet([rootDir, [db]]) -> ts\n\
 169 - Create a transaction set.\n" },
 170
 171     { "addMacro", (PyCFunction) rpmmacro_AddMacro, METH_VARARGS|METH_KEYWORDS,
 172         NULL },
 173     { "delMacro", (PyCFunction) rpmmacro_DelMacro, METH_VARARGS|METH_KEYWORDS,
 174         NULL },
 175     { "expandMacro", (PyCFunction) rpmmacro_ExpandMacro, METH_VARARGS|METH_KEYWORDS,
 176         NULL },
 177
 178     { "archscore", (PyCFunction) archScore, METH_VARARGS|METH_KEYWORDS,
 179         NULL },
 180
 181     { "signalsCaught", (PyCFunction) signalsCaught, METH_O,
 182         NULL },
 183     { "checkSignals", (PyCFunction) checkSignals, METH_VARARGS,
 184         NULL },
 185
 186     { "headerLoad", (PyCFunction) hdrLoad, METH_VARARGS|METH_KEYWORDS,
 187         NULL },
 188     { "mergeHeaderListFromFD", (PyCFunction) rpmMergeHeadersFromFD, METH_VARARGS|METH_KEYWORDS,
 189         NULL },
 190     { "readHeaderListFromFD", (PyCFunction) rpmHeaderFromFD, METH_VARARGS|METH_KEYWORDS,
 191         NULL },
 192     { "readHeaderListFromFile", (PyCFunction) rpmHeaderFromFile, METH_VARARGS|METH_KEYWORDS,
 193         NULL },
 194     { "readHeaderFromFD", (PyCFunction) rpmSingleHeaderFromFD, METH_VARARGS|METH_KEYWORDS,
 195         NULL },
 196
 197     { "setLogFile", (PyCFunction) setLogFile, METH_VARARGS|METH_KEYWORDS,
 198         NULL },
 199
 200     { "versionCompare", (PyCFunction) versionCompare, METH_VARARGS|METH_KEYWORDS,
 201         NULL },
 202     { "labelCompare", (PyCFunction) labelCompare, METH_VARARGS|METH_KEYWORDS,
 203         NULL },
 204     { "setVerbosity", (PyCFunction) setVerbosity, METH_VARARGS|METH_KEYWORDS,
 205         NULL },
 206     { "setEpochPromote", (PyCFunction) setEpochPromote, METH_VARARGS|METH_KEYWORDS,
 207         NULL },
 208     { "setStats", (PyCFunction) setStats, METH_VARARGS|METH_KEYWORDS,
 209         NULL },
 210
 211     { "dsSingle", (PyCFunction) rpmds_Single, METH_VARARGS|METH_KEYWORDS,
 212 "rpm.dsSingle(TagN, N, [EVR, [Flags]] -> ds\n\
 213 - Create a single element dependency set.\n" },
 214     { NULL }
 215 } ;
 216
 217 /*
 218 * Force clean up of open iterators and dbs on exit.
 219 */
 220 static void rpm_exithook(void)
 221 {
 222    rpmdbCheckTerminate(1);
 223 }
 224
 225 /**
 226  */
 227 static char rpm__doc__[] =
 228 "";
 229
 230 void init_rpm(void);    /* XXX eliminate gcc warning */
 231 /**
 232  */
 233 void init_rpm(void)
 234 {
 235     PyObject * d, *o, *tag = NULL, *dict, *m;
 236
 237 #if Py_TPFLAGS_HAVE_ITER        /* XXX backport to python-1.5.2 */
 238     if (PyType_Ready(&hdr_Type) < 0) return;
 239     if (PyType_Ready(&rpmds_Type) < 0) return;
 240     if (PyType_Ready(&rpmfd_Type) < 0) return;
 241     if (PyType_Ready(&rpmfi_Type) < 0) return;
 242     if (PyType_Ready(&rpmmi_Type) < 0) return;
 243     if (PyType_Ready(&rpmps_Type) < 0) return;
 244
 245     if (PyType_Ready(&rpmte_Type) < 0) return;
 246     if (PyType_Ready(&rpmts_Type) < 0) return;
 247     if (PyType_Ready(&spec_Type) < 0) return;
 248 #endif
 249
 250     m = Py_InitModule3("_rpm", rpmModuleMethods, rpm__doc__);
 251     if (m == NULL)
 252         return;
 253
 254     /*
 255      * treat error to register rpm cleanup hook as fatal, tracebacks
 256      * can and will leave stale locks around if we can't clean up
 257      */
 258     if (Py_AtExit(rpm_exithook) == -1)
 259         return;
 260
 261     rpmReadConfigFiles(NULL, NULL);
 262
 263     d = PyModule_GetDict(m);
 264
 265 #ifdef  HACK
 266     pyrpmError = PyString_FromString("_rpm.error");
 267     PyDict_SetItemString(d, "error", pyrpmError);
 268     Py_DECREF(pyrpmError);
 269 #else
 270     pyrpmError = PyErr_NewException("_rpm.error", NULL, NULL);
 271     if (pyrpmError != NULL)
 272         PyDict_SetItemString(d, "error", pyrpmError);
 273 #endif
 274
 275 #if Py_TPFLAGS_HAVE_ITER        /* XXX backport to python-1.5.2 */
 276     Py_INCREF(&hdr_Type);
 277     PyModule_AddObject(m, "hdr", (PyObject *) &hdr_Type);
 278
 279     Py_INCREF(&rpmds_Type);
 280     PyModule_AddObject(m, "ds", (PyObject *) &rpmds_Type);
 281
 282     Py_INCREF(&rpmfd_Type);
 283     PyModule_AddObject(m, "fd", (PyObject *) &rpmfd_Type);
 284
 285     Py_INCREF(&rpmfi_Type);
 286     PyModule_AddObject(m, "fi", (PyObject *) &rpmfi_Type);
 287
 288     Py_INCREF(&rpmmi_Type);
 289     PyModule_AddObject(m, "mi", (PyObject *) &rpmmi_Type);
 290
 291     Py_INCREF(&rpmps_Type);
 292     PyModule_AddObject(m, "ps", (PyObject *) &rpmps_Type);
 293
 294     Py_INCREF(&rpmte_Type);
 295     PyModule_AddObject(m, "te", (PyObject *) &rpmte_Type);
 296
 297     Py_INCREF(&rpmts_Type);
 298     PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
 299
 300     Py_INCREF(&spec_Type);
 301     PyModule_AddObject(m, "spec", (PyObject *) &spec_Type);
 302 #else
 303     hdr_Type.ob_type = &PyType_Type;
 304     rpmds_Type.ob_type = &PyType_Type;
 305     rpmfd_Type.ob_type = &PyType_Type;
 306     rpmfi_Type.ob_type = &PyType_Type;
 307     rpmmi_Type.ob_type = &PyType_Type;
 308     rpmps_Type.ob_type = &PyType_Type;
 309     rpmte_Type.ob_type = &PyType_Type;
 310     rpmts_Type.ob_type = &PyType_Type;
 311     spec_Type.ob_type =  &PyType_Type;
 312 #endif
 313
 314     dict = PyDict_New();
 315     {   const char *tname, *sname;
 316         rpmtd names = rpmtdNew();
 317         rpmTagGetNames(names, 1);
 318
 319         while ((tname = rpmtdNextString(names))) {
 320             sname = tname + strlen("RPMTAG_");
 321             tag = PyInt_FromLong(rpmTagGetValue(sname));
 322             PyDict_SetItemString(d, tname, tag);
 323             Py_DECREF(tag);
 324             o = PyString_FromString(sname);
 325             PyDict_SetItem(dict, tag, o);
 326             Py_DECREF(o);
 327         }
 328         rpmtdFreeData(names);
 329         rpmtdFree(names);
 330     }
 331     PyDict_SetItemString(d, "tagnames", dict);
 332     Py_DECREF(dict);
 333
 334
 335 #define REGISTER_ENUM(val) \
 336     PyDict_SetItemString(d, #val, o=PyInt_FromLong( val )); \
 337     Py_DECREF(o);
 338
 339     REGISTER_ENUM(RPMTAG_NOT_FOUND);
 340
 341     REGISTER_ENUM(RPMFILE_STATE_NORMAL);
 342     REGISTER_ENUM(RPMFILE_STATE_REPLACED);
 343     REGISTER_ENUM(RPMFILE_STATE_NOTINSTALLED);
 344     REGISTER_ENUM(RPMFILE_STATE_NETSHARED);
 345     REGISTER_ENUM(RPMFILE_STATE_WRONGCOLOR);
 346
 347     REGISTER_ENUM(RPMFILE_CONFIG);
 348     REGISTER_ENUM(RPMFILE_DOC);
 349     REGISTER_ENUM(RPMFILE_ICON);
 350     REGISTER_ENUM(RPMFILE_MISSINGOK);
 351     REGISTER_ENUM(RPMFILE_NOREPLACE);
 352     REGISTER_ENUM(RPMFILE_GHOST);
 353     REGISTER_ENUM(RPMFILE_LICENSE);
 354     REGISTER_ENUM(RPMFILE_README);
 355     REGISTER_ENUM(RPMFILE_EXCLUDE);
 356     REGISTER_ENUM(RPMFILE_UNPATCHED);
 357     REGISTER_ENUM(RPMFILE_PUBKEY);
 358
 359     REGISTER_ENUM(RPMDEP_SENSE_REQUIRES);
 360     REGISTER_ENUM(RPMDEP_SENSE_CONFLICTS);
 361
 362     REGISTER_ENUM(RPMSENSE_LESS);
 363     REGISTER_ENUM(RPMSENSE_GREATER);
 364     REGISTER_ENUM(RPMSENSE_EQUAL);
 365     REGISTER_ENUM(RPMSENSE_PREREQ);
 366     REGISTER_ENUM(RPMSENSE_INTERP);
 367     REGISTER_ENUM(RPMSENSE_SCRIPT_PRE);
 368     REGISTER_ENUM(RPMSENSE_SCRIPT_POST);
 369     REGISTER_ENUM(RPMSENSE_SCRIPT_PREUN);
 370     REGISTER_ENUM(RPMSENSE_SCRIPT_POSTUN);
 371     REGISTER_ENUM(RPMSENSE_SCRIPT_VERIFY);
 372     REGISTER_ENUM(RPMSENSE_FIND_REQUIRES);
 373     REGISTER_ENUM(RPMSENSE_FIND_PROVIDES);
 374     REGISTER_ENUM(RPMSENSE_TRIGGERIN);
 375     REGISTER_ENUM(RPMSENSE_TRIGGERUN);
 376     REGISTER_ENUM(RPMSENSE_TRIGGERPOSTUN);
 377     REGISTER_ENUM(RPMSENSE_SCRIPT_PREP);
 378     REGISTER_ENUM(RPMSENSE_SCRIPT_BUILD);
 379     REGISTER_ENUM(RPMSENSE_SCRIPT_INSTALL);
 380     REGISTER_ENUM(RPMSENSE_SCRIPT_CLEAN);
 381     REGISTER_ENUM(RPMSENSE_RPMLIB);
 382     REGISTER_ENUM(RPMSENSE_TRIGGERPREIN);
 383     REGISTER_ENUM(RPMSENSE_KEYRING);
 384     REGISTER_ENUM(RPMSENSE_PATCHES);
 385     REGISTER_ENUM(RPMSENSE_CONFIG);
 386
 387     REGISTER_ENUM(RPMTRANS_FLAG_TEST);
 388     REGISTER_ENUM(RPMTRANS_FLAG_BUILD_PROBS);
 389     REGISTER_ENUM(RPMTRANS_FLAG_NOSCRIPTS);
 390     REGISTER_ENUM(RPMTRANS_FLAG_JUSTDB);
 391     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERS);
 392     REGISTER_ENUM(RPMTRANS_FLAG_NODOCS);
 393     REGISTER_ENUM(RPMTRANS_FLAG_ALLFILES);
 394     REGISTER_ENUM(RPMTRANS_FLAG_KEEPOBSOLETE);
 395     REGISTER_ENUM(RPMTRANS_FLAG_REPACKAGE);
 396     REGISTER_ENUM(RPMTRANS_FLAG_REVERSE);
 397     REGISTER_ENUM(RPMTRANS_FLAG_NOPRE);
 398     REGISTER_ENUM(RPMTRANS_FLAG_NOPOST);
 399     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPREIN);
 400     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERIN);
 401     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERUN);
 402     REGISTER_ENUM(RPMTRANS_FLAG_NOPREUN);
 403     REGISTER_ENUM(RPMTRANS_FLAG_NOPOSTUN);
 404     REGISTER_ENUM(RPMTRANS_FLAG_NOTRIGGERPOSTUN);
 405     REGISTER_ENUM(RPMTRANS_FLAG_NOMD5);
 406     REGISTER_ENUM(RPMTRANS_FLAG_NOFILEDIGEST);
 407     REGISTER_ENUM(RPMTRANS_FLAG_NOSUGGEST);
 408     REGISTER_ENUM(RPMTRANS_FLAG_ADDINDEPS);
 409     REGISTER_ENUM(RPMTRANS_FLAG_NOCONFIGS);
 410
 411     REGISTER_ENUM(RPMPROB_FILTER_IGNOREOS);
 412     REGISTER_ENUM(RPMPROB_FILTER_IGNOREARCH);
 413     REGISTER_ENUM(RPMPROB_FILTER_REPLACEPKG);
 414     REGISTER_ENUM(RPMPROB_FILTER_FORCERELOCATE);
 415     REGISTER_ENUM(RPMPROB_FILTER_REPLACENEWFILES);
 416     REGISTER_ENUM(RPMPROB_FILTER_REPLACEOLDFILES);
 417     REGISTER_ENUM(RPMPROB_FILTER_OLDPACKAGE);
 418     REGISTER_ENUM(RPMPROB_FILTER_DISKSPACE);
 419     REGISTER_ENUM(RPMPROB_FILTER_DISKNODES);
 420
 421     REGISTER_ENUM(RPMCALLBACK_UNKNOWN);
 422     REGISTER_ENUM(RPMCALLBACK_INST_PROGRESS);
 423     REGISTER_ENUM(RPMCALLBACK_INST_START);
 424     REGISTER_ENUM(RPMCALLBACK_INST_OPEN_FILE);
 425     REGISTER_ENUM(RPMCALLBACK_INST_CLOSE_FILE);
 426     REGISTER_ENUM(RPMCALLBACK_TRANS_PROGRESS);
 427     REGISTER_ENUM(RPMCALLBACK_TRANS_START);
 428     REGISTER_ENUM(RPMCALLBACK_TRANS_STOP);
 429     REGISTER_ENUM(RPMCALLBACK_UNINST_PROGRESS);
 430     REGISTER_ENUM(RPMCALLBACK_UNINST_START);
 431     REGISTER_ENUM(RPMCALLBACK_UNINST_STOP);
 432     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_PROGRESS);
 433     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_START);
 434     REGISTER_ENUM(RPMCALLBACK_REPACKAGE_STOP);
 435     REGISTER_ENUM(RPMCALLBACK_UNPACK_ERROR);
 436     REGISTER_ENUM(RPMCALLBACK_CPIO_ERROR);
 437     REGISTER_ENUM(RPMCALLBACK_SCRIPT_ERROR);
 438
 439     REGISTER_ENUM(RPMPROB_BADARCH);
 440     REGISTER_ENUM(RPMPROB_BADOS);
 441     REGISTER_ENUM(RPMPROB_PKG_INSTALLED);
 442     REGISTER_ENUM(RPMPROB_BADRELOCATE);
 443     REGISTER_ENUM(RPMPROB_REQUIRES);
 444     REGISTER_ENUM(RPMPROB_CONFLICT);
 445     REGISTER_ENUM(RPMPROB_NEW_FILE_CONFLICT);
 446     REGISTER_ENUM(RPMPROB_FILE_CONFLICT);
 447     REGISTER_ENUM(RPMPROB_OLDPACKAGE);
 448     REGISTER_ENUM(RPMPROB_DISKSPACE);
 449     REGISTER_ENUM(RPMPROB_DISKNODES);
 450
 451     REGISTER_ENUM(VERIFY_DIGEST);
 452     REGISTER_ENUM(VERIFY_SIGNATURE);
 453
 454     REGISTER_ENUM(RPMLOG_EMERG);
 455     REGISTER_ENUM(RPMLOG_ALERT);
 456     REGISTER_ENUM(RPMLOG_CRIT);
 457     REGISTER_ENUM(RPMLOG_ERR);
 458     REGISTER_ENUM(RPMLOG_WARNING);
 459     REGISTER_ENUM(RPMLOG_NOTICE);
 460     REGISTER_ENUM(RPMLOG_INFO);
 461     REGISTER_ENUM(RPMLOG_DEBUG);
 462
 463     REGISTER_ENUM(RPMMIRE_DEFAULT);
 464     REGISTER_ENUM(RPMMIRE_STRCMP);
 465     REGISTER_ENUM(RPMMIRE_REGEX);
 466     REGISTER_ENUM(RPMMIRE_GLOB);
 467
 468     REGISTER_ENUM(RPMVSF_DEFAULT);
 469     REGISTER_ENUM(RPMVSF_NOHDRCHK);
 470     REGISTER_ENUM(RPMVSF_NEEDPAYLOAD);
 471     REGISTER_ENUM(RPMVSF_NOSHA1HEADER);
 472     REGISTER_ENUM(RPMVSF_NOMD5HEADER);
 473     REGISTER_ENUM(RPMVSF_NODSAHEADER);
 474     REGISTER_ENUM(RPMVSF_NORSAHEADER);
 475     REGISTER_ENUM(RPMVSF_NOSHA1);
 476     REGISTER_ENUM(RPMVSF_NOMD5);
 477     REGISTER_ENUM(RPMVSF_NODSA);
 478     REGISTER_ENUM(RPMVSF_NORSA);
 479     REGISTER_ENUM(_RPMVSF_NODIGESTS);
 480     REGISTER_ENUM(_RPMVSF_NOSIGNATURES);
 481     REGISTER_ENUM(_RPMVSF_NOHEADER);
 482     REGISTER_ENUM(_RPMVSF_NOPAYLOAD);
 483
 484     REGISTER_ENUM(TR_ADDED);
 485     REGISTER_ENUM(TR_REMOVED);
 486
 487     REGISTER_ENUM(RPMDBI_PACKAGES);
 488 }
 489