react-native-update 10.47.0 → 10.48.0

package/cpp/patch_core/hbc_transform_wire.cpp

@@ -0,0 +1,321 @@
+#include "hbc_transform_wire.h"
+
+namespace pushy {
+namespace hbc {
+
+namespace {
+
+// 面向单一受限格式的手写递归下降解析器。不追求通用 JSON 兼容,
+// 追求:无第三方依赖、输入不可信下的确定性行为、显式上限。
+constexpr size_t kMaxInputBytes = 64 * 1024;
+constexpr int kMaxDepth = 8;
+constexpr uint32_t kMaxSections = 64;
+constexpr uint32_t kMaxDeltaFields = 8;
+
+struct Cursor {
+  const char* p;
+  const char* end;
+};
+
+void SkipWs(Cursor* c) {
+  while (c->p < c->end &&
+         (*c->p == ' ' || *c->p == '\t' || *c->p == '\n' || *c->p == '\r')) {
+    ++c->p;
+  }
+}
+
+bool Consume(Cursor* c, char ch) {
+  SkipWs(c);
+  if (c->p < c->end && *c->p == ch) {
+    ++c->p;
+    return true;
+  }
+  return false;
+}
+
+bool Peek(Cursor* c, char ch) {
+  SkipWs(c);
+  return c->p < c->end && *c->p == ch;
+}
+
+// 仅接受非负整数(本格式中所有数值都是非负整数)
+bool ParseUInt(Cursor* c, uint32_t* out) {
+  SkipWs(c);
+  if (c->p >= c->end || *c->p < '0' || *c->p > '9') {
+    return false;
+  }
+  uint64_t value = 0;
+  while (c->p < c->end && *c->p >= '0' && *c->p <= '9') {
+    value = value * 10 + static_cast<uint64_t>(*c->p - '0');
+    if (value > 0xffffffffull) {
+      return false;
+    }
+    ++c->p;
+  }
+  *out = static_cast<uint32_t>(value);
+  return true;
+}
+
+bool ParseKey(Cursor* c, std::string* out) {
+  SkipWs(c);
+  if (!Consume(c, '"')) {
+    return false;
+  }
+  out->clear();
+  while (c->p < c->end && *c->p != '"') {
+    if (*c->p == '\\') {
+      return false; // 本格式的键不含转义
+    }
+    out->push_back(*c->p);
+    ++c->p;
+    if (out->size() > 64) {
+      return false;
+    }
+  }
+  return Consume(c, '"');
+}
+
+// 跳过未知键的值(数字/字符串/数组/对象),深度受限
+bool SkipValue(Cursor* c, int depth) {
+  if (depth > kMaxDepth) {
+    return false;
+  }
+  SkipWs(c);
+  if (c->p >= c->end) {
+    return false;
+  }
+  const char ch = *c->p;
+  if (ch == '"') {
+    ++c->p;
+    while (c->p < c->end && *c->p != '"') {
+      if (*c->p == '\\') {
+        ++c->p;
+      }
+      ++c->p;
+    }
+    return Consume(c, '"');
+  }
+  if (ch == '[' || ch == '{') {
+    const char close = ch == '[' ? ']' : '}';
+    ++c->p;
+    SkipWs(c);
+    if (Consume(c, close)) {
+      return true;
+    }
+    while (true) {
+      if (close == '}') {
+        std::string key;
+        if (!ParseKey(c, &key) || !Consume(c, ':')) {
+          return false;
+        }
+      }
+      if (!SkipValue(c, depth + 1)) {
+        return false;
+      }
+      if (Consume(c, close)) {
+        return true;
+      }
+      if (!Consume(c, ',')) {
+        return false;
+      }
+    }
+  }
+  if ((ch >= '0' && ch <= '9') || ch == '-') {
+    ++c->p;
+    while (c->p < c->end &&
+           ((*c->p >= '0' && *c->p <= '9') || *c->p == '.' || *c->p == 'e' ||
+            *c->p == 'E' || *c->p == '+' || *c->p == '-')) {
+      ++c->p;
+    }
+    return true;
+  }
+  // true/false/null
+  for (const char* lit : {"true", "false", "null"}) {
+    const size_t n = std::char_traits<char>::length(lit);
+    if (static_cast<size_t>(c->end - c->p) >= n &&
+        std::char_traits<char>::compare(c->p, lit, n) == 0) {
+      c->p += n;
+      return true;
+    }
+  }
+  return false;
+}
+
+// [byte, bit, bits]
+bool ParseDeltaField(Cursor* c, HbcDeltaField* out) {
+  if (!Consume(c, '[')) {
+    return false;
+  }
+  if (!ParseUInt(c, &out->byte) || !Consume(c, ',') ||
+      !ParseUInt(c, &out->bit) || !Consume(c, ',') ||
+      !ParseUInt(c, &out->bits)) {
+    return false;
+  }
+  return Consume(c, ']');
+}
+
+// [countIndex, entrySize, [field, ...]]
+bool ParseSection(Cursor* c, HbcTransformMeta::Section* out) {
+  if (!Consume(c, '[')) {
+    return false;
+  }
+  if (!ParseUInt(c, &out->countIndex) || !Consume(c, ',') ||
+      !ParseUInt(c, &out->entrySize) || !Consume(c, ',')) {
+    return false;
+  }
+  if (!Consume(c, '[')) {
+    return false;
+  }
+  if (!Consume(c, ']')) {
+    while (true) {
+      HbcDeltaField field{};
+      if (out->deltaFields.size() >= kMaxDeltaFields ||
+          !ParseDeltaField(c, &field)) {
+        return false;
+      }
+      out->deltaFields.push_back(field);
+      if (Consume(c, ']')) {
+        break;
+      }
+      if (!Consume(c, ',')) {
+        return false;
+      }
+    }
+  }
+  return Consume(c, ']');
+}
+
+bool ParseLayout(Cursor* c, HbcTransformMeta* out) {
+  if (!Consume(c, '{')) {
+    return false;
+  }
+  bool sawCounts = false;
+  bool sawSections = false;
+  if (!Consume(c, '}')) {
+    while (true) {
+      std::string key;
+      if (!ParseKey(c, &key) || !Consume(c, ':')) {
+        return false;
+      }
+      if (key == "counts") {
+        if (!ParseUInt(c, &out->headerCountFields)) {
+          return false;
+        }
+        sawCounts = true;
+      } else if (key == "sections") {
+        if (!Consume(c, '[')) {
+          return false;
+        }
+        if (!Consume(c, ']')) {
+          while (true) {
+            HbcTransformMeta::Section section;
+            if (out->sections.size() >= kMaxSections ||
+                !ParseSection(c, &section)) {
+              return false;
+            }
+            out->sections.push_back(std::move(section));
+            if (Consume(c, ']')) {
+              break;
+            }
+            if (!Consume(c, ',')) {
+              return false;
+            }
+          }
+        }
+        sawSections = true;
+      } else if (!SkipValue(c, 0)) {
+        return false;
+      }
+      if (Consume(c, '}')) {
+        break;
+      }
+      if (!Consume(c, ',')) {
+        return false;
+      }
+    }
+  }
+  return sawCounts && sawSections;
+}
+
+} // namespace
+
+bool ParseHbcTransformMeta(const std::string& json, HbcTransformMeta* out) {
+  if (out == nullptr || json.empty() || json.size() > kMaxInputBytes) {
+    return false;
+  }
+  *out = HbcTransformMeta{};
+  Cursor c{json.data(), json.data() + json.size()};
+
+  if (!Consume(&c, '{')) {
+    return false;
+  }
+  bool sawV = false;
+  bool sawHbcVersion = false;
+  bool sawLayout = false;
+  if (!Consume(&c, '}')) {
+    while (true) {
+      std::string key;
+      if (!ParseKey(&c, &key) || !Consume(&c, ':')) {
+        return false;
+      }
+      if (key == "v") {
+        if (!ParseUInt(&c, &out->v)) {
+          return false;
+        }
+        sawV = true;
+      } else if (key == "hbcVersion") {
+        if (!ParseUInt(&c, &out->hbcVersion)) {
+          return false;
+        }
+        sawHbcVersion = true;
+      } else if (key == "layout") {
+        if (!Peek(&c, '{') || !ParseLayout(&c, out)) {
+          return false;
+        }
+        sawLayout = true;
+      } else if (!SkipValue(&c, 0)) {
+        return false;
+      }
+      if (Consume(&c, '}')) {
+        break;
+      }
+      if (!Consume(&c, ',')) {
+        return false;
+      }
+    }
+  }
+  SkipWs(&c);
+  if (c.p != c.end) {
+    return false; // 尾部不允许有多余内容
+  }
+  if (!sawV || !sawHbcVersion || !sawLayout) {
+    return false;
+  }
+  if (out->sections.empty() || out->headerCountFields == 0) {
+    return false;
+  }
+  return true;
+}
+
+HbcLayoutDesc BuildLayout(
+    const HbcTransformMeta& meta,
+    std::vector<HbcSectionDesc>* sections_scratch) {
+  sections_scratch->clear();
+  sections_scratch->reserve(meta.sections.size());
+  for (const HbcTransformMeta::Section& s : meta.sections) {
+    HbcSectionDesc desc;
+    desc.countIndex = s.countIndex;
+    desc.entrySize = s.entrySize;
+    desc.deltaFields = s.deltaFields.empty() ? nullptr : s.deltaFields.data();
+    desc.deltaFieldCount = static_cast<uint32_t>(s.deltaFields.size());
+    sections_scratch->push_back(desc);
+  }
+  HbcLayoutDesc layout;
+  layout.headerCountFields = meta.headerCountFields;
+  layout.sections = sections_scratch->data();
+  layout.sectionCount = static_cast<uint32_t>(sections_scratch->size());
+  return layout;
+}
+
+} // namespace hbc
+} // namespace pushy

