// client.go SMPP 客户端(Day 34):bind_transceiver 握手、enquire_link 周期保活、 // submit_sm 在途窗口流控(令牌;窗口满时按超时等待)、deliver_sm 接收(自动回 resp)。 package smpp import ( "context" "errors" "fmt" "net" "sync" "sync/atomic" "time" ) // ErrBindRejected 绑定被拒。 var ErrBindRejected = errors.New("smpp: 网关拒绝绑定") // ErrWindowFull 流控窗口满(等待令牌超时)。 var ErrWindowFull = errors.New("smpp: 流控窗口已满(在途 submit 达上限)") // Config 客户端配置。 type Config struct { Addr string SystemID string Password string WindowSize int // 在途 submit 上限(默认 10;≤0 取默认) HeartbeatInterval time.Duration // enquire_link 周期(默认 30s) WindowWait time.Duration // 窗口满等待时长(默认 3s) Timeout time.Duration // bind/应答超时(默认 5s) } func (c *Config) withDefaults() { if c.WindowSize <= 0 { c.WindowSize = 10 } if c.HeartbeatInterval <= 0 { c.HeartbeatInterval = 30 * time.Second } if c.WindowWait <= 0 { c.WindowWait = 3 * time.Second } if c.Timeout <= 0 { c.Timeout = 5 * time.Second } } // Client SMPP 客户端。 type Client struct { cfg Config mu sync.Mutex conn net.Conn seq atomic.Uint32 done atomic.Bool window chan struct{} // 在途令牌(容量=WindowSize) pending sync.Map // seq -> chan submitResult hbCh chan struct{} // OnDeliver 下发回调(上行/回执;自动回 deliver_sm_resp)。 OnDeliver func(d *Deliver) OnHeartbeat func() } // submitResult submit 应答。 type submitResult struct { messageID string status Status } // NewClient 构造。 func NewClient(cfg Config) *Client { cfg.withDefaults() return &Client{ cfg: cfg, window: make(chan struct{}, cfg.WindowSize), hbCh: make(chan struct{}, 1), } } // nextSeq 自增流水号。 func (c *Client) nextSeq() uint32 { return c.seq.Add(1) } // Connect 建立 TCP + bind_transceiver(status=OK)。 func (c *Client) Connect(ctx context.Context) error { d := net.Dialer{Timeout: c.cfg.Timeout} conn, err := d.DialContext(ctx, "tcp", c.cfg.Addr) if err != nil { return fmt.Errorf("smpp: 连接网关失败: %w", err) } bind := &Bind{SystemID: c.cfg.SystemID, Password: c.cfg.Password, SystemType: "SMPP"} seq := c.nextSeq() if err := WritePDU(conn, &Header{CommandID: CmdBindTransceiver, SequenceNo: seq}, bind.Marshal()); err != nil { _ = conn.Close() return err } _ = conn.SetReadDeadline(time.Now().Add(c.cfg.Timeout)) h, body, err := ReadPDU(conn) _ = conn.SetReadDeadline(time.Time{}) if err != nil { _ = conn.Close() return fmt.Errorf("smpp: 读取 bind_resp 失败: %w", err) } if h.CommandID != CmdBindTransceiverResp { _ = conn.Close() return fmt.Errorf("smpp: 期望 bind_resp 实际 cmd=0x%08x", uint32(h.CommandID)) } if h.Status != StatusOK { _ = conn.Close() return fmt.Errorf("%w: status=0x%08x", ErrBindRejected, uint32(h.Status)) } _, _ = ParseBindResp(body) // system_id(诊断用) c.mu.Lock() c.conn = conn c.mu.Unlock() go c.readLoop(conn) return nil } // readLoop 常驻读循环:enquire_link_resp→心跳信号;submit_sm_resp→pending 分发; // deliver_sm→解析+自动回 resp+回调;enquire_link(网关探测)→应答;unbind→回应并退出。 func (c *Client) readLoop(conn net.Conn) { for { h, body, err := ReadPDU(conn) if err != nil { return } switch h.CommandID { case CmdEnquireLinkResp: select { case c.hbCh <- struct{}{}: default: } case CmdSubmitSMResp: if v, ok := c.pending.LoadAndDelete(h.SequenceNo); ok { if ch, ok := v.(chan submitResult); ok { id, _ := ParseSubmitResp(body) select { case ch <- submitResult{messageID: id, status: h.Status}: default: } } } case CmdDeliverSM: d, err := ParseDeliver(body) if err != nil { continue // 坏包跳过 } _ = WritePDU(conn, &Header{CommandID: CmdDeliverSMResp, SequenceNo: h.SequenceNo, Status: StatusOK}, nil) if c.OnDeliver != nil { c.OnDeliver(d) } case CmdEnquireLink: // 网关主动探测 _ = WritePDU(conn, &Header{CommandID: CmdEnquireLinkResp, SequenceNo: h.SequenceNo, Status: StatusOK}, nil) case CmdUnbind: _ = WritePDU(conn, &Header{CommandID: CmdUnbindResp, SequenceNo: h.SequenceNo, Status: StatusOK}, nil) _ = conn.Close() return } } } // heartbeat 发一次 enquire_link 并等应答(链路探测保活)。 func (c *Client) heartbeat() error { c.mu.Lock() conn := c.conn c.mu.Unlock() if conn == nil { return errors.New("smpp: 未连接") } seq := c.nextSeq() select { // 清历史信号 case <-c.hbCh: default: } if err := WritePDU(conn, &Header{CommandID: CmdEnquireLink, SequenceNo: seq}, nil); err != nil { return fmt.Errorf("smpp: enquire 发送失败: %w", err) } select { case <-c.hbCh: return nil case <-time.After(c.cfg.Timeout): return errors.New("smpp: enquire 应答超时") } } // Keepalive 周期 enquire_link 保活;失败返回(链路失效)。 func (c *Client) Keepalive(ctx context.Context) error { t := time.NewTicker(c.cfg.HeartbeatInterval) defer t.Stop() for { select { case <-ctx.Done(): return ctx.Err() case <-t.C: if err := c.heartbeat(); err != nil { _ = c.Close() return err } if c.OnHeartbeat != nil { c.OnHeartbeat() } } } } // Submit 提交短消息:流控窗口限速(在途令牌)→ 发 submit_sm → 等配对 resp。 // 验收:窗口满时阻塞等待(WindowWait 超时返回 ErrWindowFull)。 func (c *Client) Submit(req *SubmitReq) (string, Status, error) { c.mu.Lock() conn := c.conn c.mu.Unlock() if conn == nil { return "", 0, errors.New("smpp: 未连接") } // 流控:取在途令牌(窗口满则等待) select { case c.window <- struct{}{}: default: select { case c.window <- struct{}{}: case <-time.After(c.cfg.WindowWait): return "", 0, ErrWindowFull } } defer func() { <-c.window }() // 完成归还令牌 seq := c.nextSeq() ch := make(chan submitResult, 1) c.pending.Store(seq, ch) defer c.pending.Delete(seq) if err := WritePDU(conn, &Header{CommandID: CmdSubmitSM, SequenceNo: seq}, req.Marshal()); err != nil { return "", 0, fmt.Errorf("smpp: submit 发送失败: %w", err) } select { case r := <-ch: return r.messageID, r.status, nil case <-time.After(c.cfg.Timeout): return "", 0, errors.New("smpp: submit_resp 超时") } } // Close 关闭连接。 func (c *Client) Close() error { c.done.Store(true) c.mu.Lock() conn := c.conn c.conn = nil c.mu.Unlock() if conn != nil { return conn.Close() } return nil }