vapi/libsoup-2.4.vapi

   1 /* libsoup-2.4.vapi generated by lt-vapigen, do not modify. */
   2
   3 [CCode (cprefix = "Soup", lower_case_cprefix = "soup_")]
   4 namespace Soup {
   5         [CCode (cheader_filename = "libsoup/soup.h")]
   6         public class Address : GLib.Object {
   7                 [CCode (has_construct_function = false)]
   8                 public Address.any (Soup.AddressFamily family, uint port);
   9                 public static bool equal_by_ip (void* addr1, void* addr2);
  10                 public static bool equal_by_name (void* addr1, void* addr2);
  11                 [CCode (has_construct_function = false)]
  12                 public Address.from_sockaddr (void* sa, int len);
  13                 public weak string get_name ();
  14                 public weak string get_physical ();
  15                 public uint get_port ();
  16                 public void* get_sockaddr (int len);
  17                 public static uint hash_by_ip (void* addr);
  18                 public static uint hash_by_name (void* addr);
  19                 public bool is_resolved ();
  20                 [CCode (has_construct_function = false)]
  21                 public Address (string name, uint port);
  22                 public void resolve_async (GLib.MainContext async_context, GLib.Cancellable cancellable, Soup.AddressCallback callback);
  23                 public uint resolve_sync (GLib.Cancellable cancellable);
  24                 [NoAccessorMethod]
  25                 public Soup.AddressFamily family { get; construct; }
  26                 [NoAccessorMethod]
  27                 public string name { get; construct; }
  28                 public string physical { get; }
  29                 [NoAccessorMethod]
  30                 public int port { get; construct; }
  31                 [NoAccessorMethod]
  32                 public void* sockaddr { get; construct; }
  33         }
  34         [CCode (cheader_filename = "libsoup/soup.h")]
  35         public class Auth : GLib.Object {
  36                 public virtual void authenticate (string username, string password);
  37                 public void free_protection_space (GLib.SList space);
  38                 public virtual weak string get_authorization (Soup.Message msg);
  39                 public weak string get_host ();
  40                 public weak string get_info ();
  41                 public virtual weak GLib.SList get_protection_space (Soup.URI source_uri);
  42                 public weak string get_realm ();
  43                 public weak string get_scheme_name ();
  44                 [CCode (has_construct_function = false)]
  45                 public Auth (GLib.Type type, Soup.Message msg, string auth_header);
  46                 public virtual bool update (Soup.Message msg, string auth_header);
  47                 [NoAccessorMethod]
  48                 public string host { get; construct; }
  49                 [NoAccessorMethod]
  50                 public bool is_authenticated { get; }
  51                 [NoAccessorMethod]
  52                 public bool is_for_proxy { get; construct; }
  53                 [NoAccessorMethod]
  54                 public string realm { get; construct; }
  55                 public string scheme_name { get; }
  56         }
  57         [CCode (cheader_filename = "libsoup/soup.h")]
  58         public class AuthDomain : GLib.Object {
  59                 public virtual weak string accepts (Soup.Message msg);
  60                 public void add_path (string path);
  61                 public virtual weak string challenge (Soup.Message msg);
  62                 public virtual bool check_password (Soup.Message msg, string username, string password);
  63                 public bool covers (Soup.Message msg);
  64                 public weak string get_realm ();
  65                 public void remove_path (string path);
  66                 public void set_filter (Soup.AuthDomainFilter filter, void* filter_data, GLib.DestroyNotify dnotify);
  67                 public void set_generic_auth_callback (Soup.AuthDomainGenericAuthCallback auth_callback, void* auth_data, GLib.DestroyNotify dnotify);
  68                 public bool try_generic_auth_callback (Soup.Message msg, string username);
  69                 [NoAccessorMethod]
  70                 public void* filter { get; set; }
  71                 [NoAccessorMethod]
  72                 public void* filter_data { get; set; }
  73                 [NoAccessorMethod]
  74                 public void* generic_auth_callback { get; set; }
  75                 [NoAccessorMethod]
  76                 public void* generic_auth_data { get; set; }
  77                 [NoAccessorMethod]
  78                 public bool proxy { get; construct; }
  79                 [NoAccessorMethod]
  80                 public string realm { get; construct; }
  81         }
  82         [CCode (cheader_filename = "libsoup/soup.h")]
  83         public class AuthDomainBasic : Soup.AuthDomain {
  84                 [CCode (type = "SoupAuthDomain*", has_construct_function = false)]
  85                 public AuthDomainBasic (string optname1);
  86                 public static void set_auth_callback (Soup.AuthDomain domain, Soup.AuthDomainBasicAuthCallback callback, GLib.DestroyNotify dnotify);
  87                 [NoAccessorMethod]
  88                 public void* auth_callback { get; set; }
  89                 [NoAccessorMethod]
  90                 public void* auth_data { get; set; }
  91         }
  92         [CCode (cheader_filename = "libsoup/soup.h")]
  93         public class AuthDomainDigest : Soup.AuthDomain {
  94                 public static weak string encode_password (string username, string realm, string password);
  95                 [CCode (type = "SoupAuthDomain*", has_construct_function = false)]
  96                 public AuthDomainDigest (string optname1);
  97                 public static void set_auth_callback (Soup.AuthDomain domain, Soup.AuthDomainDigestAuthCallback callback, GLib.DestroyNotify dnotify);
  98                 [NoAccessorMethod]
  99                 public void* auth_callback { get; set; }
 100                 [NoAccessorMethod]
 101                 public void* auth_data { get; set; }
 102         }
 103         [Compact]
 104         [CCode (copy_function = "soup_buffer_copy", cheader_filename = "libsoup/soup.h")]
 105         public class Buffer {
 106                 public weak string data;
 107                 public size_t length;
 108                 public weak Soup.Buffer copy ();
 109                 public void* get_owner ();
 110                 [CCode (has_construct_function = false)]
 111                 public Buffer (Soup.MemoryUse use, void* data, size_t length);
 112                 [CCode (has_construct_function = false)]
 113                 public Buffer.subbuffer (Soup.Buffer parent, size_t offset, size_t length);
 114                 [CCode (has_construct_function = false)]
 115                 public Buffer.with_owner (void* data, size_t length, void* owner, GLib.DestroyNotify owner_dnotify);
 116         }
 117         [Compact]
 118         [CCode (cheader_filename = "libsoup/soup.h")]
 119         public class ByteArray {
 120         }
 121         [Compact]
 122         [CCode (cheader_filename = "libsoup/soup.h")]
 123         public class ClientContext {
 124                 public weak Soup.Address get_address ();
 125                 public weak Soup.AuthDomain get_auth_domain ();
 126                 public weak string get_auth_user ();
 127                 public weak string get_host ();
 128                 public weak Soup.Socket get_socket ();
 129         }
 130         [Compact]
 131         [CCode (copy_function = "soup_cookie_copy", cheader_filename = "libsoup/soup.h")]
 132         public class Cookie {
 133                 public weak string domain;
 134                 public weak Soup.Date expires;
 135                 public bool http_only;
 136                 public weak string name;
 137                 public weak string path;
 138                 public bool secure;
 139                 public weak string value;
 140                 public bool applies_to_uri (Soup.URI uri);
 141                 public weak Soup.Cookie copy ();
 142                 public bool equal (Soup.Cookie cookie2);
 143                 [CCode (has_construct_function = false)]
 144                 public Cookie (string name, string value, string domain, string path, int max_age);
 145                 public static weak Soup.Cookie parse (string header, Soup.URI origin);
 146                 public void set_domain (string domain);
 147                 public void set_expires (Soup.Date expires);
 148                 public void set_http_only (bool http_only);
 149                 public void set_max_age (int max_age);
 150                 public void set_name (string name);
 151                 public void set_path (string path);
 152                 public void set_secure (bool secure);
 153                 public void set_value (string value);
 154                 public weak string to_cookie_header ();
 155                 public weak string to_set_cookie_header ();
 156         }
 157         [CCode (cheader_filename = "libsoup/soup.h")]
 158         public class CookieJar : GLib.Object, Soup.SessionFeature {
 159                 public void add_cookie (Soup.Cookie cookie);
 160                 public weak GLib.SList all_cookies ();
 161                 public void delete_cookie (Soup.Cookie cookie);
 162                 public weak string get_cookies (Soup.URI uri, bool for_http);
 163                 [CCode (has_construct_function = false)]
 164                 public CookieJar ();
 165                 public virtual void save ();
 166                 public void set_cookie (Soup.URI uri, string cookie);
 167                 [NoAccessorMethod]
 168                 public bool read_only { get; construct; }
 169                 public virtual signal void changed (Soup.Cookie old_cookie, Soup.Cookie new_cookie);
 170         }
 171         [CCode (cheader_filename = "libsoup/soup.h")]
 172         public class CookieJarText : Soup.CookieJar, Soup.SessionFeature {
 173                 [CCode (type = "SoupCookieJar*", has_construct_function = false)]
 174                 public CookieJarText (string filename, bool read_only);
 175                 [NoAccessorMethod]
 176                 public string filename { get; construct; }
 177         }
 178         [Compact]
 179         [CCode (copy_function = "soup_date_copy", cheader_filename = "libsoup/soup.h")]
 180         public class Date {
 181                 public int day;
 182                 public int hour;
 183                 public int minute;
 184                 public int month;
 185                 public int offset;
 186                 public int second;
 187                 public bool utc;
 188                 public int year;
 189                 public weak Soup.Date copy ();
 190                 [CCode (has_construct_function = false)]
 191                 public Date.from_now (int offset_seconds);
 192                 [CCode (has_construct_function = false)]
 193                 public Date.from_string (string date_string);
 194                 [CCode (has_construct_function = false)]
 195                 public Date.from_time_t (ulong when);
 196                 public bool is_past ();
 197                 [CCode (has_construct_function = false)]
 198                 public Date (int year, int month, int day, int hour, int minute, int second);
 199                 public weak string to_string (Soup.DateFormat format);
 200                 public ulong to_time_t ();
 201                 public void to_timeval (GLib.TimeVal time);
 202         }
 203         [CCode (cheader_filename = "libsoup/soup.h")]
 204         public class Logger : GLib.Object, Soup.SessionFeature {
 205                 [CCode (has_construct_function = false)]
 206                 public Logger (Soup.LoggerLogLevel level, int max_body_size);
 207                 public void set_printer (Soup.LoggerPrinter printer, void* printer_data, GLib.DestroyNotify destroy);
 208                 public void set_request_filter (Soup.LoggerFilter request_filter, void* filter_data, GLib.DestroyNotify destroy);
 209                 public void set_response_filter (Soup.LoggerFilter response_filter, void* filter_data, GLib.DestroyNotify destroy);
 210         }
 211         [CCode (cheader_filename = "libsoup/soup.h")]
 212         public class Message : GLib.Object {
 213                 public weak Soup.MessageBody request_body;
 214                 public weak Soup.MessageHeaders request_headers;
 215                 public weak Soup.MessageBody response_body;
 216                 public weak Soup.MessageHeaders response_headers;
 217                 public uint add_header_handler (string @signal, string header, GLib.Callback callback);
 218                 public uint add_status_code_handler (string @signal, uint status_code, GLib.Callback callback);
 219                 [CCode (has_construct_function = false)]
 220                 public Message.from_uri (string method, Soup.URI uri);
 221                 public weak Soup.Address get_address ();
 222                 public Soup.MessageFlags get_flags ();
 223                 public Soup.HTTPVersion get_http_version ();
 224                 public weak Soup.URI get_uri ();
 225                 public bool is_keepalive ();
 226                 [CCode (has_construct_function = false)]
 227                 public Message (string method, string uri_string);
 228                 public void set_chunk_allocator (Soup.ChunkAllocator allocator, GLib.DestroyNotify destroy_notify);
 229                 public void set_flags (Soup.MessageFlags flags);
 230                 public void set_http_version (Soup.HTTPVersion version);
 231                 public void set_request (string content_type, Soup.MemoryUse req_use, string req_body, size_t req_length);
 232                 public void set_response (string content_type, Soup.MemoryUse resp_use, string resp_body, size_t resp_length);
 233                 public void set_status (uint status_code);
 234                 public void set_status_full (uint status_code, string reason_phrase);
 235                 public void set_uri (Soup.URI uri);
 236                 public Soup.MessageFlags flags { get; set; }
 237                 public Soup.HTTPVersion http_version { get; set; }
 238                 [NoAccessorMethod]
 239                 public string method { get; set; }
 240                 [NoAccessorMethod]
 241                 public string reason_phrase { get; set; }
 242                 [NoAccessorMethod]
 243                 public bool server_side { get; construct; }
 244                 [NoAccessorMethod]
 245                 public uint status_code { get; set; }
 246                 public Soup.URI uri { get; set; }
 247                 [HasEmitter]
 248                 public virtual signal void finished ();
 249                 [HasEmitter]
 250                 public virtual signal void got_body ();
 251                 [HasEmitter]
 252                 public virtual signal void got_chunk (Soup.Buffer chunk);
 253                 [HasEmitter]
 254                 public virtual signal void got_headers ();
 255                 [HasEmitter]
 256                 public virtual signal void got_informational ();
 257                 [HasEmitter]
 258                 public virtual signal void restarted ();
 259                 [HasEmitter]
 260                 public virtual signal void wrote_body ();
 261                 [HasEmitter]
 262                 public virtual signal void wrote_body_data (Soup.Buffer p0);
 263                 [HasEmitter]
 264                 public virtual signal void wrote_chunk ();
 265                 [HasEmitter]
 266                 public virtual signal void wrote_headers ();
 267                 [HasEmitter]
 268                 public virtual signal void wrote_informational ();
 269         }
 270         [Compact]
 271         [CCode (cheader_filename = "libsoup/soup.h")]
 272         public class MessageBody {
 273                 public weak string data;
 274                 public int64 length;
 275                 public void append (Soup.MemoryUse use, void* data, size_t length);
 276                 public void append_buffer (Soup.Buffer buffer);
 277                 public void complete ();
 278                 public weak Soup.Buffer flatten ();
 279                 public bool get_accumulate ();
 280                 public weak Soup.Buffer get_chunk (int64 offset);
 281                 public void got_chunk (Soup.Buffer chunk);
 282                 [CCode (has_construct_function = false)]
 283                 public MessageBody ();
 284                 public void set_accumulate (bool accumulate);
 285                 public void truncate ();
 286                 public void wrote_chunk (Soup.Buffer chunk);
 287         }
 288         [Compact]
 289         [CCode (cheader_filename = "libsoup/soup.h")]
 290         public class MessageHeaders {
 291                 public void append (string name, string value);
 292                 public void clear ();
 293                 public void @foreach (Soup.MessageHeadersForeachFunc func);
 294                 public void free_ranges (Soup.Range ranges);
 295                 public weak string get (string name);
 296                 public bool get_content_disposition (out weak string disposition, GLib.HashTable params);
 297                 public int64 get_content_length ();
 298                 public bool get_content_range (int64 start, int64 end, int64 total_length);
 299                 public weak string get_content_type (GLib.HashTable params);
 300                 public Soup.Encoding get_encoding ();
 301                 public Soup.Expectation get_expectations ();
 302                 public bool get_ranges (int64 total_length, out weak Soup.Range ranges, int length);
 303                 [CCode (has_construct_function = false)]
 304                 public MessageHeaders (Soup.MessageHeadersType type);
 305                 public void remove (string name);
 306                 public void replace (string name, string value);
 307                 public void set_content_disposition (string disposition, GLib.HashTable params);
 308                 public void set_content_length (int64 content_length);
 309                 public void set_content_range (int64 start, int64 end, int64 total_length);
 310                 public void set_content_type (string content_type, GLib.HashTable params);
 311                 public void set_encoding (Soup.Encoding encoding);
 312                 public void set_expectations (Soup.Expectation expectations);
 313                 public void set_range (int64 start, int64 end);
 314                 public void set_ranges (Soup.Range ranges, int length);
 315         }
 316         [Compact]
 317         [CCode (cheader_filename = "libsoup/soup.h")]
 318         public class MessageHeadersIter {
 319                 public void* dummy;
 320                 public void init (Soup.MessageHeaders hdrs);
 321                 public bool next (out weak string name, out weak string value);
 322         }
 323         [Compact]
 324         [CCode (cheader_filename = "libsoup/soup.h")]
 325         public class Multipart {
 326                 public void append_form_file (string control_name, string filename, string content_type, Soup.Buffer body);
 327                 public void append_form_string (string control_name, string data);
 328                 public void append_part (Soup.MessageHeaders headers, Soup.Buffer body);
 329                 [CCode (has_construct_function = false)]
 330                 public Multipart.from_message (Soup.MessageHeaders headers, Soup.MessageBody body);
 331                 public int get_length ();
 332                 public bool get_part (int part, out weak Soup.MessageHeaders headers, out weak Soup.Buffer body);
 333                 [CCode (has_construct_function = false)]
 334                 public Multipart (string mime_type);
 335                 public void to_message (Soup.MessageHeaders dest_headers, Soup.MessageBody dest_body);
 336         }
 337         [Compact]
 338         [CCode (cheader_filename = "libsoup/soup.h")]
 339         public class Range {
 340                 public int64 end;
 341                 public int64 start;
 342         }
 343         [CCode (cheader_filename = "libsoup/soup.h")]
 344         public class Server : GLib.Object {
 345                 public void add_auth_domain (Soup.AuthDomain auth_domain);
 346                 public void add_handler (string path, Soup.ServerCallback# callback);
 347                 public weak GLib.MainContext get_async_context ();
 348                 public weak Soup.Socket get_listener ();
 349                 public uint get_port ();
 350                 public bool is_https ();
 351                 [CCode (has_construct_function = false)]
 352                 public Server (string optname1, ...);
 353                 public void pause_message (Soup.Message msg);
 354                 public void quit ();
 355                 public void remove_auth_domain (Soup.AuthDomain auth_domain);
 356                 public void remove_handler (string path);
 357                 public void run ();
 358                 public void run_async ();
 359                 public void unpause_message (Soup.Message msg);
 360                 [NoAccessorMethod]
 361                 public void* async_context { get; construct; }
 362                 [NoAccessorMethod]
 363                 public Soup.Address @interface { get; construct; }
 364                 [NoAccessorMethod]
 365                 public uint port { get; construct; }
 366                 [NoAccessorMethod]
 367                 public bool raw_paths { get; construct; }
 368                 [NoAccessorMethod]
 369                 public string server_header { get; set construct; }
 370                 [NoAccessorMethod]
 371                 public string ssl_cert_file { get; construct; }
 372                 [NoAccessorMethod]
 373                 public string ssl_key_file { get; construct; }
 374                 public virtual signal void request_aborted (Soup.Message msg, Soup.ClientContext client);
 375                 public virtual signal void request_finished (Soup.Message msg, Soup.ClientContext client);
 376                 public virtual signal void request_read (Soup.Message msg, Soup.ClientContext client);
 377                 public virtual signal void request_started (Soup.Message msg, Soup.ClientContext client);
 378         }
 379         [CCode (cheader_filename = "libsoup/soup.h")]
 380         public class Session : GLib.Object {
 381                 public void abort ();
 382                 public virtual void cancel_message (Soup.Message msg, uint status_code);
 383                 public weak GLib.MainContext get_async_context ();
 384                 public void pause_message (Soup.Message msg);
 385                 public virtual void queue_message (Soup.Message# msg, Soup.SessionCallback callback);
 386                 public void remove_feature (Soup.SessionFeature feature);
 387                 public virtual void requeue_message (Soup.Message msg);
 388                 public virtual uint send_message (Soup.Message msg);
 389                 public void unpause_message (Soup.Message msg);
 390                 [NoAccessorMethod]
 391                 public Soup.SessionFeature add_feature { get; set; }
 392                 [NoAccessorMethod]
 393                 public GLib.Type add_feature_by_type { get; set; }
 394                 [NoAccessorMethod]
 395                 public void* async_context { get; construct; }
 396                 [NoAccessorMethod]
 397                 public uint idle_timeout { get; set; }
 398                 [NoAccessorMethod]
 399                 public int max_conns { get; set; }
 400                 [NoAccessorMethod]
 401                 public int max_conns_per_host { get; set; }
 402                 [NoAccessorMethod]
 403                 public Soup.URI proxy_uri { get; set; }
 404                 [NoAccessorMethod]
 405                 public GLib.Type remove_feature_by_type { get; set; }
 406                 [NoAccessorMethod]
 407                 public string ssl_ca_file { get; set; }
 408                 [NoAccessorMethod]
 409                 public uint timeout { get; set; }
 410                 [NoAccessorMethod]
 411                 public bool use_ntlm { get; set; }
 412                 [NoAccessorMethod]
 413                 public string user_agent { get; set; }
 414                 public virtual signal void authenticate (Soup.Message msg, Soup.Auth auth, bool retrying);
 415                 public virtual signal void request_queued (Soup.Message p0);
 416                 public virtual signal void request_started (Soup.Message msg, Soup.Socket socket);
 417                 public virtual signal void request_unqueued (Soup.Message p0);
 418         }
 419         [CCode (cheader_filename = "libsoup/soup.h")]
 420         public class SessionAsync : Soup.Session {
 421                 [CCode (type = "SoupSession*", has_construct_function = false)]
 422                 public SessionAsync ();
 423                 [CCode (type = "SoupSession*", has_construct_function = false)]
 424                 public SessionAsync.with_options (string optname1);
 425         }
 426         [CCode (cheader_filename = "libsoup/soup.h")]
 427         public class SessionSync : Soup.Session {
 428                 [CCode (type = "SoupSession*", has_construct_function = false)]
 429                 public SessionSync ();
 430                 [CCode (type = "SoupSession*", has_construct_function = false)]
 431                 public SessionSync.with_options (string optname1);
 432         }
 433         [CCode (cheader_filename = "libsoup/soup.h")]
 434         public class Socket : GLib.Object {
 435                 public void connect_async (GLib.Cancellable cancellable, Soup.SocketCallback callback);
 436                 public uint connect_sync (GLib.Cancellable cancellable);
 437                 public void disconnect ();
 438                 public weak Soup.Address get_local_address ();
 439                 public weak Soup.Address get_remote_address ();
 440                 public bool is_connected ();
 441                 public bool is_ssl ();
 442                 public bool listen ();
 443                 [CCode (has_construct_function = false)]
 444                 public Socket (string optname1);
 445                 public Soup.SocketIOStatus read (void* buffer, size_t len, size_t nread, GLib.Cancellable cancellable) throws GLib.Error;
 446                 public Soup.SocketIOStatus read_until (void* buffer, size_t len, void* boundary, size_t boundary_len, size_t nread, bool got_boundary, GLib.Cancellable cancellable) throws GLib.Error;
 447                 public bool start_proxy_ssl (string ssl_host, GLib.Cancellable cancellable);
 448                 public bool start_ssl (GLib.Cancellable cancellable);
 449                 public Soup.SocketIOStatus write (void* buffer, size_t len, size_t nwrote, GLib.Cancellable cancellable) throws GLib.Error;
 450                 [NoAccessorMethod]
 451                 public void* async_context { get; construct; }
 452                 [NoAccessorMethod]
 453                 public bool is_server { get; }
 454                 [NoAccessorMethod]
 455                 public Soup.Address local_address { get; construct; }
 456                 [NoAccessorMethod]
 457                 public bool non_blocking { get; set; }
 458                 [NoAccessorMethod]
 459                 public Soup.Address remote_address { get; construct; }
 460                 [NoAccessorMethod]
 461                 public void* ssl_creds { get; set; }
 462                 [NoAccessorMethod]
 463                 public uint timeout { get; set; }
 464                 public virtual signal void disconnected ();
 465                 public virtual signal void new_connection (Soup.Socket p0);
 466                 public virtual signal void readable ();
 467                 public virtual signal void writable ();
 468         }
 469         [Compact]
 470         [CCode (copy_function = "soup_uri_copy", cheader_filename = "libsoup/soup.h")]
 471         public class URI {
 472                 public weak string fragment;
 473                 public weak string host;
 474                 public weak string password;
 475                 public weak string path;
 476                 public uint port;
 477                 public weak string query;
 478                 public weak string scheme;
 479                 public weak string user;
 480                 public Soup.URI copy ();
 481                 public static string decode (string part);
 482                 public static string encode (string part, string escape_extra);
 483                 public bool equal (Soup.URI uri2);
 484                 [CCode (has_construct_function = false)]
 485                 public URI (string uri_string);
 486                 public static string normalize (string part, string unescape_extra);
 487                 public void set_fragment (string fragment);
 488                 public void set_host (string host);
 489                 public void set_password (string password);
 490                 public void set_path (string path);
 491                 public void set_port (uint port);
 492                 public void set_query (string query);
 493                 public void set_query_from_fields (...);
 494                 public void set_query_from_form (GLib.HashTable form);
 495                 public void set_scheme (string scheme);
 496                 public void set_user (string user);
 497                 public string to_string (bool just_path_and_query);
 498                 public bool uses_default_port ();
 499                 [CCode (has_construct_function = false)]
 500                 public URI.with_base (Soup.URI @base, string uri_string);
 501         }
 502         [CCode (cheader_filename = "libsoup/soup.h")]
 503         public interface ProxyResolver : Soup.SessionFeature, GLib.Object {
 504                 public abstract void get_proxy_async (Soup.Message msg, GLib.MainContext async_context, GLib.Cancellable cancellable, Soup.ProxyResolverCallback callback);
 505                 public abstract uint get_proxy_sync (Soup.Message msg, GLib.Cancellable cancellable, out weak Soup.Address addr);
 506         }
 507         [CCode (cheader_filename = "libsoup/soup.h")]
 508         public interface SessionFeature : GLib.Object {
 509                 public abstract void attach (Soup.Session session);
 510                 public abstract void detach (Soup.Session session);
 511                 [NoWrapper]
 512                 public abstract void request_queued (Soup.Session session, Soup.Message msg);
 513                 [NoWrapper]
 514                 public abstract void request_started (Soup.Session session, Soup.Message msg, Soup.Socket socket);
 515                 [NoWrapper]
 516                 public abstract void request_unqueued (Soup.Session session, Soup.Message msg);
 517         }
 518         [CCode (cprefix = "SOUP_ADDRESS_FAMILY_", cheader_filename = "libsoup/soup.h")]
 519         public enum AddressFamily {
 520                 INVALID,
 521                 IPV4,
 522                 IPV6
 523         }
 524         [CCode (cprefix = "SOUP_DATE_", cheader_filename = "libsoup/soup.h")]
 525         public enum DateFormat {
 526                 HTTP,
 527                 COOKIE,
 528                 RFC2822,
 529                 ISO8601_COMPACT,
 530                 ISO8601_FULL,
 531                 ISO8601,
 532                 ISO8601_XMLRPC
 533         }
 534         [CCode (cprefix = "SOUP_ENCODING_", cheader_filename = "libsoup/soup.h")]
 535         public enum Encoding {
 536                 UNRECOGNIZED,
 537                 NONE,
 538                 CONTENT_LENGTH,
 539                 EOF,
 540                 CHUNKED,
 541                 BYTERANGES
 542         }
 543         [CCode (cprefix = "SOUP_EXPECTATION_", cheader_filename = "libsoup/soup.h")]
 544         [Flags]
 545         public enum Expectation {
 546                 UNRECOGNIZED,
 547                 CONTINUE
 548         }
 549         [CCode (cprefix = "SOUP_HTTP_", cheader_filename = "libsoup/soup.h")]
 550         public enum HTTPVersion {
 551                 1_0,
 552                 1_1
 553         }
 554         [CCode (cprefix = "SOUP_STATUS_", cheader_filename = "libsoup/soup.h")]
 555         public enum KnownStatusCode {
 556                 NONE,
 557                 CANCELLED,
 558                 CANT_RESOLVE,
 559                 CANT_RESOLVE_PROXY,
 560                 CANT_CONNECT,
 561                 CANT_CONNECT_PROXY,
 562                 SSL_FAILED,
 563                 IO_ERROR,
 564                 MALFORMED,
 565                 TRY_AGAIN,
 566                 CONTINUE,
 567                 SWITCHING_PROTOCOLS,
 568                 PROCESSING,
 569                 OK,
 570                 CREATED,
 571                 ACCEPTED,
 572                 NON_AUTHORITATIVE,
 573                 NO_CONTENT,
 574                 RESET_CONTENT,
 575                 PARTIAL_CONTENT,
 576                 MULTI_STATUS,
 577                 MULTIPLE_CHOICES,
 578                 MOVED_PERMANENTLY,
 579                 FOUND,
 580                 MOVED_TEMPORARILY,
 581                 SEE_OTHER,
 582                 NOT_MODIFIED,
 583                 USE_PROXY,
 584                 NOT_APPEARING_IN_THIS_PROTOCOL,
 585                 TEMPORARY_REDIRECT,
 586                 BAD_REQUEST,
 587                 UNAUTHORIZED,
 588                 PAYMENT_REQUIRED,
 589                 FORBIDDEN,
 590                 NOT_FOUND,
 591                 METHOD_NOT_ALLOWED,
 592                 NOT_ACCEPTABLE,
 593                 PROXY_AUTHENTICATION_REQUIRED,
 594                 PROXY_UNAUTHORIZED,
 595                 REQUEST_TIMEOUT,
 596                 CONFLICT,
 597                 GONE,
 598                 LENGTH_REQUIRED,
 599                 PRECONDITION_FAILED,
 600                 REQUEST_ENTITY_TOO_LARGE,
 601                 REQUEST_URI_TOO_LONG,
 602                 UNSUPPORTED_MEDIA_TYPE,
 603                 REQUESTED_RANGE_NOT_SATISFIABLE,
 604                 INVALID_RANGE,
 605                 EXPECTATION_FAILED,
 606                 UNPROCESSABLE_ENTITY,
 607                 LOCKED,
 608                 FAILED_DEPENDENCY,
 609                 INTERNAL_SERVER_ERROR,
 610                 NOT_IMPLEMENTED,
 611                 BAD_GATEWAY,
 612                 SERVICE_UNAVAILABLE,
 613                 GATEWAY_TIMEOUT,
 614                 HTTP_VERSION_NOT_SUPPORTED,
 615                 INSUFFICIENT_STORAGE,
 616                 NOT_EXTENDED
 617         }
 618         [CCode (cprefix = "SOUP_LOGGER_LOG_", cheader_filename = "libsoup/soup.h")]
 619         public enum LoggerLogLevel {
 620                 NONE,
 621                 MINIMAL,
 622                 HEADERS,
 623                 BODY
 624         }
 625         [CCode (cprefix = "SOUP_MEMORY_", cheader_filename = "libsoup/soup.h")]
 626         public enum MemoryUse {
 627                 STATIC,
 628                 TAKE,
 629                 COPY,
 630                 TEMPORARY
 631         }
 632         [CCode (cprefix = "SOUP_MESSAGE_", cheader_filename = "libsoup/soup.h")]
 633         [Flags]
 634         public enum MessageFlags {
 635                 OVERWRITE_CHUNKS,
 636                 NO_REDIRECT
 637         }
 638         [CCode (cprefix = "SOUP_MESSAGE_HEADERS_", cheader_filename = "libsoup/soup.h")]
 639         public enum MessageHeadersType {
 640                 REQUEST,
 641                 RESPONSE,
 642                 MULTIPART
 643         }
 644         [CCode (cprefix = "SOUP_SSL_ERROR_", cheader_filename = "libsoup/soup.h")]
 645         public enum SSLError {
 646                 HANDSHAKE_NEEDS_READ,
 647                 HANDSHAKE_NEEDS_WRITE,
 648                 CERTIFICATE
 649         }
 650         [CCode (cprefix = "SOUP_SOCKET_", cheader_filename = "libsoup/soup.h")]
 651         public enum SocketIOStatus {
 652                 OK,
 653                 WOULD_BLOCK,
 654                 EOF,
 655                 ERROR
 656         }
 657         [CCode (cprefix = "SOUP_XMLRPC_ERROR_", cheader_filename = "libsoup/soup.h")]
 658         public enum XMLRPCError {
 659                 ARGUMENTS,
 660                 RETVAL
 661         }
 662         [CCode (cprefix = "SOUP_XMLRPC_FAULT_", cheader_filename = "libsoup/soup.h")]
 663         public enum XMLRPCFault {
 664                 PARSE_ERROR_NOT_WELL_FORMED,
 665                 PARSE_ERROR_UNSUPPORTED_ENCODING,
 666                 PARSE_ERROR_INVALID_CHARACTER_FOR_ENCODING,
 667                 SERVER_ERROR_INVALID_XML_RPC,
 668                 SERVER_ERROR_REQUESTED_METHOD_NOT_FOUND,
 669                 SERVER_ERROR_INVALID_METHOD_PARAMETERS,
 670                 SERVER_ERROR_INTERNAL_XML_RPC_ERROR,
 671                 APPLICATION_ERROR,
 672                 SYSTEM_ERROR,
 673                 TRANSPORT_ERROR
 674         }
 675         [CCode (cheader_filename = "libsoup/soup.h")]
 676         public delegate void AddressCallback (Soup.Address addr, uint status);
 677         [CCode (cheader_filename = "libsoup/soup.h")]
 678         public delegate bool AuthDomainBasicAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username, string password);
 679         [CCode (cheader_filename = "libsoup/soup.h")]
 680         public delegate weak string AuthDomainDigestAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username);
 681         [CCode (cheader_filename = "libsoup/soup.h")]
 682         public delegate bool AuthDomainFilter (Soup.AuthDomain domain, Soup.Message msg);
 683         [CCode (cheader_filename = "libsoup/soup.h")]
 684         public delegate bool AuthDomainGenericAuthCallback (Soup.AuthDomain domain, Soup.Message msg, string username);
 685         [CCode (cheader_filename = "libsoup/soup.h")]
 686         public delegate weak Soup.Buffer ChunkAllocator (Soup.Message msg, size_t max_len);
 687         [CCode (cheader_filename = "libsoup/soup.h")]
 688         public delegate Soup.LoggerLogLevel LoggerFilter (Soup.Logger logger, Soup.Message msg);
 689         [CCode (cheader_filename = "libsoup/soup.h")]
 690         public delegate void LoggerPrinter (Soup.Logger logger, Soup.LoggerLogLevel level, string direction, string data);
 691         [CCode (cheader_filename = "libsoup/soup.h")]
 692         public delegate void MessageHeadersForeachFunc (string name, string value);
 693         [CCode (cheader_filename = "libsoup/soup.h")]
 694         public static delegate void ProxyResolverCallback (Soup.ProxyResolver p1, Soup.Message p2, uint p3, Soup.Address p4, void* p5);
 695         [CCode (cheader_filename = "libsoup/soup.h")]
 696         public delegate void ServerCallback (Soup.Server server, Soup.Message msg, string path, GLib.HashTable query, Soup.ClientContext client);
 697         [CCode (cheader_filename = "libsoup/soup.h")]
 698         public delegate void SessionCallback (Soup.Session session, Soup.Message msg);
 699         [CCode (cheader_filename = "libsoup/soup.h")]
 700         public delegate void SocketCallback (Soup.Socket sock, uint status);
 701         [CCode (cheader_filename = "libsoup/soup.h")]
 702         public const int ADDRESS_ANY_PORT;
 703         [CCode (cheader_filename = "libsoup/soup.h")]
 704         public const string ADDRESS_FAMILY;
 705         [CCode (cheader_filename = "libsoup/soup.h")]
 706         public const string ADDRESS_NAME;
 707         [CCode (cheader_filename = "libsoup/soup.h")]
 708         public const string ADDRESS_PHYSICAL;
 709         [CCode (cheader_filename = "libsoup/soup.h")]
 710         public const string ADDRESS_PORT;
 711         [CCode (cheader_filename = "libsoup/soup.h")]
 712         public const string ADDRESS_SOCKADDR;
 713         [CCode (cheader_filename = "libsoup/soup.h")]
 714         public const int AF_INET6;
 715         [CCode (cheader_filename = "libsoup/soup.h")]
 716         public const string AUTH_DOMAIN_ADD_PATH;
 717         [CCode (cheader_filename = "libsoup/soup.h")]
 718         public const string AUTH_DOMAIN_BASIC_AUTH_CALLBACK;
 719         [CCode (cheader_filename = "libsoup/soup.h")]
 720         public const string AUTH_DOMAIN_BASIC_AUTH_DATA;
 721         [CCode (cheader_filename = "libsoup/soup.h")]
 722         public const int AUTH_DOMAIN_BASIC_H;
 723         [CCode (cheader_filename = "libsoup/soup.h")]
 724         public const string AUTH_DOMAIN_DIGEST_AUTH_CALLBACK;
 725         [CCode (cheader_filename = "libsoup/soup.h")]
 726         public const string AUTH_DOMAIN_DIGEST_AUTH_DATA;
 727         [CCode (cheader_filename = "libsoup/soup.h")]
 728         public const int AUTH_DOMAIN_DIGEST_H;
 729         [CCode (cheader_filename = "libsoup/soup.h")]
 730         public const string AUTH_DOMAIN_FILTER;
 731         [CCode (cheader_filename = "libsoup/soup.h")]
 732         public const string AUTH_DOMAIN_FILTER_DATA;
 733         [CCode (cheader_filename = "libsoup/soup.h")]
 734         public const string AUTH_DOMAIN_GENERIC_AUTH_CALLBACK;
 735         [CCode (cheader_filename = "libsoup/soup.h")]
 736         public const string AUTH_DOMAIN_GENERIC_AUTH_DATA;
 737         [CCode (cheader_filename = "libsoup/soup.h")]
 738         public const int AUTH_DOMAIN_H;
 739         [CCode (cheader_filename = "libsoup/soup.h")]
 740         public const string AUTH_DOMAIN_PROXY;
 741         [CCode (cheader_filename = "libsoup/soup.h")]
 742         public const string AUTH_DOMAIN_REALM;
 743         [CCode (cheader_filename = "libsoup/soup.h")]
 744         public const string AUTH_DOMAIN_REMOVE_PATH;
 745         [CCode (cheader_filename = "libsoup/soup.h")]
 746         public const int AUTH_H;
 747         [CCode (cheader_filename = "libsoup/soup.h")]
 748         public const string AUTH_HOST;
 749         [CCode (cheader_filename = "libsoup/soup.h")]
 750         public const string AUTH_IS_AUTHENTICATED;
 751         [CCode (cheader_filename = "libsoup/soup.h")]
 752         public const string AUTH_IS_FOR_PROXY;
 753         [CCode (cheader_filename = "libsoup/soup.h")]
 754         public const string AUTH_REALM;
 755         [CCode (cheader_filename = "libsoup/soup.h")]
 756         public const string AUTH_SCHEME_NAME;
 757         [CCode (cheader_filename = "libsoup/soup.h")]
 758         public const int COOKIE_H;
 759         [CCode (cheader_filename = "libsoup/soup.h")]
 760         public const int COOKIE_JAR_H;
 761         [CCode (cheader_filename = "libsoup/soup.h")]
 762         public const string COOKIE_JAR_READ_ONLY;
 763         [CCode (cheader_filename = "libsoup/soup.h")]
 764         public const string COOKIE_JAR_TEXT_FILENAME;
 765         [CCode (cheader_filename = "libsoup/soup.h")]
 766         public const int COOKIE_JAR_TEXT_H;
 767         [CCode (cheader_filename = "libsoup/soup.h")]
 768         public const int COOKIE_MAX_AGE_ONE_DAY;
 769         [CCode (cheader_filename = "libsoup/soup.h")]
 770         public const int COOKIE_MAX_AGE_ONE_HOUR;
 771         [CCode (cheader_filename = "libsoup/soup.h")]
 772         public const int COOKIE_MAX_AGE_ONE_WEEK;
 773         [CCode (cheader_filename = "libsoup/soup.h")]
 774         public const int COOKIE_MAX_AGE_ONE_YEAR;
 775         [CCode (cheader_filename = "libsoup/soup.h")]
 776         public const int DATE_H;
 777         [CCode (cheader_filename = "libsoup/soup.h")]
 778         public const int FORM_H;
 779         [CCode (cheader_filename = "libsoup/soup.h")]
 780         public const string FORM_MIME_TYPE_MULTIPART;
 781         [CCode (cheader_filename = "libsoup/soup.h")]
 782         public const string FORM_MIME_TYPE_URLENCODED;
 783         [CCode (cheader_filename = "libsoup/soup.h")]
 784         public const int H;
 785         [CCode (cheader_filename = "libsoup/soup.h")]
 786         public const int HEADERS_H;
 787         [CCode (cheader_filename = "libsoup/soup.h")]
 788         public const int LOGGER_H;
 789         [CCode (cheader_filename = "libsoup/soup.h")]
 790         public const int MESSAGE_BODY_H;
 791         [CCode (cheader_filename = "libsoup/soup.h")]
 792         public const string MESSAGE_FLAGS;
 793         [CCode (cheader_filename = "libsoup/soup.h")]
 794         public const int MESSAGE_H;
 795         [CCode (cheader_filename = "libsoup/soup.h")]
 796         public const int MESSAGE_HEADERS_H;
 797         [CCode (cheader_filename = "libsoup/soup.h")]
 798         public const string MESSAGE_HTTP_VERSION;
 799         [CCode (cheader_filename = "libsoup/soup.h")]
 800         public const string MESSAGE_METHOD;
 801         [CCode (cheader_filename = "libsoup/soup.h")]
 802         public const string MESSAGE_REASON_PHRASE;
 803         [CCode (cheader_filename = "libsoup/soup.h")]
 804         public const string MESSAGE_SERVER_SIDE;
 805         [CCode (cheader_filename = "libsoup/soup.h")]
 806         public const string MESSAGE_STATUS_CODE;
 807         [CCode (cheader_filename = "libsoup/soup.h")]
 808         public const string MESSAGE_URI;
 809         [CCode (cheader_filename = "libsoup/soup.h")]
 810         public const int METHOD_H;
 811         [CCode (cheader_filename = "libsoup/soup.h")]
 812         public const int MISC_H;
 813         [CCode (cheader_filename = "libsoup/soup.h")]
 814         public const int MULTIPART_H;
 815         [CCode (cheader_filename = "libsoup/soup.h")]
 816         public const int PROXY_RESOLVER_H;
 817         [CCode (cheader_filename = "libsoup/soup.h")]
 818         public const string SERVER_ASYNC_CONTEXT;
 819         [CCode (cheader_filename = "libsoup/soup.h")]
 820         public const int SERVER_H;
 821         [CCode (cheader_filename = "libsoup/soup.h")]
 822         public const string SERVER_INTERFACE;
 823         [CCode (cheader_filename = "libsoup/soup.h")]
 824         public const string SERVER_PORT;
 825         [CCode (cheader_filename = "libsoup/soup.h")]
 826         public const string SERVER_RAW_PATHS;
 827         [CCode (cheader_filename = "libsoup/soup.h")]
 828         public const string SERVER_SERVER_HEADER;
 829         [CCode (cheader_filename = "libsoup/soup.h")]
 830         public const string SERVER_SSL_CERT_FILE;
 831         [CCode (cheader_filename = "libsoup/soup.h")]
 832         public const string SERVER_SSL_KEY_FILE;
 833         [CCode (cheader_filename = "libsoup/soup.h")]
 834         public const string SESSION_ADD_FEATURE;
 835         [CCode (cheader_filename = "libsoup/soup.h")]
 836         public const string SESSION_ADD_FEATURE_BY_TYPE;
 837         [CCode (cheader_filename = "libsoup/soup.h")]
 838         public const string SESSION_ASYNC_CONTEXT;
 839         [CCode (cheader_filename = "libsoup/soup.h")]
 840         public const int SESSION_ASYNC_H;
 841         [CCode (cheader_filename = "libsoup/soup.h")]
 842         public const int SESSION_FEATURE_H;
 843         [CCode (cheader_filename = "libsoup/soup.h")]
 844         public const int SESSION_H;
 845         [CCode (cheader_filename = "libsoup/soup.h")]
 846         public const string SESSION_IDLE_TIMEOUT;
 847         [CCode (cheader_filename = "libsoup/soup.h")]
 848         public const string SESSION_MAX_CONNS;
 849         [CCode (cheader_filename = "libsoup/soup.h")]
 850         public const string SESSION_MAX_CONNS_PER_HOST;
 851         [CCode (cheader_filename = "libsoup/soup.h")]
 852         public const string SESSION_PROXY_URI;
 853         [CCode (cheader_filename = "libsoup/soup.h")]
 854         public const string SESSION_REMOVE_FEATURE_BY_TYPE;
 855         [CCode (cheader_filename = "libsoup/soup.h")]
 856         public const string SESSION_SSL_CA_FILE;
 857         [CCode (cheader_filename = "libsoup/soup.h")]
 858         public const int SESSION_SYNC_H;
 859         [CCode (cheader_filename = "libsoup/soup.h")]
 860         public const string SESSION_TIMEOUT;
 861         [CCode (cheader_filename = "libsoup/soup.h")]
 862         public const string SESSION_USER_AGENT;
 863         [CCode (cheader_filename = "libsoup/soup.h")]
 864         public const string SESSION_USE_NTLM;
 865         [CCode (cheader_filename = "libsoup/soup.h")]
 866         public const string SOCKET_ASYNC_CONTEXT;
 867         [CCode (cheader_filename = "libsoup/soup.h")]
 868         public const string SOCKET_FLAG_NONBLOCKING;
 869         [CCode (cheader_filename = "libsoup/soup.h")]
 870         public const int SOCKET_H;
 871         [CCode (cheader_filename = "libsoup/soup.h")]
 872         public const string SOCKET_IS_SERVER;
 873         [CCode (cheader_filename = "libsoup/soup.h")]
 874         public const string SOCKET_LOCAL_ADDRESS;
 875         [CCode (cheader_filename = "libsoup/soup.h")]
 876         public const string SOCKET_REMOTE_ADDRESS;
 877         [CCode (cheader_filename = "libsoup/soup.h")]
 878         public const string SOCKET_SSL_CREDENTIALS;
 879         [CCode (cheader_filename = "libsoup/soup.h")]
 880         public const string SOCKET_TIMEOUT;
 881         [CCode (cheader_filename = "libsoup/soup.h")]
 882         public const int STATUS_H;
 883         [CCode (cheader_filename = "libsoup/soup.h")]
 884         public const int TYPES_H;
 885         [CCode (cheader_filename = "libsoup/soup.h")]
 886         public const int URI_H;
 887         [CCode (cheader_filename = "libsoup/soup.h")]
 888         public const int VALUE_UTILS_H;
 889         [CCode (cheader_filename = "libsoup/soup.h")]
 890         public const int XMLRPC_H;
 891         [CCode (cheader_filename = "libsoup/soup.h")]
 892         public static weak GLib.TimeoutSource add_completion (GLib.MainContext async_context, GLib.SourceFunc function, void* data);
 893         [CCode (cheader_filename = "libsoup/soup.h")]
 894         public static weak GLib.TimeoutSource add_idle (GLib.MainContext async_context, GLib.SourceFunc function, void* data);
 895         [CCode (cheader_filename = "libsoup/soup.h")]
 896         public static weak GLib.TimeoutSource add_timeout (GLib.MainContext async_context, uint interval, GLib.SourceFunc function, void* data);
 897         [CCode (cheader_filename = "libsoup/soup.h")]
 898         public static void cookies_free (GLib.SList cookies);
 899         [CCode (cheader_filename = "libsoup/soup.h")]
 900         public static weak GLib.SList cookies_from_request (Soup.Message msg);
 901         [CCode (cheader_filename = "libsoup/soup.h")]
 902         public static weak GLib.SList cookies_from_response (Soup.Message msg);
 903         [CCode (cheader_filename = "libsoup/soup.h")]
 904         public static weak string cookies_to_cookie_header (GLib.SList cookies);
 905         [CCode (cheader_filename = "libsoup/soup.h")]
 906         public static void cookies_to_request (GLib.SList cookies, Soup.Message msg);
 907         [CCode (cheader_filename = "libsoup/soup.h")]
 908         public static void cookies_to_response (GLib.SList cookies, Soup.Message msg);
 909         [CCode (cheader_filename = "libsoup/soup.h")]
 910         public static weak GLib.HashTable form_decode (string encoded_form);
 911         [CCode (cheader_filename = "libsoup/soup.h")]
 912         public static weak GLib.HashTable form_decode_multipart (Soup.Message msg, string file_control_name, out weak string filename, out weak string content_type, out weak Soup.Buffer file);
 913         [CCode (cheader_filename = "libsoup/soup.h")]
 914         public static weak string form_encode (...);
 915         [CCode (cheader_filename = "libsoup/soup.h")]
 916         public static weak string form_encode_datalist (void* form_data_set);
 917         [CCode (cheader_filename = "libsoup/soup.h")]
 918         public static weak string form_encode_hash (GLib.HashTable form_data_set);
 919         [CCode (cheader_filename = "libsoup/soup.h")]
 920         public static weak string form_encode_valist (string first_field, void* args);
 921         [CCode (cheader_filename = "libsoup/soup.h")]
 922         public static weak Soup.Message form_request_new (string method, string uri, ...);
 923         [CCode (cheader_filename = "libsoup/soup.h")]
 924         public static weak Soup.Message form_request_new_from_datalist (string method, string uri, void* form_data_set);
 925         [CCode (cheader_filename = "libsoup/soup.h")]
 926         public static weak Soup.Message form_request_new_from_hash (string method, string uri, GLib.HashTable form_data_set);
 927         [CCode (cheader_filename = "libsoup/soup.h")]
 928         public static weak Soup.Message form_request_new_from_multipart (string uri, Soup.Multipart multipart);
 929         [CCode (cheader_filename = "libsoup/soup.h")]
 930         public static bool header_contains (string header, string token);
 931         [CCode (cheader_filename = "libsoup/soup.h")]
 932         public static void header_free_list (GLib.SList list);
 933         [CCode (cheader_filename = "libsoup/soup.h")]
 934         public static void header_free_param_list (GLib.HashTable param_list);
 935         [CCode (cheader_filename = "libsoup/soup.h")]
 936         public static void header_g_string_append_param (GLib.StringBuilder str, string name, string value);
 937         [CCode (cheader_filename = "libsoup/soup.h")]
 938         public static weak GLib.SList header_parse_list (string header);
 939         [CCode (cheader_filename = "libsoup/soup.h")]
 940         public static weak GLib.HashTable header_parse_param_list (string header);
 941         [CCode (cheader_filename = "libsoup/soup.h")]
 942         public static weak GLib.SList header_parse_quality_list (string header, GLib.SList unacceptable);
 943         [CCode (cheader_filename = "libsoup/soup.h")]
 944         public static weak GLib.HashTable header_parse_semi_param_list (string header);
 945         [CCode (cheader_filename = "libsoup/soup.h")]
 946         public static bool headers_parse (string str, int len, Soup.MessageHeaders dest);
 947         [CCode (cheader_filename = "libsoup/soup.h")]
 948         public static uint headers_parse_request (string str, int len, Soup.MessageHeaders req_headers, out weak string req_method, out weak string req_path, Soup.HTTPVersion ver);
 949         [CCode (cheader_filename = "libsoup/soup.h")]
 950         public static bool headers_parse_response (string str, int len, Soup.MessageHeaders headers, Soup.HTTPVersion ver, uint status_code, out weak string reason_phrase);
 951         [CCode (cheader_filename = "libsoup/soup.h")]
 952         public static bool headers_parse_status_line (string status_line, Soup.HTTPVersion ver, uint status_code, out weak string reason_phrase);
 953         [CCode (cheader_filename = "libsoup/soup.h")]
 954         public static GLib.Quark http_error_quark ();
 955         [CCode (cheader_filename = "libsoup/soup.h")]
 956         public static GLib.Quark ssl_error_quark ();
 957         [CCode (cheader_filename = "libsoup/soup.h")]
 958         public static weak string status_get_phrase (uint status_code);
 959         [CCode (cheader_filename = "libsoup/soup.h")]
 960         public static uint status_proxify (uint status_code);
 961         [CCode (cheader_filename = "libsoup/soup.h")]
 962         public static bool str_case_equal (void* v1, void* v2);
 963         [CCode (cheader_filename = "libsoup/soup.h")]
 964         public static uint str_case_hash (void* key);
 965         [CCode (cheader_filename = "libsoup/soup.h")]
 966         public static void value_array_append (GLib.ValueArray array, GLib.Type type);
 967         [CCode (cheader_filename = "libsoup/soup.h")]
 968         public static void value_array_append_vals (GLib.ValueArray array, ...);
 969         [CCode (cheader_filename = "libsoup/soup.h")]
 970         public static weak GLib.ValueArray value_array_from_args (void* args);
 971         [CCode (cheader_filename = "libsoup/soup.h")]
 972         public static bool value_array_get_nth (GLib.ValueArray array, uint index_, GLib.Type type);
 973         [CCode (cheader_filename = "libsoup/soup.h")]
 974         public static void value_array_insert (GLib.ValueArray array, uint index_, GLib.Type type);
 975         [CCode (cheader_filename = "libsoup/soup.h")]
 976         public static weak GLib.ValueArray value_array_new ();
 977         [CCode (cheader_filename = "libsoup/soup.h")]
 978         public static weak GLib.ValueArray value_array_new_with_vals (...);
 979         [CCode (cheader_filename = "libsoup/soup.h")]
 980         public static bool value_array_to_args (GLib.ValueArray array, void* args);
 981         [CCode (cheader_filename = "libsoup/soup.h")]
 982         public static void value_hash_insert (GLib.HashTable hash, string key, GLib.Type type);
 983         [CCode (cheader_filename = "libsoup/soup.h")]
 984         public static void value_hash_insert_vals (GLib.HashTable hash, ...);
 985         [CCode (cheader_filename = "libsoup/soup.h")]
 986         public static void value_hash_insert_value (GLib.HashTable hash, string key, GLib.Value value);
 987         [CCode (cheader_filename = "libsoup/soup.h")]
 988         public static bool value_hash_lookup (GLib.HashTable hash, string key, GLib.Type type);
 989         [CCode (cheader_filename = "libsoup/soup.h")]
 990         public static bool value_hash_lookup_vals (GLib.HashTable hash, ...);
 991         [CCode (cheader_filename = "libsoup/soup.h")]
 992         public static weak GLib.HashTable value_hash_new ();
 993         [CCode (cheader_filename = "libsoup/soup.h")]
 994         public static weak GLib.HashTable value_hash_new_with_vals (...);
 995         [CCode (cheader_filename = "libsoup/soup.h")]
 996         public static weak string xmlrpc_build_fault (int fault_code, string fault_format);
 997         [CCode (cheader_filename = "libsoup/soup.h")]
 998         public static weak string xmlrpc_build_method_call (string method_name, GLib.Value[] params);
 999         [CCode (cheader_filename = "libsoup/soup.h")]
1000         public static weak string xmlrpc_build_method_response (GLib.Value value);
1001         [CCode (cheader_filename = "libsoup/soup.h")]
1002         public static GLib.Quark xmlrpc_error_quark ();
1003         [CCode (cheader_filename = "libsoup/soup.h")]
1004         public static bool xmlrpc_extract_method_call (string method_call, int length, out weak string method_name);
1005         [CCode (cheader_filename = "libsoup/soup.h")]
1006         public static bool xmlrpc_extract_method_response (string method_response, int length, GLib.Type type) throws GLib.Error;
1007         [CCode (cheader_filename = "libsoup/soup.h")]
1008         public static GLib.Quark xmlrpc_fault_quark ();
1009         [CCode (cheader_filename = "libsoup/soup.h")]
1010         public static bool xmlrpc_parse_method_call (string method_call, int length, out weak string method_name, out weak GLib.ValueArray params);
1011         [CCode (cheader_filename = "libsoup/soup.h")]
1012         public static bool xmlrpc_parse_method_response (string method_response, int length, GLib.Value value) throws GLib.Error;
1013         [CCode (cheader_filename = "libsoup/soup.h")]
1014         public static weak Soup.Message xmlrpc_request_new (string uri, string method_name);
1015         [CCode (cheader_filename = "libsoup/soup.h")]
1016         public static void xmlrpc_set_fault (Soup.Message msg, int fault_code, string fault_format);
1017         [CCode (cheader_filename = "libsoup/soup.h")]
1018         public static void xmlrpc_set_response (Soup.Message msg, GLib.Type type);
1019 }