start refactoring

models/msg/msg.go

@@ -0,0 +1,122 @@
+// 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 msg
+
+import "reflect"
+
+const (
+	TypeLogin         = 'o'
+	TypeLoginResp     = '1'
+	TypeNewProxy      = 'p'
+	TypeNewProxyResp  = '2'
+	TypeNewWorkConn   = 'w'
+	TypeReqWorkConn   = 'r'
+	TypeStartWorkConn = 's'
+	TypePing          = 'h'
+	TypePong          = '4'
+)
+
+var (
+	TypeMap       map[byte]reflect.Type
+	TypeStringMap map[reflect.Type]byte
+)
+
+func init() {
+	TypeMap = make(map[byte]reflect.Type)
+	TypeStringMap = make(map[reflect.Type]byte)
+
+	TypeMap[TypeLogin] = getTypeFn((*Login)(nil))
+	TypeMap[TypeLoginResp] = getTypeFn((*LoginResp)(nil))
+	TypeMap[TypeNewProxy] = getTypeFn((*NewProxy)(nil))
+	TypeMap[TypeNewProxyResp] = getTypeFn((*NewProxyResp)(nil))
+	TypeMap[TypeNewWorkConn] = getTypeFn((*NewWorkConn)(nil))
+	TypeMap[TypeReqWorkConn] = getTypeFn((*ReqWorkConn)(nil))
+	TypeMap[TypeStartWorkConn] = getTypeFn((*StartWorkConn)(nil))
+	TypeMap[TypePing] = getTypeFn((*Ping)(nil))
+	TypeMap[TypePong] = getTypeFn((*Pong)(nil))
+
+	for k, v := range TypeMap {
+		TypeStringMap[v] = k
+	}
+}
+
+func getTypeFn(obj interface{}) reflect.Type {
+	return reflect.TypeOf(obj).Elem()
+}
+
+// Message wraps socket packages for communicating between frpc and frps.
+type Message interface{}
+
+// When frpc start, client send this message to login to server.
+type Login struct {
+	Version      string `json:"version"`
+	Hostname     string `json:"hostname"`
+	Os           string `json:"os"`
+	Arch         string `json:"arch"`
+	User         string `json:"user"`
+	PrivilegeKey string `json:"privilege_key"`
+	Timestamp    int64  `json:"timestamp"`
+	RunId        string `json:"run_id"`
+
+	// Some global configures.
+	PoolCount int `json:"pool_count"`
+}
+
+type LoginResp struct {
+	Version string `json:"version"`
+	RunId   string `json:"run_id"`
+	Error   string `json:"error"`
+}
+
+// When frpc login success, send this message to frps for running a new proxy.
+type NewProxy struct {
+	ProxyName      string `json:"proxy_name"`
+	ProxyType      string `json:"proxy_type"`
+	UseEncryption  bool   `json:"use_encryption"`
+	UseCompression bool   `json:"use_compression"`
+
+	// tcp and udp only
+	RemotePort int64 `json:"remote_port"`
+
+	// http and https only
+	CustomDomains     []string `json:"custom_domains"`
+	SubDomain         string   `json:"subdomain"`
+	Locations         []string `json:"locations"`
+	HostHeaderRewrite string   `json:"host_header_rewrite"`
+	HttpUser          string   `json:"http_user"`
+	HttpPwd           string   `json:"http_pwd"`
+}
+
+type NewProxyResp struct {
+	ProxyName string `json:"proxy_name"`
+	Error     string `json:"error"`
+}
+
+type NewWorkConn struct {
+	RunId string `json:"run_id"`
+}
+
+type ReqWorkConn struct {
+}
+
+type StartWorkConn struct {
+	ProxyName string `json:"proxy_name"`
+}
+
+type Ping struct {
+}
+
+type Pong struct {
+}

models/msg/pack.go

@@ -0,0 +1,69 @@
+// 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 msg
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	"github.com/fatedier/frp/utils/errors"
+)
+
+func unpack(typeByte byte, buffer []byte, msgIn Message) (msg Message, err error) {
+	if msgIn == nil {
+		t, ok := TypeMap[typeByte]
+		if !ok {
+			err = fmt.Errorf("Unsupported message type %b", typeByte)
+			return
+		}
+
+		msg = reflect.New(t).Interface().(Message)
+	} else {
+		msg = msgIn
+	}
+
+	err = json.Unmarshal(buffer, &msg)
+	return
+}
+
+func UnPackInto(buffer []byte, msg Message) (err error) {
+	_, err = unpack(' ', buffer, msg)
+	return
+}
+
+func UnPack(typeByte byte, buffer []byte) (msg Message, err error) {
+	return unpack(typeByte, buffer, nil)
+}
+
+func Pack(msg Message) ([]byte, error) {
+	typeByte, ok := TypeStringMap[reflect.TypeOf(msg).Elem()]
+	if !ok {
+		return nil, errors.ErrMsgType
+	}
+
+	content, err := json.Marshal(msg)
+	if err != nil {
+		return nil, err
+	}
+
+	buffer := bytes.NewBuffer(nil)
+	buffer.WriteByte(typeByte)
+	binary.Write(buffer, binary.BigEndian, int64(len(content)))
+	buffer.Write(content)
+	return buffer.Bytes(), nil
+}

models/msg/pack_test.go

