`47ba17e`

derive caller from dbus header

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 2 months ago

SHA: 47ba17eab2ddabedd3fe5ee5d69ee39088a6ed3a
Parents: a3b9db6
Tree: 8091f4f

1 changed file

Status	File	+	-
M	`garwarp/src/dbus.rs`	94	13

garwarp/src/dbus.rsmodified

  use zbus::{
      blocking::Connection,
      interface,
++    message::Header,
      zvariant::{OwnedObjectPath, OwnedValue},
  };
--use crate::error::PortalResponseCode;
++use crate::error::{PortalError, map_portal_error};
++use crate::portal::derive_request_id_from_handle;
  pub const BACKEND_DBUS_NAME: &str = "org.freedesktop.impl.portal.desktop.garwarp";
  pub const BACKEND_OBJECT_PATH: &str = "/org/freedesktop/portal/desktop";
  type PortalMethodReply = (u32, HashMap<String, OwnedValue>);
  fn failed_response() -> PortalMethodReply {
--    (PortalResponseCode::Failed as u32, HashMap::new())
++    failure_response(&PortalError::InternalFailure)
++}
++
++fn failure_response(error: &PortalError) -> PortalMethodReply {
++    let mapping = map_portal_error(error);
++    (mapping.code as u32, HashMap::new())
++}
++
++fn request_id_for_call(
++    request_handle: &OwnedObjectPath,
++    header: Header<'_>,
++) -> Result<String, PortalError> {
++    let sender = header
++        .sender()
++        .map(|sender| sender.as_str())
++        .ok_or(PortalError::UnauthorizedClient)?;
++
++    derive_request_id_from_handle(sender, request_handle.as_str())
+ }
  pub struct SessionNameGuard {
  impl ScreenshotPortal {
      fn screenshot(
          &self,
--        _handle: OwnedObjectPath,
++        handle: OwnedObjectPath,
          _app_id: &str,
          _parent_window: &str,
          _options: HashMap<String, OwnedValue>,
++        #[zbus(header)] header: Header<'_>,
      ) -> PortalMethodReply {
++        if let Err(error) = request_id_for_call(&handle, header) {
++            return failure_response(&error);
++        }
          failed_response()
+     }
      fn pick_color(
          &self,
--        _handle: OwnedObjectPath,
++        handle: OwnedObjectPath,
          _app_id: &str,
          _parent_window: &str,
          _options: HashMap<String, OwnedValue>,
++        #[zbus(header)] header: Header<'_>,
      ) -> PortalMethodReply {
++        if let Err(error) = request_id_for_call(&handle, header) {
++            return failure_response(&error);
++        }
          failed_response()
+     }
  impl FileChooserPortal {
      fn open_file(
          &self,
--        _handle: OwnedObjectPath,
++        handle: OwnedObjectPath,
          _app_id: &str,
          _parent_window: &str,
          _title: &str,
          _options: HashMap<String, OwnedValue>,
++        #[zbus(header)] header: Header<'_>,
      ) -> PortalMethodReply {
++        if let Err(error) = request_id_for_call(&handle, header) {
++            return failure_response(&error);
++        }
          failed_response()
+     }
      fn save_file(
          &self,
--        _handle: OwnedObjectPath,
++        handle: OwnedObjectPath,
          _app_id: &str,
          _parent_window: &str,
          _title: &str,
          _options: HashMap<String, OwnedValue>,
++        #[zbus(header)] header: Header<'_>,
      ) -> PortalMethodReply {
++        if let Err(error) = request_id_for_call(&handle, header) {
++            return failure_response(&error);
++        }
          failed_response()
+     }
      fn save_files(
          &self,
--        _handle: OwnedObjectPath,
++        handle: OwnedObjectPath,
          _app_id: &str,
          _parent_window: &str,
          _title: &str,
          _options: HashMap<String, OwnedValue>,
++        #[zbus(header)] header: Header<'_>,
      ) -> PortalMethodReply {
++        if let Err(error) = request_id_for_call(&handle, header) {
++            return failure_response(&error);
++        }
          failed_response()
+     }
  impl AppChooserPortal {
      fn choose_application(
          &self,
--        _handle: OwnedObjectPath,
++        handle: OwnedObjectPath,
          _app_id: &str,
          _parent_window: &str,
          _choices: Vec<String>,
          _options: HashMap<String, OwnedValue>,
++        #[zbus(header)] header: Header<'_>,
      ) -> PortalMethodReply {
++        if let Err(error) = request_id_for_call(&handle, header) {
++            return failure_response(&error);
++        }
          failed_response()
+     }
--    fn update_choices(&self, _handle: OwnedObjectPath, _choices: Vec<String>) {}
++    fn update_choices(
++        &self,
++        handle: OwnedObjectPath,
++        _choices: Vec<String>,
++        #[zbus(header)] header: Header<'_>,
++    ) -> zbus::fdo::Result<()> {
++        request_id_for_call(&handle, header)
++            .map(|_| ())
++            .map_err(|error| zbus::fdo::Error::Failed(map_portal_error(&error).reason.to_string()))
++    }
      #[zbus(property)]
      fn version(&self) -> u32 {
          ScreenshotPortal,
      };
      use crate::error::PortalResponseCode;
--    use zbus::zvariant::{OwnedObjectPath, OwnedValue};
++    use zbus::{
++        message::{Header, Message},
++        zvariant::{OwnedObjectPath, OwnedValue},
++    };
      #[test]
      fn backend_object_path_is_portal_desktop_path() {
              "org.test.App",
              "x11:0x2a",
              options.clone(),
++            test_call_header(),
          );
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
--        let (response, results) =
++        let (response, results) = ScreenshotPortal.pick_color(
--            ScreenshotPortal.pick_color(request_handle_path(), "org.test.App", "", options);
++            request_handle_path(),
++            "org.test.App",
++            "",
++            options,
++            test_call_header(),
++        );
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
+     }
              "",
              "Open",
              options.clone(),
++            test_call_header(),
          );
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
              "",
              "Save",
              options.clone(),
++            test_call_header(),
          );
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
              "",
              "Save",
              options,
++            test_call_header(),
          );
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
              "",
              choices.clone(),
              options,
++            test_call_header(),
          );
          assert_eq!(response, PortalResponseCode::Failed as u32);
          assert!(results.is_empty());
--        AppChooserPortal.update_choices(request_handle_path(), choices);
++        let error = AppChooserPortal
++            .update_choices(request_handle_path(), choices, test_call_header())
++            .expect_err("update choices should reject missing sender metadata");
++        match error {
++            zbus::fdo::Error::Failed(reason) => assert_eq!(reason, "unauthorized_client"),
++            other => panic!("unexpected update choices error: {other:?}"),
++        }
+     }
      fn request_handle_path() -> OwnedObjectPath {
          OwnedObjectPath::try_from("/org/freedesktop/portal/desktop/request/1_42/token_1")
              .expect("valid request object path")
+     }
++
++    fn test_call_header() -> Header<'static> {
++        let call = Message::method_call(BACKEND_OBJECT_PATH, "TestCall")
++            .expect("test call builder")
++            .interface("org.freedesktop.impl.portal.Screenshot")
++            .expect("test interface")
++            .build(&())
++            .expect("test message");
++        Box::leak(Box::new(call)).header()
++    }
+ }