Pcap to Go generator

package main

import (
    "bytes"
    "flag"
    "fmt"
    "go/format"
    "io"
    "os"
    "time"

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

const disclaimer = `
//
// This file is generated automatically. DO NOT EDIT.
// Generated on %v
//
`

var fileName = flag.String("f", "", "Specify file name")
var pkgName = flag.String("package", "main", "Specify package name")
var fold = flag.Int("fold", 8, "Specify number of symbols to fold a string")
var prefix = flag.String("prefix", "Frame", "Specify variable names prefix")
var output = flag.String("o", "", "Specify output file")

func PrintBytes(data []byte, fold int) string {
    var s string
    for i := range data {
        if i > 0 && i%fold == 0 {
            s += "\n"
        }
        s += fmt.Sprintf("0x%02X,", data[i])
    }
    return s + "\n"
}

func PrintPacket(pkt gopacket.Packet, fold int) string {
    var s string
    var off int
    for _, layer := range pkt.Layers() {
        contents := layer.LayerContents()
        typ := layer.LayerType()
        s += fmt.Sprintf("//\n// %v, off: %d, len: %d\n%s", typ, off,
            len(contents), PrintBytes(contents, fold))
        off += len(contents)
    }
    return s
}

func FprintPacket(w io.Writer, pkt gopacket.Packet, fold int) {
    var off int
    fmt.Fprintf(w, "[]byte{\n")
    defer fmt.Fprintf(w, "}")
    for _, layer := range pkt.Layers() {
        contents := layer.LayerContents()
        typ := layer.LayerType()
        fmt.Fprintf(w, "//\n// %v, off: %d, len: %d\n%s", typ, off,
            len(contents), PrintBytes(contents, fold))
        off += len(contents)
    }
}

const billion = 1000 * 1000 * 1000

func FprintCaptureInfo(w io.Writer, ci gopacket.CaptureInfo) {
    ns := ci.Timestamp.UnixNano()
    ts := ci.Timestamp.Format(time.RFC3339Nano)
    fmt.Fprintf(w, `gopacket.CaptureInfo{
    // %s
    Timestamp: time.Unix(%d, %d),
    CaptureLength: %d,
    Length: %d,
    }`, ts, ns/billion, ns%billion,
        ci.CaptureLength, ci.Length)
}

func FprintPacketSource(w io.Writer, src *gopacket.PacketSource, fold int) {
    fmt.Fprintf(w, "var %s = [] struct{\nData []byte\ngopacket.CaptureInfo}{\n", *prefix)
    defer fmt.Fprintf(w, "}")
    n := 1
    for pkt := range src.Packets() {
        fmt.Fprintf(w, "//\n// Frame %d\n", n)
        fmt.Fprintf(w, "{\n")
        FprintPacket(w, pkt, fold)
        fmt.Fprintf(w, ",\n")
        FprintCaptureInfo(w, pkt.Metadata().CaptureInfo)
        fmt.Fprintf(w, ",\n},\n")
        n++
    }
}

func main() {
    var err error
    flag.Parse()

    f := os.Stdin
    if *fileName != "" {
        f, err = os.Open(*fileName)
        if err != nil {
            panic(err)
        }
        defer f.Close()
    }

    out := os.Stdout
    if *output != "" {
        out, err = os.OpenFile(*output, os.O_TRUNC|os.O_WRONLY|os.O_CREATE, 0644)
        if err != nil {
            panic(err)
        }
        defer out.Close()
    }

    handle, err := pcap.OpenOfflineFile(f)
    if err != nil {
        panic(err)
    }
    defer handle.Close()

    buf := &bytes.Buffer{}
    packetSource := gopacket.NewPacketSource(handle, handle.LinkType())
    fmt.Fprintf(buf, "package %s\n\n", *pkgName)
    fmt.Fprintf(buf, disclaimer, time.Now())
    fmt.Fprintf(buf, "import \"time\"\n")
    fmt.Fprintf(buf, "import \"github.com/google/gopacket\"\n")
    FprintPacketSource(buf, packetSource, *fold)

    fmtCode, err := format.Source(buf.Bytes())
    if err != nil {
        panic(err)
    }
    fmt.Fprintf(out, string(fmtCode))
}