dynamic_modules: adds send response

source/extensions/dynamic_modules/BUILD

@@ -36,6 +36,7 @@ envoy_cc_library(
         "-Wl,--export-dynamic-symbol=envoy_dynamic_module_callback_http_get_response_trailers",
         "-Wl,--export-dynamic-symbol=envoy_dynamic_module_callback_http_get_response_trailers_count",
         "-Wl,--export-dynamic-symbol=envoy_dynamic_module_callback_http_set_response_trailer",
+        "-Wl,--export-dynamic-symbol=envoy_dynamic_module_callback_http_send_response",
     ],
     deps = [
         ":abi_version_lib",

source/extensions/dynamic_modules/abi.h

@@ -35,12 +35,15 @@
 #ifdef __cplusplus
 #include <cstdbool>
 #include <cstddef>
+#include <cstdint>
 
 extern "C" {
 #else
 
 #include <stdbool.h>
 #include <stddef.h>
+#include <stdint.h>
+
 #endif
 
 // -----------------------------------------------------------------------------
@@ -128,8 +131,19 @@ typedef char* envoy_dynamic_module_type_buffer_module_ptr;
 typedef char* envoy_dynamic_module_type_buffer_envoy_ptr;
 
 /**
- * envoy_dynamic_module_type_Header represents a key-value pair of an HTTP header owned by Envoy's
- * HeaderMap.
+ * envoy_dynamic_module_type_module_http_header represents a key-value pair of an HTTP header owned
+ * by the module.
+ */
+typedef struct {
+  envoy_dynamic_module_type_buffer_module_ptr key_ptr;
+  size_t key_length;
+  envoy_dynamic_module_type_buffer_module_ptr value_ptr;
+  size_t value_length;
+} envoy_dynamic_module_type_module_http_header;
+
+/**
+ * envoy_dynamic_module_type_http_header represents a key-value pair of an HTTP header owned by
+ * Envoy's HeaderMap.
  */
 typedef struct {
   envoy_dynamic_module_type_buffer_envoy_ptr key_ptr;
@@ -606,6 +620,24 @@ bool envoy_dynamic_module_callback_http_set_response_trailer(
     envoy_dynamic_module_type_buffer_module_ptr key, size_t key_length,
     envoy_dynamic_module_type_buffer_module_ptr value, size_t value_length);
 
+/**
+ * envoy_dynamic_module_callback_http_send_response is called by the module to send the response
+ * to the downstream.
+ *
+ * @param filter_envoy_ptr is the pointer to the DynamicModuleHttpFilter object of the
+ * corresponding HTTP filter.
+ * @param status_code is the status code of the response.
+ * @param headers_vector is the array of envoy_dynamic_module_type_module_http_header that contains
+ * the headers of the response.
+ * @param headers_vector_size is the size of the headers_vector.
+ * @param body is the pointer to the buffer of the body of the response.
+ * @param body_length is the length of the body.
+ */
+void envoy_dynamic_module_callback_http_send_response(
+    envoy_dynamic_module_type_http_filter_envoy_ptr filter_envoy_ptr, uint32_t status_code,
+    envoy_dynamic_module_type_module_http_header* headers_vector, size_t headers_vector_size,
+    envoy_dynamic_module_type_buffer_module_ptr body, size_t body_length);
+
 #ifdef __cplusplus
 }
 #endif

source/extensions/dynamic_modules/abi_version.h

@@ -6,7 +6,7 @@ namespace DynamicModules {
 #endif
 // This is the ABI version calculated as a sha256 hash of the ABI header files. When the ABI
 // changes, this value must change, and the correctness of this value is checked by the test.
-const char* kAbiVersion = "27dbe7918b67b12bfcf43e050ce142a300feb73fb3bd5779c754d1d1d3c8645f";
+const char* kAbiVersion = "5867e2259f40fd9e63a47a61e89ab7fe2e87d22e09aa5c8c198a5ec9105a9608";
 
 #ifdef __cplusplus
 } // namespace DynamicModules

source/extensions/dynamic_modules/sdk/rust/src/lib.rs

@@ -331,6 +331,17 @@ pub trait EnvoyHttpFilter {
   ///
   /// Returns true if the operation is successful.
   fn set_response_trailer(&mut self, key: &str, value: &[u8]) -> bool;
+
+  /// Send a response to the downstream with the given status code, headers, and body.
+  ///
+  /// The headers are passed as a list of key-value pairs.
+  #[allow(clippy::needless_lifetimes)] // Explicit lifetime specifiers are needed for mockall
+  fn send_response<'a, 'b, 'c>(
+    &mut self,
+    status_code: u32,
+    headers: Vec<(&'a str, &'b [u8])>,
+    body: Option<&'c [u8]>,
+  );
 }
 
 /// This implements the [`EnvoyHttpFilter`] trait with the given raw pointer to the Envoy HTTP
@@ -453,7 +464,6 @@ impl EnvoyHttpFilter for EnvoyHttpFilterImpl {
     }
   }
 
