python-plugin: RAII (PyOwned/PyBorrowed) + autodecode enum; crate: ny-llvmc --emit exe with NyRT link; tools: build_llvm.sh crate-exe path + crate_exe_smoke; CURRENT_TASK update

plugins/nyash-net-plugin/src/ffi.rs

@@ -0,0 +1,19 @@
+use std::ffi::CStr;
+use std::os::raw::c_char;
+
+// Safe wrapper: convert C string pointer to owned String.
+// Safety details are contained within; caller gets a safe String.
+pub fn cstr_to_string(ptr: *const c_char) -> String {
+    if ptr.is_null() {
+        return String::new();
+    }
+    unsafe { CStr::from_ptr(ptr) }
+        .to_string_lossy()
+        .into_owned()
+}
+
+// Re-export a safe view over a raw byte slice pointer.
+// This function is unsafe since it trusts the pointer/length.
+pub unsafe fn slice<'a>(p: *const u8, len: usize) -> &'a [u8] {
+    std::slice::from_raw_parts(p, len)
+}

plugins/nyash-net-plugin/src/state.rs

@@ -0,0 +1,78 @@
+use once_cell::sync::Lazy;
+use std::collections::HashMap;
+use std::sync::{
+    atomic::{AtomicU32, Ordering},
+    Mutex,
+};
+
+use super::{
+    ClientState, RequestState, ResponseState, ServerState, SockClientState, SockConnState,
+    SockServerState,
+};
+
+pub(crate) static SERVER_INSTANCES: Lazy<Mutex<HashMap<u32, ServerState>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+pub(crate) static SERVER_START_SEQ: AtomicU32 = AtomicU32::new(1);
+pub(crate) static ACTIVE_SERVER_ID: Lazy<Mutex<Option<u32>>> = Lazy::new(|| Mutex::new(None));
+pub(crate) static LAST_ACCEPTED_REQ: Lazy<Mutex<Option<u32>>> = Lazy::new(|| Mutex::new(None));
+pub(crate) static REQUESTS: Lazy<Mutex<HashMap<u32, RequestState>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+pub(crate) static RESPONSES: Lazy<Mutex<HashMap<u32, ResponseState>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+pub(crate) static CLIENTS: Lazy<Mutex<HashMap<u32, ClientState>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+
+pub(crate) static SERVER_ID: AtomicU32 = AtomicU32::new(1);
+pub(crate) static REQUEST_ID: AtomicU32 = AtomicU32::new(1);
+pub(crate) static RESPONSE_ID: AtomicU32 = AtomicU32::new(1);
+pub(crate) static CLIENT_ID: AtomicU32 = AtomicU32::new(1);
+pub(crate) static SOCK_SERVER_ID: AtomicU32 = AtomicU32::new(1);
+pub(crate) static SOCK_CONN_ID: AtomicU32 = AtomicU32::new(1);
+pub(crate) static SOCK_CLIENT_ID: AtomicU32 = AtomicU32::new(1);
+
+pub(crate) static SOCK_SERVERS: Lazy<Mutex<HashMap<u32, SockServerState>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+pub(crate) static SOCK_CONNS: Lazy<Mutex<HashMap<u32, SockConnState>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+pub(crate) static SOCK_CLIENTS: Lazy<Mutex<HashMap<u32, SockClientState>>> =
+    Lazy::new(|| Mutex::new(HashMap::new()));
+
+#[inline]
+pub(crate) fn next_server_id() -> u32 {
+    SERVER_ID.fetch_add(1, Ordering::Relaxed)
+}
+
+#[inline]
+pub(crate) fn next_server_start_seq() -> u32 {
+    SERVER_START_SEQ.fetch_add(1, Ordering::Relaxed)
+}
+
+#[inline]
+pub(crate) fn next_request_id() -> u32 {
+    REQUEST_ID.fetch_add(1, Ordering::Relaxed)
+}
+
+#[inline]
+pub(crate) fn next_response_id() -> u32 {
+    RESPONSE_ID.fetch_add(1, Ordering::Relaxed)
+}
+
+#[inline]
+pub(crate) fn next_client_id() -> u32 {
+    CLIENT_ID.fetch_add(1, Ordering::Relaxed)
+}
+
+#[inline]
+pub(crate) fn next_sock_server_id() -> u32 {
+    SOCK_SERVER_ID.fetch_add(1, Ordering::Relaxed)
+}
+
+#[inline]
+pub(crate) fn next_sock_conn_id() -> u32 {
+    SOCK_CONN_ID.fetch_add(1, Ordering::Relaxed)
+}
+
+#[inline]
+pub(crate) fn next_sock_client_id() -> u32 {
+    SOCK_CLIENT_ID.fetch_add(1, Ordering::Relaxed)
+}

