func (tunnel *Tunnel) HandleVOIPData(buff []byte, addr *net.UDPAddr, conn *net.UDPConn) { now := time.Now().Unix() _, receiver, _, err := tunnel.ReadVOIPData(buff) if err != nil { return } client := tunnel.FindClient(addr) if client == nil || client.appid == 0 { return } client.timestamp = now //转发消息 other := tunnel.FindAppClient(client.appid, receiver) if other == nil { log.Infof("can't dispatch voip data sender:%d receiver:%d", client.uid, receiver) return } if other.has_header { buffer := new(bytes.Buffer) var h byte = VOIP_DATA buffer.WriteByte(h) buffer.Write(buff) data := buffer.Bytes() conn.WriteTo(data, other.addr) } else { data := buff conn.WriteTo(data, other.addr) } }
func main() { go func() { var addr net.Addr var udp *net.UDPConn var err error if addr, err = net.ResolveUDPAddr("udp4", ":1234"); err != nil { panic(err) } if udp, err = net.ListenUDP("udp", addr.(*net.UDPAddr)); err != nil { panic(err) } var buf = make([]byte, 65535) n, addr, e := udp.ReadFrom(buf) if e != nil { panic(e) } udp.WriteTo(buf[:n], addr) }() runtime.Gosched() svr := NewPortalSvr() svr.basAddr = "127.0.0.1:1234" svr.basSecret = []byte("xxffe") if err := svr.Listen(":1288"); err != nil { panic(err) } svr.Run() err := svr.Auth("aas", "asas1", "255.255.255.255:1223") if err != nil { println(err.Error()) } }
func (tunnel *Tunnel) HandleAuth(buff []byte, addr *net.UDPAddr, conn *net.UDPConn) { now := time.Now().Unix() token, err := tunnel.ReadVOIPAuth(buff) if err != nil { return } client := tunnel.FindClient(addr) if client == nil { //首次收到认证消息 client = &TunnelClient{appid: 0, uid: 0, addr: addr, timestamp: now, has_header: true, token: token} tunnel.AuthClient(client, token) return } else if client.token == token { //认证成功 t := make([]byte, 2) t[0] = VOIP_AUTH_STATUS t[1] = 0 conn.WriteTo(t, addr) client.timestamp = now log.Infof("tunnel auth appid:%d uid:%d", client.appid, client.uid) } else { //新的token tunnel.RemoveTunnelClient(client) client.token = token client.appid = 0 client.uid = 0 client.timestamp = now tunnel.AuthClient(client, token) } }
func GetSend(conn *net.UDPConn, context *UdpContext) { file := context.file buffer := make([]byte, 1024) // Read into buffer len, err := file.Read(buffer) if len > 0 { // Write to socket _, err = conn.WriteTo(buffer[:len], context.dest) if err != nil { log.Println("Failed to write data to socket; abandoning transfer") } } // EOF? if err == io.EOF { log.Println("Transfer completed") return } // Some other error if err != nil { log.Println("Error reading file; abandoning transfer") return } }
func (d *UDPClient) sendAnnouncement(remote net.Addr, conn *net.UDPConn) bool { if debug { l.Debugf("discover %s: broadcast: Sending self announcement to %v", d.url, remote) } ann := d.announcer.Announcement() pkt, err := ann.MarshalXDR() if err != nil { return false } myID := protocol.DeviceIDFromBytes(ann.This.ID) _, err = conn.WriteTo(pkt, remote) if err != nil { if debug { l.Debugf("discover %s: broadcast: Failed to send self announcement: %s", d.url, err) } return false } // Verify that the announce server responds positively for our device ID time.Sleep(1 * time.Second) ann, err = d.Lookup(myID) if err != nil && debug { l.Debugf("discover %s: broadcast: Self-lookup failed: %v", d.url, err) } else if debug { l.Debugf("discover %s: broadcast: Self-lookup returned: %v", d.url, ann.This.Addresses) } return len(ann.This.Addresses) > 0 }
func handleudp(conn *net.UDPConn, remaddr net.Addr, message []byte) { fmt.Printf("UDP packet from %s (to %s)... ", remaddr, conn.LocalAddr()) n, error := conn.WriteTo(message, remaddr) checkError("Cannot write", error) if n != len(message) { panic("Cannot write") } fmt.Printf("Echoed %d bytes\n", n) }
func HandleUdpGet(conn *net.UDPConn, context *UdpContext) { log.Printf("Request for file '%s' (UDP)", context.parameters) command := fmt.Sprintf("length: %d\n", context.length) conn.WriteTo([]byte(command), context.dest) GetSend(conn, context) }
func TestHandlePing(t *testing.T) { m := GetMemberlist(t) m.config.EnableCompression = false defer m.Shutdown() var udp *net.UDPConn for port := 60000; port < 61000; port++ { udpAddr := fmt.Sprintf("127.0.0.1:%d", port) udpLn, err := net.ListenPacket("udp", udpAddr) if err == nil { udp = udpLn.(*net.UDPConn) break } } if udp == nil { t.Fatalf("no udp listener") } // Encode a ping ping := ping{SeqNo: 42} buf, err := encode(pingMsg, ping) if err != nil { t.Fatalf("unexpected err %s", err) } // Send addr := &net.UDPAddr{IP: net.ParseIP(m.config.BindAddr), Port: m.config.BindPort} udp.WriteTo(buf.Bytes(), addr) // Wait for response go func() { time.Sleep(time.Second) panic("timeout") }() in := make([]byte, 1500) n, _, err := udp.ReadFrom(in) if err != nil { t.Fatalf("unexpected err %s", err) } in = in[0:n] msgType := messageType(in[0]) if msgType != ackRespMsg { t.Fatalf("bad response %v", in) } var ack ackResp if err := decode(in[1:], &ack); err != nil { t.Fatalf("unexpected err %s", err) } if ack.SeqNo != 42 { t.Fatalf("bad sequence no") } }
func udpEchoHandler(c *net.UDPConn) { buf := make([]byte, 64) for { n, addr, err := c.ReadFrom(buf) if err != nil { return } if _, err = c.WriteTo(buf[0:n], addr); err != nil { return } } }
// Listens for an incoming packet and replies to it. func respond(t *testing.T, conn *net.UDPConn) { buff := make([]byte, 16) _, addr, err := conn.ReadFromUDP(buff) if err != nil { t.Fatalf("Cannot serve request: %s", err) } response := []byte("Some reply") if _, err = conn.WriteTo(response, addr); err != nil { t.Fatalf("Cannot write response: %s", err) } }
/* Send package */ func (pack *Package) Send(conn *net.UDPConn) (n int, err error) { pack.DataSize = uint16(len(pack.Data)) buf := new(bytes.Buffer) err = binary.Write(buf, binary.LittleEndian, pack.SeqID) if err != nil { return } if pack.IsResponse { t := uint16(uint16(0X8000) | pack.MsgID) err = binary.Write(buf, binary.LittleEndian, t) if err != nil { return } } else { err = binary.Write(buf, binary.LittleEndian, pack.MsgID) if err != nil { return } } err = binary.Write(buf, binary.LittleEndian, pack.DataSize) if err != nil { return } if pack.DataSize > 0 { if pack.IsResponse { log.Printf(">>> Response (%s): {MsgID:%d, SeqID:%d, Data:%s}\r\n", pack.Addr.String(), pack.MsgID, pack.SeqID, string(pack.Data)) } else { log.Printf(">>> Request (%s): {MsgID:%d, SeqID:%d, Data:%s}\r\n", pack.Addr.String(), pack.MsgID, pack.SeqID, string(pack.Data)) } n, err = buf.Write(pack.Data) if err != nil { return } if n != int(pack.DataSize) { return 0, errors.New("Write buffer error") } } else { if pack.IsResponse { log.Printf(">>> Response (%s): {MsgID:%d, SeqID:%d, Data:nil}\r\n", pack.Addr.String(), pack.MsgID, pack.SeqID) } else { log.Printf(">>> Request (%s): {MsgID:%d, SeqID:%d, Data:nil}\r\n", pack.Addr.String(), pack.MsgID, pack.SeqID) } } n, err = conn.WriteTo(buf.Bytes(), pack.Addr) if err != nil { return } if n != int(pack.DataSize+PACKAGE_HEAD_LEN) { return n, errors.New("Send failed!") } return }
// Transmit a message. func Transmit(l *net.UDPConn, a *net.UDPAddr, m Message) error { d, err := m.encode() if err != nil { return err } if a == nil { _, err = l.Write(d) } else { _, err = l.WriteTo(d, a) } return err }
func handleReq(n int, addr net.Addr, buf []byte, sCon *net.UDPConn){ if n < 2 { log.Printf("%v Sent less than 2 bytes\n", addr) return } pId := binary.BigEndian.Uint16(buf[:2]) switch { case pId == 0 && n == 2: //Public key request if _,err := sCon.WriteTo(encryption.RsaPub, addr); err != nil { log.Printf("Failed to reply to %v : %v", addr, err) } case pId == 0 && n > 2: //Registration ciphertext := buf[2:n] text, err := encryption.DecryptRSA(ciphertext) if err != nil{ log.Printf("%v Incorrectly encrypted message (RSA)\n") } log.Println(text) case n >= 2*encryption.AES_LENGTH + 2 + encryption.HMAC_LENGTH: //Request pId-- //Switch to real pId if int(pId) >= len(data.Players) { print(pId) log.Printf("%v Sent an invalid player id\n", addr) return } key := data.Players[pId].Key text, err := encryption.Decrypt(buf[2:n], key) if err != nil { log.Printf("%v %s\n", addr, err) return } log.Printf("%v %d\n", addr, text) data.Players[pId].Addr = addr switch text[0] { case 1: //SET2 if err := data.ReqSET2(text[1:], pId); err != nil { log.Printf("%v %s\n", addr, err) } default: log.Printf("%v Unknown request: %x", addr, text[0]) } //Reply /*res := encryption.Encrypt([]byte{1,2,3,5,8},key) _, err = sCon.WriteTo(res, addr) checkWarn(err)*/ default: log.Printf("%v Incorrectly encrypted message\n", addr) } }
/* * Handle incoming DNS packet: * - Only handle requests with at least on query resource record and * empty response resource records; skip all other packets. */ func process(conn *net.UDPConn, addr net.Addr, buf []byte, n int) { pos := 0 id, pos := getShort(buf, pos) qtype, pos := getShort(buf, pos) if (qtype & 0x8000) != 0 { if verbose { fmt.Printf("[Tor-DNS] Request is not a standard query: %x\n", qtype) } return } mode := (qtype >> 11) & 0xF if mode > 1 { if verbose { fmt.Printf("[Tor-DNS] Request is not a standard type: %x\n", qtype) } return } qd_cnt, pos := getShort(buf, pos) an_cnt, pos := getShort(buf, pos) ns_cnt, pos := getShort(buf, pos) ar_cnt, pos := getShort(buf, pos) if an_cnt > 0 || ns_cnt > 0 || ar_cnt > 0 || qd_cnt != 1 { if verbose { fmt.Printf("[Tor-DNS] Request has invalid counts: (%d,%d,%d,%d)\n", qd_cnt, an_cnt, ns_cnt, ar_cnt) } return } var q query q.mode = mode name, num := read_name(buf[pos:]) q.name = name pos += num q.typ, pos = getShort(buf, pos) q.class, pos = getShort(buf, pos) r, err := answer(id, q) if err != nil { fmt.Printf("[Tor-DNS] Can't answer query %x: %s\n", id, err.Error()) return } if n = assemble(buf, id, r); n > 0 { conn.WriteTo(buf[:n], addr) } }
func cliTunnelUDP(uconn *net.UDPConn, sconn net.Conn) { var raddr *net.UDPAddr go func() { b := lpool.Take() defer lpool.put(b) for { n, addr, err := uconn.ReadFromUDP(b) if err != nil { log.Println(err) return } raddr = addr r := bytes.NewBuffer(b[:n]) udp, err := gosocks5.ReadUDPDatagram(r) if err != nil { return } udp.Header.Rsv = uint16(len(udp.Data)) //log.Println("r", raddr.String(), udp.Header) if err := udp.Write(sconn); err != nil { log.Println(err) return } } }() for { b := lpool.Take() defer lpool.put(b) udp, err := gosocks5.ReadUDPDatagram(sconn) if err != nil { log.Println(err) return } //log.Println("w", udp.Header) udp.Header.Rsv = 0 buf := bytes.NewBuffer(b[0:0]) udp.Write(buf) if _, err := uconn.WriteTo(buf.Bytes(), raddr); err != nil { log.Println(err) return } } }
func readAndWriteUDP(r io.Reader, w io.Writer, con *net.UDPConn, ra net.Addr, verbose bool) <-chan net.Addr { buf := make([]byte, BUFFER_LIMIT) cAddr := make(chan net.Addr) go func() { defer func() { con.Close() cAddr <- ra }() for { var bytesread int var errRead, errWrite error if con, ok := r.(*net.UDPConn); ok { var addr net.Addr bytesread, addr, errRead = con.ReadFrom(buf) if con.RemoteAddr() == nil && ra == nil { ra = addr cAddr <- ra } } else { bytesread, errRead = r.Read(buf) } if errRead != nil { if errRead != io.EOF { if verbose { log.Println("READ ERROR: ", errRead) } } break } if con, ok := w.(*net.UDPConn); ok && con.RemoteAddr() == nil { _, errWrite = con.WriteTo(buf[0:bytesread], ra) } else { _, errWrite = w.Write(buf[0:bytesread]) } if errWrite != nil { if verbose { log.Println("WRITE ERROR: ", errWrite) } return } } }() return cAddr }
func udphandle(conn *net.UDPConn, remaddr net.Addr, buf *bytes.Buffer) { var response types.DNSpacket if debug > 1 { debuglogger.Logf("%d bytes packet from %s\n", buf.Len(), remaddr) } response, noresponse := generichandle(buf, remaddr) if !noresponse { binaryresponse := serialize(response) _, error := conn.WriteTo(binaryresponse, remaddr) if error != nil { if debug > 2 { debuglogger.Logf("Error in Write: %s\n", error) return } } } // Else, ignore the incoming packet. May be we should reply REFUSED instead? }
func dnsListen(conn net.UDPConn) { buf := make([]byte, 1024) n, addr, err := conn.ReadFrom(buf) log.Print("Addr", addr) if err != nil { log.Fatal(err) } log.Printf("Data come in from: %s", addr) reply := dnsRequest(buf[0:n]) _, err = conn.WriteTo(reply, addr) if err != nil { log.Fatal(err) } else { log.Print("=====EOF=====") } }
func getReflexive(sock *net.UDPConn) (string, int, error) { serverAddr, err := net.ResolveUDPAddr("udp", *stunserver) if err != nil { return "", 0, errors.New("Couldn't resolve STUN server") } //println("connect stun server", *stunserver) var tid [12]byte if _, err = rand.Read(tid[:]); err != nil { return "", 0, err } request, err := stun.BindRequest(tid[:], nil, nil, true, false) if err != nil { return "", 0, err } n, err := sock.WriteTo(request, serverAddr) if err != nil { return "", 0, err } if n < len(request) { return "", 0, err } var buf [1024]byte n, _, err = sock.ReadFromUDP(buf[:]) if err != nil { return "", 0, err } packet, err := stun.ParsePacket(buf[:n], nil) if err != nil { return "", 0, err } if packet.Class != stun.ClassSuccess || packet.Method != stun.MethodBinding || packet.Addr == nil || !bytes.Equal(tid[:], packet.Tid[:]) { return "", 0, errors.New("No address provided by STUN server") } return packet.Addr.IP.String(), packet.Addr.Port, nil }
func sendPacketJob(c *net.UDPConn, txChan chan<- *mav.MavPacket) { raddr, err := net.ResolveUDPAddr("udp", "127.0.0.1:14551") if err != nil { log.Fatalf("Error can not resolve UDP address:", err) } for { message := new(mav.Heartbeat) packet, err := mav.CreatePacket(1, 200, message) if err != nil { log.Fatalf("Error with the packet's creation:", err) } _, err = c.WriteTo(packet.Bytes(), raddr) if err != nil { log.Fatalf("Cannot write packet:", err) } txChan <- packet time.Sleep(1000 * time.Millisecond) } }
func TestHandlePing_WrongNode(t *testing.T) { m := GetMemberlist(t) m.config.EnableCompression = false defer m.Shutdown() var udp *net.UDPConn for port := 60000; port < 61000; port++ { udpAddr := fmt.Sprintf("127.0.0.1:%d", port) udpLn, err := net.ListenPacket("udp", udpAddr) if err == nil { udp = udpLn.(*net.UDPConn) break } } if udp == nil { t.Fatalf("no udp listener") } // Encode a ping, wrong node! ping := ping{SeqNo: 42, Node: m.config.Name + "-bad"} buf, err := encode(pingMsg, ping) if err != nil { t.Fatalf("unexpected err %s", err) } // Send addr := &net.UDPAddr{IP: net.ParseIP(m.config.BindAddr), Port: m.config.BindPort} udp.WriteTo(buf.Bytes(), addr) // Wait for response udp.SetDeadline(time.Now().Add(50 * time.Millisecond)) in := make([]byte, 1500) _, _, err = udp.ReadFrom(in) // Should get an i/o timeout if err == nil { t.Fatalf("expected err %s", err) } }
func receiveGoroutine(conn *net.UDPConn, ch chan<- int) { var count uint32 = 1 for i := 0; i < 2; i++ { var data [1024]byte _, addr, err := conn.ReadFrom(data[:]) if err != nil { log.Printf("Recv: %v", err) } buf := bytes.NewBuffer(data[:]) err = binary.Read(buf, binary.BigEndian, &count) if err != nil { log.Printf("Buffer: %v\n", err) break } log.Printf("Receive From Client %d\n", count) count++ bufW := new(bytes.Buffer) err = binary.Write(bufW, binary.LittleEndian, count) if err != nil { log.Printf("Buffer: %v\n", err) } _, err = conn.WriteTo(bufW.Bytes(), addr) if err != nil { log.Printf("Send: %v\n", err) break } } if err := conn.Close(); err != nil { log.Printf("Close: %v\n", err) } ch <- 1 }
func ChatWriter(channel chan string, conn *net.UDPConn) { //addrs, _ := ifi.MulticastAddrs() addr, err := net.ResolveUDPAddr("udp4", "192.168.1.255:4040") if err != nil { fmt.Println("Resolve Error: ", err) os.Exit(1) } for { select { case line := <-channel: _, err := conn.WriteTo([]byte(line), addr) if err != nil { fmt.Println("Write error: ", err) os.Exit(1) } } } }
func Main(clusterName, self, buri, rwsk, rosk string, cl *doozer.Conn, udpConn *net.UDPConn, listener, webListener net.Listener, pulseInterval, fillDelay, kickTimeout int64, hi int64) { listenAddr := listener.Addr().String() canWrite := make(chan bool, 1) in := make(chan consensus.Packet, 50) out := make(chan consensus.Packet, 50) st := store.New() pr := &proposer{ seqns: make(chan int64, alpha), props: make(chan *consensus.Prop), st: st, } calSrv := func(start int64) { go gc.Pulse(self, st.Seqns, pr, pulseInterval) go gc.Clean(st, hi, time.Tick(1e9)) var m consensus.Manager m.Self = self m.DefRev = start m.Alpha = alpha m.In = in m.Out = out m.Ops = st.Ops m.PSeqn = pr.seqns m.Props = pr.props m.TFill = fillDelay m.Store = st m.Ticker = time.Tick(10e6) go m.Run() } hostname, err := os.Hostname() if err != nil { hostname = "unknown" } if cl == nil { // we are the only node in a new cluster set(st, "/ctl/name", clusterName, store.Missing) set(st, "/ctl/node/"+self+"/addr", listenAddr, store.Missing) set(st, "/ctl/node/"+self+"/hostname", hostname, store.Missing) set(st, "/ctl/node/"+self+"/version", Version, store.Missing) set(st, "/ctl/cal/0", self, store.Missing) if buri == "" { set(st, "/ctl/ns/"+clusterName+"/"+self, listenAddr, store.Missing) } calSrv(<-st.Seqns) // Skip ahead alpha steps so that the registrar can provide a // meaningful cluster. for i := 0; i < alpha; i++ { st.Ops <- store.Op{1 + <-st.Seqns, store.Nop} } canWrite <- true go setReady(pr, self) } else { setC(cl, "/ctl/node/"+self+"/addr", listenAddr, store.Clobber) setC(cl, "/ctl/node/"+self+"/hostname", hostname, store.Clobber) setC(cl, "/ctl/node/"+self+"/version", Version, store.Clobber) rev, err := cl.Rev() if err != nil { panic(err) } stop := make(chan bool, 1) go follow(st, cl, rev+1, stop) errs := make(chan error) go func() { e, ok := <-errs if ok { panic(e) } }() doozer.Walk(cl, rev, "/", cloner{st.Ops, cl}, errs) close(errs) st.Flush() ch, err := st.Wait(store.Any, rev+1) if err == nil { <-ch } go func() { n := activate(st, self, cl) calSrv(n) advanceUntil(cl, st.Seqns, n+alpha) stop <- true canWrite <- true go setReady(pr, self) if buri != "" { b, err := doozer.DialUri(buri, "") if err != nil { panic(err) } setC( b, "/ctl/ns/"+clusterName+"/"+self, listenAddr, store.Missing, ) } }() } shun := make(chan string, 3) // sufficient for a cluster of 7 go member.Clean(shun, st, pr) go server.ListenAndServe(listener, canWrite, st, pr, rwsk, rosk) if rwsk == "" && rosk == "" && webListener != nil { web.Store = st web.ClusterName = clusterName go web.Serve(webListener) } go func() { for p := range out { n, err := udpConn.WriteTo(p.Data, p.Addr) if err != nil { log.Println(err) continue } if n != len(p.Data) { log.Println("packet len too long:", len(p.Data)) continue } } }() selfAddr, ok := udpConn.LocalAddr().(*net.UDPAddr) if !ok { panic("no UDP addr") } lv := liveness{ timeout: kickTimeout, ival: kickTimeout / 2, self: selfAddr, shun: shun, } for { t := time.Now().UnixNano() buf := make([]byte, maxUDPLen) n, addr, err := udpConn.ReadFromUDP(buf) if err == syscall.EINVAL { return } if err != nil { log.Println(err) continue } buf = buf[:n] lv.mark(addr, t) lv.check(t) in <- consensus.Packet{addr, buf} } }
func testWriteConn(t *testing.T, conn *net.UDPConn, addr *net.UDPAddr, dg datagram) { if _, err := conn.WriteTo(dg.bytes(), addr); err != nil { t.Fatal(err) } }
func SendRRQTo(filename string, Conn *net.UDPConn, raddr *net.UDPAddr) { msg, err := makeRRQ(filename) checkError(err) _, err = Conn.WriteTo(msg, raddr) checkError(err) }
func SendERRORTo(errCode []byte, errMsg string, Conn *net.UDPConn, raddr *net.UDPAddr) { msg, err := makeERROR(errCode, errMsg) checkError(err) _, err = Conn.WriteTo(msg, raddr) checkError(err) }
func SendDATATo(block []byte, data []byte, Conn *net.UDPConn, raddr *net.UDPAddr) { msg, err := makeDATA(block, data) checkError(err) _, err = Conn.WriteTo(msg, raddr) checkError(err) }
// writeToSessionUDP acts just like net.UDPConn.WritetTo(), but uses a *sessionUDP instead of a net.Addr. func writeToSessionUDP(conn *net.UDPConn, b []byte, session *sessionUDP) (int, error) { n, err := conn.WriteTo(b, session.raddr) return n, err }
func TestSendMsg_Piggyback(t *testing.T) { m := GetMemberlist(t) defer m.Shutdown() // Add a message to be broadcast a := alive{ Incarnation: 10, Node: "rand", Addr: []byte{127, 0, 0, 255}, Meta: nil, } m.encodeAndBroadcast("rand", aliveMsg, &a) var udp *net.UDPConn for port := 60000; port < 61000; port++ { udpAddr := fmt.Sprintf("127.0.0.1:%d", port) udpLn, err := net.ListenPacket("udp", udpAddr) if err == nil { udp = udpLn.(*net.UDPConn) break } } // Encode a ping ping := ping{SeqNo: 42} buf, err := encode(pingMsg, ping) if err != nil { t.Fatalf("unexpected err %s", err) } // Send addr := &net.UDPAddr{IP: net.ParseIP(m.config.BindAddr), Port: m.config.BindPort} udp.WriteTo(buf.Bytes(), addr) // Wait for response go func() { time.Sleep(time.Second) panic("timeout") }() in := make([]byte, 1500) n, _, err := udp.ReadFrom(in) if err != nil { t.Fatalf("unexpected err %s", err) } in = in[0:n] msgType := messageType(in[0]) if msgType != compoundMsg { t.Fatalf("bad response %v", in) } // get the parts trunc, parts, err := decodeCompoundMessage(in[1:]) if trunc != 0 { t.Fatalf("unexpected truncation") } if len(parts) != 2 { t.Fatalf("unexpected parts %v", parts) } if err != nil { t.Fatalf("unexpected err %s", err) } var ack ackResp if err := decode(parts[0][1:], &ack); err != nil { t.Fatalf("unexpected err %s", err) } if ack.SeqNo != 42 { t.Fatalf("bad sequence no") } var aliveout alive if err := decode(parts[1][1:], &aliveout); err != nil { t.Fatalf("unexpected err %s", err) } if aliveout.Node != "rand" || aliveout.Incarnation != 10 { t.Fatalf("bad mesg") } }