| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| package mdns |
| |
| import ( |
| "bytes" |
| "context" |
| "fmt" |
| "net" |
| "testing" |
| "time" |
| |
| "github.com/google/go-cmp/cmp" |
| ) |
| |
| var ( |
| fakeIfaceMCastUp = &net.Interface{ |
| Index: 1, |
| MTU: 1800, |
| Name: "faketh0", |
| HardwareAddr: []byte{0, 0, 0, 0, 0, 0}, |
| Flags: net.FlagMulticast | net.FlagUp, |
| } |
| fakeIfaceMCastUpJoinGroupError = &net.Interface{ |
| Index: 2, |
| MTU: 1800, |
| Name: "faketh1", |
| HardwareAddr: []byte{0x2, 0, 0, 0, 0, 0}, |
| Flags: net.FlagMulticast | net.FlagUp, |
| } |
| fakeIfaceMCastUpConnectToError = &net.Interface{ |
| Index: 3, |
| MTU: 1800, |
| Name: "faketh3", |
| HardwareAddr: []byte{0x8, 0, 0, 0, 0, 0}, |
| Flags: net.FlagMulticast | net.FlagUp, |
| } |
| fakeIfaceMCastDown = &net.Interface{ |
| Index: 4, |
| MTU: 1800, |
| Name: "faketh4", |
| HardwareAddr: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06}, |
| Flags: net.FlagMulticast, |
| } |
| ) |
| |
| type fakeAddr struct{} |
| |
| func (f *fakeAddr) Network() string { |
| return "udp" |
| } |
| |
| func (f *fakeAddr) String() string { |
| return "192.168.2.2" |
| } |
| |
| type fakePacketConn struct { |
| packetCh chan []byte |
| ifi *net.Interface |
| } |
| |
| func (f *fakePacketConn) MulticastInterface() (*net.Interface, error) { |
| return f.ifi, nil |
| } |
| |
| func (f *fakePacketConn) ReadFrom(p []byte) (n int, addr net.Addr, err error) { |
| buf := <-f.packetCh |
| for i, b := range buf { |
| p[i] = b |
| } |
| n = len(buf) |
| addr = &fakeAddr{} |
| err = nil |
| return |
| } |
| |
| func (f *fakePacketConn) WriteTo(p []byte, addr net.Addr) (n int, err error) { |
| f.packetCh <- p |
| n = len(p) |
| err = nil |
| return |
| } |
| |
| func (f *fakePacketConn) Close() error { |
| return nil |
| } |
| |
| func (f *fakePacketConn) LocalAddr() net.Addr { |
| return &fakeAddr{} |
| } |
| |
| func (f *fakePacketConn) SetDeadline(t time.Time) error { |
| return nil |
| } |
| |
| func (f *fakePacketConn) SetReadDeadline(t time.Time) error { |
| return nil |
| } |
| |
| func (f *fakePacketConn) SetWriteDeadline(t time.Time) error { |
| return nil |
| } |
| |
| type fakeNetFactory struct { |
| packetCh chan []byte |
| ttlCh chan int |
| } |
| |
| func (f *fakeNetFactory) MakeUDPSocket(ifi *net.Interface, _ *net.UDPAddr, ttl int) (packetConn, error) { |
| if ifi.Name == fakeIfaceMCastUpConnectToError.Name { |
| return nil, fmt.Errorf("returning testing error for iface %q", ifi.Name) |
| } |
| f.ttlCh <- ttl |
| return &fakePacketConn{packetCh: f.packetCh, ifi: ifi}, nil |
| } |
| |
| // Returns a fake mDNS connection, a multicast packet channel, a unicast |
| // packet channel, and a TTL-to-be-sent channel respectively. The latter does |
| // not return any data. It is to indicate the TTL that was set for all packets |
| // on this connection. |
| // |
| // Keep in mind if running multiple ConnectTo's it will simply add multiple |
| // readers to ONE channel. This doesn't support something like mapping ports to |
| // specific channels or the like. |
| func makeFakeMDNSConn(v6 bool) (mDNSConnBase, chan []byte, chan int) { |
| // NOTE: In the event that some sort of mapping is going to be made or |
| // multiple values intend to be pushed into these channels, then this |
| // implementation will need to be updated. |
| in := make(chan []byte, 1) |
| ttl := make(chan int, 1) |
| // TODO(awdavies): Should this be a dep injection from a function rather |
| // than constructed purely for tests? |
| c := mDNSConnBase{ |
| netFactory: &fakeNetFactory{packetCh: in, ttlCh: ttl}, |
| ttl: -1, |
| } |
| if v6 { |
| c.dst.IP = defaultMDNSMulticastIPv6 |
| } else { |
| c.dst.IP = defaultMDNSMulticastIPv4 |
| } |
| return c, in, ttl |
| } |
| |
| func TestCast4(t *testing.T) { |
| c, in, ttl := makeFakeMDNSConn(false) |
| defer c.Close() |
| c.dst.IP = net.ParseIP("192.168.2.2") |
| c.dst.Port = 12345 |
| if err := c.JoinGroup(fakeIfaceMCastUp); err != nil { |
| t.Fatalf("Unable to connect to port: %s", err) |
| } |
| ttlWant := -1 |
| ttlGot := <-ttl |
| if d := cmp.Diff(ttlWant, ttlGot); d != "" { |
| t.Fatalf("ttl for senders incorrect (-want +got)\n%s", d) |
| } |
| if err := c.JoinGroup(fakeIfaceMCastUp); err != nil { |
| t.Fatalf("Unable to connect to port: %s", err) |
| } |
| ttlGot = <-ttl |
| if d := cmp.Diff(ttlWant, ttlGot); d != "" { |
| t.Errorf("ttl for senders incorrect (-want +got)\n%s", d) |
| } |
| |
| rpChan := c.Listen(context.Background()) |
| |
| want := []byte{0, 1, 2, 3, 4} |
| // "Write" packet to the unicast listeners. |
| in <- want |
| got := <-rpChan |
| // Compare a subsection, as this will by default return a kilobyte buffer. |
| if d := cmp.Diff(want, got.data[:len(want)]); d != "" { |
| t.Errorf("read/write mismatch (-wrote +read)\n%s", d) |
| } |
| } |
| |
| func TestTTLValues(t *testing.T) { |
| c, _, _ := makeFakeMDNSConn(false) |
| defer c.Close() |
| // Expecting errors. |
| if err := c.SetMCastTTL(256); err == nil { |
| t.Errorf("expecting error SetMCastTTL()") |
| } |
| if err := c.SetMCastTTL(10000); err == nil { |
| t.Errorf("expecting error SetMCastTTL()") |
| } |
| |
| // Expecting no errors. |
| if err := c.SetMCastTTL(-10); err != nil { |
| t.Errorf("expecting no error SetMCastTTL()") |
| } |
| } |
| |
| func TestCast6(t *testing.T) { |
| c, in, ttl := makeFakeMDNSConn(true) |
| defer c.Close() |
| c.dst.IP = net.ParseIP("2001:db8::1") |
| c.dst.Port = 1234 |
| if err := c.JoinGroup(fakeIfaceMCastUp); err != nil { |
| t.Fatalf("Unable to connect to port: %s", err) |
| } |
| ttlWant := -1 |
| ttlGot := <-ttl |
| if d := cmp.Diff(ttlWant, ttlGot); d != "" { |
| t.Errorf("ttl for senders incorrect (-want +got)\n%s", d) |
| } |
| |
| c.SetMCastTTL(0) |
| if err := c.JoinGroup(fakeIfaceMCastUp); err != nil { |
| t.Fatalf("Unable to connect to port: %s", err) |
| } |
| ttlWant = 0 |
| ttlGot = <-ttl |
| if d := cmp.Diff(ttlWant, ttlGot); d != "" { |
| t.Errorf("ttl for senders incorrect (-want +got)\n%s", d) |
| } |
| |
| rpChan := c.Listen(context.Background()) |
| |
| want := []byte{0, 9, 2, 9, 2} |
| // "Write" packets to the listeners. |
| in <- want |
| got := <-rpChan |
| // Compare a subsection, as this will by default return a kilobyte buffer. |
| if d := cmp.Diff(want, got.data[:len(want)]); d != "" { |
| t.Errorf("read/write mismatch (-wrote +read)\n%s", d) |
| } |
| } |
| |
| func TestUint16(t *testing.T) { |
| var buf bytes.Buffer |
| v := uint16(6857) |
| writeUint16(&buf, v) |
| var v2 uint16 |
| readUint16(&buf, &v2) |
| if d := cmp.Diff(v, v2); d != "" { |
| t.Errorf("read/writeUint16: mismatch (-wrote +read)\n%s", d) |
| } |
| } |
| |
| func TestUint32(t *testing.T) { |
| var buf bytes.Buffer |
| v := uint32(6857) |
| writeUint32(&buf, v) |
| var v2 uint32 |
| readUint32(&buf, &v2) |
| if d := cmp.Diff(v, v2); d != "" { |
| t.Errorf("read/writeUint32: mismatch (-wrote +read)\n%s", d) |
| } |
| } |
| |
| func TestHeader(t *testing.T) { |
| var buf bytes.Buffer |
| v := Header{ |
| ID: 593, |
| Flags: 795, |
| QDCount: 5839, |
| ANCount: 9009, |
| NSCount: 8583, |
| ARCount: 7764, |
| } |
| v.serialize(&buf) |
| var v2 Header |
| v2.deserialize(buf.Bytes(), &buf) |
| if d := cmp.Diff(v, v2); d != "" { |
| t.Errorf("header (de)serialize: mismatch (-serialize +deserialize)\n%s", d) |
| } |
| } |
| |
| func TestDomain(t *testing.T) { |
| var buf bytes.Buffer |
| v := "this.is.a.random.domain.to.check" |
| writeDomain(&buf, v) |
| var v2 string |
| readDomain(buf.Bytes(), &buf, &v2) |
| if d := cmp.Diff(v, v2); d != "" { |
| t.Errorf("read/writeDomain: mismatch (-wrote +read)\n%s", d) |
| } |
| } |
| |
| func TestQuestion(t *testing.T) { |
| var buf bytes.Buffer |
| v := Question{ |
| Domain: "some.random.thing.local", |
| Type: 5954, |
| Unicast: true, |
| } |
| v.serialize(&buf) |
| var v2 Question |
| v2.deserialize(buf.Bytes(), &buf) |
| if d := cmp.Diff(v, v2); d != "" { |
| t.Errorf("question (de)serialize: mismatch (-serialize +deserialize)\n%s", d) |
| } |
| } |
| |
| func TestRecord(t *testing.T) { |
| var buf bytes.Buffer |
| v := Record{ |
| Domain: "some.random.thing", |
| Type: 1234, |
| Class: 8765, |
| Flush: true, |
| TTL: 18656, |
| Data: []byte{45, 145, 253, 167, 34, 74}, |
| } |
| v.serialize(&buf) |
| var v2 Record |
| v2.deserialize(buf.Bytes(), &buf) |
| if d := cmp.Diff(v, v2); d != "" { |
| t.Errorf("record (de)serialize: mismatch (-serialize +deserialize)\n%s", d) |
| } |
| } |
| |
| func TestIpToDnsRecordType(t *testing.T) { |
| ip1 := "224.0.0.251" |
| if addrType := IpToDnsRecordType(net.ParseIP(ip1)); addrType != A { |
| t.Errorf("IpToDnsRecordType(%s) mismatch %v, wanted %v", ip1, addrType, A) |
| } |
| ip2 := "ff2e::fb" |
| if addrType := IpToDnsRecordType(net.ParseIP(ip2)); addrType != AAAA { |
| t.Errorf("IpToDnsRecordType(%s) mismatch %v, wanted %v", ip2, addrType, AAAA) |
| } |
| } |
| |
| func TestSetAddress(t *testing.T) { |
| m := NewMDNS() |
| m.EnableIPv4() |
| got := m.conn4.dst.IP |
| // Should send to the default address. |
| want := net.ParseIP("224.0.0.251") |
| if d := cmp.Diff(want, got); d != "" { |
| t.Errorf("IP mismatch (-want +got)\n%s", d) |
| } |
| |
| if err := m.SetAddress("11.22.33.44"); err != nil { |
| t.Errorf("SetAddress() returned error: %s", err) |
| } else { |
| got = m.conn4.dst.IP |
| // Should send to the given custom address. |
| want = net.ParseIP("11.22.33.44") |
| if d := cmp.Diff(want, got); d != "" { |
| t.Errorf("IP mismatch (-want +got)\n%s", d) |
| } |
| } |
| |
| m = NewMDNS() |
| m.EnableIPv6() |
| got = m.conn6.dst.IP |
| want = net.ParseIP("ff02::fb") |
| if d := cmp.Diff(want, got); d != "" { |
| t.Errorf("IP mismatch (-want +got)\n%s", d) |
| } |
| |
| if err := m.SetAddress("11:22::33:44"); err != nil { |
| t.Errorf("SetAddress() returned error: %s", err) |
| } else { |
| got = m.conn6.dst.IP |
| // Should send to the given custom address. |
| want = net.ParseIP("11:22::33:44") |
| if d := cmp.Diff(want, got); d != "" { |
| t.Errorf("IP mismatch (-want +got)\n%s", d) |
| } |
| } |
| } |
