TCP

https://github.com/xaionaro-go/tcp
Admin
TCP is a Go package that provides TCP-level socket options for manipulation of TCP connection...
Tokens:3,599
Snippets:16
Trust Score:8.2
License:BSD-2-Clause
Update:6 months ago
Show doc for...
Tokens:
Raw
### Get TCP Connection State

Source: https://context7.com/xaionaro-go/tcp/llms.txt

Retrieves the current state of a TCP connection using the info package. It establishes a TCP connection, retrieves connection information, and then prints the state. Dependencies include the standard 'net' package and the 'github.com/xaionaro-go/tcp/info' package.

```go
package main

import (
    "fmt"
    "log"
    "net"

    "github.com/xaionaro-go/tcp"
    "github.com/xaionaro-go/tcp/info"
)

func main() {
    conn, _ := net.Dial("tcp", "example.com:80")
    defer conn.Close()
    tc, _ := tcp.NewConn(conn)

    var o info.Info
    var b [256]byte
    i, err := tc.Option(o.Level(), o.Name(), b[:])
    if err != nil {
        log.Fatal(err)
    }

    tcpInfo := i.(*info.Info)

    // Available states: 
    // info.Unknown, info.Closed, info.Listen, info.SynSent, 
    // info.SynReceived, info.Established, info.FinWait1, 
    // info.FinWait2, info.CloseWait, info.LastAck, 
    // info.Closing, info.TimeWait

    switch tcpInfo.State {
    case info.Established:
        fmt.Println("Connection is established")
    case info.SynSent:
        fmt.Println("SYN sent, waiting for response")
    case info.TimeWait:
        fmt.Println("Connection in TIME_WAIT state")
    default:
        fmt.Printf("Current state: %s\n", tcpInfo.State)
    }
}
```

--------------------------------

### Configure TCP Socket Options in Go

Source: https://context7.com/xaionaro-go/tcp/llms.txt

Demonstrates how to apply various TCP socket options such as NoDelay, MSS, and KeepAlive using the opt package. These options allow for fine-tuned control over network behavior and performance.

```go
package main

import (
    "log"
    "net"
    "time"

    "github.com/xaionaro-go/tcp"
    "github.com/xaionaro-go/tcp/opt"
)

func main() {
    conn, _ := net.Dial("tcp", "example.com:80")
    defer conn.Close()
    tc, _ := tcp.NewConn(conn)

    tc.SetOption(opt.NoDelay(true))
    tc.SetOption(opt.MSS(1460))
    tc.SetOption(opt.SendBuffer(65536))
    tc.SetOption(opt.ReceiveBuffer(65536))
    tc.SetOption(opt.KeepAlive(true))
    tc.SetOption(opt.KeepAliveIdleInterval(60 * time.Second))
    tc.SetOption(opt.KeepAliveProbeInterval(10 * time.Second))
    tc.SetOption(opt.KeepAliveProbeCount(5))
    tc.SetOption(opt.Cork(true))
    tc.SetOption(opt.NotSentLowWMK(16384))
    tc.SetOption(opt.QuickAck(true))
    tc.SetOption(opt.Linger{OnOff: true, Linger: 30 * time.Second})
    tc.SetOption(opt.ECN(true))
    tc.SetOption(opt.TOA{Port: 9000, Ip: net.ParseIP("192.168.1.1")})

    log.Println("All options set")
}
```

--------------------------------

### Configure Congestion Control Algorithm (Go - Linux)

Source: https://context7.com/xaionaro-go/tcp/llms.txt

This Go code snippet shows how to configure and query TCP congestion control algorithms on Linux systems using the `xaionaro-go/tcp` package. It demonstrates setting an algorithm like 'cubic' and then retrieving the currently active one. This requires the `github.com/xaionaro-go/tcp/info` sub-package.

```go
package main

import (
    "fmt"
    "log"
    "net"

    "github.com/xaionaro-go/tcp"
    "github.com/xaionaro-go/tcp/info"
)

func main() {
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    tc, err := tcp.NewConn(conn)
    if err != nil {
        log.Fatal(err)
    }

    // Set congestion control algorithm (Linux only)
    // Common algorithms: "cubic", "reno", "bbr", "vegas"
    cca := info.CCAlgorithm("cubic")
    if err := tc.SetOption(cca); err != nil {
        log.Printf("SetOption CCAlgorithm: %v", err)
    }

    // Retrieve current algorithm
    var b [64]byte
    opt, err := tc.Option(cca.Level(), cca.Name(), b[:])
    if err != nil {
        log.Printf("Get CCAlgorithm: %v", err)
    } else {
        fmt.Printf("Congestion Control Algorithm: %s\n", opt)
    }
}
```

