[libsigrok.git] / session_file.c

/*
 * This file is part of the libsigrok project.
 *
 * Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

#include <string.h>
#include <stdlib.h>
#include <unistd.h>
#include <zip.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <errno.h>
#include <glib.h>
#include <glib/gstdio.h>
#include "config.h" /* Needed for PACKAGE_VERSION and others. */
#include "libsigrok.h"
#include "libsigrok-internal.h"

#define LOG_PREFIX "session-file"

/**
 * @file
 *
 * Loading and saving libsigrok session files.
 */

/**
 * @addtogroup grp_session
 *
 * @{
 */

extern struct sr_session *session;
extern SR_PRIV struct sr_dev_driver session_driver;

/** @private */
SR_PRIV int sr_sessionfile_check(const char *filename)
{
	struct stat st;
	struct zip *archive;
	struct zip_file *zf;
	struct zip_stat zs;
	int version, ret;
	char s[11];

	if (!filename)
		return SR_ERR_ARG;

	if (stat(filename, &st) == -1) {
		sr_err("Couldn't stat %s: %s", filename, strerror(errno));
		return SR_ERR;
	}

	if (!(archive = zip_open(filename, 0, &ret)))
		/* No logging: this can be used just to check if it's
		 * a sigrok session file or not. */
		return SR_ERR;

	/* check "version" */
	version = 0;
	if (!(zf = zip_fopen(archive, "version", 0))) {
		sr_dbg("Not a sigrok session file: no version found.");
		return SR_ERR;
	}
	if ((ret = zip_fread(zf, s, 10)) == -1)
		return SR_ERR;
	zip_fclose(zf);
	s[ret] = 0;
	version = strtoull(s, NULL, 10);
	if (version > 2) {
		sr_dbg("Cannot handle sigrok session file version %d.", version);
		return SR_ERR;
	}
	sr_spew("Detected sigrok session file version %d.", version);

	/* read "metadata" */
	if (zip_stat(archive, "metadata", 0, &zs) == -1) {
		sr_dbg("Not a valid sigrok session file.");
		return SR_ERR;
	}

	return SR_OK;
}

/**
 * Load the session from the specified filename.
 *
 * @param filename The name of the session file to load. Must not be NULL.
 *
 * @return SR_OK upon success, SR_ERR_ARG upon invalid arguments,
 *         SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon
 *         other errors.
 */
