# HG changeset patch
# User Mychaela Falconia <falcon@freecalypso.org>
# Date 1656469528 28800
# Node ID cc0e1c6e33c3882614a4e71fb04d76e3133a9323
# Parent  b13acb024fc6cb054d2e5bc0efa61ba70aa54406
themwi-test-mtc utility written, compiles

diff -r b13acb024fc6 -r cc0e1c6e33c3 .hgignore
--- a/.hgignore	Sun Jun 26 23:35:19 2022 -0800
+++ b/.hgignore	Tue Jun 28 18:25:28 2022 -0800
@@ -4,6 +4,8 @@
 
 ^mncc/themwi-mncc$
 
+^mtctest/themwi-test-mtc$
+
 ^utils/sip-udp-dump$
 ^utils/themwi-check-own$
 ^utils/themwi-dump-numdb$
diff -r b13acb024fc6 -r cc0e1c6e33c3 mtctest/Makefile
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtctest/Makefile	Tue Jun 28 18:25:28 2022 -0800
@@ -0,0 +1,17 @@
+CC=	gcc
+CFLAGS=	-O2
+PROG=	themwi-test-mtc
+OBJS=	disconnect.o main.o setup.o sig_handler.o sock_conn.o
+LIBS=	../libnumdb/libnumdb.a ../libutil/libutil.a
+INSTBIN=/usr/local/bin
+
+all:	${PROG}
+
+${PROG}: ${OBJS} ${LIBS}
+	${CC} ${CFLAGS} -o $@ ${OBJS} ${LIBS}
+
+install:
+	install -c -o bin -g bin -m 755 ${PROG} ${INSTBIN}
+
+clean:
+	rm -f *.o ${PROG} errs
diff -r b13acb024fc6 -r cc0e1c6e33c3 mtctest/disconnect.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtctest/disconnect.c	Tue Jun 28 18:25:28 2022 -0800
@@ -0,0 +1,33 @@
+/*
+ * In this module we implement the sending of MNCC_DISC_REQ,
+ * signaling a caller-requested disconnect aka hang-up.
+ * It is the graceful way of signaling disconnect,
+ * as opposed to simply killing the test call process with ^C
+ * and letting themwi-mncc handle the broken socket.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include "../include/mncc.h"
+#include "../include/gsm48_const.h"
+
+int disconnect_mode;
+
+send_disconnect_req()
+{
+	struct gsm_mncc msg;
+
+	printf("Sending disconnect request\n");
+	bzero(&msg, sizeof(struct gsm_mncc));
+	msg.msg_type = MNCC_DISC_REQ;
+	msg.callref = 1;
+	mncc_set_cause(&msg, GSM48_CAUSE_LOC_USER,
+			GSM48_CC_CAUSE_NORM_CALL_CLEAR);
+	send_mncc_to_gsm(&msg, sizeof(struct gsm_mncc));
+	disconnect_mode = 1;
+}
diff -r b13acb024fc6 -r cc0e1c6e33c3 mtctest/main.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtctest/main.c	Tue Jun 28 18:25:28 2022 -0800
@@ -0,0 +1,63 @@
+/*
+ * Main module for ThemWi test MT call generator.
+ */
+
+#include <sys/types.h>
+#include <sys/errno.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <syslog.h>
+#include <unistd.h>
+
+extern int mtc_socket;
+extern int disconnect_mode;
+
+main(argc, argv)
+	char **argv;
+{
+	extern int optind;
+	extern char *optarg;
+	char *from;
+	fd_set fds;
+	int c;
+
+	from = 0;
+	while ((c = getopt(argc, argv, "f:")) != EOF) {
+		switch (c) {
+		case 'f':
+			from = optarg;
+			continue;
+		default:
+		usage:
+			fprintf(stderr,
+				"usage: %s [-f from-number] to-number\n",
+				argv[0]);
+			exit(1);
+		}
+	}
+	if (argc != optind + 1)
+		goto usage;
+	openlog("themwi-test-mtc", 0, LOG_LOCAL5);
+	init_setup_msg(from, argv[optind]);
+	connect_mtc_socket();
+	send_setup_msg();
+	/* main select loop */
+	for (;;) {
+		FD_ZERO(&fds);
+		FD_SET(mtc_socket, &fds);
+		if (!disconnect_mode)
+			FD_SET(0, &fds);
+		c = select(mtc_socket+1, &fds, 0, 0, 0);
+		if (c < 0) {
+			if (errno == EINTR)
+				continue;
+			perror("select");
+			exit(1);
+		}
+		if (FD_ISSET(mtc_socket, &fds))
+			mtc_socket_select();
+		if (!disconnect_mode && FD_ISSET(0, &fds))
+			send_disconnect_req();
+	}
+}
diff -r b13acb024fc6 -r cc0e1c6e33c3 mtctest/setup.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtctest/setup.c	Tue Jun 28 18:25:28 2022 -0800
@@ -0,0 +1,231 @@
+/*
+ * In this module we compose the MNCC_SETUP_REQ message
+ * initiating our test MT call.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <ctype.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include "../include/mncc.h"
+#include "../include/gsm48_const.h"
+
+struct gsm_mncc setup_msg;
+
+static void
+set_called_number(arg)
+	char *arg;
+{
+	int rc, ndig;
+	char short_num[5], long_num[12];
+
+	if (!strncmp(arg, "imsi:", 5)) {
+		rc = grok_imsi_user_arg(arg, setup_msg.imsi);
+		if (rc < 0) {
+			fprintf(stderr,
+			"error: call-by-IMSI destination \"%s\" is invalid\n",
+				arg);
+			exit(1);
+		}
+		return;
+	}
+	if (arg[0] == '+') {
+		if (arg[1] != '1') {
+			fprintf(stderr,
+	"error: plus-format call destination number must begin with 1\n");
+			exit(1);
+		}
+		if (grok_number_string(arg+1, 1) != 11) {
+bad_plus1:		fprintf(stderr,
+			"error: malformed +1 call destination number\n");
+			exit(1);
+		}
+		dehyphen_number_string(arg+1, setup_msg.called.number);
+		if (!is_nanp_valid_prefix(setup_msg.called.number+1))
+			goto bad_plus1;
+		setup_msg.called.type = GSM48_TON_INTERNATIONAL;
+		setup_msg.called.plan = GSM48_NPI_ISDN_E164;
+		setup_msg.fields |= MNCC_F_CALLED;
+		return;
+	}
+	ndig = grok_number_string(arg);
+	switch (ndig) {
+	case 4:
+		dehyphen_number_string(arg, short_num);
+		if (read_number_db() < 0) {
+			fprintf(stderr, "error reading number database\n");
+			exit(1);
+		}
+		rc = lookup_short_dial_number(short_num, long_num);
+		if (!rc) {
+			fprintf(stderr,
+				"error: short dial number %s is not valid\n",
+				short_num);
+			exit(1);
+		}
+		if (long_num[0]) {
+			setup_msg.called.type = GSM48_TON_INTERNATIONAL;
+			setup_msg.called.plan = GSM48_NPI_ISDN_E164;
+			setup_msg.called.number[0] = '1';
+			strcpy(setup_msg.called.number+1, long_num);
+		} else {
+			setup_msg.called.type = GSM48_TON_NET_SPEC;
+			setup_msg.called.plan = GSM48_NPI_PRIVATE;
+			strcpy(setup_msg.called.number, short_num);
+		}
+		setup_msg.fields |= MNCC_F_CALLED;
+		return;
+	case 10:
+		dehyphen_number_string(arg, long_num);
+		if (!is_nanp_valid_prefix(long_num))
+			break;
+		setup_msg.called.type = GSM48_TON_INTERNATIONAL;
+		setup_msg.called.plan = GSM48_NPI_ISDN_E164;
+		setup_msg.called.number[0] = '1';
+		strcpy(setup_msg.called.number+1, long_num);
+		setup_msg.fields |= MNCC_F_CALLED;
+		return;
+	case 11:
+		dehyphen_number_string(arg, long_num);
+		if (long_num[0] != '1')
+			break;
+		if (!is_nanp_valid_prefix(long_num+1))
+			break;
+		setup_msg.called.type = GSM48_TON_INTERNATIONAL;
+		setup_msg.called.plan = GSM48_NPI_ISDN_E164;
+		strcpy(setup_msg.called.number, long_num);
+		setup_msg.fields |= MNCC_F_CALLED;
+		return;
+	}
+	fprintf(stderr, "error: call destination number \"%s\" is invalid\n",
+		arg);
+	exit(1);
+}
+
+static void
+set_calling_number(arg)
+	char *arg;
+{
+	unsigned ndig;
+	int c;
+
+	if (!strcmp(arg, "unavail")) {
+		setup_msg.calling.present = GSM48_PRES_UNAVAIL;
+		return;
+	}
+	if (!strcmp(arg, "blocked")) {
+		setup_msg.calling.present = GSM48_PRES_RESTR;
+		return;
+	}
+	if (*arg == '+') {
+		setup_msg.calling.type = GSM48_TON_INTERNATIONAL;
+		arg++;
+	}
+	for (ndig = 0; *arg; ) {
+		c = *arg++;
+		if (c == ',')
+			break;
+		if (c == '-')
+			continue;
+		if (!is_valid_ext_digit(c)) {
+			fprintf(stderr,
+	"error: calling number argument contains invalid digit \'%c\'\n",
+				c);
+			exit(1);
+		}
+		if (ndig >= 32) {
+			fprintf(stderr,
+				"error: calling number argument is too long\n");
+			exit(1);
+		}
+		setup_msg.calling.number[ndig] = c;
+		ndig++;
+	}
+	if (!ndig) {
+		fprintf(stderr,
+			"error: calling number argument has no digits\n");
+		exit(1);
+	}
+	setup_msg.calling.plan = GSM48_NPI_ISDN_E164;
+	for (;;) {
+		while (*arg == ',')
+			arg++;
+		if (!*arg)
+			return;
+		if (!strncmp(arg, "ton=", 4)) {
+			arg += 4;
+			if (arg[0] >= '0' && arg[1] <= '7' && !isdigit(arg[1])){
+				setup_msg.calling.type = *arg - '0';
+				arg++;
+			} else {
+				fprintf(stderr,
+		"error: calling number argument contains invalid ton= part\n");
+				exit(1);
+			}
+		} else if (!strncmp(arg, "npi=", 4)) {
+			arg += 4;
+			if (arg[0] >= '0' && arg[1] <= '9' && !isdigit(arg[1])){
+				setup_msg.calling.plan = *arg - '0';
+				arg++;
+			} else if (arg[0] == '1' && arg[1] >= '0' &&
+				   arg[1] <= '5' && !isdigit(arg[2])) {
+				setup_msg.calling.plan = atoi(arg);
+				arg += 2;
+			} else {
+				fprintf(stderr,
+		"error: calling number argument contains invalid npi= part\n");
+				exit(1);
+			}
+		} else if (!strncmp(arg, "restr", 5)) {
+			arg += 5;
+			setup_msg.calling.present = GSM48_PRES_RESTR;
+		} else if (!strncmp(arg, "vp", 2)) {
+			arg += 2;
+			setup_msg.calling.screen = GSM48_SCRN_USER_PASS;
+		} else if (!strncmp(arg, "vf", 2)) {
+			arg += 2;
+			setup_msg.calling.screen = GSM48_SCRN_USER_FAIL;
+		} else if (!strncmp(arg, "net", 3)) {
+			arg += 3;
+			setup_msg.calling.screen = GSM48_SCRN_NETWORK;
+		} else {
+inv_qual:		fprintf(stderr,
+		"error: calling number argument contains invalid qualifier\n");
+			exit(1);
+		}
+		if (!*arg)
+			return;
+		if (*arg != ',')
+			goto inv_qual;
+	}
+}
+
+void
+init_setup_msg(from, to)
+	char *from, *to;
+{
+	setup_msg.msg_type = MNCC_SETUP_REQ;
+	setup_msg.callref = 1;
+	set_called_number(to);
+	if (from) {
+		set_calling_number(from);
+		setup_msg.fields |= MNCC_F_CALLING;
+	}
+}
+
+void
+send_setup_msg()
+{
+	if (setup_msg.imsi[0])
+		printf("Calling IMSI %s\n", setup_msg.imsi);
+	else
+		printf("Calling %s%s\n",
+			setup_msg.called.type == GSM48_TON_INTERNATIONAL ? "+"
+									 : "",
+			setup_msg.called.number);
+	send_mncc_to_gsm(&setup_msg, sizeof(struct gsm_mncc));
+}
diff -r b13acb024fc6 -r cc0e1c6e33c3 mtctest/sig_handler.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtctest/sig_handler.c	Tue Jun 28 18:25:28 2022 -0800
@@ -0,0 +1,323 @@
+/*
+ * In this module we handle all incoming messages from MNCC,
+ * printing all of them and generating protocol-required responses
+ * for some.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <strings.h>
+#include "../include/mncc.h"
+#include "../include/gsm48_const.h"
+
+extern int disconnect_mode;
+
+static void
+print_bearer_cap(bcap)
+	struct gsm_mncc_bearer_cap *bcap;
+{
+	int i, sv;
+
+	printf("Bearer cap: itcap=%d tmod=%d coding=%d rrq=%d\n",
+		bcap->transfer, bcap->mode, bcap->coding, bcap->radio);
+	printf("  speech: CTM=%d sv", bcap->speech_ctm);
+	for (i = 0; i < 8; i++) {
+		sv = bcap->speech_ver[i];
+		if (sv < 0)
+			break;
+		printf(" %d", sv);
+	}
+	putchar('\n');
+	printf("  data: ra=%d sig=%d async=%d nstop=%d ndata=%d\n",
+		bcap->data.rate_adaption, bcap->data.sig_access,
+		bcap->data.async, bcap->data.nr_stop_bits,
+		bcap->data.nr_data_bits);
+	printf("  urate=%d par=%d irate=%d transp=%d mtype=%d\n",
+		bcap->data.user_rate, bcap->data.parity,
+		bcap->data.interm_rate, bcap->data.transp,
+		bcap->data.modem_type);
+}
+
+static void
+print_cc_cap(cc)
+	struct gsm_mncc_cccap *cc;
+{
+	printf("CC capabilities: DTMF=%d PCP=%d\n", cc->dtmf, cc->pcp);
+}
+
+static void
+print_cause(cause)
+	struct gsm_mncc_cause *cause;
+{
+	int i;
+
+	printf("Cause: loc=%d coding=%d value=%d", cause->location,
+		cause->coding, cause->value);
+	if (cause->rec)
+		printf(" rec=0x%02X", cause->rec_val);
+	for (i = 0; i < cause->diag_len; i++) {
+		if (!(i & 15)) {
+			putchar('\n');
+			putchar(' ');
+		}
+		printf(" %02X", cause->diag[i] & 0xFF);
+	}
+	putchar('\n');
+}
+
+static void
+print_progress(prog)
+	struct gsm_mncc_progress *prog;
+{
+	printf("Progress: loc=%d coding=%d descr=0x%02X", prog->location,
+		prog->coding, prog->descr);
+}
+
+static void
+print_useruser(uu)
+	struct gsm_mncc_useruser *uu;
+{
+	printf("User-User IE: proto=0x%02X\n", uu->proto);
+	/* dump to be implemented if and when we actually get a UU somewhere */
+}
+
+static void
+print_keypad(kp)
+	int kp;
+{
+	if (kp >= '!' && kp <= '~')
+		printf("Keypad code: %c\n", kp);
+	else
+		printf("Keypad code: 0x%02X\n", kp);
+}
+
+static void
+print_facility(fac)
+	struct gsm_mncc_facility *fac;
+{
+	int i;
+
+	printf("Facility IE: %d byte(s)", fac->len);
+	for (i = 0; i < fac->len; i++) {
+		if (!(i & 15)) {
+			putchar('\n');
+			putchar(' ');
+		}
+		printf(" %02X", fac->info[i] & 0xFF);
+	}
+	putchar('\n');
+}
+
+static void
+print_ssver(ssv)
+	struct gsm_mncc_ssversion *ssv;
+{
+	int i;
+
+	printf("SS version IE: %d byte(s)", ssv->len);
+	for (i = 0; i < ssv->len; i++) {
+		if (!(i & 15)) {
+			putchar('\n');
+			putchar(' ');
+		}
+		printf(" %02X", ssv->info[i] & 0xFF);
+	}
+	putchar('\n');
+}
+
+static void
+print_fields(msg)
+	struct gsm_mncc *msg;
+{
+	if (msg->fields & MNCC_F_BEARER_CAP)
+		print_bearer_cap(&msg->bearer_cap);
+	if (msg->fields & MNCC_F_CCCAP)
+		print_cc_cap(&msg->cccap);
+	if (msg->fields & MNCC_F_CAUSE)
+		print_cause(&msg->cause);
+	if (msg->fields & MNCC_F_PROGRESS)
+		print_progress(&msg->progress);
+	if (msg->fields & MNCC_F_USERUSER)
+		print_useruser(&msg->useruser);
+	if (msg->more)
+		printf("More data flag set\n");
+	if (msg->fields & MNCC_F_KEYPAD)
+		print_keypad(msg->keypad);
+	if (msg->fields & MNCC_F_FACILITY)
+		print_facility(&msg->facility);
+	if (msg->fields & MNCC_F_SSVERSION)
+		print_ssver(&msg->ssversion);
+}
+
+static void
+send_connect_ack()
+{
+	struct gsm_mncc ack;
+
+	printf("Sending connect ack\n");
+	bzero(&ack, sizeof(struct gsm_mncc));
+	ack.msg_type = MNCC_SETUP_COMPL_REQ;
+	ack.callref = 1;
+	send_mncc_to_gsm(&ack, sizeof(struct gsm_mncc));
+}
+
+static void
+handle_signaling_msg(msg, msglen)
+	struct gsm_mncc *msg;
+	unsigned msglen;
+{
+	if (msglen != sizeof(struct gsm_mncc)) {
+		fprintf(stderr,
+			"error: Rx MNCC message type 0x%x has wrong length\n",
+			msg->msg_type);
+		exit(1);
+	}
+	if (msg->callref != 1) {
+		fprintf(stderr,
+	"error: Rx MNCC message type 0x%x has unexpected callref 0x%x\n",
+			msg->msg_type, msg->callref);
+		exit(1);
+	}
+	switch (msg->msg_type) {
+	case MNCC_SETUP_CNF:
+		printf("MNCC_SETUP_CNF: call is answered\n");
+		print_fields(msg);
+		send_connect_ack();
+		return;
+	case MNCC_CALL_CONF_IND:
+		printf("MNCC_CALL_CONF_IND: call is confirmed\n");
+		print_fields(msg);
+		return;
+	case MNCC_ALERT_IND:
+		printf("MNCC_ALERT_IND: call is alerting\n");
+		print_fields(msg);
+		return;
+	case MNCC_NOTIFY_IND:
+		printf("NNCC_NOTIFY_IND: NOTIFY byte from MS: 0x%02X\n",
+			msg->notify);
+		return;
+	case MNCC_DISC_IND:
+		printf("MNCC_DISC_IND: MS initiates disconnect\n");
+		print_fields(msg);
+		disconnect_mode = 1;
+		printf("Responding with release request\n");
+		msg->msg_type = MNCC_REL_REQ;
+		send_mncc_to_gsm(msg, sizeof(struct gsm_mncc));
+		return;
+	case MNCC_FACILITY_IND:
+		printf("MNCC_FACILITY_IND: call-related SS from MS\n");
+		print_fields(msg);
+		return;
+	case MNCC_START_DTMF_IND:
+		printf("MNCC_START_DTMF_IND: MS sending DTMF start\n");
+		print_fields(msg);
+		msg->msg_type = MNCC_START_DTMF_REJ;
+		mncc_set_cause(msg, GSM48_CAUSE_LOC_PRN_S_LU,
+				GSM48_CC_CAUSE_SERV_OPT_UNIMPL);
+		send_mncc_to_gsm(msg, sizeof(struct gsm_mncc));
+		return;
+	case MNCC_STOP_DTMF_IND:
+		printf("MNCC_STOP_DTMF_IND: MS sending DTMF stop\n");
+		msg->msg_type = MNCC_STOP_DTMF_RSP;
+		send_mncc_to_gsm(msg, sizeof(struct gsm_mncc));
+		return;
+	case MNCC_MODIFY_IND:
+		printf("MNCC_MODIFY_IND: MS requests call modification\n");
+		print_fields(msg);
+		msg->msg_type = MNCC_MODIFY_REJ;
+		mncc_set_cause(msg, GSM48_CAUSE_LOC_PRN_S_LU,
+				GSM48_CC_CAUSE_SERV_OPT_UNIMPL);
+		send_mncc_to_gsm(msg, sizeof(struct gsm_mncc));
+		return;
+	case MNCC_HOLD_IND:
+		printf("MNCC_HOLD_IND: MS requests call hold\n");
+		msg->msg_type = MNCC_HOLD_REJ;
+		mncc_set_cause(msg, GSM48_CAUSE_LOC_PRN_S_LU,
+				GSM48_CC_CAUSE_SERV_OPT_UNIMPL);
+		send_mncc_to_gsm(msg, sizeof(struct gsm_mncc));
+		return;
+	case MNCC_RETRIEVE_IND:
+		printf("MNCC_RETRIEVE_IND: MS requests call retrieve\n");
+		msg->msg_type = MNCC_RETRIEVE_REJ;
+		mncc_set_cause(msg, GSM48_CAUSE_LOC_PRN_S_LU,
+				GSM48_CC_CAUSE_SERV_OPT_UNIMPL);
+		send_mncc_to_gsm(msg, sizeof(struct gsm_mncc));
+		return;
+	case MNCC_USERINFO_IND:
+		printf("MNCC_USERINFO_IND: user-user info\n");
+		print_fields(msg);
+		return;
+	case MNCC_REL_IND:
+		printf("MNCC_REL_IND: final release\n");
+		print_fields(msg);
+		exit(0);
+	case MNCC_REL_CNF:
+		printf("MNCC_REL_CNF: final release in response to request\n");
+		print_fields(msg);
+		exit(0);
+	case MNCC_REJ_IND:
+		printf("MNCC_REJ_IND: MT call rejected\n");
+		print_fields(msg);
+		exit(0);
+	}
+}
+
+static void
+handle_rtp_create(msg, msglen)
+	struct gsm_mncc_rtp *msg;
+	unsigned msglen;
+{
+	if (msglen != sizeof(struct gsm_mncc_rtp)) {
+		fprintf(stderr,
+			"error: Rx MNCC message type 0x%x has wrong length\n",
+			msg->msg_type);
+		exit(1);
+	}
+	if (msg->callref != 1) {
+		fprintf(stderr,
+	"error: Rx MNCC message type 0x%x has unexpected callref 0x%x\n",
+			msg->msg_type, msg->callref);
+		exit(1);
+	}
+	printf("MNCC_RTP_CREATE: RTP info from MSC\n");
+	printf("payload_type=0x%x payload_msg_type=0x%x\n", msg->payload_type,
+		msg->payload_msg_type);
+}
+
+void
+msg_from_mncc(msg, msglen)
+	union mncc_msg *msg;
+	unsigned msglen;
+{
+	switch (msg->msg_type) {
+	case MNCC_SETUP_CNF:
+	case MNCC_CALL_CONF_IND:
+	case MNCC_ALERT_IND:
+	case MNCC_NOTIFY_IND:
+	case MNCC_DISC_IND:
+	case MNCC_FACILITY_IND:
+	case MNCC_START_DTMF_IND:
+	case MNCC_STOP_DTMF_IND:
+	case MNCC_MODIFY_IND:
+	case MNCC_HOLD_IND:
+	case MNCC_RETRIEVE_IND:
+	case MNCC_USERINFO_IND:
+	case MNCC_REL_IND:
+	case MNCC_REL_CNF:
+	case MNCC_REJ_IND:
+		handle_signaling_msg(msg, msglen);
+		return;
+	case MNCC_RTP_CREATE:
+		handle_rtp_create(msg, msglen);
+		return;
+	default:
+		fprintf(stderr,
+			"error: received unexpected MNCC message type 0x%x\n",
+			msg->msg_type);
+		exit(1);
+	}
+}
diff -r b13acb024fc6 -r cc0e1c6e33c3 mtctest/sock_conn.c
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtctest/sock_conn.c	Tue Jun 28 18:25:28 2022 -0800
@@ -0,0 +1,61 @@
+/*
+ * In this module we implement our connection to the MNCC daemon's
+ * mtcall socket.
+ */
+
+#include <sys/types.h>
+#include <sys/socket.h>
+#include <sys/un.h>
+#include <stdio.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include "../include/mncc.h"
+
+static char mtcall_socket_pathname[] = "/var/gsm/mtcall_socket";
+
+int mtc_socket;
+
+connect_mtc_socket()
+{
+	struct sockaddr_un sa;
+	unsigned sa_len;
+	int rc;
+
+	mtc_socket = socket(AF_UNIX, SOCK_SEQPACKET, 0);
+	if (mtc_socket < 0) {
+		perror("socket(AF_UNIX, SOCK_SEQPACKET, 0)");
+		exit(1);
+	}
+	fill_sockaddr_un(mtcall_socket_pathname, &sa, &sa_len);
+	rc = connect(mtc_socket, (struct sockaddr *) &sa, sa_len);
+	if (rc < 0) {
+		perror(mtcall_socket_pathname);
+		exit(1);
+	}
+	return(0);
+}
+
+void
+mtc_socket_select()
+{
+	union mncc_msg msg;
+	int rc;
+
+	rc = recv(mtc_socket, &msg, sizeof msg, 0);
+	if (rc < 0) {
+		perror("read from socket");
+		exit(1);
+	}
+	if (rc < 4) {
+		fprintf(stderr, "short read from socket: %d bytes", rc);
+		exit(1);
+	}
+	msg_from_mncc(&msg, rc);
+}
+
+send_mncc_to_gsm(msg, msglen)
+	union mncc_msg *msg;
+	unsigned msglen;
+{
+	return send(mtc_socket, msg, msglen, 0);
+}