react-native-update-cli 1.20.0 → 1.20.6

package/lib/utils/app-info-parser/apk.js

@@ -0,0 +1,86 @@
+'use strict';
+
+const Zip = require('./zip');
+const { mapInfoResource, findApkIconPath, getBase64FromBuffer } = require('./utils');
+const ManifestName = /^androidmanifest\.xml$/;
+const ResourceName = /^resources\.arsc$/;
+
+const ManifestXmlParser = require('./xml-parser/manifest');
+const ResourceFinder = require('./resource-finder');
+
+class ApkParser extends Zip {
+  /**
+   * parser for parsing .apk file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor(file) {
+    super(file);
+    if (!(this instanceof ApkParser)) {
+      return new ApkParser(file);
+    }
+  }
+  parse() {
+    return new Promise((resolve, reject) => {
+      this.getEntries([ManifestName, ResourceName]).then(buffers => {
+        if (!buffers[ManifestName]) {
+          throw new Error('AndroidManifest.xml can\'t be found.');
+        }
+        let apkInfo = this._parseManifest(buffers[ManifestName]);
+        let resourceMap;
+        if (!buffers[ResourceName]) {
+          resolve(apkInfo);
+        } else {
+          // parse resourceMap
+          resourceMap = this._parseResourceMap(buffers[ResourceName]);
+          // update apkInfo with resourceMap
+          apkInfo = mapInfoResource(apkInfo, resourceMap);
+
+          // find icon path and parse icon
+          const iconPath = findApkIconPath(apkInfo);
+          if (iconPath) {
+            this.getEntry(iconPath).then(iconBuffer => {
+              apkInfo.icon = iconBuffer ? getBase64FromBuffer(iconBuffer) : null;
+              resolve(apkInfo);
+            }).catch(e => {
+              apkInfo.icon = null;
+              resolve(apkInfo);
+              console.warn('[Warning] failed to parse icon: ', e);
+            });
+          } else {
+            apkInfo.icon = null;
+            resolve(apkInfo);
+          }
+        }
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+  /**
+   * Parse manifest
+   * @param {Buffer} buffer // manifest file's buffer
+   */
+  _parseManifest(buffer) {
+    try {
+      const parser = new ManifestXmlParser(buffer, {
+        ignore: ['application.activity', 'application.service', 'application.receiver', 'application.provider', 'permission-group']
+      });
+      return parser.parse();
+    } catch (e) {
+      throw new Error('Parse AndroidManifest.xml error: ', e);
+    }
+  }
+  /**
+   * Parse resourceMap
+   * @param {Buffer} buffer // resourceMap file's buffer
+   */
+  _parseResourceMap(buffer) {
+    try {
+      return new ResourceFinder().processResourceTable(buffer);
+    } catch (e) {
+      throw new Error('Parser resources.arsc error: ' + e);
+    }
+  }
+}
+
+module.exports = ApkParser;

package/lib/utils/app-info-parser/index.js