-
   fn get_response_trailer_value(&self, key: &str) -> Option<EnvoyBuffer> {
     self.get_header_value_impl(
       key,
@@ -490,6 +500,24 @@ impl EnvoyHttpFilter for EnvoyHttpFilterImpl {
       )
     }
   }
+
+  fn send_response(&mut self, status_code: u32, headers: Vec<(&str, &[u8])>, body: Option<&[u8]>) {
+    let body_ptr = body.map(|s| s.as_ptr()).unwrap_or(std::ptr::null());
+    let body_length = body.map(|s| s.len()).unwrap_or(0);
+
+    let headers_ptr = headers.as_ptr() as *mut abi::envoy_dynamic_module_type_module_http_header;
+
+    unsafe {
+      abi::envoy_dynamic_module_callback_http_send_response(
+        self.raw_ptr,
+        status_code,
+        headers_ptr,
+        headers.len(),
+        body_ptr as *mut _,
+        body_length,
+      )
+    }
+  }
 }
 
 impl EnvoyHttpFilterImpl {

source/extensions/filters/http/dynamic_modules/abi_impl.cc

@@ -197,6 +197,31 @@ bool envoy_dynamic_module_callback_http_get_response_trailers(
   DynamicModuleHttpFilter* filter = static_cast<DynamicModuleHttpFilter*>(filter_envoy_ptr);
   return getHeadersImpl(filter->response_trailers_, result_headers);
 }
+
+void envoy_dynamic_module_callback_http_send_response(
+    envoy_dynamic_module_type_http_filter_envoy_ptr filter_envoy_ptr, uint32_t status_code,
+    envoy_dynamic_module_type_module_http_header* headers_vector, size_t headers_vector_size,
+    envoy_dynamic_module_type_buffer_module_ptr body_ptr, size_t body_length) {
+  DynamicModuleHttpFilter* filter = static_cast<DynamicModuleHttpFilter*>(filter_envoy_ptr);
+
+  std::function<void(ResponseHeaderMap & headers)> modify_headers = nullptr;
+  if (headers_vector != nullptr && headers_vector_size != 0) {
+    modify_headers = [headers_vector, headers_vector_size](ResponseHeaderMap& headers) {
+      for (size_t i = 0; i < headers_vector_size; i++) {
+        const auto& header = &headers_vector[i];
+        const absl::string_view key(static_cast<const char*>(header->key_ptr), header->key_length);
+        const absl::string_view value(static_cast<const char*>(header->value_ptr),
+                                      header->value_length);
+        headers.addCopy(Http::LowerCaseString(key), value);
+      }
+    };
+  }
+  const absl::string_view body =
+      body_ptr ? absl::string_view(static_cast<const char*>(body_ptr), body_length) : "";
+
+  filter->sendLocalReply(static_cast<Http::Code>(status_code), body, modify_headers, 0,
+                         "dynamic_module");
+}
 }
 } // namespace HttpFilters
 } // namespace DynamicModules

source/extensions/filters/http/dynamic_modules/filter.cc

@@ -1,7 +1,5 @@
 #include "source/extensions/filters/http/dynamic_modules/filter.h"
 
