TimeZoneNameMapUtils.c

 
#include <winpr/config.h>
#include <winpr/assert.h>
#include <winpr/string.h>
#include <winpr/synch.h>
#include <winpr/json.h>
#include <winpr/path.h>
#include <winpr/file.h>
 
#include "../log.h"
 
#include <string.h>
 
#define TAG WINPR_TAG("timezone.utils")
 
#if defined(WITH_TIMEZONE_ICU)
#include <unicode/ucal.h>
#else
#include "WindowsZones.h"
#endif
 
#include "TimeZoneNameMap.h"
 
#if defined(WITH_TIMEZONE_COMPILED)
#include "TimeZoneNameMap_static.h"
#endif
 
typedef struct
{
  size_t count;
  TimeZoneNameMapEntry* entries;
} TimeZoneNameMapContext;
 
static TimeZoneNameMapContext tz_context = WINPR_C_ARRAY_INIT;
 
static void tz_entry_free(TimeZoneNameMapEntry* entry)
{
  if (!entry)
    return;
  free(entry->DaylightName);
  free(entry->DisplayName);
  free(entry->Iana);
  free(entry->Id);
  free(entry->StandardName);
 
  const TimeZoneNameMapEntry empty = WINPR_C_ARRAY_INIT;
  *entry = empty;
}
 
static TimeZoneNameMapEntry tz_entry_clone(const TimeZoneNameMapEntry* entry)
{
  TimeZoneNameMapEntry clone = WINPR_C_ARRAY_INIT;
  if (!entry)
    return clone;
 
  if (entry->DaylightName)
    clone.DaylightName = _strdup(entry->DaylightName);
  if (entry->DisplayName)
    clone.DisplayName = _strdup(entry->DisplayName);
  if (entry->Iana)
    clone.Iana = _strdup(entry->Iana);
  if (entry->Id)
    clone.Id = _strdup(entry->Id);
  if (entry->StandardName)
    clone.StandardName = _strdup(entry->StandardName);
  return clone;
}
 
static void tz_context_free(void)
{
  for (size_t x = 0; x < tz_context.count; x++)
    tz_entry_free(&tz_context.entries[x]);
  free(tz_context.entries);
  tz_context.count = 0;
  tz_context.entries = nullptr;
}
 
#if defined(WITH_TIMEZONE_FROM_FILE) && defined(WITH_WINPR_JSON)
static char* tz_get_object_str(WINPR_JSON* json, size_t pos, const char* name)
{
  WINPR_ASSERT(json);
  if (!WINPR_JSON_IsObject(json) || !WINPR_JSON_HasObjectItem(json, name))
  {
    WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", missing an Object named '%s'", pos,
              name);
    return nullptr;
  }
  WINPR_JSON* obj = WINPR_JSON_GetObjectItemCaseSensitive(json, name);
  WINPR_ASSERT(obj);
  if (!WINPR_JSON_IsString(obj))
  {
    WLog_WARN(TAG,
              "Invalid JSON entry at entry %" PRIuz ", Object named '%s': Not of type string",
              pos, name);
    return nullptr;
  }
 
  const char* str = WINPR_JSON_GetStringValue(obj);
  if (!str)
  {
    WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", Object named '%s': nullptr string",
              pos, name);
    return nullptr;
  }
 
  return _strdup(str);
}
 
static BOOL tz_parse_json_entry(WINPR_JSON* json, size_t pos, TimeZoneNameMapEntry* entry)
{
  WINPR_ASSERT(entry);
  if (!json || !WINPR_JSON_IsObject(json))
  {
    WLog_WARN(TAG, "Invalid JSON entry at entry %" PRIuz ", expected an array", pos);
    return FALSE;
  }
 
  entry->Id = tz_get_object_str(json, pos, "Id");
  entry->StandardName = tz_get_object_str(json, pos, "StandardName");
  entry->DisplayName = tz_get_object_str(json, pos, "DisplayName");
  entry->DaylightName = tz_get_object_str(json, pos, "DaylightName");
  entry->Iana = tz_get_object_str(json, pos, "Iana");
  if (!entry->Id || !entry->StandardName || !entry->DisplayName || !entry->DaylightName ||
      !entry->Iana)
  {
    tz_entry_free(entry);
    return FALSE;
  }
  return TRUE;
}
 
