OMC/be.ems
1
0
Fork 0
Code Issues Releases 3 Activity

marge: 合并11.2版本

Browse Source
This commit is contained in:
TsMask
2024-11-23 10:17:58 +08:00
parent 7bcb439d57
commit e5212c47ba
88 changed files with 11678 additions and 3054 deletions
Download Patch File Download Diff File Expand all files Collapse all files

101
tools/loadpconf/db.go
View File

@@ -1,101 +0,0 @@
package main
import (
"encoding/json"
"fmt"
"strings"
_ "github.com/go-sql-driver/mysql"
"xorm.io/xorm"
)
var xEngine *xorm.Engine
func XormConnectDatabaseWithUri(sql string) (*xorm.Engine, error) {
// sqlStr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&collation=utf8mb4_general_ci&parseTime=true&loc=Local", db.User, db.Password, db.Host, db.Port, db.Name)
sqlStr := fmt.Sprintf("%s?charset=utf8mb4&collation=utf8mb4_general_ci&parseTime=true&loc=Local", sql)
// fmt.Printf("sqlStr:%s:******@tcp(%s:%s)/%s?charset=utf8mb4&collation=utf8mb4_general_ci&parseTime=true&loc=Local", db.User, db.Host, db.Port, db.Name)
var err error
xEngine, err = xorm.NewEngine("mysql", sqlStr) //1、Create xorm engine
if err != nil {
fmt.Println("Failed to connect database:", err)
return nil, err
}
xEngine.ShowSQL(true)
return xEngine, nil
}
type ParamConfig struct {
// Id int `json:"id" xorm:"pk 'id' autoincr"`
NeType string `json:"neType"`
NeId string `json:"neId"`
TopTag string `json:"topTag"`
TopDisplay string `json:"topDisplay"`
Method string `json:"method"`
ParamJson string `json:"paramJson"`
}
func XormInsertParamConfig(mapJson *map[string]interface{}) (int64, error) {
var affected, a int64
var err error
paramConfig := new(ParamConfig)
for n, d := range *mapJson {
if d == nil {
break
}
fmt.Printf("n: %s", n)
session := xEngine.NewSession()
defer session.Close()
_, err = session.Table("param_config").Where("ne_type = ?", strings.ToUpper(n)).Delete()
if err != nil {
fmt.Println("Failed to delete param_config:", err)
}
session.Commit()
for t, p := range d.(map[string]interface{}) {
if p == nil {
break
}
fmt.Println("t:", t)
fmt.Println("p:", p)
for k, v := range p.(map[string]interface{}) {
fmt.Println("k, v: ", k, v)
if k == "display" {
paramConfig.TopDisplay = fmt.Sprintf("%v", v)
} else if k == "method" {
if v != "" {
paramConfig.Method = fmt.Sprintf("%v", v)
}
} else {
pc, _ := json.Marshal(v)
paramConfig.ParamJson = fmt.Sprintf("{\"%v\":%v}", k, string(pc))
}
}
paramConfig.NeType = strings.ToUpper(n)
paramConfig.NeId = ""
paramConfig.TopTag = t
// paramConfig.TopDisplay = p["display"]
// paramConfig.ParamJson = p.(string)
fmt.Println("paramConfig:", paramConfig)
session := xEngine.NewSession()
defer session.Close()
// _, err = session.Table("param_config").Where("ne_type = ? and top_tag = ?", paramConfig.NeType, paramConfig.TopTag).Delete()
// if err != nil {
// fmt.Println("Failed to delete param_config:", err)
// }
a, err = session.Insert(paramConfig)
if err != nil {
fmt.Println("Failed to insert param_config:", err)
}
session.Commit()
affected += a
}
}
return affected, err
}

375
tools/loadpconf/load.go
View File

