342 lines
9.2 KiB
C
342 lines
9.2 KiB
C
/*
|
|
* (C) 2013-2016 by Harald Welte <laforge@gnumonks.org>
|
|
*
|
|
* originally based on earlier code from Dieter Spaar and Holger
|
|
* Freyther, though by now almost entirely rewritten. Nevertheless,
|
|
* thanks to Dieter and Holger!
|
|
*
|
|
* 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 2 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, write to the Free Software Foundation, Inc.,
|
|
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
|
|
*/
|
|
|
|
#include <stdlib.h>
|
|
#include <inttypes.h>
|
|
#include <stddef.h>
|
|
#include <stdio.h>
|
|
#include <string.h>
|
|
#include <time.h>
|
|
|
|
#include <sys/stat.h>
|
|
#include <fcntl.h>
|
|
#include <unistd.h>
|
|
#include <errno.h>
|
|
#include <signal.h>
|
|
#include <getopt.h>
|
|
|
|
#include <osmocom/core/msgb.h>
|
|
#include <osmocom/core/serial.h>
|
|
#include <osmocom/core/gsmtap_util.h>
|
|
#include <osmocom/core/gsmtap.h>
|
|
#include <osmocom/core/socket.h>
|
|
#include <osmocom/core/logging.h>
|
|
|
|
#include "diag_io.h"
|
|
#include "diag_log.h"
|
|
#include "diag_msg.h"
|
|
#include "diag_cmd.h"
|
|
#include "diag_dpl.h"
|
|
#include "protocol/protocol.h"
|
|
#include "protocol/diagcmd.h"
|
|
#include "protocol/diag_log_gsm.h"
|
|
|
|
struct diag_instance di;
|
|
static char *serial_path = 0;
|
|
static uint32_t cfg_flags = 0;
|
|
static char *gsmtap_ip = "localhost";
|
|
|
|
static void do_configure(struct diag_instance *di)
|
|
{
|
|
static uint8_t timestamp[] = { DIAG_TS_F };
|
|
static const uint8_t enable_evt_report[] = {
|
|
DIAG_EVENT_REPORT_F, 0x01
|
|
};
|
|
static const uint8_t disable_evt_report[] = {
|
|
DIAG_EVENT_REPORT_F, 0x00
|
|
};
|
|
static const uint8_t disable_log[] = {
|
|
DIAG_LOG_CONFIG_F, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
|
};
|
|
|
|
// diag_transceive_buf_ign(di, timestamp, sizeof(timestamp));
|
|
/* response: 3d 67 a8 81 d4 46 6d d9 00 */
|
|
|
|
/* enable|disable the event report */
|
|
#if 0
|
|
diag_transceive_buf_ign(di, enable_evt_report, sizeof(enable_evt_report));
|
|
#else
|
|
diag_transceive_buf_ign(di, disable_log, sizeof(disable_log));
|
|
diag_msg_config_set_all_rt_mask(di, 0);
|
|
// diag_transceive_buf_ign(di, disable_evt_report, sizeof(disable_evt_report));
|
|
/* response: 40 00 00 */
|
|
#endif
|
|
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_LINUX_DATA, 0xffffffff);
|
|
// /* response: 5d 5d 04 41 00 41 00 01 00 ff ff ff ff */
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DS_ATCOP, 0xffffffff);
|
|
// /* response: 5d 5d 04 94 13 94 13 01 00 ff ff ff ff */
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DS, 0xffffffff);
|
|
// /* response: 5d 5d 04 88 13 88 13 01 00 ff ff ff ff */
|
|
// //diag_msg_config_set_rt_mask(di, MSG_SSID_DS_IPA, 0xffffffff);
|
|
// /* response: 5d 5d 04 a6 13 a6 13 01 00 ff ff ff ff */
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DS_GPRS, 0xffffffff);
|
|
// /* response: 5d 5d 04 91 13 91 13 01 00 ff ff ff ff */
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DS_GSM, 0xffffffff);
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DS_UMTS, 0xffffffff);
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DS_SOCKETS, 0xffffffff);
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DS_SIO, 0xffffffff);
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DS_APPS, 0xffffffff);
|
|
// diag_msg_config_set_rt_mask(di, MSG_SSID_DIAG, 0xffffffff);
|
|
|
|
#if 0
|
|
printf("GSM\n");
|
|
struct msgb *msg = gen_log_config_set_mask(5, 1064);
|
|
#if 0
|
|
for (int i = 0; i < 1064; i++)
|
|
log_config_set_mask_bit(msg, i);
|
|
#endif
|
|
|
|
log_config_set_mask_bit(msg, LOG_GSM_RR_CONTROL_CHANNEL_PARAMS_C);
|
|
|
|
log_config_set_mask_bit(msg, LOG_GPRS_RLC_UL_ACKNACK_PARAMS_VER2_C);
|
|
log_config_set_mask_bit(msg, LOG_GPRS_RLC_DL_ACKNACK_PARAMS_VER2_C);
|
|
log_config_set_mask_bit(msg, LOG_EGPRS_RLC_DL_HEADER_C);
|
|
log_config_set_mask_bit(msg, LOG_EGPRS_RLC_UL_HEADER_C);
|
|
|
|
log_config_set_mask_bit(msg, LOG_GPRS_LLC_PERIODIC_STATS_C);
|
|
|
|
log_config_set_mask_bit(msg, LOG_GPRS_SNDCP_UL_TCP_HDR_C);
|
|
log_config_set_mask_bit(msg, LOG_GPRS_SNDCP_DL_TCP_HDR_C);
|
|
log_config_set_mask_bit(msg, 546);
|
|
log_config_set_mask_bit(msg, 547);
|
|
log_config_set_mask_bit(msg, LOG_EGPRS_MAC_UL_ACKNACK_C);
|
|
log_config_set_mask_bit(msg, LOG_EGPRS_MAC_DL_ACKNACK_C);
|
|
|
|
diag_tranceive_msgb(di, msg);
|
|
|
|
printf("WCDMA\n");
|
|
msg = gen_log_config_set_mask(4, 1064);
|
|
#if 0
|
|
for (int i = 0; i < 1064; i++)
|
|
log_config_set_mask_bit(msg, i);
|
|
#endif
|
|
log_config_set_mask_bit(msg, 0x125);
|
|
log_config_set_mask_bit(msg, 0x126);
|
|
log_config_set_mask_bit(msg, 0x127);
|
|
log_config_set_mask_bit(msg, 0x128);
|
|
log_config_set_mask_bit(msg, 0x129);
|
|
|
|
diag_tranceive_msgb(di, msg);
|
|
#else
|
|
diag_log_enable_all_supported(di);
|
|
#endif
|
|
}
|
|
|
|
static void enable_pcap(struct diag_instance *di, uint8_t if_num)
|
|
{
|
|
struct dpl_iid iid = { .flags = 0, .if_name = if_num,
|
|
.protocol = DIAG_DPL_IID_PROT_NET_IP,
|
|
.link_instance = 64 };
|
|
#if 1
|
|
iid.flags &= ~DIAG_DPL_IID_FLAG_DIR_TX;
|
|
diag_dpl_set_if_log(di, if_num, iid, DIAG_DPL_IID_PROT_LINK_ANY);
|
|
#else
|
|
iid.flags |= DIAG_DPL_IID_FLAG_DIR_TX;
|
|
diag_dpl_set_if_log(di, if_num, iid, DIAG_DPL_IID_PROT_LINK_ANY);
|
|
#endif
|
|
}
|
|
|
|
|
|
static void signal_handler(int s)
|
|
{
|
|
struct termios tio;
|
|
switch (s) {
|
|
case SIGINT:
|
|
case SIGTERM:
|
|
diag_log_disable_all_supported(&di);
|
|
/* graceful exit by immediate read timeout */
|
|
tcgetattr(di.fd, &tio);
|
|
tio.c_cflag &= CRTSCTS;
|
|
tio.c_cc[VMIN] = 0;
|
|
tio.c_cc[VTIME] = 1;
|
|
tcsetattr(di.fd, TCSANOW, &tio);
|
|
// exit(0);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
static void print_help()
|
|
{
|
|
printf( " Some useful help...\n"
|
|
" -h --help This help text\n"
|
|
" -s --serial-path path to modem serial port, i.e /dev/ttyUSB0\n"
|
|
" Any combination of the following output flags:\n"
|
|
" -G --gsmtap GSMTAP messages sent to localhost\n"
|
|
" -Q --qcomdbg plain QC DIAG GSMTAP messages\n"
|
|
" -H --hexdump console output of rx/tx messages\n"
|
|
" -i --ip address the GSMTAP packets should be sent to (default 127.0.0.1)\n"
|
|
);
|
|
}
|
|
|
|
static void handle_options(int argc, char **argv)
|
|
{
|
|
while (1) {
|
|
int option_index = 0, c;
|
|
static struct option long_options[] = {
|
|
{ "help", 0, 0, 'h' },
|
|
{ "gsmtap", 0, 0, 'G' },
|
|
{ "qcomdbg", 0, 0, 'Q' },
|
|
{ "hexdump", 0, 0, 'H' },
|
|
{ "serial-path", 1, 0, 's' },
|
|
{ "ip", 1, 0, 'i' },
|
|
{ 0, 0, 0, 0 }
|
|
};
|
|
|
|
c = getopt_long(argc, argv, "hGQHs:i:", long_options, &option_index);
|
|
if (c == -1)
|
|
break;
|
|
|
|
switch (c) {
|
|
case 'h':
|
|
print_help();
|
|
exit(0);
|
|
case 'G':
|
|
cfg_flags |= DIAG_INST_F_GSMTAP_DECODED;
|
|
break;
|
|
case 'Q':
|
|
cfg_flags |= DIAG_INST_F_GSMTAP_DIAG;
|
|
break;
|
|
case 'H':
|
|
cfg_flags |= DIAG_INST_F_HEXDUMP;
|
|
break;
|
|
case 's':
|
|
serial_path = optarg;
|
|
break;
|
|
case 'i':
|
|
gsmtap_ip = optarg;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* special function that allows to bind to local nonlocal ips like 127.0.0.x with x != 1 */
|
|
static int gsmtap_source_add_local_sink(struct gsmtap_inst *gti)
|
|
{
|
|
int rc;
|
|
struct sockaddr_storage ss;
|
|
socklen_t ss_len = sizeof(ss);
|
|
|
|
if (gti->ofd_wq_mode)
|
|
return -1;
|
|
|
|
rc = getpeername(gsmtap_inst_fd(gti), (struct sockaddr *)&ss, &ss_len);
|
|
if (rc < 0)
|
|
return rc;
|
|
|
|
rc = osmo_sock_init_sa((struct sockaddr *)&ss, SOCK_DGRAM,
|
|
IPPROTO_UDP,
|
|
OSMO_SOCK_F_BIND |
|
|
OSMO_SOCK_F_UDP_REUSEADDR);
|
|
if (rc >= 0)
|
|
return rc;
|
|
|
|
return -ENODEV;
|
|
}
|
|
|
|
int main(int argc, char **argv)
|
|
{
|
|
struct termios tio;
|
|
int i;
|
|
int rc;
|
|
|
|
handle_options(argc, argv);
|
|
log_init(0,0);
|
|
|
|
if (!serial_path) {
|
|
printf("Invoke with %s -s PATH_TO_SERIAL\n", argv[0]);
|
|
return EXIT_FAILURE;
|
|
}
|
|
if (!cfg_flags) {
|
|
printf("no output options (-G/-Q/-H) specified?! exiting...\n");
|
|
print_help();
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
memset(&di, 0, sizeof(di));
|
|
di.fd = osmo_serial_init(serial_path, 921600);
|
|
if (di.fd < 0) {
|
|
printf("can't open serial port: errno %d\n", di.fd);
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
/* blocking reads */
|
|
rc = tcgetattr(di.fd, &tio);
|
|
tio.c_cflag &= CRTSCTS;
|
|
tio.c_cc[VMIN] = 1;
|
|
tio.c_cc[VTIME] = 0;
|
|
rc = tcsetattr(di.fd, TCSANOW, &tio);
|
|
|
|
di.gsmtap = gsmtap_source_init(gsmtap_ip, GSMTAP_UDP_PORT, 0);
|
|
if (di.gsmtap == 0) {
|
|
printf("error initializing gsmtap source!\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
di.flags = cfg_flags;
|
|
rc = gsmtap_source_add_local_sink(di.gsmtap);
|
|
if (rc < 0) {
|
|
printf("error initializing gsmtap sink!\n");
|
|
return EXIT_FAILURE;
|
|
}
|
|
|
|
printf("\n===> CONFIGURING\n");
|
|
|
|
do_configure(&di);
|
|
// diag_dpl_get_sup_if(&di);
|
|
// for (i = 1; i < 0x56; i++) {
|
|
// diag_dpl_get_if_desc(&di, i);
|
|
// enable_pcap(&di, i);
|
|
// }
|
|
|
|
/* Handle keyboard interrupts */
|
|
signal(SIGINT, &signal_handler);
|
|
signal(SIGTERM, &signal_handler);
|
|
signal(SIGABRT, &signal_handler);
|
|
signal(SIGUSR1, &signal_handler);
|
|
signal(SIGUSR2, &signal_handler);
|
|
|
|
|
|
printf("\n===> ENTERING MAIN\n");
|
|
|
|
while (1) {
|
|
i++;
|
|
struct msgb *rx = diag_read_msg(&di);
|
|
if (rx)
|
|
diag_process_msg(&di, rx);
|
|
#if 0
|
|
/* some packets need to be explicitly requested and
|
|
* don't appear automatically */
|
|
if (i % 10 == 0) {
|
|
struct msgb *msg = diag_gsm_make_log_pack_req(LOG_GPRS_LLC_PDU_STATS_C , 0, 0);
|
|
printf("Requesting LLC stats...(%s)\n", osmo_hexdump(msgb_data(msg), msgb_length(msg)));
|
|
diag_transmit_msgb(&di, msg);
|
|
}
|
|
#endif
|
|
|
|
}
|
|
|
|
return EXIT_SUCCESS;
|
|
}
|