2001-04-01 03:18:41 +00:00
|
|
|
/* value_string.c
|
|
|
|
* Routines for value_strings
|
|
|
|
*
|
2004-07-18 00:24:25 +00:00
|
|
|
* $Id$
|
2001-04-01 03:18:41 +00:00
|
|
|
*
|
2006-05-21 05:12:17 +00:00
|
|
|
* Wireshark - Network traffic analyzer
|
|
|
|
* By Gerald Combs <gerald@wireshark.org>
|
2001-04-01 03:18:41 +00:00
|
|
|
* Copyright 1998 Gerald Combs
|
|
|
|
*
|
|
|
|
* This program is free software; you can redistribute it and/or
|
|
|
|
* modify it under the terms of the GNU General Public License
|
|
|
|
* as published by the Free Software Foundation; either version 2
|
|
|
|
* of the License, or (at your option) any later version.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2001-04-01 03:18:41 +00:00
|
|
|
* This program is distributed in the hope that it will be useful,
|
|
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
|
|
* GNU General Public License for more details.
|
2002-08-28 20:41:00 +00:00
|
|
|
*
|
2001-04-01 03:18:41 +00:00
|
|
|
* You should have received a copy of the GNU General Public License
|
|
|
|
* along with this program; if not, write to the Free Software
|
|
|
|
* Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
*/
|
|
|
|
|
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
# include "config.h"
|
|
|
|
#endif
|
|
|
|
|
|
|
|
#include <stdio.h>
|
|
|
|
|
|
|
|
#include "to_str.h"
|
2005-08-17 09:28:24 +00:00
|
|
|
#include "emem.h"
|
2001-04-01 03:18:41 +00:00
|
|
|
#include "value_string.h"
|
2009-05-26 00:49:38 +00:00
|
|
|
#include <string.h>
|
2001-04-01 03:18:41 +00:00
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
/* --------------------------------------------------------------------*/
|
2001-04-01 03:18:41 +00:00
|
|
|
/* Tries to match val against each element in the value_string array vs.
|
|
|
|
Returns the associated string ptr on a match.
|
|
|
|
Formats val with fmt, and returns the resulting string, on failure. */
|
2005-06-26 19:56:52 +00:00
|
|
|
const gchar*
|
2010-04-03 18:18:50 +00:00
|
|
|
val_to_str(const guint32 val, const value_string *vs, const char *fmt) {
|
2005-06-26 19:56:52 +00:00
|
|
|
const gchar *ret;
|
2001-04-01 03:18:41 +00:00
|
|
|
|
2005-04-18 16:16:57 +00:00
|
|
|
g_assert(fmt != NULL);
|
|
|
|
|
2001-04-01 03:18:41 +00:00
|
|
|
ret = match_strval(val, vs);
|
|
|
|
if (ret != NULL)
|
|
|
|
return ret;
|
2005-06-26 11:40:26 +00:00
|
|
|
|
2005-09-15 08:55:43 +00:00
|
|
|
return ep_strdup_printf(fmt, val);
|
2001-04-01 03:18:41 +00:00
|
|
|
}
|
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
/* --------------------------------------------------------------------*/
|
2009-09-06 04:26:50 +00:00
|
|
|
/* Tries to match val against each element in the value_string array vs.
|
|
|
|
Returns the associated string ptr on a match.
|
|
|
|
Returns 'unknown_str', on failure. */
|
|
|
|
const gchar*
|
2010-04-03 18:18:50 +00:00
|
|
|
val_to_str_const(const guint32 val, const value_string *vs, const char *unknown_str) {
|
2009-09-06 04:26:50 +00:00
|
|
|
const gchar *ret;
|
|
|
|
|
|
|
|
g_assert(unknown_str != NULL);
|
|
|
|
|
|
|
|
ret = match_strval(val, vs);
|
|
|
|
if (ret != NULL)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return unknown_str;
|
|
|
|
}
|
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
/* --------------------------------------------------------------------*/
|
2001-04-01 03:18:41 +00:00
|
|
|
/* Tries to match val against each element in the value_string array vs.
|
2005-06-26 19:56:52 +00:00
|
|
|
Returns the associated string ptr, and sets "*idx" to the index in
|
|
|
|
that table, on a match, and returns NULL, and sets "*idx" to -1,
|
|
|
|
on failure. */
|
|
|
|
const gchar*
|
2010-04-03 18:18:50 +00:00
|
|
|
match_strval_idx(const guint32 val, const value_string *vs, gint *idx) {
|
2001-04-01 03:18:41 +00:00
|
|
|
gint i = 0;
|
2002-08-28 20:41:00 +00:00
|
|
|
|
2007-10-11 19:40:58 +00:00
|
|
|
if(vs) {
|
|
|
|
while (vs[i].strptr) {
|
|
|
|
if (vs[i].value == val) {
|
|
|
|
*idx = i;
|
|
|
|
return(vs[i].strptr);
|
|
|
|
}
|
|
|
|
i++;
|
2005-06-26 19:56:52 +00:00
|
|
|
}
|
2001-04-01 03:18:41 +00:00
|
|
|
}
|
|
|
|
|
2005-06-26 19:56:52 +00:00
|
|
|
*idx = -1;
|
2007-10-11 19:40:58 +00:00
|
|
|
return NULL;
|
2001-04-01 03:18:41 +00:00
|
|
|
}
|
|
|
|
|
2005-06-26 19:56:52 +00:00
|
|
|
/* Like match_strval_idx(), but doesn't return the index. */
|
|
|
|
const gchar*
|
2010-04-03 18:18:50 +00:00
|
|
|
match_strval(const guint32 val, const value_string *vs) {
|
2005-06-26 19:56:52 +00:00
|
|
|
gint ignore_me;
|
|
|
|
return match_strval_idx(val, vs, &ignore_me);
|
|
|
|
}
|
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
/* --------------------------------------------------------------------*/
|
|
|
|
/* value_string_ext functions
|
|
|
|
*
|
|
|
|
* Extended value strings allow fast(er) value_string array lookups by
|
|
|
|
* using (if possible) direct access or a binary search of the array.
|
|
|
|
*
|
|
|
|
* If the values in the value_string array are a contiguous range of values
|
|
|
|
* from min to max, the value will be used as as a direct index into the array.
|
|
|
|
*
|
|
|
|
* If the values in the array are not contiguous (ie: there are "gaps"),
|
|
|
|
* but are in assending order a binary search will be used.
|
|
|
|
*
|
|
|
|
* If direct access or binary search cannot be used, then a linear search
|
|
|
|
* is used.
|
|
|
|
*
|
|
|
|
* Note that the value_string array used with VALUE_STRING_EXT_INIT
|
|
|
|
* *must* be terminated with {0, NULL}).
|
|
|
|
*
|
|
|
|
* Extended value strings are defined at compile time as follows:
|
|
|
|
* static const value_string vs[] = { {value1, "string1"}, {value2, "string2"}, ..., {0, NULL}};
|
|
|
|
* static value_string_ext vse = VALUE_STRING_EXT_INIT(vs);
|
|
|
|
*
|
|
|
|
* Extended value strings can be created at runtime by calling
|
|
|
|
* value_string_ext_new(<ptr to value_string array>,
|
|
|
|
* <total number of entries in the value_string_array>,
|
|
|
|
* <value_string_name>);
|
|
|
|
* Note: <total number of entries in the value_string_array> should include the {0, NULL} entry
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
|
|
|
|
/* --------------------------------------------------------------------*/
|
|
|
|
|
|
|
|
/* Create a value_string_ext given a ptr to a value_string array and the total number of entries. */
|
|
|
|
/* Note: The total number of entries should include the required {0, NULL} terminating entry of the array. */
|
|
|
|
/* Return: a pointer to a gmalloc'd and initialized value_string_ext struct. */
|
|
|
|
value_string_ext *
|
|
|
|
value_string_ext_new(value_string *vs, guint vs_tot_num_entries, gchar *vs_name) {
|
|
|
|
value_string_ext *vse;
|
|
|
|
g_assert (vs_name != NULL);
|
|
|
|
g_assert (vs_tot_num_entries > 0);
|
|
|
|
g_assert (vs[vs_tot_num_entries-1].strptr == NULL); /* Null-terminated value-string ? */
|
|
|
|
vse = g_malloc(sizeof (value_string_ext));
|
|
|
|
vse->_vs_p = vs;
|
|
|
|
vse->_vs_num_entries = vs_tot_num_entries - 1; /* remember the actual number of entries */
|
|
|
|
vse->_vs_first_value = 0; /* initialized in _match_strval_ext_init */
|
2011-04-28 11:15:46 +00:00
|
|
|
vse->_vs_match2 = _match_strval_ext_init;
|
2010-10-14 17:50:35 +00:00
|
|
|
vse->_vs_name = vs_name;
|
|
|
|
return vse;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Looks up val in a value_string array using access method (direct, binary search
|
|
|
|
* or linear) determined at rutime during the initial access); (see _match_strval_ext_init)
|
|
|
|
* Returns the associated string ptr on a match, and returns NULL on failure.
|
|
|
|
*/
|
|
|
|
const gchar*
|
|
|
|
match_strval_ext(const guint32 val, const value_string_ext *vse) {
|
2011-04-28 11:15:46 +00:00
|
|
|
if (vse) {
|
|
|
|
const value_string *vs = vse->_vs_match2(val, vse);
|
|
|
|
if (vs)
|
|
|
|
return vs->strptr;
|
|
|
|
}
|
2010-10-14 17:50:35 +00:00
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2011-01-10 14:31:33 +00:00
|
|
|
/* Tries to match val against each element in the value_string array vs.
|
|
|
|
* Returns the associated string ptr, and sets "*idx" to the index in
|
|
|
|
* that table, on a match, and returns NULL, and sets "*idx" to -1,
|
|
|
|
* on failure.
|
|
|
|
*/
|
|
|
|
|
|
|
|
const gchar*
|
|
|
|
match_strval_idx_ext(const guint32 val, value_string_ext *vse, gint *idx) {
|
2011-04-28 11:15:46 +00:00
|
|
|
if (vse) {
|
|
|
|
const value_string *vs = vse->_vs_match2(val, vse);
|
|
|
|
if (vs) {
|
2011-04-28 11:53:29 +00:00
|
|
|
*idx = (gint) (vs - vse->_vs_p);
|
2011-04-28 11:15:46 +00:00
|
|
|
return vs->strptr;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*idx = -1;
|
|
|
|
return NULL;
|
2011-01-10 14:31:33 +00:00
|
|
|
}
|
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
/* Similar to match_strval_ext except that on failure
|
|
|
|
* Formats val with fmt, and returns the resulting string
|
|
|
|
*/
|
|
|
|
const gchar*
|
|
|
|
val_to_str_ext(const guint32 val, const value_string_ext *vse, const char *fmt) {
|
|
|
|
const gchar *ret;
|
|
|
|
|
|
|
|
g_assert(fmt != NULL);
|
|
|
|
|
|
|
|
ret = match_strval_ext(val, vse);
|
|
|
|
if (ret != NULL)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return ep_strdup_printf(fmt, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Similar to match_strval_ext except that on failure
|
|
|
|
* Returns 'unknown_str'
|
|
|
|
*/
|
|
|
|
const gchar*
|
|
|
|
val_to_str_ext_const(const guint32 val, const value_string_ext *vse, const char *unknown_str) {
|
|
|
|
const gchar *ret;
|
|
|
|
|
|
|
|
g_assert(unknown_str != NULL);
|
|
|
|
|
|
|
|
ret = match_strval_ext(val, vse);
|
|
|
|
if (ret != NULL)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return unknown_str;
|
|
|
|
}
|
|
|
|
|
2011-04-28 11:15:46 +00:00
|
|
|
static const value_string *
|
|
|
|
_match_strval_linear(const guint32 val, const value_string_ext *vse)
|
2010-04-27 12:38:49 +00:00
|
|
|
{
|
2010-10-14 17:50:35 +00:00
|
|
|
const value_string *vs_p = vse->_vs_p;
|
|
|
|
guint i;
|
|
|
|
for (i=0; i<vse->_vs_num_entries; i++) {
|
2011-04-28 11:15:46 +00:00
|
|
|
if (vs_p[i].value == val)
|
|
|
|
return &(vs_p[i]);
|
2010-10-14 17:50:35 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
2010-04-27 12:38:49 +00:00
|
|
|
}
|
|
|
|
|
2011-04-28 11:15:46 +00:00
|
|
|
static const value_string *
|
|
|
|
_match_strval_index(const guint32 val, const value_string_ext *vse)
|
2010-04-27 12:38:49 +00:00
|
|
|
{
|
2011-01-10 14:31:33 +00:00
|
|
|
guint i;
|
|
|
|
|
|
|
|
i = val - vse->_vs_first_value;
|
|
|
|
if (i < vse->_vs_num_entries) {
|
|
|
|
g_assert (val == vse->_vs_p[i].value);
|
2011-04-28 11:15:46 +00:00
|
|
|
return &(vse->_vs_p[i]);
|
2010-10-14 17:50:35 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
2010-04-27 12:38:49 +00:00
|
|
|
}
|
|
|
|
|
2011-04-28 11:15:46 +00:00
|
|
|
static const value_string *
|
|
|
|
_match_strval_bsearch(const guint32 val, const value_string_ext *vse)
|
2010-04-27 12:38:49 +00:00
|
|
|
{
|
2011-01-10 14:31:33 +00:00
|
|
|
guint low, i, max;
|
2010-04-27 10:32:34 +00:00
|
|
|
guint32 item;
|
2010-04-27 12:38:49 +00:00
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
for (low = 0, max = vse->_vs_num_entries; low < max; ) {
|
2011-01-10 14:31:33 +00:00
|
|
|
i = (low + max) / 2;
|
|
|
|
item = vse->_vs_p[i].value;
|
2010-04-27 12:38:49 +00:00
|
|
|
|
|
|
|
if (val < item)
|
2011-01-10 14:31:33 +00:00
|
|
|
max = i;
|
2010-04-27 12:38:49 +00:00
|
|
|
else if (val > item)
|
2011-01-10 14:31:33 +00:00
|
|
|
low = i + 1;
|
2011-04-28 11:15:46 +00:00
|
|
|
else
|
|
|
|
return &(vse->_vs_p[i]);
|
2010-04-27 12:38:49 +00:00
|
|
|
}
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
/* Init value_string_ext struct
|
|
|
|
- Go thru the value_string array to determine whether indexed access
|
|
|
|
or binary search access is possible;
|
|
|
|
- Verify that the value_string array does not contain any
|
|
|
|
NULL string pointers;
|
|
|
|
- Verify that the value_string array is terminated
|
|
|
|
by {0, NULL};
|
|
|
|
*/
|
2011-04-28 11:15:46 +00:00
|
|
|
const value_string *
|
|
|
|
_match_strval_ext_init(const guint32 val, const value_string_ext *a_vse)
|
2010-04-27 12:38:49 +00:00
|
|
|
{
|
2011-01-12 17:20:52 +00:00
|
|
|
/* Cast away the constness!
|
|
|
|
* It's better if the prototype for this function matches the other
|
|
|
|
* _match_strval_* functions (so we don't have to cast it when storing it
|
|
|
|
* in _match_strval so the compiler will notice if the prototypes get out
|
|
|
|
* of sync), but the init function is unique in that it does actually
|
|
|
|
* modify the vse.
|
|
|
|
*/
|
|
|
|
value_string_ext *vse = (value_string_ext *)a_vse;
|
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
const value_string *vs_p = vse->_vs_p;
|
|
|
|
const guint vs_num_entries = vse->_vs_num_entries;
|
2010-04-27 12:38:49 +00:00
|
|
|
|
|
|
|
/* The way matching of value is done in a value_string:
|
2010-09-17 04:51:21 +00:00
|
|
|
* 0 Sequential search (as in a normal value string)
|
|
|
|
* 1 Binary search, the values MUST be in numerical order.
|
2010-10-14 17:50:35 +00:00
|
|
|
* 2 The value used as an index(the value string MUST have all values between first and last defined in numerical order)
|
2010-04-27 12:38:49 +00:00
|
|
|
*/
|
2010-09-17 04:51:21 +00:00
|
|
|
enum { VS_SEARCH = 0, VS_BIN_TREE, VS_INDEX } type = VS_INDEX;
|
2010-04-27 12:38:49 +00:00
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
guint32 prev_value;
|
|
|
|
guint first_value;
|
|
|
|
guint i;
|
2010-04-27 12:38:49 +00:00
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
g_assert((vs_p[vs_num_entries].value==0) && (vs_p[vs_num_entries].strptr==NULL));
|
2010-04-27 12:38:49 +00:00
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
vse->_vs_first_value = vs_p[0].value;
|
|
|
|
first_value = vs_p[0].value;
|
|
|
|
prev_value = first_value;
|
|
|
|
|
|
|
|
for (i = 0; i < vs_num_entries; i++) {
|
|
|
|
g_assert(vs_p[i].strptr != NULL);
|
|
|
|
if ((type == VS_INDEX) && (vs_p[i].value != (i + first_value))) {
|
|
|
|
type = VS_BIN_TREE;
|
|
|
|
}
|
2010-10-29 22:01:29 +00:00
|
|
|
/* XXX: Should check for dups ?? */
|
2010-10-14 17:50:35 +00:00
|
|
|
if ((type == VS_BIN_TREE) && (prev_value > vs_p[i].value)) {
|
2010-04-27 12:38:49 +00:00
|
|
|
type = VS_SEARCH;
|
2010-04-27 10:32:34 +00:00
|
|
|
break;
|
|
|
|
}
|
2010-04-27 12:38:49 +00:00
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
prev_value = vs_p[i].value;
|
2010-04-27 10:32:34 +00:00
|
|
|
}
|
2010-10-14 17:50:35 +00:00
|
|
|
|
2010-04-27 12:38:49 +00:00
|
|
|
switch (type) {
|
|
|
|
case VS_SEARCH:
|
2011-04-28 11:15:46 +00:00
|
|
|
vse->_vs_match2 = _match_strval_linear;
|
2010-04-27 12:38:49 +00:00
|
|
|
break;
|
|
|
|
case VS_BIN_TREE:
|
2011-04-28 11:15:46 +00:00
|
|
|
vse->_vs_match2 = _match_strval_bsearch;
|
2010-10-14 17:50:35 +00:00
|
|
|
break;
|
|
|
|
case VS_INDEX:
|
2011-04-28 11:15:46 +00:00
|
|
|
vse->_vs_match2 = _match_strval_index;
|
2010-04-27 12:38:49 +00:00
|
|
|
break;
|
|
|
|
default:
|
|
|
|
g_assert_not_reached();
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-04-28 11:15:46 +00:00
|
|
|
return vse->_vs_match2(val, vse);
|
2010-04-27 12:38:49 +00:00
|
|
|
}
|
2010-11-12 19:48:30 +00:00
|
|
|
|
2010-11-14 16:30:56 +00:00
|
|
|
/* (Fcns for use by proto_registrar_dump_values() [See proto.c]) */
|
|
|
|
gboolean
|
2011-04-28 11:15:46 +00:00
|
|
|
value_string_ext_validate(const value_string_ext *vse) {
|
2010-11-14 16:30:56 +00:00
|
|
|
if (vse == NULL)
|
|
|
|
return FALSE;
|
2011-04-28 11:15:46 +00:00
|
|
|
if ((vse->_vs_match2 == _match_strval_ext_init) ||
|
|
|
|
(vse->_vs_match2 == _match_strval_linear) ||
|
|
|
|
(vse->_vs_match2 == _match_strval_bsearch) ||
|
|
|
|
(vse->_vs_match2 == _match_strval_index))
|
2010-11-14 16:30:56 +00:00
|
|
|
return TRUE;
|
|
|
|
return FALSE;
|
|
|
|
}
|
|
|
|
|
2011-04-28 11:15:46 +00:00
|
|
|
const gchar *
|
|
|
|
value_string_ext_match_type_str(const value_string_ext *vse) {
|
|
|
|
if (vse->_vs_match2 == _match_strval_linear)
|
2010-11-12 19:48:30 +00:00
|
|
|
return "[Linear Search]";
|
2011-04-28 11:15:46 +00:00
|
|
|
if (vse->_vs_match2 == _match_strval_bsearch)
|
2010-11-12 19:48:30 +00:00
|
|
|
return "[Binary Search]";
|
2011-04-28 11:15:46 +00:00
|
|
|
if (vse->_vs_match2 == _match_strval_index)
|
2010-11-12 19:48:30 +00:00
|
|
|
return "[Direct (indexed) Access]";
|
2010-11-14 16:30:56 +00:00
|
|
|
return "[Match Type not initialized or invalid]";
|
2010-11-12 19:48:30 +00:00
|
|
|
}
|
|
|
|
|
2010-10-14 17:50:35 +00:00
|
|
|
/* ----------- */
|
2010-04-27 10:32:34 +00:00
|
|
|
|
2009-05-26 00:49:38 +00:00
|
|
|
/* Tries to match val against each element in the value_string array vs.
|
|
|
|
Returns the associated string ptr on a match.
|
|
|
|
Formats val with fmt, and returns the resulting string, on failure. */
|
|
|
|
const gchar*
|
|
|
|
str_to_str(const gchar *val, const string_string *vs, const char *fmt) {
|
|
|
|
const gchar *ret;
|
|
|
|
|
|
|
|
g_assert(fmt != NULL);
|
|
|
|
|
|
|
|
ret = match_strstr(val, vs);
|
|
|
|
if (ret != NULL)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return ep_strdup_printf(fmt, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tries to match val against each element in the value_string array vs.
|
|
|
|
Returns the associated string ptr, and sets "*idx" to the index in
|
|
|
|
that table, on a match, and returns NULL, and sets "*idx" to -1,
|
|
|
|
on failure. */
|
|
|
|
const gchar*
|
|
|
|
match_strstr_idx(const gchar *val, const string_string *vs, gint *idx) {
|
|
|
|
gint i = 0;
|
|
|
|
|
|
|
|
if(vs) {
|
|
|
|
while (vs[i].strptr) {
|
|
|
|
if (!strcmp(vs[i].value,val)) {
|
|
|
|
*idx = i;
|
|
|
|
return(vs[i].strptr);
|
|
|
|
}
|
|
|
|
i++;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*idx = -1;
|
|
|
|
return NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Like match_strval_idx(), but doesn't return the index. */
|
|
|
|
const gchar*
|
|
|
|
match_strstr(const gchar *val, const string_string *vs) {
|
|
|
|
gint ignore_me;
|
|
|
|
return match_strstr_idx(val, vs, &ignore_me);
|
|
|
|
}
|
|
|
|
|
2001-04-01 03:18:41 +00:00
|
|
|
/* Generate a string describing an enumerated bitfield (an N-bit field
|
|
|
|
with various specific values having particular names). */
|
|
|
|
const char *
|
2010-04-03 18:18:50 +00:00
|
|
|
decode_enumerated_bitfield(const guint32 val, const guint32 mask, const int width,
|
2001-04-01 03:18:41 +00:00
|
|
|
const value_string *tab, const char *fmt)
|
|
|
|
{
|
|
|
|
static char buf[1025];
|
|
|
|
char *p;
|
|
|
|
|
|
|
|
p = decode_bitfield_value(buf, val, mask, width);
|
2009-04-08 17:31:12 +00:00
|
|
|
g_snprintf(p, (gulong) (1024-(p-buf)), fmt, val_to_str(val & mask, tab, "Unknown"));
|
2001-04-01 03:18:41 +00:00
|
|
|
return buf;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2003-12-01 23:42:32 +00:00
|
|
|
/* Generate a string describing an enumerated bitfield (an N-bit field
|
|
|
|
with various specific values having particular names). */
|
|
|
|
const char *
|
2010-04-03 18:18:50 +00:00
|
|
|
decode_enumerated_bitfield_shifted(const guint32 val, const guint32 mask, const int width,
|
2003-12-01 23:42:32 +00:00
|
|
|
const value_string *tab, const char *fmt)
|
|
|
|
{
|
|
|
|
static char buf[1025];
|
|
|
|
char *p;
|
|
|
|
int shift = 0;
|
|
|
|
|
|
|
|
/* Compute the number of bits we have to shift the bitfield right
|
|
|
|
to extract its value. */
|
|
|
|
while ((mask & (1<<shift)) == 0)
|
|
|
|
shift++;
|
|
|
|
|
|
|
|
p = decode_bitfield_value(buf, val, mask, width);
|
2009-04-08 17:31:12 +00:00
|
|
|
g_snprintf(p, (gulong) (1024-(p-buf)), fmt, val_to_str((val & mask) >> shift, tab, "Unknown"));
|
2003-12-01 23:42:32 +00:00
|
|
|
return buf;
|
|
|
|
}
|
2006-12-07 20:29:40 +00:00
|
|
|
|
|
|
|
|
|
|
|
/* FF: ranges aware versions */
|
|
|
|
|
|
|
|
/* Tries to match val against each range in the range_string array rs.
|
|
|
|
Returns the associated string ptr on a match.
|
|
|
|
Formats val with fmt, and returns the resulting string, on failure. */
|
2011-01-12 17:20:52 +00:00
|
|
|
const gchar *rval_to_str(const guint32 val, const range_string *rs, const char *fmt)
|
2006-12-07 20:29:40 +00:00
|
|
|
{
|
|
|
|
const gchar *ret = NULL;
|
|
|
|
|
|
|
|
g_assert(fmt != NULL);
|
|
|
|
|
|
|
|
ret = match_strrval(val, rs);
|
|
|
|
if(ret != NULL)
|
|
|
|
return ret;
|
|
|
|
|
|
|
|
return ep_strdup_printf(fmt, val);
|
|
|
|
}
|
|
|
|
|
|
|
|
/* Tries to match val against each range in the range_string array rs.
|
|
|
|
Returns the associated string ptr, and sets "*idx" to the index in
|
|
|
|
that table, on a match, and returns NULL, and sets "*idx" to -1,
|
|
|
|
on failure. */
|
2010-04-03 18:18:50 +00:00
|
|
|
const gchar *match_strrval_idx(const guint32 val, const range_string *rs, gint *idx)
|
2006-12-07 20:29:40 +00:00
|
|
|
{
|
|
|
|
gint i = 0;
|
|
|
|
|
2007-10-11 19:40:58 +00:00
|
|
|
if(rs) {
|
|
|
|
while(rs[i].strptr) {
|
|
|
|
if( (val >= rs[i].value_min) && (val <= rs[i].value_max) ) {
|
|
|
|
*idx = i;
|
|
|
|
return (rs[i].strptr);
|
|
|
|
}
|
|
|
|
i++;
|
2006-12-07 20:29:40 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
*idx = -1;
|
2007-10-11 19:40:58 +00:00
|
|
|
return NULL;
|
2006-12-07 20:29:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/* Like match_strrval_idx(), but doesn't return the index. */
|
2010-04-03 18:18:50 +00:00
|
|
|
const gchar *match_strrval(const guint32 val, const range_string *rs)
|
2006-12-07 20:29:40 +00:00
|
|
|
{
|
|
|
|
gint ignore_me = 0;
|
|
|
|
return match_strrval_idx(val, rs, &ignore_me);
|
|
|
|
}
|
|
|
|
|