Struct Connection

pub struct Connection { /* private fields */ }

Manages a TCP connection to a SIP server and handles message sending and receiving.

Implementations

impl Connection

pub fn new(sip_host: &str) -> Result<Self, Error>

Creates a new SIP client and opens the TCP connection to the server

• sip_host - SIP server host/ip and port
• E.g. “127.0.0.1:6001”

use sip2::Connection;
assert_eq!(Connection::new("JUNK0+..-*z$@").is_err(), true);

Examples found in repository

examples/basic.rs (line 5)

fn main() {
    // Connect to our SIP server
    let mut con = Connection::new("127.0.0.1:6001").expect("should connect");

    // Manually create a login message
    let req = Message::from_values("93", &["0", "0"], &[("CN", "sip-user"), ("CO", "sip-pass")])
        .expect("should be valid message content");

    // Send the message and wait for a response.
    let resp = con.sendrecv(&req).expect("should receive a response");

    println!("resp: {resp:?}");

    // A successful login returns a first fixed field value of "1".
    if let Some(ff) = resp.fixed_fields().first() {
        if ff.value() == "1" {
            println!("Login succeeded");
        }
    }
}

pub fn from_stream(tcp_stream: TcpStream) -> Self

Create a new SIP connection from an existing TCP stream.

pub fn set_log_prefix(&mut self, prefix: impl Into<String>)

Add a string that will be prepended to all log:: calls where a self exists.

pub fn set_ascii(&mut self, ascii: bool)

Set the ascii flag

pub fn disconnect(&self) -> Result<(), Error>

Shutdown the TCP connection with the SIP server.

pub fn send(&mut self, msg: &Message) -> Result<(), Error>

Send a SIP message

pub fn send_with_timeout( &mut self, msg: &Message, timeout: u64, ) -> Result<(), Error>

Send a message with a write timeout.

Returns Err() if the send/write times out. Clears the TCP socket timeout upon completion.

pub fn recv(&mut self) -> Result<Message, Error>

Receive a SIP response.

Blocks until a response is received.

pub fn recv_with_timeout( &mut self, timeout: u64, ) -> Result<Option<Message>, Error>

Receive a message, waiting at most timeout seconds. Clears the TCP socket timeout upon completion.

pub fn sendrecv(&mut self, msg: &Message) -> Result<Message, Error>

Shortcut for: self.send(msg); resp = self.recv();

Examples found in repository

examples/basic.rs (line 12)

fn main() {
    // Connect to our SIP server
    let mut con = Connection::new("127.0.0.1:6001").expect("should connect");

    // Manually create a login message
    let req = Message::from_values("93", &["0", "0"], &[("CN", "sip-user"), ("CO", "sip-pass")])
        .expect("should be valid message content");

    // Send the message and wait for a response.
    let resp = con.sendrecv(&req).expect("should receive a response");

    println!("resp: {resp:?}");

    // A successful login returns a first fixed field value of "1".
    if let Some(ff) = resp.fixed_fields().first() {
        if ff.value() == "1" {
            println!("Login succeeded");
        }
    }
}

Trait Implementations

impl Display for Connection

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.