new starainrt release

master
兔子 5 years ago
parent 81efabb6ca
commit fe167d7281

File diff suppressed because it is too large Load Diff

@ -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)
}

@ -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)
}))
}

@ -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))
}

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

385
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
}

@ -1,22 +1,42 @@
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
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 CurlGet(url string) (error, []byte) {
err, _, res, _, _ := Curl(url, "", HttpNul, HttpNul2, "GET")
return err, res
func (e *CircleByteBuffer) getLen() int {
if e.start == e.end {
return 0
} else if e.start < e.end {
return e.end - e.start
} else {
return e.start - e.end
}
}
//CurlPost发起一个基于表单的HTTP Post请求
func CurlPost(url, postdata string) (error, []byte) {
err, _, res, _, _ := Curl(url, postdata, HttpNul, HttpNul2, "POST")
return err, res
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 {
e.end = pos
}
return nil
}
//HttpNulReset将重置Header和Cookie为空
func HttpNulReset() {
var tmp map[string]string
HttpNul, HttpNul2 = tmp, tmp
func (e *CircleByteBuffer) getByte() (byte, error) {
if e.isClose {
return 0, io.EOF
}
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) {
var req *http.Request
if method == "" {
if len(postdata) != 0 {
method = "POST"
} else {
method = "GET"
/*func (e*CircleByteBuffer)puts(bts []byte){
for i:=0;i<len(bts);i++{
e.put(bts[i])
}
}
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 {
if err == io.EOF {
return ret, err
}
return ret, nil
}
bts[i] = b
ret++
}
BytePostData := []byte(postdata)
if postdata == "" || len(postdata) == 0 {
req, _ = http.NewRequest(method, url, nil)
} else {
req, _ = http.NewRequest(method, url, bytes.NewBuffer(BytePostData))
if e.isClose {
return ret, io.EOF
}
if (len(header) == 0 || header == nil) && method == "POST" {
req.Header.Set("Content-Type", "application/x-www-form-urlencoded")
return ret, nil
}
func (e *CircleByteBuffer) Write(bts []byte) (int, error) {
if e.isClose {
return 0, io.EOF
}
for k, v := range header {
req.Header.Set(k, v)
if bts == nil {
e.isEnd = true
return 0, io.EOF
}
if len(cookie) != 0 {
for k, v := range cookie {
req.AddCookie(&http.Cookie{Name: k, Value: v, HttpOnly: true})
var ret = 0
for i := 0; i < len(bts); i++ {
err := e.putByte(bts[i])
if err != nil {
fmt.Println("Write bts err:", err)
return ret, err
}
ret++
}
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
if e.isClose {
return ret, io.EOF
}
defer resp.Body.Close()
statuscode := resp.StatusCode
hea := resp.Header
body, _ := ioutil.ReadAll(resp.Body)
return nil, statuscode, body, hea, resp.Cookies()
return ret, nil
}

Loading…
Cancel
Save