@@ -0,0 +1,86 @@
+// 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 msg
+
+import (
+	"bytes"
+	"encoding/binary"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/fatedier/frp/utils/errors"
+)
+
+type TestStruct struct{}
+
+func TestPack(t *testing.T) {
+	assert := assert.New(t)
+
+	var (
+		msg    Message
+		buffer []byte
+		err    error
+	)
+
+	// error type
+	msg = &TestStruct{}
+	buffer, err = Pack(msg)
+	assert.Error(err, errors.ErrMsgType.Error())
+
+	// correct
+	msg = &Ping{}
+	buffer, err = Pack(msg)
+	assert.NoError(err)
+	b := bytes.NewBuffer(nil)
+	b.WriteByte(TypePing)
+	binary.Write(b, binary.BigEndian, int64(2))
+	b.WriteString("{}")
+	assert.True(bytes.Equal(b.Bytes(), buffer))
+}
+
+func TestUnPack(t *testing.T) {
+	assert := assert.New(t)
+
+	var (
+		msg Message
+		err error
+	)
+
+	// error message type
+	msg, err = UnPack('-', []byte("{}"))
+	assert.Error(err)
+
+	// correct
+	msg, err = UnPack(TypePong, []byte("{}"))
+	assert.NoError(err)
+	assert.Equal(getTypeFn(msg), getTypeFn((*Pong)(nil)))
+}
+
+func TestUnPackInto(t *testing.T) {
+	assert := assert.New(t)
+
+	var err error
+
+	// correct type
+	pongMsg := &Pong{}
+	err = UnPackInto([]byte("{}"), pongMsg)
+	assert.NoError(err)
+
+	// wrong type
+	loginMsg := &Login{}
+	err = UnPackInto([]byte(`{"version": 123}`), loginMsg)
+	assert.Error(err)
+}

models/msg/process.go

@@ -0,0 +1,88 @@
+// 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 msg
+
+import (
+	"encoding/binary"
+	"fmt"
+	"io"
+)
+
+var (
+	MaxMsgLength int64 = 10240
+)
+
+func readMsg(c io.Reader) (typeByte byte, buffer []byte, err error) {
+	buffer = make([]byte, 1)
+	_, err = c.Read(buffer)
+	if err != nil {
+		return
+	}
+	typeByte = buffer[0]
+	if _, ok := TypeMap[typeByte]; !ok {
+		err = fmt.Errorf("Message type error")
+		return
+	}
+
+	var length int64
+	err = binary.Read(c, binary.BigEndian, &length)
+	if err != nil {
+		return
+	}
+	if length > MaxMsgLength {
+		err = fmt.Errorf("Message length exceed the limit")
+		return
+	}
+
+	buffer = make([]byte, length)
+	n, err := io.ReadFull(c, buffer)
+	if err != nil {
+		return
+	}
+
+	if int64(n) != length {
+		err = fmt.Errorf("Message format error")
+	}
+	return
+}
+
+func ReadMsg(c io.Reader) (msg Message, err error) {
+	typeByte, buffer, err := readMsg(c)
+	if err != nil {
+		return
+	}
+	return UnPack(typeByte, buffer)
+}
+
+func ReadMsgInto(c io.Reader, msg Message) (err error) {
+	_, buffer, err := readMsg(c)
+	if err != nil {
+		return
+	}
+	return UnPackInto(buffer, msg)
+}
+
+func WriteMsg(c io.Writer, msg interface{}) (err error) {
+	buffer, err := Pack(msg)
+	if err != nil {
+		return
+	}
+
+	if _, err = c.Write(buffer); err != nil {
+		return
+	}
+
+	return nil
+}

models/msg/process_test.go

@@ -0,0 +1,97 @@
+// 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 msg
+
+import (
+	"bytes"
+	"encoding/binary"
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestProcess(t *testing.T) {
+	assert := assert.New(t)
+
+	var (
+		msg    Message
+		resMsg Message
+		err    error
+	)
+	// empty struct
+	msg = &Ping{}
+	buffer := bytes.NewBuffer(nil)
+	err = WriteMsg(buffer, msg)
+	assert.NoError(err)
+
+	resMsg, err = ReadMsg(buffer)
+	assert.NoError(err)
+	assert.Equal(reflect.TypeOf(resMsg).Elem(), TypeMap[TypePing])
+
+	// normal message
+	msg = &StartWorkConn{
+		ProxyName: "test",
+	}
+	buffer = bytes.NewBuffer(nil)
+	err = WriteMsg(buffer, msg)
+	assert.NoError(err)
+
+	resMsg, err = ReadMsg(buffer)
+	assert.NoError(err)
+	assert.Equal(reflect.TypeOf(resMsg).Elem(), TypeMap[TypeStartWorkConn])
+
+	startWorkConnMsg, ok := resMsg.(*StartWorkConn)
+	assert.True(ok)
+	assert.Equal("test", startWorkConnMsg.ProxyName)
+
+	// ReadMsgInto correct
+	msg = &Pong{}
+	buffer = bytes.NewBuffer(nil)
+	err = WriteMsg(buffer, msg)
+	assert.NoError(err)
+
+	err = ReadMsgInto(buffer, msg)
+	assert.NoError(err)
+
+	// ReadMsgInto error type
+	content := []byte(`{"run_id": 123}`)
+	buffer = bytes.NewBuffer(nil)
+	buffer.WriteByte(TypeNewWorkConn)
+	binary.Write(buffer, binary.BigEndian, int64(len(content)))
+	buffer.Write(content)
+
+	resMsg = &NewWorkConn{}
+	err = ReadMsgInto(buffer, resMsg)
+	assert.Error(err)
+
+	// message format error
+	buffer = bytes.NewBuffer([]byte("1234"))
+
+	resMsg = &NewProxyResp{}
+	err = ReadMsgInto(buffer, resMsg)
+	assert.Error(err)
+
+	// MaxLength, real message length is 2
+	MaxMsgLength = 1
+	msg = &Ping{}
+	buffer = bytes.NewBuffer(nil)
+	err = WriteMsg(buffer, msg)
+	assert.NoError(err)
+
+	_, err = ReadMsg(buffer)
+	assert.Error(err)
+	return
+}