/* Helper function for getSystemTimeZoneID() that compares the
zoneinfo_file_path (regular) file with files in the zoneinfo_dir_path until
it finds a match. The matching file's name is used to determine the time
zone ID. */
static QString findZoneinfoFile(QString zoneinfo_file_path,
QString zoneinfo_dir_path)
{
QString zone_id("UNDEF");
QDir zoneinfo_dir(zoneinfo_dir_path);
QFileInfoList dirlist = zoneinfo_dir.entryInfoList();
QFileInfo info;
QString basename;
QFileInfo zoneinfo_file_info(zoneinfo_file_path);
for (QFileInfoList::const_iterator it = dirlist.begin();
it != dirlist.end(); ++it)
{
info = *it;
// Skip '.' and '..' and other files starting with "." and
// skip localtime (which is often a link to zoneinfo_file_path)
basename = info.baseName();
if (basename.isEmpty() || (basename == "localtime")) {
continue;
}
if (info.isDir())
{
zone_id = findZoneinfoFile(zoneinfo_file_path,
info.absoluteFilePath());
if (zone_id != "UNDEF")
return zone_id;
}
else if (compare_zone_files(zoneinfo_file_info, info))
{
zone_id = info.absoluteFilePath();
break;
}
}
return zone_id;
}
/** \fn getTimeZoneID()
* \brief Returns the zoneinfo time zone ID or as much time zone information
* as possible
*/
QString getTimeZoneID(void)
{
QString zone_id("UNDEF");
#ifndef _WIN32
// First, try the TZ environment variable to check for environment-specific
// overrides
QString tz = getenv("TZ");
if (tz.isEmpty())
{
// No TZ, so attempt to determine the system-configured time zone ID
tz = getSystemTimeZoneID();
}
if (!tz.isEmpty())
{
zone_id = tz;
if (zone_id.startsWith("\"") || zone_id.startsWith("'"))
zone_id.remove(0, 1);
if (zone_id.endsWith("\"") || zone_id.endsWith("'"))
zone_id.chop(1);
if (zone_id.startsWith(":"))
zone_id.remove(0, 1);
// the "posix/" subdirectory typically contains the same files as the
// "zoneinfo/" parent directory, but are not typically what are in use
if (zone_id.startsWith("posix/"))
zone_id.remove(0, 6);
}
#endif
return zone_id;
}
static void TimeZoneNames_fillZoneStrings(JNIEnv* env, jclass, jstring javaLocaleName, jobjectArray result) {
ScopedIcuLocale icuLocale(env, javaLocaleName);
if (!icuLocale.valid()) {
return;
}
UErrorCode status = U_ZERO_ERROR;
UniquePtr<TimeZoneNames> names(TimeZoneNames::createInstance(icuLocale.locale(), status));
if (maybeThrowIcuException(env, "TimeZoneNames::createInstance", status)) {
return;
}
const UDate now(Calendar::getNow());
static const UnicodeString kUtc("UTC", 3, US_INV);
size_t id_count = env->GetArrayLength(result);
for (size_t i = 0; i < id_count; ++i) {
ScopedLocalRef<jobjectArray> java_row(env,
reinterpret_cast<jobjectArray>(env->GetObjectArrayElement(result, i)));
ScopedLocalRef<jstring> java_zone_id(env,
reinterpret_cast<jstring>(env->GetObjectArrayElement(java_row.get(), 0)));
ScopedJavaUnicodeString zone_id(env, java_zone_id.get());
if (!zone_id.valid()) {
return;
}
UnicodeString long_std;
names->getDisplayName(zone_id.unicodeString(), UTZNM_LONG_STANDARD, now, long_std);
UnicodeString short_std;
names->getDisplayName(zone_id.unicodeString(), UTZNM_SHORT_STANDARD, now, short_std);
UnicodeString long_dst;
names->getDisplayName(zone_id.unicodeString(), UTZNM_LONG_DAYLIGHT, now, long_dst);
UnicodeString short_dst;
names->getDisplayName(zone_id.unicodeString(), UTZNM_SHORT_DAYLIGHT, now, short_dst);
if (isUtc(zone_id.unicodeString())) {
// ICU doesn't have names for the UTC zones; it just says "GMT+00:00" for both
// long and short names. We don't want this. The best we can do is use "UTC"
// for everything (since we don't know how to say "Universal Coordinated Time" in
// every language).
// TODO: check CLDR doesn't actually have this somewhere.
long_std = short_std = long_dst = short_dst = kUtc;
}
bool okay =
setStringArrayElement(env, java_row.get(), 1, long_std) &&
setStringArrayElement(env, java_row.get(), 2, short_std) &&
setStringArrayElement(env, java_row.get(), 3, long_dst) &&
setStringArrayElement(env, java_row.get(), 4, short_dst);
if (!okay) {
return;
}
}
}
/* Helper function for getTimeZoneID() that provides an unprocessed time zone
id obtained using system-dependent means of identifying the system's time
zone. */
static QString getSystemTimeZoneID(void)
{
QString zone_id("UNDEF");
#ifdef _WIN32
// typedef struct _TIME_ZONE_INFORMATION { ...
// GetTimeZoneInformation();
// ...
// Sadly, Windows zone names are different to the (probably Unix)
// backend's names - "AUS Eastern Standard Time" vs "Australia/Sydney".
// Translation is not worthwhile. Leave it as UNDEF to check the offset.
#else
// Try to determine the time zone information by inspecting the system
// configuration
QString time_zone_file_path("/etc/timezone");
QString clock_file_path("/etc/sysconfig/clock");
QString zoneinfo_file_path("/etc/localtime");
QString zoneinfo_dir_path("/usr/share/zoneinfo");
// First, check time_zone_file_path (used by Debian-based systems)
if (read_time_zone_id(time_zone_file_path, zone_id))
return zone_id;
// Next, look for the ZONE entry in clock_file_path (used by Red Hat-based
// systems)
if (read_time_zone_id(clock_file_path, zone_id))
return zone_id;
// Next check zoneinfo_file_path
QFile zoneinfo_file(zoneinfo_file_path);
QFileInfo info(zoneinfo_file);
if (info.exists() && info.isFile())
{
QString tz;
if (info.isSymLink())
{
// The symlink refers to a file whose name contains the zone ID
tz = info.symLinkTarget();
}
else
{
// The zoneinfo_file is a copy of the file in the
// zoneinfo_dir_path, so search for the same file in
// zoneinfo_dir_path
tz = findZoneinfoFile(zoneinfo_file_path, zoneinfo_dir_path);
}
if (tz != "UNDEF")
{
int pos = 0;
// Get the zone ID from the filename
// Look for the basename of zoneinfo_dir_path in case it's a
// relative link
QString zoneinfo_dirname = zoneinfo_dir_path.section('/', -1);
if ((pos = tz.indexOf(zoneinfo_dirname)) != -1)
{
zone_id = tz.right(tz.size() - (pos + 1) -
zoneinfo_dirname.size());
}
}
else
{
// If we still haven't found a time zone, try localtime_r() to at
// least get the zone name/abbreviation (as opposed to the
// identifier for the set of rules governing the zone)
char name[64];
time_t t;
struct tm *result = (struct tm *)malloc(sizeof(*result));
if (result != NULL)
{
t = time(NULL);
localtime_r(&t, result);
if (result != NULL)
{
if (strftime(name, sizeof(name), "%Z", result) > 0)
zone_id = name;
free(result);
}
}
}
}
#endif
return zone_id;
}
void time_controller::PrivateClockController::setup_create_clock_ui(
time_controller *a_controller, cherry_kit::session_sync *a_session) {
cherry_kit::window *ck_window = new cherry_kit::window();
cherry_kit::fixed_layout *ck_ui = new cherry_kit::fixed_layout(ck_window);
cherry_kit::icon_button *ck_location_btn = 0;
cherry_kit::clock_view *ck_clock = 0;
ck_ui->set_content_margin(10, 10, 10, 10);
ck_ui->set_geometry(0, 0, 240, 240);
ck_ui->add_rows(2);
ck_ui->add_segments(0, 1);
ck_ui->add_segments(1, 1);
ck_ui->set_row_height(0, "90%");
ck_ui->set_row_height(1, "10%");
/*
ck_ui->set_segment_width(1, 0, "20%");
ck_ui->set_segment_width(1, 1, "70%");
ck_ui->set_segment_width(1, 2, "10%");
*/
cherry_kit::widget_properties_t ui_data;
ui_data["text"] + "";
ck_clock = dynamic_cast<cherry_kit::clock_view *>(
ck_ui->add_widget(0, 0, "clock", ui_data, [=]() {
}));
ck_location_btn = add_action_button(ck_ui, 1, 0, "", "ck_location");
ck_location_btn->hide();
ck_window->set_window_content(ck_ui->viewport());
ck_window->set_window_title("Time");
a_session->bind_to_window(ck_window);
ck_window->on_window_discarded([=](cherry_kit::window *aWindow) {
a_session->unbind_window(ck_window);
delete aWindow;
});
if (a_session->session_keys().contains("zone_id")) {
ck_clock->set_timezone_id(a_session->session_data("zone_id").toByteArray());
ck_window->set_window_title(a_session->session_data("zone_id").toString());
}
if (a_controller->viewport()) {
a_controller->insert(ck_window);
QPointF window_location;
window_location.setX(a_session->session_data("x").toFloat());
window_location.setY(a_session->session_data("y").toFloat());
ck_window->setPos(window_location);
}
ck_location_btn->on_click([=]() {
if (a_controller && a_controller->viewport()) {
cherry_kit::space *ck_space = a_controller->viewport();
QPointF _activity_window_location = ck_space->center(
QRectF(0, 0, 240, 240), QRectF(ck_window->x(), ck_window->y(),
ck_window->geometry().width(),
ck_window->geometry().height()),
cherry_kit::space::kCenterOnWindow);
cherry_kit::desktop_dialog_ref activity = ck_space->open_desktop_dialog(
"timezone_dialog", "TimeZone", _activity_window_location,
QRectF(0, 0, 240, 240), QVariantMap());
activity->on_action_completed([=](const QVariantMap &a_data) {
ck_clock->set_timezone_id(a_data["zone_id"].toByteArray());
ck_window->set_window_title(a_data["zone_id"].toString());
std::string zone_id(a_data["zone_id"].toByteArray().data());
a_session->save_session_attribute(
a_controller->session_store_name("clock"), "Clock", "clock_id",
a_session->session_id_to_string(), "zone_id", zone_id);
});
}
});
}
static int
perform_keystate_list(int sockfd, db_connection_t *dbconn,
const char* filterZone, char** filterKeytype, char** filterKeystate,
void (printheader)(int sockfd),
void (printkey)(int sockfd, zone_t* zone, key_data_t* key, char*tchange, hsm_key_t* hsmKey)) {
key_data_list_t* key_list;
key_data_t* key;
zone_t *zone = NULL;
char* tchange;
hsm_key_t *hsmkey;
int cmp;
int i, skipPrintKey;
if (!(key_list = key_data_list_new_get(dbconn))) {
client_printf_err(sockfd, "Unable to get list of keys, memory "
"allocation or database error!\n");
return 1;
}
if (printheader) {
(*printheader)(sockfd);
}
while ((key = key_data_list_get_next(key_list))) {
/* only refetches zone if different from previous */
if (zone
&& (db_value_cmp(zone_id(zone), key_data_zone_id(key), &cmp)
|| cmp)) {
zone_free(zone);
zone = NULL;
}
if (!zone) {
zone = key_data_get_zone(key);
}
hsmkey = key_data_get_hsm_key(key);
key_data_cache_key_states(key);
tchange = map_keytime(zone, key); /* allocs */
skipPrintKey = 0;
if(printkey == NULL)
skipPrintKey = 1;
if(filterZone != NULL && strcmp(zone_name(zone), filterZone))
skipPrintKey = 1;
for(i=0; filterKeytype && filterKeytype[i]; i++)
if(!strcasecmp(filterKeytype[i],key_data_role_text(key)))
break;
if(filterKeytype && filterKeytype[i] == NULL)
skipPrintKey = 1;
for(i=0; filterKeystate && filterKeystate[i]; i++)
if(!strcasecmp(filterKeystate[i],map_keystate(key)))
break;
if(filterKeystate && filterKeystate[i] == NULL)
skipPrintKey = 1;
if (!skipPrintKey) {
(*printkey)(sockfd, zone, key, tchange, hsmkey);
}
free(tchange);
hsm_key_free(hsmkey);
key_data_free(key);
}
zone_free(zone);
key_data_list_free(key_list);
return 0;
}