/* Function which parses command options; returns true if it
ate an option */
static int
parse(int c, char **argv, int argc,
const struct ebt_u_entry *entry,
unsigned int *flags, struct ebt_entry_match **match)
{
struct ebt_time_info *timeinfo = (struct ebt_time_info *)(*match)->data;
int hours, minutes;
switch (c) /* c is the return value of getopt_long */
{
/* timestart */
case '1':
if (*flags & EBT_TIME_START)
print_error("Can't specify --timestart twice");
parse_time_string(&hours, &minutes, optarg);
timeinfo->time_start = (hours * 60) + minutes;
*flags |= EBT_TIME_START;
break;
/* timestop */
case '2':
if (*flags & EBT_TIME_STOP)
print_error("Can't specify --timestop twice");
parse_time_string(&hours, &minutes, optarg);
timeinfo->time_stop = (hours * 60) + minutes;
*flags |= EBT_TIME_STOP;
break;
/* days */
case '3':
if (*flags & EBT_TIME_DAYS)
print_error("Can't specify --days twice");
parse_days_string(&globaldays, optarg);
timeinfo->days_match = globaldays;
*flags |= EBT_TIME_DAYS;
break;
default:
return 0;
}
/* default value if not specified */
if (!(*flags & EBT_TIME_START))
timeinfo->time_start = 0;
if (!(*flags & EBT_TIME_STOP))
timeinfo->time_stop = 1439; /* 23*60+59 = 1439*/
if (!(*flags & EBT_TIME_DAYS))
timeinfo->days_match = 0;
return 1;
}
static int
parse_generation(char *str, GENERATION **gen)
{
char *p;
int v;
if(strcmp(str, "-") == 0 || *str == '\0') {
*gen = NULL;
return 0;
}
*gen = calloc(1, sizeof(**gen));
p = strsep(&str, ":");
if(parse_time_string(&(*gen)->time, p) != 1)
return -1;
p = strsep(&str, ":");
if(sscanf(p, "%d", &v) != 1)
return -1;
(*gen)->usec = v;
p = strsep(&str, ":");
if(sscanf(p, "%d", &v) != 1)
return -1;
(*gen)->gen = v - 1; /* XXX gets bumped in _hdb_store */
return 0;
}
static void ok_button_clicked(GtkWidget *widget, gpointer user_data)
{
long time;
set_autosplit_time(gtk_entry_get_text(GTK_ENTRY(autosplit_time_entry)));
autosplit_hide(GTK_WIDGET(user_data));
time = parse_time_string();
if (time > 0) {
wavbreaker_autosplit(time);
}
}
static int
parse_time_string_alloc (time_t **t, const char *s)
{
time_t tmp;
int ret;
*t = NULL;
ret = parse_time_string (&tmp, s);
if (ret == 1) {
*t = malloc (sizeof (**t));
if (*t == NULL)
krb5_errx (context, 1, "malloc: out of memory");
**t = tmp;
}
return ret;
}
static int
parse_event(Event *ev, char *s)
{
krb5_error_code ret;
char *p;
if(strcmp(s, "-") == 0)
return 0;
memset(ev, 0, sizeof(*ev));
p = strsep(&s, ":");
if(parse_time_string(&ev->time, p) != 1)
return -1;
p = strsep(&s, ":");
ret = krb5_parse_name(context, p, &ev->principal);
if (ret)
return -1;
return 1;
}
int
main (int argc, char *argv[])
{
int r;
struct tm tm;
time_t result;
time_t now;
time_t *nowp = NULL;
char *argstr;
int round = PARSE_TIME_NO_ROUND;
char buf[1024];
const char *format = DEFAULT_FORMAT;
struct option options[] = {
{ "help", no_argument, NULL, 'h' },
{ "^", no_argument, NULL, 'u' },
{ "^^", no_argument, NULL, 'U' },
{ "_", no_argument, NULL, 'd' },
{ "format", required_argument, NULL, 'f' },
{ "ref", required_argument, NULL, 'r' },
{ NULL, 0, NULL, 0 },
};
for (;;) {
int c;
c = getopt_long (argc, argv, "huUdf:r:", options, NULL);
if (c == -1)
break;
switch (c) {
case 'f':
/* output format */
format = optarg;
break;
case 'u':
round = PARSE_TIME_ROUND_UP_INCLUSIVE;
break;
case 'U':
round = PARSE_TIME_ROUND_UP;
break;
case 'd':
round = PARSE_TIME_ROUND_DOWN;
break;
case 'r':
/* specify now in seconds since epoch */
now = (time_t) strtol (optarg, NULL, 10);
if (now >= (time_t) 0)
nowp = &now;
break;
case 'h':
case '?':
default:
usage (argv[0]);
return 1;
}
}
if (optind == argc)
return parse_stdin (stdin, nowp, round, format);
argstr = concat_args (optind, argc, argv);
if (!argstr)
return 1;
r = parse_time_string (argstr, &result, nowp, round);
free (argstr);
if (r) {
const char *errstr = parse_time_strerror (r);
if (errstr)
fprintf (stderr, "ERROR: %s\n", errstr);
else
fprintf (stderr, "ERROR: %d\n", r);
return r;
}
if (!localtime_r (&result, &tm))
return 1;
strftime (buf, sizeof (buf), format, &tm);
printf ("%s\n", buf);
return 0;
}
static int
parse_stdin (FILE *infile, time_t *ref, int round, const char *format)
{
char *input = NULL;
char result[1024];
size_t inputsize;
ssize_t len;
struct tm tm;
time_t t;
int r;
while ((len = getline (&input, &inputsize, infile)) != -1) {
const char *oper;
char *trail, *tmp;
/* trail is trailing whitespace and (optional) comment */
trail = strchr (input, '#');
if (!trail)
trail = input + len;
while (trail > input && isspace ((unsigned char) *(trail-1)))
trail--;
if (trail == input) {
printf ("%s", input);
continue;
}
tmp = strdup (trail);
if (!tmp) {
fprintf (stderr, "strdup() failed\n");
continue;
}
*trail = '\0';
trail = tmp;
/* operator */
oper = find_operator_in_string (input, &tmp, &round);
if (oper) {
*tmp = '\0';
} else {
oper = get_operator (round);
assert (oper);
}
r = parse_time_string (input, &t, ref, round);
if (!r) {
if (!localtime_r (&t, &tm)) {
fprintf (stderr, "localtime_r() failed\n");
free (trail);
continue;
}
strftime (result, sizeof (result), format, &tm);
} else {
const char *errstr = parse_time_strerror (r);
if (errstr)
snprintf (result, sizeof (result), "ERROR: %s", errstr);
else
snprintf (result, sizeof (result), "ERROR: %d", r);
}
printf ("%s%s %s%s", input, oper, result, trail);
free (trail);
}
free (input);
return 0;
}
int main(int argc, char *argv[]) {
GError *error = NULL;
gchar *server = NULL;
gchar *form_data;
gchar *form_seconds;
SoupURI *watchdog_uri = NULL;
guint ret = 0;
guint64 seconds;
gchar *prefix = NULL;
gchar *server_recipe_key = NULL;
gchar *server_recipe = NULL;
GHashTable *data_table = g_hash_table_new (NULL, NULL);
GOptionEntry entries[] = {
{"server", 's', 0, G_OPTION_ARG_STRING, &server,
"Server to connect to", "URL" },
{ NULL }
};
GOptionContext *context = g_option_context_new("<time>");
g_option_context_set_summary(context,
"Adjust watchdog on lab controller. if you don't specify the\n"
"the server url you must have RECIPEID defined.\n"
"If HARNESS_PREFIX is defined then the value of that must be\n"
"prefixed to RECIPEID");
g_option_context_add_main_entries(context, entries, NULL);
gboolean parse_succeeded = g_option_context_parse(context, &argc, &argv, &error);
if (argc < 2 || !parse_succeeded) {
g_set_error (&error, RESTRAINT_ERROR,
RESTRAINT_PARSE_ERROR_BAD_SYNTAX,
"Wrong arguments");
cmd_usage(context);
goto cleanup;
}
seconds = parse_time_string (argv[1], &error);
if (error) {
cmd_usage(context);
goto cleanup;
}
prefix = getenv("HARNESS_PREFIX") ? getenv("HARNESS_PREFIX") : "";
server_recipe_key = g_strdup_printf ("%sRECIPE_URL", prefix);
server_recipe = getenv(server_recipe_key);
g_free(server_recipe_key);
if (!server && server_recipe) {
server = g_strdup_printf ("%s/watchdog", server_recipe);
}
if (!server) {
cmd_usage(context);
goto cleanup;
}
watchdog_uri = soup_uri_new (server);
if (!watchdog_uri) {
g_set_error (&error, RESTRAINT_ERROR,
RESTRAINT_PARSE_ERROR_BAD_SYNTAX,
"Malformed server url: %s", server);
goto cleanup;
}
session = soup_session_new_with_options("timeout", 3600, NULL);
SoupMessage *server_msg = soup_message_new_from_uri ("POST", watchdog_uri);
form_seconds = g_strdup_printf ("%" PRIu64, seconds);
g_hash_table_insert (data_table, "seconds", form_seconds);
form_data = soup_form_encode_hash (data_table);
g_free (form_seconds);
soup_message_set_request (server_msg, "application/x-www-form-urlencoded",
SOUP_MEMORY_TAKE, form_data, strlen (form_data));
ret = soup_session_send_message (session, server_msg);
if (SOUP_STATUS_IS_SUCCESSFUL (ret)) {
} else {
g_warning ("Failed to adjust watchdog, status: %d Message: %s\n", ret, server_msg->reason_phrase);
}
g_object_unref(server_msg);
soup_session_abort(session);
g_object_unref(session);
cleanup:
g_hash_table_destroy(data_table);
g_option_context_free(context);
if (server != NULL) {
g_free(server);
}
if (watchdog_uri != NULL) {
soup_uri_free (watchdog_uri);
}
if (error) {
int retcode = error->code;
g_printerr("%s [%s, %d]\n", error->message,
g_quark_to_string(error->domain), error->code);
g_clear_error(&error);
return retcode;
} else {
return EXIT_SUCCESS;
}
}
/* Function which parses command options; returns true if it
ate an option */
static int
parse(int c, char **argv, int invert, unsigned int *flags,
const struct ipt_entry *entry,
unsigned int *nfcache,
struct ipt_entry_match **match)
{
struct ipt_time_info *timeinfo = (struct ipt_time_info *)(*match)->data;
int hours, minutes;
time_t temp_date;
switch (c)
{
/* timestart */
case '1':
if (invert)
exit_error(PARAMETER_PROBLEM,
"unexpected '!' with --timestart");
if (*flags & IPT_TIME_START)
exit_error(PARAMETER_PROBLEM,
"Can't specify --timestart twice");
parse_time_string(&hours, &minutes, optarg);
timeinfo->time_start = (hours * 60) + minutes;
*flags |= IPT_TIME_START;
break;
/* timestop */
case '2':
if (invert)
exit_error(PARAMETER_PROBLEM,
"unexpected '!' with --timestop");
if (*flags & IPT_TIME_STOP)
exit_error(PARAMETER_PROBLEM,
"Can't specify --timestop twice");
parse_time_string(&hours, &minutes, optarg);
timeinfo->time_stop = (hours * 60) + minutes;
*flags |= IPT_TIME_STOP;
break;
/* days */
case '3':
if (invert)
exit_error(PARAMETER_PROBLEM,
"unexpected '!' with --days");
if (*flags & IPT_TIME_DAYS)
exit_error(PARAMETER_PROBLEM,
"Can't specify --days twice");
parse_days_string(&globaldays, optarg);
timeinfo->days_match = globaldays;
*flags |= IPT_TIME_DAYS;
break;
/* datestart */
case '4':
if (invert)
exit_error(PARAMETER_PROBLEM,
"unexpected '!' with --datestart");
if (*flags & IPT_DATE_START)
exit_error(PARAMETER_PROBLEM,
"Can't specify --datestart twice");
temp_date = parse_date_string(optarg);
timeinfo->date_start = temp_date;
*flags |= IPT_DATE_START;
break;
/* datestop*/
case '5':
if (invert)
exit_error(PARAMETER_PROBLEM,
"unexpected '!' with --datestop");
if (*flags & IPT_DATE_STOP)
exit_error(PARAMETER_PROBLEM,
"Can't specify --datestop twice");
temp_date = parse_date_string(optarg);
timeinfo->date_stop = temp_date;
*flags |= IPT_DATE_STOP;
break;
default:
return 0;
}
return 1;
}
bool is_expire(char *time1, char *time2) {
// time1 after time2 return false
time_t t1 = parse_time_string(time1);
time_t t2 = parse_time_string(time2);
return t1 < t2;
}
MetaData *
restraint_parse_metadata (gchar *filename,
gchar *locale,
GError **error)
{
g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
GKeyFile *keyfile;
GKeyFileFlags flags;
GError *tmp_error = NULL;
MetaData *metadata = g_slice_new0 (MetaData);
/* Create a new GKeyFile object and a bitwise list of flags. */
keyfile = g_key_file_new();
/* This is not really needed since I don't envision writing the file back out */
flags = G_KEY_FILE_KEEP_COMMENTS | G_KEY_FILE_KEEP_TRANSLATIONS;
/* Load the GKeyFile from metadata or return. */
if (!g_key_file_load_from_file(keyfile, filename, flags, &tmp_error)) {
g_propagate_error(error, tmp_error);
goto error;
}
metadata->name = g_strstrip(g_key_file_get_locale_string(keyfile,
"General",
"name",
locale,
&tmp_error));
if (tmp_error != NULL && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
gchar *key_entry_point = g_key_file_get_locale_string(keyfile,
"restraint",
"entry_point",
locale,
&tmp_error);
if (tmp_error && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
if (key_entry_point != NULL) {
metadata->entry_point = key_entry_point;
}
gchar *max_time = g_key_file_get_locale_string (keyfile,
"restraint",
"max_time",
locale,
&tmp_error);
if (tmp_error && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
if (max_time != NULL) {
gint64 time = parse_time_string(max_time, &tmp_error);
g_free(max_time);
if (tmp_error) {
g_propagate_error(error, tmp_error);
goto error;
}
// If max_time is set it's because we read it from our run data
metadata->max_time = time;
}
gsize length;
gchar **dependencies = g_key_file_get_locale_string_list(keyfile,
"restraint",
"dependencies",
locale,
&length,
&tmp_error);
gchar **dependency = dependencies;
if (dependency) {
while (*dependency) {
metadata->dependencies = g_slist_prepend (metadata->dependencies, g_strdup(*dependency));
dependency++;
}
g_strfreev (dependencies);
}
else
metadata->dependencies = NULL;
if (tmp_error && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
gchar **softdependencies = g_key_file_get_locale_string_list(keyfile,
"restraint",
"softDependencies",
locale,
&length,
&tmp_error);
gchar **softdependency = softdependencies;
if (softdependency) {
while (*softdependency) {
metadata->softdependencies = g_slist_prepend (metadata->softdependencies, g_strdup(*softdependency));
softdependency++;
}
g_strfreev (softdependencies);
}
else
metadata->softdependencies = NULL;
if (tmp_error && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
gchar **repodeps = g_key_file_get_locale_string_list(keyfile,
"restraint",
"repoRequires",
locale,
&length,
&tmp_error);
gchar **repodep = repodeps;
if (repodep) {
while (*repodep) {
metadata->repodeps = g_slist_prepend (metadata->repodeps, g_strdup(*repodep));
repodep++;
}
g_strfreev (repodeps);
}
else
metadata->repodeps = NULL;
if (tmp_error && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
gchar **envvars = g_key_file_get_locale_string_list(keyfile,
"restraint",
"environment",
locale,
&length,
&tmp_error);
gchar **envvar = envvars;
if (envvar) {
while (*envvar) {
gchar **split = g_strsplit(*envvar, "=", 2);
if(split[0] != NULL && split[1] != NULL){
Param *p = restraint_param_new();
p->name = g_strdup(split[0]);
p->value = g_strdup(split[1]);
metadata->envvars = g_slist_prepend(metadata->envvars, p);
}
g_strfreev(split);
envvar++;
}
g_strfreev(envvars);
}
else {
metadata->envvars = NULL;
}
if (tmp_error && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
metadata->nolocalwatchdog = g_key_file_get_boolean (keyfile,
"restraint",
"no_localwatchdog",
&tmp_error);
if (tmp_error && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
metadata->use_pty = g_key_file_get_boolean (keyfile,
"restraint",
"use_pty",
&tmp_error);
if (tmp_error && tmp_error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
g_propagate_error(error, tmp_error);
goto error;
}
g_clear_error (&tmp_error);
g_key_file_free(keyfile);
return metadata;
error:
restraint_metadata_free(metadata);
g_key_file_free(keyfile);
return NULL;
}
static void parse_line(MetaData *metadata,
const gchar *line,
gsize length,
GError **error) {
g_return_if_fail(metadata != NULL);
g_return_if_fail(error == NULL || *error == NULL);
GError *tmp_error = NULL;
gchar **key_value = g_strsplit (line,":",2);
gchar *key = g_ascii_strup(g_strstrip(key_value[0]), -1);
gchar *value = g_strdup(g_strstrip(key_value[1]));
g_strfreev(key_value);
if (g_strcmp0("TESTTIME",key) == 0) {
guint64 time = parse_time_string(value, &tmp_error);
if (tmp_error) {
g_free(key);
g_free(value);
g_propagate_error(error, tmp_error);
return;
}
metadata->max_time = time;
} else if(g_strcmp0("NAME", key) == 0) {
metadata->name = g_strdup(g_strstrip(value));
} else if(g_strcmp0("USE_PTY", key) == 0) {
gchar *uvalue = g_ascii_strup(value, -1);
if (g_strcmp0("TRUE", uvalue) == 0) {
metadata->use_pty = TRUE;
} else {
metadata->use_pty = FALSE;
}
g_free(uvalue);
} else if(g_strcmp0("REQUIRES", key) == 0 ||
g_strcmp0("RHTSREQUIRES", key) == 0) {
gchar **dependencies = g_strsplit_set (value,", ", -1);
gchar **dependency = dependencies;
while (*dependency) {
if (g_strcmp0 (*dependency, "") != 0) {
metadata->dependencies = g_slist_prepend (metadata->dependencies, g_strdup(*dependency));
}
dependency++;
}
// We only want to free the array not the values that it's pointing to
g_strfreev (dependencies);
} else if(g_strcmp0("REPOREQUIRES", key) == 0) {
gchar **repodeps = g_strsplit_set (value,", ", -1);
gchar **repodep = repodeps;
while (*repodep) {
if (g_strcmp0 (*repodep, "") != 0) {
metadata->repodeps = g_slist_prepend (metadata->repodeps, g_strdup(*repodep));
}
repodep++;
}
// We only want to free the array not the values that it's pointing to
g_strfreev (repodeps);
} else if(g_strcmp0("ENVIRONMENT", key) == 0) {
gchar **envvar = g_strsplit_set (value, "= ", 2);
if(envvar[0] != NULL && envvar[1] != NULL){
Param *p = restraint_param_new();
p->name = g_strdup(envvar[0]);
p->value = g_strdup(envvar[1]);
metadata->envvars = g_slist_prepend(metadata->envvars, p);
}
g_strfreev(envvar);
}
g_free(key);
g_free(value);
}
