Build script updates

Author: padelsbach

.gitignore

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

Makefile

@@ -17,45 +17,120 @@ 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 ?= /usr/local
+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)
+
 
 all: 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
+	@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
+
+# 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.