2 * (C) 2010 by Andreas Eversberg <jolly@eversberg.eu>
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 2 of the License, or
9 * (at your option) any later version.
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
16 * You should have received a copy of the GNU General Public License along
17 * with this program; if not, write to the Free Software Foundation, Inc.,
18 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
28 #include <osmocore/msgb.h>
29 #include <osmocore/utils.h>
30 #include <osmocore/gsm48.h>
31 #include <osmocore/talloc.h>
33 #include <osmocom/logging.h>
34 #include <osmocom/osmocom_data.h>
35 #include <osmocom/mncc.h>
36 #include <osmocom/transaction.h>
37 #include <osmocom/gsm48_cc.h>
41 static int gsm48_cc_tx_release(struct gsm_trans *trans, void *arg);
42 static int gsm48_rel_null_free(struct gsm_trans *trans);
43 int mncc_release_ind(struct osmocom_ms *ms, struct gsm_trans *trans,
44 u_int32_t callref, int location, int value);
45 static int gsm48_cc_tx_disconnect(struct gsm_trans *trans, void *arg);
46 static int gsm48_cc_tx_connect_ack(struct gsm_trans *trans, void *arg);
52 int gsm48_cc_init(struct osmocom_ms *ms)
54 struct gsm48_cclayer *cc = &ms->cclayer;
58 if (!cc->mncc_upqueue.next == 0)
61 LOGP(DCC, LOGL_INFO, "init Call Control\n");
63 INIT_LLIST_HEAD(&cc->mncc_upqueue);
68 int gsm48_cc_exit(struct osmocom_ms *ms)
70 struct gsm48_cclayer *cc = &ms->cclayer;
71 struct gsm_trans *trans, *trans2;
74 LOGP(DCC, LOGL_INFO, "exit Call Control processes for %s\n", ms->name);
76 llist_for_each_entry_safe(trans, trans2, &ms->trans_list, entry) {
77 if (trans->protocol == GSM48_PDISC_CC)
78 LOGP(DCC, LOGL_NOTICE, "Free pendig CC-transaction.\n");
82 while ((msg = msgb_dequeue(&cc->mncc_upqueue)))
92 /* names of MNCC-SAP */
93 static const struct value_string gsm_mncc_names[] = {
94 { MNCC_SETUP_REQ, "MNCC_SETUP_REQ" },
95 { MNCC_SETUP_IND, "MNCC_SETUP_IND" },
96 { MNCC_SETUP_RSP, "MNCC_SETUP_RSP" },
97 { MNCC_SETUP_CNF, "MNCC_SETUP_CNF" },
98 { MNCC_SETUP_COMPL_REQ, "MNCC_SETUP_COMPL_REQ" },
99 { MNCC_SETUP_COMPL_IND, "MNCC_SETUP_COMPL_IND" },
100 { MNCC_CALL_CONF_IND, "MNCC_CALL_CONF_IND" },
101 { MNCC_CALL_PROC_REQ, "MNCC_CALL_PROC_REQ" },
102 { MNCC_PROGRESS_REQ, "MNCC_PROGRESS_REQ" },
103 { MNCC_ALERT_REQ, "MNCC_ALERT_REQ" },
104 { MNCC_ALERT_IND, "MNCC_ALERT_IND" },
105 { MNCC_NOTIFY_REQ, "MNCC_NOTIFY_REQ" },
106 { MNCC_NOTIFY_IND, "MNCC_NOTIFY_IND" },
107 { MNCC_DISC_REQ, "MNCC_DISC_REQ" },
108 { MNCC_DISC_IND, "MNCC_DISC_IND" },
109 { MNCC_REL_REQ, "MNCC_REL_REQ" },
110 { MNCC_REL_IND, "MNCC_REL_IND" },
111 { MNCC_REL_CNF, "MNCC_REL_CNF" },
112 { MNCC_FACILITY_REQ, "MNCC_FACILITY_REQ" },
113 { MNCC_FACILITY_IND, "MNCC_FACILITY_IND" },
114 { MNCC_START_DTMF_IND, "MNCC_START_DTMF_IND" },
115 { MNCC_START_DTMF_RSP, "MNCC_START_DTMF_RSP" },
116 { MNCC_START_DTMF_REJ, "MNCC_START_DTMF_REJ" },
117 { MNCC_STOP_DTMF_IND, "MNCC_STOP_DTMF_IND" },
118 { MNCC_STOP_DTMF_RSP, "MNCC_STOP_DTMF_RSP" },
119 { MNCC_MODIFY_REQ, "MNCC_MODIFY_REQ" },
120 { MNCC_MODIFY_IND, "MNCC_MODIFY_IND" },
121 { MNCC_MODIFY_RSP, "MNCC_MODIFY_RSP" },
122 { MNCC_MODIFY_CNF, "MNCC_MODIFY_CNF" },
123 { MNCC_MODIFY_REJ, "MNCC_MODIFY_REJ" },
124 { MNCC_HOLD_IND, "MNCC_HOLD_IND" },
125 { MNCC_HOLD_CNF, "MNCC_HOLD_CNF" },
126 { MNCC_HOLD_REJ, "MNCC_HOLD_REJ" },
127 { MNCC_RETRIEVE_IND, "MNCC_RETRIEVE_IND" },
128 { MNCC_RETRIEVE_CNF, "MNCC_RETRIEVE_CNF" },
129 { MNCC_RETRIEVE_REJ, "MNCC_RETRIEVE_REJ" },
130 { MNCC_USERINFO_REQ, "MNCC_USERINFO_REQ" },
131 { MNCC_USERINFO_IND, "MNCC_USERINFO_IND" },
132 { MNCC_REJ_REQ, "MNCC_REJ_REQ" },
133 { MNCC_REJ_IND, "MNCC_REJ_IND" },
134 { MNCC_PROGRESS_IND, "MNCC_PROGRESS_IND" },
135 { MNCC_CALL_PROC_IND, "MNCC_CALL_PROC_IND" },
136 { MNCC_CALL_CONF_REQ, "MNCC_CALL_CONF_REQ" },
137 { MNCC_START_DTMF_REQ, "MNCC_START_DTMF_REQ" },
138 { MNCC_STOP_DTMF_REQ, "MNCC_STOP_DTMF_REQ" },
139 { MNCC_HOLD_REQ, "MNCC_HOLD_REQ " },
140 { MNCC_RETRIEVE_REQ, "MNCC_RETRIEVE_REQ" },
144 const char *get_mncc_name(int value)
146 return get_value_string(gsm_mncc_names, value);
149 /* push MMCC header and send to MM */
150 static int gsm48_cc_to_mm(struct msgb *msg, struct gsm_trans *trans,
153 struct gsm48_hdr *gh = msgb_l3(msg);
154 struct gsm48_mmxx_hdr *mmh;
157 /* Add protocol type and transaction ID */
158 gh->proto_discr = trans->protocol | (trans->transaction_id << 4);
160 /* indicate emergency setup to MM layer */
161 if (gh->msg_type == GSM48_MT_CC_EMERG_SETUP)
165 msgb_push(msg, sizeof(struct gsm48_mmxx_hdr));
166 mmh = (struct gsm48_mmxx_hdr *)msg->data;
167 mmh->msg_type = msg_type;
168 mmh->ref = trans->callref;
169 mmh->transaction_id = trans->transaction_id;
170 mmh->emergency = emergency;
172 /* send message to MM */
173 LOGP(DCC, LOGL_INFO, "Sending '%s' using %s (callref=%x, "
174 "transaction_id=%d)\n", gsm48_cc_msg_name(gh->msg_type),
175 get_mmxx_name(msg_type), trans->callref, trans->transaction_id);
176 return gsm48_mmxx_downmsg(trans->ms, msg);
179 /* enqueue message to application (MNCC-SAP) */
180 static int mncc_recvmsg(struct osmocom_ms *ms, struct gsm_trans *trans,
181 int msg_type, struct gsm_mncc *mncc)
183 struct gsm48_cclayer *cc = &ms->cclayer;
187 LOGP(DCC, LOGL_INFO, "(ms %s ti %x) Sending '%s' to MNCC.\n",
188 ms->name, trans->transaction_id,
189 get_mncc_name(msg_type));
191 LOGP(DCC, LOGL_INFO, "(ms %s ti -) Sending '%s' to MNCC.\n",
192 ms->name, get_mncc_name(msg_type));
194 mncc->msg_type = msg_type;
196 msg = msgb_alloc(sizeof(struct gsm_mncc), "MNCC");
199 memcpy(msg->data, mncc, sizeof(struct gsm_mncc));
200 msgb_enqueue(&cc->mncc_upqueue, msg);
205 /* dequeue messages to layer 4 */
206 int mncc_dequeue(struct osmocom_ms *ms)
208 struct gsm48_cclayer *cc = &ms->cclayer;
209 struct gsm_mncc *mncc;
213 while ((msg = msgb_dequeue(&cc->mncc_upqueue))) {
214 mncc = (struct gsm_mncc *)msg->data;
216 cc->mncc_recv(ms, mncc->msg_type, mncc);
217 work = 1; /* work done */
229 static void new_cc_state(struct gsm_trans *trans, int state)
231 if (state > 31 || state < 0)
234 DEBUGP(DCC, "new state %s -> %s\n",
235 gsm48_cc_state_name(trans->cc.state),
236 gsm48_cc_state_name(state));
238 trans->cc.state = state;
245 /* timeout events of all timers */
246 static void gsm48_cc_timeout(void *arg)
248 struct gsm_trans *trans = arg;
249 int disconnect = 0, release = 0, abort = 1;
250 int mo_cause = GSM48_CC_CAUSE_RECOVERY_TIMER;
251 int mo_location = GSM48_CAUSE_LOC_PRN_S_LU;
252 int l4_cause = GSM48_CC_CAUSE_NORMAL_UNSPEC;
253 int l4_location = GSM48_CAUSE_LOC_PRN_S_LU;
254 struct gsm_mncc mo_rel, l4_rel;
256 memset(&mo_rel, 0, sizeof(struct gsm_mncc));
257 mo_rel.callref = trans->callref;
258 memset(&l4_rel, 0, sizeof(struct gsm_mncc));
259 l4_rel.callref = trans->callref;
261 LOGP(DCC, LOGL_INFO, "Timer T%x has fired.\n", trans->cc.Tcurrent);
263 switch(trans->cc.Tcurrent) {
265 /* abort if connection is not already esablished */
266 if (trans->cc.state == GSM_CSTATE_MM_CONNECTION_PEND)
270 l4_cause = GSM48_CC_CAUSE_USER_NOTRESPOND;
274 mo_cause = trans->cc.msg.cause.value;
275 mo_location = trans->cc.msg.cause.location;
278 if (!trans->cc.T308_second) {
279 /* restart T308 a second time */
280 gsm48_cc_tx_release(trans, &trans->cc.msg);
281 trans->cc.T308_second = 1;
282 break; /* stay in release state */
284 /* release MM conn, got NULL state, free trans */
285 gsm48_rel_null_free(trans);
290 l4_cause = GSM48_CC_CAUSE_USER_NOTRESPOND;
294 /* unknown, did not find it in the specs */
300 if ((release || abort) && trans->callref) {
301 /* process release towards layer 4 */
302 mncc_release_ind(trans->ms, trans, trans->callref,
303 l4_location, l4_cause);
306 if (disconnect && trans->callref) {
307 /* process disconnect towards layer 4 */
308 mncc_set_cause(&l4_rel, l4_location, l4_cause);
309 mncc_recvmsg(trans->ms, trans, MNCC_DISC_IND, &l4_rel);
312 /* process disconnect towards mobile station */
313 if (disconnect || release || abort) {
314 mncc_set_cause(&mo_rel, mo_location, mo_cause);
315 mo_rel.cause.diag[0] =
316 ((trans->cc.Tcurrent & 0xf00) >> 8) + '0';
317 mo_rel.cause.diag[1] =
318 ((trans->cc.Tcurrent & 0x0f0) >> 4) + '0';
319 mo_rel.cause.diag[2] = (trans->cc.Tcurrent & 0x00f) + '0';
320 mo_rel.cause.diag_len = 3;
323 gsm48_cc_tx_disconnect(trans, &mo_rel);
325 gsm48_cc_tx_release(trans, &mo_rel);
327 /* release MM conn, got NULL state, free trans */
328 gsm48_rel_null_free(trans);
333 /* start various timers */
334 static void gsm48_start_cc_timer(struct gsm_trans *trans, int current,
337 LOGP(DCC, LOGL_INFO, "starting timer T%x with %d seconds\n", current,
339 trans->cc.timer.cb = gsm48_cc_timeout;
340 trans->cc.timer.data = trans;
341 bsc_schedule_timer(&trans->cc.timer, sec, micro);
342 trans->cc.Tcurrent = current;
345 /* stop various timers */
346 static void gsm48_stop_cc_timer(struct gsm_trans *trans)
348 if (bsc_timer_pending(&trans->cc.timer)) {
349 LOGP(DCC, LOGL_INFO, "stopping pending timer T%x\n",
351 bsc_del_timer(&trans->cc.timer);
352 trans->cc.Tcurrent = 0;
357 * process handlers (misc)
360 /* Call Control Specific transaction release.
361 * gets called by trans_free, DO NOT CALL YOURSELF!
363 void _gsm48_cc_trans_free(struct gsm_trans *trans)
365 gsm48_stop_cc_timer(trans);
367 /* send release to L4, if callref still exists */
368 if (trans->callref) {
369 /* Ressource unavailable */
370 mncc_release_ind(trans->ms, trans, trans->callref,
371 GSM48_CAUSE_LOC_PRN_S_LU,
372 GSM48_CC_CAUSE_RESOURCE_UNAVAIL);
374 if (trans->cc.state != GSM_CSTATE_NULL)
375 new_cc_state(trans, GSM_CSTATE_NULL);
378 /* release MM connection, go NULL state, free transaction */
379 static int gsm48_rel_null_free(struct gsm_trans *trans)
383 /* release MM connection */
384 nmsg = gsm48_mmxx_msgb_alloc(GSM48_MMCC_REL_REQ, trans->callref,
385 trans->transaction_id);
388 LOGP(DCC, LOGL_INFO, "Sending MMCC_REL_REQ\n");
389 gsm48_mmxx_downmsg(trans->ms, nmsg);
391 new_cc_state(trans, GSM_CSTATE_NULL);
399 void mncc_set_cause(struct gsm_mncc *data, int loc, int val)
401 data->fields |= MNCC_F_CAUSE;
402 data->cause.location = loc;
403 data->cause.value = val;
406 /* send release indication to upper layer */
407 int mncc_release_ind(struct osmocom_ms *ms, struct gsm_trans *trans,
408 u_int32_t callref, int location, int value)
412 memset(&rel, 0, sizeof(rel));
413 rel.callref = callref;
414 mncc_set_cause(&rel, location, value);
415 return mncc_recvmsg(ms, trans, MNCC_REL_IND, &rel);
418 /* sending status message in response to unknown message */
419 static int gsm48_cc_tx_status(struct gsm_trans *trans, int cause)
422 struct gsm48_hdr *gh;
423 uint8_t *cause_ie, *call_state_ie;
425 LOGP(DCC, LOGL_INFO, "sending STATUS (cause %d)\n", cause);
427 nmsg = gsm48_l3_msgb_alloc();
430 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
432 gh->msg_type = GSM48_MT_CC_STATUS;
434 cause_ie = msgb_put(nmsg, 3);
436 cause_ie[1] = GSM48_CAUSE_CS_GSM | GSM48_CAUSE_LOC_PRN_S_LU;
437 cause_ie[2] = 0x80 | cause;
439 call_state_ie = msgb_put(nmsg, 1);
440 call_state_ie[0] = 0xc0 | trans->cc.state;
442 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
445 /* reply status enquiry */
446 static int gsm48_cc_rx_status_enq(struct gsm_trans *trans, struct msgb *msg)
448 LOGP(DCC, LOGL_INFO, "received STATUS ENQUIREY\n");
450 return gsm48_cc_tx_status(trans, GSM48_CC_CAUSE_RESP_STATUS_INQ);
454 * process handlers (mobile originating call establish)
457 /* on SETUP request from L4, init MM connection */
458 static int gsm48_cc_init_mm(struct gsm_trans *trans, void *arg)
461 struct gsm_mncc *data = arg;
462 struct gsm48_mmxx_hdr *nmmh;
464 /* store setup message */
465 memcpy(&trans->cc.msg, data, sizeof(struct gsm_mncc));
467 new_cc_state(trans, GSM_CSTATE_MM_CONNECTION_PEND);
469 /* establish MM connection */
470 nmsg = gsm48_mmxx_msgb_alloc(GSM48_MMCC_EST_REQ, trans->callref,
471 trans->transaction_id);
474 nmmh = (struct gsm48_mmxx_hdr *) nmsg->data;
477 LOGP(DCC, LOGL_INFO, "Sending MMCC_EST_REQ\n");
478 return gsm48_mmxx_downmsg(trans->ms, nmsg);
481 /* abort connection prior SETUP */
482 static int gsm48_cc_abort_mm(struct gsm_trans *trans, void *arg)
486 /* abort MM connection */
487 nmsg = gsm48_mmxx_msgb_alloc(GSM48_MMCC_REL_REQ, trans->callref,
488 trans->transaction_id);
491 LOGP(DCC, LOGL_INFO, "Sending MMCC_REL_REQ\n");
492 gsm48_mmxx_downmsg(trans->ms, nmsg);
494 new_cc_state(trans, GSM_CSTATE_NULL);
502 /* setup message from upper layer */
503 static int gsm48_cc_tx_setup(struct gsm_trans *trans)
506 struct gsm48_hdr *gh;
507 struct gsm_mncc *setup = &trans->cc.msg;
508 int rc, transaction_id;
511 LOGP(DCC, LOGL_INFO, "sending SETUP\n");
513 nmsg = gsm48_l3_msgb_alloc();
516 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
518 /* transaction id must not be assigned */
519 if (trans->transaction_id != 0xff) { /* unasssigned */
520 LOGP(DCC, LOGL_NOTICE, "TX Setup with assigned transaction. "
521 "This is not allowed!\n");
522 /* Temporarily out of order */
523 rc = mncc_release_ind(trans->ms, trans, trans->callref,
524 GSM48_CAUSE_LOC_PRN_S_LU,
525 GSM48_CC_CAUSE_NORMAL_UNSPEC);
531 /* Get free transaction_id */
532 transaction_id = trans_assign_trans_id(trans->ms, GSM48_PDISC_CC, 0);
533 if (transaction_id < 0) {
534 /* no free transaction ID */
535 rc = mncc_release_ind(trans->ms, trans, trans->callref,
536 GSM48_CAUSE_LOC_PRN_S_LU,
537 GSM48_CC_CAUSE_RESOURCE_UNAVAIL);
542 trans->transaction_id = transaction_id;
544 gh->msg_type = (setup->emergency) ? GSM48_MT_CC_EMERG_SETUP :
547 /* actually we have to start it when CM SERVICE REQUEST has been sent,
548 * but there is no primitive for that defined. i think it is ok to
549 * do it here rather than inventing MMCC-NOTIFY-IND.
551 gsm48_start_cc_timer(trans, 0x303, GSM48_T303_MS);
553 if (!setup->emergency) {
554 /* bearer capability */
555 gsm48_encode_bearer_cap(nmsg, 0, &setup->bearer_cap);
557 if (setup->fields & MNCC_F_FACILITY)
558 gsm48_encode_facility(nmsg, 0, &setup->facility);
559 /* called party BCD number */
560 if (setup->fields & MNCC_F_CALLED)
561 gsm48_encode_called(nmsg, &setup->called);
563 if (setup->fields & MNCC_F_USERUSER)
564 gsm48_encode_useruser(nmsg, 0, &setup->useruser);
566 if (setup->fields & MNCC_F_SSVERSION)
567 gsm48_encode_ssversion(nmsg, &setup->ssversion);
568 /* CLIR suppression */
569 if (setup->clir.sup) {
570 ie = msgb_put(nmsg, 1);
571 ie[0] = GSM48_IE_CLIR_SUPP;
573 /* CLIR invocation */
574 if (setup->clir.inv) {
575 ie = msgb_put(nmsg, 1);
576 ie[0] = GSM48_IE_CLIR_INVOC;
579 if (setup->fields & MNCC_F_CCCAP)
580 gsm48_encode_cccap(nmsg, &setup->cccap);
583 /* actually MM CONNECTION PENDING */
584 new_cc_state(trans, GSM_CSTATE_INITIATED);
586 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
589 /* progress is received from lower layer */
590 static int gsm48_cc_rx_progress(struct gsm_trans *trans, struct msgb *msg)
592 struct gsm48_hdr *gh = msgb_l3(msg);
593 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
594 struct tlv_parsed tp;
595 struct gsm_mncc progress;
597 LOGP(DCC, LOGL_INFO, "received PROGRESS\n");
599 memset(&progress, 0, sizeof(struct gsm_mncc));
600 progress.callref = trans->callref;
601 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len,
602 GSM48_IE_PROGR_IND, 0);
604 if (TLVP_PRESENT(&tp, GSM48_IE_PROGR_IND)) {
605 progress.fields |= MNCC_F_PROGRESS;
606 gsm48_decode_progress(&progress.progress,
607 TLVP_VAL(&tp, GSM48_IE_PROGR_IND)-1);
608 /* store last progress indicator */
609 trans->cc.prog_ind = progress.progress.descr;
612 if (TLVP_PRESENT(&tp, GSM48_IE_USER_USER)) {
613 progress.fields |= MNCC_F_USERUSER;
614 gsm48_decode_useruser(&progress.useruser,
615 TLVP_VAL(&tp, GSM48_IE_USER_USER)-1);
618 return mncc_recvmsg(trans->ms, trans, MNCC_PROGRESS_IND, &progress);
621 /* call proceeding is received from lower layer */
622 static int gsm48_cc_rx_call_proceeding(struct gsm_trans *trans,
625 struct gsm48_hdr *gh = msgb_l3(msg);
626 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
627 struct tlv_parsed tp;
628 struct gsm_mncc call_proc;
630 LOGP(DCC, LOGL_INFO, "sending CALL PROCEEDING\n");
632 gsm48_stop_cc_timer(trans);
634 memset(&call_proc, 0, sizeof(struct gsm_mncc));
635 call_proc.callref = trans->callref;
636 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len, 0, 0);
639 if (TLVP_PRESENT(&tp, GSM48_IE_REPEAT_CIR))
640 call_conf.repeat = 1;
641 if (TLVP_PRESENT(&tp, GSM48_IE_REPEAT_SEQ))
642 call_conf.repeat = 2;
644 /* bearer capability */
645 if (TLVP_PRESENT(&tp, GSM48_IE_BEARER_CAP)) {
646 call_proc.fields |= MNCC_F_BEARER_CAP;
647 gsm48_decode_bearer_cap(&call_proc.bearer_cap,
648 TLVP_VAL(&tp, GSM48_IE_BEARER_CAP)-1);
651 if (TLVP_PRESENT(&tp, GSM48_IE_FACILITY)) {
652 call_proc.fields |= MNCC_F_FACILITY;
653 gsm48_decode_facility(&call_proc.facility,
654 TLVP_VAL(&tp, GSM48_IE_FACILITY)-1);
658 if (TLVP_PRESENT(&tp, GSM48_IE_PROGR_IND)) {
659 call_proc.fields |= MNCC_F_PROGRESS;
660 gsm48_decode_progress(&call_proc.progress,
661 TLVP_VAL(&tp, GSM48_IE_PROGR_IND)-1);
662 /* store last progress indicator */
663 trans->cc.prog_ind = call_proc.progress.descr;
666 /* start T310, if last progress indicator was 1 or 2 or 64 */
667 if (trans->cc.prog_ind == 1
668 || trans->cc.prog_ind == 2
669 || trans->cc.prog_ind == 64)
670 gsm48_start_cc_timer(trans, 0x310, GSM48_T310_MS);
672 new_cc_state(trans, GSM_CSTATE_MO_CALL_PROC);
674 return mncc_recvmsg(trans->ms, trans, MNCC_CALL_PROC_IND,
678 /* alerting is received by the lower layer */
679 static int gsm48_cc_rx_alerting(struct gsm_trans *trans, struct msgb *msg)
681 struct gsm48_hdr *gh = msgb_l3(msg);
682 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
683 struct tlv_parsed tp;
684 struct gsm_mncc alerting;
686 LOGP(DCC, LOGL_INFO, "sending ALERTING\n");
688 gsm48_stop_cc_timer(trans);
689 /* no T301 in MS call control */
691 memset(&alerting, 0, sizeof(struct gsm_mncc));
692 alerting.callref = trans->callref;
693 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len, 0, 0);
695 if (TLVP_PRESENT(&tp, GSM48_IE_FACILITY)) {
696 alerting.fields |= MNCC_F_FACILITY;
697 gsm48_decode_facility(&alerting.facility,
698 TLVP_VAL(&tp, GSM48_IE_FACILITY)-1);
702 if (TLVP_PRESENT(&tp, GSM48_IE_PROGR_IND)) {
703 alerting.fields |= MNCC_F_PROGRESS;
704 gsm48_decode_progress(&alerting.progress,
705 TLVP_VAL(&tp, GSM48_IE_PROGR_IND)-1);
708 if (TLVP_PRESENT(&tp, GSM48_IE_USER_USER)) {
709 alerting.fields |= MNCC_F_USERUSER;
710 gsm48_decode_useruser(&alerting.useruser,
711 TLVP_VAL(&tp, GSM48_IE_USER_USER)-1);
714 new_cc_state(trans, GSM_CSTATE_CALL_DELIVERED);
716 return mncc_recvmsg(trans->ms, trans, MNCC_ALERT_IND,
720 /* connect is received from lower layer */
721 static int gsm48_cc_rx_connect(struct gsm_trans *trans, struct msgb *msg)
723 struct gsm48_hdr *gh = msgb_l3(msg);
724 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
725 struct tlv_parsed tp;
726 struct gsm_mncc connect;
728 LOGP(DCC, LOGL_INFO, "received CONNECT\n");
730 gsm48_stop_cc_timer(trans);
732 memset(&connect, 0, sizeof(struct gsm_mncc));
733 connect.callref = trans->callref;
734 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len, 0, 0);
736 if (TLVP_PRESENT(&tp, GSM48_IE_FACILITY)) {
737 connect.fields |= MNCC_F_FACILITY;
738 gsm48_decode_facility(&connect.facility,
739 TLVP_VAL(&tp, GSM48_IE_FACILITY)-1);
742 if (TLVP_PRESENT(&tp, GSM48_IE_CONN_BCD)) {
743 connect.fields |= MNCC_F_CONNECTED;
744 gsm48_decode_connected(&connect.connected,
745 TLVP_VAL(&tp, GSM48_IE_CONN_BCD)-1);
748 if (TLVP_PRESENT(&tp, GSM48_IE_PROGR_IND)) {
749 connect.fields |= MNCC_F_PROGRESS;
750 gsm48_decode_progress(&connect.progress,
751 TLVP_VAL(&tp, GSM48_IE_PROGR_IND)-1);
754 if (TLVP_PRESENT(&tp, GSM48_IE_USER_USER)) {
755 connect.fields |= MNCC_F_USERUSER;
756 gsm48_decode_useruser(&connect.useruser,
757 TLVP_VAL(&tp, GSM48_IE_USER_USER)-1);
760 /* ACTIVE state is set during this: */
761 gsm48_cc_tx_connect_ack(trans, NULL);
763 return mncc_recvmsg(trans->ms, trans, MNCC_SETUP_CNF, &connect);
766 /* connect ack message from upper layer */
767 static int gsm48_cc_tx_connect_ack(struct gsm_trans *trans, void *arg)
770 struct gsm48_hdr *gh;
772 LOGP(DCC, LOGL_INFO, "sending CONNECT ACKNOWLEDGE\n");
774 nmsg = gsm48_l3_msgb_alloc();
777 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
779 gh->msg_type = GSM48_MT_CC_CONNECT_ACK;
781 new_cc_state(trans, GSM_CSTATE_ACTIVE);
783 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
787 * process handlers (mobile terminating call establish)
790 /* setup is received from lower layer */
791 static int gsm48_cc_rx_setup(struct gsm_trans *trans, struct msgb *msg)
793 struct gsm48_hdr *gh = msgb_l3(msg);
794 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
795 struct tlv_parsed tp;
796 struct gsm_mncc setup;
798 LOGP(DCC, LOGL_INFO, "sending SETUP\n");
800 memset(&setup, 0, sizeof(struct gsm_mncc));
801 setup.callref = trans->callref;
802 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len, 0, 0);
804 /* bearer capability */
805 if (TLVP_PRESENT(&tp, GSM48_IE_BEARER_CAP)) {
806 setup.fields |= MNCC_F_BEARER_CAP;
807 gsm48_decode_bearer_cap(&setup.bearer_cap,
808 TLVP_VAL(&tp, GSM48_IE_BEARER_CAP)-1);
811 if (TLVP_PRESENT(&tp, GSM48_IE_FACILITY)) {
812 setup.fields |= MNCC_F_FACILITY;
813 gsm48_decode_facility(&setup.facility,
814 TLVP_VAL(&tp, GSM48_IE_FACILITY)-1);
817 if (TLVP_PRESENT(&tp, GSM48_IE_PROGR_IND)) {
818 setup.fields |= MNCC_F_PROGRESS;
819 gsm48_decode_progress(&setup.progress,
820 TLVP_VAL(&tp, GSM48_IE_PROGR_IND)-1);
823 if (TLVP_PRESENT(&tp, GSM48_IE_SIGNAL)) {
824 setup.fields |= MNCC_F_SIGNAL;
825 gsm48_decode_signal(&setup.signal,
826 TLVP_VAL(&tp, GSM48_IE_SIGNAL)-1);
828 /* calling party bcd number */
829 if (TLVP_PRESENT(&tp, GSM48_IE_CALLING_BCD)) {
830 setup.fields |= MNCC_F_CALLING;
831 gsm48_decode_calling(&setup.calling,
832 TLVP_VAL(&tp, GSM48_IE_CALLING_BCD)-1);
834 /* called party bcd number */
835 if (TLVP_PRESENT(&tp, GSM48_IE_CALLED_BCD)) {
836 setup.fields |= MNCC_F_CALLED;
837 gsm48_decode_called(&setup.called,
838 TLVP_VAL(&tp, GSM48_IE_CALLED_BCD)-1);
840 /* redirecting party bcd number */
841 if (TLVP_PRESENT(&tp, GSM48_IE_REDIR_BCD)) {
842 setup.fields |= MNCC_F_REDIRECTING;
843 gsm48_decode_redirecting(&setup.redirecting,
844 TLVP_VAL(&tp, GSM48_IE_REDIR_BCD)-1);
847 if (TLVP_PRESENT(&tp, GSM48_IE_USER_USER)) {
848 setup.fields |= MNCC_F_USERUSER;
849 gsm48_decode_useruser(&setup.useruser,
850 TLVP_VAL(&tp, GSM48_IE_USER_USER)-1);
853 new_cc_state(trans, GSM_CSTATE_CALL_PRESENT);
855 /* indicate setup to MNCC */
856 mncc_recvmsg(trans->ms, trans, MNCC_SETUP_IND, &setup);
861 /* call conf message from upper layer */
862 static int gsm48_cc_tx_call_conf(struct gsm_trans *trans, void *arg)
864 struct gsm_mncc *confirm = arg;
866 struct gsm48_hdr *gh;
868 LOGP(DCC, LOGL_INFO, "sending CALL CONFIRMED (proceeding)\n");
870 nmsg = gsm48_l3_msgb_alloc();
873 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
875 gh->msg_type = GSM48_MT_CC_CALL_CONF;
877 new_cc_state(trans, GSM_CSTATE_MO_TERM_CALL_CONF);
879 /* bearer capability */
880 if (confirm->fields & MNCC_F_BEARER_CAP)
881 gsm48_encode_bearer_cap(nmsg, 0, &confirm->bearer_cap);
883 if (confirm->fields & MNCC_F_CAUSE)
884 gsm48_encode_cause(nmsg, 0, &confirm->cause);
886 if (confirm->fields & MNCC_F_CCCAP)
887 gsm48_encode_cccap(nmsg, &confirm->cccap);
889 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
892 /* alerting message from upper layer */
893 static int gsm48_cc_tx_alerting(struct gsm_trans *trans, void *arg)
895 struct gsm_mncc *alerting = arg;
897 struct gsm48_hdr *gh;
899 LOGP(DCC, LOGL_INFO, "sending ALERTING\n");
901 nmsg = gsm48_l3_msgb_alloc();
904 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
906 gh->msg_type = GSM48_MT_CC_ALERTING;
909 if (alerting->fields & MNCC_F_FACILITY)
910 gsm48_encode_facility(nmsg, 0, &alerting->facility);
912 if (alerting->fields & MNCC_F_USERUSER)
913 gsm48_encode_useruser(nmsg, 0, &alerting->useruser);
915 if (alerting->fields & MNCC_F_SSVERSION)
916 gsm48_encode_ssversion(nmsg, &alerting->ssversion);
918 new_cc_state(trans, GSM_CSTATE_CALL_RECEIVED);
920 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
923 /* connect message from upper layer */
924 static int gsm48_cc_tx_connect(struct gsm_trans *trans, void *arg)
926 struct gsm_mncc *connect = arg;
928 struct gsm48_hdr *gh;
930 LOGP(DCC, LOGL_INFO, "sending CONNECT\n");
932 nmsg = gsm48_l3_msgb_alloc();
935 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
937 gh->msg_type = GSM48_MT_CC_CONNECT;
939 gsm48_stop_cc_timer(trans);
940 gsm48_start_cc_timer(trans, 0x313, GSM48_T313_MS);
943 if (connect->fields & MNCC_F_FACILITY)
944 gsm48_encode_facility(nmsg, 0, &connect->facility);
946 if (connect->fields & MNCC_F_USERUSER)
947 gsm48_encode_useruser(nmsg, 0, &connect->useruser);
949 if (connect->fields & MNCC_F_SSVERSION)
950 gsm48_encode_ssversion(nmsg, &connect->ssversion);
952 new_cc_state(trans, GSM_CSTATE_CONNECT_REQUEST);
954 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
957 /* connect ack is received from lower layer */
958 static int gsm48_cc_rx_connect_ack(struct gsm_trans *trans, struct msgb *msg)
960 struct gsm_mncc connect_ack;
962 LOGP(DCC, LOGL_INFO, "received CONNECT ACKNOWLEDGE\n");
964 gsm48_stop_cc_timer(trans);
966 new_cc_state(trans, GSM_CSTATE_ACTIVE);
968 memset(&connect_ack, 0, sizeof(struct gsm_mncc));
969 connect_ack.callref = trans->callref;
970 return mncc_recvmsg(trans->ms, trans, MNCC_SETUP_COMPL_IND,
975 * process handlers (during active state)
978 /* notify message from upper layer */
979 static int gsm48_cc_tx_notify(struct gsm_trans *trans, void *arg)
981 struct gsm_mncc *notify = arg;
983 struct gsm48_hdr *gh;
985 LOGP(DCC, LOGL_INFO, "sending NOTIFY\n");
987 nmsg = gsm48_l3_msgb_alloc();
990 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
992 gh->msg_type = GSM48_MT_CC_NOTIFY;
995 gsm48_encode_notify(nmsg, notify->notify);
997 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1000 /* notify is received from lower layer */
1001 static int gsm48_cc_rx_notify(struct gsm_trans *trans, struct msgb *msg)
1003 struct gsm48_hdr *gh = msgb_l3(msg);
1004 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1005 struct gsm_mncc notify;
1007 LOGP(DCC, LOGL_INFO, "received NOTIFY\n");
1009 memset(¬ify, 0, sizeof(struct gsm_mncc));
1010 notify.callref = trans->callref;
1012 if (payload_len < 1) {
1013 LOGP(DCC, LOGL_NOTICE, "Short read of notify message error.\n");
1016 gsm48_decode_notify(¬ify.notify, gh->data);
1018 return mncc_recvmsg(trans->ms, trans, MNCC_NOTIFY_IND, ¬ify);
1021 /* start dtmf message from upper layer */
1022 static int gsm48_cc_tx_start_dtmf(struct gsm_trans *trans, void *arg)
1024 struct gsm_mncc *dtmf = arg;
1026 struct gsm48_hdr *gh;
1028 LOGP(DCC, LOGL_INFO, "sending START DTMF\n");
1030 nmsg = gsm48_l3_msgb_alloc();
1033 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1035 gh->msg_type = GSM48_MT_CC_START_DTMF;
1038 gsm48_encode_keypad(nmsg, dtmf->keypad);
1040 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1043 /* start dtmf ack is received from lower layer */
1044 static int gsm48_cc_rx_start_dtmf_ack(struct gsm_trans *trans, struct msgb *msg)
1046 struct gsm48_hdr *gh = msgb_l3(msg);
1047 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1048 struct tlv_parsed tp;
1049 struct gsm_mncc dtmf;
1051 LOGP(DCC, LOGL_INFO, "received START DTMF ACKNOWLEDGE\n");
1053 memset(&dtmf, 0, sizeof(struct gsm_mncc));
1054 dtmf.callref = trans->callref;
1055 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len, 0, 0);
1056 /* keypad facility */
1057 if (TLVP_PRESENT(&tp, GSM48_IE_KPD_FACILITY)) {
1058 dtmf.fields |= MNCC_F_KEYPAD;
1059 gsm48_decode_keypad(&dtmf.keypad,
1060 TLVP_VAL(&tp, GSM48_IE_KPD_FACILITY)-1);
1063 return mncc_recvmsg(trans->ms, trans, MNCC_START_DTMF_RSP, &dtmf);
1066 /* start dtmf rej is received from lower layer */
1067 static int gsm48_cc_rx_start_dtmf_rej(struct gsm_trans *trans, struct msgb *msg)
1069 struct gsm48_hdr *gh = msgb_l3(msg);
1070 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1071 struct gsm_mncc dtmf;
1073 LOGP(DCC, LOGL_INFO, "received START DTMF REJECT\n");
1075 memset(&dtmf, 0, sizeof(struct gsm_mncc));
1076 dtmf.callref = trans->callref;
1078 if (payload_len < 1) {
1079 LOGP(DCC, LOGL_NOTICE, "Short read of dtmf reject message "
1083 gsm48_decode_cause(&dtmf.cause, gh->data);
1085 return mncc_recvmsg(trans->ms, trans, MNCC_START_DTMF_REJ, &dtmf);
1088 /* stop dtmf message from upper layer */
1089 static int gsm48_cc_tx_stop_dtmf(struct gsm_trans *trans, void *arg)
1092 struct gsm48_hdr *gh;
1094 LOGP(DCC, LOGL_INFO, "sending STOP DTMF\n");
1096 nmsg = gsm48_l3_msgb_alloc();
1099 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1101 gh->msg_type = GSM48_MT_CC_STOP_DTMF;
1103 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1106 /* stop dtmf ack is received from lower layer */
1107 static int gsm48_cc_rx_stop_dtmf_ack(struct gsm_trans *trans, struct msgb *msg)
1109 struct gsm48_hdr *gh = msgb_l3(msg);
1110 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1111 struct tlv_parsed tp;
1112 struct gsm_mncc dtmf;
1114 LOGP(DCC, LOGL_INFO, "received STOP DTMF ACKNOWLEDGE\n");
1116 memset(&dtmf, 0, sizeof(struct gsm_mncc));
1117 dtmf.callref = trans->callref;
1118 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len, 0, 0);
1120 return mncc_recvmsg(trans->ms, trans, MNCC_STOP_DTMF_RSP, &dtmf);
1123 /* hold message from upper layer */
1124 static int gsm48_cc_tx_hold(struct gsm_trans *trans, void *arg)
1127 struct gsm48_hdr *gh;
1129 LOGP(DCC, LOGL_INFO, "sending HOLD\n");
1131 nmsg = gsm48_l3_msgb_alloc();
1134 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1136 gh->msg_type = GSM48_MT_CC_HOLD;
1138 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1141 /* hold ack is received from lower layer */
1142 static int gsm48_cc_rx_hold_ack(struct gsm_trans *trans, struct msgb *msg)
1144 struct gsm_mncc hold;
1146 LOGP(DCC, LOGL_INFO, "received HOLD ACKNOWLEDGE\n");
1148 memset(&hold, 0, sizeof(struct gsm_mncc));
1149 hold.callref = trans->callref;
1151 return mncc_recvmsg(trans->ms, trans, MNCC_HOLD_CNF, &hold);
1154 /* hold rej is received from lower layer */
1155 static int gsm48_cc_rx_hold_rej(struct gsm_trans *trans, struct msgb *msg)
1157 struct gsm48_hdr *gh = msgb_l3(msg);
1158 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1159 struct gsm_mncc hold;
1161 LOGP(DCC, LOGL_INFO, "received HOLD REJECT\n");
1163 memset(&hold, 0, sizeof(struct gsm_mncc));
1164 hold.callref = trans->callref;
1166 if (payload_len < 1) {
1167 LOGP(DCC, LOGL_NOTICE, "Short read of hold reject message "
1171 gsm48_decode_cause(&hold.cause, gh->data);
1173 return mncc_recvmsg(trans->ms, trans, MNCC_HOLD_REJ, &hold);
1176 /* retrieve message from upper layer */
1177 static int gsm48_cc_tx_retrieve(struct gsm_trans *trans, void *arg)
1180 struct gsm48_hdr *gh;
1182 LOGP(DCC, LOGL_INFO, "sending RETRIEVE\n");
1184 nmsg = gsm48_l3_msgb_alloc();
1187 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1189 gh->msg_type = GSM48_MT_CC_RETR;
1191 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1194 /* retrieve ack is received from lower layer */
1195 static int gsm48_cc_rx_retrieve_ack(struct gsm_trans *trans, struct msgb *msg)
1197 struct gsm_mncc retrieve;
1199 LOGP(DCC, LOGL_INFO, "received RETRIEVE ACKNOWLEDGE\n");
1201 memset(&retrieve, 0, sizeof(struct gsm_mncc));
1202 retrieve.callref = trans->callref;
1204 return mncc_recvmsg(trans->ms, trans, MNCC_RETRIEVE_CNF, &retrieve);
1207 /* retrieve rej is received from lower layer */
1208 static int gsm48_cc_rx_retrieve_rej(struct gsm_trans *trans, struct msgb *msg)
1210 struct gsm48_hdr *gh = msgb_l3(msg);
1211 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1212 struct gsm_mncc retrieve;
1214 LOGP(DCC, LOGL_INFO, "received RETRIEVE REJECT\n");
1216 memset(&retrieve, 0, sizeof(struct gsm_mncc));
1217 retrieve.callref = trans->callref;
1219 if (payload_len < 1) {
1220 LOGP(DCC, LOGL_NOTICE, "Short read of retrieve reject message "
1224 gsm48_decode_cause(&retrieve.cause, gh->data);
1226 return mncc_recvmsg(trans->ms, trans, MNCC_RETRIEVE_REJ, &retrieve);
1229 /* facility message from upper layer or from timer event */
1230 static int gsm48_cc_tx_facility(struct gsm_trans *trans, void *arg)
1232 struct gsm_mncc *fac = arg;
1234 struct gsm48_hdr *gh;
1236 LOGP(DCC, LOGL_INFO, "sending FACILITY\n");
1238 nmsg = gsm48_l3_msgb_alloc();
1241 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1243 gh->msg_type = GSM48_MT_CC_FACILITY;
1246 gsm48_encode_facility(nmsg, 1, &fac->facility);
1248 if (fac->fields & MNCC_F_SSVERSION)
1249 gsm48_encode_ssversion(nmsg, &fac->ssversion);
1251 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1254 /* facility is received from lower layer */
1255 static int gsm48_cc_rx_facility(struct gsm_trans *trans, struct msgb *msg)
1257 struct gsm48_hdr *gh = msgb_l3(msg);
1258 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1259 struct gsm_mncc fac;
1261 LOGP(DCC, LOGL_INFO, "received FACILITY\n");
1263 memset(&fac, 0, sizeof(struct gsm_mncc));
1264 fac.callref = trans->callref;
1265 if (payload_len < 1) {
1266 LOGP(DCC, LOGL_NOTICE, "Short read of facility message "
1271 gsm48_decode_facility(&fac.facility, gh->data);
1273 return mncc_recvmsg(trans->ms, trans, MNCC_FACILITY_IND, &fac);
1276 /* user info message from upper layer or from timer event */
1277 static int gsm48_cc_tx_userinfo(struct gsm_trans *trans, void *arg)
1279 struct gsm_mncc *user = arg;
1281 struct gsm48_hdr *gh;
1283 LOGP(DCC, LOGL_INFO, "sending USERINFO\n");
1285 nmsg = gsm48_l3_msgb_alloc();
1288 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1290 gh->msg_type = GSM48_MT_CC_USER_INFO;
1293 if (user->fields & MNCC_F_USERUSER)
1294 gsm48_encode_useruser(nmsg, 1, &user->useruser);
1297 gsm48_encode_more(nmsg);
1299 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1302 /* user info is received from lower layer */
1303 static int gsm48_cc_rx_userinfo(struct gsm_trans *trans, struct msgb *msg)
1305 struct gsm48_hdr *gh = msgb_l3(msg);
1306 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1307 struct tlv_parsed tp;
1308 struct gsm_mncc user;
1310 LOGP(DCC, LOGL_INFO, "received USERINFO\n");
1312 memset(&user, 0, sizeof(struct gsm_mncc));
1313 user.callref = trans->callref;
1314 if (payload_len < 1) {
1315 LOGP(DCC, LOGL_NOTICE, "Short read of userinfo message "
1319 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len,
1320 GSM48_IE_USER_USER, 0);
1322 gsm48_decode_useruser(&user.useruser,
1323 TLVP_VAL(&tp, GSM48_IE_USER_USER)-1);
1325 if (TLVP_PRESENT(&tp, GSM48_IE_MORE_DATA))
1328 return mncc_recvmsg(trans->ms, trans, MNCC_USERINFO_IND, &user);
1331 /* modify message from upper layer or from timer event */
1332 static int gsm48_cc_tx_modify(struct gsm_trans *trans, void *arg)
1334 struct gsm_mncc *modify = arg;
1336 struct gsm48_hdr *gh;
1338 LOGP(DCC, LOGL_INFO, "sending MODIFY\n");
1340 nmsg = gsm48_l3_msgb_alloc();
1343 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1345 gh->msg_type = GSM48_MT_CC_MODIFY;
1347 gsm48_start_cc_timer(trans, 0x323, GSM48_T323_MS);
1349 /* bearer capability */
1350 gsm48_encode_bearer_cap(nmsg, 1, &modify->bearer_cap);
1352 new_cc_state(trans, GSM_CSTATE_MO_TERM_MODIFY);
1354 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1357 /* modify complete is received from lower layer */
1358 static int gsm48_cc_rx_modify_complete(struct gsm_trans *trans,
1361 struct gsm48_hdr *gh = msgb_l3(msg);
1362 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1363 struct gsm_mncc modify;
1365 LOGP(DCC, LOGL_INFO, "received MODIFY COMPLETE\n");
1367 gsm48_stop_cc_timer(trans);
1369 memset(&modify, 0, sizeof(struct gsm_mncc));
1370 modify.callref = trans->callref;
1371 if (payload_len < 1) {
1372 LOGP(DCC, LOGL_NOTICE, "Short read of modify complete message "
1376 /* bearer capability */
1377 gsm48_decode_bearer_cap(&modify.bearer_cap, gh->data);
1379 new_cc_state(trans, GSM_CSTATE_ACTIVE);
1381 return mncc_recvmsg(trans->ms, trans, MNCC_MODIFY_CNF, &modify);
1384 /* modify reject is received from lower layer */
1385 static int gsm48_cc_rx_modify_reject(struct gsm_trans *trans, struct msgb *msg)
1387 struct gsm48_hdr *gh = msgb_l3(msg);
1388 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1389 struct tlv_parsed tp;
1390 struct gsm_mncc modify;
1392 LOGP(DCC, LOGL_INFO, "received MODIFY REJECT\n");
1394 gsm48_stop_cc_timer(trans);
1396 memset(&modify, 0, sizeof(struct gsm_mncc));
1397 modify.callref = trans->callref;
1398 if (payload_len < 1) {
1399 LOGP(DCC, LOGL_NOTICE, "Short read of modify reject message "
1403 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len,
1404 GSM48_IE_BEARER_CAP, GSM48_IE_CAUSE);
1405 /* bearer capability */
1406 if (TLVP_PRESENT(&tp, GSM48_IE_BEARER_CAP)) {
1407 modify.fields |= MNCC_F_BEARER_CAP;
1408 gsm48_decode_bearer_cap(&modify.bearer_cap,
1409 TLVP_VAL(&tp, GSM48_IE_BEARER_CAP)-1);
1412 if (TLVP_PRESENT(&tp, GSM48_IE_CAUSE)) {
1413 modify.fields |= MNCC_F_CAUSE;
1414 gsm48_decode_cause(&modify.cause,
1415 TLVP_VAL(&tp, GSM48_IE_CAUSE)-1);
1418 new_cc_state(trans, GSM_CSTATE_ACTIVE);
1420 return mncc_recvmsg(trans->ms, trans, MNCC_MODIFY_REJ, &modify);
1423 /* modify is received from lower layer */
1424 static int gsm48_cc_rx_modify(struct gsm_trans *trans, struct msgb *msg)
1426 struct gsm48_hdr *gh = msgb_l3(msg);
1427 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1428 struct gsm_mncc modify;
1430 LOGP(DCC, LOGL_INFO, "received MODIFY\n");
1432 memset(&modify, 0, sizeof(struct gsm_mncc));
1433 modify.callref = trans->callref;
1434 if (payload_len < 1) {
1435 LOGP(DCC, LOGL_NOTICE, "Short read of modify message error.\n");
1438 /* bearer capability */
1439 gsm48_decode_bearer_cap(&modify.bearer_cap, gh->data);
1441 new_cc_state(trans, GSM_CSTATE_MO_ORIG_MODIFY);
1443 return mncc_recvmsg(trans->ms, trans, MNCC_MODIFY_IND, &modify);
1446 /* modify complete message from upper layer or from timer event */
1447 static int gsm48_cc_tx_modify_complete(struct gsm_trans *trans, void *arg)
1449 struct gsm_mncc *modify = arg;
1451 struct gsm48_hdr *gh;
1453 LOGP(DCC, LOGL_INFO, "sending MODIFY COMPLETE\n");
1455 nmsg = gsm48_l3_msgb_alloc();
1458 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1460 gh->msg_type = GSM48_MT_CC_MODIFY_COMPL;
1462 /* bearer capability */
1463 gsm48_encode_bearer_cap(nmsg, 1, &modify->bearer_cap);
1465 new_cc_state(trans, GSM_CSTATE_ACTIVE);
1467 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1470 /* modify reject message from upper layer or from timer event */
1471 static int gsm48_cc_tx_modify_reject(struct gsm_trans *trans, void *arg)
1473 struct gsm_mncc *modify = arg;
1475 struct gsm48_hdr *gh;
1477 LOGP(DCC, LOGL_INFO, "sending MODIFY REJECT\n");
1479 nmsg = gsm48_l3_msgb_alloc();
1482 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1484 gh->msg_type = GSM48_MT_CC_MODIFY_REJECT;
1486 /* bearer capability */
1487 gsm48_encode_bearer_cap(nmsg, 1, &modify->bearer_cap);
1489 gsm48_encode_cause(nmsg, 1, &modify->cause);
1491 new_cc_state(trans, GSM_CSTATE_ACTIVE);
1493 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1497 * process handlers (call clearing)
1500 static struct gsm_mncc_cause default_cause = {
1501 .location = GSM48_CAUSE_LOC_PRN_S_LU,
1505 .value = GSM48_CC_CAUSE_NORMAL_UNSPEC,
1510 /* disconnect message from upper layer or from timer event */
1511 static int gsm48_cc_tx_disconnect(struct gsm_trans *trans, void *arg)
1513 struct gsm_mncc *disc = arg;
1515 struct gsm48_hdr *gh;
1517 LOGP(DCC, LOGL_INFO, "sending DISCONNECT\n");
1519 nmsg = gsm48_l3_msgb_alloc();
1522 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1524 gh->msg_type = GSM48_MT_CC_DISCONNECT;
1526 gsm48_stop_cc_timer(trans);
1527 gsm48_start_cc_timer(trans, 0x305, GSM48_T305_MS);
1530 if (disc->fields & MNCC_F_CAUSE)
1531 gsm48_encode_cause(nmsg, 1, &disc->cause);
1533 gsm48_encode_cause(nmsg, 1, &default_cause);
1536 if (disc->fields & MNCC_F_FACILITY)
1537 gsm48_encode_facility(nmsg, 0, &disc->facility);
1539 if (disc->fields & MNCC_F_PROGRESS)
1540 gsm48_encode_progress(nmsg, 0, &disc->progress);
1542 if (disc->fields & MNCC_F_USERUSER)
1543 gsm48_encode_useruser(nmsg, 0, &disc->useruser);
1545 if (disc->fields & MNCC_F_SSVERSION)
1546 gsm48_encode_ssversion(nmsg, &disc->ssversion);
1548 new_cc_state(trans, GSM_CSTATE_DISCONNECT_REQ);
1550 return gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1553 /* release message from upper layer or from timer event */
1554 static int gsm48_cc_tx_release(struct gsm_trans *trans, void *arg)
1556 struct gsm_mncc *rel = arg;
1558 struct gsm48_hdr *gh;
1560 LOGP(DCC, LOGL_INFO, "sending RELEASE\n");
1562 nmsg = gsm48_l3_msgb_alloc();
1565 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1567 gh->msg_type = GSM48_MT_CC_RELEASE;
1569 gsm48_stop_cc_timer(trans);
1570 gsm48_start_cc_timer(trans, 0x308, GSM48_T308_MS);
1573 if (rel->fields & MNCC_F_CAUSE)
1574 gsm48_encode_cause(nmsg, 0, &rel->cause);
1576 if (rel->fields & MNCC_F_FACILITY)
1577 gsm48_encode_facility(nmsg, 0, &rel->facility);
1579 if (rel->fields & MNCC_F_USERUSER)
1580 gsm48_encode_useruser(nmsg, 0, &rel->useruser);
1582 if (rel->fields & MNCC_F_SSVERSION)
1583 gsm48_encode_ssversion(nmsg, &rel->ssversion);
1585 trans->cc.T308_second = 0;
1586 memcpy(&trans->cc.msg, rel, sizeof(struct gsm_mncc));
1588 if (trans->cc.state != GSM_CSTATE_RELEASE_REQ)
1589 new_cc_state(trans, GSM_CSTATE_RELEASE_REQ);
1591 gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1593 /* release without sending MMCC_REL_REQ */
1594 new_cc_state(trans, GSM_CSTATE_NULL);
1601 /* reject message from upper layer */
1602 static int gsm48_cc_tx_release_compl(struct gsm_trans *trans, void *arg)
1604 struct gsm_mncc *rel = arg;
1606 struct gsm48_hdr *gh;
1608 LOGP(DCC, LOGL_INFO, "sending RELEASE COMPLETE\n");
1610 nmsg = gsm48_l3_msgb_alloc();
1613 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1615 gh->msg_type = GSM48_MT_CC_RELEASE_COMPL;
1617 gsm48_stop_cc_timer(trans);
1620 if (rel->fields & MNCC_F_CAUSE)
1621 gsm48_encode_cause(nmsg, 0, &rel->cause);
1623 if (rel->fields & MNCC_F_FACILITY)
1624 gsm48_encode_facility(nmsg, 0, &rel->facility);
1626 if (rel->fields & MNCC_F_USERUSER)
1627 gsm48_encode_useruser(nmsg, 0, &rel->useruser);
1629 if (rel->fields & MNCC_F_SSVERSION)
1630 gsm48_encode_ssversion(nmsg, &rel->ssversion);
1632 /* release without sending MMCC_REL_REQ */
1633 new_cc_state(trans, GSM_CSTATE_NULL);
1640 /* disconnect is received from lower layer */
1641 static int gsm48_cc_rx_disconnect(struct gsm_trans *trans, struct msgb *msg)
1643 struct gsm48_hdr *gh = msgb_l3(msg);
1644 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1645 struct tlv_parsed tp;
1646 struct gsm_mncc disc;
1648 LOGP(DCC, LOGL_INFO, "received DISCONNECT\n");
1650 gsm48_stop_cc_timer(trans);
1652 new_cc_state(trans, GSM_CSTATE_DISCONNECT_IND);
1654 memset(&disc, 0, sizeof(struct gsm_mncc));
1655 disc.callref = trans->callref;
1656 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len,
1659 if (TLVP_PRESENT(&tp, GSM48_IE_CAUSE)) {
1660 disc.fields |= MNCC_F_CAUSE;
1661 gsm48_decode_cause(&disc.cause,
1662 TLVP_VAL(&tp, GSM48_IE_CAUSE)-1);
1665 if (TLVP_PRESENT(&tp, GSM48_IE_FACILITY)) {
1666 disc.fields |= MNCC_F_FACILITY;
1667 gsm48_decode_facility(&disc.facility,
1668 TLVP_VAL(&tp, GSM48_IE_FACILITY)-1);
1671 if (TLVP_PRESENT(&tp, GSM48_IE_PROGR_IND)) {
1672 disc.fields |= MNCC_F_PROGRESS;
1673 gsm48_decode_progress(&disc.progress,
1674 TLVP_VAL(&tp, GSM48_IE_PROGR_IND)-1);
1677 if (TLVP_PRESENT(&tp, GSM48_IE_USER_USER)) {
1678 disc.fields |= MNCC_F_USERUSER;
1679 gsm48_decode_useruser(&disc.useruser,
1680 TLVP_VAL(&tp, GSM48_IE_USER_USER)-1);
1683 /* store disconnect cause for T305 expiry */
1684 memcpy(&trans->cc.msg, &disc, sizeof(struct gsm_mncc));
1686 return mncc_recvmsg(trans->ms, trans, MNCC_DISC_IND, &disc);
1689 /* release is received from lower layer */
1690 static int gsm48_cc_rx_release(struct gsm_trans *trans, struct msgb *msg)
1692 struct gsm48_hdr *gh = msgb_l3(msg);
1693 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1694 struct tlv_parsed tp;
1695 struct gsm_mncc rel;
1697 LOGP(DCC, LOGL_INFO, "received RELEASE\n");
1699 gsm48_stop_cc_timer(trans);
1701 memset(&rel, 0, sizeof(struct gsm_mncc));
1702 rel.callref = trans->callref;
1703 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len, 0, 0);
1705 if (TLVP_PRESENT(&tp, GSM48_IE_CAUSE)) {
1706 rel.fields |= MNCC_F_CAUSE;
1707 gsm48_decode_cause(&rel.cause,
1708 TLVP_VAL(&tp, GSM48_IE_CAUSE)-1);
1711 if (TLVP_PRESENT(&tp, GSM48_IE_FACILITY)) {
1712 rel.fields |= MNCC_F_FACILITY;
1713 gsm48_decode_facility(&rel.facility,
1714 TLVP_VAL(&tp, GSM48_IE_FACILITY)-1);
1717 if (TLVP_PRESENT(&tp, GSM48_IE_USER_USER)) {
1718 rel.fields |= MNCC_F_USERUSER;
1719 gsm48_decode_useruser(&rel.useruser,
1720 TLVP_VAL(&tp, GSM48_IE_USER_USER)-1);
1723 if (trans->cc.state == GSM_CSTATE_RELEASE_REQ) {
1724 /* release collision 5.4.5 */
1725 mncc_recvmsg(trans->ms, trans, MNCC_REL_CNF, &rel);
1729 /* forward cause only */
1730 LOGP(DCC, LOGL_INFO, "sending RELEASE COMPLETE\n");
1732 nmsg = gsm48_l3_msgb_alloc();
1735 gh = (struct gsm48_hdr *) msgb_put(nmsg, sizeof(*gh));
1737 gh->msg_type = GSM48_MT_CC_RELEASE_COMPL;
1739 if (rel.fields & MNCC_F_CAUSE)
1740 gsm48_encode_cause(nmsg, 0, &rel.cause);
1742 gsm48_cc_to_mm(nmsg, trans, GSM48_MMCC_DATA_REQ);
1744 /* release indication */
1745 mncc_recvmsg(trans->ms, trans, MNCC_REL_IND, &rel);
1748 /* release MM conn, got NULL state, free trans */
1749 return gsm48_rel_null_free(trans);
1752 /* release complete is received from lower layer */
1753 static int gsm48_cc_rx_release_compl(struct gsm_trans *trans, struct msgb *msg)
1755 struct gsm48_hdr *gh = msgb_l3(msg);
1756 unsigned int payload_len = msgb_l3len(msg) - sizeof(*gh);
1757 struct tlv_parsed tp;
1758 struct gsm_mncc rel;
1760 LOGP(DCC, LOGL_INFO, "received RELEASE COMPLETE\n");
1762 gsm48_stop_cc_timer(trans);
1764 memset(&rel, 0, sizeof(struct gsm_mncc));
1765 rel.callref = trans->callref;
1766 tlv_parse(&tp, &gsm48_att_tlvdef, gh->data, payload_len, 0, 0);
1768 if (TLVP_PRESENT(&tp, GSM48_IE_CAUSE)) {
1769 rel.fields |= MNCC_F_CAUSE;
1770 gsm48_decode_cause(&rel.cause,
1771 TLVP_VAL(&tp, GSM48_IE_CAUSE)-1);
1774 if (TLVP_PRESENT(&tp, GSM48_IE_FACILITY)) {
1775 rel.fields |= MNCC_F_FACILITY;
1776 gsm48_decode_facility(&rel.facility,
1777 TLVP_VAL(&tp, GSM48_IE_FACILITY)-1);
1780 if (TLVP_PRESENT(&tp, GSM48_IE_USER_USER)) {
1781 rel.fields |= MNCC_F_USERUSER;
1782 gsm48_decode_useruser(&rel.useruser,
1783 TLVP_VAL(&tp, GSM48_IE_USER_USER)-1);
1786 if (trans->callref) {
1787 switch (trans->cc.state) {
1788 case GSM_CSTATE_CALL_PRESENT:
1789 mncc_recvmsg(trans->ms, trans,
1790 MNCC_REJ_IND, &rel);
1792 case GSM_CSTATE_RELEASE_REQ:
1793 mncc_recvmsg(trans->ms, trans,
1794 MNCC_REL_CNF, &rel);
1797 mncc_recvmsg(trans->ms, trans,
1798 MNCC_REL_IND, &rel);
1802 /* release MM conn, got NULL state, free trans */
1803 return gsm48_rel_null_free(trans);
1810 /* state trasitions for MNCC messages (upper layer) */
1811 static struct downstate {
1814 int (*rout) (struct gsm_trans *trans, void *arg);
1815 } downstatelist[] = {
1816 /* mobile originating call establishment */
1817 {SBIT(GSM_CSTATE_NULL), /* 5.2.1 */
1818 MNCC_SETUP_REQ, gsm48_cc_init_mm},
1820 {SBIT(GSM_CSTATE_MM_CONNECTION_PEND), /* 5.2.1 */
1821 MNCC_REL_REQ, gsm48_cc_abort_mm},
1823 /* mobile terminating call establishment */
1824 {SBIT(GSM_CSTATE_CALL_PRESENT), /* 5.2.2.3.1 */
1825 MNCC_CALL_CONF_REQ, gsm48_cc_tx_call_conf},
1827 {SBIT(GSM_CSTATE_MO_TERM_CALL_CONF), /* 5.2.2.3.2 */
1828 MNCC_ALERT_REQ, gsm48_cc_tx_alerting},
1830 {SBIT(GSM_CSTATE_MO_TERM_CALL_CONF) |
1831 SBIT(GSM_CSTATE_CALL_RECEIVED), /* 5.2.2.5 */
1832 MNCC_SETUP_RSP, gsm48_cc_tx_connect},
1834 /* signalling during call */
1835 {SBIT(GSM_CSTATE_ACTIVE), /* 5.3.1 */
1836 MNCC_NOTIFY_REQ, gsm48_cc_tx_notify},
1838 {ALL_STATES, /* 5.5.7.1 */
1839 MNCC_START_DTMF_REQ, gsm48_cc_tx_start_dtmf},
1841 {ALL_STATES, /* 5.5.7.3 */
1842 MNCC_STOP_DTMF_REQ, gsm48_cc_tx_stop_dtmf},
1844 {SBIT(GSM_CSTATE_ACTIVE),
1845 MNCC_HOLD_REQ, gsm48_cc_tx_hold},
1847 {SBIT(GSM_CSTATE_ACTIVE),
1848 MNCC_RETRIEVE_REQ, gsm48_cc_tx_retrieve},
1850 {ALL_STATES - SBIT(GSM_CSTATE_NULL) - SBIT(GSM_CSTATE_RELEASE_REQ),
1851 MNCC_FACILITY_REQ, gsm48_cc_tx_facility},
1853 {SBIT(GSM_CSTATE_ACTIVE),
1854 MNCC_USERINFO_REQ, gsm48_cc_tx_userinfo},
1857 {ALL_STATES - SBIT(GSM_CSTATE_NULL) - SBIT(GSM_CSTATE_DISCONNECT_IND) -
1858 SBIT(GSM_CSTATE_RELEASE_REQ) -
1859 SBIT(GSM_CSTATE_DISCONNECT_REQ), /* 5.4.3.1 */
1860 MNCC_DISC_REQ, gsm48_cc_tx_disconnect},
1862 {SBIT(GSM_CSTATE_INITIATED),
1863 MNCC_REJ_REQ, gsm48_cc_tx_release_compl},
1865 {ALL_STATES - SBIT(GSM_CSTATE_NULL) -
1866 SBIT(GSM_CSTATE_RELEASE_REQ), /* ??? */
1867 MNCC_REL_REQ, gsm48_cc_tx_release},
1870 {SBIT(GSM_CSTATE_ACTIVE),
1871 MNCC_MODIFY_REQ, gsm48_cc_tx_modify},
1873 {SBIT(GSM_CSTATE_MO_ORIG_MODIFY),
1874 MNCC_MODIFY_RSP, gsm48_cc_tx_modify_complete},
1876 {SBIT(GSM_CSTATE_MO_ORIG_MODIFY),
1877 MNCC_MODIFY_REJ, gsm48_cc_tx_modify_reject},
1881 (sizeof(downstatelist) / sizeof(struct downstate))
1883 int mncc_send(struct osmocom_ms *ms, int msg_type, void *arg)
1885 struct gsm_mncc *data = arg;
1886 struct gsm_trans *trans;
1890 trans = trans_find_by_callref(ms, data->callref);
1893 /* check for SETUP message */
1894 if (msg_type != MNCC_SETUP_REQ) {
1895 /* Invalid call reference */
1896 return mncc_release_ind(ms, NULL, data->callref,
1897 GSM48_CAUSE_LOC_PRN_S_LU,
1898 GSM48_CC_CAUSE_INVAL_TRANS_ID);
1900 if (data->callref >= 0x40000000) {
1901 LOGP(DCC, LOGL_FATAL, "MNCC ref wrong.\n");
1902 return mncc_release_ind(ms, NULL, data->callref,
1903 GSM48_CAUSE_LOC_PRN_S_LU,
1904 GSM48_CC_CAUSE_INVAL_TRANS_ID);
1907 /* Create transaction */
1908 trans = trans_alloc(ms, GSM48_PDISC_CC, 0xff, data->callref);
1910 /* No memory or whatever */
1911 return mncc_release_ind(ms, NULL, data->callref,
1912 GSM48_CAUSE_LOC_PRN_S_LU,
1913 GSM48_CC_CAUSE_RESOURCE_UNAVAIL);
1917 /* Find function for current state and message */
1918 for (i = 0; i < DOWNSLLEN; i++)
1919 if ((msg_type == downstatelist[i].type)
1920 && ((1 << trans->cc.state) & downstatelist[i].states))
1922 if (i == DOWNSLLEN) {
1923 LOGP(DCC, LOGL_NOTICE, "Message unhandled at this "
1928 rc = downstatelist[i].rout(trans, arg);
1933 /* state trasitions for call control messages (lower layer) */
1934 static struct datastate {
1937 int (*rout) (struct gsm_trans *trans, struct msgb *msg);
1938 } datastatelist[] = {
1939 /* mobile originating call establishment */
1940 {SBIT(GSM_CSTATE_INITIATED), /* 5.2.1.3 */
1941 GSM48_MT_CC_CALL_PROC, gsm48_cc_rx_call_proceeding},
1943 {SBIT(GSM_CSTATE_INITIATED) | SBIT(GSM_CSTATE_MO_CALL_PROC) |
1944 SBIT(GSM_CSTATE_CALL_DELIVERED), /* 5.2.1.4.1 */
1945 MNCC_PROGRESS_REQ, gsm48_cc_rx_progress},
1947 {SBIT(GSM_CSTATE_INITIATED) |
1948 SBIT(GSM_CSTATE_MO_CALL_PROC), /* 5.2.1.5 */
1949 GSM48_MT_CC_ALERTING, gsm48_cc_rx_alerting},
1951 {SBIT(GSM_CSTATE_INITIATED) | SBIT(GSM_CSTATE_MO_CALL_PROC) |
1952 SBIT(GSM_CSTATE_CALL_DELIVERED), /* 5.2.1.6 */
1953 GSM48_MT_CC_CONNECT, gsm48_cc_rx_connect},
1955 /* mobile terminating call establishment */
1956 {SBIT(GSM_CSTATE_NULL), /* 5.2.2.1 */
1957 GSM48_MT_CC_SETUP, gsm48_cc_rx_setup},
1959 {SBIT(GSM_CSTATE_CALL_PRESENT), /* 5.2.2.6 */
1960 GSM48_MT_CC_CONNECT_ACK, gsm48_cc_rx_connect_ack},
1962 /* signalling during call */
1963 {SBIT(GSM_CSTATE_ACTIVE), /* 5.3.1 */
1964 GSM48_MT_CC_NOTIFY, gsm48_cc_rx_notify},
1966 {ALL_STATES, /* 8.4 */
1967 GSM48_MT_CC_STATUS_ENQ, gsm48_cc_rx_status_enq},
1969 {ALL_STATES, /* 5.5.7.2 */
1970 GSM48_MT_CC_START_DTMF_ACK, gsm48_cc_rx_start_dtmf_ack},
1972 {ALL_STATES, /* 5.5.7.2 */
1973 GSM48_MT_CC_START_DTMF_REJ, gsm48_cc_rx_start_dtmf_rej},
1975 {ALL_STATES, /* 5.5.7.4 */
1976 GSM48_MT_CC_STOP_DTMF_ACK, gsm48_cc_rx_stop_dtmf_ack},
1978 {SBIT(GSM_CSTATE_ACTIVE),
1979 GSM48_MT_CC_HOLD_ACK, gsm48_cc_rx_hold_ack},
1981 {SBIT(GSM_CSTATE_ACTIVE),
1982 GSM48_MT_CC_HOLD_REJ, gsm48_cc_rx_hold_rej},
1984 {SBIT(GSM_CSTATE_ACTIVE),
1985 GSM48_MT_CC_RETR_ACK, gsm48_cc_rx_retrieve_ack},
1987 {SBIT(GSM_CSTATE_ACTIVE),
1988 GSM48_MT_CC_RETR_REJ, gsm48_cc_rx_retrieve_rej},
1990 {ALL_STATES - SBIT(GSM_CSTATE_NULL),
1991 GSM48_MT_CC_FACILITY, gsm48_cc_rx_facility},
1993 {SBIT(GSM_CSTATE_ACTIVE),
1994 GSM48_MT_CC_USER_INFO, gsm48_cc_rx_userinfo},
1997 {ALL_STATES - SBIT(GSM_CSTATE_NULL) - SBIT(GSM_CSTATE_RELEASE_REQ) -
1998 SBIT(GSM_CSTATE_DISCONNECT_IND), /* 5.4.4.1.1 */
1999 GSM48_MT_CC_DISCONNECT, gsm48_cc_rx_disconnect},
2001 {ALL_STATES - SBIT(GSM_CSTATE_NULL), /* 5.4.3.3 & 5.4.5!!!*/
2002 GSM48_MT_CC_RELEASE, gsm48_cc_rx_release},
2004 {ALL_STATES, /* 5.4.4.1.3 */
2005 GSM48_MT_CC_RELEASE_COMPL, gsm48_cc_rx_release_compl},
2008 {SBIT(GSM_CSTATE_ACTIVE),
2009 GSM48_MT_CC_MODIFY, gsm48_cc_rx_modify},
2011 {SBIT(GSM_CSTATE_MO_TERM_MODIFY),
2012 GSM48_MT_CC_MODIFY_COMPL, gsm48_cc_rx_modify_complete},
2014 {SBIT(GSM_CSTATE_MO_TERM_MODIFY),
2015 GSM48_MT_CC_MODIFY_REJECT, gsm48_cc_rx_modify_reject},
2019 (sizeof(datastatelist) / sizeof(struct datastate))
2021 static int gsm48_cc_data_ind(struct gsm_trans *trans, struct msgb *msg)
2023 struct osmocom_ms *ms = trans->ms;
2024 struct gsm48_hdr *gh = msgb_l3(msg);
2025 int msg_type = gh->msg_type & 0xbf;
2026 uint8_t transaction_id = ((gh->proto_discr & 0xf0) ^ 0x80) >> 4;
2028 int msg_supported = 0; /* determine, if message is supported at all */
2031 /* set transaction ID, if not already */
2032 trans->transaction_id = transaction_id;
2034 /* pull the MMCC header */
2035 msgb_pull(msg, sizeof(struct gsm48_mmxx_hdr));
2037 LOGP(DCC, LOGL_INFO, "(ms %s) Received '%s' in CC state %s\n", ms->name,
2038 gsm48_cc_msg_name(msg_type),
2039 gsm48_cc_state_name(trans->cc.state));
2041 /* find function for current state and message */
2042 for (i = 0; i < DATASLLEN; i++) {
2043 if (msg_type == datastatelist[i].type)
2045 if ((msg_type == datastatelist[i].type)
2046 && ((1 << trans->cc.state) & datastatelist[i].states))
2049 if (i == DATASLLEN) {
2050 if (msg_supported) {
2051 LOGP(DCC, LOGL_NOTICE, "Message unhandled at this "
2053 return gsm48_cc_tx_status(trans,
2054 GSM48_REJECT_MSG_TYPE_NOT_COMPATIBLE);
2056 LOGP(DCC, LOGL_NOTICE, "Message not supported.\n");
2057 return gsm48_cc_tx_status(trans,
2058 GSM48_REJECT_MSG_TYPE_NOT_IMPLEMENTED);
2062 rc = datastatelist[i].rout(trans, msg);
2067 /* receive message from MM layer */
2068 int gsm48_rcv_cc(struct osmocom_ms *ms, struct msgb *msg)
2070 struct gsm48_mmxx_hdr *mmh = (struct gsm48_mmxx_hdr *)msg->data;
2071 int msg_type = mmh->msg_type;
2072 struct gsm_trans *trans;
2075 trans = trans_find_by_callref(ms, mmh->ref);
2077 trans = trans_alloc(ms, GSM48_PDISC_CC, mmh->transaction_id,
2083 LOGP(DCC, LOGL_INFO, "(ms %s) Received '%s' in CC state %s\n", ms->name,
2084 get_mmxx_name(msg_type),
2085 gsm48_cc_state_name(trans->cc.state));
2088 case GSM48_MMCC_EST_IND:
2090 rc = gsm48_cc_data_ind(trans, msg);
2092 case GSM48_MMCC_EST_CNF:
2093 /* send setup after confirm */
2094 if (trans->cc.state == GSM_CSTATE_MM_CONNECTION_PEND)
2095 rc = gsm48_cc_tx_setup(trans);
2097 LOGP(DCC, LOGL_ERROR, "Oops, MMCC-EST-CONF in state "
2098 "%d?\n", trans->cc.state);
2100 case GSM48_MMCC_ERR_IND: /* no supporting re-establishment */
2101 case GSM48_MMCC_REL_IND:
2102 /* release L4, release transaction */
2103 mncc_release_ind(trans->ms, trans, trans->callref,
2104 GSM48_CAUSE_LOC_PRN_S_LU, mmh->cause);
2105 /* release without sending MMCC_REL_REQ */
2106 new_cc_state(trans, GSM_CSTATE_NULL);
2110 case GSM48_MMCC_DATA_IND:
2111 rc = gsm48_cc_data_ind(trans, msg);
2113 case GSM48_MMCC_UNIT_DATA_IND:
2115 case GSM48_MMCC_SYNC_IND:
2118 LOGP(DCC, LOGL_NOTICE, "Message unhandled.\n");