vapi/libsoup-2.2.vapi

   1 /* libsoup-2.2.vapi generated by vapigen, do not modify. */
   2
   3 [CCode (cprefix = "Soup", lower_case_cprefix = "soup_")]
   4 namespace Soup {
   5         [CCode (cheader_filename = "libsoup/soup.h")]
   6         public class Address : GLib.Object {
   7                 [CCode (has_construct_function = false)]
   8                 public Address (string name, uint port);
   9                 [CCode (has_construct_function = false)]
  10                 public Address.any (Soup.AddressFamily family, uint port);
  11                 public unowned string get_name ();
  12                 public unowned string get_physical ();
  13                 public uint get_port ();
  14                 public void* get_sockaddr (int len);
  15                 public void resolve_async (Soup.AddressCallback callback);
  16                 public void resolve_async_full (GLib.MainContext async_context, Soup.AddressCallback callback);
  17                 public uint resolve_sync ();
  18                 public virtual signal void dns_result (int status);
  19         }
  20         [CCode (cheader_filename = "libsoup/soup.h")]
  21         public class Connection : GLib.Object {
  22                 [CCode (has_construct_function = false)]
  23                 public Connection (string propname1);
  24                 public void connect_async (Soup.ConnectionCallback callback);
  25                 public uint connect_sync ();
  26                 public void disconnect ();
  27                 public bool is_in_use ();
  28                 public ulong last_used ();
  29                 public void release ();
  30                 public void reserve ();
  31                 public virtual void send_request (Soup.Message req);
  32                 [NoAccessorMethod]
  33                 public void* async_context { get; construct; }
  34                 [NoAccessorMethod]
  35                 public void* message_filter { get; set; }
  36                 [NoAccessorMethod]
  37                 public void* origin_uri { get; construct; }
  38                 [NoAccessorMethod]
  39                 public void* proxy_uri { get; construct; }
  40                 [NoAccessorMethod]
  41                 public void* ssl_creds { get; construct; }
  42                 [NoAccessorMethod]
  43                 public uint timeout { get; set; }
  44                 [HasEmitter]
  45                 public virtual signal void authenticate (Soup.Message p0, string auth_type, string auth_realm, void* username, void* password);
  46                 public virtual signal void connect_result (int p0);
  47                 public virtual signal void disconnected ();
  48                 [HasEmitter]
  49                 public virtual signal void reauthenticate (Soup.Message p0, string auth_type, string auth_realm, void* username, void* password);
  50         }
  51         [CCode (cheader_filename = "libsoup/soup.h")]
  52         public class Message : GLib.Object {
  53                 public weak string method;
  54                 public weak string reason_phrase;
  55                 public Soup.DataBuffer request;
  56                 public weak GLib.HashTable request_headers;
  57                 public Soup.DataBuffer response;
  58                 public weak GLib.HashTable response_headers;
  59                 public Soup.MessageStatus status;
  60                 public uint status_code;
  61                 [CCode (has_construct_function = false)]
  62                 public Message (string method, string uri_string);
  63                 public void add_chunk (Soup.Ownership owner, owned string body, uint length);
  64                 public void add_final_chunk ();
  65                 public void add_handler (Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb);
  66                 public static void add_header (GLib.HashTable hash, string name, string value);
  67                 public void add_header_handler (string header, Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb);
  68                 public void add_status_class_handler (Soup.StatusClass status_class, Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb);
  69                 public void add_status_code_handler (uint status_code, Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb);
  70                 public static void clear_headers (GLib.HashTable hash);
  71                 [CCode (has_construct_function = false)]
  72                 public Message.from_uri (string method, Soup.Uri uri);
  73                 public uint get_flags ();
  74                 public static unowned string get_header (GLib.HashTable hash, string name);
  75                 public static unowned GLib.SList get_header_list (GLib.HashTable hash, string name);
  76                 public Soup.HttpVersion get_http_version ();
  77                 public Soup.TransferEncoding get_request_encoding (uint content_length);
  78                 public Soup.TransferEncoding get_response_encoding (uint content_length);
  79                 public unowned Soup.Uri get_uri ();
  80                 public bool io_in_progress ();
  81                 public void io_pause ();
  82                 public void io_stop ();
  83                 public void io_unpause ();
  84                 public bool is_keepalive ();
  85                 public void read_request (Soup.Socket sock);
  86                 public void remove_handler (Soup.HandlerPhase phase, Soup.MessageCallbackFn handler_cb);
  87                 public static void remove_header (GLib.HashTable hash, string name);
  88                 public void send_request (Soup.Socket sock, bool is_via_proxy);
  89                 public void set_flags (uint flags);
  90                 public void set_http_version (Soup.HttpVersion version);
  91                 public void set_request (string content_type, Soup.Ownership req_owner, owned string req_body, ulong req_length);
  92                 public void set_response (string content_type, Soup.Ownership resp_owner, owned string resp_body, ulong resp_length);
  93                 public void set_status (uint status_code);
  94                 public void set_status_full (uint status_code, string reason_phrase);
  95                 public void set_uri (Soup.Uri uri);
  96                 [HasEmitter]
  97                 public virtual signal void finished ();
  98                 [HasEmitter]
  99                 public virtual signal void got_body ();
 100                 [HasEmitter]
 101                 public virtual signal void got_chunk ();
 102                 [HasEmitter]
 103                 public virtual signal void got_headers ();
 104                 [HasEmitter]
 105                 public virtual signal void got_informational ();
 106                 [HasEmitter]
 107                 public virtual signal void restarted ();
 108                 [HasEmitter]
 109                 public virtual signal void wrote_body ();
 110                 [HasEmitter]
 111                 public virtual signal void wrote_chunk ();
 112                 [HasEmitter]
 113                 public virtual signal void wrote_headers ();
 114                 [HasEmitter]
 115                 public virtual signal void wrote_informational ();
 116         }
 117         [Compact]
 118         [CCode (free_function = "soup_message_queue_destroy", cheader_filename = "libsoup/soup.h")]
 119         public class MessageQueue {
 120                 [CCode (has_construct_function = false)]
 121                 public MessageQueue ();
 122                 public void append (Soup.Message msg);
 123                 public unowned Soup.Message first (Soup.MessageQueueIter iter);
 124                 public void free_iter (Soup.MessageQueueIter iter);
 125                 public unowned Soup.Message next (Soup.MessageQueueIter iter);
 126                 public unowned Soup.Message remove (Soup.MessageQueueIter iter);
 127                 public void remove_message (Soup.Message msg);
 128         }
 129         [Compact]
 130         [CCode (cheader_filename = "libsoup/soup.h")]
 131         public class MessageQueueIter {
 132                 public weak GLib.List cur;
 133                 public weak GLib.List next;
 134         }
 135         [Compact]
 136         [CCode (cheader_filename = "libsoup/soup.h")]
 137         public class Protocol {
 138         }
 139         [CCode (cheader_filename = "libsoup/soup.h")]
 140         public class Server : GLib.Object {
 141                 [CCode (has_construct_function = false)]
 142                 public Server (string optname1, ...);
 143                 public void add_handler (string path, Soup.ServerAuthContext auth_ctx, Soup.ServerCallbackFn callback, Soup.ServerUnregisterFn unreg, void* data);
 144                 public unowned GLib.MainContext get_async_context ();
 145                 public unowned Soup.ServerHandler get_handler (string path);
 146                 public unowned Soup.Socket get_listener ();
 147                 public uint get_port ();
 148                 public unowned Soup.Protocol get_protocol ();
 149                 public unowned GLib.SList list_handlers ();
 150                 public void quit ();
 151                 public void remove_handler (string path);
 152                 public void run ();
 153                 public void run_async ();
 154                 public void* async_context { get; construct; }
 155                 [NoAccessorMethod]
 156                 public Soup.Address @interface { owned get; construct; }
 157                 public uint port { get; construct; }
 158                 [NoAccessorMethod]
 159                 public string ssl_cert_file { owned get; construct; }
 160                 [NoAccessorMethod]
 161                 public string ssl_key_file { owned get; construct; }
 162         }
 163         [Compact]
 164         [CCode (cheader_filename = "libsoup/soup.h")]
 165         public class ServerAuth {
 166                 public weak Soup.ServerAuthBasic basic;
 167                 public weak Soup.ServerAuthDigest digest;
 168                 public Soup.AuthType type;
 169                 [CCode (has_construct_function = false)]
 170                 public ServerAuth (Soup.ServerAuthContext auth_ctx, GLib.SList auth_hdrs, Soup.Message msg);
 171                 public bool check_passwd (string passwd);
 172                 public unowned string get_user ();
 173         }
 174         [Compact]
 175         [CCode (cheader_filename = "libsoup/soup.h")]
 176         public class ServerAuthBasic {
 177                 public weak string passwd;
 178                 public Soup.AuthType type;
 179                 public weak string user;
 180         }
 181         [Compact]
 182         [CCode (cheader_filename = "libsoup/soup.h")]
 183         public class ServerAuthContext {
 184                 public void* basic_info;
 185                 public weak Soup.ServerAuthCallbackFn callback;
 186                 public void* digest_info;
 187                 public uint types;
 188                 public void* user_data;
 189                 public void challenge (Soup.Message msg, string header_name);
 190         }
 191         [Compact]
 192         [CCode (cheader_filename = "libsoup/soup.h")]
 193         public class ServerAuthDigest {
 194                 public Soup.DigestAlgorithm algorithm;
 195                 public weak string cnonce;
 196                 public weak string digest_response;
 197                 public weak string digest_uri;
 198                 public bool integrity;
 199                 public weak string nonce;
 200                 public int nonce_count;
 201                 public weak string realm;
 202                 public weak string request_method;
 203                 public Soup.AuthType type;
 204                 public weak string user;
 205         }
 206         [Compact]
 207         [CCode (cheader_filename = "libsoup/soup.h")]
 208         public class ServerContext {
 209                 public weak Soup.ServerAuth auth;
 210                 public weak Soup.ServerHandler handler;
 211                 public Soup.MethodId method_id;
 212                 public weak Soup.Message msg;
 213                 public weak string path;
 214                 public weak Soup.Server server;
 215                 public weak Soup.Socket sock;
 216                 public unowned Soup.Address get_client_address ();
 217                 public unowned string get_client_host ();
 218         }
 219         [Compact]
 220         [CCode (cheader_filename = "libsoup/soup.h")]
 221         public class ServerHandler {
 222                 public weak Soup.ServerAuthContext auth_ctx;
 223                 public weak Soup.ServerCallbackFn callback;
 224                 public weak string path;
 225                 public weak Soup.ServerUnregisterFn unregister;
 226                 public void* user_data;
 227         }
 228         [CCode (cheader_filename = "libsoup/soup.h")]
 229         public class ServerMessage : Soup.Message {
 230                 [CCode (has_construct_function = false)]
 231                 public ServerMessage (Soup.Server server);
 232                 public void finish ();
 233                 public Soup.TransferEncoding get_encoding ();
 234                 public unowned Soup.Server get_server ();
 235                 public bool is_finished ();
 236                 public bool is_started ();
 237                 public void set_encoding (Soup.TransferEncoding encoding);
 238                 public void start ();
 239         }
 240         [CCode (cheader_filename = "libsoup/soup.h")]
 241         public class Session : GLib.Object, Soup.MessageFilter {
 242                 public weak Soup.MessageQueue queue;
 243                 [CCode (has_construct_function = false)]
 244                 protected Session ();
 245                 public void abort ();
 246                 public void add_filter (Soup.MessageFilter filter);
 247                 public virtual void cancel_message (Soup.Message msg);
 248                 public unowned GLib.MainContext get_async_context ();
 249                 public unowned Soup.Connection get_connection (Soup.Message msg, bool try_pruning, bool is_new);
 250                 public virtual void queue_message (owned Soup.Message msg, Soup.MessageCallbackFn callback);
 251                 public void remove_filter (Soup.MessageFilter filter);
 252                 public virtual void requeue_message (Soup.Message msg);
 253                 public virtual uint send_message (Soup.Message msg);
 254                 public bool try_prune_connection ();
 255                 public void* async_context { get; construct; }
 256                 [NoAccessorMethod]
 257                 public int max_conns { get; set; }
 258                 [NoAccessorMethod]
 259                 public int max_conns_per_host { get; set; }
 260                 [NoAccessorMethod]
 261                 public void* proxy_uri { get; set; }
 262                 [NoAccessorMethod]
 263                 public string ssl_ca_file { owned get; set; }
 264                 [NoAccessorMethod]
 265                 public uint timeout { get; set; }
 266                 [NoAccessorMethod]
 267                 public bool use_ntlm { get; set; }
 268                 public virtual signal void authenticate (Soup.Message p0, string auth_type, string auth_realm, void* username, void* password);
 269                 public virtual signal void reauthenticate (Soup.Message p0, string auth_type, string auth_realm, void* username, void* password);
 270         }
 271         [CCode (cheader_filename = "libsoup/soup.h")]
 272         public class SessionAsync : Soup.Session, Soup.MessageFilter {
 273                 [CCode (type = "SoupSession*", has_construct_function = false)]
 274                 public SessionAsync ();
 275                 [CCode (type = "SoupSession*", has_construct_function = false)]
 276                 public SessionAsync.with_options (string optname1);
 277         }
 278         [CCode (cheader_filename = "libsoup/soup.h")]
 279         public class SessionSync : Soup.Session, Soup.MessageFilter {
 280                 [CCode (type = "SoupSession*", has_construct_function = false)]
 281                 public SessionSync ();
 282                 [CCode (type = "SoupSession*", has_construct_function = false)]
 283                 public SessionSync.with_options (string optname1);
 284         }
 285         [Compact]
 286         [CCode (cheader_filename = "libsoup/soup.h")]
 287         public class SoapParameter {
 288                 public unowned Soup.SoapParameter get_first_child ();
 289                 public unowned Soup.SoapParameter get_first_child_by_name (string name);
 290                 public int get_int_value ();
 291                 public unowned string get_name ();
 292                 public unowned Soup.SoapParameter get_next_child ();
 293                 public unowned Soup.SoapParameter get_next_child_by_name (string name);
 294                 public unowned string get_property (string prop_name);
 295                 public unowned string get_string_value ();
 296         }
 297         [CCode (cheader_filename = "libsoup/soup.h")]
 298         public class Socket : GLib.Object {
 299                 [CCode (has_construct_function = false)]
 300                 public Socket (string optname1);
 301                 public static unowned Soup.Socket client_new_async (string hostname, uint port, void* ssl_creds, Soup.SocketCallback callback);
 302                 public static unowned Soup.Socket client_new_sync (string hostname, uint port, void* ssl_creds, uint status_ret);
 303                 public uint connect (Soup.Address remote_addr);
 304                 public void disconnect ();
 305                 public unowned Soup.Address get_local_address ();
 306                 public unowned Soup.Address get_remote_address ();
 307                 public bool is_connected ();
 308                 public bool listen (Soup.Address local_addr);
 309                 public Soup.SocketIOStatus read (void* buffer, size_t len, size_t nread);
 310                 public Soup.SocketIOStatus read_until (void* buffer, size_t len, void* boundary, size_t boundary_len, size_t nread, bool got_boundary);
 311                 public static unowned Soup.Socket server_new (Soup.Address local_addr, void* ssl_creds, Soup.SocketListenerCallback callback);
 312                 public bool start_proxy_ssl (string ssl_host);
 313                 public bool start_ssl ();
 314                 public Soup.SocketIOStatus write (void* buffer, size_t len, size_t nwrote);
 315                 [NoAccessorMethod]
 316                 public void* async_context { get; construct; }
 317                 [NoAccessorMethod]
 318                 public bool cloexec { get; set; }
 319                 [NoAccessorMethod]
 320                 public bool is_server { get; }
 321                 [NoAccessorMethod]
 322                 public bool nodelay { get; set; }
 323                 [NoAccessorMethod]
 324                 public bool non_blocking { get; set; }
 325                 [NoAccessorMethod]
 326                 public bool reuseaddr { get; set; }
 327                 [NoAccessorMethod]
 328                 public void* ssl_creds { get; set; }
 329                 [NoAccessorMethod]
 330                 public uint timeout { get; set; }
 331                 public virtual signal void connect_result (int p0);
 332                 public virtual signal void disconnected ();
 333                 public virtual signal void new_connection (Soup.Socket p0);
 334                 public virtual signal void readable ();
 335                 public virtual signal void writable ();
 336         }
 337         [Compact]
 338         [CCode (copy_function = "soup_uri_copy", cheader_filename = "libsoup/soup.h")]
 339         public class Uri {
 340                 public bool broken_encoding;
 341                 public weak string fragment;
 342                 public weak string host;
 343                 public weak string passwd;
 344                 public weak string path;
 345                 public uint port;
 346                 public weak Soup.Protocol protocol;
 347                 public weak string query;
 348                 public weak string user;
 349                 [CCode (has_construct_function = false)]
 350                 public Uri (string uri_string);
 351                 public Soup.Uri copy ();
 352                 public unowned Soup.Uri copy_root ();
 353                 public static void decode (string part);
 354                 public static string encode (string part, string escape_extra);
 355                 public bool equal (Soup.Uri uri2);
 356                 public unowned string to_string (bool just_path);
 357                 public bool uses_default_port ();
 358                 [CCode (has_construct_function = false)]
 359                 public Uri.with_base (Soup.Uri @base, string uri_string);
 360         }
 361         [Compact]
 362         [CCode (cheader_filename = "libsoup/soup.h")]
 363         public class XmlrpcValue {
 364                 public bool array_get_iterator (out unowned Soup.XmlrpcValueArrayIterator iter);
 365                 public void dump ();
 366                 public bool get_base64 (out unowned GLib.ByteArray data);
 367                 public bool get_boolean (bool b);
 368                 public bool get_datetime (ulong timeval);
 369                 public bool get_double (double b);
 370                 public bool get_int (long i);
 371                 public bool get_string (out unowned string str);
 372                 public bool get_struct (GLib.HashTable table);
 373         }
 374         [Compact]
 375         [CCode (cheader_filename = "libsoup/soup.h")]
 376         public class XmlrpcValueArrayIterator {
 377                 public bool get_value (out unowned Soup.XmlrpcValue value);
 378                 public unowned Soup.XmlrpcValueArrayIterator next ();
 379                 public unowned Soup.XmlrpcValueArrayIterator prev ();
 380         }
 381         [CCode (cheader_filename = "libsoup/soup.h")]
 382         public interface MessageFilter {
 383                 public abstract void setup_message (Soup.Message msg);
 384         }
 385         [CCode (type_id = "SOUP_TYPE_DATA_BUFFER", cheader_filename = "libsoup/soup.h")]
 386         public struct DataBuffer {
 387                 public Soup.Ownership owner;
 388                 public string body;
 389                 public uint length;
 390         }
 391         [CCode (cprefix = "SOUP_ADDRESS_FAMILY_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 392         public enum AddressFamily {
 393                 IPV4,
 394                 IPV6
 395         }
 396         [CCode (cprefix = "SOUP_AUTH_TYPE_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 397         public enum AuthType {
 398                 BASIC,
 399                 DIGEST
 400         }
 401         [CCode (cprefix = "SOUP_ALGORITHM_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 402         public enum DigestAlgorithm {
 403                 MD5,
 404                 MD5_SESS
 405         }
 406         [CCode (cprefix = "SOUP_HANDLER_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 407         public enum HandlerPhase {
 408                 POST_REQUEST,
 409                 PRE_BODY,
 410                 BODY_CHUNK,
 411                 POST_BODY
 412         }
 413         [CCode (cprefix = "SOUP_HTTP_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 414         public enum HttpVersion {
 415                 @1_0,
 416                 @1_1
 417         }
 418         [CCode (cprefix = "SOUP_STATUS_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 419         public enum KnownStatusCode {
 420                 NONE,
 421                 CANCELLED,
 422                 CANT_RESOLVE,
 423                 CANT_RESOLVE_PROXY,
 424                 CANT_CONNECT,
 425                 CANT_CONNECT_PROXY,
 426                 SSL_FAILED,
 427                 IO_ERROR,
 428                 MALFORMED,
 429                 TRY_AGAIN,
 430                 CONTINUE,
 431                 SWITCHING_PROTOCOLS,
 432                 PROCESSING,
 433                 OK,
 434                 CREATED,
 435                 ACCEPTED,
 436                 NON_AUTHORITATIVE,
 437                 NO_CONTENT,
 438                 RESET_CONTENT,
 439                 PARTIAL_CONTENT,
 440                 MULTI_STATUS,
 441                 MULTIPLE_CHOICES,
 442                 MOVED_PERMANENTLY,
 443                 FOUND,
 444                 MOVED_TEMPORARILY,
 445                 SEE_OTHER,
 446                 NOT_MODIFIED,
 447                 USE_PROXY,
 448                 NOT_APPEARING_IN_THIS_PROTOCOL,
 449                 TEMPORARY_REDIRECT,
 450                 BAD_REQUEST,
 451                 UNAUTHORIZED,
 452                 PAYMENT_REQUIRED,
 453                 FORBIDDEN,
 454                 NOT_FOUND,
 455                 METHOD_NOT_ALLOWED,
 456                 NOT_ACCEPTABLE,
 457                 PROXY_AUTHENTICATION_REQUIRED,
 458                 PROXY_UNAUTHORIZED,
 459                 REQUEST_TIMEOUT,
 460                 CONFLICT,
 461                 GONE,
 462                 LENGTH_REQUIRED,
 463                 PRECONDITION_FAILED,
 464                 REQUEST_ENTITY_TOO_LARGE,
 465                 REQUEST_URI_TOO_LONG,
 466                 UNSUPPORTED_MEDIA_TYPE,
 467                 REQUESTED_RANGE_NOT_SATISFIABLE,
 468                 INVALID_RANGE,
 469                 EXPECTATION_FAILED,
 470                 UNPROCESSABLE_ENTITY,
 471                 LOCKED,
 472                 FAILED_DEPENDENCY,
 473                 INTERNAL_SERVER_ERROR,
 474                 NOT_IMPLEMENTED,
 475                 BAD_GATEWAY,
 476                 SERVICE_UNAVAILABLE,
 477                 GATEWAY_TIMEOUT,
 478                 HTTP_VERSION_NOT_SUPPORTED,
 479                 INSUFFICIENT_STORAGE,
 480                 NOT_EXTENDED
 481         }
 482         [CCode (cprefix = "SOUP_MESSAGE_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 483         public enum MessageFlags {
 484                 NO_REDIRECT,
 485                 OVERWRITE_CHUNKS,
 486                 EXPECT_CONTINUE
 487         }
 488         [CCode (cprefix = "SOUP_MESSAGE_STATUS_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 489         public enum MessageStatus {
 490                 IDLE,
 491                 QUEUED,
 492                 CONNECTING,
 493                 RUNNING,
 494                 FINISHED
 495         }
 496         [CCode (cprefix = "SOUP_METHOD_ID_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 497         public enum MethodId {
 498                 UNKNOWN,
 499                 POST,
 500                 GET,
 501                 HEAD,
 502                 OPTIONS,
 503                 PUT,
 504                 MOVE,
 505                 COPY,
 506                 DELETE,
 507                 TRACE,
 508                 CONNECT,
 509                 MKCOL,
 510                 PROPPATCH,
 511                 PROPFIND,
 512                 PATCH,
 513                 LOCK,
 514                 UNLOCK
 515         }
 516         [CCode (cprefix = "SOUP_BUFFER_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 517         public enum Ownership {
 518                 SYSTEM_OWNED,
 519                 USER_OWNED,
 520                 STATIC
 521         }
 522         [CCode (cprefix = "SOUP_SOCKET_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 523         public enum SocketIOStatus {
 524                 OK,
 525                 WOULD_BLOCK,
 526                 EOF,
 527                 ERROR
 528         }
 529         [CCode (cprefix = "SOUP_STATUS_CLASS_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 530         public enum StatusClass {
 531                 TRANSPORT_ERROR,
 532                 INFORMATIONAL,
 533                 SUCCESS,
 534                 REDIRECT,
 535                 CLIENT_ERROR,
 536                 SERVER_ERROR
 537         }
 538         [CCode (cprefix = "SOUP_TRANSFER_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 539         public enum TransferEncoding {
 540                 UNKNOWN,
 541                 CHUNKED,
 542                 CONTENT_LENGTH,
 543                 BYTERANGES,
 544                 NONE,
 545                 EOF
 546         }
 547         [CCode (cprefix = "SOUP_XMLRPC_VALUE_TYPE_", has_type_id = false, cheader_filename = "libsoup/soup.h")]
 548         public enum XmlrpcValueType {
 549                 BAD,
 550                 INT,
 551                 BOOLEAN,
 552                 STRING,
 553                 DOUBLE,
 554                 DATETIME,
 555                 BASE64,
 556                 STRUCT,
 557                 ARRAY
 558         }
 559         [CCode (cheader_filename = "libsoup/soup.h")]
 560         public delegate void AddressCallback (Soup.Address addr, uint status);
 561         [CCode (cheader_filename = "libsoup/soup.h")]
 562         public delegate void ConnectionCallback (Soup.Connection conn, uint status);
 563         [CCode (cheader_filename = "libsoup/soup.h")]
 564         public delegate void MessageCallbackFn (Soup.Message req);
 565         [CCode (cheader_filename = "libsoup/soup.h")]
 566         public delegate bool ServerAuthCallbackFn (Soup.ServerAuthContext auth_ctx, Soup.ServerAuth auth, Soup.Message msg);
 567         [CCode (cheader_filename = "libsoup/soup.h")]
 568         public delegate void ServerCallbackFn (Soup.ServerContext context, Soup.Message msg);
 569         [CCode (cheader_filename = "libsoup/soup.h")]
 570         public delegate void ServerUnregisterFn (Soup.Server server, Soup.ServerHandler handler);
 571         [CCode (cheader_filename = "libsoup/soup.h")]
 572         public delegate void SocketCallback (Soup.Socket sock, uint status);
 573         [CCode (cheader_filename = "libsoup/soup.h")]
 574         public delegate void SocketListenerCallback (Soup.Socket listener, Soup.Socket sock);
 575         [CCode (cheader_filename = "libsoup/soup.h")]
 576         public const int ADDRESS_ANY_PORT;
 577         [CCode (cheader_filename = "libsoup/soup.h")]
 578         public const string CONNECTION_ASYNC_CONTEXT;
 579         [CCode (cheader_filename = "libsoup/soup.h")]
 580         public const int CONNECTION_H;
 581         [CCode (cheader_filename = "libsoup/soup.h")]
 582         public const string CONNECTION_MESSAGE_FILTER;
 583         [CCode (cheader_filename = "libsoup/soup.h")]
 584         public const string CONNECTION_ORIGIN_URI;
 585         [CCode (cheader_filename = "libsoup/soup.h")]
 586         public const string CONNECTION_PROXY_URI;
 587         [CCode (cheader_filename = "libsoup/soup.h")]
 588         public const string CONNECTION_SSL_CREDENTIALS;
 589         [CCode (cheader_filename = "libsoup/soup.h")]
 590         public const string CONNECTION_TIMEOUT;
 591         [CCode (cheader_filename = "libsoup/soup.h")]
 592         public const int DATE_H;
 593         [CCode (cheader_filename = "libsoup/soup.h")]
 594         public const int H;
 595         [CCode (cheader_filename = "libsoup/soup.h")]
 596         public const int HEADERS_H;
 597         [CCode (cheader_filename = "libsoup/soup.h")]
 598         public const int MESSAGE_FILTER_H;
 599         [CCode (cheader_filename = "libsoup/soup.h")]
 600         public const int MESSAGE_H;
 601         [CCode (cheader_filename = "libsoup/soup.h")]
 602         public const int MESSAGE_QUEUE_H;
 603         [CCode (cheader_filename = "libsoup/soup.h")]
 604         public const string METHOD_CONNECT;
 605         [CCode (cheader_filename = "libsoup/soup.h")]
 606         public const string METHOD_COPY;
 607         [CCode (cheader_filename = "libsoup/soup.h")]
 608         public const string METHOD_DELETE;
 609         [CCode (cheader_filename = "libsoup/soup.h")]
 610         public const string METHOD_GET;
 611         [CCode (cheader_filename = "libsoup/soup.h")]
 612         public const int METHOD_H;
 613         [CCode (cheader_filename = "libsoup/soup.h")]
 614         public const string METHOD_HEAD;
 615         [CCode (cheader_filename = "libsoup/soup.h")]
 616         public const string METHOD_LOCK;
 617         [CCode (cheader_filename = "libsoup/soup.h")]
 618         public const string METHOD_MKCOL;
 619         [CCode (cheader_filename = "libsoup/soup.h")]
 620         public const string METHOD_MOVE;
 621         [CCode (cheader_filename = "libsoup/soup.h")]
 622         public const string METHOD_OPTIONS;
 623         [CCode (cheader_filename = "libsoup/soup.h")]
 624         public const string METHOD_PATCH;
 625         [CCode (cheader_filename = "libsoup/soup.h")]
 626         public const string METHOD_POST;
 627         [CCode (cheader_filename = "libsoup/soup.h")]
 628         public const string METHOD_PROPFIND;
 629         [CCode (cheader_filename = "libsoup/soup.h")]
 630         public const string METHOD_PROPPATCH;
 631         [CCode (cheader_filename = "libsoup/soup.h")]
 632         public const string METHOD_PUT;
 633         [CCode (cheader_filename = "libsoup/soup.h")]
 634         public const string METHOD_TRACE;
 635         [CCode (cheader_filename = "libsoup/soup.h")]
 636         public const string METHOD_UNLOCK;
 637         [CCode (cheader_filename = "libsoup/soup.h")]
 638         public const int MISC_H;
 639         [CCode (cheader_filename = "libsoup/soup.h")]
 640         public const string SERVER_ASYNC_CONTEXT;
 641         [CCode (cheader_filename = "libsoup/soup.h")]
 642         public const int SERVER_AUTH_H;
 643         [CCode (cheader_filename = "libsoup/soup.h")]
 644         public const int SERVER_H;
 645         [CCode (cheader_filename = "libsoup/soup.h")]
 646         public const string SERVER_INTERFACE;
 647         [CCode (cheader_filename = "libsoup/soup.h")]
 648         public const int SERVER_MESSAGE_H;
 649         [CCode (cheader_filename = "libsoup/soup.h")]
 650         public const string SERVER_PORT;
 651         [CCode (cheader_filename = "libsoup/soup.h")]
 652         public const string SERVER_SSL_CERT_FILE;
 653         [CCode (cheader_filename = "libsoup/soup.h")]
 654         public const string SERVER_SSL_KEY_FILE;
 655         [CCode (cheader_filename = "libsoup/soup.h")]
 656         public const string SESSION_ASYNC_CONTEXT;
 657         [CCode (cheader_filename = "libsoup/soup.h")]
 658         public const int SESSION_ASYNC_H;
 659         [CCode (cheader_filename = "libsoup/soup.h")]
 660         public const int SESSION_H;
 661         [CCode (cheader_filename = "libsoup/soup.h")]
 662         public const string SESSION_MAX_CONNS;
 663         [CCode (cheader_filename = "libsoup/soup.h")]
 664         public const string SESSION_MAX_CONNS_PER_HOST;
 665         [CCode (cheader_filename = "libsoup/soup.h")]
 666         public const string SESSION_PROXY_URI;
 667         [CCode (cheader_filename = "libsoup/soup.h")]
 668         public const string SESSION_SSL_CA_FILE;
 669         [CCode (cheader_filename = "libsoup/soup.h")]
 670         public const int SESSION_SYNC_H;
 671         [CCode (cheader_filename = "libsoup/soup.h")]
 672         public const string SESSION_TIMEOUT;
 673         [CCode (cheader_filename = "libsoup/soup.h")]
 674         public const string SESSION_USE_NTLM;
 675         [CCode (cheader_filename = "libsoup/soup.h")]
 676         public const int SOAP_MESSAGE_H;
 677         [CCode (cheader_filename = "libsoup/soup.h")]
 678         public const string SOCKET_ASYNC_CONTEXT;
 679         [CCode (cheader_filename = "libsoup/soup.h")]
 680         public const string SOCKET_FLAG_CLOEXEC;
 681         [CCode (cheader_filename = "libsoup/soup.h")]
 682         public const string SOCKET_FLAG_NODELAY;
 683         [CCode (cheader_filename = "libsoup/soup.h")]
 684         public const string SOCKET_FLAG_NONBLOCKING;
 685         [CCode (cheader_filename = "libsoup/soup.h")]
 686         public const string SOCKET_FLAG_REUSEADDR;
 687         [CCode (cheader_filename = "libsoup/soup.h")]
 688         public const int SOCKET_H;
 689         [CCode (cheader_filename = "libsoup/soup.h")]
 690         public const string SOCKET_IS_SERVER;
 691         [CCode (cheader_filename = "libsoup/soup.h")]
 692         public const string SOCKET_SSL_CREDENTIALS;
 693         [CCode (cheader_filename = "libsoup/soup.h")]
 694         public const string SOCKET_TIMEOUT;
 695         [CCode (cheader_filename = "libsoup/soup.h")]
 696         public const int STATUS_H;
 697         [CCode (cheader_filename = "libsoup/soup.h")]
 698         public const int TYPES_H;
 699         [CCode (cheader_filename = "libsoup/soup.h")]
 700         public const int URI_H;
 701         [CCode (cheader_filename = "libsoup/soup.h")]
 702         public static unowned GLib.TimeoutSource add_idle (GLib.MainContext async_context, GLib.SourceFunc function, void* data);
 703         [CCode (cheader_filename = "libsoup/soup.h")]
 704         public static unowned GLib.TimeoutSource add_timeout (GLib.MainContext async_context, uint interval, GLib.SourceFunc function, void* data);
 705         [CCode (cheader_filename = "libsoup/soup.h")]
 706         public static unowned string base64_decode (string text, int out_len);
 707         [CCode (cheader_filename = "libsoup/soup.h")]
 708         public static int base64_decode_step (uchar[] @in, int len, uchar[] @out, int state, uint save);
 709         [CCode (cheader_filename = "libsoup/soup.h")]
 710         public static unowned string base64_encode (string text, int len);
 711         [CCode (cheader_filename = "libsoup/soup.h")]
 712         public static int base64_encode_close (uchar[] @in, int inlen, bool break_lines, uchar[] @out, int state, int save);
 713         [CCode (cheader_filename = "libsoup/soup.h")]
 714         public static int base64_encode_step (uchar[] @in, int len, bool break_lines, uchar[] @out, int state, int save);
 715         [CCode (cheader_filename = "libsoup/soup.h")]
 716         public static unowned string date_generate (ulong when);
 717         [CCode (cheader_filename = "libsoup/soup.h")]
 718         public static ulong date_iso8601_parse (string timestamp);
 719         [CCode (cheader_filename = "libsoup/soup.h")]
 720         public static ulong date_parse (string timestamp);
 721         [CCode (cheader_filename = "libsoup/soup.h")]
 722         public static void gmtime (ulong when, void* tm);
 723         [CCode (cheader_filename = "libsoup/soup.h")]
 724         public static unowned string header_param_copy_token (GLib.HashTable tokens, string t);
 725         [CCode (cheader_filename = "libsoup/soup.h")]
 726         public static unowned string header_param_decode_token (out unowned string @in);
 727         [CCode (cheader_filename = "libsoup/soup.h")]
 728         public static void header_param_destroy_hash (GLib.HashTable table);
 729         [CCode (cheader_filename = "libsoup/soup.h")]
 730         public static unowned GLib.HashTable header_param_parse_list (string header);
 731         [CCode (cheader_filename = "libsoup/soup.h")]
 732         public static bool headers_parse_request (string str, int len, GLib.HashTable dest, out unowned string req_method, out unowned string req_path, Soup.HttpVersion ver);
 733         [CCode (cheader_filename = "libsoup/soup.h")]
 734         public static bool headers_parse_response (string str, int len, GLib.HashTable dest, Soup.HttpVersion ver, uint status_code, out unowned string reason_phrase);
 735         [CCode (cheader_filename = "libsoup/soup.h")]
 736         public static bool headers_parse_status_line (string status_line, Soup.HttpVersion ver, uint status_code, out unowned string reason_phrase);
 737         [CCode (cheader_filename = "libsoup/soup.h")]
 738         public static Soup.MethodId method_get_id (string method);
 739         [CCode (cheader_filename = "libsoup/soup.h")]
 740         public static uint signal_connect_once (void* instance, string detailed_signal, GLib.Callback c_handler, void* data);
 741         [CCode (cheader_filename = "libsoup/soup.h")]
 742         public static unowned string status_get_phrase (uint status_code);
 743         [CCode (cheader_filename = "libsoup/soup.h")]
 744         public static bool str_case_equal (void* v1, void* v2);
 745         [CCode (cheader_filename = "libsoup/soup.h")]
 746         public static uint str_case_hash (void* key);
 747 }