教你用Rust实现Smpp协议

本文分享自华为云社区《华为云短信服务教你用Rust实现Smpp协议》，作者： 张俭。
协议概述

SMPP(Short Message Peer-to-Peer)协议起源于90年代，最初由Aldiscon公司开发，后来由SMPP开发者论坛维护和推广。SMPP常用于在SMSC（Short Message Service Center，短信中心）和短信应用之间传输短消息，支持高效的短信息发送、接收和查询功能，是电信运营商和短信服务提供商之间互通短信的主要协议之一。
SMPP协议基于客户端/服务端模型工作。由客户端（短信应用，如手机，应用程序等）先和SMSC建立起TCP长连接，并使用SMPP命令与SMSC进行交互，实现短信的发送和接收。在SMPP协议中，无需同步等待响应就可以发送下一个指令，实现者可以根据自己的需要，实现同步、异步两种消息传输模式，满足不同场景下的性能要求。
时序图

绑定transmitter模式，发送短信并查询短信发送成功


绑定receiver模式，从SMSC接收到短信


协议帧介绍


在SMPP协议中，每个PDU都包含两个部分：SMPP Header和SMPP Body。
SMPP Header

Header包含以下字段，大小长度都是4字节：

• Command Length：整个PDU的长度，包括Header和Body。
  
• Command ID：用于标识PDU的类型（例如，BindReceiver、QuerySM等）。
  
• Command Status：响应状态码，表示处理的结果。
  
• Sequence Number：序列号，用来匹配请求和响应。
  

用Rust实现SMPP协议栈里的BindTransmitter

本文的代码均已上传到smpp-rust
选用Tokio作为基础的异步运行时环境，tokio有非常强大的异步IO支持，也是rust库的事实标准。
代码结构组织如下:

1. ├── lib.rs
2. ├── const.rs
3. ├── protocol.rs
4. ├── smpp_client.rs
5. └── smpp_server.rs

复制代码

• lib.rs Rust项目的入口点
  
• const.rs 包含常量定义，如commandId、状态码等
  
• protocol.rs 包含PDU定义，编解码处理等
  
• smpp_client.rs 实现smpp客户端逻辑
  
• smpp_server.rs 实现
  

利用rust原子类实现sequence_number

sequence_number是从1到0x7FFFFFFF的值，利用Rust的AtomicI32来生成这个值。

1. use std::sync::atomic::{AtomicI32, Ordering};
2. use std::num::TryFromIntError;
4. struct BoundAtomicInt {
5.     min: i32,
6.     max: i32,
7.     integer: AtomicI32,
8. }
10. impl BoundAtomicInt {
11.     pub fn new(min: i32, max: i32) -> Self {
12.         assert!(min <= max, "min must be less than or equal to max");
13.         Self {
14.             min,
15.             max,
16.             integer: AtomicI32::new(min),
17.         }
18.     }
20.     pub fn next_val(&self) -> Result<i32, TryFromIntError> {
21.         let next = self.integer.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| {
22.             Some(if x >= self.max { self.min } else { x + 1 })
23.         })?;
24.         Ok(next)
25.     }
26. }

复制代码

在Rust中定义SMPP PDU

1. pub struct SmppPdu {
2.     pub header: SmppHeader,
3.     pub body: SmppBody,
4. }
6. pub struct SmppHeader {
7.     pub command_length: i32,
8.     pub command_id: i32,
9.     pub command_status: i32,
10.     pub sequence_number: i32,
11. }
13. pub enum SmppBody {
14.     BindReceiver(BindReceiver),
15.     BindReceiverResp(BindReceiverResp),
16.     BindTransmitter(BindTransmitter),
17.     BindTransmitterResp(BindTransmitterResp),
18.     QuerySm(QuerySm),
19.     QuerySmResp(QuerySmResp),
20.     SubmitSm(SubmitSm),
21.     SubmitSmResp(SubmitSmResp),
22.     DeliverSm(DeliverSm),
23.     DeliverSmResp(DeliverSmResp),
24.     Unbind(Unbind),
25.     UnbindResp(UnbindResp),
26.     ReplaceSm(ReplaceSm),
27.     ReplaceSmResp(ReplaceSmResp),
28.     CancelSm(CancelSm),
29.     CancelSmResp(CancelSmResp),
30.     BindTransceiver(BindTransceiver),
31.     BindTransceiverResp(BindTransceiverResp),
32.     Outbind(Outbind),
33.     EnquireLink(EnquireLink),
34.     EnquireLinkResp(EnquireLinkResp),
35.     SubmitMulti(SubmitMulti),
36.     SubmitMultiResp(SubmitMultiResp),
37. }

