Struct tauri::scope::FsScope

pub struct FsScope { /* private fields */ }

Scope for filesystem access.

Implementations

impl Scope

pub fn allowed_patterns(&self) -> HashSet<Pattern>

The list of allowed patterns.

pub fn forbidden_patterns(&self) -> HashSet<Pattern>

The list of forbidden patterns.

pub fn listen<F: Fn(&Event) + Send + 'static>(&self, f: F) -> Uuid

Listen to an event on this scope.

pub fn allow_directory<P: AsRef<Path>>(
    &self,
    path: P,
    recursive: bool
) -> Result<()>

Extend the allowed patterns with the given directory.

After this function has been called, the frontend will be able to use the Tauri API to read the directory and all of its files. If recursive is true, subdirectories will be accessible too.

Examples found in repository

src/scope/mod.rs (line 33)

  pub(crate) fn allow_directory(&self, path: &Path, recursive: bool) -> crate::Result<()> {
    self.fs.allow_directory(path, recursive)?;
    #[cfg(protocol_asset)]
    self.asset_protocol.allow_directory(path, recursive)?;
    Ok(())
  }

pub fn allow_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

Extend the allowed patterns with the given file path.

After this function has been called, the frontend will be able to use the Tauri API to read the contents of this file.

Examples found in repository

src/scope/mod.rs (line 41)

  pub(crate) fn allow_file(&self, path: &Path) -> crate::Result<()> {
    self.fs.allow_file(path)?;
    #[cfg(protocol_asset)]
    self.asset_protocol.allow_file(path)?;
    Ok(())
  }

pub fn forbid_directory<P: AsRef<Path>>(
    &self,
    path: P,
    recursive: bool
) -> Result<()>

Set the given directory path to be forbidden by this scope.

Note: this takes precedence over allowed paths, so its access gets denied always.

pub fn forbid_file<P: AsRef<Path>>(&self, path: P) -> Result<()>

Set the given file path to be forbidden by this scope.

Note: this takes precedence over allowed paths, so its access gets denied always.

pub fn is_allowed<P: AsRef<Path>>(&self, path: P) -> bool

Determines if the given path is allowed on this scope.

Examples found in repository

src/endpoints/file_system.rs (line 355)

fn resolve_path<R: Runtime>(
  config: &Config,
  package_info: &PackageInfo,
  window: &Window<R>,
  path: SafePathBuf,
  dir: Option<BaseDirectory>,
) -> super::Result<SafePathBuf> {
  let env = window.state::<Env>().inner();
  match crate::api::path::resolve_path(config, package_info, env, &path, dir) {
    Ok(path) => {
      if window.state::<Scopes>().fs.is_allowed(&path) {
        Ok(
          // safety: the path is resolved by Tauri so it is safe
          unsafe { SafePathBuf::new_unchecked(path) },
        )
      } else {
        Err(anyhow::anyhow!(
          crate::Error::PathNotAllowed(path).to_string()
        ))
      }
    }
    Err(e) => super::Result::<SafePathBuf>::Err(e.into())
      .with_context(|| format!("path: {}, base dir: {:?}", path.display(), dir)),
  }
}

src/api/dir.rs (line 76)

pub(crate) fn read_dir_with_options<P: AsRef<Path>>(
  path: P,
  recursive: bool,
  options: ReadDirOptions<'_>,
) -> crate::api::Result<Vec<DiskEntry>> {
  let mut files_and_dirs: Vec<DiskEntry> = vec![];
  for entry in fs::read_dir(path)? {
    let path = entry?.path();
    let path_as_string = path.display().to_string();

    if let Ok(flag) = is_dir(&path_as_string) {
      files_and_dirs.push(DiskEntry {
        path: path.clone(),
        children: if flag {
          Some(
            if recursive
              && (!is_symlink(&path_as_string)?
                || options.scope.map(|s| s.is_allowed(&path)).unwrap_or(true))
            {
              read_dir_with_options(&path_as_string, true, options)?
            } else {
              vec![]
            },
          )
        } else {
          None
        },
        name: path
          .file_name()
          .map(|name| name.to_string_lossy())
          .map(|name| name.to_string()),
      });
    }
  }
  Result::Ok(files_and_dirs)
}

