apps/openp2p
1
0
Fork 0
mirror of https://github.com/openp2p-cn/openp2p.git synced 2026-04-22 23:47:08 +08:00
Code Issues Actions Packages Projects Releases Wiki Activity

LF

Browse Source
This commit is contained in:
TenderIronh
2024-07-26 22:27:24 +08:00
parent 2dea3a718d
commit 9c3d557f5d
18 changed files with 4041 additions and 4041 deletions
Download Patch File Download Diff File Expand all files Collapse all files
USAGE-ZH.md
+108 -108
View File
@@ -1,108 +1,108 @@
# 手动运行说明 # 手动运行说明
大部分情况通过<https://console.openp2p.cn> 操作即可。有些情况需要手动运行 大部分情况通过<https://console.openp2p.cn> 操作即可。有些情况需要手动运行
> :warning: 本文所有命令, Windows环境使用"openp2p.exe", Linux环境使用"./openp2p" > :warning: 本文所有命令, Windows环境使用"openp2p.exe", Linux环境使用"./openp2p"
## 安装和监听 ## 安装和监听
``` ```
./openp2p install -node OFFICEPC1 -token TOKEN ./openp2p install -node OFFICEPC1 -token TOKEN
或 或
./openp2p -d -node OFFICEPC1 -token TOKEN ./openp2p -d -node OFFICEPC1 -token TOKEN
# 注意Windows系统把“./openp2p” 换成“openp2p.exe” # 注意Windows系统把“./openp2p” 换成“openp2p.exe”
``` ```
>* install: 安装模式【推荐】，会安装成系统服务，这样它就能随系统自动启动 >* install: 安装模式【推荐】，会安装成系统服务，这样它就能随系统自动启动
>* -d: daemon模式。发现worker进程意外退出就会自动启动新的worker进程 >* -d: daemon模式。发现worker进程意外退出就会自动启动新的worker进程
>* -node: 独一无二的节点名字，唯一标识 >* -node: 独一无二的节点名字，唯一标识
>* -token: 在<console.openp2p.cn>“我的”里面找到 >* -token: 在<console.openp2p.cn>“我的”里面找到
>* -sharebandwidth: 作为共享节点时提供带宽，默认10mbps. 如果是光纤大带宽，设置越大效果越好. 0表示不共享，该节点只在私有的P2P网络使用。不加入共享的P2P网络，这样也意味着无法使用别人的共享节点 >* -sharebandwidth: 作为共享节点时提供带宽，默认10mbps. 如果是光纤大带宽，设置越大效果越好. 0表示不共享，该节点只在私有的P2P网络使用。不加入共享的P2P网络，这样也意味着无法使用别人的共享节点
>* -loglevel: 需要查看更多调试日志，设置0；默认是1 >* -loglevel: 需要查看更多调试日志，设置0；默认是1
### 在docker容器里运行openp2p ### 在docker容器里运行openp2p
我们暂时还没提供官方docker镜像，你可以在随便一个容器里运行 我们暂时还没提供官方docker镜像，你可以在随便一个容器里运行
``` ```
nohup ./openp2p -d -node OFFICEPC1 -token TOKEN & nohup ./openp2p -d -node OFFICEPC1 -token TOKEN &
#这里由于一般的镜像都精简过，install系统服务会失败，所以使用直接daemon模式后台运行 #这里由于一般的镜像都精简过，install系统服务会失败，所以使用直接daemon模式后台运行
``` ```
## 连接 ## 连接
``` ```
./openp2p -d -node HOMEPC123 -token TOKEN -appname OfficeWindowsRemote -peernode OFFICEPC1 -dstip 127.0.0.1 -dstport 3389 -srcport 23389 ./openp2p -d -node HOMEPC123 -token TOKEN -appname OfficeWindowsRemote -peernode OFFICEPC1 -dstip 127.0.0.1 -dstport 3389 -srcport 23389
使用配置文件，建立多个P2PApp 使用配置文件，建立多个P2PApp
./openp2p -d ./openp2p -d
``` ```
>* -appname: 这个P2P应用名字 >* -appname: 这个P2P应用名字
>* -peernode: 目标节点名字 >* -peernode: 目标节点名字
>* -dstip: 目标服务地址，默认本机127.0.0.1 >* -dstip: 目标服务地址，默认本机127.0.0.1
>* -dstport: 目标服务端口，常见的如windows远程桌面3389，Linux ssh 22 >* -dstport: 目标服务端口，常见的如windows远程桌面3389，Linux ssh 22
>* -protocol: 目标服务协议 tcp、udp >* -protocol: 目标服务协议 tcp、udp
## 配置文件 ## 配置文件
一般保存在当前目录，安装模式下会保存到 `C:\Program Files\OpenP2P\config.json` 或 `/usr/local/openp2p/config.json` 一般保存在当前目录，安装模式下会保存到 `C:\Program Files\OpenP2P\config.json` 或 `/usr/local/openp2p/config.json`
希望修改参数，或者配置多个P2PApp可手动修改配置文件 希望修改参数，或者配置多个P2PApp可手动修改配置文件
配置实例 配置实例
``` ```
{ {
"network": { "network": {
"Node": "YOUR-NODE-NAME", "Node": "YOUR-NODE-NAME",
"Token": "TOKEN", "Token": "TOKEN",
"ShareBandwidth": 0, "ShareBandwidth": 0,
"ServerHost": "api.openp2p.cn", "ServerHost": "api.openp2p.cn",
"ServerPort": 27183, "ServerPort": 27183,
"UDPPort1": 27182, "UDPPort1": 27182,
"UDPPort2": 27183 "UDPPort2": 27183
}, },
"apps": [ "apps": [
{ {
"AppName": "OfficeWindowsPC", "AppName": "OfficeWindowsPC",
"Protocol": "tcp", "Protocol": "tcp",
"SrcPort": 23389, "SrcPort": 23389,
"PeerNode": "OFFICEPC1", "PeerNode": "OFFICEPC1",
"DstPort": 3389, "DstPort": 3389,
"DstHost": "localhost", "DstHost": "localhost",
}, },
{ {
"AppName": "OfficeServerSSH", "AppName": "OfficeServerSSH",
"Protocol": "tcp", "Protocol": "tcp",
"SrcPort": 22, "SrcPort": 22,
"PeerNode": "OFFICEPC1", "PeerNode": "OFFICEPC1",
"DstPort": 22, "DstPort": 22,
"DstHost": "192.168.1.5", "DstHost": "192.168.1.5",
} }
] ]
} }
``` ```
## 升级客户端 ## 升级客户端
``` ```
# update local client # update local client
./openp2p update ./openp2p update
# update remote client # update remote client
curl --insecure 'https://api.openp2p.cn:27183/api/v1/device/YOUR-NODE-NAME/update?user=&password=' curl --insecure 'https://api.openp2p.cn:27183/api/v1/device/YOUR-NODE-NAME/update?user=&password='
``` ```
Windows系统需要设置防火墙放行本程序，程序会自动设置，如果设置失败会影响连接功能。 Windows系统需要设置防火墙放行本程序，程序会自动设置，如果设置失败会影响连接功能。
Linux系统（Ubuntu和CentOS7）的防火墙默认配置均不会有影响，如果不行可尝试关闭防火墙 Linux系统（Ubuntu和CentOS7）的防火墙默认配置均不会有影响，如果不行可尝试关闭防火墙
``` ```
systemctl stop firewalld.service systemctl stop firewalld.service
systemctl start firewalld.service systemctl start firewalld.service
firewall-cmd --state firewall-cmd --state
``` ```
## 停止 ## 停止
TODO: windows linux macos TODO: windows linux macos
## 卸载 ## 卸载
``` ```
./openp2p uninstall ./openp2p uninstall
# 已安装时 # 已安装时
# windows # windows
C:\Program Files\OpenP2P\openp2p.exe uninstall C:\Program Files\OpenP2P\openp2p.exe uninstall
# linux,macos # linux,macos
sudo /usr/local/openp2p/openp2p uninstall sudo /usr/local/openp2p/openp2p uninstall
``` ```
## Docker运行 ## Docker运行
``` ```
# 把YOUR-TOKEN和YOUR-NODE-NAME替换成自己的 # 把YOUR-TOKEN和YOUR-NODE-NAME替换成自己的
docker run -d --restart=always --net host --name openp2p-client -e OPENP2P_TOKEN=YOUR-TOKEN -e OPENP2P_NODE=YOUR-NODE-NAME openp2pcn/openp2p-client:latest docker run -d --restart=always --net host --name openp2p-client -e OPENP2P_TOKEN=YOUR-TOKEN -e OPENP2P_NODE=YOUR-NODE-NAME openp2pcn/openp2p-client:latest
OR OR
docker run -d --restart=always --net host --name openp2p-client openp2pcn/openp2p-client:latest -token YOUR-TOKEN -node YOUR-NODE-NAME docker run -d --restart=always --net host --name openp2p-client openp2pcn/openp2p-client:latest -token YOUR-TOKEN -node YOUR-NODE-NAME
``` ```
USAGE.md
+108 -108
View File
@@ -1,109 +1,109 @@
# Parameters details # Parameters details
In most cases, you can operate it through <https://console.openp2p.cn>. In some cases it is necessary to run manually In most cases, you can operate it through <https://console.openp2p.cn>. In some cases it is necessary to run manually
> :warning: all commands in this doc, Windows env uses "openp2p.exe", Linux env uses "./openp2p" > :warning: all commands in this doc, Windows env uses "openp2p.exe", Linux env uses "./openp2p"
## Install and Listen ## Install and Listen
``` ```
./openp2p install -node OFFICEPC1 -token TOKEN ./openp2p install -node OFFICEPC1 -token TOKEN
Or Or
./openp2p -d -node OFFICEPC1 -token TOKEN ./openp2p -d -node OFFICEPC1 -token TOKEN
``` ```
>* install: [recommand] will install as system service. So it will autorun when system booting. >* install: [recommand] will install as system service. So it will autorun when system booting.
>* -d: daemon mode run once. When the worker process is found to exit unexpectedly, a new worker process will be automatically started >* -d: daemon mode run once. When the worker process is found to exit unexpectedly, a new worker process will be automatically started
>* -node: Unique node name, unique identification >* -node: Unique node name, unique identification
>* -token: See <console.openp2p.cn> "Profile" >* -token: See <console.openp2p.cn> "Profile"
>* -sharebandwidth: Provides bandwidth when used as a shared node, the default is 10mbps. If it is a large bandwidth of optical fiber, the larger the setting, the better the effect. 0 means not shared, the node is only used in a private P2P network. Do not join the shared P2P network, which also means that you CAN NOT use other people’s shared nodes >* -sharebandwidth: Provides bandwidth when used as a shared node, the default is 10mbps. If it is a large bandwidth of optical fiber, the larger the setting, the better the effect. 0 means not shared, the node is only used in a private P2P network. Do not join the shared P2P network, which also means that you CAN NOT use other people’s shared nodes
>* -loglevel: Need to view more debug logs, set 0; the default is 1 >* -loglevel: Need to view more debug logs, set 0; the default is 1
### Run in Docker container ### Run in Docker container
We don't provide official docker image yet, you can run it in any container We don't provide official docker image yet, you can run it in any container
``` ```
nohup ./openp2p -d -node OFFICEPC1 -token TOKEN & nohup ./openp2p -d -node OFFICEPC1 -token TOKEN &
# Since many docker images have been simplified, the install system service will fail, so the daemon mode is used to run in the background # Since many docker images have been simplified, the install system service will fail, so the daemon mode is used to run in the background
``` ```
## Connect ## Connect
``` ```
./openp2p -d -node HOMEPC123 -token TOKEN -appname OfficeWindowsRemote -peernode OFFICEPC1 -dstip 127.0.0.1 -dstport 3389 -srcport 23389 ./openp2p -d -node HOMEPC123 -token TOKEN -appname OfficeWindowsRemote -peernode OFFICEPC1 -dstip 127.0.0.1 -dstport 3389 -srcport 23389
Create multiple P2PApp by config file Create multiple P2PApp by config file
./openp2p -d ./openp2p -d
``` ```
>* -appname: This P2PApp name >* -appname: This P2PApp name
>* -peernode: Target node name >* -peernode: Target node name
>* -dstip: Target service address, default local 127.0.0.1 >* -dstip: Target service address, default local 127.0.0.1
>* -dstport: Target service port, such as windows remote desktop 3389, Linux ssh 22 >* -dstport: Target service port, such as windows remote desktop 3389, Linux ssh 22
>* -protocol: Target service protocol tcp, udp >* -protocol: Target service protocol tcp, udp
## Config file ## Config file
Generally saved in the current directory, in installation mode it will be saved to `C:\Program Files\OpenP2P\config.json` or `/usr/local/openp2p/config.json` Generally saved in the current directory, in installation mode it will be saved to `C:\Program Files\OpenP2P\config.json` or `/usr/local/openp2p/config.json`
If you want to modify the parameters, or configure multiple P2PApps, you can manually modify the configuration file If you want to modify the parameters, or configure multiple P2PApps, you can manually modify the configuration file
Configuration example Configuration example
``` ```
{ {
"network": { "network": {
"Node": "YOUR-NODE-NAME", "Node": "YOUR-NODE-NAME",
"Token": "TOKEN", "Token": "TOKEN",
"ShareBandwidth": 0, "ShareBandwidth": 0,
"ServerHost": "api.openp2p.cn", "ServerHost": "api.openp2p.cn",
"ServerPort": 27183, "ServerPort": 27183,
"UDPPort1": 27182, "UDPPort1": 27182,
"UDPPort2": 27183 "UDPPort2": 27183
}, },
"apps": [ "apps": [
{ {
"AppName": "OfficeWindowsPC", "AppName": "OfficeWindowsPC",
"Protocol": "tcp", "Protocol": "tcp",
"SrcPort": 23389, "SrcPort": 23389,
"PeerNode": "OFFICEPC1", "PeerNode": "OFFICEPC1",
"DstPort": 3389, "DstPort": 3389,
"DstHost": "localhost", "DstHost": "localhost",
}, },
{ {
"AppName": "OfficeServerSSH", "AppName": "OfficeServerSSH",
"Protocol": "tcp", "Protocol": "tcp",
"SrcPort": 22, "SrcPort": 22,
"PeerNode": "OFFICEPC1", "PeerNode": "OFFICEPC1",
"DstPort": 22, "DstPort": 22,
"DstHost": "192.168.1.5", "DstHost": "192.168.1.5",
} }
] ]
} }
``` ```
## Client update ## Client update
``` ```
# update local client # update local client
./openp2p update ./openp2p update
# update remote client # update remote client
curl --insecure 'https://api.openp2p.cn:27183/api/v1/device/YOUR-NODE-NAME/update?user=&password=' curl --insecure 'https://api.openp2p.cn:27183/api/v1/device/YOUR-NODE-NAME/update?user=&password='
``` ```
Windows system needs to set up firewall for this program, the program will automatically set the firewall, if the setting fails, the UDP punching will be affected. Windows system needs to set up firewall for this program, the program will automatically set the firewall, if the setting fails, the UDP punching will be affected.
The default firewall configuration of Linux system (Ubuntu and CentOS7) will not have any effect, if not, you can try to turn off the firewall The default firewall configuration of Linux system (Ubuntu and CentOS7) will not have any effect, if not, you can try to turn off the firewall
``` ```
systemctl stop firewalld.service systemctl stop firewalld.service
systemctl start firewalld.service systemctl start firewalld.service
firewall-cmd --state firewall-cmd --state
``` ```
## Uninstall ## Uninstall
``` ```
./openp2p uninstall ./openp2p uninstall
# when already installed # when already installed
# windows # windows
C:\Program Files\OpenP2P\openp2p.exe uninstall C:\Program Files\OpenP2P\openp2p.exe uninstall
# linux,macos # linux,macos
sudo /usr/local/openp2p/openp2p uninstall sudo /usr/local/openp2p/openp2p uninstall
``` ```
## Run with Docker ## Run with Docker
``` ```
# Replace YOUR-TOKEN and YOUR-NODE-NAME with yours # Replace YOUR-TOKEN and YOUR-NODE-NAME with yours
docker run -d --net host --name openp2p-client -e OPENP2P_TOKEN=YOUR-TOKEN -e OPENP2P_NODE=YOUR-NODE-NAME openp2pcn/openp2p-client:latest docker run -d --net host --name openp2p-client -e OPENP2P_TOKEN=YOUR-TOKEN -e OPENP2P_NODE=YOUR-NODE-NAME openp2pcn/openp2p-client:latest
OR OR
docker run -d --net host --name openp2p-client openp2pcn/openp2p-client:latest -token YOUR-TOKEN -node YOUR-NODE-NAME docker run -d --net host --name openp2p-client openp2pcn/openp2p-client:latest -token YOUR-TOKEN -node YOUR-NODE-NAME
``` ```
cmd/openp2p.go
+9 -9
View File
@@ -1,9 +1,9 @@
package main package main
import ( import (
op "openp2p/core" op "openp2p/core"
) )
func main() { func main() {
op.Run() op.Run()
} }
core/daemon.go
+115 -115
View File
@@ -1,115 +1,115 @@
package openp2p package openp2p
import ( import (
"fmt" "fmt"
"os" "os"
"path/filepath" "path/filepath"
"time" "time"
"github.com/openp2p-cn/service" "github.com/openp2p-cn/service"
) )
type daemon struct { type daemon struct {
running bool running bool
proc *os.Process proc *os.Process
} }
func (d *daemon) Start(s service.Service) error { func (d *daemon) Start(s service.Service) error {
gLog.Println(LvINFO, "daemon start") gLog.Println(LvINFO, "daemon start")
return nil return nil
} }
func (d *daemon) Stop(s service.Service) error { func (d *daemon) Stop(s service.Service) error {
gLog.Println(LvINFO, "service stop") gLog.Println(LvINFO, "service stop")
d.running = false d.running = false
if d.proc != nil { if d.proc != nil {
gLog.Println(LvINFO, "stop worker") gLog.Println(LvINFO, "stop worker")
d.proc.Kill() d.proc.Kill()
} }
if service.Interactive() { if service.Interactive() {
gLog.Println(LvINFO, "stop daemon") gLog.Println(LvINFO, "stop daemon")
os.Exit(0) os.Exit(0)
} }
return nil return nil
} }
func (d *daemon) run() { func (d *daemon) run() {
gLog.Println(LvINFO, "daemon run start") gLog.Println(LvINFO, "daemon run start")
defer gLog.Println(LvINFO, "daemon run end") defer gLog.Println(LvINFO, "daemon run end")
d.running = true d.running = true
binPath, _ := os.Executable() binPath, _ := os.Executable()
mydir, err := os.Getwd() mydir, err := os.Getwd()
if err != nil { if err != nil {
fmt.Println(err) fmt.Println(err)
} }
gLog.Println(LvINFO, mydir) gLog.Println(LvINFO, mydir)
conf := &service.Config{ conf := &service.Config{
Name: ProductName, Name: ProductName,
DisplayName: ProductName, DisplayName: ProductName,
Description: ProductName, Description: ProductName,
Executable: binPath, Executable: binPath,
} }
s, _ := service.New(d, conf) s, _ := service.New(d, conf)
go s.Run() go s.Run()
var args []string var args []string
// rm -d parameter // rm -d parameter
for i := 0; i < len(os.Args); i++ { for i := 0; i < len(os.Args); i++ {
if os.Args[i] == "-d" { if os.Args[i] == "-d" {
args = append(os.Args[0:i], os.Args[i+1:]...) args = append(os.Args[0:i], os.Args[i+1:]...)
break break
} }
} }
args = append(args, "-nv") args = append(args, "-nv")
for { for {
// start worker // start worker
tmpDump := filepath.Join("log", "dump.log.tmp") tmpDump := filepath.Join("log", "dump.log.tmp")
dumpFile := filepath.Join("log", "dump.log") dumpFile := filepath.Join("log", "dump.log")
f, err := os.Create(filepath.Join(tmpDump)) f, err := os.Create(filepath.Join(tmpDump))
if err != nil { if err != nil {
gLog.Printf(LvERROR, "start worker error:%s", err) gLog.Printf(LvERROR, "start worker error:%s", err)
return return
} }
gLog.Println(LvINFO, "start worker process, args:", args) gLog.Println(LvINFO, "start worker process, args:", args)
execSpec := &os.ProcAttr{Env: append(os.Environ(), "GOTRACEBACK=crash"), Files: []*os.File{os.Stdin, os.Stdout, f}} execSpec := &os.ProcAttr{Env: append(os.Environ(), "GOTRACEBACK=crash"), Files: []*os.File{os.Stdin, os.Stdout, f}}
p, err := os.StartProcess(binPath, args, execSpec) p, err := os.StartProcess(binPath, args, execSpec)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "start worker error:%s", err) gLog.Printf(LvERROR, "start worker error:%s", err)
return return
} }
d.proc = p d.proc = p
_, _ = p.Wait() _, _ = p.Wait()
f.Close() f.Close()
time.Sleep(time.Second) time.Sleep(time.Second)
err = os.Rename(tmpDump, dumpFile) err = os.Rename(tmpDump, dumpFile)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "rename dump error:%s", err) gLog.Printf(LvERROR, "rename dump error:%s", err)
} }
if !d.running { if !d.running {
return return
} }
gLog.Printf(LvERROR, "worker stop, restart it after 10s") gLog.Printf(LvERROR, "worker stop, restart it after 10s")
time.Sleep(time.Second * 10) time.Sleep(time.Second * 10)
} }
} }
func (d *daemon) Control(ctrlComm string, exeAbsPath string, args []string) error { func (d *daemon) Control(ctrlComm string, exeAbsPath string, args []string) error {
svcConfig := &service.Config{ svcConfig := &service.Config{
Name: ProductName, Name: ProductName,
DisplayName: ProductName, DisplayName: ProductName,
Description: ProductName, Description: ProductName,
Executable: exeAbsPath, Executable: exeAbsPath,
Arguments: args, Arguments: args,
} }
s, e := service.New(d, svcConfig) s, e := service.New(d, svcConfig)
if e != nil { if e != nil {
return e return e
} }
e = service.Control(s, ctrlComm) e = service.Control(s, ctrlComm)
if e != nil { if e != nil {
return e return e
} }
return nil return nil
} }
core/handlepush.go
+482 -482
View File
@@ -1,482 +1,482 @@
package openp2p package openp2p
import ( import (
"bytes" "bytes"
"encoding/binary" "encoding/binary"
"encoding/json" "encoding/json"
"fmt" "fmt"
"net" "net"
"os" "os"
"path/filepath" "path/filepath"
"reflect" "reflect"
"runtime" "runtime"
"time" "time"
"github.com/openp2p-cn/totp" "github.com/openp2p-cn/totp"
) )
func handlePush(subType uint16, msg []byte) error { func handlePush(subType uint16, msg []byte) error {
pushHead := PushHeader{} pushHead := PushHeader{}
err := binary.Read(bytes.NewReader(msg[openP2PHeaderSize:openP2PHeaderSize+PushHeaderSize]), binary.LittleEndian, &pushHead) err := binary.Read(bytes.NewReader(msg[openP2PHeaderSize:openP2PHeaderSize+PushHeaderSize]), binary.LittleEndian, &pushHead)
if err != nil { if err != nil {
return err return err
} }
gLog.Printf(LvDEBUG, "handle push msg type:%d, push header:%+v", subType, pushHead) gLog.Printf(LvDEBUG, "handle push msg type:%d, push header:%+v", subType, pushHead)
switch subType { switch subType {
case MsgPushConnectReq: case MsgPushConnectReq:
err = handleConnectReq(msg) err = handleConnectReq(msg)
case MsgPushRsp: case MsgPushRsp:
rsp := PushRsp{} rsp := PushRsp{}
if err = json.Unmarshal(msg[openP2PHeaderSize:], &rsp); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize:], &rsp); err != nil {
gLog.Printf(LvERROR, "wrong pushRsp:%s", err) gLog.Printf(LvERROR, "wrong pushRsp:%s", err)
return err return err
} }
if rsp.Error == 0 { if rsp.Error == 0 {
gLog.Printf(LvDEBUG, "push ok, detail:%s", rsp.Detail) gLog.Printf(LvDEBUG, "push ok, detail:%s", rsp.Detail)
} else { } else {
gLog.Printf(LvERROR, "push error:%d, detail:%s", rsp.Error, rsp.Detail) gLog.Printf(LvERROR, "push error:%d, detail:%s", rsp.Error, rsp.Detail)
} }
case MsgPushAddRelayTunnelReq: case MsgPushAddRelayTunnelReq:
req := AddRelayTunnelReq{} req := AddRelayTunnelReq{}
if err = json.Unmarshal(msg[openP2PHeaderSize+PushHeaderSize:], &req); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize+PushHeaderSize:], &req); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s", reflect.TypeOf(req), err) gLog.Printf(LvERROR, "wrong %v:%s", reflect.TypeOf(req), err)
return err return err
} }
config := AppConfig{} config := AppConfig{}
config.PeerNode = req.RelayName config.PeerNode = req.RelayName
config.peerToken = req.RelayToken config.peerToken = req.RelayToken
config.relayMode = req.RelayMode config.relayMode = req.RelayMode
go func(r AddRelayTunnelReq) { go func(r AddRelayTunnelReq) {
t, errDt := GNetwork.addDirectTunnel(config, 0) t, errDt := GNetwork.addDirectTunnel(config, 0)
if errDt == nil { if errDt == nil {
// notify peer relay ready // notify peer relay ready
msg := TunnelMsg{ID: t.id} msg := TunnelMsg{ID: t.id}
GNetwork.push(r.From, MsgPushAddRelayTunnelRsp, msg) GNetwork.push(r.From, MsgPushAddRelayTunnelRsp, msg)
appConfig := config appConfig := config
appConfig.PeerNode = req.From appConfig.PeerNode = req.From
} else { } else {
gLog.Printf(LvERROR, "addDirectTunnel error:%s", errDt) gLog.Printf(LvERROR, "addDirectTunnel error:%s", errDt)
GNetwork.push(r.From, MsgPushAddRelayTunnelRsp, "error") // compatible with old version client, trigger unmarshal error GNetwork.push(r.From, MsgPushAddRelayTunnelRsp, "error") // compatible with old version client, trigger unmarshal error
} }
}(req) }(req)
case MsgPushServerSideSaveMemApp: case MsgPushServerSideSaveMemApp:
req := ServerSideSaveMemApp{} req := ServerSideSaveMemApp{}
if err = json.Unmarshal(msg[openP2PHeaderSize+PushHeaderSize:], &req); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize+PushHeaderSize:], &req); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s", reflect.TypeOf(req), err) gLog.Printf(LvERROR, "wrong %v:%s", reflect.TypeOf(req), err)
return err return err
} }
gLog.Println(LvDEBUG, "handle MsgPushServerSideSaveMemApp:", prettyJson(req)) gLog.Println(LvDEBUG, "handle MsgPushServerSideSaveMemApp:", prettyJson(req))
var existTunnel *P2PTunnel var existTunnel *P2PTunnel
i, ok := GNetwork.allTunnels.Load(req.TunnelID) i, ok := GNetwork.allTunnels.Load(req.TunnelID)
if !ok { if !ok {
time.Sleep(time.Millisecond * 100) time.Sleep(time.Millisecond * 100)
i, ok = GNetwork.allTunnels.Load(req.TunnelID) // retry sometimes will receive MsgPushServerSideSaveMemApp but p2ptunnel not store yet. i, ok = GNetwork.allTunnels.Load(req.TunnelID) // retry sometimes will receive MsgPushServerSideSaveMemApp but p2ptunnel not store yet.
if !ok { if !ok {
gLog.Println(LvERROR, "handle MsgPushServerSideSaveMemApp error:", ErrMemAppTunnelNotFound) gLog.Println(LvERROR, "handle MsgPushServerSideSaveMemApp error:", ErrMemAppTunnelNotFound)
return ErrMemAppTunnelNotFound return ErrMemAppTunnelNotFound
} }
} }
existTunnel = i.(*P2PTunnel) existTunnel = i.(*P2PTunnel)
peerID := NodeNameToID(req.From) peerID := NodeNameToID(req.From)
existApp, appok := GNetwork.apps.Load(peerID) existApp, appok := GNetwork.apps.Load(peerID)
if appok { if appok {
app := existApp.(*p2pApp) app := existApp.(*p2pApp)
app.config.AppName = fmt.Sprintf("%d", peerID) app.config.AppName = fmt.Sprintf("%d", peerID)
app.id = req.AppID app.id = req.AppID
app.setRelayTunnelID(req.RelayTunnelID) app.setRelayTunnelID(req.RelayTunnelID)
app.relayMode = req.RelayMode app.relayMode = req.RelayMode
app.hbTimeRelay = time.Now() app.hbTimeRelay = time.Now()
if req.RelayTunnelID == 0 { if req.RelayTunnelID == 0 {
app.setDirectTunnel(existTunnel) app.setDirectTunnel(existTunnel)
} else { } else {
app.setRelayTunnel(existTunnel) app.setRelayTunnel(existTunnel)
} }
gLog.Println(LvDEBUG, "find existing memapp, update it") gLog.Println(LvDEBUG, "find existing memapp, update it")
} else { } else {
appConfig := existTunnel.config appConfig := existTunnel.config
appConfig.SrcPort = 0 appConfig.SrcPort = 0
appConfig.Protocol = "" appConfig.Protocol = ""
appConfig.AppName = fmt.Sprintf("%d", peerID) appConfig.AppName = fmt.Sprintf("%d", peerID)
appConfig.PeerNode = req.From appConfig.PeerNode = req.From
app := p2pApp{ app := p2pApp{
id: req.AppID, id: req.AppID,
config: appConfig, config: appConfig,
relayMode: req.RelayMode, relayMode: req.RelayMode,
running: true, running: true,
hbTimeRelay: time.Now(), hbTimeRelay: time.Now(),
} }
if req.RelayTunnelID == 0 { if req.RelayTunnelID == 0 {
app.setDirectTunnel(existTunnel) app.setDirectTunnel(existTunnel)
} else { } else {
app.setRelayTunnel(existTunnel) app.setRelayTunnel(existTunnel)
app.setRelayTunnelID(req.RelayTunnelID) app.setRelayTunnelID(req.RelayTunnelID)
} }
if req.RelayTunnelID != 0 { if req.RelayTunnelID != 0 {
app.relayNode = req.Node app.relayNode = req.Node
} }
GNetwork.apps.Store(NodeNameToID(req.From), &app) GNetwork.apps.Store(NodeNameToID(req.From), &app)
} }
return nil return nil
case MsgPushAPPKey: case MsgPushAPPKey:
req := APPKeySync{} req := APPKeySync{}
if err = json.Unmarshal(msg[openP2PHeaderSize+PushHeaderSize:], &req); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize+PushHeaderSize:], &req); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s", reflect.TypeOf(req), err) gLog.Printf(LvERROR, "wrong %v:%s", reflect.TypeOf(req), err)
return err return err
} }
SaveKey(req.AppID, req.AppKey) SaveKey(req.AppID, req.AppKey)
case MsgPushUpdate: case MsgPushUpdate:
gLog.Println(LvINFO, "MsgPushUpdate") gLog.Println(LvINFO, "MsgPushUpdate")
err := update(gConf.Network.ServerHost, gConf.Network.ServerPort) err := update(gConf.Network.ServerHost, gConf.Network.ServerPort)
if err == nil { if err == nil {
os.Exit(0) os.Exit(0)
} }
return err return err
case MsgPushRestart: case MsgPushRestart:
gLog.Println(LvINFO, "MsgPushRestart") gLog.Println(LvINFO, "MsgPushRestart")
os.Exit(0) os.Exit(0)
return err return err
case MsgPushReportApps: case MsgPushReportApps:
err = handleReportApps() err = handleReportApps()
case MsgPushReportMemApps: case MsgPushReportMemApps:
err = handleReportMemApps() err = handleReportMemApps()
case MsgPushReportLog: case MsgPushReportLog:
err = handleLog(msg) err = handleLog(msg)
case MsgPushReportGoroutine: case MsgPushReportGoroutine:
err = handleReportGoroutine() err = handleReportGoroutine()
case MsgPushCheckRemoteService: case MsgPushCheckRemoteService:
err = handleCheckRemoteService(msg) err = handleCheckRemoteService(msg)
case MsgPushEditApp: case MsgPushEditApp:
err = handleEditApp(msg) err = handleEditApp(msg)
case MsgPushEditNode: case MsgPushEditNode:
gLog.Println(LvINFO, "MsgPushEditNode") gLog.Println(LvINFO, "MsgPushEditNode")
req := EditNode{} req := EditNode{}
if err = json.Unmarshal(msg[openP2PHeaderSize:], &req); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize:], &req); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(req), err, string(msg[openP2PHeaderSize:])) gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(req), err, string(msg[openP2PHeaderSize:]))
return err return err
} }
gConf.setNode(req.NewName) gConf.setNode(req.NewName)
gConf.setShareBandwidth(req.Bandwidth) gConf.setShareBandwidth(req.Bandwidth)
os.Exit(0) os.Exit(0)
case MsgPushSwitchApp: case MsgPushSwitchApp:
gLog.Println(LvINFO, "MsgPushSwitchApp") gLog.Println(LvINFO, "MsgPushSwitchApp")
app := AppInfo{} app := AppInfo{}
if err = json.Unmarshal(msg[openP2PHeaderSize:], &app); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize:], &app); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(app), err, string(msg[openP2PHeaderSize:])) gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(app), err, string(msg[openP2PHeaderSize:]))
return err return err
} }
config := AppConfig{Enabled: app.Enabled, SrcPort: app.SrcPort, Protocol: app.Protocol} config := AppConfig{Enabled: app.Enabled, SrcPort: app.SrcPort, Protocol: app.Protocol}
gLog.Println(LvINFO, app.AppName, " switch to ", app.Enabled) gLog.Println(LvINFO, app.AppName, " switch to ", app.Enabled)
gConf.switchApp(config, app.Enabled) gConf.switchApp(config, app.Enabled)
if app.Enabled == 0 { if app.Enabled == 0 {
// disable APP // disable APP
GNetwork.DeleteApp(config) GNetwork.DeleteApp(config)
} }
case MsgPushDstNodeOnline: case MsgPushDstNodeOnline:
gLog.Println(LvINFO, "MsgPushDstNodeOnline") gLog.Println(LvINFO, "MsgPushDstNodeOnline")
req := PushDstNodeOnline{} req := PushDstNodeOnline{}
if err = json.Unmarshal(msg[openP2PHeaderSize:], &req); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize:], &req); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(req), err, string(msg[openP2PHeaderSize:])) gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(req), err, string(msg[openP2PHeaderSize:]))
return err return err
} }
gLog.Println(LvINFO, "retry peerNode ", req.Node) gLog.Println(LvINFO, "retry peerNode ", req.Node)
gConf.retryApp(req.Node) gConf.retryApp(req.Node)
default: default:
i, ok := GNetwork.msgMap.Load(pushHead.From) i, ok := GNetwork.msgMap.Load(pushHead.From)
if !ok { if !ok {
return ErrMsgChannelNotFound return ErrMsgChannelNotFound
} }
ch := i.(chan msgCtx) ch := i.(chan msgCtx)
ch <- msgCtx{data: msg, ts: time.Now()} ch <- msgCtx{data: msg, ts: time.Now()}
} }
return err return err
} }
func handleEditApp(msg []byte) (err error) { func handleEditApp(msg []byte) (err error) {
gLog.Println(LvINFO, "MsgPushEditApp") gLog.Println(LvINFO, "MsgPushEditApp")
newApp := AppInfo{} newApp := AppInfo{}
if err = json.Unmarshal(msg[openP2PHeaderSize:], &newApp); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize:], &newApp); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(newApp), err, string(msg[openP2PHeaderSize:])) gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(newApp), err, string(msg[openP2PHeaderSize:]))
return err return err
} }
oldConf := AppConfig{Enabled: 1} oldConf := AppConfig{Enabled: 1}
// protocol0+srcPort0 exist, delApp // protocol0+srcPort0 exist, delApp
oldConf.AppName = newApp.AppName oldConf.AppName = newApp.AppName
oldConf.Protocol = newApp.Protocol0 oldConf.Protocol = newApp.Protocol0
oldConf.Whitelist = newApp.Whitelist oldConf.Whitelist = newApp.Whitelist
oldConf.SrcPort = newApp.SrcPort0 oldConf.SrcPort = newApp.SrcPort0
oldConf.PeerNode = newApp.PeerNode oldConf.PeerNode = newApp.PeerNode
oldConf.DstHost = newApp.DstHost oldConf.DstHost = newApp.DstHost
oldConf.DstPort = newApp.DstPort oldConf.DstPort = newApp.DstPort
if newApp.Protocol0 != "" && newApp.SrcPort0 != 0 { // not edit if newApp.Protocol0 != "" && newApp.SrcPort0 != 0 { // not edit
gConf.delete(oldConf) gConf.delete(oldConf)
} }
// AddApp // AddApp
newConf := oldConf newConf := oldConf
newConf.Protocol = newApp.Protocol newConf.Protocol = newApp.Protocol
newConf.SrcPort = newApp.SrcPort newConf.SrcPort = newApp.SrcPort
newConf.RelayNode = newApp.SpecRelayNode newConf.RelayNode = newApp.SpecRelayNode
newConf.PunchPriority = newApp.PunchPriority newConf.PunchPriority = newApp.PunchPriority
gConf.add(newConf, false) gConf.add(newConf, false)
if newApp.Protocol0 != "" && newApp.SrcPort0 != 0 { // not edit if newApp.Protocol0 != "" && newApp.SrcPort0 != 0 { // not edit
GNetwork.DeleteApp(oldConf) // DeleteApp may cost some times, execute at the end GNetwork.DeleteApp(oldConf) // DeleteApp may cost some times, execute at the end
} }
return nil return nil
} }
func handleConnectReq(msg []byte) (err error) { func handleConnectReq(msg []byte) (err error) {
req := PushConnectReq{} req := PushConnectReq{}
if err = json.Unmarshal(msg[openP2PHeaderSize+PushHeaderSize:], &req); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize+PushHeaderSize:], &req); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s", reflect.TypeOf(req), err) gLog.Printf(LvERROR, "wrong %v:%s", reflect.TypeOf(req), err)
return err return err
} }
gLog.Printf(LvDEBUG, "%s is connecting...", req.From) gLog.Printf(LvDEBUG, "%s is connecting...", req.From)
gLog.Println(LvDEBUG, "push connect response to ", req.From) gLog.Println(LvDEBUG, "push connect response to ", req.From)
if compareVersion(req.Version, LeastSupportVersion) < 0 { if compareVersion(req.Version, LeastSupportVersion) < 0 {
gLog.Println(LvERROR, ErrVersionNotCompatible.Error(), ":", req.From) gLog.Println(LvERROR, ErrVersionNotCompatible.Error(), ":", req.From)
rsp := PushConnectRsp{ rsp := PushConnectRsp{
Error: 10, Error: 10,
Detail: ErrVersionNotCompatible.Error(), Detail: ErrVersionNotCompatible.Error(),
To: req.From, To: req.From,
From: gConf.Network.Node, From: gConf.Network.Node,
} }
GNetwork.push(req.From, MsgPushConnectRsp, rsp) GNetwork.push(req.From, MsgPushConnectRsp, rsp)
return ErrVersionNotCompatible return ErrVersionNotCompatible
} }
// verify totp token or token // verify totp token or token
t := totp.TOTP{Step: totp.RelayTOTPStep} t := totp.TOTP{Step: totp.RelayTOTPStep}
if t.Verify(req.Token, gConf.Network.Token, time.Now().Unix()-GNetwork.dt/int64(time.Second)) { // localTs may behind, auto adjust ts if t.Verify(req.Token, gConf.Network.Token, time.Now().Unix()-GNetwork.dt/int64(time.Second)) { // localTs may behind, auto adjust ts
gLog.Printf(LvINFO, "Access Granted") gLog.Printf(LvINFO, "Access Granted")
config := AppConfig{} config := AppConfig{}
config.peerNatType = req.NatType config.peerNatType = req.NatType
config.peerConeNatPort = req.ConeNatPort config.peerConeNatPort = req.ConeNatPort
config.peerIP = req.FromIP config.peerIP = req.FromIP
config.PeerNode = req.From config.PeerNode = req.From
config.peerVersion = req.Version config.peerVersion = req.Version
config.fromToken = req.Token config.fromToken = req.Token
config.peerIPv6 = req.IPv6 config.peerIPv6 = req.IPv6
config.hasIPv4 = req.HasIPv4 config.hasIPv4 = req.HasIPv4
config.hasUPNPorNATPMP = req.HasUPNPorNATPMP config.hasUPNPorNATPMP = req.HasUPNPorNATPMP
config.linkMode = req.LinkMode config.linkMode = req.LinkMode
config.isUnderlayServer = req.IsUnderlayServer config.isUnderlayServer = req.IsUnderlayServer
config.UnderlayProtocol = req.UnderlayProtocol config.UnderlayProtocol = req.UnderlayProtocol
// share relay node will limit bandwidth // share relay node will limit bandwidth
if req.Token != gConf.Network.Token { if req.Token != gConf.Network.Token {
gLog.Printf(LvINFO, "set share bandwidth %d mbps", gConf.Network.ShareBandwidth) gLog.Printf(LvINFO, "set share bandwidth %d mbps", gConf.Network.ShareBandwidth)
config.shareBandwidth = gConf.Network.ShareBandwidth config.shareBandwidth = gConf.Network.ShareBandwidth
} }
// go GNetwork.AddTunnel(config, req.ID) // go GNetwork.AddTunnel(config, req.ID)
go func() { go func() {
GNetwork.addDirectTunnel(config, req.ID) GNetwork.addDirectTunnel(config, req.ID)
}() }()
return nil return nil
} }
gLog.Println(LvERROR, "Access Denied:", req.From) gLog.Println(LvERROR, "Access Denied:", req.From)
rsp := PushConnectRsp{ rsp := PushConnectRsp{
Error: 1, Error: 1,
Detail: fmt.Sprintf("connect to %s error: Access Denied", gConf.Network.Node), Detail: fmt.Sprintf("connect to %s error: Access Denied", gConf.Network.Node),
To: req.From, To: req.From,
From: gConf.Network.Node, From: gConf.Network.Node,
} }
return GNetwork.push(req.From, MsgPushConnectRsp, rsp) return GNetwork.push(req.From, MsgPushConnectRsp, rsp)
} }
func handleReportApps() (err error) { func handleReportApps() (err error) {
gLog.Println(LvINFO, "MsgPushReportApps") gLog.Println(LvINFO, "MsgPushReportApps")
req := ReportApps{} req := ReportApps{}
gConf.mtx.Lock() gConf.mtx.Lock()
defer gConf.mtx.Unlock() defer gConf.mtx.Unlock()
for _, config := range gConf.Apps { for _, config := range gConf.Apps {
appActive := 0 appActive := 0
relayNode := "" relayNode := ""
specRelayNode := "" specRelayNode := ""
relayMode := "" relayMode := ""
linkMode := LinkModeUDPPunch linkMode := LinkModeUDPPunch
var connectTime string var connectTime string
var retryTime string var retryTime string
var app *p2pApp var app *p2pApp
i, ok := GNetwork.apps.Load(config.ID()) i, ok := GNetwork.apps.Load(config.ID())
if ok { if ok {
app = i.(*p2pApp) app = i.(*p2pApp)
if app.isActive() { if app.isActive() {
appActive = 1 appActive = 1
} }
if app.config.SrcPort == 0 { // memapp if app.config.SrcPort == 0 { // memapp
continue continue
} }
specRelayNode = app.config.RelayNode specRelayNode = app.config.RelayNode
if !app.isDirect() { // TODO: should always report relay node for app edit if !app.isDirect() { // TODO: should always report relay node for app edit
relayNode = app.relayNode relayNode = app.relayNode
relayMode = app.relayMode relayMode = app.relayMode
} }
if app.Tunnel() != nil { if app.Tunnel() != nil {
linkMode = app.Tunnel().linkModeWeb linkMode = app.Tunnel().linkModeWeb
} }
retryTime = app.RetryTime().Local().Format("2006-01-02T15:04:05-0700") retryTime = app.RetryTime().Local().Format("2006-01-02T15:04:05-0700")
connectTime = app.ConnectTime().Local().Format("2006-01-02T15:04:05-0700") connectTime = app.ConnectTime().Local().Format("2006-01-02T15:04:05-0700")
} }
appInfo := AppInfo{ appInfo := AppInfo{
AppName: config.AppName, AppName: config.AppName,
Error: config.errMsg, Error: config.errMsg,
Protocol: config.Protocol, Protocol: config.Protocol,
PunchPriority: config.PunchPriority, PunchPriority: config.PunchPriority,
Whitelist: config.Whitelist, Whitelist: config.Whitelist,
SrcPort: config.SrcPort, SrcPort: config.SrcPort,
RelayNode: relayNode, RelayNode: relayNode,
SpecRelayNode: specRelayNode, SpecRelayNode: specRelayNode,
RelayMode: relayMode, RelayMode: relayMode,
LinkMode: linkMode, LinkMode: linkMode,
PeerNode: config.PeerNode, PeerNode: config.PeerNode,
DstHost: config.DstHost, DstHost: config.DstHost,
DstPort: config.DstPort, DstPort: config.DstPort,
PeerUser: config.PeerUser, PeerUser: config.PeerUser,
PeerIP: config.peerIP, PeerIP: config.peerIP,
PeerNatType: config.peerNatType, PeerNatType: config.peerNatType,
RetryTime: retryTime, RetryTime: retryTime,
ConnectTime: connectTime, ConnectTime: connectTime,
IsActive: appActive, IsActive: appActive,
Enabled: config.Enabled, Enabled: config.Enabled,
} }
req.Apps = append(req.Apps, appInfo) req.Apps = append(req.Apps, appInfo)
} }
return GNetwork.write(MsgReport, MsgReportApps, &req) return GNetwork.write(MsgReport, MsgReportApps, &req)
} }
func handleReportMemApps() (err error) { func handleReportMemApps() (err error) {
gLog.Println(LvINFO, "handleReportMemApps") gLog.Println(LvINFO, "handleReportMemApps")
req := ReportApps{} req := ReportApps{}
gConf.mtx.Lock() gConf.mtx.Lock()
defer gConf.mtx.Unlock() defer gConf.mtx.Unlock()
GNetwork.sdwan.sysRoute.Range(func(key, value interface{}) bool { GNetwork.sdwan.sysRoute.Range(func(key, value interface{}) bool {
node := value.(*sdwanNode) node := value.(*sdwanNode)
appActive := 0 appActive := 0
relayMode := "" relayMode := ""
var connectTime string var connectTime string
var retryTime string var retryTime string
i, ok := GNetwork.apps.Load(node.id) i, ok := GNetwork.apps.Load(node.id)
var app *p2pApp var app *p2pApp
if ok { if ok {
app = i.(*p2pApp) app = i.(*p2pApp)
if app.isActive() { if app.isActive() {
appActive = 1 appActive = 1
} }
if !app.isDirect() { if !app.isDirect() {
relayMode = app.relayMode relayMode = app.relayMode
} }
retryTime = app.RetryTime().Local().Format("2006-01-02T15:04:05-0700") retryTime = app.RetryTime().Local().Format("2006-01-02T15:04:05-0700")
connectTime = app.ConnectTime().Local().Format("2006-01-02T15:04:05-0700") connectTime = app.ConnectTime().Local().Format("2006-01-02T15:04:05-0700")
} }
appInfo := AppInfo{ appInfo := AppInfo{
RelayMode: relayMode, RelayMode: relayMode,
PeerNode: node.name, PeerNode: node.name,
IsActive: appActive, IsActive: appActive,
Enabled: 1, Enabled: 1,
} }
if app != nil { if app != nil {
appInfo.AppName = app.config.AppName appInfo.AppName = app.config.AppName
appInfo.Error = app.config.errMsg appInfo.Error = app.config.errMsg
appInfo.Protocol = app.config.Protocol appInfo.Protocol = app.config.Protocol
appInfo.Whitelist = app.config.Whitelist appInfo.Whitelist = app.config.Whitelist
appInfo.SrcPort = app.config.SrcPort appInfo.SrcPort = app.config.SrcPort
if !app.isDirect() { if !app.isDirect() {
appInfo.RelayNode = app.relayNode appInfo.RelayNode = app.relayNode
} }
if app.Tunnel() != nil { if app.Tunnel() != nil {
appInfo.LinkMode = app.Tunnel().linkModeWeb appInfo.LinkMode = app.Tunnel().linkModeWeb
} }
appInfo.DstHost = app.config.DstHost appInfo.DstHost = app.config.DstHost
appInfo.DstPort = app.config.DstPort appInfo.DstPort = app.config.DstPort
appInfo.PeerUser = app.config.PeerUser appInfo.PeerUser = app.config.PeerUser
appInfo.PeerIP = app.config.peerIP appInfo.PeerIP = app.config.peerIP
appInfo.PeerNatType = app.config.peerNatType appInfo.PeerNatType = app.config.peerNatType
appInfo.RetryTime = retryTime appInfo.RetryTime = retryTime
appInfo.ConnectTime = connectTime appInfo.ConnectTime = connectTime
} }
req.Apps = append(req.Apps, appInfo) req.Apps = append(req.Apps, appInfo)
return true return true
}) })
gLog.Println(LvDEBUG, "handleReportMemApps res:", prettyJson(req)) gLog.Println(LvDEBUG, "handleReportMemApps res:", prettyJson(req))
return GNetwork.write(MsgReport, MsgReportMemApps, &req) return GNetwork.write(MsgReport, MsgReportMemApps, &req)
} }
func handleLog(msg []byte) (err error) { func handleLog(msg []byte) (err error) {
gLog.Println(LvDEBUG, "MsgPushReportLog") gLog.Println(LvDEBUG, "MsgPushReportLog")
const defaultLen = 1024 * 128 const defaultLen = 1024 * 128
const maxLen = 1024 * 1024 const maxLen = 1024 * 1024
req := ReportLogReq{} req := ReportLogReq{}
if err = json.Unmarshal(msg[openP2PHeaderSize:], &req); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize:], &req); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(req), err, string(msg[openP2PHeaderSize:])) gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(req), err, string(msg[openP2PHeaderSize:]))
return err return err
} }
if req.FileName == "" { if req.FileName == "" {
req.FileName = "openp2p.log" req.FileName = "openp2p.log"
} else { } else {
req.FileName = sanitizeFileName(req.FileName) req.FileName = sanitizeFileName(req.FileName)
} }
f, err := os.Open(filepath.Join("log", req.FileName)) f, err := os.Open(filepath.Join("log", req.FileName))
if err != nil { if err != nil {
gLog.Println(LvERROR, "read log file error:", err) gLog.Println(LvERROR, "read log file error:", err)
return err return err
} }
fi, err := f.Stat() fi, err := f.Stat()
if err != nil { if err != nil {
return err return err
} }
if req.Offset > fi.Size() { if req.Offset > fi.Size() {
req.Offset = fi.Size() - defaultLen req.Offset = fi.Size() - defaultLen
} }
// verify input parameters // verify input parameters
if req.Offset < 0 { if req.Offset < 0 {
req.Offset = 0 req.Offset = 0
} }
if req.Len <= 0 || req.Len > maxLen { if req.Len <= 0 || req.Len > maxLen {
req.Len = defaultLen req.Len = defaultLen
} }
f.Seek(req.Offset, 0) f.Seek(req.Offset, 0)
buff := make([]byte, req.Len) buff := make([]byte, req.Len)
readLength, err := f.Read(buff) readLength, err := f.Read(buff)
f.Close() f.Close()
if err != nil { if err != nil {
gLog.Println(LvERROR, "read log content error:", err) gLog.Println(LvERROR, "read log content error:", err)
return err return err
} }
rsp := ReportLogRsp{} rsp := ReportLogRsp{}
rsp.Content = string(buff[:readLength]) rsp.Content = string(buff[:readLength])
rsp.FileName = req.FileName rsp.FileName = req.FileName
rsp.Total = fi.Size() rsp.Total = fi.Size()
rsp.Len = req.Len rsp.Len = req.Len
return GNetwork.write(MsgReport, MsgPushReportLog, &rsp) return GNetwork.write(MsgReport, MsgPushReportLog, &rsp)
} }
func handleReportGoroutine() (err error) { func handleReportGoroutine() (err error) {
gLog.Println(LvDEBUG, "handleReportGoroutine") gLog.Println(LvDEBUG, "handleReportGoroutine")
buf := make([]byte, 1024*128) buf := make([]byte, 1024*128)
stackLen := runtime.Stack(buf, true) stackLen := runtime.Stack(buf, true)
return GNetwork.write(MsgReport, MsgPushReportLog, string(buf[:stackLen])) return GNetwork.write(MsgReport, MsgPushReportLog, string(buf[:stackLen]))
} }
func handleCheckRemoteService(msg []byte) (err error) { func handleCheckRemoteService(msg []byte) (err error) {
gLog.Println(LvDEBUG, "handleCheckRemoteService") gLog.Println(LvDEBUG, "handleCheckRemoteService")
req := CheckRemoteService{} req := CheckRemoteService{}
if err = json.Unmarshal(msg[openP2PHeaderSize:], &req); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize:], &req); err != nil {
gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(req), err, string(msg[openP2PHeaderSize:])) gLog.Printf(LvERROR, "wrong %v:%s %s", reflect.TypeOf(req), err, string(msg[openP2PHeaderSize:]))
return err return err
} }
rsp := PushRsp{Error: 0} rsp := PushRsp{Error: 0}
conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", req.Host, req.Port), time.Second*3) conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", req.Host, req.Port), time.Second*3)
if err != nil { if err != nil {
rsp.Error = 1 rsp.Error = 1
rsp.Detail = ErrRemoteServiceUnable.Error() rsp.Detail = ErrRemoteServiceUnable.Error()
} else { } else {
conn.Close() conn.Close()
} }
return GNetwork.write(MsgReport, MsgReportResponse, rsp) return GNetwork.write(MsgReport, MsgReportResponse, rsp)
} }
core/install.go
+124 -124
View File
@@ -1,124 +1,124 @@
package openp2p package openp2p
import ( import (
"fmt" "fmt"
"io" "io"
"os" "os"
"os/exec" "os/exec"
"path/filepath" "path/filepath"
"strings" "strings"
"time" "time"
) )
func install() { func install() {
gLog.Println(LvINFO, "openp2p start. version: ", OpenP2PVersion) gLog.Println(LvINFO, "openp2p start. version: ", OpenP2PVersion)
gLog.Println(LvINFO, "Contact: QQ group 16947733, Email openp2p.cn@gmail.com") gLog.Println(LvINFO, "Contact: QQ group 16947733, Email openp2p.cn@gmail.com")
gLog.Println(LvINFO, "install start") gLog.Println(LvINFO, "install start")
defer gLog.Println(LvINFO, "install end") defer gLog.Println(LvINFO, "install end")
// auto uninstall // auto uninstall
err := os.MkdirAll(defaultInstallPath, 0775) err := os.MkdirAll(defaultInstallPath, 0775)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "MkdirAll %s error:%s", defaultInstallPath, err) gLog.Printf(LvERROR, "MkdirAll %s error:%s", defaultInstallPath, err)
return return
} }
err = os.Chdir(defaultInstallPath) err = os.Chdir(defaultInstallPath)
if err != nil { if err != nil {
gLog.Println(LvERROR, "cd error:", err) gLog.Println(LvERROR, "cd error:", err)
return return
} }
uninstall() uninstall()
// save config file // save config file
parseParams("install", "") parseParams("install", "")
targetPath := filepath.Join(defaultInstallPath, defaultBinName) targetPath := filepath.Join(defaultInstallPath, defaultBinName)
d := daemon{} d := daemon{}
// copy files // copy files
binPath, _ := os.Executable() binPath, _ := os.Executable()
src, errFiles := os.Open(binPath) // can not use args[0], on Windows call openp2p is ok(=openp2p.exe) src, errFiles := os.Open(binPath) // can not use args[0], on Windows call openp2p is ok(=openp2p.exe)
if errFiles != nil { if errFiles != nil {
gLog.Printf(LvERROR, "os.OpenFile %s error:%s", os.Args[0], errFiles) gLog.Printf(LvERROR, "os.OpenFile %s error:%s", os.Args[0], errFiles)
return return
} }
dst, errFiles := os.OpenFile(targetPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0775) dst, errFiles := os.OpenFile(targetPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0775)
if errFiles != nil { if errFiles != nil {
gLog.Printf(LvERROR, "os.OpenFile %s error:%s", targetPath, errFiles) gLog.Printf(LvERROR, "os.OpenFile %s error:%s", targetPath, errFiles)
return return
} }
_, errFiles = io.Copy(dst, src) _, errFiles = io.Copy(dst, src)
if errFiles != nil { if errFiles != nil {
gLog.Printf(LvERROR, "io.Copy error:%s", errFiles) gLog.Printf(LvERROR, "io.Copy error:%s", errFiles)
return return
} }
src.Close() src.Close()
dst.Close() dst.Close()
// install system service // install system service
gLog.Println(LvINFO, "targetPath:", targetPath) gLog.Println(LvINFO, "targetPath:", targetPath)
err = d.Control("install", targetPath, []string{"-d"}) err = d.Control("install", targetPath, []string{"-d"})
if err == nil { if err == nil {
gLog.Println(LvINFO, "install system service ok.") gLog.Println(LvINFO, "install system service ok.")
} }
time.Sleep(time.Second * 2) time.Sleep(time.Second * 2)
err = d.Control("start", targetPath, []string{"-d"}) err = d.Control("start", targetPath, []string{"-d"})
if err != nil { if err != nil {
gLog.Println(LvERROR, "start openp2p service error:", err) gLog.Println(LvERROR, "start openp2p service error:", err)
} else { } else {
gLog.Println(LvINFO, "start openp2p service ok.") gLog.Println(LvINFO, "start openp2p service ok.")
} }
gLog.Println(LvINFO, "Visit WebUI on https://console.openp2p.cn") gLog.Println(LvINFO, "Visit WebUI on https://console.openp2p.cn")
} }
func installByFilename() { func installByFilename() {
params := strings.Split(filepath.Base(os.Args[0]), "-") params := strings.Split(filepath.Base(os.Args[0]), "-")
if len(params) < 4 { if len(params) < 4 {
return return
} }
serverHost := params[1] serverHost := params[1]
token := params[2] token := params[2]
gLog.Println(LvINFO, "install start") gLog.Println(LvINFO, "install start")
targetPath := os.Args[0] targetPath := os.Args[0]
args := []string{"install"} args := []string{"install"}
args = append(args, "-serverhost") args = append(args, "-serverhost")
args = append(args, serverHost) args = append(args, serverHost)
args = append(args, "-token") args = append(args, "-token")
args = append(args, token) args = append(args, token)
env := os.Environ() env := os.Environ()
cmd := exec.Command(targetPath, args...) cmd := exec.Command(targetPath, args...)
cmd.Stdout = os.Stdout cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr cmd.Stderr = os.Stderr
cmd.Stdin = os.Stdin cmd.Stdin = os.Stdin
cmd.Env = env cmd.Env = env
err := cmd.Run() err := cmd.Run()
if err != nil { if err != nil {
gLog.Println(LvERROR, "install by filename, start process error:", err) gLog.Println(LvERROR, "install by filename, start process error:", err)
return return
} }
gLog.Println(LvINFO, "install end") gLog.Println(LvINFO, "install end")
gLog.Println(LvINFO, "Visit WebUI on https://console.openp2p.cn") gLog.Println(LvINFO, "Visit WebUI on https://console.openp2p.cn")
fmt.Println("Press the Any Key to exit") fmt.Println("Press the Any Key to exit")
fmt.Scanln() fmt.Scanln()
os.Exit(0) os.Exit(0)
} }
func uninstall() { func uninstall() {
gLog.Println(LvINFO, "uninstall start") gLog.Println(LvINFO, "uninstall start")
defer gLog.Println(LvINFO, "uninstall end") defer gLog.Println(LvINFO, "uninstall end")
d := daemon{} d := daemon{}
err := d.Control("stop", "", nil) err := d.Control("stop", "", nil)
if err != nil { // service maybe not install if err != nil { // service maybe not install
return return
} }
err = d.Control("uninstall", "", nil) err = d.Control("uninstall", "", nil)
if err != nil { if err != nil {
gLog.Println(LvERROR, "uninstall system service error:", err) gLog.Println(LvERROR, "uninstall system service error:", err)
} else { } else {
gLog.Println(LvINFO, "uninstall system service ok.") gLog.Println(LvINFO, "uninstall system service ok.")
} }
binPath := filepath.Join(defaultInstallPath, defaultBinName) binPath := filepath.Join(defaultInstallPath, defaultBinName)
os.Remove(binPath + "0") os.Remove(binPath + "0")
os.Remove(binPath) os.Remove(binPath)
// os.RemoveAll(defaultInstallPath) // reserve config.json // os.RemoveAll(defaultInstallPath) // reserve config.json
} }
core/iptables.go
+74 -74
View File
@@ -1,74 +1,74 @@
package openp2p package openp2p
import ( import (
"log" "log"
"os/exec" "os/exec"
"runtime" "runtime"
) )
func allowTunForward() { func allowTunForward() {
if runtime.GOOS != "linux" { // only support Linux if runtime.GOOS != "linux" { // only support Linux
return return
} }
exec.Command("sh", "-c", `iptables -t filter -D FORWARD -i optun -j ACCEPT`).Run() exec.Command("sh", "-c", `iptables -t filter -D FORWARD -i optun -j ACCEPT`).Run()
exec.Command("sh", "-c", `iptables -t filter -D FORWARD -o optun -j ACCEPT`).Run() exec.Command("sh", "-c", `iptables -t filter -D FORWARD -o optun -j ACCEPT`).Run()
err := exec.Command("sh", "-c", `iptables -t filter -I FORWARD -i optun -j ACCEPT`).Run() err := exec.Command("sh", "-c", `iptables -t filter -I FORWARD -i optun -j ACCEPT`).Run()
if err != nil { if err != nil {
log.Println("allow foward in error:", err) log.Println("allow foward in error:", err)
} }
err = exec.Command("sh", "-c", `iptables -t filter -I FORWARD -o optun -j ACCEPT`).Run() err = exec.Command("sh", "-c", `iptables -t filter -I FORWARD -o optun -j ACCEPT`).Run()
if err != nil { if err != nil {
log.Println("allow foward out error:", err) log.Println("allow foward out error:", err)
} }
} }
func clearSNATRule() { func clearSNATRule() {
if runtime.GOOS != "linux" { if runtime.GOOS != "linux" {
return return
} }
execCommand("iptables", true, "-t", "nat", "-D", "POSTROUTING", "-j", "OPSDWAN") execCommand("iptables", true, "-t", "nat", "-D", "POSTROUTING", "-j", "OPSDWAN")
execCommand("iptables", true, "-t", "nat", "-F", "OPSDWAN") execCommand("iptables", true, "-t", "nat", "-F", "OPSDWAN")
execCommand("iptables", true, "-t", "nat", "-X", "OPSDWAN") execCommand("iptables", true, "-t", "nat", "-X", "OPSDWAN")
} }
func initSNATRule(localNet string) { func initSNATRule(localNet string) {
if runtime.GOOS != "linux" { if runtime.GOOS != "linux" {
return return
} }
clearSNATRule() clearSNATRule()
err := execCommand("iptables", true, "-t", "nat", "-N", "OPSDWAN") err := execCommand("iptables", true, "-t", "nat", "-N", "OPSDWAN")
if err != nil { if err != nil {
log.Println("iptables new sdwan chain error:", err) log.Println("iptables new sdwan chain error:", err)
return return
} }
err = execCommand("iptables", true, "-t", "nat", "-A", "POSTROUTING", "-j", "OPSDWAN") err = execCommand("iptables", true, "-t", "nat", "-A", "POSTROUTING", "-j", "OPSDWAN")
if err != nil { if err != nil {
log.Println("iptables append postrouting error:", err) log.Println("iptables append postrouting error:", err)
return return
} }
err = execCommand("iptables", true, "-t", "nat", "-A", "OPSDWAN", err = execCommand("iptables", true, "-t", "nat", "-A", "OPSDWAN",
"-o", "optun", "!", "-s", localNet, "-j", "MASQUERADE") "-o", "optun", "!", "-s", localNet, "-j", "MASQUERADE")
if err != nil { if err != nil {
log.Println("add optun snat error:", err) log.Println("add optun snat error:", err)
return return
} }
err = execCommand("iptables", true, "-t", "nat", "-A", "OPSDWAN", "!", "-o", "optun", err = execCommand("iptables", true, "-t", "nat", "-A", "OPSDWAN", "!", "-o", "optun",
"-s", localNet, "-j", "MASQUERADE") "-s", localNet, "-j", "MASQUERADE")
if err != nil { if err != nil {
log.Println("add optun snat error:", err) log.Println("add optun snat error:", err)
return return
} }
} }
func addSNATRule(target string) { func addSNATRule(target string) {
if runtime.GOOS != "linux" { if runtime.GOOS != "linux" {
return return
} }
err := execCommand("iptables", true, "-t", "nat", "-A", "OPSDWAN", "!", "-o", "optun", err := execCommand("iptables", true, "-t", "nat", "-A", "OPSDWAN", "!", "-o", "optun",
"-s", target, "-j", "MASQUERADE") "-s", target, "-j", "MASQUERADE")
if err != nil { if err != nil {
log.Println("iptables add optun snat error:", err) log.Println("iptables add optun snat error:", err)
return return
} }
} }
core/nat.go
+189 -189
View File
@@ -1,189 +1,189 @@
package openp2p package openp2p
import ( import (
"encoding/json" "encoding/json"
"fmt" "fmt"
"math/rand" "math/rand"
"net" "net"
"strconv" "strconv"
"strings" "strings"
"time" "time"
reuse "github.com/openp2p-cn/go-reuseport" reuse "github.com/openp2p-cn/go-reuseport"
) )
func natTCP(serverHost string, serverPort int) (publicIP string, publicPort int, localPort int) { func natTCP(serverHost string, serverPort int) (publicIP string, publicPort int, localPort int) {
// dialer := &net.Dialer{ // dialer := &net.Dialer{
// LocalAddr: &net.TCPAddr{ // LocalAddr: &net.TCPAddr{
// IP: net.ParseIP("0.0.0.0"), // IP: net.ParseIP("0.0.0.0"),
// Port: localPort, // Port: localPort,
// }, // },
// } // }
conn, err := reuse.DialTimeout("tcp4", fmt.Sprintf("%s:%d", "0.0.0.0", 0), fmt.Sprintf("%s:%d", serverHost, serverPort), NatTestTimeout) conn, err := reuse.DialTimeout("tcp4", fmt.Sprintf("%s:%d", "0.0.0.0", 0), fmt.Sprintf("%s:%d", serverHost, serverPort), NatTestTimeout)
// conn, err := net.Dial("tcp4", fmt.Sprintf("%s:%d", serverHost, serverPort)) // conn, err := net.Dial("tcp4", fmt.Sprintf("%s:%d", serverHost, serverPort))
// log.Println(LvINFO, conn.LocalAddr()) // log.Println(LvINFO, conn.LocalAddr())
if err != nil { if err != nil {
fmt.Printf("Dial tcp4 %s:%d error:%s", serverHost, serverPort, err) fmt.Printf("Dial tcp4 %s:%d error:%s", serverHost, serverPort, err)
return return
} }
defer conn.Close() defer conn.Close()
localPort, _ = strconv.Atoi(strings.Split(conn.LocalAddr().String(), ":")[1]) localPort, _ = strconv.Atoi(strings.Split(conn.LocalAddr().String(), ":")[1])
_, wrerr := conn.Write([]byte("1")) _, wrerr := conn.Write([]byte("1"))
if wrerr != nil { if wrerr != nil {
fmt.Printf("Write error: %s\n", wrerr) fmt.Printf("Write error: %s\n", wrerr)
return return
} }
b := make([]byte, 1000) b := make([]byte, 1000)
conn.SetReadDeadline(time.Now().Add(NatTestTimeout)) conn.SetReadDeadline(time.Now().Add(NatTestTimeout))
n, rderr := conn.Read(b) n, rderr := conn.Read(b)
if rderr != nil { if rderr != nil {
fmt.Printf("Read error: %s\n", rderr) fmt.Printf("Read error: %s\n", rderr)
return return
} }
arr := strings.Split(string(b[:n]), ":") arr := strings.Split(string(b[:n]), ":")
if len(arr) < 2 { if len(arr) < 2 {
return return
} }
publicIP = arr[0] publicIP = arr[0]
port, _ := strconv.ParseInt(arr[1], 10, 32) port, _ := strconv.ParseInt(arr[1], 10, 32)
publicPort = int(port) publicPort = int(port)
return return
} }
func natTest(serverHost string, serverPort int, localPort int) (publicIP string, publicPort int, err error) { func natTest(serverHost string, serverPort int, localPort int) (publicIP string, publicPort int, err error) {
gLog.Println(LvDEBUG, "natTest start") gLog.Println(LvDEBUG, "natTest start")
defer gLog.Println(LvDEBUG, "natTest end") defer gLog.Println(LvDEBUG, "natTest end")
conn, err := net.ListenPacket("udp", fmt.Sprintf(":%d", localPort)) conn, err := net.ListenPacket("udp", fmt.Sprintf(":%d", localPort))
if err != nil { if err != nil {
gLog.Println(LvERROR, "natTest listen udp error:", err) gLog.Println(LvERROR, "natTest listen udp error:", err)
return "", 0, err return "", 0, err
} }
defer conn.Close() defer conn.Close()
dst, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", serverHost, serverPort)) dst, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", serverHost, serverPort))
if err != nil { if err != nil {
return "", 0, err return "", 0, err
} }
// The connection can write data to the desired address. // The connection can write data to the desired address.
msg, err := newMessage(MsgNATDetect, 0, nil) msg, err := newMessage(MsgNATDetect, 0, nil)
_, err = conn.WriteTo(msg, dst) _, err = conn.WriteTo(msg, dst)
if err != nil { if err != nil {
return "", 0, err return "", 0, err
} }
deadline := time.Now().Add(NatTestTimeout) deadline := time.Now().Add(NatTestTimeout)
err = conn.SetReadDeadline(deadline) err = conn.SetReadDeadline(deadline)
if err != nil { if err != nil {
return "", 0, err return "", 0, err
} }
buffer := make([]byte, 1024) buffer := make([]byte, 1024)
nRead, _, err := conn.ReadFrom(buffer) nRead, _, err := conn.ReadFrom(buffer)
if err != nil { if err != nil {
gLog.Println(LvERROR, "NAT detect error:", err) gLog.Println(LvERROR, "NAT detect error:", err)
return "", 0, err return "", 0, err
} }
natRsp := NatDetectRsp{} natRsp := NatDetectRsp{}
json.Unmarshal(buffer[openP2PHeaderSize:nRead], &natRsp) json.Unmarshal(buffer[openP2PHeaderSize:nRead], &natRsp)
return natRsp.IP, natRsp.Port, nil return natRsp.IP, natRsp.Port, nil
} }
func getNATType(host string, udp1 int, udp2 int) (publicIP string, NATType int, err error) { func getNATType(host string, udp1 int, udp2 int) (publicIP string, NATType int, err error) {
// the random local port may be used by other. // the random local port may be used by other.
localPort := int(rand.Uint32()%15000 + 50000) localPort := int(rand.Uint32()%15000 + 50000)
ip1, port1, err := natTest(host, udp1, localPort) ip1, port1, err := natTest(host, udp1, localPort)
if err != nil { if err != nil {
return "", 0, err return "", 0, err
} }
_, port2, err := natTest(host, udp2, localPort) // 2rd nat test not need testing publicip _, port2, err := natTest(host, udp2, localPort) // 2rd nat test not need testing publicip
gLog.Printf(LvDEBUG, "local port:%d nat port:%d", localPort, port2) gLog.Printf(LvDEBUG, "local port:%d nat port:%d", localPort, port2)
if err != nil { if err != nil {
return "", 0, err return "", 0, err
} }
natType := NATSymmetric natType := NATSymmetric
if port1 == port2 { if port1 == port2 {
natType = NATCone natType = NATCone
} }
return ip1, natType, nil return ip1, natType, nil
} }
func publicIPTest(publicIP string, echoPort int) (hasPublicIP int, hasUPNPorNATPMP int) { func publicIPTest(publicIP string, echoPort int) (hasPublicIP int, hasUPNPorNATPMP int) {
if publicIP == "" || echoPort == 0 { if publicIP == "" || echoPort == 0 {
return return
} }
var echoConn *net.UDPConn var echoConn *net.UDPConn
gLog.Println(LvDEBUG, "echo server start") gLog.Println(LvDEBUG, "echo server start")
var err error var err error
echoConn, err = net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: echoPort}) echoConn, err = net.ListenUDP("udp", &net.UDPAddr{IP: net.IPv4zero, Port: echoPort})
if err != nil { // listen error if err != nil { // listen error
gLog.Println(LvERROR, "echo server listen error:", err) gLog.Println(LvERROR, "echo server listen error:", err)
return return
} }
defer echoConn.Close() defer echoConn.Close()
go func() { go func() {
// close outside for breaking the ReadFromUDP // close outside for breaking the ReadFromUDP
// wait 30s for echo testing // wait 30s for echo testing
buf := make([]byte, 1600) buf := make([]byte, 1600)
echoConn.SetReadDeadline(time.Now().Add(time.Second * 30)) echoConn.SetReadDeadline(time.Now().Add(time.Second * 30))
n, addr, err := echoConn.ReadFromUDP(buf) n, addr, err := echoConn.ReadFromUDP(buf)
if err != nil { if err != nil {
return return
} }
echoConn.WriteToUDP(buf[0:n], addr) echoConn.WriteToUDP(buf[0:n], addr)
gLog.Println(LvDEBUG, "echo server end") gLog.Println(LvDEBUG, "echo server end")
}() }()
// testing for public ip // testing for public ip
for i := 0; i < 2; i++ { for i := 0; i < 2; i++ {
if i == 1 { if i == 1 {
// test upnp or nat-pmp // test upnp or nat-pmp
gLog.Println(LvDEBUG, "upnp test start") gLog.Println(LvDEBUG, "upnp test start")
nat, err := Discover() nat, err := Discover()
if err != nil || nat == nil { if err != nil || nat == nil {
gLog.Println(LvDEBUG, "could not perform UPNP discover:", err) gLog.Println(LvDEBUG, "could not perform UPNP discover:", err)
break break
} }
ext, err := nat.GetExternalAddress() ext, err := nat.GetExternalAddress()
if err != nil { if err != nil {
gLog.Println(LvDEBUG, "could not perform UPNP external address:", err) gLog.Println(LvDEBUG, "could not perform UPNP external address:", err)
break break
} }
gLog.Println(LvINFO, "PublicIP:", ext) gLog.Println(LvINFO, "PublicIP:", ext)
externalPort, err := nat.AddPortMapping("udp", echoPort, echoPort, "openp2p", 30) // 30 seconds fot upnp testing externalPort, err := nat.AddPortMapping("udp", echoPort, echoPort, "openp2p", 30) // 30 seconds fot upnp testing
if err != nil { if err != nil {
gLog.Println(LvDEBUG, "could not add udp UPNP port mapping", externalPort) gLog.Println(LvDEBUG, "could not add udp UPNP port mapping", externalPort)
break break
} else { } else {
nat.AddPortMapping("tcp", echoPort, echoPort, "openp2p", 604800) // 7 days for tcp connection nat.AddPortMapping("tcp", echoPort, echoPort, "openp2p", 604800) // 7 days for tcp connection
} }
} }
gLog.Printf(LvDEBUG, "public ip test start %s:%d", publicIP, echoPort) gLog.Printf(LvDEBUG, "public ip test start %s:%d", publicIP, echoPort)
conn, err := net.ListenUDP("udp", nil) conn, err := net.ListenUDP("udp", nil)
if err != nil { if err != nil {
break break
} }
defer conn.Close() defer conn.Close()
dst, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", publicIP, echoPort)) dst, err := net.ResolveUDPAddr("udp", fmt.Sprintf("%s:%d", publicIP, echoPort))
if err != nil { if err != nil {
break break
} }
conn.WriteTo([]byte("echo"), dst) conn.WriteTo([]byte("echo"), dst)
buf := make([]byte, 1600) buf := make([]byte, 1600)
// wait for echo testing // wait for echo testing
conn.SetReadDeadline(time.Now().Add(PublicIPEchoTimeout)) conn.SetReadDeadline(time.Now().Add(PublicIPEchoTimeout))
_, _, err = conn.ReadFromUDP(buf) _, _, err = conn.ReadFromUDP(buf)
if err == nil { if err == nil {
if i == 1 { if i == 1 {
gLog.Println(LvDEBUG, "UPNP or NAT-PMP:YES") gLog.Println(LvDEBUG, "UPNP or NAT-PMP:YES")
hasUPNPorNATPMP = 1 hasUPNPorNATPMP = 1
} else { } else {
gLog.Println(LvDEBUG, "public ip:YES") gLog.Println(LvDEBUG, "public ip:YES")
hasPublicIP = 1 hasPublicIP = 1
} }
break break
} }
} }
return return
} }
core/openp2p.go
+121 -121
View File
@@ -1,121 +1,121 @@
package openp2p package openp2p
import ( import (
"fmt" "fmt"
"math/rand" "math/rand"
"os" "os"
"path/filepath" "path/filepath"
"strconv" "strconv"
"time" "time"
) )
var GNetwork *P2PNetwork var GNetwork *P2PNetwork
func Run() { func Run() {
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
baseDir := filepath.Dir(os.Args[0]) baseDir := filepath.Dir(os.Args[0])
os.Chdir(baseDir) // for system service os.Chdir(baseDir) // for system service
gLog = NewLogger(baseDir, ProductName, LvDEBUG, 1024*1024, LogFile|LogConsole) gLog = NewLogger(baseDir, ProductName, LvDEBUG, 1024*1024, LogFile|LogConsole)
if len(os.Args) > 1 { if len(os.Args) > 1 {
switch os.Args[1] { switch os.Args[1] {
case "version", "-v", "--version": case "version", "-v", "--version":
fmt.Println(OpenP2PVersion) fmt.Println(OpenP2PVersion)
return return
case "install": case "install":
install() install()
return return
case "uninstall": case "uninstall":
uninstall() uninstall()
return return
} }
} else { } else {
installByFilename() installByFilename()
} }
parseParams("", "") parseParams("", "")
gLog.Println(LvINFO, "openp2p start. version: ", OpenP2PVersion) gLog.Println(LvINFO, "openp2p start. version: ", OpenP2PVersion)
gLog.Println(LvINFO, "Contact: QQ group 16947733, Email openp2p.cn@gmail.com") gLog.Println(LvINFO, "Contact: QQ group 16947733, Email openp2p.cn@gmail.com")
if gConf.daemonMode { if gConf.daemonMode {
d := daemon{} d := daemon{}
d.run() d.run()
return return
} }
gLog.Println(LvINFO, &gConf) gLog.Println(LvINFO, &gConf)
setFirewall() setFirewall()
err := setRLimit() err := setRLimit()
if err != nil { if err != nil {
gLog.Println(LvINFO, "setRLimit error:", err) gLog.Println(LvINFO, "setRLimit error:", err)
} }
GNetwork = P2PNetworkInstance() GNetwork = P2PNetworkInstance()
if ok := GNetwork.Connect(30000); !ok { if ok := GNetwork.Connect(30000); !ok {
gLog.Println(LvERROR, "P2PNetwork login error") gLog.Println(LvERROR, "P2PNetwork login error")
return return
} }
// gLog.Println(LvINFO, "waiting for connection...") // gLog.Println(LvINFO, "waiting for connection...")
forever := make(chan bool) forever := make(chan bool)
<-forever <-forever
} }
// for Android app // for Android app
// gomobile not support uint64 exported to java // gomobile not support uint64 exported to java
func RunAsModule(baseDir string, token string, bw int, logLevel int) *P2PNetwork { func RunAsModule(baseDir string, token string, bw int, logLevel int) *P2PNetwork {
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
os.Chdir(baseDir) // for system service os.Chdir(baseDir) // for system service
gLog = NewLogger(baseDir, ProductName, LvINFO, 1024*1024, LogFile|LogConsole) gLog = NewLogger(baseDir, ProductName, LvINFO, 1024*1024, LogFile|LogConsole)
parseParams("", "") parseParams("", "")
n, err := strconv.ParseUint(token, 10, 64) n, err := strconv.ParseUint(token, 10, 64)
if err == nil && n > 0 { if err == nil && n > 0 {
gConf.setToken(n) gConf.setToken(n)
} }
if n <= 0 && gConf.Network.Token == 0 { // not input token if n <= 0 && gConf.Network.Token == 0 { // not input token
return nil return nil
} }
// gLog.setLevel(LogLevel(logLevel)) // gLog.setLevel(LogLevel(logLevel))
gConf.setShareBandwidth(bw) gConf.setShareBandwidth(bw)
gLog.Println(LvINFO, "openp2p start. version: ", OpenP2PVersion) gLog.Println(LvINFO, "openp2p start. version: ", OpenP2PVersion)
gLog.Println(LvINFO, "Contact: QQ group 16947733, Email openp2p.cn@gmail.com") gLog.Println(LvINFO, "Contact: QQ group 16947733, Email openp2p.cn@gmail.com")
gLog.Println(LvINFO, &gConf) gLog.Println(LvINFO, &gConf)
GNetwork = P2PNetworkInstance() GNetwork = P2PNetworkInstance()
if ok := GNetwork.Connect(30000); !ok { if ok := GNetwork.Connect(30000); !ok {
gLog.Println(LvERROR, "P2PNetwork login error") gLog.Println(LvERROR, "P2PNetwork login error")
return nil return nil
} }
// gLog.Println(LvINFO, "waiting for connection...") // gLog.Println(LvINFO, "waiting for connection...")
return GNetwork return GNetwork
} }
func RunCmd(cmd string) { func RunCmd(cmd string) {
rand.Seed(time.Now().UnixNano()) rand.Seed(time.Now().UnixNano())
baseDir := filepath.Dir(os.Args[0]) baseDir := filepath.Dir(os.Args[0])
os.Chdir(baseDir) // for system service os.Chdir(baseDir) // for system service
gLog = NewLogger(baseDir, ProductName, LvINFO, 1024*1024, LogFile|LogConsole) gLog = NewLogger(baseDir, ProductName, LvINFO, 1024*1024, LogFile|LogConsole)
parseParams("", cmd) parseParams("", cmd)
setFirewall() setFirewall()
err := setRLimit() err := setRLimit()
if err != nil { if err != nil {
gLog.Println(LvINFO, "setRLimit error:", err) gLog.Println(LvINFO, "setRLimit error:", err)
} }
GNetwork = P2PNetworkInstance() GNetwork = P2PNetworkInstance()
if ok := GNetwork.Connect(30000); !ok { if ok := GNetwork.Connect(30000); !ok {
gLog.Println(LvERROR, "P2PNetwork login error") gLog.Println(LvERROR, "P2PNetwork login error")
return return
} }
forever := make(chan bool) forever := make(chan bool)
<-forever <-forever
} }
func GetToken(baseDir string) string { func GetToken(baseDir string) string {
os.Chdir(baseDir) os.Chdir(baseDir)
gConf.load() gConf.load()
return fmt.Sprintf("%d", gConf.Network.Token) return fmt.Sprintf("%d", gConf.Network.Token)
} }
func Stop() { func Stop() {
os.Exit(0) os.Exit(0)
} }
core/optun.go
+20 -20
View File
@@ -1,20 +1,20 @@
package openp2p package openp2p
import ( import (
"github.com/openp2p-cn/wireguard-go/tun" "github.com/openp2p-cn/wireguard-go/tun"
) )
var AndroidSDWANConfig chan []byte var AndroidSDWANConfig chan []byte
type optun struct { type optun struct {
tunName string tunName string
dev tun.Device dev tun.Device
} }
func (t *optun) Stop() error { func (t *optun) Stop() error {
t.dev.Close() t.dev.Close()
return nil return nil
} }
func init() { func init() {
AndroidSDWANConfig = make(chan []byte, 1) AndroidSDWANConfig = make(chan []byte, 1)
} }
core/optun_android.go
+85 -85
View File
@@ -1,85 +1,85 @@
// optun_android.go // optun_android.go
//go:build android //go:build android
// +build android // +build android
package openp2p package openp2p
import ( import (
"net" "net"
) )
const ( const (
tunIfaceName = "optun" tunIfaceName = "optun"
PIHeaderSize = 0 PIHeaderSize = 0
) )
var AndroidReadTun chan []byte // TODO: multi channel var AndroidReadTun chan []byte // TODO: multi channel
var AndroidWriteTun chan []byte var AndroidWriteTun chan []byte
func (t *optun) Start(localAddr string, detail *SDWANInfo) error { func (t *optun) Start(localAddr string, detail *SDWANInfo) error {
return nil return nil
} }
func (t *optun) Read(bufs [][]byte, sizes []int, offset int) (n int, err error) { func (t *optun) Read(bufs [][]byte, sizes []int, offset int) (n int, err error) {
bufs[0] = <-AndroidReadTun bufs[0] = <-AndroidReadTun
sizes[0] = len(bufs[0]) sizes[0] = len(bufs[0])
return 1, nil return 1, nil
} }
func (t *optun) Write(bufs [][]byte, offset int) (int, error) { func (t *optun) Write(bufs [][]byte, offset int) (int, error) {
AndroidWriteTun <- bufs[0] AndroidWriteTun <- bufs[0]
return len(bufs[0]), nil return len(bufs[0]), nil
} }
func AndroidRead(data []byte, len int) { func AndroidRead(data []byte, len int) {
head := PacketHeader{} head := PacketHeader{}
parseHeader(data, &head) parseHeader(data, &head)
gLog.Printf(LvDev, "AndroidRead tun dst ip=%s,len=%d", net.IP{byte(head.dst >> 24), byte(head.dst >> 16), byte(head.dst >> 8), byte(head.dst)}.String(), len) gLog.Printf(LvDev, "AndroidRead tun dst ip=%s,len=%d", net.IP{byte(head.dst >> 24), byte(head.dst >> 16), byte(head.dst >> 8), byte(head.dst)}.String(), len)
buf := make([]byte, len) buf := make([]byte, len)
copy(buf, data) copy(buf, data)
AndroidReadTun <- buf AndroidReadTun <- buf
} }
func AndroidWrite(buf []byte) int { func AndroidWrite(buf []byte) int {
p := <-AndroidWriteTun p := <-AndroidWriteTun
copy(buf, p) copy(buf, p)
return len(p) return len(p)
} }
func GetAndroidSDWANConfig(buf []byte) int { func GetAndroidSDWANConfig(buf []byte) int {
p := <-AndroidSDWANConfig p := <-AndroidSDWANConfig
copy(buf, p) copy(buf, p)
gLog.Printf(LvINFO, "AndroidSDWANConfig=%s", p) gLog.Printf(LvINFO, "AndroidSDWANConfig=%s", p)
return len(p) return len(p)
} }
func GetAndroidNodeName() string { func GetAndroidNodeName() string {
gLog.Printf(LvINFO, "GetAndroidNodeName=%s", gConf.Network.Node) gLog.Printf(LvINFO, "GetAndroidNodeName=%s", gConf.Network.Node)
return gConf.Network.Node return gConf.Network.Node
} }
func setTunAddr(ifname, localAddr, remoteAddr string, wintun interface{}) error { func setTunAddr(ifname, localAddr, remoteAddr string, wintun interface{}) error {
// TODO: // TODO:
return nil return nil
} }
func addRoute(dst, gw, ifname string) error { func addRoute(dst, gw, ifname string) error {
// TODO: // TODO:
return nil return nil
} }
func delRoute(dst, gw string) error { func delRoute(dst, gw string) error {
// TODO: // TODO:
return nil return nil
} }
func delRoutesByGateway(gateway string) error { func delRoutesByGateway(gateway string) error {
// TODO: // TODO:
return nil return nil
} }
func init() { func init() {
AndroidReadTun = make(chan []byte, 1000) AndroidReadTun = make(chan []byte, 1000)
AndroidWriteTun = make(chan []byte, 1000) AndroidWriteTun = make(chan []byte, 1000)
} }
core/optun_linux.go
+133 -133
View File
@@ -1,133 +1,133 @@
//go:build !android //go:build !android
// +build !android // +build !android
// optun_linux.go // optun_linux.go
package openp2p package openp2p
import ( import (
"fmt" "fmt"
"net" "net"
"os/exec" "os/exec"
"strings" "strings"
"github.com/openp2p-cn/wireguard-go/tun" "github.com/openp2p-cn/wireguard-go/tun"
"github.com/vishvananda/netlink" "github.com/vishvananda/netlink"
) )
const ( const (
tunIfaceName = "optun" tunIfaceName = "optun"
PIHeaderSize = 0 PIHeaderSize = 0
) )
var previousIP = "" var previousIP = ""
func (t *optun) Start(localAddr string, detail *SDWANInfo) error { func (t *optun) Start(localAddr string, detail *SDWANInfo) error {
var err error var err error
t.tunName = tunIfaceName t.tunName = tunIfaceName
t.dev, err = tun.CreateTUN(t.tunName, 1420) t.dev, err = tun.CreateTUN(t.tunName, 1420)
if err != nil { if err != nil {
return err return err
} }
return nil return nil
} }
func (t *optun) Read(bufs [][]byte, sizes []int, offset int) (n int, err error) { func (t *optun) Read(bufs [][]byte, sizes []int, offset int) (n int, err error) {
return t.dev.Read(bufs, sizes, offset) return t.dev.Read(bufs, sizes, offset)
} }
func (t *optun) Write(bufs [][]byte, offset int) (int, error) { func (t *optun) Write(bufs [][]byte, offset int) (int, error) {
return t.dev.Write(bufs, offset) return t.dev.Write(bufs, offset)
} }
func setTunAddr(ifname, localAddr, remoteAddr string, wintun interface{}) error { func setTunAddr(ifname, localAddr, remoteAddr string, wintun interface{}) error {
ifce, err := netlink.LinkByName(ifname) ifce, err := netlink.LinkByName(ifname)
if err != nil { if err != nil {
return err return err
} }
netlink.LinkSetMTU(ifce, 1375) netlink.LinkSetMTU(ifce, 1375)
netlink.LinkSetTxQLen(ifce, 100) netlink.LinkSetTxQLen(ifce, 100)
netlink.LinkSetUp(ifce) netlink.LinkSetUp(ifce)
ln, err := netlink.ParseIPNet(localAddr) ln, err := netlink.ParseIPNet(localAddr)
if err != nil { if err != nil {
return err return err
} }
ln.Mask = net.CIDRMask(32, 32) ln.Mask = net.CIDRMask(32, 32)
rn, err := netlink.ParseIPNet(remoteAddr) rn, err := netlink.ParseIPNet(remoteAddr)
if err != nil { if err != nil {
return err return err
} }
rn.Mask = net.CIDRMask(32, 32) rn.Mask = net.CIDRMask(32, 32)
addr := &netlink.Addr{ addr := &netlink.Addr{
IPNet: ln, IPNet: ln,
Peer: rn, Peer: rn,
} }
if previousIP != "" { if previousIP != "" {
lnDel, err := netlink.ParseIPNet(previousIP) lnDel, err := netlink.ParseIPNet(previousIP)
if err != nil { if err != nil {
return err return err
} }
lnDel.Mask = net.CIDRMask(32, 32) lnDel.Mask = net.CIDRMask(32, 32)
addrDel := &netlink.Addr{ addrDel := &netlink.Addr{
IPNet: lnDel, IPNet: lnDel,
Peer: rn, Peer: rn,
} }
netlink.AddrDel(ifce, addrDel) netlink.AddrDel(ifce, addrDel)
} }
previousIP = localAddr previousIP = localAddr
return netlink.AddrAdd(ifce, addr) return netlink.AddrAdd(ifce, addr)
} }
func addRoute(dst, gw, ifname string) error { func addRoute(dst, gw, ifname string) error {
_, networkid, err := net.ParseCIDR(dst) _, networkid, err := net.ParseCIDR(dst)
if err != nil { if err != nil {
return err return err
} }
ipGW := net.ParseIP(gw) ipGW := net.ParseIP(gw)
if ipGW == nil { if ipGW == nil {
return fmt.Errorf("parse gateway %s failed", gw) return fmt.Errorf("parse gateway %s failed", gw)
} }
route := &netlink.Route{ route := &netlink.Route{
Dst: networkid, Dst: networkid,
Gw: ipGW, Gw: ipGW,
} }
return netlink.RouteAdd(route) return netlink.RouteAdd(route)
} }
func delRoute(dst, gw string) error { func delRoute(dst, gw string) error {
_, networkid, err := net.ParseCIDR(dst) _, networkid, err := net.ParseCIDR(dst)
if err != nil { if err != nil {
return err return err
} }
route := &netlink.Route{ route := &netlink.Route{
Dst: networkid, Dst: networkid,
} }
return netlink.RouteDel(route) return netlink.RouteDel(route)
} }
func delRoutesByGateway(gateway string) error { func delRoutesByGateway(gateway string) error {
cmd := exec.Command("route", "-n") cmd := exec.Command("route", "-n")
output, err := cmd.Output() output, err := cmd.Output()
if err != nil { if err != nil {
return err return err
} }
lines := strings.Split(string(output), "\n") lines := strings.Split(string(output), "\n")
for _, line := range lines { for _, line := range lines {
if !strings.Contains(line, gateway) { if !strings.Contains(line, gateway) {
continue continue
} }
fields := strings.Fields(line) fields := strings.Fields(line)
if len(fields) >= 8 && fields[1] == "0.0.0.0" && fields[7] == gateway { if len(fields) >= 8 && fields[1] == "0.0.0.0" && fields[7] == gateway {
delCmd := exec.Command("route", "del", "-net", fields[0], "gw", gateway) delCmd := exec.Command("route", "del", "-net", fields[0], "gw", gateway)
err := delCmd.Run() err := delCmd.Run()
if err != nil { if err != nil {
return err return err
} }
fmt.Printf("Delete route ok: %s %s %s\n", fields[0], fields[1], gateway) fmt.Printf("Delete route ok: %s %s %s\n", fields[0], fields[1], gateway)
} }
} }
return nil return nil
} }
core/optun_windows.go
+142 -142
View File
@@ -1,142 +1,142 @@
package openp2p package openp2p
import ( import (
"fmt" "fmt"
"net" "net"
"net/netip" "net/netip"
"os" "os"
"os/exec" "os/exec"
"path/filepath" "path/filepath"
"runtime" "runtime"
"strconv" "strconv"
"strings" "strings"
"github.com/openp2p-cn/wireguard-go/tun" "github.com/openp2p-cn/wireguard-go/tun"
"golang.org/x/sys/windows" "golang.org/x/sys/windows"
"golang.zx2c4.com/wireguard/windows/tunnel/winipcfg" "golang.zx2c4.com/wireguard/windows/tunnel/winipcfg"
) )
const ( const (
tunIfaceName = "optun" tunIfaceName = "optun"
PIHeaderSize = 0 PIHeaderSize = 0
) )
func (t *optun) Start(localAddr string, detail *SDWANInfo) error { func (t *optun) Start(localAddr string, detail *SDWANInfo) error {
// check wintun.dll // check wintun.dll
tmpFile := filepath.Dir(os.Args[0]) + "/wintun.dll" tmpFile := filepath.Dir(os.Args[0]) + "/wintun.dll"
fs, err := os.Stat(tmpFile) fs, err := os.Stat(tmpFile)
if err != nil || fs.Size() == 0 { if err != nil || fs.Size() == 0 {
url := fmt.Sprintf("https://openp2p.cn/download/v1/latest/wintun/%s/wintun.dll", runtime.GOARCH) url := fmt.Sprintf("https://openp2p.cn/download/v1/latest/wintun/%s/wintun.dll", runtime.GOARCH)
err = downloadFile(url, "", tmpFile) err = downloadFile(url, "", tmpFile)
if err != nil { if err != nil {
os.Remove(tmpFile) os.Remove(tmpFile)
return err return err
} }
} }
t.tunName = tunIfaceName t.tunName = tunIfaceName
uuid := &windows.GUID{ uuid := &windows.GUID{
Data1: 0xf411e821, Data1: 0xf411e821,
Data2: 0xb310, Data2: 0xb310,
Data3: 0x4567, Data3: 0x4567,
Data4: [8]byte{0x80, 0x42, 0x83, 0x7e, 0xf4, 0x56, 0xce, 0x13}, Data4: [8]byte{0x80, 0x42, 0x83, 0x7e, 0xf4, 0x56, 0xce, 0x13},
} }
t.dev, err = tun.CreateTUNWithRequestedGUID(t.tunName, uuid, 1420) t.dev, err = tun.CreateTUNWithRequestedGUID(t.tunName, uuid, 1420)
if err != nil { // retry if err != nil { // retry
t.dev, err = tun.CreateTUNWithRequestedGUID(t.tunName, uuid, 1420) t.dev, err = tun.CreateTUNWithRequestedGUID(t.tunName, uuid, 1420)
} }
if err != nil { if err != nil {
return err return err
} }
return nil return nil
} }
func (t *optun) Read(bufs [][]byte, sizes []int, offset int) (n int, err error) { func (t *optun) Read(bufs [][]byte, sizes []int, offset int) (n int, err error) {
return t.dev.Read(bufs, sizes, offset) return t.dev.Read(bufs, sizes, offset)
} }
func (t *optun) Write(bufs [][]byte, offset int) (int, error) { func (t *optun) Write(bufs [][]byte, offset int) (int, error) {
return t.dev.Write(bufs, offset) return t.dev.Write(bufs, offset)
} }
func setTunAddr(ifname, localAddr, remoteAddr string, wintun interface{}) error { func setTunAddr(ifname, localAddr, remoteAddr string, wintun interface{}) error {
nativeTunDevice := wintun.(*tun.NativeTun) nativeTunDevice := wintun.(*tun.NativeTun)
link := winipcfg.LUID(nativeTunDevice.LUID()) link := winipcfg.LUID(nativeTunDevice.LUID())
ip, err := netip.ParsePrefix(localAddr) ip, err := netip.ParsePrefix(localAddr)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "ParsePrefix error:%s, luid:%d,localAddr:%s", err, nativeTunDevice.LUID(), localAddr) gLog.Printf(LvERROR, "ParsePrefix error:%s, luid:%d,localAddr:%s", err, nativeTunDevice.LUID(), localAddr)
return err return err
} }
err = link.SetIPAddresses([]netip.Prefix{ip}) err = link.SetIPAddresses([]netip.Prefix{ip})
if err != nil { if err != nil {
gLog.Printf(LvERROR, "SetIPAddresses error:%s, netip.Prefix:%+v", err, []netip.Prefix{ip}) gLog.Printf(LvERROR, "SetIPAddresses error:%s, netip.Prefix:%+v", err, []netip.Prefix{ip})
return err return err
} }
return nil return nil
} }
func addRoute(dst, gw, ifname string) error { func addRoute(dst, gw, ifname string) error {
_, dstNet, err := net.ParseCIDR(dst) _, dstNet, err := net.ParseCIDR(dst)
if err != nil { if err != nil {
return err return err
} }
i, err := net.InterfaceByName(ifname) i, err := net.InterfaceByName(ifname)
if err != nil { if err != nil {
return err return err
} }
params := make([]string, 0) params := make([]string, 0)
params = append(params, "add") params = append(params, "add")
params = append(params, dstNet.IP.String()) params = append(params, dstNet.IP.String())
params = append(params, "mask") params = append(params, "mask")
params = append(params, net.IP(dstNet.Mask).String()) params = append(params, net.IP(dstNet.Mask).String())
params = append(params, gw) params = append(params, gw)
params = append(params, "if") params = append(params, "if")
params = append(params, strconv.Itoa(i.Index)) params = append(params, strconv.Itoa(i.Index))
// gLogger.Println(LevelINFO, "windows add route params:", params) // gLogger.Println(LevelINFO, "windows add route params:", params)
execCommand("route", true, params...) execCommand("route", true, params...)
return nil return nil
} }
func delRoute(dst, gw string) error { func delRoute(dst, gw string) error {
_, dstNet, err := net.ParseCIDR(dst) _, dstNet, err := net.ParseCIDR(dst)
if err != nil { if err != nil {
return err return err
} }
params := make([]string, 0) params := make([]string, 0)
params = append(params, "delete") params = append(params, "delete")
params = append(params, dstNet.IP.String()) params = append(params, dstNet.IP.String())
params = append(params, "mask") params = append(params, "mask")
params = append(params, net.IP(dstNet.Mask).String()) params = append(params, net.IP(dstNet.Mask).String())
params = append(params, gw) params = append(params, gw)
// gLogger.Println(LevelINFO, "windows delete route params:", params) // gLogger.Println(LevelINFO, "windows delete route params:", params)
execCommand("route", true, params...) execCommand("route", true, params...)
return nil return nil
} }
func delRoutesByGateway(gateway string) error { func delRoutesByGateway(gateway string) error {
cmd := exec.Command("route", "print", "-4") cmd := exec.Command("route", "print", "-4")
output, err := cmd.Output() output, err := cmd.Output()
if err != nil { if err != nil {
return err return err
} }
lines := strings.Split(string(output), "\n") lines := strings.Split(string(output), "\n")
for _, line := range lines { for _, line := range lines {
if !strings.Contains(line, gateway) { if !strings.Contains(line, gateway) {
continue continue
} }
fields := strings.Fields(line) fields := strings.Fields(line)
if len(fields) >= 5 { if len(fields) >= 5 {
cmd := exec.Command("route", "delete", fields[0], "mask", fields[1], gateway) cmd := exec.Command("route", "delete", fields[0], "mask", fields[1], gateway)
err := cmd.Run() err := cmd.Run()
if err != nil { if err != nil {
fmt.Println("Delete route error:", err) fmt.Println("Delete route error:", err)
} }
fmt.Printf("Delete route ok: %s %s %s\n", fields[0], fields[1], gateway) fmt.Printf("Delete route ok: %s %s %s\n", fields[0], fields[1], gateway)
} }
} }
return nil return nil
} }
core/p2pnetwork.go
+976 -976
View File
File diff suppressed because it is too large Load Diff
core/p2ptunnel.go
+806 -806
View File
File diff suppressed because it is too large Load Diff
core/sdwan.go
+292 -292
View File
@@ -1,292 +1,292 @@
package openp2p package openp2p
import ( import (
"encoding/binary" "encoding/binary"
"encoding/json" "encoding/json"
"fmt" "fmt"
"net" "net"
"runtime" "runtime"
"strings" "strings"
"sync" "sync"
"time" "time"
) )
type PacketHeader struct { type PacketHeader struct {
version int version int
// src uint32 // src uint32
// prot uint8 // prot uint8
protocol byte protocol byte
dst uint32 dst uint32
port uint16 port uint16
} }
func parseHeader(b []byte, h *PacketHeader) error { func parseHeader(b []byte, h *PacketHeader) error {
if len(b) < 20 { if len(b) < 20 {
return fmt.Errorf("small packet") return fmt.Errorf("small packet")
} }
h.version = int(b[0] >> 4) h.version = int(b[0] >> 4)
h.protocol = byte(b[9]) h.protocol = byte(b[9])
if h.version == 4 { if h.version == 4 {
h.dst = binary.BigEndian.Uint32(b[16:20]) h.dst = binary.BigEndian.Uint32(b[16:20])
} else if h.version != 6 { } else if h.version != 6 {
return fmt.Errorf("unknown version in ip header:%d", h.version) return fmt.Errorf("unknown version in ip header:%d", h.version)
} }
if h.protocol == 6 || h.protocol == 17 { // TCP or UDP if h.protocol == 6 || h.protocol == 17 { // TCP or UDP
h.port = binary.BigEndian.Uint16(b[22:24]) h.port = binary.BigEndian.Uint16(b[22:24])
} }
return nil return nil
} }
type sdwanNode struct { type sdwanNode struct {
name string name string
id uint64 id uint64
} }
type p2pSDWAN struct { type p2pSDWAN struct {
nodeName string nodeName string
tun *optun tun *optun
sysRoute sync.Map // ip:sdwanNode sysRoute sync.Map // ip:sdwanNode
subnet *net.IPNet subnet *net.IPNet
gateway net.IP gateway net.IP
virtualIP *net.IPNet virtualIP *net.IPNet
internalRoute *IPTree internalRoute *IPTree
} }
func (s *p2pSDWAN) init(name string) error { func (s *p2pSDWAN) init(name string) error {
if gConf.getSDWAN().Gateway == "" { if gConf.getSDWAN().Gateway == "" {
gLog.Println(LvDEBUG, "not in sdwan clear all ") gLog.Println(LvDEBUG, "not in sdwan clear all ")
} }
if s.internalRoute == nil { if s.internalRoute == nil {
s.internalRoute = NewIPTree("") s.internalRoute = NewIPTree("")
} }
s.nodeName = name s.nodeName = name
s.gateway, s.subnet, _ = net.ParseCIDR(gConf.getSDWAN().Gateway) s.gateway, s.subnet, _ = net.ParseCIDR(gConf.getSDWAN().Gateway)
for _, node := range gConf.getDelNodes() { for _, node := range gConf.getDelNodes() {
gLog.Println(LvDEBUG, "deal deleted node: ", node.Name) gLog.Println(LvDEBUG, "deal deleted node: ", node.Name)
delRoute(node.IP, s.gateway.String()) delRoute(node.IP, s.gateway.String())
s.internalRoute.Del(node.IP, node.IP) s.internalRoute.Del(node.IP, node.IP)
ipNum, _ := inetAtoN(node.IP) ipNum, _ := inetAtoN(node.IP)
s.sysRoute.Delete(ipNum) s.sysRoute.Delete(ipNum)
gConf.delete(AppConfig{SrcPort: 0, PeerNode: node.Name}) gConf.delete(AppConfig{SrcPort: 0, PeerNode: node.Name})
GNetwork.DeleteApp(AppConfig{SrcPort: 0, PeerNode: node.Name}) GNetwork.DeleteApp(AppConfig{SrcPort: 0, PeerNode: node.Name})
arr := strings.Split(node.Resource, ",") arr := strings.Split(node.Resource, ",")
for _, r := range arr { for _, r := range arr {
_, ipnet, err := net.ParseCIDR(r) _, ipnet, err := net.ParseCIDR(r)
if err != nil { if err != nil {
// fmt.Println("Error parsing CIDR:", err) // fmt.Println("Error parsing CIDR:", err)
continue continue
} }
if ipnet.Contains(net.ParseIP(gConf.Network.localIP)) { // local ip and resource in the same lan if ipnet.Contains(net.ParseIP(gConf.Network.localIP)) { // local ip and resource in the same lan
continue continue
} }
minIP := ipnet.IP minIP := ipnet.IP
maxIP := make(net.IP, len(minIP)) maxIP := make(net.IP, len(minIP))
copy(maxIP, minIP) copy(maxIP, minIP)
for i := range minIP { for i := range minIP {
maxIP[i] = minIP[i] | ^ipnet.Mask[i] maxIP[i] = minIP[i] | ^ipnet.Mask[i]
} }
s.internalRoute.Del(minIP.String(), maxIP.String()) s.internalRoute.Del(minIP.String(), maxIP.String())
delRoute(ipnet.String(), s.gateway.String()) delRoute(ipnet.String(), s.gateway.String())
} }
} }
for _, node := range gConf.getAddNodes() { for _, node := range gConf.getAddNodes() {
gLog.Println(LvDEBUG, "deal add node: ", node.Name) gLog.Println(LvDEBUG, "deal add node: ", node.Name)
ipNet := &net.IPNet{ ipNet := &net.IPNet{
IP: net.ParseIP(node.IP), IP: net.ParseIP(node.IP),
Mask: s.subnet.Mask, Mask: s.subnet.Mask,
} }
if node.Name == s.nodeName { if node.Name == s.nodeName {
s.virtualIP = ipNet s.virtualIP = ipNet
gLog.Println(LvINFO, "start tun ", ipNet.String()) gLog.Println(LvINFO, "start tun ", ipNet.String())
err := s.StartTun() err := s.StartTun()
if err != nil { if err != nil {
gLog.Println(LvERROR, "start tun error:", err) gLog.Println(LvERROR, "start tun error:", err)
return err return err
} }
gLog.Println(LvINFO, "start tun ok") gLog.Println(LvINFO, "start tun ok")
allowTunForward() allowTunForward()
addRoute(s.subnet.String(), s.gateway.String(), s.tun.tunName) addRoute(s.subnet.String(), s.gateway.String(), s.tun.tunName)
// addRoute("255.255.255.255/32", s.gateway.String(), s.tun.tunName) // for broadcast // addRoute("255.255.255.255/32", s.gateway.String(), s.tun.tunName) // for broadcast
// addRoute("224.0.0.0/4", s.gateway.String(), s.tun.tunName) // for multicast // addRoute("224.0.0.0/4", s.gateway.String(), s.tun.tunName) // for multicast
initSNATRule(s.subnet.String()) // for network resource initSNATRule(s.subnet.String()) // for network resource
continue continue
} }
ip, err := inetAtoN(ipNet.String()) ip, err := inetAtoN(ipNet.String())
if err != nil { if err != nil {
return err return err
} }
s.sysRoute.Store(ip, &sdwanNode{name: node.Name, id: NodeNameToID(node.Name)}) s.sysRoute.Store(ip, &sdwanNode{name: node.Name, id: NodeNameToID(node.Name)})
s.internalRoute.AddIntIP(ip, ip, &sdwanNode{name: node.Name, id: NodeNameToID(node.Name)}) s.internalRoute.AddIntIP(ip, ip, &sdwanNode{name: node.Name, id: NodeNameToID(node.Name)})
} }
for _, node := range gConf.getAddNodes() { for _, node := range gConf.getAddNodes() {
if node.Name == s.nodeName { // not deal resource itself if node.Name == s.nodeName { // not deal resource itself
continue continue
} }
if len(node.Resource) > 0 { if len(node.Resource) > 0 {
gLog.Printf(LvINFO, "deal add node: %s resource: %s", node.Name, node.Resource) gLog.Printf(LvINFO, "deal add node: %s resource: %s", node.Name, node.Resource)
arr := strings.Split(node.Resource, ",") arr := strings.Split(node.Resource, ",")
for _, r := range arr { for _, r := range arr {
// add internal route // add internal route
_, ipnet, err := net.ParseCIDR(r) _, ipnet, err := net.ParseCIDR(r)
if err != nil { if err != nil {
fmt.Println("Error parsing CIDR:", err) fmt.Println("Error parsing CIDR:", err)
continue continue
} }
if ipnet.Contains(net.ParseIP(gConf.Network.localIP)) { // local ip and resource in the same lan if ipnet.Contains(net.ParseIP(gConf.Network.localIP)) { // local ip and resource in the same lan
continue continue
} }
minIP := ipnet.IP minIP := ipnet.IP
maxIP := make(net.IP, len(minIP)) maxIP := make(net.IP, len(minIP))
copy(maxIP, minIP) copy(maxIP, minIP)
for i := range minIP { for i := range minIP {
maxIP[i] = minIP[i] | ^ipnet.Mask[i] maxIP[i] = minIP[i] | ^ipnet.Mask[i]
} }
s.internalRoute.Add(minIP.String(), maxIP.String(), &sdwanNode{name: node.Name, id: NodeNameToID(node.Name)}) s.internalRoute.Add(minIP.String(), maxIP.String(), &sdwanNode{name: node.Name, id: NodeNameToID(node.Name)})
// add sys route // add sys route
addRoute(ipnet.String(), s.gateway.String(), s.tun.tunName) addRoute(ipnet.String(), s.gateway.String(), s.tun.tunName)
} }
} }
} }
gConf.retryAllMemApp() gConf.retryAllMemApp()
gLog.Printf(LvINFO, "sdwan init ok") gLog.Printf(LvINFO, "sdwan init ok")
return nil return nil
} }
func (s *p2pSDWAN) run() { func (s *p2pSDWAN) run() {
s.sysRoute.Range(func(key, value interface{}) bool { s.sysRoute.Range(func(key, value interface{}) bool {
node := value.(*sdwanNode) node := value.(*sdwanNode)
GNetwork.ConnectNode(node.name) GNetwork.ConnectNode(node.name)
return true return true
}) })
} }
func (s *p2pSDWAN) readNodeLoop() { func (s *p2pSDWAN) readNodeLoop() {
gLog.Printf(LvDEBUG, "sdwan readNodeLoop start") gLog.Printf(LvDEBUG, "sdwan readNodeLoop start")
defer gLog.Printf(LvDEBUG, "sdwan readNodeLoop end") defer gLog.Printf(LvDEBUG, "sdwan readNodeLoop end")
writeBuff := make([][]byte, 1) writeBuff := make([][]byte, 1)
for { for {
nd := GNetwork.ReadNode(time.Second * 10) // TODO: read multi packet nd := GNetwork.ReadNode(time.Second * 10) // TODO: read multi packet
if nd == nil { if nd == nil {
gLog.Printf(LvDev, "waiting for node data") gLog.Printf(LvDev, "waiting for node data")
continue continue
} }
head := PacketHeader{} head := PacketHeader{}
parseHeader(nd.Data, &head) parseHeader(nd.Data, &head)
gLog.Printf(LvDev, "write tun dst ip=%s,len=%d", net.IP{byte(head.dst >> 24), byte(head.dst >> 16), byte(head.dst >> 8), byte(head.dst)}.String(), len(nd.Data)) gLog.Printf(LvDev, "write tun dst ip=%s,len=%d", net.IP{byte(head.dst >> 24), byte(head.dst >> 16), byte(head.dst >> 8), byte(head.dst)}.String(), len(nd.Data))
if PIHeaderSize == 0 { if PIHeaderSize == 0 {
writeBuff[0] = nd.Data writeBuff[0] = nd.Data
} else { } else {
writeBuff[0] = make([]byte, PIHeaderSize+len(nd.Data)) writeBuff[0] = make([]byte, PIHeaderSize+len(nd.Data))
copy(writeBuff[0][PIHeaderSize:], nd.Data) copy(writeBuff[0][PIHeaderSize:], nd.Data)
} }
len, err := s.tun.Write(writeBuff, PIHeaderSize) len, err := s.tun.Write(writeBuff, PIHeaderSize)
if err != nil { if err != nil {
gLog.Printf(LvDEBUG, "write tun dst ip=%s,len=%d,error:%s", net.IP{byte(head.dst >> 24), byte(head.dst >> 16), byte(head.dst >> 8), byte(head.dst)}.String(), len, err) gLog.Printf(LvDEBUG, "write tun dst ip=%s,len=%d,error:%s", net.IP{byte(head.dst >> 24), byte(head.dst >> 16), byte(head.dst >> 8), byte(head.dst)}.String(), len, err)
} }
} }
} }
func isBroadcastOrMulticast(ipUint32 uint32, subnet *net.IPNet) bool { func isBroadcastOrMulticast(ipUint32 uint32, subnet *net.IPNet) bool {
// return ipUint32 == 0xffffffff || (byte(ipUint32) == 0xff) || (ipUint32>>28 == 0xe) // return ipUint32 == 0xffffffff || (byte(ipUint32) == 0xff) || (ipUint32>>28 == 0xe)
return ipUint32 == 0xffffffff || (ipUint32>>28 == 0xe) // 225.255.255.255/32, 224.0.0.0/4 return ipUint32 == 0xffffffff || (ipUint32>>28 == 0xe) // 225.255.255.255/32, 224.0.0.0/4
} }
func (s *p2pSDWAN) routeTunPacket(p []byte, head *PacketHeader) { func (s *p2pSDWAN) routeTunPacket(p []byte, head *PacketHeader) {
var node *sdwanNode var node *sdwanNode
// v, ok := s.routes.Load(ih.dst) // v, ok := s.routes.Load(ih.dst)
v, ok := s.internalRoute.Load(head.dst) v, ok := s.internalRoute.Load(head.dst)
if !ok || v == nil { if !ok || v == nil {
if isBroadcastOrMulticast(head.dst, s.subnet) { if isBroadcastOrMulticast(head.dst, s.subnet) {
gLog.Printf(LvDev, "multicast ip=%s", net.IP{byte(head.dst >> 24), byte(head.dst >> 16), byte(head.dst >> 8), byte(head.dst)}.String()) gLog.Printf(LvDev, "multicast ip=%s", net.IP{byte(head.dst >> 24), byte(head.dst >> 16), byte(head.dst >> 8), byte(head.dst)}.String())
GNetwork.WriteBroadcast(p) GNetwork.WriteBroadcast(p)
} }
return return
} else { } else {
node = v.(*sdwanNode) node = v.(*sdwanNode)
} }
err := GNetwork.WriteNode(node.id, p) err := GNetwork.WriteNode(node.id, p)
if err != nil { if err != nil {
gLog.Printf(LvDev, "write packet to %s fail: %s", node.name, err) gLog.Printf(LvDev, "write packet to %s fail: %s", node.name, err)
} }
} }
func (s *p2pSDWAN) readTunLoop() { func (s *p2pSDWAN) readTunLoop() {
gLog.Printf(LvDEBUG, "sdwan readTunLoop start") gLog.Printf(LvDEBUG, "sdwan readTunLoop start")
defer gLog.Printf(LvDEBUG, "sdwan readTunLoop end") defer gLog.Printf(LvDEBUG, "sdwan readTunLoop end")
readBuff := make([][]byte, ReadTunBuffNum) readBuff := make([][]byte, ReadTunBuffNum)
for i := 0; i < ReadTunBuffNum; i++ { for i := 0; i < ReadTunBuffNum; i++ {
readBuff[i] = make([]byte, ReadTunBuffSize+PIHeaderSize) readBuff[i] = make([]byte, ReadTunBuffSize+PIHeaderSize)
} }
readBuffSize := make([]int, ReadTunBuffNum) readBuffSize := make([]int, ReadTunBuffNum)
ih := PacketHeader{} ih := PacketHeader{}
for { for {
n, err := s.tun.Read(readBuff, readBuffSize, PIHeaderSize) n, err := s.tun.Read(readBuff, readBuffSize, PIHeaderSize)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "read tun fail: ", err) gLog.Printf(LvERROR, "read tun fail: ", err)
return return
} }
for i := 0; i < n; i++ { for i := 0; i < n; i++ {
if readBuffSize[i] > ReadTunBuffSize { if readBuffSize[i] > ReadTunBuffSize {
gLog.Printf(LvERROR, "read tun overflow: len=", readBuffSize[i]) gLog.Printf(LvERROR, "read tun overflow: len=", readBuffSize[i])
continue continue
} }
parseHeader(readBuff[i][PIHeaderSize:readBuffSize[i]+PIHeaderSize], &ih) parseHeader(readBuff[i][PIHeaderSize:readBuffSize[i]+PIHeaderSize], &ih)
gLog.Printf(LvDev, "read tun dst ip=%s,len=%d", net.IP{byte(ih.dst >> 24), byte(ih.dst >> 16), byte(ih.dst >> 8), byte(ih.dst)}.String(), readBuffSize[0]) gLog.Printf(LvDev, "read tun dst ip=%s,len=%d", net.IP{byte(ih.dst >> 24), byte(ih.dst >> 16), byte(ih.dst >> 8), byte(ih.dst)}.String(), readBuffSize[0])
s.routeTunPacket(readBuff[i][PIHeaderSize:readBuffSize[i]+PIHeaderSize], &ih) s.routeTunPacket(readBuff[i][PIHeaderSize:readBuffSize[i]+PIHeaderSize], &ih)
} }
} }
} }
func (s *p2pSDWAN) StartTun() error { func (s *p2pSDWAN) StartTun() error {
sdwan := gConf.getSDWAN() sdwan := gConf.getSDWAN()
if s.tun == nil { if s.tun == nil {
tun := &optun{} tun := &optun{}
err := tun.Start(s.virtualIP.String(), &sdwan) err := tun.Start(s.virtualIP.String(), &sdwan)
if err != nil { if err != nil {
gLog.Println(LvERROR, "open tun fail:", err) gLog.Println(LvERROR, "open tun fail:", err)
return err return err
} }
s.tun = tun s.tun = tun
go s.readTunLoop() go s.readTunLoop()
go s.readNodeLoop() // multi-thread read will cause packets out of order, resulting in slower speeds go s.readNodeLoop() // multi-thread read will cause packets out of order, resulting in slower speeds
} }
err := setTunAddr(s.tun.tunName, s.virtualIP.String(), sdwan.Gateway, s.tun.dev) err := setTunAddr(s.tun.tunName, s.virtualIP.String(), sdwan.Gateway, s.tun.dev)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "setTunAddr error:%s,%s,%s,%s", err, s.tun.tunName, s.virtualIP.String(), sdwan.Gateway) gLog.Printf(LvERROR, "setTunAddr error:%s,%s,%s,%s", err, s.tun.tunName, s.virtualIP.String(), sdwan.Gateway)
return err return err
} }
return nil return nil
} }
func handleSDWAN(subType uint16, msg []byte) error { func handleSDWAN(subType uint16, msg []byte) error {
gLog.Printf(LvDEBUG, "handle sdwan msg type:%d", subType) gLog.Printf(LvDEBUG, "handle sdwan msg type:%d", subType)
var err error var err error
switch subType { switch subType {
case MsgSDWANInfoRsp: case MsgSDWANInfoRsp:
rsp := SDWANInfo{} rsp := SDWANInfo{}
if err = json.Unmarshal(msg[openP2PHeaderSize:], &rsp); err != nil { if err = json.Unmarshal(msg[openP2PHeaderSize:], &rsp); err != nil {
return ErrMsgFormat return ErrMsgFormat
} }
gLog.Println(LvINFO, "sdwan init:", prettyJson(rsp)) gLog.Println(LvINFO, "sdwan init:", prettyJson(rsp))
if runtime.GOOS == "android" { if runtime.GOOS == "android" {
AndroidSDWANConfig <- msg[openP2PHeaderSize:] AndroidSDWANConfig <- msg[openP2PHeaderSize:]
} }
// GNetwork.sdwan.detail = &rsp // GNetwork.sdwan.detail = &rsp
gConf.setSDWAN(rsp) gConf.setSDWAN(rsp)
err = GNetwork.sdwan.init(gConf.Network.Node) err = GNetwork.sdwan.init(gConf.Network.Node)
if err != nil { if err != nil {
gLog.Println(LvERROR, "sdwan init fail: ", err) gLog.Println(LvERROR, "sdwan init fail: ", err)
if GNetwork.sdwan.tun != nil { if GNetwork.sdwan.tun != nil {
GNetwork.sdwan.tun.Stop() GNetwork.sdwan.tun.Stop()
GNetwork.sdwan.tun = nil GNetwork.sdwan.tun = nil
return err return err
} }
} }
go GNetwork.sdwan.run() go GNetwork.sdwan.run()
default: default:
} }
return err return err
} }
core/update.go
+239 -239
View File
@@ -1,239 +1,239 @@
package openp2p package openp2p
import ( import (
"archive/tar" "archive/tar"
"archive/zip" "archive/zip"
"compress/gzip" "compress/gzip"
"crypto/tls" "crypto/tls"
"crypto/x509" "crypto/x509"
"encoding/json" "encoding/json"
"fmt" "fmt"
"io" "io"
"io/ioutil" "io/ioutil"
"net/http" "net/http"
"net/url" "net/url"
"os" "os"
"path/filepath" "path/filepath"
"runtime" "runtime"
"time" "time"
) )
func update(host string, port int) error { func update(host string, port int) error {
gLog.Println(LvINFO, "update start") gLog.Println(LvINFO, "update start")
defer gLog.Println(LvINFO, "update end") defer gLog.Println(LvINFO, "update end")
caCertPool, err := x509.SystemCertPool() caCertPool, err := x509.SystemCertPool()
if err != nil { if err != nil {
gLog.Println(LvERROR, "Failed to load system root CAs:", err) gLog.Println(LvERROR, "Failed to load system root CAs:", err)
} else { } else {
caCertPool = x509.NewCertPool() caCertPool = x509.NewCertPool()
} }
caCertPool.AppendCertsFromPEM([]byte(rootCA)) caCertPool.AppendCertsFromPEM([]byte(rootCA))
caCertPool.AppendCertsFromPEM([]byte(ISRGRootX1)) caCertPool.AppendCertsFromPEM([]byte(ISRGRootX1))
c := http.Client{ c := http.Client{
Transport: &http.Transport{ Transport: &http.Transport{
TLSClientConfig: &tls.Config{RootCAs: caCertPool, TLSClientConfig: &tls.Config{RootCAs: caCertPool,
InsecureSkipVerify: false}, InsecureSkipVerify: false},
}, },
Timeout: time.Second * 30, Timeout: time.Second * 30,
} }
goos := runtime.GOOS goos := runtime.GOOS
goarch := runtime.GOARCH goarch := runtime.GOARCH
rsp, err := c.Get(fmt.Sprintf("https://%s:%d/api/v1/update?fromver=%s&os=%s&arch=%s&user=%s&node=%s", host, port, OpenP2PVersion, goos, goarch, url.QueryEscape(gConf.Network.User), url.QueryEscape(gConf.Network.Node))) rsp, err := c.Get(fmt.Sprintf("https://%s:%d/api/v1/update?fromver=%s&os=%s&arch=%s&user=%s&node=%s", host, port, OpenP2PVersion, goos, goarch, url.QueryEscape(gConf.Network.User), url.QueryEscape(gConf.Network.Node)))
if err != nil { if err != nil {
gLog.Println(LvERROR, "update:query update list failed:", err) gLog.Println(LvERROR, "update:query update list failed:", err)
return err return err
} }
defer rsp.Body.Close() defer rsp.Body.Close()
if rsp.StatusCode != http.StatusOK { if rsp.StatusCode != http.StatusOK {
gLog.Println(LvERROR, "get update info error:", rsp.Status) gLog.Println(LvERROR, "get update info error:", rsp.Status)
return err return err
} }
rspBuf, err := ioutil.ReadAll(rsp.Body) rspBuf, err := ioutil.ReadAll(rsp.Body)
if err != nil { if err != nil {
gLog.Println(LvERROR, "update:read update list failed:", err) gLog.Println(LvERROR, "update:read update list failed:", err)
return err return err
} }
updateInfo := UpdateInfo{} updateInfo := UpdateInfo{}
if err = json.Unmarshal(rspBuf, &updateInfo); err != nil { if err = json.Unmarshal(rspBuf, &updateInfo); err != nil {
gLog.Println(LvERROR, rspBuf, " update info decode error:", err) gLog.Println(LvERROR, rspBuf, " update info decode error:", err)
return err return err
} }
if updateInfo.Error != 0 { if updateInfo.Error != 0 {
gLog.Println(LvERROR, "update error:", updateInfo.Error, updateInfo.ErrorDetail) gLog.Println(LvERROR, "update error:", updateInfo.Error, updateInfo.ErrorDetail)
return err return err
} }
err = updateFile(updateInfo.Url, "", "openp2p") err = updateFile(updateInfo.Url, "", "openp2p")
if err != nil { if err != nil {
gLog.Println(LvERROR, "update: download failed:", err) gLog.Println(LvERROR, "update: download failed:", err)
return err return err
} }
return nil return nil
} }
func downloadFile(url string, checksum string, dstFile string) error { func downloadFile(url string, checksum string, dstFile string) error {
output, err := os.OpenFile(dstFile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0776) output, err := os.OpenFile(dstFile, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0776)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "OpenFile %s error:%s", dstFile, err) gLog.Printf(LvERROR, "OpenFile %s error:%s", dstFile, err)
return err return err
} }
caCertPool, err := x509.SystemCertPool() caCertPool, err := x509.SystemCertPool()
if err != nil { if err != nil {
gLog.Println(LvERROR, "Failed to load system root CAs:", err) gLog.Println(LvERROR, "Failed to load system root CAs:", err)
} else { } else {
caCertPool = x509.NewCertPool() caCertPool = x509.NewCertPool()
} }
caCertPool.AppendCertsFromPEM([]byte(rootCA)) caCertPool.AppendCertsFromPEM([]byte(rootCA))
caCertPool.AppendCertsFromPEM([]byte(ISRGRootX1)) caCertPool.AppendCertsFromPEM([]byte(ISRGRootX1))
tr := &http.Transport{ tr := &http.Transport{
TLSClientConfig: &tls.Config{ TLSClientConfig: &tls.Config{
RootCAs: caCertPool, RootCAs: caCertPool,
InsecureSkipVerify: false}, InsecureSkipVerify: false},
} }
client := &http.Client{Transport: tr} client := &http.Client{Transport: tr}
response, err := client.Get(url) response, err := client.Get(url)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "download url %s error:%s", url, err) gLog.Printf(LvERROR, "download url %s error:%s", url, err)
output.Close() output.Close()
return err return err
} }
defer response.Body.Close() defer response.Body.Close()
n, err := io.Copy(output, response.Body) n, err := io.Copy(output, response.Body)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "io.Copy error:%s", err) gLog.Printf(LvERROR, "io.Copy error:%s", err)
output.Close() output.Close()
return err return err
} }
output.Sync() output.Sync()
output.Close() output.Close()
gLog.Println(LvINFO, "download ", url, " ok") gLog.Println(LvINFO, "download ", url, " ok")
gLog.Printf(LvINFO, "size: %d bytes", n) gLog.Printf(LvINFO, "size: %d bytes", n)
return nil return nil
} }
func updateFile(url string, checksum string, dst string) error { func updateFile(url string, checksum string, dst string) error {
gLog.Println(LvINFO, "download ", url) gLog.Println(LvINFO, "download ", url)
tmpFile := filepath.Dir(os.Args[0]) + "/openp2p.tmp" tmpFile := filepath.Dir(os.Args[0]) + "/openp2p.tmp"
err := downloadFile(url, checksum, tmpFile) err := downloadFile(url, checksum, tmpFile)
if err != nil { if err != nil {
return err return err
} }
backupFile := os.Args[0] + "0" backupFile := os.Args[0] + "0"
err = os.Rename(os.Args[0], backupFile) // the old daemon process was using the 0 file, so it will prevent override it err = os.Rename(os.Args[0], backupFile) // the old daemon process was using the 0 file, so it will prevent override it
if err != nil { if err != nil {
gLog.Printf(LvINFO, " rename %s error:%s, retry 1", os.Args[0], err) gLog.Printf(LvINFO, " rename %s error:%s, retry 1", os.Args[0], err)
backupFile = os.Args[0] + "1" backupFile = os.Args[0] + "1"
err = os.Rename(os.Args[0], backupFile) err = os.Rename(os.Args[0], backupFile)
if err != nil { if err != nil {
gLog.Printf(LvINFO, " rename %s error:%s", os.Args[0], err) gLog.Printf(LvINFO, " rename %s error:%s", os.Args[0], err)
} }
} }
// extract // extract
gLog.Println(LvINFO, "extract files") gLog.Println(LvINFO, "extract files")
err = extract(filepath.Dir(os.Args[0]), tmpFile) err = extract(filepath.Dir(os.Args[0]), tmpFile)
if err != nil { if err != nil {
gLog.Printf(LvERROR, "extract error:%s. revert rename", err) gLog.Printf(LvERROR, "extract error:%s. revert rename", err)
os.Rename(backupFile, os.Args[0]) os.Rename(backupFile, os.Args[0])
return err return err
} }
os.Remove(tmpFile) os.Remove(tmpFile)
return nil return nil
} }
func extract(dst, src string) (err error) { func extract(dst, src string) (err error) {
if runtime.GOOS == "windows" { if runtime.GOOS == "windows" {
return unzip(dst, src) return unzip(dst, src)
} else { } else {
return extractTgz(dst, src) return extractTgz(dst, src)
} }
} }
func unzip(dst, src string) (err error) { func unzip(dst, src string) (err error) {
archive, err := zip.OpenReader(src) archive, err := zip.OpenReader(src)
if err != nil { if err != nil {
return err return err
} }
defer archive.Close() defer archive.Close()
for _, f := range archive.File { for _, f := range archive.File {
filePath := filepath.Join(dst, f.Name) filePath := filepath.Join(dst, f.Name)
fmt.Println("unzipping file ", filePath) fmt.Println("unzipping file ", filePath)
if f.FileInfo().IsDir() { if f.FileInfo().IsDir() {
fmt.Println("creating directory...") fmt.Println("creating directory...")
os.MkdirAll(filePath, os.ModePerm) os.MkdirAll(filePath, os.ModePerm)
continue continue
} }
if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil { if err := os.MkdirAll(filepath.Dir(filePath), os.ModePerm); err != nil {
return err return err
} }
dstFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode()) dstFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
if err != nil { if err != nil {
return err return err
} }
fileInArchive, err := f.Open() fileInArchive, err := f.Open()
if err != nil { if err != nil {
return err return err
} }
if _, err := io.Copy(dstFile, fileInArchive); err != nil { if _, err := io.Copy(dstFile, fileInArchive); err != nil {
return err return err
} }
dstFile.Close() dstFile.Close()
fileInArchive.Close() fileInArchive.Close()
} }
return nil return nil
} }
func extractTgz(dst, src string) error { func extractTgz(dst, src string) error {
gzipStream, err := os.Open(src) gzipStream, err := os.Open(src)
if err != nil { if err != nil {
return err return err
} }
uncompressedStream, err := gzip.NewReader(gzipStream) uncompressedStream, err := gzip.NewReader(gzipStream)
if err != nil { if err != nil {
return err return err
} }
tarReader := tar.NewReader(uncompressedStream) tarReader := tar.NewReader(uncompressedStream)
for { for {
header, err := tarReader.Next() header, err := tarReader.Next()
if err == io.EOF { if err == io.EOF {
break break
} }
if err != nil { if err != nil {
return err return err
} }
switch header.Typeflag { switch header.Typeflag {
case tar.TypeDir: case tar.TypeDir:
if err := os.Mkdir(header.Name, 0755); err != nil { if err := os.Mkdir(header.Name, 0755); err != nil {
return err return err
} }
case tar.TypeReg: case tar.TypeReg:
filePath := filepath.Join(dst, header.Name) filePath := filepath.Join(dst, header.Name)
outFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.FileMode(header.Mode)) outFile, err := os.OpenFile(filePath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.FileMode(header.Mode))
if err != nil { if err != nil {
return err return err
} }
defer outFile.Close() defer outFile.Close()
if _, err := io.Copy(outFile, tarReader); err != nil { if _, err := io.Copy(outFile, tarReader); err != nil {
return err return err
} }
default: default:
return err return err
} }
} }
return nil return nil
} }
func cleanTempFiles() { func cleanTempFiles() {
tmpFile := os.Args[0] + "0" tmpFile := os.Args[0] + "0"
if _, err := os.Stat(tmpFile); err == nil { if _, err := os.Stat(tmpFile); err == nil {
if err := os.Remove(tmpFile); err != nil { if err := os.Remove(tmpFile); err != nil {
gLog.Printf(LvDEBUG, " remove %s error:%s", tmpFile, err) gLog.Printf(LvDEBUG, " remove %s error:%s", tmpFile, err)
} }
} }
tmpFile = os.Args[0] + "1" tmpFile = os.Args[0] + "1"
if _, err := os.Stat(tmpFile); err == nil { if _, err := os.Stat(tmpFile); err == nil {
if err := os.Remove(tmpFile); err != nil { if err := os.Remove(tmpFile); err != nil {
gLog.Printf(LvDEBUG, " remove %s error:%s", tmpFile, err) gLog.Printf(LvDEBUG, " remove %s error:%s", tmpFile, err)
} }
} }
} }
lib/openp2p.go
+18 -18
View File
@@ -1,18 +1,18 @@
package main package main
// On Windows env // On Windows env
// cd lib // cd lib
// go build -o openp2p.dll -buildmode=c-shared openp2p.go // go build -o openp2p.dll -buildmode=c-shared openp2p.go
// caller example see example/dll // caller example see example/dll
import ( import (
op "openp2p/core" op "openp2p/core"
) )
import "C" import "C"
func main() { func main() {
} }
//export RunCmd //export RunCmd
func RunCmd(cmd *C.char) { func RunCmd(cmd *C.char) {
op.RunCmd(C.GoString(cmd)) op.RunCmd(C.GoString(cmd))
} }