Version 17 plus test updates and OPK v17

This is the first public release of OPK v17.
See the file CHANGELOG.md for details.

util/include/log.h

@@ -22,13 +22,13 @@ namespace wvutil {
 typedef enum {
   // This log level should only be used for |g_cutoff|, in order to silence all
   // logging. It should never be passed to |Log()| as a log level.
-  LOG_SILENT = -1,
+  CDM_LOG_SILENT = -1,
 
-  LOG_ERROR = 0,
-  LOG_WARN = 1,
-  LOG_INFO = 2,
-  LOG_DEBUG = 3,
-  LOG_VERBOSE = 4,
+  CDM_LOG_ERROR = 0,
+  CDM_LOG_WARN = 1,
+  CDM_LOG_INFO = 2,
+  CDM_LOG_DEBUG = 3,
+  CDM_LOG_VERBOSE = 4,
 } LogPriority;
 
 extern LogPriority g_cutoff;
@@ -53,7 +53,7 @@ class LogBuffer {
 
 extern LogBuffer g_logbuf;
 
-static const uint32_t UNKNOWN_UID = ~0;
+static const uint32_t UNKNOWN_UID = std::numeric_limits<uint32_t>::max();
 
 #ifdef __ANDROID__
 void SetLoggingUid(const uint32_t);
@@ -93,15 +93,15 @@ CORE_UTIL_EXPORT void Log(const char* file, const char* function, int line,
 // Log APIs
 #ifndef LOGE
 #  define LOGE(...) \
-    Log(__FILE__, __func__, __LINE__, wvutil::LOG_ERROR, __VA_ARGS__)
+    Log(__FILE__, __func__, __LINE__, wvutil::CDM_LOG_ERROR, __VA_ARGS__)
 #  define LOGW(...) \
-    Log(__FILE__, __func__, __LINE__, wvutil::LOG_WARN, __VA_ARGS__)
+    Log(__FILE__, __func__, __LINE__, wvutil::CDM_LOG_WARN, __VA_ARGS__)
 #  define LOGI(...) \
-    Log(__FILE__, __func__, __LINE__, wvutil::LOG_INFO, __VA_ARGS__)
+    Log(__FILE__, __func__, __LINE__, wvutil::CDM_LOG_INFO, __VA_ARGS__)
 #  define LOGD(...) \
-    Log(__FILE__, __func__, __LINE__, wvutil::LOG_DEBUG, __VA_ARGS__)
+    Log(__FILE__, __func__, __LINE__, wvutil::CDM_LOG_DEBUG, __VA_ARGS__)
 #  define LOGV(...) \
-    Log(__FILE__, __func__, __LINE__, wvutil::LOG_VERBOSE, __VA_ARGS__)
+    Log(__FILE__, __func__, __LINE__, wvutil::CDM_LOG_VERBOSE, __VA_ARGS__)
 #endif
 }  // namespace wvutil
 

util/include/string_conversions.h

@@ -20,10 +20,15 @@ CORE_UTIL_EXPORT std::vector<uint8_t> a2b_hex(const std::string& label,
                                               const std::string& b);
 CORE_UTIL_EXPORT std::string a2bs_hex(const std::string& b);
 
-// Binary to ASCII hex conversion.
+// Binary to ASCII hex conversion. The default versions limit output to 2k to
+// protect us from log spam. The unlimited version has no length limit.
 CORE_UTIL_EXPORT std::string b2a_hex(const std::vector<uint8_t>& b);
+CORE_UTIL_EXPORT std::string unlimited_b2a_hex(const std::vector<uint8_t>& b);
 CORE_UTIL_EXPORT std::string b2a_hex(const std::string& b);
+CORE_UTIL_EXPORT std::string unlimited_b2a_hex(const std::string& b);
 CORE_UTIL_EXPORT std::string HexEncode(const uint8_t* bytes, size_t size);
+CORE_UTIL_EXPORT std::string UnlimitedHexEncode(const uint8_t* bytes,
+                                                size_t size);
 
 // Base64 encoding/decoding.
 // Converts binary data into the ASCII Base64 character set and vice

util/src/cdm_random.cpp

@@ -77,10 +77,10 @@ std::string CdmRandomGenerator::RandomData(size_t length) {
     return std::string();
   }
   CdmRandomLock lock(generator_lock_);
-  std::uniform_int_distribution<uint8_t> dist;  // Range of [0, 255].
+  std::uniform_int_distribution<short> dist(0, 255);  // Range of [0, 255].
   std::string random_data(length, '\0');
   std::generate(random_data.begin(), random_data.end(),
-                [&]() { return dist(generator_); });
+                [&]() { return static_cast<char>(dist(generator_)); });
   return random_data;
 }
 

