package tcp

Import Path
	github.com/marten-seemann/tcp (on go.dev)

Dependency Relation
	imports 12 packages, and imported by one package


Involved Source Files

	    conn.go
	    conn_linux.go
	
		Package tcp implements TCP-level socket options.
		
		The package provides TCP-level socket options that allow
		manipulation of TCP connection facilities.

	    ipv6zone.go
	    rawconn.go
	    sys.go
	    sys_linux.go
	    sys_linux_amd64.go
	    sys_unix.go
	    zsys_linux.go


Code Examples

	
		package main
		
		import (
			"crypto/tls"
			"encoding/json"
			"fmt"
			"log"
			"net"
			"net/http"
		
			"github.com/mikioh/tcp"
			"github.com/mikioh/tcpinfo"
			"github.com/mikioh/tcpopt"
		)
		
		func main() {
			// When the underlying transport connection is established,
			// your monitor goroutine can start monitoring the connection
			// by using the Option method of Conn and tcpinfo package.
			monitor := func(tc *tcp.Conn) {
				tc.SetOption(tcpopt.KeepAlive(true))
				tc.SetOption(tcpopt.KeepAliveProbeCount(3))
				var o tcpinfo.Info
				var b [256]byte
				for {
					i, err := tc.Option(o.Level(), o.Name(), b[:])
					if err != nil {
						log.Println(err)
						return
					}
					txt, err := json.Marshal(i)
					if err != nil {
						log.Println(err)
						return
					}
					fmt.Println(string(txt))
				}
			}
		
			tr := &http.Transport{
				Dial: func(network, address string) (net.Conn, error) {
					d := net.Dialer{DualStack: true}
					c, err := d.Dial(network, address)
					if err != nil {
						return nil, err
					}
					tc, err := tcp.NewConn(c)
					if err != nil {
						c.Close()
						return nil, err
					}
					go monitor(tc)
					return tc.Conn, nil
				},
				TLSClientConfig: &tls.Config{ServerName: "golang.org"},
			}
			client := http.Client{Transport: tr}
			resp, err := client.Get("https://golang.org")
			if err != nil {
				log.Fatal(err)
			}
			resp.Body.Close()
		}




Package-Level Type Names (only one)


	/* sort by:  |  */
	
		A Conn represents an end point that uses TCP connection.
		It allows to set non-portable, platform-dependent TCP-level socket
		options.

		
			Conn net.Conn
		
			
				Available returns how many bytes are unused in the underlying
				socket write buffer.
				It returns -1 when the platform doesn't support this feature.

			
				Buffered returns the number of bytes that can be read from the
				underlying socket read buffer.
				It returns -1 when the platform doesn't support this feature.

			
				Close closes the connection.
				Any blocked Read or Write operations will be unblocked and return errors.
				Close may or may not block until any buffered data is sent;
				for TCP connections see [*TCPConn.SetLinger].

			
				LocalAddr returns the local network address, if known.

			
				Option returns a socket option.

			
				OriginalDst returns an original destination address, which is an
				address not modified by intermediate entities such as network
				address and port translators inside the kernel, on the connection.
				
				Only Linux and BSD variants using PF support this feature.

			
				Read reads data from the connection.
				Read can be made to time out and return an error after a fixed
				time limit; see SetDeadline and SetReadDeadline.

			
				RemoteAddr returns the remote network address, if known.

			
				SetDeadline sets the read and write deadlines associated
				with the connection. It is equivalent to calling both
				SetReadDeadline and SetWriteDeadline.
				
				A deadline is an absolute time after which I/O operations
				fail instead of blocking. The deadline applies to all future
				and pending I/O, not just the immediately following call to
				Read or Write. After a deadline has been exceeded, the
				connection can be refreshed by setting a deadline in the future.
				
				If the deadline is exceeded a call to Read or Write or to other
				I/O methods will return an error that wraps os.ErrDeadlineExceeded.
				This can be tested using errors.Is(err, os.ErrDeadlineExceeded).
				The error's Timeout method will return true, but note that there
				are other possible errors for which the Timeout method will
				return true even if the deadline has not been exceeded.
				
				An idle timeout can be implemented by repeatedly extending
				the deadline after successful Read or Write calls.
				
				A zero value for t means I/O operations will not time out.

			
				SetOption sets a socket option.

			
				SetReadDeadline sets the deadline for future Read calls
				and any currently-blocked Read call.
				A zero value for t means Read will not time out.

			
				SetWriteDeadline sets the deadline for future Write calls
				and any currently-blocked Write call.
				Even if write times out, it may return n > 0, indicating that
				some of the data was successfully written.
				A zero value for t means Write will not time out.

			
				Write writes data to the connection.
				Write can be made to time out and return an error after a fixed
				time limit; see SetDeadline and SetWriteDeadline.

		
			 Conn : github.com/miekg/dns.Writer
			 Conn : github.com/pion/datachannel.ReadDeadliner
			 Conn : github.com/pion/datachannel.WriteDeadliner
			 Conn : github.com/pion/stun.Connection
			 Conn : github.com/pion/stun/v3.Connection
			 Conn : github.com/prometheus/common/expfmt.Closer
			 Conn : internal/bisect.Writer
			 Conn : io.Closer
			 Conn : io.ReadCloser
			 Conn : io.Reader
			 Conn : io.ReadWriteCloser
			 Conn : io.ReadWriter
			 Conn : io.WriteCloser
			 Conn : io.Writer
			 Conn : net.Conn
		
			func NewConn(c net.Conn) (*Conn, error)




Package-Level Functions (only one)


	
		NewConn returns a new end point.