lzhr/v2fly
1
0
Fork 0
mirror of https://github.com/v2fly/v2ray-core.git synced 2024-12-31 14:36:50 -05:00
Code Issues Releases Wiki Activity

update error message

Browse Source
This commit is contained in:
Darien Raymond 2017-04-06 21:44:20 +02:00
parent 75f5cb9afb
commit 67956b9120
No known key found for this signature in database
GPG Key ID: 7251FFA14BB18169
12 changed files with 26 additions and 26 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
app/dispatcher/impl/default.go
View File

@ -23,13 +23,13 @@ type DefaultDispatcher struct {
func NewDefaultDispatcher(ctx context.Context, config *dispatcher.Config) (*DefaultDispatcher, error) { func NewDefaultDispatcher(ctx context.Context, config *dispatcher.Config) (*DefaultDispatcher, error) {
space := app.SpaceFromContext(ctx) space := app.SpaceFromContext(ctx)
if space == nil { if space == nil {
return nil, errors.New("DefaultDispatcher: No space in context.") return nil, errors.New("no space in context").Path("App", "Dispatcher", "Default")
} }
d := &DefaultDispatcher{} d := &DefaultDispatcher{}
space.OnInitialize(func() error { space.OnInitialize(func() error {
d.ohm = proxyman.OutboundHandlerManagerFromSpace(space) d.ohm = proxyman.OutboundHandlerManagerFromSpace(space)
if d.ohm == nil { if d.ohm == nil {
return errors.New("DefaultDispatcher: OutboundHandlerManager is not found in the space.") return errors.New("OutboundHandlerManager is not found in the space").Path("App", "Dispatcher", "Default")
} }
d.router = router.FromSpace(space) d.router = router.FromSpace(space)
return nil return nil

2
app/dns/config.go
View File

@ -12,7 +12,7 @@ func (v *Config) GetInternalHosts() map[string]net.IP {
for domain, ipOrDomain := range v.GetHosts() { for domain, ipOrDomain := range v.GetHosts() {
address := ipOrDomain.AsAddress() address := ipOrDomain.AsAddress()
if address.Family().IsDomain() { if address.Family().IsDomain() {
log.Trace(errors.New("DNS: Ignoring domain address in static hosts: ", address.Domain()).AtWarning()) log.Trace(errors.New("ignoring domain address in static hosts: ", address.Domain()).AtWarning().Path("App", "DNS", "Config"))
continue continue
} }
hosts[domain] = address.IP() hosts[domain] = address.IP()

8
app/dns/server/nameserver.go
View File

@ -89,7 +89,7 @@ func (v *UDPNameServer) AssignUnusedID(response chan<- *ARecord) uint16 {
if _, found := v.requests[id]; found { if _, found := v.requests[id]; found {
continue continue
} }
log.Trace(errors.New("DNS: Add pending request id ", id).AtDebug()) log.Trace(errors.New("add pending request id ", id).AtDebug().Path("App", "DNS", "UDPNameServer"))
v.requests[id] = &PendingRequest{ v.requests[id] = &PendingRequest{
expire: time.Now().Add(time.Second * 8), expire: time.Now().Add(time.Second * 8),
response: response, response: response,
@ -105,7 +105,7 @@ func (v *UDPNameServer) HandleResponse(payload *buf.Buffer) {
msg := new(dns.Msg) msg := new(dns.Msg)
err := msg.Unpack(payload.Bytes()) err := msg.Unpack(payload.Bytes())
if err != nil { if err != nil {
log.Trace(errors.New("DNS: Failed to parse DNS response: ", err).AtWarning()) log.Trace(errors.New("failed to parse DNS response").Base(err).AtWarning().Path("App", "DNS", "UDPNameServer"))
return return
} }
record := &ARecord{ record := &ARecord{
@ -113,7 +113,7 @@ func (v *UDPNameServer) HandleResponse(payload *buf.Buffer) {
} }
id := msg.Id id := msg.Id
ttl := DefaultTTL ttl := DefaultTTL
log.Trace(errors.New("DNS: Handling response for id ", id, " content: ", msg.String()).AtDebug()) log.Trace(errors.New("handling response for id ", id, " content: ", msg.String()).AtDebug().Path("App", "DNS", "UDPNameServer"))
v.Lock() v.Lock()
request, found := v.requests[id] request, found := v.requests[id]
@ -201,7 +201,7 @@ func (v *LocalNameServer) QueryA(domain string) <-chan *ARecord {
ips, err := net.LookupIP(domain) ips, err := net.LookupIP(domain)
if err != nil { if err != nil {
log.Trace(errors.New("failed to lookup IPs for domain ", domain).Path("App", "DNS").Base(err)) log.Trace(errors.New("failed to lookup IPs for domain ", domain).Path("App", "DNS", "LocalNameServer").Base(err))
return return
} }

8
app/dns/server/server.go
View File

@ -35,7 +35,7 @@ type CacheServer struct {
func NewCacheServer(ctx context.Context, config *dns.Config) (*CacheServer, error) { func NewCacheServer(ctx context.Context, config *dns.Config) (*CacheServer, error) {
space := app.SpaceFromContext(ctx) space := app.SpaceFromContext(ctx)
if space == nil { if space == nil {
return nil, errors.New("DNSCacheServer: No space in context.") return nil, errors.New("no space in context").Path("App", "DNS", "CacheServer")
} }
server := &CacheServer{ server := &CacheServer{
records: make(map[string]*DomainRecord), records: make(map[string]*DomainRecord),
@ -45,7 +45,7 @@ func NewCacheServer(ctx context.Context, config *dns.Config) (*CacheServer, erro
space.OnInitialize(func() error { space.OnInitialize(func() error {
disp := dispatcher.FromSpace(space) disp := dispatcher.FromSpace(space)
if disp == nil { if disp == nil {
return errors.New("DNS: Dispatcher is not found in the space.") return errors.New("dispatcher is not found in the space").Path("App", "DNS", "CacheServer")
} }
for idx, destPB := range config.NameServers { for idx, destPB := range config.NameServers {
address := destPB.Address.AsAddress() address := destPB.Address.AsAddress()
@ -113,13 +113,13 @@ func (v *CacheServer) Get(domain string) []net.IP {
A: a, A: a,
} }
v.Unlock() v.Unlock()
log.Trace(errors.New("DNS: Returning ", len(a.IPs), " IPs for domain ", domain).AtDebug()) log.Trace(errors.New("returning ", len(a.IPs), " IPs for domain ", domain).AtDebug().Path("App", "DNS", "CacheServer"))
return a.IPs return a.IPs
case <-time.After(QueryTimeout): case <-time.After(QueryTimeout):
} }
} }
log.Trace(errors.New("DNS: Returning nil for domain ", domain).AtDebug()) log.Trace(errors.New("returning nil for domain ", domain).AtDebug().Path("App", "DNS", "CacheServer"))
return nil return nil
} }

2
app/log/access.go
View File

@ -21,7 +21,7 @@ var (
func InitAccessLogger(file string) error { func InitAccessLogger(file string) error {
logger, err := internal.NewFileLogWriter(file) logger, err := internal.NewFileLogWriter(file)
if err != nil { if err != nil {
return errors.New("Failed to create access logger on file: ", file).Base(err).Path("App", "Log") return errors.New("failed to create access logger on file: ", file).Base(err).Path("App", "Log")
} }
accessLoggerInstance = logger accessLoggerInstance = logger
return nil return nil

4
app/proxyman/config.go
View File

@ -2,8 +2,8 @@ package proxyman
import ( import (
"context" "context"
"errors"
"v2ray.com/core/common/errors"
"v2ray.com/core/proxy" "v2ray.com/core/proxy"
) )
@ -23,7 +23,7 @@ func (s *AllocationStrategy) GetRefreshValue() uint32 {
func (c *OutboundHandlerConfig) GetProxyHandler(ctx context.Context) (proxy.Outbound, error) { func (c *OutboundHandlerConfig) GetProxyHandler(ctx context.Context) (proxy.Outbound, error) {
if c == nil { if c == nil {
return nil, errors.New("Proxyman: OutboundHandlerConfig is nil.") return nil, errors.New("OutboundHandlerConfig is nil").Path("App", "Proxyman", "Outbound", "OutboundHandlerConfig")
} }
config, err := c.ProxySettings.GetInstance() config, err := c.ProxySettings.GetInstance()
if err != nil { if err != nil {

2
app/proxyman/inbound/always.go
View File

@ -37,7 +37,7 @@ func NewAlwaysOnInboundHandler(ctx context.Context, tag string, receiverConfig *
} }
for port := pr.From; port <= pr.To; port++ { for port := pr.From; port <= pr.To; port++ {
if nl.HasNetwork(net.Network_TCP) { if nl.HasNetwork(net.Network_TCP) {
log.Trace(errors.New("Proxyman|DefaultInboundHandler: creating tcp worker on ", address, ":", port).AtDebug()) log.Trace(errors.New("creating tcp worker on ", address, ":", port).AtDebug().Path("App", "Proxyman", "Inbound", "AlwaysOnInboundHandler"))
worker := &tcpWorker{ worker := &tcpWorker{
address: address, address: address,
port: net.Port(port), port: net.Port(port),

6
app/proxyman/inbound/dynamic.go
View File

@ -93,7 +93,7 @@ func (h *DynamicInboundHandler) refresh() error {
port := h.allocatePort() port := h.allocatePort()
p, err := proxy.CreateInboundHandler(ctx, h.proxyConfig) p, err := proxy.CreateInboundHandler(ctx, h.proxyConfig)
if err != nil { if err != nil {
log.Trace(errors.New("failed to create proxy instance").Base(err).Path("Proxyman", "Inbound", "DynamicInboundHandler").AtWarning()) log.Trace(errors.New("failed to create proxy instance").Base(err).Path("App", "Proxyman", "Inbound", "DynamicInboundHandler").AtWarning())
continue continue
} }
nl := p.Network() nl := p.Network()
@ -108,7 +108,7 @@ func (h *DynamicInboundHandler) refresh() error {
dispatcher: h.mux, dispatcher: h.mux,
} }
if err := worker.Start(); err != nil { if err := worker.Start(); err != nil {
log.Trace(errors.New("Proxyman:InboundHandler: Failed to create TCP worker: ", err).AtWarning()) log.Trace(errors.New("failed to create TCP worker").Base(err).AtWarning().Path("App", "Proxyman", "Inbound", "DynamicInboundHandler"))
continue continue
} }
workers = append(workers, worker) workers = append(workers, worker)
@ -124,7 +124,7 @@ func (h *DynamicInboundHandler) refresh() error {
dispatcher: h.mux, dispatcher: h.mux,
} }
if err := worker.Start(); err != nil { if err := worker.Start(); err != nil {
log.Trace(errors.New("Proxyman:InboundHandler: Failed to create UDP worker: ", err).AtWarning()) log.Trace(errors.New("failed to create UDP worker").Base(err).AtWarning().Path("App", "Proxyman", "Inbound", "DynamicInboundHandler"))
continue continue
} }
workers = append(workers, worker) workers = append(workers, worker)

6
app/proxyman/inbound/inbound.go
View File

@ -26,7 +26,7 @@ func (m *DefaultInboundHandlerManager) AddHandler(ctx context.Context, config *p
} }
receiverSettings, ok := rawReceiverSettings.(*proxyman.ReceiverConfig) receiverSettings, ok := rawReceiverSettings.(*proxyman.ReceiverConfig)
if !ok { if !ok {
return errors.New("Proxyman|DefaultInboundHandlerManager: Not a ReceiverConfig.") return errors.New("not a ReceiverConfig").Path("App", "Proxyman", "Inbound", "DefaultInboundHandlerManager")
} }
proxySettings, err := config.ProxySettings.GetInstance() proxySettings, err := config.ProxySettings.GetInstance()
if err != nil { if err != nil {
@ -50,7 +50,7 @@ func (m *DefaultInboundHandlerManager) AddHandler(ctx context.Context, config *p
} }
if handler == nil { if handler == nil {
return errors.New("Proxyman|DefaultInboundHandlerManager: Unknown allocation strategy: ", receiverSettings.AllocationStrategy.Type) return errors.New("unknown allocation strategy: ", receiverSettings.AllocationStrategy.Type).Path("App", "Proxyman", "Inbound", "DefaultInboundHandlerManager")
} }
m.handlers = append(m.handlers, handler) m.handlers = append(m.handlers, handler)
@ -63,7 +63,7 @@ func (m *DefaultInboundHandlerManager) AddHandler(ctx context.Context, config *p
func (m *DefaultInboundHandlerManager) GetHandler(ctx context.Context, tag string) (proxyman.InboundHandler, error) { func (m *DefaultInboundHandlerManager) GetHandler(ctx context.Context, tag string) (proxyman.InboundHandler, error) {
handler, found := m.taggedHandlers[tag] handler, found := m.taggedHandlers[tag]
if !found { if !found {
return nil, errors.New("Proxymand|DefaultInboundHandlerManager: Handler not found: ", tag) return nil, errors.New("handler not found: ", tag).Path("App", "Proxyman", "Inbound", "DefaultInboundHandlerManager")
} }
return handler, nil return handler, nil
} }

2
app/proxyman/inbound/worker.go
View File

@ -54,7 +54,7 @@ func (w *tcpWorker) callback(conn internet.Connection) {
ctx = proxy.ContextWithInboundEntryPoint(ctx, v2net.TCPDestination(w.address, w.port)) ctx = proxy.ContextWithInboundEntryPoint(ctx, v2net.TCPDestination(w.address, w.port))
ctx = proxy.ContextWithSource(ctx, v2net.DestinationFromAddr(conn.RemoteAddr())) ctx = proxy.ContextWithSource(ctx, v2net.DestinationFromAddr(conn.RemoteAddr()))
if err := w.proxy.Process(ctx, v2net.Network_TCP, conn, w.dispatcher); err != nil { if err := w.proxy.Process(ctx, v2net.Network_TCP, conn, w.dispatcher); err != nil {
log.Trace(errors.New("connection ends").Base(err).Path("Proxyman", "TCPWorker")) log.Trace(errors.New("connection ends").Base(err).Path("App", "Proxyman", "Inbound", "TCPWorker"))
} }
cancel() cancel()
conn.Close() conn.Close()

6
app/proxyman/mux/frame.go
View File

@ -114,7 +114,7 @@ func (f FrameMetadata) AsSupplier() buf.Supplier {
func ReadFrameFrom(b []byte) (*FrameMetadata, error) { func ReadFrameFrom(b []byte) (*FrameMetadata, error) {
if len(b) < 4 { if len(b) < 4 {
return nil, errors.New("Proxyman|Mux: Insufficient buffer: ", len(b)) return nil, errors.New("insufficient buffer: ", len(b)).Path("App", "Proxyman", "Mux", "Frame")
} }
f := &FrameMetadata{ f := &FrameMetadata{
@ -144,7 +144,7 @@ func ReadFrameFrom(b []byte) (*FrameMetadata, error) {
addr = net.DomainAddress(string(b[1 : 1+nDomain])) addr = net.DomainAddress(string(b[1 : 1+nDomain]))
b = b[nDomain+1:] b = b[nDomain+1:]
default: default:
return nil, errors.New("Proxyman|Mux: Unknown address type: ", addrType) return nil, errors.New("unknown address type: ", addrType).Path("App", "Proxyman", "Mux", "Frame")
} }
switch network { switch network {
case TargetNetworkTCP: case TargetNetworkTCP:
@ -152,7 +152,7 @@ func ReadFrameFrom(b []byte) (*FrameMetadata, error) {
case TargetNetworkUDP: case TargetNetworkUDP:
f.Target = net.UDPDestination(addr, port) f.Target = net.UDPDestination(addr, port)
default: default:
return nil, errors.New("Proxymann|Mux: Unknown network type: ", network) return nil, errors.New("unknown network type: ", network).Path("App", "Proxyman", "Mux", "Frame")
} }
} }

2
app/proxyman/mux/mux.go
View File

@ -83,7 +83,7 @@ func (m *ClientManager) Dispatch(ctx context.Context, outboundRay ray.OutboundRa
client, err := NewClient(m.proxy, m.dialer, m) client, err := NewClient(m.proxy, m.dialer, m)
if err != nil { if err != nil {
return errors.New("failed to create client").Base(err).Path("Proxymann", "Mux", "ClientManager") return errors.New("failed to create client").Base(err).Path("App", "Proxyman", "Mux", "ClientManager")
} }
m.clients = append(m.clients, client) m.clients = append(m.clients, client)
client.Dispatch(ctx, outboundRay) client.Dispatch(ctx, outboundRay)