react-native-sherpa-onnx 0.2.0 → 0.3.0

package/ios/archive/sherpa-onnx-archive-helper.mm

@@ -0,0 +1,296 @@
+/**
+ * sherpa-onnx-archive-helper.mm
+ *
+ * Purpose: Extracts .tar.bz2 archives (e.g. downloaded model bundles) to a target directory and
+ * computes file SHA-256. Used by the main module for model download and verification on iOS.
+ */
+
+#import "sherpa-onnx-archive-helper.h"
+#import <archive.h>
+#import <archive_entry.h>
+#import <CommonCrypto/CommonCrypto.h>
+#include <array>
+#include <atomic>
+#include <cstdio>
+#include <string>
+
+static std::atomic_bool g_cancelExtract(false);
+
+namespace {
+struct ArchiveReadContext {
+  FILE* file = nullptr;
+  std::array<unsigned char, 64 * 1024> buffer{};
+  CC_SHA256_CTX sha_ctx{};
+  long long bytes_read = 0;
+};
+
+static la_ssize_t ArchiveReadCallback(struct archive* archive, void* client_data, const void** buff) {
+  auto* ctx = static_cast<ArchiveReadContext*>(client_data);
+  if (!ctx || !ctx->file) {
+    archive_set_error(archive, EINVAL, "Invalid read context");
+    return -1;
+  }
+
+  size_t bytes = fread(ctx->buffer.data(), 1, ctx->buffer.size(), ctx->file);
+  if (bytes > 0) {
+    CC_SHA256_Update(&ctx->sha_ctx, ctx->buffer.data(), (CC_LONG)bytes);
+    ctx->bytes_read += (long long)bytes;
+    *buff = ctx->buffer.data();
+    return (la_ssize_t)bytes;
+  }
+
+  if (feof(ctx->file)) {
+    return 0;
+  }
+
+  archive_set_error(archive, errno, "Read error");
+  return -1;
+}
+
+static int ArchiveCloseCallback(struct archive* /* archive */, void* client_data) {
+  (void)client_data;
+  return ARCHIVE_OK;
+}
+
+static void DrainRemainingAndClose(ArchiveReadContext* ctx) {
+  if (!ctx || !ctx->file) {
+    return;
+  }
+
+  size_t bytes = 0;
+  while ((bytes = fread(ctx->buffer.data(), 1, ctx->buffer.size(), ctx->file)) > 0) {
+    CC_SHA256_Update(&ctx->sha_ctx, ctx->buffer.data(), (CC_LONG)bytes);
+    ctx->bytes_read += (long long)bytes;
+  }
+
+  fclose(ctx->file);
+  ctx->file = nullptr;
+}
+
+static NSString* HexStringFromDigest(const unsigned char* digest, size_t size) {
+  static const char* kHex = "0123456789abcdef";
+  std::string out;
+  out.reserve(size * 2);
+  for (size_t i = 0; i < size; ++i) {
+    unsigned char value = digest[i];
+    out.push_back(kHex[value >> 4]);
+    out.push_back(kHex[value & 0x0F]);
+  }
+  return [NSString stringWithUTF8String:out.c_str()];
+}
+
+static NSString* ComputeFileSha256(NSString* filePath, NSError** error) {
+  const char* path = [filePath UTF8String];
+  FILE* file = fopen(path, "rb");
+  if (!file) {
+    if (error) {
+      *error = [NSError errorWithDomain:@"SherpaOnnx"
+                                   code:5
+                               userInfo:@{NSLocalizedDescriptionKey: @"Failed to open file"}];
+    }
+    return nil;
+  }
+
+  CC_SHA256_CTX sha_ctx;
+  CC_SHA256_Init(&sha_ctx);
+
+  std::array<unsigned char, 64 * 1024> buffer{};
+  size_t bytes = 0;
+  while ((bytes = fread(buffer.data(), 1, buffer.size(), file)) > 0) {
+    CC_SHA256_Update(&sha_ctx, buffer.data(), (CC_LONG)bytes);
+  }
+
+  if (ferror(file)) {
+    fclose(file);
+    if (error) {
+      *error = [NSError errorWithDomain:@"SherpaOnnx"
+                                   code:6
+                               userInfo:@{NSLocalizedDescriptionKey: @"Read error while hashing file"}];
+    }
+    return nil;
+  }
+
+  fclose(file);
+
+  unsigned char digest[CC_SHA256_DIGEST_LENGTH];
+  CC_SHA256_Final(digest, &sha_ctx);
+  return HexStringFromDigest(digest, CC_SHA256_DIGEST_LENGTH);
+}
+}  // namespace
+
+@implementation SherpaOnnxArchiveHelper
+
++ (void)cancelExtractTarBz2
+{
+  g_cancelExtract.store(true);
+}
+
+- (NSDictionary *)extractTarBz2:(NSString *)sourcePath
+         targetPath:(NSString *)targetPath
+           force:(BOOL)force
+           progress:(SherpaOnnxArchiveProgressBlock)progress
+{
+  g_cancelExtract.store(false);
+  NSFileManager *fileManager = [NSFileManager defaultManager];
+
+  if (![fileManager fileExistsAtPath:sourcePath]) {
+    return @{ @"success": @NO, @"reason": @"Source file does not exist" };
+  }
+
+  if ([fileManager fileExistsAtPath:targetPath]) {
+    if (force) {
+      NSError *removeError = nil;
+      [fileManager removeItemAtPath:targetPath error:&removeError];
+      if (removeError) {
+        return @{ @"success": @NO, @"reason": removeError.localizedDescription ?: @"Failed to remove target" };
+      }
+    } else {
+      return @{ @"success": @NO, @"reason": @"Target path already exists" };
+    }
+  }
+
+  NSError *mkdirError = nil;
+  [fileManager createDirectoryAtPath:targetPath withIntermediateDirectories:YES attributes:nil error:&mkdirError];
+  if (mkdirError) {
+    return @{ @"success": @NO, @"reason": mkdirError.localizedDescription ?: @"Failed to create target directory" };
+  }
+
+  NSString *canonicalTarget = [[targetPath stringByStandardizingPath] stringByAppendingString:@"/"];
+
+  NSDictionary *fileAttributes = [fileManager attributesOfItemAtPath:sourcePath error:nil];
+  long long totalBytes = [[fileAttributes objectForKey:NSFileSize] longLongValue];
+
+  struct archive *archive = archive_read_new();
+  archive_read_support_format_tar(archive);
+  archive_read_support_filter_bzip2(archive);
+
+  ArchiveReadContext read_ctx;
+  read_ctx.file = fopen([sourcePath UTF8String], "rb");
+  if (!read_ctx.file) {
+    return @{ @"success": @NO, @"reason": @"Failed to open archive file" };
+  }
+  auto close_reader = [&read_ctx]() {
+    DrainRemainingAndClose(&read_ctx);
+  };
+  CC_SHA256_Init(&read_ctx.sha_ctx);
+
+  if (archive_read_open(archive, &read_ctx, nullptr, ArchiveReadCallback, ArchiveCloseCallback) != ARCHIVE_OK) {
+    const char *errorStr = archive_error_string(archive);
+    NSString *reason = errorStr ? [NSString stringWithUTF8String:errorStr] : @"Failed to open archive";
+    close_reader();
+    archive_read_free(archive);
+    return @{ @"success": @NO, @"reason": reason };
+  }
+
+  struct archive *disk = archive_write_disk_new();
+  archive_write_disk_set_options(disk, ARCHIVE_EXTRACT_TIME | ARCHIVE_EXTRACT_PERM | ARCHIVE_EXTRACT_ACL | ARCHIVE_EXTRACT_FFLAGS);
+  archive_write_disk_set_standard_lookup(disk);
+
+  struct archive_entry *entry = nullptr;
+  int result = ARCHIVE_OK;
+  long long extractedBytes = 0;
+  int lastPercent = -1;
+  long long lastEmitBytes = 0;
+  while ((result = archive_read_next_header(archive, &entry)) == ARCHIVE_OK) {
+    if (g_cancelExtract.load()) {
+      archive_read_free(archive);
+      archive_write_free(disk);
+      close_reader();
+      return @{ @"success": @NO, @"reason": @"Extraction cancelled" };
+    }
+    const char *currentPath = archive_entry_pathname(entry);
+    NSString *entryPath = currentPath ? [NSString stringWithUTF8String:currentPath] : @"";
+    NSString *fullPath = [[targetPath stringByAppendingPathComponent:entryPath] stringByStandardizingPath];
+
+    if (![fullPath hasPrefix:canonicalTarget]) {
+      archive_read_free(archive);
+      archive_write_free(disk);
+      close_reader();
+      return @{ @"success": @NO, @"reason": @"Blocked path traversal" };
+    }
+
+    archive_entry_set_pathname(entry, [fullPath UTF8String]);
+    result = archive_write_header(disk, entry);
+    if (result != ARCHIVE_OK) {
+      const char *errorStr = archive_error_string(disk);
+      NSString *reason = errorStr ? [NSString stringWithUTF8String:errorStr] : @"Failed to write entry";
+      archive_read_free(archive);
+      archive_write_free(disk);
+      close_reader();
+      return @{ @"success": @NO, @"reason": reason };
+    }
+
+    const void *buff = nullptr;
+    size_t size = 0;
+    la_int64_t offset = 0;
+    while ((result = archive_read_data_block(archive, &buff, &size, &offset)) == ARCHIVE_OK) {
+      if (g_cancelExtract.load()) {
+        archive_read_free(archive);
+        archive_write_free(disk);
+        close_reader();
+        return @{ @"success": @NO, @"reason": @"Extraction cancelled" };
+      }
+      la_ssize_t writeResult = archive_write_data_block(disk, buff, size, offset);
+      if (writeResult != ARCHIVE_OK) {
+        const char *errorStr = archive_error_string(disk);
+        NSString *reason = errorStr ? [NSString stringWithUTF8String:errorStr] : @"Failed to write data";
+        archive_read_free(archive);
+        archive_write_free(disk);
+        close_reader();
+        return @{ @"success": @NO, @"reason": reason };
+      }
+
+      extractedBytes += (long long)size;
+      if (progress) {
+        if (totalBytes > 0) {
+          long long compressedBytes = archive_filter_bytes(archive, -1);
+          int percent = (int)((compressedBytes * 100) / totalBytes);
+          if (percent > 100) {
+            percent = 100;
+          } else if (percent < 0) {
+            percent = 0;
+          }
+          if (percent != lastPercent) {
+            lastPercent = percent;
+            progress(compressedBytes, totalBytes, (double)percent);
+          }
+        } else if (extractedBytes - lastEmitBytes >= 1024 * 1024) {
+          lastEmitBytes = extractedBytes;
+          progress(extractedBytes, totalBytes, 0.0);
+        }
+      }
+    }
+
+    if (result != ARCHIVE_EOF && result != ARCHIVE_OK) {
+      const char *errorStr = archive_error_string(archive);
+      NSString *reason = errorStr ? [NSString stringWithUTF8String:errorStr] : @"Failed to read data";
+      archive_read_free(archive);
+      archive_write_free(disk);
+      close_reader();
+      return @{ @"success": @NO, @"reason": reason };
+    }
+  }
+
+  archive_read_free(archive);
+  archive_write_free(disk);
+
+  if (progress) {
+    progress(extractedBytes, extractedBytes, 100.0);
+  }
+
+  close_reader();
+
+  unsigned char digest[CC_SHA256_DIGEST_LENGTH];
+  CC_SHA256_Final(digest, &read_ctx.sha_ctx);
+  NSString *sha256Hex = HexStringFromDigest(digest, CC_SHA256_DIGEST_LENGTH);
+
+  return @{ @"success": @YES, @"path": targetPath, @"sha256": sha256Hex ?: @"" };
+}
+
+- (NSString *)computeFileSha256:(NSString *)filePath
+                           error:(NSError * _Nullable * _Nullable)error
+{
+  return ComputeFileSha256(filePath, error);
+}
+
+@end

