1use crate::{HTTPVersion, MemoryUse, MessageBody, MessageHeaders, ffi};
7use glib::{
8 object::ObjectType as _,
9 prelude::*,
10 signal::{SignalHandlerId, connect_raw},
11 translate::*,
12};
13use std::boxed::Box as Box_;
14
15glib::wrapper! {
16 #[doc(alias = "SoupServerMessage")]
17 pub struct ServerMessage(Object<ffi::SoupServerMessage, ffi::SoupServerMessageClass>);
18
19 match fn {
20 type_ => || ffi::soup_server_message_get_type(),
21 }
22}
23
24impl ServerMessage {
25 #[doc(alias = "soup_server_message_get_http_version")]
26 #[doc(alias = "get_http_version")]
27 pub fn http_version(&self) -> HTTPVersion {
28 unsafe {
29 from_glib(ffi::soup_server_message_get_http_version(
30 self.to_glib_none().0,
31 ))
32 }
33 }
34
35 #[doc(alias = "soup_server_message_get_local_address")]
36 #[doc(alias = "get_local_address")]
37 pub fn local_address(&self) -> Option<gio::SocketAddress> {
38 unsafe {
39 from_glib_none(ffi::soup_server_message_get_local_address(
40 self.to_glib_none().0,
41 ))
42 }
43 }
44
45 #[doc(alias = "soup_server_message_get_method")]
46 #[doc(alias = "get_method")]
47 pub fn method(&self) -> Option<glib::GString> {
48 unsafe { from_glib_none(ffi::soup_server_message_get_method(self.to_glib_none().0)) }
49 }
50
51 #[doc(alias = "soup_server_message_get_reason_phrase")]
52 #[doc(alias = "get_reason_phrase")]
53 pub fn reason_phrase(&self) -> Option<glib::GString> {
54 unsafe {
55 from_glib_none(ffi::soup_server_message_get_reason_phrase(
56 self.to_glib_none().0,
57 ))
58 }
59 }
60
61 #[doc(alias = "soup_server_message_get_remote_address")]
62 #[doc(alias = "get_remote_address")]
63 pub fn remote_address(&self) -> Option<gio::SocketAddress> {
64 unsafe {
65 from_glib_none(ffi::soup_server_message_get_remote_address(
66 self.to_glib_none().0,
67 ))
68 }
69 }
70
71 #[doc(alias = "soup_server_message_get_remote_host")]
72 #[doc(alias = "get_remote_host")]
73 pub fn remote_host(&self) -> Option<glib::GString> {
74 unsafe {
75 from_glib_none(ffi::soup_server_message_get_remote_host(
76 self.to_glib_none().0,
77 ))
78 }
79 }
80
81 #[doc(alias = "soup_server_message_get_request_body")]
82 #[doc(alias = "get_request_body")]
83 pub fn request_body(&self) -> Option<MessageBody> {
84 unsafe {
85 from_glib_none(ffi::soup_server_message_get_request_body(
86 self.to_glib_none().0,
87 ))
88 }
89 }
90
91 #[doc(alias = "soup_server_message_get_request_headers")]
92 #[doc(alias = "get_request_headers")]
93 pub fn request_headers(&self) -> Option<MessageHeaders> {
94 unsafe {
95 from_glib_none(ffi::soup_server_message_get_request_headers(
96 self.to_glib_none().0,
97 ))
98 }
99 }
100
101 #[doc(alias = "soup_server_message_get_response_body")]
102 #[doc(alias = "get_response_body")]
103 pub fn response_body(&self) -> Option<MessageBody> {
104 unsafe {
105 from_glib_none(ffi::soup_server_message_get_response_body(
106 self.to_glib_none().0,
107 ))
108 }
109 }
110
111 #[doc(alias = "soup_server_message_get_response_headers")]
112 #[doc(alias = "get_response_headers")]
113 pub fn response_headers(&self) -> Option<MessageHeaders> {
114 unsafe {
115 from_glib_none(ffi::soup_server_message_get_response_headers(
116 self.to_glib_none().0,
117 ))
118 }
119 }
120
121 #[doc(alias = "soup_server_message_get_socket")]
122 #[doc(alias = "get_socket")]
123 pub fn socket(&self) -> Option<gio::Socket> {
124 unsafe { from_glib_none(ffi::soup_server_message_get_socket(self.to_glib_none().0)) }
125 }
126
127 #[doc(alias = "soup_server_message_get_status")]
128 #[doc(alias = "get_status")]
129 pub fn status(&self) -> u32 {
130 unsafe { ffi::soup_server_message_get_status(self.to_glib_none().0) }
131 }
132
133 #[cfg(feature = "v3_2")]
134 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
135 #[doc(alias = "soup_server_message_get_tls_peer_certificate")]
136 #[doc(alias = "get_tls_peer_certificate")]
137 #[doc(alias = "tls-peer-certificate")]
138 pub fn tls_peer_certificate(&self) -> Option<gio::TlsCertificate> {
139 unsafe {
140 from_glib_none(ffi::soup_server_message_get_tls_peer_certificate(
141 self.to_glib_none().0,
142 ))
143 }
144 }
145
146 #[cfg(feature = "v3_2")]
147 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
148 #[doc(alias = "soup_server_message_get_tls_peer_certificate_errors")]
149 #[doc(alias = "get_tls_peer_certificate_errors")]
150 #[doc(alias = "tls-peer-certificate-errors")]
151 pub fn tls_peer_certificate_errors(&self) -> gio::TlsCertificateFlags {
152 unsafe {
153 from_glib(ffi::soup_server_message_get_tls_peer_certificate_errors(
154 self.to_glib_none().0,
155 ))
156 }
157 }
158
159 #[doc(alias = "soup_server_message_get_uri")]
160 #[doc(alias = "get_uri")]
161 pub fn uri(&self) -> Option<glib::Uri> {
162 unsafe { from_glib_none(ffi::soup_server_message_get_uri(self.to_glib_none().0)) }
163 }
164
165 #[doc(alias = "soup_server_message_is_options_ping")]
166 pub fn is_options_ping(&self) -> bool {
167 unsafe {
168 from_glib(ffi::soup_server_message_is_options_ping(
169 self.to_glib_none().0,
170 ))
171 }
172 }
173
174 #[cfg(feature = "v3_2")]
175 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
176 #[doc(alias = "soup_server_message_pause")]
177 pub fn pause(&self) {
178 unsafe {
179 ffi::soup_server_message_pause(self.to_glib_none().0);
180 }
181 }
182
183 #[doc(alias = "soup_server_message_set_http_version")]
184 pub fn set_http_version(&self, version: HTTPVersion) {
185 unsafe {
186 ffi::soup_server_message_set_http_version(self.to_glib_none().0, version.into_glib());
187 }
188 }
189
190 #[doc(alias = "soup_server_message_set_redirect")]
191 pub fn set_redirect(&self, status_code: u32, redirect_uri: &str) {
192 unsafe {
193 ffi::soup_server_message_set_redirect(
194 self.to_glib_none().0,
195 status_code,
196 redirect_uri.to_glib_none().0,
197 );
198 }
199 }
200
201 #[doc(alias = "soup_server_message_set_response")]
202 pub fn set_response(&self, content_type: Option<&str>, resp_use: MemoryUse, resp_body: &[u8]) {
203 let resp_length = resp_body.len() as _;
204 unsafe {
205 ffi::soup_server_message_set_response(
206 self.to_glib_none().0,
207 content_type.to_glib_none().0,
208 resp_use.into_glib(),
209 resp_body.to_glib_none().0,
210 resp_length,
211 );
212 }
213 }
214
215 #[doc(alias = "soup_server_message_set_status")]
216 pub fn set_status(&self, status_code: u32, reason_phrase: Option<&str>) {
217 unsafe {
218 ffi::soup_server_message_set_status(
219 self.to_glib_none().0,
220 status_code,
221 reason_phrase.to_glib_none().0,
222 );
223 }
224 }
225
226 #[doc(alias = "soup_server_message_steal_connection")]
227 pub fn steal_connection(&self) -> Option<gio::IOStream> {
228 unsafe {
229 from_glib_full(ffi::soup_server_message_steal_connection(
230 self.to_glib_none().0,
231 ))
232 }
233 }
234
235 #[cfg(feature = "v3_2")]
236 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
237 #[doc(alias = "soup_server_message_unpause")]
238 pub fn unpause(&self) {
239 unsafe {
240 ffi::soup_server_message_unpause(self.to_glib_none().0);
241 }
242 }
243
244 #[doc(alias = "accept-certificate")]
245 pub fn connect_accept_certificate<
246 F: Fn(&Self, &gio::TlsCertificate, gio::TlsCertificateFlags) -> bool + 'static,
247 >(
248 &self,
249 f: F,
250 ) -> SignalHandlerId {
251 unsafe extern "C" fn accept_certificate_trampoline<
252 F: Fn(&ServerMessage, &gio::TlsCertificate, gio::TlsCertificateFlags) -> bool + 'static,
253 >(
254 this: *mut ffi::SoupServerMessage,
255 tls_peer_certificate: *mut gio::ffi::GTlsCertificate,
256 tls_peer_errors: gio::ffi::GTlsCertificateFlags,
257 f: glib::ffi::gpointer,
258 ) -> glib::ffi::gboolean {
259 unsafe {
260 let f: &F = &*(f as *const F);
261 f(
262 &from_glib_borrow(this),
263 &from_glib_borrow(tls_peer_certificate),
264 from_glib(tls_peer_errors),
265 )
266 .into_glib()
267 }
268 }
269 unsafe {
270 let f: Box_<F> = Box_::new(f);
271 connect_raw(
272 self.as_ptr() as *mut _,
273 c"accept-certificate".as_ptr(),
274 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
275 accept_certificate_trampoline::<F> as *const (),
276 )),
277 Box_::into_raw(f),
278 )
279 }
280 }
281
282 #[doc(alias = "connected")]
283 pub fn connect_connected<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
284 unsafe extern "C" fn connected_trampoline<F: Fn(&ServerMessage) + 'static>(
285 this: *mut ffi::SoupServerMessage,
286 f: glib::ffi::gpointer,
287 ) {
288 unsafe {
289 let f: &F = &*(f as *const F);
290 f(&from_glib_borrow(this))
291 }
292 }
293 unsafe {
294 let f: Box_<F> = Box_::new(f);
295 connect_raw(
296 self.as_ptr() as *mut _,
297 c"connected".as_ptr(),
298 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
299 connected_trampoline::<F> as *const (),
300 )),
301 Box_::into_raw(f),
302 )
303 }
304 }
305
306 #[doc(alias = "disconnected")]
307 pub fn connect_disconnected<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
308 unsafe extern "C" fn disconnected_trampoline<F: Fn(&ServerMessage) + 'static>(
309 this: *mut ffi::SoupServerMessage,
310 f: glib::ffi::gpointer,
311 ) {
312 unsafe {
313 let f: &F = &*(f as *const F);
314 f(&from_glib_borrow(this))
315 }
316 }
317 unsafe {
318 let f: Box_<F> = Box_::new(f);
319 connect_raw(
320 self.as_ptr() as *mut _,
321 c"disconnected".as_ptr(),
322 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
323 disconnected_trampoline::<F> as *const (),
324 )),
325 Box_::into_raw(f),
326 )
327 }
328 }
329
330 #[doc(alias = "finished")]
331 pub fn connect_finished<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
332 unsafe extern "C" fn finished_trampoline<F: Fn(&ServerMessage) + 'static>(
333 this: *mut ffi::SoupServerMessage,
334 f: glib::ffi::gpointer,
335 ) {
336 unsafe {
337 let f: &F = &*(f as *const F);
338 f(&from_glib_borrow(this))
339 }
340 }
341 unsafe {
342 let f: Box_<F> = Box_::new(f);
343 connect_raw(
344 self.as_ptr() as *mut _,
345 c"finished".as_ptr(),
346 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
347 finished_trampoline::<F> as *const (),
348 )),
349 Box_::into_raw(f),
350 )
351 }
352 }
353
354 #[doc(alias = "got-body")]
355 pub fn connect_got_body<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
356 unsafe extern "C" fn got_body_trampoline<F: Fn(&ServerMessage) + 'static>(
357 this: *mut ffi::SoupServerMessage,
358 f: glib::ffi::gpointer,
359 ) {
360 unsafe {
361 let f: &F = &*(f as *const F);
362 f(&from_glib_borrow(this))
363 }
364 }
365 unsafe {
366 let f: Box_<F> = Box_::new(f);
367 connect_raw(
368 self.as_ptr() as *mut _,
369 c"got-body".as_ptr(),
370 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
371 got_body_trampoline::<F> as *const (),
372 )),
373 Box_::into_raw(f),
374 )
375 }
376 }
377
378 #[doc(alias = "got-chunk")]
379 pub fn connect_got_chunk<F: Fn(&Self, &glib::Bytes) + 'static>(&self, f: F) -> SignalHandlerId {
380 unsafe extern "C" fn got_chunk_trampoline<F: Fn(&ServerMessage, &glib::Bytes) + 'static>(
381 this: *mut ffi::SoupServerMessage,
382 chunk: *mut glib::ffi::GBytes,
383 f: glib::ffi::gpointer,
384 ) {
385 unsafe {
386 let f: &F = &*(f as *const F);
387 f(&from_glib_borrow(this), &from_glib_borrow(chunk))
388 }
389 }
390 unsafe {
391 let f: Box_<F> = Box_::new(f);
392 connect_raw(
393 self.as_ptr() as *mut _,
394 c"got-chunk".as_ptr(),
395 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
396 got_chunk_trampoline::<F> as *const (),
397 )),
398 Box_::into_raw(f),
399 )
400 }
401 }
402
403 #[doc(alias = "got-headers")]
404 pub fn connect_got_headers<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
405 unsafe extern "C" fn got_headers_trampoline<F: Fn(&ServerMessage) + 'static>(
406 this: *mut ffi::SoupServerMessage,
407 f: glib::ffi::gpointer,
408 ) {
409 unsafe {
410 let f: &F = &*(f as *const F);
411 f(&from_glib_borrow(this))
412 }
413 }
414 unsafe {
415 let f: Box_<F> = Box_::new(f);
416 connect_raw(
417 self.as_ptr() as *mut _,
418 c"got-headers".as_ptr(),
419 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
420 got_headers_trampoline::<F> as *const (),
421 )),
422 Box_::into_raw(f),
423 )
424 }
425 }
426
427 #[doc(alias = "wrote-body")]
428 pub fn connect_wrote_body<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
429 unsafe extern "C" fn wrote_body_trampoline<F: Fn(&ServerMessage) + 'static>(
430 this: *mut ffi::SoupServerMessage,
431 f: glib::ffi::gpointer,
432 ) {
433 unsafe {
434 let f: &F = &*(f as *const F);
435 f(&from_glib_borrow(this))
436 }
437 }
438 unsafe {
439 let f: Box_<F> = Box_::new(f);
440 connect_raw(
441 self.as_ptr() as *mut _,
442 c"wrote-body".as_ptr(),
443 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
444 wrote_body_trampoline::<F> as *const (),
445 )),
446 Box_::into_raw(f),
447 )
448 }
449 }
450
451 #[doc(alias = "wrote-body-data")]
452 pub fn connect_wrote_body_data<F: Fn(&Self, u32) + 'static>(&self, f: F) -> SignalHandlerId {
453 unsafe extern "C" fn wrote_body_data_trampoline<F: Fn(&ServerMessage, u32) + 'static>(
454 this: *mut ffi::SoupServerMessage,
455 chunk_size: std::ffi::c_uint,
456 f: glib::ffi::gpointer,
457 ) {
458 unsafe {
459 let f: &F = &*(f as *const F);
460 f(&from_glib_borrow(this), chunk_size)
461 }
462 }
463 unsafe {
464 let f: Box_<F> = Box_::new(f);
465 connect_raw(
466 self.as_ptr() as *mut _,
467 c"wrote-body-data".as_ptr(),
468 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
469 wrote_body_data_trampoline::<F> as *const (),
470 )),
471 Box_::into_raw(f),
472 )
473 }
474 }
475
476 #[doc(alias = "wrote-chunk")]
477 pub fn connect_wrote_chunk<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
478 unsafe extern "C" fn wrote_chunk_trampoline<F: Fn(&ServerMessage) + 'static>(
479 this: *mut ffi::SoupServerMessage,
480 f: glib::ffi::gpointer,
481 ) {
482 unsafe {
483 let f: &F = &*(f as *const F);
484 f(&from_glib_borrow(this))
485 }
486 }
487 unsafe {
488 let f: Box_<F> = Box_::new(f);
489 connect_raw(
490 self.as_ptr() as *mut _,
491 c"wrote-chunk".as_ptr(),
492 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
493 wrote_chunk_trampoline::<F> as *const (),
494 )),
495 Box_::into_raw(f),
496 )
497 }
498 }
499
500 #[doc(alias = "wrote-headers")]
501 pub fn connect_wrote_headers<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
502 unsafe extern "C" fn wrote_headers_trampoline<F: Fn(&ServerMessage) + 'static>(
503 this: *mut ffi::SoupServerMessage,
504 f: glib::ffi::gpointer,
505 ) {
506 unsafe {
507 let f: &F = &*(f as *const F);
508 f(&from_glib_borrow(this))
509 }
510 }
511 unsafe {
512 let f: Box_<F> = Box_::new(f);
513 connect_raw(
514 self.as_ptr() as *mut _,
515 c"wrote-headers".as_ptr(),
516 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
517 wrote_headers_trampoline::<F> as *const (),
518 )),
519 Box_::into_raw(f),
520 )
521 }
522 }
523
524 #[doc(alias = "wrote-informational")]
525 pub fn connect_wrote_informational<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
526 unsafe extern "C" fn wrote_informational_trampoline<F: Fn(&ServerMessage) + 'static>(
527 this: *mut ffi::SoupServerMessage,
528 f: glib::ffi::gpointer,
529 ) {
530 unsafe {
531 let f: &F = &*(f as *const F);
532 f(&from_glib_borrow(this))
533 }
534 }
535 unsafe {
536 let f: Box_<F> = Box_::new(f);
537 connect_raw(
538 self.as_ptr() as *mut _,
539 c"wrote-informational".as_ptr(),
540 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
541 wrote_informational_trampoline::<F> as *const (),
542 )),
543 Box_::into_raw(f),
544 )
545 }
546 }
547
548 #[cfg(feature = "v3_2")]
549 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
550 #[doc(alias = "tls-peer-certificate")]
551 pub fn connect_tls_peer_certificate_notify<F: Fn(&Self) + 'static>(
552 &self,
553 f: F,
554 ) -> SignalHandlerId {
555 unsafe extern "C" fn notify_tls_peer_certificate_trampoline<
556 F: Fn(&ServerMessage) + 'static,
557 >(
558 this: *mut ffi::SoupServerMessage,
559 _param_spec: glib::ffi::gpointer,
560 f: glib::ffi::gpointer,
561 ) {
562 unsafe {
563 let f: &F = &*(f as *const F);
564 f(&from_glib_borrow(this))
565 }
566 }
567 unsafe {
568 let f: Box_<F> = Box_::new(f);
569 connect_raw(
570 self.as_ptr() as *mut _,
571 c"notify::tls-peer-certificate".as_ptr(),
572 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
573 notify_tls_peer_certificate_trampoline::<F> as *const (),
574 )),
575 Box_::into_raw(f),
576 )
577 }
578 }
579
580 #[cfg(feature = "v3_2")]
581 #[cfg_attr(docsrs, doc(cfg(feature = "v3_2")))]
582 #[doc(alias = "tls-peer-certificate-errors")]
583 pub fn connect_tls_peer_certificate_errors_notify<F: Fn(&Self) + 'static>(
584 &self,
585 f: F,
586 ) -> SignalHandlerId {
587 unsafe extern "C" fn notify_tls_peer_certificate_errors_trampoline<
588 F: Fn(&ServerMessage) + 'static,
589 >(
590 this: *mut ffi::SoupServerMessage,
591 _param_spec: glib::ffi::gpointer,
592 f: glib::ffi::gpointer,
593 ) {
594 unsafe {
595 let f: &F = &*(f as *const F);
596 f(&from_glib_borrow(this))
597 }
598 }
599 unsafe {
600 let f: Box_<F> = Box_::new(f);
601 connect_raw(
602 self.as_ptr() as *mut _,
603 c"notify::tls-peer-certificate-errors".as_ptr(),
604 Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
605 notify_tls_peer_certificate_errors_trampoline::<F> as *const (),
606 )),
607 Box_::into_raw(f),
608 )
609 }
610 }
611}