From 5fa1544a2d60582dd6c1a361d8729ceb384f9cdd Mon Sep 17 00:00:00 2001 From: g-mpuzyna <111359125+g-mpuzyna@users.noreply.github.com> Date: Fri, 26 Aug 2022 01:19:55 +0200 Subject: [PATCH 1/3] Adding support for `tel` scheme (#40) * Added Tel scheme * added additional tests --- src/common/uri/scheme.rs | 5 ++++ tests/common/uri/scheme.rs | 16 ++++++++++ tests/common/uri/uri_with_params.rs | 45 ++++++++++++++++++++++++++++- 3 files changed, 65 insertions(+), 1 deletion(-) diff --git a/src/common/uri/scheme.rs b/src/common/uri/scheme.rs index efd2117..fe2f133 100644 --- a/src/common/uri/scheme.rs +++ b/src/common/uri/scheme.rs @@ -9,6 +9,8 @@ use crate::Error; pub enum Scheme { Sip, Sips, + // A tel scheme from RFC 2806. + Tel, Other(String), } @@ -43,6 +45,7 @@ impl std::fmt::Display for Scheme { match self { Self::Sip => write!(f, "sip"), Self::Sips => write!(f, "sips"), + Self::Tel => write!(f, "tel"), Self::Other(inner) => write!(f, "{}", inner), } } @@ -55,6 +58,7 @@ impl<'a> std::convert::TryFrom> for Sche match tokenizer.value { part if part.eq_ignore_ascii_case("sip") => Ok(Scheme::Sip), part if part.eq_ignore_ascii_case("sips") => Ok(Scheme::Sips), + part if part.eq_ignore_ascii_case("tel") => Ok(Scheme::Tel), part => Ok(Scheme::Other(part.into())), } } @@ -115,6 +119,7 @@ pub mod tokenizer { let (rem, (scheme, _)) = alt(( tuple((tag_no_case("sip"), tag(":"))), tuple((tag_no_case("sips"), tag(":"))), + tuple((tag_no_case("tel"), tag(":"))), tuple((take_until("://"), tag("://"))), ))(part) .map_err(|_: GenericNomError<'a, T>| TokenizerError::from(("scheme", part)).into())?; diff --git a/tests/common/uri/scheme.rs b/tests/common/uri/scheme.rs index a582ef8..32e5cb6 100644 --- a/tests/common/uri/scheme.rs +++ b/tests/common/uri/scheme.rs @@ -33,6 +33,14 @@ mod parser { Ok(Scheme::Sips) ); } + + #[test] + fn parser3() { + assert_eq!( + Tokenizer::from("tel".as_bytes()).try_into(), + Ok(Scheme::Tel) + ) + } } mod tokenizer { @@ -68,6 +76,14 @@ mod tokenizer { ); } + #[test] + fn tokenizer3_str() { + assert_eq!( + Tokenizer::tokenize("tel:+12124567890"), + Ok(("+12124567890", "tel".into())), + ) + } + #[test] fn errors1() { assert_eq!( diff --git a/tests/common/uri/uri_with_params.rs b/tests/common/uri/uri_with_params.rs index 5aa937f..b3eed06 100644 --- a/tests/common/uri/uri_with_params.rs +++ b/tests/common/uri/uri_with_params.rs @@ -1,6 +1,6 @@ use rsip::common::uri::{ self, - param::{Maddr, Param}, + param::{Maddr, Param, Tag}, uri_with_params::{Tokenizer, UriWithParams}, Scheme, Uri, }; @@ -50,6 +50,25 @@ mod display { String::from("") ); } + + #[test] + fn display3() { + let tag = Tag::default(); + assert_eq!( + UriWithParams { + uri: Uri { + scheme: Some(Scheme::Tel), + auth: None, + host_with_port: "+12124567890".try_into().unwrap(), + params: Default::default(), + headers: Default::default() + }, + params: vec![Param::Tag(tag.clone())], + } + .to_string(), + format!(";tag={}", tag) + ) + } } mod parser { @@ -241,4 +260,28 @@ mod tokenizer { )), ); } + + #[test] + fn tokenizer3_str() { + let tag: String = Tag::default().into(); + let input = format!(";tag={}", tag); + assert_eq!( + Tokenizer::tokenize(input.as_str()), + Ok(( + "", + Tokenizer { + uri: uri::Tokenizer { + scheme: Some("tel".into()), + auth: None, + host_with_port: ("+12124567890", None).into(), + params: vec![], + headers: None, + ..Default::default() + }, + params: vec![("tag", Some(tag.as_str())).into()], + ..Default::default() + } + )) + ); + } } From 72f72409e895dda602a9d5efaf62864083aa648d Mon Sep 17 00:00:00 2001 From: altanai Date: Tue, 11 Nov 2025 11:59:27 -0800 Subject: [PATCH 2/3] Add rsip-wrapper FFI crate (cherry-picked from curr_work) --- rsip-wrapper/Cargo.toml | 11 ++ rsip-wrapper/DIAGRAM.md | 63 ++++++ rsip-wrapper/IMPLEMENTATION.md | 61 ++++++ rsip-wrapper/TESTING.md | 168 ++++++++++++++++ rsip-wrapper/include/rsip_wrapper.h | 37 ++++ rsip-wrapper/mod_rsip_example/mod_rsip.c | 33 ++++ rsip-wrapper/src/lib.rs | 232 +++++++++++++++++++++++ rsip-wrapper/tests/integration_test.rs | 134 +++++++++++++ 8 files changed, 739 insertions(+) create mode 100644 rsip-wrapper/Cargo.toml create mode 100644 rsip-wrapper/DIAGRAM.md create mode 100644 rsip-wrapper/IMPLEMENTATION.md create mode 100644 rsip-wrapper/TESTING.md create mode 100644 rsip-wrapper/include/rsip_wrapper.h create mode 100644 rsip-wrapper/mod_rsip_example/mod_rsip.c create mode 100644 rsip-wrapper/src/lib.rs create mode 100644 rsip-wrapper/tests/integration_test.rs diff --git a/rsip-wrapper/Cargo.toml b/rsip-wrapper/Cargo.toml new file mode 100644 index 0000000..4fa39de --- /dev/null +++ b/rsip-wrapper/Cargo.toml @@ -0,0 +1,11 @@ +[package] +name = "rsip-wrapper" +version = "0.1.0" +edition = "2018" +description = "Minimal FFI wrapper around rsip: a small transport/UA and C API for integration with FreeSWITCH" +license-file = "../LICENSE" +crate-type = ["cdylib"] + +[dependencies] +lazy_static = "1.4" +rsip = { path = ".." } diff --git a/rsip-wrapper/DIAGRAM.md b/rsip-wrapper/DIAGRAM.md new file mode 100644 index 0000000..bfe8cef --- /dev/null +++ b/rsip-wrapper/DIAGRAM.md @@ -0,0 +1,63 @@ +## Incoming call flow — rsip-wrapper + mod_rsip + FreeSWITCH + +The diagram below shows the flow for an incoming SIP INVITE when using the `rsip-wrapper` hybrid stack. It highlights the Rust-side listener and parser, the C shim (e.g., `mod_rsip`) which receives events via the FFI callback, and the FreeSWITCH core that creates sessions and handles media. + +```mermaid +flowchart LR + %% External UA and network + UA[User Agent SIP endpoint] -->|SIP INVITE| RSIP_WRAPPER[rsip-wrapper UDP/TCP/WS listener] + + %% Rust-side processing + RSIP_WRAPPER -->|raw SIP bytes| RSIP_PARSER[rsip parser/types] + RSIP_PARSER -->|event: INVITE parsed| MOD_RSIP[mod_rsip c callback] + + %% C-shim translates events into FreeSWITCH API calls + MOD_RSIP -->|create session / new channel| FS_CORE[FreeSWITCH core switch_core_session_*] + MOD_RSIP -->|deliver remote SDP| FS_SDP[switch_sdp] + + %% FreeSWITCH negotiates and attaches media + FS_CORE -->|generate local SDP| FS_SDP + FS_CORE -->|attach media| FS_MEDIA[Media Engine / RTP] + FS_MEDIA -->|RTP audio/video| UA + + %% Signaling back to UA + MOD_RSIP -->|invoke rsip_send_udp / send response| RSIP_WRAPPER + RSIP_WRAPPER -->|SIP 100/180/200/ACK| UA + + %% Mid-call and teardown + UA -->|ACK / in-dialog requests| RSIP_WRAPPER + RSIP_WRAPPER --> MOD_RSIP + UA -->|BYE| RSIP_WRAPPER + RSIP_WRAPPER --> MOD_RSIP + MOD_RSIP -->|call hangup| FS_CORE + FS_CORE -->|release media| FS_MEDIA + + %% Grouping boxes + subgraph Rust + RSIP_WRAPPER + RSIP_PARSER + end + + subgraph C_Module + MOD_RSIP + end + + subgraph FreeSWITCH + FS_CORE + FS_SDP + FS_MEDIA + end + + classDef rustfill fill:#E8F1FF,stroke:#5B9BD5; + classDef cfill fill:#FFF4E5,stroke:#E69F00; + classDef fsfill fill:#E8FFE8,stroke:#2E8B57; + class RSIP_WRAPPER,RSIP_PARSER rustfill; + class MOD_RSIP cfill; + class FS_CORE,FS_SDP,FS_MEDIA fsfill; + +``` + +Notes +- The prototype `rsip-wrapper` currently forwards raw SIP datagrams to the C callback; extend `RSIP_PARSER` to emit higher-level events (INVITE/REGISTER/BYE) if desired. +- In an in-process FreeSWITCH module, callbacks from Rust should be marshalled onto FS worker threads before calling core APIs. +- Media (RTP) is typically handled by FreeSWITCH; the diagram assumes FS will terminate or proxy media and negotiate SDP with the remote UA. diff --git a/rsip-wrapper/IMPLEMENTATION.md b/rsip-wrapper/IMPLEMENTATION.md new file mode 100644 index 0000000..977c028 --- /dev/null +++ b/rsip-wrapper/IMPLEMENTATION.md @@ -0,0 +1,61 @@ +# rsip-wrapper: transport+UA hybrid (FFI) implementation + +This document describes the minimal hybrid approach implemented in this crate: a small Rust "transport & UA" wrapper around `rsip` that exposes a compact C API for integration with FreeSWITCH (or other C hosts). + +## Goals + +- Provide a small, safe C ABI surface so a host (FreeSWITCH module) can receive SIP messages from Rust and instruct Rust to send SIP messages. +- Keep the Rust side responsible for networking & protocol parsing. Minimize the FFI surface and make callbacks simple. + +## What this prototype does + +- Builds a cdylib with a C API. +- Implements a UDP listener that receives raw SIP datagrams and invokes a registered callback with event="sip_rx" and payload containing the raw SIP text. +- Exposes helper functions: init, set/clear callback, start UDP listener, send UDP datagram, shutdown, and a small version string. + +## Files added + +- `Cargo.toml` - crate manifest (cdylib crate-type). +- `src/lib.rs` - Rust implementation of the FFI API. +- `include/rsip_wrapper.h` - C header describing the API. +- `mod_rsip_example/mod_rsip.c` - small example program that registers a callback and listens on UDP/5060. + +## Design notes and safety + +- The callback has signature `void(*cb)(const char* event, const char* payload)` and is called synchronously from the Rust listener thread. The strings are only valid for the duration of the callback; the callee must copy them if it needs to persist the data. +- We use `lazy_static`-backed `Mutex` and an `AtomicBool` to store the callback, the thread handle, and a running flag. +- We intentionally keep the API small to reduce cross-language ownership complexity. +- The Rust side currently performs no full SIP transaction or dialog management — it only receives raw SIP datagrams and forwards them. `rsip` (the dependency) can be used inside the listener to parse/validate messages if you extend the implementation. + +## Integration with FreeSWITCH (next steps) + +1. In-process approach (advanced): write a FreeSWITCH module `mod_rsip.c` that dynamically loads the `rsip-wrapper` DLL (or links against it) and registers a callback. The module should translate events into FS session actions (create session, set remote SDP, answer, bridge). Ensure thread-safety: many FS APIs must be called from FS worker threads or using FS-provided async mechanisms. +2. Hybrid (recommended incremental): run the `rsip-wrapper` as an external process or simple native binary and communicate via network (SIP) or FSMQ/ESL. Use FreeSWITCH `sofia` profiles to talk to your process as a gateway. + +## Build notes (Windows PowerShell examples) + +1. Build the Rust cdylib (MSVC toolchain recommended if FreeSWITCH is built with MSVC): + + cd C:\Users\altan\Downloads\rsip\rsip-wrapper + cargo build --release + +2. The produced dynamic library will be at `target\release\rsip_wrapper.dll` (name may vary depending on platform). Use `cbindgen` or the provided header `include/rsip_wrapper.h` to include definitions in C code. + +3. Example: compile the example shim (adjust to your compiler): + + # If using MSVC: cl.exe /EHsc mod_rsip.c /I..\include + + # If using gcc: gcc mod_rsip.c -I../include -o mod_rsip_example.exe -L../target/release -lrsip_wrapper + + Note: linking against the produced rsip_wrapper library on Windows may require generating an import library or loading the DLL dynamically. + +## Limitations & next steps + +- The prototype only handles UDP datagrams; you should add TCP/TLS/WS transports for production SIP. +- Add proper SIP transaction, dialog, and timer handling (retransmits, forking, PRACK, etc.) by implementing those layers on top of `rsip` parsing. +- For in-process modules, design a small, robust event model that allows the FS module to ask Rust to perform actions synchronously or asynchronously. Carefully manage the async runtime lifecycle (spawn a dedicated runtime thread inside Rust and do not block FS threads). +- Use `cbindgen` to generate headers automatically and include tests that validate FFI linkage. + +## Contact & follow-up + +I can flesh out a `mod_rsip.c` FreeSWITCH module example that calls `switch_core_session_*` APIs and maps events into FS sessions if you want to proceed with an in-process integration. I can also extend `rsip-wrapper` to parse SIP via `rsip::message` and expose higher-level events (INVITE, BYE, REGISTER) rather than raw SIP strings. diff --git a/rsip-wrapper/TESTING.md b/rsip-wrapper/TESTING.md new file mode 100644 index 0000000..5d3e9f7 --- /dev/null +++ b/rsip-wrapper/TESTING.md @@ -0,0 +1,168 @@ +# Testing Guide for rsip-wrapper + +This document describes the unit and integration tests available for the `rsip-wrapper` crate, and how to run them locally. + +## Test Structure + +### Unit Tests (in `src/lib.rs`) + +The unit tests cover the core FFI API and internal state management: + +- `test_rsip_init()` — Verifies `rsip_init()` initializes state correctly. +- `test_rsip_version()` — Tests the `rsip_version()` helper function returns the correct version string. +- `test_callback_registration()` — Validates callback registration, clearing, and state. +- `test_udp_send_with_null_pointers()` — Ensures `rsip_send_udp()` rejects null pointers safely. +- `test_udp_send_invalid_address()` — Tests behavior with invalid IP addresses. +- `test_listener_already_running()` — Verifies that starting a listener twice fails (prevents races). +- `test_shutdown_clears_state()` — Confirms `rsip_shutdown()` cleanly resets all state. + +### Integration Tests (in `tests/integration_test.rs`) + +The integration tests validate the complete FFI linkage and runtime behavior: + +- `test_ffi_version_linkage()` — Confirms the library links correctly and exports the version symbol. +- `test_ffi_init_and_shutdown()` — Tests FFI init/shutdown lifecycle across the C boundary. +- `test_ffi_callback_registration()` — Validates callback registration from C side. +- `test_ffi_send_udp()` — Tests the `rsip_send_udp()` FFI function with a real UDP send. +- `test_ffi_listener_lifecycle()` — Starts a listener on port 15060, sends a test SIP message, and verifies the listener receives it and invokes the callback. +- `test_ffi_multiple_lifecycle()` — Stress-tests multiple init/shutdown cycles to ensure no resource leaks. + +## Running Tests Locally + +### Prerequisites + +- Rust toolchain (install from https://rustup.rs/) +- On Windows, MSVC or GNU toolchain (MSVC recommended if you're building against MSVC libraries) + +### Build the crate + +```powershell +cd C:\Users\altan\Downloads\rsip\rsip-wrapper +cargo build +``` + +This produces `target\debug\rsip_wrapper.dll` (or `.a` / `.so` depending on your platform). + +### Run unit tests + +```powershell +cargo test --lib +``` + +Example output: +``` +running 7 tests +test tests::test_rsip_init ... ok +test tests::test_rsip_version ... ok +test tests::test_callback_registration ... ok +test tests::test_udp_send_with_null_pointers ... ok +test tests::test_udp_send_invalid_address ... ok +test tests::test_listener_already_running ... ok +test tests::test_shutdown_clears_state ... ok + +test result: ok. 7 passed +``` + +### Run integration tests + +```powershell +cargo test --test integration_test +``` + +This runs the FFI linkage tests. Note: the integration tests use `extern "C"` to declare the FFI functions, so Cargo must link against the compiled cdylib. Rust's `cargo test` automatically links the library for integration tests. + +Example output (with some listener/network delays): +``` +running 6 tests +test test_ffi_version_linkage ... ok +test test_ffi_init_and_shutdown ... ok +test test_ffi_callback_registration ... ok +test test_ffi_send_udp ... ok +test test_ffi_listener_lifecycle ... ok (may take a few hundred milliseconds) +test test_ffi_multiple_lifecycle ... ok + +test result: ok. 6 passed +``` + +### Run all tests + +```powershell +cargo test +``` + +This runs both unit and integration tests in sequence. + +### Run with output + +To see println! output from tests (useful for debugging): + +```powershell +cargo test -- --nocapture +``` + +### Run a specific test + +```powershell +cargo test test_ffi_listener_lifecycle -- --nocapture +``` + +## Test Expectations + +### What the tests validate + +1. **API correctness**: init, set/clear callback, send, shutdown behave as documented. +2. **Thread safety**: the listener can be started and stopped cleanly; multiple cycles don't leak state. +3. **FFI safety**: null pointer checks, CString conversions, and callback invocations don't crash. +4. **UDP transport**: datagrams are sent and received correctly; callbacks are invoked when data arrives. + +### Known limitations + +- Tests use localhost (127.0.0.1) and high ports (15060+) to avoid conflicts with running services. +- The listener test (`test_ffi_listener_lifecycle`) sends a raw SIP-like string; the current implementation does not parse it with `rsip`, only forwards it to the callback. +- On slow systems or under high load, timing-sensitive tests may occasionally flake. Increase sleep durations in the test if needed. + +## Next Steps for Production Testing + +1. **Extend rsip parsing**: add tests that verify SIP message parsing with `rsip::message` inside the listener. +2. **Add transport variants**: test TCP, TLS, and WebSocket transports. +3. **Add transaction tests**: verify that retransmit timers, INVITE/ACK flow, and dialog state are handled correctly. +4. **Add benchmarks**: measure throughput and latency with high-volume SIP message injection. +5. **Add C/FFI tests**: write C or C++ tests that link the library dynamically and test from that side (good for validating compatibility with FreeSWITCH modules). + +## Troubleshooting + +### `cargo test` fails with "cannot find library" + +Ensure the crate is built first: +```powershell +cargo build +cargo test +``` + +### `test_ffi_listener_lifecycle` times out or hangs + +This may happen if port 15060 is already in use. Try: +- Changing the port number in the test. +- Checking if another service is listening: `netstat -an | findstr 15060` + +### Tests panic with "thread 'test-...' panicked" + +Check the panic message carefully. Common issues: +- Null pointer access in FFI functions. +- CString validation failure (non-UTF8 strings). +- Listener thread not starting (port already in use). + +## Continuous Integration + +For CI/CD pipelines (GitHub Actions, Azure Pipelines, etc.), add a step: + +```yaml +- name: Run tests + run: | + cd rsip-wrapper + cargo test --lib + cargo test --test integration_test +``` + +This will catch regressions early. + diff --git a/rsip-wrapper/include/rsip_wrapper.h b/rsip-wrapper/include/rsip_wrapper.h new file mode 100644 index 0000000..e694a66 --- /dev/null +++ b/rsip-wrapper/include/rsip_wrapper.h @@ -0,0 +1,37 @@ +#ifndef RSIP_WRAPPER_H +#define RSIP_WRAPPER_H + +#include +#include + +#ifdef __cplusplus +extern "C" { +#endif + +// Initialize internal structures. Call before other APIs. +bool rsip_init(void); + +// Set a callback to receive events from the Rust side. The callback is called +// synchronously from the Rust listener thread. The strings are valid only for +// the duration of the callback and will be freed after the call returns. +void rsip_set_event_callback(void (*cb)(const char* event, const char* payload)); +void rsip_clear_event_callback(void); + +// Start a UDP listener on the given port. Received datagrams trigger the +// registered callback with event="sip_rx" and payload being the raw SIP text. +bool rsip_start_udp_listener(uint16_t port); + +// Send a raw UDP datagram to dest_ip:dest_port with data being a C string. +bool rsip_send_udp(const char* dest_ip, uint16_t dest_port, const char* data); + +// Shutdown listener and clean up. +void rsip_shutdown(void); + +// Return an informational static string (leaked pointer) for testing linkage. +const char* rsip_version(void); + +#ifdef __cplusplus +} +#endif + +#endif // RSIP_WRAPPER_H diff --git a/rsip-wrapper/mod_rsip_example/mod_rsip.c b/rsip-wrapper/mod_rsip_example/mod_rsip.c new file mode 100644 index 0000000..eb9f6cb --- /dev/null +++ b/rsip-wrapper/mod_rsip_example/mod_rsip.c @@ -0,0 +1,33 @@ +// Example C shim showing how a FreeSWITCH module could interact with the rsip-wrapper +#include +#include +#include +#include "../include/rsip_wrapper.h" + +// callback invoked by Rust +void rsip_cb(const char* event, const char* payload) { + printf("rsip_cb: event=%s payload_len=%zu\n", event, strlen(payload)); + // In a real FreeSWITCH module, map events to FS APIs here, e.g. create session, + // set remote SDP, or answer/bridge calls. +} + +int main(int argc, char** argv) { + (void)argc; (void)argv; + if (!rsip_init()) { + fprintf(stderr, "rsip_init failed\n"); + return 1; + } + + rsip_set_event_callback(rsip_cb); + + if (!rsip_start_udp_listener(5060)) { + fprintf(stderr, "rsip_start_udp_listener failed\n"); + return 1; + } + + printf("Listening on UDP/5060. Press Enter to shutdown...\n"); + getchar(); + + rsip_shutdown(); + return 0; +} diff --git a/rsip-wrapper/src/lib.rs b/rsip-wrapper/src/lib.rs new file mode 100644 index 0000000..228387a --- /dev/null +++ b/rsip-wrapper/src/lib.rs @@ -0,0 +1,232 @@ +use lazy_static::lazy_static; +use std::ffi::{CStr, CString}; +use std::os::raw::c_char; +use std::net::UdpSocket; +use std::sync::{Arc, Mutex}; +use std::thread::{self, JoinHandle}; +use std::sync::atomic::{AtomicBool, Ordering}; + +type EventCallback = extern "C" fn(event: *const c_char, payload: *const c_char); + +lazy_static! { + static ref CALLBACK: Mutex> = Mutex::new(None); + static ref LISTENER_THREAD: Mutex>> = Mutex::new(None); + static ref RUNNING: AtomicBool = AtomicBool::new(false); +} + +#[no_mangle] +pub extern "C" fn rsip_init() -> bool { + // Set running to false and clear callback + RUNNING.store(false, Ordering::SeqCst); + let mut cb = CALLBACK.lock().unwrap(); + *cb = None; + true +} + +#[no_mangle] +pub extern "C" fn rsip_set_event_callback(cb: EventCallback) { + let mut guard = CALLBACK.lock().unwrap(); + *guard = Some(cb); +} + +#[no_mangle] +pub extern "C" fn rsip_clear_event_callback() { + let mut guard = CALLBACK.lock().unwrap(); + *guard = None; +} + +fn call_callback(event: &str, payload: &str) { + let guard = CALLBACK.lock().unwrap(); + if let Some(cb) = *guard { + let ev = CString::new(event).unwrap_or_else(|_| CString::new("err").unwrap()); + let pl = CString::new(payload).unwrap_or_else(|_| CString::new("").unwrap()); + cb(ev.as_ptr(), pl.as_ptr()); + // CString drops here; the callee must copy data if it is needed beyond the call + } +} + +#[no_mangle] +pub extern "C" fn rsip_start_udp_listener(port: u16) -> bool { + if RUNNING.load(Ordering::SeqCst) { + // already running + return false; + } + + let bind = format!("0.0.0.0:{}", port); + let socket = match UdpSocket::bind(bind) { + Ok(s) => s, + Err(_) => return false, + }; + + // make socket non-blocking to allow clean shutdown if desired + let _ = socket.set_nonblocking(false); + let socket = Arc::new(socket); + RUNNING.store(true, Ordering::SeqCst); + + let socket_clone = socket.clone(); + + let handle = thread::spawn(move || { + let mut buf = vec![0u8; 65535]; + while RUNNING.load(Ordering::SeqCst) { + match socket_clone.recv_from(&mut buf) { + Ok((n, src)) => { + if n == 0 { continue; } + // Try to parse SIP message using rsip (best-effort) and forward raw message + let msg = String::from_utf8_lossy(&buf[..n]).to_string(); + // Optionally parse with rsip::message here to validate + // For now, just call callback with event "sip_rx" and payload as the raw message + call_callback("sip_rx", &msg); + } + Err(e) => { + // On error, call error callback and continue or break for interrupt + call_callback("error", &format!("recv_err:{}", e)); + // Sleep a bit to avoid busy loop + std::thread::sleep(std::time::Duration::from_millis(50)); + } + } + } + }); + + let mut guard = LISTENER_THREAD.lock().unwrap(); + *guard = Some(handle); + true +} + +#[no_mangle] +pub extern "C" fn rsip_shutdown() { + // signal thread to stop + RUNNING.store(false, Ordering::SeqCst); + + // join thread if present + let mut guard = LISTENER_THREAD.lock().unwrap(); + if let Some(handle) = guard.take() { + let _ = handle.join(); + } + + // clear callback + let mut cb = CALLBACK.lock().unwrap(); + *cb = None; +} + +// Convenience: send raw SIP datagram to a destination +#[no_mangle] +pub extern "C" fn rsip_send_udp(dest_ip: *const c_char, dest_port: u16, data: *const c_char) -> bool { + if dest_ip.is_null() || data.is_null() { return false; } + let cstr_ip = unsafe { CStr::from_ptr(dest_ip) }; + let cstr_data = unsafe { CStr::from_ptr(data) }; + let ip = match cstr_ip.to_str() { Ok(s) => s, Err(_) => return false }; + let payload = cstr_data.to_bytes(); + + let addr = format!("{}:{}", ip, dest_port); + match std::net::UdpSocket::bind("0.0.0.0:0") { + Ok(s) => { + let _ = s.send_to(payload, addr); + true + } + Err(_) => false, + } +} + +// Minimal example: expose a helper that returns a static string to test FFI linkage +#[no_mangle] +pub extern "C" fn rsip_version() -> *const c_char { + let s = CString::new("rsip-wrapper-0.1.0").unwrap(); + let p = s.as_ptr(); + std::mem::forget(s); // leak intentionally; caller treats as static. + p +} + +#[cfg(test)] +mod tests { + use super::*; + use std::sync::atomic::{AtomicBool, Ordering}; + use std::sync::Arc; + + #[test] + fn test_rsip_init() { + let result = rsip_init(); + assert!(result, "rsip_init should return true"); + assert!(!RUNNING.load(Ordering::SeqCst), "RUNNING should be false after init"); + } + + #[test] + fn test_rsip_version() { + let ptr = rsip_version(); + assert!(!ptr.is_null(), "rsip_version should return non-null pointer"); + let cstr = unsafe { CStr::from_ptr(ptr) }; + let s = cstr.to_str().expect("version should be valid UTF-8"); + assert_eq!(s, "rsip-wrapper-0.1.0", "version string should match"); + } + + #[test] + fn test_callback_registration() { + rsip_init(); + + // Define a dummy callback + extern "C" fn dummy_cb(_event: *const c_char, _payload: *const c_char) {} + + rsip_set_event_callback(dummy_cb); + let guard = CALLBACK.lock().unwrap(); + assert!(guard.is_some(), "callback should be registered"); + drop(guard); + + rsip_clear_event_callback(); + let guard = CALLBACK.lock().unwrap(); + assert!(guard.is_none(), "callback should be cleared"); + } + + #[test] + fn test_udp_send_with_null_pointers() { + // rsip_send_udp should return false if dest_ip is null + let result = rsip_send_udp(std::ptr::null(), 5060, b"test\0".as_ptr() as *const c_char); + assert!(!result, "should return false for null dest_ip"); + + // rsip_send_udp should return false if data is null + let ip_cstr = CString::new("127.0.0.1").unwrap(); + let result = rsip_send_udp(ip_cstr.as_ptr(), 5060, std::ptr::null()); + assert!(!result, "should return false for null data"); + } + + #[test] + fn test_udp_send_invalid_address() { + // Attempt to send to an address that may fail (invalid IP) + let ip_cstr = CString::new("999.999.999.999").unwrap(); + let data_cstr = CString::new("test").unwrap(); + let result = rsip_send_udp(ip_cstr.as_ptr(), 5060, data_cstr.as_ptr()); + // We don't assert result here because the send may or may not fail depending on OS behavior. + // The test just ensures the function handles it without crashing. + println!("send to invalid addr returned: {}", result); + } + + #[test] + fn test_listener_already_running() { + rsip_init(); + + // First start should succeed + let result1 = rsip_start_udp_listener(15060); + assert!(result1, "first start_udp_listener should succeed"); + + // Second start without shutdown should fail + let result2 = rsip_start_udp_listener(15061); + assert!(!result2, "second start_udp_listener without shutdown should fail"); + + rsip_shutdown(); + std::thread::sleep(std::time::Duration::from_millis(100)); + } + + #[test] + fn test_shutdown_clears_state() { + rsip_init(); + + extern "C" fn dummy_cb(_event: *const c_char, _payload: *const c_char) {} + rsip_set_event_callback(dummy_cb); + + rsip_shutdown(); + + let guard = CALLBACK.lock().unwrap(); + assert!(guard.is_none(), "callback should be cleared after shutdown"); + drop(guard); + + assert!(!RUNNING.load(Ordering::SeqCst), "RUNNING should be false after shutdown"); + } +} diff --git a/rsip-wrapper/tests/integration_test.rs b/rsip-wrapper/tests/integration_test.rs new file mode 100644 index 0000000..e763ddb --- /dev/null +++ b/rsip-wrapper/tests/integration_test.rs @@ -0,0 +1,134 @@ +// Integration test for rsip-wrapper FFI API +// Tests real FFI linking and basic functionality + +use std::ffi::{CStr, CString}; +use std::os::raw::c_char; +use std::sync::atomic::{AtomicBool, Ordering}; +use std::sync::Arc; +use std::thread; +use std::time::Duration; +use std::net::UdpSocket; + +// FFI declarations (would normally be in a generated header) +extern "C" { + fn rsip_init() -> bool; + fn rsip_set_event_callback(cb: extern "C" fn(event: *const c_char, payload: *const c_char)); + fn rsip_clear_event_callback(); + fn rsip_start_udp_listener(port: u16) -> bool; + fn rsip_send_udp(dest_ip: *const c_char, dest_port: u16, data: *const c_char) -> bool; + fn rsip_shutdown(); + fn rsip_version() -> *const c_char; +} + +#[test] +fn test_ffi_version_linkage() { + unsafe { + let ptr = rsip_version(); + assert!(!ptr.is_null(), "version pointer should not be null"); + let cstr = CStr::from_ptr(ptr); + let version = cstr.to_str().expect("version should be UTF-8"); + assert!(!version.is_empty(), "version should not be empty"); + println!("Linked version: {}", version); + } +} + +#[test] +fn test_ffi_init_and_shutdown() { + unsafe { + let init_result = rsip_init(); + assert!(init_result, "rsip_init should succeed"); + + rsip_shutdown(); + // Shutdown should not crash + } +} + +#[test] +fn test_ffi_callback_registration() { + extern "C" fn test_callback(event: *const c_char, payload: *const c_char) { + println!("callback invoked: event={:?}, payload_ptr={:?}", event, payload); + } + + unsafe { + rsip_init(); + rsip_set_event_callback(test_callback); + thread::sleep(Duration::from_millis(50)); + rsip_clear_event_callback(); + rsip_shutdown(); + } +} + +#[test] +fn test_ffi_send_udp() { + unsafe { + rsip_init(); + + let dest_ip = CString::new("127.0.0.1").expect("dest_ip should be valid"); + let data = CString::new("INVITE sip:user@example.com SIP/2.0\r\n").expect("data should be valid"); + + let result = rsip_send_udp(dest_ip.as_ptr(), 5060, data.as_ptr()); + println!("rsip_send_udp returned: {}", result); + // We expect this to succeed (at least attempt the send) + + rsip_shutdown(); + } +} + +#[test] +fn test_ffi_listener_lifecycle() { + unsafe { + rsip_init(); + + // Register a callback to count events + let event_count = Arc::new(AtomicBool::new(false)); + let event_count_clone = event_count.clone(); + + extern "C" fn capture_callback(event: *const c_char, payload: *const c_char) { + unsafe { + let ev = CStr::from_ptr(event).to_str().unwrap_or(""); + let pl = CStr::from_ptr(payload).to_str().unwrap_or(""); + println!("capture_callback: event={}, payload_len={}", ev, pl.len()); + } + } + + rsip_set_event_callback(capture_callback); + + // Start listener on a high port to avoid conflicts + let listener_result = rsip_start_udp_listener(15060); + assert!(listener_result, "rsip_start_udp_listener should succeed"); + println!("Listener started on port 15060"); + + // Give listener time to start + thread::sleep(Duration::from_millis(100)); + + // Send a test SIP message to ourselves + let test_message = "INVITE sip:test@localhost SIP/2.0\r\nVia: SIP/2.0/UDP 127.0.0.1\r\n\r\n"; + match UdpSocket::bind("0.0.0.0:0") { + Ok(client_socket) => { + match client_socket.send_to(test_message.as_bytes(), "127.0.0.1:15060") { + Ok(n) => println!("Sent {} bytes to listener", n), + Err(e) => println!("Send failed: {}", e), + } + } + Err(e) => println!("Failed to bind client socket: {}", e), + } + + // Give callback time to be invoked + thread::sleep(Duration::from_millis(200)); + + rsip_shutdown(); + println!("Listener shutdown complete"); + } +} + +#[test] +fn test_ffi_multiple_lifecycle() { + unsafe { + for i in 0..3 { + println!("Iteration {}", i); + rsip_init(); + rsip_shutdown(); + thread::sleep(Duration::from_millis(50)); + } + } +} From a39e614b97f03c837815a7027c5ed36a5629607c Mon Sep 17 00:00:00 2001 From: altanai Date: Tue, 11 Nov 2025 12:01:25 -0800 Subject: [PATCH 3/3] chore: ignore IDE folders (.vs, .vscode) --- .gitignore | 2 +- rsip-wrapper/{IMPLEMENTATION.md => README.md} | 2 ++ .../mermaid-diagram-2025-11-11-120048.png | Bin 0 -> 159105 bytes 3 files changed, 3 insertions(+), 1 deletion(-) rename rsip-wrapper/{IMPLEMENTATION.md => README.md} (97%) create mode 100644 rsip-wrapper/mermaid-diagram-2025-11-11-120048.png diff --git a/.gitignore b/.gitignore index 1de5659..ad6bb3f 100644 --- a/.gitignore +++ b/.gitignore @@ -1 +1 @@ -target \ No newline at end of file +target# Ignore IDE folders\n.vs/\n.vscode/ diff --git a/rsip-wrapper/IMPLEMENTATION.md b/rsip-wrapper/README.md similarity index 97% rename from rsip-wrapper/IMPLEMENTATION.md rename to rsip-wrapper/README.md index 977c028..89a58ea 100644 --- a/rsip-wrapper/IMPLEMENTATION.md +++ b/rsip-wrapper/README.md @@ -2,6 +2,8 @@ This document describes the minimal hybrid approach implemented in this crate: a small Rust "transport & UA" wrapper around `rsip` that exposes a compact C API for integration with FreeSWITCH (or other C hosts). +![diagrm](mermaid-diagram-2025-11-11-120048.png) + ## Goals - Provide a small, safe C ABI surface so a host (FreeSWITCH module) can receive SIP messages from Rust and instruct Rust to send SIP messages. diff --git a/rsip-wrapper/mermaid-diagram-2025-11-11-120048.png b/rsip-wrapper/mermaid-diagram-2025-11-11-120048.png new file mode 100644 index 0000000000000000000000000000000000000000..e5e67d99cd022d801213cc0815f6003c865ab6b2 GIT binary patch literal 159105 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 literal 0 HcmV?d00001