plugins/nyash-net-plugin/src/tlv.rs

@@ -0,0 +1,181 @@
+use super::{E_INV_ARGS, E_SHORT, OK};
+
+#[inline]
+fn tlv_result_size(payloads: &[(u8, &[u8])]) -> usize {
+    4 + payloads.iter().map(|(_, p)| 4 + p.len()).sum::<usize>()
+}
+
+#[inline]
+pub fn ensure_result_capacity(res: *mut u8, res_len: *mut usize, need: usize) -> Result<(), i32> {
+    if res_len.is_null() {
+        return Err(E_INV_ARGS);
+    }
+    unsafe {
+        if res.is_null() || *res_len < need {
+            *res_len = need;
+            return Err(E_SHORT);
+        }
+    }
+    Ok(())
+}
+
+#[inline]
+unsafe fn write_bytes_unchecked(bytes: &[u8], res: *mut u8, res_len: *mut usize) {
+    std::ptr::copy_nonoverlapping(bytes.as_ptr(), res, bytes.len());
+    *res_len = bytes.len();
+}
+
+pub fn write_u32(v: u32, res: *mut u8, res_len: *mut usize) -> i32 {
+    let bytes = v.to_le_bytes();
+    if let Err(err) = ensure_result_capacity(res, res_len, bytes.len()) {
+        return err;
+    }
+    unsafe {
+        write_bytes_unchecked(&bytes, res, res_len);
+    }
+    OK
+}
+
+pub fn write_tlv_result(payloads: &[(u8, &[u8])], res: *mut u8, res_len: *mut usize) -> i32 {
+    let need = tlv_result_size(payloads);
+    if let Err(err) = ensure_result_capacity(res, res_len, need) {
+        return err;
+    }
+    let mut buf = Vec::with_capacity(need);
+    buf.extend_from_slice(&1u16.to_le_bytes());
+    buf.extend_from_slice(&(payloads.len() as u16).to_le_bytes());
+    for (tag, p) in payloads {
+        buf.push(*tag);
+        buf.push(0);
+        buf.extend_from_slice(&(p.len() as u16).to_le_bytes());
+        buf.extend_from_slice(p);
+    }
+    unsafe {
+        write_bytes_unchecked(&buf, res, res_len);
+    }
+    OK
+}
+
+pub fn write_tlv_void(res: *mut u8, res_len: *mut usize) -> i32 {
+    write_tlv_result(&[(9u8, &[])], res, res_len)
+}
+pub fn write_tlv_string(s: &str, res: *mut u8, res_len: *mut usize) -> i32 {
+    write_tlv_result(&[(6u8, s.as_bytes())], res, res_len)
+}
+pub fn write_tlv_bytes(b: &[u8], res: *mut u8, res_len: *mut usize) -> i32 {
+    write_tlv_result(&[(7u8, b)], res, res_len)
+}
+pub fn write_tlv_i32(v: i32, res: *mut u8, res_len: *mut usize) -> i32 {
+    write_tlv_result(&[(2u8, &v.to_le_bytes())], res, res_len)
+}
+pub fn write_tlv_handle(t: u32, id: u32, res: *mut u8, res_len: *mut usize) -> i32 {
+    let mut payload = [0u8; 8];
+    payload[0..4].copy_from_slice(&t.to_le_bytes());
+    payload[4..8].copy_from_slice(&id.to_le_bytes());
+    write_tlv_result(&[(8u8, &payload)], res, res_len)
+}
+
+pub fn tlv_parse_header(data: &[u8]) -> Result<(u16, u16, usize), ()> {
+    if data.len() < 4 {
+        return Err(());
+    }
+    let ver = u16::from_le_bytes([data[0], data[1]]);
+    let argc = u16::from_le_bytes([data[2], data[3]]);
+    if ver != 1 {
+        return Err(());
+    }
+    Ok((ver, argc, 4))
+}
+pub fn tlv_parse_string(data: &[u8]) -> Result<String, ()> {
+    let (_, argc, pos) = tlv_parse_header(data)?;
+    if argc < 1 {
+        return Err(());
+    }
+    let (tag, size, p) = tlv_parse_entry_hdr(data, pos)?;
+    if tag != 6 {
+        return Err(());
+    }
+    Ok(std::str::from_utf8(&data[p..p + size])
+        .map_err(|_| ())?
+        .to_string())
+}
+pub fn tlv_parse_two_strings(data: &[u8]) -> Result<(String, String), ()> {
+    let (_, argc, mut pos) = tlv_parse_header(data)?;
+    if argc < 2 {
+        return Err(());
+    }
+    let (tag1, size1, p1) = tlv_parse_entry_hdr(data, pos)?;
+    if tag1 != 6 {
+        return Err(());
+    }
+    let s1 = std::str::from_utf8(&data[p1..p1 + size1])
+        .map_err(|_| ())?
+        .to_string();
+    pos = p1 + size1;
+    let (tag2, size2, p2) = tlv_parse_entry_hdr(data, pos)?;
+    if tag2 != 6 {
+        return Err(());
+    }
+    let s2 = std::str::from_utf8(&data[p2..p2 + size2])
+        .map_err(|_| ())?
+        .to_string();
+    Ok((s1, s2))
+}
+pub fn tlv_parse_bytes(data: &[u8]) -> Result<Vec<u8>, ()> {
+    let (_, argc, pos) = tlv_parse_header(data)?;
+    if argc < 1 {
+        return Err(());
+    }
+    let (tag, size, p) = tlv_parse_entry_hdr(data, pos)?;
+    if tag != 6 && tag != 7 {
+        return Err(());
+    }
+    Ok(data[p..p + size].to_vec())
+}
+pub fn tlv_parse_i32(data: &[u8]) -> Result<i32, ()> {
+    let (_, argc, pos) = tlv_parse_header(data)?;
+    if argc < 1 {
+        return Err(());
+    }
+    let (tag, size, p) = tlv_parse_entry_hdr(data, pos)?;
+    match (tag, size) {
+        (2, 4) => {
+            let mut b = [0u8; 4];
+            b.copy_from_slice(&data[p..p + 4]);
+            Ok(i32::from_le_bytes(b))
+        }
+        (5, 8) => {
+            let mut b = [0u8; 8];
+            b.copy_from_slice(&data[p..p + 8]);
+            Ok(i64::from_le_bytes(b) as i32)
+        }
+        _ => Err(()),
+    }
+}
+pub fn tlv_parse_handle(data: &[u8]) -> Result<(u32, u32), ()> {
+    let (_, argc, pos) = tlv_parse_header(data)?;
+    if argc < 1 {
+        return Err(());
+    }
+    let (tag, size, p) = tlv_parse_entry_hdr(data, pos)?;
+    if tag != 8 || size != 8 {
+        return Err(());
+    }
+    let mut t = [0u8; 4];
+    let mut i = [0u8; 4];
+    t.copy_from_slice(&data[p..p + 4]);
+    i.copy_from_slice(&data[p + 4..p + 8]);
+    Ok((u32::from_le_bytes(t), u32::from_le_bytes(i)))
+}
+pub fn tlv_parse_entry_hdr(data: &[u8], pos: usize) -> Result<(u8, usize, usize), ()> {
+    if pos + 4 > data.len() {
+        return Err(());
+    }
+    let tag = data[pos];
+    let size = u16::from_le_bytes([data[pos + 2], data[pos + 3]]) as usize;
+    let p = pos + 4;
+    if p + size > data.len() {
+        return Err(());
+    }
+    Ok((tag, size, p))
+}