X-Git-Url: https://git.carlh.net/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FKM_util.h;h=b209d27841a890814e1841885a5e1abae6ed4f4d;hb=7ce81497e2592d5787b9a4285d6a89ae09f79022;hp=6b2e78e9ec5b71a0ec3248cf34bdab28130939da;hpb=984de376d405e0b68e77d61558d4f798fa1170a5;p=asdcplib.git diff --git a/src/KM_util.h b/src/KM_util.h index 6b2e78e..b209d27 100755 --- a/src/KM_util.h +++ b/src/KM_util.h @@ -1,5 +1,5 @@ /* -Copyright (c) 2005-2006, John Hurst +Copyright (c) 2005-2015, John Hurst All rights reserved. Redistribution and use in source and binary forms, with or without @@ -34,11 +34,14 @@ THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include #include +#include #include -#include +#include namespace Kumu { + // The version number declaration and explanation are in ../configure.ac + const char* Version(); // a class that represents the string form of a value template @@ -151,6 +154,10 @@ namespace Kumu return (*buf & 0x0f) + 1; } + // Return the BER length required to encode value. A return value of zero + // indicates a value too large for this library. + ui32_t get_BER_length_for_value(ui64_t valuse); + // read a BER value bool read_BER(const byte_t* buf, ui64_t* val); @@ -169,11 +176,117 @@ namespace Kumu { public: virtual ~IArchive(){} - virtual bool HasValue() const = 0; - virtual bool Archive(MemIOWriter* Writer) const = 0; - virtual bool Unarchive(MemIOReader* Reader) = 0; + virtual bool HasValue() const = 0; + virtual ui32_t ArchiveLength() const = 0; + virtual bool Archive(MemIOWriter* Writer) const = 0; + virtual bool Unarchive(MemIOReader* Reader) = 0; + }; + + // + template + class ArchivableList : public std::list, public IArchive + { + public: + ArchivableList() {} + virtual ~ArchivableList() {} + + bool HasValue() const { return ! this->empty(); } + + ui32_t ArchiveLength() const + { + ui32_t arch_size = sizeof(ui32_t); + + typename ArchivableList::const_iterator i = this->begin(); + for ( ; i != this->end(); i++ ) + arch_size += i->ArchiveLength(); + + return arch_size; + } + + bool Unarchive(Kumu::MemIOReader* Reader) + { + if ( Reader == 0 ) return false; + ui32_t read_size = 0; + if ( ! Reader->ReadUi32BE(&read_size) ) return false; + for ( ui32_t i = 0; i < read_size; i++ ) + { + T TmpTP; + if ( ! TmpTP.Unarchive(Reader) ) return false; + this->push_back(TmpTP); + } + + return true; + } + + bool Archive(Kumu::MemIOWriter* Writer) const + { + if ( Writer == 0 ) return false; + if ( ! Writer->WriteUi32BE(static_cast(this->size())) ) return false; + typename ArchivableList::const_iterator i = this->begin(); + for ( ; i != this->end(); i++ ) + if ( ! i->Archive(Writer) ) return false; + + return true; + } }; + // archivable version of std::string + + // + class ArchivableString : public std::string, public Kumu::IArchive + { + + public: + ArchivableString() {} + ArchivableString(const char* sz) : std::string(sz) {} + ArchivableString(const std::string& s) : std::string(s) {} + virtual ~ArchivableString() {} + + bool HasValue() const { return ! this->empty(); } + ui32_t ArchiveLength() const { return sizeof(ui32_t) + static_cast(this->size()); } + + bool Archive(MemIOWriter* Writer) const { + if ( Writer == 0 ) return false; + return Writer->WriteString(*this); + } + + bool Unarchive(MemIOReader* Reader) { + if ( Reader == 0 ) return false; + return Reader->ReadString(*this); + } + }; + + // + class ArchivableUi16 : public Kumu::IArchive + { + ui16_t m_Value; + + public: + ArchivableUi16() : m_Value(0) {} + ArchivableUi16(const ui16_t& value) : m_Value(value) {} + virtual ~ArchivableUi16() {} + + bool HasValue() const { return true; } + ui32_t ArchiveLength() const { return sizeof(ui16_t); } + + bool Archive(MemIOWriter* Writer) const { + if ( Writer == 0 ) return false; + return Writer->WriteUi16BE(m_Value); + } + + bool Unarchive(MemIOReader* Reader) { + if ( Reader == 0 ) return false; + return Reader->ReadUi16BE(&m_Value); + } + + const char* EncodeString(char* str_buf, ui32_t buf_len) const { + snprintf(str_buf, buf_len, "%hu", m_Value); + return str_buf; + } + }; + + // + typedef Kumu::ArchivableList StringList; // // the base of all identifier classes, Identifier is not usually used directly @@ -189,7 +302,7 @@ namespace Kumu public: Identifier() : m_HasValue(false) { memset(m_Value, 0, SIZE); } Identifier(const byte_t* value) : m_HasValue(true) { memcpy(m_Value, value, SIZE); } - Identifier(const Identifier& rhs) { + Identifier(const Identifier& rhs) : IArchive() { m_HasValue = rhs.m_HasValue; memcpy(m_Value, rhs.m_Value, SIZE); } @@ -203,6 +316,7 @@ namespace Kumu } inline void Set(const byte_t* value) { m_HasValue = true; memcpy(m_Value, value, SIZE); } + inline void Reset() { m_HasValue = false; memset(m_Value, 0, SIZE); } inline const byte_t* Value() const { return m_Value; } inline ui32_t Size() const { return SIZE; } @@ -231,6 +345,8 @@ namespace Kumu inline bool DecodeHex(const char* str) { ui32_t char_count; m_HasValue = ( hex2bin(str, m_Value, SIZE, &char_count) == 0 ); + if ( m_HasValue && char_count != SIZE ) + m_HasValue = false; return m_HasValue; } @@ -245,6 +361,8 @@ namespace Kumu inline bool DecodeBase64(const char* str) { ui32_t char_count; m_HasValue = ( base64decode(str, m_Value, SIZE, &char_count) == 0 ); + if ( m_HasValue && char_count != SIZE ) + m_HasValue = false; return m_HasValue; } @@ -254,6 +372,8 @@ namespace Kumu inline bool HasValue() const { return m_HasValue; } + inline ui32_t ArchiveLength() const { return SIZE; } + inline bool Unarchive(Kumu::MemIOReader* Reader) { m_HasValue = Reader->ReadRaw(m_Value, SIZE); return m_HasValue; @@ -264,7 +384,7 @@ namespace Kumu } }; - + // UUID // const ui32_t UUID_Length = 16; @@ -288,6 +408,8 @@ namespace Kumu void GenRandomUUID(byte_t* buf); // buf must be UUID_Length or longer void GenRandomValue(UUID&); + typedef ArchivableList UUIDList; + // a self-wiping key container // const ui32_t SymmetricKey_Length = 16; @@ -308,23 +430,22 @@ namespace Kumu void GenRandomValue(SymmetricKey&); // - // 2004-05-01T13:20:00-00:00 + // 2004-05-01T13:20:00+00:00 const ui32_t DateTimeLen = 25; // the number of chars in the xs:dateTime format (sans milliseconds) // UTC time+date representation class Timestamp : public IArchive { - public: - ui16_t Year; - ui8_t Month; - ui8_t Day; - ui8_t Hour; - ui8_t Minute; - ui8_t Second; + TAI::tai m_Timestamp; // always UTC + i32_t m_TZOffsetMinutes; + public: Timestamp(); Timestamp(const Timestamp& rhs); Timestamp(const char* datestr); + Timestamp(const ui16_t& Year, const ui8_t& Month, const ui8_t& Day); + Timestamp(const ui16_t& Year, const ui8_t& Month, const ui8_t& Day, + const ui8_t& Hour, const ui8_t& Minute, const ui8_t& Second); virtual ~Timestamp(); const Timestamp& operator=(const Timestamp& rhs); @@ -333,26 +454,45 @@ namespace Kumu bool operator==(const Timestamp& rhs) const; bool operator!=(const Timestamp& rhs) const; - // Write the timestamp value to the given buffer in the form 2004-05-01T13:20:00-00:00 + // always UTC + void GetComponents(ui16_t& Year, ui8_t& Month, ui8_t& Day, + ui8_t& Hour, ui8_t& Minute, ui8_t& Second) const; + void SetComponents(const ui16_t& Year, const ui8_t& Month, const ui8_t& Day, + const ui8_t& Hour, const ui8_t& Minute, const ui8_t& Second); + + // Write the timestamp value to the given buffer in the form 2004-05-01T13:20:00+00:00 // returns 0 if the buffer is smaller than DateTimeLen const char* EncodeString(char* str_buf, ui32_t buf_len) const; // decode and set value from string formatted by EncodeString bool DecodeString(const char* datestr); - // Add the given number of days or hours to the timestamp value. + // Add the given number of days, hours, minutes, or seconds to the timestamp value. // Values less than zero will cause the timestamp to decrease - void AddDays(i32_t); - void AddHours(i32_t); + inline void AddDays(const i32_t& d) { m_Timestamp.add_days(d); } + inline void AddHours(const i32_t& h) { m_Timestamp.add_hours(h); } + inline void AddMinutes(const i32_t& m) { m_Timestamp.add_minutes(m); } + inline void AddSeconds(const i32_t& s) { m_Timestamp.add_seconds(s); } + + // returns false if the requested adjustment is out of range + bool SetTZOffsetMinutes(const i32_t& minutes); + inline i32_t GetTZOffsetMinutes() const { return m_TZOffsetMinutes; } + + // Return the number of seconds since the Unix epoch UTC (1970-01-01T00:00:00+00:00) + ui64_t GetCTime() const; + + // Set internal time to the number of seconds since the Unix epoch UTC + void SetCTime(const ui64_t& ctime); - // Read and write the timestamp value as a byte string having + // Read and write the timestamp (always UTC) value as a byte string having // the following format: // | 16 bits int, big-endian | 8 bits | 8 bits | 8 bits | 8 bits | 8 bits | // | Year A.D | Month(1-12) | Day(1-31) | Hour(0-23) | Minute(0-59) | Second(0-59) | // - virtual bool HasValue() const; - virtual bool Archive(MemIOWriter* Writer) const; - virtual bool Unarchive(MemIOReader* Reader); + virtual bool HasValue() const; + virtual ui32_t ArchiveLength() const { return 8L; } + virtual bool Archive(MemIOWriter* Writer) const; + virtual bool Unarchive(MemIOReader* Reader); }; // @@ -370,8 +510,7 @@ namespace Kumu ByteString(ui32_t cap); virtual ~ByteString(); - // Sets the size of the internally allocated buffer. - // Resets content Size to zero. + // Sets or resets the size of the internally allocated buffer. Result_t Capacity(ui32_t cap); Result_t Append(const ByteString&); @@ -395,9 +534,12 @@ namespace Kumu // copy the given data into the ByteString, set Length value. // Returns error if the ByteString is too small. Result_t Set(const byte_t* buf, ui32_t buf_len); + Result_t Set(const ByteString& Buf); inline virtual bool HasValue() const { return m_Length > 0; } + inline virtual ui32_t ArchiveLength() const { return sizeof(ui32_t) + m_Length; } + inline virtual bool Archive(MemIOWriter* Writer) const { assert(Writer); if ( ! Writer->WriteUi32BE(m_Length) ) return false; @@ -407,13 +549,50 @@ namespace Kumu inline virtual bool Unarchive(MemIOReader* Reader) { assert(Reader); - if ( ! Reader->ReadUi32BE(&m_Length) ) return false; - if ( KM_FAILURE(Capacity(m_Length)) ) return false; - if ( ! Reader->ReadRaw(m_Data, m_Length) ) return false; + ui32_t tmp_len; + if ( ! Reader->ReadUi32BE(&tmp_len) ) return false; + if ( KM_FAILURE(Capacity(tmp_len)) ) return false; + if ( ! Reader->ReadRaw(m_Data, tmp_len) ) return false; + m_Length = tmp_len; return true; } }; + inline void hexdump(const ByteString& buf, FILE* stream = 0) { + hexdump(buf.RoData(), buf.Length(), stream); + } + + // Locates the first occurrence of the null-terminated string s2 in the string s1, where not more + // than n characters are searched. Characters that appear after a `\0' character are not searched. + // Reproduced here from BSD for portability. + const char *km_strnstr(const char *s1, const char *s2, size_t n); + + // Split the input string into tokens using the given separator. If the separator is not found the + // entire string will be returned as a single-item list. Empty items will be recorded for + // adjacent instances of the separator. E.g., "/foo//bar/" will return ["", "foo", "", "bar", ""]. + std::list km_token_split(const std::string& str, const std::string& separator); + + // Join the tokens in the given list using delimiter. If prefix is defined then each token + // will be concatenated with the prefix before being added to the composite string. + template + std::string + km_join(const T& list, const std::string& delimiter, const std::string& prefix = "") + { + std::string result; + + for ( typename T::const_iterator i = list.begin(); i != list.end(); ++i ) + { + if ( i != list.begin() ) + { + result += delimiter; + } + + result += prefix + *i; + } + + return result; + } + } // namespace Kumu