From 018fcb4a1852ab3368903d57bc0b5e54fa03e6c8 Mon Sep 17 00:00:00 2001 From: "vivian, zhang" Date: Sun, 3 Jun 2012 11:21:25 +0800 Subject: Initial import package dbus-python: D-Bus Python Bindings --- _dbus_bindings/Makefile.am | 35 + _dbus_bindings/Makefile.in | 647 ++++++++++++++++++ _dbus_bindings/abstract.c | 664 +++++++++++++++++++ _dbus_bindings/bus.c | 187 ++++++ _dbus_bindings/bytes.c | 267 ++++++++ _dbus_bindings/conn-internal.h | 67 ++ _dbus_bindings/conn-methods.c | 1037 +++++++++++++++++++++++++++++ _dbus_bindings/conn.c | 471 +++++++++++++ _dbus_bindings/containers.c | 769 ++++++++++++++++++++++ _dbus_bindings/dbus_bindings-internal.h | 245 +++++++ _dbus_bindings/debug.c | 95 +++ _dbus_bindings/exceptions.c | 99 +++ _dbus_bindings/float.c | 158 +++++ _dbus_bindings/generic.c | 84 +++ _dbus_bindings/int.c | 779 ++++++++++++++++++++++ _dbus_bindings/libdbusconn.c | 124 ++++ _dbus_bindings/mainloop.c | 208 ++++++ _dbus_bindings/message-append.c | 1092 +++++++++++++++++++++++++++++++ _dbus_bindings/message-get-args.c | 523 +++++++++++++++ _dbus_bindings/message-internal.h | 49 ++ _dbus_bindings/message.c | 1063 ++++++++++++++++++++++++++++++ _dbus_bindings/module.c | 395 +++++++++++ _dbus_bindings/pending-call.c | 293 +++++++++ _dbus_bindings/server.c | 581 ++++++++++++++++ _dbus_bindings/signature.c | 247 +++++++ _dbus_bindings/string.c | 380 +++++++++++ _dbus_bindings/types-internal.h | 95 +++ _dbus_bindings/validation.c | 245 +++++++ 28 files changed, 10899 insertions(+) create mode 100644 _dbus_bindings/Makefile.am create mode 100644 _dbus_bindings/Makefile.in create mode 100644 _dbus_bindings/abstract.c create mode 100644 _dbus_bindings/bus.c create mode 100644 _dbus_bindings/bytes.c create mode 100644 _dbus_bindings/conn-internal.h create mode 100644 _dbus_bindings/conn-methods.c create mode 100644 _dbus_bindings/conn.c create mode 100644 _dbus_bindings/containers.c create mode 100644 _dbus_bindings/dbus_bindings-internal.h create mode 100644 _dbus_bindings/debug.c create mode 100644 _dbus_bindings/exceptions.c create mode 100644 _dbus_bindings/float.c create mode 100644 _dbus_bindings/generic.c create mode 100644 _dbus_bindings/int.c create mode 100644 _dbus_bindings/libdbusconn.c create mode 100644 _dbus_bindings/mainloop.c create mode 100644 _dbus_bindings/message-append.c create mode 100644 _dbus_bindings/message-get-args.c create mode 100644 _dbus_bindings/message-internal.h create mode 100644 _dbus_bindings/message.c create mode 100644 _dbus_bindings/module.c create mode 100644 _dbus_bindings/pending-call.c create mode 100644 _dbus_bindings/server.c create mode 100644 _dbus_bindings/signature.c create mode 100644 _dbus_bindings/string.c create mode 100644 _dbus_bindings/types-internal.h create mode 100644 _dbus_bindings/validation.c (limited to '_dbus_bindings') diff --git a/_dbus_bindings/Makefile.am b/_dbus_bindings/Makefile.am new file mode 100644 index 0000000..c6cd1ee --- /dev/null +++ b/_dbus_bindings/Makefile.am @@ -0,0 +1,35 @@ +pyexec_LTLIBRARIES = _dbus_bindings.la + +AM_CPPFLAGS = -I$(top_srcdir)/include $(DBUS_CFLAGS) $(PYTHON_INCLUDES) +AM_LDFLAGS = -module -avoid-version -export-symbols-regex init_dbus_bindings \ + $(DBUS_LIBS) +_dbus_bindings_la_SOURCES = \ + abstract.c \ + bus.c \ + bytes.c \ + conn.c \ + conn-internal.h \ + conn-methods.c \ + containers.c \ + dbus_bindings-internal.h \ + debug.c \ + exceptions.c \ + float.c \ + generic.c \ + int.c \ + libdbusconn.c \ + mainloop.c \ + message-append.c \ + message.c \ + message-get-args.c \ + message-internal.h \ + module.c \ + pending-call.c \ + server.c \ + signature.c \ + string.c \ + types-internal.h \ + validation.c + +check_c_sources = $(_dbus_bindings_la_SOURCES) +include $(top_srcdir)/tools/check-coding-style.mk diff --git a/_dbus_bindings/Makefile.in b/_dbus_bindings/Makefile.in new file mode 100644 index 0000000..99a4b2a --- /dev/null +++ b/_dbus_bindings/Makefile.in @@ -0,0 +1,647 @@ +# Makefile.in generated by automake 1.11.1 from Makefile.am. +# @configure_input@ + +# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002, +# 2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, +# Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ + +VPATH = @srcdir@ +pkgdatadir = $(datadir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkglibexecdir = $(libexecdir)/@PACKAGE@ +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_HEADER = $(INSTALL_DATA) +transform = $(program_transform_name) +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +build_triplet = @build@ +host_triplet = @host@ +DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in \ + $(top_srcdir)/tools/check-coding-style.mk +subdir = _dbus_bindings +ACLOCAL_M4 = $(top_srcdir)/aclocal.m4 +am__aclocal_m4_deps = $(top_srcdir)/m4/am-check-pymod.m4 \ + $(top_srcdir)/m4/am-check-python-headers.m4 \ + $(top_srcdir)/m4/dbus-py-add-rst2htmlflag.m4 \ + $(top_srcdir)/m4/jh-add-cflag.m4 $(top_srcdir)/m4/libtool.m4 \ + $(top_srcdir)/m4/ltoptions.m4 $(top_srcdir)/m4/ltsugar.m4 \ + $(top_srcdir)/m4/ltversion.m4 $(top_srcdir)/m4/lt~obsolete.m4 \ + $(top_srcdir)/m4/tp-compiler-flag.m4 \ + $(top_srcdir)/m4/tp-compiler-warnings.m4 \ + $(top_srcdir)/configure.ac +am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \ + $(ACLOCAL_M4) +mkinstalldirs = $(install_sh) -d +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +CONFIG_CLEAN_VPATH_FILES = +am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`; +am__vpath_adj = case $$p in \ + $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \ + *) f=$$p;; \ + esac; +am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`; +am__install_max = 40 +am__nobase_strip_setup = \ + srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'` +am__nobase_strip = \ + for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||" +am__nobase_list = $(am__nobase_strip_setup); \ + for p in $$list; do echo "$$p $$p"; done | \ + sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \ + $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \ + if (++n[$$2] == $(am__install_max)) \ + { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \ + END { for (dir in files) print dir, files[dir] }' +am__base_list = \ + sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \ + sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g' +am__installdirs = "$(DESTDIR)$(pyexecdir)" +LTLIBRARIES = $(pyexec_LTLIBRARIES) +_dbus_bindings_la_LIBADD = +am__dbus_bindings_la_OBJECTS = abstract.lo bus.lo bytes.lo conn.lo \ + conn-methods.lo containers.lo debug.lo exceptions.lo float.lo \ + generic.lo int.lo libdbusconn.lo mainloop.lo message-append.lo \ + message.lo message-get-args.lo module.lo pending-call.lo \ + server.lo signature.lo string.lo validation.lo +_dbus_bindings_la_OBJECTS = $(am__dbus_bindings_la_OBJECTS) +AM_V_lt = $(am__v_lt_$(V)) +am__v_lt_ = $(am__v_lt_$(AM_DEFAULT_VERBOSITY)) +am__v_lt_0 = --silent +DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir) +depcomp = $(SHELL) $(top_srcdir)/depcomp +am__depfiles_maybe = depfiles +am__mv = mv -f +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \ + $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \ + $(AM_CFLAGS) $(CFLAGS) +AM_V_CC = $(am__v_CC_$(V)) +am__v_CC_ = $(am__v_CC_$(AM_DEFAULT_VERBOSITY)) +am__v_CC_0 = @echo " CC " $@; +AM_V_at = $(am__v_at_$(V)) +am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY)) +am__v_at_0 = @ +CCLD = $(CC) +LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \ + $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +AM_V_CCLD = $(am__v_CCLD_$(V)) +am__v_CCLD_ = $(am__v_CCLD_$(AM_DEFAULT_VERBOSITY)) +am__v_CCLD_0 = @echo " CCLD " $@; +AM_V_GEN = $(am__v_GEN_$(V)) +am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY)) +am__v_GEN_0 = @echo " GEN " $@; +SOURCES = $(_dbus_bindings_la_SOURCES) +DIST_SOURCES = $(_dbus_bindings_la_SOURCES) +ETAGS = etags +CTAGS = ctags +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) +ACLOCAL = @ACLOCAL@ +AMTAR = @AMTAR@ +AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@ +AR = @AR@ +AUTOCONF = @AUTOCONF@ +AUTOHEADER = @AUTOHEADER@ +AUTOMAKE = @AUTOMAKE@ +AWK = @AWK@ +CC = @CC@ +CCDEPMODE = @CCDEPMODE@ +CFLAGS = @CFLAGS@ +CPP = @CPP@ +CPPFLAGS = @CPPFLAGS@ +CYGPATH_W = @CYGPATH_W@ +DBUS_CFLAGS = @DBUS_CFLAGS@ +DBUS_GLIB_CFLAGS = @DBUS_GLIB_CFLAGS@ +DBUS_GLIB_LIBS = @DBUS_GLIB_LIBS@ +DBUS_LIBS = @DBUS_LIBS@ +DBUS_PYTHON_MAJOR_VERSION = @DBUS_PYTHON_MAJOR_VERSION@ +DBUS_PYTHON_MICRO_VERSION = @DBUS_PYTHON_MICRO_VERSION@ +DBUS_PYTHON_MINOR_VERSION = @DBUS_PYTHON_MINOR_VERSION@ +DEFS = @DEFS@ +DEPDIR = @DEPDIR@ +DSYMUTIL = @DSYMUTIL@ +DUMPBIN = @DUMPBIN@ +ECHO_C = @ECHO_C@ +ECHO_N = @ECHO_N@ +ECHO_T = @ECHO_T@ +EGREP = @EGREP@ +EPYDOC = @EPYDOC@ +EXEEXT = @EXEEXT@ +FGREP = @FGREP@ +GREP = @GREP@ +INSTALL = @INSTALL@ +INSTALL_DATA = @INSTALL_DATA@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LD = @LD@ +LDFLAGS = @LDFLAGS@ +LIBOBJS = @LIBOBJS@ +LIBS = @LIBS@ +LIBTOOL = @LIBTOOL@ +LIPO = @LIPO@ +LN_S = @LN_S@ +LTLIBOBJS = @LTLIBOBJS@ +MAKEINFO = @MAKEINFO@ +MKDIR_P = @MKDIR_P@ +NM = @NM@ +NMEDIT = @NMEDIT@ +OBJDUMP = @OBJDUMP@ +OBJEXT = @OBJEXT@ +OTOOL = @OTOOL@ +OTOOL64 = @OTOOL64@ +PACKAGE = @PACKAGE@ +PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@ +PACKAGE_NAME = @PACKAGE_NAME@ +PACKAGE_STRING = @PACKAGE_STRING@ +PACKAGE_TARNAME = @PACKAGE_TARNAME@ +PACKAGE_URL = @PACKAGE_URL@ +PACKAGE_VERSION = @PACKAGE_VERSION@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +PKG_CONFIG = @PKG_CONFIG@ +PLATFORM = @PLATFORM@ +PYTHON = @PYTHON@ +PYTHON_EXEC_PREFIX = @PYTHON_EXEC_PREFIX@ +PYTHON_INCLUDES = @PYTHON_INCLUDES@ +PYTHON_PLATFORM = @PYTHON_PLATFORM@ +PYTHON_PREFIX = @PYTHON_PREFIX@ +PYTHON_VERSION = @PYTHON_VERSION@ +RANLIB = @RANLIB@ +RST2HTML = @RST2HTML@ +RST2HTMLFLAGS = @RST2HTMLFLAGS@ +SED = @SED@ +SET_MAKE = @SET_MAKE@ +SHELL = @SHELL@ +STRIP = @STRIP@ +VERSION = @VERSION@ +abs_builddir = @abs_builddir@ +abs_srcdir = @abs_srcdir@ +abs_top_builddir = @abs_top_builddir@ +abs_top_srcdir = @abs_top_srcdir@ +ac_ct_CC = @ac_ct_CC@ +ac_ct_DUMPBIN = @ac_ct_DUMPBIN@ +am__include = @am__include@ +am__leading_dot = @am__leading_dot@ +am__quote = @am__quote@ +am__tar = @am__tar@ +am__untar = @am__untar@ +bindir = @bindir@ +build = @build@ +build_alias = @build_alias@ +build_cpu = @build_cpu@ +build_os = @build_os@ +build_vendor = @build_vendor@ +builddir = @builddir@ +datadir = @datadir@ +datarootdir = @datarootdir@ +docdir = @docdir@ +dvidir = @dvidir@ +exec_prefix = @exec_prefix@ +host = @host@ +host_alias = @host_alias@ +host_cpu = @host_cpu@ +host_os = @host_os@ +host_vendor = @host_vendor@ +htmldir = @htmldir@ +includedir = @includedir@ +infodir = @infodir@ +install_sh = @install_sh@ +libdir = @libdir@ +libexecdir = @libexecdir@ +localedir = @localedir@ +localstatedir = @localstatedir@ +lt_ECHO = @lt_ECHO@ +mandir = @mandir@ +mkdir_p = @mkdir_p@ +oldincludedir = @oldincludedir@ +pdfdir = @pdfdir@ +pkgpyexecdir = @pkgpyexecdir@ +pkgpythondir = @pkgpythondir@ +prefix = @prefix@ +program_transform_name = @program_transform_name@ +psdir = @psdir@ +pyexecdir = @pyexecdir@ +pythondir = @pythondir@ +sbindir = @sbindir@ +sharedstatedir = @sharedstatedir@ +srcdir = @srcdir@ +sysconfdir = @sysconfdir@ +target_alias = @target_alias@ +top_build_prefix = @top_build_prefix@ +top_builddir = @top_builddir@ +top_srcdir = @top_srcdir@ +pyexec_LTLIBRARIES = _dbus_bindings.la +AM_CPPFLAGS = -I$(top_srcdir)/include $(DBUS_CFLAGS) $(PYTHON_INCLUDES) +AM_LDFLAGS = -module -avoid-version -export-symbols-regex init_dbus_bindings \ + $(DBUS_LIBS) + +_dbus_bindings_la_SOURCES = \ + abstract.c \ + bus.c \ + bytes.c \ + conn.c \ + conn-internal.h \ + conn-methods.c \ + containers.c \ + dbus_bindings-internal.h \ + debug.c \ + exceptions.c \ + float.c \ + generic.c \ + int.c \ + libdbusconn.c \ + mainloop.c \ + message-append.c \ + message.c \ + message-get-args.c \ + message-internal.h \ + module.c \ + pending-call.c \ + server.c \ + signature.c \ + string.c \ + types-internal.h \ + validation.c + +check_c_sources = $(_dbus_bindings_la_SOURCES) +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .lo .o .obj +$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(top_srcdir)/tools/check-coding-style.mk $(am__configure_deps) + @for dep in $?; do \ + case '$(am__configure_deps)' in \ + *$$dep*) \ + ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \ + && { if test -f $@; then exit 0; else break; fi; }; \ + exit 1;; \ + esac; \ + done; \ + echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu _dbus_bindings/Makefile'; \ + $(am__cd) $(top_srcdir) && \ + $(AUTOMAKE) --gnu _dbus_bindings/Makefile +.PRECIOUS: Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + @case '$?' in \ + *config.status*) \ + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \ + *) \ + echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \ + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \ + esac; + +$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh + +$(top_srcdir)/configure: $(am__configure_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(ACLOCAL_M4): $(am__aclocal_m4_deps) + cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh +$(am__aclocal_m4_deps): +install-pyexecLTLIBRARIES: $(pyexec_LTLIBRARIES) + @$(NORMAL_INSTALL) + test -z "$(pyexecdir)" || $(MKDIR_P) "$(DESTDIR)$(pyexecdir)" + @list='$(pyexec_LTLIBRARIES)'; test -n "$(pyexecdir)" || list=; \ + list2=; for p in $$list; do \ + if test -f $$p; then \ + list2="$$list2 $$p"; \ + else :; fi; \ + done; \ + test -z "$$list2" || { \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(pyexecdir)'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(pyexecdir)"; \ + } + +uninstall-pyexecLTLIBRARIES: + @$(NORMAL_UNINSTALL) + @list='$(pyexec_LTLIBRARIES)'; test -n "$(pyexecdir)" || list=; \ + for p in $$list; do \ + $(am__strip_dir) \ + echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(pyexecdir)/$$f'"; \ + $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(pyexecdir)/$$f"; \ + done + +clean-pyexecLTLIBRARIES: + -test -z "$(pyexec_LTLIBRARIES)" || rm -f $(pyexec_LTLIBRARIES) + @list='$(pyexec_LTLIBRARIES)'; for p in $$list; do \ + dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \ + test "$$dir" != "$$p" || dir=.; \ + echo "rm -f \"$${dir}/so_locations\""; \ + rm -f "$${dir}/so_locations"; \ + done +_dbus_bindings.la: $(_dbus_bindings_la_OBJECTS) $(_dbus_bindings_la_DEPENDENCIES) + $(AM_V_CCLD)$(LINK) -rpath $(pyexecdir) $(_dbus_bindings_la_OBJECTS) $(_dbus_bindings_la_LIBADD) $(LIBS) + +mostlyclean-compile: + -rm -f *.$(OBJEXT) + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/abstract.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bus.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/bytes.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/conn-methods.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/conn.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/containers.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/debug.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/exceptions.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/float.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/generic.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/int.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/libdbusconn.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/mainloop.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/message-append.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/message-get-args.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/message.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/module.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/pending-call.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/server.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/signature.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/string.Plo@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/validation.Plo@am__quote@ + +.c.o: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@am__fastdepCC_FALSE@ $(AM_V_CC) @AM_BACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c $< + +.c.obj: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'` +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po +@am__fastdepCC_FALSE@ $(AM_V_CC) @AM_BACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'` + +.c.lo: +@am__fastdepCC_TRUE@ $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $< +@am__fastdepCC_TRUE@ $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo +@am__fastdepCC_FALSE@ $(AM_V_CC) @AM_BACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ +@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $< + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + mkid -fID $$unique +tags: TAGS + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + set x; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + shift; \ + if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \ + test -n "$$unique" || unique=$$empty_fix; \ + if test $$# -gt 0; then \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + "$$@" $$unique; \ + else \ + $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$unique; \ + fi; \ + fi +ctags: CTAGS +CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) '{ files[$$0] = 1; nonempty = 1; } \ + END { if (nonempty) { for (i in files) print i; }; }'`; \ + test -z "$(CTAGS_ARGS)$$unique" \ + || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \ + $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && $(am__cd) $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) "$$here" + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags + +distdir: $(DISTFILES) + @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \ + list='$(DISTFILES)'; \ + dist_files=`for file in $$list; do echo $$file; done | \ + sed -e "s|^$$srcdirstrip/||;t" \ + -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \ + case $$dist_files in \ + */*) $(MKDIR_P) `echo "$$dist_files" | \ + sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \ + sort -u` ;; \ + esac; \ + for file in $$dist_files; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + if test -d $$d/$$file; then \ + dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test -d "$(distdir)/$$file"; then \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \ + find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \ + fi; \ + cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \ + else \ + test -f "$(distdir)/$$file" \ + || cp -p $$d/$$file "$(distdir)/$$file" \ + || exit 1; \ + fi; \ + done +check-am: all-am + $(MAKE) $(AM_MAKEFLAGS) check-local +check: check-am +all-am: Makefile $(LTLIBRARIES) +installdirs: + for dir in "$(DESTDIR)$(pyexecdir)"; do \ + test -z "$$dir" || $(MKDIR_P) "$$dir"; \ + done +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES) + -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libtool clean-pyexecLTLIBRARIES \ + mostlyclean-am + +distclean: distclean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +distclean-am: clean-am distclean-compile distclean-generic \ + distclean-tags + +dvi: dvi-am + +dvi-am: + +html: html-am + +html-am: + +info: info-am + +info-am: + +install-data-am: + +install-dvi: install-dvi-am + +install-dvi-am: + +install-exec-am: install-pyexecLTLIBRARIES + +install-html: install-html-am + +install-html-am: + +install-info: install-info-am + +install-info-am: + +install-man: + +install-pdf: install-pdf-am + +install-pdf-am: + +install-ps: install-ps-am + +install-ps-am: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + -rm -rf ./$(DEPDIR) + -rm -f Makefile +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +pdf: pdf-am + +pdf-am: + +ps: ps-am + +ps-am: + +uninstall-am: uninstall-pyexecLTLIBRARIES + +.MAKE: check-am install-am install-strip + +.PHONY: CTAGS GTAGS all all-am check check-am check-local clean \ + clean-generic clean-libtool clean-pyexecLTLIBRARIES ctags \ + distclean distclean-compile distclean-generic \ + distclean-libtool distclean-tags distdir dvi dvi-am html \ + html-am info info-am install install-am install-data \ + install-data-am install-dvi install-dvi-am install-exec \ + install-exec-am install-html install-html-am install-info \ + install-info-am install-man install-pdf install-pdf-am \ + install-ps install-ps-am install-pyexecLTLIBRARIES \ + install-strip installcheck installcheck-am installdirs \ + maintainer-clean maintainer-clean-generic mostlyclean \ + mostlyclean-compile mostlyclean-generic mostlyclean-libtool \ + pdf pdf-am ps ps-am tags uninstall uninstall-am \ + uninstall-pyexecLTLIBRARIES + +check-local:: + @fail=0; \ + cd $(srcdir) || exit $$?; \ + if test -n "$(check_misc_sources)"; then \ + echo check-coding-style.mk: checking misc sources...; \ + top_srcdir=$(top_srcdir) \ + sh $(top_srcdir)/tools/check-whitespace.sh \ + $(check_misc_sources) || fail=1; \ + fi; \ + if test -n "$(check_py_sources)"; then \ + echo check-coding-style.mk: checking Python sources...; \ + top_srcdir=$(top_srcdir) \ + sh $(top_srcdir)/tools/check-py-style.sh \ + $(check_py_sources) || fail=1; \ + fi;\ + if test -n "$(check_c_sources)"; then \ + echo check-coding-style.mk: checking C sources...; \ + top_srcdir=$(top_srcdir) \ + sh $(top_srcdir)/tools/check-c-style.sh \ + $(check_c_sources) || fail=1; \ + fi;\ + if test yes = "@ENABLE_CODING_STYLE_CHECKS@"; then \ + exit "$$fail";\ + else \ + exit 0;\ + fi + +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/_dbus_bindings/abstract.c b/_dbus_bindings/abstract.c new file mode 100644 index 0000000..9a4f350 --- /dev/null +++ b/_dbus_bindings/abstract.c @@ -0,0 +1,664 @@ +/* Subclasses of built-in Python types supporting extra D-Bus functionality. + * + * Copyright (C) 2006-2007 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include + +#include "dbus_bindings-internal.h" +#include "types-internal.h" + +/* Dict indexed by object IDs, whose values are nonzero variant levels + * for immutable variable-sized D-Bus data types (_LongBase, _StrBase, Struct). + * + * This is a strange way to store them, but adding a __dict__ to the offending + * objects seems even more error-prone, given that their sizes are variable! + */ +PyObject *_dbus_py_variant_levels = NULL; + +long +dbus_py_variant_level_get(PyObject *obj) +{ + PyObject *vl_obj; + PyObject *key = PyLong_FromVoidPtr(obj); + + if (!key) { + return 0; + } + + vl_obj = PyDict_GetItem(_dbus_py_variant_levels, key); + Py_DECREF(key); + + if (!vl_obj) + return 0; + return PyInt_AsLong(vl_obj); +} + +dbus_bool_t +dbus_py_variant_level_set(PyObject *obj, long variant_level) +{ + /* key is the object's ID (= pointer) to avoid referencing it */ + PyObject *key = PyLong_FromVoidPtr(obj); + + if (!key) { + return FALSE; + } + + if (variant_level <= 0) { + if (PyDict_GetItem (_dbus_py_variant_levels, key)) { + if (PyDict_DelItem (_dbus_py_variant_levels, key) < 0) { + Py_DECREF(key); + return FALSE; + } + } + } + else { + PyObject *vl_obj = PyInt_FromLong(variant_level); + if (!vl_obj) { + Py_DECREF(key); + return FALSE; + } + if (PyDict_SetItem (_dbus_py_variant_levels, key, vl_obj) < 0) { + Py_DECREF(key); + return FALSE; + } + } + Py_DECREF(key); + return TRUE; +} + +PyObject * +dbus_py_variant_level_getattro(PyObject *obj, PyObject *name) +{ + PyObject *key, *value; + + if (PyString_Check(name)) { + Py_INCREF(name); + } + else if (PyUnicode_Check(name)) { + name = PyUnicode_AsEncodedString(name, NULL, NULL); + if (!name) { + return NULL; + } + } + else { + PyErr_SetString(PyExc_TypeError, "attribute name must be string"); + return NULL; + } + + if (strcmp(PyString_AS_STRING(name), "variant_level")) { + value = PyObject_GenericGetAttr(obj, name); + Py_DECREF(name); + return value; + } + + Py_DECREF(name); + + key = PyLong_FromVoidPtr(obj); + + if (!key) { + return NULL; + } + + value = PyDict_GetItem(_dbus_py_variant_levels, key); + Py_DECREF(key); + + if (!value) + return PyInt_FromLong(0); + Py_INCREF(value); + return value; +} + +/* To be invoked by destructors. Clear the variant level without touching the + * exception state */ +void +dbus_py_variant_level_clear(PyObject *self) +{ + PyObject *et, *ev, *etb; + + /* avoid clobbering any pending exception */ + PyErr_Fetch(&et, &ev, &etb); + if (!dbus_py_variant_level_set(self, 0)) { + /* should never happen */ + PyErr_WriteUnraisable(self); + } + PyErr_Restore(et, ev, etb); +} + +/* Support code for int subclasses. ================================== */ + +PyDoc_STRVAR(DBusPythonInt_tp_doc,\ +"Base class for int subclasses with a ``variant_level`` attribute.\n" +"Do not rely on the existence of this class outside dbus-python.\n" +); + +static PyMemberDef DBusPythonInt_tp_members[] = { + {"variant_level", T_LONG, offsetof(DBusPyIntBase, variant_level), + READONLY, + "The number of nested variants wrapping the real data. " + "0 if not in a variant."}, + {NULL}, +}; + +static PyObject * +DBusPythonInt_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self; + long variantness = 0; + static char *argnames[] = {"variant_level", NULL}; + + if (PyTuple_Size(args) > 1) { + PyErr_SetString(PyExc_TypeError, + "__new__ takes at most one positional parameter"); + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs, + "|l:__new__", argnames, + &variantness)) return NULL; + if (variantness < 0) { + PyErr_SetString(PyExc_ValueError, + "variant_level must be non-negative"); + return NULL; + } + + self = (PyInt_Type.tp_new)(cls, args, NULL); + if (self) { + ((DBusPyIntBase *)self)->variant_level = variantness; + } + return self; +} + +static PyObject * +DBusPythonInt_tp_repr(PyObject *self) +{ + PyObject *parent_repr = (PyInt_Type.tp_repr)(self); + long variant_level = ((DBusPyIntBase *)self)->variant_level; + PyObject *my_repr; + + if (!parent_repr) return NULL; + if (variant_level > 0) { + my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)", + self->ob_type->tp_name, + PyString_AS_STRING(parent_repr), + variant_level); + } + else { + my_repr = PyString_FromFormat("%s(%s)", self->ob_type->tp_name, + PyString_AS_STRING(parent_repr)); + } + /* whether my_repr is NULL or not: */ + Py_DECREF(parent_repr); + return my_repr; +} + +PyTypeObject DBusPyIntBase_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "_dbus_bindings._IntBase", + sizeof(DBusPyIntBase), + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + DBusPythonInt_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + DBusPythonInt_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + DBusPythonInt_tp_members, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&PyInt_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + PyType_GenericAlloc, /* tp_alloc */ + DBusPythonInt_tp_new, /* tp_new */ + PyObject_Del, /* tp_free */ +}; + +/* Support code for float subclasses. ================================ */ + +/* There's only one subclass at the moment (Double) but these are factored +out to make room for Float later. (Float is implemented and #if'd out) */ + +PyDoc_STRVAR(DBusPythonFloat_tp_doc,\ +"Base class for float subclasses with a ``variant_level`` attribute.\n" +"Do not rely on the existence of this class outside dbus-python.\n" +); + +static PyMemberDef DBusPythonFloat_tp_members[] = { + {"variant_level", T_LONG, offsetof(DBusPyFloatBase, variant_level), + READONLY, + "The number of nested variants wrapping the real data. " + "0 if not in a variant."}, + {NULL}, +}; + +static PyObject * +DBusPythonFloat_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self; + long variantness = 0; + static char *argnames[] = {"variant_level", NULL}; + + if (PyTuple_Size(args) > 1) { + PyErr_SetString(PyExc_TypeError, + "__new__ takes at most one positional parameter"); + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs, + "|l:__new__", argnames, + &variantness)) return NULL; + if (variantness < 0) { + PyErr_SetString(PyExc_ValueError, + "variant_level must be non-negative"); + return NULL; + } + + self = (PyFloat_Type.tp_new)(cls, args, NULL); + if (self) { + ((DBusPyFloatBase *)self)->variant_level = variantness; + } + return self; +} + +static PyObject * +DBusPythonFloat_tp_repr(PyObject *self) +{ + PyObject *parent_repr = (PyFloat_Type.tp_repr)(self); + long variant_level = ((DBusPyFloatBase *)self)->variant_level; + PyObject *my_repr; + + if (!parent_repr) return NULL; + if (variant_level > 0) { + my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)", + self->ob_type->tp_name, + PyString_AS_STRING(parent_repr), + variant_level); + } + else { + my_repr = PyString_FromFormat("%s(%s)", self->ob_type->tp_name, + PyString_AS_STRING(parent_repr)); + } + /* whether my_repr is NULL or not: */ + Py_DECREF(parent_repr); + return my_repr; +} + +PyTypeObject DBusPyFloatBase_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "_dbus_bindings._FloatBase", + sizeof(DBusPyFloatBase), + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + DBusPythonFloat_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + DBusPythonFloat_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + DBusPythonFloat_tp_members, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&PyFloat_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + DBusPythonFloat_tp_new, /* tp_new */ +}; + +/* Support code for str subclasses ================================== */ + +PyDoc_STRVAR(DBusPythonString_tp_doc,\ +"Base class for str subclasses with a ``variant_level`` attribute.\n" +"Do not rely on the existence of this class outside dbus-python.\n" +); + +static PyObject * +DBusPythonString_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self; + long variantness = 0; + static char *argnames[] = {"variant_level", NULL}; + + if (PyTuple_Size(args) > 1) { + PyErr_SetString(PyExc_TypeError, + "__new__ takes at most one positional parameter"); + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs, + "|l:__new__", argnames, + &variantness)) return NULL; + if (variantness < 0) { + PyErr_SetString(PyExc_ValueError, + "variant_level must be non-negative"); + return NULL; + } + + self = (PyString_Type.tp_new)(cls, args, NULL); + if (self) { + if (!dbus_py_variant_level_set(self, variantness)) { + Py_DECREF(self); + return NULL; + } + } + return self; +} + +static PyObject * +DBusPythonString_tp_repr(PyObject *self) +{ + PyObject *parent_repr = (PyString_Type.tp_repr)(self); + PyObject *vl_obj; + PyObject *my_repr; + long variant_level; + + if (!parent_repr) return NULL; + vl_obj = PyObject_GetAttr(self, dbus_py_variant_level_const); + if (!vl_obj) { + Py_DECREF(parent_repr); + return NULL; + } + variant_level = PyInt_AsLong(vl_obj); + Py_DECREF(vl_obj); + if (variant_level > 0) { + my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)", + self->ob_type->tp_name, + PyString_AS_STRING(parent_repr), + variant_level); + } + else { + my_repr = PyString_FromFormat("%s(%s)", self->ob_type->tp_name, + PyString_AS_STRING(parent_repr)); + } + /* whether my_repr is NULL or not: */ + Py_DECREF(parent_repr); + return my_repr; +} + +static void +DBusPyStrBase_tp_dealloc(PyObject *self) +{ + dbus_py_variant_level_clear(self); + (PyString_Type.tp_dealloc)(self); +} + +PyTypeObject DBusPyStrBase_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "_dbus_bindings._StrBase", + 0, + 0, + DBusPyStrBase_tp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + DBusPythonString_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + dbus_py_variant_level_getattro, /* tp_getattro */ + dbus_py_immutable_setattro, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + DBusPythonString_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&PyString_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + DBusPythonString_tp_new, /* tp_new */ +}; + +/* Support code for long subclasses ================================= */ + +PyDoc_STRVAR(DBusPythonLong_tp_doc,\ +"Base class for ``long`` subclasses with a ``variant_level`` attribute.\n" +"Do not rely on the existence of this class outside dbus-python.\n" +); + +static PyObject * +DBusPythonLong_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self; + long variantness = 0; + static char *argnames[] = {"variant_level", NULL}; + + if (PyTuple_Size(args) > 1) { + PyErr_SetString(PyExc_TypeError, + "__new__ takes at most one positional parameter"); + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs, + "|l:__new__", argnames, + &variantness)) return NULL; + if (variantness < 0) { + PyErr_SetString(PyExc_ValueError, + "variant_level must be non-negative"); + return NULL; + } + + self = (PyLong_Type.tp_new)(cls, args, NULL); + if (self) { + if (!dbus_py_variant_level_set(self, variantness)) { + Py_DECREF(self); + return NULL; + } + } + return self; +} + +static PyObject * +DBusPythonLong_tp_repr(PyObject *self) +{ + PyObject *parent_repr = (PyLong_Type.tp_repr)(self); + PyObject *vl_obj; + PyObject *my_repr; + long variant_level; + + if (!parent_repr) return NULL; + vl_obj = PyObject_GetAttr(self, dbus_py_variant_level_const); + if (!vl_obj) { + Py_DECREF(parent_repr); + return NULL; + } + variant_level = PyInt_AsLong(vl_obj); + Py_DECREF(vl_obj); + if (variant_level) { + my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)", + self->ob_type->tp_name, + PyString_AS_STRING(parent_repr), + variant_level); + } + else { + my_repr = PyString_FromFormat("%s(%s)", self->ob_type->tp_name, + PyString_AS_STRING(parent_repr)); + } + /* whether my_repr is NULL or not: */ + Py_DECREF(parent_repr); + return my_repr; +} + +static void +DBusPyLongBase_tp_dealloc(PyObject *self) +{ + dbus_py_variant_level_clear(self); + (PyLong_Type.tp_dealloc)(self); +} + +PyTypeObject DBusPyLongBase_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "_dbus_bindings._LongBase", + 0, + 0, + DBusPyLongBase_tp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + DBusPythonLong_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + dbus_py_variant_level_getattro, /* tp_getattro */ + dbus_py_immutable_setattro, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + DBusPythonLong_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&PyLong_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + DBusPythonLong_tp_new, /* tp_new */ +}; + +PyObject *dbus_py_variant_level_const = NULL; +PyObject *dbus_py_signature_const = NULL; +PyObject *dbus_py__dbus_object_path__const = NULL; + +dbus_bool_t +dbus_py_init_abstract(void) +{ + _dbus_py_variant_levels = PyDict_New(); + if (!_dbus_py_variant_levels) return 0; + + dbus_py__dbus_object_path__const = PyString_InternFromString("__dbus_object_path__"); + if (!dbus_py__dbus_object_path__const) return 0; + + dbus_py_variant_level_const = PyString_InternFromString("variant_level"); + if (!dbus_py_variant_level_const) return 0; + + dbus_py_signature_const = PyString_InternFromString("signature"); + if (!dbus_py_signature_const) return 0; + + DBusPyIntBase_Type.tp_base = &PyInt_Type; + if (PyType_Ready(&DBusPyIntBase_Type) < 0) return 0; + /* disable the tp_print copied from PyInt_Type, so tp_repr gets called as + desired */ + DBusPyIntBase_Type.tp_print = NULL; + + DBusPyFloatBase_Type.tp_base = &PyFloat_Type; + if (PyType_Ready(&DBusPyFloatBase_Type) < 0) return 0; + DBusPyFloatBase_Type.tp_print = NULL; + + DBusPyLongBase_Type.tp_base = &PyLong_Type; + if (PyType_Ready(&DBusPyLongBase_Type) < 0) return 0; + DBusPyLongBase_Type.tp_print = NULL; + + DBusPyStrBase_Type.tp_base = &PyString_Type; + if (PyType_Ready(&DBusPyStrBase_Type) < 0) return 0; + DBusPyStrBase_Type.tp_print = NULL; + + return 1; +} + +dbus_bool_t +dbus_py_insert_abstract_types(PyObject *this_module) +{ + Py_INCREF(&DBusPyIntBase_Type); + Py_INCREF(&DBusPyLongBase_Type); + Py_INCREF(&DBusPyStrBase_Type); + Py_INCREF(&DBusPyFloatBase_Type); + if (PyModule_AddObject(this_module, "_IntBase", + (PyObject *)&DBusPyIntBase_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "_LongBase", + (PyObject *)&DBusPyLongBase_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "_StrBase", + (PyObject *)&DBusPyStrBase_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "_FloatBase", + (PyObject *)&DBusPyFloatBase_Type) < 0) return 0; + + return 1; +} diff --git a/_dbus_bindings/bus.c b/_dbus_bindings/bus.c new file mode 100644 index 0000000..7ab0d95 --- /dev/null +++ b/_dbus_bindings/bus.c @@ -0,0 +1,187 @@ +/* Implementation of Bus, a subtype of Connection. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" +#include "conn-internal.h" + +PyObject * +DBusPyConnection_NewForBus(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *first = NULL, *mainloop = NULL; + DBusConnection *conn; + DBusError error; + Connection *self; + static char *argnames[] = {"address_or_type", "mainloop", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OO", argnames, + &first, &mainloop)) { + return NULL; + } + + dbus_error_init(&error); + + if (first && PyString_Check(first)) { + dbus_bool_t ret; + + /* It's a custom address. First connect to it, then register. */ + + self = (Connection *)(DBusPyConnection_Type.tp_new)(cls, args, kwargs); + if (!self) return NULL; + TRACE(self); + + Py_BEGIN_ALLOW_THREADS + ret = dbus_bus_register(self->conn, &error); + Py_END_ALLOW_THREADS + if (!ret) { + DBusPyException_ConsumeError(&error); + Py_DECREF(self); + return NULL; + } + + return (PyObject *)self; + } + else if (!first || PyInt_Check(first)) { + long type; + PyObject *libdbusconn; + PyObject *new_args; + PyObject *new_kwargs; + + /* If the first argument isn't a string, it must be an integer + representing one of the well-known bus types. The default is + DBUS_BUS_SESSION. */ + + if (first) { + type = PyInt_AsLong(first); + + if (type != DBUS_BUS_SESSION && type != DBUS_BUS_SYSTEM + && type != DBUS_BUS_STARTER) { + PyErr_Format(PyExc_ValueError, "Unknown bus type %ld", type); + return NULL; + } + } + else { + type = DBUS_BUS_SESSION; + } + + Py_BEGIN_ALLOW_THREADS + conn = dbus_bus_get_private(type, &error); + Py_END_ALLOW_THREADS + + if (!conn) { + DBusPyException_ConsumeError(&error); + return NULL; + } + + libdbusconn = DBusPyLibDBusConnection_New (conn); + dbus_connection_unref (conn); + + if (!libdbusconn) + return NULL; + + new_args = PyTuple_Pack(2, libdbusconn, mainloop ? mainloop : Py_None); + Py_DECREF(libdbusconn); + + if (!new_args) { + return NULL; + } + + new_kwargs = PyDict_New(); + + if (!new_kwargs) { + Py_DECREF(new_args); + return NULL; + } + + self = (Connection *)(DBusPyConnection_Type.tp_new)(cls, new_args, + new_kwargs); + Py_DECREF(new_args); + Py_DECREF(new_kwargs); + + return (PyObject *)self; /* whether NULL or not */ + } + else { + PyErr_SetString(PyExc_TypeError, "A string address or an integer " + "bus type is required"); + return NULL; + } +} + +PyObject * +DBusPyConnection_GetUniqueName(Connection *self, PyObject *args UNUSED) +{ + const char *name; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + Py_BEGIN_ALLOW_THREADS + name = dbus_bus_get_unique_name(self->conn); + Py_END_ALLOW_THREADS + if (!name) { + return DBusPyException_SetString("This connection has no unique name " + "yet"); + } + return PyString_FromString(name); +} + +PyObject * +DBusPyConnection_SetUniqueName(Connection *self, PyObject *args) +{ + const char *old_name, *new_name; + + if (!PyArg_ParseTuple(args, "s:set_unique_name", &new_name)) { + return NULL; + } + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + + /* libdbus will assert if we try to set a unique name when there's + * already one, so we need to make sure that can't happen. + * (Thanks, libdbus.) + * + * The things that can set the unique name are: + * - this function - but we don't release the GIL, so only one instance of + * this function can run + * - dbus_bus_get - but this is only called in a __new__ or __new__-like + * function, so the new connection isn't available to other code yet + * and this function can't be called on it + * - dbus_bus_register - same as dbus_bus_get + * + * Code outside dbus-python shouldn't be setting the unique name, because + * we're using a private connection; we have to trust the authors + * of mainloop bindings not to do silly things like that. + */ + old_name = dbus_bus_get_unique_name(self->conn); + if (old_name != NULL) { + PyErr_Format(PyExc_ValueError, "This connection already has a " + "unique name: '%s'", old_name); + return NULL; + } + dbus_bus_set_unique_name(self->conn, new_name); + + Py_RETURN_NONE; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/bytes.c b/_dbus_bindings/bytes.c new file mode 100644 index 0000000..a5648fe --- /dev/null +++ b/_dbus_bindings/bytes.c @@ -0,0 +1,267 @@ +/* D-Bus Byte and ByteArray types. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include + +#include "dbus_bindings-internal.h" +#include "types-internal.h" + +PyDoc_STRVAR(Byte_tp_doc, +"An unsigned byte: a subtype of int, with range restricted to [0, 255].\n" +"\n" +"A Byte b may be converted to a str of length 1 via str(b) == chr(b).\n" +"\n" +"Most of the time you don't want to use this class - it mainly exists\n" +"for symmetry with the other D-Bus types. See `dbus.ByteArray` for a\n" +"better way to handle arrays of Byte.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.Byte(integer or str of length 1[, variant_level])\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a byte, this is represented in Python by a\n" +" Byte with variant_level==2.\n" +); + +static PyObject * +Byte_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *obj; + PyObject *tuple; + long variantness = 0; + static char *argnames[] = {"variant_level", NULL}; + + if (PyTuple_Size(args) > 1) { + PyErr_SetString(PyExc_TypeError, "Byte constructor takes no more " + "than one positional argument"); + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs, + "|l:__new__", argnames, + &variantness)) return NULL; + if (variantness < 0) { + PyErr_SetString(PyExc_ValueError, + "variant_level must be non-negative"); + return NULL; + } + + /* obj is only a borrowed ref for the moment */ + obj = PyTuple_GetItem(args, 0); + + if (PyString_Check(obj)) { + /* string of length 1, we hope */ + if (PyString_GET_SIZE(obj) != 1) { + goto bad_arg; + } + obj = PyInt_FromLong((unsigned char)(PyString_AS_STRING(obj)[0])); + } + else if (PyInt_Check(obj)) { + long i = PyInt_AS_LONG(obj); + + if (obj->ob_type == cls && + ((DBusPyIntBase *)obj)->variant_level == variantness) { + Py_INCREF(obj); + return obj; + } + if (i < 0 || i > 255) goto bad_range; + /* else make it a new reference */ + Py_INCREF(obj); + } + else { + goto bad_arg; + } + + tuple = Py_BuildValue("(O)", obj); + if (!tuple) return NULL; + Py_DECREF(obj); + obj = NULL; + + obj = DBusPyIntBase_Type.tp_new(cls, tuple, kwargs); + Py_DECREF(tuple); + tuple = NULL; + return obj; + +bad_arg: + PyErr_SetString(PyExc_TypeError, "Expected a string of length 1, " + "or an int in the range 0-255"); + return NULL; +bad_range: + PyErr_SetString(PyExc_ValueError, "Integer outside range 0-255"); + return NULL; +} + +static PyObject * +Byte_tp_str(PyObject *self) +{ + unsigned char str[2] = { (unsigned char)PyInt_AS_LONG(self), 0 }; + return PyString_FromStringAndSize((char *)str, 1); +} + +PyTypeObject DBusPyByte_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Byte", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + Byte_tp_str, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Byte_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&PyInt_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + Byte_new, /* tp_new */ +}; + +PyDoc_STRVAR(ByteArray_tp_doc, +"ByteArray is a subtype of str which can be used when you want an\n" +"efficient immutable representation of a D-Bus byte array (signature 'ay').\n" +"\n" +"By default, when byte arrays are converted from D-Bus to Python, they\n" +"come out as a `dbus.Array` of `dbus.Byte`. This is just for symmetry with\n" +"the other D-Bus types - in practice, what you usually want is the byte\n" +"array represented as a string, using this class. To get this, pass the\n" +"``byte_arrays=True`` keyword argument to any of these methods:\n" +"\n" +"* any D-Bus method proxy, or ``connect_to_signal``, on the objects returned\n" +" by `Bus.get_object`\n" +"* any D-Bus method on a `dbus.Interface`\n" +"* `dbus.Interface.connect_to_signal`\n" +"* `Bus.add_signal_receiver`\n" +"\n" +"Import via::\n" +"\n" +" from dbus import ByteArray\n" +"\n" +"Constructor::\n" +"\n" +" ByteArray(str)\n" +); + +PyTypeObject DBusPyByteArray_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.ByteArray", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + ByteArray_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyStrBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ +}; + +dbus_bool_t +dbus_py_init_byte_types(void) +{ + DBusPyByte_Type.tp_base = &DBusPyIntBase_Type; + if (PyType_Ready(&DBusPyByte_Type) < 0) return 0; + DBusPyByte_Type.tp_print = NULL; + + DBusPyByteArray_Type.tp_base = &DBusPyStrBase_Type; + if (PyType_Ready(&DBusPyByteArray_Type) < 0) return 0; + DBusPyByteArray_Type.tp_print = NULL; + + return 1; +} + +dbus_bool_t +dbus_py_insert_byte_types(PyObject *this_module) +{ + Py_INCREF(&DBusPyByte_Type); + if (PyModule_AddObject(this_module, "Byte", + (PyObject *)&DBusPyByte_Type) < 0) return 0; + Py_INCREF(&DBusPyByteArray_Type); + if (PyModule_AddObject(this_module, "ByteArray", + (PyObject *)&DBusPyByteArray_Type) < 0) return 0; + + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/conn-internal.h b/_dbus_bindings/conn-internal.h new file mode 100644 index 0000000..f4c7a80 --- /dev/null +++ b/_dbus_bindings/conn-internal.h @@ -0,0 +1,67 @@ +/* _dbus_bindings internal API. For use within _dbus_bindings only. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#ifndef DBUS_BINDINGS_CONN_H +#define DBUS_BINDINGS_CONN_H + +#include "dbus_bindings-internal.h" + +typedef struct { + PyObject_HEAD + DBusConnection *conn; + /* A list of filter callbacks. */ + PyObject *filters; + /* A dict mapping object paths to one of: + * - tuples (unregister_callback or None, message_callback) + * - None (meaning unregistration from libdbus is in progress and nobody + * should touch this entry til we're finished) + */ + PyObject *object_paths; + + /* Weak-references list to make Connections weakly referenceable */ + PyObject *weaklist; + + dbus_bool_t has_mainloop; +} Connection; + +typedef struct { + PyObject_HEAD + DBusConnection *conn; +} DBusPyLibDBusConnection; + +extern struct PyMethodDef DBusPyConnection_tp_methods[]; +extern DBusHandlerResult DBusPyConnection_HandleMessage(Connection *, + PyObject *, + PyObject *); +extern PyObject *DBusPyConnection_ExistingFromDBusConnection(DBusConnection *); +extern PyObject *DBusPyConnection_GetObjectPathHandlers(PyObject *self, + PyObject *path); + +extern PyObject *DBusPyConnection_NewForBus(PyTypeObject *cls, PyObject *args, + PyObject *kwargs); +extern PyObject *DBusPyConnection_SetUniqueName(Connection *, PyObject *); +extern PyObject *DBusPyConnection_GetUniqueName(Connection *, PyObject *); + +#endif diff --git a/_dbus_bindings/conn-methods.c b/_dbus_bindings/conn-methods.c new file mode 100644 index 0000000..81c4514 --- /dev/null +++ b/_dbus_bindings/conn-methods.c @@ -0,0 +1,1037 @@ +/* Implementation of normal Python-accessible methods on the _dbus_bindings + * Connection type; separated out to keep the file size manageable. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" +#include "conn-internal.h" + +static void +_object_path_unregister(DBusConnection *conn, void *user_data) +{ + PyGILState_STATE gil = PyGILState_Ensure(); + PyObject *tuple = NULL; + Connection *conn_obj = NULL; + PyObject *callable; + + conn_obj = (Connection *)DBusPyConnection_ExistingFromDBusConnection(conn); + if (!conn_obj) goto out; + TRACE(conn_obj); + + DBG("Connection at %p unregistering object path %s", + conn_obj, PyString_AS_STRING((PyObject *)user_data)); + tuple = DBusPyConnection_GetObjectPathHandlers((PyObject *)conn_obj, (PyObject *)user_data); + if (!tuple) goto out; + if (tuple == Py_None) goto out; + + DBG("%s", "... yes we have handlers for that object path"); + + /* 0'th item is the unregisterer (if that's a word) */ + callable = PyTuple_GetItem(tuple, 0); + if (callable && callable != Py_None) { + DBG("%s", "... and we even have an unregisterer"); + /* any return from the unregisterer is ignored */ + Py_XDECREF(PyObject_CallFunctionObjArgs(callable, conn_obj, NULL)); + } +out: + Py_XDECREF(conn_obj); + Py_XDECREF(tuple); + /* the user_data (a Python str) is no longer ref'd by the DBusConnection */ + Py_XDECREF((PyObject *)user_data); + if (PyErr_Occurred()) { + PyErr_Print(); + } + PyGILState_Release(gil); +} + +static DBusHandlerResult +_object_path_message(DBusConnection *conn, DBusMessage *message, + void *user_data) +{ + DBusHandlerResult ret; + PyGILState_STATE gil = PyGILState_Ensure(); + Connection *conn_obj = NULL; + PyObject *tuple = NULL; + PyObject *msg_obj; + PyObject *callable; /* borrowed */ + + dbus_message_ref(message); + msg_obj = DBusPyMessage_ConsumeDBusMessage(message); + if (!msg_obj) { + ret = DBUS_HANDLER_RESULT_NEED_MEMORY; + goto out; + } + + conn_obj = (Connection *)DBusPyConnection_ExistingFromDBusConnection(conn); + if (!conn_obj) { + ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + goto out; + } + TRACE(conn_obj); + + DBG("Connection at %p messaging object path %s", + conn_obj, PyString_AS_STRING((PyObject *)user_data)); + DBG_DUMP_MESSAGE(message); + tuple = DBusPyConnection_GetObjectPathHandlers((PyObject *)conn_obj, (PyObject *)user_data); + if (!tuple || tuple == Py_None) { + ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + goto out; + } + + DBG("%s", "... yes we have handlers for that object path"); + + /* 1st item (0-based) is the message callback */ + callable = PyTuple_GetItem(tuple, 1); + if (!callable) { + DBG("%s", "... error getting message handler from tuple"); + ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + else if (callable == Py_None) { + /* there was actually no handler after all */ + DBG("%s", "... but those handlers don't do messages"); + ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + else { + DBG("%s", "... and we have a message handler for that object path"); + ret = DBusPyConnection_HandleMessage(conn_obj, msg_obj, callable); + } + +out: + Py_XDECREF(msg_obj); + Py_XDECREF(conn_obj); + Py_XDECREF(tuple); + if (PyErr_Occurred()) { + PyErr_Print(); + } + PyGILState_Release(gil); + return ret; +} + +static const DBusObjectPathVTable _object_path_vtable = { + _object_path_unregister, + _object_path_message, +}; + +static DBusHandlerResult +_filter_message(DBusConnection *conn, DBusMessage *message, void *user_data) +{ + DBusHandlerResult ret; + PyGILState_STATE gil = PyGILState_Ensure(); + Connection *conn_obj = NULL; + PyObject *callable = NULL; + PyObject *msg_obj; +#ifndef DBUS_PYTHON_DISABLE_CHECKS + Py_ssize_t i, size; +#endif + + dbus_message_ref(message); + msg_obj = DBusPyMessage_ConsumeDBusMessage(message); + if (!msg_obj) { + DBG("%s", "OOM while trying to construct Message"); + ret = DBUS_HANDLER_RESULT_NEED_MEMORY; + goto out; + } + + conn_obj = (Connection *)DBusPyConnection_ExistingFromDBusConnection(conn); + if (!conn_obj) { + DBG("%s", "failed to traverse DBusConnection -> Connection weakref"); + ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + goto out; + } + TRACE(conn_obj); + + /* The user_data is a pointer to a Python object. To avoid + * cross-library reference cycles, the DBusConnection isn't allowed + * to reference it. However, as long as the Connection is still + * alive, its ->filters list owns a reference to the same Python + * object, so the object should also still be alive. + * + * To ensure that this works, be careful whenever manipulating the + * filters list! (always put things in the list *before* giving + * them to libdbus, etc.) + */ +#ifdef DBUS_PYTHON_DISABLE_CHECKS + callable = (PyObject *)user_data; +#else + size = PyList_GET_SIZE(conn_obj->filters); + for (i = 0; i < size; i++) { + callable = PyList_GET_ITEM(conn_obj->filters, i); + if (callable == user_data) { + Py_INCREF(callable); + break; + } + else { + callable = NULL; + } + } + + if (!callable) { + DBG("... filter %p has vanished from ->filters, so not calling it", + user_data); + ret = DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + goto out; + } +#endif + + ret = DBusPyConnection_HandleMessage(conn_obj, msg_obj, callable); +out: + Py_XDECREF(msg_obj); + Py_XDECREF(conn_obj); + Py_XDECREF(callable); + PyGILState_Release(gil); + return ret; +} + +PyDoc_STRVAR(Connection__require_main_loop__doc__, +"_require_main_loop()\n\n" +"Raise an exception if this Connection is not bound to any main loop -\n" +"in this state, asynchronous calls, receiving signals and exporting objects\n" +"will not work.\n" +"\n" +"`dbus.mainloop.NULL_MAIN_LOOP` is treated like a valid main loop - if you're\n" +"using that, you presumably know what you're doing.\n"); +static PyObject * +Connection__require_main_loop (Connection *self, PyObject *args UNUSED) +{ + if (!self->has_mainloop) { + PyErr_SetString(PyExc_RuntimeError, + "To make asynchronous calls, receive signals or " + "export objects, D-Bus connections must be attached " + "to a main loop by passing mainloop=... to the " + "constructor or calling " + "dbus.set_default_main_loop(...)"); + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Connection_close__doc__, +"close()\n\n" +"Close the connection."); +static PyObject * +Connection_close (Connection *self, PyObject *args UNUSED) +{ + TRACE(self); + /* Because the user explicitly asked to close the connection, we'll even + let them close shared connections. */ + if (self->conn) { + Py_BEGIN_ALLOW_THREADS + dbus_connection_close(self->conn); + Py_END_ALLOW_THREADS + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Connection_get_is_connected__doc__, +"get_is_connected() -> bool\n\n" +"Return true if this Connection is connected.\n"); +static PyObject * +Connection_get_is_connected (Connection *self, PyObject *args UNUSED) +{ + dbus_bool_t ret; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + Py_BEGIN_ALLOW_THREADS + ret = dbus_connection_get_is_connected(self->conn); + Py_END_ALLOW_THREADS + return PyBool_FromLong(ret); +} + +PyDoc_STRVAR(Connection_get_is_authenticated__doc__, +"get_is_authenticated() -> bool\n\n" +"Return true if this Connection was ever authenticated.\n"); +static PyObject * +Connection_get_is_authenticated (Connection *self, PyObject *args UNUSED) +{ + dbus_bool_t ret; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + Py_BEGIN_ALLOW_THREADS + ret = dbus_connection_get_is_authenticated(self->conn); + Py_END_ALLOW_THREADS + return PyBool_FromLong(ret); +} + +PyDoc_STRVAR(Connection_set_exit_on_disconnect__doc__, +"set_exit_on_disconnect(bool)\n\n" +"Set whether the C function ``_exit`` will be called when this Connection\n" +"becomes disconnected. This will cause the program to exit without calling\n" +"any cleanup code or exit handlers.\n" +"\n" +"The default is for this feature to be disabled for Connections and enabled\n" +"for Buses.\n"); +static PyObject * +Connection_set_exit_on_disconnect (Connection *self, PyObject *args) +{ + int exit_on_disconnect; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + if (!PyArg_ParseTuple(args, "i:set_exit_on_disconnect", + &exit_on_disconnect)) { + return NULL; + } + Py_BEGIN_ALLOW_THREADS + dbus_connection_set_exit_on_disconnect(self->conn, + exit_on_disconnect ? 1 : 0); + Py_END_ALLOW_THREADS + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Connection_send_message__doc__, +"send_message(msg) -> long\n\n" +"Queue the given message for sending, and return the message serial number.\n" +"\n" +":Parameters:\n" +" `msg` : dbus.lowlevel.Message\n" +" The message to be sent.\n" +); +static PyObject * +Connection_send_message(Connection *self, PyObject *args) +{ + dbus_bool_t ok; + PyObject *obj; + DBusMessage *msg; + dbus_uint32_t serial; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + if (!PyArg_ParseTuple(args, "O", &obj)) return NULL; + + msg = DBusPyMessage_BorrowDBusMessage(obj); + if (!msg) return NULL; + + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_send(self->conn, msg, &serial); + Py_END_ALLOW_THREADS + + if (!ok) { + return PyErr_NoMemory(); + } + + return PyLong_FromUnsignedLong(serial); +} + +/* The timeout is in seconds here, since that's conventional in Python. */ +PyDoc_STRVAR(Connection_send_message_with_reply__doc__, +"send_message_with_reply(msg, reply_handler, timeout_s=-1, " +"require_main_loop=False) -> dbus.lowlevel.PendingCall\n\n" +"Queue the message for sending; expect a reply via the returned PendingCall,\n" +"which can also be used to cancel the pending call.\n" +"\n" +":Parameters:\n" +" `msg` : dbus.lowlevel.Message\n" +" The message to be sent\n" +" `reply_handler` : callable\n" +" Asynchronous reply handler: will be called with one positional\n" +" parameter, a Message instance representing the reply.\n" +" `timeout_s` : float\n" +" If the reply takes more than this many seconds, a timeout error\n" +" will be created locally and raised instead. If this timeout is\n" +" negative (default), a sane default (supplied by libdbus) is used.\n" +" `require_main_loop` : bool\n" +" If True, raise RuntimeError if this Connection does not have a main\n" +" loop configured. If False (default) and there is no main loop, you are\n" +" responsible for calling block() on the PendingCall.\n" +"\n" +); +static PyObject * +Connection_send_message_with_reply(Connection *self, PyObject *args, PyObject *kw) +{ + dbus_bool_t ok; + double timeout_s = -1.0; + int timeout_ms; + PyObject *obj, *callable; + DBusMessage *msg; + DBusPendingCall *pending; + int require_main_loop = 0; + static char *argnames[] = {"msg", "reply_handler", "timeout_s", + "require_main_loop", NULL}; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + if (!PyArg_ParseTupleAndKeywords(args, kw, + "OO|di:send_message_with_reply", + argnames, + &obj, &callable, &timeout_s, + &require_main_loop)) { + return NULL; + } + if (require_main_loop && !Connection__require_main_loop(self, NULL)) { + return NULL; + } + + msg = DBusPyMessage_BorrowDBusMessage(obj); + if (!msg) return NULL; + + if (timeout_s < 0) { + timeout_ms = -1; + } + else { + if (timeout_s > ((double)INT_MAX) / 1000.0) { + PyErr_SetString(PyExc_ValueError, "Timeout too long"); + return NULL; + } + timeout_ms = (int)(timeout_s * 1000.0); + } + + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_send_with_reply(self->conn, msg, &pending, + timeout_ms); + Py_END_ALLOW_THREADS + + if (!ok) { + return PyErr_NoMemory(); + } + + if (!pending) { + /* connection is disconnected (doesn't return FALSE!) */ + return DBusPyException_SetString ("Connection is disconnected - " + "unable to make method call"); + } + + return DBusPyPendingCall_ConsumeDBusPendingCall(pending, callable); +} + +/* Again, the timeout is in seconds, since that's conventional in Python. */ +PyDoc_STRVAR(Connection_send_message_with_reply_and_block__doc__, +"send_message_with_reply_and_block(msg, timeout_s=-1)" +" -> dbus.lowlevel.Message\n\n" +"Send the message and block while waiting for a reply.\n" +"\n" +"This does not re-enter the main loop, so it can lead to a deadlock, if\n" +"the called method tries to make a synchronous call to a method in this\n" +"application. As such, it's probably a bad idea.\n" +"\n" +":Parameters:\n" +" `msg` : dbus.lowlevel.Message\n" +" The message to be sent\n" +" `timeout_s` : float\n" +" If the reply takes more than this many seconds, a timeout error\n" +" will be created locally and raised instead. If this timeout is\n" +" negative (default), a sane default (supplied by libdbus) is used.\n" +":Returns:\n" +" A `dbus.lowlevel.Message` instance (probably a `dbus.lowlevel.MethodReturnMessage`) on success\n" +":Raises dbus.DBusException:\n" +" On error (including if the reply arrives but is an\n" +" error message)\n" +"\n" +); +static PyObject * +Connection_send_message_with_reply_and_block(Connection *self, PyObject *args) +{ + double timeout_s = -1.0; + int timeout_ms; + PyObject *obj; + DBusMessage *msg, *reply; + DBusError error; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + if (!PyArg_ParseTuple(args, "O|d:send_message_with_reply_and_block", &obj, + &timeout_s)) { + return NULL; + } + + msg = DBusPyMessage_BorrowDBusMessage(obj); + if (!msg) return NULL; + + if (timeout_s < 0) { + timeout_ms = -1; + } + else { + if (timeout_s > ((double)INT_MAX) / 1000.0) { + PyErr_SetString(PyExc_ValueError, "Timeout too long"); + return NULL; + } + timeout_ms = (int)(timeout_s * 1000.0); + } + + dbus_error_init(&error); + Py_BEGIN_ALLOW_THREADS + reply = dbus_connection_send_with_reply_and_block(self->conn, msg, + timeout_ms, &error); + Py_END_ALLOW_THREADS + + /* FIXME: if we instead used send_with_reply and blocked on the resulting + * PendingCall, then we could get all args from the error, not just + * the first */ + if (!reply) { + return DBusPyException_ConsumeError(&error); + } + return DBusPyMessage_ConsumeDBusMessage(reply); +} + +PyDoc_STRVAR(Connection_flush__doc__, +"flush()\n\n" +"Block until the outgoing message queue is empty.\n"); +static PyObject * +Connection_flush (Connection *self, PyObject *args UNUSED) +{ + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + Py_BEGIN_ALLOW_THREADS + dbus_connection_flush (self->conn); + Py_END_ALLOW_THREADS + Py_RETURN_NONE; +} + +/* Unsupported: + * dbus_connection_preallocate_send + * dbus_connection_free_preallocated_send + * dbus_connection_send_preallocated + * dbus_connection_borrow_message + * dbus_connection_return_message + * dbus_connection_steal_borrowed_message + * dbus_connection_pop_message + */ + +/* Non-main-loop handling not yet implemented: */ + /* dbus_connection_read_write_dispatch */ + /* dbus_connection_read_write */ + +/* Main loop handling not yet implemented: */ + /* dbus_connection_get_dispatch_status */ + /* dbus_connection_dispatch */ + /* dbus_connection_set_watch_functions */ + /* dbus_connection_set_timeout_functions */ + /* dbus_connection_set_wakeup_main_function */ + /* dbus_connection_set_dispatch_status_function */ + +/* Normally in Python this would be called fileno(), but I don't want to + * encourage people to select() on it */ +PyDoc_STRVAR(Connection_get_unix_fd__doc__, +"get_unix_fd() -> int or None\n\n" +"Get the connection's UNIX file descriptor, if any.\n\n" +"This can be used for SELinux access control checks with ``getpeercon()``\n" +"for example. **Do not** read or write to the file descriptor, or try to\n" +"``select()`` on it.\n"); +static PyObject * +Connection_get_unix_fd (Connection *self, PyObject *unused UNUSED) +{ + int fd; + dbus_bool_t ok; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_get_unix_fd (self->conn, &fd); + Py_END_ALLOW_THREADS + if (!ok) Py_RETURN_NONE; + return PyInt_FromLong(fd); +} + +PyDoc_STRVAR(Connection_get_peer_unix_user__doc__, +"get_peer_unix_user() -> long or None\n\n" +"Get the UNIX user ID at the other end of the connection, if it has been\n" +"authenticated. Return None if this is a non-UNIX platform or the\n" +"connection has not been authenticated.\n"); +static PyObject * +Connection_get_peer_unix_user (Connection *self, PyObject *unused UNUSED) +{ + unsigned long uid; + dbus_bool_t ok; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_get_unix_user (self->conn, &uid); + Py_END_ALLOW_THREADS + if (!ok) Py_RETURN_NONE; + return PyLong_FromUnsignedLong (uid); +} + +PyDoc_STRVAR(Connection_get_peer_unix_process_id__doc__, +"get_peer_unix_process_id() -> long or None\n\n" +"Get the UNIX process ID at the other end of the connection, if it has been\n" +"authenticated. Return None if this is a non-UNIX platform or the\n" +"connection has not been authenticated.\n"); +static PyObject * +Connection_get_peer_unix_process_id (Connection *self, PyObject *unused UNUSED) +{ + unsigned long pid; + dbus_bool_t ok; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_get_unix_process_id (self->conn, &pid); + Py_END_ALLOW_THREADS + if (!ok) Py_RETURN_NONE; + return PyLong_FromUnsignedLong (pid); +} + +/* TODO: wrap dbus_connection_set_unix_user_function Pythonically */ + +PyDoc_STRVAR(Connection_add_message_filter__doc__, +"add_message_filter(callable)\n\n" +"Add the given message filter to the internal list.\n\n" +"Filters are handlers that are run on all incoming messages, prior to the\n" +"objects registered to handle object paths.\n" +"\n" +"Filters are run in the order that they were added. The same handler can\n" +"be added as a filter more than once, in which case it will be run more\n" +"than once. Filters added during a filter callback won't be run on the\n" +"message being processed.\n" +); +static PyObject * +Connection_add_message_filter(Connection *self, PyObject *callable) +{ + dbus_bool_t ok; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + /* The callable must be referenced by ->filters *before* it is + * given to libdbus, which does not own a reference to it. + */ + if (PyList_Append(self->filters, callable) < 0) { + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_add_filter(self->conn, _filter_message, callable, + NULL); + Py_END_ALLOW_THREADS + + if (!ok) { + Py_XDECREF(PyObject_CallMethod(self->filters, "remove", "(O)", + callable)); + PyErr_NoMemory(); + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Connection_remove_message_filter__doc__, +"remove_message_filter(callable)\n\n" +"Remove the given message filter (see `add_message_filter` for details).\n" +"\n" +":Raises LookupError:\n" +" The given callable is not among the registered filters\n"); +static PyObject * +Connection_remove_message_filter(Connection *self, PyObject *callable) +{ + PyObject *obj; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + /* It's safe to do this before removing it from libdbus, because + * the presence of callable in our arguments means we have a ref + * to it. */ + obj = PyObject_CallMethod(self->filters, "remove", "(O)", callable); + if (!obj) return NULL; + Py_DECREF(obj); + + Py_BEGIN_ALLOW_THREADS + dbus_connection_remove_filter(self->conn, _filter_message, callable); + Py_END_ALLOW_THREADS + + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Connection__register_object_path__doc__, +"register_object_path(path, on_message, on_unregister=None, fallback=False)\n" +"\n" +"Register a callback to be called when messages arrive at the given\n" +"object-path. Used to export objects' methods on the bus in a low-level\n" +"way. For the high-level interface to this functionality (usually\n" +"recommended) see the `dbus.service.Object` base class.\n" +"\n" +":Parameters:\n" +" `path` : str\n" +" Object path to be acted on\n" +" `on_message` : callable\n" +" Called when a message arrives at the given object-path, with\n" +" two positional parameters: the first is this Connection,\n" +" the second is the incoming `dbus.lowlevel.Message`.\n" +" `on_unregister` : callable or None\n" +" If not None, called when the callback is unregistered.\n" +" `fallback` : bool\n" +" If True (the default is False), when a message arrives for a\n" +" 'subdirectory' of the given path and there is no more specific\n" +" handler, use this handler. Normally this handler is only run if\n" +" the paths match exactly.\n" +); +static PyObject * +Connection__register_object_path(Connection *self, PyObject *args, + PyObject *kwargs) +{ + dbus_bool_t ok; + int fallback = 0; + PyObject *callbacks, *path, *tuple, *on_message, *on_unregister = Py_None; + static char *argnames[] = {"path", "on_message", "on_unregister", + "fallback", NULL}; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + if (!Connection__require_main_loop(self, NULL)) { + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "OO|Oi:_register_object_path", + argnames, + &path, + &on_message, &on_unregister, + &fallback)) return NULL; + + /* Take a reference to path, which we give away to libdbus in a moment. + + Also, path needs to be a string (not a subclass which could do something + mad) to preserve the desirable property that the DBusConnection can + never strongly reference the Connection, even indirectly. + */ + if (PyString_CheckExact(path)) { + Py_INCREF(path); + } + else if (PyUnicode_Check(path)) { + path = PyUnicode_AsUTF8String(path); + if (!path) return NULL; + } + else if (PyString_Check(path)) { + path = PyString_FromString(PyString_AS_STRING(path)); + if (!path) return NULL; + } + else { + PyErr_SetString(PyExc_TypeError, "path must be a str or unicode object"); + return NULL; + } + + if (!dbus_py_validate_object_path(PyString_AS_STRING(path))) { + Py_DECREF(path); + return NULL; + } + + tuple = Py_BuildValue("(OO)", on_unregister, on_message); + if (!tuple) { + Py_DECREF(path); + return NULL; + } + + /* Guard against registering a handler that already exists. */ + callbacks = PyDict_GetItem(self->object_paths, path); + if (callbacks && callbacks != Py_None) { + PyErr_Format(PyExc_KeyError, "Can't register the object-path " + "handler for '%s': there is already a handler", + PyString_AS_STRING(path)); + Py_DECREF(tuple); + Py_DECREF(path); + return NULL; + } + + /* Pre-allocate a slot in the dictionary, so we know we'll be able + * to replace it with the callbacks without OOM. + * This ensures we can keep libdbus' opinion of whether those + * paths are handled in sync with our own. */ + if (PyDict_SetItem(self->object_paths, path, Py_None) < 0) { + Py_DECREF(tuple); + Py_DECREF(path); + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + if (fallback) { + ok = dbus_connection_register_fallback(self->conn, + PyString_AS_STRING(path), + &_object_path_vtable, + path); + } + else { + ok = dbus_connection_register_object_path(self->conn, + PyString_AS_STRING(path), + &_object_path_vtable, + path); + } + Py_END_ALLOW_THREADS + + if (ok) { + if (PyDict_SetItem(self->object_paths, path, tuple) < 0) { + /* That shouldn't have happened, we already allocated enough + memory for it. Oh well, try to undo the registration to keep + things in sync. If this fails too, we've leaked a bit of + memory in libdbus, but tbh we should never get here anyway. */ + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_unregister_object_path(self->conn, + PyString_AS_STRING(path)); + Py_END_ALLOW_THREADS + return NULL; + } + /* don't DECREF path: libdbus owns a ref now */ + Py_DECREF(tuple); + Py_RETURN_NONE; + } + else { + /* Oops, OOM. Tidy up, if we can, ignoring any error. */ + PyDict_DelItem(self->object_paths, path); + PyErr_Clear(); + Py_DECREF(tuple); + Py_DECREF(path); + PyErr_NoMemory(); + return NULL; + } +} + +PyDoc_STRVAR(Connection__unregister_object_path__doc__, +"unregister_object_path(path)\n\n" +"Remove a previously registered handler for the given object path.\n" +"\n" +":Parameters:\n" +" `path` : str\n" +" The object path whose handler is to be removed\n" +":Raises KeyError: if there is no handler registered for exactly that\n" +" object path.\n" +); +static PyObject * +Connection__unregister_object_path(Connection *self, PyObject *args, + PyObject *kwargs) +{ + dbus_bool_t ok; + PyObject *path; + PyObject *callbacks; + static char *argnames[] = {"path", NULL}; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "O:_unregister_object_path", + argnames, &path)) return NULL; + + /* Take a ref to the path. Same comments as for _register_object_path. */ + if (PyString_CheckExact(path)) { + Py_INCREF(path); + } + else if (PyUnicode_Check(path)) { + path = PyUnicode_AsUTF8String(path); + if (!path) return NULL; + } + else if (PyString_Check(path)) { + path = PyString_FromString(PyString_AS_STRING(path)); + if (!path) return NULL; + } + else { + PyErr_SetString(PyExc_TypeError, "path must be a str or unicode object"); + return NULL; + } + + /* Guard against unregistering a handler that doesn't, in fact, exist, + or whose unregistration is already in progress. */ + callbacks = PyDict_GetItem(self->object_paths, path); + if (!callbacks || callbacks == Py_None) { + PyErr_Format(PyExc_KeyError, "Can't unregister the object-path " + "handler for '%s': there is no such handler", + PyString_AS_STRING(path)); + Py_DECREF(path); + return NULL; + } + + /* Hang on to a reference to the callbacks for the moment. */ + Py_INCREF(callbacks); + + /* Get rid of the object-path while we still have the GIL, to + guard against unregistering twice from different threads (which + causes undefined behaviour in libdbus). + + Because deletion would make it possible for the re-insertion below + to fail, we instead set the handler to None as a placeholder. + */ + if (PyDict_SetItem(self->object_paths, path, Py_None) < 0) { + /* If that failed, there's no need to be paranoid as below - the + callbacks are still set, so we failed, but at least everything + is in sync. */ + Py_DECREF(callbacks); + Py_DECREF(path); + return NULL; + } + + /* BEGIN PARANOIA + This is something of a critical section - the dict of object-paths + and libdbus' internal structures are out of sync for a bit. We have + to be able to cope with that. + + It's really annoying that dbus_connection_unregister_object_path + can fail, *and* has undefined behaviour if the object path has + already been unregistered. Either/or would be fine. + */ + + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_unregister_object_path(self->conn, + PyString_AS_STRING(path)); + Py_END_ALLOW_THREADS + + if (ok) { + Py_DECREF(callbacks); + PyDict_DelItem(self->object_paths, path); + /* END PARANOIA on successful code path */ + /* The above can't fail unless by some strange trickery the key is no + longer present. Ignore any errors. */ + Py_DECREF(path); + PyErr_Clear(); + Py_RETURN_NONE; + } + else { + /* Oops, OOM. Put the callbacks back in the dict so + * we'll have another go if/when the user frees some memory + * and tries calling this method again. */ + PyDict_SetItem(self->object_paths, path, callbacks); + /* END PARANOIA on failing code path */ + /* If the SetItem failed, there's nothing we can do about it - but + since we know it's an existing entry, it shouldn't be able to fail + anyway. */ + Py_DECREF(path); + Py_DECREF(callbacks); + return PyErr_NoMemory(); + } +} + +PyDoc_STRVAR(Connection_list_exported_child_objects__doc__, +"list_exported_child_objects(path: str) -> list of str\n\n" +"Return a list of the names of objects exported on this Connection as\n" +"direct children of the given object path.\n" +"\n" +"Each name returned may be converted to a valid object path using\n" +"``dbus.ObjectPath('%s%s%s' % (path, (path != '/' and '/' or ''), name))``.\n" +"For the purposes of this function, every parent or ancestor of an exported\n" +"object is considered to be an exported object, even if it's only an object\n" +"synthesized by the library to support introspection.\n"); +static PyObject * +Connection_list_exported_child_objects (Connection *self, PyObject *args, + PyObject *kwargs) +{ + const char *path; + char **kids, **kid_ptr; + dbus_bool_t ok; + PyObject *ret; + static char *argnames[] = {"path", NULL}; + + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->conn); + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s", argnames, &path)) { + return NULL; + } + + if (!dbus_py_validate_object_path(path)) { + return NULL; + } + + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_list_registered(self->conn, path, &kids); + Py_END_ALLOW_THREADS + + if (!ok) { + return PyErr_NoMemory(); + } + + ret = PyList_New(0); + if (!ret) { + return NULL; + } + for (kid_ptr = kids; *kid_ptr; kid_ptr++) { + PyObject *tmp = PyString_FromString(*kid_ptr); + + if (!tmp) { + Py_DECREF(ret); + return NULL; + } + if (PyList_Append(ret, tmp) < 0) { + Py_DECREF(tmp); + Py_DECREF(ret); + return NULL; + } + Py_DECREF(tmp); + } + + dbus_free_string_array(kids); + + return ret; +} + + /* dbus_connection_get_object_path_data - not useful to Python, + * the object path data is just a PyString containing the path */ + /* dbus_connection_list_registered could be useful, though */ + +/* dbus_connection_set_change_sigpipe - sets global state */ + +/* Maxima. Does Python code ever need to manipulate these? + * OTOH they're easy to wrap */ + /* dbus_connection_set_max_message_size */ + /* dbus_connection_get_max_message_size */ + /* dbus_connection_set_max_received_size */ + /* dbus_connection_get_max_received_size */ + +/* dbus_connection_get_outgoing_size - almost certainly unneeded */ + +PyDoc_STRVAR(new_for_bus__doc__, +"Connection._new_for_bus([address: str or int]) -> Connection\n" +"\n" +"If the address is an int it must be one of the constants BUS_SESSION,\n" +"BUS_SYSTEM, BUS_STARTER; if a string, it must be a D-Bus address.\n" +"The default is BUS_SESSION.\n" +); + +PyDoc_STRVAR(get_unique_name__doc__, +"get_unique_name() -> str\n\n" +"Return this application's unique name on this bus.\n" +"\n" +":Raises DBusException: if the connection has no unique name yet\n" +" (for Bus objects this can't happen, for peer-to-peer connections\n" +" this means you haven't called `set_unique_name`)\n"); + +PyDoc_STRVAR(set_unique_name__doc__, +"set_unique_name(str)\n\n" +"Set this application's unique name on this bus. Raise ValueError if it has\n" +"already been set.\n"); + +struct PyMethodDef DBusPyConnection_tp_methods[] = { +#define ENTRY(name, flags) {#name, (PyCFunction)Connection_##name, flags, Connection_##name##__doc__} + ENTRY(_require_main_loop, METH_NOARGS), + ENTRY(close, METH_NOARGS), + ENTRY(flush, METH_NOARGS), + ENTRY(get_is_connected, METH_NOARGS), + ENTRY(get_is_authenticated, METH_NOARGS), + ENTRY(set_exit_on_disconnect, METH_VARARGS), + ENTRY(get_unix_fd, METH_NOARGS), + ENTRY(get_peer_unix_user, METH_NOARGS), + ENTRY(get_peer_unix_process_id, METH_NOARGS), + ENTRY(add_message_filter, METH_O), + ENTRY(_register_object_path, METH_VARARGS|METH_KEYWORDS), + ENTRY(remove_message_filter, METH_O), + ENTRY(send_message, METH_VARARGS), + ENTRY(send_message_with_reply, METH_VARARGS|METH_KEYWORDS), + ENTRY(send_message_with_reply_and_block, METH_VARARGS), + ENTRY(_unregister_object_path, METH_VARARGS|METH_KEYWORDS), + ENTRY(list_exported_child_objects, METH_VARARGS|METH_KEYWORDS), + {"_new_for_bus", (PyCFunction)DBusPyConnection_NewForBus, + METH_CLASS|METH_VARARGS|METH_KEYWORDS, + new_for_bus__doc__}, + {"get_unique_name", (PyCFunction)DBusPyConnection_GetUniqueName, + METH_NOARGS, + get_unique_name__doc__}, + {"set_unique_name", (PyCFunction)DBusPyConnection_SetUniqueName, + METH_VARARGS, + set_unique_name__doc__}, + {NULL}, +#undef ENTRY +}; + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/conn.c b/_dbus_bindings/conn.c new file mode 100644 index 0000000..e7c5338 --- /dev/null +++ b/_dbus_bindings/conn.c @@ -0,0 +1,471 @@ +/* Implementation of the _dbus_bindings Connection type, a Python wrapper + * for DBusConnection. See also conn-methods.c. + * + * Copyright (C) 2006-2008 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" +#include "conn-internal.h" + +/* Connection definition ============================================ */ + +PyDoc_STRVAR(Connection_tp_doc, +"A D-Bus connection.\n" +"\n" +"::\n" +"\n" +" Connection(address, mainloop=None) -> Connection\n" +); + +/* D-Bus Connection user data slot, containing an owned reference to either + * the Connection, or a weakref to the Connection. + */ +static dbus_int32_t _connection_python_slot; + +/* C API for main-loop hooks ======================================== */ + +/* Return a borrowed reference to the DBusConnection which underlies this + * Connection. */ +DBusConnection * +DBusPyConnection_BorrowDBusConnection(PyObject *self) +{ + DBusConnection *dbc; + + TRACE(self); + if (!DBusPyConnection_Check(self)) { + PyErr_SetString(PyExc_TypeError, "A dbus.Connection is required"); + return NULL; + } + dbc = ((Connection *)self)->conn; + if (!dbc) { + PyErr_SetString(PyExc_RuntimeError, "Connection is in an invalid " + "state: no DBusConnection"); + return NULL; + } + return dbc; +} + +/* Internal C API =================================================== */ + +/* Pass a message through a handler. */ +DBusHandlerResult +DBusPyConnection_HandleMessage(Connection *conn, + PyObject *msg, + PyObject *callable) +{ + PyObject *obj; + + TRACE(conn); + obj = PyObject_CallFunctionObjArgs(callable, conn, msg, + NULL); + if (obj == Py_None) { + DBG("%p: OK, handler %p returned None", conn, callable); + Py_DECREF(obj); + return DBUS_HANDLER_RESULT_HANDLED; + } + else if (obj == Py_NotImplemented) { + DBG("%p: handler %p returned NotImplemented, continuing", + conn, callable); + Py_DECREF(obj); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + else if (!obj) { + if (PyErr_ExceptionMatches(PyExc_MemoryError)) { + DBG_EXC("%p: handler %p caused OOM", conn, callable); + PyErr_Clear(); + return DBUS_HANDLER_RESULT_NEED_MEMORY; + } + DBG_EXC("%p: handler %p raised exception", conn, callable); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + else { + long i = PyInt_AsLong(obj); + DBG("%p: handler %p returned %ld", conn, callable, i); + Py_DECREF(obj); + if (i == -1 && PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, "Return from D-Bus message " + "handler callback should be None, " + "NotImplemented or integer"); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + else if (i == DBUS_HANDLER_RESULT_HANDLED || + i == DBUS_HANDLER_RESULT_NOT_YET_HANDLED || + i == DBUS_HANDLER_RESULT_NEED_MEMORY) { + return i; + } + else { + PyErr_Format(PyExc_ValueError, "Integer return from " + "D-Bus message handler callback should " + "be a DBUS_HANDLER_RESULT_... constant, " + "not %d", (int)i); + return DBUS_HANDLER_RESULT_NOT_YET_HANDLED; + } + } +} + +/* On KeyError or if unregistration is in progress, return None. */ +PyObject * +DBusPyConnection_GetObjectPathHandlers(PyObject *self, PyObject *path) +{ + PyObject *callbacks; + + TRACE(self); + callbacks = PyDict_GetItem(((Connection *)self)->object_paths, path); + if (!callbacks) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + Py_RETURN_NONE; + } + } + Py_INCREF(callbacks); + return callbacks; +} + +/* Return a new reference to a Python Connection or subclass corresponding + * to the DBusConnection conn. For use in callbacks. + * + * Raises AssertionError if the DBusConnection does not have a Connection. + */ +PyObject * +DBusPyConnection_ExistingFromDBusConnection(DBusConnection *conn) +{ + PyObject *self, *ref; + + Py_BEGIN_ALLOW_THREADS + ref = (PyObject *)dbus_connection_get_data(conn, + _connection_python_slot); + Py_END_ALLOW_THREADS + if (ref) { + DBG("(DBusConnection *)%p has weak reference at %p", conn, ref); + self = PyWeakref_GetObject(ref); /* still a borrowed ref */ + if (self && self != Py_None && DBusPyConnection_Check(self)) { + DBG("(DBusConnection *)%p has weak reference at %p pointing to %p", + conn, ref, self); + TRACE(self); + Py_INCREF(self); + TRACE(self); + return self; + } + } + + PyErr_SetString(PyExc_AssertionError, + "D-Bus connection does not have a Connection " + "instance associated with it"); + return NULL; +} + +/* Return a new reference to a Python Connection or subclass (given by cls) + * corresponding to the DBusConnection conn, which must have been newly + * created. For use by the Connection and Bus constructors. + * + * Raises AssertionError if the DBusConnection already has a Connection. + */ +static PyObject * +DBusPyConnection_NewConsumingDBusConnection(PyTypeObject *cls, + DBusConnection *conn, + PyObject *mainloop) +{ + Connection *self = NULL; + PyObject *ref; + dbus_bool_t ok; + + DBG("%s(cls=%p, conn=%p, mainloop=%p)", __func__, cls, conn, mainloop); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(conn); + + Py_BEGIN_ALLOW_THREADS + ref = (PyObject *)dbus_connection_get_data(conn, + _connection_python_slot); + Py_END_ALLOW_THREADS + if (ref) { + self = (Connection *)PyWeakref_GetObject(ref); + ref = NULL; + if (self && (PyObject *)self != Py_None) { + self = NULL; + PyErr_SetString(PyExc_AssertionError, + "Newly created D-Bus connection already has a " + "Connection instance associated with it"); + DBG("%s() fail - assertion failed, DBusPyConn has a DBusConn already", __func__); + DBG_WHEREAMI; + return NULL; + } + } + ref = NULL; + + /* Change mainloop from a borrowed reference to an owned reference */ + if (!mainloop || mainloop == Py_None) { + mainloop = dbus_py_get_default_main_loop(); + if (!mainloop) + goto err; + } + else { + Py_INCREF(mainloop); + } + + DBG("Constructing Connection from DBusConnection at %p", conn); + + self = (Connection *)(cls->tp_alloc(cls, 0)); + if (!self) goto err; + TRACE(self); + + DBG_WHEREAMI; + + self->has_mainloop = (mainloop != Py_None); + self->conn = NULL; + self->filters = PyList_New(0); + if (!self->filters) goto err; + self->object_paths = PyDict_New(); + if (!self->object_paths) goto err; + + ref = PyWeakref_NewRef((PyObject *)self, NULL); + if (!ref) goto err; + DBG("Created weak ref %p to (Connection *)%p for (DBusConnection *)%p", + ref, self, conn); + + Py_BEGIN_ALLOW_THREADS + ok = dbus_connection_set_data(conn, _connection_python_slot, + (void *)ref, + (DBusFreeFunction)dbus_py_take_gil_and_xdecref); + Py_END_ALLOW_THREADS + + if (ok) { + DBG("Attached weak ref %p ((Connection *)%p) to (DBusConnection *)%p", + ref, self, conn); + ref = NULL; /* don't DECREF it - the DBusConnection owns it now */ + } + else { + DBG("Failed to attached weak ref %p ((Connection *)%p) to " + "(DBusConnection *)%p - will dispose of it", ref, self, conn); + PyErr_NoMemory(); + goto err; + } + + DBUS_PY_RAISE_VIA_GOTO_IF_FAIL(conn, err); + self->conn = conn; + /* the DBusPyConnection will close it now */ + conn = NULL; + + if (self->has_mainloop + && !dbus_py_set_up_connection((PyObject *)self, mainloop)) { + goto err; + } + + Py_DECREF(mainloop); + + DBG("%s() -> %p", __func__, self); + TRACE(self); + return (PyObject *)self; + +err: + DBG("Failed to construct Connection from DBusConnection at %p", conn); + Py_XDECREF(mainloop); + Py_XDECREF(self); + Py_XDECREF(ref); + if (conn) { + Py_BEGIN_ALLOW_THREADS + dbus_connection_close(conn); + dbus_connection_unref(conn); + Py_END_ALLOW_THREADS + } + DBG("%s() fail", __func__); + DBG_WHEREAMI; + return NULL; +} + +/* Connection type-methods ========================================== */ + +/* Constructor */ +static PyObject * +Connection_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + DBusConnection *conn; + const char *address; + PyObject *address_or_conn; + DBusError error; + PyObject *self, *mainloop = NULL; + static char *argnames[] = {"address", "mainloop", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|O", argnames, + &address_or_conn, &mainloop)) { + return NULL; + } + + if (DBusPyLibDBusConnection_CheckExact(address_or_conn)) { + DBusPyLibDBusConnection *wrapper = + (DBusPyLibDBusConnection *) address_or_conn; + + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(wrapper->conn); + + conn = dbus_connection_ref (wrapper->conn); + } + else if ((address = PyString_AsString(address_or_conn)) != NULL) { + dbus_error_init(&error); + + /* We always open a private connection (at the libdbus level). Sharing + * is done in Python, to keep things simple. */ + Py_BEGIN_ALLOW_THREADS + conn = dbus_connection_open_private(address, &error); + Py_END_ALLOW_THREADS + + if (!conn) { + DBusPyException_ConsumeError(&error); + return NULL; + } + } + else { + return NULL; + } + + self = DBusPyConnection_NewConsumingDBusConnection(cls, conn, mainloop); + TRACE(self); + + return self; +} + +/* Post-construction: nothing to do (but don't chain up to object.__init__, + * which takes no arguments and does nothing) */ +static int +Connection_tp_init(PyObject *self UNUSED, PyObject *args UNUSED, + PyObject *kwargs UNUSED) +{ + return 0; +} + +/* Destructor */ +static void Connection_tp_dealloc(Connection *self) +{ + DBusConnection *conn = self->conn; + PyObject *et, *ev, *etb; + PyObject *filters = self->filters; + PyObject *object_paths = self->object_paths; + + /* avoid clobbering any pending exception */ + PyErr_Fetch(&et, &ev, &etb); + + if (self->weaklist) { + PyObject_ClearWeakRefs((PyObject *)self); + } + + TRACE(self); + DBG("Deallocating Connection at %p (DBusConnection at %p)", self, conn); + DBG_WHEREAMI; + + DBG("Connection at %p: deleting callbacks", self); + self->filters = NULL; + Py_XDECREF(filters); + self->object_paths = NULL; + Py_XDECREF(object_paths); + + if (conn) { + /* Might trigger callbacks if we're unlucky... */ + DBG("Connection at %p has a conn, closing it...", self); + Py_BEGIN_ALLOW_THREADS + dbus_connection_close(conn); + Py_END_ALLOW_THREADS + } + + /* make sure to do this last to preserve the invariant that + * self->conn is always non-NULL for any referenced Connection + * (until the filters and object paths were freed, we might have been + * in a reference cycle!) + */ + DBG("Connection at %p: nulling self->conn", self); + self->conn = NULL; + + if (conn) { + DBG("Connection at %p: unreffing conn", self); + dbus_connection_unref(conn); + } + + DBG("Connection at %p: freeing self", self); + PyErr_Restore(et, ev, etb); + (self->ob_type->tp_free)((PyObject *)self); +} + +/* Connection type object =========================================== */ + +PyTypeObject DBusPyConnection_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_dbus_bindings.Connection", /*tp_name*/ + sizeof(Connection), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)Connection_tp_dealloc, + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS | Py_TPFLAGS_BASETYPE, + Connection_tp_doc, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + offsetof(Connection, weaklist), /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + DBusPyConnection_tp_methods, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + Connection_tp_init, /*tp_init*/ + 0, /*tp_alloc*/ + Connection_tp_new, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ +}; + +dbus_bool_t +dbus_py_init_conn_types(void) +{ + /* Get a slot to store our weakref on DBus Connections */ + _connection_python_slot = -1; + if (!dbus_connection_allocate_data_slot(&_connection_python_slot)) + return FALSE; + if (PyType_Ready(&DBusPyConnection_Type) < 0) + return FALSE; + return TRUE; +} + +dbus_bool_t +dbus_py_insert_conn_types(PyObject *this_module) +{ + if (PyModule_AddObject(this_module, "Connection", + (PyObject *)&DBusPyConnection_Type) < 0) return FALSE; + return TRUE; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/containers.c b/_dbus_bindings/containers.c new file mode 100644 index 0000000..319ebe1 --- /dev/null +++ b/_dbus_bindings/containers.c @@ -0,0 +1,769 @@ +/* D-Bus container types: Array, Dict and Struct. + * + * Copyright (C) 2006-2007 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include + +#include "dbus_bindings-internal.h" +#include "types-internal.h" + +/* Array ============================================================ */ + +PyDoc_STRVAR(Array_tp_doc, +"An array of similar items, implemented as a subtype of list.\n" +"\n" +"As currently implemented, an Array behaves just like a list, but\n" +"with the addition of a ``signature`` property set by the constructor;\n" +"conversion of its items to D-Bus types is only done when it's sent in\n" +"a Message. This might change in future so validation is done earlier.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.Array([iterable][, signature][, variant_level])\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +"``signature`` is the D-Bus signature string for a single element of the\n" +"array, or None. If not None it must represent a single complete type, the\n" +"type of a single array item; the signature of the whole Array may be\n" +"obtained by prepending ``a`` to the given signature.\n" +"\n" +"If None (the default), when the Array is sent over\n" +"D-Bus, the item signature will be guessed from the first element.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing an array, this is represented in Python by an\n" +" Array with variant_level==2.\n" +); + +static struct PyMemberDef Array_tp_members[] = { + {"signature", T_OBJECT, offsetof(DBusPyArray, signature), READONLY, + "The D-Bus signature of each element of this Array (a Signature " + "instance)"}, + {"variant_level", T_LONG, offsetof(DBusPyArray, variant_level), + READONLY, + "The number of nested variants wrapping the real data. " + "0 if not in a variant."}, + {NULL}, +}; + +static void +Array_tp_dealloc (DBusPyArray *self) +{ + Py_XDECREF(self->signature); + self->signature = NULL; + (PyList_Type.tp_dealloc)((PyObject *)self); +} + +static PyObject * +Array_tp_repr(DBusPyArray *self) +{ + PyObject *parent_repr = (PyList_Type.tp_repr)((PyObject *)self); + PyObject *sig_repr = PyObject_Repr(self->signature); + PyObject *my_repr = NULL; + long variant_level = self->variant_level; + + if (!parent_repr) goto finally; + if (!sig_repr) goto finally; + if (variant_level > 0) { + my_repr = PyString_FromFormat("%s(%s, signature=%s, " + "variant_level=%ld)", + self->super.ob_type->tp_name, + PyString_AS_STRING(parent_repr), + PyString_AS_STRING(sig_repr), + variant_level); + } + else { + my_repr = PyString_FromFormat("%s(%s, signature=%s)", + self->super.ob_type->tp_name, + PyString_AS_STRING(parent_repr), + PyString_AS_STRING(sig_repr)); + } +finally: + Py_XDECREF(parent_repr); + Py_XDECREF(sig_repr); + return my_repr; +} + +static PyObject * +Array_tp_new (PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *variant_level = NULL; + DBusPyArray *self = (DBusPyArray *)(PyList_Type.tp_new)(cls, args, kwargs); + + /* variant_level is immutable, so handle it in __new__ rather than + __init__ */ + if (!self) return NULL; + Py_INCREF(Py_None); + self->signature = Py_None; + self->variant_level = 0; + if (kwargs) { + variant_level = PyDict_GetItem(kwargs, dbus_py_variant_level_const); + } + if (variant_level) { + self->variant_level = PyInt_AsLong(variant_level); + if (PyErr_Occurred()) { + Py_DECREF((PyObject *)self); + return NULL; + } + } + return (PyObject *)self; +} + +static int +Array_tp_init (DBusPyArray *self, PyObject *args, PyObject *kwargs) +{ + PyObject *obj = dbus_py_empty_tuple; + PyObject *signature = NULL; + PyObject *tuple; + PyObject *variant_level; + /* variant_level is accepted but ignored - it's immutable, so + * __new__ handles it */ + static char *argnames[] = {"iterable", "signature", "variant_level", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO:__init__", argnames, + &obj, &signature, &variant_level)) { + return -1; + } + + /* convert signature from a borrowed ref of unknown type to an owned ref + of type Signature (or None) */ + if (!signature) signature = Py_None; + if (signature == Py_None + || PyObject_IsInstance(signature, (PyObject *)&DBusPySignature_Type)) { + Py_INCREF(signature); + } + else { + signature = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, + "(O)", signature); + if (!signature) return -1; + } + + if (signature != Py_None) { + const char *c_str = PyString_AS_STRING(signature); + + if (!dbus_signature_validate_single(c_str, NULL)) { + Py_DECREF(signature); + PyErr_SetString(PyExc_ValueError, + "There must be exactly one complete type in " + "an Array's signature parameter"); + return -1; + } + } + + tuple = Py_BuildValue("(O)", obj); + if (!tuple) { + Py_DECREF(signature); + return -1; + } + if ((PyList_Type.tp_init)((PyObject *)self, tuple, NULL) < 0) { + Py_DECREF(tuple); + Py_DECREF(signature); + return -1; + } + Py_DECREF(tuple); + + Py_XDECREF(self->signature); + self->signature = signature; + return 0; +} + +PyTypeObject DBusPyArray_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Array", + sizeof(DBusPyArray), + 0, + (destructor)Array_tp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)Array_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Array_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + Array_tp_members, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)Array_tp_init, /* tp_init */ + 0, /* tp_alloc */ + Array_tp_new, /* tp_new */ +}; + +/* Dict ============================================================= */ + +PyDoc_STRVAR(Dict_tp_doc, +"An mapping whose keys are similar and whose values are similar,\n" +"implemented as a subtype of dict.\n" +"\n" +"As currently implemented, a Dictionary behaves just like a dict, but\n" +"with the addition of a ``signature`` property set by the constructor;\n" +"conversion of its items to D-Bus types is only done when it's sent in\n" +"a Message. This may change in future so validation is done earlier.\n" +"\n" +"Constructor::\n" +"\n" +" Dictionary(mapping_or_iterable=(), signature=None, variant_level=0)\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +"``signature`` is either a string or None. If a string, it must consist\n" +"of exactly two complete type signatures, representing the 'key' type\n" +"(which must be a primitive type, i.e. one of \"bdginoqstuxy\")\n" +"and the 'value' type. The signature of the whole Dictionary will be\n" +"``a{xx}`` where ``xx`` is replaced by the given signature.\n" +"\n" +"If it is None (the default), when the Dictionary is sent over\n" +"D-Bus, the key and value signatures will be guessed from an arbitrary\n" +"element of the Dictionary.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing an array of DICT_ENTRY, this is represented in\n" +" Python by a Dictionary with variant_level==2.\n" +); + +static struct PyMemberDef Dict_tp_members[] = { + {"signature", T_OBJECT, offsetof(DBusPyDict, signature), READONLY, + "The D-Bus signature of each key in this Dictionary, followed by " + "that of each value in this Dictionary, as a Signature instance."}, + {"variant_level", T_LONG, offsetof(DBusPyDict, variant_level), + READONLY, + "The number of nested variants wrapping the real data. " + "0 if not in a variant."}, + {NULL}, +}; + +static void +Dict_tp_dealloc (DBusPyDict *self) +{ + Py_XDECREF(self->signature); + self->signature = NULL; + (PyDict_Type.tp_dealloc)((PyObject *)self); +} + +static PyObject * +Dict_tp_repr(DBusPyDict *self) +{ + PyObject *parent_repr = (PyDict_Type.tp_repr)((PyObject *)self); + PyObject *sig_repr = PyObject_Repr(self->signature); + PyObject *my_repr = NULL; + long variant_level = self->variant_level; + + if (!parent_repr) goto finally; + if (!sig_repr) goto finally; + if (variant_level > 0) { + my_repr = PyString_FromFormat("%s(%s, signature=%s, " + "variant_level=%ld)", + self->super.ob_type->tp_name, + PyString_AS_STRING(parent_repr), + PyString_AS_STRING(sig_repr), + variant_level); + } + else { + my_repr = PyString_FromFormat("%s(%s, signature=%s)", + self->super.ob_type->tp_name, + PyString_AS_STRING(parent_repr), + PyString_AS_STRING(sig_repr)); + } +finally: + Py_XDECREF(parent_repr); + Py_XDECREF(sig_repr); + return my_repr; +} + +static PyObject * +Dict_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + DBusPyDict *self = (DBusPyDict *)(PyDict_Type.tp_new)(cls, args, kwargs); + PyObject *variant_level = NULL; + + /* variant_level is immutable, so handle it in __new__ rather than + __init__ */ + if (!self) return NULL; + Py_INCREF(Py_None); + self->signature = Py_None; + self->variant_level = 0; + if (kwargs) { + variant_level = PyDict_GetItem(kwargs, dbus_py_variant_level_const); + } + if (variant_level) { + self->variant_level = PyInt_AsLong(variant_level); + if (PyErr_Occurred()) { + Py_DECREF((PyObject *)self); + return NULL; + } + } + return (PyObject *)self; +} + +static int +Dict_tp_init(DBusPyDict *self, PyObject *args, PyObject *kwargs) +{ + PyObject *obj = dbus_py_empty_tuple; + PyObject *signature = NULL; + PyObject *tuple; + PyObject *variant_level; /* ignored here - __new__ uses it */ + static char *argnames[] = {"mapping_or_iterable", "signature", + "variant_level", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|OOO:__init__", argnames, + &obj, &signature, &variant_level)) { + return -1; + } + + /* convert signature from a borrowed ref of unknown type to an owned ref + of type Signature (or None) */ + if (!signature) signature = Py_None; + if (signature == Py_None + || PyObject_IsInstance(signature, (PyObject *)&DBusPySignature_Type)) { + Py_INCREF(signature); + } + else { + signature = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, + "(O)", signature); + if (!signature) return -1; + } + + if (signature != Py_None) { + const char *c_str = PyString_AS_STRING(signature); + + switch (c_str[0]) { + case DBUS_TYPE_BYTE: + case DBUS_TYPE_BOOLEAN: + case DBUS_TYPE_INT16: + case DBUS_TYPE_UINT16: + case DBUS_TYPE_INT32: + case DBUS_TYPE_UINT32: + case DBUS_TYPE_INT64: + case DBUS_TYPE_UINT64: + case DBUS_TYPE_DOUBLE: +#ifdef WITH_DBUS_FLOAT32 + case DBUS_TYPE_FLOAT: +#endif + case DBUS_TYPE_STRING: + case DBUS_TYPE_OBJECT_PATH: + case DBUS_TYPE_SIGNATURE: + break; + default: + Py_DECREF(signature); + PyErr_SetString(PyExc_ValueError, + "The key type in a Dictionary's signature " + "must be a primitive type"); + return -1; + } + + if (!dbus_signature_validate_single(c_str + 1, NULL)) { + Py_DECREF(signature); + PyErr_SetString(PyExc_ValueError, + "There must be exactly two complete types in " + "a Dictionary's signature parameter"); + return -1; + } + } + + tuple = Py_BuildValue("(O)", obj); + if (!tuple) { + Py_DECREF(signature); + return -1; + } + + if ((PyDict_Type.tp_init((PyObject *)self, tuple, NULL)) < 0) { + Py_DECREF(tuple); + Py_DECREF(signature); + return -1; + } + Py_DECREF(tuple); + + Py_XDECREF(self->signature); + self->signature = signature; + return 0; +} + +PyTypeObject DBusPyDict_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Dictionary", + sizeof(DBusPyDict), + 0, + (destructor)Dict_tp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)Dict_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Dict_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + Dict_tp_members, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)Dict_tp_init, /* tp_init */ + 0, /* tp_alloc */ + Dict_tp_new, /* tp_new */ +}; + +/* Struct =========================================================== */ + +static PyObject *struct_signatures; + +PyDoc_STRVAR(Struct_tp_doc, +"An structure containing items of possibly distinct types.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.Struct(iterable, signature=None, variant_level=0) -> Struct\n" +"\n" +"D-Bus structs may not be empty, so the iterable argument is required and\n" +"may not be an empty iterable.\n" +"\n" +"``signature`` is either None, or a string representing the contents of the\n" +"struct as one or more complete type signatures. The overall signature of\n" +"the struct will be the given signature enclosed in parentheses, ``()``.\n" +"\n" +"If the signature is None (default) it will be guessed\n" +"from the types of the items during construction.\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a struct, this is represented in Python by a\n" +" Struct with variant_level==2.\n" +); + +static PyObject * +Struct_tp_repr(PyObject *self) +{ + PyObject *parent_repr = (PyTuple_Type.tp_repr)((PyObject *)self); + PyObject *sig; + PyObject *sig_repr = NULL; + PyObject *key; + long variant_level; + PyObject *my_repr = NULL; + + if (!parent_repr) goto finally; + key = PyLong_FromVoidPtr(self); + if (!key) goto finally; + sig = PyDict_GetItem(struct_signatures, key); + Py_DECREF(key); + if (!sig) sig = Py_None; + sig_repr = PyObject_Repr(sig); + if (!sig_repr) goto finally; + variant_level = dbus_py_variant_level_get(self); + if (variant_level > 0) { + my_repr = PyString_FromFormat("%s(%s, signature=%s, " + "variant_level=%ld)", + self->ob_type->tp_name, + PyString_AS_STRING(parent_repr), + PyString_AS_STRING(sig_repr), + variant_level); + } + else { + my_repr = PyString_FromFormat("%s(%s, signature=%s)", + self->ob_type->tp_name, + PyString_AS_STRING(parent_repr), + PyString_AS_STRING(sig_repr)); + } + +finally: + Py_XDECREF(parent_repr); + Py_XDECREF(sig_repr); + return my_repr; +} + +static PyObject * +Struct_tp_new (PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *signature = NULL; + long variantness = 0; + PyObject *self, *key; + static char *argnames[] = {"signature", "variant_level", NULL}; + + if (PyTuple_Size(args) != 1) { + PyErr_SetString(PyExc_TypeError, + "__new__ takes exactly one positional parameter"); + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs, + "|Ol:__new__", argnames, + &signature, &variantness)) { + return NULL; + } + if (variantness < 0) { + PyErr_SetString(PyExc_ValueError, + "variant_level must be non-negative"); + return NULL; + } + + self = (PyTuple_Type.tp_new)(cls, args, NULL); + if (!self) + return NULL; + if (PyTuple_Size(self) < 1) { + PyErr_SetString(PyExc_ValueError, "D-Bus structs may not be empty"); + Py_DECREF(self); + return NULL; + } + + if (!dbus_py_variant_level_set(self, variantness)) { + Py_DECREF(self); + return NULL; + } + + /* convert signature from a borrowed ref of unknown type to an owned ref + of type Signature (or None) */ + if (!signature) signature = Py_None; + if (signature == Py_None + || PyObject_IsInstance(signature, (PyObject *)&DBusPySignature_Type)) { + Py_INCREF(signature); + } + else { + signature = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, + "(O)", signature); + if (!signature) { + Py_DECREF(self); + return NULL; + } + } + + key = PyLong_FromVoidPtr(self); + if (!key) { + Py_DECREF(self); + Py_DECREF(signature); + return NULL; + } + if (PyDict_SetItem(struct_signatures, key, signature) < 0) { + Py_DECREF(key); + Py_DECREF(self); + Py_DECREF(signature); + return NULL; + } + + Py_DECREF(key); + Py_DECREF(signature); + return self; +} + +static void +Struct_tp_dealloc(PyObject *self) +{ + PyObject *et, *ev, *etb, *key; + + dbus_py_variant_level_clear(self); + PyErr_Fetch(&et, &ev, &etb); + + key = PyLong_FromVoidPtr(self); + if (key) { + if (PyDict_GetItem(struct_signatures, key)) { + if (PyDict_DelItem(struct_signatures, key) < 0) { + /* should never happen */ + PyErr_WriteUnraisable(self); + } + } + Py_DECREF(key); + } + else { + /* not enough memory to free all the memory... leak the signature, + * there's not much else we could do here */ + PyErr_WriteUnraisable(self); + } + + PyErr_Restore(et, ev, etb); + (PyTuple_Type.tp_dealloc)(self); +} + +static PyObject * +Struct_tp_getattro(PyObject *obj, PyObject *name) +{ + PyObject *key, *value; + + if (PyString_Check(name)) { + Py_INCREF(name); + } + else if (PyUnicode_Check(name)) { + name = PyUnicode_AsEncodedString(name, NULL, NULL); + if (!name) { + return NULL; + } + } + else { + PyErr_SetString(PyExc_TypeError, "attribute name must be string"); + return NULL; + } + + if (strcmp(PyString_AS_STRING(name), "signature")) { + value = dbus_py_variant_level_getattro(obj, name); + Py_DECREF(name); + return value; + } + + Py_DECREF(name); + + key = PyLong_FromVoidPtr(obj); + + if (!key) { + return NULL; + } + + value = PyDict_GetItem(struct_signatures, key); + Py_DECREF(key); + + if (!value) + value = Py_None; + Py_INCREF(value); + return value; +} + +PyTypeObject DBusPyStruct_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Struct", + 0, + 0, + Struct_tp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + (reprfunc)Struct_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + Struct_tp_getattro, /* tp_getattro */ + dbus_py_immutable_setattro, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Struct_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + Struct_tp_new, /* tp_new */ +}; + +dbus_bool_t +dbus_py_init_container_types(void) +{ + struct_signatures = PyDict_New(); + if (!struct_signatures) return 0; + + DBusPyArray_Type.tp_base = &PyList_Type; + if (PyType_Ready(&DBusPyArray_Type) < 0) return 0; + DBusPyArray_Type.tp_print = NULL; + + DBusPyDict_Type.tp_base = &PyDict_Type; + if (PyType_Ready(&DBusPyDict_Type) < 0) return 0; + DBusPyDict_Type.tp_print = NULL; + + DBusPyStruct_Type.tp_base = &PyTuple_Type; + if (PyType_Ready(&DBusPyStruct_Type) < 0) return 0; + DBusPyStruct_Type.tp_print = NULL; + + return 1; +} + +dbus_bool_t +dbus_py_insert_container_types(PyObject *this_module) +{ + Py_INCREF(&DBusPyArray_Type); + if (PyModule_AddObject(this_module, "Array", + (PyObject *)&DBusPyArray_Type) < 0) return 0; + + Py_INCREF(&DBusPyDict_Type); + if (PyModule_AddObject(this_module, "Dictionary", + (PyObject *)&DBusPyDict_Type) < 0) return 0; + + Py_INCREF(&DBusPyStruct_Type); + if (PyModule_AddObject(this_module, "Struct", + (PyObject *)&DBusPyStruct_Type) < 0) return 0; + + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ + diff --git a/_dbus_bindings/dbus_bindings-internal.h b/_dbus_bindings/dbus_bindings-internal.h new file mode 100644 index 0000000..e2b7fbe --- /dev/null +++ b/_dbus_bindings/dbus_bindings-internal.h @@ -0,0 +1,245 @@ +/* _dbus_bindings internal API. For use within _dbus_bindings only. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#ifndef DBUS_BINDINGS_INTERNAL_H +#define DBUS_BINDINGS_INTERNAL_H + +#define PY_SSIZE_T_CLEAN 1 + +#include + +/* Python < 2.5 compat */ +#if PY_VERSION_HEX < 0x02050000 && !defined(PY_SSIZE_T_MIN) +typedef int Py_ssize_t; +#define PY_SSIZE_T_MAX INT_MAX +#define PY_SSIZE_T_MIN INT_MIN +#endif + +#define INSIDE_DBUS_PYTHON_BINDINGS +#include "dbus-python.h" + +/* no need for extern "C", this is only for internal use */ + +/* on/off switch for debugging support (see below) */ +#undef USING_DBG +#if 0 && !defined(DBG_IS_TOO_VERBOSE) +# define USING_DBG 1 +#endif + +#define DEFINE_CHECK(type) \ +static inline int type##_Check (PyObject *o) \ +{ \ + return (PyObject_TypeCheck (o, &type##_Type)); \ +} \ +static inline int type##_CheckExact (PyObject *o) \ +{ \ + return ((o)->ob_type == &type##_Type); \ +} + +PyMODINIT_FUNC init_dbus_bindings(void); + +/* conn.c */ +extern PyTypeObject DBusPyConnection_Type; +DEFINE_CHECK(DBusPyConnection) +extern dbus_bool_t dbus_py_init_conn_types(void); +extern dbus_bool_t dbus_py_insert_conn_types(PyObject *this_module); + +/* libdbusconn.c */ +extern PyTypeObject DBusPyLibDBusConnection_Type; +DEFINE_CHECK(DBusPyLibDBusConnection) +PyObject *DBusPyLibDBusConnection_New(DBusConnection *conn); +extern dbus_bool_t dbus_py_init_libdbus_conn_types(void); +extern dbus_bool_t dbus_py_insert_libdbus_conn_types(PyObject *this_module); + +/* bus.c */ +extern dbus_bool_t dbus_py_init_bus_types(void); +extern dbus_bool_t dbus_py_insert_bus_types(PyObject *this_module); + +/* exceptions.c */ +extern PyObject *DBusPyException_SetString(const char *msg); +extern PyObject *DBusPyException_ConsumeError(DBusError *error); +extern dbus_bool_t dbus_py_init_exception_types(void); +extern dbus_bool_t dbus_py_insert_exception_types(PyObject *this_module); + +/* types */ +extern PyTypeObject DBusPyBoolean_Type; +DEFINE_CHECK(DBusPyBoolean) +extern PyTypeObject DBusPyObjectPath_Type, DBusPySignature_Type; +DEFINE_CHECK(DBusPyObjectPath) +DEFINE_CHECK(DBusPySignature) +extern PyTypeObject DBusPyArray_Type, DBusPyDict_Type, DBusPyStruct_Type; +DEFINE_CHECK(DBusPyArray) +DEFINE_CHECK(DBusPyDict) +DEFINE_CHECK(DBusPyStruct) +extern PyTypeObject DBusPyByte_Type, DBusPyByteArray_Type; +DEFINE_CHECK(DBusPyByteArray) +DEFINE_CHECK(DBusPyByte) +extern PyTypeObject DBusPyUTF8String_Type, DBusPyString_Type; +DEFINE_CHECK(DBusPyUTF8String) +DEFINE_CHECK(DBusPyString) +extern PyTypeObject DBusPyDouble_Type; +DEFINE_CHECK(DBusPyDouble) +extern PyTypeObject DBusPyInt16_Type, DBusPyUInt16_Type; +DEFINE_CHECK(DBusPyInt16) +DEFINE_CHECK(DBusPyUInt16) +extern PyTypeObject DBusPyInt32_Type, DBusPyUInt32_Type; +DEFINE_CHECK(DBusPyInt32) +DEFINE_CHECK(DBusPyUInt32) +extern PyTypeObject DBusPyInt64_Type, DBusPyUInt64_Type; +DEFINE_CHECK(DBusPyInt64) +DEFINE_CHECK(DBusPyUInt64) +extern dbus_bool_t dbus_py_init_abstract(void); +extern dbus_bool_t dbus_py_init_signature(void); +extern dbus_bool_t dbus_py_init_int_types(void); +extern dbus_bool_t dbus_py_init_string_types(void); +extern dbus_bool_t dbus_py_init_float_types(void); +extern dbus_bool_t dbus_py_init_container_types(void); +extern dbus_bool_t dbus_py_init_byte_types(void); +extern dbus_bool_t dbus_py_insert_abstract_types(PyObject *this_module); +extern dbus_bool_t dbus_py_insert_signature(PyObject *this_module); +extern dbus_bool_t dbus_py_insert_int_types(PyObject *this_module); +extern dbus_bool_t dbus_py_insert_string_types(PyObject *this_module); +extern dbus_bool_t dbus_py_insert_float_types(PyObject *this_module); +extern dbus_bool_t dbus_py_insert_container_types(PyObject *this_module); +extern dbus_bool_t dbus_py_insert_byte_types(PyObject *this_module); + +/* generic */ +extern void dbus_py_take_gil_and_xdecref(PyObject *); +extern int dbus_py_immutable_setattro(PyObject *, PyObject *, PyObject *); +extern PyObject *dbus_py_tp_richcompare_by_pointer(PyObject *, + PyObject *, + int); +extern long dbus_py_tp_hash_by_pointer(PyObject *self); +extern PyObject *dbus_py_empty_tuple; +extern dbus_bool_t dbus_py_init_generic(void); + +/* message.c */ +extern DBusMessage *DBusPyMessage_BorrowDBusMessage(PyObject *msg); +extern PyObject *DBusPyMessage_ConsumeDBusMessage(DBusMessage *); +extern dbus_bool_t dbus_py_init_message_types(void); +extern dbus_bool_t dbus_py_insert_message_types(PyObject *this_module); + +/* pending-call.c */ +extern PyObject *DBusPyPendingCall_ConsumeDBusPendingCall(DBusPendingCall *, + PyObject *); +extern dbus_bool_t dbus_py_init_pending_call(void); +extern dbus_bool_t dbus_py_insert_pending_call(PyObject *this_module); + +/* mainloop.c */ +extern dbus_bool_t dbus_py_set_up_connection(PyObject *conn, + PyObject *mainloop); +extern dbus_bool_t dbus_py_set_up_server(PyObject *server, + PyObject *mainloop); +extern PyObject *dbus_py_get_default_main_loop(void); +extern dbus_bool_t dbus_py_check_mainloop_sanity(PyObject *); +extern dbus_bool_t dbus_py_init_mainloop(void); +extern dbus_bool_t dbus_py_insert_mainloop_types(PyObject *); + +/* server.c */ +extern PyTypeObject DBusPyServer_Type; +DEFINE_CHECK(DBusPyServer) +extern dbus_bool_t dbus_py_init_server_types(void); +extern dbus_bool_t dbus_py_insert_server_types(PyObject *this_module); +extern DBusServer *DBusPyServer_BorrowDBusServer(PyObject *self); + +/* validation.c */ +dbus_bool_t dbus_py_validate_bus_name(const char *name, + dbus_bool_t may_be_unique, + dbus_bool_t may_be_not_unique); +dbus_bool_t dbus_py_validate_member_name(const char *name); +dbus_bool_t dbus_py_validate_interface_name(const char *name); +dbus_bool_t dbus_py_validate_object_path(const char *path); +#define dbus_py_validate_error_name dbus_py_validate_interface_name + +/* debugging support */ +void _dbus_py_assertion_failed(const char *); +#define DBUS_PY_RAISE_VIA_NULL_IF_FAIL(assertion) \ + do { if (!(assertion)) { \ + _dbus_py_assertion_failed(#assertion); \ + return NULL; \ + } \ + } while (0) + +#define DBUS_PY_RAISE_VIA_GOTO_IF_FAIL(assertion, label) \ + do { if (!(assertion)) { \ + _dbus_py_assertion_failed(#assertion); \ + goto label; \ + } \ + } while (0) + +#define DBUS_PY_RAISE_VIA_RETURN_IF_FAIL(assertion, value) \ + do { if (!(assertion)) { \ + _dbus_py_assertion_failed(#assertion); \ + return value; \ + } \ + } while (0) + +/* verbose debugging support */ +#ifdef USING_DBG + +# include +# include + +void _dbus_py_dbg_exc(void); +void _dbus_py_whereami(void); +void _dbus_py_dbg_dump_message(DBusMessage *); + +# define TRACE(self) do { fprintf(stderr, "TRACE: <%s at %p> in %s, " \ + "%d refs\n", \ + self->ob_type->tp_name, \ + self, __func__, \ + self->ob_refcnt); } while (0) +# define DBG(format, ...) fprintf(stderr, "DEBUG: " format "\n",\ + __VA_ARGS__) +# define DBG_EXC(format, ...) do {DBG(format, __VA_ARGS__); \ + _dbus_py_dbg_exc();} while (0) +# define DBG_DUMP_MESSAGE(x) _dbus_py_dbg_dump_message(x) +# define DBG_WHEREAMI _dbus_py_whereami() + +#else /* !defined(USING_DBG) */ + +# define TRACE(self) do {} while (0) +# define DBG(format, ...) do {} while (0) +# define DBG_EXC(format, ...) do {} while (0) +# define DBG_DUMP_MESSAGE(x) do {} while (0) +# define DBG_WHEREAMI do {} while (0) + +#endif /* !defined(USING_DBG) */ + +/* General-purpose Python glue */ + +#define DEFERRED_ADDRESS(ADDR) 0 + +#if defined(__GNUC__) +# if __GNUC__ >= 3 +# define UNUSED __attribute__((__unused__)) +# else +# define UNUSED /*nothing*/ +# endif +#else +# define UNUSED /*nothing*/ +#endif + +#endif diff --git a/_dbus_bindings/debug.c b/_dbus_bindings/debug.c new file mode 100644 index 0000000..b347628 --- /dev/null +++ b/_dbus_bindings/debug.c @@ -0,0 +1,95 @@ +/* Debug code for _dbus_bindings. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" +#include + +void +_dbus_py_assertion_failed(const char *assertion) +{ + PyErr_SetString(PyExc_AssertionError, assertion); +#if 1 || defined(USING_DBG) || defined(FATAL_ASSERTIONS) + /* print the Python stack, and dump core so we can see the C stack too */ + PyErr_Print(); + abort(); +#endif +} + +#ifdef USING_DBG +void +_dbus_py_whereami(void) +{ + PyObject *c, *v, *t; + /* This is a little mad. We want to get the traceback without + clearing the error indicator, if any. */ + PyErr_Fetch(&c, &v, &t); /* 3 new refs */ + Py_XINCREF(c); Py_XINCREF(v); Py_XINCREF(t); /* now we own 6 refs */ + PyErr_Restore(c, v, t); /* steals 3 refs */ + + if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_AssertionError, + "No error, but plz provide traceback kthx"); + } + PyErr_Print(); + + PyErr_Restore(c, v, t); /* steals another 3 refs */ +} + +void +_dbus_py_dbg_exc(void) +{ + PyObject *c, *v, *t; + /* This is a little mad. We want to get the traceback without + clearing the error indicator. */ + PyErr_Fetch(&c, &v, &t); /* 3 new refs */ + Py_XINCREF(c); Py_XINCREF(v); Py_XINCREF(t); /* now we own 6 refs */ + PyErr_Restore(c, v, t); /* steals 3 refs */ + PyErr_Print(); + PyErr_Restore(c, v, t); /* steals another 3 refs */ +} + +void +_dbus_py_dbg_dump_message(DBusMessage *message) +{ + const char *s; + fprintf(stderr, "DBusMessage at %p\n", message); + + s = dbus_message_get_destination(message); + if (!s) s = "(null)"; + fprintf(stderr, "\tdestination %s\n", s); + + s = dbus_message_get_interface(message); + if (!s) s = "(null)"; + fprintf(stderr, "\tinterface %s\n", s); + + s = dbus_message_get_member(message); + if (!s) s = "(null)"; + fprintf(stderr, "\tmember %s\n", s); + + s = dbus_message_get_path(message); + if (!s) s = "(null)"; + fprintf(stderr, "\tpath %s\n", s); +} +#endif diff --git a/_dbus_bindings/exceptions.c b/_dbus_bindings/exceptions.c new file mode 100644 index 0000000..141ce9e --- /dev/null +++ b/_dbus_bindings/exceptions.c @@ -0,0 +1,99 @@ +/* D-Bus exception base classes. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" + +static PyObject *imported_dbus_exception = NULL; + +static dbus_bool_t +import_exception(void) +{ + PyObject *name; + PyObject *exceptions; + + if (imported_dbus_exception != NULL) { + return TRUE; + } + + name = PyString_FromString("dbus.exceptions"); + if (name == NULL) { + return FALSE; + } + exceptions = PyImport_Import(name); + Py_DECREF(name); + if (exceptions == NULL) { + return FALSE; + } + imported_dbus_exception = PyObject_GetAttrString(exceptions, + "DBusException"); + Py_DECREF(exceptions); + + return (imported_dbus_exception != NULL); +} + +PyObject * +DBusPyException_SetString(const char *msg) +{ + if (imported_dbus_exception != NULL || import_exception()) { + PyErr_SetString(imported_dbus_exception, msg); + } + return NULL; +} + +PyObject * +DBusPyException_ConsumeError(DBusError *error) +{ + PyObject *exc_value = NULL; + + if (imported_dbus_exception == NULL && !import_exception()) { + goto finally; + } + + exc_value = PyObject_CallFunction(imported_dbus_exception, + "s", + error->message ? error->message + : ""); + if (error->name) { + PyObject *name = PyString_FromString(error->name); + int ret; + + if (!name) + goto finally; + ret = PyObject_SetAttrString(exc_value, "_dbus_error_name", name); + Py_DECREF(name); + if (ret < 0) { + goto finally; + } + } + + PyErr_SetObject(imported_dbus_exception, exc_value); + +finally: + Py_XDECREF(exc_value); + dbus_error_free(error); + return NULL; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/float.c b/_dbus_bindings/float.c new file mode 100644 index 0000000..5826ec3 --- /dev/null +++ b/_dbus_bindings/float.c @@ -0,0 +1,158 @@ +/* Simple D-Bus types: Double and (with appropriate #defines) Float + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include + +#include "dbus_bindings-internal.h" +#include "types-internal.h" + +PyDoc_STRVAR(Double_tp_doc, +"A double-precision floating point number (a subtype of float)."); + +#ifdef WITH_DBUS_FLOAT32 +PyDoc_STRVAR(Float_tp_doc, +"A single-precision floating point number (a subtype of float)."); +#endif + +PyTypeObject DBusPyDouble_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Double", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Double_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPythonFloatType), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ +}; + +#ifdef WITH_DBUS_FLOAT32 + +PyTypeObject DBusPyFloat_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Float", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Float_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPythonFloatType), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ +}; +#endif /* defined(WITH_DBUS_FLOAT32) */ + +dbus_bool_t +dbus_py_init_float_types(void) +{ + DBusPyDouble_Type.tp_base = &DBusPyFloatBase_Type; + if (PyType_Ready(&DBusPyDouble_Type) < 0) return 0; + DBusPyDouble_Type.tp_print = NULL; + +#ifdef WITH_DBUS_FLOAT32 + DBusPyFloat_Type.tp_base = &DBusPyFloatBase_Type; + if (PyType_Ready(&DBusPyFloat_Type) < 0) return 0; + DBusPyFloat_Type.tp_print = NULL; +#endif + + return 1; +} + +dbus_bool_t +dbus_py_insert_float_types(PyObject *this_module) +{ + Py_INCREF(&DBusPyDouble_Type); + if (PyModule_AddObject(this_module, "Double", + (PyObject *)&DBusPyDouble_Type) < 0) return 0; +#ifdef WITH_DBUS_FLOAT32 + Py_INCREF(&DBusPyFloat_Type); + if (PyModule_AddObject(this_module, "Float", + (PyObject *)&DBusPyFloat_Type) < 0) return 0; +#endif + + return 1; +} diff --git a/_dbus_bindings/generic.c b/_dbus_bindings/generic.c new file mode 100644 index 0000000..cda138d --- /dev/null +++ b/_dbus_bindings/generic.c @@ -0,0 +1,84 @@ +/* General Python glue code, used in _dbus_bindings but not actually anything + * to do with D-Bus. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" + +/* The empty tuple, held globally since dbus-python turns out to use it quite + * a lot + */ +PyObject *dbus_py_empty_tuple = NULL; + +PyObject * +dbus_py_tp_richcompare_by_pointer(PyObject *self, + PyObject *other, + int op) +{ + if (op == Py_EQ || op == Py_NE) { + if (self == other) { + return PyInt_FromLong(op == Py_EQ); + } + return PyInt_FromLong(op == Py_NE); + } + PyErr_SetString(PyExc_TypeError, + "Instances of this type are not ordered"); + return NULL; +} + +long +dbus_py_tp_hash_by_pointer(PyObject *self) +{ + long hash = (long)self; + return (hash == -1L ? -2L : hash); +} + +int +dbus_py_immutable_setattro(PyObject *obj UNUSED, + PyObject *name UNUSED, + PyObject *value UNUSED) +{ + PyErr_SetString(PyExc_AttributeError, "Object is immutable"); + return -1; +} + +/* Take the global interpreter lock and decrement the reference count. + * Suitable for calling from a C callback. */ +void +dbus_py_take_gil_and_xdecref(PyObject *obj) +{ + PyGILState_STATE gil = PyGILState_Ensure(); + Py_XDECREF(obj); + PyGILState_Release(gil); +} + +dbus_bool_t +dbus_py_init_generic(void) +{ + dbus_py_empty_tuple = PyTuple_New(0); + if (!dbus_py_empty_tuple) return 0; + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/int.c b/_dbus_bindings/int.c new file mode 100644 index 0000000..b669d57 --- /dev/null +++ b/_dbus_bindings/int.c @@ -0,0 +1,779 @@ +/* Simple D-Bus types: integers of various sizes, and ObjectPath. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "types-internal.h" + +/* Specific types =================================================== */ + +/* Boolean, a subclass of DBusPythonInt ============================= */ + +PyDoc_STRVAR(Boolean_tp_doc, +"A boolean, represented as a subtype of `int` (not `bool`, because `bool`\n" +"cannot be subclassed).\n" +"\n" +"Constructor::\n" +"\n" +" dbus.Boolean(value[, variant_level]) -> Boolean\n" +"\n" +"``value`` is converted to 0 or 1 as if by ``int(bool(value))``.\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a boolean, this is represented in Python by a\n" +" Boolean with variant_level==2.\n" +); + +static PyObject * +Boolean_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *tuple, *self, *value = Py_None; + long variantness = 0; + static char *argnames[] = {"_", "variant_level", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|Ol:__new__", argnames, + &value, &variantness)) return NULL; + if (variantness < 0) { + PyErr_SetString(PyExc_ValueError, + "variant_level must be non-negative"); + return NULL; + } + tuple = Py_BuildValue("(i)", PyObject_IsTrue(value) ? 1 : 0); + if (!tuple) return NULL; + self = (DBusPyIntBase_Type.tp_new)(cls, tuple, kwargs); + Py_DECREF(tuple); + return self; +} + +static PyObject * +Boolean_tp_repr (PyObject *self) +{ + long variant_level = ((DBusPyIntBase *)self)->variant_level; + if (variant_level > 0) { + return PyString_FromFormat("%s(%s, variant_level=%ld)", + self->ob_type->tp_name, + PyInt_AsLong(self) ? "True" : "False", + variant_level); + } + return PyString_FromFormat("%s(%s)", + self->ob_type->tp_name, + PyInt_AsLong(self) ? "True" : "False"); +} + +PyTypeObject DBusPyBoolean_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Boolean", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + Boolean_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Boolean_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyIntBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + Boolean_tp_new, /* tp_new */ +}; + +/* Int16 ============================================================ */ + +PyDoc_STRVAR(Int16_tp_doc, +"A signed 16-bit integer between -0x8000 and +0x7FFF, represented as\n" +"a subtype of `int`.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.Int16(value: int[, variant_level: int]) -> Int16\n" +"\n" +"value must be within the allowed range, or OverflowError will be\n" +"raised.\n" +"\n" +" variant_level must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing an int16, this is represented in Python by an\n" +" Int16 with variant_level==2.\n" +); + +dbus_int16_t +dbus_py_int16_range_check(PyObject *obj) +{ + long i = PyInt_AsLong (obj); + if (i == -1 && PyErr_Occurred ()) return -1; + if (i < -0x8000 || i > 0x7fff) { + PyErr_Format(PyExc_OverflowError, "Value %d out of range for Int16", + (int)i); + return -1; + } + return i; +} + +static PyObject * +Int16_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self = (DBusPyIntBase_Type.tp_new)(cls, args, kwargs); + if (self && dbus_py_int16_range_check(self) == -1 && PyErr_Occurred()) { + Py_DECREF(self); + return NULL; + } + return self; +} + +PyTypeObject DBusPyInt16_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Int16", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Int16_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyIntBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + Int16_tp_new, /* tp_new */ +}; + +/* UInt16 =========================================================== */ + +PyDoc_STRVAR(UInt16_tp_doc, +"An unsigned 16-bit integer between 0 and 0xFFFF, represented as\n" +"a subtype of `int`.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.UInt16(value: int[, variant_level: int]) -> UInt16\n" +"\n" +"``value`` must be within the allowed range, or `OverflowError` will be\n" +"raised.\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a uint16, this is represented in Python by a\n" +" UInt16 with variant_level==2.\n" +); + +dbus_uint16_t +dbus_py_uint16_range_check(PyObject *obj) +{ + long i = PyInt_AsLong(obj); + if (i == -1 && PyErr_Occurred()) return (dbus_uint16_t)(-1); + if (i < 0 || i > 0xffff) { + PyErr_Format(PyExc_OverflowError, "Value %d out of range for UInt16", + (int)i); + return (dbus_uint16_t)(-1); + } + return i; +} + +static PyObject * +UInt16_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self = (DBusPyIntBase_Type.tp_new)(cls, args, kwargs); + if (self && dbus_py_uint16_range_check(self) == (dbus_uint16_t)(-1) + && PyErr_Occurred()) { + Py_DECREF (self); + return NULL; + } + return self; +} + +PyTypeObject DBusPyUInt16_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.UInt16", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + UInt16_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyIntBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + UInt16_tp_new, /* tp_new */ +}; + +/* Int32 ============================================================ */ + +PyDoc_STRVAR(Int32_tp_doc, +"A signed 32-bit integer between -0x8000 0000 and +0x7FFF FFFF, represented as\n" +"a subtype of `int`.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.Int32(value: int[, variant_level: int]) -> Int32\n" +"\n" +"``value`` must be within the allowed range, or `OverflowError` will be\n" +"raised.\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing an int32, this is represented in Python by an\n" +" Int32 with variant_level==2.\n" +); + +dbus_int32_t +dbus_py_int32_range_check(PyObject *obj) +{ + long i = PyInt_AsLong(obj); + if (i == -1 && PyErr_Occurred()) return -1; + if (i < INT32_MIN || i > INT32_MAX) { + PyErr_Format(PyExc_OverflowError, "Value %d out of range for Int32", + (int)i); + return -1; + } + return i; +} + +static PyObject * +Int32_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self = (DBusPyIntBase_Type.tp_new)(cls, args, kwargs); + if (self && dbus_py_int32_range_check(self) == -1 && PyErr_Occurred()) { + Py_DECREF(self); + return NULL; + } + return self; +} + +PyTypeObject DBusPyInt32_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Int32", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Int32_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyIntBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + Int32_tp_new, /* tp_new */ +}; + +/* UInt32 =========================================================== */ + +PyDoc_STRVAR(UInt32_tp_doc, +"An unsigned 32-bit integer between 0 and 0xFFFF FFFF, represented as a\n" +"subtype of `long`.\n" +"\n" +"Note that this may be changed in future to be a subtype of `int` on\n" +"64-bit platforms; applications should not rely on either behaviour.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.UInt32(value: long[, variant_level: int]) -> UInt32\n" +"\n" +"``value`` must be within the allowed range, or `OverflowError` will be\n" +"raised.\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a uint32, this is represented in Python by a\n" +" UInt32 with variant_level==2.\n" +); + +dbus_uint32_t +dbus_py_uint32_range_check(PyObject *obj) +{ + unsigned long i; + PyObject *long_obj = PyNumber_Long(obj); + + if (!long_obj) return (dbus_uint32_t)(-1); + i = PyLong_AsUnsignedLong(long_obj); + if (i == (unsigned long)(-1) && PyErr_Occurred()) { + Py_DECREF(long_obj); + return (dbus_uint32_t)(-1); + } + if (i > UINT32_MAX) { + PyErr_Format(PyExc_OverflowError, "Value %d out of range for UInt32", + (int)i); + Py_DECREF(long_obj); + return (dbus_uint32_t)(-1); + } + Py_DECREF(long_obj); + return i; +} + +static PyObject * +UInt32_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self = (DBusPyLongBase_Type.tp_new)(cls, args, kwargs); + if (self && dbus_py_uint32_range_check(self) == (dbus_uint32_t)(-1) + && PyErr_Occurred()) { + Py_DECREF(self); + return NULL; + } + return self; +} + +PyTypeObject DBusPyUInt32_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.UInt32", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + UInt32_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyLongBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + UInt32_tp_new, /* tp_new */ +}; + +/* Int64 =========================================================== */ + +PyDoc_STRVAR(Int64_tp_doc, +"A signed 64-bit integer between -0x8000 0000 0000 0000 and\n" +"+0x7FFF FFFF FFFF FFFF, represented as a subtype of `long`.\n" +"\n" +"Note that this may be changed in future to be a subtype of `int` on\n" +"64-bit platforms; applications should not rely on either behaviour.\n" +"\n" +"This type only works on platforms where the C compiler has suitable\n" +"64-bit types, such as C99 ``long long``.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.Int64(value: long[, variant_level: int]) -> Int64\n" +"\n" +"``value`` must be within the allowed range, or `OverflowError` will be\n" +"raised.\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing an int64, this is represented in Python by an\n" +" Int64 with variant_level==2.\n" +); + +#ifdef DBUS_PYTHON_64_BIT_WORKS +dbus_int64_t +dbus_py_int64_range_check(PyObject *obj) +{ + PY_LONG_LONG i; + PyObject *long_obj = PyNumber_Long(obj); + + if (!long_obj) return -1; + i = PyLong_AsLongLong(long_obj); + if (i == -1 && PyErr_Occurred()) { + Py_DECREF(long_obj); + return -1; + } + if (i < INT64_MIN || i > INT64_MAX) { + PyErr_SetString(PyExc_OverflowError, "Value out of range for Int64"); + Py_DECREF(long_obj); + return -1; + } + Py_DECREF(long_obj); + return i; +} +#endif + +static PyObject * +Int64_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ +#ifdef DBUS_PYTHON_64_BIT_WORKS + PyObject *self = (DBusPyLongBase_Type.tp_new)(cls, args, kwargs); + if (self && dbus_py_int64_range_check(self) == -1 && PyErr_Occurred()) { + Py_DECREF(self); + return NULL; + } + return self; +#else + PyErr_SetString(PyExc_NotImplementedError, + "64-bit types are not available on this platform"); + return NULL; +#endif +} + +PyTypeObject DBusPyInt64_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Int64", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Int64_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyLongBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + Int64_tp_new, /* tp_new */ +}; + +/* UInt64 =========================================================== */ + +PyDoc_STRVAR(UInt64_tp_doc, +"An unsigned 64-bit integer between 0 and 0xFFFF FFFF FFFF FFFF,\n" +"represented as a subtype of `long`.\n" +"\n" +"This type only exists on platforms where the C compiler has suitable\n" +"64-bit types, such as C99 ``unsigned long long``.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.UInt64(value: long[, variant_level: int]) -> UInt64\n" +"\n" +"``value`` must be within the allowed range, or `OverflowError` will be\n" +"raised.\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a uint64, this is represented in Python by a\n" +" UInt64 with variant_level==2.\n" +); + +dbus_uint64_t +dbus_py_uint64_range_check(PyObject *obj) +{ + unsigned PY_LONG_LONG i; + PyObject *long_obj = PyNumber_Long(obj); + + if (!long_obj) return (dbus_uint64_t)(-1); + i = PyLong_AsUnsignedLongLong(long_obj); + if (i == (unsigned PY_LONG_LONG)(-1) && PyErr_Occurred()) { + Py_DECREF(long_obj); + return (dbus_uint64_t)(-1); + } + if (i > UINT64_MAX) { + PyErr_SetString(PyExc_OverflowError, "Value out of range for UInt64"); + Py_DECREF(long_obj); + return (dbus_uint64_t)(-1); + } + Py_DECREF(long_obj); + return i; +} + +static PyObject * +UInt64_tp_new (PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ +#ifdef DBUS_PYTHON_64_BIT_WORKS + PyObject *self = (DBusPyLongBase_Type.tp_new)(cls, args, kwargs); + if (self && dbus_py_uint64_range_check(self) == (dbus_uint64_t)(-1) + && PyErr_Occurred()) { + Py_DECREF(self); + return NULL; + } + return self; +#else + PyErr_SetString(PyExc_NotImplementedError, + "64-bit integer types are not supported on this platform"); + return NULL; +#endif +} + +PyTypeObject DBusPyUInt64_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.UInt64", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + UInt64_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyLongBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + UInt64_tp_new, /* tp_new */ +}; + +dbus_bool_t +dbus_py_init_int_types(void) +{ + DBusPyInt16_Type.tp_base = &DBusPyIntBase_Type; + if (PyType_Ready(&DBusPyInt16_Type) < 0) return 0; + /* disable the tp_print copied from PyInt_Type, so tp_repr gets called as + desired */ + DBusPyInt16_Type.tp_print = NULL; + + DBusPyUInt16_Type.tp_base = &DBusPyIntBase_Type; + if (PyType_Ready(&DBusPyUInt16_Type) < 0) return 0; + DBusPyUInt16_Type.tp_print = NULL; + + DBusPyInt32_Type.tp_base = &DBusPyIntBase_Type; + if (PyType_Ready(&DBusPyInt32_Type) < 0) return 0; + DBusPyInt32_Type.tp_print = NULL; + + DBusPyUInt32_Type.tp_base = &DBusPyLongBase_Type; + if (PyType_Ready(&DBusPyUInt32_Type) < 0) return 0; + DBusPyUInt32_Type.tp_print = NULL; + +#if defined(DBUS_HAVE_INT64) && defined(HAVE_LONG_LONG) + DBusPyInt64_Type.tp_base = &DBusPyLongBase_Type; + if (PyType_Ready(&DBusPyInt64_Type) < 0) return 0; + DBusPyInt64_Type.tp_print = NULL; + + DBusPyUInt64_Type.tp_base = &DBusPyLongBase_Type; + if (PyType_Ready(&DBusPyUInt64_Type) < 0) return 0; + DBusPyUInt64_Type.tp_print = NULL; +#endif + return 1; +} + +dbus_bool_t +dbus_py_insert_int_types(PyObject *this_module) +{ + Py_INCREF(&DBusPyInt16_Type); + Py_INCREF(&DBusPyUInt16_Type); + Py_INCREF(&DBusPyInt32_Type); + Py_INCREF(&DBusPyUInt32_Type); + Py_INCREF(&DBusPyInt64_Type); + Py_INCREF(&DBusPyUInt64_Type); + Py_INCREF(&DBusPyBoolean_Type); + if (PyModule_AddObject(this_module, "Int16", + (PyObject *)&DBusPyInt16_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "UInt16", + (PyObject *)&DBusPyUInt16_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "Int32", + (PyObject *)&DBusPyInt32_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "UInt32", + (PyObject *)&DBusPyUInt32_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "Int64", + (PyObject *)&DBusPyInt64_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "UInt64", + (PyObject *)&DBusPyUInt64_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "Boolean", + (PyObject *)&DBusPyBoolean_Type) < 0) return 0; + + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/libdbusconn.c b/_dbus_bindings/libdbusconn.c new file mode 100644 index 0000000..9bd8def --- /dev/null +++ b/_dbus_bindings/libdbusconn.c @@ -0,0 +1,124 @@ +/* An extremely thin wrapper around a libdbus Connection, for use by + * Server. + * + * Copyright (C) 2008 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" +#include "conn-internal.h" + +PyDoc_STRVAR(DBusPyLibDBusConnection_tp_doc, +"A reference to a ``DBusConnection`` from ``libdbus``, which might not\n" +"have been attached to a `dbus.connection.Connection` yet.\n" +"\n" +"Cannot be instantiated from Python. The only use of this object is to\n" +"pass it to the ``dbus.connection.Connection`` constructor instead of an\n" +"address.\n" +); + +/** Create a DBusPyLibDBusConnection from a DBusConnection. + */ +PyObject * +DBusPyLibDBusConnection_New(DBusConnection *conn) +{ + DBusPyLibDBusConnection *self = NULL; + + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(conn); + + self = (DBusPyLibDBusConnection *)(DBusPyLibDBusConnection_Type.tp_alloc( + &DBusPyLibDBusConnection_Type, 0)); + + if (!self) + return NULL; + + self->conn = dbus_connection_ref (conn); + + return (PyObject *)self; +} + +/* Destructor */ +static void +DBusPyLibDBusConnection_tp_dealloc(Connection *self) +{ + DBusConnection *conn = self->conn; + PyObject *et, *ev, *etb; + + /* avoid clobbering any pending exception */ + PyErr_Fetch(&et, &ev, &etb); + + self->conn = NULL; + + if (conn) { + dbus_connection_unref(conn); + } + + PyErr_Restore(et, ev, etb); + (self->ob_type->tp_free)((PyObject *) self); +} + +PyTypeObject DBusPyLibDBusConnection_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_dbus_bindings._LibDBusConnection", + sizeof(DBusPyLibDBusConnection), + 0, /*tp_itemsize*/ + /* methods */ + (destructor)DBusPyLibDBusConnection_tp_dealloc, + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT, + DBusPyLibDBusConnection_tp_doc, +}; + +dbus_bool_t +dbus_py_init_libdbus_conn_types(void) +{ + if (PyType_Ready(&DBusPyLibDBusConnection_Type) < 0) + return FALSE; + + return TRUE; +} + +dbus_bool_t +dbus_py_insert_libdbus_conn_types(PyObject *this_module) +{ + if (PyModule_AddObject(this_module, "_LibDBusConnection", + (PyObject *)&DBusPyLibDBusConnection_Type) < 0) + return FALSE; + + return TRUE; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/mainloop.c b/_dbus_bindings/mainloop.c new file mode 100644 index 0000000..1733410 --- /dev/null +++ b/_dbus_bindings/mainloop.c @@ -0,0 +1,208 @@ +/* Implementation of main-loop integration for dbus-python. + * + * Copyright (C) 2006 Collabora Ltd. + * Copyright (C) 2008 Huang Peng + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "config.h" + +#include "dbus_bindings-internal.h" + +/* Native mainloop wrapper ========================================= */ + +PyDoc_STRVAR(NativeMainLoop_tp_doc, +"Object representing D-Bus main loop integration done in native code.\n" +"Cannot be instantiated directly.\n" +); + +static PyTypeObject NativeMainLoop_Type; + +DEFINE_CHECK(NativeMainLoop) + +typedef struct { + PyObject_HEAD + /* Called with the GIL held, should set a Python exception on error */ + dbus_bool_t (*set_up_connection_cb)(DBusConnection *, void *); + dbus_bool_t (*set_up_server_cb)(DBusServer *, void *); + /* Called in a destructor. Must not touch the exception state (use + * PyErr_Fetch and PyErr_Restore if necessary). */ + void (*free_cb)(void *); + void *data; +} NativeMainLoop; + +static void NativeMainLoop_tp_dealloc(NativeMainLoop *self) +{ + if (self->data && self->free_cb) { + (self->free_cb)(self->data); + } + PyObject_Del((PyObject *)self); +} + +static PyTypeObject NativeMainLoop_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.mainloop.NativeMainLoop", + sizeof(NativeMainLoop), + 0, + (destructor)NativeMainLoop_tp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + NativeMainLoop_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + /* deliberately not callable! */ + 0, /* tp_new */ +}; + +/* Internal C API for Connection, Bus, Server ======================= */ + +dbus_bool_t +dbus_py_check_mainloop_sanity(PyObject *mainloop) +{ + if (NativeMainLoop_Check(mainloop)) { + return TRUE; + } + PyErr_SetString(PyExc_TypeError, + "A dbus.mainloop.NativeMainLoop instance is required"); + return FALSE; +} + +dbus_bool_t +dbus_py_set_up_connection(PyObject *conn, PyObject *mainloop) +{ + if (NativeMainLoop_Check(mainloop)) { + /* Native mainloops are allowed to do arbitrary strange things */ + NativeMainLoop *nml = (NativeMainLoop *)mainloop; + DBusConnection *dbc = DBusPyConnection_BorrowDBusConnection(conn); + + if (!dbc) { + return FALSE; + } + return (nml->set_up_connection_cb)(dbc, nml->data); + } + PyErr_SetString(PyExc_TypeError, + "A dbus.mainloop.NativeMainLoop instance is required"); + return FALSE; +} + +dbus_bool_t +dbus_py_set_up_server(PyObject *server, PyObject *mainloop) +{ + if (NativeMainLoop_Check(mainloop)) { + /* Native mainloops are allowed to do arbitrary strange things */ + NativeMainLoop *nml = (NativeMainLoop *)mainloop; + DBusServer *dbs = DBusPyServer_BorrowDBusServer(server); + + if (!dbs) { + return FALSE; + } + return (nml->set_up_server_cb)(dbs, nml->data); + } + PyErr_SetString(PyExc_TypeError, + "A dbus.mainloop.NativeMainLoop instance is required"); + return FALSE; +} + +/* C API ============================================================ */ + +PyObject * +DBusPyNativeMainLoop_New4(dbus_bool_t (*conn_cb)(DBusConnection *, void *), + dbus_bool_t (*server_cb)(DBusServer *, void *), + void (*free_cb)(void *), + void *data) +{ + NativeMainLoop *self = PyObject_New(NativeMainLoop, &NativeMainLoop_Type); + if (self) { + self->data = data; + self->free_cb = free_cb; + self->set_up_connection_cb = conn_cb; + self->set_up_server_cb = server_cb; + } + return (PyObject *)self; +} + +/* Null mainloop implementation ===================================== */ + +static dbus_bool_t +noop_main_loop_cb(void *conn_or_server UNUSED, void *data UNUSED) +{ + return TRUE; +} + +#define noop_conn_cb ((dbus_bool_t (*)(DBusConnection *, void *))(noop_main_loop_cb)) +#define noop_server_cb ((dbus_bool_t (*)(DBusServer *, void *))(noop_main_loop_cb)) + +/* Initialization =================================================== */ + +dbus_bool_t +dbus_py_init_mainloop(void) +{ + if (PyType_Ready (&NativeMainLoop_Type) < 0) return 0; + + return 1; +} + +dbus_bool_t +dbus_py_insert_mainloop_types(PyObject *this_module) +{ + PyObject *null_main_loop = DBusPyNativeMainLoop_New4(noop_conn_cb, + noop_server_cb, + NULL, + NULL); + if (!null_main_loop) return 0; + + if (PyModule_AddObject (this_module, "NativeMainLoop", + (PyObject *)&NativeMainLoop_Type) < 0) return 0; + if (PyModule_AddObject (this_module, "NULL_MAIN_LOOP", + null_main_loop) < 0) return 0; + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/message-append.c b/_dbus_bindings/message-append.c new file mode 100644 index 0000000..93b76c7 --- /dev/null +++ b/_dbus_bindings/message-append.c @@ -0,0 +1,1092 @@ +/* D-Bus Message serialization. This contains all the logic to map from + * Python objects to D-Bus types. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#define DBG_IS_TOO_VERBOSE +#include "types-internal.h" +#include "message-internal.h" + +/* Return the number of variants wrapping the given object. Return 0 + * if the object is not a D-Bus type. + */ +static long +get_variant_level(PyObject *obj) +{ + if (DBusPyIntBase_Check(obj)) { + return ((DBusPyIntBase *)obj)->variant_level; + } + else if (DBusPyFloatBase_Check(obj)) { + return ((DBusPyFloatBase *)obj)->variant_level; + } + else if (DBusPyArray_Check(obj)) { + return ((DBusPyArray *)obj)->variant_level; + } + else if (DBusPyDict_Check(obj)) { + return ((DBusPyDict *)obj)->variant_level; + } + else if (DBusPyString_Check(obj)) { + return ((DBusPyString *)obj)->variant_level; + } + else if (DBusPyLongBase_Check(obj) || + DBusPyStrBase_Check(obj) || + DBusPyStruct_Check(obj)) { + return dbus_py_variant_level_get(obj); + } + else { + return 0; + } +} + +char dbus_py_Message_append__doc__[] = ( +"set_args(*args[, **kwargs])\n\n" +"Set the message's arguments from the positional parameter, according to\n" +"the signature given by the ``signature`` keyword parameter.\n" +"\n" +"The following type conversions are supported:\n\n" +"=============================== ===========================\n" +"D-Bus (in signature) Python\n" +"=============================== ===========================\n" +"boolean (b) any object (via bool())\n" +"byte (y) string of length 1\n" +" any integer\n" +"any integer type any integer\n" +"double (d) any float\n" +"object path anything with a __dbus_object_path__ attribute\n" +"string, signature, object path str (must be UTF-8) or unicode\n" +"dict (a{...}) any mapping\n" +"array (a...) any iterable over appropriate objects\n" +"struct ((...)) any iterable over appropriate objects\n" +"variant any object above (guess type as below)\n" +"=============================== ===========================\n" +"\n" +"Here 'any integer' means anything on which int() or long()\n" +"(as appropriate) will work, except for basestring subclasses.\n" +"'Any float' means anything on which float() will work, except\n" +"for basestring subclasses.\n" +"\n" +"If there is no signature, guess from the arguments using\n" +"the static method `Message.guess_signature`.\n" +); + +char dbus_py_Message_guess_signature__doc__[] = ( +"guess_signature(*args) -> Signature [static method]\n\n" +"Guess a D-Bus signature which should be used to encode the given\n" +"Python objects.\n" +"\n" +"The signature is constructed as follows:\n\n" +"+-------------------------------+---------------------------+\n" +"|Python |D-Bus |\n" +"+===============================+===========================+\n" +"|D-Bus type, variant_level > 0 |variant (v) |\n" +"+-------------------------------+---------------------------+\n" +"|D-Bus type, variant_level == 0 |the corresponding type |\n" +"+-------------------------------+---------------------------+\n" +"|anything with a |object path |\n" +"|__dbus_object_path__ attribute | |\n" +"+-------------------------------+---------------------------+\n" +"|bool |boolean (y) |\n" +"+-------------------------------+---------------------------+\n" +"|any other int subclass |int32 (i) |\n" +"+-------------------------------+---------------------------+\n" +"|any other long subclass |int64 (x) |\n" +"+-------------------------------+---------------------------+\n" +"|any other float subclass |double (d) |\n" +"+-------------------------------+---------------------------+\n" +"|any other str subclass |string (s) |\n" +"+-------------------------------+---------------------------+\n" +"|any other unicode subclass |string (s) |\n" +"+-------------------------------+---------------------------+\n" +"|any other tuple subclass |struct ((...)) |\n" +"+-------------------------------+---------------------------+\n" +"|any other list subclass |array (a...), guess |\n" +"| |contents' type according to|\n" +"| |type of first item |\n" +"+-------------------------------+---------------------------+\n" +"|any other dict subclass |dict (a{...}), guess key, |\n" +"| |value type according to |\n" +"| |types for an arbitrary item|\n" +"+-------------------------------+---------------------------+\n" +"|anything else |raise TypeError |\n" +"+-------------------------------+---------------------------+\n" +); + +/* return a new reference, possibly to None */ +static PyObject * +get_object_path(PyObject *obj) +{ + PyObject *magic_attr = PyObject_GetAttr(obj, dbus_py__dbus_object_path__const); + + if (magic_attr) { + if (PyString_Check(magic_attr)) { + return magic_attr; + } + else { + Py_DECREF(magic_attr); + PyErr_SetString(PyExc_TypeError, "__dbus_object_path__ must be " + "a string"); + return NULL; + } + } + else { + /* Ignore exceptions, except for SystemExit and KeyboardInterrupt */ + if (PyErr_ExceptionMatches(PyExc_SystemExit) || + PyErr_ExceptionMatches(PyExc_KeyboardInterrupt)) + return NULL; + PyErr_Clear(); + Py_RETURN_NONE; + } +} + +/* Return a new reference. If the object is a variant and variant_level_ptr + * is not NULL, put the variant level in the variable pointed to, and + * return the contained type instead of "v". */ +static PyObject * +_signature_string_from_pyobject(PyObject *obj, long *variant_level_ptr) +{ + PyObject *magic_attr; + long variant_level = get_variant_level(obj); + if (variant_level_ptr) { + *variant_level_ptr = variant_level; + } + else if (variant_level > 0) { + return PyString_FromString(DBUS_TYPE_VARIANT_AS_STRING); + } + + if (obj == Py_True || obj == Py_False) { + return PyString_FromString(DBUS_TYPE_BOOLEAN_AS_STRING); + } + + magic_attr = get_object_path(obj); + if (!magic_attr) + return NULL; + if (magic_attr != Py_None) { + Py_DECREF(magic_attr); + return PyString_FromString(DBUS_TYPE_OBJECT_PATH_AS_STRING); + } + Py_DECREF(magic_attr); + + /* Ordering is important: some of these are subclasses of each other. */ + if (PyInt_Check(obj)) { + if (DBusPyInt16_Check(obj)) + return PyString_FromString(DBUS_TYPE_INT16_AS_STRING); + else if (DBusPyInt32_Check(obj)) + return PyString_FromString(DBUS_TYPE_INT32_AS_STRING); + else if (DBusPyByte_Check(obj)) + return PyString_FromString(DBUS_TYPE_BYTE_AS_STRING); + else if (DBusPyUInt16_Check(obj)) + return PyString_FromString(DBUS_TYPE_UINT16_AS_STRING); + else if (DBusPyBoolean_Check(obj)) + return PyString_FromString(DBUS_TYPE_BOOLEAN_AS_STRING); + else + return PyString_FromString(DBUS_TYPE_INT32_AS_STRING); + } + else if (PyLong_Check(obj)) { + if (DBusPyInt64_Check(obj)) + return PyString_FromString(DBUS_TYPE_INT64_AS_STRING); + else if (DBusPyUInt32_Check(obj)) + return PyString_FromString(DBUS_TYPE_UINT32_AS_STRING); + else if (DBusPyUInt64_Check(obj)) + return PyString_FromString(DBUS_TYPE_UINT64_AS_STRING); + else + return PyString_FromString(DBUS_TYPE_INT64_AS_STRING); + } + else if (PyUnicode_Check(obj)) + return PyString_FromString(DBUS_TYPE_STRING_AS_STRING); + else if (PyFloat_Check(obj)) { +#ifdef WITH_DBUS_FLOAT32 + if (DBusPyDouble_Check(obj)) + return PyString_FromString(DBUS_TYPE_DOUBLE_AS_STRING); + else if (DBusPyFloat_Check(obj)) + return PyString_FromString(DBUS_TYPE_FLOAT_AS_STRING); + else +#endif + return PyString_FromString(DBUS_TYPE_DOUBLE_AS_STRING); + } + else if (PyString_Check(obj)) { + if (DBusPyObjectPath_Check(obj)) + return PyString_FromString(DBUS_TYPE_OBJECT_PATH_AS_STRING); + else if (DBusPySignature_Check(obj)) + return PyString_FromString(DBUS_TYPE_SIGNATURE_AS_STRING); + else if (DBusPyByteArray_Check(obj)) + return PyString_FromString(DBUS_TYPE_ARRAY_AS_STRING + DBUS_TYPE_BYTE_AS_STRING); + else + return PyString_FromString(DBUS_TYPE_STRING_AS_STRING); + } + else if (PyTuple_Check(obj)) { + Py_ssize_t len = PyTuple_GET_SIZE(obj); + PyObject *list = PyList_New(len + 2); /* new ref */ + PyObject *item; /* temporary new ref */ + PyObject *empty_str; /* temporary new ref */ + PyObject *ret; + Py_ssize_t i; + + if (!list) return NULL; + if (len == 0) { + PyErr_SetString(PyExc_ValueError, "D-Bus structs cannot be empty"); + Py_DECREF(list); + return NULL; + } + /* Set the first and last elements of list to be the parentheses */ + item = PyString_FromString(DBUS_STRUCT_BEGIN_CHAR_AS_STRING); + if (PyList_SetItem(list, 0, item) < 0) { + Py_DECREF(list); + return NULL; + } + item = PyString_FromString(DBUS_STRUCT_END_CHAR_AS_STRING); + if (PyList_SetItem(list, len + 1, item) < 0) { + Py_DECREF(list); + return NULL; + } + if (!item || !PyList_GET_ITEM(list, 0)) { + Py_DECREF(list); + return NULL; + } + item = NULL; + + for (i = 0; i < len; i++) { + item = PyTuple_GetItem(obj, i); + if (!item) { + Py_DECREF(list); + return NULL; + } + item = _signature_string_from_pyobject(item, NULL); + if (!item) { + Py_DECREF(list); + return NULL; + } + if (PyList_SetItem(list, i + 1, item) < 0) { + Py_DECREF(list); + return NULL; + } + item = NULL; + } + empty_str = PyString_FromString(""); + if (!empty_str) { + /* really shouldn't happen */ + Py_DECREF(list); + return NULL; + } + ret = PyObject_CallMethod(empty_str, "join", "(O)", list); /* new ref */ + /* whether ret is NULL or not, */ + Py_DECREF(empty_str); + Py_DECREF(list); + return ret; + } + else if (PyList_Check(obj)) { + PyObject *tmp; + PyObject *ret = PyString_FromString(DBUS_TYPE_ARRAY_AS_STRING); + if (!ret) return NULL; + if (DBusPyArray_Check(obj) && PyString_Check(((DBusPyArray *)obj)->signature)) { + PyString_Concat(&ret, ((DBusPyArray *)obj)->signature); + return ret; + } + if (PyList_GET_SIZE(obj) == 0) { + /* No items, so fail. Or should we guess "av"? */ + PyErr_SetString(PyExc_ValueError, "Unable to guess signature " + "from an empty list"); + return NULL; + } + tmp = PyList_GetItem(obj, 0); + tmp = _signature_string_from_pyobject(tmp, NULL); + if (!tmp) return NULL; + PyString_ConcatAndDel(&ret, tmp); + return ret; + } + else if (PyDict_Check(obj)) { + PyObject *key, *value, *keysig, *valuesig; + Py_ssize_t pos = 0; + PyObject *ret = NULL; + + if (DBusPyDict_Check(obj) && PyString_Check(((DBusPyDict *)obj)->signature)) { + const char *sig = PyString_AS_STRING(((DBusPyDict *)obj)->signature); + + return PyString_FromFormat((DBUS_TYPE_ARRAY_AS_STRING + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + "%s" + DBUS_DICT_ENTRY_END_CHAR_AS_STRING), + sig); + } + if (!PyDict_Next(obj, &pos, &key, &value)) { + /* No items, so fail. Or should we guess "a{vv}"? */ + PyErr_SetString(PyExc_ValueError, "Unable to guess signature " + "from an empty dict"); + return NULL; + } + keysig = _signature_string_from_pyobject(key, NULL); + valuesig = _signature_string_from_pyobject(value, NULL); + if (keysig && valuesig) { + ret = PyString_FromFormat((DBUS_TYPE_ARRAY_AS_STRING + DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING + "%s%s" + DBUS_DICT_ENTRY_END_CHAR_AS_STRING), + PyString_AS_STRING(keysig), + PyString_AS_STRING(valuesig)); + } + Py_XDECREF(keysig); + Py_XDECREF(valuesig); + return ret; + } + else { + PyErr_Format(PyExc_TypeError, "Don't know how which D-Bus type " + "to use to encode type \"%s\"", + obj->ob_type->tp_name); + return NULL; + } +} + +PyObject * +dbus_py_Message_guess_signature(PyObject *unused UNUSED, PyObject *args) +{ + PyObject *tmp, *ret = NULL; + + if (!args) { + if (!PyErr_Occurred()) { + PyErr_BadInternalCall(); + } + return NULL; + } + +#ifdef USING_DBG + fprintf(stderr, "DBG/%ld: called Message_guess_signature", (long)getpid()); + PyObject_Print(args, stderr, 0); + fprintf(stderr, "\n"); +#endif + + if (!PyTuple_Check(args)) { + DBG("%s", "Message_guess_signature: args not a tuple"); + PyErr_BadInternalCall(); + return NULL; + } + + /* if there were no args, easy */ + if (PyTuple_GET_SIZE(args) == 0) { + DBG("%s", "Message_guess_signature: no args, so return Signature('')"); + return PyObject_CallFunction((PyObject *)&DBusPySignature_Type, "(s)", ""); + } + + /* if there were args, the signature we want is, by construction, + * exactly the signature we get for the tuple args, except that we don't + * want the parentheses. */ + tmp = _signature_string_from_pyobject(args, NULL); + if (!tmp) { + DBG("%s", "Message_guess_signature: failed"); + return NULL; + } + if (!PyString_Check(tmp) || PyString_GET_SIZE(tmp) < 2) { + PyErr_SetString(PyExc_RuntimeError, "Internal error: " + "_signature_string_from_pyobject returned " + "a bad result"); + Py_DECREF(tmp); + return NULL; + } + ret = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, "(s#)", + PyString_AS_STRING(tmp) + 1, + PyString_GET_SIZE(tmp) - 2); + DBG("Message_guess_signature: returning Signature at %p \"%s\"", ret, + ret ? PyString_AS_STRING(ret) : "(NULL)"); + Py_DECREF(tmp); + return ret; +} + +static int _message_iter_append_pyobject(DBusMessageIter *appender, + DBusSignatureIter *sig_iter, + PyObject *obj, + dbus_bool_t *more); +static int _message_iter_append_variant(DBusMessageIter *appender, + PyObject *obj); + +static int +_message_iter_append_string(DBusMessageIter *appender, + int sig_type, PyObject *obj, + dbus_bool_t allow_object_path_attr) +{ + char *s; + + if (sig_type == DBUS_TYPE_OBJECT_PATH && allow_object_path_attr) { + PyObject *object_path = get_object_path (obj); + + if (object_path == Py_None) { + Py_DECREF(object_path); + } + else if (!object_path) { + return -1; + } + else { + int ret = _message_iter_append_string(appender, sig_type, + object_path, FALSE); + Py_DECREF(object_path); + return ret; + } + } + + if (PyString_Check(obj)) { + PyObject *unicode; + + /* Raise TypeError if the string has embedded NULs */ + if (PyString_AsStringAndSize(obj, &s, NULL) < 0) return -1; + /* Surely there's a faster stdlib way to validate UTF-8... */ + unicode = PyUnicode_DecodeUTF8(s, PyString_GET_SIZE(obj), NULL); + if (!unicode) { + PyErr_SetString(PyExc_UnicodeError, "String parameters " + "to be sent over D-Bus must be valid UTF-8"); + return -1; + } + Py_DECREF(unicode); + unicode = NULL; + + DBG("Performing actual append: string %s", s); + if (!dbus_message_iter_append_basic(appender, sig_type, + &s)) { + PyErr_NoMemory(); + return -1; + } + } + else if (PyUnicode_Check(obj)) { + PyObject *utf8 = PyUnicode_AsUTF8String(obj); + if (!utf8) return -1; + /* Raise TypeError if the string has embedded NULs */ + if (PyString_AsStringAndSize(utf8, &s, NULL) < 0) return -1; + DBG("Performing actual append: string (from unicode) %s", s); + if (!dbus_message_iter_append_basic(appender, sig_type, &s)) { + PyErr_NoMemory(); + return -1; + } + Py_DECREF(utf8); + } + else { + PyErr_SetString(PyExc_TypeError, + "Expected a string or unicode object"); + return -1; + } + return 0; +} + +static int +_message_iter_append_byte(DBusMessageIter *appender, PyObject *obj) +{ + unsigned char y; + + if (PyString_Check(obj)) { + if (PyString_GET_SIZE(obj) != 1) { + PyErr_Format(PyExc_ValueError, "Expected a string of " + "length 1 byte, but found %d bytes", + PyString_GET_SIZE(obj)); + return -1; + } + y = *(unsigned char *)PyString_AS_STRING(obj); + } + else { + long i = PyInt_AsLong(obj); + + if (i == -1 && PyErr_Occurred()) return -1; + if (i < 0 || i > 0xff) { + PyErr_Format(PyExc_ValueError, "%d outside range for a " + "byte value", (int)i); + return -1; + } + y = i; + } + DBG("Performing actual append: byte \\x%02x", (unsigned)y); + if (!dbus_message_iter_append_basic(appender, DBUS_TYPE_BYTE, &y)) { + PyErr_NoMemory(); + return -1; + } + return 0; +} + +static int +_message_iter_append_dictentry(DBusMessageIter *appender, + DBusSignatureIter *sig_iter, + PyObject *dict, PyObject *key) +{ + DBusSignatureIter sub_sig_iter; + DBusMessageIter sub; + int ret = -1; + PyObject *value = PyObject_GetItem(dict, key); + dbus_bool_t more; + + if (!value) return -1; + +#ifdef USING_DBG + fprintf(stderr, "Append dictentry: "); + PyObject_Print(key, stderr, 0); + fprintf(stderr, " => "); + PyObject_Print(value, stderr, 0); + fprintf(stderr, "\n"); +#endif + + DBG("Recursing signature iterator %p -> %p", sig_iter, &sub_sig_iter); + dbus_signature_iter_recurse(sig_iter, &sub_sig_iter); +#ifdef USING_DBG + { + char *s; + s = dbus_signature_iter_get_signature(sig_iter); + DBG("Signature of parent iterator %p is %s", sig_iter, s); + dbus_free(s); + s = dbus_signature_iter_get_signature(&sub_sig_iter); + DBG("Signature of sub-iterator %p is %s", &sub_sig_iter, s); + dbus_free(s); + } +#endif + + DBG("%s", "Opening DICT_ENTRY container"); + if (!dbus_message_iter_open_container(appender, DBUS_TYPE_DICT_ENTRY, + NULL, &sub)) { + PyErr_NoMemory(); + goto out; + } + ret = _message_iter_append_pyobject(&sub, &sub_sig_iter, key, &more); + if (ret == 0) { + ret = _message_iter_append_pyobject(&sub, &sub_sig_iter, value, &more); + } + DBG("%s", "Closing DICT_ENTRY container"); + if (!dbus_message_iter_close_container(appender, &sub)) { + PyErr_NoMemory(); + ret = -1; + } +out: + Py_DECREF(value); + return ret; +} + +static int +_message_iter_append_multi(DBusMessageIter *appender, + const DBusSignatureIter *sig_iter, + int mode, PyObject *obj) +{ + DBusMessageIter sub_appender; + DBusSignatureIter sub_sig_iter; + PyObject *contents; + int ret; + PyObject *iterator = PyObject_GetIter(obj); + char *sig = NULL; + int container = mode; + dbus_bool_t is_byte_array = DBusPyByteArray_Check(obj); + int inner_type; + dbus_bool_t more; + +#ifdef USING_DBG + fprintf(stderr, "Appending multiple: "); + PyObject_Print(obj, stderr, 0); + fprintf(stderr, "\n"); +#endif + + if (!iterator) return -1; + if (mode == DBUS_TYPE_DICT_ENTRY) container = DBUS_TYPE_ARRAY; + + DBG("Recursing signature iterator %p -> %p", sig_iter, &sub_sig_iter); + dbus_signature_iter_recurse(sig_iter, &sub_sig_iter); +#ifdef USING_DBG + { + char *s; + s = dbus_signature_iter_get_signature(sig_iter); + DBG("Signature of parent iterator %p is %s", sig_iter, s); + dbus_free(s); + s = dbus_signature_iter_get_signature(&sub_sig_iter); + DBG("Signature of sub-iterator %p is %s", &sub_sig_iter, s); + dbus_free(s); + } +#endif + inner_type = dbus_signature_iter_get_current_type(&sub_sig_iter); + + if (mode == DBUS_TYPE_ARRAY || mode == DBUS_TYPE_DICT_ENTRY) { + sig = dbus_signature_iter_get_signature(&sub_sig_iter); + if (!sig) { + PyErr_NoMemory(); + ret = -1; + goto out; + } + } + /* else leave sig set to NULL. */ + + DBG("Opening %c container", container); + if (!dbus_message_iter_open_container(appender, container, + sig, &sub_appender)) { + PyErr_NoMemory(); + ret = -1; + goto out; + } + ret = 0; + while ((contents = PyIter_Next(iterator))) { + + if (mode == DBUS_TYPE_ARRAY || mode == DBUS_TYPE_DICT_ENTRY) { + DBG("Recursing signature iterator %p -> %p", sig_iter, &sub_sig_iter); + dbus_signature_iter_recurse(sig_iter, &sub_sig_iter); +#ifdef USING_DBG + { + char *s; + s = dbus_signature_iter_get_signature(sig_iter); + DBG("Signature of parent iterator %p is %s", sig_iter, s); + dbus_free(s); + s = dbus_signature_iter_get_signature(&sub_sig_iter); + DBG("Signature of sub-iterator %p is %s", &sub_sig_iter, s); + dbus_free(s); + } +#endif + } + + if (mode == DBUS_TYPE_DICT_ENTRY) { + ret = _message_iter_append_dictentry(&sub_appender, &sub_sig_iter, + obj, contents); + } + else if (mode == DBUS_TYPE_ARRAY && is_byte_array + && inner_type == DBUS_TYPE_VARIANT) { + /* Subscripting a ByteArray gives a str of length 1, but if the + * container is a ByteArray and the parameter is an array of + * variants, we want to produce an array of variants containing + * bytes, not strings. + */ + PyObject *args = Py_BuildValue("(O)", contents); + PyObject *byte; + + if (!args) + break; + byte = PyObject_Call((PyObject *)&DBusPyByte_Type, args, NULL); + Py_DECREF(args); + if (!byte) + break; + ret = _message_iter_append_variant(&sub_appender, byte); + Py_DECREF(byte); + } + else { + /* advances sub_sig_iter and sets more on success - for array + * this doesn't matter, for struct it's essential */ + ret = _message_iter_append_pyobject(&sub_appender, &sub_sig_iter, + contents, &more); + } + + Py_DECREF(contents); + if (ret < 0) { + break; + } + } + + if (PyErr_Occurred()) { + ret = -1; + } + else if (mode == DBUS_TYPE_STRUCT && more) { + PyErr_Format(PyExc_TypeError, "More items found in struct's D-Bus " + "signature than in Python arguments "); + ret = -1; + } + + /* This must be run as cleanup, even on failure. */ + DBG("Closing %c container", container); + if (!dbus_message_iter_close_container(appender, &sub_appender)) { + PyErr_NoMemory(); + ret = -1; + } + +out: + Py_XDECREF(iterator); + dbus_free(sig); + return ret; +} + +static int +_message_iter_append_string_as_byte_array(DBusMessageIter *appender, + PyObject *obj) +{ + /* a bit of a faster path for byte arrays that are strings */ + Py_ssize_t len = PyString_GET_SIZE(obj); + const char *s; + DBusMessageIter sub; + int ret; + + s = PyString_AS_STRING(obj); + DBG("%s", "Opening ARRAY container"); + if (!dbus_message_iter_open_container(appender, DBUS_TYPE_ARRAY, + DBUS_TYPE_BYTE_AS_STRING, &sub)) { + PyErr_NoMemory(); + return -1; + } + DBG("Appending fixed array of %d bytes", len); + if (dbus_message_iter_append_fixed_array(&sub, DBUS_TYPE_BYTE, &s, len)) { + ret = 0; + } + else { + PyErr_NoMemory(); + ret = -1; + } + DBG("%s", "Closing ARRAY container"); + if (!dbus_message_iter_close_container(appender, &sub)) { + PyErr_NoMemory(); + return -1; + } + return ret; +} + +/* Encode some Python object into a D-Bus variant slot. */ +static int +_message_iter_append_variant(DBusMessageIter *appender, PyObject *obj) +{ + DBusSignatureIter obj_sig_iter; + const char *obj_sig_str; + PyObject *obj_sig; + int ret; + long variant_level; + dbus_bool_t dummy; + + /* Separate the object into the contained object, and the number of + * variants it's wrapped in. */ + obj_sig = _signature_string_from_pyobject(obj, &variant_level); + if (!obj_sig) return -1; + + obj_sig_str = PyString_AsString(obj_sig); + if (!obj_sig_str) return -1; + + if (variant_level < 1) { + variant_level = 1; + } + + dbus_signature_iter_init(&obj_sig_iter, obj_sig_str); + + { /* scope for variant_iters */ + DBusMessageIter variant_iters[variant_level]; + long i; + + for (i = 0; i < variant_level; i++) { + DBusMessageIter *child = &variant_iters[i]; + /* The first is a special case: its parent is the iter passed in + * to this function, instead of being the previous one in the + * stack + */ + DBusMessageIter *parent = (i == 0 + ? appender + : &(variant_iters[i-1])); + /* The last is also a special case: it contains the actual + * object, rather than another variant + */ + const char *sig_str = (i == variant_level-1 + ? obj_sig_str + : DBUS_TYPE_VARIANT_AS_STRING); + + DBG("Opening VARIANT container %p inside %p containing '%s'", + child, parent, sig_str); + if (!dbus_message_iter_open_container(parent, DBUS_TYPE_VARIANT, + sig_str, child)) { + PyErr_NoMemory(); + ret = -1; + goto out; + } + } + + /* Put the object itself into the innermost variant */ + ret = _message_iter_append_pyobject(&variant_iters[variant_level-1], + &obj_sig_iter, obj, &dummy); + + /* here we rely on i (and variant_level) being a signed long */ + for (i = variant_level - 1; i >= 0; i--) { + DBusMessageIter *child = &variant_iters[i]; + /* The first is a special case: its parent is the iter passed in + * to this function, instead of being the previous one in the + * stack + */ + DBusMessageIter *parent = (i == 0 ? appender + : &(variant_iters[i-1])); + + DBG("Closing VARIANT container %p inside %p", child, parent); + if (!dbus_message_iter_close_container(parent, child)) { + PyErr_NoMemory(); + ret = -1; + goto out; + } + } + + } + +out: + Py_XDECREF(obj_sig); + return ret; +} + +/* On success, *more is set to whether there's more in the signature. */ +static int +_message_iter_append_pyobject(DBusMessageIter *appender, + DBusSignatureIter *sig_iter, + PyObject *obj, + dbus_bool_t *more) +{ + int sig_type = dbus_signature_iter_get_current_type(sig_iter); + union { + dbus_bool_t b; + double d; + dbus_uint16_t uint16; + dbus_int16_t int16; + dbus_uint32_t uint32; + dbus_int32_t int32; +#if defined(DBUS_HAVE_INT64) && defined(HAVE_LONG_LONG) + dbus_uint64_t uint64; + dbus_int64_t int64; +#endif + } u; + int ret = -1; + +#ifdef USING_DBG + fprintf(stderr, "Appending object at %p: ", obj); + PyObject_Print(obj, stderr, 0); + fprintf(stderr, " into appender at %p, dbus wants type %c\n", + appender, sig_type); +#endif + + switch (sig_type) { + /* The numeric types are relatively simple to deal with, so are + * inlined here. */ + + case DBUS_TYPE_BOOLEAN: + if (PyObject_IsTrue(obj)) { + u.b = 1; + } + else { + u.b = 0; + } + DBG("Performing actual append: bool(%ld)", (long)u.b); + if (!dbus_message_iter_append_basic(appender, sig_type, &u.b)) { + PyErr_NoMemory(); + ret = -1; + break; + } + ret = 0; + break; + + case DBUS_TYPE_DOUBLE: + u.d = PyFloat_AsDouble(obj); + if (PyErr_Occurred()) { + ret = -1; + break; + } + DBG("Performing actual append: double(%f)", u.d); + if (!dbus_message_iter_append_basic(appender, sig_type, &u.d)) { + PyErr_NoMemory(); + ret = -1; + break; + } + ret = 0; + break; + +#ifdef WITH_DBUS_FLOAT32 + case DBUS_TYPE_FLOAT: + u.d = PyFloat_AsDouble(obj); + if (PyErr_Occurred()) { + ret = -1; + break; + } + u.f = (float)u.d; + DBG("Performing actual append: float(%f)", u.f); + if (!dbus_message_iter_append_basic(appender, sig_type, &u.f)) { + PyErr_NoMemory(); + ret = -1; + break; + } + ret = 0; + break; +#endif + + /* The integer types are all basically the same - we delegate to + intNN_range_check() */ +#define PROCESS_INTEGER(size) \ + u.size = dbus_py_##size##_range_check(obj);\ + if (u.size == (dbus_##size##_t)(-1) && PyErr_Occurred()) {\ + ret = -1; \ + break; \ + }\ + DBG("Performing actual append: " #size "(%lld)", (long long)u.size); \ + if (!dbus_message_iter_append_basic(appender, sig_type, &u.size)) {\ + PyErr_NoMemory();\ + ret = -1;\ + break;\ + } \ + ret = 0; + + case DBUS_TYPE_INT16: + PROCESS_INTEGER(int16) + break; + case DBUS_TYPE_UINT16: + PROCESS_INTEGER(uint16) + break; + case DBUS_TYPE_INT32: + PROCESS_INTEGER(int32) + break; + case DBUS_TYPE_UINT32: + PROCESS_INTEGER(uint32) + break; +#if defined(DBUS_HAVE_INT64) && defined(HAVE_LONG_LONG) + case DBUS_TYPE_INT64: + PROCESS_INTEGER(int64) + break; + case DBUS_TYPE_UINT64: + PROCESS_INTEGER(uint64) + break; +#else + case DBUS_TYPE_INT64: + case DBUS_TYPE_UINT64: + PyErr_SetString(PyExc_NotImplementedError, "64-bit integer " + "types are not supported on this platform"); + ret = -1; + break; +#endif +#undef PROCESS_INTEGER + + /* Now the more complicated cases, which are delegated to helper + * functions (although in practice, the compiler will hopefully + * inline them anyway). */ + + case DBUS_TYPE_STRING: + case DBUS_TYPE_SIGNATURE: + case DBUS_TYPE_OBJECT_PATH: + ret = _message_iter_append_string(appender, sig_type, obj, TRUE); + break; + + case DBUS_TYPE_BYTE: + ret = _message_iter_append_byte(appender, obj); + break; + + case DBUS_TYPE_ARRAY: + /* 3 cases - it might actually be a dict, or it might be a byte array + * being copied from a string (for which we have a faster path), + * or it might be a generic array. */ + + sig_type = dbus_signature_iter_get_element_type(sig_iter); + if (sig_type == DBUS_TYPE_DICT_ENTRY) + ret = _message_iter_append_multi(appender, sig_iter, + DBUS_TYPE_DICT_ENTRY, obj); + else if (sig_type == DBUS_TYPE_BYTE && PyString_Check(obj)) + ret = _message_iter_append_string_as_byte_array(appender, obj); + else + ret = _message_iter_append_multi(appender, sig_iter, + DBUS_TYPE_ARRAY, obj); + DBG("_message_iter_append_multi(): %d", ret); + break; + + case DBUS_TYPE_STRUCT: + ret = _message_iter_append_multi(appender, sig_iter, sig_type, obj); + break; + + case DBUS_TYPE_VARIANT: + ret = _message_iter_append_variant(appender, obj); + break; + + case DBUS_TYPE_INVALID: + PyErr_SetString(PyExc_TypeError, "Fewer items found in D-Bus " + "signature than in Python arguments"); + ret = -1; + break; + + default: + PyErr_Format(PyExc_TypeError, "Unknown type '\\x%x' in D-Bus " + "signature", sig_type); + ret = -1; + break; + } + if (ret < 0) return -1; + + DBG("Advancing signature iter at %p", sig_iter); + *more = dbus_signature_iter_next(sig_iter); +#ifdef USING_DBG + DBG("- result: %ld, type %02x '%c'", (long)(*more), + (int)dbus_signature_iter_get_current_type(sig_iter), + (int)dbus_signature_iter_get_current_type(sig_iter)); +#endif + return 0; +} + + +PyObject * +dbus_py_Message_append(Message *self, PyObject *args, PyObject *kwargs) +{ + const char *signature = NULL; + PyObject *signature_obj = NULL; + DBusSignatureIter sig_iter; + DBusMessageIter appender; + int i; + static char *argnames[] = {"signature", NULL}; + /* must start FALSE for the case where there's nothing there and we + * never iterate at all */ + dbus_bool_t more; + + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + +#ifdef USING_DBG + fprintf(stderr, "DBG/%ld: called Message_append(*", (long)getpid()); + PyObject_Print(args, stderr, 0); + if (kwargs) { + fprintf(stderr, ", **"); + PyObject_Print(kwargs, stderr, 0); + } + fprintf(stderr, ")\n"); +#endif + + /* only use kwargs for this step: deliberately ignore args for now */ + if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs, "|z:append", + argnames, &signature)) return NULL; + + if (!signature) { + DBG("%s", "No signature for message, guessing..."); + signature_obj = dbus_py_Message_guess_signature(NULL, args); + if (!signature_obj) return NULL; + signature = PyString_AS_STRING(signature_obj); + } + /* from here onwards, you have to do a goto rather than returning NULL + to make sure signature_obj gets freed */ + + /* iterate over args and the signature, together */ + if (!dbus_signature_validate(signature, NULL)) { + PyErr_SetString(PyExc_ValueError, "Corrupt type signature"); + goto err; + } + dbus_signature_iter_init(&sig_iter, signature); + dbus_message_iter_init_append(self->msg, &appender); + more = (signature[0] != '\0'); + for (i = 0; i < PyTuple_GET_SIZE(args); i++) { + if (_message_iter_append_pyobject(&appender, &sig_iter, + PyTuple_GET_ITEM(args, i), + &more) < 0) { + goto hosed; + } + } + if (more) { + PyErr_SetString(PyExc_TypeError, "More items found in D-Bus " + "signature than in Python arguments"); + goto hosed; + } + + /* success! */ + Py_XDECREF(signature_obj); + Py_RETURN_NONE; + +hosed: + /* "If appending any of the arguments fails due to lack of memory, + * generally the message is hosed and you have to start over" -libdbus docs + * Enforce this by throwing away the message structure. + */ + dbus_message_unref(self->msg); + self->msg = NULL; +err: + Py_XDECREF(signature_obj); + return NULL; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/message-get-args.c b/_dbus_bindings/message-get-args.c new file mode 100644 index 0000000..7d55ffd --- /dev/null +++ b/_dbus_bindings/message-get-args.c @@ -0,0 +1,523 @@ +/* D-Bus Message unserialization. This contains all the logic to map from + * D-Bus types to Python objects. + * + * Copyright (C) 2006-2007 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#define PY_SIZE_T_CLEAN 1 + +#define DBG_IS_TOO_VERBOSE +#include "types-internal.h" +#include "message-internal.h" + +char dbus_py_Message_get_args_list__doc__[] = ( +"get_args_list(**kwargs) -> list\n\n" +"Return the message's arguments. Keyword arguments control the translation\n" +"of D-Bus types to Python:\n" +"\n" +":Keywords:\n" +" `byte_arrays` : bool\n" +" If true, convert arrays of byte (signature 'ay') into dbus.ByteArray,\n" +" a str subclass. In practice, this is usually what you want, but\n" +" it's off by default for consistency.\n" +"\n" +" If false (default), convert them into a dbus.Array of Bytes.\n" +" `utf8_strings` : bool\n" +" If true, return D-Bus strings as Python 8-bit strings (of UTF-8).\n" +" If false (default), return D-Bus strings as Python unicode objects.\n" +"\n" +"Most of the type mappings should be fairly obvious:\n" +"\n" +"=============== ===================================================\n" +"D-Bus Python\n" +"=============== ===================================================\n" +"byte (y) dbus.Byte (int subclass)\n" +"bool (b) dbus.Boolean (int subclass)\n" +"Signature (g) dbus.Signature (str subclass)\n" +"intNN, uintNN dbus.IntNN, dbus.UIntNN (int or long subclasses)\n" +"double (d) dbus.Double\n" +"string (s) dbus.String (unicode subclass)\n" +" (or dbus.UTF8String, str subclass, if utf8_strings set)\n" +"Object path (o) dbus.ObjectPath (str subclass)\n" +"dict (a{...}) dbus.Dictionary\n" +"array (a...) dbus.Array (list subclass) containing appropriate types\n" +"byte array (ay) dbus.ByteArray (str subclass) if byte_arrays set; or\n" +" list of Byte\n" +"struct ((...)) dbus.Struct (tuple subclass) of appropriate types\n" +"variant (v) contained type, but with variant_level > 0\n" +"=============== ===================================================\n" +); + +typedef struct { + int byte_arrays; + int utf8_strings; +} Message_get_args_options; + +static PyObject *_message_iter_get_pyobject(DBusMessageIter *iter, + Message_get_args_options *opts, + long extra_variants); + +/* Append all the items iterated over to the given Python list object. + * Return 0 on success/-1 with exception on failure. */ +static int +_message_iter_append_all_to_list(DBusMessageIter *iter, PyObject *list, + Message_get_args_options *opts) +{ + int ret, type; + while ((type = dbus_message_iter_get_arg_type(iter)) + != DBUS_TYPE_INVALID) { + PyObject *item; + DBG("type == %d '%c'", type, type); + + item = _message_iter_get_pyobject(iter, opts, 0); + if (!item) return -1; +#ifdef USING_DBG + fprintf(stderr, "DBG/%ld: appending to list: %p == ", (long)getpid(), item); + PyObject_Print(item, stderr, 0); + fprintf(stderr, " of type %p\n", item->ob_type); +#endif + ret = PyList_Append(list, item); + Py_DECREF(item); + item = NULL; + if (ret < 0) return -1; +#ifdef USING_DBG + fprintf(stderr, "DBG/%ld: list now contains: ", (long)getpid()); + PyObject_Print(list, stderr, 0); + fprintf(stderr, "\n"); +#endif + dbus_message_iter_next(iter); + } + return 0; +} + +static inline PyObject * +_message_iter_get_dict(DBusMessageIter *iter, + Message_get_args_options *opts, + PyObject *kwargs) +{ + DBusMessageIter entries; + char *sig_str = dbus_message_iter_get_signature(iter); + PyObject *sig; + PyObject *ret; + int status; + + if (!sig_str) { + PyErr_NoMemory(); + return NULL; + } + sig = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, + "(s#)", sig_str+2, + (Py_ssize_t)strlen(sig_str)-3); + dbus_free(sig_str); + if (!sig) { + return NULL; + } + status = PyDict_SetItem(kwargs, dbus_py_signature_const, sig); + Py_DECREF(sig); + if (status < 0) { + return NULL; + } + + ret = PyObject_Call((PyObject *)&DBusPyDict_Type, dbus_py_empty_tuple, kwargs); + if (!ret) { + return NULL; + } + + dbus_message_iter_recurse(iter, &entries); + while (dbus_message_iter_get_arg_type(&entries) == DBUS_TYPE_DICT_ENTRY) { + PyObject *key = NULL; + PyObject *value = NULL; + DBusMessageIter kv; + + DBG("%s", "dict entry..."); + + dbus_message_iter_recurse(&entries, &kv); + + key = _message_iter_get_pyobject(&kv, opts, 0); + if (!key) { + Py_DECREF(ret); + return NULL; + } + dbus_message_iter_next(&kv); + + value = _message_iter_get_pyobject(&kv, opts, 0); + if (!value) { + Py_DECREF(key); + Py_DECREF(ret); + return NULL; + } + + status = PyDict_SetItem(ret, key, value); + Py_DECREF(key); + Py_DECREF(value); + + if (status < 0) { + Py_DECREF(ret); + return NULL; + } + dbus_message_iter_next(&entries); + } + + return ret; +} + +/* Returns a new reference. */ +static PyObject * +_message_iter_get_pyobject(DBusMessageIter *iter, + Message_get_args_options *opts, + long variant_level) +{ + union { + const char *s; + unsigned char y; + dbus_bool_t b; + double d; + float f; + dbus_uint16_t u16; + dbus_int16_t i16; + dbus_uint32_t u32; + dbus_int32_t i32; +#if defined(DBUS_HAVE_INT64) && defined(HAVE_LONG_LONG) + dbus_uint64_t u64; + dbus_int64_t i64; +#endif + } u; + int type = dbus_message_iter_get_arg_type(iter); + PyObject *args = NULL; + PyObject *kwargs = NULL; + PyObject *ret = NULL; + + /* If the variant-level is >0, prepare a dict for the kwargs. + * For variant wrappers optimize slightly by skipping this. + */ + if (variant_level > 0 && type != DBUS_TYPE_VARIANT) { + PyObject *variant_level_int; + + variant_level_int = PyInt_FromLong(variant_level); + if (!variant_level_int) { + return NULL; + } + kwargs = PyDict_New(); + if (!kwargs) { + Py_DECREF(variant_level_int); + return NULL; + } + if (PyDict_SetItem(kwargs, dbus_py_variant_level_const, + variant_level_int) < 0) { + Py_DECREF(variant_level_int); + Py_DECREF(kwargs); + return NULL; + } + Py_DECREF(variant_level_int); + } + /* From here down you need to break from the switch to exit, so the + * dict is freed if necessary + */ + + switch (type) { + case DBUS_TYPE_STRING: + DBG("%s", "found a string"); + dbus_message_iter_get_basic(iter, &u.s); + if (opts->utf8_strings) { + args = Py_BuildValue("(s)", u.s); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyUTF8String_Type, + args, kwargs); + } + else { + args = Py_BuildValue("(N)", PyUnicode_DecodeUTF8(u.s, + strlen(u.s), + NULL)); + if (!args) { + break; + } + ret = PyObject_Call((PyObject *)&DBusPyString_Type, + args, kwargs); + } + break; + + case DBUS_TYPE_SIGNATURE: + DBG("%s", "found a signature"); + dbus_message_iter_get_basic(iter, &u.s); + args = Py_BuildValue("(s)", u.s); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPySignature_Type, args, kwargs); + break; + + case DBUS_TYPE_OBJECT_PATH: + DBG("%s", "found an object path"); + dbus_message_iter_get_basic(iter, &u.s); + args = Py_BuildValue("(s)", u.s); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyObjectPath_Type, args, kwargs); + break; + + case DBUS_TYPE_DOUBLE: + DBG("%s", "found a double"); + dbus_message_iter_get_basic(iter, &u.d); + args = Py_BuildValue("(f)", u.d); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyDouble_Type, args, kwargs); + break; + +#ifdef WITH_DBUS_FLOAT32 + case DBUS_TYPE_FLOAT: + DBG("%s", "found a float"); + dbus_message_iter_get_basic(iter, &u.f); + args = Py_BuildValue("(f)", (double)u.f); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyFloat_Type, args, kwargs); + break; +#endif + + case DBUS_TYPE_INT16: + DBG("%s", "found an int16"); + dbus_message_iter_get_basic(iter, &u.i16); + args = Py_BuildValue("(i)", (int)u.i16); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyInt16_Type, args, kwargs); + break; + + case DBUS_TYPE_UINT16: + DBG("%s", "found a uint16"); + dbus_message_iter_get_basic(iter, &u.u16); + args = Py_BuildValue("(i)", (int)u.u16); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyUInt16_Type, args, kwargs); + break; + + case DBUS_TYPE_INT32: + DBG("%s", "found an int32"); + dbus_message_iter_get_basic(iter, &u.i32); + args = Py_BuildValue("(l)", (long)u.i32); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyInt32_Type, args, kwargs); + break; + + case DBUS_TYPE_UINT32: + DBG("%s", "found a uint32"); + dbus_message_iter_get_basic(iter, &u.u32); + args = Py_BuildValue("(k)", (unsigned long)u.u32); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyUInt32_Type, args, kwargs); + break; + +#if defined(DBUS_HAVE_INT64) && defined(HAVE_LONG_LONG) + case DBUS_TYPE_INT64: + DBG("%s", "found an int64"); + dbus_message_iter_get_basic(iter, &u.i64); + args = Py_BuildValue("(L)", (PY_LONG_LONG)u.i64); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyInt64_Type, args, kwargs); + break; + + case DBUS_TYPE_UINT64: + DBG("%s", "found a uint64"); + dbus_message_iter_get_basic(iter, &u.u64); + args = Py_BuildValue("(K)", (unsigned PY_LONG_LONG)u.u64); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyUInt64_Type, args, kwargs); + break; +#else + case DBUS_TYPE_INT64: + case DBUS_TYPE_UINT64: + PyErr_SetString(PyExc_NotImplementedError, + "64-bit integer types are not supported on " + "this platform"); + break; +#endif + + case DBUS_TYPE_BYTE: + DBG("%s", "found a byte"); + dbus_message_iter_get_basic(iter, &u.y); + args = Py_BuildValue("(l)", (long)u.y); + if (!args) + break; + ret = PyObject_Call((PyObject *)&DBusPyByte_Type, args, kwargs); + break; + + case DBUS_TYPE_BOOLEAN: + DBG("%s", "found a bool"); + dbus_message_iter_get_basic(iter, &u.b); + args = Py_BuildValue("(l)", (long)u.b); + if (!args) + break; + ret = PyObject_Call((PyObject *)&DBusPyBoolean_Type, args, kwargs); + break; + + case DBUS_TYPE_ARRAY: + DBG("%s", "found an array..."); + /* Dicts are arrays of DBUS_TYPE_DICT_ENTRY on the wire. + Also, we special-case arrays of DBUS_TYPE_BYTE sometimes. */ + type = dbus_message_iter_get_element_type(iter); + if (type == DBUS_TYPE_DICT_ENTRY) { + DBG("%s", "no, actually it's a dict..."); + if (!kwargs) { + kwargs = PyDict_New(); + if (!kwargs) break; + } + ret = _message_iter_get_dict(iter, opts, kwargs); + } + else if (opts->byte_arrays && type == DBUS_TYPE_BYTE) { + DBusMessageIter sub; + int n; + + DBG("%s", "actually, a byte array..."); + dbus_message_iter_recurse(iter, &sub); + dbus_message_iter_get_fixed_array(&sub, + (const unsigned char **)&u.s, + &n); + args = Py_BuildValue("(s#)", u.s, (Py_ssize_t)n); + if (!args) break; + ret = PyObject_Call((PyObject *)&DBusPyByteArray_Type, + args, kwargs); + } + else { + DBusMessageIter sub; + char *sig; + PyObject *sig_obj; + int status; + + DBG("%s", "a normal array..."); + if (!kwargs) { + kwargs = PyDict_New(); + if (!kwargs) break; + } + dbus_message_iter_recurse(iter, &sub); + sig = dbus_message_iter_get_signature(&sub); + if (!sig) break; + sig_obj = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, + "(s)", sig); + dbus_free(sig); + if (!sig_obj) break; + status = PyDict_SetItem(kwargs, dbus_py_signature_const, sig_obj); + Py_DECREF(sig_obj); + if (status < 0) break; + ret = PyObject_Call((PyObject *)&DBusPyArray_Type, + dbus_py_empty_tuple, kwargs); + if (!ret) break; + if (_message_iter_append_all_to_list(&sub, ret, opts) < 0) { + Py_DECREF(ret); + ret = NULL; + } + } + break; + + case DBUS_TYPE_STRUCT: + { + DBusMessageIter sub; + PyObject *list = PyList_New(0); + PyObject *tuple; + + DBG("%s", "found a struct..."); + if (!list) break; + dbus_message_iter_recurse(iter, &sub); + if (_message_iter_append_all_to_list(&sub, list, opts) < 0) { + Py_DECREF(list); + break; + } + tuple = Py_BuildValue("(O)", list); + if (tuple) { + ret = PyObject_Call((PyObject *)&DBusPyStruct_Type, tuple, kwargs); + } + else { + ret = NULL; + } + /* whether successful or not, we take the same action: */ + Py_DECREF(list); + Py_XDECREF(tuple); + } + break; + + case DBUS_TYPE_VARIANT: + { + DBusMessageIter sub; + + DBG("%s", "found a variant..."); + dbus_message_iter_recurse(iter, &sub); + ret = _message_iter_get_pyobject(&sub, opts, variant_level+1); + } + break; + + default: + PyErr_Format(PyExc_TypeError, "Unknown type '\\%x' in D-Bus " + "message", type); + } + + Py_XDECREF(args); + Py_XDECREF(kwargs); + return ret; +} + +PyObject * +dbus_py_Message_get_args_list(Message *self, PyObject *args, PyObject *kwargs) +{ + Message_get_args_options opts = { 0, 0 }; + static char *argnames[] = { "byte_arrays", "utf8_strings", NULL }; + PyObject *list; + DBusMessageIter iter; + +#ifdef USING_DBG + fprintf(stderr, "DBG/%ld: called Message_get_args_list(self, *", + (long)getpid()); + PyObject_Print(args, stderr, 0); + if (kwargs) { + fprintf(stderr, ", **"); + PyObject_Print(kwargs, stderr, 0); + } + fprintf(stderr, ")\n"); +#endif + + if (PyTuple_Size(args) != 0) { + PyErr_SetString(PyExc_TypeError, "get_args_list takes no positional " + "arguments"); + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii:get_args_list", + argnames, + &(opts.byte_arrays), + &(opts.utf8_strings))) return NULL; + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + + list = PyList_New(0); + if (!list) return NULL; + + /* Iterate over args, if any, appending to list */ + if (dbus_message_iter_init(self->msg, &iter)) { + if (_message_iter_append_all_to_list(&iter, list, &opts) < 0) { + Py_DECREF(list); + DBG_EXC("%s", "Message_get_args: appending all to list failed:"); + return NULL; + } + } + +#ifdef USING_DBG + fprintf(stderr, "DBG/%ld: message has args list ", (long)getpid()); + PyObject_Print(list, stderr, 0); + fprintf(stderr, "\n"); +#endif + + return list; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/message-internal.h b/_dbus_bindings/message-internal.h new file mode 100644 index 0000000..7532e38 --- /dev/null +++ b/_dbus_bindings/message-internal.h @@ -0,0 +1,49 @@ +/* D-Bus message: implementation internals + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include + +#include "dbus_bindings-internal.h" + +#ifndef DBUS_BINDINGS_MESSAGE_INTERNAL_H +#define DBUS_BINDINGS_MESSAGE_INTERNAL_H + +typedef struct { + PyObject_HEAD + DBusMessage *msg; +} Message; + +extern char dbus_py_Message_append__doc__[]; +extern PyObject *dbus_py_Message_append(Message *, PyObject *, PyObject *); +extern char dbus_py_Message_guess_signature__doc__[]; +extern PyObject *dbus_py_Message_guess_signature(PyObject *, PyObject *); +extern char dbus_py_Message_get_args_list__doc__[]; +extern PyObject *dbus_py_Message_get_args_list(Message *, + PyObject *, + PyObject *); + +extern PyObject *DBusPy_RaiseUnusableMessage(void); + +#endif diff --git a/_dbus_bindings/message.c b/_dbus_bindings/message.c new file mode 100644 index 0000000..a2c04c3 --- /dev/null +++ b/_dbus_bindings/message.c @@ -0,0 +1,1063 @@ +/* Implementation of D-Bus Message and subclasses (but see message-get-args.h + * and message-append.h for unserialization and serialization code). + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" +#include "message-internal.h" + +static PyTypeObject MessageType, SignalMessageType, ErrorMessageType; +static PyTypeObject MethodReturnMessageType, MethodCallMessageType; + +static inline int Message_Check(PyObject *o) +{ + return (o->ob_type == &MessageType) + || PyObject_IsInstance(o, (PyObject *)&MessageType); +} + +PyObject * +DBusPy_RaiseUnusableMessage(void) +{ + DBusPyException_SetString("Message object is uninitialized, or has become " + "unusable due to error while appending " + "arguments"); + return NULL; +} + +PyDoc_STRVAR(Message_tp_doc, +"A message to be sent or received over a D-Bus Connection.\n"); + +static void Message_tp_dealloc(Message *self) +{ + if (self->msg) { + dbus_message_unref(self->msg); + } + self->ob_type->tp_free((PyObject *)self); +} + +static PyObject * +Message_tp_new(PyTypeObject *type, + PyObject *args UNUSED, + PyObject *kwargs UNUSED) +{ + Message *self; + + self = (Message *)type->tp_alloc(type, 0); + if (!self) return NULL; + self->msg = NULL; + return (PyObject *)self; +} + +PyDoc_STRVAR(MethodCallMessage_tp_doc, "A method-call message.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.lowlevel.MethodCallMessage(destination: str or None, path: str,\n" +" interface: str or None, method: str)\n" +"\n" +"``destination`` is the destination bus name, or None to send the\n" +"message directly to the peer (usually the bus daemon).\n" +"\n" +"``path`` is the object-path of the object whose method is to be called.\n" +"\n" +"``interface`` is the interface qualifying the method name, or None to omit\n" +"the interface from the message header.\n" +"\n" +"``method`` is the method name (member name).\n" +); + +static int +MethodCallMessage_tp_init(Message *self, PyObject *args, PyObject *kwargs) +{ + const char *destination, *path, *interface, *method; + static char *kwlist[] = {"destination", "path", "interface", "method", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "zszs:__init__", kwlist, + &destination, &path, &interface, + &method)) { + return -1; + } + if (destination && !dbus_py_validate_bus_name(destination, 1, 1)) return -1; + if (!dbus_py_validate_object_path(path)) return -1; + if (interface && !dbus_py_validate_interface_name(interface)) return -1; + if (!dbus_py_validate_member_name(method)) return -1; + if (self->msg) { + dbus_message_unref(self->msg); + self->msg = NULL; + } + self->msg = dbus_message_new_method_call(destination, path, interface, + method); + if (!self->msg) { + PyErr_NoMemory(); + return -1; + } + return 0; +} + +PyDoc_STRVAR(MethodReturnMessage_tp_doc, "A method-return message.\n\n" +"Constructor::\n\n" +" dbus.lowlevel.MethodReturnMessage(method_call: MethodCallMessage)\n"); + +static int +MethodReturnMessage_tp_init(Message *self, PyObject *args, PyObject *kwargs) +{ + Message *other; + static char *kwlist[] = {"method_call", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!:__init__", kwlist, + &MessageType, &other)) { + return -1; + } + if (self->msg) { + dbus_message_unref(self->msg); + self->msg = NULL; + } + self->msg = dbus_message_new_method_return(other->msg); + if (!self->msg) { + PyErr_NoMemory(); + return -1; + } + return 0; +} + +PyDoc_STRVAR(SignalMessage_tp_doc, "A signal message.\n\n" +"Constructor::\n\n" +" dbus.lowlevel.SignalMessage(path: str, interface: str, method: str)\n"); +static int +SignalMessage_tp_init(Message *self, PyObject *args, PyObject *kwargs) +{ + const char *path, *interface, *name; + static char *kwlist[] = {"path", "interface", "name", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sss:__init__", kwlist, + &path, &interface, &name)) { + return -1; + } + if (!dbus_py_validate_object_path(path)) return -1; + if (!dbus_py_validate_interface_name(interface)) return -1; + if (!dbus_py_validate_member_name(name)) return -1; + if (self->msg) { + dbus_message_unref(self->msg); + self->msg = NULL; + } + self->msg = dbus_message_new_signal(path, interface, name); + if (!self->msg) { + PyErr_NoMemory(); + return -1; + } + return 0; +} + +PyDoc_STRVAR(ErrorMessage_tp_doc, "An error message.\n\n" +"Constructor::\n\n" +" dbus.lowlevel.ErrorMessage(reply_to: Message, error_name: str,\n" +" error_message: str or None)\n"); +static int +ErrorMessage_tp_init(Message *self, PyObject *args, PyObject *kwargs) +{ + Message *reply_to; + const char *error_name, *error_message; + static char *kwlist[] = {"reply_to", "error_name", "error_message", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O!sz:__init__", kwlist, + &MessageType, &reply_to, &error_name, + &error_message)) { + return -1; + } + if (!dbus_py_validate_error_name(error_name)) return -1; + if (self->msg) { + dbus_message_unref(self->msg); + self->msg = NULL; + } + self->msg = dbus_message_new_error(reply_to->msg, error_name, error_message); + if (!self->msg) { + PyErr_NoMemory(); + return -1; + } + return 0; +} + +DBusMessage * +DBusPyMessage_BorrowDBusMessage(PyObject *msg) +{ + if (!Message_Check(msg)) { + PyErr_SetString(PyExc_TypeError, + "A dbus.lowlevel.Message instance is required"); + return NULL; + } + if (!((Message *)msg)->msg) { + DBusPy_RaiseUnusableMessage(); + return NULL; + } + return ((Message *)msg)->msg; +} + +PyObject * +DBusPyMessage_ConsumeDBusMessage(DBusMessage *msg) +{ + PyTypeObject *type; + Message *self; + + switch (dbus_message_get_type(msg)) { + case DBUS_MESSAGE_TYPE_METHOD_CALL: + type = &MethodCallMessageType; + break; + case DBUS_MESSAGE_TYPE_METHOD_RETURN: + type = &MethodReturnMessageType; + break; + case DBUS_MESSAGE_TYPE_ERROR: + type = &ErrorMessageType; + break; + case DBUS_MESSAGE_TYPE_SIGNAL: + type = &SignalMessageType; + break; + default: + type = &MessageType; + } + + self = (Message *)(type->tp_new) (type, dbus_py_empty_tuple, NULL); + if (!self) { + dbus_message_unref(msg); + return NULL; + } + self->msg = msg; + return (PyObject *)self; +} + +PyDoc_STRVAR(Message_copy__doc__, +"message.copy() -> Message (or subclass)\n" +"Deep-copy the message, resetting the serial number to zero.\n"); +static PyObject * +Message_copy(Message *self, PyObject *args UNUSED) +{ + DBusMessage *msg; + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + msg = dbus_message_copy(self->msg); + if (!msg) return PyErr_NoMemory(); + return DBusPyMessage_ConsumeDBusMessage(msg); +} + +PyDoc_STRVAR(Message_get_auto_start__doc__, +"message.get_auto_start() -> bool\n" +"Return true if this message will cause an owner for the destination name\n" +"to be auto-started.\n"); +static PyObject * +Message_get_auto_start(Message *self, PyObject *unused UNUSED) +{ + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_get_auto_start(self->msg)); +} + +PyDoc_STRVAR(Message_set_auto_start__doc__, +"message.set_auto_start(bool) -> None\n" +"Set whether this message will cause an owner for the destination name\n" +"to be auto-started.\n"); +static PyObject * +Message_set_auto_start(Message *self, PyObject *args) +{ + int value; + if (!PyArg_ParseTuple(args, "i", &value)) return NULL; + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + dbus_message_set_auto_start(self->msg, value ? TRUE : FALSE); + Py_INCREF(Py_None); + return Py_None; +} + +PyDoc_STRVAR(Message_get_no_reply__doc__, +"message.get_no_reply() -> bool\n" +"Return true if this message need not be replied to.\n"); +static PyObject * +Message_get_no_reply(Message *self, PyObject *unused UNUSED) +{ + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_get_no_reply(self->msg)); +} + +PyDoc_STRVAR(Message_set_no_reply__doc__, +"message.set_no_reply(bool) -> None\n" +"Set whether no reply to this message is required.\n"); +static PyObject * +Message_set_no_reply(Message *self, PyObject *args) +{ + int value; + if (!PyArg_ParseTuple(args, "i", &value)) return NULL; + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + dbus_message_set_no_reply(self->msg, value ? TRUE : FALSE); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Message_get_reply_serial__doc__, +"message.get_reply_serial() -> long\n" +"Returns the serial that the message is a reply to or 0 if none.\n"); +static PyObject * +Message_get_reply_serial(Message *self, PyObject *unused UNUSED) +{ + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyLong_FromUnsignedLong(dbus_message_get_reply_serial(self->msg)); +} + +PyDoc_STRVAR(Message_set_reply_serial__doc__, +"message.set_reply_serial(bool) -> None\n" +"Set the serial that this message is a reply to.\n"); +static PyObject * +Message_set_reply_serial(Message *self, PyObject *args) +{ + dbus_uint32_t value; + + if (!PyArg_ParseTuple(args, "k", &value)) return NULL; + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + if (!dbus_message_set_reply_serial(self->msg, value)) { + return PyErr_NoMemory(); + } + Py_INCREF(Py_None); + return Py_None; +} + +PyDoc_STRVAR(Message_get_type__doc__, +"message.get_type() -> int\n\n" +"Returns the type of the message.\n"); +static PyObject * +Message_get_type(Message *self, PyObject *unused UNUSED) +{ + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyInt_FromLong(dbus_message_get_type(self->msg)); +} + +PyDoc_STRVAR(Message_get_serial__doc__, +"message.get_serial() -> long\n" +"Returns the serial of a message or 0 if none has been specified.\n" +"\n" +"The message's serial number is provided by the application sending the\n" +"message and is used to identify replies to this message. All messages\n" +"received on a connection will have a serial, but messages you haven't\n" +"sent yet may return 0.\n"); +static PyObject * +Message_get_serial(Message *self, PyObject *unused UNUSED) +{ + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyLong_FromUnsignedLong(dbus_message_get_serial(self->msg)); +} + +PyDoc_STRVAR(Message_is_method_call__doc__, +"is_method_call(interface: str, member: str) -> bool"); +static PyObject * +Message_is_method_call(Message *self, PyObject *args) +{ + const char *interface, *method; + + if (!PyArg_ParseTuple(args, "ss:is_method_call", &interface, &method)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_is_method_call(self->msg, interface, + method)); +} + +PyDoc_STRVAR(Message_is_error__doc__, +"is_error(error: str) -> bool"); +static PyObject * +Message_is_error(Message *self, PyObject *args) +{ + const char *error_name; + + if (!PyArg_ParseTuple(args, "s:is_error", &error_name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_is_error(self->msg, error_name)); +} + +PyDoc_STRVAR(Message_is_signal__doc__, +"is_signal(interface: str, member: str) -> bool"); +static PyObject * +Message_is_signal(Message *self, PyObject *args) +{ + const char *interface, *signal_name; + + if (!PyArg_ParseTuple(args, "ss:is_signal", &interface, &signal_name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_is_signal(self->msg, interface, + signal_name)); +} + +PyDoc_STRVAR(Message_get_member__doc__, +"get_member() -> str or None"); +static PyObject * +Message_get_member(Message *self, PyObject *unused UNUSED) +{ + const char *c_str; + + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + c_str = dbus_message_get_member(self->msg); + if (!c_str) { + Py_RETURN_NONE; + } + return PyString_FromString(c_str); +} + +PyDoc_STRVAR(Message_has_member__doc__, +"has_member(name: str or None) -> bool"); +static PyObject * +Message_has_member(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:has_member", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_has_member(self->msg, name)); +} + +PyDoc_STRVAR(Message_set_member__doc__, +"set_member(unique_name: str or None)"); +static PyObject * +Message_set_member(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:set_member", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + if (!dbus_py_validate_member_name(name)) return NULL; + if (!dbus_message_set_member(self->msg, name)) return PyErr_NoMemory(); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Message_get_path__doc__, +"get_path() -> ObjectPath or None\n\n" +"Return the message's destination object path (if it's a method call) or\n" +"source object path (if it's a method reply or a signal) or None (if it\n" +"has no path).\n"); +static PyObject * +Message_get_path(Message *self, PyObject *unused UNUSED) +{ + const char *c_str; + + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + c_str = dbus_message_get_path(self->msg); + if (!c_str) { + Py_RETURN_NONE; + } + return PyObject_CallFunction((PyObject *)&DBusPyObjectPath_Type, "(s)", c_str); +} + +PyDoc_STRVAR(Message_get_path_decomposed__doc__, +"get_path_decomposed() -> list of str, or None\n\n" +"Return a list of path components (e.g. /foo/bar -> ['foo','bar'], / -> [])\n" +"or None if the message has no associated path.\n"); +static PyObject * +Message_get_path_decomposed(Message *self, PyObject *unused UNUSED) +{ + char **paths, **ptr; + PyObject *ret = PyList_New(0); + + if (!ret) return NULL; + if (!self->msg) { + Py_DECREF(ret); + return DBusPy_RaiseUnusableMessage(); + } + if (!dbus_message_get_path_decomposed(self->msg, &paths)) { + Py_DECREF(ret); + return PyErr_NoMemory(); + } + if (!paths) { + Py_DECREF(ret); + Py_RETURN_NONE; + } + for (ptr = paths; *ptr; ptr++) { + PyObject *str = PyString_FromString(*ptr); + + if (!str) { + Py_DECREF(ret); + ret = NULL; + break; + } + if (PyList_Append(ret, str) < 0) { + Py_DECREF(ret); + ret = NULL; + break; + } + Py_DECREF(str); + str = NULL; + } + dbus_free_string_array(paths); + return ret; +} + +PyDoc_STRVAR(Message_has_path__doc__, +"has_path(name: str or None) -> bool"); +static PyObject * +Message_has_path(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:has_path", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_has_path(self->msg, name)); +} + +PyDoc_STRVAR(Message_set_path__doc__, +"set_path(name: str or None)"); +static PyObject * +Message_set_path(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:set_path", &name)) return NULL; + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + if (!dbus_message_has_path(self->msg, name)) return PyErr_NoMemory(); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Message_get_signature__doc__, +"get_signature() -> Signature or None"); +static PyObject * +Message_get_signature(Message *self, PyObject *unused UNUSED) +{ + const char *c_str; + + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + c_str = dbus_message_get_signature(self->msg); + if (!c_str) { + return PyObject_CallFunction((PyObject *)&DBusPySignature_Type, "(s)", ""); + } + return PyObject_CallFunction((PyObject *)&DBusPySignature_Type, "(s)", c_str); +} + +PyDoc_STRVAR(Message_has_signature__doc__, +"has_signature(signature: str) -> bool"); +static PyObject * +Message_has_signature(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "s:has_signature", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_has_signature(self->msg, name)); +} + +PyDoc_STRVAR(Message_get_sender__doc__, +"get_sender() -> str or None\n\n" +"Return the message's sender unique name, or None if none.\n"); +static PyObject * +Message_get_sender(Message *self, PyObject *unused UNUSED) +{ + const char *c_str; + + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + c_str = dbus_message_get_sender(self->msg); + if (!c_str) { + Py_RETURN_NONE; + } + return PyString_FromString(c_str); +} + +PyDoc_STRVAR(Message_has_sender__doc__, +"has_sender(unique_name: str) -> bool"); +static PyObject * +Message_has_sender(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "s:has_sender", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_has_sender(self->msg, name)); +} + +PyDoc_STRVAR(Message_set_sender__doc__, +"set_sender(unique_name: str or None)"); +static PyObject * +Message_set_sender(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:set_sender", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + if (!dbus_py_validate_bus_name(name, 1, 1)) return NULL; + if (!dbus_message_set_sender(self->msg, name)) return PyErr_NoMemory(); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Message_get_destination__doc__, +"get_destination() -> str or None\n\n" +"Return the message's destination bus name, or None if none.\n"); +static PyObject * +Message_get_destination(Message *self, PyObject *unused UNUSED) +{ + const char *c_str; + + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + c_str = dbus_message_get_destination(self->msg); + if (!c_str) { + Py_RETURN_NONE; + } + return PyString_FromString(c_str); +} + +PyDoc_STRVAR(Message_has_destination__doc__, +"has_destination(bus_name: str) -> bool"); +static PyObject * +Message_has_destination(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "s:has_destination", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_has_destination(self->msg, name)); +} + +PyDoc_STRVAR(Message_set_destination__doc__, +"set_destination(bus_name: str or None)"); +static PyObject * +Message_set_destination(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:set_destination", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + if (!dbus_py_validate_bus_name(name, 1, 1)) return NULL; + if (!dbus_message_set_destination(self->msg, name)) return PyErr_NoMemory(); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Message_get_interface__doc__, +"get_interface() -> str or None"); +static PyObject * +Message_get_interface(Message *self, PyObject *unused UNUSED) +{ + const char *c_str; + + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + c_str = dbus_message_get_interface(self->msg); + if (!c_str) { + Py_RETURN_NONE; + } + return PyString_FromString(c_str); +} + +PyDoc_STRVAR(Message_has_interface__doc__, +"has_interface(interface: str or None) -> bool"); +static PyObject * +Message_has_interface(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:has_interface", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + return PyBool_FromLong(dbus_message_has_interface(self->msg, name)); +} + +PyDoc_STRVAR(Message_set_interface__doc__, +"set_interface(name: str or None)"); +static PyObject * +Message_set_interface(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:set_interface", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + if (!dbus_py_validate_interface_name(name)) return NULL; + if (!dbus_message_set_interface(self->msg, name)) return PyErr_NoMemory(); + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Message_get_error_name__doc__, +"get_error_name() -> str or None"); +static PyObject * +Message_get_error_name(Message *self, PyObject *unused UNUSED) +{ + const char *c_str; + + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + c_str = dbus_message_get_error_name(self->msg); + if (!c_str) { + Py_RETURN_NONE; + } + return PyString_FromString(c_str); +} + +PyDoc_STRVAR(Message_set_error_name__doc__, +"set_error_name(name: str or None)"); +static PyObject * +Message_set_error_name(Message *self, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "z:set_error_name", &name)) { + return NULL; + } + if (!self->msg) return DBusPy_RaiseUnusableMessage(); + if (!dbus_py_validate_error_name(name)) return NULL; + if (!dbus_message_set_error_name(self->msg, name)) return PyErr_NoMemory(); + Py_RETURN_NONE; +} + +static PyMethodDef Message_tp_methods[] = { + {"copy", (PyCFunction)Message_copy, + METH_NOARGS, Message_copy__doc__}, + {"is_method_call", (PyCFunction)Message_is_method_call, + METH_VARARGS, Message_is_method_call__doc__}, + {"is_signal", (PyCFunction)Message_is_signal, + METH_VARARGS, Message_is_signal__doc__}, + {"is_error", (PyCFunction)Message_is_error, + METH_VARARGS, Message_is_error__doc__}, + + {"get_args_list", (PyCFunction)dbus_py_Message_get_args_list, + METH_VARARGS|METH_KEYWORDS, dbus_py_Message_get_args_list__doc__}, + {"guess_signature", (PyCFunction)dbus_py_Message_guess_signature, + METH_VARARGS|METH_STATIC, dbus_py_Message_guess_signature__doc__}, + {"append", (PyCFunction)dbus_py_Message_append, + METH_VARARGS|METH_KEYWORDS, dbus_py_Message_append__doc__}, + + {"get_auto_start", (PyCFunction)Message_get_auto_start, + METH_NOARGS, Message_get_auto_start__doc__}, + {"set_auto_start", (PyCFunction)Message_set_auto_start, + METH_VARARGS, Message_set_auto_start__doc__}, + {"get_destination", (PyCFunction)Message_get_destination, + METH_NOARGS, Message_get_destination__doc__}, + {"set_destination", (PyCFunction)Message_set_destination, + METH_VARARGS, Message_set_destination__doc__}, + {"has_destination", (PyCFunction)Message_has_destination, + METH_VARARGS, Message_has_destination__doc__}, + {"get_error_name", (PyCFunction)Message_get_error_name, + METH_NOARGS, Message_get_error_name__doc__}, + {"set_error_name", (PyCFunction)Message_set_error_name, + METH_VARARGS, Message_set_error_name__doc__}, + {"get_interface", (PyCFunction)Message_get_interface, + METH_NOARGS, Message_get_interface__doc__}, + {"set_interface", (PyCFunction)Message_set_interface, + METH_VARARGS, Message_set_interface__doc__}, + {"has_interface", (PyCFunction)Message_has_interface, + METH_VARARGS, Message_has_interface__doc__}, + {"get_member", (PyCFunction)Message_get_member, + METH_NOARGS, Message_get_member__doc__}, + {"set_member", (PyCFunction)Message_set_member, + METH_VARARGS, Message_set_member__doc__}, + {"has_member", (PyCFunction)Message_has_member, + METH_VARARGS, Message_has_member__doc__}, + {"get_path", (PyCFunction)Message_get_path, + METH_NOARGS, Message_get_path__doc__}, + {"get_path_decomposed", (PyCFunction)Message_get_path_decomposed, + METH_NOARGS, Message_get_path_decomposed__doc__}, + {"set_path", (PyCFunction)Message_set_path, + METH_VARARGS, Message_set_path__doc__}, + {"has_path", (PyCFunction)Message_has_path, + METH_VARARGS, Message_has_path__doc__}, + {"get_no_reply", (PyCFunction)Message_get_no_reply, + METH_NOARGS, Message_get_no_reply__doc__}, + {"set_no_reply", (PyCFunction)Message_set_no_reply, + METH_VARARGS, Message_set_no_reply__doc__}, + {"get_reply_serial", (PyCFunction)Message_get_reply_serial, + METH_NOARGS, Message_get_reply_serial__doc__}, + {"set_reply_serial", (PyCFunction)Message_set_reply_serial, + METH_VARARGS, Message_set_reply_serial__doc__}, + {"get_sender", (PyCFunction)Message_get_sender, + METH_NOARGS, Message_get_sender__doc__}, + {"set_sender", (PyCFunction)Message_set_sender, + METH_VARARGS, Message_set_sender__doc__}, + {"has_sender", (PyCFunction)Message_has_sender, + METH_VARARGS, Message_has_sender__doc__}, + {"get_serial", (PyCFunction)Message_get_serial, + METH_NOARGS, Message_get_serial__doc__}, + {"get_signature", (PyCFunction)Message_get_signature, + METH_NOARGS, Message_get_signature__doc__}, + {"has_signature", (PyCFunction)Message_has_signature, + METH_VARARGS, Message_has_signature__doc__}, + {"get_type", (PyCFunction)Message_get_type, + METH_NOARGS, Message_get_type__doc__}, + {NULL, NULL, 0, NULL} +}; + +static PyTypeObject MessageType = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "dbus.lowlevel.Message", /*tp_name*/ + sizeof(Message), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + (destructor)Message_tp_dealloc, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + Message_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + Message_tp_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + Message_tp_new, /* tp_new */ +}; + +static PyTypeObject MethodCallMessageType = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "dbus.lowlevel.MethodCallMessage", /*tp_name*/ + 0, /*tp_basicsize*/ + 0, /*tp_itemsize*/ + 0, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + MethodCallMessage_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&MessageType), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)MethodCallMessage_tp_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ +}; + +static PyTypeObject MethodReturnMessageType = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "dbus.lowlevel.MethodReturnMessage", /*tp_name*/ + 0, /*tp_basicsize*/ + 0, /*tp_itemsize*/ + 0, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + MethodReturnMessage_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&MessageType), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)MethodReturnMessage_tp_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ +}; + +static PyTypeObject SignalMessageType = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "dbus.lowlevel.SignalMessage", /*tp_name*/ + 0, /*tp_basicsize*/ + 0, /*tp_itemsize*/ + 0, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + SignalMessage_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&MessageType), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)SignalMessage_tp_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ +}; + +static PyTypeObject ErrorMessageType = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "dbus.lowlevel.ErrorMessage", /*tp_name*/ + 0, /*tp_basicsize*/ + 0, /*tp_itemsize*/ + 0, /*tp_dealloc*/ + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash */ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /*tp_flags*/ + ErrorMessage_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&MessageType), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + (initproc)ErrorMessage_tp_init, /* tp_init */ + 0, /* tp_alloc */ + 0, /* tp_new */ +}; + +dbus_bool_t +dbus_py_init_message_types(void) +{ + if (PyType_Ready(&MessageType) < 0) return 0; + + MethodCallMessageType.tp_base = &MessageType; + if (PyType_Ready(&MethodCallMessageType) < 0) return 0; + + MethodReturnMessageType.tp_base = &MessageType; + if (PyType_Ready(&MethodReturnMessageType) < 0) return 0; + + SignalMessageType.tp_base = &MessageType; + if (PyType_Ready(&SignalMessageType) < 0) return 0; + + ErrorMessageType.tp_base = &MessageType; + if (PyType_Ready(&ErrorMessageType) < 0) return 0; + + return 1; +} + +dbus_bool_t +dbus_py_insert_message_types(PyObject *this_module) +{ + if (PyModule_AddObject(this_module, "Message", + (PyObject *)&MessageType) < 0) return 0; + + if (PyModule_AddObject(this_module, "MethodCallMessage", + (PyObject *)&MethodCallMessageType) < 0) return 0; + + if (PyModule_AddObject(this_module, "MethodReturnMessage", + (PyObject *)&MethodReturnMessageType) < 0) return 0; + + if (PyModule_AddObject(this_module, "ErrorMessage", + (PyObject *)&ErrorMessageType) < 0) return 0; + + if (PyModule_AddObject(this_module, "SignalMessage", + (PyObject *)&SignalMessageType) < 0) return 0; + + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/module.c b/_dbus_bindings/module.c new file mode 100644 index 0000000..a4c2a66 --- /dev/null +++ b/_dbus_bindings/module.c @@ -0,0 +1,395 @@ +/* Main module source for the _dbus_bindings extension. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ +#include "config.h" + +#include +#include + +#include "dbus_bindings-internal.h" + +PyDoc_STRVAR(module_doc, +"Low-level Python bindings for libdbus. Don't use this module directly -\n" +"the public API is provided by the `dbus`, `dbus.service`, `dbus.mainloop`\n" +"and `dbus.mainloop.glib` modules, with a lower-level API provided by the\n" +"`dbus.lowlevel` module.\n" +); + +/* Global functions - validation wrappers ===========================*/ + +PyDoc_STRVAR(validate_bus_name__doc__, +"validate_bus_name(name, allow_unique=True, allow_well_known=True)\n" +"\n" +"Raise ValueError if the argument is not a valid bus name.\n" +"\n" +"By default both unique and well-known names are accepted.\n" +"\n" +":Parameters:\n" +" `name` : str\n" +" The name to be validated\n" +" `allow_unique` : bool\n" +" If False, unique names of the form :1.123 will be rejected\n" +" `allow_well_known` : bool\n" +" If False, well-known names of the form com.example.Foo\n" +" will be rejected\n" +":Since: 0.80\n" +); + +static PyObject * +validate_bus_name(PyObject *unused UNUSED, PyObject *args, PyObject *kwargs) +{ + const char *name; + int allow_unique = 1; + int allow_well_known = 1; + static char *argnames[] = { "name", "allow_unique", "allow_well_known", + NULL }; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "s|ii:validate_bus_name", argnames, + &name, &allow_unique, + &allow_well_known)) { + return NULL; + } + if (!dbus_py_validate_bus_name(name, !!allow_unique, !!allow_well_known)) { + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(validate_member_name__doc__, +"validate_member_name(name)\n" +"\n" +"Raise ValueError if the argument is not a valid member (signal or method) " +"name.\n" +"\n" +":Since: 0.80\n" +); + +static PyObject * +validate_member_name(PyObject *unused UNUSED, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "s:validate_member_name", &name)) { + return NULL; + } + if (!dbus_py_validate_member_name(name)) { + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(validate_interface_name__doc__, +"validate_interface_name(name)\n\n" +"Raise ValueError if the given string is not a valid interface name.\n" +"\n" +":Since: 0.80\n" +); + +PyDoc_STRVAR(validate_error_name__doc__, +"validate_error_name(name)\n\n" +"Raise ValueError if the given string is not a valid error name.\n" +"\n" +":Since: 0.80\n" +); + +static PyObject * +validate_interface_name(PyObject *unused UNUSED, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "s:validate_interface_name", &name)) { + return NULL; + } + if (!dbus_py_validate_interface_name(name)) { + return NULL; + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(validate_object_path__doc__, +"validate_object_path(name)\n\n" +"Raise ValueError if the given string is not a valid object path.\n" +"\n" +":Since: 0.80\n" +); + +static PyObject * +validate_object_path(PyObject *unused UNUSED, PyObject *args) +{ + const char *name; + + if (!PyArg_ParseTuple(args, "s:validate_object_path", &name)) { + return NULL; + } + if (!dbus_py_validate_object_path(name)) { + return NULL; + } + Py_RETURN_NONE; +} + +/* Global functions - main loop =====================================*/ + +/* The main loop if none is passed to the constructor */ +static PyObject *default_main_loop = NULL; + +/* Return a new reference to the default main loop */ +PyObject * +dbus_py_get_default_main_loop(void) +{ + if (!default_main_loop) { + Py_RETURN_NONE; + } + Py_INCREF(default_main_loop); + return default_main_loop; +} + +PyDoc_STRVAR(get_default_main_loop__doc__, +"get_default_main_loop() -> object\n\n" +"Return the global default dbus-python main loop wrapper, which is used\n" +"when no main loop wrapper is passed to the Connection constructor.\n" +"\n" +"If None, there is no default and you should always pass the mainloop\n" +"parameter to the constructor - if you don't, then asynchronous calls,\n" +"connecting to signals and exporting objects will raise an exception.\n" +"There is no default until set_default_main_loop is called.\n"); +static PyObject * +get_default_main_loop(PyObject *always_null UNUSED, + PyObject *no_args UNUSED) +{ + return dbus_py_get_default_main_loop(); +} + +PyDoc_STRVAR(set_default_main_loop__doc__, +"set_default_main_loop(object)\n\n" +"Change the global default dbus-python main loop wrapper, which is used\n" +"when no main loop wrapper is passed to the Connection constructor.\n" +"\n" +"If None, return to the initial situation: there is no default, and you\n" +"must always pass the mainloop parameter to the constructor.\n" +"\n" +"Two types of main loop wrapper are planned in dbus-python.\n" +"Native main-loop wrappers are instances of `dbus.mainloop.NativeMainLoop`\n" +"supplied by extension modules like `dbus.mainloop.glib`: they have no\n" +"Python API, but connect themselves to ``libdbus`` using native code.\n" + +"Python main-loop wrappers are not yet implemented. They will be objects\n" +"supporting the interface defined by `dbus.mainloop.MainLoop`, with an\n" +"API entirely based on Python methods.\n" +"\n" +); +static PyObject * +set_default_main_loop(PyObject *always_null UNUSED, + PyObject *args) +{ + PyObject *new_loop, *old_loop; + + if (!PyArg_ParseTuple(args, "O", &new_loop)) { + return NULL; + } + if (!dbus_py_check_mainloop_sanity(new_loop)) { + return NULL; + } + old_loop = default_main_loop; + Py_INCREF(new_loop); + default_main_loop = new_loop; + Py_XDECREF(old_loop); + Py_RETURN_NONE; +} + +static PyMethodDef module_functions[] = { +#define ENTRY(name,flags) {#name, (PyCFunction)name, flags, name##__doc__} + ENTRY(validate_interface_name, METH_VARARGS), + ENTRY(validate_member_name, METH_VARARGS), + ENTRY(validate_bus_name, METH_VARARGS|METH_KEYWORDS), + ENTRY(validate_object_path, METH_VARARGS), + ENTRY(set_default_main_loop, METH_VARARGS), + ENTRY(get_default_main_loop, METH_NOARGS), + /* validate_error_name is just implemented as validate_interface_name */ + {"validate_error_name", validate_interface_name, + METH_VARARGS, validate_error_name__doc__}, +#undef ENTRY + {NULL, NULL, 0, NULL} +}; + +PyMODINIT_FUNC +init_dbus_bindings(void) +{ + PyObject *this_module, *c_api; + static const int API_count = DBUS_BINDINGS_API_COUNT; + static _dbus_py_func_ptr dbus_bindings_API[DBUS_BINDINGS_API_COUNT]; + + dbus_bindings_API[0] = (_dbus_py_func_ptr)&API_count; + dbus_bindings_API[1] = (_dbus_py_func_ptr)DBusPyConnection_BorrowDBusConnection; + dbus_bindings_API[2] = (_dbus_py_func_ptr)DBusPyNativeMainLoop_New4; + + default_main_loop = NULL; + + /* I'd rather not initialize threads if we can help it - dbus-python and + pygobject both release and re-obtain the GIL on a regular basis, which is + much simpler (basically free) before threads are initialized. + + However, on Python < 2.4.2c1 you aren't allowed to call + PyGILState_Release without initializing threads first. */ + if (strcmp(Py_GetVersion(), "2.4.2c1") < 0) { + PyEval_InitThreads(); + } + + if (!dbus_py_init_generic()) return; + if (!dbus_py_init_abstract()) return; + if (!dbus_py_init_signature()) return; + if (!dbus_py_init_int_types()) return; + if (!dbus_py_init_string_types()) return; + if (!dbus_py_init_float_types()) return; + if (!dbus_py_init_container_types()) return; + if (!dbus_py_init_byte_types()) return; + if (!dbus_py_init_message_types()) return; + if (!dbus_py_init_pending_call()) return; + if (!dbus_py_init_mainloop()) return; + if (!dbus_py_init_libdbus_conn_types()) return; + if (!dbus_py_init_conn_types()) return; + if (!dbus_py_init_server_types()) return; + + this_module = Py_InitModule3("_dbus_bindings", module_functions, module_doc); + if (!this_module) return; + + if (!dbus_py_insert_abstract_types(this_module)) return; + if (!dbus_py_insert_signature(this_module)) return; + if (!dbus_py_insert_int_types(this_module)) return; + if (!dbus_py_insert_string_types(this_module)) return; + if (!dbus_py_insert_float_types(this_module)) return; + if (!dbus_py_insert_container_types(this_module)) return; + if (!dbus_py_insert_byte_types(this_module)) return; + if (!dbus_py_insert_message_types(this_module)) return; + if (!dbus_py_insert_pending_call(this_module)) return; + if (!dbus_py_insert_mainloop_types(this_module)) return; + if (!dbus_py_insert_libdbus_conn_types(this_module)) return; + if (!dbus_py_insert_conn_types(this_module)) return; + if (!dbus_py_insert_server_types(this_module)) return; + + if (PyModule_AddStringConstant(this_module, "BUS_DAEMON_NAME", + DBUS_SERVICE_DBUS) < 0) return; + if (PyModule_AddStringConstant(this_module, "BUS_DAEMON_PATH", + DBUS_PATH_DBUS) < 0) return; + if (PyModule_AddStringConstant(this_module, "BUS_DAEMON_IFACE", + DBUS_INTERFACE_DBUS) < 0) return; + if (PyModule_AddStringConstant(this_module, "LOCAL_PATH", + DBUS_PATH_LOCAL) < 0) return; + if (PyModule_AddStringConstant(this_module, "LOCAL_IFACE", + DBUS_INTERFACE_LOCAL) < 0) return; + if (PyModule_AddStringConstant(this_module, "INTROSPECTABLE_IFACE", + DBUS_INTERFACE_INTROSPECTABLE) < 0) return; + if (PyModule_AddStringConstant(this_module, "PEER_IFACE", + DBUS_INTERFACE_PEER) < 0) return; + if (PyModule_AddStringConstant(this_module, "PROPERTIES_IFACE", + DBUS_INTERFACE_PROPERTIES) < 0) return; + if (PyModule_AddStringConstant(this_module, + "DBUS_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER", + DBUS_INTROSPECT_1_0_XML_PUBLIC_IDENTIFIER) < 0) return; + if (PyModule_AddStringConstant(this_module, + "DBUS_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER", + DBUS_INTROSPECT_1_0_XML_SYSTEM_IDENTIFIER) < 0) return; + if (PyModule_AddStringConstant(this_module, + "DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE", + DBUS_INTROSPECT_1_0_XML_DOCTYPE_DECL_NODE) < 0) return; + +#define ADD_CONST_VAL(x, v) \ + if (PyModule_AddIntConstant(this_module, x, v) < 0) return; +#define ADD_CONST_PREFIXED(x) ADD_CONST_VAL(#x, DBUS_##x) +#define ADD_CONST(x) ADD_CONST_VAL(#x, x) + + ADD_CONST(DBUS_START_REPLY_SUCCESS) + ADD_CONST(DBUS_START_REPLY_ALREADY_RUNNING) + + ADD_CONST_PREFIXED(RELEASE_NAME_REPLY_RELEASED) + ADD_CONST_PREFIXED(RELEASE_NAME_REPLY_NON_EXISTENT) + ADD_CONST_PREFIXED(RELEASE_NAME_REPLY_NOT_OWNER) + + ADD_CONST_PREFIXED(REQUEST_NAME_REPLY_PRIMARY_OWNER) + ADD_CONST_PREFIXED(REQUEST_NAME_REPLY_IN_QUEUE) + ADD_CONST_PREFIXED(REQUEST_NAME_REPLY_EXISTS) + ADD_CONST_PREFIXED(REQUEST_NAME_REPLY_ALREADY_OWNER) + + ADD_CONST_PREFIXED(NAME_FLAG_ALLOW_REPLACEMENT) + ADD_CONST_PREFIXED(NAME_FLAG_REPLACE_EXISTING) + ADD_CONST_PREFIXED(NAME_FLAG_DO_NOT_QUEUE) + + ADD_CONST_PREFIXED(BUS_SESSION) + ADD_CONST_PREFIXED(BUS_SYSTEM) + ADD_CONST_PREFIXED(BUS_STARTER) + + ADD_CONST_PREFIXED(MESSAGE_TYPE_INVALID) + ADD_CONST_PREFIXED(MESSAGE_TYPE_METHOD_CALL) + ADD_CONST_PREFIXED(MESSAGE_TYPE_METHOD_RETURN) + ADD_CONST_PREFIXED(MESSAGE_TYPE_ERROR) + ADD_CONST_PREFIXED(MESSAGE_TYPE_SIGNAL) + + ADD_CONST_PREFIXED(TYPE_INVALID) + ADD_CONST_PREFIXED(TYPE_BYTE) + ADD_CONST_PREFIXED(TYPE_BOOLEAN) + ADD_CONST_PREFIXED(TYPE_INT16) + ADD_CONST_PREFIXED(TYPE_UINT16) + ADD_CONST_PREFIXED(TYPE_INT32) + ADD_CONST_PREFIXED(TYPE_UINT32) + ADD_CONST_PREFIXED(TYPE_INT64) + ADD_CONST_PREFIXED(TYPE_UINT64) + ADD_CONST_PREFIXED(TYPE_DOUBLE) + ADD_CONST_PREFIXED(TYPE_STRING) + ADD_CONST_PREFIXED(TYPE_OBJECT_PATH) + ADD_CONST_PREFIXED(TYPE_SIGNATURE) + ADD_CONST_PREFIXED(TYPE_ARRAY) + ADD_CONST_PREFIXED(TYPE_STRUCT) + ADD_CONST_VAL("STRUCT_BEGIN", DBUS_STRUCT_BEGIN_CHAR) + ADD_CONST_VAL("STRUCT_END", DBUS_STRUCT_END_CHAR) + ADD_CONST_PREFIXED(TYPE_VARIANT) + ADD_CONST_PREFIXED(TYPE_DICT_ENTRY) + ADD_CONST_VAL("DICT_ENTRY_BEGIN", DBUS_DICT_ENTRY_BEGIN_CHAR) + ADD_CONST_VAL("DICT_ENTRY_END", DBUS_DICT_ENTRY_END_CHAR) + + ADD_CONST_PREFIXED(HANDLER_RESULT_HANDLED) + ADD_CONST_PREFIXED(HANDLER_RESULT_NOT_YET_HANDLED) + ADD_CONST_PREFIXED(HANDLER_RESULT_NEED_MEMORY) + + ADD_CONST_PREFIXED(WATCH_READABLE) + ADD_CONST_PREFIXED(WATCH_WRITABLE) + ADD_CONST_PREFIXED(WATCH_HANGUP) + ADD_CONST_PREFIXED(WATCH_ERROR) + + if (PyModule_AddStringConstant(this_module, "__docformat__", + "restructuredtext") < 0) return; + + if (PyModule_AddStringConstant(this_module, "__version__", + PACKAGE_VERSION) < 0) return; + + if (PyModule_AddIntConstant(this_module, "_python_version", + PY_VERSION_HEX) < 0) return; + + c_api = PyCObject_FromVoidPtr ((void *)dbus_bindings_API, NULL); + if (!c_api) { + return; + } + PyModule_AddObject(this_module, "_C_API", c_api); +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/pending-call.c b/_dbus_bindings/pending-call.c new file mode 100644 index 0000000..ad18fd7 --- /dev/null +++ b/_dbus_bindings/pending-call.c @@ -0,0 +1,293 @@ +/* Implementation of PendingCall helper type for D-Bus bindings. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" + +PyDoc_STRVAR(PendingCall_tp_doc, +"Object representing a pending D-Bus call, returned by\n" +"Connection.send_message_with_reply(). Cannot be instantiated directly.\n" +); + +static PyTypeObject PendingCallType; + +static inline int PendingCall_Check (PyObject *o) +{ + return (o->ob_type == &PendingCallType) + || PyObject_IsInstance(o, (PyObject *)&PendingCallType); +} + +typedef struct { + PyObject_HEAD + DBusPendingCall *pc; +} PendingCall; + +PyDoc_STRVAR(PendingCall_cancel__doc__, +"cancel()\n\n" +"Cancel this pending call. Its reply will be ignored and the associated\n" +"reply handler will never be called.\n"); +static PyObject * +PendingCall_cancel(PendingCall *self, PyObject *unused UNUSED) +{ + Py_BEGIN_ALLOW_THREADS + dbus_pending_call_cancel(self->pc); + Py_END_ALLOW_THREADS + Py_RETURN_NONE; +} + +PyDoc_STRVAR(PendingCall_block__doc__, +"block()\n\n" +"Block until this pending call has completed and the associated\n" +"reply handler has been called.\n" +"\n" +"This can lead to a deadlock, if the called method tries to make a\n" +"synchronous call to a method in this application.\n"); +static PyObject * +PendingCall_block(PendingCall *self, PyObject *unused UNUSED) +{ + Py_BEGIN_ALLOW_THREADS + dbus_pending_call_block(self->pc); + Py_END_ALLOW_THREADS + Py_RETURN_NONE; +} + +static void +_pending_call_notify_function(DBusPendingCall *pc, + PyObject *list) +{ + PyGILState_STATE gil = PyGILState_Ensure(); + /* BEGIN CRITICAL SECTION + * While holding the GIL, make sure the callback only gets called once + * by deleting it from the 1-item list that's held by libdbus. + */ + PyObject *handler = PyList_GetItem(list, 0); + DBusMessage *msg; + + if (!handler) { + PyErr_Print(); + goto release; + } + if (handler == Py_None) { + /* We've already called (and thrown away) the callback */ + goto release; + } + Py_INCREF(handler); /* previously borrowed from the list, now owned */ + Py_INCREF(Py_None); /* take a ref so SetItem can steal it */ + PyList_SetItem(list, 0, Py_None); + /* END CRITICAL SECTION */ + + msg = dbus_pending_call_steal_reply(pc); + + if (!msg) { + /* omg, what happened here? the notify should only get called + * when we have a reply */ + PyErr_Warn(PyExc_UserWarning, "D-Bus notify function was called " + "for an incomplete pending call (shouldn't happen)"); + } else { + PyObject *msg_obj = DBusPyMessage_ConsumeDBusMessage(msg); + + if (msg_obj) { + PyObject *ret = PyObject_CallFunctionObjArgs(handler, msg_obj, NULL); + + if (!ret) { + PyErr_Print(); + } + Py_XDECREF(ret); + Py_DECREF(msg_obj); + } + /* else OOM has happened - not a lot we can do about that, + * except possibly making it fatal (FIXME?) */ + } + +release: + Py_XDECREF(handler); + PyGILState_Release(gil); +} + +PyDoc_STRVAR(PendingCall_get_completed__doc__, +"get_completed() -> bool\n\n" +"Return true if this pending call has completed.\n\n" +"If so, its associated reply handler has been called and it is no\n" +"longer meaningful to cancel it.\n"); +static PyObject * +PendingCall_get_completed(PendingCall *self, PyObject *unused UNUSED) +{ + dbus_bool_t ret; + + Py_BEGIN_ALLOW_THREADS + ret = dbus_pending_call_get_completed(self->pc); + Py_END_ALLOW_THREADS + return PyBool_FromLong(ret); +} + +/* Steals the reference to the pending call. */ +PyObject * +DBusPyPendingCall_ConsumeDBusPendingCall(DBusPendingCall *pc, + PyObject *callable) +{ + dbus_bool_t ret; + PyObject *list = PyList_New(1); + PendingCall *self = PyObject_New(PendingCall, &PendingCallType); + + if (!list || !self) { + Py_XDECREF(list); + Py_XDECREF(self); + Py_BEGIN_ALLOW_THREADS + dbus_pending_call_cancel(pc); + dbus_pending_call_unref(pc); + Py_END_ALLOW_THREADS + return NULL; + } + + /* INCREF because SET_ITEM steals a ref */ + Py_INCREF(callable); + PyList_SET_ITEM(list, 0, callable); + + /* INCREF so we can give a ref to set_notify and still have one */ + Py_INCREF(list); + + Py_BEGIN_ALLOW_THREADS + ret = dbus_pending_call_set_notify(pc, + (DBusPendingCallNotifyFunction)_pending_call_notify_function, + (void *)list, (DBusFreeFunction)dbus_py_take_gil_and_xdecref); + Py_END_ALLOW_THREADS + + if (!ret) { + PyErr_NoMemory(); + /* DECREF twice - one for the INCREF and one for the allocation */ + Py_DECREF(list); + Py_DECREF(list); + Py_DECREF(self); + Py_BEGIN_ALLOW_THREADS + dbus_pending_call_cancel(pc); + dbus_pending_call_unref(pc); + Py_END_ALLOW_THREADS + return NULL; + } + + /* As Alexander Larsson pointed out on dbus@lists.fd.o on 2006-11-30, + * the API has a race condition if set_notify runs in one thread and a + * mail loop runs in another - if the reply gets in before set_notify + * runs, the notify isn't called and there is no indication of error. + * + * The workaround is to check for completion immediately, but this also + * has a race which might lead to getting the notify called twice if + * we're unlucky. So I use the list to arrange for the notify to be + * deleted before it's called for the second time. The GIL protects + * the critical section in which I delete the callback from the list. + */ + if (dbus_pending_call_get_completed(pc)) { + /* the first race condition happened, so call the callable here. + * FIXME: we ought to arrange for the callable to run from the + * mainloop thread, like it would if the race hadn't happened... + * this needs a better mainloop abstraction, though. + */ + _pending_call_notify_function(pc, list); + } + + Py_DECREF(list); + self->pc = pc; + return (PyObject *)self; +} + +static void +PendingCall_tp_dealloc (PendingCall *self) +{ + if (self->pc) { + Py_BEGIN_ALLOW_THREADS + dbus_pending_call_unref(self->pc); + Py_END_ALLOW_THREADS + } + PyObject_Del (self); +} + +static PyMethodDef PendingCall_tp_methods[] = { + {"block", (PyCFunction)PendingCall_block, METH_NOARGS, + PendingCall_block__doc__}, + {"cancel", (PyCFunction)PendingCall_cancel, METH_NOARGS, + PendingCall_cancel__doc__}, + {"get_completed", (PyCFunction)PendingCall_get_completed, METH_NOARGS, + PendingCall_get_completed__doc__}, + {NULL, NULL, 0, NULL} +}; + +static PyTypeObject PendingCallType = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.lowlevel.PendingCall", + sizeof(PendingCall), + 0, + (destructor)PendingCall_tp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + PendingCall_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + PendingCall_tp_methods, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + /* deliberately not callable! Use PendingCall_ConsumeDBusPendingCall */ + 0, /* tp_new */ +}; + +dbus_bool_t +dbus_py_init_pending_call (void) +{ + if (PyType_Ready (&PendingCallType) < 0) return 0; + return 1; +} + +dbus_bool_t +dbus_py_insert_pending_call (PyObject *this_module) +{ + if (PyModule_AddObject (this_module, "PendingCall", + (PyObject *)&PendingCallType) < 0) return 0; + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/server.c b/_dbus_bindings/server.c new file mode 100644 index 0000000..7fc4f70 --- /dev/null +++ b/_dbus_bindings/server.c @@ -0,0 +1,581 @@ +/* Implementation of the _dbus_bindings Server type, a Python wrapper + * for DBusServer. + * + * Copyright (C) 2008 Openismus GmbH + * Copyright (C) 2008 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" + +/* Server definition ================================================ */ + +typedef struct { + PyObject_HEAD + DBusServer *server; + + /* The Connection subtype for which this Server is a factory */ + PyObject *conn_class; + + /* Weak-references list to make server weakly referenceable */ + PyObject *weaklist; + + PyObject *mainloop; +} Server; + +PyDoc_STRVAR(Server_tp_doc, +"A D-Bus server.\n" +"\n" +"::\n" +"\n" +" Server(address, connection_subtype, mainloop=None, auth_mechanisms=None)\n" +" -> Server\n" +); + +/* D-Bus Server user data slot, containing an owned reference to either + * the Server, or a weakref to the Server. + */ +static dbus_int32_t _server_python_slot; + +/* C API for main-loop hooks ======================================== */ + +/* Return a borrowed reference to the DBusServer which underlies this + * Server. */ +DBusServer * +DBusPyServer_BorrowDBusServer(PyObject *self) +{ + DBusServer *dbs; + + TRACE(self); + if (!DBusPyServer_Check(self)) { + PyErr_SetString(PyExc_TypeError, "A dbus.server.Server is required"); + return NULL; + } + dbs = ((Server *)self)->server; + if (!dbs) { + PyErr_SetString(PyExc_RuntimeError, "Server is in an invalid " + "state: no DBusServer"); + return NULL; + } + return dbs; +} + +/* Internal C API =================================================== */ + +static dbus_bool_t +DBusPyServer_set_auth_mechanisms(Server *self, + PyObject *auth_mechanisms) +{ + PyObject *fast_seq; + Py_ssize_t length; + Py_ssize_t i; + + fast_seq = PySequence_Fast(auth_mechanisms, + "Expecting sequence for auth_mechanisms parameter"); + + if (!fast_seq) + return FALSE; + + length = PySequence_Fast_GET_SIZE(fast_seq); + + /* scope for list */ + { + const char *list[length + 1]; + + for (i = 0; i < length; ++i) { + PyObject *am; + + am = PySequence_Fast_GET_ITEM(auth_mechanisms, i); + /* this supports either str or unicode, raising TypeError + * on failure */ + list[i] = PyString_AsString(am); + + if (!list[i]) + return FALSE; + } + + list[length] = NULL; + + Py_BEGIN_ALLOW_THREADS + dbus_server_set_auth_mechanisms(self->server, list); + Py_END_ALLOW_THREADS + } + + return TRUE; +} + +/* Return a new reference to a Python Server or subclass corresponding + * to the DBusServer server. For use in callbacks. + * + * Raises AssertionError if the DBusServer does not have a Server. + */ +static PyObject * +DBusPyServer_ExistingFromDBusServer(DBusServer *server) +{ + PyObject *self, *ref; + + Py_BEGIN_ALLOW_THREADS + ref = (PyObject *)dbus_server_get_data(server, + _server_python_slot); + Py_END_ALLOW_THREADS + if (ref) { + DBG("(DBusServer *)%p has weak reference at %p", server, ref); + self = PyWeakref_GetObject(ref); /* still a borrowed ref */ + if (self && self != Py_None && DBusPyServer_Check(self)) { + DBG("(DBusServer *)%p has weak reference at %p pointing to %p", + server, ref, self); + TRACE(self); + Py_INCREF(self); + TRACE(self); + return self; + } + } + + PyErr_SetString(PyExc_AssertionError, + "D-Bus server does not have a Server " + "instance associated with it"); + return NULL; +} + +static void +DBusPyServer_new_connection_cb(DBusServer *server, + DBusConnection *conn, + void *data UNUSED) +{ + PyGILState_STATE gil = PyGILState_Ensure(); + PyObject *self = NULL; + PyObject *method = NULL; + + self = DBusPyServer_ExistingFromDBusServer(server); + if (!self) goto out; + TRACE(self); + + method = PyObject_GetAttrString(self, "_on_new_connection"); + TRACE(method); + + if (method) { + PyObject *conn_class = ((Server *)self)->conn_class; + PyObject *wrapper = DBusPyLibDBusConnection_New(conn); + PyObject *conn_obj; + PyObject *result; + + if (!wrapper) + goto out; + + conn_obj = PyObject_CallFunctionObjArgs((PyObject *)conn_class, + wrapper, ((Server*) self)->mainloop, NULL); + Py_DECREF(wrapper); + + if (!conn_obj) + goto out; + + result = PyObject_CallFunctionObjArgs(method, conn_obj, NULL); + Py_XDECREF (conn_obj); + + /* discard result if not NULL, and fall through regardless */ + Py_XDECREF(result); + } + +out: + Py_XDECREF(method); + Py_XDECREF(self); + + if (PyErr_Occurred()) + PyErr_Print(); + + PyGILState_Release(gil); +} + +/* Return a new reference to a Python Server or subclass (given by cls) + * corresponding to the DBusServer server, which must have been newly + * created. For use by the Server constructor. + * + * Raises AssertionError if the DBusServer already has a Server. + * + * One reference to server is stolen - either the returned DBusPyServer + * claims it, or it's unreffed. + */ +static PyObject * +DBusPyServer_NewConsumingDBusServer(PyTypeObject *cls, + DBusServer *server, + PyObject *conn_class, + PyObject *mainloop, + PyObject *auth_mechanisms) +{ + Server *self = NULL; + PyObject *ref; + dbus_bool_t ok; + + DBG("%s(cls=%p, server=%p, mainloop=%p, auth_mechanisms=%p)", + __func__, cls, server, mainloop, auth_mechanisms); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(server); + + Py_BEGIN_ALLOW_THREADS + ref = (PyObject *)dbus_server_get_data(server, + _server_python_slot); + Py_END_ALLOW_THREADS + if (ref) { + self = (Server *)PyWeakref_GetObject(ref); + ref = NULL; + if (self && (PyObject *)self != Py_None) { + self = NULL; + PyErr_SetString(PyExc_AssertionError, + "Newly created D-Bus server already has a " + "Server instance associated with it"); + DBG("%s() fail - assertion failed, DBusPyServer has a DBusServer already", __func__); + DBG_WHEREAMI; + return NULL; + } + } + ref = NULL; + + /* Change mainloop from a borrowed reference to an owned reference */ + if (!mainloop || mainloop == Py_None) { + mainloop = dbus_py_get_default_main_loop(); + + if (!mainloop || mainloop == Py_None) { + PyErr_SetString(PyExc_RuntimeError, + "To run a D-Bus server, you need to either " + "pass mainloop=... to the constructor or call " + "dbus.set_default_main_loop(...)"); + goto err; + } + } + else { + Py_INCREF(mainloop); + } + + DBG("Constructing Server from DBusServer at %p", server); + + self = (Server *)(cls->tp_alloc(cls, 0)); + if (!self) goto err; + TRACE(self); + + DBG_WHEREAMI; + + self->server = NULL; + + Py_INCREF(conn_class); + self->conn_class = conn_class; + + self->mainloop = mainloop; + mainloop = NULL; /* don't DECREF it - the DBusServer owns it now */ + + ref = PyWeakref_NewRef((PyObject *)self, NULL); + if (!ref) goto err; + DBG("Created weak ref %p to (Server *)%p for (DBusServer *)%p", + ref, self, server); + + Py_BEGIN_ALLOW_THREADS + ok = dbus_server_set_data(server, _server_python_slot, + (void *)ref, + (DBusFreeFunction)dbus_py_take_gil_and_xdecref); + Py_END_ALLOW_THREADS + + if (ok) { + DBG("Attached weak ref %p ((Server *)%p) to (DBusServer *)%p", + ref, self, server); + + ref = NULL; /* don't DECREF it - the DBusServer owns it now */ + } + else { + DBG("Failed to attached weak ref %p ((Server *)%p) to " + "(DBusServer *)%p - will dispose of it", ref, self, server); + PyErr_NoMemory(); + goto err; + } + + DBUS_PY_RAISE_VIA_GOTO_IF_FAIL(server, err); + self->server = server; + /* the DBusPyServer will close it now */ + server = NULL; + + if (self->mainloop != Py_None && + !dbus_py_set_up_server((PyObject *)self, self->mainloop)) + goto err; + + if (auth_mechanisms && auth_mechanisms != Py_None && + !DBusPyServer_set_auth_mechanisms(self, auth_mechanisms)) + goto err; + + Py_BEGIN_ALLOW_THREADS + dbus_server_set_new_connection_function(self->server, + DBusPyServer_new_connection_cb, + NULL, NULL); + Py_END_ALLOW_THREADS + + DBG("%s() -> %p", __func__, self); + TRACE(self); + return (PyObject *)self; + +err: + DBG("Failed to construct Server from DBusServer at %p", server); + Py_XDECREF(mainloop); + Py_XDECREF(self); + Py_XDECREF(ref); + + if (server) { + Py_BEGIN_ALLOW_THREADS + dbus_server_disconnect(server); + dbus_server_unref(server); + Py_END_ALLOW_THREADS + } + + DBG("%s() fail", __func__); + DBG_WHEREAMI; + return NULL; +} + +/* Server type-methods ============================================== */ + +static PyObject * +Server_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + DBusServer *server; + const char *address; + DBusError error; + PyObject *self, *conn_class, *mainloop = NULL, *auth_mechanisms = NULL; + static char *argnames[] = { "address", "connection_class", "mainloop", + "auth_mechanisms", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "sO|OO", argnames, + &address, &conn_class, &mainloop, &auth_mechanisms)) { + return NULL; + } + + if (!PyType_Check(conn_class) || + !PyType_IsSubtype((PyTypeObject *) conn_class, &DBusPyConnection_Type)) { + /* strictly speaking, it can be any subtype of + * _dbus_bindings._Connection - but nobody else should be subtyping + * that, so let's keep this slightly inaccurate message */ + PyErr_SetString(PyExc_TypeError, "connection_class must be " + "dbus.connection.Connection or a subtype"); + return NULL; + } + + dbus_error_init(&error); + + Py_BEGIN_ALLOW_THREADS + server = dbus_server_listen(address, &error); + Py_END_ALLOW_THREADS + + if (!server) { + DBusPyException_ConsumeError(&error); + return NULL; + } + + self = DBusPyServer_NewConsumingDBusServer(cls, server, conn_class, + mainloop, auth_mechanisms); + TRACE(self); + + return self; +} + +/* Destructor */ +static void Server_tp_dealloc(Server *self) +{ + DBusServer *server = self->server; + PyObject *et, *ev, *etb; + + /* avoid clobbering any pending exception */ + PyErr_Fetch(&et, &ev, &etb); + + if (self->weaklist) { + PyObject_ClearWeakRefs((PyObject *)self); + } + + TRACE(self); + DBG("Deallocating Server at %p (DBusServer at %p)", self, server); + DBG_WHEREAMI; + + if (server) { + DBG("Server at %p has a server, disconnecting it...", self); + Py_BEGIN_ALLOW_THREADS + dbus_server_disconnect(server); + Py_END_ALLOW_THREADS + } + + Py_DECREF(self->mainloop); + + /* make sure to do this last to preserve the invariant that + * self->server is always non-NULL for any referenced Server. + */ + DBG("Server at %p: nulling self->server", self); + self->server = NULL; + + if (server) { + DBG("Server at %p: unreffing server", self); + dbus_server_unref(server); + } + + DBG("Server at %p: freeing self", self); + PyErr_Restore(et, ev, etb); + (self->ob_type->tp_free)((PyObject *)self); +} + +PyDoc_STRVAR(Server_disconnect__doc__, +"disconnect()\n\n" +"Releases the server's address and stops listening for new clients.\n\n" +"If called more than once, only the first call has an effect."); +static PyObject * +Server_disconnect (Server *self, PyObject *args UNUSED) +{ + TRACE(self); + if (self->server) { + Py_BEGIN_ALLOW_THREADS + dbus_server_disconnect(self->server); + Py_END_ALLOW_THREADS + } + Py_RETURN_NONE; +} + +PyDoc_STRVAR(Server_get_address__doc__, +"get_address() -> str\n\n" +"Returns the address of the server."); +static PyObject * +Server_get_address(Server *self, PyObject *args UNUSED) +{ + const char *address; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->server); + Py_BEGIN_ALLOW_THREADS + address = dbus_server_get_address(self->server); + Py_END_ALLOW_THREADS + + return PyString_FromString(address); +} + +PyDoc_STRVAR(Server_get_id__doc__, +"get_id() -> str\n\n" +"Returns the unique ID of the server."); +static PyObject * +Server_get_id(Server *self, PyObject *args UNUSED) +{ + const char *id; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->server); + Py_BEGIN_ALLOW_THREADS + id = dbus_server_get_id(self->server); + Py_END_ALLOW_THREADS + + return PyString_FromString(id); +} + +PyDoc_STRVAR(Server_get_is_connected__doc__, +"get_is_connected() -> bool\n\n" +"Return true if this Server is still listening for new connections.\n"); +static PyObject * +Server_get_is_connected (Server *self, PyObject *args UNUSED) +{ + dbus_bool_t ret; + + TRACE(self); + DBUS_PY_RAISE_VIA_NULL_IF_FAIL(self->server); + Py_BEGIN_ALLOW_THREADS + ret = dbus_server_get_is_connected(self->server); + Py_END_ALLOW_THREADS + return PyBool_FromLong(ret); +} + +/* Server type object =============================================== */ + +struct PyMethodDef DBusPyServer_tp_methods[] = { +#define ENTRY(name, flags) {#name, (PyCFunction)Server_##name, flags, Server_##name##__doc__} + ENTRY(disconnect, METH_NOARGS), + ENTRY(get_address, METH_NOARGS), + ENTRY(get_id, METH_NOARGS), + ENTRY(get_is_connected, METH_NOARGS), + {NULL}, +#undef ENTRY +}; + +PyTypeObject DBusPyServer_Type = { + PyObject_HEAD_INIT(NULL) + 0, /*ob_size*/ + "_dbus_bindings._Server",/*tp_name*/ + sizeof(Server), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + /* methods */ + (destructor)Server_tp_dealloc, + 0, /*tp_print*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_compare*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_WEAKREFS | Py_TPFLAGS_BASETYPE, + Server_tp_doc, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + offsetof(Server, weaklist), /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + DBusPyServer_tp_methods,/*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + 0, /*tp_dictoffset*/ + 0, /*tp_init*/ + 0, /*tp_alloc*/ + Server_tp_new, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ +}; + +dbus_bool_t +dbus_py_init_server_types(void) +{ + /* Get a slot to store our weakref on DBus Server */ + _server_python_slot = -1; + if (!dbus_server_allocate_data_slot(&_server_python_slot)) + return FALSE; + + if (PyType_Ready(&DBusPyServer_Type) < 0) + return FALSE; + + return TRUE; +} + +dbus_bool_t +dbus_py_insert_server_types(PyObject *this_module) +{ + if (PyModule_AddObject(this_module, "_Server", + (PyObject *)&DBusPyServer_Type) < 0) return FALSE; + + return TRUE; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/signature.c b/_dbus_bindings/signature.c new file mode 100644 index 0000000..6b31ab4 --- /dev/null +++ b/_dbus_bindings/signature.c @@ -0,0 +1,247 @@ +/* Implementation of Signature type for D-Bus bindings. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include + +#include "dbus_bindings-internal.h" +#include "types-internal.h" + +PyDoc_STRVAR(Signature_tp_doc, +"A string subclass whose values are restricted to valid D-Bus\n" +"signatures. When iterated over, instead of individual characters it\n" +"produces Signature instances representing single complete types.\n" +"\n" +"Constructor::\n" +"\n" +" ``Signature(value: str or unicode[, variant_level: int]) -> Signature``\n" +"\n" +"``value`` must be a valid D-Bus signature (zero or more single complete\n" +"types).\n" +"\n" +"``variant_level`` must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a signature, this is represented in Python by a\n" +" Signature with variant_level==2.\n" +); + +typedef struct { + PyObject_HEAD + PyObject *string; + DBusSignatureIter iter; +} SignatureIter; + +static void +SignatureIter_tp_dealloc (SignatureIter *self) +{ + Py_XDECREF(self->string); + self->string = NULL; + PyObject_Del(self); +} + +static PyObject * +SignatureIter_tp_iternext (SignatureIter *self) +{ + char *sig; + PyObject *obj; + + /* Stop immediately if finished or not correctly initialized */ + if (!self->string) return NULL; + + sig = dbus_signature_iter_get_signature(&(self->iter)); + if (!sig) return PyErr_NoMemory(); + obj = PyObject_CallFunction((PyObject *)&DBusPySignature_Type, "s", sig); + dbus_free(sig); + if (!obj) return NULL; + + if (!dbus_signature_iter_next(&(self->iter))) { + /* mark object as having been finished with */ + Py_DECREF(self->string); + self->string = NULL; + } + + return obj; +} + +static PyObject * +SignatureIter_tp_iter(PyObject *self) +{ + Py_INCREF(self); + return self; +} + +static PyTypeObject SignatureIterType = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "_dbus_bindings._SignatureIter", + sizeof(SignatureIter), + 0, + (destructor)SignatureIter_tp_dealloc, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT, /* tp_flags */ + 0, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + SignatureIter_tp_iter, /* tp_iter */ + (iternextfunc)SignatureIter_tp_iternext, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + 0, /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + /* deliberately not callable! Use iter(Signature) instead */ + 0, /* tp_new */ + 0, /* tp_free */ +}; + +static PyObject * +Signature_tp_iter (PyObject *self) +{ + SignatureIter *iter = PyObject_New(SignatureIter, &SignatureIterType); + if (!iter) return NULL; + + if (PyString_AS_STRING (self)[0]) { + Py_INCREF(self); + iter->string = self; + dbus_signature_iter_init(&(iter->iter), PyString_AS_STRING(self)); + } + else { + /* this is a null string, make a null iterator */ + iter->string = NULL; + } + return (PyObject *)iter; +} + +static PyObject * +Signature_tp_new (PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + const char *str = NULL; + PyObject *ignored; + static char *argnames[] = {"object_path", "variant_level", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|O:__new__", argnames, + &str, &ignored)) return NULL; + if (!dbus_signature_validate(str, NULL)) { + PyErr_SetString(PyExc_ValueError, "Corrupt type signature"); + return NULL; + } + return (DBusPyStrBase_Type.tp_new)(cls, args, kwargs); +} + +PyTypeObject DBusPySignature_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.Signature", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + Signature_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + Signature_tp_iter, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPythonStringType), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + Signature_tp_new, /* tp_new */ + 0, /* tp_free */ +}; + +dbus_bool_t +dbus_py_init_signature(void) +{ + if (PyType_Ready(&SignatureIterType) < 0) return 0; + + DBusPySignature_Type.tp_base = &DBusPyStrBase_Type; + if (PyType_Ready(&DBusPySignature_Type) < 0) return 0; + DBusPySignature_Type.tp_print = NULL; + + return 1; +} + +dbus_bool_t +dbus_py_insert_signature(PyObject *this_module) +{ + Py_INCREF(&DBusPySignature_Type); + if (PyModule_AddObject(this_module, "Signature", + (PyObject *)&DBusPySignature_Type) < 0) return 0; + Py_INCREF(&SignatureIterType); + if (PyModule_AddObject(this_module, "_SignatureIter", + (PyObject *)&SignatureIterType) < 0) return 0; + + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/string.c b/_dbus_bindings/string.c new file mode 100644 index 0000000..19eab2c --- /dev/null +++ b/_dbus_bindings/string.c @@ -0,0 +1,380 @@ +/* Simple D-Bus types: ObjectPath and other string types. + * + * Copyright (C) 2006-2007 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "types-internal.h" +#include + +/* UTF-8 string representation ====================================== */ + +PyDoc_STRVAR(UTF8String_tp_doc, +"A string represented using UTF-8 - a subtype of `str`.\n" +"\n" +"All strings on D-Bus are required to be valid Unicode; in the \"wire\n" +"protocol\" they're transported as UTF-8.\n" +"\n" +"By default, when byte arrays are converted from D-Bus to Python, they\n" +"come out as a `dbus.String`, which is a subtype of `unicode`.\n" +"If you prefer to get UTF-8 strings (as instances of this class) or you\n" +"want to avoid the conversion overhead of going from UTF-8 to Python's\n" +"internal Unicode representation, you can pass the ``utf8_strings=True``\n" +"keyword argument to any of these methods:\n" +"\n" +"* any D-Bus method proxy, or ``connect_to_signal``, on the objects returned\n" +" by `Bus.get_object`\n" +"* any D-Bus method on a `dbus.Interface`\n" +"* `dbus.Interface.connect_to_signal`\n" +"* `Bus.add_signal_receiver`\n" +"\n" +"\n" +"Constructor::\n" +"\n" +" dbus.UTF8String(value: str or unicode[, variant_level: int]) -> UTF8String\n" +"\n" +"If value is a str object it must be valid UTF-8.\n" +"\n" +"variant_level must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a string, this is represented in Python by a\n" +" String or UTF8String with variant_level==2.\n" +":Since: 0.80 (in older versions, use dbus.String)\n" +); + +static PyObject * +UTF8String_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + const char *str = NULL; + long variantness = 0; + static char *argnames[] = {"value", "variant_level", NULL}; + PyObject *unicode; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|l:__new__", argnames, + &str, &variantness)) return NULL; + unicode = PyUnicode_DecodeUTF8(str, strlen(str), NULL); + if (!unicode) return NULL; + Py_DECREF(unicode); + return (DBusPyStrBase_Type.tp_new)(cls, args, kwargs); +} + +PyTypeObject DBusPyUTF8String_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.UTF8String", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + UTF8String_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyStrBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + UTF8String_tp_new, /* tp_new */ +}; + +/* Object path ====================================================== */ + +PyDoc_STRVAR(ObjectPath_tp_doc, +"A D-Bus object path, such as '/com/example/MyApp/Documents/abc'.\n" +"\n" +"ObjectPath is a subtype of str, and object-paths behave like strings.\n" +"\n" +"Constructor::\n" +"\n" +" dbus.ObjectPath(path: str, variant_level: int) -> ObjectPath\n" +"\n" +"path must be an ASCII string following the syntax of object paths.\n" +"variant_level must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing an object path, this is represented in Python by an\n" +" ObjectPath with variant_level==2.\n" +); + +static PyObject * +ObjectPath_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + const char *str = NULL; + long variantness = 0; + static char *argnames[] = {"object_path", "variant_level", NULL}; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|l:__new__", argnames, + &str, &variantness)) return NULL; + if (!dbus_py_validate_object_path(str)) { + return NULL; + } + return (DBusPyStrBase_Type.tp_new)(cls, args, kwargs); +} + +PyTypeObject DBusPyObjectPath_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.ObjectPath", + 0, + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + 0, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + 0, /* tp_getattro */ + 0, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + ObjectPath_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + 0, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&DBusPyStrBase_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + ObjectPath_tp_new, /* tp_new */ +}; + +/* Unicode string representation ==================================== */ + +PyDoc_STRVAR(String_tp_doc, +"A string represented using Unicode - a subtype of `unicode`.\n" +"\n" +"All strings on D-Bus are required to be valid Unicode; in the \"wire\n" +"protocol\" they're transported as UTF-8.\n" +"\n" +"By default, when strings are converted from D-Bus to Python, they\n" +"come out as this class. If you prefer to get UTF-8 strings (as instances\n" +"of a subtype of `str`) or you want to avoid the conversion overhead of\n" +"going from UTF-8 to Python's internal Unicode representation, see the\n" +"documentation for `dbus.UTF8String`.\n" +"\n" +"Constructor::\n" +"\n" +" String(value: str or unicode[, variant_level: int]) -> String\n" +"\n" +"variant_level must be non-negative; the default is 0.\n" +"\n" +":IVariables:\n" +" `variant_level` : int\n" +" Indicates how many nested Variant containers this object\n" +" is contained in: if a message's wire format has a variant containing a\n" +" variant containing a string, this is represented in Python by a\n" +" String or UTF8String with variant_level==2.\n" +); + +static PyMemberDef String_tp_members[] = { + {"variant_level", T_LONG, offsetof(DBusPyString, variant_level), + READONLY, + "The number of nested variants wrapping the real data. " + "0 if not in a variant"}, + {NULL}, +}; + +static PyObject * +String_tp_new(PyTypeObject *cls, PyObject *args, PyObject *kwargs) +{ + PyObject *self; + long variantness = 0; + static char *argnames[] = {"variant_level", NULL}; + + if (PyTuple_Size(args) > 1) { + PyErr_SetString(PyExc_TypeError, + "__new__ takes at most one positional parameter"); + return NULL; + } + if (!PyArg_ParseTupleAndKeywords(dbus_py_empty_tuple, kwargs, + "|l:__new__", argnames, + &variantness)) return NULL; + if (variantness < 0) { + PyErr_SetString(PyExc_ValueError, + "variant_level must be non-negative"); + return NULL; + } + self = (PyUnicode_Type.tp_new)(cls, args, NULL); + if (self) { + ((DBusPyString *)self)->variant_level = variantness; + } + return self; +} + +static PyObject * +String_tp_repr(PyObject *self) +{ + PyObject *parent_repr = (PyUnicode_Type.tp_repr)(self); + PyObject *my_repr; + + if (!parent_repr) { + return NULL; + } + if (((DBusPyString *)self)->variant_level > 0) { + my_repr = PyString_FromFormat("%s(%s, variant_level=%ld)", + self->ob_type->tp_name, + PyString_AS_STRING(parent_repr), + ((DBusPyString *)self)->variant_level); + } + else { + my_repr = PyString_FromFormat("%s(%s)", self->ob_type->tp_name, + PyString_AS_STRING(parent_repr)); + } + /* whether my_repr is NULL or not: */ + Py_DECREF(parent_repr); + return my_repr; +} + +PyTypeObject DBusPyString_Type = { + PyObject_HEAD_INIT(DEFERRED_ADDRESS(&PyType_Type)) + 0, + "dbus.String", + sizeof(DBusPyString), + 0, + 0, /* tp_dealloc */ + 0, /* tp_print */ + 0, /* tp_getattr */ + 0, /* tp_setattr */ + 0, /* tp_compare */ + String_tp_repr, /* tp_repr */ + 0, /* tp_as_number */ + 0, /* tp_as_sequence */ + 0, /* tp_as_mapping */ + 0, /* tp_hash */ + 0, /* tp_call */ + 0, /* tp_str */ + PyObject_GenericGetAttr, /* tp_getattro */ + dbus_py_immutable_setattro, /* tp_setattro */ + 0, /* tp_as_buffer */ + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */ + String_tp_doc, /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + 0, /* tp_iternext */ + 0, /* tp_methods */ + String_tp_members, /* tp_members */ + 0, /* tp_getset */ + DEFERRED_ADDRESS(&PyUnicode_Type), /* tp_base */ + 0, /* tp_dict */ + 0, /* tp_descr_get */ + 0, /* tp_descr_set */ + 0, /* tp_dictoffset */ + 0, /* tp_init */ + 0, /* tp_alloc */ + String_tp_new, /* tp_new */ +}; + +dbus_bool_t +dbus_py_init_string_types(void) +{ + /* don't need to do strange contortions for unicode, since it's not a + * "variable-size" object (it has a pointer to its data instead) + */ + if (PyUnicode_Type.tp_itemsize != 0) { + fprintf(stderr, "dbus-python is not compatible with this version of " + "Python (unicode objects are assumed to be fixed-size)"); + return 0; + } + DBusPyString_Type.tp_base = &PyUnicode_Type; + if (PyType_Ready(&DBusPyString_Type) < 0) return 0; + DBusPyString_Type.tp_print = NULL; + + DBusPyUTF8String_Type.tp_base = &DBusPyStrBase_Type; + if (PyType_Ready(&DBusPyUTF8String_Type) < 0) return 0; + DBusPyUTF8String_Type.tp_print = NULL; + + DBusPyObjectPath_Type.tp_base = &DBusPyStrBase_Type; + if (PyType_Ready(&DBusPyObjectPath_Type) < 0) return 0; + DBusPyObjectPath_Type.tp_print = NULL; + + DBusPyBoolean_Type.tp_base = &DBusPyIntBase_Type; + if (PyType_Ready(&DBusPyBoolean_Type) < 0) return 0; + DBusPyBoolean_Type.tp_print = NULL; + + return 1; +} + +dbus_bool_t +dbus_py_insert_string_types(PyObject *this_module) +{ + Py_INCREF(&DBusPyObjectPath_Type); + Py_INCREF(&DBusPyUTF8String_Type); + Py_INCREF(&DBusPyString_Type); + if (PyModule_AddObject(this_module, "ObjectPath", + (PyObject *)&DBusPyObjectPath_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "UTF8String", + (PyObject *)&DBusPyUTF8String_Type) < 0) return 0; + if (PyModule_AddObject(this_module, "String", + (PyObject *)&DBusPyString_Type) < 0) return 0; + + return 1; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ diff --git a/_dbus_bindings/types-internal.h b/_dbus_bindings/types-internal.h new file mode 100644 index 0000000..a5c8147 --- /dev/null +++ b/_dbus_bindings/types-internal.h @@ -0,0 +1,95 @@ +/* D-Bus types: implementation internals + * + * Copyright (C) 2006-2007 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include +#include + +#include "dbus_bindings-internal.h" + +#ifndef DBUS_BINDINGS_TYPES_INTERNAL_H +#define DBUS_BINDINGS_TYPES_INTERNAL_H + +extern PyTypeObject DBusPyIntBase_Type; +DEFINE_CHECK(DBusPyIntBase) + +typedef struct { + PyIntObject base; + long variant_level; +} DBusPyIntBase; + +extern PyTypeObject DBusPyLongBase_Type; +DEFINE_CHECK(DBusPyLongBase) + +extern PyTypeObject DBusPyFloatBase_Type; +DEFINE_CHECK(DBusPyFloatBase) + +typedef struct { + PyFloatObject base; + long variant_level; +} DBusPyFloatBase; + +typedef struct { + PyUnicodeObject unicode; + long variant_level; +} DBusPyString; + +extern PyTypeObject DBusPyStrBase_Type; +DEFINE_CHECK(DBusPyStrBase) + +dbus_int16_t dbus_py_int16_range_check(PyObject *); +dbus_uint16_t dbus_py_uint16_range_check(PyObject *); +dbus_int32_t dbus_py_int32_range_check(PyObject *); +dbus_uint32_t dbus_py_uint32_range_check(PyObject *); + +#if defined(DBUS_HAVE_INT64) && defined(HAVE_LONG_LONG) +# define DBUS_PYTHON_64_BIT_WORKS 1 +dbus_int64_t dbus_py_int64_range_check(PyObject *); +dbus_uint64_t dbus_py_uint64_range_check(PyObject *); +#else +# undef DBUS_PYTHON_64_BIT_WORKS +#endif /* defined(DBUS_HAVE_INT64) && defined(HAVE_LONG_LONG) */ + +extern PyObject *dbus_py_variant_level_const; +extern PyObject *dbus_py_signature_const; +extern PyObject *dbus_py__dbus_object_path__const; + +typedef struct { + PyListObject super; + PyObject *signature; + long variant_level; +} DBusPyArray; + +typedef struct { + PyDictObject super; + PyObject *signature; + long variant_level; +} DBusPyDict; + +PyObject *dbus_py_variant_level_getattro(PyObject *obj, PyObject *name); +dbus_bool_t dbus_py_variant_level_set(PyObject *obj, long variant_level); +void dbus_py_variant_level_clear(PyObject *obj); +long dbus_py_variant_level_get(PyObject *obj); + +#endif diff --git a/_dbus_bindings/validation.c b/_dbus_bindings/validation.c new file mode 100644 index 0000000..abec0a9 --- /dev/null +++ b/_dbus_bindings/validation.c @@ -0,0 +1,245 @@ +/* Implementation of various validation functions for use in dbus-python. + * + * Copyright (C) 2006 Collabora Ltd. + * + * Permission is hereby granted, free of charge, to any person + * obtaining a copy of this software and associated documentation + * files (the "Software"), to deal in the Software without + * restriction, including without limitation the rights to use, copy, + * modify, merge, publish, distribute, sublicense, and/or sell copies + * of the Software, and to permit persons to whom the Software is + * furnished to do so, subject to the following conditions: + * + * The above copyright notice and this permission notice shall be + * included in all copies or substantial portions of the Software. + * + * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT + * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, + * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, + * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER + * DEALINGS IN THE SOFTWARE. + */ + +#include "dbus_bindings-internal.h" + +dbus_bool_t +dbus_py_validate_bus_name(const char *name, + dbus_bool_t may_be_unique, + dbus_bool_t may_be_not_unique) +{ + dbus_bool_t dot = FALSE; + dbus_bool_t unique; + char last; + const char *ptr; + + if (name[0] == '\0') { + PyErr_SetString(PyExc_ValueError, "Invalid bus name: " + "may not be empty"); + return FALSE; + } + unique = (name[0] == ':'); + if (unique && !may_be_unique) { + PyErr_Format(PyExc_ValueError, "Invalid well-known bus name '%s':" + "only unique names may start with ':'", name); + return FALSE; + } + if (!unique && !may_be_not_unique) { + PyErr_Format(PyExc_ValueError, "Invalid unique bus name '%s': " + "unique names must start with ':'", name); + return FALSE; + } + if (strlen(name) > 255) { + PyErr_Format(PyExc_ValueError, "Invalid bus name '%s': " + "too long (> 255 characters)", name); + return FALSE; + } + last = '\0'; + for (ptr = name + (unique ? 1 : 0); *ptr; ptr++) { + if (*ptr == '.') { + dot = TRUE; + if (last == '.') { + PyErr_Format(PyExc_ValueError, "Invalid bus name '%s': " + "contains substring '..'", name); + return FALSE; + } + else if (last == '\0') { + PyErr_Format(PyExc_ValueError, "Invalid bus name '%s': " + "must not start with '.'", name); + return FALSE; + } + } + else if (*ptr >= '0' && *ptr <= '9') { + if (!unique) { + if (last == '.') { + PyErr_Format(PyExc_ValueError, "Invalid bus name '%s': " + "a digit may not follow '.' except in a " + "unique name starting with ':'", name); + return FALSE; + } + else if (last == '\0') { + PyErr_Format(PyExc_ValueError, "Invalid bus name '%s': " + "must not start with a digit", name); + return FALSE; + } + } + } + else if ((*ptr < 'a' || *ptr > 'z') && + (*ptr < 'A' || *ptr > 'Z') && *ptr != '_' && *ptr != '-') { + PyErr_Format(PyExc_ValueError, "Invalid bus name '%s': " + "contains invalid character '%c'", name, *ptr); + return FALSE; + } + last = *ptr; + } + if (last == '.') { + PyErr_Format(PyExc_ValueError, "Invalid bus name '%s': must " + "not end with '.'", name); + return FALSE; + } + if (!dot) { + PyErr_Format(PyExc_ValueError, "Invalid bus name '%s': must " + "contain '.'", name); + return FALSE; + } + return TRUE; +} + +dbus_bool_t +dbus_py_validate_member_name(const char *name) +{ + const char *ptr; + + if (name[0] == '\0') { + PyErr_SetString(PyExc_ValueError, "Invalid member name: may not " + "be empty"); + return FALSE; + } + if (strlen(name) > 255) { + PyErr_Format(PyExc_ValueError, "Invalid member name '%s': " + "too long (> 255 characters)", name); + return FALSE; + } + for (ptr = name; *ptr; ptr++) { + if (*ptr >= '0' && *ptr <= '9') { + if (ptr == name) { + PyErr_Format(PyExc_ValueError, "Invalid member name '%s': " + "must not start with a digit", name); + return FALSE; + } + } + else if ((*ptr < 'a' || *ptr > 'z') && + (*ptr < 'A' || *ptr > 'Z') && *ptr != '_') { + PyErr_Format(PyExc_ValueError, "Invalid member name '%s': " + "contains invalid character '%c'", name, *ptr); + return FALSE; + } + } + return TRUE; +} + +dbus_bool_t +dbus_py_validate_interface_name(const char *name) +{ + dbus_bool_t dot = FALSE; + char last; + const char *ptr; + + if (name[0] == '\0') { + PyErr_SetString(PyExc_ValueError, "Invalid interface or error name: " + "may not be empty"); + return FALSE; + } + if (strlen(name) > 255) { + PyErr_Format(PyExc_ValueError, "Invalid interface or error name '%s': " + "too long (> 255 characters)", name); + return FALSE; + } + last = '\0'; + for (ptr = name; *ptr; ptr++) { + if (*ptr == '.') { + dot = TRUE; + if (last == '.') { + PyErr_Format(PyExc_ValueError, "Invalid interface or " + "error name '%s': contains substring '..'", name); + return FALSE; + } + else if (last == '\0') { + PyErr_Format(PyExc_ValueError, "Invalid interface or error " + "name '%s': must not start with '.'", name); + return FALSE; + } + } + else if (*ptr >= '0' && *ptr <= '9') { + if (last == '.') { + PyErr_Format(PyExc_ValueError, "Invalid interface or error " + "name '%s': a digit may not follow '.'", name); + return FALSE; + } + else if (last == '\0') { + PyErr_Format(PyExc_ValueError, "Invalid interface or error " + "name '%s': must not start with a digit", name); + return FALSE; + } + } + else if ((*ptr < 'a' || *ptr > 'z') && + (*ptr < 'A' || *ptr > 'Z') && *ptr != '_') { + PyErr_Format(PyExc_ValueError, "Invalid interface or error " + "name '%s': contains invalid character '%c'", + name, *ptr); + return FALSE; + } + last = *ptr; + } + if (last == '.') { + PyErr_Format(PyExc_ValueError, "Invalid interface or error name " + "'%s': must not end with '.'", name); + return FALSE; + } + if (!dot) { + PyErr_Format(PyExc_ValueError, "Invalid interface or error name " + "'%s': must contain '.'", name); + return FALSE; + } + return TRUE; +} + + +dbus_bool_t +dbus_py_validate_object_path(const char *path) +{ + const char *ptr; + + if (path[0] != '/') { + PyErr_Format(PyExc_ValueError, "Invalid object path '%s': does not " + "start with '/'", path); + return FALSE; + } + if (path[1] == '\0') return TRUE; + for (ptr = path + 1; *ptr; ptr++) { + if (*ptr == '/') { + if (ptr[-1] == '/') { + PyErr_Format(PyExc_ValueError, "Invalid object path '%s': " + "contains substring '//'", path); + return FALSE; + } + } + else if ((*ptr < 'a' || *ptr > 'z') && + (*ptr < 'A' || *ptr > 'Z') && + (*ptr < '0' || *ptr > '9') && *ptr != '_') { + PyErr_Format(PyExc_ValueError, "Invalid object path '%s': " + "contains invalid character '%c'", path, *ptr); + return FALSE; + } + } + if (ptr[-1] == '/') { + PyErr_Format(PyExc_ValueError, "Invalid object path '%s': ends " + "with '/' and is not just '/'", path); + return FALSE; + } + return TRUE; +} + +/* vim:set ft=c cino< sw=4 sts=4 et: */ -- cgit v1.2.3