}
#define COL_CHECK_REF_TIME(fd, buf) \
- if (fd->flags.ref_time) { \
+ if (fd->ref_time) { \
g_strlcpy(buf, "*REF*", COL_MAX_LEN ); \
return; \
}
col_append_frame_number(packet_info *pinfo, const gint col, const gchar *fmt_str, guint frame_num)
{
col_append_fstr(pinfo->cinfo, col, fmt_str, frame_num);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
col_data_changed_ = TRUE;
}
}
time_t then;
int tsprecision;
- if (fd->flags.has_ts) {
+ if (fd->has_ts) {
then = fd->abs_ts.secs;
if (local)
tmp = localtime(&then);
time_t then;
int tsprecision;
- if (fd->flags.has_ts) {
+ if (fd->has_ts) {
then = fd->abs_ts.secs;
if (local)
tmp = localtime(&then);
{
nstime_t del_rel_ts;
- if (!fd->flags.has_ts) {
+ if (!fd->has_ts) {
cinfo->columns[col].col_buf[0] = '\0';
return;
}
{
nstime_t del_dis_ts;
- if (!fd->flags.has_ts) {
+ if (!fd->has_ts) {
cinfo->columns[col].col_buf[0] = '\0';
return;
}
time_t then;
int tsprecision;
- if (fd->flags.has_ts) {
+ if (fd->has_ts) {
then = fd->abs_ts.secs;
if (local)
tmp = localtime(&then);
{
int tsprecision;
- if (!fd->flags.has_ts) {
+ if (!fd->has_ts) {
buf[0] = '\0';
return FALSE;
}
break;
case TS_RELATIVE:
- if (fd->flags.has_ts) {
+ if (fd->has_ts) {
nstime_t del_rel_ts;
frame_delta_abs_time(epan, fd, fd->frame_ref_num, &del_rel_ts);
break;
case TS_DELTA:
- if (fd->flags.has_ts) {
+ if (fd->has_ts) {
nstime_t del_cap_ts;
frame_delta_abs_time(epan, fd, fd->num - 1, &del_cap_ts);
break;
case TS_DELTA_DIS:
- if (fd->flags.has_ts) {
+ if (fd->has_ts) {
nstime_t del_dis_ts;
frame_delta_abs_time(epan, fd, fd->prev_dis_num, &del_dis_ts);
if (!CHECK_COL(cinfo, el))
return;
- /** @todo TODO: We don't respect fd->flags.ref_time (no way to access 'fd')
+ /** @todo TODO: We don't respect fd->ref_time (no way to access 'fd')
COL_CHECK_REF_TIME(fd, buf);
*/
dst_str = address_to_str(wmem_packet_scope(), dst);
/* Data from the TCAP dissector */
- if ((!pinfo->fd->flags.visited)&&(p_private_tcap->TransactionID_str)){
+ if ((!pinfo->fd->visited)&&(p_private_tcap->TransactionID_str)){
/* Only do this once XXX I hope it's the right thing to do */
/* The hash string needs to contain src and dest to distiguish differnt flows */
switch(ansi_map_response_matching_type){
src = address_to_str(wmem_packet_scope(), &(pinfo->src));
dst = address_to_str(wmem_packet_scope(), &(pinfo->dst));
- if ((!pinfo->fd->flags.visited)&&(ansi_tcap_private.TransactionID_str)){
+ if ((!pinfo->fd->visited)&&(ansi_tcap_private.TransactionID_str)){
/* Only do this once XXX I hope it's the right thing to do */
/* The hash string needs to contain src and dest to distiguish differnt flows */
h225_pi->h245_address = ipv4_address;
h225_pi->h245_port = ip_port;
}
- if ( !actx->pinfo->fd->flags.visited && h245_handle && ip_port!=0 ) {
+ if ( !actx->pinfo->fd->visited && h245_handle && ip_port!=0 ) {
address src_addr;
conversation_t *conv=NULL;
#.FN_BODY OpenLogicalChannel
gint32 temp;
- upcoming_olc = (!actx->pinfo->fd->flags.visited) ? wmem_new0(wmem_file_scope(), olc_info_t) : NULL;
+ upcoming_olc = (!actx->pinfo->fd->visited) ? wmem_new0(wmem_file_scope(), olc_info_t) : NULL;
h223_fw_lc_num = 0;
h223_lc_params_temp = NULL;
const gchar *olc_key;
olc_info_t *olc_req;
- upcoming_olc = (!actx->pinfo->fd->flags.visited) ? wmem_new0(wmem_packet_scope(), olc_info_t) : NULL;
+ upcoming_olc = (!actx->pinfo->fd->visited) ? wmem_new0(wmem_packet_scope(), olc_info_t) : NULL;
h223_fw_lc_num = 0;
h223_rev_lc_num = 0;
{
enc_key_t *new_key;
- if(pinfo->fd->flags.visited){
+ if(pinfo->fd->visited){
return;
}
{
service_key_t *new_key;
- if(pinfo->fd->flags.visited){
+ if(pinfo->fd->visited){
return;
}
switch(ProtocolOp) {
case LDAP_RES_SEARCH_ENTRY:
- if (!actx->pinfo->fd->flags.visited)
+ if (!actx->pinfo->fd->visited)
ldap_info->num_results++;
proto_item_append_text(tree, " [%d result%s]",
* type and mechanism, if you can unbind and rebind with a
* different type and/or mechanism.
*/
- if(!actx->pinfo->fd->flags.visited) {
+ if(!actx->pinfo->fd->visited) {
mechanism = tvb_get_string_enc(wmem_file_scope(), parameter_tvb, 0, tvb_reported_length_remaining(parameter_tvb,0), ENC_UTF_8|ENC_NA);
ldap_info->first_auth_frame = 0; /* not known until we see the bind reply */
/*
/* Track whether systemInfoValue has changed since last seen, indicating new SI config
TODO: add link back to previous config and (if known) time since previous config
was first seen */
- if (!actx->pinfo->fd->flags.visited) {
+ if (!actx->pinfo->fd->visited) {
if (system_info_value_current_set && (value != system_info_value_current)) {
/* Add entry to the hash table. Offset by one to distinguish 0 from lookup failure */
wmem_map_insert(lte_rrc_system_info_value_changed_hash, GUINT_TO_POINTER(actx->pinfo->num),
%(DEFAULT_BODY)s
transportLayerAddress_ipv4 = private_data_get_transportLayerAddress_ipv4(actx);
binding_id = private_data_get_binding_id_port(actx);
- if (actx->pinfo->fd->flags.visited || transportLayerAddress_ipv4 == 0 || binding_id == 0){
+ if (actx->pinfo->fd->visited || transportLayerAddress_ipv4 == 0 || binding_id == 0){
return offset;
}
set_address(&ipv4_addr, AT_IPv4, 4, &transportLayerAddress_ipv4);
%(DEFAULT_BODY)s
transportLayerAddress_ipv4 = private_data_get_transportLayerAddress_ipv4(actx);
binding_id = private_data_get_binding_id_port(actx);
- if (actx->pinfo->fd->flags.visited || transportLayerAddress_ipv4 == 0 || binding_id == 0){
+ if (actx->pinfo->fd->visited || transportLayerAddress_ipv4 == 0 || binding_id == 0){
return offset;
}
set_address(&ipv4_addr, AT_IPv4, 4, &transportLayerAddress_ipv4);
* negotiation in a conversation.
*/
next_level_value = (gssapi_oid_value *)p_get_proto_data(wmem_file_scope(), pinfo, proto_spnego, 0);
- if (!next_level_value && !pinfo->fd->flags.visited) {
+ if (!next_level_value && !pinfo->fd->visited) {
/*
* No handle attached to this frame, but it's the first
* pass, so it'd be attached to the conversation.
* we've already done this work, so we don't need to do it
* again.
*/
- if ((pinfo->fd->flags.visited) || (t38_udp_handle == NULL))
+ if ((pinfo->fd->visited) || (t38_udp_handle == NULL))
{
return;
}
fd_head = fragment_get(table, pinfo, id, NULL);
/* have we already seen this frame ?*/
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) {
return fd_head;
} else {
0, 0, frame_len, "Record Length: %u byte%s (%u bits)",
frame_len, frame_plurality, frame_len * 8);
- ti = proto_tree_add_boolean(fh_tree, hf_file_marked, tvb, 0, 0,pinfo->fd->flags.marked);
+ ti = proto_tree_add_boolean(fh_tree, hf_file_marked, tvb, 0, 0,pinfo->fd->marked);
PROTO_ITEM_SET_GENERATED(ti);
- ti = proto_tree_add_boolean(fh_tree, hf_file_ignored, tvb, 0, 0,pinfo->fd->flags.ignored);
+ ti = proto_tree_add_boolean(fh_tree, hf_file_ignored, tvb, 0, 0,pinfo->fd->ignored);
PROTO_ITEM_SET_GENERATED(ti);
if(pinfo->fd->pfd != 0){
#endif
}
- if (pinfo->fd->flags.ignored) {
+ if (pinfo->fd->ignored) {
/* Ignored package, stop handling here */
col_set_str(pinfo->cinfo, COL_INFO, "<Ignored>");
proto_tree_add_boolean_format(tree, hf_file_ignored, tvb, 0, -1, TRUE, "This record is marked as ignored");
}
/* Attempt to (re-)calculate color filters (if any). */
- if (pinfo->fd->flags.need_colorize) {
+ if (pinfo->fd->need_colorize) {
color_filter = color_filters_colorize_packet(file_data->color_edt);
pinfo->fd->color_filter = color_filter;
- pinfo->fd->flags.need_colorize = 0;
+ pinfo->fd->need_colorize = 0;
} else {
color_filter = pinfo->fd->color_filter;
}
{
struct _9p_hashval *val;
- if (pinfo->fd->flags.visited || fid == _9P_NOFID)
+ if (pinfo->fd->visited || fid == _9P_NOFID)
return;
/* get or create&insert fid tree */
{
char *str;
- if (pinfo->fd->flags.visited || fid == _9P_NOFID || len == 0)
+ if (pinfo->fd->visited || fid == _9P_NOFID || len == 0)
return;
str = (char*)wmem_alloc(wmem_file_scope(), len);
struct _9p_hashval *val;
struct _9p_taginfo *taginfo;
- if (pinfo->fd->flags.visited || tag == _9P_NOTAG)
+ if (pinfo->fd->visited || tag == _9P_NOTAG)
return;
val = _9p_hash_new_val(sizeof(struct _9p_taginfo));
struct _9p_hashval *val;
/* get tag only makes sense on first pass, as tree isn't built like fid */
- if (pinfo->fd->flags.visited || tag == _9P_NOTAG)
+ if (pinfo->fd->visited || tag == _9P_NOTAG)
return NULL;
/* check that length matches? */
static inline void conv_free_tag(packet_info *pinfo, guint16 tag)
{
- if (pinfo->fd->flags.visited || tag == _9P_NOTAG)
+ if (pinfo->fd->visited || tag == _9P_NOTAG)
return;
_9p_hash_free(pinfo, tag, _9P_NOFID);
proto_tree_add_item(ninep_tree, hf_9P_maxsize, tvb, offset, 4, ENC_LITTLE_ENDIAN);
offset += 4;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
_9p_len = tvb_get_letohs(tvb, offset);
tvb_s = tvb_get_string_enc(wmem_packet_scope(), tvb, offset+2, _9p_len, ENC_UTF_8|ENC_NA);
offset += _9p_dissect_string(tvb, ninep_tree, offset, hf_9P_uname, ett_9P_uname);
- if(!pinfo->fd->flags.visited) {
+ if(!pinfo->fd->visited) {
_9p_len = tvb_get_letohs(tvb, offset);
tvb_s = tvb_get_string_enc(wmem_packet_scope(), tvb, offset+2, _9p_len, ENC_UTF_8|ENC_NA);
conv_set_fid(pinfo, fid, tvb_s, _9p_len+1);
ti = proto_tree_add_item(ninep_tree, hf_9P_fid, tvb, offset, 4, ENC_LITTLE_ENDIAN);
fid_path = conv_get_fid(pinfo, fid);
proto_item_append_text(ti, " (%s)", fid_path);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
tmppath = wmem_strbuf_sized_new(wmem_packet_scope(), 0, MAXPATHLEN);
wmem_strbuf_append(tmppath, fid_path);
}
offset += 2;
for(i = 0 ; i < u16; i++) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
_9p_len = tvb_get_letohs(tvb, offset);
tvb_s = tvb_get_string_enc(wmem_packet_scope(), tvb, offset+2, _9p_len, ENC_UTF_8|ENC_NA);
wmem_strbuf_append_c(tmppath, '/');
expert_add_info(pinfo, ti, &ei_9P_first_250);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
conv_set_fid(pinfo, fid, wmem_strbuf_get_str(tmppath), wmem_strbuf_get_len(tmppath)+1);
}
proto_item_append_text(ti, " (%s)", fid_path);
offset += 4;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
_9p_len = tvb_get_letohs(tvb, offset);
tmppath = wmem_strbuf_sized_new(wmem_packet_scope(), 0, MAXPATHLEN);
wmem_strbuf_append(tmppath, fid_path);
proto_item_append_text(ti, " (%s)", fid_path);
offset += 4;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
_9p_len = tvb_get_letohs(tvb, offset);
tmppath = wmem_strbuf_sized_new(wmem_packet_scope(), 0, MAXPATHLEN);
wmem_strbuf_append(tmppath, fid_path);
proto_item_append_text(ti, " (%s)", fid_path);
offset += 4;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
_9p_len = tvb_get_letohs(tvb, offset);
tmppath = wmem_strbuf_sized_new(wmem_packet_scope(), 0, MAXPATHLEN);
wmem_strbuf_append(tmppath, conv_get_fid(pinfo, dfid));
break;
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
command_data = wmem_new(wmem_file_scope(), command_data_t);
command_data->bus_id = bus_id;
command_data->device_address = device_address;
command = command_data->command;
command_frame_number = command_data->command_frame_number;
- if (!pinfo->fd->flags.visited && command_data->response_frame_number == 0) {
+ if (!pinfo->fd->visited && command_data->response_frame_number == 0) {
command_data->response_frame_number = pinfo->num;
}
}
proto_tree_add_expert(expert_tree, pinfo, &ei_invalid_magic, tvb, offset, 4);
}
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
save_command(command, arg0, arg1, data_length, crc32, service_data, proto, data, pinfo, &service_data, &command_data);
offset += 4;
}
- if (!pinfo->fd->flags.visited && command_data) {
+ if (!pinfo->fd->visited && command_data) {
if (command_data->command_in_frame != frame_number) {
is_command = FALSE;
is_next_fragment = TRUE;
/* First pass: store message payload (usually a single packet, but
* potentially multiple fragments). */
- if (!pinfo->fd->flags.visited && command_data && command_data->reassemble_data_length < command_data->data_length) {
+ if (!pinfo->fd->visited && command_data && command_data->reassemble_data_length < command_data->data_length) {
guint chunklen = tvb_captured_length_remaining(tvb, offset);
if (chunklen > command_data->data_length - command_data->reassemble_data_length) {
chunklen = command_data->data_length - command_data->reassemble_data_length;
proto_tree_add_expert(main_tree, pinfo, &ei_invalid_data, tvb, offset, -1);
}
- if ((!pinfo->fd->flags.visited && command_data && command_data->reassemble_data_length < command_data->data_length) || data_length > (guint32) tvb_captured_length_remaining(tvb, offset)) { /* need reassemble */
+ if ((!pinfo->fd->visited && command_data && command_data->reassemble_data_length < command_data->data_length) || data_length > (guint32) tvb_captured_length_remaining(tvb, offset)) { /* need reassemble */
proto_tree_add_item(main_tree, hf_data_fragment, tvb, offset, -1, ENC_NA);
col_append_str(pinfo->cinfo, COL_INFO, "Data Fragment");
offset = tvb_captured_length(tvb);
if (is_service) {
proto_tree_add_item(main_tree, hf_service, tvb, offset, -1, ENC_ASCII | ENC_NA);
- if (!pinfo->fd->flags.visited && service_data) {
+ if (!pinfo->fd->visited && service_data) {
service_data->service = tvb_get_stringz_enc(wmem_file_scope(), tvb, offset, NULL, ENC_ASCII);
}
col_append_fstr(pinfo->cinfo, COL_INFO, "Service: %s", tvb_get_stringz_enc(wmem_packet_scope(), tvb, offset, NULL, ENC_ASCII));
return tvb_captured_length(tvb);
}
- if (!pinfo->fd->flags.visited && length > 0) { /* save Length to client_requests */
+ if (!pinfo->fd->visited && length > 0) { /* save Length to client_requests */
if (pinfo->rec->presence_flags & WTAP_HAS_INTERFACE_ID)
wireshark_interface_id = pinfo->rec->rec_header.packet_header.interface_id;
wmem_tree_insert32_array(client_requests, key, client_request);
}
- if (!pinfo->fd->flags.visited && (length == -1 || (client_request && client_request->service_in == -1 && tvb_reported_length_remaining(tvb, offset) > 0))) { /* save Service to client_requests */
+ if (!pinfo->fd->visited && (length == -1 || (client_request && client_request->service_in == -1 && tvb_reported_length_remaining(tvb, offset) > 0))) { /* save Service to client_requests */
if (!client_request) {
if (pinfo->rec->presence_flags & WTAP_HAS_INTERFACE_ID)
wireshark_interface_id = pinfo->rec->rec_header.packet_header.interface_id;
length = -1;
}
- if (!pinfo->fd->flags.visited && client_request) {
+ if (!pinfo->fd->visited && client_request) {
client_request->response_frame = pinfo->num;
client_request->status = status;
client_request->data_length = length;
if (!continuation_data || (continuation_data && continuation_data->length_in_frame == pinfo->num))
offset = dissect_ascii_uint32(main_tree, hf_hex_ascii_length, ett_length, hf_length, tvb, offset, &data_length);
- if (!pinfo->fd->flags.visited && !continuation_data && tvb_reported_length_remaining(tvb, offset) < 4) {
+ if (!pinfo->fd->visited && !continuation_data && tvb_reported_length_remaining(tvb, offset) < 4) {
key[i_key].length = 1;
key[i_key++].key = &pinfo->num;
key[i_key].length = 0;
if (tvb_reported_length_remaining(tvb, offset) >= 4 ||
(continuation_data && continuation_data->completed_in_frame == pinfo->num)) {
- if (!pinfo->fd->flags.visited && continuation_data) {
+ if (!pinfo->fd->visited && continuation_data) {
continuation_data->completed_in_frame = pinfo->num;
}
offset = dissect_ascii_uint32(main_tree, hf_hex_ascii_version, ett_version, hf_version, tvb, offset, &version);
if (framebuffer_data && framebuffer_data->completed_in_frame < pinfo->num)
framebuffer_data = NULL;
- if (!pinfo->fd->flags.visited && !framebuffer_data) {
+ if (!pinfo->fd->visited && !framebuffer_data) {
key[i_key].length = 1;
key[i_key++].key = &pinfo->num;
key[i_key].length = 0;
sub_item = proto_tree_add_item(main_tree, hf_data, tvb, offset, -1, ENC_NA);
sub_tree = proto_item_add_subtree(sub_item, ett_data);
- if (!pinfo->fd->flags.visited && framebuffer_data) {
+ if (!pinfo->fd->visited && framebuffer_data) {
framebuffer_data->current_size += tvb_captured_length_remaining(tvb, offset);
if (framebuffer_data->current_size >= framebuffer_data->size)
framebuffer_data->completed_in_frame = pinfo->num;
subtree = (wmem_tree_t *) wmem_tree_lookup32_array(fragments, key);
fragment = (subtree) ? (fragment_t *) wmem_tree_lookup32_le(subtree, pinfo->num - 1) : NULL;
if (fragment) {
- if (!pinfo->fd->flags.visited && fragment->reassembled_in_frame == -1)
+ if (!pinfo->fd->visited && fragment->reassembled_in_frame == -1)
fragment->reassembled_in_frame = pinfo->num;
if (fragment->reassembled_in_frame == pinfo->num) {
i_offset += logcat_length;
} else {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
DISSECTOR_ASSERT_HINT(adb_service_data->session_key_length + 2 <= sizeof(key) / sizeof(key[0]), "Tree session key is too small");
for (i_key = 0; i_key < adb_service_data->session_key_length; i_key += 1) {
key[i_key].length = 1;
conversation_add_proto_data(conversation, proto_adwin, adwin_info);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (direction == ADWIN_REQUEST) {
/* This is a request */
adwin_trans = wmem_new(wmem_file_scope(), adwin_transaction_t);
/* only allocate a new hash element when it's a request */
opcode = 0;
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if ( !request_val && !reply) {
new_request_key = wmem_new(wmem_file_scope(), struct afs_request_key);
*new_request_key = request_key;
dst_str = address_to_str(wmem_packet_scope(), dst);
/* Data from the TCAP dissector */
- if ((!pinfo->fd->flags.visited)&&(p_private_tcap->TransactionID_str)){
+ if ((!pinfo->fd->visited)&&(p_private_tcap->TransactionID_str)){
/* Only do this once XXX I hope it's the right thing to do */
/* The hash string needs to contain src and dest to distiguish differnt flows */
switch(ansi_map_response_matching_type){
src = address_to_str(wmem_packet_scope(), &(pinfo->src));
dst = address_to_str(wmem_packet_scope(), &(pinfo->dst));
- if ((!pinfo->fd->flags.visited)&&(ansi_tcap_private.TransactionID_str)){
+ if ((!pinfo->fd->visited)&&(ansi_tcap_private.TransactionID_str)){
/* Only do this once XXX I hope it's the right thing to do */
/* The hash string needs to contain src and dest to distiguish differnt flows */
/* only create a conversation for ATA commands */
conversation = find_or_create_conversation(pinfo);
- if( !(pinfo->fd->flags.visited) ){
+ if( !(pinfo->fd->visited) ){
if(!response){
ata_info_t *tmp_ata_info;
/* first time we see this request so add a struct for request/response
duplicate_result_key result_key = {pinfo->num, ip};
/* Look up existing result */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
result = (address_hash_value *)wmem_map_lookup(duplicate_result_hash_table,
&result_key);
}
gchar *name;
localhost_name_entry_t *localhost_name_entry;
- if (!(!pinfo->fd->flags.visited && bluetooth_data)) return;
+ if (!(!pinfo->fd->visited && bluetooth_data)) return;
while (i < size) {
length = tvb_get_guint8(tvb, offset + i);
2, pkt_cnt);
}
dropped_packets = FALSE;
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
/*
* This isn't the first pass, so we can't use the global
* "packet_count" variable to determine whether there were
tap_queue_packet(btatt_tap_handles, pinfo, tap_handles);
}
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
wmem_tree_key_t key[5];
guint32 frame_number;
handle_data_t *handle_data;
proto_tree_add_item(main_tree, hf_btatt_client_rx_mtu, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
request_parameters.mtu.mtu = tvb_get_guint16(tvb, offset - 2, ENC_LITTLE_ENDIAN);
case 0x03: /* Exchange MTU Response */
col_append_fstr(pinfo->cinfo, COL_INFO, ", Server Rx MTU: %u", tvb_get_letohs(tvb, offset));
proto_tree_add_item(main_tree, hf_btatt_server_rx_mtu, tvb, offset, 2, ENC_LITTLE_ENDIAN);
- if (!pinfo->fd->flags.visited && request_data && bluetooth_data) {
+ if (!pinfo->fd->visited && request_data && bluetooth_data) {
guint new_mtu;
new_mtu = tvb_get_guint16(tvb, offset, ENC_LITTLE_ENDIAN);
proto_tree_add_item(main_tree, hf_btatt_ending_handle, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
request_parameters.find_information.starting_handle = tvb_get_guint16(tvb, offset - 4, ENC_LITTLE_ENDIAN);
dissect_attribute_value(main_tree, NULL, pinfo, tvb, offset, tvb_captured_length_remaining(tvb, offset), 0, uuid, &att_data);
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
request_parameters.read_by_type.starting_handle = tvb_get_guint16(tvb, offset - 6, ENC_LITTLE_ENDIAN);
proto_tree_add_item(main_tree, hf_btatt_uuid16, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
request_parameters.read_by_type.starting_handle = tvb_get_guint16(tvb, offset - 6, ENC_LITTLE_ENDIAN);
&bluetooth_uuid_vals_ext, "<unknown>"));
offset += 16;
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
request_parameters.read_by_type.starting_handle = tvb_get_guint16(tvb, offset - 20, ENC_LITTLE_ENDIAN);
col_append_info_by_handle(pinfo, handle, bluetooth_data);
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
request_parameters.read_write.handle = handle;
if (is_long_attribute_value(uuid) && tvb_captured_length(tvb) >= mtu) {
sub_item = proto_tree_add_item(main_tree, hf_btatt_value, tvb, offset, -1, ENC_NA);
- if (!pinfo->fd->flags.visited && request_data && bluetooth_data)
+ if (!pinfo->fd->visited && request_data && bluetooth_data)
save_value_fragment(pinfo, tvb, offset, request_data->parameters.read_write.handle, 0, bluetooth_data);
offset = tvb_captured_length(tvb);
dissect_attribute_value(main_tree, NULL, pinfo, tvb, offset, 0, handle, uuid, &att_data);
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
request_parameters.read_write.handle = handle;
if (request_data->parameters.read_write.offset == 0 && !is_long_attribute_value(uuid)) {
offset = dissect_attribute_value(main_tree, NULL, pinfo, tvb, offset, tvb_captured_length_remaining(tvb, offset), request_data->parameters.read_write.handle, uuid, &att_data);
} else {
- if (!pinfo->fd->flags.visited && bluetooth_data)
+ if (!pinfo->fd->visited && bluetooth_data)
save_value_fragment(pinfo, tvb, offset, request_data->parameters.read_write.handle, request_data->parameters.read_write.offset, bluetooth_data);
if (tvb_captured_length(tvb) < mtu) {
dissect_attribute_value(main_tree, NULL, pinfo, tvb, offset, 0, handle, uuid, &att_data);
}
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
request_parameters.read_multiple.number_of_handles = (tvb_captured_length(tvb) - 1) / 2;
offset = dissect_attribute_value(main_tree, NULL, pinfo, tvb, offset, tvb_captured_length_remaining(tvb, offset), tvb_get_guint16(tvb, offset - 2, ENC_LITTLE_ENDIAN), uuid, &att_data);
- if (!pinfo->fd->flags.visited && bluetooth_data && (opcode == 0x12 || opcode == 0x1d)) {
+ if (!pinfo->fd->visited && bluetooth_data && (opcode == 0x12 || opcode == 0x1d)) {
union request_parameters_union request_parameters;
request_parameters.read_write.handle = handle;
proto_tree_add_item(main_tree, hf_btatt_offset, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
- if (!pinfo->fd->flags.visited && bluetooth_data && opcode == 0x16) {
+ if (!pinfo->fd->visited && bluetooth_data && opcode == 0x16) {
union request_parameters_union request_parameters;
request_parameters.data = NULL;
save_request(pinfo, opcode, request_parameters, bluetooth_data);
}
- if (!pinfo->fd->flags.visited && request_data && bluetooth_data && opcode == 0x16)
+ if (!pinfo->fd->visited && request_data && bluetooth_data && opcode == 0x16)
save_value_fragment(pinfo, tvb, offset,
tvb_get_guint16(tvb, offset - 4, ENC_LITTLE_ENDIAN),
tvb_get_guint16(tvb, offset - 2, ENC_LITTLE_ENDIAN),
proto_tree_add_item(main_tree, hf_btatt_flags, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset++;
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
union request_parameters_union request_parameters;
/* NOTE: Enable request-response tracking using empty data*/
PROTO_ITEM_SET_GENERATED(sub_item);
}
- if (!pinfo->fd->flags.visited && request_data->response_in_frame == 0 &&
+ if (!pinfo->fd->visited && request_data->response_in_frame == 0 &&
pinfo->num > request_data->request_in_frame)
request_data->response_in_frame = pinfo->num;
key[5].key = NULL;
if (packet_type == PACKET_TYPE_START) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
fragment = wmem_new(wmem_file_scope(), fragment_t);
fragment->length = length;
fragment->data = (guint8 *) wmem_alloc(wmem_file_scope(), fragment->length);
fragments->psm == psm))
fragments = NULL;
- if (!pinfo->fd->flags.visited && fragments != NULL) {
+ if (!pinfo->fd->visited && fragments != NULL) {
fragment = wmem_new(wmem_file_scope(), fragment_t);
fragment->length = length;
fragment->data = (guint8 *) wmem_alloc(wmem_file_scope(), fragment->length);
fragments->psm == psm))
fragments = NULL;
- if (!pinfo->fd->flags.visited && fragments != NULL) {
+ if (!pinfo->fd->visited && fragments != NULL) {
fragment = wmem_new(wmem_file_scope(), fragment_t);
fragment->length = length;
fragment->data = (guint8 *) wmem_alloc(wmem_file_scope(), fragment->length);
proto_tree_add_item(sep_tree, hf_btavdtp_sep_type , tvb, offset, 1, ENC_NA);
proto_tree_add_item(sep_tree, hf_btavdtp_sep_rfa1 , tvb, offset, 1, ENC_NA);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
sep_entry_t *sep_data;
wmem_tree_key_t key[7];
guint32 frame_number = pinfo->num;
channels_info->adapter_disconnect_in_frame = l2cap_data->adapter_disconnect_in_frame;
channels_info->sep = NULL;
- if (!pinfo->fd->flags.visited || (
+ if (!pinfo->fd->visited || (
*channels_info->adapter_disconnect_in_frame == 0 ||
*channels_info->hci_disconnect_in_frame == 0 ||
*channels_info->l2cap_disconnect_in_frame == 0 ||
(l2cap_data->local_cid == channels_info->media_local_cid &&
l2cap_data->remote_cid == channels_info->media_remote_cid))) {
- if (!pinfo->fd->flags.visited && channels_info->media_local_cid == BTL2CAP_UNKNOWN_CID) {
+ if (!pinfo->fd->visited && channels_info->media_local_cid == BTL2CAP_UNKNOWN_CID) {
channels_info->media_local_cid = l2cap_data->local_cid;
channels_info->media_remote_cid = l2cap_data->remote_cid;
}
if (media_stream_number_value->stream_start_in_frame == 0)
media_stream_number_value->stream_start_in_frame = pinfo->num;
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
media_stream_number_value->stream_end_in_frame = pinfo->num;
sep_data.stream_start_in_frame = media_stream_number_value->stream_start_in_frame;
if (song_position_data && (song_position_data->used_in_frame == 0 ||
song_position_data->used_in_frame == frame_number)) {
avrcp_song_position = song_position_data->song_position;
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
song_position_data->used_in_frame = frame_number;
}
sep_data.previous_media_packet_info->stream_number = sep_data.stream_number;
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
key[5].length = 1;
key[5].key = &frame_number;
key[6].length = 0;
&codec, &content_protection_type, &vendor_id,
&vendor_codec, &configuration_offset, &configuration_length);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
key[0].length = 1;
key[0].key = &interface_id;
key[1].length = 1;
&codec, &content_protection_type, &vendor_id,
&vendor_codec, &configuration_offset, &configuration_length);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
key[0].length = 1;
key[0].key = &interface_id;
key[1].length = 1;
SEID_ACP, 0, &seid, interface_id,
adapter_id, chandle, frame_number);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
key[0].length = 1;
key[0].key = &interface_id;
key[1].length = 1;
offset += 1;
break;
}
- if (message_type == MESSAGE_TYPE_ACCEPT && !pinfo->fd->flags.visited) {
+ if (message_type == MESSAGE_TYPE_ACCEPT && !pinfo->fd->visited) {
key[0].length = 1;
key[0].key = &interface_id;
break;
}
- if (message_type == MESSAGE_TYPE_ACCEPT && !pinfo->fd->flags.visited) {
+ if (message_type == MESSAGE_TYPE_ACCEPT && !pinfo->fd->visited) {
media_stream_number_value_t *media_stream_number_value;
guint32 stream_number = 0;
offset += 1;
break;
}
- if (!pinfo->fd->flags.visited && message_type == MESSAGE_TYPE_ACCEPT &&
+ if (!pinfo->fd->visited && message_type == MESSAGE_TYPE_ACCEPT &&
channels_info->disconnect_in_frame > pinfo->num) {
channels_info->disconnect_in_frame = pinfo->num;
}
offset += 1;
break;
}
- if (!pinfo->fd->flags.visited && message_type == MESSAGE_TYPE_ACCEPT &&
+ if (!pinfo->fd->visited && message_type == MESSAGE_TYPE_ACCEPT &&
channels_info->disconnect_in_frame > pinfo->num) {
channels_info->disconnect_in_frame = pinfo->num;
}
pitem = proto_tree_add_double(aptx_tree, hf_aptx_delta_time_from_the_beginning, tvb, 0, 0, nstime_to_msec(&delta));
PROTO_ITEM_SET_GENERATED(pitem);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
info->current_media_packet_info->cumulative_frame_duration += cumulative_frame_duration;
pitem = proto_tree_add_double(aptx_tree, hf_aptx_cumulative_duration, tvb, 0, 0, info->previous_media_packet_info->cumulative_frame_duration);
length = tvb_reported_length_remaining(tvb, offset);
if (packet_type == PACKET_TYPE_START) {
- if (pinfo->fd->flags.visited == 0 && tvb_captured_length_remaining(tvb, offset) == length) {
+ if (pinfo->fd->visited == 0 && tvb_captured_length_remaining(tvb, offset) == length) {
k_op = pdu_id | (company_id << 8);
frame_number = pinfo->num;
col_append_str(pinfo->cinfo, COL_INFO, " [start]");
return offset;
} else if (packet_type == PACKET_TYPE_CONTINUE) {
- if (pinfo->fd->flags.visited == 0 && tvb_captured_length_remaining(tvb, offset) == length) {
+ if (pinfo->fd->visited == 0 && tvb_captured_length_remaining(tvb, offset) == length) {
k_op = pdu_id | (company_id << 8);
frame_number = pinfo->num;
fragment->op == (pdu_id | (company_id << 8))) {
- if (fragment->state == 1 && pinfo->fd->flags.visited == 0) {
+ if (fragment->state == 1 && pinfo->fd->visited == 0) {
fragment->end_frame_number = pinfo->num;
fragment->count += 1;
fragment->state = 2;
if (song_position == 0xFFFFFFFF) {
proto_item_append_text(pitem, " (NOT SELECTED)");
col_append_str(pinfo->cinfo, COL_INFO, " (NOT SELECTED)");
- } else if (!pinfo->fd->flags.visited) {
+ } else if (!pinfo->fd->visited) {
btavrcp_song_position_data_t *song_position_data;
frame_number = pinfo->num;
val_to_str_const(tvb_get_guint8(tvb, offset), pdu_id_vals, "Unknown opcode"));
offset += 1;
- if (pinfo->fd->flags.visited == 0) {
+ if (pinfo->fd->visited == 0) {
k_op = continuing_op;
frame_number = pinfo->num;
val_to_str_const(tvb_get_guint8(tvb, offset), pdu_id_vals, "Unknown opcode"));
offset += 1;
- if (pinfo->fd->flags.visited == 0) {
+ if (pinfo->fd->visited == 0) {
k_op = continuing_op;
frame_number = pinfo->num;
key[8].length = 0;
key[8].key = NULL;
- if (pinfo->fd->flags.visited == 0) {
+ if (pinfo->fd->visited == 0) {
if (is_command) {
if (ctype == 0x00) { /* MTC is for CONTROL */
max_response_time = 200;
subtree = (wmem_tree_t *) wmem_tree_lookup32_array(chandle_tree, key);
chandle_data = (subtree) ? (chandle_data_t *) wmem_tree_lookup32_le(subtree, pinfo->num) : NULL;
- if (!pinfo->fd->flags.visited && !chandle_data) {
+ if (!pinfo->fd->visited && !chandle_data) {
key[0].length = 1;
key[0].key = &interface_id;
key[1].length = 1;
chandle_data->start_fragments = wmem_tree_new(wmem_file_scope());
wmem_tree_insert32_array(chandle_tree, key, chandle_data);
- } else if (pinfo->fd->flags.visited && !chandle_data) {
+ } else if (pinfo->fd->visited && !chandle_data) {
DISSECTOR_ASSERT_HINT(0, "Impossible: no previously session saved");
}
gint len;
if (!(pb_flag & 0x01)) { /* first fragment */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
mfp = (multi_fragment_pdu_t *) wmem_new(wmem_file_scope(), multi_fragment_pdu_t);
mfp->first_frame = pinfo->num;
mfp->last_frame = 0;
}
if (pb_flag == 0x01) { /* continuation fragment */
mfp = (multi_fragment_pdu_t *)wmem_tree_lookup32_le(chandle_data->start_fragments, pinfo->num);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
len = tvb_captured_length_remaining(tvb, offset);
if (mfp != NULL && !mfp->last_frame && (mfp->tot_len >= mfp->cur_off + len)) {
tvb_memcpy(tvb, (guint8 *) mfp->reassembled + mfp->cur_off, offset, len);
expert_add_info(pinfo, bthci_acl_item, &ei_invalid_session);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
addr = (address *) wmem_memdup(wmem_file_scope(), &pinfo->dl_src, sizeof(address));
proto_tree_add_item(tree, hf_bthci_cmd_allow_role_switch, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset++;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
guint32 interface_id;
guint32 adapter_id;
guint32 bd_addr_oui;
proto_tree_add_item(tree, hf_bthci_cmd_acr_role, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
guint32 interface_id;
guint32 adapter_id;
guint32 bd_addr_oui;
case 0x0013: /* Change Local Name */
proto_tree_add_item(tree, hf_bthci_cmd_device_name, tvb, offset, 248, ENC_UTF_8 | ENC_NA);
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.name = tvb_get_string_enc(wmem_file_scope(), tvb, offset, 248, ENC_UTF_8);
}
offset += 248;
} else {
proto_item_append_text(item, " Illegal Page Timeout");
}
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.page_timeout = timeout;
}
offset+=2;
case 0x001a: /* Write Scan Enable */
proto_tree_add_item(tree, hf_bthci_cmd_scan_enable,
tvb, offset, 1, ENC_LITTLE_ENDIAN);
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.scan = tvb_get_guint8(tvb, offset);
}
offset++;
case 0x0020: /* Write Authentication Enable */
proto_tree_add_item(tree, hf_bthci_cmd_authentication_enable,
tvb, offset, 1, ENC_LITTLE_ENDIAN);
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.authentication = tvb_get_guint8(tvb, offset);
}
offset++;
case 0x0022: /* Write Encryption Mode */
proto_tree_add_item(tree, hf_bthci_cmd_encrypt_mode, tvb, offset, 1, ENC_LITTLE_ENDIAN);
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.encryption = tvb_get_guint8(tvb, offset);
}
offset++;
case 0x0024: /* Write Class of Device */
call_dissector(btcommon_cod_handle, tvb_new_subset_length(tvb, offset, 3), pinfo, tree);
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.class_of_device = tvb_get_guint24(tvb, offset, ENC_LITTLE_ENDIAN);
}
offset += 3;
tvb, offset, 2, ENC_LITTLE_ENDIAN);
proto_tree_add_item(tree, hf_bthci_cmd_air_coding_format,
tvb, offset, 2, ENC_LITTLE_ENDIAN);
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.voice_setting = tvb_get_guint16(tvb, offset, ENC_LITTLE_ENDIAN);
}
offset+=2;
tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset+=2;
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.mtus.acl_mtu = tvb_get_guint16(tvb, offset - 7, ENC_LITTLE_ENDIAN);
bthci_cmd_data->data.mtus.sco_mtu = tvb_get_guint8(tvb, offset - 5);
bthci_cmd_data->data.mtus.acl_packets = tvb_get_guint16(tvb, offset - 4, ENC_LITTLE_ENDIAN);
case 0x0045: /* Write Inquiry Mode */
proto_tree_add_item(tree, hf_bthci_cmd_inq_mode, tvb, offset, 1, ENC_LITTLE_ENDIAN);
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.inquiry_mode = tvb_get_guint8(tvb, offset);
}
offset++;
case 0x0056: /* Write Simple Pairing Mode */
proto_tree_add_item(tree, hf_bthci_cmd_simple_pairing_mode, tvb, offset, 1, ENC_LITTLE_ENDIAN);
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
bthci_cmd_data->data.simple_pairing_mode = tvb_get_guint8(tvb, offset);
}
offset++;
set_address(&pinfo->net_dst, AT_STRINGZ, 11, "controller");
set_address(&pinfo->dl_src, AT_STRINGZ, 5, "host");
set_address(&pinfo->dl_dst, AT_STRINGZ, 11, "controller");
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
addr = (address *) wmem_memdup(wmem_file_scope(), &pinfo->dl_src, sizeof(address));
tap_queue_packet(bluetooth_hci_summary_tap, pinfo, tap_hci_summary);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
bthci_cmd_data = (bthci_cmd_data_t *) wmem_new(wmem_file_scope(), bthci_cmd_data_t);
bthci_cmd_data->opcode = opcode;
bthci_cmd_data->command_in_frame = frame_number;
}
}
- if (!pinfo->fd->flags.visited && bthci_cmd_data) {
+ if (!pinfo->fd->visited && bthci_cmd_data) {
key[0].length = 1;
key[0].key = &interface_id;
key[1].length = 1;
gchar *name;
device_name_t *device_name;
- if (!(!pinfo->fd->flags.visited && bd_addr)) return;
+ if (!(!pinfo->fd->visited && bd_addr)) return;
interface_id = bluetooth_data->interface_id;
adapter_id = bluetooth_data->adapter_id;
offset += 2;
offset = dissect_bd_addr(hf_bthci_evt_bd_addr, pinfo, tree, tvb, offset, FALSE, bluetooth_data->interface_id, bluetooth_data->adapter_id, bd_addr);
- if (!pinfo->fd->flags.visited && status == STATUS_SUCCESS) {
+ if (!pinfo->fd->visited && status == STATUS_SUCCESS) {
wmem_tree_key_t key[5];
guint32 k_interface_id;
guint32 k_adapter_id;
send_hci_summary_reason_tap(tvb_get_guint8(tvb, offset), pinfo, bluetooth_data);
offset += 1;
- if (!pinfo->fd->flags.visited && status == STATUS_SUCCESS) {
+ if (!pinfo->fd->visited && status == STATUS_SUCCESS) {
wmem_tree_key_t key[4];
guint32 interface_id;
guint32 adapter_id;
offset = dissect_bd_addr(hf_bthci_evt_bd_addr, pinfo, tree, tvb, offset, FALSE, bluetooth_data->interface_id, bluetooth_data->adapter_id, bd_addr);
proto_tree_add_item(tree, hf_bthci_evt_remote_name, tvb, offset, 248, ENC_UTF_8|ENC_NA);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
wmem_tree_key_t key[6];
guint32 interface_id;
guint32 adapter_id;
proto_item_append_text(handle_item, " Baseband slots (%f msec)", tvb_get_letohs(tvb, offset)*0.625);
offset += 2;
- if (!pinfo->fd->flags.visited && status == STATUS_SUCCESS) {
+ if (!pinfo->fd->visited && status == STATUS_SUCCESS) {
wmem_tree_key_t key[5];
guint32 interface_id;
guint32 adapter_id;
role = tvb_get_guint8(tvb, offset);
offset += 1;
- if (!pinfo->fd->flags.visited && status == STATUS_SUCCESS) {
+ if (!pinfo->fd->visited && status == STATUS_SUCCESS) {
guint32 interface_id;
guint32 adapter_id;
guint32 bd_addr_oui;
proto_tree_add_item(tree, hf_bthci_evt_le_master_clock_accuracy, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
- if (!pinfo->fd->flags.visited && status == STATUS_SUCCESS) {
+ if (!pinfo->fd->visited && status == STATUS_SUCCESS) {
wmem_tree_key_t key[5];
guint32 k_interface_id;
guint32 k_adapter_id;
proto_tree_add_item(tree, hf_bthci_evt_le_master_clock_accuracy, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
- if (!pinfo->fd->flags.visited && status == STATUS_SUCCESS) {
+ if (!pinfo->fd->visited && status == STATUS_SUCCESS) {
wmem_tree_key_t key[5];
guint32 k_interface_id;
guint32 k_adapter_id;
offset += 1;
offset = dissect_bd_addr(hf_bthci_evt_bd_addr, pinfo, tree, tvb, offset, local_addr, bluetooth_data->interface_id, bluetooth_data->adapter_id, bd_addr);
- if (!pinfo->fd->flags.visited && local_addr) {
+ if (!pinfo->fd->visited && local_addr) {
localhost_bdaddr_entry_t *localhost_bdaddr_entry;
interface_id = bluetooth_data->interface_id;
offset += 1;
proto_tree_add_item(tree, hf_bthci_evt_device_name, tvb, offset, 248, ENC_UTF_8|ENC_NA);
- if (status == STATUS_SUCCESS && !pinfo->fd->flags.visited) {
+ if (status == STATUS_SUCCESS && !pinfo->fd->visited) {
gchar *name;
localhost_name_entry_t *localhost_name_entry;
}
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
hci_vendor_data_t *new_hci_vendor_data;
adapter_id = bluetooth_data->adapter_id;
frame_number = pinfo->num;
- if (!pinfo->fd->flags.visited && status == STATUS_SUCCESS) {
+ if (!pinfo->fd->visited && status == STATUS_SUCCESS) {
remote_bdaddr_t *remote_bdaddr;
chandle_session_t *chandle_session;
bthci_sco_stream_number_t *sco_stream_number;
set_address(&pinfo->net_dst, AT_STRINGZ, 5, "host");
set_address(&pinfo->dl_src, AT_STRINGZ, 11, "controller");
set_address(&pinfo->dl_dst, AT_STRINGZ, 5, "host");
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
addr = (address *) wmem_memdup(wmem_file_scope(), &pinfo->dl_src, sizeof(address));
tap_device->data.name = lastest_bthci_cmd_data->data.name;
tap_queue_packet(bluetooth_device_tap, pinfo, tap_device);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
localhost_name_entry_t *localhost_name_entry;
wmem_tree_key_t key[4];
guint32 interface_id;
}
}
- if (!pinfo->fd->flags.visited && opcode_list_data->command_status == COMMAND_STATUS_PENDING &&
+ if (!pinfo->fd->visited && opcode_list_data->command_status == COMMAND_STATUS_PENDING &&
lastest_bthci_cmd_data->pending_in_frame == max_disconnect_in_frame) {
lastest_bthci_cmd_data->pending_in_frame = frame_number;
lastest_bthci_cmd_data->pending_abs_ts = pinfo->abs_ts;
}
- if (!pinfo->fd->flags.visited && opcode_list_data->command_status == COMMAND_STATUS_NORMAL &&
+ if (!pinfo->fd->visited && opcode_list_data->command_status == COMMAND_STATUS_NORMAL &&
lastest_bthci_cmd_data->response_in_frame == max_disconnect_in_frame) {
lastest_bthci_cmd_data->response_in_frame = frame_number;
lastest_bthci_cmd_data->response_abs_ts = pinfo->abs_ts;
}
- if (!pinfo->fd->flags.visited && opcode_list_data->command_status == COMMAND_STATUS_RESULT &&
+ if (!pinfo->fd->visited && opcode_list_data->command_status == COMMAND_STATUS_RESULT &&
lastest_bthci_cmd_data->response_in_frame == max_disconnect_in_frame &&
lastest_bthci_cmd_data->pending_in_frame == max_disconnect_in_frame) {
lastest_bthci_cmd_data->response_in_frame = frame_number;
/* TODO: This is command, but in respose (event Command Complete) there is a status for that,
so write bdaddr can fail, but we store bdaddr as valid for now... */
- if (!pinfo->fd->flags.visited && bluetooth_data) {
+ if (!pinfo->fd->visited && bluetooth_data) {
wmem_tree_key_t key[4];
guint32 frame_number;
localhost_bdaddr_entry_t *localhost_bdaddr_entry;
}
/* save fragments */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
frame_number = pinfo->num - 1;
key[0].length = 1;
/* TODO: Save bthsp.at_cmd, bthsp.at_cmd.type, frame_time and frame_num here in
- if (role == ROLE_HS && pinfo->fd->flags.visited == 0) {
+ if (role == ROLE_HS && pinfo->fd->visited == 0) {
at_cmd_db = wmem_tree_new_autoreset(wmem_epan_scope(), wmem_file_scope());
}
/* save fragments */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
frame_number = pinfo->num - 1;
key[0].length = 1;
offset += 1;
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
wmem_tree_key_t key[6];
guint32 k_interface_id;
guint32 k_adapter_id;
proto_tree_add_item(command_tree, hf_btl2cap_initial_credits, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
wmem_tree_key_t key[6];
guint32 k_interface_id;
guint32 k_adapter_id;
offset += 2;
- if (pinfo->fd->flags.visited == 0) {
+ if (pinfo->fd->visited == 0) {
psm_data_t *psm_data;
wmem_tree_key_t key[6];
guint32 k_interface_id;
val_to_str_const(result, result_vals, "Unknown"), scid);
}
- if (pinfo->fd->flags.visited == 0) {
+ if (pinfo->fd->visited == 0) {
psm_data_t *psm_data;
wmem_tree_key_t key[6];
guint32 k_interface_id;
proto_tree_add_item(command_tree, hf_btl2cap_scid, tvb, offset, 2, ENC_LITTLE_ENDIAN);
offset += 2;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
psm_data_t *psm_data;
wmem_tree_key_t key[6];
guint32 k_interface_id;
btl2cap_frame_data_t *btl2cap_frame_data = NULL;
fragment_head *frag_btl2cap_le_sdu = NULL;
- if ((!pinfo->fd->flags.visited) && (config_data) && !is_retransmit) {
+ if ((!pinfo->fd->visited) && (config_data) && !is_retransmit) {
btl2cap_frame_data = wmem_new0(wmem_file_scope(), btl2cap_frame_data_t);
if (config_data->segmentation_started == 1) {
config_data->segment_len_rem = config_data->segment_len_rem - length;
"SDU length less than length of first packet (%u < %u)", sdulen, length);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
mfp = wmem_new(wmem_file_scope(), sdu_reassembly_t);
mfp->first_frame = pinfo->num;
mfp->last_frame = 0;
}
if (segment == 0x02 || segment == 0x03) {
mfp = (sdu_reassembly_t *)wmem_tree_lookup32_le(config_data->start_fragments, pinfo->num);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (mfp != NULL && !mfp->last_frame && (mfp->tot_len>=mfp->cur_off + length)) {
tvb_memcpy(tvb, mfp->reassembled + mfp->cur_off, offset, length);
mfp->cur_off += length;
copy_address_shallow(&pinfo->dl_dst, &pinfo->net_dst);
copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
addr = (address *) wmem_memdup(wmem_file_scope(), &pinfo->dl_src, sizeof(address));
copy_address_shallow(&pinfo->dl_dst, &pinfo->net_dst);
copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
addr = (address *) wmem_memdup(wmem_file_scope(), &pinfo->dl_src, sizeof(address));
copy_address_shallow(&pinfo->dl_dst, &pinfo->net_dst);
copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
addr = (address *) wmem_memdup(wmem_file_scope(), &pinfo->dl_src, sizeof(address));
copy_address_shallow(&pinfo->dl_dst, &pinfo->net_dst);
copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
addr = (address *) wmem_memdup(wmem_file_scope(), &pinfo->dl_src, sizeof(address));
copy_address_shallow(&pinfo->dl_dst, &pinfo->net_dst);
copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
addr = (address *) wmem_memdup(wmem_file_scope(), &pinfo->dl_src, sizeof(address));
proto_tree_add_item(link_layer_data_tree, hf_link_layer_data_sleep_clock_accuracy, tvb, offset, 1, ENC_LITTLE_ENDIAN);
offset += 1;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
key[0].length = 1;
key[0].key = &interface_id;
key[1].length = 1;
set_address(&pinfo->net_dst, AT_STRINGZ, (int)strlen(str_addr_dst)+1, str_addr_dst);
copy_address_shallow(&pinfo->dst, &pinfo->net_dst);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
address *addr;
btle_frame_info = wmem_new0(wmem_file_scope(), btle_frame_info_t);
pinfo->fragmented = TRUE;
if (connection_info && !retransmit) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (connection_info->direction_info[direction].segmentation_started == 1) {
if (connection_info->direction_info[direction].segment_len_rem >= length) {
connection_info->direction_info[direction].segment_len_rem = connection_info->direction_info[direction].segment_len_rem - length;
if (le_frame_len > length) {
pinfo->fragmented = TRUE;
if (connection_info && !retransmit) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
connection_info->direction_info[direction].segmentation_started = 1;
/* The first two octets in the L2CAP PDU contain the length of the entire
* L2CAP PDU in octets, excluding the Length and CID fields(4 octets).
bthci_acl_data_t *acl_data;
if (connection_info) {
/* Add a L2CAP index for completeness */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
btle_frame_info->l2cap_index = l2cap_index;
l2cap_index++;
}
key[4].length = 1;
key[4].key = &k_dlci;
- if (!pinfo->fd->flags.visited && frame_type == FRAME_TYPE_SABM) {
+ if (!pinfo->fd->visited && frame_type == FRAME_TYPE_SABM) {
key[5].length = 0;
key[5].key = NULL;
} else if (length == 1 && tvb_get_guint8(tvb, offset) == 0x00) {
if (is_continued) *is_continued = FALSE;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (is_request) {
tid_request = (tid_request_t *) wmem_new(wmem_file_scope(), tid_request_t);
tid_request->interface_id = interface_id;
continuation_state_buffer = tvb_bytes_to_str(wmem_file_scope(), tvb, offset, continuation_state_length);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (is_request) {
tid_request = (tid_request_t *) wmem_new(wmem_file_scope(), tid_request_t);
tid_request->interface_id = interface_id;
proto_item_append_text(feature_item, ", PSM: %u", value);
proto_item_append_text(entry_item, ", PSM: %u", value);
proto_tree_add_item(sub_tree, hf_sdp_protocol_psm, tvb, entry_offset, 2, ENC_BIG_ENDIAN);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
record = save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, value, *protocol_order, service_info);
*protocol_order += 1;
} else if (uuid.bt_uuid == BTSDP_RFCOMM_PROTOCOL_UUID) {
proto_item_append_text(feature_item, ", RFCOMM Channel: %u", value);
proto_item_append_text(entry_item, ", RFCOMM Channel: %u", value);
proto_tree_add_item(sub_tree, hf_sdp_protocol_channel, tvb, entry_offset, 1, ENC_BIG_ENDIAN);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
record = save_channel(pinfo, BTSDP_RFCOMM_PROTOCOL_UUID, value, *protocol_order, service_info);
*protocol_order += 1;
} else if (uuid.bt_uuid == BTSDP_ATT_PROTOCOL_UUID) {
proto_tree_add_item(next_tree, hf_pbap_goep_l2cap_psm, tvb, offset, 2, ENC_BIG_ENDIAN);
psm = tvb_get_ntohs(tvb, offset);
wmem_strbuf_append_printf(info_buf, "%u (0x%02x)", psm, psm);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, psm, -1, service_info);
break;
case 0x314:
proto_tree_add_item(next_tree, hf_ftp_goep_l2cap_psm, tvb, offset, 2, ENC_BIG_ENDIAN);
psm = tvb_get_ntohs(tvb, offset);
wmem_strbuf_append_printf(info_buf, "%u (0x%02x)", psm, psm);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, psm, -1, service_info);
break;
default:
proto_tree_add_item(next_tree, hf_map_mas_goep_l2cap_psm, tvb, offset, 2, ENC_BIG_ENDIAN);
psm = tvb_get_ntohs(tvb, offset);
wmem_strbuf_append_printf(info_buf, "%u (0x%02x)", psm, psm);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, psm, -1, service_info);
break;
case 0x315:
proto_tree_add_item(next_tree, hf_map_mns_goep_l2cap_psm, tvb, offset, 2, ENC_BIG_ENDIAN);
psm = tvb_get_ntohs(tvb, offset);
wmem_strbuf_append_printf(info_buf, "%u (0x%02x)", psm, psm);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, psm, -1, service_info);
break;
case 0x317:
proto_tree_add_item(next_tree, hf_opp_goep_l2cap_psm, tvb, offset, 2, ENC_BIG_ENDIAN);
psm = tvb_get_ntohs(tvb, offset);
wmem_strbuf_append_printf(info_buf, "%u (0x%02x)", psm, psm);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, psm, -1, service_info);
break;
case 0x303:
proto_tree_add_item(next_tree, hf_bip_goep_l2cap_psm, tvb, offset, 2, ENC_BIG_ENDIAN);
psm = tvb_get_ntohs(tvb, offset);
wmem_strbuf_append_printf(info_buf, "%u (0x%02x)", psm, psm);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, psm, -1, service_info);
break;
case 0x310:
proto_tree_add_item(next_tree, hf_bip_goep_l2cap_psm, tvb, offset, 2, ENC_BIG_ENDIAN);
psm = tvb_get_ntohs(tvb, offset);
wmem_strbuf_append_printf(info_buf, "%u (0x%02x)", psm, psm);
- if (!pinfo->fd->flags.visited && service_info)
+ if (!pinfo->fd->visited && service_info)
save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, psm, -1, service_info);
break;
case 0x312:
proto_tree_add_item(next_tree, hf_bip_goep_l2cap_psm, tvb, offset, 2, ENC_BIG_ENDIAN);
psm = tvb_get_ntohs(tvb, offset);
wmem_strbuf_append_printf(info_buf, "%u (0x%02x)", psm, psm);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
save_channel(pinfo, BTSDP_L2CAP_PROTOCOL_UUID, psm, -1, service_info);
break;
case 0x312:
if (uuid.size == 0 && service_uuid)
uuid = *service_uuid;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
service_info = (service_info_t *) wmem_new(wmem_file_scope(), service_info_t);
service_info->interface_id = l2cap_data->interface_id;
service_info->adapter_id = l2cap_data->adapter_id;
uuid, service_offset, service_info, number_of_attributes, FALSE);
}
- if (!pinfo->fd->flags.visited && service_info) {
+ if (!pinfo->fd->visited && service_info) {
k_interface_id = l2cap_data->interface_id;
k_adapter_id = l2cap_data->adapter_id;
k_sdp_psm = l2cap_data->psm;
start_offset = offset;
memset(&empty_uuid, 0, sizeof(bluetooth_uuid_t));
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
uuid_array = wmem_array_new(wmem_file_scope(), sizeof(bluetooth_uuid_t));
ti = proto_tree_add_item(tree, hf_service_search_pattern, tvb, offset, 0, ENC_NA);
current_count * 4, "Service Record Handle List [count = %u]", current_count);
st = proto_item_add_subtree(ti, ett_btsdp_ssr);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
record_handle_array = wmem_array_new(wmem_packet_scope(), sizeof(guint32));
while (current_count > 0) {
if (is_continued)
col_append_str(pinfo->cinfo, COL_INFO, "(fragment)");
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
record_handle_service_t *record_handle_service;
wmem_tree_key_t key[7];
guint32 k_interface_id;
bluetooth_uuid_t uuid;
memset(&empty_uuid, 0, sizeof(bluetooth_uuid_t));
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
uuid_array = wmem_array_new(wmem_file_scope(), sizeof(bluetooth_uuid_t));
else
uuid_array = wmem_array_new(wmem_packet_scope(), sizeof(bluetooth_uuid_t));
d->conv = find_or_create_conversation(pinfo);
DISSECTOR_ASSERT_HINT(d->conv, "find_or_create_conversation() returned NULL");
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
/* Retrieve the saved state. */
d->convd = (c_conv_data*)p_get_proto_data(wmem_file_scope(), pinfo,
static
void c_pkt_data_save(c_pkt_data *d, packet_info *pinfo, guint off)
{
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
/*
Save a copy of the state for next time we dissect this packet.
epath_tree = proto_tree_add_subtree(cmd_tree, tvb, offset+26+net_param_offset+6, conn_path_size, ett_path, &pi, "Connection Path: ");
dissect_epath( tvb, pinfo, epath_tree, pi, offset+26+net_param_offset+6, conn_path_size, FALSE, FALSE, &connection_path, &safety_fwdopen, DISPLAY_CONNECTION_PATH, NULL, FALSE);
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
/* "Connection" is created during ForwardOpen reply (which will be after ForwardOpen request),
so ForwardOpen request can only be marked after the first pass */
/* See if we've captured the ForwardOpen request. If so some of the conversation data has already been
populated and we just need to update it. */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
return parsed_len + app_rep_size;
if ((preq_info != NULL) && (preq_info->connInfo != NULL))
hf_cip_cm_conn_serial_num, hf_cip_cm_vendor, hf_cip_cm_orig_serial_num,
&conn_triad);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
enip_mark_connection_triad(pinfo, &conn_triad);
/* Add the path size */
if (compute_crc)
{
/* Determine if packet timestamp results in rollover count increment */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
if ((timestamp != 0) && (timestamp < safety_info->eip_conn_info->safety.running_timestamp_value))
{
if (compute_crc)
{
/* Determine if packet timestamp results in rollover count increment */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
if ((timestamp != 0) && (timestamp < safety_info->eip_conn_info->safety.running_timestamp_value))
{
conversation_add_proto_data(conversation, proto_classicstun, classicstun_info);
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if (((msg_type & CLASS_MASK) >> 4) == REQUEST) {
/* This is a request */
classicstun_trans=wmem_new(wmem_file_scope(), classicstun_transaction_t);
wmem_map_insert(cops_conv_info->pdus_tree, GUINT_TO_POINTER(handle_value), pdus_array);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* XXX - yes, we're setting all the fields in this
* structure, but there's padding between op_code
if (pdus_array == NULL) /* There's no request with this handle value */
return offset;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
for (i=0; i < pdus_array->len; i++) {
cops_call = (cops_call_t*)g_ptr_array_index(pdus_array, i);
/* set information for Information column for CP2179 */
col_add_fstr(pinfo->cinfo, COL_INFO, "%s", val_to_str_ext_const(message_type, &cp2179_messagetype_vals_ext, "Unknown Message Type"));
- if (!pinfo->fd->flags.visited){
+ if (!pinfo->fd->visited){
conversation_t *conversation = NULL;
cp2179_conversation *conv_data = NULL;
offset += 4;
/* Track the request/response. */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (server_to_client == 0) {
/* This is a request, add it to this stream tracking */
cql_trans = cql_transaction_add_request(cql_conv, pinfo, stream, 0);
}
/* setup request/response matching */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
wmem_tree_key_t tkey[4];
ctdb_control=wmem_new(wmem_file_scope(), ctdb_control_t);
return offset;
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
ctdb_control->response_in = pinfo->num;
}
offset+=datalen;
/* setup request/response matching */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
wmem_tree_key_t tkey[3];
ctdb_trans=wmem_new(wmem_file_scope(), ctdb_trans_t);
* has been completely constructed. If we've already seen this
* frame, there's nothing to do.
*/
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
return;
if (is_null_pol(policy_hnd))
* has been completely constructed. If we've already seen this
* frame, there's nothing to do.
*/
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
return;
if (is_null_pol(policy_hnd))
* has been completely constructed. If we've already seen this
* frame, there's nothing to do.
*/
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
return;
if (is_null_pol(policy_hnd))
* actual object so just show it as <...> for the time being.
*/
if((param&PIDL_POLHND_OPEN)
- && !pinfo->fd->flags.visited
+ && !pinfo->fd->visited
&& !di->conformant_run){
char *pol_string=NULL;
const char *pol_name=NULL;
}
/* Track this policy handle for the response */
- if(!pinfo->fd->flags.visited
+ if(!pinfo->fd->visited
&& !di->conformant_run){
dcerpc_call_value *dcv;
tvb, offset, pinfo, tree, di, drep, sizeof(guint16),
hf_printerdata_value, TRUE, &value_name);
/* GetPrinterData() stores the printerdata in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(!dcv->se_data && value_name){
dcv->se_data = wmem_strdup(wmem_file_scope(), value_name);
}
hf_printerdata_value, TRUE, &value_name);
/* GetPrinterDataEx() stores the key/value in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(!dcv->se_data){
dcv->se_data = wmem_strdup_printf(wmem_file_scope(),
"%s==%s",
hf_printerdata_value, TRUE, &value_name);
/* GetPrinterDataEx() stores the key/value in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(!dcv->se_data){
dcv->se_data = wmem_strdup(wmem_file_scope(),
value_name?value_name:"");
name = (char *)dcv->private_data;
/* OpenPrinterEx() stores the key/value in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(!dcv->se_data){
dcv->se_data = wmem_strdup(wmem_file_scope(),
name?name:"");
} else {
pol_name = "Unknown OpenPrinterEx() handle";
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcerpc_store_polhnd_name(&policy_hnd, pinfo, pol_name);
}
tvb, offset, pinfo, tree, di, drep, sizeof(guint16),
hf_servername, TRUE, &name);
/* ReplyOpenPrinter() stores the printername in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(!dcv->se_data){
if(name){
dcv->se_data = wmem_strdup(wmem_file_scope(), name);
} else {
pol_name = "Unknown ReplyOpenPrinter() handle";
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcerpc_store_polhnd_name(&policy_hnd, pinfo, pol_name);
}
tvb, offset, pinfo, tree, di, drep, hf_level, &level);
/* GetPrinter() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GINT_TO_POINTER((int)level);
}
tvb, offset, pinfo, tree, di, drep, hf_level, &level);
/* EnumForms() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GINT_TO_POINTER((int)level);
}
} else {
pol_name = "Unknown AddPrinterEx() handle";
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcerpc_store_polhnd_name(&policy_hnd, pinfo, pol_name);
}
tvb, offset, pinfo, tree, di, drep, hf_level, &level);
/* GetPrinter() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GINT_TO_POINTER((int)level);
}
col_append_fstr(pinfo->cinfo, COL_INFO, ", level %d", level);
/* AddForm() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GUINT_TO_POINTER((int)level);
}
tvb, offset, pinfo, tree, di, drep, hf_form_level, &level);
/* GetForm() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GUINT_TO_POINTER((int)level);
}
tvb, offset, pinfo, tree, di, drep, hf_level, &level);
/* EnumJobs() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GUINT_TO_POINTER((int)level);
}
tvb, offset, pinfo, tree, di, drep, hf_level, &level);
/* GetJob() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GUINT_TO_POINTER((int)level);
}
tvb, offset, pinfo, tree, di, drep, hf_level, &level);
/* EnumPrinterDrivers() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GUINT_TO_POINTER((int)level);
}
tvb, offset, pinfo, tree, di, drep, hf_level, &level);
/* GetPrinterDriver2() stores the level in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcv->se_data = GUINT_TO_POINTER((int)level);
}
dn="";
/* OpenSCManager() stores the server\database in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(!dcv->se_data){
dcv->se_data=wmem_strdup_printf(wmem_file_scope(), "%s\\%s",mn,dn);
}
} else {
pol_name = "Unknown OpenSCManagerW() handle";
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcerpc_store_polhnd_name(&policy_hnd, pinfo, pol_name);
}
dn="";
/* OpenSCManager() stores the server\database in se_data */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(!dcv->se_data){
dcv->se_data=wmem_strdup_printf(wmem_file_scope(), "%s\\%s",mn,dn);
}
} else {
pol_name = "Unknown OpenSCManagerW() handle";
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
dcerpc_store_polhnd_name(&policy_hnd, pinfo, pol_name);
}
}
/* Save string to dcv->private_data */
if ((param & PIDL_STR_SAVE)
- && (!pinfo->fd->flags.visited)) {
+ && (!pinfo->fd->visited)) {
dcerpc_call_value *dcv = (dcerpc_call_value *)di->call_data;
dcv->private_data = wmem_strdup(wmem_file_scope(), s);
}
value = di->call_data;
if (di->ptype == PDU_REQ) {
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
if (id > value->max_ptr) {
value->max_ptr = id;
}
match to the interface.
XXX We assume that BINDs will NEVER be fragmented.
*/
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
dcerpc_bind_key *key;
dcerpc_bind_value *value;
and if so dissect the full pdu.
then exit
*/
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
fd_head = fragment_get_reassembled(&dcerpc_co_reassembly_table, frame);
goto end_cn_stub;
}
dcerpc_matched_key matched_key, *new_matched_key;
dcerpc_call_value *value;
- /* !!! we can NOT check flags.visited here since this will interact
+ /* !!! we can NOT check visited here since this will interact
badly with when SMB handles (i.e. calls the subdissector)
and desegmented pdu's .
Instead we check if this pdu is already in the matched table or not
} else {
dcerpc_matched_key matched_key, *new_matched_key;
- /* !!! we can NOT check flags.visited here since this will interact
+ /* !!! we can NOT check visited here since this will interact
badly with when SMB handles (i.e. calls the subdissector)
and desegmented pdu's .
Instead we check if this pdu is already in the matched table or not
} else {
dcerpc_matched_key matched_key, *new_matched_key;
- /* !!! we can NOT check flags.visited here since this will interact
+ /* !!! we can NOT check visited here since this will interact
badly with when SMB handles (i.e. calls the subdissector)
and desegmented pdu's .
Instead we check if this pdu is already in the matched table or not
}
}
if (hdr->flags&PFC_FIRST_FRAG) { /* FIRST fragment */
- if ( (!pinfo->fd->flags.visited) && value->rep_frame ) {
+ if ( (!pinfo->fd->visited) && value->rep_frame ) {
fragment_add_seq_next(&dcerpc_co_reassembly_table,
stub_tvb, 0,
pinfo, value->rep_frame, NULL,
}
}
} else { /* MIDDLE fragment(s) */
- if ( (!pinfo->fd->flags.visited) && value->rep_frame ) {
+ if ( (!pinfo->fd->visited) && value->rep_frame ) {
fragment_add_seq_next(&dcerpc_co_reassembly_table,
stub_tvb, 0,
pinfo, value->rep_frame, NULL,
proto_item *pi;
proto_item *parent_pi;
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
dcerpc_call_value *call_value;
dcerpc_dg_call_key *call_key;
proto_item *pi;
proto_item *parent_pi;
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
dcerpc_call_value *call_value;
dcerpc_dg_call_key call_key;
e_dce_dg_common_hdr_t *hdr, conversation_t *conv)
{
proto_item *parent_pi;
-/* if (!(pinfo->fd->flags.visited)) {*/
+/* if (!(pinfo->fd->visited)) {*/
dcerpc_call_value *call_value;
dcerpc_dg_call_key call_key;
}
if (pdus_tree) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (flags_bits & DIAM_FLAGS_R) {
/* This is a request */
diameter_pair = wmem_new(wmem_file_scope(), diameter_req_ans_pair_t);
conversation_add_proto_data(conversation, proto_djiuav, djiuav_info);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (is_cmd) {
djiuav_trans=wmem_new(wmem_file_scope(), djiuav_transaction_t);
djiuav_trans->request_frame=pinfo->num;
dmp_key = wmem_new (wmem_file_scope(), dmp_id_key);
- if (!pinfo->fd->flags.visited &&
+ if (!pinfo->fd->visited &&
(dmp.msg_type == REPORT || dmp.msg_type == NOTIF))
{
/* Try to match corresponding message */
dmp_data = (dmp_id_val *) wmem_map_lookup (dmp_id_hash_table, dmp_key);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (dmp_data) {
if (dmp.msg_type == ACK) {
/* Only save this data if positive ack */
}
} else if (dmp.checksum && !dmp.id_val->msg_resend_count) {
en = proto_tree_add_item (analysis_tree, hf_analysis_ack_missing, tvb, offset, 0, ENC_NA);
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
/* We do not know this on first visit and we do not want to
add a entry in the "Expert Severity Info" for this note */
expert_add_info(pinfo, en, &ei_analysis_ack_missing);
static guint al_fragment_aging = 64; /* sequence numbers only 6 bit */
fragment_head *frag_al = NULL;
pinfo->fragmented = TRUE;
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
frag_al = fragment_add_seq_single_aging(&al_reassembly_table,
al_tvb, 0, pinfo, tr_seq, NULL,
key[2].length = 0;
key[2].key = NULL;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (!(flags&F_RESPONSE)) {
/* This is a request */
gboolean new_transaction = FALSE;
{
col_append_fstr(pinfo->cinfo, COL_INFO, "DNP/DPP Negotiation");
- if (pinfo->fd->flags.visited &&
+ if (pinfo->fd->visited &&
api_data->transport_session->negotiation_required &&
((api_data->transport_session->negotiation_complete_at == 0) || (api_data->transport_session->negotiation_complete_at_ts.secs - api_data->transport_session->session_start_ts.secs > 10)))
{
{ "short player message", "dplay.flags.short_player_msg", FT_BOOLEAN, 32,
TFS(&tfs_dplay_flag), DPLAY_FLAG_SHORT_PLAYER_MSG, "Short Player Msg", HFILL}},
{ &hf_dplay_flags_ignored,
- { "ignored", "dplay.flags.ignored", FT_BOOLEAN, 32,
+ { "ignored", "dplay.ignored", FT_BOOLEAN, 32,
TFS(&tfs_dplay_flag), DPLAY_FLAG_IGNORED, NULL, HFILL}},
{ &hf_dplay_flags_can_join,
{ "can join", "dplay.flags.can_join", FT_BOOLEAN, 32,
/* try decryption only the first time we see this packet
* (to keep cipher synchronized) */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
ssl_session = NULL;
/* Initialize the protocol column; we'll set it later when we
eap_identity_item = proto_tree_add_item(eap_tree, hf_eap_identity, tvb, offset, size, ENC_ASCII|ENC_NA);
dissect_eap_identity(tvb, pinfo, eap_identity_item, offset, size);
}
- if(!pinfo->fd->flags.visited) {
+ if(!pinfo->fd->visited) {
conversation_state->leap_state = 0;
conversation_state->eap_tls_seq = -1;
}
/*
* We haven't - does this message require reassembly?
*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* This is the first time we've looked at this frame,
* so it wouldn't have any remembered information.
* We're finished reassembing this frame.
* Reinitialize the reassembly state.
*/
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
conversation_state->eap_tls_seq = -1;
}
request_info = NULL;
request_val = (enip_request_val_t *)wmem_map_lookup( enip_request_hashtable, prequest_key );
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
if ( prequest_key && prequest_key->requesttype == ENIP_REQUEST_PACKET )
{
enip_conv_info_t *enip_info;
address dest_address;
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
return;
// Don't create connections for Null Forward Opens.
enip_conn_key_t conn_key;
enip_conn_val_t *conn_val;
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
return;
conn_key.triad = *triad;
case CONNECTION_TRANSPORT: // 2nd item for: Connected messages (both Class 0/1 and Class 3)
// Save the connection info for the conversation filter
- if (!pinfo->fd->flags.visited && conn_info)
+ if (!pinfo->fd->visited && conn_info)
{
p_add_proto_data(wmem_file_scope(), pinfo, proto_enip, ENIP_CONNECTION_INFO, conn_info);
}
offset += 2 + elen;
}
col_append_fstr(pinfo->cinfo, COL_INFO, " %s port=%d", name, port);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
conv = conversation_new(pinfo->num, &pinfo->src, &pinfo->dst, ENDPOINT_TCP, port, 0, NO_PORT2);
conversation_set_dissector(conv, edp_handle);
}
/* Set up LUN data. OXID + LUN make up unique exchanges, but LUN is populated in subdissectors
and not necessarily in every frame. Stub it here for now */
fchdr->lun = 0xFFFF;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
fchdr->lun = (guint16)GPOINTER_TO_UINT(wmem_tree_lookup32(fc_conv_data->luns, fchdr->oxid));
}
key) when packets are guaranteed to be parsed consecutively */
/* Set up LUN data */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
wmem_tree_insert32(fc_conv_data->luns, fchdr->oxid, GUINT_TO_POINTER((guint)fchdr->lun));
}
fchdr->fc_ex = fc_ex;
/* populate the exchange struct */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(fchdr->fctl&FC_FCTL_EXCHANGE_FIRST){
fc_ex->first_exchange_frame=pinfo->num;
fc_ex->fc_time = pinfo->abs_ts;
lun = tvb_get_guint8(tvb, offset+1);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
proto_data = wmem_new(wmem_file_scope(), fcp_proto_data_t);
proto_data->lun = lun;
p_add_proto_data(wmem_file_scope(), pinfo, proto_fcp, 0, proto_data);
}
/* populate the exchange struct */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(fchdr->fctl&FC_FCTL_EXCHANGE_FIRST){
request_data->itlq->first_exchange_frame=pinfo->num;
request_data->itlq->fc_time = pinfo->abs_ts;
request_data->response_frame = pinfo->num;
/* populate the exchange struct */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(fchdr->fctl&FC_FCTL_EXCHANGE_FIRST){
request_data->itlq->first_exchange_frame=pinfo->num;
request_data->itlq->fc_time = pinfo->abs_ts;
/* Lun is only populated by FCP_IU_CMD, and subsequent packets assume the same lun.
The only way that consistently works is to save the lun on the first pass when packets
are guaranteed to be parsed consecutively */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
proto_data = wmem_new(wmem_file_scope(), fcp_proto_data_t);
proto_data->lun = fchdr->lun;
p_add_proto_data(wmem_file_scope(), pinfo, proto_fcp, 0, proto_data);
0, 0, &(pinfo->rel_ts));
PROTO_ITEM_SET_GENERATED(item);
- if (pinfo->fd->flags.ref_time) {
+ if (pinfo->fd->ref_time) {
ti = proto_tree_add_item(fh_tree, hf_frame_time_reference, tvb, 0, 0, ENC_NA);
PROTO_ITEM_SET_GENERATED(ti);
}
PROTO_ITEM_SET_GENERATED(ti);
}
- ti = proto_tree_add_boolean(fh_tree, hf_frame_marked, tvb, 0, 0,pinfo->fd->flags.marked);
+ ti = proto_tree_add_boolean(fh_tree, hf_frame_marked, tvb, 0, 0,pinfo->fd->marked);
PROTO_ITEM_SET_GENERATED(ti);
- ti = proto_tree_add_boolean(fh_tree, hf_frame_ignored, tvb, 0, 0,pinfo->fd->flags.ignored);
+ ti = proto_tree_add_boolean(fh_tree, hf_frame_ignored, tvb, 0, 0,pinfo->fd->ignored);
PROTO_ITEM_SET_GENERATED(ti);
if (pinfo->rec->rec_type == REC_TYPE_PACKET) {
}
}
- if (pinfo->fd->flags.ignored) {
+ if (pinfo->fd->ignored) {
/* Ignored package, stop handling here */
col_set_str(pinfo->cinfo, COL_INFO, "<Ignored>");
proto_tree_add_boolean_format(tree, hf_frame_ignored, tvb, 0, 0, TRUE, "This frame is marked as ignored");
}
/* Attempt to (re-)calculate color filters (if any). */
- if (pinfo->fd->flags.need_colorize) {
+ if (pinfo->fd->need_colorize) {
color_filter = color_filters_colorize_packet(fr_data->color_edt);
pinfo->fd->color_filter = color_filter;
- pinfo->fd->flags.need_colorize = 0;
+ pinfo->fd->need_colorize = 0;
} else {
color_filter = pinfo->fd->color_filter;
}
const char *method)
{
/* Only to do on first pass */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
return;
}
ftp_conversation_t *p_ftp_conv = find_or_create_ftp_conversation(pinfo);
/* Store the current working directory */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
store_directory_in_packet(pinfo, p_ftp_conv);
}
* Responses to CWD command.
*/
if (code == 250) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (p_ftp_conv && p_ftp_conv->last_command) {
/* Explicit Change Working Directory command */
if (strncmp(p_ftp_conv->last_command, "CWD ", 4) == 0) {
process_cwd_success(p_ftp_conv, p_ftp_conv->last_command+4);
/* Update path in packet */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
store_directory_in_packet(pinfo, p_ftp_conv);
}
}
else if (strncmp(p_ftp_conv->last_command, "CDUP", 4) == 0) {
process_cwd_success(p_ftp_conv, "..");
/* Update path in packet */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
store_directory_in_packet(pinfo, p_ftp_conv);
}
}
* Responses to PWD command. Overwrite whatever is stored - this is the truth!
*/
if (code == 257) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (p_ftp_conv && linelen >= 4) {
/* Want directory name, which will be between " " */
process_pwd_success(p_ftp_conv, line+4, linelen-4, pinfo, pi);
/* Update path in packet */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
store_directory_in_packet(pinfo, p_ftp_conv);
}
}
}
/* If this is a command resulting in an ftp-data stream, show details */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
/* Look up what has been stored for this frame */
ftp_data_conversation_t *ftp_data =
(ftp_data_conversation_t *)g_hash_table_lookup(ftp_command_to_data_hash, GUINT_TO_POINTER(pinfo->num));
if (p_ftp_data_conv) {
/* First time around, update info. */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (!p_ftp_data_conv->first_frame_num) {
p_ftp_data_conv->first_frame_num = pinfo->num;
p_ftp_data_conv->first_frame_time = pinfo->abs_ts;
// XXX Is it possible to "follow" a station when updating its GN_ADDR?
- if(geonw_analyze_seq && !(pinfo->fd->flags.visited)) {
+ if(geonw_analyze_seq && !(pinfo->fd->visited)) {
// Duplication detection uses SN and TST or only TST (see Annex A of ETSI EN 302 636-4-1)
// We rely on address type and hashtable as this shall be done on a per station basis (i.e. not over a conversation)
// We do not try to consider GN_ADDR updates (due to duplicate address detection or anonymous setting)
* So, how do I differentiate between the initial processing of incoming
* packets, and a user clickin on one ? Good question.
*
- * I leverage the pinfo_fd->flags.visited on a per frame
+ * I leverage the pinfo_fd->visited on a per frame
* basis.
*
* To quote from the ever helpful development list
/* look it up directly, later ie: FN -> MFN -> giop_sub_handle_t and repoid */
/* but only if user not clicking */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
add_sub_handle_repoid_to_comp_req_list(pinfo->num, subdiss, repoid);
* Save FN and MFN in complete_reply_hash, only if user is NOT clicking
*/
- if (! pinfo->fd->flags.visited) {
+ if (! pinfo->fd->visited) {
mfn = get_mfn_from_fn_and_reqid(pinfo->num, request_id, &pinfo->dst, pinfo->destport); /* find MFN for this FN */
if (mfn != pinfo->num) { /* if mfn is not fn, good */
insert_in_complete_reply_hash(pinfo->num, mfn);
* Save FN and MFN in complete_reply_hash, only if user is NOT clicking
*/
- if (! pinfo->fd->flags.visited) {
+ if (! pinfo->fd->visited) {
mfn = get_mfn_from_fn_and_reqid(pinfo->num, request_id, &pinfo->dst, pinfo->destport); /* find MFN for this FN */
if (mfn != pinfo->num) { /* if mfn is not fn, good */
insert_in_complete_reply_hash(pinfo->num, mfn);
* Save FN, reqid, and operation for later. Add sub_handle later.
* But only if user is NOT clicking.
*/
- if (! pinfo->fd->flags.visited)
+ if (! pinfo->fd->visited)
giop_complete_request_list = insert_in_comp_req_list(giop_complete_request_list, pinfo->num,
request_id, operation, NULL, &pinfo->src, pinfo->srcport);
* But only if user is NOT clicking.
*/
- if (! pinfo->fd->flags.visited)
+ if (! pinfo->fd->visited)
giop_complete_request_list = insert_in_comp_req_list(giop_complete_request_list, pinfo->num,
request_id, operation, NULL, &pinfo->src, pinfo->srcport);
* we've already done this work, so we don't need to do it
* again.
*/
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
conversation = find_or_create_conversation(pinfo);
if (repo_id_buf) {
if (pinfo) {
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
insert_in_objkey_hash(giop_objkey_hash, objkey, seqlen, repo_id_buf, ior_src_req_res);
}
else {
break;
}
- if ((!pinfo->fd->flags.visited) && rtp_port != 0) {
+ if ((!pinfo->fd->visited) && rtp_port != 0) {
rtp_add_address(pinfo, PT_UDP, &rtp_dst_addr, rtp_port, 0, "BSS MAP", pinfo->num, FALSE, 0);
rtcp_add_address(pinfo, &rtp_dst_addr, rtp_port+1, 0, "BSS MAP", pinfo->num);
}
/* First of all, if it's the first time we see this packet
* then check whether we are in the middle of reassembly or not
*/
- if( (!pinfo->fd->flags.visited)
+ if( (!pinfo->fd->visited)
&& (gss_info->do_reassembly)
&& (gssapi_reassembly) ){
fi=(gssapi_frag_info_t *)wmem_tree_lookup32(gss_info->frags, gss_info->first_frame);
/* We have seen this packet before.
* Is this blob part of reassembly or a normal blob ?
*/
- if( (pinfo->fd->flags.visited)
+ if( (pinfo->fd->visited)
&& (gssapi_reassembly) ){
fi=(gssapi_frag_info_t *)wmem_tree_lookup32(gss_info->frags, pinfo->num);
if(fi){
* doesn't dereference it or free what it points to.)
*/
oidvalue = (gssapi_oid_value *)p_get_proto_data(wmem_file_scope(), pinfo, proto_gssapi, 0);
- if (!oidvalue && !pinfo->fd->flags.visited)
+ if (!oidvalue && !pinfo->fd->visited)
{
/* No handle attached to this frame, but it's the first */
/* pass, so it'd be attached to the conversation. */
* instead for simplicity we assume there will not be several
* such authentication at once on a single tcp session
*/
- if( (!pinfo->fd->flags.visited)
+ if( (!pinfo->fd->visited)
&& (oidvalue)
&& (tvb_captured_length(gss_tvb)==tvb_reported_length(gss_tvb))
&& (len1>(guint32)tvb_captured_length_remaining(gss_tvb, oid_start_offset))
col_append_str(pinfo->cinfo, COL_INFO, address_string);
}
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
gvcp_trans->addr_list = wmem_array_new(wmem_file_scope(), sizeof(guint32));
}
/* For block read register request, address gets re-initialized here in the for loop */
addr = tvb_get_ntohl(tvb, offset);
- if (gvcp_trans && (!pinfo->fd->flags.visited))
+ if (gvcp_trans && (!pinfo->fd->visited))
{
wmem_array_append_one(gvcp_trans->addr_list, addr);
}
/* fill in Info column in Wireshark GUI */
col_append_fstr(pinfo->cinfo, COL_INFO, "%s: %d bytes", address_string, (length - 4));
- if (gvcp_trans && (!pinfo->fd->flags.visited))
+ if (gvcp_trans && (!pinfo->fd->visited))
{
gvcp_trans->addr_list = wmem_array_new(wmem_file_scope(), sizeof(guint32));
wmem_array_append_one(gvcp_trans->addr_list, addr);
conversation_add_proto_data(conversation, proto_gvcp, gvcp_info);
}
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
if (key_code == 0x42)
{
break;
}
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
if (key_code == 0x42)
{
h225_pi->h245_address = ipv4_address;
h225_pi->h245_port = ip_port;
}
- if ( !actx->pinfo->fd->flags.visited && h245_handle && ip_port!=0 ) {
+ if ( !actx->pinfo->fd->visited && h245_handle && ip_port!=0 ) {
address src_addr;
conversation_t *conv=NULL;
#line 129 "./asn1/h245/h245.cnf"
gint32 temp;
- upcoming_olc = (!actx->pinfo->fd->flags.visited) ? wmem_new0(wmem_file_scope(), olc_info_t) : NULL;
+ upcoming_olc = (!actx->pinfo->fd->visited) ? wmem_new0(wmem_file_scope(), olc_info_t) : NULL;
h223_fw_lc_num = 0;
h223_lc_params_temp = NULL;
const gchar *olc_key;
olc_info_t *olc_req;
- upcoming_olc = (!actx->pinfo->fd->flags.visited) ? wmem_new0(wmem_packet_scope(), olc_info_t) : NULL;
+ upcoming_olc = (!actx->pinfo->fd->visited) ? wmem_new0(wmem_packet_scope(), olc_info_t) : NULL;
h223_fw_lc_num = 0;
h223_rev_lc_num = 0;
{
conversation_t *conversation = NULL;
- if (!pinfo->fd->flags.visited && (pinfo->ptype == PT_UDP)) {
+ if (!pinfo->fd->visited && (pinfo->ptype == PT_UDP)) {
/*
* This function is called for a session initiate send over UDP.
* The session initiate is sent to the server on port HARTIP_PORT.
key[1].length = 1;
key[1].key = &k_adapter_id;
- if (!pinfo->fd->flags.visited && opcode == 0x01) { /* Delete Index */
+ if (!pinfo->fd->visited && opcode == 0x01) { /* Delete Index */
guint32 *disconnect_in_frame;
key[2].length = 1;
bluetooth_data->adapter_disconnect_in_frame = &max_disconnect_in_frame;
next_tvb = tvb_new_subset_remaining(tvb, offset);
- if (!pinfo->fd->flags.visited && usb_conv_info->endpoint <= 0x02 &&
+ if (!pinfo->fd->visited && usb_conv_info->endpoint <= 0x02 &&
tvb_captured_length(tvb) == tvb_reported_length(tvb)) {
fragment_info_t *fragment_info;
dirdata = &(iax_call->dirdata[!!(iax_packet->reversed)]);
- if ((!pinfo->fd->flags.visited && (dirdata->current_frag_bytes > 0)) ||
+ if ((!pinfo->fd->visited && (dirdata->current_frag_bytes > 0)) ||
((value = g_hash_table_lookup(iax_fid_table, GUINT_TO_POINTER(pinfo->num))) != NULL)) {
/* then we are continuing an already-started pdu */
gboolean complete;
#ifdef DEBUG_DESEGMENT
- g_debug("visited: %i; c_f_b: %u; hash: %u->%u", pinfo->fd->flags.visited?1:0,
+ g_debug("visited: %i; c_f_b: %u; hash: %u->%u", pinfo->fd->visited?1:0,
dirdata->current_frag_bytes, pinfo->num, dirdata->current_frag_id);
#endif
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
guint32 tot_len;
fid = dirdata->current_frag_id;
tot_len = dirdata->current_frag_minlen;
#endif
} else {
fid = GPOINTER_TO_UINT(value);
- /* these values are unused by fragment_add if pinfo->fd->flags.visited */
+ /* these values are unused by fragment_add if pinfo->fd->visited */
dirdata->current_frag_bytes = 0;
complete = FALSE;
}
/* this is the first time we are looking at this frame during a
* capture dissection, so we know the dissection is done in
* frame order (subsequent dissections may be random access) */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
wlan_radio_info = wmem_new0(wmem_file_scope(), struct wlan_radio);
p_add_proto_data(wmem_file_scope(), pinfo, proto_wlan_radio, 0, wlan_radio_info);
}
}
- if (!pinfo->fd->flags.visited && have_duration && phdr->has_tsf_timestamp) {
+ if (!pinfo->fd->visited && have_duration && phdr->has_tsf_timestamp) {
if (current_aggregate) {
current_aggregate->duration = agg_preamble + prior_duration + duration;
if (previous_frame.radio_info && previous_frame.radio_info->aggregate == current_aggregate)
tap_queue_packet(wlan_radio_timeline_tap, pinfo, wlan_radio_info);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
previous_frame.radio_info = wlan_radio_info;
}
}
* data: last seq_control seen and frame number
*/
retransmitted = FALSE;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
retransmit_key key;
retransmit_key *result;
}
}
- if (enable_decryption && !pinfo->fd->flags.visited && (len == reported_len)) {
+ if (enable_decryption && !pinfo->fd->visited && (len == reported_len)) {
/* The processing will take care of 4-way handshake sessions for WPA and WPA2 decryption */
next_tvb = try_decrypt(tvb, pinfo, hdr_len, reported_len, TRUE,
&algorithm, &sec_header, &sec_trailer, &used_key);
/* Get the address. */
packet->src16 = tvb_get_letohs(tvb, offset);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* If we know our extended source address from previous packets,
* provide a pointer to it in a hint for upper layers */
addr16.addr = packet->src16;
} /* switch */
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Update the address tables */
if ( packet->dst_addr_mode == IEEE802154_FCF_ADDR_EXT ) {
ieee802154_long_addr_invalidate(packet->dst64, pinfo->num);
request_info = NULL;
request_val = (imap_request_val_t *)wmem_map_lookup(imap_requests, request_key);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
if (is_request)
{
{
/* the following saves information about the conversation this packet defines,
so there's no point in doing it more than once per packet */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
connection_context *connection;
conversation_infiniband_data *proto_data;
{
/* the following saves information about the conversation this packet defines,
so there's no point in doing it more than once per packet */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* get the previously saved context for this connection */
connection_context *connection;
/* Sequence number analysis */
if (g_esp_do_sequence_analysis) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
check_esp_sequence_info(spi, sequence_number, pinfo);
}
show_esp_sequence_info(spi, sequence_number,
/*
* Not a system packet - check for retransmissions.
*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
conversation = find_conversation(pinfo->num, &pinfo->src,
&pinfo->dst, ENDPOINT_NCP, pinfo->srcport,
pinfo->srcport, 0);
}
/* During the first pass, store in the conversation the next_payload */
- if (!pinfo->fd->flags.visited && (fragment_number == 1)) {
+ if (!pinfo->fd->visited && (fragment_number == 1)) {
/* Create/update conversation with message_id -> next_payload */
conversation_t* p_conv = find_or_create_conversation(pinfo);
ikev2_fragmentation_state_t *p_state = wmem_new0(wmem_file_scope(), ikev2_fragmentation_state_t);
/* If this is the last fragment, need to know what the payload type for the reassembled message is,
which was included in the first fragment */
if (fragment_number == total_fragments) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* On first pass, get it from the conversation info */
conversation_t *p_conv = find_conversation_pinfo(pinfo, 0);
if (p_conv != NULL) {
/* attach a conversation dissector to this address/port tuple */
- if (addr && !pinfo->fd->flags.visited) {
+ if (addr && !pinfo->fd->visited) {
conversation_t *conv;
conv = conversation_new(pinfo->num, addr, addr, ENDPOINT_TCP, port, port, NO_ADDR2|NO_PORT2);
in the middle of a large PDU transfer being misdissected as
a PDU.
*/
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(pduLen>(guint32)tvb_reported_length_remaining(tvb, offset)){
pinfo->want_pdu_tracking=2;
pinfo->bytes_until_next_pdu=pduLen-tvb_reported_length_remaining(tvb, offset);
fragmented = TRUE;
/* Save information */
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
iso15765_frame_t *iso15765_frame = wmem_new0(wmem_file_scope(), iso15765_frame_t);
iso15765_frame->seq = iso15765_info->seq = ++msg_seqid;
iso15765_frame->len = full_len;
fragmented = TRUE;
/* Save information */
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
iso15765_info->seq = msg_seqid;
}
if (iso15765_frame != NULL)
{
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
frag_id += ((iso15765_frame->frag_id_high[frag_id]++) * 16);
/* Save the frag_id for subsequent dissection */
iso15765_info->frag_id = frag_id;
fragment_head *frag_msg;
/* Check if it's the last packet */
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
/* Update the last_frag_id */
if (frag_id > iso15765_frame->last_frag_id) {
iso15765_frame->last_frag_id = frag_id;
{
enc_key_t *new_key;
- if(pinfo->fd->flags.visited){
+ if(pinfo->fd->visited){
return;
}
{
service_key_t *new_key;
- if(pinfo->fd->flags.visited){
+ if(pinfo->fd->visited){
return;
}
tcp_address_valid = FALSE;
}
/* Note: it *is* possible for a TCP SID to appear in an LBTTCP non-transport (UIM) message. */
- if ((pinfo->fd->flags.visited == 0) && (tcp_sid_info.set) && lbm_channel_is_unknown_transport_lbttcp(channel) && tcp_address_valid)
+ if ((pinfo->fd->visited == 0) && (tcp_sid_info.set) && lbm_channel_is_unknown_transport_lbttcp(channel) && tcp_address_valid)
{
lbttcp_transport_sid_add(&tcp_addr, tcp_port, pinfo->num, tcp_sid_info.session_id);
}
lbmpdm_definition_field_t * last_fixed_required_field = NULL;
seglen = lbmpdm_get_segment_length(tvb, offset, encoding, &remaining_datalen);
- if (pinfo->fd->flags.visited == 0)
+ if (pinfo->fd->visited == 0)
{
add_definition = TRUE;
}
if (lbtrm_sequence_analysis)
{
- if (pinfo->fd->flags.visited == 0)
+ if (pinfo->fd->visited == 0)
{
if (transport != NULL)
{
copy_address_shallow(&receiver_address, &(pinfo->src));
receiver_port = pinfo->srcport;
}
- if (pinfo->fd->flags.visited == 0)
+ if (pinfo->fd->visited == 0)
{
transport = lbtru_transport_add(&source_address, source_port, session_id, pinfo->num);
}
}
if (transport != NULL)
{
- if (pinfo->fd->flags.visited == 0)
+ if (pinfo->fd->visited == 0)
{
client = lbtru_client_transport_add(transport, &receiver_address, receiver_port, pinfo->num);
if (client != NULL)
* type and mechanism, if you can unbind and rebind with a
* different type and/or mechanism.
*/
- if(!actx->pinfo->fd->flags.visited) {
+ if(!actx->pinfo->fd->visited) {
mechanism = tvb_get_string_enc(wmem_file_scope(), parameter_tvb, 0, tvb_reported_length_remaining(parameter_tvb,0), ENC_UTF_8|ENC_NA);
ldap_info->first_auth_frame = 0; /* not known until we see the bind reply */
/*
switch(ProtocolOp) {
case LDAP_RES_SEARCH_ENTRY:
- if (!actx->pinfo->fd->flags.visited)
+ if (!actx->pinfo->fd->visited)
ldap_info->num_results++;
proto_item_append_text(tree, " [%d result%s]",
/* Track whether systemInfoValue has changed since last seen, indicating new SI config
TODO: add link back to previous config and (if known) time since previous config
was first seen */
- if (!actx->pinfo->fd->flags.visited) {
+ if (!actx->pinfo->fd->visited) {
if (system_info_value_current_set && (value != system_info_value_current)) {
/* Add entry to the hash table. Offset by one to distinguish 0 from lookup failure */
wmem_map_insert(lte_rrc_system_info_value_changed_hash, GUINT_TO_POINTER(actx->pinfo->num),
proto_tree_add_item(modbus_tree, hf_modbus_functioncode, tvb, offset, 1, ENC_BIG_ENDIAN);
/* Conversation support */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
conversation_t *conversation = NULL;
modbus_conversation *modbus_conv_data = NULL;
const char *mountpoint=NULL;
int offset = 0;
- if((!pinfo->fd->flags.visited) && nfs_file_name_snooping){
+ if((!pinfo->fd->visited) && nfs_file_name_snooping){
rpc_call_info_value *civ=(rpc_call_info_value *)data;
if(civ->request && (civ->proc==1)){
/* When detecting a CC drop, store that information for the
* given frame. This info is needed, when clicking around in
* wireshark, as the pid table data only makes sense during
- * sequential processing. The flag pinfo->fd->flags.visited is
+ * sequential processing. The flag pinfo->fd->visited is
* used to tell the difference.
*
*/
}
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Get values from our current PID analysis */
frag_cur_pos = pid_analysis->frag_cur_pos;
frag_tot_len = pid_analysis->frag_tot_len;
guint32 skips = 0;
/* The initial sequential processing stage */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* This is the sequential processing stage */
pid_data = get_pid_analysis(mp2t_data, pid);
}
/* Save the info about the dropped packet */
- if (detected_drop && !pinfo->fd->flags.visited) {
+ if (detected_drop && !pinfo->fd->visited) {
/* Lookup frame data, contains TS pid data objects */
frame_analysis_data_p = get_frame_analysis_data(mp2t_data, pinfo);
if (!frame_analysis_data_p)
}
/* See if we stored info about drops */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
/* Lookup frame data, contains TS pid data objects */
frame_analysis_data_p = get_frame_analysis_data(mp2t_data, pinfo);
/* If this isn't the first time this packet has been processed,
* we've already done this work, so we don't need to do it
* again. */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
return;
}
conversation_t *conversation;
redirect_entry_t *new_conv_info;
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
/*
* We've already processed this frame once, so we
* should already have done this.
* we've already done this work, so we don't need to do it
* again.
*/
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
return;
}
/*
* TODO Set up conversation here
*/
- if (pinfo->fd->flags.visited){
+ if (pinfo->fd->visited){
/* Look for existing conversation */
conversation = find_or_create_conversation(pinfo);
/* Set dissector */
/* if this is the first time, do the reassemble things
* else just check for reassembled data */
- if (pinfo->fd->flags.visited == FALSE) {
+ if (pinfo->fd->visited == FALSE) {
/* if there was a flag in this tvb, the data found before the 1st flag
* have to be treated differently than the data found after the last flag
* this means we need to use different reass_seq_num when adding them to the reass. handler */
/* Helper function to only set state on first pass */
static void mysql_set_conn_state(packet_info *pinfo, mysql_conn_data_t *conn_data, mysql_state_t state)
{
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
conn_data->state = state;
}
/* No, so just return the rest of the current packet */
return tvb_captured_length(tvb);
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
/*
* Do we have a state structure for this transaction
*/
conversation_add_proto_data(conversation, proto_nbd, nbd_info);
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(magic==NBD_REQUEST_MAGIC){
/* This is a request */
nbd_trans=wmem_new(wmem_file_scope(), nbd_transaction_t);
* so that it can attempt to find it in case it starts
* somewhere in the middle of a segment.
*/
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
/* 'Only' SMB is transported ontop of this so make sure
* there is an SMB header there ...
*/
/* First time through we will record the initial connection and task
* values
*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (conversation != NULL) {
/* find the record telling us the
* request made that caused this
}
}
} else {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (conversation != NULL) {
/* find the record telling us the
* request made that caused this
return;
}
/* Has this already been dissected? */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Find the conversation whence the request would have come. */
conversation = find_conversation(pinfo->num, &pinfo->src, &pinfo->dst,
ENDPOINT_NCP, nw_connection, nw_connection, 0);
/* Subsequent fragments should be offset by 16 since we do not need */
/* the additional fragment handle and size fields in our composite data */
/* Also do not add retransmitted packets, just mark and return */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
if (sequence != frags[frag_count].sequence) {
fd_head = fragment_add_seq_next(&nds_reassembly_table, tvb, 16, pinfo, tid, NULL, len-16, request_value->nds_frag);
tid++;
}
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
/* Now we need to find the original fragment number. */
/* Get the fragment flag */
}
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* This is the first time we've looked at this packet.
Keep track of the address and connection whence the request
came, and the address and connection to which the request
* this EID and its associated name into our hash
* so that we can resolve the name for other NDS
* requests. */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if(add_eid)
{
request_eid_value = ncp_eid_hash_lookup(conversation, global_eid);
}
#endif
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Find the conversation whence the request would have come. */
conversation = find_conversation(pinfo->num, &pinfo->src, &pinfo->dst,
ENDPOINT_NCP, nw_connection, nw_connection, 0);
ENDPOINT_NCP, nw_connection, nw_connection, 0);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
request_value = ncp_hash_insert(conversation, sequence, ncp_rec, pinfo->num);
request_value->req_frame_num = pinfo->num;
request_value->req_frame_time=pinfo->abs_ts;
col_set_str(pinfo->cinfo, COL_INFO, "C Ping for NDS");
}
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
/* This is the first time we've looked at this packet.
hf_ndmp_scsi_device, offset, NULL);
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
/* new scsi device addressed, create a new itl structure */
get_itl_nexus(pinfo, TRUE);
}
proto_tree_add_item(tree, hf_ndmp_tape_open_mode, tvb, offset, 4, ENC_BIG_ENDIAN);
offset += 4;
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
/* new scsi device addressed, create a new itl structure */
get_itl_nexus(pinfo, TRUE);
}
*/
if ( !(ndmp_rm & RPC_RM_LASTFRAG))
{
- if ( !(pinfo->fd->flags.visited))
+ if ( !(pinfo->fd->visited))
{
nfi=wmem_new(wmem_file_scope(), ndmp_frag_info);
nfi->first_seq = seq;
*/
if ( !(ndmp_rm & RPC_RM_LASTFRAG))
{
- if ( !(pinfo->fd->flags.visited))
+ if ( !(pinfo->fd->visited))
{
nfi=wmem_new(wmem_file_scope(), ndmp_frag_info);
nfi->first_seq = seq;
ndmp_conv_data->task=NULL;
switch(nh.type){
case NDMP_MESSAGE_REQUEST:
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
ndmp_conv_data->task=wmem_new(wmem_file_scope(), ndmp_task_data_t);
ndmp_conv_data->task->request_frame=pinfo->num;
ndmp_conv_data->task->response_frame=0;
case NDMP_MESSAGE_REPLY:
ndmp_conv_data->task=(ndmp_task_data_t *)wmem_map_lookup(ndmp_conv_data->tasks, GUINT_TO_POINTER(nh.rep_seq));
- if(ndmp_conv_data->task && !pinfo->fd->flags.visited){
+ if(ndmp_conv_data->task && !pinfo->fd->visited){
ndmp_conv_data->task->response_frame=pinfo->num;
if(ndmp_conv_data->task->itlq){
ndmp_conv_data->task->itlq->last_exchange_frame=pinfo->num;
return;
}
/* Has this already been dissected? */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
/* Lets see if this is a new conversation */
conversation = find_conversation(pinfo->num, &pinfo->src, &pinfo->dst,
proto_tree *atree, *btree, *ctree, *dtree;
proto_item *aitem, *bitem, *citem, *ditem, *expert_item;
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
/* This is the first time we've looked at this packet.
Keep track of the Program and connection whence the request
proto_item *expert_item;
guint32 expert_status;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Find the conversation whence the request would have come. */
conversation = find_conversation(pinfo->num, &pinfo->src, &pinfo->dst,
ENDPOINT_NCP, (guint32) pinfo->destport, (guint32) pinfo->destport, 0);
observation domain id. */
if ((ver == 5) || (ver == 7) || (ver == 8) || (ver == 9) || (ver == 10)) {
/* On first pass check sequence analysis */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (ver != 10) {
flows_seen = pdus; /* i.e. use value from header rather than counted value */
}
/* XXX: Is an Options template with only scope fields allowed for V9 ?? */
tmplt_p = (v9_v10_tmplt_t *)wmem_map_lookup(v9_v10_tmplt_table, &tmplt);
- if (!pinfo->fd->flags.visited) { /* cache template info only during first pass */
+ if (!pinfo->fd->visited) { /* cache template info only during first pass */
do {
if (v9_tmplt_max_fields &&
((option_scope_field_count > v9_tmplt_max_fields)
/* ToDo: expert warning if replacement (changed) and new template ignored. */
tmplt_p = (v9_v10_tmplt_t *)wmem_map_lookup(v9_v10_tmplt_table, &tmplt);
- if (!pinfo->fd->flags.visited) { /* cache template info only during first pass */
+ if (!pinfo->fd->visited) { /* cache template info only during first pass */
do {
if ((count == 0) ||
(v9_tmplt_max_fields && (count > v9_tmplt_max_fields))) {
nfs_name_snoop_t *nns = NULL;
/* if this is a new packet, see if we can register the mapping */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
key.key = 0;
key.fh_length = fh_length;
key.fh = (const unsigned char *)tvb_get_ptr(tvb, fh_offset, fh_length);
if (nfs_fhandle_reqrep_matching && (!hidden) ) {
nfs_fhandle_data_t *old_fhd = NULL;
- if ( !pinfo->fd->flags.visited ) {
+ if ( !pinfo->fd->visited ) {
nfs_fhandle_data_t fhd;
/* first check if we have seen this fhandle before */
/* are we snooping fh to filenames ?*/
- if ((!pinfo->fd->flags.visited) && nfs_file_name_snooping) {
+ if ((!pinfo->fd->visited) && nfs_file_name_snooping) {
/* NFS v2 LOOKUP, CREATE, MKDIR calls might give us a mapping*/
if ( (civ->prog == 100003)
ett_nfs2_diropargs, &diropargs_item, label);
/* are we snooping fh to filenames ?*/
- if ((!pinfo->fd->flags.visited) && nfs_file_name_snooping) {
+ if ((!pinfo->fd->visited) && nfs_file_name_snooping) {
/* v2 LOOKUP, CREATE, MKDIR calls might give us a mapping*/
if ( (civ->prog == 100003)
ett_nfs3_fh, NULL, name);
/* are we snooping fh to filenames ?*/
- if ((!pinfo->fd->flags.visited) && nfs_file_name_snooping) {
+ if ((!pinfo->fd->visited) && nfs_file_name_snooping) {
/* NFS v3 LOOKUP, CREATE, MKDIR, READDIRPLUS
calls might give us a mapping*/
if ( ((civ->prog == 100003)
hf_nfs_name, name);
/* are we snooping fh to filenames ?*/
- if ((!pinfo->fd->flags.visited) && nfs_file_name_snooping) {
+ if ((!pinfo->fd->visited) && nfs_file_name_snooping) {
/* v3 LOOKUP, CREATE, MKDIR calls might give us a mapping*/
if ( (civ->prog == 100003)
&&(civ->vers == 3)
offset = dissect_nfs3_filename(tvb, offset, entry_tree, hf_nfs3_readdirplus_entry_name, &name);
/* are we snooping fh to filenames ?*/
- if ((!pinfo->fd->flags.visited) && nfs_file_name_snooping) {
+ if ((!pinfo->fd->visited) && nfs_file_name_snooping) {
/* v3 READDIRPLUS replies will give us a mapping */
if ( (civ->prog == 100003)
&&(civ->vers == 3)
{
if(nlm_match_msgres){
if(rpc_call->proc==6){ /* NLM_TEST_MSG */
- if( (!pinfo->fd->flags.visited) ){
+ if( (!pinfo->fd->visited) ){
nlm_register_unmatched_msg(pinfo, tvb, offset);
} else {
nlm_print_msgres_request(pinfo, tree, tvb);
{
if(nlm_match_msgres){
if(rpc_call->proc==7){ /* NLM_LOCK_MSG */
- if( (!pinfo->fd->flags.visited) ){
+ if( (!pinfo->fd->visited) ){
nlm_register_unmatched_msg(pinfo, tvb, offset);
} else {
nlm_print_msgres_request(pinfo, tree, tvb);
{
if(nlm_match_msgres){
if(rpc_call->proc==8){ /* NLM_CANCEL_MSG */
- if( (!pinfo->fd->flags.visited) ){
+ if( (!pinfo->fd->visited) ){
nlm_register_unmatched_msg(pinfo, tvb, offset);
} else {
nlm_print_msgres_request(pinfo, tree, tvb);
{
if(nlm_match_msgres){
if(rpc_call->proc==9){ /* NLM_UNLOCK_MSG */
- if( (!pinfo->fd->flags.visited) ){
+ if( (!pinfo->fd->visited) ){
nlm_register_unmatched_msg(pinfo, tvb, offset);
} else {
nlm_print_msgres_request(pinfo, tree, tvb);
{
if(nlm_match_msgres){
if(rpc_call->proc==10){ /* NLM_GRANTED_MSG */
- if( (!pinfo->fd->flags.visited) ){
+ if( (!pinfo->fd->visited) ){
nlm_register_unmatched_msg(pinfo, tvb, offset);
} else {
nlm_print_msgres_request(pinfo, tree, tvb);
if(nlm_match_msgres){
if(rpc_call->proc==11){ /* NLM_TEST_RES */
- if( (!pinfo->fd->flags.visited) ){
+ if( (!pinfo->fd->visited) ){
nlm_register_unmatched_res(pinfo, tvb, offset);
} else {
nlm_print_msgres_reply(pinfo, tree, tvb);
|| (rpc_call->proc==13) /* NLM_CANCEL_RES */
|| (rpc_call->proc==14) /* NLM_UNLOCK_RES */
|| (rpc_call->proc==15) ){ /* NLM_GRENTED_RES */
- if( (!pinfo->fd->flags.visited) ){
+ if( (!pinfo->fd->visited) ){
nlm_register_unmatched_res(pinfo, tvb, offset);
} else {
nlm_print_msgres_reply(pinfo, tree, tvb);
/* end-to-start */
proto_tree_add_item_ret_uint(tree, hf_nordic_ble_delta_time, tvb, offset, 4, ENC_LITTLE_ENDIAN, &delta_time);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* First time visiting this packet, store previous BLE packet time */
p_add_proto_data(wmem_file_scope(), pinfo, proto_nordic_ble, 0, GUINT_TO_POINTER(previous_ble_packet_time));
prev_packet_time = previous_ble_packet_time;
}
offset += 4;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Calculate packet time according to this packets PHY */
guint16 ble_payload_length = nordic_ble_context->payload_length - nordic_ble_context->event_packet_length;
if (nordic_ble_context->phy == LE_1M_PHY) {
/* On Connect response sets "/"
On SetPath sets what is needed
*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
obex_path_data_t *obex_path_data;
wmem_tree_key_t key[6];
guint32 frame_number;
switch (hdr_id) {
case 0x01: /* Name */
proto_tree_add_item(hdr_tree, hf_name, tvb, offset, value_length, ENC_UCS_2 | ENC_BIG_ENDIAN);
- if (!pinfo->fd->flags.visited && obex_last_opcode_data) {
+ if (!pinfo->fd->visited && obex_last_opcode_data) {
if (obex_last_opcode_data->code == OBEX_CODE_VALS_SET_PATH)
obex_last_opcode_data->data.set_data.name = tvb_get_string_enc(wmem_file_scope(), tvb, offset, value_length, ENC_UCS_2 | ENC_BIG_ENDIAN);
else if (obex_last_opcode_data->code == OBEX_CODE_VALS_GET || obex_last_opcode_data->code == OBEX_CODE_VALS_PUT)
case 0x42: /* Type */
proto_tree_add_item(hdr_tree, hf_type, tvb, offset, value_length, ENC_ASCII | ENC_NA);
proto_item_append_text(hdr_tree, ": \"%s\"", tvb_get_string_enc(wmem_packet_scope(), tvb, offset, value_length, ENC_ASCII));
- if (!pinfo->fd->flags.visited && obex_last_opcode_data && (obex_last_opcode_data->code == OBEX_CODE_VALS_GET || obex_last_opcode_data->code == OBEX_CODE_VALS_PUT)) {
+ if (!pinfo->fd->visited && obex_last_opcode_data && (obex_last_opcode_data->code == OBEX_CODE_VALS_GET || obex_last_opcode_data->code == OBEX_CODE_VALS_PUT)) {
obex_last_opcode_data->data.get_put.type = tvb_get_string_enc(wmem_file_scope(), tvb, offset, value_length, ENC_ASCII | ENC_NA);
}
if (p_get_proto_data(pinfo->pool, pinfo, proto_obex, PROTO_DATA_MEDIA_TYPE) == NULL) {
proto_item_append_text(hdr_tree, ": %s", target_vals[i].strptr);
col_append_fstr(pinfo->cinfo, COL_INFO, " - %s", target_vals[i].strptr);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
obex_profile_data_t *obex_profile_data;
wmem_tree_key_t key[6];
if (code < OBEX_CODE_VALS_CONTINUE || code == OBEX_CODE_VALS_ABORT) {
proto_tree_add_item(main_tree, hf_opcode, next_tvb, offset, 1, ENC_BIG_ENDIAN);
- if (!pinfo->fd->flags.visited &&
+ if (!pinfo->fd->visited &&
(pinfo->p2p_dir == P2P_DIR_SENT ||
pinfo->p2p_dir == P2P_DIR_RECV)) {
frame_number = pinfo->num;
PROTO_ITEM_SET_GENERATED(sub_item);
}
- if (!pinfo->fd->flags.visited && obex_last_opcode_data->response_in_frame == 0 && obex_last_opcode_data->request_in_frame < pinfo->num) {
+ if (!pinfo->fd->visited && obex_last_opcode_data->response_in_frame == 0 && obex_last_opcode_data->request_in_frame < pinfo->num) {
obex_last_opcode_data->response_in_frame = pinfo->num;
}
proto_tree_add_item(main_tree, hf_set_path_flags_0, next_tvb, offset, 1, ENC_BIG_ENDIAN);
proto_tree_add_item(main_tree, hf_set_path_flags_1, next_tvb, offset, 1, ENC_BIG_ENDIAN);
- if (!pinfo->fd->flags.visited && obex_last_opcode_data) {
+ if (!pinfo->fd->visited && obex_last_opcode_data) {
obex_last_opcode_data->data.set_data.go_up = tvb_get_guint8(tvb, offset) & 0x01;
obex_last_opcode_data->data.set_data.name = NULL;
}
proto_tree_add_item(main_tree, hf_max_pkt_len, next_tvb, offset, 2, ENC_BIG_ENDIAN);
offset += 2;
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
save_path(pinfo, path, "", FALSE, &obex_proto_data);
}
break;
}
dissect_headers(main_tree, next_tvb, offset, pinfo, profile, obex_last_opcode_data, &obex_proto_data);
- if (!pinfo->fd->flags.visited &&
+ if (!pinfo->fd->visited &&
obex_last_opcode_data &&
obex_last_opcode_data->data.set_data.name &&
obex_last_opcode_data->code == OBEX_CODE_VALS_SET_PATH &&
p_mul_key = wmem_new(wmem_file_scope(), p_mul_id_key);
- if (!pinfo->fd->flags.visited &&
+ if (!pinfo->fd->visited &&
(pdu_type == Address_PDU || pdu_type == Data_PDU || pdu_type == Discard_Message_PDU))
{
/* Try to match corresponding address PDU */
p_add_proto_data(wmem_file_scope(), pinfo, proto_p_mul, 0, pkg_list);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
p_mul_key->id = message_id;
p_mul_key->seq = seq_no;
if (!need_set_address) {
en = proto_tree_add_item (analysis_tree,
hf_analysis_ack_missing,
tvb, offset, 0, ENC_NA);
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
/* We do not know this on first visit and we do not want to
add a entry in the "Expert Severity Info" for this note */
expert_add_info(pinfo, en, &ei_analysis_ack_missing);
conversation_add_proto_data(conversation, proto_pana, pana_info);
}
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(flags&PANA_FLAG_R){
/* This is a request */
pana_trans=wmem_new(wmem_file_scope(), pana_transaction_t);
guint32 snLimit = 0;
/* If find stat_report_in_frame already, use that and get out */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
p_report_in_frame =
(pdcp_sequence_report_in_frame*)wmem_map_lookup(pdcp_lte_sequence_analysis_report_hash,
get_report_hash_key(sequenceNumber,
/***************************************/
/* UE security algorithms */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Look up current state by UEID */
current_security = (pdcp_security_info_t*)wmem_map_lookup(pdcp_security_hash,
GUINT_TO_POINTER((guint)p_pdcp_info->ueid));
data_length, ENC_NA);
}
- if (!pinfo->fd->flags.visited &&
+ if (!pinfo->fd->visited &&
(current_security != NULL) && !current_security->seen_next_ul_pdu &&
p_pdcp_info->direction == DIRECTION_UPLINK)
{
guint32 snLimit = 0;
/* If find stat_report_in_frame already, use that and get out */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
p_report_in_frame =
(pdcp_sequence_report_in_frame*)wmem_map_lookup(pdcp_nr_sequence_analysis_report_hash,
get_report_hash_key(sequenceNumber,
int offset = 0;
/* make sure we remember protocol type until the reply packet */
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
rpc_call_info_value *rpc_call=(rpc_call_info_value *)data;
if(rpc_call){
proto = tvb_get_ntohl(tvb, offset+8);
int offset = 0;
/* we might have learnt a <ipaddr><protocol><port> mapping for ONC-RPC*/
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
rpc_call_info_value *rpc_call=(rpc_call_info_value *)data;
/* only do this for UDP, TCP does not need anything like this */
if(rpc_call && (GPOINTER_TO_UINT(rpc_call->private_data)==PT_UDP) ){
if (tvb_reported_length_remaining(tvb, hdrlen) > 0) {
pinfo->fragmented = TRUE;
frag_mp = NULL;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
frag_mp = fragment_add_seq_single_aging(&mp_reassembly_table,
tvb, hdrlen, pinfo, seqnum ^ (cls << 24), NULL,
tvb_captured_length_remaining(tvb, hdrlen),
if (mode == TCP_MODE_UNEXP)
{
/* Add entry to tracking table for PVFS_SERV_IO request */
- if ((server_op == PVFS_SERV_IO) && !pinfo->fd->flags.visited)
+ if ((server_op == PVFS_SERV_IO) && !pinfo->fd->visited)
val = pvfs2_io_tracking_new_with_tag(tag, pinfo->num);
}
else
val = (pvfs2_io_tracking_value_t *)wmem_map_lookup(pvfs2_io_tracking_value_table, &key);
/* If this frame contains a known PVFS_SERV_IO tag, track it */
- if (val && !pinfo->fd->flags.visited)
+ if (val && !pinfo->fd->visited)
{
/* If response HAS NOT been seen, mark this frame as response */
if (val->response_frame_num == 0)
transportLayerAddress_ipv4 = private_data_get_transportLayerAddress_ipv4(actx);
binding_id = private_data_get_binding_id_port(actx);
- if (actx->pinfo->fd->flags.visited || transportLayerAddress_ipv4 == 0 || binding_id == 0){
+ if (actx->pinfo->fd->visited || transportLayerAddress_ipv4 == 0 || binding_id == 0){
return offset;
}
set_address(&ipv4_addr, AT_IPv4, 4, &transportLayerAddress_ipv4);
transportLayerAddress_ipv4 = private_data_get_transportLayerAddress_ipv4(actx);
binding_id = private_data_get_binding_id_port(actx);
- if (actx->pinfo->fd->flags.visited || transportLayerAddress_ipv4 == 0 || binding_id == 0){
+ if (actx->pinfo->fd->visited || transportLayerAddress_ipv4 == 0 || binding_id == 0){
return offset;
}
set_address(&ipv4_addr, AT_IPv4, 4, &transportLayerAddress_ipv4);
/* If this isn't the first time this packet has been processed,
we've already done this work, so we don't need to do it
again. */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
return;
}
conversation_add_proto_data(conversation, proto_reload_framing, reload_framing_info);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if ((reload_frame = (reload_frame_t *)
wmem_tree_lookup32_array(reload_framing_info->transaction_pdus, transaction_id_key)) == NULL) {
transaction_id_key[2].key = key_save;
message_code = tvb_get_ntohs(tvb, offset);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if ((reload_trans = (reload_transaction_t *)
wmem_tree_lookup32_array(reload_info->transaction_pdus, transaction_id_key)) == NULL) {
key[4].length = 0;
key[4].key = NULL;
- if (!pinfo->fd->flags.visited && !(cmd & 0x01)) {
+ if (!pinfo->fd->visited && !(cmd & 0x01)) {
command_data = wmem_new(wmem_file_scope(), command_data_t);
command_data->bus_id = bus_id;
command_data->device_address = device_address;
if (command_data && (command_data->response_frame_number == 0 ||
command_data->response_frame_number == pinfo->num)) {
- if (!pinfo->fd->flags.visited && command_data->response_frame_number == 0) {
+ if (!pinfo->fd->visited && command_data->response_frame_number == 0) {
command_data->response_frame_number = pinfo->num;
}
guint32 snLimit = 0;
/* If find stat_report_in_frame already, use that and get out */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
p_report_in_frame = (sequence_analysis_report*)wmem_map_lookup(sequence_analysis_report_hash,
get_report_hash_key(sequenceNumber,
pinfo->num,
gint n, i, j;
/* If find state_report_in_frame already, use that and get out */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
p_report_in_frame = (channel_repeated_nack_report*)wmem_map_lookup(repeated_nack_report_hash,
get_report_hash_key(0, pinfo->num,
p_rlc_lte_info, FALSE));
guint32 snLimit;
/* If find stat_report_in_frame already, use that and get out */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
p_report_in_frame = (sequence_analysis_report*)wmem_map_lookup(sequence_analysis_report_hash,
get_report_hash_key(0, pinfo->num,
p_rlc_lte_info,
gint stringlen;
/* Won't change state if already seen this packet */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
return;
}
gint key = cid;
guint32 sn;
- if (!pinfo->fd->flags.visited){
+ if (!pinfo->fd->visited){
rohc_cid_context = (rohc_cid_context_t*)g_hash_table_lookup(rohc_cid_hash, GUINT_TO_POINTER(key));
if(rohc_cid_context){
p_add_proto_data(wmem_file_scope(), pinfo, proto_rohc, 0, rohc_cid_context);
* Update it if we do otherwise create it
* and fill in the info.
*/
- if (!pinfo->fd->flags.visited){
+ if (!pinfo->fd->visited){
gint key = cid;
rohc_cid_context = (rohc_cid_context_t*)g_hash_table_lookup(rohc_cid_hash, GUINT_TO_POINTER(key));
if (rohc_cid_context != NULL){
* Update it if we do otherwise create it
* and fill in the info.
*/
- if (!pinfo->fd->flags.visited){
+ if (!pinfo->fd->visited){
gint key = cid;
rohc_cid_context = (rohc_cid_context_t*)g_hash_table_lookup(rohc_cid_hash, GUINT_TO_POINTER(key));
return tvb_captured_length(tvb);
}
- if (!pinfo->fd->flags.visited){
+ if (!pinfo->fd->visited){
gint key = cid;
/*g_warning("Lookup CID %u",cid);*/
segment boundaries and allow it to find RPC headers
that starts in the middle of a TCP segment.
*/
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
if(len>tvb_reported_length_remaining(tvb, offset)){
pinfo->want_pdu_tracking=2;
pinfo->bytes_until_next_pdu=len-tvb_reported_length_remaining(tvb, offset);
if (psn >= p_request->psn && psn < epsn) {
/* Current fragment belongs to this request */
p_rdma_conv_info->segment_info = p_segment_info;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
p_request->rbytes += frag_size;
}
return msg_num + psn - p_request->psn;
/* Get current segment */
p_segment_info = find_segment_info(p_rdma_conv_info, gp_infiniband_info->reth_remote_key);
- if (p_segment_info && !pinfo->fd->flags.visited) {
+ if (p_segment_info && !pinfo->fd->visited) {
/* Add request to segment */
p_request = (request_t *)wmem_alloc(wmem_file_scope(), sizeof(request_t));
p_request->psn = gp_infiniband_info->packet_seq_num;
if (fd_head == NULL) {
if (p_segment_info == NULL) {
return NULL;
- } else if (p_rdma_chunk->type == RDMA_REPLY_CHUNK && !setup && !pinfo->fd->flags.visited) {
+ } else if (p_rdma_chunk->type == RDMA_REPLY_CHUNK && !setup && !pinfo->fd->visited) {
/*
* The RPC reply has no data when having a reply chunk but it needs
* to reassemble all fragments (more_frags = FALSE) in this frame
*/
write_size = get_rdma_list_size(rdma_lists.p_write_list, pinfo);
- if (write_size > 0 && !pinfo->fd->flags.visited) {
+ if (write_size > 0 && !pinfo->fd->visited) {
/* Initialize array of write chunk offsets */
gp_rdma_write_offsets = wmem_array_new(wmem_packet_scope(), sizeof(gint));
TRY {
g_rpcrdma_reduced = FALSE;
}
ENDTRY;
- } else if (write_size > 0 && pinfo->fd->flags.visited) {
+ } else if (write_size > 0 && pinfo->fd->visited) {
/*
* Reassembly is done on the second pass (visited = 1)
* This is done because dissecting the upper layer(s) again
* All fragments were added during the first pass,
* reassembly just needs to be completed here
*/
- save_visited = pinfo->fd->flags.visited;
- pinfo->fd->flags.visited = 0;
+ save_visited = pinfo->fd->visited;
+ pinfo->fd->visited = 0;
fd_head = fragment_end_seq_next(&rpcordma_reassembly_table, pinfo, p_segment_info->msgid, NULL);
if (fd_head) {
/* Add the fragment head to the packet cache */
p_add_proto_data(wmem_file_scope(), pinfo, proto_rpcordma, 0, fd_head);
}
- pinfo->fd->flags.visited = save_visited;
+ pinfo->fd->visited = save_visited;
}
}
}
rsvd_conv_data->task = NULL;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
guint64 *key_copy = wmem_new(wmem_file_scope(), guint64);
*key_copy = request_id;
* we've already done this work, so we don't need to do it
* again.
*/
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
return;
}
conversation_add_proto_data(conversation, proto_rtitcp, rtitcp_info);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (!(control_message_kind & RTITCP_FLAG_NOT_REQUEST)) {
/* This is a request */
rtitcp_trans=wmem_new(wmem_file_scope(), rtitcp_transaction_t);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "RTMP");
RTMPT_DEBUG("Dissect: frame=%u visited=%d len=%d tree=%p\n",
- pinfo->num, pinfo->fd->flags.visited,
+ pinfo->num, pinfo->fd->visited,
tvb_reported_length_remaining(tvb, offset), tree);
/* Clear any previous data in Info column (RTMP packets are protected by a "fence") */
RTMPT_DEBUG("Segment: cdir=%d seq=%d-%d\n", cdir, seq, seq+remain-1);
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
/* Already done the work, so just dump the existing state */
wmem_stack_t *packets;
* we've already done this work, so we don't need to do it
* again.
*/
- if ((pinfo->fd->flags.visited) || (rtp_handle == NULL))
+ if ((pinfo->fd->visited) || (rtp_handle == NULL))
{
return;
}
* we've already done this work, so we don't need to do it
* again.
*/
- if ((pinfo->fd->flags.visited) || (rtp_handle == NULL) || (rtp_rfc4571_handle == NULL))
+ if ((pinfo->fd->visited) || (rtp_handle == NULL) || (rtp_rfc4571_handle == NULL))
{
return;
}
g_debug("\tRTP Must Desegment: tvb_len=%d ds_len=%d %d frag_len=%d ds_off=%d",
tvb_reported_length(newtvb),
pinfo->desegment_len,
- pinfo->fd->flags.visited,
+ pinfo->fd->visited,
frag_len,
deseg_offset);
#endif
gboolean dissect_return_value = FALSE;
type_mapping * type_mapping_object = NULL;
const gchar * param_name = NULL;
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
type_mapping_object = wmem_new(wmem_file_scope(), type_mapping);
rtps_parameter_sequence_tree = proto_tree_add_subtree_format(tree, tvb, offset, size,
pitem = proto_tree_add_double(sbc_tree, hf_sbc_delta_time_from_the_beginning, tvb, offset, 0, nstime_to_msec(&delta));
PROTO_ITEM_SET_GENERATED(pitem);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
info->current_media_packet_info->cumulative_frame_duration += cumulative_frame_duration;
info->current_media_packet_info->avrcp_song_position += cumulative_frame_duration;
}
/* We must store the service action for this itlq
* so we can identify what the data contains
*/
- if ((!pinfo->fd->flags.visited) || (!cdata->itlq->extra_data)) {
+ if ((!pinfo->fd->visited) || (!cdata->itlq->extra_data)) {
scsi_osd_extra_data_t *extra_data;
extra_data = wmem_new0(wmem_file_scope(), scsi_osd_extra_data_t);
is_retransmission = (t->first_transmit.framenum != framenum);
- if ( (! pinfo->fd->flags.visited ) && is_retransmission ) {
+ if ( (! pinfo->fd->visited ) && is_retransmission ) {
retransmit_t **r;
int i;
DPRINT2(("-------------------- setup_sdp_transport -------------------"));
/* Only do this once during first pass */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
DPRINT(("already visited"));
return;
}
memset(&sdp_data, 0, sizeof(sdp_data));
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
transport_info = (transport_info_t*)wmem_tree_lookup32( sdp_transport_reqs, pinfo->num );
if (transport_info == NULL) {
/* For messages not part of the Offer/Answer model, assume that the SDP is
* immediately effective (apply it now). */
- if ((!pinfo->fd->flags.visited) && (transport_info == &local_transport_info)) {
+ if ((!pinfo->fd->visited) && (transport_info == &local_transport_info)) {
/* XXX - This is a placeholder for higher layer protocols that haven't implemented the proper
* OFFER/ANSWER functionality using setup_sdp_transport(). Once all of the higher layers
* use setup_sdp_transport(), this should be removed
msg_type = tvb_get_ntohs(selfm_tvb, offset);
/* On first pass through the packets we have 4 tasks to complete - they are each noted below */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
conversation_t *conversation;
fm_conversation *fm_conv_data;
}
/* Return any answer stored from previous dissection */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
sip_frame_result = (sip_frame_result_value*)p_get_proto_data(wmem_file_scope(), pinfo, proto_sip, pinfo->curr_layer_num);
if (sip_frame_result != NULL)
}
/* Return any answer stored from previous dissection */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
sip_frame_result = (sip_frame_result_value*)p_get_proto_data(wmem_file_scope(), pinfo, proto_sip, pinfo->curr_layer_num);
if (sip_frame_result != NULL)
}
/* Return any answer stored from previous dissection */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
sip_frame_result = (sip_frame_result_value*)p_get_proto_data(wmem_file_scope(), pinfo, proto_sip, pinfo->curr_layer_num);
if (sip_frame_result != NULL)
proto_tree *tree, guint32 remaining_length)
{
gboolean save_fragmented = pinfo->fragmented;
- int save_visited = pinfo->fd->flags.visited;
+ int save_visited = pinfo->fd->visited;
conversation_t *conversation = NULL;
fragment_head *fd_head = NULL;
tvbuff_t *payload_tvb = NULL;
if (fd_head == NULL) {
fd_head_not_cached = TRUE;
- pinfo->fd->flags.visited = 0;
+ pinfo->fd->visited = 0;
fd_head = fragment_add_seq_next(&smb_direct_reassembly_table,
tvb, 0, pinfo,
conversation->conv_index,
}
done:
pinfo->fragmented = save_fragmented;
- pinfo->fd->flags.visited = save_visited;
+ pinfo->fd->visited = save_visited;
return;
}
} else if(strncmp(mailslot,"MSSP",4) == 0){
trans_subcmd=MAILSLOT_MSSP;
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (tri != NULL)
tri->trans_subcmd = trans_subcmd;
}
trp = (smb_transact_info_t *)smb_info->sip->extra_info;
level = tvb_get_letohs(tvb, offset);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
if (trp)
trp->info_level = level; /* remember this for the response */
* the code parsing the reply, and initialize the detail
* level to -1, meaning "unknown".
*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
trp->lanman_cmd = cmd;
trp->info_level = -1;
trp->param_descrip=NULL;
param_descrip = tvb_get_const_stringz(p_tvb, offset, &descriptor_len);
proto_tree_add_item(tree, hf_param_desc, p_tvb, offset,
descriptor_len, ENC_ASCII|ENC_NA);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* Save the parameter descriptor for future use.
*/
data_descrip = tvb_get_const_stringz(p_tvb, offset, &descriptor_len);
proto_tree_add_item(tree, hf_return_desc, p_tvb, offset,
descriptor_len, ENC_ASCII|ENC_NA);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* Save the return descriptor for future use.
*/
aux_data_descrip = tvb_get_const_stringz(p_tvb, offset, &descriptor_len);
proto_tree_add_item(tree, hf_aux_data_desc, p_tvb, offset,
descriptor_len, ENC_ASCII|ENC_NA);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* Save the auxiliary data descriptor for
* future use.
pdu and if not, check if the dissector wants us
to reassemble it
*/
- if(!pinfo->fd->flags.visited){
+ if(!pinfo->fd->visited){
/*
* This is the first pass.
*
trans_subcmd=PIPE_DCERPC;
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (tri == NULL)
return FALSE;
tri->trans_subcmd = trans_subcmd;
info_level = tvb_get_letohs(p_tvb, offset);
proto_tree_add_uint(pipe_tree, hf_smb_pipe_getinfo_info_level,
p_tvb, offset, 2, info_level);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
tri->info_level = info_level;
} else {
guint8 pipe_namelen;
return NULL;
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
fd_head = fragment_add(&smb_trans_reassembly_table, tvb, offset,
pinfo, si->sip->frame_req, NULL,
pos, count, more_frags);
tr = proto_tree_add_subtree(tree, tvb, offset, bc, ett_smb_dialects, NULL, "Requested Dialects");
- if (!pinfo->fd->flags.visited && si->sip) {
+ if (!pinfo->fd->visited && si->sip) {
dialects = wmem_new(wmem_file_scope(), struct negprot_dialects);
dialects->num = 0;
si->sip->extra_info_type = SMB_EI_DIALECTS;
len, str);
COUNT_BYTES(len);
- if (!pinfo->fd->flags.visited && dialects && (dialects->num < MAX_DIALECTS)) {
+ if (!pinfo->fd->visited && dialects && (dialects->num < MAX_DIALECTS)) {
dialects->name[dialects->num++] = wmem_strdup(wmem_file_scope(), str);
}
}
dn = get_unicode_or_ascii_string(tvb, &offset, si->unicode, &dn_len,
FALSE, FALSE, &bc);
- if ((!pinfo->fd->flags.visited) && si->sip) {
+ if ((!pinfo->fd->visited) && si->sip) {
si->sip->extra_info_type = SMB_EI_FILENAME;
si->sip->extra_info = wmem_strdup(wmem_file_scope(), dn);
}
tr = proto_item_add_subtree(it, ett_smb_tid);
offset += 2;
- if ((!pinfo->fd->flags.visited) && is_created) {
+ if ((!pinfo->fd->visited) && is_created) {
tid_info = wmem_new(wmem_file_scope(), smb_tid_info_t);
tid_info->opened_in = pinfo->num;
tid_info->closed_in = 0;
return offset;
}
- if ((!pinfo->fd->flags.visited) && is_closed) {
+ if ((!pinfo->fd->visited) && is_closed) {
tid_info->closed_in = pinfo->num;
}
/* store it for the fid->name/openframe/closeframe matching in
* dissect_smb_fid() called from the response.
*/
- if ((!pinfo->fd->flags.visited) && si->sip && fn) {
+ if ((!pinfo->fd->visited) && si->sip && fn) {
fsi = wmem_new0(wmem_file_scope(), smb_fid_saved_info_t);
fsi->filename = wmem_strdup(wmem_file_scope(), fn);
tr = proto_item_add_subtree(it, ett_smb_fid);
col_append_fstr(pinfo->cinfo, COL_INFO, ", FID: 0x%04x", fid);
- if ((!pinfo->fd->flags.visited) && is_created) {
+ if ((!pinfo->fd->visited) && is_created) {
fid_info = wmem_new(wmem_file_scope(), smb_fid_info_t);
fid_info->opened_in = pinfo->num;
fid_info->closed_in = 0;
/* Store the fid in the transaction structure and remember if
it was in the request or in the reply we saw it
*/
- if (sip && (!is_generated) && (!pinfo->fd->flags.visited)) {
+ if (sip && (!is_generated) && (!pinfo->fd->visited)) {
sip->fid = fid;
if (si->request) {
sip->fid_seen_in_request = TRUE;
}
}
- if ((!pinfo->fd->flags.visited) && is_closed) {
+ if ((!pinfo->fd->visited) && is_closed) {
fid_info->closed_in = pinfo->num;
}
/* store it for the fid->name/openframe/closeframe matching in
* dissect_smb_fid() called from the response.
*/
- if ((!pinfo->fd->flags.visited) && si->sip && fn) {
+ if ((!pinfo->fd->visited) && si->sip && fn) {
fsi = wmem_new0(wmem_file_scope(), smb_fid_saved_info_t);
fsi->filename = wmem_strdup(wmem_file_scope(), fn);
fsi->file_attributes = file_attributes;
fn = get_unicode_or_ascii_string(tvb, &offset, si->unicode, &fn_len,
FALSE, FALSE, &bc);
- if ((!pinfo->fd->flags.visited) && si->sip) {
+ if ((!pinfo->fd->visited) && si->sip) {
si->sip->extra_info_type = SMB_EI_FILENAME;
si->sip->extra_info = wmem_strdup(wmem_file_scope(), fn);
}
END_OF_SMB
/* save the offset/len for this transaction */
- if (si->sip && !pinfo->fd->flags.visited) {
+ if (si->sip && !pinfo->fd->visited) {
rni = (smb_rename_saved_info_t *)wmem_alloc(wmem_file_scope(), sizeof(smb_rename_saved_info_t));
rni->old_name = wmem_strdup(wmem_file_scope(), old_name);
rni->new_name = wmem_strdup(wmem_file_scope(), new_name);
offset += 2;
/* save the offset/len for this transaction */
- if (si->sip && !pinfo->fd->flags.visited) {
+ if (si->sip && !pinfo->fd->visited) {
rwi = wmem_new(wmem_file_scope(), rw_info_t);
rwi->offset = ofs;
rwi->len = cnt;
(cnt == 1) ? "" : "s", ofs);
/* save the offset/len for this transaction */
- if (si->sip && !pinfo->fd->flags.visited) {
+ if (si->sip && !pinfo->fd->visited) {
rwi = (rw_info_t *)wmem_alloc(wmem_file_scope(), sizeof(rw_info_t));
rwi->offset = ofs;
rwi->len = cnt;
BYTE_COUNT;
/* store the locking data for the response */
- if ((!pinfo->fd->flags.visited) && si->sip) {
+ if ((!pinfo->fd->visited) && si->sip) {
ld = (smb_locking_saved_info_t *)wmem_alloc(wmem_file_scope(), sizeof(smb_locking_saved_info_t));
ld->type = lt;
ld->oplock_level = ol;
/* Copied this portion of code from create_andx_request
to guarantee that fsi and si->sip are always correctly filled out */
- if ((!pinfo->fd->flags.visited) && si->sip && fn) {
+ if ((!pinfo->fd->visited) && si->sip && fn) {
smb_fid_saved_info_t *fsi;
fsi = wmem_new0(wmem_file_scope(), smb_fid_saved_info_t);
maxcnt, (maxcnt == 1) ? "" : "s", ofs);
/* save the offset/len for this transaction */
- if (si->sip && !pinfo->fd->flags.visited) {
+ if (si->sip && !pinfo->fd->visited) {
rwi = (rw_info_t *)wmem_alloc(wmem_file_scope(), sizeof(rw_info_t));
rwi->offset = ofs;
rwi->len = maxcnt;
datalen, (datalen == 1) ? "" : "s", ofs);
/* save the offset/len for this transaction */
- if (si->sip && !pinfo->fd->flags.visited) {
+ if (si->sip && !pinfo->fd->visited) {
rwi = (rw_info_t *)wmem_alloc(wmem_file_scope(), sizeof(rw_info_t));
rwi->offset = ofs;
rwi->len = datalen;
bc -= 2;
datalen -= 2;
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* In case we did not see the TreeConnect call,
store this TID here as well as a IPC TID
so we know that future Read/Writes to this
}
/* If we have found a uid->acct_name mapping, store it */
- if (!pinfo->fd->flags.visited && si->sip) {
+ if (!pinfo->fd->visited && si->sip) {
int idx = 0;
if ((ntlmssph = (const ntlmssp_header_t *)fetch_tapped_data(ntlmssp_tap_id, idx + 1 )) != NULL) {
if (ntlmssph && (ntlmssph->type == 3)) {
WORD_COUNT;
- if (!pinfo->fd->flags.visited && si->sip && si->sip->extra_info &&
+ if (!pinfo->fd->visited && si->sip && si->sip->extra_info &&
(si->sip->extra_info_type == SMB_EI_UID)) {
smb_uid_t *smb_uid;
/* store it for the tid->name/openframe/closeframe matching in
* dissect_smb_tid() called from the response.
*/
- if ((!pinfo->fd->flags.visited) && si->sip && an) {
+ if ((!pinfo->fd->visited) && si->sip && an) {
si->sip->extra_info_type = SMB_EI_TIDNAME;
si->sip->extra_info = wmem_strdup(wmem_file_scope(), an);
}
/* Now when we know the service type, store it so that we know it for later commands down
this tree */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Remove any previous entry for this TID */
if (g_hash_table_lookup(si->ct->tid_service, GUINT_TO_POINTER(si->tid))) {
g_hash_table_remove(si->ct->tid_service, GUINT_TO_POINTER(si->tid));
ntd.subcmd = subcmd;
if (!si->unidir && sip) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* Allocate a new smb_nt_transact_info_t
* structure.
/* store it for the fid->name/openframe/closeframe matching in
* dissect_smb_fid() called from the response.
*/
- if ((!pinfo->fd->flags.visited) && si->sip && fn) {
+ if ((!pinfo->fd->visited) && si->sip && fn) {
smb_fid_saved_info_t *fsi;
fsi = wmem_new(wmem_file_scope(), smb_fid_saved_info_t);
if ((si->sip != NULL) && (si->sip->extra_info_type == SMB_EI_T2I)) {
t2i = (smb_transact2_info_t *)si->sip->extra_info;
if (t2i != NULL) {
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
t2i->resume_keys = (mask & FF2_RESUME);
}
}
/* Find First2 information level */
CHECK_BYTE_COUNT_TRANS(2);
si->info_level = tvb_get_letohs(tvb, offset);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_ff2_information_level, tvb, offset, 2, si->info_level);
COUNT_BYTES_TRANS(2);
/* Find First2 information level */
CHECK_BYTE_COUNT_TRANS(2);
si->info_level = tvb_get_letohs(tvb, offset);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_ff2_information_level, tvb, offset, 2, si->info_level);
COUNT_BYTES_TRANS(2);
/* level of interest */
CHECK_BYTE_COUNT_TRANS(2);
si->info_level = tvb_get_letohs(tvb, offset);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_qfsi_information_level, tvb, offset, 2, si->info_level);
COUNT_BYTES_TRANS(2);
/* level of interest */
CHECK_BYTE_COUNT_TRANS(4);
si->info_level = tvb_get_letohs(tvb, offset+2);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_sfsi_information_level, tvb, offset+2, 2, si->info_level);
COUNT_BYTES_TRANS(4);
/* level of interest */
CHECK_BYTE_COUNT_TRANS(2);
si->info_level = tvb_get_letohs(tvb, offset);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_qpi_loi, tvb, offset, 2, si->info_level);
COUNT_BYTES_TRANS(2);
/* level of interest */
CHECK_BYTE_COUNT_TRANS(2);
si->info_level = tvb_get_letohs(tvb, offset);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_spi_loi, tvb, offset, 2, si->info_level);
COUNT_BYTES_TRANS(2);
/* level of interest */
CHECK_BYTE_COUNT_TRANS(2);
si->info_level = tvb_get_letohs(tvb, offset);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_qpi_loi, tvb, offset, 2, si->info_level);
COUNT_BYTES_TRANS(2);
/* level of interest */
CHECK_BYTE_COUNT_TRANS(2);
si->info_level = tvb_get_letohs(tvb, offset);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_spi_loi, tvb, offset, 2, si->info_level);
COUNT_BYTES_TRANS(2);
/* Find Notify information level */
CHECK_BYTE_COUNT_TRANS(2);
si->info_level = tvb_get_letohs(tvb, offset);
- if ((t2i != NULL) && !pinfo->fd->flags.visited)
+ if ((t2i != NULL) && !pinfo->fd->visited)
t2i->info_level = si->info_level;
proto_tree_add_uint(tree, hf_smb_fn_information_level, tvb, offset, 2, si->info_level);
COUNT_BYTES_TRANS(2);
"Unknown (0x%02x)"));
if (!si->unidir) {
- if (!pinfo->fd->flags.visited && si->sip) {
+ if (!pinfo->fd->visited && si->sip) {
/*
* Allocate a new
* smb_transact2_info_t
}
if (!si->unidir) {
- if (!pinfo->fd->flags.visited && si->sip) {
+ if (!pinfo->fd->visited && si->sip) {
/*
* Allocate a new smb_transact_info_t
* structure.
si->unidir = TRUE; /*we don't expect an answer to this one*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* try to find which original call we match and if we
find it add us to the matched table. Don't touch
anything else since we don't want this one to mess
} else { /* normal bidirectional request or response */
si->unidir = FALSE;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* first see if we find an unmatched smb "equal" to
the current one
*/
* having a response that means that the share was mapped and we
* need to track it
*/
- if (!pinfo->fd->flags.visited && (si->cmd == 0x75) && !si->request) {
+ if (!pinfo->fd->visited && (si->cmd == 0x75) && !si->request) {
offset = dissect_smb_tid(tvb, pinfo, htree, offset, (guint16)si->tid, TRUE, FALSE, si);
} else {
offset = dissect_smb_tid(tvb, pinfo, htree, offset, (guint16)si->tid, FALSE, FALSE, si);
switch (mode) {
case FID_MODE_OPEN:
offset = dissect_nt_guid_hnd(tvb, offset, pinfo, tree, &di, drep, hf_smb2_fid, &policy_hnd, &hnd_item, TRUE, FALSE);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
sfi = wmem_new(wmem_file_scope(), smb2_fid_info_t);
*sfi = sfi_key;
if (si->saved && si->saved->extra_info_type == SMB2_EI_FILENAME) {
offset = dissect_smb2_olb_tvb_max_offset(offset, &s_olb);
/* If we have found a uid->acct_name mapping, store it */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
idx = 0;
while ((ntlmssph = (const ntlmssp_header_t *)fetch_tapped_data(ntlmssp_tap_id, idx++)) != NULL) {
if (ntlmssph && ntlmssph->type == NTLMSSP_AUTH) {
/* If we have found a uid->acct_name mapping, store it */
#ifdef HAVE_KERBEROS
- if (!pinfo->fd->flags.visited && si->status == 0) {
+ if (!pinfo->fd->visited && si->status == 0) {
enc_key_t *ek;
if (krb_decrypt) {
/* treelen +1 is overkill here if the string is unicode,
* but who ever has more than a handful of TCON in a trace anyways
*/
- if (!pinfo->fd->flags.visited && si->saved && buf && olb.len) {
+ if (!pinfo->fd->visited && si->saved && buf && olb.len) {
si->saved->extra_info_type = SMB2_EI_TREENAME;
si->saved->extra_info = wmem_alloc(wmem_file_scope(), olb.len+1);
g_snprintf((char *)si->saved->extra_info,olb.len+1,"%s",buf);
proto_tree_add_item(tree, hf_smb2_reserved, tvb, offset, 1, ENC_NA);
offset += 1;
- if (!pinfo->fd->flags.visited && si->saved && si->saved->extra_info_type == SMB2_EI_TREENAME && si->session) {
+ if (!pinfo->fd->visited && si->saved && si->saved->extra_info_type == SMB2_EI_TREENAME && si->session) {
smb2_tid_info_t *tid, tid_key;
tid_key.tid = si->tid;
offset = dissect_smb2_olb_tvb_max_offset(offset, &olb);
- if (!pinfo->fd->flags.visited && si->saved && olb.len) {
+ if (!pinfo->fd->visited && si->saved && olb.len) {
si->saved->extra_info_type = SMB2_EI_FINDPATTERN;
si->saved->extra_info = wmem_alloc(wmem_file_scope(), olb.len+1);
g_snprintf((char *)si->saved->extra_info,olb.len+1,"%s",buf);
PROTO_ITEM_SET_GENERATED(item);
}
- if (!pinfo->fd->flags.visited && si->saved && si->saved->extra_info_type == SMB2_EI_FINDPATTERN) {
+ if (!pinfo->fd->visited && si->saved && si->saved->extra_info_type == SMB2_EI_FINDPATTERN) {
col_append_fstr(pinfo->cinfo, COL_INFO, " %s Pattern: %s",
val_to_str(si->saved->infolevel, smb2_find_info_levels, "(Level:0x%02x)"),
(const char *)si->saved->extra_info);
* pdu and if not, check if the dissector wants us
* to reassemble it
*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* This is the first pass.
*
col_append_fstr(pinfo->cinfo, COL_INFO, " File: %s", fname);
/* save the name if it looks sane */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (si->saved && si->saved->extra_info_type == SMB2_EI_FILENAME) {
wmem_free(wmem_file_scope(), si->saved->extra_info);
si->saved->extra_info = NULL;
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* see if we can find this msg_id in the unmatched table */
ssi = (smb2_saved_info_t *)g_hash_table_lookup(si->conv->unmatched, &ssi_key);
col_clear(pinfo->cinfo, COL_INFO);
/* SNA data should be printed in EBCDIC, not ASCII */
- pinfo->fd->flags.encoding = PACKET_CHAR_ENC_CHAR_EBCDIC;
+ pinfo->fd->encoding = PACKET_CHAR_ENC_CHAR_EBCDIC;
if (tree) {
col_clear(pinfo->cinfo, COL_INFO);
/* SNA data should be printed in EBCDIC, not ASCII */
- pinfo->fd->flags.encoding = PACKET_CHAR_ENC_CHAR_EBCDIC;
+ pinfo->fd->encoding = PACKET_CHAR_ENC_CHAR_EBCDIC;
if (tree) {
/* May need to move to reassembled frame to show there instead of here */
- if (snort_alert_in_reassembled_frame && pinfo->fd->flags.visited && (tree != NULL)) {
+ if (snort_alert_in_reassembled_frame && pinfo->fd->visited && (tree != NULL)) {
guint reassembled_frame = get_reassembled_in_frame(tree);
if (reassembled_frame && (reassembled_frame != pinfo->num)) {
}
else {
/* We expect alerts from Snort. Pass frame into snort on first pass. */
- if (!pinfo->fd->flags.visited && current_session.working) {
+ if (!pinfo->fd->visited && current_session.working) {
int write_err = 0;
gchar *err_info;
wtap_rec rec;
/* save server udp port and create udp conversation */
hash_info->udp_port = tvb_get_ntohs(tvb, offset);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
new_udp_conversation( hash_info, pinfo);
break;
col_append_str(pinfo->cinfo, COL_INFO, ", Traceroute Req");
/* run state machine if needed */
- if ((!pinfo->fd->flags.visited) &&
+ if ((!pinfo->fd->visited) &&
(!((hash_info->clientState == clientDone) &&
(hash_info->serverState == serverDone)))) {
next_tvb = tvb_new_subset_length(tvb, offset, frame->length);
is_single_chunk = num_data_frames == 0 &&
(frame->flags & SPDY_FLAG_FIN) != 0;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (!is_single_chunk) {
if (spdy_assemble_entity_bodies) {
copied_data = (guint8 *)tvb_memdup(wmem_file_scope(),next_tvb, 0, frame->length);
* If we expect data on this stream, we need to remember the content
* type and content encoding.
*/
- if (content_type != NULL && !pinfo->fd->flags.visited) {
+ if (content_type != NULL && !pinfo->fd->visited) {
gchar *content_type_params = spdy_parse_content_type(content_type);
spdy_save_stream_info(conv_data, stream_id,
(hdr_status == NULL) ? HTTP_REQUEST : HTTP_RESPONSE,
* negotiation in a conversation.
*/
next_level_value = (gssapi_oid_value *)p_get_proto_data(wmem_file_scope(), pinfo, proto_spnego, 0);
- if (!next_level_value && !pinfo->fd->flags.visited) {
+ if (!next_level_value && !pinfo->fd->visited) {
/*
* No handle attached to this frame, but it's the first
* pass, so it'd be attached to the conversation.
* we've already done this work, so we don't need to do it
* again.
*/
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
return;
}
val_to_str(msg_code, ssh1_msg_vals, "Unknown (%u)"));
offset += 1;
len = plen -1;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (peer_data->frame_key_start == 0)
peer_data->frame_key_start = pinfo->num;
peer_data->frame_key_end = pinfo->num;
conversation_add_proto_data(conversation, proto_stun, stun_info);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if ((stun_trans = (stun_transaction_t *)
wmem_tree_lookup32_array(stun_info->transaction_pdus,
transaction_id_key)) == NULL) {
bw_key[3].key = NULL;
- if ( !(assoc = (sua_assoc_info_t *)wmem_tree_lookup32_array(assocs,bw_key)) && ! pinfo->fd->flags.visited) {
+ if ( !(assoc = (sua_assoc_info_t *)wmem_tree_lookup32_array(assocs,bw_key)) && ! pinfo->fd->visited) {
assoc = new_assoc(opck, dpck);
wmem_tree_insert32_array(assocs,bw_key,assoc);
assoc->has_bw_key = TRUE;
pinfo->p2p_dir = P2P_DIR_RECV;
- if ( ! pinfo->fd->flags.visited && ! assoc->has_bw_key ) {
+ if ( ! pinfo->fd->visited && ! assoc->has_bw_key ) {
wmem_tree_insert32_array(assocs, bw_key, assoc);
assoc->has_bw_key = TRUE;
}
- if ( ! pinfo->fd->flags.visited && ! assoc->has_fw_key ) {
+ if ( ! pinfo->fd->visited && ! assoc->has_fw_key ) {
wmem_tree_insert32_array(assocs, fw_key, assoc);
assoc->has_fw_key = TRUE;
}
* struct is saved in the conversation and is copied to the
* per-packet information if a DATA frame is dissected.
*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (CFG2 == frame_type &&
check_crc(tvb, &crc)) {
conversation_t *conversation;
* we've already done this work, so we don't need to do it
* again.
*/
- if ((pinfo->fd->flags.visited) || (t38_udp_handle == NULL))
+ if ((pinfo->fd->visited) || (t38_udp_handle == NULL))
{
return;
}
fd_head = fragment_get(table, pinfo, id, NULL);
/* have we already seen this frame ?*/
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) {
return fd_head;
} else {
{
struct tcp_multisegment_pdu *msp=NULL;
- if(!pinfo->fd->flags.visited) {
+ if(!pinfo->fd->visited) {
msp=(struct tcp_multisegment_pdu *)wmem_tree_lookup32_le(multisegment_pdus, seq-1);
if(msp) {
/* If this is a continuation of a PDU started in a
* so that it can attempt to find it in case it starts
* somewhere in the middle of a segment.
*/
- if(!pinfo->fd->flags.visited && tcp_analyze_seq) {
+ if(!pinfo->fd->visited && tcp_analyze_seq) {
guint remaining_bytes;
remaining_bytes = tvb_reported_length_remaining(tvb, offset);
if(plen>remaining_bytes) {
tcp_info_append_uint(pinfo, "WS", 1 << shift);
- if(!pinfo->fd->flags.visited) {
+ if(!pinfo->fd->visited) {
pdu_store_window_scale_option(shift, tcpd);
}
if(is_tcp_segment) {
/* if !visited, check want_pdu_tracking and
store it in table */
- if(tcpd && (!pinfo->fd->flags.visited) &&
+ if(tcpd && (!pinfo->fd->visited) &&
tcp_analyze_seq && pinfo->want_pdu_tracking) {
if(seq || nxtseq) {
pdu_store_sequencenumber_of_next_pdu(
* if !visited, check want_pdu_tracking and store it
* in table
*/
- if(tcpd && (!pinfo->fd->flags.visited) && tcp_analyze_seq && pinfo->want_pdu_tracking) {
+ if(tcpd && (!pinfo->fd->visited) && tcp_analyze_seq && pinfo->want_pdu_tracking) {
if(seq || nxtseq) {
pdu_store_sequencenumber_of_next_pdu(pinfo,
seq,
if(tcpd && ((tcph->th_flags&(TH_SYN|TH_ACK))==TH_SYN) &&
(tcpd->fwd->static_flags & TCP_S_BASE_SEQ_SET) &&
(tcph->th_seq!=tcpd->fwd->base_seq) ) {
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
/* Reset the last frame seen in the conversation */
if (save_last_frame > 0)
conv->last_frame = save_last_frame;
if(tcpd && ((tcph->th_flags&(TH_SYN|TH_ACK))==(TH_SYN|TH_ACK)) &&
(tcpd->fwd->static_flags & TCP_S_BASE_SEQ_SET) &&
(tcph->th_seq!=tcpd->fwd->base_seq) ) {
- if (!(pinfo->fd->flags.visited)) {
+ if (!(pinfo->fd->visited)) {
/* Reset the last frame seen in the conversation */
if (save_last_frame > 0)
conv->last_frame = save_last_frame;
* Calculate the timestamps relative to this conversation (but only on the
* first run when frames are accessed sequentially)
*/
- if (!(pinfo->fd->flags.visited))
+ if (!(pinfo->fd->visited))
tcp_calculate_timestamps(pinfo, tcpd, tcppd);
}
/* handle TCP seq# analysis parse all new segments we see */
if(tcp_analyze_seq) {
- if(!(pinfo->fd->flags.visited)) {
+ if(!(pinfo->fd->visited)) {
tcp_analyze_sequence_number(pinfo, tcph->th_seq, tcph->th_ack, tcph->th_seglen, tcph->th_flags, tcph->th_win, tcpd);
}
if(tcpd && tcp_relative_seq) {
}
- if(!pinfo->fd->flags.visited) {
+ if(!pinfo->fd->visited) {
if((tcph->th_flags & TH_SYN)==TH_SYN) {
/* Check the validity of the window scale value
*/
/* decide if the packet is server to client or client to server
* then check its fragmentation
*/
- if(!(pinfo->fd->flags.visited))
+ if(!(pinfo->fd->visited))
{
if(conversation_data->server_port == pinfo->srcport)
{
* dissector versions was dissected only when a proto_tree context was
* available
*
- * We are at Packet reception if time pinfo->fd->flags.visited == 0
+ * We are at Packet reception if time pinfo->fd->visited == 0
*
*/
}
}
- ssl_debug_printf("\ndissect_ssl enter frame #%u (%s)\n", pinfo->num, (pinfo->fd->flags.visited)?"already visited":"first time");
+ ssl_debug_printf("\ndissect_ssl enter frame #%u (%s)\n", pinfo->num, (pinfo->fd->visited)?"already visited":"first time");
/* Track the version using conversations to reduce the
* chance that a packet that simply *looks* like a v2 or
/* try decryption only the first time we see this packet
* (to keep cipher synchronized) */
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
ssl_session = NULL;
ssl_debug_printf(" conversation = %p, ssl_session = %p\n", (void *)conversation, (void *)ssl_session);
SslSession *session;
gint is_from_server;
- ssl_debug_printf("\n%s enter frame #%u (%s)\n", G_STRFUNC, pinfo->num, (pinfo->fd->flags.visited)?"already visited":"first time");
+ ssl_debug_printf("\n%s enter frame #%u (%s)\n", G_STRFUNC, pinfo->num, (pinfo->fd->visited)?"already visited":"first time");
conversation = find_or_create_conversation(pinfo);
ssl_session = ssl_get_session(conversation, tls_handle);
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TN3270");
- pinfo->fd->flags.encoding = PACKET_CHAR_ENC_CHAR_EBCDIC;
+ pinfo->fd->encoding = PACKET_CHAR_ENC_CHAR_EBCDIC;
/* Do we have a conversation for this connection? */
conversation = find_conversation_pinfo(pinfo, 0);
if (!tn5250_info)
return 0;
- pinfo->fd->flags.encoding = PACKET_CHAR_ENC_CHAR_EBCDIC;
+ pinfo->fd->encoding = PACKET_CHAR_ENC_CHAR_EBCDIC;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TN5250");
}
/* Save request info (command_data) */
- if (!pinfo->fd->flags.visited && command != 21) {
+ if (!pinfo->fd->visited && command != 21) {
key[2].length = 1;
key[2].key = &k_frame_number;
key[3].length = 0;
* we've already done this work, so we don't need to do it
* again.
*/
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
break;
}
* we've already done this work, so we don't need to do it
* again.
*/
- if (pinfo->fd->flags.visited)
+ if (pinfo->fd->visited)
{
break;
}
/* Set Source IP = own IP */
copy_address_shallow(&src_addr, &pinfo->src);
}
- if((!pinfo->fd->flags.visited) && RTP_UDP_port!=0){
+ if((!pinfo->fd->visited) && RTP_UDP_port!=0){
rtp_add_address(pinfo, PT_UDP, &src_addr, RTP_UDP_port, 0, "UMA", pinfo->num, FALSE, 0);
if ((RTP_UDP_port & 0x1) == 0){ /* Even number RTP port RTCP should follow on odd number */
RTCP_UDP_port = tvb_get_ntohs(tvb,ie_offset);
proto_tree_add_item(urr_ie_tree, hf_uma_urr_RTCP_port, tvb, ie_offset, 2, ENC_BIG_ENDIAN);
/* TODO find out exactly which element contains IP addr */
- if((!pinfo->fd->flags.visited) && rtcp_ipv4_address!=0 && RTCP_UDP_port!=0 && rtcp_handle){
+ if((!pinfo->fd->visited) && rtcp_ipv4_address!=0 && RTCP_UDP_port!=0 && rtcp_handle){
set_address(&src_addr, AT_IPv4, 4, &rtcp_ipv4_address);
rtcp_add_address(pinfo, &src_addr, RTCP_UDP_port, 0, "UMA", pinfo->num);
}
/* Save request info (command_data) */
- if (!pinfo->fd->flags.visited && command != 21) {
+ if (!pinfo->fd->visited && command != 21) {
key[2].length = 1;
key[2].key = &k_frame_number;
key[3].length = 0;
proto_item_append_text(nitem, " (%s)", description);
offset += 1;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
guint k_bus_id;
guint k_device_address;
guint k_frame_number;
product_id);
offset += 2;
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
guint k_bus_id;
guint k_device_address;
guint k_frame_number;
class_str = val_to_str_ext(usb_conv_info->interfaceClass, &usb_class_vals_ext, "unknown (0x%X)");
proto_item_append_text(item, " (%u.%u): class %s", interface_num, alt_setting, class_str);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
usb_alt_setting_t alternate_setting;
/* Register conversation for this interface in case CONTROL messages are sent to it */
* All endpoints for the same interface descriptor share the same
* usb_conv_info structure.
*/
- if ((!pinfo->fd->flags.visited) && usb_trans_info && usb_trans_info->interface_info) {
+ if ((!pinfo->fd->visited) && usb_trans_info && usb_trans_info->interface_info) {
if (pinfo->destport == NO_ENDPOINT) {
address tmp_addr;
usb_address_t *usb_addr = wmem_new0(wmem_packet_scope(), usb_address_t);
} else {
/* this is a response */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
usb_trans_info = (usb_trans_info_t *)wmem_tree_lookup32_array(usb_conv_info->transactions, key);
} else {
return 2;
if ( cmd == 1) { /* uncompressed data */
- if ( !pinfo->fd->flags.visited){ /* if first pass */
+ if ( !pinfo->fd->visited){ /* if first pass */
wcp_save_data( tvb, pinfo);
}
next_tvb = tvb_new_subset_remaining(tvb, wcp_header_len);
data_cnt, data_offset+1);
return NULL;
}
- if ( !pinfo->fd->flags.visited){ /* if first pass */
+ if ( !pinfo->fd->visited){ /* if first pass */
dst = decompressed_entry(dst,
data_offset, data_cnt, &len,
buf_ptr);
return NULL;
}
- if ( !pinfo->fd->flags.visited){
+ if ( !pinfo->fd->visited){
/*
* This is the first pass through
* the packets, so copy it to the
}
}
- if ( pinfo->fd->flags.visited){ /* if not first pass */
+ if ( pinfo->fd->visited){ /* if not first pass */
/* get uncompressed data */
pdata_ptr = (wcp_pdata_t *)p_get_proto_data(wmem_file_scope(), pinfo, proto_wcp, 0);
ti = proto_tree_add_item(tree, proto_x11, tvb, 0, -1, ENC_NA);
t = proto_item_add_subtree(ti, ett_x11);
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
++state->sequencenumber;
OPCODE();
case PRT_ID_ISO_8073:
/* ISO 8073 COTP */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
x25_hash_add_proto_start(vc, pinfo->num, ositp_handle);
/* XXX - dissect the rest of the user data as COTP?
That needs support for NCM TPDUs, etc. */
case PRT_ID_ISO_8602:
/* ISO 8602 CLTP */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
x25_hash_add_proto_start(vc, pinfo->num, ositp_handle);
break;
}
proto_tree_add_item( userdata_tree, hf_x263_sec_protocol_id, tvb, localoffset, 1, ENC_BIG_ENDIAN);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* Is there a dissector handle for this SPI?
* If so, assign it to this virtual circuit.
/* Did the user suggest QLLC/SNA? */
if (payload_is_qllc_sna) {
/* Yes - dissect it as QLLC/SNA. */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
x25_hash_add_proto_start(vc, pinfo->num, qllc_handle);
call_dissector_with_data(qllc_handle, next_tvb, pinfo, tree, &q_bit_set);
return;
/* First byte contains the length of the remaining buffer */
if ((tvb_get_guint8(tvb, localoffset+1) & 0x0F) == 0) {
/* Second byte contains a valid COTP TPDU */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
x25_hash_add_proto_start(vc, pinfo->num, ositp_handle);
call_dissector(ositp_handle, next_tvb, pinfo, tree);
return;
case 0x45:
/* Looks like an IP header */
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
x25_hash_add_proto_start(vc, pinfo->num, ip_handle);
call_dissector(ip_handle, next_tvb, pinfo, tree);
return;
case NLPID_ISO8473_CLNP:
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
x25_hash_add_proto_start(vc, pinfo->num, clnp_handle);
call_dissector(clnp_handle, next_tvb, pinfo, tree);
return;
}
/* Update transaction entry */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (xmcp_msg_type_class == XMCP_CLASS_REQUEST) {
if (xmcp_trans->request_frame == 0) {
xmcp_trans->request_frame = pinfo->num;
id = wmem_strdup(wmem_packet_scope(), attr_id->value);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
xmpp_trans = (xmpp_transaction_t *)wmem_tree_lookup_string(xmpp_info->req_resp, id, WMEM_TREE_STRING_NOCASE);
if (xmpp_trans) {
xmpp_trans->resp_frame = pinfo->num;
jingle_packet_l = xmpp_find_element_by_name(packet,"jingle");
jingle_packet = (xmpp_element_t *)(jingle_packet_l?jingle_packet_l->data:NULL);
- if (jingle_packet && !pinfo->fd->flags.visited) {
+ if (jingle_packet && !pinfo->fd->visited) {
xmpp_attr_t *attr_id;
xmpp_attr_t *attr_sid;
gtalk_packet = (xmpp_element_t *)(gtalk_packet_l?gtalk_packet_l->data:NULL);
- if (gtalk_packet && !pinfo->fd->flags.visited) {
+ if (gtalk_packet && !pinfo->fd->visited) {
xmpp_attr_t *attr_id;
xmpp_attr_t *attr_sid;
ibb_packet = (xmpp_element_t *)(ibb_packet_l?ibb_packet_l->data:NULL);
}
- if (ibb_packet && !pinfo->fd->flags.visited) {
+ if (ibb_packet && !pinfo->fd->visited) {
xmpp_attr_t *attr_id;
xmpp_attr_t *attr_sid;
memset(&packet, 0, sizeof(packet));
/* Set up hint structures */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Allocate frame data with hints for upper layers */
nwk_hints = wmem_new0(wmem_file_scope(), zbee_nwk_hints_t);
p_add_proto_data(wmem_file_scope(), pinfo, proto_zbee_nwk, 0, nwk_hints);
proto_tree_add_item(nwk_tree, hf_zbee_nwk_src64, tvb, offset, 8, ENC_LITTLE_ENDIAN);
offset += 8;
- if (!pinfo->fd->flags.visited && nwk_hints) {
+ if (!pinfo->fd->visited && nwk_hints) {
/* Provide hints to upper layers */
nwk_hints->src_pan = ieee_packet->src_pan;
}
else {
/* See if extended source info was previously sniffed */
- if (!pinfo->fd->flags.visited && nwk_hints) {
+ if (!pinfo->fd->visited && nwk_hints) {
nwk_hints->src_pan = ieee_packet->src_pan;
addr16.addr = packet.src;
map_rec = (ieee802154_map_rec *) g_hash_table_lookup(ieee_packet->short_table, &addr16);
if (map_rec) nwk_hints->map_rec = map_rec;
}
- } /* (!pinfo->fd->flags.visited) */
+ } /* (!pinfo->fd->visited) */
else {
if (nwk_hints && nwk_hints->map_rec ) {
/* Display inferred source address info */
}
/* If ieee layer didn't know its extended source address, and nwk layer does, fill it in */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if ( (ieee_packet->src_addr_mode == IEEE802154_FCF_ADDR_SHORT) &&
ieee_hints && !ieee_hints->map_rec ) {
addr16.pan = ieee_packet->src_pan;
ieee_hints->map_rec = map_rec;
}
}
- } /* (!pinfo->fd->flags.visited */
+ } /* (!pinfo->fd->visited */
} /* (pinfo->zbee_stack_vers >= ZBEE_VERSION_2007) */
/* Add multicast control field (ZigBee 2006 and later). */
packet.src64 = tvb_get_letoh64(tvb, offset);
proto_tree_add_item(sec_tree, hf_zbee_sec_src64, tvb, offset, 8, ENC_LITTLE_ENDIAN);
#if 1
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
switch ( packet.key_id ) {
case ZBEE_SEC_KEY_LINK:
if (nwk_hints && ieee_hints) {
decrypted = FALSE;
if ( packet.src64 ) {
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
if ( nwk_hints ) {
/* Use previously found key */
switch ( packet.key_id ) {
break;
}
}
- } /* ( !pinfo->fd->flags.visited ) */
+ } /* ( !pinfo->fd->visited ) */
else {
/* We only search for sniffed keys in the first pass,
* to save time, and because decrypting with keys
}
}
}
- } /* ( ! pinfo->fd->flags.visited ) */
+ } /* ( ! pinfo->fd->visited ) */
} /* ( packet.src64 ) */
if ( decrypted ) {
zbee_nwk_hints_t *nwk_hints;
/* Update the key ring for this pan */
- if ( !pinfo->fd->flags.visited && (nwk_hints = (zbee_nwk_hints_t *)p_get_proto_data(wmem_file_scope(), pinfo,
+ if ( !pinfo->fd->visited && (nwk_hints = (zbee_nwk_hints_t *)p_get_proto_data(wmem_file_scope(), pinfo,
proto_get_id_by_filter_name(ZBEE_PROTOABBREV_NWK), 0))) {
nwk_keyring = (GSList **)g_hash_table_lookup(zbee_table_nwk_keyring, &nwk_hints->src_pan);
if ( !nwk_keyring ) {
* we've already done this work, so we don't need to do it
* again.
*/
- if (!pinfo->fd->flags.visited)
+ if (!pinfo->fd->visited)
{
conversation = find_or_create_conversation(pinfo);
if both packets' times are reference times, we compare the
times of the packets. */
#define COMPARE_TS_REAL(time1, time2) \
- ((fdata1->flags.ref_time && !fdata2->flags.ref_time) ? -1 : \
- (!fdata1->flags.ref_time && fdata2->flags.ref_time) ? 1 : \
+ ((fdata1->ref_time && !fdata2->ref_time) ? -1 : \
+ (!fdata1->ref_time && fdata2->ref_time) ? 1 : \
((time1).secs < (time2).secs) ? -1 : \
((time1).secs > (time2).secs) ? 1 : \
((time1).nsecs < (time2).nsecs) ? -1 :\
fdata->num = num;
fdata->file_off = offset;
fdata->subnum = 0;
- fdata->flags.passed_dfilter = 0;
- fdata->flags.dependent_of_displayed = 0;
- fdata->flags.encoding = PACKET_CHAR_ENC_CHAR_ASCII;
- fdata->flags.visited = 0;
- fdata->flags.marked = 0;
- fdata->flags.ref_time = 0;
- fdata->flags.ignored = 0;
- fdata->flags.has_ts = (rec->presence_flags & WTAP_HAS_TS) ? 1 : 0;
+ fdata->passed_dfilter = 0;
+ fdata->dependent_of_displayed = 0;
+ fdata->encoding = PACKET_CHAR_ENC_CHAR_ASCII;
+ fdata->visited = 0;
+ fdata->marked = 0;
+ fdata->ref_time = 0;
+ fdata->ignored = 0;
+ fdata->has_ts = (rec->presence_flags & WTAP_HAS_TS) ? 1 : 0;
switch (rec->rec_type) {
case REC_TYPE_PACKET:
break;
}
- /* To save some memory, we coerce it into a gint16 */
- g_assert(rec->tsprec <= G_MAXINT16);
- fdata->tsprec = (gint16)rec->tsprec;
+ /* To save some memory, we coerce it into 4 bits */
+ g_assert(rec->tsprec <= 0xF);
+ fdata->tsprec = (unsigned int)rec->tsprec;
fdata->abs_ts = rec->ts;
- fdata->flags.has_phdr_comment = (rec->opt_comment != NULL);
- fdata->flags.has_user_comment = 0;
- fdata->flags.need_colorize = 0;
+ fdata->has_phdr_comment = (rec->opt_comment != NULL);
+ fdata->has_user_comment = 0;
+ fdata->need_colorize = 0;
fdata->color_filter = NULL;
fdata->shift_offset.secs = 0;
fdata->shift_offset.nsecs = 0;
/* if this frames is marked as a reference time frame,
set reference frame this frame */
- if(fdata->flags.ref_time)
+ if(fdata->ref_time)
*frame_ref = fdata;
/* Get the time elapsed between the first packet and this packet. */
/* This frame either passed the display filter list or is marked as
a time reference frame. All time reference frames are displayed
even if they don't pass the display filter */
- if(fdata->flags.ref_time){
+ if(fdata->ref_time){
/* if this was a TIME REF frame we should reset the cul bytes field */
*cum_bytes = fdata->pkt_len;
fdata->cum_bytes = *cum_bytes;
void
frame_data_reset(frame_data *fdata)
{
- fdata->flags.visited = 0;
+ fdata->visited = 0;
fdata->subnum = 0;
if (fdata->pfd) {
struct _packet_info;
struct epan_session;
-#define PINFO_FD_VISITED(pinfo) ((pinfo)->fd->flags.visited)
+#define PINFO_FD_VISITED(pinfo) ((pinfo)->fd->visited)
/** @file
* Low-level frame data and metadata.
/** The frame number is the ordinal number of the frame in the capture, so
it's 1-origin. In various contexts, 0 as a frame number means "frame
- number unknown". */
+ number unknown".
+
+ There is one of these structures for every frame in the capture.
+ That means a lot of memory if we have a lot of frames.
+ They are packed into power-of-2 chunks, so their size is effectively
+ rounded up to a power of 2.
+ Try to keep it close to, and less than or equal to, a power of 2.
+ "Smaller than a power of 2" is OK for ILP32 platforms.
+
+ XXX - shuffle the fields to try to keep the most commonly-accessed
+ fields within the first 16 or 32 bytes, so they all fit in a cache
+ line? */
struct _color_filter; /* Forward */
DIAG_OFF_PEDANTIC
typedef struct _frame_data {
- GSList *pfd; /**< Per frame proto data */
guint32 num; /**< Frame number */
guint32 pkt_len; /**< Packet length */
guint32 cap_len; /**< Amount actually captured */
guint32 cum_bytes; /**< Cumulative bytes into the capture */
gint64 file_off; /**< File offset */
- guint16 subnum; /**< subframe number, for protocols that require this */
- gint16 tsprec; /**< Time stamp precision */
- struct {
- unsigned int passed_dfilter : 1; /**< 1 = display, 0 = no display */
- unsigned int dependent_of_displayed : 1; /**< 1 if a displayed frame depends on this frame */
- /* Do NOT use packet_char_enc enum here: MSVC compiler does not handle an enum in a bit field properly */
- unsigned int encoding : 1; /**< Character encoding (ASCII, EBCDIC...) */
- unsigned int visited : 1; /**< Has this packet been visited yet? 1=Yes,0=No*/
- unsigned int marked : 1; /**< 1 = marked by user, 0 = normal */
- unsigned int ref_time : 1; /**< 1 = marked as a reference time frame, 0 = normal */
- unsigned int ignored : 1; /**< 1 = ignore this frame, 0 = normal */
- unsigned int has_ts : 1; /**< 1 = has time stamp, 0 = no time stamp */
- unsigned int has_phdr_comment : 1; /** 1 = there's comment for this packet */
- unsigned int has_user_comment : 1; /** 1 = user set (also deleted) comment for this packet */
- unsigned int need_colorize : 1; /**< 1 = need to (re-)calculate packet color */
- } flags;
-
+ /* These two are pointers, meaning 64-bit on LP64 (64-bit UN*X) and
+ LLP64 (64-bit Windows) platforms. Put them here, one after the
+ other, so they don't require padding between them. */
+ GSList *pfd; /**< Per frame proto data */
const struct _color_filter *color_filter; /**< Per-packet matching color_filter_t object */
-
+ guint16 subnum; /**< subframe number, for protocols that require this */
+ /* Keep the bitfields below to 16 bits, so this plus the previous field
+ are 32 bits. */
+ unsigned int passed_dfilter : 1; /**< 1 = display, 0 = no display */
+ unsigned int dependent_of_displayed : 1; /**< 1 if a displayed frame depends on this frame */
+ /* Do NOT use packet_char_enc enum here: MSVC compiler does not handle an enum in a bit field properly */
+ unsigned int encoding : 1; /**< Character encoding (ASCII, EBCDIC...) */
+ unsigned int visited : 1; /**< Has this packet been visited yet? 1=Yes,0=No*/
+ unsigned int marked : 1; /**< 1 = marked by user, 0 = normal */
+ unsigned int ref_time : 1; /**< 1 = marked as a reference time frame, 0 = normal */
+ unsigned int ignored : 1; /**< 1 = ignore this frame, 0 = normal */
+ unsigned int has_ts : 1; /**< 1 = has time stamp, 0 = no time stamp */
+ unsigned int has_phdr_comment : 1; /** 1 = there's comment for this packet */
+ unsigned int has_user_comment : 1; /** 1 = user set (also deleted) comment for this packet */
+ unsigned int need_colorize : 1; /**< 1 = need to (re-)calculate packet color */
+ unsigned int tsprec : 4; /**< Time stamp precision -2^tsprec gives up to femtoseconds */
nstime_t abs_ts; /**< Absolute timestamp */
nstime_t shift_offset; /**< How much the abs_tm of the frame is shifted */
guint32 frame_ref_num; /**< Previous reference frame (0 if this is one) */
if (dependent_frame && frames) {
dependent_fd = frame_data_sequence_find(frames, dependent_frame);
- dependent_fd->flags.dependent_of_displayed = 1;
+ dependent_fd->dependent_of_displayed = 1;
}
}
edt->pi.cinfo = cinfo;
edt->pi.presence_flags = 0;
edt->pi.num = fd->num;
- if (fd->flags.has_ts) {
+ if (fd->has_ts) {
edt->pi.presence_flags |= PINFO_HAS_TS;
edt->pi.abs_ts = fd->abs_ts;
}
frame_delta_abs_time(edt->session, fd, fd->frame_ref_num, &edt->pi.rel_ts);
/* pkt comment use first user, later from rec */
- if (fd->flags.has_user_comment)
+ if (fd->has_user_comment)
frame_dissector_data.pkt_comment = epan_get_user_comment(edt->session, fd);
- else if (fd->flags.has_phdr_comment)
+ else if (fd->has_phdr_comment)
frame_dissector_data.pkt_comment = rec->opt_comment;
else
frame_dissector_data.pkt_comment = NULL;
}
ENDTRY;
- fd->flags.visited = 1;
+ fd->visited = 1;
}
/* Creates the top-most tvbuff and calls dissect_file() */
TRY {
/* pkt comment use first user, later from rec */
- if (fd->flags.has_user_comment)
+ if (fd->has_user_comment)
file_dissector_data.pkt_comment = epan_get_user_comment(edt->session, fd);
- else if (fd->flags.has_phdr_comment)
+ else if (fd->has_phdr_comment)
file_dissector_data.pkt_comment = rec->opt_comment;
else
file_dissector_data.pkt_comment = NULL;
}
ENDTRY;
- fd->flags.visited = 1;
+ fd->visited = 1;
}
/*********************** code added for sub-dissector lookup *********************/
data.stream = stream;
data.success = TRUE;
data.src_list = edt->pi.data_src;
- data.encoding = (packet_char_enc)edt->pi.fd->flags.encoding;
+ data.encoding = (packet_char_enc)edt->pi.fd->encoding;
data.print_dissections = print_dissections;
/* If we're printing the entire packet in hex, don't
print uninterpreted data fields in hex as well. */
return TRUE;
cp = tvb_get_ptr(tvb, 0, length);
if (!print_hex_data_buffer(stream, cp, length,
- (packet_char_enc)edt->pi.fd->flags.encoding))
+ (packet_char_enc)edt->pi.fd->encoding))
return FALSE;
}
return TRUE;
/* leave it here for future debugging sessions */
if(strcmp(pinfo->current_proto, "DCERPC") == 0) {
printf("proto:%s num:%u id:%u offset:%u len:%u more:%u visited:%u\n",
- pinfo->current_proto, pinfo->num, id, frag_offset, frag_data_len, more_frags, pinfo->fd->flags.visited);
+ pinfo->current_proto, pinfo->num, id, frag_offset, frag_data_len, more_frags, pinfo->fd->visited);
if(fd_head != NULL) {
for(fd_item=fd_head->next;fd_item;fd_item=fd_item->next){
printf("fd_frame:%u fd_offset:%u len:%u datalen:%u\n",
/*
* Is this the first pass through the capture?
*/
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/*
* Yes, so we could be doing reassembly. If
* "check_already_added" is true, and fd_head is non-null,
* If this isn't the first pass, look for this frame in the table
* of reassembled packets.
*/
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
reass_key.frame = pinfo->num;
reass_key.id = id;
return (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key);
fd_head = lookup_fd_head(table, pinfo, id, data, &orig_key);
/* have we already seen this frame ?*/
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
if (fd_head != NULL && fd_head->flags & FD_DEFRAGMENTED) {
if (orig_keyp != NULL)
*orig_keyp = orig_key;
* Have we already seen this frame?
* If so, look for it in the table of reassembled packets.
*/
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
reass_key.frame = pinfo->num;
reass_key.id = id;
return (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key);
* If so, look for it in the table of reassembled packets.
* Note here we store in the reassembly table by the single sequence
* number rather than the sequence number of the First fragment. */
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
reass_key.frame = pinfo->num;
reass_key.id = id;
fh = (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key);
fragment_head *fd_head;
/* Have we already seen this frame ?*/
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
return;
}
* Have we already seen this frame?
* If so, look for it in the table of reassembled packets.
*/
- if (pinfo->fd->flags.visited) {
+ if (pinfo->fd->visited) {
reass_key.frame = pinfo->num;
reass_key.id = id;
return (fragment_head *)g_hash_table_lookup(table->reassembled_table, &reass_key);
/* adding the same fragment again should do nothing, even with different
* offset etc */
- pinfo.fd->flags.visited = 1;
+ pinfo.fd->visited = 1;
fd_head=fragment_add_seq(&test_reassembly_table, tvb, 5, &pinfo, 12, NULL,
0, 60, TRUE, 0);
ASSERT_EQ(1,g_hash_table_size(test_reassembly_table.fragment_table));
ASSERT_EQ_POINTER(NULL,fd_head);
/* start another pdu (just to confuse things) */
- pinfo.fd->flags.visited = 0;
+ pinfo.fd->visited = 0;
pinfo.num = 2;
fd_head=fragment_add_seq(&test_reassembly_table, tvb, 15, &pinfo, 13, NULL,
0, 60, TRUE, 0);
/* what happens if we revisit the packets now? */
fdh0 = fd_head;
- pinfo.fd->flags.visited = 1;
+ pinfo.fd->visited = 1;
pinfo.num = 1;
fd_head=fragment_add_seq(&test_reassembly_table, tvb, 10, &pinfo, 12, NULL,
0, 50, TRUE, 0);
/* adding the same fragment again should do nothing, even with different
* offset etc */
- pinfo.fd->flags.visited = 1;
+ pinfo.fd->visited = 1;
fd_head=fragment_add_seq_next(&test_reassembly_table, tvb, 5, &pinfo, 12, NULL,
60, TRUE);
ASSERT_EQ(1,g_hash_table_size(test_reassembly_table.fragment_table));
ASSERT_EQ_POINTER(NULL,fd_head);
/* start another pdu (just to confuse things) */
- pinfo.fd->flags.visited = 0;
+ pinfo.fd->visited = 0;
pinfo.num = 2;
fd_head=fragment_add_seq_next(&test_reassembly_table, tvb, 15, &pinfo, 13, NULL,
60, TRUE);
/* check what happens when we revisit the packets */
- pinfo.fd->flags.visited = TRUE;
+ pinfo.fd->visited = TRUE;
pinfo.num = 1;
fd_head=fragment_add_seq_next(&test_reassembly_table, tvb, 10, &pinfo, 12, NULL,
ASSERT_EQ_POINTER(NULL,fd_head);
/* check what happens when we revisit the packets */
- pinfo.fd->flags.visited = TRUE;
+ pinfo.fd->visited = TRUE;
pinfo.num = 11;
fd_head=fragment_add_seq_next(&test_reassembly_table, tvb, 10, &pinfo, 24, NULL,
ASSERT_EQ_POINTER(NULL,fd_head->next);
/* revisiting the packet ought to produce the same result. */
- pinfo.fd->flags.visited = TRUE;
+ pinfo.fd->visited = TRUE;
pinfo.num = 20;
fd_head=fragment_add_seq_next(&test_reassembly_table, tvb, 5, &pinfo, 30, NULL,
/* other test stuff */
pinfo.fd = &fd;
- fd.flags.visited = 0;
+ fd.visited = 0;
set_address(&pinfo.src,AT_IPv4,4,src);
set_address(&pinfo.dst,AT_IPv4,4,dst);
ASSERT(test_reassembly_table.fragment_table != NULL);
ASSERT(test_reassembly_table.reassembled_table != NULL);
- pinfo.fd->flags.visited = FALSE;
+ pinfo.fd->visited = FALSE;
tests[i]();
rec.rec_header.packet_header.pkt_encap = lua_pinfo->rec->rec_header.packet_header.pkt_encap;
rec.rec_header.packet_header.pseudo_header = *lua_pinfo->pseudo_header;
- if (lua_pinfo->fd->flags.has_user_comment) {
+ if (lua_pinfo->fd->has_user_comment) {
rec.opt_comment = wmem_strdup(wmem_packet_scope(), epan_get_user_comment(lua_pinfo->epan, lua_pinfo->fd));
rec.has_comment_changed = TRUE;
- } else if (lua_pinfo->fd->flags.has_phdr_comment) {
+ } else if (lua_pinfo->fd->has_phdr_comment) {
rec.opt_comment = wmem_strdup(wmem_packet_scope(), lua_pinfo->rec->opt_comment);
}
/* WSLUA_ATTRIBUTE Pinfo_visited RO Whether this packet has been already visited. */
-PINFO_NAMED_BOOLEAN_GETTER(visited,fd->flags.visited);
+PINFO_NAMED_BOOLEAN_GETTER(visited,fd->visited);
/* WSLUA_ATTRIBUTE Pinfo_number RO The number of this packet in the current file. */
PINFO_NAMED_NUMBER_GETTER(number,num);
* TODO: actually detect that situation or maybe apply other optimizations? */
if (edt->tree && color_filters_used()) {
color_filters_prime_edt(edt);
- fdata->flags.need_colorize = 1;
+ fdata->need_colorize = 1;
}
#endif
- if (!fdata->flags.visited) {
+ if (!fdata->visited) {
/* This is the first pass, so prime the epan_dissect_t with the
hfids postdissectors want on the first pass. */
prime_epan_dissect_with_postdissector_wanted_hfids(edt);
/* If we don't have a display filter, set "passed_dfilter" to 1. */
if (dfcode != NULL) {
- fdata->flags.passed_dfilter = dfilter_apply_edt(dfcode, edt) ? 1 : 0;
+ fdata->passed_dfilter = dfilter_apply_edt(dfcode, edt) ? 1 : 0;
- if (fdata->flags.passed_dfilter) {
+ if (fdata->passed_dfilter) {
/* This frame passed the display filter but it may depend on other
* (potentially not displayed) frames. Find those frames and mark them
* as depended upon.
g_slist_foreach(edt->pi.dependent_frames, find_and_mark_frame_depended_upon, cf->provider.frames);
}
} else
- fdata->flags.passed_dfilter = 1;
+ fdata->passed_dfilter = 1;
- if (fdata->flags.passed_dfilter || fdata->flags.ref_time)
+ if (fdata->passed_dfilter || fdata->ref_time)
cf->displayed_count++;
if (add_to_packet_list) {
packet_list_append(cinfo, fdata);
}
- if (fdata->flags.passed_dfilter || fdata->flags.ref_time)
+ if (fdata->passed_dfilter || fdata->ref_time)
{
frame_data_set_after_dissect(fdata, &cf->cum_bytes);
cf->provider.prev_dis = fdata;
}
/* Frame dependencies from the previous dissection/filtering are no longer valid. */
- fdata->flags.dependent_of_displayed = 0;
+ fdata->dependent_of_displayed = 0;
if (!cf_read_record(cf, fdata))
break; /* error reading the frame */
/* If the previous frame is displayed, and we haven't yet seen the
selected frame, remember that frame - it's the closest one we've
yet seen before the selected frame. */
- if (prev_frame_num != -1 && !selected_frame_seen && prev_frame->flags.passed_dfilter) {
+ if (prev_frame_num != -1 && !selected_frame_seen && prev_frame->passed_dfilter) {
preceding_frame_num = prev_frame_num;
preceding_frame = prev_frame;
}
seen displayed after the selected frame, remember this frame -
it's the closest one we've yet seen at or after the selected
frame. */
- if (fdata->flags.passed_dfilter && selected_frame_seen && following_frame_num == -1) {
+ if (fdata->passed_dfilter && selected_frame_seen && following_frame_num == -1) {
following_frame_num = fdata->num;
following_frame = fdata;
}
if (fdata == selected_frame) {
selected_frame_seen = TRUE;
- if (fdata->flags.passed_dfilter)
+ if (fdata->passed_dfilter)
selected_frame_num = fdata->num;
}
cf->provider.ref = fdata;
/* if this frames is marked as a reference time frame, reset
firstsec and firstusec to this frame */
- if (fdata->flags.ref_time)
+ if (fdata->ref_time)
cf->provider.ref = fdata;
/* If we don't have the time stamp of the previous displayed packet,
/* If this frame is displayed, get the time elapsed between the
previous displayed packet and this packet. */
- if ( fdata->flags.passed_dfilter ) {
+ if ( fdata->passed_dfilter ) {
fdata->prev_dis_num = cf->provider.prev_dis->num;
cf->provider.prev_dis = fdata;
}
/*
* Byte counts
*/
- if ( (fdata->flags.passed_dfilter) || (fdata->flags.ref_time) ) {
+ if ( (fdata->passed_dfilter) || (fdata->ref_time) ) {
/* This frame either passed the display filter list or is marked as
a time reference frame. All time reference frames are displayed
even if they don't pass the display filter */
- if (fdata->flags.ref_time) {
+ if (fdata->ref_time) {
/* if this was a TIME REF frame we should reset the cum_bytes field */
cf->cum_bytes = fdata->pkt_len;
fdata->cum_bytes = cf->cum_bytes;
static match_result
match_marked(capture_file *cf _U_, frame_data *fdata, void *criterion _U_)
{
- return fdata->flags.marked ? MR_MATCHED : MR_NOTMATCHED;
+ return fdata->marked ? MR_MATCHED : MR_NOTMATCHED;
}
gboolean
static match_result
match_time_reference(capture_file *cf _U_, frame_data *fdata, void *criterion _U_)
{
- return fdata->flags.ref_time ? MR_MATCHED : MR_NOTMATCHED;
+ return fdata->ref_time ? MR_MATCHED : MR_NOTMATCHED;
}
static gboolean
count++;
/* Is this packet in the display? */
- if (fdata && fdata->flags.passed_dfilter) {
+ if (fdata && fdata->passed_dfilter) {
/* Yes. Does it match the search criterion? */
result = (*match_function)(cf, fdata, criterion);
if (result == MR_ERROR) {
statusbar_push_temporary_msg("There is no packet number %u.", fnumber);
return FALSE; /* we failed to go to that packet */
}
- if (!fdata->flags.passed_dfilter) {
+ if (!fdata->passed_dfilter) {
/* that packet currently isn't displayed */
/* XXX - add it to the set of displayed packets? */
statusbar_push_temporary_msg("Packet number %u isn't displayed.", fnumber);
void
cf_mark_frame(capture_file *cf, frame_data *frame)
{
- if (! frame->flags.marked) {
- frame->flags.marked = TRUE;
+ if (! frame->marked) {
+ frame->marked = TRUE;
if (cf->count > cf->marked_count)
cf->marked_count++;
}
void
cf_unmark_frame(capture_file *cf, frame_data *frame)
{
- if (frame->flags.marked) {
- frame->flags.marked = FALSE;
+ if (frame->marked) {
+ frame->marked = FALSE;
if (cf->marked_count > 0)
cf->marked_count--;
}
void
cf_ignore_frame(capture_file *cf, frame_data *frame)
{
- if (! frame->flags.ignored) {
- frame->flags.ignored = TRUE;
+ if (! frame->ignored) {
+ frame->ignored = TRUE;
if (cf->count > cf->ignored_count)
cf->ignored_count++;
}
void
cf_unignore_frame(capture_file *cf, frame_data *frame)
{
- if (frame->flags.ignored) {
- frame->flags.ignored = FALSE;
+ if (frame->ignored) {
+ frame->ignored = FALSE;
if (cf->ignored_count > 0)
cf->ignored_count--;
}
char *comment;
/* fetch user comment */
- if (fd->flags.has_user_comment)
+ if (fd->has_user_comment)
return g_strdup(cap_file_provider_get_user_comment(&cf->provider, fd));
/* fetch phdr comment */
- if (fd->flags.has_phdr_comment) {
+ if (fd->has_phdr_comment) {
wtap_rec rec; /* Record metadata */
Buffer buf; /* Record data */
/* Make changes based on anything that the user has done but that
hasn't been saved yet. */
- if (fdata->flags.has_user_comment)
+ if (fdata->has_user_comment)
pkt_comment = cap_file_provider_get_user_comment(&cf->provider, fdata);
else
pkt_comment = rec->opt_comment;
new_rec.opt_comment = g_strdup(pkt_comment);
- new_rec.has_comment_changed = fdata->flags.has_user_comment ? TRUE : FALSE;
+ new_rec.has_comment_changed = fdata->has_user_comment ? TRUE : FALSE;
/* XXX - what if times have been shifted? */
/* and save the packet */
for (framenum = 1; framenum <= cf->count; framenum++) {
fdata = frame_data_sequence_find(cf->provider.frames, framenum);
- fdata->flags.has_phdr_comment = FALSE;
- fdata->flags.has_user_comment = FALSE;
+ fdata->has_phdr_comment = FALSE;
+ fdata->has_user_comment = FALSE;
}
if (cf->provider.frames_user_comments) {
/* insert new packet comment */
g_tree_replace(prov->frames_user_comments, fd, g_strdup(new_comment));
- fd->flags.has_user_comment = TRUE;
+ fd->has_user_comment = TRUE;
}
ref_time_frame.num = pinfo->num;
ref_time_frame.abs_ts = pinfo->abs_ts;
}
- else if ( !pinfo->fd->flags.visited )
+ else if ( !pinfo->fd->visited )
{
guint64 nsecs = tvb_get_letoh64(tvb, offset+8) - ref_time_frame.esl_ts;
guint64 secs = nsecs/1000000000;
in_heur = TRUE;
/*TRY */
{
- if ( ref_time_frame.fd != NULL && !pinfo->fd->flags.visited && pinfo->num <= ref_time_frame.num )
+ if ( ref_time_frame.fd != NULL && !pinfo->fd->visited && pinfo->num <= ref_time_frame.num )
ref_time_frame.fd = NULL;
/* Check that there's enough data */
offset = dissect_dcerpc_uint16(tvb, offset, pinfo, sub_tree_selector, drep, hf_pn_io_ar_arreserved, &u16ArReserved);
/* When ARType==IOCARSR, then find or create conversation for this frame */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Get current conversation endpoints using MAC addresses */
conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, ENDPOINT_UDP, 0, 0, 0);
if (conversation == NULL) {
/* Set global Variant for Number of IO Data Objects */
/* Notice: Handle Input & Output seperate!!! */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Get current conversation endpoints using MAC addresses */
conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, ENDPOINT_NONE, 0, 0, 0);
if (conversation == NULL) {
proto_item_set_len(sub_item, offset - u32SubStart);
- if (!pinfo->fd->flags.visited && station_info != NULL) {
+ if (!pinfo->fd->visited && station_info != NULL) {
io_data_object = wmem_new0(wmem_file_scope(), ioDataObject);
io_data_object->slotNr = u16SlotNr;
io_data_object->subSlotNr = u16SubslotNr;
hf_pn_io_number_of_iocs, &u16NumberOfIOCS);
/* Set global Vairant for NumberOfIOCS */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (station_info != NULL) {
station_info->iocsNr = u16NumberOfIOCS;
}
proto_item_set_len(sub_item, offset - u32SubStart);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
if (station_info != NULL) {
if (u16IOCRType == PN_INPUT_CR) {
iocs_list = station_info->iocs_data_in;
proto_item_set_len(sub_item, offset - u32SubStart);
/* Save new data for IO Data Objects */
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Get current conversation endpoints using MAC addresses */
conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, ENDPOINT_NONE, 0, 0, 0);
if (conversation == NULL) {
u16NumberOfSubmodules);
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Get current conversation endpoints using MAC addresses */
conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, ENDPOINT_NONE, 0, 0, 0);
if (conversation == NULL) {
prm_flag1, prm_flag2, src_addr, dst_addr, wd_time, par_crc);
}
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Get current conversation endpoints using MAC addresses */
conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, ENDPOINT_NONE, 0, 0, 0);
if (conversation == NULL) {
station_info = (stationInfo*)conversation_get_proto_data(conversation, proto_pn_dcp);
if (station_info != NULL) {
- if (!pinfo->fd->flags.visited) {
+ if (!pinfo->fd->visited) {
/* Search within the entire existing list for current input object data */
for (frame = wmem_list_head(station_info->ioobject_data_in); frame != NULL; frame = wmem_list_frame_next(frame)) {
io_data_object = (ioDataObject*)wmem_list_frame_data(frame);
proto_item_append_text(block_item, ", DeviceVendorValue: \"%s\"", typeofstation);
- if (pinfo->fd->flags.visited == FALSE) {
+ if (pinfo->fd->visited == FALSE) {
/* Create a conversation between the MAC addresses */
conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, ENDPOINT_NONE, 0, 0, 0);
if (conversation == NULL) {
proto_item_append_text(block_item, ", \"%s\"", nameofstation);
- if (pinfo->fd->flags.visited == FALSE) {
+ if (pinfo->fd->visited == FALSE) {
/* Create a conversation between the MAC addresses */
conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, ENDPOINT_NONE, 0, 0, 0);
if (conversation == NULL) {
offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_vendor_id, &vendor_id);
offset = dissect_pn_uint16(tvb, offset, pinfo, tree, hf_pn_dcp_suboption_device_id, &device_id);
- if (pinfo->fd->flags.visited == FALSE) {
+ if (pinfo->fd->visited == FALSE) {
/* Create a conversation between the MAC addresses */
conversation = find_conversation(pinfo->num, &pinfo->dl_src, &pinfo->dl_dst, ENDPOINT_NONE, 0, 0, 0);
if (conversation == NULL) {
if (dissect_flags & SHARKD_DISSECT_FLAG_COLOR) {
color_filters_prime_edt(&edt);
- fdata->flags.need_colorize = 1;
+ fdata->need_colorize = 1;
}
if (cinfo)
* XXX - need to catch an OutOfMemoryError exception and
* attempt to recover from it.
*/
- fdata->flags.ref_time = (framenum == frame_ref_num);
+ fdata->ref_time = (framenum == frame_ref_num);
fdata->frame_ref_num = frame_ref_num;
fdata->prev_dis_num = prev_dis_num;
epan_dissect_run(&edt, cfile.cd_t, &rec,
if (dissect_color) {
color_filters_prime_edt(&edt);
- fdata->flags.need_colorize = 1;
+ fdata->need_colorize = 1;
}
if (cinfo)
* XXX - need to catch an OutOfMemoryError exception and
* attempt to recover from it.
*/
- fdata->flags.ref_time = (fdata->num == frame_ref_num);
+ fdata->ref_time = (fdata->num == frame_ref_num);
fdata->frame_ref_num = frame_ref_num;
fdata->prev_dis_num = prev_dis_num;
epan_dissect_run(&edt, cfile.cd_t, &rec,
if (!wtap_seek_read(cfile.provider.wth, fdata->file_off, &rec, &buf, &err, &err_info))
break;
- fdata->flags.ref_time = FALSE;
+ fdata->ref_time = FALSE;
fdata->frame_ref_num = (framenum != 1) ? 1 : 0;
fdata->prev_dis_num = framenum - 1;
epan_dissect_run_with_taps(&edt, cfile.cd_t, &rec,
/* frame_data_set_before_dissect */
epan_dissect_prime_with_dfilter(&edt, dfcode);
- fdata->flags.ref_time = FALSE;
+ fdata->ref_time = FALSE;
fdata->frame_ref_num = (framenum != 1) ? 1 : 0;
fdata->prev_dis_num = prev_dis_num;
epan_dissect_run(&edt, cfile.cd_t, &rec,
sharkd_json_value_anyf(TRUE, "num", "%u", framenum);
- if (fdata->flags.has_user_comment || fdata->flags.has_phdr_comment)
+ if (fdata->has_user_comment || fdata->has_phdr_comment)
{
- if (!fdata->flags.has_user_comment || sharkd_get_user_comment(fdata) != NULL)
+ if (!fdata->has_user_comment || sharkd_get_user_comment(fdata) != NULL)
sharkd_json_value_anyf(TRUE, "ct", "true");
}
- if (fdata->flags.ignored)
+ if (fdata->ignored)
sharkd_json_value_anyf(TRUE, "i", "true");
- if (fdata->flags.marked)
+ if (fdata->marked)
sharkd_json_value_anyf(TRUE, "m", "true");
if (fdata->color_filter)
sharkd_json_value_anyf(FALSE, "err", "0");
- if (fdata->flags.has_user_comment)
+ if (fdata->has_user_comment)
pkt_comment = sharkd_get_user_comment(fdata);
- else if (fdata->flags.has_phdr_comment)
+ else if (fdata->has_phdr_comment)
pkt_comment = pi->rec->opt_comment;
if (pkt_comment)
sharkd_json_array_close();
}
- if (fdata->flags.ignored)
+ if (fdata->ignored)
sharkd_json_value_anyf(TRUE, "i", "true");
- if (fdata->flags.marked)
+ if (fdata->marked)
sharkd_json_value_anyf(TRUE, "m", "true");
if (fdata->color_filter)
{
const guchar *cp = tvb_get_ptr(tvb, 0, length);
- /* XXX pi.fd->flags.encoding */
+ /* XXX pi.fd->encoding */
sharkd_json_value_base64(TRUE, "bytes", cp, length);
}
else
{
const guchar *cp = tvb_get_ptr(tvb, 0, length);
- /* XXX pi.fd->flags.encoding */
+ /* XXX pi.fd->encoding */
sharkd_json_value_base64(TRUE, "bytes", cp, length);
}
else
if (edt) {
epan_dissect_reset(edt);
}
- return passed || fdata->flags.dependent_of_displayed;
+ return passed || fdata->dependent_of_displayed;
}
static gboolean
if (dissect_color) {
color_filters_prime_edt(edt);
- fdata->flags.need_colorize = 1;
+ fdata->need_colorize = 1;
}
epan_dissect_run_with_taps(edt, cf->cd_t, rec,
if (edt) {
epan_dissect_reset(edt);
}
- return passed || fdata->flags.dependent_of_displayed;
+ return passed || fdata->dependent_of_displayed;
}
static gboolean
if (dissect_color) {
color_filters_prime_edt(edt);
- fdata.flags.need_colorize = 1;
+ fdata.need_colorize = 1;
}
epan_dissect_run_with_taps(edt, cf->cd_t, rec,
if (range->cf->current_frame == packet) {
range->selected_packet = framenum;
}
- if (packet->flags.passed_dfilter) {
+ if (packet->passed_dfilter) {
range->displayed_cnt++;
}
- if (packet->flags.passed_dfilter ||
- packet->flags.dependent_of_displayed) {
+ if (packet->passed_dfilter ||
+ packet->dependent_of_displayed) {
range->displayed_plus_dependents_cnt++;
}
- if (packet->flags.marked) {
- if (packet->flags.ignored) {
+ if (packet->marked) {
+ if (packet->ignored) {
range->ignored_marked_cnt++;
}
- if (packet->flags.passed_dfilter) {
+ if (packet->passed_dfilter) {
range->displayed_marked_cnt++;
- if (packet->flags.ignored) {
+ if (packet->ignored) {
range->displayed_ignored_marked_cnt++;
}
if (displayed_mark_low == 0) {
mark_high = framenum;
}
}
- if (packet->flags.ignored) {
+ if (packet->ignored) {
range->ignored_cnt++;
- if (packet->flags.passed_dfilter) {
+ if (packet->passed_dfilter) {
range->displayed_ignored_cnt++;
}
}
framenum <= mark_high)
{
range->mark_range_cnt++;
- if (packet->flags.ignored) {
+ if (packet->ignored) {
range->ignored_mark_range_cnt++;
}
}
if (framenum >= displayed_mark_low &&
framenum <= displayed_mark_high)
{
- if (packet->flags.passed_dfilter) {
+ if (packet->passed_dfilter) {
range->displayed_mark_range_cnt++;
- if (packet->flags.ignored) {
+ if (packet->ignored) {
range->displayed_ignored_mark_range_cnt++;
}
}
if (value_is_in_range(range->user_range, framenum)) {
range->user_range_cnt++;
- if (packet->flags.ignored) {
+ if (packet->ignored) {
range->ignored_user_range_cnt++;
}
- if (packet->flags.passed_dfilter) {
+ if (packet->passed_dfilter) {
range->displayed_user_range_cnt++;
- if (packet->flags.ignored) {
+ if (packet->ignored) {
range->displayed_ignored_user_range_cnt++;
}
}
/* do we have to process this packet? */
range_process_e packet_range_process_packet(packet_range_t *range, frame_data *fdata) {
- if (range->remove_ignored && fdata->flags.ignored) {
+ if (range->remove_ignored && fdata->ignored) {
return range_process_next;
}
range->selected_done = TRUE;
break;
case(range_process_marked):
- if (fdata->flags.marked == FALSE) {
+ if (fdata->marked == FALSE) {
return range_process_next;
}
break;
if (range->marked_range_left == 0) {
return range_processing_finished;
}
- if (fdata->flags.marked == TRUE) {
+ if (fdata->marked == TRUE) {
range->marked_range_active = TRUE;
}
if (range->marked_range_active == FALSE ) {
return range_process_next;
}
if (!range->process_filtered ||
- (range->process_filtered && fdata->flags.passed_dfilter == TRUE))
+ (range->process_filtered && fdata->passed_dfilter == TRUE))
{
range->marked_range_left--;
}
* Try next, but only if we're not including dependent packets and this
* packet happens to be a dependency on something that is displayed.
*/
- if ((range->process_filtered && fdata->flags.passed_dfilter == FALSE) &&
- !(range->include_dependents && fdata->flags.dependent_of_displayed)) {
+ if ((range->process_filtered && fdata->passed_dfilter == FALSE) &&
+ !(range->include_dependents && fdata->dependent_of_displayed)) {
return range_process_next;
}
/* Get stats from this protocol tree */
process_tree(edt.tree, ps);
- if (frame->flags.has_ts) {
+ if (frame->has_ts) {
/* Update times */
cur_time = nstime_to_sec(&frame->abs_ts);
if (cur_time < ps->first_time)
passed the display filter? If so, it should
probably do so for other loops (see "file.c") that
look only at those packets. */
- if (frame->flags.passed_dfilter) {
+ if (frame->passed_dfilter) {
- if (frame->flags.has_ts) {
+ if (frame->has_ts) {
if (tot_packets == 0) {
double cur_time = nstime_to_sec(&frame->abs_ts);
ps->first_time = cur_time;
packet_char_enc encoding = PACKET_CHAR_ENC_CHAR_ASCII;
if ( cap_file_ && cap_file_->current_frame )
- encoding = (packet_char_enc)cap_file_->current_frame->flags.encoding;
+ encoding = (packet_char_enc)cap_file_->current_frame->encoding;
QByteArray data;
if ( tvb ) {
if (!iax2info) return FALSE;
/* we ignore packets that are not displayed */
- if (pinfo->fd->flags.passed_dfilter == 0)
+ if (pinfo->fd->passed_dfilter == 0)
return FALSE;
/* we ignore packets that carry no data */
gboolean LBMLBTRMTransportDialog::tapPacket(void * tap_data, packet_info * pinfo, epan_dissect_t *, const void * tap_info)
{
- if (pinfo->fd->flags.passed_dfilter == 1)
+ if (pinfo->fd->passed_dfilter == 1)
{
const lbm_lbtrm_tap_info_t * tapinfo = (const lbm_lbtrm_tap_info_t *)tap_info;
LBMLBTRMTransportDialogInfo * info = (LBMLBTRMTransportDialogInfo *)tap_data;
gboolean LBMLBTRUTransportDialog::tapPacket(void * tap_data, packet_info * pinfo, epan_dissect_t *, const void * tap_info)
{
- if (pinfo->fd->flags.passed_dfilter == 1)
+ if (pinfo->fd->passed_dfilter == 1)
{
const lbm_lbtru_tap_info_t * tapinfo = (const lbm_lbtru_tap_info_t *)tap_info;
LBMLBTRUTransportDialogInfo * info = (LBMLBTRUTransportDialogInfo *)tap_data;
gboolean LBMStreamDialog::tapPacket(void * tap_data, packet_info * pinfo, epan_dissect_t *, const void * stream_info)
{
- if (pinfo->fd->flags.passed_dfilter == 1)
+ if (pinfo->fd->passed_dfilter == 1)
{
const lbm_uim_stream_tap_info_t * tapinfo = (const lbm_uim_stream_tap_info_t *)stream_info;
LBMStreamDialogInfo * info = (LBMStreamDialogInfo *)tap_data;
if (cf->state == FILE_READ_DONE && cf->current_frame) {
ws_info->cf_framenr = cf->current_frame->num;
- ws_info->frame_passed_dfilter = (cf->current_frame->flags.passed_dfilter == 1);
+ ws_info->frame_passed_dfilter = (cf->current_frame->passed_dfilter == 1);
}
else {
ws_info->cf_framenr = 0;
have_frames = capture_file_.capFile()->count > 0;
have_marked = capture_file_.capFile()->marked_count > 0;
another_is_marked = have_marked &&
- !(capture_file_.capFile()->marked_count == 1 && frame_selected && capture_file_.capFile()->current_frame->flags.marked);
+ !(capture_file_.capFile()->marked_count == 1 && frame_selected && capture_file_.capFile()->current_frame->marked);
have_filtered = capture_file_.capFile()->displayed_count > 0 && capture_file_.capFile()->displayed_count != capture_file_.capFile()->count;
have_ignored = capture_file_.capFile()->ignored_count > 0;
have_time_ref = capture_file_.capFile()->ref_time_count > 0;
another_is_time_ref = have_time_ref &&
- !(capture_file_.capFile()->ref_time_count == 1 && frame_selected && capture_file_.capFile()->current_frame->flags.ref_time);
+ !(capture_file_.capFile()->ref_time_count == 1 && frame_selected && capture_file_.capFile()->current_frame->ref_time);
if (capture_file_.capFile()->edt)
{
foreach (PacketListRecord *record, physical_rows_) {
frame_data *fdata = record->frameData();
- if (fdata->flags.passed_dfilter || fdata->flags.ref_time) {
+ if (fdata->passed_dfilter || fdata->ref_time) {
visible_rows_ << record;
if (number_to_row_.size() <= (int)fdata->num) {
number_to_row_.resize(fdata->num + 10000);
frame_data *fdata = record->frameData();
if (!fdata) return;
- if (fdata->flags.marked)
+ if (fdata->marked)
cf_unmark_frame(cap_file_, fdata);
else
cf_mark_frame(cap_file_, fdata);
frame_data *fdata = record->frameData();
if (!fdata) return;
- if (fdata->flags.ignored)
+ if (fdata->ignored)
cf_unignore_frame(cap_file_, fdata);
else
cf_ignore_frame(cap_file_, fdata);
frame_data *fdata = record->frameData();
if (!fdata) return;
- if (fdata->flags.ref_time) {
- fdata->flags.ref_time=0;
+ if (fdata->ref_time) {
+ fdata->ref_time=0;
cap_file_->ref_time_count--;
} else {
- fdata->flags.ref_time=1;
+ fdata->ref_time=1;
cap_file_->ref_time_count++;
}
cf_reftime_packets(cap_file_);
- if (!fdata->flags.ref_time && !fdata->flags.passed_dfilter) {
+ if (!fdata->ref_time && !fdata->passed_dfilter) {
cap_file_->displayed_count--;
}
record->resetColumns(&cap_file_->cinfo);
foreach (PacketListRecord *record, physical_rows_) {
frame_data *fdata = record->frameData();
- if (fdata->flags.ref_time) {
- fdata->flags.ref_time = 0;
+ if (fdata->ref_time) {
+ fdata->ref_time = 0;
}
}
cap_file_->ref_time_count = 0;
foreach (PacketListRecord *record, physical_rows_) {
frame_data *fdata = record->frameData();
- if (fdata->flags.passed_dfilter || fdata->flags.ref_time) {
+ if (fdata->passed_dfilter || fdata->ref_time) {
visible_rows_ << record;
if (number_to_row_.size() <= (int)fdata->num) {
number_to_row_.resize(fdata->num + 10000);
case Qt::BackgroundRole:
const color_t *color;
- if (fdata->flags.ignored) {
+ if (fdata->ignored) {
color = &prefs.gui_ignored_bg;
- } else if (fdata->flags.marked) {
+ } else if (fdata->marked) {
color = &prefs.gui_marked_bg;
} else if (fdata->color_filter && recent.packet_list_colorize) {
const color_filter_t *color_filter = (const color_filter_t *) fdata->color_filter;
}
return ColorUtils::fromColorT(color);
case Qt::ForegroundRole:
- if (fdata->flags.ignored) {
+ if (fdata->ignored) {
color = &prefs.gui_ignored_fg;
- } else if (fdata->flags.marked) {
+ } else if (fdata->marked) {
color = &prefs.gui_marked_fg;
} else if (fdata->color_filter && recent.packet_list_colorize) {
const color_filter_t *color_filter = (const color_filter_t *) fdata->color_filter;
physical_rows_ << record;
- if (fdata->flags.passed_dfilter || fdata->flags.ref_time) {
+ if (fdata->passed_dfilter || fdata->ref_time) {
new_visible_rows_ << record;
if (new_visible_rows_.count() < 2) {
// This is the first queued packet. Schedule an insertion for
/* Re-color when the coloring rules are changed via the UI. */
if (dissect_color) {
color_filters_prime_edt(&edt);
- fdata_->flags.need_colorize = 1;
+ fdata_->need_colorize = 1;
}
if (dissect_columns)
col_custom_prime_edt(&edt, cinfo);
for (int row = 0; row < pl_rows; row++) {
frame_data *fdata = packet_list_model_->getRowFdata(row);
- if (fdata->flags.marked || fdata->flags.ref_time || fdata->flags.ignored) {
+ if (fdata->marked || fdata->ref_time || fdata->ignored) {
int new_line = row * o_height / pl_rows;
int tick_width = o_width / 3;
// Marked or ignored: left side, time refs: right side.
// XXX Draw ignored ticks in the middle?
- int x1 = fdata->flags.ref_time ? o_width - tick_width : 1;
- int x2 = fdata->flags.ref_time ? o_width - 1 : tick_width;
+ int x1 = fdata->ref_time ? o_width - tick_width : 1;
+ int x2 = fdata->ref_time ? o_width - 1 : tick_width;
painter.drawLine(x1, new_line, x2, new_line);
have_marked_image = true;
pr_ui_->selectedCapturedLabel->setEnabled(false);
pr_ui_->selectedDisplayedLabel->setEnabled(false);
}
- if ((range_->remove_ignored && can_select && range_->cf->current_frame->flags.ignored) || selected_num < 1) {
+ if ((range_->remove_ignored && can_select && range_->cf->current_frame->ignored) || selected_num < 1) {
pr_ui_->selectedCapturedLabel->setText("0");
pr_ui_->selectedDisplayedLabel->setText("0");
} else {
displayed_ignored_cnt = range_->displayed_ignored_cnt;
break;
case(range_process_selected):
- ignored_cnt = (can_select && range_->cf->current_frame->flags.ignored) ? 1 : 0;
+ ignored_cnt = (can_select && range_->cf->current_frame->ignored) ? 1 : 0;
displayed_ignored_cnt = ignored_cnt;
break;
case(range_process_marked):
if (!rtpinfo) return FALSE;
/* we ignore packets that are not displayed */
- if (pinfo->fd->flags.passed_dfilter == 0)
+ if (pinfo->fd->passed_dfilter == 0)
return FALSE;
/* also ignore RTP Version != 2 */
else if (rtpinfo->info_version != 2)
if (!rtpinfo) return FALSE;
/* we ignore packets that are not displayed */
- if (pinfo->fd->flags.passed_dfilter == 0)
+ if (pinfo->fd->passed_dfilter == 0)
return FALSE;
/* also ignore RTP Version != 2 */
else if (rtpinfo->info_version != 2)
return;
frame_data *fdata = frame_data_sequence_find(cfile.provider.frames, num);
- if (!fdata->flags.passed_dfilter && fdata->prev_dis_num > 0)
+ if (!fdata->passed_dfilter && fdata->prev_dis_num > 0)
num = fdata->prev_dis_num;
cf_goto_frame(&cfile, num);
* with all other sub pixels that fall within this
* pixel */
last_x = x;
- accumulate_rgb(rgb, height, fdata->flags.passed_dfilter, width, red, green, blue);
+ accumulate_rgb(rgb, height, fdata->passed_dfilter, width, red, green, blue);
} else {
/* it spans more than 1 pixel.
* first accumulate the part that does fit */
float partial = ((int) x) + 1 - x;
- accumulate_rgb(rgb, height, fdata->flags.passed_dfilter, partial, red, green, blue);
+ accumulate_rgb(rgb, height, fdata->passed_dfilter, partial, red, green, blue);
/* and render it */
render_pixels(p, (int) x, 1, rgb, ratio);
last_x = -1;
width -= partial;
/* are there any whole pixels of width left to draw? */
if (width > 1.0) {
- render_rectangle(p, x, width, height, fdata->flags.passed_dfilter, red, green, blue, ratio);
+ render_rectangle(p, x, width, height, fdata->passed_dfilter, red, green, blue, ratio);
x += (int) width;
width -= (int) width;
}
/* is there a partial pixel left */
if (width > 0.0) {
last_x = x;
- accumulate_rgb(rgb, height, fdata->flags.passed_dfilter, width, red, green, blue);
+ accumulate_rgb(rgb, height, fdata->passed_dfilter, width, red, green, blue);
}
}
}
double cur_time;
sum_tally->bytes += cur_frame->pkt_len;
- if (cur_frame->flags.passed_dfilter){
+ if (cur_frame->passed_dfilter){
sum_tally->filtered_count++;
sum_tally->filtered_bytes += cur_frame->pkt_len;
}
- if (cur_frame->flags.marked){
+ if (cur_frame->marked){
sum_tally->marked_count++;
sum_tally->marked_bytes += cur_frame->pkt_len;
}
- if (cur_frame->flags.ignored){
+ if (cur_frame->ignored){
sum_tally->ignored_count++;
}
- if (cur_frame->flags.has_ts) {
+ if (cur_frame->has_ts) {
/* This packet has a time stamp. */
cur_time = nstime_to_sec(&cur_frame->abs_ts);
if (cur_time > sum_tally->stop_time){
sum_tally->stop_time = cur_time;
}
- if (cur_frame->flags.passed_dfilter){
+ if (cur_frame->passed_dfilter){
sum_tally->filtered_count_ts++;
/*
* If we've seen one filtered packet, this is the first
}
}
}
- if (cur_frame->flags.marked){
+ if (cur_frame->marked){
sum_tally->marked_count_ts++;
/*
* If we've seen one marked packet, this is the first
rec.rec_header.packet_header.pkt_encap = exp_pdu_tap_data->pkt_encap;
- if (pinfo->fd->flags.has_user_comment) {
+ if (pinfo->fd->has_user_comment) {
rec.opt_comment = g_strdup(epan_get_user_comment(edt->session, pinfo->fd));
rec.has_comment_changed = TRUE;
- } else if (pinfo->fd->flags.has_phdr_comment) {
+ } else if (pinfo->fd->has_phdr_comment) {
rec.opt_comment = g_strdup(pinfo->rec->opt_comment);
}
selected_num = (g_cf->current_frame) ? g_cf->current_frame->num : 0;
cur_ctrl = GetDlgItem(dlg_hwnd, EWFD_SEL_PKT_CAP);
EnableWindow(cur_ctrl, selected_num && !filtered_active);
- if (range->remove_ignored && g_cf->current_frame && g_cf->current_frame->flags.ignored) {
+ if (range->remove_ignored && g_cf->current_frame && g_cf->current_frame->ignored) {
StringCchPrintf(static_val, STATIC_LABEL_CHARS, _T("0"));
} else {
StringCchPrintf(static_val, STATIC_LABEL_CHARS, _T("%d"), selected_num ? 1 : 0);
cur_ctrl = GetDlgItem(dlg_hwnd, EWFD_SEL_PKT_DISP);
EnableWindow(cur_ctrl, selected_num && filtered_active);
- if (range->remove_ignored && g_cf->current_frame && g_cf->current_frame->flags.ignored) {
+ if (range->remove_ignored && g_cf->current_frame && g_cf->current_frame->ignored) {
StringCchPrintf(static_val, STATIC_LABEL_CHARS, _T("0"));
} else {
StringCchPrintf(static_val, STATIC_LABEL_CHARS, _T("%d"), selected_num ? 1 : 0);
displayed_ignored_cnt = range->displayed_ignored_cnt;
break;
case(range_process_selected):
- ignored_cnt = (g_cf->current_frame && g_cf->current_frame->flags.ignored) ? 1 : 0;
+ ignored_cnt = (g_cf->current_frame && g_cf->current_frame->ignored) ? 1 : 0;
displayed_ignored_cnt = ignored_cnt;
break;
case(range_process_marked):
git.samba.org / gd / wireshark / .git / commitdiff