react-native-update 10.59.2 → 10.61.0

package/cpp/update_flow_core/native_config.cpp

@@ -0,0 +1,436 @@
+#include "native_config.h"
+
+#include <unordered_set>
+#include <utility>
+#include <vector>
+
+#include "../patch_core/native_texts.h"
+
+namespace flowcore {
+
+using flowjson::Value;
+
+namespace {
+
+// Length of the ECMAScript whitespace/line terminator encoded at text[i], or
+// 0 when there is none.
+size_t WhitespaceAt(const std::string& text, size_t i) {
+  const size_t left = text.size() - i;
+  const auto byte = [&](size_t k) {
+    return static_cast<unsigned char>(text[i + k]);
+  };
+  const unsigned char b0 = byte(0);
+  if (b0 == ' ' || (b0 >= 0x09 && b0 <= 0x0d)) {
+    return 1;
+  }
+  if (b0 == 0xc2 && left >= 2 && byte(1) == 0xa0) {
+    return 2;  // U+00A0
+  }
+  if (left < 3) {
+    return 0;
+  }
+  const unsigned char b1 = byte(1);
+  const unsigned char b2 = byte(2);
+  if (b0 == 0xe1 && b1 == 0x9a && b2 == 0x80) {
+    return 3;  // U+1680
+  }
+  if (b0 == 0xe2 && b1 == 0x80 &&
+      (b2 <= 0x8a || b2 == 0xa8 || b2 == 0xa9 || b2 == 0xaf) && b2 >= 0x80) {
+    return 3;  // U+2000-U+200A, U+2028, U+2029, U+202F
+  }
+  if (b0 == 0xe2 && b1 == 0x81 && b2 == 0x9f) {
+    return 3;  // U+205F
+  }
+  if (b0 == 0xe3 && b1 == 0x80 && b2 == 0x80) {
+    return 3;  // U+3000
+  }
+  if (b0 == 0xef && b1 == 0xbb && b2 == 0xbf) {
+    return 3;  // U+FEFF
+  }
+  return 0;
+}
+
+bool ContainsJsWhitespace(const std::string& text) {
+  for (size_t i = 0; i < text.size(); i++) {
+    if (WhitespaceAt(text, i) != 0) {
+      return true;
+    }
+  }
+  return false;
+}
+
+std::string StripTrailingSlashes(std::string text) {
+  while (!text.empty() && text.back() == '/') {
+    text.pop_back();
+  }
+  return text;
+}
+
+// Strings lose their trailing '/' first; then every entry (string or not)
+// already present by value is dropped.
+Value CanonicalUrlList(const Value& list) {
+  if (!list.IsArray()) {
+    return list;
+  }
+  Value result = Value::Array();
+  std::unordered_set<std::string> strings;
+  std::vector<const Value*> others;
+  for (const Value& item : list.elements()) {
+    if (item.IsString()) {
+      std::string url = StripTrailingSlashes(item.AsString());
+      if (strings.insert(url).second) {
+        result.Push(Value::String(std::move(url)));
+      }
+      continue;
+    }
+    bool seen = false;
+    for (const Value* other : others) {
+      if (Value::DeepEquals(*other, item)) {
+        seen = true;
+        break;
+      }
+    }
+    if (!seen) {
+      others.push_back(&item);
+      result.Push(item);
+    }
+  }
+  return result;
+}
+
+Value ParseObject(const std::string& json) {
+  bool ok = false;
+  Value value = flowjson::Parse(json, &ok);
+  return ok && value.IsObject() ? value : Value::Undefined();
+}
+
+// Stored encoded (native_texts.h), Pushy's service addresses among them.
+using pushy::texts::DefaultEndpoints;
+using pushy::texts::DefaultQueryUrls;
+using pushy::texts::PolicyNextLaunch;
+
+Value StringArray(const std::vector<std::string>& values) {
+  Value array = Value::Array();
+  for (const std::string& value : values) {
+    array.Push(Value::String(value));
+  }
+  return array;
+}
+
+bool IsHexDigit(char c) {
+  return (c >= '0' && c <= '9') || (c >= 'a' && c <= 'f') ||
+         (c >= 'A' && c <= 'F');
+}
+
+bool IsDigit(char c) { return c >= '0' && c <= '9'; }
+
+bool IsHostChar(char c) {
+  return (c >= 'a' && c <= 'z') || (c >= 'A' && c <= 'Z') || IsDigit(c) ||
+         c == '.' || c == '-';
+}
+
+// ^https?://(\[[0-9a-fA-F:]+\]|[a-zA-Z0-9.-]+)(:[0-9]+)?([/?#]|$) — the
+// scheme and authority check; anything else in the authority (userinfo,
+// spaces, a missing host) fails it. Every quantifier is greedy and its
+// continuation cannot start with a character it consumes, so a single
+// left-to-right scan matches exactly what the backtracking regex does.
+bool HasHttpAuthority(const std::string& url) {
+  size_t i = 0;
+  const std::string http = "http";
+  if (url.compare(0, http.size(), http) != 0) {
+    return false;
+  }
+  i = http.size();
+  if (i < url.size() && url[i] == 's') {
+    i++;
+  }
+  if (url.compare(i, 3, "://") != 0) {
+    return false;
+  }
+  i += 3;
+  const size_t host = i;
+  if (i < url.size() && url[i] == '[') {
+    i++;
+    while (i < url.size() && (IsHexDigit(url[i]) || url[i] == ':')) {
+      i++;
+    }
+    if (i == host + 1 || i >= url.size() || url[i] != ']') {
+      return false;
+    }
+    i++;
+  } else {
+    while (i < url.size() && IsHostChar(url[i])) {
+      i++;
+    }
+    if (i == host) {
+      return false;
+    }
+  }
+  if (i < url.size() && url[i] == ':') {
+    const size_t port = ++i;
+    while (i < url.size() && IsDigit(url[i])) {
+      i++;
+    }
+    if (i == port) {
+      return false;
+    }
+  }
+  return i == url.size() || url[i] == '/' || url[i] == '?' || url[i] == '#';
+}
+
+// The normalizer's checks report the first problem in *error (without the
+// prefix) and return false; no exceptions, the cores build without unwind
+// tables on Android.
+bool ConfigString(const Value& value, const std::string& name, bool allowEmpty,
+                  std::string* out, std::string* error) {
+  if (!value.IsString() ||
+      (!allowEmpty && TrimJsWhitespace(value.AsString()).empty())) {
+    *error = name + " must be a string" +
+             (allowEmpty ? "" : " and must not be blank");
+    return false;
+  }
+  *out = value.AsString();
+  return true;
+}
+
+// `base` lists (endpoints) are request bases: non-empty, no query or
+// fragment, trailing '/' dropped. Discovery lists keep their URLs whole.
+bool ConfigUrls(const Value& values, const std::string& name, bool base,
+                Value* out, std::string* error) {
+  if (!values.IsArray() || (base && values.Size() == 0)) {
+    *error = name + " must be " + (base ? "a non-empty" : "an") + " array";
+    return false;
+  }
+  Value result = Value::Array();
+  std::unordered_set<std::string> seen;
+  for (const Value& item : values.elements()) {
+    std::string url;
+    if (!ConfigString(item, name, false, &url, error)) {
+      return false;
+    }
+    url = TrimJsWhitespace(url);
+    if (!HasHttpAuthority(url) || ContainsJsWhitespace(url) ||
+        url.find('\\') != std::string::npos ||
+        (base && url.find_first_of("?#") != std::string::npos)) {
+      *error = name + " requires absolute HTTP(S) URLs without credentials" +
+               (base ? ", queries or fragments" : "");
+      return false;
+    }
+    if (base) {
+      url = StripTrailingSlashes(std::move(url));
+    }
+    if (seen.insert(url).second) {
+      result.Push(Value::String(std::move(url)));
+    }
+  }
+  *out = std::move(result);
+  return true;
+}
+
+bool Normalize(const std::string& optionsJson, Value* out,
+               std::string* error) {
+  const Value options = ParseObject(optionsJson);
+  if (!options.IsObject()) {
+    *error = "expected an object";
+    return false;
+  }
+  static const char* const kKeys[] = {
+      "appKey",   "endpoints",      "queryUrls", "afterDownload",
+      "disabled", "packageVersion", "rnu",       "rn"};
+  for (const auto& member : options.members()) {
+    bool known = false;
+    for (const char* key : kKeys) {
+      known = known || member.first == key;
+    }
+    if (!known) {
+      *error = "unknown option " + member.first;
+      return false;
+    }
+  }
+  const auto has = [&](const char* key) {
+    return !options.Get(key).IsUndefined();
+  };
+  // A string option: absent takes `fallback`, present must pass ConfigString.
+  const auto string = [&](const char* key, bool allowEmpty,
+                          const std::string& fallback, Value* result) {
+    std::string value = fallback;
+    if (has(key) &&
+        !ConfigString(options.Get(key), key, allowEmpty, &value, error)) {
+      return false;
+    }
+    *result = Value::String(std::move(value));
+    return true;
+  };
+
+  Value appKey, endpoints, queryUrls, rnu, rn, packageVersion;
+  if (!has("appKey")) {
+    *error = "appKey must be a string and must not be blank";
+    return false;
+  }
+  if (!string("appKey", false, "", &appKey)) {
+    return false;
+  }
+  const bool customEndpoints = has("endpoints");
+  if (!ConfigUrls(customEndpoints ? options.Get("endpoints")
+                                  : StringArray(DefaultEndpoints()),
+                  "endpoints", true, &endpoints, error) ||
+      !ConfigUrls(has("queryUrls")  ? options.Get("queryUrls")
+                  : customEndpoints ? Value::Array()
+                                    : StringArray(DefaultQueryUrls()),
+                  "queryUrls", false, &queryUrls, error)) {
+    return false;
+  }
+  Value afterDownload = Value::String("none");
+  if (has("afterDownload")) {
+    afterDownload = options.Get("afterDownload");
+    if (!afterDownload.IsString() || (afterDownload.AsString() != "none" &&
+                                      afterDownload.AsString() !=
+                                          PolicyNextLaunch())) {
+      *error = "afterDownload must be none or " + PolicyNextLaunch();
+      return false;
+    }
+  }
+  const Value& disabled = options.Get("disabled");
+  if (!disabled.IsUndefined() && !disabled.IsBool()) {
+    *error = "disabled must be a boolean";
+    return false;
+  }
+  if (!string("rnu", true, "", &rnu) || !string("rn", true, "", &rn) ||
+      (has("packageVersion") &&
+       !string("packageVersion", false, "", &packageVersion))) {
+    return false;
+  }
+  Value result = Value::Object();
+  result.Set("appKey", std::move(appKey));
+  result.Set("endpoints", std::move(endpoints));
+  result.Set("queryUrls", std::move(queryUrls));
+  result.Set("afterDownload", std::move(afterDownload));
+  result.Set("disabled", Value::Bool(disabled.IsBool() && disabled.AsBool()));
+  result.Set("rnu", std::move(rnu));
+  result.Set("rn", std::move(rn));
+  if (!packageVersion.IsUndefined()) {
+    result.Set("packageVersion", std::move(packageVersion));
+  }
+  *out = std::move(result);
+  return true;
+}
+
+}  // namespace
+
+std::string TrimJsWhitespace(const std::string& text) {
+  size_t begin = 0;
+  while (begin < text.size()) {
+    const size_t length = WhitespaceAt(text, begin);
+    if (length == 0) {
+      break;
+    }
+    begin += length;
+  }
+  size_t end = text.size();
+  while (end > begin) {
+    // A whitespace sequence is 1-3 bytes; try each length ending at `end`.
+    size_t length = 0;
+    for (size_t candidate = 1; candidate <= 3 && candidate <= end - begin;
+         candidate++) {
+      if (WhitespaceAt(text, end - candidate) == candidate) {
+        length = candidate;
+        break;
+      }
+    }
+    if (length == 0) {
+      break;
+    }
+    end -= length;
+  }
+  return text.substr(begin, end - begin);
+}
+
+Value CanonicalNativeConfig(const std::string& json) {
+  Value config = ParseObject(json);
+  if (!config.IsObject()) {
+    return config;
+  }
+  const std::pair<const char*, Value> defaults[] = {
+      {"disabled", Value::Bool(false)}, {"queryUrls", Value::Array()},
+      {"rnu", Value::String("")},       {"rn", Value::String("")},
+      {"afterDownload", Value::String("none")},
+  };
+  for (const auto& entry : defaults) {
+    if (config.Get(entry.first).IsUndefined()) {
+      config.Set(entry.first, entry.second);
+    }
+  }
+  for (const char* key : {"endpoints", "queryUrls"}) {
+    const Value& list = config.Get(key);
+    if (list.IsArray()) {
+      config.Set(key, CanonicalUrlList(list));
+    }
+  }
+  return config;
+}
+
+bool ConfigsEquivalent(const std::string& a, const std::string& b) {
+  const Value left = CanonicalNativeConfig(a);
+  if (!left.IsObject()) {
+    return false;
+  }
+  const Value right = CanonicalNativeConfig(b);
+  return right.IsObject() && Value::DeepEquals(left, right);
+}
+
+RunnableConfig ParseRunnableConfig(const std::string& json) {
+  RunnableConfig result;
+  if (json.empty()) {
+    result.status = "skipped";
+    result.reason = "not_configured";
+    return result;
+  }
+  Value config = ParseObject(json);
+  if (!config.IsObject()) {
+    result.status = "failed";
+    result.reason = "invalid_config";
+    return result;
+  }
+  if (config.Get("disabled").Truthy()) {
+    result.status = "skipped";
+    result.reason = "disabled";
+    return result;
+  }
+  const Value& appKey = config.Get("appKey");
+  std::string trimmed =
+      appKey.IsString() ? TrimJsWhitespace(appKey.AsString()) : std::string();
+  if (trimmed.empty()) {
+    result.status = "failed";
+    result.reason = "invalid_config";
+    return result;
+  }
+  result.appKey = std::move(trimmed);
+  result.config = std::move(config);
+  return result;
+}
+
+std::string RunnableConfigJson(const std::string& json) {
+  const RunnableConfig parsed = ParseRunnableConfig(json);
+  Value result = Value::Object();
+  if (parsed.runnable()) {
+    result.Set("appKey", Value::String(parsed.appKey));
+  } else {
+    result.Set("status", Value::String(parsed.status));
+    result.Set("reason", Value::String(parsed.reason));
+  }
+  return flowjson::Stringify(result);
+}
+
+bool NormalizeConfiguration(const std::string& optionsJson, std::string* out,
+                            std::string* error) {
+  Value result;
+  std::string why;
+  if (!Normalize(optionsJson, &result, &why)) {
+    *error = "Invalid native configuration: " + why;
+    return false;
+  }
+  *out = flowjson::Stringify(result);
+  return true;
+}
+
+}  // namespace flowcore

