ignore secode equal sign in ini mod

archive.go

@@ -0,0 +1,69 @@
+package starainrt
+
+import (
+	"archive/zip"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+// Unzip 读取位于src的zip文件，并解压到dst文件夹中
+// shell传入当前解压的文件名称
+func Unzip(src, dst string, shell func(string)) error {
+	dst, err := filepath.Abs(dst)
+	if err != nil {
+		return err
+	}
+	if !IsFile(src) {
+		return errors.New(src + " Not Exists")
+	}
+	if Exists(dst) && !IsFolder(dst) {
+		return errors.New(dst + " Exists And Not A Folder")
+	}
+	if !Exists(dst) {
+		err := os.MkdirAll(dst, 0755)
+		if err != nil {
+			return err
+		}
+	}
+	zipreader, err := zip.OpenReader(src)
+	if err != nil {
+		return err
+	}
+	defer zipreader.Close()
+	for _, v := range zipreader.File {
+		name := strings.ReplaceAll(v.Name, "\\", string(os.PathSeparator))
+		if v.FileInfo().IsDir() {
+			err := os.MkdirAll(dst+string(os.PathSeparator)+name, 0755)
+			if err != nil {
+				fmt.Println(err)
+			}
+			continue
+		}
+		fp, err := v.Open()
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+		go shell(name)
+		dir := filepath.Dir(dst + string(os.PathSeparator) + name)
+		if !Exists(dir) {
+			os.MkdirAll(dir, 0755)
+		}
+		fpdst, err := os.Create(dst + string(os.PathSeparator) + name)
+		if err != nil {
+			fmt.Println(err)
+			continue
+		}
+		_, err = io.Copy(fpdst, fp)
+		if err != nil {
+			fmt.Println(err)
+		}
+		fp.Close()
+		fpdst.Close()
+	}
+	return nil
+}

archive_test.go

@@ -0,0 +1,10 @@
+package starainrt
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_Unzip(t *testing.T) {
+	Unzip(`C:\Users\Starainrt\Desktop\o\BK.ZIP`, `C:\Users\Starainrt\Desktop\o\lalala`, func(i string) { fmt.Println(i) })
+}

crypto.go.old

@@ -0,0 +1,536 @@
+package starainrt
+
+import (
+	"crypto/md5"
+	"crypto/rc4"
+	"crypto/sha1"
+	"crypto/sha256"
+	"crypto/sha512"
+	"encoding/base64"
+	"encoding/hex"
+	"fmt"
+	"hash/crc32"
+	"io"
+	"io/ioutil"
+	"os"
+	"regexp"
+	"strconv"
+)
+
+type StarCrypto struct {
+}
+
+func (this StarCrypto) SmallEncodeFileByBase64(filepath, outputname string, buffer int) bool {
+	if !Exists(filepath) {
+		return false
+	}
+	rempar := regexp.MustCompile(`(.*)\*(.*)`)
+	if !rempar.Match([]byte(outputname)) {
+		return false
+	}
+	rest := rempar.FindSubmatch([]byte(outputname))
+	par1 := string(rest[1])
+	par2 := string(rest[2])
+	bfile, _ := ioutil.ReadFile(filepath)
+	bitlen := len(bfile)
+	i := 1
+	var seed int = buffer
+	if bitlen > seed {
+		for bitlen > seed {
+			coder := base64.StdEncoding.EncodeToString(bfile[seed*(i-1) : seed*i])
+			ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755)
+			i++
+			bitlen -= seed
+		}
+	}
+	coder := base64.StdEncoding.EncodeToString(bfile[seed*(i-1):])
+	ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755)
+	return true
+}
+
+func (this StarCrypto) SmallDecodeFileByBase64(inputname, outputname string, filesum int) bool {
+	rempar := regexp.MustCompile(`(.*)\*(.*)`)
+	if !rempar.Match([]byte(inputname)) {
+		return false
+	}
+	rest := rempar.FindSubmatch([]byte(inputname))
+	par1 := string(rest[1])
+	par2 := string(rest[2])
+	for i := 1; i <= filesum; i++ {
+		if !Exists(par1 + strconv.Itoa(i) + par2) {
+			return false
+		}
+	}
+	i := 1
+	big := filesum
+	res := []byte{}
+	for i <= big {
+		bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2)
+		coder, _ := base64.StdEncoding.DecodeString(string(bfile))
+		for _, v := range coder {
+			res = append(res, v)
+		}
+		i++
+		//time.Sleep(time.Microsecond * 560)
+	}
+	ioutil.WriteFile(outputname, res, 0755)
+	return true
+}
+
+/**
+需要改写
+*/
+func (this StarCrypto) EncodeFileByBase64(filepath, outputname string, buffer int) bool {
+	if !Exists(filepath) {
+		return false
+	}
+	rempar := regexp.MustCompile(`(.*)\*(.*)`)
+	if !rempar.Match([]byte(outputname)) {
+		return false
+	}
+	rest := rempar.FindSubmatch([]byte(outputname))
+	par1 := string(rest[1])
+	par2 := string(rest[2])
+	ret := this.SlitFile(filepath, outputname, 0, int64(buffer), int64(buffer)/10)
+	if !ret {
+		return false
+	}
+	i := 1
+	for {
+		if !Exists(par1 + strconv.Itoa(i) + par2) {
+			break
+		} else {
+			bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2)
+			coder := base64.StdEncoding.EncodeToString(bfile)
+			ioutil.WriteFile(par1+strconv.Itoa(i)+par2, []byte(coder), 0755)
+
+		}
+		i++
+	}
+	return true
+}
+
+func (this StarCrypto) DecodeFileByBase64(inputname, outputname string, filesum int) bool {
+	rempar := regexp.MustCompile(`(.*)\*(.*)`)
+	if !rempar.Match([]byte(inputname)) {
+		return false
+	}
+	rest := rempar.FindSubmatch([]byte(inputname))
+	par1 := string(rest[1])
+	par2 := string(rest[2])
+	if filesum != 0 {
+		for i := 1; i <= filesum; i++ {
+			if !Exists(par1 + strconv.Itoa(i) + par2) {
+				return false
+			}
+		}
+	} else {
+		var i int
+		for i = 1; ; i++ {
+			if !Exists(par1 + strconv.Itoa(i) + par2) {
+				break
+			}
+		}
+		filesum = i - 1
+	}
+	i := 1
+	big := filesum
+	fpw, _ := os.Create(outputname)
+	defer fpw.Close()
+	for i <= big {
+		bfile, _ := ioutil.ReadFile(par1 + strconv.Itoa(i) + par2)
+		coder, _ := base64.StdEncoding.DecodeString(string(bfile))
+		fpw.Write(coder)
+		i++
+		//time.Sleep(time.Microsecond * 560)
+	}
+	return true
+}
+
+func (this StarCrypto) SlitFile(filename, outputname string, num int, databig, buffer int64) bool {
+	rempar := regexp.MustCompile(`(.*)\*(.*)`)
+	if !rempar.Match([]byte(outputname)) {
+		return false
+	}
+	rest := rempar.FindSubmatch([]byte(outputname))
+	par1 := string(rest[1])
+	par2 := string(rest[2])
+	if !Exists(filename) {
+		return false
+	}
+	fileinfo, _ := os.Stat(filename)
+	filesize := fileinfo.Size()
+	var spbyte int64
+	if num != 0 {
+		spbyte = filesize / int64(num)
+	}
+	if databig != 0 {
+		spbyte = databig
+		num = int(filesize/spbyte + 1)
+	}
+	if buffer == 0 {
+		buffer = spbyte / 10
+	}
+	if buffer > 100*1024*1024 {
+		buffer = 50 * 1024 * 1024
+	}
+	fp, _ := os.Open(filename)
+	defer fp.Close()
+	data := make([]byte, buffer)
+	var i int64 = 0
+	var k int = 1
+	fpw, _ := os.Create(par1 + strconv.Itoa(k) + par2)
+	for {
+		data = data[:cap(data)]
+
+		// read bytes to slice
+		n, err := fp.Read(data)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			fmt.Println(err)
+			break
+		}
+		i += int64(n)
+		data = data[:n]
+		fpw.Write(data)
+		if i > spbyte && k < num {
+			fpw.Close()
+			k++
+			i = 1
+			fpw, _ = os.Create(par1 + strconv.Itoa(k) + par2)
+			defer fpw.Close()
+		}
+	}
+	return true
+}
+
+func SpliceFile(inputname, outputname string, num int, buffer int64) bool {
+	rempar := regexp.MustCompile(`(.*)\*(.*)`)
+	if !rempar.Match([]byte(inputname)) {
+		return false
+	}
+	rest := rempar.FindSubmatch([]byte(inputname))
+	par1 := string(rest[1])
+	par2 := string(rest[2])
+	if num != 0 {
+		for i := 1; i <= num; i++ {
+			if !Exists(par1 + strconv.Itoa(i) + par2) {
+				return false
+			}
+		}
+	} else {
+		var i int
+		for i = 1; ; i++ {
+			if !Exists(par1 + strconv.Itoa(i) + par2) {
+				break
+			}
+		}
+		num = i - 1
+	}
+	fpw, _ := os.Create(outputname)
+	defer fpw.Close()
+	fileinfo, _ := os.Stat(par1 + "1" + par2)
+	filesize := fileinfo.Size()
+	if buffer == 0 {
+		buffer = filesize / 5
+	}
+	if buffer > 1024*1024*100 {
+		buffer = 1024 * 1024 * 100
+	}
+	data := make([]byte, buffer)
+	for i := 1; i <= num; i++ {
+		fp, _ := os.Open(par1 + strconv.Itoa(i) + par2)
+		for {
+			data = data[:cap(data)]
+			// read bytes to slice
+			n, err := fp.Read(data)
+			if err != nil {
+				if err == io.EOF {
+					break
+				}
+				fmt.Println(err)
+				break
+			}
+			data = data[:n]
+			fpw.Write(data)
+		}
+		fp.Close()
+	}
+	return true
+}
+
+func (this StarCrypto) MixFile(filepath, outputname string, buffer int64, remix bool) bool {
+	if !Exists(filepath) || !IsFile(filepath) {
+		return false
+	}
+	fileinfo, _ := os.Stat(filepath)
+	filesize := fileinfo.Size()
+	if buffer == 0 {
+		buffer = filesize / 5
+	}
+	if buffer > 1024*1024*100 {
+		buffer = 1024 * 1024 * 100
+	}
+	var spbyte int64
+	if !remix {
+		spbyte = filesize / 2
+	} else {
+		spbyte = filesize - filesize/2
+	}
+	fpw, _ := os.Create(outputname)
+	defer fpw.Close()
+	fp, _ := os.Open(filepath)
+	defer fp.Close()
+	data := make([]byte, buffer)
+	_, _ = fp.Seek(spbyte, 0)
+	for {
+		data = data[:cap(data)]
+
+		// read bytes to slice
+		n, err := fp.Read(data)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			fmt.Println(err)
+			break
+		}
+		data = data[:n]
+		fpw.Write(data)
+	}
+	_, _ = fp.Seek(0, 0)
+	i := int64(0)
+	for {
+		data = data[:cap(data)]
+
+		// read bytes to slice
+		n, err := fp.Read(data)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			fmt.Println(err)
+			break
+		}
+		i += int64(n)
+		if i < spbyte {
+			data = data[:n]
+			fpw.Write(data)
+		} else {
+			data = data[:(int64(n) - i + spbyte)]
+			fpw.Write(data)
+			break
+		}
+	}
+	return true
+}
+
+func Md5File(filepath string) string {
+	f, err := os.Open(filepath)
+	if err != nil {
+		fmt.Println("Open", err)
+		return ""
+	}
+	defer f.Close()
+	md5hash := md5.New()
+	if _, err := io.Copy(md5hash, f); err != nil {
+		fmt.Println("Copy", err)
+		return ""
+	}
+	result := md5hash.Sum(nil)
+	return hex.EncodeToString(result)
+}
+
+func Crc32File(filepath string) string {
+	f, err := os.Open(filepath)
+	if err != nil {
+		fmt.Println("Open", err)
+		return ""
+	}
+
+	defer f.Close()
+	crchash := crc32.NewIEEE()
+	if _, err := io.Copy(crchash, f); err != nil {
+		fmt.Println("Copy", err)
+		return ""
+	}
+	result := crchash.Sum(nil)
+	return hex.EncodeToString(result)
+}
+
+func Sha1File(filepath string) string {
+	f, err := os.Open(filepath)
+	if err != nil {
+		fmt.Println("Open", err)
+		return ""
+	}
+
+	defer f.Close()
+	sha1hash := sha1.New()
+	if _, err := io.Copy(sha1hash, f); err != nil {
+		fmt.Println("Copy", err)
+		return ""
+	}
+	result := sha1hash.Sum(nil)
+	return hex.EncodeToString(result)
+}
+
+func Sha256File(filepath string) string {
+	f, err := os.Open(filepath)
+	if err != nil {
+		fmt.Println("Open", err)
+		return ""
+	}
+
+	defer f.Close()
+	sha256hash := sha256.New()
+	if _, err := io.Copy(sha256hash, f); err != nil {
+		fmt.Println("Copy", err)
+		return ""
+	}
+	result := sha256hash.Sum(nil)
+	return hex.EncodeToString(result)
+}
+
+func Sha512File(filepath string) string {
+	f, err := os.Open(filepath)
+	if err != nil {
+		fmt.Println("Open", err)
+		return ""
+	}
+
+	defer f.Close()
+	sha512hash := sha512.New()
+	if _, err := io.Copy(sha512hash, f); err != nil {
+		fmt.Println("Copy", err)
+		return ""
+	}
+	result := sha512hash.Sum(nil)
+	return hex.EncodeToString(result)
+}
+
+func RC4File(filepath string, key []byte) string {
+	rc4obj, _ := rc4.NewCipher(key)
+	plain, _ := ioutil.ReadFile(filepath)
+	res := make([]byte, len(plain))
+	rc4obj.XORKeyStream(res, plain)
+	return hex.EncodeToString(res)
+}
+func DetachFile(source, output1, output2 string, key int64) bool {
+	if !Exists(source) {
+		return false
+	}
+	fin, _ := os.Stat(source)
+	filesize := fin.Size()
+	fpw, _ := os.Create(output1)
+	fp, _ := os.Open(source)
+	defer fp.Close()
+	buffer := filesize / 10
+	if buffer > 100*1024*1024 {
+		buffer = 100 * 1024 * 1024
+	}
+	data := make([]byte, buffer)
+	i := int64(0)
+	for {
+		data = data[:cap(data)]
+
+		// read bytes to slice
+		n, err := fp.Read(data)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			fmt.Println(err)
+			break
+		}
+		i += int64(n)
+		if i < key {
+			data = data[:n]
+			fpw.Write(data)
+		} else {
+			data = data[:(int64(n) - i + key)]
+			fpw.Write(data)
+			break
+		}
+	}
+	fpw.Close()
+	_, _ = fp.Seek(key+20, 0)
+	fpw, _ = os.Create(output2)
+	for {
+		data = data[:cap(data)]
+
+		// read bytes to slice
+		n, err := fp.Read(data)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			fmt.Println(err)
+			break
+		}
+		data = data[:n]
+		fpw.Write(data)
+	}
+	return true
+}
+func AttachFile(source, target, output string) (bool, string) {
+	if !Exists(source) {
+		return false, ""
+	}
+	if !Exists(target) {
+		return false, ""
+	}
+	fin, _ := os.Stat(source)
+	filesize := fin.Size()
+	_ = ioutil.WriteFile(output+".ini", []byte(strconv.FormatInt(filesize, 10)), 0755)
+	fpw, _ := os.Create(output)
+	defer fpw.Close()
+	fp, _ := os.Open(source)
+	buffer := filesize / 10
+	if buffer > 100*1024*1024 {
+		buffer = 100 * 1024 * 1024
+	}
+	data := make([]byte, buffer)
+	for {
+		data = data[:cap(data)]
+		// read bytes to slice
+		n, err := fp.Read(data)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			fmt.Println(err)
+			break
+		}
+		data = data[:n]
+		fpw.Write(data)
+	}
+	fp.Close()
+	fpw.Write([]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0})
+	fin, _ = os.Stat(target)
+	filesize2 := fin.Size()
+	fp, _ = os.Open(target)
+	buffer = filesize2 / 10
+	if buffer > 100*1024*1024 {
+		buffer = 100 * 1024 * 1024
+	}
+	data = make([]byte, buffer)
+	for {
+		data = data[:cap(data)]
+		// read bytes to slice
+		n, err := fp.Read(data)
+		if err != nil {
+			if err == io.EOF {
+				break
+			}
+			fmt.Println(err)
+			break
+		}
+		data = data[:n]
+		fpw.Write(data)
+	}
+	fp.Close()
+	return true, strconv.FormatInt(filesize, 10)
+}

