feat: set workspace edition = "2024" rust-version = "1.85.0"

rust 1.85 is the MSRV for edition 2024.

cargo fmt --all reformats many files for 2024.

Manual fix to ngx_container_of! macro for safety rules in 2024, as well
as various conditional and in-macro uses of no_mangle -
these weren't migrated automatically by `cargo fix`

Manual fixes to several other macros that created an &mut Request in an
expression, Rust 2024 is stricter about taking &mut of temporaries, so
instead the request is let-bound first.

Author: pchickey

Cargo.toml

@@ -6,11 +6,11 @@ members = [
 ]
 
 [workspace.package]
-edition = "2021"
+edition = "2024"
 license = "Apache-2.0"
 homepage = "https://github.com/nginx/ngx-rust"
 repository = "https://github.com/nginx/ngx-rust"
-rust-version = "1.81.0"
+rust-version = "1.85.0"
 
 [package]
 name = "ngx"

examples/async.rs

@@ -81,7 +81,7 @@ ngx::ngx_modules!(ngx_http_async_module);
 
 #[used]
 #[allow(non_upper_case_globals)]
-#[cfg_attr(not(feature = "export-modules"), no_mangle)]
+#[cfg_attr(not(feature = "export-modules"), unsafe(no_mangle))]
 pub static mut ngx_http_async_module: ngx_module_t = ngx_module_t {
     ctx: std::ptr::addr_of!(NGX_HTTP_ASYNC_MODULE_CTX) as _,
     commands: unsafe { &NGX_HTTP_ASYNC_COMMANDS[0] as *const _ as *mut _ },
@@ -100,16 +100,16 @@ impl http::Merge for ModuleConfig {
 
 unsafe extern "C" fn check_async_work_done(event: *mut ngx_event_t) {
     let ctx = ngx::ngx_container_of!(event, RequestCTX, event);
-    let c: *mut ngx_connection_t = (*event).data.cast();
+    let c: *mut ngx_connection_t = unsafe { (*event).data.cast() };
 
-    if (*ctx).done.load(Ordering::Relaxed) {
+    if unsafe { (*ctx).done.load(Ordering::Relaxed) } {
         // Triggering async_access_handler again
-        ngx_post_event((*c).write, addr_of_mut!(ngx_posted_events));
+        unsafe { ngx_post_event((*c).write, addr_of_mut!(ngx_posted_events)) };
     } else {
         // this doesn't have have good performance but works as a simple thread-safe example and
         // doesn't causes segfault. The best method that provides both thread-safety and
         // performance requires an nginx patch.
-        ngx_post_event(event, addr_of_mut!(ngx_posted_next_events));
+        unsafe { ngx_post_event(event, addr_of_mut!(ngx_posted_next_events)) };
     }
 }
 

examples/awssig.rs

@@ -112,7 +112,7 @@ ngx::ngx_modules!(ngx_http_awssigv4_module);
 
 #[used]
 #[allow(non_upper_case_globals)]
-#[cfg_attr(not(feature = "export-modules"), no_mangle)]
+#[cfg_attr(not(feature = "export-modules"), unsafe(no_mangle))]
 pub static mut ngx_http_awssigv4_module: ngx_module_t = ngx_module_t {
     ctx: std::ptr::addr_of!(NGX_HTTP_AWSSIGV4_MODULE_CTX) as _,
     commands: unsafe { &NGX_HTTP_AWSSIGV4_COMMANDS[0] as *const _ as *mut _ },

examples/curl.rs

@@ -75,7 +75,7 @@ ngx::ngx_modules!(ngx_http_curl_module);
 
 #[used]
 #[allow(non_upper_case_globals)]
-#[cfg_attr(not(feature = "export-modules"), no_mangle)]
+#[cfg_attr(not(feature = "export-modules"), unsafe(no_mangle))]
 pub static mut ngx_http_curl_module: ngx_module_t = ngx_module_t {
     ctx: std::ptr::addr_of!(NGX_HTTP_CURL_MODULE_CTX) as _,
     commands: unsafe { &NGX_HTTP_CURL_COMMANDS[0] as *const _ as *mut _ },

examples/httporigdst.rs

@@ -1,5 +1,5 @@
 use std::ffi::{c_int, c_void};
-use std::ptr::addr_of;
+use std::ptr::{addr_of, NonNull};
 
 use ngx::core;
 use ngx::ffi::{
@@ -47,29 +47,33 @@ impl NgxHttpOrigDstCtx {
     }
 
     pub unsafe fn bind_addr(&self, v: *mut ngx_variable_value_t) {
+        let mut v = NonNull::new(v).unwrap();
+        let v = unsafe { v.as_mut() };
         if self.orig_dst_addr.len == 0 {
-            (*v).set_not_found(1);
+            v.set_not_found(1);
             return;
         }
 
-        (*v).set_valid(1);
-        (*v).set_no_cacheable(0);
-        (*v).set_not_found(0);
-        (*v).set_len(self.orig_dst_addr.len as u32);
-        (*v).data = self.orig_dst_addr.data;
+        v.set_valid(1);
+        v.set_no_cacheable(0);
+        v.set_not_found(0);
+        v.set_len(self.orig_dst_addr.len as u32);
+        v.data = self.orig_dst_addr.data;
     }
 
     pub unsafe fn bind_port(&self, v: *mut ngx_variable_value_t) {
+        let mut v = NonNull::new(v).unwrap();
+        let v = unsafe { v.as_mut() };
         if self.orig_dst_port.len == 0 {
-            (*v).set_not_found(1);
+            v.set_not_found(1);
             return;
         }
 
-        (*v).set_valid(1);
-        (*v).set_no_cacheable(0);
-        (*v).set_not_found(0);
-        (*v).set_len(self.orig_dst_port.len as u32);
-        (*v).data = self.orig_dst_port.data;
+        v.set_valid(1);
+        v.set_no_cacheable(0);
+        v.set_not_found(0);
+        v.set_len(self.orig_dst_port.len as u32);
+        v.data = self.orig_dst_port.data;
     }
 }
 
@@ -91,7 +95,7 @@ ngx::ngx_modules!(ngx_http_orig_dst_module);
 
 #[used]
 #[allow(non_upper_case_globals)]
-#[cfg_attr(not(feature = "export-modules"), no_mangle)]
+#[cfg_attr(not(feature = "export-modules"), unsafe(no_mangle))]
 pub static mut ngx_http_orig_dst_module: ngx_module_t = ngx_module_t {
     ctx: std::ptr::addr_of!(NGX_HTTP_ORIG_DST_MODULE_CTX) as _,
     commands: std::ptr::null_mut(),
@@ -129,19 +133,21 @@ unsafe fn ngx_get_origdst(
 ) -> Result<(String, in_port_t), core::Status> {
     let c = request.connection();
 
-    if (*c).type_ != libc::SOCK_STREAM {
+    if unsafe { (*c).type_ } != libc::SOCK_STREAM {
         ngx_log_debug_http!(request, "httporigdst: connection is not type SOCK_STREAM");
         return Err(core::Status::NGX_DECLINED);
     }
 
-    if ngx_connection_local_sockaddr(c, std::ptr::null_mut(), 0) != core::Status::NGX_OK.into() {
+    if unsafe { ngx_connection_local_sockaddr(c, std::ptr::null_mut(), 0) }
+        != core::Status::NGX_OK.into()
+    {
         ngx_log_debug_http!(request, "httporigdst: no local sockaddr from connection");
         return Err(core::Status::NGX_ERROR);
     }
 
     let level: c_int;
     let optname: c_int;
-    match (*(*c).local_sockaddr).sa_family as i32 {
+    match unsafe { (*(*c).local_sockaddr).sa_family } as i32 {
         libc::AF_INET => {
             level = libc::SOL_IP;
             optname = libc::SO_ORIGINAL_DST;
@@ -154,13 +160,15 @@ unsafe fn ngx_get_origdst(
 
     let mut addr: sockaddr_storage = { std::mem::zeroed() };
     let mut addrlen: libc::socklen_t = std::mem::size_of_val(&addr) as libc::socklen_t;
-    let rc = libc::getsockopt(
-        (*c).fd,
-        level,
-        optname,
-        &mut addr as *mut _ as *mut _,
-        &mut addrlen as *mut u32,
-    );
+    let rc = unsafe {
+        libc::getsockopt(
+            (*c).fd,
+            level,
+            optname,
+            &mut addr as *mut _ as *mut _,
+            &mut addrlen as *mut u32,
+        )
+    };
     if rc == -1 {
         ngx_log_debug_http!(request, "httporigdst: getsockopt failed");
         return Err(core::Status::NGX_DECLINED);
@@ -192,10 +200,11 @@ unsafe fn ngx_get_origdst(
 http_variable_get!(
     ngx_http_orig_dst_addr_variable,
     |request: &mut http::Request, v: *mut ngx_variable_value_t, _: usize| {
-        let ctx = request.get_module_ctx::<NgxHttpOrigDstCtx>(&*addr_of!(ngx_http_orig_dst_module));
+        let ctx = request
+            .get_module_ctx::<NgxHttpOrigDstCtx>(unsafe { &*addr_of!(ngx_http_orig_dst_module) });
         if let Some(obj) = ctx {
             ngx_log_debug_http!(request, "httporigdst: found context and binding variable",);
-            obj.bind_addr(v);
+            unsafe { obj.bind_addr(v) };
             return core::Status::NGX_OK;
         }
         // lazy initialization:
@@ -204,7 +213,7 @@ http_variable_get!(
         //   set context
         // bind address
         ngx_log_debug_http!(request, "httporigdst: context not found, getting address");
-        let r = ngx_get_origdst(request);
+        let r = unsafe { ngx_get_origdst(request) };
         match r {
             Err(e) => {
                 return e;
@@ -226,10 +235,11 @@ http_variable_get!(
                     ip,
                     port,
                 );
-                (*new_ctx).save(&ip, port, &request.pool());
-                (*new_ctx).bind_addr(v);
-                request
-                    .set_module_ctx(new_ctx as *mut c_void, &*addr_of!(ngx_http_orig_dst_module));
+                unsafe { (*new_ctx).save(&ip, port, &request.pool()) };
+                unsafe { (*new_ctx).bind_addr(v) };
+                request.set_module_ctx(new_ctx as *mut c_void, unsafe {
+                    &*addr_of!(ngx_http_orig_dst_module)
+                });
             }
         }
         core::Status::NGX_OK
@@ -239,10 +249,11 @@ http_variable_get!(
 http_variable_get!(
     ngx_http_orig_dst_port_variable,
     |request: &mut http::Request, v: *mut ngx_variable_value_t, _: usize| {
-        let ctx = request.get_module_ctx::<NgxHttpOrigDstCtx>(&*addr_of!(ngx_http_orig_dst_module));
+        let ctx = request
+            .get_module_ctx::<NgxHttpOrigDstCtx>(unsafe { &*addr_of!(ngx_http_orig_dst_module) });
         if let Some(obj) = ctx {
             ngx_log_debug_http!(request, "httporigdst: found context and binding variable",);
-            obj.bind_port(v);
+            unsafe { obj.bind_port(v) };
             return core::Status::NGX_OK;
         }
         // lazy initialization:
@@ -251,7 +262,7 @@ http_variable_get!(
         //   set context
         // bind port
         ngx_log_debug_http!(request, "httporigdst: context not found, getting address");
-        let r = ngx_get_origdst(request);
+        let r = unsafe { ngx_get_origdst(request) };
         match r {
             Err(e) => {
                 return e;
@@ -273,10 +284,11 @@ http_variable_get!(
                     ip,
                     port,
                 );
-                (*new_ctx).save(&ip, port, &request.pool());
-                (*new_ctx).bind_port(v);
-                request
-                    .set_module_ctx(new_ctx as *mut c_void, &*addr_of!(ngx_http_orig_dst_module));
+                unsafe { (*new_ctx).save(&ip, port, &request.pool()) };
+                unsafe { (*new_ctx).bind_port(v) };
+                request.set_module_ctx(new_ctx as *mut c_void, unsafe {
+                    &*addr_of!(ngx_http_orig_dst_module)
+                });
             }
         }
         core::Status::NGX_OK
@@ -292,13 +304,15 @@ impl HttpModule for Module {
 
     // static ngx_int_t ngx_http_orig_dst_add_variables(ngx_conf_t *cf)
     unsafe extern "C" fn preconfiguration(cf: *mut ngx_conf_t) -> ngx_int_t {
-        for mut v in NGX_HTTP_ORIG_DST_VARS {
-            let var = ngx_http_add_variable(cf, &mut v.name, v.flags);
-            if var.is_null() {
+        for mut v in unsafe { NGX_HTTP_ORIG_DST_VARS } {
+            let var = NonNull::new(unsafe { ngx_http_add_variable(cf, &mut v.name, v.flags) });
+            if var.is_none() {
                 return core::Status::NGX_ERROR.into();
             }
-            (*var).get_handler = v.get_handler;
-            (*var).data = v.data;
+            let mut var = var.unwrap();
+            let var = unsafe { var.as_mut() };
+            var.get_handler = v.get_handler;
+            var.data = v.data;
         }
         core::Status::NGX_OK.into()
     }

examples/shared_dict.rs

@@ -89,7 +89,7 @@ ngx::ngx_modules!(ngx_http_shared_dict_module);
 
 #[used]
 #[allow(non_upper_case_globals)]
-#[cfg_attr(not(feature = "export-modules"), no_mangle)]
+#[cfg_attr(not(feature = "export-modules"), unsafe(no_mangle))]
 pub static mut ngx_http_shared_dict_module: ngx_module_t = ngx_module_t {
     ctx: ptr::addr_of!(NGX_HTTP_SHARED_DICT_MODULE_CTX) as _,
     commands: unsafe { ptr::addr_of_mut!(NGX_HTTP_SHARED_DICT_COMMANDS[0]) },