Adjust to GVariant-based sr_config_* functions

diff --git a/device.c b/device.c
index d489ef3f8cff7d6e1e65d2443e801aaa7cebe069..0a78a802e3c7f14f9cf90dda983c358504ac64ac 100644 (file)
--- a/device.c
+++ b/device.c
@@ -192,22 +192,28 @@ SR_API int sr_dev_trigger_set(const struct sr_dev_inst *sdi, int probenum,
  */
 SR_API gboolean sr_dev_has_option(const struct sr_dev_inst *sdi, int key)
 {
+       GVariant *gvar;
        const int *devopts;
-       int i;
+       gsize num_opts, i;
+       int ret;
 
-       if (!sdi || !sdi->driver)
+       if (!sdi || !sdi->driver || !sdi->driver->config_list)
                return FALSE;
 
-       if (sdi->driver->config_list(SR_CONF_DEVICE_OPTIONS,
-                       (const void **)&devopts, NULL) != SR_OK)
+       if (sdi->driver->config_list(SR_CONF_DEVICE_OPTIONS, &gvar, NULL) != SR_OK)
                return FALSE;
 
-       for (i = 0; devopts[i]; i++) {
-               if (devopts[i] == key)
-                       return TRUE;
+       ret = FALSE;
+       devopts = g_variant_get_fixed_array(gvar, &num_opts, sizeof(int32_t));
+       for (i = 0; i < num_opts; i++) {
+               if (devopts[i] == key) {
+                       ret = TRUE;
+                       break;
+               }
        }
+       g_variant_unref(gvar);
 
-       return FALSE;
+       return ret;
 }
 
 /** @private */

diff --git a/session_driver.c b/session_driver.c
index 4a517d7ae6771120de193c40f5aaa3331987b670..0efd304de2bce9fbc72d93cdfccc4987d35263a0 100644 (file)
--- a/session_driver.c
+++ b/session_driver.c
@@ -148,7 +148,7 @@ static int hw_dev_open(struct sr_dev_inst *sdi)
        return SR_OK;
 }
 
-static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
+static int config_get(int id, GVariant **data, const struct sr_dev_inst *sdi)
 {
        struct session_vdev *vdev;
 
@@ -156,7 +156,7 @@ static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
        case SR_CONF_SAMPLERATE:
                if (sdi) {
                        vdev = sdi->priv;
-                       *data = &vdev->samplerate;
+                       *data = g_variant_new_uint64(vdev->samplerate);
                } else
                        return SR_ERR;
                break;
@@ -167,34 +167,30 @@ static int config_get(int id, const void **data, const struct sr_dev_inst *sdi)
        return SR_OK;
 }
 
-static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
+static int config_set(int id, GVariant *data, const struct sr_dev_inst *sdi)
 {
        struct session_vdev *vdev;
-       const uint64_t *tmp_u64;
 
        vdev = sdi->priv;
 
        switch (id) {
        case SR_CONF_SAMPLERATE:
-               tmp_u64 = value;
-               vdev->samplerate = *tmp_u64;
+               vdev->samplerate = g_variant_get_uint64(data);
                sr_info("Setting samplerate to %" PRIu64 ".", vdev->samplerate);
                break;
        case SR_CONF_SESSIONFILE:
-               vdev->sessionfile = g_strdup(value);
+               vdev->sessionfile = g_strdup(g_variant_get_string(data, NULL));
                sr_info("Setting sessionfile to '%s'.", vdev->sessionfile);
                break;
        case SR_CONF_CAPTUREFILE:
-               vdev->capturefile = g_strdup(value);
+               vdev->capturefile = g_strdup(g_variant_get_string(data, NULL));
                sr_info("Setting capturefile to '%s'.", vdev->capturefile);
                break;
        case SR_CONF_CAPTURE_UNITSIZE:
-               tmp_u64 = value;
-               vdev->unitsize = *tmp_u64;
+               vdev->unitsize = g_variant_get_uint64(data);
                break;
        case SR_CONF_CAPTURE_NUM_PROBES:
-               tmp_u64 = value;
-               vdev->num_probes = *tmp_u64;
+               vdev->num_probes = g_variant_get_uint64(data);
                break;
        default:
                sr_err("Unknown capability: %d.", id);
@@ -204,14 +200,15 @@ static int config_set(int id, const void *value, const struct sr_dev_inst *sdi)
        return SR_OK;
 }
 
-static int config_list(int key, const void **data, const struct sr_dev_inst *sdi)
+static int config_list(int key, GVariant **data, const struct sr_dev_inst *sdi)
 {
 
        (void)sdi;
 
        switch (key) {
        case SR_CONF_DEVICE_OPTIONS:
-               *data = hwcaps;
+               *data = g_variant_new_fixed_array(G_VARIANT_TYPE_INT32,
+                               hwcaps, ARRAY_SIZE(hwcaps), sizeof(int32_t));
                break;
        default:
                return SR_ERR_ARG;

diff --git a/session_file.c b/session_file.c
index 108f00e6aba22023e262f5b77ed40d9c3cae3a89..c743e5c465a0b46fc901cfb6fcace7fdf5e568c2 100644 (file)
--- a/session_file.c
+++ b/session_file.c
@@ -135,7 +135,7 @@ SR_API int sr_session_load(const char *filename)
                if (!strncmp(sections[i], "device ", 7)) {
                        /* device section */
                        sdi = NULL;
-                       enabled_probes = 0;
+                       enabled_probes = total_probes = 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);
@@ -146,18 +146,23 @@ SR_API int sr_session_load(const char *filename)
                                                /* first device, init the driver */
                                                sdi->driver->init(NULL);
                                        sr_session_dev_add(sdi);
-                                       sdi->driver->config_set(SR_CONF_SESSIONFILE, filename, sdi);
-                                       sdi->driver->config_set(SR_CONF_CAPTUREFILE, val, sdi);
+                                       sdi->driver->config_set(SR_CONF_SESSIONFILE,
+                                                       g_variant_new_string(filename), sdi);
+                                       sdi->driver->config_set(SR_CONF_CAPTUREFILE,
+                                                       g_variant_new_string(val), sdi);
                                        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, &tmp_u64, sdi);
+                                       sdi->driver->config_set(SR_CONF_SAMPLERATE,
+                                                       g_variant_new_uint64(tmp_u64), sdi);
                                } else if (!strcmp(keys[j], "unitsize")) {
                                        tmp_u64 = strtoull(val, NULL, 10);
-                                       sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE, &tmp_u64, sdi);
+                                       sdi->driver->config_set(SR_CONF_CAPTURE_UNITSIZE,
+                                                       g_variant_new_uint64(tmp_u64), sdi);
                                } else if (!strcmp(keys[j], "total probes")) {
                                        total_probes = strtoull(val, NULL, 10);
-                                       sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES, &total_probes, sdi);
+                                       sdi->driver->config_set(SR_CONF_CAPTURE_NUM_PROBES,
+                                                       g_variant_new_uint64(total_probes), sdi);
                                        for (p = 0; p < total_probes; p++) {
                                                snprintf(probename, SR_MAX_PROBENAME_LEN, "%" PRIu64, p);
                                                if (!(probe = sr_probe_new(p, SR_PROBE_LOGIC, TRUE,
@@ -179,8 +184,9 @@ SR_API int sr_session_load(const char *filename)
                        }
                        g_strfreev(keys);
                        /* Disable probes not specifically listed. */
-                       for (p = enabled_probes; p < total_probes; p++)
-                               sr_dev_probe_enable(sdi, p, FALSE);
+                       if (total_probes)
+                               for (p = enabled_probes; p < total_probes; p++)
+                                       sr_dev_probe_enable(sdi, p, FALSE);
                }
                devcnt++;
        }
@@ -207,12 +213,13 @@ SR_API int sr_session_save(const char *filename, const struct sr_dev_inst *sdi,
                unsigned char *buf, int unitsize, int units)
 {
        GSList *l;
+       GVariant *gvar;
        FILE *meta;
        struct sr_probe *probe;
        struct zip *zipfile;
        struct zip_source *versrc, *metasrc, *logicsrc;
        int tmpfile, ret, probecnt;
-       uint64_t *samplerate;
+       uint64_t samplerate;
        char version[1], rawname[16], metafile[32], *s;
 
        if (!filename) {
@@ -255,10 +262,12 @@ SR_API int sr_session_save(const char *filename, const struct sr_dev_inst *sdi,
        fprintf(meta, "total probes = %d\n", g_slist_length(sdi->probes));
        if (sr_dev_has_option(sdi, SR_CONF_SAMPLERATE)) {
                if (sr_config_get(sdi->driver, SR_CONF_SAMPLERATE,
-                               (const void **)&samplerate, sdi) == SR_OK) {
-                       s = sr_samplerate_string(*samplerate);
+                               &gvar, sdi) == SR_OK) {
+                       samplerate = g_variant_get_uint64(gvar);
+                       s = sr_samplerate_string(samplerate);
                        fprintf(meta, "samplerate = %s\n", s);
                        g_free(s);
+                       g_variant_unref(gvar);
                }
        }
        probecnt = 1;

diff --git a/strutil.c b/strutil.c
index ad9f64974fe8c477df34f9749700ad1f11bddd1e..5b14f51afc74741d767e5f3ebdf863d8da44daf4 100644 (file)
--- a/strutil.c
+++ b/strutil.c
@@ -216,6 +216,7 @@ SR_API char **sr_parse_triggerstring(const struct sr_dev_inst *sdi,
                                     const char *triggerstring)
 {
        GSList *l;
+       GVariant *gvar;
        struct sr_probe *probe;
        int max_probes, probenum, i;
        char **tokens, **triggerlist, *trigger, *tc;
@@ -230,11 +231,11 @@ SR_API char **sr_parse_triggerstring(const struct sr_dev_inst *sdi,
                return NULL;
        }
 
-       if (sdi->driver->config_list(SR_CONF_TRIGGER_TYPE,
-                       (const void **)&trigger_types, sdi) != SR_OK) {
+       if (sdi->driver->config_list(SR_CONF_TRIGGER_TYPE, &gvar, sdi) != SR_OK) {
                sr_err("%s: Device doesn't support any triggers.", __func__);
                return NULL;
        }
+       trigger_types = g_variant_get_string(gvar, NULL);
 
        tokens = g_strsplit(triggerstring, ",", max_probes);
        for (i = 0; tokens[i]; i++) {
@@ -269,6 +270,7 @@ SR_API char **sr_parse_triggerstring(const struct sr_dev_inst *sdi,
                }
        }
        g_strfreev(tokens);
+       g_variant_unref(gvar);
 
        if (error) {
                for (i = 0; i < max_probes; i++)