更改目录结构

server/sessdata/copy_struct.go

@@ -0,0 +1,51 @@
+package sessdata
+
+import (
+	"fmt"
+	"reflect"
+)
+
+// 用b的所有字段覆盖a的
+// 如果fields不为空, 表示用b的特定字段覆盖a的
+// a应该为结构体指针
+func CopyStruct(a interface{}, b interface{}, fields ...string) (err error) {
+	at := reflect.TypeOf(a)
+	av := reflect.ValueOf(a)
+	bt := reflect.TypeOf(b)
+	bv := reflect.ValueOf(b)
+
+	// 简单判断下
+	if at.Kind() != reflect.Ptr {
+		err = fmt.Errorf("a must be a struct pointer")
+		return
+	}
+	av = reflect.ValueOf(av.Interface())
+
+	// 要复制哪些字段
+	_fields := make([]string, 0)
+	if len(fields) > 0 {
+		_fields = fields
+	} else {
+		for i := 0; i < bv.NumField(); i++ {
+			_fields = append(_fields, bt.Field(i).Name)
+		}
+	}
+
+	if len(_fields) == 0 {
+		fmt.Println("no fields to copy")
+		return
+	}
+
+	// 复制
+	for i := 0; i < len(_fields); i++ {
+		name := _fields[i]
+		f := av.Elem().FieldByName(name)
+		bValue := bv.FieldByName(name)
+
+		// a中有同名的字段并且类型一致才复制
+		if f.IsValid() && f.Kind() == bValue.Kind() {
+			f.Set(bValue)
+		}
+	}
+	return
+}

server/sessdata/copy_struct_test.go

@@ -0,0 +1,38 @@
+package sessdata
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+type A struct {
+	Id   int
+	Name string
+	Age  int
+	Addr string
+}
+
+type B struct {
+	IdB   int
+	NameB string
+	Age   int
+	Addr  string
+}
+
+func TestCopyStruct(t *testing.T) {
+	assert := assert.New(t)
+	a := A{
+		Id:   1,
+		Name: "bob",
+		Age:  15,
+		Addr: "American",
+	}
+	b := B{}
+	err := CopyStruct(&b, a)
+	assert.Nil(err)
+	assert.Equal(b.IdB, 0)
+	assert.Equal(b.NameB, "")
+	assert.Equal(b.Age, 15)
+	assert.Equal(b.Addr, "American")
+}

server/sessdata/ip_pool.go

