sipgo

package module
v0.22.3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Sep 2, 2024 License: BSD-2-Clause Imports: 17 Imported by: 0

README

SIPGO

Go Report Card Used By Coverage License GitHub go.mod Go version

SIPGO is library for writing fast SIP services in GO language.
It comes with SIP stack (RFC 3261|RFC3581) optimized for fast parsing.

For extra functionality checkout also
github.com/emiago/sipgox It adds media, rtp, sdp, softphone creation on top of sipgo more easily.

Fetch lib with:

go get github.com/emiago/sipgo

NOTE: LIB MAY HAVE API CHANGES UNTIL STABLE VERSION.

*If you like/use project currently or need additional help/support checkout Support section

You can follow on X/Twitter for more updates.

More on documentation you can find on Go doc

Supported protocols

  • UDP
  • TCP
  • TLS
  • WS
  • WSS

Examples

Also thanks to pion project sharing this example of using SIPgo with webrtc:

Tools developed:

  • CLI softphone for easy testing gophone
  • Simple proxy where NAT is problem psip
  • ... your tool can be here

Performance

As example you can find example/proxysip as simple version of statefull proxy. It is used for stress testing with sipp. To find out more about performance check the latest results:
example/proxysip

Used By

babelforce

If you are using in company, your logo can be here.

Usage

Lib allows you to write easily sip servers, clients, stateful proxies, registrars or any sip routing. Writing in GO we are not limited to handle SIP requests/responses in many ways, or to integrate and scale with any external services (databases, caches...).

UAS/UAC build

Using server or client handle for UA you can build incoming or outgoing requests.

ua, _ := sipgo.NewUA() // Build user agent
srv, _ := sipgo.NewServer(ua) // Creating server handle for ua
client, _ := sipgo.NewClient(ua) // Creating client handle for ua
srv.OnInvite(inviteHandler)
srv.OnAck(ackHandler)
srv.OnCancel(cancelHandler)
srv.OnBye(byeHandler)

// For registrars
// srv.OnRegister(registerHandler)
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()

TLS transports

// TLS
conf :=  sipgo.GenerateTLSConfig(certFile, keyFile, rootPems)
srv.ListenAndServeTLS(ctx, "tcp", "127.0.0.1:5061", conf)
srv.ListenAndServeTLS(ctx, "ws", "127.0.0.1:5081", conf)

UAC first

If you are acting as client first, you can say to client which host:port to use, and this connection will be reused until closing UA. Any request received can be still processed with server handle.

ua, _ := sipgo.NewUA() // Build user agent
defer ua.Close()

client, _ := sipgo.NewClient(ua, sipgo.WithClientHostname("127.0.0.1"), sipgo.WithClientPort(5060))
server, _ := sipgo.NewServer(ua) 
srv.OnBye(func(req *sip.Request, tx sip.ServerTransaction)) {
    // This will be received on 127.0.0.1:5060
}

tx, err := client.TransactionRequest(ctx, sip.NewRequest(sip.INVITE, recipient))

Server Transaction

Server transaction is passed on handler

// Incoming request
srv.OnInvite(func(req *sip.Request, tx sip.ServerTransaction) {
    res := sip.NewResponseFromRequest(req, code, reason, body)
    // Send response
    tx.Respond(res)

    select {
        case m := <-tx.Acks(): // Handle ACK . ACKs on 2xx are send as different request
        case m := <-tx.Cancels(): // Handle Cancel 
        case <-tx.Done():
            // Signal transaction is done. 
            // Check any errors with tx.Err() to have more info why terminated
            return
    }

    // terminating handler terminates Server transaction automaticaly
})

Server stateless response

srv := sipgo.NewServer()
...
func ackHandler(req *sip.Request, tx sip.ServerTransaction) {
    res := sip.NewResponseFromRequest(req, code, reason, body)
    srv.WriteResponse(res)
}
srv.OnACK(ackHandler)

Client Transaction

