WITH_PYTHON_SUBPACKAGE=0
AS_IF([test "$enable_python" = yes],[
- AM_PATH_PYTHON([2.6],[
+ AM_PATH_PYTHON([3.2],[
PKG_CHECK_MODULES([PYTHON], [python-${PYTHON_VERSION}], [WITH_PYTHON_SUBPACKAGE=1])
AC_SUBST(PYTHON_CFLAGS)
AC_SUBST(PYTHON_LIB)
[],
[with_lua=yes])
+if test X"$LUA_PKGCONFIG_NAME" = X ; then
+ LUA_PKGCONFIG_NAME=lua
+fi
AS_IF([test "$with_lua" != no],[
PKG_CHECK_MODULES([LUA],
- [lua >= 5.1],
+ [${LUA_PKGCONFIG_NAME} >= 5.1],
[AC_DEFINE(WITH_LUA, 1, [Build with lua support?])],
[AC_MSG_ERROR([lua not present (--without-lua to disable)])])
AC_SUBST(LUA_CFLAGS)
--- /dev/null
+librpm-tizen (4.14.1.1.tizen20230628-20230828) unstable; urgency=low
+
+ * Rebase on latest Tizen
+
+ -- Xu Huayong <huayong.xu@samsung.com> Tue, 05 Sep 2023 14:21:46 +0300
+
+librpm-tizen (4.11.0.1.tizen20140530-tizen20140723) unstable; urgency=low
+
+ * Rebase on latest Tizen 3.0
+
+ -- Markus Lehtonen <markus.lehtonen@linux.intel.com> Wed, 23 Jul 2014 19:50:46 +0300
+
+librpm-tizen (4.11.0.1.tizen20130618-tizen20140306) unstable; urgency=low
+
+ [ Markus Lehtonen ]
+ * Fix build against Lua 5.2
+
+ -- Markus Lehtonen <markus.lehtonen@linux.intel.com> Thu, 06 Mar 2014 12:43:43 +0200
+
+librpm-tizen (4.11.0.1.tizen20130618-tizen20131001) unstable; urgency=low
+
+ * Ignore bad expressions in %if conditionals
+ * lua: Enable Lua
+ * lua: fall through failed lua scripts
+
+ -- Markus Lehtonen <markus.lehtonen@linux.intel.com> Tue, 01 Oct 2013 12:12:43 +0300
+
+librpm-tizen (4.11.0.1.tizen20130618-tizen20130821) unstable; urgency=low
+
+ [ Zhang Qiang ]
+ * fix segmentation fault error while parsing spec
+
+ [ Markus Lehtonen ]
+ * Prevent execution of arbitrary scripts
+ * Bump the log level of "unexpanded script" msg
+
+ -- Markus Lehtonen <markus.lehtonen@linux.intel.com> Wed, 21 Aug 2013 14:31:24 +0300
+
+librpm-tizen (4.11.0.1.tizen20130618-tizen20130619) unstable; urgency=low
+
+ * Version bump to latest from Tizen 3.0
+
+ -- Markus Lehtonen <markus.lehtonen@linux.intel.com> Tue, 18 Jun 2013 14:07:13 +0300
+
+librpm-tizen (4.11.0.1.tizen20130304-tizen20130307) unstable; urgency=low
+
+ * Version bump to latest from Tizen
+
+ -- Markus Lehtonen <markus.lehtonen@linux.intel.com> Thu, 07 Mar 2013 09:27:00 +0200
+
+librpm-tizen (4.10.91.tizen20121215-tizen20130226) unstable; urgency=low
+
+ * Enable lua
+ * Add a provide tag to make gbs depend on new changes
+ * Install Tizen macros
+ * Ignore unknown internal scripts
+
+ -- Markus Lehtonen <markus.lehtonen@linux.intel.com> Wed, 27 Feb 2013 10:12:00 +0200
+
+librpm-tizen (4.10.91.tizen20121215-tizen20130226) unstable; urgency=low
+
+ * Initial packaging
+
+ -- Markus Lehtonen <markus.lehtonen@linux.intel.com> Tue, 17 Dec 2012 13:22:00 +0200
+
--- /dev/null
+Source: librpm-tizen
+Section: vcs
+Priority: optional
+Build-Depends: debhelper,
+ dh-python,
+ dpkg-dev,
+ dh-autoreconf,
+ libtool,
+ autoconf,
+ automake,
+ autotools-dev,
+ autopoint,
+ zlib1g-dev,
+ libarchive-dev,
+ libpopt-dev,
+ libxml2-dev,
+ libreadline-dev,
+ libsqlite3-dev,
+ python3-all-dev,
+ python3,
+ pkg-config,
+ libnspr4-dev,
+ libnss3-dev,
+ liblzma-dev,
+ libmagic-dev,
+ libelf-dev,
+ libdw-dev,
+ libdb-dev,
+ liblua5.1-dev
+Maintainer: Markus Lehtonen <markus.lehtonen@linux.intel.com>
+Standards-Version: 3.9.3
+Homepage: http://rpm.org/
+X-Python-Version: >= 3
+
+Package: librpm-tizen
+Architecture: any
+Depends: ${shlibs:Depends}, ${misc:Depends}, ${python3:Depends}
+Description: The RPM libraries for git-buildpackage
+ RPM Package Manager is the main tool for managing the software packages
+ of Tizen.
+ .
+ RPM can be used to install and remove software packages. With rpm, it
+ is easy to update packages. RPM keeps track of all these manipulations
+ in a central database.»·This way it is possible to get an overview of
+ all installed packages. RPM also supports database queries.
+ .
+ This is a special stripped-down version of RPM, only intended to be used by the
+ git-buildpackage tool. Doesn't interfere with the RPM libraries of the host system.
+ This package only contains rpmlib and rpm-python.
+
--- /dev/null
+usr/lib*/*/*.so.*
+usr/lib*/*/rpm/*
+usr/lib/python*/*packages/*/*.so
+usr/lib/python*/*packages/*/*.py*
--- /dev/null
+#!/usr/bin/make -f
+
+python_mod_name := rpm_tizen
+
+CPPFLAGS += $(shell pkg-config --cflags nss)
+
+%:
+ dh $@ --with python3,autoreconf,autotools_dev
+
+override_dh_auto_configure:
+ dh_auto_configure -- --disable-dependency-tracking \
+ --libdir=/usr/lib/librpm-tizen \
+ --with-lua \
+ --without-acl \
+ --without-cap \
+ --enable-shared \
+ --enable-python \
+ --with-external-db \
+ --build=${DEB_BUILD_GNU_CPU}-tizen-linux \
+ PYTHON_MODULENAME=$(python_mod_name) \
+ LUA_PKGCONFIG_NAME=lua5.1 \
+ CPPFLAGS="$(CPPFLAGS)"
+
+override_dh_auto_install:
+ dh_auto_install --destdir=debian/tmp
+ # Install extra sources
+ install -m644 packaging/rpm-tizen_macros debian/tmp/usr/lib/librpm-tizen/rpm/tizen_macros
+ install -d debian/tmp/usr/lib/librpm-tizen/rpm/tizen
+ ln -s ../tizen_macros debian/tmp/usr/lib/librpm-tizen/rpm/tizen/macros
%if 0%{?centos_ver} || 0%{?centos_version}
BuildRequires: python-devel
%else
-BuildRequires: pkgconfig(python) >= 2.6
+BuildRequires: pkgconfig(python3)
%endif
# Disable security
%if 0
# And only copy the files that we want
install -d %{buildroot}%{_libdir}/%{name}
-install -d %{buildroot}%{python_sitearch}
+install -d %{buildroot}%{python3_sitearch}
cp -ax tmp_install/%{_libdir}/%{name} %{buildroot}%{_libdir}/
-cp -ax tmp_install/%{python_sitearch}/%{python_mod_name} %{buildroot}%{python_sitearch}/
+cp -ax tmp_install/%{python3_sitearch}/%{python_mod_name} %{buildroot}%{python3_sitearch}/
# Install extra sources
install -m644 %{SOURCE4} %{buildroot}%{_libdir}/%{name}/rpm/tizen_macros
# Compile python modules (Fedora does this automatically) and find duplicates
%if 0%{?suse_version}
-%py_compile %{buildroot}/%{python_sitearch}/%{python_mod_name}/
-%py_compile -O %{buildroot}/%{python_sitearch}/%{python_mod_name}/
+%py3_compile %{buildroot}/%{python3_sitearch}/%{python_mod_name}/
+%py3_compile -O %{buildroot}/%{python3_sitearch}/%{python_mod_name}/
-%fdupes %{buildroot}/%{python_sitearch}/
+%fdupes %{buildroot}/%{python3_sitearch}/
%endif
%files
%defattr(-,root,root,-)
%dir %{_libdir}/%{name}
-%dir %{python_sitearch}/%{python_mod_name}/
+%dir %{python3_sitearch}/%{python_mod_name}/
%{_libdir}/%{name}/*.so.*
%{_libdir}/%{name}/rpm
-%{python_sitearch}/%{python_mod_name}/*
+%{python3_sitearch}/%{python_mod_name}/*
AM_CPPFLAGS += -I$(top_srcdir)/python
AM_CPPFLAGS += @PYTHON_CFLAGS@ -DPYTHON_MODULENAME=\"@PYTHON_MODULENAME@\"
-pkgpyexec_LTLIBRARIES = _rpmmodule.la _rpmbmodule.la _rpmsmodule.la
+pkgpyexec_LTLIBRARIES = _rpm.la
pkgpyexec_DATA = rpm/__init__.py rpm/transaction.py
pkgpyexecdir = @pyexecdir@/@PYTHON_MODULENAME@
-_rpmmodule_la_LDFLAGS = -module -avoid-version -shared
-_rpmmodule_la_LIBADD = \
+_rpm_la_LDFLAGS = -module -avoid-version -shared
+_rpm_la_LIBADD = \
$(top_builddir)/lib/librpm.la \
$(top_builddir)/rpmio/librpmio.la \
+ $(top_builddir)/build/librpmbuild.la \
+ $(top_builddir)/sign/librpmsign.la \
@PYTHON_LIBS@
-_rpmmodule_la_SOURCES = rpmmodule.c rpmsystem-py.h \
+_rpm_la_SOURCES = rpmmodule.c rpmsystem-py.h \
header-py.c header-py.h \
rpmarchive-py.c rpmarchive-py.h \
rpmds-py.c rpmds-py.h \
rpmstrpool-py.c rpmstrpool-py.h \
rpmtd-py.c rpmtd-py.h \
rpmte-py.c rpmte-py.h \
- rpmts-py.c rpmts-py.h
-
-_rpmbmodule_la_LDFLAGS = -module -avoid-version -shared
-_rpmbmodule_la_LIBADD = \
- $(top_builddir)/build/librpmbuild.la \
- $(top_builddir)/lib/librpm.la \
- $(top_builddir)/rpmio/librpmio.la \
- @PYTHON_LIBS@
-
-_rpmbmodule_la_SOURCES = rpmbmodule.c rpmsystem-py.h \
+ rpmts-py.c rpmts-py.h \
spec-py.c spec-py.h
-
-_rpmsmodule_la_LDFLAGS = -module -avoid-version -shared
-_rpmsmodule_la_LIBADD = \
- $(top_builddir)/sign/librpmsign.la \
- $(top_builddir)/lib/librpm.la \
- $(top_builddir)/rpmio/librpmio.la \
- @PYTHON_LIBS@
-
-_rpmsmodule_la_SOURCES = rpmsmodule.c rpmsystem-py.h
-
hi = headerInitIterator(s->h);
while ((tag = headerNextTag(hi)) != RPMTAG_NOT_FOUND) {
- PyObject *to = PyInt_FromLong(tag);
+ PyObject *to = PyLong_FromLong(tag);
if (!to) {
headerFreeIterator(hi);
Py_DECREF(keys);
return NULL;
}
- result = Py_BuildValue("s", r);
+ result = utf8FromString(r);
free(r);
return result;
if (s->hi == NULL) s->hi = headerInitIterator(s->h);
if ((tag = headerNextTag(s->hi)) != RPMTAG_NOT_FOUND) {
- res = PyInt_FromLong(tag);
+ res = PyLong_FromLong(tag);
} else {
s->hi = headerFreeIterator(s->hi);
}
rpmTagVal tag = RPMTAG_NOT_FOUND;
PyObject *str = NULL;
- if (PyInt_Check(item)) {
+ if (PyLong_Check(item)) {
/* XXX we should probably validate tag numbers too */
- tag = PyInt_AsLong(item);
+ tag = PyLong_AsLong(item);
} else if (utf8FromPyObject(item, &str)) {
tag = rpmTagGetValue(PyBytes_AsString(str));
Py_DECREF(str);
switch (tclass) {
case RPM_NUMERIC_CLASS:
- rc = (PyLong_Check(item) || PyInt_Check(item));
+ rc = (PyLong_Check(item) || PyLong_Check(item));
break;
case RPM_STRING_CLASS:
rc = (PyBytes_Check(item) || PyUnicode_Check(item));
case RPM_STRING_TYPE:
case RPM_STRING_ARRAY_TYPE: {
PyObject *str = NULL;
- if (utf8FromPyObject(item, &str))
+ if (utf8FromPyObject(item, &str))
rc = headerPutString(h, tag, PyBytes_AsString(str));
Py_XDECREF(str);
} break;
rc = headerPutBin(h, tag, val, len);
} break;
case RPM_INT64_TYPE: {
- uint64_t val = PyInt_AsUnsignedLongLongMask(item);
+ uint64_t val = PyLong_AsUnsignedLongLongMask(item);
rc = headerPutUint64(h, tag, &val, 1);
} break;
case RPM_INT32_TYPE: {
- uint32_t val = PyInt_AsUnsignedLongMask(item);
+ uint32_t val = PyLong_AsUnsignedLongMask(item);
rc = headerPutUint32(h, tag, &val, 1);
} break;
case RPM_INT16_TYPE: {
- uint16_t val = PyInt_AsUnsignedLongMask(item);
+ uint16_t val = PyLong_AsUnsignedLongMask(item);
rc = headerPutUint16(h, tag, &val, 1);
} break;
case RPM_INT8_TYPE:
case RPM_CHAR_TYPE: {
- uint8_t val = PyInt_AsUnsignedLongMask(item);
+ uint8_t val = PyLong_AsUnsignedLongMask(item);
rc = headerPutUint8(h, tag, &val, 1);
} break;
default:
__version__ = _rpm.__version__
__version_info__ = tuple(__version__.split('.'))
-# try to import build bits but dont require it
-try:
- from @PYTHON_MODULENAME@._rpmb import *
-except ImportError:
- pass
-
-# try to import signing bits but dont require it
-try:
- from @PYTHON_MODULENAME@._rpms import *
-except ImportError:
- pass
-
# backwards compatibility + give the same class both ways
ts = TransactionSet
return self._wrapSetGet('_probFilter', ignoreSet)
def parseSpec(self, specfile):
- import rpm._rpmb
- return rpm._rpmb.spec(specfile)
+ return rpm.spec(specfile)
def getKeys(self):
keys = []
+++ /dev/null
-#include "rpmsystem-py.h"
-
-#include "spec-py.h"
-
-static char rpmb__doc__[] =
-"";
-
-/*
- Do any common preliminary work before python 2 vs python 3 module creation:
-*/
-static int prepareInitModule(void)
-{
- if (PyType_Ready(&spec_Type) < 0) return 0;
- if (PyType_Ready(&specPkg_Type) < 0) return 0;
-
- return 1;
-}
-
-static int initModule(PyObject *m)
-{
- Py_INCREF(&spec_Type);
- PyModule_AddObject(m, "spec", (PyObject *) &spec_Type);
- Py_INCREF(&specPkg_Type);
- PyModule_AddObject(m, "specPkg", (PyObject *) &specPkg_Type);
-
-#define REGISTER_ENUM(val) PyModule_AddIntConstant(m, #val, val)
- REGISTER_ENUM(RPMBUILD_ISSOURCE);
- REGISTER_ENUM(RPMBUILD_ISPATCH);
- REGISTER_ENUM(RPMBUILD_ISICON);
- REGISTER_ENUM(RPMBUILD_ISNO);
-
- REGISTER_ENUM(RPMBUILD_NONE);
- REGISTER_ENUM(RPMBUILD_PREP);
- REGISTER_ENUM(RPMBUILD_BUILD);
- REGISTER_ENUM(RPMBUILD_INSTALL);
- REGISTER_ENUM(RPMBUILD_CHECK);
- REGISTER_ENUM(RPMBUILD_CLEAN);
- REGISTER_ENUM(RPMBUILD_FILECHECK);
- REGISTER_ENUM(RPMBUILD_PACKAGESOURCE);
- REGISTER_ENUM(RPMBUILD_PACKAGEBINARY);
- REGISTER_ENUM(RPMBUILD_RMSOURCE);
- REGISTER_ENUM(RPMBUILD_RMBUILD);
- REGISTER_ENUM(RPMBUILD_RMSPEC);
-
- REGISTER_ENUM(RPMBUILD_PKG_NONE);
- REGISTER_ENUM(RPMBUILD_PKG_NODIRTOKENS);
-
- REGISTER_ENUM(RPMSPEC_NONE);
- REGISTER_ENUM(RPMSPEC_ANYARCH);
- REGISTER_ENUM(RPMSPEC_FORCE);
- REGISTER_ENUM(RPMSPEC_NOLANG);
-
- return 1;
-}
-
-#if PY_MAJOR_VERSION >= 3
-static struct PyModuleDef moduledef = {
- PyModuleDef_HEAD_INIT,
- "_rpmb", /* m_name */
- rpmb__doc__, /* m_doc */
- 0, /* m_size */
- NULL, /* m_methods */
- NULL, /* m_reload */
- NULL, /* m_traverse */
- NULL, /* m_clear */
- NULL /* m_free */
-};
-
-PyObject * PyInit__rpmb(void); /* XXX eliminate gcc warning */
-PyObject * PyInit__rpmb(void)
-{
- PyObject *m;
-
- if (!prepareInitModule())
- return NULL;
- m = PyModule_Create(&moduledef);
- if (m == NULL || !initModule(m)) {
- Py_XDECREF(m);
- m = NULL;
- }
- return m;
-}
-#else
-void init_rpmb(void); /* XXX eliminate gcc warning */
-void init_rpmb(void)
-{
- PyObject *m;
-
- if (!prepareInitModule())
- return;
-
- m = Py_InitModule3("_rpmb", NULL, rpmb__doc__);
- if (m) initModule(m);
-}
-#endif
static PyObject *
rpmds_DNEVR(rpmdsObject * s)
{
- return Py_BuildValue("s", rpmdsDNEVR(s->ds));
+ return utf8FromString(rpmdsDNEVR(s->ds));
}
static PyObject *
rpmds_N(rpmdsObject * s)
{
- return Py_BuildValue("s", rpmdsN(s->ds));
+ return utf8FromString(rpmdsN(s->ds));
}
static PyObject *
rpmds_EVR(rpmdsObject * s)
{
- return Py_BuildValue("s", rpmdsEVR(s->ds));
+ return utf8FromString(rpmdsEVR(s->ds));
}
static PyObject *
{
int ix;
- if (!PyInt_Check(key)) {
+ if (!PyLong_Check(key)) {
PyErr_SetString(PyExc_TypeError, "integer expected");
return NULL;
}
- ix = (int) PyInt_AsLong(key);
+ ix = (int) PyLong_AsLong(key);
rpmdsSetIx(s->ds, ix);
- return Py_BuildValue("s", rpmdsDNEVR(s->ds));
+ return utf8FromString(rpmdsDNEVR(s->ds));
}
static PyMappingMethods rpmds_as_mapping = {
PyObject *str = NULL;
rpmsenseFlags flags = RPMSENSE_ANY;
- if (PyInt_Check(o)) {
+ if (PyLong_Check(o)) {
ok = 1;
- flags = PyInt_AsLong(o);
+ flags = PyLong_AsLong(o);
} else if (utf8FromPyObject(o, &str)) {
ok = 1;
for (const char *s = PyBytes_AsString(str); *s; s++) {
static PyObject *rpmfd_get_name(rpmfdObject *s)
{
/* XXX: rpm returns non-paths with [mumble], python files use <mumble> */
- return Py_BuildValue("s", Fdescr(s->fd));
+ return utf8FromString(Fdescr(s->fd));
}
static PyObject *rpmfd_get_mode(rpmfdObject *s)
{
- return Py_BuildValue("s", s->mode);
+ return utf8FromString(s->mode);
}
static PyObject *rpmfd_get_flags(rpmfdObject *s)
{
- return Py_BuildValue("s", s->flags);
+ return utf8FromString(s->flags);
}
static PyGetSetDef rpmfd_getseters[] = {
static PyObject *
rpmfi_BN(rpmfiObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmfiBN(s->fi));
+ return utf8FromString(rpmfiBN(s->fi));
}
static PyObject *
rpmfi_DN(rpmfiObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmfiDN(s->fi));
+ return utf8FromString(rpmfiDN(s->fi));
}
static PyObject *
rpmfi_FN(rpmfiObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmfiFN(s->fi));
+ return utf8FromString(rpmfiFN(s->fi));
}
static PyObject *
{
char *digest = rpmfiFDigestHex(s->fi, NULL);
if (digest) {
- PyObject *dig = Py_BuildValue("s", digest);
+ PyObject *dig = utf8FromString(digest);
free(digest);
return dig;
} else {
static PyObject *
rpmfi_FLink(rpmfiObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmfiFLink(s->fi));
+ return utf8FromString(rpmfiFLink(s->fi));
}
static PyObject *
static PyObject *
rpmfi_FUser(rpmfiObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmfiFUser(s->fi));
+ return utf8FromString(rpmfiFUser(s->fi));
}
static PyObject *
rpmfi_FGroup(rpmfiObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmfiFGroup(s->fi));
+ return utf8FromString(rpmfiFGroup(s->fi));
}
static PyObject *
if ((FClass = rpmfiFClass(s->fi)) == NULL)
FClass = "";
- return Py_BuildValue("s", FClass);
+ return utf8FromString(FClass);
}
static PyObject *
result = PyTuple_New(nlinks);
for (uint32_t i=0; i<nlinks; i++) {
- PyTuple_SET_ITEM(result, i, PyInt_FromLong(files[i]));
+ PyTuple_SET_ITEM(result, i, PyLong_FromLong(files[i]));
}
return result;
}
Py_INCREF(Py_None);
PyTuple_SET_ITEM(result, 0, Py_None);
} else
- PyTuple_SET_ITEM(result, 0, Py_BuildValue("s", FN));
+ PyTuple_SET_ITEM(result, 0, utf8FromString(FN));
PyTuple_SET_ITEM(result, 1, PyLong_FromLongLong(FSize));
- PyTuple_SET_ITEM(result, 2, PyInt_FromLong(FMode));
- PyTuple_SET_ITEM(result, 3, PyInt_FromLong(FMtime));
- PyTuple_SET_ITEM(result, 4, PyInt_FromLong(FFlags));
- PyTuple_SET_ITEM(result, 5, PyInt_FromLong(FRdev));
- PyTuple_SET_ITEM(result, 6, PyInt_FromLong(FInode));
- PyTuple_SET_ITEM(result, 7, PyInt_FromLong(FNlink));
- PyTuple_SET_ITEM(result, 8, PyInt_FromLong(FState));
- PyTuple_SET_ITEM(result, 9, PyInt_FromLong(VFlags));
+ PyTuple_SET_ITEM(result, 2, PyLong_FromLong(FMode));
+ PyTuple_SET_ITEM(result, 3, PyLong_FromLong(FMtime));
+ PyTuple_SET_ITEM(result, 4, PyLong_FromLong(FFlags));
+ PyTuple_SET_ITEM(result, 5, PyLong_FromLong(FRdev));
+ PyTuple_SET_ITEM(result, 6, PyLong_FromLong(FInode));
+ PyTuple_SET_ITEM(result, 7, PyLong_FromLong(FNlink));
+ PyTuple_SET_ITEM(result, 8, PyLong_FromLong(FState));
+ PyTuple_SET_ITEM(result, 9, PyLong_FromLong(VFlags));
if (FUser == NULL) {
Py_INCREF(Py_None);
PyTuple_SET_ITEM(result, 10, Py_None);
} else
- PyTuple_SET_ITEM(result, 10, Py_BuildValue("s", FUser));
+ PyTuple_SET_ITEM(result, 10, utf8FromString(FUser));
if (FGroup == NULL) {
Py_INCREF(Py_None);
PyTuple_SET_ITEM(result, 11, Py_None);
} else
- PyTuple_SET_ITEM(result, 11, Py_BuildValue("s", FGroup));
+ PyTuple_SET_ITEM(result, 11, utf8FromString(FGroup));
PyTuple_SET_ITEM(result, 12, rpmfi_Digest(s, NULL));
} else
{
int ix;
- if (!PyInt_Check(key)) {
+ if (!PyLong_Check(key)) {
PyErr_SetString(PyExc_TypeError, "integer expected");
return NULL;
}
- ix = (int) PyInt_AsLong(key);
+ ix = (int) PyLong_AsLong(key);
rpmfiSetFX(s->fi, ix);
- return Py_BuildValue("s", rpmfiFN(s->fi));
+ return utf8FromString(rpmfiFN(s->fi));
}
static PyMappingMethods rpmfi_as_mapping = {
static PyObject *rpmfile_name(rpmfileObject *s)
{
char * fn = rpmfilesFN(s->files, s->ix);
- PyObject *o = Py_BuildValue("s", fn);
+ PyObject *o = utf8FromString(fn);
free(fn);
return o;
}
static PyObject *rpmfile_basename(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesBN(s->files, s->ix));
+ return utf8FromString(rpmfilesBN(s->files, s->ix));
}
static PyObject *rpmfile_dirname(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesDN(s->files, rpmfilesDI(s->files, s->ix)));
+ return utf8FromString(rpmfilesDN(s->files, rpmfilesDI(s->files, s->ix)));
}
static PyObject *rpmfile_orig_name(rpmfileObject *s)
{
char * fn = rpmfilesOFN(s->files, s->ix);
- PyObject *o = Py_BuildValue("s", fn);
+ PyObject *o = utf8FromString(fn);
free(fn);
return o;
}
static PyObject *rpmfile_orig_basename(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesOBN(s->files, s->ix));
+ return utf8FromString(rpmfilesOBN(s->files, s->ix));
}
static PyObject *rpmfile_orig_dirname(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesODN(s->files, rpmfilesODI(s->files, s->ix)));
+ return utf8FromString(rpmfilesODN(s->files, rpmfilesODI(s->files, s->ix)));
}
static PyObject *rpmfile_mode(rpmfileObject *s)
{
static PyObject *rpmfile_linkto(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesFLink(s->files, s->ix));
+ return utf8FromString(rpmfilesFLink(s->files, s->ix));
}
static PyObject *rpmfile_user(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesFUser(s->files, s->ix));
+ return utf8FromString(rpmfilesFUser(s->files, s->ix));
}
static PyObject *rpmfile_group(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesFGroup(s->files, s->ix));
+ return utf8FromString(rpmfilesFGroup(s->files, s->ix));
}
static PyObject *rpmfile_fflags(rpmfileObject *s)
NULL, &diglen);
if (digest) {
char * hex = pgpHexStr(digest, diglen);
- PyObject *o = Py_BuildValue("s", hex);
+ PyObject *o = utf8FromString(hex);
free(hex);
return o;
}
static PyObject *rpmfile_class(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesFClass(s->files, s->ix));
+ return utf8FromString(rpmfilesFClass(s->files, s->ix));
}
static PyObject *rpmfile_caps(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesFCaps(s->files, s->ix));
+ return utf8FromString(rpmfilesFCaps(s->files, s->ix));
}
static PyObject *rpmfile_langs(rpmfileObject *s)
{
- return Py_BuildValue("s", rpmfilesFLangs(s->files, s->ix));
+ return utf8FromString(rpmfilesFLangs(s->files, s->ix));
}
static PyObject *rpmfile_links(rpmfileObject *s)
PyObject *str = NULL;
/* treat numbers as sequence accesses */
- if (PyInt_Check(item)) {
- return rpmfiles_getitem(s, PyInt_AsSsize_t(item));
+ if (PyLong_Check(item)) {
+ return rpmfiles_getitem(s, PyLong_AsSsize_t(item));
} else if (PyLong_Check(item)) {
return rpmfiles_getitem(s, PyLong_AsSsize_t(item));
}
if (PySlice_Check(item)) {
Py_ssize_t start, stop, step, slicelength, i, cur;
PyObject * result;
-
+
if (PySlice_GetIndicesEx(
#if PY_MAJOR_VERSION < 3
(PySliceObject*)
for (int i = 0; i < entries; i++) {
tuple = PyTuple_New(2);
PyTuple_SET_ITEM(tuple, 0,
- PyInt_FromLong(rpmdbIndexIteratorPkgOffset(s->ii, i)));
+ PyLong_FromLong(rpmdbIndexIteratorPkgOffset(s->ii, i)));
PyTuple_SET_ITEM(tuple, 1,
- PyInt_FromLong(rpmdbIndexIteratorTagNum(s->ii, i)));
+ PyLong_FromLong(rpmdbIndexIteratorTagNum(s->ii, i)));
PyList_SET_ITEM(list, i, tuple);
}
return list;
static PyObject * rpmPubkey_Base64(rpmPubkeyObject *s)
{
char *b64 = rpmPubkeyBase64(s->pubkey);
- PyObject *res = Py_BuildValue("s", b64);
+ PyObject *res = utf8FromString(b64);
free(b64);
return res;
}
if (rpmExpandMacros(NULL, macro, &str, 0) < 0)
PyErr_SetString(pyrpmError, "error expanding macro");
else
- res = Py_BuildValue("s", str);
+ res = utf8FromString(str);
free(str);
}
return res;
#include <rpm/rpmsq.h>
#include <rpm/rpmlog.h>
#include <rpm/rpmmacro.h>
+#include <rpm/rpmsign.h>
#include "header-py.h"
#include "rpmarchive-py.h"
#include "rpmtd-py.h"
#include "rpmte-py.h"
#include "rpmts-py.h"
+#include "spec-py.h"
/** \ingroup python
* \name Module: rpm
Py_RETURN_NONE;
}
+static int parseSignArgs(PyObject * args, PyObject *kwds,
+ const char **path, struct rpmSignArgs *sargs)
+{
+ char * kwlist[] = { "path", "keyid", "hashalgo", NULL };
+
+ memset(sargs, 0, sizeof(*sargs));
+ return PyArg_ParseTupleAndKeywords(args, kwds, "s|si", kwlist,
+ path, &sargs->keyid, &sargs->hashalgo);
+}
+
+static PyObject * addSign(PyObject * self, PyObject * args, PyObject *kwds)
+{
+ const char *path = NULL;
+ struct rpmSignArgs sargs;
+
+ if (!parseSignArgs(args, kwds, &path, &sargs))
+ return NULL;
+
+ return PyBool_FromLong(rpmPkgSign(path, &sargs) == 0);
+}
+
+static PyObject * delSign(PyObject * self, PyObject * args, PyObject *kwds)
+{
+ const char *path = NULL;
+ struct rpmSignArgs sargs;
+
+ if (!parseSignArgs(args, kwds, &path, &sargs))
+ return NULL;
+
+ return PyBool_FromLong(rpmPkgDelSign(path, &sargs) == 0);
+}
+
static PyMethodDef rpmModuleMethods[] = {
{ "addMacro", (PyCFunction) rpmmacro_AddMacro, METH_VARARGS|METH_KEYWORDS,
"rpmPushMacro(macro, value)\n"
"once only at process startup because currently signal handlers will\n"
"not be retroactively applied if a database is open."
},
+ { "addSign", (PyCFunction) addSign, METH_VARARGS|METH_KEYWORDS, NULL },
+ { "delSign", (PyCFunction) delSign, METH_VARARGS|METH_KEYWORDS, NULL },
{ NULL }
} ;
tagval = rpmTagGetValue(shortname);
PyModule_AddIntConstant(module, tagname, tagval);
- pyval = PyInt_FromLong(tagval);
- pyname = Py_BuildValue("s", shortname);
+ pyval = PyLong_FromLong(tagval);
+ pyname = utf8FromString(shortname);
PyDict_SetItem(dict, pyval, pyname);
Py_DECREF(pyval);
Py_DECREF(pyname);
#endif
if (PyType_Ready(&rpmte_Type) < 0) return 0;
if (PyType_Ready(&rpmts_Type) < 0) return 0;
+ if (PyType_Ready(&spec_Type) < 0) return 0;
+ if (PyType_Ready(&specPkg_Type) < 0) return 0;
return 1;
}
Py_INCREF(&rpmts_Type);
PyModule_AddObject(m, "ts", (PyObject *) &rpmts_Type);
+ Py_INCREF(&spec_Type);
+ PyModule_AddObject(m, "spec", (PyObject *) &spec_Type);
+
+ Py_INCREF(&specPkg_Type);
+ PyModule_AddObject(m, "specPkg", (PyObject *) &specPkg_Type);
+
addRpmTags(m);
PyModule_AddStringConstant(m, "__version__", RPMVERSION);
REGISTER_ENUM(RPMVERIFY_READFAIL);
REGISTER_ENUM(RPMVERIFY_LSTATFAIL);
+ REGISTER_ENUM(RPMBUILD_ISSOURCE);
+ REGISTER_ENUM(RPMBUILD_ISPATCH);
+ REGISTER_ENUM(RPMBUILD_ISICON);
+ REGISTER_ENUM(RPMBUILD_ISNO);
+
+ REGISTER_ENUM(RPMBUILD_NONE);
+ REGISTER_ENUM(RPMBUILD_PREP);
+ REGISTER_ENUM(RPMBUILD_BUILD);
+ REGISTER_ENUM(RPMBUILD_INSTALL);
+ REGISTER_ENUM(RPMBUILD_CHECK);
+ REGISTER_ENUM(RPMBUILD_CLEAN);
+ REGISTER_ENUM(RPMBUILD_FILECHECK);
+ REGISTER_ENUM(RPMBUILD_PACKAGESOURCE);
+ REGISTER_ENUM(RPMBUILD_PACKAGEBINARY);
+ REGISTER_ENUM(RPMBUILD_RMSOURCE);
+ REGISTER_ENUM(RPMBUILD_RMBUILD);
+ REGISTER_ENUM(RPMBUILD_RMSPEC);
+
+ REGISTER_ENUM(RPMBUILD_PKG_NONE);
+ REGISTER_ENUM(RPMBUILD_PKG_NODIRTOKENS);
+
+ REGISTER_ENUM(RPMSPEC_NONE);
+ REGISTER_ENUM(RPMSPEC_ANYARCH);
+ REGISTER_ENUM(RPMSPEC_FORCE);
+ REGISTER_ENUM(RPMSPEC_NOLANG);
+
return 1;
}
static PyObject *rpmprob_get_pkgnevr(rpmProblemObject *s, void *closure)
{
- return Py_BuildValue("s", rpmProblemGetPkgNEVR(s->prob));
+ return utf8FromString(rpmProblemGetPkgNEVR(s->prob));
}
static PyObject *rpmprob_get_altnevr(rpmProblemObject *s, void *closure)
{
- return Py_BuildValue("s", rpmProblemGetAltNEVR(s->prob));
+ return utf8FromString(rpmProblemGetAltNEVR(s->prob));
}
static PyObject *rpmprob_get_key(rpmProblemObject *s, void *closure)
static PyObject *rpmprob_get_str(rpmProblemObject *s, void *closure)
{
- return Py_BuildValue("s", rpmProblemGetStr(s->prob));
+ return utf8FromString(rpmProblemGetStr(s->prob));
}
static PyObject *rpmprob_get_num(rpmProblemObject *s, void *closure)
static PyObject *rpmprob_str(rpmProblemObject *s)
{
char *str = rpmProblemString(s->prob);
- PyObject *res = Py_BuildValue("s", str);
+ PyObject *res = utf8FromString(str);
free(str);
return res;
}
+++ /dev/null
-#include "rpmsystem-py.h"
-
-#include <rpm/rpmsign.h>
-
-static char rpms__doc__[] =
-"";
-
-static int parseSignArgs(PyObject * args, PyObject *kwds,
- const char **path, struct rpmSignArgs *sargs)
-{
- char * kwlist[] = { "path", "keyid", "hashalgo", NULL };
-
- memset(sargs, 0, sizeof(*sargs));
- return PyArg_ParseTupleAndKeywords(args, kwds, "s|si", kwlist,
- path, &sargs->keyid, &sargs->hashalgo);
-}
-
-static PyObject * addSign(PyObject * self, PyObject * args, PyObject *kwds)
-{
- const char *path = NULL;
- struct rpmSignArgs sargs;
-
- if (parseSignArgs(args, kwds, &path, &sargs))
- return NULL;
-
- return PyBool_FromLong(rpmPkgSign(path, &sargs) == 0);
-}
-
-static PyObject * delSign(PyObject * self, PyObject * args, PyObject *kwds)
-{
- const char *path = NULL;
- struct rpmSignArgs sargs;
-
- if (parseSignArgs(args, kwds, &path, &sargs))
- return NULL;
-
- return PyBool_FromLong(rpmPkgDelSign(path, &sargs) == 0);
-}
-
-/*
- Do any common preliminary work before python 2 vs python 3 module creation:
-*/
-static int prepareInitModule(void)
-{
- return 1;
-}
-
-static int initModule(PyObject *m)
-{
- return 1;
-}
-
-static PyMethodDef modMethods[] = {
- { "addSign", (PyCFunction) addSign, METH_VARARGS|METH_KEYWORDS, NULL },
- { "delSign", (PyCFunction) delSign, METH_VARARGS|METH_KEYWORDS, NULL },
- { NULL },
-};
-
-#if PY_MAJOR_VERSION >= 3
-static struct PyModuleDef moduledef = {
- PyModuleDef_HEAD_INIT,
- "_rpms", /* m_name */
- rpms__doc__, /* m_doc */
- 0, /* m_size */
- modMethods, /* m_methods */
- NULL, /* m_reload */
- NULL, /* m_traverse */
- NULL, /* m_clear */
- NULL /* m_free */
-};
-
-PyObject * PyInit__rpms(void); /* XXX eliminate gcc warning */
-PyObject * PyInit__rpms(void)
-{
- PyObject *m;
-
- if (!prepareInitModule())
- return NULL;
- m = PyModule_Create(&moduledef);
- if (m == NULL || !initModule(m)) {
- Py_XDECREF(m);
- m = NULL;
- }
- return m;
-}
-#else
-void init_rpms(void); /* XXX eliminate gcc warning */
-void init_rpms(void)
-{
- PyObject *m;
-
- if (!prepareInitModule())
- return;
-
- m = Py_InitModule3("_rpms", modMethods, rpms__doc__);
- if (m) initModule(m);
-}
-#endif
const char *str = rpmstrPoolStr(s->pool, id);
if (str)
- ret = PyBytes_FromString(str);
- else
+ ret = utf8FromString(str);
+ else
PyErr_SetObject(PyExc_KeyError, item);
}
return ret;
#define CAPSULE_EXTRACT(obj,name) PyCObject_AsVoidPtr(obj)
#endif
-/* For Python 3, use the PyLong type throughout in place of PyInt */
+/* In Python 3, we return all strings as surrogate-escaped utf-8 */
#if PY_MAJOR_VERSION >= 3
-#define PyInt_Check PyLong_Check
-#define PyInt_AsLong PyLong_AsLong
-#define PyInt_FromLong PyLong_FromLong
-#define PyInt_AsUnsignedLongMask PyLong_AsUnsignedLongMask
-#define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
-#define PyInt_AsSsize_t PyLong_AsSsize_t
+#define utf8FromString(_s) PyUnicode_DecodeUTF8(_s, strlen(_s), "surrogateescape")
+#else
+#define utf8FromString(_s) PyBytes_FromString(_s)
#endif
#endif /* H_SYSTEM_PYTHON */
switch (tclass) {
case RPM_STRING_CLASS:
- res = PyBytes_FromString(rpmtdGetString(td));
+ res = utf8FromString(rpmtdGetString(td));
break;
case RPM_NUMERIC_CLASS:
res = PyLong_FromLongLong(rpmtdGetNumber(td));
static PyObject *
rpmte_N(rpmteObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmteN(s->te));
+ return utf8FromString(rpmteN(s->te));
}
static PyObject *
rpmte_E(rpmteObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmteE(s->te));
+ return utf8FromString(rpmteE(s->te));
}
static PyObject *
rpmte_V(rpmteObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmteV(s->te));
+ return utf8FromString(rpmteV(s->te));
}
static PyObject *
rpmte_R(rpmteObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmteR(s->te));
+ return utf8FromString(rpmteR(s->te));
}
static PyObject *
rpmte_A(rpmteObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmteA(s->te));
+ return utf8FromString(rpmteA(s->te));
}
static PyObject *
rpmte_O(rpmteObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmteO(s->te));
+ return utf8FromString(rpmteO(s->te));
}
static PyObject *
rpmte_NEVR(rpmteObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmteNEVR(s->te));
+ return utf8FromString(rpmteNEVR(s->te));
}
static PyObject *
rpmte_NEVRA(rpmteObject * s, PyObject * unused)
{
- return Py_BuildValue("s", rpmteNEVRA(s->te));
+ return utf8FromString(rpmteNEVRA(s->te));
}
static PyObject *
PyEval_RestoreThread(cbInfo->_save);
- args = Py_BuildValue("(Oissi)", cbInfo->tso,
- rpmdsTagN(ds), rpmdsN(ds), rpmdsEVR(ds), rpmdsFlags(ds));
- result = PyEval_CallObject(cbInfo->cb, args);
+ args = Py_BuildValue("(OiNNi)", cbInfo->tso,
+ rpmdsTagN(ds), utf8FromString(rpmdsN(ds)),
+ utf8FromString(rpmdsEVR(ds)), rpmdsFlags(ds));
+ result = PyObject_Call(cbInfo->cb, args, NULL);
Py_DECREF(args);
if (!result) {
die(cbInfo->cb);
} else {
- if (PyInt_Check(result))
- res = PyInt_AsLong(result);
+ if (PyLong_Check(result))
+ res = PyLong_AsLong(result);
Py_DECREF(result);
}
rpmrc = headerCheck(s->ts, uh, uc, &msg);
Py_END_ALLOW_THREADS;
- return Py_BuildValue("(is)", rpmrc, msg);
+ return Py_BuildValue("(iN)", rpmrc, utf8FromString(msg));
}
static PyObject *
/* Synthesize a python object for callback (if necessary). */
if (pkgObj == NULL) {
if (h) {
- pkgObj = Py_BuildValue("s", headerGetString(h, RPMTAG_NAME));
+ pkgObj = utf8FromString(headerGetString(h, RPMTAG_NAME));
} else {
pkgObj = Py_None;
Py_INCREF(pkgObj);
PyEval_RestoreThread(cbInfo->_save);
args = Py_BuildValue("(iLLOO)", what, amount, total, pkgObj, cbInfo->data);
- result = PyEval_CallObject(cbInfo->cb, args);
+ result = PyObject_Call(cbInfo->cb, args, NULL);
Py_DECREF(args);
Py_DECREF(pkgObj);
return NULL;
if (Key) {
- if (PyInt_Check(Key)) {
- lkey = PyInt_AsLong(Key);
+ if (PyLong_Check(Key)) {
+ lkey = PyLong_AsLong(Key);
key = (char *)&lkey;
len = sizeof(lkey);
} else if (PyLong_Check(Key)) {
static PyObject *rpmts_get_rootDir(rpmtsObject *s, void *closure)
{
- return Py_BuildValue("s", rpmtsRootDir(s->ts));
+ return utf8FromString(rpmtsRootDir(s->ts));
}
static int rpmts_set_scriptFd(rpmtsObject *s, PyObject *value, void *closure)
PyTypeObject rpmts_Type = {
PyVarObject_HEAD_INIT(&PyType_Type, 0)
- PYTHON_MODULENAME".ts", /* tp_name */
+ PYTHON_MODULENAME".ts", /* tp_name */
sizeof(rpmtsObject), /* tp_size */
0, /* tp_itemsize */
(destructor) rpmts_dealloc, /* tp_dealloc */
rpmmod = Extension('@PYTHON_MODULENAME@._rpm',
- sources = [ 'header-py.c', 'rpmds-py.c', 'rpmfd-py.c',
- 'rpmfi-py.c', 'rpmii-py.c', 'rpmkeyring-py.c',
- 'rpmmacro-py.c', 'rpmmi-py.c', 'rpmps-py.c',
- 'rpmstrpool-py.c', 'rpmfiles-py.c',
- 'rpmarchive-py.c', 'rpmtd-py.c',
- 'rpmte-py.c', 'rpmts-py.c', 'rpmmodule.c',
- ],
+ sources = ['header-py.c', 'rpmds-py.c', 'rpmfd-py.c',
+ 'rpmfi-py.c', 'rpmii-py.c', 'rpmkeyring-py.c',
+ 'rpmmacro-py.c', 'rpmmi-py.c', 'rpmps-py.c',
+ 'rpmstrpool-py.c', 'rpmfiles-py.c',
+ 'rpmarchive-py.c', 'rpmtd-py.c',
+ 'rpmte-py.c', 'rpmts-py.c',
+ 'spec-py',
+ 'rpmmodule.c'],
include_dirs = pkgconfig('--cflags'),
library_dirs = pkgconfig('--libs-only-L'),
- libraries = pkgconfig('--libs-only-l'),
- extra_compile_args = cflags,
- extra_link_args = additional_link_args
- )
-
-rpmbuild_mod = Extension('@PYTHON_MODULENAME@._rpmb',
- sources = ['rpmbmodule.c', 'spec-py.c'],
- include_dirs = pkgconfig('--cflags'),
- library_dirs = pkgconfig('--libs-only-L'),
- libraries = pkgconfig('--libs-only-l') + ['rpmbuild'],
- extra_compile_args = cflags,
- extra_link_args = additional_link_args
- )
-
-rpmsign_mod = Extension('@PYTHON_MODULENAME@._rpms',
- sources = ['rpmsmodule.c'],
- include_dirs = pkgconfig('--cflags'),
- library_dirs = pkgconfig('--libs-only-L'),
- libraries = pkgconfig('--libs-only-l') + ['rpmsign'],
+ libraries = pkgconfig('--libs-only-l') + ['rpmbuild', 'rpmsign'],
extra_compile_args = cflags,
extra_link_args = additional_link_args
)
description='Python bindings for @PACKAGE_NAME@',
maintainer_email='@PACKAGE_BUGREPORT@',
url='http://www.rpm.org/',
- packages = ['@PACKAGE_NAME@'],
- ext_modules= [rpmmod, rpmbuild_mod, rpmsign_mod]
+ packages=['@PACKAGE_NAME@'],
+ ext_modules=[rpmmod]
)
{
char *sect = rpmSpecPkgGetSection(pkg, section);
if (sect != NULL) {
- PyObject *ps = PyBytes_FromString(sect);
+ PyObject *ps = utf8FromString(sect);
free(sect);
if (ps != NULL)
return ps;
{
const char *sect = rpmSpecGetSection(spec, section);
if (sect) {
- return Py_BuildValue("s", sect);
+ return utf8FromString(sect);
}
Py_RETURN_NONE;
}
rpmSpecSrcIter iter = rpmSpecSrcIterInit(s->spec);
while ((source = rpmSpecSrcIterNext(iter)) != NULL) {
- PyObject *srcUrl = Py_BuildValue("(sii)",
- rpmSpecSrcFilename(source, 1),
+ PyObject *srcUrl = Py_BuildValue("(Nii)",
+ utf8FromString(rpmSpecSrcFilename(source, 1)),
rpmSpecSrcNum(source),
rpmSpecSrcFlags(source));
if (!srcUrl) {
projects / tools / librpm-tizen.git / commitdiff