e1cap_dump: Implement functional HDLC decode of super-channel
Finally the bit ordering and bit format of the SuperChannel has been
figured out.
* the data as read from DAHDI must be flipped (0->1 / 1->0). why?
* the data must be read lsb-first when converting into a bit-buffer
We are now getting the following output e.g. for a OM2000 "TX
Configuration Request" message:
fa 03 8a 8a 80 80 00 13 00 b0 0b 00 ff 01 20 00 2e 2b 1c 00 06 01 95 81 76 00 e9 bf
^ lapd hdr ^ OML ^l ^OM2000 TX Config Req for 43 dBm
diff --git a/src/Makefile b/src/Makefile
index 734c658..25c00d6 100644
--- a/src/Makefile
+++ b/src/Makefile
@@ -1,16 +1,19 @@
CFLAGS=-g -Wall
LDFLAGS=-losmocore -losmogsm -losmovty -losmoabis -ltalloc
-all: osmo-e1-recorder osmo-e1cap-dump
+all: osmo-e1-recorder osmo-e1cap-dump hdlc-test
osmo-e1-recorder: e1_recorder.o storage.o vty.o
$(CC) $(LDFLAGS) -o$@ $^
-osmo-e1cap-dump: e1cap_dump.o storage.o
+osmo-e1cap-dump: e1cap_dump.o storage.o flip_bits.o hdlc.o
+ $(CC) $(LDFLAGS) -o$@ $^
+
+hdlc-test: hdlc.o hdlc-test.o
$(CC) $(LDFLAGS) -o$@ $^
%.o: %.c
$(CC) $(CFLAGS) -o $@ -c $^
clean:
- @rm *.o osmo-e1-recorder
+ @rm *.o osmo-e1-recorder osmo-e1cap-dump
diff --git a/src/e1cap_dump.c b/src/e1cap_dump.c
index 7bbb71e..eb55c41 100644
--- a/src/e1cap_dump.c
+++ b/src/e1cap_dump.c
@@ -5,6 +5,7 @@
#include <sys/time.h>
+#include <osmocom/core/bits.h>
#include <osmocom/core/signal.h>
#include <osmocom/core/logging.h>
#include <osmocom/core/application.h>
@@ -12,6 +13,8 @@
#include "storage.h"
#include "recorder.h"
+#include "flip_bits.h"
+#include "hdlc.h"
struct e1_recorder g_recorder;
@@ -28,6 +31,8 @@
struct sc_state {
uint8_t ts_data[MAX_TS][CHUNK_BYTES];
uint8_t num_ts;
+ uint32_t ts_mask;
+ struct hdlc_proc hdlc;
};
static struct sc_state g_sc_state[2];
@@ -65,15 +70,21 @@
static void handle_sc_out(struct sc_state *scs)
{
- uint8_t out[scs->num_ts * CHUNK_BYTES];
+ unsigned int num_bytes = scs->num_ts * CHUNK_BYTES;
+ unsigned int num_bits = num_bytes * 8;
+ uint8_t out[32*CHUNK_BYTES];
+ ubit_t out_bits[32*CHUNK_BYTES*8];
int i, j, k = 0;
/* re-shuffle the data from columns to lines */
for (i = 0; i < CHUNK_BYTES; i++) {
- for (j = 1; j < scs->num_ts; j++)
+ for (j = 0; j < scs->num_ts; j++)
out[k++] = scs->ts_data[j][i];
}
- printf("%s\n", osmo_hexdump_nospc(out, scs->num_ts * CHUNK_BYTES));
+ //printf("num_bytes=%u %s\n", num_bytes, osmo_hexdump_nospc(out, num_bytes));
+ osmo_pbit2ubit_ext(out_bits, 0, out, 0, num_bits, 1);
+ //for (i = 0; i < num_bits; i++) fputc(out_bits[i] ? '1' : '.', stdout); fputc('\n', stdout);
+ process_raw_hdlc(&scs->hdlc, out_bits, num_bits);
}
static void handle_sc_in(struct osmo_e1cap_pkthdr *pkt, const uint8_t *data, unsigned int len)
@@ -96,16 +107,48 @@
exit(1);
}
- memcpy(scs->ts_data[pkt->ts_nr], data, len);
- if (pkt->ts_nr-1 > scs->num_ts)
- scs->num_ts = pkt->ts_nr-1;
- if (pkt->ts_nr == scs->num_ts)
+ if (pkt->ts_nr == 1) {
+ scs->ts_mask = 0;
+ memset(scs->ts_data, 0, sizeof(scs->ts_data));
+ }
+
+ /* copy over the data */
+ memcpy(scs->ts_data[pkt->ts_nr-1], data, len);
+ /* note that we have valid data for the given timeslot */
+ scs->ts_mask |= (1 << (pkt->ts_nr-1));
+
+ /* make sure we know what's the maximum timeslot number */
+ if (pkt->ts_nr > scs->num_ts)
+ scs->num_ts = pkt->ts_nr;
+
+ /* check if we have data for all needed timeslots */
+ uint32_t ts_mask = (1 << scs->num_ts) -1;
+ //printf("num_ts=%u, ts_mask=0x%x, scs_ts_mask=0x%x\n", scs->num_ts, ts_mask, scs->ts_mask);
+ if (scs->ts_mask == ts_mask) {
handle_sc_out(scs);
+ }
}
-static void handle_data(struct osmo_e1cap_pkthdr *pkt, const uint8_t *data, int len)
+static void handle_data(struct osmo_e1cap_pkthdr *pkt, uint8_t *data, int len)
{
+ flip_buf_bits(data, len);
+#if 0
+ /* filter out all-ff/all-fe/all-7f */
+ if (all_bytes_are(0xff, data, len) ||
+ all_bytes_are(0x7f, data, len) ||
+ all_bytes_are(0x7e, data, len) ||
+ all_bytes_are(0xe7, data, len) ||
+ all_bytes_are(0x3f, data, len) ||
+ all_bytes_are(0xf3, data, len) ||
+ all_bytes_are(0x9f, data, len) ||
+ all_bytes_are(0xf9, data, len) ||
+ all_bytes_are(0xcf, data, len) ||
+ all_bytes_are(0xfc, data, len) ||
+ all_bytes_are(0xfe, data, len))
+ return;
+#endif
+
switch (g_mode) {
case MODE_PRINT:
printf("%s %02u/%02u %u (%u): %s\n",
@@ -127,6 +170,7 @@
int len, void *c)
{
OSMO_ASSERT(ch == g_filter_subslot);
+
handle_data(g_last_pkthdr, data, len);
return 0;
@@ -175,6 +219,9 @@
printf("sizeof(timeval) = %zu\n", sizeof(struct timeval));
printf("sizeof(osmo_e1cap_pkthdr) = %zu\n", sizeof(*pkt));
+ memset(g_sc_state, 0, sizeof(g_sc_state));
+ init_flip_bits();
+
handle_options(argc, argv);
if (optind >= argc) {
@@ -194,6 +241,8 @@
subch_demux_activate(&smux, g_filter_subslot);
}
+// printf("hdlc=%s\n", osmo_hexdump(&g_sc_state[0].hdlc, sizeof(g_sc_state[0].hdlc)));
+
while ((pkt = osmo_e1cap_read_next(f))) {
num_pkt++;
g_last_pkthdr = pkt;
diff --git a/src/hdlc-test.c b/src/hdlc-test.c
new file mode 100644
index 0000000..1c7c6ef
--- /dev/null
+++ b/src/hdlc-test.c
@@ -0,0 +1,42 @@
+#include <string.h>
+#include "hdlc.h"
+
+#include <osmocom/core/utils.h>
+#include <osmocom/core/bits.h>
+
+const char *tdata = "7e7e7e7e7a76f20609167d3cfcfcfc";
+
+static void hdlc_process_hex_str(struct hdlc_proc *hdlc, const char *hex)
+{
+ uint8_t *bytes, *bits;
+ int string_len = strlen(hex);
+ int byte_len = string_len/2;
+ int bit_len = byte_len*8;
+ int rc;
+
+ printf("hex string = %s\n", hex);
+ bytes = alloca(byte_len);
+ bits = alloca(bit_len);
+ rc = osmo_hexparse(hex, bytes, byte_len);
+ printf("parsed bytes = %s\n", osmo_hexdump(bytes, byte_len));
+
+ printf("MSB mode\n");
+ osmo_pbit2ubit(bits, bytes, bit_len);
+ process_raw_hdlc(hdlc, bits, bit_len);
+
+ printf("LSB mode\n");
+ memset(hdlc, 0, sizeof(*hdlc));
+ osmo_pbit2ubit_ext(bits, 0, bytes, 0, bit_len, 1);
+ process_raw_hdlc(hdlc, bits, bit_len);
+}
+
+int main(int argc, char **argv)
+{
+ struct hdlc_proc hdlc;
+ memset(&hdlc, 0, sizeof(hdlc));
+
+ if (argc < 2)
+ exit(1);
+
+ hdlc_process_hex_str(&hdlc, argv[1]);
+}