static WINPR_JSON* load_timezones_from_file(const char* filename)
{
  WINPR_JSON* json = WINPR_JSON_ParseFromFile(filename);
  if (!json)
    WLog_WARN(TAG, "Timezone resource file '%s' is not a valid JSON file", filename);
  return json;
}
#endif
 
static BOOL reallocate_context(TimeZoneNameMapContext* context, size_t size_to_add)
{
  {
    TimeZoneNameMapEntry* tmp = realloc(context->entries, (context->count + size_to_add) *
                                                              sizeof(TimeZoneNameMapEntry));
    if (!tmp)
    {
      WLog_WARN(TAG,
                "Failed to reallocate TimeZoneNameMapEntry::entries to %" PRIuz " elements",
                context->count + size_to_add);
      return FALSE;
    }
    const size_t offset = context->count;
    context->entries = tmp;
    context->count += size_to_add;
 
    memset(&context->entries[offset], 0, size_to_add * sizeof(TimeZoneNameMapEntry));
  }
  return TRUE;
}
 
static BOOL CALLBACK load_timezones(PINIT_ONCE once, PVOID param, PVOID* pvcontext)
{
  TimeZoneNameMapContext* context = param;
  WINPR_ASSERT(context);
  WINPR_UNUSED(pvcontext);
  WINPR_UNUSED(once);
 
  const TimeZoneNameMapContext empty = WINPR_C_ARRAY_INIT;
  *context = empty;
 
#if defined(WITH_TIMEZONE_FROM_FILE) && defined(WITH_WINPR_JSON)
  {
    WINPR_JSON* json = nullptr;
    char* filename = GetCombinedPath(WINPR_RESOURCE_ROOT, "TimeZoneNameMap.json");
    if (!filename)
    {
      WLog_WARN(TAG, "Could not create WinPR timezone resource filename");
      goto end;
    }
 
    json = load_timezones_from_file(filename);
    if (!json)
      goto end;
 
    if (!WINPR_JSON_IsObject(json))
    {
      WLog_WARN(TAG, "Invalid top level JSON type in file %s, expected an array", filename);
      goto end;
    }
 
    WINPR_JSON* obj = WINPR_JSON_GetObjectItemCaseSensitive(json, "TimeZoneNameMap");
    if (!WINPR_JSON_IsArray(obj))
    {
      WLog_WARN(TAG, "Invalid top level JSON type in file %s, expected an array", filename);
      goto end;
    }
    const size_t count = WINPR_JSON_GetArraySize(obj);
    const size_t offset = context->count;
    if (!reallocate_context(context, count))
      goto end;
    for (size_t x = 0; x < count; x++)
    {
      WINPR_JSON* entry = WINPR_JSON_GetArrayItem(obj, x);
      if (!tz_parse_json_entry(entry, x, &context->entries[offset + x]))
        goto end;
    }
 
  end:
    free(filename);
    WINPR_JSON_Delete(json);
  }
#endif
 
#if defined(WITH_TIMEZONE_COMPILED)
  {
    const size_t offset = context->count;
    if (!reallocate_context(context, TimeZoneNameMapSize))
      return FALSE;
    for (size_t x = 0; x < TimeZoneNameMapSize; x++)
      context->entries[offset + x] = tz_entry_clone(&TimeZoneNameMap[x]);
  }
#endif
 
  (void)atexit(tz_context_free);
  return TRUE;
}
 
const TimeZoneNameMapEntry* TimeZoneGetAt(size_t index)
{
  static INIT_ONCE init_guard = INIT_ONCE_STATIC_INIT;
 
  if (!InitOnceExecuteOnce(&init_guard, load_timezones, &tz_context, nullptr))
    return nullptr;
  if (index >= tz_context.count)
    return nullptr;
  return &tz_context.entries[index];
}
 
static const char* return_type(const TimeZoneNameMapEntry* entry, TimeZoneNameType type)
{
  WINPR_ASSERT(entry);
  switch (type)
  {
    case TIME_ZONE_NAME_IANA:
      return entry->Iana;
    case TIME_ZONE_NAME_ID:
      return entry->Id;
    case TIME_ZONE_NAME_STANDARD:
      return entry->StandardName;
    case TIME_ZONE_NAME_DISPLAY:
      return entry->DisplayName;
    case TIME_ZONE_NAME_DAYLIGHT:
      return entry->DaylightName;
    default:
      return nullptr;
  }
}
 
