feat: support compressed http3 bodies

Author: pymumu

Makefile

@@ -55,6 +55,7 @@ $(SMARTDNS_SYSTEMD): systemd/smartdns.service.in
 help:
 	@echo "Options:"
 	@echo "  WITH_UI=1: Build with smartdns-ui plugin" 
+	@echo "  WITH_ZLIB=auto|1|0: Auto-detect, force enable, or disable zlib support"
 	@echo "  OPTIMIZE_SIZE=1: Optimize size of the smartdns-ui plugin (only for smartdns-ui)"
 	@echo "  DESTDIR: Specify the installation directory prefix"
 
@@ -70,4 +71,3 @@ install: SMARTDNS_BIN
 	install -v -m 0755 -D -t $(DESTDIR)$(SBINDIR) src/smartdns
 	install -v -m 0644 -D -t $(DESTDIR)$(SYSTEMDSYSTEMUNITDIR) systemd/smartdns.service
 	$(call PLUGINS_TARGETS, install)
-

plugin/smartdns-ui/build.rs

@@ -49,6 +49,16 @@ fn link_rename_lib() {
     println!("cargo:rustc-link-arg={}", so_path);
 }
 
+fn should_link_zlib() -> bool {
+    matches!(
+        env::var("WITH_ZLIB")
+            .unwrap_or_default()
+            .to_lowercase()
+            .as_str(),
+        "1" | "yes" | "true" | "on"
+    )
+}
+
 fn link_smartdns_lib() {
     let curr_source_dir = env::var("CARGO_MANIFEST_DIR").unwrap();
     let smartdns_src_dir = format!("{}/../../src", curr_source_dir);
@@ -95,6 +105,10 @@ fn link_smartdns_lib() {
         println!("cargo:rustc-link-lib=static=smartdns-test");
         println!("cargo:rustc-link-lib=ssl");
         println!("cargo:rustc-link-lib=crypto");
+        println!("cargo:rerun-if-env-changed=WITH_ZLIB");
+        if should_link_zlib() {
+            println!("cargo:rustc-link-lib=z");
+        }
         println!("cargo:rustc-link-search=native={}", smartdns_src_dir);
     }
 }

src/Makefile

@@ -43,6 +43,21 @@ ifeq ($(HAS_UNWIND), 1)
 override CFLAGS += -DHAVE_UNWIND_BACKTRACE
 endif
 
+WITH_ZLIB ?= auto
+HAS_ZLIB := $(shell printf '$(HASH)include <zlib.h>\nint main(void) { return zlibVersion()[0] == 0; }' | $(CC) -x c - -lz -o /dev/null >/dev/null 2>&1 && echo -n 1 || echo -n 0)
+ifeq ($(WITH_ZLIB), yes)
+override WITH_ZLIB := 1
+endif
+ifeq ($(WITH_ZLIB), auto)
+ ifeq ($(HAS_ZLIB), 1)
+  override CFLAGS += -DWITH_ZLIB
+  override LDFLAGS += -lz
+ endif
+else ifeq ($(WITH_ZLIB), 1)
+override CFLAGS += -DWITH_ZLIB
+override LDFLAGS += -lz
+endif
+
 override CFLAGS +=-Iinclude
 override CFLAGS += -DBASE_FILE_NAME='"$(notdir $<)"'
 override CFLAGS += $(EXTRA_CFLAGS)
@@ -118,4 +133,3 @@ clean:
 lint-files:
 	@echo "Specify FILES variable to lint specific files, e.g., make lint-files FILES='src/dns.c src/proxy.c'"
 	clang-tidy -p=. $(FILES) -- $(CFLAGS)
-

src/http_parse/http3_parse.c

@@ -23,9 +23,16 @@
 #include <limits.h>
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+
+#ifdef WITH_ZLIB
+#include <zlib.h>
+#endif
 
 #define HTTP3_HEADER_FRAME 1
 #define HTTP3_DATA_FRAME 0
