github
/
v2ray-core
mirror of https://github.com/v2ray/v2ray-core
1
0
Fork 0
Code Issues Releases Wiki Activity

h2 transport

pull/931/head
Darien Raymond 2018-03-01 13:16:52 +01:00
parent af29e42771
commit d207d953bd
No known key found for this signature in database
GPG Key ID: 7251FFA14BB18169
14 changed files with 467 additions and 28 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
common/interfaces.go
View File

@ -27,3 +27,16 @@ type HasType interface {
// Type returns the type of the object.
Type() interface{}
}
type ChainedClosable []Closable
func NewChainedClosable(c ...Closable) ChainedClosable {
return ChainedClosable(c)
}
func (cc ChainedClosable) Close() error {
for _, c := range cc {
c.Close()
}
return nil
}

4
testing/tls/tls.go
View File

@ -29,12 +29,12 @@ func GenerateCertificateForTest() *v2tls.Certificate {
Subject: pkix.Name{
Organization: []string{"V2Ray Inc"},
},
NotBefore: time.Now(),
NotBefore: time.Now().Add(time.Hour * -1),
NotAfter: time.Now().Add(time.Hour),
KeyUsage: x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
ExtKeyUsage: []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
BasicConstraintsValid: true,
DNSNames: []string{"www.v2ray.com"},
DNSNames: []string{"www.v2ray.com", "v2ray.com"},
}
derBytes, err := x509.CreateCertificate(rand.Reader, &template, &template, &priv.PublicKey, priv)

53
transport/internet/config.pb.go
View File

