package httpu

Import Path
	github.com/huin/goupnp/httpu (on go.dev)

Dependency Relation
	imports 12 packages, and imported by 2 packages

Involved Source Files

	    httpu.go
	    multiclient.go
	    serve.go
Package-Level Type Names (total 8)

	/* sort by: alphabet | popularity */
	 type ClientInterface (interface)
		ClientInterface is the general interface provided to perform HTTP-over-UDP
		requests.

		Methods (only one)
			( ClientInterface) Do(req *http.Request, timeout time.Duration, numSends int) ([]*http.Response, error)
				Do performs a request. The timeout is how long to wait for before returning
				the responses that were received. An error is only returned for failing to
				send the request. Failures in receipt simply do not add to the resulting
				responses.

		Implemented By (at least 3)
			*HTTPUClient
			*MultiClient
			 github.com/huin/goupnp/ssdp.HTTPUClient (interface)
		Implements (at least one exported)
			 ClientInterface : github.com/huin/goupnp/ssdp.HTTPUClient
		As Inputs Of (at least one exported)
			func NewMultiClient(delegates []ClientInterface) *MultiClient

	 type ClientInterfaceCtx (interface)
		ClientInterfaceCtx is the equivalent of ClientInterface, except with methods
		taking a context.Context parameter.

		Methods (only one)
			( ClientInterfaceCtx) DoWithContext(req *http.Request, numSends int) ([]*http.Response, error)
				DoWithContext performs a request. If the input request has a
				deadline, then that value will be used as the timeout for how long
				to wait before returning the responses that were received. If the
				request's context is canceled, this method will return immediately.
				
				If the request's context is never canceled, and does not have a
				deadline, then this function WILL NEVER RETURN. You MUST set an
				appropriate deadline on the context, or otherwise cancel it when you
				want to finish an operation.
				
				An error is only returned for failing to send the request. Failures
				in receipt simply do not add to the resulting responses.

		Implemented By (at least 3)
			*HTTPUClient
			*MultiClientCtx
			 github.com/huin/goupnp/ssdp.HTTPUClientCtx (interface)
		Implements (at least one exported)
			 ClientInterfaceCtx : github.com/huin/goupnp/ssdp.HTTPUClientCtx
		As Inputs Of (at least one exported)
			func NewMultiClientCtx(delegates []ClientInterfaceCtx) *MultiClientCtx

	 type Handler (interface)
		Handler is the interface by which received HTTPU messages are passed to
		handling code.

		Methods (only one)
			( Handler) ServeMessage(r *http.Request)
				ServeMessage is called for each HTTPU message received. peerAddr contains
				the address that the message was received from.

		Implemented By (at least 2)
			 HandlerFunc
			*github.com/huin/goupnp/ssdp.Registry
		As Inputs Of (at least one exported)
			func Serve(l net.PacketConn, handler Handler) error

	 type HandlerFunc (func)
		HandlerFunc is a function-to-Handler adapter.

		Methods (only one)
			( HandlerFunc) ServeMessage(r *http.Request)
		Implements (at least one exported)
			 HandlerFunc : Handler

	 type HTTPUClient (struct)
		HTTPUClient is a client for dealing with HTTPU (HTTP over UDP). Its typical
		function is for HTTPMU, and particularly SSDP.

		Methods (total 3)
			(*HTTPUClient) Close() error
				Close shuts down the client. The client will no longer be useful following
				this.

			(*HTTPUClient) Do(req *http.Request, timeout time.Duration, numSends int) ([]*http.Response, error)
				Do implements ClientInterface.Do.
				
				Note that at present only one concurrent connection will happen per
				HTTPUClient.

			(*HTTPUClient) DoWithContext(req *http.Request, numSends int) ([]*http.Response, error)
				DoWithContext implements ClientInterfaceCtx.DoWithContext.
				
				Make sure to read the documentation on the ClientInterfaceCtx interface
				regarding cancellation!

		Implements (at least 6)
			*HTTPUClient : ClientInterface
			*HTTPUClient : ClientInterfaceCtx
			*HTTPUClient : github.com/huin/goupnp/ssdp.HTTPUClient
			*HTTPUClient : github.com/huin/goupnp/ssdp.HTTPUClientCtx
			*HTTPUClient : github.com/prometheus/common/expfmt.Closer
			*HTTPUClient : io.Closer
		As Outputs Of (at least 2)
			func NewHTTPUClient() (*HTTPUClient, error)
			func NewHTTPUClientAddr(addr string) (*HTTPUClient, error)

	 type MultiClient (struct)
		MultiClient dispatches requests out to all the delegated clients.

		Methods (only one)
			(*MultiClient) Do(req *http.Request, timeout time.Duration, numSends int) ([]*http.Response, error)
				Do implements ClientInterface.Do.

		Implements (at least 2)
			*MultiClient : ClientInterface
			*MultiClient : github.com/huin/goupnp/ssdp.HTTPUClient
		As Outputs Of (at least one exported)
			func NewMultiClient(delegates []ClientInterface) *MultiClient

	 type MultiClientCtx (struct)
		MultiClientCtx dispatches requests out to all the delegated clients.

		Methods (only one)
			(*MultiClientCtx) DoWithContext(req *http.Request, numSends int) ([]*http.Response, error)
				DoWithContext implements ClientInterfaceCtx.DoWithContext.

		Implements (at least 2)
			*MultiClientCtx : ClientInterfaceCtx
			*MultiClientCtx : github.com/huin/goupnp/ssdp.HTTPUClientCtx
		As Outputs Of (at least one exported)
			func NewMultiClientCtx(delegates []ClientInterfaceCtx) *MultiClientCtx

	 type Server (struct)
		A Server defines parameters for running an HTTPU server.

		Fields (total 5)
			Addr string
				// UDP address to listen on

			Handler Handler
				// handler to invoke

			Interface *net.Interface
				// Network interface to listen on for multicast, nil for default multicast interface

			MaxMessageBytes int
				// maximum number of bytes to read from a packet, DefaultMaxMessageBytes if 0

			Multicast bool
				// Should listen for multicast?

		Methods (total 2)
			(*Server) ListenAndServe() error
				ListenAndServe listens on the UDP network address srv.Addr. If srv.Multicast
				is true, then a multicast UDP listener will be used on srv.Interface (or
				default interface if nil).

			(*Server) Serve(l net.PacketConn) error
				Serve messages received on the given packet listener to the srv.Handler.

		As Outputs Of (at least one exported)
			func github.com/huin/goupnp/ssdp.NewServerAndRegistry() (*Server, *ssdp.Registry)


Package-Level Functions (total 5)

	 func NewHTTPUClient() (*HTTPUClient, error)
		NewHTTPUClient creates a new HTTPUClient, opening up a new UDP socket for the
		purpose.

	 func NewHTTPUClientAddr(addr string) (*HTTPUClient, error)
		NewHTTPUClientAddr creates a new HTTPUClient which will broadcast packets
		from the specified address, opening up a new UDP socket for the purpose

	 func NewMultiClient(delegates []ClientInterface) *MultiClient
		NewMultiClient creates a new MultiClient that delegates to all the given
		clients.

	 func NewMultiClientCtx(delegates []ClientInterfaceCtx) *MultiClientCtx
		NewMultiClient creates a new MultiClient that delegates to all the given
		clients.

	 func Serve(l net.PacketConn, handler Handler) error
		Serve messages received on the given packet listener to the given handler.


Package-Level Constants (total 2)

	const DefaultMaxMessageBytes = 2048
	const LocalAddressHeader = "goupnp-local-address"

The pages are generated with Golds v0.8.2. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds.