react-native-update 10.49.0 → 10.51.0

package/cpp/patch_core/tests/patch_core_test.cpp

@@ -814,6 +814,102 @@ void TestSha256File() {
       "Sha256File over a missing file returns empty");
 }
 
+void TestCrc32KnownVectors() {
+  {
+    pushy::digest::Crc32 crc;
+    Expect(crc.Value() == 0x00000000u, "crc32 of empty input");
+  }
+  {
+    // The classic check value: crc32("123456789") == 0xCBF43926.
+    pushy::digest::Crc32 crc;
+    const char* input = "123456789";
+    crc.Update(reinterpret_cast<const uint8_t*>(input), 9);
+    Expect(crc.Value() == 0xCBF43926u, "crc32 check value of \"123456789\"");
+  }
+  {
+    // Streaming in awkward chunks must match the one-shot value.
+    const std::string input(100000, 'a');
+    pushy::digest::Crc32 one_shot;
+    one_shot.Update(
+        reinterpret_cast<const uint8_t*>(input.data()), input.size());
+    pushy::digest::Crc32 streamed;
+    size_t offset = 0;
+    size_t chunk = 1;
+    while (offset < input.size()) {
+      const size_t take =
+          offset + chunk > input.size() ? input.size() - offset : chunk;
+      streamed.Update(
+          reinterpret_cast<const uint8_t*>(input.data()) + offset, take);
+      offset += take;
+      chunk = chunk * 2 + 1;
+    }
+    Expect(
+        streamed.Value() == one_shot.Value(),
+        "crc32 streaming matches one-shot");
+  }
+}
+
+void TestCrc32File() {
+  TempDir temp;
+  const std::string dir = temp.path;
+  const std::string path = dir + "/input.bin";
+  WriteFile(path, "123456789");
+  uint32_t value = 0;
+  Expect(pushy::digest::Crc32File(path, &value), "Crc32File should read");
+  Expect(value == 0xCBF43926u, "Crc32File check value");
+  Expect(
+      !pushy::digest::Crc32File(dir + "/missing.bin", &value),
+      "Crc32File over a missing file returns false");
+}
+
+void TestApplyPatchCopiesVerifyExpectedCrc() {
+  TempDir temp;
+  const std::string source = JoinPath(temp.path, "origin");
+  const std::string target = JoinPath(temp.path, "target");
+  const std::string patch = JoinPath(temp.path, "bundle.patch");
+
+  WriteFile(JoinPath(source, "index.bundlejs"), "old bundle");
+  WriteFile(JoinPath(source, "assets/keep.txt"), "123456789");
+  WriteFile(patch, "unused patch");
+
+  FakeBundlePatcher patcher("patched bundle");
+  FileSourcePatchOptions options;
+  options.source_root = source;
+  options.target_root = target;
+  options.origin_bundle_path = JoinPath(source, "index.bundlejs");
+  options.bundle_patch_path = patch;
+  options.bundle_output_path = JoinPath(target, "index.bundlejs");
+  options.enable_merge = false;
+  CopyOperation copy;
+  copy.from = "assets/keep.txt";
+  copy.to = "assets/keep.txt";
+  copy.has_expected_crc = true;
+  copy.expected_crc = 0xCBF43926u;  // crc32("123456789")
+  options.manifest.copies.push_back(copy);
+
+  Status status = ApplyPatchFromFileSource(options, patcher);
+  Expect(status.ok, status.message);
+  ExpectEq(
+      ReadFile(JoinPath(target, "assets/keep.txt")),
+      "123456789",
+      "verified copy content");
+
+  // Same manifest applied on a "rebuilt" source whose file drifted: the copy
+  // must fail the whole patch (caller falls back to full), not copy silently.
+  WriteFile(JoinPath(source, "assets/keep.txt"), "drifted-bytes");
+  const std::string target2 = JoinPath(temp.path, "target2");
+  options.target_root = target2;
+  options.bundle_output_path = JoinPath(target2, "index.bundlejs");
+  Status mismatch = ApplyPatchFromFileSource(options, patcher);
+  Expect(!mismatch.ok, "drifted copy source must fail the patch");
+  Expect(
+      mismatch.message.find("crc32") != std::string::npos,
+      "mismatch error should mention crc32");
+  Expect(
+      !Exists(JoinPath(target2, "assets/keep.txt")),
+      "drifted content must not be copied");
+}
+
 }  // namespace
 
 int main(int argc, char** argv) {
@@ -848,6 +944,9 @@ int main(int argc, char** argv) {
       {"Sha256KnownVectors", TestSha256KnownVectors},
       {"Sha256StreamingMatchesOneShot", TestSha256StreamingMatchesOneShot},
       {"Sha256File", TestSha256File},
+      {"Crc32KnownVectors", TestCrc32KnownVectors},
+      {"Crc32File", TestCrc32File},
+      {"ApplyPatchCopiesVerifyExpectedCrc", TestApplyPatchCopiesVerifyExpectedCrc},
   };
 
   int failures = 0;

package/cpp/update_flow_core/flow_json.cpp

@@ -0,0 +1,522 @@
+#include "flow_json.h"
+
+#include <cmath>
+#include <cstdio>
+#include <cstdlib>
+
+namespace flowjson {
+
+namespace {
+const Value kUndefined;
+}  // namespace
+
+bool Value::Truthy() const {
+  switch (kind_) {
+    case Kind::Undefined:
+    case Kind::Null:
+      return false;
+    case Kind::Bool:
+      return bool_;
+    case Kind::Number:
+      return number_ != 0 && !std::isnan(number_);
+    case Kind::String:
+      return !string_.empty();
+    case Kind::Array:
+    case Kind::Object:
+      return true;
+  }
+  return false;
+}
+
+const Value& Value::At(size_t i) const {
+  if (kind_ != Kind::Array || i >= elements_.size()) {
+    return kUndefined;
+  }
+  return elements_[i];
+}
+
+const Value& Value::Get(const std::string& key) const {
+  if (kind_ == Kind::Object) {
+    for (const auto& member : members_) {
+      if (member.first == key) {
+        return member.second;
+      }
+    }
+  }
+  return kUndefined;
+}
+
+void Value::Set(const std::string& key, Value v) {
+  for (auto& member : members_) {
+    if (member.first == key) {
+      member.second = std::move(v);
+      return;
+    }
+  }
+  members_.emplace_back(key, std::move(v));
+}
+
+void Value::Remove(const std::string& key) {
+  for (auto it = members_.begin(); it != members_.end(); ++it) {
+    if (it->first == key) {
+      members_.erase(it);
+      return;
+    }
+  }
+}
+
+bool Value::StrictEquals(const Value& a, const Value& b) {
+  if (a.kind_ != b.kind_) {
+    return false;
+  }
+  switch (a.kind_) {
+    case Kind::Undefined:
+    case Kind::Null:
+      return true;
+    case Kind::Bool:
+      return a.bool_ == b.bool_;
+    case Kind::Number:
+      return a.number_ == b.number_;
+    case Kind::String:
+      return a.string_ == b.string_;
+    case Kind::Array:
+    case Kind::Object:
+      return false;
+  }
+  return false;
+}
+
+namespace {
+
+void AppendEscaped(const std::string& s, std::string* out) {
+  out->push_back('"');
+  for (unsigned char c : s) {
+    switch (c) {
+      case '"':
+        out->append("\\\"");
+        break;
+      case '\\':
+        out->append("\\\\");
+        break;
+      case '\b':
+        out->append("\\b");
+        break;
+      case '\f':
+        out->append("\\f");
+        break;
+      case '\n':
+        out->append("\\n");
+        break;
+      case '\r':
+        out->append("\\r");
+        break;
+      case '\t':
+        out->append("\\t");
+        break;
+      default:
+        if (c < 0x20) {
+          char buf[8];
+          std::snprintf(buf, sizeof(buf), "\\u%04x", c);
+          out->append(buf);
+        } else {
+          out->push_back(static_cast<char>(c));
+        }
+    }
+  }
+  out->push_back('"');
+}
+
+void AppendNumber(double n, std::string* out) {
+  // The decision layer only ever emits integral numbers (hashes, counters,
+  // rollout percentages); print them the way JSON.stringify does. The %.17g
+  // fallback exists so an unexpected fractional value surfaces as a vector
+  // mismatch instead of silent truncation.
+  if (std::isfinite(n) && n == std::floor(n) && std::fabs(n) <= 9007199254740992.0) {
+    char buf[32];
+    std::snprintf(buf, sizeof(buf), "%lld", static_cast<long long>(n));
+    out->append(buf);
+  } else {
+    char buf[40];
+    std::snprintf(buf, sizeof(buf), "%.17g", n);
+    out->append(buf);
+  }
+}
+
+void AppendValue(const Value& v, std::string* out) {
+  switch (v.kind()) {
+    case Value::Kind::Undefined:  // only reachable inside arrays
+    case Value::Kind::Null:
+      out->append("null");
+      break;
+    case Value::Kind::Bool:
+      out->append(v.AsBool() ? "true" : "false");
+      break;
+    case Value::Kind::Number:
+      AppendNumber(v.AsNumber(), out);
+      break;
+    case Value::Kind::String:
+      AppendEscaped(v.AsString(), out);
+      break;
+    case Value::Kind::Array: {
+      out->push_back('[');
+      bool first = true;
+      for (const auto& element : v.elements()) {
+        if (!first) {
+          out->push_back(',');
+        }
+        first = false;
+        AppendValue(element, out);
+      }
+      out->push_back(']');
+      break;
+    }
+    case Value::Kind::Object: {
+      out->push_back('{');
+      bool first = true;
+      for (const auto& member : v.members()) {
+        if (member.second.IsUndefined()) {
+          continue;  // JSON.stringify drops undefined-valued members
+        }
+        if (!first) {
+          out->push_back(',');
+        }
+        first = false;
+        AppendEscaped(member.first, out);
+        out->push_back(':');
+        AppendValue(member.second, out);
+      }
+      out->push_back('}');
+      break;
+    }
+  }
+}
+
+}  // namespace
+
+std::string Stringify(const Value& v) {
+  if (v.IsUndefined()) {
+    return "undefined";
+  }
+  std::string out;
+  AppendValue(v, &out);
+  return out;
+}
+
+namespace {
+
+// The parser also consumes server checkUpdate responses, so hostile input
+// must fail cleanly: nesting is capped to keep recursive descent off the
+// stack limit. Real responses nest ~4 levels.
+constexpr int kMaxDepth = 64;
+
+class Parser {
+ public:
+  Parser(const std::string& text) : text_(text) {}
+
+  Value Run(bool* ok) {
+    Value v = ParseValue();
+    SkipWs();
+    *ok = ok_ && pos_ == text_.size();
+    return *ok ? v : Value::Undefined();
+  }
+
+ private:
+  void SkipWs() {
+    while (pos_ < text_.size()) {
+      char c = text_[pos_];
+      if (c == ' ' || c == '\t' || c == '\n' || c == '\r') {
+        pos_++;
+      } else {
+        break;
+      }
+    }
+  }
+
+  bool Consume(char expected) {
+    if (pos_ < text_.size() && text_[pos_] == expected) {
+      pos_++;
+      return true;
+    }
+    ok_ = false;
+    return false;
+  }
+
+  bool ConsumeLiteral(const char* literal) {
+    size_t len = 0;
+    while (literal[len]) {
+      len++;
+    }
+    if (text_.compare(pos_, len, literal) == 0) {
+      pos_ += len;
+      return true;
+    }
+    ok_ = false;
+    return false;
+  }
+
+  Value ParseValue() {
+    SkipWs();
+    if (pos_ >= text_.size()) {
+      ok_ = false;
+      return Value::Undefined();
+    }
+    char c = text_[pos_];
+    switch (c) {
+      case '{':
+      case '[': {
+        if (depth_ >= kMaxDepth) {
+          ok_ = false;
+          return Value::Undefined();
+        }
+        depth_++;
+        Value v = c == '{' ? ParseObject() : ParseArray();
+        depth_--;
+        return v;
+      }
+      case '"':
+        return Value::String(ParseString());
+      case 't':
+        ConsumeLiteral("true");
+        return Value::Bool(true);
+      case 'f':
+        ConsumeLiteral("false");
+        return Value::Bool(false);
+      case 'n':
+        ConsumeLiteral("null");
+        return Value::Null();
+      default:
+        return ParseNumber();
+    }
+  }
+
+  Value ParseObject() {
+    Value obj = Value::Object();
+    Consume('{');
+    SkipWs();
+    if (pos_ < text_.size() && text_[pos_] == '}') {
+      pos_++;
+      return obj;
+    }
+    while (ok_) {
+      SkipWs();
+      std::string key = ParseString();
+      SkipWs();
+      Consume(':');
+      obj.Set(key, ParseValue());
+      SkipWs();
+      if (pos_ < text_.size() && text_[pos_] == ',') {
+        pos_++;
+        continue;
+      }
+      Consume('}');
+      break;
+    }
+    return obj;
+  }
+
+  Value ParseArray() {
+    Value arr = Value::Array();
+    Consume('[');
+    SkipWs();
+    if (pos_ < text_.size() && text_[pos_] == ']') {
+      pos_++;
+      return arr;
+    }
+    while (ok_) {
+      arr.Push(ParseValue());
+      SkipWs();
+      if (pos_ < text_.size() && text_[pos_] == ',') {
+        pos_++;
+        continue;
+      }
+      Consume(']');
+      break;
+    }
+    return arr;
+  }
+
+  std::string ParseString() {
+    std::string out;
+    if (!Consume('"')) {
+      return out;
+    }
+    while (pos_ < text_.size()) {
+      char c = text_[pos_++];
+      if (c == '"') {
+        return out;
+      }
+      if (c != '\\') {
+        out.push_back(c);
+        continue;
+      }
+      if (pos_ >= text_.size()) {
+        break;
+      }
+      char esc = text_[pos_++];
+      switch (esc) {
+        case '"':
+        case '\\':
+        case '/':
+          out.push_back(esc);
+          break;
+        case 'b':
+          out.push_back('\b');
+          break;
+        case 'f':
+          out.push_back('\f');
+          break;
+        case 'n':
+          out.push_back('\n');
+          break;
+        case 'r':
+          out.push_back('\r');
+          break;
+        case 't':
+          out.push_back('\t');
+          break;
+        case 'u': {
+          unsigned code = ParseHex4();
+          // BMP code point to UTF-8 (surrogate pairs are combined).
+          if (code >= 0xd800 && code <= 0xdbff &&
+              text_.compare(pos_, 2, "\\u") == 0) {
+            pos_ += 2;
+            unsigned low = ParseHex4();
+            if (low >= 0xdc00 && low <= 0xdfff) {
+              code = 0x10000 + ((code - 0xd800) << 10) + (low - 0xdc00);
+            } else {
+              ok_ = false;
+            }
+          }
+          AppendUtf8(code, &out);
+          break;
+        }
+        default:
+          ok_ = false;
+          return out;
+      }
+    }
+    ok_ = false;
+    return out;
+  }
+
+  unsigned ParseHex4() {
+    unsigned code = 0;
+    for (int i = 0; i < 4; i++) {
+      if (pos_ >= text_.size()) {
+        ok_ = false;
+        return 0;
+      }
+      char c = text_[pos_++];
+      code <<= 4;
+      if (c >= '0' && c <= '9') {
+        code |= static_cast<unsigned>(c - '0');
+      } else if (c >= 'a' && c <= 'f') {
+        code |= static_cast<unsigned>(c - 'a' + 10);
+      } else if (c >= 'A' && c <= 'F') {
+        code |= static_cast<unsigned>(c - 'A' + 10);
+      } else {
+        ok_ = false;
+        return 0;
+      }
+    }
+    return code;
+  }
+
+  static void AppendUtf8(unsigned code, std::string* out) {
+    if (code < 0x80) {
+      out->push_back(static_cast<char>(code));
+    } else if (code < 0x800) {
+      out->push_back(static_cast<char>(0xc0 | (code >> 6)));
+      out->push_back(static_cast<char>(0x80 | (code & 0x3f)));
+    } else if (code < 0x10000) {
+      out->push_back(static_cast<char>(0xe0 | (code >> 12)));
+      out->push_back(static_cast<char>(0x80 | ((code >> 6) & 0x3f)));
+      out->push_back(static_cast<char>(0x80 | (code & 0x3f)));
+    } else {
+      out->push_back(static_cast<char>(0xf0 | (code >> 18)));
+      out->push_back(static_cast<char>(0x80 | ((code >> 12) & 0x3f)));
+      out->push_back(static_cast<char>(0x80 | ((code >> 6) & 0x3f)));
+      out->push_back(static_cast<char>(0x80 | (code & 0x3f)));
+    }
+  }
+
+  Value ParseNumber() {
+    size_t start = pos_;
+    if (pos_ < text_.size() && text_[pos_] == '-') {
+      pos_++;
+    }
+
+    if (pos_ >= text_.size()) {
+      ok_ = false;
+      return Value::Undefined();
+    }
+    if (text_[pos_] == '0') {
+      pos_++;
+      // RFC 8259 forbids leading zeroes (except the number zero itself).
+      if (pos_ < text_.size() && text_[pos_] >= '0' && text_[pos_] <= '9') {
+        ok_ = false;
+        return Value::Undefined();
+      }
+    } else if (text_[pos_] >= '1' && text_[pos_] <= '9') {
+      while (pos_ < text_.size() && text_[pos_] >= '0' &&
+             text_[pos_] <= '9') {
+        pos_++;
+      }
+    } else {
+      ok_ = false;
+      return Value::Undefined();
+    }
+
+    if (pos_ < text_.size() && text_[pos_] == '.') {
+      pos_++;
+      if (pos_ >= text_.size() || text_[pos_] < '0' || text_[pos_] > '9') {
+        ok_ = false;
+        return Value::Undefined();
+      }
+      while (pos_ < text_.size() && text_[pos_] >= '0' &&
+             text_[pos_] <= '9') {
+        pos_++;
+      }
+    }
+
+    if (pos_ < text_.size() &&
+        (text_[pos_] == 'e' || text_[pos_] == 'E')) {
+      pos_++;
+      if (pos_ < text_.size() &&
+          (text_[pos_] == '+' || text_[pos_] == '-')) {
+        pos_++;
+      }
+      if (pos_ >= text_.size() || text_[pos_] < '0' || text_[pos_] > '9') {
+        ok_ = false;
+        return Value::Undefined();
+      }
+      while (pos_ < text_.size() && text_[pos_] >= '0' &&
+             text_[pos_] <= '9') {
+        pos_++;
+      }
+    }
+
+    char* end = nullptr;
+    std::string token = text_.substr(start, pos_ - start);
+    double n = std::strtod(token.c_str(), &end);
+    if (end == nullptr || *end != '\0') {
+      ok_ = false;
+      return Value::Undefined();
+    }
+    return Value::Number(n);
+  }
+
+  const std::string& text_;
+  size_t pos_ = 0;
+  int depth_ = 0;
+  bool ok_ = true;
+};
+
+}  // namespace
+
+Value Parse(const std::string& text, bool* ok) {
+  Parser parser(text);
+  return parser.Run(ok);
+}
+
+}  // namespace flowjson