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