Ejemplo n.º 1
0
const char *add_to_sessvar(const char *desc, const char *uuid)
{
	size_t envlen; /* Length of the new string */
	char *sessvar; /* Copy of the original envvar */
	char *envbuf; /* Temporary buffer for the finished string */

	assert(valid_uuid(uuid, TRUE));

	if (!is_valid_desc_string(desc))
		desc = NULL;

	if (getenv(ENV_SESS)) {
		char *ap;

		ap = strdup(getenv(ENV_SESS));
		clean_up_sessvar(ap);
		sessvar = strdup(ap);
		free(ap);
	} else
		sessvar = strdup("");
	if (!sessvar) {
		myerror("add_to_sessvar(): Could not duplicate %s "
		        "environment variable", ENV_SESS);
		return NULL;
	}

	envlen = strlen(ENV_SESS) + 1 + strlen(sessvar) + 1 +
	         strlen(desc) + 1 + UUID_LENGTH + 1 + 1;
	envbuf = malloc(envlen);
	if (!envbuf) {
		myerror("Could not allocate %lu bytes for %s buffer",
		        envlen, ENV_SESS);
		free(sessvar);
		return NULL;
	}

	snprintf(envbuf, envlen,
	         "%s=%s,%s%s%s,",
	         ENV_SESS,
	         sessvar ? sessvar : "",
	         desc ? desc : "",
	         desc ? "/" : "",
	         uuid);

	if (putenv(envbuf)) {
		myerror("Could not set %s environment variable", ENV_SESS);
		free(sessvar);
		return NULL;
	}

	free(sessvar);

	return getenv(ENV_SESS);
}
Ejemplo n.º 2
0
int run_session(const struct Options *orig_opt,
                const int argc, char * const argv[])
{
	int retval = EXIT_SUCCESS;
	struct Options opt = *orig_opt;
	char *cmd = NULL;
	char *start_uuid = NULL;
	char *cmd_desc = NULL;
	struct uuid_result result;

	assert(orig_opt);
	assert(argv);

	cmd = concat_cmd_string(argc, argv);
	if (!cmd)
		return -1;
	cmd_desc = get_desc_from_command(cmd);
	msg(2, "cmd_desc = \"%s\"", cmd_desc);

	opt.count = 1;
	opt.whereto = "e";
	result = create_and_log_uuids(&opt);
	if (!result.success) {
		myerror("Error generating UUID, session not started");
		retval = -1;
		goto cleanup;
	}
	start_uuid = strdup(result.lastuuid);
	if (!start_uuid) {
		myerror("Could not duplicate start UUID");
		retval = -1;
		goto cleanup;
	}
	assert(valid_uuid(start_uuid, TRUE));
	msg(3, "old %s: \"%s\"", ENV_SESS, getenv(ENV_SESS));
	add_to_sessvar(cmd_desc, start_uuid);
	msg(3, "new %s: \"%s\"", ENV_SESS, getenv(ENV_SESS));

	msg(1, "Executing \"%s\"", cmd);
	retval = system(cmd); /* fixme: This value is shifted with 8 bits in 
	                       * main(). Check if it's ok.
	                       */
	msg(2, "run_session(): retval from system() = %d (0x%x)",
	       retval, retval);

cleanup:
	free(start_uuid);
	free(cmd_desc);
	free(cmd);

	return(retval);
}
Ejemplo n.º 3
0
int fill_sess(struct Entry *dest, const char *uuid,
              const char *desc, const size_t desclen)
{
	char *auuid = NULL, *adesc = NULL;
	static unsigned int sessind = 0;

	assert(dest);
	assert(valid_uuid(uuid, FALSE));

	if (sessind >= MAX_SESS) {
		fprintf(stderr, "%s: Maximum number of sess entries (%u) "
		                "exceeded\n", progname, MAX_SESS);
		return EXIT_FAILURE;
	}

	auuid = strndup(uuid, UUID_LENGTH);
	if (!auuid) {
		myerror("fill_sess(): Memory allcation error, "
		        "could not duplicate UUID");
		return EXIT_FAILURE;
	}

	if (desc && desclen) {
		adesc = strndup(desc, desclen);
		if (!adesc) {
			myerror("fill_sess(): Memory allocation error, "
			        "could not duplicate desc");
			free(auuid);
			return EXIT_FAILURE;
		}
		if (!is_valid_desc_string(adesc))
			free(adesc);
		else
			dest->sess[sessind].desc = adesc;
	}
	dest->sess[sessind].uuid = auuid;
	sessind++;

	return EXIT_SUCCESS;
}
/**
 * terminal_profiles_list_dup_uuid:
 * @list:
 * @uuid: (allow-none):
 * @error:
 *
 * Returns: (transfer full): the UUID of the profile specified by @uuid, or %NULL
 */
