package server

import "github.com/plgd-dev/go-coap/v3/dtls/server"

Index ¶

• Variables
• type Config
• type ErrorFunc
• type EventFunc
• type GetMIDFunc
• type HandlerFunc
• type Listener
• type OnNewConnFunc
• type Option
• type Server
• func New(opt ...Option) *Server
• func (s *Server) Serve(l Listener) error
• func (s *Server) Stop()
• type Session
• func NewSession( ctx context.Context, connection *coapNet.Conn, maxMessageSize uint32, mtu uint16, closeSocket bool, ) *Session
• func (s *Session) AddOnClose(f EventFunc)
• func (s *Session) Close() error
• func (s *Session) Context() context.Context
• func (s *Session) Done() <-chan struct{}
• func (s *Session) LocalAddr() net.Addr
• func (s *Session) MaxMessageSize() uint32
• func (s *Session) NetConn() net.Conn
• func (s *Session) RemoteAddr() net.Addr
• func (s *Session) Run(cc *client.Conn) (err error)
• func (s *Session) SetContextValue(key interface{}, val interface{})
• func (s *Session) WriteMessage(req *pool.Message) error
• func (s *Session) WriteMulticastMessage(*pool.Message, *net.UDPAddr, ...coapNet.MulticastOption) error

Variables ¶

var DefaultConfig = func() Config {
	opts := Config{
		Common: config.NewCommon[*udpClient.Conn](),
		CreateInactivityMonitor: func() udpClient.InactivityMonitor {
			timeout := time.Second * 16
			onInactive := func(cc *udpClient.Conn) {
				_ = cc.Close()
			}
			return inactivity.New(timeout, onInactive)
		},
		RequestMonitor: func(*udpClient.Conn, *pool.Message) (bool, error) {
			return false, nil
		},
		OnNewConn: func(*udpClient.Conn) {

		},
		TransmissionNStart:             1,
		TransmissionAcknowledgeTimeout: time.Second * 2,
		TransmissionMaxRetransmit:      4,
		GetMID:                         message.GetMID,
		MTU:                            udpClient.DefaultMTU,
	}
	opts.Handler = func(w *responsewriter.ResponseWriter[*udpClient.Conn], _ *pool.Message) {
		if err := w.SetResponse(codes.NotFound, message.TextPlain, nil); err != nil {
			opts.Errors(fmt.Errorf("dtls server: cannot set response: %w", err))
		}
	}
	return opts
}()

Types ¶

type Config ¶

type Config struct {
	config.Common[*udpClient.Conn]
	CreateInactivityMonitor        func() udpClient.InactivityMonitor
	GetMID                         GetMIDFunc
	Handler                        HandlerFunc
	OnNewConn                      OnNewConnFunc
	RequestMonitor                 udpClient.RequestMonitorFunc
	TransmissionNStart             uint32
	TransmissionAcknowledgeTimeout time.Duration
	TransmissionMaxRetransmit      uint32
	MTU                            uint16
}

type ErrorFunc ¶

type ErrorFunc = func(error)

type EventFunc ¶

type EventFunc = func()

type GetMIDFunc ¶

type GetMIDFunc = func() int32

type HandlerFunc ¶

type HandlerFunc = func(*responsewriter.ResponseWriter[*udpClient.Conn], *pool.Message)

The HandlerFunc type is an adapter to allow the use of ordinary functions as COAP handlers.

type Listener ¶

type Listener interface {
	Close() error
	AcceptWithContext(ctx context.Context) (net.Conn, error)
}

Listener defined used by coap

type OnNewConnFunc ¶

type OnNewConnFunc = func(*udpClient.Conn)

OnNewConnFunc is the callback for new connections.

type Option ¶

type Option interface {
	DTLSServerApply(cfg *Config)
}

A Option sets options such as credentials, codec and keepalive parameters, etc.

type Server ¶

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

func New ¶

func New(opt ...Option) *Server

func (*Server) Serve ¶

func (s *Server) Serve(l Listener) error

func (*Server) Stop ¶

func (s *Server) Stop()

Stop stops server without wait of ends Serve function.

type Session ¶

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

func NewSession ¶

func NewSession(
	ctx context.Context,
	connection *coapNet.Conn,
	maxMessageSize uint32,
	mtu uint16,
	closeSocket bool,
) *Session

func (*Session) AddOnClose ¶

func (s *Session) AddOnClose(f EventFunc)

func (*Session) Close ¶

func (s *Session) Close() error

func (*Session) Context ¶

func (s *Session) Context() context.Context

func (*Session) Done ¶

func (s *Session) Done() <-chan struct{}

Done signalizes that connection is not more processed.

func (*Session) LocalAddr ¶

func (s *Session) LocalAddr() net.Addr

func (*Session) MaxMessageSize ¶

func (s *Session) MaxMessageSize() uint32

func (*Session) NetConn ¶

func (s *Session) NetConn() net.Conn

NetConn returns the underlying connection that is wrapped by s. The Conn returned is shared by all invocations of NetConn, so do not modify it.

func (*Session) RemoteAddr ¶

func (s *Session) RemoteAddr() net.Addr

func (*Session) Run ¶

func (s *Session) Run(cc *client.Conn) (err error)

Run reads and processes requests from a connection, until the connection is closed.

func (*Session) SetContextValue ¶

func (s *Session) SetContextValue(key interface{}, val interface{})

SetContextValue stores the value associated with key to context of connection.

func (*Session) WriteMessage ¶

func (s *Session) WriteMessage(req *pool.Message) error

func (*Session) WriteMulticastMessage ¶

func (s *Session) WriteMulticastMessage(*pool.Message, *net.UDPAddr, ...coapNet.MulticastOption) error

WriteMulticastMessage sends multicast to the remote multicast address. Currently it is not implemented - is just satisfy golang udp/client/Session interface.

Source Files ¶

config.go server.go session.go