starainrt/starainrt.go

package starainrt

import (
	"bufio"
	"bytes"
	"crypto/md5"
	"crypto/rc4"
	"crypto/sha1"
	"crypto/sha256"
	"crypto/sha512"
	"database/sql"
	"encoding/base64"
	"encoding/hex"
	"errors"
	"fmt"
	"hash/crc32"
	"io"
	"io/ioutil"
	"net"
	"net/http"
	"os"
	"os/exec"
	"regexp"
	"strconv"
	"strings"
	"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

func Exists(filepath string) bool {
	_, err := os.Stat(filepath)
	if err != nil && os.IsNotExist(err) {
		return false
	}
	return true
}
func IsFile(fpath string) bool {
	s, err := os.Stat(fpath)
	if err != nil {
		return false
	}
	return !s.IsDir()
}
func IsFolder(fpath string) bool {
	s, err := os.Stat(fpath)
	if err != nil {
		return false
	}
	return s.IsDir()
}
func ReWriteFileByKV(filepath, rem, conn, ret string, kv map[string]string) bool {
	var outputstr string
	var ataru bool = false
	if (!Exists(filepath)) || (!IsFile(filepath)) {
		return false
	}
	fso, err := os.Open(filepath)
	if err != nil {
		return false
	}
	rempar := regexp.MustCompile("^" + rem)
	buf := bufio.NewReader(fso)
	for {
		bytxt, _, eof := buf.ReadLine()
		if eof == io.EOF {
			break
		}
		txt := strings.TrimSpace(string(bytxt))
		if rempar.Match([]byte(txt)) {
			outputstr += txt + ret
			continue
		}
		for k, v := range kv {
			keypar := regexp.MustCompile("^" + k)
			if keypar.Match([]byte(txt)) {
				ataru = true
				outputstr += k + conn + v + ret
				delete(kv, k)
			}
		}
		if ataru {
			ataru = false
			continue
		} else {
			outputstr += txt + ret
		}
	}
	fso.Close()
	if len(kv) != 0 {
		for k, v := range kv {
			outputstr += k + conn + v + ret
			delete(kv, k)
		}
	}
	err = ioutil.WriteFile(filepath, []byte(outputstr), 0755)
	if err != nil {
		return false
	}
	return true
}

func GetINIValue(filepath, rem, conn string, kv []string) (bool, map[string]string) {
	outputstr := make(map[string]string)
	if (!Exists(filepath)) || (!IsFile(filepath)) {
		return false, outputstr
	}
	fso, err := os.Open(filepath)
	if err != nil {
		return false, outputstr
	}
	rempar := regexp.MustCompile("^" + rem)
	buf := bufio.NewReader(fso)
	for {
		bytxt, _, eof := buf.ReadLine()
		if eof == io.EOF {
			break
		}
		txt := strings.TrimSpace(string(bytxt))
		if rempar.Match([]byte(txt)) {
			continue
		}
		var i int = 0
		var v2 string
		for k, v := range kv {
			if v == "" {
				continue
			}
			v2 = ""
			for _, b := range []byte(v) {
				switch string(b) {
				case ".":
					v2 += "\\."
				case "\\":
					v2 += "\\"
				case "-":
					v2 += "\\-"
				case "(":
					v2 += "\\("
				case ")":
					v2 += "\\)"
				case "{":
					v2 += "\\{"
				case "}":
					v2 += "\\}"
				case "[":
					v2 += "\\["
				case "]":
					v2 += "\\]"
				case "$":
					v2 += "\\]$"
				case "^":
					v2 += "\\^"
				default:
					v2 += string(b)
				}
			}
			keypar := regexp.MustCompile("^" + v2 + ".*?" + conn + "(.*)")
			if keypar.Match([]byte(txt)) {
				i++
				kekka := keypar.FindSubmatch([]byte(txt))
				outputstr[v] = string(kekka[1])
				kv[k] = ""
			}
		}
		if i != len(kv) {
			for _, v := range kv {
				if v != "" {
					outputstr[v] = ""
				}
			}
		}
	}
	return true, outputstr
}

func 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 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 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 := 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 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 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 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)
}

func CurlGet(url string) (error, []byte) {
	err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET")
	return err, res
}

func CurlPost(url, postdata string) (error, []byte) {
	err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST")
	return err, res
}
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()

}