@@ -1,375 +0,0 @@
package main
import (
"flag"
"fmt"
"os"
"reflect"
"gopkg.in/yaml.v3"
)
// Yaml struct of config
type YamlConfig struct {
Logger struct {
File string `yaml:"file"`
Level string `yaml:"level"`
}
Rest struct {
Addr string `yaml:"addr"`
Port uint16 `yaml:"port"`
}
Database struct {
Type string `yaml:"type"`
User string `yaml:"user"`
Password string `yaml:"password"`
Host string `yaml:"host"`
Port string `yaml:"port"`
Name string `yaml:"name"`
}
ParamFileDir string `yaml:"paramfiledir"`
}
var yamlConfig YamlConfig
func ReadConfig(configFile string) {
yamlFile, err := os.ReadFile(configFile)
if err != nil {
fmt.Printf("ioutil.ReadFile %s err %v", configFile, err)
}
// fmt.Println("yamlfile:", string(yamlFile))
err = yaml.Unmarshal(yamlFile, &yamlConfig)
if err != nil {
fmt.Printf("Unmarshal: %v when to struct", err)
}
}
func GetYamlConfig() *YamlConfig {
return &yamlConfig
}
//var mapYaml map[string]interface{}
func ReadParamConfig(fileName string) *map[string]interface{} {
file, err := os.ReadFile(fileName)
if err != nil {
fmt.Println("yamlFile.Get err", err)
}
mapYaml := make(map[string]interface{})
var node yaml.Node
err = yaml.Unmarshal(file, &node)
if err != nil {
fmt.Printf("yaml.Unmarshal: %v when to struct", err)
}
err = unmarshalNode(&node, &mapYaml)
if err != nil {
fmt.Println("Failed to unmarshalNode:", err)
}
// var node yaml.Node
// err = yaml.Unmarshal(file, &node)
// if err != nil {
// fmt.Printf("yaml.Unmarshal: %v when to struct", err)
// }
// err = unmarshalNode(&node, reflect.ValueOf(&mapYaml))
// if err != nil {
// fmt.Println("Failed to unmarshalNode:", err)
// }
err = yaml.Unmarshal(file, &mapYaml)
if err != nil {
fmt.Printf("yaml.Unmarshal: %v when to struct", err)
}
// fmt.Println("mapYaml:", mapYaml)
return &mapYaml
}
func GetAllFile(dir string, s []string) ([]string, error) {
rd, err := os.ReadDir(dir)
if err != nil {
fmt.Println("read dir fail:", err)
return s, err
}
for _, fi := range rd {
if !fi.IsDir() {
fullName := dir + "/" + fi.Name()
s = append(s, fullName)
}
}
return s, nil
}
const defaultConfigFile = "./loadpconf.yaml"
var (
version string
buildTime string
goVer string
)
var pfiles []string
func init() {
cfile := flag.String("c", defaultConfigFile, "config file")
pfile := flag.String("p", "", "param file")
pv := flag.Bool("v", false, "print version")
ph := flag.Bool("h", false, "print help")
flag.Parse()
if *pv {
fmt.Printf("OMC initems version: %s\n%s\n%s\n\n", version, buildTime, goVer)
os.Exit(0)
}
if *ph {
flag.Usage()
os.Exit(0)
}
ReadConfig(*cfile)
fmt.Println("pfile:", *pfile)
if *pfile != "" {
pfiles = append(pfiles, *pfile)
} else {
pfiles, _ = GetAllFile(yamlConfig.ParamFileDir, pfiles)
}
fmt.Println("pfiles:", pfiles)
}
func unmarshalNode(node *yaml.Node, out interface{}) error {
switch node.Kind {
case yaml.DocumentNode:
return unmarshalNode(node.Content[0], out)
case yaml.MappingNode:
m := nodeToMap(node)
return unmarshalMap(m, out)
case yaml.SequenceNode:
s := nodeToSlice(node)
return unmarshalSlice(s, out)
case yaml.ScalarNode:
return unmarshalScalar(node, out)
default:
return fmt.Errorf("unknown node kind: %v", node.Kind)
}
}
func nodeToMap(node *yaml.Node) map[string]*yaml.Node {
m := make(map[string]*yaml.Node)
for i := 0; i < len(node.Content); i += 2 {
key := node.Content[i].Value
value := node.Content[i+1]
m[key] = value
}
return m
}
func unmarshalMap(m map[string]*yaml.Node, out interface{}) error {
data, ok := out.(*map[string]interface{})
if !ok {
return fmt.Errorf("out must be a map[string]interface{}")
}
*data = make(map[string]interface{})
for key, value := range m {
var v interface{}
err := unmarshalNode(value, &v)
if err != nil {
return err
}
(*data)[key] = v
}
return nil
}
func nodeToSlice(node *yaml.Node) []*yaml.Node {
return node.Content
}
func unmarshalSlice(s []*yaml.Node, out interface{}) error {
data, ok := out.(*[]interface{})
if !ok {
return fmt.Errorf("out must be a []interface{}")
}
*data = make([]interface{}, len(s))
for i, value := range s {
var v interface{}
err := unmarshalNode(value, &v)
if err != nil {
return err
}
(*data)[i] = v
}
return nil
}
func unmarshalScalar(node *yaml.Node, out interface{}) error {
switch node.Tag {
case "!!str":
val := reflect.ValueOf(node.Value)
val.Elem().Set(reflect.ValueOf(out))
//*out = node.Value
case "!!int":
val := reflect.ValueOf(node.Value)
val.Elem().Set(reflect.ValueOf(out))
//*out = node.Value
case "!!float":
val := reflect.ValueOf(node.Value)
val.Elem().Set(reflect.ValueOf(out))
//*out = node.Value
case "!!bool":
val := reflect.ValueOf(node.Value == "true")
val.Elem().Set(reflect.ValueOf(out))
//*out = node.Value == "true"
case "!!null":
val := reflect.ValueOf(node.Value)
val.Elem().Set(reflect.ValueOf(out))
//*out = nil
default:
return fmt.Errorf("unknown scalar tag: %v", node.Tag)
}
return nil
}
/*
func unmarshalNode(node *yaml.Node, out reflect.Value) error {
switch node.Kind {
case yaml.DocumentNode:
return unmarshalNode(node.Content[0], out)
case yaml.MappingNode:
m := nodeToMap(node)
return unmarshalMap(m, out)
case yaml.SequenceNode:
s := nodeToSlice(node)
return unmarshalSlice(s, out)
case yaml.ScalarNode:
return unmarshalScalar(node, out)
default:
return fmt.Errorf("unknown node kind: %v", node.Kind)
}
}
func nodeToMap(node *yaml.Node) map[string]*yaml.Node {
m := make(map[string]*yaml.Node)
for i := 0; i < len(node.Content); i += 2 {
key := node.Content[i].Value
value := node.Content[i+1]
m[key] = value
}
return m
}
func unmarshalMap(m map[string]*yaml.Node, out reflect.Value) error {
if out.Kind() != reflect.Ptr || out.IsNil() {
return fmt.Errorf("out must be a non-nil pointer")
}
outType := out.Type().Elem()
if outType.Kind() != reflect.Map {
return fmt.Errorf("out must be a pointer to a map")
}
mapType := outType.Elem()
if mapType.Kind() != reflect.Interface && mapType.Kind() != reflect.Map {
return fmt.Errorf("out must be a pointer to a map of interface{}")
}
out.Set(reflect.MakeMap(outType))
for key, value := range m {
var v reflect.Value
if mapType.Kind() == reflect.Interface {
v = reflect.New(reflect.TypeOf((*interface{})(nil)).Elem())
} else {
v = reflect.New(mapType)
}
err := unmarshalNode(value, v.Elem())
if err != nil {
return err
}
out.Elem().SetMapIndex(reflect.ValueOf(key), v.Elem())
}
return nil
}
func nodeToSlice(node *yaml.Node) []*yaml.Node {
return node.Content
}
func unmarshalSlice(s []*yaml.Node, out reflect.Value) error {
if out.Kind() != reflect.Ptr || out.IsNil() {
return fmt.Errorf("out must be a non-nil pointer")
}
outType := out.Type().Elem()
if outType.Kind() != reflect.Slice {
return fmt.Errorf("out must be a pointer to a slice")
}
sliceType := outType.Elem()
if sliceType.Kind() != reflect.Interface && sliceType.Kind() != reflect.Slice {
return fmt.Errorf("out must be a pointer to a slice of interface{}")
}
out.Set(reflect.MakeSlice(outType, len(s), len(s)))
for i, value := range s {
var v reflect.Value
if sliceType.Kind() == reflect.Interface {
v = reflect.New(reflect.TypeOf((*interface{})(nil)).Elem())
} else {
v = reflect.New(sliceType)
}
err := unmarshalNode(value, v.Elem())
if err != nil {
return err
}
out.Elem().Index(i).Set(v.Elem())
}
return nil
}
func unmarshalScalar(node *yaml.Node, out reflect.Value) error {
switch node.Tag {
case "!!str":
out.SetString(node.Value)
case "!!int":
i, err := strconv.ParseInt(node.Value, 10, 64)
if err != nil {
return err
}
out.SetInt(i)
case "!!float":
f, err := strconv.ParseFloat(node.Value, 64)
if err != nil {
return err
}
out.SetFloat(f)
case "!!bool":
b, err := strconv.ParseBool(node.Value)
if err != nil {
return err
}
out.SetBool(b)
case "!!null":
out.Set(reflect.Zero(out.Type()))
default:
return fmt.Errorf("unknown scalar tag: %v", node.Tag)
}
return nil
}
*/

