chore: satisfy clippy and make the dev image portable

Clippy runs in CI now, so the warnings it had are fixed: pointer casts made
explicit, the mutable static reached through a raw pointer, the large enum
variant boxed. The dev image installs clippy and picks its benchmark binaries
by architecture instead of assuming arm64.

Author: sowahq

docker/Dockerfile.dev

@@ -14,12 +14,20 @@ ENV PATH="/opt/php/bin:${PATH}"
 ENV CARGO_TARGET_DIR=/target
 ENV RUSTFLAGS="-C target-cpu=native"
 
+RUN rustup component add clippy
+
+# Benchmark tools, for comparing against the reference stacks by hand.
 ARG BOMBARDIER_VERSION=1.2.6
-RUN curl -fsSL -o /usr/local/bin/bombardier \
-      "https://github.com/codesenberg/bombardier/releases/download/v${BOMBARDIER_VERSION}/bombardier-linux-arm64" \
- && chmod +x /usr/local/bin/bombardier \
+RUN arch="$(dpkg --print-architecture)" \
+ && case "$arch" in \
+      arm64) fp_arch=aarch64 ;; \
+      amd64) fp_arch=x86_64 ;; \
+      *) echo "unsupported architecture: $arch" >&2; exit 1 ;; \
+    esac \
+ && curl -fsSL -o /usr/local/bin/bombardier \
+      "https://github.com/codesenberg/bombardier/releases/download/v${BOMBARDIER_VERSION}/bombardier-linux-${arch}" \
  && curl -fsSL -o /usr/local/bin/frankenphp \
-      "https://github.com/php/frankenphp/releases/latest/download/frankenphp-linux-aarch64" \
- && chmod +x /usr/local/bin/frankenphp
+      "https://github.com/php/frankenphp/releases/latest/download/frankenphp-linux-${fp_arch}" \
+ && chmod +x /usr/local/bin/bombardier /usr/local/bin/frankenphp
 
 WORKDIR /work

docker/compose.yml

@@ -12,6 +12,9 @@ services:
       - cargo-registry:/usr/local/cargo/registry
     working_dir: /work
     command: sleep infinity
+    dns:
+      - 1.1.1.1
+      - 8.8.8.8
     security_opt:
       - seccomp=unconfined
     ports:

src/php/engine.rs

@@ -62,30 +62,34 @@ impl Engine {
     }
 
     pub(crate) unsafe fn apply_request_info(&mut self) {
-        let info = unsafe { &mut *(&raw mut sapi_globals.request_info) };
-        info.request_method = self.ctx.method.as_ptr();
-        info.query_string = self.ctx.query.as_ptr() as *mut c_char;
-        info.request_uri = self.ctx.uri.as_ptr() as *mut c_char;
-        info.path_translated = self.ctx.script.as_ptr() as *mut c_char;
-        info.content_length = self.ctx.post.len() as zend_long;
-        info.content_type = match &self.ctx.content_type {
-            Some(t) => t.as_ptr(),
-            None => ptr::null(),
-        };
-        info.proto_num = 1001;
-        info.headers_only = self.ctx.method.as_bytes() == b"HEAD";
-        sapi_globals.server_context = 1 as *mut c_void;
+        let info = &raw mut sapi_globals.request_info;
+        unsafe {
+            (*info).request_method = self.ctx.method.as_ptr();
+            (*info).query_string = self.ctx.query.as_ptr() as *mut c_char;
+            (*info).request_uri = self.ctx.uri.as_ptr() as *mut c_char;
+            (*info).path_translated = self.ctx.script.as_ptr() as *mut c_char;
+            (*info).content_length = self.ctx.post.len() as zend_long;
+            (*info).content_type = match &self.ctx.content_type {
+                Some(t) => t.as_ptr(),
+                None => ptr::null(),
+            };
+            (*info).proto_num = 1001;
+            (*info).headers_only = self.ctx.method.as_bytes() == b"HEAD";
+        }
+        sapi_globals.server_context = std::ptr::dangling_mut::<c_void>();
         sapi_globals.sapi_headers.http_response_code = 200;
     }
 
     pub(crate) unsafe fn clear_request_info(&mut self) {
-        let info = unsafe { &mut *(&raw mut sapi_globals.request_info) };
-        info.request_method = ptr::null();
-        info.query_string = ptr::null_mut();
-        info.request_uri = ptr::null_mut();
-        info.path_translated = ptr::null_mut();
-        info.content_type = ptr::null();
-        info.cookie_data = ptr::null_mut();
+        let info = &raw mut sapi_globals.request_info;
+        unsafe {
+            (*info).request_method = ptr::null();
+            (*info).query_string = ptr::null_mut();
+            (*info).request_uri = ptr::null_mut();
+            (*info).path_translated = ptr::null_mut();
+            (*info).content_type = ptr::null();
+            (*info).cookie_data = ptr::null_mut();
+        }
         sapi_globals.server_context = ptr::null_mut();
     }
 
