Makefile.in

# Makefile to build curl-impersonate
# Some Makefile tricks were taken from https://tech.davis-hansson.com/p/make/

SHELL := bash
.ONESHELL:
.SHELLFLAGS := -euc
.DELETE_ON_ERROR:
# MAKEFLAGS += --warn-undefined-variables
# MAKEFLAGS += --no-builtin-rules
SUBJOBS := 4

BROTLI_VERSION := 1.1.0
 # In case this is changed, update build-and-test-make.yml as well
BORING_SSL_COMMIT := cd95210465496ac2337b313cf49f607762abe286
NGHTTP2_VERSION := nghttp2-1.63.0
NGHTTP2_URL := https://github.com/nghttp2/nghttp2/releases/download/v1.63.0/nghttp2-1.63.0.tar.bz2
CURL_VERSION := curl-8_7_1

# https://github.com/google/brotli/commit/641bec0e30bea648b3da1cd90fc6b44deb429f71
brotli_install_dir := $(abspath brotli-$(BROTLI_VERSION)/out/installed)
brotli_static_libs := $(brotli_install_dir)/lib/libbrotlicommon.a $(brotli_install_dir)/lib/libbrotlidec.a
boringssl_dir := $(abspath boringssl-$(BORING_SSL_COMMIT))
boringssl_install_dir := $(boringssl_dir)/build
boringssl_static_libs := $(boringssl_dir)/lib/libssl.a $(boringssl_dir)/lib/libcrypto.a
nghttp2_install_dir := $(abspath $(NGHTTP2_VERSION)/installed)
nghttp2_static_libs := $(nghttp2_install_dir)/lib/libnghttp2.a

# Dependencies needed to compile the Chrome version
chrome_libs := $(brotli_static_libs) $(boringssl_static_libs) $(nghttp2_static_libs)

# The following variables will be set by the configure script.
prefix = @prefix@
exec_prefix = @exec_prefix@
srcdir = @abs_srcdir@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
build = @build@
# Whether to link curl-impersonate with libcurl-impersonate statically.
static_build = @static_build@
# Whether the user provided a specific find for zlib
with_zlib = @with_zlib@
# Whether the user provided a specific find for libzstd
with_zstd = @with_zstd@
# Path to be passed to curl's --with-ca-bundle configure option.
with_ca_bundle = @with_ca_bundle@
# Path to be passed to curl's --with-ca-path configure option.
with_ca_path = @with_ca_path@

CC = @CC@
CXX = @CXX@
STRIP = @STRIP@

# Auto-generate Makefile help.
# Borrowed from https://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
help: ## Show this help message
	@grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'
.PHONY: help
.DEFAULT_GOAL := help

chrome-build: $(CURL_VERSION)/.chrome ## Build the Chrome version of curl-impersonate
	cd $(CURL_VERSION)
	# Don't pass this Makefile's MAKEFLAGS
	$(MAKE) MAKEFLAGS=-j$(SUBJOBS)
.PHONY: chrome-build

chrome-checkbuild: ## Run basic checks on the built binary
ifeq ($(host),$(build))
	cd $(CURL_VERSION)
	# Make sure all needed features were compiled in
	./src/curl-impersonate-chrome -V | grep -q zlib
	./src/curl-impersonate-chrome -V | grep -q brotli
	./src/curl-impersonate-chrome -V | grep -q nghttp2
	./src/curl-impersonate-chrome -V | grep -q BoringSSL
	$(info Build OK)
else
	$(info Cross compiling, skipping checkbuild)
endif
.PHONY: chrome-checkbuild

chrome-install: ## Install the Chrome version of curl-impersonate after build
	cd $(CURL_VERSION)
	$(MAKE) install-exec MAKEFLAGS=
	# Wrapper scripts for the Chrome version (e.g. 'curl_chrome99')
	install $(srcdir)/chrome/curl_* @bindir@
.PHONY: chrome-install

chrome-install-strip: ## Like 'chrome-install', but strip binaries for smaller size
	cd $(CURL_VERSION)
	$(MAKE) install-exec MAKEFLAGS=
	# We could have used 'install-strip' but then the docs would be installed as well.
	# Instead strip manually.
	$(STRIP) @bindir@/curl-impersonate-chrome
	# Wrapper scripts for the Chrome version (e.g. 'curl_chrome99')
	install $(srcdir)/chrome/curl_chrome* $(srcdir)/chrome/curl_edge* $(srcdir)/chrome/curl_safari* @bindir@
.PHONY: chrome-install-strip

