static int get_days_remaining(ASN1_UTCTIME *tm) { apr_time_t then, now = apr_time_now(); apr_time_exp_t exp = {0}; int diff; /* Fail if the time isn't a valid ASN.1 UTCTIME; RFC3280 mandates * that the seconds digits are present even though ASN.1 * doesn't. */ if (tm->length < 11 || !ASN1_UTCTIME_check(tm)) return 0; exp.tm_year = DIGIT2NUM(tm->data); exp.tm_mon = DIGIT2NUM(tm->data + 2) - 1; exp.tm_mday = DIGIT2NUM(tm->data + 4) + 1; exp.tm_hour = DIGIT2NUM(tm->data + 6); exp.tm_min = DIGIT2NUM(tm->data + 8); exp.tm_sec = DIGIT2NUM(tm->data + 10); if (exp.tm_year <= 50) exp.tm_year += 100; if (apr_time_exp_gmt_get(&then, &exp) != APR_SUCCESS) return 0; diff = (int)((apr_time_sec(then) - apr_time_sec(now)) / (60*60*24)); return diff > 0 ? diff : 0; }
bool LLDate::fromStream(std::istream& s) { struct apr_time_exp_t exp_time; apr_int32_t tm_part; int c; s >> tm_part; exp_time.tm_year = tm_part - 1900; c = s.get(); // skip the hypen if (c != '-') { return false; } s >> tm_part; exp_time.tm_mon = tm_part - 1; c = s.get(); // skip the hypen if (c != '-') { return false; } s >> tm_part; exp_time.tm_mday = tm_part; c = s.get(); // skip the T if (c != 'T') { return false; } s >> tm_part; exp_time.tm_hour = tm_part; c = s.get(); // skip the : if (c != ':') { return false; } s >> tm_part; exp_time.tm_min = tm_part; c = s.get(); // skip the : if (c != ':') { return false; } s >> tm_part; exp_time.tm_sec = tm_part; // zero out the unused fields exp_time.tm_usec = 0; exp_time.tm_wday = 0; exp_time.tm_yday = 0; exp_time.tm_isdst = 0; exp_time.tm_gmtoff = 0; // generate a time_t from that apr_time_t time; if (apr_time_exp_gmt_get(&time, &exp_time) != APR_SUCCESS) { return false; } F64 seconds_since_epoch = time / LL_APR_USEC_PER_SEC; // check for fractional c = s.peek(); if(c == '.') { F64 fractional = 0.0; s >> fractional; seconds_since_epoch += fractional; }
int lua_apr_time_implode(lua_State *L) { apr_status_t status; apr_time_exp_t components = { 0 }; apr_time_t time; time_check_exploded(L, 1, &components, 0); status = apr_time_exp_gmt_get(&time, &components); if (status != APR_SUCCESS) return push_error_status(L, status); return time_push(L, time); }
static void test_imp_gmt(CuTest *tc) { apr_status_t rv; apr_time_exp_t xt; apr_time_t imp; rv = apr_time_exp_gmt(&xt, now); CuAssertTrue(tc, rv == APR_SUCCESS); rv = apr_time_exp_gmt_get(&imp, &xt); if (rv == APR_ENOTIMPL) { CuNotImpl(tc, "apr_time_exp_gmt_get"); } CuAssertTrue(tc, rv == APR_SUCCESS); CuAssertTrue(tc, now == imp); }
SWITCH_DECLARE(switch_status_t) switch_time_exp_gmt_get(switch_time_t *result, switch_time_exp_t *input) { return apr_time_exp_gmt_get((apr_time_t *) result, (apr_time_exp_t *) input); }
svn_error_t * svn_time_from_cstring(apr_time_t *when, const char *data, apr_pool_t *pool) { apr_time_exp_t exploded_time; apr_status_t apr_err; char wday[4], month[4]; char *c; /* Open-code parsing of the new timestamp format, as this is a hot path for reading the entries file. This format looks like: "2001-08-31T04:24:14.966996Z" */ exploded_time.tm_year = strtol(data, &c, 10); if (*c++ != '-') goto fail; exploded_time.tm_mon = strtol(c, &c, 10); if (*c++ != '-') goto fail; exploded_time.tm_mday = strtol(c, &c, 10); if (*c++ != 'T') goto fail; exploded_time.tm_hour = strtol(c, &c, 10); if (*c++ != ':') goto fail; exploded_time.tm_min = strtol(c, &c, 10); if (*c++ != ':') goto fail; exploded_time.tm_sec = strtol(c, &c, 10); if (*c++ != '.') goto fail; exploded_time.tm_usec = strtol(c, &c, 10); if (*c++ != 'Z') goto fail; exploded_time.tm_year -= 1900; exploded_time.tm_mon -= 1; exploded_time.tm_wday = 0; exploded_time.tm_yday = 0; exploded_time.tm_isdst = 0; exploded_time.tm_gmtoff = 0; apr_err = apr_time_exp_gmt_get(when, &exploded_time); if (apr_err == APR_SUCCESS) return SVN_NO_ERROR; return svn_error_create(SVN_ERR_BAD_DATE, NULL, NULL); fail: /* Try the compatibility option. This does not need to be fast, as this format is no longer generated and the client will convert an old-format entries file the first time it reads it. */ if (sscanf(data, OLD_TIMESTAMP_FORMAT, wday, &exploded_time.tm_mday, month, &exploded_time.tm_year, &exploded_time.tm_hour, &exploded_time.tm_min, &exploded_time.tm_sec, &exploded_time.tm_usec, &exploded_time.tm_yday, &exploded_time.tm_isdst, &exploded_time.tm_gmtoff) == 11) { exploded_time.tm_year -= 1900; exploded_time.tm_yday -= 1; /* Using hard coded limits for the arrays - they are going away soon in any case. */ exploded_time.tm_wday = find_matching_string(wday, 7, apr_day_snames); exploded_time.tm_mon = find_matching_string(month, 12, apr_month_snames); apr_err = apr_time_exp_gmt_get(when, &exploded_time); if (apr_err != APR_SUCCESS) return svn_error_create(SVN_ERR_BAD_DATE, NULL, NULL); return SVN_NO_ERROR; } /* Timestamp is something we do not recognize. */ else return svn_error_create(SVN_ERR_BAD_DATE, NULL, NULL); }
/* Retrieve the date from the X.509 cert data between *P and END in either * UTCTime or GeneralizedTime format (as defined in RFC 5280 s. 4.1.2.5.1 and * 4.1.2.5.2 respectively) and place the result in WHEN using SCRATCH_POOL * for temporary allocations. */ static svn_error_t * x509_get_date(apr_time_t *when, const unsigned char **p, const unsigned char *end, apr_pool_t *scratch_pool) { svn_error_t *err; apr_status_t ret; int tag; ptrdiff_t len; char *date; apr_time_exp_t xt = { 0 }; char tz; err = asn1_get_tag(p, end, &len, ASN1_UTC_TIME); if (err && err->apr_err == SVN_ERR_ASN1_UNEXPECTED_TAG) { svn_error_clear(err); err = asn1_get_tag(p, end, &len, ASN1_GENERALIZED_TIME); tag = ASN1_GENERALIZED_TIME; } else { tag = ASN1_UTC_TIME; } if (err) return svn_error_create(SVN_ERR_X509_CERT_INVALID_DATE, err, NULL); date = apr_pstrndup(scratch_pool, (const char *) *p, len); switch (tag) { case ASN1_UTC_TIME: if (sscanf(date, "%2d%2d%2d%2d%2d%2d%c", &xt.tm_year, &xt.tm_mon, &xt.tm_mday, &xt.tm_hour, &xt.tm_min, &xt.tm_sec, &tz) < 6) return svn_error_create(SVN_ERR_X509_CERT_INVALID_DATE, NULL, NULL); /* UTCTime only provides a 2 digit year. X.509 specifies that years * greater than or equal to 50 must be interpreted as 19YY and years * less than 50 be interpreted as 20YY. This format is not used for * years greater than 2049. apr_time_exp_t wants years as the number * of years since 1900, so don't convert to 4 digits here. */ xt.tm_year += 100 * (xt.tm_year < 50); break; case ASN1_GENERALIZED_TIME: if (sscanf(date, "%4d%2d%2d%2d%2d%2d%c", &xt.tm_year, &xt.tm_mon, &xt.tm_mday, &xt.tm_hour, &xt.tm_min, &xt.tm_sec, &tz) < 6) return svn_error_create(SVN_ERR_X509_CERT_INVALID_DATE, NULL, NULL); /* GeneralizedTime has the full 4 digit year. But apr_time_exp_t * wants years as the number of years since 1900. */ xt.tm_year -= 1900; break; default: /* shouldn't ever get here because we should error out above in the * asn1_get_tag() bits but doesn't hurt to be extra paranoid. */ return svn_error_create(SVN_ERR_X509_CERT_INVALID_DATE, NULL, NULL); break; } /* check that the timezone is GMT * ASN.1 allows for the timezone to be specified but X.509 says it must * always be GMT. A little bit of extra paranoia here seems like a good * idea. */ if (tz != 'Z') return svn_error_create(SVN_ERR_X509_CERT_INVALID_DATE, NULL, NULL); /* apr_time_exp_t expects months to be zero indexed, 0=Jan, 11=Dec. */ xt.tm_mon -= 1; /* range checks (as per definition of apr_time_exp_t in apr_time.h) */ if (xt.tm_usec < 0 || xt.tm_sec < 0 || xt.tm_sec > 61 || xt.tm_min < 0 || xt.tm_min > 59 || xt.tm_hour < 0 || xt.tm_hour > 23 || xt.tm_mday < 1 || xt.tm_mday > 31 || xt.tm_mon < 0 || xt.tm_mon > 11 || xt.tm_year < 0 || xt.tm_wday < 0 || xt.tm_wday > 6 || xt.tm_yday < 0 || xt.tm_yday > 365) return svn_error_create(SVN_ERR_X509_CERT_INVALID_DATE, NULL, NULL); ret = apr_time_exp_gmt_get(when, &xt); if (ret) return svn_error_wrap_apr(ret, NULL); *p += len; return SVN_NO_ERROR; }
/* Deprecated */ APR_DECLARE(apr_status_t) apr_implode_gmt(apr_time_t *t, apr_time_exp_t *xt) { return apr_time_exp_gmt_get(t, xt); }
static int badge_get_time_arg(time_t * result, badge_timestamp * ts, int yearerr, int montherr, int dayerr, int hourerr, int minerr, int secerr) { apr_time_exp_t exptime; apr_time_t aprtime; long l; char * cp; int errflags; /** *** Convert time components in the given timestamp into a *** time_t. Return ored-in error flags. **/ memset((char *) &exptime, 0, sizeof exptime); errflags = 0; if (ts->year && *ts->year && (l = strtol(ts->year, &cp, 10)) >= 0 && !*cp) { if (l >= 1900) l -= 1900; exptime.tm_year = l; } else errflags |= yearerr; if (ts->month && *ts->month && (l = strtol(ts->month, &cp, 10)) > 0 && !*cp && l <= 12) exptime.tm_mon = l - 1; else errflags |= montherr; if (ts->day && *ts->day && (l = strtol(ts->day, &cp, 10)) > 0 && !*cp && l <= 31) exptime.tm_mday = l; else errflags |= dayerr; if (ts->hour && *ts->hour && (l = strtol(ts->hour, &cp, 10)) >= 0 && !*cp && l <= 23) exptime.tm_hour = l; else errflags |= hourerr; if (ts->min && *ts->min && (l = strtol(ts->min, &cp, 10)) >= 0 && !*cp && l <= 59) exptime.tm_min = l; else errflags |= minerr; if (ts->sec && *ts->sec && (l = strtol(ts->sec, &cp, 10)) >= 0 && !*cp && l <= 59) exptime.tm_sec = l; else errflags |= secerr; if (errflags) return errflags; if (apr_time_exp_gmt_get(&aprtime, &exptime) == OK) { *result = apr_time_sec(aprtime); /* Check for overflow. */ if (*result == apr_time_sec(aprtime)) return 0; } return yearerr | montherr | dayerr; /* Date problem. */ }