6

diff --git a/Port.go b/Port.go
new file mode 100644 (file)
index 0000000..66112fc
--- /dev/null
+++ b/Port.go
@@ -0,0 +1,36 @@
+package part
+
+type port struct {}
+
+var (
+       port_map map[string]int = make(map[string]int)
+       port_buf chan bool = make(chan bool,1)
+)
+
+func Port() (*port) {
+       return &port{}
+}
+
+func (p *port) Get(key string) int {
+       if p,ok := port_map[key]; ok {return p} 
+       return p.New(key)
+}
+
+func (*port) Del(key string) {
+       delete(port_map,key)
+}
+
+func (*port) New(key string) int {
+       port_buf<-true
+       defer func(){
+               <-port_buf
+       }()
+
+       if p := Sys().GetFreeProt();p != 0{
+               port_map[key] = p
+               return p
+       }
+
+       Logf().E("cant get free port with key:",key)
+       return 0
+}
\ No newline at end of file

diff --git a/Sys.go b/Sys.go
index b95060c1859519ae948ca2e9d87c07a684fc1462..bd8cb67ed9116eb2146c96764ae214089e022659 100644 (file)
--- a/Sys.go
+++ b/Sys.go
@@ -6,6 +6,7 @@ import (
        "os"
        "runtime"
        "time"
+       "net"
        "strconv"
 )
 
@@ -41,4 +42,43 @@ func (this *sys) GetSys(sys string)bool{
 func (this *sys) GetTime() string {
        now := strconv.FormatInt(time.Now().Unix(),10)
        return now[len(now)-4:]
-}
\ No newline at end of file
+}
+
+func (this *sys) GetFreeProt() int {
+       addr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:0")
+       if err != nil {
+               return 0
+       }
+
+       l, err := net.ListenTCP("tcp", addr)
+       if err != nil {
+               return 0
+       }
+       defer l.Close()
+       return l.Addr().(*net.TCPAddr).Port
+}
+
+func (this *sys) GetIntranetIp() string {
+    netInterfaces, err := net.Interfaces()
+    if err != nil {
+        Logf().E("net.Interfaces failed, err:", err.Error())
+        Logf().E("[part]no loacl ip")
+       return "127.0.0.1"
+       }
+ 
+    for i := 0; i < len(netInterfaces); i++ {
+        if (netInterfaces[i].Flags & net.FlagUp) != 0 {
+            addrs, _ := netInterfaces[i].Addrs()
+ 
+            for _, address := range addrs {
+                if ipnet, ok := address.(*net.IPNet); ok && !ipnet.IP.IsLoopback() {
+                    if ipnet.IP.To4() != nil {
+                        return ipnet.IP.String()
+                    }
+                }
+            }
+        }
+    }
+    Logf().E("[part]no loacl ip")
+    return "127.0.0.1"
+}

diff --git a/Zip.go b/Zip.go
new file mode 100644 (file)
index 0000000..288eaa3
--- /dev/null
+++ b/Zip.go
@@ -0,0 +1,135 @@
+package part
+
+import (
+    "sync"
+       "os"
+    "github.com/klauspost/compress/zip"
+       "io"
+    "path/filepath"
+       "strings"
+)
+
+type lzip struct {sync.Mutex}
+
+func Zip() *lzip{
+    return &lzip{}
+}
+
+func (this *lzip) InZip(srcFile string, destZip string) error {
+    this.Lock()
+       defer this.Unlock()
+
+    zipfile, err := os.Create(destZip)
+    if err != nil {
+        return err
+    }
+    defer zipfile.Close()
+
+    archive := zip.NewWriter(zipfile)
+    defer archive.Close()
+
+    if Sys().GetSys("windows") {srcFile=strings.Replace(srcFile,"/","\\",-1)}
+
+    filepath.Walk(srcFile, func(path string, info os.FileInfo, err error) error {
+        if err != nil {
+            return err
+               }
+               
+               var path_cut string = "/"
+               if Sys().GetSys("windows") {path_cut="\\"}
+               
+               if path[len(path)-1:] == path_cut {return nil}
+
+        header, err := zip.FileInfoHeader(info)
+        if err != nil {
+            return err
+        }
+        
+        header.Name = strings.TrimPrefix(path, filepath.Dir(srcFile) + path_cut)
+        // header.Name = path
+        if info.IsDir() {
+            header.Name += path_cut
+        } else {
+            header.Method = zip.Deflate
+        }
+
+        writer, err := archive.CreateHeader(header)
+        if err != nil {
+            return err
+        }
+
+        if ! info.IsDir() {
+            file, err := os.Open(path)
+            if err != nil {
+                return err
+            }
+            defer file.Close()
+            _, err = io.Copy(writer, file)
+        }
+        return err
+    })
+
+    return err
+}
+
+func (this *lzip) UnZip(zipFile string, destDir string) error {
+    this.Lock()
+       defer this.Unlock()
+
+    r, err := zip.OpenReader(zipFile)
+    if err != nil {
+        return err
+    }
+    defer func() {
+        if err := r.Close(); err != nil {
+            panic(err)
+        }
+    }()
+
+    os.MkdirAll(destDir, 0755)
+
+    // Closure to address file descriptors issue with all the deferred .Close() methods
+    extractAndWriteFile := func(f *zip.File) error {
+        rc, err := f.Open()
+        if err != nil {
+            return err
+        }
+        defer func() {
+            if err := rc.Close(); err != nil {
+                panic(err)
+            }
+        }()
+
+        path := filepath.Join(destDir, f.Name)
+
+        if f.FileInfo().IsDir() {
+            os.MkdirAll(path, f.Mode())
+        } else {
+            os.MkdirAll(filepath.Dir(path), f.Mode())
+            f, err := os.OpenFile(path, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, f.Mode())
+            if err != nil {
+                return err
+            }
+            defer func() {
+                if err := f.Close(); err != nil {
+                    panic(err)
+                }
+            }()
+
+            _, err = io.Copy(f, rc)
+            if err != nil {
+                return err
+            }
+        }
+        return nil
+    }
+
+    for _, f := range r.File {
+        err := extractAndWriteFile(f)
+        if err != nil {
+            return err
+        }
+    }
+
+    return nil
+}
\ No newline at end of file