Using client handle allows easy creating and sending request. Unless you customize transaction request with opts by default client.TransactionRequest will build all other headers needed to pass correct sip request.

Here is full example:

ctx := context.Background()
client, _ := sipgo.NewClient(ua) // Creating client handle

// Request is either from server request handler or created
req.SetDestination("10.1.2.3") // Change sip.Request destination
tx, err := client.TransactionRequest(ctx, req) // Send request and get client transaction handle

defer tx.Terminate() // Client Transaction must be terminated for cleanup
...

select {
    case res := <-tx.Responses():
    // Handle responses
    case <-tx.Done():
    // Wait for termination
    return
}

Client stateless request

client, _ := sipgo.NewClient(ua) // Creating client handle
req := sip.NewRequest(method, recipient)
// Send request and forget
client.WriteRequest(req)

Dialog handling

DialogClient and DialogServer allow easier managing multiple dialog (Calls) sessions. They are seperated based on your request context, but they act more like peer. They both need client handle to be able send request and server handle to accept request.

UAC:

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

contactHDR := sip.ContactHeader{
    Address: sip.Uri{User: "test", Host: "127.0.0.200", Port: 5088},
}
dialogCli := sipgo.NewDialogClient(client, contactHDR)

// Attach Bye handling for dialog
srv.OnBye(func(req *sip.Request, tx sip.ServerTransaction) {
    err := dialogCli.ReadBye(req, tx)
    //handle error
})

// Create dialog session
dialog, err := dialogCli.Invite(ctx, recipientURI, nil)
defer dialog.Close() // Cleans up from dialog pool
// Wait for answer
err = dialog.WaitAnswer(ctx, AnswerOptions{})
// Check dialog response dialog.InviteResponse (SDP) and return ACK
err = dialog.Ack(ctx)
// Send BYE to terminate call
err = dialog.Bye(ctx)

UAS:

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

uasContact := sip.ContactHeader{
    Address: sip.Uri{User: "test", Host: "127.0.0.200", Port: 5099},
}
dialogSrv := sipgo.NewDialogServer(client, uasContact)

srv.OnInvite(func(req *sip.Request, tx sip.ServerTransaction) {
    dlg, err := dialogSrv.ReadInvite(req, tx)
    // handle error
    dlg.Respond(sip.StatusTrying, "Trying", nil)
    dlg.Respond(sip.StatusOK, "OK", nil)
    
    // Instead Done also dlg.State() can be used for granular state checking
    <-dlg.Context().Done()
})

srv.OnAck(func(req *sip.Request, tx sip.ServerTransaction) {
    dialogSrv.ReadAck(req, tx)
})

srv.OnBye(func(req *sip.Request, tx sip.ServerTransaction) {
    dialogSrv.ReadBye(req, tx)
})

Stateful Proxy build

Proxy is combination client and server handle that creates server/client transaction. They need to share same ua same like uac/uas build.

Forwarding request is done via client handle:

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

srv.OnInvite(func(req *sip.Request, tx sip.ServerTransaction) {
    ctx := context.Background()
    req.SetDestination("10.1.2.3") // Change sip.Request destination
    // Start client transaction and relay our request. Add Via and Record-Route header
    clTx, err := client.TransactionRequest(ctx, req, sipgo.ClientRequestAddVia, sipgo.ClientRequestAddRecordRoute)
    // Send back response
    res := <-cltx.Responses()
    tx.Respond(res)
})

SIP Debug

You can have full SIP messages dumped from transport into Debug level message.

Example:

sip.SIPDebug = true

Feb 24 23:32:26.493191 DBG UDP read 10.10.0.10:5060 <- 10.10.0.100:5060:
SIP/2.0 100 Trying
Via: SIP/2.0/UDP 10.10.0.10:5060;rport=5060;received=10.10.0.10;branch=z9hG4bK.G3nCwpXAKJQ0T2oZUII70wuQx9NeXc61;alias
Via: SIP/2.0/UDP 10.10.1.1:5060;branch=z9hG4bK-1-1-0
Record-Route: <sip:10.10.0.10;transport=udp;lr>
Call-ID: 1-1@10.10.1.1
From: "sipp" <sip:sipp@10.10.1.1>;tag=1SIPpTag001
To: "uac" <sip:uac@10.10.0.10>
CSeq: 1 INVITE
Server: Asterisk PBX 18.16.0
Content-Length:  0

