Merge pull request #332 from padelsbach/padelsbach/build-updates

Build script updates

Author: cconlon

.gitignore

@@ -38,3 +38,6 @@ infer-out/
 target/
 
 **/.claude/settings.local.json
+
+# Native dependency files
+native/*.d

Makefile

@@ -17,45 +17,138 @@ ifeq ($(LIBDIR),)
     LIBDIR=lib
 endif
 
+# Native JNI compilation variables
+NATIVE_SRC_DIR  = native
+NATIVE_SRCS     = $(wildcard $(NATIVE_SRC_DIR)/*.c)
+NATIVE_OBJS     = $(NATIVE_SRCS:.c=.o)
+NATIVE_DEPS     = $(NATIVE_SRCS:.c=.d)
+
+CC              ?= gcc
+WOLFSSL_INSTALL_DIR ?= $(INSTALL_DIR)
+WOLFSSL_LIBNAME ?= wolfssl
+
+# Platform detection
+OS              := $(shell uname)
+ARCH            := $(shell uname -m)
+
+# JAVA_HOME detection with platform-aware fallback
+JAVA_HOME       ?= $(shell \
+    if [ "$(OS)" = "Darwin" ]; then \
+        /usr/libexec/java_home 2>/dev/null; \
+    else \
+        java_bin=$$(readlink -f $$(which java) 2>/dev/null); \
+        jh=$$(dirname $$(dirname $$java_bin)); \
+        if [ ! -d "$$jh/include" ]; then jh=$$(dirname $$jh); fi; \
+        echo $$jh; \
+    fi)
+
+# Platform-specific flags
+ifeq ($(OS),Darwin)
+    JNI_INCLUDES  = -I$(JAVA_HOME)/include \
+                    -I$(JAVA_HOME)/include/darwin \
+                    -I$(WOLFSSL_INSTALL_DIR)/include
+    JNI_LIB_FLAGS = -dynamiclib
+    JNI_LIB_NAME  = libwolfssljni.dylib
+else ifeq ($(OS),Linux)
+    JNI_INCLUDES  = -I$(JAVA_HOME)/include \
+                    -I$(JAVA_HOME)/include/linux \
+                    -I$(WOLFSSL_INSTALL_DIR)/include
+    JNI_LIB_FLAGS = -shared
+    JNI_LIB_NAME  = libwolfssljni.so
+    ifneq ($(filter x86_64 aarch64,$(ARCH)),)
+        FPIC = -fPIC
+    endif
+else
+    $(error Unsupported host OS '$(OS)'; supported OSes are Linux and Darwin)
+endif
+
+# Optionally enable all patch defines in the native code for testing.
+ifeq ($(ENABLE_PATCHES),1)
+    PATCH_CFLAGS = $(addprefix -D,$(shell ./scripts/find-wolfssl-pr-patch-defines.sh))
+    ifeq ($(PATCH_CFLAGS),)
+        $(warning no WOLFSSL_PR*_PATCH_APPLIED defines found; building without patches)
+    endif
+endif
+
+# Verbose mode: set V=1 to see full compiler commands
+ifeq ($(V),1)
+    Q =
+else
+    Q = @
+endif
+
+JNI_CFLAGS  = -Wall -Wextra -Werror $(FPIC) -MMD -MP $(PATCH_CFLAGS) $(CFLAGS)
+JNI_LDFLAGS = -Wall $(JNI_LIB_FLAGS) $(CFLAGS) \
+              -L$(WOLFSSL_INSTALL_DIR)/lib \
+              -L$(WOLFSSL_INSTALL_DIR)/lib64
+JNI_LDLIBS  = -l$(WOLFSSL_LIBNAME)
+
+.PHONY: all build check native clean-native clean install uninstall dist rpm print-config
+
 all: build
 
-.PHONY: build
-build: java.sh build.xml
-		@cflags=""; \
-	if [ "$(ENABLE_PATCHES)" = "1" ]; then \
-		if [ -n "$(PATCH_DEFINES)" ]; then \
-			defines="$(PATCH_DEFINES)"; \
-		else \
-			defines="$$(./scripts/find-wolfssl-pr-patch-defines.sh)"; \
-		fi; \
-		if [ -z "$$defines" ]; then \
-			echo "warning: no WOLFSSL_PR*_PATCH_APPLIED defines found; building without patches"; \
-		else \
-			for define in $$defines; do \
-				cflags="$$cflags -D$$define"; \
-			done; \
-		fi; \
-	fi; \
-	CFLAGS="$$cflags" ./java.sh $(INSTALL_DIR); \
+build: build.xml
+	$(MAKE) native WOLFSSL_INSTALL_DIR="$(WOLFSSL_INSTALL_DIR)" WOLFSSL_LIBNAME="$(WOLFSSL_LIBNAME)"
 	ant
 
 check: build
 	ant test
 
-clean:
-	ant clean cleanjni
+# Pattern rule: compile any native/*.c to native/*.o
+$(NATIVE_SRC_DIR)/%.o: $(NATIVE_SRC_DIR)/%.c | print-config
+	@echo "  CC      $<"
+	$(Q)$(CC) $(JNI_CFLAGS) -c $< -o $@ $(JNI_INCLUDES)
+
+# Link all .o files into the shared library
+lib/$(JNI_LIB_NAME): $(NATIVE_OBJS) | lib
+	@echo "  LD      $@"
+	$(Q)$(CC) $(JNI_LDFLAGS) -o $@ $(NATIVE_OBJS) $(JNI_LDLIBS)
+
+lib:
+	mkdir -p lib
 
+# Print build configuration, matching the output style of upstream java.sh
+print-config:
+	@echo "Compiling Native JNI library:"
+	@echo "    WOLFSSL_INSTALL_DIR = $(WOLFSSL_INSTALL_DIR)"
+	@echo "    WOLFSSL_LIBNAME     = $(WOLFSSL_LIBNAME)"
+	@if [ -n "$(JAVA_HOME)" ]; then \
+	    echo "    JAVA_HOME           = $(JAVA_HOME)"; \
+	else \
+	    echo "    JAVA_HOME           = <not set>"; \
+	fi
+	@if [ -n "$(CFLAGS)" ]; then \
+	    echo "    CFLAGS              = $(CFLAGS)"; \
+	else \
+	    echo "    CFLAGS              = <none>"; \
+	fi
+	@echo "    Host OS             = $(OS) $(ARCH)"
+
+# Convenience target for building just native JNI library
+native: lib/$(JNI_LIB_NAME)
+	@echo "    Generated ./lib/$(JNI_LIB_NAME)"
+
+# Clean only native artifacts (.o, .d files and shared lib)
+clean-native:
+	$(Q)rm -f $(NATIVE_SRC_DIR)/*.o $(NATIVE_SRC_DIR)/*.d
+	$(Q)rm -f lib/$(JNI_LIB_NAME)
+
+# Include auto-generated dependency files (if they exist)
+-include $(NATIVE_DEPS)
+
+clean: clean-native
+	ant clean cleanjni
 
 install:
 	$(INSTALL) -d $(INSTALL_DIR)/$(LIBDIR)
-	$(INSTALL) lib/libwolfssljni.so $(INSTALL_DIR)/$(LIBDIR)
+	$(INSTALL) lib/$(JNI_LIB_NAME) $(INSTALL_DIR)/$(LIBDIR)
 	$(INSTALL) lib/wolfssl.jar $(INSTALL_DIR)/$(LIBDIR)
 	$(INSTALL) lib/wolfssl-jsse.jar $(INSTALL_DIR)/$(LIBDIR)
 
 uninstall:
-	rm -f $(INSTALL_DIR)/$(LIBDIR)/libwolfssljni.so
-	rm -f $(INSTALL_DIR)/share/java/wolfssl.jar
-	rm -f $(INSTALL_DIR)/share/java/wolfssl-jsse.jar
+	rm -f $(INSTALL_DIR)/$(LIBDIR)/$(JNI_LIB_NAME)
+	rm -f $(INSTALL_DIR)/$(LIBDIR)/wolfssl.jar
+	rm -f $(INSTALL_DIR)/$(LIBDIR)/wolfssl-jsse.jar
 
 dist:
 	@mkdir -p "$(NAME)-$(VERSION)"

README.md

@@ -65,33 +65,65 @@ If building a wolfSSL FIPS or FIPS Ready release bundle, additional
 configure options may be required. Reference the wolfSSL Manual and build
 documentation for exact build instructions.
 
-## Building with ant
+## Building and testing with make/ant
 
 wolfSSL JNI/JSSE's ant build is the most stable and well-tested. Newer support
 for building with Maven has also been added. See section below for instructions
 on building with Maven.
 
-***Note 1)***
-The `java.sh` script uses a common location for the Java install location. If
-your Java install location is different, this could lead to an error when
-running `java.sh`. In this case, you should modify `java.sh` to match your
-environment.
-
-Build targets for ant are :
-* **ant build (ant)**     (only builds the jar necessary for an app to use)
-* **ant test**      (builds the jar and tests then runs the tests, requires JUNIT setup)
-* **ant examples**  (builds the jar and example cases)
-* **ant clean**     (cleans all Java artifacts)
-* **ant cleanjni**  (cleans native artifacts)
+The `Makefile` compiles the native JNI shared library
+(`libwolfssljni.so`/`libwolfssljni.dylib`) and invokes `ant` to build the Java
+sources. It will auto-detect `JAVA_HOME` if not already set. To explicitly
+specify a Java installation, set `JAVA_HOME` before running `make`.
+
+Make targets:
+* **make** / **make build** - Compiles the native JNI library and Java sources (JAR)
+* **make check**            - Builds and runs JUnit tests (requires `JUNIT_HOME`)
+* **make native**           - Compiles only the native JNI shared library
+* **make clean**            - Cleans all Java and native artifacts
+* **make clean-native**     - Cleans only native artifacts (`.o`, `.d`, shared lib)
+* **make install**          - Installs shared library and JARs
+* **make uninstall**        - Removes installed files
+
+Ant-only targets are also available:
+* **ant build (ant)** - Only builds the JAR
+* **ant test**        - Builds and runs tests (requires JUNIT setup)
+* **ant examples**    - Builds examples
+* **ant clean**       - Cleans Java artifacts
+* **ant cleanjni**    - Cleans native artifacts
 
 To build wolfJSSE:
 
 ```
 $ cd wolfssljni
-$ ./java.sh
-$ ant
 $ export JUNIT_HOME=/path/to/junit/jars
-$ ant test
+$ make build
+$ make check
+```
+
+Custom wolfSSL installation directories and library names can be passed to
+`make`:
+
+```
+$ make WOLFSSL_INSTALL_DIR=/path/to/wolfssl WOLFSSL_LIBNAME=wolfssljsse
+```
+
+Set `V=1` to see the full compiler commands:
+
+```
+$ make V=1
+```
+
+Set `ENABLE_PATCHES=1` to automatically detect and enable JNI code that
+depends on wolfSSL pull request patches (`WOLFSSL_PR*_PATCH_APPLIED` defines).
+This enables functionality and test coverage for features added since the last
+official wolfSSL build.
+
+**Note:** this requires a recent build of wolfSSL with the PR included, often 
+newer than the latest tagged release.
+
+```
+$ make ENABLE_PATCHES=1
 ```
 
 To compile and run the examples, use the `ant examples` target:
@@ -108,28 +140,20 @@ $ ./examples/provider/ServerJSSE.sh
 $ ./examples/provider/ClientJSSE.sh
 ```
 
-### java.sh Script Options
-
-The `java.sh` script compiles the native JNI sources into a shared library named
-either `libwolfssljni.so` (Linux/Unix) or `libwolfssljni.dylib` (MacOS).
-Compiling on Linux/Unix and Mac OSX are currently supported.
+### java.sh Script
 
-This script will attempt to auto-detect the `JAVA_HOME` location if not set.
-To explicitly use a Java home location, set the `JAVA_HOME` environment variable
-prior to running this script.
+The `java.sh` script is a convenience wrapper around the Makefile that compiles
+the native JNI sources into a shared library named either `libwolfssljni.so`
+(Linux/Unix) or `libwolfssljni.dylib` (MacOS). It invokes `make clean-native`
+followed by `make native`, performing a clean rebuild of the native library each
+time.
 
-This script will try to link against a wolfSSL library installed to the
-default location of `/usr/local`. This script accepts two arguments on the
-command line. The first argument can point to a custom wolfSSL installation
-location. A custom install location would match the directory set at wolfSSL
-`./configure --prefix=<DIR>`.
+The script accepts two optional arguments:
 
-The second argument represents the wolfSSL library name that should be
-linked against. This is helpful if a non-standard library name has been
-used with wolfSSL, for example the `./configure --with-libsuffix` option
-has been used to add a suffix to the wolfSSL library name. Note that to
-use this argument, an installation location must be specified via the
-first argument.
+1. **wolfSSL installation directory** (default: `/usr/local`) - should match
+   the directory set at wolfSSL `./configure --prefix=<DIR>`.
+2. **wolfSSL library name** (default: `wolfssl`) - useful if a non-standard
+   library name has been used, for example via `./configure --with-libsuffix`.
 
 For example, if wolfSSL was configured with `--with-libsuffix=jsse`, then
 this script could be called like so using the default installation
@@ -139,8 +163,7 @@ path of `/usr/local`:
 java.sh /usr/local wolfssljsse
 ```
 
-`java.sh` can use preset `CFLAGS` defines, if set in the environment variable
-prior to running the script, for example:
+`CFLAGS` can be set in the environment prior to running the script:
 
 ```
 CFLAGS=-DWOLFJNI_USE_IO_SELECT java.sh
@@ -153,12 +176,11 @@ are already set up to use and consume Maven packages.
 
 wolfJSSE's Maven build configuration is defined in the included `pom.xml`.
 
-First, compile the native JNI shared library (libwolfssljni.so/dylib) same
-as above. This will create the native JNI shared library under the `./lib`
-directory:
+First, compile the native JNI shared library (libwolfssljni.so/dylib). This
+will create the native JNI shared library under the `./lib` directory:
 
 ```
-$ ./java.sh
+$ make native
 ```
 
 Compile the Java sources, where Maven will place the compiled `.class` files
@@ -202,10 +224,10 @@ The local Maven repository installation location will be similar to:
 ~/.m2/repository/com/wolfssl/wolfssl-jsse/X.X.X-SNAPSHOT/wolfssl-jsse-X.X.X-SNAPSHOT.jar
 ```
 
-The wolfSSL JNI shared library (`libwolfssljni.so/dylib`) created with the
-`java.sh` script will need to be "installed" by being placed on your native
+The wolfSSL JNI shared library (`libwolfssljni.so/dylib`) will need to be
+"installed" by being placed on your native
 library search path. For example, copied into `/usr/local/lib`, `/usr/lib`,
-or other location. Alternatively, append the `./libs` directory to your native
+or other location. Alternatively, append the `./lib` directory to your native
 library search path by exporting `LD_LIBRARY_PATH` (Linux) or
 `DYLD_LIBRARY_PATH` (OSX):
 
@@ -261,15 +283,14 @@ Maven builds support automatic module-info compilation.
 
 ```
 $ export JAVA_HOME=/path/to/jdk11   # or any JDK 9+
-$ ./java.sh
-$ ant
+$ make build
 ```
 
 **Using Maven:**
 
 ```
 $ export JAVA_HOME=/path/to/jdk11   # or any JDK 9+
-$ ./java.sh
+$ make native
 $ mvn package
 ```
 
@@ -494,7 +515,8 @@ file descriptors inside Java Socket objects. These native file descriptors
 are watched for read and write events with either `select()` or `poll()`.
 
 By default `poll()` will be used, unless `WOLFJNI_USE_IO_SELECT` is defined
-or added to CFLAGS when compiling the native JNI sources (see `java.sh`).
+or added to CFLAGS when compiling the native JNI sources (e.g.
+`make CFLAGS=-DWOLFJNI_USE_IO_SELECT`).
 Windows builds will also default to using `select()` since `poll()` is not
 available there.
 
@@ -698,14 +720,14 @@ legacy behavior where SNI is automatically configured from hostname/peer informa
 even without explicit SSLParameters configuration. Default value is "false", where
 SNI is only set when explicitly configured through SSLParameters.
 
-**wolfssl.skipLibraryLoad (boolean)** - When set to "true", `WolfSSL.loadLibrary()`
+**wolfssl.skipLibraryLoad (boolean)** - When set to "true", `wolfSSL.loadLibrary()`
 will skip the default `System.loadLibrary()` calls for native wolfSSL and
 wolfSSL JNI libraries. This is useful when applications need to load the native
 libraries themselves using custom logic, for example when bundling the native
 library inside a JAR file and extracting it at runtime. The property must be set
-before `WolfSSL.loadLibrary()` is called, either directly or via
+before `wolfSSL.loadLibrary()` is called, either directly or via
 `WolfSSLProvider()` constructor. Applications can check if library loading was
-skipped by calling `WolfSSL.isLibraryLoadSkipped()`.
+skipped by calling `wolfSSL.isLibraryLoadSkipped()`.
 
 Setting via command line:
 
@@ -722,8 +744,8 @@ System.setProperty("wolfssl.skipLibraryLoad", "true");
 System.load("/path/to/libwolfssl.so");
 System.load("/path/to/libwolfssljni.so");
 
-/* Then use WolfSSL as normal */
-WolfSSL.loadLibrary();
+/* Then use wolfSSL as normal */
+wolfSSL.loadLibrary();
 ```
 
 If there are other System properties you would like to use with wolfJSSE,