diff --git a/go.mod b/go.mod
index 8bf44a45c16f47ed6ced40f794da98c638938b4d..4cb42a10743836596591762794de2de1c8b5ba98 100644 (file)
--- a/go.mod
+++ b/go.mod
@@ -1,3 +1,5 @@
 module github.com/qydysky/part
 
 go 1.14
+
+require github.com/klauspost/compress v1.10.10

diff --git a/go.sum b/go.sum
new file mode 100644 (file)
index 0000000..9ff177b
--- /dev/null
+++ b/go.sum
@@ -0,0 +1,2 @@
+github.com/klauspost/compress v1.10.10 h1:a/y8CglcM7gLGYmlbP/stPE5sR3hbhFRUjCBfd/0B3I=
+github.com/klauspost/compress v1.10.10/go.mod h1:aoV0uJVorq1K+umq18yTdKaF57EivdYsUV+/s2qKfXs=

diff --git a/linuxwin/linux.go b/linuxwin/linux.go
index c25f7ea12cc2b7fbb51c0f9280288eb4bff691e8..a16c4ae783c1f783061846f45f5b39e752f76fc5 100755 (executable)
--- a/linuxwin/linux.go
+++ b/linuxwin/linux.go
@@ -35,10 +35,11 @@ func PStartf(pro []*exec.Cmd){
     }
 }
 
-func PRun(hide bool,prog string,cmd ...string){
+func PRun(hide bool,prog string,cmd ...string) error {
     p:=exec.Command(prog,cmd...)
     if hide {}
-    p.Run()
+    e:=p.Run()
+    return e
 }
 
 func Cdir()string{
@@ -47,14 +48,15 @@ func Cdir()string{
     return exPath
 }
 
-func PProxy(s, pacUrl string){
+func PProxy(s, pacUrl string) error {
     if s=="off" {
-        PRun(true,"gsettings","set","org.gnome.system.proxy","mode","none");
-        PRun(true,"kwriteconfig5","--file","kioslaverc","--group","'Proxy Settings'","--key","ProxyType","\"0\"");
+        if e:=PRun(true,"gsettings","set","org.gnome.system.proxy","mode","none");e!=nil{return e}
+        if e:=PRun(true,"kwriteconfig5","--file","kioslaverc","--group","Proxy Settings","--key","ProxyType","0");e!=nil{return e}
     }else{
-        PRun(true,"gsettings","set","org.gnome.system.proxy","autoconfig-url",pacUrl);
-        PRun(true,"gsettings","set","org.gnome.system.proxy","mode","auto");
-        PRun(true,"kwriteconfig5","--file","kioslaverc","--group","'Proxy Settings'","--key","ProxyType","\"2\"");
-        PRun(true,"kwriteconfig5","--file","kioslaverc","--group","'Proxy Settings'","--key","Proxy Config Script","\""+pacUrl+"\"");
+        if e:=PRun(true,"gsettings","set","org.gnome.system.proxy","autoconfig-url",pacUrl);e!=nil{return e}
+        if e:=PRun(true,"gsettings","set","org.gnome.system.proxy","mode","auto");e!=nil{return e}
+        if e:=PRun(true,"kwriteconfig5","--file","kioslaverc","--group","Proxy Settings","--key","ProxyType","2");e!=nil{return e}
+        if e:=PRun(true,"kwriteconfig5","--file","kioslaverc","--group","Proxy Settings","--key","Proxy Config Script",pacUrl);e!=nil{return e}
     }
+    return nil
 }

diff --git a/linuxwin/win.go b/linuxwin/win.go
index 792f5e88d7bf01fd8e8ef4d16785206a2b708b16..0de08e66274f25ce098f39379aeacb658cf4da72 100755 (executable)
--- a/linuxwin/win.go
+++ b/linuxwin/win.go
@@ -76,19 +76,21 @@ func PStartf(pro []*exec.Cmd){
     }
 }
 
-func PRun(hide bool,prog string,cmd ...string){
+func PRun(hide bool,prog string,cmd ...string) error {
     p:=exec.Command(prog,cmd...)
     if hide {p.SysProcAttr = &syscall.SysProcAttr{HideWindow: true}}
-    p.Run()
+    return p.Run()
 }
 
-func PProxy(s, pacUrl string){
+func PProxy(s, pacUrl string) error {
     if s=="off"{
-        PRun(true,Cdir()+"/ref/sysproxy64.exe","off")
+        return PRun(true,Cdir()+"/ref/sysproxy64.exe","off")
     }else{
-        PRun(true,Cdir()+"/ref/sysproxy64.exe","pac",pacUrl)
+        return PRun(true,Cdir()+"/ref/sysproxy64.exe","pac",pacUrl)
     }
+    return nil
 }
+
 func Cdir()string{
     dir, _ := os.Executable()
     exPath := filepath.Dir(dir)