func (fs *FrameSender) Send(hdr *aoe.Header) (int, error) {
hdr.Version = 1
hdr.FlagResponse = true
hdr.Major = fs.major
hdr.Minor = fs.minor
hdr.Tag = fs.orig.Tag
hbuf, err := hdr.MarshalBinary()
if err != nil {
panic(err)
}
frame := ðernet.Frame{
Destination: fs.dst,
Source: fs.src,
EtherType: aoe.EtherType,
Payload: hbuf,
}
ebuf, err := frame.MarshalBinary()
if err != nil {
panic(err)
}
clog.Debugf("send %d %s %+v", len(ebuf), fs.dst, hdr)
//clog.Debugf("send arg %+v", hdr.Arg)
return fs.conn.WriteTo(ebuf, &raw.Addr{HardwareAddr: fs.dst})
}
// 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 := ðernet.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
}
// testBPFProgram builds a BPF program for the input server and compares the
// output of the program against the input AoE header, returning whether or
// not the header was accepted by the filter.
func testBPFProgram(t *testing.T, s *Server, h *aoe.Header) bool {
filter, ok := bpf.Disassemble(s.mustAssembleBPF(testMTU))
if !ok {
t.Fatal("failed to decode all BPF instructions")
}
vm, err := bpf.NewVM(filter)
if !ok {
t.Fatalf("failed to load BPF program: %v", err)
}
// Fill in empty AoE header fields not relevant to this test
h.Version = aoe.Version
h.Command = aoe.CommandQueryConfigInformation
h.Arg = &aoe.ConfigArg{
Command: aoe.ConfigCommandRead,
}
hb, err := h.MarshalBinary()
if err != nil {
t.Fatalf("failed to marshal AoE header to binary: %v", err)
}
f := ðernet.Frame{
EtherType: aoe.EtherType,
Payload: hb,
}
fb, err := f.MarshalBinary()
if err != nil {
t.Fatalf("failed to marshal Ethernet frame to binary: %v", err)
}
out, err := vm.Run(fb)
if err != nil {
t.Fatalf("failed to run BPF program: %v", err)
}
return out > 0
}