char *
terminal_profiles_list_dup_uuid (TerminalSettingsList *list,
                                 const char *uuid,
                                 GError **error)
{
    char *rv;

    if (uuid == NULL) {
        rv = terminal_settings_list_dup_default_child (list);
        if (rv == NULL)
            goto err;
        return rv;
    } else if (!valid_uuid (uuid, error))
        return NULL;

    if (terminal_settings_list_has_child (list, uuid))
        return g_strdup (uuid);

err:
    g_set_error (error, G_OPTION_ERROR, G_OPTION_ERROR_BAD_VALUE,
                 "No profile with UUID \"%s\" exists", uuid);
    return NULL;
}
Ejemplo n.º 5
0
struct uuid_result create_and_log_uuids(const struct Options *opt)
{
	struct uuid_result retval;
	char *rcfile = NULL, *logfile = NULL;
	unsigned int i, count;
	struct Rc rc;
	struct Entry entry;
	struct Logs logs;

	assert(opt);

	logs.logfp = NULL;
	count = opt->count;
	retval.count = 0;
	memset(retval.lastuuid, 0, UUID_LENGTH + 1);
	retval.success = TRUE;
	init_xml_entry(&entry);

	/*
	 * Get information about the environment; hostname, current directory, 
	 * tty, location of rc file and log directory, etc.
	 */

	if (init_randomness() == EXIT_FAILURE) {
		retval.success = FALSE;
		goto cleanup;
	}

	rcfile = get_rcfilename(opt);
	if (read_rcfile(rcfile, &rc) == EXIT_FAILURE) {
		retval.success = FALSE;
		goto cleanup;
	}

	if (fill_entry_struct(&entry, &rc, opt) == EXIT_FAILURE) {
		retval.success = FALSE;
		goto cleanup;
	}

	logfile = get_log_prefix(&rc, opt, ".xml");
	if (!logfile) {
		retval.success = FALSE;
		goto cleanup;
	}

	signal(SIGHUP, sighandler);
	signal(SIGINT, sighandler);
	signal(SIGQUIT, sighandler);
	signal(SIGPIPE, sighandler);
	signal(SIGTERM, sighandler);

	/*
	 * Open the log file. If it's missing, create it.
	 */

	logs.logfp = open_logfile(logfile);
	if (!logs.logfp) {
		retval.success = FALSE;
		goto cleanup;
	}

	/*
	 * Generate the UUIDs and write them to the log file.
	 */

	if (opt->uuid)
		count = 1;
	for (i = 0; i < count; i++) {
		if (!process_uuid(&logs, &rc, opt, &entry)) {
			retval.success = FALSE;
			goto cleanup;
		}
		retval.count++;
		if (should_terminate)
			break;
	}
	if (valid_uuid(entry.uuid, TRUE))
		strncpy(retval.lastuuid, entry.uuid, UUID_LENGTH + 1);

	/*
	 * Check that the correct amount of UUIDs were created.
	 */

	if (retval.count < opt->count)
		fprintf(stderr, "%s: Generated only %u of %u UUIDs\n",
		                progname, retval.count, opt->count);

	/*
	 * Close up the shop and go home.
	 */

cleanup:
	if (logs.logfp && (close_logfile(logs.logfp) == EXIT_FAILURE))
		retval.success = FALSE;