@@ -0,0 +1,167 @@
+package sessdata
+
+import (
+	"encoding/binary"
+	"net"
+	"sync"
+	"time"
+
+	"github.com/bjdgyc/anylink/base"
+	"github.com/bjdgyc/anylink/dbdata"
+)
+
+var (
+	IpPool   = &ipPoolConfig{}
+	ipActive = map[string]bool{}
+)
+
+type ipPoolConfig struct {
+	mux sync.Mutex
+	// 计算动态ip
+	Ipv4Gateway net.IP
+	Ipv4Mask    net.IP
+	Ipv4IPNet   *net.IPNet
+	IpLongMin   uint32
+	IpLongMax   uint32
+}
+
+func initIpPool() {
+
+	// 地址处理
+	_, ipNet, err := net.ParseCIDR(base.Cfg.Ipv4CIDR)
+	if err != nil {
+		panic(err)
+	}
+	IpPool.Ipv4IPNet = ipNet
+	IpPool.Ipv4Mask = net.IP(ipNet.Mask)
+	IpPool.Ipv4Gateway = net.ParseIP(base.Cfg.Ipv4Gateway)
+
+	// 网络地址零值
+	// zero := binary.BigEndian.Uint32(ip.Mask(mask))
+	// 广播地址
+	// one, _ := ipNet.Mask.Size()
+	// max := min | uint32(math.Pow(2, float64(32-one))-1)
+
+	// ip地址池
+	IpPool.IpLongMin = ip2long(net.ParseIP(base.Cfg.Ipv4Pool[0]))
+	IpPool.IpLongMax = ip2long(net.ParseIP(base.Cfg.Ipv4Pool[1]))
+}
+
+func long2ip(i uint32) net.IP {
+	ip := make([]byte, 4)
+	binary.BigEndian.PutUint32(ip, i)
+	return ip
+}
+
+func ip2long(ip net.IP) uint32 {
+	ip = ip.To4()
+	return binary.BigEndian.Uint32(ip)
+}
+
+// 获取动态ip
+func AcquireIp(username, macAddr string) net.IP {
+	IpPool.mux.Lock()
+	defer IpPool.mux.Unlock()
+
+	tNow := time.Now()
+
+	// 判断已经分配过
+	mi := &dbdata.IpMap{}
+	err := dbdata.One("MacAddr", macAddr, mi)
+	if err == nil {
+		ip := mi.IpAddr
+		ipStr := ip.String()
+		// 检测原有ip是否在新的ip池内
+		if IpPool.Ipv4IPNet.Contains(ip) {
+			mi.Username = username
+			mi.LastLogin = tNow
+			// 回写db数据
+			_ = dbdata.Save(mi)
+			ipActive[ipStr] = true
+			return ip
+		} else {
+			_ = dbdata.Del(mi)
+		}
+	}
+
+	// 全局遍历未分配ip
+	// 优先获取没有使用的ip
+	for i := IpPool.IpLongMin; i <= IpPool.IpLongMax; i++ {
+		ip := long2ip(i)
+		ipStr := ip.String()
+		mi := &dbdata.IpMap{}
+		err := dbdata.One("IpAddr", ip, mi)
+		if err != nil && dbdata.CheckErrNotFound(err) {
+			// 该ip没有被使用
+			mi := &dbdata.IpMap{IpAddr: ip, MacAddr: macAddr, Username: username, LastLogin: tNow}
+			_ = dbdata.Save(mi)
+			ipActive[ipStr] = true
+			return ip
+		}
+	}
+
+	farIp := &dbdata.IpMap{LastLogin: tNow}
+	// 遍历超过租期ip
+	for i := IpPool.IpLongMin; i <= IpPool.IpLongMax; i++ {
+		ip := long2ip(i)
+		ipStr := ip.String()
+
+		// 跳过活跃连接
+		if _, ok := ipActive[ipStr]; ok {
+			continue
+		}
+
+		v := &dbdata.IpMap{}
+		err := dbdata.One("IpAddr", ip, v)
+		if err != nil {
+			base.Error(err)
+			return nil
+		}
+		if v.Keep {
+			continue
+		}
+
+		// 已经超过租期
+		if tNow.Sub(v.LastLogin) > time.Duration(base.Cfg.IpLease)*time.Second {
+			_ = dbdata.Del(v)
+			mi := &dbdata.IpMap{IpAddr: ip, MacAddr: macAddr, Username: username, LastLogin: tNow}
+			// 重写db数据
+			_ = dbdata.Save(mi)
+			ipActive[ipStr] = true
+			return ip
+		}
+
+		// 其他情况判断最早登陆
+		if v.LastLogin.Before(farIp.LastLogin) {
+			farIp = v
+		}
+	}
+
+	// 全都在线，没有数据可用
+	if farIp.Id == 0 {
+		return nil
+	}
+
+	// 使用最早登陆的mac ip
+	ip := farIp.IpAddr
+	ipStr := ip.String()
+	mi = &dbdata.IpMap{IpAddr: ip, MacAddr: macAddr, Username: username, LastLogin: tNow}
+	// 回写db数据
+	_ = dbdata.Save(mi)
+	ipActive[ipStr] = true
+	return ip
+}
+
+// 回收ip
+func ReleaseIp(ip net.IP, macAddr string) {
+	IpPool.mux.Lock()
+	defer IpPool.mux.Unlock()
+
+	delete(ipActive, ip.String())
+	mi := &dbdata.IpMap{}
+	err := dbdata.One("IpAddr", ip, mi)
+	if err == nil {
+		mi.LastLogin = time.Now()
+		_ = dbdata.Save(mi)
+	}
+}

server/sessdata/ip_pool_test.go

