package rrdformat import ( "encoding/binary" "fmt" "math" "git.lukeshu.com/go/librrd/rrdformat/rrdbinary" ) func SniffArchitecture(data []byte) (rrdbinary.Architecture, error) { var arch rrdbinary.Architecture var header struct { Cookie rrdbinary.String `rrdbinary:"size=4" xml:"-"` Version rrdbinary.String `rrdbinary:"size=5" xml:"version"` } if err := rrdbinary.NewDecoder(arch, data).Decode(&header, ""); err != nil { return rrdbinary.Architecture{}, err } // 1. File header magic number if header.Cookie != "RRD" { return rrdbinary.Architecture{}, rrdbinary.NewBinError("not an RRD file: wrong magic number", data, 0, 4) } // 1. File format version string switch header.Version { case RRD_VERSION1, RRD_VERSION2, RRD_VERSION3, RRD_VERSION4, RRD_VERSION5: // do nothing default: return rrdbinary.Architecture{}, rrdbinary.NewBinError(fmt.Sprintf("can't handle RRD file version %q", header.Version), data, 4, 5) } // 3. float cookie // // Assume IEEE 754 doubles. C doesn't assume 754 doubles, but anything that doesn't use 754 doubles is exotic // enough that I'm OK saying "you're going to need to use `rrdtool dump`". This lets us assume that: // - a 'double' is 8 bytes wide // - the value will be exactly equal, and we don't need to worry about weird rounding. arch.DoubleWidth = 8 magicFloat := float64(8.642135e130) floatAddrPacked := 9 floatAddr32 := ((floatAddrPacked + 3) / 4) * 4 floatAddr64 := ((floatAddrPacked + 7) / 8) * 8 var restOffset int switch { case len(data) < floatAddr32+arch.DoubleWidth: return rrdbinary.Architecture{}, rrdbinary.NewBinError("unexpected end-of-file", data, floatAddrPacked, floatAddr64+arch.DoubleWidth-floatAddrPacked) case math.Float64frombits(binary.LittleEndian.Uint64(data[floatAddr32:])) == magicFloat: arch.ByteOrder = binary.LittleEndian arch.DoubleAlign = 4 restOffset = floatAddr32 + arch.DoubleWidth case math.Float64frombits(binary.BigEndian.Uint64(data[floatAddr32:])) == magicFloat: arch.ByteOrder = binary.BigEndian arch.DoubleAlign = 4 restOffset = floatAddr32 + arch.DoubleWidth case len(data) < floatAddr64+arch.DoubleWidth: return rrdbinary.Architecture{}, rrdbinary.NewBinError("unexpected end-of-file", data, floatAddrPacked, floatAddr64+arch.DoubleWidth-floatAddrPacked) case math.Float64frombits(binary.LittleEndian.Uint64(data[floatAddr64:])) == magicFloat: arch.ByteOrder = binary.LittleEndian arch.DoubleAlign = 8 restOffset = floatAddr64 + arch.DoubleWidth case math.Float64frombits(binary.BigEndian.Uint64(data[floatAddr64:])) == magicFloat: arch.ByteOrder = binary.BigEndian arch.DoubleAlign = 8 restOffset = floatAddr64 + arch.DoubleWidth default: return rrdbinary.Architecture{}, rrdbinary.NewBinError("failed to sniff byte-order and float-alignment", data, floatAddrPacked, floatAddr64+arch.DoubleWidth-floatAddrPacked) } // 5, 6. ds_cnt, rra_cnt switch arch.DoubleAlign { case 4: // Assume that if floats are only 32-bit aligned, then everything is 32-bit arch.LongWidth = 4 arch.LongAlign = 4 case 8: // If floats are 64-bit aligned, then this might be all-in on 64-bit, or it might 32-bit ints. // (The following heuristic is borrowed from javascriptRRD, and adjusted to also work with big-endian.) // // The next 2 things after the float_cookie are ds_cnt and rra_cnt (both 'unsigned long'--which may be // either 32 or 64 bit). We'll inspect the bytes a bit to guess how long a long is. // // By assuming // 1. ds_cnt <= math.MaxUint32 // 2l. rra_cnt > 0 (relevant if little-endian) // 2b. ds_cnt > 0 (relevant if big-endian) // we can inspect the 4 bytes (marked "big" or "little" below) that are either // - the most significant bits of 64-bit ds_cnt, or // - the entirety of 32-bit rra_cnt (if littlen-endian) or 32-bit ds_cnt (if big-endian) // If we see that those 4 bytes are all 0, then we assume that it's part of a 64-bit ds_cnt. // // | | | | | | | big | little | // |00|01|02|03|04|05|06|07|08|09|10|11|12|13|14|15|16|17|18|19|20|21|22|23|24|25|26|27|28|29|30|31| // 32 | R| R| D|\0| 0| 0| 0| 3|\0| |<----doublecookie----->|<--ds_cnt->|<-rra_cnt->| // 64le | R| R| D|\0| 0| 0| 0| 3|\0| |<----doublecookie----->|<1111----ds_cnt---0000>| // 64be | R| R| D|\0| 0| 0| 0| 3|\0| |<----doublecookie----->|<0000----ds_cnt---1111>| if len(data) < restOffset+8 { return rrdbinary.Architecture{}, rrdbinary.NewBinError("unexpected end of file", data, restOffset, 8) } offset := map[binary.ByteOrder]int{ binary.BigEndian: restOffset, // 24 in the above diagram binary.LittleEndian: restOffset + 4, // 28 in the above diagram }[arch.ByteOrder] if arch.ByteOrder.Uint32(data[offset:]) == 0 { arch.LongWidth = 8 arch.LongAlign = 8 } else { arch.LongWidth = 4 arch.LongAlign = 4 } } // The above just os happens that DoubleXXX >= LongXXX, so we // can just set the Unival stuff to the Double Stuff. arch.UnivalWidth = arch.DoubleWidth // max(DoubleWidth, LongWidth) arch.UnivalAlign = arch.DoubleAlign // max(DoubleAlign, LongAlign) // FIXME: Figure out how to sniff the sizeof(time_t). // // javascriptRRD assumes that it's the same as sizeof(long), // which his historically been true, but // - isn't true of proprietary 32-bit Unixen that are 2038-safe // - isn't true of the Linux kernel with the x32 ABI arch.TimeWidth = arch.LongWidth arch.TimeAlign = arch.LongAlign // FIXME: Figure out how to sniff the sizeof(short). // // javascriptRRD doesn't deal with this at all (it only comes // up in parsing the params for DST_CDEF). // // For now, just assume it's sizeof(long)/2, which is true on // i686, x86_64, and arm. (It is not true on alpha or ia64.) arch.ShortWidth = arch.LongWidth / 2 arch.Shortalign = arch.LongAlign / 2 return arch, nil }