package/cpp/update_flow_core/native_config.h

@@ -0,0 +1,84 @@
+#pragma once
+
+#include <string>
+
+#include "flow_json.h"
+
+// The persisted native check config: its validation when a host configures
+// it, the gate that decides whether it can run a round, and the equivalence
+// that decides whether a new one is a change. One implementation for the
+// Android, iOS and Harmony orchestrators (each used to carry its own copy);
+// JSON strings in and out so the bindings stay thin.
+//
+// The JS client keeps its own TS copy of the equivalence
+// (src/updateFlowCore.ts nativeConfigsEquivalent — it must also run on web and
+// on natives that predate this file); both replay
+// tests/config-equivalence-vectors.json. The gate and the normalizer have no
+// JS counterpart; tests/native-config-vectors.json pins them.
+// Keep the core internal to whichever binary links it (see podspec Core).
+#pragma GCC visibility push(hidden)
+
+namespace flowcore {
+
+// ECMAScript String.prototype.trim: strips WhiteSpace and LineTerminator
+// code points (TAB, LF, VT, FF, CR, SPACE, NBSP, U+1680, U+2000-U+200A,
+// U+2028, U+2029, U+202F, U+205F, U+3000, U+FEFF) from both ends of a UTF-8
+// string. Other control characters are kept.
+std::string TrimJsWhitespace(const std::string& text);
+
+// Contract C1. Canonical form of a persisted config: the parsed object with
+// absent keys defaulted ({disabled:false, queryUrls:[], rnu:"", rn:"",
+// afterDownload:"none"}) and each `endpoints`/`queryUrls` array's strings
+// stripped of every trailing '/', then deduplicated keeping the first
+// occurrence. Present values are never coerced (0 is not false, null is not
+// a default). Undefined when the text is not a JSON object.
+flowjson::Value CanonicalNativeConfig(const std::string& json);
+
+// Two configs are equivalent iff both are JSON objects whose canonical forms
+// are DeepEquals (key order ignored). Anything else is never equivalent, not
+// even to itself — callers pass "" for an absent config.
+bool ConfigsEquivalent(const std::string& a, const std::string& b);
+
+// The gate every entry point (round start, crash-hold install, the host's
+// prepareBundle, the round itself) applies to the persisted config, so they
+// agree on what is runnable:
+//   ""                                   -> skipped / not_configured
+//   not a JSON object                    -> failed  / invalid_config
+//   `disabled` truthy (JS truthiness)    -> skipped / disabled
+//   `appKey` not a string, or blank      -> failed  / invalid_config
+//     after TrimJsWhitespace
+//   otherwise runnable, with the trimmed appKey and the parsed config.
+struct RunnableConfig {
+  std::string status;  // empty when runnable, else "skipped" / "failed"
+  std::string reason;
+  std::string appKey;
+  flowjson::Value config;
+
+  bool runnable() const { return status.empty(); }
+};
+RunnableConfig ParseRunnableConfig(const std::string& json);
+
+// Binding form of ParseRunnableConfig: {"appKey": "<trimmed>"} when runnable,
+// otherwise {"status": "...", "reason": "..."}. The binding re-parses the
+// config itself when it needs more fields.
+std::string RunnableConfigJson(const std::string& json);
+
+// Validates the options a host passes to configure() (a JSON object) and
+// returns the config to persist:
+//   {appKey, endpoints, queryUrls, afterDownload, disabled, rnu, rn,
+//    packageVersion?}
+// Only those keys are accepted. appKey/packageVersion are non-blank strings
+// (kept as given), rnu/rn strings. endpoints default to Pushy's own and must
+// be a non-empty array of absolute http(s) URLs without credentials, queries
+// or fragments; each is trimmed, stripped of trailing '/' and deduplicated.
+// queryUrls default to Pushy's discovery URLs, or to [] once endpoints are
+// custom; each is trimmed and deduplicated (queries allowed). afterDownload
+// is "none" (default) or the next-launch policy; disabled a boolean. A
+// present null is invalid, never a default. On failure returns false and
+// sets *error to "Invalid native configuration: <why>".
+bool NormalizeConfiguration(const std::string& optionsJson, std::string* out,
+                            std::string* error);
+
+}  // namespace flowcore
+
+#pragma GCC visibility pop