golang 十六进制网络读写

最简C/S程序

server.go

package main

import (
    "fmt"
    "net"
)

func process(conn net.Conn) {
    defer conn.Close()
    for {
        var buf [128]byte
        n, err := conn.Read(buf[:])
        if err != nil {
            fmt.Println("Read for tcp server faild", err)
            break
        }
        data := string(buf[:n])
        fmt.Printf("Recived from client data:%s\n", data)
    }
}
func main() {
    //监控TCP和端口
    listener, err := net.Listen("tcp", "0.0.0.0:8888")
    if err != nil {
        fmt.Println("Listen Tcp failed", err)
        return
    }
    for {
        //建立socket连接
        conn, err := listener.Accept()
        if err != nil {
            fmt.Println("Listener Accept failed", err)
            continue
        }
        //业务处理
        go process(conn)
    }
}

client.go

func main() {
    //连接服务器
    conn, err := net.Dial("tcp", "192.168.10.223:2026")
    if err != nil {
        fmt.Println("Connect Tcp 8888 failed", err)
        return
    }
    inputReader := bufio.NewReader(os.Stdin)
    for {
        input, err := inputReader.ReadString('\n')
        if err != nil {
            fmt.Println("Read from console failed", err)
            return
        }
        //读到字符 "q"退出
        str := strings.TrimSpace(input)
        fmt.Printf("\"%s\"", str)
        if str == "q" {
            break
        }
        // 响应服务端信息
        _,err = conn.Write([]byte(input))
        if err != nil{
            fmt.Println("Write failed,err:",err)
            break
        }
        //如果有返回，与服务器的读取方式相同。
        var buf [128]byte
        n, err := conn.Read(buf[:])
        if err != nil {
            fmt.Println("Read for tcp server faild", err)
            break
        }
        data := string(buf[:n])
        fmt.Printf("Recived from client data:%s\n", data)
   }

}

十六制处理办法

// 处理控制台输入的 \xFF\xEE 字符,四个字符一截取，并取后面两位
// 也可以使用strings.Split(str, "\\x") ，但会出现最后一个字符出现回车符

func Hextob(str string) []byte {
    slen := len(str)
    bHex := make([]byte, len(str)/4)
    ii := 0
    for i := 0; i < len(str); i = i + 4 {
        if slen > 1 {
            ss := string(str[i+3]) + string(str[i+4])
            if (ss == "\\x") || (ss == "") {
                continue
            }
            bt, _ := strconv.ParseInt(ss, 16, 32)
            bHex[ii] = byte(bt)
            ii = ii + 1
            slen = slen - 4
           //防止函数越界
            if len(bHex)-1 < ii {
                return bHex
            }
        }
    }
    return bHex
 }
// 如果字符为 FF FE 空格为间隔直接使用：strarray := strings.Fields(strings.TrimSpace(str))
func StringTo(str []string) []byte {
    //切片必须与字符长度一致，不然会出现 0
    bHex := make([]byte, len(str))
    for i := 0; i < len(str); i++ {
        if str[i] == "" {
            continue
        }
        bt, _ := strconv.ParseInt(str[i], 16, 32)
        bHex[i] = byte(bt)
    }
    return bHex
}

• 如果是内部定义的字符串
  如：str1 := "\xFE\x01\x00\x10\xC9"。
  直接使用：
  _, err = conn.Write([]byte(str1))

• 打印输出格式化成Hex：\xFF\x00\xEE。

  var buf [128]byte
  n, err := conn.Read(buf[:])
  if err != nil {
  fmt.Println("Read for tcp server faild", err)
  break
  }
  for i := 0; i < n; i++ {
  if buf[i] < 16 {
      fmt.Printf("0%X ", buf[i])
      continue
  }
  fmt.Printf("%X ", buf[i])
  }

• 如果不需要显示，可以直接使用