--------------------------------

### Wrap net.Conn with NewConn in Go

Source: https://context7.com/xaionaro-go/tcp/llms.txt

The NewConn function is the entry point for utilizing the library. It takes a standard net.Conn and returns a wrapped connection object that exposes extended TCP-level socket options.

```go
package main

import (
    "log"
    "net"

    "github.com/xaionaro-go/tcp"
)

func main() {
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    tc, err := tcp.NewConn(conn)
    if err != nil {
        log.Fatal(err)
    }

    log.Printf("Local address: %s", tc.LocalAddr())
    log.Printf("Remote address: %s", tc.RemoteAddr())
}
```

--------------------------------

### Configure TCP Socket Options in Go

Source: https://context7.com/xaionaro-go/tcp/llms.txt

The SetOption method allows for the configuration of various TCP parameters such as keep-alive intervals, Maximum Segment Size (MSS), and Nagle's algorithm. These options are type-safe and implement the opt.Option interface.

```go
package main

import (
    "log"
    "net"
    "time"

    "github.com/xaionaro-go/tcp"
    "github.com/xaionaro-go/tcp/opt"
)

func main() {
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    tc, err := tcp.NewConn(conn)
    if err != nil {
        log.Fatal(err)
    }

    if err := tc.SetOption(opt.KeepAlive(true)); err != nil {
        log.Fatal(err)
    }

    if err := tc.SetOption(opt.KeepAliveIdleInterval(3 * time.Minute)); err != nil {
        log.Fatal(err)
    }

    if err := tc.SetOption(opt.KeepAliveProbeInterval(30 * time.Second)); err != nil {
        log.Fatal(err)
    }

    if err := tc.SetOption(opt.KeepAliveProbeCount(3)); err != nil {
        log.Fatal(err)
    }

    if err := tc.SetOption(opt.MSS(1100)); err != nil {
        log.Fatal(err)
    }

    if err := tc.SetOption(opt.NoDelay(true)); err != nil {
        log.Fatal(err)
    }

    log.Println("TCP options configured successfully")
}
```

--------------------------------

### Monitor TCP Connections with HTTP Client

Source: https://context7.com/xaionaro-go/tcp/llms.txt

Demonstrates integrating TCP connection monitoring into an HTTP client. It defines a custom HTTP transport that wraps the network connection with TCP monitoring capabilities. The monitor function runs in a goroutine, periodically logging TCP statistics. Dependencies include 'net/http', 'crypto/tls', 'encoding/json', and the 'github.com/xaionaro-go/tcp' packages.

```go
package main

import (
    "crypto/tls"
    "encoding/json"
    "fmt"
    "log"
    "net"
    "net/http"
    "time"

    "github.com/xaionaro-go/tcp"
    "github.com/xaionaro-go/tcp/info"
    "github.com/xaionaro-go/tcp/opt"
)

func main() {
    // Monitor function runs in a goroutine to track connection stats
    monitor := func(tc *tcp.Conn) {
        // Configure keep-alive on the connection
        tc.SetOption(opt.KeepAlive(true))
        tc.SetOption(opt.KeepAliveProbeCount(3))

        var o info.Info
        var b [256]byte

        ticker := time.NewTicker(1 * time.Second)
        defer ticker.Stop()

        for range ticker.C {
            i, err := tc.Option(o.Level(), o.Name(), b[:])
            if err != nil {
                log.Println("Monitor error:", err)
                return
            }
            txt, _ := json.Marshal(i)
            fmt.Println("TCP Stats:", string(txt))
        }
    }

    // Custom transport with TCP monitoring
    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
            }

            // Start monitoring in background
            go monitor(tc)

            // Return the underlying connection for HTTP use
            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)
    }
    defer resp.Body.Close()

    fmt.Printf("Response status: %s\n", resp.Status)
}
```

--------------------------------

### Retrieve TCP Connection Statistics in Go

Source: https://context7.com/xaionaro-go/tcp/llms.txt

Shows how to extract detailed TCP connection information including RTT, congestion control, and flow control data using the info package. The output can be used for monitoring or diagnostic purposes.

