[libsigrok.git] / src / 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"

/** @cond PRIVATE */
#define LOG_PREFIX "session-file"
/** @endcond */

/**
 * @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.
 * @param session The session to load the file into. 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, struct sr_session **session)
{
	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 devcnt, ret, i, j;
	uint64_t tmp_u64, total_channels, enabled_channels, p;
	char **sections, **keys, *metafile, *val;
	char channelname[SR_MAX_CHANNELNAME_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;
	}

	if ((ret = sr_session_new(session)) != SR_OK)
		return ret;

	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(*session, 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_CHANNELS,
							g_variant_new_uint64(total_channels), sdi, NULL);
					for (p = 0; p < total_channels; p++) {
						snprintf(channelname, SR_MAX_CHANNELNAME_LEN, "%" PRIu64, p);
						if (!(ch = sr_channel_new(p, SR_CHANNEL_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_channel_name_set(sdi, tmp_u64 - 1, val);
				}
			}
			g_strfreev(keys);
			/* Disable channels not specifically listed. */
			if (total_channels)
				for (p = enabled_channels; p < total_channels; p++)
					sr_dev_channel_enable(sdi, p, FALSE);
		}
		devcnt++;
	}
	g_strfreev(sections);
	g_key_file_free(kf);

	return SR_OK;
}

/**
 * Save a session to the specified file.
 *
 * @param session The session to save to the specified file. Must not be NULL.
 * @param filename The name of the filename to save the 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
 *
 * @since 0.2.0
 */
SR_API int sr_session_save(struct sr_session *session, 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_CHANNEL_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(session, filename, samplerate,
			channel_names)) != SR_OK)
		return ret;

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

	return ret;
}

/**
 * Initialize a saved session file.
 *
 * @param session The session to use. Must not be NULL.
 * @param filename The name of the filename to save the 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
 *
 * @since 0.3.0
 */
SR_API int sr_session_save_init(struct sr_session *session,
		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;

	(void)session;

	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 session The session to use. Must not be NULL.
 * @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
 *
 * @since 0.3.0
 */
SR_API int sr_session_append(struct sr_session *session, 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];

	(void)session;

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