Struct BindRequest 

pub struct BindRequest {
    pub sequence_number: u32,
    pub mode: BindMode,
    pub system_id: String,
    pub password: String,
    pub system_type: String,
    pub interface_version: u8,
    pub addr_ton: Ton,
    pub addr_npi: Npi,
    pub address_range: String,
}

Represents a Bind Request PDU (Receiver, Transmitter, or Transceiver).

This PDU is used to initiate a session with the SMSC.

Fields

sequence_number: u32

mode: BindMode

system_id: String

password: String

system_type: String

interface_version: u8

addr_ton: Ton

addr_npi: Npi

address_range: String

Implementations

impl BindRequest

pub fn new( sequence_number: u32, mode: BindMode, system_id: String, password: String, ) -> Self

Create a new Bind Request with defaults.

Examples

use smpp_codec::pdus::BindRequest;
use smpp_codec::common::BindMode;

let sequence_number: u32 = 1;
let bind_req = BindRequest::new(
    sequence_number,
    BindMode::Transceiver,
    "system_id".to_string(),
    "password".to_string(),
);

Examples found in repository

examples/bind_transceiver.rs (lines 8-13)

fn main() {
    println!("=== SMPP Bind Transceiver Example ===");

    // 1. Create a BindTransceiver Request
    let bind_req = BindRequest::new(
        1, // Sequence Number
        BindMode::Transceiver,
        "my_system_id".to_string(),
        "password".to_string(),
    )
    .with_address_range(Ton::International, Npi::Isdn, "12345".to_string());

    println!("Created PDU: {:?}", bind_req);

    // 2. Encode into bytes
    let mut buffer = Vec::new();
    match bind_req.encode(&mut buffer) {
        Ok(_) => {
            println!("Encoded successfully! {} bytes", buffer.len());
            print!("Hex encoded: ");
            for byte in &buffer {
                print!("{:02X} ", byte);
            }
            println!();
        }
        Err(e) => {
            eprintln!("Failed to encode: {:?}", e);
        }
    }
}

pub fn with_address_range(self, ton: Ton, npi: Npi, range: String) -> Self

Examples found in repository

examples/bind_transceiver.rs (line 14)

fn main() {
    println!("=== SMPP Bind Transceiver Example ===");

    // 1. Create a BindTransceiver Request
    let bind_req = BindRequest::new(
        1, // Sequence Number
        BindMode::Transceiver,
        "my_system_id".to_string(),
        "password".to_string(),
    )
    .with_address_range(Ton::International, Npi::Isdn, "12345".to_string());

    println!("Created PDU: {:?}", bind_req);

    // 2. Encode into bytes
    let mut buffer = Vec::new();
    match bind_req.encode(&mut buffer) {
        Ok(_) => {
            println!("Encoded successfully! {} bytes", buffer.len());
            print!("Hex encoded: ");
            for byte in &buffer {
                print!("{:02X} ", byte);
            }
            println!();
        }
        Err(e) => {
            eprintln!("Failed to encode: {:?}", e);
        }
    }
}

pub fn encode(&self, writer: &mut impl Write) -> Result<(), PduError>

Encode the struct into raw bytes for the network.

Errors

Returns a PduError if:

• system_id exceeds 16 characters.
• password exceeds 9 characters.
• system_type exceeds 13 characters.
• address_range exceeds 41 characters.
• An I/O error occurs while writing.

Examples

let mut buffer = Vec::new();
bind_req.encode(&mut buffer).expect("Encoding failed");

Examples found in repository

examples/bind_transceiver.rs (line 20)

fn main() {
    println!("=== SMPP Bind Transceiver Example ===");

    // 1. Create a BindTransceiver Request
    let bind_req = BindRequest::new(
        1, // Sequence Number
        BindMode::Transceiver,
        "my_system_id".to_string(),
        "password".to_string(),
    )
    .with_address_range(Ton::International, Npi::Isdn, "12345".to_string());

    println!("Created PDU: {:?}", bind_req);

    // 2. Encode into bytes
    let mut buffer = Vec::new();
    match bind_req.encode(&mut buffer) {
        Ok(_) => {
            println!("Encoded successfully! {} bytes", buffer.len());
            print!("Hex encoded: ");
            for byte in &buffer {
                print!("{:02X} ", byte);
            }
            println!();
        }
        Err(e) => {
            eprintln!("Failed to encode: {:?}", e);
        }
    }
}

pub fn decode(buffer: &[u8]) -> Result<Self, PduError>

Decode raw bytes from the network into the struct.

Errors

Returns a PduError if:

• The buffer is too short to contain a valid header.
• The command ID does not correspond to a Bind Request.
• The buffer data is malformed.

Examples

let decoded = BindRequest::decode(&buffer).expect("Decoding failed");
assert_eq!(decoded.system_id, "id");

Trait Implementations

impl Clone for BindRequest

fn clone(&self) -> BindRequest

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for BindRequest

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

Formats the value using the given formatter.