hero123457/uhd
1
0
Fork 0
mirror of https://github.com/EttusResearch/uhd.git synced 2026-10-25 17:36:10 +00:00
Code Issues Projects Releases Wiki Activity

tools: Remove uhd_dump

Browse Source 
This tool was originally written to aid with X3x0 development, prior to
the development of current-day RFNoC. Basically, it's a poor-man's
version of Wireshark.

However, it implements an old version of the network protocol, which is
currently not in use. The tool is therefore obsolete, and our Wireshark
dissectors are a perfectly reasonable substitute. We therefore remove it
from UHD.
This commit is contained in:
Martin Braun 2025-03-14 09:49:07 +01:00 committed by Jörg Hofrichter
parent d370974bc1
commit b767b4e628
7 changed files with 4 additions and 1136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
CHANGELOG
View File

@ -17,6 +17,10 @@ Change Log for Releases
* Bug Fixes
- Calling `recv()` on an RX streamer connected to an RFNoC device with a
zero timeout value now correctly returns immediately.
* Removals / Deprecations
- Removed tools/uhd_dump. This tool is obsolete, the USRP X3x0 is not even
compatible with it any more. Dumps can be recorded and analyzed with wireshark
and the UHD dissectors in here.
## 004.008.000.000

5
tools/README.md
View File

