mirror of
https://gitee.com/IrisVega/frp.git
synced 2024-11-01 22:31:29 +08:00
462 lines
11 KiB
Go
462 lines
11 KiB
Go
// Copyright 2020 The frp Authors
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package config
|
|
|
|
import (
|
|
"testing"
|
|
|
|
"github.com/fatedier/frp/pkg/consts"
|
|
"github.com/stretchr/testify/assert"
|
|
|
|
"gopkg.in/ini.v1"
|
|
)
|
|
|
|
var (
|
|
testLoadOptions = ini.LoadOptions{
|
|
Insensitive: false,
|
|
InsensitiveSections: false,
|
|
InsensitiveKeys: false,
|
|
IgnoreInlineComment: true,
|
|
AllowBooleanKeys: true,
|
|
}
|
|
|
|
testProxyPrefix = "test."
|
|
)
|
|
|
|
func Test_Proxy_Interface(t *testing.T) {
|
|
for name := range proxyConfTypeMap {
|
|
NewConfByType(name)
|
|
}
|
|
}
|
|
|
|
func Test_Proxy_UnmarshalFromIni(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
testcases := []struct {
|
|
sname string
|
|
source []byte
|
|
expected ProxyConf
|
|
}{
|
|
|
|
{
|
|
sname: "ssh",
|
|
source: []byte(`
|
|
[ssh]
|
|
# tcp | udp | http | https | stcp | xtcp, default is tcp
|
|
type = tcp
|
|
local_ip = 127.0.0.9
|
|
local_port = 29
|
|
bandwidth_limit = 19MB
|
|
use_encryption
|
|
use_compression
|
|
remote_port = 6009
|
|
group = test_group
|
|
group_key = 123456
|
|
health_check_type = tcp
|
|
health_check_timeout_s = 3
|
|
health_check_max_failed = 3
|
|
health_check_interval_s = 19
|
|
meta_var1 = 123
|
|
meta_var2 = 234`),
|
|
expected: &TCPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "ssh",
|
|
ProxyType: consts.TCPProxy,
|
|
UseCompression: true,
|
|
UseEncryption: true,
|
|
Group: "test_group",
|
|
GroupKey: "123456",
|
|
BandwidthLimit: MustBandwidthQuantity("19MB"),
|
|
Metas: map[string]string{
|
|
"var1": "123",
|
|
"var2": "234",
|
|
},
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.9",
|
|
LocalPort: 29,
|
|
},
|
|
HealthCheckConf: HealthCheckConf{
|
|
HealthCheckType: consts.TCPProxy,
|
|
HealthCheckTimeoutS: 3,
|
|
HealthCheckMaxFailed: 3,
|
|
HealthCheckIntervalS: 19,
|
|
HealthCheckAddr: "127.0.0.9:29",
|
|
},
|
|
},
|
|
RemotePort: 6009,
|
|
},
|
|
},
|
|
{
|
|
sname: "ssh_random",
|
|
source: []byte(`
|
|
[ssh_random]
|
|
type = tcp
|
|
local_ip = 127.0.0.9
|
|
local_port = 29
|
|
remote_port = 9
|
|
`),
|
|
expected: &TCPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "ssh_random",
|
|
ProxyType: consts.TCPProxy,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.9",
|
|
LocalPort: 29,
|
|
},
|
|
},
|
|
RemotePort: 9,
|
|
},
|
|
},
|
|
{
|
|
sname: "dns",
|
|
source: []byte(`
|
|
[dns]
|
|
type = udp
|
|
local_ip = 114.114.114.114
|
|
local_port = 59
|
|
remote_port = 6009
|
|
use_encryption
|
|
use_compression
|
|
`),
|
|
expected: &UDPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "dns",
|
|
ProxyType: consts.UDPProxy,
|
|
UseEncryption: true,
|
|
UseCompression: true,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "114.114.114.114",
|
|
LocalPort: 59,
|
|
},
|
|
},
|
|
RemotePort: 6009,
|
|
},
|
|
},
|
|
{
|
|
sname: "web01",
|
|
source: []byte(`
|
|
[web01]
|
|
type = http
|
|
local_ip = 127.0.0.9
|
|
local_port = 89
|
|
use_encryption
|
|
use_compression
|
|
http_user = admin
|
|
http_pwd = admin
|
|
subdomain = web01
|
|
custom_domains = web02.yourdomain.com
|
|
locations = /,/pic
|
|
host_header_rewrite = example.com
|
|
header_X-From-Where = frp
|
|
health_check_type = http
|
|
health_check_url = /status
|
|
health_check_interval_s = 19
|
|
health_check_max_failed = 3
|
|
health_check_timeout_s = 3
|
|
`),
|
|
expected: &HTTPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "web01",
|
|
ProxyType: consts.HTTPProxy,
|
|
UseCompression: true,
|
|
UseEncryption: true,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.9",
|
|
LocalPort: 89,
|
|
},
|
|
HealthCheckConf: HealthCheckConf{
|
|
HealthCheckType: consts.HTTPProxy,
|
|
HealthCheckTimeoutS: 3,
|
|
HealthCheckMaxFailed: 3,
|
|
HealthCheckIntervalS: 19,
|
|
HealthCheckURL: "http://127.0.0.9:89/status",
|
|
},
|
|
},
|
|
DomainConf: DomainConf{
|
|
CustomDomains: []string{"web02.yourdomain.com"},
|
|
SubDomain: "web01",
|
|
},
|
|
Locations: []string{"/", "/pic"},
|
|
HTTPUser: "admin",
|
|
HTTPPwd: "admin",
|
|
HostHeaderRewrite: "example.com",
|
|
Headers: map[string]string{
|
|
"X-From-Where": "frp",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
sname: "web02",
|
|
source: []byte(`
|
|
[web02]
|
|
type = https
|
|
local_ip = 127.0.0.9
|
|
local_port = 8009
|
|
use_encryption
|
|
use_compression
|
|
subdomain = web01
|
|
custom_domains = web02.yourdomain.com
|
|
proxy_protocol_version = v2
|
|
`),
|
|
expected: &HTTPSProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "web02",
|
|
ProxyType: consts.HTTPSProxy,
|
|
UseCompression: true,
|
|
UseEncryption: true,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.9",
|
|
LocalPort: 8009,
|
|
},
|
|
ProxyProtocolVersion: "v2",
|
|
},
|
|
DomainConf: DomainConf{
|
|
CustomDomains: []string{"web02.yourdomain.com"},
|
|
SubDomain: "web01",
|
|
},
|
|
},
|
|
},
|
|
{
|
|
sname: "secret_tcp",
|
|
source: []byte(`
|
|
[secret_tcp]
|
|
type = stcp
|
|
sk = abcdefg
|
|
local_ip = 127.0.0.1
|
|
local_port = 22
|
|
use_encryption = false
|
|
use_compression = false
|
|
`),
|
|
expected: &STCPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "secret_tcp",
|
|
ProxyType: consts.STCPProxy,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.1",
|
|
LocalPort: 22,
|
|
},
|
|
},
|
|
Role: "server",
|
|
Sk: "abcdefg",
|
|
},
|
|
},
|
|
{
|
|
sname: "p2p_tcp",
|
|
source: []byte(`
|
|
[p2p_tcp]
|
|
type = xtcp
|
|
sk = abcdefg
|
|
local_ip = 127.0.0.1
|
|
local_port = 22
|
|
use_encryption = false
|
|
use_compression = false
|
|
`),
|
|
expected: &XTCPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "p2p_tcp",
|
|
ProxyType: consts.XTCPProxy,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.1",
|
|
LocalPort: 22,
|
|
},
|
|
},
|
|
Role: "server",
|
|
Sk: "abcdefg",
|
|
},
|
|
},
|
|
{
|
|
sname: "tcpmuxhttpconnect",
|
|
source: []byte(`
|
|
[tcpmuxhttpconnect]
|
|
type = tcpmux
|
|
multiplexer = httpconnect
|
|
local_ip = 127.0.0.1
|
|
local_port = 10701
|
|
custom_domains = tunnel1
|
|
`),
|
|
expected: &TCPMuxProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "tcpmuxhttpconnect",
|
|
ProxyType: consts.TCPMuxProxy,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.1",
|
|
LocalPort: 10701,
|
|
},
|
|
},
|
|
DomainConf: DomainConf{
|
|
CustomDomains: []string{"tunnel1"},
|
|
SubDomain: "",
|
|
},
|
|
Multiplexer: "httpconnect",
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, c := range testcases {
|
|
f, err := ini.LoadSources(testLoadOptions, c.source)
|
|
assert.NoError(err)
|
|
|
|
proxyType := f.Section(c.sname).Key("type").String()
|
|
assert.NotEmpty(proxyType)
|
|
|
|
actual := DefaultProxyConf(proxyType)
|
|
assert.NotNil(actual)
|
|
|
|
err = actual.UnmarshalFromIni(testProxyPrefix, c.sname, f.Section(c.sname))
|
|
assert.NoError(err)
|
|
assert.Equal(c.expected, actual)
|
|
}
|
|
}
|
|
|
|
func Test_RangeProxy_UnmarshalFromIni(t *testing.T) {
|
|
assert := assert.New(t)
|
|
|
|
testcases := []struct {
|
|
sname string
|
|
source []byte
|
|
expected map[string]ProxyConf
|
|
}{
|
|
{
|
|
sname: "range:tcp_port",
|
|
source: []byte(`
|
|
[range:tcp_port]
|
|
type = tcp
|
|
local_ip = 127.0.0.9
|
|
local_port = 6010-6011,6019
|
|
remote_port = 6010-6011,6019
|
|
use_encryption = false
|
|
use_compression = false
|
|
`),
|
|
expected: map[string]ProxyConf{
|
|
"tcp_port_0": &TCPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "tcp_port_0",
|
|
ProxyType: consts.TCPProxy,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.9",
|
|
LocalPort: 6010,
|
|
},
|
|
},
|
|
RemotePort: 6010,
|
|
},
|
|
"tcp_port_1": &TCPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "tcp_port_1",
|
|
ProxyType: consts.TCPProxy,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.9",
|
|
LocalPort: 6011,
|
|
},
|
|
},
|
|
RemotePort: 6011,
|
|
},
|
|
"tcp_port_2": &TCPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "tcp_port_2",
|
|
ProxyType: consts.TCPProxy,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "127.0.0.9",
|
|
LocalPort: 6019,
|
|
},
|
|
},
|
|
RemotePort: 6019,
|
|
},
|
|
},
|
|
},
|
|
{
|
|
sname: "range:udp_port",
|
|
source: []byte(`
|
|
[range:udp_port]
|
|
type = udp
|
|
local_ip = 114.114.114.114
|
|
local_port = 6000,6010-6011
|
|
remote_port = 6000,6010-6011
|
|
use_encryption
|
|
use_compression
|
|
`),
|
|
expected: map[string]ProxyConf{
|
|
"udp_port_0": &UDPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "udp_port_0",
|
|
ProxyType: consts.UDPProxy,
|
|
UseEncryption: true,
|
|
UseCompression: true,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "114.114.114.114",
|
|
LocalPort: 6000,
|
|
},
|
|
},
|
|
RemotePort: 6000,
|
|
},
|
|
"udp_port_1": &UDPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "udp_port_1",
|
|
ProxyType: consts.UDPProxy,
|
|
UseEncryption: true,
|
|
UseCompression: true,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "114.114.114.114",
|
|
LocalPort: 6010,
|
|
},
|
|
},
|
|
RemotePort: 6010,
|
|
},
|
|
"udp_port_2": &UDPProxyConf{
|
|
BaseProxyConf: BaseProxyConf{
|
|
ProxyName: testProxyPrefix + "udp_port_2",
|
|
ProxyType: consts.UDPProxy,
|
|
UseEncryption: true,
|
|
UseCompression: true,
|
|
LocalSvrConf: LocalSvrConf{
|
|
LocalIP: "114.114.114.114",
|
|
LocalPort: 6011,
|
|
},
|
|
},
|
|
RemotePort: 6011,
|
|
},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, c := range testcases {
|
|
|
|
f, err := ini.LoadSources(testLoadOptions, c.source)
|
|
assert.NoError(err)
|
|
|
|
actual := make(map[string]ProxyConf)
|
|
s := f.Section(c.sname)
|
|
|
|
err = renderRangeProxyTemplates(f, s)
|
|
assert.NoError(err)
|
|
|
|
f.DeleteSection(ini.DefaultSection)
|
|
f.DeleteSection(c.sname)
|
|
|
|
for _, section := range f.Sections() {
|
|
proxyType := section.Key("type").String()
|
|
newsname := section.Name()
|
|
|
|
tmp := DefaultProxyConf(proxyType)
|
|
err = tmp.UnmarshalFromIni(testProxyPrefix, newsname, section)
|
|
assert.NoError(err)
|
|
|
|
actual[newsname] = tmp
|
|
}
|
|
|
|
assert.Equal(c.expected, actual)
|
|
}
|
|
|
|
}
|