func ethernetFrame(t *testing.T) []byte {
	f := new(ethernet.Frame)
	fb, err := f.MarshalFCS()
	if err != nil {
		t.Fatalf("failed to marshal Ethernet frame: %v", err)
	}

	return fb
}

// Handles a IPv4 packet and sends it to it's destination
func (p *PeerToPeer) handlePacketIPv4(contents []byte, proto int) {
	Log(Trace, "Handling IPv4 Packet")
	f := new(ethernet.Frame)
	if err := f.UnmarshalBinary(contents); err != nil {
		Log(Error, "Failed to unmarshal IPv4 packet")
	}

	if f.EtherType != ethernet.EtherTypeIPv4 {
		return
	}
	msg := CreateNencP2PMessage(p.Crypter, contents, uint16(proto), 1, 1, 1)
	p.SendTo(f.Destination, msg)
}

func parsePacket(buf []byte) (*Packet, *ethernet.Frame, error) {
	f := new(ethernet.Frame)
	if err := f.UnmarshalBinary(buf); err != nil {
		return nil, nil, err
	}

	// Ignore frames which do not have ARP EtherType
	if f.EtherType != ethernet.EtherTypeARP {
		return nil, nil, errInvalidARPPacket
	}

	p := new(Packet)
	if err := p.UnmarshalBinary(f.Payload); err != nil {
		return nil, nil, err
	}
	return p, f, nil
}

// testRequest performs a single AoE request using the input request
// header and returns a single AoE response.
func testRequest(t *testing.T, req *aoe.Header) *aoe.Header {
	recv, send, run, done := testAoEServer(t)
	defer done()

	reqb, err := req.MarshalBinary()
	if err != nil {
		t.Fatalf("failed to marshal request AoE header: %v", err)
	}

	reqf := &ethernet.Frame{
		Payload: reqb,
	}

	reqfb, err := reqf.MarshalBinary()
	if err != nil {
		t.Fatalf("failed to marshal request Ethernet frame: %v", err)
	}

	if _, err := send.Write(reqfb); err != nil {
		t.Fatalf("failed to write request to server: %v", err)
	}

	if err := run(); err != nil {
		t.Fatalf("failed to run server: %v", err)
	}

	b, err := ioutil.ReadAll(recv)
	if err != nil {
		t.Fatalf("failed to read server response: %v", err)
	}

	resf := new(ethernet.Frame)
	if err := resf.UnmarshalBinary(b); err != nil {
		t.Fatalf("failed to unmarshal response Ethernet frame: %v", err)
	}

	resh := new(aoe.Header)
	if err := resh.UnmarshalBinary(resf.Payload); err != nil {
		t.Fatalf("failed to unmarshal response AoE header: %v", err)
	}

	return resh
}

// UnmarshalBinary allocates a byte slice and marshals a Frame into binary form.
//
// If a VNI value is invalid, ErrInvalidVNI will be returned.
func (f *Frame) UnmarshalBinary(b []byte) error {
	// Need at least VXLAN frame and empty Ethernet frame
	if len(b) < 18 {
		return io.ErrUnexpectedEOF
	}

	// I flag must be set to 1.
	if (b[0] >> 3) != 1 {
		return ErrInvalidFrame
	}

	f.VNI = VNI(binary.BigEndian.Uint32(b[3:]))

	ef := new(ethernet.Frame)
	if err := ef.UnmarshalFCS(b[8:]); err != nil {
		return err
	}
	f.Ethernet = ef

	return nil
}

// parseRequest unmarshals a raw ethernet frame and an ARP packet into a Request.
func parseRequest(buf []byte) (*Request, error) {
	f := new(ethernet.Frame)
	if err := f.UnmarshalBinary(buf); err != nil {
		return nil, err
	}

	// Ignore frames which do not have ARP EtherType
	if f.EtherType != ethernet.EtherTypeARP {
		return nil, errInvalidARPPacket
	}

	p := new(Packet)
	if err := p.UnmarshalBinary(f.Payload); err != nil {
		return nil, err
	}

	return &Request{
		Operation:          p.Operation,
		SenderHardwareAddr: p.SenderHardwareAddr,
		SenderIP:           p.SenderIP,
		TargetHardwareAddr: p.TargetHardwareAddr,
		TargetIP:           p.TargetIP,
	}, nil
}