@ -16,11 +16,6 @@ This is a packet dissector for [Wireshark](http://www.wireshark.org/). It allows
you to view the details of a Compressed HeaDeR (CHDR) formatted-packet in
Wireshark. The USRP™ B2xx and X3xx use the CHDR format.
`__uhd_dump/__`
This tool can be used with `tcpdump` to make sense of packet dumps from your
network-connected USRP™ device.
`__usrp_x3xx_fpga_jtag_programmer.sh__`
This tool is to be used with the USRP™ X300 and X310 devices. It allows you to

37
tools/uhd_dump/Makefile
View File

@ -1,37 +0,0 @@
# Copyright 2013-2014 Ettus Research LLC
#
# GNU Radio is free software; you can redistribute it and/or modify it under the
# terms of the GNU General Public License as published by the Free Software
# Foundation; either version 3, or (at your option) any later version.
#
# GNU Radio is distributed in the hope that it will be useful, but WITHOUT ANY
# WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR
# A PARTICULAR PURPOSE. See the GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License along with
# GNU Radio; see the file COPYING. If not, write to the Free Software
# Foundation, Inc., 51 Franklin Street, Boston, MA 02110-1301, USA.
INCLUDES = usrp3_regs.h uhd_dump.h
BINARIES = chdr_log
OBJECTS = uhd_dump.o
CFLAGS = -g -O0 -Wall
LIBS = -lpcap -lm
CC = cc
.PHONY: all
all: $(BINARIES)
chdr_log: uhd_dump.o chdr_log.o $(INCLUDES)
$(CC) $(CFLAGS) -o $@ uhd_dump.o chdr_log.o $(LIBS) $(LDFLAGS)
clean:
rm $(BINARIES) $(BINARIES:%=%.o) $(OBJECTS)

229
tools/uhd_dump/chdr_log.c
View File

@ -1,229 +0,0 @@
//
// Copyright 2013-2014 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
#include <stdio.h>
#include <stdlib.h>
#include <pcap.h>
#include <netinet/in.h>
#include <time.h>
#include <unistd.h>
#include <string.h>
#include "uhd_dump.h"
//#define DEBUG 1
void usage()
{
fprintf(stderr,"Usage: chdr_dump [-h host_ip] filename.pcap\n");
exit(2);
}
int main(int argc, char *argv[])
{
struct pbuf_info *packet_buffer; // Store all packets of interest here
struct in_addr host_addr; // Apparent Host IP addr in this capture
struct in_addr usrp_addr; // Apparent USRP IP addr in this capture
struct timeval *origin_ts; // Timestamp of first packet in file.
long long origin_ts_in_us;
int direction; // Flag to show direction of packet flow. 0=H->U, 1=U->H.
int packet_count[2]; // Number of packets that match filter
double size_average[2]; // Average size of packets Host to USRP
int size_histogram[90][2]; // Array captures histogram of packet sizes Host to USRP in 100 byte bins
int x; // Local integer scratch variables
char *conversion_error[1];
int c;
char buffer[26]; // Buffer to format GMT time stamp strings for output
double time_since_start; // Time elapsed in seconds since start
const struct ip_header *ip_header;
u32 *dump_header;
host_addr.s_addr = 0x0;
//usrp_addr.s_addr = 0x0;
while ((c = getopt(argc, argv, "h:u:")) != -1) {
switch(c) {
case 'h':
// Explicit IP address for host on command line
if (*optarg == '\0')
usage();
host_addr.s_addr = strtol(strtok(optarg,"."),conversion_error,10) ;
if (**conversion_error != '\0')
usage();
host_addr.s_addr = host_addr.s_addr | strtol(strtok(NULL,"."),conversion_error,10) << 8;
if (**conversion_error != '\0')
usage();
host_addr.s_addr = host_addr.s_addr | strtol(strtok(NULL,"."),conversion_error,10) << 16;
if (**conversion_error != '\0')
usage();
host_addr.s_addr = host_addr.s_addr | strtol(strtok(NULL,"\0"),conversion_error,10) << 24;
if (**conversion_error != '\0')
usage();
break;
case 'u':
// Explicit IP address for USRP on command line
if (*optarg == '\0')
usage();
usrp_addr.s_addr = strtol(strtok(optarg,"."),conversion_error,10) ;
if (**conversion_error != '\0')
usage();
usrp_addr.s_addr = usrp_addr.s_addr | strtol(strtok(NULL,"."),conversion_error,10) << 8;
if (**conversion_error != '\0')
usage();
usrp_addr.s_addr = usrp_addr.s_addr | strtol(strtok(NULL,"."),conversion_error,10) << 16;
if (**conversion_error != '\0')
usage();
usrp_addr.s_addr = usrp_addr.s_addr | strtol(strtok(NULL,"\0"),conversion_error,10) << 24;
if (**conversion_error != '\0')
usage();
break;
case'?':
default:
usage();
}
}
argc -= (optind - 1);
argv += (optind -1);
// Just a mandatory pcap filename for now, better parser and options later.
if (argc != 2) {
usage();
}
// Init packet buffer
packet_buffer = malloc(sizeof(struct pbuf_info));
// Init origin timestamp
origin_ts = malloc(sizeof(struct timeval));
// Go read matching packets from capture file into memory
get_udp_port_from_file(CHDR_PORT,argv[1],packet_buffer,origin_ts);
// Extract origin tome of first packet and convert to uS.
origin_ts_in_us = origin_ts->tv_sec * 1000000 + origin_ts->tv_usec;
// Count number of packets in capture
packet_buffer->current = packet_buffer->start;
x = 0;
while (packet_buffer->current != NULL) {
x++;
packet_buffer->current = packet_buffer->current->next;
}
fprintf(stdout,"\n===================================================================\n");
fprintf(stdout,"\n Total matching packet count in capture file: %d\n",x);
fprintf(stdout,"\n===================================================================\n\n");
// If no packets were CHDR then just exit now
if (x == 0) {
exit(0);
}
// Determine host and USRP IP addresses so that we can classify direction of packet flow later.
if (host_addr.s_addr == 0x0)
get_connection_endpoints(packet_buffer,&host_addr,&usrp_addr);
// Count packets in list.
// Build histogram of packet sizes
// Build histogram of Stream ID's
packet_buffer->current = packet_buffer->start;
for (x=0;x<90;x+=1)
size_histogram[x][H2U] = size_histogram[x][U2H] = 0;
size_average[H2U] = size_average[U2H] = 0;
packet_count[H2U] = packet_count[U2H] = 0;
while (packet_buffer->current != NULL) {
// Overlay IP header on packet payload
ip_header = (struct ip_header *)(packet_buffer->current->payload+ETH_SIZE);
// Identify packet direction
if (ip_header->ip_src.s_addr == host_addr.s_addr)
direction = H2U;
else
direction = U2H;
packet_count[direction]++;
size_average[direction]+=(double)packet_buffer->current->size;
if ((x=packet_buffer->current->size) > 9000)
fprintf(stderr,"Current packet size = %d at absolute time %s, relative time %f, exceeds MTU! Skip counting.",
x,format_gmt(&packet_buffer->current->ts,buffer),(relative_time(&packet_buffer->current->ts,origin_ts)));
else
size_histogram[x/100][direction]++;
packet_buffer->current = packet_buffer->current->next;
}
fprintf(stdout,"\n===================================================================\n");
fprintf(stdout,"\n Average packet size Host -> USRP: %d\n",(int)(size_average[H2U]/packet_count[H2U]));
fprintf(stdout,"\n Average packet size USRP -> Host: %d\n",(int)(size_average[U2H]/packet_count[U2H]));
fprintf(stdout,"\n===================================================================\n\n");
//
// Now produce packet by packet log
//
packet_buffer->current = packet_buffer->start;
x = 0;
while (packet_buffer->current != NULL) {
x++;
// Calculate time offset of this packet from start
time_since_start = ((double) packet_buffer->current->ts.tv_sec * 1000000 + packet_buffer->current->ts.tv_usec - origin_ts_in_us)/1000000;
dump_header = (u32 *) (packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
/* fprintf(stdout,"DUMP: %08x %08x %08x %08x %08x %08x\n", */
/* swapint((int) *(dump_header)), */
/* swapint((int) *(dump_header+1)), */
/* swapint((int) *(dump_header+2)), */
/* swapint((int) *(dump_header+3)), */
/* swapint((int) *(dump_header+4)), */
/* swapint((int) *(dump_header+5))); */
// Extract the device portion of the SID to see which packet flow this belongs in
fprintf(stdout,"%8d %f \t",x,time_since_start);
print_direction(packet_buffer,&host_addr,&usrp_addr);
fprintf(stdout,"\t");
print_size(packet_buffer);
fprintf(stdout,"\t");
print_sid(packet_buffer);
fprintf(stdout,"\t");
print_vita_header(packet_buffer,&host_addr);
fprintf(stdout,"\n");
packet_buffer->current = packet_buffer->current->next;
}
// Normal Exit
return(0);
}

547
tools/uhd_dump/uhd_dump.c
View File

@ -1,547 +0,0 @@
//
// Copyright 2013-2014 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
#include <stdio.h>
#include <stdlib.h>
#include <pcap.h>
#include <netinet/in.h>
#include <time.h>
#include <string.h>
#include "uhd_dump.h"
#include "usrp3_regs.h"
// Swap endianness of 64bits
unsigned long swaplong (unsigned long nLongNumber)
{
union u {unsigned long vi; unsigned char c[sizeof(unsigned long)];};
union v {unsigned long ni; unsigned char d[sizeof(unsigned long)];};
union u un;
union v vn;
un.vi = nLongNumber;
vn.d[0]=un.c[7];
vn.d[1]=un.c[6];
vn.d[2]=un.c[5];
vn.d[3]=un.c[4];
vn.d[4]=un.c[3];
vn.d[5]=un.c[2];
vn.d[6]=un.c[1];
vn.d[7]=un.c[0];
return (vn.ni);
}
// Swap endianness of 32bits
unsigned int swapint (unsigned int nIntNumber)
{
union u {unsigned int vi; unsigned char c[sizeof(unsigned long)];};
union v {unsigned int ni; unsigned char d[sizeof(unsigned long)];};
union u un;
union v vn;
un.vi = nIntNumber;
vn.d[0]=un.c[3];
vn.d[1]=un.c[2];
vn.d[2]=un.c[1];
vn.d[3]=un.c[0];
return (vn.ni);
}
// Swap Endianness of 16bits
unsigned short swapshort (unsigned short nShortNumber)
{
union u {unsigned short vi; unsigned char c[sizeof(unsigned short)];};
union v {unsigned short ni; unsigned char d[sizeof(unsigned short)];};
union u un;
union v vn;
un.vi = nShortNumber;
vn.d[0]=un.c[1];
vn.d[1]=un.c[0];
return (vn.ni);
}
// Format time from pcap as ascii style.
char *format_gmt(const struct timeval *ts, char *buffer)
{
time_t seconds;
struct tm gmt;
seconds = ts->tv_sec;
if ((gmtime_r(&seconds, &gmt)) == NULL) {
fprintf(stderr, "Fatal time format conversion error.\n");
exit(2);
}
sprintf(buffer,
"%04i-%02i-%02iT%02i:%02i:%02i,%03iZ",
gmt.tm_year + 1900, gmt.tm_mon + 1, gmt.tm_mday,
gmt.tm_hour, gmt.tm_min, gmt.tm_sec, (int) (ts->tv_usec / 1000));
return (buffer);
}
// Takes 2 timeval absolute timevalues, and returns a double value thats the relative time
// difference normalized to seconds.
double relative_time(struct timeval *event_ts, struct timeval *origin_ts)
{
struct timeval z;
double x;
timersub(event_ts,origin_ts,&z);
x = (double)z.tv_sec + (double)z.tv_usec/1000000;
return x;
}
// Convert timeval to double, normalized to seconds.
double timeval2double(struct timeval *event_ts)
{
double x;
x = (double)event_ts->tv_sec + (double)event_ts->tv_usec/1000000;
return x;
}
void get_packet(struct pbuf_info *packet_buffer , const struct pcap_pkthdr *header, const u_char *packet)
{
// Get size of new packet
packet_buffer->current->size = header->caplen;
packet_buffer->current->orig_size = header->len;
// Allocate memory for packet
packet_buffer->current->payload = (char *)malloc((size_t)packet_buffer->current->size);
// Copy Packet into buffer
memcpy(packet_buffer->current->payload,packet,packet_buffer->current->size);
packet_buffer->current->ts = header->ts;
// Allocate memory for next pbuf in chain, init it and shift list.
packet_buffer->current->next = malloc(sizeof (struct pbuf));
packet_buffer->current->next->last = packet_buffer->current;
packet_buffer->current = packet_buffer->current->next;
}
// This grabs the (absolute) time stamp of the first packet in the cature file, which can be used to
// derive times relative to the start of the capture file for cross correlation with interactive work
// in Wireshark
void get_start_time(struct timeval *ts , const struct pcap_pkthdr *header, const u_char *packet)
{
*ts = header->ts;
}
void get_udp_port_from_file(const u16 udp_port, const char *filename, struct pbuf_info *packet_buffer, struct timeval *ts)
{
pcap_t *handle; // Session handle
char errbuf[PCAP_ERRBUF_SIZE]; // Error string
char filter_exp[256]; // The ascii filter expression
struct bpf_program filter; // The compiled filter
// Open PCAP file for read capture time stamp of first packet
if ((handle = pcap_open_offline(filename,errbuf)) == NULL) {
fprintf(stderr,"Can't open pcap file for reading: %s\n",errbuf);
exit(2);
}
// Parse PCAP file with no filter to grab the time stamp of the first captured packet, which becomes the time origin
// local to the capture file.
if (pcap_dispatch(handle, 1, (pcap_handler) get_start_time, (u_char *)ts) == -1) {
fprintf(stderr, "Error parsing PCAP file: %s\n", pcap_geterr(handle));
exit(2);
}
// Close file again because no way to rewind file descriptor.
pcap_close(handle);
// Open PCAP file for read.
if ((handle = pcap_open_offline(filename,errbuf)) == NULL) {
fprintf(stderr,"Can't open pcap file for reading: %s\n",errbuf);
exit(2);
}
// Build ASCII filter expression from UDP port
sprintf(filter_exp,"udp port %d",udp_port);
printf("\nBPF filter is udp port %d\n",udp_port);
// Compile filter string to BPF
if (pcap_compile(handle, &filter, filter_exp, 0, 0) == -1) {
fprintf(stderr, "Couldn't parse filter %s: %s\n", filter_exp, pcap_geterr(handle));
exit(2);
}
// Apply filter
if (pcap_setfilter(handle, &filter) == -1) {
fprintf(stderr, "Couldn't install filter %s: %s\n", filter_exp, pcap_geterr(handle));
exit(2);
}
// Allocate and initialize packet buffer linked list
packet_buffer->start = packet_buffer->current = malloc(sizeof (struct pbuf));
packet_buffer->start->last = NULL;
// Parse PCAP file using filter, collect all interesting packets.
if (pcap_dispatch(handle, -1, (pcap_handler) get_packet, (u_char *)packet_buffer) == -1) {
fprintf(stderr, "Error parsing PCAP file: %s\n", pcap_geterr(handle));
exit(2);
}
// If no packets matched in the capture then linked list should be completely empty.
if ( packet_buffer->start == packet_buffer->current) {
free(packet_buffer->current);
packet_buffer->start = packet_buffer->current = NULL;
} else {
// Note the last used buffer in the list. Removed allocated but unused buffer from list and free
packet_buffer->end = packet_buffer->current->last;
packet_buffer->end->next = NULL;
free(packet_buffer->current);
}
}
//
// Read a pcap file into memory.
//
void get_everything_from_file(const char *filename, struct pbuf_info *packet_buffer, struct timeval *ts)
{
pcap_t *handle; // Session handle
char errbuf[PCAP_ERRBUF_SIZE]; // Error string
// Open PCAP file for read capture time stamp of first packet
if ((handle = pcap_open_offline(filename,errbuf)) == NULL) {
fprintf(stderr,"Can't open pcap file for reading: %s\n",errbuf);
exit(2);
}
// Parse PCAP file with no filter to grab the time stamp of the first captured packet, which becomes the time origin
// local to the capture file.
if (pcap_dispatch(handle, 1, (pcap_handler) get_start_time, (u_char *)ts) == -1) {
fprintf(stderr, "Error parsing PCAP file: %s\n", pcap_geterr(handle));
exit(2);
}
// Close file again because no way to rewind file descriptor.
pcap_close(handle);
// Open PCAP file for read
if ((handle = pcap_open_offline(filename,errbuf)) == NULL) {
fprintf(stderr,"Can't open pcap file for reading: %s\n",errbuf);
exit(2);
}
// Allocate and initialize packet buffer linked list
packet_buffer->start = packet_buffer->current = malloc(sizeof (struct pbuf));
packet_buffer->start->last = NULL;
// Parse PCAP file using filter, collect all interesting packets.
if (pcap_dispatch(handle, -1, (pcap_handler) get_packet, (u_char *)packet_buffer) == -1) {
fprintf(stderr, "Error parsing PCAP file: %s\n", pcap_geterr(handle));
exit(2);
}
// If no packets matched in the capture then linked list should be completely empty.
if ( packet_buffer->start == packet_buffer->current) {
free(packet_buffer->current);
packet_buffer->start = packet_buffer->current = NULL;
} else {
// Note the last used buffer in the list. Removed allocated but unused buffer from list and free
packet_buffer->end = packet_buffer->current->last;
packet_buffer->end->next = NULL;
free(packet_buffer->current);
}
}
// Debug
void print_raw(const struct pbuf_info *packet_buffer, const int count)
{
const u8 *raw;
int x;
raw = (u8 *) packet_buffer;
fprintf(stdout," ");
for (x = 0; x<count; x++)
fprintf(stdout,"%02x ",*(raw+x));
}
// Print to STDOUT the direction of this packet flow
void print_direction(const struct pbuf_info *packet_buffer, const struct in_addr *host_addr, const struct in_addr *usrp_addr)
{
const struct ip_header *ip_header;
// Overlay IP header on packet payload
ip_header = (struct ip_header *)(packet_buffer->current->payload+ETH_SIZE);
if ((host_addr->s_addr == ip_header->ip_src.s_addr) && (usrp_addr->s_addr == ip_header->ip_dst.s_addr))
fprintf(stdout,"Host->USRP");
else if ((host_addr->s_addr == ip_header->ip_dst.s_addr) && (usrp_addr->s_addr == ip_header->ip_src.s_addr))
fprintf(stdout,"USRP->Host");
else
fprintf(stdout,"UNKNOWN");
}
// Print to STDOUT the CHDR size in bytes
void print_size(const struct pbuf_info *packet_buffer)
{
const struct chdr_header *chdr_header;
// Overlay CHDR header on packet payload
chdr_header = (struct chdr_header *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
fprintf(stdout,"Size: %04d ",(swapint(chdr_header->chdr_type) & SIZE));
}
// Print to STDOUT the CHDR SID decode
void print_sid(const struct pbuf_info *packet_buffer)
{
const struct chdr_header *chdr_header;
const struct chdr_sid *chdr_sid;
// Overlay CHDR header on packet payload
chdr_header = (struct chdr_header *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
// Overlay CHDR SID definition on CHDR SID.
chdr_sid = (struct chdr_sid *)&(chdr_header->chdr_sid);
fprintf(stdout,"%02x.%02x->%02x.%02x",chdr_sid->src_device,chdr_sid->src_endpoint,chdr_sid->dst_device,chdr_sid->dst_endpoint);
}
// Print to STDOUT a decoded tx response packet payload.
void print_tx_response(const struct tx_response *tx_response)
{
switch(swapint(tx_response->error_code))
{
case TX_ACK: fprintf(stdout,"ACK "); break;
case TX_EOB: fprintf(stdout,"EOB "); break;
case TX_UNDERRUN: fprintf(stdout,"Underrun "); break;
case TX_SEQ_ERROR: fprintf(stdout,"Sequence Error "); break;
case TX_TIME_ERROR: fprintf(stdout,"Time Error "); break;
case TX_MIDBURST_SEQ_ERROR: fprintf(stdout,"Mid-Burst Seq Errror "); break;
default: fprintf(stdout,"Unknown Error ");
}
fprintf(stdout,"for SeqID = %03x ",swapint(tx_response->seq_id)&0xFFF);
}
// Returns Name of a register from it's address
char *reg_addr_to_name(const u32 addr)
{
int x;
x = 0;
while((reg_list[x].addr != addr) && (reg_list[x].addr != 999))
x++;
return(reg_list[x].name);
}
// Print to STDOUT decode of CHDR header including time if present.
void print_vita_header(const struct pbuf_info *packet_buffer, const struct in_addr *host_addr)
{
const struct ip_header *ip_header;
const struct chdr_header *chdr_header;
const struct chdr_sid *chdr_sid;
const struct radio_ctrl_payload *radio_ctrl_payload;
const struct radio_response *radio_response;
const struct tx_response *tx_response;
const struct src_flow_ctrl *src_flow_ctrl;
const struct vita_time *vita_time;
int direction;
u8 endpoint;
int has_time;
// Overlay IP header on packet payload
ip_header = (struct ip_header *)(packet_buffer->current->payload+ETH_SIZE);
// Overlay CHDR header on packet payload
chdr_header = (struct chdr_header *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
// Overlay CHDR SID definition on CHDR SID.
chdr_sid = (struct chdr_sid *)&(chdr_header->chdr_sid);
// Identify packet direction
if (ip_header->ip_src.s_addr == host_addr->s_addr)
direction = H2U;
else
direction = U2H;
// Decode packet type
if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) == EXT_CONTEXT) fprintf(stdout,"Context Ext ");
else fprintf(stdout,"IF Data ");
// Determine USRP Sink/Src Endpoint
if (direction==H2U)
endpoint = (chdr_sid->dst_endpoint) & 0x3;
else if (direction==U2H)
endpoint = (chdr_sid->src_endpoint) & 0x3;
// Look for CHDR EOB flags.
if ((swapint(chdr_header->chdr_type) & EOB) == EOB) fprintf(stdout,"EOB ");
else fprintf(stdout," ");
// Is there embeded VITA time?
if ((swapint(chdr_header->chdr_type) & HAS_TIME) == HAS_TIME) {
vita_time = (struct vita_time *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE);
fprintf(stdout,"Time=%016lx ",swaplong(vita_time->time));
has_time = 1;
} else {
fprintf(stdout," ");
has_time = 0;
}
fprintf(stdout,"SeqID=%03x ",(swapint(chdr_header->chdr_type)>>16)&0xFFF);
// Print Payload
if (endpoint == RADIO)
{
if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) != EXT_CONTEXT)
{
if (direction == H2U)
{
fprintf(stdout,"TX IF Data ");
}
else
// U2H
{
fprintf(stdout,"RX IF Data ");
}
}
else if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) == EXT_CONTEXT)
{
if (direction == H2U)
{
// BAD PACKET
}
else
// U2H
{
// TX Response packet.
tx_response = (struct tx_response *) (packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE+(has_time?VITA_TIME_SIZE:0));
print_tx_response(tx_response);
}
}
}
else if (endpoint == RADIO_CTRL)
{
fprintf(stdout,"\t\t\t");
if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) != EXT_CONTEXT)
{
// BAD PACKET
}
else if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) == EXT_CONTEXT)
{
if (direction == H2U)
{
radio_ctrl_payload = (struct radio_ctrl_payload *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE+(VITA_TIME_SIZE*has_time));
fprintf(stdout,"Radio Ctrl %s(0x%02x)=0x%08x",reg_addr_to_name(swapint(radio_ctrl_payload->addr)),(u8)swapint(radio_ctrl_payload->addr),swapint(radio_ctrl_payload->data));
}
else
// U2H
{
radio_response = (struct radio_response *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE+(VITA_TIME_SIZE*has_time));
fprintf(stdout,"Radio Response = 0x%016lx",swaplong(radio_response->data));
}
}
}
else if (endpoint == SRC_FLOW_CTRL)
{
if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) != EXT_CONTEXT)
{
// BAD PACKET
}
else if ((swapint(chdr_header->chdr_type) & EXT_CONTEXT) == EXT_CONTEXT)
{
if (direction == H2U)
{
src_flow_ctrl = (struct src_flow_ctrl *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE+CHDR_SIZE+(VITA_TIME_SIZE*has_time));
fprintf(stdout,"Src Flow Ctrl = 0x%04x",swapint(src_flow_ctrl->seq_id));
}
else
// U2H
{
// Bad Packet
}
}
}
//print_raw((struct pbuf_info *)vrt_header,16);
}
// Find IP addresses for Host and USRP in this Session
void get_connection_endpoints( struct pbuf_info *packet_buffer, struct in_addr *host_addr, struct in_addr *usrp_addr)
{
const struct ip_header *ip_header;
const struct chdr_header *chdr_header;
const struct chdr_sid *chdr_sid;
// Determine which side of the stream is Host and which is USRP by probing capture until a
// CHDR message type is discovered. The SID reveals which direction the packet is traveling.
// Then record apparent IP addresses of Host and USRP for future packet clasification.
packet_buffer->current = packet_buffer->start;
host_addr->s_addr = 0x0;
usrp_addr->s_addr = 0x0;
while (packet_buffer->current != NULL) {
// Overlay IP header on packet payload
ip_header = (struct ip_header *)(packet_buffer->current->payload+ETH_SIZE);
// Overlay CHDR header on packet payload
chdr_header = (struct chdr_header *)(packet_buffer->current->payload+ETH_SIZE+IP_SIZE+UDP_SIZE);
// Overlay CHDR SID definition on CHDR SID.
chdr_sid = (struct chdr_sid *)&(chdr_header->chdr_sid);
// Catagorise stream
// CHDR is actually quite hard to conclusively detect, the following deductions help...
// For CHDR v2 bit 62 should always be 0 (reserved)
// Bit 47 should always be 0 because sizes > 8192 are unsupport be typical ethernet MTU's
// By convention currently the host uses SID address 0.x so the first packets in a new UHD session
// should flow from Host to Device hence [31:24] = 0.
if (
((swapint(chdr_header->chdr_type) & 0x40000000) != 0x0) ||
((swapint(chdr_header->chdr_type) & 0x8000) != 0x0) ||
((swapint(chdr_header->chdr_sid) & 0xFF000000) != 0x0) ||
((swapint(chdr_header->chdr_sid) & 0x0000FF00) == 0x0)
)
fprintf(stderr,"Current packet is not CHDR. Skipping.");
else
{
// Implicitly CHDR (At least that is our best guess)
// Go take a look at the SID and see who is boss.
if ((chdr_sid->src_device == 0) && (chdr_sid->dst_device != 0))
{
// Host->USRP
host_addr->s_addr = ip_header->ip_src.s_addr;
usrp_addr->s_addr = ip_header->ip_dst.s_addr;
break;
}
else if ((chdr_sid->src_device == 0) && (chdr_sid->dst_device != 0))
{
// USRP->Host
usrp_addr->s_addr = ip_header->ip_src.s_addr;
host_addr->s_addr = ip_header->ip_dst.s_addr;
break;
}
else
{
fprintf(stderr,"Malformed CHDR packet, SID is unexpected value: 0x%x",swapint(chdr_header->chdr_sid));
}
}
packet_buffer->current = packet_buffer->current->next;
}
if (host_addr->s_addr == 0) {
fprintf(stderr, "Could not identify Host/USRP direction in capture analysis, exiting.\n");
exit(2);
}
}