Support

If you find this project interesting for bigger support or consulting, you can contact me on mail

You can buy me a coffee in meantime on ko-fi.com/emiasupport

For bugs features pls create issue.

Extra

E2E/integration testing

If you are interested using lib for your testing services then checkout article on how easy you can make calls and other

Tests

Library will be covered with more tests. Focus is more on benchmarking currently.

go test ./...

Credits

This project was influenced by gosip, project by @ghetovoice, but started as new project to achieve best/better performance and to improve API. This unfortunately required many design changes, therefore this libraries are not compatible.

Documentation

Index

Examples

Constants

This section is empty.

Variables

View Source 
var (
	ErrDialogOutsideDialog   = errors.New("Call/Transaction outside dialog")
	ErrDialogDoesNotExists   = errors.New("Dialog Does Not Exist")
	ErrDialogInviteNoContact = errors.New("No Contact header")
	ErrDialogCanceled        = errors.New("Dialog canceled")
)
View Source 
var (
	// Used only for testing, better way is to pass listener with Serve{Transport}
	ListenReadyCtxKey = "ListenReadyCtxKey"
)

Functions

func ClientRequestAddRecordRoute 

func ClientRequestAddRecordRoute(c *Client, r *sip.Request) error

ClientRequestAddRecordRoute is option for adding record route header Based on proxy setup https://www.rfc-editor.org/rfc/rfc3261#section-16

func ClientRequestAddVia 

func ClientRequestAddVia(c *Client, r *sip.Request) error

ClientRequestAddVia is option for adding via header Based on proxy setup https://www.rfc-editor.org/rfc/rfc3261.html#section-16.6

func ClientRequestBuild 

func ClientRequestBuild(c *Client, r *sip.Request) error

ClientRequestBuild will build missing fields in request This is by default but can be used to combine with other ClientRequestOptions

func ClientRequestDecreaseMaxForward 

func ClientRequestDecreaseMaxForward(c *Client, r *sip.Request) error

Based on proxy setup https://www.rfc-editor.org/rfc/rfc3261#section-16 ClientRequestDecreaseMaxForward should be used when forwarding request. It decreases max forward in case of 0 it returnes error

func GenerateTLSConfig 

func GenerateTLSConfig(certFile string, keyFile string, rootPems []byte) (*tls.Config, error)

GenerateTLSConfig creates basic tls.Config that you can pass for ServerTLS It needs rootPems for client side

func Init 

func Init()

Types

type AnswerOptions 

type AnswerOptions struct {
	OnResponse func(res *sip.Response)

	// For digest authentication
	Username string
	Password string
}

type Client 

type Client struct {
	*UserAgent
	// contains filtered or unexported fields
}

func NewClient 

func NewClient(ua *UserAgent, options ...ClientOption) (*Client, error)

NewClient creates client handle for user agent

func (*Client) Close 

func (c *Client) Close() error

Close client handle. UserAgent must be closed for full transaction and transport layer closing.

func (*Client) DoDigestAuth 

func (c *Client) DoDigestAuth(ctx context.Context, req *sip.Request, res *sip.Response, auth DigestAuth) (sip.ClientTransaction, error)

DoDigestAuth will apply digest authentication if initial request is chalenged by 401 or 407. It returns new transaction that is created for this request

func (*Client) GetHostname 

func (c *Client) GetHostname() string

func (*Client) TransactionRequest 

func (c *Client) TransactionRequest(ctx context.Context, req *sip.Request, options ...ClientRequestOption) (sip.ClientTransaction, error)

TransactionRequest uses transaction layer to send request and returns transaction

NOTE: By default request will not be cloned and it will populate request with missing headers unless options are used In most cases you want this as you will retry with additional headers