SR_API int sr_session_load(const char *filename)
{
	GKeyFile *kf;
	GPtrArray *capturefiles;
	struct zip *archive;
	struct zip_file *zf;
	struct zip_stat zs;
	struct sr_dev_inst *sdi;
	struct sr_channel *ch;
	int ret, channelnum, devcnt, i, j;
	uint64_t tmp_u64, total_channels, enabled_channels, p;
	char **sections, **keys, *metafile, *val;
	char channelname[SR_MAX_PROBENAME_LEN + 1];

	if ((ret = sr_sessionfile_check(filename)) != SR_OK)
		return ret;

	if (!(archive = zip_open(filename, 0, &ret)))
		return SR_ERR;

	if (zip_stat(archive, "metadata", 0, &zs) == -1)
		return SR_ERR;

	if (!(metafile = g_try_malloc(zs.size))) {
		sr_err("%s: metafile malloc failed", __func__);
		return SR_ERR_MALLOC;
	}

	zf = zip_fopen_index(archive, zs.index, 0);
	zip_fread(zf, metafile, zs.size);
	zip_fclose(zf);

	kf = g_key_file_new();
	if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
		sr_dbg("Failed to parse metadata.");
		return SR_ERR;
	}

	sr_session_new();

	devcnt = 0;
	capturefiles = g_ptr_array_new_with_free_func(g_free);
	sections = g_key_file_get_groups(kf, NULL);
	for (i = 0; sections[i]; i++) {
		if (!strcmp(sections[i], "global"))
			/* nothing really interesting in here yet */
			continue;
		if (!strncmp(sections[i], "device ", 7)) {
			/* device section */
			sdi = NULL;
			enabled_channels = total_channels = 0;
			keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
			for (j = 0; keys[j]; j++) {
				val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
				if (!strcmp(keys[j], "capturefile")) {
					sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, NULL, NULL, NULL);
					sdi->driver = &session_driver;
					if (devcnt == 0)
						/* first device, init the driver */
						sdi->driver->init(NULL);
					sr_dev_open(sdi);
					sr_session_dev_add(sdi);
					sdi->driver->config_set(SR_CONF_SESSIONFILE,
							g_variant_new_string(filename), sdi, NULL);
					sdi->driver->config_set(SR_CONF_CAPTUREFILE,
							g_variant_new_string(val), sdi, NULL);
					g_ptr_array_add(capturefiles, val);
				} else if (!strcmp(keys[j], "samplerate")) {
					sr_parse_sizestring(val, &tmp_u64);
					sdi->driver->config_set(SR_CONF_SAMPLERATE,
							g_variant_new_uint64(tmp_u64), sdi, NULL);
				} else if (!strcmp(keys[j], "unitsize")) {
					tmp_u64 = strtoull(val, NULL, 10);
					sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
							g_variant_new_uint64(tmp_u64), sdi, NULL);
				} else if (!strcmp(keys[j], "total probes")) {
					total_channels = strtoull(val, NULL, 10);
					sdi->driver->config_set(SR_CONF_NUM_LOGIC_PROBES,
							g_variant_new_uint64(total_channels), sdi, NULL);
					for (p = 0; p < total_channels; p++) {
						snprintf(channelname, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
						if (!(ch = sr_probe_new(p, SR_PROBE_LOGIC, TRUE,
								channelname)))
							return SR_ERR;
						sdi->channels = g_slist_append(sdi->channels, ch);
					}
				} else if (!strncmp(keys[j], "probe", 5)) {
					if (!sdi)
						continue;
					enabled_channels++;
					tmp_u64 = strtoul(keys[j]+5, NULL, 10);
					/* sr_session_save() */
					sr_dev_probe_name_set(sdi, tmp_u64 - 1, val);
				} else if (!strncmp(keys[j], "trigger", 7)) {
					channelnum = strtoul(keys[j]+7, NULL, 10);
					sr_dev_trigger_set(sdi, channelnum, val);
				}
			}
			g_strfreev(keys);
			/* Disable channels not specifically listed. */
			if (total_channels)
				for (p = enabled_channels; p < total_channels; p++)
					sr_dev_probe_enable(sdi, p, FALSE);
		}
		devcnt++;
	}
	g_strfreev(sections);
	g_key_file_free(kf);

	return SR_OK;
}

/**
 * Save the current session to the specified file.
 *
 * @param filename The name of the filename to save the current session as.
 *                 Must not be NULL.
 * @param sdi The device instance from which the data was captured.
 * @param buf The data to be saved.
 * @param unitsize The number of bytes per sample.
 * @param units The number of samples.
 *
 * @retval SR_OK Success
 * @retval SR_ERR_ARG Invalid arguments
 * @retval SR_ERR Other errors
 */
SR_API int sr_session_save(const char *filename, const struct sr_dev_inst *sdi,
		unsigned char *buf, int unitsize, int units)
{
	struct sr_channel *ch;
	GSList *l;
	GVariant *gvar;
	uint64_t samplerate;
	int cnt, ret;
	char **channel_names;

	samplerate = 0;
	if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) {
		if (sr_config_get(sdi->driver, sdi, NULL,
					SR_CONF_SAMPLERATE, &gvar) == SR_OK) {
			samplerate = g_variant_get_uint64(gvar);
			g_variant_unref(gvar);
		}
	}

	channel_names = g_malloc0(sizeof(char *) * (g_slist_length(sdi->channels) + 1));
	cnt = 0;
	for (l = sdi->channels; l; l = l->next) {
		ch = l->data;
		if (ch->type != SR_PROBE_LOGIC)
			continue;
		if (ch->enabled != TRUE)
			continue;
		if (!ch->name)
			continue;
		/* Just borrowing the ptr. */
		channel_names[cnt++] = ch->name;
	}

	if ((ret = sr_session_save_init(filename, samplerate, channel_names)) != SR_OK)
		return ret;

	ret = sr_session_append(filename, buf, unitsize, units);

	return ret;
}

/**
 * Initialize a saved session file.
 *
 * @param filename The name of the filename to save the current session as.
 *                 Must not be NULL.
 * @param samplerate The samplerate to store for this session.
 * @param channels A NULL-terminated array of strings containing the names
 * of all the channels active in this session.
 *
 * @retval SR_OK Success
 * @retval SR_ERR_ARG Invalid arguments
 * @retval SR_ERR Other errors
 */