util/src/string_conversions.cpp

@@ -201,20 +201,34 @@ std::string b2a_hex(const std::vector<uint8_t>& byte) {
   return HexEncode(byte.data(), byte.size());
 }
 
+std::string unlimited_b2a_hex(const std::vector<uint8_t>& byte) {
+  if (byte.empty()) return "";
+  return UnlimitedHexEncode(byte.data(), byte.size());
+}
+
 std::string b2a_hex(const std::string& byte) {
   if (byte.empty()) return "";
   return HexEncode(reinterpret_cast<const uint8_t*>(byte.data()),
                    byte.length());
 }
 
+std::string unlimited_b2a_hex(const std::string& byte) {
+  if (byte.empty()) return "";
+  return UnlimitedHexEncode(reinterpret_cast<const uint8_t*>(byte.data()),
+                            byte.length());
+}
+
 std::string HexEncode(const uint8_t* in_buffer, size_t size) {
-  static const char kHexChars[] = "0123456789ABCDEF";
-  if (size == 0) return "";
   constexpr unsigned int kMaxSafeSize = 2048;
   if (size > kMaxSafeSize) size = kMaxSafeSize;
+  return UnlimitedHexEncode(in_buffer, size);
+}
+
+std::string UnlimitedHexEncode(const uint8_t* in_buffer, size_t size) {
+  static const char kHexChars[] = "0123456789ABCDEF";
+  if (size == 0) return "";
   // Each input byte creates two output hex characters.
   std::string out_buffer(size * 2, '\0');
-
   for (unsigned int i = 0; i < size; ++i) {
     char byte = in_buffer[i];
     out_buffer[(i << 1)] = kHexChars[(byte >> 4) & 0xf];

util/test/test_clock.cpp

@@ -13,7 +13,7 @@ namespace wvutil {
 
 namespace {
 // A fake clock that only advances when TestSleep::Sleep is called.
-class FakeClock : public wvcdm::TestSleep::CallBack {
+class FakeClock : public TestSleep::CallBack {
  public:
   FakeClock() {
     auto now = std::chrono::system_clock().now();
@@ -34,7 +34,7 @@ FakeClock* g_fake_clock = nullptr;
 
 // On devices running a fake OEMCrypto, we can use a fake sleep and fake time.
 int64_t Clock::GetCurrentTime() {
-  wvcdm::TestSleep::SyncFakeClock();
+  TestSleep::SyncFakeClock();
   if (g_fake_clock == nullptr) g_fake_clock = new FakeClock();
   return g_fake_clock->now() / 1000;
 }

util/test/test_sleep.cpp

@@ -58,6 +58,21 @@ void TestSleep::SyncFakeClock() {
   Sleep(0);
 }
 
+void TestSleep::SetFakeClock(int64_t time_seconds) {
+  if (real_sleep_) {
+    LOGE("SetFakeClock when using a real clock. Expect other failures.");
+  }
+  // Delta could be positive or negative. If the fake clock had been initialized
+  // by the current time on a real clock, and then the command line
+  // re-initializes it to 0, then delta is negative.
+  int64_t delta = time_seconds - Clock().GetCurrentTime();
+  if (callback_ != nullptr) {
+    callback_->ElapseTime(delta * 1000);
+  } else {
+    LOGE("Setting fake clock with no callback. This won't work.");
+  }
+}
+
 bool TestSleep::RollbackSystemTime(int seconds) {
   if (real_sleep_) {
 #ifdef _WIN32

util/test/test_sleep.h

@@ -41,6 +41,10 @@ class TestSleep {
   // verify this function does not roll back the clock used by OEMCrypto.
   static bool RollbackSystemTime(int seconds);
 
+  // Set the system clock to the specified time. This is only expected to work
+  // when real_sleep is false.
+  static void SetFakeClock(int64_t time_seconds);
+
   // Roll the system clock forward to undo all previous calls to
   // RollBackSystemTime. Returns true on success.
   static bool ResetRollback() {