1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
|
package main
// RFC implementation
import (
"bytes"
"context"
"fmt"
"io/ioutil"
"net"
"net/http"
"os/user"
"time"
)
// Function to create a persistent TCP connection
func createPersistentConnection(host string) (net.Conn, error) {
dialer := &net.Dialer{
Timeout: 10 * time.Second,
KeepAlive: 30 * time.Second,
}
conn, err := dialer.Dial("tcp", host)
if err != nil {
return nil, fmt.Errorf("failed to establish connection: %w", err)
}
return conn, nil
}
func mesocket() {
host := "example.com:80"
// Establish a persistent TCP connection
conn, err := createPersistentConnection(host)
if err != nil {
fmt.Println("Error creating connection:", err)
return
}
defer conn.Close()
// Custom transport that forces HTTP requests to use our existing connection
transport := &http.Transport{
DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
fmt.Println("Reusing existing TCP connection")
return conn, nil
},
DisableKeepAlives: false, // Ensure Keep-Alive is enabled
}
client := &http.Client{
Transport: transport,
Timeout: 10 * time.Second,
}
url := "http://example.com/endpoint"
data := []byte(`{"message": "Hello"}`)
// Create an HTTP request
req, err := http.NewRequest(http.MethodPost, url, bytes.NewBuffer(data))
if err != nil {
fmt.Println("Error creating request:", err)
return
}
usr, _ := user.Current()
req.Header.Set("author", usr.Username)
req.Header.Set("Connection", "keep-alive") // Keep connection alive
// Perform the HTTP request
resp, err := client.Do(req)
if err != nil {
fmt.Println("Error performing request:", err)
return
}
defer resp.Body.Close()
// Read and print the response
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
fmt.Println("Error reading response:", err)
return
}
fmt.Println("Response:", string(body))
}
|