SR_API int sr_session_save_init(const char *filename, uint64_t samplerate,
		char **channels)
{
	FILE *meta;
	struct zip *zipfile;
	struct zip_source *versrc, *metasrc;
	int tmpfile, cnt, ret, i;
	char version[1], metafile[32], *s;

	if (!filename) {
		sr_err("%s: filename was NULL", __func__);
		return SR_ERR_ARG;
	}

	/* Quietly delete it first, libzip wants replace ops otherwise. */
	unlink(filename);
	if (!(zipfile = zip_open(filename, ZIP_CREATE, &ret)))
		return SR_ERR;

	/* "version" */
	version[0] = '2';
	if (!(versrc = zip_source_buffer(zipfile, version, 1, 0)))
		return SR_ERR;
	if (zip_add(zipfile, "version", versrc) == -1) {
		sr_info("error saving version into zipfile: %s",
			zip_strerror(zipfile));
		return SR_ERR;
	}

	/* init "metadata" */
	strcpy(metafile, "sigrok-meta-XXXXXX");
	if ((tmpfile = g_mkstemp(metafile)) == -1)
		return SR_ERR;
	close(tmpfile);
	meta = g_fopen(metafile, "wb");
	fprintf(meta, "[global]\n");
	fprintf(meta, "sigrok version = %s\n", PACKAGE_VERSION);

	/* metadata */
	fprintf(meta, "[device 1]\n");

	/* metadata */
	fprintf(meta, "capturefile = logic-1\n");
	cnt = 0;
	for (i = 0; channels[i]; i++)
		cnt++;
	fprintf(meta, "total probes = %d\n", cnt);
	s = sr_samplerate_string(samplerate);
	fprintf(meta, "samplerate = %s\n", s);
	g_free(s);

	for (i = 0; channels[i]; i++)
		fprintf(meta, "probe%d = %s\n", i + 1, channels[i]);

	fclose(meta);

	if (!(metasrc = zip_source_file(zipfile, metafile, 0, -1))) {
		unlink(metafile);
		return SR_ERR;
	}
	if (zip_add(zipfile, "metadata", metasrc) == -1) {
		unlink(metafile);
		return SR_ERR;
	}

	if ((ret = zip_close(zipfile)) == -1) {
		sr_info("error saving zipfile: %s", zip_strerror(zipfile));
		unlink(metafile);
		return SR_ERR;
	}

	unlink(metafile);

	return SR_OK;
}

/**
 * Append data to an existing session file.
 *
 * The session file must have been created with sr_session_save_init()
 * or sr_session_save() beforehand.
 *
 * @param filename The name of the filename to append to. Must not be NULL.
 * @param buf The data to be appended.
 * @param unitsize The number of bytes per sample.
 * @param units The number of samples.
 *
 * @retval SR_OK Success
 * @retval SR_ERR_ARG Invalid arguments
 * @retval SR_ERR Other errors
 */
