SIP: Fix incoming re-invite
[lcr.git] / gsm.cpp
1 /*****************************************************************************\
2 **                                                                           **
3 ** LCR                                                                       **
4 **                                                                           **
5 **---------------------------------------------------------------------------**
6 ** Copyright: Andreas Eversberg                                              **
7 **            MNCC-Interface: Harald Welte                                   **
8 **                                                                           **
9 ** mISDN gsm                                                                 **
10 **                                                                           **
11 \*****************************************************************************/ 
12
13 #include "main.h"
14 #include "mncc.h"
15
16 #ifndef _GNU_SOURCE
17 #define _GNU_SOURCE
18 #endif
19 extern "C" {
20 #include "gsm_audio.h"
21 }
22
23 #include <assert.h>
24
25 #define SOCKET_RETRY_TIMER      5
26
27 //struct lcr_gsm *gsm = NULL;
28
29 int new_callref = 1;
30
31 /* names of MNCC-SAP */
32 static const struct _value_string {
33         int msg_type;
34         const char *name;
35 } mncc_names[] = {
36         { 0,                    "New call ref" },
37         { 1,                    "Codec negotiation" },
38         { MNCC_SETUP_REQ,       "MNCC_SETUP_REQ" },
39         { MNCC_SETUP_IND,       "MNCC_SETUP_IND" },
40         { MNCC_SETUP_RSP,       "MNCC_SETUP_RSP" },
41         { MNCC_SETUP_CNF,       "MNCC_SETUP_CNF" },
42         { MNCC_SETUP_COMPL_REQ, "MNCC_SETUP_COMPL_REQ" },
43         { MNCC_SETUP_COMPL_IND, "MNCC_SETUP_COMPL_IND" },
44         { MNCC_CALL_CONF_IND,   "MNCC_CALL_CONF_IND" },
45         { MNCC_CALL_PROC_REQ,   "MNCC_CALL_PROC_REQ" },
46         { MNCC_PROGRESS_REQ,    "MNCC_PROGRESS_REQ" },
47         { MNCC_ALERT_REQ,       "MNCC_ALERT_REQ" },
48         { MNCC_ALERT_IND,       "MNCC_ALERT_IND" },
49         { MNCC_NOTIFY_REQ,      "MNCC_NOTIFY_REQ" },
50         { MNCC_NOTIFY_IND,      "MNCC_NOTIFY_IND" },
51         { MNCC_DISC_REQ,        "MNCC_DISC_REQ" },
52         { MNCC_DISC_IND,        "MNCC_DISC_IND" },
53         { MNCC_REL_REQ,         "MNCC_REL_REQ" },
54         { MNCC_REL_IND,         "MNCC_REL_IND" },
55         { MNCC_REL_CNF,         "MNCC_REL_CNF" },
56         { MNCC_FACILITY_REQ,    "MNCC_FACILITY_REQ" },
57         { MNCC_FACILITY_IND,    "MNCC_FACILITY_IND" },
58         { MNCC_START_DTMF_IND,  "MNCC_START_DTMF_IND" },
59         { MNCC_START_DTMF_RSP,  "MNCC_START_DTMF_RSP" },
60         { MNCC_START_DTMF_REJ,  "MNCC_START_DTMF_REJ" },
61         { MNCC_STOP_DTMF_IND,   "MNCC_STOP_DTMF_IND" },
62         { MNCC_STOP_DTMF_RSP,   "MNCC_STOP_DTMF_RSP" },
63         { MNCC_MODIFY_REQ,      "MNCC_MODIFY_REQ" },
64         { MNCC_MODIFY_IND,      "MNCC_MODIFY_IND" },
65         { MNCC_MODIFY_RSP,      "MNCC_MODIFY_RSP" },
66         { MNCC_MODIFY_CNF,      "MNCC_MODIFY_CNF" },
67         { MNCC_MODIFY_REJ,      "MNCC_MODIFY_REJ" },
68         { MNCC_HOLD_IND,        "MNCC_HOLD_IND" },
69         { MNCC_HOLD_CNF,        "MNCC_HOLD_CNF" },
70         { MNCC_HOLD_REJ,        "MNCC_HOLD_REJ" },
71         { MNCC_RETRIEVE_IND,    "MNCC_RETRIEVE_IND" },
72         { MNCC_RETRIEVE_CNF,    "MNCC_RETRIEVE_CNF" },
73         { MNCC_RETRIEVE_REJ,    "MNCC_RETRIEVE_REJ" },
74         { MNCC_USERINFO_REQ,    "MNCC_USERINFO_REQ" },
75         { MNCC_USERINFO_IND,    "MNCC_USERINFO_IND" },
76         { MNCC_REJ_REQ,         "MNCC_REJ_REQ" },
77         { MNCC_REJ_IND,         "MNCC_REJ_IND" },
78         { MNCC_PROGRESS_IND,    "MNCC_PROGRESS_IND" },
79         { MNCC_CALL_PROC_IND,   "MNCC_CALL_PROC_IND" },
80         { MNCC_CALL_CONF_REQ,   "MNCC_CALL_CONF_REQ" },
81         { MNCC_START_DTMF_REQ,  "MNCC_START_DTMF_REQ" },
82         { MNCC_STOP_DTMF_REQ,   "MNCC_STOP_DTMF_REQ" },
83         { MNCC_HOLD_REQ,        "MNCC_HOLD_REQ " },
84         { MNCC_RETRIEVE_REQ,    "MNCC_RETRIEVE_REQ" },
85
86         { MNCC_LCHAN_MODIFY,    "MNCC_LCHAN_MODIFY" },
87
88         { MNCC_BRIDGE,          "MNCC_BRIDGE" },
89         { MNCC_FRAME_RECV,      "MNCC_FRAME_RECV" },
90         { MNCC_FRAME_DROP,      "MNCC_FRAME_DROP" },
91         { MNCC_RTP_CREATE,      "MNCC_RTP_CREATE" },
92         { MNCC_RTP_CONNECT,     "MNCC_RTP_CONNECT" },
93         { MNCC_RTP_FREE,        "MNCC_RTP_FREE" },
94
95         { 0,                    NULL }
96 };
97
98 const char *mncc_name(int value)
99 {
100         int i = 0;
101         static char ukn[32];
102
103         while (mncc_names[i].name) {
104                 if (mncc_names[i].msg_type == value)
105                         return mncc_names[i].name;
106                 i++;
107         }
108         SPRINT(ukn, "unknown(0x%x)", value);
109         return ukn;
110 }
111
112 static int mncc_send(struct lcr_gsm *lcr_gsm, int msg_type, void *data);
113
114 /*
115  * create and send mncc message
116  */
117 struct gsm_mncc *create_mncc(int msg_type, unsigned int callref)
118 {
119         struct gsm_mncc *mncc;
120
121         mncc = (struct gsm_mncc *)MALLOC(sizeof(struct gsm_mncc));
122         mncc->msg_type = msg_type;
123         mncc->callref = callref;
124         return (mncc);
125 }
126 int send_and_free_mncc(struct lcr_gsm *lcr_gsm, unsigned int msg_type, void *data)
127 {
128         int ret = 0;
129
130         if (lcr_gsm) {
131                 ret = mncc_send(lcr_gsm, msg_type, data);
132         }
133         free(data);
134
135         return ret;
136 }
137
138 void Pgsm::send_mncc_rtp_connect(void)
139 {
140         struct gsm_mncc_rtp *nrtp;
141
142         nrtp = (struct gsm_mncc_rtp *) create_mncc(MNCC_RTP_CONNECT, p_g_callref);
143         nrtp->ip = p_g_rtp_ip_remote;
144         nrtp->port = p_g_rtp_port_remote;
145         switch (p_g_media_type) {
146         case MEDIA_TYPE_GSM:
147                 nrtp->payload_msg_type = GSM_TCHF_FRAME;
148                 break;
149         case MEDIA_TYPE_GSM_EFR:
150                 nrtp->payload_msg_type = GSM_TCHF_FRAME_EFR;
151                 break;
152         case MEDIA_TYPE_AMR:
153                 nrtp->payload_msg_type = GSM_TCH_FRAME_AMR;
154                 break;
155         case MEDIA_TYPE_GSM_HR:
156                 nrtp->payload_msg_type = GSM_TCHH_FRAME;
157                 break;
158         }
159         nrtp->payload_type = p_g_payload_type;
160         PDEBUG(DEBUG_GSM, "sending MNCC RTP connect with payload_msg_type=%x, payload_type=%d\n", nrtp->payload_msg_type, nrtp->payload_type);
161         send_and_free_mncc(p_g_lcr_gsm, nrtp->msg_type, nrtp);
162 }
163
164 static int delete_event(struct lcr_work *work, void *instance, int index);
165
166 /*
167  * constructor
168  */
169 Pgsm::Pgsm(int type, char *portname, struct port_settings *settings, struct interface *interface) : Port(type, portname, settings, interface)
170 {
171 #ifdef WITH_GSMHR
172         signed short homing[160];
173         int i;
174 #endif
175
176         p_g_tones = 0;
177         if (interface->is_tones == IS_YES)
178                 p_g_tones = 1;
179         p_g_earlyb = 0;
180         if (interface->is_earlyb == IS_YES)
181                 p_g_earlyb = 1;
182         p_g_rtp_bridge = 0;
183         if (interface->rtp_bridge)
184                 p_g_rtp_bridge = 1;
185         p_g_rtp_payloads = 0;
186         memset(&p_g_samples, 0, sizeof(p_g_samples));
187         p_callerinfo.itype = (interface->extension)?INFO_ITYPE_ISDN_EXTENSION:INFO_ITYPE_ISDN;
188         memset(&p_g_delete, 0, sizeof(p_g_delete));
189         add_work(&p_g_delete, delete_event, this, 0);
190         p_g_lcr_gsm = NULL;
191         p_g_callref = 0;
192         p_g_mode = 0;
193         p_g_gsm_b_sock = -1;
194         p_g_gsm_b_index = -1;
195         p_g_gsm_b_active = 0;
196         p_g_notify_pending = NULL;
197         p_g_setup_pending = NULL;
198         p_g_connect_pending = NULL;
199         p_g_fr_decoder = NULL;
200         p_g_fr_encoder = NULL;
201         p_g_hr_decoder = NULL;
202         p_g_hr_encoder = NULL;
203         p_g_amr_decoder = NULL;
204         p_g_amr_encoder = NULL;
205         p_g_amr_cmr = 0;
206         p_g_amr_cmr_valid = 0;
207 #ifdef WITH_GSMFR
208         p_g_fr_decoder = gsm_fr_create();
209         p_g_fr_encoder = gsm_fr_create();
210         if (!p_g_fr_encoder || !p_g_fr_decoder) {
211                 PERROR("Failed to create GSM FR codec instance\n");
212                 trigger_work(&p_g_delete);
213         }
214 #endif
215 #ifdef WITH_GSMHR
216         p_g_hr_decoder = gsm_hr_create();
217         p_g_hr_encoder = gsm_hr_create();
218         if (!p_g_hr_encoder || !p_g_hr_decoder) {
219                 PERROR("Failed to create GSM HR codec instance\n");
220                 trigger_work(&p_g_delete);
221         }
222         /* Homing */
223         for (i = 0; i < 160; i++)
224                 homing[i] = 0x0008;
225         gsm_hr_encode(p_g_hr_encoder, homing, NULL);
226 #endif
227 #ifdef WITH_GSMAMR
228         p_g_amr_decoder = gsm_amr_create();
229         p_g_amr_encoder = gsm_amr_create();
230         if (!p_g_amr_encoder || !p_g_amr_decoder) {
231                 PERROR("Failed to create GSM AMR codec instance\n");
232                 trigger_work(&p_g_delete);
233         }
234 #endif
235         p_g_rxpos = 0;
236         p_g_tch_connected = 0;
237         p_g_media_type = 0;
238
239         PDEBUG(DEBUG_GSM, "Created new GSMPort(%s).\n", portname);
240 }
241
242 /*
243  * destructor
244  */
245 Pgsm::~Pgsm()
246 {
247         PDEBUG(DEBUG_GSM, "Destroyed GSM process(%s).\n", p_name);
248
249         del_work(&p_g_delete);
250
251         /* remove queued message */
252         if (p_g_notify_pending)
253                 message_free(p_g_notify_pending);
254         if (p_g_setup_pending)
255                 message_free(p_g_setup_pending);
256         if (p_g_connect_pending)
257                 message_free(p_g_connect_pending);
258
259 //#ifdef WITH_GSMFR
260         /* close codec */
261         if (p_g_fr_encoder)
262                 gsm_fr_destroy(p_g_fr_encoder);
263         if (p_g_fr_decoder)
264                 gsm_fr_destroy(p_g_fr_decoder);
265 //#endif
266 #ifdef WITH_GSMHR
267         if (p_g_hr_encoder)
268                 gsm_hr_destroy(p_g_hr_encoder);
269         if (p_g_hr_decoder)
270                 gsm_hr_destroy(p_g_hr_decoder);
271 #endif
272 #ifdef WITH_GSMAMR
273         /* close codec */
274         if (p_g_amr_encoder)
275                 gsm_amr_destroy(p_g_amr_encoder);
276         if (p_g_amr_decoder)
277                 gsm_amr_destroy(p_g_amr_decoder);
278 #endif
279 }
280
281
282 /* receive encoded frame from gsm */
283 void Pgsm::frame_receive(void *arg)
284 {
285         struct gsm_data_frame *frame = (struct gsm_data_frame *)arg;
286         unsigned char data[160];
287         int i, cmr;
288
289         if (!p_g_fr_decoder)
290                 return;
291
292         switch (frame->msg_type) {
293         case ANALOG_8000HZ:
294                 if (p_g_media_type != MEDIA_TYPE_ANALOG) {
295                         PERROR("'Analog' frame, but current media type mismatches.\n");
296                         return;
297                 }
298                 for (i = 0; i < 160; i++) {
299                         data[i] = audio_s16_to_law[((int16_t *)frame->data)[i] & 0xffff];
300                 }
301                 break;
302         case GSM_TCHF_FRAME:
303                 if (p_g_media_type != MEDIA_TYPE_GSM) {
304                         PERROR("FR frame, but current media type mismatches.\n");
305                         return;
306                 }
307                 if (!p_g_fr_decoder) {
308                         PERROR("FR frame, but decoder not created.\n");
309                         return;
310                 }
311                 if ((frame->data[0]>>4) != 0xd) {
312                         PDEBUG(DEBUG_GSM, "received GSM frame with wrong magig 0x%x\n", frame->data[0]>>4);
313                         goto bfi;
314                 }
315 #ifdef WITH_GSMFR
316                 /* decode */
317                 gsm_fr_decode(p_g_fr_decoder, frame->data, p_g_samples);
318                 for (i = 0; i < 160; i++) {
319                         data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
320                 }
321 #endif
322                 break;
323         case GSM_TCHH_FRAME:
324                 if (p_g_media_type != MEDIA_TYPE_GSM_HR) {
325                         PERROR("HR frame, but current media type mismatches.\n");
326                         return;
327                 }
328                 if (!p_g_hr_decoder) {
329                         PERROR("HR frame, but decoder not created.\n");
330                         return;
331                 }
332                 if ((frame->data[0]>>4) != 0x0)
333                         goto bfi;
334 #ifdef WITH_GSMHR
335                 /* decode */
336                 if (gsm_hr_decode(p_g_hr_decoder, frame->data, p_g_samples))
337                         goto bfi;
338                 for (i = 0; i < 160; i++) {
339                         data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
340                 }
341 #endif
342                 break;
343         case GSM_TCHF_FRAME_EFR:
344                 if (p_g_media_type != MEDIA_TYPE_GSM_EFR) {
345                         PERROR("EFR frame, but current media type mismatches.\n");
346                         return;
347                 }
348                 if (!p_g_amr_decoder) {
349                         PERROR("EFR frame, but decoder not created.\n");
350                         return;
351                 }
352                 if ((frame->data[0]>>4) != 0xc)
353                         goto bfi;
354 #ifdef WITH_GSMAMR
355                 /* decode */
356                 gsm_efr_decode(p_g_amr_decoder, frame->data, p_g_samples);
357                 for (i = 0; i < 160; i++) {
358                         data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
359                 }
360 #endif
361                 break;
362         case GSM_TCH_FRAME_AMR:
363                 if (p_g_media_type != MEDIA_TYPE_AMR) {
364                         PERROR("AMR frame, but current media type mismatches.\n");
365                         return;
366                 }
367                 if (!p_g_amr_decoder) {
368                         PERROR("AMR frame, but decoder not created.\n");
369                         return;
370                 }
371                 cmr = (frame->data[1] >> 4);
372                 if (cmr <= 7) {
373                         p_g_amr_cmr = cmr;
374                         p_g_amr_cmr_valid = 1;
375                 }
376                 if (!(frame->data[2] & 0x04))
377                         goto bfi;
378 #ifdef WITH_GSMAMR
379                 /* decode (skip length byte in front) */
380                 gsm_amr_decode(p_g_amr_decoder, frame->data + 1, p_g_samples);
381                 for (i = 0; i < 160; i++) {
382                         data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
383                 }
384 #endif
385                 break;
386         case GSM_BAD_FRAME:
387         default:
388 bfi:
389                 if (p_echotest) {
390                         /* beep on bad frame */
391                         for (i = 0; i < 160; i++) {
392                                 if ((i & 3) > 2)
393                                         p_g_samples[i] = 15000;
394                                 else
395                                         p_g_samples[i] = -15000;
396                                 data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
397                         }
398                 } else {
399                         /* repeat on bad frame */
400                         for (i = 0; i < 160; i++) {
401                                 p_g_samples[i] = (p_g_samples[i] * 14) >> 4;
402                                 data[i] = audio_s16_to_law[p_g_samples[i] & 0xffff];
403                         }
404                 }
405         }
406
407         /* record data */
408         if (p_record)
409                 record(data, 160, 0); // from down
410         if (p_tap)
411                 tap(data, 160, 0); // from down
412
413         /* local echo */
414         if (p_echotest)
415                 bridge_rx(data, 160);
416
417         /* send to remote*/
418         bridge_tx(data, 160);
419 }
420
421 /* send traffic to gsm */
422 int Pgsm::bridge_rx(unsigned char *data, int len)
423 {
424         int ret;
425
426         if ((ret = Port::bridge_rx(data, len)))
427                 return ret;
428
429         if (p_tone_name[0])
430                 return -EINVAL;
431
432         return audio_send(data, len);
433 }
434
435 int Pgsm::audio_send(unsigned char *data, int len)
436 {
437         unsigned char frame[33];
438
439         /* record data */
440         if (p_record)
441                 record(data, len, 1); // from up
442         if (p_tap)
443                 tap(data, len, 1); // from up
444
445         /* encoder init failed */
446         if (!p_g_fr_encoder)
447                 return -EINVAL;
448
449         /* (currently) not connected, so don't flood tch! */
450         if (!p_g_tch_connected)
451                 return -EINVAL;
452
453         /* write to rx buffer */
454         while(len--) {
455                 p_g_rxdata[p_g_rxpos++] = audio_law_to_s32[*data++];
456                 if (p_g_rxpos != 160)
457                         continue;
458                 p_g_rxpos = 0;
459
460                 switch (p_g_media_type) {
461                 case MEDIA_TYPE_ANALOG:
462                         frame_send(p_g_rxdata, 320, ANALOG_8000HZ);
463                         break;
464                 case MEDIA_TYPE_GSM:
465                         if (!p_g_fr_encoder) {
466                                 PERROR("FR frame, but encoder not created.\n");
467                                 break;
468                         }
469 #ifdef WITH_GSMFR
470                         /* encode data */
471                         gsm_fr_encode(p_g_fr_encoder, p_g_rxdata, frame);
472                         frame_send(frame, 33, GSM_TCHF_FRAME);
473 #endif
474                         break;
475                 case MEDIA_TYPE_GSM_HR:
476                         if (!p_g_hr_encoder) {
477                                 PERROR("HR frame, but encoder not created.\n");
478                                 break;
479                         }
480 #ifdef WITH_GSMHR
481                         /* encode data */
482                         gsm_hr_encode(p_g_hr_encoder, p_g_rxdata, frame);
483                         frame_send(frame, 15, GSM_TCHH_FRAME);
484 #endif
485                         break;
486                 case MEDIA_TYPE_GSM_EFR:
487                         if (!p_g_amr_encoder) {
488                                 PERROR("EFR frame, but encoder not created.\n");
489                                 break;
490                         }
491 #ifdef WITH_GSMAMR
492                         /* encode data */
493                         gsm_efr_encode(p_g_amr_encoder, p_g_rxdata, frame);
494                         frame_send(frame, 31, GSM_TCHF_FRAME_EFR);
495 #endif
496                         break;
497                 case MEDIA_TYPE_AMR:
498                         if (!p_g_amr_encoder) {
499                                 PERROR("AMR frame, but encoder not created.\n");
500                                 break;
501                         }
502                         if (!p_g_amr_cmr_valid) {
503                                 PDEBUG(DEBUG_GSM, "no valid CMR yet.\n");
504                                 break;
505                         }
506 #ifdef WITH_GSMAMR
507                         /* encode data (prefix a length byte) */
508                         int ret;
509                         ret = gsm_amr_encode(p_g_amr_encoder, p_g_rxdata, frame + 1, p_g_amr_cmr);
510                         frame[0] = ret;
511                         frame_send(frame, ret + 1, GSM_TCH_FRAME_AMR);
512 #endif
513                         break;
514                 }
515         }
516
517         return 0;
518 }
519
520 void Pgsm::frame_send(void *_frame, int len, int msg_type)
521 {
522         unsigned char buffer[sizeof(struct gsm_data_frame) + len];
523         struct gsm_data_frame *frame = (struct gsm_data_frame *)buffer;
524         
525         frame->msg_type = msg_type;
526         frame->callref = p_g_callref;
527         memcpy(frame->data, _frame, len);
528
529         if (p_g_lcr_gsm) {
530                 mncc_send(p_g_lcr_gsm, frame->msg_type, frame);
531         }
532 }
533
534 /*
535  * create trace
536  */
537 void gsm_trace_header(const char *interface_name, class Pgsm *port, unsigned int msg_type, int direction)
538 {
539         char msgtext[64];
540         struct interface *interface = interface_first;
541
542         interface = getinterfacebyname(interface_name);
543         if (!interface)
544                 return;
545
546         /* select message and primitive text */
547         SCPY(msgtext, mncc_name(msg_type));
548
549         /* add direction */
550         if (port) {
551                 switch(port->p_type) {
552                 case PORT_TYPE_GSM_BS_OUT:
553                 case PORT_TYPE_GSM_BS_IN:
554                         SCAT(msgtext, " LCR<->BSC");
555                         break;
556                 case PORT_TYPE_GSM_MS_OUT:
557                 case PORT_TYPE_GSM_MS_IN:
558                         SCAT(msgtext, " LCR<->MS");
559                         break;
560                 }
561         } else
562                 SCAT(msgtext, " ----");
563
564         /* init trace with given values */
565         start_trace(-1,
566                     interface,
567                     port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL,
568                     port?port->p_dialinginfo.id:NULL,
569                     direction,
570                     CATEGORY_CH,
571                     port?port->p_serial:0,
572                     msgtext);
573 }
574
575 /* modify lchan to given payload type */
576 void Pgsm::modify_lchan(int media_type)
577 {
578         struct gsm_mncc *mode;
579
580         /* already modified to that media type */
581         if (p_g_media_type == media_type)
582                 return;
583
584         p_g_media_type = media_type;
585         gsm_trace_header(p_interface_name, this, MNCC_LCHAN_MODIFY, DIRECTION_OUT);
586         mode = create_mncc(MNCC_LCHAN_MODIFY, p_g_callref);
587         switch (media_type) {
588         case MEDIA_TYPE_GSM_EFR:
589                 add_trace("speech", "version", "EFR given");
590                 mode->lchan_mode = 0x21; /* GSM V2 */
591                 break;
592         case MEDIA_TYPE_AMR:
593                 add_trace("speech", "version", "AMR given");
594                 mode->lchan_mode = 0x41; /* GSM V3 */
595                 break;
596         default:
597                 add_trace("speech", "version", "Full/Half Rate given");
598                 mode->lchan_mode = 0x01; /* GSM V1 */
599         }
600         mode->lchan_type = 0x02; /* FIXME: unused */
601         add_trace("mode", NULL, "0x%02x", mode->lchan_mode);
602         end_trace();
603         send_and_free_mncc(p_g_lcr_gsm, mode->msg_type, mode);
604 }
605
606 /* CALL PROCEEDING INDICATION (from network) */
607 void Pgsm::call_proc_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
608 {
609         struct lcr_msg *message;
610         struct gsm_mncc *frame;
611
612         gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN);
613         end_trace();
614
615         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_PROCEEDING);
616         message_put(message);
617
618         new_state(PORT_STATE_OUT_PROCEEDING);
619
620         if (p_g_earlyb && !p_g_tch_connected) { /* only if ... */
621                 gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT);
622                 end_trace();
623                 frame = create_mncc(MNCC_FRAME_RECV, p_g_callref);
624                 send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame);
625                 p_g_tch_connected = 1;
626         }
627
628         /* modify to GSM FR (this is GSM user side only, so there is FR supported only) */
629         modify_lchan(MEDIA_TYPE_GSM);
630 }
631
632 /* ALERTING INDICATION */
633 void Pgsm::alert_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
634 {
635         struct lcr_msg *message;
636         struct gsm_mncc *frame;
637
638         gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN);
639         end_trace();
640
641         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_ALERTING);
642         message_put(message);
643
644         new_state(PORT_STATE_OUT_ALERTING);
645
646         if (p_g_earlyb && !p_g_tch_connected) { /* only if ... */
647                 gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT);
648                 end_trace();
649                 frame = create_mncc(MNCC_FRAME_RECV, p_g_callref);
650                 send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame);
651                 p_g_tch_connected = 1;
652         }
653
654         /* modify to GSM FR, if not already */
655         if (!p_g_media_type) {
656                 modify_lchan(MEDIA_TYPE_GSM);
657         }
658 }
659
660 /* CONNECT INDICATION */
661 void Pgsm::setup_cnf(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
662 {
663         struct gsm_mncc *resp, *frame;
664         struct lcr_msg *message;
665
666         SCPY(p_connectinfo.id, mncc->connected.number);
667         SCPY(p_connectinfo.imsi, mncc->imsi);
668         p_connectinfo.present = INFO_PRESENT_ALLOWED;
669         p_connectinfo.screen = INFO_SCREEN_NETWORK;
670         switch (mncc->connected.type) {
671                 case 0x1:
672                 p_connectinfo.ntype = INFO_NTYPE_INTERNATIONAL;
673                 break;
674                 case 0x2:
675                 p_connectinfo.ntype = INFO_NTYPE_NATIONAL;
676                 break;
677                 case 0x4:
678                 p_connectinfo.ntype = INFO_NTYPE_SUBSCRIBER;
679                 break;
680                 default:
681                 p_connectinfo.ntype = INFO_NTYPE_UNKNOWN;
682                 break;
683         }
684         SCPY(p_connectinfo.interface, p_interface_name);
685
686         gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN);
687         if (p_connectinfo.id[0])
688                 add_trace("connect", "number", "%s", p_connectinfo.id);
689         else if (mncc->imsi[0])
690                 SPRINT(p_connectinfo.id, "imsi-%s", p_connectinfo.imsi);
691         if (mncc->imsi[0])
692                 add_trace("connect", "imsi", "%s", p_connectinfo.imsi);
693         end_trace();
694
695         /* send resp */
696         gsm_trace_header(p_interface_name, this, MNCC_SETUP_COMPL_REQ, DIRECTION_OUT);
697         resp = create_mncc(MNCC_SETUP_COMPL_REQ, p_g_callref);
698         end_trace();
699         send_and_free_mncc(p_g_lcr_gsm, resp->msg_type, resp);
700
701         new_state(PORT_STATE_CONNECT);
702
703         if (!p_g_tch_connected) { /* only if ... */
704                 gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT);
705                 end_trace();
706                 frame = create_mncc(MNCC_FRAME_RECV, p_g_callref);
707                 send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame);
708                 p_g_tch_connected = 1;
709         }
710
711         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CONNECT);
712         memcpy(&message->param.connectinfo, &p_connectinfo, sizeof(struct connect_info));
713
714         /* if we have a bridge, but not yet modified, the phone accepts out requested payload.
715          * we force the first in list */
716         if (p_g_rtp_bridge) {
717                 if (!p_g_media_type) {
718                         /* modify to first given type */
719                         modify_lchan(p_g_rtp_media_types[0]);
720                         /* also set payload type */
721                         p_g_payload_type = p_g_rtp_payload_types[0];
722                 }
723                 message->param.connectinfo.rtpinfo.media_types[0] = p_g_media_type;
724                 message->param.connectinfo.rtpinfo.payload_types[0] = p_g_payload_type;
725                 message->param.connectinfo.rtpinfo.payloads = 1;
726         } else {
727                 /* modify to GSM FR, if not already
728                 * for network side, this should have been already happened */
729                 if (!p_g_media_type)
730                         modify_lchan(MEDIA_TYPE_GSM);
731         }
732
733
734         if (p_g_rtp_bridge) {
735                 struct gsm_mncc_rtp *rtp;
736
737                 PDEBUG(DEBUG_GSM, "Request RTP peer info, before forwarding connect msg\n");
738                 p_g_connect_pending = message;
739                 rtp = (struct gsm_mncc_rtp *) create_mncc(MNCC_RTP_CREATE, p_g_callref);
740                 send_and_free_mncc(p_g_lcr_gsm, rtp->msg_type, rtp);
741         } else
742                 message_put(message);
743 }
744
745 /* CONNECT ACK INDICATION */
746 void Pgsm::setup_compl_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
747 {
748         struct gsm_mncc *frame;
749
750         gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN);
751         end_trace();
752
753         new_state(PORT_STATE_CONNECT);
754
755         if (!p_g_tch_connected) { /* only if ... */
756                 gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT);
757                 end_trace();
758                 frame = create_mncc(MNCC_FRAME_RECV, p_g_callref);
759                 send_and_free_mncc(p_g_lcr_gsm, frame->msg_type, frame);
760                 p_g_tch_connected = 1;
761         }
762
763         /* modify to GSM FR, if not already */
764         if (!p_g_media_type) {
765                 modify_lchan(MEDIA_TYPE_GSM);
766         }
767 }
768
769 /* DISCONNECT INDICATION */
770 void Pgsm::disc_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
771 {
772         struct lcr_msg *message;
773         int cause = 16, location = 0;
774         struct gsm_mncc *resp;
775
776         gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN);
777         if (mncc->fields & MNCC_F_CAUSE) {
778                 location = mncc->cause.location;
779                 cause = mncc->cause.value;
780                 add_trace("cause", "coding", "%d", mncc->cause.coding);
781                 add_trace("cause", "location", "%d", location);
782                 add_trace("cause", "value", "%d", cause);
783         }
784         end_trace();
785
786         /* send release */
787         resp = create_mncc(MNCC_REL_REQ, p_g_callref);
788         gsm_trace_header(p_interface_name, this, MNCC_REL_REQ, DIRECTION_OUT);
789 #if 0
790         resp->fields |= MNCC_F_CAUSE;
791         resp->cause.coding = 3;
792         resp->cause.location = 1;
793         resp->cause.value = cause;
794         add_trace("cause", "coding", "%d", resp->cause.coding);
795         add_trace("cause", "location", "%d", resp->cause.location);
796         add_trace("cause", "value", "%d", resp->cause.value);
797 #endif
798         end_trace();
799         send_and_free_mncc(p_g_lcr_gsm, resp->msg_type, resp);
800
801         /* sending release to endpoint */
802         while(p_epointlist) {
803                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
804                 message->param.disconnectinfo.cause = cause;
805                 message->param.disconnectinfo.location = location;
806                 message_put(message);
807                 /* remove epoint */
808                 free_epointlist(p_epointlist);
809         }
810         new_state(PORT_STATE_RELEASE);
811         trigger_work(&p_g_delete);
812 }
813
814 /* CC_RELEASE INDICATION */
815 void Pgsm::rel_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
816 {
817         int location = 0, cause = 16;
818         struct lcr_msg *message;
819
820         gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN);
821         if (mncc->fields & MNCC_F_CAUSE) {
822                 location = mncc->cause.location;
823                 cause = mncc->cause.value;
824                 add_trace("cause", "coding", "%d", mncc->cause.coding);
825                 add_trace("cause", "location", "%d", mncc->cause.location);
826                 add_trace("cause", "value", "%d", mncc->cause.value);
827         }
828         end_trace();
829
830         /* sending release to endpoint */
831         while(p_epointlist) {
832                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
833                 message->param.disconnectinfo.cause = cause;
834                 message->param.disconnectinfo.location = location;
835                 message_put(message);
836                 /* remove epoint */
837                 free_epointlist(p_epointlist);
838         }
839         new_state(PORT_STATE_RELEASE);
840         trigger_work(&p_g_delete);
841 }
842
843 /* NOTIFY INDICATION */
844 void Pgsm::notify_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
845 {
846         struct lcr_msg *message;
847
848         gsm_trace_header(p_interface_name, this, msg_type, DIRECTION_IN);
849         add_trace("notify", NULL, "%d", mncc->notify);
850         end_trace();
851
852         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_NOTIFY);
853         message->param.notifyinfo.notify = mncc->notify;
854         message_put(message);
855 }
856
857 /* MESSAGE_NOTIFY */
858 void Pgsm::message_notify(unsigned int epoint_id, int message_id, union parameter *param)
859 {
860         struct gsm_mncc *mncc;
861         int notify;
862
863 //      printf("if = %d\n", param->notifyinfo.notify);
864         if (param->notifyinfo.notify>INFO_NOTIFY_NONE) {
865                 notify = param->notifyinfo.notify & 0x7f;
866                 if (p_state!=PORT_STATE_CONNECT /*&& p_state!=PORT_STATE_IN_PROCEEDING*/ && p_state!=PORT_STATE_IN_ALERTING) {
867                         /* queue notification */
868                         if (p_g_notify_pending)
869                                 message_free(p_g_notify_pending);
870                         p_g_notify_pending = message_create(ACTIVE_EPOINT(p_epointlist), p_serial, EPOINT_TO_PORT, message_id);
871                         memcpy(&p_g_notify_pending->param, param, sizeof(union parameter));
872                 } else {
873                         /* sending notification */
874                         gsm_trace_header(p_interface_name, this, MNCC_NOTIFY_REQ, DIRECTION_OUT);
875                         add_trace("notify", NULL, "%d", notify);
876                         end_trace();
877                         mncc = create_mncc(MNCC_NOTIFY_REQ, p_g_callref);
878                         mncc->notify = notify;
879                         send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc);
880                 }
881         }
882 }
883
884 /* RTP create indication */
885 void Pgsm::rtp_create_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
886 {
887         struct gsm_mncc_rtp *rtp = (struct gsm_mncc_rtp *) mncc;
888
889         /* send queued setup, as we received remote RTP info */
890         if (p_g_setup_pending) {
891                 struct lcr_msg *message;
892
893                 message = p_g_setup_pending;
894                 PDEBUG(DEBUG_GSM, "Got RTP peer info (%08x,%d) forwarding setup\n", rtp->ip, rtp->port);
895                 message->param.setup.rtpinfo.ip = rtp->ip;
896                 message->param.setup.rtpinfo.port = rtp->port;
897                 message_put(message);
898                 p_g_setup_pending = NULL;
899         }
900         if (p_g_connect_pending) {
901                 PDEBUG(DEBUG_GSM, "Got RTP peer info (%08x,%d) connecting RTP... \n", rtp->ip, rtp->port);
902                 send_mncc_rtp_connect();
903         }
904 }
905
906 /* RTP connect indication */
907 void Pgsm::rtp_connect_ind(unsigned int msg_type, unsigned int callref, struct gsm_mncc *mncc)
908 {
909         struct lcr_msg *message;
910         struct gsm_mncc_rtp *rtp = (struct gsm_mncc_rtp *) mncc;
911
912         if (p_g_connect_pending) {
913                 message = p_g_connect_pending;
914                 PDEBUG(DEBUG_GSM, "Got RTP peer info (%08x,%d) forwarding connect\n", rtp->ip, rtp->port);
915                 message->param.connectinfo.rtpinfo.ip = rtp->ip;
916                 message->param.connectinfo.rtpinfo.port = rtp->port;
917                 message_put(message);
918                 p_g_connect_pending = NULL;
919         }
920 }
921
922 /* MESSAGE_PROGRESS */
923 void Pgsm::message_progress(unsigned int epoint_id, int message_id, union parameter *param)
924 {
925         if (param->progressinfo.progress == 8) {
926                 PDEBUG(DEBUG_GSM, "Remote provides tones for us\n");
927                 p_g_tones = 1;
928         }
929
930         if (param->progressinfo.rtpinfo.port) {
931                 PDEBUG(DEBUG_GSM, "PROGRESS with RTP peer info, sent to BSC (%08x,%d) with media %d, pt %d\n", param->progressinfo.rtpinfo.ip, param->progressinfo.rtpinfo.port, param->progressinfo.rtpinfo.media_types[0], param->progressinfo.rtpinfo.payload_types[0]);
932
933                 /* modify channel to givne type, also sets media type */
934                 modify_lchan(param->progressinfo.rtpinfo.media_types[0]);
935
936                 /* connect RTP */
937                 p_g_rtp_ip_remote = param->progressinfo.rtpinfo.ip;
938                 p_g_rtp_port_remote = param->progressinfo.rtpinfo.port;
939                 /* p_g_media_type is already set by modify_lchan() */
940                 p_g_payload_type = param->progressinfo.rtpinfo.payload_types[0];
941                 send_mncc_rtp_connect();
942         }
943 }
944
945 /* MESSAGE_ALERTING */
946 void Pgsm::message_alerting(unsigned int epoint_id, int message_id, union parameter *param)
947 {
948         struct gsm_mncc *mncc;
949
950         /* send alert */
951         gsm_trace_header(p_interface_name, this, MNCC_ALERT_REQ, DIRECTION_OUT);
952         mncc = create_mncc(MNCC_ALERT_REQ, p_g_callref);
953         if (p_g_tones) {
954                 mncc->fields |= MNCC_F_PROGRESS;
955                 mncc->progress.coding = 3; /* GSM */
956                 mncc->progress.location = 1;
957                 mncc->progress.descr = 8;
958                 add_trace("progress", "coding", "%d", mncc->progress.coding);
959                 add_trace("progress", "location", "%d", mncc->progress.location);
960                 add_trace("progress", "descr", "%d", mncc->progress.descr);
961         }
962         end_trace();
963         send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc);
964
965         new_state(PORT_STATE_IN_ALERTING);
966
967         if (p_g_tones && !p_g_tch_connected) { /* only if ... */
968                 gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT);
969                 end_trace();
970                 mncc = create_mncc(MNCC_FRAME_RECV, p_g_callref);
971                 send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc);
972                 p_g_tch_connected = 1;
973         }
974
975         /* modify to GSM FR, if not already */
976         if (!p_g_media_type) {
977                 modify_lchan(MEDIA_TYPE_GSM);
978         }
979 }
980
981 /* MESSAGE_CONNECT */
982 void Pgsm::message_connect(unsigned int epoint_id, int message_id, union parameter *param)
983 {
984         struct gsm_mncc *mncc;
985
986         /* copy connected information */
987         memcpy(&p_connectinfo, &param->connectinfo, sizeof(p_connectinfo));
988         /* screen outgoing caller id */
989         do_screen(1, p_connectinfo.id, sizeof(p_connectinfo.id), &p_connectinfo.ntype, &p_connectinfo.present, p_interface_name);
990
991         /* send connect */
992         mncc = create_mncc(MNCC_SETUP_RSP, p_g_callref);
993         gsm_trace_header(p_interface_name, this, MNCC_SETUP_RSP, DIRECTION_OUT);
994         /* caller information */
995         mncc->fields |= MNCC_F_CONNECTED;
996         mncc->connected.plan = 1;
997         switch (p_callerinfo.ntype) {
998                 case INFO_NTYPE_UNKNOWN:
999                 mncc->connected.type = 0x0;
1000                 break;
1001                 case INFO_NTYPE_INTERNATIONAL:
1002                 mncc->connected.type = 0x1;
1003                 break;
1004                 case INFO_NTYPE_NATIONAL:
1005                 mncc->connected.type = 0x2;
1006                 break;
1007                 case INFO_NTYPE_SUBSCRIBER:
1008                 mncc->connected.type = 0x4;
1009                 break;
1010                 default: /* INFO_NTYPE_NOTPRESENT */
1011                 mncc->fields &= ~MNCC_F_CONNECTED;
1012                 break;
1013         }
1014         switch (p_callerinfo.screen) {
1015                 case INFO_SCREEN_USER:
1016                 mncc->connected.screen = 0;
1017                 break;
1018                 default: /* INFO_SCREEN_NETWORK */
1019                 mncc->connected.screen = 3;
1020                 break;
1021         }
1022         switch (p_callerinfo.present) {
1023                 case INFO_PRESENT_ALLOWED:
1024                 mncc->connected.present = 0;
1025                 break;
1026                 case INFO_PRESENT_RESTRICTED:
1027                 mncc->connected.present = 1;
1028                 break;
1029                 default: /* INFO_PRESENT_NOTAVAIL */
1030                 mncc->connected.present = 2;
1031                 break;
1032         }
1033         if (mncc->fields & MNCC_F_CONNECTED) {
1034                 SCPY(mncc->connected.number, p_connectinfo.id);
1035                 add_trace("connected", "type", "%d", mncc->connected.type);
1036                 add_trace("connected", "plan", "%d", mncc->connected.plan);
1037                 add_trace("connected", "present", "%d", mncc->connected.present);
1038                 add_trace("connected", "screen", "%d", mncc->connected.screen);
1039                 add_trace("connected", "number", "%s", mncc->connected.number);
1040         }
1041         end_trace();
1042         send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc);
1043
1044         new_state(PORT_STATE_CONNECT_WAITING);
1045
1046         if (param->connectinfo.rtpinfo.port) {
1047                 PDEBUG(DEBUG_GSM, "CONNECT with RTP peer info, sent to BSC (%08x,%d)\n", param->connectinfo.rtpinfo.ip, param->connectinfo.rtpinfo.port);
1048
1049                 /* modify channel to givne type, also sets media type */
1050                 modify_lchan(param->connectinfo.rtpinfo.media_types[0]);
1051
1052                 /* connect RTP */
1053                 p_g_rtp_ip_remote = param->connectinfo.rtpinfo.ip;
1054                 p_g_rtp_port_remote = param->connectinfo.rtpinfo.port;
1055                 /* p_g_media_type is already set by modify_lchan() */
1056                 p_g_payload_type = param->connectinfo.rtpinfo.payload_types[0];
1057                 send_mncc_rtp_connect();
1058         }
1059 }
1060
1061 /* MESSAGE_DISCONNECT */
1062 void Pgsm::message_disconnect(unsigned int epoint_id, int message_id, union parameter *param)
1063 {
1064         struct gsm_mncc *mncc;
1065
1066         /* send disconnect */
1067         mncc = create_mncc(MNCC_DISC_REQ, p_g_callref);
1068         gsm_trace_header(p_interface_name, this, MNCC_DISC_REQ, DIRECTION_OUT);
1069         if (p_g_tones) {
1070                 mncc->fields |= MNCC_F_PROGRESS;
1071                 mncc->progress.coding = 3; /* GSM */
1072                 mncc->progress.location = 1;
1073                 mncc->progress.descr = 8;
1074                 add_trace("progress", "coding", "%d", mncc->progress.coding);
1075                 add_trace("progress", "location", "%d", mncc->progress.location);
1076                 add_trace("progress", "descr", "%d", mncc->progress.descr);
1077         }
1078         mncc->fields |= MNCC_F_CAUSE;
1079         mncc->cause.coding = 3;
1080         mncc->cause.location = param->disconnectinfo.location;
1081         mncc->cause.value = param->disconnectinfo.cause;
1082         add_trace("cause", "coding", "%d", mncc->cause.coding);
1083         add_trace("cause", "location", "%d", mncc->cause.location);
1084         add_trace("cause", "value", "%d", mncc->cause.value);
1085         end_trace();
1086         send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc);
1087
1088         new_state(PORT_STATE_OUT_DISCONNECT);
1089
1090         if (p_g_tones && !p_g_tch_connected) { /* only if ... */
1091                 gsm_trace_header(p_interface_name, this, MNCC_FRAME_RECV, DIRECTION_OUT);
1092                 end_trace();
1093                 mncc = create_mncc(MNCC_FRAME_RECV, p_g_callref);
1094                 send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc);
1095                 p_g_tch_connected = 1;
1096         }
1097 }
1098
1099
1100 /* MESSAGE_RELEASE */
1101 void Pgsm::message_release(unsigned int epoint_id, int message_id, union parameter *param)
1102 {
1103         struct gsm_mncc *mncc;
1104
1105         /* send release */
1106         mncc = create_mncc(MNCC_REL_REQ, p_g_callref);
1107         gsm_trace_header(p_interface_name, this, MNCC_REL_REQ, DIRECTION_OUT);
1108         mncc->fields |= MNCC_F_CAUSE;
1109         mncc->cause.coding = 3;
1110         mncc->cause.location = param->disconnectinfo.location;
1111         mncc->cause.value = param->disconnectinfo.cause;
1112         add_trace("cause", "coding", "%d", mncc->cause.coding);
1113         add_trace("cause", "location", "%d", mncc->cause.location);
1114         add_trace("cause", "value", "%d", mncc->cause.value);
1115         end_trace();
1116         send_and_free_mncc(p_g_lcr_gsm, mncc->msg_type, mncc);
1117
1118         new_state(PORT_STATE_RELEASE);
1119         trigger_work(&p_g_delete);
1120         return;
1121 }
1122
1123 /*
1124  * endpoint sends messages to the port
1125  */
1126 int Pgsm::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
1127 {
1128         int ret = 0;
1129
1130         if (Port::message_epoint(epoint_id, message_id, param))
1131                 return 1;
1132
1133         switch(message_id) {
1134                 case MESSAGE_NOTIFY: /* display and notifications */
1135                 ret = 1;
1136                 message_notify(epoint_id, message_id, param);
1137                 break;
1138
1139 //              case MESSAGE_FACILITY: /* facility message */
1140 //              message_facility(epoint_id, message_id, param);
1141 //              break;
1142
1143                 case MESSAGE_PROCEEDING: /* message not handles */
1144                 ret = 1;
1145                 break;
1146
1147                 case MESSAGE_PROGRESS:
1148                 ret = 1;
1149                 message_progress(epoint_id, message_id, param);
1150                 break;
1151
1152                 case MESSAGE_ALERTING: /* call of endpoint is ringing */
1153                 ret = 1;
1154                 if (p_state!=PORT_STATE_IN_PROCEEDING)
1155                         break;
1156                 message_alerting(epoint_id, message_id, param);
1157                 if (p_g_notify_pending) {
1158                         /* send pending notify message during connect */
1159                         message_notify(ACTIVE_EPOINT(p_epointlist), p_g_notify_pending->type, &p_g_notify_pending->param);
1160                         message_free(p_g_notify_pending);
1161                         p_g_notify_pending = NULL;
1162                 }
1163                 break;
1164
1165                 case MESSAGE_CONNECT: /* call of endpoint is connected */
1166                 ret = 1;
1167                 if (p_state!=PORT_STATE_IN_PROCEEDING
1168                  && p_state!=PORT_STATE_IN_ALERTING)
1169                         break;
1170                 message_connect(epoint_id, message_id, param);
1171                 if (p_g_notify_pending) {
1172                         /* send pending notify message during connect */
1173                         message_notify(ACTIVE_EPOINT(p_epointlist), p_g_notify_pending->type, &p_g_notify_pending->param);
1174                         message_free(p_g_notify_pending);
1175                         p_g_notify_pending = NULL;
1176                 }
1177                 break;
1178
1179                 case MESSAGE_DISCONNECT: /* call has been disconnected */
1180                 ret = 1;
1181                 if (p_state!=PORT_STATE_IN_PROCEEDING
1182                  && p_state!=PORT_STATE_IN_ALERTING
1183                  && p_state!=PORT_STATE_OUT_SETUP
1184                  && p_state!=PORT_STATE_OUT_OVERLAP
1185                  && p_state!=PORT_STATE_OUT_PROCEEDING
1186                  && p_state!=PORT_STATE_OUT_ALERTING
1187                  && p_state!=PORT_STATE_CONNECT
1188                  && p_state!=PORT_STATE_CONNECT_WAITING)
1189                         break;
1190                 message_disconnect(epoint_id, message_id, param);
1191                 break;
1192
1193                 case MESSAGE_RELEASE: /* release isdn port */
1194                 ret = 1;
1195                 if (p_state==PORT_STATE_RELEASE)
1196                         break;
1197                 message_release(epoint_id, message_id, param);
1198                 break;
1199
1200         }
1201
1202         return ret;
1203 }
1204
1205 /* deletes only if l3id is release, otherwhise it will be triggered then */
1206 static int delete_event(struct lcr_work *work, void *instance, int index)
1207 {
1208         class Pgsm *gsmport = (class Pgsm *)instance;
1209
1210         delete gsmport;
1211
1212         return 0;
1213 }
1214
1215 int gsm_exit(int rc)
1216 {
1217         return(rc);
1218 }
1219
1220 int gsm_init(void)
1221 {
1222         /* seed the PRNG */
1223         srand(time(NULL));
1224
1225         return 0;
1226 }
1227
1228 /*
1229  * MNCC interface
1230  */
1231
1232 static int mncc_q_enqueue(struct lcr_gsm *lcr_gsm, struct gsm_mncc *mncc, unsigned int len)
1233 {
1234         struct mncc_q_entry *qe;
1235
1236         qe = (struct mncc_q_entry *) MALLOC(sizeof(*qe)+sizeof(*mncc)+len);
1237         if (!qe)
1238                 return -ENOMEM;
1239
1240         qe->next = NULL;
1241         qe->len = len;
1242         memcpy(qe->data, mncc, len);
1243
1244         /* in case of empty list ... */
1245         if (!lcr_gsm->mncc_q_hd && !lcr_gsm->mncc_q_tail) {
1246                 /* the list head and tail both point to the new qe */
1247                 lcr_gsm->mncc_q_hd = lcr_gsm->mncc_q_tail = qe;
1248         } else {
1249                 /* append to tail of list */
1250                 lcr_gsm->mncc_q_tail->next = qe;
1251                 lcr_gsm->mncc_q_tail = qe;
1252         }
1253
1254         lcr_gsm->mncc_lfd.when |= LCR_FD_WRITE;
1255
1256         return 0;
1257 }
1258
1259 static struct mncc_q_entry *mncc_q_dequeue(struct lcr_gsm *lcr_gsm)
1260 {
1261         struct mncc_q_entry *qe = lcr_gsm->mncc_q_hd;
1262         if (!qe)
1263                 return NULL;
1264
1265         /* dequeue the successfully sent message */
1266         lcr_gsm->mncc_q_hd = qe->next;
1267         if (!qe)
1268                 return NULL;
1269         if (qe == lcr_gsm->mncc_q_tail)
1270                 lcr_gsm->mncc_q_tail = NULL;
1271
1272         return qe;
1273 }
1274
1275 /* routine called by LCR code if it wants to send a message to OpenBSC */
1276 static int mncc_send(struct lcr_gsm *lcr_gsm, int msg_type, void *data)
1277 {
1278         int len = 0;
1279
1280         /* FIXME: the caller should provide this */
1281         switch (msg_type) {
1282         case ANALOG_8000HZ:
1283                 len = sizeof(struct gsm_data_frame) + 320;
1284                 break;
1285         case GSM_TCHF_FRAME:
1286                 len = sizeof(struct gsm_data_frame) + 33;
1287                 break;
1288         default:
1289                 len = sizeof(struct gsm_mncc);
1290                 break;
1291         }
1292                 
1293         return mncc_q_enqueue(lcr_gsm, (struct gsm_mncc *)data, len);
1294 }
1295
1296 /* close MNCC socket */
1297 static int mncc_fd_close(struct lcr_gsm *lcr_gsm, struct lcr_fd *lfd)
1298 {
1299         class Port *port;
1300         class Pgsm *pgsm = NULL;
1301         struct lcr_msg *message;
1302
1303         PERROR("Lost MNCC socket, retrying in %u seconds\n", SOCKET_RETRY_TIMER);
1304         close(lfd->fd);
1305         unregister_fd(lfd);
1306         lfd->fd = -1;
1307
1308         /* free all the calls that were running through the MNCC interface */
1309         port = port_first;
1310         while(port) {
1311                 if ((port->p_type & PORT_CLASS_MASK) == PORT_CLASS_GSM) {
1312                         pgsm = (class Pgsm *)port;
1313                         if (pgsm->p_g_lcr_gsm == lcr_gsm) {
1314                                 message = message_create(pgsm->p_serial, ACTIVE_EPOINT(pgsm->p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
1315                                 message->param.disconnectinfo.cause = 41; // temp. fail.
1316                                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1317                                 message_put(message);
1318                                 pgsm->new_state(PORT_STATE_RELEASE);
1319                                 trigger_work(&pgsm->p_g_delete);
1320                         }
1321                 }
1322                 port = port->next;
1323         }
1324
1325         /* flush the queue */
1326         while (mncc_q_dequeue(lcr_gsm))
1327                 ;
1328
1329         /* start the re-connect timer */
1330         schedule_timer(&lcr_gsm->socket_retry, SOCKET_RETRY_TIMER, 0);
1331
1332         return 0;
1333 }
1334
1335 /* write to OpenBSC via MNCC socket */
1336 static int mncc_fd_write(struct lcr_fd *lfd, void *inst, int idx)
1337 {
1338         struct lcr_gsm *lcr_gsm = (struct lcr_gsm *) inst;
1339         struct mncc_q_entry *qe, *qe2;
1340         int rc;
1341
1342         while (1) {
1343                 qe = lcr_gsm->mncc_q_hd;
1344                 if (!qe) {
1345                         lfd->when &= ~LCR_FD_WRITE;
1346                         break;
1347                 }
1348                 rc = write(lfd->fd, qe->data, qe->len);
1349                 if (rc == 0)
1350                         return mncc_fd_close(lcr_gsm, lfd);
1351                 if (rc < 0)
1352                         return rc;
1353                 if (rc < (int)qe->len)
1354                         return -1;
1355                 /* dequeue the successfully sent message */
1356                 qe2 = mncc_q_dequeue(lcr_gsm);
1357                 assert(qe == qe2);
1358                 free(qe);
1359         }
1360         return 0;
1361 }
1362
1363 /* read from OpenBSC via MNCC socket */
1364 static int mncc_fd_read(struct lcr_fd *lfd, void *inst, int idx)
1365 {
1366         struct lcr_gsm *lcr_gsm = (struct lcr_gsm *) inst;
1367         int rc;
1368         static char buf[sizeof(struct gsm_mncc)+1024];
1369         struct gsm_mncc *mncc_prim = (struct gsm_mncc *) buf;
1370         struct gsm_mncc_hello *hello = (struct gsm_mncc_hello *) buf;
1371         class Port *port;
1372         class Pgsm *pgsm = NULL;
1373         unsigned int callref;
1374
1375         memset(buf, 0, sizeof(buf));
1376         rc = recv(lfd->fd, buf, sizeof(buf), 0);
1377         if (rc == 0)
1378                 return mncc_fd_close(lcr_gsm, lfd);
1379         if (rc < 0)
1380                 return rc;
1381
1382         /* TODO: size check? */
1383         switch (mncc_prim->msg_type) {
1384         case MNCC_SOCKET_HELLO:
1385                 if (hello->version != MNCC_SOCK_VERSION) {
1386                         PERROR("MNCC version different. BSC version is %u\n", hello->version);
1387                         mncc_fd_close(lcr_gsm, lfd);
1388                         return 0;
1389                 }
1390                 if (hello->mncc_size != sizeof(struct gsm_mncc)) {
1391                         PERROR("MNCC gsm_mncc size differs: %u %u\n",
1392                                 hello->mncc_size, sizeof(struct gsm_mncc));
1393                         mncc_fd_close(lcr_gsm, lfd);
1394                         return 0;
1395                 }
1396                 if (hello->data_frame_size != sizeof(struct gsm_data_frame)) {
1397                         PERROR("MNCC gsm_mncc size differs: %u %u\n",
1398                                 hello->data_frame_size, sizeof(struct gsm_data_frame));
1399                         mncc_fd_close(lcr_gsm, lfd);
1400                         return 0;
1401                 }
1402
1403 #define CHECK_OFFSET(hello, field, lcr_gsm, lfd)        \
1404                 if (hello->field ##_offset != __builtin_offsetof(struct gsm_mncc, field)) {     \
1405                         PERROR("MNCC gsm_mncc offset of %s is %u %u\n",                         \
1406                                 #field, hello->field ##_offset,                                 \
1407                                 __builtin_offsetof(struct gsm_mncc, field));                    \
1408                         mncc_fd_close(lcr_gsm, lfd);                                            \
1409                         return 0;                                                               \
1410                 }
1411
1412                 CHECK_OFFSET(hello, called, lcr_gsm, lfd);
1413                 CHECK_OFFSET(hello, signal, lcr_gsm, lfd);
1414                 CHECK_OFFSET(hello, emergency, lcr_gsm, lfd);
1415                 CHECK_OFFSET(hello, lchan_type, lcr_gsm, lfd);
1416 #undef CHECK_OFFSET
1417
1418                 break;
1419         }
1420
1421         /* Find port object */
1422         callref = mncc_prim->callref;
1423         port = port_first;
1424         while(port) {
1425                 if ((port->p_type & PORT_CLASS_MASK) == PORT_CLASS_GSM) {
1426                         pgsm = (class Pgsm *)port;
1427                         if (pgsm->p_g_lcr_gsm == lcr_gsm && pgsm->p_g_callref == callref)
1428                                 break;
1429                 }
1430                 port = port->next;
1431         }
1432
1433         /* Hand the MNCC message into LCR */
1434         switch (lcr_gsm->type) {
1435 #ifdef WITH_GSM_BS
1436         case LCR_GSM_TYPE_NETWORK:
1437                 if (port && (port->p_type & PORT_CLASS_GSM_MASK) != PORT_CLASS_GSM_BS)
1438                         FATAL("Port is set and bound to network socket, but is not of network type, please fix");
1439                 return message_bsc((class Pgsm_bs *)port, lcr_gsm, mncc_prim->msg_type, mncc_prim);
1440 #endif
1441 #ifdef WITH_GSM_MS
1442         case LCR_GSM_TYPE_MS:
1443                 if (port && (port->p_type & PORT_CLASS_GSM_MASK) != PORT_CLASS_GSM_MS)
1444                         FATAL("Port is set and bound to mobile socket, but is not of mobile type, please fix");
1445                 return message_ms((class Pgsm_ms *)port, lcr_gsm, mncc_prim->msg_type, mncc_prim);
1446 #endif
1447         default:
1448                 return 0;
1449         }
1450 }
1451
1452 /* file descriptor callback if we can read or write form MNCC socket */
1453 static int mncc_fd_cb(struct lcr_fd *lfd, unsigned int what, void *inst, int idx)
1454 {
1455         int rc = 0;
1456
1457         if (what & LCR_FD_READ)
1458                 rc = mncc_fd_read(lfd, inst, idx);
1459         if (rc < 0)
1460                 return rc;
1461
1462         if (what & LCR_FD_WRITE)
1463                 rc = mncc_fd_write(lfd, inst, idx);
1464
1465         return rc;
1466 }
1467
1468 int mncc_socket_retry_cb(struct lcr_timer *timer, void *inst, int index)
1469 {
1470         struct lcr_gsm *lcr_gsm = (struct lcr_gsm *) inst;
1471         int fd, rc;
1472
1473         lcr_gsm->mncc_lfd.fd = -1;
1474
1475         fd = socket(PF_UNIX, SOCK_SEQPACKET, 0);
1476         if (fd < 0) {
1477                 PERROR("Cannot create SEQPACKET socket, giving up!\n");
1478                 return fd;
1479         }
1480
1481         rc = connect(fd, (struct sockaddr *) &lcr_gsm->sun,
1482                      sizeof(lcr_gsm->sun));
1483         if (rc < 0) {
1484                 PERROR("Could not connect to MNCC socket %s, "
1485                         "retrying in %u seconds\n", lcr_gsm->sun.sun_path,
1486                         SOCKET_RETRY_TIMER);
1487                 close(fd);
1488                 schedule_timer(&lcr_gsm->socket_retry, SOCKET_RETRY_TIMER, 0);
1489         } else {
1490                 PDEBUG(DEBUG_GSM, "Connected to MNCC socket %s!\n", lcr_gsm->sun.sun_path);
1491                 lcr_gsm->mncc_lfd.fd = fd;
1492                 register_fd(&lcr_gsm->mncc_lfd, LCR_FD_READ, &mncc_fd_cb, lcr_gsm, 0);
1493         }
1494
1495         return 0;
1496 }
1497