+ file = g_mapped_file_new (filename, FALSE, NULL);
+ if (file != NULL)
+ {
+ zoneinfo = g_bytes_new_with_free_func (g_mapped_file_get_contents (file),
+ g_mapped_file_get_length (file),
+ (GDestroyNotify)g_mapped_file_unref,
+ g_mapped_file_ref (file));
+ g_mapped_file_unref (file);
+ }
+ g_free (filename);
+ return zoneinfo;
+}
+
+static void
+init_zone_from_iana_info (GTimeZone *gtz, GBytes *zoneinfo)
+{
+ gsize size;
+ guint index;
+ guint32 time_count, type_count;
+ guint8 *tz_transitions, *tz_type_index, *tz_ttinfo;
+ guint8 *tz_abbrs;
+ gsize timesize = sizeof (gint32);
+ const struct tzhead *header = g_bytes_get_data (zoneinfo, &size);
+
+ g_return_if_fail (size >= sizeof (struct tzhead) &&
+ memcmp (header, "TZif", 4) == 0);
+
+ if (header->tzh_version == '2')
+ {
+ /* Skip ahead to the newer 64-bit data if it's available. */
+ header = (const struct tzhead *)
+ (((const gchar *) (header + 1)) +
+ guint32_from_be(header->tzh_ttisgmtcnt) +
+ guint32_from_be(header->tzh_ttisstdcnt) +
+ 8 * guint32_from_be(header->tzh_leapcnt) +
+ 5 * guint32_from_be(header->tzh_timecnt) +
+ 6 * guint32_from_be(header->tzh_typecnt) +
+ guint32_from_be(header->tzh_charcnt));
+ timesize = sizeof (gint64);
+ }
+ time_count = guint32_from_be(header->tzh_timecnt);
+ type_count = guint32_from_be(header->tzh_typecnt);
+
+ tz_transitions = ((guint8 *) (header) + sizeof (*header));
+ tz_type_index = tz_transitions + timesize * time_count;
+ tz_ttinfo = tz_type_index + time_count;
+ tz_abbrs = tz_ttinfo + sizeof (struct ttinfo) * type_count;
+
+ gtz->t_info = g_array_sized_new (FALSE, TRUE, sizeof (TransitionInfo),
+ type_count);
+ gtz->transitions = g_array_sized_new (FALSE, TRUE, sizeof (Transition),
+ time_count);
+
+ for (index = 0; index < type_count; index++)
+ {
+ TransitionInfo t_info;
+ struct ttinfo info = ((struct ttinfo*)tz_ttinfo)[index];
+ t_info.gmt_offset = gint32_from_be (info.tt_gmtoff);
+ t_info.is_dst = info.tt_isdst ? TRUE : FALSE;
+ t_info.abbrev = g_strdup ((gchar *) &tz_abbrs[info.tt_abbrind]);
+ g_array_append_val (gtz->t_info, t_info);
+ }
+
+ for (index = 0; index < time_count; index++)
+ {
+ Transition trans;
+ if (header->tzh_version == '2')
+ trans.time = gint64_from_be (((gint64_be*)tz_transitions)[index]);
+ else
+ trans.time = gint32_from_be (((gint32_be*)tz_transitions)[index]);
+ trans.info_index = tz_type_index[index];
+ g_assert (trans.info_index >= 0);
+ g_assert (trans.info_index < gtz->t_info->len);
+ g_array_append_val (gtz->transitions, trans);
+ }
+}
+
+#elif defined (G_OS_WIN32)
+
+static void
+copy_windows_systemtime (SYSTEMTIME *s_time, TimeZoneDate *tzdate)
+{
+ tzdate->sec = s_time->wSecond;
+ tzdate->min = s_time->wMinute;
+ tzdate->hour = s_time->wHour;
+ tzdate->mon = s_time->wMonth;
+ tzdate->year = s_time->wYear;
+ tzdate->wday = s_time->wDayOfWeek ? s_time->wDayOfWeek : 7;
+
+ if (s_time->wYear)
+ {
+ tzdate->mday = s_time->wDay;
+ tzdate->wday = 0;
+ }
+ else
+ tzdate->week = s_time->wDay;
+}
+
+/* UTC = local time + bias while local time = UTC + offset */
+static void
+rule_from_windows_time_zone_info (TimeZoneRule *rule,
+ TIME_ZONE_INFORMATION *tzi)
+{
+ /* Set offset */
+ if (tzi->StandardDate.wMonth)
+ {
+ rule->std_offset = -(tzi->Bias + tzi->StandardBias) * 60;
+ rule->dlt_offset = -(tzi->Bias + tzi->DaylightBias) * 60;
+ copy_windows_systemtime (&(tzi->DaylightDate), &(rule->dlt_start));
+
+ copy_windows_systemtime (&(tzi->StandardDate), &(rule->dlt_end));
+
+ }
+
+ else
+ {
+ rule->std_offset = -tzi->Bias * 60;
+ rule->dlt_start.mon = 0;
+ }
+ strncpy (rule->std_name, (gchar*)tzi->StandardName, NAME_SIZE - 1);
+ strncpy (rule->dlt_name, (gchar*)tzi->DaylightName, NAME_SIZE - 1);
+}
+
+static gchar*
+windows_default_tzname (void)
+{
+ const gchar *subkey =
+ "SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation";
+ HKEY key;
+ gchar *key_name = NULL;
+ if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, subkey, 0,
+ KEY_QUERY_VALUE, &key) == ERROR_SUCCESS)
+ {
+ DWORD size = 0;
+ if (RegQueryValueExA (key, "TimeZoneKeyName", NULL, NULL,
+ NULL, &size) == ERROR_SUCCESS)
+ {
+ key_name = g_malloc ((gint)size);
+ if (RegQueryValueExA (key, "TimeZoneKeyName", NULL, NULL,
+ (LPBYTE)key_name, &size) != ERROR_SUCCESS)
+ {
+ g_free (key_name);
+ key_name = NULL;
+ }
+ }
+ RegCloseKey (key);
+ }
+ return key_name;
+}
+
+typedef struct
+{
+ LONG Bias;
+ LONG StandardBias;
+ LONG DaylightBias;
+ SYSTEMTIME StandardDate;
+ SYSTEMTIME DaylightDate;
+} RegTZI;
+
+static void
+system_time_copy (SYSTEMTIME *orig, SYSTEMTIME *target)
+{
+ g_return_if_fail (orig != NULL);
+ g_return_if_fail (target != NULL);
+
+ target->wYear = orig->wYear;
+ target->wMonth = orig->wMonth;
+ target->wDayOfWeek = orig->wDayOfWeek;
+ target->wDay = orig->wDay;
+ target->wHour = orig->wHour;
+ target->wMinute = orig->wMinute;
+ target->wSecond = orig->wSecond;
+ target->wMilliseconds = orig->wMilliseconds;
+}
+
+static void
+register_tzi_to_tzi (RegTZI *reg, TIME_ZONE_INFORMATION *tzi)
+{
+ g_return_if_fail (reg != NULL);
+ g_return_if_fail (tzi != NULL);
+ tzi->Bias = reg->Bias;
+ system_time_copy (&(reg->StandardDate), &(tzi->StandardDate));
+ tzi->StandardBias = reg->StandardBias;
+ system_time_copy (&(reg->DaylightDate), &(tzi->DaylightDate));
+ tzi->DaylightBias = reg->DaylightBias;
+}
+
+static gint
+rules_from_windows_time_zone (const gchar *identifier, TimeZoneRule **rules)
+{
+ HKEY key;
+ gchar *subkey, *subkey_dynamic;
+ gchar *key_name = NULL;
+ const gchar *reg_key =
+ "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\";
+ TIME_ZONE_INFORMATION tzi;
+ DWORD size;
+ gint rules_num = 0;
+ RegTZI regtzi, regtzi_prev;
+
+ *rules = NULL;
+ key_name = NULL;
+
+ if (!identifier)
+ key_name = windows_default_tzname ();
+ else
+ key_name = g_strdup (identifier);
+
+ if (!key_name)
+ return 0;
+
+ subkey = g_strconcat (reg_key, key_name, NULL);
+ subkey_dynamic = g_strconcat (subkey, "\\Dynamic DST", NULL);
+
+ if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, subkey, 0,
+ KEY_QUERY_VALUE, &key) != ERROR_SUCCESS)
+ return 0;
+ size = sizeof tzi.StandardName;
+ if (RegQueryValueExA (key, "Std", NULL, NULL,
+ (LPBYTE)&(tzi.StandardName), &size) != ERROR_SUCCESS)
+ goto failed;
+
+ size = sizeof tzi.DaylightName;
+
+ if (RegQueryValueExA (key, "Dlt", NULL, NULL,
+ (LPBYTE)&(tzi.DaylightName), &size) != ERROR_SUCCESS)
+ goto failed;
+
+ RegCloseKey (key);
+ if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, subkey_dynamic, 0,
+ KEY_QUERY_VALUE, &key) == ERROR_SUCCESS)
+ {
+ DWORD first, last;
+ int year, i;
+ gchar *s;
+
+ size = sizeof first;
+ if (RegQueryValueExA (key, "FirstEntry", NULL, NULL,
+ (LPBYTE) &first, &size) != ERROR_SUCCESS)
+ goto failed;
+
+ size = sizeof last;
+ if (RegQueryValueExA (key, "LastEntry", NULL, NULL,
+ (LPBYTE) &last, &size) != ERROR_SUCCESS)
+ goto failed;
+
+ rules_num = last - first + 2;
+ *rules = g_new0 (TimeZoneRule, rules_num);
+
+ for (year = first, i = 0; year <= last; year++)
+ {
+ s = g_strdup_printf ("%d", year);
+
+ size = sizeof regtzi;
+ if (RegQueryValueExA (key, s, NULL, NULL,
+ (LPBYTE) ®tzi, &size) != ERROR_SUCCESS)
+ {
+ g_free (*rules);
+ *rules = NULL;
+ break;
+ }
+
+ g_free (s);
+
+ if (year > first && memcmp (®tzi_prev, ®tzi, sizeof regtzi) == 0)
+ continue;
+ else
+ memcpy (®tzi_prev, ®tzi, sizeof regtzi);
+
+ register_tzi_to_tzi (®tzi, &tzi);
+ rule_from_windows_time_zone_info (&(*rules)[i], &tzi);
+ (*rules)[i++].start_year = year;
+ }
+
+ rules_num = i + 1;
+
+failed:
+ RegCloseKey (key);
+ }
+ else if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, subkey, 0,
+ KEY_QUERY_VALUE, &key) == ERROR_SUCCESS)
+ {
+ size = sizeof regtzi;
+ if (RegQueryValueExA (key, "TZI", NULL, NULL,
+ (LPBYTE) ®tzi, &size) == ERROR_SUCCESS)
+ {
+ rules_num = 2;
+ *rules = g_new0 (TimeZoneRule, 2);
+ register_tzi_to_tzi (®tzi, &tzi);
+ rule_from_windows_time_zone_info (&(*rules)[0], &tzi);
+ }
+
+ RegCloseKey (key);
+ }
+
+ g_free (subkey_dynamic);
+ g_free (subkey);
+ g_free (key_name);
+
+ if (*rules)
+ {
+ (*rules)[0].start_year = MIN_TZYEAR;
+ if ((*rules)[rules_num - 2].start_year < MAX_TZYEAR)
+ (*rules)[rules_num - 1].start_year = MAX_TZYEAR;
+ else
+ (*rules)[rules_num - 1].start_year = (*rules)[rules_num - 2].start_year + 1;
+
+ return rules_num;
+ }
+ else
+ return 0;
+}
+
+#endif
+
+static void
+find_relative_date (TimeZoneDate *buffer)
+{
+ gint wday;
+ GDate date;
+ g_date_clear (&date, 1);
+ wday = buffer->wday;
+
+ /* Get last day if last is needed, first day otherwise */
+ if (buffer->mon == 13 || buffer->mon == 14) /* Julian Date */
+ {
+ g_date_set_dmy (&date, 1, 1, buffer->year);
+ if (wday >= 59 && buffer->mon == 13 && g_date_is_leap_year (buffer->year))
+ g_date_add_days (&date, wday);
+ else
+ g_date_add_days (&date, wday - 1);
+ buffer->mon = (int) g_date_get_month (&date);
+ buffer->mday = (int) g_date_get_day (&date);
+ buffer->wday = 0;
+ }
+ else /* M.W.D */
+ {
+ guint days;
+ guint days_in_month = g_date_days_in_month (buffer->mon, buffer->year);
+ GDateWeekday first_wday;
+
+ g_date_set_dmy (&date, 1, buffer->mon, buffer->year);
+ first_wday = g_date_get_weekday (&date);
+
+ if (first_wday > wday)
+ ++(buffer->week);
+ /* week is 1 <= w <= 5, we need 0-based */
+ days = 7 * (buffer->week - 1) + wday - first_wday;
+
+ while (days > days_in_month)
+ days -= 7;
+
+ g_date_add_days (&date, days);
+
+ buffer->mday = g_date_get_day (&date);
+ }
+}
+
+/* Offset is previous offset of local time. Returns 0 if month is 0 */
+static gint64
+boundary_for_year (TimeZoneDate *boundary,
+ gint year,
+ gint32 offset)
+{
+ TimeZoneDate buffer;
+ GDate date;
+ const guint64 unix_epoch_start = 719163L;
+ const guint64 seconds_per_day = 86400L;
+
+ if (!boundary->mon)
+ return 0;
+ buffer = *boundary;
+
+ if (boundary->year == 0)
+ {
+ buffer.year = year;
+
+ if (buffer.wday)
+ find_relative_date (&buffer);
+ }
+
+ g_assert (buffer.year == year);
+ g_date_clear (&date, 1);
+ g_date_set_dmy (&date, buffer.mday, buffer.mon, buffer.year);
+ return ((g_date_get_julian (&date) - unix_epoch_start) * seconds_per_day +
+ buffer.hour * 3600 + buffer.min * 60 + buffer.sec - offset);
+}
+
+static void
+fill_transition_info_from_rule (TransitionInfo *info,
+ TimeZoneRule *rule,
+ gboolean is_dst)
+{
+ gint offset = is_dst ? rule->dlt_offset : rule->std_offset;
+ gchar *name = is_dst ? rule->dlt_name : rule->std_name;
+
+ info->gmt_offset = offset;
+ info->is_dst = is_dst;
+
+ if (name)
+ info->abbrev = g_strdup (name);
+
+ else
+ info->abbrev = g_strdup_printf ("%+03d%02d",
+ (int) offset / 3600,
+ (int) abs (offset / 60) % 60);
+}
+
+static void
+init_zone_from_rules (GTimeZone *gtz,
+ TimeZoneRule *rules,
+ gint rules_num)
+{
+ guint type_count = 0, trans_count = 0, info_index = 0;
+ guint ri; /* rule index */
+ gboolean skip_first_std_trans = TRUE;
+ gint32 last_offset;
+
+ type_count = 0;
+ trans_count = 0;
+
+ /* Last rule only contains max year */
+ for (ri = 0; ri < rules_num - 1; ri++)
+ {
+ if (rules[ri].dlt_start.mon || rules[ri].dlt_end.mon)
+ {
+ guint rulespan = (rules[ri + 1].start_year - rules[ri].start_year);
+ guint transitions = rules[ri].dlt_start.mon > 0 ? 1 : 0;
+ transitions += rules[ri].dlt_end.mon > 0 ? 1 : 0;
+ type_count += rules[ri].dlt_start.mon > 0 ? 2 : 1;
+ trans_count += transitions * rulespan;
+ }
+ else
+ type_count++;
+ }
+
+ gtz->t_info = g_array_sized_new (FALSE, TRUE, sizeof (TransitionInfo), type_count);
+ gtz->transitions = g_array_sized_new (FALSE, TRUE, sizeof (Transition), trans_count);
+
+ last_offset = rules[0].std_offset;
+
+ for (ri = 0; ri < rules_num - 1; ri++)
+ {
+ if ((rules[ri].std_offset || rules[ri].dlt_offset) &&
+ rules[ri].dlt_start.mon == 0 && rules[ri].dlt_end.mon == 0)
+ {
+ TransitionInfo std_info;
+ /* Standard */
+ fill_transition_info_from_rule (&std_info, &(rules[ri]), FALSE);
+ g_array_append_val (gtz->t_info, std_info);
+
+ if (ri > 0 &&
+ ((rules[ri - 1].dlt_start.mon > 12 &&
+ rules[ri - 1].dlt_start.wday > rules[ri - 1].dlt_end.wday) ||
+ rules[ri - 1].dlt_start.mon > rules[ri - 1].dlt_end.mon))
+ {
+ /* The previous rule was a southern hemisphere rule that
+ starts the year with DST, so we need to add a
+ transition to return to standard time */
+ guint year = rules[ri].start_year;
+ gint64 std_time = boundary_for_year (&rules[ri].dlt_end,
+ year, last_offset);
+ Transition std_trans = {std_time, info_index};
+ g_array_append_val (gtz->transitions, std_trans);
+
+ }
+ last_offset = rules[ri].std_offset;
+ ++info_index;
+ skip_first_std_trans = TRUE;
+ }
+ else if (rules[ri].std_offset || rules[ri].dlt_offset)
+ {
+ const guint start_year = rules[ri].start_year;
+ const guint end_year = rules[ri + 1].start_year;
+ gboolean dlt_first;
+ guint year;
+ TransitionInfo std_info, dlt_info;
+ if (rules[ri].dlt_start.mon > 12)
+ dlt_first = rules[ri].dlt_start.wday > rules[ri].dlt_end.wday;
+ else
+ dlt_first = rules[ri].dlt_start.mon > rules[ri].dlt_end.mon;
+ /* Standard rules are always even, because before the first
+ transition is always standard time, and 0 is even. */
+ fill_transition_info_from_rule (&std_info, &(rules[ri]), FALSE);
+ fill_transition_info_from_rule (&dlt_info, &(rules[ri]), TRUE);
+
+ g_array_append_val (gtz->t_info, std_info);
+ g_array_append_val (gtz->t_info, dlt_info);
+
+ /* Transition dates. We hope that a year which ends daylight
+ time in a southern-hemisphere country (i.e., one that
+ begins the year in daylight time) will include a rule
+ which has only a dlt_end. */
+ for (year = start_year; year < end_year; year++)
+ {
+ gint32 dlt_offset = (dlt_first ? last_offset :
+ rules[ri].dlt_offset);
+ gint32 std_offset = (dlt_first ? rules[ri].std_offset :
+ last_offset);
+ /* NB: boundary_for_year returns 0 if mon == 0 */
+ gint64 std_time = boundary_for_year (&rules[ri].dlt_end,
+ year, dlt_offset);
+ gint64 dlt_time = boundary_for_year (&rules[ri].dlt_start,
+ year, std_offset);
+ Transition std_trans = {std_time, info_index};
+ Transition dlt_trans = {dlt_time, info_index + 1};
+ last_offset = (dlt_first ? rules[ri].dlt_offset :
+ rules[ri].std_offset);
+ if (dlt_first)
+ {
+ if (skip_first_std_trans)
+ skip_first_std_trans = FALSE;
+ else if (std_time)
+ g_array_append_val (gtz->transitions, std_trans);
+ if (dlt_time)
+ g_array_append_val (gtz->transitions, dlt_trans);
+ }
+ else
+ {
+ if (dlt_time)
+ g_array_append_val (gtz->transitions, dlt_trans);
+ if (std_time)
+ g_array_append_val (gtz->transitions, std_trans);
+ }
+ }
+
+ info_index += 2;
+ }
+ }
+ if (ri > 0 &&
+ ((rules[ri - 1].dlt_start.mon > 12 &&
+ rules[ri - 1].dlt_start.wday > rules[ri - 1].dlt_end.wday) ||
+ rules[ri - 1].dlt_start.mon > rules[ri - 1].dlt_end.mon))
+ {
+ /* The previous rule was a southern hemisphere rule that
+ starts the year with DST, so we need to add a
+ transition to return to standard time */
+ TransitionInfo info;
+ guint year = rules[ri].start_year;
+ Transition trans;
+ fill_transition_info_from_rule (&info, &(rules[ri - 1]), FALSE);
+ g_array_append_val (gtz->t_info, info);
+ trans.time = boundary_for_year (&rules[ri - 1].dlt_end,
+ year, last_offset);
+ trans.info_index = info_index;
+ g_array_append_val (gtz->transitions, trans);
+ }
+}
+
+/*
+ * parses date[/time] for parsing TZ environment variable
+ *
+ * date is either Mm.w.d, Jn or N
+ * - m is 1 to 12
+ * - w is 1 to 5
+ * - d is 0 to 6
+ * - n is 1 to 365
+ * - N is 0 to 365
+ *
+ * time is either h or hh[[:]mm[[[:]ss]]]
+ * - h[h] is 0 to 23
+ * - mm is 00 to 59
+ * - ss is 00 to 59
+ */
+static gboolean
+parse_mwd_boundary (gchar **pos, TimeZoneDate *boundary)
+{
+ gint month, week, day;
+
+ if (**pos == '\0' || **pos < '0' || '9' < **pos)
+ return FALSE;
+
+ month = *(*pos)++ - '0';
+
+ if ((month == 1 && **pos >= '0' && '2' >= **pos) ||
+ (month == 0 && **pos >= '0' && '9' >= **pos))
+ {
+ month *= 10;
+ month += *(*pos)++ - '0';
+ }
+
+ if (*(*pos)++ != '.' || month == 0)
+ return FALSE;
+
+ if (**pos == '\0' || **pos < '1' || '5' < **pos)
+ return FALSE;
+
+ week = *(*pos)++ - '0';
+
+ if (*(*pos)++ != '.')
+ return FALSE;
+
+ if (**pos == '\0' || **pos < '0' || '6' < **pos)
+ return FALSE;
+
+ day = *(*pos)++ - '0';
+
+ if (!day)
+ day += 7;
+
+ boundary->year = 0;
+ boundary->mon = month;
+ boundary->week = week;
+ boundary->wday = day;
+ return TRUE;
+}
+
+/* Different implementations of tzset interpret the Julian day field
+ differently. For example, Linux specifies that it should be 1-based
+ (1 Jan is JD 1) for both Jn and n formats, while zOS and BSD
+ specify that a Jn JD is 1-based while an n JD is 0-based. Rather
+ than trying to follow different specs, we will follow GDate's
+ practice thatIn order to keep it simple, we will follow Linux's
+ practice. */
+
+static gboolean
+parse_julian_boundary (gchar** pos, TimeZoneDate *boundary,
+ gboolean ignore_leap)
+{
+ gint day = 0;
+ GDate date;
+
+ while (**pos >= '0' && '9' >= **pos)
+ {
+ day *= 10;
+ day += *(*pos)++ - '0';
+ }
+
+ if (day < 1 || 365 < day)
+ return FALSE;
+
+ g_date_clear (&date, 1);
+ g_date_set_julian (&date, day);
+ boundary->year = 0;
+ boundary->mon = (int) g_date_get_month (&date);
+ boundary->mday = (int) g_date_get_day (&date);
+ boundary->wday = 0;
+
+ if (!ignore_leap && day >= 59)
+ boundary->mday++;
+
+ return TRUE;
+}
+
+static gboolean
+parse_tz_boundary (const gchar *identifier,
+ TimeZoneDate *boundary)
+{
+ gchar *pos;
+
+ pos = (gchar*)identifier;
+ /* Month-week-weekday */
+ if (*pos == 'M')
+ {
+ ++pos;
+ if (!parse_mwd_boundary (&pos, boundary))
+ return FALSE;
+ }
+ /* Julian date which ignores Feb 29 in leap years */
+ else if (*pos == 'J')
+ {
+ ++pos;
+ if (!parse_julian_boundary (&pos, boundary, FALSE))
+ return FALSE ;
+ }
+ /* Julian date which counts Feb 29 in leap years */
+ else if (*pos >= '0' && '9' >= *pos)
+ {
+ if (!parse_julian_boundary (&pos, boundary, TRUE))
+ return FALSE;
+ }
+ else
+ return FALSE;
+
+ /* Time */
+
+ if (*pos == '/')
+ {
+ gint32 offset;
+
+ if (!parse_time (++pos, &offset))
+ return FALSE;
+
+ boundary->hour = offset / 3600;
+ boundary->min = (offset / 60) % 60;
+ boundary->sec = offset % 3600;
+
+ return TRUE;
+ }
+
+ else
+ {
+ boundary->hour = 2;
+ boundary->min = 0;
+ boundary->sec = 0;
+
+ return *pos == '\0';
+ }
+}
+
+static gint
+create_ruleset_from_rule (TimeZoneRule **rules, TimeZoneRule *rule)
+{
+ *rules = g_new0 (TimeZoneRule, 2);
+
+ (*rules)[0].start_year = MIN_TZYEAR;
+ (*rules)[1].start_year = MAX_TZYEAR;
+
+ (*rules)[0].std_offset = -rule->std_offset;
+ (*rules)[0].dlt_offset = -rule->dlt_offset;
+ (*rules)[0].dlt_start = rule->dlt_start;
+ (*rules)[0].dlt_end = rule->dlt_end;
+ strcpy ((*rules)[0].std_name, rule->std_name);
+ strcpy ((*rules)[0].dlt_name, rule->dlt_name);
+ return 2;
+}
+
+static gboolean
+parse_offset (gchar **pos, gint32 *target)
+{
+ gchar *buffer;
+ gchar *target_pos = *pos;
+ gboolean ret;
+
+ while (**pos == '+' || **pos == '-' || **pos == ':' ||
+ (**pos >= '0' && '9' >= **pos))
+ ++(*pos);
+
+ buffer = g_strndup (target_pos, *pos - target_pos);
+ ret = parse_constant_offset (buffer, target);
+ g_free (buffer);
+
+ return ret;
+}
+
+static gboolean
+parse_identifier_boundary (gchar **pos, TimeZoneDate *target)
+{
+ gchar *buffer;
+ gchar *target_pos = *pos;
+ gboolean ret;
+
+ while (**pos != ',' && **pos != '\0')
+ ++(*pos);
+ buffer = g_strndup (target_pos, *pos - target_pos);
+ ret = parse_tz_boundary (buffer, target);
+ g_free (buffer);
+
+ return ret;
+}
+
+static gboolean
+set_tz_name (gchar **pos, gchar *buffer, guint size)
+{
+ gchar *name_pos = *pos;
+ guint len;
+
+ /* Name is ASCII alpha (Is this necessarily true?) */
+ while (g_ascii_isalpha (**pos))
+ ++(*pos);
+
+ /* Name should be three or more alphabetic characters */
+ if (*pos - name_pos < 3)
+ return FALSE;
+
+ memset (buffer, 0, NAME_SIZE);
+ /* name_pos isn't 0-terminated, so we have to limit the length expressly */
+ len = *pos - name_pos > size - 1 ? size - 1 : *pos - name_pos;
+ strncpy (buffer, name_pos, len);
+ return TRUE;
+}
+
+static gboolean
+parse_identifier_boundaries (gchar **pos, TimeZoneRule *tzr)
+{
+ if (*(*pos)++ != ',')
+ return FALSE;
+
+ /* Start date */
+ if (!parse_identifier_boundary (pos, &(tzr->dlt_start)) || *(*pos)++ != ',')
+ return FALSE;
+
+ /* End date */
+ if (!parse_identifier_boundary (pos, &(tzr->dlt_end)))
+ return FALSE;
+ return TRUE;
+}
+
+/*
+ * Creates an array of TimeZoneRule from a TZ environment variable
+ * type of identifier. Should free rules afterwards
+ */
+static gint
+rules_from_identifier (const gchar *identifier,
+ TimeZoneRule **rules)
+{
+ gchar *pos;
+ TimeZoneRule tzr;
+
+ if (!identifier)
+ return 0;
+
+ pos = (gchar*)identifier;
+ memset (&tzr, 0, sizeof (tzr));
+ /* Standard offset */
+ if (!(set_tz_name (&pos, tzr.std_name, NAME_SIZE)) ||
+ !parse_offset (&pos, &(tzr.std_offset)))
+ return 0;
+
+ if (*pos == 0)
+ return create_ruleset_from_rule (rules, &tzr);
+
+ /* Format 2 */
+ if (!(set_tz_name (&pos, tzr.dlt_name, NAME_SIZE)))
+ return 0;
+ parse_offset (&pos, &(tzr.dlt_offset));
+ if (tzr.dlt_offset == 0) /* No daylight offset given, assume it's 1
+ hour earlier that standard */
+ tzr.dlt_offset = tzr.std_offset - 3600;
+ if (*pos == '\0')
+#ifdef G_OS_WIN32
+ /* Windows allows us to use the US DST boundaries if they're not given */
+ {
+ int i;
+ guint rules_num = 0;
+
+ /* Use US rules, Windows' default is Pacific Standard Time */
+ if ((rules_num = rules_from_windows_time_zone ("Pacific Standard Time",
+ rules)))
+ {
+ for (i = 0; i < rules_num - 1; i++)
+ {
+ (*rules)[i].std_offset = - tzr.std_offset;
+ (*rules)[i].dlt_offset = - tzr.dlt_offset;
+ strcpy ((*rules)[i].std_name, tzr.std_name);
+ strcpy ((*rules)[i].dlt_name, tzr.dlt_name);
+ }
+
+ return rules_num;
+ }
+ else
+ return 0;
+ }
+#else
+ return 0;
+#endif
+ /* Start and end required (format 2) */
+ if (!parse_identifier_boundaries (&pos, &tzr))
+ return 0;
+
+ return create_ruleset_from_rule (rules, &tzr);