复制代码

实现编解码方法

1. impl SmppPdu {
2.     pub fn encode(&self) -> Vec<u8> {
3.         let mut body_buf = match &self.body {
4.             SmppBody::BindTransmitter(bind_transmitter) => bind_transmitter.encode(),
5.             _ => unimplemented!(),
6.         };
8.         let command_length = (body_buf.len() + 16) as i32;
9.         let header = SmppHeader {
10.             command_length,
11.             command_id: self.header.command_id,
12.             command_status: self.header.command_status,
13.             sequence_number: self.header.sequence_number,
14.         };
16.         let mut buf = header.encode();
17.         buf.append(&mut body_buf);
18.         buf
19.     }
21.     pub fn decode(buf: &[u8]) -> io::Result<Self> {
22.         let header = SmppHeader::decode(&buf[0..16])?;
23.         let body = match header.command_id {
24.             constant::BIND_TRANSMITTER_RESP_ID => SmppBody::BindTransmitterResp(BindTransmitterResp::decode(&buf[16..])?),
25.             _ => unimplemented!(),
26.         };
27.         Ok(SmppPdu { header, body })
28.     }
29. }
31. impl SmppHeader {
32.     pub(crate) fn encode(&self) -> Vec<u8> {
33.         let mut buf = vec![];
34.         buf.extend_from_slice(&self.command_length.to_be_bytes());
35.         buf.extend_from_slice(&self.command_id.to_be_bytes());
36.         buf.extend_from_slice(&self.command_status.to_be_bytes());
37.         buf.extend_from_slice(&self.sequence_number.to_be_bytes());
38.         buf
39.     }
41.     pub(crate) fn decode(buf: &[u8]) -> io::Result<Self> {
42.         if buf.len() < 16 {
43.             return Err(io::Error::new(io::ErrorKind::InvalidData, "Buffer too short for SmppHeader"));
44.         }
45.         let command_id = u32::from_be_bytes(buf[0..4].try_into().unwrap());
46.         let command_status = i32::from_be_bytes(buf[4..8].try_into().unwrap());
47.         let sequence_number = i32::from_be_bytes(buf[8..12].try_into().unwrap());
48.         Ok(SmppHeader {
49.             command_length: 0,
50.             command_id,
51.             command_status,
52.             sequence_number,
53.         })
54.     }
55. }
57. impl BindTransmitter {
58.     pub(crate) fn encode(&self) -> Vec<u8> {
59.         let mut buf = vec![];
60.         write_cstring(&mut buf, &self.system_id);
61.         write_cstring(&mut buf, &self.password);
62.         write_cstring(&mut buf, &self.system_type);
63.         buf.push(self.interface_version);
64.         buf.push(self.addr_ton);
65.         buf.push(self.addr_npi);
66.         write_cstring(&mut buf, &self.address_range);
67.         buf
68.     }
70.     pub(crate) fn decode(buf: &[u8]) -> io::Result<Self> {
71.         let mut offset = 0;
72.         let system_id = read_cstring(buf, &mut offset)?;
73.         let password = read_cstring(buf, &mut offset)?;
74.         let system_type = read_cstring(buf, &mut offset)?;
75.         let interface_version = buf[offset];
76.         offset += 1;
77.         let addr_ton = buf[offset];
78.         offset += 1;
79.         let addr_npi = buf[offset];
80.         offset += 1;
81.         let address_range = read_cstring(buf, &mut offset)?;
83.         Ok(BindTransmitter {
84.             system_id,
85.             password,
86.             system_type,
87.             interface_version,
88.             addr_ton,
89.             addr_npi,
90.             address_range,
91.         })
92.     }
93. }