static BOOL iana_cmp(const TimeZoneNameMapEntry* entry, const char* iana)
{
  if (!entry || !iana || !entry->Iana)
    return FALSE;
  return strcmp(iana, entry->Iana) == 0;
}
 
static BOOL id_cmp(const TimeZoneNameMapEntry* entry, const char* id)
{
  if (!entry || !id || !entry->Id)
    return FALSE;
  return strcmp(id, entry->Id) == 0;
}
 
static const char* get_for_type(const char* val, TimeZoneNameType type,
                                BOOL (*cmp)(const TimeZoneNameMapEntry*, const char*))
{
  WINPR_ASSERT(val);
  WINPR_ASSERT(cmp);
 
  size_t index = 0;
  while (TRUE)
  {
    const TimeZoneNameMapEntry* entry = TimeZoneGetAt(index++);
    if (!entry)
      return nullptr;
    if (cmp(entry, val))
      return return_type(entry, type);
  }
}
 
#if defined(WITH_TIMEZONE_ICU)
static char* get_wzid_icu(const UChar* utzid, size_t utzid_len)
{
  char* res = nullptr;
  UErrorCode error = U_ZERO_ERROR;
 
  int32_t rc = ucal_getWindowsTimeZoneID(utzid, WINPR_ASSERTING_INT_CAST(int32_t, utzid_len),
                                         nullptr, 0, &error);
  if ((error == U_BUFFER_OVERFLOW_ERROR) && (rc > 0))
  {
    rc++; // make space for '\0'
    UChar* wzid = calloc((size_t)rc + 1, sizeof(UChar));
    if (wzid)
    {
      UErrorCode error2 = U_ZERO_ERROR;
      int32_t rc2 = ucal_getWindowsTimeZoneID(
          utzid, WINPR_ASSERTING_INT_CAST(int32_t, utzid_len), wzid, rc, &error2);
      if (U_SUCCESS(error2) && (rc2 > 0))
        res = ConvertWCharNToUtf8Alloc(wzid, (size_t)rc, nullptr);
      free(wzid);
    }
  }
  return res;
}
 
static char* get(const char* iana)
{
  size_t utzid_len = 0;
  UChar* utzid = ConvertUtf8ToWCharAlloc(iana, &utzid_len);
  if (!utzid)
    return nullptr;
 
  char* wzid = get_wzid_icu(utzid, utzid_len);
  free(utzid);
  return wzid;
}
 
static const char* map_fallback(const char* iana, TimeZoneNameType type)
{
  char* wzid = get(iana);
  if (!wzid)
    return nullptr;
 
  const char* res = get_for_type(wzid, type, id_cmp);
  free(wzid);
  return res;
}
#else
static const char* map_fallback(const char* iana, WINPR_ATTR_UNUSED TimeZoneNameType type)
{
  if (!iana)
    return nullptr;
 
  for (size_t x = 0; x < WindowsZonesNrElements; x++)
  {
    const WINDOWS_TZID_ENTRY* const entry = &WindowsZones[x];
    if (strchr(entry->tzid, ' '))
    {
      const char* res = nullptr;
      char* tzid = _strdup(entry->tzid);
      char* ctzid = tzid;
      while (tzid)
      {
        char* space = strchr(tzid, ' ');
        if (space)
          *space++ = '\0';
        if (strcmp(tzid, iana) == 0)
        {
          res = entry->windows;
          break;
        }
        tzid = space;
      }
      free(ctzid);
      if (res)
        return res;
    }
    else if (strcmp(entry->tzid, iana) == 0)
      return entry->windows;
  }
 
  return nullptr;
}
#endif
 
const char* TimeZoneIanaToWindows(const char* iana, TimeZoneNameType type)
{
  if (!iana)
    return nullptr;
 
  const char* val = get_for_type(iana, type, iana_cmp);
  if (val)
    return val;
 
  const char* wzid = map_fallback(iana, type);
  if (!wzid)
    return nullptr;
 
  return get_for_type(wzid, type, id_cmp);
}