Following header fields will be added if not exist to have correct SIP request: To, From, CSeq, Call-ID, Max-Forwards, Via

Passing options will override this behavior, that is it is expected that you have request fully built This is useful when using client handle in proxy building as request are already parsed

func (*Client) WriteRequest 

func (c *Client) WriteRequest(req *sip.Request, options ...ClientRequestOption) error

WriteRequest sends request directly to transport layer Behavior is same as TransactionRequest Non-transaction ACK request should be passed like this

type ClientOption 

type ClientOption func(c *Client) error

func WithClientAddr 

func WithClientAddr(addr string) ClientOption

WithClientAddr is merge of WithClientHostname and WithClientPort addr is format <host>:<port>

func WithClientHostname 

func WithClientHostname(hostname string) ClientOption

WithClientHost allows setting default route host or IP on Via in case of IP it will enforce transport layer to create/reuse connection with this IP default: user agent IP This is useful when you need to act as client first and avoid creating server handle listeners. NOTE: From header hostname is WithUserAgentHostname option on UA or modify request manually

func WithClientLogger 

func WithClientLogger(logger zerolog.Logger) ClientOption

WithClientLogger allows customizing client logger

func WithClientNAT 

func WithClientNAT() ClientOption

WithClientNAT makes client aware that is behind NAT.

func WithClientPort 

func WithClientPort(port int) ClientOption

WithClientPort allows setting default route Via port it will enforce transport layer to create connection with this port if does NOT exist transport layer will choose existing connection by default unless TransportLayer.ConnectionReuse is set to false default: ephemeral port

type ClientRequestOption 

type ClientRequestOption func(c *Client, req *sip.Request) error

type Dialog 

type Dialog struct {
	ID string

	// InviteRequest is set when dialog is created. It is not thread safe!
	// Use it only as read only and use methods to change headers
	InviteRequest *sip.Request

	// InviteResponse is last response received or sent. It is not thread safe!
	// Use it only as read only and do not change values
	InviteResponse *sip.Response
	// contains filtered or unexported fields
}

func (*Dialog) Body 

func (d *Dialog) Body() []byte

func (*Dialog) Context 

func (d *Dialog) Context() context.Context

func (*Dialog) Done deprecated 

func (d *Dialog) Done() <-chan struct{}

Done is signaled when dialog state ended

Deprecated: It is wrapper on context, so better to use Context()

func (*Dialog) State 

func (d *Dialog) State() <-chan sip.DialogState

type DialogClient 

type DialogClient struct {
	// contains filtered or unexported fields
}

func NewDialogClient 

func NewDialogClient(client *Client, contactHDR sip.ContactHeader) *DialogClient

NewDialogClient provides handle for managing UAC dialog Contact hdr is default to be provided for correct invite. It is not used if you provided hdr as part of request, but contact hdr must be present so this makes sure correct dialog is established. In case handling different transports you should have multiple instances per transport

func (*DialogClient) Invite 

func (c *DialogClient) Invite(ctx context.Context, recipient sip.Uri, body []byte, headers ...sip.Header) (*DialogClientSession, error)

Invite sends INVITE request and creates early dialog session. This is actually not yet dialog (ID is empty) You need to call WaitAnswer after for establishing dialog For passing custom Invite request use WriteInvite

func (*DialogClient) ReadBye 

func (c *DialogClient) ReadBye(req *sip.Request, tx sip.ServerTransaction) error

func (*DialogClient) ReadRefer 

func (c *DialogClient) ReadRefer(req *sip.Request, tx sip.ServerTransaction, referUri *sip.Uri) (*DialogClientSession, error)

Experiment ReadRefer reads REFER (Transfer action) and parses referURI if dialog exists. Returned dialog you should use to pass NOTIFY and BYE if your new INVITE dialog is successful

func (*DialogClient) WriteInvite 

func (c *DialogClient) WriteInvite(ctx context.Context, inviteRequest *sip.Request) (*DialogClientSession, error)