SR_API int sr_session_append(const char *filename, unsigned char *buf,
		int unitsize, int units)
{
	struct zip *archive;
	struct zip_source *logicsrc;
	zip_int64_t num_files;
	struct zip_file *zf;
	struct zip_stat zs;
	struct zip_source *metasrc;
	GKeyFile *kf;
	GError *error;
	gsize len;
	int chunk_num, next_chunk_num, tmpfile, ret, i;
	const char *entry_name;
	char *metafile, tmpname[32], chunkname[16];

	if ((ret = sr_sessionfile_check(filename)) != SR_OK)
		return ret;

	if (!(archive = zip_open(filename, 0, &ret)))
		return SR_ERR;

	if (zip_stat(archive, "metadata", 0, &zs) == -1)
		return SR_ERR;

	metafile = g_malloc(zs.size);
	zf = zip_fopen_index(archive, zs.index, 0);
	zip_fread(zf, metafile, zs.size);
	zip_fclose(zf);

	/*
	 * If the file was only initialized but doesn't yet have any
	 * data it in, it won't have a unitsize field in metadata yet.
	 */
	error = NULL;
	kf = g_key_file_new();
	if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, &error)) {
		sr_err("Failed to parse metadata: %s.", error->message);
		return SR_ERR;
	}
	g_free(metafile);
	tmpname[0] = '\0';
	if (!g_key_file_has_key(kf, "device 1", "unitsize", &error)) {
		if (error && error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
			sr_err("Failed to check unitsize key: %s", error ? error->message : "?");
			return SR_ERR;
		}
		/* Add unitsize field. */
		g_key_file_set_integer(kf, "device 1", "unitsize", unitsize);
		metafile = g_key_file_to_data(kf, &len, &error);
		strcpy(tmpname, "sigrok-meta-XXXXXX");
		if ((tmpfile = g_mkstemp(tmpname)) == -1)
			return SR_ERR;
		if (write(tmpfile, metafile, len) < 0) {
			sr_dbg("Failed to create new metadata: %s", strerror(errno));
			g_free(metafile);
			unlink(tmpname);
			return SR_ERR;
		}
		close(tmpfile);
		if (!(metasrc = zip_source_file(archive, tmpname, 0, -1))) {
			sr_err("Failed to create zip source for metadata.");
			g_free(metafile);
			unlink(tmpname);
			return SR_ERR;
		}
		if (zip_replace(archive, zs.index, metasrc) == -1) {
			sr_err("Failed to replace metadata file.");
			g_free(metafile);
			unlink(tmpname);
			return SR_ERR;
		}
		g_free(metafile);
	}
	g_key_file_free(kf);

	next_chunk_num = 1;
	num_files = zip_get_num_entries(archive, 0);
	for (i = 0; i < num_files; i++) {
		entry_name = zip_get_name(archive, i, 0);
		if (strncmp(entry_name, "logic-1", 7))
			continue;
		if (strlen(entry_name) == 7) {
			/* This file has no extra chunks, just a single "logic-1".
			 * Rename it to "logic-1-1" * and continue with chunk 2. */
			if (zip_rename(archive, i, "logic-1-1") == -1) {
				sr_err("Failed to rename 'logic-1' to 'logic-1-1'.");
				unlink(tmpname);
				return SR_ERR;
			}
			next_chunk_num = 2;
			break;
		} else if (strlen(entry_name) > 8 && entry_name[7] == '-') {
			chunk_num = strtoull(entry_name + 8, NULL, 10);
			if (chunk_num >= next_chunk_num)
				next_chunk_num = chunk_num + 1;
		}
	}
	snprintf(chunkname, 15, "logic-1-%d", next_chunk_num);
	if (!(logicsrc = zip_source_buffer(archive, buf, units * unitsize, FALSE))) {
		unlink(tmpname);
		return SR_ERR;
	}
	if (zip_add(archive, chunkname, logicsrc) == -1) {
		unlink(tmpname);
		return SR_ERR;
	}
	if ((ret = zip_close(archive)) == -1) {
		sr_info("error saving session file: %s", zip_strerror(archive));
		unlink(tmpname);
		return SR_ERR;
	}
	unlink(tmpname);

	return SR_OK;
}

