// Create a layer type and give it a name and a decoder to use.
var LayerTypeHTTP2 = gopacket.RegisterLayerType(12345, gopacket.LayerTypeMetadata{Name: "HTTP2", Decoder: gopacket.DecodeFunc(decodeHTTP2)})

type HTTP2 struct {
    layers.BaseLayer

    frames []http2.Frame
}

// Implement layer's metadata
func (h HTTP2) LayerType() gopacket.LayerType      { return LayerTypeHTTP2 }
func (h *HTTP2) Payload() []byte                   { return nil }
func (h *HTTP2) CanDecode() gopacket.LayerClass    { return LayerTypeHTTP2 }
func (h *HTTP2) NextLayerType() gopacket.LayerType { return gopacket.LayerTypeZero }

// Implement the decoder function to be used
func decodeHTTP2(data []byte, p gopacket.PacketBuilder) error {
    h := &HTTP2{}
    err := h.DecodeFromBytes(data, p)
    if err != nil {
        return err
    }
    p.AddLayer(h)
    p.SetApplicationLayer(h)
    return nil
}

func (h *HTTP2) Frames() []http2.Frame {
    return h.frames
}

func (h *HTTP2) DecodeFromBytes(data []byte, df gopacket.DecodeFeedback) error {
    var frames []http2.Frame
    frameHeaderLength := uint32(9)
    payloadLength := len(data)

    payloadIdx := 0
    for payloadIdx < payloadLength {
        if payloadIdx+int(frameHeaderLength) > payloadLength {
            return fmt.Errorf("Payload length couldn't contain Frame Headers")
        }

        framePayloadLength := (uint32(data[payloadIdx+0])<<16 | uint32(data[payloadIdx+1])<<8 | uint32(data[payloadIdx+2]))
        frameLength := int(frameHeaderLength + framePayloadLength)

        rBit := data[payloadIdx+5] >> 7

        if rBit != 0 {
            return fmt.Errorf("R bit is not unset")
        }

        if payloadIdx+frameLength > payloadLength {
            return fmt.Errorf("Payload length couldn't contain Payload with the length mentioned in Frame Header")
        }

        var framerOutput bytes.Buffer
        r := bytes.NewReader(data[payloadIdx : payloadIdx+frameLength])
        framer := http2.NewFramer(&framerOutput, r)

        frame, err := framer.ReadFrame()
        if err != nil {
            return err
        }
        frames = append(frames, frame)

        payloadIdx += int(frameLength)
    }

    if payloadIdx != payloadLength {
        return fmt.Errorf("Payload length is not equal with the Frame length mentioned in Frame Header")
    }

    h.BaseLayer = layers.BaseLayer{Contents: data[:len(data)]}
    h.frames = frames
    return nil
}

package main

import (
    "bytes"
    "fmt"
    "log"
    "time"

    "github.com/google/gopacket"
    "github.com/google/gopacket/layers"
    "github.com/google/gopacket/pcap"

    "golang.org/x/net/http2"
)

var (
    device       string        = "lo0"
    snapshot_len int32         = 1024
    promiscuous  bool          = false
    timeout      time.Duration = 900 * time.Millisecond
    filter       string        = "tcp"
)

func main() {
    // Open device: We could also use other options (i.e. Open a .pcap file)
    handle, err := pcap.OpenLive(device, snapshot_len, promiscuous, timeout)
    if err != nil {
        log.Fatal(err)
    }
    log.Printf("Successfully opened live sniffing on %s\n", device)
    defer handle.Close()

    var h2c HTTP2

    // Create a parser to decode our HTTP/2 frame
    parser := gopacket.NewDecodingLayerParser(LayerTypeHTTP2, &h2c)

    // Use the handle as a packet source to process all packets
    source := gopacket.NewPacketSource(handle, handle.LinkType())
    decoded := []gopacket.LayerType{}

    // Process every packet
    for packet := range source.Packets() {
        ipLayer := packet.NetworkLayer()
        if ipLayer == nil {
            log.Println("No IP")
            continue
        }

        // Cast the layer to either IPv4 or IPv6
        ipv4, ipv4Ok := ipLayer.(*layers.IPv4)
        ipv6, ipv6Ok := ipLayer.(*layers.IPv6)
        if !ipv4Ok && !ipv6Ok {
            log.Println("Failed to cast packet to IPv4 or IPv6")
            continue
        }

        tcpLayer := packet.Layer(layers.LayerTypeTCP)
        if tcpLayer == nil {
            log.Println("Not a TCP Packet")
            continue
        }

        tcp, ok := tcpLayer.(*layers.TCP)
        if !ok {
            log.Println("Failed to cast packet to TCP")
            continue
        }

        appLayer := packet.ApplicationLayer()
        if appLayer == nil {
            log.Println("No ApplicationLayer payload")
            continue
        }

        packetData := appLayer.Payload()
        if err := parser.DecodeLayers(packetData, &decoded); err != nil {
            fmt.Printf("Could not decode layers: %v\n", err)
            continue
        }

        fmt.Println("*****************************************************")
        if ipv4Ok {
            fmt.Println("IPv4 SrcIP:        ", ipv4.SrcIP)
            fmt.Println("IPv4 DstIP:        ", ipv4.DstIP)
        } else if ipv6Ok {
            fmt.Println("IPv6 SrcIP:        ", ipv6.SrcIP)
            fmt.Println("IPv6 DstIP:        ", ipv6.DstIP)
        }
        fmt.Println("TCP srcPort:       ", tcp.SrcPort)
        fmt.Println("TCP dstPort:       ", tcp.DstPort)
        fmt.Println("HTTP/2:            ", h2c.frame)
        fmt.Println("*****************************************************")
    }
}