type DialogClientSession 

type DialogClientSession struct {
	Dialog
	// contains filtered or unexported fields
}

func (*DialogClientSession) Ack 

func (s *DialogClientSession) Ack(ctx context.Context) error

Ack sends ack. Use WriteAck for more customizing

func (*DialogClientSession) Bye 

func (s *DialogClientSession) Bye(ctx context.Context) error

Bye sends bye and terminates session. Use WriteBye if you want to customize bye request

func (*DialogClientSession) Close 

func (s *DialogClientSession) Close() error

Close must be always called in order to cleanup some internal resources Consider that this will not send BYE or CANCEL or change dialog state

func (*DialogClientSession) TransactionRequest 

func (s *DialogClientSession) TransactionRequest(ctx context.Context, req *sip.Request) (sip.ClientTransaction, error)

TransactionRequest is doing client DIALOG request based on RFC https://www.rfc-editor.org/rfc/rfc3261#section-12.2.1 This ensures that you have proper request done within dialog. You should avoid setting any Dialog header (cseq, from, to, callid)

func (*DialogClientSession) WaitAnswer 

func (s *DialogClientSession) WaitAnswer(ctx context.Context, opts AnswerOptions) error

WaitAnswer waits for success response or returns ErrDialogResponse in case non 2xx Canceling context while waiting 2xx will send Cancel request Returns errors: - ErrDialogResponse in case non 2xx response - any internal in case waiting answer failed for different reasons

func (*DialogClientSession) WriteAck 

func (s *DialogClientSession) WriteAck(ctx context.Context, ack *sip.Request) error

func (*DialogClientSession) WriteBye 

func (s *DialogClientSession) WriteBye(ctx context.Context, bye *sip.Request) error

func (*DialogClientSession) WriteRequest 

func (s *DialogClientSession) WriteRequest(req *sip.Request) error

type DialogServer 

type DialogServer struct {
	// contains filtered or unexported fields
}

func NewDialogServer 

func NewDialogServer(client *Client, contactHDR sip.ContactHeader) *DialogServer

NewDialogServer provides handle for managing UAS dialog Contact hdr is default that is provided for responses. Client is needed for termination dialog session In case handling different transports you should have multiple instances per transport

func (*DialogServer) ReadAck 

func (s *DialogServer) ReadAck(req *sip.Request, tx sip.ServerTransaction) error

ReadAck should read from your OnAck handler

func (*DialogServer) ReadBye 

func (s *DialogServer) ReadBye(req *sip.Request, tx sip.ServerTransaction) error

ReadBye should read from your OnBye handler

func (*DialogServer) ReadInvite 

func (s *DialogServer) ReadInvite(req *sip.Request, tx sip.ServerTransaction) (*DialogServerSession, error)

ReadInvite should read from your OnInvite handler for which it creates dialog context You need to use DialogServerSession for all further responses Do not forget to add ReadAck and ReadBye for confirming dialog and terminating

type DialogServerSession 

type DialogServerSession struct {
	Dialog
	// contains filtered or unexported fields
}

func (*DialogServerSession) Bye 

func (s *DialogServerSession) Bye(ctx context.Context) error

func (*DialogServerSession) Close 

func (s *DialogServerSession) Close() error

Close is always good to call for cleanup or terminating dialog state

func (*DialogServerSession) Respond 

func (s *DialogServerSession) Respond(statusCode sip.StatusCode, reason string, body []byte, headers ...sip.Header) error

Respond should be called for Invite request, you may want to call this multiple times like 100 Progress or 180 Ringing 2xx for creating dialog or other code in case failure

In case Cancel request received: ErrDialogCanceled is responded

func (*DialogServerSession) RespondSDP 

func (s *DialogServerSession) RespondSDP(sdp []byte) error

RespondSDP is just wrapper to call 200 with SDP. It is better to use this when answering as it provide correct headers

func (*DialogServerSession) TransactionRequest 

func (s *DialogServerSession) TransactionRequest(ctx context.Context, req *sip.Request) (sip.ClientTransaction, error)

