added version info to libpyasdcp (same as other lib versions)

[asdcplib.git] / src / KM_util.cpp

diff --git a/src/KM_util.cpp b/src/KM_util.cpp
index 391394c6080e3bdb483687c4d52e9926429cdf24..2624f07fcb1bf6533153c787c9892360b07e9564 100755 (executable)
--- a/src/KM_util.cpp
+++ b/src/KM_util.cpp
@@ -537,9 +537,6 @@ Kumu::GenRandomValue(SymmetricKey& Key)
 
 
 //------------------------------------------------------------------------------------------
-// read a ber value from the buffer and compare with test value.
-// Advances buffer to first character after BER value.
-
 // read a ber value from the buffer and compare with test value.
 // Advances buffer to first character after BER value.
 //
@@ -605,6 +602,20 @@ static const ui64_t ber_masks[9] =
     0
   };
 
+//
+ui32_t
+Kumu::get_BER_length_for_value(ui64_t val)
+{
+  for ( ui32_t i = 0; i < 9; i++ )
+    {
+      if ( ( val & ber_masks[i] ) == 0 )
+       return i + 1;
+    }
+
+  ui64Printer tmp_i(val);
+  DefaultLogSink().Error("BER integer encoding not supported for large value %s\n", tmp_i.c_str());
+  return 0;
+}
 
 //
 bool
@@ -626,14 +637,14 @@ Kumu::write_BER(byte_t* buf, ui64_t val, ui32_t ber_len)
     { // sanity check BER length
       if ( ber_len > 9 )
         {
-          DefaultLogSink().Error("BER size %u exceeds maximum size of 9\n", ber_len);
+          DefaultLogSink().Error("BER integer length %u exceeds maximum size of 9\n", ber_len);
           return false;
         }
       
-      if ( val & ber_masks[ber_len - 1] )
+      if ( ( val & ber_masks[ber_len - 1] ) != 0 )
         {
          ui64Printer tmp_i(val);
-          DefaultLogSink().Error("BER size %u too small for value %s\n", tmp_i.c_str());
+          DefaultLogSink().Error("BER integer length %u too small for value %s\n", ber_len, tmp_i.c_str());
           return false;
         }
     }
@@ -774,6 +785,26 @@ Kumu::Timestamp::AddMinutes(i32_t minutes)
     }
 }
 
+//
+void
+Kumu::Timestamp::AddSeconds(i32_t seconds)
+{
+  SYSTEMTIME current_st;
+  FILETIME current_ft;
+  ULARGE_INTEGER current_ul;
+
+  if ( seconds != 0 )
+    {
+      TIMESTAMP_TO_SYSTIME(*this, &current_st);
+      SystemTimeToFileTime(&current_st, &current_ft);
+      memcpy(&current_ul, &current_ft, sizeof(current_ul));
+      current_ul.QuadPart += ( seconds_to_ns100(1) * (i64_t)seconds );
+      memcpy(&current_ft, &current_ul, sizeof(current_ft));
+      FileTimeToSystemTime(&current_ft, &current_st);
+      SYSTIME_TO_TIMESTAMP(&current_st, *this);
+    }
+}
+
 #else // KM_WIN32
 
 #include <time.h>
@@ -889,6 +920,23 @@ Kumu::Timestamp::AddMinutes(i32_t minutes)
     }
 }
 
+//
+void
+Kumu::Timestamp::AddSeconds(i32_t seconds)
+{
+  Kumu::TAI::caltime ct;
+  Kumu::TAI::tai t;
+
+  if ( seconds != 0 )
+    {
+      TIMESTAMP_TO_CALTIME(*this, &ct)
+      t = ct;
+      t.add_seconds(seconds);
+      ct = t;
+      CALTIME_TO_TIMESTAMP(&ct, *this)
+    }
+}
+
 #endif // KM_WIN32
 
 
@@ -952,15 +1000,42 @@ Kumu::Timestamp::operator!=(const Timestamp& rhs) const
 // 
 const char*
 Kumu::Timestamp::EncodeString(char* str_buf, ui32_t buf_len) const
