new starainrt release

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", func(pect float64) {
+		fmt.Printf("已处理%f\r", pect)
+	}))
+}

database.go

@@ -3,9 +3,333 @@ package starainrt
 import (
 	"database/sql"
 	"errors"
+	"reflect"
 	"strconv"
 )
 
+var DBRes *sql.DB
+var DBRows *sql.Rows
+
+type StarDB struct {
+	DB   *sql.DB
+	Rows *sql.Rows
+}
+
+type StarRows struct {
+	Rows         *sql.Rows
+	Length       int
+	StringResult []map[string]string
+	Columns      []string
+	ColumnsType  []reflect.Type
+	columnref    map[string]int
+	result       [][]interface{}
+}
+
+type StarResult struct {
+	Result      []interface{}
+	Columns     []string
+	columnref   map[string]int
+	ColumnsType []reflect.Type
+}
+
+type StarResultCol struct {
+	Result []interface{}
+}
+
+func (this *StarResultCol) MustBytes() [][]byte {
+	var res [][]byte
+	for _, v := range this.Result {
+		res = append(res, v.([]byte))
+	}
+	return res
+}
+
+func (this *StarResultCol) MustBool() []bool {
+	var res []bool
+	for _, v := range this.Result {
+		res = append(res, v.(bool))
+	}
+	return res
+}
+func (this *StarResultCol) MustFloat32() []float32 {
+	var res []float32
+	for _, v := range this.Result {
+		res = append(res, v.(float32))
+	}
+	return res
+}
+func (this *StarResultCol) MustFloat64() []float64 {
+	var res []float64
+	for _, v := range this.Result {
+		res = append(res, v.(float64))
+	}
+	return res
+}
+func (this *StarResultCol) MustString() []string {
+	var res []string
+	for _, v := range this.Result {
+		res = append(res, v.(string))
+	}
+	return res
+}
+func (this *StarResultCol) MustInt32() []int32 {
+	var res []int32
+	for _, v := range this.Result {
+		res = append(res, v.(int32))
+	}
+	return res
+}
+func (this *StarResultCol) MustInt64() []int64 {
+	var res []int64
+	for _, v := range this.Result {
+		res = append(res, v.(int64))
+	}
+	return res
+}
+func (this *StarResultCol) MustInt() []int {
+	var res []int
+	for _, v := range this.Result {
+		res = append(res, v.(int))
+	}
+	return res
+}
+
+func (this *StarResult) MustInt64(name string) int64 {
+	num, ok := this.columnref[name]
+	if !ok {
+		return 0
+	}
+	res := this.Result[num].(int64)
+	return res
+}
+func (this *StarResult) MustInt32(name string) int32 {
+	num, ok := this.columnref[name]
+	if !ok {
+		return 0
+	}
+	res := this.Result[num].(int32)
+	return res
+}
+func (this *StarResult) MustString(name string) string {
+	num, ok := this.columnref[name]
+	if !ok {
+		return ""
+	}
+	res := this.Result[num].(string)
+	return res
+}
+func (this *StarResult) MustFloat64(name string) float64 {
+	num, ok := this.columnref[name]
+	if !ok {
+		return 0
+	}
+	res := this.Result[num].(float64)
+	return res
+}
+func (this *StarResult) MustFloat32(name string) float32 {
+	num, ok := this.columnref[name]
+	if !ok {
+		return 0
+	}
+	res := this.Result[num].(float32)
+	return res
+}
+func (this *StarResult) MustInt(name string) int {
+	num, ok := this.columnref[name]
+	if !ok {
+		return 0
+	}
+	res := this.Result[num].(int)
+	return res
+}
+
+func (this *StarResult) MustBool(name string) bool {
+	num, ok := this.columnref[name]
+	if !ok {
+		return false
+	}
+	res := this.Result[num].(bool)
+	return res
+}
+func (this *StarResult) MustBytes(name string) []byte {
+	num, ok := this.columnref[name]
+	if !ok {
+		return []byte{}
+	}
+	res := this.Result[num].([]byte)
+	return res
+}
+
+func (this *StarRows) Rescan() {
+	this.parserows()
+}
+
+func (this *StarRows) Col(name string) *StarResultCol {
+	result := new(StarResultCol)
+	if _, ok := this.columnref[name]; !ok {
+		return result
+	}
+	var rescol []interface{}
+	for _, v := range this.result {
+		rescol = append(rescol, v[this.columnref[name]])
+	}
+	result.Result = rescol
+	return result
+}
+
+func (this *StarRows) Row(id int) *StarResult {
+	result := new(StarResult)
+	if id+1 > len(this.result) {
+		return result
+	}
+	result.Result = this.result[id]
+	result.Columns = this.Columns
+	result.ColumnsType = this.ColumnsType
+	result.columnref = this.columnref
+	return result
+}
+
+func (this *StarRows) Close() error {
+	return this.Rows.Close()
+}
+
+func (this *StarRows) parserows() {
+	this.result = [][]interface{}{}
+	this.columnref = make(map[string]int)
+	this.StringResult = []map[string]string{make(map[string]string)}
+	this.Columns, _ = this.Rows.Columns()
+	types, _ := this.Rows.ColumnTypes()
+	for _, v := range types {
+		this.ColumnsType = append(this.ColumnsType, v.ScanType())
+	}
+	scanArgs := make([]interface{}, len(this.Columns))
+	values := make([]interface{}, len(this.Columns))
+	for i, _ := range values {
+		this.columnref[this.Columns[i]] = i
+		scanArgs[i] = &values[i]
+	}
+	for this.Rows.Next() {
+		if err := this.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 float64:
+				record[this.Columns[i]] = strconv.FormatFloat(vtype, 'f', -1, 64)
+			case int64:
+				record[this.Columns[i]] = strconv.FormatInt(vtype, 10)
+			case string:
+				record[this.Columns[i]] = vtype
+			case nil:
+				record[this.Columns[i]] = ""
+			default:
+				record[this.Columns[i]] = string(vtype.([]byte))
+			}
+		}
+		this.result = append(this.result, rescopy)
+		this.StringResult = append(this.StringResult, record)
+	}
+	this.Length = len(this.StringResult)
+}
+
+func (this *StarDB) Query(args ...interface{}) (*StarRows, error) {
+	var err error
+	effect := new(StarRows)
+	if err = this.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 this.Rows, err = this.DB.Query(sql.(string)); err != nil {
+			return effect, err
+		}
+		effect.Rows = this.Rows
+		effect.parserows()
+		return effect, nil
+	}
+	sql := args[0]
+	stmt, err := this.DB.Prepare(sql.(string))
+	defer stmt.Close()
+	if err != nil {
+		return effect, err
+	}
+	var para []interface{}
+	for k, v := range args {
+		if k != 0 {
+			switch vtype := v.(type) {
+			default:
+				para = append(para, vtype)
+			}
+		}
+	}
+	if this.Rows, err = stmt.Query(para...); err != nil {
+		return effect, err
+	}
+	effect.Rows = this.Rows
+	effect.parserows()
+	return effect, nil
+}
+
+func (this *StarDB) Open(Method, ConnStr string) error {
+	var err error
+	this.DB, err = sql.Open(Method, ConnStr)
+	if err != nil {
+		return err
+	}
+	err = this.DB.Ping()
+	return err
+}
+
+func (this *StarDB) Close() error {
+	if err := this.DB.Close(); err != nil {
+		return err
+	}
+	return this.Rows.Close()
+}
+
+func (this *StarDB) Exec(args ...interface{}) (sql.Result, error) {
+	var err error
+	var effect sql.Result
+	if err = this.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 = this.DB.Exec(sql.(string)); err != nil {
+			return effect, err
+		}
+		return effect, nil
+	}
+	sql := args[0]
+	stmt, err := this.DB.Prepare(sql.(string))
+	defer stmt.Close()
+	if err != nil {
+		return effect, err
+	}
+	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
+}
+
 func FetchAll(rows *sql.Rows) (error, map[int]map[string]string) {
 	var ii int = 0
 	records := make(map[int]map[string]string)
@@ -31,6 +355,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))
 			}

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"))
+}

