Merge remote-tracking branch 'origin/main' into dconeybe/PortChangelist361880889

Author: dconeybe

.github/workflows/android.yml

@@ -70,7 +70,7 @@ jobs:
       - name: Add msbuild to PATH
         if: startsWith(matrix.os, 'windows')
         uses: microsoft/[email protected]
-      
+
       - name: Cache NDK
         id: cache_ndk
         uses: actions/cache@v2
@@ -83,6 +83,26 @@ jobs:
         run: |
           build_scripts/android/install_prereqs.sh
 
+      - name: Add strings.exe to PATH (Windows only)
+        if: startsWith(matrix.os, 'windows')
+        shell: bash
+        run: |
+          # strings.exe was installed in repo root by install_prereqs.sh.
+          # There is another conflicting strings executable on Github runners.
+          # "C:\ProgramData\Chocolatey\lib\mingw\tools\install\mingw64\bin\strings.exe"
+          # Make sure to prepend the one in our repo root to the path.
+          echo "${{ github.workspace }}" >> $GITHUB_PATH
+
+      - name: Run strings.exe once to accept license(Windows only)
+        if: startsWith(matrix.os, 'windows')
+        shell: bash
+        run: |
+          # This invocation is just to accept the license. Otherwise the command
+          # fails during build process. Also, running a command with just this
+          # flag makes the process exit with code 127 and stops the workflow.
+          # We ignore the error and continue with the rest of the steps.
+          strings -accepteula || true
+
       - name: Cache ccache files
         id: cache_ccache
         uses: actions/cache@v2

.github/workflows/check-labels.yml

@@ -0,0 +1,20 @@
+name: Check PR Labels
+on:
+  pull_request:
+    types: [opened, reopened, synchronize, labeled, unlabeled]
+
+env:
+  triggerLabelFull: "tests-requested: full"
+  triggerLabelQuick: "tests-requested: quick"
+  statusLabelInProgress: "tests: in-progress"
+  statusLabelFailed: "tests: failed"
+
+jobs:
+  check_integration_test_labels:
+    # This check fails if integration tests are queued, in progress, or failed.
+    runs-on: ubuntu-latest
+    steps:
+    - uses: docker://agilepathway/pull-request-label-checker:latest
+      with:
+        none_of: "${{ env.statusLabelInProgress }},${{ env.statusLabelFailed }},${{ env.triggerLabelFull }},${{ env.triggerLabelQuick }}"
+        repo_token: ${{ github.token }}

.github/workflows/cpp-packaging.yml

@@ -457,6 +457,13 @@ jobs:
           declare -a additional_flags
           tar -xvzf artifacts/packaging-tools-${tools_platform}/packaging-tools.tgz -C bin
           chmod -R u+x bin