@@ -0,0 +1,64 @@
+package sessdata
+
+import (
+	"fmt"
+	"net"
+	"os"
+	"path"
+	"testing"
+
+	"github.com/bjdgyc/anylink/base"
+	"github.com/bjdgyc/anylink/dbdata"
+	"github.com/stretchr/testify/assert"
+)
+
+func preData(tmpDir string) {
+	base.Test()
+	tmpDb := path.Join(tmpDir, "test.db")
+	base.Cfg.DbFile = tmpDb
+	base.Cfg.Ipv4CIDR = "192.168.3.0/24"
+	base.Cfg.Ipv4Pool = []string{"192.168.3.1", "192.168.3.199"}
+	base.Cfg.MaxClient = 100
+	base.Cfg.MaxUserClient = 3
+
+	dbdata.Start()
+	group := dbdata.Group{
+		Name:      "group1",
+		Bandwidth: 1000,
+	}
+	_ = dbdata.Save(&group)
+	initIpPool()
+}
+
+func cleardata(tmpDir string) {
+	_ = dbdata.Stop()
+	tmpDb := path.Join(tmpDir, "test.db")
+	os.Remove(tmpDb)
+}
+
+func TestIpPool(t *testing.T) {
+	assert := assert.New(t)
+	tmp := t.TempDir()
+	preData(tmp)
+	defer cleardata(tmp)
+
+	var ip net.IP
+
+	for i := 1; i <= 100; i++ {
+		_ = AcquireIp("user", fmt.Sprintf("mac-%d", i))
+	}
+	ip = AcquireIp("user", "mac-new")
+	assert.True(net.IPv4(192, 168, 3, 101).Equal(ip))
+	for i := 102; i <= 199; i++ {
+		ip = AcquireIp("user", fmt.Sprintf("mac-%d", i))
+	}
+	assert.True(net.IPv4(192, 168, 3, 199).Equal(ip))
+	ip = AcquireIp("user", "mac-nil")
+	assert.Nil(ip)
+
+	ReleaseIp(net.IPv4(192, 168, 3, 88), "mac-88")
+	ReleaseIp(net.IPv4(192, 168, 3, 77), "mac-77")
+	// 从头循环获取可用ip
+	ip = AcquireIp("user", "mac-release-new")
+	assert.True(net.IPv4(192, 168, 3, 77).Equal(ip))
+}

server/sessdata/limit_client.go

@@ -0,0 +1,45 @@
+package sessdata
+
+import (
+	"sync"
+
+	"github.com/bjdgyc/anylink/base"
+)
+
+const limitAllKey = "__ALL__"
+
+var (
+	limitClient = map[string]int{limitAllKey: 0}
+	limitMux    = sync.Mutex{}
+)
+
+func LimitClient(user string, close bool) bool {
+	limitMux.Lock()
+	defer limitMux.Unlock()
+
+	_all := limitClient[limitAllKey]
+	c, ok := limitClient[user]
+	if !ok { // 不存在用户
+		limitClient[user] = 0
+	}
+
+	if close {
+		limitClient[user] = c - 1
+		limitClient[limitAllKey] = _all - 1
+		return true
+	}
+
+	// 全局判断
+	if _all >= base.Cfg.MaxClient {
+		return false
+	}
+
+	// 超出同一个用户限制
+	if c >= base.Cfg.MaxUserClient {
+		return false
+	}
+
+	limitClient[user] = c + 1
+	limitClient[limitAllKey] = _all + 1
+	return true
+}

server/sessdata/limit_rate.go

@@ -0,0 +1,23 @@
+package sessdata
+
+import (
+	"context"
+
+	"golang.org/x/time/rate"
+)
+
+type LimitRater struct {
+	limit *rate.Limiter
+}
+
+// lim: 令牌产生速率
+// burst: 允许的最大爆发速率
+func NewLimitRater(lim, burst int) *LimitRater {
+	limit := rate.NewLimiter(rate.Limit(lim), burst)
+	return &LimitRater{limit: limit}
+}
+
+// bt 不能超过burst大小
+func (l *LimitRater) Wait(bt int) error {
+	return l.limit.WaitN(context.Background(), bt)
+}

server/sessdata/limit_test.go

