osmocom
/
wireshark
11
0
Fork 1
Code Issues Pull Requests Projects Releases Wiki Activity

rename some structures and defines from the se_tree to the emem_tree prefix 

svn path=/trunk/; revision=18894
This commit is contained in:
Ronnie Sahlberg 2006-08-14 08:29:29 +00:00
parent c6c15e8b6b
commit 8ce8e719e0
22 changed files with 208 additions and 206 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

24
asn1/h248/packet-h248-template.c
View File

@ -150,10 +150,10 @@ static GHashTable* h248_wild_terms = NULL;
static dissector_table_t h248_package_bin_dissector_table=NULL;
#endif
static se_tree_t* msgs = NULL;
static se_tree_t* trxs = NULL;
static se_tree_t* ctxs_by_trx = NULL;
static se_tree_t* ctxs = NULL;
static emem_tree_t* msgs = NULL;
static emem_tree_t* trxs = NULL;
static emem_tree_t* ctxs_by_trx = NULL;
static emem_tree_t* ctxs = NULL;
static gboolean h248_prefs_initialized = FALSE;
static gboolean keep_persistent_data = FALSE;
@ -1150,7 +1150,7 @@ static h248_msg_t* h248_msg(packet_info* pinfo, int o) {
if (keep_persistent_data) {
se_tree_key_t key[] = {
emem_tree_key_t key[] = {
{1,NULL},
{1,NULL},
{0,NULL},
@ -1226,7 +1226,7 @@ static h248_trx_t* h248_trx(h248_msg_t* m ,guint32 t_id , h248_trx_type_t type)
DISSECTOR_ASSERT(! "a trx that should exist does not!" );
} else {
se_tree_key_t key[] = {
emem_tree_key_t key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
@ -1294,14 +1294,14 @@ static h248_ctx_t* h248_ctx(h248_msg_t* m, h248_trx_t* t, guint32 c_id) {
if ( !m || !t ) return NULL;
if (keep_persistent_data) {
se_tree_key_t ctx_key[] = {
emem_tree_key_t ctx_key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
{0,NULL}
};
se_tree_key_t trx_key[] = {
emem_tree_key_t trx_key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
@ -2131,10 +2131,10 @@ void proto_register_h248(void) {
register_init_routine( &h248_init );
msgs = se_tree_create(SE_TREE_TYPE_RED_BLACK, "h248_msgs");
trxs = se_tree_create(SE_TREE_TYPE_RED_BLACK, "h248_trxs");
ctxs_by_trx = se_tree_create(SE_TREE_TYPE_RED_BLACK, "h248_ctxs_by_trx");
ctxs = se_tree_create(SE_TREE_TYPE_RED_BLACK, "h248_ctxs");
msgs = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "h248_msgs");
trxs = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "h248_trxs");
ctxs_by_trx = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "h248_ctxs_by_trx");
ctxs = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "h248_ctxs");
}

30
doc/README.binarytrees
View File

@ -27,9 +27,9 @@ Please see README.malloc for a description of EmPhereal and SEasonal storage.
2. Basic Usage
For most users it will be sufficiant to only know and use three functions
se_tree_t *se_tree_create(int type, char *name);
void se_tree_insert32(se_tree_t *se_tree, guint32 key, void *data);
void *se_tree_lookup32(se_tree_t *se_tree, guint32 key);
emem_tree_t *se_tree_create(int type, char *name);
void se_tree_insert32(emem_tree_t *se_tree, guint32 key, void *data);
void *se_tree_lookup32(emem_tree_t *se_tree, guint32 key);
2.1 se_tree_create(int type, char *name);
@ -49,11 +49,11 @@ proto_register_<yourprotocol>() function.
Example (from packet-tcp.c):
#include <epan/emem.h>
...
static se_tree_t *tcp_pdu_time_table = NULL;
static emem_tree_t *tcp_pdu_time_table = NULL;
...
void proto_register_...(void) {
...
tcp_pdu_time_table=se_tree_create(SE_TREE_TYPE_RED_BLACK, "PROTO_my_tree");
tcp_pdu_time_table=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "PROTO_my_tree");
...
}
@ -63,7 +63,7 @@ Everytime a new capture is loaded, all nodes allocated to the tree is
automatically and the tree is reset without you having to do anything at all.
2.2 se_tree_insert32(se_tree_t *se_tree, guint32 key, void *data);
2.2 se_tree_insert32(emem_tree_t *se_tree, guint32 key, void *data);
This function is used to add a new node into the tree.
This function is used for such trees where you always use a guint32 as the
identifier/key for the node. Most trees you want to use are likely in this
@ -110,7 +110,7 @@ If you dont think you should not use the if statement to protect the insert
please reconsider and think it through one extra time.
2.3 se_tree_lookup32(se_tree_t *se_tree, guint32 key);
2.3 se_tree_lookup32(emem_tree_t *se_tree, guint32 key);
This function is used to read back from the tree the data value that is
associated with this key.
If no such node was found the function will return NULL.
@ -154,12 +154,12 @@ In that case, this is the function you want.
3.2 se_tree_insert32_array / se_tree_lookup32_array
typedef struct _se_tree_key_t {
typedef struct _emem_tree_key_t {
guint32 length; /*length in guint32 words */
guint32 *key;
} se_tree_key_t;
void se_tree_insert32_array(se_tree_t *se_tree, se_tree_key_t *key, void *data);
void *se_tree_lookup32_array(se_tree_t *se_tree, se_tree_key_t *key);
} emem_tree_key_t;
void se_tree_insert32_array(emem_tree_t *se_tree, emem_tree_key_t *key, void *data);
void *se_tree_lookup32_array(emem_tree_t *se_tree, emem_tree_key_t *key);
NOTE: the *key parameter taken by these functions WILL be modified by
these functions so if you want to reuse the key for a second call
@ -169,12 +169,12 @@ you will have to reinitialize key.
These functions are used to insert and lookup a tree where nodes are NOT
indexed by a single guint32 but more like an array of guint32 elements.
These functions take as key an array of guint32 vectors : se_tree_key_t.
These functions take as key an array of guint32 vectors : emem_tree_key_t.
The fucntions will use vector by vector to search further down the tree
until an array element where length==0 is found indicating the end of the
array.
NOTE: you MUST terminate the se_tree_key_t array by {0, NULL}
NOTE: you MUST terminate the emem_tree_key_t array by {0, NULL}
If you forget to do this wireshark will immediately crash.
NOTE: length indicates the number of guint32 values in the vector, not number
@ -183,7 +183,7 @@ of bytes.
If your keys are always of exactly the same length, always, and you are willing
to bet that there can never ever be a key of a different length you can
get away with a simple :
se_tree_key_t key[2];
emem_tree_key_t key[2];
key[0].length= LEN;
key[0].key= KEY;
key[1].length=0;
@ -199,7 +199,7 @@ Specify the first index as 1 guint32 holding the total number of guints in the
rest of the key.
See NFS that does this to handle filehandes that may be of different lengths
in the same tree :
se_tree_key_t fhkey[3];
emem_tree_key_t fhkey[3];
guint32 tmplen;
tmplen = <length of filehandle/4>;

4
doc/README.request_response_tracking
View File

@ -66,7 +66,7 @@ this would be a good place to store that additional info you may want to keep
around.
typedef struct _pana_conv_info_t {
se_tree_t *pdus;
emem_tree_t *pdus;
} pana_conv_info_t;
@ -112,7 +112,7 @@ actual dissector
* it to the list of information structures.
*/
pana_info = se_alloc(sizeof(pana_conv_info_t));
pana_info->pdus=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "pana_pdus");
pana_info->pdus=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "pana_pdus");
conversation_add_proto_data(conversation, proto_pana, pana_info);
}

