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