	free(logfile);
	free_sess(&entry);
	free_tags(&entry);
	free(rc.uuidcmd);
	free(rc.macaddr);
	free(rc.hostname);
	free(entry.txt);
	free(entry.date);
	free(entry.cwd);
	free(rcfile);

	return retval;
}
Ejemplo n.º 6
0
char *process_uuid(struct Logs *logs,
                   const struct Rc *rc, const struct Options *opt,
                   struct Entry *entry)
{
	assert(logs);
	assert(logs->logfp);
	assert(rc);
	assert(opt);
	assert(entry);

	/*
	 * Generate the UUID or use an already generated UUID stored in 
	 * opt->uuid.
	 */

	if (opt->uuid) {
		if (!valid_uuid(opt->uuid, TRUE)) {
			fprintf(stderr, "process_uuid(): UUID \"%s\" is not "
			                "valid.\n", opt->uuid);
			return NULL;
		}
		entry->uuid = opt->uuid;
	} else
		entry->uuid = generate_uuid(rc, opt->random_mac);
	if (!entry->uuid) {
		fprintf(stderr, "%s: UUID generation failed\n", progname);
		return NULL;
	}

	/*
	 * Extract the time stamp from the UUID and store it in an allocated 
	 * buffer.
	 */

	if (!entry->date)
		entry->date = malloc(DATE_LENGTH + 1);
	if (!entry->date) {
		myerror("process_uuid(): Could not allocate %lu bytes for "
		        "date string", DATE_LENGTH + 1);
		return NULL;
	}
	if (!uuid_date_from_uuid(entry->date, entry->uuid))
		return NULL;

	if (add_to_logfile(logs->logfp, entry, opt->raw) == EXIT_FAILURE)
		return NULL;

	/*
	 * Write the UUID to stdout and/or stderr, or not, depending on the 
	 * -w/--whereto argument.
	 */

	if (!opt->whereto)
		puts(entry->uuid);
	else {
		if (strchr(opt->whereto, 'a') || strchr(opt->whereto, 'o'))
			fprintf(stdout, "%s\n", entry->uuid);
		if (strchr(opt->whereto, 'a') || strchr(opt->whereto, 'e'))
			fprintf(stderr, "%s\n", entry->uuid);
	}

	return entry->uuid;
}
Ejemplo n.º 7
0
int get_sess_info(struct Entry *entry)
{
	char *s, *p, *desc_found = NULL, *desc_end = NULL;

	assert(entry);

	if (!getenv(ENV_SESS))
		return EXIT_SUCCESS;

	s = strdup(getenv(ENV_SESS));
	if (!s) {
		myerror("get_sess_info(): Could not duplicate %s environment "
		        "variable", ENV_SESS);
		return EXIT_FAILURE;
	}

	if (!scan_for_uuid(s)) {
		/*
		 * The environment variable exists, but contains no valid 
		 * UUIDs. Not much to do about that, so just return gracefully.
		 */
		free(s);
		return EXIT_SUCCESS;
	}

	p = s;
	while (*p) {
		if (valid_uuid(p, FALSE)) {
			size_t desclen = 0;

			if (desc_found && !desc_end)
				desc_end = p; /* There was no slash between 
				               * desc and uuid, so desc_end 
				               * hasn't been set.
				               */

			if (desc_end > desc_found)
				desclen = desc_end - desc_found;

			if (fill_sess(entry, p,
				      desc_found, desclen) == EXIT_FAILURE) {
				free(s);
				return EXIT_FAILURE;
			}

			p += UUID_LENGTH - 1;
			desc_found = desc_end = NULL;
		} else if (is_legal_desc_char(*p)) {
			if (!desc_found && p >= s)
				desc_found = p;
		} else if (*p == '/') {
			if (desc_found)
				desc_end = p;
		} else
			desc_found = desc_end = NULL;
		p++;
	}
	free(s);

	return EXIT_SUCCESS;
}