Golang Buffer.Init方法代碼示例

// Pack packets into their binary form. This will stack the packets before
// encoding them (see the Compose() method) and also calculate the checksums.
func Pack(pkts ...packet.Packet) ([]byte, error) {
	var buf packet.Buffer

	base_pkt, err := Compose(pkts...)
	if err != nil {
		return nil, err
	}

	tot_len := int(base_pkt.GetLength())

	buf.Init(make([]byte, tot_len))

	for i := len(pkts) - 1; i >= 0; i-- {
		cur_pkt := pkts[i]
		cur_len := int(cur_pkt.GetLength())

		buf.SetOffset(tot_len - cur_len)
		buf.NewLayer()

		err := cur_pkt.Pack(&buf)
		if err != nil {
			return nil, err
		}
	}

	buf.SetOffset(0)

	return buf.Bytes(), nil
}

// Unpack the given byte slice into the packet list supplied. Note that this
// will not check whether the packet types provided match the raw data. If the
// packet types to be decoded are unknown, UnpackAll() should be used instead.
//
// Note that unpacking is done without copying the input slice, which means that
// if the slice is modifed, it may affect the packets that where unpacked from
// it. If you can't guarantee that the data slice won't change, you'll need to
// copy it and pass the copy to Unpack().
func Unpack(buf []byte, pkts ...packet.Packet) (packet.Packet, error) {
	var b packet.Buffer
	b.Init(buf)

	prev_pkt := packet.Packet(nil)

	for _, p := range pkts {
		if b.Len() <= 0 {
			break
		}

		b.NewLayer()

		err := p.Unpack(&b)
		if err != nil {
			return nil, err
		}

		if prev_pkt != nil {
			prev_pkt.SetPayload(p)
		}

		if p.GuessPayloadType() == packet.None {
			break
		}

		prev_pkt = p
	}

	return pkts[0], nil
}

func TestUnpackOptions(t *testing.T) {
	var p tcp.Packet

	var b packet.Buffer
	b.Init(test_options)

	err := p.Unpack(&b)
	if err != nil {
		t.Fatalf("Error unpacking: %s", err)
	}

	if len(p.Options) != 4 {
		t.Fatalf("Options number mismatch: %d", len(p.Options))
	}

	if p.Options[0].Type != tcp.MSS {
		t.Fatalf("Option MSS mismatch: %x", p.Options[0].Data)
	}

	if p.Options[1].Type != tcp.SAckOk {
		t.Fatalf("Option SAckOk mismatch: %x", p.Options[1].Data)
	}

	if p.Options[2].Type != tcp.Timestamp {
		t.Fatalf("Option Timestamp mismatch: %x", p.Options[2].Data)
	}

	if p.Options[3].Type != tcp.WindowScale {
		t.Fatalf("Option WindowScale mismatch: %x", p.Options[3].Data)
	}
}

func TestPackWithIPv4(t *testing.T) {
	var b packet.Buffer
	b.Init(make([]byte, len(test_with_ipv4)))

	ip4 := ipv4.Make()
	ip4.SrcAddr = net.ParseIP(ipsrc_str)
	ip4.DstAddr = net.ParseIP(ipdst_str)

	udp := &udp.Packet{
		SrcPort: 52134,
		DstPort: 80,
		Length:  18,
	}

	ip4.SetPayload(udp)

	err := udp.Pack(&b)
	if err != nil {
		t.Fatalf("Error packing: %s", err)
	}

	if !bytes.Equal(test_with_ipv4, b.Buffer()) {
		t.Fatalf("Raw packet mismatch: %x", b.Buffer())
	}
}

func BenchmarkUnpack(bn *testing.B) {
	var p eth.Packet
	var b packet.Buffer

	for n := 0; n < bn.N; n++ {
		b.Init(test_simple)
		p.Unpack(&b)
	}
}

func BenchmarkPack(bn *testing.B) {
	var b packet.Buffer
	b.Init(make([]byte, len(test_simple)))

	p := MakeTestSimple()

	for n := 0; n < bn.N; n++ {
		p.Pack(&b)
	}
}

