github/nps
1
0
Fork 0
mirror of https://github.com/ehang-io/nps.git synced 2025-07-02 04:00:42 +00:00
Code Issues Packages Projects Releases Wiki Activity

bug repair when high concurrent

Browse Source
This commit is contained in:
刘河 2019-02-18 01:05:05 +08:00
parent 48c7309973
commit dab51c32a2
14 changed files with 229 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
README.md
View File

@ -272,6 +272,7 @@ server {
listen 80;
server_name *.proxy.com;
location / {
proxy_set_header Host $http_host;
proxy_pass http://127.0.0.1:8024;
}
}
@ -290,6 +291,7 @@ server {
ssl_protocols TLSv1 TLSv1.1 TLSv1.2;
ssl_prefer_server_ciphers on;
location / {
proxy_set_header Host $http_host;
proxy_pass http://127.0.0.1:8024;
}
}

120
client/client.go
View File

@ -1,18 +1,11 @@
package client
import (
"errors"
"github.com/cnlh/nps/lib/common"
"github.com/cnlh/nps/lib/config"
"github.com/cnlh/nps/lib/conn"
"github.com/cnlh/nps/lib/lg"
"github.com/cnlh/nps/lib/pool"
"github.com/cnlh/nps/vender/github.com/xtaci/kcp"
"github.com/cnlh/nps/vender/golang.org/x/net/proxy"
"io/ioutil"
"net"
"net/url"
"path/filepath"
"sync"
"time"
)
@ -133,7 +126,7 @@ func (s *TRPClient) linkProcess(link *conn.Link, c *conn.Conn) {
}
pool.PutBufPoolCopy(buf)
s.Lock()
delete(s.linkMap, link.Id)
//TODO 删除map
s.Unlock()
}
@ -173,7 +166,6 @@ func (s *TRPClient) dealChan() {
go func() {
for {
if id, err := s.tunnel.GetLen(); err != nil {
lg.Println("get id error", err, id)
break
} else {
s.Lock()
@ -193,113 +185,3 @@ func (s *TRPClient) dealChan() {
}()
<-s.stop
}
var errAdd = errors.New("The server returned an error, which port or host may have been occupied or not allowed to open.")
func StartFromFile(path string) {
first := true
cnf, err := config.NewConfig(path)
if err != nil {
lg.Fatalln(err)
}
lg.Printf("Loading configuration file %s successfully", path)
re:
if first || cnf.CommonConfig.AutoReconnection {
if !first {
lg.Println("Reconnecting...")
time.Sleep(time.Second * 5)
}
} else {
return
}
first = false
c, err := NewConn(cnf.CommonConfig.Tp, cnf.CommonConfig.VKey, cnf.CommonConfig.Server, common.WORK_CONFIG, cnf.CommonConfig.ProxyUrl)
if err != nil {
lg.Println(err)
goto re
}
if _, err := c.SendConfigInfo(cnf.CommonConfig.Cnf); err != nil {
lg.Println(err)
goto re
}
var b []byte
if b, err = c.ReadLen(16); err != nil {
lg.Println(err)
goto re
} else {
ioutil.WriteFile(filepath.Join(common.GetTmpPath(), "npc_vkey.txt"), []byte(string(b)), 0600)
}
if !c.GetAddStatus() {
lg.Println(errAdd)
goto re
}
for _, v := range cnf.Hosts {
if _, err := c.SendHostInfo(v); err != nil {
lg.Println(err)
goto re
}
if !c.GetAddStatus() {
lg.Println(errAdd, v.Host)
goto re
}
}
for _, v := range cnf.Tasks {
if _, err := c.SendTaskInfo(v); err != nil {
lg.Println(err)
goto re
}
if !c.GetAddStatus() {
lg.Println(errAdd, v.Ports)
goto re
}
}
c.Close()
NewRPClient(cnf.CommonConfig.Server, string(b), cnf.CommonConfig.Tp, cnf.CommonConfig.ProxyUrl).Start()
goto re
}
//Create a new connection with the server and verify it
func NewConn(tp string, vkey string, server string, connType string, proxyUrl string) (*conn.Conn, error) {
var err error
var connection net.Conn
var sess *kcp.UDPSession
if tp == "tcp" {
if proxyUrl != "" {
u, er := url.Parse(proxyUrl)
if er != nil {
return nil, er
}
n, er := proxy.FromURL(u, nil)
if er != nil {
return nil, er
}
connection, err = n.Dial("tcp", server)
} else {
connection, err = net.Dial("tcp", server)
}
} else {
sess, err = kcp.DialWithOptions(server, nil, 10, 3)
conn.SetUdpSession(sess)
connection = sess
}
if err != nil {
return nil, err
}
c := conn.NewConn(connection)
if _, err := c.Write([]byte(common.Getverifyval(vkey))); err != nil {
lg.Println(err)
}
if s, err := c.ReadFlag(); err != nil {
lg.Println(err)
} else if s == common.VERIFY_EER {
lg.Fatalf("Validation key %s incorrect", vkey)
}
if _, err := c.Write([]byte(connType)); err != nil {
lg.Println(err)
}
c.SetAlive(tp)
return c, nil
}

180
client/control.go Normal file
View File

@ -0,0 +1,180 @@
package client
import (
"errors"
"github.com/cnlh/nps/lib/common"
"github.com/cnlh/nps/lib/config"
"github.com/cnlh/nps/lib/conn"
"github.com/cnlh/nps/lib/lg"
"github.com/cnlh/nps/vender/github.com/xtaci/kcp"
"github.com/cnlh/nps/vender/golang.org/x/net/proxy"
"io/ioutil"
"log"
"net"
"net/url"
"os"
"path/filepath"
"strconv"
"strings"
"time"
)
func GetTaskStatus(path string) {
cnf, err := config.NewConfig(path)
if err != nil {
log.Fatalln(err)
}
c, err := NewConn(cnf.CommonConfig.Tp, cnf.CommonConfig.VKey, cnf.CommonConfig.Server, common.WORK_CONFIG, cnf.CommonConfig.ProxyUrl)
if err != nil {
log.Fatalln(err)
}
if _, err := c.Write([]byte(common.WORK_STATUS)); err != nil {
log.Fatalln(err)
}
if f, err := common.ReadAllFromFile(filepath.Join(common.GetTmpPath(), "npc_vkey.txt")); err != nil {
log.Fatalln(err)
} else if _, err := c.Write([]byte(string(f))); err != nil {
log.Fatalln(err)
}
if l, err := c.GetLen(); err != nil {
log.Fatalln(err)
} else if b, err := c.ReadLen(l); err != nil {
lg.Fatalln(err)
} else {
arr := strings.Split(string(b), common.CONN_DATA_SEQ)
for _, v := range cnf.Hosts {
if common.InStrArr(arr, v.Remark) {
log.Println(v.Remark, "ok")
} else {
log.Println(v.Remark, "not running")
}
}
for _, v := range cnf.Tasks {
ports := common.GetPorts(v.Ports)
for _, vv := range ports {
var remark string
if len(ports) > 1 {
remark = v.Remark + "_" + strconv.Itoa(vv)
} else {
remark = v.Remark
}
if common.InStrArr(arr, remark) {
log.Println(remark, "ok")
} else {
log.Println(remark, "not running")
}
}
}
}
os.Exit(0)
}
var errAdd = errors.New("The server returned an error, which port or host may have been occupied or not allowed to open.")
func StartFromFile(path string) {
first := true
cnf, err := config.NewConfig(path)
if err != nil {
lg.Fatalln(err)
}
lg.Printf("Loading configuration file %s successfully", path)
re:
if first || cnf.CommonConfig.AutoReconnection {
if !first {
lg.Println("Reconnecting...")
time.Sleep(time.Second * 5)
}
} else {
return
}
first = false
c, err := NewConn(cnf.CommonConfig.Tp, cnf.CommonConfig.VKey, cnf.CommonConfig.Server, common.WORK_CONFIG, cnf.CommonConfig.ProxyUrl)
if err != nil {
lg.Println(err)
goto re
}
if _, err := c.SendConfigInfo(cnf.CommonConfig.Cnf); err != nil {
lg.Println(err)
goto re
}
var b []byte
if b, err = c.ReadLen(16); err != nil {
lg.Println(err)
goto re
} else {
ioutil.WriteFile(filepath.Join(common.GetTmpPath(), "npc_vkey.txt"), []byte(string(b)), 0600)
}
if !c.GetAddStatus() {
lg.Println(errAdd)
goto re
}
for _, v := range cnf.Hosts {
if _, err := c.SendHostInfo(v); err != nil {
lg.Println(err)
goto re
}
if !c.GetAddStatus() {
lg.Println(errAdd, v.Host)
goto re
}
}
for _, v := range cnf.Tasks {
if _, err := c.SendTaskInfo(v); err != nil {
lg.Println(err)
goto re
}
if !c.GetAddStatus() {
lg.Println(errAdd, v.Ports)
goto re
}
}
c.Close()
NewRPClient(cnf.CommonConfig.Server, string(b), cnf.CommonConfig.Tp, cnf.CommonConfig.ProxyUrl).Start()
goto re
}
//Create a new connection with the server and verify it
func NewConn(tp string, vkey string, server string, connType string, proxyUrl string) (*conn.Conn, error) {
var err error
var connection net.Conn
var sess *kcp.UDPSession
if tp == "tcp" {
if proxyUrl != "" {
u, er := url.Parse(proxyUrl)
if er != nil {
return nil, er
}
n, er := proxy.FromURL(u, nil)
if er != nil {
return nil, er
}
connection, err = n.Dial("tcp", server)
} else {
connection, err = net.Dial("tcp", server)
}
} else {
sess, err = kcp.DialWithOptions(server, nil, 10, 3)
conn.SetUdpSession(sess)
connection = sess
}
if err != nil {
return nil, err
}
c := conn.NewConn(connection)
if _, err := c.Write([]byte(common.Getverifyval(vkey))); err != nil {
lg.Println(err)
}
if s, err := c.ReadFlag(); err != nil {
lg.Println(err)
} else if s == common.VERIFY_EER {
lg.Fatalf("Validation key %s incorrect", vkey)
}
if _, err := c.Write([]byte(connType)); err != nil {
lg.Println(err)
}
c.SetAlive(tp)
return c, nil
}

62
client/status.go
View File

@ -1,62 +0,0 @@
package client
import (
"github.com/cnlh/nps/lib/common"
"github.com/cnlh/nps/lib/config"
"github.com/cnlh/nps/lib/lg"
"log"
"os"
"path/filepath"
"strconv"
"strings"
)
func GetTaskStatus(path string) {
cnf, err := config.NewConfig(path)
if err != nil {
log.Fatalln(err)
}
c, err := NewConn(cnf.CommonConfig.Tp, cnf.CommonConfig.VKey, cnf.CommonConfig.Server, common.WORK_CONFIG, cnf.CommonConfig.ProxyUrl)
if err != nil {
log.Fatalln(err)
}
if _, err := c.Write([]byte(common.WORK_STATUS)); err != nil {
log.Fatalln(err)
}
if f, err := common.ReadAllFromFile(filepath.Join(common.GetTmpPath(), "npc_vkey.txt")); err != nil {
log.Fatalln(err)
} else if _, err := c.Write([]byte(string(f))); err != nil {
log.Fatalln(err)
}
if l, err := c.GetLen(); err != nil {
log.Fatalln(err)
} else if b, err := c.ReadLen(l); err != nil {
lg.Fatalln(err)
} else {
arr := strings.Split(string(b), common.CONN_DATA_SEQ)
for _, v := range cnf.Hosts {
if common.InArr(arr, v.Remark) {
log.Println(v.Remark, "ok")
} else {
log.Println(v.Remark, "not running")
}
}
for _, v := range cnf.Tasks {
ports := common.GetPorts(v.Ports)
for _, vv := range ports {
var remark string
if len(ports) > 1 {
remark = v.Remark + "_" + strconv.Itoa(vv)
} else {
remark = v.Remark
}
if common.InArr(arr, remark) {
log.Println(remark, "ok")
} else {
log.Println(remark, "not running")
}
}
}
}
os.Exit(0)
}

1
cmd/nps/nps.go
View File

@ -23,7 +23,6 @@ var (
)
func main() {
log.SetFlags(log.Lshortfile)
flag.Parse()
if len(os.Args) > 1 {
switch os.Args[1] {

6
conf/npc.conf
View File

@ -3,11 +3,11 @@ server=127.0.0.1:8284
tp=tcp
vkey=123
auto_reconnection=true
crypt=true
[web1]
host=a.o.com
host_change=www.proxy.com
target=127.0.0.1:8080
target=127.0.0.1:8082
location=/
[web2]
@ -18,7 +18,7 @@ header_set_proxy=nps
[tcp]
mode=tcpServer
target=8001-8005,8080
target=8001-8005,8082
port=9001-9005,9006
[socks5]

6
lib/common/util.go
View File

@ -5,7 +5,6 @@ import (
"encoding/base64"
"encoding/binary"
"github.com/cnlh/nps/lib/crypt"
"github.com/cnlh/nps/lib/lg"
"io/ioutil"
"net"
"net/http"
@ -23,7 +22,7 @@ func GetCompressType(compress string) (int, int) {
case "snappy":
return COMPRESS_SNAPY_DECODE, COMPRESS_SNAPY_ENCODE
default:
lg.Fatalln("数据压缩格式错误")
return COMPRESS_NONE_DECODE, COMPRESS_NONE_ENCODE
}
return COMPRESS_NONE_DECODE, COMPRESS_NONE_ENCODE
}
@ -184,7 +183,7 @@ func BinaryWrite(raw *bytes.Buffer, v ...string) {
binary.Write(raw, binary.LittleEndian, buffer.Bytes())
}
func InArr(arr []string, val string) bool {
func InStrArr(arr []string, val string) bool {
for _, v := range arr {
if v == val {
return true
@ -224,6 +223,7 @@ func GetPorts(p string) []int {
}
return ps
}
func IsPort(p string) bool {
pi, err := strconv.Atoi(p)
if err != nil {

8
lib/conn/conn.go
View File

@ -89,11 +89,9 @@ func (s *Conn) ReadLen(cLen int) ([]byte, error) {
//read length or id (content length=4)
func (s *Conn) GetLen() (int, error) {
val, err := s.ReadLen(4)
if err != nil {
return 0, err
}
return GetLenByBytes(val)
var l int32
err := binary.Read(s, binary.LittleEndian, &l)
return int(l), err
}
//read flag

36
lib/conn/snappy.go
View File

@ -1,41 +1,29 @@
package conn
import (
"github.com/cnlh/nps/lib/crypt"
"github.com/cnlh/nps/lib/lg"
"github.com/cnlh/nps/lib/pool"
"github.com/cnlh/nps/lib/rate"
"github.com/cnlh/nps/vender/github.com/golang/snappy"
"log"
"net"
)
type SnappyConn struct {
w *snappy.Writer
r *snappy.Reader
crypt bool
rate *rate.Rate
w *snappy.Writer
r *snappy.Reader
rate *rate.Rate
}
func NewSnappyConn(conn net.Conn, crypt bool, rate *rate.Rate) *SnappyConn {
c := new(SnappyConn)
c.w = snappy.NewBufferedWriter(conn)
c.r = snappy.NewReader(conn)
c.crypt = crypt
c.rate = rate
return c
}
//snappy压缩写 包含加密
//snappy压缩写
func (s *SnappyConn) Write(b []byte) (n int, err error) {
n = len(b)
if s.crypt {
if b, err = crypt.AesEncrypt(b, []byte(cryptKey)); err != nil {
lg.Println("encode crypt error:", err)
return
}
}
if _, err = s.w.Write(b); err != nil {
if n, err = s.w.Write(b); err != nil {
return
}
if err = s.w.Flush(); err != nil {
@ -47,24 +35,14 @@ func (s *SnappyConn) Write(b []byte) (n int, err error) {
return
}
//snappy压缩读 包含解密
//snappy压缩读
func (s *SnappyConn) Read(b []byte) (n int, err error) {
buf := pool.BufPool.Get().([]byte)
defer pool.BufPool.Put(buf)
if n, err = s.r.Read(buf); err != nil {
return
}
var bs []byte
if s.crypt {
if bs, err = crypt.AesDecrypt(buf[:n], []byte(cryptKey)); err != nil {
log.Println("decode crypt error:", err)
return
}
} else {
bs = buf[:n]
}
n = len(bs)
copy(b, bs)
copy(b, buf[:n])
if s.rate != nil {
s.rate.Get(int64(n))
}

2
lib/file/file.go
View File

@ -157,7 +157,7 @@ func (s *Csv) UpdateTask(t *Tunnel) error {
return nil
}
}
return errors.New("不存在")
return errors.New("the task is not exist")
}
func (s *Csv) DelTask(id int) error {

5
server/proxy/base.go
View File

@ -12,6 +12,11 @@ import (
"sync"
)
type Service interface {
Start() error
Close() error
}
//server base struct
type server struct {
id int

3
server/proxy/http.go
View File

@ -89,8 +89,9 @@ func (s *httpServer) Start() error {
return nil
}
func (s *httpServer) Close() {
func (s *httpServer) Close() error {
s.stop <- true
return nil
}
func (s *httpServer) handleTunneling(w http.ResponseWriter, r *http.Request) {

4
server/proxy/tcp.go
View File

@ -87,6 +87,10 @@ func (s *WebServer) Start() error {
return errors.New("Web management startup failure")
}
func (s *WebServer) Close() error {
return nil
}
//new
func NewWebServer(bridge *bridge.Bridge) *WebServer {
s := new(WebServer)

36
server/server.go
View File

@ -9,7 +9,6 @@ import (
"github.com/cnlh/nps/server/proxy"
"github.com/cnlh/nps/server/tool"
"github.com/cnlh/nps/vender/github.com/astaxie/beego"
"reflect"
)
var (
@ -37,6 +36,7 @@ func InitFromCsv() {
}
}
}
func DealBridgeTask() {
for {
select {
@ -59,27 +59,27 @@ func StartNewServer(bridgePort int, cnf *file.Tunnel, bridgeType string) {
}
go DealBridgeTask()
if svr := NewMode(Bridge, cnf); svr != nil {
RunList[cnf.Id] = svr
err := reflect.ValueOf(svr).MethodByName("Start").Call(nil)[0]
if err.Interface() != nil {
if err := svr.Start(); err != nil {
lg.Fatalln(err)
}
RunList[cnf.Id] = svr
} else {
lg.Fatalln("启动模式%s不正确", cnf.Mode)
}
}
//new a server by mode name
func NewMode(Bridge *bridge.Bridge, c *file.Tunnel) interface{} {
func NewMode(Bridge *bridge.Bridge, c *file.Tunnel) proxy.Service {
var service proxy.Service
switch c.Mode {
case "tcpServer":
return proxy.NewTunnelModeServer(proxy.ProcessTunnel, Bridge, c)
service = proxy.NewTunnelModeServer(proxy.ProcessTunnel, Bridge, c)
case "socks5Server":
return proxy.NewSock5ModeServer(Bridge, c)
service = proxy.NewSock5ModeServer(Bridge, c)
case "httpProxyServer":
return proxy.NewTunnelModeServer(proxy.ProcessHttp, Bridge, c)
service = proxy.NewTunnelModeServer(proxy.ProcessHttp, Bridge, c)
case "udpServer":
return proxy.NewUdpModeServer(Bridge, c)
service = proxy.NewUdpModeServer(Bridge, c)
case "webServer":
InitFromCsv()
t := &file.Tunnel{
@ -89,19 +89,20 @@ func NewMode(Bridge *bridge.Bridge, c *file.Tunnel) interface{} {
Status: true,
}
AddTask(t)
return proxy.NewWebServer(Bridge)
service = proxy.NewWebServer(Bridge)
case "httpHostServer":
return proxy.NewHttp(Bridge, c)
service = proxy.NewHttp(Bridge, c)
}
return nil
return service
}
//stop server
func StopServer(id int) error {
if v, ok := RunList[id]; ok {
if reflect.ValueOf(v).IsValid() {
//TODO 错误处理
reflect.ValueOf(v).MethodByName("Close").Call(nil)
if svr, ok := v.(proxy.Service); ok {
if err := svr.Close(); err != nil {
return err
}
if t, err := file.GetCsvDb().GetTask(id); err != nil {
return err
} else {
@ -118,14 +119,13 @@ func StopServer(id int) error {
//add task
func AddTask(t *file.Tunnel) error {
if b := tool.TestServerPort(t.Port, t.Mode); !b && t.Mode != "httpHostServer" {
lg.Printf("taskId %d start error Port %d Open Failed", t.Id, t.Port)
lg.Printf("taskId %d start error port %d Open Failed", t.Id, t.Port)
return errors.New("the port open error")
}
if svr := NewMode(Bridge, t); svr != nil {
RunList[t.Id] = svr
go func() {
err := reflect.ValueOf(svr).MethodByName("Start").Call(nil)[0]
if err.Interface() != nil {
if err := svr.Start(); err != nil {
lg.Println("clientId %d taskId %d start error %s", t.Client.Id, t.Id, err)
delete(RunList, t.Id)
return