21
tools/loadpconf/loadpconf.go
View File

@@ -1,21 +0,0 @@
package main
import (
"fmt"
)
func main() {
fmt.Println("========================= OMC loadpconf startup =========================")
fmt.Printf("OMC loadpconf version: %s %s %s", version, buildTime, goVer)
for _, f := range pfiles {
fmt.Println("f:", f)
paramMap := ReadParamConfig(f)
fmt.Println("paramMap:", paramMap)
db := yamlConfig.Database
sqlStr := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s", db.User, db.Password, db.Host, db.Port, db.Name)
XormConnectDatabaseWithUri(sqlStr)
XormInsertParamConfig(paramMap)
}
}

17
tools/loadpconf/loadpconf.yaml
View File

@@ -1,17 +0,0 @@
logger:
file: ./initems.log
level: trace
rest:
addr: 0.0.0.0
port: 3040
database:
type: mysql
user: root
password: 1000omc@kp!
host: 127.0.0.1
port: 33066
name: omc_db
paramfiledir: ../../config/param

22
tools/loadpconf/makefile
View File

@@ -1,22 +0,0 @@
# Makefile for rest agent project
PROJECT = OMC
VERSION = 5GC16.1.1
PLATFORM = amd64
DEBDIR = ../../../deb
ETCDIR = ../../../etc
RELEASEDIR = ../../../release
LIBDIR = ../lib
BINNAME = loadpconf
.PHONY: build $(BINNAME)
build $(BINNAME):
go build -o $(BINNAME) -v -ldflags "-X 'main.version=$(VERSION)' \
-X 'main.buildTime=`date`' \
-X 'main.goVer=`go version`'"
run: $(BINNAME)
./$(BINNAME)
clean:
rm ./$(BINNAME)

