libsigrokdecode  0.4.0
sigrok protocol decoding library
decoder.c
Go to the documentation of this file.
1 /*
2  * This file is part of the libsigrokdecode project.
3  *
4  * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
5  * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
6  *
7  * This program is free software: you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation, either version 3 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program. If not, see <http://www.gnu.org/licenses/>.
19  */
20 
21 #include <config.h>
22 #include "libsigrokdecode-internal.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */
23 #include "libsigrokdecode.h"
24 #include <glib.h>
25 
26 /**
27  * @file
28  *
29  * Listing, loading, unloading, and handling protocol decoders.
30  */
31 
32 /**
33  * @defgroup grp_decoder Protocol decoders
34  *
35  * Handling protocol decoders.
36  *
37  * @{
38  */
39 
40 /** @cond PRIVATE */
41 
42 /* The list of loaded protocol decoders. */
43 static GSList *pd_list = NULL;
44 
45 /* srd.c */
46 extern SRD_PRIV GSList *searchpaths;
47 
48 /* session.c */
49 extern SRD_PRIV GSList *sessions;
50 extern SRD_PRIV int max_session_id;
51 
52 /* module_sigrokdecode.c */
53 extern SRD_PRIV PyObject *mod_sigrokdecode;
54 
55 /** @endcond */
56 
57 static gboolean srd_check_init(void)
58 {
59  if (max_session_id < 0) {
60  srd_err("Library is not initialized.");
61  return FALSE;
62  } else
63  return TRUE;
64 }
65 
66 /**
67  * Returns the list of loaded protocol decoders.
68  *
69  * This is a GSList of pointers to struct srd_decoder items.
70  *
71  * @return List of decoders, NULL if none are supported or loaded.
72  *
73  * @since 0.2.0
74  */
75 SRD_API const GSList *srd_decoder_list(void)
76 {
77  return pd_list;
78 }
79 
80 /**
81  * Get the decoder with the specified ID.
82  *
83  * @param id The ID string of the decoder to return.
84  *
85  * @return The decoder with the specified ID, or NULL if not found.
86  *
87  * @since 0.1.0
88  */
89 SRD_API struct srd_decoder *srd_decoder_get_by_id(const char *id)
90 {
91  GSList *l;
92  struct srd_decoder *dec;
93 
94  for (l = pd_list; l; l = l->next) {
95  dec = l->data;
96  if (!strcmp(dec->id, id))
97  return dec;
98  }
99 
100  return NULL;
101 }
102 
103 static void channel_free(void *data)
104 {
105  struct srd_channel *ch = data;
106 
107  if (!ch)
108  return;
109 
110  g_free(ch->desc);
111  g_free(ch->name);
112  g_free(ch->id);
113  g_free(ch);
114 }
115 
116 static void variant_free(void *data)
117 {
118  GVariant *var = data;
119 
120  if (!var)
121  return;
122 
123  g_variant_unref(var);
124 }
125 
126 static void annotation_row_free(void *data)
127 {
128  struct srd_decoder_annotation_row *row = data;
129 
130  if (!row)
131  return;
132 
133  g_slist_free(row->ann_classes);
134  g_free(row->desc);
135  g_free(row->id);
136  g_free(row);
137 }
138 
139 static void decoder_option_free(void *data)
140 {
141  struct srd_decoder_option *opt = data;
142 
143  if (!opt)
144  return;
145 
146  g_slist_free_full(opt->values, &variant_free);
147  variant_free(opt->def);
148  g_free(opt->desc);
149  g_free(opt->id);
150  g_free(opt);
151 }
152 
153 static void decoder_free(struct srd_decoder *dec)
154 {
155  if (!dec)
156  return;
157 
158  Py_XDECREF(dec->py_dec);
159  Py_XDECREF(dec->py_mod);
160 
161  g_slist_free_full(dec->options, &decoder_option_free);
162  g_slist_free_full(dec->binary, (GDestroyNotify)&g_strfreev);
163  g_slist_free_full(dec->annotation_rows, &annotation_row_free);
164  g_slist_free_full(dec->annotations, (GDestroyNotify)&g_strfreev);
165  g_slist_free_full(dec->opt_channels, &channel_free);
166  g_slist_free_full(dec->channels, &channel_free);
167 
168  g_free(dec->license);
169  g_free(dec->desc);
170  g_free(dec->longname);
171  g_free(dec->name);
172  g_free(dec->id);
173 
174  g_free(dec);
175 }
176 
177 static int get_channels(const struct srd_decoder *d, const char *attr,
178  GSList **out_pdchl, int offset)
179 {
180  PyObject *py_channellist, *py_entry;
181  struct srd_channel *pdch;
182  GSList *pdchl;
183  ssize_t i;
184 
185  if (!PyObject_HasAttrString(d->py_dec, attr))
186  /* No channels of this type specified. */
187  return SRD_OK;
188 
189  pdchl = NULL;
190 
191  py_channellist = PyObject_GetAttrString(d->py_dec, attr);
192  if (!py_channellist)
193  goto except_out;
194 
195  if (!PyTuple_Check(py_channellist)) {
196  srd_err("Protocol decoder %s %s attribute is not a tuple.",
197  d->name, attr);
198  goto err_out;
199  }
200 
201  for (i = PyTuple_Size(py_channellist) - 1; i >= 0; i--) {
202  py_entry = PyTuple_GetItem(py_channellist, i);
203  if (!py_entry)
204  goto except_out;
205 
206  if (!PyDict_Check(py_entry)) {
207  srd_err("Protocol decoder %s %s attribute is not "
208  "a list of dict elements.", d->name, attr);
209  goto err_out;
210  }
211  pdch = g_malloc0(sizeof(struct srd_channel));
212  /* Add to list right away so it doesn't get lost. */
213  pdchl = g_slist_prepend(pdchl, pdch);
214 
215  if (py_dictitem_as_str(py_entry, "id", &pdch->id) != SRD_OK)
216  goto err_out;
217  if (py_dictitem_as_str(py_entry, "name", &pdch->name) != SRD_OK)
218  goto err_out;
219  if (py_dictitem_as_str(py_entry, "desc", &pdch->desc) != SRD_OK)
220  goto err_out;
221 
222  pdch->order = offset + i;
223  }
224 
225  Py_DECREF(py_channellist);
226  *out_pdchl = pdchl;
227 
228  return SRD_OK;
229 
230 except_out:
231  srd_exception_catch("Failed to get %s list of %s decoder",
232  attr, d->name);
233 err_out:
234  g_slist_free_full(pdchl, &channel_free);
235  Py_XDECREF(py_channellist);
236 
237  return SRD_ERR_PYTHON;
238 }
239 
240 static int get_options(struct srd_decoder *d)
241 {
242  PyObject *py_opts, *py_opt, *py_str, *py_values, *py_default, *py_item;
243  GSList *options;
244  struct srd_decoder_option *o;
245  GVariant *gvar;
246  ssize_t opt, i;
247 
248  if (!PyObject_HasAttrString(d->py_dec, "options"))
249  /* No options, that's fine. */
250  return SRD_OK;
251 
252  options = NULL;
253 
254  /* If present, options must be a tuple. */
255  py_opts = PyObject_GetAttrString(d->py_dec, "options");
256  if (!py_opts)
257  goto except_out;
258 
259  if (!PyTuple_Check(py_opts)) {
260  srd_err("Protocol decoder %s: options attribute is not "
261  "a tuple.", d->id);
262  goto err_out;
263  }
264 
265  for (opt = PyTuple_Size(py_opts) - 1; opt >= 0; opt--) {
266  py_opt = PyTuple_GetItem(py_opts, opt);
267  if (!py_opt)
268  goto except_out;
269 
270  if (!PyDict_Check(py_opt)) {
271  srd_err("Protocol decoder %s options: each option "
272  "must consist of a dictionary.", d->name);
273  goto err_out;
274  }
275 
276  o = g_malloc0(sizeof(struct srd_decoder_option));
277  /* Add to list right away so it doesn't get lost. */
278  options = g_slist_prepend(options, o);
279 
280  py_str = PyDict_GetItemString(py_opt, "id");
281  if (!py_str) {
282  srd_err("Protocol decoder %s option %zd has no id.",
283  d->name, opt);
284  goto err_out;
285  }
286  if (py_str_as_str(py_str, &o->id) != SRD_OK)
287  goto err_out;
288 
289  py_str = PyDict_GetItemString(py_opt, "desc");
290  if (py_str) {
291  if (py_str_as_str(py_str, &o->desc) != SRD_OK)
292  goto err_out;
293  }
294 
295  py_default = PyDict_GetItemString(py_opt, "default");
296  if (py_default) {
297  gvar = py_obj_to_variant(py_default);
298  if (!gvar) {
299  srd_err("Protocol decoder %s option 'default' has "
300  "invalid default value.", d->name);
301  goto err_out;
302  }
303  o->def = g_variant_ref_sink(gvar);
304  }
305 
306  py_values = PyDict_GetItemString(py_opt, "values");
307  if (py_values) {
308  /* A default is required if a list of values is
309  * given, since it's used to verify their type. */
310  if (!o->def) {
311  srd_err("No default for option '%s'.", o->id);
312  goto err_out;
313  }
314  if (!PyTuple_Check(py_values)) {
315  srd_err("Option '%s' values should be a tuple.", o->id);
316  goto err_out;
317  }
318 
319  for (i = PyTuple_Size(py_values) - 1; i >= 0; i--) {
320  py_item = PyTuple_GetItem(py_values, i);
321  if (!py_item)
322  goto except_out;
323 
324  if (Py_TYPE(py_default) != Py_TYPE(py_item)) {
325  srd_err("All values for option '%s' must be "
326  "of the same type as the default.",
327  o->id);
328  goto err_out;
329  }
330  gvar = py_obj_to_variant(py_item);
331  if (!gvar) {
332  srd_err("Protocol decoder %s option 'values' "
333  "contains invalid value.", d->name);
334  goto err_out;
335  }
336  o->values = g_slist_prepend(o->values,
337  g_variant_ref_sink(gvar));
338  }
339  }
340  }
341  d->options = options;
342  Py_DECREF(py_opts);
343 
344  return SRD_OK;
345 
346 except_out:
347  srd_exception_catch("Failed to get %s decoder options", d->name);
348 err_out:
349  g_slist_free_full(options, &decoder_option_free);
350  Py_XDECREF(py_opts);
351 
352  return SRD_ERR_PYTHON;
353 }
354 
355 /* Convert annotation class attribute to GSList of char **.
356  */
357 static int get_annotations(struct srd_decoder *dec)
358 {
359  PyObject *py_annlist, *py_ann;
360  GSList *annotations;
361  char **annpair;
362  ssize_t i;
363 
364  if (!PyObject_HasAttrString(dec->py_dec, "annotations"))
365  return SRD_OK;
366 
367  annotations = NULL;
368 
369  py_annlist = PyObject_GetAttrString(dec->py_dec, "annotations");
370  if (!py_annlist)
371  goto except_out;
372 
373  if (!PyTuple_Check(py_annlist)) {
374  srd_err("Protocol decoder %s annotations should "
375  "be a tuple.", dec->name);
376  goto err_out;
377  }
378 
379  for (i = PyTuple_Size(py_annlist) - 1; i >= 0; i--) {
380  py_ann = PyTuple_GetItem(py_annlist, i);
381  if (!py_ann)
382  goto except_out;
383 
384  if (!PyTuple_Check(py_ann) || PyTuple_Size(py_ann) != 2) {
385  srd_err("Protocol decoder %s annotation %zd should "
386  "be a tuple with two elements.",
387  dec->name, i + 1);
388  goto err_out;
389  }
390  if (py_strseq_to_char(py_ann, &annpair) != SRD_OK)
391  goto err_out;
392 
393  annotations = g_slist_prepend(annotations, annpair);
394  }
395  dec->annotations = annotations;
396  Py_DECREF(py_annlist);
397 
398  return SRD_OK;
399 
400 except_out:
401  srd_exception_catch("Failed to get %s decoder annotations", dec->name);
402 err_out:
403  g_slist_free_full(annotations, (GDestroyNotify)&g_strfreev);
404  Py_XDECREF(py_annlist);
405 
406  return SRD_ERR_PYTHON;
407 }
408 
409 /* Convert annotation_rows to GSList of 'struct srd_decoder_annotation_row'.
410  */
411 static int get_annotation_rows(struct srd_decoder *dec)
412 {
413  PyObject *py_ann_rows, *py_ann_row, *py_ann_classes, *py_item;
414  GSList *annotation_rows;
415  struct srd_decoder_annotation_row *ann_row;
416  ssize_t i, k;
417  size_t class_idx;
418 
419  if (!PyObject_HasAttrString(dec->py_dec, "annotation_rows"))
420  return SRD_OK;
421 
422  annotation_rows = NULL;
423 
424  py_ann_rows = PyObject_GetAttrString(dec->py_dec, "annotation_rows");
425  if (!py_ann_rows)
426  goto except_out;
427 
428  if (!PyTuple_Check(py_ann_rows)) {
429  srd_err("Protocol decoder %s annotation_rows "
430  "must be a tuple.", dec->name);
431  goto err_out;
432  }
433 
434  for (i = PyTuple_Size(py_ann_rows) - 1; i >= 0; i--) {
435  py_ann_row = PyTuple_GetItem(py_ann_rows, i);
436  if (!py_ann_row)
437  goto except_out;
438 
439  if (!PyTuple_Check(py_ann_row) || PyTuple_Size(py_ann_row) != 3) {
440  srd_err("Protocol decoder %s annotation_rows "
441  "must contain only tuples of 3 elements.",
442  dec->name);
443  goto err_out;
444  }
445  ann_row = g_malloc0(sizeof(struct srd_decoder_annotation_row));
446  /* Add to list right away so it doesn't get lost. */
447  annotation_rows = g_slist_prepend(annotation_rows, ann_row);
448 
449  py_item = PyTuple_GetItem(py_ann_row, 0);
450  if (!py_item)
451  goto except_out;
452  if (py_str_as_str(py_item, &ann_row->id) != SRD_OK)
453  goto err_out;
454 
455  py_item = PyTuple_GetItem(py_ann_row, 1);
456  if (!py_item)
457  goto except_out;
458  if (py_str_as_str(py_item, &ann_row->desc) != SRD_OK)
459  goto err_out;
460 
461  py_ann_classes = PyTuple_GetItem(py_ann_row, 2);
462  if (!py_ann_classes)
463  goto except_out;
464 
465  if (!PyTuple_Check(py_ann_classes)) {
466  srd_err("Protocol decoder %s annotation_rows tuples "
467  "must have a tuple of numbers as 3rd element.",
468  dec->name);
469  goto err_out;
470  }
471 
472  for (k = PyTuple_Size(py_ann_classes) - 1; k >= 0; k--) {
473  py_item = PyTuple_GetItem(py_ann_classes, k);
474  if (!py_item)
475  goto except_out;
476 
477  if (!PyLong_Check(py_item)) {
478  srd_err("Protocol decoder %s annotation row "
479  "class tuple must only contain numbers.",
480  dec->name);
481  goto err_out;
482  }
483  class_idx = PyLong_AsSize_t(py_item);
484  if (PyErr_Occurred())
485  goto except_out;
486 
487  ann_row->ann_classes = g_slist_prepend(ann_row->ann_classes,
488  GSIZE_TO_POINTER(class_idx));
489  }
490  }
491  dec->annotation_rows = annotation_rows;
492  Py_DECREF(py_ann_rows);
493 
494  return SRD_OK;
495 
496 except_out:
497  srd_exception_catch("Failed to get %s decoder annotation rows",
498  dec->name);
499 err_out:
500  g_slist_free_full(annotation_rows, &annotation_row_free);
501  Py_XDECREF(py_ann_rows);
502 
503  return SRD_ERR_PYTHON;
504 }
505 
506 /* Convert binary classes to GSList of char **.
507  */
508 static int get_binary_classes(struct srd_decoder *dec)
509 {
510  PyObject *py_bin_classes, *py_bin_class;
511  GSList *bin_classes;
512  char **bin;
513  ssize_t i;
514 
515  if (!PyObject_HasAttrString(dec->py_dec, "binary"))
516  return SRD_OK;
517 
518  bin_classes = NULL;
519 
520  py_bin_classes = PyObject_GetAttrString(dec->py_dec, "binary");
521  if (!py_bin_classes)
522  goto except_out;
523 
524  if (!PyTuple_Check(py_bin_classes)) {
525  srd_err("Protocol decoder %s binary classes should "
526  "be a tuple.", dec->name);
527  goto err_out;
528  }
529 
530  for (i = PyTuple_Size(py_bin_classes) - 1; i >= 0; i--) {
531  py_bin_class = PyTuple_GetItem(py_bin_classes, i);
532  if (!py_bin_class)
533  goto except_out;
534 
535  if (!PyTuple_Check(py_bin_class)
536  || PyTuple_Size(py_bin_class) != 2) {
537  srd_err("Protocol decoder %s binary classes should "
538  "consist only of tuples of 2 elements.",
539  dec->name);
540  goto err_out;
541  }
542  if (py_strseq_to_char(py_bin_class, &bin) != SRD_OK)
543  goto err_out;
544 
545  bin_classes = g_slist_prepend(bin_classes, bin);
546  }
547  dec->binary = bin_classes;
548  Py_DECREF(py_bin_classes);
549 
550  return SRD_OK;
551 
552 except_out:
553  srd_exception_catch("Failed to get %s decoder binary classes",
554  dec->name);
555 err_out:
556  g_slist_free_full(bin_classes, (GDestroyNotify)&g_strfreev);
557  Py_XDECREF(py_bin_classes);
558 
559  return SRD_ERR_PYTHON;
560 }
561 
562 /* Check whether the Decoder class defines the named method.
563  */
564 static int check_method(PyObject *py_dec, const char *mod_name,
565  const char *method_name)
566 {
567  PyObject *py_method;
568  int is_callable;
569 
570  py_method = PyObject_GetAttrString(py_dec, method_name);
571  if (!py_method) {
572  srd_exception_catch("Protocol decoder %s Decoder class "
573  "has no %s() method", mod_name, method_name);
574  return SRD_ERR_PYTHON;
575  }
576 
577  is_callable = PyCallable_Check(py_method);
578  Py_DECREF(py_method);
579 
580  if (!is_callable) {
581  srd_err("Protocol decoder %s Decoder class attribute '%s' "
582  "is not a method.", mod_name, method_name);
583  return SRD_ERR_PYTHON;
584  }
585 
586  return SRD_OK;
587 }
588 
589 /**
590  * Load a protocol decoder module into the embedded Python interpreter.
591  *
592  * @param module_name The module name to be loaded.
593  *
594  * @return SRD_OK upon success, a (negative) error code otherwise.
595  *
596  * @since 0.1.0
597  */
598 SRD_API int srd_decoder_load(const char *module_name)
599 {
600  PyObject *py_basedec, *py_apiver;
601  struct srd_decoder *d;
602  long apiver;
603  int is_subclass;
604 
605  if (!srd_check_init())
606  return SRD_ERR;
607 
608  if (!module_name)
609  return SRD_ERR_ARG;
610 
611  if (PyDict_GetItemString(PyImport_GetModuleDict(), module_name)) {
612  /* Module was already imported. */
613  return SRD_OK;
614  }
615 
616  srd_dbg("Loading protocol decoder '%s'.", module_name);
617 
618  d = g_malloc0(sizeof(struct srd_decoder));
619 
620  d->py_mod = py_import_by_name(module_name);
621  if (!d->py_mod)
622  goto except_out;
623 
624  if (!mod_sigrokdecode) {
625  srd_err("sigrokdecode module not loaded.");
626  goto err_out;
627  }
628 
629  /* Get the 'Decoder' class as Python object. */
630  d->py_dec = PyObject_GetAttrString(d->py_mod, "Decoder");
631  if (!d->py_dec)
632  goto except_out;
633 
634  py_basedec = PyObject_GetAttrString(mod_sigrokdecode, "Decoder");
635  if (!py_basedec)
636  goto except_out;
637 
638  is_subclass = PyObject_IsSubclass(d->py_dec, py_basedec);
639  Py_DECREF(py_basedec);
640 
641  if (!is_subclass) {
642  srd_err("Decoder class in protocol decoder module %s is not "
643  "a subclass of sigrokdecode.Decoder.", module_name);
644  goto err_out;
645  }
646 
647  /*
648  * Check that this decoder has the correct PD API version.
649  * PDs of different API versions are incompatible and cannot work.
650  */
651  py_apiver = PyObject_GetAttrString(d->py_dec, "api_version");
652  apiver = (py_apiver && PyLong_Check(py_apiver))
653  ? PyLong_AsLong(py_apiver) : 0;
654  Py_XDECREF(py_apiver);
655 
656  if (apiver != 2) {
657  srd_exception_catch("Only PDs of API version 2 are supported");
658  goto err_out;
659  }
660 
661  /* Check Decoder class for required methods.
662  */
663  if (check_method(d->py_dec, module_name, "start") != SRD_OK)
664  goto err_out;
665 
666  if (check_method(d->py_dec, module_name, "decode") != SRD_OK)
667  goto err_out;
668 
669  /* Store required fields in newly allocated strings. */
670  if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK)
671  goto err_out;
672 
673  if (py_attr_as_str(d->py_dec, "name", &(d->name)) != SRD_OK)
674  goto err_out;
675 
676  if (py_attr_as_str(d->py_dec, "longname", &(d->longname)) != SRD_OK)
677  goto err_out;
678 
679  if (py_attr_as_str(d->py_dec, "desc", &(d->desc)) != SRD_OK)
680  goto err_out;
681 
682  if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK)
683  goto err_out;
684 
685  /* All options and their default values. */
686  if (get_options(d) != SRD_OK)
687  goto err_out;
688 
689  /* Check and import required channels. */
690  if (get_channels(d, "channels", &d->channels, 0) != SRD_OK)
691  goto err_out;
692 
693  /* Check and import optional channels. */
694  if (get_channels(d, "optional_channels", &d->opt_channels,
695  g_slist_length(d->channels)) != SRD_OK)
696  goto err_out;
697 
698  if (get_annotations(d) != SRD_OK)
699  goto err_out;
700 
701  if (get_annotation_rows(d) != SRD_OK)
702  goto err_out;
703 
704  if (get_binary_classes(d) != SRD_OK)
705  goto err_out;
706 
707  /* Append it to the list of loaded decoders. */
708  pd_list = g_slist_append(pd_list, d);
709 
710  return SRD_OK;
711 
712 except_out:
713  srd_exception_catch("Failed to load decoder %s", module_name);
714 err_out:
715  decoder_free(d);
716 
717  return SRD_ERR_PYTHON;
718 }
719 
720 /**
721  * Return a protocol decoder's docstring.
722  *
723  * @param dec The loaded protocol decoder.
724  *
725  * @return A newly allocated buffer containing the protocol decoder's
726  * documentation. The caller is responsible for free'ing the buffer.
727  *
728  * @since 0.1.0
729  */
730 SRD_API char *srd_decoder_doc_get(const struct srd_decoder *dec)
731 {
732  PyObject *py_str;
733  char *doc;
734 
735  if (!srd_check_init())
736  return NULL;
737 
738  if (!dec)
739  return NULL;
740 
741  if (!PyObject_HasAttrString(dec->py_mod, "__doc__"))
742  return NULL;
743 
744  if (!(py_str = PyObject_GetAttrString(dec->py_mod, "__doc__"))) {
745  srd_exception_catch("Failed to get docstring");
746  return NULL;
747  }
748 
749  doc = NULL;
750  if (py_str != Py_None)
751  py_str_as_str(py_str, &doc);
752  Py_DECREF(py_str);
753 
754  return doc;
755 }
756 
757 /**
758  * Unload the specified protocol decoder.
759  *
760  * @param dec The struct srd_decoder to be unloaded.
761  *
762  * @return SRD_OK upon success, a (negative) error code otherwise.
763  *
764  * @since 0.1.0
765  */
767 {
768  struct srd_session *sess;
769  GSList *l;
770 
771  if (!srd_check_init())
772  return SRD_ERR;
773 
774  if (!dec)
775  return SRD_ERR_ARG;
776 
777  srd_dbg("Unloading protocol decoder '%s'.", dec->name);
778 
779  /*
780  * Since any instances of this decoder need to be released as well,
781  * but they could be anywhere in the stack, just free the entire
782  * stack. A frontend reloading a decoder thus has to restart all
783  * instances, and rebuild the stack.
784  */
785  for (l = sessions; l; l = l->next) {
786  sess = l->data;
787  srd_inst_free_all(sess, NULL);
788  }
789 
790  /* Remove the PD from the list of loaded decoders. */
791  pd_list = g_slist_remove(pd_list, dec);
792 
793  decoder_free(dec);
794 
795  return SRD_OK;
796 }
797 
798 static void srd_decoder_load_all_zip_path(char *path)
799 {
800  PyObject *zipimport_mod, *zipimporter_class, *zipimporter;
801  PyObject *prefix_obj, *files, *key, *value, *set, *modname;
802  Py_ssize_t pos = 0;
803  char *prefix;
804  size_t prefix_len;
805 
806  set = files = prefix_obj = zipimporter = zipimporter_class = NULL;
807 
808  zipimport_mod = py_import_by_name("zipimport");
809  if (zipimport_mod == NULL)
810  goto err_out;
811 
812  zipimporter_class = PyObject_GetAttrString(zipimport_mod, "zipimporter");
813  if (zipimporter_class == NULL)
814  goto err_out;
815 
816  zipimporter = PyObject_CallFunction(zipimporter_class, "s", path);
817  if (zipimporter == NULL)
818  goto err_out;
819 
820  prefix_obj = PyObject_GetAttrString(zipimporter, "prefix");
821  if (prefix_obj == NULL)
822  goto err_out;
823 
824  files = PyObject_GetAttrString(zipimporter, "_files");
825  if (files == NULL || !PyDict_Check(files))
826  goto err_out;
827 
828  set = PySet_New(NULL);
829  if (set == NULL)
830  goto err_out;
831 
832  if (py_str_as_str(prefix_obj, &prefix) != SRD_OK)
833  goto err_out;
834 
835  prefix_len = strlen(prefix);
836 
837  while (PyDict_Next(files, &pos, &key, &value)) {
838  char *path, *slash;
839  if (py_str_as_str(key, &path) == SRD_OK) {
840  if (strlen(path) > prefix_len
841  && memcmp(path, prefix, prefix_len) == 0
842  && (slash = strchr(path + prefix_len, '/'))) {
843 
844  modname = PyUnicode_FromStringAndSize(path + prefix_len,
845  slash - (path + prefix_len));
846  if (modname == NULL) {
847  PyErr_Clear();
848  } else {
849  PySet_Add(set, modname);
850  Py_DECREF(modname);
851  }
852  }
853  g_free(path);
854  }
855  }
856  g_free(prefix);
857 
858  while ((modname = PySet_Pop(set))) {
859  char *modname_str;
860  if (py_str_as_str(modname, &modname_str) == SRD_OK) {
861  /* The directory name is the module name (e.g. "i2c"). */
862  srd_decoder_load(modname_str);
863  g_free(modname_str);
864  }
865  Py_DECREF(modname);
866  }
867 
868 err_out:
869  Py_XDECREF(set);
870  Py_XDECREF(files);
871  Py_XDECREF(prefix_obj);
872  Py_XDECREF(zipimporter);
873  Py_XDECREF(zipimporter_class);
874  Py_XDECREF(zipimport_mod);
875  PyErr_Clear();
876 }
877 
878 static void srd_decoder_load_all_path(char *path)
879 {
880  GDir *dir;
881  const gchar *direntry;
882 
883  if (!(dir = g_dir_open(path, 0, NULL))) {
884  /* Not really fatal */
885  /* Try zipimport method too */
886  srd_decoder_load_all_zip_path(path);
887  return;
888  }
889 
890  /* This ignores errors returned by srd_decoder_load(). That
891  * function will have logged the cause, but in any case we
892  * want to continue anyway. */
893  while ((direntry = g_dir_read_name(dir)) != NULL) {
894  /* The directory name is the module name (e.g. "i2c"). */
895  srd_decoder_load(direntry);
896  }
897  g_dir_close(dir);
898 
899 }
900 
901 /**
902  * Load all installed protocol decoders.
903  *
904  * @return SRD_OK upon success, a (negative) error code otherwise.
905  *
906  * @since 0.1.0
907  */
909 {
910  GSList *l;
911 
912  if (!srd_check_init())
913  return SRD_ERR;
914 
915  for (l = searchpaths; l; l = l->next)
916  srd_decoder_load_all_path(l->data);
917 
918  return SRD_OK;
919 }
920 
921 /**
922  * Unload all loaded protocol decoders.
923  *
924  * @return SRD_OK upon success, a (negative) error code otherwise.
925  *
926  * @since 0.1.0
927  */
929 {
930  GSList *l;
931  struct srd_decoder *dec;
932 
933  for (l = pd_list; l; l = l->next) {
934  dec = l->data;
935  srd_decoder_unload(dec);
936  }
937  g_slist_free(pd_list);
938  pd_list = NULL;
939 
940  return SRD_OK;
941 }
942 
943 /** @} */
char * name
The name of the channel.
void * py_mod
Python module.
char * license
The license of the decoder.
The public libsigrokdecode header file to be used by frontends.
int srd_decoder_unload_all(void)
Unload all loaded protocol decoders.
Definition: decoder.c:928
#define SRD_PRIV
int srd_decoder_load(const char *module_name)
Load a protocol decoder module into the embedded Python interpreter.
Definition: decoder.c:598
GSList * annotations
List of NULL-terminated char[], containing descriptions of the supported annotation output...
void * py_dec
sigrokdecode.Decoder class.
char * srd_decoder_doc_get(const struct srd_decoder *dec)
Return a protocol decoder&#39;s docstring.
Definition: decoder.c:730
#define SRD_API
char * desc
The description of the channel.
GSList * annotation_rows
List of annotation rows (row items: id, description, and a list of annotation classes belonging to th...
Python C API error.
GSList * opt_channels
List of optional channels for this decoder.
No error.
int order
The index of the channel, i.e.
Function argument error.
Generic/unspecified error.
int srd_decoder_load_all(void)
Load all installed protocol decoders.
Definition: decoder.c:908
const GSList * srd_decoder_list(void)
Returns the list of loaded protocol decoders.
Definition: decoder.c:75
struct srd_decoder * srd_decoder_get_by_id(const char *id)
Get the decoder with the specified ID.
Definition: decoder.c:89
char * name
The (short) decoder name.
int srd_decoder_unload(struct srd_decoder *dec)
Unload the specified protocol decoder.
Definition: decoder.c:766
GSList * binary
List of NULL-terminated char[], containing descriptions of the supported binary output.
char * longname
The (long) decoder name.
char * id
The decoder ID.
Structure which contains information about one protocol decoder channel.
GSList * options
List of decoder options.
GSList * channels
List of channels required by this decoder.
char * desc
A (short, one-line) description of the decoder.
char * id
The ID of the channel.