```go
package main

import (
    "encoding/json"
    "fmt"
    "log"
    "net"

    "github.com/xaionaro-go/tcp"
    "github.com/xaionaro-go/tcp/info"
)

func main() {
    conn, err := net.Dial("tcp", "golang.org:80")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    tc, err := tcp.NewConn(conn)
    if err != nil {
        log.Fatal(err)
    }

    var o info.Info
    var b [256]byte

    i, err := tc.Option(o.Level(), o.Name(), b[:])
    if err != nil {
        log.Fatal(err)
    }

    tcpInfo := i.(*info.Info)

    fmt.Printf("Connection State: %s\n", tcpInfo.State)
    fmt.Printf("RTT: %v\n", tcpInfo.RTT)
    fmt.Printf("RTT Variance: %v\n", tcpInfo.RTTVar)
    fmt.Printf("Retransmission Timeout: %v\n", tcpInfo.RTO)
    fmt.Printf("Sender MSS: %d bytes\n", tcpInfo.SenderMSS)
    fmt.Printf("Receiver MSS: %d bytes\n", tcpInfo.ReceiverMSS)

    if tcpInfo.FlowControl != nil {
        fmt.Printf("Receiver Window: %d bytes\n", tcpInfo.FlowControl.ReceiverWindow)
    }

    if tcpInfo.CongestionControl != nil {
        fmt.Printf("Sender SS Threshold: %d\n", tcpInfo.CongestionControl.SenderSSThreshold)
        fmt.Printf("Sender Window (bytes): %d\n", tcpInfo.CongestionControl.SenderWindowBytes)
        fmt.Printf("Sender Window (segs): %d\n", tcpInfo.CongestionControl.SenderWindowSegs)
    }

    txt, _ := json.MarshalIndent(i, "", "  ")
    fmt.Println(string(txt))
}
```

--------------------------------

### Check TCP Buffer Status

Source: https://context7.com/xaionaro-go/tcp/llms.txt

Provides methods to check the read buffer (incoming data) and write buffer (available space) status on a TCP connection. It establishes a connection, then uses `Buffered()` to check read availability and `Available()` for write buffer space. Returns -1 if the platform does not support the feature. Dependencies include the standard 'net' package and the 'github.com/xaionaro-go/tcp' package.

```go
package main

import (
    "fmt"
    "log"
    "net"

    "github.com/xaionaro-go/tcp"
)

func main() {
    conn, err := net.Dial("tcp", "example.com:80")
    if err != nil {
        log.Fatal(err)
    }
    defer conn.Close()

    tc, err := tcp.NewConn(conn)
    if err != nil {
        log.Fatal(err)
    }

    // Check bytes available to read from socket buffer
    // Returns -1 if platform doesn't support this feature
    buffered := tc.Buffered()
    if buffered >= 0 {
        fmt.Printf("Bytes available to read: %d\n", buffered)
    }

    // Check available space in write buffer
    // Returns -1 if platform doesn't support this feature
    available := tc.Available()
    if available >= 0 {
        fmt.Printf("Available write buffer space: %d bytes\n", available)
    }
}
```

--------------------------------

### Retrieve Original Destination Address (Go)

Source: https://context7.com/xaionaro-go/tcp/llms.txt

This Go code snippet demonstrates how to retrieve the original destination address of a TCP connection, which is crucial for transparent proxy implementations. It utilizes the `tcp.NewConn` function to wrap a standard `net.Conn` and then calls the `OriginalDst()` method. This functionality is supported on Linux and BSD variants using PF.

```go
package main

import (
    "fmt"
    "log"
    "net"

    "github.com/xaionaro-go/tcp"
)

func main() {
    // This example is for a server handling redirected connections
    listener, err := net.Listen("tcp", ":8080")
    if err != nil {
        log.Fatal(err)
    }
    defer listener.Close()

    for {
        conn, err := listener.Accept()
        if err != nil {
            log.Println(err)
            continue
        }

        go func(c net.Conn) {
            defer c.Close()

            tc, err := tcp.NewConn(c)
            if err != nil {
                log.Println(err)
                return
            }

            // Get the original destination (before NAT/redirect)
            // Useful for transparent proxy implementations
            origDst, err := tc.OriginalDst()
            if err != nil {
                log.Println("OriginalDst error:", err)
                return
            }

            fmt.Printf("Client: %s -> Original destination: %s\n",
                tc.RemoteAddr(), origDst)

            // Now you can forward the connection to origDst
        }(conn)
    }
}
```
Tokens:
Raw