1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal, clippy::upper_case_acronyms)]
8#![cfg_attr(docsrs, feature(doc_cfg))]
9
10use glib_sys as glib;
11use gobject_sys as gobject;
12use gio_sys as gio;
13
14#[allow(unused_imports)]
15use std::ffi::{c_int, c_char, c_uchar, c_float, c_uint, c_double,
16 c_short, c_ushort, c_long, c_ulong, c_void};
17#[allow(unused_imports)]
18use libc::{size_t, ssize_t, time_t, off_t, intptr_t, uintptr_t, FILE};
19#[cfg(unix)]
20#[allow(unused_imports)]
21use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
22
23#[allow(unused_imports)]
24use glib::{gboolean, gconstpointer, gpointer, GType};
25
26pub type SoupCacheType = c_int;
28pub const SOUP_CACHE_SINGLE_USER: SoupCacheType = 0;
29pub const SOUP_CACHE_SHARED: SoupCacheType = 1;
30
31pub type SoupCookieJarAcceptPolicy = c_int;
32pub const SOUP_COOKIE_JAR_ACCEPT_ALWAYS: SoupCookieJarAcceptPolicy = 0;
33pub const SOUP_COOKIE_JAR_ACCEPT_NEVER: SoupCookieJarAcceptPolicy = 1;
34pub const SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY: SoupCookieJarAcceptPolicy = 2;
35pub const SOUP_COOKIE_JAR_ACCEPT_GRANDFATHERED_THIRD_PARTY: SoupCookieJarAcceptPolicy = 3;
36
37pub type SoupDateFormat = c_int;
38pub const SOUP_DATE_HTTP: SoupDateFormat = 1;
39pub const SOUP_DATE_COOKIE: SoupDateFormat = 2;
40
41pub type SoupEncoding = c_int;
42pub const SOUP_ENCODING_UNRECOGNIZED: SoupEncoding = 0;
43pub const SOUP_ENCODING_NONE: SoupEncoding = 1;
44pub const SOUP_ENCODING_CONTENT_LENGTH: SoupEncoding = 2;
45pub const SOUP_ENCODING_EOF: SoupEncoding = 3;
46pub const SOUP_ENCODING_CHUNKED: SoupEncoding = 4;
47pub const SOUP_ENCODING_BYTERANGES: SoupEncoding = 5;
48
49pub type SoupHTTPVersion = c_int;
50pub const SOUP_HTTP_1_0: SoupHTTPVersion = 0;
51pub const SOUP_HTTP_1_1: SoupHTTPVersion = 1;
52pub const SOUP_HTTP_2_0: SoupHTTPVersion = 2;
53
54pub type SoupLoggerLogLevel = c_int;
55pub const SOUP_LOGGER_LOG_NONE: SoupLoggerLogLevel = 0;
56pub const SOUP_LOGGER_LOG_MINIMAL: SoupLoggerLogLevel = 1;
57pub const SOUP_LOGGER_LOG_HEADERS: SoupLoggerLogLevel = 2;
58pub const SOUP_LOGGER_LOG_BODY: SoupLoggerLogLevel = 3;
59
60pub type SoupMemoryUse = c_int;
61pub const SOUP_MEMORY_STATIC: SoupMemoryUse = 0;
62pub const SOUP_MEMORY_TAKE: SoupMemoryUse = 1;
63pub const SOUP_MEMORY_COPY: SoupMemoryUse = 2;
64
65pub type SoupMessageHeadersType = c_int;
66pub const SOUP_MESSAGE_HEADERS_REQUEST: SoupMessageHeadersType = 0;
67pub const SOUP_MESSAGE_HEADERS_RESPONSE: SoupMessageHeadersType = 1;
68pub const SOUP_MESSAGE_HEADERS_MULTIPART: SoupMessageHeadersType = 2;
69
70pub type SoupMessagePriority = c_int;
71pub const SOUP_MESSAGE_PRIORITY_VERY_LOW: SoupMessagePriority = 0;
72pub const SOUP_MESSAGE_PRIORITY_LOW: SoupMessagePriority = 1;
73pub const SOUP_MESSAGE_PRIORITY_NORMAL: SoupMessagePriority = 2;
74pub const SOUP_MESSAGE_PRIORITY_HIGH: SoupMessagePriority = 3;
75pub const SOUP_MESSAGE_PRIORITY_VERY_HIGH: SoupMessagePriority = 4;
76
77pub type SoupSameSitePolicy = c_int;
78pub const SOUP_SAME_SITE_POLICY_NONE: SoupSameSitePolicy = 0;
79pub const SOUP_SAME_SITE_POLICY_LAX: SoupSameSitePolicy = 1;
80pub const SOUP_SAME_SITE_POLICY_STRICT: SoupSameSitePolicy = 2;
81
82pub type SoupSessionError = c_int;
83pub const SOUP_SESSION_ERROR_PARSING: SoupSessionError = 0;
84pub const SOUP_SESSION_ERROR_ENCODING: SoupSessionError = 1;
85pub const SOUP_SESSION_ERROR_TOO_MANY_REDIRECTS: SoupSessionError = 2;
86pub const SOUP_SESSION_ERROR_TOO_MANY_RESTARTS: SoupSessionError = 3;
87pub const SOUP_SESSION_ERROR_REDIRECT_NO_LOCATION: SoupSessionError = 4;
88pub const SOUP_SESSION_ERROR_REDIRECT_BAD_URI: SoupSessionError = 5;
89pub const SOUP_SESSION_ERROR_MESSAGE_ALREADY_IN_QUEUE: SoupSessionError = 6;
90
91pub type SoupStatus = c_int;
92pub const SOUP_STATUS_NONE: SoupStatus = 0;
93pub const SOUP_STATUS_CONTINUE: SoupStatus = 100;
94pub const SOUP_STATUS_SWITCHING_PROTOCOLS: SoupStatus = 101;
95pub const SOUP_STATUS_PROCESSING: SoupStatus = 102;
96pub const SOUP_STATUS_OK: SoupStatus = 200;
97pub const SOUP_STATUS_CREATED: SoupStatus = 201;
98pub const SOUP_STATUS_ACCEPTED: SoupStatus = 202;
99pub const SOUP_STATUS_NON_AUTHORITATIVE: SoupStatus = 203;
100pub const SOUP_STATUS_NO_CONTENT: SoupStatus = 204;
101pub const SOUP_STATUS_RESET_CONTENT: SoupStatus = 205;
102pub const SOUP_STATUS_PARTIAL_CONTENT: SoupStatus = 206;
103pub const SOUP_STATUS_MULTI_STATUS: SoupStatus = 207;
104pub const SOUP_STATUS_MULTIPLE_CHOICES: SoupStatus = 300;
105pub const SOUP_STATUS_MOVED_PERMANENTLY: SoupStatus = 301;
106pub const SOUP_STATUS_FOUND: SoupStatus = 302;
107pub const SOUP_STATUS_MOVED_TEMPORARILY: SoupStatus = 302;
108pub const SOUP_STATUS_SEE_OTHER: SoupStatus = 303;
109pub const SOUP_STATUS_NOT_MODIFIED: SoupStatus = 304;
110pub const SOUP_STATUS_USE_PROXY: SoupStatus = 305;
111pub const SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL: SoupStatus = 306;
112pub const SOUP_STATUS_TEMPORARY_REDIRECT: SoupStatus = 307;
113pub const SOUP_STATUS_PERMANENT_REDIRECT: SoupStatus = 308;
114pub const SOUP_STATUS_BAD_REQUEST: SoupStatus = 400;
115pub const SOUP_STATUS_UNAUTHORIZED: SoupStatus = 401;
116pub const SOUP_STATUS_PAYMENT_REQUIRED: SoupStatus = 402;
117pub const SOUP_STATUS_FORBIDDEN: SoupStatus = 403;
118pub const SOUP_STATUS_NOT_FOUND: SoupStatus = 404;
119pub const SOUP_STATUS_METHOD_NOT_ALLOWED: SoupStatus = 405;
120pub const SOUP_STATUS_NOT_ACCEPTABLE: SoupStatus = 406;
121pub const SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED: SoupStatus = 407;
122pub const SOUP_STATUS_PROXY_UNAUTHORIZED: SoupStatus = 407;
123pub const SOUP_STATUS_REQUEST_TIMEOUT: SoupStatus = 408;
124pub const SOUP_STATUS_CONFLICT: SoupStatus = 409;
125pub const SOUP_STATUS_GONE: SoupStatus = 410;
126pub const SOUP_STATUS_LENGTH_REQUIRED: SoupStatus = 411;
127pub const SOUP_STATUS_PRECONDITION_FAILED: SoupStatus = 412;
128pub const SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE: SoupStatus = 413;
129pub const SOUP_STATUS_REQUEST_URI_TOO_LONG: SoupStatus = 414;
130pub const SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE: SoupStatus = 415;
131pub const SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE: SoupStatus = 416;
132pub const SOUP_STATUS_INVALID_RANGE: SoupStatus = 416;
133pub const SOUP_STATUS_EXPECTATION_FAILED: SoupStatus = 417;
134pub const SOUP_STATUS_MISDIRECTED_REQUEST: SoupStatus = 421;
135pub const SOUP_STATUS_UNPROCESSABLE_ENTITY: SoupStatus = 422;
136pub const SOUP_STATUS_LOCKED: SoupStatus = 423;
137pub const SOUP_STATUS_FAILED_DEPENDENCY: SoupStatus = 424;
138pub const SOUP_STATUS_INTERNAL_SERVER_ERROR: SoupStatus = 500;
139pub const SOUP_STATUS_NOT_IMPLEMENTED: SoupStatus = 501;
140pub const SOUP_STATUS_BAD_GATEWAY: SoupStatus = 502;
141pub const SOUP_STATUS_SERVICE_UNAVAILABLE: SoupStatus = 503;
142pub const SOUP_STATUS_GATEWAY_TIMEOUT: SoupStatus = 504;
143pub const SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED: SoupStatus = 505;
144pub const SOUP_STATUS_INSUFFICIENT_STORAGE: SoupStatus = 507;
145pub const SOUP_STATUS_NOT_EXTENDED: SoupStatus = 510;
146
147pub type SoupTLDError = c_int;
148pub const SOUP_TLD_ERROR_INVALID_HOSTNAME: SoupTLDError = 0;
149pub const SOUP_TLD_ERROR_IS_IP_ADDRESS: SoupTLDError = 1;
150pub const SOUP_TLD_ERROR_NOT_ENOUGH_DOMAINS: SoupTLDError = 2;
151pub const SOUP_TLD_ERROR_NO_BASE_DOMAIN: SoupTLDError = 3;
152pub const SOUP_TLD_ERROR_NO_PSL_DATA: SoupTLDError = 4;
153
154pub type SoupURIComponent = c_int;
155pub const SOUP_URI_NONE: SoupURIComponent = 0;
156pub const SOUP_URI_SCHEME: SoupURIComponent = 1;
157pub const SOUP_URI_USER: SoupURIComponent = 2;
158pub const SOUP_URI_PASSWORD: SoupURIComponent = 3;
159pub const SOUP_URI_AUTH_PARAMS: SoupURIComponent = 4;
160pub const SOUP_URI_HOST: SoupURIComponent = 5;
161pub const SOUP_URI_PORT: SoupURIComponent = 6;
162pub const SOUP_URI_PATH: SoupURIComponent = 7;
163pub const SOUP_URI_QUERY: SoupURIComponent = 8;
164pub const SOUP_URI_FRAGMENT: SoupURIComponent = 9;
165
166pub type SoupWebsocketCloseCode = c_int;
167pub const SOUP_WEBSOCKET_CLOSE_NORMAL: SoupWebsocketCloseCode = 1000;
168pub const SOUP_WEBSOCKET_CLOSE_GOING_AWAY: SoupWebsocketCloseCode = 1001;
169pub const SOUP_WEBSOCKET_CLOSE_PROTOCOL_ERROR: SoupWebsocketCloseCode = 1002;
170pub const SOUP_WEBSOCKET_CLOSE_UNSUPPORTED_DATA: SoupWebsocketCloseCode = 1003;
171pub const SOUP_WEBSOCKET_CLOSE_NO_STATUS: SoupWebsocketCloseCode = 1005;
172pub const SOUP_WEBSOCKET_CLOSE_ABNORMAL: SoupWebsocketCloseCode = 1006;
173pub const SOUP_WEBSOCKET_CLOSE_BAD_DATA: SoupWebsocketCloseCode = 1007;
174pub const SOUP_WEBSOCKET_CLOSE_POLICY_VIOLATION: SoupWebsocketCloseCode = 1008;
175pub const SOUP_WEBSOCKET_CLOSE_TOO_BIG: SoupWebsocketCloseCode = 1009;
176pub const SOUP_WEBSOCKET_CLOSE_NO_EXTENSION: SoupWebsocketCloseCode = 1010;
177pub const SOUP_WEBSOCKET_CLOSE_SERVER_ERROR: SoupWebsocketCloseCode = 1011;
178pub const SOUP_WEBSOCKET_CLOSE_TLS_HANDSHAKE: SoupWebsocketCloseCode = 1015;
179
180pub type SoupWebsocketConnectionType = c_int;
181pub const SOUP_WEBSOCKET_CONNECTION_UNKNOWN: SoupWebsocketConnectionType = 0;
182pub const SOUP_WEBSOCKET_CONNECTION_CLIENT: SoupWebsocketConnectionType = 1;
183pub const SOUP_WEBSOCKET_CONNECTION_SERVER: SoupWebsocketConnectionType = 2;
184
185pub type SoupWebsocketDataType = c_int;
186pub const SOUP_WEBSOCKET_DATA_TEXT: SoupWebsocketDataType = 1;
187pub const SOUP_WEBSOCKET_DATA_BINARY: SoupWebsocketDataType = 2;
188
189pub type SoupWebsocketError = c_int;
190pub const SOUP_WEBSOCKET_ERROR_FAILED: SoupWebsocketError = 0;
191pub const SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET: SoupWebsocketError = 1;
192pub const SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE: SoupWebsocketError = 2;
193pub const SOUP_WEBSOCKET_ERROR_BAD_ORIGIN: SoupWebsocketError = 3;
194
195pub type SoupWebsocketState = c_int;
196pub const SOUP_WEBSOCKET_STATE_OPEN: SoupWebsocketState = 1;
197pub const SOUP_WEBSOCKET_STATE_CLOSING: SoupWebsocketState = 2;
198pub const SOUP_WEBSOCKET_STATE_CLOSED: SoupWebsocketState = 3;
199
200pub const SOUP_COOKIE_MAX_AGE_ONE_DAY: c_int = 0;
202pub const SOUP_COOKIE_MAX_AGE_ONE_HOUR: c_int = 3600;
203pub const SOUP_COOKIE_MAX_AGE_ONE_WEEK: c_int = 0;
204pub const SOUP_COOKIE_MAX_AGE_ONE_YEAR: c_int = 0;
205pub const SOUP_FORM_MIME_TYPE_MULTIPART: &[u8] = b"multipart/form-data\0";
206pub const SOUP_FORM_MIME_TYPE_URLENCODED: &[u8] = b"application/x-www-form-urlencoded\0";
207pub const SOUP_HSTS_POLICY_MAX_AGE_PAST: c_int = 0;
208pub const SOUP_HTTP_URI_FLAGS: c_int = 482;
209
210pub type SoupCacheability = c_uint;
212pub const SOUP_CACHE_CACHEABLE: SoupCacheability = 1;
213pub const SOUP_CACHE_UNCACHEABLE: SoupCacheability = 2;
214pub const SOUP_CACHE_INVALIDATES: SoupCacheability = 4;
215pub const SOUP_CACHE_VALIDATES: SoupCacheability = 8;
216
217pub type SoupExpectation = c_uint;
218pub const SOUP_EXPECTATION_UNRECOGNIZED: SoupExpectation = 1;
219pub const SOUP_EXPECTATION_CONTINUE: SoupExpectation = 2;
220
221pub type SoupMessageFlags = c_uint;
222pub const SOUP_MESSAGE_NO_REDIRECT: SoupMessageFlags = 2;
223pub const SOUP_MESSAGE_NEW_CONNECTION: SoupMessageFlags = 4;
224pub const SOUP_MESSAGE_IDEMPOTENT: SoupMessageFlags = 8;
225pub const SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE: SoupMessageFlags = 16;
226pub const SOUP_MESSAGE_COLLECT_METRICS: SoupMessageFlags = 32;
227
228pub type SoupServerListenOptions = c_uint;
229pub const SOUP_SERVER_LISTEN_HTTPS: SoupServerListenOptions = 1;
230pub const SOUP_SERVER_LISTEN_IPV4_ONLY: SoupServerListenOptions = 2;
231pub const SOUP_SERVER_LISTEN_IPV6_ONLY: SoupServerListenOptions = 4;
232
233pub type SoupAuthDomainBasicAuthCallback = Option<unsafe extern "C" fn(*mut SoupAuthDomainBasic, *mut SoupServerMessage, *const c_char, *const c_char, gpointer) -> gboolean>;
235pub type SoupAuthDomainDigestAuthCallback = Option<unsafe extern "C" fn(*mut SoupAuthDomainDigest, *mut SoupServerMessage, *const c_char, gpointer) -> *mut c_char>;
236pub type SoupAuthDomainFilter = Option<unsafe extern "C" fn(*mut SoupAuthDomain, *mut SoupServerMessage, gpointer) -> gboolean>;
237pub type SoupAuthDomainGenericAuthCallback = Option<unsafe extern "C" fn(*mut SoupAuthDomain, *mut SoupServerMessage, *const c_char, gpointer) -> gboolean>;
238pub type SoupLoggerFilter = Option<unsafe extern "C" fn(*mut SoupLogger, *mut SoupMessage, gpointer) -> SoupLoggerLogLevel>;
239pub type SoupLoggerPrinter = Option<unsafe extern "C" fn(*mut SoupLogger, SoupLoggerLogLevel, c_char, *const c_char, gpointer)>;
240pub type SoupMessageHeadersForeachFunc = Option<unsafe extern "C" fn(*const c_char, *const c_char, gpointer)>;
241pub type SoupServerCallback = Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage, *const c_char, *mut glib::GHashTable, gpointer)>;
242pub type SoupServerWebsocketCallback = Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage, *const c_char, *mut SoupWebsocketConnection, gpointer)>;
243
244#[derive(Copy, Clone)]
246#[repr(C)]
247pub struct SoupAuthClass {
248 pub parent_class: gobject::GObjectClass,
249 pub scheme_name: *const c_char,
250 pub strength: c_uint,
251 pub update: Option<unsafe extern "C" fn(*mut SoupAuth, *mut SoupMessage, *mut glib::GHashTable) -> gboolean>,
252 pub get_protection_space: Option<unsafe extern "C" fn(*mut SoupAuth, *mut glib::GUri) -> *mut glib::GSList>,
253 pub authenticate: Option<unsafe extern "C" fn(*mut SoupAuth, *const c_char, *const c_char)>,
254 pub is_authenticated: Option<unsafe extern "C" fn(*mut SoupAuth) -> gboolean>,
255 pub get_authorization: Option<unsafe extern "C" fn(*mut SoupAuth, *mut SoupMessage) -> *mut c_char>,
256 pub is_ready: Option<unsafe extern "C" fn(*mut SoupAuth, *mut SoupMessage) -> gboolean>,
257 pub can_authenticate: Option<unsafe extern "C" fn(*mut SoupAuth) -> gboolean>,
258 pub padding: [gpointer; 6],
259}
260
261impl ::std::fmt::Debug for SoupAuthClass {
262 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
263 f.debug_struct(&format!("SoupAuthClass @ {self:p}"))
264 .field("parent_class", &self.parent_class)
265 .field("scheme_name", &self.scheme_name)
266 .field("strength", &self.strength)
267 .field("update", &self.update)
268 .field("get_protection_space", &self.get_protection_space)
269 .field("authenticate", &self.authenticate)
270 .field("is_authenticated", &self.is_authenticated)
271 .field("get_authorization", &self.get_authorization)
272 .field("is_ready", &self.is_ready)
273 .field("can_authenticate", &self.can_authenticate)
274 .field("padding", &self.padding)
275 .finish()
276 }
277}
278
279#[derive(Copy, Clone)]
280#[repr(C)]
281pub struct SoupAuthDomainBasicClass {
282 pub parent_class: SoupAuthDomainClass,
283}
284
285impl ::std::fmt::Debug for SoupAuthDomainBasicClass {
286 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
287 f.debug_struct(&format!("SoupAuthDomainBasicClass @ {self:p}"))
288 .field("parent_class", &self.parent_class)
289 .finish()
290 }
291}
292
293#[derive(Copy, Clone)]
294#[repr(C)]
295pub struct SoupAuthDomainClass {
296 pub parent_class: gobject::GObjectClass,
297 pub accepts: Option<unsafe extern "C" fn(*mut SoupAuthDomain, *mut SoupServerMessage, *const c_char) -> *mut c_char>,
298 pub challenge: Option<unsafe extern "C" fn(*mut SoupAuthDomain, *mut SoupServerMessage) -> *mut c_char>,
299 pub check_password: Option<unsafe extern "C" fn(*mut SoupAuthDomain, *mut SoupServerMessage, *const c_char, *const c_char) -> gboolean>,
300 pub padding: [gpointer; 6],
301}
302
303impl ::std::fmt::Debug for SoupAuthDomainClass {
304 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
305 f.debug_struct(&format!("SoupAuthDomainClass @ {self:p}"))
306 .field("parent_class", &self.parent_class)
307 .field("accepts", &self.accepts)
308 .field("challenge", &self.challenge)
309 .field("check_password", &self.check_password)
310 .field("padding", &self.padding)
311 .finish()
312 }
313}
314
315#[derive(Copy, Clone)]
316#[repr(C)]
317pub struct SoupAuthDomainDigestClass {
318 pub parent_class: SoupAuthDomainClass,
319}
320
321impl ::std::fmt::Debug for SoupAuthDomainDigestClass {
322 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
323 f.debug_struct(&format!("SoupAuthDomainDigestClass @ {self:p}"))
324 .field("parent_class", &self.parent_class)
325 .finish()
326 }
327}
328
329#[derive(Copy, Clone)]
330#[repr(C)]
331pub struct SoupAuthManagerClass {
332 pub parent_class: gobject::GObjectClass,
333}
334
335impl ::std::fmt::Debug for SoupAuthManagerClass {
336 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
337 f.debug_struct(&format!("SoupAuthManagerClass @ {self:p}"))
338 .field("parent_class", &self.parent_class)
339 .finish()
340 }
341}
342
343#[derive(Copy, Clone)]
344#[repr(C)]
345pub struct SoupCacheClass {
346 pub parent_class: gobject::GObjectClass,
347 pub get_cacheability: Option<unsafe extern "C" fn(*mut SoupCache, *mut SoupMessage) -> SoupCacheability>,
348 pub padding: [gpointer; 4],
349}
350
351impl ::std::fmt::Debug for SoupCacheClass {
352 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
353 f.debug_struct(&format!("SoupCacheClass @ {self:p}"))
354 .field("parent_class", &self.parent_class)
355 .field("get_cacheability", &self.get_cacheability)
356 .field("padding", &self.padding)
357 .finish()
358 }
359}
360
361#[derive(Copy, Clone)]
362#[repr(C)]
363pub struct SoupContentDecoderClass {
364 pub parent_class: gobject::GObjectClass,
365}
366
367impl ::std::fmt::Debug for SoupContentDecoderClass {
368 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
369 f.debug_struct(&format!("SoupContentDecoderClass @ {self:p}"))
370 .field("parent_class", &self.parent_class)
371 .finish()
372 }
373}
374
375#[derive(Copy, Clone)]
376#[repr(C)]
377pub struct SoupContentSnifferClass {
378 pub parent_class: gobject::GObjectClass,
379}
380
381impl ::std::fmt::Debug for SoupContentSnifferClass {
382 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
383 f.debug_struct(&format!("SoupContentSnifferClass @ {self:p}"))
384 .field("parent_class", &self.parent_class)
385 .finish()
386 }
387}
388
389#[repr(C)]
390#[allow(dead_code)]
391pub struct SoupCookie {
392 _data: [u8; 0],
393 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
394}
395
396impl ::std::fmt::Debug for SoupCookie {
397 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
398 f.debug_struct(&format!("SoupCookie @ {self:p}"))
399 .finish()
400 }
401}
402
403#[derive(Copy, Clone)]
404#[repr(C)]
405pub struct SoupCookieJarClass {
406 pub parent_class: gobject::GObjectClass,
407 pub save: Option<unsafe extern "C" fn(*mut SoupCookieJar)>,
408 pub is_persistent: Option<unsafe extern "C" fn(*mut SoupCookieJar) -> gboolean>,
409 pub changed: Option<unsafe extern "C" fn(*mut SoupCookieJar, *mut SoupCookie, *mut SoupCookie)>,
410 pub padding: [gpointer; 6],
411}
412
413impl ::std::fmt::Debug for SoupCookieJarClass {
414 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
415 f.debug_struct(&format!("SoupCookieJarClass @ {self:p}"))
416 .field("parent_class", &self.parent_class)
417 .field("save", &self.save)
418 .field("is_persistent", &self.is_persistent)
419 .field("changed", &self.changed)
420 .field("padding", &self.padding)
421 .finish()
422 }
423}
424
425#[derive(Copy, Clone)]
426#[repr(C)]
427pub struct SoupCookieJarDBClass {
428 pub parent_class: SoupCookieJarClass,
429}
430
431impl ::std::fmt::Debug for SoupCookieJarDBClass {
432 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
433 f.debug_struct(&format!("SoupCookieJarDBClass @ {self:p}"))
434 .field("parent_class", &self.parent_class)
435 .finish()
436 }
437}
438
439#[derive(Copy, Clone)]
440#[repr(C)]
441pub struct SoupCookieJarTextClass {
442 pub parent_class: SoupCookieJarClass,
443}
444
445impl ::std::fmt::Debug for SoupCookieJarTextClass {
446 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
447 f.debug_struct(&format!("SoupCookieJarTextClass @ {self:p}"))
448 .field("parent_class", &self.parent_class)
449 .finish()
450 }
451}
452
453#[derive(Copy, Clone)]
454#[repr(C)]
455pub struct SoupHSTSEnforcerClass {
456 pub parent_class: gobject::GObjectClass,
457 pub is_persistent: Option<unsafe extern "C" fn(*mut SoupHSTSEnforcer) -> gboolean>,
458 pub has_valid_policy: Option<unsafe extern "C" fn(*mut SoupHSTSEnforcer, *const c_char) -> gboolean>,
459 pub changed: Option<unsafe extern "C" fn(*mut SoupHSTSEnforcer, *mut SoupHSTSPolicy, *mut SoupHSTSPolicy)>,
460 pub padding: [gpointer; 4],
461}
462
463impl ::std::fmt::Debug for SoupHSTSEnforcerClass {
464 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
465 f.debug_struct(&format!("SoupHSTSEnforcerClass @ {self:p}"))
466 .field("parent_class", &self.parent_class)
467 .field("is_persistent", &self.is_persistent)
468 .field("has_valid_policy", &self.has_valid_policy)
469 .field("changed", &self.changed)
470 .finish()
471 }
472}
473
474#[derive(Copy, Clone)]
475#[repr(C)]
476pub struct SoupHSTSEnforcerDBClass {
477 pub parent_class: SoupHSTSEnforcerClass,
478}
479
480impl ::std::fmt::Debug for SoupHSTSEnforcerDBClass {
481 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
482 f.debug_struct(&format!("SoupHSTSEnforcerDBClass @ {self:p}"))
483 .field("parent_class", &self.parent_class)
484 .finish()
485 }
486}
487
488#[repr(C)]
489#[allow(dead_code)]
490pub struct SoupHSTSPolicy {
491 _data: [u8; 0],
492 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
493}
494
495impl ::std::fmt::Debug for SoupHSTSPolicy {
496 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
497 f.debug_struct(&format!("SoupHSTSPolicy @ {self:p}"))
498 .finish()
499 }
500}
501
502#[derive(Copy, Clone)]
503#[repr(C)]
504pub struct SoupLoggerClass {
505 pub parent_class: gobject::GObjectClass,
506}
507
508impl ::std::fmt::Debug for SoupLoggerClass {
509 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
510 f.debug_struct(&format!("SoupLoggerClass @ {self:p}"))
511 .field("parent_class", &self.parent_class)
512 .finish()
513 }
514}
515
516#[derive(Copy, Clone)]
517#[repr(C)]
518pub struct SoupMessageBody {
519 pub data: *const u8,
520 pub length: i64,
521}
522
523impl ::std::fmt::Debug for SoupMessageBody {
524 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
525 f.debug_struct(&format!("SoupMessageBody @ {self:p}"))
526 .field("data", &self.data)
527 .field("length", &self.length)
528 .finish()
529 }
530}
531
532#[derive(Copy, Clone)]
533#[repr(C)]
534pub struct SoupMessageClass {
535 pub parent_class: gobject::GObjectClass,
536}
537
538impl ::std::fmt::Debug for SoupMessageClass {
539 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
540 f.debug_struct(&format!("SoupMessageClass @ {self:p}"))
541 .field("parent_class", &self.parent_class)
542 .finish()
543 }
544}
545
546#[repr(C)]
547#[allow(dead_code)]
548pub struct SoupMessageHeaders {
549 _data: [u8; 0],
550 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
551}
552
553impl ::std::fmt::Debug for SoupMessageHeaders {
554 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
555 f.debug_struct(&format!("SoupMessageHeaders @ {self:p}"))
556 .finish()
557 }
558}
559
560#[derive(Copy, Clone)]
561#[repr(C)]
562pub struct SoupMessageHeadersIter {
563 pub dummy: [gpointer; 3],
564}
565
566impl ::std::fmt::Debug for SoupMessageHeadersIter {
567 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
568 f.debug_struct(&format!("SoupMessageHeadersIter @ {self:p}"))
569 .finish()
570 }
571}
572
573#[repr(C)]
574#[allow(dead_code)]
575pub struct SoupMessageMetrics {
576 _data: [u8; 0],
577 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
578}
579
580impl ::std::fmt::Debug for SoupMessageMetrics {
581 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
582 f.debug_struct(&format!("SoupMessageMetrics @ {self:p}"))
583 .finish()
584 }
585}
586
587#[repr(C)]
588#[allow(dead_code)]
589pub struct SoupMultipart {
590 _data: [u8; 0],
591 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
592}
593
594impl ::std::fmt::Debug for SoupMultipart {
595 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
596 f.debug_struct(&format!("SoupMultipart @ {self:p}"))
597 .finish()
598 }
599}
600
601#[derive(Copy, Clone)]
602#[repr(C)]
603pub struct SoupMultipartInputStreamClass {
604 pub parent_class: gio::GFilterInputStreamClass,
605}
606
607impl ::std::fmt::Debug for SoupMultipartInputStreamClass {
608 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
609 f.debug_struct(&format!("SoupMultipartInputStreamClass @ {self:p}"))
610 .field("parent_class", &self.parent_class)
611 .finish()
612 }
613}
614
615#[derive(Copy, Clone)]
616#[repr(C)]
617pub struct SoupRange {
618 pub start: i64,
619 pub end: i64,
620}
621
622impl ::std::fmt::Debug for SoupRange {
623 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
624 f.debug_struct(&format!("SoupRange @ {self:p}"))
625 .field("start", &self.start)
626 .field("end", &self.end)
627 .finish()
628 }
629}
630
631#[derive(Copy, Clone)]
632#[repr(C)]
633pub struct SoupServerClass {
634 pub parent_class: gobject::GObjectClass,
635 pub request_started: Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage)>,
636 pub request_read: Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage)>,
637 pub request_finished: Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage)>,
638 pub request_aborted: Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage)>,
639 pub padding: [gpointer; 6],
640}
641
642impl ::std::fmt::Debug for SoupServerClass {
643 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
644 f.debug_struct(&format!("SoupServerClass @ {self:p}"))
645 .field("parent_class", &self.parent_class)
646 .field("request_started", &self.request_started)
647 .field("request_read", &self.request_read)
648 .field("request_finished", &self.request_finished)
649 .field("request_aborted", &self.request_aborted)
650 .field("padding", &self.padding)
651 .finish()
652 }
653}
654
655#[derive(Copy, Clone)]
656#[repr(C)]
657pub struct SoupServerMessageClass {
658 pub parent_class: gobject::GObjectClass,
659}
660
661impl ::std::fmt::Debug for SoupServerMessageClass {
662 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
663 f.debug_struct(&format!("SoupServerMessageClass @ {self:p}"))
664 .field("parent_class", &self.parent_class)
665 .finish()
666 }
667}
668
669#[derive(Copy, Clone)]
670#[repr(C)]
671pub struct SoupSessionClass {
672 pub parent_class: gobject::GObjectClass,
673 pub request_queued: Option<unsafe extern "C" fn(*mut SoupSession, *mut SoupMessage)>,
674 pub request_unqueued: Option<unsafe extern "C" fn(*mut SoupSession, *mut SoupMessage)>,
675 pub _soup_reserved1: Option<unsafe extern "C" fn()>,
676 pub _soup_reserved2: Option<unsafe extern "C" fn()>,
677 pub _soup_reserved3: Option<unsafe extern "C" fn()>,
678 pub _soup_reserved4: Option<unsafe extern "C" fn()>,
679 pub _soup_reserved5: Option<unsafe extern "C" fn()>,
680 pub _soup_reserved6: Option<unsafe extern "C" fn()>,
681 pub _soup_reserved7: Option<unsafe extern "C" fn()>,
682 pub _soup_reserved8: Option<unsafe extern "C" fn()>,
683}
684
685impl ::std::fmt::Debug for SoupSessionClass {
686 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
687 f.debug_struct(&format!("SoupSessionClass @ {self:p}"))
688 .field("parent_class", &self.parent_class)
689 .field("request_queued", &self.request_queued)
690 .field("request_unqueued", &self.request_unqueued)
691 .field("_soup_reserved1", &self._soup_reserved1)
692 .field("_soup_reserved2", &self._soup_reserved2)
693 .field("_soup_reserved3", &self._soup_reserved3)
694 .field("_soup_reserved4", &self._soup_reserved4)
695 .field("_soup_reserved5", &self._soup_reserved5)
696 .field("_soup_reserved6", &self._soup_reserved6)
697 .field("_soup_reserved7", &self._soup_reserved7)
698 .field("_soup_reserved8", &self._soup_reserved8)
699 .finish()
700 }
701}
702
703#[repr(C)]
704#[allow(dead_code)]
705pub struct _SoupSessionFeatureInterface {
706 _data: [u8; 0],
707 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
708}
709
710pub type SoupSessionFeatureInterface = _SoupSessionFeatureInterface;
711
712#[derive(Copy, Clone)]
713#[repr(C)]
714pub struct SoupWebsocketConnectionClass {
715 pub parent_class: gobject::GObjectClass,
716}
717
718impl ::std::fmt::Debug for SoupWebsocketConnectionClass {
719 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
720 f.debug_struct(&format!("SoupWebsocketConnectionClass @ {self:p}"))
721 .field("parent_class", &self.parent_class)
722 .finish()
723 }
724}
725
726#[derive(Copy, Clone)]
727#[repr(C)]
728pub struct SoupWebsocketExtensionClass {
729 pub parent_class: gobject::GObjectClass,
730 pub name: *const c_char,
731 pub configure: Option<unsafe extern "C" fn(*mut SoupWebsocketExtension, SoupWebsocketConnectionType, *mut glib::GHashTable, *mut *mut glib::GError) -> gboolean>,
732 pub get_request_params: Option<unsafe extern "C" fn(*mut SoupWebsocketExtension) -> *mut c_char>,
733 pub get_response_params: Option<unsafe extern "C" fn(*mut SoupWebsocketExtension) -> *mut c_char>,
734 pub process_outgoing_message: Option<unsafe extern "C" fn(*mut SoupWebsocketExtension, *mut u8, *mut glib::GBytes, *mut *mut glib::GError) -> *mut glib::GBytes>,
735 pub process_incoming_message: Option<unsafe extern "C" fn(*mut SoupWebsocketExtension, *mut u8, *mut glib::GBytes, *mut *mut glib::GError) -> *mut glib::GBytes>,
736 pub padding: [gpointer; 6],
737}
738
739impl ::std::fmt::Debug for SoupWebsocketExtensionClass {
740 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
741 f.debug_struct(&format!("SoupWebsocketExtensionClass @ {self:p}"))
742 .field("parent_class", &self.parent_class)
743 .field("name", &self.name)
744 .field("configure", &self.configure)
745 .field("get_request_params", &self.get_request_params)
746 .field("get_response_params", &self.get_response_params)
747 .field("process_outgoing_message", &self.process_outgoing_message)
748 .field("process_incoming_message", &self.process_incoming_message)
749 .finish()
750 }
751}
752
753#[derive(Copy, Clone)]
754#[repr(C)]
755pub struct SoupWebsocketExtensionDeflateClass {
756 pub parent_class: SoupWebsocketExtensionClass,
757}
758
759impl ::std::fmt::Debug for SoupWebsocketExtensionDeflateClass {
760 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
761 f.debug_struct(&format!("SoupWebsocketExtensionDeflateClass @ {self:p}"))
762 .field("parent_class", &self.parent_class)
763 .finish()
764 }
765}
766
767#[derive(Copy, Clone)]
768#[repr(C)]
769pub struct SoupWebsocketExtensionManagerClass {
770 pub parent_class: gobject::GObjectClass,
771}
772
773impl ::std::fmt::Debug for SoupWebsocketExtensionManagerClass {
774 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
775 f.debug_struct(&format!("SoupWebsocketExtensionManagerClass @ {self:p}"))
776 .field("parent_class", &self.parent_class)
777 .finish()
778 }
779}
780
781#[derive(Copy, Clone)]
783#[repr(C)]
784pub struct SoupAuth {
785 pub parent_instance: gobject::GObject,
786}
787
788impl ::std::fmt::Debug for SoupAuth {
789 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
790 f.debug_struct(&format!("SoupAuth @ {self:p}"))
791 .field("parent_instance", &self.parent_instance)
792 .finish()
793 }
794}
795
796#[repr(C)]
797#[allow(dead_code)]
798pub struct SoupAuthBasic {
799 _data: [u8; 0],
800 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
801}
802
803impl ::std::fmt::Debug for SoupAuthBasic {
804 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
805 f.debug_struct(&format!("SoupAuthBasic @ {self:p}"))
806 .finish()
807 }
808}
809
810#[repr(C)]
811#[allow(dead_code)]
812pub struct SoupAuthDigest {
813 _data: [u8; 0],
814 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
815}
816
817impl ::std::fmt::Debug for SoupAuthDigest {
818 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
819 f.debug_struct(&format!("SoupAuthDigest @ {self:p}"))
820 .finish()
821 }
822}
823
824#[derive(Copy, Clone)]
825#[repr(C)]
826pub struct SoupAuthDomain {
827 pub parent_instance: gobject::GObject,
828}
829
830impl ::std::fmt::Debug for SoupAuthDomain {
831 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
832 f.debug_struct(&format!("SoupAuthDomain @ {self:p}"))
833 .field("parent_instance", &self.parent_instance)
834 .finish()
835 }
836}
837
838#[repr(C)]
839#[allow(dead_code)]
840pub struct SoupAuthDomainBasic {
841 _data: [u8; 0],
842 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
843}
844
845impl ::std::fmt::Debug for SoupAuthDomainBasic {
846 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
847 f.debug_struct(&format!("SoupAuthDomainBasic @ {self:p}"))
848 .finish()
849 }
850}
851
852#[repr(C)]
853#[allow(dead_code)]
854pub struct SoupAuthDomainDigest {
855 _data: [u8; 0],
856 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
857}
858
859impl ::std::fmt::Debug for SoupAuthDomainDigest {
860 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
861 f.debug_struct(&format!("SoupAuthDomainDigest @ {self:p}"))
862 .finish()
863 }
864}
865
866#[repr(C)]
867#[allow(dead_code)]
868pub struct SoupAuthManager {
869 _data: [u8; 0],
870 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
871}
872
873impl ::std::fmt::Debug for SoupAuthManager {
874 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
875 f.debug_struct(&format!("SoupAuthManager @ {self:p}"))
876 .finish()
877 }
878}
879
880#[repr(C)]
881#[allow(dead_code)]
882pub struct SoupAuthNTLM {
883 _data: [u8; 0],
884 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
885}
886
887impl ::std::fmt::Debug for SoupAuthNTLM {
888 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
889 f.debug_struct(&format!("SoupAuthNTLM @ {self:p}"))
890 .finish()
891 }
892}
893
894#[repr(C)]
895#[allow(dead_code)]
896pub struct SoupAuthNegotiate {
897 _data: [u8; 0],
898 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
899}
900
901impl ::std::fmt::Debug for SoupAuthNegotiate {
902 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
903 f.debug_struct(&format!("SoupAuthNegotiate @ {self:p}"))
904 .finish()
905 }
906}
907
908#[derive(Copy, Clone)]
909#[repr(C)]
910pub struct SoupCache {
911 pub parent_instance: gobject::GObject,
912}
913
914impl ::std::fmt::Debug for SoupCache {
915 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
916 f.debug_struct(&format!("SoupCache @ {self:p}"))
917 .field("parent_instance", &self.parent_instance)
918 .finish()
919 }
920}
921
922#[repr(C)]
923#[allow(dead_code)]
924pub struct SoupContentDecoder {
925 _data: [u8; 0],
926 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
927}
928
929impl ::std::fmt::Debug for SoupContentDecoder {
930 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
931 f.debug_struct(&format!("SoupContentDecoder @ {self:p}"))
932 .finish()
933 }
934}
935
936#[repr(C)]
937#[allow(dead_code)]
938pub struct SoupContentSniffer {
939 _data: [u8; 0],
940 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
941}
942
943impl ::std::fmt::Debug for SoupContentSniffer {
944 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
945 f.debug_struct(&format!("SoupContentSniffer @ {self:p}"))
946 .finish()
947 }
948}
949
950#[derive(Copy, Clone)]
951#[repr(C)]
952pub struct SoupCookieJar {
953 pub parent_instance: gobject::GObject,
954}
955
956impl ::std::fmt::Debug for SoupCookieJar {
957 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
958 f.debug_struct(&format!("SoupCookieJar @ {self:p}"))
959 .field("parent_instance", &self.parent_instance)
960 .finish()
961 }
962}
963
964#[repr(C)]
965#[allow(dead_code)]
966pub struct SoupCookieJarDB {
967 _data: [u8; 0],
968 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
969}
970
971impl ::std::fmt::Debug for SoupCookieJarDB {
972 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
973 f.debug_struct(&format!("SoupCookieJarDB @ {self:p}"))
974 .finish()
975 }
976}
977
978#[repr(C)]
979#[allow(dead_code)]
980pub struct SoupCookieJarText {
981 _data: [u8; 0],
982 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
983}
984
985impl ::std::fmt::Debug for SoupCookieJarText {
986 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
987 f.debug_struct(&format!("SoupCookieJarText @ {self:p}"))
988 .finish()
989 }
990}
991
992#[derive(Copy, Clone)]
993#[repr(C)]
994pub struct SoupHSTSEnforcer {
995 pub parent_instance: gobject::GObject,
996}
997
998impl ::std::fmt::Debug for SoupHSTSEnforcer {
999 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1000 f.debug_struct(&format!("SoupHSTSEnforcer @ {self:p}"))
1001 .field("parent_instance", &self.parent_instance)
1002 .finish()
1003 }
1004}
1005
1006#[repr(C)]
1007#[allow(dead_code)]
1008pub struct SoupHSTSEnforcerDB {
1009 _data: [u8; 0],
1010 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1011}
1012
1013impl ::std::fmt::Debug for SoupHSTSEnforcerDB {
1014 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1015 f.debug_struct(&format!("SoupHSTSEnforcerDB @ {self:p}"))
1016 .finish()
1017 }
1018}
1019
1020#[repr(C)]
1021#[allow(dead_code)]
1022pub struct SoupLogger {
1023 _data: [u8; 0],
1024 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1025}
1026
1027impl ::std::fmt::Debug for SoupLogger {
1028 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1029 f.debug_struct(&format!("SoupLogger @ {self:p}"))
1030 .finish()
1031 }
1032}
1033
1034#[repr(C)]
1035#[allow(dead_code)]
1036pub struct SoupMessage {
1037 _data: [u8; 0],
1038 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1039}
1040
1041impl ::std::fmt::Debug for SoupMessage {
1042 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1043 f.debug_struct(&format!("SoupMessage @ {self:p}"))
1044 .finish()
1045 }
1046}
1047
1048#[repr(C)]
1049#[allow(dead_code)]
1050pub struct SoupMultipartInputStream {
1051 _data: [u8; 0],
1052 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1053}
1054
1055impl ::std::fmt::Debug for SoupMultipartInputStream {
1056 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1057 f.debug_struct(&format!("SoupMultipartInputStream @ {self:p}"))
1058 .finish()
1059 }
1060}
1061
1062#[derive(Copy, Clone)]
1063#[repr(C)]
1064pub struct SoupServer {
1065 pub parent_instance: gobject::GObject,
1066}
1067
1068impl ::std::fmt::Debug for SoupServer {
1069 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1070 f.debug_struct(&format!("SoupServer @ {self:p}"))
1071 .field("parent_instance", &self.parent_instance)
1072 .finish()
1073 }
1074}
1075
1076#[repr(C)]
1077#[allow(dead_code)]
1078pub struct SoupServerMessage {
1079 _data: [u8; 0],
1080 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1081}
1082
1083impl ::std::fmt::Debug for SoupServerMessage {
1084 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1085 f.debug_struct(&format!("SoupServerMessage @ {self:p}"))
1086 .finish()
1087 }
1088}
1089
1090#[derive(Copy, Clone)]
1091#[repr(C)]
1092pub struct SoupSession {
1093 pub parent_instance: gobject::GObject,
1094}
1095
1096impl ::std::fmt::Debug for SoupSession {
1097 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1098 f.debug_struct(&format!("SoupSession @ {self:p}"))
1099 .field("parent_instance", &self.parent_instance)
1100 .finish()
1101 }
1102}
1103
1104#[repr(C)]
1105#[allow(dead_code)]
1106pub struct SoupWebsocketConnection {
1107 _data: [u8; 0],
1108 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1109}
1110
1111impl ::std::fmt::Debug for SoupWebsocketConnection {
1112 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1113 f.debug_struct(&format!("SoupWebsocketConnection @ {self:p}"))
1114 .finish()
1115 }
1116}
1117
1118#[derive(Copy, Clone)]
1119#[repr(C)]
1120pub struct SoupWebsocketExtension {
1121 pub parent_instance: gobject::GObject,
1122}
1123
1124impl ::std::fmt::Debug for SoupWebsocketExtension {
1125 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1126 f.debug_struct(&format!("SoupWebsocketExtension @ {self:p}"))
1127 .field("parent_instance", &self.parent_instance)
1128 .finish()
1129 }
1130}
1131
1132#[repr(C)]
1133#[allow(dead_code)]
1134pub struct SoupWebsocketExtensionDeflate {
1135 _data: [u8; 0],
1136 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1137}
1138
1139impl ::std::fmt::Debug for SoupWebsocketExtensionDeflate {
1140 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1141 f.debug_struct(&format!("SoupWebsocketExtensionDeflate @ {self:p}"))
1142 .finish()
1143 }
1144}
1145
1146#[repr(C)]
1147#[allow(dead_code)]
1148pub struct SoupWebsocketExtensionManager {
1149 _data: [u8; 0],
1150 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1151}
1152
1153impl ::std::fmt::Debug for SoupWebsocketExtensionManager {
1154 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1155 f.debug_struct(&format!("SoupWebsocketExtensionManager @ {self:p}"))
1156 .finish()
1157 }
1158}
1159
1160#[repr(C)]
1162#[allow(dead_code)]
1163pub struct SoupSessionFeature {
1164 _data: [u8; 0],
1165 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1166}
1167
1168impl ::std::fmt::Debug for SoupSessionFeature {
1169 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1170 write!(f, "SoupSessionFeature @ {self:p}")
1171 }
1172}
1173
1174
1175extern "C" {
1176
1177 pub fn soup_cache_type_get_type() -> GType;
1181
1182 pub fn soup_cookie_jar_accept_policy_get_type() -> GType;
1186
1187 pub fn soup_date_format_get_type() -> GType;
1191
1192 pub fn soup_encoding_get_type() -> GType;
1196
1197 pub fn soup_http_version_get_type() -> GType;
1201
1202 pub fn soup_logger_log_level_get_type() -> GType;
1206
1207 pub fn soup_memory_use_get_type() -> GType;
1211
1212 pub fn soup_message_headers_type_get_type() -> GType;
1216
1217 pub fn soup_message_priority_get_type() -> GType;
1221
1222 pub fn soup_same_site_policy_get_type() -> GType;
1226
1227 pub fn soup_session_error_get_type() -> GType;
1231 pub fn soup_session_error_quark() -> glib::GQuark;
1232
1233 pub fn soup_status_get_type() -> GType;
1237 pub fn soup_status_get_phrase(status_code: c_uint) -> *const c_char;
1238
1239 pub fn soup_tld_error_get_type() -> GType;
1243 pub fn soup_tld_error_quark() -> glib::GQuark;
1244
1245 pub fn soup_uri_component_get_type() -> GType;
1249
1250 pub fn soup_websocket_close_code_get_type() -> GType;
1254
1255 pub fn soup_websocket_connection_type_get_type() -> GType;
1259
1260 pub fn soup_websocket_data_type_get_type() -> GType;
1264
1265 pub fn soup_websocket_error_get_type() -> GType;
1269 pub fn soup_websocket_error_quark() -> glib::GQuark;
1270
1271 pub fn soup_websocket_state_get_type() -> GType;
1275
1276 pub fn soup_cacheability_get_type() -> GType;
1280
1281 pub fn soup_expectation_get_type() -> GType;
1285
1286 pub fn soup_message_flags_get_type() -> GType;
1290
1291 pub fn soup_server_listen_options_get_type() -> GType;
1295
1296 pub fn soup_cookie_get_type() -> GType;
1300 pub fn soup_cookie_new(name: *const c_char, value: *const c_char, domain: *const c_char, path: *const c_char, max_age: c_int) -> *mut SoupCookie;
1301 pub fn soup_cookie_applies_to_uri(cookie: *mut SoupCookie, uri: *mut glib::GUri) -> gboolean;
1302 pub fn soup_cookie_copy(cookie: *mut SoupCookie) -> *mut SoupCookie;
1303 pub fn soup_cookie_domain_matches(cookie: *mut SoupCookie, host: *const c_char) -> gboolean;
1304 pub fn soup_cookie_equal(cookie1: *mut SoupCookie, cookie2: *mut SoupCookie) -> gboolean;
1305 pub fn soup_cookie_free(cookie: *mut SoupCookie);
1306 pub fn soup_cookie_get_domain(cookie: *mut SoupCookie) -> *const c_char;
1307 pub fn soup_cookie_get_expires(cookie: *mut SoupCookie) -> *mut glib::GDateTime;
1308 pub fn soup_cookie_get_http_only(cookie: *mut SoupCookie) -> gboolean;
1309 pub fn soup_cookie_get_name(cookie: *mut SoupCookie) -> *const c_char;
1310 pub fn soup_cookie_get_path(cookie: *mut SoupCookie) -> *const c_char;
1311 pub fn soup_cookie_get_same_site_policy(cookie: *mut SoupCookie) -> SoupSameSitePolicy;
1312 pub fn soup_cookie_get_secure(cookie: *mut SoupCookie) -> gboolean;
1313 pub fn soup_cookie_get_value(cookie: *mut SoupCookie) -> *const c_char;
1314 pub fn soup_cookie_set_domain(cookie: *mut SoupCookie, domain: *const c_char);
1315 pub fn soup_cookie_set_expires(cookie: *mut SoupCookie, expires: *mut glib::GDateTime);
1316 pub fn soup_cookie_set_http_only(cookie: *mut SoupCookie, http_only: gboolean);
1317 pub fn soup_cookie_set_max_age(cookie: *mut SoupCookie, max_age: c_int);
1318 pub fn soup_cookie_set_name(cookie: *mut SoupCookie, name: *const c_char);
1319 pub fn soup_cookie_set_path(cookie: *mut SoupCookie, path: *const c_char);
1320 pub fn soup_cookie_set_same_site_policy(cookie: *mut SoupCookie, policy: SoupSameSitePolicy);
1321 pub fn soup_cookie_set_secure(cookie: *mut SoupCookie, secure: gboolean);
1322 pub fn soup_cookie_set_value(cookie: *mut SoupCookie, value: *const c_char);
1323 pub fn soup_cookie_to_cookie_header(cookie: *mut SoupCookie) -> *mut c_char;
1324 pub fn soup_cookie_to_set_cookie_header(cookie: *mut SoupCookie) -> *mut c_char;
1325 pub fn soup_cookie_parse(header: *const c_char, origin: *mut glib::GUri) -> *mut SoupCookie;
1326
1327 pub fn soup_hsts_policy_get_type() -> GType;
1331 pub fn soup_hsts_policy_new(domain: *const c_char, max_age: c_ulong, include_subdomains: gboolean) -> *mut SoupHSTSPolicy;
1332 pub fn soup_hsts_policy_new_from_response(msg: *mut SoupMessage) -> *mut SoupHSTSPolicy;
1333 pub fn soup_hsts_policy_new_full(domain: *const c_char, max_age: c_ulong, expires: *mut glib::GDateTime, include_subdomains: gboolean) -> *mut SoupHSTSPolicy;
1334 pub fn soup_hsts_policy_new_session_policy(domain: *const c_char, include_subdomains: gboolean) -> *mut SoupHSTSPolicy;
1335 pub fn soup_hsts_policy_copy(policy: *mut SoupHSTSPolicy) -> *mut SoupHSTSPolicy;
1336 pub fn soup_hsts_policy_equal(policy1: *mut SoupHSTSPolicy, policy2: *mut SoupHSTSPolicy) -> gboolean;
1337 pub fn soup_hsts_policy_free(policy: *mut SoupHSTSPolicy);
1338 pub fn soup_hsts_policy_get_domain(policy: *mut SoupHSTSPolicy) -> *const c_char;
1339 pub fn soup_hsts_policy_get_expires(policy: *mut SoupHSTSPolicy) -> *mut glib::GDateTime;
1340 pub fn soup_hsts_policy_get_max_age(policy: *mut SoupHSTSPolicy) -> c_ulong;
1341 pub fn soup_hsts_policy_includes_subdomains(policy: *mut SoupHSTSPolicy) -> gboolean;
1342 pub fn soup_hsts_policy_is_expired(policy: *mut SoupHSTSPolicy) -> gboolean;
1343 pub fn soup_hsts_policy_is_session_policy(policy: *mut SoupHSTSPolicy) -> gboolean;
1344
1345 pub fn soup_message_body_get_type() -> GType;
1349 pub fn soup_message_body_new() -> *mut SoupMessageBody;
1350 pub fn soup_message_body_append(body: *mut SoupMessageBody, use_: SoupMemoryUse, data: gconstpointer, length: size_t);
1351 pub fn soup_message_body_append_bytes(body: *mut SoupMessageBody, buffer: *mut glib::GBytes);
1352 pub fn soup_message_body_append_take(body: *mut SoupMessageBody, data: *mut u8, length: size_t);
1353 pub fn soup_message_body_complete(body: *mut SoupMessageBody);
1354 pub fn soup_message_body_flatten(body: *mut SoupMessageBody) -> *mut glib::GBytes;
1355 pub fn soup_message_body_get_accumulate(body: *mut SoupMessageBody) -> gboolean;
1356 pub fn soup_message_body_get_chunk(body: *mut SoupMessageBody, offset: i64) -> *mut glib::GBytes;
1357 pub fn soup_message_body_got_chunk(body: *mut SoupMessageBody, chunk: *mut glib::GBytes);
1358 pub fn soup_message_body_ref(body: *mut SoupMessageBody) -> *mut SoupMessageBody;
1359 pub fn soup_message_body_set_accumulate(body: *mut SoupMessageBody, accumulate: gboolean);
1360 pub fn soup_message_body_truncate(body: *mut SoupMessageBody);
1361 pub fn soup_message_body_unref(body: *mut SoupMessageBody);
1362 pub fn soup_message_body_wrote_chunk(body: *mut SoupMessageBody, chunk: *mut glib::GBytes);
1363
1364 pub fn soup_message_headers_get_type() -> GType;
1368 pub fn soup_message_headers_new(type_: SoupMessageHeadersType) -> *mut SoupMessageHeaders;
1369 pub fn soup_message_headers_append(hdrs: *mut SoupMessageHeaders, name: *const c_char, value: *const c_char);
1370 pub fn soup_message_headers_clean_connection_headers(hdrs: *mut SoupMessageHeaders);
1371 pub fn soup_message_headers_clear(hdrs: *mut SoupMessageHeaders);
1372 pub fn soup_message_headers_foreach(hdrs: *mut SoupMessageHeaders, func: SoupMessageHeadersForeachFunc, user_data: gpointer);
1373 pub fn soup_message_headers_free_ranges(hdrs: *mut SoupMessageHeaders, ranges: *mut SoupRange);
1374 pub fn soup_message_headers_get_content_disposition(hdrs: *mut SoupMessageHeaders, disposition: *mut *mut c_char, params: *mut *mut glib::GHashTable) -> gboolean;
1375 pub fn soup_message_headers_get_content_length(hdrs: *mut SoupMessageHeaders) -> i64;
1376 pub fn soup_message_headers_get_content_range(hdrs: *mut SoupMessageHeaders, start: *mut i64, end: *mut i64, total_length: *mut i64) -> gboolean;
1377 pub fn soup_message_headers_get_content_type(hdrs: *mut SoupMessageHeaders, params: *mut *mut glib::GHashTable) -> *const c_char;
1378 pub fn soup_message_headers_get_encoding(hdrs: *mut SoupMessageHeaders) -> SoupEncoding;
1379 pub fn soup_message_headers_get_expectations(hdrs: *mut SoupMessageHeaders) -> SoupExpectation;
1380 pub fn soup_message_headers_get_headers_type(hdrs: *mut SoupMessageHeaders) -> SoupMessageHeadersType;
1381 pub fn soup_message_headers_get_list(hdrs: *mut SoupMessageHeaders, name: *const c_char) -> *const c_char;
1382 pub fn soup_message_headers_get_one(hdrs: *mut SoupMessageHeaders, name: *const c_char) -> *const c_char;
1383 pub fn soup_message_headers_get_ranges(hdrs: *mut SoupMessageHeaders, total_length: i64, ranges: *mut *mut SoupRange, length: *mut c_int) -> gboolean;
1384 pub fn soup_message_headers_header_contains(hdrs: *mut SoupMessageHeaders, name: *const c_char, token: *const c_char) -> gboolean;
1385 pub fn soup_message_headers_header_equals(hdrs: *mut SoupMessageHeaders, name: *const c_char, value: *const c_char) -> gboolean;
1386 pub fn soup_message_headers_ref(hdrs: *mut SoupMessageHeaders) -> *mut SoupMessageHeaders;
1387 pub fn soup_message_headers_remove(hdrs: *mut SoupMessageHeaders, name: *const c_char);
1388 pub fn soup_message_headers_replace(hdrs: *mut SoupMessageHeaders, name: *const c_char, value: *const c_char);
1389 pub fn soup_message_headers_set_content_disposition(hdrs: *mut SoupMessageHeaders, disposition: *const c_char, params: *mut glib::GHashTable);
1390 pub fn soup_message_headers_set_content_length(hdrs: *mut SoupMessageHeaders, content_length: i64);
1391 pub fn soup_message_headers_set_content_range(hdrs: *mut SoupMessageHeaders, start: i64, end: i64, total_length: i64);
1392 pub fn soup_message_headers_set_content_type(hdrs: *mut SoupMessageHeaders, content_type: *const c_char, params: *mut glib::GHashTable);
1393 pub fn soup_message_headers_set_encoding(hdrs: *mut SoupMessageHeaders, encoding: SoupEncoding);
1394 pub fn soup_message_headers_set_expectations(hdrs: *mut SoupMessageHeaders, expectations: SoupExpectation);
1395 pub fn soup_message_headers_set_range(hdrs: *mut SoupMessageHeaders, start: i64, end: i64);
1396 pub fn soup_message_headers_set_ranges(hdrs: *mut SoupMessageHeaders, ranges: *mut SoupRange, length: c_int);
1397 pub fn soup_message_headers_unref(hdrs: *mut SoupMessageHeaders);
1398
1399 pub fn soup_message_headers_iter_init(iter: *mut SoupMessageHeadersIter, hdrs: *mut SoupMessageHeaders);
1403 pub fn soup_message_headers_iter_next(iter: *mut SoupMessageHeadersIter, name: *mut *const c_char, value: *mut *const c_char) -> gboolean;
1404
1405 pub fn soup_message_metrics_get_type() -> GType;
1409 pub fn soup_message_metrics_copy(metrics: *mut SoupMessageMetrics) -> *mut SoupMessageMetrics;
1410 pub fn soup_message_metrics_free(metrics: *mut SoupMessageMetrics);
1411 pub fn soup_message_metrics_get_connect_end(metrics: *mut SoupMessageMetrics) -> u64;
1412 pub fn soup_message_metrics_get_connect_start(metrics: *mut SoupMessageMetrics) -> u64;
1413 pub fn soup_message_metrics_get_dns_end(metrics: *mut SoupMessageMetrics) -> u64;
1414 pub fn soup_message_metrics_get_dns_start(metrics: *mut SoupMessageMetrics) -> u64;
1415 pub fn soup_message_metrics_get_fetch_start(metrics: *mut SoupMessageMetrics) -> u64;
1416 pub fn soup_message_metrics_get_request_body_bytes_sent(metrics: *mut SoupMessageMetrics) -> u64;
1417 pub fn soup_message_metrics_get_request_body_size(metrics: *mut SoupMessageMetrics) -> u64;
1418 pub fn soup_message_metrics_get_request_header_bytes_sent(metrics: *mut SoupMessageMetrics) -> u64;
1419 pub fn soup_message_metrics_get_request_start(metrics: *mut SoupMessageMetrics) -> u64;
1420 pub fn soup_message_metrics_get_response_body_bytes_received(metrics: *mut SoupMessageMetrics) -> u64;
1421 pub fn soup_message_metrics_get_response_body_size(metrics: *mut SoupMessageMetrics) -> u64;
1422 pub fn soup_message_metrics_get_response_end(metrics: *mut SoupMessageMetrics) -> u64;
1423 pub fn soup_message_metrics_get_response_header_bytes_received(metrics: *mut SoupMessageMetrics) -> u64;
1424 pub fn soup_message_metrics_get_response_start(metrics: *mut SoupMessageMetrics) -> u64;
1425 pub fn soup_message_metrics_get_tls_start(metrics: *mut SoupMessageMetrics) -> u64;
1426
1427 pub fn soup_multipart_get_type() -> GType;
1431 pub fn soup_multipart_new(mime_type: *const c_char) -> *mut SoupMultipart;
1432 pub fn soup_multipart_new_from_message(headers: *mut SoupMessageHeaders, body: *mut glib::GBytes) -> *mut SoupMultipart;
1433 pub fn soup_multipart_append_form_file(multipart: *mut SoupMultipart, control_name: *const c_char, filename: *const c_char, content_type: *const c_char, body: *mut glib::GBytes);
1434 pub fn soup_multipart_append_form_string(multipart: *mut SoupMultipart, control_name: *const c_char, data: *const c_char);
1435 pub fn soup_multipart_append_part(multipart: *mut SoupMultipart, headers: *mut SoupMessageHeaders, body: *mut glib::GBytes);
1436 pub fn soup_multipart_free(multipart: *mut SoupMultipart);
1437 pub fn soup_multipart_get_length(multipart: *mut SoupMultipart) -> c_int;
1438 pub fn soup_multipart_get_part(multipart: *mut SoupMultipart, part: c_int, headers: *mut *mut SoupMessageHeaders, body: *mut *mut glib::GBytes) -> gboolean;
1439 pub fn soup_multipart_to_message(multipart: *mut SoupMultipart, dest_headers: *mut SoupMessageHeaders, dest_body: *mut *mut glib::GBytes);
1440
1441 pub fn soup_auth_get_type() -> GType;
1445 pub fn soup_auth_new(type_: GType, msg: *mut SoupMessage, auth_header: *const c_char) -> *mut SoupAuth;
1446 pub fn soup_auth_authenticate(auth: *mut SoupAuth, username: *const c_char, password: *const c_char);
1447 pub fn soup_auth_can_authenticate(auth: *mut SoupAuth) -> gboolean;
1448 pub fn soup_auth_cancel(auth: *mut SoupAuth);
1449 pub fn soup_auth_free_protection_space(auth: *mut SoupAuth, space: *mut glib::GSList);
1450 pub fn soup_auth_get_authority(auth: *mut SoupAuth) -> *const c_char;
1451 pub fn soup_auth_get_authorization(auth: *mut SoupAuth, msg: *mut SoupMessage) -> *mut c_char;
1452 pub fn soup_auth_get_info(auth: *mut SoupAuth) -> *mut c_char;
1453 pub fn soup_auth_get_protection_space(auth: *mut SoupAuth, source_uri: *mut glib::GUri) -> *mut glib::GSList;
1454 pub fn soup_auth_get_realm(auth: *mut SoupAuth) -> *const c_char;
1455 pub fn soup_auth_get_scheme_name(auth: *mut SoupAuth) -> *const c_char;
1456 pub fn soup_auth_is_authenticated(auth: *mut SoupAuth) -> gboolean;
1457 pub fn soup_auth_is_cancelled(auth: *mut SoupAuth) -> gboolean;
1458 pub fn soup_auth_is_for_proxy(auth: *mut SoupAuth) -> gboolean;
1459 pub fn soup_auth_is_ready(auth: *mut SoupAuth, msg: *mut SoupMessage) -> gboolean;
1460 pub fn soup_auth_update(auth: *mut SoupAuth, msg: *mut SoupMessage, auth_header: *const c_char) -> gboolean;
1461
1462 pub fn soup_auth_basic_get_type() -> GType;
1466
1467 pub fn soup_auth_digest_get_type() -> GType;
1471
1472 pub fn soup_auth_domain_get_type() -> GType;
1476 pub fn soup_auth_domain_accepts(domain: *mut SoupAuthDomain, msg: *mut SoupServerMessage) -> *mut c_char;
1477 pub fn soup_auth_domain_add_path(domain: *mut SoupAuthDomain, path: *const c_char);
1478 pub fn soup_auth_domain_challenge(domain: *mut SoupAuthDomain, msg: *mut SoupServerMessage);
1479 pub fn soup_auth_domain_check_password(domain: *mut SoupAuthDomain, msg: *mut SoupServerMessage, username: *const c_char, password: *const c_char) -> gboolean;
1480 pub fn soup_auth_domain_covers(domain: *mut SoupAuthDomain, msg: *mut SoupServerMessage) -> gboolean;
1481 pub fn soup_auth_domain_get_realm(domain: *mut SoupAuthDomain) -> *const c_char;
1482 pub fn soup_auth_domain_remove_path(domain: *mut SoupAuthDomain, path: *const c_char);
1483 pub fn soup_auth_domain_set_filter(domain: *mut SoupAuthDomain, filter: SoupAuthDomainFilter, filter_data: gpointer, dnotify: glib::GDestroyNotify);
1484 pub fn soup_auth_domain_set_generic_auth_callback(domain: *mut SoupAuthDomain, auth_callback: SoupAuthDomainGenericAuthCallback, auth_data: gpointer, dnotify: glib::GDestroyNotify);
1485
1486 pub fn soup_auth_domain_basic_get_type() -> GType;
1490 pub fn soup_auth_domain_basic_new(optname1: *const c_char, ...) -> *mut SoupAuthDomain;
1491 pub fn soup_auth_domain_basic_set_auth_callback(domain: *mut SoupAuthDomainBasic, callback: SoupAuthDomainBasicAuthCallback, user_data: gpointer, dnotify: glib::GDestroyNotify);
1492
1493 pub fn soup_auth_domain_digest_get_type() -> GType;
1497 pub fn soup_auth_domain_digest_new(optname1: *const c_char, ...) -> *mut SoupAuthDomain;
1498 pub fn soup_auth_domain_digest_encode_password(username: *const c_char, realm: *const c_char, password: *const c_char) -> *mut c_char;
1499 pub fn soup_auth_domain_digest_set_auth_callback(domain: *mut SoupAuthDomainDigest, callback: SoupAuthDomainDigestAuthCallback, user_data: gpointer, dnotify: glib::GDestroyNotify);
1500
1501 pub fn soup_auth_manager_get_type() -> GType;
1505 pub fn soup_auth_manager_clear_cached_credentials(manager: *mut SoupAuthManager);
1506 pub fn soup_auth_manager_use_auth(manager: *mut SoupAuthManager, uri: *mut glib::GUri, auth: *mut SoupAuth);
1507
1508 pub fn soup_auth_ntlm_get_type() -> GType;
1512
1513 pub fn soup_auth_negotiate_get_type() -> GType;
1517 pub fn soup_auth_negotiate_supported() -> gboolean;
1518
1519 pub fn soup_cache_get_type() -> GType;
1523 pub fn soup_cache_new(cache_dir: *const c_char, cache_type: SoupCacheType) -> *mut SoupCache;
1524 pub fn soup_cache_clear(cache: *mut SoupCache);
1525 pub fn soup_cache_dump(cache: *mut SoupCache);
1526 pub fn soup_cache_flush(cache: *mut SoupCache);
1527 pub fn soup_cache_get_max_size(cache: *mut SoupCache) -> c_uint;
1528 pub fn soup_cache_load(cache: *mut SoupCache);
1529 pub fn soup_cache_set_max_size(cache: *mut SoupCache, max_size: c_uint);
1530
1531 pub fn soup_content_decoder_get_type() -> GType;
1535
1536 pub fn soup_content_sniffer_get_type() -> GType;
1540 pub fn soup_content_sniffer_new() -> *mut SoupContentSniffer;
1541 pub fn soup_content_sniffer_sniff(sniffer: *mut SoupContentSniffer, msg: *mut SoupMessage, buffer: *mut glib::GBytes, params: *mut *mut glib::GHashTable) -> *mut c_char;
1542
1543 pub fn soup_cookie_jar_get_type() -> GType;
1547 pub fn soup_cookie_jar_new() -> *mut SoupCookieJar;
1548 pub fn soup_cookie_jar_add_cookie(jar: *mut SoupCookieJar, cookie: *mut SoupCookie);
1549 pub fn soup_cookie_jar_add_cookie_full(jar: *mut SoupCookieJar, cookie: *mut SoupCookie, uri: *mut glib::GUri, first_party: *mut glib::GUri);
1550 pub fn soup_cookie_jar_add_cookie_with_first_party(jar: *mut SoupCookieJar, first_party: *mut glib::GUri, cookie: *mut SoupCookie);
1551 pub fn soup_cookie_jar_all_cookies(jar: *mut SoupCookieJar) -> *mut glib::GSList;
1552 pub fn soup_cookie_jar_delete_cookie(jar: *mut SoupCookieJar, cookie: *mut SoupCookie);
1553 pub fn soup_cookie_jar_get_accept_policy(jar: *mut SoupCookieJar) -> SoupCookieJarAcceptPolicy;
1554 pub fn soup_cookie_jar_get_cookie_list(jar: *mut SoupCookieJar, uri: *mut glib::GUri, for_http: gboolean) -> *mut glib::GSList;
1555 pub fn soup_cookie_jar_get_cookie_list_with_same_site_info(jar: *mut SoupCookieJar, uri: *mut glib::GUri, top_level: *mut glib::GUri, site_for_cookies: *mut glib::GUri, for_http: gboolean, is_safe_method: gboolean, is_top_level_navigation: gboolean) -> *mut glib::GSList;
1556 pub fn soup_cookie_jar_get_cookies(jar: *mut SoupCookieJar, uri: *mut glib::GUri, for_http: gboolean) -> *mut c_char;
1557 pub fn soup_cookie_jar_is_persistent(jar: *mut SoupCookieJar) -> gboolean;
1558 pub fn soup_cookie_jar_set_accept_policy(jar: *mut SoupCookieJar, policy: SoupCookieJarAcceptPolicy);
1559 pub fn soup_cookie_jar_set_cookie(jar: *mut SoupCookieJar, uri: *mut glib::GUri, cookie: *const c_char);
1560 pub fn soup_cookie_jar_set_cookie_with_first_party(jar: *mut SoupCookieJar, uri: *mut glib::GUri, first_party: *mut glib::GUri, cookie: *const c_char);
1561
1562 pub fn soup_cookie_jar_db_get_type() -> GType;
1566 pub fn soup_cookie_jar_db_new(filename: *const c_char, read_only: gboolean) -> *mut SoupCookieJar;
1567
1568 pub fn soup_cookie_jar_text_get_type() -> GType;
1572 pub fn soup_cookie_jar_text_new(filename: *const c_char, read_only: gboolean) -> *mut SoupCookieJar;
1573
1574 pub fn soup_hsts_enforcer_get_type() -> GType;
1578 pub fn soup_hsts_enforcer_new() -> *mut SoupHSTSEnforcer;
1579 pub fn soup_hsts_enforcer_get_domains(hsts_enforcer: *mut SoupHSTSEnforcer, session_policies: gboolean) -> *mut glib::GList;
1580 pub fn soup_hsts_enforcer_get_policies(hsts_enforcer: *mut SoupHSTSEnforcer, session_policies: gboolean) -> *mut glib::GList;
1581 pub fn soup_hsts_enforcer_has_valid_policy(hsts_enforcer: *mut SoupHSTSEnforcer, domain: *const c_char) -> gboolean;
1582 pub fn soup_hsts_enforcer_is_persistent(hsts_enforcer: *mut SoupHSTSEnforcer) -> gboolean;
1583 pub fn soup_hsts_enforcer_set_policy(hsts_enforcer: *mut SoupHSTSEnforcer, policy: *mut SoupHSTSPolicy);
1584 pub fn soup_hsts_enforcer_set_session_policy(hsts_enforcer: *mut SoupHSTSEnforcer, domain: *const c_char, include_subdomains: gboolean);
1585
1586 pub fn soup_hsts_enforcer_db_get_type() -> GType;
1590 pub fn soup_hsts_enforcer_db_new(filename: *const c_char) -> *mut SoupHSTSEnforcer;
1591
1592 pub fn soup_logger_get_type() -> GType;
1596 pub fn soup_logger_new(level: SoupLoggerLogLevel) -> *mut SoupLogger;
1597 pub fn soup_logger_get_max_body_size(logger: *mut SoupLogger) -> c_int;
1598 pub fn soup_logger_set_max_body_size(logger: *mut SoupLogger, max_body_size: c_int);
1599 pub fn soup_logger_set_printer(logger: *mut SoupLogger, printer: SoupLoggerPrinter, printer_data: gpointer, destroy: glib::GDestroyNotify);
1600 pub fn soup_logger_set_request_filter(logger: *mut SoupLogger, request_filter: SoupLoggerFilter, filter_data: gpointer, destroy: glib::GDestroyNotify);
1601 pub fn soup_logger_set_response_filter(logger: *mut SoupLogger, response_filter: SoupLoggerFilter, filter_data: gpointer, destroy: glib::GDestroyNotify);
1602
1603 pub fn soup_message_get_type() -> GType;
1607 pub fn soup_message_new(method: *const c_char, uri_string: *const c_char) -> *mut SoupMessage;
1608 pub fn soup_message_new_from_encoded_form(method: *const c_char, uri_string: *const c_char, encoded_form: *mut c_char) -> *mut SoupMessage;
1609 pub fn soup_message_new_from_multipart(uri_string: *const c_char, multipart: *mut SoupMultipart) -> *mut SoupMessage;
1610 pub fn soup_message_new_from_uri(method: *const c_char, uri: *mut glib::GUri) -> *mut SoupMessage;
1611 pub fn soup_message_new_options_ping(base_uri: *mut glib::GUri) -> *mut SoupMessage;
1612 pub fn soup_message_add_flags(msg: *mut SoupMessage, flags: SoupMessageFlags);
1613 pub fn soup_message_add_header_handler(msg: *mut SoupMessage, signal: *const c_char, header: *const c_char, callback: gobject::GCallback, user_data: gpointer) -> c_uint;
1614 pub fn soup_message_add_status_code_handler(msg: *mut SoupMessage, signal: *const c_char, status_code: c_uint, callback: gobject::GCallback, user_data: gpointer) -> c_uint;
1615 pub fn soup_message_disable_feature(msg: *mut SoupMessage, feature_type: GType);
1616 pub fn soup_message_get_connection_id(msg: *mut SoupMessage) -> u64;
1617 pub fn soup_message_get_first_party(msg: *mut SoupMessage) -> *mut glib::GUri;
1618 pub fn soup_message_get_flags(msg: *mut SoupMessage) -> SoupMessageFlags;
1619 #[cfg(feature = "v3_4")]
1620 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
1621 pub fn soup_message_get_force_http1(msg: *mut SoupMessage) -> gboolean;
1622 pub fn soup_message_get_http_version(msg: *mut SoupMessage) -> SoupHTTPVersion;
1623 pub fn soup_message_get_is_options_ping(msg: *mut SoupMessage) -> gboolean;
1624 pub fn soup_message_get_is_top_level_navigation(msg: *mut SoupMessage) -> gboolean;
1625 pub fn soup_message_get_method(msg: *mut SoupMessage) -> *const c_char;
1626 pub fn soup_message_get_metrics(msg: *mut SoupMessage) -> *mut SoupMessageMetrics;
1627 pub fn soup_message_get_priority(msg: *mut SoupMessage) -> SoupMessagePriority;
1628 pub fn soup_message_get_reason_phrase(msg: *mut SoupMessage) -> *const c_char;
1629 pub fn soup_message_get_remote_address(msg: *mut SoupMessage) -> *mut gio::GSocketAddress;
1630 pub fn soup_message_get_request_headers(msg: *mut SoupMessage) -> *mut SoupMessageHeaders;
1631 pub fn soup_message_get_response_headers(msg: *mut SoupMessage) -> *mut SoupMessageHeaders;
1632 pub fn soup_message_get_site_for_cookies(msg: *mut SoupMessage) -> *mut glib::GUri;
1633 pub fn soup_message_get_status(msg: *mut SoupMessage) -> SoupStatus;
1634 pub fn soup_message_get_tls_ciphersuite_name(msg: *mut SoupMessage) -> *const c_char;
1635 pub fn soup_message_get_tls_peer_certificate(msg: *mut SoupMessage) -> *mut gio::GTlsCertificate;
1636 pub fn soup_message_get_tls_peer_certificate_errors(msg: *mut SoupMessage) -> gio::GTlsCertificateFlags;
1637 pub fn soup_message_get_tls_protocol_version(msg: *mut SoupMessage) -> gio::GTlsProtocolVersion;
1638 pub fn soup_message_get_uri(msg: *mut SoupMessage) -> *mut glib::GUri;
1639 pub fn soup_message_is_feature_disabled(msg: *mut SoupMessage, feature_type: GType) -> gboolean;
1640 pub fn soup_message_is_keepalive(msg: *mut SoupMessage) -> gboolean;
1641 pub fn soup_message_query_flags(msg: *mut SoupMessage, flags: SoupMessageFlags) -> gboolean;
1642 pub fn soup_message_remove_flags(msg: *mut SoupMessage, flags: SoupMessageFlags);
1643 pub fn soup_message_set_first_party(msg: *mut SoupMessage, first_party: *mut glib::GUri);
1644 pub fn soup_message_set_flags(msg: *mut SoupMessage, flags: SoupMessageFlags);
1645 #[cfg(feature = "v3_4")]
1646 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
1647 pub fn soup_message_set_force_http1(msg: *mut SoupMessage, value: gboolean);
1648 pub fn soup_message_set_is_options_ping(msg: *mut SoupMessage, is_options_ping: gboolean);
1649 pub fn soup_message_set_is_top_level_navigation(msg: *mut SoupMessage, is_top_level_navigation: gboolean);
1650 pub fn soup_message_set_method(msg: *mut SoupMessage, method: *const c_char);
1651 pub fn soup_message_set_priority(msg: *mut SoupMessage, priority: SoupMessagePriority);
1652 pub fn soup_message_set_request_body(msg: *mut SoupMessage, content_type: *const c_char, stream: *mut gio::GInputStream, content_length: ssize_t);
1653 pub fn soup_message_set_request_body_from_bytes(msg: *mut SoupMessage, content_type: *const c_char, bytes: *mut glib::GBytes);
1654 pub fn soup_message_set_site_for_cookies(msg: *mut SoupMessage, site_for_cookies: *mut glib::GUri);
1655 pub fn soup_message_set_tls_client_certificate(msg: *mut SoupMessage, certificate: *mut gio::GTlsCertificate);
1656 pub fn soup_message_set_uri(msg: *mut SoupMessage, uri: *mut glib::GUri);
1657 pub fn soup_message_tls_client_certificate_password_request_complete(msg: *mut SoupMessage);
1658
1659 pub fn soup_multipart_input_stream_get_type() -> GType;
1663 pub fn soup_multipart_input_stream_new(msg: *mut SoupMessage, base_stream: *mut gio::GInputStream) -> *mut SoupMultipartInputStream;
1664 pub fn soup_multipart_input_stream_get_headers(multipart: *mut SoupMultipartInputStream) -> *mut SoupMessageHeaders;
1665 pub fn soup_multipart_input_stream_next_part(multipart: *mut SoupMultipartInputStream, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut gio::GInputStream;
1666 pub fn soup_multipart_input_stream_next_part_async(multipart: *mut SoupMultipartInputStream, io_priority: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, data: gpointer);
1667 pub fn soup_multipart_input_stream_next_part_finish(multipart: *mut SoupMultipartInputStream, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut gio::GInputStream;
1668
1669 pub fn soup_server_get_type() -> GType;
1673 pub fn soup_server_new(optname1: *const c_char, ...) -> *mut SoupServer;
1674 pub fn soup_server_accept_iostream(server: *mut SoupServer, stream: *mut gio::GIOStream, local_addr: *mut gio::GSocketAddress, remote_addr: *mut gio::GSocketAddress, error: *mut *mut glib::GError) -> gboolean;
1675 pub fn soup_server_add_auth_domain(server: *mut SoupServer, auth_domain: *mut SoupAuthDomain);
1676 pub fn soup_server_add_early_handler(server: *mut SoupServer, path: *const c_char, callback: SoupServerCallback, user_data: gpointer, destroy: glib::GDestroyNotify);
1677 pub fn soup_server_add_handler(server: *mut SoupServer, path: *const c_char, callback: SoupServerCallback, user_data: gpointer, destroy: glib::GDestroyNotify);
1678 pub fn soup_server_add_websocket_extension(server: *mut SoupServer, extension_type: GType);
1679 pub fn soup_server_add_websocket_handler(server: *mut SoupServer, path: *const c_char, origin: *const c_char, protocols: *mut *mut c_char, callback: SoupServerWebsocketCallback, user_data: gpointer, destroy: glib::GDestroyNotify);
1680 pub fn soup_server_disconnect(server: *mut SoupServer);
1681 pub fn soup_server_get_listeners(server: *mut SoupServer) -> *mut glib::GSList;
1682 pub fn soup_server_get_tls_auth_mode(server: *mut SoupServer) -> gio::GTlsAuthenticationMode;
1683 pub fn soup_server_get_tls_certificate(server: *mut SoupServer) -> *mut gio::GTlsCertificate;
1684 pub fn soup_server_get_tls_database(server: *mut SoupServer) -> *mut gio::GTlsDatabase;
1685 pub fn soup_server_get_uris(server: *mut SoupServer) -> *mut glib::GSList;
1686 pub fn soup_server_is_https(server: *mut SoupServer) -> gboolean;
1687 pub fn soup_server_listen(server: *mut SoupServer, address: *mut gio::GSocketAddress, options: SoupServerListenOptions, error: *mut *mut glib::GError) -> gboolean;
1688 pub fn soup_server_listen_all(server: *mut SoupServer, port: c_uint, options: SoupServerListenOptions, error: *mut *mut glib::GError) -> gboolean;
1689 pub fn soup_server_listen_local(server: *mut SoupServer, port: c_uint, options: SoupServerListenOptions, error: *mut *mut glib::GError) -> gboolean;
1690 pub fn soup_server_listen_socket(server: *mut SoupServer, socket: *mut gio::GSocket, options: SoupServerListenOptions, error: *mut *mut glib::GError) -> gboolean;
1691 pub fn soup_server_pause_message(server: *mut SoupServer, msg: *mut SoupServerMessage);
1692 pub fn soup_server_remove_auth_domain(server: *mut SoupServer, auth_domain: *mut SoupAuthDomain);
1693 pub fn soup_server_remove_handler(server: *mut SoupServer, path: *const c_char);
1694 pub fn soup_server_remove_websocket_extension(server: *mut SoupServer, extension_type: GType);
1695 pub fn soup_server_set_tls_auth_mode(server: *mut SoupServer, mode: gio::GTlsAuthenticationMode);
1696 pub fn soup_server_set_tls_certificate(server: *mut SoupServer, certificate: *mut gio::GTlsCertificate);
1697 pub fn soup_server_set_tls_database(server: *mut SoupServer, tls_database: *mut gio::GTlsDatabase);
1698 pub fn soup_server_unpause_message(server: *mut SoupServer, msg: *mut SoupServerMessage);
1699
1700 pub fn soup_server_message_get_type() -> GType;
1704 pub fn soup_server_message_get_http_version(msg: *mut SoupServerMessage) -> SoupHTTPVersion;
1705 pub fn soup_server_message_get_local_address(msg: *mut SoupServerMessage) -> *mut gio::GSocketAddress;
1706 pub fn soup_server_message_get_method(msg: *mut SoupServerMessage) -> *const c_char;
1707 pub fn soup_server_message_get_reason_phrase(msg: *mut SoupServerMessage) -> *const c_char;
1708 pub fn soup_server_message_get_remote_address(msg: *mut SoupServerMessage) -> *mut gio::GSocketAddress;
1709 pub fn soup_server_message_get_remote_host(msg: *mut SoupServerMessage) -> *const c_char;
1710 pub fn soup_server_message_get_request_body(msg: *mut SoupServerMessage) -> *mut SoupMessageBody;
1711 pub fn soup_server_message_get_request_headers(msg: *mut SoupServerMessage) -> *mut SoupMessageHeaders;
1712 pub fn soup_server_message_get_response_body(msg: *mut SoupServerMessage) -> *mut SoupMessageBody;
1713 pub fn soup_server_message_get_response_headers(msg: *mut SoupServerMessage) -> *mut SoupMessageHeaders;
1714 pub fn soup_server_message_get_socket(msg: *mut SoupServerMessage) -> *mut gio::GSocket;
1715 pub fn soup_server_message_get_status(msg: *mut SoupServerMessage) -> c_uint;
1716 #[cfg(feature = "v3_2")]
1717 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
1718 pub fn soup_server_message_get_tls_peer_certificate(msg: *mut SoupServerMessage) -> *mut gio::GTlsCertificate;
1719 #[cfg(feature = "v3_2")]
1720 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
1721 pub fn soup_server_message_get_tls_peer_certificate_errors(msg: *mut SoupServerMessage) -> gio::GTlsCertificateFlags;
1722 pub fn soup_server_message_get_uri(msg: *mut SoupServerMessage) -> *mut glib::GUri;
1723 pub fn soup_server_message_is_options_ping(msg: *mut SoupServerMessage) -> gboolean;
1724 #[cfg(feature = "v3_2")]
1725 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
1726 pub fn soup_server_message_pause(msg: *mut SoupServerMessage);
1727 pub fn soup_server_message_set_http_version(msg: *mut SoupServerMessage, version: SoupHTTPVersion);
1728 pub fn soup_server_message_set_redirect(msg: *mut SoupServerMessage, status_code: c_uint, redirect_uri: *const c_char);
1729 pub fn soup_server_message_set_response(msg: *mut SoupServerMessage, content_type: *const c_char, resp_use: SoupMemoryUse, resp_body: *const u8, resp_length: size_t);
1730 pub fn soup_server_message_set_status(msg: *mut SoupServerMessage, status_code: c_uint, reason_phrase: *const c_char);
1731 pub fn soup_server_message_steal_connection(msg: *mut SoupServerMessage) -> *mut gio::GIOStream;
1732 #[cfg(feature = "v3_2")]
1733 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
1734 pub fn soup_server_message_unpause(msg: *mut SoupServerMessage);
1735
1736 pub fn soup_session_get_type() -> GType;
1740 pub fn soup_session_new() -> *mut SoupSession;
1741 pub fn soup_session_new_with_options(optname1: *const c_char, ...) -> *mut SoupSession;
1742 pub fn soup_session_abort(session: *mut SoupSession);
1743 pub fn soup_session_add_feature(session: *mut SoupSession, feature: *mut SoupSessionFeature);
1744 pub fn soup_session_add_feature_by_type(session: *mut SoupSession, feature_type: GType);
1745 pub fn soup_session_get_accept_language(session: *mut SoupSession) -> *const c_char;
1746 pub fn soup_session_get_accept_language_auto(session: *mut SoupSession) -> gboolean;
1747 pub fn soup_session_get_async_result_message(session: *mut SoupSession, result: *mut gio::GAsyncResult) -> *mut SoupMessage;
1748 pub fn soup_session_get_feature(session: *mut SoupSession, feature_type: GType) -> *mut SoupSessionFeature;
1749 pub fn soup_session_get_feature_for_message(session: *mut SoupSession, feature_type: GType, msg: *mut SoupMessage) -> *mut SoupSessionFeature;
1750 pub fn soup_session_get_idle_timeout(session: *mut SoupSession) -> c_uint;
1751 pub fn soup_session_get_local_address(session: *mut SoupSession) -> *mut gio::GInetSocketAddress;
1752 pub fn soup_session_get_max_conns(session: *mut SoupSession) -> c_uint;
1753 pub fn soup_session_get_max_conns_per_host(session: *mut SoupSession) -> c_uint;
1754 pub fn soup_session_get_proxy_resolver(session: *mut SoupSession) -> *mut gio::GProxyResolver;
1755 pub fn soup_session_get_remote_connectable(session: *mut SoupSession) -> *mut gio::GSocketConnectable;
1756 pub fn soup_session_get_timeout(session: *mut SoupSession) -> c_uint;
1757 pub fn soup_session_get_tls_database(session: *mut SoupSession) -> *mut gio::GTlsDatabase;
1758 pub fn soup_session_get_tls_interaction(session: *mut SoupSession) -> *mut gio::GTlsInteraction;
1759 pub fn soup_session_get_user_agent(session: *mut SoupSession) -> *const c_char;
1760 pub fn soup_session_has_feature(session: *mut SoupSession, feature_type: GType) -> gboolean;
1761 pub fn soup_session_preconnect_async(session: *mut SoupSession, msg: *mut SoupMessage, io_priority: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
1762 pub fn soup_session_preconnect_finish(session: *mut SoupSession, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean;
1763 pub fn soup_session_remove_feature(session: *mut SoupSession, feature: *mut SoupSessionFeature);
1764 pub fn soup_session_remove_feature_by_type(session: *mut SoupSession, feature_type: GType);
1765 pub fn soup_session_send(session: *mut SoupSession, msg: *mut SoupMessage, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut gio::GInputStream;
1766 pub fn soup_session_send_and_read(session: *mut SoupSession, msg: *mut SoupMessage, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> *mut glib::GBytes;
1767 pub fn soup_session_send_and_read_async(session: *mut SoupSession, msg: *mut SoupMessage, io_priority: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
1768 pub fn soup_session_send_and_read_finish(session: *mut SoupSession, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut glib::GBytes;
1769 #[cfg(feature = "v3_4")]
1770 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
1771 pub fn soup_session_send_and_splice(session: *mut SoupSession, msg: *mut SoupMessage, out_stream: *mut gio::GOutputStream, flags: gio::GOutputStreamSpliceFlags, cancellable: *mut gio::GCancellable, error: *mut *mut glib::GError) -> ssize_t;
1772 #[cfg(feature = "v3_4")]
1773 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
1774 pub fn soup_session_send_and_splice_async(session: *mut SoupSession, msg: *mut SoupMessage, out_stream: *mut gio::GOutputStream, flags: gio::GOutputStreamSpliceFlags, io_priority: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
1775 #[cfg(feature = "v3_4")]
1776 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
1777 pub fn soup_session_send_and_splice_finish(session: *mut SoupSession, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> ssize_t;
1778 pub fn soup_session_send_async(session: *mut SoupSession, msg: *mut SoupMessage, io_priority: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
1779 pub fn soup_session_send_finish(session: *mut SoupSession, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut gio::GInputStream;
1780 pub fn soup_session_set_accept_language(session: *mut SoupSession, accept_language: *const c_char);
1781 pub fn soup_session_set_accept_language_auto(session: *mut SoupSession, accept_language_auto: gboolean);
1782 pub fn soup_session_set_idle_timeout(session: *mut SoupSession, timeout: c_uint);
1783 pub fn soup_session_set_proxy_resolver(session: *mut SoupSession, proxy_resolver: *mut gio::GProxyResolver);
1784 pub fn soup_session_set_timeout(session: *mut SoupSession, timeout: c_uint);
1785 pub fn soup_session_set_tls_database(session: *mut SoupSession, tls_database: *mut gio::GTlsDatabase);
1786 pub fn soup_session_set_tls_interaction(session: *mut SoupSession, tls_interaction: *mut gio::GTlsInteraction);
1787 pub fn soup_session_set_user_agent(session: *mut SoupSession, user_agent: *const c_char);
1788 pub fn soup_session_websocket_connect_async(session: *mut SoupSession, msg: *mut SoupMessage, origin: *const c_char, protocols: *mut *mut c_char, io_priority: c_int, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer);
1789 pub fn soup_session_websocket_connect_finish(session: *mut SoupSession, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> *mut SoupWebsocketConnection;
1790
1791 pub fn soup_websocket_connection_get_type() -> GType;
1795 pub fn soup_websocket_connection_new(stream: *mut gio::GIOStream, uri: *mut glib::GUri, type_: SoupWebsocketConnectionType, origin: *const c_char, protocol: *const c_char, extensions: *mut glib::GList) -> *mut SoupWebsocketConnection;
1796 pub fn soup_websocket_connection_close(self_: *mut SoupWebsocketConnection, code: c_ushort, data: *const c_char);
1797 pub fn soup_websocket_connection_get_close_code(self_: *mut SoupWebsocketConnection) -> c_ushort;
1798 pub fn soup_websocket_connection_get_close_data(self_: *mut SoupWebsocketConnection) -> *const c_char;
1799 pub fn soup_websocket_connection_get_connection_type(self_: *mut SoupWebsocketConnection) -> SoupWebsocketConnectionType;
1800 pub fn soup_websocket_connection_get_extensions(self_: *mut SoupWebsocketConnection) -> *mut glib::GList;
1801 pub fn soup_websocket_connection_get_io_stream(self_: *mut SoupWebsocketConnection) -> *mut gio::GIOStream;
1802 pub fn soup_websocket_connection_get_keepalive_interval(self_: *mut SoupWebsocketConnection) -> c_uint;
1803 #[cfg(feature = "v3_6")]
1804 #[cfg_attr(docsrs, doc(cfg(feature = "v3_6")))]
1805 pub fn soup_websocket_connection_get_keepalive_pong_timeout(self_: *mut SoupWebsocketConnection) -> c_uint;
1806 pub fn soup_websocket_connection_get_max_incoming_payload_size(self_: *mut SoupWebsocketConnection) -> u64;
1807 pub fn soup_websocket_connection_get_origin(self_: *mut SoupWebsocketConnection) -> *const c_char;
1808 pub fn soup_websocket_connection_get_protocol(self_: *mut SoupWebsocketConnection) -> *const c_char;
1809 pub fn soup_websocket_connection_get_state(self_: *mut SoupWebsocketConnection) -> SoupWebsocketState;
1810 pub fn soup_websocket_connection_get_uri(self_: *mut SoupWebsocketConnection) -> *mut glib::GUri;
1811 pub fn soup_websocket_connection_send_binary(self_: *mut SoupWebsocketConnection, data: gconstpointer, length: size_t);
1812 pub fn soup_websocket_connection_send_message(self_: *mut SoupWebsocketConnection, type_: SoupWebsocketDataType, message: *mut glib::GBytes);
1813 pub fn soup_websocket_connection_send_text(self_: *mut SoupWebsocketConnection, text: *const c_char);
1814 pub fn soup_websocket_connection_set_keepalive_interval(self_: *mut SoupWebsocketConnection, interval: c_uint);
1815 #[cfg(feature = "v3_6")]
1816 #[cfg_attr(docsrs, doc(cfg(feature = "v3_6")))]
1817 pub fn soup_websocket_connection_set_keepalive_pong_timeout(self_: *mut SoupWebsocketConnection, pong_timeout: c_uint);
1818 pub fn soup_websocket_connection_set_max_incoming_payload_size(self_: *mut SoupWebsocketConnection, max_incoming_payload_size: u64);
1819
1820 pub fn soup_websocket_extension_get_type() -> GType;
1824 pub fn soup_websocket_extension_configure(extension: *mut SoupWebsocketExtension, connection_type: SoupWebsocketConnectionType, params: *mut glib::GHashTable, error: *mut *mut glib::GError) -> gboolean;
1825 pub fn soup_websocket_extension_get_request_params(extension: *mut SoupWebsocketExtension) -> *mut c_char;
1826 pub fn soup_websocket_extension_get_response_params(extension: *mut SoupWebsocketExtension) -> *mut c_char;
1827 pub fn soup_websocket_extension_process_incoming_message(extension: *mut SoupWebsocketExtension, header: *mut u8, payload: *mut glib::GBytes, error: *mut *mut glib::GError) -> *mut glib::GBytes;
1828 pub fn soup_websocket_extension_process_outgoing_message(extension: *mut SoupWebsocketExtension, header: *mut u8, payload: *mut glib::GBytes, error: *mut *mut glib::GError) -> *mut glib::GBytes;
1829
1830 pub fn soup_websocket_extension_deflate_get_type() -> GType;
1834
1835 pub fn soup_websocket_extension_manager_get_type() -> GType;
1839
1840 pub fn soup_session_feature_get_type() -> GType;
1844
1845 pub fn soup_check_version(major: c_uint, minor: c_uint, micro: c_uint) -> gboolean;
1849 pub fn soup_cookies_free(cookies: *mut glib::GSList);
1850 pub fn soup_cookies_from_request(msg: *mut SoupMessage) -> *mut glib::GSList;
1851 pub fn soup_cookies_from_response(msg: *mut SoupMessage) -> *mut glib::GSList;
1852 pub fn soup_cookies_to_cookie_header(cookies: *mut glib::GSList) -> *mut c_char;
1853 pub fn soup_cookies_to_request(cookies: *mut glib::GSList, msg: *mut SoupMessage);
1854 pub fn soup_cookies_to_response(cookies: *mut glib::GSList, msg: *mut SoupMessage);
1855 pub fn soup_date_time_new_from_http_string(date_string: *const c_char) -> *mut glib::GDateTime;
1856 pub fn soup_date_time_to_string(date: *mut glib::GDateTime, format: SoupDateFormat) -> *mut c_char;
1857 pub fn soup_form_decode(encoded_form: *const c_char) -> *mut glib::GHashTable;
1858 pub fn soup_form_decode_multipart(multipart: *mut SoupMultipart, file_control_name: *const c_char, filename: *mut *mut c_char, content_type: *mut *mut c_char, file: *mut *mut glib::GBytes) -> *mut glib::GHashTable;
1859 pub fn soup_form_encode(first_field: *const c_char, ...) -> *mut c_char;
1860 pub fn soup_form_encode_datalist(form_data_set: *mut *mut glib::GData) -> *mut c_char;
1861 pub fn soup_form_encode_hash(form_data_set: *mut glib::GHashTable) -> *mut c_char;
1862 pub fn soup_get_major_version() -> c_uint;
1864 pub fn soup_get_micro_version() -> c_uint;
1865 pub fn soup_get_minor_version() -> c_uint;
1866 pub fn soup_header_contains(header: *const c_char, token: *const c_char) -> gboolean;
1867 pub fn soup_header_free_list(list: *mut glib::GSList);
1868 pub fn soup_header_free_param_list(param_list: *mut glib::GHashTable);
1869 pub fn soup_header_g_string_append_param(string: *mut glib::GString, name: *const c_char, value: *const c_char);
1870 pub fn soup_header_g_string_append_param_quoted(string: *mut glib::GString, name: *const c_char, value: *const c_char);
1871 pub fn soup_header_parse_list(header: *const c_char) -> *mut glib::GSList;
1872 pub fn soup_header_parse_param_list(header: *const c_char) -> *mut glib::GHashTable;
1873 pub fn soup_header_parse_param_list_strict(header: *const c_char) -> *mut glib::GHashTable;
1874 pub fn soup_header_parse_quality_list(header: *const c_char, unacceptable: *mut *mut glib::GSList) -> *mut glib::GSList;
1875 pub fn soup_header_parse_semi_param_list(header: *const c_char) -> *mut glib::GHashTable;
1876 pub fn soup_header_parse_semi_param_list_strict(header: *const c_char) -> *mut glib::GHashTable;
1877 pub fn soup_headers_parse(str: *const c_char, len: c_int, dest: *mut SoupMessageHeaders) -> gboolean;
1878 pub fn soup_headers_parse_request(str: *const c_char, len: c_int, req_headers: *mut SoupMessageHeaders, req_method: *mut *mut c_char, req_path: *mut *mut c_char, ver: *mut SoupHTTPVersion) -> c_uint;
1879 pub fn soup_headers_parse_response(str: *const c_char, len: c_int, headers: *mut SoupMessageHeaders, ver: *mut SoupHTTPVersion, status_code: *mut c_uint, reason_phrase: *mut *mut c_char) -> gboolean;
1880 pub fn soup_headers_parse_status_line(status_line: *const c_char, ver: *mut SoupHTTPVersion, status_code: *mut c_uint, reason_phrase: *mut *mut c_char) -> gboolean;
1881 pub fn soup_tld_domain_is_public_suffix(domain: *const c_char) -> gboolean;
1882 pub fn soup_tld_get_base_domain(hostname: *const c_char, error: *mut *mut glib::GError) -> *const c_char;
1883 pub fn soup_uri_copy(uri: *mut glib::GUri, first_component: SoupURIComponent, ...) -> *mut glib::GUri;
1884 pub fn soup_uri_decode_data_uri(uri: *const c_char, content_type: *mut *mut c_char) -> *mut glib::GBytes;
1885 pub fn soup_uri_equal(uri1: *mut glib::GUri, uri2: *mut glib::GUri) -> gboolean;
1886 pub fn soup_websocket_client_prepare_handshake(msg: *mut SoupMessage, origin: *const c_char, protocols: *mut *mut c_char, supported_extensions: *mut glib::GPtrArray);
1887 pub fn soup_websocket_client_verify_handshake(msg: *mut SoupMessage, supported_extensions: *mut glib::GPtrArray, accepted_extensions: *mut *mut glib::GList, error: *mut *mut glib::GError) -> gboolean;
1888 pub fn soup_websocket_server_check_handshake(msg: *mut SoupServerMessage, origin: *const c_char, protocols: *mut *mut c_char, supported_extensions: *mut glib::GPtrArray, error: *mut *mut glib::GError) -> gboolean;
1889 pub fn soup_websocket_server_process_handshake(msg: *mut SoupServerMessage, expected_origin: *const c_char, protocols: *mut *mut c_char, supported_extensions: *mut glib::GPtrArray, accepted_extensions: *mut *mut glib::GList) -> gboolean;
1890
1891}