251
tools/uhd_dump/uhd_dump.h
View File

@ -1,251 +0,0 @@
//
// Copyright 2013-2014 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
#ifndef _UHD_DUMP_H_
#define _UHD_DUMP_H_
#define FALSE 0
#define TRUE 1
#define UNKNOWN 2
// Define directions for Host->USRP & USRP->Host
#define H2U 0
#define U2H 1
// Endpoint encodings for USRP3 from SID LSB's
#define RADIO 0
#define RADIO_CTRL 1
#define SRC_FLOW_CTRL 2
#define RESERVED 3
/* // VRT Type definitions */
/* #define IF_DATA_NO_SID 0 */
/* #define IF_DATA_WITH_SID 1 */
/* #define EXT_DATA_NO_SID 2 */
/* #define EXT_DATA_WITH_SID 3 */
/* #define IF_CONTEXT 4 */
/* #define EXT_CONTEXT 5 */
// CHDR bit masks
#define EXT_CONTEXT 1<<31
#define HAS_TIME 1<<29
#define EOB 1<<28
#define SIZE (1<<16)-1
// UDP used as source for all CHDR comms.
#define CHDR_PORT 49153
typedef unsigned char u8;
typedef unsigned short u16;
typedef unsigned int u32;
typedef unsigned long u64;
union ip_addr_decoder {
unsigned long s_addr;
unsigned char octet[4];
};
/*
Ethernet header structure
*/
struct ethernet_header {
u8 eth_dst[6]; // MAC addr of destination
u8 eth_src[6]; // MAC addr of source
u16 eth_typ; // Payload protocol type
};
#define ETH_SIZE 14
/*
IP Header strcture
NOTE: Network byte order (Big Endian)
*/
struct ip_header {
u8 ip_vhl; // [7:4] Version, [3:0] Header Length
u8 ip_tos; // Type of Service/DIff Serv/ECN
u16 ip_len; // Total Length
u16 ip_id; // Identification
u16 ip_off; // [15:14] Flags, [13:0] Fragment Offset
u8 ip_ttl; // Time To Live
u8 ip_pro; // Protocol
u16 ip_sum; // Checksum
struct in_addr ip_src; // IP Source address
struct in_addr ip_dst; // IP Destination address
};
#define IP_SIZE 20
/*
UDP Header Structure
NOTE: Network byte order (Big Endian)
*/
struct udp_header {
u16 udp_src; // Source Port
u16 udp_dst; // Destination Port
u16 udp_len; // Length
u16 udp_sum; // Checksum
};
#define UDP_SIZE 8
/* /\* */
/* VITA49 VRLP Header */
/* NOTE: Network byte order (Big Endian) */
/* *\/ */
/* struct vrlp_header { */
/* u32 vrlp_start; // Hardcoded to ASCII "VRLP" */
/* u32 vrlp_size; // [31:20] Frame Count, [19:0] Frame Size */
/* }; */
/* #define VRLP_SIZE 8 */
/* #define VRLP_SEQID(x) (((x & 0xff)<<4) | ((x & 0xf000) >> 12)) */
/* /\* */
/* VITA49 VRLP Trailer */
/* NOTE: Network byte order (Big Endian) */
/* *\/ */
/* struct vrlp_trailer { */
/* u32 vrlp_end; // Hardcoded to ASCII "VEND" */
/* }; */
/* #define VRLP_TRAILER_SIZE 4 */
/* /\* */
/* VITA49 VRT Header */
/* NOTE: Network byte order (Big Endian) */
/* *\/ */
/* struct vrt_header { */
/* u8 vrt_type; // [7:4] type, [3] Class ID flag, [2] Trailer flag, [1] SOB, [0] EOB */
/* u8 vrt_count; // [7:6] TSI, [5:4] TSF, [3:0] Packet Count modulo 16 */
/* u16 vrt_size; // Number of 32bit words in VRT packet including headers and payload. */
/* u32 vrt_sid; // Stream ID */
/* }; */
/* #define VRT_SIZE 8 */
/*
Ettus Research CHDR header
NOTE: Little endian byte order (must be unswizzled)
*/
struct chdr_header {
u32 chdr_type;// [31] Ext Context, [30] RSVD, [29] Has_time, [28] EOB], [27:16] SEQ_ID, [15:0] Size
u32 chdr_sid; // Stream ID
};
#define CHDR_SIZE 8
/*
Break down SID into CHDR defined fields
*/
struct chdr_sid {
u8 src_device;
u8 src_endpoint;
u8 dst_device;
u8 dst_endpoint;
};
struct radio_ctrl_payload {
u32 addr;
u32 data;
};
struct radio_response {
u64 data;
};
struct tx_response {
u32 error_code;
u32 seq_id;
};
#define TX_ACK 0x00
#define TX_EOB 0x01
#define TX_UNDERRUN 0x02
#define TX_SEQ_ERROR 0x04
#define TX_TIME_ERROR 0x08
#define TX_MIDBURST_SEQ_ERROR 0x20
struct src_flow_ctrl {
u32 unused;
u32 seq_id;
};
struct vita_time {
u64 time;
};
#define VITA_TIME_SIZE 8
#define RADIO_CTRL_SIZE 8
#define RADIO_RESPONSE_SIZE 4
/*
Packet storage
*/
struct pbuf {
struct pbuf *next;
struct pbuf *last;
struct timeval ts;
int size; // Size stored in pcap file
int orig_size; // Original capture size on the wire
char *payload;
};
struct pbuf_info {
struct pbuf *start;
struct pbuf *current;
struct pbuf *end;
};
struct radio_ctrl_names {
u32 addr;
char *name;
};
//
// Prototypes
//
unsigned long swaplong (unsigned long);
unsigned int swapint (unsigned int);
unsigned short swapshort (unsigned short);
char *format_gmt(const struct timeval *, char *);
double timeval2double(struct timeval *);
double relative_time(struct timeval *, struct timeval *);
void get_packet(struct pbuf_info * , const struct pcap_pkthdr *, const u_char *);
void get_start_time(struct timeval * , const struct pcap_pkthdr *, const u_char *);
void get_udp_port_from_file(u16, const char *, struct pbuf_info *, struct timeval *);
void get_everything_from_file(const char *, struct pbuf_info *, struct timeval *);
void get_connection_endpoints( struct pbuf_info *, struct in_addr *, struct in_addr *);
void print_direction(const struct pbuf_info *, const struct in_addr *, const struct in_addr *);
void print_size( const struct pbuf_info *);
void print_sid( const struct pbuf_info *);
void print_vita_header( const struct pbuf_info *, const struct in_addr *);
#endif