/** @} */
Commit	Line	Data
	1	/*
	2	* This file is part of the libsigrok project.
	3	*
	4	* Copyright (C) 2013 Bert Vermeulen <bert@biot.com>
	5	*
	6	* This program is free software: you can redistribute it and/or modify
	7	* it under the terms of the GNU General Public License as published by
	8	* the Free Software Foundation, either version 3 of the License, or
	9	* (at your option) any later version.
	10	*
	11	* This program is distributed in the hope that it will be useful,
	12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	14	* GNU General Public License for more details.
	15	*
	16	* You should have received a copy of the GNU General Public License
	17	* along with this program. If not, see <http://www.gnu.org/licenses/>.
	18	*/
	19
	20	#include <string.h>
	21	#include <stdlib.h>
	22	#include <unistd.h>
	23	#include <zip.h>
	24	#include <sys/types.h>
	25	#include <sys/stat.h>
	26	#include <errno.h>
	27	#include <glib.h>
	28	#include <glib/gstdio.h>
	29	#include "config.h" /* Needed for PACKAGE_VERSION and others. */
	30	#include "libsigrok.h"
	31	#include "libsigrok-internal.h"
	32
	33	#define LOG_PREFIX "session-file"
	34
	35	/**
	36	* @file
	37	*
	38	* Loading and saving libsigrok session files.
	39	*/
	40
	41	/**
	42	* @addtogroup grp_session
	43	*
	44	* @{
	45	*/
	46
	47	extern struct sr_session *session;
	48	extern SR_PRIV struct sr_dev_driver session_driver;
	49
	50	/** @private */
	51	SR_PRIV int sr_sessionfile_check(const char *filename)
	52	{
	53	struct stat st;
	54	struct zip *archive;
	55	struct zip_file *zf;
	56	struct zip_stat zs;
	57	int version, ret;
	58	char s[11];
	59
	60	if (!filename)
	61	return SR_ERR_ARG;
	62
	63	if (stat(filename, &st) == -1) {
	64	sr_err("Couldn't stat %s: %s", filename, strerror(errno));
	65	return SR_ERR;
	66	}
	67
	68	if (!(archive = zip_open(filename, 0, &ret)))
	69	/* No logging: this can be used just to check if it's
	70	* a sigrok session file or not. */
	71	return SR_ERR;
	72
	73	/* check "version" */
	74	version = 0;
	75	if (!(zf = zip_fopen(archive, "version", 0))) {
	76	sr_dbg("Not a sigrok session file: no version found.");
	77	return SR_ERR;
	78	}
	79	if ((ret = zip_fread(zf, s, 10)) == -1)
	80	return SR_ERR;
	81	zip_fclose(zf);
	82	s[ret] = 0;
	83	version = strtoull(s, NULL, 10);
	84	if (version > 2) {
	85	sr_dbg("Cannot handle sigrok session file version %d.", version);
	86	return SR_ERR;
	87	}
	88	sr_spew("Detected sigrok session file version %d.", version);
	89
	90	/* read "metadata" */
	91	if (zip_stat(archive, "metadata", 0, &zs) == -1) {
	92	sr_dbg("Not a valid sigrok session file.");
	93	return SR_ERR;
	94	}
	95
	96	return SR_OK;
	97	}
	98
	99	/**
	100	* Load the session from the specified filename.
	101	*
	102	* @param filename The name of the session file to load. Must not be NULL.
	103	*
	104	* @return SR_OK upon success, SR_ERR_ARG upon invalid arguments,
	105	* SR_ERR_MALLOC upon memory allocation errors, or SR_ERR upon
	106	* other errors.
	107	*/
	108	SR_API int sr_session_load(const char *filename)
	109	{
	110	GKeyFile *kf;
	111	GPtrArray *capturefiles;
	112	struct zip *archive;
	113	struct zip_file *zf;
	114	struct zip_stat zs;
	115	struct sr_dev_inst *sdi;
	116	struct sr_channel *ch;
	117	int ret, channelnum, devcnt, i, j;
	118	uint64_t tmp_u64, total_channels, enabled_channels, p;
	119	char sections, keys, metafile, val;
	120	char channelname[SR_MAX_PROBENAME_LEN + 1];
	121
	122	if ((ret = sr_sessionfile_check(filename)) != SR_OK)
	123	return ret;
	124
	125	if (!(archive = zip_open(filename, 0, &ret)))
	126	return SR_ERR;
	127
	128	if (zip_stat(archive, "metadata", 0, &zs) == -1)
	129	return SR_ERR;
	130
	131	if (!(metafile = g_try_malloc(zs.size))) {
	132	sr_err("%s: metafile malloc failed", __func__);
	133	return SR_ERR_MALLOC;
	134	}
	135
	136	zf = zip_fopen_index(archive, zs.index, 0);
	137	zip_fread(zf, metafile, zs.size);
	138	zip_fclose(zf);
	139
	140	kf = g_key_file_new();
	141	if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, NULL)) {
	142	sr_dbg("Failed to parse metadata.");
	143	return SR_ERR;
	144	}
	145
	146	sr_session_new();
	147
	148	devcnt = 0;
	149	capturefiles = g_ptr_array_new_with_free_func(g_free);
	150	sections = g_key_file_get_groups(kf, NULL);
	151	for (i = 0; sections[i]; i++) {
	152	if (!strcmp(sections[i], "global"))
	153	/* nothing really interesting in here yet */
	154	continue;
	155	if (!strncmp(sections[i], "device ", 7)) {
	156	/* device section */
	157	sdi = NULL;
	158	enabled_channels = total_channels = 0;
	159	keys = g_key_file_get_keys(kf, sections[i], NULL, NULL);
	160	for (j = 0; keys[j]; j++) {
	161	val = g_key_file_get_string(kf, sections[i], keys[j], NULL);
	162	if (!strcmp(keys[j], "capturefile")) {
	163	sdi = sr_dev_inst_new(devcnt, SR_ST_ACTIVE, NULL, NULL, NULL);
	164	sdi->driver = &session_driver;
	165	if (devcnt == 0)
	166	/* first device, init the driver */
	167	sdi->driver->init(NULL);
	168	sr_dev_open(sdi);
	169	sr_session_dev_add(sdi);
	170	sdi->driver->config_set(SR_CONF_SESSIONFILE,
	171	g_variant_new_string(filename), sdi, NULL);
	172	sdi->driver->config_set(SR_CONF_CAPTUREFILE,
	173	g_variant_new_string(val), sdi, NULL);
	174	g_ptr_array_add(capturefiles, val);
	175	} else if (!strcmp(keys[j], "samplerate")) {
	176	sr_parse_sizestring(val, &tmp_u64);
	177	sdi->driver->config_set(SR_CONF_SAMPLERATE,
	178	g_variant_new_uint64(tmp_u64), sdi, NULL);
	179	} else if (!strcmp(keys[j], "unitsize")) {
	180	tmp_u64 = strtoull(val, NULL, 10);
	181	sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
	182	g_variant_new_uint64(tmp_u64), sdi, NULL);
	183	} else if (!strcmp(keys[j], "total probes")) {
	184	total_channels = strtoull(val, NULL, 10);
	185	sdi->driver->config_set(SR_CONF_NUM_LOGIC_PROBES,
	186	g_variant_new_uint64(total_channels), sdi, NULL);
	187	for (p = 0; p < total_channels; p++) {
	188	snprintf(channelname, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
	189	if (!(ch = sr_probe_new(p, SR_PROBE_LOGIC, TRUE,
	190	channelname)))
	191	return SR_ERR;
	192	sdi->channels = g_slist_append(sdi->channels, ch);
	193	}
	194	} else if (!strncmp(keys[j], "probe", 5)) {
	195	if (!sdi)
	196	continue;
	197	enabled_channels++;
	198	tmp_u64 = strtoul(keys[j]+5, NULL, 10);
	199	/* sr_session_save() */
	200	sr_dev_probe_name_set(sdi, tmp_u64 - 1, val);
	201	} else if (!strncmp(keys[j], "trigger", 7)) {
	202	channelnum = strtoul(keys[j]+7, NULL, 10);
	203	sr_dev_trigger_set(sdi, channelnum, val);
	204	}
	205	}
	206	g_strfreev(keys);
	207	/* Disable channels not specifically listed. */
	208	if (total_channels)
	209	for (p = enabled_channels; p < total_channels; p++)
	210	sr_dev_probe_enable(sdi, p, FALSE);
	211	}
	212	devcnt++;
	213	}
	214	g_strfreev(sections);
	215	g_key_file_free(kf);
	216
	217	return SR_OK;
	218	}
	219
	220	/**
	221	* Save the current session to the specified file.
	222	*
	223	* @param filename The name of the filename to save the current session as.
	224	* Must not be NULL.
	225	* @param sdi The device instance from which the data was captured.
	226	* @param buf The data to be saved.
	227	* @param unitsize The number of bytes per sample.
	228	* @param units The number of samples.
	229	*
	230	* @retval SR_OK Success
	231	* @retval SR_ERR_ARG Invalid arguments
	232	* @retval SR_ERR Other errors
	233	*/
	234	SR_API int sr_session_save(const char filename, const struct sr_dev_inst sdi,
	235	unsigned char *buf, int unitsize, int units)
	236	{
	237	struct sr_channel *ch;
	238	GSList *l;
	239	GVariant *gvar;
	240	uint64_t samplerate;
	241	int cnt, ret;
	242	char **channel_names;
	243
	244	samplerate = 0;
	245	if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) {
	246	if (sr_config_get(sdi->driver, sdi, NULL,
	247	SR_CONF_SAMPLERATE, &gvar) == SR_OK) {
	248	samplerate = g_variant_get_uint64(gvar);
	249	g_variant_unref(gvar);
	250	}
	251	}
	252
	253	channel_names = g_malloc0(sizeof(char ) (g_slist_length(sdi->channels) + 1));
	254	cnt = 0;
	255	for (l = sdi->channels; l; l = l->next) {
	256	ch = l->data;
	257	if (ch->type != SR_PROBE_LOGIC)
	258	continue;
	259	if (ch->enabled != TRUE)
	260	continue;
	261	if (!ch->name)
	262	continue;
	263	/* Just borrowing the ptr. */
	264	channel_names[cnt++] = ch->name;
	265	}
	266
	267	if ((ret = sr_session_save_init(filename, samplerate, channel_names)) != SR_OK)
	268	return ret;
	269
	270	ret = sr_session_append(filename, buf, unitsize, units);
	271
	272	return ret;
	273	}
	274
	275	/**
	276	* Initialize a saved session file.
	277	*
	278	* @param filename The name of the filename to save the current session as.
	279	* Must not be NULL.
	280	* @param samplerate The samplerate to store for this session.
	281	* @param channels A NULL-terminated array of strings containing the names
	282	* of all the channels active in this session.
	283	*
	284	* @retval SR_OK Success
	285	* @retval SR_ERR_ARG Invalid arguments
	286	* @retval SR_ERR Other errors
	287	*/
	288	SR_API int sr_session_save_init(const char *filename, uint64_t samplerate,
	289	char **channels)
	290	{
	291	FILE *meta;
	292	struct zip *zipfile;
	293	struct zip_source versrc, metasrc;
	294	int tmpfile, cnt, ret, i;
	295	char version[1], metafile[32], *s;
	296
	297	if (!filename) {
	298	sr_err("%s: filename was NULL", __func__);
	299	return SR_ERR_ARG;
	300	}
	301
	302	/* Quietly delete it first, libzip wants replace ops otherwise. */
	303	unlink(filename);
	304	if (!(zipfile = zip_open(filename, ZIP_CREATE, &ret)))
	305	return SR_ERR;
	306
	307	/* "version" */
	308	version[0] = '2';
	309	if (!(versrc = zip_source_buffer(zipfile, version, 1, 0)))
	310	return SR_ERR;
	311	if (zip_add(zipfile, "version", versrc) == -1) {
	312	sr_info("error saving version into zipfile: %s",
	313	zip_strerror(zipfile));
	314	return SR_ERR;
	315	}
	316
	317	/* init "metadata" */
	318	strcpy(metafile, "sigrok-meta-XXXXXX");
	319	if ((tmpfile = g_mkstemp(metafile)) == -1)
	320	return SR_ERR;
	321	close(tmpfile);
	322	meta = g_fopen(metafile, "wb");
	323	fprintf(meta, "[global]\n");
	324	fprintf(meta, "sigrok version = %s\n", PACKAGE_VERSION);
	325
	326	/* metadata */
	327	fprintf(meta, "[device 1]\n");
	328
	329	/* metadata */
	330	fprintf(meta, "capturefile = logic-1\n");
	331	cnt = 0;
	332	for (i = 0; channels[i]; i++)
	333	cnt++;
	334	fprintf(meta, "total probes = %d\n", cnt);
	335	s = sr_samplerate_string(samplerate);
	336	fprintf(meta, "samplerate = %s\n", s);
	337	g_free(s);
	338
	339	for (i = 0; channels[i]; i++)
	340	fprintf(meta, "probe%d = %s\n", i + 1, channels[i]);
	341
	342	fclose(meta);
	343
	344	if (!(metasrc = zip_source_file(zipfile, metafile, 0, -1))) {
	345	unlink(metafile);
	346	return SR_ERR;
	347	}
	348	if (zip_add(zipfile, "metadata", metasrc) == -1) {
	349	unlink(metafile);
	350	return SR_ERR;
	351	}
	352
	353	if ((ret = zip_close(zipfile)) == -1) {
	354	sr_info("error saving zipfile: %s", zip_strerror(zipfile));
	355	unlink(metafile);
	356	return SR_ERR;
	357	}
	358
	359	unlink(metafile);
	360
	361	return SR_OK;
	362	}
	363
	364	/**
	365	* Append data to an existing session file.
	366	*
	367	* The session file must have been created with sr_session_save_init()
	368	* or sr_session_save() beforehand.
	369	*
	370	* @param filename The name of the filename to append to. Must not be NULL.
	371	* @param buf The data to be appended.
	372	* @param unitsize The number of bytes per sample.
	373	* @param units The number of samples.
	374	*
	375	* @retval SR_OK Success
	376	* @retval SR_ERR_ARG Invalid arguments
	377	* @retval SR_ERR Other errors
	378	*/
	379	SR_API int sr_session_append(const char filename, unsigned char buf,
	380	int unitsize, int units)
	381	{
	382	struct zip *archive;
	383	struct zip_source *logicsrc;
	384	zip_int64_t num_files;
	385	struct zip_file *zf;
	386	struct zip_stat zs;
	387	struct zip_source *metasrc;
	388	GKeyFile *kf;
	389	GError *error;
	390	gsize len;
	391	int chunk_num, next_chunk_num, tmpfile, ret, i;
	392	const char *entry_name;
	393	char *metafile, tmpname[32], chunkname[16];
	394
	395	if ((ret = sr_sessionfile_check(filename)) != SR_OK)
	396	return ret;
	397
	398	if (!(archive = zip_open(filename, 0, &ret)))
	399	return SR_ERR;
	400
	401	if (zip_stat(archive, "metadata", 0, &zs) == -1)
	402	return SR_ERR;
	403
	404	metafile = g_malloc(zs.size);
	405	zf = zip_fopen_index(archive, zs.index, 0);
	406	zip_fread(zf, metafile, zs.size);
	407	zip_fclose(zf);
	408
	409	/*
	410	* If the file was only initialized but doesn't yet have any
	411	* data it in, it won't have a unitsize field in metadata yet.
	412	*/
	413	error = NULL;
	414	kf = g_key_file_new();
	415	if (!g_key_file_load_from_data(kf, metafile, zs.size, 0, &error)) {
	416	sr_err("Failed to parse metadata: %s.", error->message);
	417	return SR_ERR;
	418	}
	419	g_free(metafile);
	420	tmpname[0] = '\0';
	421	if (!g_key_file_has_key(kf, "device 1", "unitsize", &error)) {
	422	if (error && error->code != G_KEY_FILE_ERROR_KEY_NOT_FOUND) {
	423	sr_err("Failed to check unitsize key: %s", error ? error->message : "?");
	424	return SR_ERR;
	425	}
	426	/* Add unitsize field. */
	427	g_key_file_set_integer(kf, "device 1", "unitsize", unitsize);
	428	metafile = g_key_file_to_data(kf, &len, &error);
	429	strcpy(tmpname, "sigrok-meta-XXXXXX");
	430	if ((tmpfile = g_mkstemp(tmpname)) == -1)
	431	return SR_ERR;
	432	if (write(tmpfile, metafile, len) < 0) {
	433	sr_dbg("Failed to create new metadata: %s", strerror(errno));
	434	g_free(metafile);
	435	unlink(tmpname);
	436	return SR_ERR;
	437	}
	438	close(tmpfile);
	439	if (!(metasrc = zip_source_file(archive, tmpname, 0, -1))) {
	440	sr_err("Failed to create zip source for metadata.");
	441	g_free(metafile);
	442	unlink(tmpname);
	443	return SR_ERR;
	444	}
	445	if (zip_replace(archive, zs.index, metasrc) == -1) {
	446	sr_err("Failed to replace metadata file.");
	447	g_free(metafile);
	448	unlink(tmpname);
	449	return SR_ERR;
	450	}
	451	g_free(metafile);
	452	}
	453	g_key_file_free(kf);
	454
	455	next_chunk_num = 1;
	456	num_files = zip_get_num_entries(archive, 0);
	457	for (i = 0; i < num_files; i++) {
	458	entry_name = zip_get_name(archive, i, 0);
	459	if (strncmp(entry_name, "logic-1", 7))
	460	continue;
	461	if (strlen(entry_name) == 7) {
	462	/* This file has no extra chunks, just a single "logic-1".
	463	* Rename it to "logic-1-1" * and continue with chunk 2. */
	464	if (zip_rename(archive, i, "logic-1-1") == -1) {
	465	sr_err("Failed to rename 'logic-1' to 'logic-1-1'.");
	466	unlink(tmpname);
	467	return SR_ERR;
	468	}
	469	next_chunk_num = 2;
	470	break;
	471	} else if (strlen(entry_name) > 8 && entry_name[7] == '-') {
	472	chunk_num = strtoull(entry_name + 8, NULL, 10);
	473	if (chunk_num >= next_chunk_num)
	474	next_chunk_num = chunk_num + 1;
	475	}
	476	}
	477	snprintf(chunkname, 15, "logic-1-%d", next_chunk_num);
	478	if (!(logicsrc = zip_source_buffer(archive, buf, units * unitsize, FALSE))) {
	479	unlink(tmpname);
	480	return SR_ERR;
	481	}
	482	if (zip_add(archive, chunkname, logicsrc) == -1) {
	483	unlink(tmpname);
	484	return SR_ERR;
	485	}
	486	if ((ret = zip_close(archive)) == -1) {
	487	sr_info("error saving session file: %s", zip_strerror(archive));
	488	unlink(tmpname);
	489	return SR_ERR;
	490	}
	491	unlink(tmpname);
	492
	493	return SR_OK;
	494	}
	495
	496	/** @} */