parsers.c

   1 /*
   2  * This file is part of the sigrok-cli project.
   3  *
   4  * Copyright (C) 2011 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 <config.h>
  21 #include <stdio.h>
  22 #include <stdlib.h>
  23 #include <stdint.h>
  24 #include <string.h>
  25 #include <glib.h>
  26 #include "sigrok-cli.h"
  27
  28 struct sr_channel *find_channel(GSList *channellist, const char *channelname,
  29         gboolean exact_case)
  30 {
  31         struct sr_channel *ch;
  32         GSList *l;
  33
  34         ch = NULL;
  35         for (l = channellist; l; l = l->next) {
  36                 ch = l->data;
  37                 if (exact_case) {
  38                         if (strcmp(ch->name, channelname) == 0)
  39                                 break;
  40                 } else {
  41                         if (g_ascii_strcasecmp(ch->name, channelname) == 0)
  42                                 break;
  43                 }
  44         }
  45         ch = l ? l->data : NULL;
  46
  47         return ch;
  48 }
  49
  50 GSList *parse_channelstring(struct sr_dev_inst *sdi, const char *channelstring)
  51 {
  52         struct sr_channel *ch;
  53         GSList *channellist, *channels;
  54         int ret, n, b, e, i;
  55         char **tokens, **range, **names, *eptr, str[8];
  56
  57         channels = sr_dev_inst_channels_get(sdi);
  58
  59         if (!channelstring || !channelstring[0])
  60                 /* Use all channels by default. */
  61                 return g_slist_copy(channels);
  62
  63         ret = SR_OK;
  64         range = NULL;
  65         names = NULL;
  66         channellist = NULL;
  67         tokens = g_strsplit(channelstring, ",", 0);
  68         for (i = 0; tokens[i]; i++) {
  69                 if (tokens[i][0] == '\0') {
  70                         g_critical("Invalid empty channel.");
  71                         ret = SR_ERR;
  72                         break;
  73                 }
  74                 if (strchr(tokens[i], '-')) {
  75                         /*
  76                          * A range of channels in the form a-b. This will only work
  77                          * if the channels are named as numbers -- so every channel
  78                          * in the range must exist as a channel name string in the
  79                          * device.
  80                          */
  81                         range = g_strsplit(tokens[i], "-", 2);
  82                         if (!range[0] || !range[1] || range[2]) {
  83                                 /* Need exactly two arguments. */
  84                                 g_critical("Invalid channel syntax '%s'.", tokens[i]);
  85                                 ret = SR_ERR;
  86                                 goto range_fail;
  87                         }
  88
  89                         b = strtol(range[0], &eptr, 10);
  90                         if (eptr == range[0] || *eptr != '\0') {
  91                                 g_critical("Invalid channel '%s'.", range[0]);
  92                                 ret = SR_ERR;
  93                                 goto range_fail;
  94                         }
  95                         e = strtol(range[1], NULL, 10);
  96                         if (eptr == range[1] || *eptr != '\0') {
  97                                 g_critical("Invalid channel '%s'.", range[1]);
  98                                 ret = SR_ERR;
  99                                 goto range_fail;
 100                         }
 101                         if (b < 0 || b >= e) {
 102                                 g_critical("Invalid channel range '%s'.", tokens[i]);
 103                                 ret = SR_ERR;
 104                                 goto range_fail;
 105                         }
 106
 107                         while (b <= e) {
 108                                 n = snprintf(str, 8, "%d", b);
 109                                 if (n < 0 || n > 8) {
 110                                         g_critical("Invalid channel '%d'.", b);
 111                                         ret = SR_ERR;
 112                                         break;
 113                                 }
 114                                 ch = find_channel(channels, str, TRUE);
 115                                 if (!ch) {
 116                                         g_critical("unknown channel '%d'.", b);
 117                                         ret = SR_ERR;
 118                                         break;
 119                                 }
 120                                 channellist = g_slist_append(channellist, ch);
 121                                 b++;
 122                         }
 123 range_fail:
 124                         if (range)
 125                                 g_strfreev(range);
 126
 127                         if (ret != SR_OK)
 128                                 break;
 129                 } else {
 130                         names = g_strsplit(tokens[i], "=", 2);
 131                         if (!names[0] || (names[1] && names[2])) {
 132                                 /* Need one or two arguments. */
 133                                 g_critical("Invalid channel '%s'.", tokens[i]);
 134                                 g_strfreev(names);
 135                                 ret = SR_ERR;
 136                                 break;
 137                         }
 138
 139                         ch = find_channel(channels, names[0], TRUE);
 140                         if (!ch) {
 141                                 g_critical("unknown channel '%s'.", names[0]);
 142                                 g_strfreev(names);
 143                                 ret = SR_ERR;
 144                                 break;
 145                         }
 146                         if (names[1]) {
 147                                 /* Rename channel. */
 148                                 sr_dev_channel_name_set(ch, names[1]);
 149                         }
 150                         channellist = g_slist_append(channellist, ch);
 151
 152                         g_strfreev(names);
 153                 }
 154         }
 155
 156         if (ret != SR_OK) {
 157                 g_slist_free(channellist);
 158                 channellist = NULL;
 159         }
 160
 161         g_strfreev(tokens);
 162
 163         return channellist;
 164 }
 165
 166 int parse_trigger_match(char c)
 167 {
 168         int match;
 169
 170         if (c == '0')
 171                 match = SR_TRIGGER_ZERO;
 172         else if (c == '1')
 173                 match = SR_TRIGGER_ONE;
 174         else if (c == 'r')
 175                 match = SR_TRIGGER_RISING;
 176         else if (c == 'f')
 177                 match = SR_TRIGGER_FALLING;
 178         else if (c == 'e')
 179                 match = SR_TRIGGER_EDGE;
 180         else if (c == 'o')
 181                 match = SR_TRIGGER_OVER;
 182         else if (c == 'u')
 183                 match = SR_TRIGGER_UNDER;
 184         else
 185                 match = 0;
 186
 187         return match;
 188 }
 189
 190 int parse_triggerstring(const struct sr_dev_inst *sdi, const char *s,
 191                 struct sr_trigger **trigger)
 192 {
 193         struct sr_channel *ch;
 194         struct sr_trigger_stage *stage;
 195         GVariant *gvar;
 196         GSList *l, *channels;
 197         gsize num_matches;
 198         gboolean found_match, error;
 199         const int32_t *matches;
 200         int32_t match;
 201         unsigned int j;
 202         int t, i;
 203         char **tokens, *sep;
 204         struct sr_dev_driver *driver;
 205
 206         driver = sr_dev_inst_driver_get(sdi);
 207         channels = sr_dev_inst_channels_get(sdi);
 208
 209         if (maybe_config_list(driver, sdi, NULL, SR_CONF_TRIGGER_MATCH,
 210                         &gvar) != SR_OK) {
 211                 g_critical("Device doesn't support any triggers.");
 212                 return FALSE;
 213         }
 214         matches = g_variant_get_fixed_array(gvar, &num_matches, sizeof(int32_t));
 215
 216         *trigger = sr_trigger_new(NULL);
 217         error = FALSE;
 218         tokens = g_strsplit(s, ",", -1);
 219         for (i = 0; tokens[i]; i++) {
 220                 if (!(sep = strchr(tokens[i], '='))) {
 221                         g_critical("Invalid trigger '%s'.", tokens[i]);
 222                         error = TRUE;
 223                         break;
 224                 }
 225                 *sep++ = 0;
 226                 ch = NULL;
 227                 for (l = channels; l; l = l->next) {
 228                         ch = l->data;
 229                         if (ch->enabled && !strcmp(ch->name, tokens[i]))
 230                                 break;
 231                         ch = NULL;
 232                 }
 233                 if (!ch) {
 234                         g_critical("Invalid channel '%s'.", tokens[i]);
 235                         error = TRUE;
 236                         break;
 237                 }
 238                 for (t = 0; sep[t]; t++) {
 239                         if (!(match = parse_trigger_match(sep[t]))) {
 240                                 g_critical("Invalid trigger match '%c'.", sep[t]);
 241                                 error = TRUE;
 242                                 break;
 243                         }
 244                         found_match = FALSE;
 245                         for (j = 0; j < num_matches; j++) {
 246                                 if (matches[j] == match) {
 247                                         found_match = TRUE;
 248                                         break;
 249                                 }
 250                         }
 251                         if (!found_match) {
 252                                 g_critical("Trigger match '%c' not supported by device.", sep[t]);
 253                                 error = TRUE;
 254                                 break;
 255                         }
 256                         /* Make sure this ends up in the right stage, creating
 257                          * them as needed. */
 258                         while (!(stage = g_slist_nth_data((*trigger)->stages, t)))
 259                                 sr_trigger_stage_add(*trigger);
 260                         if (sr_trigger_match_add(stage, ch, match, 0) != SR_OK) {
 261                                 error = TRUE;
 262                                 break;
 263                         }
 264                 }
 265         }
 266         g_strfreev(tokens);
 267         g_variant_unref(gvar);
 268
 269         if (error)
 270                 sr_trigger_free(*trigger);
 271
 272         return !error;
 273 }
 274
 275 /**
 276  * Split an input text into a key and value respectively ('=' separator).
 277  *
 278  * @param[in] text Writeable copy of the input text, gets modified.
 279  * @param[out] key Position of the keyword.
 280  * @param[out] val Position of the value.
 281  *
 282  * TODO In theory the returned key/value locations could be const pointers.
 283  * Which even would be preferrable. Unfortunately most call sites deal with
 284  * glib hashes, and their insert API seriously lacks the const attribute.
 285  * So we drop it here as well to avoid clutter at callers'.
 286  */
 287 static void split_key_value(char *text, char **key, char **val)
 288 {
 289         char *k, *v;
 290         char *pos;
 291
 292         if (key)
 293                 *key = NULL;
 294         if (val)
 295                 *val = NULL;
 296         if (!text || !*text)
 297                 return;
 298
 299         k = text;
 300         v = NULL;
 301         pos = strchr(k, '=');
 302         if (pos) {
 303                 *pos = '\0';
 304                 v = ++pos;
 305         }
 306         if (key)
 307                 *key = k;
 308         if (val)
 309                 *val = v;
 310 }
 311
 312 /**
 313  * Create hash table from colon separated key-value pairs input text.
 314  *
 315  * Accepts input text as it was specified by users. Splits the colon
 316  * separated key-value pairs and creates a hash table from these items.
 317  * Optionally supports special forms which are useful for different CLI
 318  * features.
 319  *
 320  * Typical form: <key>=<val>[:<key>=<val>]*
 321  * Generic list of key-value pairs, all items being equal. Mere set.
 322  *
 323  * ID form: <id>[:<key>=<val>]*
 324  * First item is not a key-value pair, instead it's an identifier. Used
 325  * to specify a protocol decoder, or a device driver, or an input/output
 326  * file format, optionally followed by more parameters' values. The ID
 327  * part of the input spec is not optional.
 328  *
 329  * Optional ID: [<sel>=<id>][:<key>=<val>]*
 330  * All items are key-value pairs. The first item _may_ be an identifier,
 331  * if its key matches a caller specified key name. Otherwise the input
 332  * text is the above typical form, a mere list of key-value pairs while
 333  * none of them is special.
 334  *
 335  * @param[in] arg Input text.
 336  * @param[in] sep_first Boolean, whether ID form is required.
 337  * @param[in] key_first Keyword name if optional ID is applicable.
 338  *
 339  * @returns A hash table which contains the key/value pairs, or #NULL
 340  *   when the input is invalid.
 341  */
 342 GHashTable *parse_generic_arg(const char *arg,
 343         gboolean sep_first, const char *key_first)
 344 {
 345         GHashTable *hash;
 346         char **elements;
 347         int i;
 348         char *k, *v;
 349
 350         if (!arg || !arg[0])
 351                 return NULL;
 352         if (key_first && !key_first[0])
 353                 key_first = NULL;
 354
 355         hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 356         elements = g_strsplit(arg, ":", 0);
 357         i = 0;
 358         if (sep_first) {
 359                 k = g_strdup("sigrok_key");
 360                 v = g_strdup(elements[i++]);
 361                 g_hash_table_insert(hash, k, v);
 362         } else if (key_first) {
 363                 split_key_value(elements[i], &k, &v);
 364                 if (g_ascii_strcasecmp(k, key_first) == 0) {
 365                         k = "sigrok_key";
 366                 }
 367                 k = g_strdup(k);
 368                 v = g_strdup(v);
 369                 g_hash_table_insert(hash, k, v);
 370                 i++;
 371         }
 372         for (; elements[i]; i++) {
 373                 if (!elements[i][0])
 374                         continue;
 375                 split_key_value(elements[i], &k, &v);
 376                 k = g_strdup(k);
 377                 v = v ? g_strdup(v) : NULL;
 378                 g_hash_table_insert(hash, k, v);
 379         }
 380         g_strfreev(elements);
 381
 382         return hash;
 383 }
 384
 385 GSList *check_unknown_keys(const struct sr_option **avail, GHashTable *used)
 386 {
 387         GSList *unknown;
 388         GHashTableIter iter;
 389         void *key;
 390         const char *used_id;
 391         size_t avail_idx;
 392         const char *avail_id, *found_id;
 393
 394         /* Collect a list of used but not available keywords. */
 395         unknown = NULL;
 396         g_hash_table_iter_init(&iter, used);
 397         while (g_hash_table_iter_next(&iter, &key, NULL)) {
 398                 used_id = key;
 399                 found_id = NULL;
 400                 for (avail_idx = 0; avail[avail_idx] && avail[avail_idx]->id; avail_idx++) {
 401                         avail_id = avail[avail_idx]->id;
 402                         if (strcmp(avail_id, used_id) == 0) {
 403                                 found_id = avail_id;
 404                                 break;
 405                         }
 406                 }
 407                 if (!found_id)
 408                         unknown = g_slist_append(unknown, g_strdup(used_id));
 409         }
 410
 411         /* Return the list of unknown keywords, or NULL if empty. */
 412         return unknown;
 413 }
 414
 415 gboolean warn_unknown_keys(const struct sr_option **avail, GHashTable *used,
 416         const char *caption)
 417 {
 418         GSList *unknown, *l;
 419         gboolean had_unknown;
 420         const char *s;
 421
 422         if (!caption || !*caption)
 423                 caption = "Unknown keyword";
 424
 425         unknown = check_unknown_keys(avail, used);
 426         had_unknown = unknown != NULL;
 427         for (l = unknown; l; l = l->next) {
 428                 s = l->data;
 429                 g_warning("%s: %s.", caption, s);
 430         }
 431         g_slist_free_full(unknown, g_free);
 432
 433         return had_unknown;
 434 }
 435
 436 GHashTable *generic_arg_to_opt(const struct sr_option **opts, GHashTable *genargs)
 437 {
 438         GHashTable *hash;
 439         GVariant *gvar;
 440         int i;
 441         char *s;
 442         gboolean b;
 443
 444         hash = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
 445                         (GDestroyNotify)g_variant_unref);
 446         for (i = 0; opts[i]; i++) {
 447                 if (!(s = g_hash_table_lookup(genargs, opts[i]->id)))
 448                         continue;
 449                 if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_UINT32)) {
 450                         gvar = g_variant_new_uint32(strtoul(s, NULL, 10));
 451                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 452                                         g_variant_ref_sink(gvar));
 453                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_INT32)) {
 454                         gvar = g_variant_new_int32(strtol(s, NULL, 10));
 455                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 456                                         g_variant_ref_sink(gvar));
 457                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_UINT64)) {
 458                         gvar = g_variant_new_uint64(strtoull(s, NULL, 10));
 459                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 460                                         g_variant_ref_sink(gvar));
 461                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_DOUBLE)) {
 462                         gvar = g_variant_new_double(strtod(s, NULL));
 463                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 464                                         g_variant_ref_sink(gvar));
 465                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_STRING)) {
 466                         gvar = g_variant_new_string(s);
 467                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 468                                         g_variant_ref_sink(gvar));
 469                 } else if (g_variant_is_of_type(opts[i]->def, G_VARIANT_TYPE_BOOLEAN)) {
 470                         b = TRUE;
 471                         if (0 == strcmp(s, "false") || 0 == strcmp(s, "no")) {
 472                                 b = FALSE;
 473                         } else if (!(0 == strcmp(s, "true") || 0 == strcmp(s, "yes"))) {
 474                                 g_critical("Unable to convert '%s' to boolean!", s);
 475                         }
 476
 477                         gvar = g_variant_new_boolean(b);
 478                         g_hash_table_insert(hash, g_strdup(opts[i]->id),
 479                                         g_variant_ref_sink(gvar));
 480                 } else {
 481                         g_critical("Don't know GVariant type for option '%s'!", opts[i]->id);
 482                  }
 483         }
 484
 485         return hash;
 486 }
 487
 488 static char *strcanon(const char *str)
 489 {
 490         int p0, p1;
 491         char *s;
 492
 493         /* Returns newly allocated string. */
 494         s = g_ascii_strdown(str, -1);
 495         for (p0 = p1 = 0; str[p0]; p0++) {
 496                 if ((s[p0] >= 'a' && s[p0] <= 'z')
 497                                 || (s[p0] >= '0' && s[p0] <= '9'))
 498                         s[p1++] = s[p0];
 499         }
 500         s[p1] = '\0';
 501
 502         return s;
 503 }
 504
 505 int canon_cmp(const char *str1, const char *str2)
 506 {
 507         int ret;
 508         char *s1, *s2;
 509
 510         s1 = strcanon(str1);
 511         s2 = strcanon(str2);
 512         ret = g_ascii_strcasecmp(s1, s2);
 513         g_free(s2);
 514         g_free(s1);
 515
 516         return ret;
 517 }
 518
 519 /* Convert driver options hash to GSList of struct sr_config. */
 520 static GSList *hash_to_hwopt(GHashTable *hash)
 521 {
 522         struct sr_config *src;
 523         GList *gl, *keys;
 524         GSList *opts;
 525         char *key;
 526
 527         keys = g_hash_table_get_keys(hash);
 528         opts = NULL;
 529         for (gl = keys; gl; gl = gl->next) {
 530                 key = gl->data;
 531                 src = g_malloc(sizeof(struct sr_config));
 532                 if (opt_to_gvar(key, g_hash_table_lookup(hash, key), src) != 0)
 533                         return NULL;
 534                 opts = g_slist_append(opts, src);
 535         }
 536         g_list_free(keys);
 537
 538         return opts;
 539 }
 540
 541 int parse_driver(char *arg, struct sr_dev_driver **driver, GSList **drvopts)
 542 {
 543         struct sr_dev_driver **drivers;
 544         GHashTable *drvargs;
 545         int i;
 546         char *drvname;
 547
 548         if (!arg)
 549                 return FALSE;
 550
 551         drvargs = parse_generic_arg(arg, TRUE, NULL);
 552
 553         drvname = g_strdup(g_hash_table_lookup(drvargs, "sigrok_key"));
 554         g_hash_table_remove(drvargs, "sigrok_key");
 555         *driver = NULL;
 556         drivers = sr_driver_list(sr_ctx);
 557         for (i = 0; drivers[i]; i++) {
 558                 if (strcmp(drivers[i]->name, drvname))
 559                         continue;
 560                 *driver = drivers[i];
 561         }
 562         if (!*driver) {
 563                 g_critical("Driver %s not found.", drvname);
 564                 g_hash_table_destroy(drvargs);
 565                 g_free(drvname);
 566                 return FALSE;
 567         }
 568         g_free(drvname);
 569         if (sr_driver_init(sr_ctx, *driver) != SR_OK) {
 570                 g_critical("Failed to initialize driver.");
 571                 g_hash_table_destroy(drvargs);
 572                 return FALSE;
 573         }
 574
 575         if (drvopts) {
 576                 *drvopts = NULL;
 577                 if (g_hash_table_size(drvargs) > 0) {
 578                         if (!(*drvopts = hash_to_hwopt(drvargs))) {
 579                                 /* Unknown options, already logged. */
 580                                 g_hash_table_destroy(drvargs);
 581                                 return FALSE;
 582                         }
 583                 }
 584         }
 585
 586         g_hash_table_destroy(drvargs);
 587
 588         return TRUE;
 589 }