复制代码

实现同步的bind_transmitter方法

1. pub async fn bind_transmitter(
2.         &mut self,
3.         bind_transmitter: BindTransmitter,
4.     ) -> io::Result<BindTransmitterResp> {
5.         if let Some(stream) = &mut self.stream {
6.             let sequence_number = self.sequence_number.next_val();
7.             let pdu = SmppPdu {
8.                 header: SmppHeader {
9.                     command_length: 0,
10.                     command_id: constant::BIND_TRANSMITTER_ID,
11.                     command_status: 0,
12.                     sequence_number,
13.                 },
14.                 body: SmppBody::BindTransmitter(bind_transmitter),
15.             };
16.             let encoded_request = pdu.encode();
17.             stream.write_all(&encoded_request).await?;
19.             let mut length_buf = [0u8; 4];
20.             stream.read_exact(&mut length_buf).await?;
21.             let msg_length = u32::from_be_bytes(length_buf) as usize - 4;
23.             let mut msg_buf = vec![0u8; msg_length];
24.             stream.read_exact(&mut msg_buf).await?;
26.             let response = SmppPdu::decode(&msg_buf)?;
27.             if response.header.command_status != 0 {
28.                 Err(io::Error::new(
29.                     io::ErrorKind::Other,
30.                     format!("Error response: {:?}", response.header.command_status),
31.                 ))
32.             } else {
33.                 // Assuming response.body is of type BindTransmitterResp
34.                 match response.body {
35.                     SmppBody::BindTransmitterResp(resp) => Ok(resp),
36.                     _ => Err(io::Error::new(io::ErrorKind::InvalidData, "Unexpected response body")),
37.                 }
38.             }
39.         } else {
40.             Err(io::Error::new(io::ErrorKind::NotConnected, "Not connected"))
41.         }
42.     }

复制代码

运行example，验证连接成功

1. use smpp_rust::protocol::BindTransmitter;
2. use smpp_rust::smpp_client::SmppClient;
4. #[tokio::main]
5. async fn main() -> Result<(), Box<dyn std::error::Error>> {
6.     let mut client = SmppClient::new("127.0.0.1", 2775);
7.     client.connect().await?;
8.     let bind_transmitter = BindTransmitter{
9.         system_id: "system_id".to_string(),
10.         password: "password".to_string(),
11.         system_type: "system_type".to_string(),
12.         interface_version: 0x34,
13.         addr_ton: 0,
14.         addr_npi: 0,
15.         address_range: "".to_string(),
16.     };
17.     client.bind_transmitter(bind_transmitter).await?;
18.     client.close().await?;
19.     Ok(())
20. }

复制代码

相关开源项目

• netty-codec-sms 存放各种SMS协议（如cmpp、sgip、smpp）的netty编解码器
  
• sms-client-java 存放各种SMS协议的Java客户端
  
• sms-server-java 存放各种SMS协议的Java服务端
  
• smpp-rust smpp协议的rust实现
  

总结

本文简单对SMPP协议进行了介绍，并尝试用rust实现协议栈，但实际商用发送短信往往更加复杂，面临诸如流控、运营商对接、传输层安全等问题，可以选择华为云消息&短信（Message & SMS）服务，华为云短信服务是华为云携手全球多家优质运营商和渠道，为企业用户提供的通信服务。企业调用API或使用群发助手，即可使用验证码、通知短信服务。
 
点击关注，第一时间了解华为云新鲜技术~
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！