ss5.cpp

   1 /*****************************************************************************\
   2 **                                                                           **
   3 ** LCR                                                                       **
   4 **                                                                           **
   5 **---------------------------------------------------------------------------**
   6 ** Copyright: Andreas Eversberg                                              **
   7 **                                                                           **
   8 ** mISDN ss5                                                                 **
   9 **                                                                           **
  10 \*****************************************************************************/
  11
  12 /*
  13  * STATES:
  14  *
  15  * there are three types of states
  16  *
  17  * - the port state (p_state): used for current call state
  18  * - the ss5 state (p_m_s_state): used for current tone
  19  * - the ss5 signal state (p_m_s_signal): used for current signal state of current tone
  20  *
  21  * the port state differs from isdn state:
  22  *
  23  * - PORT_STATE_IDLE: used until number is complete. outgoing overlap dialing is received in this state.
  24  * - PORT_STATE_OUT_SETUP: the seizing procedure is started.
  25  * - PORT_STATE_OUT_OVERLAP: the transmitter is sending the digits.
  26  * - PORT_STATE_OUT_PROCEEDING: the digits are sent, we wait until someone answers.
  27  * - PORT_STATE_OUT_DISCONNECT: a clear-back is sent, after DISCONNECT was received
  28  * - PORT_STATE_CONNECT: a call is answered on either side.
  29  * - PORT_STATE_IN_SETUP: the seizing is received, we wait for the first digit.
  30  * - PORT_STATE_IN_OVERLAP: the digits are received.
  31  * - PORT_STATE_IN_PROCEEDING: the number is complete, a SETUP is indicated.
  32  * - PORT_STATE_IN_DISCONNECT: a clear-back was received, an DISCONNECT is indicated.
  33  * - PORT_STATE_RELEASE: the clear forward procedure is started.
  34  *
  35  */
  36
  37 #include "main.h"
  38
  39 //#define DEBUG_DETECT
  40
  41 /* ss5 signal states */
  42 enum {
  43         SS5_STATE_IDLE,                 /* no signal */
  44         SS5_STATE_SEIZING,              /* seizing */
  45         SS5_STATE_PROCEED_TO_SEND,      /* proceed-to-send */
  46         SS5_STATE_BUSY_FLASH,           /* busy-flash / clear back */
  47         SS5_STATE_ACK_BUSY_FLASH,       /* acknowledge of busy/answer/clear-back */
  48         SS5_STATE_ANSWER,               /* answer */
  49         SS5_STATE_ACK_ANSWER,           /* acknowledge of busy/answer/clear-back */
  50         SS5_STATE_FORWARD_TRANSFER,     /* forward transfer */
  51         SS5_STATE_CLEAR_BACK,           /* clear-back */
  52         SS5_STATE_ACK_CLEAR_BACK,       /* acknowledge of busy/answer/clear-back */
  53         SS5_STATE_CLEAR_FORWARD,        /* clear-forward */
  54         SS5_STATE_RELEASE_GUARD,        /* release-guard */
  55         SS5_STATE_DIAL_OUT,             /* dialing state (transmitter) */
  56         SS5_STATE_DIAL_IN,              /* dialing state (receiver) */
  57         SS5_STATE_DIAL_IN_PULSE,        /* dialing state (receiver with pulses) */
  58         SS5_STATE_DELAY,                /* after signal wait until next signal can be sent */
  59         SS5_STATE_DOUBLE_SEIZE,         /* in case of a double seize, we make the remote size recognize it */
  60 };
  61 const char *ss5_state_name[] = {
  62         "STATE_IDLE",
  63         "STATE_SEIZING",
  64         "STATE_PROCEED_TO_SEND",
  65         "STATE_BUSY_FLASH",
  66         "STATE_ACK_BUSY_FLASH",
  67         "STATE_ANSWER",
  68         "STATE_ACK_ANSWER",
  69         "STATE_FORWARD_TRANSFER",
  70         "STATE_CLEAR_BACK",
  71         "STATE_ACK_CLEAR_BACK",
  72         "STATE_CLEAR_FORWARD",
  73         "STATE_RELEASE_GUARD",
  74         "STATE_DIAL_OUT",
  75         "STATE_DIAL_IN",
  76         "STATE_DIAL_IN_PULSE",
  77         "STATE_DELAY",
  78         "STATE_DOUBLE_SEIZE",
  79 };
  80
  81 enum {
  82         SS5_SIGNAL_NULL,
  83         /* sending signal states */
  84         SS5_SIGNAL_SEND_ON,             /* sending signal, waiting for acknowledge */
  85         SS5_SIGNAL_SEND_ON_RECOG,       /* sending signal, receiving ack, waiting for recogition timer */
  86         SS5_SIGNAL_SEND_OFF,            /* silence, receiving ack, waiting for stop */
  87         /* receiving signal states */
  88         SS5_SIGNAL_RECEIVE_RECOG,       /* receiving signal, waiting for recognition timer */
  89         SS5_SIGNAL_RECEIVE,             /* receiving signal / send ack, waiting for stop */
  90         SS5_SIGNAL_DELAY,               /* delay after release guard to prevent ping-pong */
  91         /* sending / receiving digit states */
  92         SS5_SIGNAL_DIGIT_PAUSE,         /* pausing before sending (next) digit */
  93         SS5_SIGNAL_DIGIT_ON,            /* sending digit */
  94         SS5_SIGNAL_PULSE_OFF,           /* make */
  95         SS5_SIGNAL_PULSE_ON,            /* break */
  96 };
  97 const char *ss5_signal_name[] = {
  98         "NULL",
  99         "SIGNAL_SEND_ON",
 100         "SIGNAL_SEND_ON_RECOG",
 101         "SIGNAL_SEND_OFF",
 102         "SIGNAL_RECEIVE_RECOG",
 103         "SIGNAL_RECEIVE",
 104         "SIGNAL_DELAY",
 105         "SIGNAL_DIGIT_PAUSE",
 106         "SIGNAL_DIGIT_ON",
 107         "SIGNAL_PULSE_OFF",
 108         "SIGNAL_PULSE_ON",
 109 };
 110
 111 /* ss5 signal timers (in samples) */
 112 #define SS5_TIMER_AFTER_SIGNAL  (100*8) /* wait after signal is terminated */
 113 #define SS5_TIMER_KP            (100*8) /* duration of KP1 or KP2 digit */
 114 #define SS5_TIMER_DIGIT         (55*8)  /* duration of all other digits */
 115 #define SS5_TIMER_PAUSE         (55*8)  /* pause between digits */
 116 #define SS5_TIMER_FORWARD       (850*8) /* forward transfer length */
 117 #define SS5_TIMER_RECOG_SEIZE   (40*8)  /* recognition time of seizing / proceed-to-send signal */
 118 #define SS5_TIMER_RECOG_OTHER   (125*8) /* recognition time of all other f1/f2 signals */
 119 #define SS5_TIMER_SIGNAL_LOSS   (15*8)  /* minimum time of signal loss for a continous signal */
 120 #define SS5_TIMER_DOUBLE_SEIZE  (850*8) /* double seize length */
 121 #define SS5_TIMER_RELEASE_GUARD (850*8) /* be sure to release after clear-forward */
 122 #define SS5_TIMER_RELEASE_MAX   (2000*8)/* maximum time for release guard to prevent 'double-releasing' */
 123 #define SS5_TIMER_RELEASE_DELAY (4000*8)/* wait after release guard to prevent ping-pong */
 124 #define BELL_TIMER_BREAK        (50*8)  /* loop open, tone */
 125 #define BELL_TIMER_MAKE         (50*8)  /* loop closed, no tone */
 126 #define BELL_TIMER_PAUSE        (800*8) /* interdigit delay */
 127 #define BELL_TIMER_RECOG_HANGUP (200*8) /* time to recognize hangup */
 128 #define BELL_TIMER_RECOG_END    (300*8) /* recognize end of digit */
 129
 130 /* ss5 timers */
 131 #define SS5_TIMER_OVERLAP       10      /* timeout for overlap digits received on incomming exchange */
 132 #define SS5_TIMER_RELEASE       20      /* timeout after disconnect on incomming exchange */
 133
 134
 135 /*
 136  * ss5 trace header
 137  */
 138 enum { /* even values are indications, odd values are requests */
 139         SS5_SEIZING_IND,
 140         SS5_SEIZING_REQ,
 141         SS5_PROCEED_TO_SEND_IND,
 142         SS5_PROCEED_TO_SEND_REQ,
 143         SS5_BUSY_FLASH_IND,
 144         SS5_BUSY_FLASH_REQ,
 145         SS5_ANSWER_IND,
 146         SS5_ANSWER_REQ,
 147         SS5_CLEAR_BACK_IND,
 148         SS5_CLEAR_BACK_REQ,
 149         SS5_CLEAR_FORWARD_IND,
 150         SS5_CLEAR_FORWARD_REQ,
 151         SS5_RELEASE_GUARD_IND,
 152         SS5_RELEASE_GUARD_REQ,
 153         SS5_ACKNOWLEDGE_IND,
 154         SS5_ACKNOWLEDGE_REQ,
 155         SS5_DOUBLE_SEIZURE_IND,
 156         SS5_DOUBLE_SEIZURE_REQ,
 157         SS5_DIALING_IND,
 158         SS5_DIALING_REQ,
 159         SS5_FORWARD_TRANSFER_IND,
 160         SS5_FORWARD_TRANSFER_REQ,
 161         SS5_TIMEOUT_IND,
 162         SS5_QUALITY_IND,
 163 };
 164 static struct isdn_message {
 165         const char *name;
 166         unsigned int value;
 167 } ss5_message[] = {
 168         {"SEIZING RECEIVED", SS5_SEIZING_IND},
 169         {"SEIZING SENDING", SS5_SEIZING_REQ},
 170         {"PROCEED-TO-SEND RECEIVED", SS5_PROCEED_TO_SEND_IND},
 171         {"PROCEED-TO-SEND SENDING", SS5_PROCEED_TO_SEND_REQ},
 172         {"BUSY-FLASH RECEIVED", SS5_BUSY_FLASH_IND},
 173         {"BUSY-FLASH SENDING", SS5_BUSY_FLASH_REQ},
 174         {"ANSWER RECEIVED", SS5_ANSWER_IND},
 175         {"ANSWER SENDING", SS5_ANSWER_REQ},
 176         {"CLEAR-BACK RECEIVED", SS5_CLEAR_BACK_IND},
 177         {"CLEAR-BACK SENDING", SS5_CLEAR_BACK_REQ},
 178         {"CLEAR-FORWARD RECEIVED", SS5_CLEAR_FORWARD_IND},
 179         {"CLEAR-FORWARD SENDING", SS5_CLEAR_FORWARD_REQ},
 180         {"RELEASE-GUARD RECEIVED", SS5_RELEASE_GUARD_IND},
 181         {"RELEASE-GUARD SENDING", SS5_RELEASE_GUARD_REQ},
 182         {"ACKNOWLEDGE RECEIVED", SS5_ACKNOWLEDGE_IND},
 183         {"ACKNOWLEDGE SENDING", SS5_ACKNOWLEDGE_REQ},
 184         {"DOUBLE-SEIZURE RECEIVED", SS5_DOUBLE_SEIZURE_IND},
 185         {"DOUBLE-SEIZURE SENDING", SS5_DOUBLE_SEIZURE_REQ},
 186         {"DIALING RECEIVED", SS5_DIALING_IND},
 187         {"DIALING SENDING", SS5_DIALING_REQ},
 188         {"FORWARD-TRANSFER RECEIVED", SS5_FORWARD_TRANSFER_IND},
 189         {"FORWARD-TRANSFER SENDING", SS5_FORWARD_TRANSFER_REQ},
 190         {"TIMEOUT", SS5_TIMEOUT_IND},
 191         {"QUALITY REPORT", SS5_QUALITY_IND},
 192         {NULL, 0},
 193 };
 194 static void ss5_trace_header(struct mISDNport *mISDNport, class PmISDN *port, unsigned int msg, int channel)
 195 {
 196         int i;
 197         char msgtext[64];
 198
 199         SCPY(msgtext, "<<UNKNOWN MESSAGE>>");
 200         /* select message and primitive text */
 201         i = 0;
 202         while(ss5_message[i].name) {
 203 //              if (msg == L3_NOTIFY_REQ) printf("val = %x %s\n", isdn_message[i].value, isdn_message[i].name);
 204                 if (ss5_message[i].value == msg) {
 205                         SCPY(msgtext, ss5_message[i].name);
 206                         break;
 207                 }
 208                 i++;
 209         }
 210
 211         /* init trace with given values */
 212         start_trace(mISDNport?mISDNport->portnum:-1,
 213                     mISDNport?(mISDNport->ifport?mISDNport->ifport->interface:NULL):NULL,
 214                     port?numberrize_callerinfo(port->p_callerinfo.id, port->p_callerinfo.ntype, options.national, options.international):NULL,
 215                     port?port->p_dialinginfo.id:NULL,
 216                     (msg&1)?DIRECTION_OUT:DIRECTION_IN,
 217                     CATEGORY_CH,
 218                     port?port->p_serial:0,
 219                     msgtext);
 220         add_trace("channel", NULL, "%d", channel);
 221         switch (port->p_type) {
 222                 case PORT_TYPE_SS5_OUT:
 223                 add_trace("state", NULL, "outgoing");
 224                 break;
 225                 case PORT_TYPE_SS5_IN:
 226                 add_trace("state", NULL, "incomming");
 227                 break;
 228                 default:
 229                 add_trace("state", NULL, "idle");
 230                 break;
 231         }
 232 }
 233
 234
 235 /*
 236  * changes release tone into silence
 237  * this makes the line sound more authentic
 238  */
 239 void Pss5::set_tone(const char *dir, const char *name)
 240 {
 241         if (name && !strcmp(name, "cause_10"))
 242                 name = NULL;
 243
 244         PmISDN::set_tone(dir, name);
 245 }
 246
 247 /*
 248  * creation of static channels
 249  */
 250 void ss5_create_channel(struct mISDNport *mISDNport, int i)
 251 {
 252         class Pss5              *ss5port;
 253         char                    portname[32];
 254         struct port_settings    port_settings;
 255
 256         SPRINT(portname, "%s-%d", mISDNport->name, i+1);
 257
 258         memset(&port_settings, 0, sizeof(port_settings));
 259         SCPY(port_settings.tones_dir, options.tones_dir);
 260
 261         ss5port = new Pss5(PORT_TYPE_SS5_IDLE, mISDNport, portname, &port_settings, mISDNport->ifport->interface, i + (i>=15) + 1, 1, B_MODE_TRANSPARENT);
 262         if (!ss5port)
 263                 FATAL("No memory for Pss5 class.\n");
 264         if (!ss5port->p_m_b_channel)
 265                 FATAL("No bchannel on given index.\n");
 266
 267         /* connect channel */
 268         bchannel_event(mISDNport, ss5port->p_m_b_index, B_EVENT_USE);
 269
 270 }
 271
 272
 273 /*
 274  * hunt for a free line
 275  * this function returns a port object in idle state.
 276  */
 277 class Pss5 *ss5_hunt_line(struct mISDNport *mISDNport)
 278 {
 279         int i;
 280         class Port      *port;
 281         class Pss5      *ss5port = NULL;
 282         struct select_channel *selchannel;
 283
 284         PDEBUG(DEBUG_SS5, "Entered name=%s\n", mISDNport->name);
 285         selchannel = mISDNport->ifport->out_channel;
 286         while(selchannel) {
 287                 switch(selchannel->channel) {
 288                         case CHANNEL_FREE: /* free channel */
 289                         case CHANNEL_ANY: /* any channel */
 290                         for (i = 0; i < mISDNport->b_num; i++) {
 291                                 port = mISDNport->b_port[i];
 292                                 PDEBUG(DEBUG_SS5, "Checking port %p on index\n", port, i);
 293                                 if (!port)
 294                                         continue;
 295                                 if (port->p_type == PORT_TYPE_SS5_IN || port->p_type == PORT_TYPE_SS5_OUT)
 296                                         PDEBUG(DEBUG_SS5, "Checking port %s: channel %d not available, because port not idle type.\n",
 297                                                 mISDNport->name, i);
 298                                 if (port->p_type != PORT_TYPE_SS5_IDLE)
 299                                         continue;
 300                                 ss5port = (class Pss5 *)port;
 301                                 /* is really idle ? */
 302                                 if (ss5port->p_state == PORT_STATE_IDLE
 303                                  && ss5port->p_m_s_state == SS5_STATE_IDLE)
 304                                         return ss5port;
 305                                 PDEBUG(DEBUG_SS5, "Checking port %s: channel %d not available, because p_state=%d, ss5_state=%d.\n",
 306                                         mISDNport->name, i, ss5port->p_state,ss5port->p_m_s_state);
 307                         }
 308                         PDEBUG(DEBUG_SS5, "no free interface\n");
 309                         return NULL;
 310
 311                         case CHANNEL_NO:
 312                         break;
 313
 314                         default:
 315                         if (selchannel->channel<1 || selchannel->channel==16)
 316                                 break;
 317                         i = selchannel->channel-1-(selchannel->channel>=17);
 318                         if (i >= mISDNport->b_num)
 319                                 break;
 320                         port = mISDNport->b_port[i];
 321                         if (!port)
 322                                 break;
 323                         if (port->p_type == PORT_TYPE_SS5_IN || port->p_type == PORT_TYPE_SS5_OUT)
 324                                 PDEBUG(DEBUG_SS5, "Checking port %s: channel %d not available, because port not idle type.\n",
 325                                         mISDNport->name, i);
 326                         if (port->p_type != PORT_TYPE_SS5_IDLE)
 327                                 break;
 328                         ss5port = (class Pss5 *)port;
 329                         /* is really idle ? */
 330                         if (ss5port->p_state == PORT_STATE_IDLE
 331                          && ss5port->p_m_s_state == SS5_STATE_IDLE)
 332                                 return ss5port;
 333                         PDEBUG(DEBUG_SS5, "Checking port %s: channel %d not available, because p_state=%d, ss5_state=%d.\n",
 334                                 mISDNport->name, i, ss5port->p_state,ss5port->p_m_s_state);
 335                 }
 336                 selchannel = selchannel->next;
 337         }
 338         PDEBUG(DEBUG_SS5, "no free interface in channel list\n");
 339         return NULL;
 340 }
 341
 342 static int timeout(struct lcr_timer *timer, void *instance, int i)
 343 {
 344         class Pss5 *ss5 = (class Pss5 *)instance;
 345
 346         ss5->register_timeout();
 347
 348         return 0;
 349 }
 350
 351 int queue_event(struct lcr_work *work, void *instance, int index)
 352 {
 353         class Pss5 *ss5port = (class Pss5 *)instance;
 354
 355         ss5port->process_queue();
 356
 357         return 0;
 358 }
 359
 360 /*
 361  * constructor
 362  */
 363 Pss5::Pss5(int type, struct mISDNport *mISDNport, char *portname, struct port_settings *settings, struct interface *interface, int channel, int exclusive, int mode) : PmISDN(type, mISDNport, portname, settings, interface, channel, exclusive, mode)
 364 {
 365         p_callerinfo.itype = (mISDNport->ifport->interface->extension)?INFO_ITYPE_ISDN_EXTENSION:INFO_ITYPE_ISDN;
 366         p_m_s_state = SS5_STATE_IDLE;
 367         p_m_s_signal = SS5_SIGNAL_NULL;
 368         p_m_s_dial[0] = '\0';
 369         p_m_s_digit_i = 0;
 370         p_m_s_pulsecount = 0;
 371         p_m_s_last_digit = ' ';
 372         p_m_s_last_digit_used = ' ';
 373         p_m_s_signal_loss = 0;
 374         p_m_s_decoder_count = 0;
 375         //p_m_s_decoder_buffer;
 376         p_m_s_sample_nr = 0;
 377         p_m_s_quality_value = 0;
 378         p_m_s_quality_count = 0;
 379         p_m_s_recog = 0;
 380         memset(&p_m_s_queue, 0, sizeof(p_m_s_queue));
 381         add_work(&p_m_s_queue, queue_event, this, 0);
 382         p_m_s_queued_signal = 0;
 383         memset(p_m_s_delay_digits, ' ', sizeof(p_m_s_delay_digits));
 384         memset(p_m_s_delay_mute, ' ', sizeof(p_m_s_delay_mute));
 385         memset(&p_m_s_timer, 0, sizeof(p_m_s_timer));
 386         add_timer(&p_m_s_timer, timeout, this, 0);
 387
 388         /* turn on signalling receiver */
 389         inband_receive_on();
 390
 391         PDEBUG(DEBUG_SS5, "Created new mISDNPort(%s). Currently %d objects use.\n", portname, mISDNport->use);
 392 }
 393
 394
 395 /*
 396  * destructor
 397  */
 398 Pss5::~Pss5()
 399 {
 400         del_timer(&p_m_s_timer);
 401         del_work(&p_m_s_queue);
 402 }
 403
 404
 405 /*
 406  * timeout trigger
 407  */
 408 void Pss5::register_timeout(void)
 409 {
 410         ss5_trace_header(p_m_mISDNport, this, SS5_TIMEOUT_IND, p_m_b_channel);
 411         end_trace();
 412         switch(p_state) {
 413         case PORT_STATE_IN_SETUP:
 414                 PDEBUG(DEBUG_SS5, "%s: timeout after seize\n", p_name);
 415                 do_release(CAUSE_UNSPECIFIED, LOCATION_PRIVATE_LOCAL, SS5_CLEAR_BACK_REQ);
 416                 break;
 417         case PORT_STATE_IN_OVERLAP:
 418                 PDEBUG(DEBUG_SS5, "%s: timeout during dialing\n", p_name);
 419                 do_release(CAUSE_UNSPECIFIED, LOCATION_PRIVATE_LOCAL, SS5_CLEAR_BACK_REQ);
 420                 break;
 421         case PORT_STATE_OUT_DISCONNECT:
 422                 PDEBUG(DEBUG_SS5, "%s: timeout after sending busy flash / clear forward\n", p_name);
 423                 /* always send clear forward, because release guard only works as a reply to clear forward */
 424                 do_release(CAUSE_UNSPECIFIED, LOCATION_PRIVATE_LOCAL, SS5_CLEAR_FORWARD_REQ);
 425                 break;
 426         }
 427 }
 428
 429 /*
 430  * change port state
 431  */
 432 void Pss5::new_state(int state)
 433 {
 434         switch(state) {
 435         case PORT_STATE_IN_SETUP:
 436         case PORT_STATE_IN_OVERLAP:
 437                 if (SS5_TIMER_OVERLAP == 0)
 438                         break;
 439                 PDEBUG(DEBUG_SS5, "%s: starting timeout timer with %d seconds\n", p_name, SS5_TIMER_OVERLAP);
 440                 schedule_timer(&p_m_s_timer, SS5_TIMER_OVERLAP, 0);
 441                 break;
 442         case PORT_STATE_OUT_DISCONNECT:
 443                 if (p_type != PORT_TYPE_SS5_IN)
 444                         break;
 445                 if (SS5_TIMER_RELEASE == 0)
 446                         break;
 447                 PDEBUG(DEBUG_SS5, "%s: starting timeout timer with %d seconds\n", p_name, SS5_TIMER_RELEASE);
 448                 schedule_timer(&p_m_s_timer, SS5_TIMER_RELEASE, 0);
 449                 break;
 450         default:
 451                 PDEBUG(DEBUG_SS5, "%s: stopping timeout timer\n", p_name);
 452                 unsched_timer(&p_m_s_timer);
 453         }
 454         Port::new_state(state);
 455 }
 456
 457 /*
 458  * change ss5 states
 459  */
 460 void Pss5::_new_ss5_state(int state, const char *func, int line)
 461 {
 462         PDEBUG(DEBUG_SS5, "%s(%s:%d): changing SS5 state from %s to %s\n", p_name, func, line, ss5_state_name[p_m_s_state], ss5_state_name[state]);
 463         p_m_s_state = state;
 464         p_m_s_signal = SS5_SIGNAL_NULL;
 465
 466         if (p_m_s_state == SS5_STATE_IDLE && p_m_s_queued_signal)
 467                 trigger_work(&p_m_s_queue);
 468 }
 469
 470 void Pss5::process_queue(void)
 471 {
 472         /* when clear forward is scheduled, we abort current state */
 473         if (p_m_s_queued_signal == SS5_CLEAR_FORWARD_REQ)
 474                 new_ss5_state(SS5_STATE_IDLE);
 475
 476         /* if there is an ongoing signal, we wait until done */
 477         if (p_m_s_state != SS5_STATE_IDLE)
 478                 return;
 479
 480         /* this shoud not happen */
 481         if (!p_m_s_queued_signal)
 482                 return;
 483
 484         /* start signal */
 485         ss5_trace_header(p_m_mISDNport, this, p_m_s_queued_signal, p_m_b_channel);
 486         end_trace();
 487         switch(p_m_s_queued_signal) {
 488         case SS5_ANSWER_REQ:
 489                 /* start answer */
 490                 p_m_s_queued_signal = 0; /* prevent trigger loop */
 491                 start_signal(SS5_STATE_ANSWER);
 492                 break;
 493         case SS5_BUSY_FLASH_REQ:
 494                 /* busy flash */
 495                 p_m_s_queued_signal = 0; /* prevent trigger loop */
 496                 start_signal(SS5_STATE_BUSY_FLASH);
 497                 break;
 498         case SS5_CLEAR_BACK_REQ:
 499                 /* clear back */
 500                 p_m_s_queued_signal = 0; /* prevent trigger loop */
 501                 start_signal(SS5_STATE_CLEAR_BACK);
 502                 break;
 503         case SS5_CLEAR_FORWARD_REQ:
 504                 /* clear forward */
 505                 p_m_s_queued_signal = 0; /* prevent trigger loop */
 506                 start_signal(SS5_STATE_CLEAR_FORWARD);
 507                 break;
 508         default:
 509                 PERROR("unhandled event %d\n", p_m_s_queued_signal);
 510                 p_m_s_queued_signal = 0;
 511         }
 512 }
 513
 514 void Pss5::_new_ss5_signal(int signal, const char *func, int line)
 515 {
 516         if (p_m_s_signal)
 517                 PDEBUG(DEBUG_SS5, "%s: changing SS5 signal state from %s to %s\n", p_name, ss5_signal_name[p_m_s_signal], ss5_signal_name[signal]);
 518         else
 519                 PDEBUG(DEBUG_SS5, "%s: changing SS5 signal state to %s\n", p_name, ss5_signal_name[signal]);
 520         p_m_s_signal = signal;
 521 }
 522
 523
 524 /*
 525  * signalling receiver
 526  *
 527  * this function will be called for every audio received.
 528  */
 529 void Pss5::inband_receive(unsigned char *buffer, int len)
 530 {
 531         int count = 0, tocopy, space;
 532         char digit;
 533         double quality;
 534         int mute = 0;
 535
 536         again:
 537         /* how much to copy ? */
 538         tocopy = len - count;
 539         space = SS5_DECODER_NPOINTS - p_m_s_decoder_count;
 540         if (space < 0)
 541                 FATAL("p_m_s_decoder_count overflows\n");
 542         if (space < tocopy)
 543                 tocopy = space;
 544         /* copy an count */
 545         memcpy(p_m_s_decoder_buffer+p_m_s_decoder_count, buffer+count, tocopy);
 546         p_m_s_decoder_count += tocopy;
 547         count += tocopy;
 548         /* decoder buffer not completely filled ? */
 549         if (tocopy < space)
 550                 return;
 551
 552         /* decode one frame */
 553         digit = ss5_decode(p_m_s_decoder_buffer, SS5_DECODER_NPOINTS, &quality);
 554         p_m_s_decoder_count = 0;
 555
 556         /* indicate quality of received digit */
 557         if ((p_m_mISDNport->ss5 & SS5_FEATURE_QUALITY)) {
 558                 if (digit != ' ') {
 559                         p_m_s_quality_value += quality;
 560                         p_m_s_quality_count++;
 561                 } else if (p_m_s_quality_count) {
 562                         ss5_trace_header(p_m_mISDNport, this, SS5_QUALITY_IND, p_m_b_channel);
 563                         add_trace("digit", NULL, "%c", p_m_s_last_digit);
 564                         quality = p_m_s_quality_value/p_m_s_quality_count;
 565                         add_trace("quality", NULL, "%3d%%", (int)(quality*100.0));
 566                         end_trace();
 567                         p_m_s_quality_value = 0;
 568                         p_m_s_quality_count = 0;
 569                 }
 570         }
 571
 572 #ifdef DEBUG_DETECT
 573         if (p_m_s_last_digit != digit && digit != ' ')
 574                 PDEBUG(DEBUG_SS5, "%s: detecting signal '%c' start (state=%s signal=%s)\n", p_name, digit, ss5_state_name[p_m_s_state], ss5_signal_name[p_m_s_signal]);
 575 #endif
 576
 577         /* ignore short loss of signal, or change within one decode window */
 578         if (p_m_s_signal_loss) {
 579                 if (digit == ' ') {
 580                         /* still lost */
 581                         if (p_m_s_signal_loss >= SS5_TIMER_SIGNAL_LOSS) {
 582 #ifdef DEBUG_DETECT
 583                                 PDEBUG(DEBUG_SS5, "%s: signal '%c' lost too long\n", p_name, p_m_s_last_digit);
 584 #endif
 585                                 /* long enough, we stop loss-timer */
 586                                 p_m_s_signal_loss = 0;
 587                         } else {
 588                                 /* not long enough, so we use last signal */
 589                                 p_m_s_signal_loss += SS5_DECODER_NPOINTS;
 590                                 digit = p_m_s_last_digit;
 591                         }
 592                 } else {
 593                         /* signal is back, we stop timer and store */
 594 #ifdef DEBUG_DETECT
 595                         PDEBUG(DEBUG_SS5, "%s: signal '%c' lost, but continues with '%c'\n", p_name, p_m_s_last_digit, digit);
 596 #endif
 597                         p_m_s_signal_loss = 0;
 598                         p_m_s_last_digit = digit;
 599                 }
 600         } else {
 601                 if (p_m_s_last_digit != ' ' && digit == ' ') {
 602 #ifdef DEBUG_DETECT
 603                         PDEBUG(DEBUG_SS5, "%s: signal '%c' lost\n", p_name, p_m_s_last_digit);
 604 #endif
 605                         /* restore last digit until signal is really lost */
 606                         p_m_s_last_digit = digit;
 607                         /* starting to loose signal */
 608                         p_m_s_signal_loss = SS5_DECODER_NPOINTS;
 609                 } else if (digit != p_m_s_last_digit) {
 610                         /* digit changes, but we keep old digit until it is detected twice */
 611 #ifdef DEBUG_DETECT
 612                         PDEBUG(DEBUG_SS5, "%s: signal '%c' changes to '%c'\n", p_name, p_m_s_last_digit, digit);
 613 #endif
 614                         p_m_s_last_digit = digit;
 615                         digit = p_m_s_last_digit_used;
 616                 } else {
 617                         /* storing last signal, in case it is lost */
 618                         p_m_s_last_digit = digit;
 619                 }
 620         }
 621         p_m_s_last_digit_used = digit;
 622
 623         /* delay decoded tones */
 624         if ((p_m_mISDNport->ss5 & SS5_FEATURE_DELAY)) {
 625                 /* shift buffer */
 626                 memcpy(p_m_s_delay_digits, p_m_s_delay_digits+1, sizeof(p_m_s_delay_digits)-1);
 627                 /* first in */
 628                 p_m_s_delay_digits[sizeof(p_m_s_delay_digits)-1] = digit;
 629                 /* first out */
 630                 digit = p_m_s_delay_digits[0];
 631         }
 632
 633         /* clear forward is always recognized */
 634         if (digit == 'C' && p_m_s_state != SS5_STATE_CLEAR_FORWARD && p_m_s_state != SS5_STATE_RELEASE_GUARD) {
 635                 switch (p_type) {
 636                         case PORT_TYPE_SS5_OUT:
 637                         PDEBUG(DEBUG_SS5, "%s: received release-guard, waiting for recognition\n", p_name);
 638                         break;
 639                         case PORT_TYPE_SS5_IN:
 640                         PDEBUG(DEBUG_SS5, "%s: received clear-forward, waiting for recognition\n", p_name);
 641                         break;
 642                         default:
 643                         PDEBUG(DEBUG_SS5, "%s: received clear-forward in idle state, waiting for recognition\n", p_name);
 644                         break;
 645                 }
 646                 new_ss5_state(SS5_STATE_RELEASE_GUARD);
 647                 new_ss5_signal(SS5_SIGNAL_RECEIVE_RECOG);
 648                 p_m_s_recog = 0;
 649         } else
 650         switch(p_m_s_state) {
 651                 case SS5_STATE_IDLE:
 652                 /* seizing only recognized in port idle state */
 653                 if (p_state == PORT_STATE_IDLE) {
 654                         if (digit != 'A')
 655                                 break;
 656                         seize:
 657                         PDEBUG(DEBUG_SS5, "%s: received seize, waiting for recognition\n", p_name);
 658                         p_type = PORT_TYPE_SS5_IN;
 659                         new_ss5_state(SS5_STATE_PROCEED_TO_SEND);
 660                         new_ss5_signal(SS5_SIGNAL_RECEIVE_RECOG);
 661                         p_m_s_recog = 0;
 662                         break;
 663                 }
 664                 /* other signals */
 665                 if (digit == 'A') {
 666                         if (p_type != PORT_TYPE_SS5_OUT)
 667                                 break;
 668                         PDEBUG(DEBUG_SS5, "%s: received answer, waiting for recognition\n", p_name);
 669                         new_ss5_state(SS5_STATE_ACK_ANSWER);
 670                         new_ss5_signal(SS5_SIGNAL_RECEIVE_RECOG);
 671                         p_m_s_recog = 0;
 672                         break;
 673                 }
 674                 if (digit == 'B') {
 675                         if (p_type == PORT_TYPE_SS5_IN) {
 676                                 if ((p_m_mISDNport->ss5 & SS5_FEATURE_BELL)) {
 677                                         new_ss5_state(SS5_STATE_DIAL_IN_PULSE); /* go pulsing state */
 678                                         new_ss5_signal(SS5_SIGNAL_PULSE_OFF); /* we are starting with pulse off */
 679                                         p_m_s_pulsecount = 0; /* init pulse counter */
 680                                         p_m_s_dial[0] = '\0'; /* init dial string */
 681                                         pulse_ind(1); /* also inits recogition timer... */
 682                                         break;
 683                                 }
 684                                 PDEBUG(DEBUG_SS5, "%s: received forward-transfer, waiting for recognition\n", p_name);
 685                                 /* forward transfer on incomming lines */
 686                                 new_ss5_state(SS5_STATE_FORWARD_TRANSFER);
 687                                 new_ss5_signal(SS5_SIGNAL_RECEIVE_RECOG);
 688                                 p_m_s_recog = 0;
 689                                 break;
 690                         }
 691                         if (p_state == PORT_STATE_CONNECT) {
 692                                 PDEBUG(DEBUG_SS5, "%s: received clear-back, waiting for recognition\n", p_name);
 693                                 new_ss5_state(SS5_STATE_ACK_CLEAR_BACK);
 694                         } else {
 695                                 PDEBUG(DEBUG_SS5, "%s: received busy-flash, waiting for recognition\n", p_name);
 696                                 new_ss5_state(SS5_STATE_ACK_BUSY_FLASH);
 697                         }
 698                         new_ss5_signal(SS5_SIGNAL_RECEIVE_RECOG);
 699                         p_m_s_recog = 0;
 700                         break;
 701                 }
 702                 /* dialing only allowed in incomming setup state */
 703                 if (p_state == PORT_STATE_IN_SETUP) {
 704                         if (!strchr("1234567890*#abc", digit))
 705                                 break;
 706                         PDEBUG(DEBUG_SS5, "%s: received dialing start with '%c'\n", p_name, digit);
 707                         new_ss5_state(SS5_STATE_DIAL_IN);
 708                         new_ss5_signal(SS5_SIGNAL_DIGIT_ON);
 709                         p_m_s_dial[0] = '\0';
 710                         digit_ind(digit);
 711                         break;
 712                 }
 713                 break;
 714                 /* sending seizing */
 715                 case SS5_STATE_SEIZING:
 716                 switch (p_m_s_signal) {
 717                         case SS5_SIGNAL_SEND_ON:
 718                         if (digit == 'A') { /* double seize */
 719                                 PDEBUG(DEBUG_SS5, "%s: received double seizure\n", p_name, digit);
 720                                 double_seizure_ind();
 721                                 break;
 722                         }
 723                         if (digit == 'B') {
 724                                 PDEBUG(DEBUG_SS5, "%s: received answer to outgoing seize, waiting for recognition\n", p_name);
 725                                 /* set recognition timer */
 726                                 new_ss5_signal(SS5_SIGNAL_SEND_ON_RECOG);
 727                                 p_m_s_recog = 0;
 728                         }
 729                         break;
 730                         case SS5_SIGNAL_SEND_ON_RECOG:
 731                         if (digit != 'B') { /* seize */
 732                                 PDEBUG(DEBUG_SS5, "%s: answer to outgoing seize is gone before recognition\n", p_name);
 733                                 new_ss5_signal(SS5_SIGNAL_SEND_ON);
 734 //                              p_m_s_sample_nr = 0;
 735 //                              inband_send_on();
 736                                 break;
 737                         }
 738                         p_m_s_recog += SS5_DECODER_NPOINTS;
 739                         if (p_m_s_recog < SS5_TIMER_RECOG_SEIZE)
 740                                 break;
 741                         PDEBUG(DEBUG_SS5, "%s: answer to outgoing seize recognized, turning off, waiting for recognition\n", p_name);
 742                         new_ss5_signal(SS5_SIGNAL_SEND_OFF);
 743                         break;
 744                         case SS5_SIGNAL_SEND_OFF:
 745                         if (digit == 'B')
 746                                 break;
 747                         PDEBUG(DEBUG_SS5, "%s: outgoing seizure is complete, proceeding...\n", p_name);
 748                         new_ss5_state(SS5_STATE_IDLE);
 749                         proceed_to_send_ind();
 750                         break;
 751                 }
 752                 break;
 753                 /* answer to seize */
 754                 case SS5_STATE_PROCEED_TO_SEND:
 755                 if (p_m_s_signal == SS5_SIGNAL_RECEIVE_RECOG) {
 756                         if (digit != 'A') {
 757                                 PDEBUG(DEBUG_SS5, "%s: incomming seize is gone before recognition\n", p_name);
 758                                 new_ss5_state(SS5_STATE_IDLE);
 759                                 p_type = PORT_TYPE_SS5_IDLE;
 760                                 break;
 761                         }
 762                         p_m_s_recog += SS5_DECODER_NPOINTS;
 763                         if (p_m_s_recog < SS5_TIMER_RECOG_SEIZE)
 764                                 break;
 765                         PDEBUG(DEBUG_SS5, "%s: incomming seize is recognized, responding...\n", p_name);
 766                         new_ss5_signal(SS5_SIGNAL_RECEIVE);
 767                         p_m_s_sample_nr = 0;
 768                         inband_send_on();
 769                         break;
 770                 }
 771                 if (digit != 'A') {
 772                         PDEBUG(DEBUG_SS5, "%s: incomming seize is gone after responding\n", p_name);
 773                         new_ss5_state(SS5_STATE_IDLE);
 774                         seizing_ind();
 775                 }
 776                 break;
 777                 /* sending busy flash / answer / clear-back */
 778                 case SS5_STATE_BUSY_FLASH:
 779                 case SS5_STATE_ANSWER:
 780                 case SS5_STATE_CLEAR_BACK:
 781                 switch (p_m_s_signal) {
 782                         case SS5_SIGNAL_SEND_ON:
 783                         if (digit == 'A') {
 784                                 PDEBUG(DEBUG_SS5, "%s: received acknowledge, waiting for recognition\n", p_name);
 785                                 /* set recognition timer */
 786                                 new_ss5_signal(SS5_SIGNAL_SEND_ON_RECOG);
 787                                 p_m_s_recog = 0;
 788                         }
 789                         break;
 790                         case SS5_SIGNAL_SEND_ON_RECOG:
 791                         if (digit != 'A') {
 792                                 PDEBUG(DEBUG_SS5, "%s: acknowledge is gone before recognition\n", p_name);
 793                                 new_ss5_signal(SS5_SIGNAL_SEND_ON);
 794 //                              p_m_s_sample_nr = 0;
 795 //                              inband_send_on();
 796                                 break;
 797                         }
 798                         p_m_s_recog += SS5_DECODER_NPOINTS;
 799                         if (p_m_s_recog < SS5_TIMER_RECOG_OTHER)
 800                                 break;
 801                         PDEBUG(DEBUG_SS5, "%s: acknowledge recognized, turning off, waiting for recognition\n", p_name);
 802                         new_ss5_signal(SS5_SIGNAL_SEND_OFF);
 803                         break;
 804                         case SS5_SIGNAL_SEND_OFF:
 805                         if (digit == 'A')
 806                                 break;
 807                         PDEBUG(DEBUG_SS5, "%s: outgoing signal is complete\n", p_name);
 808                         new_ss5_state(SS5_STATE_IDLE);
 809                         break;
 810                 }
 811                 break;
 812                 /* answer to busy-flash / clear back */
 813                 case SS5_STATE_ACK_BUSY_FLASH:
 814                 case SS5_STATE_ACK_CLEAR_BACK:
 815                 if (p_m_s_signal == SS5_SIGNAL_RECEIVE_RECOG) {
 816                         if (digit != 'B') {
 817                                 PDEBUG(DEBUG_SS5, "%s: incomming clear-back/busy-flash is gone before recognition\n", p_name);
 818                                 new_ss5_state(SS5_STATE_IDLE);
 819                                 break;
 820                         }
 821                         p_m_s_recog += SS5_DECODER_NPOINTS;
 822                         if (p_m_s_recog < SS5_TIMER_RECOG_OTHER)
 823                                 break;
 824                         PDEBUG(DEBUG_SS5, "%s: incomming clear-back/busy-flash is recognized, responding...\n", p_name);
 825                         new_ss5_signal(SS5_SIGNAL_RECEIVE);
 826                         p_m_s_sample_nr = 0;
 827                         inband_send_on();
 828                         break;
 829                 }
 830                 if (digit != 'B') {
 831                         PDEBUG(DEBUG_SS5, "%s: incomming clear-back/busy-flash is gone after responding\n", p_name);
 832                         new_ss5_state(SS5_STATE_IDLE);
 833                         if (p_m_s_state == SS5_STATE_ACK_BUSY_FLASH)
 834                                 busy_flash_ind();
 835                         else
 836                                 clear_back_ind();
 837                 }
 838                 break;
 839                 /* answer to answer */
 840                 case SS5_STATE_ACK_ANSWER:
 841                 if (p_m_s_signal == SS5_SIGNAL_RECEIVE_RECOG) {
 842                         if (digit != 'A') {
 843                                 PDEBUG(DEBUG_SS5, "%s: incomming answer is gone before recognition\n", p_name);
 844                                 new_ss5_state(SS5_STATE_IDLE);
 845                                 break;
 846                         }
 847                         p_m_s_recog += SS5_DECODER_NPOINTS;
 848                         if (p_m_s_recog < SS5_TIMER_RECOG_OTHER)
 849                                 break;
 850                         PDEBUG(DEBUG_SS5, "%s: incomming answer is recognized, responding...\n", p_name);
 851                         new_ss5_signal(SS5_SIGNAL_RECEIVE);
 852                         p_m_s_sample_nr = 0;
 853                         inband_send_on();
 854                         break;
 855                 }
 856                 if (digit != 'A') {
 857                         PDEBUG(DEBUG_SS5, "%s: incomming answer is gone after responding\n", p_name);
 858                         new_ss5_state(SS5_STATE_IDLE);
 859                         answer_ind();
 860                 }
 861                 break;
 862                 /* sending clear-forward */
 863                 case SS5_STATE_CLEAR_FORWARD:
 864                 switch (p_m_s_signal) {
 865                         case SS5_SIGNAL_SEND_ON:
 866                         if (digit == 'C') {
 867                                 PDEBUG(DEBUG_SS5, "%s: received answer to clear-forward, waiting for recognition\n", p_name);
 868                                 /* set recognition timer */
 869                                 new_ss5_signal(SS5_SIGNAL_SEND_ON_RECOG);
 870                                 p_m_s_recog = 0;
 871                         }
 872                         break;
 873                         case SS5_SIGNAL_SEND_ON_RECOG:
 874                         if (digit != 'C') {
 875                                 PDEBUG(DEBUG_SS5, "%s: answer to clear-forward is gone before recognition\n", p_name);
 876                                 new_ss5_signal(SS5_SIGNAL_SEND_ON);
 877 //                              p_m_s_sample_nr = 0;
 878 //                              inband_send_on();
 879                                 break;
 880                         }
 881                         p_m_s_recog += SS5_DECODER_NPOINTS;
 882                         if (p_m_s_recog < SS5_TIMER_RECOG_OTHER)
 883                                 break;
 884                         PDEBUG(DEBUG_SS5, "%s: answer to clear-forward recognized, turning off, waiting for recognition\n", p_name);
 885                         new_ss5_signal(SS5_SIGNAL_SEND_OFF);
 886                         break;
 887                         case SS5_SIGNAL_SEND_OFF:
 888                         if (digit == 'A') {
 889                                 PDEBUG(DEBUG_SS5, "%s: received seize right after clear-forward answer, continue with seize\n", p_name);
 890                                 new_state(PORT_STATE_IDLE);
 891                                 goto seize;
 892                         }
 893                         if (digit == 'C')
 894                                 break;
 895                         PDEBUG(DEBUG_SS5, "%s: answer to clear-forward is complete\n", p_name);
 896                         release_guard_ind();
 897                         new_ss5_signal(SS5_SIGNAL_DELAY);
 898                         p_m_s_recog = 0; /* use recog to delay */
 899                         PDEBUG(DEBUG_SS5, "%s: answer to clear-forward on outgoing interface starting delay to prevent ping-pong\n", p_name);
 900                         break;
 901                         case SS5_SIGNAL_DELAY:
 902                         if (digit == 'A') {
 903                                 PDEBUG(DEBUG_SS5, "%s: received seize right after clear-forward answer, continue with seize\n", p_name);
 904                                 new_state(PORT_STATE_IDLE);
 905                                 goto seize;
 906                         }
 907                         p_m_s_recog += SS5_DECODER_NPOINTS;
 908                         if (p_m_s_recog < SS5_TIMER_RELEASE_DELAY)
 909                                 break;
 910                         PDEBUG(DEBUG_SS5, "%s: delay time over, going idle\n", p_name);
 911                         new_ss5_state(SS5_STATE_IDLE);
 912                         new_state(PORT_STATE_IDLE);
 913                         p_type = PORT_TYPE_SS5_IDLE;
 914                         break;
 915                 }
 916                 break;
 917                 /* answer to release-guard*/
 918                 case SS5_STATE_RELEASE_GUARD:
 919                 switch (p_m_s_signal) {
 920                         case SS5_SIGNAL_RECEIVE_RECOG:
 921                         if (digit != 'C') {
 922                                 if (p_type == PORT_TYPE_SS5_OUT)
 923                                         PDEBUG(DEBUG_SS5, "%s: incomming release-guard is gone before recognition\n", p_name);
 924                                 else
 925                                         PDEBUG(DEBUG_SS5, "%s: incomming clear forward is gone before recognition\n", p_name);
 926                                 new_ss5_state(SS5_STATE_IDLE);
 927                                 break;
 928                         }
 929                         p_m_s_recog += SS5_DECODER_NPOINTS;
 930                         if (p_m_s_recog < SS5_TIMER_RECOG_OTHER)
 931                                 break;
 932                         if (p_type == PORT_TYPE_SS5_OUT)
 933                                 PDEBUG(DEBUG_SS5, "%s: incomming release-guard is recognized, responding...\n", p_name);
 934                         else
 935                                 PDEBUG(DEBUG_SS5, "%s: incomming clear-forward is recognized, responding...\n", p_name);
 936                         new_state(PORT_STATE_RELEASE);
 937                         new_ss5_signal(SS5_SIGNAL_RECEIVE);
 938                         p_m_s_sample_nr = 0;
 939                         inband_send_on();
 940                         break;
 941                         case SS5_SIGNAL_RECEIVE:
 942                         if (digit == 'C'
 943                          || p_m_s_sample_nr < 256) /* small hack to keep answer for at least some time */
 944                          break;
 945 #if 0
 946                         if (digit == 'A') {
 947                                 PDEBUG(DEBUG_SS5, "%s: received seize right after clear-forward is received\n", p_name);
 948                                 new_state(PORT_STATE_IDLE);
 949                                 goto seize;
 950                         }
 951 #endif
 952                         /* if clear forward stops right after recognition on the incomming side,
 953                          * the release guard signal stops and may be too short to be recognized at the outgoing side.
 954                          * to prevent this, a timer can be started to force a release guard that is long
 955                          * enough to be recognized on the outgoing side.
 956                          * this will prevent braking via blueboxing (other tricks may still be possible).
 957                          */
 958                         if ((p_m_mISDNport->ss5 & SS5_FEATURE_RELEASEGUARDTIMER)
 959                          && p_m_s_sample_nr < SS5_TIMER_RELEASE_GUARD)
 960                                 break;
 961                         if (p_type == PORT_TYPE_SS5_OUT)
 962                                 PDEBUG(DEBUG_SS5, "%s: incomming release-guard is gone after responding\n", p_name);
 963                         else
 964                                 PDEBUG(DEBUG_SS5, "%s: incomming clear-forward is gone after responding\n", p_name);
 965                         if (p_type == PORT_TYPE_SS5_OUT) {
 966                                 release_guard_ind();
 967                                 new_ss5_signal(SS5_SIGNAL_DELAY);
 968                                 p_m_s_recog = 0; /* use recog to delay */
 969                                 PDEBUG(DEBUG_SS5, "%s: incomming release-guard on outgoing interface starting delay to prevent ping-pong\n", p_name);
 970                         } else {
 971                                 clear_forward_ind();
 972                                 new_ss5_state(SS5_STATE_IDLE);
 973                         }
 974                         break;
 975                         case SS5_SIGNAL_DELAY:
 976                         if (digit == 'A') {
 977                                 PDEBUG(DEBUG_SS5, "%s: received seize right after release guard is gone, continue with seize\n", p_name);
 978                                 new_state(PORT_STATE_IDLE);
 979                                 goto seize;
 980                         }
 981                         p_m_s_recog += SS5_DECODER_NPOINTS;
 982                         if (p_m_s_recog < SS5_TIMER_RELEASE_DELAY)
 983                                 break;
 984                         PDEBUG(DEBUG_SS5, "%s: delay time over, going idle\n", p_name);
 985                         new_ss5_state(SS5_STATE_IDLE);
 986                         new_state(PORT_STATE_IDLE);
 987                         p_type = PORT_TYPE_SS5_IDLE;
 988                         break;
 989                 }
 990                 break;
 991                 /* wait time to recognize forward transfer */
 992                 case SS5_STATE_FORWARD_TRANSFER:
 993                 if (p_m_s_signal == SS5_SIGNAL_RECEIVE_RECOG) {
 994                         if (digit != 'B') {
 995                                 PDEBUG(DEBUG_SS5, "%s: incomming forward-transfer is gone before recognition\n", p_name);
 996                                 new_ss5_state(SS5_STATE_IDLE);
 997                                 break;
 998                         }
 999                         p_m_s_recog += SS5_DECODER_NPOINTS;
1000                         if (p_m_s_recog < SS5_TIMER_RECOG_OTHER)
1001                                 break;
1002                         PDEBUG(DEBUG_SS5, "%s: incomming forward-transfer is recognized, responding, if BELL feature was selected...\n", p_name);
1003                         new_ss5_signal(SS5_SIGNAL_RECEIVE);
1004 #if 0
1005                         p_m_s_sample_nr = 0;
1006                         inband_send_on();
1007 #endif
1008                         break;
1009                 }
1010                 if (digit != 'B') {
1011                         PDEBUG(DEBUG_SS5, "%s: incomming forward-transfer is gone after recognition\n", p_name);
1012                         new_ss5_state(SS5_STATE_IDLE);
1013                         forward_transfer_ind();
1014                         break;
1015                 }
1016                 break;
1017                 /* dialing is received */
1018                 case SS5_STATE_DIAL_IN:
1019                 if (strchr("1234567890*#abc", digit)) {
1020                         if (p_m_s_signal != SS5_SIGNAL_DIGIT_PAUSE)
1021                                 break;
1022                         PDEBUG(DEBUG_SS5, "%s: incomming digit '%c' is recognized\n", p_name, digit);
1023                         new_ss5_signal(SS5_SIGNAL_DIGIT_ON);
1024                         digit_ind(digit);
1025                 } else {
1026                         if (p_m_s_signal != SS5_SIGNAL_DIGIT_ON)
1027                                 break;
1028                         PDEBUG(DEBUG_SS5, "%s: incomming digit is gone after recognition\n", p_name);
1029                         new_ss5_signal(SS5_SIGNAL_DIGIT_PAUSE);
1030                 }
1031                 break;
1032                 case SS5_STATE_DIAL_IN_PULSE:
1033                 if (digit == 'B')
1034                         pulse_ind(1);
1035                 else
1036                         pulse_ind(0);
1037                 break;
1038         }
1039
1040         /* update mute on RX */
1041         if ((p_m_mISDNport->ss5 & SS5_FEATURE_MUTE_RX)) {
1042                 int mdigit;
1043                 memcpy(p_m_s_delay_mute, p_m_s_delay_mute+1, sizeof(p_m_s_delay_mute)-1);
1044                 p_m_s_delay_mute[sizeof(p_m_s_delay_mute)-1] = digit;
1045                 mdigit = p_m_s_delay_mute[0];
1046                 if (mdigit == 'A' || mdigit == 'B' || mdigit == 'C')
1047                         mute = 1;
1048         }
1049
1050         /* mute when TX */
1051         if ((p_m_mISDNport->ss5 & SS5_FEATURE_MUTE_TX)) {
1052                 switch(p_m_s_signal) {
1053                 case SS5_SIGNAL_SEND_ON_RECOG:
1054                 case SS5_SIGNAL_RECEIVE_RECOG:
1055                         if (p_m_s_recog > SS5_DELAY_MUTE)
1056                                 mute = 1;
1057                         break;
1058                 case SS5_SIGNAL_SEND_OFF:
1059                 case SS5_SIGNAL_RECEIVE:
1060                         mute = 1;
1061                         break;
1062                 }
1063         }
1064
1065         /* apply mute state */
1066         if (p_m_mute) {
1067                 /* mute is on */
1068                 if (!mute)
1069                         mute_off();
1070         } else {
1071                 /* mute is off */
1072                 if (mute)
1073                         mute_on();
1074         }
1075
1076         /* something more to decode ? */
1077         if (count != len)
1078                 goto again;
1079 }
1080
1081
1082 /*
1083  * signalling sender
1084  *
1085  * this function generates tones and assembles dial string with digits and pause
1086  * the result is sent to mISDN. it uses the ss5_encode() function.
1087  * except for dialing and forward-transfer, tones are continuous and will not change state.
1088  */
1089 int Pss5::inband_send(unsigned char *buffer, int len)
1090 {
1091         int count = 0; /* sample counter */
1092         int duration;
1093         char digit;
1094         int tocode, tosend;
1095
1096         switch(p_m_s_state) {
1097                 /* turn off transmitter in idle state */
1098                 case SS5_STATE_IDLE:
1099                 inband_send_off();
1100                 break;
1101
1102                 case SS5_STATE_SEIZING:
1103                 if (p_m_s_signal != SS5_SIGNAL_SEND_ON
1104                  && p_m_s_signal != SS5_SIGNAL_SEND_ON_RECOG)
1105                         break;
1106                 duration = -1; /* continuous */
1107                 digit = 'A';
1108                 send:
1109                 /* how much samples do we have left */
1110                 if (duration < 0)
1111                         tocode = len;
1112                 else
1113                         tocode = duration - p_m_s_sample_nr;
1114                 if (tocode > 0) {
1115                         if (tocode > len)
1116                                 tocode = len;
1117                         ss5_encode(buffer, tocode, digit, p_m_s_sample_nr);
1118                         /* increase counters */
1119                         p_m_s_sample_nr += tocode;
1120                         count += tocode;
1121                 }
1122                 /* more to come ? */
1123                 if (duration > 0 && p_m_s_sample_nr >= duration) {
1124                         PDEBUG(DEBUG_SS5, "%s: sending tone '%c' complete, starting delay\n", p_name, digit);
1125                         if (p_m_s_state == SS5_STATE_DOUBLE_SEIZE) {
1126                                 do_release(CAUSE_NOCHANNEL, LOCATION_PRIVATE_LOCAL, SS5_CLEAR_FORWARD_REQ);
1127                                 break;
1128                         }
1129                         new_ss5_state(SS5_STATE_DELAY);
1130                         p_m_s_sample_nr = 0;
1131                 }
1132 #if 0
1133                 /* stop sending if too long */
1134                 if (duration < 0 && p_m_s_sample_nr >= SS5_TIMER_MAX_SIGNAL) {
1135                         PDEBUG(DEBUG_SS5, "%s: sending tone '%c' too long, stopping\n", p_name, digit);
1136                         inband_send_off();
1137                         break;
1138                 }
1139 #endif
1140                 break;
1141                 /* incomming seizing */
1142                 case SS5_STATE_PROCEED_TO_SEND:
1143                 if (p_m_s_signal != SS5_SIGNAL_RECEIVE)
1144                         break;
1145                 duration = -1; /* continuous */
1146                 digit = 'B';
1147                 goto send;
1148
1149                 case SS5_STATE_BUSY_FLASH:
1150                 case SS5_STATE_CLEAR_BACK:
1151                 if (p_m_s_signal != SS5_SIGNAL_SEND_ON
1152                  && p_m_s_signal != SS5_SIGNAL_SEND_ON_RECOG)
1153                         break;
1154                 duration = -1; /* continuous */
1155                 digit = 'B';
1156                 goto send;
1157
1158                 case SS5_STATE_ANSWER:
1159                 if (p_m_s_signal != SS5_SIGNAL_SEND_ON
1160                  && p_m_s_signal != SS5_SIGNAL_SEND_ON_RECOG)
1161                         break;
1162                 duration = -1; /* continuous */
1163                 digit = 'A';
1164                 goto send;
1165
1166                 case SS5_STATE_ACK_BUSY_FLASH:
1167                 case SS5_STATE_ACK_ANSWER:
1168                 case SS5_STATE_ACK_CLEAR_BACK:
1169                 if (p_m_s_signal != SS5_SIGNAL_RECEIVE)
1170                         break;
1171                 duration = -1; /* continuous */
1172                 digit = 'A';
1173                 goto send;
1174
1175 #if 0
1176                 case SS5_STATE_FORWARD_TRANSFER:
1177                 if (p_m_s_signal != SS5_SIGNAL_RECEIVE)
1178                         break;
1179                 /* only on bell systems continue and acknowledge tone */
1180                 if (!(p_m_mISDNport->ss5 & SS5_FEATURE_BELL))
1181                         break;
1182                 duration = SS5_TIMER_FORWARD;
1183                 digit = 'B';
1184                 goto send;
1185 #endif
1186
1187                 case SS5_STATE_CLEAR_FORWARD:
1188                 if (p_m_s_signal != SS5_SIGNAL_SEND_ON
1189                  && p_m_s_signal != SS5_SIGNAL_SEND_ON_RECOG)
1190                         break;
1191                 duration = -1; /* continuous */
1192                 digit = 'C';
1193                 goto send;
1194
1195                 case SS5_STATE_RELEASE_GUARD:
1196                 if (p_m_s_signal != SS5_SIGNAL_RECEIVE
1197                  && p_m_s_signal != SS5_SIGNAL_DELAY)
1198                         break;
1199                 /* prevent from sending release guard too long */
1200                 if (p_m_s_sample_nr >= SS5_TIMER_RELEASE_MAX)
1201                         break;
1202                 duration = -1; /* continuous */
1203                 digit = 'C';
1204                 goto send;
1205
1206                 case SS5_STATE_DIAL_OUT:
1207                 if ((p_m_mISDNport->ss5 & SS5_FEATURE_PULSEDIALING))
1208                         count = inband_dial_pulse(buffer, len, count);
1209                 else
1210                         count = inband_dial_mf(buffer, len, count);
1211                 break;
1212                 break;
1213
1214                 case SS5_STATE_DELAY:
1215                 tosend = len - count;
1216                 memset(buffer+count, audio_s16_to_law[0], tosend);
1217                 p_m_s_sample_nr += tosend;
1218                 count += tosend;
1219                 if (p_m_s_sample_nr >= SS5_TIMER_AFTER_SIGNAL) {
1220                         PDEBUG(DEBUG_SS5, "%s: delay done, ready for next signal\n", p_name);
1221                         new_ss5_state(SS5_STATE_IDLE);
1222                         inband_send_off();
1223                 }
1224                 break;
1225
1226                 case SS5_STATE_DOUBLE_SEIZE:
1227                 duration = SS5_TIMER_DOUBLE_SEIZE;
1228                 digit = 'A';
1229                 goto send;
1230
1231                 /* nothing to send */
1232                 default:
1233                 PERROR("inband signalling is turned on, but no signal is processed here.");
1234                 new_ss5_state(SS5_STATE_IDLE);
1235                 inband_send_off();
1236                 return 0;
1237         }
1238
1239         /* return (partly) filled buffer */
1240         return count;
1241 }
1242
1243
1244 int Pss5::inband_dial_mf(unsigned char *buffer, int len, int count)
1245 {
1246         int duration;
1247         int tocode, tosend;
1248         char digit;
1249
1250         /* dialing
1251          *
1252          * p_m_s_dial: digits to be dialed
1253          * p_m_s_digit_i: current digit counter
1254          * p_m_s_signal: current signal state
1255          * p_m_s_sample_nr: current sample number
1256          */
1257         again:
1258         /* get digit and duration */
1259         digit = p_m_s_dial[p_m_s_digit_i];
1260         if (!digit) { /* if end of string reached */
1261                 new_ss5_state(SS5_STATE_DELAY);
1262                 p_m_s_sample_nr = 0;
1263                 return count;
1264         }
1265         if (p_m_s_signal == SS5_SIGNAL_DIGIT_ON) {
1266                 if (!p_m_s_digit_i) // first digit
1267                         duration = SS5_TIMER_KP;
1268                 else
1269                         duration = SS5_TIMER_DIGIT;
1270         } else {
1271                 duration = SS5_TIMER_PAUSE;
1272         }
1273         /* end of digit/pause ? */
1274         if (p_m_s_sample_nr >= duration) {
1275                 p_m_s_sample_nr = 0;
1276                 if (p_m_s_signal == SS5_SIGNAL_DIGIT_PAUSE)
1277                         new_ss5_signal(SS5_SIGNAL_DIGIT_ON);
1278                 else {
1279                         new_ss5_signal(SS5_SIGNAL_DIGIT_PAUSE);
1280                         p_m_s_digit_i++;
1281                         goto again;
1282                 }
1283         }
1284         /* how much samples do we have left */
1285         tosend = len - count;
1286         tocode = duration - p_m_s_sample_nr;
1287         if (tocode < 0)
1288                 FATAL("sample_nr overrun duration");
1289         if (tosend < tocode)
1290                 tocode = tosend;
1291         /* digit or pause */
1292         if (p_m_s_signal == SS5_SIGNAL_DIGIT_PAUSE) {
1293                 memset(buffer+count, audio_s16_to_law[0], tocode);
1294 //              printf("coding pause %d bytes\n", tocode);
1295         } else {
1296                 ss5_encode(buffer+count, tocode, digit, p_m_s_sample_nr);
1297 //              printf("coding digit '%c' %d bytes\n", digit, tocode);
1298         }
1299         /* increase counters */
1300         p_m_s_sample_nr += tocode;
1301         count += tocode;
1302         /* can we take more ? */
1303         if (len != count)
1304                 goto again;
1305         return count;
1306 }
1307
1308
1309 int Pss5::inband_dial_pulse(unsigned char *buffer, int len, int count)
1310 {
1311         int tocode, tosend;
1312         int duration;
1313         char digit;
1314
1315         /* dialing
1316          *
1317          * p_m_s_dial: digits to be dialed
1318          * p_m_s_digit_i: current digit counter
1319          * p_m_s_signal: current signal state
1320          * p_m_s_sample_nr: current sample number
1321          */
1322         again:
1323         /* get digit */
1324         digit = p_m_s_dial[p_m_s_digit_i];
1325         if (!digit) { /* if end of string reached */
1326                 new_ss5_state(SS5_STATE_DELAY);
1327                 p_m_s_sample_nr = 0;
1328                 return count;
1329         }
1330         /* convert digit to pulse */
1331         switch (digit) {
1332                 case '1':
1333                 case '2':
1334                 case '3':
1335                 case '4':
1336                 case '5':
1337                 case '6':
1338                 case '7':
1339                 case '8':
1340                 case '9':
1341                 digit -= '0';
1342                 break;
1343                 case '0':
1344                 digit = 10;
1345                 break;
1346                 case '*':
1347                 digit = 11;
1348                 break;
1349                 case '#':
1350                 digit = 12;
1351                 break;
1352                 default:
1353                 p_m_s_digit_i++;
1354                 goto again;
1355         }
1356         /* get duration */
1357         if (p_m_s_signal == SS5_SIGNAL_DIGIT_ON) {
1358                 if (p_m_s_pulsecount & 1)
1359                         duration = BELL_TIMER_MAKE; /* loop closed */
1360                 else
1361                         duration = BELL_TIMER_BREAK; /* loop open, tone */
1362         } else {
1363                 duration = BELL_TIMER_PAUSE;
1364         }
1365         /* end of digit/pause ? */
1366         if (p_m_s_sample_nr >= duration) {
1367                 p_m_s_sample_nr = 0;
1368                 if (p_m_s_signal == SS5_SIGNAL_DIGIT_PAUSE) {
1369                         new_ss5_signal(SS5_SIGNAL_DIGIT_ON);
1370                         PDEBUG(DEBUG_SS5, "%s: starting pusling digit '%c'\n", p_name, digit);
1371                 } else {
1372                         p_m_s_pulsecount++; /* toggle pulse */
1373                         if (!(p_m_s_pulsecount & 1)) {
1374                                 /* pulse now on again, but if end is reached... */
1375                                 if (p_m_s_pulsecount == (digit<<1)) {
1376                                         new_ss5_signal(SS5_SIGNAL_DIGIT_PAUSE);
1377                                         p_m_s_pulsecount = 0;
1378                                         p_m_s_digit_i++;
1379                                         goto again;
1380                                 }
1381                         }
1382                 }
1383         }
1384         /* how much samples do we have left */
1385         tosend = len - count;
1386         tocode = duration - p_m_s_sample_nr;
1387         if (tocode < 0)
1388                 FATAL("sample_nr overrun duration");
1389         if (tosend < tocode)
1390                 tocode = tosend;
1391         /* digit or pause */
1392         if (p_m_s_signal == SS5_SIGNAL_DIGIT_PAUSE
1393          || (p_m_s_pulsecount&1)) /* ...or currently on and no pulse */
1394                 memset(buffer+count, audio_s16_to_law[0], tocode);
1395         else
1396                 ss5_encode(buffer+count, tocode, 'B', p_m_s_sample_nr);
1397         /* increase counters */
1398         p_m_s_sample_nr += tocode;
1399         count += tocode;
1400         /* can we take more ? */
1401         if (len != count)
1402                 goto again;
1403         return count;
1404 }
1405
1406
1407 /*
1408  * start signal
1409  */
1410 void Pss5::start_signal(int state)
1411 {
1412         PDEBUG(DEBUG_SS5, "%s: starting singal '%s'\n", p_name, ss5_state_name[state]);
1413         /* start signal */
1414         new_ss5_state(state);
1415         if (state == SS5_STATE_DIAL_OUT) {
1416                 p_m_s_digit_i = 0;
1417                 p_m_s_pulsecount = 0;
1418                 new_ss5_signal(SS5_SIGNAL_DIGIT_ON);
1419         } else
1420                 new_ss5_signal(SS5_SIGNAL_SEND_ON);
1421
1422         /* double seize must continue the current seize tone, so don't reset sample_nr */
1423         if (state != SS5_STATE_DOUBLE_SEIZE) {
1424                 /* (re)set sound phase to 0 */
1425                 p_m_s_sample_nr = 0;
1426         }
1427
1428         /* turn on inband transmitter */
1429         inband_send_on();
1430 }
1431
1432
1433 /*
1434  * handles all indications
1435  */
1436 void Pss5::seizing_ind(void)
1437 {
1438         ss5_trace_header(p_m_mISDNport, this, SS5_SEIZING_IND, p_m_b_channel);
1439         end_trace();
1440
1441         new_state(PORT_STATE_IN_SETUP);
1442         set_tone("", "noise");
1443 }
1444
1445 void Pss5::digit_ind(char digit)
1446 {
1447         int i;
1448         char string[128] = "", dial[128] = "";
1449         int dash, first_digit, last_was_digit;
1450
1451         /* add digit */
1452         SCCAT(p_m_s_dial, digit);
1453
1454         if (p_state == PORT_STATE_IN_SETUP)
1455                 new_state(PORT_STATE_IN_OVERLAP);
1456
1457         /* not last digit ? */
1458         if (digit != 'c')
1459                 return;
1460
1461         /* parse string */
1462         dash = 0; /* dash must be used next time */
1463         first_digit = 1;
1464         last_was_digit = 0;
1465         p_dialinginfo.ntype = INFO_NTYPE_UNKNOWN;
1466         for (i = 0; p_m_s_dial[i]; i++) {
1467                 if (dash || (last_was_digit && (p_m_s_dial[i]<'0' || p_m_s_dial[i]>'9')))
1468                         SCCAT(string, '-');
1469                 dash = 0;
1470                 last_was_digit = 0;
1471                 switch(p_m_s_dial[i]) {
1472                         case '1':
1473                         case '2':
1474                         case '3':
1475                         case '4':
1476                         case '5':
1477                         case '6':
1478                         case '7':
1479                         case '8':
1480                         case '9':
1481                         case '0':
1482                         if (first_digit)
1483                                 dash = 1;
1484                         first_digit = 0;
1485                         last_was_digit = 1;
1486                         SCCAT(string, p_m_s_dial[i]);
1487                         SCCAT(dial, p_m_s_dial[i]);
1488                         break;
1489                         case '*':
1490                         SCAT(string, "C11");
1491                         SCCAT(dial, p_m_s_dial[i]);
1492                         dash = 1;
1493                         break;
1494                         case '#':
1495                         SCAT(string, "C12");
1496                         SCCAT(dial, p_m_s_dial[i]);
1497                         dash = 1;
1498                         break;
1499                         case 'a':
1500                         SCAT(string, "KP1");
1501                         SCCAT(dial, p_m_s_dial[i]);
1502                         dash = 1;
1503                         break;
1504                         case 'b':
1505                         SCAT(string, "KP2");
1506                         SCCAT(dial, p_m_s_dial[i]);
1507                         dash = 1;
1508                         break;
1509                         case 'c':
1510                         SCAT(string, "ST");
1511                         dash = 1;
1512                         break;
1513                         default:
1514                         break;
1515                 }
1516         }
1517         ss5_trace_header(p_m_mISDNport, this, SS5_DIALING_IND, p_m_b_channel);
1518         add_trace("string", NULL, "%s", string);
1519         add_trace("number", NULL, "%s", dial);
1520         end_trace();
1521         new_ss5_state(SS5_STATE_IDLE);
1522
1523         do_setup(dial, 1);
1524         new_state(PORT_STATE_IN_PROCEEDING);
1525 }
1526
1527 void Pss5::pulse_ind(int on)
1528 {
1529         struct lcr_msg *message;
1530         char dial[3] = "a.";
1531
1532         if (p_m_s_signal == SS5_SIGNAL_PULSE_OFF) {
1533                 if (on) {
1534                         /* pulse turns on */
1535                         p_m_s_recog = 0;
1536                         new_ss5_signal(SS5_SIGNAL_PULSE_ON);
1537                         /* pulse turns of, count it */
1538                         p_m_s_pulsecount++;
1539                         PDEBUG(DEBUG_SS5, "%s: pulse turns on, counting\n", p_name);
1540                 } else {
1541                         /* pulse remains off */
1542                         p_m_s_recog += SS5_DECODER_NPOINTS;
1543                         /* not recognized end of digit, we wait... */
1544                         if (p_m_s_recog < BELL_TIMER_RECOG_END)
1545                                 return;
1546                         PDEBUG(DEBUG_SS5, "%s: pulse remains off, counted %d pulses\n", p_name, p_m_s_pulsecount);
1547                         if (p_m_s_pulsecount >= 12)
1548                                 dial[1] = '#';
1549                         else if (p_m_s_pulsecount == 11)
1550                                 dial[1] = '*';
1551                         else if (p_m_s_pulsecount == 10)
1552                                 dial[1] = '0';
1553                         else
1554                                 dial[1] = p_m_s_pulsecount + '0';
1555                         ss5_trace_header(p_m_mISDNport, this, SS5_DIALING_IND, p_m_b_channel);
1556                         add_trace("digit", NULL, "%s", dial+1);
1557                         add_trace("pulses", NULL, "%d", p_m_s_pulsecount);
1558                         end_trace();
1559                         if (p_state == PORT_STATE_IN_SETUP) {
1560                                 /* sending digit as setup */
1561                                 do_setup(dial, 0); /* include 'a' == KP1 */
1562                                 new_state(PORT_STATE_IN_OVERLAP);
1563                         } else {
1564                                 /* sending digit as information */
1565                                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_INFORMATION);
1566                                 SCPY(message->param.information.id, dial+1);
1567                                 message_put(message);
1568                         }
1569                                 new_ss5_state(SS5_STATE_IDLE);
1570                         /* done rx pulses, return to idle */
1571                         new_ss5_state(SS5_STATE_IDLE);
1572                 }
1573         } else {
1574                 if (on) {
1575                         /* pulse remains on */
1576                         p_m_s_recog += SS5_DECODER_NPOINTS;
1577                 } else {
1578                         /* pulse turns off */
1579                         if (p_m_s_recog >= BELL_TIMER_RECOG_HANGUP) {
1580                                 PDEBUG(DEBUG_SS5, "%s: long pulse turns off, releasing\n", p_name);
1581                                 ss5_trace_header(p_m_mISDNport, this, SS5_DIALING_IND, p_m_b_channel);
1582                                 add_trace("longtone", NULL, "releases call");
1583                                 end_trace();
1584                                 /* long pulse is gone, release current connection, if any */
1585                                 while(p_epointlist) {
1586                                         message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1587                                         message->param.disconnectinfo.location = LOCATION_BEYOND;
1588                                         message->param.disconnectinfo.cause = CAUSE_NORMAL;
1589                                         message_put(message);
1590                                         free_epointlist(p_epointlist);
1591                                 }
1592                                 set_tone("", NULL);
1593                                 /* return to setup state */
1594                                 new_state(PORT_STATE_IN_SETUP);
1595                                 new_ss5_state(SS5_STATE_IDLE);
1596                                 return;
1597                         }
1598                         PDEBUG(DEBUG_SS5, "%s: short pulse turns off, releasing\n", p_name);
1599                         p_m_s_recog = 0;
1600                         new_ss5_signal(SS5_SIGNAL_PULSE_OFF);
1601                 }
1602         }
1603 }
1604
1605 void Pss5::proceed_to_send_ind(void)
1606 {
1607         ss5_trace_header(p_m_mISDNport, this, SS5_PROCEED_TO_SEND_IND, p_m_b_channel);
1608         end_trace();
1609
1610         SCPY(p_m_s_dial, p_dialinginfo.id);
1611         start_signal(SS5_STATE_DIAL_OUT);
1612
1613         new_state(PORT_STATE_OUT_OVERLAP);
1614 }
1615
1616 void Pss5::busy_flash_ind(void)
1617 {
1618         struct lcr_msg *message;
1619
1620         ss5_trace_header(p_m_mISDNport, this, SS5_BUSY_FLASH_IND, p_m_b_channel);
1621         end_trace();
1622
1623         /* busy before dialing ? */
1624         if (!p_epointlist)
1625                 return;
1626
1627         if (!(p_m_mISDNport->ss5 & SS5_FEATURE_NODISCONNECT)) {
1628                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DISCONNECT);
1629                 message->param.disconnectinfo.location = LOCATION_BEYOND;
1630                 message->param.disconnectinfo.cause = CAUSE_BUSY;
1631                 message_put(message);
1632         }
1633
1634         new_state(PORT_STATE_IN_DISCONNECT);
1635 }
1636
1637 void Pss5::answer_ind(void)
1638 {
1639         struct lcr_msg *message;
1640
1641         ss5_trace_header(p_m_mISDNport, this, SS5_ANSWER_IND, p_m_b_channel);
1642         end_trace();
1643
1644         /* answer before dialing ? */
1645         if (!p_epointlist)
1646                 return;
1647
1648         /* already connected */
1649         if (!(p_m_mISDNport->ss5 & SS5_FEATURE_CONNECT)) {
1650                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CONNECT);
1651                 message_put(message);
1652         }
1653
1654         new_state(PORT_STATE_CONNECT);
1655 }
1656
1657 void Pss5::forward_transfer_ind(void)
1658 {
1659 //      struct lcr_msg *message;
1660
1661         ss5_trace_header(p_m_mISDNport, this, SS5_FORWARD_TRANSFER_IND, p_m_b_channel);
1662         end_trace();
1663
1664 #if 0
1665         /* if BELL flavor bluebox flag is set, use it to seize a new line */
1666         if (!(p_m_mISDNport->ss5 & SS5_FEATURE_BELL))
1667                 return;
1668
1669         /* special BELL flavor hack to clear a line and seize a new one */
1670         while(p_epointlist) {
1671                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1672                 message->param.disconnectinfo.location = LOCATION_BEYOND;
1673                 message->param.disconnectinfo.cause = CAUSE_NORMAL;
1674                 message_put(message);
1675                 free_epointlist(p_epointlist);
1676         }
1677         set_tone("", NULL);
1678         new_state(PORT_STATE_IN_SETUP);
1679 #endif
1680 }
1681
1682 void Pss5::clear_back_ind(void)
1683 {
1684         struct lcr_msg *message;
1685
1686         ss5_trace_header(p_m_mISDNport, this, SS5_CLEAR_BACK_IND, p_m_b_channel);
1687         end_trace();
1688
1689         /* nobody? */
1690         if (!p_epointlist)
1691                 return;
1692
1693         if (!(p_m_mISDNport->ss5 & SS5_FEATURE_NODISCONNECT)) {
1694                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_DISCONNECT);
1695                 message->param.disconnectinfo.location = LOCATION_BEYOND;
1696                 message->param.disconnectinfo.cause = CAUSE_NORMAL;
1697                 message_put(message);
1698         }
1699
1700         new_state(PORT_STATE_IN_DISCONNECT);
1701 }
1702
1703 void Pss5::clear_forward_ind(void)
1704 {
1705         struct lcr_msg *message;
1706
1707         ss5_trace_header(p_m_mISDNport, this, SS5_CLEAR_FORWARD_IND, p_m_b_channel);
1708         end_trace();
1709
1710         new_state(PORT_STATE_IDLE);
1711         set_tone("", NULL);
1712         p_type = PORT_TYPE_SS5_IDLE;
1713
1714         /* someone ? */
1715         if (!p_epointlist)
1716                 return;
1717
1718         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
1719         message->param.disconnectinfo.location = LOCATION_BEYOND;
1720         message->param.disconnectinfo.cause = CAUSE_NORMAL;
1721         message_put(message);
1722         free_epointlist(p_epointlist);
1723
1724 }
1725
1726 void Pss5::release_guard_ind(void)
1727 {
1728         struct lcr_msg *message;
1729
1730         ss5_trace_header(p_m_mISDNport, this, SS5_RELEASE_GUARD_IND, p_m_b_channel);
1731         end_trace();
1732
1733         set_tone("", NULL);
1734
1735         /* someone ? */
1736         if (!p_epointlist)
1737                 return;
1738
1739         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_RELEASE);
1740         message->param.disconnectinfo.location = LOCATION_BEYOND;
1741         message->param.disconnectinfo.cause = CAUSE_NORMAL;
1742         message_put(message);
1743         free_epointlist(p_epointlist);
1744 }
1745
1746 void Pss5::double_seizure_ind(void)
1747 {
1748         ss5_trace_header(p_m_mISDNport, this, SS5_DOUBLE_SEIZURE_IND, p_m_b_channel);
1749         end_trace();
1750         ss5_trace_header(p_m_mISDNport, this, SS5_DOUBLE_SEIZURE_REQ, p_m_b_channel);
1751         end_trace();
1752
1753         /* start double seizure sequence, so remote exchange will recognize it */
1754         start_signal(SS5_STATE_DOUBLE_SEIZE);
1755 }
1756
1757
1758 /*
1759  * shuts down by sending a clear forward and releasing endpoint
1760  */
1761 void Pss5::do_release(int cause, int location, int signal)
1762 {
1763         struct lcr_msg *message;
1764
1765         /* sending release to endpoint */
1766         while(p_epointlist) {
1767                 message = message_create(p_serial, p_epointlist->epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1768                 message->param.disconnectinfo.location = location;
1769                 message->param.disconnectinfo.cause = cause;
1770                 message_put(message);
1771                 free_epointlist(p_epointlist);
1772         }
1773
1774 //      if (p_state != PORT_STATE_RELEASE) {
1775                 p_m_s_queued_signal = signal;
1776                 if (signal == SS5_CLEAR_FORWARD_REQ) {
1777                         new_state(PORT_STATE_RELEASE);
1778                         set_tone("", "noise");
1779                 } else
1780                         new_state(PORT_STATE_OUT_DISCONNECT);
1781                 trigger_work(&p_m_s_queue);
1782 //      }
1783 }
1784
1785
1786 /*
1787  * create endpoint and send setup
1788  */
1789 void Pss5::do_setup(char *dial, int complete)
1790 {
1791         class Endpoint *epoint;
1792         struct lcr_msg *message;
1793
1794         SCPY(p_dialinginfo.id, dial);
1795         p_dialinginfo.sending_complete = complete;
1796         p_callerinfo.present = INFO_PRESENT_NOTAVAIL;
1797         p_callerinfo.screen = INFO_SCREEN_NETWORK;
1798         p_callerinfo.ntype = INFO_NTYPE_NOTPRESENT;
1799         p_callerinfo.isdn_port = p_m_portnum;
1800         SCPY(p_callerinfo.interface, p_m_mISDNport->ifport->interface->name);
1801
1802         p_capainfo.bearer_capa = INFO_BC_AUDIO;
1803         p_capainfo.bearer_info1 = (options.law=='a')?3:2;
1804         p_capainfo.bearer_mode = INFO_BMODE_CIRCUIT;
1805         p_capainfo.hlc = INFO_HLC_NONE;
1806         p_capainfo.exthlc = INFO_HLC_NONE;
1807         p_capainfo.source_mode = B_MODE_TRANSPARENT;
1808
1809         /* create endpoint */
1810         if (p_epointlist)
1811                 FATAL("Incoming call but already got an endpoint.\n");
1812         if (!(epoint = new Endpoint(p_serial, 0)))
1813                 FATAL("No memory for Endpoint instance\n");
1814         epoint->ep_app = new_endpointapp(epoint, 0, p_m_mISDNport->ifport->interface->app); //incoming
1815         epointlist_new(epoint->ep_serial);
1816
1817         /* send setup message to endpoit */
1818         message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_SETUP);
1819         message->param.setup.isdn_port = p_m_portnum;
1820         message->param.setup.port_type = p_type;
1821 //      message->param.setup.dtmf = !p_m_mISDNport->ifport->nodtmf;
1822         memcpy(&message->param.setup.dialinginfo, &p_dialinginfo, sizeof(struct dialing_info));
1823         memcpy(&message->param.setup.callerinfo, &p_callerinfo, sizeof(struct caller_info));
1824         memcpy(&message->param.setup.redirinfo, &p_redirinfo, sizeof(struct redir_info));
1825         memcpy(&message->param.setup.capainfo, &p_capainfo, sizeof(struct capa_info));
1826         message_put(message);
1827
1828 }
1829
1830
1831
1832 /*
1833  * handles all messages from endpoint
1834  */
1835
1836 /* MESSAGE_SETUP */
1837 void Pss5::message_setup(unsigned int epoint_id, int message_id, union parameter *param)
1838 {
1839         struct lcr_msg *message;
1840         int i;
1841         char string[128] = "", dial[128] = "";
1842         int dash, first_digit, last_was_digit;
1843
1844         if (p_epointlist) {
1845                 PERROR("endpoint already exist.\n");
1846                 message = message_create(p_serial, epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1847                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1848                 message->param.disconnectinfo.cause = CAUSE_UNSPECIFIED;
1849                 message_put(message);
1850                 return;
1851         }
1852
1853         /* copy setup infos to port */
1854         memcpy(&p_callerinfo, &param->setup.callerinfo, sizeof(p_callerinfo));
1855         memcpy(&p_dialinginfo, &param->setup.dialinginfo, sizeof(p_dialinginfo));
1856         memcpy(&p_capainfo, &param->setup.capainfo, sizeof(p_capainfo));
1857         memcpy(&p_redirinfo, &param->setup.redirinfo, sizeof(p_redirinfo));
1858         /* screen outgoing caller id */
1859         do_screen(1, p_callerinfo.id, sizeof(p_callerinfo.id), &p_callerinfo.ntype, &p_callerinfo.present, p_m_mISDNport->ifport->interface->name);
1860         do_screen(1, p_callerinfo.id2, sizeof(p_callerinfo.id2), &p_callerinfo.ntype2, &p_callerinfo.present2, p_m_mISDNport->ifport->interface->name);
1861
1862         /* parse dial string  */
1863         dash = 0; /* dash must be used next time */
1864         first_digit = 1;
1865         last_was_digit = 0;
1866         for (i = 0; p_dialinginfo.id[i]; i++) {
1867                 if (dash || (last_was_digit && (p_dialinginfo.id[i]<'0' || p_dialinginfo.id[i]>'9')))
1868                         SCCAT(string, '-');
1869                 dash = 0;
1870                 last_was_digit = 0;
1871                 switch(p_dialinginfo.id[i]) {
1872                         case '1':
1873                         case '2':
1874                         case '3':
1875                         case '4':
1876                         case '5':
1877                         case '6':
1878                         case '7':
1879                         case '8':
1880                         case '9':
1881                         case '0':
1882                         if (i && first_digit)
1883                                 dash = 1;
1884                         first_digit = 0;
1885                         last_was_digit = 1;
1886                         SCCAT(string, p_dialinginfo.id[i]);
1887                         SCCAT(dial, p_dialinginfo.id[i]);
1888                         break;
1889                         case '*':
1890                         SCAT(string, "C11");
1891                         SCCAT(dial, '*');
1892                         dash = 1;
1893                         break;
1894                         case '#':
1895                         SCAT(string, "C12");
1896                         SCCAT(dial, '#');
1897                         dash = 1;
1898                         break;
1899                         case 'a':
1900                         SCAT(string, "KP1");
1901                         SCCAT(dial, 'a');
1902                         dash = 1;
1903                         break;
1904                         case 'b':
1905                         SCAT(string, "KP2");
1906                         SCCAT(dial, 'b');
1907                         dash = 1;
1908                         break;
1909                         case 'c':
1910                         SCAT(string, "ST");
1911                         SCCAT(dial, 'c');
1912                         dash = 1;
1913                         case 'K':
1914                         i++;
1915                         if (p_dialinginfo.id[i] != 'P')
1916                                 goto dial_error;
1917                         i++;
1918                         if (p_dialinginfo.id[i] == '1') {
1919                                 SCAT(string, "KP1");
1920                                 SCCAT(dial, 'a');
1921                                 dash = 1;
1922                                 break;
1923                         }
1924                         if (p_dialinginfo.id[i] == '2') {
1925                                 SCAT(string, "KP2");
1926                                 SCCAT(dial, 'b');
1927                                 dash = 1;
1928                                 break;
1929                         }
1930                         goto dial_error;
1931                         case 'C':
1932                         i++;
1933                         if (p_dialinginfo.id[i] != '1')
1934                                 goto dial_error;
1935                         i++;
1936                         if (p_dialinginfo.id[i] == '1') {
1937                                 SCAT(string, "C11");
1938                                 SCCAT(dial, 'a');
1939                                 dash = 1;
1940                                 break;
1941                         }
1942                         if (p_dialinginfo.id[i] == '2') {
1943                                 SCAT(string, "C12");
1944                                 SCCAT(dial, 'b');
1945                                 dash = 1;
1946                                 break;
1947                         }
1948                         goto dial_error;
1949                         case 'S':
1950                         i++;
1951                         if (p_dialinginfo.id[i] != 'T')
1952                                 goto dial_error;
1953                         SCAT(string, "ST");
1954                         SCCAT(dial, 'c');
1955                         dash = 1;
1956                         break;
1957                         default:
1958                         break;
1959                 }
1960                 /* stop, if ST */
1961                 if (dial[0] && dial[strlen(dial)-1] == 'c')
1962                         break;
1963         }
1964         /* terminate */
1965         if (dial[0] && dial[strlen(dial)-1]!='c') {
1966                 SCCAT(string, '-');
1967                 SCAT(string, "ST");
1968                 SCCAT(dial, 'c');
1969         }
1970
1971         /* error in dial string */
1972         if (!dial[0]) {
1973                 dial_error:
1974                 ss5_trace_header(p_m_mISDNport, this, SS5_DIALING_REQ, p_m_b_channel);
1975                 add_trace("string", NULL, "%s", p_dialinginfo.id);
1976                 if (!dial[0])
1977                         add_trace("error", NULL, "no number", dial);
1978                 else if (dial[0]!='a' && dial[0]!='b')
1979                         add_trace("error", NULL, "number must start with KP1/KP2", dial);
1980                 else
1981                         add_trace("error", NULL, "illegal format", dial);
1982                 end_trace();
1983                 message = message_create(p_serial, epoint_id, PORT_TO_EPOINT, MESSAGE_RELEASE);
1984                 message->param.disconnectinfo.location = LOCATION_PRIVATE_LOCAL;
1985                 message->param.disconnectinfo.cause = CAUSE_INVALID;
1986                 message_put(message);
1987                 return;
1988         }
1989
1990         /* copy new dial string */
1991         SCPY(p_dialinginfo.id, dial);
1992
1993         /* attach only if not already */
1994         epointlist_new(epoint_id);
1995
1996         ss5_trace_header(p_m_mISDNport, this, SS5_DIALING_REQ, p_m_b_channel);
1997         add_trace("string", NULL, "%s", string);
1998         add_trace("type", NULL, "%s", (dial[0]=='b')?"international":"national");
1999         add_trace("number", NULL, "%s", dial);
2000         end_trace();
2001         /* connect auto path */
2002         if ((p_m_mISDNport->ss5 & SS5_FEATURE_CONNECT)) {
2003                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_CONNECT);
2004                 message_put(message);
2005         } else {
2006                 message = message_create(p_serial, ACTIVE_EPOINT(p_epointlist), PORT_TO_EPOINT, MESSAGE_PROCEEDING);
2007                 message_put(message);
2008         }
2009
2010         /* start seizing */
2011         ss5_trace_header(p_m_mISDNport, this, SS5_SEIZING_REQ, p_m_b_channel);
2012         end_trace();
2013         new_ss5_state(SS5_STATE_SEIZING);
2014         new_ss5_signal(SS5_SIGNAL_SEND_ON);
2015         p_m_s_sample_nr = 0;
2016         inband_send_on();
2017
2018         p_type = PORT_TYPE_SS5_OUT;
2019         new_state(PORT_STATE_OUT_SETUP);
2020 }
2021
2022 /* MESSAGE_CONNECT */
2023 void Pss5::message_connect(unsigned int epoint_id, int message_id, union parameter *param)
2024 {
2025         memcpy(&p_connectinfo, &param->connectinfo, sizeof(p_connectinfo));
2026
2027         if (p_state != PORT_STATE_CONNECT) {
2028                 p_m_s_queued_signal = SS5_ANSWER_REQ;
2029                 new_state(PORT_STATE_CONNECT);
2030                 trigger_work(&p_m_s_queue);
2031         }
2032
2033         set_tone("", NULL);
2034 }
2035
2036 /* MESSAGE_DISCONNECT */
2037 void Pss5::message_disconnect(unsigned int epoint_id, int message_id, union parameter *param)
2038 {
2039         /* release and clear forward */
2040         if (p_type==PORT_TYPE_SS5_OUT) { /* outgoing exchange */
2041                 do_release(param->disconnectinfo.cause, param->disconnectinfo.location, SS5_CLEAR_FORWARD_REQ);
2042                 return;
2043         }
2044         /* release and clear back */
2045         if ((p_m_mISDNport->ss5 & SS5_FEATURE_RELEASE)) {
2046                 do_release(param->disconnectinfo.cause, param->disconnectinfo.location, SS5_CLEAR_BACK_REQ);
2047                 return;
2048         }
2049
2050         /* disconnect by sending clear back (after answer) or busy flash (before answer) */
2051         if (p_state != PORT_STATE_OUT_DISCONNECT) {
2052                 if (p_state == PORT_STATE_CONNECT)
2053                         p_m_s_queued_signal = SS5_CLEAR_BACK_REQ;
2054                 else
2055                         p_m_s_queued_signal = SS5_BUSY_FLASH_REQ;
2056                 new_state(PORT_STATE_OUT_DISCONNECT);
2057                 trigger_work(&p_m_s_queue);
2058         }
2059 }
2060
2061 /* MESSAGE_RELEASE */
2062 void Pss5::message_release(unsigned int epoint_id, int message_id, union parameter *param)
2063 {
2064         /* always send clear forward, because release guard only works as a reply to clear forward */
2065         do_release(param->disconnectinfo.cause, param->disconnectinfo.location, SS5_CLEAR_FORWARD_REQ);
2066 }
2067
2068 /*
2069  * endpoint sends messages to the port
2070  */
2071 int Pss5::message_epoint(unsigned int epoint_id, int message_id, union parameter *param)
2072 {
2073         if (PmISDN::message_epoint(epoint_id, message_id, param))
2074                 return(1);
2075
2076         switch(message_id) {
2077                 case MESSAGE_SETUP: /* dial-out command received from epoint */
2078                 if (p_state!=PORT_STATE_IDLE) {
2079                         PERROR("Pss5(%s) ignoring setup because isdn port is not in idle state (or connected for sending display info).\n", p_name);
2080                         break;
2081                 }
2082                 if (p_epointlist && p_state==PORT_STATE_IDLE)
2083                         FATAL("Pss5(%s): epoint pointer is set in idle state, how bad!!\n", p_name);
2084                 message_setup(epoint_id, message_id, param);
2085                 break;
2086
2087                 case MESSAGE_CONNECT: /* call of endpoint is connected */
2088                 message_connect(epoint_id, message_id, param);
2089                 break;
2090
2091                 case MESSAGE_DISCONNECT: /* call has been disconnected */
2092                 message_disconnect(epoint_id, message_id, param);
2093                 break;
2094
2095                 case MESSAGE_RELEASE: /* release isdn port */
2096                 message_release(epoint_id, message_id, param);
2097                 break;
2098
2099                 default:
2100                 PDEBUG(DEBUG_SS5, "Pss5(%s) ss5 port with (caller id %s) received an unhandled message: %d\n", p_name, p_callerinfo.id, message_id);
2101         }
2102
2103         return(1);
2104 }
2105