test net unpack

main.go

package main                                                                  
                                                                              
import (                                                                      
        "log"                                                                 
        "fmt"                                                                 
        "net"                                                                 
        "bytes"                                                               
        "unsafe"                                                              
        "encoding/binary"                                                     
)                                                                             
                                                                              
type ident int8                                                               
                                                                              
                                                                              
type header struct {                                                          
        Ident   ident                                                         
        BodyLen int8                                                          
}                                                                             
                                                                              
type body struct {                                                            
        fnNameLen       int                                                   
        fnName          string                                                
        params          []byte                                                
}                                                                             
                                                                              
func main() {                                                                 
        sock, err := net.Listen("tcp", ":18103")                              
        defer sock.Close()                                                    
        if err != nil {                                                       
                panic(err.Error())                                            
        }                                                                     
        log.Println("listening on port 18103")                                
        for {                                                                 
                conn, err := sock.Accept()                                    
                if err != nil {                                               
                        panic(fmt.Sprintf("Error accepting: %v", err.Error()))
                }                                                             
                go handleConn(conn)                                           
        }                                                                                                         
}                                                                                                         
                                                                                                          
func handleConn(conn net.Conn) {                                                                          
        // sock = socket.socket(); sock.connect(("10.3.155.177", 18103)); d = struct.pack("<QQ", 1, 2); sock.send(d)                                                                                                
        // read ident and fnLen                                                                           
        defer conn.Close()                                                                                
        size := unsafe.Sizeof(int(0)) * 2                                                                 
        fmt.Printf("allocing %d for header\n", size)                                                      
        buf := make([]byte, size, size)                                                                   
        n, err := conn.Read(buf)                                                                          
        fmt.Println("read ", n, buf)                                                                      
        if err != nil {                                                                                   
                log.Printf("Error reading from conn: %v\n", err.Error())                                  
                return                                                                                    
        }                                                                                                 
        r := bytes.NewReader(buf)                                                                         
        h := header{}                                                                                     
        if err = binary.Read(r, binary.LittleEndian, &h); err != nil {                                    
                log.Println("Error parsing header: ", err.Error())                                        
        } else {                                                                                          
                fmt.Println("parse successful ", h)                                                       
        }                                                                                                 
}