coap

README

Go-CoAP

The Constrained Application Protocol (CoAP) is a specialized web transfer protocol for use with constrained nodes and constrained networks in the Internet of Things. The protocol is designed for machine-to-machine (M2M) applications such as smart energy and building automation.

The go-coap provides servers and clients for DTLS, TCP-TLS, UDP, TCP in golang language.

Features

• CoAP over UDP RFC 7252.
• CoAP over TCP/TLS RFC 8232
• Observe resources in CoAP RFC 7641
• Block-wise transfers in CoAP RFC 7959
• request multiplexer
• multicast
• CoAP NoResponse option in CoAP RFC 7967
• CoAP over DTLS pion/dtls

Samples

Simple

Server UDP/TCP

    // Server

    // Middleware function, which will be called for each request.
    func loggingMiddleware(next mux.Handler) mux.Handler {
        return mux.HandlerFunc(func(w mux.ResponseWriter, r *mux.Message) {
            log.Printf("ClientAddress %v, %v\n", w.Client().RemoteAddr(), r.String())
            next.ServeCOAP(w, r)
        })
    }

    // See /examples/simple/server/main.go
    func handleA(w mux.ResponseWriter, req *mux.Message) {
        err := w.SetResponse(codes.GET, message.TextPlain, bytes.NewReader([]byte("hello world")))
        if err != nil {
            log.Printf("cannot set response: %v", err)
        }
    }

    func main() {
        r := mux.NewRouter()
        r.Use(loggingMiddleware)
        r.Handle("/a", mux.HandlerFunc(handleA))
        r.Handle("/b", mux.HandlerFunc(handleB))

        log.Fatal(coap.ListenAndServe("udp", ":5688", r))


        // for tcp
        // log.Fatal(coap.ListenAndServe("tcp", ":5688",  r))

        // for tcp-tls
        // log.Fatal(coap.ListenAndServeTLS("tcp", ":5688", &tls.Config{...}, r))

        // for udp-dtls
        // log.Fatal(coap.ListenAndServeDTLS("udp", ":5688", &dtls.Config{...}, r))
    }

Client

    // Client
    // See /examples/simpler/client/main.go
    func main() {
        co, err := udp.Dial("localhost:5688")

        // for tcp
        // co, err := tcp.Dial("localhost:5688")

        // for tcp-tls
        // co, err := tcp.Dial("localhost:5688", tcp.WithTLS(&tls.Config{...}))

        // for dtls
        // co, err := dtls.Dial("localhost:5688", &dtls.Config{...}))

        if err != nil {
            log.Fatalf("Error dialing: %v", err)
        }
        ctx, cancel := context.WithTimeout(context.Background(), time.Second)
        defer cancel()
        resp, err := co.Get(ctx, "/a")
        if err != nil {
            log.Fatalf("Cannot get response: %v", err)
            return
        }
        log.Printf("Response: %+v", resp)
    }

Observe / Notify

Server example.

Client example.

Multicast

Server example.

Client example.

Contributing

In order to run the tests that the CI will run locally, the following two commands can be used to build the Docker image and run the tests. When making changes, these are the tests that the CI will run, so please make sure that the tests work locally before committing.

docker build . --network=host -t go-coap:build --target build
docker run --mount type=bind,source="$(pwd)",target=/shared,readonly --network=host go-coap:build go test './...'

License

Apache 2.0

Sponsors

Become a sponsor and get your logo on our README on Github with a link to your site.

Backers

Become a backer and get your image on our README on Github with a link to your site.

Documentation

Overview

Package coap provides a CoAP client and server.

Index

• func ListenAndServe(network string, addr string, handler mux.Handler) (err error)
• func ListenAndServeDTLS(network string, addr string, config *piondtls.Config, handler mux.Handler) (err error)
• func ListenAndServeTCPTLS(network, addr string, config *tls.Config, handler mux.Handler) (err error)

Functions

func ListenAndServe

func ListenAndServe(network string, addr string, handler mux.Handler) (err error)

ListenAndServe Starts a server on address and network specified Invoke handler for incoming queries.

func ListenAndServeDTLS

func ListenAndServeDTLS(network string, addr string, config *piondtls.Config, handler mux.Handler) (err error)

ListenAndServeDTLS Starts a server on address and network over DTLS specified Invoke handler for incoming queries.

func ListenAndServeTCPTLS

func ListenAndServeTCPTLS(network, addr string, config *tls.Config, handler mux.Handler) (err error)

ListenAndServeTCPTLS Starts a server on address and network over TLS specified Invoke handler for incoming queries.