+{
+  return EncodeStringWithOffset(str_buf, buf_len, 0);
+}
+
+// 
+const char*
+Kumu::Timestamp::EncodeStringWithOffset(char* str_buf, ui32_t buf_len,
+                                       i32_t offset_minutes) const
 {
   if ( buf_len < ( DateTimeLen + 1 ) )
     return 0;
 
-  // 2004-05-01T13:20:00-00:00
+  // ensure offset is within +/- 14 hours
+  if ((offset_minutes < -14 * 60) || (offset_minutes > 14 * 60))
+    return 0;
+
+  // set the apparent time
+  Kumu::Timestamp tmp_t(*this);
+  tmp_t.AddMinutes(offset_minutes);
+
+  char direction = '+';
+  if (offset_minutes < 0) {
+    direction = '-';
+    // need absolute offset from zero
+    offset_minutes = -offset_minutes;
+  }
+
+  // 2004-05-01T13:20:00+00:00
   snprintf(str_buf, buf_len,
-          "%04hu-%02hu-%02huT%02hu:%02hu:%02hu+00:00",
-          Year, Month, Day, Hour, Minute, Second);
-  
+          "%04hu-%02hu-%02huT%02hu:%02hu:%02hu%c%02hu:%02hu",
+          tmp_t.Year, tmp_t.Month, tmp_t.Day,
+          tmp_t.Hour, tmp_t.Minute, tmp_t.Second,
+          direction,
+          offset_minutes / 60,
+          offset_minutes % 60);
+
   return str_buf;
 }
 
@@ -1021,16 +1096,19 @@ Kumu::Timestamp::DecodeString(const char* datestr)
 
          char_count += 6;
 
-         i32_t TZ_mm = 60 * atoi(datestr + 20);
-         TZ_mm += atoi(datestr + 23);
-         if (datestr[19] == '-')
-           TZ_mm = -TZ_mm;
-
-         if ((TZ_mm > 14 * 60) || (TZ_mm < -12 * 60))
+         ui32_t TZ_hh = atoi(datestr + 20);
+         ui32_t TZ_mm = atoi(datestr + 23);
+         if ((TZ_hh > 14) || (TZ_mm > 59) || ((TZ_hh == 14) && (TZ_mm > 0)))
            return false;
 
-         else 
-           TmpStamp.AddMinutes(-TZ_mm);
+         i32_t TZ_offset = 60 * TZ_hh + TZ_mm;
+         if (datestr[19] == '-')
+           TZ_offset = -TZ_offset;
+         /* at this point, TZ_offset reflects the contents of the string */
+
+         /* a negative offset is behind UTC and so needs to increment to
+          * convert, while a positive offset must do the reverse */
+         TmpStamp.AddMinutes(-TZ_offset);
        }
       else if (datestr[19] == 'Z')
        {
@@ -1095,6 +1173,45 @@ Kumu::Timestamp::Archive(MemIOWriter* Writer) const
   return true;
 }
 
+//
+long
+Kumu::Timestamp::GetSecondsSinceEpoch(void) const
+{
+#ifdef KM_WIN32
+  SYSTEMTIME timeST;
+  TIMESTAMP_TO_SYSTIME(*this, &timeST);
+  FILETIME timeFT;
+  SystemTimeToFileTime(&timeST, &timeFT);
+  ULARGE_INTEGER timeUL;
+  timeUL.LowPart = timeFT.dwLowDateTime;
+  timeUL.HighPart = timeFT.dwHighDateTime;
+
+  SYSTEMTIME epochST;
+  epochST.wYear = 1970;
+  epochST.wMonth = 0;
+  epochST.wDayOfWeek = 4;
+  epochST.wDay = 1;
+  epochST.wHour = 0;
+  epochST.wMinute = 0;
+  epochST.wSecond = 0;
+  epochST.wMilliseconds = 0;
+  FILETIME epochFT;
+  SystemTimeToFileTime(&epochST, &epochFT);
+  ULARGE_INTEGER epochUL;
+  epochUL.LowPart = epochFT.dwLowDateTime;
+  epochUL.HighPart = epochFT.dwHighDateTime;
+
+  return (timeUL.QuadPart - epochUL.QuadPart) / 10000000;
+#else
+  Kumu::TAI::caltime ct;
+  Kumu::TAI::tai t;
+  TIMESTAMP_TO_CALTIME(*this, &ct);
+  t = ct;
+
+  return (long) (t.x - ui64_C(4611686018427387914));
+#endif
+}
+
 //------------------------------------------------------------------------------------------
 
 Kumu::MemIOWriter::MemIOWriter(ByteString* Buf)