func TestPackOptions(t *testing.T) {
	var b packet.Buffer
	b.Init(make([]byte, len(test_options)))

	p := MakeTestSimple()

	p.DataOff = 10

	p.Options = append(p.Options,
		tcp.Option{
			Type: tcp.MSS,
			Len:  4,
			Data: []byte{0x05, 0x78},
		},
	)

	p.Options = append(p.Options,
		tcp.Option{
			Type: tcp.SAckOk,
			Len:  2,
		},
	)

	p.Options = append(p.Options,
		tcp.Option{
			Type: tcp.Timestamp,
			Len:  10,
			Data: []byte{0x61, 0x25, 0xE5, 0xB2, 0x00, 0x13, 0x15, 0x66},
		},
	)

	p.Options = append(p.Options,
		tcp.Option{
			Type: tcp.WindowScale,
			Len:  3,
			Data: []byte{0x0A},
		},
	)

	p.Options = append(p.Options,
		tcp.Option{
			Type: tcp.End,
		},
	)

	err := p.Pack(&b)
	if err != nil {
		t.Fatalf("Error packing: %s", err)
	}

	if !bytes.Equal(test_options, b.Buffer()) {
		t.Fatalf("Raw packet mismatch: %x", b.Buffer())
	}
}

func TestPack(t *testing.T) {
	var b packet.Buffer
	b.Init(make([]byte, len(test_simple)))

	p := MakeTestSimple()

	err := p.Pack(&b)
	if err != nil {
		t.Fatalf("Error packing: %s", err)
	}

	if !bytes.Equal(test_simple, b.Buffer()) {
		t.Fatalf("Raw packet mismatch: %x", b.Buffer())
	}
}

func TestUnpack(t *testing.T) {
	var p eth.Packet

	cmp := MakeTestSimple()

	var b packet.Buffer
	b.Init(test_simple)

	err := p.Unpack(&b)
	if err != nil {
		t.Fatalf("Error unpacking: %s", err)
	}

	if !p.Equals(cmp) {
		t.Fatalf("Packet mismatch:\n%s\n%s", &p, cmp)
	}
}

func TestUnpackWithIPv6(t *testing.T) {
	var p icmpv6.Packet

	cmp := MakeTestSimple()
	cmp.Checksum = 0x5bed

	var b packet.Buffer
	b.Init(test_with_ipv6)

	err := p.Unpack(&b)
	if err != nil {
		t.Fatalf("Error unpacking: %s", err)
	}

	if !p.Equals(cmp) {
		t.Fatalf("Packet mismatch:\n%s\n%s", &p, cmp)
	}
}

func TestPackWithIPv6(t *testing.T) {
	var b packet.Buffer
	b.Init(make([]byte, len(test_with_ipv6)))

	ip6 := ipv6.Make()
	ip6.SrcAddr = net.ParseIP(ipsrc_str)
	ip6.DstAddr = net.ParseIP(ipdst_str)

	icmp6 := MakeTestSimple()

	ip6.SetPayload(icmp6)

	err := icmp6.Pack(&b)
	if err != nil {
		t.Fatalf("Error packing: %s", err)
	}

	if !bytes.Equal(test_with_ipv6, b.Buffer()) {
		t.Fatalf("Raw packet mismatch: %x", b.Buffer())
	}
}

// Recursively unpack the given byte slice into a packet. The link_type argument
// must specify the type of the first layer in the input data, successive layers
// will be detected automatically.
//
// Note that unpacking is done without copying the input slice, which means that
// if the slice is modifed, it may affect the packets that where unpacked from
// it. If you can't guarantee that the data slice won't change, you'll need to
// copy it and pass the copy to UnpackAll().
func UnpackAll(buf []byte, link_type packet.Type) (packet.Packet, error) {
	var b packet.Buffer
	b.Init(buf)

	first_pkt := packet.Packet(nil)
	prev_pkt := packet.Packet(nil)

	for link_type != packet.None {
		var p packet.Packet

		if b.Len() <= 0 {
			break
		}

		switch link_type {
		case packet.ARP:
			p = &arp.Packet{}
		case packet.Eth:
			p = &eth.Packet{}
		case packet.ICMPv4:
			p = &icmpv4.Packet{}
		case packet.ICMPv6:
			p = &icmpv6.Packet{}
		case packet.IPv4:
			p = &ipv4.Packet{}
		case packet.IPv6:
			p = &ipv6.Packet{}
		case packet.LLC:
			p = &llc.Packet{}
		case packet.RadioTap:
			p = &radiotap.Packet{}
		case packet.SLL:
			p = &sll.Packet{}
		case packet.SNAP:
			p = &snap.Packet{}
		case packet.TCP:
			p = &tcp.Packet{}
		case packet.UDP:
			p = &udp.Packet{}
		case packet.VLAN:
			p = &vlan.Packet{}
		default:
			p = &raw.Packet{}
		}

		if p == nil {
			break
		}

		b.NewLayer()

		err := p.Unpack(&b)
		if err != nil {
			return nil, err
		}

		if prev_pkt != nil {
			prev_pkt.SetPayload(p)
		} else {
			first_pkt = p
		}

		prev_pkt = p
		link_type = p.GuessPayloadType()
	}

	return first_pkt, nil
}