chrome-uninstall: ## Uninstall the Chrome version of curl-impersonate after 'make install'
	cd $(CURL_VERSION)
	$(MAKE) uninstall MAKEFLAGS=
	rm -Rf @bindir@/curl_chrome* @bindir@/curl_edge* @bindir@/curl_safari*
.PHONY: chrome-uninstall

chrome-clean: ## Clean build artifacts of the Chrome version. Use after re-running './configure'
	cd $(CURL_VERSION)
	$(MAKE) clean MAKEFLAGS=
	rm -f .chrome
.PHONY: chrome-clean

clean: ## Remove all build artifacts, including dependencies
	rm -Rf brotli-$(BROTLI_VERSION).tar.gz brotli-$(BROTLI_VERSION)
	rm -Rf boringssl-$(BORING_SSL_COMMIT).zip boringssl-$(BORING_SSL_COMMIT)
	rm -Rf $(NGHTTP2_VERSION).tar.bz2 $(NGHTTP2_VERSION)
	rm -Rf $(CURL_VERSION).tar.gz $(CURL_VERSION)

brotli-$(BROTLI_VERSION).tar.gz:
	curl -L "https://github.com/google/brotli/archive/refs/tags/v${BROTLI_VERSION}.tar.gz" \
		-o "brotli-${BROTLI_VERSION}.tar.gz"

$(brotli_static_libs): brotli-$(BROTLI_VERSION).tar.gz
	tar xf brotli-$(BROTLI_VERSION).tar.gz
	cd brotli-$(BROTLI_VERSION)
	mkdir -p out
	cd out

	# Convert autoconf style os name to CMake style os name.
	case $(host_os) in           \
	  linux*)                    \
	    system_name=Linux        \
	    ;;                       \
	  darwin*)                   \
	    system_name=Darwin       \
	    ;;                       \
	  *)                         \
	    system_name=$(host_os)   \
	    ;;                       \
	esac

	@cmake@ -DCMAKE_BUILD_TYPE=Release \
	        -DCMAKE_INSTALL_PREFIX=./installed \
	        -DCMAKE_INSTALL_LIBDIR=lib \
	        -DCMAKE_CXX_COMPILER=$(CXX) \
	        -DCMAKE_C_COMPILER=$(CC) \
			-DCMAKE_C_FLAGS="$(CFLAGS)" \
	        -DCMAKE_SYSTEM_NAME=$$system_name \
	        -DCMAKE_SYSTEM_PROCESSOR=$(host_cpu) \
	        -DBUILD_SHARED_LIBS=OFF \
	        ..

	@cmake@ --build . --config Release --target install --parallel $(SUBJOBS)


boringssl-$(BORING_SSL_COMMIT).zip:
	curl -L https://github.com/google/boringssl/archive/$(BORING_SSL_COMMIT).zip \
		-o boringssl-$(BORING_SSL_COMMIT).zip

# Patch boringssl and use a dummy '.patched' file to mark it patched
boringssl-$(BORING_SSL_COMMIT)/.patched: $(srcdir)/chrome/patches/boringssl.patch
	unzip -q -o boringssl-$(BORING_SSL_COMMIT).zip
	# mv boringssl boringssl-$(BORING_SSL_COMMIT)
	cd boringssl-$(BORING_SSL_COMMIT)/
	for p in $^; do patch -p1 < $$p; done
	touch .patched

$(boringssl_static_libs): boringssl-$(BORING_SSL_COMMIT).zip boringssl-$(BORING_SSL_COMMIT)/.patched
	mkdir -p $(boringssl_install_dir)
	cd $(boringssl_install_dir)

	# Convert autoconf style os name to CMake style os name.
	case $(host_os) in      \
	  linux*)               \
	    system_name=Linux   \
	    ;;                  \
	  darwin*)              \
	    system_name=Darwin  \
	    ;;                  \
	  *)                    \
	    system_name=Linux   \
	    ;;                  \
	esac

	# The extra CMAKE_C_FLAGS are needed because otherwise boringssl fails to
	# compile in release mode on some systems with gcc 12 (e.g. Fedora).
	# In addition, guard these options with -Wno-unknown-warning-option to
	# prevent clang from failing on them.
	@cmake@ -DCMAKE_BUILD_TYPE=Release \
			-DCMAKE_POSITION_INDEPENDENT_CODE=on \
			-DCMAKE_C_FLAGS="$(CFLAGS) -Wno-unknown-warning-option -Wno-stringop-overflow -Wno-array-bounds" \
			-DCMAKE_CXX_COMPILER=$(CXX) \
			-DCMAKE_C_COMPILER=$(CC) \
			-DCMAKE_SYSTEM_NAME=$$system_name \
			-DCMAKE_SYSTEM_PROCESSOR=$(host_cpu) \
			-GNinja \
			..
	@ninja@ -j$(SUBJOBS)

	# Fix the directory structure so that curl can compile against it.
	# See: https://everything.curl.dev/build/boringssl.html
	mkdir -p $(boringssl_dir)/lib
	cp ssl/libssl.a $(boringssl_dir)/lib
	cp crypto/libcrypto.a $(boringssl_dir)/lib