@ -23,6 +23,7 @@ const (
TransportProtocol_UDP TransportProtocol = 1
TransportProtocol_MKCP TransportProtocol = 2
TransportProtocol_WebSocket TransportProtocol = 3
TransportProtocol_HTTP TransportProtocol = 4
)
var TransportProtocol_name = map[int32]string{
@ -30,12 +31,14 @@ var TransportProtocol_name = map[int32]string{
1: "UDP",
2: "MKCP",
3: "WebSocket",
4: "HTTP",
}
var TransportProtocol_value = map[string]int32{
"TCP": 0,
"UDP": 1,
"MKCP": 2,
"WebSocket": 3,
"HTTP": 4,
}
func (x TransportProtocol) String() string {
@ -138,29 +141,29 @@ func init() {
func init() { proto.RegisterFile("v2ray.com/core/transport/internet/config.proto", fileDescriptor0) }
var fileDescriptor0 = []byte{
// 374 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x91, 0x4d, 0x4b, 0xeb, 0x40,
0x14, 0x86, 0x6f, 0x92, 0x72, 0x6f, 0x7a, 0xda, 0x5e, 0xd3, 0x59, 0x15, 0xa1, 0x58, 0x2b, 0x48,
0x70, 0x31, 0x29, 0x71, 0xef, 0xa2, 0x71, 0x23, 0x5a, 0x0c, 0x49, 0x55, 0x10, 0xa4, 0xa4, 0xe3,
0x18, 0x82, 0x4d, 0xa6, 0x4c, 0x46, 0x31, 0xbf, 0xc7, 0x9d, 0x7b, 0xff, 0x9f, 0xe4, 0x63, 0x86,
0xa2, 0x50, 0xba, 0x71, 0x37, 0x64, 0xde, 0xf3, 0x9c, 0x27, 0xef, 0x00, 0x7e, 0x75, 0x79, 0x54,
0x60, 0xc2, 0x52, 0x87, 0x30, 0x4e, 0x1d, 0xc1, 0xa3, 0x2c, 0x5f, 0x33, 0x2e, 0x9c, 0x24, 0x13,
0x94, 0x67, 0x54, 0x38, 0x84, 0x65, 0x4f, 0x49, 0x8c, 0xd7, 0x9c, 0x09, 0x86, 0x86, 0x32, 0xcf,
0x29, 0x56, 0x59, 0x2c, 0xb3, 0xfb, 0x93, 0x6f, 0x38, 0xc2, 0xd2, 0x94, 0x65, 0x4e, 0x4e, 0x79,
0x12, 0xad, 0x1c, 0x51, 0xac, 0xe9, 0xe3, 0x22, 0xa5, 0x79, 0x1e, 0xc5, 0xb4, 0x06, 0x8e, 0xdf,
0x35, 0xd8, 0x9b, 0x4b, 0x90, 0x57, 0xad, 0x42, 0x57, 0x60, 0x56, 0x97, 0x84, 0xad, 0x06, 0xda,
0x48, 0xb3, 0xff, 0xbb, 0x13, 0xbc, 0x75, 0x2f, 0x56, 0x04, 0xbf, 0x99, 0x0b, 0x14, 0x01, 0x4d,
0xc1, 0xcc, 0xa9, 0x10, 0x49, 0x16, 0xe7, 0x03, 0x7d, 0xa4, 0xd9, 0x1d, 0xf7, 0x78, 0x93, 0x56,
0x2b, 0xe2, 0x5a, 0x11, 0xcf, 0x4b, 0xc5, 0x59, 0x6d, 0x18, 0xa8, 0xb9, 0xf1, 0xa7, 0x0e, 0xdd,
0x50, 0x70, 0x1a, 0xa5, 0xbf, 0xa2, 0xf8, 0x00, 0x48, 0x4d, 0x2c, 0x36, 0x64, 0x0d, 0xbb, 0xe3,
0xe2, 0x5d, 0xb9, 0xb5, 0x59, 0xd0, 0x57, 0x99, 0xb0, 0x01, 0xa1, 0x23, 0xe8, 0xe5, 0x94, 0xbc,
0xf0, 0x44, 0x14, 0x8b, 0xf2, 0x0d, 0x06, 0xc6, 0x48, 0xb3, 0xdb, 0x41, 0x57, 0x7e, 0x2c, 0x7f,
0x1a, 0x85, 0xd0, 0x57, 0x21, 0xa5, 0xd0, 0xaa, 0x14, 0x76, 0xed, 0xcb, 0x92, 0x00, 0xb9, 0x79,
0x7c, 0x00, 0x1d, 0x9f, 0xb3, 0xb7, 0xa2, 0x69, 0xcd, 0x02, 0x43, 0x44, 0x71, 0x55, 0x58, 0x3b,
0x28, 0x8f, 0x27, 0x67, 0xd0, 0xff, 0x51, 0x0c, 0xfa, 0x07, 0xc6, 0xdc, 0xf3, 0xad, 0x3f, 0xe5,
0xe1, 0xe6, 0xdc, 0xb7, 0x34, 0x64, 0x42, 0x6b, 0x76, 0xe9, 0xf9, 0x96, 0x8e, 0x7a, 0xd0, 0xbe,
0xa3, 0xcb, 0x90, 0x91, 0x67, 0x2a, 0x2c, 0x63, 0x7a, 0x0d, 0x87, 0x84, 0xa5, 0xdb, 0x2b, 0xf2,
0xb5, 0x7b, 0x53, 0x9e, 0x3f, 0xf4, 0xe1, 0xad, 0x1b, 0x44, 0x05, 0xf6, 0xca, 0xac, 0x5a, 0x8d,
0x2f, 0x9a, 0xfb, 0xe5, 0xdf, 0xea, 0x51, 0x4e, 0xbf, 0x02, 0x00, 0x00, 0xff, 0xff, 0xbf, 0x4a,
0x68, 0x51, 0x19, 0x03, 0x00, 0x00,
// 379 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xb4, 0x91, 0x4f, 0x4b, 0xf3, 0x40,
0x10, 0x87, 0xdf, 0x24, 0xe5, 0x35, 0x9d, 0xb6, 0x9a, 0xee, 0xa9, 0x08, 0xc5, 0x5a, 0x41, 0x82,
0x87, 0x4d, 0x89, 0xdf, 0xa0, 0xf1, 0x50, 0xd1, 0x62, 0x48, 0xa2, 0x82, 0x20, 0x25, 0x5d, 0xd7,
0x10, 0x6c, 0xb2, 0x65, 0xb3, 0x8a, 0xf9, 0x3c, 0xde, 0xbc, 0xfb, 0xfd, 0x24, 0xff, 0x96, 0xa2,
0x50, 0x7a, 0xf1, 0x36, 0x64, 0x7e, 0xf3, 0xcc, 0x93, 0x59, 0xc0, 0x6f, 0x36, 0x0f, 0x73, 0x4c,
0x58, 0x62, 0x11, 0xc6, 0xa9, 0x25, 0x78, 0x98, 0x66, 0x6b, 0xc6, 0x85, 0x15, 0xa7, 0x82, 0xf2,
0x94, 0x0a, 0x8b, 0xb0, 0xf4, 0x39, 0x8e, 0xf0, 0x9a, 0x33, 0xc1, 0xd0, 0xb0, 0xc9, 0x73, 0x8a,
0x65, 0x16, 0x37, 0xd9, 0xc3, 0xc9, 0x0f, 0x1c, 0x61, 0x49, 0xc2, 0x52, 0x2b, 0xa3, 0x3c, 0x0e,
0x57, 0x96, 0xc8, 0xd7, 0xf4, 0x69, 0x91, 0xd0, 0x2c, 0x0b, 0x23, 0x5a, 0x01, 0xc7, 0x1f, 0x0a,
0x1c, 0x04, 0x0d, 0xc8, 0x29, 0x57, 0xa1, 0x6b, 0xd0, 0xcb, 0x26, 0x61, 0xab, 0x81, 0x32, 0x52,
0xcc, 0x7d, 0x7b, 0x82, 0xb7, 0xee, 0xc5, 0x92, 0xe0, 0xd6, 0x73, 0x9e, 0x24, 0xa0, 0x29, 0xe8,
0x19, 0x15, 0x22, 0x4e, 0xa3, 0x6c, 0xa0, 0x8e, 0x14, 0xb3, 0x63, 0x9f, 0x6e, 0xd2, 0x2a, 0x45,
0x5c, 0x29, 0xe2, 0xa0, 0x50, 0x9c, 0x57, 0x86, 0x9e, 0x9c, 0x1b, 0x7f, 0xa9, 0xd0, 0xf5, 0x05,
0xa7, 0x61, 0xf2, 0x27, 0x8a, 0x8f, 0x80, 0xe4, 0xc4, 0x62, 0x43, 0x56, 0x33, 0x3b, 0x36, 0xde,
0x95, 0x5b, 0x99, 0x79, 0x7d, 0x99, 0xf1, 0x6b, 0x10, 0x3a, 0x81, 0x5e, 0x46, 0xc9, 0x2b, 0x8f,
0x45, 0xbe, 0x28, 0xde, 0x60, 0xa0, 0x8d, 0x14, 0xb3, 0xed, 0x75, 0x9b, 0x8f, 0xc5, 0x4f, 0x23,
0x1f, 0xfa, 0x32, 0x24, 0x15, 0x5a, 0xa5, 0xc2, 0xae, 0xf7, 0x32, 0x1a, 0x40, 0xb3, 0x79, 0x7c,
0x04, 0x1d, 0x97, 0xb3, 0xf7, 0xbc, 0xbe, 0x9a, 0x01, 0x9a, 0x08, 0xa3, 0xf2, 0x60, 0x6d, 0xaf,
0x28, 0xcf, 0x66, 0xd0, 0xff, 0x75, 0x18, 0xb4, 0x07, 0x5a, 0xe0, 0xb8, 0xc6, 0xbf, 0xa2, 0xb8,
0xbd, 0x70, 0x0d, 0x05, 0xe9, 0xd0, 0x9a, 0x5f, 0x39, 0xae, 0xa1, 0xa2, 0x1e, 0xb4, 0xef, 0xe9,
0xd2, 0x67, 0xe4, 0x85, 0x0a, 0x43, 0x2b, 0x1a, 0xb3, 0x20, 0x70, 0x8d, 0xd6, 0xf4, 0x06, 0x8e,
0x09, 0x4b, 0xb6, 0x1f, 0xcb, 0x55, 0x1e, 0xf4, 0xa6, 0xfe, 0x54, 0x87, 0x77, 0xb6, 0x17, 0xe6,
0xd8, 0x29, 0xb2, 0x52, 0x02, 0x5f, 0xd6, 0xfd, 0xe5, 0xff, 0xf2, 0x79, 0xce, 0xbf, 0x03, 0x00,
0x00, 0xff, 0xff, 0xf3, 0x7b, 0xd5, 0x57, 0x23, 0x03, 0x00, 0x00,
}

1
transport/internet/config.proto
View File

@ -13,6 +13,7 @@ enum TransportProtocol {
UDP = 1;
MKCP = 2;
WebSocket = 3;
HTTP = 4;
}
message TransportConfig {

12
transport/internet/http/config.go Normal file
View File

@ -0,0 +1,12 @@
package http
import (
"v2ray.com/core/common"
"v2ray.com/core/transport/internet"
)
func init() {
common.Must(internet.RegisterProtocolConfigCreator(internet.TransportProtocol_HTTP, func() interface{} {
return new(Config)
}))
}

63
transport/internet/http/config.pb.go Normal file
View File

@ -0,0 +1,63 @@
package http
import proto "github.com/golang/protobuf/proto"
import fmt "fmt"
import math "math"
// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf
// This is a compile-time assertion to ensure that this generated file
// is compatible with the proto package it is being compiled against.
// A compilation error at this line likely means your copy of the
// proto package needs to be updated.
const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
type Config struct {
Host []string `protobuf:"bytes,1,rep,name=host" json:"host,omitempty"`
Path string `protobuf:"bytes,2,opt,name=path" json:"path,omitempty"`
}
func (m *Config) Reset() { *m = Config{} }
func (m *Config) String() string { return proto.CompactTextString(m) }
func (*Config) ProtoMessage() {}
func (*Config) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
func (m *Config) GetHost() []string {
if m != nil {
return m.Host
}
return nil
}
func (m *Config) GetPath() string {
if m != nil {
return m.Path
}
return ""
}
func init() {
proto.RegisterType((*Config)(nil), "v2ray.core.transport.internet.http.Config")
}
func init() {
proto.RegisterFile("v2ray.com/core/transport/internet/http/config.proto", fileDescriptor0)
}
var fileDescriptor0 = []byte{
// 173 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x32, 0x2e, 0x33, 0x2a, 0x4a,
0xac, 0xd4, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xce, 0x2f, 0x4a, 0xd5, 0x2f, 0x29, 0x4a, 0xcc, 0x2b,
0x2e, 0xc8, 0x2f, 0x2a, 0xd1, 0xcf, 0xcc, 0x2b, 0x49, 0x2d, 0xca, 0x4b, 0x2d, 0xd1, 0xcf, 0x28,
0x29, 0x29, 0xd0, 0x4f, 0xce, 0xcf, 0x4b, 0xcb, 0x4c, 0xd7, 0x2b, 0x28, 0xca, 0x2f, 0xc9, 0x17,
0x52, 0x82, 0x69, 0x2a, 0x4a, 0xd5, 0x83, 0x6b, 0xd0, 0x83, 0x69, 0xd0, 0x03, 0x69, 0x50, 0x32,
0xe0, 0x62, 0x73, 0x06, 0xeb, 0x11, 0x12, 0xe2, 0x62, 0xc9, 0xc8, 0x2f, 0x2e, 0x91, 0x60, 0x54,
0x60, 0xd6, 0xe0, 0x0c, 0x02, 0xb3, 0x41, 0x62, 0x05, 0x89, 0x25, 0x19, 0x12, 0x4c, 0x0a, 0x8c,
0x20, 0x31, 0x10, 0xdb, 0x29, 0x94, 0x4b, 0x2d, 0x39, 0x3f, 0x57, 0x8f, 0xb0, 0xd9, 0x01, 0x8c,
0x51, 0x2c, 0x20, 0x7a, 0x15, 0x93, 0x52, 0x98, 0x51, 0x50, 0x62, 0xa5, 0x9e, 0x33, 0x48, 0x71,
0x08, 0x5c, 0xb1, 0x27, 0x4c, 0xb1, 0x47, 0x49, 0x49, 0x41, 0x12, 0x1b, 0xd8, 0xcd, 0xc6, 0x80,
0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0xf2, 0x95, 0x63, 0xea, 0x00, 0x00, 0x00,
}

12
transport/internet/http/config.proto Normal file
View File

@ -0,0 +1,12 @@
syntax = "proto3";
package v2ray.core.transport.internet.http;
option csharp_namespace = "V2Ray.Core.Transport.Internet.Http";
option go_package = "http";
option java_package = "com.v2ray.core.transport.internet.http";
option java_multiple_files = true;
message Config {
repeated string host = 1;
string path = 2;
}

49
transport/internet/http/connection.go Normal file
View File

@ -0,0 +1,49 @@
package http
import (
"io"
"time"
"v2ray.com/core/common"
"v2ray.com/core/common/net"
)
type Connection struct {
Reader io.Reader
Writer io.Writer
Closer common.Closable
Local net.Addr
Remote net.Addr
}
func (c *Connection) Read(b []byte) (int, error) {
return c.Reader.Read(b)
}
func (c *Connection) Write(b []byte) (int, error) {
return c.Writer.Write(b)
}
func (c *Connection) Close() error {
return c.Closer.Close()
}
func (c *Connection) LocalAddr() net.Addr {
return c.Local
}
func (c *Connection) RemoteAddr() net.Addr {
return c.Remote
}
func (c *Connection) SetDeadline(t time.Time) error {
return nil
}
func (c *Connection) SetReadDeadline(t time.Time) error {
return nil
}
func (c *Connection) SetWriteDeadline(t time.Time) error {
return nil
}

115
transport/internet/http/dialer.go Normal file
View File

@ -0,0 +1,115 @@
package http
import (
"context"
gotls "crypto/tls"
"io"
"net/http"
"net/url"
"sync"
"golang.org/x/net/http2"
"v2ray.com/core/common"
"v2ray.com/core/common/net"
"v2ray.com/core/transport/internet"
"v2ray.com/core/transport/internet/tls"
)
var (
globalDialerMap = make(map[net.Destination]*http.Client)
globalDailerAccess sync.Mutex
)
func getHTTPClient(ctx context.Context, dest net.Destination) (*http.Client, error) {
globalDailerAccess.Lock()
defer globalDailerAccess.Unlock()
if client, found := globalDialerMap[dest]; found {
return client, nil
}
config := tls.ConfigFromContext(ctx)
if config == nil {
return nil, newError("TLS must be enabled for http transport.").AtWarning()
}
transport := &http2.Transport{
DialTLS: func(network string, addr string, tlsConfig *gotls.Config) (net.Conn, error) {
rawHost, rawPort, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
if len(rawPort) == 0 {
rawPort = "443"
}
port, err := net.PortFromString(rawPort)
if err != nil {
return nil, err
}
address := net.ParseAddress(rawHost)
pconn, err := internet.DialSystem(context.Background(), nil, net.TCPDestination(address, port))
if err != nil {
return nil, err
}
return gotls.Client(pconn, tlsConfig), nil
},
TLSClientConfig: config.GetTLSConfig(tls.WithDestination(dest), tls.WithNextProto("h2")),
}
client := &http.Client{
Transport: transport,
}
globalDialerMap[dest] = client
return client, nil
}
// Dial dials a new TCP connection to the given destination.
func Dial(ctx context.Context, dest net.Destination) (internet.Connection, error) {
client, err := getHTTPClient(ctx, dest)
if err != nil {
return nil, err
}
preader, pwriter := io.Pipe()
request := &http.Request{
Method: "PUT",
Host: "www.v2ray.com",
Body: preader,
URL: &url.URL{
Scheme: "https",
Host: dest.NetAddr(),
Path: "/",
},
Proto: "HTTP/2",
ProtoMajor: 2,
ProtoMinor: 0,
}
response, err := client.Do(request)
if err != nil {
return nil, newError("failed to dial to ", dest).Base(err).AtWarning()
}
if response.StatusCode != 200 {
return nil, newError("unexpected status", response.StatusCode).AtWarning()
}
return &Connection{
Reader: response.Body,
Writer: pwriter,
Closer: common.NewChainedClosable(preader, pwriter, response.Body),
Local: &net.TCPAddr{
IP: []byte{0, 0, 0, 0},
Port: 0,
},
Remote: &net.TCPAddr{
IP: []byte{0, 0, 0, 0},
Port: 0,
},
}, nil
}
func init() {
common.Must(internet.RegisterTransportDialer(internet.TransportProtocol_HTTP, Dial))
}

5
transport/internet/http/errors.generated.go Normal file
View File

@ -0,0 +1,5 @@
package http
import "v2ray.com/core/common/errors"
func newError(values ...interface{}) *errors.Error { return errors.New(values...).Path("Transport", "Internet", "HTTP") }

3
transport/internet/http/http.go Normal file
View File

@ -0,0 +1,3 @@
package http
//go:generate go run $GOPATH/src/v2ray.com/core/common/errors/errorgen/main.go -pkg http -path Transport,Internet,HTTP

75
transport/internet/http/http_test.go Normal file
View File

@ -0,0 +1,75 @@
package http_test
import (
"context"
"crypto/rand"
"testing"
"time"
"v2ray.com/core/common"
"v2ray.com/core/common/buf"
"v2ray.com/core/common/net"
"v2ray.com/core/testing/servers/tcp"
tlsgen "v2ray.com/core/testing/tls"
"v2ray.com/core/transport/internet"
. "v2ray.com/core/transport/internet/http"
"v2ray.com/core/transport/internet/tls"
. "v2ray.com/ext/assert"
)
func TestHTTPConnection(t *testing.T) {
assert := With(t)
port := tcp.PickPort()
listener, err := Listen(internet.ContextWithSecuritySettings(context.Background(), &tls.Config{
Certificate: []*tls.Certificate{tlsgen.GenerateCertificateForTest()},
}), net.LocalHostIP, port, func(conn internet.Connection) {
go func() {
defer conn.Close()
b := buf.New()
defer b.Release()
for {
if err := b.Reset(buf.ReadFrom(conn)); err != nil {
return
}
nBytes, err := conn.Write(b.Bytes())
assert(err, IsNil)
assert(nBytes, Equals, b.Len())
}
}()
})
assert(err, IsNil)
defer listener.Close()
time.Sleep(time.Second)
conn, err := Dial(internet.ContextWithSecuritySettings(context.Background(), &tls.Config{
ServerName: "www.v2ray.com",
AllowInsecure: true,
}), net.TCPDestination(net.LocalHostIP, port))
assert(err, IsNil)
defer conn.Close()
const N = 1024
b1 := make([]byte, N)
common.Must2(rand.Read(b1))
b2 := buf.New()
nBytes, err := conn.Write(b1)
assert(nBytes, Equals, N)
assert(err, IsNil)
assert(b2.Reset(buf.ReadFullFrom(conn, N)), IsNil)
assert(b2.Bytes(), Equals, b1)
nBytes, err = conn.Write(b1)
assert(nBytes, Equals, N)
assert(err, IsNil)
assert(b2.Reset(buf.ReadFullFrom(conn, N)), IsNil)
assert(b2.Bytes(), Equals, b1)
}

86
transport/internet/http/hub.go Normal file
View File

@ -0,0 +1,86 @@
package http
import (
"context"
"io"
"net/http"
"v2ray.com/core/common"
"v2ray.com/core/common/net"
"v2ray.com/core/common/serial"
"v2ray.com/core/common/signal"
"v2ray.com/core/transport/internet"
"v2ray.com/core/transport/internet/tls"
)
type Listener struct {
server *http.Server
handler internet.ConnHandler
local net.Addr
}
func (l *Listener) Addr() net.Addr {
return l.local
}
func (l *Listener) Close() error {
return l.server.Shutdown(context.Background())
}
type flushWriter struct {
w io.Writer
}
func (fw flushWriter) Write(p []byte) (n int, err error) {
n, err = fw.w.Write(p)
if f, ok := fw.w.(http.Flusher); ok {
f.Flush()
}
return
}
func (l *Listener) ServeHTTP(writer http.ResponseWriter, request *http.Request) {
writer.WriteHeader(200)
if f, ok := writer.(http.Flusher); ok {
f.Flush()
}
done := signal.NewDone()
l.handler(&Connection{
Reader: request.Body,
Writer: flushWriter{writer},
Closer: common.NewChainedClosable(request.Body, done),
Local: l.Addr(),
Remote: l.Addr(),
})
<-done.C()
}
func Listen(ctx context.Context, address net.Address, port net.Port, handler internet.ConnHandler) (internet.Listener, error) {
listener := &Listener{
handler: handler,
local: &net.TCPAddr{
IP: address.IP(),
Port: int(port),
},
}
config := tls.ConfigFromContext(ctx)
if config == nil {
return nil, newError("TLS must be enabled for http transport.").AtWarning()
}
server := &http.Server{
Addr: serial.Concat(address, ":", port),
TLSConfig: config.GetTLSConfig(tls.WithNextProto("h2")),
Handler: listener,
}
listener.server = server
go server.ListenAndServeTLS("", "")
return listener, nil
}
func init() {
common.Must(internet.RegisterTransportListener(internet.TransportProtocol_HTTP, Listen))
}

4
transport/internet/tls/config.go
View File

@ -28,7 +28,6 @@ func (c *Config) BuildCertificates() []tls.Certificate {
func (c *Config) GetTLSConfig(opts ...Option) *tls.Config {
config := &tls.Config{
ClientSessionCache: globalSessionCache,
NextProtos: []string{"http/1.1"},
}
if c == nil {
return config
@ -47,6 +46,9 @@ func (c *Config) GetTLSConfig(opts ...Option) *tls.Config {
if len(c.NextProtocol) > 0 {
config.NextProtos = c.NextProtocol
}
if len(config.NextProtos) == 0 {
config.NextProtos = []string{"http/1.1"}
}
return config
}