TransactionRequest is doing client DIALOG request based on RFC https://www.rfc-editor.org/rfc/rfc3261#section-12.2.1 This ensures that you have proper request done within dialog

func (*DialogServerSession) WriteRequest 

func (s *DialogServerSession) WriteRequest(req *sip.Request) error

func (*DialogServerSession) WriteResponse 

func (s *DialogServerSession) WriteResponse(res *sip.Response) error

WriteResponse allows passing you custom response

type DigestAuth 

type DigestAuth struct {
	Username string
	Password string
}

type ErrDialogResponse 

type ErrDialogResponse struct {
	Res *sip.Response
}

func (ErrDialogResponse) Error 

func (e ErrDialogResponse) Error() string

type ListenReadyCtxValue 

type ListenReadyCtxValue chan struct{}

type RequestHandler 

type RequestHandler func(req *sip.Request, tx sip.ServerTransaction)

RequestHandler is a callback that will be called on the incoming request

type Server 

type Server struct {
	*UserAgent
	// contains filtered or unexported fields
}

Server is a SIP server

func NewServer 

func NewServer(ua *UserAgent, options ...ServerOption) (*Server, error)

NewServer creates new instance of SIP server handle. Allows creating server transaction handlers It uses User Agent transport and transaction layer

func (*Server) Close 

func (srv *Server) Close() error

Close server handle. UserAgent must be closed for full transaction and transport layer closing.

func (*Server) ListenAndServe 

func (srv *Server) ListenAndServe(ctx context.Context, network string, addr string) error

Serve will fire all listeners Network supported: udp, tcp, ws

func (*Server) ListenAndServeTLS 

func (srv *Server) ListenAndServeTLS(ctx context.Context, network string, addr string, conf *tls.Config) error

Serve will fire all listeners that are secured. Network supported: tls, wss

func (*Server) OnAck 

func (srv *Server) OnAck(handler RequestHandler)

OnAck registers Ack request handler

func (*Server) OnBye 

func (srv *Server) OnBye(handler RequestHandler)

OnBye registers Bye request handler

func (*Server) OnCancel 

func (srv *Server) OnCancel(handler RequestHandler)

OnCancel registers Cancel request handler

func (*Server) OnInfo 

func (srv *Server) OnInfo(handler RequestHandler)

OnInfo registers Info request handler

func (*Server) OnInvite 

func (srv *Server) OnInvite(handler RequestHandler)

OnInvite registers Invite request handler

func (*Server) OnMessage 

func (srv *Server) OnMessage(handler RequestHandler)

OnMessage registers Message request handler

func (*Server) OnNoRoute 

func (srv *Server) OnNoRoute(handler RequestHandler)

OnNoRoute registers no route handler default is handling is responding 405 Method Not allowed This allows customizing your response for any non handled message

Example 
// Creating no route handler allows you to respond for non handled (non routed) requests
ua, _ := NewUA()
srv, _ := NewServer(ua)

srv.OnNoRoute(func(req *sip.Request, tx sip.ServerTransaction) {
	res := sip.NewResponseFromRequest(req, 405, "Method Not Allowed", nil)
	// Send response directly and let transaction terminate
	if err := srv.WriteResponse(res); err != nil {
		srv.log.Error().Err(err).Msg("respond '405 Method Not Allowed' failed")
	}
})

Output:

func (*Server) OnNotify 

func (srv *Server) OnNotify(handler RequestHandler)

OnNotify registers Notify request handler

func (*Server) OnOptions 

func (srv *Server) OnOptions(handler RequestHandler)

OnOptions registers Options request handler

func (*Server) OnPrack 

func (srv *Server) OnPrack(handler RequestHandler)

OnPrack registers Prack request handler

func (*Server) OnPublish 

func (srv *Server) OnPublish(handler RequestHandler)

OnPublish registers Publish request handler

func (*Server) OnRefer 

func (srv *Server) OnRefer(handler RequestHandler)