crypto_test.go

@@ -0,0 +1,13 @@
+package starainrt
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_FileSumAll(t *testing.T) {
+	cry := new(StarCrypto)
+	fmt.Println(cry.FileSumAll("D:\\Download\\macos.iso",[]string{"md5"}, func(pect float64) {
+		fmt.Printf("已处理%f\r", pect)
+	}))
+}

database.go

@@ -3,9 +3,835 @@ package starainrt
 import (
 	"database/sql"
 	"errors"
+	"reflect"
 	"strconv"
+	"time"
 )
 
+// DBRes 单连接下的数据库资源句柄
+var DBRes *sql.DB
+
+// DBRows 单连接下的数据库查询句柄
+var DBRows *sql.Rows
+
+// StarDB 一个简单封装的DB库
+type StarDB struct {
+	DB   *sql.DB
+	Rows *sql.Rows
+}
+
+// StarRows 为查询结果集（按行）
+type StarRows struct {
+	Rows         *sql.Rows
+	Length       int
+	StringResult []map[string]string
+	Columns      []string
+	ColumnsType  []reflect.Type
+	columnref    map[string]int
+	result       [][]interface{}
+}
+
+// StarResult 为查询结果集（总）
+type StarResult struct {
+	Result      []interface{}
+	Columns     []string
+	columnref   map[string]int
+	ColumnsType []reflect.Type
+}
+
+// StarResultCol 为查询结果集（按列）
+type StarResultCol struct {
+	Result []interface{}
+}
+
+// MustBytes 列查询结果转Bytes
+func (star *StarResultCol) MustBytes() [][]byte {
+	var res [][]byte
+	for _, v := range star.Result {
+		res = append(res, v.([]byte))
+	}
+	return res
+}
+
+// MustBool 列查询结果转Bool
+func (star *StarResultCol) MustBool() []bool {
+	var res []bool
+	var tmp bool
+	for _, v := range star.Result {
+		switch vtype := v.(type) {
+		case nil:
+			tmp = false
+		case bool:
+			tmp = vtype
+		case float64:
+			if vtype > 0 {
+				tmp = true
+			} else {
+				tmp = false
+			}
+		case float32:
+			if vtype > 0 {
+				tmp = true
+			} else {
+				tmp = false
+			}
+		case int:
+			if vtype > 0 {
+				tmp = true
+			} else {
+				tmp = false
+			}
+		case int32:
+			if vtype > 0 {
+				tmp = true
+			} else {
+				tmp = false
+			}
+		case int64:
+			if vtype > 0 {
+				tmp = true
+			} else {
+				tmp = false
+			}
+		case string:
+			tmp, _ = strconv.ParseBool(vtype)
+		default:
+			tmp, _ = strconv.ParseBool(string(vtype.([]byte)))
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// MustFloat32 列查询结果转Float32
+func (star *StarResultCol) MustFloat32() []float32 {
+	var res []float32
+	var tmp float32
+	for _, v := range star.Result {
+		switch vtype := v.(type) {
+		case nil:
+			tmp = 0
+		case float32:
+			tmp = vtype
+		case float64:
+			tmp = float32(vtype)
+		case string:
+			tmps, _ := strconv.ParseFloat(vtype, 32)
+			tmp = float32(tmps)
+		case int:
+			tmp = float32(vtype)
+		case int32:
+			tmp = float32(vtype)
+		case int64:
+			tmp = float32(vtype)
+		case time.Time:
+			tmp = float32(vtype.Unix())
+		default:
+			tmpt := string(vtype.([]byte))
+			tmps, _ := strconv.ParseFloat(tmpt, 32)
+			tmp = float32(tmps)
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// MustFloat64 列查询结果转Float64
+func (star *StarResultCol) MustFloat64() []float64 {
+	var res []float64
+	var tmp float64
+	for _, v := range star.Result {
+		switch vtype := v.(type) {
+		case nil:
+			tmp = 0
+		case float64:
+			tmp = vtype
+		case float32:
+			tmp = float64(vtype)
+		case string:
+			tmp, _ = strconv.ParseFloat(vtype, 64)
+		case int:
+			tmp = float64(vtype)
+		case int32:
+			tmp = float64(vtype)
+		case int64:
+			tmp = float64(vtype)
+		case time.Time:
+			tmp = float64(vtype.Unix())
+		default:
+			tmpt := string(vtype.([]byte))
+			tmps, _ := strconv.ParseFloat(tmpt, 64)
+			tmp = float64(tmps)
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// MustString 列查询结果转String
+func (star *StarResultCol) MustString() []string {
+	var res []string
+	var tmp string
+	for _, v := range star.Result {
+		switch vtype := v.(type) {
+		case nil:
+			tmp = ""
+		case string:
+			tmp = vtype
+		case int64:
+			tmp = strconv.FormatInt(vtype, 10)
+		case int32:
+			tmp = strconv.Itoa(int(vtype))
+		case bool:
+			tmp = strconv.FormatBool(vtype)
+		case float64:
+			tmp = strconv.FormatFloat(vtype, 'f', 10, 64)
+		case float32:
+			tmp = strconv.FormatFloat(float64(vtype), 'f', 10, 32)
+		case int:
+			tmp = strconv.Itoa(vtype)
+		case time.Time:
+			tmp = vtype.String()
+		default:
+			tmp = string(vtype.([]byte))
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// MustInt32 列查询结果转Int32
+func (star *StarResultCol) MustInt32() []int32 {
+	var res []int32
+	var tmp int32
+	for _, v := range star.Result {
+		switch vtype := v.(type) {
+		case nil:
+			tmp = 0
+		case float64:
+			tmp = int32(vtype)
+		case float32:
+			tmp = int32(vtype)
+		case string:
+			tmps, _ := strconv.ParseInt(vtype, 10, 32)
+			tmp = int32(tmps)
+		case int:
+			tmp = int32(vtype)
+		case int64:
+			tmp = int32(vtype)
+		case int32:
+			tmp = vtype
+		case time.Time:
+			tmp = int32(vtype.Unix())
+		default:
+			tmpt := string(vtype.([]byte))
+			tmps, _ := strconv.ParseInt(tmpt, 10, 32)
+			tmp = int32(tmps)
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// MustInt64 列查询结果转Int64
+func (star *StarResultCol) MustInt64() []int64 {
+	var res []int64
+	var tmp int64
+	for _, v := range star.Result {
+		switch vtype := v.(type) {
+		case nil:
+			tmp = 0
+		case float64:
+			tmp = int64(vtype)
+		case float32:
+			tmp = int64(vtype)
+		case string:
+			tmps, _ := strconv.ParseInt(vtype, 10, 64)
+			tmp = int64(tmps)
+		case int:
+			tmp = int64(vtype)
+		case int32:
+			tmp = int64(vtype)
+		case int64:
+			tmp = vtype
+		case time.Time:
+			tmp = vtype.Unix()
+		default:
+			tmpt := string(vtype.([]byte))
+			tmp, _ = strconv.ParseInt(tmpt, 10, 64)
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// MustInt 列查询结果转Int
+func (star *StarResultCol) MustInt() []int {
+	var res []int
+	var tmp int
+	for _, v := range star.Result {
+		switch vtype := v.(type) {
+		case nil:
+			tmp = 0
+		case float64:
+			tmp = int(vtype)
+		case float32:
+			tmp = int(vtype)
+		case string:
+			tmps, _ := strconv.ParseInt(vtype, 10, 64)
+			tmp = int(tmps)
+		case int:
+			tmp = vtype
+		case int32:
+			tmp = int(vtype)
+		case int64:
+			tmp = int(vtype)
+		case time.Time:
+			tmp = int(vtype.Unix())
+		default:
+			tmpt := string(vtype.([]byte))
+			tmps, _ := strconv.ParseInt(tmpt, 10, 64)
+			tmp = int(tmps)
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// MustDate 列查询结果转Date(time.Time)
+func (star *StarResultCol) MustDate(layout string) []time.Time {
+	var res []time.Time
+	var tmp time.Time
+	for _, v := range star.Result {
+		switch vtype := v.(type) {
+		case nil:
+			tmp = time.Time{}
+		case float64:
+			tmp = time.Unix(int64(vtype), int64(vtype-float64(int64(vtype)))*1000000000)
+		case float32:
+			tmp = time.Unix(int64(vtype), int64(vtype-float32(int64(vtype)))*1000000000)
+		case string:
+			tmp, _ = time.Parse(layout, vtype)
+		case int:
+			tmp = time.Unix(int64(vtype), 0)
+		case int32:
+			tmp = time.Unix(int64(vtype), 0)
+		case int64:
+			tmp = time.Unix(vtype, 0)
+		case time.Time:
+			tmp = vtype
+		default:
+			tmpt := string(vtype.([]byte))
+			tmp, _ = time.Parse(layout, tmpt)
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// IsNil 检测是不是nil 列查询结果是不是nil
+func (star *StarResultCol) IsNil(name string) []bool {
+	var res []bool
+	var tmp bool
+	for _, v := range star.Result {
+		switch v.(type) {
+		case nil:
+			tmp = true
+		default:
+			tmp = false
+		}
+		res = append(res, tmp)
+	}
+	return res
+}
+
+// IsNil 检测是不是nil
+func (star *StarResult) IsNil(name string) bool {
+	num, ok := star.columnref[name]
+	if !ok {
+		return false
+	}
+	tmp := star.Result[num]
+	switch tmp.(type) {
+	case nil:
+		return true
+	default:
+		return false
+	}
+}
+
+// MustDate 列查询结果转Date
+func (star *StarResult) MustDate(name, layout string) time.Time {
+	var res time.Time
+	num, ok := star.columnref[name]
+	if !ok {
+		return time.Time{}
+	}
+	tmp := star.Result[num]
+	switch vtype := tmp.(type) {
+	case nil:
+		res = time.Time{}
+	case float64:
+		res = time.Unix(int64(vtype), int64(vtype-float64(int64(vtype)))*1000000000)
+	case float32:
+		res = time.Unix(int64(vtype), int64(vtype-float32(int64(vtype)))*1000000000)
+	case string:
+		res, _ = time.Parse(layout, vtype)
+	case int:
+		res = time.Unix(int64(vtype), 0)
+	case int32:
+		res = time.Unix(int64(vtype), 0)
+	case int64:
+		res = time.Unix(vtype, 0)
+	case time.Time:
+		res = vtype
+	default:
+		res, _ = time.Parse(layout, string(tmp.([]byte)))
+	}
+	return res
+}
+
+// MustInt64 列查询结果转int64
+func (star *StarResult) MustInt64(name string) int64 {
+	var res int64
+	num, ok := star.columnref[name]
+	if !ok {
+		return 0
+	}
+	tmp := star.Result[num]
+	switch vtype := tmp.(type) {
+	case nil:
+		res = 0
+	case float64:
+		res = int64(vtype)
+	case float32:
+		res = int64(vtype)
+	case string:
+		res, _ = strconv.ParseInt(vtype, 10, 64)
+	case int:
+		res = int64(vtype)
+	case int32:
+		res = int64(vtype)
+	case int64:
+		res = vtype
+	case time.Time:
+		res = int64(vtype.Unix())
+	default:
+		res, _ = strconv.ParseInt(string(tmp.([]byte)), 10, 64)
+	}
+	return res
+}
+
+// MustInt32 列查询结果转Int32
+func (star *StarResult) MustInt32(name string) int32 {
+	var res int32
+	num, ok := star.columnref[name]
+	if !ok {
+		return 0
+	}
+	tmp := star.Result[num]
+	switch vtype := tmp.(type) {
+	case nil:
+		res = 0
+	case float64:
+		res = int32(vtype)
+	case float32:
+		res = int32(vtype)
+	case string:
+		ress, _ := strconv.ParseInt(vtype, 10, 32)
+		res = int32(ress)
+	case int:
+		res = int32(vtype)
+	case int32:
+		res = vtype
+	case int64:
+		res = int32(vtype)
+	case time.Time:
+		res = int32(vtype.Unix())
+	default:
+		ress, _ := strconv.ParseInt(string(tmp.([]byte)), 10, 32)
+		res = int32(ress)
+	}
+	return res
+}
+
+// MustString 列查询结果转string
+func (star *StarResult) MustString(name string) string {
+	var res string
+	num, ok := star.columnref[name]
+	if !ok {
+		return ""
+	}
+	switch vtype := star.Result[num].(type) {
+	case nil:
+		res = ""
+	case string:
+		res = vtype
+	case int64:
+		res = strconv.FormatInt(vtype, 10)
+	case int32:
+		res = strconv.Itoa(int(vtype))
+	case bool:
+		res = strconv.FormatBool(vtype)
+	case float64:
+		res = strconv.FormatFloat(vtype, 'f', 10, 64)
+	case float32:
+		res = strconv.FormatFloat(float64(vtype), 'f', 10, 32)
+	case int:
+		res = strconv.Itoa(vtype)
+	case time.Time:
+		res = vtype.String()
+	default:
+		res = string(vtype.([]byte))
+	}
+	return res
+}
+
+// MustFloat64 列查询结果转float64
+func (star *StarResult) MustFloat64(name string) float64 {
+	var res float64
+	num, ok := star.columnref[name]
+	if !ok {
+		return 0
+	}
+	switch vtype := star.Result[num].(type) {
+	case nil:
+		res = 0
+	case string:
+		res, _ = strconv.ParseFloat(vtype, 64)
+	case float64:
+		res = vtype
+	case int:
+		res = float64(vtype)
+	case int64:
+		res = float64(vtype)
+	case int32:
+		res = float64(vtype)
+	case float32:
+		res = float64(vtype)
+	case time.Time:
+		res = float64(vtype.Unix())
+	default:
+		res, _ = strconv.ParseFloat(string(vtype.([]byte)), 64)
+	}
+	return res
+}
+
+// MustFloat32 列查询结果转float32
+func (star *StarResult) MustFloat32(name string) float32 {
+	var res float32
+	num, ok := star.columnref[name]
+	if !ok {
+		return 0
+	}
+	switch vtype := star.Result[num].(type) {
+	case nil:
+		res = 0
+	case string:
+		tmp, _ := strconv.ParseFloat(vtype, 32)
+		res = float32(tmp)
+	case float64:
+		res = float32(vtype)
+	case float32:
+		res = vtype
+	case int:
+		res = float32(vtype)
+	case int64:
+		res = float32(vtype)
+	case int32:
+		res = float32(vtype)
+	case time.Time:
+		res = float32(vtype.Unix())
+	default:
+		tmp, _ := strconv.ParseFloat(string(vtype.([]byte)), 32)
+		res = float32(tmp)
+	}
+	return res
+}
+
+// MustInt 列查询结果转int
+func (star *StarResult) MustInt(name string) int {
+	var res int
+	num, ok := star.columnref[name]
+	if !ok {
+		return 0
+	}
+	tmp := star.Result[num]
+	switch vtype := tmp.(type) {
+	case nil:
+		res = 0
+	case float64:
+		res = int(vtype)
+	case float32:
+		res = int(vtype)
+	case string:
+		ress, _ := strconv.ParseInt(vtype, 10, 64)
+		res = int(ress)
+	case int:
+		res = vtype
+	case int32:
+		res = int(vtype)
+	case int64:
+		res = int(vtype)
+	case time.Time:
+		res = int(vtype.Unix())
+	default:
+		ress, _ := strconv.ParseInt(string(tmp.([]byte)), 10, 64)
+		res = int(ress)
+	}
+	return res
+}
+
+// MustBool 列查询结果转bool
+func (star *StarResult) MustBool(name string) bool {
+	var res bool
+	num, ok := star.columnref[name]
+	if !ok {
+		return false
+	}
+	tmp := star.Result[num]
+	switch vtype := tmp.(type) {
+	case nil:
+		res = false
+	case bool:
+		res = vtype
+	case float64:
+		if vtype > 0 {
+			res = true
+		} else {
+			res = false
+		}
+	case float32:
+		if vtype > 0 {
+			res = true
+		} else {
+			res = false
+		}
+	case int:
+		if vtype > 0 {
+			res = true
+		} else {
+			res = false
+		}
+	case int32:
+		if vtype > 0 {
+			res = true
+		} else {
+			res = false
+		}
+	case int64:
+		if vtype > 0 {
+			res = true
+		} else {
+			res = false
+		}
+	case string:
+		res, _ = strconv.ParseBool(vtype)
+	default:
+		res, _ = strconv.ParseBool(string(vtype.([]byte)))
+	}
+	return res
+}
+
+// MustBytes 列查询结果转byte
+func (star *StarResult) MustBytes(name string) []byte {
+	num, ok := star.columnref[name]
+	if !ok {
+		return []byte{}
+	}
+	res := star.Result[num].([]byte)
+	return res
+}
+
+// Rescan 重新分析结果集
+func (star *StarRows) Rescan() {
+	star.parserows()
+}
+
+// Col 选择需要进行操作的数据结果列
+func (star *StarRows) Col(name string) *StarResultCol {
+	result := new(StarResultCol)
+	if _, ok := star.columnref[name]; !ok {
+		return result
+	}
+	var rescol []interface{}
+	for _, v := range star.result {
+		rescol = append(rescol, v[star.columnref[name]])
+	}
+	result.Result = rescol
+	return result
+}
+
+// Row 选择需要进行操作的数据结果行
+func (star *StarRows) Row(id int) *StarResult {
+	result := new(StarResult)
+	if id+1 > len(star.result) {
+		return result
+	}
+	result.Result = star.result[id]
+	result.Columns = star.Columns
+	result.ColumnsType = star.ColumnsType
+	result.columnref = star.columnref
+	return result
+}
+
+// Close 关闭打开的结果集
+func (star *StarRows) Close() error {
+	return star.Rows.Close()
+}
+
+func (star *StarRows) parserows() {
+	star.result = [][]interface{}{}
+	star.columnref = make(map[string]int)
+	star.StringResult = []map[string]string{}
+	star.Columns, _ = star.Rows.Columns()
+	types, _ := star.Rows.ColumnTypes()
+	for _, v := range types {
+		star.ColumnsType = append(star.ColumnsType, v.ScanType())
+	}
+	scanArgs := make([]interface{}, len(star.Columns))
+	values := make([]interface{}, len(star.Columns))
+	for i := range values {
+		star.columnref[star.Columns[i]] = i
+		scanArgs[i] = &values[i]
+	}
+	for star.Rows.Next() {
+		if err := star.Rows.Scan(scanArgs...); err != nil {
+			return
+		}
+		record := make(map[string]string)
+		var rescopy []interface{}
+		for i, col := range values {
+			rescopy = append(rescopy, col)
+			switch vtype := col.(type) {
+			case float32:
+				record[star.Columns[i]] = strconv.FormatFloat(float64(vtype), 'f', -1, 64)
+			case float64:
+				record[star.Columns[i]] = strconv.FormatFloat(vtype, 'f', -1, 64)
+			case int64:
+				record[star.Columns[i]] = strconv.FormatInt(vtype, 10)
+			case int32:
+				record[star.Columns[i]] = strconv.FormatInt(int64(vtype), 10)
+			case int:
+				record[star.Columns[i]] = strconv.Itoa(vtype)
+			case string:
+				record[star.Columns[i]] = vtype
+			case bool:
+				record[star.Columns[i]] = strconv.FormatBool(vtype)
+			case time.Time:
+				record[star.Columns[i]] = vtype.String()
+			case nil:
+				record[star.Columns[i]] = ""
+			default:
+				record[star.Columns[i]] = string(vtype.([]byte))
+			}
+		}
+		star.result = append(star.result, rescopy)
+		star.StringResult = append(star.StringResult, record)
+	}
+	star.Length = len(star.StringResult)
+}
+
+// Query 进行Query操作
+func (star *StarDB) Query(args ...interface{}) (*StarRows, error) {
+	var err error
+	effect := new(StarRows)
+	if err = star.DB.Ping(); err != nil {
+		return effect, err
+	}
+	if len(args) == 0 {
+		return effect, errors.New("no args")
+	}
+	if len(args) == 1 {
+		sql := args[0]
+		if star.Rows, err = star.DB.Query(sql.(string)); err != nil {
+			return effect, err
+		}
+		effect.Rows = star.Rows
+		effect.parserows()
+		return effect, nil
+	}
+	sql := args[0]
+	stmt, err := star.DB.Prepare(sql.(string))
+	if err != nil {
+		return effect, err
+	}
+	defer stmt.Close()
+	var para []interface{}
+	for k, v := range args {
+		if k != 0 {
+			switch vtype := v.(type) {
+			default:
+				para = append(para, vtype)
+			}
+		}
+	}
+	if star.Rows, err = stmt.Query(para...); err != nil {
+		return effect, err
+	}
+	effect.Rows = star.Rows
+	effect.parserows()
+	return effect, nil
+}
+
+// Open 打开一个新的数据库
+func (star *StarDB) Open(Method, ConnStr string) error {
+	var err error
+	star.DB, err = sql.Open(Method, ConnStr)
+	if err != nil {
+		return err
+	}
+	err = star.DB.Ping()
+	return err
+}
+
+// Close 关闭打开的数据库
+func (star *StarDB) Close() error {
+	if err := star.DB.Close(); err != nil {
+		return err
+	}
+	return star.DB.Close()
+}
+
+// Exec 执行Exec操作
+func (star *StarDB) Exec(args ...interface{}) (sql.Result, error) {
+	var err error
+	var effect sql.Result
+	if err = star.DB.Ping(); err != nil {
+		return effect, err
+	}
+	if len(args) == 0 {
+		return effect, errors.New("no args")
+	}
+	if len(args) == 1 {
+		sql := args[0]
+		if _, err = star.DB.Exec(sql.(string)); err != nil {
+			return effect, err
+		}
+		return effect, nil
+	}
+	sql := args[0]
+	stmt, err := star.DB.Prepare(sql.(string))
+	if err != nil {
+		return effect, err
+	}
+	defer stmt.Close()
+	var para []interface{}
+	for k, v := range args {
+		if k != 0 {
+			switch vtype := v.(type) {
+			default:
+				para = append(para, vtype)
+			}
+		}
+	}
+	if effect, err = stmt.Exec(para...); err != nil {
+		return effect, err
+	}
+	return effect, nil
+}
+
+// FetchAll 把结果集全部转为key-value型<string>数据
 func FetchAll(rows *sql.Rows) (error, map[int]map[string]string) {
 	var ii int = 0
 	records := make(map[int]map[string]string)
@@ -31,6 +857,8 @@ func FetchAll(rows *sql.Rows) (error, map[int]map[string]string) {
 				record[columns[i]] = strconv.FormatInt(vtype, 10)
 			case string:
 				record[columns[i]] = vtype
+			case nil:
+				record[columns[i]] = ""
 			default:
 				record[columns[i]] = string(vtype.([]byte))
 			}
@@ -41,6 +869,7 @@ func FetchAll(rows *sql.Rows) (error, map[int]map[string]string) {
 	return nil, records
 }
 
+// OpenDB 打开一个数据库
 func OpenDB(Method, ConnStr string) error {
 	var err error
 	DBRes, err = sql.Open(Method, ConnStr)
@@ -50,11 +879,14 @@ func OpenDB(Method, ConnStr string) error {
 	err = DBRes.Ping()
 	return err
 }
+
+// CloseDB 关闭打开的数据库
 func CloseDB() {
 	DBRes.Close()
 	DBRows.Close()
 }
 
+// Query 进行数据库查询操作
 func Query(args ...interface{}) (error, map[int]map[string]string) {
 	var err error
 	records := make(map[int]map[string]string)
@@ -93,6 +925,7 @@ func Query(args ...interface{}) (error, map[int]map[string]string) {
 
 }
 
+// DBExec 进行数据库EXEC查询操作
 func DBExec(args ...interface{}) error {
 	var err error
 	if err = DBRes.Ping(); err != nil {

database_test.go

@@ -0,0 +1,19 @@
+package starainrt
+
+import (
+	"fmt"
+	"testing"
+
+	_ "github.com/mattn/go-sqlite3"
+)
+
+func TestDataBase(t *testing.T) {
+	mysql := new(StarDB)
+	defer mysql.Close()
+	mysql.Open("sqlite3", "D:\\Ttest.db")
+	mysql.Exec("CREATE TABLE IF NOT EXISTS sakura(id INT PRIMARY KEY,xihuan TEXT)")
+	mysql.Exec("INSERT INTO sakura VALUES(?,?)", 2, "dssfsdfdf")
+	sakura, _ := mysql.Query("SELECT * FROM sakura")
+	defer sakura.Close()
+	fmt.Println(sakura.Row(0).MustString("xihuan"))
+}

http.go

@@ -0,0 +1,421 @@
+package starainrt
+
+import (
+	"bytes"
+	"crypto/rand"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"mime/multipart"
+	"net"
+	"net/http"
+	urls "net/url"
+	"os"
+	"path/filepath"
+	"time"
+)
+
+type StarCurl struct {
+	TimeOut      int
+	DialTimeOut  int
+	ReqHeader    http.Header
+	ReqCookies   []*http.Cookie
+	RespHeader   http.Header
+	RespCookies  []*http.Cookie
+	RespHttpCode int
+	PostBuffer   *bytes.Buffer
+	CircleBuffer *CircleByteBuffer
+	Proxy        string
+}
+
+func NewStarCurl() *StarCurl {
+	star := new(StarCurl)
+	star.ReqHeader = make(http.Header)
+	star.TimeOut = 60
+	star.DialTimeOut = 15
+	star.PostBuffer = nil
+	return star
+}
+
+func (this *StarCurl) ResetReqHeader() {
+	this.ReqHeader = make(http.Header)
+}
+
+func (this *StarCurl) ResetReqCookies() {
+	this.ReqCookies = []*http.Cookie{}
+}
+
+func (this *StarCurl) AddSimpleCookie(key, value string) {
+	this.ReqCookies = append(this.ReqCookies, &http.Cookie{Name: key, Value: value, Path: "/"})
+}
+
+func randomBoundary() string {
+	var buf [30]byte
+	_, err := io.ReadFull(rand.Reader, buf[:])
+	if err != nil {
+		panic(err)
+	}
+	return fmt.Sprintf("%x", buf[:])
+
+}
+
+func (this *StarCurl) CurlWithFile(url string, postdata map[string]string, formname, fpath, savepath string, tofile bool, shell func(float64)) (result []byte, err error) {
+	fpsrc, err := os.Open(fpath)
+	if err != nil {
+		return
+	}
+	defer fpsrc.Close()
+	boundary := randomBoundary()
+	boundarybytes := []byte("\r\n--" + boundary + "\r\n")
+	endbytes := []byte("\r\n--" + boundary + "--\r\n")
+	fpstat, _ := os.Stat(fpath)
+	filebig := float64(fpstat.Size())
+	sum, n := 0, 0
+	fpdst := NewCircleByteBuffer(1048576)
+	if postdata != nil {
+		for k, v := range postdata {
+			header := fmt.Sprintf("Content-Disposition: form-data; name=\"%s\";\r\nContent-Type: x-www-form-urlencoded \r\n\r\n", k)
+			fpdst.Write(boundarybytes)
+			fpdst.Write([]byte(header))
+			fpdst.Write([]byte(v))
+		}
+	}
+	header := fmt.Sprintf("Content-Disposition: form-data; name=\"%s\"; filename=\"%s\"\r\nContent-Type: application/octet-stream\r\n\r\n", formname, fpstat.Name())
+	fpdst.Write(boundarybytes)
+	fpdst.Write([]byte(header))
+	go func() {
+		for {
+			bufs := make([]byte, 393213)
+			n, err = fpsrc.Read(bufs)
+			if err != nil {
+				if err == io.EOF {
+					if n != 0 {
+						fpdst.Write(bufs[0:n])
+						go shell(float64(sum+n) / filebig * 100)
+					}
+					break
+				}
+				return
+			}
+			sum += n
+			go shell(float64(sum) / filebig * 100)
+			fpdst.Write(bufs[0:n])
+		}
+		fpdst.Write(endbytes)
+		fpdst.Write(nil)
+	}()
+	this.CircleBuffer = fpdst
+	this.ReqHeader.Set("Content-Type", "multipart/form-data;boundary="+boundary)
+	if tofile {
+		err = this.CurlDataToFile(url, []byte{}, "POST", savepath, shell)
+		this.ResetReqHeader()
+	} else {
+		result, err = this.Curl(url, []byte{}, "POST")
+	}
+	this.ResetReqHeader()
+	return
+}
+
+func (this *StarCurl) CurlWithFileByBytes(url string, postdata map[string]string, formname, fname string, data []byte, savepath string, tofile bool) (result []byte, err error) {
+	buf := &bytes.Buffer{}
+	bufwriter := multipart.NewWriter(buf)
+	if postdata != nil {
+		for k, v := range postdata {
+			bufwriter.WriteField(k, v)
+		}
+	}
+	fpdst, err := bufwriter.CreateFormFile(formname, fname)
+	if err != nil {
+		return
+	}
+	fpdst.Write(data)
+	this.PostBuffer = buf
+	this.ReqHeader.Set("Content-Type", "multipart/form-data;boundary="+bufwriter.Boundary())
+	bufwriter.Close()
+	if tofile {
+		err = this.CurlDataToFile(url, []byte{}, "POST", savepath, func(float64) {})
+		this.ResetReqHeader()
+	} else {
+		result, err = this.Curl(url, []byte{}, "POST")
+	}
+	this.ResetReqHeader()
+	return
+}
+
+func (this *StarCurl) CurlWithFileByMemory(url string, postdata map[string]string, formname, fpath, savepath string, tofile bool, shell func(float64)) (result []byte, err error) {
+	buf := &bytes.Buffer{}
+	bufwriter := multipart.NewWriter(buf)
+	if postdata != nil {
+		for k, v := range postdata {
+			bufwriter.WriteField(k, v)
+		}
+	}
+	fpdst, err := bufwriter.CreateFormFile(formname, filepath.Base(fpath))
+	if err != nil {
+		return
+	}
+	fpsrc, err := os.Open(fpath)
+	if err != nil {
+		return
+	}
+	defer fpsrc.Close()
+	fpstat, _ := os.Stat(fpath)
+	filebig := float64(fpstat.Size())
+	sum, n := 0, 0
+	for {
+		bufs := make([]byte, 393213)
+		n, err = fpsrc.Read(bufs)
+		if err != nil {
+			if err == io.EOF {
+				if n != 0 {
+					fpdst.Write(bufs[0:n])
+					go shell(float64(sum+n) / filebig * 100)
+				}
+				break
+			}
+			return
+		}
+		sum += n
+		go shell(float64(sum) / filebig * 100)
+		fpdst.Write(bufs[0:n])
+	}
+
+	this.PostBuffer = buf
+	this.ReqHeader.Set("Content-Type", "multipart/form-data;boundary="+bufwriter.Boundary())
+	bufwriter.Close()
+	if tofile {
+		err = this.CurlDataToFile(url, []byte{}, "POST", savepath, shell)
+		this.ResetReqHeader()
+	} else {
+		result, err = this.Curl(url, []byte{}, "POST")
+	}
+	this.ResetReqHeader()
+	return
+}
+
+func (this *StarCurl) CurlDataToFile(url string, postdata []byte, method, fpath string, shell func(float64)) (err error) {
+	var req *http.Request
+	if method == "" {
+		if len(postdata) != 0 {
+			method = "POST"
+		} else {
+			method = "GET"
+		}
+	}
+	if len(postdata) == 0 && this.PostBuffer == nil && this.CircleBuffer == nil {
+		req, err = http.NewRequest(method, url, nil)
+	} else if len(postdata) != 0 {
+		req, err = http.NewRequest(method, url, bytes.NewBuffer(postdata))
+	} else if this.PostBuffer != nil {
+		req, err = http.NewRequest(method, url, this.PostBuffer)
+	} else {
+		req, err = http.NewRequest(method, url, this.CircleBuffer)
+	}
+	if err != nil {
+		return
+	}
+	if (this.ReqHeader == nil) && method == "POST" {
+		this.ReqHeader.Set("Content-Type", "application/x-www-form-urlencoded")
+	}
+	req.Header = this.ReqHeader
+	if len(this.ReqCookies) != 0 {
+		for _, v := range this.ReqCookies {
+			req.AddCookie(v)
+		}
+	}
+	transport := &http.Transport{
+		Dial: func(netw, addr string) (net.Conn, error) {
+			deadline := time.Now().Add(time.Duration(this.TimeOut) * time.Second)
+			c, err := net.DialTimeout(netw, addr, time.Second*time.Duration(this.DialTimeOut))
+			if err != nil {
+				return nil, err
+			}
+			if this.TimeOut != 0 {
+				c.SetDeadline(deadline)
+			}
+			return c, nil
+		},
+	}
+	if this.Proxy != "" {
+		purl, _ := urls.Parse(this.Proxy)
+		transport.Proxy = http.ProxyURL(purl)
+	}
+	client := &http.Client{
+		Transport: transport,
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	this.PostBuffer = nil
+	this.CircleBuffer = nil
+	this.RespHttpCode = resp.StatusCode
+	this.RespHeader = resp.Header
+	this.RespCookies = resp.Cookies()
+	fpsrc, err := os.Create(fpath)
+	if err != nil {
+		return
+	}
+	defer fpsrc.Close()
+	filebig := float64(resp.ContentLength)
+	if filebig <= 0 {
+		filebig = 100
+	}
+	var n, sum int = 0, 0
+	for {
+		buf := make([]byte, 393213)
+		n, err = resp.Body.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				err = nil
+				if n != 0 {
+					fpsrc.Write(buf[0:n])
+				}
+				go shell(100.00)
+				break
+			}
+			return
+		}
+		sum += n
+		go shell(float64(sum) / filebig * 100.00)
+		fpsrc.Write(buf[0:n])
+	}
+	return
+}
+
+func (this *StarCurl) Curl(url string, postdata []byte, method string) (body []byte, err error) {
+	var req *http.Request
+	if method == "" {
+		if len(postdata) != 0 {
+			method = "POST"
+		} else {
+			method = "GET"
+		}
+	}
+	if len(postdata) == 0 && this.PostBuffer == nil && this.CircleBuffer == nil {
+		req, err = http.NewRequest(method, url, nil)
+	} else if len(postdata) != 0 {
+		req, err = http.NewRequest(method, url, bytes.NewBuffer(postdata))
+	} else if this.PostBuffer != nil {
+		req, err = http.NewRequest(method, url, this.PostBuffer)
+	} else {
+		req, err = http.NewRequest(method, url, this.CircleBuffer)
+	}
+	if err != nil {
+		return
+	}
+	if (this.ReqHeader == nil) && method == "POST" {
+		this.ReqHeader.Set("Content-Type", "application/x-www-form-urlencoded")
+	}
+	req.Header = this.ReqHeader
+	if len(this.ReqCookies) != 0 {
+		for _, v := range this.ReqCookies {
+			req.AddCookie(v)
+		}
+	}
+	transport := &http.Transport{
+		Dial: func(netw, addr string) (net.Conn, error) {
+			deadline := time.Now().Add(time.Duration(this.TimeOut) * time.Second)
+			c, err := net.DialTimeout(netw, addr, time.Second*time.Duration(this.DialTimeOut))
+			if err != nil {
+				return nil, err
+			}
+			if this.TimeOut != 0 {
+				c.SetDeadline(deadline)
+			}
+			return c, nil
+		},
+	}
+	if this.Proxy != "" {
+		purl, _ := urls.Parse(this.Proxy)
+		transport.Proxy = http.ProxyURL(purl)
+	}
+	client := &http.Client{
+		Transport: transport,
+	}
+	resp, err := client.Do(req)
+	if err != nil {
+		return
+	}
+	defer resp.Body.Close()
+	this.PostBuffer = nil
+	this.CircleBuffer = nil
+	this.RespHttpCode = resp.StatusCode
+	this.RespHeader = resp.Header
+	this.RespCookies = resp.Cookies()
+	body, err = ioutil.ReadAll(resp.Body)
+	return
+}
+
+//HttpNulReset将重置Header和Cookie为空
+func HttpNulReset() {
+	var tmp map[string]string
+	HttpNul, HttpNul2 = tmp, tmp
+}
+
+func Curl(url string, postdata string, header map[string]string, cookie map[string]string, method string) (error, int, []byte, http.Header, []*http.Cookie) {
+	var req *http.Request
+	if method == "" {
+		if len(postdata) != 0 {
+			method = "POST"
+		} else {
+			method = "GET"
+		}
+	}
+	BytePostData := []byte(postdata)
+	if postdata == "" || len(postdata) == 0 {
+		req, _ = http.NewRequest(method, url, nil)
+	} else {
+		req, _ = http.NewRequest(method, url, bytes.NewBuffer(BytePostData))
+	}
+
+	if (len(header) == 0 || header == nil) && method == "POST" {
+		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+	}
+	for k, v := range header {
+		req.Header.Set(k, v)
+	}
+	if len(cookie) != 0 {
+		for k, v := range cookie {
+			req.AddCookie(&http.Cookie{Name: k, Value: v, HttpOnly: true})
+		}
+
+	}
+	client := &http.Client{
+		Transport: &http.Transport{
+			Dial: func(netw, addr string) (net.Conn, error) {
+				deadline := time.Now().Add(time.Duration(HttpTimeOut) * time.Second)
+				c, err := net.DialTimeout(netw, addr, time.Second*time.Duration(HttpTimeOut))
+				if err != nil {
+					return nil, err
+				}
+				c.SetDeadline(deadline)
+				return c, nil
+			},
+		}}
+	resp, err := client.Do(req)
+	var rte []*http.Cookie
+	if err != nil {
+		return err, 0, []byte(""), req.Header, rte
+	}
+	defer resp.Body.Close()
+
+	statuscode := resp.StatusCode
+	hea := resp.Header
+	body, _ := ioutil.ReadAll(resp.Body)
+	return nil, statuscode, body, hea, resp.Cookies()
+
+}
+
+//CurlGet发起一个HTTP GET请求
+func CurlGet(url string) (error, []byte) {
+	err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET")
+	return err, res
+}
+
+//CurlPost发起一个基于表单的HTTP Post请求
+func CurlPost(url, postdata string) (error, []byte) {
+	err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST")
+	return err, res
+}

ini.go

@@ -3,10 +3,13 @@ package starainrt
 import (
 	"bufio"
 	"errors"
+	"fmt"
 	"io"
 	"io/ioutil"
 	"os"
+	"reflect"
 	"regexp"
+	"strconv"
 	"strings"
 )
 
@@ -159,7 +162,7 @@ jump:
 		if ok, _ := regexp.MatchString("^#", v); ok {
 			continue
 		}
-		segfind := regexp.MustCompile(`\[(.*)\]`)
+		segfind := regexp.MustCompile(`^\[(.*)\]`)
 		if !inseg {
 			if ok, _ := regexp.MatchString(`(.*?)=(.*)`, v); ok {
 				nolabel = true
@@ -195,3 +198,469 @@ jump:
 	}
 	return result, nil
 }
+
+type StarCfg struct {
+	Data   []*CfgSegment
+	segmap map[string]int
+	//nodemap map[int]map[string]int
+	segid int
+}
+
+type CfgNode struct {
+	Key     string
+	Value   string
+	Comment string
+}
+
+type CfgSegment struct {
+	Name    string
+	cmap    map[string]int
+	Comment string
+	Node    []*CfgNode
+	nodeid  int
+	//InsertNode []*CfgNode
+}
+
+func (this *StarCfg) ParseFromFile(filepath string) error {
+	if !Exists(filepath) {
+		return errors.New(filepath + " 不存在")
+	}
+	data, err := ioutil.ReadFile(filepath)
+	if err != nil {
+		return err
+	}
+	this.Parse(data)
+	return nil
+}
+
+func (this *StarCfg) WriteToFile(filepath string) error {
+	data := this.Build()
+	return ioutil.WriteFile(filepath, data, 0644)
+}
+
+// Parse 生成INI文件结构
+func (this *StarCfg) Parse(data []byte) {
+	var newnode *CfgNode
+	this.segid = 0 //segment序号
+	nodeint := 0
+	this.segmap = make(map[string]int) //segment名 序号
+	//this.nodemap = make(map[int]map[string]int)
+	nodemap := make(map[string]int)
+	strdata := string(data)              //转换成字符串
+	list := strings.Split(strdata, "\n") //分割
+	newseg := new(CfgSegment)
+	newseg.Name = "unnamed" //默认名
+	//newseg.InsertNode = []*CfgNode{}
+	this.segmap["unnamed"] = 0
+	lastiseg := true
+	for _, v := range list {
+		istrans := false
+		isseg := false   //是否为新seg
+		isnote := false  //是否为注释
+		isequal := false // 是否为等号
+		tmp1 := []rune{}
+		tmp2 := []rune{}
+		note := []rune{}
+		v = strings.TrimSpace(v)
+		if len(v) > 0 && v[0:1] == ";" {
+			isnote = true //首字母是;时，代表注释
+		}
+		for k, v2 := range v {
+			if k == 0 {
+				if v2 == '[' {
+					isseg = true
+					continue
+				}
+			}
+			if v2 == '=' && (!istrans && !isnote && !isequal) {
+				isequal = true
+				continue
+			}
+			if v2 == ']' && (!istrans && !isnote) {
+				continue
+			}
+			if v2 == '#' && (!istrans && !isnote) {
+				isnote = true
+				continue
+			}
+			if v2 == '\\' && (!istrans && !isnote) {
+				istrans = true
+				continue
+			}
+			if istrans {
+				istrans = false
+			}
+			if !isnote && (!isequal) {
+				tmp1 = append(tmp1, v2)
+			} else if !isnote && isequal {
+				tmp2 = append(tmp2, v2)
+			} else if isnote {
+				note = append(note, v2)
+			}
+		}
+		if isseg {
+			this.Data = append(this.Data, newseg)
+			newseg.nodeid = nodeint
+			//newseg.cmap = make(map[string]int)
+			newseg.cmap = nodemap
+			nodemap = make(map[string]int)
+			newseg = new(CfgSegment)
+			//newseg.InsertNode = []*CfgNode{}
+			newseg.Name = strings.TrimSpace(string(tmp1))
+			if isnote {
+				newseg.Comment = strings.TrimSpace(string(note))
+			}
+			this.segid++
+			this.segmap[newseg.Name] = this.segid
+			nodeint = 0
+			lastiseg = true
+			continue
+		}
+		if isequal {
+			newnode = new(CfgNode)
+			newnode.Key = strings.TrimSpace(string(tmp1))
+			newnode.Value = strings.TrimSpace(string(tmp2))
+			if isnote {
+				newnode.Comment = strings.TrimSpace(string(note))
+			}
+			newseg.Node = append(newseg.Node, newnode)
+			nodemap[newnode.Key] = nodeint
+			nodeint++
+			lastiseg = false
+			continue
+		}
+		if isnote {
+			comment := strings.TrimSpace(string(note))
+			if lastiseg {
+				newseg.Comment += "\n" + comment
+			} else {
+				newnode.Comment += "\n" + comment
+			}
+			continue
+		}
+
+	}
+	newseg.nodeid = nodeint
+	//newseg.cmap = make(map[string]int)
+	newseg.cmap = nodemap
+	this.Data = append(this.Data, newseg)
+}
+
+// Unmarshal 输出结果到结构体中
+func (cfg *StarCfg) Unmarshal(ins interface{}) error {
+	var structSet func(t reflect.Type, v reflect.Value) error
+	t := reflect.TypeOf(ins)
+	v := reflect.ValueOf(ins).Elem()
+	if v.Kind() != reflect.Struct {
+		return errors.New("Not a Struct")
+	}
+	if t.Kind() != reflect.Ptr || !v.CanSet() {
+		return errors.New("Cannot Write!")
+	}
+	t = t.Elem()
+	structSet = func(t reflect.Type, v reflect.Value) error {
+		for i := 0; i < t.NumField(); i++ {
+			tp := t.Field(i)
+			vl := v.Field(i)
+			if !vl.CanSet() {
+				continue
+			}
+			if vl.Type().Kind() == reflect.Struct {
+				structSet(vl.Type(), vl)
+				continue
+			}
+			seg := tp.Tag.Get("seg")
+			key := tp.Tag.Get("key")
+			if seg == "" || key == "" {
+				continue
+			}
+			if _, ok := cfg.segmap[seg]; !ok {
+				continue
+			}
+			segs := cfg.Data[cfg.segmap[seg]]
+			if segs.Get(key) == "" {
+				continue
+			}
+			switch vl.Kind() {
+			case reflect.String:
+				vl.SetString(segs.Get(key))
+			case reflect.Int, reflect.Int32, reflect.Int64:
+				vl.SetInt(segs.Int64(key))
+			case reflect.Float32, reflect.Float64:
+				vl.SetFloat(segs.Float64(key))
+			case reflect.Bool:
+				vl.SetBool(segs.Bool(key))
+			case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+				vl.SetUint(uint64(segs.Int64(key)))
+			default:
+				continue
+			}
+		}
+		return nil
+	}
+	return structSet(t, v)
+}
+
+// Marshal 输出结果到结构体中
+func (cfg *StarCfg) Marshal(ins interface{}) ([]byte, error) {
+	var structSet func(t reflect.Type, v reflect.Value)
+	t := reflect.TypeOf(ins)
+	v := reflect.ValueOf(ins)
+	if v.Kind() != reflect.Struct {
+		return nil, errors.New("Not a Struct")
+	}
+	if t.Kind() == reflect.Ptr {
+		t = t.Elem()
+		v = v.Elem()
+	}
+	structSet = func(t reflect.Type, v reflect.Value) {
+		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)
+				continue
+			}
+			seg = tp.Tag.Get("seg")
+			key = tp.Tag.Get("key")
+			comment = tp.Tag.Get("comment")
+			if seg == "" || key == "" {
+				continue
+			}
+			if _, ok := cfg.segmap[seg]; !ok {
+				cfg.AddSeg(seg)
+			}
+			cfg.Seg(seg).Set(key, fmt.Sprint(vl), comment)
+		}
+
+	}
+	structSet(t, v)
+	return cfg.Build(), nil
+}
+
+func (this *StarCfg) Seg(name string) *CfgSegment {
+	if _, ok := this.segmap[name]; !ok {
+		return nil
+	}
+	seg := this.Data[this.segmap[name]]
+	return seg
+}
+
+func (cfg *StarCfg) AddSeg(name string) *CfgSegment {
+	if _, ok := cfg.segmap[name]; !ok {
+		newseg := new(CfgSegment)
+		newseg.Name = name
+		newseg.cmap = make(map[string]int)
+		cfg.Data = append(cfg.Data, newseg)
+		cfg.segid++
+		if cfg.segmap == nil {
+			cfg.segid = 0
+			cfg.segmap = make(map[string]int)
+		}
+		cfg.segmap[newseg.Name] = cfg.segid
+		return newseg
+	}
+	seg := cfg.Data[cfg.segmap[name]]
+	return seg
+}
+
+func (cfg *StarCfg) DeleteSeg(name string) error {
+	if _, ok := cfg.segmap[name]; !ok {
+		return errors.New("Seg Not Exists")
+	}
+	cfg.Data[cfg.segmap[name]] = nil
+	delete(cfg.segmap, name)
+	return nil
+}
+
+func (this *StarCfg) Build() []byte {
+	var res, comm string
+	for _, v := range this.Data {
+		comm = ""
+		if v == nil {
+			continue
+		}
+		if v.Name != "unnamed" {
+			res += `[ ` + this.repkv(v.Name) + ` ]`
+		}
+		if v.Comment != "" {
+			comm = strings.Replace(v.Comment, "\n", "\n#", -1)
+			if comm[0:1] != "\n" {
+				comm = " #" + comm
+			}
+
+		}
+		res += comm + "\n"
+		for _, v2 := range v.Node {
+			comm = ""
+			if v2 == nil {
+				continue
+			}
+			res += this.repkv(v2.Key) + " = " + this.repkv(v2.Value)
+			if v2.Comment != "" {
+				comm = strings.Replace(v2.Comment, "\n", "\n#", -1)
+				if comm[0:1] != "\n" {
+					comm = " #" + comm
+				}
+			}
+			res += comm + "\n"
+		}
+	}
+	return []byte(strings.TrimSpace(res))
+}
+
+func (this *StarCfg) repkv(value string) string {
+	value = strings.Replace(value, `\`, `\\`, -1)
+	value = strings.Replace(value, `#`, `\#`, -1)
+	//value = strings.Replace(value, `=`, `\=`, -1)
+	value = strings.Replace(value, `[`, `\[`, -1)
+	value = strings.Replace(value, `]`, `\]`, -1)
+	return value
+}
+
+func (this *CfgSegment) GetComment(key string) string {
+	if v, ok := this.cmap[key]; !ok {
+		return ""
+	} else {
+		return this.Node[v].Comment
+	}
+}
+
+func (this *CfgSegment) SetComment(key, comment string) error {
+	if v, ok := this.cmap[key]; !ok {
+		return errors.New("Key Not Exists")
+	} else {
+		this.Node[v].Comment = comment
+		return nil
+	}
+}
+
+func (this *CfgSegment) Exist(key string) bool {
+	if _, ok := this.cmap[key]; !ok {
+		return false
+	} else {
+		return true
+	}
+}
+
+func (this *CfgSegment) Get(key string) string {
+	if v, ok := this.cmap[key]; !ok {
+		return ""
+	} else {
+		return this.Node[v].Value
+	}
+}
+
+func (this *CfgSegment) Int(key string) int {
+	val := this.Get(key)
+	if val == "" {
+		return 0
+	}
+	res, _ := strconv.Atoi(val)
+	return res
+}
+
+func (this *CfgSegment) Int64(key string) int64 {
+	val := this.Get(key)
+	if val == "" {
+		return 0
+	}
+	res, _ := strconv.ParseInt(val, 10, 64)
+	return res
+}
+
+func (this *CfgSegment) Int32(key string) int32 {
+	val := this.Get(key)
+	if val == "" {
+		return 0
+	}
+	res, _ := strconv.ParseInt(val, 10, 32)
+	return int32(res)
+}
+
+func (this *CfgSegment) Float64(key string) float64 {
+	val := this.Get(key)
+	if val == "" {
+		return 0
+	}
+	res, _ := strconv.ParseFloat(val, 64)
+	return res
+}
+
+func (this *CfgSegment) Float32(key string) float32 {
+	val := this.Get(key)
+	if val == "" {
+		return 0
+	}
+	res, _ := strconv.ParseFloat(val, 32)
+	return float32(res)
+}
+
+func (this *CfgSegment) Bool(key string) bool {
+	val := this.Get(key)
+	if val == "" {
+		return false
+	}
+	res, _ := strconv.ParseBool(val)
+	return res
+}
+
+func (this *CfgSegment) SetBool(key string, value bool, comment string) error {
+	res := strconv.FormatBool(value)
+	return this.Set(key, res, comment)
+}
+
+func (this *CfgSegment) SetFloat64(key string, prec int, value float64, comment string) error {
+	res := strconv.FormatFloat(value, 'f', prec, 64)
+	return this.Set(key, res, comment)
+}
+
+func (this *CfgSegment) SetFloat32(key string, prec int, value float32, comment string) error {
+	res := strconv.FormatFloat(float64(value), 'f', prec, 32)
+	return this.Set(key, res, comment)
+}
+
+func (this *CfgSegment) SetInt64(key string, value int64, comment string) error {
+	res := strconv.FormatInt(value, 10)
+	return this.Set(key, res, comment)
+}
+
+func (this *CfgSegment) SetInt32(key string, value int32, comment string) error {
+	res := strconv.FormatInt(int64(value), 10)
+	return this.Set(key, res, comment)
+}
+
+func (this *CfgSegment) SetInt(key string, value int, comment string) error {
+	res := strconv.Itoa(value)
+	return this.Set(key, res, comment)
+}
+
+func (this *CfgSegment) Set(key, value, comment string) error {
+	if v, ok := this.cmap[key]; !ok {
+		node := new(CfgNode)
+		node.Key = key
+		node.Value = value
+		node.Comment = comment
+		this.Node = append(this.Node, node)
+		this.cmap[key] = this.nodeid
+		this.nodeid++
+		return nil
+	} else {
+		this.Node[v].Value = value
+		if comment != "" {
+			this.Node[v].Comment = comment
+		}
+	}
+	return nil
+}
+
+func (this *CfgSegment) Delete(key string) error {
+	if v, ok := this.cmap[key]; !ok {
+		return errors.New("Key not exists!")
+	} else {
+		this.Node[v] = nil
+		delete(this.cmap, key)
+	}
+	return nil
+}

ini_test.go

@@ -0,0 +1,89 @@
+package starainrt
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_CfgParse(t *testing.T) {
+	data := `#lalala
+	ok =true\# #ok
+	[happy] #ok
+	#kkk
+	me = \=tru
+	sa = p\\k
+	migrate = ok #oooo
+	[siki]
+	sakurs = ssss #[ossk]`
+	//data, _ := ioutil.ReadFile(`c:\Users\Starainrt\Desktop\postgresql.conf`)
+	ini := new(StarCfg)
+	ini.Parse([]byte(data))
+	ini.Seg("happy").SetInt64("sakura", 986787, "")
+	fmt.Println(string(ini.Build()))
+}
+
+type Ntest struct {
+	N string `seg:"happy" key:"me"`
+}
+type Testsss struct {
+	Okk     string `seg:"unnamed" key:"ok"`
+	Migrate string `seg:"happy" key:"migrate" comment:"whnb"`
+	Ntest
+}
+
+func Test_CfgParseStruct(t *testing.T) {
+	data := `#lalala
+	ok =true\#  #ok
+	[happy] #ok
+	#kkk
+	me = \=tru
+	sa = p\\k
+	migrate = ok #oooo
+	[siki]
+	sakurs = ssss #[ossk]`
+	//data, _ := ioutil.ReadFile(`c:\Users\Starainrt\Desktop\postgresql.conf`)
+	okk := Testsss{}
+	ini := new(StarCfg)
+	ini.Parse([]byte(data))
+	//fmt.Println(ini.Seg("happy").Get("migrate"))
+	fmt.Println(ini.Unmarshal(&okk))
+	fmt.Println(okk)
+}
+
+func Test_DeleteAdd(t *testing.T) {
+	data := `[A]
+a=1
+b=2
+c=3
+[B]
+a=1
+b=2
+c=3
+[C]
+a=1
+b=2
+c=3
+`
+	ini := new(StarCfg)
+	ini.Parse([]byte(data))
+	fmt.Println(ini.Seg("A").Int("a"))
+	fmt.Println(ini.Seg("A").Int("b"))
+	fmt.Println(ini.Seg("B").Int("c"))
+	fmt.Println("-----------------------")
+	ini.Seg("A").Set("d", "4", "")
+	ini.DeleteSeg("B")
+	ini.AddSeg("D")
+	ini.AddSeg("E").SetInt("a", 1, "")
+	ini.Seg("C").Delete("a")
+	fmt.Println(string(ini.Build()))
+}
+
+func Test_Marshal(t *testing.T) {
+	var a Testsss
+	a.Migrate = "1"
+	a.N = "2"
+	a.Okk = "okkkkk"
+	ini := StarCfg{}
+	data, err := ini.Marshal(a)
+	fmt.Println(string(data), err)
+}

net.go

@@ -0,0 +1,284 @@
+package starainrt
+
+import (
+	"bytes"
+	"context"
+	"encoding/binary"
+	"errors"
+	"sync"
+	"time"
+)
+
+//SecretKey 通信加密Key，不应当被修改
+const SecretKey string = "1996victorique1127B612BTXL"
+
+// 识别头
+var header = []byte{11, 27, 19, 96, 12, 25, 02, 20}
+
+// MsgQueue 为基本的信息单位
+type MsgQueue struct {
+	ID   uint16
+	Msg  []byte
+	Conn interface{}
+}
+
+// StarQueue 为流数据中的消息队列分发
+type StarQueue struct {
+	Encode   bool
+	Reserve  uint16
+	Msgid    uint16
+	MsgPool  []MsgQueue
+	UnFinMsg sync.Map
+	LastID   int //= -1
+	ctx      context.Context
+	cancel   context.CancelFunc
+	duration time.Duration
+}
+
+// NewQueue 建立一个新消息队列
+func NewQueue() *StarQueue {
+	var que StarQueue
+	que.Encode = true
+	que.ctx, que.cancel = context.WithCancel(context.Background())
+	que.duration = 0
+	return &que
+}
+
+// Uint32ToByte 4位uint32转byte
+func Uint32ToByte(src uint32) []byte {
+	res := make([]byte, 4)
+	res[3] = uint8(src)
+	res[2] = uint8(src >> 8)
+	res[1] = uint8(src >> 16)
+	res[0] = uint8(src >> 24)
+	return res
+}
+
+// ByteToUint32 byte转4位uint32
+func ByteToUint32(src []byte) uint32 {
+	var res uint32
+	buffer := bytes.NewBuffer(src)
+	binary.Read(buffer, binary.BigEndian, &res)
+	return res
+}
+
+// Uint16ToByte 2位uint16转byte
+func Uint16ToByte(src uint16) []byte {
+	res := make([]byte, 2)
+	res[1] = uint8(src)
+	res[0] = uint8(src >> 8)
+	return res
+}
+
+// ByteToUint16 用于byte转uint16
+func ByteToUint16(src []byte) uint16 {
+	var res uint16
+	buffer := bytes.NewBuffer(src)
+	binary.Read(buffer, binary.BigEndian, &res)
+	return res
+}
+
+// BuildMessage 生成编码后的信息用于发送
+func (que *StarQueue) BuildMessage(src []byte) []byte {
+	var buff bytes.Buffer
+	que.Msgid++
+	if que.Encode {
+		cryptos := new(StarCrypto)
+		src = cryptos.VicqueEncodeV1(src, SecretKey)
+	}
+	length := uint32(len(src))
+	buff.Write(header)
+	buff.Write(Uint32ToByte(length))
+	buff.Write(Uint16ToByte(que.Msgid))
+	buff.Write(src)
+	return buff.Bytes()
+}
+
+type unFinMsg struct {
+	ID         uint16
+	LengthRecv uint32
+	// HeaderMsg 信息头，应当为14位：8位识别码+4位长度码+2位id
+	HeaderMsg []byte
+	RecvMsg   []byte
+}
+
+// ParseMessage 用于解析啊收到的msg信息
+func (que *StarQueue) ParseMessage(msg []byte, conn interface{}) error {
+	tmp, ok := que.UnFinMsg.Load(conn)
+	cryptos := new(StarCrypto)
+	if ok { //存在未完成的信息
+		lastMsg := tmp.(*unFinMsg)
+		headerLen := len(lastMsg.HeaderMsg)
+		if headerLen < 14 { //未完成头标题
+			//传输的数据不能填充header头
+			if len(msg) < 14-headerLen {
+				//加入header头并退出
+				lastMsg.HeaderMsg = bytesMerge(lastMsg.HeaderMsg, msg)
+				que.UnFinMsg.Store(conn, lastMsg)
+				return nil
+			}
+			//获取14字节完整的header
+			header := msg[0 : 14-headerLen]
+			lastMsg.HeaderMsg = bytesMerge(lastMsg.HeaderMsg, header)
+			//检查收到的header是否为认证header
+			//若不是，丢弃并重新来过
+			if !checkHeader(lastMsg.HeaderMsg[0:8]) {
+				que.UnFinMsg.Delete(conn)
+				if len(msg) == 0 {
+					return nil
+				}
+				return que.ParseMessage(msg, conn)
+			}
+			//获得本数据包长度
+			lastMsg.LengthRecv = ByteToUint32(lastMsg.HeaderMsg[8:12])
+			//获得本数据包ID
+			lastMsg.ID = ByteToUint16(lastMsg.HeaderMsg[12:14])
+			//存入列表
+			que.UnFinMsg.Store(conn, lastMsg)
+			msg = msg[14-headerLen:]
+			if uint32(len(msg)) < lastMsg.LengthRecv {
+				lastMsg.RecvMsg = msg
+				que.UnFinMsg.Store(conn, lastMsg)
+				return nil
+			}
+			if uint32(len(msg)) >= lastMsg.LengthRecv {
+				lastMsg.RecvMsg = msg[0:lastMsg.LengthRecv]
+				if que.Encode {
+					lastMsg.RecvMsg = cryptos.VicqueDecodeV1(lastMsg.RecvMsg, SecretKey)
+				}
+				msg = msg[lastMsg.LengthRecv:]
+				stroeMsg := MsgQueue{
+					ID:   lastMsg.ID,
+					Msg:  lastMsg.RecvMsg,
+					Conn: conn,
+				}
+				que.MsgPool = append(que.MsgPool, stroeMsg)
+				que.UnFinMsg.Delete(conn)
+				return que.ParseMessage(msg, conn)
+			}
+		} else {
+			lastID := int(lastMsg.LengthRecv) - len(lastMsg.RecvMsg)
+			if lastID < 0 {
+				que.UnFinMsg.Delete(conn)
+				return que.ParseMessage(msg, conn)
+			}
+			if len(msg) >= lastID {
+				lastMsg.RecvMsg = bytesMerge(lastMsg.RecvMsg, msg[0:lastID])
+				if que.Encode {
+					lastMsg.RecvMsg = cryptos.VicqueDecodeV1(lastMsg.RecvMsg, SecretKey)
+				}
+				stroeMsg := MsgQueue{
+					ID:   lastMsg.ID,
+					Msg:  lastMsg.RecvMsg,
+					Conn: conn,
+				}
+				que.MsgPool = append(que.MsgPool, stroeMsg)
+				que.UnFinMsg.Delete(conn)
+				if len(msg) == lastID {
+					return nil
+				}
+				msg = msg[lastID:]
+				return que.ParseMessage(msg, conn)
+			}
+			lastMsg.RecvMsg = bytesMerge(lastMsg.RecvMsg, msg)
+			que.UnFinMsg.Store(conn, lastMsg)
+			return nil
+		}
+	}
+	if len(msg) == 0 {
+		return nil
+	}
+	var start int
+	if start = searchHeader(msg); start == -1 {
+		return errors.New("data format error")
+	}
+	msg = msg[start:]
+	lastMsg := unFinMsg{}
+	que.UnFinMsg.Store(conn, &lastMsg)
+	return que.ParseMessage(msg, conn)
+}
+
+func checkHeader(msg []byte) bool {
+	if len(msg) != 8 {
+		return false
+	}
+	for k, v := range msg {
+		if v != header[k] {
+			return false
+		}
+	}
+	return true
+}
+
+func searchHeader(msg []byte) int {
+	if len(msg) < 8 {
+		return 0
+	}
+	for k, v := range msg {
+		find := 0
+		if v == header[0] {
+			for k2, v2 := range header {
+				if msg[k+k2] == v2 {
+					find++
+				} else {
+					break
+				}
+			}
+			if find == 8 {
+				return k
+			}
+		}
+	}
+	return -1
+}
+
+func bytesMerge(src ...[]byte) []byte {
+	var buff bytes.Buffer
+	for _, v := range src {
+		buff.Write(v)
+	}
+	return buff.Bytes()
+}
+
+// Restore 获取收到的信息
+func (que *StarQueue) Restore(n int) ([]MsgQueue, error) {
+	var res []MsgQueue
+	dura := time.Duration(0)
+	for len(que.MsgPool) < n {
+		select {
+		case <-que.ctx.Done():
+			return res, errors.New("Stoped By External Function Call")
+		default:
+			time.Sleep(time.Millisecond * 20)
+			dura = time.Millisecond*20 + dura
+			if que.duration != 0 && dura > que.duration {
+				return res, errors.New("Time Exceed")
+			}
+		}
+	}
+	if len(que.MsgPool) < n {
+		return res, errors.New("Result Not Enough")
+	}
+	res = que.MsgPool[0:n]
+	que.MsgPool = que.MsgPool[n:]
+	return res, nil
+}
+
+// RestoreOne 获取收到的一个信息
+func (que *StarQueue) RestoreOne() (MsgQueue, error) {
+	data, err := que.Restore(1)
+	if len(data) == 1 {
+		return data[0], err
+	}
+	return MsgQueue{}, err
+}
+
+// Stop 立即停止Restore
+func (que *StarQueue) Stop() {
+	que.cancel()
+}
+
+// RestoreDuration Restore最大超时时间
+func (que *StarQueue) RestoreDuration(tm time.Duration) {
+	que.duration = tm
+}

net_test.go

@@ -0,0 +1,184 @@
+package starainrt
+
+import (
+	"fmt"
+	"testing"
+)
+
+func Test_oldddd(t *testing.T) {
+	a := []int{}
+	a = append(a, 1)
+	a = append(a, 2)
+	a = append(a, 3)
+	fmt.Println(a)
+	a = a[3:]
+	fmt.Println(a)
+}
+
+func Test_binary(t *testing.T) {
+	bytes := Uint16ToByte(65512)
+	fmt.Println(bytes)
+	fmt.Println(ByteToUint16(bytes))
+}
+
+func Test_test(t *testing.T) {
+	que := NewQueue()
+	okk := que.BuildMessage([]byte(`
+	with
+    all_values as (
+      (select V.ID,
+        V.OBJID,
+        V.TITLE,
+        V.CONTENT,
+        V.URL,
+        V.URL_TYPE,
+        V.STATUS,
+        V.SEARCH_TIMES,
+        V.UPDATE_TIMES
+      from SPMS_SEARCH_VIEW V
+      )
+
+    ),
+    in_values as (
+      select T1.*
+      from SPMS_SEARCH_DATASET T1,
+        (select V.ID,
+        V.OBJID,
+        V.TITLE,
+        V.CONTENT,
+        V.URL,
+        V.URL_TYPE,
+        V.STATUS,
+        V.SEARCH_TIMES,
+        V.UPDATE_TIMES
+      from SPMS_SEARCH_VIEW V
+      ) T
+      where T.OBJID = T1.OBJID
+
+    ),
+    upsert as (
+      update SPMS_SEARCH_DATASET as T1
+      set
+        ID = T.ID,
+        TITLE = T.TITLE,
+        CONTENT = T.CONTENT,
+        URL = T.URL,
+        URL_TYPE = T.URL_TYPE,
+        STATUS = T.STATUS,
+        SEARCH_TIMES = T.SEARCH_TIMES,
+        UPDATE_TIMES = TO_CHAR(T.UPDATE_TIMES, 'yyyy-MM-dd hh24:mi:ss'),
+        SYNC_TIMES = V_CUR_TIME
+      from all_values T  
+      where T.OBJID = T1.OBJID and TO_DATE(T1.UPDATE_TIMES, 'yyyy-MM-dd hh24:mi:ss') \u003c TO_DATE(TO_CHAR(T.UPDATE_TIMES, 'yyyy-MM-dd hh24:mi:ss'), 'yyyy-MM-dd hh24:mi:ss')
+    ) 
+  insert into SPMS_SEARCH_DATASET(ID, OBJID, TITLE, CONTENT, URL, URL_TYPE, STATUS, SEARCH_TIMES, UPDATE_TIMES, SYNC_TIMES)
+  select T.ID,
+    T.OBJID,
+    T.TITLE,
+    T.CONTENT,
+    T.URL,
+    T.URL_TYPE,
+    T.STATUS,
+    T.SEARCH_TIMES,
+    TO_CHAR(T.UPDATE_TIMES, 'yyyy-MM-dd hh24:mi:ss'),
+    V_CUR_TIME
+  from (select V.ID,
+    V.OBJID,
+    V.TITLE,
+    V.CONTENT,
+    V.URL,
+    V.URL_TYPE,
+    V.STATUS,
+    V.SEARCH_TIMES,
+    V.UPDATE_TIMES
+  from SPMS_SEARCH_VIEW V
+  ) T
+  where not exists(select 1
+  from in_values T1
+  where T.OBJID = T1.OBJID
+  )
+  with
+  all_values as (
+	(select V.ID,
+	  V.OBJID,
+	  V.TITLE,
+	  V.CONTENT,
+	  V.URL,
+	  V.URL_TYPE,
+	  V.STATUS,
+	  V.SEARCH_TIMES,
+	  V.UPDATE_TIMES
+	from SPMS_SEARCH_VIEW V
+	)
+
+  ),
+  in_values as (
+	select T1.*
+	from SPMS_SEARCH_DATASET T1,
+	  (select V.ID,
+	  V.OBJID,
+	  V.TITLE,
+	  V.CONTENT,
+	  V.URL,
+	  V.URL_TYPE,
+	  V.STATUS,
+	  V.SEARCH_TIMES,
+	  V.UPDATE_TIMES
+	from SPMS_SEARCH_VIEW V
+	) T
+	where T.OBJID = T1.OBJID
+
+  ),
+  upsert as (
+	update SPMS_SEARCH_DATASET as T1
+	set
+	  ID = T.ID,
+	  TITLE = T.TITLE,
+	  CONTENT = T.CONTENT,
+	  URL = T.URL,
+	  URL_TYPE = T.URL_TYPE,
+	  STATUS = T.STATUS,
+	  SEARCH_TIMES = T.SEARCH_TIMES,
+	  UPDATE_TIMES = TO_CHAR(T.UPDATE_TIMES, 'yyyy-MM-dd hh24:mi:ss'),
+	  SYNC_TIMES = V_CUR_TIME
+	from all_values T  
+	where T.OBJID = T1.OBJID and TO_DATE(T1.UPDATE_TIMES, 'yyyy-MM-dd hh24:mi:ss') \u003c TO_DATE(TO_CHAR(T.UPDATE_TIMES, 'yyyy-MM-dd hh24:mi:ss'), 'yyyy-MM-dd hh24:mi:ss')
+  ) 
+insert into SPMS_SEARCH_DATASET(ID, OBJID, TITLE, CONTENT, URL, URL_TYPE, STATUS, SEARCH_TIMES, UPDATE_TIMES, SYNC_TIMES)
+select T.ID,
+  T.OBJID,
+  T.TITLE,
+  T.CONTENT,
+  T.URL,
+  T.URL_TYPE,
+  T.STATUS,
+  T.SEARCH_TIMES,
+  TO_CHAR(T.UPDATE_TIMES, 'yyyy-MM-dd hh24:mi:ss'),
+  V_CUR_TIME
+from (select V.ID,
+  V.OBJID,
+  V.TITLE,
+  V.CONTENT,
+  V.URL,
+  V.URL_TYPE,
+  V.STATUS,
+  V.SEARCH_TIMES,
+  V.UPDATE_TIMES
+from SPMS_SEARCH_VIEW V
+) T
+where not exists(select 1
+from in_values T1
+where T.OBJID = T1.OBJID
+)
+	`))
+	fmt.Println(string(okk))
+	que.ParseMessage([]byte{'n', 'm', 'b'}, "nbb")
+	//	que.ParseMessage([]byte{'n', 23, 24, 4, 45, 6, 56, 56, 2, 3, 1, 2}, "nbb")
+	que.ParseMessage(okk[0:123], "nbb")
+	que.ParseMessage([]byte{}, "nbb")
+	que.ParseMessage([]byte{}, "nbb")
+	que.ParseMessage([]byte{}, "nbb")
+	que.ParseMessage(okk[123:135], "nbb")
+	que.ParseMessage(okk[135:], "nbb")
+	fmt.Println(string(que.MsgPool[0].Msg))
+}

shell.go

@@ -31,10 +31,7 @@ func NewPipeShell(command string, arg ...string) (*suncli, error) {
 	lovecli.counter = 0
 	cmd := exec.Command(command, arg...)
 	lovecli.cmd = cmd
-	lovecli.infile, err = lovecli.cmd.StdinPipe()
-	if err != nil {
-		return &lovecli, err
-	}
+
 	lovecli.outfile, err = lovecli.cmd.StdoutPipe()
 	if err != nil {
 		return &lovecli, err
@@ -119,7 +116,7 @@ func (this suncli) WriteCmd(cmdstr string) {
 	return
 }
 
-func (this suncli) ExitCode() int {
+func (this *suncli) ExitCode() int {
 	return this.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
 }
 

starainrt.go

@@ -1,23 +1,43 @@
 package starainrt
 
 import (
-	"bytes"
-	"database/sql"
-	"io/ioutil"
-	"net"
-	"net/http"
+	"errors"
+	"fmt"
+	"io"
 	"os"
 	"time"
 )
 
 var HttpNul, HttpNul2 map[string]string
 var HttpTimeOut int64 = 15
-var DBRes *sql.DB
-var DBRows *sql.Rows
 var ShellRes, ShellErr string
 var ShellExit bool
 
-//Exits返回指定文件夹/文件是否存在
+type CircleByteBuffer struct {
+	io.Reader
+	io.Writer
+	io.Closer
+	datas []byte
+
+	start   int
+	end     int
+	size    int
+	isClose bool
+	isEnd   bool
+}
+
+func NewCircleByteBuffer(len int) *CircleByteBuffer {
+	var e = new(CircleByteBuffer)
+	e.datas = make([]byte, len)
+	e.start = 0
+	e.end = 0
+	e.size = len
+	e.isClose = false
+	e.isEnd = false
+	return e
+}
+
+// Exists 返回指定文件夹/文件是否存在
 func Exists(filepath string) bool {
 	_, err := os.Stat(filepath)
 	if err != nil && os.IsNotExist(err) {
@@ -46,74 +66,128 @@ func IsFolder(fpath string) bool {
 	return s.IsDir()
 }
 
-//CurlGet发起一个HTTP GET请求
-func CurlGet(url string) (error, []byte) {
-	err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET")
-	return err, res
-}
-
-//CurlPost发起一个基于表单的HTTP Post请求
-func CurlPost(url, postdata string) (error, []byte) {
-	err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST")
-	return err, res
-}
-
-//HttpNulReset将重置Header和Cookie为空
-func HttpNulReset() {
-	var tmp map[string]string
-	HttpNul, HttpNul2 = tmp, tmp
-}
-
-func Curl(url string, postdata string, header map[string]string, cookie map[string]string, method string) (error, int, []byte, http.Header, []*http.Cookie) {
-	var req *http.Request
-	if method == "" {
-		if len(postdata) != 0 {
-			method = "POST"
+func (e *CircleByteBuffer) getLen() int {
+	if e.start == e.end {
+		return 0
+	} else if e.start < e.end {
+		return e.end - e.start
 	} else {
-			method = "GET"
+		return e.start - e.end
 	}
 }
-	BytePostData := []byte(postdata)
-	if postdata == "" || len(postdata) == 0 {
-		req, _ = http.NewRequest(method, url, nil)
+func (e *CircleByteBuffer) getFree() int {
+	return e.size - e.getLen()
+}
+func (e *CircleByteBuffer) putByte(b byte) error {
+	if e.isClose {
+		return io.EOF
+	}
+	e.datas[e.end] = b
+	var pos = e.end + 1
+	for pos == e.start {
+		if e.isClose {
+			return io.EOF
+		}
+		time.Sleep(time.Microsecond)
+	}
+	if pos == e.size {
+		e.end = 0
 	} else {
-		req, _ = http.NewRequest(method, url, bytes.NewBuffer(BytePostData))
+		e.end = pos
+	}
+	return nil
 }
 
-	if (len(header) == 0 || header == nil) && method == "POST" {
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+func (e *CircleByteBuffer) getByte() (byte, error) {
+	if e.isClose {
+		return 0, io.EOF
 	}
-	for k, v := range header {
-		req.Header.Set(k, v)
+	if e.isEnd && e.getLen() <= 0 {
+		return 0, io.EOF
 	}
-	if len(cookie) != 0 {
-		for k, v := range cookie {
-			req.AddCookie(&http.Cookie{Name: k, Value: v, HttpOnly: true})
+	if e.getLen() <= 0 {
+		return 0, errors.New("no datas")
+	}
+	var ret = e.datas[e.start]
+	e.start++
+	if e.start == e.size {
+		e.start = 0
+	}
+	return ret, nil
+}
+func (e *CircleByteBuffer) geti(i int) byte {
+	if i >= e.getLen() {
+		panic("out buffer")
+	}
+	var pos = e.start + i
+	if pos >= e.size {
+		pos -= e.size
+	}
+	return e.datas[pos]
 }
 
+/*func (e*CircleByteBuffer)puts(bts []byte){
+	for i:=0;i<len(bts);i++{
+		e.put(bts[i])
 	}
-	client := &http.Client{
-		Transport: &http.Transport{
-			Dial: func(netw, addr string) (net.Conn, error) {
-				deadline := time.Now().Add(time.Duration(HttpTimeOut) * time.Second)
-				c, err := net.DialTimeout(netw, addr, time.Second*time.Duration(HttpTimeOut))
+}
+func (e*CircleByteBuffer)gets(bts []byte)int{
+	if bts==nil {return 0}
+	var ret=0
+	for i:=0;i<len(bts);i++{
+		if e.getLen()<=0{break}
+		bts[i]=e.get()
+		ret++
+	}
+	return ret
+}*/
+func (e *CircleByteBuffer) Close() error {
+	e.isClose = true
+	return nil
+}
+func (e *CircleByteBuffer) Read(bts []byte) (int, error) {
+	if e.isClose {
+		return 0, io.EOF
+	}
+	if bts == nil {
+		return 0, errors.New("bts is nil")
+	}
+	var ret = 0
+	for i := 0; i < len(bts); i++ {
+		b, err := e.getByte()
 		if err != nil {
-					return nil, err
+			if err == io.EOF {
+				return ret, err
 			}
-				c.SetDeadline(deadline)
-				return c, nil
-			},
-		}}
-	resp, err := client.Do(req)
-	var rte []*http.Cookie
+			return ret, nil
+		}
+		bts[i] = b
+		ret++
+	}
+	if e.isClose {
+		return ret, io.EOF
+	}
+	return ret, nil
+}
+func (e *CircleByteBuffer) Write(bts []byte) (int, error) {
+	if e.isClose {
+		return 0, io.EOF
+	}
+	if bts == nil {
+		e.isEnd = true
+		return 0, io.EOF
+	}
+	var ret = 0
+	for i := 0; i < len(bts); i++ {
+		err := e.putByte(bts[i])
 		if err != nil {
-		return err, 0, []byte(""), req.Header, rte
+			fmt.Println("Write bts err:", err)
+			return ret, err
 		}
-	defer resp.Body.Close()
-
-	statuscode := resp.StatusCode
-	hea := resp.Header
-	body, _ := ioutil.ReadAll(resp.Body)
-	return nil, statuscode, body, hea, resp.Cookies()
-
+		ret++
+	}
+	if e.isClose {
+		return ret, io.EOF
+	}
+	return ret, nil
 }

starshell.go

@@ -0,0 +1,161 @@
+package starainrt
+
+import (
+	"context"
+	"errors"
+	"io"
+	"os"
+	"os/exec"
+	"syscall"
+	"time"
+)
+
+type StarShell struct {
+	outfile  *io.ReadCloser
+	infile   *io.WriteCloser
+	errfile  *io.ReadCloser
+	cmd      *exec.Cmd
+	running  bool
+	stopSign context.Context
+	stopFunc context.CancelFunc
+	stdout   []byte
+	errout   []byte
+	runerr   error
+	exitcode int
+}
+
+func NewStarShell(command string, args ...string) (*StarShell, error) {
+	shell := new(StarShell)
+	shell.stopSign, shell.stopFunc = context.WithCancel(context.Background())
+	cmd := exec.CommandContext(shell.stopSign, command, args...)
+	shell.cmd = cmd
+	infile, err := shell.cmd.StdinPipe()
+	if err != nil {
+		return shell, err
+	}
+	shell.infile = &infile
+	errfile, err := shell.cmd.StderrPipe()
+	if err != nil {
+		return shell, err
+	}
+	shell.errfile = &errfile
+	outfile, err := shell.cmd.StdoutPipe()
+	if err != nil {
+		return shell, err
+	}
+	shell.outfile = &outfile
+	shell.runerr = nil
+	shell.exitcode = -999
+	return shell, nil
+}
+
+func (starcli *StarShell) Start() error {
+	if err := starcli.cmd.Start(); err != nil {
+		return err
+	}
+	starcli.running = true
+	go func() {
+		err := starcli.cmd.Wait()
+		if err != nil {
+			starcli.runerr = err
+		}
+		starcli.exitcode = starcli.cmd.ProcessState.Sys().(syscall.WaitStatus).ExitStatus()
+		starcli.running = false
+	}()
+	go starcli.queryResult()
+	go starcli.queryErrResult()
+	return nil
+}
+
+func (starcli *StarShell) queryResult() error {
+	for starcli.running {
+		out := make([]byte, 65535)
+		n, err := (*starcli.outfile).Read(out)
+		if n != 0 {
+			for i := 0; i < n; i++ {
+				starcli.stdout = append(starcli.stdout, out[i])
+			}
+		}
+		if err != nil {
+			if err == io.EOF {
+				break
+			} else {
+				starcli.runerr = err
+				return err
+			}
+
+		}
+		time.Sleep(time.Microsecond * 100)
+	}
+	return nil
+}
+
+func (starcli *StarShell) queryErrResult() error {
+	for starcli.running {
+		out := make([]byte, 65535)
+		n, err := (*starcli.errfile).Read(out)
+		if n != 0 {
+			for i := 0; i < n; i++ {
+				starcli.errout = append(starcli.errout, out[i])
+			}
+		}
+		if err != nil {
+			if err == io.EOF {
+				break
+			} else {
+				starcli.runerr = err
+				return err
+			}
+		}
+		time.Sleep(time.Microsecond * 100)
+	}
+	return nil
+}
+
+func (starcli *StarShell) GetResult() (string, error) {
+	np := len(starcli.stdout)
+	res1 := string(starcli.stdout[0:np])
+	starcli.stdout = starcli.stdout[np:]
+	np = len(starcli.errout)
+	res2 := string(starcli.errout[0:np])
+	starcli.errout = starcli.errout[np:]
+	if len(res2) == 0 && starcli.runerr != nil {
+		res2 = starcli.runerr.Error()
+	}
+	if len(res2) == 0 {
+		return res1, nil
+	}
+	return res1, errors.New(res2)
+}
+
+func (starcli *StarShell) Exec(cmd string, wait int) (string, error) {
+	(*starcli.infile).Write([]byte(cmd + "\n"))
+	time.Sleep(time.Millisecond * time.Duration(wait))
+	return starcli.GetResult()
+}
+
+func (starcli *StarShell) WriteCmd(cmdstr string) {
+	(*starcli.infile).Write([]byte(cmdstr + "\n"))
+	return
+}
+
+func (starcli *StarShell) ExitCode() int {
+	return starcli.exitcode
+}
+
+func (starcli *StarShell) Kill() {
+	starcli.stopFunc()
+	starcli.running = false
+}
+
+func (starcli *StarShell) IsRunning() bool {
+	return starcli.running
+}
+
+func (starcli *StarShell) GetPid() int {
+	return starcli.cmd.Process.Pid
+}
+
+func (starcli *StarShell) Signal(sig os.Signal) error {
+	return starcli.cmd.Process.Signal(sig)
+}

starshell_linux.go

@@ -0,0 +1,34 @@
+// +build linux
+
+package starainrt
+
+import "syscall"
+
+func (starcli *StarShell) SetRunUser(uid, gid uint32) {
+	starcli.cmd.SysProcAttr = &syscall.SysProcAttr{
+		Credential: &syscall.Credential{
+			Uid: uid,
+			Gid: gid,
+		},
+		Setsid: true,
+	}
+}
+
+func (starcli *StarShell) Release() error {
+	if err := starcli.cmd.Start(); err != nil {
+		return err
+	}
+	starcli.cmd.SysProcAttr = &syscall.SysProcAttr{
+		Setsid: true,
+	}
+	starcli.cmd.Process.Release()
+	return nil
+}
+
+func (starcli *StarShell) SetKeepCaps() error {
+	_, _, err := syscall.RawSyscall(157 /*SYS PRCTL */, 0x8 /*PR SET KEEPCAPS*/, 1, 0)
+	if 0 != err {
+		return err
+	}
+	return nil
+}

starshell_test.go

@@ -0,0 +1,60 @@
+package starainrt
+
+import (
+	"fmt"
+	"testing"
+	"time"
+)
+
+func Test_Starshell(t *testing.T) {
+	star, err := NewStarShell("cmd.exe")
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	go func() {
+		time.Sleep(time.Second * 2)
+		star.WriteCmd("chcp 65001")
+		time.Sleep(time.Second * 2)
+		star.WriteCmd("ping baidu.com -n 10")
+		time.Sleep(time.Second * 12)
+		star.WriteCmd("exit")
+	}()
+	for star.IsRunning() {
+		time.Sleep(time.Millisecond * 100)
+		str, err := star.GetResult()
+		if err != nil {
+			fmt.Println("error:", err)
+		}
+		fmt.Print(str)
+	}
+	fmt.Println(star.ExitCode())
+}
+
+func Test_Starbash(t *testing.T) {
+	star, err := NewStarShell("bash", "-c", "ping baidu.com -c 10")
+	err = star.Start()
+	if err != nil {
+		fmt.Println(err)
+		return
+	}
+	/*
+		go func() {
+			time.Sleep(time.Second * 2)
+			star.WriteCmd("chcp 65001")
+			time.Sleep(time.Second * 2)
+			star.WriteCmd("ping baidu.com -n 10")
+			time.Sleep(time.Second * 12)
+			star.WriteCmd("exit")
+		}()
+	*/
+	for star.IsRunning() {
+		time.Sleep(time.Millisecond * 100)
+		str, err := star.GetResult()
+		if err != nil {
+			fmt.Println("error:", err)
+		}
+		fmt.Print(str)
+	}
+	fmt.Println(star.ExitCode())
+}