on "darwin", "dragonfly", "freebsd", "netbsd" the ip total length and frag off needs to be host byte order

[nhooyr]

https://developer.apple.com/library/mac/documentation/Darwin/Reference/ManPages/man4/ip.4.html

go down to raw ip sockets and the line "Note that the ip_off and ip_len fields are in host byte order."

This doesn't happen in gopacket and I was very confused for a while.

In the ipv4 package it is done there

https://github.com/golang/net/blob/master/ipv4/header.go (line 75)

Its trivial to fix in your own code but it would be nice to have it in gopacket.

[kkirsche]

Is this what is causing "Message too long" error when using gopacket on darwin / OS X?

[nhooyr]

@kkirsche likely, but I'd need to see code to really determine.

[kkirsche]

@nhooyr thanks for your response. A quick example would be:

package main

import (
    "github.com/google/gopacket"
    "github.com/google/gopacket/layers"
    "github.com/google/gopacket/pcap"
    "log"
    "net"
    "time"
)

var (
    device       string = "en0"
    snapshot_len int32  = 1024
    promiscuous  bool   = false
    err          error
    timeout      time.Duration = 30 * time.Second
    handle       *pcap.Handle
    buffer       gopacket.SerializeBuffer
    options      gopacket.SerializeOptions
)

func main() {
    // Open device
    handle, err = pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
    if err != nil {
        log.Fatal(err)
    }
    defer handle.Close()

    // Send raw bytes over wire
    rawBytes := []byte{10, 20, 30}
    err = handle.WritePacketData(rawBytes)
    if err != nil {
        log.Fatal(err)
    }

    buffer = gopacket.NewSerializeBuffer()

    ipLayer := &layers.IPv4{
        SrcIP: net.IP{127, 0, 0, 1},
        DstIP: net.IP{8, 8, 8, 8},
    }
    ethernetLayer := &layers.Ethernet{
        SrcMAC: net.HardwareAddr{0xFF, 0xAA, 0xFA, 0xAA, 0xFF, 0xAA, 0xFA, 0xAA},
        DstMAC: net.HardwareAddr{0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD},
    }
    tcpLayer := &layers.TCP{
        SrcPort: layers.TCPPort(4321),
        DstPort: layers.TCPPort(80),
    }
    // And create the packet with the layers
    buffer = gopacket.NewSerializeBuffer()
    gopacket.SerializeLayers(buffer, options,
        ethernetLayer,
        ipLayer,
        tcpLayer,
        gopacket.Payload(rawBytes),
    )
    outgoingPacket = buffer.Bytes()

       // Send our packet
    err = handle.WritePacketData(outgoingPacket)
    if err != nil {
        log.Fatal(err)
    }
}

[gconnell]

Set options.FixLengths

On Wed, Dec 2, 2015 at 11:33 AM, Kevin Kirsche notifications@github.com
wrote:

@nhooyr https://github.com/nhooyr thanks for your response. A quick
example would be:

package main
import (
"github.com/google/gopacket"
"github.com/google/gopacket/layers"
"github.com/google/gopacket/pcap"
"log"
"net"
"time"
)
var (
device string = "en0"
snapshot_len int32 = 1024
promiscuous bool = false
err error
timeout time.Duration = 30 * time.Second
handle *pcap.Handle
buffer gopacket.SerializeBuffer
options gopacket.SerializeOptions
)
func main() {
// Open device
handle, err = pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
if err != nil {
log.Fatal(err)
}
defer handle.Close()

// Send raw bytes over wire
rawBytes := []byte{10, 20, 30}
err = handle.WritePacketData(rawBytes)
if err != nil {
    log.Fatal(err)
}

buffer = gopacket.NewSerializeBuffer()
outgoingPacket := buffer.Bytes()

// This time lets fill out some information
ipLayer := &layers.IPv4{
    SrcIP: net.IP{127, 0, 0, 1},
    DstIP: net.IP{8, 8, 8, 8},
}
ethernetLayer := &layers.Ethernet{
    SrcMAC: net.HardwareAddr{0xFF, 0xAA, 0xFA, 0xAA, 0xFF, 0xAA, 0xFA, 0xAA},
    DstMAC: net.HardwareAddr{0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD, 0xBD},
}
tcpLayer := &layers.TCP{
    SrcPort: layers.TCPPort(4321),
    DstPort: layers.TCPPort(80),
}
// And create the packet with the layers
buffer = gopacket.NewSerializeBuffer()
gopacket.SerializeLayers(buffer, options,
    ethernetLayer,
    ipLayer,
    tcpLayer,
    gopacket.Payload(rawBytes),
)
outgoingPacket = buffer.Bytes()

   // Send our packet
err = handle.WritePacketData(outgoingPacket)
if err != nil {
    log.Fatal(err)
}

}

—
Reply to this email directly or view it on GitHub
#150 (comment).

[nhooyr]

Closing as per @gconnell's comment.

[troublemaker]

hey, @nhooyr why this was closed ? seems the issue persists on Darwin when using RAW sockets. Thanks !