feat(core): register the tun-mips inbound and load it from JSON

The inbound is registered like xray's tun: it declares no listening
network, opens its device in Start, and tears the stack down in Close. Its
settings object is validated on load — name, mtu, address4 and dnsTarget
are required, address6, excludeProcesses, selfPids and directTag are
optional — so a field the service forgot fails the configuration instead
of becoming a zero value at runtime.

The JSON loader gains an inbound side. It is a separate protocol set from
the outbound one, and a protocol used in the wrong direction is an error
rather than being stripped and then silently skipped. The three production
entry points (file builder, cmdarg loader, reader loader) now share one
strip and one append step, so an inbound cannot be handled on one path
and forgotten on another. The receiver settings carry the sniffing block,
which is what the proxyman builds the sniffing context from.

Tests load the document the service will generate through both the file
and the reader path and check tag, sniffing, every settings field, no
listening port, and that the native socks inbound beside it is untouched;
they reject tun-mips as an outbound and anytls as an inbound, fail a
document missing dnsTarget, and confirm a document without custom
protocols is returned byte-identical.
This commit is contained in:
Zakk committed 2026-09-19 10:34:55 +10:00
1 parent 834d8dd340
commit fa051aa35f
7 files changed
+818 -65

No files matched your search

+195 -65
View File
@@ -20,6 +20,7 @@ import (
hint_anytls "github.com/v2rayA/v2raya-core/hint/proxy/anytls"
hint_juicity "github.com/v2rayA/v2raya-core/hint/proxy/juicity"
hint_tuic "github.com/v2rayA/v2raya-core/hint/proxy/tuic"
hint_tunmips "github.com/v2rayA/v2raya-core/hint/proxy/tunmips"
xray_commander "github.com/xtls/xray-core/app/commander"
xray_proxyman "github.com/xtls/xray-core/app/proxyman"
"github.com/xtls/xray-core/common"
@@ -86,6 +87,14 @@ type customOutboundJSON struct {
StreamSettings json.RawMessage `json:"streamSettings"`
}
// customInboundJSON is the raw JSON form of a tun-mips inbound.
type customInboundJSON struct {
Protocol string `json:"protocol"`
Tag string `json:"tag"`
Settings json.RawMessage `json:"settings"`
Sniffing *xray_conf.SniffingConfig `json:"sniffing"`
}
// customProtocols is the set of outbound protocols handled by hint/proxy.
var customProtocols = map[string]bool{
"anytls": true,
@@ -93,53 +102,122 @@ var customProtocols = map[string]bool{
"tuic": true,
}
// stripCustomOutbounds parses raw JSON, removes custom-protocol outbound entries,
// and returns the modified JSON along with the stripped outbound descriptors.
// If the JSON is not valid or has no outbounds, raw is returned unchanged with
// nil custom list (safe to pass to xray unmodified).
func stripCustomOutbounds(raw []byte) ([]byte, []customOutboundJSON, error) {
// customInboundProtocols is the set of inbound protocols handled by
// hint/proxy. It is kept apart from customProtocols so that a protocol used
// in the wrong direction is rejected instead of being stripped and then
// silently dropped.
var customInboundProtocols = map[string]bool{
"tun-mips": true,
}
// customConfig is everything stripped from one JSON document before xray
// parses it.
type customConfig struct {
outbounds []customOutboundJSON
inbounds []customInboundJSON
}
func (c *customConfig) empty() bool {
return c == nil || (len(c.outbounds) == 0 && len(c.inbounds) == 0)
}
func (c *customConfig) merge(other *customConfig) {
if other == nil {
return
}
c.outbounds = append(c.outbounds, other.outbounds...)
c.inbounds = append(c.inbounds, other.inbounds...)
}
// stripCustom removes hint/proxy outbounds and inbounds from raw JSON and
// returns the modified document with the stripped descriptors. Invalid JSON
// or a document without those arrays is returned unchanged, nothing
// stripped, for xray to report on.
func stripCustom(raw []byte) ([]byte, *customConfig, error) {
var doc map[string]json.RawMessage
if err := json.Unmarshal(raw, &doc); err != nil {
return raw, nil, nil
}
outboundsRaw, ok := doc["outbounds"]
if !ok {
return raw, nil, nil
}
var outbounds []json.RawMessage
if err := json.Unmarshal(outboundsRaw, &outbounds); err != nil {
return raw, nil, nil
}
custom := &customConfig{}
changed := false
var remaining []json.RawMessage
var custom []customOutboundJSON
for _, ob := range outbounds {
var probe struct {
Protocol string `json:"protocol"`
}
if err := json.Unmarshal(ob, &probe); err != nil {
remaining = append(remaining, ob)
continue
}
if customProtocols[probe.Protocol] {
var c customOutboundJSON
if err := json.Unmarshal(ob, &c); err == nil {
custom = append(custom, c)
if outboundsRaw, ok := doc["outbounds"]; ok {
var outbounds []json.RawMessage
if err := json.Unmarshal(outboundsRaw, &outbounds); err == nil {
var remaining []json.RawMessage
for _, ob := range outbounds {
var probe struct {
Protocol string `json:"protocol"`
Tag string `json:"tag"`
}
if err := json.Unmarshal(ob, &probe); err != nil {
remaining = append(remaining, ob)
continue
}
if customInboundProtocols[probe.Protocol] {
return raw, nil, errors.New("protocol ", probe.Protocol, " is an inbound, not valid as outbound (tag ", probe.Tag, ")")
}
if !customProtocols[probe.Protocol] {
remaining = append(remaining, ob)
continue
}
var c customOutboundJSON
if err := json.Unmarshal(ob, &c); err != nil {
return raw, nil, errors.New("invalid ", probe.Protocol, " outbound (tag ", probe.Tag, ")").Base(err)
}
custom.outbounds = append(custom.outbounds, c)
}
if len(custom.outbounds) > 0 {
newOutbounds, err := json.Marshal(remaining)
if err != nil {
return raw, nil, err
}
doc["outbounds"] = newOutbounds
changed = true
}
} else {
remaining = append(remaining, ob)
}
}
if len(custom) == 0 {
return raw, nil, nil
if inboundsRaw, ok := doc["inbounds"]; ok {
var inbounds []json.RawMessage
if err := json.Unmarshal(inboundsRaw, &inbounds); err == nil {
var remaining []json.RawMessage
for _, ib := range inbounds {
var probe struct {
Protocol string `json:"protocol"`
Tag string `json:"tag"`
}
if err := json.Unmarshal(ib, &probe); err != nil {
remaining = append(remaining, ib)
continue
}
if customProtocols[probe.Protocol] {
return raw, nil, errors.New("protocol ", probe.Protocol, " is an outbound, not valid as inbound (tag ", probe.Tag, ")")
}
if !customInboundProtocols[probe.Protocol] {
remaining = append(remaining, ib)
continue
}
var c customInboundJSON
if err := json.Unmarshal(ib, &c); err != nil {
return raw, nil, errors.New("invalid ", probe.Protocol, " inbound (tag ", probe.Tag, ")").Base(err)
}
custom.inbounds = append(custom.inbounds, c)
}
if len(custom.inbounds) > 0 {
newInbounds, err := json.Marshal(remaining)
if err != nil {
return raw, nil, err
}
doc["inbounds"] = newInbounds
changed = true
}
}
}
newOutbounds, err := json.Marshal(remaining)
if err != nil {
return raw, nil, err
if !changed {
return raw, nil, nil
}
doc["outbounds"] = newOutbounds
modified, err := json.Marshal(doc)
if err != nil {
return raw, nil, err
@@ -147,6 +225,70 @@ func stripCustomOutbounds(raw []byte) ([]byte, []customOutboundJSON, error) {
return modified, custom, nil
}
// buildCustomInbounds converts stripped inbound descriptors into
// InboundHandlerConfig entries. The receiver settings carry the sniffing
// block so the proxyman builds the same sniffing context it would for a
// native inbound; there is no port because the device is the input.
func buildCustomInbounds(customs []customInboundJSON) ([]*xray_core.InboundHandlerConfig, error) {
result := make([]*xray_core.InboundHandlerConfig, 0, len(customs))
for _, c := range customs {
receiver := &xray_proxyman.ReceiverConfig{}
if c.Sniffing != nil {
sniffing, err := c.Sniffing.Build()
if err != nil {
return nil, errors.New("invalid sniffing settings for tag ", c.Tag).Base(err)
}
receiver.SniffingSettings = sniffing
}
var proxySettings *serial.TypedMessage
switch c.Protocol {
case "tun-mips":
var raw hint_tunmips.ConfigJSON
if len(c.Settings) == 0 {
return nil, errors.New("tun-mips inbound (tag ", c.Tag, ") has no settings")
}
if err := json.Unmarshal(c.Settings, &raw); err != nil {
return nil, errors.New("invalid tun-mips settings for tag ", c.Tag).Base(err)
}
cfg, err := raw.Build()
if err != nil {
return nil, errors.New("invalid tun-mips settings for tag ", c.Tag).Base(err)
}
proxySettings = serial.ToTypedMessage(cfg)
default:
return nil, errors.New("unknown custom inbound protocol ", c.Protocol)
}
result = append(result, &xray_core.InboundHandlerConfig{
Tag: c.Tag,
ReceiverSettings: serial.ToTypedMessage(receiver),
ProxySettings: proxySettings,
})
}
return result, nil
}
// appendCustom adds the stripped descriptors to a built core config.
func appendCustom(coreConfig *xray_core.Config, custom *customConfig) error {
if custom.empty() {
return nil
}
if len(custom.outbounds) > 0 {
customOutbounds, err := buildCustomOutbounds(custom.outbounds)
if err != nil {
return err
}
coreConfig.Outbound = append(coreConfig.Outbound, customOutbounds...)
}
if len(custom.inbounds) > 0 {
customInbounds, err := buildCustomInbounds(custom.inbounds)
if err != nil {
return err
}
coreConfig.Inbound = append(coreConfig.Inbound, customInbounds...)
}
return nil
}
// buildCustomOutbounds converts stripped custom outbound JSON descriptors into
// xray OutboundHandlerConfig proto messages ready to append to coreConfig.Outbound.
func buildCustomOutbounds(customs []customOutboundJSON) ([]*xray_core.OutboundHandlerConfig, error) {
@@ -381,7 +523,7 @@ func injectCompatService(coreConfig *xray_core.Config) {
// also extracts the extendedJSON fields (e.g. multiObservatory).
// Custom-protocol outbounds (anytls, juicity) are stripped from the JSON
// before xray processes it, and returned separately.
func loadAndExtend(arg string) (*xray_conf.Config, *extendedJSON, []customOutboundJSON, error) {
func loadAndExtend(arg string) (*xray_conf.Config, *extendedJSON, *customConfig, error) {
r, err := confloader.LoadConfig(arg)
if err != nil {
return nil, nil, nil, errors.New("failed to read config: ", arg).Base(err)
@@ -390,9 +532,9 @@ func loadAndExtend(arg string) (*xray_conf.Config, *extendedJSON, []customOutbou
if err != nil {
return nil, nil, nil, errors.New("failed to read config bytes: ", arg).Base(err)
}
modified, customs, err := stripCustomOutbounds(raw)
modified, customs, err := stripCustom(raw)
if err != nil {
return nil, nil, nil, errors.New("failed to strip custom outbounds: ", arg).Base(err)
return nil, nil, nil, errors.New("failed to strip custom protocols: ", arg).Base(err)
}
c, err := conf_serial.DecodeJSONConfig(bytes.NewReader(modified))
if err != nil {
@@ -410,7 +552,7 @@ func loadAndExtend(arg string) (*xray_conf.Config, *extendedJSON, []customOutbou
func buildConfigFromFiles(files []*xray_core.ConfigSource) (*xray_core.Config, error) {
cf := &xray_conf.Config{}
var ext *extendedJSON
var allCustoms []customOutboundJSON
allCustoms := &customConfig{}
for i, file := range files {
errors.LogInfo(context.Background(), "v2raya-core: reading config: ", file)
@@ -423,12 +565,12 @@ func buildConfigFromFiles(files []*xray_core.ConfigSource) (*xray_core.Config, e
return nil, errors.New("failed to read config bytes: ", file).Base(err)
}
// Strip custom outbounds before passing to xray.
modified, customs, err := stripCustomOutbounds(raw)
// Strip custom protocols before passing to xray.
modified, customs, err := stripCustom(raw)
if err != nil {
return nil, errors.New("failed to strip custom outbounds: ", file).Base(err)
return nil, errors.New("failed to strip custom protocols: ", file).Base(err)
}
allCustoms = append(allCustoms, customs...)
allCustoms.merge(customs)
c, err := conf_serial.DecodeJSONConfig(bytes.NewReader(modified))
if err != nil {
@@ -458,12 +600,8 @@ func buildConfigFromFiles(files []*xray_core.ConfigSource) (*xray_core.Config, e
}
injectCompatService(coreConfig)
reorderAppsForAPIReadiness(coreConfig)
if len(allCustoms) > 0 {
customOutbounds, err := buildCustomOutbounds(allCustoms)
if err != nil {
return nil, err
}
coreConfig.Outbound = append(coreConfig.Outbound, customOutbounds...)
if err := appendCustom(coreConfig, allCustoms); err != nil {
return nil, err
}
return coreConfig, nil
}
@@ -479,7 +617,7 @@ func init() {
Extension: []string{"json"},
Loader: func(input interface{}) (*xray_core.Config, error) {
var ext *extendedJSON
var allCustoms []customOutboundJSON
allCustoms := &customConfig{}
switch v := input.(type) {
case cmdarg.Arg:
@@ -499,7 +637,7 @@ func init() {
if e != nil && (e.MultiObservatory != nil || e.BurstObservatory != nil) {
ext = e
}
allCustoms = append(allCustoms, customs...)
allCustoms.merge(customs)
}
coreConfig, err := cf.Build()
if err != nil {
@@ -512,12 +650,8 @@ func init() {
}
injectCompatService(coreConfig)
reorderAppsForAPIReadiness(coreConfig)
if len(allCustoms) > 0 {
customOutbounds, err := buildCustomOutbounds(allCustoms)
if err != nil {
return nil, err
}
coreConfig.Outbound = append(coreConfig.Outbound, customOutbounds...)
if err := appendCustom(coreConfig, allCustoms); err != nil {
return nil, err
}
return coreConfig, nil
@@ -526,9 +660,9 @@ func init() {
if err != nil {
return nil, errors.New("failed to read config reader").Base(err)
}
modified, customs, err := stripCustomOutbounds(raw)
modified, customs, err := stripCustom(raw)
if err != nil {
return nil, errors.New("failed to strip custom outbounds").Base(err)
return nil, errors.New("failed to strip custom protocols").Base(err)
}
c, err := conf_serial.DecodeJSONConfig(bytes.NewReader(modified))
if err != nil {
@@ -547,12 +681,8 @@ func init() {
}
injectCompatService(coreConfig)
reorderAppsForAPIReadiness(coreConfig)
if len(customs) > 0 {
customOutbounds, err := buildCustomOutbounds(customs)
if err != nil {
return nil, err
}
coreConfig.Outbound = append(coreConfig.Outbound, customOutbounds...)
if err := appendCustom(coreConfig, customs); err != nil {
return nil, err
}
return coreConfig, nil
+157
View File
@@ -0,0 +1,157 @@
// SPDX-License-Identifier: MPL-2.0
package conf
import (
"bytes"
"os"
"path/filepath"
"strings"
"testing"
hint_tunmips "github.com/v2rayA/v2raya-core/hint/proxy/tunmips"
xray_proxyman "github.com/xtls/xray-core/app/proxyman"
xray_core "github.com/xtls/xray-core/core"
_ "github.com/xtls/xray-core/main/confloader/external"
)
const tunMipsDoc = `{
"inbounds": [
{"port": 20170, "protocol": "socks", "listen": "127.0.0.1", "settings": {"udp": true}, "tag": "socks"},
{
"protocol": "tun-mips",
"tag": "transparent",
"sniffing": {"enabled": true, "destOverride": ["http", "tls", "quic"], "routeOnly": false},
"settings": {
"name": "tun0",
"mtu": 1500,
"address4": "10.0.85.2/30",
"address6": "%s",
"dnsTarget": "127.0.0.1:52353",
"excludeProcesses": ["curl", "v2raya"],
"selfPids": [4242]
}
}
],
"outbounds": [
{"protocol": "freedom", "tag": "direct"}
]
}`
func tunMipsJSON(address6 string) []byte {
return []byte(strings.Replace(tunMipsDoc, "%s", address6, 1))
}
// loadBothWays runs the document through the file builder and the reader
// loader, the two production entry points, and checks they agree.
func loadBothWays(t *testing.T, raw []byte) *xray_core.Config {
t.Helper()
path := filepath.Join(t.TempDir(), "config.json")
if err := os.WriteFile(path, raw, 0o600); err != nil {
t.Fatal(err)
}
fromFile, err := buildConfigFromFiles([]*xray_core.ConfigSource{{Name: path, Format: "json"}})
if err != nil {
t.Fatalf("buildConfigFromFiles: %v", err)
}
fromReader, err := xray_core.LoadConfig("json", bytes.NewReader(raw))
if err != nil {
t.Fatalf("LoadConfig(reader): %v", err)
}
if len(fromFile.Inbound) != len(fromReader.Inbound) || len(fromFile.Outbound) != len(fromReader.Outbound) {
t.Fatalf("file and reader paths disagree: %d/%d inbounds, %d/%d outbounds",
len(fromFile.Inbound), len(fromReader.Inbound), len(fromFile.Outbound), len(fromReader.Outbound))
}
return fromFile
}
func findInbound(t *testing.T, cfg *xray_core.Config, tag string) *xray_core.InboundHandlerConfig {
t.Helper()
for _, ib := range cfg.Inbound {
if ib.Tag == tag {
return ib
}
}
t.Fatalf("no inbound tagged %q among %d", tag, len(cfg.Inbound))
return nil
}
func TestTunMipsInboundIsBuilt(t *testing.T) {
for _, address6 := range []string{"fdfe:dcba:9876::2/126", ""} {
t.Run("address6="+address6, func(t *testing.T) {
cfg := loadBothWays(t, tunMipsJSON(address6))
if len(cfg.Inbound) != 2 {
t.Fatalf("%d inbounds, want the socks one and tun-mips", len(cfg.Inbound))
}
// The native inbound went through xray untouched.
findInbound(t, cfg, "socks")
ib := findInbound(t, cfg, "transparent")
proxy, err := ib.ProxySettings.GetInstance()
if err != nil {
t.Fatal(err)
}
tc, ok := proxy.(*hint_tunmips.Config)
if !ok {
t.Fatalf("proxy settings are %T", proxy)
}
if tc.Name != "tun0" || tc.Mtu != 1500 || tc.Address4 != "10.0.85.2/30" || tc.Address6 != address6 ||
tc.DnsTarget != "127.0.0.1:52353" || len(tc.ExcludeProcesses) != 2 || len(tc.SelfPids) != 1 || tc.SelfPids[0] != 4242 {
t.Fatalf("config %+v", tc)
}
receiver, err := ib.ReceiverSettings.GetInstance()
if err != nil {
t.Fatal(err)
}
rc := receiver.(*xray_proxyman.ReceiverConfig)
if rc.SniffingSettings == nil || !rc.SniffingSettings.Enabled || len(rc.SniffingSettings.DestinationOverride) != 3 {
t.Fatalf("sniffing settings %+v", rc.SniffingSettings)
}
if rc.PortList != nil {
t.Fatalf("tun-mips inbound must not listen, got ports %+v", rc.PortList)
}
})
}
}
func TestWrongDirectionIsRejectedNotDropped(t *testing.T) {
for _, tc := range []struct{ name, doc, want string }{
{"tun-mips as outbound",
`{"outbounds": [{"protocol": "freedom", "tag": "direct"}, {"protocol": "tun-mips", "tag": "oops", "settings": {}}]}`,
"not valid as outbound"},
{"anytls as inbound",
`{"inbounds": [{"protocol": "anytls", "tag": "oops", "settings": {}}]}`,
"not valid as inbound"},
} {
t.Run(tc.name, func(t *testing.T) {
_, _, err := stripCustom([]byte(tc.doc))
if err == nil || !strings.Contains(err.Error(), tc.want) {
t.Fatalf("err = %v, want %q", err, tc.want)
}
if _, err := xray_core.LoadConfig("json", strings.NewReader(tc.doc)); err == nil {
t.Fatal("LoadConfig accepted a protocol in the wrong direction")
}
})
}
}
func TestTunMipsMissingRequiredFieldFails(t *testing.T) {
doc := strings.Replace(string(tunMipsJSON("")), `"dnsTarget": "127.0.0.1:52353",`, "", 1)
_, err := xray_core.LoadConfig("json", strings.NewReader(doc))
if err == nil || !strings.Contains(err.Error(), "dnsTarget") {
t.Fatalf("err = %v, want a dnsTarget complaint", err)
}
}
// TestDocumentWithoutCustomProtocolsIsUntouched is the behaviour-neutrality
// check for configurations the service generates today.
func TestDocumentWithoutCustomProtocolsIsUntouched(t *testing.T) {
raw := []byte(`{"inbounds": [{"port": 20170, "protocol": "socks", "tag": "socks"}], "outbounds": [{"protocol": "freedom", "tag": "direct"}]}`)
modified, custom, err := stripCustom(raw)
if err != nil {
t.Fatal(err)
}
if !bytes.Equal(modified, raw) || !custom.empty() {
t.Fatalf("document was rewritten: %s", modified)
}
}
+208
View File
@@ -0,0 +1,208 @@
// Code generated by protoc-gen-go. DO NOT EDIT.
// versions:
// protoc-gen-go v1.36.11
// protoc v7.34.2
// source: config.proto
package tunmips
import (
protoreflect "google.golang.org/protobuf/reflect/protoreflect"
protoimpl "google.golang.org/protobuf/runtime/protoimpl"
reflect "reflect"
sync "sync"
unsafe "unsafe"
)
const (
// Verify that this generated code is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(20 - protoimpl.MinVersion)
// Verify that runtime/protoimpl is sufficiently up-to-date.
_ = protoimpl.EnforceVersion(protoimpl.MaxVersion - 20)
)
// Config is the "tun-mips" inbound: a TUN device the core owns, driven by a
// user-space IP stack. The service side manages routes; the core creates
// the device and assigns its addresses.
type Config struct {
state protoimpl.MessageState `protogen:"open.v1"`
// Interface name. On macOS "utun" lets the kernel pick the unit.
Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
Mtu uint32 `protobuf:"varint,2,opt,name=mtu,proto3" json:"mtu,omitempty"`
// Operating-system side IPv4 address with prefix, e.g. "10.0.85.2/30".
Address4 string `protobuf:"bytes,3,opt,name=address4,proto3" json:"address4,omitempty"`
// Optional IPv6 address with prefix; empty disables IPv6 on the device.
Address6 string `protobuf:"bytes,4,opt,name=address6,proto3" json:"address6,omitempty"`
// host:port of the core's DNS module; port-53 flows to non-local
// resolvers are relayed there.
DnsTarget string `protobuf:"bytes,5,opt,name=dns_target,json=dnsTarget,proto3" json:"dns_target,omitempty"`
// Executable basenames whose flows bypass the proxy.
ExcludeProcesses []string `protobuf:"bytes,6,rep,name=exclude_processes,json=excludeProcesses,proto3" json:"exclude_processes,omitempty"`
// PIDs whose flows always bypass the proxy (v2rayA and the core itself).
SelfPids []uint32 `protobuf:"varint,7,rep,packed,name=self_pids,json=selfPids,proto3" json:"self_pids,omitempty"`
// Outbound tag used for excluded flows; "direct" when empty.
DirectTag string `protobuf:"bytes,8,opt,name=direct_tag,json=directTag,proto3" json:"direct_tag,omitempty"`
UserLevel uint32 `protobuf:"varint,9,opt,name=user_level,json=userLevel,proto3" json:"user_level,omitempty"`
unknownFields protoimpl.UnknownFields
sizeCache protoimpl.SizeCache
}
func (x *Config) Reset() {
*x = Config{}
mi := &file_config_proto_msgTypes[0]
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
ms.StoreMessageInfo(mi)
}
func (x *Config) String() string {
return protoimpl.X.MessageStringOf(x)
}
func (*Config) ProtoMessage() {}
func (x *Config) ProtoReflect() protoreflect.Message {
mi := &file_config_proto_msgTypes[0]
if x != nil {
ms := protoimpl.X.MessageStateOf(protoimpl.Pointer(x))
if ms.LoadMessageInfo() == nil {
ms.StoreMessageInfo(mi)
}
return ms
}
return mi.MessageOf(x)
}
// Deprecated: Use Config.ProtoReflect.Descriptor instead.
func (*Config) Descriptor() ([]byte, []int) {
return file_config_proto_rawDescGZIP(), []int{0}
}
func (x *Config) GetName() string {
if x != nil {
return x.Name
}
return ""
}
func (x *Config) GetMtu() uint32 {
if x != nil {
return x.Mtu
}
return 0
}
func (x *Config) GetAddress4() string {
if x != nil {
return x.Address4
}
return ""
}
func (x *Config) GetAddress6() string {
if x != nil {
return x.Address6
}
return ""
}
func (x *Config) GetDnsTarget() string {
if x != nil {
return x.DnsTarget
}
return ""
}
func (x *Config) GetExcludeProcesses() []string {
if x != nil {
return x.ExcludeProcesses
}
return nil
}
func (x *Config) GetSelfPids() []uint32 {
if x != nil {
return x.SelfPids
}
return nil
}
func (x *Config) GetDirectTag() string {
if x != nil {
return x.DirectTag
}
return ""
}
func (x *Config) GetUserLevel() uint32 {
if x != nil {
return x.UserLevel
}
return 0
}
var File_config_proto protoreflect.FileDescriptor
const file_config_proto_rawDesc = "" +
"\n" +
"\fconfig.proto\x12\x14v2raya.proxy.tunmips\"\x8d\x02\n" +
"\x06Config\x12\x12\n" +
"\x04name\x18\x01 \x01(\tR\x04name\x12\x10\n" +
"\x03mtu\x18\x02 \x01(\rR\x03mtu\x12\x1a\n" +
"\baddress4\x18\x03 \x01(\tR\baddress4\x12\x1a\n" +
"\baddress6\x18\x04 \x01(\tR\baddress6\x12\x1d\n" +
"\n" +
"dns_target\x18\x05 \x01(\tR\tdnsTarget\x12+\n" +
"\x11exclude_processes\x18\x06 \x03(\tR\x10excludeProcesses\x12\x1b\n" +
"\tself_pids\x18\a \x03(\rR\bselfPids\x12\x1d\n" +
"\n" +
"direct_tag\x18\b \x01(\tR\tdirectTag\x12\x1d\n" +
"\n" +
"user_level\x18\t \x01(\rR\tuserLevelB2Z0github.com/v2rayA/v2raya-core/hint/proxy/tunmipsb\x06proto3"
var (
file_config_proto_rawDescOnce sync.Once
file_config_proto_rawDescData []byte
)
func file_config_proto_rawDescGZIP() []byte {
file_config_proto_rawDescOnce.Do(func() {
file_config_proto_rawDescData = protoimpl.X.CompressGZIP(unsafe.Slice(unsafe.StringData(file_config_proto_rawDesc), len(file_config_proto_rawDesc)))
})
return file_config_proto_rawDescData
}
var file_config_proto_msgTypes = make([]protoimpl.MessageInfo, 1)
var file_config_proto_goTypes = []any{
(*Config)(nil), // 0: v2raya.proxy.tunmips.Config
}
var file_config_proto_depIdxs = []int32{
0, // [0:0] is the sub-list for method output_type
0, // [0:0] is the sub-list for method input_type
0, // [0:0] is the sub-list for extension type_name
0, // [0:0] is the sub-list for extension extendee
0, // [0:0] is the sub-list for field type_name
}
func init() { file_config_proto_init() }
func file_config_proto_init() {
if File_config_proto != nil {
return
}
type x struct{}
out := protoimpl.TypeBuilder{
File: protoimpl.DescBuilder{
GoPackagePath: reflect.TypeOf(x{}).PkgPath(),
RawDescriptor: unsafe.Slice(unsafe.StringData(file_config_proto_rawDesc), len(file_config_proto_rawDesc)),
NumEnums: 0,
NumMessages: 1,
NumExtensions: 0,
NumServices: 0,
},
GoTypes: file_config_proto_goTypes,
DependencyIndexes: file_config_proto_depIdxs,
MessageInfos: file_config_proto_msgTypes,
}.Build()
File_config_proto = out.File
file_config_proto_goTypes = nil
file_config_proto_depIdxs = nil
}
+27
View File
@@ -0,0 +1,27 @@
syntax = "proto3";
package v2raya.proxy.tunmips;
option go_package = "github.com/v2rayA/v2raya-core/hint/proxy/tunmips";
// Config is the "tun-mips" inbound: a TUN device the core owns, driven by a
// user-space IP stack. The service side manages routes; the core creates
// the device and assigns its addresses.
message Config {
// Interface name. On macOS "utun" lets the kernel pick the unit.
string name = 1;
uint32 mtu = 2;
// Operating-system side IPv4 address with prefix, e.g. "10.0.85.2/30".
string address4 = 3;
// Optional IPv6 address with prefix; empty disables IPv6 on the device.
string address6 = 4;
// host:port of the core's DNS module; port-53 flows to non-local
// resolvers are relayed there.
string dns_target = 5;
// Executable basenames whose flows bypass the proxy.
repeated string exclude_processes = 6;
// PIDs whose flows always bypass the proxy (v2rayA and the core itself).
repeated uint32 self_pids = 7;
// Outbound tag used for excluded flows; "direct" when empty.
string direct_tag = 8;
uint32 user_level = 9;
}
+55
View File
@@ -0,0 +1,55 @@
// SPDX-License-Identifier: MPL-2.0
package tunmips
import (
"errors"
"net/netip"
)
// ConfigJSON is the "settings" object of a tun-mips inbound as the service
// writes it. Required fields are checked here so a missing one fails to
// load instead of silently becoming a zero value; the optional ones default
// to "no IPv6", "no exclusions" and "direct".
type ConfigJSON struct {
Name string `json:"name"`
MTU uint32 `json:"mtu"`
Address4 string `json:"address4"`
Address6 string `json:"address6"`
DnsTarget string `json:"dnsTarget"`
ExcludeProcesses []string `json:"excludeProcesses"`
SelfPids []uint32 `json:"selfPids"`
DirectTag string `json:"directTag"`
UserLevel uint32 `json:"userLevel"`
}
// Build validates and converts to the proto Config.
func (c *ConfigJSON) Build() (*Config, error) {
if c.Name == "" {
return nil, errors.New("tun-mips: name is required")
}
if c.MTU == 0 {
return nil, errors.New("tun-mips: mtu is required")
}
if p, err := netip.ParsePrefix(c.Address4); err != nil || !p.Addr().Is4() {
return nil, errors.New("tun-mips: address4 must be an IPv4 prefix such as 10.0.85.2/30")
}
if c.Address6 != "" {
if p, err := netip.ParsePrefix(c.Address6); err != nil || !p.Addr().Is6() {
return nil, errors.New("tun-mips: address6 must be an IPv6 prefix or empty")
}
}
if _, err := netip.ParseAddrPort(c.DnsTarget); err != nil {
return nil, errors.New("tun-mips: dnsTarget must be host:port")
}
return &Config{
Name: c.Name,
Mtu: c.MTU,
Address4: c.Address4,
Address6: c.Address6,
DnsTarget: c.DnsTarget,
ExcludeProcesses: c.ExcludeProcesses,
SelfPids: c.SelfPids,
DirectTag: c.DirectTag,
UserLevel: c.UserLevel,
}, nil
}
+174
View File
@@ -0,0 +1,174 @@
// SPDX-License-Identifier: MPL-2.0
package tunmips
import (
"context"
"fmt"
"net/netip"
"os"
"sync"
"github.com/xtls/xray-core/common"
"github.com/xtls/xray-core/common/errors"
"github.com/xtls/xray-core/common/net"
"github.com/xtls/xray-core/common/session"
"github.com/xtls/xray-core/core"
"github.com/xtls/xray-core/features/policy"
"github.com/xtls/xray-core/features/routing"
"github.com/xtls/xray-core/features/stats"
"github.com/xtls/xray-core/transport/internet/stat"
"golang.zx2c4.com/wireguard/tun"
)
// Handler is the "tun-mips" inbound. Like xray's tun inbound it listens on
// no port: its input is the device it opens in Start.
type Handler struct {
ctx context.Context
config *Config
tag string
sniff session.SniffingRequest
pm policy.Manager
dsp routing.Dispatcher
addr4 netip.Prefix
addr6 netip.Prefix
uplink stats.Counter
downlnk stats.Counter
mu sync.Mutex
dev tun.Device
stack *mipsStack
fwd *forwarder
}
func newHandler(ctx context.Context, config *Config) (*Handler, error) {
h := &Handler{ctx: ctx, config: config}
if config.Name == "" {
return nil, errors.New("tun-mips: name is required")
}
if config.Mtu == 0 {
return nil, errors.New("tun-mips: mtu is required")
}
var err error
if h.addr4, err = netip.ParsePrefix(config.Address4); err != nil || !h.addr4.Addr().Is4() {
return nil, errors.New("tun-mips: address4 must be an IPv4 prefix, got ", fmt.Sprintf("%q", config.Address4))
}
if config.Address6 != "" {
if h.addr6, err = netip.ParsePrefix(config.Address6); err != nil || !h.addr6.Addr().Is6() {
return nil, errors.New("tun-mips: address6 must be an IPv6 prefix, got ", fmt.Sprintf("%q", config.Address6))
}
}
if config.DnsTarget == "" {
return nil, errors.New("tun-mips: dnsTarget is required")
}
if _, err := netip.ParseAddrPort(config.DnsTarget); err != nil {
return nil, errors.New("tun-mips: dnsTarget must be host:port, got ", fmt.Sprintf("%q", config.DnsTarget))
}
return h, nil
}
// Init receives the tag and sniffing request the proxyman set in ctx.
func (h *Handler) Init(ctx context.Context, pm policy.Manager, dsp routing.Dispatcher) error {
if inbound := session.InboundFromContext(ctx); inbound != nil {
h.tag = inbound.Tag
}
if content := session.ContentFromContext(ctx); content != nil {
h.sniff = content.SniffingRequest
}
h.ctx = core.ToBackgroundDetachedContext(ctx)
h.pm, h.dsp = pm, dsp
if h.tag != "" {
if sm, ok := core.MustFromContext(ctx).GetFeature(stats.ManagerType()).(stats.Manager); ok {
if pm.ForSystem().Stats.InboundUplink {
h.uplink, _ = sm.GetOrRegisterCounter("inbound>>>" + h.tag + ">>>traffic>>>uplink")
}
if pm.ForSystem().Stats.InboundDownlink {
h.downlnk, _ = sm.GetOrRegisterCounter("inbound>>>" + h.tag + ">>>traffic>>>downlink")
}
}
}
return nil
}
// Start opens the device, assigns its addresses and starts the stack.
func (h *Handler) Start() error {
h.mu.Lock()
defer h.mu.Unlock()
dev, err := openDevice(h.config.Name, h.config.Mtu, h.addr4, h.addr6)
if err != nil {
return err
}
name, _ := dev.Name()
fwd := newForwarder(h.ctx, h.dsp)
fwd.tag = h.tag
fwd.sniffing = h.sniff
fwd.userLevel = h.config.UserLevel
fwd.uplink, fwd.downlink = h.uplink, h.downlnk
fwd.dns = newDNSHijack(h.config.DnsTarget)
selfPids := append([]uint32{uint32(os.Getpid())}, h.config.SelfPids...)
fwd.excl = newExclusion(h.config.ExcludeProcesses, selfPids)
fwd.directTag = h.config.DirectTag
if fwd.directTag == "" {
fwd.directTag = "direct"
}
stack := newMipsStack(h.config.Mtu)
if err := stack.Start(dev, fwd.handlers()); err != nil {
dev.Close()
return errors.New("tun-mips: start stack on ", name).Base(err)
}
h.dev, h.stack, h.fwd = dev, stack, fwd
errors.LogInfo(h.ctx, "tun-mips: ", name, " up, ", h.addr4, " ", h.config.Address6)
go h.watch(name, stack, dev)
return nil
}
// watch reports a pump failure and closes the device. The core keeps
// running, as with xray's tun inbound; the service's connectivity monitor
// sees the device disappear and pauses the transparent proxy.
func (h *Handler) watch(name string, stack *mipsStack, dev tun.Device) {
<-stack.done
if err := stack.Err(); err != nil {
errors.LogError(h.ctx, "tun-mips: ", name, " stopped: ", err)
}
dev.Close()
}
func (h *Handler) Close() error {
h.mu.Lock()
defer h.mu.Unlock()
if h.fwd != nil && h.fwd.dns != nil {
h.fwd.dns.close()
}
if h.stack != nil {
h.stack.Close()
}
if h.dev != nil {
h.dev.Close()
}
h.dev, h.stack, h.fwd = nil, nil, nil
return nil
}
// Network declares no listening network: the proxyman opens no port.
func (h *Handler) Network() []net.Network { return []net.Network{} }
// Process is never called because nothing listens.
func (h *Handler) Process(context.Context, net.Network, stat.Connection, routing.Dispatcher) error {
return nil
}
var _ common.Runnable = (*Handler)(nil)
func init() {
common.Must(common.RegisterConfig((*Config)(nil), func(ctx context.Context, config interface{}) (interface{}, error) {
h, err := newHandler(ctx, config.(*Config))
if err != nil {
return nil, err
}
err = core.RequireFeatures(ctx, func(pm policy.Manager, dsp routing.Dispatcher) error {
return h.Init(ctx, pm, dsp)
})
return h, err
}))
}
+2
View File
@@ -89,9 +89,11 @@ import (
// (replaces github.com/xtls/xray-core/main/json)
// - hint/proxy/anytls: native anytls outbound protocol handler
// - hint/proxy/juicity: native juicity outbound protocol handler
// - hint/proxy/tunmips: in-core TUN inbound (tun-mips)
_ "github.com/v2rayA/v2raya-core/hint/app/observatory/command"
_ "github.com/v2rayA/v2raya-core/hint/app/observatory/multiobservatory"
_ "github.com/v2rayA/v2raya-core/hint/conf"
_ "github.com/v2rayA/v2raya-core/hint/proxy/anytls"
_ "github.com/v2rayA/v2raya-core/hint/proxy/juicity"
_ "github.com/v2rayA/v2raya-core/hint/proxy/tunmips"
)