static void header_fields_update_cb(void *r, const char **err) { header_field_t *rec = (header_field_t *)r; char c; if (rec->header_name == NULL) { *err = ep_strdup_printf("Header name can't be empty"); return; } g_strstrip(rec->header_name); if (rec->header_name[0] == 0) { *err = ep_strdup_printf("Header name can't be empty"); return; } /* Check for invalid characters (to avoid asserting out when * registering the field). */ c = proto_check_field_name(rec->header_name); if (c) { *err = ep_strdup_printf("Header name can't contain '%c'", c); return; } *err = NULL; }
void SyntaxLineEdit::checkFieldName(QString field) { if (field.isEmpty()) { setSyntaxState(SyntaxLineEdit::Empty); return; } char invalid_char = proto_check_field_name(field.toUtf8().constData()); if (invalid_char) { setSyntaxState(SyntaxLineEdit::Invalid); } else { checkDisplayFilter(field); } }
static gboolean user_data_fields_update_cb(void *r, char **err) { user_data_field_t *rec = (user_data_field_t *)r; char c; *err = NULL; if (rec->udf_length == 0) { *err = g_strdup_printf("length of user data field can't be 0 Bytes (name: %s offset: %i length: %i)", rec->udf_name, rec->udf_offset, rec->udf_length); return (*err == NULL); } if (rec->udf_length > 4) { *err = g_strdup_printf("length of user data field can't be greater 4 Bytes (name: %s offset: %i length: %i)", rec->udf_name, rec->udf_offset, rec->udf_length); return (*err == NULL); } if (rec->udf_offset < 2) { *err = g_strdup_printf("offset of user data field can't be short than 2 (name: %s offset: %i length: %i)", rec->udf_name, rec->udf_offset, rec->udf_length); return (*err == NULL); } if (rec->udf_mask >= G_MAXUINT32) { *err = g_strdup_printf("mask can only be up to 32bits (name: %s)", rec->udf_name); return (*err == NULL); } if (rec->udf_name == NULL) { *err = g_strdup_printf("Name of user data field can't be empty"); return (*err == NULL); } g_strstrip(rec->udf_name); if (rec->udf_name[0] == 0) { *err = g_strdup_printf("Name of user data field can't be empty"); return (*err == NULL); } /* Check for invalid characters (to avoid asserting out when * registering the field). */ c = proto_check_field_name(rec->udf_name); if (c) { *err = g_strdup_printf("Name of user data field can't contain '%c'", c); return (*err == NULL); } return (*err == NULL); }
void DisplayFilterEdit::checkFilter(const QString& text) { dfilter_t *dfp; guchar c; clear_button_->setVisible(!text.isEmpty()); popFilterSyntaxStatus(); if (field_name_only_ && (c = proto_check_field_name(text.toUtf8().constData()))) { setSyntaxState(Invalid); emit pushFilterSyntaxStatus(QString().sprintf("Illegal character in field name: '%c'", c)); } else if (dfilter_compile(text.toUtf8().constData(), &dfp)) { GPtrArray *depr = NULL; if (dfp != NULL) { depr = dfilter_deprecated_tokens(dfp); } if (text.isEmpty()) { setSyntaxState(Empty); } else if (depr) { /* You keep using that word. I do not think it means what you think it means. */ setSyntaxState(Deprecated); /* * We're being lazy and only printing the first "problem" token. * Would it be better to print all of them? */ emit pushFilterSyntaxWarning(QString().sprintf("\"%s\" may have unexpected results (see the User's Guide)", (const char *) g_ptr_array_index(depr, 0))); } else { setSyntaxState(Valid); } dfilter_free(dfp); } else { setSyntaxState(Invalid); QString invalidMsg(tr("Invalid filter")); if (dfilter_error_msg) { invalidMsg.append(QString().sprintf(": %s", dfilter_error_msg)); } emit pushFilterSyntaxStatus(invalidMsg); } bookmark_button_->setEnabled(syntaxState() == Valid || syntaxState() == Deprecated); if (apply_button_) { apply_button_->setEnabled(SyntaxState() != Invalid); } }
void FilterExpressionsPreferencesFrame::expressionTextChanged(QString) { SyntaxLineEdit *syntax_edit = qobject_cast<SyntaxLineEdit *>(cur_line_edit_); QTreeWidgetItem *item = ui->expressionTreeWidget->currentItem(); if (!syntax_edit || !item) return; dfilter_t *dfp = NULL; const char *field_text = syntax_edit->text().toUtf8().constData(); if (strlen(field_text) < 1) { syntax_edit->setSyntaxState(SyntaxLineEdit::Empty); } else if (proto_check_field_name(field_text) != 0 || !dfilter_compile(field_text, &dfp)) { syntax_edit->setSyntaxState(SyntaxLineEdit::Invalid); } else { syntax_edit->setSyntaxState(SyntaxLineEdit::Valid); } dfilter_free(dfp); }
static const gchar* check_field_name(lua_State* L, const int abbr_idx, const enum ftenum type) { const gchar* abbr = luaL_checkstring(L,abbr_idx); const header_field_info* hfinfo = NULL; if (!abbr[0]) { luaL_argerror(L, abbr_idx, "Empty field name abbreviation"); return NULL; } if (proto_check_field_name(abbr)) { luaL_argerror(L, abbr_idx, "Invalid char in abbrev"); return NULL; } hfinfo = proto_registrar_get_byname(abbr); if (hfinfo && !ftype_similar_types(type, hfinfo->type)) { luaL_argerror(L, abbr_idx, "A field of an incompatible ftype with this abbrev already exists"); return NULL; } return abbr; }
void SyntaxLineEdit::checkCustomColumn(QString fields) { if (fields.isEmpty()) { setSyntaxState(SyntaxLineEdit::Empty); return; } gchar **splitted_fields = g_regex_split_simple(COL_CUSTOM_PRIME_REGEX, fields.toUtf8().constData(), G_REGEX_ANCHORED, G_REGEX_MATCH_ANCHORED); for (guint i = 0; i < g_strv_length(splitted_fields); i++) { if (splitted_fields[i] && *splitted_fields[i]) { if (proto_check_field_name(splitted_fields[i]) != 0) { setSyntaxState(SyntaxLineEdit::Invalid); g_strfreev(splitted_fields); return; } } } g_strfreev(splitted_fields); checkDisplayFilter(fields); }