12
epan/dissectors/packet-alcap.c
View File

@ -404,9 +404,9 @@ static int hf_alcap_leg_release_cause = -1;
static gboolean keep_persistent_info = TRUE;
se_tree_t* legs_by_dsaid = NULL;
se_tree_t* legs_by_osaid = NULL;
se_tree_t* legs_by_bearer = NULL;
emem_tree_t* legs_by_dsaid = NULL;
emem_tree_t* legs_by_osaid = NULL;
emem_tree_t* legs_by_bearer = NULL;
static gchar* dissect_fields_unknown(packet_info* pinfo _U_, tvbuff_t *tvb, proto_tree *tree, int offset, int len, alcap_message_info_t* msg_info _U_) {
proto_item* pi = proto_tree_add_item(tree,hf_alcap_unknown,tvb,offset,len,FALSE);
@ -1788,9 +1788,9 @@ proto_register_alcap(void)
"Whether persistent call leg information is to be kept",
&keep_persistent_info);
legs_by_dsaid = se_tree_create(SE_TREE_TYPE_RED_BLACK, "legs_by_dsaid");
legs_by_osaid = se_tree_create(SE_TREE_TYPE_RED_BLACK, "legs_by_osaid");
legs_by_bearer = se_tree_create(SE_TREE_TYPE_RED_BLACK, "legs_by_bearer");
legs_by_dsaid = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "legs_by_dsaid");
legs_by_osaid = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "legs_by_osaid");
legs_by_bearer = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "legs_by_bearer");
}

8
epan/dissectors/packet-bthci_acl.c
View File

@ -67,10 +67,10 @@ typedef struct _multi_fragment_pdu_t {
} multi_fragment_pdu_t;
typedef struct _chandle_data_t {
se_tree_t *start_fragments; /* indexed by pinfo->fd->num */
emem_tree_t *start_fragments; /* indexed by pinfo->fd->num */
} chandle_data_t;
static se_tree_t *chandle_tree=NULL;
static emem_tree_t *chandle_tree=NULL;
static const value_string pb_flag_vals[] = {
{1, "Continuing Fragment"},
@ -125,7 +125,7 @@ dissect_btacl(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
chandle_data=se_tree_lookup32(chandle_tree, acl_data->chandle);
if(!chandle_data){
chandle_data=se_alloc(sizeof(chandle_data_t));
chandle_data->start_fragments=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "bthci_acl fragment starts");
chandle_data->start_fragments=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "bthci_acl fragment starts");
se_tree_insert32(chandle_tree, acl_data->chandle, chandle_data);
}
@ -279,7 +279,7 @@ proto_register_btacl(void)
"Whether the ACL dissector should reassemble fragmented PDUs",
&acl_reassembly);
chandle_tree=se_tree_create(SE_TREE_TYPE_RED_BLACK, "bthci_acl chandles");
chandle_tree=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "bthci_acl chandles");
}

4
epan/dissectors/packet-btl2cap.c
View File

@ -87,7 +87,7 @@ dissector_table_t l2cap_psm_dissector_table;
* The same table is used both for SCID and DCID.
* For received CIDs we mask the cid with 0x8000 in this table
*/
static se_tree_t *cid_to_psm_table = NULL;
static emem_tree_t *cid_to_psm_table = NULL;
typedef struct _psm_data_t {
guint16 psm;
} psm_data_t;
@ -848,7 +848,7 @@ proto_register_btl2cap(void)
proto_register_field_array(proto_btl2cap, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
cid_to_psm_table=se_tree_create(SE_TREE_TYPE_RED_BLACK, "btl2cap scid to psm");
cid_to_psm_table=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "btl2cap scid to psm");
}

4
epan/dissectors/packet-btrfcomm.c
View File

@ -98,7 +98,7 @@ static gint ett_ctrl_pn_ci = -1;
static gint ett_ctrl_pn_v24 = -1;
static se_tree_t *dlci_table=NULL;
static emem_tree_t *dlci_table=NULL;
typedef struct _dlci_stream_t {
int len;
@ -991,7 +991,7 @@ proto_register_btrfcomm(void)
proto_register_field_array(proto_btrfcomm, hf, array_length(hf));
proto_register_subtree_array(ett, array_length(ett));
dlci_table=se_tree_create(SE_TREE_TYPE_RED_BLACK, "RFCOMM dlci table");
dlci_table=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "RFCOMM dlci table");
}

4
epan/dissectors/packet-fc.c
View File

@ -135,7 +135,7 @@ static dissector_handle_t data_handle;
static int fc_tap = -1;
typedef struct _fc_conv_data_t {
se_tree_t *exchanges;
emem_tree_t *exchanges;
} fc_conv_data_t;
@ -661,7 +661,7 @@ dissect_fc_helper (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean
fc_conv_data=conversation_get_proto_data(conversation, proto_fc);
if(!fc_conv_data){
fc_conv_data=se_alloc(sizeof(fc_conv_data_t));
fc_conv_data->exchanges=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "FC Exchanges");
fc_conv_data->exchanges=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "FC Exchanges");
conversation_add_proto_data(conversation, proto_fc, fc_conv_data);
}

