X-Git-Url: https://sigrok.org/gitweb/?p=libsigrokdecode.git;a=blobdiff_plain;f=decoder.c;h=fc6ae07317c86929a8db634c9b9d2e4391dba081;hp=8ad0c5a132e1bac021184bab8c9ee60e28aa5ff6;hb=HEAD;hpb=21dfd91d99836bdc6c0da939b601dd8a52358f21 diff --git a/decoder.c b/decoder.c index 8ad0c5a..dd3bd5a 100644 --- a/decoder.c +++ b/decoder.c @@ -136,6 +136,18 @@ static void annotation_row_free(void *data) g_free(row); } +static void logic_output_channel_free(void *data) +{ + struct srd_decoder_logic_output_channel *logic_out_ch = data; + + if (!logic_out_ch) + return; + + g_free(logic_out_ch->desc); + g_free(logic_out_ch->id); + g_free(logic_out_ch); +} + static void decoder_option_free(void *data) { struct srd_decoder_option *opt = data; @@ -152,11 +164,15 @@ static void decoder_option_free(void *data) static void decoder_free(struct srd_decoder *dec) { + PyGILState_STATE gstate; + if (!dec) return; + gstate = PyGILState_Ensure(); Py_XDECREF(dec->py_dec); Py_XDECREF(dec->py_mod); + PyGILState_Release(gstate); g_slist_free_full(dec->options, &decoder_option_free); g_slist_free_full(dec->binary, (GDestroyNotify)&g_strfreev); @@ -165,6 +181,9 @@ static void decoder_free(struct srd_decoder *dec) g_slist_free_full(dec->opt_channels, &channel_free); g_slist_free_full(dec->channels, &channel_free); + g_slist_free_full(dec->outputs, g_free); + g_slist_free_full(dec->inputs, g_free); + g_slist_free_full(dec->tags, g_free); g_free(dec->license); g_free(dec->desc); g_free(dec->longname); @@ -180,11 +199,16 @@ static int get_channels(const struct srd_decoder *d, const char *attr, PyObject *py_channellist, *py_entry; struct srd_channel *pdch; GSList *pdchl; - ssize_t i; + ssize_t ch_idx; + PyGILState_STATE gstate; + + gstate = PyGILState_Ensure(); - if (!PyObject_HasAttrString(d->py_dec, attr)) + if (!PyObject_HasAttrString(d->py_dec, attr)) { /* No channels of this type specified. */ + PyGILState_Release(gstate); return SRD_OK; + } pdchl = NULL; @@ -198,8 +222,9 @@ static int get_channels(const struct srd_decoder *d, const char *attr, goto err_out; } - for (i = PyTuple_Size(py_channellist) - 1; i >= 0; i--) { - py_entry = PyTuple_GetItem(py_channellist, i); + ch_idx = PyTuple_Size(py_channellist); + while (ch_idx--) { + py_entry = PyTuple_GetItem(py_channellist, ch_idx); if (!py_entry) goto except_out; @@ -208,7 +233,7 @@ static int get_channels(const struct srd_decoder *d, const char *attr, "a list of dict elements.", d->name, attr); goto err_out; } - pdch = g_malloc0(sizeof(struct srd_channel)); + pdch = g_malloc(sizeof(struct srd_channel)); /* Add to list right away so it doesn't get lost. */ pdchl = g_slist_prepend(pdchl, pdch); @@ -219,20 +244,24 @@ static int get_channels(const struct srd_decoder *d, const char *attr, if (py_dictitem_as_str(py_entry, "desc", &pdch->desc) != SRD_OK) goto err_out; - pdch->order = offset + i; + pdch->order = offset + ch_idx; } Py_DECREF(py_channellist); *out_pdchl = pdchl; + PyGILState_Release(gstate); + return SRD_OK; except_out: srd_exception_catch("Failed to get %s list of %s decoder", attr, d->name); + err_out: g_slist_free_full(pdchl, &channel_free); Py_XDECREF(py_channellist); + PyGILState_Release(gstate); return SRD_ERR_PYTHON; } @@ -243,11 +272,16 @@ static int get_options(struct srd_decoder *d) GSList *options; struct srd_decoder_option *o; GVariant *gvar; - ssize_t opt, i; + ssize_t opt, val_idx; + PyGILState_STATE gstate; + + gstate = PyGILState_Ensure(); - if (!PyObject_HasAttrString(d->py_dec, "options")) + if (!PyObject_HasAttrString(d->py_dec, "options")) { /* No options, that's fine. */ + PyGILState_Release(gstate); return SRD_OK; + } options = NULL; @@ -279,7 +313,7 @@ static int get_options(struct srd_decoder *d) py_str = PyDict_GetItemString(py_opt, "id"); if (!py_str) { - srd_err("Protocol decoder %s option %zd has no id.", + srd_err("Protocol decoder %s option %zd has no ID.", d->name, opt); goto err_out; } @@ -305,8 +339,10 @@ static int get_options(struct srd_decoder *d) py_values = PyDict_GetItemString(py_opt, "values"); if (py_values) { - /* A default is required if a list of values is - * given, since it's used to verify their type. */ + /* + * A default is required if a list of values is + * given, since it's used to verify their type. + */ if (!o->def) { srd_err("No default for option '%s'.", o->id); goto err_out; @@ -316,12 +352,13 @@ static int get_options(struct srd_decoder *d) goto err_out; } - for (i = PyTuple_Size(py_values) - 1; i >= 0; i--) { - py_item = PyTuple_GetItem(py_values, i); + val_idx = PyTuple_Size(py_values); + while (val_idx--) { + py_item = PyTuple_GetItem(py_values, val_idx); if (!py_item) goto except_out; - if (Py_TYPE(py_default) != Py_TYPE(py_item)) { + if (py_default && (Py_TYPE(py_default) != Py_TYPE(py_item))) { srd_err("All values for option '%s' must be " "of the same type as the default.", o->id); @@ -340,29 +377,39 @@ static int get_options(struct srd_decoder *d) } d->options = options; Py_DECREF(py_opts); + PyGILState_Release(gstate); return SRD_OK; except_out: srd_exception_catch("Failed to get %s decoder options", d->name); + err_out: g_slist_free_full(options, &decoder_option_free); Py_XDECREF(py_opts); + PyGILState_Release(gstate); return SRD_ERR_PYTHON; } -/* Convert annotation class attribute to GSList of char **. - */ -static int get_annotations(struct srd_decoder *dec) +/* Convert annotation class attribute to GSList of char **. */ +static int get_annotations(struct srd_decoder *dec, size_t *ret_count) { PyObject *py_annlist, *py_ann; GSList *annotations; char **annpair; - ssize_t i; + ssize_t ann_idx; + PyGILState_STATE gstate; - if (!PyObject_HasAttrString(dec->py_dec, "annotations")) + if (ret_count) + *ret_count = 0; + + gstate = PyGILState_Ensure(); + + if (!PyObject_HasAttrString(dec->py_dec, "annotations")) { + PyGILState_Release(gstate); return SRD_OK; + } annotations = NULL; @@ -371,20 +418,22 @@ static int get_annotations(struct srd_decoder *dec) goto except_out; if (!PyTuple_Check(py_annlist)) { - srd_err("Protocol decoder %s annotations should " - "be a tuple.", dec->name); + srd_err("Protocol decoder %s annotations should be a tuple.", + dec->name); goto err_out; } - for (i = PyTuple_Size(py_annlist) - 1; i >= 0; i--) { - py_ann = PyTuple_GetItem(py_annlist, i); + ann_idx = PyTuple_Size(py_annlist); + if (ret_count) + *ret_count = ann_idx; + while (ann_idx--) { + py_ann = PyTuple_GetItem(py_annlist, ann_idx); if (!py_ann) goto except_out; if (!PyTuple_Check(py_ann) || PyTuple_Size(py_ann) != 2) { - srd_err("Protocol decoder %s annotation %zd should " - "be a tuple with two elements.", - dec->name, i + 1); + srd_err("Protocol decoder %s annotation %zd should be a tuple with two elements.", + dec->name, ann_idx + 1); goto err_out; } if (py_strseq_to_char(py_ann, &annpair) != SRD_OK) @@ -394,52 +443,61 @@ static int get_annotations(struct srd_decoder *dec) } dec->annotations = annotations; Py_DECREF(py_annlist); + PyGILState_Release(gstate); return SRD_OK; except_out: srd_exception_catch("Failed to get %s decoder annotations", dec->name); + err_out: g_slist_free_full(annotations, (GDestroyNotify)&g_strfreev); Py_XDECREF(py_annlist); + PyGILState_Release(gstate); return SRD_ERR_PYTHON; } -/* Convert annotation_rows to GSList of 'struct srd_decoder_annotation_row'. - */ -static int get_annotation_rows(struct srd_decoder *dec) +/* Convert annotation_rows to GSList of 'struct srd_decoder_annotation_row'. */ +static int get_annotation_rows(struct srd_decoder *dec, size_t cls_count) { + const char *py_member_name = "annotation_rows"; + PyObject *py_ann_rows, *py_ann_row, *py_ann_classes, *py_item; GSList *annotation_rows; struct srd_decoder_annotation_row *ann_row; - ssize_t i, k; + ssize_t row_idx, item_idx; size_t class_idx; + PyGILState_STATE gstate; - if (!PyObject_HasAttrString(dec->py_dec, "annotation_rows")) + gstate = PyGILState_Ensure(); + + if (!PyObject_HasAttrString(dec->py_dec, py_member_name)) { + PyGILState_Release(gstate); return SRD_OK; + } annotation_rows = NULL; - py_ann_rows = PyObject_GetAttrString(dec->py_dec, "annotation_rows"); + py_ann_rows = PyObject_GetAttrString(dec->py_dec, py_member_name); if (!py_ann_rows) goto except_out; if (!PyTuple_Check(py_ann_rows)) { - srd_err("Protocol decoder %s annotation_rows " - "must be a tuple.", dec->name); + srd_err("Protocol decoder %s %s must be a tuple.", + dec->name, py_member_name); goto err_out; } - for (i = PyTuple_Size(py_ann_rows) - 1; i >= 0; i--) { - py_ann_row = PyTuple_GetItem(py_ann_rows, i); + row_idx = PyTuple_Size(py_ann_rows); + while (row_idx--) { + py_ann_row = PyTuple_GetItem(py_ann_rows, row_idx); if (!py_ann_row) goto except_out; if (!PyTuple_Check(py_ann_row) || PyTuple_Size(py_ann_row) != 3) { - srd_err("Protocol decoder %s annotation_rows " - "must contain only tuples of 3 elements.", - dec->name); + srd_err("Protocol decoder %s %s must contain only tuples of 3 elements.", + dec->name, py_member_name); goto err_out; } ann_row = g_malloc0(sizeof(struct srd_decoder_annotation_row)); @@ -463,26 +521,30 @@ static int get_annotation_rows(struct srd_decoder *dec) goto except_out; if (!PyTuple_Check(py_ann_classes)) { - srd_err("Protocol decoder %s annotation_rows tuples " - "must have a tuple of numbers as 3rd element.", - dec->name); + srd_err("Protocol decoder %s %s tuples must have a tuple of numbers as 3rd element.", + dec->name, py_member_name); goto err_out; } - for (k = PyTuple_Size(py_ann_classes) - 1; k >= 0; k--) { - py_item = PyTuple_GetItem(py_ann_classes, k); + item_idx = PyTuple_Size(py_ann_classes); + while (item_idx--) { + py_item = PyTuple_GetItem(py_ann_classes, item_idx); if (!py_item) goto except_out; if (!PyLong_Check(py_item)) { - srd_err("Protocol decoder %s annotation row " - "class tuple must only contain numbers.", + srd_err("Protocol decoder %s annotation row class tuple must only contain numbers.", dec->name); goto err_out; } class_idx = PyLong_AsSize_t(py_item); if (PyErr_Occurred()) goto except_out; + if (class_idx >= cls_count) { + srd_err("Protocol decoder %s annotation row %zd references invalid class %zu.", + dec->name, row_idx, class_idx); + goto err_out; + } ann_row->ann_classes = g_slist_prepend(ann_row->ann_classes, GSIZE_TO_POINTER(class_idx)); @@ -490,30 +552,37 @@ static int get_annotation_rows(struct srd_decoder *dec) } dec->annotation_rows = annotation_rows; Py_DECREF(py_ann_rows); + PyGILState_Release(gstate); return SRD_OK; except_out: srd_exception_catch("Failed to get %s decoder annotation rows", dec->name); + err_out: g_slist_free_full(annotation_rows, &annotation_row_free); Py_XDECREF(py_ann_rows); + PyGILState_Release(gstate); return SRD_ERR_PYTHON; } -/* Convert binary classes to GSList of char **. - */ +/* Convert binary classes to GSList of char **. */ static int get_binary_classes(struct srd_decoder *dec) { PyObject *py_bin_classes, *py_bin_class; GSList *bin_classes; char **bin; - ssize_t i; + ssize_t bin_idx; + PyGILState_STATE gstate; + + gstate = PyGILState_Ensure(); - if (!PyObject_HasAttrString(dec->py_dec, "binary")) + if (!PyObject_HasAttrString(dec->py_dec, "binary")) { + PyGILState_Release(gstate); return SRD_OK; + } bin_classes = NULL; @@ -527,8 +596,9 @@ static int get_binary_classes(struct srd_decoder *dec) goto err_out; } - for (i = PyTuple_Size(py_bin_classes) - 1; i >= 0; i--) { - py_bin_class = PyTuple_GetItem(py_bin_classes, i); + bin_idx = PyTuple_Size(py_bin_classes); + while (bin_idx--) { + py_bin_class = PyTuple_GetItem(py_bin_classes, bin_idx); if (!py_bin_class) goto except_out; @@ -546,37 +616,118 @@ static int get_binary_classes(struct srd_decoder *dec) } dec->binary = bin_classes; Py_DECREF(py_bin_classes); + PyGILState_Release(gstate); return SRD_OK; except_out: srd_exception_catch("Failed to get %s decoder binary classes", dec->name); + err_out: g_slist_free_full(bin_classes, (GDestroyNotify)&g_strfreev); Py_XDECREF(py_bin_classes); + PyGILState_Release(gstate); return SRD_ERR_PYTHON; } -/* Check whether the Decoder class defines the named method. - */ +/* Convert logic_output_channels to GSList of 'struct srd_decoder_logic_output_channel'. */ +static int get_logic_output_channels(struct srd_decoder *dec) +{ + PyObject *py_logic_out_chs, *py_logic_out_ch, *py_item; + GSList *logic_out_chs; + struct srd_decoder_logic_output_channel *logic_out_ch; + ssize_t i; + PyGILState_STATE gstate; + + gstate = PyGILState_Ensure(); + + if (!PyObject_HasAttrString(dec->py_dec, "logic_output_channels")) { + PyGILState_Release(gstate); + return SRD_OK; + } + + logic_out_chs = NULL; + + py_logic_out_chs = PyObject_GetAttrString(dec->py_dec, "logic_output_channels"); + if (!py_logic_out_chs) + goto except_out; + + if (!PyTuple_Check(py_logic_out_chs)) { + srd_err("Protocol decoder %s logic_output_channels " + "must be a tuple.", dec->name); + goto err_out; + } + + for (i = PyTuple_Size(py_logic_out_chs) - 1; i >= 0; i--) { + py_logic_out_ch = PyTuple_GetItem(py_logic_out_chs, i); + if (!py_logic_out_ch) + goto except_out; + + if (!PyTuple_Check(py_logic_out_ch) || PyTuple_Size(py_logic_out_ch) != 2) { + srd_err("Protocol decoder %s logic_output_channels " + "must contain only tuples of 2 elements.", + dec->name); + goto err_out; + } + logic_out_ch = g_malloc0(sizeof(*logic_out_ch)); + /* Add to list right away so it doesn't get lost. */ + logic_out_chs = g_slist_prepend(logic_out_chs, logic_out_ch); + + py_item = PyTuple_GetItem(py_logic_out_ch, 0); + if (!py_item) + goto except_out; + if (py_str_as_str(py_item, &logic_out_ch->id) != SRD_OK) + goto err_out; + + py_item = PyTuple_GetItem(py_logic_out_ch, 1); + if (!py_item) + goto except_out; + if (py_str_as_str(py_item, &logic_out_ch->desc) != SRD_OK) + goto err_out; + } + dec->logic_output_channels = logic_out_chs; + Py_DECREF(py_logic_out_chs); + PyGILState_Release(gstate); + + return SRD_OK; + +except_out: + srd_exception_catch("Failed to get %s decoder logic output channels", + dec->name); + +err_out: + g_slist_free_full(logic_out_chs, &logic_output_channel_free); + Py_XDECREF(py_logic_out_chs); + PyGILState_Release(gstate); + + return SRD_ERR_PYTHON; +} + +/* Check whether the Decoder class defines the named method. */ static int check_method(PyObject *py_dec, const char *mod_name, const char *method_name) { PyObject *py_method; int is_callable; + PyGILState_STATE gstate; + + gstate = PyGILState_Ensure(); py_method = PyObject_GetAttrString(py_dec, method_name); if (!py_method) { srd_exception_catch("Protocol decoder %s Decoder class " "has no %s() method", mod_name, method_name); + PyGILState_Release(gstate); return SRD_ERR_PYTHON; } is_callable = PyCallable_Check(py_method); Py_DECREF(py_method); + PyGILState_Release(gstate); + if (!is_callable) { srd_err("Protocol decoder %s Decoder class attribute '%s' " "is not a method.", mod_name, method_name); @@ -592,23 +743,77 @@ static int check_method(PyObject *py_dec, const char *mod_name, * @param d The decoder to use. Must not be NULL. * * @return The API version of the decoder, or 0 upon errors. + * + * @private */ SRD_PRIV long srd_decoder_apiver(const struct srd_decoder *d) { PyObject *py_apiver; long apiver; + PyGILState_STATE gstate; if (!d) return 0; + gstate = PyGILState_Ensure(); + py_apiver = PyObject_GetAttrString(d->py_dec, "api_version"); apiver = (py_apiver && PyLong_Check(py_apiver)) ? PyLong_AsLong(py_apiver) : 0; Py_XDECREF(py_apiver); + PyGILState_Release(gstate); + return apiver; } +static gboolean contains_duplicates(GSList *list) +{ + for (GSList *l1 = list; l1; l1 = l1->next) { + for (GSList *l2 = l1->next; l2; l2 = l2->next) + if (!strcmp(l1->data, l2->data)) + return TRUE; + } + + return FALSE; +} + +static gboolean contains_duplicate_ids(GSList *list1, GSList *list2) +{ + for (GSList *l1 = list1; l1; l1 = l1->next) { + unsigned int cnt = 0; + const char **s1 = l1->data; + for (GSList *l2 = list2; l2; l2 = l2->next) { + const char **s2 = l2->data; + if (!strcmp(s1[0], s2[0])) + cnt++; + if ((list1 == list2) && cnt > 1) + return TRUE; + if ((list1 != list2) && cnt > 0) + return TRUE; + } + } + + return FALSE; +} + +static gboolean contains_duplicate_row_ids(GSList *list1, GSList *list2) +{ + for (GSList *l1 = list1; l1; l1 = l1->next) { + unsigned int cnt = 0; + const struct srd_decoder_annotation_row *r1 = l1->data; + for (GSList *l2 = list2; l2; l2 = l2->next) { + const struct srd_decoder_annotation_row *r2 = l2->data; + if (!strcmp(r1->id, r2->id)) + cnt++; + if (cnt > 1) + return TRUE; + } + } + + return FALSE; +} + /** * Load a protocol decoder module into the embedded Python interpreter. * @@ -625,6 +830,8 @@ SRD_API int srd_decoder_load(const char *module_name) long apiver; int is_subclass; const char *fail_txt; + PyGILState_STATE gstate; + size_t ann_cls_count; if (!srd_check_init()) return SRD_ERR; @@ -632,13 +839,14 @@ SRD_API int srd_decoder_load(const char *module_name) if (!module_name) return SRD_ERR_ARG; + gstate = PyGILState_Ensure(); + if (PyDict_GetItemString(PyImport_GetModuleDict(), module_name)) { /* Module was already imported. */ + PyGILState_Release(gstate); return SRD_OK; } - srd_dbg("Loading protocol decoder '%s'.", module_name); - d = g_malloc0(sizeof(struct srd_decoder)); fail_txt = NULL; @@ -682,15 +890,20 @@ SRD_API int srd_decoder_load(const char *module_name) * PDs of different API versions are incompatible and cannot work. */ apiver = srd_decoder_apiver(d); - if (apiver != 2 && apiver != 3) { - srd_exception_catch("Only PD API version 2/3 is supported, " + if (apiver != 3) { + srd_exception_catch("Only PD API version 3 is supported, " "decoder %s has version %ld", module_name, apiver); fail_txt = "API version mismatch"; goto err_out; } - /* Check Decoder class for required methods. - */ + /* Check Decoder class for required methods. */ + + if (check_method(d->py_dec, module_name, "reset") != SRD_OK) { + fail_txt = "no 'reset()' method"; + goto err_out; + } + if (check_method(d->py_dec, module_name, "start") != SRD_OK) { fail_txt = "no 'start()' method"; goto err_out; @@ -727,6 +940,21 @@ SRD_API int srd_decoder_load(const char *module_name) goto err_out; } + if (py_attr_as_strlist(d->py_dec, "inputs", &(d->inputs)) != SRD_OK) { + fail_txt = "missing or malformed 'inputs' attribute"; + goto err_out; + } + + if (py_attr_as_strlist(d->py_dec, "outputs", &(d->outputs)) != SRD_OK) { + fail_txt = "missing or malformed 'outputs' attribute"; + goto err_out; + } + + if (py_attr_as_strlist(d->py_dec, "tags", &(d->tags)) != SRD_OK) { + fail_txt = "missing or malformed 'tags' attribute"; + goto err_out; + } + /* All options and their default values. */ if (get_options(d) != SRD_OK) { fail_txt = "cannot get options"; @@ -746,12 +974,12 @@ SRD_API int srd_decoder_load(const char *module_name) goto err_out; } - if (get_annotations(d) != SRD_OK) { + if (get_annotations(d, &ann_cls_count) != SRD_OK) { fail_txt = "cannot get annotations"; goto err_out; } - if (get_annotation_rows(d) != SRD_OK) { + if (get_annotation_rows(d, ann_cls_count) != SRD_OK) { fail_txt = "cannot get annotation rows"; goto err_out; } @@ -761,23 +989,86 @@ SRD_API int srd_decoder_load(const char *module_name) goto err_out; } + if (contains_duplicates(d->inputs)) { + fail_txt = "duplicate input IDs"; + goto err_out; + } + + if (contains_duplicates(d->outputs)) { + fail_txt = "duplicate output IDs"; + goto err_out; + } + + if (contains_duplicates(d->tags)) { + fail_txt = "duplicate tags"; + goto err_out; + } + + if (contains_duplicate_ids(d->channels, d->channels)) { + fail_txt = "duplicate channel IDs"; + goto err_out; + } + + if (contains_duplicate_ids(d->opt_channels, d->opt_channels)) { + fail_txt = "duplicate optional channel IDs"; + goto err_out; + } + + if (contains_duplicate_ids(d->channels, d->opt_channels)) { + fail_txt = "channel and optional channel IDs contain duplicates"; + goto err_out; + } + + if (contains_duplicate_ids(d->options, d->options)) { + fail_txt = "duplicate option IDs"; + goto err_out; + } + + if (contains_duplicate_ids(d->annotations, d->annotations)) { + fail_txt = "duplicate annotation class IDs"; + goto err_out; + } + + if (contains_duplicate_row_ids(d->annotation_rows, d->annotation_rows)) { + fail_txt = "duplicate annotation row IDs"; + goto err_out; + } + + if (contains_duplicate_ids(d->annotations, d->annotation_rows)) { + fail_txt = "annotation class/row IDs contain duplicates"; + goto err_out; + } + + if (contains_duplicate_ids(d->binary, d->binary)) { + fail_txt = "duplicate binary class IDs"; + goto err_out; + } + + if (get_logic_output_channels(d) != SRD_OK) { + fail_txt = "cannot get logic output channels"; + goto err_out; + } + + PyGILState_Release(gstate); + /* Append it to the list of loaded decoders. */ pd_list = g_slist_append(pd_list, d); return SRD_OK; except_out: - if (fail_txt) { + /* Don't show a message for the "common" directory, it's not a PD. */ + if (strcmp(module_name, "common")) { srd_exception_catch("Failed to load decoder %s: %s", module_name, fail_txt); - fail_txt = NULL; - } else { - srd_exception_catch("Failed to load decoder %s", module_name); } + fail_txt = NULL; + err_out: if (fail_txt) srd_err("Failed to load decoder %s: %s", module_name, fail_txt); decoder_free(d); + PyGILState_Release(gstate); return SRD_ERR_PYTHON; } @@ -785,7 +1076,7 @@ err_out: /** * Return a protocol decoder's docstring. * - * @param dec The loaded protocol decoder. + * @param dec The loaded protocol decoder. Must not be NULL. * * @return A newly allocated buffer containing the protocol decoder's * documentation. The caller is responsible for free'ing the buffer. @@ -796,19 +1087,22 @@ SRD_API char *srd_decoder_doc_get(const struct srd_decoder *dec) { PyObject *py_str; char *doc; + PyGILState_STATE gstate; if (!srd_check_init()) return NULL; - if (!dec) + if (!dec || !dec->py_mod) return NULL; + gstate = PyGILState_Ensure(); + if (!PyObject_HasAttrString(dec->py_mod, "__doc__")) - return NULL; + goto err; if (!(py_str = PyObject_GetAttrString(dec->py_mod, "__doc__"))) { srd_exception_catch("Failed to get docstring"); - return NULL; + goto err; } doc = NULL; @@ -816,7 +1110,14 @@ SRD_API char *srd_decoder_doc_get(const struct srd_decoder *dec) py_str_as_str(py_str, &doc); Py_DECREF(py_str); + PyGILState_Release(gstate); + return doc; + +err: + PyGILState_Release(gstate); + + return NULL; } /** @@ -839,8 +1140,6 @@ SRD_API int srd_decoder_unload(struct srd_decoder *dec) if (!dec) return SRD_ERR_ARG; - srd_dbg("Unloading protocol decoder '%s'.", dec->name); - /* * Since any instances of this decoder need to be released as well, * but they could be anywhere in the stack, just free the entire @@ -849,7 +1148,7 @@ SRD_API int srd_decoder_unload(struct srd_decoder *dec) */ for (l = sessions; l; l = l->next) { sess = l->data; - srd_inst_free_all(sess, NULL); + srd_inst_free_all(sess); } /* Remove the PD from the list of loaded decoders. */ @@ -860,16 +1159,19 @@ SRD_API int srd_decoder_unload(struct srd_decoder *dec) return SRD_OK; } -static void srd_decoder_load_all_zip_path(char *path) +static void srd_decoder_load_all_zip_path(char *zip_path) { PyObject *zipimport_mod, *zipimporter_class, *zipimporter; PyObject *prefix_obj, *files, *key, *value, *set, *modname; Py_ssize_t pos = 0; char *prefix; size_t prefix_len; + PyGILState_STATE gstate; set = files = prefix_obj = zipimporter = zipimporter_class = NULL; + gstate = PyGILState_Ensure(); + zipimport_mod = py_import_by_name("zipimport"); if (zipimport_mod == NULL) goto err_out; @@ -878,7 +1180,7 @@ static void srd_decoder_load_all_zip_path(char *path) if (zipimporter_class == NULL) goto err_out; - zipimporter = PyObject_CallFunction(zipimporter_class, "s", path); + zipimporter = PyObject_CallFunction(zipimporter_class, "s", zip_path); if (zipimporter == NULL) goto err_out; @@ -938,6 +1240,7 @@ err_out: Py_XDECREF(zipimporter_class); Py_XDECREF(zipimport_mod); PyErr_Clear(); + PyGILState_Release(gstate); } static void srd_decoder_load_all_path(char *path) @@ -946,21 +1249,21 @@ static void srd_decoder_load_all_path(char *path) const gchar *direntry; if (!(dir = g_dir_open(path, 0, NULL))) { - /* Not really fatal */ - /* Try zipimport method too */ + /* Not really fatal. Try zipimport method too. */ srd_decoder_load_all_zip_path(path); return; } - /* This ignores errors returned by srd_decoder_load(). That + /* + * This ignores errors returned by srd_decoder_load(). That * function will have logged the cause, but in any case we - * want to continue anyway. */ + * want to continue anyway. + */ while ((direntry = g_dir_read_name(dir)) != NULL) { /* The directory name is the module name (e.g. "i2c"). */ srd_decoder_load(direntry); } g_dir_close(dir); - } /** @@ -983,6 +1286,13 @@ SRD_API int srd_decoder_load_all(void) return SRD_OK; } +static void srd_decoder_unload_cb(void *arg, void *ignored) +{ + (void)ignored; + + srd_decoder_unload((struct srd_decoder *)arg); +} + /** * Unload all loaded protocol decoders. * @@ -992,7 +1302,7 @@ SRD_API int srd_decoder_load_all(void) */ SRD_API int srd_decoder_unload_all(void) { - g_slist_foreach(pd_list, (GFunc)srd_decoder_unload, NULL); + g_slist_foreach(pd_list, srd_decoder_unload_cb, NULL); g_slist_free(pd_list); pd_list = NULL;