gocmpp

To start a CMMP server, use the cmpp.ListenAndServe function. This function sets up a TCP listener, manages connection lifecycles, and handles active testing (heartbeats).

Parameters

• addr: The TCP address to listen on (e.g., ":8080").
• typ: The CMMP protocol version (V20 or V30).
• t: The interval between active tests (heartbeats).
• n: The number of continuous active tests sent without a response before the connection is closed.
• logWriter: An io.Writer for error logging (e.g., os.Stderr).
• handlers: A variadic list of Handler implementations to process incoming packets. Handlers are executed in the order provided (middleware pattern).

Handler Behavior

Each handler's ServeCmpp method returns:

1. bool: If true, the server continues to the next handler in the chain. If false, the chain stops.
2. error: If non-nil, the server will send a response (if applicable) and then close the client connection.

err := cmpp.ListenAndServe(
    ":8080",
    cmpp.V30,
    30*time.Second, // T: heartbeat interval
    3,              // N: max failed heartbeats
    os.Stderr,
    myHandler,
    middlewareHandler,
)

The cmpp.HandlerFunc type allows you to implement a middleware pattern. Because ListenAndServe accepts multiple handlers, you can wrap logic (like authentication or logging) around your main business logic.

In the chain, if a handler returns false, the subsequent handlers are not called. If a handler returns an error, the connection is closed.

// A middleware that logs every request
loggingMiddleware := cmpp.HandlerFunc(func(r *cmpp.Response, p *cmpp.Packet, l *log.Logger) (bool, error) {
    l.Printf("Received packet: %v", p.Packer)
    return true, nil // Continue to next handler
})

// The main business logic
mainHandler := cmpp.HandlerFunc(func(r *cmpp.Response, p *cmpp.Packet, l *log.Logger) (bool, error) {
    // Handle specific CMMP logic here
    return false, nil // Stop the chain here
})

// Registering them
// cmpp.ListenAndServe(..., loggingMiddleware, mainHandler)

You can implement the Handler interface to process incoming CMMP packets. Alternatively, you can use the HandlerFunc adapter to convert a standard function into a Handler.

Handler Interface

type Handler interface {
    ServeCmpp(r *Response, p *Packet, l *log.Logger) (bool, error)
}

HandlerFunc Adapter

If you have a function with the signature func(*Response, *Packet, *log.Logger) (bool, error), you can cast it to cmpp.HandlerFunc to use it as a handler.

Arguments

• r (*Response): Contains the response packet to be sent back to the client. The SeqId in r.SeqId is used for the response.
• p (*Packet): The incoming request packet.
• l (*log.Logger): The server's error logger.

Return Values

• bool: Return true to allow the next handler in the chain to run. Return false to stop processing this packet.
• error: Return a non-nil error to trigger a connection closure after the response is sent.

// Using HandlerFunc for a simple handler
myHandler := cmpp.HandlerFunc(func(r *cmpp.Response, p *cmpp.Packet, l *log.Logger) (bool, error) {
    // Process packet p
    // ...
    
    // Prepare a response if needed
    // r.Packer = &cmpp.Cmpp2SubmitRspPkt{SeqId: r.SeqId}
    
    return true, nil
})

The CmppConnReqPkt struct represents a connection request for both CMMP version 2.x and 3.x.

Client-side usage (Packing): You must initialize the struct with the correct SrcAddr, Secret, and Version. Calling Pack(seqId uint32) will automatically generate the AuthSrc (authenticator) using an MD5 hash of the source address, a padding buffer, the secret, and the timestamp.

Server-side usage (Unpacking): You do not need to initialize the struct. Calling Unpack(data []byte) will populate the SeqId, SrcAddr, AuthSrc, Version, and Timestamp from the incoming byte stream.

// Client side example
req := &cmpp.CmppConnReqPkt{
    SrcAddr: "123456",
    Secret:  "your_secret",
    Version: cmpp.Type2, // Assuming Type2 is defined elsewhere
}
bytes, err := req.Pack(12345)

// Server side example
req := &cmpp.CmppConnReqPkt{}
err := req.Unpack(incomingBytes)