package/cpp/patch_core/hbc_transform_wire.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <cstdint>
+#include <string>
+#include <vector>
+
+#include "hbc_transform.h"
+
+namespace pushy {
+namespace hbc {
+
+// 客户端当前支持的变换规范版本(内部 wire 版本,仅用于校验 __diff.json
+// 中 hbcTransform.v)。v 不在支持范围时调用方必须放弃 diff 应用(回退
+// 整包),不能忽略元数据。
+constexpr uint32_t kHbcTransformSupportedVersion = 1;
+
+// 客户端可消费的 diff 轨道版本(客户端↔服务端接口用这个数字):
+//   1 = baseline(普通 hdiff single 格式)
+//   2 = v2 轨道(HBC 变换元数据 spec v1 + HDIFF13 流式容器)
+// 经 getConstants 暴露给 JS,随 checkUpdate 以 diffV 上报,服务端据此
+// 决定下发 v2/ 前缀产物。轨道号与 OSS 前缀/文档中的 "v2" 语义对齐;
+// 变换 spec 版本是其内部实现细节(轨道 v2 ⇒ spec ≤ 1)。
+constexpr uint32_t kSupportedDiffVersion = 2;
+
+// __diff.json 中单个 bundle patch 条目的 hbcTransform 元数据:
+// {"v":1,"hbcVersion":96,"layout":{"counts":19,"sections":[[ci,es,[[b,bi,bits],...]],...]}}
+// 解析结果自持有存储;BuildLayout 产出的描述指向本结构,生存期须不短于使用期。
+struct HbcTransformMeta {
+  uint32_t v = 0;
+  uint32_t hbcVersion = 0;
+  uint32_t headerCountFields = 0;
+  struct Section {
+    uint32_t countIndex = 0;
+    uint32_t entrySize = 0;
+    std::vector<HbcDeltaField> deltaFields;
+  };
+  std::vector<Section> sections;
+};
+
+// 严格解析(元数据视为不可信输入):结构、类型、数量全部受限,
+// 任何偏离返回 false。允许对象中出现未知键(数字/字符串/嵌套值会被跳过),
+// 为未来元数据扩展留余地。
+bool ParseHbcTransformMeta(const std::string& json, HbcTransformMeta* out);
+
+// 由 meta 构建解释器输入。sections_scratch 由调用方持有,生存期须覆盖
+// layout 的使用期(layout 内部指针指向 meta 与 scratch)。
+HbcLayoutDesc BuildLayout(
+    const HbcTransformMeta& meta,
+    std::vector<HbcSectionDesc>* sections_scratch);
+
+} // namespace hbc
+} // namespace pushy