@@ -0,0 +1,56 @@
+package sessdata
+
+import (
+	"testing"
+	"time"
+
+	"github.com/stretchr/testify/assert"
+
+	"github.com/bjdgyc/anylink/base"
+)
+
+// func TestCheckUser(t *testing.T) {
+// 	user["user1"] = User{Password: "7c4a8d09ca3762af61e59520943dc26494f8941b"}
+// 	user["user2"] = User{Password: "7c4a8d09ca3762af61e59520943dc26494f8941c"}
+//
+// 	var res bool
+// 	res = CheckUser("user1", "123456", "")
+// 	AssertTrue(t, res == true)
+//
+// 	res = CheckUser("user2", "123457", "")
+// 	AssertTrue(t, res == false)
+// }
+
+func TestLimitClient(t *testing.T) {
+	assert := assert.New(t)
+	base.Cfg.MaxClient = 2
+	base.Cfg.MaxUserClient = 1
+
+	res1 := LimitClient("user1", false)
+	res2 := LimitClient("user1", false)
+	res3 := LimitClient("user2", false)
+	res4 := LimitClient("user3", false)
+	res5 := LimitClient("user1", true)
+
+	assert.True(res1)
+	assert.False(res2)
+	assert.True(res3)
+	assert.False(res4)
+	assert.True(res5)
+
+}
+
+func TestLimitWait(t *testing.T) {
+	assert := assert.New(t)
+	limit := NewLimitRater(1, 2)
+	err := limit.Wait(2)
+	assert.Nil(err)
+	start := time.Now()
+	err = limit.Wait(2)
+	assert.Nil(err)
+	err = limit.Wait(1)
+	assert.Nil(err)
+	end := time.Now()
+	sub := end.Sub(start)
+	assert.Equal(3, int(sub.Seconds()))
+}

server/sessdata/online.go

@@ -0,0 +1,73 @@
+package sessdata
+
+import (
+	"bytes"
+	"net"
+	"sort"
+	"sync/atomic"
+	"time"
+
+	"github.com/bjdgyc/anylink/pkg/utils"
+)
+
+type Online struct {
+	Token            string    `json:"token"`
+	Username         string    `json:"username"`
+	Group            string    `json:"group"`
+	MacAddr          string    `json:"mac_addr"`
+	Ip               net.IP    `json:"ip"`
+	RemoteAddr       string    `json:"remote_addr"`
+	TunName          string    `json:"tun_name"`
+	Mtu              int       `json:"mtu"`
+	Client           string    `json:"client"`
+	BandwidthUp      string    `json:"bandwidth_up"`
+	BandwidthDown    string    `json:"bandwidth_down"`
+	BandwidthUpAll   string    `json:"bandwidth_up_all"`
+	BandwidthDownAll string    `json:"bandwidth_down_all"`
+	LastLogin        time.Time `json:"last_login"`
+}
+
+type Onlines []Online
+
+func (o Onlines) Len() int {
+	return len(o)
+}
+
+func (o Onlines) Less(i, j int) bool {
+	return bytes.Compare(o[i].Ip, o[j].Ip) < 0
+}
+
+func (o Onlines) Swap(i, j int) {
+	o[i], o[j] = o[j], o[i]
+}
+
+func OnlineSess() []Online {
+	var datas Onlines
+	sessMux.Lock()
+	for _, v := range sessions {
+		v.mux.Lock()
+		if v.IsActive {
+			val := Online{
+				Token:            v.Token,
+				Ip:               v.CSess.IpAddr,
+				Username:         v.Username,
+				Group:            v.Group,
+				MacAddr:          v.MacAddr,
+				RemoteAddr:       v.CSess.RemoteAddr,
+				TunName:          v.CSess.TunName,
+				Mtu:              v.CSess.Mtu,
+				Client:           v.CSess.Client,
+				BandwidthUp:      utils.HumanByte(atomic.LoadUint32(&v.CSess.BandwidthUpPeriod)) + "/s",
+				BandwidthDown:    utils.HumanByte(atomic.LoadUint32(&v.CSess.BandwidthDownPeriod)) + "/s",
+				BandwidthUpAll:   utils.HumanByte(atomic.LoadUint32(&v.CSess.BandwidthUpAll)),
+				BandwidthDownAll: utils.HumanByte(atomic.LoadUint32(&v.CSess.BandwidthDownAll)),
+				LastLogin:        v.LastLogin,
+			}
+			datas = append(datas, val)
+		}
+		v.mux.Unlock()
+	}
+	sessMux.Unlock()
+	sort.Sort(&datas)
+	return datas
+}

server/sessdata/protocol.go

