blob: 4b3263846587de3e74dbc17dc9c3184b0a368c18 [file] [log] [blame]
Bert Vermeulenb2c19612011-12-04 10:33:02 +01001/*
Uwe Hermann50bd5d22013-04-23 22:27:20 +02002 * This file is part of the libsigrokdecode project.
Bert Vermeulenb2c19612011-12-04 10:33:02 +01003 *
4 * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
Bert Vermeulen4fadb122012-01-22 03:29:22 +01005 * Copyright (C) 2012 Bert Vermeulen <bert@biot.com>
Bert Vermeulenb2c19612011-12-04 10:33:02 +01006 *
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"
Uwe Hermannc1f86f02013-05-03 14:49:21 +020022#include "libsigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */
23#include "libsigrokdecode-internal.h"
Bert Vermeuleneb2bbd62012-01-19 17:12:02 +010024#include <glib.h>
Bert Vermeulenb2c19612011-12-04 10:33:02 +010025
Uwe Hermann54fdeee2013-02-09 22:10:57 +010026/**
27 * @file
28 *
29 * Listing, loading, unloading, and handling protocol decoders.
30 */
31
Uwe Hermann48954182013-02-09 22:25:15 +010032/**
33 * @defgroup grp_decoder Protocol decoders
34 *
35 * Handling protocol decoders.
36 *
37 * @{
38 */
39
Uwe Hermann57790bc2013-02-09 21:44:11 +010040/** @cond PRIVATE */
41
Bert Vermeulenb2c19612011-12-04 10:33:02 +010042/* The list of protocol decoders. */
Uwe Hermann20605102014-05-03 23:52:54 +020043static GSList *pd_list = NULL;
Bert Vermeulenb2c19612011-12-04 10:33:02 +010044
Bert Vermeulenea81b492013-12-11 18:31:56 +010045/* srd.c */
46extern GSList *searchpaths;
47
48/* session.c */
Bert Vermeulen32cfb922013-09-12 23:54:43 +020049extern GSList *sessions;
50
Uwe Hermannc9bfccc2012-02-08 22:39:30 +010051/* module_sigrokdecode.c */
Uwe Hermann55c3c5f2012-02-09 19:11:53 +010052extern SRD_PRIV PyObject *mod_sigrokdecode;
Bert Vermeulen451680f2012-01-15 03:58:27 +010053
Uwe Hermann57790bc2013-02-09 21:44:11 +010054/** @endcond */
55
Bert Vermeulenb2c19612011-12-04 10:33:02 +010056/**
57 * Returns the list of supported/loaded protocol decoders.
58 *
59 * This is a GSList containing the names of the decoders as strings.
60 *
61 * @return List of decoders, NULL if none are supported or loaded.
Uwe Hermann8c664ca2013-05-03 14:45:49 +020062 *
63 * @since 0.1.0 (but the API changed in 0.2.0)
Bert Vermeulenb2c19612011-12-04 10:33:02 +010064 */
Uwe Hermann38ff5042013-02-02 12:18:29 +010065SRD_API const GSList *srd_decoder_list(void)
Bert Vermeulenb2c19612011-12-04 10:33:02 +010066{
Bert Vermeulene5080882011-12-07 09:56:49 +010067 return pd_list;
Bert Vermeulenb2c19612011-12-04 10:33:02 +010068}
69
Bert Vermeulenb2c19612011-12-04 10:33:02 +010070/**
71 * Get the decoder with the specified ID.
72 *
73 * @param id The ID string of the decoder to return.
Bert Vermeulen582c8472012-02-12 14:55:20 +010074 *
Bert Vermeulenb2c19612011-12-04 10:33:02 +010075 * @return The decoder with the specified ID, or NULL if not found.
Uwe Hermann8c664ca2013-05-03 14:45:49 +020076 *
77 * @since 0.1.0
Bert Vermeulenb2c19612011-12-04 10:33:02 +010078 */
Bert Vermeulen9d122fd2012-02-14 03:43:28 +010079SRD_API struct srd_decoder *srd_decoder_get_by_id(const char *id)
Bert Vermeulenb2c19612011-12-04 10:33:02 +010080{
81 GSList *l;
82 struct srd_decoder *dec;
83
Uwe Hermann38ff5042013-02-02 12:18:29 +010084 for (l = pd_list; l; l = l->next) {
Bert Vermeulenb2c19612011-12-04 10:33:02 +010085 dec = l->data;
86 if (!strcmp(dec->id, id))
87 return dec;
88 }
89
90 return NULL;
91}
92
Uwe Hermann6a155972014-04-13 19:57:43 +020093static int get_channels(const struct srd_decoder *d, const char *attr,
94 GSList **pdchl)
Bert Vermeulenf38ec282012-01-20 22:25:42 +010095{
Uwe Hermann6a155972014-04-13 19:57:43 +020096 PyObject *py_channellist, *py_entry;
97 struct srd_channel *pdch;
98 int ret, num_channels, i;
Bert Vermeulenf38ec282012-01-20 22:25:42 +010099
100 if (!PyObject_HasAttrString(d->py_dec, attr))
Uwe Hermann6a155972014-04-13 19:57:43 +0200101 /* No channels of this type specified. */
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100102 return SRD_OK;
103
Uwe Hermann6a155972014-04-13 19:57:43 +0200104 py_channellist = PyObject_GetAttrString(d->py_dec, attr);
105 if (!PyTuple_Check(py_channellist)) {
Bert Vermeulenda9bcbd2014-03-10 12:23:38 +0100106 srd_err("Protocol decoder %s %s attribute is not a tuple.",
Bert Vermeulen22c9bc22013-11-18 09:41:14 +0100107 d->name, attr);
108 return SRD_ERR_PYTHON;
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100109 }
110
Uwe Hermann6a155972014-04-13 19:57:43 +0200111 if ((num_channels = PyTuple_Size(py_channellist)) == 0)
112 /* Empty channellist. */
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100113 return SRD_OK;
114
Bert Vermeulen22c9bc22013-11-18 09:41:14 +0100115 ret = SRD_OK;
Uwe Hermann6a155972014-04-13 19:57:43 +0200116 for (i = 0; i < num_channels; i++) {
117 py_entry = PyTuple_GetItem(py_channellist, i);
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100118 if (!PyDict_Check(py_entry)) {
119 srd_err("Protocol decoder %s %s attribute is not "
Uwe Hermannc9bfccc2012-02-08 22:39:30 +0100120 "a list with dict elements.", d->name, attr);
Bert Vermeulen22c9bc22013-11-18 09:41:14 +0100121 ret = SRD_ERR_PYTHON;
122 break;
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100123 }
124
Uwe Hermann6a155972014-04-13 19:57:43 +0200125 if (!(pdch = g_try_malloc(sizeof(struct srd_channel)))) {
126 srd_err("Failed to g_malloc() struct srd_channel.");
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100127 ret = SRD_ERR_MALLOC;
Bert Vermeulen22c9bc22013-11-18 09:41:14 +0100128 break;
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100129 }
130
Uwe Hermann6a155972014-04-13 19:57:43 +0200131 if ((py_dictitem_as_str(py_entry, "id", &pdch->id)) != SRD_OK) {
Bert Vermeulen22c9bc22013-11-18 09:41:14 +0100132 ret = SRD_ERR_PYTHON;
133 break;
134 }
Uwe Hermann6a155972014-04-13 19:57:43 +0200135 if ((py_dictitem_as_str(py_entry, "name", &pdch->name)) != SRD_OK) {
Bert Vermeulen22c9bc22013-11-18 09:41:14 +0100136 ret = SRD_ERR_PYTHON;
137 break;
138 }
Uwe Hermann6a155972014-04-13 19:57:43 +0200139 if ((py_dictitem_as_str(py_entry, "desc", &pdch->desc)) != SRD_OK) {
Bert Vermeulen22c9bc22013-11-18 09:41:14 +0100140 ret = SRD_ERR_PYTHON;
141 break;
142 }
Uwe Hermann6a155972014-04-13 19:57:43 +0200143 pdch->order = i;
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100144
Uwe Hermann6a155972014-04-13 19:57:43 +0200145 *pdchl = g_slist_append(*pdchl, pdch);
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100146 }
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100147
Uwe Hermann6a155972014-04-13 19:57:43 +0200148 Py_DecRef(py_channellist);
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100149
150 return ret;
151}
152
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100153static int get_options(struct srd_decoder *d)
154{
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100155 PyObject *py_opts, *py_opt, *py_val, *py_default, *py_item;
156 Py_ssize_t opt, i;
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100157 struct srd_decoder_option *o;
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100158 GVariant *gvar;
159 gint64 lval;
160 double dval;
161 int overflow;
162 char *sval;
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100163
164 if (!PyObject_HasAttrString(d->py_dec, "options"))
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100165 /* No options, that's fine. */
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100166 return SRD_OK;
167
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100168 /* If present, options must be a tuple. */
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100169 py_opts = PyObject_GetAttrString(d->py_dec, "options");
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100170 if (!PyTuple_Check(py_opts)) {
171 srd_err("Protocol decoder %s: options attribute is not "
172 "a tuple.", d->id);
173 return SRD_ERR_PYTHON;
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100174 }
175
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100176 for (opt = 0; opt < PyTuple_Size(py_opts); opt++) {
177 py_opt = PyTuple_GetItem(py_opts, opt);
178 if (!PyDict_Check(py_opt)) {
179 srd_err("Protocol decoder %s options: each option "
180 "must consist of a dictionary.", d->name);
181 return SRD_ERR_PYTHON;
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100182 }
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100183 if (!(py_val = PyDict_GetItemString(py_opt, "id"))) {
184 srd_err("Protocol decoder %s option %d has no "
185 "id.", d->name);
186 return SRD_ERR_PYTHON;
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100187 }
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100188 o = g_malloc0(sizeof(struct srd_decoder_option));
189 py_str_as_str(py_val, &o->id);
190
191 if ((py_val = PyDict_GetItemString(py_opt, "desc")))
192 py_str_as_str(py_val, &o->desc);
193
194 if ((py_default = PyDict_GetItemString(py_opt, "default"))) {
195 if (PyUnicode_Check(py_default)) {
196 /* UTF-8 string */
197 py_str_as_str(py_default, &sval);
198 o->def = g_variant_new_string(sval);
199 g_free(sval);
200 } else if (PyLong_Check(py_default)) {
201 /* Long */
202 lval = PyLong_AsLongAndOverflow(py_default, &overflow);
203 if (overflow) {
204 /* Value is < LONG_MIN or > LONG_MAX */
205 PyErr_Clear();
206 srd_err("Protocol decoder %s option 'default' has "
207 "invalid default value.", d->name);
208 return SRD_ERR_PYTHON;
209 }
210 o->def = g_variant_new_int64(lval);
211 } else if (PyFloat_Check(py_default)) {
212 /* Float */
213 if ((dval = PyFloat_AsDouble(py_default)) == -1.0) {
214 PyErr_Clear();
215 srd_err("Protocol decoder %s option 'default' has "
216 "invalid default value.", d->name);
217 return SRD_ERR_PYTHON;
218 }
219 o->def = g_variant_new_double(dval);
220 } else {
221 srd_err("Protocol decoder %s option 'default' has "
222 "value of unsupported type '%s'.", d->name,
223 Py_TYPE(py_default)->tp_name);
224 return SRD_ERR_PYTHON;
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100225 }
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100226 g_variant_ref_sink(o->def);
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100227 }
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100228
229 if ((py_val = PyDict_GetItemString(py_opt, "values"))) {
230 /* A default is required if a list of values is
231 * given, since it's used to verify their type. */
232 if (!o->def) {
233 srd_err("No default for option '%s'", o->id);
234 return SRD_ERR_PYTHON;
235 }
236 if (!PyTuple_Check(py_val)) {
237 srd_err("Option '%s' values should be a tuple.", o->id);
238 return SRD_ERR_PYTHON;
239 }
240 for (i = 0; i < PyTuple_Size(py_val); i++) {
241 py_item = PyTuple_GetItem(py_val, i);
242 if (Py_TYPE(py_default) != Py_TYPE(py_item)) {
243 srd_err("All values for option '%s' must be "
244 "of the same type as the default.",
245 o->id);
246 return SRD_ERR_PYTHON;
247 }
248 if (PyUnicode_Check(py_item)) {
249 /* UTF-8 string */
250 py_str_as_str(py_item, &sval);
251 gvar = g_variant_new_string(sval);
252 g_variant_ref_sink(gvar);
253 g_free(sval);
254 o->values = g_slist_append(o->values, gvar);
255 } else if (PyLong_Check(py_item)) {
256 /* Long */
Bert Vermeulen65f6eb72014-03-11 23:27:31 +0100257 lval = PyLong_AsLongAndOverflow(py_item, &overflow);
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100258 if (overflow) {
259 /* Value is < LONG_MIN or > LONG_MAX */
260 PyErr_Clear();
261 srd_err("Protocol decoder %s option 'values' "
262 "has invalid value.", d->name);
263 return SRD_ERR_PYTHON;
264 }
265 gvar = g_variant_new_int64(lval);
266 g_variant_ref_sink(gvar);
267 o->values = g_slist_append(o->values, gvar);
Bert Vermeulen65f6eb72014-03-11 23:27:31 +0100268 } else if (PyFloat_Check(py_item)) {
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100269 /* Float */
Bert Vermeulen65f6eb72014-03-11 23:27:31 +0100270 if ((dval = PyFloat_AsDouble(py_item)) == -1.0) {
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100271 PyErr_Clear();
272 srd_err("Protocol decoder %s option 'default' has "
273 "invalid default value.", d->name);
274 return SRD_ERR_PYTHON;
275 }
276 gvar = g_variant_new_double(dval);
277 g_variant_ref_sink(gvar);
278 o->values = g_slist_append(o->values, gvar);
279 }
280 }
281 }
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100282 d->options = g_slist_append(d->options, o);
283 }
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100284
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100285 return SRD_OK;
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100286}
287
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100288/**
Uwe Hermann64c29e22012-01-15 15:36:01 +0100289 * Load a protocol decoder module into the embedded Python interpreter.
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100290 *
Uwe Hermann38ff5042013-02-02 12:18:29 +0100291 * @param module_name The module name to be loaded.
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100292 *
293 * @return SRD_OK upon success, a (negative) error code otherwise.
Uwe Hermann8c664ca2013-05-03 14:45:49 +0200294 *
295 * @since 0.1.0
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100296 */
Bert Vermeulen9d122fd2012-02-14 03:43:28 +0100297SRD_API int srd_decoder_load(const char *module_name)
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100298{
Uwe Hermann1ce46812014-01-31 16:59:22 +0100299 PyObject *py_basedec, *py_method, *py_attr, *py_annlist, *py_ann;
300 PyObject *py_bin_classes, *py_bin_class, *py_ann_rows, *py_ann_row;
301 PyObject *py_ann_classes, *py_long;
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100302 struct srd_decoder *d;
Uwe Hermann1ce46812014-01-31 16:59:22 +0100303 int ret, i, j;
304 char **ann, **bin, *ann_row_id, *ann_row_desc;
Uwe Hermann6a155972014-04-13 19:57:43 +0200305 struct srd_channel *pdch;
Uwe Hermann1ce46812014-01-31 16:59:22 +0100306 GSList *l, *ann_classes;
307 struct srd_decoder_annotation_row *ann_row;
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100308
Bert Vermeulene195c022013-11-18 01:21:16 +0100309 if (!srd_check_init())
310 return SRD_ERR;
311
Bert Vermeulen8a014682013-10-17 23:52:15 +0200312 if (!module_name)
313 return SRD_ERR_ARG;
314
Bert Vermeulenaac68132013-11-18 10:44:28 +0100315 if (PyDict_GetItemString(PyImport_GetModuleDict(), module_name)) {
316 /* Module was already imported. */
317 return SRD_OK;
318 }
319
Uwe Hermann8ad6e502012-03-16 15:25:53 +0100320 srd_dbg("Loading protocol decoder '%s'.", module_name);
Bert Vermeulend906d3f2012-01-22 02:51:49 +0100321
Bert Vermeulen11ea8ae2012-01-20 22:23:27 +0100322 py_basedec = py_method = py_attr = NULL;
Uwe Hermann64c29e22012-01-15 15:36:01 +0100323
Bert Vermeulen451680f2012-01-15 03:58:27 +0100324 if (!(d = g_try_malloc0(sizeof(struct srd_decoder)))) {
Uwe Hermanna61ece22012-02-10 00:06:58 +0100325 srd_dbg("Failed to g_malloc() struct srd_decoder.");
Bert Vermeulen451680f2012-01-15 03:58:27 +0100326 ret = SRD_ERR_MALLOC;
327 goto err_out;
328 }
329
Bert Vermeulen21481b62012-01-19 09:59:00 +0100330 ret = SRD_ERR_PYTHON;
331
Bert Vermeulen451680f2012-01-15 03:58:27 +0100332 /* Import the Python module. */
Bert Vermeulen9b371092012-02-14 03:28:53 +0100333 if (!(d->py_mod = PyImport_ImportModule(module_name))) {
Uwe Hermannaafeeae2012-03-25 15:08:16 +0200334 srd_exception_catch("Import of '%s' failed.", module_name);
Bert Vermeulen451680f2012-01-15 03:58:27 +0100335 goto err_out;
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100336 }
337
338 /* Get the 'Decoder' class as Python object. */
Bert Vermeulen451680f2012-01-15 03:58:27 +0100339 if (!(d->py_dec = PyObject_GetAttrString(d->py_mod, "Decoder"))) {
340 /* This generated an AttributeError exception. */
341 PyErr_Clear();
Uwe Hermann361fdca2012-03-15 22:00:24 +0100342 srd_err("Decoder class not found in protocol decoder %s.",
343 module_name);
Bert Vermeulen451680f2012-01-15 03:58:27 +0100344 goto err_out;
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100345 }
346
Bert Vermeulen451680f2012-01-15 03:58:27 +0100347 if (!(py_basedec = PyObject_GetAttrString(mod_sigrokdecode, "Decoder"))) {
Uwe Hermann7a1712c2012-01-26 01:15:10 +0100348 srd_dbg("sigrokdecode module not loaded.");
Bert Vermeulen451680f2012-01-15 03:58:27 +0100349 goto err_out;
350 }
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100351
Bert Vermeulen451680f2012-01-15 03:58:27 +0100352 if (!PyObject_IsSubclass(d->py_dec, py_basedec)) {
353 srd_err("Decoder class in protocol decoder module %s is not "
Bert Vermeulen9b371092012-02-14 03:28:53 +0100354 "a subclass of sigrokdecode.Decoder.", module_name);
Bert Vermeulen451680f2012-01-15 03:58:27 +0100355 goto err_out;
356 }
Bert Vermeulenad022d92012-01-30 01:22:27 +0100357 Py_CLEAR(py_basedec);
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100358
Bert Vermeulen1d552cd2012-01-19 15:05:38 +0100359 /* Check for a proper start() method. */
360 if (!PyObject_HasAttrString(d->py_dec, "start")) {
361 srd_err("Protocol decoder %s has no start() method Decoder "
Bert Vermeulen9b371092012-02-14 03:28:53 +0100362 "class.", module_name);
Bert Vermeulen1d552cd2012-01-19 15:05:38 +0100363 goto err_out;
364 }
365 py_method = PyObject_GetAttrString(d->py_dec, "start");
366 if (!PyFunction_Check(py_method)) {
Bert Vermeulend906d3f2012-01-22 02:51:49 +0100367 srd_err("Protocol decoder %s Decoder class attribute 'start' "
Bert Vermeulen9b371092012-02-14 03:28:53 +0100368 "is not a method.", module_name);
Bert Vermeulen1d552cd2012-01-19 15:05:38 +0100369 goto err_out;
370 }
Bert Vermeulenad022d92012-01-30 01:22:27 +0100371 Py_CLEAR(py_method);
Bert Vermeulen1d552cd2012-01-19 15:05:38 +0100372
373 /* Check for a proper decode() method. */
374 if (!PyObject_HasAttrString(d->py_dec, "decode")) {
375 srd_err("Protocol decoder %s has no decode() method Decoder "
Bert Vermeulen9b371092012-02-14 03:28:53 +0100376 "class.", module_name);
Bert Vermeulen1d552cd2012-01-19 15:05:38 +0100377 goto err_out;
378 }
379 py_method = PyObject_GetAttrString(d->py_dec, "decode");
380 if (!PyFunction_Check(py_method)) {
381 srd_err("Protocol decoder %s Decoder class attribute 'decode' "
Bert Vermeulen9b371092012-02-14 03:28:53 +0100382 "is not a method.", module_name);
Bert Vermeulen1d552cd2012-01-19 15:05:38 +0100383 goto err_out;
384 }
Bert Vermeulenad022d92012-01-30 01:22:27 +0100385 Py_CLEAR(py_method);
Bert Vermeulen1d552cd2012-01-19 15:05:38 +0100386
Bert Vermeulen84c1c0b2014-03-09 23:48:27 +0100387 /* Store required fields in newly allocated strings. */
388 if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK)
389 goto err_out;
390
391 if (py_attr_as_str(d->py_dec, "name", &(d->name)) != SRD_OK)
392 goto err_out;
393
394 if (py_attr_as_str(d->py_dec, "longname", &(d->longname)) != SRD_OK)
395 goto err_out;
396
397 if (py_attr_as_str(d->py_dec, "desc", &(d->desc)) != SRD_OK)
398 goto err_out;
399
400 if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK)
401 goto err_out;
402
403 /* All options and their default values. */
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100404 if (get_options(d) != SRD_OK)
405 goto err_out;
Bert Vermeulen11ea8ae2012-01-20 22:23:27 +0100406
Uwe Hermann6a155972014-04-13 19:57:43 +0200407 /* Check and import required channels. */
408 if (get_channels(d, "channels", &d->channels) != SRD_OK)
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100409 goto err_out;
410
Uwe Hermann6a155972014-04-13 19:57:43 +0200411 /* Check and import optional channels. */
412 if (get_channels(d, "optional_channels", &d->opt_channels) != SRD_OK)
Bert Vermeulenf38ec282012-01-20 22:25:42 +0100413 goto err_out;
414
Uwe Hermann38ff5042013-02-02 12:18:29 +0100415 /*
Uwe Hermann6a155972014-04-13 19:57:43 +0200416 * Fix order numbers for the optional channels.
Uwe Hermann38ff5042013-02-02 12:18:29 +0100417 *
418 * Example:
Uwe Hermann6a155972014-04-13 19:57:43 +0200419 * Required channels: r1, r2, r3. Optional: o1, o2, o3, o4.
420 * 'order' fields in the d->channels list = 0, 1, 2.
421 * 'order' fields in the d->opt_channels list = 3, 4, 5, 6.
Uwe Hermann38ff5042013-02-02 12:18:29 +0100422 */
Uwe Hermann6a155972014-04-13 19:57:43 +0200423 for (l = d->opt_channels; l; l = l->next) {
424 pdch = l->data;
425 pdch->order += g_slist_length(d->channels);
Uwe Hermann38ff5042013-02-02 12:18:29 +0100426 }
427
Bert Vermeulend75d8a72013-11-10 12:42:11 +0100428 /* Convert annotation class attribute to GSList of char **. */
Uwe Hermanne97b6ef2012-01-10 21:05:09 +0100429 d->annotations = NULL;
Bert Vermeulen451680f2012-01-15 03:58:27 +0100430 if (PyObject_HasAttrString(d->py_dec, "annotations")) {
431 py_annlist = PyObject_GetAttrString(d->py_dec, "annotations");
Bert Vermeulenda9bcbd2014-03-10 12:23:38 +0100432 if (!PyTuple_Check(py_annlist)) {
Bert Vermeulen1f2275d2013-12-12 00:56:12 +0100433 srd_err("Protocol decoder %s annotations should "
Bert Vermeulenda9bcbd2014-03-10 12:23:38 +0100434 "be a tuple.", module_name);
Bert Vermeulen451680f2012-01-15 03:58:27 +0100435 goto err_out;
Bert Vermeulen15969942012-01-07 02:50:14 +0100436 }
Bert Vermeulenda9bcbd2014-03-10 12:23:38 +0100437 for (i = 0; i < PyTuple_Size(py_annlist); i++) {
438 py_ann = PyTuple_GetItem(py_annlist, i);
439 if (!PyTuple_Check(py_ann) || PyTuple_Size(py_ann) != 2) {
Bert Vermeulen1f2275d2013-12-12 00:56:12 +0100440 srd_err("Protocol decoder %s annotation %d should "
Bert Vermeulenda9bcbd2014-03-10 12:23:38 +0100441 "be a tuple with two elements.", module_name, i + 1);
Bert Vermeulen451680f2012-01-15 03:58:27 +0100442 goto err_out;
Bert Vermeulen15969942012-01-07 02:50:14 +0100443 }
444
Bert Vermeulen62a2b152013-12-11 23:41:02 +0100445 if (py_strseq_to_char(py_ann, &ann) != SRD_OK) {
Bert Vermeulen451680f2012-01-15 03:58:27 +0100446 goto err_out;
447 }
Uwe Hermanne97b6ef2012-01-10 21:05:09 +0100448 d->annotations = g_slist_append(d->annotations, ann);
Bert Vermeulen15969942012-01-07 02:50:14 +0100449 }
450 }
451
Uwe Hermann1ce46812014-01-31 16:59:22 +0100452 /* Convert annotation_rows to GSList of 'struct srd_decoder_annotation_row'. */
453 d->annotation_rows = NULL;
454 if (PyObject_HasAttrString(d->py_dec, "annotation_rows")) {
455 py_ann_rows = PyObject_GetAttrString(d->py_dec, "annotation_rows");
456 if (!PyTuple_Check(py_ann_rows)) {
457 srd_err("Protocol decoder %s annotation row list "
458 "must be a tuple.", module_name);
459 goto err_out;
460 }
461 for (i = 0; i < PyTuple_Size(py_ann_rows); i++) {
462 py_ann_row = PyTuple_GetItem(py_ann_rows, i);
463 if (!PyTuple_Check(py_ann_row)) {
464 srd_err("Protocol decoder %s annotation rows "
465 "must be tuples.", module_name);
466 goto err_out;
467 }
468 if (PyTuple_Size(py_ann_row) != 3
469 || !PyUnicode_Check(PyTuple_GetItem(py_ann_row, 0))
470 || !PyUnicode_Check(PyTuple_GetItem(py_ann_row, 1))
471 || !PyTuple_Check(PyTuple_GetItem(py_ann_row, 2))) {
472 srd_err("Protocol decoder %s annotation rows "
473 "must contain tuples containing two "
474 "strings and a tuple.", module_name);
475 goto err_out;
476 }
477
478 if (py_str_as_str(PyTuple_GetItem(py_ann_row, 0), &ann_row_id) != SRD_OK)
479 goto err_out;
480
481 if (py_str_as_str(PyTuple_GetItem(py_ann_row, 1), &ann_row_desc) != SRD_OK)
482 goto err_out;
483
484 py_ann_classes = PyTuple_GetItem(py_ann_row, 2);
485 ann_classes = NULL;
486 for (j = 0; j < PyTuple_Size(py_ann_classes); j++) {
487 py_long = PyTuple_GetItem(py_ann_classes, j);
488 if (!PyLong_Check(py_long)) {
489 srd_err("Protocol decoder %s annotation row class "
490 "list must only contain numbers.", module_name);
491 goto err_out;
492 }
493 ann_classes = g_slist_append(ann_classes,
494 GINT_TO_POINTER(PyLong_AsLong(py_long)));
495 }
496
497 ann_row = g_malloc0(sizeof(struct srd_decoder_annotation_row));
498 ann_row->id = ann_row_id;
499 ann_row->desc = ann_row_desc;
500 ann_row->ann_classes = ann_classes;
501 d->annotation_rows = g_slist_append(d->annotation_rows, ann_row);
502 }
503 }
504
Bert Vermeulend75d8a72013-11-10 12:42:11 +0100505 /* Convert binary class to GSList of char *. */
506 d->binary = NULL;
507 if (PyObject_HasAttrString(d->py_dec, "binary")) {
508 py_bin_classes = PyObject_GetAttrString(d->py_dec, "binary");
509 if (!PyTuple_Check(py_bin_classes)) {
Bert Vermeulen1f2275d2013-12-12 00:56:12 +0100510 srd_err("Protocol decoder %s binary classes should "
511 "be a tuple.", module_name);
Bert Vermeulend75d8a72013-11-10 12:42:11 +0100512 goto err_out;
513 }
Uwe Hermann1ce46812014-01-31 16:59:22 +0100514 for (i = 0; i < PyTuple_Size(py_bin_classes); i++) {
Bert Vermeulend75d8a72013-11-10 12:42:11 +0100515 py_bin_class = PyTuple_GetItem(py_bin_classes, i);
Bert Vermeulen1f2275d2013-12-12 00:56:12 +0100516 if (!PyTuple_Check(py_bin_class)) {
517 srd_err("Protocol decoder %s binary classes "
518 "should consist of tuples.", module_name);
519 goto err_out;
520 }
521 if (PyTuple_Size(py_bin_class) != 2
522 || !PyUnicode_Check(PyTuple_GetItem(py_bin_class, 0))
523 || !PyUnicode_Check(PyTuple_GetItem(py_bin_class, 1))) {
524 srd_err("Protocol decoder %s binary classes should "
525 "contain tuples with two strings.", module_name);
Bert Vermeulend75d8a72013-11-10 12:42:11 +0100526 goto err_out;
527 }
528
Bert Vermeulen1f2275d2013-12-12 00:56:12 +0100529 if (py_strseq_to_char(py_bin_class, &bin) != SRD_OK) {
Bert Vermeulend75d8a72013-11-10 12:42:11 +0100530 goto err_out;
531 }
532 d->binary = g_slist_append(d->binary, bin);
533 }
534 }
535
Bert Vermeulen9b371092012-02-14 03:28:53 +0100536 /* Append it to the list of supported/loaded decoders. */
537 pd_list = g_slist_append(pd_list, d);
538
Bert Vermeulen451680f2012-01-15 03:58:27 +0100539 ret = SRD_OK;
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100540
Bert Vermeulen451680f2012-01-15 03:58:27 +0100541err_out:
542 if (ret != SRD_OK) {
Bert Vermeulen1d552cd2012-01-19 15:05:38 +0100543 Py_XDECREF(py_method);
Bert Vermeulen451680f2012-01-15 03:58:27 +0100544 Py_XDECREF(py_basedec);
545 Py_XDECREF(d->py_dec);
546 Py_XDECREF(d->py_mod);
547 g_free(d);
548 }
549
550 return ret;
551}
552
Bert Vermeulen582c8472012-02-12 14:55:20 +0100553/**
554 * Return a protocol decoder's docstring.
555 *
556 * @param dec The loaded protocol decoder.
557 *
Uwe Hermann361fdca2012-03-15 22:00:24 +0100558 * @return A newly allocated buffer containing the protocol decoder's
Uwe Hermannabeeed82012-03-16 15:12:54 +0100559 * documentation. The caller is responsible for free'ing the buffer.
Uwe Hermann8c664ca2013-05-03 14:45:49 +0200560 *
561 * @since 0.1.0
Bert Vermeulen582c8472012-02-12 14:55:20 +0100562 */
Uwe Hermannb33b8aa2012-03-25 14:49:11 +0200563SRD_API char *srd_decoder_doc_get(const struct srd_decoder *dec)
Bert Vermeulen451680f2012-01-15 03:58:27 +0100564{
Bert Vermeulene7edca02012-01-15 04:24:15 +0100565 PyObject *py_str;
Bert Vermeulen451680f2012-01-15 03:58:27 +0100566 char *doc;
567
Bert Vermeulene195c022013-11-18 01:21:16 +0100568 if (!srd_check_init())
569 return NULL;
570
571 if (!dec)
572 return NULL;
573
Bert Vermeulene7edca02012-01-15 04:24:15 +0100574 if (!PyObject_HasAttrString(dec->py_mod, "__doc__"))
575 return NULL;
576
577 if (!(py_str = PyObject_GetAttrString(dec->py_mod, "__doc__"))) {
Uwe Hermannaafeeae2012-03-25 15:08:16 +0200578 srd_exception_catch("");
Bert Vermeulene7edca02012-01-15 04:24:15 +0100579 return NULL;
580 }
581
Bert Vermeulen451680f2012-01-15 03:58:27 +0100582 doc = NULL;
Bert Vermeulene7edca02012-01-15 04:24:15 +0100583 if (py_str != Py_None)
584 py_str_as_str(py_str, &doc);
585 Py_DecRef(py_str);
Bert Vermeulen451680f2012-01-15 03:58:27 +0100586
587 return doc;
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100588}
589
Uwe Hermann6a155972014-04-13 19:57:43 +0200590static void free_channels(GSList *channellist)
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100591{
592 GSList *l;
Uwe Hermann6a155972014-04-13 19:57:43 +0200593 struct srd_channel *pdch;
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100594
Uwe Hermann6a155972014-04-13 19:57:43 +0200595 if (channellist == NULL)
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100596 return;
597
Uwe Hermann6a155972014-04-13 19:57:43 +0200598 for (l = channellist; l; l = l->next) {
599 pdch = l->data;
600 g_free(pdch->id);
601 g_free(pdch->name);
602 g_free(pdch->desc);
603 g_free(pdch);
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100604 }
Uwe Hermann6a155972014-04-13 19:57:43 +0200605 g_slist_free(channellist);
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100606}
607
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100608/**
Uwe Hermann4cc0d9f2013-05-03 21:21:30 +0200609 * Unload the specified protocol decoder.
Bert Vermeulen451680f2012-01-15 03:58:27 +0100610 *
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100611 * @param dec The struct srd_decoder to be unloaded.
Bert Vermeulen451680f2012-01-15 03:58:27 +0100612 *
613 * @return SRD_OK upon success, a (negative) error code otherwise.
Uwe Hermann8c664ca2013-05-03 14:45:49 +0200614 *
615 * @since 0.1.0
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100616 */
Bert Vermeulen9d122fd2012-02-14 03:43:28 +0100617SRD_API int srd_decoder_unload(struct srd_decoder *dec)
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100618{
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100619 struct srd_decoder_option *o;
Bert Vermeulen32cfb922013-09-12 23:54:43 +0200620 struct srd_session *sess;
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100621 GSList *l;
622
Bert Vermeulene195c022013-11-18 01:21:16 +0100623 if (!srd_check_init())
624 return SRD_ERR;
625
626 if (!dec)
627 return SRD_ERR_ARG;
628
Uwe Hermann8ad6e502012-03-16 15:25:53 +0100629 srd_dbg("Unloading protocol decoder '%s'.", dec->name);
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100630
Uwe Hermann361fdca2012-03-15 22:00:24 +0100631 /*
632 * Since any instances of this decoder need to be released as well,
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100633 * but they could be anywhere in the stack, just free the entire
634 * stack. A frontend reloading a decoder thus has to restart all
Uwe Hermann361fdca2012-03-15 22:00:24 +0100635 * instances, and rebuild the stack.
636 */
Bert Vermeulen32cfb922013-09-12 23:54:43 +0200637 for (l = sessions; l; l = l->next) {
638 sess = l->data;
639 srd_inst_free_all(sess, NULL);
640 }
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100641
Bert Vermeulen2f395bf2013-03-19 01:47:53 +0100642 for (l = dec->options; l; l = l->next) {
643 o = l->data;
644 g_free(o->id);
645 g_free(o->desc);
646 g_variant_unref(o->def);
647 g_free(o);
648 }
649 g_slist_free(dec->options);
650
Uwe Hermann6a155972014-04-13 19:57:43 +0200651 free_channels(dec->channels);
652 free_channels(dec->opt_channels);
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100653 g_free(dec->id);
654 g_free(dec->name);
Bert Vermeulenb2315462012-01-09 00:13:03 +0100655 g_free(dec->longname);
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100656 g_free(dec->desc);
Bert Vermeulenb2315462012-01-09 00:13:03 +0100657 g_free(dec->license);
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100658
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100659 /* The module's Decoder class. */
Bert Vermeulen451680f2012-01-15 03:58:27 +0100660 Py_XDECREF(dec->py_dec);
Bert Vermeulenfa12a212012-01-31 23:48:10 +0100661 /* The module itself. */
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100662 Py_XDECREF(dec->py_mod);
663
Bert Vermeulene592ac82013-05-05 17:20:13 +0200664 g_free(dec);
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100665
666 return SRD_OK;
667}
668
Bert Vermeulenea81b492013-12-11 18:31:56 +0100669static void srd_decoder_load_all_path(char *path)
670{
671 GDir *dir;
672 const gchar *direntry;
673
674 if (!(dir = g_dir_open(path, 0, NULL)))
675 /* Not really fatal */
676 return;
677
678 /* This ignores errors returned by srd_decoder_load(). That
679 * function will have logged the cause, but in any case we
680 * want to continue anyway. */
681 while ((direntry = g_dir_read_name(dir)) != NULL) {
682 /* The directory name is the module name (e.g. "i2c"). */
683 srd_decoder_load(direntry);
684 }
685 g_dir_close(dir);
686
687}
688
Bert Vermeulen582c8472012-02-12 14:55:20 +0100689/**
Bert Vermeulen9b371092012-02-14 03:28:53 +0100690 * Load all installed protocol decoders.
Bert Vermeulen582c8472012-02-12 14:55:20 +0100691 *
692 * @return SRD_OK upon success, a (negative) error code otherwise.
Uwe Hermann8c664ca2013-05-03 14:45:49 +0200693 *
694 * @since 0.1.0
Bert Vermeulen582c8472012-02-12 14:55:20 +0100695 */
Uwe Hermann8ad6e502012-03-16 15:25:53 +0100696SRD_API int srd_decoder_load_all(void)
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100697{
Bert Vermeulenea81b492013-12-11 18:31:56 +0100698 GSList *l;
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100699
Bert Vermeulene195c022013-11-18 01:21:16 +0100700 if (!srd_check_init())
701 return SRD_ERR;
702
Bert Vermeulenea81b492013-12-11 18:31:56 +0100703 for (l = searchpaths; l; l = l->next)
704 srd_decoder_load_all_path(l->data);
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100705
706 return SRD_OK;
707}
708
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100709/**
Bert Vermeulen582c8472012-02-12 14:55:20 +0100710 * Unload all loaded protocol decoders.
711 *
712 * @return SRD_OK upon success, a (negative) error code otherwise.
Uwe Hermann8c664ca2013-05-03 14:45:49 +0200713 *
714 * @since 0.1.0
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100715 */
Uwe Hermann8ad6e502012-03-16 15:25:53 +0100716SRD_API int srd_decoder_unload_all(void)
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100717{
718 GSList *l;
719 struct srd_decoder *dec;
720
Uwe Hermann38ff5042013-02-02 12:18:29 +0100721 for (l = pd_list; l; l = l->next) {
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100722 dec = l->data;
Bert Vermeulen9d122fd2012-02-14 03:43:28 +0100723 srd_decoder_unload(dec);
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100724 }
Bert Vermeulen820bf442013-12-11 16:30:25 +0100725 g_slist_free(pd_list);
726 pd_list = NULL;
Bert Vermeulenb2c19612011-12-04 10:33:02 +0100727
728 return SRD_OK;
729}
Uwe Hermann48954182013-02-09 22:25:15 +0100730
731/** @} */