1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
7#![allow(
8 clippy::approx_constant,
9 clippy::type_complexity,
10 clippy::unreadable_literal,
11 clippy::upper_case_acronyms
12)]
13#![cfg_attr(docsrs, feature(doc_cfg))]
14
15use gio_sys as gio;
16use glib_sys as glib;
17use gobject_sys as gobject;
18
19#[allow(unused_imports)]
20use libc::{FILE, intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t};
21#[cfg(unix)]
22#[allow(unused_imports)]
23use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
24#[allow(unused_imports)]
25use std::ffi::{
26 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
27};
28
29#[allow(unused_imports)]
30use glib::{GType, gboolean, gconstpointer, gpointer};
31
32pub type SoupCacheType = c_int;
34pub const SOUP_CACHE_SINGLE_USER: SoupCacheType = 0;
35pub const SOUP_CACHE_SHARED: SoupCacheType = 1;
36
37pub type SoupCookieJarAcceptPolicy = c_int;
38pub const SOUP_COOKIE_JAR_ACCEPT_ALWAYS: SoupCookieJarAcceptPolicy = 0;
39pub const SOUP_COOKIE_JAR_ACCEPT_NEVER: SoupCookieJarAcceptPolicy = 1;
40pub const SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY: SoupCookieJarAcceptPolicy = 2;
41pub const SOUP_COOKIE_JAR_ACCEPT_GRANDFATHERED_THIRD_PARTY: SoupCookieJarAcceptPolicy = 3;
42
43pub type SoupDateFormat = c_int;
44pub const SOUP_DATE_HTTP: SoupDateFormat = 1;
45pub const SOUP_DATE_COOKIE: SoupDateFormat = 2;
46
47pub type SoupEncoding = c_int;
48pub const SOUP_ENCODING_UNRECOGNIZED: SoupEncoding = 0;
49pub const SOUP_ENCODING_NONE: SoupEncoding = 1;
50pub const SOUP_ENCODING_CONTENT_LENGTH: SoupEncoding = 2;
51pub const SOUP_ENCODING_EOF: SoupEncoding = 3;
52pub const SOUP_ENCODING_CHUNKED: SoupEncoding = 4;
53pub const SOUP_ENCODING_BYTERANGES: SoupEncoding = 5;
54
55pub type SoupHTTPVersion = c_int;
56pub const SOUP_HTTP_1_0: SoupHTTPVersion = 0;
57pub const SOUP_HTTP_1_1: SoupHTTPVersion = 1;
58pub const SOUP_HTTP_2_0: SoupHTTPVersion = 2;
59
60pub type SoupLoggerLogLevel = c_int;
61pub const SOUP_LOGGER_LOG_NONE: SoupLoggerLogLevel = 0;
62pub const SOUP_LOGGER_LOG_MINIMAL: SoupLoggerLogLevel = 1;
63pub const SOUP_LOGGER_LOG_HEADERS: SoupLoggerLogLevel = 2;
64pub const SOUP_LOGGER_LOG_BODY: SoupLoggerLogLevel = 3;
65
66pub type SoupMemoryUse = c_int;
67pub const SOUP_MEMORY_STATIC: SoupMemoryUse = 0;
68pub const SOUP_MEMORY_TAKE: SoupMemoryUse = 1;
69pub const SOUP_MEMORY_COPY: SoupMemoryUse = 2;
70
71pub type SoupMessageHeadersType = c_int;
72pub const SOUP_MESSAGE_HEADERS_REQUEST: SoupMessageHeadersType = 0;
73pub const SOUP_MESSAGE_HEADERS_RESPONSE: SoupMessageHeadersType = 1;
74pub const SOUP_MESSAGE_HEADERS_MULTIPART: SoupMessageHeadersType = 2;
75
76pub type SoupMessagePriority = c_int;
77pub const SOUP_MESSAGE_PRIORITY_VERY_LOW: SoupMessagePriority = 0;
78pub const SOUP_MESSAGE_PRIORITY_LOW: SoupMessagePriority = 1;
79pub const SOUP_MESSAGE_PRIORITY_NORMAL: SoupMessagePriority = 2;
80pub const SOUP_MESSAGE_PRIORITY_HIGH: SoupMessagePriority = 3;
81pub const SOUP_MESSAGE_PRIORITY_VERY_HIGH: SoupMessagePriority = 4;
82
83pub type SoupSameSitePolicy = c_int;
84pub const SOUP_SAME_SITE_POLICY_NONE: SoupSameSitePolicy = 0;
85pub const SOUP_SAME_SITE_POLICY_LAX: SoupSameSitePolicy = 1;
86pub const SOUP_SAME_SITE_POLICY_STRICT: SoupSameSitePolicy = 2;
87
88pub type SoupSessionError = c_int;
89pub const SOUP_SESSION_ERROR_PARSING: SoupSessionError = 0;
90pub const SOUP_SESSION_ERROR_ENCODING: SoupSessionError = 1;
91pub const SOUP_SESSION_ERROR_TOO_MANY_REDIRECTS: SoupSessionError = 2;
92pub const SOUP_SESSION_ERROR_TOO_MANY_RESTARTS: SoupSessionError = 3;
93pub const SOUP_SESSION_ERROR_REDIRECT_NO_LOCATION: SoupSessionError = 4;
94pub const SOUP_SESSION_ERROR_REDIRECT_BAD_URI: SoupSessionError = 5;
95pub const SOUP_SESSION_ERROR_MESSAGE_ALREADY_IN_QUEUE: SoupSessionError = 6;
96
97pub type SoupStatus = c_int;
98pub const SOUP_STATUS_NONE: SoupStatus = 0;
99pub const SOUP_STATUS_CONTINUE: SoupStatus = 100;
100pub const SOUP_STATUS_SWITCHING_PROTOCOLS: SoupStatus = 101;
101pub const SOUP_STATUS_PROCESSING: SoupStatus = 102;
102pub const SOUP_STATUS_OK: SoupStatus = 200;
103pub const SOUP_STATUS_CREATED: SoupStatus = 201;
104pub const SOUP_STATUS_ACCEPTED: SoupStatus = 202;
105pub const SOUP_STATUS_NON_AUTHORITATIVE: SoupStatus = 203;
106pub const SOUP_STATUS_NO_CONTENT: SoupStatus = 204;
107pub const SOUP_STATUS_RESET_CONTENT: SoupStatus = 205;
108pub const SOUP_STATUS_PARTIAL_CONTENT: SoupStatus = 206;
109pub const SOUP_STATUS_MULTI_STATUS: SoupStatus = 207;
110pub const SOUP_STATUS_MULTIPLE_CHOICES: SoupStatus = 300;
111pub const SOUP_STATUS_MOVED_PERMANENTLY: SoupStatus = 301;
112pub const SOUP_STATUS_FOUND: SoupStatus = 302;
113pub const SOUP_STATUS_MOVED_TEMPORARILY: SoupStatus = 302;
114pub const SOUP_STATUS_SEE_OTHER: SoupStatus = 303;
115pub const SOUP_STATUS_NOT_MODIFIED: SoupStatus = 304;
116pub const SOUP_STATUS_USE_PROXY: SoupStatus = 305;
117pub const SOUP_STATUS_NOT_APPEARING_IN_THIS_PROTOCOL: SoupStatus = 306;
118pub const SOUP_STATUS_TEMPORARY_REDIRECT: SoupStatus = 307;
119pub const SOUP_STATUS_PERMANENT_REDIRECT: SoupStatus = 308;
120pub const SOUP_STATUS_BAD_REQUEST: SoupStatus = 400;
121pub const SOUP_STATUS_UNAUTHORIZED: SoupStatus = 401;
122pub const SOUP_STATUS_PAYMENT_REQUIRED: SoupStatus = 402;
123pub const SOUP_STATUS_FORBIDDEN: SoupStatus = 403;
124pub const SOUP_STATUS_NOT_FOUND: SoupStatus = 404;
125pub const SOUP_STATUS_METHOD_NOT_ALLOWED: SoupStatus = 405;
126pub const SOUP_STATUS_NOT_ACCEPTABLE: SoupStatus = 406;
127pub const SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED: SoupStatus = 407;
128pub const SOUP_STATUS_PROXY_UNAUTHORIZED: SoupStatus = 407;
129pub const SOUP_STATUS_REQUEST_TIMEOUT: SoupStatus = 408;
130pub const SOUP_STATUS_CONFLICT: SoupStatus = 409;
131pub const SOUP_STATUS_GONE: SoupStatus = 410;
132pub const SOUP_STATUS_LENGTH_REQUIRED: SoupStatus = 411;
133pub const SOUP_STATUS_PRECONDITION_FAILED: SoupStatus = 412;
134pub const SOUP_STATUS_REQUEST_ENTITY_TOO_LARGE: SoupStatus = 413;
135pub const SOUP_STATUS_REQUEST_URI_TOO_LONG: SoupStatus = 414;
136pub const SOUP_STATUS_UNSUPPORTED_MEDIA_TYPE: SoupStatus = 415;
137pub const SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE: SoupStatus = 416;
138pub const SOUP_STATUS_INVALID_RANGE: SoupStatus = 416;
139pub const SOUP_STATUS_EXPECTATION_FAILED: SoupStatus = 417;
140pub const SOUP_STATUS_MISDIRECTED_REQUEST: SoupStatus = 421;
141pub const SOUP_STATUS_UNPROCESSABLE_ENTITY: SoupStatus = 422;
142pub const SOUP_STATUS_LOCKED: SoupStatus = 423;
143pub const SOUP_STATUS_FAILED_DEPENDENCY: SoupStatus = 424;
144pub const SOUP_STATUS_INTERNAL_SERVER_ERROR: SoupStatus = 500;
145pub const SOUP_STATUS_NOT_IMPLEMENTED: SoupStatus = 501;
146pub const SOUP_STATUS_BAD_GATEWAY: SoupStatus = 502;
147pub const SOUP_STATUS_SERVICE_UNAVAILABLE: SoupStatus = 503;
148pub const SOUP_STATUS_GATEWAY_TIMEOUT: SoupStatus = 504;
149pub const SOUP_STATUS_HTTP_VERSION_NOT_SUPPORTED: SoupStatus = 505;
150pub const SOUP_STATUS_INSUFFICIENT_STORAGE: SoupStatus = 507;
151pub const SOUP_STATUS_NOT_EXTENDED: SoupStatus = 510;
152
153pub type SoupTLDError = c_int;
154pub const SOUP_TLD_ERROR_INVALID_HOSTNAME: SoupTLDError = 0;
155pub const SOUP_TLD_ERROR_IS_IP_ADDRESS: SoupTLDError = 1;
156pub const SOUP_TLD_ERROR_NOT_ENOUGH_DOMAINS: SoupTLDError = 2;
157pub const SOUP_TLD_ERROR_NO_BASE_DOMAIN: SoupTLDError = 3;
158pub const SOUP_TLD_ERROR_NO_PSL_DATA: SoupTLDError = 4;
159
160pub type SoupURIComponent = c_int;
161pub const SOUP_URI_NONE: SoupURIComponent = 0;
162pub const SOUP_URI_SCHEME: SoupURIComponent = 1;
163pub const SOUP_URI_USER: SoupURIComponent = 2;
164pub const SOUP_URI_PASSWORD: SoupURIComponent = 3;
165pub const SOUP_URI_AUTH_PARAMS: SoupURIComponent = 4;
166pub const SOUP_URI_HOST: SoupURIComponent = 5;
167pub const SOUP_URI_PORT: SoupURIComponent = 6;
168pub const SOUP_URI_PATH: SoupURIComponent = 7;
169pub const SOUP_URI_QUERY: SoupURIComponent = 8;
170pub const SOUP_URI_FRAGMENT: SoupURIComponent = 9;
171
172pub type SoupWebsocketCloseCode = c_int;
173pub const SOUP_WEBSOCKET_CLOSE_NORMAL: SoupWebsocketCloseCode = 1000;
174pub const SOUP_WEBSOCKET_CLOSE_GOING_AWAY: SoupWebsocketCloseCode = 1001;
175pub const SOUP_WEBSOCKET_CLOSE_PROTOCOL_ERROR: SoupWebsocketCloseCode = 1002;
176pub const SOUP_WEBSOCKET_CLOSE_UNSUPPORTED_DATA: SoupWebsocketCloseCode = 1003;
177pub const SOUP_WEBSOCKET_CLOSE_NO_STATUS: SoupWebsocketCloseCode = 1005;
178pub const SOUP_WEBSOCKET_CLOSE_ABNORMAL: SoupWebsocketCloseCode = 1006;
179pub const SOUP_WEBSOCKET_CLOSE_BAD_DATA: SoupWebsocketCloseCode = 1007;
180pub const SOUP_WEBSOCKET_CLOSE_POLICY_VIOLATION: SoupWebsocketCloseCode = 1008;
181pub const SOUP_WEBSOCKET_CLOSE_TOO_BIG: SoupWebsocketCloseCode = 1009;
182pub const SOUP_WEBSOCKET_CLOSE_NO_EXTENSION: SoupWebsocketCloseCode = 1010;
183pub const SOUP_WEBSOCKET_CLOSE_SERVER_ERROR: SoupWebsocketCloseCode = 1011;
184pub const SOUP_WEBSOCKET_CLOSE_TLS_HANDSHAKE: SoupWebsocketCloseCode = 1015;
185
186pub type SoupWebsocketConnectionType = c_int;
187pub const SOUP_WEBSOCKET_CONNECTION_UNKNOWN: SoupWebsocketConnectionType = 0;
188pub const SOUP_WEBSOCKET_CONNECTION_CLIENT: SoupWebsocketConnectionType = 1;
189pub const SOUP_WEBSOCKET_CONNECTION_SERVER: SoupWebsocketConnectionType = 2;
190
191pub type SoupWebsocketDataType = c_int;
192pub const SOUP_WEBSOCKET_DATA_TEXT: SoupWebsocketDataType = 1;
193pub const SOUP_WEBSOCKET_DATA_BINARY: SoupWebsocketDataType = 2;
194
195pub type SoupWebsocketError = c_int;
196pub const SOUP_WEBSOCKET_ERROR_FAILED: SoupWebsocketError = 0;
197pub const SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET: SoupWebsocketError = 1;
198pub const SOUP_WEBSOCKET_ERROR_BAD_HANDSHAKE: SoupWebsocketError = 2;
199pub const SOUP_WEBSOCKET_ERROR_BAD_ORIGIN: SoupWebsocketError = 3;
200
201pub type SoupWebsocketState = c_int;
202pub const SOUP_WEBSOCKET_STATE_OPEN: SoupWebsocketState = 1;
203pub const SOUP_WEBSOCKET_STATE_CLOSING: SoupWebsocketState = 2;
204pub const SOUP_WEBSOCKET_STATE_CLOSED: SoupWebsocketState = 3;
205
206pub const SOUP_COOKIE_MAX_AGE_ONE_DAY: c_int = 0;
208pub const SOUP_COOKIE_MAX_AGE_ONE_HOUR: c_int = 3600;
209pub const SOUP_COOKIE_MAX_AGE_ONE_WEEK: c_int = 0;
210pub const SOUP_COOKIE_MAX_AGE_ONE_YEAR: c_int = 0;
211pub const SOUP_FORM_MIME_TYPE_MULTIPART: &[u8] = b"multipart/form-data\0";
212pub const SOUP_FORM_MIME_TYPE_URLENCODED: &[u8] = b"application/x-www-form-urlencoded\0";
213pub const SOUP_HSTS_POLICY_MAX_AGE_PAST: c_int = 0;
214pub const SOUP_HTTP_URI_FLAGS: c_int = 482;
215
216pub type SoupCacheability = c_uint;
218pub const SOUP_CACHE_CACHEABLE: SoupCacheability = 1;
219pub const SOUP_CACHE_UNCACHEABLE: SoupCacheability = 2;
220pub const SOUP_CACHE_INVALIDATES: SoupCacheability = 4;
221pub const SOUP_CACHE_VALIDATES: SoupCacheability = 8;
222
223pub type SoupExpectation = c_uint;
224pub const SOUP_EXPECTATION_UNRECOGNIZED: SoupExpectation = 1;
225pub const SOUP_EXPECTATION_CONTINUE: SoupExpectation = 2;
226
227pub type SoupMessageFlags = c_uint;
228pub const SOUP_MESSAGE_NO_REDIRECT: SoupMessageFlags = 2;
229pub const SOUP_MESSAGE_NEW_CONNECTION: SoupMessageFlags = 4;
230pub const SOUP_MESSAGE_IDEMPOTENT: SoupMessageFlags = 8;
231pub const SOUP_MESSAGE_DO_NOT_USE_AUTH_CACHE: SoupMessageFlags = 16;
232pub const SOUP_MESSAGE_COLLECT_METRICS: SoupMessageFlags = 32;
233
234pub type SoupServerListenOptions = c_uint;
235pub const SOUP_SERVER_LISTEN_HTTPS: SoupServerListenOptions = 1;
236pub const SOUP_SERVER_LISTEN_IPV4_ONLY: SoupServerListenOptions = 2;
237pub const SOUP_SERVER_LISTEN_IPV6_ONLY: SoupServerListenOptions = 4;
238
239pub type SoupAuthDomainBasicAuthCallback = Option<
241 unsafe extern "C" fn(
242 *mut SoupAuthDomainBasic,
243 *mut SoupServerMessage,
244 *const c_char,
245 *const c_char,
246 gpointer,
247 ) -> gboolean,
248>;
249pub type SoupAuthDomainDigestAuthCallback = Option<
250 unsafe extern "C" fn(
251 *mut SoupAuthDomainDigest,
252 *mut SoupServerMessage,
253 *const c_char,
254 gpointer,
255 ) -> *mut c_char,
256>;
257pub type SoupAuthDomainFilter =
258 Option<unsafe extern "C" fn(*mut SoupAuthDomain, *mut SoupServerMessage, gpointer) -> gboolean>;
259pub type SoupAuthDomainGenericAuthCallback = Option<
260 unsafe extern "C" fn(
261 *mut SoupAuthDomain,
262 *mut SoupServerMessage,
263 *const c_char,
264 gpointer,
265 ) -> gboolean,
266>;
267pub type SoupLoggerFilter =
268 Option<unsafe extern "C" fn(*mut SoupLogger, *mut SoupMessage, gpointer) -> SoupLoggerLogLevel>;
269pub type SoupLoggerPrinter = Option<
270 unsafe extern "C" fn(*mut SoupLogger, SoupLoggerLogLevel, c_char, *const c_char, gpointer),
271>;
272pub type SoupMessageHeadersForeachFunc =
273 Option<unsafe extern "C" fn(*const c_char, *const c_char, gpointer)>;
274pub type SoupServerCallback = Option<
275 unsafe extern "C" fn(
276 *mut SoupServer,
277 *mut SoupServerMessage,
278 *const c_char,
279 *mut glib::GHashTable,
280 gpointer,
281 ),
282>;
283pub type SoupServerWebsocketCallback = Option<
284 unsafe extern "C" fn(
285 *mut SoupServer,
286 *mut SoupServerMessage,
287 *const c_char,
288 *mut SoupWebsocketConnection,
289 gpointer,
290 ),
291>;
292
293#[derive(Copy, Clone)]
295#[repr(C)]
296pub struct SoupAuthClass {
297 pub parent_class: gobject::GObjectClass,
298 pub scheme_name: *const c_char,
299 pub strength: c_uint,
300 pub update: Option<
301 unsafe extern "C" fn(*mut SoupAuth, *mut SoupMessage, *mut glib::GHashTable) -> gboolean,
302 >,
303 pub get_protection_space:
304 Option<unsafe extern "C" fn(*mut SoupAuth, *mut glib::GUri) -> *mut glib::GSList>,
305 pub authenticate: Option<unsafe extern "C" fn(*mut SoupAuth, *const c_char, *const c_char)>,
306 pub is_authenticated: Option<unsafe extern "C" fn(*mut SoupAuth) -> gboolean>,
307 pub get_authorization:
308 Option<unsafe extern "C" fn(*mut SoupAuth, *mut SoupMessage) -> *mut c_char>,
309 pub is_ready: Option<unsafe extern "C" fn(*mut SoupAuth, *mut SoupMessage) -> gboolean>,
310 pub can_authenticate: Option<unsafe extern "C" fn(*mut SoupAuth) -> gboolean>,
311 pub padding: [gpointer; 6],
312}
313
314impl ::std::fmt::Debug for SoupAuthClass {
315 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
316 f.debug_struct(&format!("SoupAuthClass @ {self:p}"))
317 .field("parent_class", &self.parent_class)
318 .field("scheme_name", &self.scheme_name)
319 .field("strength", &self.strength)
320 .field("update", &self.update)
321 .field("get_protection_space", &self.get_protection_space)
322 .field("authenticate", &self.authenticate)
323 .field("is_authenticated", &self.is_authenticated)
324 .field("get_authorization", &self.get_authorization)
325 .field("is_ready", &self.is_ready)
326 .field("can_authenticate", &self.can_authenticate)
327 .field("padding", &self.padding)
328 .finish()
329 }
330}
331
332#[derive(Copy, Clone)]
333#[repr(C)]
334pub struct SoupAuthDomainBasicClass {
335 pub parent_class: SoupAuthDomainClass,
336}
337
338impl ::std::fmt::Debug for SoupAuthDomainBasicClass {
339 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
340 f.debug_struct(&format!("SoupAuthDomainBasicClass @ {self:p}"))
341 .field("parent_class", &self.parent_class)
342 .finish()
343 }
344}
345
346#[derive(Copy, Clone)]
347#[repr(C)]
348pub struct SoupAuthDomainClass {
349 pub parent_class: gobject::GObjectClass,
350 pub accepts: Option<
351 unsafe extern "C" fn(
352 *mut SoupAuthDomain,
353 *mut SoupServerMessage,
354 *const c_char,
355 ) -> *mut c_char,
356 >,
357 pub challenge:
358 Option<unsafe extern "C" fn(*mut SoupAuthDomain, *mut SoupServerMessage) -> *mut c_char>,
359 pub check_password: Option<
360 unsafe extern "C" fn(
361 *mut SoupAuthDomain,
362 *mut SoupServerMessage,
363 *const c_char,
364 *const c_char,
365 ) -> gboolean,
366 >,
367 pub padding: [gpointer; 6],
368}
369
370impl ::std::fmt::Debug for SoupAuthDomainClass {
371 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
372 f.debug_struct(&format!("SoupAuthDomainClass @ {self:p}"))
373 .field("parent_class", &self.parent_class)
374 .field("accepts", &self.accepts)
375 .field("challenge", &self.challenge)
376 .field("check_password", &self.check_password)
377 .field("padding", &self.padding)
378 .finish()
379 }
380}
381
382#[derive(Copy, Clone)]
383#[repr(C)]
384pub struct SoupAuthDomainDigestClass {
385 pub parent_class: SoupAuthDomainClass,
386}
387
388impl ::std::fmt::Debug for SoupAuthDomainDigestClass {
389 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
390 f.debug_struct(&format!("SoupAuthDomainDigestClass @ {self:p}"))
391 .field("parent_class", &self.parent_class)
392 .finish()
393 }
394}
395
396#[derive(Copy, Clone)]
397#[repr(C)]
398pub struct SoupAuthManagerClass {
399 pub parent_class: gobject::GObjectClass,
400}
401
402impl ::std::fmt::Debug for SoupAuthManagerClass {
403 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
404 f.debug_struct(&format!("SoupAuthManagerClass @ {self:p}"))
405 .field("parent_class", &self.parent_class)
406 .finish()
407 }
408}
409
410#[derive(Copy, Clone)]
411#[repr(C)]
412pub struct SoupCacheClass {
413 pub parent_class: gobject::GObjectClass,
414 pub get_cacheability:
415 Option<unsafe extern "C" fn(*mut SoupCache, *mut SoupMessage) -> SoupCacheability>,
416 pub padding: [gpointer; 4],
417}
418
419impl ::std::fmt::Debug for SoupCacheClass {
420 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
421 f.debug_struct(&format!("SoupCacheClass @ {self:p}"))
422 .field("parent_class", &self.parent_class)
423 .field("get_cacheability", &self.get_cacheability)
424 .field("padding", &self.padding)
425 .finish()
426 }
427}
428
429#[derive(Copy, Clone)]
430#[repr(C)]
431pub struct SoupContentDecoderClass {
432 pub parent_class: gobject::GObjectClass,
433}
434
435impl ::std::fmt::Debug for SoupContentDecoderClass {
436 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
437 f.debug_struct(&format!("SoupContentDecoderClass @ {self:p}"))
438 .field("parent_class", &self.parent_class)
439 .finish()
440 }
441}
442
443#[derive(Copy, Clone)]
444#[repr(C)]
445pub struct SoupContentSnifferClass {
446 pub parent_class: gobject::GObjectClass,
447}
448
449impl ::std::fmt::Debug for SoupContentSnifferClass {
450 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
451 f.debug_struct(&format!("SoupContentSnifferClass @ {self:p}"))
452 .field("parent_class", &self.parent_class)
453 .finish()
454 }
455}
456
457#[repr(C)]
458#[allow(dead_code)]
459pub struct SoupCookie {
460 _data: [u8; 0],
461 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
462}
463
464impl ::std::fmt::Debug for SoupCookie {
465 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
466 f.debug_struct(&format!("SoupCookie @ {self:p}")).finish()
467 }
468}
469
470#[derive(Copy, Clone)]
471#[repr(C)]
472pub struct SoupCookieJarClass {
473 pub parent_class: gobject::GObjectClass,
474 pub save: Option<unsafe extern "C" fn(*mut SoupCookieJar)>,
475 pub is_persistent: Option<unsafe extern "C" fn(*mut SoupCookieJar) -> gboolean>,
476 pub changed: Option<unsafe extern "C" fn(*mut SoupCookieJar, *mut SoupCookie, *mut SoupCookie)>,
477 pub padding: [gpointer; 6],
478}
479
480impl ::std::fmt::Debug for SoupCookieJarClass {
481 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
482 f.debug_struct(&format!("SoupCookieJarClass @ {self:p}"))
483 .field("parent_class", &self.parent_class)
484 .field("save", &self.save)
485 .field("is_persistent", &self.is_persistent)
486 .field("changed", &self.changed)
487 .field("padding", &self.padding)
488 .finish()
489 }
490}
491
492#[derive(Copy, Clone)]
493#[repr(C)]
494pub struct SoupCookieJarDBClass {
495 pub parent_class: SoupCookieJarClass,
496}
497
498impl ::std::fmt::Debug for SoupCookieJarDBClass {
499 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
500 f.debug_struct(&format!("SoupCookieJarDBClass @ {self:p}"))
501 .field("parent_class", &self.parent_class)
502 .finish()
503 }
504}
505
506#[derive(Copy, Clone)]
507#[repr(C)]
508pub struct SoupCookieJarTextClass {
509 pub parent_class: SoupCookieJarClass,
510}
511
512impl ::std::fmt::Debug for SoupCookieJarTextClass {
513 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
514 f.debug_struct(&format!("SoupCookieJarTextClass @ {self:p}"))
515 .field("parent_class", &self.parent_class)
516 .finish()
517 }
518}
519
520#[derive(Copy, Clone)]
521#[repr(C)]
522pub struct SoupHSTSEnforcerClass {
523 pub parent_class: gobject::GObjectClass,
524 pub is_persistent: Option<unsafe extern "C" fn(*mut SoupHSTSEnforcer) -> gboolean>,
525 pub has_valid_policy:
526 Option<unsafe extern "C" fn(*mut SoupHSTSEnforcer, *const c_char) -> gboolean>,
527 pub changed: Option<
528 unsafe extern "C" fn(*mut SoupHSTSEnforcer, *mut SoupHSTSPolicy, *mut SoupHSTSPolicy),
529 >,
530 pub padding: [gpointer; 4],
531}
532
533impl ::std::fmt::Debug for SoupHSTSEnforcerClass {
534 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
535 f.debug_struct(&format!("SoupHSTSEnforcerClass @ {self:p}"))
536 .field("parent_class", &self.parent_class)
537 .field("is_persistent", &self.is_persistent)
538 .field("has_valid_policy", &self.has_valid_policy)
539 .field("changed", &self.changed)
540 .finish()
541 }
542}
543
544#[derive(Copy, Clone)]
545#[repr(C)]
546pub struct SoupHSTSEnforcerDBClass {
547 pub parent_class: SoupHSTSEnforcerClass,
548}
549
550impl ::std::fmt::Debug for SoupHSTSEnforcerDBClass {
551 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
552 f.debug_struct(&format!("SoupHSTSEnforcerDBClass @ {self:p}"))
553 .field("parent_class", &self.parent_class)
554 .finish()
555 }
556}
557
558#[repr(C)]
559#[allow(dead_code)]
560pub struct SoupHSTSPolicy {
561 _data: [u8; 0],
562 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
563}
564
565impl ::std::fmt::Debug for SoupHSTSPolicy {
566 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
567 f.debug_struct(&format!("SoupHSTSPolicy @ {self:p}"))
568 .finish()
569 }
570}
571
572#[derive(Copy, Clone)]
573#[repr(C)]
574pub struct SoupLoggerClass {
575 pub parent_class: gobject::GObjectClass,
576}
577
578impl ::std::fmt::Debug for SoupLoggerClass {
579 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
580 f.debug_struct(&format!("SoupLoggerClass @ {self:p}"))
581 .field("parent_class", &self.parent_class)
582 .finish()
583 }
584}
585
586#[derive(Copy, Clone)]
587#[repr(C)]
588pub struct SoupMessageBody {
589 pub data: *const u8,
590 pub length: i64,
591}
592
593impl ::std::fmt::Debug for SoupMessageBody {
594 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
595 f.debug_struct(&format!("SoupMessageBody @ {self:p}"))
596 .field("data", &self.data)
597 .field("length", &self.length)
598 .finish()
599 }
600}
601
602#[derive(Copy, Clone)]
603#[repr(C)]
604pub struct SoupMessageClass {
605 pub parent_class: gobject::GObjectClass,
606}
607
608impl ::std::fmt::Debug for SoupMessageClass {
609 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
610 f.debug_struct(&format!("SoupMessageClass @ {self:p}"))
611 .field("parent_class", &self.parent_class)
612 .finish()
613 }
614}
615
616#[repr(C)]
617#[allow(dead_code)]
618pub struct SoupMessageHeaders {
619 _data: [u8; 0],
620 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
621}
622
623impl ::std::fmt::Debug for SoupMessageHeaders {
624 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
625 f.debug_struct(&format!("SoupMessageHeaders @ {self:p}"))
626 .finish()
627 }
628}
629
630#[derive(Copy, Clone)]
631#[repr(C)]
632pub struct SoupMessageHeadersIter {
633 pub dummy: [gpointer; 3],
634}
635
636impl ::std::fmt::Debug for SoupMessageHeadersIter {
637 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
638 f.debug_struct(&format!("SoupMessageHeadersIter @ {self:p}"))
639 .finish()
640 }
641}
642
643#[repr(C)]
644#[allow(dead_code)]
645pub struct SoupMessageMetrics {
646 _data: [u8; 0],
647 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
648}
649
650impl ::std::fmt::Debug for SoupMessageMetrics {
651 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
652 f.debug_struct(&format!("SoupMessageMetrics @ {self:p}"))
653 .finish()
654 }
655}
656
657#[repr(C)]
658#[allow(dead_code)]
659pub struct SoupMultipart {
660 _data: [u8; 0],
661 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
662}
663
664impl ::std::fmt::Debug for SoupMultipart {
665 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
666 f.debug_struct(&format!("SoupMultipart @ {self:p}"))
667 .finish()
668 }
669}
670
671#[derive(Copy, Clone)]
672#[repr(C)]
673pub struct SoupMultipartInputStreamClass {
674 pub parent_class: gio::GFilterInputStreamClass,
675}
676
677impl ::std::fmt::Debug for SoupMultipartInputStreamClass {
678 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
679 f.debug_struct(&format!("SoupMultipartInputStreamClass @ {self:p}"))
680 .field("parent_class", &self.parent_class)
681 .finish()
682 }
683}
684
685#[derive(Copy, Clone)]
686#[repr(C)]
687pub struct SoupRange {
688 pub start: i64,
689 pub end: i64,
690}
691
692impl ::std::fmt::Debug for SoupRange {
693 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
694 f.debug_struct(&format!("SoupRange @ {self:p}"))
695 .field("start", &self.start)
696 .field("end", &self.end)
697 .finish()
698 }
699}
700
701#[derive(Copy, Clone)]
702#[repr(C)]
703pub struct SoupServerClass {
704 pub parent_class: gobject::GObjectClass,
705 pub request_started: Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage)>,
706 pub request_read: Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage)>,
707 pub request_finished: Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage)>,
708 pub request_aborted: Option<unsafe extern "C" fn(*mut SoupServer, *mut SoupServerMessage)>,
709 pub padding: [gpointer; 6],
710}
711
712impl ::std::fmt::Debug for SoupServerClass {
713 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
714 f.debug_struct(&format!("SoupServerClass @ {self:p}"))
715 .field("parent_class", &self.parent_class)
716 .field("request_started", &self.request_started)
717 .field("request_read", &self.request_read)
718 .field("request_finished", &self.request_finished)
719 .field("request_aborted", &self.request_aborted)
720 .field("padding", &self.padding)
721 .finish()
722 }
723}
724
725#[derive(Copy, Clone)]
726#[repr(C)]
727pub struct SoupServerMessageClass {
728 pub parent_class: gobject::GObjectClass,
729}
730
731impl ::std::fmt::Debug for SoupServerMessageClass {
732 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
733 f.debug_struct(&format!("SoupServerMessageClass @ {self:p}"))
734 .field("parent_class", &self.parent_class)
735 .finish()
736 }
737}
738
739#[derive(Copy, Clone)]
740#[repr(C)]
741pub struct SoupSessionClass {
742 pub parent_class: gobject::GObjectClass,
743 pub request_queued: Option<unsafe extern "C" fn(*mut SoupSession, *mut SoupMessage)>,
744 pub request_unqueued: Option<unsafe extern "C" fn(*mut SoupSession, *mut SoupMessage)>,
745 pub _soup_reserved1: Option<unsafe extern "C" fn()>,
746 pub _soup_reserved2: Option<unsafe extern "C" fn()>,
747 pub _soup_reserved3: Option<unsafe extern "C" fn()>,
748 pub _soup_reserved4: Option<unsafe extern "C" fn()>,
749 pub _soup_reserved5: Option<unsafe extern "C" fn()>,
750 pub _soup_reserved6: Option<unsafe extern "C" fn()>,
751 pub _soup_reserved7: Option<unsafe extern "C" fn()>,
752 pub _soup_reserved8: Option<unsafe extern "C" fn()>,
753}
754
755impl ::std::fmt::Debug for SoupSessionClass {
756 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
757 f.debug_struct(&format!("SoupSessionClass @ {self:p}"))
758 .field("parent_class", &self.parent_class)
759 .field("request_queued", &self.request_queued)
760 .field("request_unqueued", &self.request_unqueued)
761 .field("_soup_reserved1", &self._soup_reserved1)
762 .field("_soup_reserved2", &self._soup_reserved2)
763 .field("_soup_reserved3", &self._soup_reserved3)
764 .field("_soup_reserved4", &self._soup_reserved4)
765 .field("_soup_reserved5", &self._soup_reserved5)
766 .field("_soup_reserved6", &self._soup_reserved6)
767 .field("_soup_reserved7", &self._soup_reserved7)
768 .field("_soup_reserved8", &self._soup_reserved8)
769 .finish()
770 }
771}
772
773#[repr(C)]
774#[allow(dead_code)]
775pub struct _SoupSessionFeatureInterface {
776 _data: [u8; 0],
777 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
778}
779
780pub type SoupSessionFeatureInterface = _SoupSessionFeatureInterface;
781
782#[derive(Copy, Clone)]
783#[repr(C)]
784pub struct SoupWebsocketConnectionClass {
785 pub parent_class: gobject::GObjectClass,
786}
787
788impl ::std::fmt::Debug for SoupWebsocketConnectionClass {
789 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
790 f.debug_struct(&format!("SoupWebsocketConnectionClass @ {self:p}"))
791 .field("parent_class", &self.parent_class)
792 .finish()
793 }
794}
795
796#[derive(Copy, Clone)]
797#[repr(C)]
798pub struct SoupWebsocketExtensionClass {
799 pub parent_class: gobject::GObjectClass,
800 pub name: *const c_char,
801 pub configure: Option<
802 unsafe extern "C" fn(
803 *mut SoupWebsocketExtension,
804 SoupWebsocketConnectionType,
805 *mut glib::GHashTable,
806 *mut *mut glib::GError,
807 ) -> gboolean,
808 >,
809 pub get_request_params:
810 Option<unsafe extern "C" fn(*mut SoupWebsocketExtension) -> *mut c_char>,
811 pub get_response_params:
812 Option<unsafe extern "C" fn(*mut SoupWebsocketExtension) -> *mut c_char>,
813 pub process_outgoing_message: Option<
814 unsafe extern "C" fn(
815 *mut SoupWebsocketExtension,
816 *mut u8,
817 *mut glib::GBytes,
818 *mut *mut glib::GError,
819 ) -> *mut glib::GBytes,
820 >,
821 pub process_incoming_message: Option<
822 unsafe extern "C" fn(
823 *mut SoupWebsocketExtension,
824 *mut u8,
825 *mut glib::GBytes,
826 *mut *mut glib::GError,
827 ) -> *mut glib::GBytes,
828 >,
829 pub padding: [gpointer; 6],
830}
831
832impl ::std::fmt::Debug for SoupWebsocketExtensionClass {
833 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
834 f.debug_struct(&format!("SoupWebsocketExtensionClass @ {self:p}"))
835 .field("parent_class", &self.parent_class)
836 .field("name", &self.name)
837 .field("configure", &self.configure)
838 .field("get_request_params", &self.get_request_params)
839 .field("get_response_params", &self.get_response_params)
840 .field("process_outgoing_message", &self.process_outgoing_message)
841 .field("process_incoming_message", &self.process_incoming_message)
842 .finish()
843 }
844}
845
846#[derive(Copy, Clone)]
847#[repr(C)]
848pub struct SoupWebsocketExtensionDeflateClass {
849 pub parent_class: SoupWebsocketExtensionClass,
850}
851
852impl ::std::fmt::Debug for SoupWebsocketExtensionDeflateClass {
853 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
854 f.debug_struct(&format!("SoupWebsocketExtensionDeflateClass @ {self:p}"))
855 .field("parent_class", &self.parent_class)
856 .finish()
857 }
858}
859
860#[derive(Copy, Clone)]
861#[repr(C)]
862pub struct SoupWebsocketExtensionManagerClass {
863 pub parent_class: gobject::GObjectClass,
864}
865
866impl ::std::fmt::Debug for SoupWebsocketExtensionManagerClass {
867 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
868 f.debug_struct(&format!("SoupWebsocketExtensionManagerClass @ {self:p}"))
869 .field("parent_class", &self.parent_class)
870 .finish()
871 }
872}
873
874#[derive(Copy, Clone)]
876#[repr(C)]
877pub struct SoupAuth {
878 pub parent_instance: gobject::GObject,
879}
880
881impl ::std::fmt::Debug for SoupAuth {
882 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
883 f.debug_struct(&format!("SoupAuth @ {self:p}"))
884 .field("parent_instance", &self.parent_instance)
885 .finish()
886 }
887}
888
889#[repr(C)]
890#[allow(dead_code)]
891pub struct SoupAuthBasic {
892 _data: [u8; 0],
893 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
894}
895
896impl ::std::fmt::Debug for SoupAuthBasic {
897 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
898 f.debug_struct(&format!("SoupAuthBasic @ {self:p}"))
899 .finish()
900 }
901}
902
903#[repr(C)]
904#[allow(dead_code)]
905pub struct SoupAuthDigest {
906 _data: [u8; 0],
907 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
908}
909
910impl ::std::fmt::Debug for SoupAuthDigest {
911 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
912 f.debug_struct(&format!("SoupAuthDigest @ {self:p}"))
913 .finish()
914 }
915}
916
917#[derive(Copy, Clone)]
918#[repr(C)]
919pub struct SoupAuthDomain {
920 pub parent_instance: gobject::GObject,
921}
922
923impl ::std::fmt::Debug for SoupAuthDomain {
924 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
925 f.debug_struct(&format!("SoupAuthDomain @ {self:p}"))
926 .field("parent_instance", &self.parent_instance)
927 .finish()
928 }
929}
930
931#[repr(C)]
932#[allow(dead_code)]
933pub struct SoupAuthDomainBasic {
934 _data: [u8; 0],
935 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
936}
937
938impl ::std::fmt::Debug for SoupAuthDomainBasic {
939 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
940 f.debug_struct(&format!("SoupAuthDomainBasic @ {self:p}"))
941 .finish()
942 }
943}
944
945#[repr(C)]
946#[allow(dead_code)]
947pub struct SoupAuthDomainDigest {
948 _data: [u8; 0],
949 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
950}
951
952impl ::std::fmt::Debug for SoupAuthDomainDigest {
953 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
954 f.debug_struct(&format!("SoupAuthDomainDigest @ {self:p}"))
955 .finish()
956 }
957}
958
959#[repr(C)]
960#[allow(dead_code)]
961pub struct SoupAuthManager {
962 _data: [u8; 0],
963 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
964}
965
966impl ::std::fmt::Debug for SoupAuthManager {
967 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
968 f.debug_struct(&format!("SoupAuthManager @ {self:p}"))
969 .finish()
970 }
971}
972
973#[repr(C)]
974#[allow(dead_code)]
975pub struct SoupAuthNTLM {
976 _data: [u8; 0],
977 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
978}
979
980impl ::std::fmt::Debug for SoupAuthNTLM {
981 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
982 f.debug_struct(&format!("SoupAuthNTLM @ {self:p}")).finish()
983 }
984}
985
986#[repr(C)]
987#[allow(dead_code)]
988pub struct SoupAuthNegotiate {
989 _data: [u8; 0],
990 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
991}
992
993impl ::std::fmt::Debug for SoupAuthNegotiate {
994 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
995 f.debug_struct(&format!("SoupAuthNegotiate @ {self:p}"))
996 .finish()
997 }
998}
999
1000#[derive(Copy, Clone)]
1001#[repr(C)]
1002pub struct SoupCache {
1003 pub parent_instance: gobject::GObject,
1004}
1005
1006impl ::std::fmt::Debug for SoupCache {
1007 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1008 f.debug_struct(&format!("SoupCache @ {self:p}"))
1009 .field("parent_instance", &self.parent_instance)
1010 .finish()
1011 }
1012}
1013
1014#[repr(C)]
1015#[allow(dead_code)]
1016pub struct SoupContentDecoder {
1017 _data: [u8; 0],
1018 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1019}
1020
1021impl ::std::fmt::Debug for SoupContentDecoder {
1022 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1023 f.debug_struct(&format!("SoupContentDecoder @ {self:p}"))
1024 .finish()
1025 }
1026}
1027
1028#[repr(C)]
1029#[allow(dead_code)]
1030pub struct SoupContentSniffer {
1031 _data: [u8; 0],
1032 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1033}
1034
1035impl ::std::fmt::Debug for SoupContentSniffer {
1036 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1037 f.debug_struct(&format!("SoupContentSniffer @ {self:p}"))
1038 .finish()
1039 }
1040}
1041
1042#[derive(Copy, Clone)]
1043#[repr(C)]
1044pub struct SoupCookieJar {
1045 pub parent_instance: gobject::GObject,
1046}
1047
1048impl ::std::fmt::Debug for SoupCookieJar {
1049 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1050 f.debug_struct(&format!("SoupCookieJar @ {self:p}"))
1051 .field("parent_instance", &self.parent_instance)
1052 .finish()
1053 }
1054}
1055
1056#[repr(C)]
1057#[allow(dead_code)]
1058pub struct SoupCookieJarDB {
1059 _data: [u8; 0],
1060 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1061}
1062
1063impl ::std::fmt::Debug for SoupCookieJarDB {
1064 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1065 f.debug_struct(&format!("SoupCookieJarDB @ {self:p}"))
1066 .finish()
1067 }
1068}
1069
1070#[repr(C)]
1071#[allow(dead_code)]
1072pub struct SoupCookieJarText {
1073 _data: [u8; 0],
1074 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1075}
1076
1077impl ::std::fmt::Debug for SoupCookieJarText {
1078 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1079 f.debug_struct(&format!("SoupCookieJarText @ {self:p}"))
1080 .finish()
1081 }
1082}
1083
1084#[derive(Copy, Clone)]
1085#[repr(C)]
1086pub struct SoupHSTSEnforcer {
1087 pub parent_instance: gobject::GObject,
1088}
1089
1090impl ::std::fmt::Debug for SoupHSTSEnforcer {
1091 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1092 f.debug_struct(&format!("SoupHSTSEnforcer @ {self:p}"))
1093 .field("parent_instance", &self.parent_instance)
1094 .finish()
1095 }
1096}
1097
1098#[repr(C)]
1099#[allow(dead_code)]
1100pub struct SoupHSTSEnforcerDB {
1101 _data: [u8; 0],
1102 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1103}
1104
1105impl ::std::fmt::Debug for SoupHSTSEnforcerDB {
1106 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1107 f.debug_struct(&format!("SoupHSTSEnforcerDB @ {self:p}"))
1108 .finish()
1109 }
1110}
1111
1112#[repr(C)]
1113#[allow(dead_code)]
1114pub struct SoupLogger {
1115 _data: [u8; 0],
1116 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1117}
1118
1119impl ::std::fmt::Debug for SoupLogger {
1120 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1121 f.debug_struct(&format!("SoupLogger @ {self:p}")).finish()
1122 }
1123}
1124
1125#[repr(C)]
1126#[allow(dead_code)]
1127pub struct SoupMessage {
1128 _data: [u8; 0],
1129 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1130}
1131
1132impl ::std::fmt::Debug for SoupMessage {
1133 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1134 f.debug_struct(&format!("SoupMessage @ {self:p}")).finish()
1135 }
1136}
1137
1138#[repr(C)]
1139#[allow(dead_code)]
1140pub struct SoupMultipartInputStream {
1141 _data: [u8; 0],
1142 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1143}
1144
1145impl ::std::fmt::Debug for SoupMultipartInputStream {
1146 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1147 f.debug_struct(&format!("SoupMultipartInputStream @ {self:p}"))
1148 .finish()
1149 }
1150}
1151
1152#[derive(Copy, Clone)]
1153#[repr(C)]
1154pub struct SoupServer {
1155 pub parent_instance: gobject::GObject,
1156}
1157
1158impl ::std::fmt::Debug for SoupServer {
1159 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1160 f.debug_struct(&format!("SoupServer @ {self:p}"))
1161 .field("parent_instance", &self.parent_instance)
1162 .finish()
1163 }
1164}
1165
1166#[repr(C)]
1167#[allow(dead_code)]
1168pub struct SoupServerMessage {
1169 _data: [u8; 0],
1170 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1171}
1172
1173impl ::std::fmt::Debug for SoupServerMessage {
1174 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1175 f.debug_struct(&format!("SoupServerMessage @ {self:p}"))
1176 .finish()
1177 }
1178}
1179
1180#[derive(Copy, Clone)]
1181#[repr(C)]
1182pub struct SoupSession {
1183 pub parent_instance: gobject::GObject,
1184}
1185
1186impl ::std::fmt::Debug for SoupSession {
1187 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1188 f.debug_struct(&format!("SoupSession @ {self:p}"))
1189 .field("parent_instance", &self.parent_instance)
1190 .finish()
1191 }
1192}
1193
1194#[repr(C)]
1195#[allow(dead_code)]
1196pub struct SoupWebsocketConnection {
1197 _data: [u8; 0],
1198 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1199}
1200
1201impl ::std::fmt::Debug for SoupWebsocketConnection {
1202 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1203 f.debug_struct(&format!("SoupWebsocketConnection @ {self:p}"))
1204 .finish()
1205 }
1206}
1207
1208#[derive(Copy, Clone)]
1209#[repr(C)]
1210pub struct SoupWebsocketExtension {
1211 pub parent_instance: gobject::GObject,
1212}
1213
1214impl ::std::fmt::Debug for SoupWebsocketExtension {
1215 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1216 f.debug_struct(&format!("SoupWebsocketExtension @ {self:p}"))
1217 .field("parent_instance", &self.parent_instance)
1218 .finish()
1219 }
1220}
1221
1222#[repr(C)]
1223#[allow(dead_code)]
1224pub struct SoupWebsocketExtensionDeflate {
1225 _data: [u8; 0],
1226 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1227}
1228
1229impl ::std::fmt::Debug for SoupWebsocketExtensionDeflate {
1230 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1231 f.debug_struct(&format!("SoupWebsocketExtensionDeflate @ {self:p}"))
1232 .finish()
1233 }
1234}
1235
1236#[repr(C)]
1237#[allow(dead_code)]
1238pub struct SoupWebsocketExtensionManager {
1239 _data: [u8; 0],
1240 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1241}
1242
1243impl ::std::fmt::Debug for SoupWebsocketExtensionManager {
1244 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1245 f.debug_struct(&format!("SoupWebsocketExtensionManager @ {self:p}"))
1246 .finish()
1247 }
1248}
1249
1250#[repr(C)]
1252#[allow(dead_code)]
1253pub struct SoupSessionFeature {
1254 _data: [u8; 0],
1255 _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
1256}
1257
1258impl ::std::fmt::Debug for SoupSessionFeature {
1259 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1260 write!(f, "SoupSessionFeature @ {self:p}")
1261 }
1262}
1263
1264unsafe extern "C" {
1265
1266 pub fn soup_cache_type_get_type() -> GType;
1270
1271 pub fn soup_cookie_jar_accept_policy_get_type() -> GType;
1275
1276 pub fn soup_date_format_get_type() -> GType;
1280
1281 pub fn soup_encoding_get_type() -> GType;
1285
1286 pub fn soup_http_version_get_type() -> GType;
1290
1291 pub fn soup_logger_log_level_get_type() -> GType;
1295
1296 pub fn soup_memory_use_get_type() -> GType;
1300
1301 pub fn soup_message_headers_type_get_type() -> GType;
1305
1306 pub fn soup_message_priority_get_type() -> GType;
1310
1311 pub fn soup_same_site_policy_get_type() -> GType;
1315
1316 pub fn soup_session_error_get_type() -> GType;
1320 pub fn soup_session_error_quark() -> glib::GQuark;
1321
1322 pub fn soup_status_get_type() -> GType;
1326 pub fn soup_status_get_phrase(status_code: c_uint) -> *const c_char;
1327
1328 pub fn soup_tld_error_get_type() -> GType;
1332 pub fn soup_tld_error_quark() -> glib::GQuark;
1333
1334 pub fn soup_uri_component_get_type() -> GType;
1338
1339 pub fn soup_websocket_close_code_get_type() -> GType;
1343
1344 pub fn soup_websocket_connection_type_get_type() -> GType;
1348
1349 pub fn soup_websocket_data_type_get_type() -> GType;
1353
1354 pub fn soup_websocket_error_get_type() -> GType;
1358 pub fn soup_websocket_error_quark() -> glib::GQuark;
1359
1360 pub fn soup_websocket_state_get_type() -> GType;
1364
1365 pub fn soup_cacheability_get_type() -> GType;
1369
1370 pub fn soup_expectation_get_type() -> GType;
1374
1375 pub fn soup_message_flags_get_type() -> GType;
1379
1380 pub fn soup_server_listen_options_get_type() -> GType;
1384
1385 pub fn soup_cookie_get_type() -> GType;
1389 pub fn soup_cookie_new(
1390 name: *const c_char,
1391 value: *const c_char,
1392 domain: *const c_char,
1393 path: *const c_char,
1394 max_age: c_int,
1395 ) -> *mut SoupCookie;
1396 pub fn soup_cookie_applies_to_uri(cookie: *mut SoupCookie, uri: *mut glib::GUri) -> gboolean;
1397 pub fn soup_cookie_copy(cookie: *mut SoupCookie) -> *mut SoupCookie;
1398 pub fn soup_cookie_domain_matches(cookie: *mut SoupCookie, host: *const c_char) -> gboolean;
1399 pub fn soup_cookie_equal(cookie1: *mut SoupCookie, cookie2: *mut SoupCookie) -> gboolean;
1400 pub fn soup_cookie_free(cookie: *mut SoupCookie);
1401 pub fn soup_cookie_get_domain(cookie: *mut SoupCookie) -> *const c_char;
1402 pub fn soup_cookie_get_expires(cookie: *mut SoupCookie) -> *mut glib::GDateTime;
1403 pub fn soup_cookie_get_http_only(cookie: *mut SoupCookie) -> gboolean;
1404 pub fn soup_cookie_get_name(cookie: *mut SoupCookie) -> *const c_char;
1405 pub fn soup_cookie_get_path(cookie: *mut SoupCookie) -> *const c_char;
1406 pub fn soup_cookie_get_same_site_policy(cookie: *mut SoupCookie) -> SoupSameSitePolicy;
1407 pub fn soup_cookie_get_secure(cookie: *mut SoupCookie) -> gboolean;
1408 pub fn soup_cookie_get_value(cookie: *mut SoupCookie) -> *const c_char;
1409 pub fn soup_cookie_set_domain(cookie: *mut SoupCookie, domain: *const c_char);
1410 pub fn soup_cookie_set_expires(cookie: *mut SoupCookie, expires: *mut glib::GDateTime);
1411 pub fn soup_cookie_set_http_only(cookie: *mut SoupCookie, http_only: gboolean);
1412 pub fn soup_cookie_set_max_age(cookie: *mut SoupCookie, max_age: c_int);
1413 pub fn soup_cookie_set_name(cookie: *mut SoupCookie, name: *const c_char);
1414 pub fn soup_cookie_set_path(cookie: *mut SoupCookie, path: *const c_char);
1415 pub fn soup_cookie_set_same_site_policy(cookie: *mut SoupCookie, policy: SoupSameSitePolicy);
1416 pub fn soup_cookie_set_secure(cookie: *mut SoupCookie, secure: gboolean);
1417 pub fn soup_cookie_set_value(cookie: *mut SoupCookie, value: *const c_char);
1418 pub fn soup_cookie_to_cookie_header(cookie: *mut SoupCookie) -> *mut c_char;
1419 pub fn soup_cookie_to_set_cookie_header(cookie: *mut SoupCookie) -> *mut c_char;
1420 pub fn soup_cookie_parse(header: *const c_char, origin: *mut glib::GUri) -> *mut SoupCookie;
1421
1422 pub fn soup_hsts_policy_get_type() -> GType;
1426 pub fn soup_hsts_policy_new(
1427 domain: *const c_char,
1428 max_age: c_ulong,
1429 include_subdomains: gboolean,
1430 ) -> *mut SoupHSTSPolicy;
1431 pub fn soup_hsts_policy_new_from_response(msg: *mut SoupMessage) -> *mut SoupHSTSPolicy;
1432 pub fn soup_hsts_policy_new_full(
1433 domain: *const c_char,
1434 max_age: c_ulong,
1435 expires: *mut glib::GDateTime,
1436 include_subdomains: gboolean,
1437 ) -> *mut SoupHSTSPolicy;
1438 pub fn soup_hsts_policy_new_session_policy(
1439 domain: *const c_char,
1440 include_subdomains: gboolean,
1441 ) -> *mut SoupHSTSPolicy;
1442 pub fn soup_hsts_policy_copy(policy: *mut SoupHSTSPolicy) -> *mut SoupHSTSPolicy;
1443 pub fn soup_hsts_policy_equal(
1444 policy1: *mut SoupHSTSPolicy,
1445 policy2: *mut SoupHSTSPolicy,
1446 ) -> gboolean;
1447 pub fn soup_hsts_policy_free(policy: *mut SoupHSTSPolicy);
1448 pub fn soup_hsts_policy_get_domain(policy: *mut SoupHSTSPolicy) -> *const c_char;
1449 pub fn soup_hsts_policy_get_expires(policy: *mut SoupHSTSPolicy) -> *mut glib::GDateTime;
1450 pub fn soup_hsts_policy_get_max_age(policy: *mut SoupHSTSPolicy) -> c_ulong;
1451 pub fn soup_hsts_policy_includes_subdomains(policy: *mut SoupHSTSPolicy) -> gboolean;
1452 pub fn soup_hsts_policy_is_expired(policy: *mut SoupHSTSPolicy) -> gboolean;
1453 pub fn soup_hsts_policy_is_session_policy(policy: *mut SoupHSTSPolicy) -> gboolean;
1454
1455 pub fn soup_message_body_get_type() -> GType;
1459 pub fn soup_message_body_new() -> *mut SoupMessageBody;
1460 pub fn soup_message_body_append(
1461 body: *mut SoupMessageBody,
1462 use_: SoupMemoryUse,
1463 data: gconstpointer,
1464 length: size_t,
1465 );
1466 pub fn soup_message_body_append_bytes(body: *mut SoupMessageBody, buffer: *mut glib::GBytes);
1467 pub fn soup_message_body_append_take(body: *mut SoupMessageBody, data: *mut u8, length: size_t);
1468 pub fn soup_message_body_complete(body: *mut SoupMessageBody);
1469 pub fn soup_message_body_flatten(body: *mut SoupMessageBody) -> *mut glib::GBytes;
1470 pub fn soup_message_body_get_accumulate(body: *mut SoupMessageBody) -> gboolean;
1471 pub fn soup_message_body_get_chunk(
1472 body: *mut SoupMessageBody,
1473 offset: i64,
1474 ) -> *mut glib::GBytes;
1475 pub fn soup_message_body_got_chunk(body: *mut SoupMessageBody, chunk: *mut glib::GBytes);
1476 pub fn soup_message_body_ref(body: *mut SoupMessageBody) -> *mut SoupMessageBody;
1477 pub fn soup_message_body_set_accumulate(body: *mut SoupMessageBody, accumulate: gboolean);
1478 pub fn soup_message_body_truncate(body: *mut SoupMessageBody);
1479 pub fn soup_message_body_unref(body: *mut SoupMessageBody);
1480 pub fn soup_message_body_wrote_chunk(body: *mut SoupMessageBody, chunk: *mut glib::GBytes);
1481
1482 pub fn soup_message_headers_get_type() -> GType;
1486 pub fn soup_message_headers_new(type_: SoupMessageHeadersType) -> *mut SoupMessageHeaders;
1487 pub fn soup_message_headers_append(
1488 hdrs: *mut SoupMessageHeaders,
1489 name: *const c_char,
1490 value: *const c_char,
1491 );
1492 pub fn soup_message_headers_clean_connection_headers(hdrs: *mut SoupMessageHeaders);
1493 pub fn soup_message_headers_clear(hdrs: *mut SoupMessageHeaders);
1494 pub fn soup_message_headers_foreach(
1495 hdrs: *mut SoupMessageHeaders,
1496 func: SoupMessageHeadersForeachFunc,
1497 user_data: gpointer,
1498 );
1499 pub fn soup_message_headers_free_ranges(hdrs: *mut SoupMessageHeaders, ranges: *mut SoupRange);
1500 pub fn soup_message_headers_get_content_disposition(
1501 hdrs: *mut SoupMessageHeaders,
1502 disposition: *mut *mut c_char,
1503 params: *mut *mut glib::GHashTable,
1504 ) -> gboolean;
1505 pub fn soup_message_headers_get_content_length(hdrs: *mut SoupMessageHeaders) -> i64;
1506 pub fn soup_message_headers_get_content_range(
1507 hdrs: *mut SoupMessageHeaders,
1508 start: *mut i64,
1509 end: *mut i64,
1510 total_length: *mut i64,
1511 ) -> gboolean;
1512 pub fn soup_message_headers_get_content_type(
1513 hdrs: *mut SoupMessageHeaders,
1514 params: *mut *mut glib::GHashTable,
1515 ) -> *const c_char;
1516 pub fn soup_message_headers_get_encoding(hdrs: *mut SoupMessageHeaders) -> SoupEncoding;
1517 pub fn soup_message_headers_get_expectations(hdrs: *mut SoupMessageHeaders) -> SoupExpectation;
1518 pub fn soup_message_headers_get_headers_type(
1519 hdrs: *mut SoupMessageHeaders,
1520 ) -> SoupMessageHeadersType;
1521 pub fn soup_message_headers_get_list(
1522 hdrs: *mut SoupMessageHeaders,
1523 name: *const c_char,
1524 ) -> *const c_char;
1525 pub fn soup_message_headers_get_one(
1526 hdrs: *mut SoupMessageHeaders,
1527 name: *const c_char,
1528 ) -> *const c_char;
1529 pub fn soup_message_headers_get_ranges(
1530 hdrs: *mut SoupMessageHeaders,
1531 total_length: i64,
1532 ranges: *mut *mut SoupRange,
1533 length: *mut c_int,
1534 ) -> gboolean;
1535 pub fn soup_message_headers_header_contains(
1536 hdrs: *mut SoupMessageHeaders,
1537 name: *const c_char,
1538 token: *const c_char,
1539 ) -> gboolean;
1540 pub fn soup_message_headers_header_equals(
1541 hdrs: *mut SoupMessageHeaders,
1542 name: *const c_char,
1543 value: *const c_char,
1544 ) -> gboolean;
1545 pub fn soup_message_headers_ref(hdrs: *mut SoupMessageHeaders) -> *mut SoupMessageHeaders;
1546 pub fn soup_message_headers_remove(hdrs: *mut SoupMessageHeaders, name: *const c_char);
1547 pub fn soup_message_headers_replace(
1548 hdrs: *mut SoupMessageHeaders,
1549 name: *const c_char,
1550 value: *const c_char,
1551 );
1552 pub fn soup_message_headers_set_content_disposition(
1553 hdrs: *mut SoupMessageHeaders,
1554 disposition: *const c_char,
1555 params: *mut glib::GHashTable,
1556 );
1557 pub fn soup_message_headers_set_content_length(
1558 hdrs: *mut SoupMessageHeaders,
1559 content_length: i64,
1560 );
1561 pub fn soup_message_headers_set_content_range(
1562 hdrs: *mut SoupMessageHeaders,
1563 start: i64,
1564 end: i64,
1565 total_length: i64,
1566 );
1567 pub fn soup_message_headers_set_content_type(
1568 hdrs: *mut SoupMessageHeaders,
1569 content_type: *const c_char,
1570 params: *mut glib::GHashTable,
1571 );
1572 pub fn soup_message_headers_set_encoding(hdrs: *mut SoupMessageHeaders, encoding: SoupEncoding);
1573 pub fn soup_message_headers_set_expectations(
1574 hdrs: *mut SoupMessageHeaders,
1575 expectations: SoupExpectation,
1576 );
1577 pub fn soup_message_headers_set_range(hdrs: *mut SoupMessageHeaders, start: i64, end: i64);
1578 pub fn soup_message_headers_set_ranges(
1579 hdrs: *mut SoupMessageHeaders,
1580 ranges: *mut SoupRange,
1581 length: c_int,
1582 );
1583 pub fn soup_message_headers_unref(hdrs: *mut SoupMessageHeaders);
1584
1585 pub fn soup_message_headers_iter_init(
1589 iter: *mut SoupMessageHeadersIter,
1590 hdrs: *mut SoupMessageHeaders,
1591 );
1592 pub fn soup_message_headers_iter_next(
1593 iter: *mut SoupMessageHeadersIter,
1594 name: *mut *const c_char,
1595 value: *mut *const c_char,
1596 ) -> gboolean;
1597
1598 pub fn soup_message_metrics_get_type() -> GType;
1602 pub fn soup_message_metrics_copy(metrics: *mut SoupMessageMetrics) -> *mut SoupMessageMetrics;
1603 pub fn soup_message_metrics_free(metrics: *mut SoupMessageMetrics);
1604 pub fn soup_message_metrics_get_connect_end(metrics: *mut SoupMessageMetrics) -> u64;
1605 pub fn soup_message_metrics_get_connect_start(metrics: *mut SoupMessageMetrics) -> u64;
1606 pub fn soup_message_metrics_get_dns_end(metrics: *mut SoupMessageMetrics) -> u64;
1607 pub fn soup_message_metrics_get_dns_start(metrics: *mut SoupMessageMetrics) -> u64;
1608 pub fn soup_message_metrics_get_fetch_start(metrics: *mut SoupMessageMetrics) -> u64;
1609 pub fn soup_message_metrics_get_request_body_bytes_sent(
1610 metrics: *mut SoupMessageMetrics,
1611 ) -> u64;
1612 pub fn soup_message_metrics_get_request_body_size(metrics: *mut SoupMessageMetrics) -> u64;
1613 pub fn soup_message_metrics_get_request_header_bytes_sent(
1614 metrics: *mut SoupMessageMetrics,
1615 ) -> u64;
1616 pub fn soup_message_metrics_get_request_start(metrics: *mut SoupMessageMetrics) -> u64;
1617 pub fn soup_message_metrics_get_response_body_bytes_received(
1618 metrics: *mut SoupMessageMetrics,
1619 ) -> u64;
1620 pub fn soup_message_metrics_get_response_body_size(metrics: *mut SoupMessageMetrics) -> u64;
1621 pub fn soup_message_metrics_get_response_end(metrics: *mut SoupMessageMetrics) -> u64;
1622 pub fn soup_message_metrics_get_response_header_bytes_received(
1623 metrics: *mut SoupMessageMetrics,
1624 ) -> u64;
1625 pub fn soup_message_metrics_get_response_start(metrics: *mut SoupMessageMetrics) -> u64;
1626 pub fn soup_message_metrics_get_tls_start(metrics: *mut SoupMessageMetrics) -> u64;
1627
1628 pub fn soup_multipart_get_type() -> GType;
1632 pub fn soup_multipart_new(mime_type: *const c_char) -> *mut SoupMultipart;
1633 pub fn soup_multipart_new_from_message(
1634 headers: *mut SoupMessageHeaders,
1635 body: *mut glib::GBytes,
1636 ) -> *mut SoupMultipart;
1637 pub fn soup_multipart_append_form_file(
1638 multipart: *mut SoupMultipart,
1639 control_name: *const c_char,
1640 filename: *const c_char,
1641 content_type: *const c_char,
1642 body: *mut glib::GBytes,
1643 );
1644 pub fn soup_multipart_append_form_string(
1645 multipart: *mut SoupMultipart,
1646 control_name: *const c_char,
1647 data: *const c_char,
1648 );
1649 pub fn soup_multipart_append_part(
1650 multipart: *mut SoupMultipart,
1651 headers: *mut SoupMessageHeaders,
1652 body: *mut glib::GBytes,
1653 );
1654 pub fn soup_multipart_free(multipart: *mut SoupMultipart);
1655 pub fn soup_multipart_get_length(multipart: *mut SoupMultipart) -> c_int;
1656 pub fn soup_multipart_get_part(
1657 multipart: *mut SoupMultipart,
1658 part: c_int,
1659 headers: *mut *mut SoupMessageHeaders,
1660 body: *mut *mut glib::GBytes,
1661 ) -> gboolean;
1662 pub fn soup_multipart_to_message(
1663 multipart: *mut SoupMultipart,
1664 dest_headers: *mut SoupMessageHeaders,
1665 dest_body: *mut *mut glib::GBytes,
1666 );
1667
1668 pub fn soup_auth_get_type() -> GType;
1672 pub fn soup_auth_new(
1673 type_: GType,
1674 msg: *mut SoupMessage,
1675 auth_header: *const c_char,
1676 ) -> *mut SoupAuth;
1677 pub fn soup_auth_authenticate(
1678 auth: *mut SoupAuth,
1679 username: *const c_char,
1680 password: *const c_char,
1681 );
1682 pub fn soup_auth_can_authenticate(auth: *mut SoupAuth) -> gboolean;
1683 pub fn soup_auth_cancel(auth: *mut SoupAuth);
1684 pub fn soup_auth_free_protection_space(auth: *mut SoupAuth, space: *mut glib::GSList);
1685 pub fn soup_auth_get_authority(auth: *mut SoupAuth) -> *const c_char;
1686 pub fn soup_auth_get_authorization(auth: *mut SoupAuth, msg: *mut SoupMessage) -> *mut c_char;
1687 pub fn soup_auth_get_info(auth: *mut SoupAuth) -> *mut c_char;
1688 pub fn soup_auth_get_protection_space(
1689 auth: *mut SoupAuth,
1690 source_uri: *mut glib::GUri,
1691 ) -> *mut glib::GSList;
1692 pub fn soup_auth_get_realm(auth: *mut SoupAuth) -> *const c_char;
1693 pub fn soup_auth_get_scheme_name(auth: *mut SoupAuth) -> *const c_char;
1694 pub fn soup_auth_is_authenticated(auth: *mut SoupAuth) -> gboolean;
1695 pub fn soup_auth_is_cancelled(auth: *mut SoupAuth) -> gboolean;
1696 pub fn soup_auth_is_for_proxy(auth: *mut SoupAuth) -> gboolean;
1697 pub fn soup_auth_is_ready(auth: *mut SoupAuth, msg: *mut SoupMessage) -> gboolean;
1698 pub fn soup_auth_update(
1699 auth: *mut SoupAuth,
1700 msg: *mut SoupMessage,
1701 auth_header: *const c_char,
1702 ) -> gboolean;
1703
1704 pub fn soup_auth_basic_get_type() -> GType;
1708
1709 pub fn soup_auth_digest_get_type() -> GType;
1713
1714 pub fn soup_auth_domain_get_type() -> GType;
1718 pub fn soup_auth_domain_accepts(
1719 domain: *mut SoupAuthDomain,
1720 msg: *mut SoupServerMessage,
1721 ) -> *mut c_char;
1722 pub fn soup_auth_domain_add_path(domain: *mut SoupAuthDomain, path: *const c_char);
1723 pub fn soup_auth_domain_challenge(domain: *mut SoupAuthDomain, msg: *mut SoupServerMessage);
1724 pub fn soup_auth_domain_check_password(
1725 domain: *mut SoupAuthDomain,
1726 msg: *mut SoupServerMessage,
1727 username: *const c_char,
1728 password: *const c_char,
1729 ) -> gboolean;
1730 pub fn soup_auth_domain_covers(
1731 domain: *mut SoupAuthDomain,
1732 msg: *mut SoupServerMessage,
1733 ) -> gboolean;
1734 pub fn soup_auth_domain_get_realm(domain: *mut SoupAuthDomain) -> *const c_char;
1735 pub fn soup_auth_domain_remove_path(domain: *mut SoupAuthDomain, path: *const c_char);
1736 pub fn soup_auth_domain_set_filter(
1737 domain: *mut SoupAuthDomain,
1738 filter: SoupAuthDomainFilter,
1739 filter_data: gpointer,
1740 dnotify: glib::GDestroyNotify,
1741 );
1742 pub fn soup_auth_domain_set_generic_auth_callback(
1743 domain: *mut SoupAuthDomain,
1744 auth_callback: SoupAuthDomainGenericAuthCallback,
1745 auth_data: gpointer,
1746 dnotify: glib::GDestroyNotify,
1747 );
1748
1749 pub fn soup_auth_domain_basic_get_type() -> GType;
1753 pub fn soup_auth_domain_basic_new(optname1: *const c_char, ...) -> *mut SoupAuthDomain;
1754 pub fn soup_auth_domain_basic_set_auth_callback(
1755 domain: *mut SoupAuthDomainBasic,
1756 callback: SoupAuthDomainBasicAuthCallback,
1757 user_data: gpointer,
1758 dnotify: glib::GDestroyNotify,
1759 );
1760
1761 pub fn soup_auth_domain_digest_get_type() -> GType;
1765 pub fn soup_auth_domain_digest_new(optname1: *const c_char, ...) -> *mut SoupAuthDomain;
1766 pub fn soup_auth_domain_digest_encode_password(
1767 username: *const c_char,
1768 realm: *const c_char,
1769 password: *const c_char,
1770 ) -> *mut c_char;
1771 pub fn soup_auth_domain_digest_set_auth_callback(
1772 domain: *mut SoupAuthDomainDigest,
1773 callback: SoupAuthDomainDigestAuthCallback,
1774 user_data: gpointer,
1775 dnotify: glib::GDestroyNotify,
1776 );
1777
1778 pub fn soup_auth_manager_get_type() -> GType;
1782 pub fn soup_auth_manager_clear_cached_credentials(manager: *mut SoupAuthManager);
1783 pub fn soup_auth_manager_use_auth(
1784 manager: *mut SoupAuthManager,
1785 uri: *mut glib::GUri,
1786 auth: *mut SoupAuth,
1787 );
1788
1789 pub fn soup_auth_ntlm_get_type() -> GType;
1793
1794 pub fn soup_auth_negotiate_get_type() -> GType;
1798 pub fn soup_auth_negotiate_supported() -> gboolean;
1799
1800 pub fn soup_cache_get_type() -> GType;
1804 pub fn soup_cache_new(cache_dir: *const c_char, cache_type: SoupCacheType) -> *mut SoupCache;
1805 pub fn soup_cache_clear(cache: *mut SoupCache);
1806 pub fn soup_cache_dump(cache: *mut SoupCache);
1807 pub fn soup_cache_flush(cache: *mut SoupCache);
1808 pub fn soup_cache_get_max_size(cache: *mut SoupCache) -> c_uint;
1809 pub fn soup_cache_load(cache: *mut SoupCache);
1810 pub fn soup_cache_set_max_size(cache: *mut SoupCache, max_size: c_uint);
1811
1812 pub fn soup_content_decoder_get_type() -> GType;
1816
1817 pub fn soup_content_sniffer_get_type() -> GType;
1821 pub fn soup_content_sniffer_new() -> *mut SoupContentSniffer;
1822 pub fn soup_content_sniffer_sniff(
1823 sniffer: *mut SoupContentSniffer,
1824 msg: *mut SoupMessage,
1825 buffer: *mut glib::GBytes,
1826 params: *mut *mut glib::GHashTable,
1827 ) -> *mut c_char;
1828
1829 pub fn soup_cookie_jar_get_type() -> GType;
1833 pub fn soup_cookie_jar_new() -> *mut SoupCookieJar;
1834 pub fn soup_cookie_jar_add_cookie(jar: *mut SoupCookieJar, cookie: *mut SoupCookie);
1835 pub fn soup_cookie_jar_add_cookie_full(
1836 jar: *mut SoupCookieJar,
1837 cookie: *mut SoupCookie,
1838 uri: *mut glib::GUri,
1839 first_party: *mut glib::GUri,
1840 );
1841 pub fn soup_cookie_jar_add_cookie_with_first_party(
1842 jar: *mut SoupCookieJar,
1843 first_party: *mut glib::GUri,
1844 cookie: *mut SoupCookie,
1845 );
1846 pub fn soup_cookie_jar_all_cookies(jar: *mut SoupCookieJar) -> *mut glib::GSList;
1847 pub fn soup_cookie_jar_delete_cookie(jar: *mut SoupCookieJar, cookie: *mut SoupCookie);
1848 pub fn soup_cookie_jar_get_accept_policy(jar: *mut SoupCookieJar) -> SoupCookieJarAcceptPolicy;
1849 pub fn soup_cookie_jar_get_cookie_list(
1850 jar: *mut SoupCookieJar,
1851 uri: *mut glib::GUri,
1852 for_http: gboolean,
1853 ) -> *mut glib::GSList;
1854 pub fn soup_cookie_jar_get_cookie_list_with_same_site_info(
1855 jar: *mut SoupCookieJar,
1856 uri: *mut glib::GUri,
1857 top_level: *mut glib::GUri,
1858 site_for_cookies: *mut glib::GUri,
1859 for_http: gboolean,
1860 is_safe_method: gboolean,
1861 is_top_level_navigation: gboolean,
1862 ) -> *mut glib::GSList;
1863 pub fn soup_cookie_jar_get_cookies(
1864 jar: *mut SoupCookieJar,
1865 uri: *mut glib::GUri,
1866 for_http: gboolean,
1867 ) -> *mut c_char;
1868 pub fn soup_cookie_jar_is_persistent(jar: *mut SoupCookieJar) -> gboolean;
1869 pub fn soup_cookie_jar_set_accept_policy(
1870 jar: *mut SoupCookieJar,
1871 policy: SoupCookieJarAcceptPolicy,
1872 );
1873 pub fn soup_cookie_jar_set_cookie(
1874 jar: *mut SoupCookieJar,
1875 uri: *mut glib::GUri,
1876 cookie: *const c_char,
1877 );
1878 pub fn soup_cookie_jar_set_cookie_with_first_party(
1879 jar: *mut SoupCookieJar,
1880 uri: *mut glib::GUri,
1881 first_party: *mut glib::GUri,
1882 cookie: *const c_char,
1883 );
1884
1885 pub fn soup_cookie_jar_db_get_type() -> GType;
1889 pub fn soup_cookie_jar_db_new(
1890 filename: *const c_char,
1891 read_only: gboolean,
1892 ) -> *mut SoupCookieJar;
1893
1894 pub fn soup_cookie_jar_text_get_type() -> GType;
1898 pub fn soup_cookie_jar_text_new(
1899 filename: *const c_char,
1900 read_only: gboolean,
1901 ) -> *mut SoupCookieJar;
1902
1903 pub fn soup_hsts_enforcer_get_type() -> GType;
1907 pub fn soup_hsts_enforcer_new() -> *mut SoupHSTSEnforcer;
1908 pub fn soup_hsts_enforcer_get_domains(
1909 hsts_enforcer: *mut SoupHSTSEnforcer,
1910 session_policies: gboolean,
1911 ) -> *mut glib::GList;
1912 pub fn soup_hsts_enforcer_get_policies(
1913 hsts_enforcer: *mut SoupHSTSEnforcer,
1914 session_policies: gboolean,
1915 ) -> *mut glib::GList;
1916 pub fn soup_hsts_enforcer_has_valid_policy(
1917 hsts_enforcer: *mut SoupHSTSEnforcer,
1918 domain: *const c_char,
1919 ) -> gboolean;
1920 pub fn soup_hsts_enforcer_is_persistent(hsts_enforcer: *mut SoupHSTSEnforcer) -> gboolean;
1921 pub fn soup_hsts_enforcer_set_policy(
1922 hsts_enforcer: *mut SoupHSTSEnforcer,
1923 policy: *mut SoupHSTSPolicy,
1924 );
1925 pub fn soup_hsts_enforcer_set_session_policy(
1926 hsts_enforcer: *mut SoupHSTSEnforcer,
1927 domain: *const c_char,
1928 include_subdomains: gboolean,
1929 );
1930
1931 pub fn soup_hsts_enforcer_db_get_type() -> GType;
1935 pub fn soup_hsts_enforcer_db_new(filename: *const c_char) -> *mut SoupHSTSEnforcer;
1936
1937 pub fn soup_logger_get_type() -> GType;
1941 pub fn soup_logger_new(level: SoupLoggerLogLevel) -> *mut SoupLogger;
1942 pub fn soup_logger_get_max_body_size(logger: *mut SoupLogger) -> c_int;
1943 pub fn soup_logger_set_max_body_size(logger: *mut SoupLogger, max_body_size: c_int);
1944 pub fn soup_logger_set_printer(
1945 logger: *mut SoupLogger,
1946 printer: SoupLoggerPrinter,
1947 printer_data: gpointer,
1948 destroy: glib::GDestroyNotify,
1949 );
1950 pub fn soup_logger_set_request_filter(
1951 logger: *mut SoupLogger,
1952 request_filter: SoupLoggerFilter,
1953 filter_data: gpointer,
1954 destroy: glib::GDestroyNotify,
1955 );
1956 pub fn soup_logger_set_response_filter(
1957 logger: *mut SoupLogger,
1958 response_filter: SoupLoggerFilter,
1959 filter_data: gpointer,
1960 destroy: glib::GDestroyNotify,
1961 );
1962
1963 pub fn soup_message_get_type() -> GType;
1967 pub fn soup_message_new(method: *const c_char, uri_string: *const c_char) -> *mut SoupMessage;
1968 pub fn soup_message_new_from_encoded_form(
1969 method: *const c_char,
1970 uri_string: *const c_char,
1971 encoded_form: *mut c_char,
1972 ) -> *mut SoupMessage;
1973 pub fn soup_message_new_from_multipart(
1974 uri_string: *const c_char,
1975 multipart: *mut SoupMultipart,
1976 ) -> *mut SoupMessage;
1977 pub fn soup_message_new_from_uri(
1978 method: *const c_char,
1979 uri: *mut glib::GUri,
1980 ) -> *mut SoupMessage;
1981 pub fn soup_message_new_options_ping(base_uri: *mut glib::GUri) -> *mut SoupMessage;
1982 pub fn soup_message_add_flags(msg: *mut SoupMessage, flags: SoupMessageFlags);
1983 pub fn soup_message_add_header_handler(
1984 msg: *mut SoupMessage,
1985 signal: *const c_char,
1986 header: *const c_char,
1987 callback: gobject::GCallback,
1988 user_data: gpointer,
1989 ) -> c_uint;
1990 pub fn soup_message_add_status_code_handler(
1991 msg: *mut SoupMessage,
1992 signal: *const c_char,
1993 status_code: c_uint,
1994 callback: gobject::GCallback,
1995 user_data: gpointer,
1996 ) -> c_uint;
1997 pub fn soup_message_disable_feature(msg: *mut SoupMessage, feature_type: GType);
1998 pub fn soup_message_get_connection_id(msg: *mut SoupMessage) -> u64;
1999 pub fn soup_message_get_first_party(msg: *mut SoupMessage) -> *mut glib::GUri;
2000 pub fn soup_message_get_flags(msg: *mut SoupMessage) -> SoupMessageFlags;
2001 #[cfg(feature = "v3_4")]
2002 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
2003 pub fn soup_message_get_force_http1(msg: *mut SoupMessage) -> gboolean;
2004 pub fn soup_message_get_http_version(msg: *mut SoupMessage) -> SoupHTTPVersion;
2005 pub fn soup_message_get_is_options_ping(msg: *mut SoupMessage) -> gboolean;
2006 pub fn soup_message_get_is_top_level_navigation(msg: *mut SoupMessage) -> gboolean;
2007 pub fn soup_message_get_method(msg: *mut SoupMessage) -> *const c_char;
2008 pub fn soup_message_get_metrics(msg: *mut SoupMessage) -> *mut SoupMessageMetrics;
2009 pub fn soup_message_get_priority(msg: *mut SoupMessage) -> SoupMessagePriority;
2010 pub fn soup_message_get_reason_phrase(msg: *mut SoupMessage) -> *const c_char;
2011 pub fn soup_message_get_remote_address(msg: *mut SoupMessage) -> *mut gio::GSocketAddress;
2012 pub fn soup_message_get_request_headers(msg: *mut SoupMessage) -> *mut SoupMessageHeaders;
2013 pub fn soup_message_get_response_headers(msg: *mut SoupMessage) -> *mut SoupMessageHeaders;
2014 pub fn soup_message_get_site_for_cookies(msg: *mut SoupMessage) -> *mut glib::GUri;
2015 pub fn soup_message_get_status(msg: *mut SoupMessage) -> SoupStatus;
2016 pub fn soup_message_get_tls_ciphersuite_name(msg: *mut SoupMessage) -> *const c_char;
2017 pub fn soup_message_get_tls_peer_certificate(
2018 msg: *mut SoupMessage,
2019 ) -> *mut gio::GTlsCertificate;
2020 pub fn soup_message_get_tls_peer_certificate_errors(
2021 msg: *mut SoupMessage,
2022 ) -> gio::GTlsCertificateFlags;
2023 pub fn soup_message_get_tls_protocol_version(msg: *mut SoupMessage)
2024 -> gio::GTlsProtocolVersion;
2025 pub fn soup_message_get_uri(msg: *mut SoupMessage) -> *mut glib::GUri;
2026 pub fn soup_message_is_feature_disabled(msg: *mut SoupMessage, feature_type: GType)
2027 -> gboolean;
2028 pub fn soup_message_is_keepalive(msg: *mut SoupMessage) -> gboolean;
2029 pub fn soup_message_query_flags(msg: *mut SoupMessage, flags: SoupMessageFlags) -> gboolean;
2030 pub fn soup_message_remove_flags(msg: *mut SoupMessage, flags: SoupMessageFlags);
2031 pub fn soup_message_set_first_party(msg: *mut SoupMessage, first_party: *mut glib::GUri);
2032 pub fn soup_message_set_flags(msg: *mut SoupMessage, flags: SoupMessageFlags);
2033 #[cfg(feature = "v3_4")]
2034 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
2035 pub fn soup_message_set_force_http1(msg: *mut SoupMessage, value: gboolean);
2036 pub fn soup_message_set_is_options_ping(msg: *mut SoupMessage, is_options_ping: gboolean);
2037 pub fn soup_message_set_is_top_level_navigation(
2038 msg: *mut SoupMessage,
2039 is_top_level_navigation: gboolean,
2040 );
2041 pub fn soup_message_set_method(msg: *mut SoupMessage, method: *const c_char);
2042 pub fn soup_message_set_priority(msg: *mut SoupMessage, priority: SoupMessagePriority);
2043 pub fn soup_message_set_request_body(
2044 msg: *mut SoupMessage,
2045 content_type: *const c_char,
2046 stream: *mut gio::GInputStream,
2047 content_length: ssize_t,
2048 );
2049 pub fn soup_message_set_request_body_from_bytes(
2050 msg: *mut SoupMessage,
2051 content_type: *const c_char,
2052 bytes: *mut glib::GBytes,
2053 );
2054 pub fn soup_message_set_site_for_cookies(
2055 msg: *mut SoupMessage,
2056 site_for_cookies: *mut glib::GUri,
2057 );
2058 pub fn soup_message_set_tls_client_certificate(
2059 msg: *mut SoupMessage,
2060 certificate: *mut gio::GTlsCertificate,
2061 );
2062 pub fn soup_message_set_uri(msg: *mut SoupMessage, uri: *mut glib::GUri);
2063 pub fn soup_message_tls_client_certificate_password_request_complete(msg: *mut SoupMessage);
2064
2065 pub fn soup_multipart_input_stream_get_type() -> GType;
2069 pub fn soup_multipart_input_stream_new(
2070 msg: *mut SoupMessage,
2071 base_stream: *mut gio::GInputStream,
2072 ) -> *mut SoupMultipartInputStream;
2073 pub fn soup_multipart_input_stream_get_headers(
2074 multipart: *mut SoupMultipartInputStream,
2075 ) -> *mut SoupMessageHeaders;
2076 pub fn soup_multipart_input_stream_next_part(
2077 multipart: *mut SoupMultipartInputStream,
2078 cancellable: *mut gio::GCancellable,
2079 error: *mut *mut glib::GError,
2080 ) -> *mut gio::GInputStream;
2081 pub fn soup_multipart_input_stream_next_part_async(
2082 multipart: *mut SoupMultipartInputStream,
2083 io_priority: c_int,
2084 cancellable: *mut gio::GCancellable,
2085 callback: gio::GAsyncReadyCallback,
2086 data: gpointer,
2087 );
2088 pub fn soup_multipart_input_stream_next_part_finish(
2089 multipart: *mut SoupMultipartInputStream,
2090 result: *mut gio::GAsyncResult,
2091 error: *mut *mut glib::GError,
2092 ) -> *mut gio::GInputStream;
2093
2094 pub fn soup_server_get_type() -> GType;
2098 pub fn soup_server_new(optname1: *const c_char, ...) -> *mut SoupServer;
2099 pub fn soup_server_accept_iostream(
2100 server: *mut SoupServer,
2101 stream: *mut gio::GIOStream,
2102 local_addr: *mut gio::GSocketAddress,
2103 remote_addr: *mut gio::GSocketAddress,
2104 error: *mut *mut glib::GError,
2105 ) -> gboolean;
2106 pub fn soup_server_add_auth_domain(server: *mut SoupServer, auth_domain: *mut SoupAuthDomain);
2107 pub fn soup_server_add_early_handler(
2108 server: *mut SoupServer,
2109 path: *const c_char,
2110 callback: SoupServerCallback,
2111 user_data: gpointer,
2112 destroy: glib::GDestroyNotify,
2113 );
2114 pub fn soup_server_add_handler(
2115 server: *mut SoupServer,
2116 path: *const c_char,
2117 callback: SoupServerCallback,
2118 user_data: gpointer,
2119 destroy: glib::GDestroyNotify,
2120 );
2121 pub fn soup_server_add_websocket_extension(server: *mut SoupServer, extension_type: GType);
2122 pub fn soup_server_add_websocket_handler(
2123 server: *mut SoupServer,
2124 path: *const c_char,
2125 origin: *const c_char,
2126 protocols: *mut *mut c_char,
2127 callback: SoupServerWebsocketCallback,
2128 user_data: gpointer,
2129 destroy: glib::GDestroyNotify,
2130 );
2131 pub fn soup_server_disconnect(server: *mut SoupServer);
2132 pub fn soup_server_get_listeners(server: *mut SoupServer) -> *mut glib::GSList;
2133 pub fn soup_server_get_tls_auth_mode(server: *mut SoupServer) -> gio::GTlsAuthenticationMode;
2134 pub fn soup_server_get_tls_certificate(server: *mut SoupServer) -> *mut gio::GTlsCertificate;
2135 pub fn soup_server_get_tls_database(server: *mut SoupServer) -> *mut gio::GTlsDatabase;
2136 pub fn soup_server_get_uris(server: *mut SoupServer) -> *mut glib::GSList;
2137 pub fn soup_server_is_https(server: *mut SoupServer) -> gboolean;
2138 pub fn soup_server_listen(
2139 server: *mut SoupServer,
2140 address: *mut gio::GSocketAddress,
2141 options: SoupServerListenOptions,
2142 error: *mut *mut glib::GError,
2143 ) -> gboolean;
2144 pub fn soup_server_listen_all(
2145 server: *mut SoupServer,
2146 port: c_uint,
2147 options: SoupServerListenOptions,
2148 error: *mut *mut glib::GError,
2149 ) -> gboolean;
2150 pub fn soup_server_listen_local(
2151 server: *mut SoupServer,
2152 port: c_uint,
2153 options: SoupServerListenOptions,
2154 error: *mut *mut glib::GError,
2155 ) -> gboolean;
2156 pub fn soup_server_listen_socket(
2157 server: *mut SoupServer,
2158 socket: *mut gio::GSocket,
2159 options: SoupServerListenOptions,
2160 error: *mut *mut glib::GError,
2161 ) -> gboolean;
2162 pub fn soup_server_pause_message(server: *mut SoupServer, msg: *mut SoupServerMessage);
2163 pub fn soup_server_remove_auth_domain(
2164 server: *mut SoupServer,
2165 auth_domain: *mut SoupAuthDomain,
2166 );
2167 pub fn soup_server_remove_handler(server: *mut SoupServer, path: *const c_char);
2168 pub fn soup_server_remove_websocket_extension(server: *mut SoupServer, extension_type: GType);
2169 pub fn soup_server_set_tls_auth_mode(
2170 server: *mut SoupServer,
2171 mode: gio::GTlsAuthenticationMode,
2172 );
2173 pub fn soup_server_set_tls_certificate(
2174 server: *mut SoupServer,
2175 certificate: *mut gio::GTlsCertificate,
2176 );
2177 pub fn soup_server_set_tls_database(
2178 server: *mut SoupServer,
2179 tls_database: *mut gio::GTlsDatabase,
2180 );
2181 pub fn soup_server_unpause_message(server: *mut SoupServer, msg: *mut SoupServerMessage);
2182
2183 pub fn soup_server_message_get_type() -> GType;
2187 pub fn soup_server_message_get_http_version(msg: *mut SoupServerMessage) -> SoupHTTPVersion;
2188 pub fn soup_server_message_get_local_address(
2189 msg: *mut SoupServerMessage,
2190 ) -> *mut gio::GSocketAddress;
2191 pub fn soup_server_message_get_method(msg: *mut SoupServerMessage) -> *const c_char;
2192 pub fn soup_server_message_get_reason_phrase(msg: *mut SoupServerMessage) -> *const c_char;
2193 pub fn soup_server_message_get_remote_address(
2194 msg: *mut SoupServerMessage,
2195 ) -> *mut gio::GSocketAddress;
2196 pub fn soup_server_message_get_remote_host(msg: *mut SoupServerMessage) -> *const c_char;
2197 pub fn soup_server_message_get_request_body(
2198 msg: *mut SoupServerMessage,
2199 ) -> *mut SoupMessageBody;
2200 pub fn soup_server_message_get_request_headers(
2201 msg: *mut SoupServerMessage,
2202 ) -> *mut SoupMessageHeaders;
2203 pub fn soup_server_message_get_response_body(
2204 msg: *mut SoupServerMessage,
2205 ) -> *mut SoupMessageBody;
2206 pub fn soup_server_message_get_response_headers(
2207 msg: *mut SoupServerMessage,
2208 ) -> *mut SoupMessageHeaders;
2209 pub fn soup_server_message_get_socket(msg: *mut SoupServerMessage) -> *mut gio::GSocket;
2210 pub fn soup_server_message_get_status(msg: *mut SoupServerMessage) -> c_uint;
2211 #[cfg(feature = "v3_2")]
2212 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
2213 pub fn soup_server_message_get_tls_peer_certificate(
2214 msg: *mut SoupServerMessage,
2215 ) -> *mut gio::GTlsCertificate;
2216 #[cfg(feature = "v3_2")]
2217 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
2218 pub fn soup_server_message_get_tls_peer_certificate_errors(
2219 msg: *mut SoupServerMessage,
2220 ) -> gio::GTlsCertificateFlags;
2221 pub fn soup_server_message_get_uri(msg: *mut SoupServerMessage) -> *mut glib::GUri;
2222 pub fn soup_server_message_is_options_ping(msg: *mut SoupServerMessage) -> gboolean;
2223 #[cfg(feature = "v3_2")]
2224 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
2225 pub fn soup_server_message_pause(msg: *mut SoupServerMessage);
2226 pub fn soup_server_message_set_http_version(
2227 msg: *mut SoupServerMessage,
2228 version: SoupHTTPVersion,
2229 );
2230 pub fn soup_server_message_set_redirect(
2231 msg: *mut SoupServerMessage,
2232 status_code: c_uint,
2233 redirect_uri: *const c_char,
2234 );
2235 pub fn soup_server_message_set_response(
2236 msg: *mut SoupServerMessage,
2237 content_type: *const c_char,
2238 resp_use: SoupMemoryUse,
2239 resp_body: *const u8,
2240 resp_length: size_t,
2241 );
2242 pub fn soup_server_message_set_status(
2243 msg: *mut SoupServerMessage,
2244 status_code: c_uint,
2245 reason_phrase: *const c_char,
2246 );
2247 pub fn soup_server_message_steal_connection(msg: *mut SoupServerMessage)
2248 -> *mut gio::GIOStream;
2249 #[cfg(feature = "v3_2")]
2250 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
2251 pub fn soup_server_message_unpause(msg: *mut SoupServerMessage);
2252
2253 pub fn soup_session_get_type() -> GType;
2257 pub fn soup_session_new() -> *mut SoupSession;
2258 pub fn soup_session_new_with_options(optname1: *const c_char, ...) -> *mut SoupSession;
2259 pub fn soup_session_abort(session: *mut SoupSession);
2260 pub fn soup_session_add_feature(session: *mut SoupSession, feature: *mut SoupSessionFeature);
2261 pub fn soup_session_add_feature_by_type(session: *mut SoupSession, feature_type: GType);
2262 pub fn soup_session_get_accept_language(session: *mut SoupSession) -> *const c_char;
2263 pub fn soup_session_get_accept_language_auto(session: *mut SoupSession) -> gboolean;
2264 pub fn soup_session_get_async_result_message(
2265 session: *mut SoupSession,
2266 result: *mut gio::GAsyncResult,
2267 ) -> *mut SoupMessage;
2268 pub fn soup_session_get_feature(
2269 session: *mut SoupSession,
2270 feature_type: GType,
2271 ) -> *mut SoupSessionFeature;
2272 pub fn soup_session_get_feature_for_message(
2273 session: *mut SoupSession,
2274 feature_type: GType,
2275 msg: *mut SoupMessage,
2276 ) -> *mut SoupSessionFeature;
2277 pub fn soup_session_get_idle_timeout(session: *mut SoupSession) -> c_uint;
2278 pub fn soup_session_get_local_address(
2279 session: *mut SoupSession,
2280 ) -> *mut gio::GInetSocketAddress;
2281 pub fn soup_session_get_max_conns(session: *mut SoupSession) -> c_uint;
2282 pub fn soup_session_get_max_conns_per_host(session: *mut SoupSession) -> c_uint;
2283 pub fn soup_session_get_proxy_resolver(session: *mut SoupSession) -> *mut gio::GProxyResolver;
2284 pub fn soup_session_get_remote_connectable(
2285 session: *mut SoupSession,
2286 ) -> *mut gio::GSocketConnectable;
2287 pub fn soup_session_get_timeout(session: *mut SoupSession) -> c_uint;
2288 pub fn soup_session_get_tls_database(session: *mut SoupSession) -> *mut gio::GTlsDatabase;
2289 pub fn soup_session_get_tls_interaction(session: *mut SoupSession)
2290 -> *mut gio::GTlsInteraction;
2291 pub fn soup_session_get_user_agent(session: *mut SoupSession) -> *const c_char;
2292 pub fn soup_session_has_feature(session: *mut SoupSession, feature_type: GType) -> gboolean;
2293 pub fn soup_session_preconnect_async(
2294 session: *mut SoupSession,
2295 msg: *mut SoupMessage,
2296 io_priority: c_int,
2297 cancellable: *mut gio::GCancellable,
2298 callback: gio::GAsyncReadyCallback,
2299 user_data: gpointer,
2300 );
2301 pub fn soup_session_preconnect_finish(
2302 session: *mut SoupSession,
2303 result: *mut gio::GAsyncResult,
2304 error: *mut *mut glib::GError,
2305 ) -> gboolean;
2306 pub fn soup_session_remove_feature(session: *mut SoupSession, feature: *mut SoupSessionFeature);
2307 pub fn soup_session_remove_feature_by_type(session: *mut SoupSession, feature_type: GType);
2308 pub fn soup_session_send(
2309 session: *mut SoupSession,
2310 msg: *mut SoupMessage,
2311 cancellable: *mut gio::GCancellable,
2312 error: *mut *mut glib::GError,
2313 ) -> *mut gio::GInputStream;
2314 pub fn soup_session_send_and_read(
2315 session: *mut SoupSession,
2316 msg: *mut SoupMessage,
2317 cancellable: *mut gio::GCancellable,
2318 error: *mut *mut glib::GError,
2319 ) -> *mut glib::GBytes;
2320 pub fn soup_session_send_and_read_async(
2321 session: *mut SoupSession,
2322 msg: *mut SoupMessage,
2323 io_priority: c_int,
2324 cancellable: *mut gio::GCancellable,
2325 callback: gio::GAsyncReadyCallback,
2326 user_data: gpointer,
2327 );
2328 pub fn soup_session_send_and_read_finish(
2329 session: *mut SoupSession,
2330 result: *mut gio::GAsyncResult,
2331 error: *mut *mut glib::GError,
2332 ) -> *mut glib::GBytes;
2333 #[cfg(feature = "v3_4")]
2334 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
2335 pub fn soup_session_send_and_splice(
2336 session: *mut SoupSession,
2337 msg: *mut SoupMessage,
2338 out_stream: *mut gio::GOutputStream,
2339 flags: gio::GOutputStreamSpliceFlags,
2340 cancellable: *mut gio::GCancellable,
2341 error: *mut *mut glib::GError,
2342 ) -> ssize_t;
2343 #[cfg(feature = "v3_4")]
2344 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
2345 pub fn soup_session_send_and_splice_async(
2346 session: *mut SoupSession,
2347 msg: *mut SoupMessage,
2348 out_stream: *mut gio::GOutputStream,
2349 flags: gio::GOutputStreamSpliceFlags,
2350 io_priority: c_int,
2351 cancellable: *mut gio::GCancellable,
2352 callback: gio::GAsyncReadyCallback,
2353 user_data: gpointer,
2354 );
2355 #[cfg(feature = "v3_4")]
2356 #[cfg_attr(docsrs, doc(cfg(feature = "v3_4")))]
2357 pub fn soup_session_send_and_splice_finish(
2358 session: *mut SoupSession,
2359 result: *mut gio::GAsyncResult,
2360 error: *mut *mut glib::GError,
2361 ) -> ssize_t;
2362 pub fn soup_session_send_async(
2363 session: *mut SoupSession,
2364 msg: *mut SoupMessage,
2365 io_priority: c_int,
2366 cancellable: *mut gio::GCancellable,
2367 callback: gio::GAsyncReadyCallback,
2368 user_data: gpointer,
2369 );
2370 pub fn soup_session_send_finish(
2371 session: *mut SoupSession,
2372 result: *mut gio::GAsyncResult,
2373 error: *mut *mut glib::GError,
2374 ) -> *mut gio::GInputStream;
2375 pub fn soup_session_set_accept_language(
2376 session: *mut SoupSession,
2377 accept_language: *const c_char,
2378 );
2379 pub fn soup_session_set_accept_language_auto(
2380 session: *mut SoupSession,
2381 accept_language_auto: gboolean,
2382 );
2383 pub fn soup_session_set_idle_timeout(session: *mut SoupSession, timeout: c_uint);
2384 pub fn soup_session_set_proxy_resolver(
2385 session: *mut SoupSession,
2386 proxy_resolver: *mut gio::GProxyResolver,
2387 );
2388 pub fn soup_session_set_timeout(session: *mut SoupSession, timeout: c_uint);
2389 pub fn soup_session_set_tls_database(
2390 session: *mut SoupSession,
2391 tls_database: *mut gio::GTlsDatabase,
2392 );
2393 pub fn soup_session_set_tls_interaction(
2394 session: *mut SoupSession,
2395 tls_interaction: *mut gio::GTlsInteraction,
2396 );
2397 pub fn soup_session_set_user_agent(session: *mut SoupSession, user_agent: *const c_char);
2398 pub fn soup_session_websocket_connect_async(
2399 session: *mut SoupSession,
2400 msg: *mut SoupMessage,
2401 origin: *const c_char,
2402 protocols: *mut *mut c_char,
2403 io_priority: c_int,
2404 cancellable: *mut gio::GCancellable,
2405 callback: gio::GAsyncReadyCallback,
2406 user_data: gpointer,
2407 );
2408 pub fn soup_session_websocket_connect_finish(
2409 session: *mut SoupSession,
2410 result: *mut gio::GAsyncResult,
2411 error: *mut *mut glib::GError,
2412 ) -> *mut SoupWebsocketConnection;
2413
2414 pub fn soup_websocket_connection_get_type() -> GType;
2418 pub fn soup_websocket_connection_new(
2419 stream: *mut gio::GIOStream,
2420 uri: *mut glib::GUri,
2421 type_: SoupWebsocketConnectionType,
2422 origin: *const c_char,
2423 protocol: *const c_char,
2424 extensions: *mut glib::GList,
2425 ) -> *mut SoupWebsocketConnection;
2426 pub fn soup_websocket_connection_close(
2427 self_: *mut SoupWebsocketConnection,
2428 code: c_ushort,
2429 data: *const c_char,
2430 );
2431 pub fn soup_websocket_connection_get_close_code(
2432 self_: *mut SoupWebsocketConnection,
2433 ) -> c_ushort;
2434 pub fn soup_websocket_connection_get_close_data(
2435 self_: *mut SoupWebsocketConnection,
2436 ) -> *const c_char;
2437 pub fn soup_websocket_connection_get_connection_type(
2438 self_: *mut SoupWebsocketConnection,
2439 ) -> SoupWebsocketConnectionType;
2440 pub fn soup_websocket_connection_get_extensions(
2441 self_: *mut SoupWebsocketConnection,
2442 ) -> *mut glib::GList;
2443 pub fn soup_websocket_connection_get_io_stream(
2444 self_: *mut SoupWebsocketConnection,
2445 ) -> *mut gio::GIOStream;
2446 pub fn soup_websocket_connection_get_keepalive_interval(
2447 self_: *mut SoupWebsocketConnection,
2448 ) -> c_uint;
2449 #[cfg(feature = "v3_6")]
2450 #[cfg_attr(docsrs, doc(cfg(feature = "v3_6")))]
2451 pub fn soup_websocket_connection_get_keepalive_pong_timeout(
2452 self_: *mut SoupWebsocketConnection,
2453 ) -> c_uint;
2454 pub fn soup_websocket_connection_get_max_incoming_payload_size(
2455 self_: *mut SoupWebsocketConnection,
2456 ) -> u64;
2457 #[cfg(feature = "v3_8")]
2458 #[cfg_attr(docsrs, doc(cfg(feature = "v3_8")))]
2459 pub fn soup_websocket_connection_get_max_total_message_size(
2460 self_: *mut SoupWebsocketConnection,
2461 ) -> u64;
2462 pub fn soup_websocket_connection_get_origin(
2463 self_: *mut SoupWebsocketConnection,
2464 ) -> *const c_char;
2465 pub fn soup_websocket_connection_get_protocol(
2466 self_: *mut SoupWebsocketConnection,
2467 ) -> *const c_char;
2468 pub fn soup_websocket_connection_get_state(
2469 self_: *mut SoupWebsocketConnection,
2470 ) -> SoupWebsocketState;
2471 pub fn soup_websocket_connection_get_uri(
2472 self_: *mut SoupWebsocketConnection,
2473 ) -> *mut glib::GUri;
2474 pub fn soup_websocket_connection_send_binary(
2475 self_: *mut SoupWebsocketConnection,
2476 data: gconstpointer,
2477 length: size_t,
2478 );
2479 pub fn soup_websocket_connection_send_message(
2480 self_: *mut SoupWebsocketConnection,
2481 type_: SoupWebsocketDataType,
2482 message: *mut glib::GBytes,
2483 );
2484 pub fn soup_websocket_connection_send_text(
2485 self_: *mut SoupWebsocketConnection,
2486 text: *const c_char,
2487 );
2488 pub fn soup_websocket_connection_set_keepalive_interval(
2489 self_: *mut SoupWebsocketConnection,
2490 interval: c_uint,
2491 );
2492 #[cfg(feature = "v3_6")]
2493 #[cfg_attr(docsrs, doc(cfg(feature = "v3_6")))]
2494 pub fn soup_websocket_connection_set_keepalive_pong_timeout(
2495 self_: *mut SoupWebsocketConnection,
2496 pong_timeout: c_uint,
2497 );
2498 pub fn soup_websocket_connection_set_max_incoming_payload_size(
2499 self_: *mut SoupWebsocketConnection,
2500 max_incoming_payload_size: u64,
2501 );
2502 #[cfg(feature = "v3_8")]
2503 #[cfg_attr(docsrs, doc(cfg(feature = "v3_8")))]
2504 pub fn soup_websocket_connection_set_max_total_message_size(
2505 self_: *mut SoupWebsocketConnection,
2506 max_total_message_size: u64,
2507 );
2508
2509 pub fn soup_websocket_extension_get_type() -> GType;
2513 pub fn soup_websocket_extension_configure(
2514 extension: *mut SoupWebsocketExtension,
2515 connection_type: SoupWebsocketConnectionType,
2516 params: *mut glib::GHashTable,
2517 error: *mut *mut glib::GError,
2518 ) -> gboolean;
2519 pub fn soup_websocket_extension_get_request_params(
2520 extension: *mut SoupWebsocketExtension,
2521 ) -> *mut c_char;
2522 pub fn soup_websocket_extension_get_response_params(
2523 extension: *mut SoupWebsocketExtension,
2524 ) -> *mut c_char;
2525 pub fn soup_websocket_extension_process_incoming_message(
2526 extension: *mut SoupWebsocketExtension,
2527 header: *mut u8,
2528 payload: *mut glib::GBytes,
2529 error: *mut *mut glib::GError,
2530 ) -> *mut glib::GBytes;
2531 pub fn soup_websocket_extension_process_outgoing_message(
2532 extension: *mut SoupWebsocketExtension,
2533 header: *mut u8,
2534 payload: *mut glib::GBytes,
2535 error: *mut *mut glib::GError,
2536 ) -> *mut glib::GBytes;
2537
2538 pub fn soup_websocket_extension_deflate_get_type() -> GType;
2542
2543 pub fn soup_websocket_extension_manager_get_type() -> GType;
2547
2548 pub fn soup_session_feature_get_type() -> GType;
2552
2553 pub fn soup_check_version(major: c_uint, minor: c_uint, micro: c_uint) -> gboolean;
2557 pub fn soup_cookies_free(cookies: *mut glib::GSList);
2558 pub fn soup_cookies_from_request(msg: *mut SoupMessage) -> *mut glib::GSList;
2559 pub fn soup_cookies_from_response(msg: *mut SoupMessage) -> *mut glib::GSList;
2560 pub fn soup_cookies_to_cookie_header(cookies: *mut glib::GSList) -> *mut c_char;
2561 pub fn soup_cookies_to_request(cookies: *mut glib::GSList, msg: *mut SoupMessage);
2562 pub fn soup_cookies_to_response(cookies: *mut glib::GSList, msg: *mut SoupMessage);
2563 pub fn soup_date_time_new_from_http_string(date_string: *const c_char) -> *mut glib::GDateTime;
2564 pub fn soup_date_time_to_string(
2565 date: *mut glib::GDateTime,
2566 format: SoupDateFormat,
2567 ) -> *mut c_char;
2568 pub fn soup_form_decode(encoded_form: *const c_char) -> *mut glib::GHashTable;
2569 pub fn soup_form_decode_multipart(
2570 multipart: *mut SoupMultipart,
2571 file_control_name: *const c_char,
2572 filename: *mut *mut c_char,
2573 content_type: *mut *mut c_char,
2574 file: *mut *mut glib::GBytes,
2575 ) -> *mut glib::GHashTable;
2576 pub fn soup_form_encode(first_field: *const c_char, ...) -> *mut c_char;
2577 pub fn soup_form_encode_datalist(form_data_set: *mut *mut glib::GData) -> *mut c_char;
2578 pub fn soup_form_encode_hash(form_data_set: *mut glib::GHashTable) -> *mut c_char;
2579 pub fn soup_get_major_version() -> c_uint;
2581 pub fn soup_get_micro_version() -> c_uint;
2582 pub fn soup_get_minor_version() -> c_uint;
2583 pub fn soup_header_contains(header: *const c_char, token: *const c_char) -> gboolean;
2584 #[cfg(feature = "v3_8")]
2585 #[cfg_attr(docsrs, doc(cfg(feature = "v3_8")))]
2586 pub fn soup_header_contains_case_sensitive(
2587 header: *const c_char,
2588 token: *const c_char,
2589 ) -> gboolean;
2590 pub fn soup_header_free_list(list: *mut glib::GSList);
2591 pub fn soup_header_free_param_list(param_list: *mut glib::GHashTable);
2592 pub fn soup_header_g_string_append_param(
2593 string: *mut glib::GString,
2594 name: *const c_char,
2595 value: *const c_char,
2596 );
2597 pub fn soup_header_g_string_append_param_quoted(
2598 string: *mut glib::GString,
2599 name: *const c_char,
2600 value: *const c_char,
2601 );
2602 pub fn soup_header_parse_list(header: *const c_char) -> *mut glib::GSList;
2603 pub fn soup_header_parse_param_list(header: *const c_char) -> *mut glib::GHashTable;
2604 pub fn soup_header_parse_param_list_strict(header: *const c_char) -> *mut glib::GHashTable;
2605 pub fn soup_header_parse_quality_list(
2606 header: *const c_char,
2607 unacceptable: *mut *mut glib::GSList,
2608 ) -> *mut glib::GSList;
2609 pub fn soup_header_parse_semi_param_list(header: *const c_char) -> *mut glib::GHashTable;
2610 pub fn soup_header_parse_semi_param_list_strict(header: *const c_char)
2611 -> *mut glib::GHashTable;
2612 pub fn soup_headers_parse(
2613 str: *const c_char,
2614 len: c_int,
2615 dest: *mut SoupMessageHeaders,
2616 ) -> gboolean;
2617 pub fn soup_headers_parse_request(
2618 str: *const c_char,
2619 len: c_int,
2620 req_headers: *mut SoupMessageHeaders,
2621 req_method: *mut *mut c_char,
2622 req_path: *mut *mut c_char,
2623 ver: *mut SoupHTTPVersion,
2624 ) -> c_uint;
2625 pub fn soup_headers_parse_response(
2626 str: *const c_char,
2627 len: c_int,
2628 headers: *mut SoupMessageHeaders,
2629 ver: *mut SoupHTTPVersion,
2630 status_code: *mut c_uint,
2631 reason_phrase: *mut *mut c_char,
2632 ) -> gboolean;
2633 pub fn soup_headers_parse_status_line(
2634 status_line: *const c_char,
2635 ver: *mut SoupHTTPVersion,
2636 status_code: *mut c_uint,
2637 reason_phrase: *mut *mut c_char,
2638 ) -> gboolean;
2639 pub fn soup_tld_domain_is_public_suffix(domain: *const c_char) -> gboolean;
2640 pub fn soup_tld_get_base_domain(
2641 hostname: *const c_char,
2642 error: *mut *mut glib::GError,
2643 ) -> *const c_char;
2644 pub fn soup_uri_copy(
2645 uri: *mut glib::GUri,
2646 first_component: SoupURIComponent,
2647 ...
2648 ) -> *mut glib::GUri;
2649 pub fn soup_uri_decode_data_uri(
2650 uri: *const c_char,
2651 content_type: *mut *mut c_char,
2652 ) -> *mut glib::GBytes;
2653 pub fn soup_uri_equal(uri1: *mut glib::GUri, uri2: *mut glib::GUri) -> gboolean;
2654 pub fn soup_websocket_client_prepare_handshake(
2655 msg: *mut SoupMessage,
2656 origin: *const c_char,
2657 protocols: *mut *mut c_char,
2658 supported_extensions: *mut glib::GPtrArray,
2659 );
2660 pub fn soup_websocket_client_verify_handshake(
2661 msg: *mut SoupMessage,
2662 supported_extensions: *mut glib::GPtrArray,
2663 accepted_extensions: *mut *mut glib::GList,
2664 error: *mut *mut glib::GError,
2665 ) -> gboolean;
2666 pub fn soup_websocket_server_check_handshake(
2667 msg: *mut SoupServerMessage,
2668 origin: *const c_char,
2669 protocols: *mut *mut c_char,
2670 supported_extensions: *mut glib::GPtrArray,
2671 error: *mut *mut glib::GError,
2672 ) -> gboolean;
2673 pub fn soup_websocket_server_process_handshake(
2674 msg: *mut SoupServerMessage,
2675 expected_origin: *const c_char,
2676 protocols: *mut *mut c_char,
2677 supported_extensions: *mut glib::GPtrArray,
2678 accepted_extensions: *mut *mut glib::GList,
2679 ) -> gboolean;
2680
2681}