<MACRO>
<NAME>SOUP_TYPE_SESSION_SYNC</NAME>
#define SOUP_TYPE_SESSION_SYNC            (soup_session_sync_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_SYNC</NAME>
#define SOUP_SESSION_SYNC(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SESSION_SYNC, SoupSessionSync))
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_SYNC_CLASS</NAME>
#define SOUP_SESSION_SYNC_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SESSION_SYNC</NAME>
#define SOUP_IS_SESSION_SYNC(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SESSION_SYNC))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SESSION_SYNC_CLASS</NAME>
#define SOUP_IS_SESSION_SYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_SYNC))
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_SYNC_GET_CLASS</NAME>
#define SOUP_SESSION_SYNC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncClass))
</MACRO>
<STRUCT>
<NAME>SoupSessionSync</NAME>
struct _SoupSessionSync {
	SoupSession parent;

};
</STRUCT>
<STRUCT>
<NAME>SoupSessionSyncClass</NAME>
typedef struct {
	SoupSessionClass parent_class;

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupSessionSyncClass;
</STRUCT>
<FUNCTION>
<NAME>soup_session_sync_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_session_sync_new</NAME>
<RETURNS>SoupSession *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_session_sync_new_with_options</NAME>
<RETURNS>SoupSession *</RETURNS>
const char *optname1,...
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_SESSION</NAME>
#define SOUP_TYPE_SESSION            (soup_session_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_SESSION</NAME>
#define SOUP_SESSION(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SESSION, SoupSession))
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_CLASS</NAME>
#define SOUP_SESSION_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SESSION, SoupSessionClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SESSION</NAME>
#define SOUP_IS_SESSION(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SESSION))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SESSION_CLASS</NAME>
#define SOUP_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION))
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_GET_CLASS</NAME>
#define SOUP_SESSION_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION, SoupSessionClass))
</MACRO>
<USER_FUNCTION>
<NAME>SoupSessionCallback</NAME>
<RETURNS>void </RETURNS>
SoupSession           *session,
				     SoupMessage           *msg,
				     gpointer               user_data
</USER_FUNCTION>
<STRUCT>
<NAME>SoupSession</NAME>
struct _SoupSession {
	GObject parent;

};
</STRUCT>
<STRUCT>
<NAME>SoupSessionClass</NAME>
typedef struct {
	GObjectClass parent_class;

	/* signals */
	void (*request_started) (SoupSession *session, SoupMessage *msg,
				 SoupSocket *socket);
	void (*authenticate)    (SoupSession *session, SoupMessage *msg,
				 SoupAuth *auth, gboolean retrying);

	/* methods */
	void  (*queue_message)   (SoupSession *session, SoupMessage *msg,
				  SoupSessionCallback callback,
				  gpointer user_data);
	void  (*requeue_message) (SoupSession *session, SoupMessage *msg);
	guint (*send_message)    (SoupSession *session, SoupMessage *msg);

	void  (*cancel_message)  (SoupSession *session, SoupMessage *msg,
				  guint status_code);

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupSessionClass;
</STRUCT>
<FUNCTION>
<NAME>soup_session_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_SESSION_PROXY_URI</NAME>
#define SOUP_SESSION_PROXY_URI          "proxy-uri"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_MAX_CONNS</NAME>
#define SOUP_SESSION_MAX_CONNS          "max-conns"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_MAX_CONNS_PER_HOST</NAME>
#define SOUP_SESSION_MAX_CONNS_PER_HOST "max-conns-per-host"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_USE_NTLM</NAME>
#define SOUP_SESSION_USE_NTLM           "use-ntlm"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_SSL_CA_FILE</NAME>
#define SOUP_SESSION_SSL_CA_FILE        "ssl-ca-file"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_ASYNC_CONTEXT</NAME>
#define SOUP_SESSION_ASYNC_CONTEXT      "async-context"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_TIMEOUT</NAME>
#define SOUP_SESSION_TIMEOUT            "timeout"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_USER_AGENT</NAME>
#define SOUP_SESSION_USER_AGENT         "user-agent"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_IDLE_TIMEOUT</NAME>
#define SOUP_SESSION_IDLE_TIMEOUT       "idle-timeout"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_ADD_FEATURE</NAME>
#define SOUP_SESSION_ADD_FEATURE            "add-feature"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_ADD_FEATURE_BY_TYPE</NAME>
#define SOUP_SESSION_ADD_FEATURE_BY_TYPE    "add-feature-by-type"
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_REMOVE_FEATURE_BY_TYPE</NAME>
#define SOUP_SESSION_REMOVE_FEATURE_BY_TYPE "remove-feature-by-type"
</MACRO>
<FUNCTION>
<NAME>soup_session_get_async_context</NAME>
<RETURNS>GMainContext   *</RETURNS>
SoupSession           *session
</FUNCTION>
<FUNCTION>
<NAME>soup_session_queue_message</NAME>
<RETURNS>void            </RETURNS>
SoupSession           *session,SoupMessage           *msg,SoupSessionCallback    callback,gpointer               user_data
</FUNCTION>
<FUNCTION>
<NAME>soup_session_requeue_message</NAME>
<RETURNS>void            </RETURNS>
SoupSession           *session,SoupMessage           *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_session_send_message</NAME>
<RETURNS>guint           </RETURNS>
SoupSession           *session,SoupMessage           *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_session_pause_message</NAME>
<RETURNS>void            </RETURNS>
SoupSession           *session,SoupMessage           *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_session_unpause_message</NAME>
<RETURNS>void            </RETURNS>
SoupSession           *session,SoupMessage           *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_session_cancel_message</NAME>
<RETURNS>void            </RETURNS>
SoupSession           *session,SoupMessage           *msg,guint                  status_code
</FUNCTION>
<FUNCTION>
<NAME>soup_session_abort</NAME>
<RETURNS>void            </RETURNS>
SoupSession           *session
</FUNCTION>
<FUNCTION>
<NAME>soup_session_add_feature</NAME>
<RETURNS>void                </RETURNS>
SoupSession        *session,SoupSessionFeature *feature
</FUNCTION>
<FUNCTION>
<NAME>soup_session_add_feature_by_type</NAME>
<RETURNS>void                </RETURNS>
SoupSession        *session,GType               feature_type
</FUNCTION>
<FUNCTION>
<NAME>soup_session_remove_feature</NAME>
<RETURNS>void                </RETURNS>
SoupSession        *session,SoupSessionFeature *feature
</FUNCTION>
<FUNCTION>
<NAME>soup_session_remove_feature_by_type</NAME>
<RETURNS>void                </RETURNS>
SoupSession        *session,GType               feature_type
</FUNCTION>
<FUNCTION>
<NAME>soup_session_get_features</NAME>
<RETURNS>GSList             *</RETURNS>
SoupSession        *session,GType               feature_type
</FUNCTION>
<FUNCTION>
<NAME>soup_session_get_feature</NAME>
<RETURNS>SoupSessionFeature *</RETURNS>
SoupSession        *session,GType               feature_type
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_SESSION_FEATURE</NAME>
#define SOUP_TYPE_SESSION_FEATURE            (soup_session_feature_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_FEATURE</NAME>
#define SOUP_SESSION_FEATURE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SESSION_FEATURE, SoupSessionFeature))
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_FEATURE_CLASS</NAME>
#define SOUP_SESSION_FEATURE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SESSION_FEATURE, SoupSessionFeatureInterface))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SESSION_FEATURE</NAME>
#define SOUP_IS_SESSION_FEATURE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SESSION_FEATURE))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SESSION_FEATURE_CLASS</NAME>
#define SOUP_IS_SESSION_FEATURE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SESSION_FEATURE))
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_FEATURE_GET_CLASS</NAME>
#define SOUP_SESSION_FEATURE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SOUP_TYPE_SESSION_FEATURE, SoupSessionFeatureInterface))
</MACRO>
<STRUCT>
<NAME>SoupSessionFeatureInterface</NAME>
typedef struct {
	GTypeInterface parent;

	/* methods */
	void (*attach)           (SoupSessionFeature *feature,
				  SoupSession        *session);
	void (*detach)           (SoupSessionFeature *feature,
				  SoupSession        *session);

	void (*request_queued)   (SoupSessionFeature *feature,
				  SoupSession        *session,
				  SoupMessage        *msg);
	void (*request_started)  (SoupSessionFeature *feature,
				  SoupSession        *session,
				  SoupMessage        *msg,
				  SoupSocket         *socket);
	void (*request_unqueued) (SoupSessionFeature *feature,
				  SoupSession        *session,
				  SoupMessage        *msg);

} SoupSessionFeatureInterface;
</STRUCT>
<FUNCTION>
<NAME>soup_session_feature_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_session_feature_attach</NAME>
<RETURNS>void </RETURNS>
SoupSessionFeature *feature,SoupSession        *session
</FUNCTION>
<FUNCTION>
<NAME>soup_session_feature_detach</NAME>
<RETURNS>void </RETURNS>
SoupSessionFeature *feature,SoupSession        *session
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_SERVER</NAME>
#define SOUP_TYPE_SERVER            (soup_server_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_SERVER</NAME>
#define SOUP_SERVER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SERVER, SoupServer))
</MACRO>
<MACRO>
<NAME>SOUP_SERVER_CLASS</NAME>
#define SOUP_SERVER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SERVER, SoupServerClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SERVER</NAME>
#define SOUP_IS_SERVER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SERVER))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SERVER_CLASS</NAME>
#define SOUP_IS_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SERVER))
</MACRO>
<MACRO>
<NAME>SOUP_SERVER_GET_CLASS</NAME>
#define SOUP_SERVER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SERVER, SoupServerClass))
</MACRO>
<TYPEDEF>
<NAME>SoupClientContext</NAME>
typedef struct SoupClientContext SoupClientContext;
</TYPEDEF>
<FUNCTION>
<NAME>soup_client_context_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_CLIENT_CONTEXT</NAME>
#define SOUP_TYPE_CLIENT_CONTEXT (soup_client_context_get_type ())
</MACRO>
<STRUCT>
<NAME>SoupServer</NAME>
struct _SoupServer {
	GObject parent;

};
</STRUCT>
<STRUCT>
<NAME>SoupServerClass</NAME>
typedef struct {
	GObjectClass parent_class;

	/* signals */
	void (*request_started)  (SoupServer *server, SoupMessage *msg,
				  SoupClientContext *client);
	void (*request_read)     (SoupServer *server, SoupMessage *msg,
				  SoupClientContext *client);
	void (*request_finished) (SoupServer *server, SoupMessage *msg,
				  SoupClientContext *client);
	void (*request_aborted)  (SoupServer *server, SoupMessage *msg,
				  SoupClientContext *client);

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupServerClass;
</STRUCT>
<FUNCTION>
<NAME>soup_server_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<USER_FUNCTION>
<NAME>SoupServerCallback</NAME>
<RETURNS>void </RETURNS>
SoupServer        *server,
				    SoupMessage       *msg, 
				    const char        *path,
				    GHashTable        *query,
				    SoupClientContext *client,
				    gpointer           user_data
</USER_FUNCTION>
<MACRO>
<NAME>SOUP_SERVER_PORT</NAME>
#define SOUP_SERVER_PORT          "port"
</MACRO>
<MACRO>
<NAME>SOUP_SERVER_INTERFACE</NAME>
#define SOUP_SERVER_INTERFACE     "interface"
</MACRO>
<MACRO>
<NAME>SOUP_SERVER_SSL_CERT_FILE</NAME>
#define SOUP_SERVER_SSL_CERT_FILE "ssl-cert-file"
</MACRO>
<MACRO>
<NAME>SOUP_SERVER_SSL_KEY_FILE</NAME>
#define SOUP_SERVER_SSL_KEY_FILE  "ssl-key-file"
</MACRO>
<MACRO>
<NAME>SOUP_SERVER_ASYNC_CONTEXT</NAME>
#define SOUP_SERVER_ASYNC_CONTEXT "async-context"
</MACRO>
<MACRO>
<NAME>SOUP_SERVER_RAW_PATHS</NAME>
#define SOUP_SERVER_RAW_PATHS     "raw-paths"
</MACRO>
<MACRO>
<NAME>SOUP_SERVER_SERVER_HEADER</NAME>
#define SOUP_SERVER_SERVER_HEADER "server-header"
</MACRO>
<FUNCTION>
<NAME>soup_server_new</NAME>
<RETURNS>SoupServer        *</RETURNS>
const char            *optname1,...
</FUNCTION>
<FUNCTION>
<NAME>soup_server_is_https</NAME>
<RETURNS>gboolean           </RETURNS>
SoupServer            *server
</FUNCTION>
<FUNCTION>
<NAME>soup_server_get_port</NAME>
<RETURNS>guint              </RETURNS>
SoupServer            *server
</FUNCTION>
<FUNCTION>
<NAME>soup_server_get_listener</NAME>
<RETURNS>SoupSocket        *</RETURNS>
SoupServer            *server
</FUNCTION>
<FUNCTION>
<NAME>soup_server_run</NAME>
<RETURNS>void               </RETURNS>
SoupServer            *server
</FUNCTION>
<FUNCTION>
<NAME>soup_server_run_async</NAME>
<RETURNS>void               </RETURNS>
SoupServer            *server
</FUNCTION>
<FUNCTION>
<NAME>soup_server_quit</NAME>
<RETURNS>void               </RETURNS>
SoupServer            *server
</FUNCTION>
<FUNCTION>
<NAME>soup_server_get_async_context</NAME>
<RETURNS>GMainContext      *</RETURNS>
SoupServer         *server
</FUNCTION>
<FUNCTION>
<NAME>soup_server_add_handler</NAME>
<RETURNS>void               </RETURNS>
SoupServer            *server,const char            *path,SoupServerCallback     callback,gpointer               user_data,GDestroyNotify         destroy
</FUNCTION>
<FUNCTION>
<NAME>soup_server_remove_handler</NAME>
<RETURNS>void               </RETURNS>
SoupServer            *server,const char            *path
</FUNCTION>
<FUNCTION>
<NAME>soup_server_add_auth_domain</NAME>
<RETURNS>void               </RETURNS>
SoupServer     *server,SoupAuthDomain *auth_domain
</FUNCTION>
<FUNCTION>
<NAME>soup_server_remove_auth_domain</NAME>
<RETURNS>void               </RETURNS>
SoupServer     *server,SoupAuthDomain *auth_domain
</FUNCTION>
<FUNCTION>
<NAME>soup_server_pause_message</NAME>
<RETURNS>void               </RETURNS>
SoupServer           *server,SoupMessage          *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_server_unpause_message</NAME>
<RETURNS>void               </RETURNS>
SoupServer           *server,SoupMessage          *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_client_context_get_socket</NAME>
<RETURNS>SoupSocket     *</RETURNS>
SoupClientContext *client
</FUNCTION>
<FUNCTION>
<NAME>soup_client_context_get_address</NAME>
<RETURNS>SoupAddress    *</RETURNS>
SoupClientContext *client
</FUNCTION>
<FUNCTION>
<NAME>soup_client_context_get_host</NAME>
<RETURNS>const char     *</RETURNS>
SoupClientContext *client
</FUNCTION>
<FUNCTION>
<NAME>soup_client_context_get_auth_domain</NAME>
<RETURNS>SoupAuthDomain *</RETURNS>
SoupClientContext *client
</FUNCTION>
<FUNCTION>
<NAME>soup_client_context_get_auth_user</NAME>
<RETURNS>const char     *</RETURNS>
SoupClientContext *client
</FUNCTION>
<STRUCT>
<NAME>SoupAddress</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupAuth</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupAuthDomain</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupCookie</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupDate</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupMessage</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupServer</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupSession</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupSessionAsync</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupSessionFeature</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupSessionSync</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupSocket</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupURI</NAME>
</STRUCT>
<STRUCT>
<NAME>SoupCookie</NAME>
struct _SoupCookie {
	char     *name;
	char     *value;
	char     *domain;
	char     *path;
	SoupDate *expires;
	gboolean  secure;
	gboolean  http_only;
};
</STRUCT>
<FUNCTION>
<NAME>soup_cookie_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_COOKIE</NAME>
#define SOUP_TYPE_COOKIE (soup_cookie_get_type())
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_MAX_AGE_ONE_HOUR</NAME>
#define SOUP_COOKIE_MAX_AGE_ONE_HOUR (60 * 60)
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_MAX_AGE_ONE_DAY</NAME>
#define SOUP_COOKIE_MAX_AGE_ONE_DAY  (SOUP_COOKIE_MAX_AGE_ONE_HOUR * 24)
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_MAX_AGE_ONE_WEEK</NAME>
#define SOUP_COOKIE_MAX_AGE_ONE_WEEK (SOUP_COOKIE_MAX_AGE_ONE_DAY * 7)
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_MAX_AGE_ONE_YEAR</NAME>
#define SOUP_COOKIE_MAX_AGE_ONE_YEAR (SOUP_COOKIE_MAX_AGE_ONE_DAY * 365.2422)
</MACRO>
<FUNCTION>
<NAME>soup_cookie_new</NAME>
<RETURNS>SoupCookie *</RETURNS>
const char  *name,const char  *value,const char  *domain,const char  *path,int          max_age
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_parse</NAME>
<RETURNS>SoupCookie *</RETURNS>
const char  *header,SoupURI     *origin
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_copy</NAME>
<RETURNS>SoupCookie *</RETURNS>
SoupCookie  *cookie
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_set_name</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie,const char  *name
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_set_value</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie,const char  *value
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_set_domain</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie,const char  *domain
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_set_path</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie,const char  *path
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_set_max_age</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie,int          max_age
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_set_expires</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie,SoupDate    *expires
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_set_secure</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie,gboolean     secure
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_set_http_only</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie,gboolean     http_only
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_to_set_cookie_header</NAME>
<RETURNS>char       *</RETURNS>
SoupCookie  *cookie
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_to_cookie_header</NAME>
<RETURNS>char       *</RETURNS>
SoupCookie  *cookie
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_applies_to_uri</NAME>
<RETURNS>gboolean    </RETURNS>
SoupCookie  *cookie,SoupURI     *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_equal</NAME>
<RETURNS>gboolean    </RETURNS>
SoupCookie  *cookie1,SoupCookie  *cookie2
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_free</NAME>
<RETURNS>void        </RETURNS>
SoupCookie  *cookie
</FUNCTION>
<FUNCTION>
<NAME>soup_cookies_from_response</NAME>
<RETURNS>GSList     *</RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_cookies_from_request</NAME>
<RETURNS>GSList     *</RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_cookies_to_response</NAME>
<RETURNS>void        </RETURNS>
GSList      *cookies,SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_cookies_to_request</NAME>
<RETURNS>void        </RETURNS>
GSList      *cookies,SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_cookies_free</NAME>
<RETURNS>void        </RETURNS>
GSList      *cookies
</FUNCTION>
<FUNCTION>
<NAME>soup_cookies_to_cookie_header</NAME>
<RETURNS>char       *</RETURNS>
GSList      *cookies
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_PROXY_URI_RESOLVER</NAME>
#define SOUP_TYPE_PROXY_URI_RESOLVER            (soup_proxy_uri_resolver_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_PROXY_URI_RESOLVER</NAME>
#define SOUP_PROXY_URI_RESOLVER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), SOUP_TYPE_PROXY_URI_RESOLVER, SoupProxyURIResolver))
</MACRO>
<MACRO>
<NAME>SOUP_PROXY_URI_RESOLVER_CLASS</NAME>
#define SOUP_PROXY_URI_RESOLVER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_PROXY_URI_RESOLVER, SoupProxyURIResolverInterface))
</MACRO>
<MACRO>
<NAME>SOUP_IS_PROXY_URI_RESOLVER</NAME>
#define SOUP_IS_PROXY_URI_RESOLVER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), SOUP_TYPE_PROXY_URI_RESOLVER))
</MACRO>
<MACRO>
<NAME>SOUP_IS_PROXY_URI_RESOLVER_CLASS</NAME>
#define SOUP_IS_PROXY_URI_RESOLVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_PROXY_URI_RESOLVER))
</MACRO>
<MACRO>
<NAME>SOUP_PROXY_URI_RESOLVER_GET_CLASS</NAME>
#define SOUP_PROXY_URI_RESOLVER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SOUP_TYPE_PROXY_URI_RESOLVER, SoupProxyURIResolverInterface))
</MACRO>
<STRUCT>
<NAME>SoupProxyURIResolver</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>SoupProxyURIResolverCallback</NAME>
<RETURNS>void </RETURNS>
SoupProxyURIResolver *,
					      guint, SoupURI *, gpointer
</USER_FUNCTION>
<STRUCT>
<NAME>SoupProxyURIResolverInterface</NAME>
typedef struct {
	GTypeInterface base;

	/* virtual methods */
	void (*get_proxy_uri_async) (SoupProxyURIResolver *, SoupURI *,
				     GMainContext *, GCancellable *,
				     SoupProxyURIResolverCallback, gpointer);
	guint (*get_proxy_uri_sync) (SoupProxyURIResolver *, SoupURI *,
				     GCancellable *, SoupURI **);

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupProxyURIResolverInterface;
</STRUCT>
<FUNCTION>
<NAME>soup_proxy_uri_resolver_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_proxy_uri_resolver_get_proxy_uri_async</NAME>
<RETURNS>void  </RETURNS>
SoupProxyURIResolver  *proxy_uri_resolver,SoupURI               *uri,GMainContext          *async_context,GCancellable          *cancellable,SoupProxyURIResolverCallback callback,gpointer                user_data
</FUNCTION>
<FUNCTION>
<NAME>soup_proxy_uri_resolver_get_proxy_uri_sync</NAME>
<RETURNS>guint </RETURNS>
SoupProxyURIResolver  *proxy_uri_resolver,SoupURI               *uri,GCancellable          *cancellable,SoupURI              **proxy_uri
</FUNCTION>
<FUNCTION>
<NAME>soup_add_io_watch</NAME>
<RETURNS>GSource           *</RETURNS>
GMainContext *async_context,GIOChannel   *chan,GIOCondition  condition,GIOFunc       function,gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>soup_add_idle</NAME>
<RETURNS>GSource           *</RETURNS>
GMainContext *async_context,GSourceFunc   function,gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>soup_add_completion</NAME>
<RETURNS>GSource           *</RETURNS>
GMainContext *async_context,GSourceFunc   function,gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>soup_add_timeout</NAME>
<RETURNS>GSource           *</RETURNS>
GMainContext *async_context,guint         interval,GSourceFunc   function,gpointer      data
</FUNCTION>
<FUNCTION>
<NAME>soup_str_case_hash</NAME>
<RETURNS>guint              </RETURNS>
gconstpointer key
</FUNCTION>
<FUNCTION>
<NAME>soup_str_case_equal</NAME>
<RETURNS>gboolean           </RETURNS>
gconstpointer v1,gconstpointer v2
</FUNCTION>
<VARIABLE>
<NAME>soup_ssl_supported</NAME>
extern const gboolean soup_ssl_supported;
</VARIABLE>
<MACRO>
<NAME>SOUP_SSL_ERROR</NAME>
#define SOUP_SSL_ERROR soup_ssl_error_quark()
</MACRO>
<FUNCTION>
<NAME>soup_ssl_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>SoupSSLError</NAME>
typedef enum {
	SOUP_SSL_ERROR_HANDSHAKE_NEEDS_READ,
	SOUP_SSL_ERROR_HANDSHAKE_NEEDS_WRITE,
	SOUP_SSL_ERROR_CERTIFICATE
} SoupSSLError;
</ENUM>
<FUNCTION>
<NAME>g_warn_message</NAME>
<RETURNS>void </RETURNS>
const char     *domain,const char     *file,int             line,const char     *func,const char     *warnexpr
</FUNCTION>
<MACRO>
<NAME>g_warn_if_fail</NAME>
#define g_warn_if_fail(expr)    do { if G_LIKELY (expr) ; else \
                                       g_warn_message (G_LOG_DOMAIN, __FILE__, __LINE__, G_STRFUNC, #expr); } while (0)
</MACRO>
<FUNCTION>
<NAME>g_once_impl</NAME>
<RETURNS>gpointer </RETURNS>
GOnce *once, GThreadFunc func, gpointer arg
</FUNCTION>
<FUNCTION>
<NAME>g_once_init_enter</NAME>
<RETURNS>gboolean  </RETURNS>
volatile gsize *value_location
</FUNCTION>
<FUNCTION>
<NAME>g_once_init_enter_impl</NAME>
<RETURNS>gboolean				</RETURNS>
volatile gsize *value_location
</FUNCTION>
<FUNCTION>
<NAME>g_once_init_leave</NAME>
<RETURNS>void                    </RETURNS>
volatile gsize *value_location,gsize initialization_value
</FUNCTION>
<FUNCTION>
<NAME>G_LIKELY</NAME>
<RETURNS>if </RETURNS>
g_atomic_pointer_get ((void*volatile*) value_location) != NULL)return FALSE;elsereturn g_once_init_enter_impl (value_location
</FUNCTION>
<TYPEDEF>
<NAME>SoupCancellable</NAME>
typedef struct _GCancellable        SoupCancellable;
</TYPEDEF>
<TYPEDEF>
<NAME>SoupCancellableClass</NAME>
typedef struct _GCancellableClass   SoupCancellableClass;
</TYPEDEF>
<FUNCTION>
<NAME>g_cancellable_new</NAME>
<RETURNS>SoupCancellable *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>g_cancellable_is_cancelled</NAME>
<RETURNS>gboolean      </RETURNS>
SoupCancellable  *cancellable
</FUNCTION>
<FUNCTION>
<NAME>g_cancellable_cancel</NAME>
<RETURNS>void		  </RETURNS>
SoupCancellable *cancellable
</FUNCTION>
<FUNCTION>
<NAME>g_strcmp0</NAME>
<RETURNS>int			  </RETURNS>
const char *str1, const char *str2
</FUNCTION>
<MACRO>
<NAME>SOUP_PROXY_RESOLVER_GNOME</NAME>
#define SOUP_PROXY_RESOLVER_GNOME(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), SOUP_TYPE_PROXY_RESOLVER_GNOME, SoupProxyResolverGNOME))
</MACRO>
<MACRO>
<NAME>SOUP_PROXY_RESOLVER_GNOME_CLASS</NAME>
#define SOUP_PROXY_RESOLVER_GNOME_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_PROXY_RESOLVER_GNOME, SoupProxyResolverGNOMEClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_PROXY_RESOLVER_GNOME</NAME>
#define SOUP_IS_PROXY_RESOLVER_GNOME(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), SOUP_TYPE_PROXY_RESOLVER_GNOME))
</MACRO>
<MACRO>
<NAME>SOUP_IS_PROXY_RESOLVER_GNOME_CLASS</NAME>
#define SOUP_IS_PROXY_RESOLVER_GNOME_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_PROXY_RESOLVER_GNOME))
</MACRO>
<MACRO>
<NAME>SOUP_PROXY_RESOLVER_GNOME_GET_CLASS</NAME>
#define SOUP_PROXY_RESOLVER_GNOME_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_PROXY_RESOLVER_GNOME, SoupProxyResolverGNOMEClass))
</MACRO>
<STRUCT>
<NAME>SoupProxyResolverGNOME</NAME>
typedef struct {
	GObject parent;

} SoupProxyResolverGNOME;
</STRUCT>
<STRUCT>
<NAME>SoupProxyResolverGNOMEClass</NAME>
typedef struct {
	GObjectClass parent_class;

} SoupProxyResolverGNOMEClass;
</STRUCT>
<STRUCT>
<NAME>SoupDate</NAME>
struct _SoupDate {
	int      year;
	int      month;
	int      day;

	int      hour;
	int      minute;
	int      second;

	gboolean utc;
	int      offset;
};
</STRUCT>
<ENUM>
<NAME>SoupDateFormat</NAME>
typedef enum {
	SOUP_DATE_HTTP = 1,
	SOUP_DATE_COOKIE,
	SOUP_DATE_RFC2822,
	SOUP_DATE_ISO8601_COMPACT,
	SOUP_DATE_ISO8601_FULL,
	SOUP_DATE_ISO8601 = SOUP_DATE_ISO8601_FULL,
	SOUP_DATE_ISO8601_XMLRPC
} SoupDateFormat;
</ENUM>
<FUNCTION>
<NAME>soup_date_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_DATE</NAME>
#define SOUP_TYPE_DATE (soup_date_get_type ())
</MACRO>
<FUNCTION>
<NAME>soup_date_new</NAME>
<RETURNS>SoupDate *</RETURNS>
int             year,int             month,int             day,int             hour,int             minute,int             second
</FUNCTION>
<FUNCTION>
<NAME>soup_date_new_from_string</NAME>
<RETURNS>SoupDate *</RETURNS>
const char     *date_string
</FUNCTION>
<FUNCTION>
<NAME>soup_date_new_from_time_t</NAME>
<RETURNS>SoupDate *</RETURNS>
time_t          when
</FUNCTION>
<FUNCTION>
<NAME>soup_date_new_from_now</NAME>
<RETURNS>SoupDate *</RETURNS>
int             offset_seconds
</FUNCTION>
<FUNCTION>
<NAME>soup_date_to_string</NAME>
<RETURNS>char     *</RETURNS>
SoupDate       *date,SoupDateFormat  format
</FUNCTION>
<FUNCTION>
<NAME>soup_date_to_time_t</NAME>
<RETURNS>time_t    </RETURNS>
SoupDate       *date
</FUNCTION>
<FUNCTION>
<NAME>soup_date_to_timeval</NAME>
<RETURNS>void      </RETURNS>
SoupDate       *date,GTimeVal       *time
</FUNCTION>
<FUNCTION>
<NAME>soup_date_is_past</NAME>
<RETURNS>gboolean  </RETURNS>
SoupDate       *date
</FUNCTION>
<FUNCTION>
<NAME>soup_date_copy</NAME>
<RETURNS>SoupDate *</RETURNS>
SoupDate       *date
</FUNCTION>
<FUNCTION>
<NAME>soup_date_free</NAME>
<RETURNS>void      </RETURNS>
SoupDate       *date
</FUNCTION>
<STRUCT>
<NAME>SoupURI</NAME>
struct _SoupURI {
	const char *scheme;

	char       *user;
	char       *password;

	char       *host;
	guint       port;

	char       *path;
	char       *query;

	char       *fragment;
};
</STRUCT>
<FUNCTION>
<NAME>soup_uri_get_type</NAME>
<RETURNS>GType     </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_URI</NAME>
#define SOUP_TYPE_URI (soup_uri_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_HTTP</NAME>
#define SOUP_URI_SCHEME_HTTP  (_SOUP_URI_SCHEME_HTTP ? _SOUP_URI_SCHEME_HTTP : (_SOUP_URI_SCHEME_HTTP = g_intern_static_string ("http")))
</MACRO>
<MACRO>
<NAME>SOUP_URI_SCHEME_HTTPS</NAME>
#define SOUP_URI_SCHEME_HTTPS (_SOUP_URI_SCHEME_HTTPS ? _SOUP_URI_SCHEME_HTTPS : (_SOUP_URI_SCHEME_HTTPS = g_intern_static_string ("https")))
</MACRO>
<FUNCTION>
<NAME>soup_uri_new_with_base</NAME>
<RETURNS>SoupURI  *</RETURNS>
SoupURI    *base,const char *uri_string
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_new</NAME>
<RETURNS>SoupURI  *</RETURNS>
const char *uri_string
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_to_string</NAME>
<RETURNS>char     *</RETURNS>
SoupURI    *uri,gboolean    just_path_and_query
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_copy</NAME>
<RETURNS>SoupURI  *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_equal</NAME>
<RETURNS>gboolean  </RETURNS>
SoupURI    *uri1,SoupURI    *uri2
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_free</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_encode</NAME>
<RETURNS>char     *</RETURNS>
const char *part,const char *escape_extra
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_decode</NAME>
<RETURNS>char     *</RETURNS>
const char *part
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_normalize</NAME>
<RETURNS>char     *</RETURNS>
const char *part,const char *unescape_extra
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_uses_default_port</NAME>
<RETURNS>gboolean  </RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_scheme</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,const char *scheme
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_user</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,const char *user
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_password</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,const char *password
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_host</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,const char *host
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_port</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,guint       port
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_path</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,const char *path
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_query</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,const char *query
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_query_from_form</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,GHashTable *form
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_query_from_fields</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,const char *first_field,...
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_set_fragment</NAME>
<RETURNS>void      </RETURNS>
SoupURI    *uri,const char *fragment
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_copy_host</NAME>
<RETURNS>SoupURI  *</RETURNS>
SoupURI    *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_host_hash</NAME>
<RETURNS>guint     </RETURNS>
gconstpointer key
</FUNCTION>
<FUNCTION>
<NAME>soup_uri_host_equal</NAME>
<RETURNS>gboolean  </RETURNS>
gconstpointer v1,gconstpointer v2
</FUNCTION>
<MACRO>
<NAME>SOUP_URI_VALID_FOR_HTTP</NAME>
#define   SOUP_URI_VALID_FOR_HTTP(uri) ((uri) && ((uri)->scheme == SOUP_URI_SCHEME_HTTP || (uri)->scheme == SOUP_URI_SCHEME_HTTPS) && (uri)->host)
</MACRO>
<FUNCTION>
<NAME>soup_headers_parse</NAME>
<RETURNS>gboolean    </RETURNS>
const char          *str,int                  len,SoupMessageHeaders  *dest
</FUNCTION>
<FUNCTION>
<NAME>soup_headers_parse_request</NAME>
<RETURNS>guint       </RETURNS>
const char          *str,int                  len,SoupMessageHeaders  *req_headers,char               **req_method,char               **req_path,SoupHTTPVersion     *ver
</FUNCTION>
<FUNCTION>
<NAME>soup_headers_parse_status_line</NAME>
<RETURNS>gboolean    </RETURNS>
const char          *status_line,SoupHTTPVersion     *ver,guint               *status_code,char               **reason_phrase
</FUNCTION>
<FUNCTION>
<NAME>soup_headers_parse_response</NAME>
<RETURNS>gboolean    </RETURNS>
const char          *str,int                  len,SoupMessageHeaders  *headers,SoupHTTPVersion     *ver,guint               *status_code,char               **reason_phrase
</FUNCTION>
<FUNCTION>
<NAME>soup_header_parse_list</NAME>
<RETURNS>GSList     *</RETURNS>
const char       *header
</FUNCTION>
<FUNCTION>
<NAME>soup_header_parse_quality_list</NAME>
<RETURNS>GSList     *</RETURNS>
const char       *header,GSList          **unacceptable
</FUNCTION>
<FUNCTION>
<NAME>soup_header_free_list</NAME>
<RETURNS>void        </RETURNS>
GSList           *list
</FUNCTION>
<FUNCTION>
<NAME>soup_header_contains</NAME>
<RETURNS>gboolean    </RETURNS>
const char       *header,const char       *token
</FUNCTION>
<FUNCTION>
<NAME>soup_header_parse_param_list</NAME>
<RETURNS>GHashTable *</RETURNS>
const char       *header
</FUNCTION>
<FUNCTION>
<NAME>soup_header_parse_semi_param_list</NAME>
<RETURNS>GHashTable *</RETURNS>
const char       *header
</FUNCTION>
<FUNCTION>
<NAME>soup_header_free_param_list</NAME>
<RETURNS>void        </RETURNS>
GHashTable       *param_list
</FUNCTION>
<FUNCTION>
<NAME>soup_header_g_string_append_param</NAME>
<RETURNS>void        </RETURNS>
GString          *string,const char       *name,const char       *value
</FUNCTION>
<MACRO>
<NAME>SOUP_METHOD_OPTIONS</NAME>
#define SOUP_METHOD_OPTIONS   (_SOUP_METHOD_OPTIONS ? _SOUP_METHOD_OPTIONS : (_SOUP_METHOD_OPTIONS = g_intern_static_string ("OPTIONS")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_GET</NAME>
#define SOUP_METHOD_GET       (_SOUP_METHOD_GET ? _SOUP_METHOD_GET : (_SOUP_METHOD_GET = g_intern_static_string ("GET")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_HEAD</NAME>
#define SOUP_METHOD_HEAD      (_SOUP_METHOD_HEAD ? _SOUP_METHOD_HEAD : (_SOUP_METHOD_HEAD = g_intern_static_string ("HEAD")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_POST</NAME>
#define SOUP_METHOD_POST      (_SOUP_METHOD_POST ? _SOUP_METHOD_POST : (_SOUP_METHOD_POST = g_intern_static_string ("POST")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_PUT</NAME>
#define SOUP_METHOD_PUT       (_SOUP_METHOD_PUT ? _SOUP_METHOD_PUT : (_SOUP_METHOD_PUT = g_intern_static_string ("PUT")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_DELETE</NAME>
#define SOUP_METHOD_DELETE    (_SOUP_METHOD_DELETE ? _SOUP_METHOD_DELETE : (_SOUP_METHOD_DELETE = g_intern_static_string ("DELETE")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_TRACE</NAME>
#define SOUP_METHOD_TRACE     (_SOUP_METHOD_TRACE ? _SOUP_METHOD_TRACE : (_SOUP_METHOD_TRACE = g_intern_static_string ("TRACE")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_CONNECT</NAME>
#define SOUP_METHOD_CONNECT   (_SOUP_METHOD_CONNECT ? _SOUP_METHOD_CONNECT : (_SOUP_METHOD_CONNECT = g_intern_static_string ("CONNECT")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_PROPFIND</NAME>
#define SOUP_METHOD_PROPFIND  (_SOUP_METHOD_PROPFIND ? _SOUP_METHOD_PROPFIND : (_SOUP_METHOD_PROPFIND = g_intern_static_string ("PROPFIND")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_PROPPATCH</NAME>
#define SOUP_METHOD_PROPPATCH (_SOUP_METHOD_PROPPATCH ? _SOUP_METHOD_PROPPATCH : (_SOUP_METHOD_PROPPATCH = g_intern_static_string ("PROPPATCH")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_MKCOL</NAME>
#define SOUP_METHOD_MKCOL     (_SOUP_METHOD_MKCOL ? _SOUP_METHOD_MKCOL : (_SOUP_METHOD_MKCOL = g_intern_static_string ("MKCOL")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_COPY</NAME>
#define SOUP_METHOD_COPY      (_SOUP_METHOD_COPY ? _SOUP_METHOD_COPY : (_SOUP_METHOD_COPY = g_intern_static_string ("COPY")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_MOVE</NAME>
#define SOUP_METHOD_MOVE      (_SOUP_METHOD_MOVE ? _SOUP_METHOD_MOVE : (_SOUP_METHOD_MOVE = g_intern_static_string ("MOVE")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_LOCK</NAME>
#define SOUP_METHOD_LOCK      (_SOUP_METHOD_LOCK ? _SOUP_METHOD_LOCK : (_SOUP_METHOD_LOCK = g_intern_static_string ("LOCK")))
</MACRO>
<MACRO>
<NAME>SOUP_METHOD_UNLOCK</NAME>
#define SOUP_METHOD_UNLOCK    (_SOUP_METHOD_UNLOCK ? _SOUP_METHOD_UNLOCK : (_SOUP_METHOD_UNLOCK = g_intern_static_string ("UNLOCK")))
</MACRO>
<STRUCT>
<NAME>GHashTable</NAME>
</STRUCT>
<USER_FUNCTION>
<NAME>GHRFunc</NAME>
<RETURNS>gboolean </RETURNS>
gpointer  key,
                               gpointer  value,
                               gpointer  user_data
</USER_FUNCTION>
<STRUCT>
<NAME>GHashTableIter</NAME>
</STRUCT>
<STRUCT>
<NAME>GHashTableIter</NAME>
struct _GHashTableIter
{
  /*< private >*/
  gpointer	dummy1;
  gpointer	dummy2;
  gpointer	dummy3;
  int		dummy4;
  gboolean	dummy5;
  gpointer	dummy6;
};
</STRUCT>
<FUNCTION>
<NAME>g_hash_table_new</NAME>
<RETURNS>GHashTable*</RETURNS>
GHashFunc	    hash_func,GEqualFunc	    key_equal_func
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_new_full</NAME>
<RETURNS>GHashTable*</RETURNS>
GHashFunc	    hash_func,GEqualFunc	    key_equal_func,GDestroyNotify  key_destroy_func,GDestroyNotify  value_destroy_func
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_destroy</NAME>
<RETURNS>void	    </RETURNS>
GHashTable	   *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_insert</NAME>
<RETURNS>void	    </RETURNS>
GHashTable	   *hash_table,gpointer	    key,gpointer	    value
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_replace</NAME>
<RETURNS>void        </RETURNS>
GHashTable     *hash_table,gpointer	    key,gpointer	    value
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_remove</NAME>
<RETURNS>gboolean    </RETURNS>
GHashTable	   *hash_table,gconstpointer   key
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_remove_all</NAME>
<RETURNS>void        </RETURNS>
GHashTable     *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_steal</NAME>
<RETURNS>gboolean    </RETURNS>
GHashTable     *hash_table,gconstpointer   key
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_steal_all</NAME>
<RETURNS>void        </RETURNS>
GHashTable     *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_lookup</NAME>
<RETURNS>gpointer    </RETURNS>
GHashTable	   *hash_table,gconstpointer   key
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_lookup_extended</NAME>
<RETURNS>gboolean    </RETURNS>
GHashTable	   *hash_table,gconstpointer   lookup_key,gpointer	   *orig_key,gpointer	   *value
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_foreach</NAME>
<RETURNS>void	    </RETURNS>
GHashTable	   *hash_table,GHFunc	    func,gpointer	    user_data
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_find</NAME>
<RETURNS>gpointer    </RETURNS>
GHashTable	   *hash_table,GHRFunc	    predicate,gpointer	    user_data
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_foreach_remove</NAME>
<RETURNS>guint	    </RETURNS>
GHashTable	   *hash_table,GHRFunc	    func,gpointer	    user_data
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_foreach_steal</NAME>
<RETURNS>guint	    </RETURNS>
GHashTable	   *hash_table,GHRFunc	    func,gpointer	    user_data
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_size</NAME>
<RETURNS>guint	    </RETURNS>
GHashTable	   *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_get_keys</NAME>
<RETURNS>GList *</RETURNS>
GHashTable     *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_get_values</NAME>
<RETURNS>GList *</RETURNS>
GHashTable     *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_iter_init</NAME>
<RETURNS>void        </RETURNS>
GHashTableIter *iter,GHashTable     *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_iter_next</NAME>
<RETURNS>gboolean    </RETURNS>
GHashTableIter *iter,gpointer       *key,gpointer       *value
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_iter_get_hash_table</NAME>
<RETURNS>GHashTable*</RETURNS>
GHashTableIter *iter
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_iter_remove</NAME>
<RETURNS>void        </RETURNS>
GHashTableIter *iter
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_iter_steal</NAME>
<RETURNS>void        </RETURNS>
GHashTableIter *iter
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_ref</NAME>
<RETURNS>GHashTable*</RETURNS>
GHashTable 	   *hash_table
</FUNCTION>
<FUNCTION>
<NAME>g_hash_table_unref</NAME>
<RETURNS>void        </RETURNS>
GHashTable     *hash_table
</FUNCTION>
<MACRO>
<NAME>g_hash_table_freeze</NAME>
#define g_hash_table_freeze(hash_table) ((void)0)
</MACRO>
<MACRO>
<NAME>g_hash_table_thaw</NAME>
#define g_hash_table_thaw(hash_table) ((void)0)
</MACRO>
<FUNCTION>
<NAME>g_str_equal</NAME>
<RETURNS>gboolean </RETURNS>
gconstpointer  v1,gconstpointer  v2
</FUNCTION>
<FUNCTION>
<NAME>g_str_hash</NAME>
<RETURNS>guint    </RETURNS>
gconstpointer  v
</FUNCTION>
<FUNCTION>
<NAME>g_int_equal</NAME>
<RETURNS>gboolean </RETURNS>
gconstpointer  v1,gconstpointer  v2
</FUNCTION>
<FUNCTION>
<NAME>g_int_hash</NAME>
<RETURNS>guint    </RETURNS>
gconstpointer  v
</FUNCTION>
<FUNCTION>
<NAME>g_direct_hash</NAME>
<RETURNS>guint    </RETURNS>
gconstpointer  v
</FUNCTION>
<FUNCTION>
<NAME>g_direct_equal</NAME>
<RETURNS>gboolean </RETURNS>
gconstpointer  v1,gconstpointer  v2
</FUNCTION>
<MACRO>
<NAME>SOUP_FORM_MIME_TYPE_URLENCODED</NAME>
#define SOUP_FORM_MIME_TYPE_URLENCODED "application/x-www-form-urlencoded"
</MACRO>
<MACRO>
<NAME>SOUP_FORM_MIME_TYPE_MULTIPART</NAME>
#define SOUP_FORM_MIME_TYPE_MULTIPART  "multipart/form-data"
</MACRO>
<FUNCTION>
<NAME>soup_form_decode</NAME>
<RETURNS>GHashTable  *</RETURNS>
const char   *encoded_form
</FUNCTION>
<FUNCTION>
<NAME>soup_form_decode_multipart</NAME>
<RETURNS>GHashTable  *</RETURNS>
SoupMessage  *msg,const char   *file_control_name,char        **filename,char        **content_type,SoupBuffer  **file
</FUNCTION>
<FUNCTION>
<NAME>soup_form_encode</NAME>
<RETURNS>char        *</RETURNS>
const char   *first_field,...
</FUNCTION>
<FUNCTION>
<NAME>soup_form_encode_hash</NAME>
<RETURNS>char        *</RETURNS>
GHashTable   *form_data_set
</FUNCTION>
<FUNCTION>
<NAME>soup_form_encode_datalist</NAME>
<RETURNS>char        *</RETURNS>
GData       **form_data_set
</FUNCTION>
<FUNCTION>
<NAME>soup_form_encode_valist</NAME>
<RETURNS>char        *</RETURNS>
const char   *first_field,va_list       args
</FUNCTION>
<MACRO>
<NAME>soup_form_decode_urlencoded</NAME>
<DEPRECATED/>
#define soup_form_decode_urlencoded      soup_form_decode
</MACRO>
<MACRO>
<NAME>soup_form_encode_urlencoded</NAME>
<DEPRECATED/>
#define soup_form_encode_urlencoded      soup_form_encode_hash
</MACRO>
<MACRO>
<NAME>soup_form_encode_urlencoded_list</NAME>
<DEPRECATED/>
#define soup_form_encode_urlencoded_list soup_form_encode_datalist
</MACRO>
<FUNCTION>
<NAME>soup_form_request_new</NAME>
<RETURNS>SoupMessage *</RETURNS>
const char     *method,const char     *uri,const char     *first_field,...
</FUNCTION>
<FUNCTION>
<NAME>soup_form_request_new_from_hash</NAME>
<RETURNS>SoupMessage *</RETURNS>
const char     *method,const char     *uri,GHashTable     *form_data_set
</FUNCTION>
<FUNCTION>
<NAME>soup_form_request_new_from_datalist</NAME>
<RETURNS>SoupMessage *</RETURNS>
const char     *method,const char     *uri,GData         **form_data_set
</FUNCTION>
<FUNCTION>
<NAME>soup_form_request_new_from_multipart</NAME>
<RETURNS>SoupMessage *</RETURNS>
const char     *uri,SoupMultipart  *multipart
</FUNCTION>
<MACRO>
<NAME>SOUP_STATUS_IS_TRANSPORT_ERROR</NAME>
#define SOUP_STATUS_IS_TRANSPORT_ERROR(status) ((status) >  0   && (status) < 100)
</MACRO>
<MACRO>
<NAME>SOUP_STATUS_IS_INFORMATIONAL</NAME>
#define SOUP_STATUS_IS_INFORMATIONAL(status)   ((status) >= 100 && (status) < 200)
</MACRO>
<MACRO>
<NAME>SOUP_STATUS_IS_SUCCESSFUL</NAME>
#define SOUP_STATUS_IS_SUCCESSFUL(status)      ((status) >= 200 && (status) < 300)
</MACRO>
<MACRO>
<NAME>SOUP_STATUS_IS_REDIRECTION</NAME>
#define SOUP_STATUS_IS_REDIRECTION(status)     ((status) >= 300 && (status) < 400)
</MACRO>
<MACRO>
<NAME>SOUP_STATUS_IS_CLIENT_ERROR</NAME>
#define SOUP_STATUS_IS_CLIENT_ERROR(status)    ((status) >= 400 && (status) < 500)
</MACRO>
<MACRO>
<NAME>SOUP_STATUS_IS_SERVER_ERROR</NAME>
#define SOUP_STATUS_IS_SERVER_ERROR(status)    ((status) >= 500 && (status) < 600)
</MACRO>
<ENUM>
<NAME>SoupKnownStatusCode</NAME>
typedef enum {
	SOUP_STATUS_NONE,

	/* Transport Errors */
	SOUP_STATUS_CANCELLED                       = 1,
	SOUP_STATUS_CANT_RESOLVE,
	SOUP_STATUS_CANT_RESOLVE_PROXY,
	SOUP_STATUS_CANT_CONNECT,
	SOUP_STATUS_CANT_CONNECT_PROXY,
	SOUP_STATUS_SSL_FAILED,
	SOUP_STATUS_IO_ERROR,
	SOUP_STATUS_MALFORMED,
	SOUP_STATUS_TRY_AGAIN,

	/* HTTP Status Codes */
	SOUP_STATUS_CONTINUE                        = 100,
	SOUP_STATUS_SWITCHING_PROTOCOLS             = 101,
	SOUP_STATUS_PROCESSING                      = 102, /* WebDAV */

	SOUP_STATUS_OK                              = 200,
	SOUP_STATUS_CREATED                         = 201,
	SOUP_STATUS_ACCEPTED                        = 202,
	SOUP_STATUS_NON_AUTHORITATIVE               = 203,
	SOUP_STATUS_NO_CONTENT                      = 204,
	SOUP_STATUS_RESET_CONTENT                   = 205,
	SOUP_STATUS_PARTIAL_CONTENT                 = 206,
	SOUP_STATUS_MULTI_STATUS                    = 207, /* WebDAV */

	SOUP_STATUS_MULTIPLE_CHOICES                = 300,
	SOUP_STATUS_MOVED_PERMANENTLY               = 301,
	SOUP_STATUS_FOUND                           = 302,
	SOUP_STATUS_MOVED_TEMPORARILY               = 302, /* RFC 2068 */
	SOUP_STATUS_SEE_OTHER                       = 303,
	SOUP_STATUS_NOT_MODIFIED                    = 304,
	SOUP_STATUS_USE_PROXY                       = 305,
	SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL  = 306, /* (reserved) */
	SOUP_STATUS_TEMPORARY_REDIRECT              = 307,

	SOUP_STATUS_BAD_REQUEST                     = 400,
	SOUP_STATUS_UNAUTHORIZED                    = 401,
	SOUP_STATUS_PAYMENT_REQUIRED                = 402, /* (reserved) */
	SOUP_STATUS_FORBIDDEN                       = 403,
	SOUP_STATUS_NOT_FOUND                       = 404,
	SOUP_STATUS_METHOD_NOT_ALLOWED              = 405,
	SOUP_STATUS_NOT_ACCEPTABLE                  = 406,
	SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED   = 407,
	SOUP_STATUS_PROXY_UNAUTHORIZED              = SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED,
	SOUP_STATUS_REQUEST_TIMEOUT                 = 408,
	SOUP_STATUS_CONFLICT                        = 409,
	SOUP_STATUS_GONE                            = 410,
	SOUP_STATUS_LENGTH_REQUIRED                 = 411,
	SOUP_STATUS_PRECONDITION_FAILED             = 412,
	SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE        = 413,
	SOUP_STATUS_REQUEST_URI_TOO_LONG            = 414,
	SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE          = 415,
	SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE = 416,
	SOUP_STATUS_INVALID_RANGE                   = SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE,
	SOUP_STATUS_EXPECTATION_FAILED              = 417,
	SOUP_STATUS_UNPROCESSABLE_ENTITY            = 422, /* WebDAV */
	SOUP_STATUS_LOCKED                          = 423, /* WebDAV */
	SOUP_STATUS_FAILED_DEPENDENCY               = 424, /* WebDAV */

	SOUP_STATUS_INTERNAL_SERVER_ERROR           = 500,
	SOUP_STATUS_NOT_IMPLEMENTED                 = 501,
	SOUP_STATUS_BAD_GATEWAY                     = 502,
	SOUP_STATUS_SERVICE_UNAVAILABLE             = 503,
	SOUP_STATUS_GATEWAY_TIMEOUT                 = 504,
	SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED      = 505,
	SOUP_STATUS_INSUFFICIENT_STORAGE            = 507, /* WebDAV search */
	SOUP_STATUS_NOT_EXTENDED                    = 510  /* RFC 2774 */
} SoupKnownStatusCode;
</ENUM>
<FUNCTION>
<NAME>soup_status_get_phrase</NAME>
<RETURNS>const char *</RETURNS>
guint status_code
</FUNCTION>
<FUNCTION>
<NAME>soup_status_proxify</NAME>
<RETURNS>guint       </RETURNS>
guint status_code
</FUNCTION>
<MACRO>
<NAME>SOUP_HTTP_ERROR</NAME>
#define SOUP_HTTP_ERROR soup_http_error_quark()
</MACRO>
<FUNCTION>
<NAME>soup_http_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_AUTH_DOMAIN_BASIC</NAME>
#define SOUP_TYPE_AUTH_DOMAIN_BASIC            (soup_auth_domain_basic_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_BASIC</NAME>
#define SOUP_AUTH_DOMAIN_BASIC(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_AUTH_DOMAIN_BASIC, SoupAuthDomainBasic))
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_BASIC_CLASS</NAME>
#define SOUP_AUTH_DOMAIN_BASIC_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_AUTH_DOMAIN_BASIC, SoupAuthDomainBasicClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_AUTH_DOMAIN_BASIC</NAME>
#define SOUP_IS_AUTH_DOMAIN_BASIC(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_AUTH_DOMAIN_BASIC))
</MACRO>
<MACRO>
<NAME>SOUP_IS_AUTH_DOMAIN_BASIC_CLASS</NAME>
#define SOUP_IS_AUTH_DOMAIN_BASIC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_AUTH_DOMAIN_BASIC))
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_BASIC_GET_CLASS</NAME>
#define SOUP_AUTH_DOMAIN_BASIC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_DOMAIN_BASIC, SoupAuthDomainBasicClass))
</MACRO>
<STRUCT>
<NAME>SoupAuthDomainBasic</NAME>
typedef struct {
	SoupAuthDomain parent;

} SoupAuthDomainBasic;
</STRUCT>
<STRUCT>
<NAME>SoupAuthDomainBasicClass</NAME>
typedef struct {
	SoupAuthDomainClass parent_class;

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupAuthDomainBasicClass;
</STRUCT>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK</NAME>
#define SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK "auth-callback"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_BASIC_AUTH_DATA</NAME>
#define SOUP_AUTH_DOMAIN_BASIC_AUTH_DATA     "auth-data"
</MACRO>
<FUNCTION>
<NAME>soup_auth_domain_basic_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_basic_new</NAME>
<RETURNS>SoupAuthDomain *</RETURNS>
const char *optname1,...
</FUNCTION>
<USER_FUNCTION>
<NAME>SoupAuthDomainBasicAuthCallback</NAME>
<RETURNS>gboolean </RETURNS>
SoupAuthDomain *domain,
						     SoupMessage    *msg,
						     const char     *username,
						     const char     *password,
						     gpointer        user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_basic_set_auth_callback</NAME>
<RETURNS>void      </RETURNS>
SoupAuthDomain *domain,SoupAuthDomainBasicAuthCallback callback,gpointer        user_data,GDestroyNotify  dnotify
</FUNCTION>
<ENUM>
<NAME>GChecksumType</NAME>
typedef enum {
  G_CHECKSUM_MD5,
  G_CHECKSUM_SHA1,
  G_CHECKSUM_SHA256
} GChecksumType;
</ENUM>
<STRUCT>
<NAME>GChecksum</NAME>
</STRUCT>
<FUNCTION>
<NAME>g_checksum_type_get_length</NAME>
<RETURNS>gssize                </RETURNS>
GChecksumType checksum_type
</FUNCTION>
<FUNCTION>
<NAME>g_checksum_new</NAME>
<RETURNS>GChecksum *</RETURNS>
GChecksumType     checksum_type
</FUNCTION>
<FUNCTION>
<NAME>g_checksum_copy</NAME>
<RETURNS>GChecksum *</RETURNS>
const GChecksum  *checksum
</FUNCTION>
<FUNCTION>
<NAME>g_checksum_free</NAME>
<RETURNS>void                  </RETURNS>
GChecksum        *checksum
</FUNCTION>
<FUNCTION>
<NAME>g_checksum_update</NAME>
<RETURNS>void                  </RETURNS>
GChecksum        *checksum,const guchar     *data,gssize            length
</FUNCTION>
<FUNCTION>
<NAME>g_checksum_get_string</NAME>
<RETURNS>G_CONST_RETURN gchar *</RETURNS>
GChecksum        *checksum
</FUNCTION>
<FUNCTION>
<NAME>g_checksum_get_digest</NAME>
<RETURNS>void                  </RETURNS>
GChecksum        *checksum,guint8           *buffer,gsize            *digest_len
</FUNCTION>
<FUNCTION>
<NAME>g_compute_checksum_for_data</NAME>
<RETURNS>gchar *</RETURNS>
GChecksumType  checksum_type,const guchar  *data,gsize          length
</FUNCTION>
<FUNCTION>
<NAME>g_compute_checksum_for_string</NAME>
<RETURNS>gchar *</RETURNS>
GChecksumType  checksum_type,const gchar   *str,gssize         length
</FUNCTION>
<TYPEDEF>
<NAME>SoupMessageHeaders</NAME>
typedef struct SoupMessageHeaders SoupMessageHeaders;
</TYPEDEF>
<FUNCTION>
<NAME>soup_message_headers_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_MESSAGE_HEADERS</NAME>
#define SOUP_TYPE_MESSAGE_HEADERS (soup_message_headers_get_type ())
</MACRO>
<ENUM>
<NAME>SoupMessageHeadersType</NAME>
typedef enum {
	SOUP_MESSAGE_HEADERS_REQUEST,
	SOUP_MESSAGE_HEADERS_RESPONSE,
	SOUP_MESSAGE_HEADERS_MULTIPART
} SoupMessageHeadersType;
</ENUM>
<FUNCTION>
<NAME>soup_message_headers_new</NAME>
<RETURNS>SoupMessageHeaders *</RETURNS>
SoupMessageHeadersType type
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_free</NAME>
<RETURNS>void                </RETURNS>
SoupMessageHeaders *hdrs
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_append</NAME>
<RETURNS>void                </RETURNS>
SoupMessageHeaders *hdrs,const char         *name,const char         *value
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_replace</NAME>
<RETURNS>void                </RETURNS>
SoupMessageHeaders *hdrs,const char         *name,const char         *value
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_remove</NAME>
<RETURNS>void                </RETURNS>
SoupMessageHeaders *hdrs,const char         *name
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_clear</NAME>
<RETURNS>void                </RETURNS>
SoupMessageHeaders *hdrs
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_get</NAME>
<DEPRECATED/>
<RETURNS>const char         *</RETURNS>
SoupMessageHeaders *hdrs,const char         *name
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_get_one</NAME>
<RETURNS>const char         *</RETURNS>
SoupMessageHeaders *hdrs,const char         *name
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_get_list</NAME>
<RETURNS>const char         *</RETURNS>
SoupMessageHeaders *hdrs,const char         *name
</FUNCTION>
<USER_FUNCTION>
<NAME>SoupMessageHeadersForeachFunc</NAME>
<RETURNS>void </RETURNS>
const char         *name,
						   const char         *value,
						   gpointer            user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_foreach</NAME>
<RETURNS>void                </RETURNS>
SoupMessageHeaders *hdrs,SoupMessageHeadersForeachFunc func,gpointer            user_data
</FUNCTION>
<STRUCT>
<NAME>SoupMessageHeadersIter</NAME>
typedef struct {
	/*< private >*/
	gpointer dummy[3];
} SoupMessageHeadersIter;
</STRUCT>
<FUNCTION>
<NAME>soup_message_headers_iter_init</NAME>
<RETURNS>void                </RETURNS>
SoupMessageHeadersIter  *iter,SoupMessageHeaders      *hdrs
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_iter_next</NAME>
<RETURNS>gboolean            </RETURNS>
SoupMessageHeadersIter  *iter,const char             **name,const char             **value
</FUNCTION>
<ENUM>
<NAME>SoupEncoding</NAME>
typedef enum {
	SOUP_ENCODING_UNRECOGNIZED,
	SOUP_ENCODING_NONE,
	SOUP_ENCODING_CONTENT_LENGTH,
	SOUP_ENCODING_EOF,
	SOUP_ENCODING_CHUNKED,
	SOUP_ENCODING_BYTERANGES
} SoupEncoding;
</ENUM>
<FUNCTION>
<NAME>soup_message_headers_get_encoding</NAME>
<RETURNS>SoupEncoding    </RETURNS>
SoupMessageHeaders *hdrs
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_set_encoding</NAME>
<RETURNS>void            </RETURNS>
SoupMessageHeaders *hdrs,SoupEncoding        encoding
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_get_content_length</NAME>
<RETURNS>goffset         </RETURNS>
SoupMessageHeaders *hdrs
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_set_content_length</NAME>
<RETURNS>void            </RETURNS>
SoupMessageHeaders *hdrs,goffset             content_length
</FUNCTION>
<ENUM>
<NAME>SoupExpectation</NAME>
typedef enum {
	SOUP_EXPECTATION_UNRECOGNIZED = (1 << 0),
	SOUP_EXPECTATION_CONTINUE     = (1 << 1)
} SoupExpectation;
</ENUM>
<FUNCTION>
<NAME>soup_message_headers_get_expectations</NAME>
<RETURNS>SoupExpectation </RETURNS>
SoupMessageHeaders *hdrs
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_set_expectations</NAME>
<RETURNS>void            </RETURNS>
SoupMessageHeaders *hdrs,SoupExpectation     expectations
</FUNCTION>
<STRUCT>
<NAME>SoupRange</NAME>
typedef struct {
	goffset start;
	goffset end;
} SoupRange;
</STRUCT>
<FUNCTION>
<NAME>soup_message_headers_get_ranges</NAME>
<RETURNS>gboolean        </RETURNS>
SoupMessageHeaders  *hdrs,goffset              total_length,SoupRange          **ranges,int                 *length
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_free_ranges</NAME>
<RETURNS>void            </RETURNS>
SoupMessageHeaders  *hdrs,SoupRange           *ranges
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_set_ranges</NAME>
<RETURNS>void            </RETURNS>
SoupMessageHeaders  *hdrs,SoupRange           *ranges,int                  length
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_set_range</NAME>
<RETURNS>void            </RETURNS>
SoupMessageHeaders  *hdrs,goffset              start,goffset              end
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_get_content_range</NAME>
<RETURNS>gboolean        </RETURNS>
SoupMessageHeaders  *hdrs,goffset             *start,goffset             *end,goffset             *total_length
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_set_content_range</NAME>
<RETURNS>void            </RETURNS>
SoupMessageHeaders  *hdrs,goffset              start,goffset              end,goffset              total_length
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_get_content_type</NAME>
<RETURNS>const char *</RETURNS>
SoupMessageHeaders  *hdrs,GHashTable         **params
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_set_content_type</NAME>
<RETURNS>void        </RETURNS>
SoupMessageHeaders  *hdrs,const char          *content_type,GHashTable          *params
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_get_content_disposition</NAME>
<RETURNS>gboolean </RETURNS>
SoupMessageHeaders  *hdrs,char               **disposition,GHashTable         **params
</FUNCTION>
<FUNCTION>
<NAME>soup_message_headers_set_content_disposition</NAME>
<RETURNS>void     </RETURNS>
SoupMessageHeaders  *hdrs,const char          *disposition,GHashTable          *params
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_MESSAGE</NAME>
#define SOUP_TYPE_MESSAGE            (soup_message_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE</NAME>
#define SOUP_MESSAGE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_MESSAGE, SoupMessage))
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE_CLASS</NAME>
#define SOUP_MESSAGE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_MESSAGE, SoupMessageClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_MESSAGE</NAME>
#define SOUP_IS_MESSAGE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_MESSAGE))
</MACRO>
<MACRO>
<NAME>SOUP_IS_MESSAGE_CLASS</NAME>
#define SOUP_IS_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_MESSAGE))
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE_GET_CLASS</NAME>
#define SOUP_MESSAGE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_MESSAGE, SoupMessageClass))
</MACRO>
<STRUCT>
<NAME>SoupMessage</NAME>
struct _SoupMessage {
	GObject parent;

	/*< public >*/
	const char         *method;

	guint               status_code;
	char               *reason_phrase;

	SoupMessageBody    *request_body;
	SoupMessageHeaders *request_headers;

	SoupMessageBody    *response_body;
	SoupMessageHeaders *response_headers;
};
</STRUCT>
<STRUCT>
<NAME>SoupMessageClass</NAME>
typedef struct {
	GObjectClass parent_class;

	/* signals */
	void     (*wrote_informational) (SoupMessage *msg);
	void     (*wrote_headers)       (SoupMessage *msg);
	void     (*wrote_chunk)         (SoupMessage *msg);
	void     (*wrote_body)          (SoupMessage *msg);
	void     (*got_informational)   (SoupMessage *msg);
	void     (*got_headers)         (SoupMessage *msg);
	void     (*got_chunk)           (SoupMessage *msg, SoupBuffer *chunk);
	void     (*got_body)            (SoupMessage *msg);
	void     (*restarted)           (SoupMessage *msg);
	void     (*finished)            (SoupMessage *msg);

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupMessageClass;
</STRUCT>
<FUNCTION>
<NAME>soup_message_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_MESSAGE_METHOD</NAME>
#define SOUP_MESSAGE_METHOD        "method"
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE_URI</NAME>
#define SOUP_MESSAGE_URI           "uri"
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE_HTTP_VERSION</NAME>
#define SOUP_MESSAGE_HTTP_VERSION  "http-version"
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE_FLAGS</NAME>
#define SOUP_MESSAGE_FLAGS         "flags"
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE_SERVER_SIDE</NAME>
#define SOUP_MESSAGE_SERVER_SIDE   "server-side"
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE_STATUS_CODE</NAME>
#define SOUP_MESSAGE_STATUS_CODE   "status-code"
</MACRO>
<MACRO>
<NAME>SOUP_MESSAGE_REASON_PHRASE</NAME>
#define SOUP_MESSAGE_REASON_PHRASE "reason-phrase"
</MACRO>
<FUNCTION>
<NAME>soup_message_new</NAME>
<RETURNS>SoupMessage   *</RETURNS>
const char        *method,const char        *uri_string
</FUNCTION>
<FUNCTION>
<NAME>soup_message_new_from_uri</NAME>
<RETURNS>SoupMessage   *</RETURNS>
const char        *method,SoupURI           *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_message_set_request</NAME>
<RETURNS>void           </RETURNS>
SoupMessage       *msg,const char        *content_type,SoupMemoryUse      req_use,const char        *req_body,gsize              req_length
</FUNCTION>
<FUNCTION>
<NAME>soup_message_set_response</NAME>
<RETURNS>void           </RETURNS>
SoupMessage       *msg,const char        *content_type,SoupMemoryUse      resp_use,const char        *resp_body,gsize              resp_length
</FUNCTION>
<ENUM>
<NAME>SoupHTTPVersion</NAME>
typedef enum {
	SOUP_HTTP_1_0 = 0,
	SOUP_HTTP_1_1 = 1
} SoupHTTPVersion;
</ENUM>
<FUNCTION>
<NAME>soup_message_set_http_version</NAME>
<RETURNS>void             </RETURNS>
SoupMessage       *msg,SoupHTTPVersion    version
</FUNCTION>
<FUNCTION>
<NAME>soup_message_get_http_version</NAME>
<RETURNS>SoupHTTPVersion  </RETURNS>
SoupMessage       *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_is_keepalive</NAME>
<RETURNS>gboolean         </RETURNS>
SoupMessage       *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_get_uri</NAME>
<RETURNS>SoupURI         *</RETURNS>
SoupMessage       *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_set_uri</NAME>
<RETURNS>void             </RETURNS>
SoupMessage       *msg,SoupURI           *uri
</FUNCTION>
<FUNCTION>
<NAME>soup_message_get_address</NAME>
<RETURNS>SoupAddress     *</RETURNS>
SoupMessage       *msg
</FUNCTION>
<ENUM>
<NAME>SoupMessageFlags</NAME>
typedef enum {
#ifndef LIBSOUP_DISABLE_DEPRECATED
	SOUP_MESSAGE_OVERWRITE_CHUNKS = (1 << 3),
#endif
	SOUP_MESSAGE_NO_REDIRECT      = (1 << 1)
} SoupMessageFlags;
</ENUM>
<FUNCTION>
<NAME>soup_message_set_flags</NAME>
<RETURNS>void           </RETURNS>
SoupMessage        *msg,SoupMessageFlags    flags
</FUNCTION>
<FUNCTION>
<NAME>soup_message_get_flags</NAME>
<RETURNS>SoupMessageFlags </RETURNS>
SoupMessage        *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_add_header_handler</NAME>
<RETURNS>guint          </RETURNS>
SoupMessage       *msg,const char        *signal,const char        *header,GCallback          callback,gpointer           user_data
</FUNCTION>
<FUNCTION>
<NAME>soup_message_add_status_code_handler</NAME>
<RETURNS>guint          </RETURNS>
SoupMessage       *msg,const char        *signal,guint              status_code,GCallback          callback,gpointer           user_data
</FUNCTION>
<FUNCTION>
<NAME>soup_message_set_status</NAME>
<RETURNS>void           </RETURNS>
SoupMessage       *msg,guint              status_code
</FUNCTION>
<FUNCTION>
<NAME>soup_message_set_status_full</NAME>
<RETURNS>void           </RETURNS>
SoupMessage       *msg,guint              status_code,const char        *reason_phrase
</FUNCTION>
<USER_FUNCTION>
<NAME>SoupChunkAllocator</NAME>
<RETURNS>SoupBuffer *</RETURNS>
SoupMessage       *msg,
						 gsize              max_len,
						 gpointer           user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>soup_message_set_chunk_allocator</NAME>
<RETURNS>void           </RETURNS>
SoupMessage       *msg,SoupChunkAllocator allocator,gpointer           user_data,GDestroyNotify     destroy_notify
</FUNCTION>
<FUNCTION>
<NAME>soup_message_wrote_informational</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_wrote_headers</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_wrote_chunk</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_wrote_body_data</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg, SoupBuffer *chunk
</FUNCTION>
<FUNCTION>
<NAME>soup_message_wrote_body</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_got_informational</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_got_headers</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_got_chunk</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg, SoupBuffer *chunk
</FUNCTION>
<FUNCTION>
<NAME>soup_message_got_body</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_restarted</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_message_finished</NAME>
<RETURNS>void </RETURNS>
SoupMessage *msg
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_SESSION_ASYNC</NAME>
#define SOUP_TYPE_SESSION_ASYNC            (soup_session_async_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_ASYNC</NAME>
#define SOUP_SESSION_ASYNC(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SESSION_ASYNC, SoupSessionAsync))
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_ASYNC_CLASS</NAME>
#define SOUP_SESSION_ASYNC_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SESSION_ASYNC, SoupSessionAsyncClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SESSION_ASYNC</NAME>
#define SOUP_IS_SESSION_ASYNC(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SESSION_ASYNC))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SESSION_ASYNC_CLASS</NAME>
#define SOUP_IS_SESSION_ASYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_ASYNC))
</MACRO>
<MACRO>
<NAME>SOUP_SESSION_ASYNC_GET_CLASS</NAME>
#define SOUP_SESSION_ASYNC_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_ASYNC, SoupSessionAsyncClass))
</MACRO>
<STRUCT>
<NAME>SoupSessionAsync</NAME>
struct _SoupSessionAsync {
	SoupSession parent;

};
</STRUCT>
<STRUCT>
<NAME>SoupSessionAsyncClass</NAME>
typedef struct {
	SoupSessionClass parent_class;

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupSessionAsyncClass;
</STRUCT>
<FUNCTION>
<NAME>soup_session_async_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_session_async_new</NAME>
<RETURNS>SoupSession *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_session_async_new_with_options</NAME>
<RETURNS>SoupSession *</RETURNS>
const char *optname1,...
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_ADDRESS</NAME>
#define SOUP_TYPE_ADDRESS            (soup_address_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_ADDRESS</NAME>
#define SOUP_ADDRESS(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_ADDRESS, SoupAddress))
</MACRO>
<MACRO>
<NAME>SOUP_ADDRESS_CLASS</NAME>
#define SOUP_ADDRESS_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_ADDRESS, SoupAddressClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_ADDRESS</NAME>
#define SOUP_IS_ADDRESS(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_ADDRESS))
</MACRO>
<MACRO>
<NAME>SOUP_IS_ADDRESS_CLASS</NAME>
#define SOUP_IS_ADDRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_ADDRESS))
</MACRO>
<MACRO>
<NAME>SOUP_ADDRESS_GET_CLASS</NAME>
#define SOUP_ADDRESS_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_ADDRESS, SoupAddressClass))
</MACRO>
<STRUCT>
<NAME>SoupAddress</NAME>
struct _SoupAddress {
	GObject parent;

};
</STRUCT>
<STRUCT>
<NAME>SoupAddressClass</NAME>
typedef struct {
	GObjectClass parent_class;

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupAddressClass;
</STRUCT>
<MACRO>
<NAME>SOUP_ADDRESS_NAME</NAME>
#define SOUP_ADDRESS_NAME     "name"
</MACRO>
<MACRO>
<NAME>SOUP_ADDRESS_FAMILY</NAME>
#define SOUP_ADDRESS_FAMILY   "family"
</MACRO>
<MACRO>
<NAME>SOUP_ADDRESS_PORT</NAME>
#define SOUP_ADDRESS_PORT     "port"
</MACRO>
<MACRO>
<NAME>SOUP_ADDRESS_PHYSICAL</NAME>
#define SOUP_ADDRESS_PHYSICAL "physical"
</MACRO>
<MACRO>
<NAME>SOUP_ADDRESS_SOCKADDR</NAME>
#define SOUP_ADDRESS_SOCKADDR "sockaddr"
</MACRO>
<MACRO>
<NAME>AF_INET6</NAME>
#define AF_INET6 -1
</MACRO>
<ENUM>
<NAME>SoupAddressFamily</NAME>
typedef enum {
	SOUP_ADDRESS_FAMILY_INVALID = -1,

	SOUP_ADDRESS_FAMILY_IPV4 = AF_INET,
	SOUP_ADDRESS_FAMILY_IPV6 = AF_INET6
} SoupAddressFamily;
</ENUM>
<MACRO>
<NAME>SOUP_ADDRESS_ANY_PORT</NAME>
#define SOUP_ADDRESS_ANY_PORT 0
</MACRO>
<USER_FUNCTION>
<NAME>SoupAddressCallback</NAME>
<RETURNS>void </RETURNS>
SoupAddress         *addr,
						  guint                status,
						  gpointer             data
</USER_FUNCTION>
<FUNCTION>
<NAME>soup_address_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_address_new</NAME>
<RETURNS>SoupAddress     *</RETURNS>
const char          *name,guint                port
</FUNCTION>
<FUNCTION>
<NAME>soup_address_new_from_sockaddr</NAME>
<RETURNS>SoupAddress     *</RETURNS>
struct sockaddr     *sa,int                  len
</FUNCTION>
<FUNCTION>
<NAME>soup_address_new_any</NAME>
<RETURNS>SoupAddress     *</RETURNS>
SoupAddressFamily    family,guint                port
</FUNCTION>
<FUNCTION>
<NAME>soup_address_resolve_async</NAME>
<RETURNS>void             </RETURNS>
SoupAddress         *addr,GMainContext        *async_context,GCancellable        *cancellable,SoupAddressCallback  callback,gpointer             user_data
</FUNCTION>
<FUNCTION>
<NAME>soup_address_resolve_sync</NAME>
<RETURNS>guint            </RETURNS>
SoupAddress         *addr,GCancellable        *cancellable
</FUNCTION>
<FUNCTION>
<NAME>soup_address_get_name</NAME>
<RETURNS>const char      *</RETURNS>
SoupAddress         *addr
</FUNCTION>
<FUNCTION>
<NAME>soup_address_get_physical</NAME>
<RETURNS>const char      *</RETURNS>
SoupAddress         *addr
</FUNCTION>
<FUNCTION>
<NAME>soup_address_get_port</NAME>
<RETURNS>guint            </RETURNS>
SoupAddress         *addr
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_AUTH</NAME>
#define SOUP_TYPE_AUTH            (soup_auth_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_AUTH</NAME>
#define SOUP_AUTH(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_AUTH, SoupAuth))
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_CLASS</NAME>
#define SOUP_AUTH_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_AUTH, SoupAuthClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_AUTH</NAME>
#define SOUP_IS_AUTH(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_AUTH))
</MACRO>
<MACRO>
<NAME>SOUP_IS_AUTH_CLASS</NAME>
#define SOUP_IS_AUTH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_AUTH))
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_GET_CLASS</NAME>
#define SOUP_AUTH_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH, SoupAuthClass))
</MACRO>
<STRUCT>
<NAME>SoupAuth</NAME>
struct _SoupAuth {
	GObject parent;

	char *realm;
};
</STRUCT>
<STRUCT>
<NAME>SoupAuthClass</NAME>
typedef struct {
	GObjectClass parent_class;

	const char  *scheme_name;
	guint        strength;

	gboolean     (*update)               (SoupAuth      *auth,
					      SoupMessage   *msg,
					      GHashTable    *auth_params);

	GSList *     (*get_protection_space) (SoupAuth      *auth,
					      SoupURI       *source_uri);

	void         (*authenticate)         (SoupAuth      *auth,
					      const char    *username,
					      const char    *password);
	gboolean     (*is_authenticated)     (SoupAuth      *auth);

	char *       (*get_authorization)    (SoupAuth      *auth,
					      SoupMessage   *msg);
	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupAuthClass;
</STRUCT>
<MACRO>
<NAME>SOUP_AUTH_SCHEME_NAME</NAME>
#define SOUP_AUTH_SCHEME_NAME      "scheme-name"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_REALM</NAME>
#define SOUP_AUTH_REALM            "realm"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_HOST</NAME>
#define SOUP_AUTH_HOST             "host"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_IS_FOR_PROXY</NAME>
#define SOUP_AUTH_IS_FOR_PROXY     "is-for-proxy"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_IS_AUTHENTICATED</NAME>
#define SOUP_AUTH_IS_AUTHENTICATED "is-authenticated"
</MACRO>
<FUNCTION>
<NAME>soup_auth_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_new</NAME>
<RETURNS>SoupAuth   *</RETURNS>
GType          type,SoupMessage   *msg,const char    *auth_header
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_update</NAME>
<RETURNS>gboolean    </RETURNS>
SoupAuth      *auth,SoupMessage   *msg,const char    *auth_header
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_is_for_proxy</NAME>
<RETURNS>gboolean    </RETURNS>
SoupAuth      *auth
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_get_scheme_name</NAME>
<RETURNS>const char *</RETURNS>
SoupAuth      *auth
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_get_host</NAME>
<RETURNS>const char *</RETURNS>
SoupAuth      *auth
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_get_realm</NAME>
<RETURNS>const char *</RETURNS>
SoupAuth      *auth
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_get_info</NAME>
<RETURNS>char       *</RETURNS>
SoupAuth      *auth
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_authenticate</NAME>
<RETURNS>void        </RETURNS>
SoupAuth      *auth,const char    *username,const char    *password
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_is_authenticated</NAME>
<RETURNS>gboolean    </RETURNS>
SoupAuth      *auth
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_get_authorization</NAME>
<RETURNS>char       *</RETURNS>
SoupAuth      *auth,SoupMessage   *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_get_protection_space</NAME>
<RETURNS>GSList     *</RETURNS>
SoupAuth      *auth,SoupURI       *source_uri
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_free_protection_space</NAME>
<RETURNS>void        </RETURNS>
SoupAuth      *auth,GSList        *space
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_SOCKET</NAME>
#define SOUP_TYPE_SOCKET            (soup_socket_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET</NAME>
#define SOUP_SOCKET(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SOCKET, SoupSocket))
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET_CLASS</NAME>
#define SOUP_SOCKET_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SOCKET, SoupSocketClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SOCKET</NAME>
#define SOUP_IS_SOCKET(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SOCKET))
</MACRO>
<MACRO>
<NAME>SOUP_IS_SOCKET_CLASS</NAME>
#define SOUP_IS_SOCKET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SOCKET))
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET_GET_CLASS</NAME>
#define SOUP_SOCKET_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOCKET, SoupSocketClass))
</MACRO>
<STRUCT>
<NAME>SoupSocket</NAME>
struct _SoupSocket {
	GObject parent;

};
</STRUCT>
<STRUCT>
<NAME>SoupSocketClass</NAME>
typedef struct {
	GObjectClass parent_class;

	/* signals */
	void (*readable)       (SoupSocket *);
	void (*writable)       (SoupSocket *);
	void (*disconnected)   (SoupSocket *);

	void (*new_connection) (SoupSocket *, SoupSocket *);

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupSocketClass;
</STRUCT>
<MACRO>
<NAME>SOUP_SOCKET_LOCAL_ADDRESS</NAME>
#define SOUP_SOCKET_LOCAL_ADDRESS    "local-address"
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET_REMOTE_ADDRESS</NAME>
#define SOUP_SOCKET_REMOTE_ADDRESS   "remote-address"
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET_FLAG_NONBLOCKING</NAME>
#define SOUP_SOCKET_FLAG_NONBLOCKING "non-blocking"
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET_IS_SERVER</NAME>
#define SOUP_SOCKET_IS_SERVER        "is-server"
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET_SSL_CREDENTIALS</NAME>
#define SOUP_SOCKET_SSL_CREDENTIALS  "ssl-creds"
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET_ASYNC_CONTEXT</NAME>
#define SOUP_SOCKET_ASYNC_CONTEXT    "async-context"
</MACRO>
<MACRO>
<NAME>SOUP_SOCKET_TIMEOUT</NAME>
#define SOUP_SOCKET_TIMEOUT	     "timeout"
</MACRO>
<USER_FUNCTION>
<NAME>SoupSocketCallback</NAME>
<RETURNS>void </RETURNS>
SoupSocket         *sock,
					       guint               status,
					       gpointer            user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>soup_socket_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_new</NAME>
<RETURNS>SoupSocket    *</RETURNS>
const char         *optname1,...
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_connect_async</NAME>
<RETURNS>void           </RETURNS>
SoupSocket         *sock,GCancellable       *cancellable,SoupSocketCallback  callback,gpointer            user_data
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_connect_sync</NAME>
<RETURNS>guint          </RETURNS>
SoupSocket         *sock,GCancellable       *cancellable
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_listen</NAME>
<RETURNS>gboolean       </RETURNS>
SoupSocket         *sock
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_start_ssl</NAME>
<RETURNS>gboolean       </RETURNS>
SoupSocket         *sock,GCancellable       *cancellable
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_start_proxy_ssl</NAME>
<RETURNS>gboolean       </RETURNS>
SoupSocket         *sock,const char         *ssl_host,GCancellable       *cancellable
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_is_ssl</NAME>
<RETURNS>gboolean       </RETURNS>
SoupSocket         *sock
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_disconnect</NAME>
<RETURNS>void           </RETURNS>
SoupSocket         *sock
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_is_connected</NAME>
<RETURNS>gboolean       </RETURNS>
SoupSocket         *sock
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_get_local_address</NAME>
<RETURNS>SoupAddress   *</RETURNS>
SoupSocket         *sock
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_get_remote_address</NAME>
<RETURNS>SoupAddress   *</RETURNS>
SoupSocket         *sock
</FUNCTION>
<ENUM>
<NAME>SoupSocketIOStatus</NAME>
typedef enum {
	SOUP_SOCKET_OK,
	SOUP_SOCKET_WOULD_BLOCK,
	SOUP_SOCKET_EOF,
	SOUP_SOCKET_ERROR
} SoupSocketIOStatus;
</ENUM>
<FUNCTION>
<NAME>soup_socket_read</NAME>
<RETURNS>SoupSocketIOStatus  </RETURNS>
SoupSocket         *sock,gpointer            buffer,gsize               len,gsize              *nread,GCancellable       *cancellable,GError            **error
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_read_until</NAME>
<RETURNS>SoupSocketIOStatus  </RETURNS>
SoupSocket         *sock,gpointer            buffer,gsize               len,gconstpointer       boundary,gsize               boundary_len,gsize              *nread,gboolean           *got_boundary,GCancellable       *cancellable,GError            **error
</FUNCTION>
<FUNCTION>
<NAME>soup_socket_write</NAME>
<RETURNS>SoupSocketIOStatus  </RETURNS>
SoupSocket         *sock,gconstpointer       buffer,gsize               len,gsize              *nwrote,GCancellable       *cancellable,GError            **error
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_LOGGER</NAME>
#define SOUP_TYPE_LOGGER            (soup_logger_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_LOGGER</NAME>
#define SOUP_LOGGER(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_LOGGER, SoupLogger))
</MACRO>
<MACRO>
<NAME>SOUP_LOGGER_CLASS</NAME>
#define SOUP_LOGGER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_LOGGER, SoupLoggerClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_LOGGER</NAME>
#define SOUP_IS_LOGGER(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_LOGGER))
</MACRO>
<MACRO>
<NAME>SOUP_IS_LOGGER_CLASS</NAME>
#define SOUP_IS_LOGGER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_LOGGER))
</MACRO>
<MACRO>
<NAME>SOUP_LOGGER_GET_CLASS</NAME>
#define SOUP_LOGGER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_LOGGER, SoupLoggerClass))
</MACRO>
<ENUM>
<NAME>SoupLoggerLogLevel</NAME>
typedef enum {
	SOUP_LOGGER_LOG_NONE,
	SOUP_LOGGER_LOG_MINIMAL,
	SOUP_LOGGER_LOG_HEADERS,
	SOUP_LOGGER_LOG_BODY
} SoupLoggerLogLevel;
</ENUM>
<STRUCT>
<NAME>SoupLogger</NAME>
typedef struct {
	GObject parent;

} SoupLogger;
</STRUCT>
<STRUCT>
<NAME>SoupLoggerClass</NAME>
typedef struct {
	GObjectClass parent_class;

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupLoggerClass;
</STRUCT>
<USER_FUNCTION>
<NAME>SoupLoggerFilter</NAME>
<RETURNS>SoupLoggerLogLevel </RETURNS>
SoupLogger         *logger,
						 SoupMessage        *msg,
						 gpointer            user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SoupLoggerPrinter</NAME>
<RETURNS>void </RETURNS>
SoupLogger         *logger,
						 SoupLoggerLogLevel  level,
						 char                direction,
						 const char         *data,
						 gpointer            user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>soup_logger_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_logger_new</NAME>
<RETURNS>SoupLogger *</RETURNS>
SoupLoggerLogLevel  level,int                 max_body_size
</FUNCTION>
<FUNCTION>
<NAME>soup_logger_attach</NAME>
<DEPRECATED/>
<RETURNS>void        </RETURNS>
SoupLogger         *logger,SoupSession        *session
</FUNCTION>
<FUNCTION>
<NAME>soup_logger_detach</NAME>
<DEPRECATED/>
<RETURNS>void        </RETURNS>
SoupLogger         *logger,SoupSession        *session
</FUNCTION>
<FUNCTION>
<NAME>soup_logger_set_request_filter</NAME>
<RETURNS>void        </RETURNS>
SoupLogger        *logger,SoupLoggerFilter   request_filter,gpointer           filter_data,GDestroyNotify     destroy
</FUNCTION>
<FUNCTION>
<NAME>soup_logger_set_response_filter</NAME>
<RETURNS>void        </RETURNS>
SoupLogger        *logger,SoupLoggerFilter   response_filter,gpointer           filter_data,GDestroyNotify     destroy
</FUNCTION>
<FUNCTION>
<NAME>soup_logger_set_printer</NAME>
<RETURNS>void        </RETURNS>
SoupLogger        *logger,SoupLoggerPrinter  printer,gpointer           printer_data,GDestroyNotify     destroy
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_AUTH_DOMAIN</NAME>
#define SOUP_TYPE_AUTH_DOMAIN            (soup_auth_domain_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN</NAME>
#define SOUP_AUTH_DOMAIN(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_AUTH_DOMAIN, SoupAuthDomain))
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_CLASS</NAME>
#define SOUP_AUTH_DOMAIN_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_AUTH_DOMAIN, SoupAuthDomainClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_AUTH_DOMAIN</NAME>
#define SOUP_IS_AUTH_DOMAIN(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_AUTH_DOMAIN))
</MACRO>
<MACRO>
<NAME>SOUP_IS_AUTH_DOMAIN_CLASS</NAME>
#define SOUP_IS_AUTH_DOMAIN_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_AUTH_DOMAIN))
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_GET_CLASS</NAME>
#define SOUP_AUTH_DOMAIN_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_DOMAIN, SoupAuthDomainClass))
</MACRO>
<STRUCT>
<NAME>SoupAuthDomain</NAME>
struct _SoupAuthDomain {
	GObject parent;

};
</STRUCT>
<STRUCT>
<NAME>SoupAuthDomainClass</NAME>
typedef struct {
	GObjectClass parent_class;

	char *   (*accepts)        (SoupAuthDomain *domain,
				    SoupMessage    *msg,
				    const char     *header);
	char *   (*challenge)      (SoupAuthDomain *domain,
				    SoupMessage    *msg);
	gboolean (*check_password) (SoupAuthDomain *domain,
				    SoupMessage    *msg,
				    const char     *username,
				    const char     *password);

	/* Padding for future expansion */
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupAuthDomainClass;
</STRUCT>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_REALM</NAME>
#define SOUP_AUTH_DOMAIN_REALM       "realm"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_PROXY</NAME>
#define SOUP_AUTH_DOMAIN_PROXY       "proxy"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_ADD_PATH</NAME>
#define SOUP_AUTH_DOMAIN_ADD_PATH    "add-path"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_REMOVE_PATH</NAME>
#define SOUP_AUTH_DOMAIN_REMOVE_PATH "remove-path"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_FILTER</NAME>
#define SOUP_AUTH_DOMAIN_FILTER      "filter"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_FILTER_DATA</NAME>
#define SOUP_AUTH_DOMAIN_FILTER_DATA "filter-data"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_GENERIC_AUTH_CALLBACK</NAME>
#define SOUP_AUTH_DOMAIN_GENERIC_AUTH_CALLBACK "generic-auth-callback"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_GENERIC_AUTH_DATA</NAME>
#define SOUP_AUTH_DOMAIN_GENERIC_AUTH_DATA     "generic-auth-data"
</MACRO>
<USER_FUNCTION>
<NAME>SoupAuthDomainFilter</NAME>
<RETURNS>gboolean </RETURNS>
SoupAuthDomain *domain,
					  SoupMessage    *msg,
					  gpointer        user_data
</USER_FUNCTION>
<USER_FUNCTION>
<NAME>SoupAuthDomainGenericAuthCallback</NAME>
<RETURNS>gboolean </RETURNS>
SoupAuthDomain *domain,
						       SoupMessage    *msg,
						       const char     *username,
						       gpointer        user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_get_type</NAME>
<RETURNS>GType       </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_add_path</NAME>
<RETURNS>void        </RETURNS>
SoupAuthDomain       *domain,const char           *path
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_remove_path</NAME>
<RETURNS>void        </RETURNS>
SoupAuthDomain       *domain,const char           *path
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_set_filter</NAME>
<RETURNS>void        </RETURNS>
SoupAuthDomain       *domain,SoupAuthDomainFilter  filter,gpointer              filter_data,GDestroyNotify        dnotify
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_get_realm</NAME>
<RETURNS>const char *</RETURNS>
SoupAuthDomain       *domain
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_set_generic_auth_callback</NAME>
<RETURNS>void        </RETURNS>
SoupAuthDomain *domain,SoupAuthDomainGenericAuthCallback auth_callback,gpointer        auth_data,GDestroyNotify  dnotify
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_check_password</NAME>
<RETURNS>gboolean    </RETURNS>
SoupAuthDomain    *domain,SoupMessage       *msg,const char        *username,const char        *password
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_covers</NAME>
<RETURNS>gboolean    </RETURNS>
SoupAuthDomain       *domain,SoupMessage          *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_accepts</NAME>
<RETURNS>char       *</RETURNS>
SoupAuthDomain       *domain,SoupMessage          *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_challenge</NAME>
<RETURNS>void        </RETURNS>
SoupAuthDomain       *domain,SoupMessage          *msg
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_try_generic_auth_callback</NAME>
<RETURNS>gboolean    </RETURNS>
SoupAuthDomain *domain,SoupMessage    *msg,const char     *username
</FUNCTION>
<TYPEDEF>
<NAME>SoupMultipart</NAME>
typedef struct SoupMultipart SoupMultipart;
</TYPEDEF>
<FUNCTION>
<NAME>soup_multipart_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_MULTIPART</NAME>
#define SOUP_TYPE_MULTIPART (soup_multipart_get_type ())
</MACRO>
<FUNCTION>
<NAME>soup_multipart_new</NAME>
<RETURNS>SoupMultipart *</RETURNS>
const char          *mime_type
</FUNCTION>
<FUNCTION>
<NAME>soup_multipart_new_from_message</NAME>
<RETURNS>SoupMultipart *</RETURNS>
SoupMessageHeaders  *headers,SoupMessageBody     *body
</FUNCTION>
<FUNCTION>
<NAME>soup_multipart_get_length</NAME>
<RETURNS>int      </RETURNS>
SoupMultipart       *multipart
</FUNCTION>
<FUNCTION>
<NAME>soup_multipart_get_part</NAME>
<RETURNS>gboolean </RETURNS>
SoupMultipart       *multipart,int                  part,SoupMessageHeaders **headers,SoupBuffer         **body
</FUNCTION>
<FUNCTION>
<NAME>soup_multipart_append_part</NAME>
<RETURNS>void     </RETURNS>
SoupMultipart       *multipart,SoupMessageHeaders  *headers,SoupBuffer          *body
</FUNCTION>
<FUNCTION>
<NAME>soup_multipart_append_form_string</NAME>
<RETURNS>void     </RETURNS>
SoupMultipart       *multipart,const char          *control_name,const char          *data
</FUNCTION>
<FUNCTION>
<NAME>soup_multipart_append_form_file</NAME>
<RETURNS>void     </RETURNS>
SoupMultipart       *multipart,const char          *control_name,const char          *filename,const char          *content_type,SoupBuffer          *body
</FUNCTION>
<FUNCTION>
<NAME>soup_multipart_to_message</NAME>
<RETURNS>void     </RETURNS>
SoupMultipart       *multipart,SoupMessageHeaders  *dest_headers,SoupMessageBody     *dest_body
</FUNCTION>
<FUNCTION>
<NAME>soup_multipart_free</NAME>
<RETURNS>void     </RETURNS>
SoupMultipart       *multipart
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_COOKIE_JAR</NAME>
#define SOUP_TYPE_COOKIE_JAR            (soup_cookie_jar_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR</NAME>
#define SOUP_COOKIE_JAR(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_COOKIE_JAR, SoupCookieJar))
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR_CLASS</NAME>
#define SOUP_COOKIE_JAR_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_COOKIE_JAR, SoupCookieJarClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_COOKIE_JAR</NAME>
#define SOUP_IS_COOKIE_JAR(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_COOKIE_JAR))
</MACRO>
<MACRO>
<NAME>SOUP_IS_COOKIE_JAR_CLASS</NAME>
#define SOUP_IS_COOKIE_JAR_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_COOKIE_JAR))
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR_GET_CLASS</NAME>
#define SOUP_COOKIE_JAR_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_COOKIE_JAR, SoupCookieJarClass))
</MACRO>
<STRUCT>
<NAME>SoupCookieJar</NAME>
typedef struct {
	GObject parent;

} SoupCookieJar;
</STRUCT>
<STRUCT>
<NAME>SoupCookieJarClass</NAME>
typedef struct {
	GObjectClass parent_class;

	void (*save)    (SoupCookieJar *jar);

	/* signals */
	void (*changed) (SoupCookieJar *jar,
			 SoupCookie    *old_cookie,
			 SoupCookie    *new_cookie);

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
} SoupCookieJarClass;
</STRUCT>
<MACRO>
<NAME>SOUP_COOKIE_JAR_READ_ONLY</NAME>
#define SOUP_COOKIE_JAR_READ_ONLY "read-only"
</MACRO>
<FUNCTION>
<NAME>soup_cookie_jar_get_type</NAME>
<RETURNS>GType          </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_new</NAME>
<RETURNS>SoupCookieJar *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_save</NAME>
<DEPRECATED/>
<RETURNS>void           </RETURNS>
SoupCookieJar *jar
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_get_cookies</NAME>
<RETURNS>char          *</RETURNS>
SoupCookieJar *jar,SoupURI       *uri,gboolean       for_http
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_set_cookie</NAME>
<RETURNS>void           </RETURNS>
SoupCookieJar *jar,SoupURI       *uri,const char    *cookie
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_add_cookie</NAME>
<RETURNS>void           </RETURNS>
SoupCookieJar *jar,SoupCookie    *cookie
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_delete_cookie</NAME>
<RETURNS>void           </RETURNS>
SoupCookieJar *jar,SoupCookie    *cookie
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_all_cookies</NAME>
<RETURNS>GSList        *</RETURNS>
SoupCookieJar *jar
</FUNCTION>
<MACRO>
<NAME>SOUP_VALUE_SETV</NAME>
#define SOUP_VALUE_SETV(val, type, args)				\
G_STMT_START {								\
	char *error = NULL;						\
									\
	memset (val, 0, sizeof (GValue));				\
	g_value_init (val, type);					\
	G_VALUE_COLLECT (val, args, G_VALUE_NOCOPY_CONTENTS, &error);	\
	if (error)							\
		g_free (error);						\
} G_STMT_END
</MACRO>
<MACRO>
<NAME>SOUP_VALUE_GETV</NAME>
#define SOUP_VALUE_GETV(val, type, args)				\
G_STMT_START {								\
	char *error = NULL;						\
									\
	G_VALUE_LCOPY (val, args, G_VALUE_NOCOPY_CONTENTS, &error);	\
	if (error)							\
		g_free (error);						\
} G_STMT_END
</MACRO>
<FUNCTION>
<NAME>soup_value_hash_new</NAME>
<RETURNS>GHashTable  *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_value_hash_new_with_vals</NAME>
<RETURNS>GHashTable  *</RETURNS>
const char  *first_key,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_hash_insert_value</NAME>
<RETURNS>void         </RETURNS>
GHashTable  *hash,const char  *key,GValue      *value
</FUNCTION>
<FUNCTION>
<NAME>soup_value_hash_insert</NAME>
<RETURNS>void         </RETURNS>
GHashTable  *hash,const char  *key,GType        type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_hash_insert_vals</NAME>
<RETURNS>void         </RETURNS>
GHashTable  *hash,const char  *first_key,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_hash_lookup</NAME>
<RETURNS>gboolean     </RETURNS>
GHashTable  *hash,const char  *key,GType        type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_hash_lookup_vals</NAME>
<RETURNS>gboolean     </RETURNS>
GHashTable  *hash,const char  *first_key,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_array_from_args</NAME>
<RETURNS>GValueArray *</RETURNS>
va_list      args
</FUNCTION>
<FUNCTION>
<NAME>soup_value_array_to_args</NAME>
<RETURNS>gboolean     </RETURNS>
GValueArray *array,va_list      args
</FUNCTION>
<FUNCTION>
<NAME>soup_value_array_new</NAME>
<RETURNS>GValueArray *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_value_array_new_with_vals</NAME>
<RETURNS>GValueArray *</RETURNS>
GType        first_type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_array_insert</NAME>
<RETURNS>void         </RETURNS>
GValueArray *array,guint        index_,GType        type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_array_append</NAME>
<RETURNS>void         </RETURNS>
GValueArray *array,GType        type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_array_append_vals</NAME>
<RETURNS>void         </RETURNS>
GValueArray *array,GType        first_type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_value_array_get_nth</NAME>
<RETURNS>gboolean     </RETURNS>
GValueArray *array,guint        index_,GType        type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_byte_array_get_type</NAME>
<RETURNS>GType        </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_BYTE_ARRAY</NAME>
#define SOUP_TYPE_BYTE_ARRAY (soup_byte_array_get_type ())
</MACRO>
<ENUM>
<NAME>SoupMemoryUse</NAME>
typedef enum {
	SOUP_MEMORY_STATIC,
	SOUP_MEMORY_TAKE,
	SOUP_MEMORY_COPY,
	SOUP_MEMORY_TEMPORARY
} SoupMemoryUse;
</ENUM>
<STRUCT>
<NAME>SoupBuffer</NAME>
typedef struct {
	const char *data;
	gsize       length;
} SoupBuffer;
</STRUCT>
<FUNCTION>
<NAME>soup_buffer_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_BUFFER</NAME>
#define SOUP_TYPE_BUFFER (soup_buffer_get_type ())
</MACRO>
<FUNCTION>
<NAME>soup_buffer_new</NAME>
<RETURNS>SoupBuffer *</RETURNS>
SoupMemoryUse   use,gconstpointer   data,gsize           length
</FUNCTION>
<FUNCTION>
<NAME>soup_buffer_new_subbuffer</NAME>
<RETURNS>SoupBuffer *</RETURNS>
SoupBuffer     *parent,gsize           offset,gsize           length
</FUNCTION>
<FUNCTION>
<NAME>soup_buffer_new_with_owner</NAME>
<RETURNS>SoupBuffer *</RETURNS>
gconstpointer   data,gsize           length,gpointer        owner,GDestroyNotify  owner_dnotify
</FUNCTION>
<FUNCTION>
<NAME>soup_buffer_get_owner</NAME>
<RETURNS>gpointer    </RETURNS>
SoupBuffer     *buffer
</FUNCTION>
<FUNCTION>
<NAME>soup_buffer_copy</NAME>
<RETURNS>SoupBuffer *</RETURNS>
SoupBuffer     *buffer
</FUNCTION>
<FUNCTION>
<NAME>soup_buffer_free</NAME>
<RETURNS>void        </RETURNS>
SoupBuffer     *buffer
</FUNCTION>
<STRUCT>
<NAME>SoupMessageBody</NAME>
typedef struct {
	const char *data;
	goffset     length;
} SoupMessageBody;
</STRUCT>
<FUNCTION>
<NAME>soup_message_body_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_MESSAGE_BODY</NAME>
#define SOUP_TYPE_MESSAGE_BODY (soup_message_body_get_type ())
</MACRO>
<FUNCTION>
<NAME>soup_message_body_new</NAME>
<RETURNS>SoupMessageBody *</RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_set_accumulate</NAME>
<RETURNS>void             </RETURNS>
SoupMessageBody *body,gboolean         accumulate
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_get_accumulate</NAME>
<RETURNS>gboolean         </RETURNS>
SoupMessageBody *body
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_append</NAME>
<RETURNS>void             </RETURNS>
SoupMessageBody *body,SoupMemoryUse    use,gconstpointer    data,gsize            length
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_append_buffer</NAME>
<RETURNS>void             </RETURNS>
SoupMessageBody *body,SoupBuffer      *buffer
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_truncate</NAME>
<RETURNS>void             </RETURNS>
SoupMessageBody *body
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_complete</NAME>
<RETURNS>void             </RETURNS>
SoupMessageBody *body
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_flatten</NAME>
<RETURNS>SoupBuffer      *</RETURNS>
SoupMessageBody *body
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_get_chunk</NAME>
<RETURNS>SoupBuffer      *</RETURNS>
SoupMessageBody *body,goffset          offset
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_got_chunk</NAME>
<RETURNS>void             </RETURNS>
SoupMessageBody *body,SoupBuffer      *chunk
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_wrote_chunk</NAME>
<RETURNS>void             </RETURNS>
SoupMessageBody *body,SoupBuffer      *chunk
</FUNCTION>
<FUNCTION>
<NAME>soup_message_body_free</NAME>
<RETURNS>void             </RETURNS>
SoupMessageBody *body
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_COOKIE_JAR_SQLITE</NAME>
#define SOUP_TYPE_COOKIE_JAR_SQLITE            (soup_cookie_jar_sqlite_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR_SQLITE</NAME>
#define SOUP_COOKIE_JAR_SQLITE(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_COOKIE_JAR_SQLITE, SoupCookieJarSqlite))
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR_SQLITE_CLASS</NAME>
#define SOUP_COOKIE_JAR_SQLITE_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_COOKIE_JAR_SQLITE, SoupCookieJarSqliteClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_COOKIE_JAR_SQLITE</NAME>
#define SOUP_IS_COOKIE_JAR_SQLITE(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_COOKIE_JAR_SQLITE))
</MACRO>
<MACRO>
<NAME>SOUP_IS_COOKIE_JAR_SQLITE_CLASS</NAME>
#define SOUP_IS_COOKIE_JAR_SQLITE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_COOKIE_JAR_SQLITE))
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR_SQLITE_GET_CLASS</NAME>
#define SOUP_COOKIE_JAR_SQLITE_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_COOKIE_JAR_SQLITE, SoupCookieJarSqliteClass))
</MACRO>
<STRUCT>
<NAME>SoupCookieJarSqlite</NAME>
typedef struct {
	SoupCookieJar parent;

} SoupCookieJarSqlite;
</STRUCT>
<STRUCT>
<NAME>SoupCookieJarSqliteClass</NAME>
typedef struct {
	SoupCookieJarClass parent_class;

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupCookieJarSqliteClass;
</STRUCT>
<MACRO>
<NAME>SOUP_COOKIE_JAR_SQLITE_FILENAME</NAME>
#define SOUP_COOKIE_JAR_SQLITE_FILENAME  "filename"
</MACRO>
<FUNCTION>
<NAME>soup_cookie_jar_sqlite_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_sqlite_new</NAME>
<RETURNS>SoupCookieJar *</RETURNS>
const char *filename,gboolean    read_only
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_COOKIE_JAR_TEXT</NAME>
#define SOUP_TYPE_COOKIE_JAR_TEXT            (soup_cookie_jar_text_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR_TEXT</NAME>
#define SOUP_COOKIE_JAR_TEXT(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_COOKIE_JAR_TEXT, SoupCookieJarText))
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR_TEXT_CLASS</NAME>
#define SOUP_COOKIE_JAR_TEXT_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_COOKIE_JAR_TEXT, SoupCookieJarTextClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_COOKIE_JAR_TEXT</NAME>
#define SOUP_IS_COOKIE_JAR_TEXT(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_COOKIE_JAR_TEXT))
</MACRO>
<MACRO>
<NAME>SOUP_IS_COOKIE_JAR_TEXT_CLASS</NAME>
#define SOUP_IS_COOKIE_JAR_TEXT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_COOKIE_JAR_TEXT))
</MACRO>
<MACRO>
<NAME>SOUP_COOKIE_JAR_TEXT_GET_CLASS</NAME>
#define SOUP_COOKIE_JAR_TEXT_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_COOKIE_JAR_TEXT, SoupCookieJarTextClass))
</MACRO>
<STRUCT>
<NAME>SoupCookieJarText</NAME>
typedef struct {
	SoupCookieJar parent;

} SoupCookieJarText;
</STRUCT>
<STRUCT>
<NAME>SoupCookieJarTextClass</NAME>
typedef struct {
	SoupCookieJarClass parent_class;

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupCookieJarTextClass;
</STRUCT>
<MACRO>
<NAME>SOUP_COOKIE_JAR_TEXT_FILENAME</NAME>
#define SOUP_COOKIE_JAR_TEXT_FILENAME  "filename"
</MACRO>
<FUNCTION>
<NAME>soup_cookie_jar_text_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_cookie_jar_text_new</NAME>
<RETURNS>SoupCookieJar *</RETURNS>
const char *filename,gboolean    read_only
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_PROXY_RESOLVER</NAME>
<DEPRECATED/>
#define SOUP_TYPE_PROXY_RESOLVER            (soup_proxy_resolver_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_PROXY_RESOLVER</NAME>
<DEPRECATED/>
#define SOUP_PROXY_RESOLVER(object)         (G_TYPE_CHECK_INSTANCE_CAST ((object), SOUP_TYPE_PROXY_RESOLVER, SoupProxyResolver))
</MACRO>
<MACRO>
<NAME>SOUP_PROXY_RESOLVER_CLASS</NAME>
<DEPRECATED/>
#define SOUP_PROXY_RESOLVER_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_PROXY_RESOLVER, SoupProxyResolverInterface))
</MACRO>
<MACRO>
<NAME>SOUP_IS_PROXY_RESOLVER</NAME>
<DEPRECATED/>
#define SOUP_IS_PROXY_RESOLVER(object)      (G_TYPE_CHECK_INSTANCE_TYPE ((object), SOUP_TYPE_PROXY_RESOLVER))
</MACRO>
<MACRO>
<NAME>SOUP_IS_PROXY_RESOLVER_CLASS</NAME>
<DEPRECATED/>
#define SOUP_IS_PROXY_RESOLVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_PROXY_RESOLVER))
</MACRO>
<MACRO>
<NAME>SOUP_PROXY_RESOLVER_GET_CLASS</NAME>
<DEPRECATED/>
#define SOUP_PROXY_RESOLVER_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SOUP_TYPE_PROXY_RESOLVER, SoupProxyResolverInterface))
</MACRO>
<STRUCT>
<NAME>SoupProxyResolver</NAME>
<DEPRECATED/>
</STRUCT>
<USER_FUNCTION>
<NAME>SoupProxyResolverCallback</NAME>
<DEPRECATED/>
<RETURNS>void </RETURNS>
SoupProxyResolver *, SoupMessage *,
					   guint, SoupAddress *, gpointer
</USER_FUNCTION>
<STRUCT>
<NAME>SoupProxyResolverInterface</NAME>
<DEPRECATED/>
typedef struct {
	GTypeInterface base;

	/* virtual methods */
	void (*get_proxy_async) (SoupProxyResolver *, SoupMessage *,
				 GMainContext *, GCancellable *,
				 SoupProxyResolverCallback, gpointer);
	guint (*get_proxy_sync) (SoupProxyResolver *, SoupMessage *,
				 GCancellable *, SoupAddress **);

} SoupProxyResolverInterface;
</STRUCT>
<FUNCTION>
<NAME>soup_proxy_resolver_get_type</NAME>
<DEPRECATED/>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_proxy_resolver_get_proxy_async</NAME>
<DEPRECATED/>
<RETURNS>void  </RETURNS>
SoupProxyResolver  *proxy_resolver,SoupMessage        *msg,GMainContext       *async_context,GCancellable       *cancellable,SoupProxyResolverCallback callback,gpointer            user_data
</FUNCTION>
<FUNCTION>
<NAME>soup_proxy_resolver_get_proxy_sync</NAME>
<DEPRECATED/>
<RETURNS>guint </RETURNS>
SoupProxyResolver  *proxy_resolver,SoupMessage        *msg,GCancellable       *cancellable,SoupAddress       **addr
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_build_method_call</NAME>
<RETURNS>char        *</RETURNS>
const char   *method_name,GValue       *params,int           n_params
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_request_new</NAME>
<RETURNS>SoupMessage *</RETURNS>
const char   *uri,const char   *method_name,...
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_parse_method_response</NAME>
<RETURNS>gboolean     </RETURNS>
const char   *method_response,int           length,GValue       *value,GError      **error
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_extract_method_response</NAME>
<RETURNS>gboolean     </RETURNS>
const char   *method_response,int           length,GError      **error,GType         type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_parse_method_call</NAME>
<RETURNS>gboolean     </RETURNS>
const char   *method_call,int           length,char        **method_name,GValueArray **params
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_extract_method_call</NAME>
<RETURNS>gboolean     </RETURNS>
const char   *method_call,int           length,char        **method_name,...
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_build_method_response</NAME>
<RETURNS>char        *</RETURNS>
GValue       *value
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_build_fault</NAME>
<RETURNS>char        *</RETURNS>
int           fault_code,const char   *fault_format,...
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_set_response</NAME>
<RETURNS>void         </RETURNS>
SoupMessage  *msg,GType         type,...
</FUNCTION>
<FUNCTION>
<NAME>soup_xmlrpc_set_fault</NAME>
<RETURNS>void         </RETURNS>
SoupMessage  *msg,int           fault_code,const char   *fault_format,...
</FUNCTION>
<MACRO>
<NAME>SOUP_XMLRPC_ERROR</NAME>
#define SOUP_XMLRPC_ERROR soup_xmlrpc_error_quark()
</MACRO>
<FUNCTION>
<NAME>soup_xmlrpc_error_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>SoupXMLRPCError</NAME>
typedef enum {
	SOUP_XMLRPC_ERROR_ARGUMENTS,
	SOUP_XMLRPC_ERROR_RETVAL
} SoupXMLRPCError;
</ENUM>
<MACRO>
<NAME>SOUP_XMLRPC_FAULT</NAME>
#define SOUP_XMLRPC_FAULT soup_xmlrpc_fault_quark()
</MACRO>
<FUNCTION>
<NAME>soup_xmlrpc_fault_quark</NAME>
<RETURNS>GQuark </RETURNS>
void
</FUNCTION>
<ENUM>
<NAME>SoupXMLRPCFault</NAME>
typedef enum {
	SOUP_XMLRPC_FAULT_PARSE_ERROR_NOT_WELL_FORMED = -32700,
	SOUP_XMLRPC_FAULT_PARSE_ERROR_UNSUPPORTED_ENCODING = -32701,
	SOUP_XMLRPC_FAULT_PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING = -32702,
	SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_XML_RPC = -32600,
	SOUP_XMLRPC_FAULT_SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND = -32601,
	SOUP_XMLRPC_FAULT_SERVER_ERROR_INVALID_METHOD_PARAMETERS = -32602,
	SOUP_XMLRPC_FAULT_SERVER_ERROR_INTERNAL_XML_RPC_ERROR = -32603,
	SOUP_XMLRPC_FAULT_APPLICATION_ERROR = -32500,
	SOUP_XMLRPC_FAULT_SYSTEM_ERROR = -32400,
	SOUP_XMLRPC_FAULT_TRANSPORT_ERROR = -32300
} SoupXMLRPCFault;
</ENUM>
<MACRO>
<NAME>SOUP_TYPE_AUTH_DOMAIN_DIGEST</NAME>
#define SOUP_TYPE_AUTH_DOMAIN_DIGEST            (soup_auth_domain_digest_get_type ())
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_DIGEST</NAME>
#define SOUP_AUTH_DOMAIN_DIGEST(obj)            (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_AUTH_DOMAIN_DIGEST, SoupAuthDomainDigest))
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_DIGEST_CLASS</NAME>
#define SOUP_AUTH_DOMAIN_DIGEST_CLASS(klass)    (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_AUTH_DOMAIN_DIGEST, SoupAuthDomainDigestClass))
</MACRO>
<MACRO>
<NAME>SOUP_IS_AUTH_DOMAIN_DIGEST</NAME>
#define SOUP_IS_AUTH_DOMAIN_DIGEST(obj)         (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_AUTH_DOMAIN_DIGEST))
</MACRO>
<MACRO>
<NAME>SOUP_IS_AUTH_DOMAIN_DIGEST_CLASS</NAME>
#define SOUP_IS_AUTH_DOMAIN_DIGEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_AUTH_DOMAIN_DIGEST))
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_DIGEST_GET_CLASS</NAME>
#define SOUP_AUTH_DOMAIN_DIGEST_GET_CLASS(obj)  (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_DOMAIN_DIGEST, SoupAuthDomainDigestClass))
</MACRO>
<STRUCT>
<NAME>SoupAuthDomainDigest</NAME>
typedef struct {
	SoupAuthDomain parent;

} SoupAuthDomainDigest;
</STRUCT>
<STRUCT>
<NAME>SoupAuthDomainDigestClass</NAME>
typedef struct {
	SoupAuthDomainClass parent_class;

	/* Padding for future expansion */
	void (*_libsoup_reserved1) (void);
	void (*_libsoup_reserved2) (void);
	void (*_libsoup_reserved3) (void);
	void (*_libsoup_reserved4) (void);
} SoupAuthDomainDigestClass;
</STRUCT>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK</NAME>
#define SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK "auth-callback"
</MACRO>
<MACRO>
<NAME>SOUP_AUTH_DOMAIN_DIGEST_AUTH_DATA</NAME>
#define SOUP_AUTH_DOMAIN_DIGEST_AUTH_DATA     "auth-data"
</MACRO>
<FUNCTION>
<NAME>soup_auth_domain_digest_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_digest_new</NAME>
<RETURNS>SoupAuthDomain *</RETURNS>
const char *optname1,...
</FUNCTION>
<USER_FUNCTION>
<NAME>SoupAuthDomainDigestAuthCallback</NAME>
<RETURNS>char *</RETURNS>
SoupAuthDomain *domain,
						    SoupMessage    *msg,
						    const char     *username,
						    gpointer        user_data
</USER_FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_digest_set_auth_callback</NAME>
<RETURNS>void    </RETURNS>
SoupAuthDomain *domain,SoupAuthDomainDigestAuthCallback callback,gpointer        user_data,GDestroyNotify  dnotify
</FUNCTION>
<FUNCTION>
<NAME>soup_auth_domain_digest_encode_password</NAME>
<RETURNS>char   *</RETURNS>
const char     *username,const char     *realm,const char     *password
</FUNCTION>
<FUNCTION>
<NAME>soup_proxy_resolver_gnome_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_PROXY_RESOLVER_GNOME</NAME>
#define SOUP_TYPE_PROXY_RESOLVER_GNOME (soup_proxy_resolver_gnome_get_type ())
</MACRO>
<FUNCTION>
<NAME>soup_gnome_features_2_26_get_type</NAME>
<RETURNS>GType </RETURNS>
void
</FUNCTION>
<MACRO>
<NAME>SOUP_TYPE_GNOME_FEATURES_2_26</NAME>
#define SOUP_TYPE_GNOME_FEATURES_2_26 (soup_gnome_features_2_26_get_type ())
</MACRO>
