go-gost/core
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

remove pkgs to github.com/go-gost/x

Browse Source
This commit is contained in:
ginuerzh
2022-04-04 11:30:31 +08:00
parent 6340d5198f
commit 04f6ed4708
78 changed files with 11 additions and 5627 deletions
Download Patch File Download Diff File Expand all files Collapse all files

40
registry/admission.go
View File

@ -1,40 +0,0 @@
package registry
import (
"github.com/go-gost/core/admission"
)
type admissionRegistry struct {
registry
}
func (r *admissionRegistry) Register(name string, v admission.Admission) error {
return r.registry.Register(name, v)
}
func (r *admissionRegistry) Get(name string) admission.Admission {
if name != "" {
return &admissionWrapper{name: name, r: r}
}
return nil
}
func (r *admissionRegistry) get(name string) admission.Admission {
if v := r.registry.Get(name); v != nil {
return v.(admission.Admission)
}
return nil
}
type admissionWrapper struct {
name string
r *admissionRegistry
}
func (w *admissionWrapper) Admit(addr string) bool {
p := w.r.get(w.name)
if p == nil {
return false
}
return p.Admit(addr)
}

40
registry/auther.go
View File

@ -1,40 +0,0 @@
package registry
import (
"github.com/go-gost/core/auth"
)
type autherRegistry struct {
registry
}
func (r *autherRegistry) Register(name string, v auth.Authenticator) error {
return r.registry.Register(name, v)
}
func (r *autherRegistry) Get(name string) auth.Authenticator {
if name != "" {
return &autherWrapper{name: name, r: r}
}
return nil
}
func (r *autherRegistry) get(name string) auth.Authenticator {
if v := r.registry.Get(name); v != nil {
return v.(auth.Authenticator)
}
return nil
}
type autherWrapper struct {
name string
r *autherRegistry
}
func (w *autherWrapper) Authenticate(user, password string) bool {
v := w.r.get(w.name)
if v == nil {
return true
}
return v.Authenticate(user, password)
}

40
registry/bypass.go
View File

@ -1,40 +0,0 @@
package registry
import (
"github.com/go-gost/core/bypass"
)
type bypassRegistry struct {
registry
}
func (r *bypassRegistry) Register(name string, v bypass.Bypass) error {
return r.registry.Register(name, v)
}
func (r *bypassRegistry) Get(name string) bypass.Bypass {
if name != "" {
return &bypassWrapper{name: name, r: r}
}
return nil
}
func (r *bypassRegistry) get(name string) bypass.Bypass {
if v := r.registry.Get(name); v != nil {
return v.(bypass.Bypass)
}
return nil
}
type bypassWrapper struct {
name string
r *bypassRegistry
}
func (w *bypassWrapper) Contains(addr string) bool {
bp := w.r.get(w.name)
if bp == nil {
return false
}
return bp.Contains(addr)
}

40
registry/chain.go
View File

@ -1,40 +0,0 @@
package registry
import (
"github.com/go-gost/core/chain"
)
type chainRegistry struct {
registry
}
func (r *chainRegistry) Register(name string, v chain.Chainer) error {
return r.registry.Register(name, v)
}
func (r *chainRegistry) Get(name string) chain.Chainer {
if name != "" {
return &chainWrapper{name: name, r: r}
}
return nil
}
func (r *chainRegistry) get(name string) chain.Chainer {
if v := r.registry.Get(name); v != nil {
return v.(chain.Chainer)
}
return nil
}
type chainWrapper struct {
name string
r *chainRegistry
}
func (w *chainWrapper) Route(network, address string) *chain.Route {
v := w.r.get(w.name)
if v == nil {
return nil
}
return v.Route(network, address)
}

26
registry/connector.go
View File

@ -1,26 +0,0 @@
package registry
import (
"github.com/go-gost/core/connector"
"github.com/go-gost/core/logger"
)
type NewConnector func(opts ...connector.Option) connector.Connector
type connectorRegistry struct {
registry
}
func (r *connectorRegistry) Register(name string, v NewConnector) error {
if err := r.registry.Register(name, v); err != nil {
logger.Default().Fatal(err)
}
return nil
}
func (r *connectorRegistry) Get(name string) NewConnector {
if v := r.registry.Get(name); v != nil {
return v.(NewConnector)
}
return nil
}

26
registry/dialer.go
View File

@ -1,26 +0,0 @@
package registry
import (
"github.com/go-gost/core/dialer"
"github.com/go-gost/core/logger"
)
type NewDialer func(opts ...dialer.Option) dialer.Dialer
type dialerRegistry struct {
registry
}
func (r *dialerRegistry) Register(name string, v NewDialer) error {
if err := r.registry.Register(name, v); err != nil {
logger.Default().Fatal(err)
}
return nil
}
func (r *dialerRegistry) Get(name string) NewDialer {
if v := r.registry.Get(name); v != nil {
return v.(NewDialer)
}
return nil
}

26
registry/handler.go
View File

@ -1,26 +0,0 @@
package registry
import (
"github.com/go-gost/core/handler"
"github.com/go-gost/core/logger"
)
type NewHandler func(opts ...handler.Option) handler.Handler
type handlerRegistry struct {
registry
}
func (r *handlerRegistry) Register(name string, v NewHandler) error {
if err := r.registry.Register(name, v); err != nil {
logger.Default().Fatal(err)
}
return nil
}
func (r *handlerRegistry) Get(name string) NewHandler {
if v := r.registry.Get(name); v != nil {
return v.(NewHandler)
}
return nil
}

42
registry/hosts.go
View File