@@ -0,0 +1,71 @@
+package sessdata
+
+type LType int8
+
+const (
+	LTypeEthernet LType = 1
+	LTypeIPData   LType = 2
+)
+
+type Payload struct {
+	PType byte  // payload types
+	LType LType // LinkType
+	Data  []byte
+}
+
+/*
+   var header = []byte{'S', 'T', 'F', 0x01, 0, 0, 0x00, 0}
+   https://tools.ietf.org/html/draft-mavrogiannopoulos-openconnect-02#section-2.2
+
+   +---------------------+---------------------------------------------+
+   |         byte        | value                                       |
+   +---------------------+---------------------------------------------+
+   |          0          | fixed to 0x53 (S)                           |
+   |                     |                                             |
+   |          1          | fixed to 0x54 (T)                           |
+   |                     |                                             |
+   |          2          | fixed to 0x46 (F)                           |
+   |                     |                                             |
+   |          3          | fixed to 0x01                               |
+   |                     |                                             |
+   |         4-5         | The length of the packet that follows this  |
+   |                     | header in big endian order                  |
+   |                     |                                             |
+   |          6          | The type of the payload that follows (see   |
+   |                     | Table 3 for available types)                |
+   |                     |                                             |
+   |          7          | fixed to 0x00                               |
+   +---------------------+---------------------------------------------+
+
+
+   The available payload types are listed in Table 3.
+   +---------------------+---------------------------------------------+
+   |        Value        | Description                                 |
+   +---------------------+---------------------------------------------+
+   |         0x00        | DATA: the TLS record packet contains an     |
+   |                     | IPv4 or IPv6 packet                         |
+   |                     |                                             |
+   |         0x03        | DPD-REQ: used for dead peer detection. Once |
+   |                     | sent the peer should reply with a DPD-RESP  |
+   |                     | packet, that has the same contents as the   |
+   |                     | original request.                           |
+   |                     |                                             |
+   |         0x04        | DPD-RESP: used as a response to a           |
+   |                     | previously received DPD-REQ.                |
+   |                     |                                             |
+   |         0x05        | DISCONNECT: sent by the client (or server)  |
+   |                     | to terminate the session.  No data is       |
+   |                     | associated with this request. The session   |
+   |                     | will be invalidated after such request.     |
+   |                     |                                             |
+   |         0x07        | KEEPALIVE: sent by any peer. No data is     |
+   |                     | associated with this request.               |
+   |                     |                                             |
+   |         0x08        | COMPRESSED DATA: a Data packet which is     |
+   |                     | compressed prior to encryption.             |
+   |                     |                                             |
+   |         0x09        | TERMINATE: sent by the server to indicate   |
+   |                     | that the server is shutting down. No data   |
+   |                     | is associated with this request.            |
+   +---------------------+---------------------------------------------+
+*/

server/sessdata/session.go

