Merge branch 'main' into main

penberg · web-flow · commit fb39e144dc07 · 2025-07-29T13:08:42.000+03:00
diff --git a/Cargo.lock b/Cargo.lock
diff --git a/Cargo.toml b/Cargo.toml
@@ -25,18 +25,18 @@ exclude = [
 ]
 
 [workspace.package]
-version = "0.9.12"
+version = "0.9.19"
 authors = ["the libSQL authors"]
 edition = "2021"
 license = "MIT"
 repository = "https://github.com/tursodatabase/libsql"
 
 [workspace.dependencies]
-libsql-ffi = { path = "libsql-ffi", version = "0.9.12" }
-libsql-sys = { path = "libsql-sys", version = "0.9.12", default-features = false }
-libsql-hrana = { path = "libsql-hrana", version = "0.9.12" }
-libsql_replication = { path = "libsql-replication", version = "0.9.12" }
-rusqlite = { package = "libsql-rusqlite", path = "vendored/rusqlite", version = "0.9.12", default-features = false, features = [
+libsql-ffi = { path = "libsql-ffi", version = "0.9.19" }
+libsql-sys = { path = "libsql-sys", version = "0.9.19", default-features = false }
+libsql-hrana = { path = "libsql-hrana", version = "0.9.19" }
+libsql_replication = { path = "libsql-replication", version = "0.9.19" }
+rusqlite = { package = "libsql-rusqlite", path = "vendored/rusqlite", version = "0.9.19", default-features = false, features = [
     "libsql-experimental",
     "column_decltype",
     "load_extension",
diff --git a/bindings/c/Cargo.toml b/bindings/c/Cargo.toml
@@ -19,14 +19,8 @@ tracing = "0.1.40"
 tracing-subscriber = "0.3.18"
 http = "1.1.0"
 anyhow = "1.0.86"
-
-[target.'cfg(not(any(target_os = "ios", target_os = "android")))'.dependencies]
 libsql = { path = "../../libsql", features = ["encryption"] }
 
-# Disable encryption for ios and android targets
-[target.'cfg(any(target_os = "ios", target_os = "android"))'.dependencies]
-libsql = { path = "../../libsql"}
-
 
 # The produced binaries are too large for mobiles
 # When compiling for iOS or Android, you should turn on symbol stripping, lto and cut debug symbols
diff --git a/bindings/c/Makefile b/bindings/c/Makefile
@@ -1,7 +1,7 @@
 OS := $(shell uname)
 CFLAGS := -Iinclude
 LDFLAGS := -lm
-ARCHS_IOS = x86_64-apple-ios aarch64-apple-ios aarch64-apple-ios-sim
+ARCHS_IOS = aarch64-apple-ios aarch64-apple-ios-sim
 ARCHS_ANDROID = aarch64-linux-android armv7-linux-androideabi x86_64-linux-android i686-linux-android
 LIB = libsql_experimental.a
 HEADER = libsql.h
@@ -40,11 +40,21 @@ $(ARCHS_ANDROID): %:
 ios: $(XCFRAMEWORK)
 
 $(ARCHS_IOS): %:
-	cargo build --release --target $@
-
-$(XCFRAMEWORK): $(ARCHS_IOS)
+	cargo build  --release --target $@
+
+x86_64-apple-ios:
+	SDKROOT=$$(xcrun --sdk iphonesimulator --show-sdk-path) \
+	CFLAGS_x86_64_apple_ios="-target x86_64-apple-ios-simulator" \
+	CXXFLAGS_x86_64_apple_ios="-target x86_64-apple-ios-simulator" \
+	CC_x86_64_apple_ios=$$(xcrun --sdk iphonesimulator --find clang) \
+	CXX_x86_64_apple_ios=$$(xcrun --sdk iphonesimulator --find clang++) \
+	CMAKE_SYSTEM_NAME=iOS \
+	CMAKE_OSX_SYSROOT=$$(xcrun --sdk iphonesimulator --show-sdk-path) \
+	cargo build --release --target x86_64-apple-ios
+
+$(XCFRAMEWORK): $(ARCHS_IOS) x86_64-apple-ios
 	rm -rf generated
 	mkdir -p generated/simulator_fat
 	rm -rf $@
 	lipo -create $(wildcard ../../target/x86_64-apple-ios/release/$(LIB)) $(wildcard ../../target/aarch64-apple-ios-sim/release/$(LIB)) -output generated/simulator_fat/$(LIB)
-	xcodebuild -create-xcframework -library $(wildcard ../../target/aarch64-apple-ios/release/$(LIB)) -headers include -library generated/simulator_fat/$(LIB) -headers include -output $@
+	xcodebuild -create-xcframework -library $(wildcard ../../target/aarch64-apple-ios/release/$(LIB)) -headers include -library generated/simulator_fat/$(LIB) -headers include -output $@
diff --git a/bindings/c/include/libsql.h b/bindings/c/include/libsql.h
@@ -41,6 +41,7 @@ typedef struct {
   int sync_interval;
   char with_webpki;
   char offline;
+  const char *remote_encryption_key;
 } libsql_config;
 
 typedef const libsql_connection *libsql_connection_t;
diff --git a/bindings/c/src/lib.rs b/bindings/c/src/lib.rs
@@ -98,6 +98,7 @@ pub unsafe extern "C" fn libsql_open_sync(
         sync_interval: 0,
         with_webpki: 0,
         offline: 0,
+        remote_encryption_key: std::ptr::null(),
     };
     libsql_open_sync_with_config(config, out_db, out_err_msg)
 }
@@ -121,6 +122,7 @@ pub unsafe extern "C" fn libsql_open_sync_with_webpki(
         sync_interval: 0,
         with_webpki: 1,
         offline: 0,
+        remote_encryption_key: std::ptr::null(),
     };
     libsql_open_sync_with_config(config, out_db, out_err_msg)
 }
@@ -271,6 +273,19 @@ pub unsafe extern "C" fn libsql_open_sync_with_config(
                 .build();
             builder = builder.connector(https);
         }
+        if !config.remote_encryption_key.is_null() {
+            let key = unsafe { std::ffi::CStr::from_ptr(config.remote_encryption_key) };
+            let key = match key.to_str() {
+                Ok(k) => k,
+                Err(e) => {
+                    set_err_msg(format!("Wrong encryption key: {e}"), out_err_msg);
+                    return 5;
+                }
+            };
+            builder = builder.remote_encryption(libsql::EncryptionContext {
+                key: libsql::EncryptionKey::Base64Encoded(key.to_string()),
+            });
+        };
         match RT.block_on(builder.build()) {
             Ok(db) => {
                 let db = Box::leak(Box::new(libsql_database { db }));
@@ -325,6 +340,19 @@ pub unsafe extern "C" fn libsql_open_sync_with_config(
         let config = libsql::EncryptionConfig::new(libsql::Cipher::Aes256Cbc, key);
         builder = builder.encryption_config(config)
     };
+    if !config.remote_encryption_key.is_null() {
+        let key = unsafe { std::ffi::CStr::from_ptr(config.remote_encryption_key) };
+        let key = match key.to_str() {
+            Ok(k) => k,
+            Err(e) => {
+                set_err_msg(format!("Wrong encryption key: {e}"), out_err_msg);
+                return 5;
+            }
+        };
+        builder = builder.remote_encryption(libsql::EncryptionContext {
+            key: libsql::EncryptionKey::Base64Encoded(key.to_string()),
+        });
+    };
     match RT.block_on(builder.build()) {
         Ok(db) => {
             let db = Box::leak(Box::new(libsql_database { db }));
diff --git a/bindings/c/src/types.rs b/bindings/c/src/types.rs
@@ -15,6 +15,7 @@ pub struct libsql_config {
     pub sync_interval: std::ffi::c_int,
     pub with_webpki: std::ffi::c_char,
     pub offline: std::ffi::c_char,
+    pub remote_encryption_key: *const std::ffi::c_char,
 }
 
 #[derive(Clone, Debug)]
diff --git a/libsql-ffi/build.rs b/libsql-ffi/build.rs
@@ -485,6 +485,11 @@ fn build_multiple_ciphers(out_path: &Path) -> PathBuf {
         build.compiler(cxx);
         config.init_cxx_cfg(build);
     }
+    let target = env::var("TARGET").unwrap();
+
+    if target.ends_with("apple-ios") {
+        config.define("SQLITE3MC_OMIT_AES_HARDWARE_SUPPORT", "ON");
+    }
 
     if cfg!(feature = "wasmtime-bindings") {
         config.define("LIBSQL_ENABLE_WASM_RUNTIME", "1");
@@ -496,6 +501,14 @@ fn build_multiple_ciphers(out_path: &Path) -> PathBuf {
             .define("SQLITE_ENABLE_SESSION", "ON");
     }
 
+    if let Ok(abi) = env::var("CARGO_NDK_ANDROID_TARGET") {
+        config.define("ANDROID_ABI", abi);
+    }
+
+    if let Ok(platform) = env::var("ANDROID_PLATFORM") {
+        config.define("ANDROID_PLATFORM", platform);
+    }
+
     config.build()
 }
 
diff --git a/libsql-ffi/bundled/SQLite3MultipleCiphers/CMakeLists.txt b/libsql-ffi/bundled/SQLite3MultipleCiphers/CMakeLists.txt
@@ -313,11 +313,12 @@ if (CMAKE_C_COMPILER_ID STREQUAL "Clang" AND NOT (
       CMAKE_SYSTEM_PROCESSOR STREQUAL "aarch64"
       OR CMAKE_SYSTEM_PROCESSOR STREQUAL "arm64"
       OR CMAKE_SYSTEM_PROCESSOR STREQUAL "arm"
+      OR CMAKE_ANDROID_ARCH_ABI STREQUAL "arm64-v8a"
+      OR CMAKE_ANDROID_ARCH_ABI STREQUAL "armeabi-v7a"
   ))
   set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -msse4.2 -maes -Wno-error=incompatible-function-pointer-types")
   set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -msse4.2 -maes")
 endif()
-
 set(_LIB_DIFINITIONS
   _LIB
 )
diff --git a/libsql/examples/encryption_sync.rs b/libsql/examples/encryption_sync.rs
@@ -25,8 +25,11 @@ async fn main() {
         None
     };
 
-    let db_builder =
-        Builder::new_synced_database(db_path, sync_url, auth_token).remote_encryption(encryption);
+    let mut db_builder = Builder::new_synced_database(db_path, sync_url, auth_token);
+
+    if let Some(enc) = encryption {
+        db_builder = db_builder.remote_encryption(enc);
+    }
 
     let db = match db_builder.build().await {
         Ok(db) => db,
diff --git a/libsql/src/connection.rs b/libsql/src/connection.rs
@@ -137,7 +137,7 @@ impl Connection {
     ///
     /// # Return
     ///
-    /// This returns a `BatchRows` currently only the `remote`  and `local` connection supports this feature and
+    /// This returns a `BatchRows` currently only the `remote` and `local` connection supports this feature and
     /// all other connection types will return an empty set always.
     pub async fn execute_batch(&self, sql: &str) -> Result<BatchRows> {
         tracing::trace!("executing batch `{}`", sql);
@@ -206,7 +206,7 @@ impl Connection {
         self.conn.busy_timeout(timeout)
     }
 
-    /// Check weather libsql is in `autocommit` or not.
+    /// Check whether libsql is in `autocommit` or not.
     pub fn is_autocommit(&self) -> bool {
         self.conn.is_autocommit()
     }
diff --git a/libsql/src/database/builder.rs b/libsql/src/database/builder.rs
@@ -25,7 +25,7 @@ pub use crate::database::EncryptionContext;
 ///
 /// # Note
 ///
-/// Embedded replica's require a clean database (no database file) or a previously synced database or else it will
+/// Embedded replicas require a clean database (no database file) or a previously synced database or else it will
 /// throw an error to prevent any misuse. To work around this error a user can delete the database
 /// and let it resync and create the wal_index metadata file.
 pub struct Builder<T = ()> {
@@ -276,7 +276,7 @@ cfg_replication! {
             self
         }
 
-        /// Set weather you want writes to be visible locally before the write query returns. This
+        /// Set whether you want writes to be visible locally before the write query returns. This
         /// means that you will be able to read your own writes if this is set to `true`.
         ///
         /// # Default
@@ -306,8 +306,8 @@ cfg_replication! {
 
         /// Set the encryption context if the database is encrypted in remote server.
         #[cfg(feature = "sync")]
-        pub fn remote_encryption(mut self, encryption_context: Option<EncryptionContext>) -> Builder<RemoteReplica> {
-            self.inner.remote_encryption = encryption_context;
+        pub fn remote_encryption(mut self, encryption_context: EncryptionContext) -> Builder<RemoteReplica> {
+            self.inner.remote_encryption = Some(encryption_context);
             self
         }
 
@@ -333,7 +333,7 @@ cfg_replication! {
             self
         }
 
-        /// Skip the saftey assert used to ensure that sqlite3 is configured correctly for the way
+        /// Skip the safety assert used to ensure that sqlite3 is configured correctly for the way
         /// that libsql uses the ffi code. By default, libsql will try to use the SERIALIZED
         /// threadsafe mode for sqlite3. This allows us to implement Send/Sync for all the types to
         /// allow them to move between threads safely. Due to the fact that sqlite3 has a global
@@ -399,9 +399,14 @@ cfg_replication! {
                             url.to_string()
                         };
                         let req = http::Request::get(format!("{prefix}/info"))
-                            .header("Authorization", format!("Bearer {}", auth_token))
-                            .body(hyper::Body::empty())
-                            .unwrap();
+                            .header("Authorization", format!("Bearer {}", auth_token));
+
+                        let req = if let Some(ref remote_encryption) = remote_encryption {
+                            req.header("x-turso-encryption-key", remote_encryption.key.as_string())
+                        } else {
+                            req
+                        };
+                        let req = req.body(hyper::Body::empty()).unwrap();
 
                         let res = client
                             .request(req)
@@ -427,11 +432,14 @@ cfg_replication! {
 
                         if res.status().is_success() {
                             tracing::trace!("Using sync protocol v2 for {}", url);
-                            let builder = Builder::new_synced_database(path, url, auth_token)
+                            let mut builder = Builder::new_synced_database(path, url, auth_token)
                                 .connector(connector)
                                 .remote_writes(true)
-                                .read_your_writes(read_your_writes)
-                                .remote_encryption(remote_encryption);
+                                .read_your_writes(read_your_writes);
+
+                            if let Some(encryption) = remote_encryption {
+                                builder = builder.remote_encryption(encryption);
+                            }
 
                             let builder = if let Some(sync_interval) = sync_interval {
                                 builder.sync_interval(sync_interval)
@@ -616,8 +624,8 @@ cfg_sync! {
         }
 
          /// Set the encryption context if the database is encrypted in remote server.
-        pub fn remote_encryption(mut self, encryption_context: Option<EncryptionContext>) -> Builder<SyncedDatabase> {
-            self.inner.remote_encryption = encryption_context;
+        pub fn remote_encryption(mut self, encryption_context: EncryptionContext) -> Builder<SyncedDatabase> {
+            self.inner.remote_encryption = Some(encryption_context);
             self
         }
 
@@ -784,8 +792,8 @@ cfg_remote! {
         }
 
         /// Set the encryption context if the database is encrypted in remote server.
-        pub fn remote_encryption(mut self, encryption_context: Option<EncryptionContext>) -> Builder<Remote> {
-            self.inner.remote_encryption = encryption_context;
+        pub fn remote_encryption(mut self, encryption_context: EncryptionContext) -> Builder<Remote> {
+            self.inner.remote_encryption = Some(encryption_context);
             self
         }
 
diff --git a/libsql/src/local/connection.rs b/libsql/src/local/connection.rs
diff --git a/libsql/src/sync.rs b/libsql/src/sync.rs
diff --git a/vendored/rusqlite/Cargo.toml b/vendored/rusqlite/Cargo.toml
diff --git a/xtask/src/main.rs b/xtask/src/main.rs

Original file line number	Diff line number	Diff line change
`@@ -15,6 +15,7 @@ pub struct libsql_config {`
`15`	`15`	`pub sync_interval: std::ffi::c_int,`
`16`	`16`	`pub with_webpki: std::ffi::c_char,`
`17`	`17`	`pub offline: std::ffi::c_char,`
	`18`	`+ pub remote_encryption_key: *const std::ffi::c_char,`
`18`	`19`	`}`
`19`	`20`
`20`	`21`	`#[derive(Clone, Debug)]`