@@ -0,0 +1,37 @@
+'use strict';
+
+const ApkParser = require('./apk');
+const IpaParser = require('./ipa');
+const supportFileTypes = ['ipa', 'apk'];
+
+class AppInfoParser {
+  /**
+   * parser for parsing .ipa or .apk file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor(file) {
+    if (!file) {
+      throw new Error('Param miss: file(file\'s path in Node, instance of File or Blob in browser).');
+    }
+    const splits = (file.name || file).split('.');
+    const fileType = splits[splits.length - 1].toLowerCase();
+    if (!supportFileTypes.includes(fileType)) {
+      throw new Error('Unsupported file type, only support .ipa or .apk file.');
+    }
+    this.file = file;
+
+    switch (fileType) {
+      case 'ipa':
+        this.parser = new IpaParser(this.file);
+        break;
+      case 'apk':
+        this.parser = new ApkParser(this.file);
+        break;
+    }
+  }
+  parse() {
+    return this.parser.parse();
+  }
+}
+
+module.exports = AppInfoParser;

package/lib/utils/app-info-parser/ipa.js

@@ -0,0 +1,96 @@
+'use strict';
+
+function _toConsumableArray(arr) { if (Array.isArray(arr)) { for (var i = 0, arr2 = Array(arr.length); i < arr.length; i++) arr2[i] = arr[i]; return arr2; } else { return Array.from(arr); } }
+
+const parsePlist = require('plist').parse;
+const parseBplist = require('bplist-parser').parseBuffer;
+const cgbiToPng = require('cgbi-to-png');
+
+const Zip = require('./zip');
+const { findIpaIconPath, getBase64FromBuffer, isBrowser } = require('./utils');
+
+const PlistName = new RegExp('payload/[^/]+?.app/info.plist$', 'i');
+const ProvisionName = /payload\/.+?\.app\/embedded.mobileprovision/;
+
+class IpaParser extends Zip {
+  /**
+   * parser for parsing .ipa file
+   * @param {String | File | Blob} file // file's path in Node, instance of File or Blob in Browser
+   */
+  constructor(file) {
+    super(file);
+    if (!(this instanceof IpaParser)) {
+      return new IpaParser(file);
+    }
+  }
+  parse() {
+    return new Promise((resolve, reject) => {
+      this.getEntries([PlistName, ProvisionName]).then(buffers => {
+        if (!buffers[PlistName]) {
+          throw new Error('Info.plist can\'t be found.');
+        }
+        const plistInfo = this._parsePlist(buffers[PlistName]);
+        // parse mobile provision
+        const provisionInfo = this._parseProvision(buffers[ProvisionName]);
+        plistInfo.mobileProvision = provisionInfo;
+
+        // find icon path and parse icon
+        const iconRegex = new RegExp(findIpaIconPath(plistInfo).toLowerCase());
+        this.getEntry(iconRegex).then(iconBuffer => {
+          try {
+            // In general, the ipa file's icon has been specially processed, should be converted
+            plistInfo.icon = iconBuffer ? getBase64FromBuffer(cgbiToPng.revert(iconBuffer)) : null;
+          } catch (err) {
+            if (isBrowser()) {
+              // Normal conversion in other cases
+              plistInfo.icon = iconBuffer ? getBase64FromBuffer(window.btoa(String.fromCharCode.apply(String, _toConsumableArray(iconBuffer)))) : null;
+            } else {
+              plistInfo.icon = null;
+              console.warn('[Warning] failed to parse icon: ', err);
+            }
+          }
+          resolve(plistInfo);
+        }).catch(e => {
+          reject(e);
+        });
+      }).catch(e => {
+        reject(e);
+      });
+    });
+  }
+  /**
+   * Parse plist
+   * @param {Buffer} buffer // plist file's buffer
+   */
+  _parsePlist(buffer) {
+    let result;
+    const bufferType = buffer[0];
+    if (bufferType === 60 || bufferType === '<' || bufferType === 239) {
+      result = parsePlist(buffer.toString());
+    } else if (bufferType === 98) {
+      result = parseBplist(buffer)[0];
+    } else {
+      throw new Error('Unknown plist buffer type.');
+    }
+    return result;
+  }
+  /**
+   * parse provision
+   * @param {Buffer} buffer // provision file's buffer
+   */
+  _parseProvision(buffer) {
+    let info = {};
+    if (buffer) {
+      let content = buffer.toString('utf-8');
+      const firstIndex = content.indexOf('<?xml');
+      const endIndex = content.indexOf('</plist>');
+      content = content.slice(firstIndex, endIndex + 8);
+      if (content) {
+        info = parsePlist(content);
+      }
+    }
+    return info;
+  }
+}
+
+module.exports = IpaParser;

package/lib/utils/app-info-parser/resource-finder.js