func FetchAll(rows *sql.Rows) (error, map[int]map[string]string) {
	var ii int = 0
	records := make(map[int]map[string]string)
	columns, err := rows.Columns()
	if err != nil {
		return err, records
	}
	scanArgs := make([]interface{}, len(columns))
	values := make([]interface{}, len(columns))
	for i := range values {
		scanArgs[i] = &values[i]
	}
	for rows.Next() {
		if err := rows.Scan(scanArgs...); err != nil {
			return err, records
		}
		record := make(map[string]string)
		for i, col := range values {
			switch vtype := col.(type) {
			case int64:
				record[columns[i]] = strconv.FormatInt(vtype, 10)
			case string:
				record[columns[i]] = vtype
			default:
				record[columns[i]] = string(vtype.([]byte))
			}
		}
		records[ii] = record
		ii++
	}
	return nil, records
}

func OpenDB(Method, ConnStr string) error {
	var err error
	DBRes, err = sql.Open(Method, ConnStr)
	if err != nil {
		return err
	}
	err = DBRes.Ping()
	return err
}
func CloseDB() {
	DBRes.Close()
	DBRows.Close()
}

func Query(args ...interface{}) (error, map[int]map[string]string) {
	var err error
	records := make(map[int]map[string]string)
	if err = DBRes.Ping(); err != nil {
		return err, records
	}
	if len(args) == 0 {
		return errors.New("no args"), records
	}
	if len(args) == 1 {
		sql := args[0]
		if DBRows, err = DBRes.Query(sql.(string)); err != nil {
			return err, records
		}
		return FetchAll(DBRows)
	}
	sql := args[0]
	stmt, err := DBRes.Prepare(sql.(string))
	if err != nil {
		return err, records
	}
	var para []interface{}
	for k, v := range args {
		if k != 0 {
			switch vtype := v.(type) {
			default:
				para = append(para, vtype)
			}
		}
	}
	if DBRows, err = stmt.Query(para...); err != nil {
		return err, records
	}
	return FetchAll(DBRows)

}

func DBExec(args ...interface{}) error {
	var err error
	if err = DBRes.Ping(); err != nil {
		return err
	}
	if len(args) == 0 {
		return errors.New("no args")
	}
	if len(args) == 1 {
		sql := args[0]
		if _, err = DBRes.Exec(sql.(string)); err != nil {
			return err
		}
		return nil
	}
	sql := args[0]
	stmt, err := DBRes.Prepare(sql.(string))
	if err != nil {
		return err
	}
	var para []interface{}
	for k, v := range args {
		if k != 0 {
			switch vtype := v.(type) {
			default:
				para = append(para, vtype)
			}
		}
	}
	if _, err = stmt.Exec(para...); err != nil {
		return err
	}
	return nil

}

type suncli struct {
	outfile io.ReadCloser
	infile  io.WriteCloser
	errfile io.ReadCloser
	cmd     *exec.Cmd
	thread  bool
	counter int
}

func (this suncli) IsExit() bool {
	return ShellExit
}

func NewPipeShell(command string, arg ...string) (*suncli, error) {
	var err error
	lovecli := suncli{}
	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
	}
	lovecli.errfile, err = lovecli.cmd.StderrPipe()
	if err != nil {
		return &lovecli, err
	}
	if err := lovecli.cmd.Start(); err != nil {
		return &lovecli, err
	}
	go func() {
		lovecli.cmd.Wait()
	}()
	ShellExit = false
	lovecli.thread = false
	return &lovecli, nil
}

func (this suncli) GetResult(maxtime int) (string, string, bool) {
	var stop bool
	reader := bufio.NewReader(this.outfile)
	erreader := bufio.NewReader(this.errfile)
	if !this.thread {
		this.thread = true
		go func() {
			var line2 string
			var stack bool = false
			stop = false
			for {
				if !stack {
					go func() {
						stack = true
						if erreader.Size() > 0 {
							line2, _ = erreader.ReadString('\n')
							ShellErr += line2
							line2 = ""
						}
						stack = false
					}()
				}
				line, err2 := reader.ReadString('\n')
				if err2 != nil || io.EOF == err2 {
					stop = true
					break
				}
				this.counter++
				ShellRes += line
			}
		}()
	}
	waittm := 0
	for !stop {
		time.Sleep(time.Millisecond * 250)
		waittm += 1
		if maxtime >= 0 {
			if waittm/4 > maxtime {
				restr := ShellRes
				ShellRes = ""
				errstr := ShellErr
				ShellErr = ""
				return restr, errstr, false
			}
		}
	}
	ShellExit = true
	this.thread = false
	restr := ShellRes
	ShellRes = ""
	errstr := ShellErr
	ShellErr = ""
	return restr, errstr, true
}

func (this suncli) Exec(cmdstr string, maxtime int) (string, string, bool) {
	this.infile.Write([]byte(cmdstr + "\n"))
	return this.GetResult(maxtime)
}

func (this suncli) WriteCmd(cmdstr string) {
	this.infile.Write([]byte(cmdstr + "\n"))
	return
}