diff options
Diffstat (limited to 'libs/samba/src')
6 files changed, 355 insertions, 3 deletions
diff --git a/libs/samba/src/main/cpp/jni.hpp b/libs/samba/src/main/cpp/jni.hpp index 3b5078a..1729828 100644 --- a/libs/samba/src/main/cpp/jni.hpp +++ b/libs/samba/src/main/cpp/jni.hpp @@ -51,7 +51,7 @@ class Ref { T ptr_; }; -constexpr jint JNI_VERSION = JNI_VERSION_1_2; +constexpr jint JNI_VERSION = JNI_VERSION_1_4; JNIEnv* AttachCurrentThread(); diff --git a/libs/samba/src/main/cpp/samba.cpp b/libs/samba/src/main/cpp/samba.cpp index 1e6b425..4a8af51 100644 --- a/libs/samba/src/main/cpp/samba.cpp +++ b/libs/samba/src/main/cpp/samba.cpp @@ -1,7 +1,9 @@ #include <algorithm> #include <cassert> +#include <fcntl.h> #include <jni.h> #include <memory> +#include <limits> #include <optional> #include <string> #include <string_view> @@ -46,6 +48,74 @@ class Dir { smb2dir* const dir_; }; +class File { + public: + File(std::shared_ptr<smb2_context> context, smb2fh* fh) : context_(std::move(context)), fh_(fh) { + assert(context_ && fh_); + } + + ~File() { + smb2_close(context_.get(), fh_); + } + + File(const File&) = delete; + File& operator=(const File&) = delete; + + int32_t read(uint8_t* data, int32_t size) { + if (size <= 0) return 0; + int32_t total = 0; + while (size > std::numeric_limits<int>::max()) { + int ret = smb2_read(context_.get(), fh_, data, + std::numeric_limits<int>::max()); + if (ret < 0) return total ? total : ret; + if (ret != std::numeric_limits<int>::max()) + return total + ret; + data += ret; + size -= ret; + } + int ret = smb2_read(context_.get(), fh_, data, size); + if (ret < 0) return total ? total : ret; + return total + ret; + } + + int32_t write(const uint8_t* data, int32_t size) { + if (size <= 0) return 0; + int32_t total = 0; + while (size > std::numeric_limits<int>::max()) { + int ret = smb2_write(context_.get(), fh_, data, + std::numeric_limits<int>::max()); + if (ret < 0) return total ? total : ret; + if (ret != std::numeric_limits<int>::max()) + return total + ret; + data += ret; + size -= ret; + } + int ret = smb2_write(context_.get(), fh_, data, size); + if (ret < 0) return total ? total : ret; + return total + ret; + } + + int64_t seek(int64_t offset, int32_t native_whence) { + int whence; + switch (native_whence) { + case 0: + whence = SEEK_SET; + break; + case 1: + whence = SEEK_CUR; + break; + default: + assert(false); + return -1; + } + return smb2_lseek(context_.get(), fh_, offset, whence, nullptr); + } + + private: + std::shared_ptr<smb2_context> context_; + smb2fh* const fh_; +}; + class Url { public: explicit Url(smb2_url* url) : url_(url) { @@ -142,6 +212,23 @@ class Context { } } + [[nodiscard]] std::unique_ptr<File> OpenFile(const std::string& path, int32_t mode) { + int flags; + switch (mode) { + case 0: + flags = O_RDONLY; + break; + case 1: + flags = O_WRONLY | O_CREAT | O_TRUNC; + break; + default: + assert(false); + return nullptr; + } + auto* ptr = smb2_open(context_.get(), path.c_str(), flags); + return ptr ? std::make_unique<File>(context_, ptr) : nullptr; + } + private: struct ContextDeleter { void operator()(smb2_context* context) { @@ -205,6 +292,10 @@ jstring nativeContextReadLink(JNIEnv* env, jclass clazz, jlong ptr, jstring path return nullptr; } +jlong nativeContextOpenFile(JNIEnv* env, jclass clazz, jlong ptr, jstring path, jint mode) { + return reinterpret_cast<jlong>(reinterpret_cast<Context*>(ptr)->OpenFile(jni::StringToUTF8(env, jni::ParamRef<jstring>(env, path)), mode).release()); +} + void nativeUrlDestroy(JNIEnv* env, jclass clazz, jlong ptr) { delete reinterpret_cast<Url*>(ptr); } @@ -224,6 +315,50 @@ jobjectArray nativeDirList(JNIEnv* env, jclass clazz, jlong ptr) { return reinterpret_cast<Dir*>(ptr)->List(env, g_DirEntryClass).release(); } +void nativeFileDestroy(JNIEnv* env, jclass clazz, jlong ptr) { + delete reinterpret_cast<File*>(ptr); +} + +jint nativeFileRead(JNIEnv* env, jclass clazz, jlong ptr, jbyteArray array, jint offset, jint length) { + jboolean is_copy = JNI_FALSE; + bool critical = true; + auto* data = reinterpret_cast<jbyte*>(env->GetPrimitiveArrayCritical(array, &is_copy)); + if (!data) { + critical = false; + data = env->GetByteArrayElements(array, &is_copy); + if (!data) return -1; + } + auto ret = reinterpret_cast<File *>(ptr)->read(reinterpret_cast<uint8_t *>(data + offset), length); + if (critical) { + env->ReleasePrimitiveArrayCritical(array, data, JNI_COMMIT); + } else { + env->ReleaseByteArrayElements(array, data, JNI_COMMIT); + } + return ret; +} + +jint nativeFileWrite(JNIEnv* env, jclass clazz, jlong ptr, jbyteArray array, jint offset, jint length) { + jboolean is_copy = JNI_FALSE; + bool critical = true; + auto* data = reinterpret_cast<jbyte*>(env->GetPrimitiveArrayCritical(array, &is_copy)); + if (!data) { + critical = false; + data = env->GetByteArrayElements(array, &is_copy); + if (!data) return -1; + } + auto ret = reinterpret_cast<File *>(ptr)->write(reinterpret_cast<uint8_t *>(data + offset), length); + if (critical) { + env->ReleasePrimitiveArrayCritical(array, data, JNI_ABORT); + } else { + env->ReleaseByteArrayElements(array, data, JNI_ABORT); + } + return ret; +} + +jlong nativeFileSeek(JNIEnv* env, jclass clazz, jlong ptr, jlong offset, jint whence) { + return reinterpret_cast<File*>(ptr)->seek(offset, whence); +} + jni::GlobalRef<jclass> g_NativeSambaClass(nullptr, nullptr); jmethodID g_CreateDirEntry; @@ -244,12 +379,18 @@ void RegisterSamba(JNIEnv* env) { { "nativeContextRemoveDir", "(JLjava/lang/String;)Z", reinterpret_cast<void*>(&nativeContextRemoveDir) }, { "nativeContextUnlink", "(JLjava/lang/String;)Z", reinterpret_cast<void*>(&nativeContextUnlink) }, { "nativeContextReadLink", "(JLjava/lang/String;)Ljava/lang/String;", reinterpret_cast<void*>(&nativeContextReadLink) }, + { "nativeContextOpenFile", "(JLjava/lang/String;I)J", reinterpret_cast<void*>(&nativeContextOpenFile) }, { "nativeUrlDestroy", "(J)V", reinterpret_cast<void*>(&nativeUrlDestroy) }, { "nativeUrlPath", "(J)Ljava/lang/String;", reinterpret_cast<void*>(&nativeUrlPath) }, { "nativeDirDestroy", "(J)V", reinterpret_cast<void*>(&nativeDirDestroy) }, { "nativeDirList", "(J)[Lorg/the_jk/cleversync/io/samba/NativeSamba$DirEntry;", reinterpret_cast<void*>(&nativeDirList) }, + + { "nativeFileDestroy", "(J)V", reinterpret_cast<void*>(&nativeFileDestroy) }, + { "nativeFileRead", "(J[BII)I", reinterpret_cast<void*>(&nativeFileRead) }, + { "nativeFileSeek", "(JJI)J", reinterpret_cast<void*>(&nativeFileSeek) }, + { "nativeFileWrite", "(J[BII)I", reinterpret_cast<void*>(&nativeFileWrite) }, }; auto ret = env->RegisterNatives(clazz.get(), methods, sizeof(methods) / sizeof(methods[0])); ABORT_IF_NOT_OK(ret); diff --git a/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/NativeSamba.kt b/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/NativeSamba.kt index 1863e22..c951d37 100644 --- a/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/NativeSamba.kt +++ b/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/NativeSamba.kt @@ -27,6 +27,7 @@ internal object NativeSamba { fun removeDir(path: String): Boolean fun unlink(path: String): Boolean fun readLink(path: String): String? + fun openFile(path: String, mode: OpenMode): File? } interface Url : Object { @@ -53,6 +54,25 @@ internal object NativeSamba { fun list(): Array<DirEntry> } + enum class OpenMode(val value: Int) { + READ(0), + WRITE_CREATE_TRUNCATE(1), + } + + enum class SeekWhence(val value: Int) { + SET(0), + CURRENT(1), + } + + interface File : Object { + val path: String + + fun read(bytes: ByteArray, offset: Int, length: Int): Int + fun seek(offset: Long, whence: SeekWhence): Long + + fun write(bytes: ByteArray, offset: Int, length: Int): Int + } + private class NativeContext(private var ptr: Long): Context { override fun destroy() { if (ptr == 0L) return @@ -97,6 +117,11 @@ internal object NativeSamba { override fun readLink(path: String): String? { return nativeContextReadLink(ptr, path) } + + override fun openFile(path: String, mode: NativeSamba.OpenMode): File? { + val file = nativeContextOpenFile(ptr, path, mode.value) + return if (file != 0L) NativeFile(path, file) else null + } } private class NativeUrl(private var ptr: Long): Url { @@ -123,6 +148,26 @@ internal object NativeSamba { } } + private class NativeFile(override val path: String, private var ptr: Long): File { + override fun read(bytes: ByteArray, offset: Int, length: Int): Int { + return nativeFileRead(ptr, bytes, offset, length) + } + + override fun seek(offset: Long, whence: SeekWhence): Long { + return nativeFileSeek(ptr, offset, whence.value) + } + + override fun write(bytes: ByteArray, offset: Int, length: Int): Int { + return nativeFileWrite(ptr, bytes, offset, length) + } + + override fun destroy() { + if (ptr == 0L) return + nativeFileDestroy(ptr) + ptr = 0L + } + } + init { System.loadLibrary("samba") } @@ -154,10 +199,16 @@ internal object NativeSamba { private external fun nativeContextRemoveDir(ptr: Long, path: String): Boolean private external fun nativeContextUnlink(ptr: Long, path: String): Boolean private external fun nativeContextReadLink(otr: Long, path: String): String? + private external fun nativeContextOpenFile(ptr: Long, path: String, mode: Int): Long private external fun nativeUrlDestroy(ptr: Long) private external fun nativeUrlPath(ptr: Long): String private external fun nativeDirDestroy(ptr: Long) private external fun nativeDirList(ptr: Long): Array<DirEntry> + + private external fun nativeFileDestroy(ptr: Long) + private external fun nativeFileRead(ptr: Long, bytes: ByteArray, offset: Int, length: Int): Int + private external fun nativeFileSeek(ptr: Long, offset: Long, whence: Int): Long + private external fun nativeFileWrite(ptr: Long, bytes: ByteArray, offset: Int, length: Int): Int } diff --git a/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/SambaConnection.kt b/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/SambaConnection.kt index d7302cd..6eda092 100644 --- a/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/SambaConnection.kt +++ b/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/SambaConnection.kt @@ -40,6 +40,9 @@ internal class SambaConnection(uri: String, credentials: SambaCredentials) { fun readLink(path: String): String? = if (connected) context.readLink(join(url!!.path(), path)) else null + fun openFile(path: String, read: NativeSamba.OpenMode): NativeSamba.File? = + if (connected) context.openFile(join(url!!.path(), path), read) else null + companion object { fun join(a: String, b: String): String { if (a.isEmpty() || b.startsWith("/")) return b diff --git a/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/SambaFile.kt b/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/SambaFile.kt index 817c1bf..9913035 100644 --- a/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/SambaFile.kt +++ b/libs/samba/src/main/java/org/the_jk/cleversync/io/samba/SambaFile.kt @@ -15,11 +15,96 @@ internal class SambaFile( private var cacheEndOfLife: Instant = Instant.now().plusSeconds(60), ) : ModifiableFile { override fun write(): OutputStream { - TODO("Not yet implemented") + val file = conn.openFile(path, NativeSamba.OpenMode.WRITE_CREATE_TRUNCATE) + ?: throw IOException(conn.error) + return object : OutputStream() { + override fun write(b: Int) { + val buffer = ByteArray(1) + buffer[0] = b.toByte() + if (file.write(buffer, 0, 1) != 1) throw IOException(conn.error) + } + + override fun write(b: ByteArray?) = write(b, 0, b?.size ?: 0) + + override fun write(b: ByteArray?, off: Int, len: Int) { + if (b == null) throw NullPointerException("b == null") + if (off < 0) throw IndexOutOfBoundsException("off < 0") + if (len < 0) throw java.lang.IndexOutOfBoundsException("len < 0") + if (off + len > b.size) throw IndexOutOfBoundsException("off + len > b.size") + if (file.write(b, off, len) != len) throw IOException(conn.error) + } + + override fun flush() { + clearCache() + } + + override fun close() { + file.destroy() + clearCache() + } + } } override fun read(): InputStream { - TODO("Not yet implemented") + val file = conn.openFile(path, NativeSamba.OpenMode.READ) ?: throw IOException(conn.error) + return object : InputStream() { + private var markedPosition = 0L + + override fun read(): Int { + val buffer = ByteArray(1) + val got = file.read(buffer, 0, 1) + if (got == 0) return -1 + if (got < 0) throw IOException(conn.error) + return buffer[0].toInt() + } + + override fun read(b: ByteArray?) = read(b, 0, b?.size ?: 0) + + override fun read(b: ByteArray?, off: Int, len: Int): Int { + if (b == null) throw NullPointerException("b == null") + if (off < 0) throw IndexOutOfBoundsException("off < 0") + if (len < 0) throw java.lang.IndexOutOfBoundsException("len < 0") + if (off + len > b.size) throw IndexOutOfBoundsException("off + len > b.size") + if (len == 0) return 0 + val got = file.read(b, off, len) + if (got == 0) return -1 + if (got < 0) throw IOException(conn.error) + return got + } + + override fun skip(n: Long): Long { + if (n <= 0) return 0 + val offset = file.seek(n, NativeSamba.SeekWhence.CURRENT) + if (offset < 0) throw IOException(conn.error) + return offset - n + } + + override fun available(): Int { + val current = file.seek(0, NativeSamba.SeekWhence.CURRENT) + if (current < 0) throw IOException(conn.error) + val total = size + if (current.toULong() >= total) return 0 + val left = total - current.toULong() + if (left >= Int.MAX_VALUE.toULong()) return Int.MAX_VALUE + return left.toInt() + } + + override fun close() { + file.destroy() + } + + override fun mark(readlimit: Int) { + markedPosition = file.seek(0, NativeSamba.SeekWhence.CURRENT) + } + + override fun markSupported() = true + + override fun reset() { + if (file.seek(markedPosition, NativeSamba.SeekWhence.SET) != markedPosition) { + throw IOException(conn.error) + } + } + } } override val size: ULong get() { @@ -37,4 +122,8 @@ internal class SambaFile( private fun useCached(): Boolean { return Instant.now().isBefore(cacheEndOfLife) } + + private fun clearCache() { + cacheEndOfLife = Instant.EPOCH + } } diff --git a/libs/samba/src/test/java/org/the_jk/cleversync/samba/SambaTreeTest.kt b/libs/samba/src/test/java/org/the_jk/cleversync/samba/SambaTreeTest.kt index 1eddb6b..5df61da 100644 --- a/libs/samba/src/test/java/org/the_jk/cleversync/samba/SambaTreeTest.kt +++ b/libs/samba/src/test/java/org/the_jk/cleversync/samba/SambaTreeTest.kt @@ -14,6 +14,7 @@ import org.robolectric.annotation.Config import org.the_jk.cleversync.io.Link import org.the_jk.cleversync.io.samba.SambaCredentials import java.io.File +import java.nio.charset.StandardCharsets import java.nio.file.Files import kotlin.io.path.createSymbolicLinkPointingTo @@ -82,6 +83,73 @@ class SambaTreeTest { } } + @Test + fun readFile() { + File(shareDir, "file").writeText("hello world") + + SambaTreeFactory.tree(uri, credentials).getOrThrow().use { root -> + val file = root.openFile("file") + assertThat(file?.name).isEqualTo("file") + assertThat(file?.size).isEqualTo(11UL) + + file?.read().use { input -> + assertThat(input?.readAllBytes()?.toString(StandardCharsets.UTF_8)).isEqualTo("hello world") + } + + file?.read().use { input -> + assertThat(input?.available()).isEqualTo(11) + assertThat(input?.markSupported()).isTrue() + val buffer = ByteArray(10) + assertThat(input?.read(buffer, 5, 5)).isEqualTo(5) + input?.mark(100) + assertThat(buffer.sliceArray(5..<10).toString(StandardCharsets.UTF_8)).isEqualTo("hello") + assertThat(input?.read(buffer)).isEqualTo(6) + assertThat(buffer.sliceArray(0..<6).toString(StandardCharsets.UTF_8)).isEqualTo(" world") + input?.reset() + assertThat(input?.read(buffer, 3, 5)).isEqualTo(5) + assertThat(buffer.sliceArray(3..<8).toString(StandardCharsets.UTF_8)).isEqualTo(" worl") + } + } + } + + @Test + fun writeFile() { + SambaTreeFactory.modifiableTree(uri, credentials).getOrThrow().use { root -> + val file = root.createFile("file") + assertThat(file.name).isEqualTo("file") + + file.write().writer().use { output -> + output.write("hello world") + } + + assertThat(file.size).isEqualTo(11UL) + } + + assertThat(File(shareDir, "file").readText()).isEqualTo("hello world") + } + + @Test + fun overwriteFile() { + File(shareDir, "file").writeText("hello world") + + SambaTreeFactory.modifiableTree(uri, credentials).getOrThrow().use { root -> + val file = root.modifiableOpenFile("file") + assertThat(file?.name).isEqualTo("file") + assertThat(file?.size).isEqualTo(11UL) + + file?.write().use { output -> + val buffer = "foobar".toByteArray(StandardCharsets.UTF_8) + output?.write(buffer, 0, 1) + output?.write(buffer, 1, 2) + output?.write(buffer, 3, 3) + } + + assertThat(file?.size).isEqualTo(6UL) + } + + assertThat(File(shareDir, "file").readText()).isEqualTo("foobar") + } + companion object { private lateinit var uri: String private lateinit var credentials: SambaCredentials |