@@ -0,0 +1,318 @@
+package sessdata
+
+import (
+	"crypto/md5"
+	"fmt"
+	"math/rand"
+	"net"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+
+	"github.com/bjdgyc/anylink/base"
+	"github.com/bjdgyc/anylink/dbdata"
+)
+
+var (
+	// session_token -> SessUser
+	sessions = make(map[string]*Session)
+	sessMux  sync.Mutex
+)
+
+// 连接sess
+type ConnSession struct {
+	Sess                *Session
+	MasterSecret        string // dtls协议的 master_secret
+	IpAddr              net.IP // 分配的ip地址
+	LocalIp             net.IP
+	MacHw               net.HardwareAddr // 客户端mac地址,从Session取出
+	RemoteAddr          string
+	Mtu                 int
+	TunName             string
+	Client              string // 客户端  mobile pc
+	CstpDpd             int
+	Group               *dbdata.Group
+	Limit               *LimitRater
+	BandwidthUp         uint32 // 使用上行带宽 Byte
+	BandwidthDown       uint32 // 使用下行带宽 Byte
+	BandwidthUpPeriod   uint32 // 前一周期的总量
+	BandwidthDownPeriod uint32
+	BandwidthUpAll      uint32 // 使用上行带宽总量
+	BandwidthDownAll    uint32 // 使用下行带宽总量
+	closeOnce           sync.Once
+	CloseChan           chan struct{}
+	PayloadIn           chan *Payload
+	PayloadOut          chan *Payload
+}
+
+type Session struct {
+	mux            sync.Mutex
+	Sid            string // auth返回的 session-id
+	Token          string // session信息的唯一token
+	DtlsSid        string // dtls协议的 session_id
+	MacAddr        string // 客户端mac地址
+	UniqueIdGlobal string // 客户端唯一标示
+	Username       string // 用户名
+	Group          string
+	AuthStep       string
+	AuthPass       string
+
+	LastLogin time.Time
+	IsActive  bool
+
+	// 开启link需要设置的参数
+	CSess *ConnSession
+}
+
+func init() {
+	rand.Seed(time.Now().UnixNano())
+}
+
+func checkSession() {
+	// 检测过期的session
+	go func() {
+		if base.Cfg.SessionTimeout == 0 {
+			return
+		}
+		timeout := time.Duration(base.Cfg.SessionTimeout) * time.Second
+		tick := time.NewTicker(time.Second * 60)
+		for range tick.C {
+			sessMux.Lock()
+			t := time.Now()
+			for k, v := range sessions {
+				v.mux.Lock()
+				if !v.IsActive {
+					if t.Sub(v.LastLogin) > timeout {
+						delete(sessions, k)
+					}
+				}
+				v.mux.Unlock()
+			}
+			sessMux.Unlock()
+		}
+	}()
+}
+
+func GenToken() string {
+	// 生成32位的 token
+	btoken := make([]byte, 32)
+	rand.Read(btoken)
+	return fmt.Sprintf("%x", btoken)
+}
+
+func NewSession(token string) *Session {
+	if token == "" {
+		btoken := make([]byte, 32)
+		rand.Read(btoken)
+		token = fmt.Sprintf("%x", btoken)
+	}
+
+	// 生成 dtlsn session_id
+	dtlsid := make([]byte, 32)
+	rand.Read(dtlsid)
+
+	sess := &Session{
+		Sid:       fmt.Sprintf("%d", time.Now().Unix()),
+		Token:     token,
+		DtlsSid:   fmt.Sprintf("%x", dtlsid),
+		LastLogin: time.Now(),
+	}
+
+	sessMux.Lock()
+	sessions[token] = sess
+	sessMux.Unlock()
+	return sess
+}
+
+func (s *Session) NewConn() *ConnSession {
+	s.mux.Lock()
+	active := s.IsActive
+	macAddr := s.MacAddr
+	username := s.Username
+	s.mux.Unlock()
+	if active {
+		s.CSess.Close()
+	}
+
+	limit := LimitClient(username, false)
+	if !limit {
+		return nil
+	}
+	// 获取客户端mac地址
+	macHw, err := net.ParseMAC(macAddr)
+	if err != nil {
+		sum := md5.Sum([]byte(s.UniqueIdGlobal))
+		macHw = sum[0:5] // 5个byte
+		macHw = append([]byte{0x02}, macHw...)
+		macAddr = macHw.String()
+	}
+	ip := AcquireIp(username, macAddr)
+	if ip == nil {
+		LimitClient(username, true)
+		return nil
+	}
+
+	cSess := &ConnSession{
+		Sess:       s,
+		MacHw:      macHw,
+		IpAddr:     ip,
+		closeOnce:  sync.Once{},
+		CloseChan:  make(chan struct{}),
+		PayloadIn:  make(chan *Payload),
+		PayloadOut: make(chan *Payload),
+	}
+
+	// 查询group信息
+	group := &dbdata.Group{}
+	err = dbdata.One("Name", s.Group, group)
+	if err != nil {
+		base.Error(err)
+		cSess.Close()
+		return nil
+	}
+	cSess.Group = group
+	if group.Bandwidth > 0 {
+		// 限流设置
+		cSess.Limit = NewLimitRater(group.Bandwidth, group.Bandwidth)
+	}
+
+	go cSess.ratePeriod()
+
+	s.mux.Lock()
+	s.MacAddr = macAddr
+	s.IsActive = true
+	s.CSess = cSess
+	s.mux.Unlock()
+	return cSess
+}
+
+func (cs *ConnSession) Close() {
+	cs.closeOnce.Do(func() {
+		base.Info("closeOnce:", cs.IpAddr)
+		cs.Sess.mux.Lock()
+		defer cs.Sess.mux.Unlock()
+
+		close(cs.CloseChan)
+		cs.Sess.IsActive = false
+		cs.Sess.LastLogin = time.Now()
+		cs.Sess.CSess = nil
+
+		ReleaseIp(cs.IpAddr, cs.Sess.MacAddr)
+		LimitClient(cs.Sess.Username, true)
+	})
+}
+
+const BandwidthPeriodSec = 2 // 流量速率统计周期(秒)
+
+func (cs *ConnSession) ratePeriod() {
+	tick := time.NewTicker(time.Second * BandwidthPeriodSec)
+	defer tick.Stop()
+
+	for range tick.C {
+		select {
+		case <-cs.CloseChan:
+			return
+		default:
+		}
+
+		// 实时流量清零
+		rtUp := atomic.SwapUint32(&cs.BandwidthUp, 0)
+		rtDown := atomic.SwapUint32(&cs.BandwidthDown, 0)
+		// 设置上一周期每秒的流量
+		atomic.SwapUint32(&cs.BandwidthUpPeriod, rtUp/BandwidthPeriodSec)
+		atomic.SwapUint32(&cs.BandwidthDownPeriod, rtDown/BandwidthPeriodSec)
+		// 累加所有流量
+		atomic.AddUint32(&cs.BandwidthUpAll, rtUp)
+		atomic.AddUint32(&cs.BandwidthDownAll, rtDown)
+	}
+}
+
+const MaxMtu = 1460
+
+func (cs *ConnSession) SetMtu(mtu string) {
+	cs.Mtu = MaxMtu
+
+	mi, err := strconv.Atoi(mtu)
+	if err != nil || mi < 100 {
+		return
+	}
+
+	if mi < MaxMtu {
+		cs.Mtu = mi
+	}
+}
+
+func (cs *ConnSession) SetTunName(name string) {
+	cs.Sess.mux.Lock()
+	defer cs.Sess.mux.Unlock()
+	cs.TunName = name
+}
+
+func (cs *ConnSession) RateLimit(byt int, isUp bool) error {
+	if isUp {
+		atomic.AddUint32(&cs.BandwidthUp, uint32(byt))
+		return nil
+	}
+	// 只对下行速率限制
+	atomic.AddUint32(&cs.BandwidthDown, uint32(byt))
+	if cs.Limit == nil {
+		return nil
+	}
+	return cs.Limit.Wait(byt)
+}
+
+func SToken2Sess(stoken string) *Session {
+	stoken = strings.TrimSpace(stoken)
+	sarr := strings.Split(stoken, "@")
+	token := sarr[1]
+
+	return Token2Sess(token)
+}
+
+func Token2Sess(token string) *Session {
+	sessMux.Lock()
+	defer sessMux.Unlock()
+	return sessions[token]
+}
+
+func Dtls2Sess(dtlsid []byte) *Session {
+	return nil
+}
+
+func DelSess(token string) {
+	// sessions.Delete(token)
+}
+
+func CloseSess(token string) {
+	sessMux.Lock()
+	defer sessMux.Unlock()
+	sess, ok := sessions[token]
+	if !ok {
+		return
+	}
+
+	delete(sessions, token)
+	sess.CSess.Close()
+}
+
+func CloseCSess(token string) {
+	sessMux.Lock()
+	defer sessMux.Unlock()
+	sess, ok := sessions[token]
+	if !ok {
+		return
+	}
+
+	sess.CSess.Close()
+}
+
+func DelSessByStoken(stoken string) {
+	stoken = strings.TrimSpace(stoken)
+	sarr := strings.Split(stoken, "@")
+	token := sarr[1]
+	sessMux.Lock()
+	delete(sessions, token)
+	sessMux.Unlock()
+}

