← Back to branch summary

~ubuntu-branches/ubuntu/hardy/vala/hardy

« back to all changes in this revision

Viewing changes to vapi/libsoup-2.2.vapi

  • Committer: Bazaar Package Importer
  • Author(s): Sebastian Dröge, Marc-Andre Lureau, Sebastian Dröge
  • Date: 2007-10-15 14:37:51 UTC
  • mfrom: (1.1.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20071015143751-zy7hqcyjutdyfkg3
Tags: 0.1.4-1
[ Marc-Andre Lureau ]
* New Upstream Version
* debian/patches:
  + Remove patch no longer needed in 0.1.4
* debian/rules
  + Add xsltproc build dependency for the Vala manual.
  + Add libenchant-dev build dependency for enchant test case.
* debian/control, debian/vala-doc.install:
  + Add a "vala-doc" documentation package.

[ Sebastian Dröge ]
* debian/control:
  + Let vala-doc suggest valac/devhelp and don't depend on libvala0.
* debian/libvala-dev.install:
  + Add the new vapicheck utility.

Show diffs side-by-side

added added

removed removed

Lines of Context:
vapi/libsoup-2.2.vapi
 
1
/* libsoup-2.2.vapi generated by lt-vapigen, do not modify. */
 
2
 
 
3
[CCode (cprefix = "Soup", lower_case_cprefix = "soup_")]
 
4
namespace Soup {
 
5
        [CCode (cprefix = "SOUP_ADDRESS_FAMILY_", cheader_filename = "libsoup/soup.h")]
 
6
        public enum AddressFamily {
 
7
                IPV4,
 
8
                IPV6,
 
9
        }
 
10
        [CCode (cprefix = "SOUP_AUTH_TYPE_", cheader_filename = "libsoup/soup.h")]
 
11
        public enum AuthType {
 
12
                BASIC,
 
13
                DIGEST,
 
14
        }
 
15
        [CCode (cprefix = "SOUP_ALGORITHM_", cheader_filename = "libsoup/soup.h")]
 
16
        public enum DigestAlgorithm {
 
17
                MD5,
 
18
                MD5_SESS,
 
19
        }
 
20
        [CCode (cprefix = "SOUP_HANDLER_", cheader_filename = "libsoup/soup.h")]
 
21
        public enum HandlerPhase {
 
22
                POST_REQUEST,
 
23
                PRE_BODY,
 
24
                BODY_CHUNK,
 
25
                POST_BODY,
 
26
        }
 
27
        [CCode (cprefix = "SOUP_HTTP_", cheader_filename = "libsoup/soup.h")]
 
28
        public enum HttpVersion {
 
29
                1_0,
 
30
                1_1,
 
31
        }
 
32
        [CCode (cprefix = "SOUP_STATUS_", cheader_filename = "libsoup/soup.h")]
 
33
        public enum KnownStatusCode {
 
34
                NONE,
 
35
                CANCELLED,
 
36
                CANT_RESOLVE,
 
37
                CANT_RESOLVE_PROXY,
 
38
                CANT_CONNECT,
 
39
                CANT_CONNECT_PROXY,
 
40
                SSL_FAILED,
 
41
                IO_ERROR,
 
42
                MALFORMED,
 
43
                TRY_AGAIN,
 
44
                CONTINUE,
 
45
                SWITCHING_PROTOCOLS,
 
46
                PROCESSING,
 
47
                OK,
 
48
                CREATED,
 
49
                ACCEPTED,
 
50
                NON_AUTHORITATIVE,
 
51
                NO_CONTENT,
 
52
                RESET_CONTENT,
 
53
                PARTIAL_CONTENT,
 
54
                MULTI_STATUS,
 
55
                MULTIPLE_CHOICES,
 
56
                MOVED_PERMANENTLY,
 
57
                FOUND,
 
58
                MOVED_TEMPORARILY,
 
59
                SEE_OTHER,
 
60
                NOT_MODIFIED,
 
61
                USE_PROXY,
 
62
                NOT_APPEARING_IN_THIS_PROTOCOL,
 
63
                TEMPORARY_REDIRECT,
 
64
                BAD_REQUEST,
 
65
                UNAUTHORIZED,
 
66
                PAYMENT_REQUIRED,
 
67
                FORBIDDEN,
 
68
                NOT_FOUND,
 
69
                METHOD_NOT_ALLOWED,
 
70
                NOT_ACCEPTABLE,
 
71
                PROXY_AUTHENTICATION_REQUIRED,
 
72
                PROXY_UNAUTHORIZED,
 
73
                REQUEST_TIMEOUT,
 
74
                CONFLICT,
 
75
                GONE,
 
76
                LENGTH_REQUIRED,
 
77
                PRECONDITION_FAILED,
 
78
                REQUEST_ENTITY_TOO_LARGE,
 
79
                REQUEST_URI_TOO_LONG,
 
80
                UNSUPPORTED_MEDIA_TYPE,
 
81
                REQUESTED_RANGE_NOT_SATISFIABLE,
 
82
                INVALID_RANGE,
 
83
                EXPECTATION_FAILED,
 
84
                UNPROCESSABLE_ENTITY,
 
85
                LOCKED,
 
86
                FAILED_DEPENDENCY,
 
87
                INTERNAL_SERVER_ERROR,
 
88
                NOT_IMPLEMENTED,
 
89
                BAD_GATEWAY,
 
90
                SERVICE_UNAVAILABLE,
 
91
                GATEWAY_TIMEOUT,
 
92
                HTTP_VERSION_NOT_SUPPORTED,
 
93
                INSUFFICIENT_STORAGE,
 
94
                NOT_EXTENDED,
 
95
        }
 
96
        [CCode (cprefix = "SOUP_MESSAGE_", cheader_filename = "libsoup/soup.h")]
 
97
        public enum MessageFlags {
 
98
                NO_REDIRECT,
 
99
                OVERWRITE_CHUNKS,
 
100
                EXPECT_CONTINUE,
 
101
        }
 
102
        [CCode (cprefix = "SOUP_MESSAGE_STATUS_", cheader_filename = "libsoup/soup.h")]
 
103
        public enum MessageStatus {
 
104
                IDLE,
 
105
                QUEUED,
 
106
                CONNECTING,
 
107
                RUNNING,
 
108
                FINISHED,
 
109
        }
 
110
        [CCode (cprefix = "SOUP_METHOD_ID_", cheader_filename = "libsoup/soup.h")]
 
111
        public enum MethodId {
 
112
                UNKNOWN,
 
113
                POST,
 
114
                GET,
 
115
                HEAD,
 
116
                OPTIONS,
 
117
                PUT,
 
118
                MOVE,
 
119
                COPY,
 
120
                DELETE,
 
121
                TRACE,
 
122
                CONNECT,
 
123
                MKCOL,
 
124
                PROPPATCH,
 
125
                PROPFIND,
 
126
                PATCH,
 
127
                LOCK,
 
128
                UNLOCK,
 
129
        }
 
130
        [CCode (cprefix = "SOUP_BUFFER_", cheader_filename = "libsoup/soup.h")]
 
131
        public enum Ownership {
 
132
                SYSTEM_OWNED,
 
133
                USER_OWNED,
 
134
                STATIC,
 
135
        }
 
136
        [CCode (cprefix = "SOUP_SSL_TYPE_", cheader_filename = "libsoup/soup.h")]
 
137
        public enum SSLType {
 
138
                CLIENT,
 
139
                SERVER,
 
140
        }
 
141
        [CCode (cprefix = "SOUP_SSL_ERROR_", cheader_filename = "libsoup/soup.h")]
 
142
        public enum SocketError {
 
143
                HANDSHAKE_NEEDS_READ,
 
144
                HANDSHAKE_NEEDS_WRITE,
 
145
                CERTIFICATE,
 
146
        }
 
147
        [CCode (cprefix = "SOUP_SOCKET_", cheader_filename = "libsoup/soup.h")]
 
148
        public enum SocketIOStatus {
 
149
                OK,
 
150
                WOULD_BLOCK,
 
151
                EOF,
 
152
                ERROR,
 
153
        }
 
154
        [CCode (cprefix = "SOUP_STATUS_CLASS_", cheader_filename = "libsoup/soup.h")]
 
155
        public enum StatusClass {
 
156
                TRANSPORT_ERROR,
 
157
                INFORMATIONAL,
 
158
                SUCCESS,
 
159
                REDIRECT,
 
160
                CLIENT_ERROR,
 
161
                SERVER_ERROR,
 
162
        }
 
163
        [CCode (cprefix = "SOUP_TRANSFER_", cheader_filename = "libsoup/soup.h")]
 
164
        public enum TransferEncoding {
 
165
                UNKNOWN,
 
166
                CHUNKED,
 
167
                CONTENT_LENGTH,
 
168
                BYTERANGES,
 
169
                NONE,
 
170
                EOF,
 
171
        }
 
172
        [CCode (cprefix = "SOUP_XMLRPC_VALUE_TYPE_", cheader_filename = "libsoup/soup.h")]
 
173
        public enum XmlrpcValueType {
 
174
                BAD,
 
175
                INT,
 
176
                BOOLEAN,
 
177
                STRING,
 
178
                DOUBLE,
 
179
                DATETIME,
 
180
                BASE64,
 
181
                STRUCT,
 
182
                ARRAY,
 
183
        }
 
184
        [CCode (cheader_filename = "libsoup/soup.h")]
 
185
        public class ServerAuth {
 
186
                public ServerAuth (Soup.ServerAuthContext auth_ctx, GLib.SList auth_hdrs, Soup.Message msg);
 
187
                public weak string get_user ();
 
188
                public bool check_passwd (string passwd);
 
189
        }
 
190
        [CCode (cheader_filename = "libsoup/soup.h")]
 
191
        public class Address : GLib.Object {
 
192
                public weak string get_name ();
 
193
                public weak string get_physical ();
 
194
                public uint get_port ();
 
195
                public static GLib.Type get_type ();
 
196
                public Address (string name, uint port);
 
197
                public Address.any (Soup.AddressFamily family, uint port);
 
198
                public void resolve_async (Soup.AddressCallback callback, pointer user_data);
 
199
                public void resolve_async_full (GLib.MainContext async_context, Soup.AddressCallback callback, pointer user_data);
 
200
                public uint resolve_sync ();
 
201
                public signal void dns_result (uint status);
 
202
        }
 
203
        [CCode (cheader_filename = "libsoup/soup.h")]
 
204
        public class Auth : GLib.Object {
 
205
                public void authenticate (string username, string password);
 
206
                public static GLib.Type basic_get_type ();
 
207
                public void free_protection_space (GLib.SList space);
 
208
                public weak string get_authorization (Soup.Message msg);
 
209
                public weak GLib.SList get_protection_space (Soup.Uri source_uri);
 
210
                public weak string get_realm ();
 
211
                public weak string get_scheme_name ();
 
212
                public static GLib.Type get_type ();
 
213
                public virtual bool is_authenticated ();
 
214
                public Auth.from_header_list (GLib.SList vals);
 
215
        }
 
216
        [CCode (cheader_filename = "libsoup/soup.h")]
 
217
        public class AuthDigest : Soup.Auth {
 
218
                public static GLib.Type get_type ();
 
219
        }
 
220
        [CCode (cheader_filename = "libsoup/soup.h")]
 
221
        public class Connection : GLib.Object {
 
222
                public void authenticate (Soup.Message msg, string auth_type, string auth_realm, out string username, out string password);
 
223
                public void connect_async (Soup.ConnectionCallback callback, pointer user_data);
 
224
                public uint connect_sync ();
 
225
                public void disconnect ();
 
226
                public static GLib.Type get_type ();
 
227
                public bool is_in_use ();
 
228
                public ulong last_used ();
 
229
                public Connection (string propname1);
 
230
                public void reauthenticate (Soup.Message msg, string auth_type, string auth_realm, out string username, out string password);
 
231
                public void release ();
 
232
                public void reserve ();
 
233
                public virtual void send_request (Soup.Message req);
 
234
                [NoAccessorMethod]
 
235
                public weak pointer origin_uri { get; construct; }
 
236
                [NoAccessorMethod]
 
237
                public weak pointer proxy_uri { get; construct; }
 
238
                [NoAccessorMethod]
 
239
                public weak pointer ssl_creds { get; construct; }
 
240
                [NoAccessorMethod]
 
241
                public weak pointer message_filter { get; set; }
 
242
                [NoAccessorMethod]
 
243
                public weak pointer async_context { get; construct; }
 
244
                [NoAccessorMethod]
 
245
                public weak uint timeout { get; set; }
 
246
                public signal void connect_result (uint arg2);
 
247
                public signal void disconnected ();
 
248
        }
 
249
        [CCode (cheader_filename = "libsoup/soup.h")]
 
250
        public class ConnectionNTLM : Soup.Connection {
 
251
                public static GLib.Type get_type ();
 
252
        }
 
253
        [CCode (cheader_filename = "libsoup/soup.h")]
 
254
        public class Message : GLib.Object {
 
255
                public weak string method;
 
256
                public uint status_code;
 
257
                public weak string reason_phrase;
 
258
                public weak Soup.DataBuffer request;
 
259
                public weak GLib.HashTable request_headers;
 
260
                public weak Soup.DataBuffer response;
 
261
                public weak GLib.HashTable response_headers;
 
262
                public Soup.MessageStatus status;
 
263
                public void add_chunk (Soup.Ownership owner, string body, uint length);
 
264
                public void add_final_chunk ();
 
265
                public void add_handler (Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb, pointer user_data);
 
266
                public static void add_header (GLib.HashTable hash, string name, string value);
 
267
                public void add_header_handler (string header, Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb, pointer user_data);
 
268
                public void add_status_class_handler (pointer status_class, Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb, pointer user_data);
 
269
                public void add_status_code_handler (uint status_code, Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb, pointer user_data);
 
270
                public static void clear_headers (GLib.HashTable hash);
 
271
                public uint get_flags ();
 
272
                public static weak string get_header (GLib.HashTable hash, string name);
 
273
                public static weak GLib.SList get_header_list (GLib.HashTable hash, string name);
 
274
                public Soup.HttpVersion get_http_version ();
 
275
                public Soup.TransferEncoding get_request_encoding (uint content_length);
 
276
                public Soup.TransferEncoding get_response_encoding (uint content_length);
 
277
                public static GLib.Type get_type ();
 
278
                public weak Soup.Uri get_uri ();
 
279
                public bool io_in_progress ();
 
280
                public void io_pause ();
 
281
                public void io_stop ();
 
282
                public void io_unpause ();
 
283
                public bool is_keepalive ();
 
284
                public Message (string method, string uri_string);
 
285
                public Message.from_uri (string method, Soup.Uri uri);
 
286
                public weak Soup.DataBuffer pop_chunk ();
 
287
                public void read_request (Soup.Socket sock);
 
288
                public void remove_handler (Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb, pointer user_data);
 
289
                public static void remove_header (GLib.HashTable hash, string name);
 
290
                public void send_request (Soup.Socket sock, bool is_via_proxy);
 
291
                public void set_flags (uint flags);
 
292
                public void set_http_version (Soup.HttpVersion version);
 
293
                public void set_request (string content_type, Soup.Ownership req_owner, string req_body, ulong req_length);
 
294
                public void set_response (string content_type, Soup.Ownership resp_owner, string resp_body, ulong resp_length);
 
295
                public void set_status (uint status_code);
 
296
                public void set_status_full (uint status_code, string reason_phrase);
 
297
                public void set_uri (Soup.Uri uri);
 
298
                [HasEmitter]
 
299
                public signal void wrote_informational ();
 
300
                [HasEmitter]
 
301
                public signal void wrote_headers ();
 
302
                [HasEmitter]
 
303
                public signal void wrote_chunk ();
 
304
                [HasEmitter]
 
305
                public signal void wrote_body ();
 
306
                [HasEmitter]
 
307
                public signal void got_informational ();
 
308
                [HasEmitter]
 
309
                public signal void got_headers ();
 
310
                [HasEmitter]
 
311
                public signal void got_chunk ();
 
312
                [HasEmitter]
 
313
                public signal void got_body ();
 
314
                [HasEmitter]
 
315
                public signal void restarted ();
 
316
                [HasEmitter]
 
317
                public signal void finished ();
 
318
        }
 
319
        [CCode (cheader_filename = "libsoup/soup.h")]
 
320
        public class Server : GLib.Object {
 
321
                public void add_handler (string path, Soup.ServerAuthContext auth_ctx, Soup.ServerCallbackFn callback, Soup.ServerUnregisterFn unreg, pointer data);
 
322
                public static bool auth_check_passwd (Soup.ServerAuth auth, string passwd);
 
323
                public static void auth_free (Soup.ServerAuth auth);
 
324
                public static weak string auth_get_user (Soup.ServerAuth auth);
 
325
                public static weak Soup.ServerAuth auth_new (Soup.ServerAuthContext auth_ctx, GLib.SList auth_hdrs, Soup.Message msg);
 
326
                public weak Soup.ServerHandler get_handler (string path);
 
327
                public weak Soup.Socket get_listener ();
 
328
                public uint get_port ();
 
329
                public GLib.Quark get_protocol ();
 
330
                public static GLib.Type get_type ();
 
331
                public weak GLib.SList list_handlers ();
 
332
                public Server (string optname1, ...);
 
333
                public void quit ();
 
334
                public void remove_handler (string path);
 
335
                public void run ();
 
336
                public void run_async ();
 
337
                [NoAccessorMethod]
 
338
                public weak uint port { get; construct; }
 
339
                [NoAccessorMethod]
 
340
                public weak Soup.Address @interface { get; construct; }
 
341
                [NoAccessorMethod]
 
342
                public weak string ssl_cert_file { get; construct; }
 
343
                [NoAccessorMethod]
 
344
                public weak string ssl_key_file { get; construct; }
 
345
                [NoAccessorMethod]
 
346
                public weak pointer async_context { get; construct; }
 
347
        }
 
348
        [CCode (cheader_filename = "libsoup/soup.h")]
 
349
        public class ServerMessage : Soup.Message {
 
350
                public void finish ();
 
351
                public Soup.TransferEncoding get_encoding ();
 
352
                public weak Soup.Server get_server ();
 
353
                public static GLib.Type get_type ();
 
354
                public bool is_finished ();
 
355
                public bool is_started ();
 
356
                public ServerMessage (Soup.Server server);
 
357
                public void set_encoding (Soup.TransferEncoding encoding);
 
358
                public void start ();
 
359
        }
 
360
        [CCode (cheader_filename = "libsoup/soup.h")]
 
361
        public class Session : GLib.Object {
 
362
                public void abort ();
 
363
                public void add_filter (Soup.MessageFilter filter);
 
364
                public virtual void cancel_message (Soup.Message msg);
 
365
                public weak Soup.Connection get_connection (Soup.Message msg, bool try_pruning, bool is_new);
 
366
                public static GLib.Type get_type ();
 
367
                public void queue_message (Soup.Message msg, Soup.MessageCallbackFn callback, pointer user_data);
 
368
                public void remove_filter (Soup.MessageFilter filter);
 
369
                public virtual void requeue_message (Soup.Message msg);
 
370
                public virtual uint send_message (Soup.Message msg);
 
371
                public bool try_prune_connection ();
 
372
                [NoAccessorMethod]
 
373
                public weak pointer proxy_uri { get; set; }
 
374
                [NoAccessorMethod]
 
375
                public weak int max_conns { get; set; }
 
376
                [NoAccessorMethod]
 
377
                public weak int max_conns_per_host { get; set; }
 
378
                [NoAccessorMethod]
 
379
                public weak bool use_ntlm { get; set; }
 
380
                [NoAccessorMethod]
 
381
                public weak string ssl_ca_file { get; set; }
 
382
                [NoAccessorMethod]
 
383
                public weak pointer async_context { get; construct; }
 
384
                [NoAccessorMethod]
 
385
                public weak uint timeout { get; set; }
 
386
        }
 
387
        [CCode (cheader_filename = "libsoup/soup.h")]
 
388
        public class SessionAsync : Soup.Session {
 
389
                public static GLib.Type get_type ();
 
390
                public SessionAsync ();
 
391
                public SessionAsync.with_options (string optname1);
 
392
        }
 
393
        [CCode (cheader_filename = "libsoup/soup.h")]
 
394
        public class SessionSync : Soup.Session {
 
395
                public static GLib.Type get_type ();
 
396
                public SessionSync ();
 
397
                public SessionSync.with_options (string optname1);
 
398
        }
 
399
        [CCode (cheader_filename = "libsoup/soup.h")]
 
400
        public class Socket : GLib.Object {
 
401
                public static weak Soup.Socket client_new_async (string hostname, uint port, pointer ssl_creds, Soup.SocketCallback callback, pointer user_data);
 
402
                public static weak Soup.Socket client_new_sync (string hostname, uint port, pointer ssl_creds, uint status_ret);
 
403
                public uint connect (Soup.Address remote_addr);
 
404
                public void disconnect ();
 
405
                public weak Soup.Address get_local_address ();
 
406
                public weak Soup.Address get_remote_address ();
 
407
                public static GLib.Type get_type ();
 
408
                public bool is_connected ();
 
409
                public bool listen (Soup.Address local_addr);
 
410
                public Socket (string optname1);
 
411
                public Soup.SocketIOStatus read (pointer buffer, ulong len, ulong nread);
 
412
                public Soup.SocketIOStatus read_until (pointer buffer, ulong len, pointer boundary, ulong boundary_len, ulong nread, bool got_boundary);
 
413
                public static weak Soup.Socket server_new (Soup.Address local_addr, pointer ssl_creds, Soup.SocketListenerCallback callback, pointer user_data);
 
414
                public bool start_proxy_ssl (string ssl_host);
 
415
                public bool start_ssl ();
 
416
                public Soup.SocketIOStatus write (pointer buffer, ulong len, ulong nwrote);
 
417
                [NoAccessorMethod]
 
418
                public weak bool non_blocking { get; set; }
 
419
                [NoAccessorMethod]
 
420
                public weak bool nodelay { get; set; }
 
421
                [NoAccessorMethod]
 
422
                public weak bool reuseaddr { get; set; }
 
423
                [NoAccessorMethod]
 
424
                public weak bool cloexec { get; set; }
 
425
                [NoAccessorMethod]
 
426
                public weak bool is_server { get; }
 
427
                [NoAccessorMethod]
 
428
                public weak pointer ssl_creds { get; set; }
 
429
                [NoAccessorMethod]
 
430
                public weak pointer async_context { get; construct; }
 
431
                [NoAccessorMethod]
 
432
                public weak uint timeout { get; set; }
 
433
                public signal void connect_result (uint arg2);
 
434
                public signal void readable ();
 
435
                public signal void writable ();
 
436
                public signal void disconnected ();
 
437
                public signal void new_connection (Soup.Socket arg2);
 
438
        }
 
439
        [CCode (cheader_filename = "libsoup/soup.h")]
 
440
        public class AuthBasicClass {
 
441
                public pointer parent_class;
 
442
        }
 
443
        [CCode (cheader_filename = "libsoup/soup.h")]
 
444
        public class DNSLookup {
 
445
                public void cancel ();
 
446
                public weak string get_hostname ();
 
447
                public static weak Soup.DNSLookup name (string name);
 
448
                public bool resolve ();
 
449
                public void resolve_async (GLib.MainContext async_context, Soup.DNSCallback callback, pointer user_data);
 
450
        }
 
451
        [CCode (cheader_filename = "libsoup/soup.h")]
 
452
        public class DataBuffer {
 
453
                public Soup.Ownership owner;
 
454
                public weak string body;
 
455
                public uint length;
 
456
        }
 
457
        [CCode (cheader_filename = "libsoup/soup.h")]
 
458
        public class MD5Context {
 
459
                public uint buf;
 
460
                public uint bits;
 
461
                public uchar @in;
 
462
                public bool doByteReverse;
 
463
        }
 
464
        [CCode (free_function = "soup_message_queue_destroy", cheader_filename = "libsoup/soup.h")]
 
465
        public class MessageQueue {
 
466
                public void append (Soup.Message msg);
 
467
                public weak Soup.Message first (Soup.MessageQueueIter iter);
 
468
                public void free_iter (Soup.MessageQueueIter iter);
 
469
                public MessageQueue ();
 
470
                public weak Soup.Message next (Soup.MessageQueueIter iter);
 
471
                public weak Soup.Message remove (Soup.MessageQueueIter iter);
 
472
                public void remove_message (Soup.Message msg);
 
473
        }
 
474
        [CCode (cheader_filename = "libsoup/soup.h")]
 
475
        public class MessageQueueIter {
 
476
                public weak GLib.List cur;
 
477
                public weak GLib.List next;
 
478
        }
 
479
        [CCode (cheader_filename = "libsoup/soup.h")]
 
480
        public class ServerAuthBasic {
 
481
                public Soup.AuthType type;
 
482
                public weak string user;
 
483
                public weak string passwd;
 
484
        }
 
485
        [CCode (cheader_filename = "libsoup/soup.h")]
 
486
        public class ServerAuthContext {
 
487
                public uint types;
 
488
                public Soup.ServerAuthCallbackFn callback;
 
489
                public pointer user_data;
 
490
                public uint allow_algorithms;
 
491
                public bool force_integrity;
 
492
                public void challenge (Soup.Message msg, string header_name);
 
493
        }
 
494
        [CCode (cheader_filename = "libsoup/soup.h")]
 
495
        public class ServerAuthDigest {
 
496
                public Soup.AuthType type;
 
497
                public Soup.DigestAlgorithm algorithm;
 
498
                public bool integrity;
 
499
                public weak string realm;
 
500
                public weak string user;
 
501
                public weak string nonce;
 
502
                public int nonce_count;
 
503
                public weak string cnonce;
 
504
                public weak string digest_uri;
 
505
                public weak string digest_response;
 
506
                public weak string request_method;
 
507
        }
 
508
        [CCode (cheader_filename = "libsoup/soup.h")]
 
509
        public class ServerContext {
 
510
                public weak Soup.Message msg;
 
511
                public weak string path;
 
512
                public Soup.MethodId method_id;
 
513
                public weak Soup.ServerAuth auth;
 
514
                public weak Soup.Server server;
 
515
                public weak Soup.ServerHandler handler;
 
516
                public weak Soup.Socket sock;
 
517
                public weak Soup.Address get_client_address ();
 
518
                public weak string get_client_host ();
 
519
        }
 
520
        [CCode (cheader_filename = "libsoup/soup.h")]
 
521
        public class ServerHandler {
 
522
                public weak string path;
 
523
                public weak Soup.ServerAuthContext auth_ctx;
 
524
                public Soup.ServerCallbackFn callback;
 
525
                public Soup.ServerUnregisterFn unregister;
 
526
                public pointer user_data;
 
527
        }
 
528
        [CCode (copy_function = "soup_uri_copy", cheader_filename = "libsoup/soup.h")]
 
529
        public class Uri {
 
530
                public GLib.Quark protocol;
 
531
                public weak string user;
 
532
                public weak string passwd;
 
533
                public weak string host;
 
534
                public uint port;
 
535
                public weak string path;
 
536
                public weak string query;
 
537
                public weak string fragment;
 
538
                public bool broken_encoding;
 
539
                public weak Soup.Uri copy ();
 
540
                public weak Soup.Uri copy_root ();
 
541
                public static void decode (string part);
 
542
                public static weak string encode (string part, string escape_extra);
 
543
                public bool equal (Soup.Uri uri2);
 
544
                public Uri (string uri_string);
 
545
                public Uri.with_base (Soup.Uri @base, string uri_string);
 
546
                public weak string to_string (bool just_path);
 
547
                public bool uses_default_port ();
 
548
        }
 
549
        [CCode (cheader_filename = "libsoup/soup.h")]
 
550
        public class Date {
 
551
                public static weak string generate (ulong when);
 
552
                public static ulong iso8601_parse (string timestamp);
 
553
                public static ulong parse (string timestamp);
 
554
        }
 
555
        [CCode (cheader_filename = "libsoup/soup.h")]
 
556
        public class Dns {
 
557
                public static void init ();
 
558
        }
 
559
        [CCode (cheader_filename = "libsoup/soup.h")]
 
560
        public class Header {
 
561
                public static weak string param_copy_token (GLib.HashTable tokens, string t);
 
562
                public static weak string param_decode_token (out string @in);
 
563
                public static void param_destroy_hash (GLib.HashTable table);
 
564
                public static weak GLib.HashTable param_parse_list (string header);
 
565
        }
 
566
        [CCode (cheader_filename = "libsoup/soup.h")]
 
567
        public class Headers {
 
568
                public static bool parse_request (string str, int len, GLib.HashTable dest, out string req_method, out string req_path, Soup.HttpVersion ver);
 
569
                public static bool parse_response (string str, int len, GLib.HashTable dest, Soup.HttpVersion ver, uint status_code, out string reason_phrase);
 
570
                public static bool parse_status_line (string status_line, Soup.HttpVersion ver, uint status_code, out string reason_phrase);
 
571
        }
 
572
        [CCode (cheader_filename = "libsoup/soup.h")]
 
573
        public class Ssl {
 
574
                public static GLib.Quark error_quark ();
 
575
                public static void free_client_credentials (pointer creds);
 
576
                public static void free_server_credentials (pointer creds);
 
577
                public static pointer get_client_credentials (string ca_file);
 
578
                public static pointer get_server_credentials (string cert_file, string key_file);
 
579
                public static weak GLib.IOChannel wrap_iochannel (GLib.IOChannel sock, Soup.SSLType type, string remote_host, pointer credentials);
 
580
        }
 
581
        [CCode (cheader_filename = "libsoup/soup.h")]
 
582
        public class Str {
 
583
                public static bool case_equal (pointer v1, pointer v2);
 
584
                public static uint case_hash (pointer key);
 
585
        }
 
586
        [CCode (cheader_filename = "libsoup/soup.h")]
 
587
        public interface MessageFilter {
 
588
                public static GLib.Type get_type ();
 
589
                public abstract void setup_message (Soup.Message msg);
 
590
        }
 
591
        public static delegate void AddressCallback (Soup.Address addr, uint status, pointer data);
 
592
        public static delegate void ConnectionCallback (Soup.Connection conn, uint status, pointer data);
 
593
        public static delegate void DNSCallback (Soup.DNSLookup lookup, bool success, pointer user_data);
 
594
        public static delegate void MessageCallbackFn (Soup.Message req, pointer user_data);
 
595
        public static delegate bool ServerAuthCallbackFn (Soup.ServerAuthContext auth_ctx, Soup.ServerAuth auth, Soup.Message msg, pointer data);
 
596
        public static delegate void ServerCallbackFn (Soup.ServerContext context, Soup.Message msg, pointer user_data);
 
597
        public static delegate void ServerUnregisterFn (Soup.Server server, Soup.ServerHandler handler, pointer user_data);
 
598
        public static delegate void SocketCallback (Soup.Socket sock, uint status, pointer user_data);
 
599
        public static delegate void SocketListenerCallback (Soup.Socket listener, Soup.Socket sock, pointer user_data);
 
600
        public static weak GLib.Source add_idle (GLib.MainContext async_context, GLib.SourceFunc function, pointer data);
 
601
        public static weak GLib.Source add_timeout (GLib.MainContext async_context, uint interval, GLib.SourceFunc function, pointer data);
 
602
        public static Soup.MethodId method_get_id (string method);
 
603
        public static uint signal_connect_once (pointer instance, string detailed_signal, GLib.Callback c_handler, pointer data);
 
604
        public static weak string status_get_phrase (uint status_code);
 
605
}