init
This commit is contained in:
commit
eb9f7b8031
9
vtqe/cmd.go
Normal file
9
vtqe/cmd.go
Normal file
@ -0,0 +1,9 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"Victorique/vtqe/tools"
|
||||
)
|
||||
|
||||
func main() {
|
||||
tools.Maincmd.Execute()
|
||||
}
|
||||
46
vtqe/tools/attach.go
Normal file
46
vtqe/tools/attach.go
Normal file
@ -0,0 +1,46 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"b612.me/starainrt"
|
||||
"b612.me/starlog"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var attachcmd = &cobra.Command{
|
||||
Use: "attach",
|
||||
Short: "合并两个文件",
|
||||
Long: "合并两个文件",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
var src, dst, out string
|
||||
if len(args) == 3 {
|
||||
src = args[0]
|
||||
dst = args[1]
|
||||
out = args[2]
|
||||
} else {
|
||||
src, _ = this.Flags().GetString("src")
|
||||
dst, _ = this.Flags().GetString("dst")
|
||||
out, _ = this.Flags().GetString("out")
|
||||
}
|
||||
if src == "" || dst == "" {
|
||||
starlog.Println("ERROR PATH", "red", "b")
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
cryp := new(starainrt.StarCrypto)
|
||||
err := cryp.Attach(src, dst, out)
|
||||
if err != nil {
|
||||
starlog.Println(err.Error, "red", "b")
|
||||
} else {
|
||||
fmt.Println("完成")
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
attachcmd.Flags().StringP("src", "s", "", "源文件路径")
|
||||
attachcmd.Flags().StringP("dst", "d", "", "目标文件路径")
|
||||
attachcmd.Flags().StringP("out", "o", "", "输出文件路径")
|
||||
Maincmd.AddCommand(attachcmd)
|
||||
}
|
||||
61
vtqe/tools/base64.go
Normal file
61
vtqe/tools/base64.go
Normal file
@ -0,0 +1,61 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"b612.me/starainrt"
|
||||
"b612.me/starlog"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var b64cmd = &cobra.Command{
|
||||
Use: "base64",
|
||||
Short: "使用base64处理文件或字符串",
|
||||
Long: "使用base64处理文件或字符串",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
var err error
|
||||
ok, _ := this.Flags().GetBool("file")
|
||||
de, _ := this.Flags().GetBool("decode")
|
||||
if len(args) != 1 {
|
||||
starlog.Println("参数不足，请输入文件地址或字符串", "red", "b")
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
shell := func(pect float64) {
|
||||
if pect == 100 {
|
||||
fmt.Println("已处理：100.000000%")
|
||||
} else {
|
||||
fmt.Printf("已处理：%f%%\r", pect)
|
||||
}
|
||||
}
|
||||
cry := new(starainrt.StarCrypto)
|
||||
if ok {
|
||||
path, _ := this.Flags().GetString("path")
|
||||
if !de {
|
||||
err = cry.Base64EncodeFile(args[0], path, shell)
|
||||
} else {
|
||||
err = cry.Base64DecodeFile(args[0], path, shell)
|
||||
}
|
||||
} else {
|
||||
if !de {
|
||||
data := cry.Base64Encode([]byte(args[0]))
|
||||
fmt.Println(data)
|
||||
} else {
|
||||
var data []byte
|
||||
data, err = cry.Base64Decode(args[0])
|
||||
fmt.Println(string(data))
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
starlog.Println(err, "red", "b")
|
||||
return
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
b64cmd.Flags().BoolP("file", "f", false, "base64处理文件")
|
||||
b64cmd.Flags().StringP("path", "p", "./b64.encode", "指定处理地址，默认为./b64.encode")
|
||||
b64cmd.Flags().BoolP("decode", "d", false, "base64解码")
|
||||
Maincmd.AddCommand(b64cmd)
|
||||
}
|
||||
18
vtqe/tools/cmd.go
Normal file
18
vtqe/tools/cmd.go
Normal file
@ -0,0 +1,18 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var Version string = "0.1.12"
|
||||
|
||||
var Maincmd = &cobra.Command{
|
||||
Use: "",
|
||||
Short: "Victorique's Small Smart Toolkit",
|
||||
Long: "Victorique's Small Smart Toolkit",
|
||||
}
|
||||
|
||||
func init() {
|
||||
cobra.MousetrapHelpText = ""
|
||||
Maincmd.Version = Version
|
||||
}
|
||||
210
vtqe/tools/curl.go
Normal file
210
vtqe/tools/curl.go
Normal file
@ -0,0 +1,210 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"strings"
|
||||
|
||||
"b612.me/starainrt"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var curlcmd = &cobra.Command{
|
||||
Use: "curl",
|
||||
Short: "Curl工具",
|
||||
Long: "Curl小工具",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
var method string
|
||||
var err error
|
||||
var data []byte
|
||||
o, _ := this.Flags().GetString("output")
|
||||
d, _ := this.Flags().GetString("data")
|
||||
f, _ := this.Flags().GetString("file")
|
||||
h, _ := this.Flags().GetString("header")
|
||||
c, _ := this.Flags().GetString("cookie")
|
||||
b, _ := this.Flags().GetString("cookie-jar")
|
||||
i, _ := this.Flags().GetBool("include")
|
||||
x, _ := this.Flags().GetString("proxy")
|
||||
m, _ := this.Flags().GetInt("max-time")
|
||||
ua, _ := this.Flags().GetString("user-agent")
|
||||
connecttimeout, _ := this.Flags().GetInt("connect-timeout")
|
||||
if len(args) != 1 {
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
url := args[0]
|
||||
shell := func(pect float64) {
|
||||
if pect == 100 {
|
||||
fmt.Println("已完成：100.000000%")
|
||||
} else {
|
||||
fmt.Printf("已完成：%f%%\r", pect)
|
||||
}
|
||||
}
|
||||
var postdata map[string]string
|
||||
if d != "" {
|
||||
postdata = make(map[string]string)
|
||||
strip := strings.Split(d, "&")
|
||||
for _, v := range strip {
|
||||
tmp := strings.Split(v, "=")
|
||||
if len(tmp) != 2 {
|
||||
continue
|
||||
}
|
||||
postdata[tmp[0]] = tmp[1]
|
||||
}
|
||||
}
|
||||
if len(d) == 0 {
|
||||
method = "GET"
|
||||
} else {
|
||||
method = "POST"
|
||||
}
|
||||
tmp := strings.Split(f, ",")
|
||||
curl := starainrt.NewStarCurl()
|
||||
curl.TimeOut = m
|
||||
curl.DialTimeOut = connecttimeout
|
||||
curl.ReqHeader.Set("User-Agent", "Victorique - B612.ME")
|
||||
if ua != "" {
|
||||
curl.ReqHeader.Set("User-Agent", ua)
|
||||
}
|
||||
if x != "" {
|
||||
curl.Proxy = x
|
||||
}
|
||||
if h != "" {
|
||||
head := strings.Split(h, ",")
|
||||
for _, v := range head {
|
||||
hp := strings.Split(v, "=")
|
||||
if len(hp) != 2 {
|
||||
continue
|
||||
}
|
||||
curl.ReqHeader.Set(hp[0], hp[1])
|
||||
}
|
||||
}
|
||||
if c != "" {
|
||||
if starainrt.Exists(c) {
|
||||
ck, err := ioutil.ReadFile(c)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
return
|
||||
}
|
||||
h = strings.TrimSpace(string(ck))
|
||||
}
|
||||
cook := strings.Split(h, ",")
|
||||
for _, v := range cook {
|
||||
hp := strings.Split(v, "=")
|
||||
if len(hp) != 2 {
|
||||
continue
|
||||
}
|
||||
curl.ReqCookies = append(curl.ReqCookies, &http.Cookie{Name: hp[0], Value: hp[1]})
|
||||
}
|
||||
|
||||
}
|
||||
if len(tmp) != 2 && f != "" {
|
||||
fmt.Println("对file应使用逗号分隔区分文件名和路径")
|
||||
return
|
||||
}
|
||||
if o != "" {
|
||||
if f != "" {
|
||||
_, err = curl.CurlWithFile(url, postdata, tmp[0], tmp[1], o, true, shell)
|
||||
|
||||
} else {
|
||||
err = curl.CurlDataToFile(url, []byte(d), method, o, shell)
|
||||
|
||||
}
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
if i {
|
||||
for k, v := range curl.RespHeader {
|
||||
for _, v2 := range v {
|
||||
fmt.Println(k + ":" + v2)
|
||||
}
|
||||
}
|
||||
fmt.Println("\n")
|
||||
var cookiewriter string
|
||||
for _, v := range curl.RespCookies {
|
||||
fmt.Println(v.Name + ":" + v.Value)
|
||||
if b != "" {
|
||||
cookiewriter += v.Name + ":" + v.Value + ","
|
||||
}
|
||||
}
|
||||
fmt.Println("\n\n")
|
||||
if b != "" {
|
||||
ioutil.WriteFile(b, []byte(cookiewriter), 0755)
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if f != "" {
|
||||
data, err = curl.CurlWithFile(url, postdata, tmp[0], tmp[1], "", false, shell)
|
||||
|
||||
} else {
|
||||
data, err = curl.Curl(url, []byte(d), method)
|
||||
}
|
||||
if i {
|
||||
for k, v := range curl.RespHeader {
|
||||
for _, v2 := range v {
|
||||
fmt.Println(k + ":" + v2)
|
||||
}
|
||||
}
|
||||
fmt.Println("\n")
|
||||
var cookiewriter string
|
||||
for _, v := range curl.RespCookies {
|
||||
fmt.Println(v.Name + ":" + v.Value)
|
||||
if b != "" {
|
||||
cookiewriter += v.Name + ":" + v.Value + ","
|
||||
}
|
||||
}
|
||||
fmt.Println("\n\n")
|
||||
if b != "" {
|
||||
ioutil.WriteFile(b, []byte(cookiewriter), 0755)
|
||||
}
|
||||
}
|
||||
fmt.Println(string(data))
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
Maincmd.AddCommand(curlcmd)
|
||||
curlcmd.Flags().StringP("output", "o", "", "写入文件而不是标准输出")
|
||||
curlcmd.Flags().StringP("data", "d", "", "http postdata数据")
|
||||
curlcmd.Flags().StringP("file", "f", "", "上传文件的地址")
|
||||
curlcmd.Flags().StringP("header", "H", "", "使用的header")
|
||||
curlcmd.Flags().StringP("cookie", "b", "", "使用的cookie")
|
||||
curlcmd.Flags().StringP("cookie-jar", "c", "", "写入返回的cookie到文件中")
|
||||
curlcmd.Flags().BoolP("include", "i", false, "显示返回的header与cookie")
|
||||
curlcmd.Flags().StringP("proxy", "x", "", "使用代理")
|
||||
curlcmd.Flags().IntP("max-time", "m", 0, "最大传输超时时间")
|
||||
curlcmd.Flags().Int("connect-timeout", 15, "最大连接建立超时时间")
|
||||
curlcmd.Flags().StringP("user-agent", "A", "", "UA设置")
|
||||
curlcmd.AddCommand(curlupcmd)
|
||||
}
|
||||
|
||||
var curlupcmd = &cobra.Command{
|
||||
Use: "upload",
|
||||
Short: "victorique上传工具",
|
||||
Long: "victorique上传工具",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
if len(args) != 2 {
|
||||
fmt.Println(args, "不合法啊")
|
||||
return
|
||||
}
|
||||
curl := starainrt.NewStarCurl()
|
||||
curl.TimeOut = 0
|
||||
shell := func(pect float64) {
|
||||
if pect == 100 {
|
||||
fmt.Println("已完成：100.000000%")
|
||||
} else {
|
||||
fmt.Printf("已完成：%f%%\r", pect)
|
||||
}
|
||||
}
|
||||
data, err := curl.CurlWithFile("http://"+args[0]+"/vtqeupload1127", nil, "victorique", args[1], "", false, shell)
|
||||
fmt.Println(string(data))
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
},
|
||||
}
|
||||
48
vtqe/tools/detach.go
Normal file
48
vtqe/tools/detach.go
Normal file
@ -0,0 +1,48 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"b612.me/starainrt"
|
||||
"b612.me/starlog"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var detachcmd = &cobra.Command{
|
||||
Use: "detach",
|
||||
Short: "分离两个文件",
|
||||
Long: "分离两个文件",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
var src, dst, out string
|
||||
if len(args) == 3 {
|
||||
src = args[0]
|
||||
dst = args[1]
|
||||
out = args[2]
|
||||
} else {
|
||||
src, _ = this.Flags().GetString("src")
|
||||
dst, _ = this.Flags().GetString("dst")
|
||||
out, _ = this.Flags().GetString("out")
|
||||
}
|
||||
num, _ := this.Flags().GetInt("num")
|
||||
if src == "" || dst == "" {
|
||||
starlog.Println("ERROR PATH", "red", "b")
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
cryp := new(starainrt.StarCrypto)
|
||||
err := cryp.Detach(src, num, dst, out)
|
||||
if err != nil {
|
||||
starlog.Println(err.Error, "red", "b")
|
||||
} else {
|
||||
fmt.Println("完成")
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
detachcmd.Flags().StringP("src", "s", "", "源文件路径")
|
||||
detachcmd.Flags().StringP("dst", "d", "", "目标文件路径1")
|
||||
detachcmd.Flags().StringP("out", "o", "", "目标文件路径2")
|
||||
detachcmd.Flags().IntP("num", "n", 0, "分割开始字节")
|
||||
Maincmd.AddCommand(detachcmd)
|
||||
}
|
||||
50
vtqe/tools/ftp.go
Normal file
50
vtqe/tools/ftp.go
Normal file
@ -0,0 +1,50 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"log"
|
||||
"path/filepath"
|
||||
|
||||
filedriver "github.com/goftp/file-driver"
|
||||
"github.com/goftp/server"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var ports int
|
||||
var username, pwd string
|
||||
|
||||
// ftpCmd represents the ftp command
|
||||
var ftpcmd = &cobra.Command{
|
||||
Use: "ftp",
|
||||
Short: `FTP文件服务器`,
|
||||
Long: `FTP文件服务器`,
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
path, _ = filepath.Abs(path)
|
||||
factory := &filedriver.FileDriverFactory{
|
||||
RootPath: path,
|
||||
Perm: server.NewSimplePerm("user", "group"),
|
||||
}
|
||||
opts := &server.ServerOpts{
|
||||
Factory: factory,
|
||||
Port: ports,
|
||||
Hostname: ip,
|
||||
Auth: &server.SimpleAuth{Name: username, Password: pwd},
|
||||
}
|
||||
|
||||
log.Printf("Starting ftp server on %v:%v", opts.Hostname, opts.Port)
|
||||
log.Printf("Username %v, Password %v", username, pwd)
|
||||
server := server.NewServer(opts)
|
||||
err := server.ListenAndServe()
|
||||
if err != nil {
|
||||
log.Fatal("Error starting server:", err)
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
Maincmd.AddCommand(ftpcmd)
|
||||
ftpcmd.Flags().IntVarP(&ports, "port", "p", 21, "监听端口")
|
||||
ftpcmd.Flags().StringVarP(&ip, "ip", "i", "0.0.0.0", "监听地址")
|
||||
ftpcmd.Flags().StringVarP(&username, "user", "u", "1", "用户名，默认为1")
|
||||
ftpcmd.Flags().StringVarP(&pwd, "pwd", "k", "1", "密码，默认为1")
|
||||
ftpcmd.Flags().StringVarP(&path, "folder", "f", "./", "本地文件地址")
|
||||
}
|
||||
39
vtqe/tools/generate.go
Normal file
39
vtqe/tools/generate.go
Normal file
@ -0,0 +1,39 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"b612.me/starainrt"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var gencmd = &cobra.Command{
|
||||
Use: "generate",
|
||||
Short: "生成随机文件",
|
||||
Long: "生成指定大小的随机文件",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
sum, _ := this.Flags().GetInt("sum")
|
||||
num, _ := this.Flags().GetInt("num")
|
||||
if len(args) != 1 {
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
err := starainrt.FillWithRandom(args[0], num, 1024*1024, sum, func(pect float64) {
|
||||
if pect == 100 {
|
||||
fmt.Println("文件已处理：100.000000%")
|
||||
} else {
|
||||
fmt.Printf("文件已处理：%f%%\r", pect)
|
||||
}
|
||||
})
|
||||
if err != nil {
|
||||
fmt.Println("err:" + err.Error())
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
gencmd.Flags().IntP("sum", "s", 3, "随机的种子组数")
|
||||
gencmd.Flags().IntP("num", "n", 1024, "生成的文件大小")
|
||||
gencmd.MarkFlagRequired("num")
|
||||
Maincmd.AddCommand(gencmd)
|
||||
}
|
||||
71
vtqe/tools/hash.go
Normal file
71
vtqe/tools/hash.go
Normal file
@ -0,0 +1,71 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
|
||||
"b612.me/starainrt"
|
||||
|
||||
"b612.me/starlog"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var hashcmd = &cobra.Command{
|
||||
Use: "hash",
|
||||
Short: "多种方法哈希值校验",
|
||||
Long: "进行多种方法哈希值校验",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
var cumethod, method []string
|
||||
var result map[string]string
|
||||
var err error
|
||||
crypto := new(starainrt.StarCrypto)
|
||||
cumethod = []string{"md5", "crc32", "sha512", "sha384", "sha256", "sha224", "sha1"}
|
||||
if ok, _ := this.Flags().GetBool("all"); ok {
|
||||
method = cumethod
|
||||
} else {
|
||||
if len(args) == 0 {
|
||||
this.Usage()
|
||||
os.Exit(1)
|
||||
}
|
||||
|
||||
for _, v := range cumethod {
|
||||
if ok, _ := this.Flags().GetBool(v); ok {
|
||||
method = append(method, v)
|
||||
}
|
||||
}
|
||||
if len(method) == 0 {
|
||||
method = append(method, "md5")
|
||||
}
|
||||
}
|
||||
if ok, _ := this.Flags().GetBool("file"); ok {
|
||||
result, err = crypto.FileSumAll(args[0], method, func(pect float64) {
|
||||
if pect != 100.0 {
|
||||
fmt.Printf("校验已完成：%f%%\r", pect)
|
||||
} else {
|
||||
fmt.Printf("校验已完成：%f%%\n", pect)
|
||||
}
|
||||
})
|
||||
} else {
|
||||
result, err = crypto.SumAll([]byte(args[0]), method)
|
||||
}
|
||||
if err != nil {
|
||||
starlog.Println("错误："+err.Error(), "red", "")
|
||||
}
|
||||
for _, v := range method {
|
||||
fmt.Printf("%s：%s\n", v, result[v])
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
hashcmd.Flags().BoolP("all", "a", false, "使用所有的校验方法")
|
||||
hashcmd.Flags().BoolP("file", "f", false, "对指定文件进行校验")
|
||||
hashcmd.Flags().BoolP("md5", "m", false, "进行MD5校验（默认）")
|
||||
hashcmd.Flags().BoolP("crc32", "c", false, "进行CRC32校验")
|
||||
hashcmd.Flags().BoolP("sha512", "s", false, "进行SHA512校验")
|
||||
hashcmd.Flags().Bool("sha384", false, "进行SHA384校验")
|
||||
hashcmd.Flags().Bool("sha256", false, "进行SHA256校验")
|
||||
hashcmd.Flags().Bool("sha224", false, "进行SHA224校验")
|
||||
hashcmd.Flags().Bool("sha1", false, "进行SHA1校验")
|
||||
Maincmd.AddCommand(hashcmd)
|
||||
}
|
||||
192
vtqe/tools/http.go
Normal file
192
vtqe/tools/http.go
Normal file
@ -0,0 +1,192 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"os"
|
||||
"path/filepath"
|
||||
"strconv"
|
||||
"strings"
|
||||
|
||||
"b612.me/starainrt"
|
||||
|
||||
"b612.me/starlog"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var port, ip, path string
|
||||
var up bool
|
||||
|
||||
type TraceHandler struct {
|
||||
h http.Handler
|
||||
}
|
||||
|
||||
// httpCmd represents the http command
|
||||
var httpcmd = &cobra.Command{
|
||||
Use: "http",
|
||||
Short: "HTTP文件服务器",
|
||||
Long: `HTTP文件服务器`,
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
http.HandleFunc("/", httplisten)
|
||||
path, _ = filepath.Abs(path)
|
||||
fmt.Println("Listening On Port:" + port)
|
||||
if up {
|
||||
fmt.Println("upload is openned,path is /vtqeupload1127")
|
||||
http.HandleFunc("/vtqeupload1127", uploadfile)
|
||||
}
|
||||
err := http.ListenAndServe(ip+":"+port, nil)
|
||||
if err != nil {
|
||||
starlog.Println("Error:"+err.Error(), "red", "")
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func uploadfile(w http.ResponseWriter, r *http.Request) {
|
||||
if r.Method != "POST" {
|
||||
w.Write([]byte("USE POST METHOD!"))
|
||||
return
|
||||
}
|
||||
r.ParseMultipartForm(10485760)
|
||||
file, handler, err := r.FormFile("victorique")
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
w.WriteHeader(502)
|
||||
w.Write([]byte(err.Error()))
|
||||
return
|
||||
}
|
||||
defer file.Close()
|
||||
fmt.Printf("Upload %s From %s\n", handler.Filename, r.RemoteAddr)
|
||||
fmt.Fprintf(w, `<html><body><p>%v</p><h2><a href="./vtqeupload1127/web">Return To Web Page</a></h2></body></html>`, handler.Header)
|
||||
os.Mkdir("./vtqeupload1127", 0755)
|
||||
f, err := os.OpenFile("./vtqeupload1127/"+handler.Filename, os.O_WRONLY|os.O_CREATE, 0755)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
return
|
||||
}
|
||||
defer f.Close()
|
||||
io.Copy(f, file)
|
||||
}
|
||||
|
||||
func httplisten(w http.ResponseWriter, r *http.Request) {
|
||||
w.Header().Set("Server", "Vicorique")
|
||||
p := r.URL.Path
|
||||
cmd := r.URL.Query()["cmd"]
|
||||
fmt.Println("Get " + p + " " + r.RemoteAddr)
|
||||
fullpath, _ := filepath.Abs(path + p)
|
||||
|
||||
if p == "/" {
|
||||
ReadFolder(w, r, fullpath, true)
|
||||
return
|
||||
}
|
||||
if up {
|
||||
if p == "/vtqeupload1127/web" {
|
||||
w.Write([]byte(`<html><body><form id= "uploadForm" action= "../vtqeupload1127" method= "post" enctype ="multipart/form-data">
|
||||
<h1 >Victorique's File Upload Page </h1>
|
||||
<p >上传文件： <input type ="file" name="victorique" /></p>
|
||||
<input type ="submit" value="上传"/>
|
||||
</form>
|
||||
<h2>Copyright@b612.me </h2></body></html>`))
|
||||
return
|
||||
}
|
||||
}
|
||||
if !starainrt.Exists(fullpath) {
|
||||
w.WriteHeader(404)
|
||||
if len(cmd) != 0 {
|
||||
if cmd[0] == "header" {
|
||||
for k, v := range r.Header {
|
||||
for _, v2 := range v {
|
||||
fmt.Fprintf(w, "%s:%s\n", k, v2)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
w.Write([]byte("<h1>404 NOT FOUND</h1>"))
|
||||
return
|
||||
}
|
||||
if starainrt.IsFolder(fullpath) {
|
||||
ReadFolder(w, r, fullpath, false)
|
||||
return
|
||||
}
|
||||
fpdst, err := os.Open(fullpath)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
w.WriteHeader(502)
|
||||
w.Write([]byte("<h1>502 ERROR</h1>"))
|
||||
return
|
||||
}
|
||||
fpinfo, _ := os.Stat(fullpath)
|
||||
name := filepath.Base(fullpath)
|
||||
tmp := strings.Split(name, ".")
|
||||
ext := ""
|
||||
if len(tmp) >= 2 {
|
||||
ext = strings.ToLower(tmp[len(tmp)-1])
|
||||
}
|
||||
switch ext {
|
||||
case "jpeg", "jpg", "jpe":
|
||||
w.Header().Set("Content-Type", "image/jpeg")
|
||||
case "mpeg", "mpg", "mkv":
|
||||
w.Header().Set("Content-Type", "video/mpeg")
|
||||
case "mp4":
|
||||
w.Header().Set("Content-Type", "video/mp4")
|
||||
case "pdf":
|
||||
w.Header().Set("Content-Type", "application/pdf")
|
||||
default:
|
||||
w.Header().Set("Content-Type", "application/download")
|
||||
w.Header().Set("Content-Disposition", "attachment;filename="+name)
|
||||
}
|
||||
w.Header().Set("Content-Transfer-Encoding", "binary")
|
||||
w.Header().Set("Accept-Ranges", "bytes")
|
||||
w.Header().Set("Content-Length", strconv.Itoa(int(fpinfo.Size())))
|
||||
w.WriteHeader(200)
|
||||
defer fpdst.Close()
|
||||
for {
|
||||
buf := make([]byte, 1048576)
|
||||
n, err := fpdst.Read(buf)
|
||||
if err != nil {
|
||||
if err == io.EOF {
|
||||
break
|
||||
}
|
||||
return
|
||||
}
|
||||
w.Write(buf[0:n])
|
||||
}
|
||||
}
|
||||
|
||||
func ReadFolder(w http.ResponseWriter, r *http.Request, fullpath string, isroot bool) {
|
||||
dir, err := ioutil.ReadDir(fullpath)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
w.WriteHeader(403)
|
||||
w.Write([]byte("<h1>Cannot Access!</h1>"))
|
||||
return
|
||||
}
|
||||
w.Write([]byte("<html>\n<style>\np{margin: 2px auto}\n</style>\n<h1>Victorique Http Server - " + Version + "</h1>"))
|
||||
if up {
|
||||
w.Write([]byte("<a href=/vtqeupload1127/web>Upload Web Page Is Openned!</a><br /><br />"))
|
||||
}
|
||||
w.Write([]byte("<hr /><pre>\n"))
|
||||
if !isroot {
|
||||
w.Write([]byte(fmt.Sprintf("<p><a href='%s'>%s</a> %s</p>\n", "..", "..", "上层文件夹")))
|
||||
}
|
||||
for _, v := range dir {
|
||||
if v.Name() != "." || v.Name() != ".." {
|
||||
if !v.IsDir() {
|
||||
w.Write([]byte(fmt.Sprintf("<p><a href='%s'>%s</a> %d %s</p>\n", r.URL.Path+"/"+v.Name(), v.Name(), int(v.Size()), v.ModTime().Format("2006-01-02 15:04:05"))))
|
||||
} else {
|
||||
w.Write([]byte(fmt.Sprintf("<p><a href='%s'>%s</a> %s %s</p>\n", v.Name(), v.Name(), "文件夹", v.ModTime().Format("2006-01-02 15:04:05"))))
|
||||
}
|
||||
}
|
||||
}
|
||||
w.Write([]byte("</pre>\n</html>"))
|
||||
return
|
||||
}
|
||||
func init() {
|
||||
httpcmd.Flags().StringVarP(&port, "port", "p", "80", "监听端口")
|
||||
httpcmd.Flags().StringVarP(&ip, "ip", "i", "0.0.0.0", "监听ip")
|
||||
httpcmd.Flags().StringVarP(&path, "folder", "f", "./", "本地文件地址")
|
||||
httpcmd.Flags().BoolVarP(&up, "upload", "u", false, "是否开启文件上传")
|
||||
Maincmd.AddCommand(httpcmd)
|
||||
}
|
||||
48
vtqe/tools/merge.go
Normal file
48
vtqe/tools/merge.go
Normal file
@ -0,0 +1,48 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
|
||||
"b612.me/starainrt"
|
||||
"b612.me/starlog"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var mergecmd = &cobra.Command{
|
||||
Use: "merge",
|
||||
Short: "合并文件",
|
||||
Long: "按路径自动合并分割的文件",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
var src, dst string
|
||||
if len(args) == 2 {
|
||||
src = args[0]
|
||||
dst = args[1]
|
||||
} else {
|
||||
src, _ = this.Flags().GetString("src")
|
||||
dst, _ = this.Flags().GetString("dst")
|
||||
}
|
||||
if src == "" || dst == "" {
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
crypto := new(starainrt.StarCrypto)
|
||||
err := crypto.MergeFile(src, dst, func(pect float64) {
|
||||
if pect == 100 {
|
||||
fmt.Println("文件已处理：100.000000%")
|
||||
} else {
|
||||
fmt.Printf("文件已处理：%f%%\r", pect)
|
||||
}
|
||||
})
|
||||
if err != nil {
|
||||
starlog.Println(err.Error, "red", "")
|
||||
}
|
||||
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
mergecmd.Flags().StringP("src", "s", "", "源文件地址，用*替换文件数字")
|
||||
mergecmd.Flags().StringP("dst", "d", "", "目标文件地址")
|
||||
Maincmd.AddCommand(mergecmd)
|
||||
}
|
||||
17
vtqe/tools/ping/fqdn.go
Normal file
17
vtqe/tools/ping/fqdn.go
Normal file
@ -0,0 +1,17 @@
|
||||
package ping
|
||||
|
||||
import "net"
|
||||
|
||||
// GetIP ...
|
||||
func GetIP(hostname string) string {
|
||||
addrs, err := net.LookupIP(hostname)
|
||||
if err != nil {
|
||||
return ""
|
||||
}
|
||||
for _, addr := range addrs {
|
||||
if ipv4 := addr.To4(); ipv4 != nil {
|
||||
return ipv4.String()
|
||||
}
|
||||
}
|
||||
return ""
|
||||
}
|
||||
120
vtqe/tools/ping/http.go
Normal file
120
vtqe/tools/ping/http.go
Normal file
@ -0,0 +1,120 @@
|
||||
package ping
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"io"
|
||||
"io/ioutil"
|
||||
"net/http"
|
||||
"net/http/httptrace"
|
||||
"time"
|
||||
)
|
||||
|
||||
// HTTPing ...
|
||||
type HTTPing struct {
|
||||
target *Target
|
||||
done chan struct{}
|
||||
result *Result
|
||||
Method string
|
||||
}
|
||||
|
||||
var _ Pinger = (*HTTPing)(nil)
|
||||
|
||||
// NewHTTPing return new HTTPing
|
||||
func NewHTTPing(method string) *HTTPing {
|
||||
return &HTTPing{
|
||||
done: make(chan struct{}),
|
||||
Method: method,
|
||||
}
|
||||
}
|
||||
|
||||
// SetTarget ...
|
||||
func (ping *HTTPing) SetTarget(target *Target) {
|
||||
ping.target = target
|
||||
if ping.result == nil {
|
||||
ping.result = &Result{Target: target}
|
||||
}
|
||||
}
|
||||
|
||||
// Start ping
|
||||
func (ping *HTTPing) Start() <-chan struct{} {
|
||||
go func() {
|
||||
t := time.NewTicker(ping.target.Interval)
|
||||
defer t.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-t.C:
|
||||
if ping.result.Counter >= ping.target.Counter && ping.target.Counter != 0 {
|
||||
ping.Stop()
|
||||
return
|
||||
}
|
||||
duration, resp, remoteAddr, err := ping.ping()
|
||||
ping.result.Counter++
|
||||
|
||||
if err != nil {
|
||||
fmt.Printf("Ping %s - failed: %s\n", ping.target, err)
|
||||
} else {
|
||||
defer resp.Body.Close()
|
||||
length, _ := io.Copy(ioutil.Discard, resp.Body)
|
||||
fmt.Printf("Ping %s(%s) - %s is open - time=%s method=%s status=%d bytes=%d\n", ping.target, remoteAddr, ping.target.Protocol, duration, ping.Method, resp.StatusCode, length)
|
||||
if ping.result.MinDuration == 0 {
|
||||
ping.result.MinDuration = duration
|
||||
}
|
||||
if ping.result.MaxDuration == 0 {
|
||||
ping.result.MaxDuration = duration
|
||||
}
|
||||
ping.result.SuccessCounter++
|
||||
if duration > ping.result.MaxDuration {
|
||||
ping.result.MaxDuration = duration
|
||||
} else if duration < ping.result.MinDuration {
|
||||
ping.result.MinDuration = duration
|
||||
}
|
||||
ping.result.TotalDuration += duration
|
||||
}
|
||||
case <-ping.done:
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
return ping.done
|
||||
}
|
||||
|
||||
// Result return ping result
|
||||
func (ping *HTTPing) Result() *Result {
|
||||
return ping.result
|
||||
}
|
||||
|
||||
// Stop the tcping
|
||||
func (ping *HTTPing) Stop() {
|
||||
ping.done <- struct{}{}
|
||||
}
|
||||
|
||||
func (ping HTTPing) ping() (time.Duration, *http.Response, string, error) {
|
||||
var resp *http.Response
|
||||
var body io.Reader
|
||||
if ping.Method == "POST" {
|
||||
body = bytes.NewBufferString("{}")
|
||||
}
|
||||
req, err := http.NewRequest(ping.Method, ping.target.String(), body)
|
||||
req.Header.Set(http.CanonicalHeaderKey("User-Agent"), "tcping")
|
||||
if err != nil {
|
||||
return 0, nil, "", err
|
||||
}
|
||||
var remoteAddr string
|
||||
trace := &httptrace.ClientTrace{
|
||||
ConnectStart: func(network, addr string) {
|
||||
remoteAddr = addr
|
||||
},
|
||||
}
|
||||
req = req.WithContext(httptrace.WithClientTrace(req.Context(), trace))
|
||||
duration, errIfce := timeIt(func() interface{} {
|
||||
client := http.Client{Timeout: ping.target.Timeout}
|
||||
resp, err = client.Do(req)
|
||||
return err
|
||||
})
|
||||
if errIfce != nil {
|
||||
err := errIfce.(error)
|
||||
return 0, nil, "", err
|
||||
}
|
||||
return time.Duration(duration), resp, remoteAddr, nil
|
||||
}
|
||||
149
vtqe/tools/ping/ping.go
Normal file
149
vtqe/tools/ping/ping.go
Normal file
@ -0,0 +1,149 @@
|
||||
package ping
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"fmt"
|
||||
"html/template"
|
||||
"regexp"
|
||||
"strconv"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
// Protocol ...
|
||||
type Protocol int
|
||||
|
||||
func (protocol Protocol) String() string {
|
||||
switch protocol {
|
||||
case TCP:
|
||||
return "tcp"
|
||||
case HTTP:
|
||||
return "http"
|
||||
case HTTPS:
|
||||
return "https"
|
||||
}
|
||||
return "unkown"
|
||||
}
|
||||
|
||||
const (
|
||||
// TCP is tcp protocol
|
||||
TCP Protocol = iota
|
||||
// HTTP is http protocol
|
||||
HTTP
|
||||
// HTTPS is https protocol
|
||||
HTTPS
|
||||
)
|
||||
|
||||
// NewProtocol convert protocol stirng to Protocol
|
||||
func NewProtocol(protocol string) (Protocol, error) {
|
||||
switch strings.ToLower(protocol) {
|
||||
case TCP.String():
|
||||
return TCP, nil
|
||||
case HTTP.String():
|
||||
return HTTP, nil
|
||||
case HTTPS.String():
|
||||
return HTTPS, nil
|
||||
}
|
||||
return 0, fmt.Errorf("protocol %s not support", protocol)
|
||||
}
|
||||
|
||||
// Target is a ping
|
||||
type Target struct {
|
||||
Protocol Protocol
|
||||
Host string
|
||||
Port int
|
||||
|
||||
Counter int
|
||||
Interval time.Duration
|
||||
Timeout time.Duration
|
||||
}
|
||||
|
||||
func (target Target) String() string {
|
||||
return fmt.Sprintf("%s://%s:%d", target.Protocol, target.Host, target.Port)
|
||||
}
|
||||
|
||||
// Pinger is a ping interface
|
||||
type Pinger interface {
|
||||
Start() <-chan struct{}
|
||||
Stop()
|
||||
Result() *Result
|
||||
SetTarget(target *Target)
|
||||
}
|
||||
|
||||
// Ping is a ping interface
|
||||
type Ping interface {
|
||||
Start() <-chan struct{}
|
||||
|
||||
Host() string
|
||||
Port() int
|
||||
Protocol() Protocol
|
||||
Counter() int
|
||||
|
||||
Stop()
|
||||
|
||||
Result() Result
|
||||
}
|
||||
|
||||
// Result ...
|
||||
type Result struct {
|
||||
Counter int
|
||||
SuccessCounter int
|
||||
Target *Target
|
||||
|
||||
MinDuration time.Duration
|
||||
MaxDuration time.Duration
|
||||
TotalDuration time.Duration
|
||||
}
|
||||
|
||||
// Avg return the average time of ping
|
||||
func (result Result) Avg() time.Duration {
|
||||
if result.SuccessCounter == 0 {
|
||||
return 0
|
||||
}
|
||||
return result.TotalDuration / time.Duration(result.SuccessCounter)
|
||||
}
|
||||
|
||||
// Failed return failed counter
|
||||
func (result Result) Failed() int {
|
||||
return result.Counter - result.SuccessCounter
|
||||
}
|
||||
|
||||
func (result Result) String() string {
|
||||
const resultTpl = `
|
||||
Ping statistics {{.Target}}
|
||||
{{.Counter}} probes sent.
|
||||
{{.SuccessCounter}} successful, {{.Failed}} failed.
|
||||
Approximate trip times:
|
||||
Minimum = {{.MinDuration}}, Maximum = {{.MaxDuration}}, Average = {{.Avg}}`
|
||||
t := template.Must(template.New("result").Parse(resultTpl))
|
||||
res := bytes.NewBufferString("")
|
||||
t.Execute(res, result)
|
||||
return res.String()
|
||||
}
|
||||
|
||||
// CheckURI check uri
|
||||
func CheckURI(uri string) (schema, host string, port int, matched bool) {
|
||||
const reExp = `^((?P<schema>((ht|f)tp(s?))|tcp)\://)?((([a-zA-Z0-9_\-]+\.)+[a-zA-Z]{2,})|((?:(?:25[0-5]|2[0-4]\d|[01]\d\d|\d?\d)((\.?\d)\.)){4})|(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9])\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[1-9]|0)\.(25[0-5]|2[0-4][0-9]|[0-1]{1}[0-9]{2}|[1-9]{1}[0-9]{1}|[0-9]))(:([0-9]+))?(/[a-zA-Z0-9\-\._\?\,\'/\\\+&%\$#\=~]*)?$`
|
||||
pattern := regexp.MustCompile(reExp)
|
||||
res := pattern.FindStringSubmatch(uri)
|
||||
if len(res) == 0 {
|
||||
return
|
||||
}
|
||||
matched = true
|
||||
schema = res[2]
|
||||
if schema == "" {
|
||||
schema = "tcp"
|
||||
}
|
||||
host = res[6]
|
||||
if res[17] == "" {
|
||||
if schema == HTTPS.String() {
|
||||
port = 443
|
||||
} else {
|
||||
port = 80
|
||||
}
|
||||
} else {
|
||||
port, _ = strconv.Atoi(res[17])
|
||||
}
|
||||
|
||||
return
|
||||
}
|
||||
102
vtqe/tools/ping/tcp.go
Normal file
102
vtqe/tools/ping/tcp.go
Normal file
@ -0,0 +1,102 @@
|
||||
package ping
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"net"
|
||||
"time"
|
||||
)
|
||||
|
||||
// TCPing ...
|
||||
type TCPing struct {
|
||||
target *Target
|
||||
done chan struct{}
|
||||
result *Result
|
||||
}
|
||||
|
||||
var _ Pinger = (*TCPing)(nil)
|
||||
|
||||
// NewTCPing return a new TCPing
|
||||
func NewTCPing() *TCPing {
|
||||
tcping := TCPing{
|
||||
done: make(chan struct{}),
|
||||
}
|
||||
return &tcping
|
||||
}
|
||||
|
||||
// SetTarget set target for TCPing
|
||||
func (tcping *TCPing) SetTarget(target *Target) {
|
||||
tcping.target = target
|
||||
if tcping.result == nil {
|
||||
tcping.result = &Result{Target: target}
|
||||
}
|
||||
}
|
||||
|
||||
// Result return the result
|
||||
func (tcping TCPing) Result() *Result {
|
||||
return tcping.result
|
||||
}
|
||||
|
||||
// Start a tcping
|
||||
func (tcping TCPing) Start() <-chan struct{} {
|
||||
go func() {
|
||||
t := time.NewTicker(tcping.target.Interval)
|
||||
defer t.Stop()
|
||||
for {
|
||||
select {
|
||||
case <-t.C:
|
||||
if tcping.result.Counter >= tcping.target.Counter && tcping.target.Counter != 0 {
|
||||
tcping.Stop()
|
||||
return
|
||||
}
|
||||
duration, remoteAddr, err := tcping.ping()
|
||||
tcping.result.Counter++
|
||||
|
||||
if err != nil {
|
||||
fmt.Printf("Ping %s - failed: %s\n", tcping.target, err)
|
||||
} else {
|
||||
fmt.Printf("Ping %s(%s) - Connected - time=%s\n", tcping.target, remoteAddr, duration)
|
||||
|
||||
if tcping.result.MinDuration == 0 {
|
||||
tcping.result.MinDuration = duration
|
||||
}
|
||||
if tcping.result.MaxDuration == 0 {
|
||||
tcping.result.MaxDuration = duration
|
||||
}
|
||||
tcping.result.SuccessCounter++
|
||||
if duration > tcping.result.MaxDuration {
|
||||
tcping.result.MaxDuration = duration
|
||||
} else if duration < tcping.result.MinDuration {
|
||||
tcping.result.MinDuration = duration
|
||||
}
|
||||
tcping.result.TotalDuration += duration
|
||||
}
|
||||
case <-tcping.done:
|
||||
return
|
||||
}
|
||||
}
|
||||
}()
|
||||
return tcping.done
|
||||
}
|
||||
|
||||
// Stop the tcping
|
||||
func (tcping *TCPing) Stop() {
|
||||
tcping.done <- struct{}{}
|
||||
}
|
||||
|
||||
func (tcping TCPing) ping() (time.Duration, net.Addr, error) {
|
||||
var remoteAddr net.Addr
|
||||
duration, errIfce := timeIt(func() interface{} {
|
||||
conn, err := net.DialTimeout("tcp", fmt.Sprintf("%s:%d", tcping.target.Host, tcping.target.Port), tcping.target.Timeout)
|
||||
if err != nil {
|
||||
return err
|
||||
}
|
||||
remoteAddr = conn.RemoteAddr()
|
||||
conn.Close()
|
||||
return nil
|
||||
})
|
||||
if errIfce != nil {
|
||||
err := errIfce.(error)
|
||||
return 0, remoteAddr, err
|
||||
}
|
||||
return time.Duration(duration), remoteAddr, nil
|
||||
}
|
||||
51
vtqe/tools/ping/utils.go
Normal file
51
vtqe/tools/ping/utils.go
Normal file
@ -0,0 +1,51 @@
|
||||
package ping
|
||||
|
||||
import (
|
||||
"context"
|
||||
"fmt"
|
||||
"net"
|
||||
"strings"
|
||||
"time"
|
||||
)
|
||||
|
||||
func timeIt(f func() interface{}) (int64, interface{}) {
|
||||
startAt := time.Now()
|
||||
res := f()
|
||||
endAt := time.Now()
|
||||
return endAt.UnixNano() - startAt.UnixNano(), res
|
||||
}
|
||||
|
||||
// UseCustomeDNS will set the dns to default DNS resolver for global
|
||||
func UseCustomeDNS(dns []string) {
|
||||
resolver := net.Resolver{
|
||||
PreferGo: true,
|
||||
Dial: func(ctx context.Context, network, address string) (conn net.Conn, err error) {
|
||||
for _, addr := range dns {
|
||||
if conn, err = net.Dial("udp", addr+":53"); err != nil {
|
||||
continue
|
||||
} else {
|
||||
return conn, nil
|
||||
}
|
||||
}
|
||||
return
|
||||
},
|
||||
}
|
||||
net.DefaultResolver = &resolver
|
||||
}
|
||||
|
||||
// FormatIP - trim spaces and format IP
|
||||
//
|
||||
// IP - the provided IP
|
||||
//
|
||||
// string - return "" if the input is neither valid IPv4 nor valid IPv6
|
||||
// return IPv4 in format like "192.168.9.1"
|
||||
// return IPv6 in format like "[2002:ac1f:91c5:1::bd59]"
|
||||
func FormatIP(IP string) string {
|
||||
|
||||
host := strings.Trim(IP, "[ ]")
|
||||
if parseIP := net.ParseIP(host); parseIP != nil && parseIP.To4() == nil {
|
||||
host = fmt.Sprintf("[%s]", host)
|
||||
}
|
||||
|
||||
return host
|
||||
}
|
||||
43
vtqe/tools/ping/utils_test.go
Normal file
43
vtqe/tools/ping/utils_test.go
Normal file
@ -0,0 +1,43 @@
|
||||
package ping
|
||||
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
. "github.com/smartystreets/goconvey/convey"
|
||||
)
|
||||
|
||||
func TestFormatIP(t *testing.T) {
|
||||
|
||||
Convey("IP", t, func() {
|
||||
Convey("for v4 success", func() {
|
||||
rc := FormatIP("192.168.0.1")
|
||||
So(rc, ShouldEqual, "192.168.0.1")
|
||||
})
|
||||
|
||||
Convey("for v4 failure", func() {
|
||||
rc := FormatIP("192.0.1")
|
||||
So(rc, ShouldEqual, "")
|
||||
})
|
||||
|
||||
Convey("for v4 format", func() {
|
||||
rc := FormatIP("[192.0.1.1] ")
|
||||
So(rc, ShouldEqual, "192.0.1.1")
|
||||
})
|
||||
|
||||
Convey("for v6 success", func() {
|
||||
rc := FormatIP("[2002:ac1f:91c5:1::bd59]")
|
||||
So(rc, ShouldEqual, "[2002:ac1f:91c5:1::bd59]")
|
||||
})
|
||||
|
||||
Convey("for v6 failure", func() {
|
||||
rc := FormatIP("2002:ac1f:91c5:1:")
|
||||
So(rc, ShouldEqual, "")
|
||||
})
|
||||
|
||||
Convey("for v6 format", func() {
|
||||
rc := FormatIP("2002:ac1f:91c5:1::bd59 ")
|
||||
So(rc, ShouldEqual, "[2002:ac1f:91c5:1::bd59]")
|
||||
})
|
||||
})
|
||||
}
|
||||
77
vtqe/tools/sftp.go
Normal file
77
vtqe/tools/sftp.go
Normal file
@ -0,0 +1,77 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strings"
|
||||
|
||||
"b612.me/sshd"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var sftpcmd = &cobra.Command{
|
||||
Use: "sftp",
|
||||
Short: "sftp上传下载",
|
||||
Long: "sftp上传下载",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
d, _ := this.Flags().GetBool("download")
|
||||
i, _ := this.Flags().GetString("identify")
|
||||
k, _ := this.Flags().GetString("password")
|
||||
p, _ := this.Flags().GetInt("port")
|
||||
b, _ := this.Flags().GetInt("buffer")
|
||||
var user, host string
|
||||
var err error
|
||||
if len(args) != 3 {
|
||||
fmt.Println("sftp <[user@]Host> <Local> <Remote>")
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
hosts := strings.Split(args[0], "@")
|
||||
if len(hosts) == 1 {
|
||||
host = hosts[0]
|
||||
user = "root"
|
||||
} else {
|
||||
user = hosts[0]
|
||||
host = hosts[1]
|
||||
}
|
||||
fmt.Println("进行SSH连接……")
|
||||
client, err := sshd.Connect(user, k, host, i, p, []string{})
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
return
|
||||
}
|
||||
defer client.Close()
|
||||
fmt.Println("已连接上……")
|
||||
sftp, err := sshd.CreateSftp(client)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
return
|
||||
}
|
||||
defer sftp.Close()
|
||||
fmt.Println("已建立SFTP……")
|
||||
shell := func(pect float64) {
|
||||
if pect != 100.0 {
|
||||
fmt.Printf("传输已完成：%f%%\r", pect)
|
||||
} else {
|
||||
fmt.Printf("传输已完成：%f%%\n", pect)
|
||||
}
|
||||
}
|
||||
if !d {
|
||||
err = sshd.FtpTransferOutFunc(args[1], args[2], b, shell, sftp)
|
||||
} else {
|
||||
err = sshd.FtpTransferInFunc(args[1], args[2], b, shell, sftp)
|
||||
}
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
Maincmd.AddCommand(sftpcmd)
|
||||
sftpcmd.Flags().BoolP("download", "d", false, "进行下载")
|
||||
sftpcmd.Flags().StringP("identify", "i", "", "RSA登录密钥")
|
||||
sftpcmd.Flags().StringP("password", "k", "", "登录密码")
|
||||
sftpcmd.Flags().IntP("port", "p", 22, "登录端口")
|
||||
sftpcmd.Flags().IntP("buffer", "b", 10240, "buffer大小")
|
||||
}
|
||||
61
vtqe/tools/split.go
Normal file
61
vtqe/tools/split.go
Normal file
@ -0,0 +1,61 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"strconv"
|
||||
|
||||
"b612.me/starainrt"
|
||||
"b612.me/starlog"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var splitcmd = &cobra.Command{
|
||||
Use: "split",
|
||||
Short: "分割文件",
|
||||
Long: "按字节或文件数分割文件",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
var src, dst string
|
||||
var num int
|
||||
if len(args) == 3 {
|
||||
src = args[0]
|
||||
dst = args[1]
|
||||
num, _ = strconv.Atoi(args[2])
|
||||
} else {
|
||||
src, _ = this.Flags().GetString("src")
|
||||
dst, _ = this.Flags().GetString("dst")
|
||||
num, _ = this.Flags().GetInt("num")
|
||||
}
|
||||
if !starainrt.Exists(src) {
|
||||
starlog.Println("源文件不存在", "red", "b")
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
if num == 0 {
|
||||
starlog.Println("参数num不合法", "red", "b")
|
||||
this.Help()
|
||||
return
|
||||
}
|
||||
crypto := new(starainrt.StarCrypto)
|
||||
ok, _ := this.Flags().GetBool("byte")
|
||||
err := crypto.SplitFile(src, dst, num, !ok, func(pect float64) {
|
||||
if pect == 100 {
|
||||
fmt.Println("文件已处理：100.000000%")
|
||||
} else {
|
||||
fmt.Printf("文件已处理：%f%%\r", pect)
|
||||
}
|
||||
})
|
||||
if err != nil {
|
||||
starlog.Println(err.Error, "red", "")
|
||||
}
|
||||
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
splitcmd.Flags().StringP("src", "s", "", "源文件地址")
|
||||
splitcmd.Flags().StringP("dst", "d", "./split*.vicque", "目标文件地址，用*替换文件数字")
|
||||
splitcmd.Flags().BoolP("byte", "b", false, "按byte分割")
|
||||
splitcmd.Flags().IntP("num", "n", 0, "分割数/byte数")
|
||||
Maincmd.AddCommand(splitcmd)
|
||||
}
|
||||
181
vtqe/tools/tcping.go
Normal file
181
vtqe/tools/tcping.go
Normal file
@ -0,0 +1,181 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"os/signal"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
"strconv"
|
||||
|
||||
"victorique/vtqe/tools/ping"
|
||||
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var (
|
||||
showVersion bool
|
||||
version string
|
||||
gitCommit string
|
||||
counter int
|
||||
timeout string
|
||||
interval string
|
||||
sigs chan os.Signal
|
||||
|
||||
httpMode bool
|
||||
httpHead bool
|
||||
httpPost bool
|
||||
httpUA string
|
||||
|
||||
dnsServer []string
|
||||
)
|
||||
|
||||
var tcpingcmd = &cobra.Command{
|
||||
Use: "tcping",
|
||||
Short: "tcp ping",
|
||||
Long: "进行Tcping",
|
||||
Example: `
|
||||
1. ping over tcp
|
||||
> tcping google.com
|
||||
2. ping over tcp with custom port
|
||||
> tcping google.com 443
|
||||
3. ping over http
|
||||
> tcping -H google.com
|
||||
4. ping with URI schema
|
||||
> tcping http://hui.lu
|
||||
`,
|
||||
Run: func(cmd *cobra.Command, args []string) {
|
||||
sigs = make(chan os.Signal, 1)
|
||||
signal.Notify(sigs, syscall.SIGINT, syscall.SIGTERM)
|
||||
if showVersion {
|
||||
fmt.Printf("version: %s\n", version)
|
||||
fmt.Printf("git: %s\n", gitCommit)
|
||||
return
|
||||
}
|
||||
if len(args) != 2 && len(args) != 1 {
|
||||
cmd.Usage()
|
||||
return
|
||||
}
|
||||
host := args[0]
|
||||
|
||||
var (
|
||||
err error
|
||||
port int
|
||||
schema string
|
||||
)
|
||||
if len(args) == 2 {
|
||||
port, err = strconv.Atoi(args[1])
|
||||
if err != nil {
|
||||
fmt.Println("端口应当为Int类型")
|
||||
cmd.Usage()
|
||||
return
|
||||
}
|
||||
schema = ping.TCP.String()
|
||||
} else {
|
||||
var matched bool
|
||||
schema, host, port, matched = ping.CheckURI(host)
|
||||
if !matched {
|
||||
fmt.Println("不是一个合法的URI")
|
||||
cmd.Usage()
|
||||
return
|
||||
}
|
||||
}
|
||||
var timeoutDuration time.Duration
|
||||
if res, err := strconv.Atoi(timeout); err == nil {
|
||||
timeoutDuration = time.Duration(res) * time.Millisecond
|
||||
} else {
|
||||
timeoutDuration, err = time.ParseDuration(timeout)
|
||||
if err != nil {
|
||||
fmt.Println("parse timeout failed", err)
|
||||
cmd.Usage()
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
var intervalDuration time.Duration
|
||||
if res, err := strconv.Atoi(interval); err == nil {
|
||||
intervalDuration = time.Duration(res) * time.Millisecond
|
||||
} else {
|
||||
intervalDuration, err = time.ParseDuration(interval)
|
||||
if err != nil {
|
||||
fmt.Println("parse interval failed", err)
|
||||
cmd.Usage()
|
||||
return
|
||||
}
|
||||
}
|
||||
var protocol ping.Protocol
|
||||
if httpMode {
|
||||
protocol = ping.HTTP
|
||||
} else {
|
||||
protocol, err = ping.NewProtocol(schema)
|
||||
if err != nil {
|
||||
fmt.Println(err)
|
||||
cmd.Usage()
|
||||
return
|
||||
}
|
||||
}
|
||||
if len(dnsServer) != 0 {
|
||||
ping.UseCustomeDNS(dnsServer)
|
||||
}
|
||||
|
||||
parseHost := ping.FormatIP(host)
|
||||
target := ping.Target{
|
||||
Timeout: timeoutDuration,
|
||||
Interval: intervalDuration,
|
||||
Host: parseHost,
|
||||
Port: port,
|
||||
Counter: counter,
|
||||
Protocol: protocol,
|
||||
}
|
||||
var pinger ping.Pinger
|
||||
switch protocol {
|
||||
case ping.TCP:
|
||||
pinger = ping.NewTCPing()
|
||||
case ping.HTTP, ping.HTTPS:
|
||||
var httpMethod string
|
||||
switch {
|
||||
case httpHead:
|
||||
httpMethod = "HEAD"
|
||||
case httpPost:
|
||||
httpMethod = "POST"
|
||||
default:
|
||||
httpMethod = "GET"
|
||||
}
|
||||
pinger = ping.NewHTTPing(httpMethod)
|
||||
default:
|
||||
fmt.Printf("schema: %s not support\n", schema)
|
||||
cmd.Usage()
|
||||
return
|
||||
}
|
||||
pinger.SetTarget(&target)
|
||||
pingerDone := pinger.Start()
|
||||
select {
|
||||
case <-pingerDone:
|
||||
break
|
||||
case <-sigs:
|
||||
break
|
||||
}
|
||||
|
||||
fmt.Println(pinger.Result())
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
tcpingcmd.Flags().BoolVarP(&showVersion, "version", "v", false, "show the version and exit")
|
||||
tcpingcmd.Flags().IntVarP(&counter, "counter", "c", 4, "ping的次数")
|
||||
tcpingcmd.Flags().StringVarP(&timeout, "timeout", "T", "1s", `超时时间, 单位为 "ns", "us" (or "µs"), "ms", "s", "m", "h"`)
|
||||
tcpingcmd.Flags().StringVarP(&interval, "interval", "I", "1s", `ping间隔时间, 单位为 "ns", "us" (or "µs"), "ms", "s", "m", "h"`)
|
||||
|
||||
tcpingcmd.Flags().BoolVarP(&httpMode, "http", "H", false, `Use "HTTP" mode. will ignore URI Schema, force to http`)
|
||||
tcpingcmd.Flags().BoolVar(&httpHead, "head", false, `使用http head模式`)
|
||||
tcpingcmd.Flags().BoolVar(&httpPost, "post", false, `使用http post模式`)
|
||||
tcpingcmd.Flags().StringVar(&httpUA, "user-agent", "tcping", `自定义UA`)
|
||||
|
||||
tcpingcmd.Flags().StringArrayVarP(&dnsServer, "dns-server", "D", nil, `使用自定义DNS服务器`)
|
||||
|
||||
}
|
||||
|
||||
func init() {
|
||||
Maincmd.AddCommand(tcpingcmd)
|
||||
}
|
||||
33
vtqe/tools/uac.go
Normal file
33
vtqe/tools/uac.go
Normal file
@ -0,0 +1,33 @@
|
||||
// +build windows
|
||||
|
||||
package tools
|
||||
|
||||
import (
|
||||
"os"
|
||||
|
||||
"b612.me/wincmd"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var uaccmd = &cobra.Command{
|
||||
Use: "uac",
|
||||
Short: "Windows 使用uac权限打开文件",
|
||||
Long: "Windows 使用uac权限打开文件",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
if len(args) == 0 {
|
||||
return
|
||||
}
|
||||
cmdLine := ""
|
||||
if len(args) > 1 {
|
||||
for _, v := range args[1:] {
|
||||
cmdLine += v + " "
|
||||
}
|
||||
}
|
||||
pwd, _ := os.Getwd()
|
||||
wincmd.StartProcess(args[0], cmdLine, pwd, true, 1)
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
Maincmd.AddCommand(uaccmd)
|
||||
}
|
||||
97
vtqe/tools/vic.go
Normal file
97
vtqe/tools/vic.go
Normal file
@ -0,0 +1,97 @@
|
||||
package tools
|
||||
|
||||
import (
|
||||
"fmt"
|
||||
"os"
|
||||
"regexp"
|
||||
|
||||
"b612.me/starainrt"
|
||||
"b612.me/starlog"
|
||||
"github.com/spf13/cobra"
|
||||
)
|
||||
|
||||
var viccmd = &cobra.Command{
|
||||
Use: "vicque",
|
||||
Short: "嵐を乗り越えて",
|
||||
Long: "ほら！嵐を乗り越えて",
|
||||
Run: func(this *cobra.Command, args []string) {
|
||||
var err error
|
||||
ok, _ := this.Flags().GetBool("file")
|
||||
de, _ := this.Flags().GetBool("decode")
|
||||
pwd, _ := this.Flags().GetString("key")
|
||||
rep, _ := this.Flags().GetBool("replace")
|
||||
ext, _ := this.Flags().GetBool("extension")
|
||||
if len(args) != 2 {
|
||||
if len(args) < 2 || args[1] != "sakura" {
|
||||
starlog.Println("ヴィクトリカだけが使えるよ", "red", "b")
|
||||
return
|
||||
}
|
||||
}
|
||||
shell := func(pect float64) {
|
||||
if pect == 100 {
|
||||
fmt.Println("已处理：100.000000%")
|
||||
} else {
|
||||
fmt.Printf("已处理：%f%%\r", pect)
|
||||
}
|
||||
}
|
||||
cry := new(starainrt.StarCrypto)
|
||||
if ok {
|
||||
path, _ := this.Flags().GetString("path")
|
||||
if !de {
|
||||
err = cry.VicqueEncodeV1File(args[0], path, pwd, shell)
|
||||
if err == nil {
|
||||
if rep {
|
||||
os.Remove(args[0])
|
||||
os.Rename(path, args[0])
|
||||
path = args[0]
|
||||
}
|
||||
if ext {
|
||||
os.Rename(path, path+".victorique")
|
||||
}
|
||||
}
|
||||
} else {
|
||||
err = cry.VicqueDecodeV1File(args[0], path, pwd, shell)
|
||||
if err == nil {
|
||||
if rep {
|
||||
os.Remove(args[0])
|
||||
os.Rename(path, args[0])
|
||||
path = args[0]
|
||||
}
|
||||
if ext {
|
||||
reg := regexp.MustCompile(`(.*?)\.victorique$`)
|
||||
if reg.MatchString(path) {
|
||||
paths := reg.FindStringSubmatch(path)
|
||||
os.Rename(path, paths[1])
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
} else {
|
||||
if !de {
|
||||
data := cry.VicqueEncodeV1([]byte(args[0]), pwd)
|
||||
fmt.Println(data)
|
||||
fmt.Println(cry.Base64Encode(data))
|
||||
} else {
|
||||
var data []byte
|
||||
src, _ := cry.Base64Decode(args[0])
|
||||
data = cry.VicqueDecodeV1(src, pwd)
|
||||
fmt.Println(string(data))
|
||||
}
|
||||
}
|
||||
if err != nil {
|
||||
starlog.Println(err, "red", "b")
|
||||
return
|
||||
}
|
||||
},
|
||||
}
|
||||
|
||||
func init() {
|
||||
viccmd.Flags().BoolP("file", "f", false, "VICQUE处理文件")
|
||||
viccmd.Flags().StringP("path", "p", "./v64.encode", "指定处理地址，默认为./v64.encode")
|
||||
viccmd.Flags().BoolP("decode", "d", false, "VICQUE解码")
|
||||
viccmd.Flags().StringP("key", "k", "", "密钥")
|
||||
viccmd.Flags().BoolP("replace", "r", false, "覆盖原文件")
|
||||
viccmd.Flags().BoolP("extension", "e", false, "添加/取消.victorique后缀")
|
||||
viccmd.MarkFlagRequired("key")
|
||||
Maincmd.AddCommand(viccmd)
|
||||
}
|
||||
Loading…
x
Reference in New Issue
Block a user