-#include "envoy/server/filter_config.h"
-
 namespace Envoy {
 namespace Extensions {
 namespace DynamicModules {
@@ -17,19 +15,31 @@ void DynamicModuleHttpFilter::onDestroy() { config_->on_http_filter_destroy_(in_
 
 FilterHeadersStatus DynamicModuleHttpFilter::decodeHeaders(RequestHeaderMap& headers,
                                                            bool end_of_stream) {
+  if (sent_local_reply_) {
+    return FilterHeadersStatus::Continue;
+  }
+
   request_headers_ = &headers;
   const envoy_dynamic_module_type_on_http_filter_request_headers_status status =
       config_->on_http_filter_request_headers_(thisAsVoidPtr(), in_module_filter_, end_of_stream);
   return static_cast<FilterHeadersStatus>(status);
 };
 
 FilterDataStatus DynamicModuleHttpFilter::decodeData(Buffer::Instance&, bool end_of_stream) {
+  if (sent_local_reply_) {
+    return FilterDataStatus::Continue;
+  }
+
   const envoy_dynamic_module_type_on_http_filter_request_body_status status =
       config_->on_http_filter_request_body_(thisAsVoidPtr(), in_module_filter_, end_of_stream);
   return static_cast<FilterDataStatus>(status);
 };
 
 FilterTrailersStatus DynamicModuleHttpFilter::decodeTrailers(RequestTrailerMap& trailers) {
+  if (sent_local_reply_) {
+    return FilterTrailersStatus::Continue;
+  }
+
   request_trailers_ = &trailers;
   const envoy_dynamic_module_type_on_http_filter_request_trailers_status status =
       config_->on_http_filter_request_trailers_(thisAsVoidPtr(), in_module_filter_);
@@ -48,19 +58,31 @@ Filter1xxHeadersStatus DynamicModuleHttpFilter::encode1xxHeaders(ResponseHeaderM
 
 FilterHeadersStatus DynamicModuleHttpFilter::encodeHeaders(ResponseHeaderMap& headers,
                                                            bool end_of_stream) {
+  if (sent_local_reply_) {
+    return FilterHeadersStatus::Continue;
+  }
+
   response_headers_ = &headers;
   const envoy_dynamic_module_type_on_http_filter_response_headers_status status =
       config_->on_http_filter_response_headers_(thisAsVoidPtr(), in_module_filter_, end_of_stream);
   return static_cast<FilterHeadersStatus>(status);
 };
 
 FilterDataStatus DynamicModuleHttpFilter::encodeData(Buffer::Instance&, bool end_of_stream) {
+  if (sent_local_reply_) {
+    return FilterDataStatus::Continue;
+  }
+
   const envoy_dynamic_module_type_on_http_filter_response_body_status status =
       config_->on_http_filter_response_body_(thisAsVoidPtr(), in_module_filter_, end_of_stream);
   return static_cast<FilterDataStatus>(status);
 };
 
 FilterTrailersStatus DynamicModuleHttpFilter::encodeTrailers(ResponseTrailerMap& trailers) {
+  if (sent_local_reply_) {
+    return FilterTrailersStatus::Continue;
+  }
+
   response_trailers_ = &trailers;
   const envoy_dynamic_module_type_on_http_filter_response_trailers_status status =
       config_->on_http_filter_response_trailers_(thisAsVoidPtr(), in_module_filter_);
@@ -71,6 +93,18 @@ FilterMetadataStatus DynamicModuleHttpFilter::encodeMetadata(MetadataMap&) {
   return FilterMetadataStatus::Continue;
 }
 
+void DynamicModuleHttpFilter::sendLocalReply(
+    Code code, absl::string_view body,
+    std::function<void(ResponseHeaderMap& headers)> modify_headers,
+    const absl::optional<Grpc::Status::GrpcStatus> grpc_status, absl::string_view details) {
+  if (sent_local_reply_) {
+    return;
+  }
+
+  sent_local_reply_ = true;
+  decoder_callbacks_->sendLocalReply(code, body, modify_headers, grpc_status, details);
+}
+
 void DynamicModuleHttpFilter::encodeComplete(){};
 
 } // namespace HttpFilters

source/extensions/filters/http/dynamic_modules/filter.h

@@ -50,6 +50,11 @@ class DynamicModuleHttpFilter : public Http::StreamFilter,
   }
   void encodeComplete() override;
 
+  void sendLocalReply(Code code, absl::string_view body,
+                      std::function<void(ResponseHeaderMap& headers)> modify_headers,
+                      const absl::optional<Grpc::Status::GrpcStatus> grpc_status,
+                      absl::string_view details);
+
   // The callbacks for the filter. They are only valid until onDestroy() is called.
   StreamDecoderFilterCallbacks* decoder_callbacks_ = nullptr;
   StreamEncoderFilterCallbacks* encoder_callbacks_ = nullptr;
@@ -60,6 +65,9 @@ class DynamicModuleHttpFilter : public Http::StreamFilter,
   ResponseTrailerMap* response_trailers_ = nullptr;
 
 private:
+  // This ensures that we do not re-enter the dynamic filter hooks when sending a local reply
+  bool sent_local_reply_ = false;
+
   /**
    * This is a helper function to get the `this` pointer as a void pointer which is passed to the
    * various event hooks.