Lightweight coding agent that runs in your terminal
Rust
Prepare managed policy validation for Windows sandbox provisioning (#42344)
johnl-oaic4ea7294b989
diff --git a/codex-rs/Cargo.lock b/codex-rs/Cargo.lockindex dba3abd7a1..9a31b5f104 100644--- a/codex-rs/Cargo.lock+++ b/codex-rs/Cargo.lock@@ -4977,7 +4977,12 @@ name = "codex-windows-sandbox-service"version = "0.0.0"dependencies = ["anyhow",+ "codex-cloud-config",+ "codex-config",+ "codex-core","codex-windows-sandbox",+ "tokio",+ "toml 0.9.11+spec-1.1.0","windows-sys 0.52.0",]diff --git a/codex-rs/cloud-config/src/bundle_loader.rs b/codex-rs/cloud-config/src/bundle_loader.rsindex d95f9bdb87..d38355189f 100644--- a/codex-rs/cloud-config/src/bundle_loader.rs+++ b/codex-rs/cloud-config/src/bundle_loader.rs@@ -88,24 +88,45 @@ pub async fn cloud_config_bundle_loader_for_storage(auth_config: AuthConfig,enable_codex_api_key_env: bool,) -> std::io::Result<CloudConfigBundleLoader> {- let auth_manager =- AuthManager::shared_from_auth_config(auth_config.clone(), enable_codex_api_key_env).await?;- Ok(cloud_config_bundle_loader_from_auth_config(- auth_config,- auth_manager,- ))+ let service =+ cloud_config_bundle_service_for_storage(auth_config, enable_codex_api_key_env).await?;+ let (loader, refresh_task) = cloud_config_bundle_loader_for_service(service);+ replace_refresh_task(refresher_task_slot(), refresh_task);+ Ok(loader)}-fn cloud_config_bundle_loader_from_auth_config(+/// Fetches directly from the network on each load, without reading or writing+/// the disk cache or starting a background refresher.+pub async fn cloud_config_bundle_loader_for_storage_without_cache(auth_config: AuthConfig,- auth_manager: Arc<AuthManager>,-) -> CloudConfigBundleLoader {- cloud_config_bundle_loader(+ enable_codex_api_key_env: bool,+) -> std::io::Result<CloudConfigBundleLoader> {+ let service = Arc::new(+ cloud_config_bundle_service_for_storage(auth_config, enable_codex_api_key_env)+ .await?+ .without_cache(),+ );+ Ok(CloudConfigBundleLoader::from_getter(move || {+ let service = Arc::clone(&service);+ async move { service.load_startup_bundle_with_timeout().await }+ }))+}++async fn cloud_config_bundle_service_for_storage(+ auth_config: AuthConfig,+ enable_codex_api_key_env: bool,+) -> std::io::Result<CloudConfigBundleService<BackendBundleClient>> {+ let auth_manager =+ AuthManager::shared_from_auth_config(auth_config.clone(), enable_codex_api_key_env).await?;+ Ok(CloudConfigBundleService::new(auth_manager,- auth_config- .chatgpt_base_url- .unwrap_or_else(|| "https://chatgpt.com/backend-api/".to_string()),+ Arc::new(BackendBundleClient::new(+ auth_config+ .chatgpt_base_url+ .unwrap_or_else(|| "https://chatgpt.com/backend-api/".to_string()),+ auth_config.auth_route_config.http_client_factory().clone(),+ )),auth_config.codex_home,- auth_config.auth_route_config.http_client_factory().clone(),- )+ CLOUD_CONFIG_BUNDLE_TIMEOUT,+ ))}diff --git a/codex-rs/cloud-config/src/lib.rs b/codex-rs/cloud-config/src/lib.rsindex 0e742f5522..3bcf30f4c3 100644--- a/codex-rs/cloud-config/src/lib.rs+++ b/codex-rs/cloud-config/src/lib.rs@@ -12,3 +12,4 @@ mod validation;pub use bundle_loader::cloud_config_bundle_loader;pub use bundle_loader::cloud_config_bundle_loader_for_storage;+pub use bundle_loader::cloud_config_bundle_loader_for_storage_without_cache;diff --git a/codex-rs/cloud-config/src/service.rs b/codex-rs/cloud-config/src/service.rsindex faafe895a1..25326c4d5b 100644--- a/codex-rs/cloud-config/src/service.rs+++ b/codex-rs/cloud-config/src/service.rs@@ -2,6 +2,7 @@//!//! Startup loads a shared bundle from cache or backend, and background refresh//! updates both the on-disk cache and the bundle observed by future config loads.+//! One-shot network loads can disable disk-cache reads and writes.use crate::backend::BundleClient;use crate::backend::BundleRequestError;@@ -78,6 +79,7 @@ pub(crate) struct CloudConfigBundleService<C> {auth_manager: Arc<AuthManager>,client: Arc<C>,cache: CloudConfigBundleCache,+ cache_enabled: bool,codex_home: AbsolutePathBuf,timeout: Duration,latest_bundle: OnceCell<Mutex<Result<Option<CloudConfigBundle>, CloudConfigBundleLoadError>>>,@@ -98,12 +100,18 @@ whereauth_manager,client,cache: CloudConfigBundleCache::new(codex_home.clone()),+ cache_enabled: true,codex_home,timeout,latest_bundle: OnceCell::new(),}}+ pub(crate) fn without_cache(mut self) -> Self {+ self.cache_enabled = false;+ self+ }+pub(crate) async fn get_latest(&self,) -> Result<Option<CloudConfigBundle>, CloudConfigBundleLoadError> {@@ -182,15 +190,17 @@ wherereturn Ok(None);}- // Startup prefers a valid, identity-matched cache entry. The backend is- // only consulted on cache miss or invalid cache contents.- let (chatgpt_user_id, account_id) = auth_identity(&auth);- match self- .load_valid_cached_bundle(chatgpt_user_id.as_deref(), account_id.as_deref())- .await- {- CachedBundleLookup::Hit(bundle) => return Ok(bundle),- CachedBundleLookup::Miss => {}+ if self.cache_enabled {+ // Startup prefers a valid, identity-matched cache entry. The backend is+ // only consulted on cache miss or invalid cache contents.+ let (chatgpt_user_id, account_id) = auth_identity(&auth);+ match self+ .load_valid_cached_bundle(chatgpt_user_id.as_deref(), account_id.as_deref())+ .await+ {+ CachedBundleLookup::Hit(bundle) => return Ok(bundle),+ CachedBundleLookup::Miss => {}+ }}self.fetch_remote_bundle_and_update_cache_with_retries(auth, "startup")@@ -322,10 +332,11 @@ where}let (chatgpt_user_id, account_id) = auth_identity(auth);- if let Err(err) = self- .cache- .save(chatgpt_user_id, account_id, bundle.clone())- .await+ if self.cache_enabled+ && let Err(err) = self+ .cache+ .save(chatgpt_user_id, account_id, bundle.clone())+ .await{tracing::warn!(error = %err,diff --git a/codex-rs/cloud-config/src/service_tests.rs b/codex-rs/cloud-config/src/service_tests.rsindex d1d0c347d2..3760694b1e 100644--- a/codex-rs/cloud-config/src/service_tests.rs+++ b/codex-rs/cloud-config/src/service_tests.rs@@ -634,6 +634,74 @@ async fn get_bundle_uses_cache_when_valid() {assert_eq!(fetcher.request_count.load(Ordering::SeqCst), 0);}+#[tokio::test]+async fn get_bundle_without_cache_ignores_and_preserves_valid_cache() {+ let codex_home = tempdir().expect("tempdir");+ let cache = create_test_cache(codex_home.path());+ cache+ .save(+ Some("user-12345".to_string()),+ Some("account-12345".to_string()),+ CloudConfigBundle::default(),+ )+ .await+ .expect("write empty cache");+ let cached_bytes = std::fs::read(cache.path()).expect("read cache");+ let bundle = test_bundle();+ let fetcher = Arc::new(StaticBundleClient::new(bundle.clone()));+ let service = CloudConfigBundleService::new(+ auth_manager_with_plan("business").await,+ fetcher.clone(),+ codex_home.path().to_path_buf(),+ CLOUD_CONFIG_BUNDLE_TIMEOUT,+ )+ .without_cache();++ assert_eq!(+ service.load_startup_bundle_with_timeout().await,+ Ok(Some(bundle))+ );+ assert_eq!(fetcher.request_count.load(Ordering::SeqCst), 1);+ assert_eq!(+ std::fs::read(cache.path()).expect("read unchanged cache"),+ cached_bytes+ );+}++#[tokio::test(start_paused = true)]+async fn get_bundle_without_cache_fails_closed_on_request_failure() {+ let codex_home = tempdir().expect("tempdir");+ create_test_cache(codex_home.path())+ .save(+ Some("user-12345".to_string()),+ Some("account-12345".to_string()),+ test_bundle(),+ )+ .await+ .expect("write valid cache");+ let fetcher = Arc::new(SequenceBundleClient::new(vec![+ Err(request_error());+ CLOUD_CONFIG_BUNDLE_MAX_ATTEMPTS+ ]));+ let service = CloudConfigBundleService::new(+ auth_manager_with_plan("business").await,+ fetcher.clone(),+ codex_home.path().to_path_buf(),+ CLOUD_CONFIG_BUNDLE_TIMEOUT,+ )+ .without_cache();++ let err = service+ .load_startup_bundle_with_timeout()+ .await+ .expect_err("request failure must not fall back to the cache");+ assert_eq!(err.code(), CloudConfigBundleLoadErrorCode::RequestFailed);+ assert_eq!(+ fetcher.request_count.load(Ordering::SeqCst),+ CLOUD_CONFIG_BUNDLE_MAX_ATTEMPTS+ );+}+#[tokio::test]async fn get_bundle_ignores_cache_for_different_auth_identity() {let codex_home = tempdir().expect("tempdir");diff --git a/codex-rs/windows-sandbox-service/Cargo.toml b/codex-rs/windows-sandbox-service/Cargo.tomlindex 97632ad5b2..5d6baa76b7 100644--- a/codex-rs/windows-sandbox-service/Cargo.toml+++ b/codex-rs/windows-sandbox-service/Cargo.toml@@ -18,7 +18,14 @@ workspace = true[dependencies]anyhow = { workspace = true }+codex-cloud-config = { workspace = true }+codex-config = { workspace = true }+codex-core = { workspace = true }codex-windows-sandbox = { workspace = true }+tokio = { workspace = true, features = ["macros", "rt", "sync", "time"] }++[dev-dependencies]+toml = { workspace = true }[target.'cfg(windows)'.dependencies.windows-sys]version = "0.52"diff --git a/codex-rs/windows-sandbox-service/src/lib.rs b/codex-rs/windows-sandbox-service/src/lib.rsindex 56dc54d141..04dd1c2ea3 100644--- a/codex-rs/windows-sandbox-service/src/lib.rs+++ b/codex-rs/windows-sandbox-service/src/lib.rs@@ -2,6 +2,10 @@ use anyhow::Result;#[cfg(windows)]mod ipc;+// Provisioning remains disabled until authenticated transport connects this policy.+#[cfg(windows)]+#[allow(dead_code)]+mod machine_policy;#[cfg(windows)]mod service;diff --git a/codex-rs/windows-sandbox-service/src/machine_policy.rs b/codex-rs/windows-sandbox-service/src/machine_policy.rsnew file mode 100644index 0000000000..85c43f78ae--- /dev/null+++ b/codex-rs/windows-sandbox-service/src/machine_policy.rs@@ -0,0 +1,138 @@+//! Validates provisioning requests against the standard managed configuration layers.++use anyhow::Context;+use anyhow::Result;+use anyhow::bail;+use codex_cloud_config::cloud_config_bundle_loader_for_storage_without_cache;+use codex_config::ConfigLoadOptions;+use codex_config::ConfigRequirementsToml;+use codex_config::types::WindowsSandboxModeToml;+use codex_core::config::bootstrap_auth_config;+use codex_core::config::load_config_toml_with_layer_stack;+use codex_windows_sandbox::WindowsSandboxProvisioningSettings;+use codex_windows_sandbox::WindowsSandboxProxyListeners;+use std::path::Path;+use std::sync::Arc;+use tokio::sync::Notify;+use windows_sys::Win32::Foundation::HANDLE;+use windows_sys::Win32::Security::ImpersonateLoggedOnUser;++pub(crate) fn validate_provisioning_settings(+ codex_home: &Path,+ settings: &WindowsSandboxProvisioningSettings,+ listeners: &WindowsSandboxProxyListeners,+ impersonation_token: HANDLE,+) -> Result<()> {+ let impersonation_failure = Arc::new(Notify::new());+ let worker_impersonation_failure = Arc::clone(&impersonation_failure);+ let runtime = tokio::runtime::Builder::new_current_thread()+ .enable_all()+ .on_thread_start(move || {+ if unsafe { ImpersonateLoggedOnUser(impersonation_token) } == 0 {+ let error = std::io::Error::last_os_error();+ worker_impersonation_failure.notify_one();+ panic!(+ "failed to impersonate provisioning client on configuration runtime thread: {error}"+ );+ }+ })+ .build()+ .context("start managed configuration runtime")?;+ let requirements = runtime.block_on(async {+ tokio::select! {+ biased;+ () = impersonation_failure.notified() => {+ Err(anyhow::anyhow!("configuration runtime worker failed to impersonate the provisioning client"))+ },+ result = async {+ let mut bootstrap_config = load_config_toml_with_layer_stack(+ codex_home,+ /*cwd*/ None,+ Vec::new(),+ ConfigLoadOptions::default(),+ )+ .await+ .context("load bootstrap configuration")?;+ // Use the default cloud-policy endpoint unless managed requirements override it.+ bootstrap_config.config_toml.chatgpt_base_url = None;+ let cloud_config_bundle = cloud_config_bundle_loader_for_storage_without_cache(+ bootstrap_auth_config(codex_home, &bootstrap_config)+ .context("resolve cloud configuration authentication")?,+ /*enable_codex_api_key_env*/ false,+ )+ .await+ .context("initialize cloud configuration authentication")?;+ let config = load_config_toml_with_layer_stack(+ codex_home,+ /*cwd*/ None,+ Vec::new(),+ ConfigLoadOptions {+ cloud_config_bundle,+ ..Default::default()+ },+ )+ .await+ .context("load managed configuration")?;++ Ok::<_, anyhow::Error>(config.config_layer_stack.requirements_toml().clone())+ } => result,+ }+ })?;++ validate_requirements(settings, listeners, &requirements)+ .context("enforce managed provisioning requirements")+}++fn validate_requirements(+ settings: &WindowsSandboxProvisioningSettings,+ listeners: &WindowsSandboxProxyListeners,+ requirements: &ConfigRequirementsToml,+) -> Result<()> {+ if requirements+ .windows+ .as_ref()+ .and_then(|windows| windows.allowed_sandbox_implementations.as_ref())+ .is_some_and(|allowed| !allowed.contains(&WindowsSandboxModeToml::Elevated))+ {+ bail!("managed policy does not permit the elevated Windows sandbox");+ }++ let Some(network) = requirements.network.as_ref() else {+ return Ok(());+ };+ if network.enabled == Some(false)+ && (settings.allow_local_binding || !settings.proxy_ports.is_empty())+ {+ bail!("managed policy disables sandbox network access");+ }+ if settings.allow_local_binding && network.allow_local_binding == Some(false) {+ bail!("managed policy does not permit local network binding");+ }+ if let Some(required) = network.http_port+ && let Some(actual) = listeners.http_ports.iter().find(|port| **port != required)+ {+ bail!("managed policy does not permit HTTP proxy port {actual}");+ }+ if let Some(required) = network.socks_port+ && let Some(actual) = listeners.socks_ports.iter().find(|port| **port != required)+ {+ bail!("managed policy does not permit SOCKS proxy port {actual}");+ }+ // Omitting listener identities must not bypass managed port restrictions.+ if network.http_port.is_some() || network.socks_port.is_some() {+ for port in &settings.proxy_ports {+ if !listeners.http_ports.contains(port)+ && !listeners.socks_ports.contains(port)+ && network.http_port != Some(*port)+ && network.socks_port != Some(*port)+ {+ bail!("managed policy does not permit unclassified proxy port {port}");+ }+ }+ }+ Ok(())+}++#[cfg(test)]+#[path = "machine_policy_tests.rs"]+mod tests;diff --git a/codex-rs/windows-sandbox-service/src/machine_policy_tests.rs b/codex-rs/windows-sandbox-service/src/machine_policy_tests.rsnew file mode 100644index 0000000000..17b92359cc--- /dev/null+++ b/codex-rs/windows-sandbox-service/src/machine_policy_tests.rs@@ -0,0 +1,277 @@+use anyhow::Result;+use codex_config::ConfigRequirementsToml;+use codex_windows_sandbox::WindowsSandboxProvisioningSettings;+use codex_windows_sandbox::WindowsSandboxProxyListeners;++fn validate_requirements(+ settings: &WindowsSandboxProvisioningSettings,+ listeners: WindowsSandboxProxyListeners,+ contents: &str,+) -> Result<()> {+ let requirements: ConfigRequirementsToml = toml::from_str(contents)?;+ super::validate_requirements(settings, &listeners, &requirements)+}++#[test]+fn runtime_worker_impersonation_failure_rejects_provisioning() {+ let error = super::validate_provisioning_settings(+ &std::env::temp_dir(),+ &WindowsSandboxProvisioningSettings::default(),+ &WindowsSandboxProxyListeners::default(),+ /*impersonation_token*/ 0,+ )+ .expect_err("runtime workers must not load configuration without impersonating the client");++ assert!(error.to_string().contains("failed to impersonate"));+}++#[test]+fn unmanaged_policy_allows_default_and_requested_network_settings() -> Result<()> {+ validate_requirements(+ &WindowsSandboxProvisioningSettings::default(),+ WindowsSandboxProxyListeners::default(),+ "",+ )?;+ validate_requirements(+ &WindowsSandboxProvisioningSettings {+ proxy_ports: vec![3128, 8080, 9000],+ allow_local_binding: true,+ },+ WindowsSandboxProxyListeners {+ http_ports: vec![3128],+ socks_ports: vec![8080],+ },+ "allowed_sandbox_modes = [\"workspace-write\"]",+ )+}++#[test]+fn elevated_sandbox_is_allowed_when_included() -> Result<()> {+ validate_requirements(+ &WindowsSandboxProvisioningSettings::default(),+ WindowsSandboxProxyListeners::default(),+ "[windows]\nallowed_sandbox_implementations = [\"unelevated\", \"elevated\"]",+ )+}++#[test]+fn elevated_sandbox_is_rejected_when_prohibited_or_empty() {+ for implementations in ["[\"unelevated\"]", "[]"] {+ let policy = format!("[windows]\nallowed_sandbox_implementations = {implementations}");+ assert!(+ validate_requirements(+ &WindowsSandboxProvisioningSettings::default(),+ WindowsSandboxProxyListeners::default(),+ &policy,+ )+ .is_err()+ );+ }+}++#[test]+fn forbidden_local_binding_is_rejected() {+ let settings = WindowsSandboxProvisioningSettings {+ proxy_ports: Vec::new(),+ allow_local_binding: true,+ };+ assert!(+ validate_requirements(+ &settings,+ WindowsSandboxProxyListeners::default(),+ "[experimental_network]\nallow_local_binding = false"+ )+ .is_err()+ );+}++#[test]+fn disabled_network_rejects_proxy_ports_and_local_binding() -> Result<()> {+ let policy = "[experimental_network]\nenabled = false";+ validate_requirements(+ &WindowsSandboxProvisioningSettings::default(),+ WindowsSandboxProxyListeners::default(),+ policy,+ )?;+ for settings in [+ WindowsSandboxProvisioningSettings {+ proxy_ports: vec![3128],+ allow_local_binding: false,+ },+ WindowsSandboxProvisioningSettings {+ proxy_ports: Vec::new(),+ allow_local_binding: true,+ },+ ] {+ assert!(+ validate_requirements(&settings, WindowsSandboxProxyListeners::default(), policy)+ .is_err()+ );+ }+ Ok(())+}++#[test]+fn enabled_network_allows_unrestricted_proxy_ports() -> Result<()> {+ validate_requirements(+ &WindowsSandboxProvisioningSettings {+ proxy_ports: vec![3128, 8080, 8081, 9000],+ allow_local_binding: false,+ },+ WindowsSandboxProxyListeners {+ http_ports: vec![3128, 8080],+ socks_ports: vec![8081],+ },+ "[experimental_network]\nenabled = true",+ )+}++#[test]+fn disabled_local_binding_is_allowed_when_policy_permits_binding() -> Result<()> {+ validate_requirements(+ &WindowsSandboxProvisioningSettings::default(),+ WindowsSandboxProxyListeners::default(),+ "[experimental_network]\nallow_local_binding = true",+ )+}++#[test]+fn managed_proxy_ports_allow_only_configured_ports() -> Result<()> {+ let policy = "[experimental_network]\nhttp_port = 3128\nsocks_port = 1080";+ let allowed = WindowsSandboxProvisioningSettings {+ proxy_ports: vec![1080, 3128],+ allow_local_binding: false,+ };+ for listeners in [+ WindowsSandboxProxyListeners {+ http_ports: vec![3128],+ socks_ports: vec![1080],+ },+ WindowsSandboxProxyListeners::default(),+ ] {+ validate_requirements(&allowed, listeners, policy)?;+ }+ let prohibited = WindowsSandboxProvisioningSettings {+ proxy_ports: vec![1080, 3128, 8080],+ allow_local_binding: false,+ };+ for listeners in [+ WindowsSandboxProxyListeners {+ http_ports: vec![3128, 8080],+ socks_ports: vec![1080],+ },+ WindowsSandboxProxyListeners {+ http_ports: vec![3128],+ socks_ports: vec![1080],+ },+ WindowsSandboxProxyListeners::default(),+ ] {+ assert!(validate_requirements(&prohibited, listeners, policy).is_err());+ }+ validate_requirements(+ &WindowsSandboxProvisioningSettings::default(),+ WindowsSandboxProxyListeners::default(),+ policy,+ )+}++#[test]+fn managed_http_port_does_not_restrict_the_unmanaged_socks_listener() -> Result<()> {+ validate_requirements(+ &WindowsSandboxProvisioningSettings {+ proxy_ports: vec![3128, 8081],+ allow_local_binding: false,+ },+ WindowsSandboxProxyListeners {+ http_ports: vec![3128],+ socks_ports: vec![8081],+ },+ "[experimental_network]\nhttp_port = 3128",+ )+}++#[test]+fn managed_socks_port_does_not_restrict_the_unmanaged_http_listener() -> Result<()> {+ validate_requirements(+ &WindowsSandboxProvisioningSettings {+ proxy_ports: vec![1080, 3128],+ allow_local_binding: false,+ },+ WindowsSandboxProxyListeners {+ http_ports: vec![3128],+ socks_ports: vec![1080],+ },+ "[experimental_network]\nsocks_port = 1080",+ )+}++#[test]+fn managed_proxy_ports_reject_swapped_listener_roles() {+ assert!(+ validate_requirements(+ &WindowsSandboxProvisioningSettings {+ proxy_ports: vec![1080, 3128],+ allow_local_binding: false,+ },+ WindowsSandboxProxyListeners {+ http_ports: vec![1080],+ socks_ports: vec![3128],+ },+ "[experimental_network]\nhttp_port = 3128\nsocks_port = 1080",+ )+ .is_err()+ );+}++#[test]+fn managed_socks_port_rejects_a_mismatched_socks_listener() {+ assert!(+ validate_requirements(+ &WindowsSandboxProvisioningSettings {+ proxy_ports: vec![1080, 3128, 8081],+ allow_local_binding: false,+ },+ WindowsSandboxProxyListeners {+ http_ports: vec![3128],+ socks_ports: vec![1080, 8081],+ },+ "[experimental_network]\nhttp_port = 3128\nsocks_port = 1080",+ )+ .is_err()+ );+}++#[test]+fn managed_socks_port_does_not_require_a_disabled_socks_listener() -> Result<()> {+ validate_requirements(+ &WindowsSandboxProvisioningSettings {+ proxy_ports: vec![3128],+ allow_local_binding: false,+ },+ WindowsSandboxProxyListeners {+ http_ports: vec![3128],+ socks_ports: Vec::new(),+ },+ "[experimental_network]\nhttp_port = 3128\nsocks_port = 1080",+ )+}++#[test]+fn malformed_machine_policy_fails_closed() {+ assert!(+ validate_requirements(+ &WindowsSandboxProvisioningSettings::default(),+ WindowsSandboxProxyListeners::default(),+ "[experimental_network]\nhttp_port = \"invalid\""+ )+ .is_err()+ );+ assert!(+ validate_requirements(+ &WindowsSandboxProvisioningSettings::default(),+ WindowsSandboxProxyListeners::default(),+ "[windows]\nallowed_sandbox_implementations = [\"invalid\"]"+ )+ .is_err()+ );+}