all: modify import path, change version to v0.8.0

2026-03-19 16:29:14 +08:00 · 2016-08-11 16:10:44 +08:00
parent 9c0ca8675d
commit d4ecc2218d
32 changed files with 59 additions and 59 deletions
--- a/src/cmd/frps/control.go
+++ b/src/cmd/frps/control.go
@@ -0,0 +1,326 @@
+// Copyright 2016 fatedier, fatedier@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io"
+	"time"
+
+	"github.com/fatedier/frp/src/models/consts"
+	"github.com/fatedier/frp/src/models/msg"
+	"github.com/fatedier/frp/src/models/server"
+	"github.com/fatedier/frp/src/utils/conn"
+	"github.com/fatedier/frp/src/utils/log"
+	"github.com/fatedier/frp/src/utils/pcrypto"
+)
+
+func ProcessControlConn(l *conn.Listener) {
+	for {
+		c, err := l.Accept()
+		if err != nil {
+			return
+		}
+		log.Debug("Get new connection, %v", c.GetRemoteAddr())
+		go controlWorker(c)
+	}
+}
+
+// connection from every client and server
+func controlWorker(c *conn.Conn) {
+	// if login message type is NewWorkConn, don't close this connection
+	var closeFlag bool = true
+	var s *server.ProxyServer
+	defer func() {
+		if closeFlag {
+			c.Close()
+			if s != nil {
+				s.Close()
+			}
+		}
+	}()
+
+	// get login message
+	buf, err := c.ReadLine()
+	if err != nil {
+		log.Warn("Read error, %v", err)
+		return
+	}
+	log.Debug("Get msg from frpc: %s", buf)
+
+	cliReq := &msg.ControlReq{}
+	if err := json.Unmarshal([]byte(buf), &cliReq); err != nil {
+		log.Warn("Parse msg from frpc error: %v : %s", err, buf)
+		return
+	}
+
+	// login when type is NewCtlConn or NewWorkConn
+	ret, info := doLogin(cliReq, c)
+	// if login type is NewWorkConn, nothing will be send to frpc
+	if cliReq.Type != consts.NewWorkConn {
+		cliRes := &msg.ControlRes{
+			Type: consts.NewCtlConnRes,
+			Code: ret,
+			Msg:  info,
+		}
+		byteBuf, _ := json.Marshal(cliRes)
+		err = c.Write(string(byteBuf) + "\n")
+		if err != nil {
+			log.Warn("ProxyName [%s], write to client error, proxy exit", cliReq.ProxyName)
+			return
+		}
+	} else {
+		closeFlag = false
+		return
+	}
+
+	// if login failed, just return
+	if ret > 0 {
+		return
+	}
+
+	s, ok := server.ProxyServers[cliReq.ProxyName]
+	if !ok {
+		log.Warn("ProxyName [%s], is not exist now", cliReq.ProxyName)
+		return
+	}
+
+	// create a channel for sending messages
+	msgSendChan := make(chan interface{}, 1024)
+	go msgSender(s, c, msgSendChan)
+	go noticeUserConn(s, msgSendChan)
+
+	// loop for reading control messages from frpc and deal with different types
+	msgReader(s, c, msgSendChan)
+
+	close(msgSendChan)
+	log.Info("ProxyName [%s], I'm dead!", s.Name)
+	return
+}
+
+// when frps get one new user connection, send NoticeUserConn message to frpc and accept one new WorkConn later
+func noticeUserConn(s *server.ProxyServer, msgSendChan chan interface{}) {
+	for {
+		closeFlag := s.WaitUserConn()
+		if closeFlag {
+			log.Debug("ProxyName [%s], goroutine for noticing user conn is closed", s.Name)
+			break
+		}
+		notice := &msg.ControlRes{
+			Type: consts.NoticeUserConn,
+		}
+		msgSendChan <- notice
+		log.Debug("ProxyName [%s], notice client to add work conn", s.Name)
+	}
+}
+
+// loop for reading messages from frpc after control connection is established
+func msgReader(s *server.ProxyServer, c *conn.Conn, msgSendChan chan interface{}) error {
+	// for heartbeat
+	var heartbeatTimeout bool = false
+	timer := time.AfterFunc(time.Duration(server.HeartBeatTimeout)*time.Second, func() {
+		heartbeatTimeout = true
+		s.Close()
+		log.Error("ProxyName [%s], client heartbeat timeout", s.Name)
+	})
+	defer timer.Stop()
+
+	for {
+		buf, err := c.ReadLine()
+		if err != nil {
+			if err == io.EOF {
+				log.Warn("ProxyName [%s], client is dead!", s.Name)
+				return err
+			} else if c == nil || c.IsClosed() {
+				log.Warn("ProxyName [%s], client connection is closed", s.Name)
+				return err
+			}
+			log.Warn("ProxyName [%s], read error: %v", s.Name, err)
+			continue
+		}
+
+		cliReq := &msg.ControlReq{}
+		if err := json.Unmarshal([]byte(buf), &cliReq); err != nil {
+			log.Warn("ProxyName [%s], parse msg from frpc error: %v : %s", s.Name, err, buf)
+			continue
+		}
+
+		switch cliReq.Type {
+		case consts.HeartbeatReq:
+			log.Debug("ProxyName [%s], get heartbeat", s.Name)
+			timer.Reset(time.Duration(server.HeartBeatTimeout) * time.Second)
+			heartbeatRes := &msg.ControlRes{
+				Type: consts.HeartbeatRes,
+			}
+			msgSendChan <- heartbeatRes
+		default:
+			log.Warn("ProxyName [%s}, unsupport msgType [%d]", s.Name, cliReq.Type)
+		}
+	}
+	return nil
+}
+
+// loop for sending messages from channel to frpc
+func msgSender(s *server.ProxyServer, c *conn.Conn, msgSendChan chan interface{}) {
+	for {
+		msg, ok := <-msgSendChan
+		if !ok {
+			break
+		}
+
+		buf, _ := json.Marshal(msg)
+		err := c.Write(string(buf) + "\n")
+		if err != nil {
+			log.Warn("ProxyName [%s], write to client error, proxy exit", s.Name)
+			s.Close()
+			break
+		}
+	}
+}
+
+// if success, ret equals 0, otherwise greater than 0
+func doLogin(req *msg.ControlReq, c *conn.Conn) (ret int64, info string) {
+	ret = 1
+	// check if PrivilegeMode is enabled
+	if req.PrivilegeMode && !server.PrivilegeMode {
+		info = fmt.Sprintf("ProxyName [%s], PrivilegeMode is disabled in frps", req.ProxyName)
+		log.Warn("info")
+		return
+	}
+
+	var (
+		s  *server.ProxyServer
+		ok bool
+	)
+	s, ok = server.ProxyServers[req.ProxyName]
+	if req.PrivilegeMode && req.Type == consts.NewCtlConn {
+		log.Debug("ProxyName [%s], doLogin and privilege mode is enabled", req.ProxyName)
+	} else {
+		if !ok {
+			info = fmt.Sprintf("ProxyName [%s] is not exist", req.ProxyName)
+			log.Warn(info)
+			return
+		}
+	}
+
+	// check authKey or privilegeKey
+	nowTime := time.Now().Unix()
+	if req.PrivilegeMode {
+		privilegeKey := pcrypto.GetAuthKey(req.ProxyName + server.PrivilegeToken + fmt.Sprintf("%d", req.Timestamp))
+		// privilegeKey avaiable in 15 minutes
+		if nowTime-req.Timestamp > 15*60 {
+			info = fmt.Sprintf("ProxyName [%s], privilege mode authorization timeout", req.ProxyName)
+			log.Warn(info)
+			return
+		} else if req.PrivilegeKey != privilegeKey {
+			info = fmt.Sprintf("ProxyName [%s], privilege mode authorization failed", req.ProxyName)
+			log.Warn(info)
+			return
+		}
+	} else {
+		authKey := pcrypto.GetAuthKey(req.ProxyName + s.AuthToken + fmt.Sprintf("%d", req.Timestamp))
+		// authKey avaiable in 15 minutes
+		if nowTime-req.Timestamp > 15*60 {
+			info = fmt.Sprintf("ProxyName [%s], authorization timeout", req.ProxyName)
+			log.Warn(info)
+			return
+		} else if req.AuthKey != authKey {
+			info = fmt.Sprintf("ProxyName [%s], authorization failed", req.ProxyName)
+			log.Warn(info)
+			return
+		}
+	}
+
+	// control conn
+	if req.Type == consts.NewCtlConn {
+		if req.PrivilegeMode {
+			s = server.NewProxyServerFromCtlMsg(req)
+			// we check listen_port if privilege_allow_ports are set
+			// and PrivilegeMode is enabled
+			if s.Type == "tcp" {
+				_, ok := server.PrivilegeAllowPorts[s.ListenPort]
+				if !ok {
+					info = fmt.Sprintf("ProxyName [%s], remote_port [%d] isn't allowed", req.ProxyName, s.ListenPort)
+					log.Warn(info)
+					return
+				}
+			}
+			err := server.CreateProxy(s)
+			if err != nil {
+				info = fmt.Sprintf("ProxyName [%s], %v", req.ProxyName, err)
+				log.Warn(info)
+				return
+			}
+		}
+
+		// check if vhost_port is set
+		if s.Type == "http" && server.VhostHttpMuxer == nil {
+			info = fmt.Sprintf("ProxyName [%s], type [http] not support when vhost_http_port is not set", req.ProxyName)
+			log.Warn(info)
+			return
+		}
+		if s.Type == "https" && server.VhostHttpsMuxer == nil {
+			info = fmt.Sprintf("ProxyName [%s], type [https] not support when vhost_https_port is not set", req.ProxyName)
+			log.Warn(info)
+			return
+		}
+
+		// set infomations from frpc
+		s.UseEncryption = req.UseEncryption
+		s.UseGzip = req.UseGzip
+		s.HostHeaderRewrite = req.HostHeaderRewrite
+		if req.PoolCount > server.MaxPoolCount {
+			s.PoolCount = server.MaxPoolCount
+		} else if req.PoolCount < 0 {
+			s.PoolCount = 0
+		} else {
+			s.PoolCount = req.PoolCount
+		}
+
+		if s.Status == consts.Working {
+			info = fmt.Sprintf("ProxyName [%s], already in use", req.ProxyName)
+			log.Warn(info)
+			return
+		}
+
+		// start proxy and listen for user connections, no block
+		err := s.Start(c)
+		if err != nil {
+			info = fmt.Sprintf("ProxyName [%s], start proxy error: %v", req.ProxyName, err)
+			log.Warn(info)
+			return
+		}
+		log.Info("ProxyName [%s], start proxy success", req.ProxyName)
+		if req.PrivilegeMode {
+			log.Info("ProxyName [%s], created by PrivilegeMode", req.ProxyName)
+		}
+	} else if req.Type == consts.NewWorkConn {
+		// work conn
+		if s.Status != consts.Working {
+			log.Warn("ProxyName [%s], is not working when it gets one new work connnection", req.ProxyName)
+			return
+		}
+		// the connection will close after join over
+		s.RegisterNewWorkConn(c)
+	} else {
+		info = fmt.Sprintf("Unsupport login message type [%d]", req.Type)
+		log.Warn("Unsupport login message type [%d]", req.Type)
+		return
+	}
+
+	ret = 0
+	return
+}
--- a/src/cmd/frps/main.go
+++ b/src/cmd/frps/main.go
@@ -0,0 +1,179 @@
+// Copyright 2016 fatedier, fatedier@gmail.com
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"strconv"
+	"strings"
+	"time"
+
+	docopt "github.com/docopt/docopt-go"
+
+	"github.com/fatedier/frp/src/models/server"
+	"github.com/fatedier/frp/src/utils/conn"
+	"github.com/fatedier/frp/src/utils/log"
+	"github.com/fatedier/frp/src/utils/version"
+	"github.com/fatedier/frp/src/utils/vhost"
+)
+
+var usage string = `frps is the server of frp
+
+Usage: 
+    frps [-c config_file] [-L log_file] [--log-level=<log_level>] [--addr=<bind_addr>]
+    frps --reload
+    frps -h | --help
+    frps -v | --version
+
+Options:
+    -c config_file            set config file
+    -L log_file               set output log file, including console
+    --log-level=<log_level>   set log level: debug, info, warn, error
+    --addr=<bind_addr>        listen addr for client, example: 0.0.0.0:7000
+    --reload                  reload ini file and configures in common section won't be changed
+    -h --help                 show this screen
+    -v --version              show version
+`
+
+func main() {
+	// the configures parsed from file will be replaced by those from command line if exist
+	args, err := docopt.Parse(usage, nil, true, version.Full(), false)
+
+	if args["-c"] != nil {
+		server.ConfigFile = args["-c"].(string)
+	}
+	err = server.LoadConf(server.ConfigFile)
+	if err != nil {
+		fmt.Println(err)
+		os.Exit(-1)
+	}
+
+	// reload check
+	if args["--reload"] != nil {
+		if args["--reload"].(bool) {
+			resp, err := http.Get("http://" + server.BindAddr + ":" + fmt.Sprintf("%d", server.DashboardPort) + "/api/reload")
+			if err != nil {
+				fmt.Printf("frps reload error: %v\n", err)
+				os.Exit(1)
+			} else {
+				defer resp.Body.Close()
+				body, err := ioutil.ReadAll(resp.Body)
+				if err != nil {
+					fmt.Printf("frps reload error: %v\n", err)
+					os.Exit(1)
+				}
+				res := &server.GeneralResponse{}
+				err = json.Unmarshal(body, &res)
+				if err != nil {
+					fmt.Printf("http response error: %v\n", err)
+					os.Exit(1)
+				} else if res.Code != 0 {
+					fmt.Printf("reload error: %s\n", res.Msg)
+					os.Exit(1)
+				}
+				fmt.Printf("reload success\n")
+				os.Exit(0)
+			}
+		}
+	}
+
+	if args["-L"] != nil {
+		if args["-L"].(string) == "console" {
+			server.LogWay = "console"
+		} else {
+			server.LogWay = "file"
+			server.LogFile = args["-L"].(string)
+		}
+	}
+
+	if args["--log-level"] != nil {
+		server.LogLevel = args["--log-level"].(string)
+	}
+
+	if args["--addr"] != nil {
+		addr := strings.Split(args["--addr"].(string), ":")
+		if len(addr) != 2 {
+			fmt.Println("--addr format error: example 0.0.0.0:7000")
+			os.Exit(1)
+		}
+		bindPort, err := strconv.ParseInt(addr[1], 10, 64)
+		if err != nil {
+			fmt.Println("--addr format error, example 0.0.0.0:7000")
+			os.Exit(1)
+		}
+		server.BindAddr = addr[0]
+		server.BindPort = bindPort
+	}
+
+	if args["-v"] != nil {
+		if args["-v"].(bool) {
+			fmt.Println(version.Full())
+			os.Exit(0)
+		}
+	}
+
+	log.InitLog(server.LogWay, server.LogFile, server.LogLevel, server.LogMaxDays)
+
+	l, err := conn.Listen(server.BindAddr, server.BindPort)
+	if err != nil {
+		log.Error("Create server listener error, %v", err)
+		os.Exit(1)
+	}
+
+	// create vhost if VhostHttpPort != 0
+	if server.VhostHttpPort != 0 {
+		vhostListener, err := conn.Listen(server.BindAddr, server.VhostHttpPort)
+		if err != nil {
+			log.Error("Create vhost http listener error, %v", err)
+			os.Exit(1)
+		}
+		server.VhostHttpMuxer, err = vhost.NewHttpMuxer(vhostListener, 30*time.Second)
+		if err != nil {
+			log.Error("Create vhost httpMuxer error, %v", err)
+		}
+	}
+
+	// create vhost if VhostHttpPort != 0
+	if server.VhostHttpsPort != 0 {
+		vhostListener, err := conn.Listen(server.BindAddr, server.VhostHttpsPort)
+		if err != nil {
+			log.Error("Create vhost https listener error, %v", err)
+			os.Exit(1)
+		}
+		server.VhostHttpsMuxer, err = vhost.NewHttpsMuxer(vhostListener, 30*time.Second)
+		if err != nil {
+			log.Error("Create vhost httpsMuxer error, %v", err)
+		}
+	}
+
+	// create dashboard web server if DashboardPort is set, so it won't be 0
+	if server.DashboardPort != 0 {
+		err := server.RunDashboardServer(server.BindAddr, server.DashboardPort)
+		if err != nil {
+			log.Error("Create dashboard web server error, %v", err)
+			os.Exit(1)
+		}
+	}
+
+	log.Info("Start frps success")
+	if server.PrivilegeMode == true {
+		log.Info("PrivilegeMode is enabled, you should pay more attention to security issues")
+	}
+	ProcessControlConn(l)
+}