finish up dial

app/proxyman/outbound/unix.go

@@ -0,0 +1,132 @@
+package outbound
+
+import (
+ "context"
+ "io"
+
+ "v2ray.com/core"
+ "v2ray.com/core/app/proxyman"
+ "v2ray.com/core/app/proxyman/mux"
+ "v2ray.com/core/common"
+ "v2ray.com/core/common/errors"
+ "v2ray.com/core/common/net"
+ "v2ray.com/core/proxy"
+ "v2ray.com/core/transport/internet"
+ "v2ray.com/core/transport/internet/domainsocket"
+ "v2ray.com/core/transport/ray"
+)
+
+type UnixHandler struct {
+ config *core.OutboundHandlerConfig
+ senderSettings *proxyman.UnixSenderConfig
+ proxy proxy.Outbound
+ outboundManager core.OutboundHandlerManager
+ mux *mux.ClientManager
+}
+
+func NewUnixHandler(ctx context.Context, config *core.OutboundHandlerConfig) (core.OutboundHandler, error) {
+ v := core.FromContext(ctx)
+ if v == nil {
+ return nil, newError("V is not in context")
+ }
+ h := &UnixHandler{
+ config: config,
+ outboundManager: v.OutboundHandlerManager(),
+ }
+
+ if config.SenderSettings != nil {
+ senderSettings, err := config.SenderSettings.GetInstance()
+ if err != nil {
+ return nil, err
+ }
+ switch s := senderSettings.(type) {
+ case *proxyman.UnixSenderConfig:
+ h.senderSettings = s
+ default:
+ return nil, newError("settings is not SenderConfig")
+ }
+ }
+
+ proxyConfig, err := config.ProxySettings.GetInstance()
+ if err != nil {
+ return nil, err
+ }
+
+ rawProxyHandler, err := common.CreateObject(ctx, proxyConfig)
+ if err != nil {
+ return nil, err
+ }
+
+ proxyHandler, ok := rawProxyHandler.(proxy.Outbound)
+ if !ok {
+ return nil, newError("not an outbound handler")
+ }
+
+ if h.senderSettings != nil && h.senderSettings.MultiplexSettings != nil && h.senderSettings.MultiplexSettings.Enabled {
+ config := h.senderSettings.MultiplexSettings
+ if config.Concurrency < 1 || config.Concurrency > 1024 {
+ return nil, newError("invalid mux concurrency: ", config.Concurrency).AtWarning()
+ }
+ h.mux = mux.NewClientManager(proxyHandler, h, config)
+ }
+
+ h.proxy = proxyHandler
+ return h, nil
+}
+
+// Tag implements core.OutboundHandler.
+func (h *UnixHandler) Tag() string {
+ return h.config.Tag
+}
+
+// Dispatch implements proxy.Outbound.Dispatch.
+func (h *UnixHandler) Dispatch(ctx context.Context, outboundRay ray.OutboundRay) {
+ if h.mux != nil {
+ err := h.mux.Dispatch(ctx, outboundRay)
+ if err != nil {
+ newError("failed to process outbound traffic").Base(err).WriteToLog()
+ outboundRay.OutboundOutput().CloseError()
+ }
+ } else {
+ err := h.proxy.Process(ctx, outboundRay, h)
+ // Ensure outbound ray is properly closed.
+ if err != nil && errors.Cause(err) != io.EOF {
+ newError("failed to process outbound traffic").Base(err).WriteToLog()
+ outboundRay.OutboundOutput().CloseError()
+ } else {
+ outboundRay.OutboundOutput().Close()
+ }
+ outboundRay.OutboundInput().CloseError()
+ }
+}
+
+// Dial implements proxy.Dialer.Dial().
+func (h *UnixHandler) Dial(ctx context.Context, dest net.Destination) (internet.Connection, error) {
+ if h.senderSettings != nil {
+ if h.senderSettings.ProxySettings.HasTag() {
+ newError("Unix domain socket does not support redirect").AtWarning().WriteToLog()
+ }
+
+ if h.senderSettings.StreamSettings != nil {
+ newError("Unix domain socket does not support stream setting").AtWarning().WriteToLog()
+ }
+ }
+
+ return domainsocket.DialDS(ctx, h.senderSettings.GetVia().GetPath())
+}
+
+// GetOutbound implements proxy.GetOutbound.
+func (h *UnixHandler) GetOutbound() proxy.Outbound {
+ return h.proxy
+}
+
+// Start implements common.Runnable.
+func (h *UnixHandler) Start() error {
+ return nil
+}
+
+// Close implements common.Runnable.
+func (h *UnixHandler) Close() error {
+ common.Close(h.mux)
+ return nil
+}

transport/internet/domainsocket/dial.go

@@ -6,14 +6,13 @@ import (
 )
 
 func DialDS(ctx context.Context, path string) (*net.UnixConn, error) {
- resolvedAddress, err := net.ResolveUnixAddr("unixpacket", path)
+ resolvedAddress, err := net.ResolveUnixAddr("unix", path)
  if err != nil {
  return nil, err
  }
- dialedUnix, err := net.DialUnix("unixpacket", nil, resolvedAddress)
+ dialedUnix, err := net.DialUnix("unix", nil, resolvedAddress)
  if err != nil {
  return nil, err
  }
  return dialedUnix, nil
-
 }