2
tools/misc/dumpdb.sh
View File

@@ -1,7 +1,7 @@
#!/bin/bash
Home=/home/simon
GitLocalRoot=${Home}/local.git
GitLocalRoot=${Home}/omc.git
EmsBEDir=${GitLocalRoot}/be.ems
user="root"
password="1000omc@kp!"

2
tools/misc/dumpsql.sh
View File

@@ -1,7 +1,7 @@
#!/bin/bash
Home=/home/simon
GitLocalRoot=${Home}/local.git
GitLocalRoot=${Home}/omc.git
EmsBEDir=${GitLocalRoot}/be.ems
EMSBuildDir=${GitLocalRoot}/build.ems
user="root"

2
tools/misc/tables_c.lst
View File

@@ -9,7 +9,7 @@ mml_command
mml_http_map
mml_subscriber
mml_system
param_config
ne_config
pm_custom_title
title_info
trace_info

94
tools/websocket/load.go
View File

@@ -1,94 +0,0 @@
package main
import (
"flag"
"fmt"
"io/ioutil"
"os"
"strings"
"be.ems/lib/log"
"gopkg.in/yaml.v3"
)
// Yaml struct of config
type YamlConfig struct {
Logger struct {
File string `yaml:"file"`
Level string `yaml:"level"`
Duration int `yaml:"duration"`
}
Rest struct {
BindIP string `yaml:"bindip"`
Port uint16 `yaml:"port"`
}
}
var yamlConfig YamlConfig
func ReadConfig(configFile string) {
yamlFile, err := ioutil.ReadFile(configFile)
if err != nil {
fmt.Printf("ioutil.ReadFile %s err %v", configFile, err)
}
// fmt.Println("yamlfile:", string(yamlFile))
err = yaml.Unmarshal(yamlFile, &yamlConfig)
if err != nil {
fmt.Printf("Unmarshal: %v when to struct", err)
}
}
func GetYamlConfig() *YamlConfig {
return &yamlConfig
}
func GetLogLevel() log.LogLevel {
var logLevel log.LogLevel
switch strings.ToLower(yamlConfig.Logger.Level) {
case "trace":
logLevel = log.LOG_TRACE
case "info":
logLevel = log.LOG_INFO
case "debug":
logLevel = log.LOG_DEBUG
case "warn":
logLevel = log.LOG_WARN
case "error":
logLevel = log.LOG_ERROR
case "fatal":
logLevel = log.LOG_FATAL
case "off":
logLevel = log.LOG_OFF
default:
logLevel = log.LOG_DEBUG
}
return logLevel
}
const defaultConfigFile = "./tt.yaml"
var (
version string
buildTime string
goVer string
)
func init() {
cfile := flag.String("c", defaultConfigFile, "config file")
pv := flag.Bool("v", false, "print version")
ph := flag.Bool("h", false, "print help")
flag.Parse()
if *pv {
fmt.Printf("OMC version: %s\n%s\n%s\n\n", version, buildTime, goVer)
os.Exit(0)
}
if *ph {
flag.Usage()
os.Exit(0)
}
ReadConfig(*cfile)
}

