7x31/anylink
1
0
Fork 0
mirror of https://github.com/bjdgyc/anylink.git synced 2025-08-11 13:36:51 +08:00
Code Issues Packages Projects Releases Wiki Activity

增加管理后台

Browse Source
This commit is contained in:
bjd
2020-12-16 16:36:56 +08:00
parent 31b1f12dbe
commit a9584000c6
68 changed files with 2408 additions and 1281 deletions
Download Patch File Download Diff File Expand all files Collapse all files

158
sessdata/ip_pool.go
View File

@@ -6,29 +6,16 @@ import (
"sync"
"time"
"github.com/bjdgyc/anylink/common"
"github.com/bjdgyc/anylink/base"
"github.com/bjdgyc/anylink/dbdata"
)
const (
// ip租期 (秒)
IpLease = 1209600
)
var (
IpPool = &IpPoolConfig{}
macInfo = map[string]*MacIp{}
ipInfo = map[string]*MacIp{}
IpPool = &ipPoolConfig{}
ipActive = map[string]bool{}
)
type MacIp struct {
IsActive bool
Ip net.IP
MacAddr string
LastLogin time.Time
}
type IpPoolConfig struct {
type ipPoolConfig struct {
mux sync.Mutex
// 计算动态ip
Ipv4Gateway net.IP
@@ -37,25 +24,15 @@ type IpPoolConfig struct {
IpLongMax uint32
}
func initIpMac() {
macs := dbdata.GetAllMacIp()
for _, v := range macs {
mi := &MacIp{}
CopyStruct(mi, v)
macInfo[v.MacAddr] = mi
ipInfo[v.Ip.String()] = mi
}
}
func initIpPool() {
// 地址处理
// ip地址
ip := net.ParseIP(common.ServerCfg.Ipv4Network)
ip := net.ParseIP(base.Cfg.Ipv4Network)
// 子网掩码
maskIp := net.ParseIP(common.ServerCfg.Ipv4Netmask).To4()
maskIp := net.ParseIP(base.Cfg.Ipv4Netmask).To4()
IpPool.Ipv4IPNet = net.IPNet{IP: ip, Mask: net.IPMask(maskIp)}
IpPool.Ipv4Gateway = net.ParseIP(common.ServerCfg.Ipv4Gateway)
IpPool.Ipv4Gateway = net.ParseIP(base.Cfg.Ipv4Gateway)
// 网络地址零值
// zero := binary.BigEndian.Uint32(ip.Mask(mask))
@@ -64,8 +41,8 @@ func initIpPool() {
// max := min | uint32(math.Pow(2, float64(32-one))-1)
// ip地址池
IpPool.IpLongMin = ip2long(net.ParseIP(common.ServerCfg.Ipv4Pool[0]))
IpPool.IpLongMax = ip2long(net.ParseIP(common.ServerCfg.Ipv4Pool[1]))
IpPool.IpLongMin = ip2long(net.ParseIP(base.Cfg.Ipv4Pool[0]))
IpPool.IpLongMax = ip2long(net.ParseIP(base.Cfg.Ipv4Pool[1]))
}
func long2ip(i uint32) net.IP {
@@ -80,79 +57,96 @@ func ip2long(ip net.IP) uint32 {
}
// 获取动态ip
func AcquireIp(macAddr string) net.IP {
func AcquireIp(username, macAddr string) net.IP {
IpPool.mux.Lock()
defer IpPool.mux.Unlock()
tNow := time.Now()
// 判断已经分配过
if mi, ok := macInfo[macAddr]; ok {
ip := mi.Ip
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.IsActive = true
mi.Username = username
mi.LastLogin = tNow
// 回写db数据
dbdata.Set(dbdata.BucketMacIp, macAddr, mi)
dbdata.Save(mi)
ipActive[ipStr] = true
return ip
} else {
delete(macInfo, macAddr)
delete(ipInfo, ip.String())
dbdata.Del(dbdata.BucketMacIp, macAddr)
dbdata.Del(mi)
}
}
farMac := &MacIp{LastLogin: tNow}
// 全局遍历未分配ip
// 优先获取没有使用的ip
for i := IpPool.IpLongMin; i <= IpPool.IpLongMax; i++ {
ip := long2ip(i)
ipStr := ip.String()
v, ok := ipInfo[ipStr]
// 该ip没有被使用
if !ok {
mi := &MacIp{IsActive: true, Ip: ip, MacAddr: macAddr, LastLogin: tNow}
macInfo[macAddr] = mi
ipInfo[ipStr] = mi
// 回写db数据
dbdata.Set(dbdata.BucketMacIp, macAddr, mi)
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.IsActive {
continue
}
// 已经超过租期
if tNow.Sub(v.LastLogin) > IpLease*time.Second {
delete(macInfo, v.MacAddr)
mi := &MacIp{IsActive: true, Ip: ip, MacAddr: macAddr, LastLogin: tNow}
macInfo[macAddr] = mi
ipInfo[ipStr] = mi
// 回写db数据
dbdata.Del(dbdata.BucketMacIp, v.MacAddr)
dbdata.Set(dbdata.BucketMacIp, macAddr, mi)
return ip
}
// 其他情况判断最早登陆的mac
if v.LastLogin.Before(farMac.LastLogin) {
farMac = v
// 其他情况判断最早登陆
if v.LastLogin.Before(farIp.LastLogin) {
farIp = v
}
}
// 全都在线，没有数据可用
if farMac.MacAddr == "" {
if farIp.Id == 0 {
return nil
}
// 使用最早登陆的mac ip
delete(macInfo, farMac.MacAddr)
ip := farMac.Ip
mi := &MacIp{IsActive: true, Ip: ip, MacAddr: macAddr, LastLogin: tNow}
macInfo[macAddr] = mi
ipInfo[ip.String()] = mi
ip := farIp.IpAddr
ipStr := ip.String()
mi = &dbdata.IpMap{IpAddr: ip, MacAddr: macAddr, Username: username, LastLogin: tNow}
// 回写db数据
dbdata.Del(dbdata.BucketMacIp, farMac.MacAddr)
dbdata.Set(dbdata.BucketMacIp, macAddr, mi)
dbdata.Save(mi)
ipActive[ipStr] = true
return ip
}
@@ -160,12 +154,12 @@ func AcquireIp(macAddr string) net.IP {
func ReleaseIp(ip net.IP, macAddr string) {
IpPool.mux.Lock()
defer IpPool.mux.Unlock()
if mi, ok := macInfo[macAddr]; ok {
if mi.Ip.Equal(ip) {
mi.IsActive = false
mi.LastLogin = time.Now()
// 回写db数据
dbdata.Set(dbdata.BucketMacIp, macAddr, mi)
}
delete(ipActive, ip.String())
mi := &dbdata.IpMap{}
err := dbdata.One("IpAddr", ip, mi)
if err == nil {
mi.LastLogin = time.Now()
dbdata.Save(mi)
}
}

22
sessdata/ip_pool_test.go
View File

@@ -7,17 +7,17 @@ import (
"path"
"testing"
"github.com/bjdgyc/anylink/common"
"github.com/bjdgyc/anylink/base"
"github.com/bjdgyc/anylink/dbdata"
"github.com/stretchr/testify/assert"
)
func preIpData() {
common.ServerCfg.Ipv4Network = "192.168.3.0"
common.ServerCfg.Ipv4Netmask = "255.255.255.0"
common.ServerCfg.Ipv4Pool = []string{"192.168.3.1", "192.168.3.199"}
base.Cfg.Ipv4Network = "192.168.3.0"
base.Cfg.Ipv4Netmask = "255.255.255.0"
base.Cfg.Ipv4Pool = []string{"192.168.3.1", "192.168.3.199"}
tmpDb := path.Join(os.TempDir(), "anylink_test.db")
common.ServerCfg.DbFile = tmpDb
base.Cfg.DbFile = tmpDb
dbdata.Start()
}
@@ -32,27 +32,25 @@ func TestIpPool(t *testing.T) {
preIpData()
defer closeIpdata()
macInfo = map[string]*MacIp{}
ipInfo = map[string]*MacIp{}
initIpPool()
var ip net.IP
for i := 1; i <= 100; i++ {
ip = AcquireIp(fmt.Sprintf("mac-%d", i))
ip = AcquireIp("user", fmt.Sprintf("mac-%d", i))
}
ip = AcquireIp(fmt.Sprintf("mac-new"))
ip = AcquireIp("user", fmt.Sprintf("mac-new"))
assert.True(net.IPv4(192, 168, 3, 101).Equal(ip))
for i := 102; i <= 199; i++ {
ip = AcquireIp(fmt.Sprintf("mac-%d", i))
ip = AcquireIp("user", fmt.Sprintf("mac-%d", i))
}
assert.True(net.IPv4(192, 168, 3, 199).Equal(ip))
ip = AcquireIp(fmt.Sprintf("mac-nil"))
ip = AcquireIp("user", fmt.Sprintf("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("mac-release-new")
ip = AcquireIp("user", "mac-release-new")
assert.True(net.IPv4(192, 168, 3, 88).Equal(ip))
}

7
sessdata/limit_client.go
View File

@@ -3,7 +3,7 @@ package sessdata
import (
"sync"
"github.com/bjdgyc/anylink/common"
"github.com/bjdgyc/anylink/base"
)
const limitAllKey = "__ALL__"
@@ -16,7 +16,6 @@ var (
func LimitClient(user string, close bool) bool {
limitMux.Lock()
defer limitMux.Unlock()
// defer fmt.Println(limitClient)
_all := limitClient[limitAllKey]
c, ok := limitClient[user]
@@ -31,12 +30,12 @@ func LimitClient(user string, close bool) bool {
}
// 全局判断
if _all >= common.ServerCfg.MaxClient {
if _all >= base.Cfg.MaxClient {
return false
}
// 超出同一个用户限制
if c >= common.ServerCfg.MaxUserClient {
if c >= base.Cfg.MaxUserClient {
return false
}

22
sessdata/limit_rate.go
View File

@@ -2,32 +2,10 @@ package sessdata
import (
"context"
"fmt"
"time"
"github.com/bjdgyc/anylink/common"
"golang.org/x/time/rate"
)
var Sess = &ConnSession{}
func init() {
return
tick := time.Tick(time.Second * 2)
go func() {
for range tick {
uP := common.HumanByte(float64(Sess.BandwidthUpPeriod / BandwidthPeriodSec))
dP := common.HumanByte(float64(Sess.BandwidthDownPeriod / BandwidthPeriodSec))
uA := common.HumanByte(float64(Sess.BandwidthUpAll))
dA := common.HumanByte(float64(Sess.BandwidthDownAll))
fmt.Printf("rateUp:%s rateDown:%s allUp %s allDown %s \n",
uP, dP, uA, dA)
}
}()
}
type LimitRater struct {
limit *rate.Limiter
}

10
sessdata/limit_test.go
View File

@@ -6,12 +6,12 @@ import (
"github.com/stretchr/testify/assert"
"github.com/bjdgyc/anylink/common"
"github.com/bjdgyc/anylink/base"
)
// func TestCheckUser(t *testing.T) {
// users["user1"] = User{Password: "7c4a8d09ca3762af61e59520943dc26494f8941b"}
// users["user2"] = User{Password: "7c4a8d09ca3762af61e59520943dc26494f8941c"}
// user["user1"] = User{Password: "7c4a8d09ca3762af61e59520943dc26494f8941b"}
// user["user2"] = User{Password: "7c4a8d09ca3762af61e59520943dc26494f8941c"}
//
// var res bool
// res = CheckUser("user1", "123456", "")
@@ -23,8 +23,8 @@ import (
func TestLimitClient(t *testing.T) {
assert := assert.New(t)
common.ServerCfg.MaxClient = 2
common.ServerCfg.MaxUserClient = 1
base.Cfg.MaxClient = 2
base.Cfg.MaxUserClient = 1
res1 := LimitClient("user1", false)
res2 := LimitClient("user1", false)

76
sessdata/online.go Normal file
View File

@@ -0,0 +1,76 @@
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 {
if bytes.Compare(o[i].Ip, o[j].Ip) < 0 {
return true
}
return false
}
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
}

132
sessdata/session.go
View File

@@ -12,26 +12,29 @@ import (
"sync/atomic"
"time"
"github.com/bjdgyc/anylink/common"
"github.com/bjdgyc/anylink/base"
"github.com/bjdgyc/anylink/dbdata"
)
const BandwidthPeriodSec = 2 // 流量速率统计周期(秒)
var (
// session_token -> SessUser
sessions = sync.Map{} // make(map[string]*Session)
sessions = make(map[string]*Session)
sessMux sync.Mutex
)
// 连接sess
type ConnSession struct {
Sess *Session
MasterSecret string // dtls协议的 master_secret
Ip net.IP // 分配的ip地址
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
@@ -43,7 +46,6 @@ type ConnSession struct {
CloseChan chan struct{}
PayloadIn chan *Payload
PayloadOut chan *Payload
PayloadArp chan *Payload
}
type Session struct {
@@ -53,7 +55,10 @@ type Session struct {
DtlsSid string // dtls协议的 session_id
MacAddr string // 客户端mac地址
UniqueIdGlobal string // 客户端唯一标示
UserName string // 用户名
Username string // 用户名
Group string
AuthStep string
AuthPass string
LastLogin time.Time
IsActive bool
@@ -67,45 +72,48 @@ func init() {
}
func checkSession() {
// 检测过期的session
go func() {
if common.ServerCfg.SessionTimeout == 0 {
if base.Cfg.SessionTimeout == 0 {
return
}
timeout := time.Duration(common.ServerCfg.SessionTimeout) * time.Second
timeout := time.Duration(base.Cfg.SessionTimeout) * time.Second
tick := time.Tick(time.Second * 60)
for range tick {
sessMux.Lock()
t := time.Now()
sessions.Range(func(key, value interface{}) bool {
v := value.(*Session)
for k, v := range sessions {
v.mux.Lock()
defer v.mux.Unlock()
if v.IsActive == true {
return true
if v.IsActive != true {
if t.Sub(v.LastLogin) > timeout {
delete(sessions, k)
}
}
if t.Sub(v.LastLogin) > timeout {
sessions.Delete(key)
}
return true
})
v.mux.Unlock()
}
sessMux.Unlock()
}
}()
}
func NewSession() *Session {
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)
token := fmt.Sprintf("%x", btoken)
sess := &Session{
Sid: fmt.Sprintf("%d", time.Now().Unix()),
Token: token,
@@ -113,7 +121,9 @@ func NewSession() *Session {
LastLogin: time.Now(),
}
sessions.Store(token, sess)
sessMux.Lock()
sessions[token] = sess
sessMux.Unlock()
return sess
}
@@ -121,12 +131,13 @@ func (s *Session) NewConn() *ConnSession {
s.mux.Lock()
active := s.IsActive
macAddr := s.MacAddr
username := s.Username
s.mux.Unlock()
if active == true {
s.CSess.Close()
}
limit := LimitClient(s.UserName, false)
limit := LimitClient(username, false)
if limit == false {
return nil
}
@@ -138,21 +149,34 @@ func (s *Session) NewConn() *ConnSession {
macHw = append([]byte{0x00}, macHw...)
macAddr = macHw.String()
}
ip := AcquireIp(macAddr)
ip := AcquireIp(username, macAddr)
if ip == nil {
LimitClient(username, true)
return nil
}
cSess := &ConnSession{
Sess: s,
MacHw: macHw,
Ip: ip,
IpAddr: ip,
closeOnce: sync.Once{},
CloseChan: make(chan struct{}),
PayloadIn: make(chan *Payload),
PayloadOut: make(chan *Payload),
PayloadArp: make(chan *Payload, 1000),
// Limit: NewLimitRater(1024 * 1024),
}
// 查询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()
@@ -167,7 +191,7 @@ func (s *Session) NewConn() *ConnSession {
func (cs *ConnSession) Close() {
cs.closeOnce.Do(func() {
log.Println("closeOnce:", cs.Ip)
log.Println("closeOnce:", cs.IpAddr)
cs.Sess.mux.Lock()
defer cs.Sess.mux.Unlock()
@@ -176,11 +200,13 @@ func (cs *ConnSession) Close() {
cs.Sess.LastLogin = time.Now()
cs.Sess.CSess = nil
ReleaseIp(cs.Ip, cs.Sess.MacAddr)
LimitClient(cs.Sess.UserName, true)
ReleaseIp(cs.IpAddr, cs.Sess.MacAddr)
LimitClient(cs.Sess.Username, true)
})
}
const BandwidthPeriodSec = 2 // 流量速率统计周期(秒)
func (cs *ConnSession) ratePeriod() {
tick := time.Tick(time.Second * BandwidthPeriodSec)
for range tick {
@@ -193,9 +219,9 @@ func (cs *ConnSession) ratePeriod() {
// 实时流量清零
rtUp := atomic.SwapUint32(&cs.BandwidthUp, 0)
rtDown := atomic.SwapUint32(&cs.BandwidthDown, 0)
// 设置上一周期的流量
atomic.SwapUint32(&cs.BandwidthUpPeriod, rtUp)
atomic.SwapUint32(&cs.BandwidthDownPeriod, rtDown)
// 设置上一周期每秒的流量
atomic.SwapUint32(&cs.BandwidthUpPeriod, rtUp/BandwidthPeriodSec)
atomic.SwapUint32(&cs.BandwidthDownPeriod, rtDown/BandwidthPeriodSec)
// 累加所有流量
atomic.AddUint32(&cs.BandwidthUpAll, rtUp)
atomic.AddUint32(&cs.BandwidthDownAll, rtDown)
@@ -217,6 +243,12 @@ func (cs *ConnSession) SetMtu(mtu string) {
}
}
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))
@@ -235,11 +267,13 @@ func SToken2Sess(stoken string) *Session {
sarr := strings.Split(stoken, "@")
token := sarr[1]
if sess, ok := sessions.Load(token); ok {
return sess.(*Session)
}
return Token2Sess(token)
}
return nil
func Token2Sess(token string) *Session {
sessMux.Lock()
defer sessMux.Unlock()
return sessions[token]
}
func Dtls2Sess(dtlsid []byte) *Session {
@@ -250,9 +284,23 @@ 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 DelSessByStoken(stoken string) {
stoken = strings.TrimSpace(stoken)
sarr := strings.Split(stoken, "@")
token := sarr[1]
sessions.Delete(token)
sessMux.Lock()
delete(sessions, token)
sessMux.Unlock()
}

9
sessdata/session_test.go
View File

@@ -1,7 +1,6 @@
package sessdata
import (
"sync"
"testing"
"github.com/stretchr/testify/assert"
@@ -9,10 +8,10 @@ import (
func TestNewSession(t *testing.T) {
assert := assert.New(t)
sessions = sync.Map{}
sess := NewSession()
sessions = make(map[string]*Session)
sess := NewSession("")
token := sess.Token
v, ok := sessions.Load(token)
v, ok := sessions[token]
assert.True(ok)
assert.Equal(sess, v)
}
@@ -21,7 +20,7 @@ func TestConnSession(t *testing.T) {
assert := assert.New(t)
preIpData()
defer closeIpdata()
sess := NewSession()
sess := NewSession("")
cSess := sess.NewConn()
cSess.RateLimit(100, true)
assert.Equal(cSess.BandwidthUp, uint32(100))

1
sessdata/start.go
View File

@@ -2,6 +2,5 @@ package sessdata
func Start() {
initIpPool()
initIpMac()
checkSession()
}