src/endpoints/http.rs (line 106)

  async fn http_request<R: Runtime>(
    context: InvokeContext<R>,
    client_id: ClientId,
    options: Box<HttpRequestBuilder>,
  ) -> super::Result<ResponseData> {
    use crate::Manager;
    let scopes = context.window.state::<crate::Scopes>();
    if scopes.http.is_allowed(&options.url) {
      let client = clients()
        .lock()
        .unwrap()
        .get(&client_id)
        .ok_or_else(|| crate::Error::HttpClientNotInitialized.into_anyhow())?
        .clone();
      let options = *options;
      if let Some(crate::api::http::Body::Form(form)) = &options.body {
        for value in form.0.values() {
          if let crate::api::http::FormPart::File {
            file: crate::api::http::FilePart::Path(path),
            ..
          } = value
          {
            if crate::api::file::SafePathBuf::new(path.clone()).is_err()
              || !scopes.fs.is_allowed(&path)
            {
              return Err(crate::Error::PathNotAllowed(path.clone()).into_anyhow());
            }
          }
        }
      }
      let response = client.send(options).await?;
      Ok(response.read().await?)
    } else {
      Err(crate::Error::UrlNotAllowed(options.url).into_anyhow())
    }
  }

src/manager.rs (line 522)

  fn prepare_pending_window(
    &self,
    mut pending: PendingWindow<EventLoopMessage, R>,
    label: &str,
    window_labels: &[String],
    app_handle: AppHandle<R>,
    web_resource_request_handler: Option<Box<WebResourceRequestHandler>>,
  ) -> crate::Result<PendingWindow<EventLoopMessage, R>> {
    let is_init_global = self.inner.config.build.with_global_tauri;
    let plugin_init = self
      .inner
      .plugins
      .lock()
      .expect("poisoned plugin store")
      .initialization_script();

    let pattern_init = PatternJavascript {
      pattern: self.pattern().into(),
    }
    .render_default(&Default::default())?;

    let ipc_init = IpcJavascript {
      isolation_origin: &match self.pattern() {
        #[cfg(feature = "isolation")]
        Pattern::Isolation { schema, .. } => crate::pattern::format_real_schema(schema),
        _ => "".to_string(),
      },
    }
    .render_default(&Default::default())?;

    let mut webview_attributes = pending.webview_attributes;

    let mut window_labels = window_labels.to_vec();
    let l = label.to_string();
    if !window_labels.contains(&l) {
      window_labels.push(l);
    }
    webview_attributes = webview_attributes
      .initialization_script(&self.inner.invoke_initialization_script)
      .initialization_script(&format!(
        r#"
          Object.defineProperty(window, '__TAURI_METADATA__', {{
            value: {{
              __windows: {window_labels_array}.map(function (label) {{ return {{ label: label }} }}),
              __currentWindow: {{ label: {current_window_label} }}
            }}
          }})
        "#,
        window_labels_array = serde_json::to_string(&window_labels)?,
        current_window_label = serde_json::to_string(&label)?,
      ))
      .initialization_script(&self.initialization_script(&ipc_init.into_string(),&pattern_init.into_string(),&plugin_init, is_init_global)?)
      ;

    #[cfg(feature = "isolation")]
    if let Pattern::Isolation { schema, .. } = self.pattern() {
      webview_attributes = webview_attributes.initialization_script(
        &IsolationJavascript {
          origin: self.get_browser_origin(),
          isolation_src: &crate::pattern::format_real_schema(schema),
          style: tauri_utils::pattern::isolation::IFRAME_STYLE,
        }
        .render_default(&Default::default())?
        .into_string(),
      );
    }

    pending.webview_attributes = webview_attributes;

    let mut registered_scheme_protocols = Vec::new();

    for (uri_scheme, protocol) in &self.inner.uri_scheme_protocols {
      registered_scheme_protocols.push(uri_scheme.clone());
      let protocol = protocol.clone();
      let app_handle = Mutex::new(app_handle.clone());
      pending.register_uri_scheme_protocol(uri_scheme.clone(), move |p| {
        (protocol.protocol)(&app_handle.lock().unwrap(), p)
      });
    }

    let window_url = Url::parse(&pending.url).unwrap();
    let window_origin =
      if cfg!(windows) && window_url.scheme() != "http" && window_url.scheme() != "https" {
        format!("https://{}.localhost", window_url.scheme())
      } else {
        format!(
          "{}://{}{}",
          window_url.scheme(),
          window_url.host().unwrap(),
          if let Some(port) = window_url.port() {
            format!(":{}", port)
          } else {
            "".into()
          }
        )
      };

    if !registered_scheme_protocols.contains(&"tauri".into()) {
      pending.register_uri_scheme_protocol(
        "tauri",
        self.prepare_uri_scheme_protocol(&window_origin, web_resource_request_handler),
      );
      registered_scheme_protocols.push("tauri".into());
    }

    #[cfg(protocol_asset)]
    if !registered_scheme_protocols.contains(&"asset".into()) {
      use crate::api::file::SafePathBuf;
      use tokio::io::{AsyncReadExt, AsyncSeekExt};
      use url::Position;
      let asset_scope = self.state().get::<crate::Scopes>().asset_protocol.clone();
      pending.register_uri_scheme_protocol("asset", move |request| {
        let parsed_path = Url::parse(request.uri())?;
        let filtered_path = &parsed_path[..Position::AfterPath];
        #[cfg(target_os = "windows")]
        let path = filtered_path
          .strip_prefix("asset://localhost/")
          // the `strip_prefix` only returns None when a request is made to `https://tauri.$P` on Windows
          // where `$P` is not `localhost/*`
          .unwrap_or("");
        // safe to unwrap: request.uri() always starts with this prefix
        #[cfg(not(target_os = "windows"))]
        let path = filtered_path.strip_prefix("asset://").unwrap();
        let path = percent_encoding::percent_decode(path.as_bytes())
          .decode_utf8_lossy()
          .to_string();

        if let Err(e) = SafePathBuf::new(path.clone().into()) {
          debug_eprintln!("asset protocol path \"{}\" is not valid: {}", path, e);
          return HttpResponseBuilder::new().status(403).body(Vec::new());
        }

        if !asset_scope.is_allowed(&path) {
          debug_eprintln!("asset protocol not configured to allow the path: {}", path);
          return HttpResponseBuilder::new().status(403).body(Vec::new());
        }

        let path_ = path.clone();

        let mut response =
          HttpResponseBuilder::new().header("Access-Control-Allow-Origin", &window_origin);

        // handle 206 (partial range) http request
        if let Some(range) = request
          .headers()
          .get("range")
          .and_then(|r| r.to_str().map(|r| r.to_string()).ok())
        {
          let (headers, status_code, data) = crate::async_runtime::safe_block_on(async move {
            let mut headers = HashMap::new();
            let mut buf = Vec::new();
            // open the file
            let mut file = match tokio::fs::File::open(path_.clone()).await {
              Ok(file) => file,
              Err(e) => {
                debug_eprintln!("Failed to open asset: {}", e);
                return (headers, 404, buf);
              }
            };
            // Get the file size
            let file_size = match file.metadata().await {
              Ok(metadata) => metadata.len(),
              Err(e) => {
                debug_eprintln!("Failed to read asset metadata: {}", e);
                return (headers, 404, buf);
              }
            };
            // parse the range
            let range = match crate::runtime::http::HttpRange::parse(
              &if range.ends_with("-*") {
                range.chars().take(range.len() - 1).collect::<String>()
              } else {
                range.clone()
              },
              file_size,
            ) {
              Ok(r) => r,
              Err(e) => {
                debug_eprintln!("Failed to parse range {}: {:?}", range, e);
                return (headers, 400, buf);
              }
            };

            // FIXME: Support multiple ranges
            // let support only 1 range for now
            let status_code = if let Some(range) = range.first() {
              let mut real_length = range.length;
              // prevent max_length;
              // specially on webview2
              if range.length > file_size / 3 {
                // max size sent (400ko / request)
                // as it's local file system we can afford to read more often
                real_length = std::cmp::min(file_size - range.start, 1024 * 400);
              }

              // last byte we are reading, the length of the range include the last byte
              // who should be skipped on the header
              let last_byte = range.start + real_length - 1;

              headers.insert("Connection", "Keep-Alive".into());
              headers.insert("Accept-Ranges", "bytes".into());
              headers.insert("Content-Length", real_length.to_string());
              headers.insert(
                "Content-Range",
                format!("bytes {}-{}/{}", range.start, last_byte, file_size),
              );

              if let Err(e) = file.seek(std::io::SeekFrom::Start(range.start)).await {
                debug_eprintln!("Failed to seek file to {}: {}", range.start, e);
                return (headers, 422, buf);
              }

              if let Err(e) = file.take(real_length).read_to_end(&mut buf).await {
                debug_eprintln!("Failed read file: {}", e);
                return (headers, 422, buf);
              }
              // partial content
              206
            } else {
              200
            };

            (headers, status_code, buf)
          });

          for (k, v) in headers {
            response = response.header(k, v);
          }

          let mime_type = MimeType::parse(&data, &path);
          response.mimetype(&mime_type).status(status_code).body(data)
        } else {
          match crate::async_runtime::safe_block_on(async move { tokio::fs::read(path_).await }) {
            Ok(data) => {
              let mime_type = MimeType::parse(&data, &path);
              response.mimetype(&mime_type).body(data)
            }
            Err(e) => {
              debug_eprintln!("Failed to read file: {}", e);
              response.status(404).body(Vec::new())
            }
          }
        }
      });
    }

    #[cfg(feature = "isolation")]
    if let Pattern::Isolation {
      assets,
      schema,
      key: _,
      crypto_keys,
    } = &self.inner.pattern
    {
      let assets = assets.clone();
      let schema_ = schema.clone();
      let url_base = format!("{}://localhost", schema_);
      let aes_gcm_key = *crypto_keys.aes_gcm().raw();

      pending.register_uri_scheme_protocol(schema, move |request| {
        match request_to_path(request, &url_base).as_str() {
          "index.html" => match assets.get(&"index.html".into()) {
            Some(asset) => {
              let asset = String::from_utf8_lossy(asset.as_ref());
              let template = tauri_utils::pattern::isolation::IsolationJavascriptRuntime {
                runtime_aes_gcm_key: &aes_gcm_key,
              };
              match template.render(asset.as_ref(), &Default::default()) {
                Ok(asset) => HttpResponseBuilder::new()
                  .mimetype("text/html")
                  .body(asset.into_string().as_bytes().to_vec()),
                Err(_) => HttpResponseBuilder::new()
                  .status(500)
                  .mimetype("text/plain")
                  .body(Vec::new()),
              }
            }

            None => HttpResponseBuilder::new()
              .status(404)
              .mimetype("text/plain")
              .body(Vec::new()),
          },
          _ => HttpResponseBuilder::new()
            .status(404)
            .mimetype("text/plain")
            .body(Vec::new()),
        }
      });
    }

    Ok(pending)
  }

Trait Implementations

impl Clone for Scope

fn clone(&self) -> Scope

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Scope

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.