Merge branch 'master' of git.b612.me:b612/staros

beep_darwin.go

@@ -0,0 +1,28 @@
+// +build darwin
+
+package staros
+
+import (
+	"os"
+	"os/exec"
+)
+
+var (
+	// DefaultFreq - frequency, in Hz, middle A
+	DefaultFreq = 0.0
+	// DefaultDuration - duration in milliseconds
+	DefaultDuration = 0
+)
+
+// Beep beeps the PC speaker (https://en.wikipedia.org/wiki/PC_speaker).
+func Beep(freq float64, duration int) error {
+	osa, err := exec.LookPath("osascript")
+	if err != nil {
+		// Output the only beep we can
+		_, err = os.Stdout.Write([]byte{7})
+		return err
+	}
+
+	cmd := exec.Command(osa, "-e", `beep`)
+	return cmd.Run()
+}

beep_linux.go

@@ -0,0 +1,138 @@
+// +build linux
+
+package staros
+
+import (
+	"errors"
+	"os"
+	"syscall"
+	"time"
+	"unsafe"
+)
+
+// Constants
+const (
+	// This number represents the fixed frequency of the original PC XT's timer chip, which is approximately 1.193 MHz. This number
+	// is divided with the desired frequency to obtain a counter value, that is subsequently fed into the timer chip, tied to the PC speaker.
+	clockTickRate = 1193180
+
+	// linux/kd.h, start sound generation (0 for off)
+	kiocsound = 0x4B2F
+
+	// linux/input-event-codes.h
+	evSnd   = 0x12 // Event type
+	sndTone = 0x02 // Sound
+)
+
+var (
+	// DefaultFreq - frequency, in Hz, middle A
+	DefaultFreq = 440.0
+	// DefaultDuration - duration in milliseconds
+	DefaultDuration = 200
+)
+
+// inputEvent represents linux/input.h event structure.
+type inputEvent struct {
+	Time  syscall.Timeval // time in seconds since epoch at which event occurred
+	Type  uint16          // event type
+	Code  uint16          // event code related to the event type
+	Value int32           // event value related to the event type
+}
+
+// ioctl system call manipulates the underlying device parameters of special files.
+func ioctl(fd, name, data uintptr) error {
+	_, _, e := syscall.Syscall(syscall.SYS_IOCTL, fd, name, data)
+	if e != 0 {
+		return e
+	}
+
+	return nil
+}
+
+// Beep beeps the PC speaker (https://en.wikipedia.org/wiki/PC_speaker).
+//
+// On Linux it needs permission to access `/dev/tty0` or `/dev/input/by-path/platform-pcspkr-event-spkr` files for writing,
+// and `pcspkr` module must be loaded. User must be in correct groups, usually `input` and/or `tty`.
+//
+// If it can not open device files, it will fallback to sending Bell character (https://en.wikipedia.org/wiki/Bell_character).
+// For bell character in X11 terminals you can enable bell with `xset b on`. For console check `setterm` and `--blength` or `--bfreq` options.
+//
+// On macOS this just sends bell character. Enable `Audible bell` in Terminal --> Preferences --> Settings --> Advanced.
+//
+// On Windows it uses Beep function via syscall.
+//
+// On Web it plays hard coded beep sound.
+func Beep(freq float64, duration int) error {
+	if freq == 0 {
+		freq = DefaultFreq
+	} else if freq > 20000 {
+		freq = 20000
+	} else if freq < 0 {
+		freq = DefaultFreq
+	}
+
+	if duration == 0 {
+		duration = DefaultDuration
+	}
+
+	period := int(float64(clockTickRate) / freq)
+
+	var evdev bool
+
+	f, err := os.OpenFile("/dev/tty0", os.O_WRONLY, 0644)
+	if err != nil {
+		e := err
+		f, err = os.OpenFile("/dev/input/by-path/platform-pcspkr-event-spkr", os.O_WRONLY, 0644)
+		if err != nil {
+			e = errors.New("beeep: " + e.Error() + "; " + err.Error())
+
+			// Output the only beep we can
+			_, err = os.Stdout.Write([]byte{7})
+			if err != nil {
+				return errors.New(e.Error() + "; " + err.Error())
+			}
+
+			return nil
+		}
+
+		evdev = true
+	}
+
+	defer f.Close()
+
+	if evdev { // Use Linux evdev API
+		ev := inputEvent{}
+		ev.Type = evSnd
+		ev.Code = sndTone
+		ev.Value = int32(freq)
+
+		d := *(*[unsafe.Sizeof(ev)]byte)(unsafe.Pointer(&ev))
+
+		// Start beep
+		f.Write(d[:])
+
+		time.Sleep(time.Duration(duration) * time.Millisecond)
+
+		ev.Value = 0
+		d = *(*[unsafe.Sizeof(ev)]byte)(unsafe.Pointer(&ev))
+
+		// Stop beep
+		f.Write(d[:])
+	} else { // Use ioctl
+		// Start beep
+		err = ioctl(f.Fd(), kiocsound, uintptr(period))
+		if err != nil {
+			return err
+		}
+
+		time.Sleep(time.Duration(duration) * time.Millisecond)
+
+		// Stop beep
+		err = ioctl(f.Fd(), kiocsound, uintptr(0))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}

beep_test.go

@@ -0,0 +1,37 @@
+package staros
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+const (
+	rat float64 = 1.059463094 //2^(1/12)
+	C   float64 = 493.8833013 * rat
+	CU          = C * rat * rat
+	D           = CU * rat
+	DU          = D * rat
+	E           = DU * rat
+	F           = E * rat
+	FU          = F * rat
+	G           = FU * rat
+	GU          = G * rat
+	A           = GU * rat
+	AU          = A * rat
+	B           = AU * rat
+)
+
+func beepMusic(qual ...float64) {
+	for _, v := range qual {
+		fmt.Println(v)
+		Beep(v, 700)
+		time.Sleep(time.Millisecond * 1000)
+	}
+}
+
+func Test_Music(t *testing.T) {
+	beepMusic(G, D, A, AU, A, G, F, D, DU, D, C, D, AU/2, C, G/2, C, D)
+	time.Sleep(time.Second * 3)
+	beepMusic(D,AU,A,G,A,D*2,F*2,G*2,F*2,D*2,D*2,C*2,D*2,DU*2,D*2,AU,A,E,G,FU)
+}

beep_windows.go

@@ -0,0 +1,41 @@
+// +build windows
+
+package staros
+
+import (
+	"syscall"
+)
+
+var (
+	// DefaultFreq - frequency, in Hz, middle A
+	DefaultFreq = 587.0
+	// DefaultDuration - duration in milliseconds
+	DefaultDuration = 500
+)
+
+// Beep beeps the PC speaker (https://en.wikipedia.org/wiki/PC_speaker).
+func Beep(freq float64, duration int) error {
+	if freq == 0 {
+		freq = DefaultFreq
+	} else if freq > 32767 {
+		freq = 32767
+	} else if freq < 37 {
+		freq = DefaultFreq
+	}
+
+	if duration == 0 {
+		duration = DefaultDuration
+	}
+
+	kernel32, _ := syscall.LoadLibrary("kernel32.dll")
+	beep32, _ := syscall.GetProcAddress(kernel32, "Beep")
+
+	defer syscall.FreeLibrary(kernel32)
+
+	_, _, e := syscall.Syscall(uintptr(beep32), uintptr(2), uintptr(int(freq)), uintptr(duration), 0)
+	if e != 0 {
+		return e
+	}
+
+	return nil
+}

files.go

@@ -1,6 +1,18 @@
 package staros
 
-import "os"
+import (
+	"errors"
+	"os"
+)
+
+var ERR_ALREADY_LOCKED = errors.New("ALREADY LOCKED")
+var ERR_TIMEOUT = errors.New("TIME OUT")
+
+func NewFileLock(filepath string) FileLock {
+	return FileLock{
+		filepath: filepath,
+	}
+}
 
 // 检测文件/文件夹是否存在
 func Exists(path string) bool {

files_darwin.go

@@ -3,11 +3,81 @@
 package staros
 
 import (
+	"b612.me/stario"
 	"os"
 	"syscall"
 	"time"
 )
 
+type FileLock struct {
+	fd       int
+	filepath string
+}
+
+func (f *FileLock) openFileForLock() error {
+	fd, err := syscall.Open(f.filepath, syscall.O_CREAT|syscall.O_RDONLY, 0600)
+	if err != nil {
+		return err
+	}
+	f.filepath = f.filepath
+	f.fd = fd
+	return nil
+}
+
+func (f *FileLock) Lock(Exclusive bool) error {
+	var lockType int
+	if Exclusive {
+		lockType = syscall.LOCK_EX
+	} else {
+		lockType = syscall.LOCK_SH
+	}
+	if err := f.openFileForLock(); err != nil {
+		return err
+	}
+	return syscall.Flock(f.fd, lockType)
+}
+
+func (f *FileLock) LockNoBlocking(Exclusive bool) error {
+	var lockType int
+	if Exclusive {
+		lockType = syscall.LOCK_EX
+	} else {
+		lockType = syscall.LOCK_SH
+	}
+	if err := f.openFileForLock(); err != nil {
+		return err
+	}
+	err := syscall.Flock(f.fd, lockType|syscall.LOCK_NB)
+	if err != nil {
+		syscall.Close(f.fd)
+		if err == syscall.EWOULDBLOCK {
+			return ERR_ALREADY_LOCKED
+		}
+	}
+	return err
+}
+
+func (f *FileLock) Unlock() error {
+	err := syscall.Flock(f.fd, syscall.LOCK_UN)
+	if err != nil {
+		return err
+	}
+	return syscall.Close(f.fd)
+}
+
+func (f *FileLock) LockWithTimeout(tm time.Duration, Exclusive bool) error {
+	return stario.WaitUntilTimeout(tm, func(tmout chan struct{}) error {
+		err := f.Lock(Exclusive)
+		select {
+		case <-tmout:
+			f.Unlock()
+			return nil
+		default:
+		}
+		return err
+	})
+}
+
 func timespecToTime(ts syscall.Timespec) time.Time {
 	return time.Unix(int64(ts.Sec), int64(ts.Nsec))
 }

files_test.go

@@ -0,0 +1,23 @@
+package staros
+
+import (
+	"fmt"
+	"os"
+	"testing"
+	"time"
+)
+
+func Test_FileLock(t *testing.T) {
+	filename := "./test.file"
+	lock := NewFileLock(filename)
+	lock2 := NewFileLock(filename)
+	fmt.Println("lock1", lock.LockNoBlocking(false))
+	time.Sleep(time.Second)
+	fmt.Println("lock2", lock2.LockWithTimeout(time.Second*5, false))
+	fmt.Println("unlock1", lock.Unlock())
+	time.Sleep(time.Second)
+	fmt.Println("unlock2", lock2.Unlock())
+	fmt.Println("lock2", lock2.LockNoBlocking(true))
+	fmt.Println("unlock2", lock2.Unlock())
+	os.Remove(filename)
+}

files_unix.go

@@ -3,11 +3,17 @@
 package staros
 
 import (
+	"b612.me/stario"
 	"os"
 	"syscall"
 	"time"
 )
 
+type FileLock struct {
+	fd       int
+	filepath string
+}
+
 func timespecToTime(ts syscall.Timespec) time.Time {
 	return time.Unix(int64(ts.Sec), int64(ts.Nsec))
 }
@@ -19,3 +25,67 @@ func GetFileCreationTime(fileinfo os.FileInfo) time.Time {
 func GetFileAccessTime(fileinfo os.FileInfo) time.Time {
 	return timespecToTime(fileinfo.Sys().(*syscall.Stat_t).Atim)
 }
+
+func (f *FileLock) openFileForLock() error {
+	fd, err := syscall.Open(f.filepath, syscall.O_CREAT|syscall.O_RDONLY, 0600)
+	if err != nil {
+		return err
+	}
+	f.filepath = f.filepath
+	f.fd = fd
+	return nil
+}
+
+func (f *FileLock) Lock(Exclusive bool) error {
+	var lockType int
+	if Exclusive {
+		lockType = syscall.LOCK_EX
+	} else {
+		lockType = syscall.LOCK_SH
+	}
+	if err := f.openFileForLock(); err != nil {
+		return err
+	}
+	return syscall.Flock(f.fd, lockType)
+}
+
+func (f *FileLock) LockNoBlocking(Exclusive bool) error {
+	var lockType int
+	if Exclusive {
+		lockType = syscall.LOCK_EX
+	} else {
+		lockType = syscall.LOCK_SH
+	}
+	if err := f.openFileForLock(); err != nil {
+		return err
+	}
+	err := syscall.Flock(f.fd, lockType|syscall.LOCK_NB)
+	if err != nil {
+		syscall.Close(f.fd)
+		if err == syscall.EWOULDBLOCK {
+			return ERR_ALREADY_LOCKED
+		}
+	}
+	return err
+}
+
+func (f *FileLock) Unlock() error {
+	err := syscall.Flock(f.fd, syscall.LOCK_UN)
+	if err != nil {
+		return err
+	}
+	return syscall.Close(f.fd)
+}
+
+func (f *FileLock) LockWithTimeout(tm time.Duration, Exclusive bool) error {
+	return stario.WaitUntilTimeout(tm, func(tmout chan struct{}) error {
+		err := f.Lock(Exclusive)
+		select {
+		case <-tmout:
+			f.Unlock()
+			return nil
+		default:
+		}
+		return err
+	})
+}

files_windows.go

@@ -3,11 +3,17 @@
 package staros
 
 import (
+	"b612.me/win32api"
 	"os"
 	"syscall"
 	"time"
 )
 
+type FileLock struct {
+	filepath string
+	handle   win32api.HANDLE
+}
+
 func GetFileCreationTime(fileinfo os.FileInfo) time.Time {
 	d := fileinfo.Sys().(*syscall.Win32FileAttributeData)
 	return time.Unix(0, d.CreationTime.Nanoseconds())
@@ -18,10 +24,100 @@ func GetFileAccessTime(fileinfo os.FileInfo) time.Time {
 	return time.Unix(0, d.LastAccessTime.Nanoseconds())
 }
 
-func SetFileTimes(file *os.File,info os.FileInfo) {
+func SetFileTimes(file *os.File, info os.FileInfo) {
 
 }
 
 func SetFileTimesbyTime(file *os.File) {
 
 }
+
+func (f *FileLock) openFileForLock() error {
+	name, err := syscall.UTF16PtrFromString(f.filepath)
+	if err != nil {
+		return err
+	}
+	handle, err := syscall.CreateFile(
+		name,
+		syscall.GENERIC_READ,
+		syscall.FILE_SHARE_READ,
+		nil,
+		syscall.OPEN_ALWAYS,
+		syscall.FILE_FLAG_OVERLAPPED|0x00000080,
+		0)
+	if err != nil {
+		return err
+	}
+	f.handle = win32api.HANDLE(handle)
+	return nil
+}
+
+func (f *FileLock) lockForTimeout(timeout time.Duration, lockType win32api.DWORD) error {
+	var err error
+	if err = f.openFileForLock(); err != nil {
+		return err
+	}
+	event, err := win32api.CreateEventW(nil, true, false, nil)
+	if err != nil {
+		return err
+	}
+	myEvent := &syscall.Overlapped{HEvent: syscall.Handle(event)}
+	defer syscall.CloseHandle(myEvent.HEvent)
+	_, err = win32api.LockFileEx(f.handle, lockType, 0, 1, 0, myEvent)
+	if err == nil {
+		return nil
+	}
+	if err != syscall.ERROR_IO_PENDING {
+		return err
+	}
+	millis := uint32(syscall.INFINITE)
+	if timeout >= 0 {
+		millis = uint32(timeout.Nanoseconds() / 1000000)
+	}
+	s, err := syscall.WaitForSingleObject(myEvent.HEvent, millis)
+	switch s {
+	case syscall.WAIT_OBJECT_0:
+		// success!
+		return nil
+	case syscall.WAIT_TIMEOUT:
+		f.Unlock()
+		return ERR_TIMEOUT
+	default:
+		f.Unlock()
+		return err
+	}
+}
+
+func (f *FileLock) Lock(Exclusive bool) error {
+	var lockType win32api.DWORD
+	if Exclusive {
+		lockType = win32api.LOCKFILE_EXCLUSIVE_LOCK
+	} else {
+		lockType = 0
+	}
+	return f.lockForTimeout(0, lockType)
+}
+
+func (f *FileLock) LockWithTimeout(tm time.Duration, Exclusive bool) error {
+	var lockType win32api.DWORD
+	if Exclusive {
+		lockType = win32api.LOCKFILE_EXCLUSIVE_LOCK
+	} else {
+		lockType = 0
+	}
+	return f.lockForTimeout(tm, lockType)
+}
+
+func (f *FileLock) LockNoBlocking(Exclusive bool) error {
+	var lockType win32api.DWORD
+	if Exclusive {
+		lockType = win32api.LOCKFILE_EXCLUSIVE_LOCK
+	} else {
+		lockType = 0
+	}
+	return f.lockForTimeout(0, lockType|win32api.LOCKFILE_FAIL_IMMEDIATELY)
+}
+
+func (f *FileLock) Unlock() error {
+	return syscall.Close(syscall.Handle(f.handle))
+}

go.mod

@@ -0,0 +1,10 @@
+module b612.me/staros
+
+go 1.16
+
+require (
+	b612.me/stario v0.0.10
+	b612.me/win32api v0.0.2
+	b612.me/wincmd v0.0.4
+	golang.org/x/sys v0.24.0
+)

go.sum

@@ -0,0 +1,75 @@
+b612.me/stario v0.0.10 h1:+cIyiDCBCjUfodMJDp4FLs+2E1jo7YENkN+sMEe6550=
+b612.me/stario v0.0.10/go.mod h1:1Owmu9jzKWgs4VsmeI8YWlGwLrCwPNM/bYpxkyn+MMk=
+b612.me/win32api v0.0.2 h1:5PwvPR5fYs3a/v+LjYdtRif+5Q04zRGLTVxmCYNjCpA=
+b612.me/win32api v0.0.2/go.mod h1:sj66sFJDKElEjOR+0YhdSW6b4kq4jsXu4T5/Hnpyot0=
+b612.me/wincmd v0.0.4 h1:fv9p1V8mw2HdUjaoZBWZy0T41JftueyLxAuch1MgtdI=
+b612.me/wincmd v0.0.4/go.mod h1:o3yPoE+DpVPHGKl/q1WT1C8OaIVwHEnpeNgMFqzlwD8=
+github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY=
+github.com/yuin/goldmark v1.4.13/go.mod h1:6yULJ656Px+3vBD8DxQVa3kxgyrAnzto9xy5taEt/CY=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20210921155107-089bfa567519/go.mod h1:GvvjBRRGRdwPK5ydBHafDWAxML/pGHZbMvKqRZ5+Abc=
+golang.org/x/crypto v0.13.0/go.mod h1:y6Z2r+Rw4iayiXXAIxJIDAJ1zMW4yaTpebo8fPOliYc=
+golang.org/x/crypto v0.19.0/go.mod h1:Iy9bg/ha4yyC70EfRS8jz+B6ybOBKMaSxLj6P6oBDfU=
+golang.org/x/crypto v0.23.0/go.mod h1:CKFgDieR+mRhux2Lsu27y0fO304Db0wZe70UKqHu0v8=
+golang.org/x/crypto v0.26.0 h1:RrRspgV4mU+YwB4FYnuBoKsUapNIL5cohGAmSH3azsw=
+golang.org/x/crypto v0.26.0/go.mod h1:GY7jblb9wI+FOo5y8/S2oY4zWP07AkOJ4+jxCqdqn54=
+golang.org/x/mod v0.6.0-dev.0.20220419223038-86c51ed26bb4/go.mod h1:jJ57K6gSWd91VN4djpZkiMVwK6gcyfeH4XE8wZrZaV4=
+golang.org/x/mod v0.8.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.12.0/go.mod h1:iBbtSCu2XBx23ZKBPSOrRkjjQPZFPuis4dIYUhu/chs=
+golang.org/x/mod v0.15.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/mod v0.17.0/go.mod h1:hTbmBsO62+eylJbnUtE2MGJUyE7QWk4xUqPFrRgJ+7c=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/net v0.0.0-20210226172049-e18ecbb05110/go.mod h1:m0MpNAwzfU5UDzcl9v0D8zg8gWTRqZa9RBIspLL5mdg=
+golang.org/x/net v0.0.0-20220722155237-a158d28d115b/go.mod h1:XRhObCWvk6IyKnWLug+ECip1KBveYUHfp+8e9klMJ9c=
+golang.org/x/net v0.6.0/go.mod h1:2Tu9+aMcznHK/AK1HMvgo6xiTLG5rD5rZLDS+rp2Bjs=
+golang.org/x/net v0.10.0/go.mod h1:0qNGK6F8kojg2nk9dLZ2mShWaEBan6FAoqfSigmmuDg=
+golang.org/x/net v0.15.0/go.mod h1:idbUs1IY1+zTqbi8yxTbhexhEEk5ur9LInksu6HrEpk=
+golang.org/x/net v0.21.0/go.mod h1:bIjVDfnllIU7BJ2DNgfnXvpSvtn8VRwhlsaeUTyUS44=
+golang.org/x/net v0.25.0/go.mod h1:JkAGAh7GEvH74S6FOH42FLoXpXbE/aqXSrIQjXgsiwM=
+golang.org/x/sync v0.0.0-20190423024810-112230192c58/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20220722155255-886fb9371eb4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.1.0/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.3.0/go.mod h1:FU7BRWz2tNW+3quACPkgCx/L+uEAv1htQ0V83Z9Rj+Y=
+golang.org/x/sync v0.6.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.7.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sync v0.8.0/go.mod h1:Czt+wKu1gCyEFDUtn0jG5QVvpJ6rzVqr5aXyt9drQfk=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20201119102817-f84b799fce68/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.0.0-20210615035016-665e8c7367d1/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220520151302-bc2c85ada10a/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.0.0-20220722155257-8c9f86f7a55f/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.8.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.12.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg=
+golang.org/x/sys v0.17.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.18.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.20.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.23.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/sys v0.24.0 h1:Twjiwq9dn6R1fQcyiK+wQyHWfaz/BJB+YIpzU/Cv3Xg=
+golang.org/x/sys v0.24.0/go.mod h1:/VUhepiaJMQUp4+oa/7Zr1D23ma6VTLIYjOOTFZPUcA=
+golang.org/x/telemetry v0.0.0-20240228155512-f48c80bd79b2/go.mod h1:TeRTkGYfJXctD9OcfyVLyj2J3IxLnKwHJR8f4D8a3YE=
+golang.org/x/term v0.0.0-20201126162022-7de9c90e9dd1/go.mod h1:bj7SfCRtBDWHUb9snDiAeCFNEtKQo2Wmx5Cou7ajbmo=
+golang.org/x/term v0.0.0-20210927222741-03fcf44c2211/go.mod h1:jbD1KX2456YbFQfuXm/mYQcufACuNUgVhRMnK/tPxf8=
+golang.org/x/term v0.5.0/go.mod h1:jMB1sMXY+tzblOD4FWmEbocvup2/aLOaQEp7JmGp78k=
+golang.org/x/term v0.8.0/go.mod h1:xPskH00ivmX89bAKVGSKKtLOWNx2+17Eiy94tnKShWo=
+golang.org/x/term v0.12.0/go.mod h1:owVbMEjm3cBLCHdkQu9b1opXd4ETQWc3BhuQGKgXgvU=
+golang.org/x/term v0.17.0/go.mod h1:lLRBjIVuehSbZlaOtGMbcMncT+aqLLLmKrsjNrUguwk=
+golang.org/x/term v0.20.0/go.mod h1:8UkIAJTvZgivsXaD6/pH6U9ecQzZ45awqEOzuCvwpFY=
+golang.org/x/term v0.23.0 h1:F6D4vR+EHoL9/sWAWgAR1H2DcHr4PareCbAaCo1RpuU=
+golang.org/x/term v0.23.0/go.mod h1:DgV24QBUrK6jhZXl+20l6UWznPlwAHm1Q1mGHtydmSk=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/text v0.3.3/go.mod h1:5Zoc/QRtKVWzQhOtBMvqHzDpF6irO9z98xDceosuGiQ=
+golang.org/x/text v0.3.7/go.mod h1:u+2+/6zg+i71rQMx5EYifcz6MCKuco9NR6JIITiCfzQ=
+golang.org/x/text v0.7.0/go.mod h1:mrYo+phRRbMaCq/xk9113O4dZlRixOauAjOtrjsXDZ8=
+golang.org/x/text v0.9.0/go.mod h1:e1OnstbJyHTd6l/uOt8jFFHp6TRDWZR/bV3emEE/zU8=
+golang.org/x/text v0.13.0/go.mod h1:TvPlkZtksWOMsz7fbANvkp4WM8x/WCo/om8BMLbz+aE=
+golang.org/x/text v0.14.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.15.0/go.mod h1:18ZOQIKpY8NJVqYksKHtTdi31H5itFRjB5/qKTNYzSU=
+golang.org/x/text v0.17.0/go.mod h1:BuEKDfySbSR4drPmRPG/7iBdf8hvFMuRexcpahXilzY=
+golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20191119224855-298f0cb1881e/go.mod h1:b+2E5dAYhXwXZwtnZ6UAqBI28+e2cm9otk0dWdXHAEo=
+golang.org/x/tools v0.1.12/go.mod h1:hNGJHUnrk76NpqgfD5Aqm5Crs+Hm0VOH/i9J2+nxYbc=
+golang.org/x/tools v0.6.0/go.mod h1:Xwgl3UAJ/d3gWutnCtw505GrjyAbvKui8lOU390QaIU=
+golang.org/x/tools v0.13.0/go.mod h1:HvlwmtVNQAhOuCjW7xxvovg8wbNq7LwfXh/k7wXUl58=
+golang.org/x/tools v0.21.1-0.20240508182429-e35e4ccd0d2d/go.mod h1:aiJjzUbINMkxbQROHiO6hDPo2LHcIPhhQsa9DLh0yGk=
+golang.org/x/xerrors v0.0.0-20190717185122-a985d3407aa7/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0=

hosts/hosts_test.go

@@ -6,7 +6,149 @@ import (
 )
 
 func Test_Hosts(t *testing.T) {
-	//RemoveHostbyIp("192.168.222.33")
+	var h = NewHosts()
-	Parse()
+	err := h.Parse("./test_hosts.txt")
-	fmt.Println(GetAllListbyIp())
+	if err != nil {
+		t.Error(err)
+	}
+	next := h.firstUid
+	for next != 0 {
+		node, _ := h.GetNode(next)
+		fmt.Printf("Last %d, Next: %d, IP: %s, Hosts: %s, Comment: %s\n", node.LastUID(), node.NextUID(), node.IP(), node.Hosts(), node.Comment())
+		next = node.NextUID()
+	}
+	data := h.ListHostsByIP("11.22.33.44")
+	if len(data) != 2 {
+		t.Error("Expected 2, got ", len(data))
+	} else {
+		t.Log(data)
+	}
+
+	data = h.ListIPsByHost("dns.b612.me")
+	if len(data) < 1 || data[0] != "4.5.6.7" {
+		t.Error("Expected 4.5.6.7, got ", data)
+	} else {
+		t.Log(data)
+	}
+
+	err = h.RemoveHosts("dns.b612.me")
+	if err != nil {
+		t.Error(err)
+	}
+	data = h.ListIPsByHost("dns.b612.me")
+	if len(data) > 0 {
+		t.Error("Expected 0, got ", len(data))
+	} else {
+		t.Log(data)
+	}
+
+	err = h.RemoveHosts("test.dns.set.b612.me")
+	if err != nil {
+		t.Error(err)
+	}
+
+	data = h.ListIPsByHost("remove.b612.me")
+	if len(data) < 1 || data[0] != "11.22.33.44" {
+		t.Error("Expected 11.22.33.44, got ", data)
+	} else {
+		t.Log(data)
+	}
+
+	nodes := h.ListByIP("11.22.33.44")
+	if nodes == nil {
+		t.Error("Expected not nil, got ", nodes)
+	} else {
+		t.Log(nodes)
+	}
+
+	nodes[0].AddHosts("hello.b612.me")
+	err = h.UpdateNode(nodes[0])
+	if err != nil {
+		t.Error(err)
+	}
+	data = h.ListIPsByHost("hello.b612.me")
+	if len(data) < 1 || data[0] != "11.22.33.44" {
+		t.Error("Not Expected Data", data)
+	} else {
+		t.Log(data)
+	}
+	insertNode := new(HostNode)
+	insertNode.SetIP("11.11.11.11")
+	insertNode.SetHosts("insert.b612.me")
+	insertNode.SetComment("Insert Node")
+	insertNode.SetNextUID(nodes[0].UID())
+	insertNode.SetLastUID(nodes[0].LastUID())
+	err = h.InsertNode(insertNode)
+	if err != nil {
+		t.Error(err)
+	}
+	data = h.ListIPsByHost("insert.b612.me")
+	if len(data) < 1 || data[0] != "11.11.11.11" {
+		t.Error("Expected 11.11.11.11 got ", data)
+	} else {
+		t.Log(data)
+	}
+
+	err = h.SaveAs("./test_hosts_01.txt")
+	if err != nil {
+		t.Error(err)
+	}
+
+	err = h.DeleteNode(insertNode)
+	if err != nil {
+		t.Error(err)
+	}
+	data = h.ListIPsByHost("insert.b612.me")
+	if len(data) > 0 {
+		t.Error("Expected 0 got ", data)
+	} else {
+		t.Log(data)
+	}
+
+	for i := 0; i < 100; i++ {
+		err = h.RemoveHosts("release-ftpd")
+		if err != nil {
+			t.Error(err)
+		}
+		err = h.AddHosts("2.3.4.9", "release-ftpd")
+		if err != nil {
+			t.Error(err)
+		}
+	}
+
+	err = h.SetHostIPs("ssh.b612.me", "9.9.9.9")
+	if err != nil {
+		t.Error(err)
+	}
+
+	data = h.ListIPsByHost("ssh.b612.me")
+	if len(data) == 0 {
+		t.Error("Expected 1 got ", data)
+	} else {
+		t.Log(data)
+	}
+
+	err = h.SetIPHosts("10.10.10.10", "ssh.b612.me", "ssr.b612.me")
+	if len(data) == 0 {
+		t.Error("Expected 1 got ", data)
+	}
+
+	err = h.SaveAs("./test_hosts_02.txt")
+	if err != nil {
+		t.Error(err)
+	}
+}
+
+func BenchmarkAddHosts(b *testing.B) {
+	var h = NewHosts()
+	err := h.Parse("./test_hosts.txt")
+	if err != nil {
+		b.Error(err)
+	}
+	for i := 0; i < b.N; i++ {
+		err = h.AddHosts("1.3.4.5", "test.b612.me")
+		if err != nil {
+			b.Error(err)
+		}
+	}
 }

hosts/test_hosts.txt

@@ -0,0 +1,23 @@
+#hosts         This file describes a number of hostname-to-address
+#mappings for the TCP/IP subsystem.  It is mostly
+#used at boot time, when no name servers are running.
+#On small systems, this file can be used instead of a
+#"named" name server.
+#Syntax:
+#IP-Address  Full-Qualifie
+#special IPv6 addre
+127.0.0.1 localhost
+127.0.0.1 b612
+8.8.8.8     ssh.b612.me
+#special IPv6 addresses
+::1 localhost ipv6-localhost ipv6-loopback
+fe00::0 ipv6-localnet
+ff00::0 ipv6-mcastprefix
+ff02::1 ipv6-allnodes
+ff02::2 ipv6-allrouters
+ff02::3 ipv6-allhosts
+1.2.3.4 ssh.b612.me
+4.5.6.7 dns.b612.me
+8.9.10.11 release-ftpd
+11.22.33.44 test.dns.set.b612.me  remove.b612.me
+4.5.6.7 game.b612.me

network_unix.go

@@ -1,3 +1,4 @@
+//go:build !windows
 // +build !windows
 
 package staros
@@ -67,7 +68,13 @@ func NetSpeeds(duration time.Duration) ([]NetSpeed, error) {
 	for k, v := range list1 {
 		recv := float64(list2[k].RecvBytes-v.RecvBytes) / duration.Seconds()
 		send := float64(list2[k].SendBytes-v.SendBytes) / duration.Seconds()
-		res = append(res, NetSpeed{v.Name, recv, send})
+		res = append(res, NetSpeed{
+			Name:       v.Name,
+			RecvSpeeds: recv,
+			SendSpeeds: send,
+			RecvBytes:  list2[k].RecvBytes,
+			SendBytes:  list2[k].SendBytes,
+		})
 	}
 	return res, nil
 }
@@ -87,17 +94,29 @@ func NetSpeedsByName(duration time.Duration, name string) (NetSpeed, error) {
 
 // NetConnections return all TCP/UDP/UNIX DOMAIN SOCKET Connections
 // if your uid != 0 ,and analysePid==true ,you should have CAP_SYS_PRTACE and CAP_DAC_OVERRIDE/CAP_DAC_READ_SEARCH Caps
-func NetConnections(analysePid bool) ([]NetConn, error) {
+func NetConnections(analysePid bool, types string) ([]NetConn, error) {
 	var result []NetConn
 	var inodeMap map[string]int64
 	var err error
-	fileList := []string{
+	var fileList []string
+	if types == "" || strings.Contains(strings.ToLower(types), "all") {
+		fileList = []string{
 			"/proc/net/tcp",
 			"/proc/net/tcp6",
 			"/proc/net/udp",
 			"/proc/net/udp6",
 			"/proc/net/unix",
 		}
+	}
+	if strings.Contains(strings.ToLower(types), "tcp") {
+		fileList = append(fileList, "/proc/net/tcp", "/proc/net/tcp6")
+	}
+	if strings.Contains(strings.ToLower(types), "udp") {
+		fileList = append(fileList, "/proc/net/udp", "/proc/net/udp6")
+	}
+	if strings.Contains(strings.ToLower(types), "unix") {
+		fileList = append(fileList, "/proc/net/unix")
+	}
 	if analysePid {
 		inodeMap, err = GetInodeMap()
 		if err != nil {
@@ -135,6 +154,9 @@ func GetInodeMap() (map[string]int64, error) {
 				if err != nil {
 					continue
 				}
+				if !strings.Contains(socket, "socket") {
+					continue
+				}
 				start := strings.Index(socket, "[")
 				if start < 0 {
 					continue
@@ -147,7 +169,7 @@ func GetInodeMap() (map[string]int64, error) {
 			}
 		}
 	}
-	return nil, err
+	return res, err
 }
 
 func analyseNetFiles(data []byte, inodeMap map[string]int64, typed string) ([]NetConn, error) {
@@ -177,6 +199,60 @@ func analyseNetFiles(data []byte, inodeMap map[string]int64, typed string) ([]Ne
 		}
 		res.RemoteAddr = ip
 		res.RemotePort = port
+		//connection state
+		if strings.Contains(typed, "tcp") {
+			state, err := strconv.ParseInt(strings.TrimSpace(v[3]), 16, 64)
+			if err != nil {
+				return result, err
+			}
+			res.Status = TCP_STATE[state]
+		}
+		txrx_queue := strings.Split(strings.TrimSpace(v[4]), ":")
+		if len(txrx_queue) != 2 {
+			return result, errors.New("not a valid net file")
+		}
+		tx_queue, err := strconv.ParseInt(txrx_queue[0], 16, 64)
+		if err != nil {
+			return result, err
+		}
+		res.TX_Queue = tx_queue
+		rx_queue, err := strconv.ParseInt(txrx_queue[1], 16, 64)
+		if err != nil {
+			return result, err
+		}
+		res.RX_Queue = rx_queue
+		timer := strings.Split(strings.TrimSpace(v[5]), ":")
+		if len(timer) != 2 {
+			return result, errors.New("not a valid net file")
+		}
+		switch timer[0] {
+		case "00":
+			res.TimerActive = "NO_TIMER"
+		case "01":
+			//重传定时器
+			res.TimerActive = "RETRANSMIT"
+		case "02":
+			//连接定时器、FIN_WAIT_2定时器或TCP保活定时器
+			res.TimerActive = "KEEPALIVE"
+		case "03":
+			//TIME_WAIT定时器
+			res.TimerActive = "TIME_WAIT"
+		case "04":
+			//持续定时器
+			res.TimerActive = "ZERO_WINDOW_PROBE"
+		default:
+			res.TimerActive = "UNKNOWN"
+		}
+		timerJif, err := strconv.ParseInt(timer[1], 16, 64)
+		if err != nil {
+			return result, err
+		}
+		res.TimerJiffies = timerJif
+		timerCnt, err := strconv.ParseInt(strings.TrimSpace(v[6]), 16, 64)
+		if err != nil {
+			return result, err
+		}
+		res.RtoTimer = timerCnt
 		res.Uid, err = strconv.ParseInt(v[7], 10, 64)
 		if err != nil {
 			return result, err
@@ -229,7 +305,7 @@ func analyseUnixFiles(data []byte, inodeMap map[string]int64, typed string) ([]N
 				res.Pid = -1
 			} else {
 				_, ok := pidMap[res.Pid]
-				if !ok {
+				if !ok || pidMap[res.Pid] == nil {
 					tmp, err := FindProcessByPid(res.Pid)
 					if err != nil {
 						pidMap[res.Pid] = nil
@@ -237,10 +313,12 @@ func analyseUnixFiles(data []byte, inodeMap map[string]int64, typed string) ([]N
 						pidMap[res.Pid] = &tmp
 					}
 				}
+				if pidMap[res.Pid] != nil {
 					res.Uid = int64(pidMap[res.Pid].RUID)
 					res.Process = pidMap[res.Pid]
 				}
 			}
+		}
 		res.Typed = typed
 		result = append(result, res)
 	}

os_unix.go

@@ -3,6 +3,7 @@
 package staros
 
 import (
+	"bytes"
 	"fmt"
 	"io/ioutil"
 	"os/user"
@@ -12,6 +13,8 @@ import (
 	"time"
 )
 
+var clockTicks = 100 // default value
+
 // StartTime 开机时间
 func StartTime() time.Time {
 	tmp, _ := readAsString("/proc/stat")
@@ -64,8 +67,8 @@ func getCPUSample() (idle, total uint64) {
 					fmt.Println("Error: ", i, fields[i], err)
 				}
 				total += val          // tally up all the numbers to get total ticks
-				if i == 4 {  // idle is the 5th field in the cpu line
+				if i == 4 || i == 5 { // idle is the 5th field in the cpu line
-					idle = val
+					idle += val
 				}
 			}
 			return
@@ -73,6 +76,55 @@ func getCPUSample() (idle, total uint64) {
 	}
 	return
 }
+func splitProcStat(content []byte) []string {
+	nameStart := bytes.IndexByte(content, '(')
+	nameEnd := bytes.LastIndexByte(content, ')')
+	restFields := strings.Fields(string(content[nameEnd+2:])) // +2 skip ') '
+	name := content[nameStart+1 : nameEnd]
+	pid := strings.TrimSpace(string(content[:nameStart]))
+	fields := make([]string, 3, len(restFields)+3)
+	fields[1] = string(pid)
+	fields[2] = string(name)
+	fields = append(fields, restFields...)
+	return fields
+}
+
+func getCPUSampleByPid(pid int) float64 {
+	contents, err := ioutil.ReadFile("/proc/" + strconv.Itoa(pid) + "/stat")
+	if err != nil {
+		return 0
+	}
+	fields := splitProcStat(contents)
+	utime, err := strconv.ParseFloat(fields[14], 64)
+	if err != nil {
+		return 0
+	}
+
+	stime, err := strconv.ParseFloat(fields[15], 64)
+	if err != nil {
+		return 0
+	}
+
+	// There is no such thing as iotime in stat file.  As an approximation, we
+	// will use delayacct_blkio_ticks (aggregated block I/O delays, as per Linux
+	// docs).  Note: I am assuming at least Linux 2.6.18
+	var iotime float64
+	if len(fields) > 42 {
+		iotime, err = strconv.ParseFloat(fields[42], 64)
+		if err != nil {
+			iotime = 0 // Ancient linux version, most likely
+		}
+	} else {
+		iotime = 0 // e.g. SmartOS containers
+	}
+	return utime/float64(clockTicks) + stime/float64(clockTicks) + iotime/float64(clockTicks)
+}
+func CpuUsageByPid(pid int, sleep time.Duration) float64 {
+	total1 := getCPUSampleByPid(pid)
+	time.Sleep(sleep)
+	total2 := getCPUSampleByPid(pid)
+	return (total2 - total1) / sleep.Seconds() * 100
+}
 
 // CpuUsage 获取CPU使用量
 func CpuUsage(sleep time.Duration) float64 {

process.go

@@ -9,6 +9,7 @@ import (
 	"os/exec"
 	"strings"
 	"sync"
+	"sync/atomic"
 	"syscall"
 	"time"
 )
@@ -20,8 +21,7 @@ type StarCmd struct {
 	outfile io.ReadCloser
 	infile  io.WriteCloser
 	errfile io.ReadCloser
-	running     bool
+	running int32
-	runningChan chan int
 	//Store AlL of the Standed Outputs
 	stdout []byte
 	//Store All of the Standed Errors
@@ -42,11 +42,10 @@ type StarCmd struct {
 func Command(command string, args ...string) (*StarCmd, error) {
 	var err error
 	shell := new(StarCmd)
-	shell.running = false
+	shell.running = 0
 	shell.prewritetime = time.Millisecond * 200
 	shell.stdoutBuf = bytes.NewBuffer(make([]byte, 0))
 	shell.stderrBuf = bytes.NewBuffer(make([]byte, 0))
-	shell.runningChan = make(chan int, 3)
 	shell.stopctx, shell.stopctxfunc = context.WithCancel(context.Background())
 	cmd := exec.Command(command, args...)
 	shell.CMD = cmd
@@ -69,10 +68,9 @@ func Command(command string, args ...string) (*StarCmd, error) {
 func CommandContext(ctx context.Context, command string, args ...string) (*StarCmd, error) {
 	var err error
 	shell := new(StarCmd)
-	shell.running = false
+	shell.running = 0
 	shell.stdoutBuf = bytes.NewBuffer(make([]byte, 0))
 	shell.stderrBuf = bytes.NewBuffer(make([]byte, 0))
-	shell.runningChan = make(chan int, 3)
 	shell.prewritetime = time.Millisecond * 200
 	shell.stopctx, shell.stopctxfunc = context.WithCancel(context.Background())
 	cmd := exec.CommandContext(ctx, command, args...)
@@ -95,7 +93,7 @@ func CommandContext(ctx context.Context, command string, args ...string) (*StarC
 }
 
 func (starcli *StarCmd) queryStdout(ctx context.Context) {
-	for starcli.running && starcli.CMD != nil {
+	for starcli.IsRunning() && starcli.CMD != nil {
 		select {
 		case <-ctx.Done():
 			return
@@ -115,7 +113,7 @@ func (starcli *StarCmd) queryStdout(ctx context.Context) {
 			if err == io.EOF {
 				break
 			} else {
-				if !strings.Contains(err.Error(),"file already closed") {
+				if !strings.Contains(err.Error(), "file already closed") {
 					starcli.runerr = err
 				}
 				return
@@ -125,7 +123,7 @@ func (starcli *StarCmd) queryStdout(ctx context.Context) {
 }
 
 func (starcli *StarCmd) queryStderr(ctx context.Context) {
-	for starcli.running && starcli.CMD != nil {
+	for starcli.IsRunning() && starcli.CMD != nil {
 		select {
 		case <-ctx.Done():
 			return
@@ -145,7 +143,7 @@ func (starcli *StarCmd) queryStderr(ctx context.Context) {
 			if err == io.EOF {
 				break
 			} else {
-				if !strings.Contains(err.Error(),"file already closed") {
+				if !strings.Contains(err.Error(), "file already closed") {
 					starcli.runerr = err
 				}
 				return
@@ -247,20 +245,38 @@ func (starcli *StarCmd) AllStdErr() error {
 	return err
 }
 
+func (starcli *StarCmd) setRunning(alive bool) {
+	if alive {
+		val := atomic.LoadInt32(&starcli.running)
+		if val == 0 {
+			atomic.AddInt32(&starcli.running, 1)
+		} else {
+			atomic.AddInt32(&starcli.running, 1-val)
+		}
+		return
+	}
+	val := atomic.LoadInt32(&starcli.running)
+	if val == 1 {
+		atomic.AddInt32(&starcli.running, -1)
+	} else {
+		atomic.AddInt32(&starcli.running, -val)
+	}
+}
 func (starcli *StarCmd) Start() error {
 	if err := starcli.CMD.Start(); err != nil {
 		return err
 	}
-	starcli.running = true
+	starcli.setRunning(true)
 	go func() {
 		err := starcli.CMD.Wait()
 		if err != nil {
 			starcli.runerr = err
 		}
 		starcli.stopctxfunc()
-		starcli.running = false
+		starcli.setRunning(false)
+		if starcli.CMD.ProcessState != nil {
 			starcli.exitcode = starcli.CMD.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
-		starcli.runningChan <- 1
+		}
 	}()
 	go starcli.queryStdout(starcli.stopctx)
 	go starcli.queryStderr(starcli.stopctx)
@@ -282,11 +298,11 @@ func (starcli *StarCmd) Start() error {
 }
 
 func (starcli *StarCmd) IsRunning() bool {
-	return starcli.running
+	return 0 != atomic.LoadInt32(&starcli.running)
 }
 
-func (starcli *StarCmd) Stoped() <-chan int {
+func (starcli *StarCmd) Stoped() <-chan struct{} {
-	return starcli.runningChan
+	return starcli.stopctx.Done()
 }
 
 func (starcli *StarCmd) Exec(cmd string, wait int) (string, error) {
@@ -313,12 +329,12 @@ func (starcli *StarCmd) ExitCode() int {
 	return starcli.exitcode
 }
 
-func (starcli *StarCmd) Kill() error{
+func (starcli *StarCmd) Kill() error {
-	err:=starcli.CMD.Process.Kill()
+	err := starcli.CMD.Process.Kill()
-	if err!=nil{
+	if err != nil {
 		return err
 	}
-	starcli.running = false
+	starcli.setRunning(false)
 	return nil
 }
 

process_unix.go

@@ -36,7 +36,7 @@ func FindProcess(compare func(Process) bool) (datas []Process, err error) {
 	if err != nil {
 		return
 	}
-	netInfo, netErr = NetConnections(false)
+	netInfo, netErr = NetConnections(false, "")
 	appendNetInfo := func(p *Process) {
 		if netErr != nil {
 			p.netErr = netErr
@@ -170,7 +170,7 @@ func FindProcessByPid(pid int64) (datas Process, err error) {
 		err = errors.New("Not Found")
 		return
 	}
-	netInfo, netErr := NetConnections(false)
+	netInfo, netErr := NetConnections(false, "")
 	appendNetInfo := func(p *Process) {
 		if netErr != nil {
 			p.netErr = netErr
@@ -283,7 +283,7 @@ func Daemon(path string, args ...string) (int, error) {
 	return pid, err
 }
 
-func DaemonWithUser(uid, gid uint32,groups []uint32,path string, args ...string) (int, error) {
+func DaemonWithUser(uid, gid uint32, groups []uint32, path string, args ...string) (int, error) {
 	cmd := exec.Command(path, args...)
 	cmd.SysProcAttr = &syscall.SysProcAttr{
 		Credential: &syscall.Credential{
@@ -301,7 +301,7 @@ func DaemonWithUser(uid, gid uint32,groups []uint32,path string, args ...string)
 	return pid, err
 }
 
-func (starcli *StarCmd) SetRunUser(uid, gid uint32,groups []uint32) {
+func (starcli *StarCmd) SetRunUser(uid, gid uint32, groups []uint32) {
 	starcli.CMD.SysProcAttr = &syscall.SysProcAttr{
 		Credential: &syscall.Credential{
 			Uid:    uid,
@@ -318,13 +318,16 @@ func (starcli *StarCmd) Release() error {
 			Setsid: true,
 		}
 	} else {
+		if !starcli.CMD.SysProcAttr.Setsid {
 			starcli.CMD.SysProcAttr.Setsid = true
 		}
+	}
 	if !starcli.IsRunning() {
 		if err := starcli.CMD.Start(); err != nil {
 			return err
 		}
 	}
+	time.Sleep(time.Millisecond * 10)
 	return starcli.CMD.Process.Release()
 }
 

process_win.go

@@ -59,7 +59,7 @@ func Daemon(path string, args ...string) (int, error) {
 	return pid, nil
 }
 
-func (starcli *StarCmd) SetRunUser(uid, gid uint32) {
+func (starcli *StarCmd) SetRunUser(uid, gid uint32, groups []uint32) {
 
 }
 

sysconf/sysconf.go

@@ -78,8 +78,7 @@ func (syscfg *SysConf) ParseFromFile(filepath string) error {
 	if err != nil {
 		return err
 	}
-	syscfg.Parse(data)
+	return syscfg.Parse(data)
-	return nil
 }
 
 // Parse 生成INI文件结构
@@ -477,7 +476,7 @@ func SliceIn(slice interface{}, data interface{}) bool {
 
 // Unmarshal 输出结果到结构体中
 func (cfg *SysConf) Unmarshal(ins interface{}) error {
-	var structSet func(t reflect.Type, v reflect.Value,oriSeg string) error
+	var structSet func(t reflect.Type, v reflect.Value, oriSeg string) error
 	t := reflect.TypeOf(ins)
 	v := reflect.ValueOf(ins).Elem()
 	if v.Kind() != reflect.Struct {
@@ -487,7 +486,7 @@ func (cfg *SysConf) Unmarshal(ins interface{}) error {
 		return errors.New("Cannot Write!")
 	}
 	t = t.Elem()
-	structSet = func(t reflect.Type, v reflect.Value,oriSeg string) error {
+	structSet = func(t reflect.Type, v reflect.Value, oriSeg string) error {
 		for i := 0; i < t.NumField(); i++ {
 			tp := t.Field(i)
 			vl := v.Field(i)
@@ -495,13 +494,16 @@ func (cfg *SysConf) Unmarshal(ins interface{}) error {
 				continue
 			}
 			if vl.Type().Kind() == reflect.Struct {
-				structSet(vl.Type(), vl,tp.Tag.Get("seg"))
+				structSet(vl.Type(), vl, tp.Tag.Get("seg"))
 				continue
 			}
 			seg := tp.Tag.Get("seg")
 			key := tp.Tag.Get("key")
-			if oriSeg!="" {
+			if key != "" && seg == "" && cfg.HaveSegMent {
-				seg=oriSeg
+				seg = "unnamed"
+			}
+			if oriSeg != "" {
+				seg = oriSeg
 			}
 			if seg == "" || key == "" {
 				continue
@@ -530,12 +532,12 @@ func (cfg *SysConf) Unmarshal(ins interface{}) error {
 		}
 		return nil
 	}
-	return structSet(t, v,"")
+	return structSet(t, v, "")
 }
 
 // Marshal 输出结果到结构体中
 func (cfg *SysConf) Marshal(ins interface{}) ([]byte, error) {
-	var structSet func(t reflect.Type, v reflect.Value,oriSeg string)
+	var structSet func(t reflect.Type, v reflect.Value, oriSeg string)
 	t := reflect.TypeOf(ins)
 	v := reflect.ValueOf(ins)
 	if v.Kind() != reflect.Struct {
@@ -545,20 +547,20 @@ func (cfg *SysConf) Marshal(ins interface{}) ([]byte, error) {
 		t = t.Elem()
 		v = v.Elem()
 	}
-	structSet = func(t reflect.Type, v reflect.Value,oriSeg string) {
+	structSet = func(t reflect.Type, v reflect.Value, oriSeg string) {
 		for i := 0; i < t.NumField(); i++ {
 			var seg, key, comment string = "", "", ""
 			tp := t.Field(i)
 			vl := v.Field(i)
 			if vl.Type().Kind() == reflect.Struct {
-				structSet(vl.Type(), vl,tp.Tag.Get("seg"))
+				structSet(vl.Type(), vl, tp.Tag.Get("seg"))
 				continue
 			}
 			seg = tp.Tag.Get("seg")
 			key = tp.Tag.Get("key")
 			comment = tp.Tag.Get("comment")
 			if oriSeg != "" {
-				seg=oriSeg
+				seg = oriSeg
 			}
 			if seg == "" || key == "" {
 				continue
@@ -570,7 +572,7 @@ func (cfg *SysConf) Marshal(ins interface{}) ([]byte, error) {
 		}
 
 	}
-	structSet(t, v,"")
+	structSet(t, v, "")
 	return cfg.Build(), nil
 }
 

sysconf/sysconf_test.go

@@ -33,11 +33,10 @@ func Test_Parse(t *testing.T) {
 	fmt.Println(cfg.Parse([]byte(data)))
 	cfg.Reverse()
 	cfg.Data[0].Delete(`pp.com`)
-	//fmt.Println(cfg.Data[0].Comment)
+	//fmt.Println(cfg.Data[0].comment)
 	fmt.Println(string(cfg.Build()))
 }
 
-
 type slicetest struct {
 	A string `seg:"s" key:"a"`
 	B string `seg:"a" key:"b"`
@@ -50,7 +49,7 @@ type testme struct {
 
 func Test_Marshal(t *testing.T) {
 
-	var info string =`
+	var info string = `
 [love]
 a=abc
 b=123
@@ -59,10 +58,10 @@ a=456
 b=789
 `
 	var tmp testme
-	ini:=NewIni()
+	ini := NewIni()
 	ini.Parse([]byte(info))
 	ini.Unmarshal(&tmp)
-	fmt.Printf("%+v\n",tmp)
+	fmt.Printf("%+v\n", tmp)
-	b,_:=ini.Marshal(tmp)
+	b, _ := ini.Marshal(tmp)
 	fmt.Println(string(b))
 }

typed.go

@@ -11,6 +11,22 @@ const (
 	TB = GB << 10
 	PB = TB << 10
 )
+const (
+	TCP_UNKNOWN = iota
+	TCP_ESTABLISHED
+	TCP_SYN_SENT
+	TCP_SYN_RECV
+	TCP_FIN_WAIT1
+	TCP_FIN_WAIT2
+	TCP_TIME_WAIT
+	TCP_CLOSE
+	TCP_CLOSE_WAIT
+	TCP_LAST_ACL
+	TCP_LISTEN
+	TCP_CLOSING
+)
+
+var TCP_STATE = []string{"TCP_UNKNOWN", "TCP_ESTABLISHED", "TCP_SYN_SENT", "TCP_SYN_RECV", "TCP_FIN_WAIT1", "TCP_FIN_WAIT2", "TCP_TIME_WAIT", "TCP_CLOSE", "TCP_CLOSE_WAIT", "TCP_LAST_ACL", "TCP_LISTEN", "TCP_CLOSING"}
 
 type NetAdapter struct {
 	Name      string
@@ -20,8 +36,10 @@ type NetAdapter struct {
 
 type NetSpeed struct {
 	Name       string
-	RecvBytes float64
+	RecvSpeeds float64
-	SendBytes float64
+	SendSpeeds float64
+	RecvBytes  uint64
+	SendBytes  uint64
 }
 
 // Process 定义一个进程的信息
@@ -86,6 +104,12 @@ type NetConn struct {
 	RemotePort   int
 	Socket       string
 	Inode        string
+	Status       string
+	TX_Queue     int64
+	RX_Queue     int64
+	TimerActive  string
+	TimerJiffies int64
+	RtoTimer     int64
 	Pid          int64
 	Uid          int64
 	Process      *Process