libsigrokdecode  0.5.1
sigrok protocol decoding library
 All Data Structures Files Functions Variables Typedefs Enumerations Enumerator Macros Modules Pages
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  PyGILState_STATE gstate;
156 
157  if (!dec)
158  return;
159 
160  gstate = PyGILState_Ensure();
161  Py_XDECREF(dec->py_dec);
162  Py_XDECREF(dec->py_mod);
163  PyGILState_Release(gstate);
164 
165  g_slist_free_full(dec->options, &decoder_option_free);
166  g_slist_free_full(dec->binary, (GDestroyNotify)&g_strfreev);
167  g_slist_free_full(dec->annotation_rows, &annotation_row_free);
168  g_slist_free_full(dec->annotations, (GDestroyNotify)&g_strfreev);
169  g_slist_free_full(dec->opt_channels, &channel_free);
170  g_slist_free_full(dec->channels, &channel_free);
171 
172  g_slist_free_full(dec->outputs, g_free);
173  g_slist_free_full(dec->inputs, g_free);
174  g_free(dec->license);
175  g_free(dec->desc);
176  g_free(dec->longname);
177  g_free(dec->name);
178  g_free(dec->id);
179 
180  g_free(dec);
181 }
182 
183 static int get_channels(const struct srd_decoder *d, const char *attr,
184  GSList **out_pdchl, int offset)
185 {
186  PyObject *py_channellist, *py_entry;
187  struct srd_channel *pdch;
188  GSList *pdchl;
189  ssize_t i;
190  PyGILState_STATE gstate;
191 
192  gstate = PyGILState_Ensure();
193 
194  if (!PyObject_HasAttrString(d->py_dec, attr)) {
195  /* No channels of this type specified. */
196  PyGILState_Release(gstate);
197  return SRD_OK;
198  }
199 
200  pdchl = NULL;
201 
202  py_channellist = PyObject_GetAttrString(d->py_dec, attr);
203  if (!py_channellist)
204  goto except_out;
205 
206  if (!PyTuple_Check(py_channellist)) {
207  srd_err("Protocol decoder %s %s attribute is not a tuple.",
208  d->name, attr);
209  goto err_out;
210  }
211 
212  for (i = PyTuple_Size(py_channellist) - 1; i >= 0; i--) {
213  py_entry = PyTuple_GetItem(py_channellist, i);
214  if (!py_entry)
215  goto except_out;
216 
217  if (!PyDict_Check(py_entry)) {
218  srd_err("Protocol decoder %s %s attribute is not "
219  "a list of dict elements.", d->name, attr);
220  goto err_out;
221  }
222  pdch = g_malloc0(sizeof(struct srd_channel));
223  /* Add to list right away so it doesn't get lost. */
224  pdchl = g_slist_prepend(pdchl, pdch);
225 
226  if (py_dictitem_as_str(py_entry, "id", &pdch->id) != SRD_OK)
227  goto err_out;
228  if (py_dictitem_as_str(py_entry, "name", &pdch->name) != SRD_OK)
229  goto err_out;
230  if (py_dictitem_as_str(py_entry, "desc", &pdch->desc) != SRD_OK)
231  goto err_out;
232 
233  pdch->order = offset + i;
234  }
235 
236  Py_DECREF(py_channellist);
237  *out_pdchl = pdchl;
238 
239  PyGILState_Release(gstate);
240 
241  return SRD_OK;
242 
243 except_out:
244  srd_exception_catch("Failed to get %s list of %s decoder",
245  attr, d->name);
246 err_out:
247  g_slist_free_full(pdchl, &channel_free);
248  Py_XDECREF(py_channellist);
249  PyGILState_Release(gstate);
250 
251  return SRD_ERR_PYTHON;
252 }
253 
254 static int get_options(struct srd_decoder *d)
255 {
256  PyObject *py_opts, *py_opt, *py_str, *py_values, *py_default, *py_item;
257  GSList *options;
258  struct srd_decoder_option *o;
259  GVariant *gvar;
260  ssize_t opt, i;
261  PyGILState_STATE gstate;
262 
263  gstate = PyGILState_Ensure();
264 
265  if (!PyObject_HasAttrString(d->py_dec, "options")) {
266  /* No options, that's fine. */
267  PyGILState_Release(gstate);
268  return SRD_OK;
269  }
270 
271  options = NULL;
272 
273  /* If present, options must be a tuple. */
274  py_opts = PyObject_GetAttrString(d->py_dec, "options");
275  if (!py_opts)
276  goto except_out;
277 
278  if (!PyTuple_Check(py_opts)) {
279  srd_err("Protocol decoder %s: options attribute is not "
280  "a tuple.", d->id);
281  goto err_out;
282  }
283 
284  for (opt = PyTuple_Size(py_opts) - 1; opt >= 0; opt--) {
285  py_opt = PyTuple_GetItem(py_opts, opt);
286  if (!py_opt)
287  goto except_out;
288 
289  if (!PyDict_Check(py_opt)) {
290  srd_err("Protocol decoder %s options: each option "
291  "must consist of a dictionary.", d->name);
292  goto err_out;
293  }
294 
295  o = g_malloc0(sizeof(struct srd_decoder_option));
296  /* Add to list right away so it doesn't get lost. */
297  options = g_slist_prepend(options, o);
298 
299  py_str = PyDict_GetItemString(py_opt, "id");
300  if (!py_str) {
301  srd_err("Protocol decoder %s option %zd has no ID.",
302  d->name, opt);
303  goto err_out;
304  }
305  if (py_str_as_str(py_str, &o->id) != SRD_OK)
306  goto err_out;
307 
308  py_str = PyDict_GetItemString(py_opt, "desc");
309  if (py_str) {
310  if (py_str_as_str(py_str, &o->desc) != SRD_OK)
311  goto err_out;
312  }
313 
314  py_default = PyDict_GetItemString(py_opt, "default");
315  if (py_default) {
316  gvar = py_obj_to_variant(py_default);
317  if (!gvar) {
318  srd_err("Protocol decoder %s option 'default' has "
319  "invalid default value.", d->name);
320  goto err_out;
321  }
322  o->def = g_variant_ref_sink(gvar);
323  }
324 
325  py_values = PyDict_GetItemString(py_opt, "values");
326  if (py_values) {
327  /* A default is required if a list of values is
328  * given, since it's used to verify their type. */
329  if (!o->def) {
330  srd_err("No default for option '%s'.", o->id);
331  goto err_out;
332  }
333  if (!PyTuple_Check(py_values)) {
334  srd_err("Option '%s' values should be a tuple.", o->id);
335  goto err_out;
336  }
337 
338  for (i = PyTuple_Size(py_values) - 1; i >= 0; i--) {
339  py_item = PyTuple_GetItem(py_values, i);
340  if (!py_item)
341  goto except_out;
342 
343  if (Py_TYPE(py_default) != Py_TYPE(py_item)) {
344  srd_err("All values for option '%s' must be "
345  "of the same type as the default.",
346  o->id);
347  goto err_out;
348  }
349  gvar = py_obj_to_variant(py_item);
350  if (!gvar) {
351  srd_err("Protocol decoder %s option 'values' "
352  "contains invalid value.", d->name);
353  goto err_out;
354  }
355  o->values = g_slist_prepend(o->values,
356  g_variant_ref_sink(gvar));
357  }
358  }
359  }
360  d->options = options;
361  Py_DECREF(py_opts);
362  PyGILState_Release(gstate);
363 
364  return SRD_OK;
365 
366 except_out:
367  srd_exception_catch("Failed to get %s decoder options", d->name);
368 err_out:
369  g_slist_free_full(options, &decoder_option_free);
370  Py_XDECREF(py_opts);
371  PyGILState_Release(gstate);
372 
373  return SRD_ERR_PYTHON;
374 }
375 
376 /* Convert annotation class attribute to GSList of char **.
377  */
378 static int get_annotations(struct srd_decoder *dec)
379 {
380  PyObject *py_annlist, *py_ann;
381  GSList *annotations;
382  char **annpair;
383  ssize_t i;
384  PyGILState_STATE gstate;
385 
386  gstate = PyGILState_Ensure();
387 
388  if (!PyObject_HasAttrString(dec->py_dec, "annotations")) {
389  PyGILState_Release(gstate);
390  return SRD_OK;
391  }
392 
393  annotations = NULL;
394 
395  py_annlist = PyObject_GetAttrString(dec->py_dec, "annotations");
396  if (!py_annlist)
397  goto except_out;
398 
399  if (!PyTuple_Check(py_annlist)) {
400  srd_err("Protocol decoder %s annotations should "
401  "be a tuple.", dec->name);
402  goto err_out;
403  }
404 
405  for (i = PyTuple_Size(py_annlist) - 1; i >= 0; i--) {
406  py_ann = PyTuple_GetItem(py_annlist, i);
407  if (!py_ann)
408  goto except_out;
409 
410  if (!PyTuple_Check(py_ann) || PyTuple_Size(py_ann) != 2) {
411  srd_err("Protocol decoder %s annotation %zd should "
412  "be a tuple with two elements.",
413  dec->name, i + 1);
414  goto err_out;
415  }
416  if (py_strseq_to_char(py_ann, &annpair) != SRD_OK)
417  goto err_out;
418 
419  annotations = g_slist_prepend(annotations, annpair);
420  }
421  dec->annotations = annotations;
422  Py_DECREF(py_annlist);
423  PyGILState_Release(gstate);
424 
425  return SRD_OK;
426 
427 except_out:
428  srd_exception_catch("Failed to get %s decoder annotations", dec->name);
429 err_out:
430  g_slist_free_full(annotations, (GDestroyNotify)&g_strfreev);
431  Py_XDECREF(py_annlist);
432  PyGILState_Release(gstate);
433 
434  return SRD_ERR_PYTHON;
435 }
436 
437 /* Convert annotation_rows to GSList of 'struct srd_decoder_annotation_row'.
438  */
439 static int get_annotation_rows(struct srd_decoder *dec)
440 {
441  PyObject *py_ann_rows, *py_ann_row, *py_ann_classes, *py_item;
442  GSList *annotation_rows;
443  struct srd_decoder_annotation_row *ann_row;
444  ssize_t i, k;
445  size_t class_idx;
446  PyGILState_STATE gstate;
447 
448  gstate = PyGILState_Ensure();
449 
450  if (!PyObject_HasAttrString(dec->py_dec, "annotation_rows")) {
451  PyGILState_Release(gstate);
452  return SRD_OK;
453  }
454 
455  annotation_rows = NULL;
456 
457  py_ann_rows = PyObject_GetAttrString(dec->py_dec, "annotation_rows");
458  if (!py_ann_rows)
459  goto except_out;
460 
461  if (!PyTuple_Check(py_ann_rows)) {
462  srd_err("Protocol decoder %s annotation_rows "
463  "must be a tuple.", dec->name);
464  goto err_out;
465  }
466 
467  for (i = PyTuple_Size(py_ann_rows) - 1; i >= 0; i--) {
468  py_ann_row = PyTuple_GetItem(py_ann_rows, i);
469  if (!py_ann_row)
470  goto except_out;
471 
472  if (!PyTuple_Check(py_ann_row) || PyTuple_Size(py_ann_row) != 3) {
473  srd_err("Protocol decoder %s annotation_rows "
474  "must contain only tuples of 3 elements.",
475  dec->name);
476  goto err_out;
477  }
478  ann_row = g_malloc0(sizeof(struct srd_decoder_annotation_row));
479  /* Add to list right away so it doesn't get lost. */
480  annotation_rows = g_slist_prepend(annotation_rows, ann_row);
481 
482  py_item = PyTuple_GetItem(py_ann_row, 0);
483  if (!py_item)
484  goto except_out;
485  if (py_str_as_str(py_item, &ann_row->id) != SRD_OK)
486  goto err_out;
487 
488  py_item = PyTuple_GetItem(py_ann_row, 1);
489  if (!py_item)
490  goto except_out;
491  if (py_str_as_str(py_item, &ann_row->desc) != SRD_OK)
492  goto err_out;
493 
494  py_ann_classes = PyTuple_GetItem(py_ann_row, 2);
495  if (!py_ann_classes)
496  goto except_out;
497 
498  if (!PyTuple_Check(py_ann_classes)) {
499  srd_err("Protocol decoder %s annotation_rows tuples "
500  "must have a tuple of numbers as 3rd element.",
501  dec->name);
502  goto err_out;
503  }
504 
505  for (k = PyTuple_Size(py_ann_classes) - 1; k >= 0; k--) {
506  py_item = PyTuple_GetItem(py_ann_classes, k);
507  if (!py_item)
508  goto except_out;
509 
510  if (!PyLong_Check(py_item)) {
511  srd_err("Protocol decoder %s annotation row "
512  "class tuple must only contain numbers.",
513  dec->name);
514  goto err_out;
515  }
516  class_idx = PyLong_AsSize_t(py_item);
517  if (PyErr_Occurred())
518  goto except_out;
519 
520  ann_row->ann_classes = g_slist_prepend(ann_row->ann_classes,
521  GSIZE_TO_POINTER(class_idx));
522  }
523  }
524  dec->annotation_rows = annotation_rows;
525  Py_DECREF(py_ann_rows);
526  PyGILState_Release(gstate);
527 
528  return SRD_OK;
529 
530 except_out:
531  srd_exception_catch("Failed to get %s decoder annotation rows",
532  dec->name);
533 err_out:
534  g_slist_free_full(annotation_rows, &annotation_row_free);
535  Py_XDECREF(py_ann_rows);
536  PyGILState_Release(gstate);
537 
538  return SRD_ERR_PYTHON;
539 }
540 
541 /* Convert binary classes to GSList of char **.
542  */
543 static int get_binary_classes(struct srd_decoder *dec)
544 {
545  PyObject *py_bin_classes, *py_bin_class;
546  GSList *bin_classes;
547  char **bin;
548  ssize_t i;
549  PyGILState_STATE gstate;
550 
551  gstate = PyGILState_Ensure();
552 
553  if (!PyObject_HasAttrString(dec->py_dec, "binary")) {
554  PyGILState_Release(gstate);
555  return SRD_OK;
556  }
557 
558  bin_classes = NULL;
559 
560  py_bin_classes = PyObject_GetAttrString(dec->py_dec, "binary");
561  if (!py_bin_classes)
562  goto except_out;
563 
564  if (!PyTuple_Check(py_bin_classes)) {
565  srd_err("Protocol decoder %s binary classes should "
566  "be a tuple.", dec->name);
567  goto err_out;
568  }
569 
570  for (i = PyTuple_Size(py_bin_classes) - 1; i >= 0; i--) {
571  py_bin_class = PyTuple_GetItem(py_bin_classes, i);
572  if (!py_bin_class)
573  goto except_out;
574 
575  if (!PyTuple_Check(py_bin_class)
576  || PyTuple_Size(py_bin_class) != 2) {
577  srd_err("Protocol decoder %s binary classes should "
578  "consist only of tuples of 2 elements.",
579  dec->name);
580  goto err_out;
581  }
582  if (py_strseq_to_char(py_bin_class, &bin) != SRD_OK)
583  goto err_out;
584 
585  bin_classes = g_slist_prepend(bin_classes, bin);
586  }
587  dec->binary = bin_classes;
588  Py_DECREF(py_bin_classes);
589  PyGILState_Release(gstate);
590 
591  return SRD_OK;
592 
593 except_out:
594  srd_exception_catch("Failed to get %s decoder binary classes",
595  dec->name);
596 err_out:
597  g_slist_free_full(bin_classes, (GDestroyNotify)&g_strfreev);
598  Py_XDECREF(py_bin_classes);
599  PyGILState_Release(gstate);
600 
601  return SRD_ERR_PYTHON;
602 }
603 
604 /* Check whether the Decoder class defines the named method.
605  */
606 static int check_method(PyObject *py_dec, const char *mod_name,
607  const char *method_name)
608 {
609  PyObject *py_method;
610  int is_callable;
611  PyGILState_STATE gstate;
612 
613  gstate = PyGILState_Ensure();
614 
615  py_method = PyObject_GetAttrString(py_dec, method_name);
616  if (!py_method) {
617  srd_exception_catch("Protocol decoder %s Decoder class "
618  "has no %s() method", mod_name, method_name);
619  PyGILState_Release(gstate);
620  return SRD_ERR_PYTHON;
621  }
622 
623  is_callable = PyCallable_Check(py_method);
624  Py_DECREF(py_method);
625 
626  PyGILState_Release(gstate);
627 
628  if (!is_callable) {
629  srd_err("Protocol decoder %s Decoder class attribute '%s' "
630  "is not a method.", mod_name, method_name);
631  return SRD_ERR_PYTHON;
632  }
633 
634  return SRD_OK;
635 }
636 
637 /**
638  * Get the API version of the specified decoder.
639  *
640  * @param d The decoder to use. Must not be NULL.
641  *
642  * @return The API version of the decoder, or 0 upon errors.
643  *
644  * @private
645  */
646 SRD_PRIV long srd_decoder_apiver(const struct srd_decoder *d)
647 {
648  PyObject *py_apiver;
649  long apiver;
650  PyGILState_STATE gstate;
651 
652  if (!d)
653  return 0;
654 
655  gstate = PyGILState_Ensure();
656 
657  py_apiver = PyObject_GetAttrString(d->py_dec, "api_version");
658  apiver = (py_apiver && PyLong_Check(py_apiver))
659  ? PyLong_AsLong(py_apiver) : 0;
660  Py_XDECREF(py_apiver);
661 
662  PyGILState_Release(gstate);
663 
664  return apiver;
665 }
666 
667 /**
668  * Load a protocol decoder module into the embedded Python interpreter.
669  *
670  * @param module_name The module name to be loaded.
671  *
672  * @return SRD_OK upon success, a (negative) error code otherwise.
673  *
674  * @since 0.1.0
675  */
676 SRD_API int srd_decoder_load(const char *module_name)
677 {
678  PyObject *py_basedec;
679  struct srd_decoder *d;
680  long apiver;
681  int is_subclass;
682  const char *fail_txt;
683  PyGILState_STATE gstate;
684 
685  if (!srd_check_init())
686  return SRD_ERR;
687 
688  if (!module_name)
689  return SRD_ERR_ARG;
690 
691  gstate = PyGILState_Ensure();
692 
693  if (PyDict_GetItemString(PyImport_GetModuleDict(), module_name)) {
694  /* Module was already imported. */
695  PyGILState_Release(gstate);
696  return SRD_OK;
697  }
698 
699  d = g_malloc0(sizeof(struct srd_decoder));
700  fail_txt = NULL;
701 
702  d->py_mod = py_import_by_name(module_name);
703  if (!d->py_mod) {
704  fail_txt = "import by name failed";
705  goto except_out;
706  }
707 
708  if (!mod_sigrokdecode) {
709  srd_err("sigrokdecode module not loaded.");
710  fail_txt = "sigrokdecode(3) not loaded";
711  goto err_out;
712  }
713 
714  /* Get the 'Decoder' class as Python object. */
715  d->py_dec = PyObject_GetAttrString(d->py_mod, "Decoder");
716  if (!d->py_dec) {
717  fail_txt = "no 'Decoder' attribute in imported module";
718  goto except_out;
719  }
720 
721  py_basedec = PyObject_GetAttrString(mod_sigrokdecode, "Decoder");
722  if (!py_basedec) {
723  fail_txt = "no 'Decoder' attribute in sigrokdecode(3)";
724  goto except_out;
725  }
726 
727  is_subclass = PyObject_IsSubclass(d->py_dec, py_basedec);
728  Py_DECREF(py_basedec);
729 
730  if (!is_subclass) {
731  srd_err("Decoder class in protocol decoder module %s is not "
732  "a subclass of sigrokdecode.Decoder.", module_name);
733  fail_txt = "not a subclass of sigrokdecode.Decoder";
734  goto err_out;
735  }
736 
737  /*
738  * Check that this decoder has the correct PD API version.
739  * PDs of different API versions are incompatible and cannot work.
740  */
741  apiver = srd_decoder_apiver(d);
742  if (apiver != 3) {
743  srd_exception_catch("Only PD API version 3 is supported, "
744  "decoder %s has version %ld", module_name, apiver);
745  fail_txt = "API version mismatch";
746  goto err_out;
747  }
748 
749  /* Check Decoder class for required methods.
750  */
751  if (check_method(d->py_dec, module_name, "start") != SRD_OK) {
752  fail_txt = "no 'start()' method";
753  goto err_out;
754  }
755 
756  if (check_method(d->py_dec, module_name, "decode") != SRD_OK) {
757  fail_txt = "no 'decode()' method";
758  goto err_out;
759  }
760 
761  /* Store required fields in newly allocated strings. */
762  if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK) {
763  fail_txt = "no 'id' attribute";
764  goto err_out;
765  }
766 
767  if (py_attr_as_str(d->py_dec, "name", &(d->name)) != SRD_OK) {
768  fail_txt = "no 'name' attribute";
769  goto err_out;
770  }
771 
772  if (py_attr_as_str(d->py_dec, "longname", &(d->longname)) != SRD_OK) {
773  fail_txt = "no 'longname' attribute";
774  goto err_out;
775  }
776 
777  if (py_attr_as_str(d->py_dec, "desc", &(d->desc)) != SRD_OK) {
778  fail_txt = "no 'desc' attribute";
779  goto err_out;
780  }
781 
782  if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK) {
783  fail_txt = "no 'license' attribute";
784  goto err_out;
785  }
786 
787  if (py_attr_as_strlist(d->py_dec, "inputs", &(d->inputs)) != SRD_OK) {
788  fail_txt = "missing or malformed 'inputs' attribute";
789  goto err_out;
790  }
791 
792  if (py_attr_as_strlist(d->py_dec, "outputs", &(d->outputs)) != SRD_OK) {
793  fail_txt = "missing or malformed 'outputs' attribute";
794  goto err_out;
795  }
796 
797  /* All options and their default values. */
798  if (get_options(d) != SRD_OK) {
799  fail_txt = "cannot get options";
800  goto err_out;
801  }
802 
803  /* Check and import required channels. */
804  if (get_channels(d, "channels", &d->channels, 0) != SRD_OK) {
805  fail_txt = "cannot get channels";
806  goto err_out;
807  }
808 
809  /* Check and import optional channels. */
810  if (get_channels(d, "optional_channels", &d->opt_channels,
811  g_slist_length(d->channels)) != SRD_OK) {
812  fail_txt = "cannot get optional channels";
813  goto err_out;
814  }
815 
816  if (get_annotations(d) != SRD_OK) {
817  fail_txt = "cannot get annotations";
818  goto err_out;
819  }
820 
821  if (get_annotation_rows(d) != SRD_OK) {
822  fail_txt = "cannot get annotation rows";
823  goto err_out;
824  }
825 
826  if (get_binary_classes(d) != SRD_OK) {
827  fail_txt = "cannot get binary classes";
828  goto err_out;
829  }
830 
831  PyGILState_Release(gstate);
832 
833  /* Append it to the list of loaded decoders. */
834  pd_list = g_slist_append(pd_list, d);
835 
836  return SRD_OK;
837 
838 except_out:
839  /* Don't show a message for the "common" directory, it's not a PD. */
840  if (strcmp(module_name, "common")) {
841  srd_exception_catch("Failed to load decoder %s: %s",
842  module_name, fail_txt);
843  }
844  fail_txt = NULL;
845 err_out:
846  if (fail_txt)
847  srd_err("Failed to load decoder %s: %s", module_name, fail_txt);
848  decoder_free(d);
849  PyGILState_Release(gstate);
850 
851  return SRD_ERR_PYTHON;
852 }
853 
854 /**
855  * Return a protocol decoder's docstring.
856  *
857  * @param dec The loaded protocol decoder.
858  *
859  * @return A newly allocated buffer containing the protocol decoder's
860  * documentation. The caller is responsible for free'ing the buffer.
861  *
862  * @since 0.1.0
863  */
864 SRD_API char *srd_decoder_doc_get(const struct srd_decoder *dec)
865 {
866  PyObject *py_str;
867  char *doc;
868  PyGILState_STATE gstate;
869 
870  if (!srd_check_init())
871  return NULL;
872 
873  if (!dec)
874  return NULL;
875 
876  gstate = PyGILState_Ensure();
877 
878  if (!PyObject_HasAttrString(dec->py_mod, "__doc__"))
879  goto err;
880 
881  if (!(py_str = PyObject_GetAttrString(dec->py_mod, "__doc__"))) {
882  srd_exception_catch("Failed to get docstring");
883  goto err;
884  }
885 
886  doc = NULL;
887  if (py_str != Py_None)
888  py_str_as_str(py_str, &doc);
889  Py_DECREF(py_str);
890 
891  PyGILState_Release(gstate);
892 
893  return doc;
894 
895 err:
896  PyGILState_Release(gstate);
897 
898  return NULL;
899 }
900 
901 /**
902  * Unload the specified protocol decoder.
903  *
904  * @param dec The struct srd_decoder to be unloaded.
905  *
906  * @return SRD_OK upon success, a (negative) error code otherwise.
907  *
908  * @since 0.1.0
909  */
911 {
912  struct srd_session *sess;
913  GSList *l;
914 
915  if (!srd_check_init())
916  return SRD_ERR;
917 
918  if (!dec)
919  return SRD_ERR_ARG;
920 
921  /*
922  * Since any instances of this decoder need to be released as well,
923  * but they could be anywhere in the stack, just free the entire
924  * stack. A frontend reloading a decoder thus has to restart all
925  * instances, and rebuild the stack.
926  */
927  for (l = sessions; l; l = l->next) {
928  sess = l->data;
929  srd_inst_free_all(sess);
930  }
931 
932  /* Remove the PD from the list of loaded decoders. */
933  pd_list = g_slist_remove(pd_list, dec);
934 
935  decoder_free(dec);
936 
937  return SRD_OK;
938 }
939 
940 static void srd_decoder_load_all_zip_path(char *path)
941 {
942  PyObject *zipimport_mod, *zipimporter_class, *zipimporter;
943  PyObject *prefix_obj, *files, *key, *value, *set, *modname;
944  Py_ssize_t pos = 0;
945  char *prefix;
946  size_t prefix_len;
947  PyGILState_STATE gstate;
948 
949  set = files = prefix_obj = zipimporter = zipimporter_class = NULL;
950 
951  gstate = PyGILState_Ensure();
952 
953  zipimport_mod = py_import_by_name("zipimport");
954  if (zipimport_mod == NULL)
955  goto err_out;
956 
957  zipimporter_class = PyObject_GetAttrString(zipimport_mod, "zipimporter");
958  if (zipimporter_class == NULL)
959  goto err_out;
960 
961  zipimporter = PyObject_CallFunction(zipimporter_class, "s", path);
962  if (zipimporter == NULL)
963  goto err_out;
964 
965  prefix_obj = PyObject_GetAttrString(zipimporter, "prefix");
966  if (prefix_obj == NULL)
967  goto err_out;
968 
969  files = PyObject_GetAttrString(zipimporter, "_files");
970  if (files == NULL || !PyDict_Check(files))
971  goto err_out;
972 
973  set = PySet_New(NULL);
974  if (set == NULL)
975  goto err_out;
976 
977  if (py_str_as_str(prefix_obj, &prefix) != SRD_OK)
978  goto err_out;
979 
980  prefix_len = strlen(prefix);
981 
982  while (PyDict_Next(files, &pos, &key, &value)) {
983  char *path, *slash;
984  if (py_str_as_str(key, &path) == SRD_OK) {
985  if (strlen(path) > prefix_len
986  && memcmp(path, prefix, prefix_len) == 0
987  && (slash = strchr(path + prefix_len, '/'))) {
988 
989  modname = PyUnicode_FromStringAndSize(path + prefix_len,
990  slash - (path + prefix_len));
991  if (modname == NULL) {
992  PyErr_Clear();
993  } else {
994  PySet_Add(set, modname);
995  Py_DECREF(modname);
996  }
997  }
998  g_free(path);
999  }
1000  }
1001  g_free(prefix);
1002 
1003  while ((modname = PySet_Pop(set))) {
1004  char *modname_str;
1005  if (py_str_as_str(modname, &modname_str) == SRD_OK) {
1006  /* The directory name is the module name (e.g. "i2c"). */
1007  srd_decoder_load(modname_str);
1008  g_free(modname_str);
1009  }
1010  Py_DECREF(modname);
1011  }
1012 
1013 err_out:
1014  Py_XDECREF(set);
1015  Py_XDECREF(files);
1016  Py_XDECREF(prefix_obj);
1017  Py_XDECREF(zipimporter);
1018  Py_XDECREF(zipimporter_class);
1019  Py_XDECREF(zipimport_mod);
1020  PyErr_Clear();
1021  PyGILState_Release(gstate);
1022 }
1023 
1024 static void srd_decoder_load_all_path(char *path)
1025 {
1026  GDir *dir;
1027  const gchar *direntry;
1028 
1029  if (!(dir = g_dir_open(path, 0, NULL))) {
1030  /* Not really fatal */
1031  /* Try zipimport method too */
1032  srd_decoder_load_all_zip_path(path);
1033  return;
1034  }
1035 
1036  /* This ignores errors returned by srd_decoder_load(). That
1037  * function will have logged the cause, but in any case we
1038  * want to continue anyway. */
1039  while ((direntry = g_dir_read_name(dir)) != NULL) {
1040  /* The directory name is the module name (e.g. "i2c"). */
1041  srd_decoder_load(direntry);
1042  }
1043  g_dir_close(dir);
1044 
1045 }
1046 
1047 /**
1048  * Load all installed protocol decoders.
1049  *
1050  * @return SRD_OK upon success, a (negative) error code otherwise.
1051  *
1052  * @since 0.1.0
1053  */
1055 {
1056  GSList *l;
1057 
1058  if (!srd_check_init())
1059  return SRD_ERR;
1060 
1061  for (l = searchpaths; l; l = l->next)
1062  srd_decoder_load_all_path(l->data);
1063 
1064  return SRD_OK;
1065 }
1066 
1067 /**
1068  * Unload all loaded protocol decoders.
1069  *
1070  * @return SRD_OK upon success, a (negative) error code otherwise.
1071  *
1072  * @since 0.1.0
1073  */
1075 {
1076  g_slist_foreach(pd_list, (GFunc)srd_decoder_unload, NULL);
1077  g_slist_free(pd_list);
1078  pd_list = NULL;
1079 
1080  return SRD_OK;
1081 }
1082 
1083 /** @} */
char * license
The license of the decoder.
char * srd_decoder_doc_get(const struct srd_decoder *dec)
Return a protocol decoder's docstring.
Definition: decoder.c:864
GSList * opt_channels
List of optional channels for this decoder.
const GSList * srd_decoder_list(void)
Returns the list of loaded protocol decoders.
Definition: decoder.c:75
GSList * outputs
List of possible decoder output IDs.
Structure which contains information about one protocol decoder channel.
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.
char * longname
The (long) decoder name.
int order
The index of the channel, i.e.
char * id
The ID of the channel.
#define SRD_API
char * name
The name of the channel.
GSList * annotations
List of NULL-terminated char[], containing descriptions of the supported annotation output...
No error.
The public libsigrokdecode header file to be used by frontends.
char * desc
A (short, one-line) description of the decoder.
Function argument error.
int srd_decoder_unload_all(void)
Unload all loaded protocol decoders.
Definition: decoder.c:1074
Python C API error.
int srd_decoder_load(const char *module_name)
Load a protocol decoder module into the embedded Python interpreter.
Definition: decoder.c:676
int srd_decoder_unload(struct srd_decoder *dec)
Unload the specified protocol decoder.
Definition: decoder.c:910
GSList * binary
List of NULL-terminated char[], containing descriptions of the supported binary output.
GSList * inputs
List of possible decoder input IDs.
#define SRD_PRIV
GSList * options
List of decoder options.
char * desc
The description of the channel.
void * py_mod
Python module.
GSList * annotation_rows
List of annotation rows (row items: id, description, and a list of annotation classes belonging to th...
void * py_dec
sigrokdecode.Decoder class.
char * id
The decoder ID.
GSList * channels
List of channels required by this decoder.
Generic/unspecified error.
int srd_decoder_load_all(void)
Load all installed protocol decoders.
Definition: decoder.c:1054