65d05d01ef9b4b3babeb943a1cbbe254fe2a82e5
[libsigrokdecode.git] / decoder.c
1 /*
2  * This file is part of the sigrok project.
3  *
4  * Copyright (C) 2010 Uwe Hermann <uwe@hermann-uwe.de>
5  * Copyright (C) 2011 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 <glib.h>
22 #include "config.h"
23 #include "sigrokdecode.h" /* First, so we avoid a _POSIX_C_SOURCE warning. */
24 #include "sigrokdecode-internal.h"
25
26 /* The list of protocol decoders. */
27 GSList *pd_list = NULL;
28
29 /* lives in module_sigrokdecode.c */
30 extern PyObject *mod_sigrokdecode;
31
32
33 /**
34  * Returns the list of supported/loaded protocol decoders.
35  *
36  * This is a GSList containing the names of the decoders as strings.
37  *
38  * @return List of decoders, NULL if none are supported or loaded.
39  */
40 GSList *srd_list_decoders(void)
41 {
42
43         return pd_list;
44 }
45
46
47 /**
48  * Get the decoder with the specified ID.
49  *
50  * @param id The ID string of the decoder to return.
51  * @return The decoder with the specified ID, or NULL if not found.
52  */
53 struct srd_decoder *srd_get_decoder_by_id(const char *id)
54 {
55         GSList *l;
56         struct srd_decoder *dec;
57
58         for (l = srd_list_decoders(); l; l = l->next) {
59                 dec = l->data;
60                 if (!strcmp(dec->id, id))
61                         return dec;
62         }
63
64         return NULL;
65 }
66
67
68 /**
69  * Load a protocol decoder module into the embedded Python interpreter.
70  *
71  * @param name The module name to be loaded.
72  * @param dec Pointer to the struct srd_decoder filled with the loaded module.
73  *
74  * @return SRD_OK upon success, a (negative) error code otherwise.
75  */
76 int srd_load_decoder(const char *name, struct srd_decoder **dec)
77 {
78         PyObject *py_basedec, *py_annlist, *py_ann;
79         struct srd_decoder *d;
80         int alen, ret, i;
81         char **ann;
82
83         py_basedec = NULL;
84
85         srd_dbg("decoder: %s: loading module '%s'", __func__, name);
86
87         if (!(d = g_try_malloc0(sizeof(struct srd_decoder)))) {
88                 srd_err("decoder: %s: d malloc failed", __func__);
89                 ret = SRD_ERR_MALLOC;
90                 goto err_out;
91         }
92
93         ret = SRD_ERR_PYTHON;
94
95         /* Import the Python module. */
96         if (!(d->py_mod = PyImport_ImportModule(name))) {
97                 /* TODO: Report exception message/traceback to err/dbg. */
98                 srd_warn("decoder: %s: import of '%s' failed", __func__, name);
99                 PyErr_Print();
100                 PyErr_Clear();
101                 goto err_out;
102         }
103
104         /* Get the 'Decoder' class as Python object. */
105         if (!(d->py_dec = PyObject_GetAttrString(d->py_mod, "Decoder"))) {
106                 /* This generated an AttributeError exception. */
107                 PyErr_Print();
108                 PyErr_Clear();
109                 srd_err("Decoder class not found in protocol decoder module %s", name);
110                 goto err_out;
111         }
112
113         if (!(py_basedec = PyObject_GetAttrString(mod_sigrokdecode, "Decoder"))) {
114                 srd_dbg("sigrokdecode module not loaded");
115                 goto err_out;
116         }
117
118         if (!PyObject_IsSubclass(d->py_dec, py_basedec)) {
119                 srd_err("Decoder class in protocol decoder module %s is not "
120                                 "a subclass of sigrokdecode.Decoder", name);
121                 goto err_out;
122         }
123         Py_DecRef(py_basedec);
124
125         if (py_attr_as_str(d->py_dec, "id", &(d->id)) != SRD_OK)
126                 goto err_out;
127
128         if (py_attr_as_str(d->py_dec, "name", &(d->name)) != SRD_OK)
129                 goto err_out;
130
131         if (py_attr_as_str(d->py_dec, "longname", &(d->longname)) != SRD_OK)
132                 goto err_out;
133
134         if (py_attr_as_str(d->py_dec, "desc", &(d->desc)) != SRD_OK)
135                 goto err_out;
136
137         if (py_attr_as_str(d->py_dec, "license", &(d->license)) != SRD_OK)
138                 goto err_out;
139
140         /* TODO: Handle inputformats, outputformats. */
141         d->inputformats = NULL;
142         d->outputformats = NULL;
143
144         /* Convert class annotation attribute to GSList of **char */
145         d->annotations = NULL;
146         if (PyObject_HasAttrString(d->py_dec, "annotations")) {
147                 py_annlist = PyObject_GetAttrString(d->py_dec, "annotations");
148                 if (!PyList_Check(py_annlist)) {
149                         srd_err("Protocol decoder module %s annotations should be a list", name);
150                         goto err_out;
151                 }
152                 alen = PyList_Size(py_annlist);
153                 for (i = 0; i < alen; i++) {
154                         py_ann = PyList_GetItem(py_annlist, i);
155                         if (!PyList_Check(py_ann) || PyList_Size(py_ann) != 2) {
156                                 srd_err("Protocol decoder module %s annotation %d should be a list with two elements",
157                                                 name, i+1);
158                                 goto err_out;
159                         }
160
161                         if (py_strlist_to_char(py_ann, &ann) != SRD_OK) {
162                                 goto err_out;
163                         }
164                         d->annotations = g_slist_append(d->annotations, ann);
165                 }
166         }
167
168         *dec = d;
169         ret = SRD_OK;
170
171 err_out:
172         if (ret != SRD_OK) {
173                 Py_XDECREF(py_basedec);
174                 Py_XDECREF(d->py_dec);
175                 Py_XDECREF(d->py_mod);
176                 g_free(d);
177         }
178
179         return ret;
180 }
181
182 char *srd_decoder_doc(struct srd_decoder *dec)
183 {
184         PyObject *py_str;
185         char *doc;
186
187         if (!PyObject_HasAttrString(dec->py_mod, "__doc__"))
188                 return NULL;
189
190         if (!(py_str = PyObject_GetAttrString(dec->py_mod, "__doc__"))) {
191                 PyErr_Clear();
192                 return NULL;
193         }
194
195         doc = NULL;
196         if (py_str != Py_None)
197                 py_str_as_str(py_str, &doc);
198         Py_DecRef(py_str);
199
200         return doc;
201 }
202
203
204 /**
205  * Unload decoder module.
206  *
207  * @param dec The decoder struct to be unloaded.
208  *
209  * @return SRD_OK upon success, a (negative) error code otherwise.
210  */
211 int srd_unload_decoder(struct srd_decoder *dec)
212 {
213
214         g_free(dec->id);
215         g_free(dec->name);
216         g_free(dec->longname);
217         g_free(dec->desc);
218         g_free(dec->license);
219
220         /* TODO: Free everything in inputformats and outputformats. */
221         if (dec->inputformats != NULL)
222                 g_slist_free(dec->inputformats);
223         if (dec->outputformats != NULL)
224                 g_slist_free(dec->outputformats);
225
226         Py_XDECREF(dec->py_dec);
227         Py_XDECREF(dec->py_mod);
228
229         /* TODO: (g_)free dec itself? */
230
231         return SRD_OK;
232 }
233
234 /**
235  * Check if the directory in the specified search path is a valid PD dir.
236  *
237  * A valid sigrok protocol decoder consists of a directory, which contains
238  * at least two .py files (the special __init__.py and at least one additional
239  * .py file which contains the actual PD code).
240  *
241  * TODO: We should also check that this is not a random other Python module,
242  * but really a sigrok PD module by some means.
243  *
244  * @param search_path A string containing the (absolute) path to the directory
245  *                    where 'entry' resides in.
246  * @param entry A string containing the (relative) directory name of the
247  *              sigrok PD module. E.g. "i2c" for the I2C protocol decoder.
248  * @return SRD_OK, if the directory is a valid sigrok PD, a negative error
249  *         code, such as SRD_ERR, otherwise.
250  */
251 int srd_is_valid_pd_dir(const gchar *search_path, const gchar *entry)
252 {
253         GDir *dir;
254         int py_files = 0, has_init_py = 0;
255         gchar *path1, *path2, *file;
256         GError *error;
257
258         /* TODO: Error handling. */
259         path1 = g_build_filename(search_path, entry, NULL);
260
261         /* Check that it is a directory (and exists). */
262         if (!g_file_test(path1, G_FILE_TEST_IS_DIR)) {
263                 srd_dbg("decoder: %s: '%s' not a directory or doesn't exist",
264                         __func__, entry);
265                 return SRD_ERR;
266         }
267
268         if (!(dir = g_dir_open(path1, 0, &error))) { /* TODO: flags? */
269                 srd_dbg("decoder: %s: '%s' failed to open directory",
270                         __func__, entry);
271                 return SRD_ERR;
272         }
273
274         /* Check the contents of the directory. */
275         while ((file = g_dir_read_name(dir)) != NULL) {
276                 /* TODO: Error handling. */
277                 path2 = g_build_filename(path1, file, NULL);
278
279                 /* Ignore non-files. */
280                 if (!g_file_test(path2, G_FILE_TEST_IS_REGULAR)) {
281                         srd_spew("decoder: %s: '%s' not a file, ignoring",
282                                  __func__, file);
283                         continue;
284                 }
285
286                 /* Count number of .py files. */
287                 if (g_str_has_suffix(path2, ".py")) {
288                         srd_spew("decoder: %s: found .py file: '%s'",
289                                  __func__, file);
290                         py_files++;
291                 }
292
293                 /* Check if it's an __init__.py file. */
294                 if (g_str_has_suffix(path2, "__init__.py")) {
295                         srd_spew("decoder: %s: found __init__.py file: '%s'",
296                                  __func__, path2);
297                         has_init_py = 1;
298                 }
299         }
300         g_dir_close(dir);
301
302         /* Check if the directory contains >= 2 *.py files. */
303         if (py_files < 2) {
304                 srd_dbg("decoder: %s: '%s' is not a valid PD dir, it doesn't "
305                         "contain >= 2 .py files", __func__, entry);
306                 return SRD_ERR;
307         }
308
309         /* Check if the directory contains an __init__.py file. */
310         if (!has_init_py) {
311                 srd_dbg("decoder: %s: '%s' is not a valid PD dir, it doesn't "
312                         "contain an __init__.py file", __func__, entry);
313                 return SRD_ERR;
314         }
315
316         /* TODO: Check if it's a PD, not a random other Python module. */
317
318         return SRD_OK;
319 }
320
321 int srd_load_all_decoders(void)
322 {
323         GDir *dir;
324         gchar *direntry;
325         int ret;
326         char *decodername;
327         struct srd_decoder *dec;
328         GError *error;
329
330         if (!(dir = g_dir_open(DECODERS_DIR, 0, &error))) { /* TODO: flags? */
331                 Py_Finalize(); /* Returns void. */
332                 return SRD_ERR_DECODERS_DIR;
333         }
334
335         while ((direntry = g_dir_read_name(dir)) != NULL) {
336                 /* Ignore directory entries which are not valid PDs. */
337                 if (srd_is_valid_pd_dir(DECODERS_DIR, direntry) != SRD_OK) {
338                         srd_dbg("decoder: %s: '%s' not a valid PD dir, "
339                                 "ignoring it", __func__, direntry);
340                         continue;
341                 }
342
343                 /* The decoder name is the PD directory name (e.g. "i2c"). */
344                 decodername = g_strdup(direntry);
345
346                 /* TODO: Error handling. Use g_try_malloc(). */
347                 if (!(dec = malloc(sizeof(struct srd_decoder)))) {
348                         Py_Finalize(); /* Returns void. */
349                         return SRD_ERR_MALLOC;
350                 }
351
352                 /* Load the decoder. */
353                 /* TODO: Warning if loading fails for a decoder. */
354                 if ((ret = srd_load_decoder(decodername, &dec)) == SRD_OK) {
355                         /* Append it to the list of supported/loaded decoders. */
356                         pd_list = g_slist_append(pd_list, dec);
357                 }
358         }
359         g_dir_close(dir);
360
361         return SRD_OK;
362 }
363
364 /**
365  * TODO
366  */
367 int srd_unload_all_decoders(void)
368 {
369         GSList *l;
370         struct srd_decoder *dec;
371
372         for (l = srd_list_decoders(); l; l = l->next) {
373                 dec = l->data;
374                 /* TODO: Error handling. */
375                 srd_unload_decoder(dec);
376         }
377
378         return SRD_OK;
379 }
380
381
382