/*=export_func optionTimeDate
* private:
*
* what: process an option with a time and date.
* arg: + tOptions* + pOpts + program options descriptor +
* arg: + tOptDesc* + pOptDesc + the descriptor for this arg +
*
* doc:
* Decipher a time and date value.
=*/
void
optionTimeDate(tOptions * pOpts, tOptDesc * pOD)
{
#if defined(HAVE_GETDATE_R) && defined(HAVE_PUTENV)
if ((! HAS_pzPkgDataDir(pOpts)) || (pOpts->pzPkgDataDir == NULL))
goto default_action;
/*
* Export the DATEMSK environment variable. getdate_r() uses it to
* find the file with the strptime formats. If we cannot find the file
* we need ($PKGDATADIR/datemsk), then fall back to just a time duration.
*/
{
static char * envptr = NULL;
if (envptr == NULL) {
static char const fmt[] = "DATEMSK=%s/datemsk";
envptr = AGALOC(sizeof(fmt) + strlen(pOpts->pzPkgDataDir), fmt);
sprintf(envptr, fmt, pOpts->pzPkgDataDir);
putenv(envptr);
}
if (access(envptr+8, R_OK) != 0)
goto default_action;
}
/*
* Convert the date to a time since the epoch and stash it in a long int.
*/
{
struct tm stm;
time_t tm;
if (getdate_r(pOD->optArg.argString, &stm) != 0) {
fprintf(stderr, zNotDate, pOpts->pzProgName,
pOD->optArg.argString);
if ((pOpts->fOptSet & OPTPROC_ERRSTOP) != 0)
(*(pOpts->pUsageProc))(pOpts, EXIT_FAILURE);
return;
}
tm = mktime(&stm);
if (pOD->fOptState & OPTST_ALLOC_ARG) {
AGFREE(pOD->optArg.argString);
pOD->fOptState &= ~OPTST_ALLOC_ARG;
}
pOD->optArg.argInt = tm;
}
return;
default_action:
#endif
optionTimeVal(pOpts, pOD);
if (pOD->optArg.argInt != BAD_TIME)
pOD->optArg.argInt += (unsigned long)time(NULL);
}
static int parse_string_getdate(duk_context *ctx, const char *str) {
struct tm tm;
int rc;
time_t t;
/* For this to work, DATEMSK must be set, to this is not very
* convenient for an embeddable interpreter.
*/
DUK_MEMSET(&tm, 0, sizeof(struct tm));
rc = getdate_r(str, &tm);
DUK_DDDPRINT("getdate_r() -> %d", rc);
if (rc == 0) {
t = mktime(&tm);
DUK_DDDPRINT("mktime() -> %d", (int) t);
if (t >= 0) {
duk_push_number(ctx, (double) t);
return 1;
}
}
duk_push_nan(ctx);
return 1;
}
int CommandLineInterface::update(const std::vector<std::string>& tokens)
{
if (tokens.size() % 2 || tokens.size() < 2)
{
std::cerr << "Even number of arguments expected (More then 1)!" << std::endl;
return -1;
}
Core::Object *o;
try
{
o = ::cache(tokens[1]);
}
catch (std::out_of_range)
{
std::cerr << "No such object!" << std::endl;
return -1;
}
for (int i = 2; i < tokens.size(); i++)
{
auto name = tokens[i++];
auto value = tokens[i];
try
{
if (isdigit(*(value.c_str())))
{
struct tm time;
getdate_r(value.c_str(), &time);
o->update(name, mktime(&time));
}
else
{
o->update(name, value);
}
}
catch (boost::bad_any_cast)
{
std::cerr << name << ": Invalid type or reserved field!" << std::endl;
}
}
return 0;
}
int CommandLineInterface::lua_call(const std::vector<std::string>& tokens)
{
if (tokens.size() < 2)
{
std::cerr << "Argument expected!" << std::endl;
return -1;
}
lua_getglobal(vm(), tokens[1].c_str());
try
{
for (int i = 2; i < tokens.size(); i ++)
{
if (isdigit(*(tokens[i].c_str())))
{
struct tm time;
getdate_r(tokens[i].c_str(), &time);
lua_pushnumber(vm(), mktime(&time));
continue;
}
if (*(tokens[i].c_str()) == '#')
{
lua_create_lua_object(vm(), ::cache(tokens[i]));
continue;
}
lua_pushstring(vm(), tokens[i].c_str());
}
}
catch (std::out_of_range)
{
std::cerr << "No such object!" << std::endl;
return -1;
}
if (lua_pcall(vm(), tokens.size() - 2, 0, 0))
{
std::cerr << lua_tostring(vm(), -1) << std::endl;
return -1;
}
return 0;
}
DUK_INTERNAL duk_bool_t duk_bi_date_parse_string_getdate(duk_context *ctx, const char *str) {
struct tm tm;
duk_small_int_t rc;
time_t t;
/* For this to work, DATEMSK must be set, so this is not very
* convenient for an embeddable interpreter.
*/
DUK_MEMZERO(&tm, sizeof(struct tm));
rc = (duk_small_int_t) getdate_r(str, &tm);
DUK_DDD(DUK_DDDPRINT("getdate_r() -> %ld", (long) rc));
if (rc == 0) {
t = mktime(&tm);
DUK_DDD(DUK_DDDPRINT("mktime() -> %ld", (long) t));
if (t >= 0) {
duk_push_number(ctx, (duk_double_t) t);
return 1;
}
}
return 0;
}
uint64 Misc_parseDateTime(const char *string)
{
const char *DATE_TIME_FORMATS[] =
{
"%Y-%m-%dT%H:%i:%s%Q", // 2011-03-11T14:46:23-06:00
"%A, %d %b %y %H:%M:%S %z", // Fri, 11 Mar 11 14:46:23 -0500
"%a, %d %b %y %H:%M:%S %z", // Friday, 11 Mar 11 14:46:23 -0500
"%A, %d %B %y %H:%M:%S %z", // Fri, 11 Mar 11 14:46:23 -0500
"%a, %d %B %y %H:%M:%S %z", // Friday, 11 Mar 11 14:46:23 -0500
"%A, %d %b %Y %H:%M:%S %z", // Fri, 11 Mar 2011 14:46:23 -0500
"%a, %d %b %Y %H:%M:%S %z", // Friday, 11 Mar 2011 14:46:23 -0500
"%A, %d %B %Y %H:%M:%S %z", // Fri, 11 Mar 2011 14:46:23 -0500
"%a, %d %B %Y %H:%M:%S %z", // Friday, 11 Mar 2011 14:46:23 -0500
"%A, %d-%b-%y %H:%M:%S UTC", // Fri, 11-Mar-11 14:46:23 UTC
"%a, %d-%b-%y %H:%M:%S UTC", // Friday, 11-Mar-11 14:46:23 UTC
"%A, %d-%B-%y %H:%M:%S UTC", // Fri, 11-March-11 14:46:23 UTC
"%a, %d-%B-%y %H:%M:%S UTC", // Friday, 11-March-11 14:46:23 UTC
"%A, %d-%b-%Y %H:%M:%S UTC", // Fri, 11-Mar-2011 14:46:23 UTC
"%a, %d-%b-%Y %H:%M:%S UTC", // Friday, 11-Mar-2-11 14:46:23 UTC
"%A, %d-%B-%Y %H:%M:%S UTC", // Fri, 11-March-2011 14:46:23 UTC
"%a, %d-%B-%Y %H:%M:%S UTC", // Friday, 11-March-2011 14:46:23 UTC
"%A, %d %b %y %H:%M:%S GMT", // Fri, 11 Mar 11 14:46:23 GMT
"%a, %d %b %y %H:%M:%S GMT", // Friday, 11 Mar 11 14:46:23 GMT
"%A, %d %B %y %H:%M:%S GMT", // Fri, 11 March 11 14:46:23 GMT
"%a, %d %B %y %H:%M:%S GMT", // Friday, 11 March 11 14:46:23 GMT
"%A, %d %b %Y %H:%M:%S GMT", // Fri, 11 Mar 2011 14:46:23 GMT
"%a, %d %b %Y %H:%M:%S GMT", // Friday, 11 Mar 2011 14:46:23 GMT
"%A, %d %B %Y %H:%M:%S GMT", // Fri, 11 March 2011 14:46:23 GMT
"%a, %d %B %Y %H:%M:%S GMT", // Friday, 11 March 2011 14:46:23 GMT
DATE_TIME_FORMAT_DEFAULT
};
#ifdef HAVE_GETDATE_R
struct tm tmBuffer;
#endif /* HAVE_GETDATE_R */
struct tm *tm;
uint z;
const char *s;
uint64 dateTime;
assert(string != NULL);
#ifdef HAVE_GETDATE_R
tm = (getdate_r(string,&tmBuffer) == 0) ? &tmBuffer : NULL;
#else /* not HAVE_GETDATE_R */
tm = getdate(string);
#endif /* HAVE_GETDATE_R */
if (tm == NULL)
{
z = 0;
while ((z < SIZE_OF_ARRAY(DATE_TIME_FORMATS)) && (tm == NULL))
{
s = strptime(string,DATE_TIME_FORMATS[z],&tmBuffer);
if ((s != NULL) && ((*s) == '\0'))
{
tm = &tmBuffer;
}
z++;
}
}
if (tm != NULL)
{
dateTime = (uint64)mktime(tm);
}
else
{
dateTime = 0LL;
}
return dateTime;
}
int date_main(int argc, char *argv[])
{
int c;
int res;
struct tm tm;
time_t t;
struct timeval tv;
struct timespec ts;
char strbuf[260];
int fd;
int useutc = 0;
tzset();
do {
c = getopt(argc, argv, "us:");
if (c == EOF)
break;
switch (c) {
case 'u':
useutc = 1;
break;
case 's':
settime(optarg);
break;
case '?':
fprintf(stderr, "%s: invalid option -%c\n",
argv[0], optopt);
exit(1);
}
} while (1);
if(optind + 2 < argc) {
fprintf(stderr,"%s [-u] [date]\n", argv[0]);
return 1;
}
int hasfmt = argc == optind + 1 && argv[optind][0] == '+';
if(optind == argc || hasfmt) {
char buf[2000];
time(&t);
if (useutc) {
gmtime_r(&t, &tm);
strftime(strbuf, sizeof(strbuf),
(hasfmt ? argv[optind] + 1 : "%a %b %e %H:%M:%S GMT %Y"),
&tm);
} else {
localtime_r(&t, &tm);
strftime(strbuf, sizeof(strbuf),
(hasfmt ? argv[optind] + 1 : "%a %b %e %H:%M:%S %Z %Y"),
&tm);
}
printf("%s\n", strbuf);
}
else if(optind + 1 == argc) {
#if 0
struct tm *tmptr;
tmptr = getdate(argv[optind]);
if(tmptr == NULL) {
fprintf(stderr,"getdate_r failed\n");
return 1;
}
tm = *tmptr;
#if 0
if(getdate_r(argv[optind], &tm) < 0) {
fprintf(stderr,"getdate_r failed %s\n", strerror(errno));
return 1;
}
#endif
#endif
//strptime(argv[optind], NULL, &tm);
//tv.tv_sec = mktime(&tm);
//tv.tv_usec = 0;
strtotimeval(argv[optind], &tv);
printf("time %s -> %d.%d\n", argv[optind], tv.tv_sec, tv.tv_usec);
fd = open("/dev/alarm", O_RDWR);
ts.tv_sec = tv.tv_sec;
ts.tv_nsec = tv.tv_usec * 1000;
res = ioctl(fd, ANDROID_ALARM_SET_RTC, &ts);
//res = settimeofday(&tv, NULL);
if(res < 0) {
fprintf(stderr,"settimeofday failed %s\n", strerror(errno));
return 1;
}
}
else {
fprintf(stderr,"%s [-s 20070325.123456] [-u] [date]\n", argv[0]);
return 1;
}
return 0;
}