net.go

@@ -0,0 +1,385 @@
+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})
+}
+
+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, 1048576)
+			n, err = fpsrc.Read(bufs)
+			if err != nil {
+				if err == io.EOF {
+					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) 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, 1048576)
+		n, err = fpsrc.Read(bufs)
+		if err != nil {
+			if err == io.EOF {
+				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, 1048576)
+		n, err = resp.Body.Read(buf)
+		if err != nil {
+			if err == io.EOF {
+				err = nil
+				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
+}

starainrt.go

@@ -1,22 +1,42 @@
 package starainrt
 
 import (
-	"bytes"
+	"errors"
-	"database/sql"
+	"fmt"
-	"io/ioutil"
+	"io"
-	"net"
-	"net/http"
 	"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
 
+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
+}
+
 //Exits返回指定文件夹/文件是否存在
 func Exists(filepath string) bool {
 	_, err := os.Stat(filepath)
@@ -46,74 +66,128 @@ func IsFolder(fpath string) bool {
 	return s.IsDir()
 }
 
-//CurlGet发起一个HTTP GET请求
+func (e *CircleByteBuffer) getLen() int {
-func CurlGet(url string) (error, []byte) {
+	if e.start == e.end {
-	err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET")
+		return 0
-	return err, res
+	} else if e.start < e.end {
+		return e.end - e.start
+	} else {
+		return e.start - e.end
+	}
 }
-
+func (e *CircleByteBuffer) getFree() int {
-//CurlPost发起一个基于表单的HTTP Post请求
+	return e.size - e.getLen()
-func CurlPost(url, postdata string) (error, []byte) {
+}
-	err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST")
+func (e *CircleByteBuffer) putByte(b byte) error {
-	return err, res
+	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 {
+		e.end = pos
+	}
+	return nil
 }
 
-//HttpNulReset将重置Header和Cookie为空
+func (e *CircleByteBuffer) getByte() (byte, error) {
-func HttpNulReset() {
+	if e.isClose {
-	var tmp map[string]string
+		return 0, io.EOF
-	HttpNul, HttpNul2 = tmp, tmp
+	}
+	if e.isEnd && e.getLen() <= 0 {
+		return 0, io.EOF
+	}
+	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 Curl(url string, postdata string, header map[string]string, cookie map[string]string, method string) (error, int, []byte, http.Header, []*http.Cookie) {
+/*func (e*CircleByteBuffer)puts(bts []byte){
-	var req *http.Request
+	for i:=0;i<len(bts);i++{
-	if method == "" {
+		e.put(bts[i])
-		if len(postdata) != 0 {
+	}
-			method = "POST"
+}
-		} else {
+func (e*CircleByteBuffer)gets(bts []byte)int{
-			method = "GET"
+	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 {
+			if err == io.EOF {
+				return ret, err
+			}
+			return ret, nil
 		}
+		bts[i] = b
+		ret++
 	}
-	BytePostData := []byte(postdata)
+	if e.isClose {
-	if postdata == "" || len(postdata) == 0 {
+		return ret, io.EOF
-		req, _ = http.NewRequest(method, url, nil)
-	} else {
-		req, _ = http.NewRequest(method, url, bytes.NewBuffer(BytePostData))
 	}
-
+	return ret, nil
-	if (len(header) == 0 || header == nil) && method == "POST" {
+}
-		req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
+func (e *CircleByteBuffer) Write(bts []byte) (int, error) {
+	if e.isClose {
+		return 0, io.EOF
 	}
-	for k, v := range header {
+	if bts == nil {
-		req.Header.Set(k, v)
+		e.isEnd = true
+		return 0, io.EOF
 	}
-	if len(cookie) != 0 {
+	var ret = 0
-		for k, v := range cookie {
+	for i := 0; i < len(bts); i++ {
-			req.AddCookie(&http.Cookie{Name: k, Value: v, HttpOnly: true})
+		err := e.putByte(bts[i])
+		if err != nil {
+			fmt.Println("Write bts err:", err)
+			return ret, err
 		}
-
+		ret++
 	}
-	client := &http.Client{
+	if e.isClose {
-		Transport: &http.Transport{
+		return ret, io.EOF
-			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()
+	return ret, nil
-
-	statuscode := resp.StatusCode
-	hea := resp.Header
-	body, _ := ioutil.ReadAll(resp.Body)
-	return nil, statuscode, body, hea, resp.Cookies()
-
 }