OnRefer registers Refer request handler

func (*Server) OnRegister 

func (srv *Server) OnRegister(handler RequestHandler)

OnRegister registers Register request handler

func (*Server) OnRequest 

func (srv *Server) OnRequest(method sip.RequestMethod, handler RequestHandler)

OnRequest registers new request callback. Can be used as generic way to add handler

func (*Server) OnSubscribe 

func (srv *Server) OnSubscribe(handler RequestHandler)

OnSubscribe registers Subscribe request handler

func (*Server) OnUpdate 

func (srv *Server) OnUpdate(handler RequestHandler)

OnUpdate registers Update request handler

func (*Server) RegisteredMethods 

func (srv *Server) RegisteredMethods() []string

RegisteredMethods returns list of registered handlers. Can be used for constructing Allow header

func (*Server) ServeRequest 

func (srv *Server) ServeRequest(f func(r *sip.Request))

ServeRequest can be used as middleware for preprocessing message

func (*Server) ServeTCP 

func (srv *Server) ServeTCP(l net.Listener) error

ServeTCP starts serving request on TCP type listener.

func (*Server) ServeTLS 

func (srv *Server) ServeTLS(l net.Listener) error

ServeTLS starts serving request on TLS type listener.

func (*Server) ServeUDP 

func (srv *Server) ServeUDP(l net.PacketConn) error

ServeUDP starts serving request on UDP type listener.

func (*Server) ServeWS 

func (srv *Server) ServeWS(l net.Listener) error

ServeWS starts serving request on WS type listener.

func (*Server) ServeWSS 

func (srv *Server) ServeWSS(l net.Listener) error

ServeWS starts serving request on WS type listener.

func (*Server) TransportLayer 

func (srv *Server) TransportLayer() *sip.TransportLayer

Transport is function to get transport layer of server Can be used for modifying

func (*Server) WriteResponse 

func (srv *Server) WriteResponse(r *sip.Response) error

WriteResponse will proxy message to transport layer. Use it in stateless mode

type ServerOption 

type ServerOption func(s *Server) error

func WithServerLogger 

func WithServerLogger(logger zerolog.Logger) ServerOption

WithServerLogger allows customizing server logger

type UserAgent 

type UserAgent struct {
	// contains filtered or unexported fields
}

func NewUA 

func NewUA(options ...UserAgentOption) (*UserAgent, error)

NewUA creates User Agent User Agent will create transport and transaction layer Check options for customizing user agent

func (*UserAgent) Close 

func (ua *UserAgent) Close() error

func (*UserAgent) GetIP 

func (ua *UserAgent) GetIP() net.IP

func (*UserAgent) Name 

func (ua *UserAgent) Name() string

func (*UserAgent) TransactionLayer 

func (ua *UserAgent) TransactionLayer() *sip.TransactionLayer

func (*UserAgent) TransportLayer 

func (ua *UserAgent) TransportLayer() *sip.TransportLayer

type UserAgentOption 

type UserAgentOption func(s *UserAgent) error

func WithUserAgenTLSConfig 

func WithUserAgenTLSConfig(c *tls.Config) UserAgentOption

WithUserAgenTLSConfig allows customizing default tls config.

func WithUserAgent 

func WithUserAgent(ua string) UserAgentOption

WithUserAgent changes user agent name Default: sipgo

func WithUserAgentDNSResolver 

func WithUserAgentDNSResolver(r *net.Resolver) UserAgentOption

WithUserAgentDNSResolver allows customizing default DNS resolver for transport layer

func WithUserAgentHostname 

func WithUserAgentHostname(hostname string) UserAgentOption

WithUserAgentHostname represents FQDN of user that can be presented in From header

func WithUserAgentParser 

func WithUserAgentParser(p *sip.Parser) UserAgentOption

Source Files

View all Source files

Directories

Path Synopsis
Originally forked from https://github.com/ghettovoice/gosip by @ghetovoice
 Originally forked from https://github.com/ghettovoice/gosip by @ghetovoice

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.