+#define HTTP3_MAX_DECOMPRESSED_SIZE (1024 * 1024)
 
 static int _http3_get_expected_data_len(struct http_head *http_head, int *expect_data_len)
 {
@@ -56,6 +63,148 @@ static int _http3_get_expected_data_len(struct http_head *http_head, int *expect
 	return 0;
 }
 
+static int _http3_decompress_data(const uint8_t *compressed, int compressed_len, uint8_t **decompressed,
+								  int *decompressed_len, int is_gzip)
+{
+#ifdef WITH_ZLIB
+	z_stream strm;
+	int ret = Z_OK;
+	int window_bits = is_gzip ? (15 + 16) : 15;
+	int out_size = compressed_len * 4;
+	uint8_t *out_buf = NULL;
+
+	if (compressed == NULL || compressed_len <= 0 || decompressed == NULL || decompressed_len == NULL) {
+		return -2;
+	}
+
+	if (out_size < 8192) {
+		out_size = 8192;
+	}
+	if (out_size > HTTP3_MAX_DECOMPRESSED_SIZE) {
+		out_size = HTTP3_MAX_DECOMPRESSED_SIZE;
+	}
+
+	out_buf = malloc(out_size);
+	if (out_buf == NULL) {
+		return -3;
+	}
+
+	memset(&strm, 0, sizeof(strm));
+	strm.avail_in = compressed_len;
+	strm.next_in = (Bytef *)compressed;
+
+	ret = inflateInit2(&strm, window_bits);
+	if (ret != Z_OK) {
+		free(out_buf);
+		return -2;
+	}
+
+	while (ret != Z_STREAM_END) {
+		if ((int)strm.total_out == out_size) {
+			int new_size = out_size * 2;
+			uint8_t *new_buf = NULL;
+
+			if (new_size <= out_size || new_size > HTTP3_MAX_DECOMPRESSED_SIZE) {
+				inflateEnd(&strm);
+				free(out_buf);
+				return -3;
+			}
+
+			new_buf = realloc(out_buf, new_size);
+			if (new_buf == NULL) {
+				inflateEnd(&strm);
+				free(out_buf);
+				return -3;
+			}
+
+			out_buf = new_buf;
+			out_size = new_size;
+		}
+
+		strm.avail_out = out_size - strm.total_out;
+		strm.next_out = out_buf + strm.total_out;
+
+		ret = inflate(&strm, Z_NO_FLUSH);
+		if (ret == Z_STREAM_END) {
+			break;
+		}
+
+		if (ret == Z_BUF_ERROR || (ret == Z_OK && strm.avail_in == 0 && strm.avail_out > 0)) {
+			inflateEnd(&strm);
+			free(out_buf);
+			return -1;
+		}
+
+		if (ret != Z_OK) {
+			inflateEnd(&strm);
+			free(out_buf);
+			return -2;
+		}
+	}
+
+	*decompressed = out_buf;
+	*decompressed_len = strm.total_out;
+	inflateEnd(&strm);
+	return 0;
+#else
+	return -2;
+#endif
+}
+
+static int _http3_decode_content_encoding(struct http_head *http_head)
+{
+	const char *content_encoding = NULL;
+	uint8_t *decompressed = NULL;
+	int decompressed_len = 0;
+	int is_gzip = 0;
+	int ret = 0;
+	int data_offset = 0;
+	int data_end_offset = 0;
+
+	if (http_head == NULL || http_head->data == NULL || http_head->data_len <= 0) {
+		return 0;
+	}
+
+	content_encoding = http_head_get_fields_value(http_head, "content-encoding");
+	if (content_encoding == NULL || content_encoding[0] == '\0') {
+		return 0;
+	}
+
+	is_gzip = strcasecmp(content_encoding, "gzip") == 0;
+	if (!is_gzip && strcasecmp(content_encoding, "deflate") != 0) {
+		return 0;
+	}
+
+	ret = _http3_decompress_data(http_head->data, http_head->data_len, &decompressed, &decompressed_len, is_gzip);
+	if (ret != 0) {
+		return ret;
+	}
+
+	data_offset = http_head->data - http_head->buff;
+	data_end_offset = data_offset + http_head->data_len;
+	if (data_offset < 0 || data_offset > http_head->buff_size || decompressed_len > http_head->buff_size - data_offset) {
+		free(decompressed);
+		return -3;
+	}
+
+	if (data_end_offset == http_head->buff_len) {
+		memcpy(http_head->buff + data_offset, decompressed, decompressed_len);
+		http_head->buff_len = data_offset + decompressed_len;
+		http_head->data = http_head->buff + data_offset;
+	} else {
+		if (_http_head_buffer_left_len(http_head) < decompressed_len) {
+			free(decompressed);
+			return -3;
+		}
+		http_head->data = _http_head_buffer_get_end(http_head);
+		_http_head_buffer_append(http_head, decompressed, decompressed_len);
+	}
+	http_head->data_len = decompressed_len;
+
+	free(decompressed);
+	return 0;
+}
+
 static int _quicvarint_encode(uint64_t value, uint8_t *buffer, int buffer_size)
 {
 	if (value <= 63) {
@@ -660,6 +809,11 @@ int http_head_parse_http3_0(struct http_head *http_head, const uint8_t *data, in
 		}
 	}
 
+	offset_ret = _http3_decode_content_encoding(http_head);
+	if (offset_ret < 0) {
+		return offset_ret;
+	}
+
 	if (offset >= http_head->buff_size) {
 		return -3;
 	}

test/Makefile

@@ -34,7 +34,25 @@ ifeq ($(filter -j,$(MAKEFLAGS)),)
 MAKEFLAGS += -j$(shell nproc)
 endif
 
+HASH := \#
+WITH_ZLIB ?= auto
+HAS_ZLIB := $(shell printf '$(HASH)include <zlib.h>\nint main(void) { return zlibVersion()[0] == 0; }' | $(CC) -x c - -lz -o /dev/null >/dev/null 2>&1 && echo -n 1 || echo -n 0)
+ifeq ($(WITH_ZLIB), yes)
+override WITH_ZLIB := 1
+endif
+ifeq ($(WITH_ZLIB), auto)
+ ifeq ($(HAS_ZLIB), 1)
+  ZLIB_CXXFLAGS += -DWITH_ZLIB
+  ZLIB_LDFLAGS += -lz
+ endif
+else ifeq ($(WITH_ZLIB), 1)
+ZLIB_CXXFLAGS += -DWITH_ZLIB
+ZLIB_LDFLAGS += -lz
+endif
+
+CXXFLAGS += $(ZLIB_CXXFLAGS)
 LDFLAGS += -lssl -lcrypto -lpthread -ldl -lgtest -lstdc++ -lm -rdynamic
+LDFLAGS += $(ZLIB_LDFLAGS)
 LDFLAGS += $(EXTRA_LDFLAGS)
 
 .PHONY: all clean test $(SMARTDNS_TEST_LIB)
@@ -48,7 +66,7 @@ test: $(BIN)
 	./$(BIN)
 
 $(SMARTDNS_TEST_LIB): 
-	$(MAKE) DEBUG=1 -C $(SMARTDNS_SRC_DIR) libsmartdns-test.a
+	$(MAKE) DEBUG=1 WITH_ZLIB=$(WITH_ZLIB) -C $(SMARTDNS_SRC_DIR) libsmartdns-test.a
 
 clean:
 	$(RM) $(OBJS) $(BIN)

test/cases/test-http.cc

@@ -170,6 +170,39 @@ TEST_F(HTTP, http3_0_parse)
 	http_head_destroy(http_head);
 }
 
+#ifdef WITH_ZLIB
+TEST_F(HTTP, http3_0_response_parse_gzip_body)
+{
+	const unsigned char gzip_body[] = {0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
+									   0x02, 0x03, 0xcb, 0x48, 0xcd, 0xc9, 0xc9, 0x57,
+									   0x28, 0xcf, 0x2f, 0xca, 0x49, 0x01, 0x00, 0x85,
+									   0x11, 0x4a, 0x0d, 0x0b, 0x00, 0x00, 0x00};
+	unsigned char buffer[1024];
+
+	struct http_head *http_head = http_head_init(1024, HTTP_VERSION_3_0);
+	ASSERT_NE(http_head, nullptr);
+	http_head_set_httpversion(http_head, "HTTP/3");
+	http_head_set_httpcode(http_head, 200, "OK");
+	http_head_add_fields(http_head, "content-type", "application/dns-message");
+	http_head_add_fields(http_head, "content-encoding", "gzip");
+	http_head_set_data(http_head, gzip_body, sizeof(gzip_body));
+	http_head_set_head_type(http_head, HTTP_HEAD_RESPONSE);
+
+	int buffer_len = http_head_serialize(http_head, buffer, sizeof(buffer));
+	ASSERT_GT(buffer_len, 0);
+	http_head_destroy(http_head);
+
+	http_head = http_head_init(1024, HTTP_VERSION_3_0);
+	ASSERT_NE(http_head, nullptr);
+	int ret = http_head_parse(http_head, buffer, buffer_len);
+	ASSERT_EQ(ret, buffer_len);
+	EXPECT_EQ(http_head_get_httpcode(http_head), 200);
+	ASSERT_EQ(http_head_get_data_len(http_head), (int)strlen("hello world"));
+	EXPECT_EQ(memcmp(http_head_get_data(http_head), "hello world", strlen("hello world")), 0);
+	http_head_destroy(http_head);
+}
+#endif
+
 TEST_F(HTTP, http1_1_small_buffer)
 {
 	const char *data = "HTTP/1.1 200 OK\r\n"