@ -1,42 +0,0 @@
package registry
import (
"net"
"github.com/go-gost/core/hosts"
)
type hostsRegistry struct {
registry
}
func (r *hostsRegistry) Register(name string, v hosts.HostMapper) error {
return r.registry.Register(name, v)
}
func (r *hostsRegistry) Get(name string) hosts.HostMapper {
if name != "" {
return &hostsWrapper{name: name, r: r}
}
return nil
}
func (r *hostsRegistry) get(name string) hosts.HostMapper {
if v := r.registry.Get(name); v != nil {
return v.(hosts.HostMapper)
}
return nil
}
type hostsWrapper struct {
name string
r *hostsRegistry
}
func (w *hostsWrapper) Lookup(network, host string) ([]net.IP, bool) {
v := w.r.get(w.name)
if v == nil {
return nil, false
}
return v.Lookup(network, host)
}

26
registry/listener.go
View File

@ -1,26 +0,0 @@
package registry
import (
"github.com/go-gost/core/listener"
"github.com/go-gost/core/logger"
)
type NewListener func(opts ...listener.Option) listener.Listener
type listenerRegistry struct {
registry
}
func (r *listenerRegistry) Register(name string, v NewListener) error {
if err := r.registry.Register(name, v); err != nil {
logger.Default().Fatal(err)
}
return nil
}
func (r *listenerRegistry) Get(name string) NewListener {
if v := r.registry.Get(name); v != nil {
return v.(NewListener)
}
return nil
}

116
registry/registry.go
View File

@ -1,116 +0,0 @@
package registry
import (
"errors"
"sync"
"github.com/go-gost/core/admission"
"github.com/go-gost/core/auth"
"github.com/go-gost/core/bypass"
"github.com/go-gost/core/chain"
"github.com/go-gost/core/hosts"
"github.com/go-gost/core/resolver"
"github.com/go-gost/core/service"
)
var (
ErrDup = errors.New("registry: duplicate object")
)
var (
listenerReg Registry[NewListener] = &listenerRegistry{}
handlerReg Registry[NewHandler] = &handlerRegistry{}
dialerReg Registry[NewDialer] = &dialerRegistry{}
connectorReg Registry[NewConnector] = &connectorRegistry{}
serviceReg Registry[service.Service] = &serviceRegistry{}
chainReg Registry[chain.Chainer] = &chainRegistry{}
autherReg Registry[auth.Authenticator] = &autherRegistry{}
admissionReg Registry[admission.Admission] = &admissionRegistry{}
bypassReg Registry[bypass.Bypass] = &bypassRegistry{}
resolverReg Registry[resolver.Resolver] = &resolverRegistry{}
hostsReg Registry[hosts.HostMapper] = &hostsRegistry{}
)
type Registry[T any] interface {
Register(name string, v T) error
Unregister(name string)
IsRegistered(name string) bool
Get(name string) T
}
type registry struct {
m sync.Map
}
func (r *registry) Register(name string, v any) error {
if name == "" || v == nil {
return nil
}
if _, loaded := r.m.LoadOrStore(name, v); loaded {
return ErrDup
}
return nil
}
func (r *registry) Unregister(name string) {
r.m.Delete(name)
}
func (r *registry) IsRegistered(name string) bool {
_, ok := r.m.Load(name)
return ok
}
func (r *registry) Get(name string) any {
if name == "" {
return nil
}
v, _ := r.m.Load(name)
return v
}
func ListenerRegistry() Registry[NewListener] {
return listenerReg
}
func HandlerRegistry() Registry[NewHandler] {
return handlerReg
}
func DialerRegistry() Registry[NewDialer] {
return dialerReg
}
func ConnectorRegistry() Registry[NewConnector] {
return connectorReg
}
func ServiceRegistry() Registry[service.Service] {
return serviceReg
}
func ChainRegistry() Registry[chain.Chainer] {
return chainReg
}
func AutherRegistry() Registry[auth.Authenticator] {
return autherReg
}
func AdmissionRegistry() Registry[admission.Admission] {
return admissionReg
}
func BypassRegistry() Registry[bypass.Bypass] {
return bypassReg
}
func ResolverRegistry() Registry[resolver.Resolver] {
return resolverReg
}
func HostsRegistry() Registry[hosts.HostMapper] {
return hostsReg
}

43
registry/resolver.go
View File

@ -1,43 +0,0 @@
package registry
import (
"context"
"net"
"github.com/go-gost/core/resolver"
)
type resolverRegistry struct {
registry
}
func (r *resolverRegistry) Register(name string, v resolver.Resolver) error {
return r.registry.Register(name, v)
}
func (r *resolverRegistry) Get(name string) resolver.Resolver {
if name != "" {
return &resolverWrapper{name: name, r: r}
}
return nil
}
func (r *resolverRegistry) get(name string) resolver.Resolver {
if v := r.registry.Get(name); v != nil {
return v.(resolver.Resolver)
}
return nil
}
type resolverWrapper struct {
name string
r *resolverRegistry
}
func (w *resolverWrapper) Resolve(ctx context.Context, network, host string) ([]net.IP, error) {
r := w.r.get(w.name)
if r == nil {
return nil, resolver.ErrInvalid
}
return r.Resolve(ctx, network, host)
}

20
registry/service.go
View File

@ -1,20 +0,0 @@
package registry
import (
"github.com/go-gost/core/service"
)
type serviceRegistry struct {
registry
}
func (r *serviceRegistry) Register(name string, v service.Service) error {
return r.registry.Register(name, v)
}
func (r *serviceRegistry) Get(name string) service.Service {
if v := r.registry.Get(name); v != nil {
return v.(service.Service)
}
return nil
}