seq_analysis_item_t* sequence_analysis_create_sai_with_addresses(packet_info *pinfo, seq_analysis_info_t *sainfo) { seq_analysis_item_t *sai = NULL; char time_str[COL_MAX_LEN]; if (sainfo->any_addr) { if (pinfo->net_src.type!=AT_NONE && pinfo->net_dst.type!=AT_NONE) { sai = g_new0(seq_analysis_item_t, 1); copy_address(&(sai->src_addr),&(pinfo->net_src)); copy_address(&(sai->dst_addr),&(pinfo->net_dst)); } } else { if (pinfo->src.type!=AT_NONE && pinfo->dst.type!=AT_NONE) { sai = g_new0(seq_analysis_item_t, 1); copy_address(&(sai->src_addr),&(pinfo->src)); copy_address(&(sai->dst_addr),&(pinfo->dst)); } } if (sai) { /* Fill in the timestamps */ set_fd_time(pinfo->epan, pinfo->fd, time_str); sai->time_str = g_strdup(time_str); } return sai; }
RtpAudioStream::RtpAudioStream(QObject *parent, _rtp_stream_info *rtp_stream) : QObject(parent), decoders_hash_(rtp_decoder_hash_table_new()), global_start_rel_time_(0.0), start_abs_offset_(0.0), start_rel_time_(0.0), stop_rel_time_(0.0), audio_out_rate_(0), audio_resampler_(0), audio_output_(0), max_sample_val_(1), color_(0), jitter_buffer_size_(50), timing_mode_(RtpAudioStream::JitterBuffer) { copy_address(&src_addr_, &rtp_stream->src_addr); src_port_ = rtp_stream->src_port; copy_address(&dst_addr_, &rtp_stream->dest_addr); dst_port_ = rtp_stream->dest_port; ssrc_ = rtp_stream->ssrc; // We keep visual samples in memory. Make fewer of them. visual_resampler_ = ws_codec_resampler_init(1, default_audio_sample_rate_, visual_sample_rate_, SPEEX_RESAMPLER_QUALITY_MIN, NULL); ws_codec_resampler_skip_zeros(visual_resampler_); QString tempname = QString("%1/wireshark_rtp_stream").arg(QDir::tempPath()); tempfile_ = new QTemporaryFile(tempname, this); tempfile_->open(); // RTP_STREAM_DEBUG("Writing to %s", tempname.toUtf8().constData()); }
/* deep copy of id */ void rtpstream_id_copy(const rtpstream_id_t *src, rtpstream_id_t *dest) { copy_address(&(dest->src_addr), &(src->src_addr)); dest->src_port=src->src_port; copy_address(&(dest->dst_addr), &(src->dst_addr)); dest->dst_port=src->dst_port; dest->ssrc=src->ssrc; }
static int _getifaddrs(int domain, char* buffer, size_t len, struct ifaddrs** previous) { int socket = ::socket(domain, SOCK_DGRAM, 0); if (socket < 0) return -1; FileDescriptorCloser closer(socket); // Get interfaces configuration ifconf config; config.ifc_buf = buffer; config.ifc_len = len; if (ioctl(socket, SIOCGIFCONF, &config, sizeof(struct ifconf)) < 0) return -1; ifreq* interfaces = (ifreq*)buffer; ifreq* end = (ifreq*)(buffer + config.ifc_len); while (interfaces < end) { struct ifaddrs* current = new(std::nothrow) ifaddrs(); if (current == NULL) { errno = B_NO_MEMORY; return -1; } // Chain this interface with the next one current->ifa_next = *previous; *previous = current; current->ifa_name = strdup(interfaces[0].ifr_name); current->ifa_addr = copy_address(interfaces[0].ifr_addr); current->ifa_netmask = NULL; current->ifa_dstaddr = NULL; current->ifa_data = NULL; ifreq request; strlcpy(request.ifr_name, interfaces[0].ifr_name, IF_NAMESIZE); if (ioctl(socket, SIOCGIFFLAGS, &request, sizeof(struct ifreq)) == 0) current->ifa_flags = request.ifr_flags; if (ioctl(socket, SIOCGIFNETMASK, &request, sizeof(struct ifreq)) == 0) { current->ifa_netmask = copy_address(request.ifr_mask); } if (ioctl(socket, SIOCGIFDSTADDR, &request, sizeof(struct ifreq)) == 0) { current->ifa_dstaddr = copy_address(request.ifr_dstaddr); } // Move on to next interface interfaces = (ifreq*)((uint8_t*)interfaces + _SIZEOF_ADDR_IFREQ(interfaces[0])); } return 0; }
void TCPStreamDialog::on_actionSwitchDirection_triggered() { address tmp_addr; guint16 tmp_port; copy_address(&tmp_addr, &graph_.src_address); tmp_port = graph_.src_port; copy_address(&graph_.src_address, &graph_.dst_address); graph_.src_port = graph_.dst_port; copy_address(&graph_.dst_address, &tmp_addr); graph_.dst_port = tmp_port; fillGraph(); }
/* WSLUA_ATTRIBUTE Pinfo_lo RO lower Address of this Packet. */ static int Pinfo_get_lo(lua_State *L) { Pinfo pinfo = checkPinfo(L,1); Address addr; addr = (Address)g_malloc(sizeof(address)); if (cmp_address(&(pinfo->ws_pinfo->src), &(pinfo->ws_pinfo->dst) ) < 0) { copy_address(addr, &(pinfo->ws_pinfo->src)); } else { copy_address(addr, &(pinfo->ws_pinfo->dst)); } pushAddress(L,addr); return 1; }
static status_t fill_route_entry(route_entry* target, void* _buffer, size_t bufferSize, net_route* route) { UserBuffer buffer(((uint8*)_buffer) + sizeof(route_entry), bufferSize - sizeof(route_entry)); target->destination = copy_address(buffer, route->destination); target->mask = copy_address(buffer, route->mask); target->gateway = copy_address(buffer, route->gateway); target->source = copy_address(buffer, route->interface_address->local); target->flags = route->flags; target->mtu = route->mtu; return buffer.Status(); }
void updateStreamInfo(const mcast_stream_info_t *stream_info) { copy_address(&src_addr_, &stream_info->src_addr); src_port_ = stream_info->src_port; copy_address(&dst_addr_, &stream_info->dest_addr); dst_port_ = stream_info->dest_port; num_packets_ = stream_info->npackets; avg_pps_ = stream_info->apackets; avg_bw_ = stream_info->average_bw; max_bw_ = stream_info->element.maxbw; top_burst_size_ = stream_info->element.topburstsize; num_bursts_ = stream_info->element.numbursts; top_buff_usage_ = stream_info->element.topbuffusage; num_buff_alarms_ = stream_info->element.numbuffalarms; draw(); }
//Copy from ui/gtk/follow_udp.c static gboolean udp_queue_packet_data(void *tapdata, packet_info *pinfo, epan_dissect_t *, const void *data) { follow_record_t *follow_record; follow_info_t *follow_info = (follow_info_t *)tapdata; tvbuff_t *next_tvb = (tvbuff_t *)data; follow_record = g_new(follow_record_t,1); follow_record->data = g_byte_array_sized_new(tvb_captured_length(next_tvb)); follow_record->data = g_byte_array_append(follow_record->data, tvb_get_ptr(next_tvb, 0, -1), tvb_captured_length(next_tvb)); follow_record->packet_num = pinfo->fd->num; if (follow_info->client_port == 0) { follow_info->client_port = pinfo->srcport; copy_address(&follow_info->client_ip, &pinfo->src); } if (addresses_equal(&follow_info->client_ip, &pinfo->src) && follow_info->client_port == pinfo->srcport) follow_record->is_server = FALSE; else follow_record->is_server = TRUE; /* update stream counter */ follow_info->bytes_written[follow_record->is_server] += follow_record->data->len; follow_info->payload = g_list_append(follow_info->payload, follow_record); return FALSE; }
static void dissect_wimax_fch_decoder(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { gint offset = 0; proto_item *fch_item = NULL; proto_tree *fch_tree = NULL; /* save the base station address (once) */ if(!bs_address.len) copy_address(&bs_address, &(pinfo->src)); /* update the info column */ col_append_sep_str(pinfo->cinfo, COL_INFO, NULL, "FCH"); if (tree) { /* we are being asked for details */ /* display FCH dissector info */ fch_item = proto_tree_add_protocol_format(tree, proto_wimax_fch_decoder, tvb, offset, 3, "DL Frame Prefix (24 bits)"); /* add FCH subtree */ fch_tree = proto_item_add_subtree(fch_item, ett_wimax_fch_decoder); /* Decode and display the used sub-channel groups */ proto_tree_add_item(fch_tree, hf_fch_used_subchannel_group0, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); proto_tree_add_item(fch_tree, hf_fch_used_subchannel_group1, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); proto_tree_add_item(fch_tree, hf_fch_used_subchannel_group2, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); proto_tree_add_item(fch_tree, hf_fch_used_subchannel_group3, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); proto_tree_add_item(fch_tree, hf_fch_used_subchannel_group4, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); proto_tree_add_item(fch_tree, hf_fch_used_subchannel_group5, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); proto_tree_add_item(fch_tree, hf_fch_reserved_1, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); /* Decode and display the repetition coding indication */ proto_tree_add_item(fch_tree, hf_fch_repetition_coding_indication, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); /* Decode and display the coding indication */ proto_tree_add_item(fch_tree, hf_fch_coding_indication, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); /* Decode and display the DL MAP length */ proto_tree_add_item(fch_tree, hf_fch_dlmap_length, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); proto_tree_add_item(fch_tree, hf_fch_reserved_2, tvb, offset, FCH_BURST_LENGTH, ENC_BIG_ENDIAN); } }
//Copy from ui/gtk/follow_ssl.c static gboolean ssl_queue_packet_data(void *tapdata, packet_info *pinfo, epan_dissect_t *, const void *ssl) { follow_info_t * follow_info = (follow_info_t*) tapdata; SslDecryptedRecord * rec = NULL; SslDataInfo * appl_data = NULL; int proto_ssl = GPOINTER_TO_INT(ssl); SslPacketInfo * pi = NULL; show_stream_t from = FROM_CLIENT; /* Skip packets without decrypted payload data. */ pi = (SslPacketInfo*) p_get_proto_data(wmem_file_scope(), pinfo, proto_ssl, 0); if (!pi || !pi->appl_data) return 0; /* Compute the packet's sender. */ if (follow_info->client_port == 0) { follow_info->client_port = pinfo->srcport; copy_address(&follow_info->client_ip, &pinfo->src); } if (addresses_equal(&follow_info->client_ip, &pinfo->src) && follow_info->client_port == pinfo->srcport) { from = FROM_CLIENT; } else { from = FROM_SERVER; } for (appl_data = pi->appl_data; appl_data != NULL; appl_data = appl_data->next) { /* TCP segments that contain the end of two or more SSL PDUs will be queued to SSL taps for each of those PDUs. Therefore a single packet could be processed by this SSL tap listener multiple times. The following test handles that scenario by treating the follow_info->bytes_written[] values as the next expected appl_data->seq. Any appl_data instances that fall below that have already been processed and must be skipped. */ if (appl_data->seq < follow_info->bytes_written[from]) continue; /* Allocate a SslDecryptedRecord to hold the current appl_data instance's decrypted data. Even though it would be possible to consolidate multiple appl_data instances into a single rec, it is beneficial to use a one-to-one mapping. This affords the Follow Stream dialog view modes (ASCII, EBCDIC, Hex Dump, C Arrays, Raw) the opportunity to accurately reflect SSL PDU boundaries. Currently the Hex Dump view does by starting a new line, and the C Arrays view does by starting a new array declaration. */ rec = (SslDecryptedRecord*) g_malloc(sizeof(SslDecryptedRecord) + appl_data->plain_data.data_len); rec->is_from_server = from == FROM_SERVER; rec->packet_num = pinfo->fd->num; rec->data.data = (guchar*) (rec + 1); rec->data.data_len = appl_data->plain_data.data_len; memcpy(rec->data.data, appl_data->plain_data.data, appl_data->plain_data.data_len); /* Append the record to the follow_info structure. */ follow_info->payload = g_list_append(follow_info->payload, rec); follow_info->bytes_written[from] += rec->data.data_len; } return FALSE; }
/* deep copy of id from packet_info */ void rtpstream_id_copy_pinfo(const packet_info *pinfo, rtpstream_id_t *dest, gboolean swap_src_dst) { if (!swap_src_dst) { copy_address(&(dest->src_addr), &(pinfo->src)); dest->src_port=pinfo->srcport; copy_address(&(dest->dst_addr), &(pinfo->dst)); dest->dst_port=pinfo->destport; } else { copy_address(&(dest->src_addr), &(pinfo->dst)); dest->src_port=pinfo->destport; copy_address(&(dest->dst_addr), &(pinfo->src)); dest->dst_port=pinfo->srcport; } }
static sctp_ep_t* alloc_sctp_ep(struct _sctp_info *si) { sctp_ep_t* ep; guint16 chunk_type; if(!si) return NULL; if (!(ep = (sctp_ep_t *)g_malloc(sizeof(sctp_ep_t)))) return NULL; copy_address(&ep->src,&si->ip_src); copy_address(&ep->dst,&si->ip_dst); ep->sport = si->sport; ep->dport = si->dport; ep->next = NULL; for(chunk_type = 0; chunk_type < 256; chunk_type++) ep->chunk_count[chunk_type] = 0; return ep; }
WlanStationTreeWidgetItem(address *addr) : QTreeWidgetItem (wlan_station_row_type_), packets_(0), sent_(0), received_(0), probe_req_(0), probe_resp_(0), auth_(0), deauth_(0), other_(0) { copy_address(&addr_, addr); setText(col_bssid_, address_to_qstring(&addr_)); }
static guint add_or_get_node(seq_analysis_info_t *sainfo, address *node) { guint i; if (node->type == AT_NONE) return NODE_OVERFLOW; for (i=0; i<MAX_NUM_NODES && i < sainfo->num_nodes ; i++) { if ( cmp_address(&(sainfo->nodes[i]), node) == 0 ) return i; /* it is in the array */ } if (i >= MAX_NUM_NODES) { return NODE_OVERFLOW; } else { sainfo->num_nodes++; copy_address(&(sainfo->nodes[i]), node); return i; } }
void add_hostlist_table_data(conv_hash_t *ch, const address *addr, guint32 port, gboolean sender, int num_frames, int num_bytes, hostlist_dissector_info_t *host_info, port_type port_type_val) { hostlist_talker_t *talker=NULL; int talker_idx=0; /* XXX should be optimized to allocate n extra entries at a time instead of just one */ /* if we don't have any entries at all yet */ if(ch->conv_array==NULL){ ch->conv_array=g_array_sized_new(FALSE, FALSE, sizeof(hostlist_talker_t), 10000); ch->hashtable = g_hash_table_new_full(host_hash, host_match, /* key_equal_func */ g_free, /* key_destroy_func */ NULL); /* value_destroy_func */ } else { /* try to find it among the existing known conversations */ host_key_t existing_key; gpointer talker_idx_hash_val; copy_address_shallow(&existing_key.myaddress, addr); existing_key.port = port; if (g_hash_table_lookup_extended(ch->hashtable, &existing_key, NULL, &talker_idx_hash_val)) { talker = &g_array_index(ch->conv_array, hostlist_talker_t, GPOINTER_TO_UINT(talker_idx_hash_val)); } } /* if we still don't know what talker this is it has to be a new one and we have to allocate it and append it to the end of the list */ if(talker==NULL){ host_key_t *new_key; hostlist_talker_t host; copy_address(&host.myaddress, addr); host.dissector_info = host_info; host.ptype=port_type_val; host.port=port; host.rx_frames=0; host.tx_frames=0; host.rx_bytes=0; host.tx_bytes=0; host.modified = TRUE; g_array_append_val(ch->conv_array, host); talker_idx= ch->conv_array->len - 1; talker=&g_array_index(ch->conv_array, hostlist_talker_t, talker_idx); /* hl->hosts address is not a constant but address.data is */ new_key = g_new(host_key_t,1); set_address(&new_key->myaddress, talker->myaddress.type, talker->myaddress.len, talker->myaddress.data); new_key->port = port; g_hash_table_insert(ch->hashtable, new_key, GUINT_TO_POINTER(talker_idx)); } /* if this is a new talker we need to initialize the struct */ talker->modified = TRUE; /* update the talker struct */ if( sender ){ talker->tx_frames+=num_frames; talker->tx_bytes+=num_bytes; } else { talker->rx_frames+=num_frames; talker->rx_bytes+=num_bytes; } }
void add_conversation_table_data_with_conv_id( conv_hash_t *ch, const address *src, const address *dst, guint32 src_port, guint32 dst_port, conv_id_t conv_id, int num_frames, int num_bytes, nstime_t *ts, nstime_t *abs_ts, ct_dissector_info_t *ct_info, port_type ptype) { const address *addr1, *addr2; guint32 port1, port2; conv_item_t *conv_item = NULL; unsigned int conversation_idx = 0; if (src_port > dst_port) { addr1 = src; addr2 = dst; port1 = src_port; port2 = dst_port; } else if (src_port < dst_port) { addr2 = src; addr1 = dst; port2 = src_port; port1 = dst_port; } else if (cmp_address(src, dst) < 0) { addr1 = src; addr2 = dst; port1 = src_port; port2 = dst_port; } else { addr2 = src; addr1 = dst; port2 = src_port; port1 = dst_port; } /* if we don't have any entries at all yet */ if (ch->conv_array == NULL) { ch->conv_array = g_array_sized_new(FALSE, FALSE, sizeof(conv_item_t), 10000); ch->hashtable = g_hash_table_new_full(conversation_hash, conversation_equal, /* key_equal_func */ g_free, /* key_destroy_func */ NULL); /* value_destroy_func */ } else { /* try to find it among the existing known conversations */ conv_key_t existing_key; gpointer conversation_idx_hash_val; existing_key.addr1 = *addr1; existing_key.addr2 = *addr2; existing_key.port1 = port1; existing_key.port2 = port2; existing_key.conv_id = conv_id; if (g_hash_table_lookup_extended(ch->hashtable, &existing_key, NULL, &conversation_idx_hash_val)) { conv_item = &g_array_index(ch->conv_array, conv_item_t, GPOINTER_TO_UINT(conversation_idx_hash_val)); } } /* if we still don't know what conversation this is it has to be a new one and we have to allocate it and append it to the end of the list */ if (conv_item == NULL) { conv_key_t *new_key; conv_item_t new_conv_item; copy_address(&new_conv_item.src_address, addr1); copy_address(&new_conv_item.dst_address, addr2); new_conv_item.dissector_info = ct_info; new_conv_item.ptype = ptype; new_conv_item.src_port = port1; new_conv_item.dst_port = port2; new_conv_item.conv_id = conv_id; new_conv_item.rx_frames = 0; new_conv_item.tx_frames = 0; new_conv_item.rx_bytes = 0; new_conv_item.tx_bytes = 0; new_conv_item.modified = TRUE; if (ts) { memcpy(&new_conv_item.start_time, ts, sizeof(new_conv_item.start_time)); memcpy(&new_conv_item.stop_time, ts, sizeof(new_conv_item.stop_time)); memcpy(&new_conv_item.start_abs_time, abs_ts, sizeof(new_conv_item.start_abs_time)); } else { nstime_set_unset(&new_conv_item.start_abs_time); nstime_set_unset(&new_conv_item.start_time); nstime_set_unset(&new_conv_item.stop_time); } g_array_append_val(ch->conv_array, new_conv_item); conversation_idx = ch->conv_array->len - 1; conv_item = &g_array_index(ch->conv_array, conv_item_t, conversation_idx); /* ct->conversations address is not a constant but src/dst_address.data are */ new_key = g_new(conv_key_t, 1); set_address(&new_key->addr1, conv_item->src_address.type, conv_item->src_address.len, conv_item->src_address.data); set_address(&new_key->addr2, conv_item->dst_address.type, conv_item->dst_address.len, conv_item->dst_address.data); new_key->port1 = port1; new_key->port2 = port2; new_key->conv_id = conv_id; g_hash_table_insert(ch->hashtable, new_key, GUINT_TO_POINTER(conversation_idx)); } /* update the conversation struct */ conv_item->modified = TRUE; if ( (!cmp_address(src, addr1)) && (!cmp_address(dst, addr2)) && (src_port==port1) && (dst_port==port2) ) { conv_item->tx_frames += num_frames; conv_item->tx_bytes += num_bytes; } else { conv_item->rx_frames += num_frames; conv_item->rx_bytes += num_bytes; } if (ts) { if (nstime_cmp(ts, &conv_item->stop_time) > 0) { memcpy(&conv_item->stop_time, ts, sizeof(conv_item->stop_time)); } else if (nstime_cmp(ts, &conv_item->start_time) < 0) { memcpy(&conv_item->start_time, ts, sizeof(conv_item->start_time)); memcpy(&conv_item->start_abs_time, abs_ts, sizeof(conv_item->start_abs_time)); } } }
/* Broadcasts are searches, offers or promises. * * Searches are sent by * a peer when it needs a file (ie. while applying its policy, when it needs * files such as installers to install software.) * * Each broadcast relates to one file and each file is identified only by its * checksum - no file names are ever used. A search times out after 10 seconds * (configurable) and the peer will then attempt to act on any offers by * downloading (via push or pull - see dissect_ldss_transfer) from those peers. * * If no offers are received, the search fails and the peer fetches the file * from a remote server, generally a HTTP server on the other side of a WAN. * The protocol exists to minimize the number of WAN downloads needed. * * While downloading from WAN the peer sends promises to inform other peers * when it will be available for them to download. This prevents multiple peers * simultaneously downloading the same file. Promises also inform other peers * how much download bandwidth is being used by their download. Other peers use * this information and the configured knowledge of the WAN bandwidth to avoid * saturating the WAN link, as file downloads are a non-time-critical and * non-business-critical network function. LDSS is intended for networks of * 5-20 machines connected by slow WAN link. The current implementation of the * protocol allows administrator to configure "time windows" when WAN usage is * throttled/unthrottled, though this isn't visible in LDSS. * * Once a WAN download or a LAN transfer (see below above dissect_ldss_transfer) * has complete the peer will offer the file to other peers on the LAN so they * don't need to download it themselves. * * Peers also notify when they shut down in case any other peer is waiting for * a file. */ static int dissect_ldss_broadcast(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree) { guint16 messageID; guint8 digest_type; guint8 compression; guint32 cookie; guint8 *digest; guint64 size; guint64 offset; guint32 targetTime; guint16 port; guint16 rate; guint16 messageDetail = INFERRED_NONE; proto_tree *ti, *ldss_tree; const gchar *packet_type, *packet_detail; messageID = tvb_get_ntohs (tvb, 0); digest_type = tvb_get_guint8 (tvb, 2); compression = tvb_get_guint8 (tvb, 3); cookie = tvb_get_ntohl (tvb, 4); digest = (guint8 *)tvb_memdup (NULL, tvb, 8, DIGEST_LEN); size = tvb_get_ntoh64 (tvb, 40); offset = tvb_get_ntoh64 (tvb, 48); targetTime = tvb_get_ntohl (tvb, 56); port = tvb_get_ntohs (tvb, 64); rate = tvb_get_ntohs (tvb, 66); packet_type = val_to_str_const(messageID, ldss_message_id_value, "unknown"); if (messageID == MESSAGE_ID_WILLSEND) { if (cookie == 0) { /* Shutdown: Dishonor promises from this peer. Current * implementation abuses WillSend for this. */ messageDetail = INFERRED_PEERSHUTDOWN; } else if (size == 0 && offset == 0) { /* NeedFile search failed - going to WAN */ messageDetail = INFERRED_WANDOWNLOAD; } else if (size > 0) { /* Size is known (not always the case) */ if (size == offset) { /* File is available for pull on this peer's TCP port */ messageDetail = INFERRED_OFFER; } else { /* WAN download progress announcement from this peer */ messageDetail = INFERRED_PROMISE; } } } else if (messageID == MESSAGE_ID_NEEDFILE) { messageDetail = INFERRED_SEARCH; } packet_detail = val_to_str_const(messageDetail, ldss_inferred_info, "unknown"); /* Set the info column */ col_add_fstr(pinfo->cinfo, COL_INFO, "LDSS Broadcast (%s%s)", packet_type, packet_detail); /* If we have a non-null tree (ie we are building the proto_tree * instead of just filling out the columns), then give more detail. */ if (tree) { ti = proto_tree_add_item(tree, proto_ldss, tvb, 0, (tvb_captured_length(tvb) > 72) ? tvb_captured_length(tvb) : 72, ENC_NA); ldss_tree = proto_item_add_subtree(ti, ett_ldss_broadcast); proto_tree_add_item(ldss_tree, hf_ldss_message_id, tvb, 0, 2, ENC_BIG_ENDIAN); ti = proto_tree_add_uint(ldss_tree, hf_ldss_message_detail, tvb, 0, 0, messageDetail); PROTO_ITEM_SET_GENERATED(ti); proto_tree_add_item(ldss_tree, hf_ldss_digest_type, tvb, 2, 1, ENC_BIG_ENDIAN); proto_tree_add_item(ldss_tree, hf_ldss_compression, tvb, 3, 1, ENC_BIG_ENDIAN); proto_tree_add_uint_format_value(ldss_tree, hf_ldss_cookie, tvb, 4, 4, FALSE, "0x%x%s", cookie, (cookie == 0) ? " - shutdown (promises from this peer are no longer valid)" : ""); proto_tree_add_item(ldss_tree, hf_ldss_digest, tvb, 8, DIGEST_LEN, ENC_NA); proto_tree_add_item(ldss_tree, hf_ldss_size, tvb, 40, 8, ENC_BIG_ENDIAN); proto_tree_add_item(ldss_tree, hf_ldss_offset, tvb, 48, 8, ENC_BIG_ENDIAN); proto_tree_add_uint_format_value(ldss_tree, hf_ldss_target_time, tvb, 56, 4, FALSE, "%d:%02d:%02d", (int)(targetTime / 3600), (int)((targetTime / 60) % 60), (int)(targetTime % 60)); proto_tree_add_item(ldss_tree, hf_ldss_reserved_1, tvb, 60, 4, ENC_BIG_ENDIAN); proto_tree_add_uint_format_value(ldss_tree, hf_ldss_port, tvb, 64, 2, FALSE, "%d%s", port, (messageID == MESSAGE_ID_WILLSEND && size > 0 && size == offset) ? " - file can be pulled at this TCP port" : (messageID == MESSAGE_ID_NEEDFILE ? " - file can be pushed to this TCP port" : "")); proto_tree_add_uint_format_value(ldss_tree, hf_ldss_rate, tvb, 66, 2, FALSE, "%ld", (rate > 0) ? (long)floor(exp(rate * G_LN2 / 2048)) : 0); proto_tree_add_item(ldss_tree, hf_ldss_priority, tvb, 68, 2, ENC_BIG_ENDIAN); proto_tree_add_item(ldss_tree, hf_ldss_property_count, tvb, 70, 2, ENC_BIG_ENDIAN); if (tvb_reported_length(tvb) > 72) { proto_tree_add_item(ldss_tree, hf_ldss_properties, tvb, 72, tvb_captured_length(tvb) - 72, ENC_NA); } } /* Finally, store the broadcast and register ourselves to dissect * any pushes or pulls that result from this broadcast. All data * is pushed/pulled over TCP using the port from the broadcast * packet's port field. * Track each by a TCP conversation with the remote end wildcarded. * The TCP conv tracks back to a broadcast conv to determine what it * is in response to. * * These steps only need to be done once per packet, so a variable * tracks the highest frame number seen. Handles the case of first frame * being frame zero. */ if (messageDetail != INFERRED_PEERSHUTDOWN && (highest_num_seen == 0 || highest_num_seen < pinfo->num)) { ldss_broadcast_t *data; /* Populate data from the broadcast */ data = wmem_new0(wmem_file_scope(), ldss_broadcast_t); data->num = pinfo->num; data->ts = pinfo->abs_ts; data->message_id = messageID; data->message_detail = messageDetail; data->port = port; data->size = size; data->offset = offset; data->compression = compression; data->file = wmem_new0(wmem_file_scope(), ldss_file_t); data->file->digest = digest; data->file->digest_type = digest_type; data->broadcaster = wmem_new0(wmem_file_scope(), ldss_broadcaster_t); copy_address(&data->broadcaster->addr, &pinfo->src); data->broadcaster->port = port; /* Dissect any future pushes/pulls */ if (port > 0) { prepare_ldss_transfer_conv(data); } /* Record that the frame was processed */ highest_num_seen = pinfo->num; } return tvb_captured_length(tvb); }
TCPStreamDialog::TCPStreamDialog(QWidget *parent, capture_file *cf, tcp_graph_type graph_type) : QDialog(NULL, Qt::Window), ui(new Ui::TCPStreamDialog), cap_file_(cf), ts_offset_(0), ts_origin_conn_(true), seq_offset_(0), seq_origin_zero_(true), title_(NULL), base_graph_(NULL), tput_graph_(NULL), seg_graph_(NULL), ack_graph_(NULL), rwin_graph_(NULL), tracer_(NULL), packet_num_(0), mouse_drags_(true), rubber_band_(NULL), num_dsegs_(-1), num_acks_(-1), num_sack_ranges_(-1) { struct segment current; int graph_idx = -1; ui->setupUi(this); setAttribute(Qt::WA_DeleteOnClose, true); graph_.type = GRAPH_UNDEFINED; set_address(&graph_.src_address, AT_NONE, 0, NULL); graph_.src_port = 0; set_address(&graph_.dst_address, AT_NONE, 0, NULL); graph_.dst_port = 0; graph_.stream = 0; graph_.segments = NULL; struct tcpheader *header = select_tcpip_session(cap_file_, ¤t); if (!header) { done(QDialog::Rejected); return; } //#ifdef Q_OS_MAC // ui->hintLabel->setAttribute(Qt::WA_MacSmallSize, true); //#endif QComboBox *gtcb = ui->graphTypeComboBox; gtcb->setUpdatesEnabled(false); gtcb->addItem(ui->actionRoundTripTime->text(), GRAPH_RTT); if (graph_type == GRAPH_RTT) graph_idx = gtcb->count() - 1; gtcb->addItem(ui->actionThroughput->text(), GRAPH_THROUGHPUT); if (graph_type == GRAPH_THROUGHPUT) graph_idx = gtcb->count() - 1; gtcb->addItem(ui->actionStevens->text(), GRAPH_TSEQ_STEVENS); if (graph_type == GRAPH_TSEQ_STEVENS) graph_idx = gtcb->count() - 1; gtcb->addItem(ui->actionTcptrace->text(), GRAPH_TSEQ_TCPTRACE); if (graph_type == GRAPH_TSEQ_TCPTRACE) graph_idx = gtcb->count() - 1; gtcb->addItem(ui->actionWindowScaling->text(), GRAPH_WSCALE); if (graph_type == GRAPH_WSCALE) graph_idx = gtcb->count() - 1; gtcb->setUpdatesEnabled(true); ui->dragRadioButton->setChecked(mouse_drags_); ctx_menu_.addAction(ui->actionZoomIn); ctx_menu_.addAction(ui->actionZoomInX); ctx_menu_.addAction(ui->actionZoomInY); ctx_menu_.addAction(ui->actionZoomOut); ctx_menu_.addAction(ui->actionZoomOutX); ctx_menu_.addAction(ui->actionZoomOutY); ctx_menu_.addAction(ui->actionReset); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionMoveRight10); ctx_menu_.addAction(ui->actionMoveLeft10); ctx_menu_.addAction(ui->actionMoveUp10); ctx_menu_.addAction(ui->actionMoveDown10); ctx_menu_.addAction(ui->actionMoveRight1); ctx_menu_.addAction(ui->actionMoveLeft1); ctx_menu_.addAction(ui->actionMoveUp1); ctx_menu_.addAction(ui->actionMoveDown1); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionNextStream); ctx_menu_.addAction(ui->actionPreviousStream); ctx_menu_.addAction(ui->actionSwitchDirection); ctx_menu_.addAction(ui->actionGoToPacket); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionDragZoom); ctx_menu_.addAction(ui->actionToggleSequenceNumbers); ctx_menu_.addAction(ui->actionToggleTimeOrigin); ctx_menu_.addAction(ui->actionCrosshairs); ctx_menu_.addSeparator(); ctx_menu_.addAction(ui->actionRoundTripTime); ctx_menu_.addAction(ui->actionThroughput); ctx_menu_.addAction(ui->actionStevens); ctx_menu_.addAction(ui->actionTcptrace); ctx_menu_.addAction(ui->actionWindowScaling); memset (&graph_, 0, sizeof(graph_)); graph_.type = graph_type; copy_address(&graph_.src_address, ¤t.ip_src); graph_.src_port = current.th_sport; copy_address(&graph_.dst_address, ¤t.ip_dst); graph_.dst_port = current.th_dport; graph_.stream = header->th_stream; findStream(); ui->streamNumberSpinBox->blockSignals(true); ui->streamNumberSpinBox->setMaximum(get_tcp_stream_count() - 1); ui->streamNumberSpinBox->setValue(graph_.stream); ui->streamNumberSpinBox->blockSignals(false); QCustomPlot *sp = ui->streamPlot; QCPPlotTitle *file_title = new QCPPlotTitle(sp, cf_get_display_name(cap_file_)); file_title->setFont(sp->xAxis->labelFont()); title_ = new QCPPlotTitle(sp); sp->plotLayout()->insertRow(0); sp->plotLayout()->addElement(0, 0, file_title); sp->plotLayout()->insertRow(0); sp->plotLayout()->addElement(0, 0, title_); base_graph_ = sp->addGraph(); // All: Selectable segments base_graph_->setPen(QPen(QBrush(graph_color_1), 0.25)); tput_graph_ = sp->addGraph(sp->xAxis, sp->yAxis2); // Throughput: Moving average tput_graph_->setPen(QPen(QBrush(graph_color_2), 0.5)); tput_graph_->setLineStyle(QCPGraph::lsLine); seg_graph_ = sp->addGraph(); // tcptrace: fwd segments seg_graph_->setErrorType(QCPGraph::etValue); seg_graph_->setLineStyle(QCPGraph::lsNone); seg_graph_->setScatterStyle(QCPScatterStyle(QCPScatterStyle::ssDot, Qt::transparent, 0)); seg_graph_->setErrorPen(QPen(QBrush(graph_color_1), 0.5)); seg_graph_->setErrorBarSize(pkt_point_size_); ack_graph_ = sp->addGraph(); // tcptrace: rev ACKs ack_graph_->setPen(QPen(QBrush(graph_color_2), 0.5)); ack_graph_->setLineStyle(QCPGraph::lsStepLeft); rwin_graph_ = sp->addGraph(); // tcptrace: rev RWIN rwin_graph_->setPen(QPen(QBrush(graph_color_3), 0.5)); rwin_graph_->setLineStyle(QCPGraph::lsStepLeft); tracer_ = new QCPItemTracer(sp); sp->addItem(tracer_); // Triggers fillGraph(). ui->graphTypeComboBox->setCurrentIndex(graph_idx); sp->setMouseTracking(true); sp->yAxis->setLabelColor(QColor(graph_color_1)); sp->yAxis->setTickLabelColor(QColor(graph_color_1)); tracer_->setVisible(false); toggleTracerStyle(true); QPushButton *save_bt = ui->buttonBox->button(QDialogButtonBox::Save); save_bt->setText(tr("Save As" UTF8_HORIZONTAL_ELLIPSIS)); QPushButton *close_bt = ui->buttonBox->button(QDialogButtonBox::Close); if (close_bt) { close_bt->setDefault(true); } ProgressFrame::addToButtonBox(ui->buttonBox, parent); connect(sp, SIGNAL(mousePress(QMouseEvent*)), this, SLOT(graphClicked(QMouseEvent*))); connect(sp, SIGNAL(mouseMove(QMouseEvent*)), this, SLOT(mouseMoved(QMouseEvent*))); connect(sp, SIGNAL(mouseRelease(QMouseEvent*)), this, SLOT(mouseReleased(QMouseEvent*))); connect(sp, SIGNAL(axisClick(QCPAxis*,QCPAxis::SelectablePart,QMouseEvent*)), this, SLOT(axisClicked(QCPAxis*,QCPAxis::SelectablePart,QMouseEvent*))); connect(sp->yAxis, SIGNAL(rangeChanged(QCPRange)), this, SLOT(transformYRange(QCPRange))); disconnect(ui->buttonBox, SIGNAL(accepted()), this, SLOT(accept())); this->setResult(QDialog::Accepted); }
static gboolean lbm_uimflow_add_to_graph(seq_analysis_info_t * seq_info, packet_info * pinfo, const lbm_uim_stream_info_t * stream_info) { lbm_uim_stream_endpoint_t epa; lbm_uim_stream_endpoint_t epb; seq_analysis_item_t * item; gchar * ctxinst1 = NULL; gchar * ctxinst2 = NULL; gboolean swap_endpoints = FALSE; int rc; if (stream_info->endpoint_a.type != stream_info->endpoint_b.type) { return (FALSE); } if (stream_info->endpoint_a.type == lbm_uim_instance_stream) { rc = memcmp((void *)stream_info->endpoint_a.stream_info.ctxinst.ctxinst, (void *)stream_info->endpoint_b.stream_info.ctxinst.ctxinst, LBM_CONTEXT_INSTANCE_BLOCK_SZ); if (rc <= 0) { swap_endpoints = FALSE; } else { swap_endpoints = TRUE; } } else { if (stream_info->endpoint_a.stream_info.dest.domain < stream_info->endpoint_b.stream_info.dest.domain) { swap_endpoints = FALSE; } else if (stream_info->endpoint_a.stream_info.dest.domain > stream_info->endpoint_b.stream_info.dest.domain) { swap_endpoints = TRUE; } else { int compare; compare = cmp_address(&(stream_info->endpoint_a.stream_info.dest.addr), &(stream_info->endpoint_b.stream_info.dest.addr)); if (compare < 0) { swap_endpoints = FALSE; } else if (compare > 0) { swap_endpoints = TRUE; } else { if (stream_info->endpoint_a.stream_info.dest.port <= stream_info->endpoint_b.stream_info.dest.port) { swap_endpoints = FALSE; } else { swap_endpoints = TRUE; } } } } if (swap_endpoints == FALSE) { epa = stream_info->endpoint_a; epb = stream_info->endpoint_b; } else { epb = stream_info->endpoint_a; epa = stream_info->endpoint_b; } item = (seq_analysis_item_t *)g_malloc0(sizeof(seq_analysis_item_t)); copy_address(&(item->src_addr), &(pinfo->src)); copy_address(&(item->dst_addr), &(pinfo->dst)); item->frame_number = pinfo->fd->num; item->port_src = pinfo->srcport; item->port_dst = pinfo->destport; item->protocol = g_strdup(port_type_to_str(pinfo->ptype)); if (stream_info->description == NULL) { item->frame_label = g_strdup_printf("(%" G_GUINT32_FORMAT ")", stream_info->sqn); } else { item->frame_label = g_strdup_printf("%s (%" G_GUINT32_FORMAT ")", stream_info->description, stream_info->sqn); } if (epa.type == lbm_uim_instance_stream) { ctxinst1 = bytes_to_str(pinfo->pool, epa.stream_info.ctxinst.ctxinst, sizeof(epa.stream_info.ctxinst.ctxinst)); ctxinst2 = bytes_to_str(pinfo->pool, epb.stream_info.ctxinst.ctxinst, sizeof(epb.stream_info.ctxinst.ctxinst)); item->comment = g_strdup_printf("%s <-> %s [%" G_GUINT64_FORMAT "]", ctxinst1, ctxinst2, stream_info->channel); } else { item->comment = g_strdup_printf("%" G_GUINT32_FORMAT ":%s:%" G_GUINT16_FORMAT " <-> %" G_GUINT32_FORMAT ":%s:%" G_GUINT16_FORMAT " [%" G_GUINT64_FORMAT "]", epa.stream_info.dest.domain, address_to_str(pinfo->pool, &(epa.stream_info.dest.addr)), epa.stream_info.dest.port, epb.stream_info.dest.domain, address_to_str(pinfo->pool, &(epb.stream_info.dest.addr)), epb.stream_info.dest.port, stream_info->channel); } item->conv_num = (guint16)LBM_CHANNEL_ID(stream_info->channel); item->display = TRUE; item->line_style = 1; g_queue_push_tail(seq_info->items, item); return (TRUE); }
/*! Returns a chained list of all interfaces. We follow BSD semantics, and only return one entry per interface, not per address; since this is mainly used by NetBSD's netresolv, it's probably what it expects. */ int getifaddrs(struct ifaddrs** _ifaddrs) { if (_ifaddrs == NULL) { errno = B_BAD_VALUE; return -1; } int socket = ::socket(AF_INET, SOCK_DGRAM, 0); if (socket < 0) return -1; FileDescriptorCloser closer(socket); // Get interface count ifconf config; config.ifc_len = sizeof(config.ifc_value); if (ioctl(socket, SIOCGIFCOUNT, &config, sizeof(struct ifconf)) < 0) return -1; size_t count = (size_t)config.ifc_value; if (count == 0) { errno = B_BAD_VALUE; return -1; } // Allocate a buffer for ifreqs for all interfaces char* buffer = (char*)malloc(count * sizeof(struct ifreq)); if (buffer == NULL) { errno = B_NO_MEMORY; return -1; } MemoryDeleter deleter(buffer); // Get interfaces configuration config.ifc_len = count * sizeof(struct ifreq); config.ifc_buf = buffer; if (ioctl(socket, SIOCGIFCONF, &config, sizeof(struct ifconf)) < 0) return -1; ifreq* interfaces = (ifreq*)buffer; ifreq* end = (ifreq*)(buffer + config.ifc_len); struct ifaddrs* previous = NULL; for (uint32_t i = 0; interfaces < end; i++) { struct ifaddrs* current = new(std::nothrow) ifaddrs(); if (current == NULL) { freeifaddrs(previous); errno = B_NO_MEMORY; return -1; } // Chain this interface with the next one current->ifa_next = previous; previous = current; current->ifa_name = strdup(interfaces[0].ifr_name); current->ifa_addr = copy_address(interfaces[0].ifr_addr); current->ifa_netmask = NULL; current->ifa_dstaddr = NULL; current->ifa_data = NULL; ifreq request; strlcpy(request.ifr_name, interfaces[0].ifr_name, IF_NAMESIZE); if (ioctl(socket, SIOCGIFFLAGS, &request, sizeof(struct ifreq)) == 0) current->ifa_flags = request.ifr_flags; if (ioctl(socket, SIOCGIFNETMASK, &request, sizeof(struct ifreq)) == 0) { current->ifa_netmask = copy_address(request.ifr_mask); } if (ioctl(socket, SIOCGIFDSTADDR, &request, sizeof(struct ifreq)) == 0) { current->ifa_dstaddr = copy_address(request.ifr_dstaddr); } // Move on to next interface interfaces = (ifreq*)((uint8_t*)interfaces + _SIZEOF_ADDR_IFREQ(interfaces[0])); } *_ifaddrs = previous; return 0; }
Iax2AnalysisDialog::Iax2AnalysisDialog(QWidget &parent, CaptureFile &cf) : WiresharkDialog(parent, cf), ui(new Ui::Iax2AnalysisDialog), port_src_fwd_(0), port_dst_fwd_(0), port_src_rev_(0), port_dst_rev_(0) { ui->setupUi(this); setWindowSubtitle(tr("IAX2 Stream Analysis")); // XXX Use recent settings instead resize(parent.width() * 4 / 5, parent.height() * 4 / 5); ui->progressFrame->hide(); stream_ctx_menu_.addAction(ui->actionGoToPacket); stream_ctx_menu_.addAction(ui->actionNextProblem); stream_ctx_menu_.addSeparator(); stream_ctx_menu_.addAction(ui->actionSaveAudio); stream_ctx_menu_.addAction(ui->actionSaveForwardAudio); stream_ctx_menu_.addAction(ui->actionSaveReverseAudio); stream_ctx_menu_.addSeparator(); stream_ctx_menu_.addAction(ui->actionSaveCsv); stream_ctx_menu_.addAction(ui->actionSaveForwardCsv); stream_ctx_menu_.addAction(ui->actionSaveReverseCsv); stream_ctx_menu_.addSeparator(); stream_ctx_menu_.addAction(ui->actionSaveGraph); ui->forwardTreeWidget->installEventFilter(this); ui->forwardTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu); connect(ui->forwardTreeWidget, SIGNAL(customContextMenuRequested(QPoint)), SLOT(showStreamMenu(QPoint))); ui->reverseTreeWidget->installEventFilter(this); ui->reverseTreeWidget->setContextMenuPolicy(Qt::CustomContextMenu); connect(ui->reverseTreeWidget, SIGNAL(customContextMenuRequested(QPoint)), SLOT(showStreamMenu(QPoint))); connect(ui->streamGraph, SIGNAL(mousePress(QMouseEvent*)), this, SLOT(graphClicked(QMouseEvent*))); graph_ctx_menu_.addAction(ui->actionSaveGraph); QStringList header_labels; for (int i = 0; i < ui->forwardTreeWidget->columnCount(); i++) { header_labels << ui->forwardTreeWidget->headerItem()->text(i); } ui->reverseTreeWidget->setHeaderLabels(header_labels); memset(&src_fwd_, 0, sizeof(address)); memset(&dst_fwd_, 0, sizeof(address)); memset(&src_rev_, 0, sizeof(address)); memset(&dst_rev_, 0, sizeof(address)); QList<QCheckBox *> graph_cbs = QList<QCheckBox *>() << ui->fJitterCheckBox << ui->fDiffCheckBox << ui->rJitterCheckBox << ui->rDiffCheckBox; for (int i = 0; i < num_graphs_; i++) { QCPGraph *graph = ui->streamGraph->addGraph(); graph->setPen(QPen(ColorUtils::graph_colors_[i])); graph->setName(graph_cbs[i]->text()); graphs_ << graph; graph_cbs[i]->setChecked(true); graph_cbs[i]->setIcon(StockIcon::colorIcon(ColorUtils::graph_colors_[i], QPalette::Text)); } ui->streamGraph->xAxis->setLabel("Arrival Time"); ui->streamGraph->yAxis->setLabel("Value (ms)"); // We keep our temp files open for the lifetime of the dialog. The GTK+ // UI opens and closes at various points. QString tempname = QString("%1/wireshark_iax2_f").arg(QDir::tempPath()); fwd_tempfile_ = new QTemporaryFile(tempname, this); fwd_tempfile_->open(); tempname = QString("%1/wireshark_iax2_r").arg(QDir::tempPath()); rev_tempfile_ = new QTemporaryFile(tempname, this); rev_tempfile_->open(); if (fwd_tempfile_->error() != QFile::NoError || rev_tempfile_->error() != QFile::NoError) { err_str_ = tr("Unable to save RTP data."); ui->actionSaveAudio->setEnabled(false); ui->actionSaveForwardAudio->setEnabled(false); ui->actionSaveReverseAudio->setEnabled(false); } QMenu *save_menu = new QMenu(); save_menu->addAction(ui->actionSaveAudio); save_menu->addAction(ui->actionSaveForwardAudio); save_menu->addAction(ui->actionSaveReverseAudio); save_menu->addSeparator(); save_menu->addAction(ui->actionSaveCsv); save_menu->addAction(ui->actionSaveForwardCsv); save_menu->addAction(ui->actionSaveReverseCsv); save_menu->addSeparator(); save_menu->addAction(ui->actionSaveGraph); ui->buttonBox->button(QDialogButtonBox::Save)->setMenu(save_menu); const gchar *filter_text = "iax2 && (ip || ipv6)"; dfilter_t *sfcode; gchar *err_msg; if (!dfilter_compile(filter_text, &sfcode, &err_msg)) { QMessageBox::warning(this, tr("No IAX2 packets found"), QString("%1").arg(err_msg)); g_free(err_msg); close(); } if (!cap_file_.capFile() || !cap_file_.capFile()->current_frame) close(); frame_data *fdata = cap_file_.capFile()->current_frame; if (!cf_read_record(cap_file_.capFile(), fdata)) close(); epan_dissect_t edt; epan_dissect_init(&edt, cap_file_.capFile()->epan, TRUE, FALSE); epan_dissect_prime_dfilter(&edt, sfcode); epan_dissect_run(&edt, cap_file_.capFile()->cd_t, &cap_file_.capFile()->phdr, frame_tvbuff_new_buffer(fdata, &cap_file_.capFile()->buf), fdata, NULL); // This shouldn't happen (the menu item should be disabled) but check anyway if (!dfilter_apply_edt(sfcode, &edt)) { epan_dissect_cleanup(&edt); dfilter_free(sfcode); err_str_ = tr("Please select an IAX2 packet"); updateWidgets(); return; } dfilter_free(sfcode); /* ok, it is a IAX2 frame, so let's get the ip and port values */ copy_address(&(src_fwd_), &(edt.pi.src)); copy_address(&(dst_fwd_), &(edt.pi.dst)); port_src_fwd_ = edt.pi.srcport; port_dst_fwd_ = edt.pi.destport; /* assume the inverse ip/port combination for the reverse direction */ copy_address(&(src_rev_), &(edt.pi.dst)); copy_address(&(dst_rev_), &(edt.pi.src)); port_src_rev_ = edt.pi.destport; port_dst_rev_ = edt.pi.srcport; #if 0 /* check if it is Voice or MiniPacket */ bool ok; getIntFromProtoTree(edt.tree, "iax2", "iax2.call", &ok); if (!ok) { err_str_ = tr("Please select an IAX2 packet."); updateWidgets(); return; } #endif #ifdef IAX2_RTP_STREAM_CHECK rtpstream_tapinfot tapinfo; /* Register the tap listener */ memset(&tapinfo, 0, sizeof(rtpstream_tapinfot)); tapinfo.tap_data = this; tapinfo.mode = TAP_ANALYSE; // register_tap_listener_rtp_stream(&tapinfo, NULL); /* Scan for RTP streams (redissect all packets) */ rtpstream_scan(&tapinfo, cap_file_.capFile(), NULL); int num_streams = 0; GList *filtered_list = NULL; for (GList *strinfo_list = g_list_first(tapinfo.strinfo_list); strinfo_list; strinfo_list = g_list_next(strinfo_list)) { rtp_stream_info_t * strinfo = (rtp_stream_info_t*)(strinfo_list->data); << address_to_qstring(&strinfo->dest_addr) << address_to_qstring(&src_rev_) << address_to_qstring(&dst_rev_); if (addresses_equal(&(strinfo->src_addr), &(src_fwd_)) && (strinfo->src_port == port_src_fwd_) && (addresses_equal(&(strinfo->dest_addr), &(dst_fwd_))) && (strinfo->dest_port == port_dst_fwd_)) { ++num_streams; filtered_list = g_list_prepend(filtered_list, strinfo); } if (addresses_equal(&(strinfo->src_addr), &(src_rev_)) && (strinfo->src_port == port_src_rev_) && (addresses_equal(&(strinfo->dest_addr), &(dst_rev_))) && (strinfo->dest_port == port_dst_rev_)) { ++num_streams; filtered_list = g_list_append(filtered_list, strinfo); } }
void copy_link_address(ChannelState *state){ copy_address(state); }
void copy_link_address(Address a, Address b){ copy_address(a, b); }