func TestPacketDot11CtrlAck(t *testing.T) { p := gopacket.NewPacket(testPacketDot11CtrlAck, LinkTypeIEEE80211Radio, gopacket.Default) if p.ErrorLayer() != nil { t.Error("Failed to decode packet:", p.ErrorLayer().Error()) } checkLayers(p, []gopacket.LayerType{LayerTypeRadioTap, LayerTypeDot11}, t) if got, ok := p.Layer(LayerTypeDot11).(*Dot11); ok { if !got.ChecksumValid() { t.Errorf("Dot11 packet processing failed:\nchecksum failed. got :\n%#v\n\n", got) } } if got, ok := p.Layer(LayerTypeDot11).(*Dot11); ok { want := &Dot11{ BaseLayer: BaseLayer{ Contents: []uint8{0xd4, 0x0, 0x0, 0x0, 0x0, 0x19, 0xe3, 0xd3, 0x53, 0x52}, Payload: []uint8{}, }, Type: Dot11TypeCtrlAck, Proto: 0x0, Flags: 0x0, DurationID: 0x0, Address1: net.HardwareAddr{0x0, 0x19, 0xe3, 0xd3, 0x53, 0x52}, Address2: net.HardwareAddr(nil), Address3: net.HardwareAddr(nil), Address4: net.HardwareAddr(nil), Checksum: 0x8776e946, } if !reflect.DeepEqual(got, want) { t.Errorf("Dot11 packet processing failed:\ngot :\n%#v\n\nwant :\n%#v\n\n", got, want) } } }
func NewEthernet() *Ethernet { eth := new(Ethernet) eth.HWDst = net.HardwareAddr(make([]byte, 6)) eth.HWSrc = net.HardwareAddr(make([]byte, 6)) eth.VLANID = *NewVLAN() eth.Ethertype = 0x800 return eth }
func (vb *VXLANBackend) handleInitialSubnetEvents(batch []subnet.Event) error { log.Infof("Handling initial subnet events") fdbTable, err := vb.dev.GetL2List() if err != nil { return fmt.Errorf("Error fetching L2 table: %v", err) } for _, fdbEntry := range fdbTable { log.Infof("fdb already populated with: %s %s ", fdbEntry.IP, fdbEntry.HardwareAddr) } evtMarker := make([]bool, len(batch)) leaseAttrsList := make([]vxlanLeaseAttrs, len(batch)) fdbEntryMarker := make([]bool, len(fdbTable)) for i, evt := range batch { if evt.Lease.Attrs.BackendType != "vxlan" { log.Warningf("Ignoring non-vxlan subnet: type=%v", evt.Lease.Attrs.BackendType) evtMarker[i] = true continue } if err := json.Unmarshal(evt.Lease.Attrs.BackendData, &leaseAttrsList[i]); err != nil { log.Error("Error decoding subnet lease JSON: ", err) evtMarker[i] = true continue } for j, fdbEntry := range fdbTable { if evt.Lease.Attrs.PublicIP.ToIP().Equal(fdbEntry.IP) && bytes.Equal([]byte(leaseAttrsList[i].VtepMAC), []byte(fdbEntry.HardwareAddr)) { evtMarker[i] = true fdbEntryMarker[j] = true break } } vb.rts.set(evt.Lease.Subnet, net.HardwareAddr(leaseAttrsList[i].VtepMAC)) } for j, marker := range fdbEntryMarker { if !marker && fdbTable[j].IP != nil { err := vb.dev.DelL2(neigh{IP: ip.FromIP(fdbTable[j].IP), MAC: fdbTable[j].HardwareAddr}) if err != nil { log.Error("Delete L2 failed: ", err) } } } for i, marker := range evtMarker { if !marker { err := vb.dev.AddL2(neigh{IP: batch[i].Lease.Attrs.PublicIP, MAC: net.HardwareAddr(leaseAttrsList[i].VtepMAC)}) if err != nil { log.Error("Add L2 failed: ", err) } } } return nil }
func (vb *VXLANBackend) handleSubnetEvents(batch subnet.EventBatch) { for _, evt := range batch { switch evt.Type { case subnet.SubnetAdded: log.Info("Subnet added: ", evt.Lease.Network) if evt.Lease.Attrs.BackendType != "vxlan" { log.Warningf("Ignoring non-vxlan subnet: type=%v", evt.Lease.Attrs.BackendType) continue } var attrs vxlanLeaseAttrs if err := json.Unmarshal(evt.Lease.Attrs.BackendData, &attrs); err != nil { log.Error("Error decoding subnet lease JSON: ", err) continue } if err := vb.dev.AddL2(neigh{IP: evt.Lease.Attrs.PublicIP, MAC: net.HardwareAddr(attrs.VtepMAC)}); err != nil { log.Error("Error adding L2 entry: ", err) } if err := vb.dev.AddL3(neigh{IP: evt.Lease.Network.IP, MAC: net.HardwareAddr(attrs.VtepMAC)}); err != nil { log.Error("Error adding L3 entry: ", err) } if err := vb.dev.AddRoute(evt.Lease.Network); err != nil { log.Error("Error adding route: ", err) } case subnet.SubnetRemoved: log.Info("Subnet removed: ", evt.Lease.Network) if evt.Lease.Attrs.BackendType != "vxlan" { log.Warningf("Ignoring non-vxlan subnet: type=%v", evt.Lease.Attrs.BackendType) continue } var attrs vxlanLeaseAttrs if err := json.Unmarshal(evt.Lease.Attrs.BackendData, &attrs); err != nil { log.Error("Error decoding subnet lease JSON: ", err) continue } if err := vb.dev.DelRoute(evt.Lease.Network); err != nil { log.Error("Error deleting route: ", err) } if len(attrs.VtepMAC) > 0 { if err := vb.dev.DelL2(neigh{IP: evt.Lease.Attrs.PublicIP, MAC: net.HardwareAddr(attrs.VtepMAC)}); err != nil { log.Error("Error deleting L2 entry: ", err) } if err := vb.dev.DelL3(neigh{IP: evt.Lease.Network.IP, MAC: net.HardwareAddr(attrs.VtepMAC)}); err != nil { log.Error("Error deleting L3 entry: ", err) } } default: log.Error("Internal error: unknown event type: ", int(evt.Type)) } } }
// NewMatch returns a Match whose fields are all wildcarded func NewMatch() openflow.Match { return &Match{ wildcards: newWildcardAll(), srcMAC: net.HardwareAddr([]byte{0, 0, 0, 0, 0, 0}), dstMAC: net.HardwareAddr([]byte{0, 0, 0, 0, 0, 0}), srcIP: net.IPv4zero, dstIP: net.IPv4zero, } }
func (m *Dot11) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { if len(data) < 10 { df.SetTruncated() return fmt.Errorf("Dot11 length %v too short, %v required", len(data), 10) } m.Type = Dot11Type((data[0])&0xFC) >> 2 m.Proto = uint8(data[0]) & 0x0003 m.Flags = Dot11Flags(data[1]) m.DurationID = binary.LittleEndian.Uint16(data[2:4]) m.Address1 = net.HardwareAddr(data[4:10]) offset := 10 mainType := m.Type.MainType() switch mainType { case Dot11TypeCtrl: switch m.Type { case Dot11TypeCtrlRTS, Dot11TypeCtrlPowersavePoll, Dot11TypeCtrlCFEnd, Dot11TypeCtrlCFEndAck: if len(data) < offset+6 { df.SetTruncated() return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+6) } m.Address2 = net.HardwareAddr(data[offset : offset+6]) offset += 6 } case Dot11TypeMgmt, Dot11TypeData: if len(data) < offset+14 { df.SetTruncated() return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+14) } m.Address2 = net.HardwareAddr(data[offset : offset+6]) offset += 6 m.Address3 = net.HardwareAddr(data[offset : offset+6]) offset += 6 m.SequenceNumber = (binary.LittleEndian.Uint16(data[offset:offset+2]) & 0xFFF0) >> 4 m.FragmentNumber = (binary.LittleEndian.Uint16(data[offset:offset+2]) & 0x000F) offset += 2 } if mainType == Dot11TypeData && m.Flags.FromDS() && m.Flags.ToDS() { if len(data) < offset+6 { df.SetTruncated() return fmt.Errorf("Dot11 length %v too short, %v required", len(data), offset+6) } m.Address4 = net.HardwareAddr(data[offset : offset+6]) offset += 6 } m.BaseLayer = BaseLayer{Contents: data[0:offset], Payload: data[offset : len(data)-4]} m.Checksum = binary.LittleEndian.Uint32(data[len(data)-4 : len(data)]) return nil }
func decodeFDDI(data []byte, p gopacket.PacketBuilder) error { f := &FDDI{ FrameControl: FDDIFrameControl(data[0] & 0xF8), Priority: data[0] & 0x07, SrcMAC: net.HardwareAddr(data[1:7]), DstMAC: net.HardwareAddr(data[7:13]), BaseLayer: BaseLayer{data[:13], data[13:]}, } p.SetLinkLayer(f) p.AddLayer(f) return p.NextDecoder(f.FrameControl) }
// http://en.wikipedia.org/wiki/Ethernet_frame#Structure // // - no preamble / SFD / FCS (handle by hardware) // // +---------+---------+------+------------------------------------ // | dest | src | type | payload // +---------+---------+------+------------------------------------ func decodeEthernet(raw []byte) (Impl, decodeFunc, error) { if len(raw) < 14 { return nil, nil, errDecodeFailed } dest := net.HardwareAddr(raw[0:6]) src := net.HardwareAddr(raw[6:12]) type_ := EthernetType(binary.BigEndian.Uint16(raw[12:14])) p := &Ethernet{dest, src, type_, raw} return p, p.Type.Decoder(), nil }
func (p *Packet) Unpack(buf *packet.Buffer) error { p.DstAddr = net.HardwareAddr(buf.Next(6)) p.SrcAddr = net.HardwareAddr(buf.Next(6)) buf.ReadN(&p.Type) if p.Type < 0x0600 { p.Length = uint16(p.Type) p.Type = LLC } return nil }
func (router *Router) handleForwardedPacket(key ForwardPacketKey) FlowOp { if key.DstPeer != router.Ourself.Peer { // it's not for us, we're just relaying it router.PacketLogging.LogForwardPacket("Relaying", key) return router.relay(key) } // At this point, it's either unicast to us, or a broadcast // (because the DstPeer on a forwarded broadcast packet is // always set to the peer being forwarded to) srcMac := net.HardwareAddr(key.SrcMAC[:]) dstMac := net.HardwareAddr(key.DstMAC[:]) switch newSrcMac, conflictPeer := router.Macs.AddForced(srcMac, key.SrcPeer); { case newSrcMac: log.Print("Discovered remote MAC ", srcMac, " at ", key.SrcPeer) case conflictPeer != nil: log.Print("Discovered remote MAC ", srcMac, " at ", key.SrcPeer, " (was at ", conflictPeer, ")") // We need to clear out any flows destined to the MAC // that forward to the old peer. router.Overlay.InvalidateRoutes() } router.PacketLogging.LogForwardPacket("Injecting", key) injectFop := router.Bridge.InjectPacket(key.PacketKey) dstPeer := router.Macs.Lookup(dstMac) if dstPeer == router.Ourself.Peer { return injectFop } router.PacketLogging.LogForwardPacket("Relaying broadcast", key) relayFop := router.relayBroadcast(key.SrcPeer, key.PacketKey) switch { case injectFop == nil: return relayFop case relayFop == nil: return injectFop default: mfop := NewMultiFlowOp(false) mfop.Add(injectFop) mfop.Add(relayFop) return mfop } }
func TestRequestPacket(t *testing.T) { var tests = []struct { description string mt MessageType chAddr net.HardwareAddr cIAddr net.IP xId []byte broadcast bool options []Option }{ { description: "discover request", mt: Discover, chAddr: net.HardwareAddr([]byte("01:23:45:67:89:ab")), cIAddr: net.IP([]byte{192, 168, 1, 1}), xId: []byte{0, 1, 2, 3}, broadcast: true, options: nil, }, { description: "request request", mt: Request, chAddr: net.HardwareAddr([]byte("de:ad:be:ef:de:ad")), xId: []byte{4, 5, 6, 7}, broadcast: false, options: oneOptionSlice, }, { description: "decline request", mt: Decline, chAddr: net.HardwareAddr([]byte("ff:ff:ff:ff:ff:ff")), xId: []byte{8, 9, 10, 11}, broadcast: true, options: twoOptionsSlice, }, } for i, tt := range tests { // Compare our basic test implementation's packet against the library's // implementation want := newRequestPacket(tt.mt, tt.chAddr, tt.cIAddr, tt.xId, tt.broadcast, tt.options) got := RequestPacket(tt.mt, tt.chAddr, tt.cIAddr, tt.xId, tt.broadcast, tt.options) if !bytes.Equal(want, got) { t.Fatalf("%02d: RequestPacket(), test %q, unexpected result: %v != %v", i, tt.description, want, got) } } }
// JSON encoder for MAC addresses func (i HardwareAddr) MarshalJSON() ([]byte, error) { buf := new(bytes.Buffer) buf.WriteByte('"') buf.WriteString(net.HardwareAddr(i).String()) buf.WriteByte('"') return buf.Bytes(), nil }
func (r *BaseAction) DstMAC() (ok bool, mac net.HardwareAddr) { if r.dstMAC == nil { return false, net.HardwareAddr([]byte{0, 0, 0, 0, 0, 0}) } return true, *r.dstMAC }
func newInterfaces(ctx *C.struct_ibv_context) { var deviceAttr C.struct_ibv_device_attr errno := C.ibv_query_device(ctx, &deviceAttr) if errno != 0 { return } pd := C.ibv_alloc_pd(ctx) if pd == nil { panic(newError("ibv_alloc_pd", -1)) } pds[pd] = true for port := C.uint8_t(1); port <= deviceAttr.phys_port_cnt; port++ { var portAttr C.struct_ibv_port_attr errno := C.ibv_query_port(ctx, port, &portAttr) if errno != 0 { continue } var gid C.union_ibv_gid errno = C.ibv_query_gid(ctx, port, 0, &gid) if errno != 0 { continue } // last 8 bytes of GID is the GUID guid := net.HardwareAddr(gid[8:]) iface := &Interface{ctx, pd, uint8(port), &deviceAttr, guid} interfaces = append(interfaces, iface) guidToInterface[string([]byte(guid))] = iface } }
func (m *Dot11MgmtReassociationReq) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { m.CapabilityInfo = binary.LittleEndian.Uint16(data[0:2]) m.ListenInterval = binary.LittleEndian.Uint16(data[2:4]) m.CurrentApAddress = net.HardwareAddr(data[4:10]) m.Payload = data[10:] return m.Dot11Mgmt.DecodeFromBytes(data, df) }
// readARP watches a handle for incoming ARP responses we might care about, and prints them. // // readARP loops until 'stop' is closed. func readARP(handle *pcap.Handle, iface *net.Interface, stop chan struct{}) { src := gopacket.NewPacketSource(handle, layers.LayerTypeEthernet) in := src.Packets() for { var packet gopacket.Packet select { case <-stop: return case packet = <-in: arpLayer := packet.Layer(layers.LayerTypeARP) if arpLayer == nil { continue } arp := arpLayer.(*layers.ARP) if arp.Operation != layers.ARPReply || bytes.Equal([]byte(iface.HardwareAddr), arp.SourceHwAddress) { // This is a packet I sent. continue } // Note: we might get some packets here that aren't responses to ones we've sent, // if for example someone else sends US an ARP request. Doesn't much matter, though... // all information is good information :) log.Printf("IP %v is at %v", net.IP(arp.SourceProtAddress), net.HardwareAddr(arp.SourceHwAddress)) } } }
func (p Packet) CHAddr() net.HardwareAddr { hLen := p.HLen() if hLen > 16 { // Prevent chaddr exceeding p boundary hLen = 16 } return net.HardwareAddr(p[28 : 28+hLen]) // max endPos 44 }
func NeighDeserialize(m []byte) (*Neigh, error) { msg := deserializeNdmsg(m) neigh := Neigh{ LinkIndex: int(msg.Index), Family: int(msg.Family), State: int(msg.State), Type: int(msg.Type), Flags: int(msg.Flags), } attrs, err := nl.ParseRouteAttr(m[msg.Len():]) if err != nil { return nil, err } for _, attr := range attrs { switch attr.Attr.Type { case NDA_DST: neigh.IP = net.IP(attr.Value) case NDA_LLADDR: neigh.HardwareAddr = net.HardwareAddr(attr.Value) } } return &neigh, nil }
func spammer() { hostname := "SpamSpamSpam SpamSpamSpamSpamSpamSpamSpamSpamSpamSpamSpamSpam" broadcastConn := openUDPConnOrDie(spamerPort) defer broadcastConn.Close() addr, err := net.ResolveUDPAddr("udp4", net.IPv4bcast.String()+":"+strconv.Itoa(receiverPort)) if err != nil { log.Fatalf("Cannot resolve broadcast receiver address: %s", err) } hardwareAddr := make([]byte, 6) broadcastCommonData := append(hardwareAddr, byte(len(hostname))) broadcastCommonData = append(broadcastCommonData, ([]byte)(hostname)...) timestampBuff := make([]byte, 4) //32!!!! ticker := time.NewTicker(spamInterval) for _ = range ticker.C { unixTimestamp := Timestamp(time.Now().Unix()) endian.PutUint32(timestampBuff, uint32(unixTimestamp)) endian.PutUint32(broadcastCommonData, rand.Uint32()) endian.PutUint32(broadcastCommonData[2:], rand.Uint32()) copy(broadcastCommonData[7:], []byte(net.HardwareAddr(broadcastCommonData[0:6]).String())) _, err = broadcastConn.WriteTo(append(broadcastCommonData, timestampBuff...), addr) if err != nil { log.Fatalf("Unable to broadcast SPAM: %s", err) } } }
func NewARP(opt int) (*ARP, error) { if opt != Type_Request && opt != Type_Reply { return nil, errors.New("Invalid ARP Operation.") } a := new(ARP) a.HWType = 1 a.ProtoType = 0x800 a.HWLength = 6 a.ProtoLength = 4 a.Operation = uint16(opt) a.HWSrc = net.HardwareAddr(make([]byte, 6)) a.IPSrc = net.IP(make([]byte, 4)) a.HWDst = net.HardwareAddr(make([]byte, 6)) a.IPDst = net.IP(make([]byte, 4)) return a, nil }
// RandomMac returns a random mac address. func RandomMac() (net.HardwareAddr, error) { addr := make([]byte, 6) if _, err := rand.Read(addr[1:]); err != nil { return nil, err } return net.HardwareAddr(addr), nil }
func (p *Packet) Unpack(buf *packet.Buffer) error { buf.ReadN(&p.HWType) buf.ReadN(&p.ProtoType) buf.ReadN(&p.HWAddrLen) buf.ReadN(&p.ProtoAddrLen) buf.ReadN(&p.Operation) p.HWSrcAddr = net.HardwareAddr(buf.Next(int(p.HWAddrLen))) p.ProtoSrcAddr = net.IP(buf.Next(int(p.ProtoAddrLen))) p.HWDstAddr = net.HardwareAddr(buf.Next(int(p.HWAddrLen))) p.ProtoDstAddr = net.IP(buf.Next(int(p.ProtoAddrLen))) return nil }
func decodePBB(data []byte, p gopacket.PacketBuilder) error { if data[0]&0x3 != 0 { return errors.New("I-TAG TCI Res2 must be zero") } pbb := &PBB{ Priority: data[0] >> 5, DropEligible: data[0]&0x10 != 0, UseCustomerAddress: data[0]&0x08 != 0, ServiceIdentifier: binary.BigEndian.Uint32(append(make([]byte, 1), data[1:4]...)), DstMAC: net.HardwareAddr(data[4:10]), SrcMAC: net.HardwareAddr(data[10:16]), Type: layers.EthernetType(binary.BigEndian.Uint16(data[16:18])), BaseLayer: layers.BaseLayer{Contents: data[:18], Payload: data[18:]}, } p.AddLayer(pbb) return p.NextDecoder(pbb.Type) }
// Address returns the address of the remote peripheral. func (a *Advertisement) Address() ble.Addr { b := a.e.Address(a.i) addr := net.HardwareAddr([]byte{b[5], b[4], b[3], b[2], b[1], b[0]}) if a.e.AddressType(a.i) == 1 { return RandomAddress{addr} } return addr }
func TestFilename(t *testing.T) { for _, tt := range []struct { i logicalInterface f string }{ {logicalInterface{name: "iface", configDepth: 0}, "00-iface"}, {logicalInterface{name: "iface", configDepth: 9}, "09-iface"}, {logicalInterface{name: "iface", configDepth: 10}, "0a-iface"}, {logicalInterface{name: "iface", configDepth: 53}, "35-iface"}, {logicalInterface{hwaddr: net.HardwareAddr([]byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab}), configDepth: 1}, "01-01:23:45:67:89:ab"}, {logicalInterface{name: "iface", hwaddr: net.HardwareAddr([]byte{0x01, 0x23, 0x45, 0x67, 0x89, 0xab}), configDepth: 1}, "01-iface"}, } { if tt.i.Filename() != tt.f { t.Fatalf("bad filename (%q): got %q, want %q", tt.i, tt.i.Filename(), tt.f) } } }
// TestNewDUIDLLT verifies that NewDUIDLLT generates a proper DUIDLLT or error // from an input hardware type, time value, and hardware address. func TestNewDUIDLLT(t *testing.T) { var tests = []struct { desc string hardwareType uint16 time time.Time hardwareAddr net.HardwareAddr duid *DUIDLLT err error }{ { desc: "date too early", time: duidLLTTime.Add(-1 * time.Minute), err: ErrInvalidDUIDLLTTime, }, { desc: "OK", hardwareType: 1, time: duidLLTTime.Add(1 * time.Minute), hardwareAddr: net.HardwareAddr([]byte{0, 1, 0, 1, 0, 1}), duid: &DUIDLLT{ Type: DUIDTypeLLT, HardwareType: 1, Time: duidLLTTime.Add(1 * time.Minute).Sub(duidLLTTime), HardwareAddr: net.HardwareAddr([]byte{0, 1, 0, 1, 0, 1}), }, }, } for i, tt := range tests { duid, err := NewDUIDLLT(tt.hardwareType, tt.time, tt.hardwareAddr) if err != nil { if want, got := tt.err, err; want != got { t.Fatalf("[%02d] test %q, unexpected error: %v != %v", i, tt.desc, want, got) } continue } if want, got := tt.duid, duid; !reflect.DeepEqual(want, got) { t.Fatalf("[%02d] test %q, unexpected DUIDLLT:\n- want %v\n- got %v", i, tt.desc, want, got) } } }
func (router *NetworkRouter) handleCapturedPacket(key PacketKey) FlowOp { router.PacketLogging.LogPacket("Captured", key) srcMac := net.HardwareAddr(key.SrcMAC[:]) switch newSrcMac, conflictPeer := router.Macs.Add(srcMac, router.Ourself.Peer); { case newSrcMac: log.Println("Discovered local MAC", srcMac) case conflictPeer != nil: // The MAC cache has an entry for the source MAC // associated with another peer. This probably means // we are seeing a frame we injected ourself. That // shouldn't happen, but discard it just in case. log.Error("Captured frame from MAC (", srcMac, ") associated with another peer ", conflictPeer) return DiscardingFlowOp{} } // Discard STP broadcasts if key.DstMAC == [...]byte{0x01, 0x80, 0xC2, 0x00, 0x00, 0x00} { return DiscardingFlowOp{} } dstMac := net.HardwareAddr(key.DstMAC[:]) switch dstPeer := router.Macs.Lookup(dstMac); dstPeer { case router.Ourself.Peer: // The packet is destined for a local MAC. The bridge // won't normally send us such packets, and if it does // it's likely to be broadcasting the packet to all // ports. So if it happens, just drop the packet to // avoid warnings if we try to forward it. return DiscardingFlowOp{} case nil: // If we don't know which peer corresponds to the dest // MAC, broadcast it. router.PacketLogging.LogPacket("Broadcasting", key) return router.relayBroadcast(router.Ourself.Peer, key) default: router.PacketLogging.LogPacket("Forwarding", key) return router.relay(ForwardPacketKey{ PacketKey: key, SrcPeer: router.Ourself.Peer, DstPeer: dstPeer}) } }
// Generate a MAC address. func GenerateMAC() (net.HardwareAddr, error) { buf := make([]byte, 6) _, err := rand.Read(buf) if err != nil { return nil, err } buf[0] &= 0xFE // Unicast buf[0] |= 0x02 // Locally administered return net.HardwareAddr(buf), nil }
func (vb *VXLANBackend) handleSubnetEvents(batch []subnet.Event) { for _, evt := range batch { switch evt.Type { case subnet.EventAdded: log.Info("Subnet added: ", evt.Lease.Subnet) if evt.Lease.Attrs.BackendType != "vxlan" { log.Warningf("Ignoring non-vxlan subnet: type=%v", evt.Lease.Attrs.BackendType) continue } var attrs vxlanLeaseAttrs if err := json.Unmarshal(evt.Lease.Attrs.BackendData, &attrs); err != nil { log.Error("Error decoding subnet lease JSON: ", err) continue } vb.rts.set(evt.Lease.Subnet, net.HardwareAddr(attrs.VtepMAC)) vb.dev.AddL2(neigh{IP: evt.Lease.Attrs.PublicIP, MAC: net.HardwareAddr(attrs.VtepMAC)}) case subnet.EventRemoved: log.Info("Subnet removed: ", evt.Lease.Subnet) if evt.Lease.Attrs.BackendType != "vxlan" { log.Warningf("Ignoring non-vxlan subnet: type=%v", evt.Lease.Attrs.BackendType) continue } var attrs vxlanLeaseAttrs if err := json.Unmarshal(evt.Lease.Attrs.BackendData, &attrs); err != nil { log.Error("Error decoding subnet lease JSON: ", err) continue } if len(attrs.VtepMAC) > 0 { vb.dev.DelL2(neigh{IP: evt.Lease.Attrs.PublicIP, MAC: net.HardwareAddr(attrs.VtepMAC)}) } vb.rts.remove(evt.Lease.Subnet) default: log.Error("Internal error: unknown event type: ", int(evt.Type)) } } }
func (m *Dot11) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error { m.Type = Dot11Type((data[0])&0xFC) >> 2 m.Proto = uint8(data[0]) & 0x0003 m.Flags = Dot11Flags(data[1]) m.DurationID = binary.LittleEndian.Uint16(data[2:4]) m.Address1 = net.HardwareAddr(data[4:10]) offset := 10 mainType := m.Type.MainType() switch mainType { case Dot11TypeCtrl: switch m.Type { case Dot11TypeCtrlRTS, Dot11TypeCtrlPowersavePoll, Dot11TypeCtrlCFEnd, Dot11TypeCtrlCFEndAck: m.Address2 = net.HardwareAddr(data[offset : offset+6]) offset += 6 } case Dot11TypeMgmt, Dot11TypeData: m.Address2 = net.HardwareAddr(data[offset : offset+6]) offset += 6 m.Address3 = net.HardwareAddr(data[offset : offset+6]) offset += 6 m.SequenceNumber = (binary.LittleEndian.Uint16(data[offset:offset+2]) & 0xFFC0) >> 6 m.FragmentNumber = (binary.LittleEndian.Uint16(data[offset:offset+2]) & 0x003F) offset += 2 } if mainType == Dot11TypeData && m.Flags.FromDS() && m.Flags.ToDS() { m.Address4 = net.HardwareAddr(data[offset : offset+6]) offset += 6 } if mainType == Dot11TypeData { m.BaseLayer = BaseLayer{Contents: data[0:offset], Payload: data[offset:len(data)]} } else { m.BaseLayer = BaseLayer{Contents: data[0:offset], Payload: data[offset : len(data)-4]} m.Checksum = binary.LittleEndian.Uint32(data[len(data)-4 : len(data)]) } return nil }