4
epan/dissectors/packet-fcp.c
View File

@ -97,7 +97,7 @@ static gint ett_fcp_taskmgmt = -1;
static gint ett_fcp_rsp_flags = -1;
typedef struct _fcp_conv_data_t {
se_tree_t *luns;
emem_tree_t *luns;
} fcp_conv_data_t;
static dissector_table_t fcp_dissector;
@ -621,7 +621,7 @@ dissect_fcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
fcp_conv_data=conversation_get_proto_data(fchdr->conversation, proto_fcp);
if(!fcp_conv_data){
fcp_conv_data=se_alloc(sizeof(fcp_conv_data_t));
fcp_conv_data->luns=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "FCP Luns");
fcp_conv_data->luns=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "FCP Luns");
conversation_add_proto_data(fchdr->conversation, proto_fcp, fcp_conv_data);
}

26
epan/dissectors/packet-h248.c
View File

@ -1,6 +1,6 @@
/* Do not modify this file. */
/* It is created automatically by the ASN.1 to Wireshark dissector compiler */
/* .\packet-h248.c */
/* ./packet-h248.c */
/* ../../tools/asn2wrs.py -b -e -p h248 -c h248.cnf -s packet-h248-template MEGACO.asn */
/* Input file: packet-h248-template.c */
@ -556,10 +556,10 @@ static GHashTable* h248_wild_terms = NULL;
static dissector_table_t h248_package_bin_dissector_table=NULL;
#endif
static se_tree_t* msgs = NULL;
static se_tree_t* trxs = NULL;
static se_tree_t* ctxs_by_trx = NULL;
static se_tree_t* ctxs = NULL;
static emem_tree_t* msgs = NULL;
static emem_tree_t* trxs = NULL;
static emem_tree_t* ctxs_by_trx = NULL;
static emem_tree_t* ctxs = NULL;
static gboolean h248_prefs_initialized = FALSE;
static gboolean keep_persistent_data = FALSE;
@ -1556,7 +1556,7 @@ static h248_msg_t* h248_msg(packet_info* pinfo, int o) {
if (keep_persistent_data) {
se_tree_key_t key[] = {
emem_tree_key_t key[] = {
{1,NULL},
{1,NULL},
{0,NULL},
@ -1632,7 +1632,7 @@ static h248_trx_t* h248_trx(h248_msg_t* m ,guint32 t_id , h248_trx_type_t type)
DISSECTOR_ASSERT(! "a trx that should exist does not!" );
} else {
se_tree_key_t key[] = {
emem_tree_key_t key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
@ -1700,14 +1700,14 @@ static h248_ctx_t* h248_ctx(h248_msg_t* m, h248_trx_t* t, guint32 c_id) {
if ( !m || !t ) return NULL;
if (keep_persistent_data) {
se_tree_key_t ctx_key[] = {
emem_tree_key_t ctx_key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
{0,NULL}
};
se_tree_key_t trx_key[] = {
emem_tree_key_t trx_key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
@ -7335,10 +7335,10 @@ void proto_register_h248(void) {
register_init_routine( &h248_init );
msgs = se_tree_create(SE_TREE_TYPE_RED_BLACK, "h248_msgs");
trxs = se_tree_create(SE_TREE_TYPE_RED_BLACK, "h248_trxs");
ctxs_by_trx = se_tree_create(SE_TREE_TYPE_RED_BLACK, "h248_ctxs_by_trx");
ctxs = se_tree_create(SE_TREE_TYPE_RED_BLACK, "h248_ctxs");
msgs = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "h248_msgs");
trxs = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "h248_trxs");
ctxs_by_trx = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "h248_ctxs_by_trx");
ctxs = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "h248_ctxs");
}

2
epan/dissectors/packet-h248.h
View File

@ -1,6 +1,6 @@
/* Do not modify this file. */
/* It is created automatically by the ASN.1 to Wireshark dissector compiler */
/* .\packet-h248.h */
/* ./packet-h248.h */
/* ../../tools/asn2wrs.py -b -e -p h248 -c h248.cnf -s packet-h248-template MEGACO.asn */
/* Input file: packet-h248-template.h */

8
epan/dissectors/packet-iscsi.c
View File

@ -212,8 +212,8 @@ static gint ett_iscsi_ISID = -1;
/* this structure contains session wide state for a specific tcp conversation */
typedef struct _iscsi_session_t {
guint32 header_digest;
se_tree_t *itlq; /* indexed by ITT */
se_tree_t *itl; /* indexed by LUN */
emem_tree_t *itlq; /* indexed by ITT */
emem_tree_t *itl; /* indexed by LUN */
} iscsi_session_t;
@ -2199,8 +2199,8 @@ dissect_iscsi(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree, gboolean chec
if(!iscsi_session){
iscsi_session=se_alloc(sizeof(iscsi_session_t));
iscsi_session->header_digest=ISCSI_HEADER_DIGEST_AUTO;
iscsi_session->itlq=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "iSCSI ITLQ");
iscsi_session->itl=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "iSCSI ITL");
iscsi_session->itlq=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "iSCSI ITLQ");
iscsi_session->itl=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "iSCSI ITL");
conversation_add_proto_data(conversation, proto_iscsi, iscsi_session);
/* DataOut PDUs are often mistaken by DCERPC heuristics to be

8
epan/dissectors/packet-ndmp.c
View File

@ -270,8 +270,8 @@ typedef struct _ndmp_task_data_t {
typedef struct _ndmp_conv_data_t {
guint8 version;
se_tree_t *tasks; /* indexed by Sequence# */
se_tree_t *itl; /* indexed by packet# */
emem_tree_t *tasks; /* indexed by Sequence# */
emem_tree_t *itl; /* indexed by packet# */
ndmp_task_data_t *task;
} ndmp_conv_data_t;
ndmp_conv_data_t *ndmp_conv_data=NULL;
@ -2877,8 +2877,8 @@ dissect_ndmp_message(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
if(!ndmp_conv_data){
ndmp_conv_data=se_alloc(sizeof(ndmp_conv_data_t));
ndmp_conv_data->version=NDMP_PROTOCOL_UNKNOWN;
ndmp_conv_data->tasks=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "NDMP tasks");
ndmp_conv_data->itl=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "NDMP itl");
ndmp_conv_data->tasks=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "NDMP tasks");
ndmp_conv_data->itl=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "NDMP itl");
conversation_add_proto_data(conversation, proto_ndmp, ndmp_conv_data);
}