@@ -109,7 +113,7 @@ impl Engine {
             php_execute_script(&mut handle);
             zend_destroy_file_handle(&mut handle);
 
-            let fatal = (core_globals.last_error_type as i32 & FATAL_ERRORS) != 0;
+            let fatal = (core_globals.last_error_type & FATAL_ERRORS) != 0;
             php_request_shutdown(ptr::null_mut());
             self.clear_request_info();
 

src/php/sapi.rs

@@ -32,7 +32,7 @@ opcache.jit_buffer_size=64M
 pub(crate) fn ini_entries(extra: Option<&str>) -> CString {
     let mut ini = String::from(BASE_INI);
     if let Some(extra) = extra {
-        for entry in extra.split(|c| c == ',' || c == '\n') {
+        for entry in extra.split([',', '\n']) {
             let entry = entry.trim();
             if !entry.is_empty() {
                 ini.push_str(entry);
@@ -52,7 +52,7 @@ pub(crate) fn functions() -> *const zend_function_entry {
         unsafe { std::mem::zeroed() },
         unsafe { std::mem::zeroed() },
     ]));
-    arg_info[0].name = 1 as *const c_char;
+    arg_info[0].name = std::ptr::dangling::<c_char>();
     arg_info[1].name = c"handler".as_ptr();
 
     let mut table: Vec<zend_function_entry> = Vec::with_capacity(NAMES.len() + 1);
@@ -89,7 +89,7 @@ unsafe extern "C" fn ub_write(buf: *const c_char, len: usize) -> usize {
     match ctx() {
         Some(c) => {
             c.out
-                .extend_from_slice(unsafe { slice::from_raw_parts(buf as *const u8, len) });
+                .extend_from_slice(unsafe { slice::from_raw_parts(buf.cast::<u8>(), len) });
             if c.stream.is_some() && c.out.len() >= STREAM_CHUNK {
                 c.flush_stream();
             }
@@ -136,7 +136,7 @@ unsafe extern "C" fn read_post(buf: *mut c_char, count: usize) -> usize {
     let remaining = c.post.len() - c.post_read;
     let n = remaining.min(count);
     if n > 0 {
-        unsafe { ptr::copy_nonoverlapping(c.post.as_ptr().add(c.post_read), buf as *mut u8, n) };
+        unsafe { ptr::copy_nonoverlapping(c.post.as_ptr().add(c.post_read), buf.cast::<u8>(), n) };
         c.post_read += n;
     }
     n

src/php/worker.rs

@@ -159,7 +159,7 @@ unsafe fn install_super_global(
         let slot = &mut core_globals.http_globals[track as usize];
         zval_ptr_dtor_nogc(slot);
         slot.value.arr = array;
-        slot.u1.type_info = IS_ARRAY | ((IS_TYPE_REFCOUNTED as u32) << Z_TYPE_FLAGS_SHIFT);
+        slot.u1.type_info = IS_ARRAY | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT);
 
         let key = zend_string_init(name.as_ptr(), name_str.len(), false);
         zend_hash_update(&raw mut executor_globals.symbol_table, key, slot);
@@ -355,7 +355,7 @@ unsafe fn build_prepared_env(entries: &[(CString, CString)]) -> *mut HashTable {
         let string = unsafe { zend_string_init(value.as_ptr(), value.as_bytes().len(), true) };
         let mut zv: zval = unsafe { std::mem::zeroed() };
         zv.value.str_ = string;
-        zv.u1.type_info = IS_STRING | ((IS_TYPE_REFCOUNTED as u32) << Z_TYPE_FLAGS_SHIFT);
+        zv.u1.type_info = IS_STRING | (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT);
         unsafe { zend_hash_update(array, key, &mut zv) };
     }
     array
@@ -392,14 +392,14 @@ unsafe fn snapshot_super_global(name: &str, skip_request_keys: bool) -> Vec<(CSt
     unsafe { zend_hash_internal_pointer_reset_ex(array, &mut pos) };
 
     loop {
-        let data = unsafe { zend_hash_get_current_data_ex(array, &mut pos) };
+        let data = unsafe { zend_hash_get_current_data_ex(array, &pos) };
         if data.is_null() {
             break;
         }
 
         let mut key: *mut zend_string = ptr::null_mut();
         let mut index: zend_ulong = 0;
-        let kind = unsafe { zend_hash_get_current_key_ex(array, &mut key, &mut index, &mut pos) };
+        let kind = unsafe { zend_hash_get_current_key_ex(array, &mut key, &mut index, &pos) };
 
         if kind == zend_hash_key_type_HASH_KEY_IS_STRING && !key.is_null() {
             let name = unsafe { zend_str(key) };
@@ -430,7 +430,7 @@ unsafe fn zend_str(s: *mut zend_string) -> String {
         return String::new();
     }
     let len = unsafe { (*s).len };
-    let bytes = unsafe { std::slice::from_raw_parts((*s).val.as_ptr() as *const u8, len) };
+    let bytes = unsafe { std::slice::from_raw_parts((*s).val.as_ptr().cast::<u8>(), len) };
     String::from_utf8_lossy(bytes).into_owned()
 }
 
@@ -489,7 +489,7 @@ pub fn handle(engine: &mut Engine, worker: &mut WorkerHandle) -> u16 {
         let ok = php_execute_script(&mut handle);
         zend_destroy_file_handle(&mut handle);
 
-        let fatal = (core_globals.last_error_type as i32 & FATAL_ERRORS) != 0;
+        let fatal = (core_globals.last_error_type & FATAL_ERRORS) != 0;
         let produced = engine.ctx().out.len();
 
         request_shutdown();

src/runtime.rs

@@ -33,11 +33,8 @@ impl Runtime {
 
     pub fn handle(&mut self, mut job: Job) {
         let reply = job.reply.take();
-        match self.respond(&job, reply) {
-            Some((reply, outcome)) => {
-                let _ = reply.send(outcome);
-            }
-            None => {}
+        if let Some((reply, outcome)) = self.respond(&job, reply) {
+            let _ = reply.send(outcome);
         }
     }
 

src/server.rs

@@ -80,7 +80,7 @@ impl Reply {
 /// its own and pays a queue hop per request — measured at a quarter of the throughput, which
 /// is why buffering stays the default.
 enum Sink {
-    Inline(RefCell<Runtime>),
+    Inline(Box<RefCell<Runtime>>),
     Queue(Arc<Dispatcher>),
 }
 
@@ -285,7 +285,7 @@ pub fn run(
             .build()
             .map_err(|e| format!("tokio runtime: {e}"))?;
 
-        SINK.with_borrow_mut(|slot| *slot = Some(Sink::Inline(RefCell::new(runtime))));
+        SINK.with_borrow_mut(|slot| *slot = Some(Sink::Inline(Box::new(RefCell::new(runtime)))));
         let result = tokio_runtime.block_on(accept_loop(socket, tls));
         SINK.with_borrow_mut(|slot| *slot = None);
         return result;