/*
* dissect lwapp control packets. This is not fully implemented,
* but it's a good start.
*/
static void
dissect_control(tvbuff_t *tvb, packet_info *pinfo,
proto_tree *tree)
{
CNTL_Header header;
proto_tree *control_tree;
tvbuff_t *next_tvb;
/* Set up structures needed to add the protocol subtree and manage it */
proto_item *ti;
gint offset=0;
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "LWAPP");
col_set_str(pinfo->cinfo, COL_INFO,
"CNTL ");
/* Copy our header */
tvb_memcpy(tvb, (guint8*) &header, offset, sizeof(header));
/*
* Fix the length (network byte ordering), and set our version &
* slot id
*/
header.length = g_ntohs(header.length);
col_append_str(pinfo->cinfo, COL_INFO,
val_to_str_ext(header.type, &control_msg_vals_ext, "Bad Type: 0x%02x"));
/* In the interest of speed, if "tree" is NULL, don't do any work not
necessary to generate protocol tree items. */
if (tree) {
/* create display subtree for the protocol */
ti = proto_tree_add_item(tree, proto_lwapp_control, tvb, offset,
-1, ENC_NA);
control_tree = proto_item_add_subtree(ti, ett_lwapp_control);
proto_tree_add_uint(control_tree, hf_lwapp_control_type,
tvb, offset, 1, header.type);
offset++;
proto_tree_add_uint(control_tree, hf_lwapp_control_seq_no,
tvb, offset, 1, header.seqNo);
offset++;
proto_tree_add_uint(control_tree, hf_lwapp_control_length,
tvb, offset, 2, header.length);
offset += 2;
/* Dissect rest of packet as data */
next_tvb = tvb_new_subset_remaining(tvb, offset);
call_dissector(data_handle,next_tvb, pinfo, tree);
}
} /* dissect_control */
EXPORT_C
#endif
guint16
gst_rtp_buffer_get_seq (GstBuffer * buffer)
{
g_return_val_if_fail (GST_IS_BUFFER (buffer), 0);
g_return_val_if_fail (GST_BUFFER_DATA (buffer) != NULL, 0);
return g_ntohs (GST_RTP_HEADER_SEQ (buffer));
}
static gboolean read_stream(GObex *obex, GError **err)
{
GIOChannel *io = obex->io;
GIOStatus status;
gsize rbytes, toread;
guint16 u16;
gchar *buf;
if (obex->rx_data >= 3)
goto read_body;
rbytes = 0;
toread = 3 - obex->rx_data;
buf = (gchar *) &obex->rx_buf[obex->rx_data];
status = g_io_channel_read_chars(io, buf, toread, &rbytes, NULL);
if (status != G_IO_STATUS_NORMAL)
return TRUE;
obex->rx_data += rbytes;
if (obex->rx_data < 3)
goto done;
memcpy(&u16, &buf[1], sizeof(u16));
obex->rx_pkt_len = g_ntohs(u16);
if (obex->rx_pkt_len > obex->rx_mtu) {
g_set_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR,
"Too big incoming packet");
g_obex_debug(G_OBEX_DEBUG_ERROR, "%s", (*err)->message);
return FALSE;
}
read_body:
if (obex->rx_data >= obex->rx_pkt_len)
goto done;
do {
toread = obex->rx_pkt_len - obex->rx_data;
buf = (gchar *) &obex->rx_buf[obex->rx_data];
status = g_io_channel_read_chars(io, buf, toread, &rbytes, NULL);
if (status != G_IO_STATUS_NORMAL)
goto done;
obex->rx_data += rbytes;
} while (rbytes > 0 && obex->rx_data < obex->rx_pkt_len);
done:
g_obex_dump(G_OBEX_DEBUG_DATA, ">", obex->rx_buf, obex->rx_data);
return TRUE;
}
static gboolean
source_next_uint16 (SerialSource* source, guint16 *ptr)
{
guint16 x;
if (! source->source_read (source, (guint8*) &x, sizeof (x)))
return FALSE;
(*ptr) = g_ntohs (x);
return TRUE;
}
gboolean
fb_mqtt_message_read_u16(FbMqttMessage *msg, guint16 *value)
{
if (!fb_mqtt_message_read(msg, value, sizeof *value)) {
return FALSE;
}
if (value != NULL) {
*value = g_ntohs(*value);
}
return TRUE;
}
static gboolean read_packet(GObex *obex, GError **err)
{
GIOChannel *io = obex->io;
GError *read_err = NULL;
GIOStatus status;
gsize rbytes;
guint16 u16;
if (obex->rx_data > 0) {
g_set_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR,
"RX buffer not empty before reading packet");
goto fail;
}
status = g_io_channel_read_chars(io, (gchar *) obex->rx_buf,
obex->rx_mtu, &rbytes, &read_err);
if (status != G_IO_STATUS_NORMAL) {
g_set_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR,
"Unable to read data: %s", read_err->message);
g_error_free(read_err);
goto fail;
}
obex->rx_data += rbytes;
if (rbytes < 3) {
g_set_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR,
"Incomplete packet received");
goto fail;
}
memcpy(&u16, &obex->rx_buf[1], sizeof(u16));
obex->rx_pkt_len = g_ntohs(u16);
if (obex->rx_pkt_len != rbytes) {
g_set_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR,
"Data size doesn't match packet size (%zu != %u)",
rbytes, obex->rx_pkt_len);
return FALSE;
}
g_obex_dump(G_OBEX_DEBUG_DATA, ">", obex->rx_buf, obex->rx_data);
return TRUE;
fail:
g_obex_debug(G_OBEX_DEBUG_ERROR, "%s", (*err)->message);
return FALSE;
}
static void
profile_msg(MsnCmdProc *cmdproc, MsnMessage *msg)
{
MsnSession *session;
const char *value;
session = cmdproc->session;
if (strcmp(msg->remote_user, "Hotmail"))
{
pecan_warning ("unofficial message");
return;
}
if ((value = msn_message_get_attr(msg, "kv")) != NULL)
{
g_free(session->passport_info.kv);
session->passport_info.kv = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "sid")) != NULL)
{
g_free(session->passport_info.sid);
session->passport_info.sid = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "MSPAuth")) != NULL)
{
g_free(session->passport_info.mspauth);
session->passport_info.mspauth = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "ClientIP")) != NULL)
{
g_free(session->passport_info.client_ip);
session->passport_info.client_ip = g_strdup(value);
}
if ((value = msn_message_get_attr(msg, "ClientPort")) != NULL)
session->passport_info.client_port = g_ntohs(atoi(value));
if ((value = msn_message_get_attr(msg, "LoginTime")) != NULL)
session->passport_info.sl = atol(value);
if ((value = msn_message_get_attr(msg, "EmailEnabled")) != NULL)
session->passport_info.email_enabled = atol(value);
}
void sniff_loop_sll(u_char *data, const struct pcap_pkthdr *header, const u_char *packet) {
const struct sll_header *sll;
guint16 ethtype;
if (header->caplen < sizeof(struct sll_header)) {
debug_error("sniff_loop_ssl() %x %x\n", header->caplen, sizeof(struct sll_header));
return;
}
sll = (const struct sll_header *) packet;
ethtype = g_ntohs(sll->sll_protocol);
if (ethtype == ETHERTYPE_IP)
sniff_loop_ip((session_t *) data, header->caplen - sizeof(struct sll_header), packet + SIZE_SLL);
else
debug_error("sniff_loop_sll() ethtype [0x%x] != ETHERTYPE_IP, CUL\n", ethtype);
}
gint32
thrift_binary_protocol_read_i16 (ThriftProtocol *protocol, gint16 *value,
GError **error)
{
g_return_val_if_fail (THRIFT_IS_BINARY_PROTOCOL (protocol), -1);
gint32 ret;
gpointer b[2];
if ((ret =
thrift_transport_read (protocol->transport,
b, 2, error)) < 0)
{
return -1;
}
*value = *(gint16 *) b;
*value = g_ntohs (*value);
return ret;
}
static inline void sniff_loop_ether(u_char *data, const struct pcap_pkthdr *header, const u_char *packet) {
const struct ethhdr *ethernet;
guint16 ethtype; /* g_ntohs(ethernet->ether_type) */
if (header->caplen < sizeof(struct ethhdr)) {
debug_error("sniff_loop_ether() %x %x\n", header->caplen, sizeof(struct ethhdr));
return;
}
ethernet = (const struct ethhdr *) packet;
ethtype = g_ntohs(ethernet->ether_type);
if (ethtype == ETHERTYPE_ARP)
debug_function("sniff_loop_ether() ARP\n");
else if (ethtype == ETHERTYPE_IP)
sniff_loop_ip((session_t *) data, header->caplen - sizeof(struct ethhdr), packet + SIZE_ETHERNET);
else
debug_error("sniff_loop_ether() ethtype [0x%x] != ETHERTYPE_IP, CUL\n", ethtype);
}
gint32
thrift_binary_protocol_read_i16 (ThriftProtocol *protocol, gint16 *value,
GError **error)
{
gint32 ret;
union
{
gint8 byte_array[2];
gint16 int16;
} b;
g_return_val_if_fail (THRIFT_IS_BINARY_PROTOCOL (protocol), -1);
if ((ret =
thrift_transport_read_all (protocol->transport,
b.byte_array, 2, error)) < 0)
{
return -1;
}
*value = g_ntohs (b.int16);
return ret;
}
static void parse_connect_data(GObex *obex, GObexPacket *pkt)
{
const struct connect_data *data;
GObexHeader *connid;
guint16 u16;
size_t data_len;
data = g_obex_packet_get_data(pkt, &data_len);
if (data == NULL || data_len != sizeof(*data))
return;
memcpy(&u16, &data->mtu, sizeof(u16));
obex->tx_mtu = g_ntohs(u16);
if (obex->io_tx_mtu > 0 && obex->tx_mtu > obex->io_tx_mtu)
obex->tx_mtu = obex->io_tx_mtu;
obex->tx_buf = g_realloc(obex->tx_buf, obex->tx_mtu);
connid = g_obex_packet_get_header(pkt, G_OBEX_HDR_CONNECTION);
if (connid != NULL)
g_obex_header_get_uint32(connid, &obex->conn_id);
}
void
test_listen_started (void)
{
struct sockaddr_in *address_inet;
gchar actual_address_string[INET6_ADDRSTRLEN];
GError *error = NULL;
cut_trace(setup_client());
milter_client_run(client, &error);
gcut_assert_error(error);
cut_assert_not_null(actual_address);
address_inet = (struct sockaddr_in *)actual_address;
cut_assert_equal_uint(AF_INET, address_inet->sin_family);
cut_assert_equal_uint(9999, g_ntohs(address_inet->sin_port));
cut_assert_equal_string("127.0.0.1",
inet_ntop(AF_INET, &(address_inet->sin_addr),
actual_address_string,
sizeof(actual_address_string)));
cut_assert_equal_uint(sizeof(*address_inet), actual_address_size);
}
static connection_t *sniff_tcp_find_connection(const struct iphdr *ip, const struct tcphdr *tcp) {
#if 0
connection_t *d;
list_t l;
for (l = tcp_connections; l; l = l->next) {
connection_t *c = l->data;
if ( c->srcip.s_addr == ip->ip_src.s_addr && c->srcport == g_ntohs(tcp->th_sport) &&
c->dstip.s_addr == ip->ip_dst.s_addr && c->dstport == g_ntohs(tcp->th_dport))
return c;
if ( c->srcip.s_addr == ip->ip_dst.s_addr && c->srcport == g_ntohs(tcp->th_dport) &&
c->dstip.s_addr == ip->ip_src.s_addr && c->dstport == g_ntohs(tcp->th_sport))
return c;
}
d = xmalloc(sizeof(connection_t));
d->srcip = ip->ip_src;
d->srcport = g_ntohs(tcp->th_sport);
d->dstip = ip->ip_dst;
d->dstport = g_ntohs(tcp->th_dport);
list_add(&tcp_connections, d, 0);
#endif
static connection_t d;
d.srcip = ip->ip_src;
d.srcport = g_ntohs(tcp->th_sport);
d.dstip = ip->ip_dst;
d.dstport = g_ntohs(tcp->th_dport);
return &d;
}
gboolean
_gimp_wire_read_int16 (GIOChannel *channel,
guint16 *data,
gint count,
gpointer user_data)
{
g_return_val_if_fail (count >= 0, FALSE);
if (count > 0)
{
if (! _gimp_wire_read_int8 (channel,
(guint8 *) data, count * 2, user_data))
return FALSE;
while (count--)
{
*data = g_ntohs (*data);
data++;
}
}
return TRUE;
}
static inline void sniff_loop_udp(session_t *s, int len, const u_char *packet, const struct iphdr *ip) {
#define RIVCHAT_PACKET_LEN 328
static const char rivchat_magic[11] = { 'R', 'i', 'v', 'C', 'h', 'a', 't' /* here NULs */}; /* RivChat\0\0\0\0 */
/* XXX here, make some struct with known UDP services, and demangler-function */
const struct udphdr *udp;
connection_t *hdr;
const char *payload;
int size_payload;
/* XXX, it's enough? */
/* code copied from: http://gpsbots.com/tutorials/sniff_packets.php */
CHECK_LEN(sizeof(struct udphdr)); udp = (struct udphdr *) (packet);
hdr = sniff_udp_get(ip, udp);
payload = (char *) (packet + sizeof(struct udphdr));
size_payload = g_ntohs(udp->th_len)-sizeof(struct udphdr);
CHECK_LEN(sizeof(struct udphdr) + size_payload);
debug_error("sniff_loop_udp() IP/UDP %15s:%5d <==> %15s:%5d\n",
_inet_ntoa(hdr->srcip), /* src ip */
hdr->srcport, /* src port */
_inet_ntoa(hdr->dstip), /* dest ip */
hdr->dstport); /* dest port */
if (size_payload == RIVCHAT_PACKET_LEN && !memcmp(payload, rivchat_magic, sizeof(rivchat_magic))) { /* RIVCHAT [check based on header (11b), ~100% hit] */
sniff_rivchat(s, hdr, (rivchat_packet *) payload, size_payload);
} else if (hdr->srcport == 53 || hdr->dstport == 53) { /* DNS [check based on port, ~80% hit] */
sniff_dns(s, hdr, (DNS_HEADER *) payload, size_payload);
} else { /* OTHER PROTOs, feel free */
debug_error("NOT RIVCHAT/ NOT DNS:\n");
tcp_print_payload((u_char *) payload, size_payload);
}
}
GObexHeader *g_obex_header_decode(const void *data, gsize len,
GObexDataPolicy data_policy, gsize *parsed,
GError **err)
{
GObexHeader *header;
const guint8 *ptr = data;
guint16 hdr_len;
gsize str_len;
GError *conv_err = NULL;
if (len < 2) {
g_set_error(err, G_OBEX_ERROR, G_OBEX_ERROR_PARSE_ERROR,
"Too short header in packet");
g_obex_debug(G_OBEX_DEBUG_ERROR, "%s", (*err)->message);
return NULL;
}
header = g_new0(GObexHeader, 1);
ptr = get_bytes(&header->id, ptr, sizeof(header->id));
g_obex_debug(G_OBEX_DEBUG_HEADER, "header 0x%02x",
G_OBEX_HDR_ENC(header->id));
switch (G_OBEX_HDR_ENC(header->id)) {
case G_OBEX_HDR_ENC_UNICODE:
if (len < 3) {
g_set_error(err, G_OBEX_ERROR,
G_OBEX_ERROR_PARSE_ERROR,
"Not enough data for unicode header (0x%02x)",
header->id);
goto failed;
}
ptr = get_bytes(&hdr_len, ptr, sizeof(hdr_len));
hdr_len = g_ntohs(hdr_len);
if (hdr_len == 3) {
header->v.string = g_strdup("");
header->vlen = 0;
header->hlen = hdr_len;
*parsed = hdr_len;
break;
}
if (hdr_len > len || hdr_len < 5) {
g_set_error(err, G_OBEX_ERROR,
G_OBEX_ERROR_PARSE_ERROR,
"Invalid unicode header (0x%02x) length (%u)",
header->id, hdr_len);
goto failed;
}
header->v.string = g_convert((const char *) ptr, hdr_len - 5,
"UTF8", "UTF16BE",
NULL, &str_len, &conv_err);
if (header->v.string == NULL) {
g_set_error(err, G_OBEX_ERROR,
G_OBEX_ERROR_PARSE_ERROR,
"Unicode conversion failed: %s",
conv_err->message);
g_error_free(conv_err);
goto failed;
}
header->vlen = (gsize) str_len;
header->hlen = hdr_len;
*parsed = hdr_len;
break;
case G_OBEX_HDR_ENC_BYTES:
if (len < 3) {
g_set_error(err, G_OBEX_ERROR,
G_OBEX_ERROR_PARSE_ERROR,
"Too short byte array header");
goto failed;
}
ptr = get_bytes(&hdr_len, ptr, sizeof(hdr_len));
hdr_len = g_ntohs(hdr_len);
if (hdr_len > len) {
g_set_error(err, G_OBEX_ERROR,
G_OBEX_ERROR_PARSE_ERROR,
"Too long byte array header");
goto failed;
}
if (hdr_len < 3) {
g_set_error(err, G_OBEX_ERROR,
G_OBEX_ERROR_PARSE_ERROR,
"Too small byte array length");
goto failed;
}
header->vlen = hdr_len - 3;
header->hlen = hdr_len;
switch (data_policy) {
case G_OBEX_DATA_COPY:
header->v.data = g_memdup(ptr, header->vlen);
break;
case G_OBEX_DATA_REF:
header->extdata = TRUE;
header->v.extdata = ptr;
break;
default:
g_set_error(err, G_OBEX_ERROR,
G_OBEX_ERROR_INVALID_ARGS,
"Invalid data policy");
goto failed;
}
*parsed = hdr_len;
break;
case G_OBEX_HDR_ENC_UINT8:
header->vlen = 1;
header->hlen = 2;
header->v.u8 = *ptr;
*parsed = 2;
break;
case G_OBEX_HDR_ENC_UINT32:
if (len < 5) {
g_set_error(err, G_OBEX_ERROR,
G_OBEX_ERROR_PARSE_ERROR,
"Too short uint32 header");
goto failed;
}
header->vlen = 4;
header->hlen = 5;
ptr = get_bytes(&header->v.u32, ptr, sizeof(header->v.u32));
header->v.u32 = g_ntohl(header->v.u32);
*parsed = 5;
break;
default:
g_assert_not_reached();
}
return header;
failed:
if (*err)
g_obex_debug(G_OBEX_DEBUG_ERROR, "%s", (*err)->message);
g_obex_header_free(header);
return NULL;
}
static void
dissect_tpcp(tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
tpcpdu_t tpcph;
proto_tree *tpcp_tree = NULL, *field_tree = NULL;
proto_item *ti, *tf;
guint8 length = TPCP_VER_1_LENGTH;
col_set_str(pinfo->cinfo, COL_PROTOCOL, "TPCP");
col_clear(pinfo->cinfo, COL_INFO);
/* need to find out which version!! */
tpcph.version = tvb_get_guint8(tvb, 0);
/* as version 1 and 2 are so similar use the same structure, just don't use as much for version 1*/
if (tpcph.version == TPCP_VER_1) {
length = TPCP_VER_1_LENGTH;
tvb_memcpy(tvb, (guint8 *) &tpcph, 0, length);
} else if (tpcph.version == TPCP_VER_2){
length = TPCP_VER_2_LENGTH;
tvb_memcpy(tvb, (guint8 *) &tpcph, 0, length);
}
tpcph.id = g_ntohs(tpcph.id);
tpcph.flags = g_ntohs(tpcph.flags);
tpcph.cport = g_ntohs(tpcph.cport);
if (check_col(pinfo->cinfo, COL_INFO))
col_add_fstr(pinfo->cinfo, COL_INFO,"%s id %d CPort %s CIP %s SIP %s",
val_to_str(tpcph.type, type_vals, "Unknown"),
tpcph.id,
get_udp_port(tpcph.cport),
ip_to_str((guint8 *)&tpcph.caddr),
ip_to_str((guint8 *)&tpcph.saddr));
if (tree) {
ti = proto_tree_add_protocol_format(tree, proto_tpcp, tvb, 0, length,
"Alteon WebSystems - Transparent Proxy Cache Protocol");
tpcp_tree = proto_item_add_subtree(ti, ett_tpcp);
proto_tree_add_item(tpcp_tree, hf_tpcp_version, tvb, 0, 1, tpcph.version);
proto_tree_add_uint_format(tpcp_tree, hf_tpcp_type, tvb, 1, 1, tpcph.type,
"Type: %s (%d)",
val_to_str(tpcph.type, type_vals, "Unknown"), tpcph.type);
/* flags next , i'll do that when I can work out how to do it :-( */
tf = proto_tree_add_text(tpcp_tree, tvb, 2, 2, "Flags: 0x%04x",tpcph.flags);
field_tree = proto_item_add_subtree(tf, ett_tpcp_flags);
proto_tree_add_boolean(field_tree, hf_tpcp_flags_tcp, tvb, 2, 2, tpcph.flags);
proto_tree_add_boolean(field_tree, hf_tpcp_flags_redir, tvb, 2,2, tpcph.flags);
proto_tree_add_boolean(field_tree, hf_tpcp_flags_xon, tvb, 2, 2, tpcph.flags);
proto_tree_add_boolean(field_tree, hf_tpcp_flags_xoff, tvb, 2, 2, tpcph.flags);
proto_tree_add_uint(tpcp_tree, hf_tpcp_id, tvb, 4, 2, tpcph.id);
proto_tree_add_uint_format(tpcp_tree, hf_tpcp_cport, tvb, 6, 2, tpcph.cport,
"Client Source port: %s", get_udp_port(tpcph.cport));
proto_tree_add_ipv4(tpcp_tree, hf_tpcp_caddr, tvb, 8, 4, tpcph.caddr);
proto_tree_add_ipv4(tpcp_tree, hf_tpcp_saddr, tvb, 12, 4, tpcph.saddr);
if (tpcph.version == TPCP_VER_2) {
proto_tree_add_ipv4(tpcp_tree, hf_tpcp_vaddr, tvb, 16, 4, tpcph.vaddr);
proto_tree_add_ipv4(tpcp_tree, hf_tpcp_rasaddr, tvb, 20, 4, tpcph.rasaddr);
proto_tree_add_text(tpcp_tree, tvb, 24, 4, "Signature: %u", tpcph.signature);
}
}
}
uint16_t nghttp2_get_uint16(const uint8_t *data) {
uint16_t n;
memcpy(&n, data, sizeof(uint16_t));
return g_ntohs(n);
}
static gboolean
nettl_read_rec(wtap *wth, FILE_T fh, struct wtap_pkthdr *phdr, Buffer *buf,
int *err, gchar **err_info)
{
union wtap_pseudo_header *pseudo_header = &phdr->pseudo_header;
nettl_t *nettl = (nettl_t *)wth->priv;
gboolean fddihack = FALSE;
int bytes_read;
struct nettlrec_hdr rec_hdr;
guint16 hdr_len;
struct nettlrec_ns_ls_drv_eth_hdr drv_eth_hdr;
guint32 length, caplen;
int subsys;
guint padlen;
int datalen;
guint8 dummyc[16];
int bytes_to_read;
guint8 *pd;
guint8 dummy[3];
errno = WTAP_ERR_CANT_READ;
bytes_read = file_read(&rec_hdr.hdr_len, sizeof rec_hdr.hdr_len, fh);
if (bytes_read != sizeof rec_hdr.hdr_len) {
*err = file_error(fh, err_info);
if (*err == 0 && bytes_read != 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
hdr_len = g_ntohs(rec_hdr.hdr_len);
if (hdr_len < NETTL_REC_HDR_LEN) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("nettl: record header length %u too short",
hdr_len);
return FALSE;
}
bytes_read = file_read(&rec_hdr.subsys, NETTL_REC_HDR_LEN - 2, fh);
if (bytes_read != NETTL_REC_HDR_LEN - 2) {
*err = file_error(fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
subsys = g_ntohs(rec_hdr.subsys);
hdr_len -= NETTL_REC_HDR_LEN;
if (file_seek(fh, hdr_len, SEEK_CUR, err) == -1)
return FALSE;
if ( (pntoh32(&rec_hdr.kind) & NETTL_HDR_PDU_MASK) == 0 ) {
/* not actually a data packet (PDU) trace record */
phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_IP;
length = pntoh32(&rec_hdr.length);
caplen = pntoh32(&rec_hdr.caplen);
padlen = 0;
} else switch (subsys) {
case NETTL_SUBSYS_LAN100 :
case NETTL_SUBSYS_EISA100BT :
case NETTL_SUBSYS_BASE100 :
case NETTL_SUBSYS_GSC100BT :
case NETTL_SUBSYS_PCI100BT :
case NETTL_SUBSYS_SPP100BT :
case NETTL_SUBSYS_100VG :
case NETTL_SUBSYS_GELAN :
case NETTL_SUBSYS_BTLAN :
case NETTL_SUBSYS_INTL100 :
case NETTL_SUBSYS_IGELAN :
case NETTL_SUBSYS_IETHER :
case NETTL_SUBSYS_IXGBE :
case NETTL_SUBSYS_HSSN :
case NETTL_SUBSYS_IGSSN :
case NETTL_SUBSYS_ICXGBE :
case NETTL_SUBSYS_IEXGBE :
case NETTL_SUBSYS_IOCXGBE :
case NETTL_SUBSYS_IQXGBE :
case NETTL_SUBSYS_HPPB_FDDI :
case NETTL_SUBSYS_EISA_FDDI :
case NETTL_SUBSYS_PCI_FDDI :
case NETTL_SUBSYS_HSC_FDDI :
case NETTL_SUBSYS_TOKEN :
case NETTL_SUBSYS_PCI_TR :
case NETTL_SUBSYS_NS_LS_IP :
case NETTL_SUBSYS_NS_LS_LOOPBACK :
case NETTL_SUBSYS_NS_LS_TCP :
case NETTL_SUBSYS_NS_LS_UDP :
case NETTL_SUBSYS_HP_APAPORT :
case NETTL_SUBSYS_HP_APALACP :
case NETTL_SUBSYS_NS_LS_IPV6 :
case NETTL_SUBSYS_NS_LS_ICMPV6 :
case NETTL_SUBSYS_NS_LS_ICMP :
case NETTL_SUBSYS_NS_LS_TELNET :
case NETTL_SUBSYS_NS_LS_SCTP :
if( (subsys == NETTL_SUBSYS_NS_LS_IP)
|| (subsys == NETTL_SUBSYS_NS_LS_LOOPBACK)
|| (subsys == NETTL_SUBSYS_NS_LS_UDP)
|| (subsys == NETTL_SUBSYS_NS_LS_TCP)
|| (subsys == NETTL_SUBSYS_NS_LS_SCTP)
|| (subsys == NETTL_SUBSYS_NS_LS_IPV6)) {
phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_IP;
} else if (subsys == NETTL_SUBSYS_NS_LS_ICMP) {
phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_ICMP;
} else if (subsys == NETTL_SUBSYS_NS_LS_ICMPV6) {
phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_ICMPV6;
} else if (subsys == NETTL_SUBSYS_NS_LS_TELNET) {
phdr->pkt_encap = WTAP_ENCAP_NETTL_RAW_TELNET;
} else if( (subsys == NETTL_SUBSYS_HPPB_FDDI)
|| (subsys == NETTL_SUBSYS_EISA_FDDI)
|| (subsys == NETTL_SUBSYS_PCI_FDDI)
|| (subsys == NETTL_SUBSYS_HSC_FDDI) ) {
phdr->pkt_encap = WTAP_ENCAP_NETTL_FDDI;
} else if( (subsys == NETTL_SUBSYS_PCI_TR)
|| (subsys == NETTL_SUBSYS_TOKEN) ) {
phdr->pkt_encap = WTAP_ENCAP_NETTL_TOKEN_RING;
} else {
phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
}
length = pntoh32(&rec_hdr.length);
caplen = pntoh32(&rec_hdr.caplen);
/* HPPB FDDI has different inbound vs outbound trace records */
if (subsys == NETTL_SUBSYS_HPPB_FDDI) {
if (pntoh32(&rec_hdr.kind) == NETTL_HDR_PDUIN) {
/* inbound is very strange...
there are an extra 3 bytes after the DSAP and SSAP
for SNAP frames ???
*/
fddihack=TRUE;
padlen = 0;
} else {
/* outbound appears to have variable padding */
bytes_read = file_read(dummyc, 9, fh);
if (bytes_read != 9) {
*err = file_error(fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
/* padding is usually either a total 11 or 16 bytes??? */
padlen = (int)dummyc[8];
if (file_seek(fh, padlen, SEEK_CUR, err) == -1)
return FALSE;
padlen += 9;
}
} else if ( (subsys == NETTL_SUBSYS_PCI_FDDI)
|| (subsys == NETTL_SUBSYS_EISA_FDDI)
|| (subsys == NETTL_SUBSYS_HSC_FDDI) ) {
/* other flavor FDDI cards have an extra 3 bytes of padding */
if (file_seek(fh, 3, SEEK_CUR, err) == -1)
return FALSE;
padlen = 3;
} else if (subsys == NETTL_SUBSYS_NS_LS_LOOPBACK) {
/* LOOPBACK has an extra 26 bytes of padding */
if (file_seek(fh, 26, SEEK_CUR, err) == -1)
return FALSE;
padlen = 26;
} else if (subsys == NETTL_SUBSYS_NS_LS_SCTP) {
/*
* SCTP 8 byte header that we will ignore...
* 32 bit integer defines format
* 1 = Log
* 2 = ASCII
* 3 = Binary (PDUs should be Binary format)
* 32 bit integer defines type
* 1 = Inbound
* 2 = Outbound
*/
if (file_seek(fh, 8, SEEK_CUR, err) == -1)
return FALSE;
padlen = 8;
} else {
padlen = 0;
}
break;
case NETTL_SUBSYS_NS_LS_DRIVER :
/* XXX we dont know how to identify this as ethernet frames, so
we assumes everything is. We will crash and burn for anything else */
/* for encapsulated 100baseT we do this */
phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
bytes_read = file_read(&drv_eth_hdr, NS_LS_DRV_ETH_HDR_LEN, fh);
if (bytes_read != NS_LS_DRV_ETH_HDR_LEN) {
*err = file_error(fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
length = pntoh16(&drv_eth_hdr.length);
caplen = pntoh16(&drv_eth_hdr.caplen);
/*
* XXX - is there a length field that would give the length
* of this header, so that we don't have to check for
* nettl files from HP-UX 11?
*
* And what are the extra two bytes?
*/
if (nettl->is_hpux_11) {
if (file_seek(fh, 2, SEEK_CUR, err) == -1) return FALSE;
}
padlen = 0;
break;
case NETTL_SUBSYS_SX25L2:
case NETTL_SUBSYS_SX25L3:
/*
* XXX - is the 24-byte padding actually a header with
* packet lengths, time stamps, etc., just as is the case
* for NETTL_SUBSYS_NS_LS_DRIVER? It might be
*
* guint8 caplen[2];
* guint8 length[2];
* guint8 xxc[4];
* guint8 sec[4];
* guint8 usec[4];
* guint8 xxd[4];
*
* or something such as that - if it has 4 bytes before that
* (making it 24 bytes), it'd be like struct
* nettlrec_ns_ls_drv_eth_hdr but with 2 more bytes at the end.
*
* And is "from_dce" at xxa[0] in the nettlrec_hdr structure?
*/
phdr->pkt_encap = WTAP_ENCAP_NETTL_X25;
length = pntoh32(&rec_hdr.length);
caplen = pntoh32(&rec_hdr.caplen);
padlen = 24; /* sizeof (struct nettlrec_sx25l2_hdr) - NETTL_REC_HDR_LEN + 4 */
if (file_seek(fh, padlen, SEEK_CUR, err) == -1)
return FALSE;
break;
default:
/* We're going to assume it's ethernet if we don't recognize the
subsystem -- We'll probably spew junks and core if it isn't... */
wth->file_encap = WTAP_ENCAP_PER_PACKET;
phdr->pkt_encap = WTAP_ENCAP_NETTL_ETHERNET;
length = pntoh32(&rec_hdr.length);
caplen = pntoh32(&rec_hdr.caplen);
padlen = 0;
break;
}
if (length < padlen) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("nettl: packet length %u in record header too short, less than %u",
length, padlen);
return FALSE;
}
phdr->rec_type = REC_TYPE_PACKET;
phdr->presence_flags = WTAP_HAS_TS|WTAP_HAS_CAP_LEN;
phdr->len = length - padlen;
if (caplen < padlen) {
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("nettl: captured length %u in record header too short, less than %u",
caplen, padlen);
return FALSE;
}
datalen = caplen - padlen;
phdr->caplen = datalen;
phdr->ts.secs = pntoh32(&rec_hdr.sec);
phdr->ts.nsecs = pntoh32(&rec_hdr.usec) * 1000;
pseudo_header->nettl.subsys = subsys;
pseudo_header->nettl.devid = pntoh32(&rec_hdr.devid);
pseudo_header->nettl.kind = pntoh32(&rec_hdr.kind);
pseudo_header->nettl.pid = pntoh32(&rec_hdr.pid);
pseudo_header->nettl.uid = pntoh16(&rec_hdr.uid);
if (phdr->caplen > WTAP_MAX_PACKET_SIZE) {
/*
* Probably a corrupt capture file; don't blow up trying
* to allocate space for an immensely-large packet.
*/
*err = WTAP_ERR_BAD_FILE;
*err_info = g_strdup_printf("nettl: File has %u-byte packet, bigger than maximum of %u",
phdr->caplen, WTAP_MAX_PACKET_SIZE);
return FALSE;
}
/*
* Read the packet data.
*/
buffer_assure_space(buf, datalen);
pd = buffer_start_ptr(buf);
errno = WTAP_ERR_CANT_READ;
if (fddihack) {
/* read in FC, dest, src, DSAP and SSAP */
bytes_to_read = 15;
if (bytes_to_read > datalen)
bytes_to_read = datalen;
bytes_read = file_read(pd, bytes_to_read, fh);
if (bytes_read != bytes_to_read) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
datalen -= bytes_read;
if (datalen == 0) {
/* There's nothing past the FC, dest, src, DSAP and SSAP */
return TRUE;
}
if (pd[13] == 0xAA) {
/* it's SNAP, have to eat 3 bytes??? */
bytes_to_read = 3;
if (bytes_to_read > datalen)
bytes_to_read = datalen;
bytes_read = file_read(dummy, bytes_to_read, fh);
if (bytes_read != bytes_to_read) {
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
datalen -= bytes_read;
if (datalen == 0) {
/* There's nothing past the FC, dest, src, DSAP, SSAP, and 3 bytes to eat */
return TRUE;
}
}
bytes_read = file_read(pd + 15, datalen, fh);
} else
bytes_read = file_read(pd, datalen, fh);
if (bytes_read != datalen) {
*err = file_error(fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
return FALSE;
}
return TRUE;
}
int nettl_open(wtap *wth, int *err, gchar **err_info)
{
struct nettl_file_hdr file_hdr;
guint16 dummy[2];
int subsys;
int bytes_read;
nettl_t *nettl;
memset(&file_hdr, 0, sizeof(file_hdr));
/* Read in the string that should be at the start of a HP file */
errno = WTAP_ERR_CANT_READ;
bytes_read = file_read(file_hdr.magic, MAGIC_SIZE, wth->fh);
if (bytes_read != MAGIC_SIZE) {
*err = file_error(wth->fh, err_info);
if (*err != 0 && *err != WTAP_ERR_SHORT_READ)
return -1;
return 0;
}
if (memcmp(file_hdr.magic, nettl_magic_hpux9, MAGIC_SIZE) &&
memcmp(file_hdr.magic, nettl_magic_hpux10, MAGIC_SIZE)) {
return 0;
}
/* Read the rest of the file header */
bytes_read = file_read(file_hdr.file_name, FILE_HDR_SIZE - MAGIC_SIZE,
wth->fh);
if (bytes_read != FILE_HDR_SIZE - MAGIC_SIZE) {
*err = file_error(wth->fh, err_info);
if (*err == 0)
*err = WTAP_ERR_SHORT_READ;
return -1;
}
/* This is an nettl file */
wth->file_type_subtype = WTAP_FILE_TYPE_SUBTYPE_NETTL;
nettl = g_new(nettl_t,1);
wth->priv = (void *)nettl;
if (file_hdr.os_vers[2] == '1' && file_hdr.os_vers[3] == '1')
nettl->is_hpux_11 = TRUE;
else
nettl->is_hpux_11 = FALSE;
wth->subtype_read = nettl_read;
wth->subtype_seek_read = nettl_seek_read;
wth->snapshot_length = 0; /* not available */
/* read the first header to take a guess at the file encap */
bytes_read = file_read(dummy, 4, wth->fh);
if (bytes_read != 4) {
if (*err != 0) {
return -1;
}
if (bytes_read != 0) {
*err = WTAP_ERR_SHORT_READ;
return -1;
}
return 0;
}
subsys = g_ntohs(dummy[1]);
switch (subsys) {
case NETTL_SUBSYS_HPPB_FDDI :
case NETTL_SUBSYS_EISA_FDDI :
case NETTL_SUBSYS_PCI_FDDI :
case NETTL_SUBSYS_HSC_FDDI :
wth->file_encap = WTAP_ENCAP_NETTL_FDDI;
break;
case NETTL_SUBSYS_TOKEN :
case NETTL_SUBSYS_PCI_TR :
wth->file_encap = WTAP_ENCAP_NETTL_TOKEN_RING;
break;
case NETTL_SUBSYS_NS_LS_IP :
case NETTL_SUBSYS_NS_LS_LOOPBACK :
case NETTL_SUBSYS_NS_LS_TCP :
case NETTL_SUBSYS_NS_LS_UDP :
case NETTL_SUBSYS_NS_LS_IPV6 :
wth->file_encap = WTAP_ENCAP_NETTL_RAW_IP;
break;
case NETTL_SUBSYS_NS_LS_ICMP :
wth->file_encap = WTAP_ENCAP_NETTL_RAW_ICMP;
break;
case NETTL_SUBSYS_NS_LS_ICMPV6 :
wth->file_encap = WTAP_ENCAP_NETTL_RAW_ICMPV6;
break;
case NETTL_SUBSYS_NS_LS_TELNET :
wth->file_encap = WTAP_ENCAP_NETTL_RAW_TELNET;
break;
default:
/* If this assumption is bad, the read will catch it */
wth->file_encap = WTAP_ENCAP_NETTL_ETHERNET;
}
if (file_seek(wth->fh, FILE_HDR_SIZE, SEEK_SET, err) == -1) {
return -1;
}
wth->tsprecision = WTAP_FILE_TSPREC_USEC;
return 1;
}
static GstBuffer *
gst_rtp_dtmf_depay_process (GstBaseRTPDepayload * depayload, GstBuffer * buf)
{
GstRtpDTMFDepay *rtpdtmfdepay = NULL;
GstBuffer *outbuf = NULL;
gint payload_len;
guint8 *payload = NULL;
guint32 timestamp;
GstRTPDTMFPayload dtmf_payload;
gboolean marker;
GstStructure *structure = NULL;
GstMessage *dtmf_message = NULL;
rtpdtmfdepay = GST_RTP_DTMF_DEPAY (depayload);
if (!gst_rtp_buffer_validate (buf))
goto bad_packet;
payload_len = gst_rtp_buffer_get_payload_len (buf);
payload = gst_rtp_buffer_get_payload (buf);
if (payload_len != sizeof (GstRTPDTMFPayload))
goto bad_packet;
memcpy (&dtmf_payload, payload, sizeof (GstRTPDTMFPayload));
if (dtmf_payload.event > MAX_EVENT)
goto bad_packet;
marker = gst_rtp_buffer_get_marker (buf);
timestamp = gst_rtp_buffer_get_timestamp (buf);
dtmf_payload.duration = g_ntohs (dtmf_payload.duration);
/* clip to whole units of unit_time */
if (rtpdtmfdepay->unit_time) {
guint unit_time_clock =
(rtpdtmfdepay->unit_time * depayload->clock_rate) / 1000;
if (dtmf_payload.duration % unit_time_clock) {
/* Make sure we don't overflow the duration */
if (dtmf_payload.duration < G_MAXUINT16 - unit_time_clock)
dtmf_payload.duration += unit_time_clock -
(dtmf_payload.duration % unit_time_clock);
else
dtmf_payload.duration -= dtmf_payload.duration % unit_time_clock;
}
}
/* clip to max duration */
if (rtpdtmfdepay->max_duration) {
guint max_duration_clock =
(rtpdtmfdepay->max_duration * depayload->clock_rate) / 1000;
if (max_duration_clock < G_MAXUINT16 &&
dtmf_payload.duration > max_duration_clock)
dtmf_payload.duration = max_duration_clock;
}
GST_DEBUG_OBJECT (depayload, "Received new RTP DTMF packet : "
"marker=%d - timestamp=%u - event=%d - duration=%d",
marker, timestamp, dtmf_payload.event, dtmf_payload.duration);
GST_DEBUG_OBJECT (depayload,
"Previous information : timestamp=%u - duration=%d",
rtpdtmfdepay->previous_ts, rtpdtmfdepay->previous_duration);
/* First packet */
if (marker || rtpdtmfdepay->previous_ts != timestamp) {
rtpdtmfdepay->sample = 0;
rtpdtmfdepay->previous_ts = timestamp;
rtpdtmfdepay->previous_duration = dtmf_payload.duration;
rtpdtmfdepay->first_gst_ts = GST_BUFFER_TIMESTAMP (buf);
structure = gst_structure_new ("dtmf-event",
"number", G_TYPE_INT, dtmf_payload.event,
"volume", G_TYPE_INT, dtmf_payload.volume,
"type", G_TYPE_INT, 1, "method", G_TYPE_INT, 1, NULL);
if (structure) {
dtmf_message =
gst_message_new_element (GST_OBJECT (depayload), structure);
if (dtmf_message) {
if (!gst_element_post_message (GST_ELEMENT (depayload), dtmf_message)) {
GST_ERROR_OBJECT (depayload,
"Unable to send dtmf-event message to bus");
}
} else {
GST_ERROR_OBJECT (depayload, "Unable to create dtmf-event message");
}
} else {
GST_ERROR_OBJECT (depayload, "Unable to create dtmf-event structure");
}
} else {
guint16 duration = dtmf_payload.duration;
dtmf_payload.duration -= rtpdtmfdepay->previous_duration;
/* If late buffer, ignore */
if (duration > rtpdtmfdepay->previous_duration)
rtpdtmfdepay->previous_duration = duration;
}
GST_DEBUG_OBJECT (depayload, "new previous duration : %d - new duration : %d"
" - diff : %d - clock rate : %d - timestamp : %llu",
rtpdtmfdepay->previous_duration, dtmf_payload.duration,
(rtpdtmfdepay->previous_duration - dtmf_payload.duration),
depayload->clock_rate, GST_BUFFER_TIMESTAMP (buf));
/* If late or duplicate packet (like the redundant end packet). Ignore */
if (dtmf_payload.duration > 0) {
outbuf = gst_buffer_new ();
gst_dtmf_src_generate_tone (rtpdtmfdepay, dtmf_payload, outbuf);
GST_BUFFER_TIMESTAMP (outbuf) = rtpdtmfdepay->first_gst_ts +
(rtpdtmfdepay->previous_duration - dtmf_payload.duration) *
GST_SECOND / depayload->clock_rate;
GST_BUFFER_OFFSET (outbuf) =
(rtpdtmfdepay->previous_duration - dtmf_payload.duration) *
GST_SECOND / depayload->clock_rate;
GST_BUFFER_OFFSET_END (outbuf) = rtpdtmfdepay->previous_duration *
GST_SECOND / depayload->clock_rate;
GST_DEBUG_OBJECT (depayload, "timestamp : %llu - time %" GST_TIME_FORMAT,
GST_BUFFER_TIMESTAMP (buf), GST_TIME_ARGS (GST_BUFFER_TIMESTAMP (buf)));
}
return outbuf;
bad_packet:
GST_ELEMENT_WARNING (rtpdtmfdepay, STREAM, DECODE,
("Packet did not validate"), (NULL));
return NULL;
}
/**
* gst_rtp_buffer_list_validate:
* @list: the buffer list to validate
*
* Check if all RTP packets in the @list are valid using validate_data().
* Use this function to validate an list before using the other functions in
* this module.
*
* Returns: TRUE if @list consists only of valid RTP packets.
*
* Since: 0.10.24
*/
gboolean
gst_rtp_buffer_list_validate (GstBufferList * list)
{
guint16 prev_seqnum = 0;
GstBufferListIterator *it;
guint i = 0;
g_return_val_if_fail (GST_IS_BUFFER_LIST (list), FALSE);
it = gst_buffer_list_iterate (list);
g_return_val_if_fail (it != NULL, FALSE);
/* iterate through all the RTP packets in the list */
while (gst_buffer_list_iterator_next_group (it)) {
GstBuffer *rtpbuf;
GstBuffer *paybuf;
guint8 *packet_header;
guint8 *packet_payload;
guint payload_size;
guint packet_size;
/* each group should consists of 2 buffers: one containing the RTP header
* and the other one the payload, FIXME, relax the requirement of only one
* payload buffer. */
if (gst_buffer_list_iterator_n_buffers (it) != 2)
goto invalid_list;
/* get the RTP header */
rtpbuf = gst_buffer_list_iterator_next (it);
packet_header = GST_BUFFER_DATA (rtpbuf);
if (packet_header == NULL)
goto invalid_list;
/* get the payload */
paybuf = gst_buffer_list_iterator_next (it);
packet_payload = GST_BUFFER_DATA (paybuf);
if (packet_payload == NULL) {
goto invalid_list;
}
payload_size = GST_BUFFER_SIZE (paybuf);
if (payload_size == 0) {
goto invalid_list;
}
/* the size of the RTP packet within the current group */
packet_size = GST_BUFFER_SIZE (rtpbuf) + payload_size;
/* check the sequence number */
if (G_UNLIKELY (i == 0)) {
prev_seqnum = g_ntohs (GST_RTP_HEADER_SEQ (packet_header));
i++;
} else {
if (++prev_seqnum != g_ntohs (GST_RTP_HEADER_SEQ (packet_header)))
goto invalid_list;
}
/* validate packet */
if (!validate_data (packet_header, packet_size, packet_payload,
payload_size)) {
goto invalid_list;
}
}
gst_buffer_list_iterator_free (it);
return TRUE;
/* ERRORS */
invalid_list:
{
gst_buffer_list_iterator_free (it);
return FALSE;
}
}
/**
* gst_rtp_buffer_get_seq:
* @buffer: the buffer
*
* Get the sequence number of the RTP packet in @buffer.
*
* Returns: The sequence number in host order.
*/
guint16
gst_rtp_buffer_get_seq (GstBuffer * buffer)
{
return g_ntohs (GST_RTP_HEADER_SEQ (GST_BUFFER_DATA (buffer)));
}
/* classic wtap: open capture file. Return 1 on success, 0 on normal failure
* like malformed format, -1 on bad error like file system
*/
int
ipfix_open(wtap *wth, int *err, gchar **err_info)
{
gint i, n, records_for_ipfix_check = RECORDS_FOR_IPFIX_CHECK;
gchar *s;
guint16 checked_len = 0;
ipfix_message_header_t msg_hdr;
ipfix_set_header_t set_hdr;
ipfix_debug0("ipfix_open: opening file");
/* number of records to scan before deciding if this really is IPFIX */
if ((s = getenv("IPFIX_RECORDS_TO_CHECK")) != NULL) {
if ((n = atoi(s)) > 0 && n < 101) {
records_for_ipfix_check = n;
}
}
/*
* IPFIX is a little hard because there's no magic number; we look at
* the first few records and see if they look enough like IPFIX
* records.
*/
for (i = 0; i < records_for_ipfix_check; i++) {
/* read first message header to check version */
if (!ipfix_read_message_header(&msg_hdr, wth->fh, err, err_info)) {
ipfix_debug3("ipfix_open: couldn't read message header #%d with err code #%d (%s)",
i, *err, *err_info);
if (*err == WTAP_ERR_BAD_FILE) {
*err = 0; /* not actually an error in this case */
g_free(*err_info);
*err_info = NULL;
return 0;
}
if (*err != 0)
return -1; /* real failure */
/* else it's EOF */
if (i < 1) {
/* we haven't seen enough to prove this is a ipfix file */
return 0;
}
/* if we got here, it's EOF and we think it's an ipfix file */
break;
}
if (file_seek(wth->fh, IPFIX_MSG_HDR_SIZE, SEEK_CUR, err) == -1) {
ipfix_debug1("ipfix_open: failed seek to next message in file, %d bytes away",
msg_hdr.message_length);
return 0;
}
checked_len = IPFIX_MSG_HDR_SIZE;
/* check each Set in IPFIX Message for sanity */
while (checked_len < msg_hdr.message_length) {
wtap_file_read_expected_bytes(&set_hdr, IPFIX_SET_HDR_SIZE, wth->fh, err, err_info);
set_hdr.set_length = g_ntohs(set_hdr.set_length);
if ((set_hdr.set_length < IPFIX_SET_HDR_SIZE) ||
((set_hdr.set_length + checked_len) > msg_hdr.message_length)) {
ipfix_debug1("ipfix_open: found invalid set_length of %d",
set_hdr.set_length);
return 0;
}
if (file_seek(wth->fh, set_hdr.set_length - IPFIX_SET_HDR_SIZE,
SEEK_CUR, err) == -1)
{
ipfix_debug1("ipfix_open: failed seek to next set in file, %d bytes away",
set_hdr.set_length - IPFIX_SET_HDR_SIZE);
return 0;
}
checked_len += set_hdr.set_length;
}
}
/* all's good, this is a IPFIX file */
wth->file_encap = WTAP_ENCAP_RAW_IPFIX;
wth->snapshot_length = 0;
wth->tsprecision = WTAP_FILE_TSPREC_SEC;
wth->subtype_read = ipfix_read;
wth->subtype_seek_read = ipfix_seek_read;
wth->subtype_close = ipfix_close;
wth->file_type = WTAP_FILE_IPFIX;
/* go back to beginning of file */
if (file_seek (wth->fh, 0, SEEK_SET, err) != 0)
{
return -1;
}
return 1;
}
static void
dissect_fcfcs (tvbuff_t *tvb, packet_info *pinfo, proto_tree *tree)
{
/* Set up structures needed to add the protocol subtree and manage it */
int offset = 0;
proto_item *ti;
proto_tree *fcfcs_tree = NULL;
fc_ct_preamble cthdr;
gboolean isreq = 1;
conversation_t *conversation;
fcfcs_conv_data_t *cdata;
fcfcs_conv_key_t ckey, *req_key;
int opcode,
failed_opcode = 0;
/* Make entries in Protocol column and Info column on summary display */
col_set_str(pinfo->cinfo, COL_PROTOCOL, "FC-FCS");
if (tree) {
ti = proto_tree_add_protocol_format (tree, proto_fcfcs, tvb, 0,
tvb_reported_length (tvb),
"FCS");
fcfcs_tree = proto_item_add_subtree (ti, ett_fcfcs);
}
tvb_memcpy (tvb, (guint8 *)&cthdr, offset, FCCT_PRMBL_SIZE);
cthdr.revision = tvb_get_guint8 (tvb, offset);
cthdr.in_id = tvb_get_ntoh24 (tvb, offset+1);
cthdr.opcode = g_ntohs (cthdr.opcode);
opcode = tvb_get_ntohs (tvb, offset+8);
cthdr.maxres_size = g_ntohs (cthdr.maxres_size);
if ((opcode != FCCT_MSG_ACC) && (opcode != FCCT_MSG_RJT)) {
conversation = find_conversation (pinfo->fd->num, &pinfo->src, &pinfo->dst,
pinfo->ptype, pinfo->oxid,
pinfo->rxid, NO_PORT2);
if (!conversation) {
conversation = conversation_new (pinfo->fd->num, &pinfo->src, &pinfo->dst,
pinfo->ptype, pinfo->oxid,
pinfo->rxid, NO_PORT2);
}
ckey.conv_idx = conversation->index;
cdata = (fcfcs_conv_data_t *)g_hash_table_lookup (fcfcs_req_hash,
&ckey);
if (cdata) {
/* Since we never free the memory used by an exchange, this maybe a
* case of another request using the same exchange as a previous
* req.
*/
cdata->opcode = opcode;
}
else {
req_key = se_alloc (sizeof(fcfcs_conv_key_t));
req_key->conv_idx = conversation->index;
cdata = se_alloc (sizeof(fcfcs_conv_data_t));
cdata->opcode = opcode;
g_hash_table_insert (fcfcs_req_hash, req_key, cdata);
}
if (check_col (pinfo->cinfo, COL_INFO)) {
col_add_str (pinfo->cinfo, COL_INFO,
val_to_str (opcode, fc_fcs_opcode_abbrev_val, "0x%x"));
}
}
else {
/* Opcode is ACC or RJT */
conversation = find_conversation (pinfo->fd->num, &pinfo->src, &pinfo->dst,
pinfo->ptype, pinfo->oxid,
pinfo->rxid, NO_PORT2);
isreq = 0;
if (!conversation) {
if (tree && (opcode == FCCT_MSG_ACC)) {
if (check_col (pinfo->cinfo, COL_INFO)) {
col_add_str (pinfo->cinfo, COL_INFO,
val_to_str (opcode, fc_fcs_opcode_abbrev_val,
"0x%x"));
}
/* No record of what this accept is for. Can't decode */
proto_tree_add_text (fcfcs_tree, tvb, 0, tvb_length (tvb),
"No record of Exchg. Unable to decode MSG_ACC/RJT");
return;
}
}
else {
ckey.conv_idx = conversation->index;
cdata = (fcfcs_conv_data_t *)g_hash_table_lookup (fcfcs_req_hash,
&ckey);
if (cdata != NULL) {
if (opcode == FCCT_MSG_ACC)
opcode = cdata->opcode;
else
failed_opcode = cdata->opcode;
}
if (check_col (pinfo->cinfo, COL_INFO)) {
if (opcode != FCCT_MSG_RJT) {
col_add_fstr (pinfo->cinfo, COL_INFO, "MSG_ACC (%s)",
val_to_str (opcode, fc_fcs_opcode_abbrev_val,
"0x%x"));
}
else {
col_add_fstr (pinfo->cinfo, COL_INFO, "MSG_RJT (%s)",
val_to_str (failed_opcode,
fc_fcs_opcode_abbrev_val,
"0x%x"));
}
}
if (tree) {
if ((cdata == NULL) && (opcode != FCCT_MSG_RJT)) {
/* No record of what this accept is for. Can't decode */
proto_tree_add_text (fcfcs_tree, tvb, 0, tvb_length (tvb),
"No record of Exchg. Unable to decode MSG_ACC/RJT");
return;
}
}
}
}
if (tree) {
proto_tree_add_item (fcfcs_tree, hf_fcs_opcode, tvb, offset+8, 2, ENC_BIG_ENDIAN);
proto_tree_add_item (fcfcs_tree, hf_fcs_maxres_size, tvb, offset+10,
2, ENC_BIG_ENDIAN);
}
switch (opcode) {
case FCCT_MSG_RJT:
dissect_fcfcs_rjt (tvb, fcfcs_tree);
break;
case FCFCS_GIEL:
dissect_fcfcs_giel (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GIET:
dissect_fcfcs_giet (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GDID:
dissect_fcfcs_gdid (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GMID:
dissect_fcfcs_gmid (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GFN:
dissect_fcfcs_gfn (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GIELN:
dissect_fcfcs_gieln (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GMAL:
dissect_fcfcs_gmal (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GIEIL:
dissect_fcfcs_gieil (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GPL:
dissect_fcfcs_gpl (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GPT:
dissect_fcfcs_gpt (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GPPN:
dissect_fcfcs_gppn (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GAPNL:
dissect_fcfcs_gapnl (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GPS:
dissect_fcfcs_gps (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GPLNL:
dissect_fcfcs_gplnl (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GPLT:
dissect_fcfcs_gplt (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GPLML:
dissect_fcfcs_gplml (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GNPL:
dissect_fcfcs_gnpl (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GPNL:
dissect_fcfcs_gpnl (tvb, fcfcs_tree, isreq);
break;
case FCFCS_RIELN:
dissect_fcfcs_rieln (tvb, fcfcs_tree, isreq);
break;
case FCFCS_RPL:
dissect_fcfcs_rpl (tvb, fcfcs_tree, isreq);
break;
case FCFCS_RPLN:
dissect_fcfcs_rpln (tvb, fcfcs_tree, isreq);
break;
case FCFCS_RPLT:
dissect_fcfcs_rplt (tvb, fcfcs_tree, isreq);
break;
case FCFCS_RPLM:
dissect_fcfcs_rplm (tvb, fcfcs_tree, isreq);
break;
case FCFCS_DPL:
dissect_fcfcs_dpl (tvb, fcfcs_tree, isreq);
break;
case FCFCS_DPLN:
dissect_fcfcs_dpln (tvb, fcfcs_tree, isreq);
break;
case FCFCS_DPLML:
dissect_fcfcs_dplml (tvb, fcfcs_tree, isreq);
break;
case FCFCS_GCAP:
dissect_fcfcs_gcap (tvb, fcfcs_tree, isreq);
break;
default:
call_dissector (data_handle, tvb, pinfo, fcfcs_tree);
break;
}
}
static void _qq_s5_sendconnect(gpointer data, gint source)
{
unsigned char buf[512];
struct PHB *phb = data;
struct sockaddr_in sin, ctlsin;
int port;
socklen_t ctllen;
gaim_debug(GAIM_DEBUG_INFO, "s5_sendconnect", "remote host is %s:%d\n", phb->host, phb->port);
buf[0] = 0x05;
buf[1] = 0x03; /* udp relay */
buf[2] = 0x00; /* reserved */
buf[3] = 0x01; /* address type -- ipv4 */
memset(buf + 4, 0, 0x04);
ctllen = sizeof(ctlsin);
if (getsockname(source, (struct sockaddr *) &ctlsin, &ctllen) < 0) {
gaim_debug(GAIM_DEBUG_INFO, "QQ", "getsockname: %s\n", strerror(errno));
close(source);
g_free(phb->host);
g_free(phb);
return;
}
phb->udpsock = socket(PF_INET, SOCK_DGRAM, 0);
gaim_debug(GAIM_DEBUG_INFO, "s5_sendconnect", "UDP socket=%d\n", phb->udpsock);
if (phb->udpsock < 0) {
close(source);
g_free(phb->host);
g_free(phb);
return;
}
fcntl(phb->udpsock, F_SETFL, O_NONBLOCK);
port = g_ntohs(ctlsin.sin_port) + 1;
while (1) {
inet_aton("0.0.0.0", &(sin.sin_addr));
sin.sin_family = AF_INET;
sin.sin_port = g_htons(port);
if (bind(phb->udpsock, (struct sockaddr *) &sin, sizeof(sin)) < 0) {
port++;
if (port > 65500) {
close(source);
g_free(phb->host);
g_free(phb);
return;
}
} else
break;
}
memset(buf + 4, 0, 0x04);
memcpy(buf + 8, &(sin.sin_port), 0x02);
if (write(source, buf, 10) < 10) {
close(source);
gaim_debug(GAIM_DEBUG_INFO, "s5_sendconnect", "packet too small\n");
if (phb->account == NULL || gaim_account_get_connection(phb->account) != NULL) {
phb->func(phb->data, -1, _("Unable to connect"));
}
g_free(phb->host);
g_free(phb);
return;
}
phb->inpa = gaim_input_add(source, GAIM_INPUT_READ, _qq_s5_canread_again, phb);
}
void SCTPGraphDialog::drawNRSACKGraph()
{
tsn_t *sack;
GList *list=NULL, *tlist;
guint16 gap_start=0, gap_end=0, i, numberOf_gaps, numberOf_nr_gaps;
guint8 type;
guint32 tsnumber, j, min_tsn;
struct nr_sack_chunk_header *nr_sack_header;
struct gaps *nr_gap;
/* This holds the sum of gap acks and nr gap acks */
guint16 total_gaps = 0;
if (direction == 1) {
list = g_list_last(selected_assoc->sack1);
min_tsn = selected_assoc->min_tsn1;
} else {
list = g_list_last(selected_assoc->sack2);
min_tsn = selected_assoc->min_tsn2;
}
while (list) {
sack = (tsn_t*) (list->data);
tlist = g_list_first(sack->tsns);
while (tlist) {
type = ((struct chunk_header *)tlist->data)->type;
if (type == SCTP_NR_SACK_CHUNK_ID) {
gIsNRSackChunkPresent = 1;
nr_sack_header =(struct nr_sack_chunk_header *)tlist->data;
numberOf_nr_gaps=g_ntohs(nr_sack_header->nr_of_nr_gaps);
numberOf_gaps=g_ntohs(nr_sack_header->nr_of_gaps);
tsnumber = g_ntohl(nr_sack_header->cum_tsn_ack);
total_gaps = numberOf_gaps + numberOf_nr_gaps;
/* If the number of nr_gaps is greater than 0 */
if (total_gaps > 0) {
nr_gap = &nr_sack_header->gaps[0];
for (i = 0; i < total_gaps; i++) {
gap_start = g_ntohs(nr_gap->start);
gap_end = g_ntohs(nr_gap->end);
for (j = gap_start; j <= gap_end; j++) {
if (i >= numberOf_gaps) {
yn.append(j + tsnumber);
xn.append(sack->secs + sack->usecs/1000000.0);
fn.append(sack->frame_number);
} else {
yg.append(j + tsnumber);
xg.append(sack->secs + sack->usecs/1000000.0);
fg.append(sack->frame_number);
}
}
if (i < total_gaps-1)
nr_gap++;
}
if (tsnumber>=min_tsn) {
ys.append(j + tsnumber);
xs.append(sack->secs + sack->usecs/1000000.0);
fs.append(sack->frame_number);
}
}
}
tlist = g_list_next(tlist);
}
list = g_list_previous(list);
}
}
void SCTPGraphDialog::drawSACKGraph()
{
GList *listSACK = NULL, *tlist;
guint16 gap_start=0, gap_end=0, nr, dup_nr;
struct sack_chunk_header *sack_header;
struct gaps *gap;
tsn_t *tsn;
guint8 type;
guint32 tsnumber=0;
guint32 minTSN;
guint32 *dup_list;
int i, j;
if (direction == 1) {
minTSN = selected_assoc->min_tsn1;
listSACK = g_list_last(selected_assoc->sack1);
} else {
minTSN = selected_assoc->min_tsn2;
listSACK = g_list_last(selected_assoc->sack2);
}
while (listSACK) {
tsn = (tsn_t*) (listSACK->data);
tlist = g_list_first(tsn->tsns);
while (tlist) {
type = ((struct chunk_header *)tlist->data)->type;
if (type == SCTP_SACK_CHUNK_ID) {
gIsSackChunkPresent = 1;
sack_header =(struct sack_chunk_header *)tlist->data;
nr=g_ntohs(sack_header->nr_of_gaps);
tsnumber = g_ntohl(sack_header->cum_tsn_ack);
dup_nr=g_ntohs(sack_header->nr_of_dups);
if (nr>0) { // Gap Reports green
gap = &sack_header->gaps[0];
for(i=0;i<nr; i++) {
gap_start=g_ntohs(gap->start);
gap_end = g_ntohs(gap->end);
for (j=gap_start; j<=gap_end; j++) {
yg.append(j+tsnumber);
xg.append(tsn->secs + tsn->usecs/1000000.0);
fg.append(tsn->frame_number);
}
if (i < nr-1)
gap++;
}
}
if (tsnumber>=minTSN) { // CumTSNAck red
ys.append(tsnumber);
xs.append(tsn->secs + tsn->usecs/1000000.0);
fs.append(tsn->frame_number);
}
if (dup_nr > 0) { // Duplicates cyan
dup_list = &sack_header->a_rwnd + 2 + nr;
for (i = 0; i < dup_nr; i++) {
tsnumber = g_ntohl(dup_list[i]);
if (tsnumber >= minTSN) {
yd.append(tsnumber);
xd.append(tsn->secs + tsn->usecs/1000000.0);
fd.append(tsn->frame_number);
}
}
}
}
tlist = g_list_next(tlist);
}
listSACK = g_list_previous(listSACK);
}
QCPScatterStyle myScatter;
myScatter.setShape(QCPScatterStyle::ssCircle);
myScatter.setSize(3);
int graphcount = ui->sctpPlot->graphCount();
// create graph and assign data to it:
// Add SACK graph
if (xs.size() > 0) {
QCPGraph *gr = ui->sctpPlot->addGraph();
gr->setName(QString("SACK"));
myScatter.setPen(QPen(Qt::red));
myScatter.setBrush(Qt::red);
ui->sctpPlot->graph(graphcount)->setScatterStyle(myScatter);
ui->sctpPlot->graph(graphcount)->setLineStyle(QCPGraph::lsNone);
ui->sctpPlot->graph(graphcount)->setData(xs, ys);
typeStrings.insert(graphcount, QString(tr("CumTSNAck")));
graphcount++;
}
// Add Gap Acks
if (xg.size() > 0) {
QCPGraph *gr = ui->sctpPlot->addGraph();
gr->setName(QString("GAP"));
myScatter.setPen(QPen(Qt::green));
myScatter.setBrush(Qt::green);
ui->sctpPlot->graph(graphcount)->setScatterStyle(myScatter);
ui->sctpPlot->graph(graphcount)->setLineStyle(QCPGraph::lsNone);
ui->sctpPlot->graph(graphcount)->setData(xg, yg);
typeStrings.insert(graphcount, QString(tr("Gap Ack")));
graphcount++;
}
// Add NR Gap Acks
if (xn.size() > 0) {
QCPGraph *gr = ui->sctpPlot->addGraph();
gr->setName(QString("NR_GAP"));
myScatter.setPen(QPen(Qt::blue));
myScatter.setBrush(Qt::blue);
ui->sctpPlot->graph(graphcount)->setScatterStyle(myScatter);
ui->sctpPlot->graph(graphcount)->setLineStyle(QCPGraph::lsNone);
ui->sctpPlot->graph(graphcount)->setData(xn, yn);
typeStrings.insert(graphcount, QString(tr("NR Gap Ack")));
graphcount++;
}
// Add Duplicates
if (xd.size() > 0) {
QCPGraph *gr = ui->sctpPlot->addGraph();
gr->setName(QString("DUP"));
myScatter.setPen(QPen(Qt::cyan));
myScatter.setBrush(Qt::cyan);
ui->sctpPlot->graph(graphcount)->setScatterStyle(myScatter);
ui->sctpPlot->graph(graphcount)->setLineStyle(QCPGraph::lsNone);
ui->sctpPlot->graph(graphcount)->setData(xd, yd);
typeStrings.insert(graphcount, QString(tr("Duplicate Ack")));
}
}
static void gfire_server_query_read(gpointer p_data, gint p_fd, PurpleInputCondition p_condition)
{
static unsigned char buffer[65535];
gfire_server_query *query = (gfire_server_query*)p_data;
// Take the time now
GTimeVal gtv;
g_get_current_time(>v);
struct sockaddr_in addr;
guint addr_len = sizeof(addr);
guint len = recvfrom(p_fd, buffer, 65534, 0, (struct sockaddr*)&addr, &addr_len);
if(len <= 0)
return;
buffer[len] = 0;
// Get the responding server
GList *cur = query->cur_servers;
gfire_game_query_server *server = NULL;
while(cur)
{
gfire_game_query_server *scur = cur->data;
if(scur->server->ip == g_ntohl(addr.sin_addr.s_addr) && scur->server->query_port == g_ntohs(addr.sin_port))
{
server = scur;
break;
}
cur = g_list_next(cur);
}
if(!server)
{
purple_debug_warning("gfire", "Server Query: Got packet from unknown server\n");
return;
}
// Let the driver do its work
if(query->driver->parse(server->server, (gtv.tv_sec * 1000) + (gtv.tv_usec / 1000) - server->timeout,
query->full_query, buffer, len))
{
query->driver->query(server->server, query->full_query, p_fd);
// Reset timeout
server->timeout = (gtv.tv_sec * 1000) + (gtv.tv_usec / 1000);
}
else
{
// Server is done
query->callback(server->server, server->p_data, query->callback_data);
query->cur_servers = g_list_delete_link(query->cur_servers, cur);
g_free(server);
// Fill the list with new ones
while(!g_queue_is_empty(query->servers) && g_list_length(query->cur_servers) != GFSQ_MAX_QUERIES)
{
server = g_queue_pop_tail(query->servers);
query->cur_servers = g_list_append(query->cur_servers, server);
query->driver->query(gfire_game_server_apply_query_port(query, server->server), query->full_query, p_fd);
server->timeout = (gtv.tv_sec * 1000) + (gtv.tv_usec / 1000);
}
}
}