87
tools/websocket/tt.go
View File

@@ -1,87 +0,0 @@
package main
import (
"fmt"
"net"
"os"
"time"
"be.ems/lib/log"
)
const (
//经过测试，linux下，延时需要大于100ms
TIME_DELAY_AFTER_WRITE = 500 //500ms
)
func main() {
log.InitLogger(yamlConfig.Logger.File, yamlConfig.Logger.Duration, "omc:tt", GetLogLevel())
fmt.Printf("OMC tt version: %s\n", version)
log.Infof("========================= OMC tt startup =========================")
log.Infof("OMC tt version: %s %s %s", version, buildTime, goVer)
conn, err := net.Dial("tcp", "192.168.4.233:4100")
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
var buf [8192]byte
var n int
n, err = conn.Write([]byte("admin\nadmin\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
time.Sleep(time.Millisecond * TIME_DELAY_AFTER_WRITE)
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
log.Debug(string(buf[0:n]))
n, err = conn.Write([]byte("date\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
time.Sleep(time.Millisecond * TIME_DELAY_AFTER_WRITE)
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
log.Debug(string(buf[0 : n-5]))
/*
n, err = conn.Write([]byte("\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
time.Sleep(time.Millisecond * TIME_DELAY_AFTER_WRITE)
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
log.Debug(string(buf[0:n]))
log.Debug(string(buf[0:n]))
*/
/* n, err = conn.Write([]byte("\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
*/
}

15
tools/websocket/tt.yaml
View File

@@ -1,15 +0,0 @@
logger:
file: ./tt.log
level: trace
rest:
addr: 0.0.0.0
port: 3040
database:
type: mysql
user: root
password: 1000omc@kp!
host: 127.0.0.1
port: 33066
name: omc_db

11
tools/websocket/ttt.go
View File

@@ -1,11 +0,0 @@
package main
import (
"github.com/reiver/go-telnet"
)
func main() {
var caller telnet.Caller = telnet.StandardCaller
telnet.DialToAndCall("192.168.4.233:4100", caller)
}

301
tools/websocket/websocket.go
View File

@@ -1,301 +0,0 @@
package main
import (
"fmt"
"io"
"net"
"net/http"
"os"
"time"
"github.com/gin-gonic/gin"
"github.com/go-admin-team/go-admin-core/sdk/api"
"github.com/gorilla/websocket"
"github.com/ziutek/telnet"
"golang.org/x/crypto/ssh"
"golang.org/x/crypto/ssh/terminal"
)
type TgWs struct {
api.Api
}
var upGrader = websocket.Upgrader{
ReadBufferSize: 1024,
WriteBufferSize: 1024 * 1024 * 10,
CheckOrigin: func(r *http.Request) bool {
return true
},
}
type ShellInfoStruct struct {
Proto string `json:"proto"`
IpAddr string `json:"ipaddr"`
Port string `json:"port"`
}
type wsWrapper struct {
*websocket.Conn
}
func main() {
telnetHandle(rw io.ReadWriter, ip, port string, errhandle func(string)) {
}
func init() {
routerCheckRole = append(routerCheckRole, registerTgWsRouter)
}
// 需认证的路由代码
func registerTgWsRouter(v1 *gin.RouterGroup, authMiddleware *jwt.GinJWTMiddleware) {
api := apis.TgWs{}
r := v1.Group("")
{
// 协议、IP、端口
r.GET("/tgws/:proto/:ipaddr/:port", api.TgWsWeb)
}
}
func (e TgWs) TgWsWeb(c *gin.Context) {
// 初始化返回信息
err := e.MakeContext(c).Errors
if err != nil {
e.Logger.Error(err)
e.Error(500, err, fmt.Sprintf(" %s ", err.Error()))
return
}
// 升级为websocket
wsConn, err := upGrader.Upgrade(c.Writer, c.Request, nil)
if err != nil {
e.Logger.Error(err)
e.Error(500, err, "websocket client connect error")
return
}
defer wsConn.Close()
proto := c.Param("proto")
ipaddr := c.Param("ipaddr")
port := c.Param("port")
shellinfo := ShellInfoStruct{
Proto: proto,
IpAddr: ipaddr,
Port: port,
}
quitChan := make(chan bool, 1)
go websocketHandle(wsConn, shellinfo, quitChan)
<-quitChan
}
func websocketHandle(con *websocket.Conn, shellinfo ShellInfoStruct, exitCh chan bool) {
defer setQuit(exitCh)
rw := io.ReadWriter(&wsWrapper{con})
webprintln := func(data string) {
rw.Write([]byte(data + "\r\n"))
}
con.SetCloseHandler(func(code int, text string) error {
con.Close()
return nil
})
switch shellinfo.Proto {
case "ssh":
sshHandle(rw, shellinfo.IpAddr, shellinfo.Port, "XXX", "XXX", webprintln)
case "telnet":
telnetHandle(rw, shellinfo.IpAddr, shellinfo.Port, webprintln)
case "bind_shell":
bindShellHandler(rw, shellinfo.IpAddr, shellinfo.Port, webprintln)
default:
webprintln("Not Support Protocol '" + shellinfo.Proto + "'")
}
return
}
func (wsw *wsWrapper) Write(p []byte) (n int, err error) {
writer, err := wsw.Conn.NextWriter(websocket.TextMessage)
if err != nil {
return 0, err
}
defer writer.Close()
return writer.Write(p)
}
func (wsw *wsWrapper) Read(p []byte) (n int, err error) {
for {
msgType, reader, err := wsw.Conn.NextReader()
if err != nil {
return 0, err
}
if msgType != websocket.TextMessage {
continue
}
return reader.Read(p)
}
}
// SSH连接
func sshHandle(rw io.ReadWriter, ip, port, user, passwd string, errhandle func(string)) {
sshConfig := &ssh.ClientConfig{
User: user,
Auth: []ssh.AuthMethod{ssh.Password(passwd)},
Timeout: 6 * time.Second,
}
sshConfig.HostKeyCallback = ssh.InsecureIgnoreHostKey()
if port == "" {
ip = ip + ":22"
} else {
ip = ip + ":" + port
}
client, err := ssh.Dial("tcp", ip, sshConfig)
if err != nil {
errhandle(err.Error())
return
}
defer client.Close()
session, err := client.NewSession()
if err != nil {
errhandle(err.Error())
return
}
defer session.Close()
fd := int(os.Stdin.Fd())
session.Stdout = rw
session.Stderr = rw
session.Stdin = rw
modes := ssh.TerminalModes{
ssh.ECHO: 1,
ssh.TTY_OP_ISPEED: 14400,
ssh.TTY_OP_OSPEED: 14400,
}
termWidth, termHeight, err := terminal.GetSize(fd)
err = session.RequestPty("xterm", termHeight, termWidth, modes)
if err != nil {
errhandle(err.Error())
}
err = session.Shell()
if err != nil {
errhandle(err.Error())
}
err = session.Wait()
if err != nil {
errhandle(err.Error())
}
return
}
// telnet连接
func telnetHandle(rw io.ReadWriter, ip, port string, errhandle func(string)) {
if port == "" {
ip = ip + ":23"
} else {
ip = ip + ":" + port
}
con, err := telnet.Dial("tcp", ip)
if err != nil {
errhandle(err.Error())
return
}
defer con.Close()
buf := make([]byte, 16*1024)
// 从远端读取返回结果并回显页面
go func() {
for {
n, err := con.Read(buf)
if err != nil {
errhandle(err.Error())
break
}
_, err = rw.Write(buf[:n])
if err != nil {
errhandle(err.Error())
break
}
}
}()
for {
// 从页面读取命令
n, err := rw.Read(buf)
if err != nil {
errhandle(err.Error())
break
}
if buf[0] == 13 { // 处理换行
data := []byte{telnet.CR, telnet.LF}
_, err = con.Write(data)
} else {
_, err = con.Write(buf[:n])
}
if err != nil {
errhandle(err.Error())
break
}
}
return
}
// 正向shell
func bindShellHandler(rw io.ReadWriter, ip, port string, errhandle func(string)) {
server := ip + ":" + port
//获取命令行参数 socket地址
addr, err := net.ResolveTCPAddr("tcp4", server)
if err != nil {
errhandle(err.Error())
return
}
//建立tcp连接
con, err := net.DialTCP("tcp4", nil, addr)
if err != nil {
errhandle(err.Error())
return
}
rw.Write([]byte("reverse shell connected " + "\r\n"))
defer con.Close()
buf := make([]byte, 16*1024)
go func() {
for {
n, err := con.Read(buf)
if err != nil {
errhandle(err.Error())
break
}
_, err = rw.Write(buf[:n])
if err != nil {
errhandle(err.Error())
break
}
}
}()
for {
n, err := rw.Read(buf)
if err != nil {
errhandle(err.Error())
break
}
_, err = rw.Write(buf[:n])
if err != nil {
errhandle(err.Error())
break
}
if buf[0] == 13 {
data := []byte{telnet.LF}
_, err = con.Write(data)
rw.Write([]byte("\r\n"))
} else {
_, err = con.Write(buf[:n])
}
if err != nil {
errhandle(err.Error())
break
}
}
return
}
func setQuit(ch chan bool) {
ch <- true
}

290
tools/websocket/webtel.go
View File

@@ -1,290 +0,0 @@
package main
import (
"fmt"
"net"
"os"
)
func main() {
conn, err := net.Dial("tcp", "192.168.4.233:4100")
if err != nil {
fmt.Sprint(os.Stderr, "Error: %s", err.Error())
return
}
var buf [16192]byte
/*
// for {
n, err := conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
*/
n, err := conn.Write([]byte("admin\nadmin\n\ndate\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
/*
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
n, err = conn.Write([]byte("admin\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
return
}
*/
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println((string(buf[0:n])))
fmt.Println(string(buf[0:n]))
n, err = conn.Write([]byte("date\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println((string(buf[0:n])))
fmt.Println(string(buf[0:n]))
/*
buf[1] = 252
buf[4] = 252
buf[7] = 252
buf[10] = 252
fmt.Println((buf[0:n]))
n, err = conn.Write(buf[0:n])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
fmt.Println((buf[0:n]))
*/
/*
buf[1] = 252
buf[4] = 251
buf[7] = 252
buf[10] = 254
buf[13] = 252
fmt.Println((buf[0:n]))
n, err = conn.Write(buf[0:n])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
fmt.Println((buf[0:n]))
buf[1] = 252
buf[4] = 252
fmt.Println((buf[0:n]))
n, err = conn.Write(buf[0:n])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
fmt.Println((buf[0:n]))
*/
/*
buf[0] = 255
buf[1] = 252
buf[2] = 1
buf[3] = 255
buf[4] = 253
buf[5] = 1
buf[6] = 255
buf[7] = 252
buf[8] = 1
buf[9] = 255
buf[10] = 253
buf[11] = 1
fmt.Println((buf[0:12]))
n, err = conn.Write(buf[0:12])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
*/
/*
n, err = conn.Write([]byte("admin\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
n, err = conn.Write([]byte("\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s\n", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
for {
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
if strings.HasSuffix(string(buf[0:n]), "> ") {
break
}
}
n, err = conn.Write([]byte("enable\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
n, err = conn.Write([]byte("terminal length 0\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
n, err = conn.Write([]byte("show port\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
for {
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
if strings.HasSuffix(string(buf[0:n]), "# ") {
break
}
}
n, err = conn.Write([]byte("show interface\n\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
for {
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
if strings.HasSuffix(string(buf[0:n]), "# ") {
break
}
}
n, err = conn.Write([]byte("show running-config\n"))
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
reader := bufio.NewReader(conn)
if reader == nil {
fmt.Fprintf(os.Stderr, "Create reader failed.")
}
for {
n, err := reader.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
if strings.HasSuffix(string(buf[0:n]), "# ") {
break
}
}
*/
/*
for {
n, err = conn.Read(buf[0:])
if err != nil {
fmt.Fprintf(os.Stderr, "Error: %s", err.Error())
return
}
fmt.Println(string(buf[0:n]))
fmt.Println(n)
if strings.HasSuffix(string(buf[0:n]), "# ") {
break
}
}
*/
}

218
tools/websocket/webtelnet.go
View File

@@ -1,218 +0,0 @@
package main
import (
"bufio"
"fmt"
"io"
"log"
"net"
"os"
"strings"
"time"
)
type TelnetClient struct {
IP string
Port string
IsAuthentication bool
UserName string
Password string
}
const (
//经过测试，linux下，延时需要大于100ms
TIME_DELAY_AFTER_WRITE = 500 //500ms
)
var g_WriteChan chan string
func main() {
g_WriteChan = make(chan string)
telnetClientObj := new(TelnetClient)
telnetClientObj.IP = "192.168.4.233"
telnetClientObj.Port = "4100"
telnetClientObj.IsAuthentication = true
telnetClientObj.UserName = "admin"
telnetClientObj.Password = "admin"
//fmt.Println(telnetClientObj.PortIsOpen(5))
go telnetClientObj.Telnet(20)
for {
line := readLine()
g_WriteChan <- string(line)
}
}
func readLine() string {
//fmt.Print("> ")
line, err := bufio.NewReader(os.Stdin).ReadString('\n')
if err != nil && err != io.EOF {
log.Fatal(err)
}
return strings.TrimSpace(line)
}
func (this *TelnetClient) PortIsOpen(timeout int) bool {
raddr := this.IP + ":" + this.Port
conn, err := net.DialTimeout("tcp", raddr, time.Duration(timeout)*time.Second)
if nil != err {
log.Println("pkg: model, func: PortIsOpen, method: net.DialTimeout, errInfo:", err)
return false
}
defer conn.Close()
return true
}
func (this *TelnetClient) Telnet(timeout int) (err error) {
raddr := this.IP + ":" + this.Port
conn, err := net.DialTimeout("tcp", raddr, time.Duration(timeout)*time.Second)
if nil != err {
log.Println("pkg: model, func: Telnet, method: net.DialTimeout, errInfo:", err)
return
}
defer conn.Close()
if false == this.telnetProtocolHandshake(conn) {
log.Println("pkg: model, func: Telnet, method: this.telnetProtocolHandshake, errInfo: telnet protocol handshake failed!!!")
return
}
go func() {
for {
data := make([]byte, 1024)
_, err := conn.Read(data)
if err != nil {
fmt.Println(err)
break
}
//strData := string(data)
fmt.Printf("%s", data)
}
}()
// conn.SetReadDeadline(time.Now().Add(time.Second * 30))
for {
select {
case cmd, _ := <-g_WriteChan:
_, err = conn.Write([]byte(cmd + "\n"))
if nil != err {
log.Println("pkg: model, func: Telnet, method: conn.Write, errInfo:", err)
return
}
break
default:
time.Sleep(100 * time.Millisecond)
continue
}
}
fmt.Println("Out telnet!!!!!!")
return
}
func (this *TelnetClient) telnetProtocolHandshake(conn net.Conn) bool {
var buf [4096]byte
n, err := conn.Read(buf[0:])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Read, errInfo:", err)
return false
}
//fmt.Println(string(buf[0:n]))
//fmt.Println((buf[0:n]))
buf[1] = 252
buf[4] = 252
buf[7] = 252
buf[10] = 252
//fmt.Println((buf[0:n]))
n, err = conn.Write(buf[0:n])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Write, errInfo:", err)
return false
}
n, err = conn.Read(buf[0:])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Read, errInfo:", err)
return false
}
//fmt.Println(string(buf[0:n]))
//fmt.Println((buf[0:n]))
buf[1] = 252
buf[4] = 251
buf[7] = 252
buf[10] = 254
buf[13] = 252
fmt.Println((buf[0:n]))
n, err = conn.Write(buf[0:n])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Write, errInfo:", err)
return false
}
n, err = conn.Read(buf[0:])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Read, errInfo:", err)
return false
}
//fmt.Println(string(buf[0:n]))
//fmt.Println((buf[0:n]))
buf[1] = 252
buf[4] = 252
//fmt.Println((buf[0:n]))
n, err = conn.Write(buf[0:n])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Write, errInfo:", err)
return false
}
n, err = conn.Read(buf[0:])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Read, errInfo:", err)
return false
}
//fmt.Println(string(buf[0:n]))
//fmt.Println((buf[0:n]))
if false == this.IsAuthentication {
return true
}
n, err = conn.Write([]byte(this.UserName + "\n"))
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Write, errInfo:", err)
return false
}
time.Sleep(time.Millisecond * TIME_DELAY_AFTER_WRITE)
n, err = conn.Read(buf[0:])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Read, errInfo:", err)
return false
}
//fmt.Println(string(buf[0:n]))
n, err = conn.Write([]byte(this.Password + "\n"))
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Write, errInfo:", err)
return false
}
n, err = conn.Read(buf[0:])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Read, errInfo:", err)
return false
}
n, err = conn.Write([]byte("date" + "\n"))
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Write, errInfo:", err)
return false
}
time.Sleep(time.Millisecond * TIME_DELAY_AFTER_WRITE)
n, err = conn.Read(buf[0:])
if nil != err {
log.Println("pkg: model, func: telnetProtocolHandshake, method: conn.Read, errInfo:", err)
return false
}
fmt.Println(string(buf[0:n]))
return true
}