1
0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-23 02:26:49 -05:00
v2fly/shell/point/config_json.go

278 lines
8.8 KiB
Go
Raw Normal View History

2016-01-17 15:43:10 -05:00
// +build json
package point
import (
"encoding/json"
2016-05-29 10:37:52 -04:00
"errors"
2016-01-17 15:43:10 -05:00
"io/ioutil"
"os"
"strings"
2016-08-20 14:55:45 -04:00
"v2ray.com/core/app/dns"
"v2ray.com/core/app/router"
"v2ray.com/core/common"
"v2ray.com/core/common/log"
v2net "v2ray.com/core/common/net"
"v2ray.com/core/transport"
"v2ray.com/core/transport/internet"
2016-01-17 15:43:10 -05:00
)
const (
DefaultRefreshMinute = int(9999)
)
2016-01-17 15:43:10 -05:00
func (this *Config) UnmarshalJSON(data []byte) error {
type JsonConfig struct {
2016-06-03 18:38:22 -04:00
Port v2net.Port `json:"port"` // Port of this Point server.
LogConfig *LogConfig `json:"log"`
RouterConfig *router.Config `json:"routing"`
DNSConfig *dns.Config `json:"dns"`
InboundConfig *InboundConnectionConfig `json:"inbound"`
OutboundConfig *OutboundConnectionConfig `json:"outbound"`
InboundDetours []*InboundDetourConfig `json:"inboundDetour"`
OutboundDetours []*OutboundDetourConfig `json:"outboundDetour"`
Transport *transport.Config `json:"transport"`
2016-01-17 15:43:10 -05:00
}
jsonConfig := new(JsonConfig)
if err := json.Unmarshal(data, jsonConfig); err != nil {
2016-06-11 16:52:37 -04:00
return errors.New("Point: Failed to parse config: " + err.Error())
2016-01-17 15:43:10 -05:00
}
this.Port = jsonConfig.Port
this.LogConfig = jsonConfig.LogConfig
this.RouterConfig = jsonConfig.RouterConfig
if jsonConfig.InboundConfig == nil {
return errors.New("Point: Inbound config is not specified.")
}
2016-01-17 15:43:10 -05:00
this.InboundConfig = jsonConfig.InboundConfig
if jsonConfig.OutboundConfig == nil {
return errors.New("Point: Outbound config is not specified.")
}
2016-01-17 15:43:10 -05:00
this.OutboundConfig = jsonConfig.OutboundConfig
this.InboundDetours = jsonConfig.InboundDetours
this.OutboundDetours = jsonConfig.OutboundDetours
2016-05-16 12:05:01 -04:00
if jsonConfig.DNSConfig == nil {
jsonConfig.DNSConfig = &dns.Config{
NameServers: []v2net.Destination{
v2net.UDPDestination(v2net.DomainAddress("localhost"), v2net.Port(53)),
},
}
}
2016-05-16 03:25:34 -04:00
this.DNSConfig = jsonConfig.DNSConfig
2016-06-01 19:49:25 -04:00
this.TransportConfig = jsonConfig.Transport
2016-01-17 15:43:10 -05:00
return nil
}
2016-06-03 18:38:22 -04:00
func (this *InboundConnectionConfig) UnmarshalJSON(data []byte) error {
type JsonConfig struct {
2016-06-14 16:54:08 -04:00
Port uint16 `json:"port"`
2016-08-26 18:04:35 -04:00
Listen *v2net.AddressPB `json:"listen"`
2016-06-14 16:54:08 -04:00
Protocol string `json:"protocol"`
StreamSetting *internet.StreamSettings `json:"streamSettings"`
Settings json.RawMessage `json:"settings"`
2016-08-12 17:37:21 -04:00
AllowPassive bool `json:"allowPassive"`
2016-06-03 18:38:22 -04:00
}
jsonConfig := new(JsonConfig)
if err := json.Unmarshal(data, jsonConfig); err != nil {
2016-06-11 16:52:37 -04:00
return errors.New("Point: Failed to parse inbound config: " + err.Error())
2016-06-03 18:38:22 -04:00
}
this.Port = v2net.Port(jsonConfig.Port)
this.ListenOn = v2net.AnyIP
if jsonConfig.Listen != nil {
2016-08-26 18:04:35 -04:00
if jsonConfig.Listen.AsAddress().Family().IsDomain() {
return errors.New("Point: Unable to listen on domain address: " + jsonConfig.Listen.AsAddress().Domain())
2016-06-03 18:38:22 -04:00
}
2016-08-26 18:04:35 -04:00
this.ListenOn = jsonConfig.Listen.AsAddress()
2016-06-03 18:38:22 -04:00
}
2016-06-14 16:54:08 -04:00
if jsonConfig.StreamSetting != nil {
this.StreamSettings = jsonConfig.StreamSetting
}
2016-06-03 18:38:22 -04:00
this.Protocol = jsonConfig.Protocol
this.Settings = jsonConfig.Settings
2016-08-12 17:37:21 -04:00
this.AllowPassiveConnection = jsonConfig.AllowPassive
2016-06-03 18:38:22 -04:00
return nil
}
func (this *OutboundConnectionConfig) UnmarshalJSON(data []byte) error {
2016-01-17 15:43:10 -05:00
type JsonConnectionConfig struct {
2016-06-14 16:54:08 -04:00
Protocol string `json:"protocol"`
2016-08-26 18:04:35 -04:00
SendThrough *v2net.AddressPB `json:"sendThrough"`
2016-06-14 16:54:08 -04:00
StreamSetting *internet.StreamSettings `json:"streamSettings"`
Settings json.RawMessage `json:"settings"`
2016-01-17 15:43:10 -05:00
}
jsonConfig := new(JsonConnectionConfig)
if err := json.Unmarshal(data, jsonConfig); err != nil {
2016-06-11 16:52:37 -04:00
return errors.New("Point: Failed to parse outbound config: " + err.Error())
2016-01-17 15:43:10 -05:00
}
this.Protocol = jsonConfig.Protocol
this.Settings = jsonConfig.Settings
2016-06-03 18:38:22 -04:00
if jsonConfig.SendThrough != nil {
2016-08-26 18:04:35 -04:00
address := jsonConfig.SendThrough.AsAddress()
2016-08-14 12:14:12 -04:00
if address.Family().IsDomain() {
2016-06-03 18:38:22 -04:00
return errors.New("Point: Unable to send through: " + address.String())
}
this.SendThrough = address
}
2016-06-14 16:54:08 -04:00
if jsonConfig.StreamSetting != nil {
this.StreamSettings = jsonConfig.StreamSetting
}
2016-01-17 15:43:10 -05:00
return nil
}
func (this *LogConfig) UnmarshalJSON(data []byte) error {
type JsonLogConfig struct {
AccessLog string `json:"access"`
ErrorLog string `json:"error"`
LogLevel string `json:"loglevel"`
}
jsonConfig := new(JsonLogConfig)
if err := json.Unmarshal(data, jsonConfig); err != nil {
2016-06-11 16:52:37 -04:00
return errors.New("Point: Failed to parse log config: " + err.Error())
2016-01-17 15:43:10 -05:00
}
this.AccessLog = jsonConfig.AccessLog
this.ErrorLog = jsonConfig.ErrorLog
level := strings.ToLower(jsonConfig.LogLevel)
switch level {
case "debug":
this.LogLevel = log.DebugLevel
case "info":
this.LogLevel = log.InfoLevel
case "error":
this.LogLevel = log.ErrorLevel
2016-04-29 05:36:27 -04:00
case "none":
this.LogLevel = log.NoneLevel
2016-01-17 15:43:10 -05:00
default:
this.LogLevel = log.WarningLevel
}
return nil
}
func (this *InboundDetourAllocationConfig) UnmarshalJSON(data []byte) error {
type JsonInboundDetourAllocationConfig struct {
Strategy string `json:"strategy"`
Concurrency int `json:"concurrency"`
RefreshMin int `json:"refresh"`
2016-01-17 15:43:10 -05:00
}
jsonConfig := new(JsonInboundDetourAllocationConfig)
if err := json.Unmarshal(data, jsonConfig); err != nil {
2016-06-11 16:52:37 -04:00
return errors.New("Point: Failed to parse inbound detour allocation config: " + err.Error())
2016-01-17 15:43:10 -05:00
}
this.Strategy = jsonConfig.Strategy
this.Concurrency = jsonConfig.Concurrency
this.Refresh = jsonConfig.RefreshMin
2016-02-04 05:43:04 -05:00
if this.Strategy == AllocationStrategyRandom {
if this.Refresh == 0 {
this.Refresh = 5
}
if this.Concurrency == 0 {
this.Concurrency = 3
}
}
if this.Refresh == 0 {
this.Refresh = DefaultRefreshMinute
}
2016-01-17 15:43:10 -05:00
return nil
}
func (this *InboundDetourConfig) UnmarshalJSON(data []byte) error {
type JsonInboundDetourConfig struct {
2016-06-14 16:54:08 -04:00
Protocol string `json:"protocol"`
PortRange *v2net.PortRange `json:"port"`
2016-08-26 18:04:35 -04:00
ListenOn *v2net.AddressPB `json:"listen"`
2016-06-14 16:54:08 -04:00
Settings json.RawMessage `json:"settings"`
Tag string `json:"tag"`
Allocation *InboundDetourAllocationConfig `json:"allocate"`
StreamSetting *internet.StreamSettings `json:"streamSettings"`
2016-08-12 17:37:21 -04:00
AllowPassive bool `json:"allowPassive"`
2016-01-17 15:43:10 -05:00
}
jsonConfig := new(JsonInboundDetourConfig)
if err := json.Unmarshal(data, jsonConfig); err != nil {
2016-06-11 16:52:37 -04:00
return errors.New("Point: Failed to parse inbound detour config: " + err.Error())
2016-01-17 15:43:10 -05:00
}
if jsonConfig.PortRange == nil {
log.Error("Point: Port range not specified in InboundDetour.")
2016-08-18 02:21:20 -04:00
return common.ErrBadConfiguration
2016-01-17 15:43:10 -05:00
}
2016-05-29 10:37:52 -04:00
this.ListenOn = v2net.AnyIP
if jsonConfig.ListenOn != nil {
2016-08-26 18:04:35 -04:00
if jsonConfig.ListenOn.AsAddress().Family().IsDomain() {
return errors.New("Point: Unable to listen on domain address: " + jsonConfig.ListenOn.AsAddress().Domain())
2016-05-29 10:37:52 -04:00
}
2016-08-26 18:04:35 -04:00
this.ListenOn = jsonConfig.ListenOn.AsAddress()
2016-05-29 10:37:52 -04:00
}
2016-01-17 15:43:10 -05:00
this.Protocol = jsonConfig.Protocol
this.PortRange = *jsonConfig.PortRange
this.Settings = jsonConfig.Settings
this.Tag = jsonConfig.Tag
this.Allocation = jsonConfig.Allocation
if this.Allocation == nil {
this.Allocation = &InboundDetourAllocationConfig{
Strategy: AllocationStrategyAlways,
Refresh: DefaultRefreshMinute,
}
}
2016-06-14 16:54:08 -04:00
if jsonConfig.StreamSetting != nil {
this.StreamSettings = jsonConfig.StreamSetting
}
2016-08-12 17:37:21 -04:00
this.AllowPassiveConnection = jsonConfig.AllowPassive
2016-01-17 15:43:10 -05:00
return nil
}
func (this *OutboundDetourConfig) UnmarshalJSON(data []byte) error {
type JsonOutboundDetourConfig struct {
2016-06-14 16:54:08 -04:00
Protocol string `json:"protocol"`
2016-08-26 18:04:35 -04:00
SendThrough *v2net.AddressPB `json:"sendThrough"`
2016-06-14 16:54:08 -04:00
Tag string `json:"tag"`
Settings json.RawMessage `json:"settings"`
StreamSetting *internet.StreamSettings `json:"streamSettings"`
2016-01-17 15:43:10 -05:00
}
jsonConfig := new(JsonOutboundDetourConfig)
if err := json.Unmarshal(data, jsonConfig); err != nil {
2016-06-11 16:52:37 -04:00
return errors.New("Point: Failed to parse outbound detour config: " + err.Error())
2016-01-17 15:43:10 -05:00
}
this.Protocol = jsonConfig.Protocol
this.Tag = jsonConfig.Tag
this.Settings = jsonConfig.Settings
2016-06-03 18:38:22 -04:00
if jsonConfig.SendThrough != nil {
2016-08-26 18:04:35 -04:00
address := jsonConfig.SendThrough.AsAddress()
2016-08-14 12:14:12 -04:00
if address.Family().IsDomain() {
2016-06-03 18:38:22 -04:00
return errors.New("Point: Unable to send through: " + address.String())
}
this.SendThrough = address
}
2016-06-14 16:54:08 -04:00
if jsonConfig.StreamSetting != nil {
this.StreamSettings = jsonConfig.StreamSetting
}
2016-01-17 15:43:10 -05:00
return nil
}
func JsonLoadConfig(file string) (*Config, error) {
fixedFile := os.ExpandEnv(file)
rawConfig, err := ioutil.ReadFile(fixedFile)
if err != nil {
2016-01-18 06:24:33 -05:00
log.Error("Failed to read server config file (", file, "): ", file, err)
2016-01-17 15:43:10 -05:00
return nil, err
}
jsonConfig := &Config{}
err = json.Unmarshal(rawConfig, jsonConfig)
if err != nil {
2016-01-18 06:24:33 -05:00
log.Error("Failed to load server config: ", err)
2016-01-17 15:43:10 -05:00
return nil, err
}
return jsonConfig, err
}
func init() {
configLoader = JsonLoadConfig
}