server/sessdata/session_test.go

@@ -0,0 +1,38 @@
+package sessdata
+
+import (
+	"testing"
+
+	"github.com/stretchr/testify/assert"
+)
+
+func TestNewSession(t *testing.T) {
+	ast := assert.New(t)
+	sessions = make(map[string]*Session)
+	sess := NewSession("")
+	token := sess.Token
+	v, ok := sessions[token]
+	ast.True(ok)
+	ast.Equal(sess, v)
+}
+
+func TestConnSession(t *testing.T) {
+	ast := assert.New(t)
+	tmp := t.TempDir()
+	preData(tmp)
+	defer cleardata(tmp)
+
+	sess := NewSession("")
+	sess.Group = "group1"
+	sess.MacAddr = "00:15:5d:50:14:43"
+
+	cSess := sess.NewConn()
+
+	err := cSess.RateLimit(100, true)
+	ast.Nil(err)
+	ast.Equal(cSess.BandwidthUp, uint32(100))
+	err = cSess.RateLimit(200, false)
+	ast.Nil(err)
+	ast.Equal(cSess.BandwidthDown, uint32(200))
+	cSess.Close()
+}

server/sessdata/start.go

@@ -0,0 +1,6 @@
+package sessdata
+
+func Start() {
+	initIpPool()
+	checkSession()
+}