@@ -0,0 +1,486 @@
+"use strict";
+
+/**
+ * Code translated from a C# project https://github.com/hylander0/Iteedee.ApkReader/blob/master/Iteedee.ApkReader/ApkResourceFinder.cs
+ *
+ * Decode binary file `resources.arsc` from a .apk file to a JavaScript Object.
+ */
+
+var ByteBuffer = require("bytebuffer");
+
+var DEBUG = false;
+
+var RES_STRING_POOL_TYPE = 0x0001;
+var RES_TABLE_TYPE = 0x0002;
+var RES_TABLE_PACKAGE_TYPE = 0x0200;
+var RES_TABLE_TYPE_TYPE = 0x0201;
+var RES_TABLE_TYPE_SPEC_TYPE = 0x0202;
+
+// The 'data' holds a ResTable_ref, a reference to another resource
+// table entry.
+var TYPE_REFERENCE = 0x01;
+// The 'data' holds an index into the containing resource table's
+// global value string pool.
+var TYPE_STRING = 0x03;
+
+function ResourceFinder() {
+  this.valueStringPool = null;
+  this.typeStringPool = null;
+  this.keyStringPool = null;
+
+  this.package_id = 0;
+
+  this.responseMap = {};
+  this.entryMap = {};
+}
+
+/**
+ * Same to C# BinaryReader.readBytes
+ *
+ * @param bb ByteBuffer
+ * @param len length
+ * @returns {Buffer}
+ */
+ResourceFinder.readBytes = function (bb, len) {
+  var uint8Array = new Uint8Array(len);
+  for (var i = 0; i < len; i++) {
+    uint8Array[i] = bb.readUint8();
+  }
+
+  return ByteBuffer.wrap(uint8Array, "binary", true);
+};
+
+//
+/**
+ *
+ * @param {ByteBuffer} bb
+ * @return {Map<String, Set<String>>}
+ */
+ResourceFinder.prototype.processResourceTable = function (resourceBuffer) {
+  const bb = ByteBuffer.wrap(resourceBuffer, "binary", true);
+
+  // Resource table structure
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      packageCount = bb.readInt(),
+      buffer,
+      bb2;
+  if (type != RES_TABLE_TYPE) {
+    throw new Error("No RES_TABLE_TYPE found!");
+  }
+  if (size != bb.limit) {
+    throw new Error("The buffer size not matches to the resource table size.");
+  }
+  bb.offset = headerSize;
+
+  var realStringPoolCount = 0,
+      realPackageCount = 0;
+
+  while (true) {
+    var pos, t, hs, s;
+    try {
+      pos = bb.offset;
+      t = bb.readShort();
+      hs = bb.readShort();
+      s = bb.readInt();
+    } catch (e) {
+      break;
+    }
+    if (t == RES_STRING_POOL_TYPE) {
+      // Process the string pool
+      if (realStringPoolCount == 0) {
+        // Only the first string pool is processed.
+        if (DEBUG) {
+          console.log("Processing the string pool ...");
+        }
+
+        buffer = new ByteBuffer(s);
+        bb.offset = pos;
+        bb.prependTo(buffer);
+
+        bb2 = ByteBuffer.wrap(buffer, "binary", true);
+
+        bb2.LE();
+        this.valueStringPool = this.processStringPool(bb2);
+      }
+      realStringPoolCount++;
+    } else if (t == RES_TABLE_PACKAGE_TYPE) {
+      // Process the package
+      if (DEBUG) {
+        console.log("Processing the package " + realPackageCount + " ...");
+      }
+
+      buffer = new ByteBuffer(s);
+      bb.offset = pos;
+      bb.prependTo(buffer);
+
+      bb2 = ByteBuffer.wrap(buffer, "binary", true);
+      bb2.LE();
+      this.processPackage(bb2);
+
+      realPackageCount++;
+    } else {
+      throw new Error("Unsupported type");
+    }
+    bb.offset = pos + s;
+    if (!bb.remaining()) break;
+  }
+
+  if (realStringPoolCount != 1) {
+    throw new Error("More than 1 string pool found!");
+  }
+  if (realPackageCount != packageCount) {
+    throw new Error("Real package count not equals the declared count.");
+  }
+
+  return this.responseMap;
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processPackage = function (bb) {
+  // Package structure
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      id = bb.readInt();
+
+  this.package_id = id;
+
+  for (var i = 0; i < 256; ++i) {
+    bb.readUint8();
+  }
+
+  var typeStrings = bb.readInt(),
+      lastPublicType = bb.readInt(),
+      keyStrings = bb.readInt(),
+      lastPublicKey = bb.readInt();
+
+  if (typeStrings != headerSize) {
+    throw new Error("TypeStrings must immediately following the package structure header.");
+  }
+
+  if (DEBUG) {
+    console.log("Type strings:");
+  }
+
+  var lastPosition = bb.offset;
+  bb.offset = typeStrings;
+  var bbTypeStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
+  bb.offset = lastPosition;
+  this.typeStringPool = this.processStringPool(bbTypeStrings);
+
+  // Key strings
+  if (DEBUG) {
+    console.log("Key strings:");
+  }
+
+  bb.offset = keyStrings;
+  var key_type = bb.readShort(),
+      key_headerSize = bb.readShort(),
+      key_size = bb.readInt();
+
+  lastPosition = bb.offset;
+  bb.offset = keyStrings;
+  var bbKeyStrings = ResourceFinder.readBytes(bb, bb.limit - bb.offset);
+  bb.offset = lastPosition;
+  this.keyStringPool = this.processStringPool(bbKeyStrings);
+
+  // Iterate through all chunks
+  var typeSpecCount = 0;
+  var typeCount = 0;
+
+  bb.offset = keyStrings + key_size;
+
+  var bb2;
+
+  while (true) {
+    var pos = bb.offset;
+    try {
+      var t = bb.readShort();
+      var hs = bb.readShort();
+      var s = bb.readInt();
+    } catch (e) {
+      break;
+    }
+
+    if (t == RES_TABLE_TYPE_SPEC_TYPE) {
+      bb.offset = pos;
+      bb2 = ResourceFinder.readBytes(bb, s);
+      this.processTypeSpec(bb2);
+
+      typeSpecCount++;
+    } else if (t == RES_TABLE_TYPE_TYPE) {
+      bb.offset = pos;
+      bb2 = ResourceFinder.readBytes(bb, s);
+      this.processType(bb2);
+
+      typeCount++;
+    }
+
+    if (s == 0) {
+      break;
+    }
+
+    bb.offset = pos + s;
+
+    if (!bb.remaining()) {
+      break;
+    }
+  }
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processType = function (bb) {
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      id = bb.readByte(),
+      res0 = bb.readByte(),
+      res1 = bb.readShort(),
+      entryCount = bb.readInt(),
+      entriesStart = bb.readInt();
+
+  var refKeys = {};
+
+  var config_size = bb.readInt();
+
+  // Skip the config data
+  bb.offset = headerSize;
+
+  if (headerSize + entryCount * 4 != entriesStart) {
+    throw new Error("HeaderSize, entryCount and entriesStart are not valid.");
+  }
+
+  // Start to get entry indices
+  var entryIndices = new Array(entryCount);
+  for (var i = 0; i < entryCount; ++i) {
+    entryIndices[i] = bb.readInt();
+  }
+
+  // Get entries
+  for (var i = 0; i < entryCount; ++i) {
+    if (entryIndices[i] == -1) continue;
+
+    var resource_id = this.package_id << 24 | id << 16 | i;
+
+    var pos = bb.offset,
+        entry_size,
+        entry_flag,
+        entry_key,
+        value_size,
+        value_res0,
+        value_dataType,
+        value_data;
+    try {
+      entry_size = bb.readShort();
+      entry_flag = bb.readShort();
+      entry_key = bb.readInt();
+    } catch (e) {
+      break;
+    }
+
+    // Get the value (simple) or map (complex)
+
+    var FLAG_COMPLEX = 0x0001;
+    if ((entry_flag & FLAG_COMPLEX) == 0) {
+      // Simple case
+      value_size = bb.readShort();
+      value_res0 = bb.readByte();
+      value_dataType = bb.readByte();
+      value_data = bb.readInt();
+
+      var idStr = Number(resource_id).toString(16);
+      var keyStr = this.keyStringPool[entry_key];
+
+      var data = null;
+
+      if (DEBUG) {
+        console.log("Entry 0x" + idStr + ", key: " + keyStr + ", simple value type: ");
+      }
+
+      var key = parseInt(idStr, 16);
+
+      var entryArr = this.entryMap[key];
+      if (entryArr == null) {
+        entryArr = [];
+      }
+      entryArr.push(keyStr);
+
+      this.entryMap[key] = entryArr;
+
+      if (value_dataType == TYPE_STRING) {
+        data = this.valueStringPool[value_data];
+
+        if (DEBUG) {
+          console.log(", data: " + this.valueStringPool[value_data] + "");
+        }
+      } else if (value_dataType == TYPE_REFERENCE) {
+        var hexIndex = Number(value_data).toString(16);
+
+        refKeys[idStr] = value_data;
+      } else {
+        data = "" + value_data;
+        if (DEBUG) {
+          console.log(", data: " + value_data + "");
+        }
+      }
+
+      this.putIntoMap("@" + idStr, data);
+    } else {
+      // Complex case
+      var entry_parent = bb.readInt();
+      var entry_count = bb.readInt();
+
+      for (var j = 0; j < entry_count; ++j) {
+        var ref_name = bb.readInt();
+        value_size = bb.readShort();
+        value_res0 = bb.readByte();
+        value_dataType = bb.readByte();
+        value_data = bb.readInt();
+      }
+
+      if (DEBUG) {
+        console.log("Entry 0x" + Number(resource_id).toString(16) + ", key: " + this.keyStringPool[entry_key] + ", complex value, not printed.");
+      }
+    }
+  }
+
+  for (var refK in refKeys) {
+    var values = this.responseMap["@" + Number(refKeys[refK]).toString(16).toUpperCase()];
+    if (values != null && Object.keys(values).length < 1000) {
+      for (var value in values) {
+        this.putIntoMap("@" + refK, values[value]);
+      }
+    }
+  }
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ * @return {Array}
+ */
+ResourceFinder.prototype.processStringPool = function (bb) {
+  // String pool structure
+  //
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      stringCount = bb.readInt(),
+      styleCount = bb.readInt(),
+      flags = bb.readInt(),
+      stringsStart = bb.readInt(),
+      stylesStart = bb.readInt(),
+      u16len,
+      buffer;
+
+  var isUTF_8 = (flags & 256) != 0;
+
+  var offsets = new Array(stringCount);
+  for (var i = 0; i < stringCount; ++i) {
+    offsets[i] = bb.readInt();
+  }
+
+  var strings = new Array(stringCount);
+
+  for (var i = 0; i < stringCount; ++i) {
+    var pos = stringsStart + offsets[i];
+    bb.offset = pos;
+
+    strings[i] = "";
+
+    if (isUTF_8) {
+      u16len = bb.readUint8();
+
+      if ((u16len & 0x80) != 0) {
+        u16len = ((u16len & 0x7f) << 8) + bb.readUint8();
+      }
+
+      var u8len = bb.readUint8();
+      if ((u8len & 0x80) != 0) {
+        u8len = ((u8len & 0x7f) << 8) + bb.readUint8();
+      }
+
+      if (u8len > 0) {
+        buffer = ResourceFinder.readBytes(bb, u8len);
+        try {
+          strings[i] = ByteBuffer.wrap(buffer, "utf8", true).toString("utf8");
+        } catch (e) {
+          if (DEBUG) {
+            console.error(e);
+            console.log("Error when turning buffer to utf-8 string.");
+          }
+        }
+      } else {
+        strings[i] = "";
+      }
+    } else {
+      u16len = bb.readUint16();
+      if ((u16len & 0x8000) != 0) {
+        // larger than 32768
+        u16len = ((u16len & 0x7fff) << 16) + bb.readUint16();
+      }
+
+      if (u16len > 0) {
+        var len = u16len * 2;
+        buffer = ResourceFinder.readBytes(bb, len);
+        try {
+          strings[i] = ByteBuffer.wrap(buffer, "utf8", true).toString("utf8");
+        } catch (e) {
+          if (DEBUG) {
+            console.error(e);
+            console.log("Error when turning buffer to utf-8 string.");
+          }
+        }
+      }
+    }
+
+    if (DEBUG) {
+      console.log("Parsed value: {0}", strings[i]);
+    }
+  }
+
+  return strings;
+};
+
+/**
+ *
+ * @param {ByteBuffer} bb
+ */
+ResourceFinder.prototype.processTypeSpec = function (bb) {
+  var type = bb.readShort(),
+      headerSize = bb.readShort(),
+      size = bb.readInt(),
+      id = bb.readByte(),
+      res0 = bb.readByte(),
+      res1 = bb.readShort(),
+      entryCount = bb.readInt();
+
+  if (DEBUG) {
+    console.log("Processing type spec " + this.typeStringPool[id - 1] + "...");
+  }
+
+  var flags = new Array(entryCount);
+
+  for (var i = 0; i < entryCount; ++i) {
+    flags[i] = bb.readInt();
+  }
+};
+
+ResourceFinder.prototype.putIntoMap = function (resId, value) {
+  if (this.responseMap[resId.toUpperCase()] == null) {
+    this.responseMap[resId.toUpperCase()] = [];
+  }
+  if (value) {
+    this.responseMap[resId.toUpperCase()].push(value);
+  }
+};
+
+module.exports = ResourceFinder;