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

del: 移除无用工具，整理mod依赖包

Browse Source
This commit is contained in:
TsMask
2024-08-12 11:37:32 +08:00
parent 9ec059b4cf
commit efad81e977
9 changed files with 8 additions and 1168 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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
}