package/ios/libarchive_darwin_config.h

@@ -0,0 +1,153 @@
+/* Configuration for libarchive when building on Apple platforms (iOS/macOS).
+ * iOS does not ship libarchive; we vendor and build it. This config is based on
+ * the Android contrib config with Apple-appropriate settings.
+ */
+#ifndef ARCHIVE_PLATFORM_H_DARWIN_INCLUDED
+#define ARCHIVE_PLATFORM_H_DARWIN_INCLUDED
+
+#define __LIBARCHIVE_CONFIG_H_INCLUDED 1
+
+#define HAVE_CHOWN 1
+#define HAVE_CHROOT 1
+#define HAVE_CLOSEFROM 0
+#define HAVE_CLOSE_RANGE 0
+#define HAVE_CTIME_R 1
+#define HAVE_CTYPE_H 1
+#define HAVE_DECL_EXTATTR_NAMESPACE_USER 0
+#define HAVE_DECL_INTMAX_MIN 1
+#define HAVE_DECL_INTMAX_MAX 1
+#define HAVE_DECL_INT64_MAX 1
+#define HAVE_DECL_INT64_MIN 1
+#define HAVE_DECL_SIZE_MAX 1
+#define HAVE_DECL_SSIZE_MAX 1
+#define HAVE_DECL_STRERROR_R 1
+#define HAVE_DECL_UINTMAX_MAX 1
+#define HAVE_DECL_UINT32_MAX 1
+#define HAVE_DECL_UINT64_MAX 1
+#define HAVE_DECL_INT32_MAX 1
+#define HAVE_DECL_INT32_MIN 1
+#define HAVE_DIRENT_H 1
+#define HAVE_DIRFD 1
+#define HAVE_DLFCN_H 1
+#define HAVE_EILSEQ 1
+#define HAVE_ERRNO_H 1
+#define HAVE_FCHDIR 1
+#define HAVE_FCHMOD 1
+#define HAVE_FCHOWN 1
+#define HAVE_FCNTL 1
+#define HAVE_FCNTL_H 1
+#define HAVE_FDOPENDIR 1
+#define HAVE_FGETXATTR 1
+#define HAVE_FLISTXATTR 1
+#define HAVE_FORK 1
+#define HAVE_FSEEKO 1
+#define HAVE_FSETXATTR 1
+#define HAVE_FSTAT 1
+#define HAVE_FSTATAT 1
+#define HAVE_FSTATFS 1
+#define HAVE_FTRUNCATE 1
+#define HAVE_GETEUID 1
+#define HAVE_GETPID 1
+#define HAVE_GETPWNAM_R 1
+#define HAVE_GETPWUID_R 1
+#define HAVE_GETXATTR 1
+#define HAVE_GMTIME_R 1
+#define HAVE_GRP_H 1
+#define HAVE_INTMAX_T 1
+#define HAVE_INTTYPES_H 1
+#define HAVE_LCHOWN 1
+#define HAVE_LGETXATTR 1
+#define HAVE_LIBLZMA 0
+#define HAVE_LIBZ 1
+#define HAVE_LIMITS_H 1
+#define HAVE_LINK 1
+#define HAVE_LISTXATTR 1
+#define HAVE_LLISTXATTR 1
+#define HAVE_LOCALE_H 1
+#define HAVE_LOCALTIME_R 1
+#define HAVE_LONG_LONG_INT 1
+#define HAVE_LSETXATTR 1
+#define HAVE_LSTAT 1
+#define HAVE_MBRTOWC 1
+#define HAVE_MEMMOVE 1
+#define HAVE_MEMSET 1
+#define HAVE_MKDIR 1
+#define HAVE_MKFIFO 1
+#define HAVE_MKNOD 1
+#define HAVE_MKSTEMP 1
+#define HAVE_OPENAT 1
+#define HAVE_PIPE 1
+#define HAVE_POLL 1
+#define HAVE_POLL_H 1
+#define HAVE_PTHREAD_H 1
+#define HAVE_PWD_H 1
+#define HAVE_READLINK 1
+#define HAVE_READLINKAT 1
+#define HAVE_READDIR_R 1
+#define HAVE_REGEX_H 1
+#define HAVE_SELECT 1
+#define HAVE_STATVFS 1
+#define HAVE_FSTATVFS 1
+#define HAVE_SYS_STATVFS_H 1
+#define HAVE_SETENV 1
+#define HAVE_SETLOCALE 1
+#define HAVE_SIGACTION 1
+#define HAVE_SIGNAL_H 1
+#define HAVE_STATFS 1
+#define HAVE_STDARG_H 1
+#define HAVE_STDINT_H 1
+#define HAVE_STDLIB_H 1
+#define HAVE_STRCHR 1
+#define HAVE_STRDUP 1
+#define HAVE_STRERROR 1
+#define HAVE_STRERROR_R 1
+#define HAVE_STRFTIME 1
+#define HAVE_STRINGS_H 1
+#define HAVE_STRING_H 1
+#define HAVE_STRRCHR 1
+#define HAVE_STRUCT_STAT_ST_BLKSIZE 1
+/* Darwin uses struct timespec (st_atimespec etc.), not st_*time_nsec */
+#define HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC 1
+#define HAVE_STRUCT_STAT_ST_MTIME_NSEC 0
+#define HAVE_STRUCT_STAT_ST_BIRTHTIMESPEC_TV_NSEC 1
+#define HAVE_STRUCT_TM_TM_GMTOFF 1
+#define HAVE_SYMLINK 1
+#define HAVE_SYS_CDEFS_H 1
+#define HAVE_SYS_STAT_H 1
+#define HAVE_SYS_TIME_H 1
+#define HAVE_SYS_TYPES_H 1
+#define HAVE_SYS_WAIT_H 1
+#define HAVE_TCGETATTR 1
+#define HAVE_TCSETATTR 1
+#define HAVE_TIME_H 1
+#define HAVE_TZSET 1
+#define HAVE_UINTMAX_T 1
+#define HAVE_UNISTD_H 1
+#define HAVE_UNSETENV 1
+#define HAVE_UNSIGNED_LONG_LONG 1
+#define HAVE_UNSIGNED_LONG_LONG_INT 1
+#define HAVE_UTIME 1
+#define HAVE_UTIMES 1
+#define HAVE_UTIME_H 1
+#define HAVE_VFORK 1
+#define HAVE_VPRINTF 1
+#define HAVE_WCHAR_H 1
+#define HAVE_WCHAR_T 1
+#define HAVE_WCRTOMB 1
+#define HAVE_WCSCMP 1
+#define HAVE_WCSCPY 1
+#define HAVE_WCSLEN 1
+#define HAVE_WCTOMB 1
+#define HAVE_WCTYPE_H 1
+#define HAVE_WMEMCMP 1
+#define HAVE_WMEMCPY 1
+#define HAVE_ARC4RANDOM_BUF 1
+#define HAVE_ZLIB_H 1
+#define LSTAT_FOLLOWS_SLASHED_SYMLINK 1
+#define STDC_HEADERS 1
+/* macOS/iOS use XSI strerror_r (returns int), not GNU (returns char*) */
+#define STRERROR_R_CHAR_P 0
+/* wchar_t size: 4 on iOS/ARM, 4 on macOS ARM, 4 on Intel */
+#define SIZEOF_WCHAR_T 4
+
+#endif

