yeyinlaoying/openp2p
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

install bug and new log api

Browse Source
This commit is contained in:
TenderIronh
2025-11-14 17:19:50 +08:00
parent d827fd108d
commit 6639f40d70
16 changed files with 575 additions and 302 deletions
Download Patch File Download Diff File Expand all files Collapse all files
core/errorcode.go
+3
View File
@@ -30,4 +30,7 @@ var (
ErrBuildTunnelBusy = errors.New("build tunnel busy")
ErrMemAppTunnelNotFound = errors.New("memapp tunnel not found")
ErrRemoteServiceUnable = errors.New("remote service unable")
ErrAppWithoutTunnel = errors.New("p2papp has no available tunnel")
ErrWriteWindowFull = errors.New("writeWindow full")
ErrHeaderDataLen = errors.New("header datalen error")
)
core/install.go
+39 -39
View File
@@ -11,26 +11,14 @@ import (
)
func install() {
gLog.Println(LvINFO, "openp2p start. version: ", OpenP2PVersion)
gLog.Println(LvINFO, "Contact: QQ group 16947733, Email [email protected]")
gLog.Println(LvINFO, "install start")
defer gLog.Println(LvINFO, "install end")
// auto uninstall
err := os.MkdirAll(defaultInstallPath, 0775)
if err != nil {
gLog.Printf(LvERROR, "MkdirAll %s error:%s", defaultInstallPath, err)
return
}
err = os.Chdir(defaultInstallPath)
if err != nil {
gLog.Println(LvERROR, "Chdir error:", err)
return
}
uninstall()
// save config file
gLog.i("openp2p start. version: %s", OpenP2PVersion)
gLog.i("Contact: QQ group 16947733, Email [email protected]")
gLog.i("install start")
defer gLog.i("install end")
parseParams("install", "")
// auto uninstall
uninstall(false)
gLog.i("install path: %s", defaultInstallPath)
targetPath := filepath.Join(defaultInstallPath, defaultBinName)
d := daemon{}
// copy files
@@ -38,37 +26,42 @@ func install() {
binPath, _ := os.Executable()
src, errFiles := os.Open(binPath) // can not use args[0], on Windows call openp2p is ok(=openp2p.exe)
if errFiles != nil {
gLog.Printf(LvERROR, "os.Open %s error:%s", os.Args[0], errFiles)
gLog.e("os.Open %s error:%s", os.Args[0], errFiles)
return
}
dst, errFiles := os.OpenFile(targetPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0775)
if errFiles != nil {
gLog.Printf(LvERROR, "os.OpenFile %s error:%s", targetPath, errFiles)
return
time.Sleep(time.Second * 5) // maybe windows defender occupied the file, retry
dst, errFiles = os.OpenFile(targetPath, os.O_CREATE|os.O_WRONLY|os.O_TRUNC, 0775)
if errFiles != nil {
gLog.e("os.OpenFile %s error:%s", targetPath, errFiles)
return
}
}
_, errFiles = io.Copy(dst, src)
if errFiles != nil {
gLog.Printf(LvERROR, "io.Copy error:%s", errFiles)
gLog.e("io.Copy error:%s", errFiles)
return
}
src.Close()
dst.Close()
// install system service
err = d.Control("install", targetPath, []string{"-d"})
err := d.Control("install", targetPath, []string{"-d"})
if err == nil {
gLog.Println(LvINFO, "install system service ok.")
gLog.i("install system service ok.")
}
time.Sleep(time.Second * 2)
err = d.Control("start", targetPath, []string{"-d"})
if err != nil {
gLog.Println(LvERROR, "start openp2p service error:", err)
gLog.e("start openp2p service error:%s", err)
} else {
gLog.Println(LvINFO, "start openp2p service ok.")
gLog.i("start openp2p service ok.")
}
gLog.Println(LvINFO, "Visit WebUI on https://console.openp2p.cn")
gConf.save()
gLog.i("Visit WebUI on https://console.openp2p.cn")
}
func installByFilename() {
@@ -78,7 +71,7 @@ func installByFilename() {
}
serverHost := params[1]
token := params[2]
gLog.Println(LvINFO, "install start")
gLog.i("install start")
targetPath := os.Args[0]
args := []string{"install"}
args = append(args, "-serverhost")
@@ -93,31 +86,38 @@ func installByFilename() {
cmd.Env = env
err := cmd.Run()
if err != nil {
gLog.Println(LvERROR, "install by filename, start process error:", err)
gLog.e("install by filename, start process error:%s", err)
return
}
gLog.Println(LvINFO, "install end")
gLog.Println(LvINFO, "Visit WebUI on https://console.openp2p.cn")
gLog.i("install end")
gLog.i("Visit WebUI on https://console.openp2p.cn")
fmt.Println("Press the Any Key to exit")
fmt.Scanln()
os.Exit(0)
}
func uninstall() {
gLog.Println(LvINFO, "uninstall start")
defer gLog.Println(LvINFO, "uninstall end")
func uninstall(rmFiles bool) {
gLog.i("uninstall start")
defer gLog.i("uninstall end")
d := daemon{}
err := d.Control("stop", "", nil)
if err != nil { // service maybe not install
return
gLog.d("stop service error:%s", err)
}
err = d.Control("uninstall", "", nil)
if err != nil {
gLog.Println(LvERROR, "uninstall system service error:", err)
gLog.d("uninstall system service error:%s", err)
} else {
gLog.Println(LvINFO, "uninstall system service ok.")
gLog.i("uninstall system service ok.")
}
time.Sleep(time.Second * 3)
binPath := filepath.Join(defaultInstallPath, defaultBinName)
os.Remove(binPath + "0")
os.Remove(binPath)
// os.RemoveAll(defaultInstallPath) // reserve config.json
if rmFiles {
if err := os.RemoveAll(defaultInstallPath); err != nil {
gLog.e("RemoveAll %s error:%s", defaultInstallPath, err)
}
}
}
core/log.go
+107 -88
View File
@@ -3,38 +3,33 @@ package openp2p
import (
"log"
"os"
"path/filepath"
"runtime"
"sync"
"sync/atomic"
"time"
)
type LogLevel int
type LogLevel int32
var gLog *logger
const (
LvDev LogLevel = -1
LvDEBUG LogLevel = iota
LvINFO
LvWARN
LvERROR
LvDEBUG LogLevel = 0
LvINFO LogLevel = 1
LvWARN LogLevel = 2
LvERROR LogLevel = 3
)
var (
logFileNames map[LogLevel]string
loglevel map[LogLevel]string
)
func init() {
logFileNames = make(map[LogLevel]string)
loglevel = make(map[LogLevel]string)
logFileNames[0] = ".log"
loglevel[LvDEBUG] = "DEBUG"
loglevel[LvINFO] = "INFO"
loglevel[LvWARN] = "WARN"
loglevel[LvERROR] = "ERROR"
loglevel[LvDev] = "Dev"
const logFileNames string = ".log"
var loglevel = map[LogLevel]string{
LvDEBUG: "DEBUG",
LvINFO: "INFO",
LvWARN: "WARN",
LvERROR: "ERROR",
LvDev: "Dev",
}
const (
@@ -43,62 +38,54 @@ const (
)
type logger struct {
loggers map[LogLevel]*log.Logger
files map[LogLevel]*os.File
level LogLevel
logDir string
mtx *sync.Mutex
lineEnding string
pid int
maxLogSize int64
mode int
stdLogger *log.Logger
logger *log.Logger
files *os.File
level atomic.Int32
logDir string
mtx sync.Mutex
lineEnding string
pid int
maxLogSize atomic.Int64
mode int
stdLogger *log.Logger
checkFileRunning bool
}
func NewLogger(path string, filePrefix string, level LogLevel, maxLogSize int64, mode int) *logger {
loggers := make(map[LogLevel]*log.Logger)
logfiles := make(map[LogLevel]*os.File)
var (
logdir string
)
if path == "" {
logdir = "log/"
} else {
logdir = path + "/log/"
logdir := filepath.Join(path, "log")
if err := os.MkdirAll(logdir, 0755); err != nil && mode&LogFile != 0 {
return nil
}
os.MkdirAll(logdir, 0777)
for lv := range logFileNames {
logFilePath := logdir + filePrefix + logFileNames[lv]
f, err := os.OpenFile(logFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil {
log.Fatal(err)
}
os.Chmod(logFilePath, 0644)
logfiles[lv] = f
loggers[lv] = log.New(f, "", log.LstdFlags|log.Lmicroseconds)
logFilePath := filepath.Join(logdir, filePrefix+logFileNames)
f, err := os.OpenFile(logFilePath, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if err != nil && mode&LogFile != 0 {
log.Fatal(err)
}
var le string
stdLog := log.New(f, "", log.LstdFlags|log.Lmicroseconds)
le := "\n"
if runtime.GOOS == "windows" {
le = "\r\n"
} else {
le = "\n"
}
pLog := &logger{loggers, logfiles, level, logdir, &sync.Mutex{}, le, os.Getpid(), maxLogSize, mode, log.New(os.Stdout, "", 0)}
pLog := &logger{logger: stdLog,
files: f,
logDir: logdir,
lineEnding: le,
pid: os.Getpid(),
mode: mode,
stdLogger: log.New(os.Stdout, "", 0)}
pLog.setMaxSize(maxLogSize)
pLog.setLevel(level)
pLog.stdLogger.SetFlags(log.LstdFlags | log.Lmicroseconds)
go pLog.checkFile()
return pLog
}
func (l *logger) setLevel(level LogLevel) {
l.mtx.Lock()
defer l.mtx.Unlock()
l.level = level
l.level.Store(int32(level))
}
func (l *logger) setMaxSize(size int64) {
l.mtx.Lock()
defer l.mtx.Unlock()
l.maxLogSize = size
l.maxLogSize.Store(size)
}
func (l *logger) setMode(mode int) {
@@ -107,49 +94,61 @@ func (l *logger) setMode(mode int) {
l.mode = mode
}
func (l *logger) close() {
l.checkFileRunning = false
l.files.Close()
}
func (l *logger) checkFile() {
if l.maxLogSize <= 0 {
if l.maxLogSize.Load() <= 0 {
return
}
l.checkFileRunning = true
ticker := time.NewTicker(time.Minute)
for {
for l.checkFileRunning {
select {
case <-ticker.C:
l.mtx.Lock()
for lv, logFile := range l.files {
f, e := logFile.Stat()
if e != nil {
continue
}
if f.Size() <= l.maxLogSize {
continue
}
logFile.Close()
fname := f.Name()
backupPath := l.logDir + fname + ".0"
os.Remove(backupPath)
os.Rename(l.logDir+fname, backupPath)
newFile, e := os.OpenFile(l.logDir+fname, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
if e == nil {
l.loggers[lv].SetOutput(newFile)
l.files[lv] = newFile
}
f, e := l.files.Stat()
if e != nil {
continue
}
l.mtx.Unlock()
if f.Size() <= l.maxLogSize.Load() {
continue
}
l.mtx.Lock()
l.files.Close()
fname := f.Name()
backupPath := filepath.Join(l.logDir, fname+".0")
err := os.Remove(backupPath)
if err != nil {
log.Println("remove openp2p.log0 error:", err)
}
if err = os.Rename(filepath.Join(l.logDir, fname), backupPath); err != nil {
log.Println("rename openp2p.log error:", err)
}
if newFile, e := os.OpenFile(filepath.Join(l.logDir, fname), os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644); e == nil {
l.logger.SetOutput(newFile)
l.files = newFile
l.mtx.Unlock()
}
case <-time.After(time.Second * 1):
}
}
}
func (l *logger) Printf(level LogLevel, format string, params ...interface{}) {
l.mtx.Lock()
defer l.mtx.Unlock()
if level < l.level {
if level < LogLevel(l.level.Load()) {
return
}
l.mtx.Lock()
defer l.mtx.Unlock()
pidAndLevel := []interface{}{l.pid, loglevel[level]}
params = append(pidAndLevel, params...)
if l.mode&LogFile != 0 {
l.loggers[0].Printf("%d %s "+format+l.lineEnding, params...)
l.logger.Printf("%d %s "+format+l.lineEnding, params...)
}
if l.mode&LogConsole != 0 {
l.stdLogger.Printf("%d %s "+format+l.lineEnding, params...)
@@ -157,18 +156,38 @@ func (l *logger) Printf(level LogLevel, format string, params ...interface{}) {
}
func (l *logger) Println(level LogLevel, params ...interface{}) {
l.mtx.Lock()
defer l.mtx.Unlock()
if level < l.level {
if level < LogLevel(l.level.Load()) {
return
}
l.mtx.Lock()
defer l.mtx.Unlock()
pidAndLevel := []interface{}{l.pid, " ", loglevel[level], " "}
params = append(pidAndLevel, params...)
params = append(params, l.lineEnding)
if l.mode&LogFile != 0 {
l.loggers[0].Print(params...)
l.logger.Print(params...)
}
if l.mode&LogConsole != 0 {
l.stdLogger.Print(params...)
}
}
func (l *logger) d(format string, params ...interface{}) {
l.Printf(LvDEBUG, format, params...)
}
func (l *logger) i(format string, params ...interface{}) {
l.Printf(LvINFO, format, params...)
}
func (l *logger) w(format string, params ...interface{}) {
l.Printf(LvWARN, format, params...)
}
func (l *logger) e(format string, params ...interface{}) {
l.Printf(LvERROR, format, params...)
}
func (l *logger) dev(format string, params ...interface{}) {
l.Printf(LvDev, format, params...)
}
core/openp2p.go
+1 -1
View File
@@ -25,7 +25,7 @@ func Run() {
install()
return
case "uninstall":
uninstall()
uninstall(true)
return
}
} else {
core/optun.go
+3
View File
@@ -4,7 +4,10 @@ import (
"github.com/openp2p-cn/wireguard-go/tun"
)
const optunMTU = 1420
var AndroidSDWANConfig chan []byte
var preAndroidSDWANConfig string
type optun struct {
tunName string
core/optun_android.go
+20 -10
View File
@@ -5,12 +5,14 @@
package openp2p
import (
"net"
"time"
)
const (
tunIfaceName = "optun"
PIHeaderSize = 0
tunIfaceName = "optun"
PIHeaderSize = 0
ReadTunBuffSize = 2048
ReadTunBuffNum = 16
)
var AndroidReadTun chan []byte // TODO: multi channel
@@ -35,27 +37,35 @@ func (t *optun) Write(bufs [][]byte, offset int) (int, error) {
func AndroidRead(data []byte, len int) {
head := PacketHeader{}
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.dev("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)
copy(buf, data)
AndroidReadTun <- buf
}
func AndroidWrite(buf []byte) int {
p := <-AndroidWriteTun
copy(buf, p)
return len(p)
func AndroidWrite(buf []byte, timeoutMs int) int {
timeout := time.Duration(timeoutMs) * time.Millisecond
select {
case p := <-AndroidWriteTun:
if len(p) > int(gConf.sdwan.Mtu) {
gLog.e("AndroidWrite packet too large %d", len(p))
}
copy(buf, p)
return len(p)
case <-time.After(timeout):
return 0
}
}
func GetAndroidSDWANConfig(buf []byte) int {
p := <-AndroidSDWANConfig
copy(buf, p)
gLog.Printf(LvINFO, "AndroidSDWANConfig=%s", p)
gLog.i("AndroidSDWANConfig=%s", p)
return len(p)
}
func GetAndroidNodeName() string {
gLog.Printf(LvINFO, "GetAndroidNodeName=%s", gConf.Network.Node)
gLog.i("GetAndroidNodeName=%s", gConf.Network.Node)
return gConf.Network.Node
}
core/udp.go
+7 -3
View File
@@ -22,7 +22,7 @@ func UDPRead(conn *net.UDPConn, timeout time.Duration) (ra net.Addr, head *openP
if timeout > 0 {
err = conn.SetReadDeadline(time.Now().Add(timeout))
if err != nil {
gLog.Println(LvERROR, "SetReadDeadline error")
gLog.e("SetReadDeadline error")
return nil, nil, nil, 0, err
}
}
@@ -35,9 +35,13 @@ func UDPRead(conn *net.UDPConn, timeout time.Duration) (ra net.Addr, head *openP
}
head = &openP2PHeader{}
err = binary.Read(bytes.NewReader(buff[:openP2PHeaderSize]), binary.LittleEndian, head)
if err != nil || head.DataLen > uint32(len(buff)-openP2PHeaderSize) {
gLog.Println(LvERROR, "parse p2pheader error:", err)
if err != nil {
gLog.e("parse p2pheader error:%s", err)
return nil, nil, nil, 0, err
}
if head.DataLen > uint32(len(buff)-openP2PHeaderSize) {
gLog.e("parse p2pheader error:%d", ErrHeaderDataLen)
return nil, nil, nil, 0, ErrHeaderDataLen
}
return
}
core/upnp.go
+8 -2
View File
@@ -63,13 +63,15 @@ func Discover() (nat NAT, err error) {
return
}
var n int
socket.SetDeadline(time.Now().Add(3 * time.Second))
_, _, err = socket.ReadFromUDP(answerBytes)
if err != nil {
gLog.Println(LvDEBUG, "UPNP discover error:", err)
gLog.d("UPNP discover error:%s", err)
return
}
for {
socket.SetDeadline(time.Now().Add(3 * time.Second))
n, _, err = socket.ReadFromUDP(answerBytes)
if err != nil {
break
@@ -266,7 +268,11 @@ func soapRequest(url, function, message, domain string) (r *http.Response, err e
// log.Stderr("soapRequest ", req)
r, err = http.DefaultClient.Do(req)
client := &http.Client{
Timeout: 3 * time.Second,
}
r, err = client.Do(req)
if err != nil {
return nil, err
}
core/util_darwin.go
+5 -2
View File
@@ -5,9 +5,12 @@ import (
"syscall"
)
const (
var (
defaultInstallPath = "/usr/local/openp2p"
defaultBinName = "openp2p"
)
const (
defaultBinName = "openp2p"
)
func getOsName() (osName string) {
core/util_freebsd.go
+5 -2
View File
@@ -9,9 +9,12 @@ import (
"syscall"
)
const (
var (
defaultInstallPath = "/usr/local/openp2p"
defaultBinName = "openp2p"
)
const (
defaultBinName = "openp2p"
)
func getOsName() (osName string) {
core/util_linux.go
+5 -2
View File
@@ -10,9 +10,12 @@ import (
"syscall"
)
const (
var (
defaultInstallPath = "/usr/local/openp2p"
defaultBinName = "openp2p"
)
const (
defaultBinName = "openp2p"
)
func getOsName() (osName string) {
core/util_windows.go
+6 -3
View File
@@ -11,9 +11,12 @@ import (
"golang.org/x/sys/windows/registry"
)
const (
var (
defaultInstallPath = "C:\\Program Files\\OpenP2P"
defaultBinName = "openp2p.exe"
)
const (
defaultBinName = "openp2p.exe"
)
func getOsName() (osName string) {
@@ -47,7 +50,7 @@ func setRLimit() error {
func setFirewall() {
fullPath, err := filepath.Abs(os.Args[0])
if err != nil {
gLog.Println(LvERROR, "add firewall error:", err)
gLog.e("add firewall error:%s", err)
return
}
isXP := false