$(NGHTTP2_VERSION).tar.bz2:
	curl -L $(NGHTTP2_URL) -o $(NGHTTP2_VERSION).tar.bz2

$(nghttp2_static_libs): $(NGHTTP2_VERSION).tar.bz2
	tar -xf $(NGHTTP2_VERSION).tar.bz2
	cd $(NGHTTP2_VERSION)

	# Set up the configure flags to nghttp2.
	# If the user provided the --host flag to our configure script
	# (for cross compilation), then pass it on to nghttp2.
	{ \
	  config_flags="--prefix=$(nghttp2_install_dir)"; \
	  config_flags="$$config_flags --with-pic --enable-lib-only"; \
	  config_flags="$$config_flags --disable-shared --disable-python-bindings"; \
	  if test -n "$(host_alias)"; then \
	    config_flags="$$config_flags --host=$(host_alias)"; \
	  fi; \
	}

	./configure $$config_flags
	$(MAKE) MAKEFLAGS=-j$(SUBJOBS)
	$(MAKE) install MAKEFLAGS=

$(CURL_VERSION).tar.gz:
	curl -L "https://github.com/curl/curl/archive/$(CURL_VERSION).tar.gz" \
		-o "$(CURL_VERSION).tar.gz"

# Apply the "Chorme version" patches and mark using a dummy file
$(CURL_VERSION)/.patched-chrome: $(srcdir)/chrome/patches/curl-*.patch
	rm -Rf $(CURL_VERSION)
	tar -xf $(CURL_VERSION).tar.gz
	mv curl-$(CURL_VERSION) $(CURL_VERSION)  # fix directory name
	cd $(CURL_VERSION)
	for p in $^; do patch -p1 < $$p; done
	# Re-generate the configure script
	autoreconf -fi
	touch .patched-chrome

# This is a small hack that flags that curl was patched and configured in the "chrome" version
$(CURL_VERSION)/.chrome: $(chrome_libs)	$(CURL_VERSION).tar.gz $(CURL_VERSION)/.patched-chrome
	cd $(CURL_VERSION)

	# Set up the configure flags to curl.
	# If the user provided the --host flag to our configure script
	# (for cross compilation), then pass it on to curl.
	{ \
	  config_flags="--prefix=@prefix@"; \
	  config_flags="$$config_flags --with-nghttp2=$(nghttp2_install_dir)"; \
	  config_flags="$$config_flags --with-brotli=$(brotli_install_dir)"; \
	  config_flags="$$config_flags --with-openssl=$(boringssl_dir)"; \
	  config_flags="$$config_flags --enable-websockets"; \
	  config_flags="$$config_flags --enable-ech"; \
	  config_flags="$$config_flags --enable-ipv6"; \
	  config_flags="$$config_flags USE_CURL_SSLKEYLOGFILE=true"; \
	  if test "$(static_build)" = "yes"; then \
	    config_flags="$$config_flags --enable-static --disable-shared";
	  fi; \
	  if test -n "$(host_alias)"; then \
	    config_flags="$$config_flags --host=$(host_alias)"; \
	  fi; \
	  if test -n "$(with_zlib)"; then \
	    config_flags="$$config_flags --with-zlib=$(with_zlib)"; \
	  else \
	    config_flags+=" --with-zlib"; \
	  fi; \
	  if test -n "$(with_zstd)"; then \
	    config_flags="$$config_flags --with-zstd=$(with_zstd)"; \
	  else \
	    config_flags+=" --with-zstd"; \
	  fi; \
	  if test -n "$(with_ca_bundle)"; then \
		config_flags="$$config_flags --with-ca-bundle=$(with_ca_bundle)"; \
	  fi; \
	  if test -n "$(with_ca_path)"; then \
		config_flags="$$config_flags --with-ca-path=$(with_ca_path)"; \
	  fi; \
	  add_libs="-pthread -lc++"; \
	}

	echo "Configuring curl with: $$config_flags"

	CXXFLAGS="-stdlib=libc++" LDFLAGS="-lc++" ./configure $$config_flags LIBS="$$add_libs"

	# Remove possible leftovers from a previous compilation
	$(MAKE) clean MAKEFLAGS=
	touch .chrome