package/cpp/patch_core/patch_core.cpp

@@ -10,6 +10,9 @@
 
 #include <vector>
 
+#include "hbc_transform.h"
+#include "hbc_transform_wire.h"
+
 extern "C" {
 #include "hpatch.h"
 }
@@ -181,6 +184,51 @@ Status RemovePathRecursively(const std::string& path) {
   return Status::Ok();
 }
 
+Status ReadFileBytes(const std::string& path, std::vector<uint8_t>* out) {
+  FILE* file = fopen(path.c_str(), "rb");
+  if (file == nullptr) {
+    return MakeErrnoStatus("Failed to open file for reading " + path);
+  }
+  if (fseek(file, 0, SEEK_END) != 0) {
+    fclose(file);
+    return MakeErrnoStatus("Failed to seek file " + path);
+  }
+  const long size = ftell(file);
+  if (size < 0) {
+    fclose(file);
+    return MakeErrnoStatus("Failed to size file " + path);
+  }
+  if (fseek(file, 0, SEEK_SET) != 0) {
+    fclose(file);
+    return MakeErrnoStatus("Failed to rewind file " + path);
+  }
+  out->resize(static_cast<size_t>(size));
+  if (size > 0 &&
+      fread(out->data(), 1, out->size(), file) != out->size()) {
+    fclose(file);
+    return Status::Error("Failed to read file " + path);
+  }
+  fclose(file);
+  return Status::Ok();
+}
+
+Status WriteFileBytes(const std::string& path, const std::vector<uint8_t>& data) {
+  FILE* file = fopen(path.c_str(), "wb");
+  if (file == nullptr) {
+    return MakeErrnoStatus("Failed to open file for writing " + path);
+  }
+  if (!data.empty() && fwrite(data.data(), 1, data.size(), file) != data.size()) {
+    fclose(file);
+    remove(path.c_str());
+    return Status::Error("Failed to write file " + path);
+  }
+  if (fclose(file) != 0) {
+    remove(path.c_str());
+    return MakeErrnoStatus("Failed to flush file " + path);
+  }
+  return Status::Ok();
+}
+
 Status CopyFile(const std::string& from, const std::string& to, bool overwrite) {
   struct stat st;
   if (stat(from.c_str(), &st) != 0) {
@@ -393,6 +441,77 @@ const BundlePatcher& DefaultBundlePatcher() {
   return kPatcher;
 }
 
+namespace {
+
+// 变换域 bundle patch:T(origin) → hpatch → T⁻¹。
+// 元数据/变换的任何失败都返回错误——调用方沿既有失败路径回退整包;
+// 绝不能忽略元数据直接 hpatch(会产出损坏 bundle,虽然最终 hash 校验
+// 也会拦住,但应在此处快速失败)。
+Status ApplyBundlePatchWithHbcTransform(
+    const FileSourcePatchOptions& options,
+    const BundlePatcher& bundle_patcher) {
+  hbc::HbcTransformMeta meta;
+  if (!hbc::ParseHbcTransformMeta(options.bundle_hbc_transform_meta, &meta)) {
+    return Status::Error("Invalid hbcTransform metadata");
+  }
+  if (meta.v != hbc::kHbcTransformSupportedVersion) {
+    return Status::Error(
+        "Unsupported hbcTransform version " +
+        IntToString(static_cast<int>(meta.v)));
+  }
+  std::vector<hbc::HbcSectionDesc> sections_scratch;
+  const hbc::HbcLayoutDesc layout = hbc::BuildLayout(meta, &sections_scratch);
+
+  std::vector<uint8_t> origin;
+  Status status = ReadFileBytes(options.origin_bundle_path, &origin);
+  if (!status) {
+    return status;
+  }
+  if (!hbc::TransformHbcInPlace(origin.data(), origin.size(), layout, false)) {
+    return Status::Error("hbcTransform failed on origin bundle");
+  }
+
+  Status dir_status = EnsureDirectory(Dirname(options.bundle_output_path));
+  if (!dir_status) {
+    return dir_status;
+  }
+  const std::string temp_origin = options.bundle_output_path + ".hbct-origin";
+  const std::string temp_patched = options.bundle_output_path + ".hbct-patched";
+  status = WriteFileBytes(temp_origin, origin);
+  if (!status) {
+    return status;
+  }
+  origin = std::vector<uint8_t>(); // 及早释放,patch 期间只保留文件副本
+
+  Status patch_status =
+      bundle_patcher.Apply(temp_origin, options.bundle_patch_path, temp_patched);
+  remove(temp_origin.c_str());
+  if (!patch_status) {
+    remove(temp_patched.c_str());
+    return patch_status;
+  }
+
+  std::vector<uint8_t> patched;
+  status = ReadFileBytes(temp_patched, &patched);
+  remove(temp_patched.c_str());
+  if (!status) {
+    return status;
+  }
+  if (!hbc::TransformHbcInPlace(patched.data(), patched.size(), layout, true)) {
+    return Status::Error("hbcTransform inverse failed on patched bundle");
+  }
+
+  if (PathExists(options.bundle_output_path)) {
+    Status remove_status = RemovePathRecursively(options.bundle_output_path);
+    if (!remove_status) {
+      return remove_status;
+    }
+  }
+  return WriteFileBytes(options.bundle_output_path, patched);
+}
+
+}  // namespace
+
 Status ApplyPatchFromFileSource(
     const FileSourcePatchOptions& options,
     const BundlePatcher& bundle_patcher) {
@@ -401,10 +520,13 @@ Status ApplyPatchFromFileSource(
     return manifest_status;
   }
 
-  Status bundle_status = bundle_patcher.Apply(
-      options.origin_bundle_path,
-      options.bundle_patch_path,
-      options.bundle_output_path);
+  Status bundle_status =
+      options.bundle_hbc_transform_meta.empty()
+          ? bundle_patcher.Apply(
+                options.origin_bundle_path,
+                options.bundle_patch_path,
+                options.bundle_output_path)
+          : ApplyBundlePatchWithHbcTransform(options, bundle_patcher);
   if (!bundle_status) {
     return bundle_status;
   }

package/cpp/patch_core/patch_core.h

@@ -36,6 +36,11 @@ struct FileSourcePatchOptions {
   std::string bundle_output_path;
   std::string merge_source_subdir;
   bool enable_merge = true;
+  // __diff.json 中该 bundle patch 条目的 hbcTransform 元数据(原始 JSON)。
+  // 非空时 patch 走变换域:T(origin) → hpatch → T⁻¹。元数据不可解析或
+  // 变换规范版本不受支持时返回错误(调用方回退整包),绝不忽略元数据
+  // 直接应用——那会产出损坏的 bundle。
+  std::string bundle_hbc_transform_meta;
 };
 
 class BundlePatcher {

package/cpp/patch_core/patch_core_android.cpp

@@ -27,7 +27,8 @@ Java_cn_reactnative_modules_update_DownloadTask_applyPatchFromFileSource(
     jboolean enable_merge,
     jobjectArray copy_froms,
     jobjectArray copy_tos,
-    jobjectArray deletes) {
+    jobjectArray deletes,
+    jstring hbc_transform_meta) {
   const std::vector<std::string> from_values = JArrayToVector(env, copy_froms);
   const std::vector<std::string> to_values = JArrayToVector(env, copy_tos);
 
@@ -44,6 +45,7 @@ Java_cn_reactnative_modules_update_DownloadTask_applyPatchFromFileSource(
   options.bundle_output_path = JStringToString(env, bundle_output_path);
   options.merge_source_subdir = JStringToString(env, merge_source_subdir);
   options.enable_merge = enable_merge == JNI_TRUE;
+  options.bundle_hbc_transform_meta = JStringToString(env, hbc_transform_meta);
 
   for (size_t index = 0; index < from_values.size(); ++index) {
     options.manifest.copies.push_back(pushy::patch::CopyOperation{

package/cpp/patch_core/tests/fixtures/v96.meta.json

@@ -0,0 +1 @@
+{"v":1,"hbcVersion":96,"layout":{"counts":19,"sections":[[2,16,[[0,0,25],[8,0,25]]],[3,4,[]],[4,4,[]],[5,4,[[0,1,23]]],[6,8,[[0,0,32]]],[7,1,[]],[12,1,[]],[13,1,[]],[14,1,[]],[8,8,[[0,0,32]]],[9,1,[]],[10,8,[[0,0,32]]],[11,1,[]],[16,8,[]],[17,8,[]]]}}