18
epan/dissectors/packet-nfs.c
View File

@ -445,7 +445,7 @@ gint default_nfs_fhandle_type=FHT_UNKNOWN;
/* fhandle displayfilters to match also corresponding request/response
packet in addition to the one containing the actual filehandle */
gboolean nfs_fhandle_reqrep_matching = FALSE;
static se_tree_t *nfs_fhandle_frame_table = NULL;
static emem_tree_t *nfs_fhandle_frame_table = NULL;
/* file name snooping */
@ -472,8 +472,8 @@ static GHashTable *nfs_name_snoop_unmatched = NULL;
static GHashTable *nfs_name_snoop_matched = NULL;
static se_tree_t *nfs_name_snoop_known = NULL;
static se_tree_t *nfs_file_handles = NULL;
static emem_tree_t *nfs_name_snoop_known = NULL;
static emem_tree_t *nfs_file_handles = NULL;
/* This function will store one nfs filehandle in our global tree of
* filehandles.
@ -492,7 +492,7 @@ static nfs_fhandle_data_t *
store_nfs_file_handle(nfs_fhandle_data_t *nfs_fh)
{
guint32 fhlen;
se_tree_key_t fhkey[3];
emem_tree_key_t fhkey[3];
nfs_fhandle_data_t *new_nfs_fh;
fhlen=nfs_fh->len/4;
@ -772,7 +772,7 @@ nfs_name_snoop_fh(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int fh_of
nns=g_hash_table_lookup(nfs_name_snoop_matched, &key);
if(nns){
guint32 fhlen;
se_tree_key_t fhkey[3];
emem_tree_key_t fhkey[3];
fhlen=nns->fh_length;
fhkey[0].length=1;
@ -798,7 +798,7 @@ nfs_name_snoop_fh(packet_info *pinfo, proto_tree *tree, tvbuff_t *tvb, int fh_of
/* see if we know this mapping */
if(!nns){
guint32 fhlen;
se_tree_key_t fhkey[3];
emem_tree_key_t fhkey[3];
fhlen=fh_length;
fhkey[0].length=1;
@ -8760,9 +8760,9 @@ proto_register_nfs(void)
nfs_fhandle_types,
FALSE);
nfs_name_snoop_known=se_tree_create(SE_TREE_TYPE_RED_BLACK, "nfs_name_snoop_known");
nfs_file_handles=se_tree_create(SE_TREE_TYPE_RED_BLACK, "nfs_file_handles");
nfs_fhandle_frame_table=se_tree_create(SE_TREE_TYPE_RED_BLACK, "nfs_fhandle_frame_table");
nfs_name_snoop_known=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "nfs_name_snoop_known");
nfs_file_handles=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "nfs_file_handles");
nfs_fhandle_frame_table=se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "nfs_fhandle_frame_table");
register_init_routine(nfs_name_snoop_init);
}

4
epan/dissectors/packet-pana.c
View File

@ -242,7 +242,7 @@ typedef struct _pana_transaction_t {
} pana_transaction_t;
typedef struct _pana_conv_info_t {
se_tree_t *pdus;
emem_tree_t *pdus;
} pana_conv_info_t;
/*
@ -620,7 +620,7 @@ dissect_pana_pdu(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
* it to the list of information structures.
*/
pana_info = se_alloc(sizeof(pana_conv_info_t));
pana_info->pdus=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "pana_pdus");
pana_info->pdus=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "pana_pdus");
conversation_add_proto_data(conversation, proto_pana, pana_info);
}

14
epan/dissectors/packet-sccp.c
View File

