sipgo

SIPGO is a SIP stack implemented in Go, compliant with RFC 3261. It is designed for high performance and includes the following core layers:

• Parser: Optimized for fast encoding and decoding of SIP messages.
• Transport Layer: Supports various protocols for message delivery.
• Transaction Layer: Manages transaction sessions and state machines.

The proxysip library uses heavy caching to reduce Go Garbage Collection (GC) pressure, which results in HIGH memory usage.

To manage performance and memory:

• To improve performance: Increase the GOGC environment variable (e.g., GOGC=200). This reduces GC frequency but increases memory consumption.
• Container environments: Ensure GOMAXPROCS is correctly set to match your CPU quota. Alternatively, import go.uber.org/automaxprocs to handle this automatically.

import _ "go.uber.org/automaxprocs"

When a request is received by a Server, the handler receives a sip.ServerTransaction. You use this transaction to send provisional or final responses and to monitor the transaction lifecycle (ACKs or termination).

// Incoming request handler
srv.OnInvite(func(req *sip.Request, tx sip.ServerTransaction) {
    // Send provisional response (e.g., 100 Trying)
    res := sip.NewResponseFromRequest(req, 100, "Trying", nil)
    tx.Respond(res)
    
    // Send final response (e.g., 200 OK)
    res := sip.NewResponseFromRequest(req, 200, "OK", body)
    tx.Respond(res)

    // Wait for transaction termination
    select {
    case m := <-tx.Acks(): 
        // Handle ACK for response
    case <-tx.Done():
        // Signal transaction is done. 
        // Check tx.Err() for error details
        return
    }
})

The SIP parser is optimized for speed by default, automatically parsing common headers such as From, To, Via, Cseq, Content-Type, and Content-Length. These headers can be accessed via fast reference methods on the message object (e.g., msg.Via(), msg.From()).

To increase performance in high-throughput scenarios, you can use WithHeadersParsers to reduce the set of headers that are parsed automatically. When a header is not in the pre-parsed set, the stack uses lazy parsing to access it when requested.

You can stress test the proxy using docker-compose with sipp running uac and uas scenarios. All traffic is proxied from the UAC to the UAS.

To run the stress test environment, open three separate terminals and execute the following commands:

1. Start the proxy service.
2. Start the UAS (User Agent Server).
3. Start the UAC (User Agent Client).

Note: Performance results vary by hardware, but on an i7 (limited to 4 cores), it has demonstrated handling >2000 calls/s and peaks >12000 calls.

# Run this in 3 terminals
docker-compose run proxy
docker-compose run uas
docker-compose run uac

SIPGO uses a UA (User Agent) as the base for both servers (UAS) and clients (UAC). You create a UA using sipgo.NewUA(), then wrap it in either a Server handle to react to incoming requests or a Client handle to initiate outgoing requests.

Supported transport protocols include udp, tcp, tls, ws, and wss.

ua, _ := sipgo.NewUA() // Build user agent
srv, _ := sipgo.NewServer(ua) // Creating server handle for ua
client, _ := sipgo.NewClient(ua) // Creating client handle for ua

// Register handlers for incoming requests
srv.OnInvite(inviteHandler)
srv.OnAck(ackHandler)
srv.OnBye(byeHandler)

// Start listening on various transports
ctx, _ := signal.NotifyContext(ctx, os.Interrupt)
go srv.ListenAndServe(ctx, "udp", "127.0.0.1:5060")
go srv.ListenAndServe(ctx, "tcp", "127.0.0.1:5061")
go srv.ListenAndServe(ctx, "ws", "127.0.0.1:5080")
<-ctx.Done()

To run the registration client example, use the go run command on the client directory. Use the following flags to configure the client:

• -u: The username for registration.
• -p: The password for registration.
• -srv: The SIP server address (IP and port) to register with.

go run ./client -u alice -p alice -srv 127.0.0.10:5060
go run ./client -u bob -p bob -srv 127.0.0.10:5060

To use SIPGO in your Go project, fetch the library using go get:

go get github.com/emiago/sipgo

To view full SIP messages dumped from the transport layer, enable the global sip.SIPDebug flag. This will output messages at the DEBUG log level, showing the raw SIP content including headers and body.

sip.SIPDebug = true