func (p *PeerToPeer) handlePacketARP(contents []byte, proto int) {
	// Prepare new ethernet frame and fill it with
	// contents of the packet
	f := new(ethernet.Frame)
	if err := f.UnmarshalBinary(contents); err != nil {
		Log(Error, "Failed to Unmarshal ARP Binary")
		return
	}

	if f.EtherType != ethernet.EtherTypeARP {
		Log(Error, "Not ARP")
		return
	}

	packet := new(ARPPacket)
	if err := packet.UnmarshalARP(f.Payload); err != nil {
		Log(Error, "Failed to unmarshal arp")
		return
	}
	Log(Trace, "Peers: %v, Target IP: %s", p.NetworkPeers, packet.TargetIP.String())
	var hwAddr net.HardwareAddr
	id, exists := p.IPIDTable[packet.TargetIP.String()]
	if !exists {
		Log(Debug, "Unknown IP requested")
		return
	}
	peer, exists := p.NetworkPeers[id]
	if !exists {
		Log(Debug, "Specified ID was not found in peer list")
		return
	}
	hwAddr = peer.PeerHW
	// TODO: Put there normal IP from list of ips
	// Send a reply
	if hwAddr == nil {
		Log(Error, "Cannot find hardware address for requested IP")
		_, hwAddr = GenerateMAC()
		peer.PeerHW = hwAddr
		p.NetworkPeers[id] = peer
	}
	if hwAddr.String() == "00:00:00:00:00:00" {
		_, hwAddr = GenerateMAC()
		peer.PeerHW = hwAddr
		p.NetworkPeers[id] = peer
	}
	var reply ARPPacket
	ip := net.ParseIP(packet.TargetIP.String())
	response, err := reply.NewPacket(OperationReply, hwAddr, ip, packet.SenderHardwareAddr, packet.SenderIP)
	if err != nil {
		Log(Error, "Failed to create ARP reply")
		return
	}
	rp, err := response.MarshalBinary()
	if err != nil {
		Log(Error, "Failed to marshal ARP response packet")
		return
	}

	fr := &ethernet.Frame{
		Destination: response.TargetHardwareAddr,
		Source:      response.SenderHardwareAddr,
		EtherType:   ethernet.EtherTypeARP,
		Payload:     rp,
	}

	fb, err := fr.MarshalBinary()
	if err != nil {
		Log(Error, "Failed to marshal ARP Ethernet Frame")
	}
	Log(Debug, "%v", packet.String())
	p.WriteToDevice(fb, uint16(proto), false)
}

func TestServeOK(t *testing.T) {
	b := append([]byte{
		// Ethernet frame
		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad,
		0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
		0x08, 0x06,
		// ARP Packet
		0, 1,
		0x08, 0x06,
		6,
		4,
		0, 1,
		0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff,
		192, 168, 1, 10,
		0xde, 0xad, 0xbe, 0xef, 0xde, 0xad,
		192, 168, 1, 1,
	}, make([]byte, 40)...)

	// Values to be sent in ARP reply and checked later
	wantsHW := net.HardwareAddr{0xde, 0xad, 0xbe, 0xef, 0xde, 0xad}
	wantsIP := net.IP{192, 168, 1, 1}

	wanttHW := net.HardwareAddr{0xaa, 0xbb, 0xcc, 0xdd, 0xee, 0xff}
	wanttIP := net.IP{192, 168, 1, 10}

	// Count bytes sent
	var n int
	p, err := testServe(b, true, func(w ResponseSender, r *Request) {
		// Build an ARP reply for request
		pkt, err := NewPacket(
			OperationReply,
			r.TargetHardwareAddr,
			r.TargetIP,
			r.SenderHardwareAddr,
			r.SenderIP,
		)
		if err != nil {
			t.Fatal(err)
		}

		n, err = w.Send(pkt)
		if err != nil {
			t.Fatal(err)
		}
		return
	})
	if err != nil {
		t.Fatal(err)
	}

	if want, got := n, p.wb.Len(); want != got {
		t.Fatalf("unexpected response length: %v != %v", want, got)
	}

	// Unmarshal ethernet frame and verify fields
	f := new(ethernet.Frame)
	if err := f.UnmarshalBinary(p.wb.Bytes()); err != nil {
		log.Println(len(p.wb.Bytes()))
		t.Fatal(err)
	}

	if want, got := wanttHW, f.Destination; !bytes.Equal(want, got) {
		t.Fatalf("unexpected ethernet frame destination:\n- want: %v\n-  got: %v",
			want, got)
	}
	if want, got := wantsHW, f.Source; !bytes.Equal(want, got) {
		t.Fatalf("unexpected ethernet frame source:\n- want: %v\n-  got: %v",
			want, got)
	}
	if want, got := ethernet.EtherTypeARP, f.EtherType; want != got {
		t.Fatalf("unexpected ethernet frame EtherType: %v != %v", want, got)
	}

	// Unmarshal ARP packet and verify fields
	pkt := new(Packet)
	if err := pkt.UnmarshalBinary(f.Payload); err != nil {
		t.Fatal(err)
	}

	// Hardware type is hardcoded
	if want, got := uint16(1), pkt.HardwareType; want != got {
		t.Fatalf("unexpected ARP packet hardware type: %v != %v", want, got)
	}
	// Protocol type is hardcoded
	if want, got := uint16(ethernet.EtherTypeIPv4), pkt.ProtocolType; want != got {
		t.Fatalf("unexpected ARP packet protocol type: %v != %v", want, got)
	}

	if want, got := uint8(len(wantsHW)), pkt.HardwareAddrLength; want != got {
		t.Fatalf("unexpected ARP packet hardware address length: %v != %v", want, got)
	}
	if want, got := uint8(len(wantsIP)), pkt.IPLength; want != got {
		t.Fatalf("unexpected ARP packet IP length: %v != %v", want, got)
	}

	if want, got := OperationReply, pkt.Operation; want != got {
		t.Fatalf("unexpected ARP packet operation: %v != %v", want, got)
	}

	if want, got := wantsHW, pkt.SenderHardwareAddr; !bytes.Equal(want, got) {
//.........这里部分代码省略.........