@ -736,7 +736,7 @@ static guint slr = 0;
static dissector_handle_t data_handle;
static dissector_table_t sccp_ssn_dissector_table;
static se_tree_t* assocs = NULL;
static emem_tree_t* assocs = NULL;
sccp_assoc_info_t* assoc;
sccp_assoc_info_t no_assoc = {0,0,0,0,FALSE,FALSE,SCCP_PLOAD_NONE,NULL};
@ -756,7 +756,7 @@ static sccp_assoc_info_t* sccp_assoc(address* opc, address* dpc, guint src_lr, g
case MESSAGE_TYPE_CR:
{
/* Calling and called is seen from initiator of CR */
se_tree_key_t key[] = {
emem_tree_key_t key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
@ -786,13 +786,13 @@ static sccp_assoc_info_t* sccp_assoc(address* opc, address* dpc, guint src_lr, g
case MESSAGE_TYPE_CC:
{
/* Calling and called is seen from initiator of CR */
se_tree_key_t called_key[] = {
emem_tree_key_t called_key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
{0,NULL}
};
se_tree_key_t calling_key[] = {
emem_tree_key_t calling_key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
@ -836,7 +836,7 @@ static sccp_assoc_info_t* sccp_assoc(address* opc, address* dpc, guint src_lr, g
}
default:
{
se_tree_key_t calling_key[] = {
emem_tree_key_t calling_key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
@ -850,7 +850,7 @@ static sccp_assoc_info_t* sccp_assoc(address* opc, address* dpc, guint src_lr, g
assoc = se_tree_lookup32_array(assocs,calling_key);
/* Should a check be made on pinfo->p2p_dir ??? */
if (!assoc){
se_tree_key_t called_key[] = {
emem_tree_key_t called_key[] = {
{1,NULL},
{1,NULL},
{1,NULL},
@ -2831,7 +2831,7 @@ proto_register_sccp(void)
register_init_routine(&init_sccp);
assocs = se_tree_create(SE_TREE_TYPE_RED_BLACK, "sccp_associations");
assocs = se_tree_create(EMEM_TREE_TYPE_RED_BLACK, "sccp_associations");
}

4
epan/dissectors/packet-smb.c
View File

@ -15432,8 +15432,8 @@ dissect_smb(tvbuff_t *tvb, packet_info *pinfo, proto_tree *parent_tree)
smb_saved_info_equal_unmatched);
si->ct->raw_ntlmssp = 0;
si->ct->fid_tree=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "SMB fid_tree");
si->ct->tid_tree=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "SMB tid_tree");
si->ct->fid_tree=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "SMB fid_tree");
si->ct->tid_tree=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "SMB tid_tree");
conversation_add_proto_data(conversation, proto_smb, si->ct);
}

4
epan/dissectors/packet-smb.h
View File

@ -252,10 +252,10 @@ typedef struct conv_tables {
gboolean raw_ntlmssp; /* Do extended security exc use raw ntlmssp */
/* track fid to fidstruct (filename/openframe/closeframe */
se_tree_t *fid_tree;
emem_tree_t *fid_tree;
/* track tid to fidstruct (sharename/shareframe/unshareframe */
se_tree_t *tid_tree;
emem_tree_t *tid_tree;
} conv_tables_t;
typedef struct smb_info {

6
epan/dissectors/packet-tcp.c
View File

@ -246,7 +246,7 @@ get_tcp_conversation_data(packet_info *pinfo)
tcpd->flow1.nextseqframe=0;
tcpd->flow1.window=0;
tcpd->flow1.win_scale=-1;
tcpd->flow1.multisegment_pdus=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "tcp_multisegment_pdus");
tcpd->flow1.multisegment_pdus=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "tcp_multisegment_pdus");
tcpd->flow2.segments=NULL;
tcpd->flow2.base_seq=0;
tcpd->flow2.lastack=0;
@ -259,8 +259,8 @@ get_tcp_conversation_data(packet_info *pinfo)
tcpd->flow2.nextseqframe=0;
tcpd->flow2.window=0;
tcpd->flow2.win_scale=-1;
tcpd->flow2.multisegment_pdus=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "tcp_multisegment_pdus");
tcpd->acked_table=se_tree_create_non_persistent(SE_TREE_TYPE_RED_BLACK, "tcp_analyze_acked_table");
tcpd->flow2.multisegment_pdus=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "tcp_multisegment_pdus");
tcpd->acked_table=se_tree_create_non_persistent(EMEM_TREE_TYPE_RED_BLACK, "tcp_analyze_acked_table");
conversation_add_proto_data(conv, proto_tcp, tcpd);

4
epan/dissectors/packet-tcp.h
View File

@ -142,7 +142,7 @@ typedef struct _tcp_flow_t {
/* This tree is indexed by sequence number and keeps track of all
* all pdus spanning multiple segments for this flow.
*/
se_tree_t *multisegment_pdus;
emem_tree_t *multisegment_pdus;
} tcp_flow_t;
@ -178,7 +178,7 @@ struct tcp_analysis {
/* This structure contains a tree containing all the various ta's
* keyed by frame number.
*/
se_tree_t *acked_table;
emem_tree_t *acked_table;
};

160
epan/emem.c
View File

@ -737,7 +737,7 @@ void
se_free_all(void)
{
emem_chunk_t *npc;
se_tree_t *se_tree_list;
emem_tree_t *se_tree_list;
#ifndef SE_DEBUG_FREE
#ifdef DEBUG_USE_CANARIES
guint i;
@ -830,19 +830,19 @@ void* ep_stack_pop(ep_stack_t stack) {
#ifdef REMOVED
void print_tree_item(se_tree_node_t *node, int level){
void print_tree_item(emem_tree_node_t *node, int level){
int i;
for(i=0;i<level;i++){
printf(" ");
}
printf("%s KEY:0x%08x node:0x%08x parent:0x%08x left:0x%08x right:0x%08x\n",node->u.rb_color==SE_TREE_RB_COLOR_BLACK?"BLACK":"RED",node->key32,(int)node,(int)node->parent,(int)node->left,(int)node->right);
printf("%s KEY:0x%08x node:0x%08x parent:0x%08x left:0x%08x right:0x%08x\n",node->u.rb_color==EMEM_TREE_RB_COLOR_BLACK?"BLACK":"RED",node->key32,(int)node,(int)node->parent,(int)node->left,(int)node->right);
if(node->left)
print_tree_item(node->left,level+1);
if(node->right)
print_tree_item(node->right,level+1);
}
void print_tree(se_tree_node_t *node){
void print_tree(emem_tree_node_t *node){
if(!node){
return;
}
@ -856,14 +856,14 @@ void print_tree(se_tree_node_t *node){
/* routines to manage se allocated red-black trees */
se_tree_t *se_trees=NULL;
emem_tree_t *se_trees=NULL;
se_tree_t *
emem_tree_t *
se_tree_create(int type, char *name)
{
se_tree_t *tree_list;
emem_tree_t *tree_list;
tree_list=malloc(sizeof(se_tree_t));
tree_list=malloc(sizeof(emem_tree_t));
tree_list->next=se_trees;
tree_list->type=type;
tree_list->tree=NULL;
@ -877,9 +877,9 @@ se_tree_create(int type, char *name)
void *
se_tree_lookup32(se_tree_t *se_tree, guint32 key)
se_tree_lookup32(emem_tree_t *se_tree, guint32 key)
{
se_tree_node_t *node;
emem_tree_node_t *node;
node=se_tree->tree;
@ -900,9 +900,9 @@ se_tree_lookup32(se_tree_t *se_tree, guint32 key)
}
void *
se_tree_lookup32_le(se_tree_t *se_tree, guint32 key)
se_tree_lookup32_le(emem_tree_t *se_tree, guint32 key)
{
se_tree_node_t *node;
emem_tree_node_t *node;
node=se_tree->tree;
@ -988,16 +988,16 @@ se_tree_lookup32_le(se_tree_t *se_tree, guint32 key)
}
static inline se_tree_node_t *
emem_tree_parent(se_tree_node_t *node)
static inline emem_tree_node_t *
emem_tree_parent(emem_tree_node_t *node)
{
return node->parent;
}
static inline se_tree_node_t *
emem_tree_grandparent(se_tree_node_t *node)
static inline emem_tree_node_t *
emem_tree_grandparent(emem_tree_node_t *node)
{
se_tree_node_t *parent;
emem_tree_node_t *parent;
parent=emem_tree_parent(node);
if(parent){
@ -1005,10 +1005,10 @@ emem_tree_grandparent(se_tree_node_t *node)
}
return NULL;
}
static inline se_tree_node_t *
emem_tree_uncle(se_tree_node_t *node)
static inline emem_tree_node_t *
emem_tree_uncle(emem_tree_node_t *node)
{
se_tree_node_t *parent, *grandparent;
emem_tree_node_t *parent, *grandparent;
parent=emem_tree_parent(node);
if(!parent){
@ -1024,11 +1024,11 @@ emem_tree_uncle(se_tree_node_t *node)
return grandparent->left;
}
static inline void rb_insert_case1(se_tree_t *se_tree, se_tree_node_t *node);
static inline void rb_insert_case2(se_tree_t *se_tree, se_tree_node_t *node);
static inline void rb_insert_case1(emem_tree_t *se_tree, emem_tree_node_t *node);
static inline void rb_insert_case2(emem_tree_t *se_tree, emem_tree_node_t *node);
static inline void
rotate_left(se_tree_t *se_tree, se_tree_node_t *node)
rotate_left(emem_tree_t *se_tree, emem_tree_node_t *node)
{
if(node->parent){
if(node->parent->left==node){
@ -1049,7 +1049,7 @@ rotate_left(se_tree_t *se_tree, se_tree_node_t *node)
}
static inline void
rotate_right(se_tree_t *se_tree, se_tree_node_t *node)
rotate_right(emem_tree_t *se_tree, emem_tree_node_t *node)
{
if(node->parent){
if(node->parent->left==node){
@ -1070,15 +1070,15 @@ rotate_right(se_tree_t *se_tree, se_tree_node_t *node)
}
static inline void
rb_insert_case5(se_tree_t *se_tree, se_tree_node_t *node)
rb_insert_case5(emem_tree_t *se_tree, emem_tree_node_t *node)
{
se_tree_node_t *grandparent;
se_tree_node_t *parent;
emem_tree_node_t *grandparent;
emem_tree_node_t *parent;
parent=emem_tree_parent(node);
grandparent=emem_tree_parent(parent);
parent->u.rb_color=SE_TREE_RB_COLOR_BLACK;
grandparent->u.rb_color=SE_TREE_RB_COLOR_RED;
parent->u.rb_color=EMEM_TREE_RB_COLOR_BLACK;
grandparent->u.rb_color=EMEM_TREE_RB_COLOR_RED;
if( (node==parent->left) && (parent==grandparent->left) ){
rotate_right(se_tree, grandparent);
} else {
@ -1087,10 +1087,10 @@ rb_insert_case5(se_tree_t *se_tree, se_tree_node_t *node)
}
static inline void
rb_insert_case4(se_tree_t *se_tree, se_tree_node_t *node)
rb_insert_case4(emem_tree_t *se_tree, emem_tree_node_t *node)
{
se_tree_node_t *grandparent;
se_tree_node_t *parent;
emem_tree_node_t *grandparent;
emem_tree_node_t *parent;
parent=emem_tree_parent(node);
grandparent=emem_tree_parent(parent);
@ -1108,19 +1108,19 @@ rb_insert_case4(se_tree_t *se_tree, se_tree_node_t *node)
}
static inline void
rb_insert_case3(se_tree_t *se_tree, se_tree_node_t *node)
rb_insert_case3(emem_tree_t *se_tree, emem_tree_node_t *node)
{
se_tree_node_t *grandparent;
se_tree_node_t *parent;
se_tree_node_t *uncle;
emem_tree_node_t *grandparent;
emem_tree_node_t *parent;
emem_tree_node_t *uncle;
uncle=emem_tree_uncle(node);
if(uncle && (uncle->u.rb_color==SE_TREE_RB_COLOR_RED)){
if(uncle && (uncle->u.rb_color==EMEM_TREE_RB_COLOR_RED)){
parent=emem_tree_parent(node);
parent->u.rb_color=SE_TREE_RB_COLOR_BLACK;
uncle->u.rb_color=SE_TREE_RB_COLOR_BLACK;
parent->u.rb_color=EMEM_TREE_RB_COLOR_BLACK;
uncle->u.rb_color=EMEM_TREE_RB_COLOR_BLACK;
grandparent=emem_tree_grandparent(node);
grandparent->u.rb_color=SE_TREE_RB_COLOR_RED;
grandparent->u.rb_color=EMEM_TREE_RB_COLOR_RED;
rb_insert_case1(se_tree, grandparent);
} else {
rb_insert_case4(se_tree, node);
@ -1128,26 +1128,26 @@ rb_insert_case3(se_tree_t *se_tree, se_tree_node_t *node)
}
static inline void
rb_insert_case2(se_tree_t *se_tree, se_tree_node_t *node)
rb_insert_case2(emem_tree_t *se_tree, emem_tree_node_t *node)
{
se_tree_node_t *parent;
emem_tree_node_t *parent;
parent=emem_tree_parent(node);
/* parent is always non-NULL here */
if(parent->u.rb_color==SE_TREE_RB_COLOR_BLACK){
if(parent->u.rb_color==EMEM_TREE_RB_COLOR_BLACK){
return;
}
rb_insert_case3(se_tree, node);
}
static inline void
rb_insert_case1(se_tree_t *se_tree, se_tree_node_t *node)
rb_insert_case1(emem_tree_t *se_tree, emem_tree_node_t *node)
{
se_tree_node_t *parent;
emem_tree_node_t *parent;
parent=emem_tree_parent(node);
if(!parent){
node->u.rb_color=SE_TREE_RB_COLOR_BLACK;
node->u.rb_color=EMEM_TREE_RB_COLOR_BLACK;
return;
}
rb_insert_case2(se_tree, node);
@ -1156,18 +1156,18 @@ rb_insert_case1(se_tree_t *se_tree, se_tree_node_t *node)
/* insert a new node in the tree. if this node matches an already existing node
* then just replace the data for that node */
void
se_tree_insert32(se_tree_t *se_tree, guint32 key, void *data)
se_tree_insert32(emem_tree_t *se_tree, guint32 key, void *data)
{
se_tree_node_t *node;
emem_tree_node_t *node;
node=se_tree->tree;
/* is this the first node ?*/
if(!node){
node=se_tree->malloc(sizeof(se_tree_node_t));
node=se_tree->malloc(sizeof(emem_tree_node_t));
switch(se_tree->type){
case SE_TREE_TYPE_RED_BLACK:
node->u.rb_color=SE_TREE_RB_COLOR_BLACK;
case EMEM_TREE_TYPE_RED_BLACK:
node->u.rb_color=EMEM_TREE_RB_COLOR_BLACK;
break;
}
node->parent=NULL;
@ -1191,8 +1191,8 @@ se_tree_insert32(se_tree_t *se_tree, guint32 key, void *data)
if(key<node->key32) {
if(!node->left){
/* new node to the left */
se_tree_node_t *new_node;
new_node=se_tree->malloc(sizeof(se_tree_node_t));
emem_tree_node_t *new_node;
new_node=se_tree->malloc(sizeof(emem_tree_node_t));
node->left=new_node;
new_node->parent=node;
new_node->left=NULL;
@ -1208,8 +1208,8 @@ se_tree_insert32(se_tree_t *se_tree, guint32 key, void *data)
if(key>node->key32) {
if(!node->right){
/* new node to the right */
se_tree_node_t *new_node;
new_node=se_tree->malloc(sizeof(se_tree_node_t));
emem_tree_node_t *new_node;
new_node=se_tree->malloc(sizeof(emem_tree_node_t));
node->right=new_node;
new_node->parent=node;
new_node->left=NULL;
@ -1226,24 +1226,24 @@ se_tree_insert32(se_tree_t *se_tree, guint32 key, void *data)
/* node will now point to the newly created node */
switch(se_tree->type){
case SE_TREE_TYPE_RED_BLACK:
node->u.rb_color=SE_TREE_RB_COLOR_RED;
case EMEM_TREE_TYPE_RED_BLACK:
node->u.rb_color=EMEM_TREE_RB_COLOR_RED;
rb_insert_case1(se_tree, node);
break;
}
}
static void* lookup_or_insert32(se_tree_t *se_tree, guint32 key, void*(*func)(void*),void* ud) {
se_tree_node_t *node;
static void* lookup_or_insert32(emem_tree_t *se_tree, guint32 key, void*(*func)(void*),void* ud) {
emem_tree_node_t *node;
node=se_tree->tree;
/* is this the first node ?*/
if(!node){
node=se_tree->malloc(sizeof(se_tree_node_t));
node=se_tree->malloc(sizeof(emem_tree_node_t));
switch(se_tree->type){
case SE_TREE_TYPE_RED_BLACK:
node->u.rb_color=SE_TREE_RB_COLOR_BLACK;
case EMEM_TREE_TYPE_RED_BLACK:
node->u.rb_color=EMEM_TREE_RB_COLOR_BLACK;
break;
}
node->parent=NULL;
@ -1266,8 +1266,8 @@ static void* lookup_or_insert32(se_tree_t *se_tree, guint32 key, void*(*func)(vo
if(key<node->key32) {
if(!node->left){
/* new node to the left */
se_tree_node_t *new_node;
new_node=se_tree->malloc(sizeof(se_tree_node_t));
emem_tree_node_t *new_node;
new_node=se_tree->malloc(sizeof(emem_tree_node_t));
node->left=new_node;
new_node->parent=node;
new_node->left=NULL;
@ -1283,8 +1283,8 @@ static void* lookup_or_insert32(se_tree_t *se_tree, guint32 key, void*(*func)(vo
if(key>node->key32) {
if(!node->right){
/* new node to the right */
se_tree_node_t *new_node;
new_node=se_tree->malloc(sizeof(se_tree_node_t));
emem_tree_node_t *new_node;
new_node=se_tree->malloc(sizeof(emem_tree_node_t));
node->right=new_node;
new_node->parent=node;
new_node->left=NULL;
@ -1301,8 +1301,8 @@ static void* lookup_or_insert32(se_tree_t *se_tree, guint32 key, void*(*func)(vo
/* node will now point to the newly created node */
switch(se_tree->type){
case SE_TREE_TYPE_RED_BLACK:
node->u.rb_color=SE_TREE_RB_COLOR_RED;
case EMEM_TREE_TYPE_RED_BLACK:
node->u.rb_color=EMEM_TREE_RB_COLOR_RED;
rb_insert_case1(se_tree, node);
break;
}
@ -1313,12 +1313,12 @@ static void* lookup_or_insert32(se_tree_t *se_tree, guint32 key, void*(*func)(vo
/* When the se data is released, this entire tree will dissapear as if it
* never existed including all metadata associated with the tree.
*/
se_tree_t *
emem_tree_t *
se_tree_create_non_persistent(int type, char *name)
{
se_tree_t *tree_list;
emem_tree_t *tree_list;
tree_list=se_alloc(sizeof(se_tree_t));
tree_list=se_alloc(sizeof(emem_tree_t));
tree_list->next=NULL;
tree_list->type=type;
tree_list->tree=NULL;
@ -1329,7 +1329,7 @@ se_tree_create_non_persistent(int type, char *name)
}
static void* create_sub_tree(void* d) {
se_tree_t *se_tree = d;
emem_tree_t *se_tree = d;
return se_tree_create_non_persistent(se_tree->type, "subtree");
}
@ -1337,9 +1337,9 @@ static void* create_sub_tree(void* d) {
* then just replace the data for that node */
void
se_tree_insert32_array(se_tree_t *se_tree, se_tree_key_t *key, void *data)
se_tree_insert32_array(emem_tree_t *se_tree, emem_tree_key_t *key, void *data)
{
se_tree_t *next_tree;
emem_tree_t *next_tree;
if((key[0].length<1)||(key[0].length>100)){
DISSECTOR_ASSERT_NOT_REACHED();
@ -1361,9 +1361,9 @@ se_tree_insert32_array(se_tree_t *se_tree, se_tree_key_t *key, void *data)
}
void *
se_tree_lookup32_array(se_tree_t *se_tree, se_tree_key_t *key)
se_tree_lookup32_array(emem_tree_t *se_tree, emem_tree_key_t *key)
{
se_tree_t *next_tree;
emem_tree_t *next_tree;
if((key[0].length<1)||(key[0].length>100)){
DISSECTOR_ASSERT_NOT_REACHED();
@ -1385,11 +1385,11 @@ se_tree_lookup32_array(se_tree_t *se_tree, se_tree_key_t *key)
}
void se_tree_insert_string(se_string_hash_t* se_tree, const gchar* k, void* v) {
void se_tree_insert_string(emem_string_hash_t* se_tree, const gchar* k, void* v) {
guint32 len = strlen(k);
guint32 div = (len-1)/4;
guint32 residual = 0;
se_tree_key_t key[] = {
emem_tree_key_t key[] = {
{1,NULL},
{0,NULL},
{1,NULL},
@ -1425,11 +1425,11 @@ void se_tree_insert_string(se_string_hash_t* se_tree, const gchar* k, void* v) {
se_tree_insert32_array(se_tree,key,v);
}
void* se_tree_lookup_string(se_string_hash_t* se_tree, const gchar* k) {
void* se_tree_lookup_string(emem_string_hash_t* se_tree, const gchar* k) {
guint32 len = strlen(k);
guint32 div = (len-1)/4;
guint32 residual = 0;
se_tree_key_t key[] = {
emem_tree_key_t key[] = {
{1,NULL},
{0,NULL},
{1,NULL},

62
epan/emem.h
View File

@ -158,20 +158,20 @@ void se_free_all(void);
/**************************************************************
* binary trees with SE allocation
* binary trees
**************************************************************/
#define SE_TREE_RB_COLOR_RED 0x00
#define SE_TREE_RB_COLOR_BLACK 0x01
typedef struct _se_tree_node_t {
struct _se_tree_node_t *parent;
struct _se_tree_node_t *left;
struct _se_tree_node_t *right;
#define EMEM_TREE_RB_COLOR_RED 0x00
#define EMEM_TREE_RB_COLOR_BLACK 0x01
typedef struct _emem_tree_node_t {
struct _emem_tree_node_t *parent;
struct _emem_tree_node_t *left;
struct _emem_tree_node_t *right;
union {
guint32 rb_color;
} u;
guint32 key32;
void *data;
} se_tree_node_t;
} emem_tree_node_t;
/* Right now we only do basic red/black trees but in the future we might want
* to try something different, such as a tree where each node keeps track
@ -179,39 +179,39 @@ typedef struct _se_tree_node_t {
* nodes bubble upwards in the tree using rotate_right/left.
* That would probably be good for things like nfs filehandles
*/
#define SE_TREE_TYPE_RED_BLACK 1
typedef struct _se_tree_t {
struct _se_tree_t *next;
#define EMEM_TREE_TYPE_RED_BLACK 1
typedef struct _emem_tree_t {
struct _emem_tree_t *next;
int type;
char *name; /* just a string to make debugging easier */
se_tree_node_t *tree;
emem_tree_node_t *tree;
void *(*malloc)(size_t);
} se_tree_t;
} emem_tree_t;
/* list of all se trees so they can all be reset automatically when
* we free all se memory
/* list of all trees with se allocation scope so that they can all be reset
* automatically when we free all se memory
*/
extern se_tree_t *se_trees;
extern emem_tree_t *se_trees;
/* This function is used to create a se based tree with monitoring.
* When the SE heap is released back to the system the pointer to the
* tree is automatically reset to NULL.
*
* type is : SE_TREE_TYPE_RED_BLACK for a standard red/black tree.
* type is : EMEM_TREE_TYPE_RED_BLACK for a standard red/black tree.
*/
se_tree_t *se_tree_create(int type, char *name);
emem_tree_t *se_tree_create(int type, char *name);
/* This function is used to insert a node indexed by a guint32 key value.
* The data pointer should be allocated by SE allocators so that the
* data will be released at the same time as the tree itself is destroyed.
*/
void se_tree_insert32(se_tree_t *se_tree, guint32 key, void *data);
void se_tree_insert32(emem_tree_t *se_tree, guint32 key, void *data);
/* This function will look up a node in the tree indexed by a guint32 integer
* value.
*/
void *se_tree_lookup32(se_tree_t *se_tree, guint32 key);
void *se_tree_lookup32(emem_tree_t *se_tree, guint32 key);
/* This function will look up a node in the tree indexed by a guint32 integer
* value.
@ -219,7 +219,7 @@ void *se_tree_lookup32(se_tree_t *se_tree, guint32 key);
* equal to or smaller than the search key, or NULL if no such key was
* found.
*/
void *se_tree_lookup32_le(se_tree_t *se_tree, guint32 key);
void *se_tree_lookup32_le(emem_tree_t *se_tree, guint32 key);
/* This function is similar to the se_tree_create() call but with the
@ -231,12 +231,14 @@ void *se_tree_lookup32_le(se_tree_t *se_tree, guint32 key);
* another structure that is also se allocated so that when the structure is
* released, the tree will be completely released as well.
*/
se_tree_t *se_tree_create_non_persistent(int type, char *name);
emem_tree_t *se_tree_create_non_persistent(int type, char *name);
typedef struct _se_tree_key_t {
typedef struct _emem_tree_key_t {
guint32 length; /*length in guint32 words */
guint32 *key;
} se_tree_key_t;
} emem_tree_key_t;
/* This function is used to insert a node indexed by a sequence of guint32
* key values.
@ -256,7 +258,7 @@ typedef struct _se_tree_key_t {
* The NFS dissector handles this by providing a guint32 containing the length
* as the very first item in this vector :
*
* se_tree_key_t fhkey[3];
* emem_tree_key_t fhkey[3];
*
* fhlen=nns->fh_length;
* fhkey[0].length=1;
@ -265,26 +267,26 @@ typedef struct _se_tree_key_t {
* fhkey[1].key=nns->fh;
* fhkey[2].length=0;
*/
void se_tree_insert32_array(se_tree_t *se_tree, se_tree_key_t *key, void *data);
void se_tree_insert32_array(emem_tree_t *se_tree, emem_tree_key_t *key, void *data);
/* This function will look up a node in the tree indexed by a sequence of
* guint32 integer values.
*/
void *se_tree_lookup32_array(se_tree_t *se_tree, se_tree_key_t *key);
void *se_tree_lookup32_array(emem_tree_t *se_tree, emem_tree_key_t *key);
/*
* A hash table with string keys based on the red/black tree
*/
typedef struct _se_tree_t se_string_hash_t;
typedef struct _emem_tree_t emem_string_hash_t;
/* Create a new string based hash table */
#define se_tree_create_string() se_tree_create(SE_TREE_TYPE_RED_BLACK)
/* Insert a new value under a string key */
void se_tree_insert_string(se_string_hash_t* h, const gchar* k, void* v);
void se_tree_insert_string(emem_string_hash_t* h, const gchar* k, void* v);
/* Lookup the value under a string key */
void* se_tree_lookup_string(se_string_hash_t* h, const gchar* k);
void* se_tree_lookup_string(emem_string_hash_t* h, const gchar* k);
#endif /* emem.h */