Milestone 5: deliver embedded RDP sessions and lifecycle hardening
This commit is contained in:
Keith Smith
408
third_party/FreeRDP/winpr/libwinpr/timezone/TimeZoneNameMapUtils.c
vendored
Normal file
408
third_party/FreeRDP/winpr/libwinpr/timezone/TimeZoneNameMapUtils.c
vendored
Normal file
@@ -0,0 +1,408 @@
|
||||
/**
|
||||
* WinPR: Windows Portable Runtime
|
||||
* Time Zone Name Map Utils
|
||||
*
|
||||
* Copyright 2024 Armin Novak <anovak@thincast.com>
|
||||
* Copyright 2024 Thincast Technologies GmbH
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
#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);
|
||||
}
|
||||
Reference in New Issue
Block a user