SoupMessageQueue typedef struct SoupMessageQueue SoupMessageQueue; SoupMessageQueueIter typedef struct { GList *cur, *next; } SoupMessageQueueIter; soup_message_queue_new SoupMessageQueue * void soup_message_queue_append void SoupMessageQueue *queue,SoupMessage *msg soup_message_queue_first SoupMessage * SoupMessageQueue *queue,SoupMessageQueueIter *iter soup_message_queue_next SoupMessage * SoupMessageQueue *queue,SoupMessageQueueIter *iter soup_message_queue_remove SoupMessage * SoupMessageQueue *queue,SoupMessageQueueIter *iter soup_message_queue_free_iter void SoupMessageQueue *queue,SoupMessageQueueIter *iter soup_message_queue_destroy void SoupMessageQueue *queue soup_message_queue_remove_message void SoupMessageQueue *queue,SoupMessage *msg SOUP_TYPE_MESSAGE #define SOUP_TYPE_MESSAGE (soup_message_get_type ()) SOUP_MESSAGE #define SOUP_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_MESSAGE, SoupMessage)) SOUP_MESSAGE_CLASS #define SOUP_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_MESSAGE, SoupMessageClass)) SOUP_IS_MESSAGE #define SOUP_IS_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_MESSAGE)) SOUP_IS_MESSAGE_CLASS #define SOUP_IS_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_MESSAGE)) SOUP_MESSAGE_GET_CLASS #define SOUP_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_MESSAGE, SoupMessageClass)) SoupMessagePrivate typedef struct SoupMessagePrivate SoupMessagePrivate; SoupMessageStatus typedef enum { SOUP_MESSAGE_STATUS_IDLE, SOUP_MESSAGE_STATUS_QUEUED, SOUP_MESSAGE_STATUS_CONNECTING, SOUP_MESSAGE_STATUS_RUNNING, SOUP_MESSAGE_STATUS_FINISHED } SoupMessageStatus; SOUP_MESSAGE_IS_STARTING #define SOUP_MESSAGE_IS_STARTING(msg) (msg->status == SOUP_MESSAGE_STATUS_QUEUED || msg->status == SOUP_MESSAGE_STATUS_CONNECTING) SoupTransferEncoding typedef enum { SOUP_TRANSFER_UNKNOWN = 0, SOUP_TRANSFER_CHUNKED, SOUP_TRANSFER_CONTENT_LENGTH } SoupTransferEncoding; SoupOwnership typedef enum { SOUP_BUFFER_SYSTEM_OWNED = 0, SOUP_BUFFER_USER_OWNED, SOUP_BUFFER_STATIC } SoupOwnership; SoupDataBuffer typedef struct { SoupOwnership owner; char *body; guint length; } SoupDataBuffer; SoupMessage struct SoupMessage { GObject parent; SoupMessagePrivate *priv; const char *method; guint status_code; const char *reason_phrase; SoupDataBuffer request; GHashTable *request_headers; SoupDataBuffer response; GHashTable *response_headers; SoupMessageStatus status; }; SoupMessageClass 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); void (*got_body) (SoupMessage *msg); void (*restarted) (SoupMessage *msg); void (*finished) (SoupMessage *msg); } SoupMessageClass; soup_message_get_type GType void SoupMessageCallbackFn void SoupMessage *req, gpointer user_data soup_message_new SoupMessage * const char *method,const char *uri_string soup_message_new_from_uri SoupMessage * const char *method,const SoupUri *uri soup_message_set_request void SoupMessage *msg,const char *content_type,SoupOwnership req_owner,char *req_body,gulong req_length soup_message_set_response void SoupMessage *msg,const char *content_type,SoupOwnership resp_owner,char *resp_body,gulong resp_length soup_message_add_header void GHashTable *hash,const char *name,const char *value soup_message_get_header const char * GHashTable *hash,const char *name soup_message_get_header_list const GSList * GHashTable *hash,const char *name soup_message_foreach_header void GHashTable *hash,GHFunc func,gpointer user_data soup_message_remove_header void GHashTable *hash,const char *name soup_message_clear_headers void GHashTable *hash SoupHttpVersion typedef enum { SOUP_HTTP_1_0 = 0, SOUP_HTTP_1_1 = 1 } SoupHttpVersion; soup_message_set_http_version void SoupMessage *msg,SoupHttpVersion version soup_message_get_http_version SoupHttpVersion SoupMessage *msg soup_message_is_keepalive gboolean SoupMessage *msg soup_message_get_uri const SoupUri * SoupMessage *msg soup_message_set_uri void SoupMessage *msg,const SoupUri *uri SoupMessageFlags typedef enum { /* * SOUP_MESSAGE_NO_REDIRECT: * Do not follow redirection responses. */ SOUP_MESSAGE_NO_REDIRECT = (1 << 1), /* * SOUP_MESSAGE_OVERWRITE_CHUNKS: * Downloaded data chunks should not be stored in the response * data buffer. Instead only send data to SOUP_HANDLER_BODY_CHUNK * handlers, then truncate the data buffer. * * Useful when the response is expected to be very large, and * storage in memory is not desired. */ SOUP_MESSAGE_OVERWRITE_CHUNKS = (1 << 3), /* * SOUP_MESSAGE_EXPECT_CONTINUE: The message includes an * "Expect: 100-continue" header, and we should not send the * body until the Continue response has been received. (This * is automatically set if there is an "Expect: 100-continue" * header.) */ SOUP_MESSAGE_EXPECT_CONTINUE = (1 << 4) } SoupMessageFlags; soup_message_set_flags void SoupMessage *msg,guint flags soup_message_get_flags guint SoupMessage *msg SoupHandlerPhase typedef enum { SOUP_HANDLER_POST_REQUEST = 1, SOUP_HANDLER_PRE_BODY, SOUP_HANDLER_BODY_CHUNK, SOUP_HANDLER_POST_BODY } SoupHandlerPhase; soup_message_add_handler void SoupMessage *msg,SoupHandlerPhase type,SoupMessageCallbackFn handler_cb,gpointer user_data soup_message_add_header_handler void SoupMessage *msg,const char *header,SoupHandlerPhase type,SoupMessageCallbackFn,gpointer user_data soup_message_add_status_code_handler void SoupMessage *msg,guint status_code,SoupHandlerPhase type,SoupMessageCallbackFn,gpointer user_data soup_message_add_status_class_handler void SoupMessage *msg,SoupStatusClass status_class,SoupHandlerPhase type,SoupMessageCallbackFn,gpointer user_data soup_message_remove_handler void SoupMessage *msg,SoupHandlerPhase type,SoupMessageCallbackFn,gpointer user_data soup_message_set_status void SoupMessage *msg,guint status_code soup_message_set_status_full void SoupMessage *msg,guint status_code,const char *reason_phrase soup_message_add_chunk void SoupMessage *msg,SoupOwnership owner,const char *body,guint length soup_message_add_final_chunk void SoupMessage *msg soup_message_pop_chunk SoupDataBuffer* SoupMessage *msg soup_message_send_request void SoupMessage *req,SoupSocket *sock,gboolean via_proxy soup_message_read_request void SoupMessage *req,SoupSocket *sock soup_message_io_stop void SoupMessage *msg soup_message_io_pause void SoupMessage *msg soup_message_io_unpause void SoupMessage *msg soup_message_wrote_informational void SoupMessage *msg soup_message_wrote_headers void SoupMessage *msg soup_message_wrote_chunk void SoupMessage *msg soup_message_wrote_body void SoupMessage *msg soup_message_got_informational void SoupMessage *msg soup_message_got_headers void SoupMessage *msg soup_message_got_chunk void SoupMessage *msg soup_message_got_body void SoupMessage *msg soup_message_restarted void SoupMessage *msg soup_message_finished void SoupMessage *msg SOUP_TYPE_MESSAGE_FILTER #define SOUP_TYPE_MESSAGE_FILTER (soup_message_filter_get_type ()) SOUP_MESSAGE_FILTER #define SOUP_MESSAGE_FILTER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_MESSAGE_FILTER, SoupMessageFilter)) SOUP_MESSAGE_FILTER_CLASS #define SOUP_MESSAGE_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_MESSAGE_FILTER, SoupMessageFilterClass)) SOUP_IS_MESSAGE_FILTER #define SOUP_IS_MESSAGE_FILTER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_MESSAGE_FILTER)) SOUP_IS_MESSAGE_FILTER_CLASS #define SOUP_IS_MESSAGE_FILTER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_MESSAGE_FILTER)) SOUP_MESSAGE_FILTER_GET_CLASS #define SOUP_MESSAGE_FILTER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_INTERFACE ((obj), SOUP_TYPE_MESSAGE_FILTER, SoupMessageFilterClass)) SoupMessageFilterClass typedef struct { GTypeInterface parent; /* methods */ void (*setup_message) (SoupMessageFilter *filter, SoupMessage *msg); } SoupMessageFilterClass; soup_message_filter_get_type GType void soup_message_filter_setup_message void SoupMessageFilter *filter,SoupMessage *msg SOUP_TYPE_AUTH_DIGEST #define SOUP_TYPE_AUTH_DIGEST (soup_auth_digest_get_type ()) SOUP_AUTH_DIGEST #define SOUP_AUTH_DIGEST(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), SOUP_TYPE_AUTH_DIGEST, SoupAuthDigest)) SOUP_AUTH_DIGEST_CLASS #define SOUP_AUTH_DIGEST_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_AUTH_DIGEST, SoupAuthDigestClass)) SOUP_IS_AUTH_DIGEST #define SOUP_IS_AUTH_DIGEST(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), SOUP_TYPE_AUTH_DIGEST)) SOUP_IS_AUTH_DIGEST_CLASS #define SOUP_IS_AUTH_DIGEST_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_AUTH_DIGEST)) SOUP_AUTH_DIGEST_GET_CLASS #define SOUP_AUTH_DIGEST_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_DIGEST, SoupAuthDigestClass)) SoupAuthDigestPrivate typedef struct SoupAuthDigestPrivate SoupAuthDigestPrivate; SoupAuthDigest typedef struct { SoupAuth parent; SoupAuthDigestPrivate *priv; } SoupAuthDigest; SoupAuthDigestClass typedef struct { SoupAuthClass parent_class; } SoupAuthDigestClass; soup_auth_digest_get_type GType void SoupMD5Context typedef struct { guint32 buf[4]; guint32 bits[2]; guchar in[64]; gboolean doByteReverse; } SoupMD5Context; soup_md5_init void SoupMD5Context *ctx soup_md5_update void SoupMD5Context *ctx,const guchar *buf,guint32 len soup_md5_final void SoupMD5Context *ctx,guchar digest[16] SOUP_TYPE_SESSION_SYNC #define SOUP_TYPE_SESSION_SYNC (soup_session_sync_get_type ()) SOUP_SESSION_SYNC #define SOUP_SESSION_SYNC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SESSION_SYNC, SoupSessionSync)) SOUP_SESSION_SYNC_CLASS #define SOUP_SESSION_SYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncClass)) SOUP_IS_SESSION_SYNC #define SOUP_IS_SESSION_SYNC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SESSION_SYNC)) SOUP_IS_SESSION_SYNC_CLASS #define SOUP_IS_SESSION_SYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_SYNC)) SOUP_SESSION_SYNC_GET_CLASS #define SOUP_SESSION_SYNC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_SYNC, SoupSessionSyncClass)) SoupSessionSyncPrivate typedef struct SoupSessionSyncPrivate SoupSessionSyncPrivate; SoupSessionSync struct SoupSessionSync { SoupSession parent; SoupSessionSyncPrivate *priv; }; SoupSessionSyncClass typedef struct { SoupSessionClass parent_class; } SoupSessionSyncClass; soup_session_sync_get_type GType void soup_session_sync_new SoupSession * void soup_session_sync_new_with_options SoupSession * const char *optname1,... SoupServerAuthCallbackFn gboolean SoupServerAuthContext *auth_ctx, SoupServerAuth *auth, SoupMessage *msg, gpointer data SoupServerAuthContext struct SoupServerAuthContext { guint types; SoupServerAuthCallbackFn callback; gpointer user_data; struct { const gchar *realm; } basic_info; soup_server_auth_context_challenge void SoupServerAuthContext *auth_ctx,SoupMessage *msg,gchar *header_name SoupAuthType typedef enum { SOUP_AUTH_TYPE_BASIC = 1, SOUP_AUTH_TYPE_DIGEST } SoupAuthType; SoupServerAuthBasic typedef struct { SoupAuthType type; const gchar *user; const gchar *passwd; } SoupServerAuthBasic; SoupDigestAlgorithm typedef enum { SOUP_ALGORITHM_MD5 = 1 << 0, SOUP_ALGORITHM_MD5_SESS = 1 << 1 } SoupDigestAlgorithm; SoupServerAuthDigest typedef struct { SoupAuthType type; SoupDigestAlgorithm algorithm; gboolean integrity; const gchar *realm; const gchar *user; const gchar *nonce; gint nonce_count; const gchar *cnonce; const gchar *digest_uri; const gchar *digest_response; const gchar *request_method; } SoupServerAuthDigest; soup_server_auth_new SoupServerAuth * SoupServerAuthContext *auth_ctx,const GSList *auth_hdrs,SoupMessage *msg soup_server_auth_free void SoupServerAuth *auth soup_server_auth_get_user const gchar * SoupServerAuth *auth soup_server_auth_check_passwd gboolean SoupServerAuth *auth,gchar *passwd SoupStatusClass typedef enum { SOUP_STATUS_CLASS_TRANSPORT_ERROR = 0, SOUP_STATUS_CLASS_INFORMATIONAL, SOUP_STATUS_CLASS_SUCCESS, SOUP_STATUS_CLASS_REDIRECT, SOUP_STATUS_CLASS_CLIENT_ERROR, SOUP_STATUS_CLASS_SERVER_ERROR } SoupStatusClass; SOUP_STATUS_IS_TRANSPORT_ERROR #define SOUP_STATUS_IS_TRANSPORT_ERROR(status) ((status) > 0 && (status) < 100) SOUP_STATUS_IS_INFORMATIONAL #define SOUP_STATUS_IS_INFORMATIONAL(status) ((status) >= 100 && (status) < 200) SOUP_STATUS_IS_SUCCESSFUL #define SOUP_STATUS_IS_SUCCESSFUL(status) ((status) >= 200 && (status) < 300) SOUP_STATUS_IS_REDIRECTION #define SOUP_STATUS_IS_REDIRECTION(status) ((status) >= 300 && (status) < 400) SOUP_STATUS_IS_CLIENT_ERROR #define SOUP_STATUS_IS_CLIENT_ERROR(status) ((status) >= 400 && (status) < 500) SOUP_STATUS_IS_SERVER_ERROR #define SOUP_STATUS_IS_SERVER_ERROR(status) ((status) >= 500 && (status) < 600) SoupKnownStatusCode 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; soup_status_get_phrase const char * guint status_code SOUP_TYPE_SERVER #define SOUP_TYPE_SERVER (soup_server_get_type ()) SOUP_SERVER #define SOUP_SERVER(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SERVER, SoupServer)) SOUP_SERVER_CLASS #define SOUP_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SERVER, SoupServerClass)) SOUP_IS_SERVER #define SOUP_IS_SERVER(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SERVER)) SOUP_IS_SERVER_CLASS #define SOUP_IS_SERVER_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SERVER)) SOUP_SERVER_GET_CLASS #define SOUP_SERVER_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SERVER, SoupServerClass)) SoupServerPrivate typedef struct SoupServerPrivate SoupServerPrivate; SoupServer struct SoupServer { GObject parent; SoupServerPrivate *priv; }; SoupServerClass typedef struct { GObjectClass parent_class; } SoupServerClass; soup_server_get_type GType void SoupServerHandler typedef struct SoupServerHandler SoupServerHandler; SoupServerContext typedef struct { SoupMessage *msg; char *path; SoupMethodId method_id; SoupServerAuth *auth; SoupServer *server; SoupServerHandler *handler; SoupSocket *sock; } SoupServerContext; SoupServerCallbackFn void SoupServerContext *context, SoupMessage *msg, gpointer user_data SoupServerUnregisterFn void SoupServer *server, SoupServerHandler *handler, gpointer user_data SoupServerHandler struct SoupServerHandler { char *path; SoupServerAuthContext *auth_ctx; SoupServerCallbackFn callback; SoupServerUnregisterFn unregister; gpointer user_data; }; SOUP_SERVER_PORT #define SOUP_SERVER_PORT "port" SOUP_SERVER_INTERFACE #define SOUP_SERVER_INTERFACE "interface" SOUP_SERVER_SSL_CERT_FILE #define SOUP_SERVER_SSL_CERT_FILE "ssl-cert-file" SOUP_SERVER_SSL_KEY_FILE #define SOUP_SERVER_SSL_KEY_FILE "ssl-key-file" soup_server_new SoupServer * const char *optname1,... soup_server_get_protocol SoupProtocol SoupServer *serv soup_server_get_port guint SoupServer *serv soup_server_run void SoupServer *serv soup_server_run_async void SoupServer *serv soup_server_quit void SoupServer *serv soup_server_add_handler void SoupServer *serv,const char *path,SoupServerAuthContext *auth_ctx,SoupServerCallbackFn callback,SoupServerUnregisterFn unreg,gpointer data soup_server_remove_handler void SoupServer *serv,const char *path soup_server_get_handler SoupServerHandler * SoupServer *serv,const char *path soup_server_list_handlers GSList * SoupServer *serv soup_server_context_get_client_address SoupAddress * SoupServerContext *ctx soup_server_context_get_client_host const char * SoupServerContext *ctx SoupDNSEntry typedef struct SoupDNSEntry SoupDNSEntry; soup_dns_entry_from_name SoupDNSEntry * const char *name soup_dns_entry_from_addr SoupDNSEntry * gconstpointer addr,int family soup_dns_entry_check_lookup gboolean SoupDNSEntry *entry soup_dns_entry_cancel_lookup void SoupDNSEntry *entry SOUP_TYPE_SESSION_ASYNC #define SOUP_TYPE_SESSION_ASYNC (soup_session_async_get_type ()) SOUP_SESSION_ASYNC #define SOUP_SESSION_ASYNC(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SESSION_ASYNC, SoupSessionAsync)) SOUP_SESSION_ASYNC_CLASS #define SOUP_SESSION_ASYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SESSION_ASYNC, SoupSessionAsyncClass)) SOUP_IS_SESSION_ASYNC #define SOUP_IS_SESSION_ASYNC(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SESSION_ASYNC)) SOUP_IS_SESSION_ASYNC_CLASS #define SOUP_IS_SESSION_ASYNC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION_ASYNC)) SOUP_SESSION_ASYNC_GET_CLASS #define SOUP_SESSION_ASYNC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION_ASYNC, SoupSessionAsyncClass)) SoupSessionAsyncPrivate typedef struct SoupSessionAsyncPrivate SoupSessionAsyncPrivate; SoupSessionAsync struct SoupSessionAsync { SoupSession parent; SoupSessionAsyncPrivate *priv; }; SoupSessionAsyncClass typedef struct { SoupSessionClass parent_class; } SoupSessionAsyncClass; soup_session_async_get_type GType void soup_session_async_new SoupSession * void soup_session_async_new_with_options SoupSession * const char *optname1,... soup_headers_parse_request gboolean char *str,int len,GHashTable *dest,char **req_method,char **req_path,SoupHttpVersion *ver soup_headers_parse_status_line gboolean const char *status_line,SoupHttpVersion *ver,guint *status_code,char **status_phrase soup_headers_parse_response gboolean char *str,int len,GHashTable *dest,SoupHttpVersion *ver,guint *status_code,char **status_phrase soup_header_param_decode_token char * char **in soup_header_param_parse_list GHashTable * const char *header soup_header_param_copy_token char * GHashTable *tokens,char *t soup_header_param_destroy_hash void GHashTable *table SoupSSLType typedef enum { SOUP_SSL_TYPE_CLIENT = 0, SOUP_SSL_TYPE_SERVER } SoupSSLType; soup_ssl_get_client_credentials gpointer const char *ca_file soup_ssl_free_client_credentials void gpointer creds soup_ssl_get_server_credentials gpointer const char *cert_file,const char *key_file soup_ssl_free_server_credentials void gpointer creds soup_ssl_wrap_iochannel GIOChannel * GIOChannel *sock,SoupSSLType type,const char *remote_host,gpointer credentials SOUP_SSL_ERROR #define SOUP_SSL_ERROR soup_ssl_error_quark() soup_ssl_error_quark GQuark void SoupSocketError typedef enum { SOUP_SSL_ERROR_HANDSHAKE_NEEDS_READ, SOUP_SSL_ERROR_HANDSHAKE_NEEDS_WRITE, SOUP_SSL_ERROR_CERTIFICATE, } SoupSocketError; SoupProtocol typedef GQuark SoupProtocol; SOUP_PROTOCOL_HTTP #define SOUP_PROTOCOL_HTTP (g_quark_from_static_string ("http")) SOUP_PROTOCOL_HTTPS #define SOUP_PROTOCOL_HTTPS (g_quark_from_static_string ("https")) SoupUri struct SoupUri { SoupProtocol protocol; char *user; char *passwd; char *host; guint port; char *path; char *query; char *fragment; /* Don't use this */ gboolean broken_encoding; }; soup_uri_new_with_base SoupUri * const SoupUri *base,const char *uri_string soup_uri_new SoupUri * const char *uri_string soup_uri_to_string char * const SoupUri *uri,gboolean just_path soup_uri_copy SoupUri * const SoupUri *uri soup_uri_copy_root SoupUri * const SoupUri *uri soup_uri_equal gboolean const SoupUri *uri1,const SoupUri *uri2 soup_uri_free void SoupUri *uri soup_uri_encode char * const char *part,const char *escape_extra soup_uri_decode void char *part soup_uri_uses_default_port gboolean const SoupUri *uri SOUP_TYPE_ADDRESS #define SOUP_TYPE_ADDRESS (soup_address_get_type ()) SOUP_ADDRESS #define SOUP_ADDRESS(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_ADDRESS, SoupAddress)) SOUP_ADDRESS_CLASS #define SOUP_ADDRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_ADDRESS, SoupAddressClass)) SOUP_IS_ADDRESS #define SOUP_IS_ADDRESS(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_ADDRESS)) SOUP_IS_ADDRESS_CLASS #define SOUP_IS_ADDRESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_ADDRESS)) SOUP_ADDRESS_GET_CLASS #define SOUP_ADDRESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_ADDRESS, SoupAddressClass)) SoupAddressPrivate typedef struct SoupAddressPrivate SoupAddressPrivate; SoupAddress struct SoupAddress { GObject parent; SoupAddressPrivate *priv; }; SoupAddressClass typedef struct { GObjectClass parent_class; /* signals */ void (*dns_result) (SoupAddress *addr, guint status); } SoupAddressClass; SoupAddressFamily typedef enum { SOUP_ADDRESS_FAMILY_IPV4 = AF_INET, SOUP_ADDRESS_FAMILY_IPV6 = AF_INET6 } SoupAddressFamily; SoupAddressFamily typedef enum { SOUP_ADDRESS_FAMILY_IPV4 = AF_INET, SOUP_ADDRESS_FAMILY_IPV6 = -1 } SoupAddressFamily; SOUP_ADDRESS_ANY_PORT #define SOUP_ADDRESS_ANY_PORT 0 soup_address_get_type GType void soup_address_new SoupAddress * const char *name,guint port soup_address_new_from_sockaddr SoupAddress * struct sockaddr *sa,int len soup_address_new_any SoupAddress * SoupAddressFamily family,guint port SoupAddressCallback void SoupAddress *addr, guint status, gpointer data soup_address_resolve_async void SoupAddress *addr,SoupAddressCallback callback,gpointer user_data soup_address_resolve_sync guint SoupAddress *addr soup_address_get_name const char * SoupAddress *addr SOUP_TYPE_SOAP_MESSAGE #define SOUP_TYPE_SOAP_MESSAGE (soup_soap_message_get_type ()) SOUP_SOAP_MESSAGE #define SOUP_SOAP_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessage)) SOUP_SOAP_MESSAGE_CLASS #define SOUP_SOAP_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessageClass)) SOUP_IS_SOAP_MESSAGE #define SOUP_IS_SOAP_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SOAP_MESSAGE)) SOUP_IS_SOAP_MESSAGE_CLASS #define SOUP_IS_SOAP_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SOAP_MESSAGE)) SOUP_SOAP_MESSAGE_GET_CLASS #define SOUP_SOAP_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOAP_MESSAGE, SoupSoapMessageClass)) SoupSoapMessagePrivate SoupSoapMessage typedef struct { SoupMessage parent; SoupSoapMessagePrivate *priv; } SoupSoapMessage; SoupSoapMessageClass typedef struct { SoupMessageClass parent_class; } SoupSoapMessageClass; soup_soap_message_get_type GType void soup_soap_message_new SoupSoapMessage * const char *method, const char *uri_string,gboolean standalone, const char *xml_encoding,const char *env_prefix, const char *env_uri soup_soap_message_new_from_uri SoupSoapMessage * const char *method, const SoupUri *uri,gboolean standalone, const char *xml_encoding,const char *env_prefix, const char *env_uri soup_soap_message_start_envelope void SoupSoapMessage *msg soup_soap_message_end_envelope void SoupSoapMessage *msg soup_soap_message_start_body void SoupSoapMessage *msg soup_soap_message_end_body void SoupSoapMessage *msg soup_soap_message_start_element void SoupSoapMessage *msg,const char *name,const char *prefix,const char *ns_uri soup_soap_message_end_element void SoupSoapMessage *msg soup_soap_message_start_fault void SoupSoapMessage *msg,const char *faultcode,const char *faultstring,const char *faultfactor soup_soap_message_end_fault void SoupSoapMessage *msg soup_soap_message_start_fault_detail void SoupSoapMessage *msg soup_soap_message_end_fault_detail void SoupSoapMessage *msg soup_soap_message_start_header void SoupSoapMessage *msg soup_soap_message_end_header void SoupSoapMessage *msg soup_soap_message_start_header_element void SoupSoapMessage *msg,const char *name,gboolean must_understand,const char *actor_uri,const char *prefix,const char *ns_uri soup_soap_message_end_header_element void SoupSoapMessage *msg soup_soap_message_write_int void SoupSoapMessage *msg, long i soup_soap_message_write_double void SoupSoapMessage *msg, double d soup_soap_message_write_base64 void SoupSoapMessage *msg, const char *string, int len soup_soap_message_write_time void SoupSoapMessage *msg, const time_t *timeval soup_soap_message_write_string void SoupSoapMessage *msg, const char *string soup_soap_message_write_buffer void SoupSoapMessage *msg, const char *buffer, int len soup_soap_message_set_element_type void SoupSoapMessage *msg, const char *xsi_type soup_soap_message_set_null void SoupSoapMessage *msg soup_soap_message_add_attribute void SoupSoapMessage *msg,const char *name,const char *value,const char *prefix,const char *ns_uri soup_soap_message_add_namespace void SoupSoapMessage *msg,const char *prefix,const char *ns_uri soup_soap_message_set_default_namespace void SoupSoapMessage *msg,const char *ns_uri soup_soap_message_set_encoding_style void SoupSoapMessage *msg, const char *enc_style soup_soap_message_reset void SoupSoapMessage *msg soup_soap_message_persist void SoupSoapMessage *msg soup_soap_message_get_namespace_prefix const char * SoupSoapMessage *msg, const char *ns_uri soup_soap_message_get_xml_doc xmlDocPtr SoupSoapMessage *msg soup_soap_message_parse_response SoupSoapResponse * SoupSoapMessage *msg SoupMessagePrivate struct SoupMessagePrivate { gpointer io_data; guint msg_flags; GSList *chunks, *last_chunk; GSList *content_handlers; SoupHttpVersion http_version; SoupUri *uri; }; soup_message_run_handlers void SoupMessage *msg,SoupHandlerPhase phase soup_message_cleanup_response void SoupMessage *req SoupMessageGetHeadersFn void SoupMessage *msg, GString *headers, SoupTransferEncoding *encoding, gpointer user_data SoupMessageParseHeadersFn guint SoupMessage *msg, char *headers, guint header_len, SoupTransferEncoding *encoding, guint *content_len, gpointer user_data soup_message_io_client void SoupMessage *msg,SoupSocket *sock,SoupMessageGetHeadersFn get_headers_cb,SoupMessageParseHeadersFn parse_headers_cb,gpointer user_data soup_message_io_server void SoupMessage *msg,SoupSocket *sock,SoupMessageGetHeadersFn get_headers_cb,SoupMessageParseHeadersFn parse_headers_cb,gpointer user_data SOUP_TYPE_SOAP_RESPONSE #define SOUP_TYPE_SOAP_RESPONSE (soup_soap_response_get_type ()) SOUP_SOAP_RESPONSE #define SOUP_SOAP_RESPONSE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponse)) SOUP_SOAP_RESPONSE_CLASS #define SOUP_SOAP_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponseClass)) SOUP_IS_SOAP_RESPONSE #define SOUP_IS_SOAP_RESPONSE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SOAP_RESPONSE)) SOUP_IS_SOAP_RESPONSE_CLASS #define SOUP_IS_SOAP_RESPONSE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_SOAP_RESPONSE)) SOUP_SOAP_RESPONSE_GET_CLASS #define SOUP_SOAP_RESPONSE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOAP_RESPONSE, SoupSoapResponseClass)) SoupSoapResponsePrivate SoupSoapResponse typedef struct { GObject parent; SoupSoapResponsePrivate *priv; } SoupSoapResponse; SoupSoapResponseClass typedef struct { GObjectClass parent_class; } SoupSoapResponseClass; soup_soap_response_get_type GType void soup_soap_response_new SoupSoapResponse * void soup_soap_response_new_from_string SoupSoapResponse * const char *xmlstr soup_soap_response_from_string gboolean SoupSoapResponse *response, const char *xmlstr soup_soap_response_get_method_name const char * SoupSoapResponse *response soup_soap_response_set_method_name void SoupSoapResponse *response,const char *method_name SoupSoapParameter typedef xmlNode SoupSoapParameter; soup_soap_parameter_get_name const char * SoupSoapParameter *param soup_soap_parameter_get_int_value int SoupSoapParameter *param soup_soap_parameter_get_string_value char * SoupSoapParameter *param soup_soap_parameter_get_first_child SoupSoapParameter * SoupSoapParameter *param soup_soap_parameter_get_first_child_by_name SoupSoapParameter * SoupSoapParameter *param,const char *name soup_soap_parameter_get_next_child SoupSoapParameter * SoupSoapParameter *param soup_soap_parameter_get_next_child_by_name SoupSoapParameter * SoupSoapParameter *param,const char *name soup_soap_parameter_get_property char * SoupSoapParameter *param, const char *prop_name soup_soap_response_get_parameters const GList * SoupSoapResponse *response soup_soap_response_get_first_parameter SoupSoapParameter * SoupSoapResponse *response soup_soap_response_get_first_parameter_by_name SoupSoapParameter * SoupSoapResponse *response,const char *name soup_soap_response_get_next_parameter SoupSoapParameter * SoupSoapResponse *response,SoupSoapParameter *from soup_soap_response_get_next_parameter_by_name SoupSoapParameter * SoupSoapResponse *response,SoupSoapParameter *from,const char *name SOUP_TYPE_SESSION #define SOUP_TYPE_SESSION (soup_session_get_type ()) SOUP_SESSION #define SOUP_SESSION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SESSION, SoupSession)) SOUP_SESSION_CLASS #define SOUP_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SESSION, SoupSessionClass)) SOUP_IS_SESSION #define SOUP_IS_SESSION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SESSION)) SOUP_IS_SESSION_CLASS #define SOUP_IS_SESSION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SESSION)) SOUP_SESSION_GET_CLASS #define SOUP_SESSION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SESSION, SoupSessionClass)) SoupSessionPrivate typedef struct SoupSessionPrivate SoupSessionPrivate; SoupSession struct SoupSession { GObject parent; SoupSessionPrivate *priv; /* protected */ SoupMessageQueue *queue; }; SoupSessionClass typedef struct { GObjectClass parent_class; /* signals */ void (*authenticate) (SoupSession *, SoupMessage *, const char *auth_type, const char *auth_realm, char **username, char **password); void (*reauthenticate) (SoupSession *, SoupMessage *, const char *auth_type, const char *auth_realm, char **username, char **password); /* methods */ void (*queue_message) (SoupSession *session, SoupMessage *msg, SoupMessageCallbackFn 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); } SoupSessionClass; soup_session_get_type GType void SOUP_SESSION_PROXY_URI #define SOUP_SESSION_PROXY_URI "proxy-uri" SOUP_SESSION_MAX_CONNS #define SOUP_SESSION_MAX_CONNS "max-conns" SOUP_SESSION_MAX_CONNS_PER_HOST #define SOUP_SESSION_MAX_CONNS_PER_HOST "max-conns-per-host" SOUP_SESSION_USE_NTLM #define SOUP_SESSION_USE_NTLM "use-ntlm" SOUP_SESSION_SSL_CA_FILE #define SOUP_SESSION_SSL_CA_FILE "ssl-ca-file" soup_session_add_filter void SoupSession *session,SoupMessageFilter *filter soup_session_remove_filter void SoupSession *session,SoupMessageFilter *filter soup_session_queue_message void SoupSession *session,SoupMessage *msg,SoupMessageCallbackFn callback,gpointer user_data soup_session_requeue_message void SoupSession *session,SoupMessage *msg soup_session_send_message guint SoupSession *session,SoupMessage *msg soup_session_cancel_message void SoupSession *session,SoupMessage *msg soup_session_abort void SoupSession *session soup_session_get_connection SoupConnection * SoupSession *session,SoupMessage *msg,gboolean *try_pruning,gboolean *is_new soup_session_try_prune_connection gboolean SoupSession *session SOUP_TYPE_AUTH #define SOUP_TYPE_AUTH (soup_auth_get_type ()) SOUP_AUTH #define SOUP_AUTH(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_AUTH, SoupAuth)) SOUP_AUTH_CLASS #define SOUP_AUTH_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_AUTH, SoupAuthClass)) SOUP_IS_AUTH #define SOUP_IS_AUTH(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_AUTH)) SOUP_IS_AUTH_CLASS #define SOUP_IS_AUTH_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_AUTH)) SOUP_AUTH_GET_CLASS #define SOUP_AUTH_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH, SoupAuthClass)) SoupAuth typedef struct { GObject parent; } SoupAuth; SoupAuthClass typedef struct { GObjectClass parent_class; const char *scheme_name; void (*construct) (SoupAuth *auth, const char *header); GSList * (*get_protection_space) (SoupAuth *auth, const SoupUri *source_uri); const char * (*get_realm) (SoupAuth *auth); void (*authenticate) (SoupAuth *auth, const char *username, const char *password); gboolean (*is_authenticated) (SoupAuth *auth); char * (*get_authorization) (SoupAuth *auth, SoupMessage *msg); } SoupAuthClass; soup_auth_get_type GType void soup_auth_new_from_header_list SoupAuth * const GSList *header soup_auth_get_scheme_name const char * SoupAuth *auth soup_auth_get_realm const char * SoupAuth *auth soup_auth_authenticate void SoupAuth *auth,const char *username,const char *password soup_auth_is_authenticated gboolean SoupAuth *auth soup_auth_get_authorization char * SoupAuth *auth,SoupMessage *msg soup_auth_get_protection_space GSList * SoupAuth *auth,const SoupUri *source_uri soup_auth_free_protection_space void SoupAuth *auth,GSList *space SOUP_TYPE_SOCKET #define SOUP_TYPE_SOCKET (soup_socket_get_type ()) SOUP_SOCKET #define SOUP_SOCKET(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SOCKET, SoupSocket)) SOUP_SOCKET_CLASS #define SOUP_SOCKET_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SOCKET, SoupSocketClass)) SOUP_IS_SOCKET #define SOUP_IS_SOCKET(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SOCKET)) SOUP_IS_SOCKET_CLASS #define SOUP_IS_SOCKET_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SOCKET)) SOUP_SOCKET_GET_CLASS #define SOUP_SOCKET_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SOCKET, SoupSocketClass)) SoupSocketPrivate typedef struct SoupSocketPrivate SoupSocketPrivate; SoupSocket struct SoupSocket { GObject parent; SoupSocketPrivate *priv; }; SoupSocketClass typedef struct { GObjectClass parent_class; /* signals */ void (*connect_result) (SoupSocket *, guint); void (*readable) (SoupSocket *); void (*writable) (SoupSocket *); void (*disconnected) (SoupSocket *); void (*new_connection) (SoupSocket *, SoupSocket *); } SoupSocketClass; SOUP_SOCKET_FLAG_NONBLOCKING #define SOUP_SOCKET_FLAG_NONBLOCKING "non-blocking" SOUP_SOCKET_FLAG_NODELAY #define SOUP_SOCKET_FLAG_NODELAY "nodelay" SOUP_SOCKET_FLAG_REUSEADDR #define SOUP_SOCKET_FLAG_REUSEADDR "reuseaddr" SOUP_SOCKET_IS_SERVER #define SOUP_SOCKET_IS_SERVER "is-server" SOUP_SOCKET_SSL_CREDENTIALS #define SOUP_SOCKET_SSL_CREDENTIALS "ssl-creds" soup_socket_get_type GType void soup_socket_new SoupSocket * const char *optname1,... soup_socket_connect guint SoupSocket *sock,SoupAddress *remote_addr soup_socket_listen gboolean SoupSocket *sock,SoupAddress *local_addr soup_socket_start_ssl gboolean SoupSocket *sock soup_socket_start_proxy_ssl gboolean SoupSocket *sock,const char *ssl_host soup_socket_disconnect void SoupSocket *sock soup_socket_is_connected gboolean SoupSocket *sock SoupSocketCallback void SoupSocket *sock, guint status, gpointer user_data SoupSocketListenerCallback void SoupSocket *listener, SoupSocket *sock, gpointer user_data soup_socket_client_new_async SoupSocket * const char *hostname,guint port,gpointer ssl_creds,SoupSocketCallback callback,gpointer user_data soup_socket_client_new_sync SoupSocket * const char *hostname,guint port,gpointer ssl_creds,guint *status_ret soup_socket_server_new SoupSocket * SoupAddress *local_addr,gpointer ssl_creds,SoupSocketListenerCallback callback,gpointer user_data soup_socket_get_local_address SoupAddress * SoupSocket *sock soup_socket_get_remote_address SoupAddress * SoupSocket *sock SoupSocketIOStatus typedef enum { SOUP_SOCKET_OK, SOUP_SOCKET_WOULD_BLOCK, SOUP_SOCKET_EOF, SOUP_SOCKET_ERROR } SoupSocketIOStatus; soup_socket_read SoupSocketIOStatus SoupSocket *sock,gpointer buffer,gsize len,gsize *nread soup_socket_read_until SoupSocketIOStatus SoupSocket *sock,gpointer buffer,gsize len,gconstpointer boundary,gsize boundary_len,gsize *nread,gboolean *got_boundary soup_socket_write SoupSocketIOStatus SoupSocket *sock,gconstpointer buffer,gsize len,gsize *nwrote SOUP_TYPE_CONNECTION_NTLM #define SOUP_TYPE_CONNECTION_NTLM (soup_connection_ntlm_get_type ()) SOUP_CONNECTION_NTLM #define SOUP_CONNECTION_NTLM(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), SOUP_TYPE_CONNECTION_NTLM, SoupConnectionNTLM)) SOUP_CONNECTION_NTLM_CLASS #define SOUP_CONNECTION_NTLM_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_CONNECTION_NTLM, SoupConnectionNTLMClass)) SOUP_IS_CONNECTION_NTLM #define SOUP_IS_CONNECTION_NTLM(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), SOUP_TYPE_CONNECTION_NTLM)) SOUP_IS_CONNECTION_NTLM_CLASS #define SOUP_IS_CONNECTION_NTLM_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_CONNECTION_NTLM)) SOUP_CONNECTION_NTLM_GET_CLASS #define SOUP_CONNECTION_NTLM_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_CONNECTION_NTLM, SoupConnectionNTLMClass)) SoupConnectionNTLMPrivate typedef struct SoupConnectionNTLMPrivate SoupConnectionNTLMPrivate; SoupConnectionNTLM typedef struct { SoupConnection parent; SoupConnectionNTLMPrivate *priv; } SoupConnectionNTLM; SoupConnectionNTLMClass typedef struct { SoupConnectionClass parent_class; } SoupConnectionNTLMClass; soup_connection_ntlm_get_type GType void SOUP_METHOD_POST #define SOUP_METHOD_POST "POST" SOUP_METHOD_GET #define SOUP_METHOD_GET "GET" SOUP_METHOD_HEAD #define SOUP_METHOD_HEAD "HEAD" SOUP_METHOD_OPTIONS #define SOUP_METHOD_OPTIONS "OPTIONS" SOUP_METHOD_PUT #define SOUP_METHOD_PUT "PUT" SOUP_METHOD_MOVE #define SOUP_METHOD_MOVE "MOVE" SOUP_METHOD_COPY #define SOUP_METHOD_COPY "COPY" SOUP_METHOD_DELETE #define SOUP_METHOD_DELETE "DELETE" SOUP_METHOD_TRACE #define SOUP_METHOD_TRACE "TRACE" SOUP_METHOD_CONNECT #define SOUP_METHOD_CONNECT "CONNECT" SOUP_METHOD_MKCOL #define SOUP_METHOD_MKCOL "MKCOL" SOUP_METHOD_PROPPATCH #define SOUP_METHOD_PROPPATCH "PROPPATCH" SOUP_METHOD_PROPFIND #define SOUP_METHOD_PROPFIND "PROPFIND" SOUP_METHOD_PATCH #define SOUP_METHOD_PATCH "PATCH" SOUP_METHOD_LOCK #define SOUP_METHOD_LOCK "LOCK" SOUP_METHOD_UNLOCK #define SOUP_METHOD_UNLOCK "UNLOCK" SoupMethodId typedef enum { SOUP_METHOD_ID_UNKNOWN = 0, SOUP_METHOD_ID_POST, SOUP_METHOD_ID_GET, SOUP_METHOD_ID_HEAD, SOUP_METHOD_ID_OPTIONS, SOUP_METHOD_ID_PUT, SOUP_METHOD_ID_MOVE, SOUP_METHOD_ID_COPY, SOUP_METHOD_ID_DELETE, SOUP_METHOD_ID_TRACE, SOUP_METHOD_ID_CONNECT, SOUP_METHOD_ID_MKCOL, SOUP_METHOD_ID_PROPPATCH, SOUP_METHOD_ID_PROPFIND, SOUP_METHOD_ID_PATCH, SOUP_METHOD_ID_LOCK, SOUP_METHOD_ID_UNLOCK } SoupMethodId; soup_method_get_id SoupMethodId const char *method soup_base64_encode char * const char *text,int len soup_base64_encode_close int const guchar *in,int inlen,gboolean break_lines,guchar *out,int *state,int *save soup_base64_encode_step int const guchar *in,int len,gboolean break_lines,guchar *out,int *state,int *save soup_base64_decode char * const gchar *text,int *out_len soup_base64_decode_step int const guchar *in,int len,guchar *out,int *state,guint *save soup_signal_connect_once guint gpointer instance,const char *detailed_signal,GCallback c_handler,gpointer data soup_str_case_hash guint gconstpointer key soup_str_case_equal gboolean gconstpointer v1,gconstpointer v2 soup_ssl_supported extern gboolean soup_ssl_supported; SOUP_TYPE_AUTH_BASIC #define SOUP_TYPE_AUTH_BASIC (soup_auth_basic_get_type ()) SOUP_AUTH_BASIC #define SOUP_AUTH_BASIC(object) (G_TYPE_CHECK_INSTANCE_CAST ((object), SOUP_TYPE_AUTH_BASIC, SoupAuthBasic)) SOUP_AUTH_BASIC_CLASS #define SOUP_AUTH_BASIC_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_AUTH_BASIC, SoupAuthBasicClass)) SOUP_IS_AUTH_BASIC #define SOUP_IS_AUTH_BASIC(object) (G_TYPE_CHECK_INSTANCE_TYPE ((object), SOUP_TYPE_AUTH_BASIC)) SOUP_IS_AUTH_BASIC_CLASS #define SOUP_IS_AUTH_BASIC_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((klass), SOUP_TYPE_AUTH_BASIC)) SOUP_AUTH_BASIC_GET_CLASS #define SOUP_AUTH_BASIC_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_AUTH_BASIC, SoupAuthBasicClass)) SoupAuthBasicPrivate typedef struct SoupAuthBasicPrivate SoupAuthBasicPrivate; SoupAuthBasic typedef struct { SoupAuth parent; SoupAuthBasicPrivate *priv; } SoupAuthBasic; SoupAuthBasicClass typedef struct { SoupAuthClass parent_class; } SoupAuthBasicClass; soup_auth_basic_get_type GType void SOUP_TYPE_CONNECTION #define SOUP_TYPE_CONNECTION (soup_connection_get_type ()) SOUP_CONNECTION #define SOUP_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_CONNECTION, SoupConnection)) SOUP_CONNECTION_CLASS #define SOUP_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_CONNECTION, SoupConnectionClass)) SOUP_IS_CONNECTION #define SOUP_IS_CONNECTION(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_CONNECTION)) SOUP_IS_CONNECTION_CLASS #define SOUP_IS_CONNECTION_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_CONNECTION)) SOUP_CONNECTION_GET_CLASS #define SOUP_CONNECTION_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_CONNECTION, SoupConnectionClass)) SoupConnectionPrivate typedef struct SoupConnectionPrivate SoupConnectionPrivate; SoupConnection struct SoupConnection { GObject parent; SoupConnectionPrivate *priv; }; SoupConnectionClass typedef struct { GObjectClass parent_class; /* signals */ void (*connect_result) (SoupConnection *, guint); void (*disconnected) (SoupConnection *); void (*authenticate) (SoupConnection *, SoupMessage *, const char *auth_type, const char *auth_realm, char **username, char **password); void (*reauthenticate) (SoupConnection *, SoupMessage *, const char *auth_type, const char *auth_realm, char **username, char **password); /* methods */ void (*send_request) (SoupConnection *, SoupMessage *); } SoupConnectionClass; soup_connection_get_type GType void SOUP_CONNECTION_ORIGIN_URI #define SOUP_CONNECTION_ORIGIN_URI "origin-uri" SOUP_CONNECTION_PROXY_URI #define SOUP_CONNECTION_PROXY_URI "proxy-uri" SOUP_CONNECTION_SSL_CREDENTIALS #define SOUP_CONNECTION_SSL_CREDENTIALS "ssl-creds" SOUP_CONNECTION_MESSAGE_FILTER #define SOUP_CONNECTION_MESSAGE_FILTER "message-filter" soup_connection_new SoupConnection * const char *propname1,... SoupConnectionCallback void SoupConnection *conn, guint status, gpointer data soup_connection_connect_async void SoupConnection *conn,SoupConnectionCallback callback,gpointer user_data soup_connection_connect_sync guint SoupConnection *conn soup_connection_disconnect void SoupConnection *conn soup_connection_is_in_use gboolean SoupConnection *conn soup_connection_last_used time_t SoupConnection *conn soup_connection_send_request void SoupConnection *conn,SoupMessage *req soup_connection_reserve void SoupConnection *conn soup_connection_release void SoupConnection *conn soup_connection_authenticate void SoupConnection *conn,SoupMessage *msg,const char *auth_type,const char *auth_realm,char **username,char **password soup_connection_reauthenticate void SoupConnection *conn,SoupMessage *msg,const char *auth_type,const char *auth_realm,char **username,char **password SOUP_TYPE_SERVER_MESSAGE #define SOUP_TYPE_SERVER_MESSAGE (soup_server_message_get_type ()) SOUP_SERVER_MESSAGE #define SOUP_SERVER_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_CAST ((obj), SOUP_TYPE_SERVER_MESSAGE, SoupServerMessage)) SOUP_SERVER_MESSAGE_CLASS #define SOUP_SERVER_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_CAST ((klass), SOUP_TYPE_SERVER_MESSAGE, SoupServerMessageClass)) SOUP_IS_SERVER_MESSAGE #define SOUP_IS_SERVER_MESSAGE(obj) (G_TYPE_CHECK_INSTANCE_TYPE ((obj), SOUP_TYPE_SERVER_MESSAGE)) SOUP_IS_SERVER_MESSAGE_CLASS #define SOUP_IS_SERVER_MESSAGE_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), SOUP_TYPE_SERVER_MESSAGE)) SOUP_SERVER_MESSAGE_GET_CLASS #define SOUP_SERVER_MESSAGE_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), SOUP_TYPE_SERVER_MESSAGE, SoupServerMessageClass)) SoupServerMessagePrivate typedef struct SoupServerMessagePrivate SoupServerMessagePrivate; SoupServerMessage struct SoupServerMessage { SoupMessage parent; SoupServerMessagePrivate *priv; }; SoupServerMessageClass typedef struct { SoupMessageClass parent_class; } SoupServerMessageClass; soup_server_message_get_type GType void soup_server_message_new SoupServerMessage * SoupServer *server soup_server_message_get_server SoupServer * SoupServerMessage *smsg soup_server_message_set_encoding void SoupServerMessage *smsg,SoupTransferEncoding encoding soup_server_message_get_encoding SoupTransferEncoding SoupServerMessage *smsg soup_server_message_start void SoupServerMessage *smsg soup_server_message_is_started gboolean SoupServerMessage *smsg soup_server_message_finish void SoupServerMessage *smsg soup_server_message_is_finished gboolean SoupServerMessage *smsg