From: Dan Winship Date: Sat, 9 Feb 2008 23:33:22 +0000 (+0000) Subject: First draft of libsoup python bindings. Not complete, not final, X-Git-Tag: LIBSOUP_2_3_2~3 X-Git-Url: http://review.tizen.org/git/?a=commitdiff_plain;h=973896b37277298bdd441675b827108e594db52f;p=platform%2Fupstream%2Flibsoup.git First draft of libsoup python bindings. Not complete, not final, etc. (And not built by default and not installed.) svn path=/trunk/; revision=1082 --- diff --git a/python/AUTHORS b/python/AUTHORS new file mode 100644 index 0000000..e69de29 diff --git a/python/ChangeLog b/python/ChangeLog new file mode 100644 index 0000000..6df670b --- /dev/null +++ b/python/ChangeLog @@ -0,0 +1,4 @@ +2008-02-09 Dan Winship + + First draft of libsoup python bindings. Not complete, not final, + etc. (And not built by default and not installed.) diff --git a/python/Makefile.am b/python/Makefile.am new file mode 100644 index 0000000..22bc3f9 --- /dev/null +++ b/python/Makefile.am @@ -0,0 +1,24 @@ +AUTOMAKE_OPTIONS=1.5 + +INCLUDES = \ + $(PYTHON_INCLUDES) \ + $(PYGOBJECT_CFLAGS) \ + $(SOUP_CFLAGS) + +noinst_LTLIBRARIES = soup.la +soup_la_LDFLAGS = -module -avoid-version -export-symbols-regex initsoup +soup_la_LIBADD = $(SOUP_LIBS) +soup_la_SOURCES = libsoupmodule.c +nodist_soup_la_SOURCES = libsoup.c +libsoup.c: libsoup.defs *.override +CLEANFILES = libsoup.c +EXTRA_DIST = *.override + +.defs.c: + (cd $(srcdir)\ + && pygtk-codegen-2.0 \ + --register $(GIO_DEFS) \ + --override $*.override \ + --prefix py$* $*.defs) > gen-$*.c \ + && cp gen-$*.c $*.c \ + && rm -f gen-$*.c diff --git a/python/NEWS b/python/NEWS new file mode 100644 index 0000000..e69de29 diff --git a/python/README b/python/README new file mode 100644 index 0000000..433bd10 --- /dev/null +++ b/python/README @@ -0,0 +1,6 @@ +Incomplete, unfinished, not heavily tested, etc, etc, etc + +If you want to use these, you'll have to copy the sources into your +project and build them locally. + +Eventually they will be installed along with libsoup... diff --git a/python/SoupLogger.override b/python/SoupLogger.override new file mode 100644 index 0000000..31a426c --- /dev/null +++ b/python/SoupLogger.override @@ -0,0 +1,140 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * SoupLogger.override: overrides for SoupLogger + */ +%% +override soup_logger_set_request_filter kwargs + +static SoupLoggerLogLevel +pysoup_logger_filter (SoupLogger *logger, SoupMessage *msg, gpointer user_data) +{ + PySoupCallback *psc = user_data; + PyGILState_STATE state; + PyObject *py_msg, *py_ret; + SoupLoggerLogLevel ret = SOUP_LOGGER_LOG_NONE; + + state = pyg_gil_state_ensure (); + + py_msg = pygobject_new ((GObject *)msg); + if (psc->data) + py_ret = PyEval_CallFunction (psc->func, "(NO)", py_msg, psc->data); + else + py_ret = PyEval_CallFunction (psc->func, "(N)", py_msg); + + if (py_ret != NULL) { + if (pyg_enum_get_value (SOUP_TYPE_LOGGER_LOG_LEVEL, + py_ret, (gpointer)&ret) != 0) + PyErr_Print (); + Py_DECREF (py_ret); + } else + PyErr_Print (); + + pyg_gil_state_release (state); + return ret; +} + +static PyObject * +_wrap_soup_logger_set_request_filter (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "request_filter", "filter_data", NULL }; + PyObject *pyfunc, *pyarg = NULL; + PySoupCallback *psc; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "O|O:SoupLogger.set_request_filter", + kwlist, &pyfunc, &pyarg)) + return NULL; + if (!PyCallable_Check (pyfunc)) { + PyErr_SetString (PyExc_TypeError, "request_filter must be a callable object"); + return NULL; + } + + psc = pysoup_callback_new (pyfunc, pyarg); + soup_logger_set_request_filter (SOUP_LOGGER (self->obj), + pysoup_logger_filter, psc, + pysoup_callback_destroy_notify); + + Py_INCREF (Py_None); + return Py_None; +} +%% +override soup_logger_set_response_filter kwargs +static PyObject * +_wrap_soup_logger_set_response_filter (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "response_filter", "filter_data", NULL }; + PyObject *pyfunc, *pyarg = NULL; + PySoupCallback *psc; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "O|O:SoupLogger.set_response_filter", + kwlist, &pyfunc, &pyarg)) + return NULL; + if (!PyCallable_Check (pyfunc)) { + PyErr_SetString (PyExc_TypeError, "response_filter must be a callable object"); + return NULL; + } + + psc = pysoup_callback_new (pyfunc, pyarg); + soup_logger_set_response_filter (SOUP_LOGGER (self->obj), + pysoup_logger_filter, psc, + pysoup_callback_destroy_notify); + + Py_INCREF (Py_None); + return Py_None; +} +%% +override soup_logger_set_printer kwargs + +static void +pysoup_printer (SoupLogger *logger, SoupLoggerLogLevel level, + char direction, const char *data, gpointer user_data) +{ + PySoupCallback *psc = user_data; + PyGILState_STATE state; + PyObject *py_level, *py_ret; + + state = pyg_gil_state_ensure (); + + py_level = pyg_enum_from_gtype (SOUP_TYPE_LOGGER_LOG_LEVEL, level); + + if (psc->data) { + py_ret = PyEval_CallFunction (psc->func, "(NcsO)", py_level, + direction, data, psc->data); + } else { + py_ret = PyEval_CallFunction (psc->func, "(Ncs)", py_level, + direction, data); + } + + if (py_ret != NULL) + Py_DECREF (py_ret); + else + PyErr_Print (); + + pyg_gil_state_release (state); +} + +static PyObject * +_wrap_soup_logger_set_printer (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "printer", "filter_data", NULL }; + PyObject *pyfunc, *pyarg = NULL; + PySoupCallback *psc; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "O|O:SoupLogger.set_printer", + kwlist, &pyfunc, &pyarg)) + return NULL; + if (!PyCallable_Check (pyfunc)) { + PyErr_SetString (PyExc_TypeError, "printer must be a callable object"); + return NULL; + } + + psc = pysoup_callback_new (pyfunc, pyarg); + soup_logger_set_printer (SOUP_LOGGER (self->obj), + pysoup_printer, psc, + pysoup_callback_destroy_notify); + + Py_INCREF (Py_None); + return Py_None; +} diff --git a/python/SoupMessageBody.override b/python/SoupMessageBody.override new file mode 100644 index 0000000..837ec12 --- /dev/null +++ b/python/SoupMessageBody.override @@ -0,0 +1,60 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * SoupMessageBody.override: overrides for SoupMessageBody + */ +%% +override soup_message_body_append kwargs +static PyObject * +_wrap_soup_message_body_append (PyObject *self, + PyObject *args, + PyObject *kwargs) +{ + static char *kwlist[] = { "data", "length", NULL }; + char *data; + int length, caller_length = 0; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "s#|i:SoupMessageBody.append", + kwlist, &data, &length, &caller_length)) + return NULL; + + if (caller_length) + length = caller_length; + + /* FIXME: Add a way to create a SoupBuffer that refs data's PyObject */ + soup_message_body_append (pyg_boxed_get(self, SoupMessageBody), + SOUP_MEMORY_COPY, data, length); + + Py_INCREF(Py_None); + return Py_None; +} +%% +override soup_message_body_get_chunk kwargs +static PyObject * +_wrap_soup_message_body_get_chunk (PyObject *self, + PyObject *args, + PyObject *kwargs) +{ + static char *kwlist[] = { "offset", NULL }; + long long offset; + SoupBuffer *chunk; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "L:SoupMessageBody.get_chunk", + kwlist, &offset)) + return NULL; + + chunk = soup_message_body_get_chunk (pyg_boxed_get(self, SoupMessageBody), + offset); + return pyg_boxed_new(SOUP_TYPE_BUFFER, chunk, TRUE, TRUE); +} +%% +override-attr SoupMessageBody.length +static PyObject * +_wrap_soup_message_body__get_length(PyObject *self, void *closure) +{ + goffset length; + + length = pyg_boxed_get(self, SoupMessageBody)->length; + return PyLong_FromLongLong(length); +} diff --git a/python/SoupMessageHeaders.override b/python/SoupMessageHeaders.override new file mode 100644 index 0000000..3f43297 --- /dev/null +++ b/python/SoupMessageHeaders.override @@ -0,0 +1,156 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * SoupMessageHeaders.override: overrides for SoupMessageHeaders + */ +%% +ignore + soup_message_headers_foreach +%% +override-slot SoupMessageHeaders.tp_as_mapping +static PyObject * +_wrap_soup_message_headers_tp_getitem (PyGObject *self, PyObject *item) +{ + char *name; + const char *value; + + if (!PyString_Check (item)) { + PyErr_SetString (PyExc_TypeError, + "could not parse subscript as a header name"); + return NULL; + } + + name = PyString_AsString (item); + value = soup_message_headers_get ((SoupMessageHeaders *)self->obj, name); + return Py_BuildValue ("s", value); + +} +static int +_wrap_soup_message_headers_tp_setitem (PyGObject *self, PyObject *item, + PyObject *value) +{ + char *name, *string_value; + + if (!PyString_Check (item)) { + PyErr_SetString (PyExc_TypeError, + "could not parse subscript as a header name"); + return -1; + } + name = PyString_AsString (item); + + if (!PyString_Check (value)) { + PyErr_SetString (PyExc_TypeError, + "could not parse value as a string"); + return -1; + } + string_value = PyString_AsString (value); + + soup_message_headers_replace ((SoupMessageHeaders *)self->obj, name, + string_value); + return 0; +} + +static PyMappingMethods _wrap_soup_message_headers_tp_as_mapping = { + (lenfunc) NULL, + (binaryfunc)_wrap_soup_message_headers_tp_getitem, + (objobjargproc)_wrap_soup_message_headers_tp_setitem +}; +%% +override-slot SoupMessageHeaders.tp_iter + +typedef struct { + PyObject_HEAD + + SoupMessageHeadersIter iter; +} PySoupMessageHeadersIter; + +static void +pysoup_message_headers_iter_dealloc (PySoupMessageHeadersIter *iter) +{ + soup_message_headers_iter_free (&iter->iter); + PyObject_Del ((PyObject*) iter); +} + +static PyObject * +pysoup_message_headers_iter_next (PySoupMessageHeadersIter *iter) +{ + const char *name, *value; + + if (!soup_message_headers_iter_next (&iter->iter, &name, &value)) { + PyErr_SetNone (PyExc_StopIteration); + return NULL; + } + + return Py_BuildValue ("(ss)", name, value); +} + +static PyTypeObject PySoupMessageHeadersIter_Type = { + PyObject_HEAD_INIT(NULL) + 0, /* ob_size */ + "soup.SoupMessageHeadersIter", /* tp_name */ + sizeof (PySoupMessageHeadersIter), /* tp_basicsize */ + 0, /* tp_itemsize */ + (destructor)pysoup_message_headers_iter_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 */ + "SoupMessageHeaders iterator", /* tp_doc */ + 0, /* tp_traverse */ + 0, /* tp_clear */ + 0, /* tp_richcompare */ + 0, /* tp_weaklistoffset */ + 0, /* tp_iter */ + (iternextfunc)pysoup_message_headers_iter_next, /* tp_iternext */ +}; + +static PyObject * +_wrap_soup_message_headers_tp_iter (PyGObject *self) +{ + PySoupMessageHeadersIter *iter; + + iter = PyObject_NEW (PySoupMessageHeadersIter, + &PySoupMessageHeadersIter_Type); + soup_message_headers_iter_init (&iter->iter, + (SoupMessageHeaders *)self->obj); + return (PyObject *) iter; +} +%% +override soup_message_headers_get_content_length +static PyObject * +_wrap_soup_message_headers_get_content_length (PyObject *self) +{ + goffset content_length; + + content_length = soup_message_headers_get_content_length (pyg_boxed_get (self, SoupMessageHeaders)); + + return PyLong_FromLongLong (content_length); +} +%% +override soup_message_headers_set_content_length +static PyObject * +_wrap_soup_message_headers_set_content_length (PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "content_length", NULL }; + long long content_length; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, + "L:SoupMessageHeaders.set_content_length", + kwlist, &content_length)) + return NULL; + + soup_message_headers_set_content_length (pyg_boxed_get (self, SoupMessageHeaders), content_length); + + Py_INCREF(Py_None); + return Py_None; +} diff --git a/python/SoupURI.override b/python/SoupURI.override new file mode 100644 index 0000000..bb996b4 --- /dev/null +++ b/python/SoupURI.override @@ -0,0 +1,153 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * SoupURI.override: overrides for SoupURI + */ +%% +ignore-glob + soup_uri_set_* +%% +override-slot SoupURI.tp_str +static PyObject * +_wrap_soup_uri_tp_str (PyObject *self) +{ + char *str; + PyObject *ret; + + str = soup_uri_to_string (pyg_boxed_get (self, SoupURI), FALSE); + ret = PyString_FromString (str); + g_free (str); + + return ret; +} +%% +override-slot SoupURI.tp_repr +static PyObject * +_wrap_soup_uri_tp_repr (PyObject *self) +{ + SoupURI *uri = pyg_boxed_get (self, SoupURI); + char *str, *repr; + PyObject *ret; + + str = soup_uri_to_string (uri, FALSE); + repr = g_strdup_printf ("", str, uri); + ret = PyString_FromString (repr); + g_free (repr); + g_free (str); + + return ret; +} +%% +override-attr SoupURI.scheme +static int +_wrap_soup_uri__set_scheme (PyObject *self, PyObject *value, void *closure) +{ + char *scheme = PyString_AsString (value); + + if (!scheme) + return -1; + soup_uri_set_scheme (pyg_boxed_get (self, SoupURI), scheme); + + return 0; +} +%% +override-attr SoupURI.user +static int +_wrap_soup_uri__set_user (PyObject *self, PyObject *value, void *closure) +{ + char *user = PyString_AsString (value); + + if (!user) + return -1; + soup_uri_set_user (pyg_boxed_get (self, SoupURI), user); + + return 0; +} +%% +override-attr SoupURI.password +static int +_wrap_soup_uri__set_password (PyObject *self, PyObject *value, void *closure) +{ + char *password = PyString_AsString (value); + + if (!password) + return -1; + soup_uri_set_password (pyg_boxed_get (self, SoupURI), password); + + return 0; +} +%% +override-attr SoupURI.host +static int +_wrap_soup_uri__set_host (PyObject *self, PyObject *value, void *closure) +{ + char *host = PyString_AsString (value); + + if (!host) + return -1; + soup_uri_set_host (pyg_boxed_get (self, SoupURI), host); + + return 0; +} +%% +override-attr SoupURI.port +static int +_wrap_soup_uri__set_port (PyObject *self, PyObject *value, void *closure) +{ + int port = PyInt_AsLong (value); + + if (PyErr_Occurred()) + return -1; + soup_uri_set_port (pyg_boxed_get (self, SoupURI), port); + + return 0; +} +%% +override-attr SoupURI.path +static int +_wrap_soup_uri__set_path (PyObject *self, PyObject *value, void *closure) +{ + char *path = PyString_AsString (value); + + if (!path) + return -1; + soup_uri_set_path (pyg_boxed_get (self, SoupURI), path); + + return 0; +} +%% +override-attr SoupURI.query +static int +_wrap_soup_uri__set_query (PyObject *self, PyObject *value, void *closure) +{ + if (PyString_Check (value)) { + char *string_query = PyString_AsString (value); + + soup_uri_set_query (pyg_boxed_get (self, SoupURI), string_query); + } else if (PyDict_Check (value)) { + GHashTable *dict_query = pysoup_pydict_to_ghashtable (value); + + if (!dict_query) + return -1; + + soup_uri_set_query_from_form (pyg_boxed_get (self, SoupURI), dict_query); + g_hash_table_destroy (dict_query); + } else { + PyErr_SetString (PyExc_TypeError, "query value must be a string or a dict"); + return -1; + } + + return 0; +} +%% +override-attr SoupURI.fragment +static int +_wrap_soup_uri__set_fragment (PyObject *self, PyObject *value, void *closure) +{ + char *fragment = PyString_AsString (value); + + if (!fragment) + return -1; + soup_uri_set_fragment (pyg_boxed_get (self, SoupURI), fragment); + + return 0; +} diff --git a/python/acinclude.m4 b/python/acinclude.m4 new file mode 100644 index 0000000..fe90156 --- /dev/null +++ b/python/acinclude.m4 @@ -0,0 +1,66 @@ +## this one is commonly used with AM_PATH_PYTHONDIR ... +dnl AM_CHECK_PYMOD(MODNAME [,SYMBOL [,ACTION-IF-FOUND [,ACTION-IF-NOT-FOUND]]]) +dnl Check if a module containing a given symbol is visible to python. +AC_DEFUN([AM_CHECK_PYMOD], +[AC_REQUIRE([AM_PATH_PYTHON]) +py_mod_var=`echo $1['_']$2 | sed 'y%./+-%__p_%'` +AC_MSG_CHECKING(for ifelse([$2],[],,[$2 in ])python module $1) +AC_CACHE_VAL(py_cv_mod_$py_mod_var, [ +ifelse([$2],[], [prog=" +import sys +try: + import $1 +except ImportError: + sys.exit(1) +except: + sys.exit(0) +sys.exit(0)"], [prog=" +import $1 +$1.$2"]) +if $PYTHON -c "$prog" 1>&AC_FD_CC 2>&AC_FD_CC + then + eval "py_cv_mod_$py_mod_var=yes" + else + eval "py_cv_mod_$py_mod_var=no" + fi +]) +py_val=`eval "echo \`echo '$py_cv_mod_'$py_mod_var\`"` +if test "x$py_val" != xno; then + AC_MSG_RESULT(yes) + ifelse([$3], [],, [$3 +])dnl +else + AC_MSG_RESULT(no) + ifelse([$4], [],, [$4 +])dnl +fi +]) + +dnl a macro to check for ability to create python extensions +dnl AM_CHECK_PYTHON_HEADERS([ACTION-IF-POSSIBLE], [ACTION-IF-NOT-POSSIBLE]) +dnl function also defines PYTHON_INCLUDES +AC_DEFUN([AM_CHECK_PYTHON_HEADERS], +[AC_REQUIRE([AM_PATH_PYTHON]) +AC_MSG_CHECKING(for headers required to compile python extensions) +dnl deduce PYTHON_INCLUDES +py_prefix=`$PYTHON -c "import sys; print sys.prefix"` +py_exec_prefix=`$PYTHON -c "import sys; print sys.exec_prefix"` +if test -x "$PYTHON-config"; then +PYTHON_INCLUDES=`$PYTHON-config --includes 2>/dev/null` +else +PYTHON_INCLUDES="-I${py_prefix}/include/python${PYTHON_VERSION}" +if test "$py_prefix" != "$py_exec_prefix"; then + PYTHON_INCLUDES="$PYTHON_INCLUDES -I${py_exec_prefix}/include/python${PYTHON_VERSION}" +fi +fi +AC_SUBST(PYTHON_INCLUDES) +dnl check if the headers exist: +save_CPPFLAGS="$CPPFLAGS" +CPPFLAGS="$CPPFLAGS $PYTHON_INCLUDES" +AC_TRY_CPP([#include ],dnl +[AC_MSG_RESULT(found) +$1],dnl +[AC_MSG_RESULT(not found) +$2]) +CPPFLAGS="$save_CPPFLAGS" +]) diff --git a/python/configure.in b/python/configure.in new file mode 100644 index 0000000..14fd092 --- /dev/null +++ b/python/configure.in @@ -0,0 +1,51 @@ +AC_PREREQ(2.53) +AC_INIT(libsoup-python, 0.0) +AC_CONFIG_SRCDIR(libsoup.defs) +AM_INIT_AUTOMAKE(AC_PACKAGE_NAME, AC_PACKAGE_VERSION) + +AM_MAINTAINER_MODE +AC_PROG_MAKE_SET + +AC_PROG_CC +AM_PROG_CC_STDC +AC_HEADER_STDC + +AM_PROG_LIBTOOL + +AC_ARG_ENABLE(more-warnings, + [ --disable-more-warnings Inhibit compiler warnings], + set_more_warnings=no) + +if test "$GCC" = "yes" -a "$set_more_warnings" != "no"; then + CFLAGS="$CFLAGS \ + -Wall -Wstrict-prototypes -Wmissing-declarations \ + -Wmissing-prototypes -Wnested-externs -Wpointer-arith" +fi + +dnl ****** +dnl Python +dnl ****** + +AM_PATH_PYTHON() +AM_CHECK_PYTHON_HEADERS(,AC_MSG_ERROR([install python-devel])) +PKG_CHECK_MODULES(PYGOBJECT, pygobject-2.0 >= 2.15.0) +gio_defsdir=`$PKG_CONFIG --variable=defsdir pygobject-2.0` +if test "$gio_defsdir" = ""; then + # kludge until we can depend on pygobject 2.15.1 + gio_defsdir=`$PKG_CONFIG --variable=fixxref pygobject-2.0 | sed -e 's|xsl/fixxref.py|2.0/defs|'` +fi +GIO_DEFS="$gio_defsdir/gio.defs" +AC_SUBST(GIO_DEFS) + +dnl ******* +dnl libsoup +dnl ******* + +if test -f ../libsoup/libsoup-2.4.la; then + SOUP_CFLAGS=-I.. + SOUP_LIBS=../libsoup/libsoup-2.4.la +else + PKG_CHECK_MODULES(SOUP, libsoup-2.4) +fi + +AC_OUTPUT([Makefile]) diff --git a/python/libsoup-ignore.defs b/python/libsoup-ignore.defs new file mode 100644 index 0000000..cecc618 --- /dev/null +++ b/python/libsoup-ignore.defs @@ -0,0 +1,5 @@ +(define-boxed Array + (in-module "GByte") + (c-name "GByteArray") + (gtype-id "G_TYPE_BYTE_ARRAY") +) diff --git a/python/libsoup.defs b/python/libsoup.defs new file mode 100644 index 0000000..0320ba4 --- /dev/null +++ b/python/libsoup.defs @@ -0,0 +1,2532 @@ +;; -*- scheme -*- +; boxed definitions ... + +(define-boxed Buffer + (in-module "Soup") + (c-name "SoupBuffer") + (gtype-id "SOUP_TYPE_BUFFER") + (fields + '("const-char*" "data") + '("gsize" "length") + ) +) + +(define-boxed ClientContext + (in-module "Soup") + (c-name "SoupClientContext") + (gtype-id "SOUP_TYPE_CLIENT_CONTEXT") +) + +(define-boxed Date + (in-module "Soup") + (c-name "SoupDate") + (gtype-id "SOUP_TYPE_DATE") + (fields + '("int" "year") + '("int" "month") + '("int" "day") + '("int" "hour") + '("int" "minute") + '("int" "second") + '("gboolean" "utc") + '("int" "offset") + ) +) + +(define-boxed MessageBody + (in-module "Soup") + (c-name "SoupMessageBody") + (gtype-id "SOUP_TYPE_MESSAGE_BODY") + (fields + '("const-char*" "data") + '("goffset" "length") + ) +) + +(define-boxed MessageHeaders + (in-module "Soup") + (c-name "SoupMessageHeaders") + (gtype-id "SOUP_TYPE_MESSAGE_HEADERS") +) + +(define-boxed URI + (in-module "Soup") + (c-name "SoupURI") + (gtype-id "SOUP_TYPE_URI") + (fields + '("const-char*" "scheme") + '("char*" "user") + '("char*" "password") + '("char*" "host") + '("int" "port") + '("char*" "path") + '("char*" "query") + '("char*" "fragment") + ) +) + +; interface definitions ... + +; object definitions ... + +(define-object Address + (in-module "Soup") + (parent "GObject") + (c-name "SoupAddress") + (gtype-id "SOUP_TYPE_ADDRESS") +) + +(define-object Auth + (in-module "Soup") + (parent "GObject") + (c-name "SoupAuth") + (gtype-id "SOUP_TYPE_AUTH") +) + +(define-object AuthDomain + (in-module "Soup") + (parent "GObject") + (c-name "SoupAuthDomain") + (gtype-id "SOUP_TYPE_AUTH_DOMAIN") +) + +(define-object AuthDomainBasic + (in-module "Soup") + (parent "SoupAuthDomain") + (c-name "SoupAuthDomainBasic") + (gtype-id "SOUP_TYPE_AUTH_DOMAIN_BASIC") +) + +(define-object AuthDomainDigest + (in-module "Soup") + (parent "SoupAuthDomain") + (c-name "SoupAuthDomainDigest") + (gtype-id "SOUP_TYPE_AUTH_DOMAIN_DIGEST") +) + +(define-object Logger + (in-module "Soup") + (parent "GObject") + (c-name "SoupLogger") + (gtype-id "SOUP_TYPE_LOGGER") +) + +(define-object Message + (in-module "Soup") + (parent "GObject") + (c-name "SoupMessage") + (gtype-id "SOUP_TYPE_MESSAGE") + (fields + '("const-char*" "method") + '("int" "status_code") + '("const-char*" "reason_phrase") + '("SoupMessageBody*" "request_body") + '("SoupMessageHeaders*" "request_headers") + '("SoupMessageBody*" "response_body") + '("SoupMessageHeaders*" "response_headers") + ) +) + +(define-object Server + (in-module "Soup") + (parent "GObject") + (c-name "SoupServer") + (gtype-id "SOUP_TYPE_SERVER") +) + +(define-object Session + (in-module "Soup") + (parent "GObject") + (c-name "SoupSession") + (gtype-id "SOUP_TYPE_SESSION") +) + +(define-object SessionAsync + (in-module "Soup") + (parent "SoupSession") + (c-name "SoupSessionAsync") + (gtype-id "SOUP_TYPE_SESSION_ASYNC") +) + +(define-object SessionSync + (in-module "Soup") + (parent "SoupSession") + (c-name "SoupSessionSync") + (gtype-id "SOUP_TYPE_SESSION_SYNC") +) + +(define-object Socket + (in-module "Soup") + (parent "GObject") + (c-name "SoupSocket") + (gtype-id "SOUP_TYPE_SOCKET") +) + +; pointer definitions ... + +;; Enumerations and Flags ... + +(define-enum AddressFamily + (in-module "Soup") + (c-name "SoupAddressFamily") + (gtype-id "SOUP_TYPE_ADDRESS_FAMILY") + (values + '("invalid" "SOUP_ADDRESS_FAMILY_INVALID") + '("ipv4" "SOUP_ADDRESS_FAMILY_IPV4") + '("ipv6" "SOUP_ADDRESS_FAMILY_IPV6") + ) +) + +(define-enum DateFormat + (in-module "Soup") + (c-name "SoupDateFormat") + (gtype-id "SOUP_TYPE_DATE_FORMAT") + (values + '("http" "SOUP_DATE_HTTP") + '("cookie" "SOUP_DATE_COOKIE") + '("rfc2822" "SOUP_DATE_RFC2822") + '("iso8601-compact" "SOUP_DATE_ISO8601_COMPACT") + '("iso8601-full" "SOUP_DATE_ISO8601_FULL") + '("iso8601" "SOUP_DATE_ISO8601") + '("iso8601-xmlrpc" "SOUP_DATE_ISO8601_XMLRPC") + ) +) + +(define-enum Encoding + (in-module "Soup") + (c-name "SoupEncoding") + (gtype-id "SOUP_TYPE_ENCODING") + (values + '("unrecognized" "SOUP_ENCODING_UNRECOGNIZED") + '("none" "SOUP_ENCODING_NONE") + '("content-length" "SOUP_ENCODING_CONTENT_LENGTH") + '("eof" "SOUP_ENCODING_EOF") + '("chunked" "SOUP_ENCODING_CHUNKED") + '("byteranges" "SOUP_ENCODING_BYTERANGES") + ) +) + +(define-enum HTTPVersion + (in-module "Soup") + (c-name "SoupHTTPVersion") + (gtype-id "SOUP_TYPE_HTTP_VERSION") + (values + '("0" "SOUP_HTTP_1_0") + '("1" "SOUP_HTTP_1_1") + ) +) + +(define-enum KnownStatusCode + (in-module "Soup") + (c-name "SoupKnownStatusCode") + (gtype-id "SOUP_TYPE_KNOWN_STATUS_CODE") + (values + '("none" "SOUP_STATUS_NONE") + '("cancelled" "SOUP_STATUS_CANCELLED") + '("cant-resolve" "SOUP_STATUS_CANT_RESOLVE") + '("cant-resolve-proxy" "SOUP_STATUS_CANT_RESOLVE_PROXY") + '("cant-connect" "SOUP_STATUS_CANT_CONNECT") + '("cant-connect-proxy" "SOUP_STATUS_CANT_CONNECT_PROXY") + '("ssl-failed" "SOUP_STATUS_SSL_FAILED") + '("io-error" "SOUP_STATUS_IO_ERROR") + '("malformed" "SOUP_STATUS_MALFORMED") + '("try-again" "SOUP_STATUS_TRY_AGAIN") + '("continue" "SOUP_STATUS_CONTINUE") + '("switching-protocols" "SOUP_STATUS_SWITCHING_PROTOCOLS") + '("processing" "SOUP_STATUS_PROCESSING") + '("ok" "SOUP_STATUS_OK") + '("created" "SOUP_STATUS_CREATED") + '("accepted" "SOUP_STATUS_ACCEPTED") + '("non-authoritative" "SOUP_STATUS_NON_AUTHORITATIVE") + '("no-content" "SOUP_STATUS_NO_CONTENT") + '("reset-content" "SOUP_STATUS_RESET_CONTENT") + '("partial-content" "SOUP_STATUS_PARTIAL_CONTENT") + '("multi-status" "SOUP_STATUS_MULTI_STATUS") + '("multiple-choices" "SOUP_STATUS_MULTIPLE_CHOICES") + '("moved-permanently" "SOUP_STATUS_MOVED_PERMANENTLY") + '("found" "SOUP_STATUS_FOUND") + '("moved-temporarily" "SOUP_STATUS_MOVED_TEMPORARILY") + '("see-other" "SOUP_STATUS_SEE_OTHER") + '("not-modified" "SOUP_STATUS_NOT_MODIFIED") + '("use-proxy" "SOUP_STATUS_USE_PROXY") + '("not-appearing-in-this-protocol" "SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL") + '("temporary-redirect" "SOUP_STATUS_TEMPORARY_REDIRECT") + '("bad-request" "SOUP_STATUS_BAD_REQUEST") + '("unauthorized" "SOUP_STATUS_UNAUTHORIZED") + '("payment-required" "SOUP_STATUS_PAYMENT_REQUIRED") + '("forbidden" "SOUP_STATUS_FORBIDDEN") + '("not-found" "SOUP_STATUS_NOT_FOUND") + '("method-not-allowed" "SOUP_STATUS_METHOD_NOT_ALLOWED") + '("not-acceptable" "SOUP_STATUS_NOT_ACCEPTABLE") + '("proxy-authentication-required" "SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED") + '("proxy-unauthorized" "SOUP_STATUS_PROXY_UNAUTHORIZED") + '("request-timeout" "SOUP_STATUS_REQUEST_TIMEOUT") + '("conflict" "SOUP_STATUS_CONFLICT") + '("gone" "SOUP_STATUS_GONE") + '("length-required" "SOUP_STATUS_LENGTH_REQUIRED") + '("precondition-failed" "SOUP_STATUS_PRECONDITION_FAILED") + '("request-entity-too-large" "SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE") + '("request-uri-too-long" "SOUP_STATUS_REQUEST_URI_TOO_LONG") + '("unsupported-media-type" "SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE") + '("requested-range-not-satisfiable" "SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE") + '("invalid-range" "SOUP_STATUS_INVALID_RANGE") + '("expectation-failed" "SOUP_STATUS_EXPECTATION_FAILED") + '("unprocessable-entity" "SOUP_STATUS_UNPROCESSABLE_ENTITY") + '("locked" "SOUP_STATUS_LOCKED") + '("failed-dependency" "SOUP_STATUS_FAILED_DEPENDENCY") + '("internal-server-error" "SOUP_STATUS_INTERNAL_SERVER_ERROR") + '("not-implemented" "SOUP_STATUS_NOT_IMPLEMENTED") + '("bad-gateway" "SOUP_STATUS_BAD_GATEWAY") + '("service-unavailable" "SOUP_STATUS_SERVICE_UNAVAILABLE") + '("gateway-timeout" "SOUP_STATUS_GATEWAY_TIMEOUT") + '("http-version-not-supported" "SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED") + '("insufficient-storage" "SOUP_STATUS_INSUFFICIENT_STORAGE") + '("not-extended" "SOUP_STATUS_NOT_EXTENDED") + ) +) + +(define-enum LoggerLogLevel + (in-module "Soup") + (c-name "SoupLoggerLogLevel") + (gtype-id "SOUP_TYPE_LOGGER_LOG_LEVEL") + (values + '("none" "SOUP_LOGGER_LOG_NONE") + '("minimal" "SOUP_LOGGER_LOG_MINIMAL") + '("headers" "SOUP_LOGGER_LOG_HEADERS") + '("body" "SOUP_LOGGER_LOG_BODY") + ) +) + +(define-enum MemoryUse + (in-module "Soup") + (c-name "SoupMemoryUse") + (gtype-id "SOUP_TYPE_MEMORY_USE") + (values + '("static" "SOUP_MEMORY_STATIC") + '("take" "SOUP_MEMORY_TAKE") + '("copy" "SOUP_MEMORY_COPY") + '("temporary" "SOUP_MEMORY_TEMPORARY") + ) +) + +(define-enum MessageHeadersType + (in-module "Soup") + (c-name "SoupMessageHeadersType") + (gtype-id "SOUP_TYPE_MESSAGE_HEADERS_TYPE") + (values + '("request" "SOUP_MESSAGE_HEADERS_REQUEST") + '("response" "SOUP_MESSAGE_HEADERS_RESPONSE") + ) +) + +(define-enum SSLError + (in-module "Soup") + (c-name "SoupSSLError") + (gtype-id "SOUP_TYPE_SSL_ERROR") + (values + '("handshake-needs-read" "SOUP_SSL_ERROR_HANDSHAKE_NEEDS_READ") + '("handshake-needs-write" "SOUP_SSL_ERROR_HANDSHAKE_NEEDS_WRITE") + '("certificate" "SOUP_SSL_ERROR_CERTIFICATE") + ) +) + +(define-enum SocketIOStatus + (in-module "Soup") + (c-name "SoupSocketIOStatus") + (gtype-id "SOUP_TYPE_SOCKET_IO_STATUS") + (values + '("ok" "SOUP_SOCKET_OK") + '("would-block" "SOUP_SOCKET_WOULD_BLOCK") + '("eof" "SOUP_SOCKET_EOF") + '("error" "SOUP_SOCKET_ERROR") + ) +) + +(define-enum XMLRPCError + (in-module "Soup") + (c-name "SoupXMLRPCError") + (gtype-id "SOUP_TYPE_XMLRPC_ERROR") + (values + '("arguments" "SOUP_XMLRPC_ERROR_ARGUMENTS") + '("retval" "SOUP_XMLRPC_ERROR_RETVAL") + ) +) + +(define-enum XMLRPCFault + (in-module "Soup") + (c-name "SoupXMLRPCFault") + (gtype-id "SOUP_TYPE_XMLRPC_FAULT") + (values + '("parse-error-not-well-formed" "SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED") + '("parse-error-unsupported-encoding" "SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING") + '("parse-error-invalid-character-for-encoding" "SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING") + '("server-error-invalid-xml-rpc" "SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC") + '("server-error-requested-method-not-found" "SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND") + '("server-error-invalid-method-parameters" "SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS") + '("server-error-internal-xml-rpc-error" "SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR") + '("application-error" "SOUP_XMLRPC_FAULT_APPLICATION_ERROR") + '("system-error" "SOUP_XMLRPC_FAULT_SYSTEM_ERROR") + '("transport-error" "SOUP_XMLRPC_FAULT_TRANSPORT_ERROR") + ) +) + +(define-flags Expectation + (in-module "Soup") + (c-name "SoupExpectation") + (gtype-id "SOUP_TYPE_EXPECTATION") + (values + '("unrecognized" "SOUP_EXPECTATION_UNRECOGNIZED") + '("continue" "SOUP_EXPECTATION_CONTINUE") + ) +) + +(define-flags MessageFlags + (in-module "Soup") + (c-name "SoupMessageFlags") + (gtype-id "SOUP_TYPE_MESSAGE_FLAGS") + (values + '("no-redirect" "SOUP_MESSAGE_NO_REDIRECT") + '("overwrite-chunks" "SOUP_MESSAGE_OVERWRITE_CHUNKS") + ) +) + + +;; From soup-address.h + +(define-function address_get_type + (c-name "soup_address_get_type") + (return-type "GType") +) + +(define-function address_new + (c-name "soup_address_new") + (is-constructor-of "SoupAddress") + (return-type "SoupAddress*") + (parameters + '("const-char*" "name") + '("guint" "port") + ) +) + +(define-function address_new_from_sockaddr + (c-name "soup_address_new_from_sockaddr") + (return-type "SoupAddress*") + (parameters + '("struct-sockaddr*" "sa") + '("int" "len") + ) +) + +(define-function address_new_any + (c-name "soup_address_new_any") + (return-type "SoupAddress*") + (parameters + '("SoupAddressFamily" "family") + '("guint" "port") + ) +) + +(define-method resolve_async + (of-object "SoupAddress") + (c-name "soup_address_resolve_async") + (return-type "none") + (parameters + '("GMainContext*" "async_context") + '("GCancellable*" "cancellable") + '("SoupAddressCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method resolve_sync + (of-object "SoupAddress") + (c-name "soup_address_resolve_sync") + (return-type "int") + (parameters + '("GCancellable*" "cancellable") + ) +) + +(define-method get_name + (of-object "SoupAddress") + (c-name "soup_address_get_name") + (return-type "const-char*") +) + +(define-method get_physical + (of-object "SoupAddress") + (c-name "soup_address_get_physical") + (return-type "const-char*") +) + +(define-method get_port + (of-object "SoupAddress") + (c-name "soup_address_get_port") + (return-type "int") +) + + + +;; From soup-auth-domain-basic.h + +(define-function auth_domain_basic_get_type + (c-name "soup_auth_domain_basic_get_type") + (return-type "GType") +) + +(define-function auth_domain_basic_new + (c-name "soup_auth_domain_basic_new") + (is-constructor-of "SoupAuthDomainBasic") + (return-type "SoupAuthDomain*") + (parameters + '("const-char*" "optname1") + ) + (varargs #t) +) + +(define-method basic_set_auth_callback + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_basic_set_auth_callback") + (return-type "none") + (parameters + '("SoupAuthDomainBasicAuthCallback" "callback") + '("gpointer" "user_data") + '("GDestroyNotify" "dnotify") + ) +) + + + +;; From soup-auth-domain-digest.h + +(define-function auth_domain_digest_get_type + (c-name "soup_auth_domain_digest_get_type") + (return-type "GType") +) + +(define-function auth_domain_digest_new + (c-name "soup_auth_domain_digest_new") + (is-constructor-of "SoupAuthDomainDigest") + (return-type "SoupAuthDomain*") + (parameters + '("const-char*" "optname1") + ) + (varargs #t) +) + +(define-method digest_set_auth_callback + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_digest_set_auth_callback") + (return-type "none") + (parameters + '("SoupAuthDomainDigestAuthCallback" "callback") + '("gpointer" "user_data") + '("GDestroyNotify" "dnotify") + ) +) + +(define-function auth_domain_digest_encode_password + (c-name "soup_auth_domain_digest_encode_password") + (return-type "char*") + (parameters + '("const-char*" "username") + '("const-char*" "realm") + '("const-char*" "password") + ) +) + + + +;; From soup-auth-domain.h + +(define-function auth_domain_get_type + (c-name "soup_auth_domain_get_type") + (return-type "GType") +) + +(define-method add_path + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_add_path") + (return-type "none") + (parameters + '("const-char*" "path") + ) +) + +(define-method remove_path + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_remove_path") + (return-type "none") + (parameters + '("const-char*" "path") + ) +) + +(define-method set_filter + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_set_filter") + (return-type "none") + (parameters + '("SoupAuthDomainFilter" "filter") + '("gpointer" "filter_data") + '("GDestroyNotify" "dnotify") + ) +) + +(define-method get_realm + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_get_realm") + (return-type "const-char*") +) + +(define-method set_generic_auth_callback + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_set_generic_auth_callback") + (return-type "none") + (parameters + '("SoupAuthDomainGenericAuthCallback" "auth_callback") + '("gpointer" "auth_data") + '("GDestroyNotify" "dnotify") + ) +) + +(define-method check_password + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_check_password") + (return-type "gboolean") + (parameters + '("SoupMessage*" "msg") + '("const-char*" "username") + '("const-char*" "password") + ) +) + +(define-method covers + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_covers") + (return-type "gboolean") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method accepts + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_accepts") + (return-type "char*") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method challenge + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_challenge") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method try_generic_auth_callback + (of-object "SoupAuthDomain") + (c-name "soup_auth_domain_try_generic_auth_callback") + (return-type "gboolean") + (parameters + '("SoupMessage*" "msg") + '("const-char*" "username") + ) +) + + + +;; From soup-auth.h + +(define-function auth_get_type + (c-name "soup_auth_get_type") + (return-type "GType") +) + +(define-function auth_new + (c-name "soup_auth_new") + (is-constructor-of "SoupAuth") + (return-type "SoupAuth*") + (parameters + '("GType" "type") + '("SoupMessage*" "msg") + '("const-char*" "auth_header") + ) +) + +(define-method update + (of-object "SoupAuth") + (c-name "soup_auth_update") + (return-type "gboolean") + (parameters + '("SoupMessage*" "msg") + '("const-char*" "auth_header") + ) +) + +(define-method is_for_proxy + (of-object "SoupAuth") + (c-name "soup_auth_is_for_proxy") + (return-type "gboolean") +) + +(define-method get_scheme_name + (of-object "SoupAuth") + (c-name "soup_auth_get_scheme_name") + (return-type "const-char*") +) + +(define-method get_host + (of-object "SoupAuth") + (c-name "soup_auth_get_host") + (return-type "const-char*") +) + +(define-method get_realm + (of-object "SoupAuth") + (c-name "soup_auth_get_realm") + (return-type "const-char*") +) + +(define-method get_info + (of-object "SoupAuth") + (c-name "soup_auth_get_info") + (return-type "char*") +) + +(define-method authenticate + (of-object "SoupAuth") + (c-name "soup_auth_authenticate") + (return-type "none") + (parameters + '("const-char*" "username") + '("const-char*" "password") + ) +) + +(define-method is_authenticated + (of-object "SoupAuth") + (c-name "soup_auth_is_authenticated") + (return-type "gboolean") +) + +(define-method get_authorization + (of-object "SoupAuth") + (c-name "soup_auth_get_authorization") + (return-type "char*") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method get_protection_space + (of-object "SoupAuth") + (c-name "soup_auth_get_protection_space") + (return-type "GSList*") + (parameters + '("SoupURI*" "source_uri") + ) +) + +(define-method free_protection_space + (of-object "SoupAuth") + (c-name "soup_auth_free_protection_space") + (return-type "none") + (parameters + '("GSList*" "space") + ) +) + + + +;; From soup-date.h + +(define-function date_get_type + (c-name "soup_date_get_type") + (return-type "GType") +) + +(define-function date_new + (c-name "soup_date_new") + (is-constructor-of "SoupDate") + (return-type "SoupDate*") + (parameters + '("int" "year") + '("int" "month") + '("int" "day") + '("int" "hour") + '("int" "minute") + '("int" "second") + ) +) + +(define-function date_new_from_string + (c-name "soup_date_new_from_string") + (return-type "SoupDate*") + (parameters + '("const-char*" "date_string") + ) +) + +(define-function date_new_from_time_t + (c-name "soup_date_new_from_time_t") + (return-type "SoupDate*") + (parameters + '("time_t" "when") + ) +) + +(define-function date_new_from_now + (c-name "soup_date_new_from_now") + (return-type "SoupDate*") + (parameters + '("int" "offset_seconds") + ) +) + +(define-method to_string + (of-object "SoupDate") + (c-name "soup_date_to_string") + (return-type "char*") + (parameters + '("SoupDateFormat" "format") + ) +) + +(define-method to_time_t + (of-object "SoupDate") + (c-name "soup_date_to_time_t") + (return-type "time_t") +) + +(define-method copy + (of-object "SoupDate") + (c-name "soup_date_copy") + (return-type "SoupDate*") +) + +(define-method free + (of-object "SoupDate") + (c-name "soup_date_free") + (return-type "none") +) + + + +;; From soup-enum-types.h + +(define-function address_family_get_type + (c-name "soup_address_family_get_type") + (return-type "GType") +) + +(define-function date_format_get_type + (c-name "soup_date_format_get_type") + (return-type "GType") +) + +(define-function logger_log_level_get_type + (c-name "soup_logger_log_level_get_type") + (return-type "GType") +) + +(define-function http_version_get_type + (c-name "soup_http_version_get_type") + (return-type "GType") +) + +(define-function message_flags_get_type + (c-name "soup_message_flags_get_type") + (return-type "GType") +) + +(define-function memory_use_get_type + (c-name "soup_memory_use_get_type") + (return-type "GType") +) + +(define-function message_headers_type_get_type + (c-name "soup_message_headers_type_get_type") + (return-type "GType") +) + +(define-function encoding_get_type + (c-name "soup_encoding_get_type") + (return-type "GType") +) + +(define-function expectation_get_type + (c-name "soup_expectation_get_type") + (return-type "GType") +) + +(define-function ssl_error_get_type + (c-name "soup_ssl_error_get_type") + (return-type "GType") +) + +(define-function socket_io_status_get_type + (c-name "soup_socket_io_status_get_type") + (return-type "GType") +) + +(define-function known_status_code_get_type + (c-name "soup_known_status_code_get_type") + (return-type "GType") +) + +(define-function xmlrpc_error_get_type + (c-name "soup_xmlrpc_error_get_type") + (return-type "GType") +) + +(define-function xmlrpc_fault_get_type + (c-name "soup_xmlrpc_fault_get_type") + (return-type "GType") +) + + + +;; From soup-form.h + +(define-function form_decode + (c-name "soup_form_decode") + (return-type "GHashTable*") + (parameters + '("const-char*" "encoded_form") + ) +) + +(define-function form_encode + (c-name "soup_form_encode") + (return-type "char*") + (parameters + '("const-char*" "first_field") + ) + (varargs #t) +) + +(define-function form_encode_hash + (c-name "soup_form_encode_hash") + (return-type "char*") + (parameters + '("GHashTable*" "form_data_set") + ) +) + +(define-function form_encode_datalist + (c-name "soup_form_encode_datalist") + (return-type "char*") + (parameters + '("GData**" "form_data_set") + ) +) + +(define-function form_encode_valist + (c-name "soup_form_encode_valist") + (return-type "char*") + (parameters + '("const-char*" "first_field") + '("va_list" "args") + ) +) + +(define-function form_request_new + (c-name "soup_form_request_new") + (return-type "SoupMessage*") + (parameters + '("const-char*" "method") + '("const-char*" "uri") + '("const-char*" "first_field") + ) + (varargs #t) +) + +(define-function form_request_new_from_hash + (c-name "soup_form_request_new_from_hash") + (return-type "SoupMessage*") + (parameters + '("const-char*" "method") + '("const-char*" "uri") + '("GHashTable*" "form_data_set") + ) +) + +(define-function form_request_new_from_datalist + (c-name "soup_form_request_new_from_datalist") + (return-type "SoupMessage*") + (parameters + '("const-char*" "method") + '("const-char*" "uri") + '("GData**" "form_data_set") + ) +) + + + +;; From soup-headers.h + +(define-function headers_parse_request + (c-name "soup_headers_parse_request") + (return-type "int") + (parameters + '("const-char*" "str") + '("int" "len") + '("SoupMessageHeaders*" "req_headers") + '("char**" "req_method") + '("char**" "req_path") + '("SoupHTTPVersion*" "ver") + ) +) + +(define-function headers_parse_status_line + (c-name "soup_headers_parse_status_line") + (return-type "gboolean") + (parameters + '("const-char*" "status_line") + '("SoupHTTPVersion*" "ver") + '("guint*" "status_code") + '("char**" "reason_phrase") + ) +) + +(define-function headers_parse_response + (c-name "soup_headers_parse_response") + (return-type "gboolean") + (parameters + '("const-char*" "str") + '("int" "len") + '("SoupMessageHeaders*" "headers") + '("SoupHTTPVersion*" "ver") + '("guint*" "status_code") + '("char**" "reason_phrase") + ) +) + +(define-function header_parse_list + (c-name "soup_header_parse_list") + (return-type "GSList*") + (parameters + '("const-char*" "header") + ) +) + +(define-function header_parse_quality_list + (c-name "soup_header_parse_quality_list") + (return-type "GSList*") + (parameters + '("const-char*" "header") + '("GSList**" "unacceptable") + ) +) + +(define-function header_free_list + (c-name "soup_header_free_list") + (return-type "none") + (parameters + '("GSList*" "list") + ) +) + +(define-function header_contains + (c-name "soup_header_contains") + (return-type "gboolean") + (parameters + '("const-char*" "header") + '("const-char*" "token") + ) +) + +(define-function header_parse_param_list + (c-name "soup_header_parse_param_list") + (return-type "GHashTable*") + (parameters + '("const-char*" "header") + ) +) + +(define-function header_free_param_list + (c-name "soup_header_free_param_list") + (return-type "none") + (parameters + '("GHashTable*" "param_list") + ) +) + + + +;; From soup-logger.h + +(define-function logger_get_type + (c-name "soup_logger_get_type") + (return-type "GType") +) + +(define-function logger_new + (c-name "soup_logger_new") + (is-constructor-of "SoupLogger") + (return-type "SoupLogger*") + (parameters + '("SoupLoggerLogLevel" "level") + '("int" "max_body_size") + ) +) + +(define-method attach + (of-object "SoupLogger") + (c-name "soup_logger_attach") + (return-type "none") + (parameters + '("SoupSession*" "session") + ) +) + +(define-method detach + (of-object "SoupLogger") + (c-name "soup_logger_detach") + (return-type "none") + (parameters + '("SoupSession*" "session") + ) +) + +(define-method set_request_filter + (of-object "SoupLogger") + (c-name "soup_logger_set_request_filter") + (return-type "none") + (parameters + '("SoupLoggerFilter" "request_filter") + '("gpointer" "filter_data") + '("GDestroyNotify" "destroy") + ) +) + +(define-method set_response_filter + (of-object "SoupLogger") + (c-name "soup_logger_set_response_filter") + (return-type "none") + (parameters + '("SoupLoggerFilter" "response_filter") + '("gpointer" "filter_data") + '("GDestroyNotify" "destroy") + ) +) + +(define-method set_printer + (of-object "SoupLogger") + (c-name "soup_logger_set_printer") + (return-type "none") + (parameters + '("SoupLoggerPrinter" "printer") + '("gpointer" "printer_data") + '("GDestroyNotify" "destroy") + ) +) + + + +;; From soup-message-body.h + +(define-function buffer_get_type + (c-name "soup_buffer_get_type") + (return-type "GType") +) + +(define-function buffer_new + (c-name "soup_buffer_new") + (is-constructor-of "SoupBuffer") + (return-type "SoupBuffer*") + (parameters + '("SoupMemoryUse" "use") + '("gconstpointer" "data") + '("gsize" "length") + ) +) + +(define-method new_subbuffer + (of-object "SoupBuffer") + (c-name "soup_buffer_new_subbuffer") + (return-type "SoupBuffer*") + (parameters + '("gsize" "offset") + '("gsize" "length") + ) +) + +(define-method copy + (of-object "SoupBuffer") + (c-name "soup_buffer_copy") + (return-type "SoupBuffer*") +) + +(define-method free + (of-object "SoupBuffer") + (c-name "soup_buffer_free") + (return-type "none") +) + +(define-function message_body_get_type + (c-name "soup_message_body_get_type") + (return-type "GType") +) + +(define-function message_body_new + (c-name "soup_message_body_new") + (is-constructor-of "SoupMessageBody") + (return-type "SoupMessageBody*") +) + +(define-method append + (of-object "SoupMessageBody") + (c-name "soup_message_body_append") + (return-type "none") + (parameters + '("SoupMemoryUse" "use") + '("gconstpointer" "data") + '("gsize" "length") + ) +) + +(define-method append_buffer + (of-object "SoupMessageBody") + (c-name "soup_message_body_append_buffer") + (return-type "none") + (parameters + '("SoupBuffer*" "buffer") + ) +) + +(define-method truncate + (of-object "SoupMessageBody") + (c-name "soup_message_body_truncate") + (return-type "none") +) + +(define-method complete + (of-object "SoupMessageBody") + (c-name "soup_message_body_complete") + (return-type "none") +) + +(define-method flatten + (of-object "SoupMessageBody") + (c-name "soup_message_body_flatten") + (return-type "SoupBuffer*") +) + +(define-method get_chunk + (of-object "SoupMessageBody") + (c-name "soup_message_body_get_chunk") + (return-type "SoupBuffer*") + (parameters + '("goffset" "offset") + ) +) + +(define-method free + (of-object "SoupMessageBody") + (c-name "soup_message_body_free") + (return-type "none") +) + + + +;; From soup-message-headers.h + +(define-function message_headers_get_type + (c-name "soup_message_headers_get_type") + (return-type "GType") +) + +(define-function message_headers_new + (c-name "soup_message_headers_new") + (is-constructor-of "SoupMessageHeaders") + (return-type "SoupMessageHeaders*") + (parameters + '("SoupMessageHeadersType" "type") + ) +) + +(define-method free + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_free") + (return-type "none") +) + +(define-method append + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_append") + (return-type "none") + (parameters + '("const-char*" "name") + '("const-char*" "value") + ) +) + +(define-method replace + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_replace") + (return-type "none") + (parameters + '("const-char*" "name") + '("const-char*" "value") + ) +) + +(define-method remove + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_remove") + (return-type "none") + (parameters + '("const-char*" "name") + ) +) + +(define-method clear + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_clear") + (return-type "none") +) + +(define-method get + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_get") + (return-type "const-char*") + (parameters + '("const-char*" "name") + ) +) + +(define-method foreach + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_foreach") + (return-type "none") + (parameters + '("SoupMessageHeadersForeachFunc" "func") + '("gpointer" "user_data") + ) +) + +(define-method get_encoding + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_get_encoding") + (return-type "SoupEncoding") +) + +(define-method set_encoding + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_set_encoding") + (return-type "none") + (parameters + '("SoupEncoding" "encoding") + ) +) + +(define-method get_content_length + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_get_content_length") + (return-type "goffset") +) + +(define-method set_content_length + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_set_content_length") + (return-type "none") + (parameters + '("goffset" "content_length") + ) +) + +(define-method get_expectations + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_get_expectations") + (return-type "SoupExpectation") +) + +(define-method set_expectations + (of-object "SoupMessageHeaders") + (c-name "soup_message_headers_set_expectations") + (return-type "none") + (parameters + '("SoupExpectation" "expectations") + ) +) + + + +;; From soup-message.h + +(define-function message_get_type + (c-name "soup_message_get_type") + (return-type "GType") +) + +(define-function message_new + (c-name "soup_message_new") + (is-constructor-of "SoupMessage") + (return-type "SoupMessage*") + (parameters + '("const-char*" "method") + '("const-char*" "uri_string") + ) +) + +(define-function message_new_from_uri + (c-name "soup_message_new_from_uri") + (return-type "SoupMessage*") + (parameters + '("const-char*" "method") + '("SoupURI*" "uri") + ) +) + +(define-method set_request + (of-object "SoupMessage") + (c-name "soup_message_set_request") + (return-type "none") + (parameters + '("const-char*" "content_type") + '("SoupMemoryUse" "req_use") + '("const-char*" "req_body") + '("gsize" "req_length") + ) +) + +(define-method set_response + (of-object "SoupMessage") + (c-name "soup_message_set_response") + (return-type "none") + (parameters + '("const-char*" "content_type") + '("SoupMemoryUse" "resp_use") + '("const-char*" "resp_body") + '("gsize" "resp_length") + ) +) + +(define-method set_http_version + (of-object "SoupMessage") + (c-name "soup_message_set_http_version") + (return-type "none") + (parameters + '("SoupHTTPVersion" "version") + ) +) + +(define-method get_http_version + (of-object "SoupMessage") + (c-name "soup_message_get_http_version") + (return-type "SoupHTTPVersion") +) + +(define-method is_keepalive + (of-object "SoupMessage") + (c-name "soup_message_is_keepalive") + (return-type "gboolean") +) + +(define-method get_uri + (of-object "SoupMessage") + (c-name "soup_message_get_uri") + (return-type "SoupURI*") +) + +(define-method set_uri + (of-object "SoupMessage") + (c-name "soup_message_set_uri") + (return-type "none") + (parameters + '("SoupURI*" "uri") + ) +) + +(define-method set_flags + (of-object "SoupMessage") + (c-name "soup_message_set_flags") + (return-type "none") + (parameters + '("SoupMessageFlags" "flags") + ) +) + +(define-method get_flags + (of-object "SoupMessage") + (c-name "soup_message_get_flags") + (return-type "SoupMessageFlags") +) + +(define-method add_header_handler + (of-object "SoupMessage") + (c-name "soup_message_add_header_handler") + (return-type "guint") + (parameters + '("const-char*" "signal") + '("const-char*" "header") + '("GCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method add_status_code_handler + (of-object "SoupMessage") + (c-name "soup_message_add_status_code_handler") + (return-type "guint") + (parameters + '("const-char*" "signal") + '("guint" "status_code") + '("GCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method set_status + (of-object "SoupMessage") + (c-name "soup_message_set_status") + (return-type "none") + (parameters + '("guint" "status_code") + ) +) + +(define-method set_status_full + (of-object "SoupMessage") + (c-name "soup_message_set_status_full") + (return-type "none") + (parameters + '("guint" "status_code") + '("const-char*" "reason_phrase") + ) +) + +(define-method wrote_informational + (of-object "SoupMessage") + (c-name "soup_message_wrote_informational") + (return-type "none") +) + +(define-method wrote_headers + (of-object "SoupMessage") + (c-name "soup_message_wrote_headers") + (return-type "none") +) + +(define-method wrote_chunk + (of-object "SoupMessage") + (c-name "soup_message_wrote_chunk") + (return-type "none") +) + +(define-method wrote_body + (of-object "SoupMessage") + (c-name "soup_message_wrote_body") + (return-type "none") +) + +(define-method got_informational + (of-object "SoupMessage") + (c-name "soup_message_got_informational") + (return-type "none") +) + +(define-method got_headers + (of-object "SoupMessage") + (c-name "soup_message_got_headers") + (return-type "none") +) + +(define-method got_chunk + (of-object "SoupMessage") + (c-name "soup_message_got_chunk") + (return-type "none") + (parameters + '("SoupBuffer*" "chunk") + ) +) + +(define-method got_body + (of-object "SoupMessage") + (c-name "soup_message_got_body") + (return-type "none") +) + +(define-method restarted + (of-object "SoupMessage") + (c-name "soup_message_restarted") + (return-type "none") +) + +(define-method finished + (of-object "SoupMessage") + (c-name "soup_message_finished") + (return-type "none") +) + + + +;; From soup-method.h + + + +;; From soup-misc.h + +(define-function add_io_watch + (c-name "soup_add_io_watch") + (return-type "GSource*") + (parameters + '("GMainContext*" "async_context") + '("GIOChannel*" "chan") + '("GIOCondition" "condition") + '("GIOFunc" "function") + '("gpointer" "data") + ) +) + +(define-function add_idle + (c-name "soup_add_idle") + (return-type "GSource*") + (parameters + '("GMainContext*" "async_context") + '("GSourceFunc" "function") + '("gpointer" "data") + ) +) + +(define-function add_timeout + (c-name "soup_add_timeout") + (return-type "GSource*") + (parameters + '("GMainContext*" "async_context") + '("guint" "interval") + '("GSourceFunc" "function") + '("gpointer" "data") + ) +) + +(define-function signal_connect_once + (c-name "soup_signal_connect_once") + (return-type "guint") + (parameters + '("gpointer" "instance") + '("const-char*" "detailed_signal") + '("GCallback" "c_handler") + '("gpointer" "data") + ) +) + +(define-function str_case_hash + (c-name "soup_str_case_hash") + (return-type "guint") + (parameters + '("gconstpointer" "key") + ) +) + +(define-function str_case_equal + (c-name "soup_str_case_equal") + (return-type "gboolean") + (parameters + '("gconstpointer" "v1") + '("gconstpointer" "v2") + ) +) + +(define-function ssl_error_quark + (c-name "soup_ssl_error_quark") + (return-type "GQuark") +) + + + +;; From soup-portability.h + + + +;; From soup-server.h + +(define-function client_context_get_type + (c-name "soup_client_context_get_type") + (return-type "GType") +) + +(define-function server_get_type + (c-name "soup_server_get_type") + (return-type "GType") +) + +(define-function server_new + (c-name "soup_server_new") + (is-constructor-of "SoupServer") + (return-type "SoupServer*") + (parameters + '("const-char*" "optname1") + ) + (varargs #t) +) + +(define-method is_https + (of-object "SoupServer") + (c-name "soup_server_is_https") + (return-type "gboolean") +) + +(define-method get_port + (of-object "SoupServer") + (c-name "soup_server_get_port") + (return-type "int") +) + +(define-method get_listener + (of-object "SoupServer") + (c-name "soup_server_get_listener") + (return-type "SoupSocket*") +) + +(define-method run + (of-object "SoupServer") + (c-name "soup_server_run") + (return-type "none") +) + +(define-method run_async + (of-object "SoupServer") + (c-name "soup_server_run_async") + (return-type "none") +) + +(define-method quit + (of-object "SoupServer") + (c-name "soup_server_quit") + (return-type "none") +) + +(define-method get_async_context + (of-object "SoupServer") + (c-name "soup_server_get_async_context") + (return-type "GMainContext*") +) + +(define-method add_handler + (of-object "SoupServer") + (c-name "soup_server_add_handler") + (return-type "none") + (parameters + '("const-char*" "path") + '("SoupServerCallback" "callback") + '("gpointer" "user_data") + '("GDestroyNotify" "destroy") + ) +) + +(define-method remove_handler + (of-object "SoupServer") + (c-name "soup_server_remove_handler") + (return-type "none") + (parameters + '("const-char*" "path") + ) +) + +(define-method add_auth_domain + (of-object "SoupServer") + (c-name "soup_server_add_auth_domain") + (return-type "none") + (parameters + '("SoupAuthDomain*" "auth_domain") + ) +) + +(define-method remove_auth_domain + (of-object "SoupServer") + (c-name "soup_server_remove_auth_domain") + (return-type "none") + (parameters + '("SoupAuthDomain*" "auth_domain") + ) +) + +(define-method pause_message + (of-object "SoupServer") + (c-name "soup_server_pause_message") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method unpause_message + (of-object "SoupServer") + (c-name "soup_server_unpause_message") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method get_socket + (of-object "SoupClientContext") + (c-name "soup_client_context_get_socket") + (return-type "SoupSocket*") +) + +(define-method get_address + (of-object "SoupClientContext") + (c-name "soup_client_context_get_address") + (return-type "SoupAddress*") +) + +(define-method get_host + (of-object "SoupClientContext") + (c-name "soup_client_context_get_host") + (return-type "const-char*") +) + +(define-method get_auth_domain + (of-object "SoupClientContext") + (c-name "soup_client_context_get_auth_domain") + (return-type "SoupAuthDomain*") +) + +(define-method get_auth_user + (of-object "SoupClientContext") + (c-name "soup_client_context_get_auth_user") + (return-type "const-char*") +) + + + +;; From soup-session-async.h + +(define-function session_async_get_type + (c-name "soup_session_async_get_type") + (return-type "GType") +) + +(define-function session_async_new + (c-name "soup_session_async_new") + (is-constructor-of "SoupSessionAsync") + (return-type "SoupSession*") +) + +(define-function session_async_new_with_options + (c-name "soup_session_async_new_with_options") + (return-type "SoupSession*") + (parameters + '("const-char*" "optname1") + ) + (varargs #t) +) + + + +;; From soup-session-sync.h + +(define-function session_sync_get_type + (c-name "soup_session_sync_get_type") + (return-type "GType") +) + +(define-function session_sync_new + (c-name "soup_session_sync_new") + (is-constructor-of "SoupSessionSync") + (return-type "SoupSession*") +) + +(define-function session_sync_new_with_options + (c-name "soup_session_sync_new_with_options") + (return-type "SoupSession*") + (parameters + '("const-char*" "optname1") + ) + (varargs #t) +) + + + +;; From soup-session.h + +(define-function session_get_type + (c-name "soup_session_get_type") + (return-type "GType") +) + +(define-method get_async_context + (of-object "SoupSession") + (c-name "soup_session_get_async_context") + (return-type "GMainContext*") +) + +(define-method queue_message + (of-object "SoupSession") + (c-name "soup_session_queue_message") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + '("SoupSessionCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method requeue_message + (of-object "SoupSession") + (c-name "soup_session_requeue_message") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method send_message + (of-object "SoupSession") + (c-name "soup_session_send_message") + (return-type "int") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method pause_message + (of-object "SoupSession") + (c-name "soup_session_pause_message") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method unpause_message + (of-object "SoupSession") + (c-name "soup_session_unpause_message") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + ) +) + +(define-method cancel_message + (of-object "SoupSession") + (c-name "soup_session_cancel_message") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + '("guint" "status_code") + ) +) + +(define-method abort + (of-object "SoupSession") + (c-name "soup_session_abort") + (return-type "none") +) + + + +;; From soup-socket.h + +(define-function socket_get_type + (c-name "soup_socket_get_type") + (return-type "GType") +) + +(define-function socket_new + (c-name "soup_socket_new") + (is-constructor-of "SoupSocket") + (return-type "SoupSocket*") + (parameters + '("const-char*" "optname1") + ) + (varargs #t) +) + +(define-method connect_async + (of-object "SoupSocket") + (c-name "soup_socket_connect_async") + (return-type "none") + (parameters + '("GCancellable*" "cancellable") + '("SoupSocketCallback" "callback") + '("gpointer" "user_data") + ) +) + +(define-method connect_sync + (of-object "SoupSocket") + (c-name "soup_socket_connect_sync") + (return-type "int") + (parameters + '("GCancellable*" "cancellable") + ) +) + +(define-method listen + (of-object "SoupSocket") + (c-name "soup_socket_listen") + (return-type "gboolean") +) + +(define-method start_ssl + (of-object "SoupSocket") + (c-name "soup_socket_start_ssl") + (return-type "gboolean") + (parameters + '("GCancellable*" "cancellable") + ) +) + +(define-method start_proxy_ssl + (of-object "SoupSocket") + (c-name "soup_socket_start_proxy_ssl") + (return-type "gboolean") + (parameters + '("const-char*" "ssl_host") + '("GCancellable*" "cancellable") + ) +) + +(define-method is_ssl + (of-object "SoupSocket") + (c-name "soup_socket_is_ssl") + (return-type "gboolean") +) + +(define-method disconnect + (of-object "SoupSocket") + (c-name "soup_socket_disconnect") + (return-type "none") +) + +(define-method is_connected + (of-object "SoupSocket") + (c-name "soup_socket_is_connected") + (return-type "gboolean") +) + +(define-method get_local_address + (of-object "SoupSocket") + (c-name "soup_socket_get_local_address") + (return-type "SoupAddress*") +) + +(define-method get_remote_address + (of-object "SoupSocket") + (c-name "soup_socket_get_remote_address") + (return-type "SoupAddress*") +) + +(define-method read + (of-object "SoupSocket") + (c-name "soup_socket_read") + (return-type "SoupSocketIOStatus") + (parameters + '("gpointer" "buffer") + '("gsize" "len") + '("gsize*" "nread") + '("GCancellable*" "cancellable") + '("GError**" "error") + ) +) + +(define-method read_until + (of-object "SoupSocket") + (c-name "soup_socket_read_until") + (return-type "SoupSocketIOStatus") + (parameters + '("gpointer" "buffer") + '("gsize" "len") + '("gconstpointer" "boundary") + '("gsize" "boundary_len") + '("gsize*" "nread") + '("gboolean*" "got_boundary") + '("GCancellable*" "cancellable") + '("GError**" "error") + ) +) + +(define-method write + (of-object "SoupSocket") + (c-name "soup_socket_write") + (return-type "SoupSocketIOStatus") + (parameters + '("gconstpointer" "buffer") + '("gsize" "len") + '("gsize*" "nwrote") + '("GCancellable*" "cancellable") + '("GError**" "error") + ) +) + + + +;; From soup-status.h + +(define-function status_get_phrase + (c-name "soup_status_get_phrase") + (return-type "const-char*") + (parameters + '("guint" "status_code") + ) +) + +(define-function http_error_quark + (c-name "soup_http_error_quark") + (return-type "GQuark") +) + + + +;; From soup-types.h + + + +;; From soup-uri.h + +(define-function uri_get_type + (c-name "soup_uri_get_type") + (return-type "GType") +) + +(define-method new_with_base + (of-object "SoupURI") + (c-name "soup_uri_new_with_base") + (return-type "SoupURI*") + (parameters + '("const-char*" "uri_string") + ) +) + +(define-function uri_new + (c-name "soup_uri_new") + (is-constructor-of "SoupURI") + (return-type "SoupURI*") + (parameters + '("const-char*" "uri_string") + ) +) + +(define-method to_string + (of-object "SoupURI") + (c-name "soup_uri_to_string") + (return-type "char*") + (parameters + '("gboolean" "just_path_and_query") + ) +) + +(define-method copy + (of-object "SoupURI") + (c-name "soup_uri_copy") + (return-type "SoupURI*") +) + +(define-method equal + (of-object "SoupURI") + (c-name "soup_uri_equal") + (return-type "gboolean") + (parameters + '("SoupURI*" "uri2") + ) +) + +(define-method free + (of-object "SoupURI") + (c-name "soup_uri_free") + (return-type "none") +) + +(define-function uri_encode + (c-name "soup_uri_encode") + (return-type "char*") + (parameters + '("const-char*" "part") + '("const-char*" "escape_extra") + ) +) + +(define-function uri_decode + (c-name "soup_uri_decode") + (return-type "char*") + (parameters + '("const-char*" "part") + ) +) + +(define-function uri_normalize + (c-name "soup_uri_normalize") + (return-type "char*") + (parameters + '("const-char*" "part") + '("const-char*" "unescape_extra") + ) +) + +(define-method uses_default_port + (of-object "SoupURI") + (c-name "soup_uri_uses_default_port") + (return-type "gboolean") +) + +(define-method set_scheme + (of-object "SoupURI") + (c-name "soup_uri_set_scheme") + (return-type "none") + (parameters + '("const-char*" "scheme") + ) +) + +(define-method set_user + (of-object "SoupURI") + (c-name "soup_uri_set_user") + (return-type "none") + (parameters + '("const-char*" "user") + ) +) + +(define-method set_password + (of-object "SoupURI") + (c-name "soup_uri_set_password") + (return-type "none") + (parameters + '("const-char*" "password") + ) +) + +(define-method set_host + (of-object "SoupURI") + (c-name "soup_uri_set_host") + (return-type "none") + (parameters + '("const-char*" "host") + ) +) + +(define-method set_port + (of-object "SoupURI") + (c-name "soup_uri_set_port") + (return-type "none") + (parameters + '("guint" "port") + ) +) + +(define-method set_path + (of-object "SoupURI") + (c-name "soup_uri_set_path") + (return-type "none") + (parameters + '("const-char*" "path") + ) +) + +(define-method set_query + (of-object "SoupURI") + (c-name "soup_uri_set_query") + (return-type "none") + (parameters + '("const-char*" "query") + ) +) + +(define-method set_query_from_form + (of-object "SoupURI") + (c-name "soup_uri_set_query_from_form") + (return-type "none") + (parameters + '("GHashTable*" "form") + ) +) + +(define-method set_query_from_fields + (of-object "SoupURI") + (c-name "soup_uri_set_query_from_fields") + (return-type "none") + (parameters + '("const-char*" "first_field") + ) + (varargs #t) +) + +(define-method set_fragment + (of-object "SoupURI") + (c-name "soup_uri_set_fragment") + (return-type "none") + (parameters + '("const-char*" "fragment") + ) +) + + + +;; From soup-value-utils.h + +(define-function value_hash_new + (c-name "soup_value_hash_new") + (return-type "GHashTable*") +) + +(define-function value_hash_new_with_vals + (c-name "soup_value_hash_new_with_vals") + (return-type "GHashTable*") + (parameters + '("const-char*" "first_key") + ) + (varargs #t) +) + +(define-function value_hash_insert_value + (c-name "soup_value_hash_insert_value") + (return-type "none") + (parameters + '("GHashTable*" "hash") + '("const-char*" "key") + '("GValue*" "value") + ) +) + +(define-function value_hash_insert + (c-name "soup_value_hash_insert") + (return-type "none") + (parameters + '("GHashTable*" "hash") + '("const-char*" "key") + '("GType" "type") + ) + (varargs #t) +) + +(define-function value_hash_insert_vals + (c-name "soup_value_hash_insert_vals") + (return-type "none") + (parameters + '("GHashTable*" "hash") + '("const-char*" "first_key") + ) + (varargs #t) +) + +(define-function value_hash_lookup + (c-name "soup_value_hash_lookup") + (return-type "gboolean") + (parameters + '("GHashTable*" "hash") + '("const-char*" "key") + '("GType" "type") + ) + (varargs #t) +) + +(define-function value_hash_lookup_vals + (c-name "soup_value_hash_lookup_vals") + (return-type "gboolean") + (parameters + '("GHashTable*" "hash") + '("const-char*" "first_key") + ) + (varargs #t) +) + +(define-function value_array_from_args + (c-name "soup_value_array_from_args") + (return-type "GValueArray*") + (parameters + '("va_list" "args") + ) +) + +(define-function value_array_to_args + (c-name "soup_value_array_to_args") + (return-type "gboolean") + (parameters + '("GValueArray*" "array") + '("va_list" "args") + ) +) + +(define-function value_array_new + (c-name "soup_value_array_new") + (return-type "GValueArray*") +) + +(define-function value_array_new_with_vals + (c-name "soup_value_array_new_with_vals") + (return-type "GValueArray*") + (parameters + '("GType" "first_type") + ) + (varargs #t) +) + +(define-function value_array_insert + (c-name "soup_value_array_insert") + (return-type "none") + (parameters + '("GValueArray*" "array") + '("guint" "index_") + '("GType" "type") + ) + (varargs #t) +) + +(define-function value_array_append + (c-name "soup_value_array_append") + (return-type "none") + (parameters + '("GValueArray*" "array") + '("GType" "type") + ) + (varargs #t) +) + +(define-function value_array_append_vals + (c-name "soup_value_array_append_vals") + (return-type "none") + (parameters + '("GValueArray*" "array") + '("GType" "first_type") + ) + (varargs #t) +) + +(define-function value_array_get_nth + (c-name "soup_value_array_get_nth") + (return-type "gboolean") + (parameters + '("GValueArray*" "array") + '("guint" "index_") + '("GType" "type") + ) + (varargs #t) +) + +(define-function byte_array_get_type + (c-name "soup_byte_array_get_type") + (return-type "GType") +) + + + +;; From soup-xmlrpc.h + +(define-function xmlrpc_build_method_call + (c-name "soup_xmlrpc_build_method_call") + (return-type "char*") + (parameters + '("const-char*" "method_name") + '("GValue*" "params") + '("int" "n_params") + ) +) + +(define-function xmlrpc_request_new + (c-name "soup_xmlrpc_request_new") + (return-type "SoupMessage*") + (parameters + '("const-char*" "uri") + '("const-char*" "method_name") + ) + (varargs #t) +) + +(define-function xmlrpc_parse_method_response + (c-name "soup_xmlrpc_parse_method_response") + (return-type "gboolean") + (parameters + '("const-char*" "method_response") + '("int" "length") + '("GValue*" "value") + '("GError**" "error") + ) +) + +(define-function xmlrpc_extract_method_response + (c-name "soup_xmlrpc_extract_method_response") + (return-type "gboolean") + (parameters + '("const-char*" "method_response") + '("int" "length") + '("GError**" "error") + '("GType" "type") + ) + (varargs #t) +) + +(define-function xmlrpc_parse_method_call + (c-name "soup_xmlrpc_parse_method_call") + (return-type "gboolean") + (parameters + '("const-char*" "method_call") + '("int" "length") + '("char**" "method_name") + '("GValueArray**" "params") + ) +) + +(define-function xmlrpc_extract_method_call + (c-name "soup_xmlrpc_extract_method_call") + (return-type "gboolean") + (parameters + '("const-char*" "method_call") + '("int" "length") + '("char**" "method_name") + ) + (varargs #t) +) + +(define-function xmlrpc_build_method_response + (c-name "soup_xmlrpc_build_method_response") + (return-type "char*") + (parameters + '("GValue*" "value") + ) +) + +(define-function xmlrpc_build_fault + (c-name "soup_xmlrpc_build_fault") + (return-type "char*") + (parameters + '("int" "fault_code") + '("const-char*" "fault_format") + ) + (varargs #t) +) + +(define-function xmlrpc_set_response + (c-name "soup_xmlrpc_set_response") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + '("GType" "type") + ) + (varargs #t) +) + +(define-function xmlrpc_set_fault + (c-name "soup_xmlrpc_set_fault") + (return-type "none") + (parameters + '("SoupMessage*" "msg") + '("int" "fault_code") + '("const-char*" "fault_format") + ) + (varargs #t) +) + +(define-function xmlrpc_error_quark + (c-name "soup_xmlrpc_error_quark") + (return-type "GQuark") +) + +(define-function xmlrpc_fault_quark + (c-name "soup_xmlrpc_fault_quark") + (return-type "GQuark") +) + + + +;; From soup.h + + diff --git a/python/libsoup.override b/python/libsoup.override new file mode 100644 index 0000000..2f9068c --- /dev/null +++ b/python/libsoup.override @@ -0,0 +1,591 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * libsoup.override: overrides for libsoup + */ +%% +headers +#define NO_IMPORT_PYGOBJECT +#include "pygobject.h" +#include + +%% +modulename soup +%% +import gobject.GObject as PyGObject_Type +import gio.GCancellable as PyGCancellable_Type +%% +include + SoupLogger.override + SoupMessageBody.override + SoupMessageHeaders.override + SoupURI.override + soup-forms.override + soup-headers.override + soup-xmlrpc.override +%% +ignore + soup_auth_free_protection_space + soup_buffer_new + soup_message_new_from_uri + soup_signal_connect_once +%% +ignore-glob + *_get_async_context + *_get_type + *_new_with_options + *_quark + soup_address_new_* + soup_date_new_* + soup_value_array_* + soup_value_hash_* + soup_str_case_* + soup_add_* +%% +body +static int +pysoup_generic_construct (PyGObject *self, PyObject *kwargs) +{ + PyObject *key, *item; + Py_ssize_t i, n_params; + GObjectClass *klass; + GParamSpec *pspec; + GParameter *params; + int ret = -1, n; + + if (!kwargs) + return pygobject_constructv (self, 0, NULL); + + klass = g_type_class_ref (pyg_type_from_object((PyObject *) self)); + n_params = PyDict_Size (kwargs); + params = g_new0 (GParameter, n_params); + + i = n = 0; + while (PyDict_Next (kwargs, &i, &key, &item)) { + params[n].name = PyString_AsString (key); + + pspec = g_object_class_find_property (klass, params[n].name); + if (!pspec) { + PyErr_Format (PyExc_TypeError, "'%s' is an invalid keyword argument for this function", params[n].name); + goto cleanup; + } + + g_value_init (¶ms[n].value, pspec->value_type); + if (pyg_value_from_pyobject (¶ms[n].value, item) == -1) { + PyErr_Format(PyExc_TypeError, "could not convert parameter '%s' of type '%s'", + params[n].name, g_type_name (pspec->value_type)); + goto cleanup; + } + n++; + } + + ret = pygobject_constructv (self, n_params, params); + +cleanup: + for (i = 0; i < n_params; i++) + g_value_unset (¶ms[i].value); + g_free (params); + g_type_class_unref (klass); + + return ret; +} + +static gboolean +pysoup_value_from_pyobject (GValue *value, PyObject *pyo) +{ + memset (value, 0, sizeof (GValue)); + + if (PyBool_Check (pyo)) { + g_value_init (value, G_TYPE_BOOLEAN); + g_value_set_boolean (value, PyObject_IsTrue (pyo)); + } else if (PyInt_Check (pyo)) { + g_value_init (value, G_TYPE_INT); + g_value_set_int (value, PyInt_AsLong (pyo)); + } else if (PyFloat_Check (pyo)) { + g_value_init (value, G_TYPE_DOUBLE); + g_value_set_double (value, PyFloat_AsDouble (pyo)); + } else if (PyString_Check (pyo)) { + g_value_init (value, G_TYPE_STRING); + g_value_set_string (value, PyString_AsString (pyo)); + } else if (pyg_boxed_check (pyo, SOUP_TYPE_DATE)) { + g_value_init (value, SOUP_TYPE_DATE); + g_value_set_boxed (value, pyg_boxed_get (pyo, SoupDate)); + } else if (PyTuple_Check (pyo) && PyTuple_Size (pyo) == 1 && + PyString_Check (PyTuple_GetItem (pyo, 0))) { + GByteArray *ba; + char *data; + Py_ssize_t len; + + PyString_AsStringAndSize (PyTuple_GetItem (pyo, 0), &data, &len); + ba = g_byte_array_new (); + g_byte_array_append (ba, (guchar *)data, len); + + g_value_init (value, SOUP_TYPE_BYTE_ARRAY); + g_value_take_boxed (value, ba); + } else if (PyDict_Check (pyo)) { + GHashTable *dict; + Py_ssize_t i = 0; + PyObject *key, *item; + char *string_key; + GValue member; + + dict = soup_value_hash_new (); + while (PyDict_Next (pyo, &i, &key, &item)) { + string_key = PyString_AsString (key); + if (!pysoup_value_from_pyobject (&member, item)) { + g_hash_table_destroy (dict); + return FALSE; + } + g_hash_table_insert (dict, g_strdup (string_key), + g_memdup (&member, sizeof (GValue))); + } + + g_value_init (value, G_TYPE_HASH_TABLE); + g_value_take_boxed (value, dict); + } else if (PyList_Check (pyo)) { + GValueArray *array; + PyObject *item; + Py_ssize_t len, i; + + len = PyList_Size (pyo); + array = g_value_array_new (len); + for (i = 0; i < len; i++) { + item = PyList_GetItem (pyo, i); + if (!pysoup_value_from_pyobject (&array->values[i], item)) { + g_value_array_free (array); + return FALSE; + } + array->n_values++; + } + + g_value_init (value, G_TYPE_VALUE_ARRAY); + g_value_take_boxed (value, array); + } else { + PyErr_Format(PyExc_TypeError, "Could not convert argument"); + return FALSE; + } + + return TRUE; +} + +static PyObject * +pysoup_value_to_pyobject (GValue *value) +{ + if (G_VALUE_HOLDS_BOOLEAN (value)) { + if (g_value_get_boolean (value)) + Py_RETURN_TRUE; + else + Py_RETURN_FALSE; + } else if (G_VALUE_HOLDS_INT (value)) { + return PyInt_FromLong (g_value_get_int (value)); + } else if (G_VALUE_HOLDS_DOUBLE (value)) { + return PyFloat_FromDouble (g_value_get_double (value)); + } else if (G_VALUE_HOLDS_STRING (value)) { + return PyString_FromString (g_value_get_string (value)); + } else if (G_VALUE_TYPE (value) == SOUP_TYPE_DATE) { + return pyg_boxed_new (SOUP_TYPE_DATE, g_value_get_boxed (value), + TRUE, TRUE); + } else if (G_VALUE_TYPE (value) == SOUP_TYPE_BYTE_ARRAY) { + GByteArray *ba = g_value_get_boxed (value); + + return PyString_FromStringAndSize ((char *)ba->data, ba->len); + } else if (G_VALUE_TYPE (value) == G_TYPE_HASH_TABLE) { + GHashTable *dict = g_value_get_boxed (value); + GHashTableIter iter; + gpointer key, value; + PyObject *py_dict, *py_member; + + py_dict = PyDict_New (); + g_hash_table_iter_init (&iter, dict); + while (g_hash_table_iter_next (&iter, &key, &value)) { + py_member = pysoup_value_to_pyobject (value); + if (!py_member) { + Py_DECREF (py_dict); + return NULL; + } + PyDict_SetItemString (py_dict, key, py_member); + } + return py_dict; + } else if (G_VALUE_TYPE (value) == G_TYPE_VALUE_ARRAY) { + GValueArray *array = g_value_get_boxed (value); + PyObject *py_list, *py_member; + int i; + + py_list = PyList_New (array->n_values); + for (i = 0; i < array->n_values; i++) { + py_member = pysoup_value_to_pyobject (&array->values[i]); + if (!py_member) { + Py_DECREF (py_list); + return FALSE; + } + PyList_SetItem (py_list, i, py_member); + } + return py_list; + } + + PyErr_Format(PyExc_TypeError, "Could not convert argument"); + return NULL; +} + +static PyObject * +pysoup_gslist_to_pylist (GSList *gslist) +{ + PyObject *pylist; + int i; + + pylist = PyList_New (g_slist_length (gslist)); + for (i = 0; gslist; i++, gslist = gslist->next) + PyList_SetItem (pylist, i, PyString_FromString (gslist->data)); + return pylist; +} + +static PyObject * +pysoup_ghashtable_to_pydict (GHashTable *dict) +{ + GHashTableIter iter; + gpointer key, value; + PyObject *py_dict; + + py_dict = PyDict_New (); + g_hash_table_iter_init (&iter, dict); + while (g_hash_table_iter_next (&iter, &key, &value)) { + PyDict_SetItemString (py_dict, key, + PyString_FromString (value ? value : "")); + } + return py_dict; +} + +static GHashTable * +pysoup_pydict_to_ghashtable (PyObject *dict) +{ + GHashTable *hash; + PyObject *key, *item; + char *string_key, *string_item; + Py_ssize_t i = 0; + + g_return_val_if_fail (PyDict_Check (dict), NULL); + + hash = g_hash_table_new (g_str_hash, g_str_equal); + while (PyDict_Next (dict, &i, &key, &item)) { + string_key = PyString_AsString (key); + string_item = PyString_AsString (item); + if (!string_item) { + PyErr_Format (PyExc_TypeError, "value of key '%s' is not a string", string_key); + g_hash_table_destroy (hash); + return NULL; + } + g_hash_table_insert (hash, string_key, string_item); + } + + return hash; +} + +typedef struct { + PyObject *func, *data; +} PySoupCallback; + +static PySoupCallback * +pysoup_callback_new (PyObject *func, PyObject *data) +{ + PySoupCallback *psc; + + psc = g_slice_new (PySoupCallback); + psc->func = func; + psc->data = data; + Py_INCREF (psc->func); + Py_XINCREF (psc->data); + return psc; +} + +static void +pysoup_callback_destroy_notify (gpointer data) +{ + PySoupCallback *psc = data; + + Py_DECREF (psc->func); + Py_XDECREF (psc->data); + g_slice_free (PySoupCallback, psc); +} + +%% +override soup_date_new kwargs +static int +_wrap_soup_date_new(PyGBoxed *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "year", "month", "day", "hour", "minute", + "second", "utc", "offset", "date_string", + "time_t", "from_now", NULL }; + int year = 0, month = 0, day = 0, hour = 0, minute = 0, second = 0; + int offset = 0, from_now = 0; + PyObject *py_utc = NULL; + char *date_string = NULL; + long timet = 0; + SoupDate *date; + + if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|iiiiiiOizli:SoupDate.__init__", + kwlist, &year, &month, &day, &hour, + &minute, &second, &py_utc, &offset, + &date_string, &timet, &from_now)) + return -1; + + self->gtype = SOUP_TYPE_DATE; + self->free_on_dealloc = FALSE; + + if (date_string) { + if (year || month || day || hour || minute || second || + py_utc || offset || timet || from_now) { + PyErr_SetString(PyExc_TypeError, "SoupDate.__init__() called with contradictory arguments"); + return -1; + } + self->boxed = soup_date_new_from_string (date_string); + } else if (timet) { + if (year || month || day || hour || minute || second || + py_utc || offset || from_now) { + PyErr_SetString(PyExc_TypeError, "SoupDate.__init__() called with contradictory arguments"); + return -1; + } + self->boxed = soup_date_new_from_time_t (timet); + } else if (year && month && day) { + if (from_now) { + PyErr_SetString(PyExc_TypeError, "SoupDate.__init__() called with contradictory arguments"); + return -1; + } + self->boxed = date = soup_date_new (year, month, day, hour, minute, second); + if (py_utc && PyObject_IsTrue(py_utc)) + date->utc = TRUE; + date->offset = offset; + } else { + if (year && !from_now) { + from_now = year; + year = 0; + } + if (year || month || day || hour || minute || second || + py_utc || offset) { + PyErr_SetString(PyExc_TypeError, "SoupDate.__init__() called with incomplete or contradictory arguments"); + return -1; + } + self->boxed = soup_date_new_from_now (from_now); + } + + if (!self->boxed) { + PyErr_SetString(PyExc_RuntimeError, "could not create SoupDate object"); + return -1; + } + self->free_on_dealloc = TRUE; + return 0; +} +%% +new-constructor SOUP_TYPE_ADDRESS +%% +override soup_address_new kwargs +static int +_wrap_soup_address_new(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "name_or_family", "port", NULL }; + PyObject *py_name_or_family = NULL; + int port = 0; + char *name; + SoupAddressFamily family; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "O|i:SoupAddress.__init__", + kwlist, &py_name_or_family, &port)) + return -1; + if (PyString_Check (py_name_or_family)) { + name = PyString_AsString (py_name_or_family); + if (pygobject_construct (self, "name", name, "port", port, NULL) == -1) + return -1; + } else { + if (pyg_enum_get_value (SOUP_TYPE_ADDRESS_FAMILY, py_name_or_family, (gpointer)&family) == -1) { + PyErr_SetString (PyExc_TypeError, "Parameter 'name_or_family' must be a string or a SoupAddressFamily"); + return -1; + } + if (pygobject_construct (self, "family", family, "port", port, NULL) == -1) + return -1; + } + + return 0; +} +%% +override soup_auth_get_protection_space kwargs +static PyObject * +_wrap_soup_auth_get_protection_space (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "source_uri", NULL }; + PyObject *py_uri; + SoupURI *source_uri; + GSList *pspace; + PyObject *py_ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "O:SoupAuth.get_protection_space", + kwlist, &py_uri)) + return NULL; + if (!pyg_boxed_check (py_uri, SOUP_TYPE_URI)) { + PyErr_SetString (PyExc_TypeError, "source_uri must be a SoupURI"); + return NULL; + } + source_uri = pyg_boxed_get (py_uri, SoupURI); + + pspace = soup_auth_get_protection_space (SOUP_AUTH (self->obj), source_uri); + py_ret = pysoup_gslist_to_pylist (pspace); + soup_auth_free_protection_space (SOUP_AUTH (self->obj), pspace); + + return py_ret; +} + +%% +new-constructor SOUP_TYPE_AUTH_DOMAIN_BASIC +%% +override soup_auth_domain_basic_new kwargs +static int +_wrap_soup_auth_domain_basic_new (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + return pysoup_generic_construct (self, kwargs); +} +%% +new-constructor SOUP_TYPE_AUTH_DOMAIN_DIGEST +%% +override soup_auth_domain_digest_new kwargs +static int +_wrap_soup_auth_domain_digest_new (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + return pysoup_generic_construct (self, kwargs); +} +%% +new-constructor SOUP_TYPE_MESSAGE +%% +override soup_message_new kwargs +static int +_wrap_soup_message_new(PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "method", "uri", NULL }; + char *method, *uri_str; + PyObject *py_uri; + SoupURI *uri; + gboolean free_uri = FALSE; + int ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "sO:SoupMessage.__init__", + kwlist, &method, &py_uri)) + return -1; + if (PyString_Check (py_uri)) { + uri_str = PyString_AsString (py_uri); + uri = soup_uri_new (uri_str); + free_uri = TRUE; + if (!uri) { + PyErr_SetString (PyExc_TypeError, "invalid URI"); + return -1; + } + } else if (pyg_boxed_check (py_uri, SOUP_TYPE_URI)) { + uri = pyg_boxed_get (py_uri, SoupURI); + } else { + PyErr_SetString (PyExc_TypeError, "uri should be a string or SoupURI"); + return -1; + } + + ret = pygobject_construct (self, "method", method, "uri", uri, NULL); + if (free_uri) + soup_uri_free (uri); + + if (ret == -1) + PyErr_SetString(PyExc_RuntimeError, "invalid URI"); + return ret; +} +%% +new-constructor SOUP_TYPE_SERVER +%% +override soup_server_new kwargs +static int +_wrap_soup_server_new (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + return pysoup_generic_construct (self, kwargs); +} +%% +override soup_session_queue_message + +static void +pysoup_queue_message_callback (SoupSession *session, SoupMessage *msg, + gpointer user_data) +{ + PySoupCallback *psc = user_data; + PyGILState_STATE state; + PyObject *py_session, *py_msg, *py_ret; + + state = pyg_gil_state_ensure (); + + py_session = pygobject_new ((GObject *)session); + py_msg = pygobject_new ((GObject *)msg); + if (psc->data) { + py_ret = PyEval_CallFunction (psc->func, "(NNO)", py_session, py_msg, + psc->data); + } else + py_ret = PyEval_CallFunction (psc->func, "(NN)", py_session, py_msg); + + if (py_ret != NULL) + Py_DECREF (py_ret); + else + PyErr_Print (); + + pyg_gil_state_release (state); +} + +static PyObject * +_wrap_soup_session_queue_message (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "msg", "callback", "user_data", NULL }; + PyGObject *pymsg; + PyObject *pyfunc, *pyarg = NULL; + PySoupCallback *psc; + SoupMessage *msg; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "OO|O:SoupSession.queue_message", + kwlist, &pymsg, pyfunc, &pyarg)) + return NULL; + if (!pygobject_check (pymsg, &PySoupMessage_Type)) { + PyErr_SetString (PyExc_TypeError, "msg must be a SoupMessage"); + return NULL; + } + if (!PyCallable_Check (pyfunc)) { + PyErr_SetString (PyExc_TypeError, "callback must be a callable object"); + return NULL; + } + + /* soup_session_queue_message steals a ref, so add an extra one. */ + msg = g_object_ref (pymsg->obj); + + psc = pysoup_callback_new (pyfunc, pyarg); + soup_session_queue_message (SOUP_SESSION (self->obj), msg, + pysoup_queue_message_callback, psc); + + Py_INCREF (Py_None); + return Py_None; +} +%% +new-constructor SOUP_TYPE_SESSION_ASYNC +%% +override soup_session_async_new kwargs +static int +_wrap_soup_session_async_new (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + return pysoup_generic_construct (self, kwargs); +} +%% +new-constructor SOUP_TYPE_SESSION_SYNC +%% +override soup_session_sync_new kwargs +static int +_wrap_soup_session_sync_new (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + return pysoup_generic_construct (self, kwargs); +} +%% +new-constructor SOUP_TYPE_SOCKET +%% +override soup_socket_new kwargs +static int +_wrap_soup_socket_new (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + return pysoup_generic_construct (self, kwargs); +} diff --git a/python/libsoupmodule.c b/python/libsoupmodule.c new file mode 100644 index 0000000..69f7630 --- /dev/null +++ b/python/libsoupmodule.c @@ -0,0 +1,48 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * libsoupmodule.c: module wrapping libsoup. + * + * based off atkmodule.c, Copyright (C) 1998-2003 James Henstridge + * + * This library is free software; you can redistribute it and/or + * modify it under the terms of the GNU Lesser General Public + * License as published by the Free Software Foundation; either + * version 2.1 of the License, or (at your option) any later version. + * + * This library is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + * Lesser General Public License for more details. + * + * You should have received a copy of the GNU Lesser General Public + * License along with this library; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 + * USA + */ + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + +/* include this first, before NO_IMPORT_PYGOBJECT is defined */ +#include + +void pylibsoup_register_classes (PyObject *d); +void pylibsoup_add_constants(PyObject *module, const gchar *strip_prefix); +void _pylibsoup_register_boxed_types(void); + +extern PyMethodDef pylibsoup_functions[]; + +DL_EXPORT(void) +initsoup(void) +{ + PyObject *m, *d; + + init_pygobject (); + g_thread_init (NULL); + + m = Py_InitModule ("soup", pylibsoup_functions); + d = PyModule_GetDict (m); + pylibsoup_register_classes (d); + pylibsoup_add_constants(m, "SOUP_"); +} diff --git a/python/soup-forms.override b/python/soup-forms.override new file mode 100644 index 0000000..92e897e --- /dev/null +++ b/python/soup-forms.override @@ -0,0 +1,81 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * soup-forms.override: overrides for soup-forms + */ +%% +ignore-glob + soup_form_encode_* + soup_form_request_new_* +%% +override soup_form_decode kwargs +static PyObject * +_wrap_soup_form_decode (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "encoded_form", NULL }; + char *encoded_form; + GHashTable *hash; + PyObject *dict; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "s:soup.form_decode", + kwlist, &encoded_form)) + return NULL; + + hash = soup_form_decode (encoded_form); + dict = pysoup_ghashtable_to_pydict (hash); + g_hash_table_destroy (hash); + return dict; +} +%% +override soup_form_encode kwargs +static PyObject * +_wrap_soup_form_encode (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "form_data_set", NULL }; + PyObject *py_form, *py_encoded; + GHashTable *form; + char *encoded; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "O:soup.form_encode", + kwlist, &py_form)) + return NULL; + if (!PyDict_Check (py_form)) { + PyErr_SetString (PyExc_TypeError, "soup.form_encode: argument must be a dict"); + return NULL; + } + + form = pysoup_pydict_to_ghashtable (py_form); + encoded = soup_form_encode_hash (form); + py_encoded = PyString_FromString (encoded); + + g_free (encoded); + g_hash_table_destroy (form); + return py_encoded; +} +%% +override soup_form_request_new kwargs +static PyObject * +_wrap_soup_form_request_new (PyGObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "method", "uri", "form_data_set", NULL }; + char *method, *uri; + PyObject *py_form; + GHashTable *form; + SoupMessage *msg; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "ssO:soup.form_request_new", + kwlist, &method, &uri, &py_form)) + return NULL; + if (!PyDict_Check (py_form)) { + PyErr_SetString (PyExc_TypeError, "soup.form_request_new: 'form_data_set' must be a dict"); + return NULL; + } + + form = pysoup_pydict_to_ghashtable (py_form); + msg = soup_form_request_new_from_hash (method, uri, form); + + g_hash_table_destroy (form); + return pygobject_new (G_OBJECT (msg)); +} diff --git a/python/soup-headers.override b/python/soup-headers.override new file mode 100644 index 0000000..193ccaf --- /dev/null +++ b/python/soup-headers.override @@ -0,0 +1,215 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * soup-headers.override: overrides for soup-headers + */ +%% +ignore + soup_header_free_list + soup_header_free_param_list +%% +override soup_header_parse_list kwargs +static PyObject * +_wrap_soup_header_parse_list (PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "header", NULL }; + char *header; + GSList *parsed; + PyObject *ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "s:soup.header_parse_list", + kwlist, &header)) + return NULL; + + parsed = soup_header_parse_list (header); + ret = pysoup_gslist_to_pylist (parsed); + soup_header_free_list (parsed); + + return ret; +} +%% +override soup_header_parse_quality_list kwargs +static PyObject * +_wrap_soup_header_parse_quality_list (PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "header", NULL }; + char *header; + GSList *acceptable, *unacceptable; + PyObject *py_acceptable, *py_unacceptable, *ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "s:soup.header_parse_quality_list", + kwlist, &header)) + return NULL; + + acceptable = soup_header_parse_quality_list (header, &unacceptable); + py_acceptable = pysoup_gslist_to_pylist (acceptable); + py_unacceptable = pysoup_gslist_to_pylist (unacceptable); + soup_header_free_list (acceptable); + soup_header_free_list (unacceptable); + + ret = PyTuple_New (2); + PyTuple_SetItem (ret, 0, py_acceptable); + PyTuple_SetItem (ret, 1, py_unacceptable); + return ret; +} +%% +override soup_header_parse_param_list kwargs +static PyObject * +_wrap_soup_header_parse_param_list (PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "header", NULL }; + char *header; + GHashTable *params; + PyObject *ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "s:soup.header_parse_quality_list", + kwlist, &header)) + return NULL; + + params = soup_header_parse_param_list (header); + ret = pysoup_ghashtable_to_pydict (params); + soup_header_free_param_list (params); + return ret; +} +%% +override soup_headers_parse_request kwargs +static PyObject * +_wrap_soup_headers_parse_request (PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "str", "len", NULL }; + char *str; + int len = -1, status_code; + SoupMessageHeaders *headers; + char *method, *path; + SoupHTTPVersion version; + PyObject *ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "s|i:soup.headers_parse_request", + kwlist, &str, &len)) + return NULL; + if (len == -1) + len = strlen (str); + + headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_REQUEST); + status_code = soup_headers_parse_request (str, len, headers, + &method, &path, &version); + + ret = PyTuple_New (5); + PyTuple_SetItem (ret, 0, PyInt_FromLong (status_code)); + if (SOUP_STATUS_IS_SUCCESSFUL (status_code)) { + PyTuple_SetItem (ret, 1, pyg_boxed_new (SOUP_TYPE_MESSAGE_HEADERS, + headers, FALSE, TRUE)); + PyTuple_SetItem (ret, 2, PyString_FromString (method)); + PyTuple_SetItem (ret, 3, PyString_FromString (path)); + PyTuple_SetItem (ret, 4, pyg_enum_from_gtype (SOUP_TYPE_HTTP_VERSION, version)); + + g_free (method); + g_free (path); + } else { + soup_message_headers_free (headers); + + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 1, Py_None); + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 2, Py_None); + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 3, Py_None); + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 4, Py_None); + } + + return ret; +} +%% +override soup_headers_parse_response kwargs +static PyObject * +_wrap_soup_headers_parse_response (PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "str", "len", NULL }; + char *str; + int len = -1; + SoupMessageHeaders *headers; + SoupHTTPVersion version; + guint status_code; + char *reason_phrase; + gboolean ok; + PyObject *ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "s|i:soup.headers_parse_response", + kwlist, &str, &len)) + return NULL; + if (len == -1) + len = strlen (str); + + headers = soup_message_headers_new (SOUP_MESSAGE_HEADERS_RESPONSE); + ok = soup_headers_parse_response (str, len, headers, + &version, &status_code, &reason_phrase); + + ret = PyTuple_New (4); + if (ok) { + PyTuple_SetItem (ret, 0, pyg_boxed_new (SOUP_TYPE_MESSAGE_HEADERS, + headers, FALSE, TRUE)); + PyTuple_SetItem (ret, 1, pyg_enum_from_gtype (SOUP_TYPE_HTTP_VERSION, version)); + PyTuple_SetItem (ret, 2, PyInt_FromLong (status_code)); + PyTuple_SetItem (ret, 3, PyString_FromString (reason_phrase)); + + g_free (reason_phrase); + } else { + soup_message_headers_free (headers); + + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 0, Py_None); + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 1, Py_None); + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 2, Py_None); + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 3, Py_None); + } + + return ret; +} +%% +override soup_headers_parse_status_line kwargs +static PyObject * +_wrap_soup_headers_parse_status_line (PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "status_line", NULL }; + char *status_line; + SoupHTTPVersion version; + guint status_code; + char *reason_phrase; + gboolean ok; + PyObject *ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "s:soup.headers_parse_response", + kwlist, &status_line)) + return NULL; + + ok = soup_headers_parse_status_line (status_line, + &version, &status_code, + &reason_phrase); + + ret = PyTuple_New (3); + if (ok) { + PyTuple_SetItem (ret, 0, pyg_enum_from_gtype (SOUP_TYPE_HTTP_VERSION, version)); + PyTuple_SetItem (ret, 1, PyInt_FromLong (status_code)); + PyTuple_SetItem (ret, 2, PyString_FromString (reason_phrase)); + + g_free (reason_phrase); + } else { + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 0, Py_None); + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 1, Py_None); + Py_INCREF(Py_None); + PyTuple_SetItem (ret, 2, Py_None); + } + + return ret; +} diff --git a/python/soup-xmlrpc.override b/python/soup-xmlrpc.override new file mode 100644 index 0000000..50aa316 --- /dev/null +++ b/python/soup-xmlrpc.override @@ -0,0 +1,134 @@ +/* -*- Mode: C; c-basic-offset: 4 -*- + * + * soup-xmlrpc.override: overrides for soup-xmlrpc + */ +%% +ignore + soup_xmlrpc_extract_method_response +%% +override soup_xmlrpc_build_method_call + +static char * +pysoup_xmlrpc_build_method_call (PyObject *args, int name_arg) +{ + PyObject *py_method_name, *py_param; + Py_ssize_t size, i; + char *method_name, *method_call; + GValueArray *params; + GValue value; + + size = PyTuple_Size (args); + if (size <= name_arg) { + PyErr_SetString (PyExc_TypeError, "soup.xmlrpc_build_method_call: 'method_name' not specified"); + return NULL; + } + py_method_name = PyTuple_GetItem (args, name_arg); + if (!PyString_Check (py_method_name)) { + PyErr_SetString (PyExc_TypeError, "soup.xmlrpc_build_method_call: 'method_name' must be a string"); + return NULL; + } + method_name = PyString_AsString (py_method_name); + + params = g_value_array_new (size - name_arg - 1); + for (i = name_arg + 1; i < size; i++) { + py_param = PyTuple_GetItem (args, i); + if (!pysoup_value_from_pyobject (&value, py_param)) { + PyErr_Format (PyExc_TypeError, "soup.xmlrpc_build_method_call: parameter %d could not be converted", (int)i); + g_value_array_free (params); + return NULL; + } + g_value_array_append (params, &value); + g_value_unset (&value); + } + + method_call = soup_xmlrpc_build_method_call (method_name, params->values, + params->n_values); + g_value_array_free (params); + + return method_call; +} + +static PyObject * +_wrap_soup_xmlrpc_build_method_call (PyObject *self, PyObject *args) +{ + char *method_call; + PyObject *py_ret; + + method_call = pysoup_xmlrpc_build_method_call (args, 0); + if (!method_call) + return NULL; + + py_ret = PyString_FromString (method_call); + g_free (method_call); + + return py_ret; +} +%% +override soup_xmlrpc_request_new +static PyObject * +_wrap_soup_xmlrpc_request_new (PyObject *self, PyObject *args) +{ + char *uri, *method_call; + SoupMessage *msg; + PyObject *py_uri; + + if (PyTuple_Size (args) < 1) { + PyErr_SetString (PyExc_TypeError, "soup.xmlrpc_request_new: 'uri' not specified"); + return NULL; + } + py_uri = PyTuple_GetItem (args, 0); + if (!PyString_Check (py_uri)) { + PyErr_SetString (PyExc_TypeError, "soup.xmlrpc_request_new: 'uri' must be a string"); + return NULL; + } + uri = PyString_AsString (py_uri); + + method_call = pysoup_xmlrpc_build_method_call (args, 1); + if (!method_call) + return NULL; + + msg = soup_message_new ("POST", uri); + soup_message_set_request (msg, "text/xml", SOUP_MEMORY_TAKE, + method_call, strlen (method_call)); + + return pygobject_new (G_OBJECT (msg)); +} +%% +override soup_xmlrpc_parse_method_response kwargs +static PyObject * +_wrap_soup_xmlrpc_parse_method_response (PyObject *self, PyObject *args, PyObject *kwargs) +{ + static char *kwlist[] = { "method_response", NULL }; + PyObject *py_method_response; + char *method_response; + Py_ssize_t length; + GError *error = NULL; + GValue value; + PyObject *py_ret; + + if (!PyArg_ParseTupleAndKeywords (args, kwargs, + "O:soup.xmlrpc_parse_method_response", + kwlist, &py_method_response)) + return NULL; + + if (PyString_Check (py_method_response)) + PyString_AsStringAndSize (py_method_response, &method_response, &length); + else if (pygobject_check (py_method_response, &PySoupMessage_Type)) { + SoupMessage *msg = (SoupMessage *)(((PyGObject *)py_method_response)->obj); + method_response = (char *)msg->response_body->data; + length = msg->response_body->length; + } else { + PyErr_SetString (PyExc_TypeError, "method_response should be a string or SoupMessage"); + return NULL; + } + + if (!soup_xmlrpc_parse_method_response (method_response, length, + &value, &error)) { + pyg_error_check (&error); + return NULL; + } + + py_ret = pysoup_value_to_pyobject (&value); + g_value_unset (&value); + return py_ret; +}