67
tools/uhd_dump/usrp3_regs.h
View File

@ -1,67 +0,0 @@
//
// Copyright 2013-2014 Ettus Research LLC
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program. If not, see <http://www.gnu.org/licenses/>.
//
const struct radio_ctrl_names reg_list[] =
{
{5, "SR_DACSYNC"},
{6, "SR_LOOPBACK"},
{7, "SR_TEST"},
{8, "SR_SPI_DIVIDER"},
{9, "SR_SPI_CONFIG"},
{10, "SR_SPI_DATA"},
{16, "SR_GPIO_IDLE"},
{17, "SR_GPIO_RX"},
{18, "SR_GPIO_TX"},
{19, "SR_GPIO_FDX"},
{20, "SR_GPIO_DDR"},
{24, "SR_MISC_OUTS"},
{32, "SR_READBACK"},
{64, "SR_ERROR_POLICY"},
{66, "SR_CYCLES"},
{67, "SR_PACKETS"},
{96, "SR_RX_CTRL_CMD"},
{97, "SR_RX_CTRL_TIME_H"},
{98, "SR_RX_CTRL_TIME_L"},
{99, "SR_RX_CTRL_RX_HALT"},
{100, "SR_RX_CTRL_MAXLEN"},
{101, "SR_RX_CTRL_SID"},
{102, "SR_RX_CTRL_WINDOW_SIZE"},
{103, "SR_RX_CTRL_WINDOW_ENABLE"},
{128, "SR_TIME_HI"},
{129, "SR_TIME_LO"},
{130, "SR_TIME_CTRL"},
{144, "SR_RX_DSP_0"},
{145, "SR_RX_DSP_1"},
{146, "SR_RX_DSP_2"},
{147, "SR_RX_DSP_3"},
{184, "SR_TX_DSP_0"},
{185, "SR_TX_DSP_1"},
{186, "SR_TX_DSP_2"},
{196, "SR_LEDS_IDLE"},
{197, "SR_LEDS_RX"},
{198, "SR_LEDS_TX"},
{199, "SR_LEDS_FDX"},
{200, "SR_LEDS_DDR"},
{208, "SR_SWAP_IQ"},
{209, "SR_MAG_CORR"},
{210, "SR_PHASE_CORR"},
{211, "SR_RX_DC_OFFSET_I"},
{212, "SR_RX_DC_OFFSET_Q"},
{999, "NOT FOUND"}
}
;