+          # To save space, delete any artifacts that we don't need for packaging.
+          for pkg in artifacts/firebase-cpp-sdk-*; do
+            if [[ "${pkg}" != "artifacts/firebase-cpp-sdk-${{ matrix.sdk_platform }}${{ matrix.suffix }}"* ]]; then
+              echo "Deleting unneeded artifact: ${pkg}"
+              rm  -rf "${pkg}"
+            fi
+          done
           for pkg in artifacts/firebase-cpp-sdk-${{ matrix.sdk_platform }}${{ matrix.suffix }}*-build/*.tgz; do
             # determine the build variant based on the artifact filename
             variant=$(sdk-src/build_scripts/desktop/get_variant.sh "${pkg}")

.github/workflows/integration_tests.yml

@@ -23,7 +23,7 @@ android {
     ndk {
       // Default list of ABIs available in up-to-date NDK.
       abiFilters "x86", "armeabi-v7a", "arm64-v8a", "x86_64"
-      
+
       if (System.getenv("ANDROID_NDK_HOME").contains("r16b") ||
           System.getenv("ANDROID_NDK_HOME").contains("r11c")) {
         // Deprecated ABIs are added to the list when building using older NDKs only.

android_build_files/android_abis.gradle

@@ -21,6 +21,7 @@
 #include <iostream>
 #include <memory>
 #include <string>
+#include <string_view>
 #include <vector>
 
 #include "gtest/gtest.h"
@@ -1047,5 +1048,135 @@ TEST(ZLibWrapperStandalone, ReadPastEndOfWindow) {
   LOG(INFO) << "passed read-past-end-of-window test";
 }
 
+TEST(ZLibWrapperStandalone, BytewiseRead) {
+  std::string text =
+      "v nedrah tundry vydra v getrah tyrit v vedrah yadra kedra";
+  size_t text_len = text.size();
+  size_t archive_len = ZLib::MinCompressbufSize(text_len);
+  std::string archive(archive_len, '\0');
+  size_t decompressed_len = text_len + 1;
+  std::string decompressed(decompressed_len, '\0');
+  size_t decompressed_offset = 0;
+
+  ZLib compressor;
+  compressor.SetGzipHeaderMode();
+  int rc = compressor.Compress((Bytef*)archive.data(), &archive_len,
+                               (Bytef*)text.data(), text_len);
+  ASSERT_EQ(rc, Z_OK);
+
+  ZLib zlib;
+  zlib.SetGzipHeaderMode();
+  for (size_t i = 0; i < archive_len; ++i) {
+    size_t source_len = 1;
+    size_t dest_len = decompressed_len - decompressed_offset;
+    rc = zlib.UncompressAtMost(
+        (Bytef*)decompressed.data() + decompressed_offset, &dest_len,
+        (Bytef*)archive.data() + i, &source_len);
+    ASSERT_EQ(rc, Z_OK);
+    ASSERT_EQ(source_len, 0);
+    decompressed_offset += dest_len;
+  }
+
+  ASSERT_TRUE(zlib.IsGzipFooterValid());
+  ASSERT_EQ(decompressed_offset, text_len);
+
+  std::string truncated_output(decompressed.data(), text_len);
+  ASSERT_EQ(truncated_output, text);
+
+  // if we haven't segfaulted by now, we pass
+  LOG(INFO) << "passed bytewise-read test";
+}
+
+TEST(ZLibWrapperStandaloneTest, TruncatedData) {
+  const int kBufferLen = 64;
+  std::string uncompressed = "Hello, World!";
+  std::string compressed(
+      "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\xf3\x48\xcd\xc9\xc9"
+      "\xd7\x51\x08\xcf\x2f\xca\x49\x51\x04\x00\xd0\xc3\x4a\xec\x0d"
+      "\x00\x00\x00",
+      33);
+
+  // Verify that "compressed" contains valid gzip data.
+  {
+    ZLib zlib;
+    zlib.SetGzipHeaderMode();
+    char uncompbuf[kBufferLen];
+    bzero(uncompbuf, kBufferLen);
+    uLongf uncomplen = kBufferLen;
+    int err = zlib.Uncompress(
+        reinterpret_cast<Bytef*>(uncompbuf), &uncomplen,
+        reinterpret_cast<const Bytef*>(compressed.c_str()), compressed.size());
+    ASSERT_EQ(err, Z_OK);
+    ASSERT_EQ(uncompressed, std::string_view(uncompbuf, uncomplen));
+  }
+
+  // Test truncated data with ZLib::Uncompress().
+  for (int len = compressed.size() - 1; len > 0; len--) {
+    SCOPED_TRACE(absl::StrCat("Decompressing first ", len, " out of ",
+                              compressed.size(), " bytes"));
+    ZLib zlib;
+    zlib.SetGzipHeaderMode();
+    char uncompbuf[kBufferLen];
+    bzero(uncompbuf, kBufferLen);
+    uLongf uncomplen = kBufferLen;
+    int err = zlib.Uncompress(
+        reinterpret_cast<Bytef*>(uncompbuf), &uncomplen,
+        reinterpret_cast<const Bytef*>(compressed.c_str()), len);
+    ASSERT_NE(err, Z_OK);
+  }
+
+  // Test truncated data with ZLib::UncompressAtMost() and
+  // ZLib::UncompressDone().
+  for (int len = compressed.size() - 1; len > 0; len--) {
+    SCOPED_TRACE(absl::StrCat("Decompressing first ", len, " out of ",
+                              compressed.size(), " bytes"));
+    ZLib zlib;
+    zlib.SetGzipHeaderMode();
+    char uncompbuf[kBufferLen];
+    bzero(uncompbuf, kBufferLen);
+    uLongf uncomplen = kBufferLen;
+    uLongf complen = len;
+    int err = zlib.UncompressAtMost(
+        reinterpret_cast<Bytef*>(uncompbuf), &uncomplen,
+        reinterpret_cast<const Bytef*>(compressed.c_str()), &complen);
+    ASSERT_EQ(err, Z_OK);
+    ASSERT_EQ(complen, 0);
+    if (uncomplen > 0) {
+      EXPECT_THAT(uncompressed,
+                  testing::StartsWith(absl::string_view(uncompbuf, uncomplen)));
+    }
+    ASSERT_FALSE(zlib.UncompressChunkDone());
+  }
+}
+
+TEST(ZLibWrapperStandalone, GzipUncompressedLength) {
+  ZLib zlib;
+
+  // "Hello, World!", compressed.
+  std::string hello_world(
+      "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\xf3\x48\xcd\xc9\xc9"
+      "\xd7\x51\x08\xcf\x2f\xca\x49\x51\x04\x00\xd0\xc3\x4a\xec\x0d"
+      "\x00\x00\x00",
+      33);
+  EXPECT_EQ(13, zlib.GzipUncompressedLength(
+                    reinterpret_cast<const Bytef*>(hello_world.c_str()),
+                    hello_world.size()));
+
+  // Empty string, "", compressed.
+  std::string empty(
+      "\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\x03\x03\x00\x00\x00\x00"
+      "\x00\x00\x00\x00\x00",
+      20);
+  EXPECT_EQ(0,
+            zlib.GzipUncompressedLength(
+                reinterpret_cast<const Bytef*>(empty.c_str()), empty.size()));
+
+  std::string bad_data("\x01\x01\x01\x01", 4);
+  for (int len = 0; len <= bad_data.size(); len++) {
+    EXPECT_EQ(0, zlib.GzipUncompressedLength(
+                     reinterpret_cast<const Bytef*>(bad_data.c_str()), len));
+  }
+}
+
 }  // namespace
 }  // namespace firebase

app/rest/tests/zlibwrapper_unittest.cc

@@ -312,12 +312,12 @@ CurlThread* g_curl_thread = nullptr;
 int g_initialize_count = 0;
 
 // Mutex for Curl initialization.
-Mutex g_initialize_mutex;  // NOLINT
+Mutex* g_initialize_mutex = new Mutex();
 
 }  // namespace
 
 void InitTransportCurl() {
-  MutexLock lock(g_initialize_mutex);
+  MutexLock lock(*g_initialize_mutex);
   if (g_initialize_count == 0) {
     // Initialize curl.
     CURLcode global_init_code = curl_global_init(CURL_GLOBAL_ALL);
@@ -333,7 +333,7 @@ void InitTransportCurl() {
 }
 
 void CleanupTransportCurl() {
-  MutexLock lock(g_initialize_mutex);
+  MutexLock lock(*g_initialize_mutex);
   assert(g_initialize_count > 0);
   g_initialize_count--;
   if (g_initialize_count == 0) {

app/rest/transport_curl.cc

@@ -45,23 +45,23 @@ const char kGet[] = "GET";
 const char kPost[] = "POST";
 
 // Mutex for utils initialization and distribution of CURL pointers.
-static ::firebase::Mutex g_util_curl_mutex;  // NOLINT
+static ::firebase::Mutex* g_util_curl_mutex = new Mutex();
 
 CURL* g_curl_instance = nullptr;
 int g_init_ref_count = 0;
 
 void* CreateCurlPtr() {  // NOLINT
-  MutexLock lock(g_util_curl_mutex);
+  MutexLock lock(*g_util_curl_mutex);
   return curl_easy_init();
 }
 
 void DestroyCurlPtr(void* curl_ptr) {
-  MutexLock lock(g_util_curl_mutex);
+  MutexLock lock(*g_util_curl_mutex);
   curl_easy_cleanup(static_cast<CURL*>(curl_ptr));
 }
 
 void Initialize() {
-  MutexLock curl_lock(g_util_curl_mutex);
+  MutexLock curl_lock(*g_util_curl_mutex);
   assert(g_init_ref_count >= 0);
   if (g_init_ref_count == 0) {
     g_curl_instance = reinterpret_cast<CURL*>(CreateCurlPtr());
@@ -70,7 +70,7 @@ void Initialize() {
 }
 
 void Terminate() {
-  MutexLock curl_lock(g_util_curl_mutex);
+  MutexLock curl_lock(*g_util_curl_mutex);
   --g_init_ref_count;
   assert(g_init_ref_count >= 0);
   if (g_init_ref_count == 0) {

app/rest/util.cc

@@ -703,7 +703,9 @@ int ZLib::UncompressChunk(Bytef* dest, uLongf* destLen, const Bytef* source,
 // mode, we also check the gzip footer to make sure we pass the gzip
 // consistency checks.  We RETURN true iff both types of checks pass.
 bool ZLib::UncompressChunkDone() {
-  assert(!first_chunk_ && uncomp_init_);
+  if (first_chunk_ || !uncomp_init_) {
+    return false;
+  }
   // Make sure we're at the end-of-compressed-data point.  This means
   // if we call inflate with Z_FINISH we won't consume any input or
   // write any output
@@ -784,7 +786,8 @@ int ZLib::Uncompress(Bytef* dest, uLongf* destLen, const Bytef* source,
 
 // read uncompress length from gzip footer
 uLongf ZLib::GzipUncompressedLength(const Bytef* source, uLong len) {
-  assert(len > 4);
+  if (len <= 4) return 0;  // malformed data.
+
   return (static_cast<uLongf>(source[len - 1]) << 24) +
          (static_cast<uLongf>(source[len - 2]) << 16) +
          (static_cast<uLongf>(source[len - 3]) << 8) +

app/rest/zlibwrapper.cc

@@ -126,7 +126,8 @@ class ZLib {
   int Uncompress(Bytef* dest, uLongf* destLen, const Bytef* source,
                  uLong sourceLen);
 
-  // Get the uncompressed size from the gzip header.
+  // Get the uncompressed size from the gzip header. Returns 0 if source is too
+  // short (len < 5).
   uLongf GzipUncompressedLength(const Bytef* source, uLong len);
 
   // Special helper function to help uncompress gzipped documents: