grpc 1.50.0 → 1.51.0

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_privacy_integrity_record_protocol.cc

@@ -23,6 +23,7 @@
 #include <grpc/support/alloc.h>
 #include <grpc/support/log.h>
 
+#include "src/core/lib/slice/slice.h"
 #include "src/core/lib/slice/slice_internal.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.h"
 #include "src/core/tsi/alts/zero_copy_frame_protector/alts_iovec_record_protocol.h"
@@ -61,11 +62,11 @@ static tsi_result alts_grpc_privacy_integrity_protect(
   if (status != GRPC_STATUS_OK) {
     gpr_log(GPR_ERROR, "Failed to protect, %s", error_details);
     gpr_free(error_details);
-    grpc_slice_unref_internal(protected_slice);
+    grpc_core::CSliceUnref(protected_slice);
     return TSI_INTERNAL_ERROR;
   }
   grpc_slice_buffer_add(protected_slices, protected_slice);
-  grpc_slice_buffer_reset_and_unref_internal(unprotected_slices);
+  grpc_slice_buffer_reset_and_unref(unprotected_slices);
   return TSI_OK;
 }
 
@@ -92,7 +93,7 @@ static tsi_result alts_grpc_privacy_integrity_unprotect(
   iovec_t unprotected_iovec = {GRPC_SLICE_START_PTR(unprotected_slice),
                                GRPC_SLICE_LENGTH(unprotected_slice)};
   /* Strips frame header from protected slices.  */
-  grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
+  grpc_slice_buffer_reset_and_unref(&rp->header_sb);
   grpc_slice_buffer_move_first(protected_slices, rp->header_length,
                                &rp->header_sb);
   iovec_t header_iovec = alts_grpc_record_protocol_get_header_iovec(rp);
@@ -106,11 +107,11 @@ static tsi_result alts_grpc_privacy_integrity_unprotect(
   if (status != GRPC_STATUS_OK) {
     gpr_log(GPR_ERROR, "Failed to unprotect, %s", error_details);
     gpr_free(error_details);
-    grpc_slice_unref_internal(unprotected_slice);
+    grpc_core::CSliceUnref(unprotected_slice);
     return TSI_INTERNAL_ERROR;
   }
-  grpc_slice_buffer_reset_and_unref_internal(&rp->header_sb);
-  grpc_slice_buffer_reset_and_unref_internal(protected_slices);
+  grpc_slice_buffer_reset_and_unref(&rp->header_sb);
+  grpc_slice_buffer_reset_and_unref(protected_slices);
   grpc_slice_buffer_add(unprotected_slices, unprotected_slice);
   return TSI_OK;
 }

data/src/core/tsi/alts/zero_copy_frame_protector/alts_grpc_record_protocol_common.cc

@@ -156,7 +156,7 @@ void alts_grpc_record_protocol_destroy(alts_grpc_record_protocol* self) {
     self->vtable->destruct(self);
   }
   alts_iovec_record_protocol_destroy(self->iovec_rp);
-  grpc_slice_buffer_destroy_internal(&self->header_sb);
+  grpc_slice_buffer_destroy(&self->header_sb);
   gpr_free(self->header_buf);
   gpr_free(self->iovec_buf);
   gpr_free(self);

data/src/core/tsi/alts/zero_copy_frame_protector/alts_zero_copy_grpc_protector.cc

@@ -190,7 +190,7 @@ static tsi_result alts_zero_copy_grpc_protector_unprotect(
       /* We have not parsed frame size yet. Parses frame size.  */
       if (!read_frame_size(&protector->protected_sb,
                            &protector->parsed_frame_size)) {
-        grpc_slice_buffer_reset_and_unref_internal(&protector->protected_sb);
+        grpc_slice_buffer_reset_and_unref(&protector->protected_sb);
         return TSI_DATA_CORRUPTED;
       }
     }
@@ -211,7 +211,7 @@ static tsi_result alts_zero_copy_grpc_protector_unprotect(
     }
     protector->parsed_frame_size = 0;
     if (status != TSI_OK) {
-      grpc_slice_buffer_reset_and_unref_internal(&protector->protected_sb);
+      grpc_slice_buffer_reset_and_unref(&protector->protected_sb);
       return status;
     }
   }
@@ -235,9 +235,9 @@ static void alts_zero_copy_grpc_protector_destroy(
       reinterpret_cast<alts_zero_copy_grpc_protector*>(self);
   alts_grpc_record_protocol_destroy(protector->record_protocol);
   alts_grpc_record_protocol_destroy(protector->unrecord_protocol);
-  grpc_slice_buffer_destroy_internal(&protector->unprotected_staging_sb);
-  grpc_slice_buffer_destroy_internal(&protector->protected_sb);
-  grpc_slice_buffer_destroy_internal(&protector->protected_staging_sb);
+  grpc_slice_buffer_destroy(&protector->unprotected_staging_sb);
+  grpc_slice_buffer_destroy(&protector->protected_sb);
+  grpc_slice_buffer_destroy(&protector->protected_staging_sb);
   gpr_free(protector);
 }
 

data/src/core/tsi/fake_transport_security.cc

@@ -481,7 +481,7 @@ static tsi_result fake_zero_copy_grpc_protector_unprotect(
         impl->parsed_frame_size - TSI_FAKE_FRAME_HEADER_SIZE,
         unprotected_slices);
     impl->parsed_frame_size = 0;
-    grpc_slice_buffer_reset_and_unref_internal(&impl->header_sb);
+    grpc_slice_buffer_reset_and_unref(&impl->header_sb);
   }
   if (min_progress_size != nullptr) {
     if (impl->parsed_frame_size > TSI_FAKE_FRAME_HEADER_SIZE) {
@@ -498,8 +498,8 @@ static void fake_zero_copy_grpc_protector_destroy(
   if (self == nullptr) return;
   tsi_fake_zero_copy_grpc_protector* impl =
       reinterpret_cast<tsi_fake_zero_copy_grpc_protector*>(self);
-  grpc_slice_buffer_destroy_internal(&impl->header_sb);
-  grpc_slice_buffer_destroy_internal(&impl->protected_sb);
+  grpc_slice_buffer_destroy(&impl->header_sb);
+  grpc_slice_buffer_destroy(&impl->protected_sb);
   gpr_free(impl);
 }
 

data/src/core/tsi/ssl/key_logging/ssl_key_logging.cc

@@ -55,7 +55,7 @@ TlsSessionKeyLoggerCache::TlsSessionKeyLogger::TlsSessionKeyLogger(
     gpr_log(GPR_ERROR,
             "Ignoring TLS Key logging. ERROR Opening TLS Keylog "
             "file: %s",
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
   }
   cache_->tls_session_key_logger_map_.emplace(tls_session_key_log_file_path_,
                                               this);
@@ -88,7 +88,7 @@ void TlsSessionKeyLoggerCache::TlsSessionKeyLogger::LogSessionKeys(
   if (err) {
     grpc_error_handle error = GRPC_OS_ERROR(errno, "fwrite");
     gpr_log(GPR_ERROR, "Error Appending to TLS session key log file: %s",
-            grpc_error_std_string(error).c_str());
+            grpc_core::StatusToString(error).c_str());
     fclose(fd_);
     fd_ = nullptr;  // disable future attempts to write to this file
   } else {
@@ -118,7 +118,11 @@ grpc_core::RefCountedPtr<TlsSessionKeyLogger> TlsSessionKeyLoggerCache::Get(
     grpc_core::RefCountedPtr<TlsSessionKeyLoggerCache> cache;
     if (g_cache_instance == nullptr) {
       // This will automatically set g_cache_instance.
-      cache = grpc_core::MakeRefCounted<TlsSessionKeyLoggerCache>();
+      // Not using MakeRefCounted because to the thread safety analysis, which
+      // cannot see through calls, it would look like MakeRefCounted was
+      // calling TlsSessionKeyLoggerCache without holding a lock on
+      // g_tls_session_key_log_cache_mu.
+      cache.reset(new TlsSessionKeyLoggerCache());
     } else {
       cache = g_cache_instance->Ref();
     }

data/src/core/tsi/ssl/session_cache/ssl_session_boringssl.cc

@@ -51,7 +51,7 @@ class BoringSslCachedSession : public SslCachedSession {
 
 std::unique_ptr<SslCachedSession> SslCachedSession::Create(
     SslSessionPtr session) {
-  return absl::make_unique<BoringSslCachedSession>(std::move(session));
+  return std::make_unique<BoringSslCachedSession>(std::move(session));
 }
 
 }  // namespace tsi

data/src/core/tsi/ssl/session_cache/ssl_session_openssl.cc

@@ -26,6 +26,8 @@
 
 #include "absl/memory/memory.h"
 
+#include "src/core/lib/slice/slice.h"
+
 // OpenSSL invalidates SSL_SESSION on SSL destruction making it pointless
 // to cache sessions. The workaround is to serialize (relatively expensive)
 // session into binary blob and re-create it from blob on every handshake.
@@ -49,7 +51,9 @@ class OpenSslCachedSession : public SslCachedSession {
     serialized_session_ = slice;
   }
 
-  virtual ~OpenSslCachedSession() { grpc_slice_unref(serialized_session_); }
+  virtual ~OpenSslCachedSession() {
+    grpc_core::CSliceUnref(serialized_session_);
+  }
 
   SslSessionPtr CopySession() const override {
     const unsigned char* data = GRPC_SLICE_START_PTR(serialized_session_);
@@ -69,7 +73,7 @@ class OpenSslCachedSession : public SslCachedSession {
 
 std::unique_ptr<SslCachedSession> SslCachedSession::Create(
     SslSessionPtr session) {
-  return absl::make_unique<OpenSslCachedSession>(std::move(session));
+  return std::make_unique<OpenSslCachedSession>(std::move(session));
 }
 
 }  // namespace tsi

data/src/ruby/ext/grpc/rb_grpc_imports.generated.c

@@ -35,7 +35,6 @@ grpc_metadata_array_init_type grpc_metadata_array_init_import;
 grpc_metadata_array_destroy_type grpc_metadata_array_destroy_import;
 grpc_call_details_init_type grpc_call_details_init_import;
 grpc_call_details_destroy_type grpc_call_details_destroy_import;
-grpc_register_plugin_type grpc_register_plugin_import;
 grpc_init_type grpc_init_import;
 grpc_shutdown_type grpc_shutdown_import;
 grpc_is_initialized_type grpc_is_initialized_import;
@@ -321,7 +320,6 @@ void grpc_rb_load_imports(HMODULE library) {
   grpc_metadata_array_destroy_import = (grpc_metadata_array_destroy_type) GetProcAddress(library, "grpc_metadata_array_destroy");
   grpc_call_details_init_import = (grpc_call_details_init_type) GetProcAddress(library, "grpc_call_details_init");
   grpc_call_details_destroy_import = (grpc_call_details_destroy_type) GetProcAddress(library, "grpc_call_details_destroy");
-  grpc_register_plugin_import = (grpc_register_plugin_type) GetProcAddress(library, "grpc_register_plugin");
   grpc_init_import = (grpc_init_type) GetProcAddress(library, "grpc_init");
   grpc_shutdown_import = (grpc_shutdown_type) GetProcAddress(library, "grpc_shutdown");
   grpc_is_initialized_import = (grpc_is_initialized_type) GetProcAddress(library, "grpc_is_initialized");

data/src/ruby/ext/grpc/rb_grpc_imports.generated.h

@@ -80,9 +80,6 @@ extern grpc_call_details_init_type grpc_call_details_init_import;
 typedef void(*grpc_call_details_destroy_type)(grpc_call_details* details);
 extern grpc_call_details_destroy_type grpc_call_details_destroy_import;
 #define grpc_call_details_destroy grpc_call_details_destroy_import
-typedef void(*grpc_register_plugin_type)(void (*init)(void), void (*destroy)(void));
-extern grpc_register_plugin_type grpc_register_plugin_import;
-#define grpc_register_plugin grpc_register_plugin_import
 typedef void(*grpc_init_type)(void);
 extern grpc_init_type grpc_init_import;
 #define grpc_init grpc_init_import

data/src/ruby/lib/grpc/version.rb

@@ -14,5 +14,5 @@
 
 # GRPC contains the General RPC module.
 module GRPC
-  VERSION = '1.50.0'
+  VERSION = '1.51.0'
 end

data/src/ruby/spec/channel_spec.rb

@@ -28,28 +28,6 @@ describe GRPC::Core::Channel do
     GRPC::Core::ChannelCredentials.new(load_test_certs[0])
   end
 
-  def fork_with_propagated_error_message
-    pipe_read, pipe_write = IO.pipe
-    pid = fork do
-      pipe_read.close
-      begin
-        yield
-      rescue => exc
-        pipe_write.syswrite(exc.message)
-      end
-      pipe_write.close
-    end
-    pipe_write.close
-
-    exc_message = pipe_read.read
-    Process.wait(pid)
-
-    unless $CHILD_STATUS.success?
-      raise "forked process failed with #{$CHILD_STATUS}"
-    end
-    raise exc_message unless exc_message.empty?
-  end
-
   shared_examples '#new' do
     it 'take a host name without channel args' do
       blk = proc do
@@ -102,14 +80,6 @@ describe GRPC::Core::Channel do
       blk = construct_with_args(args)
       expect(&blk).to_not raise_error
     end
-
-    it 'raises if grpc was initialized in another process' do
-      blk = construct_with_args({})
-      expect(&blk).not_to raise_error
-      expect do
-        fork_with_propagated_error_message(&blk)
-      end.to raise_error(RuntimeError, 'grpc cannot be used before and after forking')
-    end
   end
 
   describe '#new for secure channels' do
@@ -168,19 +138,6 @@ describe GRPC::Core::Channel do
       expect(&blk).to raise_error(RuntimeError)
       STDERR.puts "#{Time.now}: finished: raises an error if called on a closed channel"
     end
-
-    it 'raises if grpc was initialized in another process' do
-      ch = GRPC::Core::Channel.new(fake_host, nil, :this_channel_is_insecure)
-
-      deadline = Time.now + 5
-
-      blk = proc do
-        fork_with_propagated_error_message do
-          ch.create_call(nil, nil, 'phony_method', nil, deadline)
-        end
-      end
-      expect(&blk).to raise_error(RuntimeError, 'grpc cannot be used before and after forking')
-    end
   end
 
   describe '#destroy' do

data/src/ruby/spec/generic/active_call_spec.rb

@@ -65,12 +65,21 @@ describe GRPC::ActiveCall do
 
   describe 'restricted view methods' do
     before(:each) do
-      call = make_test_call
-      ActiveCall.client_invoke(call)
-      @client_call = ActiveCall.new(call, @pass_through,
+      @call = make_test_call
+      ActiveCall.client_invoke(@call)
+      @client_call = ActiveCall.new(@call, @pass_through,
                                     @pass_through, deadline)
     end
 
+    after(:each) do
+      # terminate the RPC that was started in before(:each)
+      recvd_rpc = @received_rpcs_queue.pop
+      recvd_call = recvd_rpc.call
+      recvd_call.run_batch(CallOps::SEND_INITIAL_METADATA => nil)
+      @call.run_batch(CallOps::RECV_INITIAL_METADATA => nil)
+      send_and_receive_close_and_status(@call, recvd_call)
+    end
+
     describe '#multi_req_view' do
       it 'exposes a fixed subset of the ActiveCall.methods' do
         want = %w(cancelled?, deadline, each_remote_read, metadata, \

data/third_party/abseil-cpp/absl/cleanup/cleanup.h

@@ -0,0 +1,140 @@
+// Copyright 2021 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+//
+// -----------------------------------------------------------------------------
+// File: cleanup.h
+// -----------------------------------------------------------------------------
+//
+// `absl::Cleanup` implements the scope guard idiom, invoking the contained
+// callback's `operator()() &&` on scope exit.
+//
+// Example:
+//
+// ```
+//   absl::Status CopyGoodData(const char* source_path, const char* sink_path) {
+//     FILE* source_file = fopen(source_path, "r");
+//     if (source_file == nullptr) {
+//       return absl::NotFoundError("No source file");  // No cleanups execute
+//     }
+//
+//     // C++17 style cleanup using class template argument deduction
+//     absl::Cleanup source_closer = [source_file] { fclose(source_file); };
+//
+//     FILE* sink_file = fopen(sink_path, "w");
+//     if (sink_file == nullptr) {
+//       return absl::NotFoundError("No sink file");  // First cleanup executes
+//     }
+//
+//     // C++11 style cleanup using the factory function
+//     auto sink_closer = absl::MakeCleanup([sink_file] { fclose(sink_file); });
+//
+//     Data data;
+//     while (ReadData(source_file, &data)) {
+//       if (!data.IsGood()) {
+//         absl::Status result = absl::FailedPreconditionError("Read bad data");
+//         return result;  // Both cleanups execute
+//       }
+//       SaveData(sink_file, &data);
+//     }
+//
+//     return absl::OkStatus();  // Both cleanups execute
+//   }
+// ```
+//
+// Methods:
+//
+// `std::move(cleanup).Cancel()` will prevent the callback from executing.
+//
+// `std::move(cleanup).Invoke()` will execute the callback early, before
+// destruction, and prevent the callback from executing in the destructor.
+//
+// Usage:
+//
+// `absl::Cleanup` is not an interface type. It is only intended to be used
+// within the body of a function. It is not a value type and instead models a
+// control flow construct. Check out `defer` in Golang for something similar.
+
+#ifndef ABSL_CLEANUP_CLEANUP_H_
+#define ABSL_CLEANUP_CLEANUP_H_
+
+#include <utility>
+
+#include "absl/base/config.h"
+#include "absl/base/macros.h"
+#include "absl/cleanup/internal/cleanup.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+template <typename Arg, typename Callback = void()>
+class ABSL_MUST_USE_RESULT Cleanup final {
+  static_assert(cleanup_internal::WasDeduced<Arg>(),
+                "Explicit template parameters are not supported.");
+
+  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
+                "Callbacks that return values are not supported.");
+
+ public:
+  Cleanup(Callback callback) : storage_(std::move(callback)) {}  // NOLINT
+
+  Cleanup(Cleanup&& other) = default;
+
+  void Cancel() && {
+    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+    storage_.DestroyCallback();
+  }
+
+  void Invoke() && {
+    ABSL_HARDENING_ASSERT(storage_.IsCallbackEngaged());
+    storage_.InvokeCallback();
+    storage_.DestroyCallback();
+  }
+
+  ~Cleanup() {
+    if (storage_.IsCallbackEngaged()) {
+      storage_.InvokeCallback();
+      storage_.DestroyCallback();
+    }
+  }
+
+ private:
+  cleanup_internal::Storage<Callback> storage_;
+};
+
+// `absl::Cleanup c = /* callback */;`
+//
+// C++17 type deduction API for creating an instance of `absl::Cleanup`
+#if defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
+template <typename Callback>
+Cleanup(Callback callback) -> Cleanup<cleanup_internal::Tag, Callback>;
+#endif  // defined(ABSL_HAVE_CLASS_TEMPLATE_ARGUMENT_DEDUCTION)
+
+// `auto c = absl::MakeCleanup(/* callback */);`
+//
+// C++11 type deduction API for creating an instance of `absl::Cleanup`
+template <typename... Args, typename Callback>
+absl::Cleanup<cleanup_internal::Tag, Callback> MakeCleanup(Callback callback) {
+  static_assert(cleanup_internal::WasDeduced<cleanup_internal::Tag, Args...>(),
+                "Explicit template parameters are not supported.");
+
+  static_assert(cleanup_internal::ReturnsVoid<Callback>(),
+                "Callbacks that return values are not supported.");
+
+  return {std::move(callback)};
+}
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CLEANUP_CLEANUP_H_

data/third_party/abseil-cpp/absl/cleanup/internal/cleanup.h

@@ -0,0 +1,100 @@
+// Copyright 2021 The Abseil Authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//      https://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+#ifndef ABSL_CLEANUP_INTERNAL_CLEANUP_H_
+#define ABSL_CLEANUP_INTERNAL_CLEANUP_H_
+
+#include <new>
+#include <type_traits>
+#include <utility>
+
+#include "absl/base/internal/invoke.h"
+#include "absl/base/macros.h"
+#include "absl/base/thread_annotations.h"
+#include "absl/utility/utility.h"
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+
+namespace cleanup_internal {
+
+struct Tag {};
+
+template <typename Arg, typename... Args>
+constexpr bool WasDeduced() {
+  return (std::is_same<cleanup_internal::Tag, Arg>::value) &&
+         (sizeof...(Args) == 0);
+}
+
+template <typename Callback>
+constexpr bool ReturnsVoid() {
+  return (std::is_same<base_internal::invoke_result_t<Callback>, void>::value);
+}
+
+template <typename Callback>
+class Storage {
+ public:
+  Storage() = delete;
+
+  explicit Storage(Callback callback) {
+    // Placement-new into a character buffer is used for eager destruction when
+    // the cleanup is invoked or cancelled. To ensure this optimizes well, the
+    // behavior is implemented locally instead of using an absl::optional.
+    ::new (GetCallbackBuffer()) Callback(std::move(callback));
+    is_callback_engaged_ = true;
+  }
+
+  Storage(Storage&& other) {
+    ABSL_HARDENING_ASSERT(other.IsCallbackEngaged());
+
+    ::new (GetCallbackBuffer()) Callback(std::move(other.GetCallback()));
+    is_callback_engaged_ = true;
+
+    other.DestroyCallback();
+  }
+
+  Storage(const Storage& other) = delete;
+
+  Storage& operator=(Storage&& other) = delete;
+
+  Storage& operator=(const Storage& other) = delete;
+
+  void* GetCallbackBuffer() { return static_cast<void*>(+callback_buffer_); }
+
+  Callback& GetCallback() {
+    return *reinterpret_cast<Callback*>(GetCallbackBuffer());
+  }
+
+  bool IsCallbackEngaged() const { return is_callback_engaged_; }
+
+  void DestroyCallback() {
+    is_callback_engaged_ = false;
+    GetCallback().~Callback();
+  }
+
+  void InvokeCallback() ABSL_NO_THREAD_SAFETY_ANALYSIS {
+    std::move(GetCallback())();
+  }
+
+ private:
+  bool is_callback_engaged_;
+  alignas(Callback) char callback_buffer_[sizeof(Callback)];
+};
+
+}  // namespace cleanup_internal
+
+ABSL_NAMESPACE_END
+}  // namespace absl
+
+#endif  // ABSL_CLEANUP_INTERNAL_CLEANUP_H_

data/third_party/zlib/compress.c

@@ -19,7 +19,7 @@
    memory, Z_BUF_ERROR if there was not enough room in the output buffer,
    Z_STREAM_ERROR if the level parameter is invalid.
 */
-int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
+int ZEXPORT compress2(dest, destLen, source, sourceLen, level)
     Bytef *dest;
     uLongf *destLen;
     const Bytef *source;
@@ -65,7 +65,7 @@ int ZEXPORT compress2 (dest, destLen, source, sourceLen, level)
 
 /* ===========================================================================
  */
-int ZEXPORT compress (dest, destLen, source, sourceLen)
+int ZEXPORT compress(dest, destLen, source, sourceLen)
     Bytef *dest;
     uLongf *destLen;
     const Bytef *source;
@@ -78,7 +78,7 @@ int ZEXPORT compress (dest, destLen, source, sourceLen)
      If the default memLevel or windowBits for deflateInit() is changed, then
    this function needs to be updated.
  */
-uLong ZEXPORT compressBound (sourceLen)
+uLong ZEXPORT compressBound(sourceLen)
     uLong sourceLen;
 {
     return sourceLen + (sourceLen >> 12) + (sourceLen >> 14) +

data/third_party/zlib/crc32.c

@@ -98,13 +98,22 @@
 #  endif
 #endif
 
+/* If available, use the ARM processor CRC32 instruction. */
+#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) && W == 8
+#  define ARMCRC32
+#endif
+
 /* Local functions. */
 local z_crc_t multmodp OF((z_crc_t a, z_crc_t b));
 local z_crc_t x2nmodp OF((z_off64_t n, unsigned k));
 
-/* If available, use the ARM processor CRC32 instruction. */
-#if defined(__aarch64__) && defined(__ARM_FEATURE_CRC32) && W == 8
-#  define ARMCRC32
+#if defined(W) && (!defined(ARMCRC32) || defined(DYNAMIC_CRC_TABLE))
+    local z_word_t byte_swap OF((z_word_t word));
+#endif
+
+#if defined(W) && !defined(ARMCRC32)
+    local z_crc_t crc_word OF((z_word_t data));
+    local z_word_t crc_word_big OF((z_word_t data));
 #endif
 
 #if defined(W) && (!defined(ARMCRC32) || defined(DYNAMIC_CRC_TABLE))
@@ -630,7 +639,7 @@ unsigned long ZEXPORT crc32_z(crc, buf, len)
 #endif /* DYNAMIC_CRC_TABLE */
 
     /* Pre-condition the CRC */
-    crc ^= 0xffffffff;
+    crc = (~crc) & 0xffffffff;
 
     /* Compute the CRC up to a word boundary. */
     while (len && ((z_size_t)buf & 7) != 0) {
@@ -645,8 +654,8 @@ unsigned long ZEXPORT crc32_z(crc, buf, len)
     len &= 7;
 
     /* Do three interleaved CRCs to realize the throughput of one crc32x
-       instruction per cycle. Each CRC is calcuated on Z_BATCH words. The three
-       CRCs are combined into a single CRC after each set of batches. */
+       instruction per cycle. Each CRC is calculated on Z_BATCH words. The
+       three CRCs are combined into a single CRC after each set of batches. */
     while (num >= 3 * Z_BATCH) {
         crc1 = 0;
         crc2 = 0;
@@ -749,7 +758,7 @@ unsigned long ZEXPORT crc32_z(crc, buf, len)
 #endif /* DYNAMIC_CRC_TABLE */
 
     /* Pre-condition the CRC */
-    crc ^= 0xffffffff;
+    crc = (~crc) & 0xffffffff;
 
 #ifdef W
 
@@ -1077,7 +1086,7 @@ uLong ZEXPORT crc32_combine64(crc1, crc2, len2)
 #ifdef DYNAMIC_CRC_TABLE
     once(&made, make_crc_table);
 #endif /* DYNAMIC_CRC_TABLE */
-    return multmodp(x2nmodp(len2, 3), crc1) ^ crc2;
+    return multmodp(x2nmodp(len2, 3), crc1) ^ (crc2 & 0xffffffff);
 }
 
 /* ========================================================================= */
@@ -1086,7 +1095,7 @@ uLong ZEXPORT crc32_combine(crc1, crc2, len2)
     uLong crc2;
     z_off_t len2;
 {
-    return crc32_combine64(crc1, crc2, len2);
+    return crc32_combine64(crc1, crc2, (z_off64_t)len2);
 }
 
 /* ========================================================================= */
@@ -1103,14 +1112,14 @@ uLong ZEXPORT crc32_combine_gen64(len2)
 uLong ZEXPORT crc32_combine_gen(len2)
     z_off_t len2;
 {
-    return crc32_combine_gen64(len2);
+    return crc32_combine_gen64((z_off64_t)len2);
 }
 
 /* ========================================================================= */
-uLong crc32_combine_op(crc1, crc2, op)
+uLong ZEXPORT crc32_combine_op(crc1, crc2, op)
     uLong crc1;
     uLong crc2;
     uLong op;
 {
-    return multmodp(op, crc1) ^ crc2;
+    return multmodp(op, crc1) ^ (crc2 & 0xffffffff);
 }