package/{android/src/main/cpp/jni → ios/model_detect}/sherpa-onnx-common.h

@@ -1,18 +1,18 @@
-#ifndef SHERPA_ONNX_COMMON_H
-#define SHERPA_ONNX_COMMON_H
-
-#include <string>
-
-namespace sherpaonnx {
-
-/**
- * Information about a detected model.
- */
-struct DetectedModel {
-    std::string type;      // Model type (e.g., "transducer", "paraformer", "nemo_ctc")
-    std::string modelDir;  // Directory path where the model is located
-};
-
-} // namespace sherpaonnx
-
-#endif // SHERPA_ONNX_COMMON_H
+#ifndef SHERPA_ONNX_COMMON_H
+#define SHERPA_ONNX_COMMON_H
+
+#include <string>
+
+namespace sherpaonnx {
+
+/**
+ * Information about a detected model.
+ */
+struct DetectedModel {
+    std::string type;      // Model type (e.g., "transducer", "paraformer", "nemo_ctc")
+    std::string modelDir;  // Directory path where the model is located
+};
+
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_COMMON_H

package/ios/model_detect/sherpa-onnx-model-detect-helper.h

@@ -0,0 +1,49 @@
+#ifndef SHERPA_ONNX_MODEL_DETECT_HELPER_H
+#define SHERPA_ONNX_MODEL_DETECT_HELPER_H
+
+#include <cstdint>
+#include <optional>
+#include <string>
+#include <vector>
+
+namespace sherpaonnx {
+namespace model_detect {
+
+struct FileEntry {
+    std::string path;
+    std::string nameLower;
+    std::uint64_t size = 0;
+};
+
+bool FileExists(const std::string& path);
+bool IsDirectory(const std::string& path);
+std::vector<std::string> ListDirectories(const std::string& path);
+std::vector<FileEntry> ListFiles(const std::string& path);
+std::vector<FileEntry> ListFilesRecursive(const std::string& path, int maxDepth);
+std::string ToLower(std::string value);
+std::string ResolveTokenizerDir(const std::string& modelDir);
+
+std::string FindFileByName(const std::string& baseDir, const std::string& fileName, int maxDepth);
+/** Find file whose name equals or ends with suffix (e.g. tokens.txt, tiny-tokens.txt) in a pre-built file list. */
+std::string FindFileEndingWith(const std::vector<FileEntry>& files, const std::string& suffix);
+std::string FindDirectoryByName(const std::string& baseDir, const std::string& dirName, int maxDepth);
+
+std::string FindOnnxByToken(
+    const std::vector<FileEntry>& files,
+    const std::string& token,
+    const std::optional<bool>& preferInt8
+);
+std::string FindOnnxByAnyToken(
+    const std::vector<FileEntry>& files,
+    const std::vector<std::string>& tokens,
+    const std::optional<bool>& preferInt8
+);
+std::string FindLargestOnnxExcludingTokens(
+    const std::vector<FileEntry>& files,
+    const std::vector<std::string>& excludeTokens
+);
+
+} // namespace model_detect
+} // namespace sherpaonnx
+
+#endif // SHERPA_ONNX_MODEL_DETECT_HELPER_H