Move binpac code into the main Zeek repository

This is based on commit 48f75b5f6415fe9d597e3e991cec635b1bc400dc from
the binpac repository.

tools/binpac/lib/binpac_bytestring.h

@@ -0,0 +1,142 @@
+#ifndef binpac_bytestring_h
+#define binpac_bytestring_h
+
+#include <string.h>
+#include <string>
+
+#include "binpac.h"
+
+namespace binpac {
+
+template<class T>
+class datastring;
+
+template<class T>
+class const_datastring {
+public:
+    const_datastring() : begin_(0), end_(0) {}
+
+    const_datastring(T const* data, int length) : begin_(data), end_(data + length) {}
+
+    const_datastring(const T* begin, const T* end) : begin_(begin), end_(end) {}
+
+    const_datastring(datastring<T> const& s) : begin_(s.begin()), end_(s.end()) {}
+
+    void init(const T* data, int length) {
+        begin_ = data;
+        end_ = data + length;
+    }
+
+    T const* begin() const { return begin_; }
+    T const* end() const { return end_; }
+    int length() const { return end_ - begin_; }
+
+    T const& operator[](int index) const { return begin()[index]; }
+
+    bool operator==(const_datastring<T> const& s) {
+        if ( length() != s.length() )
+            return false;
+        return memcmp((const void*)begin(), (const void*)s.begin(), sizeof(T) * length()) == 0;
+    }
+
+    void set_begin(T const* begin) { begin_ = begin; }
+    void set_end(T const* end) { end_ = end; }
+
+private:
+    T const* begin_;
+    T const* end_;
+};
+
+typedef const_datastring<uint8> const_bytestring;
+
+template<class T>
+class datastring {
+public:
+    datastring() { clear(); }
+
+    datastring(T* data, int len) { set(data, len); }
+
+    datastring(T const* begin, T const* end) { set_const(begin, end - begin); }
+
+    datastring(datastring<T> const& x) : data_(x.data()), length_(x.length()) {}
+
+    explicit datastring(const_datastring<T> const& x) { set_const(x.begin(), x.length()); }
+
+    datastring const& operator=(datastring<T> const& x) {
+        BINPAC_ASSERT(! data_);
+        set(x.data(), x.length());
+        return *this;
+    }
+
+    void init(T const* begin, int length) {
+        BINPAC_ASSERT(! data_);
+        set_const(begin, length);
+    }
+
+    void clear() {
+        data_ = 0;
+        length_ = 0;
+    }
+
+    void free() {
+        if ( data_ )
+            delete[] data_;
+        clear();
+    }
+
+    void clone() { set_const(begin(), length()); }
+
+    datastring const& operator=(const_datastring<T> const& x) {
+        BINPAC_ASSERT(! data_);
+        set_const(x.begin(), x.length());
+        return *this;
+    }
+
+    T const& operator[](int index) const { return begin()[index]; }
+
+    T* data() const { return data_; }
+    int length() const { return length_; }
+
+    T const* begin() const { return data_; }
+    T const* end() const { return data_ + length_; }
+
+private:
+    void set(T* data, int len) {
+        data_ = data;
+        length_ = len;
+    }
+
+    void set_const(T const* data, int len) {
+        length_ = len;
+        data_ = new T[len + 1];
+        memcpy(data_, data, sizeof(T) * len);
+        data_[len] = 0;
+    }
+
+    T* data_;
+    int length_;
+};
+
+typedef datastring<uint8> bytestring;
+
+inline const char* c_str(bytestring const& s) { return (const char*)s.begin(); }
+
+inline std::string std_str(const_bytestring const& s) {
+    return std::string((const char*)s.begin(), (const char*)s.end());
+}
+
+inline bool operator==(bytestring const& s1, const char* s2) { return strcmp(c_str(s1), s2) == 0; }
+
+inline void get_pointers(const_bytestring const& s, uint8 const** pbegin, uint8 const** pend) {
+    *pbegin = s.begin();
+    *pend = s.end();
+}
+
+inline void get_pointers(bytestring const* s, uint8 const** pbegin, uint8 const** pend) {
+    *pbegin = s->begin();
+    *pend = s->end();
+}
+
+} // namespace binpac
+
+#endif // binpac_bytestring_h