channels/chan_dahdi.c

   1 /*
   2  * Asterisk -- An open source telephony toolkit.
   3  *
   4  * Copyright (C) 1999 - 2008, Digium, Inc.
   5  *
   6  * Mark Spencer <markster@digium.com>
   7  *
   8  * See http://www.asterisk.org for more information about
   9  * the Asterisk project. Please do not directly contact
  10  * any of the maintainers of this project for assistance;
  11  * the project provides a web site, mailing lists and IRC
  12  * channels for your use.
  13  *
  14  * This program is free software, distributed under the terms of
  15  * the GNU General Public License Version 2. See the LICENSE file
  16  * at the top of the source tree.
  17  */
  18
  19 /*! \file
  20  *
  21  * \brief DAHDI for Pseudo TDM
  22  *
  23  * \author Mark Spencer <markster@digium.com>
  24  *
  25  * Connects to the DAHDI telephony library as well as
  26  * libpri. Libpri is optional and needed only if you are
  27  * going to use ISDN connections.
  28  *
  29  * You need to install libraries before you attempt to compile
  30  * and install the DAHDI channel.
  31  *
  32  * \par See also
  33  * \arg \ref Config_dahdi
  34  *
  35  * \ingroup channel_drivers
  36  *
  37  * \todo Deprecate the "musiconhold" configuration option post 1.4
  38  */
  39
  40 /*** MODULEINFO
  41         <use type="module">res_smdi</use>
  42         <depend>dahdi</depend>
  43         <depend>tonezone</depend>
  44         <use type="external">pri</use>
  45         <use type="external">ss7</use>
  46         <use type="external">openr2</use>
  47         <support_level>core</support_level>
  48  ***/
  49
  50 #include "asterisk.h"
  51
  52 ASTERISK_FILE_VERSION(__FILE__, "$Revision$")
  53
  54 #if defined(__NetBSD__) || defined(__FreeBSD__)
  55 #include <pthread.h>
  56 #include <signal.h>
  57 #else
  58 #include <sys/signal.h>
  59 #endif
  60 #include <sys/ioctl.h>
  61 #include <sys/stat.h>
  62 #include <math.h>
  63 #include <ctype.h>
  64
  65 #include <dahdi/user.h>
  66 #include <dahdi/tonezone.h>
  67 #include "sig_analog.h"
  68 /* Analog signaling is currently still present in chan_dahdi for use with
  69  * radio. Sig_analog does not currently handle any radio operations. If
  70  * radio only uses analog signaling, then the radio handling logic could
  71  * be placed in sig_analog and the duplicated code could be removed.
  72  */
  73
  74 #ifdef HAVE_PRI
  75 #include "sig_pri.h"
  76 #endif
  77
  78 #if defined(HAVE_SS7)
  79 #include "sig_ss7.h"
  80 #endif  /* defined(HAVE_SS7) */
  81
  82 #ifdef HAVE_OPENR2
  83 /* put this here until sig_mfcr2 comes along */
  84 #define SIG_MFCR2_MAX_CHANNELS  672             /*!< No more than a DS3 per trunk group */
  85 #include <openr2.h>
  86 #endif
  87
  88 #include "asterisk/lock.h"
  89 #include "asterisk/channel.h"
  90 #include "asterisk/config.h"
  91 #include "asterisk/module.h"
  92 #include "asterisk/pbx.h"
  93 #include "asterisk/file.h"
  94 #include "asterisk/ulaw.h"
  95 #include "asterisk/alaw.h"
  96 #include "asterisk/callerid.h"
  97 #include "asterisk/adsi.h"
  98 #include "asterisk/cli.h"
  99 #include "asterisk/cdr.h"
 100 #include "asterisk/cel.h"
 101 #include "asterisk/features.h"
 102 #include "asterisk/musiconhold.h"
 103 #include "asterisk/say.h"
 104 #include "asterisk/tdd.h"
 105 #include "asterisk/app.h"
 106 #include "asterisk/dsp.h"
 107 #include "asterisk/astdb.h"
 108 #include "asterisk/manager.h"
 109 #include "asterisk/causes.h"
 110 #include "asterisk/term.h"
 111 #include "asterisk/utils.h"
 112 #include "asterisk/transcap.h"
 113 #include "asterisk/stringfields.h"
 114 #include "asterisk/abstract_jb.h"
 115 #include "asterisk/smdi.h"
 116 #include "asterisk/astobj.h"
 117 #include "asterisk/event.h"
 118 #include "asterisk/devicestate.h"
 119 #include "asterisk/paths.h"
 120 #include "asterisk/ccss.h"
 121 #include "asterisk/data.h"
 122
 123 /*** DOCUMENTATION
 124         <application name="DAHDISendKeypadFacility" language="en_US">
 125                 <synopsis>
 126                         Send digits out of band over a PRI.
 127                 </synopsis>
 128                 <syntax>
 129                         <parameter name="digits" required="true" />
 130                 </syntax>
 131                 <description>
 132                         <para>This application will send the given string of digits in a Keypad
 133                         Facility IE over the current channel.</para>
 134                 </description>
 135         </application>
 136         <application name="DAHDISendCallreroutingFacility" language="en_US">
 137                 <synopsis>
 138                         Send an ISDN call rerouting/deflection facility message.
 139                 </synopsis>
 140                 <syntax argsep=",">
 141                         <parameter name="destination" required="true">
 142                                 <para>Destination number.</para>
 143                         </parameter>
 144                         <parameter name="original">
 145                                 <para>Original called number.</para>
 146                         </parameter>
 147                         <parameter name="reason">
 148                                 <para>Diversion reason, if not specified defaults to <literal>unknown</literal></para>
 149                         </parameter>
 150                 </syntax>
 151                 <description>
 152                         <para>This application will send an ISDN switch specific call
 153                         rerouting/deflection facility message over the current channel.
 154                         Supported switches depend upon the version of libpri in use.</para>
 155                 </description>
 156         </application>
 157         <application name="DAHDIAcceptR2Call" language="en_US">
 158                 <synopsis>
 159                         Accept an R2 call if its not already accepted (you still need to answer it)
 160                 </synopsis>
 161                 <syntax>
 162                         <parameter name="charge" required="true">
 163                                 <para>Yes or No.</para>
 164                                 <para>Whether you want to accept the call with charge or without charge.</para>
 165                         </parameter>
 166                 </syntax>
 167                 <description>
 168                         <para>This application will Accept the R2 call either with charge or no charge.</para>
 169                 </description>
 170         </application>
 171         <manager name="DAHDITransfer" language="en_US">
 172                 <synopsis>
 173                         Transfer DAHDI Channel.
 174                 </synopsis>
 175                 <syntax>
 176                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 177                         <parameter name="DAHDIChannel" required="true">
 178                                 <para>DAHDI channel number to transfer.</para>
 179                         </parameter>
 180                 </syntax>
 181                 <description>
 182                         <para>Simulate a flash hook event by the user connected to the channel.</para>
 183                         <note><para>Valid only for analog channels.</para></note>
 184                 </description>
 185         </manager>
 186         <manager name="DAHDIHangup" language="en_US">
 187                 <synopsis>
 188                         Hangup DAHDI Channel.
 189                 </synopsis>
 190                 <syntax>
 191                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 192                         <parameter name="DAHDIChannel" required="true">
 193                                 <para>DAHDI channel number to hangup.</para>
 194                         </parameter>
 195                 </syntax>
 196                 <description>
 197                         <para>Simulate an on-hook event by the user connected to the channel.</para>
 198                         <note><para>Valid only for analog channels.</para></note>
 199                 </description>
 200         </manager>
 201         <manager name="DAHDIDialOffhook" language="en_US">
 202                 <synopsis>
 203                         Dial over DAHDI channel while offhook.
 204                 </synopsis>
 205                 <syntax>
 206                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 207                         <parameter name="DAHDIChannel" required="true">
 208                                 <para>DAHDI channel number to dial digits.</para>
 209                         </parameter>
 210                         <parameter name="Number" required="true">
 211                                 <para>Digits to dial.</para>
 212                         </parameter>
 213                 </syntax>
 214                 <description>
 215                         <para>Generate DTMF control frames to the bridged peer.</para>
 216                 </description>
 217         </manager>
 218         <manager name="DAHDIDNDon" language="en_US">
 219                 <synopsis>
 220                         Toggle DAHDI channel Do Not Disturb status ON.
 221                 </synopsis>
 222                 <syntax>
 223                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 224                         <parameter name="DAHDIChannel" required="true">
 225                                 <para>DAHDI channel number to set DND on.</para>
 226                         </parameter>
 227                 </syntax>
 228                 <description>
 229                         <para>Equivalent to the CLI command "dahdi set dnd <variable>channel</variable> on".</para>
 230                         <note><para>Feature only supported by analog channels.</para></note>
 231                 </description>
 232         </manager>
 233         <manager name="DAHDIDNDoff" language="en_US">
 234                 <synopsis>
 235                         Toggle DAHDI channel Do Not Disturb status OFF.
 236                 </synopsis>
 237                 <syntax>
 238                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 239                         <parameter name="DAHDIChannel" required="true">
 240                                 <para>DAHDI channel number to set DND off.</para>
 241                         </parameter>
 242                 </syntax>
 243                 <description>
 244                         <para>Equivalent to the CLI command "dahdi set dnd <variable>channel</variable> off".</para>
 245                         <note><para>Feature only supported by analog channels.</para></note>
 246                 </description>
 247         </manager>
 248         <manager name="DAHDIShowChannels" language="en_US">
 249                 <synopsis>
 250                         Show status of DAHDI channels.
 251                 </synopsis>
 252                 <syntax>
 253                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 254                         <parameter name="DAHDIChannel">
 255                                 <para>Specify the specific channel number to show.  Show all channels if zero or not present.</para>
 256                         </parameter>
 257                 </syntax>
 258                 <description>
 259                         <para>Similar to the CLI command "dahdi show channels".</para>
 260                 </description>
 261         </manager>
 262         <manager name="DAHDIRestart" language="en_US">
 263                 <synopsis>
 264                         Fully Restart DAHDI channels (terminates calls).
 265                 </synopsis>
 266                 <syntax>
 267                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 268                 </syntax>
 269                 <description>
 270                         <para>Equivalent to the CLI command "dahdi restart".</para>
 271                 </description>
 272         </manager>
 273         <manager name="PRIShowSpans" language="en_US">
 274                 <synopsis>
 275                         Show status of PRI spans.
 276                 </synopsis>
 277                 <syntax>
 278                         <xi:include xpointer="xpointer(/docs/manager[@name='Login']/syntax/parameter[@name='ActionID'])" />
 279                         <parameter name="Span">
 280                                 <para>Specify the specific span to show.  Show all spans if zero or not present.</para>
 281                         </parameter>
 282                 </syntax>
 283                 <description>
 284                         <para>Similar to the CLI command "pri show spans".</para>
 285                 </description>
 286         </manager>
 287  ***/
 288
 289 #define SMDI_MD_WAIT_TIMEOUT 1500 /* 1.5 seconds */
 290
 291 static const char * const lbostr[] = {
 292 "0 db (CSU)/0-133 feet (DSX-1)",
 293 "133-266 feet (DSX-1)",
 294 "266-399 feet (DSX-1)",
 295 "399-533 feet (DSX-1)",
 296 "533-655 feet (DSX-1)",
 297 "-7.5db (CSU)",
 298 "-15db (CSU)",
 299 "-22.5db (CSU)"
 300 };
 301
 302 /*! Global jitterbuffer configuration - by default, jb is disabled
 303  *  \note Values shown here match the defaults shown in chan_dahdi.conf.sample */
 304 static struct ast_jb_conf default_jbconf =
 305 {
 306         .flags = 0,
 307         .max_size = 200,
 308         .resync_threshold = 1000,
 309         .impl = "fixed",
 310         .target_extra = 40,
 311 };
 312 static struct ast_jb_conf global_jbconf;
 313
 314 /*!
 315  * \note Define ZHONE_HACK to cause us to go off hook and then back on hook when
 316  * the user hangs up to reset the state machine so ring works properly.
 317  * This is used to be able to support kewlstart by putting the zhone in
 318  * groundstart mode since their forward disconnect supervision is entirely
 319  * broken even though their documentation says it isn't and their support
 320  * is entirely unwilling to provide any assistance with their channel banks
 321  * even though their web site says they support their products for life.
 322  */
 323 /* #define ZHONE_HACK */
 324
 325 /*! \brief Typically, how many rings before we should send Caller*ID */
 326 #define DEFAULT_CIDRINGS 1
 327
 328 #define AST_LAW(p) (((p)->law == DAHDI_LAW_ALAW) ? AST_FORMAT_ALAW : AST_FORMAT_ULAW)
 329
 330
 331 /*! \brief Signaling types that need to use MF detection should be placed in this macro */
 332 #define NEED_MFDETECT(p) (((p)->sig == SIG_FEATDMF) || ((p)->sig == SIG_FEATDMF_TA) || ((p)->sig == SIG_E911) || ((p)->sig == SIG_FGC_CAMA) || ((p)->sig == SIG_FGC_CAMAMF) || ((p)->sig == SIG_FEATB))
 333
 334 static const char tdesc[] = "DAHDI Telephony Driver"
 335 #if defined(HAVE_PRI) || defined(HAVE_SS7) || defined(HAVE_OPENR2)
 336         " w/"
 337         #if defined(HAVE_PRI)
 338                 "PRI"
 339         #endif  /* defined(HAVE_PRI) */
 340         #if defined(HAVE_SS7)
 341                 #if defined(HAVE_PRI)
 342                 " & "
 343                 #endif  /* defined(HAVE_PRI) */
 344                 "SS7"
 345         #endif  /* defined(HAVE_SS7) */
 346         #if defined(HAVE_OPENR2)
 347                 #if defined(HAVE_PRI) || defined(HAVE_SS7)
 348                 " & "
 349                 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
 350                 "MFC/R2"
 351         #endif  /* defined(HAVE_OPENR2) */
 352 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) || defined(HAVE_OPENR2) */
 353 ;
 354
 355 static const char config[] = "chan_dahdi.conf";
 356
 357 #define SIG_EM          DAHDI_SIG_EM
 358 #define SIG_EMWINK      (0x0100000 | DAHDI_SIG_EM)
 359 #define SIG_FEATD       (0x0200000 | DAHDI_SIG_EM)
 360 #define SIG_FEATDMF     (0x0400000 | DAHDI_SIG_EM)
 361 #define SIG_FEATB       (0x0800000 | DAHDI_SIG_EM)
 362 #define SIG_E911        (0x1000000 | DAHDI_SIG_EM)
 363 #define SIG_FEATDMF_TA  (0x2000000 | DAHDI_SIG_EM)
 364 #define SIG_FGC_CAMA    (0x4000000 | DAHDI_SIG_EM)
 365 #define SIG_FGC_CAMAMF  (0x8000000 | DAHDI_SIG_EM)
 366 #define SIG_FXSLS       DAHDI_SIG_FXSLS
 367 #define SIG_FXSGS       DAHDI_SIG_FXSGS
 368 #define SIG_FXSKS       DAHDI_SIG_FXSKS
 369 #define SIG_FXOLS       DAHDI_SIG_FXOLS
 370 #define SIG_FXOGS       DAHDI_SIG_FXOGS
 371 #define SIG_FXOKS       DAHDI_SIG_FXOKS
 372 #define SIG_PRI         DAHDI_SIG_CLEAR
 373 #define SIG_BRI         (0x2000000 | DAHDI_SIG_CLEAR)
 374 #define SIG_BRI_PTMP    (0X4000000 | DAHDI_SIG_CLEAR)
 375 #define SIG_SS7         (0x1000000 | DAHDI_SIG_CLEAR)
 376 #define SIG_MFCR2       DAHDI_SIG_CAS
 377 #define SIG_SF          DAHDI_SIG_SF
 378 #define SIG_SFWINK      (0x0100000 | DAHDI_SIG_SF)
 379 #define SIG_SF_FEATD    (0x0200000 | DAHDI_SIG_SF)
 380 #define SIG_SF_FEATDMF  (0x0400000 | DAHDI_SIG_SF)
 381 #define SIG_SF_FEATB    (0x0800000 | DAHDI_SIG_SF)
 382 #define SIG_EM_E1       DAHDI_SIG_EM_E1
 383
 384 #ifdef LOTS_OF_SPANS
 385 #define NUM_SPANS       DAHDI_MAX_SPANS
 386 #else
 387 #define NUM_SPANS               32
 388 #endif
 389
 390 #define CHAN_PSEUDO     -2
 391
 392 #define CALLPROGRESS_PROGRESS           1
 393 #define CALLPROGRESS_FAX_OUTGOING       2
 394 #define CALLPROGRESS_FAX_INCOMING       4
 395 #define CALLPROGRESS_FAX                (CALLPROGRESS_FAX_INCOMING | CALLPROGRESS_FAX_OUTGOING)
 396
 397 #define NUM_CADENCE_MAX 25
 398 static int num_cadence = 4;
 399 static int user_has_defined_cadences = 0;
 400
 401 static struct dahdi_ring_cadence cadences[NUM_CADENCE_MAX] = {
 402         { { 125, 125, 2000, 4000 } },                   /*!< Quick chirp followed by normal ring */
 403         { { 250, 250, 500, 1000, 250, 250, 500, 4000 } }, /*!< British style ring */
 404         { { 125, 125, 125, 125, 125, 4000 } },  /*!< Three short bursts */
 405         { { 1000, 500, 2500, 5000 } },  /*!< Long ring */
 406 };
 407
 408 /*! \brief cidrings says in which pause to transmit the cid information, where the first pause
 409  * is 1, the second pause is 2 and so on.
 410  */
 411
 412 static int cidrings[NUM_CADENCE_MAX] = {
 413         2,                                                                              /*!< Right after first long ring */
 414         4,                                                                              /*!< Right after long part */
 415         3,                                                                              /*!< After third chirp */
 416         2,                                                                              /*!< Second spell */
 417 };
 418
 419 /* ETSI EN300 659-1 specifies the ring pulse between 200 and 300 mS */
 420 static struct dahdi_ring_cadence AS_RP_cadence = {{250, 10000}};
 421
 422 #define ISTRUNK(p) ((p->sig == SIG_FXSLS) || (p->sig == SIG_FXSKS) || \
 423                         (p->sig == SIG_FXSGS) || (p->sig == SIG_PRI))
 424
 425 #define CANBUSYDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)
 426 #define CANPROGRESSDETECT(p) (ISTRUNK(p) || (p->sig & (SIG_EM | SIG_EM_E1 | SIG_SF)) /* || (p->sig & __DAHDI_SIG_FXO) */)
 427
 428 static char defaultcic[64] = "";
 429 static char defaultozz[64] = "";
 430
 431 /*! Run this script when the MWI state changes on an FXO line, if mwimonitor is enabled */
 432 static char mwimonitornotify[PATH_MAX] = "";
 433 #ifndef HAVE_DAHDI_LINEREVERSE_VMWI
 434 static int  mwisend_rpas = 0;
 435 #endif
 436
 437 static char progzone[10] = "";
 438
 439 static int usedistinctiveringdetection = 0;
 440 static int distinctiveringaftercid = 0;
 441
 442 static int numbufs = 4;
 443
 444 static int mwilevel = 512;
 445 static int dtmfcid_level = 256;
 446
 447 #define REPORT_CHANNEL_ALARMS 1
 448 #define REPORT_SPAN_ALARMS    2
 449 static int report_alarms = REPORT_CHANNEL_ALARMS;
 450
 451 #ifdef HAVE_PRI
 452 static int pridebugfd = -1;
 453 static char pridebugfilename[1024] = "";
 454 #endif
 455
 456 /*! \brief Wait up to 16 seconds for first digit (FXO logic) */
 457 static int firstdigittimeout = 16000;
 458
 459 /*! \brief How long to wait for following digits (FXO logic) */
 460 static int gendigittimeout = 8000;
 461
 462 /*! \brief How long to wait for an extra digit, if there is an ambiguous match */
 463 static int matchdigittimeout = 3000;
 464
 465 /*! \brief Protect the interface list (of dahdi_pvt's) */
 466 AST_MUTEX_DEFINE_STATIC(iflock);
 467
 468
 469 static int ifcount = 0;
 470
 471 #ifdef HAVE_PRI
 472 AST_MUTEX_DEFINE_STATIC(pridebugfdlock);
 473 #endif
 474
 475 /*! \brief Protect the monitoring thread, so only one process can kill or start it, and not
 476    when it's doing something critical. */
 477 AST_MUTEX_DEFINE_STATIC(monlock);
 478
 479 /*! \brief This is the thread for the monitor which checks for input on the channels
 480    which are not currently in use. */
 481 static pthread_t monitor_thread = AST_PTHREADT_NULL;
 482 static ast_cond_t ss_thread_complete;
 483 AST_MUTEX_DEFINE_STATIC(ss_thread_lock);
 484 AST_MUTEX_DEFINE_STATIC(restart_lock);
 485 static int ss_thread_count = 0;
 486 static int num_restart_pending = 0;
 487
 488 static int restart_monitor(void);
 489
 490 static enum ast_bridge_result dahdi_bridge(struct ast_channel *c0, struct ast_channel *c1, int flags, struct ast_frame **fo, struct ast_channel **rc, int timeoutms);
 491
 492 static int dahdi_sendtext(struct ast_channel *c, const char *text);
 493
 494 static void mwi_event_cb(const struct ast_event *event, void *userdata)
 495 {
 496         /* This module does not handle MWI in an event-based manner.  However, it
 497          * subscribes to MWI for each mailbox that is configured so that the core
 498          * knows that we care about it.  Then, chan_dahdi will get the MWI from the
 499          * event cache instead of checking the mailbox directly. */
 500 }
 501
 502 /*! \brief Avoid the silly dahdi_getevent which ignores a bunch of events */
 503 static inline int dahdi_get_event(int fd)
 504 {
 505         int j;
 506         if (ioctl(fd, DAHDI_GETEVENT, &j) == -1)
 507                 return -1;
 508         return j;
 509 }
 510
 511 /*! \brief Avoid the silly dahdi_waitevent which ignores a bunch of events */
 512 static inline int dahdi_wait_event(int fd)
 513 {
 514         int i, j = 0;
 515         i = DAHDI_IOMUX_SIGEVENT;
 516         if (ioctl(fd, DAHDI_IOMUX, &i) == -1)
 517                 return -1;
 518         if (ioctl(fd, DAHDI_GETEVENT, &j) == -1)
 519                 return -1;
 520         return j;
 521 }
 522
 523 /*! Chunk size to read -- we use 20ms chunks to make things happy. */
 524 #define READ_SIZE 160
 525
 526 #define MASK_AVAIL              (1 << 0)        /*!< Channel available for PRI use */
 527 #define MASK_INUSE              (1 << 1)        /*!< Channel currently in use */
 528
 529 #define CALLWAITING_SILENT_SAMPLES              ((300 * 8) / READ_SIZE) /*!< 300 ms */
 530 #define CALLWAITING_REPEAT_SAMPLES              ((10000 * 8) / READ_SIZE) /*!< 10,000 ms */
 531 #define CALLWAITING_SUPPRESS_SAMPLES    ((100 * 8) / READ_SIZE) /*!< 100 ms */
 532 #define CIDCW_EXPIRE_SAMPLES                    ((500 * 8) / READ_SIZE) /*!< 500 ms */
 533 #define MIN_MS_SINCE_FLASH                              ((2000) )       /*!< 2000 ms */
 534 #define DEFAULT_RINGT                                   ((8000 * 8) / READ_SIZE) /*!< 8,000 ms */
 535 #define DEFAULT_DIALTONE_DETECT_TIMEOUT ((10000 * 8) / READ_SIZE) /*!< 10,000 ms */
 536
 537 struct dahdi_pvt;
 538
 539 /*!
 540  * \brief Configured ring timeout base.
 541  * \note Value computed from "ringtimeout" read in from chan_dahdi.conf if it exists.
 542  */
 543 static int ringt_base = DEFAULT_RINGT;
 544
 545 #if defined(HAVE_SS7)
 546
 547 struct dahdi_ss7 {
 548         struct sig_ss7_linkset ss7;
 549 };
 550
 551 static struct dahdi_ss7 linksets[NUM_SPANS];
 552
 553 static int cur_ss7type = -1;
 554 static int cur_linkset = -1;
 555 static int cur_pointcode = -1;
 556 static int cur_cicbeginswith = -1;
 557 static int cur_adjpointcode = -1;
 558 static int cur_networkindicator = -1;
 559 static int cur_defaultdpc = -1;
 560 #endif  /* defined(HAVE_SS7) */
 561
 562 #ifdef HAVE_OPENR2
 563 struct dahdi_mfcr2 {
 564         pthread_t r2master;                    /*!< Thread of master */
 565         openr2_context_t *protocol_context;    /*!< OpenR2 context handle */
 566         struct dahdi_pvt *pvts[SIG_MFCR2_MAX_CHANNELS];     /*!< Member channel pvt structs */
 567         int numchans;                          /*!< Number of channels in this R2 block */
 568         int monitored_count;                   /*!< Number of channels being monitored */
 569 };
 570
 571 struct dahdi_mfcr2_conf {
 572         openr2_variant_t variant;
 573         int mfback_timeout;
 574         int metering_pulse_timeout;
 575         int max_ani;
 576         int max_dnis;
 577 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
 578         int dtmf_time_on;
 579         int dtmf_time_off;
 580 #endif
 581 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
 582         int dtmf_end_timeout;
 583 #endif
 584         signed int get_ani_first:2;
 585 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
 586         signed int skip_category_request:2;
 587 #endif
 588         unsigned int call_files:1;
 589         unsigned int allow_collect_calls:1;
 590         unsigned int charge_calls:1;
 591         unsigned int accept_on_offer:1;
 592         unsigned int forced_release:1;
 593         unsigned int double_answer:1;
 594         signed int immediate_accept:2;
 595 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
 596         signed int dtmf_dialing:2;
 597         signed int dtmf_detection:2;
 598 #endif
 599         char logdir[OR2_MAX_PATH];
 600         char r2proto_file[OR2_MAX_PATH];
 601         openr2_log_level_t loglevel;
 602         openr2_calling_party_category_t category;
 603 };
 604
 605 /* malloc'd array of malloc'd r2links */
 606 static struct dahdi_mfcr2 **r2links;
 607 /* how many r2links have been malloc'd */
 608 static int r2links_count = 0;
 609
 610 #endif /* HAVE_OPENR2 */
 611
 612 #ifdef HAVE_PRI
 613
 614 struct dahdi_pri {
 615         int dchannels[SIG_PRI_NUM_DCHANS];              /*!< What channel are the dchannels on */
 616         int mastertrunkgroup;                                   /*!< What trunk group is our master */
 617         int prilogicalspan;                                             /*!< Logical span number within trunk group */
 618         struct sig_pri_span pri;
 619 };
 620
 621 static struct dahdi_pri pris[NUM_SPANS];
 622
 623 #if defined(HAVE_PRI_CCSS)
 624 /*! DAHDI PRI CCSS agent and monitor type name. */
 625 static const char dahdi_pri_cc_type[] = "DAHDI/PRI";
 626 #endif  /* defined(HAVE_PRI_CCSS) */
 627
 628 #else
 629 /*! Shut up the compiler */
 630 struct dahdi_pri;
 631 #endif
 632
 633 #define SUB_REAL        0                       /*!< Active call */
 634 #define SUB_CALLWAIT    1                       /*!< Call-Waiting call on hold */
 635 #define SUB_THREEWAY    2                       /*!< Three-way call */
 636
 637 /* Polarity states */
 638 #define POLARITY_IDLE   0
 639 #define POLARITY_REV    1
 640
 641
 642 struct distRingData {
 643         int ring[3];
 644         int range;
 645 };
 646 struct ringContextData {
 647         char contextData[AST_MAX_CONTEXT];
 648 };
 649 struct dahdi_distRings {
 650         struct distRingData ringnum[3];
 651         struct ringContextData ringContext[3];
 652 };
 653
 654 static const char * const subnames[] = {
 655         "Real",
 656         "Callwait",
 657         "Threeway"
 658 };
 659
 660 struct dahdi_subchannel {
 661         int dfd;
 662         struct ast_channel *owner;
 663         int chan;
 664         short buffer[AST_FRIENDLY_OFFSET/2 + READ_SIZE];
 665         struct ast_frame f;             /*!< One frame for each channel.  How did this ever work before? */
 666         unsigned int needringing:1;
 667         unsigned int needbusy:1;
 668         unsigned int needcongestion:1;
 669         unsigned int needanswer:1;
 670         unsigned int needflash:1;
 671         unsigned int needhold:1;
 672         unsigned int needunhold:1;
 673         unsigned int linear:1;
 674         unsigned int inthreeway:1;
 675         struct dahdi_confinfo curconf;
 676 };
 677
 678 #define CONF_USER_REAL          (1 << 0)
 679 #define CONF_USER_THIRDCALL     (1 << 1)
 680
 681 #define MAX_SLAVES      4
 682
 683 /* States for sending MWI message
 684  * First three states are required for send Ring Pulse Alert Signal
 685  */
 686 typedef enum {
 687         MWI_SEND_NULL = 0,
 688         MWI_SEND_SA,
 689         MWI_SEND_SA_WAIT,
 690         MWI_SEND_PAUSE,
 691         MWI_SEND_SPILL,
 692         MWI_SEND_CLEANUP,
 693         MWI_SEND_DONE,
 694 } mwisend_states;
 695
 696 struct mwisend_info {
 697         struct  timeval pause;
 698         mwisend_states  mwisend_current;
 699 };
 700
 701 /*! Specify the lists dahdi_pvt can be put in. */
 702 enum DAHDI_IFLIST {
 703         DAHDI_IFLIST_NONE,      /*!< The dahdi_pvt is not in any list. */
 704         DAHDI_IFLIST_MAIN,      /*!< The dahdi_pvt is in the main interface list */
 705 #if defined(HAVE_PRI)
 706         DAHDI_IFLIST_NO_B_CHAN, /*!< The dahdi_pvt is in a no B channel interface list */
 707 #endif  /* defined(HAVE_PRI) */
 708 };
 709
 710 struct dahdi_pvt {
 711         ast_mutex_t lock;                                       /*!< Channel private lock. */
 712         struct callerid_state *cs;
 713         struct ast_channel *owner;                      /*!< Our current active owner (if applicable) */
 714                                                         /*!< Up to three channels can be associated with this call */
 715
 716         struct dahdi_subchannel sub_unused;             /*!< Just a safety precaution */
 717         struct dahdi_subchannel subs[3];                        /*!< Sub-channels */
 718         struct dahdi_confinfo saveconf;                 /*!< Saved conference info */
 719
 720         struct dahdi_pvt *slaves[MAX_SLAVES];           /*!< Slave to us (follows our conferencing) */
 721         struct dahdi_pvt *master;                               /*!< Master to us (we follow their conferencing) */
 722         int inconference;                               /*!< If our real should be in the conference */
 723
 724         int bufsize;                /*!< Size of the buffers */
 725         int buf_no;                                     /*!< Number of buffers */
 726         int buf_policy;                         /*!< Buffer policy */
 727         int faxbuf_no;              /*!< Number of Fax buffers */
 728         int faxbuf_policy;          /*!< Fax buffer policy */
 729         int sig;                                        /*!< Signalling style */
 730         /*!
 731          * \brief Nonzero if the signaling type is sent over a radio.
 732          * \note Set to a couple of nonzero values but it is only tested like a boolean.
 733          */
 734         int radio;
 735         int outsigmod;                                  /*!< Outbound Signalling style (modifier) */
 736         int oprmode;                                    /*!< "Operator Services" mode */
 737         struct dahdi_pvt *oprpeer;                              /*!< "Operator Services" peer tech_pvt ptr */
 738         /*! \brief Amount of gain to increase during caller id */
 739         float cid_rxgain;
 740         /*! \brief Rx gain set by chan_dahdi.conf */
 741         float rxgain;
 742         /*! \brief Tx gain set by chan_dahdi.conf */
 743         float txgain;
 744
 745         float txdrc; /*!< Dynamic Range Compression factor. a number between 1 and 6ish */
 746         float rxdrc;
 747
 748         int tonezone;                                   /*!< tone zone for this chan, or -1 for default */
 749         enum DAHDI_IFLIST which_iflist; /*!< Which interface list is this structure listed? */
 750         struct dahdi_pvt *next;                         /*!< Next channel in list */
 751         struct dahdi_pvt *prev;                         /*!< Prev channel in list */
 752
 753         /* flags */
 754
 755         /*!
 756          * \brief TRUE if ADSI (Analog Display Services Interface) available
 757          * \note Set from the "adsi" value read in from chan_dahdi.conf
 758          */
 759         unsigned int adsi:1;
 760         /*!
 761          * \brief TRUE if we can use a polarity reversal to mark when an outgoing
 762          * call is answered by the remote party.
 763          * \note Set from the "answeronpolarityswitch" value read in from chan_dahdi.conf
 764          */
 765         unsigned int answeronpolarityswitch:1;
 766         /*!
 767          * \brief TRUE if busy detection is enabled.
 768          * (Listens for the beep-beep busy pattern.)
 769          * \note Set from the "busydetect" value read in from chan_dahdi.conf
 770          */
 771         unsigned int busydetect:1;
 772         /*!
 773          * \brief TRUE if call return is enabled.
 774          * (*69, if your dialplan doesn't catch this first)
 775          * \note Set from the "callreturn" value read in from chan_dahdi.conf
 776          */
 777         unsigned int callreturn:1;
 778         /*!
 779          * \brief TRUE if busy extensions will hear the call-waiting tone
 780          * and can use hook-flash to switch between callers.
 781          * \note Can be disabled by dialing *70.
 782          * \note Initialized with the "callwaiting" value read in from chan_dahdi.conf
 783          */
 784         unsigned int callwaiting:1;
 785         /*!
 786          * \brief TRUE if send caller ID for Call Waiting
 787          * \note Set from the "callwaitingcallerid" value read in from chan_dahdi.conf
 788          */
 789         unsigned int callwaitingcallerid:1;
 790         /*!
 791          * \brief TRUE if support for call forwarding enabled.
 792          * Dial *72 to enable call forwarding.
 793          * Dial *73 to disable call forwarding.
 794          * \note Set from the "cancallforward" value read in from chan_dahdi.conf
 795          */
 796         unsigned int cancallforward:1;
 797         /*!
 798          * \brief TRUE if support for call parking is enabled.
 799          * \note Set from the "canpark" value read in from chan_dahdi.conf
 800          */
 801         unsigned int canpark:1;
 802         /*! \brief TRUE if to wait for a DTMF digit to confirm answer */
 803         unsigned int confirmanswer:1;
 804         /*!
 805          * \brief TRUE if the channel is to be destroyed on hangup.
 806          * (Used by pseudo channels.)
 807          */
 808         unsigned int destroy:1;
 809         unsigned int didtdd:1;                          /*!< flag to say its done it once */
 810         /*! \brief TRUE if analog type line dialed no digits in Dial() */
 811         unsigned int dialednone:1;
 812         /*!
 813          * \brief TRUE if in the process of dialing digits or sending something.
 814          * \note This is used as a receive squelch for ISDN until connected.
 815          */
 816         unsigned int dialing:1;
 817         /*! \brief TRUE if the transfer capability of the call is digital. */
 818         unsigned int digital:1;
 819         /*! \brief TRUE if Do-Not-Disturb is enabled, present only for non sig_analog */
 820         unsigned int dnd:1;
 821         /*! \brief XXX BOOLEAN Purpose??? */
 822         unsigned int echobreak:1;
 823         /*!
 824          * \brief TRUE if echo cancellation enabled when bridged.
 825          * \note Initialized with the "echocancelwhenbridged" value read in from chan_dahdi.conf
 826          * \note Disabled if the echo canceller is not setup.
 827          */
 828         unsigned int echocanbridged:1;
 829         /*! \brief TRUE if echo cancellation is turned on. */
 830         unsigned int echocanon:1;
 831         /*! \brief TRUE if a fax tone has already been handled. */
 832         unsigned int faxhandled:1;
 833         /*! TRUE if dynamic faxbuffers are configured for use, default is OFF */
 834         unsigned int usefaxbuffers:1;
 835         /*! TRUE while buffer configuration override is in use */
 836         unsigned int bufferoverrideinuse:1;
 837         /*! \brief TRUE if over a radio and dahdi_read() has been called. */
 838         unsigned int firstradio:1;
 839         /*!
 840          * \brief TRUE if the call will be considered "hung up" on a polarity reversal.
 841          * \note Set from the "hanguponpolarityswitch" value read in from chan_dahdi.conf
 842          */
 843         unsigned int hanguponpolarityswitch:1;
 844         /*! \brief TRUE if DTMF detection needs to be done by hardware. */
 845         unsigned int hardwaredtmf:1;
 846         /*!
 847          * \brief TRUE if the outgoing caller ID is blocked/hidden.
 848          * \note Caller ID can be disabled by dialing *67.
 849          * \note Caller ID can be enabled by dialing *82.
 850          * \note Initialized with the "hidecallerid" value read in from chan_dahdi.conf
 851          */
 852         unsigned int hidecallerid:1;
 853         /*!
 854          * \brief TRUE if hide just the name not the number for legacy PBX use.
 855          * \note Only applies to PRI channels.
 856          * \note Set from the "hidecalleridname" value read in from chan_dahdi.conf
 857          */
 858         unsigned int hidecalleridname:1;
 859         /*! \brief TRUE if DTMF detection is disabled. */
 860         unsigned int ignoredtmf:1;
 861         /*!
 862          * \brief TRUE if the channel should be answered immediately
 863          * without attempting to gather any digits.
 864          * \note Set from the "immediate" value read in from chan_dahdi.conf
 865          */
 866         unsigned int immediate:1;
 867         /*! \brief TRUE if in an alarm condition. */
 868         unsigned int inalarm:1;
 869         /*! \brief TRUE if TDD in MATE mode */
 870         unsigned int mate:1;
 871         /*! \brief TRUE if we originated the call leg. */
 872         unsigned int outgoing:1;
 873         /* unsigned int overlapdial:1;                  unused and potentially confusing */
 874         /*!
 875          * \brief TRUE if busy extensions will hear the call-waiting tone
 876          * and can use hook-flash to switch between callers.
 877          * \note Set from the "callwaiting" value read in from chan_dahdi.conf
 878          */
 879         unsigned int permcallwaiting:1;
 880         /*!
 881          * \brief TRUE if the outgoing caller ID is blocked/restricted/hidden.
 882          * \note Set from the "hidecallerid" value read in from chan_dahdi.conf
 883          */
 884         unsigned int permhidecallerid:1;
 885         /*!
 886          * \brief TRUE if PRI congestion/busy indications are sent out-of-band.
 887          * \note Set from the "priindication" value read in from chan_dahdi.conf
 888          */
 889         unsigned int priindication_oob:1;
 890         /*!
 891          * \brief TRUE if PRI B channels are always exclusively selected.
 892          * \note Set from the "priexclusive" value read in from chan_dahdi.conf
 893          */
 894         unsigned int priexclusive:1;
 895         /*!
 896          * \brief TRUE if we will pulse dial.
 897          * \note Set from the "pulsedial" value read in from chan_dahdi.conf
 898          */
 899         unsigned int pulse:1;
 900         /*! \brief TRUE if a pulsed digit was detected. (Pulse dial phone detected) */
 901         unsigned int pulsedial:1;
 902         unsigned int restartpending:1;          /*!< flag to ensure counted only once for restart */
 903         /*!
 904          * \brief TRUE if caller ID is restricted.
 905          * \note Set but not used.  Should be deleted.  Redundant with permhidecallerid.
 906          * \note Set from the "restrictcid" value read in from chan_dahdi.conf
 907          */
 908         unsigned int restrictcid:1;
 909         /*!
 910          * \brief TRUE if three way calling is enabled
 911          * \note Set from the "threewaycalling" value read in from chan_dahdi.conf
 912          */
 913         unsigned int threewaycalling:1;
 914         /*!
 915          * \brief TRUE if call transfer is enabled
 916          * \note For FXS ports (either direct analog or over T1/E1):
 917          *   Support flash-hook call transfer
 918          * \note For digital ports using ISDN PRI protocols:
 919          *   Support switch-side transfer (called 2BCT, RLT or other names)
 920          * \note Set from the "transfer" value read in from chan_dahdi.conf
 921          */
 922         unsigned int transfer:1;
 923         /*!
 924          * \brief TRUE if caller ID is used on this channel.
 925          * \note PRI and SS7 spans will save caller ID from the networking peer.
 926          * \note FXS ports will generate the caller ID spill.
 927          * \note FXO ports will listen for the caller ID spill.
 928          * \note Set from the "usecallerid" value read in from chan_dahdi.conf
 929          */
 930         unsigned int use_callerid:1;
 931         /*!
 932          * \brief TRUE if we will use the calling presentation setting
 933          * from the Asterisk channel for outgoing calls.
 934          * \note Only applies to PRI and SS7 channels.
 935          * \note Set from the "usecallingpres" value read in from chan_dahdi.conf
 936          */
 937         unsigned int use_callingpres:1;
 938         /*!
 939          * \brief TRUE if distinctive rings are to be detected.
 940          * \note For FXO lines
 941          * \note Set indirectly from the "usedistinctiveringdetection" value read in from chan_dahdi.conf
 942          */
 943         unsigned int usedistinctiveringdetection:1;
 944         /*!
 945          * \brief TRUE if we should use the callerid from incoming call on dahdi transfer.
 946          * \note Set from the "useincomingcalleridondahditransfer" value read in from chan_dahdi.conf
 947          */
 948         unsigned int dahditrcallerid:1;
 949         /*!
 950          * \brief TRUE if allowed to flash-transfer to busy channels.
 951          * \note Set from the "transfertobusy" value read in from chan_dahdi.conf
 952          */
 953         unsigned int transfertobusy:1;
 954         /*!
 955          * \brief TRUE if the FXO port monitors for neon type MWI indications from the other end.
 956          * \note Set if the "mwimonitor" value read in contains "neon" from chan_dahdi.conf
 957          */
 958         unsigned int mwimonitor_neon:1;
 959         /*!
 960          * \brief TRUE if the FXO port monitors for fsk type MWI indications from the other end.
 961          * \note Set if the "mwimonitor" value read in contains "fsk" from chan_dahdi.conf
 962          */
 963         unsigned int mwimonitor_fsk:1;
 964         /*!
 965          * \brief TRUE if the FXO port monitors for rpas precursor to fsk MWI indications from the other end.
 966          * \note RPAS - Ring Pulse Alert Signal
 967          * \note Set if the "mwimonitor" value read in contains "rpas" from chan_dahdi.conf
 968          */
 969         unsigned int mwimonitor_rpas:1;
 970         /*! \brief TRUE if an MWI monitor thread is currently active */
 971         unsigned int mwimonitoractive:1;
 972         /*! \brief TRUE if a MWI message sending thread is active */
 973         unsigned int mwisendactive:1;
 974         /*!
 975          * \brief TRUE if channel is out of reset and ready
 976          * \note Set but not used.
 977          */
 978         unsigned int inservice:1;
 979         /*!
 980          * \brief TRUE if the channel is locally blocked.
 981          * \note Applies to SS7 and MFCR2 channels.
 982          */
 983         unsigned int locallyblocked:1;
 984         /*!
 985          * \brief TRUE if the channel is remotely blocked.
 986          * \note Applies to SS7 and MFCR2 channels.
 987          */
 988         unsigned int remotelyblocked:1;
 989         /*!
 990          * \brief TRUE if the channel alarms will be managed also as Span ones
 991          * \note Applies to all channels
 992          */
 993         unsigned int manages_span_alarms:1;
 994
 995 #if defined(HAVE_PRI)
 996         struct sig_pri_span *pri;
 997         int logicalspan;
 998 #endif
 999         /*!
1000          * \brief TRUE if SMDI (Simplified Message Desk Interface) is enabled
1001          * \note Set from the "usesmdi" value read in from chan_dahdi.conf
1002          */
1003         unsigned int use_smdi:1;
1004         struct mwisend_info mwisend_data;
1005         /*! \brief The SMDI interface to get SMDI messages from. */
1006         struct ast_smdi_interface *smdi_iface;
1007
1008         /*! \brief Distinctive Ring data */
1009         struct dahdi_distRings drings;
1010
1011         /*!
1012          * \brief The configured context for incoming calls.
1013          * \note The "context" string read in from chan_dahdi.conf
1014          */
1015         char context[AST_MAX_CONTEXT];
1016         /*!
1017          * \brief A description for the channel configuration
1018          * \note The "description" string read in from chan_dahdi.conf
1019          */
1020         char description[32];
1021         /*!
1022          * \brief Saved context string.
1023          */
1024         char defcontext[AST_MAX_CONTEXT];
1025         /*! \brief Extension to use in the dialplan. */
1026         char exten[AST_MAX_EXTENSION];
1027         /*!
1028          * \brief Language configured for calls.
1029          * \note The "language" string read in from chan_dahdi.conf
1030          */
1031         char language[MAX_LANGUAGE];
1032         /*!
1033          * \brief The configured music-on-hold class to use for calls.
1034          * \note The "musicclass" or "mohinterpret" or "musiconhold" string read in from chan_dahdi.conf
1035          */
1036         char mohinterpret[MAX_MUSICCLASS];
1037         /*!
1038          * \brief Suggested music-on-hold class for peer channel to use for calls.
1039          * \note The "mohsuggest" string read in from chan_dahdi.conf
1040          */
1041         char mohsuggest[MAX_MUSICCLASS];
1042         char parkinglot[AST_MAX_EXTENSION]; /*!< Parking lot for this channel */
1043 #if defined(HAVE_PRI) || defined(HAVE_SS7)
1044         /*! \brief Automatic Number Identification number (Alternate PRI caller ID number) */
1045         char cid_ani[AST_MAX_EXTENSION];
1046 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
1047         /*! \brief Automatic Number Identification code from PRI */
1048         int cid_ani2;
1049         /*! \brief Caller ID number from an incoming call. */
1050         char cid_num[AST_MAX_EXTENSION];
1051         /*!
1052          * \brief Caller ID tag from incoming call
1053          * \note the "cid_tag" string read in from chan_dahdi.conf
1054          */
1055         char cid_tag[AST_MAX_EXTENSION];
1056         /*! \brief Caller ID Q.931 TON/NPI field values.  Set by PRI. Zero otherwise. */
1057         int cid_ton;
1058         /*! \brief Caller ID name from an incoming call. */
1059         char cid_name[AST_MAX_EXTENSION];
1060         /*! \brief Caller ID subaddress from an incoming call. */
1061         char cid_subaddr[AST_MAX_EXTENSION];
1062         char *origcid_num;                              /*!< malloced original callerid */
1063         char *origcid_name;                             /*!< malloced original callerid */
1064         /*! \brief Call waiting number. */
1065         char callwait_num[AST_MAX_EXTENSION];
1066         /*! \brief Call waiting name. */
1067         char callwait_name[AST_MAX_EXTENSION];
1068         /*! \brief Redirecting Directory Number Information Service (RDNIS) number */
1069         char rdnis[AST_MAX_EXTENSION];
1070         /*! \brief Dialed Number Identifier */
1071         char dnid[AST_MAX_EXTENSION];
1072         /*!
1073          * \brief Bitmapped groups this belongs to.
1074          * \note The "group" bitmapped group string read in from chan_dahdi.conf
1075          */
1076         ast_group_t group;
1077         /*! \brief Default call PCM encoding format: DAHDI_LAW_ALAW or DAHDI_LAW_MULAW. */
1078         int law_default;
1079         /*! \brief Active PCM encoding format: DAHDI_LAW_ALAW or DAHDI_LAW_MULAW */
1080         int law;
1081         int confno;                                     /*!< Our conference */
1082         int confusers;                                  /*!< Who is using our conference */
1083         int propconfno;                                 /*!< Propagated conference number */
1084         /*!
1085          * \brief Bitmapped call groups this belongs to.
1086          * \note The "callgroup" bitmapped group string read in from chan_dahdi.conf
1087          */
1088         ast_group_t callgroup;
1089         /*!
1090          * \brief Bitmapped pickup groups this belongs to.
1091          * \note The "pickupgroup" bitmapped group string read in from chan_dahdi.conf
1092          */
1093         ast_group_t pickupgroup;
1094         /*!
1095          * \brief Channel variable list with associated values to set when a channel is created.
1096          * \note The "setvar" strings read in from chan_dahdi.conf
1097          */
1098         struct ast_variable *vars;
1099         int channel;                                    /*!< Channel Number */
1100         int span;                                       /*!< Span number */
1101         time_t guardtime;                               /*!< Must wait this much time before using for new call */
1102         int cid_signalling;                             /*!< CID signalling type bell202 or v23 */
1103         int cid_start;                                  /*!< CID start indicator, polarity or ring or DTMF without warning event */
1104         int dtmfcid_holdoff_state;              /*!< State indicator that allows for line to settle before checking for dtmf energy */
1105         struct timeval  dtmfcid_delay;  /*!< Time value used for allow line to settle */
1106         int callingpres;                                /*!< The value of calling presentation that we're going to use when placing a PRI call */
1107         int callwaitingrepeat;                          /*!< How many samples to wait before repeating call waiting */
1108         int cidcwexpire;                                /*!< When to stop waiting for CID/CW CAS response (In samples) */
1109         int cid_suppress_expire;                /*!< How many samples to suppress after a CID spill. */
1110         /*! \brief Analog caller ID waveform sample buffer */
1111         unsigned char *cidspill;
1112         /*! \brief Position in the cidspill buffer to send out next. */
1113         int cidpos;
1114         /*! \brief Length of the cidspill buffer containing samples. */
1115         int cidlen;
1116         /*! \brief Ring timeout timer?? */
1117         int ringt;
1118         /*!
1119          * \brief Ring timeout base.
1120          * \note Value computed indirectly from "ringtimeout" read in from chan_dahdi.conf
1121          */
1122         int ringt_base;
1123         /*!
1124          * \brief Number of most significant digits/characters to strip from the dialed number.
1125          * \note Feature is deprecated.  Use dialplan logic.
1126          * \note The characters are stripped before the PRI TON/NPI prefix
1127          * characters are processed.
1128          */
1129         int stripmsd;
1130         /*!
1131          * \brief TRUE if Call Waiting (CW) CPE Alert Signal (CAS) is being sent.
1132          * \note
1133          * After CAS is sent, the call waiting caller id will be sent if the phone
1134          * gives a positive reply.
1135          */
1136         int callwaitcas;
1137         /*! \brief Number of call waiting rings. */
1138         int callwaitrings;
1139         /*! \brief Echo cancel parameters. */
1140         struct {
1141                 struct dahdi_echocanparams head;
1142                 struct dahdi_echocanparam params[DAHDI_MAX_ECHOCANPARAMS];
1143         } echocancel;
1144         /*!
1145          * \brief Echo training time. 0 = disabled
1146          * \note Set from the "echotraining" value read in from chan_dahdi.conf
1147          */
1148         int echotraining;
1149         /*! \brief Filled with 'w'.  XXX Purpose?? */
1150         char echorest[20];
1151         /*!
1152          * \brief Number of times to see "busy" tone before hanging up.
1153          * \note Set from the "busycount" value read in from chan_dahdi.conf
1154          */
1155         int busycount;
1156         /*!
1157          * \brief Busy cadence pattern description.
1158          * \note Set from the "busypattern" value read from chan_dahdi.conf
1159          */
1160         struct ast_dsp_busy_pattern busy_cadence;
1161         /*!
1162          * \brief Bitmapped call progress detection flags. CALLPROGRESS_xxx values.
1163          * \note Bits set from the "callprogress" and "faxdetect" values read in from chan_dahdi.conf
1164          */
1165         int callprogress;
1166         /*!
1167          * \brief Number of milliseconds to wait for dialtone.
1168          * \note Set from the "waitfordialtone" value read in from chan_dahdi.conf
1169          */
1170         int waitfordialtone;
1171         /*!
1172          * \brief Number of frames to watch for dialtone in incoming calls
1173          * \note Set from the "dialtone_detect" value read in from chan_dahdi.conf
1174          */
1175         int dialtone_detect;
1176         int dialtone_scanning_time_elapsed;     /*!< Amount of audio scanned for dialtone, in frames */
1177         struct timeval waitingfordt;                    /*!< Time we started waiting for dialtone */
1178         struct timeval flashtime;                       /*!< Last flash-hook time */
1179         /*! \brief Opaque DSP configuration structure. */
1180         struct ast_dsp *dsp;
1181         /*! \brief DAHDI dial operation command struct for ioctl() call. */
1182         struct dahdi_dialoperation dop;
1183         int whichwink;                                  /*!< SIG_FEATDMF_TA Which wink are we on? */
1184         /*! \brief Second part of SIG_FEATDMF_TA wink operation. */
1185         char finaldial[64];
1186         char accountcode[AST_MAX_ACCOUNT_CODE];         /*!< Account code */
1187         int amaflags;                                   /*!< AMA Flags */
1188         struct tdd_state *tdd;                          /*!< TDD flag */
1189         /*! \brief Accumulated call forwarding number. */
1190         char call_forward[AST_MAX_EXTENSION];
1191         /*!
1192          * \brief Voice mailbox location.
1193          * \note Set from the "mailbox" string read in from chan_dahdi.conf
1194          */
1195         char mailbox[AST_MAX_EXTENSION];
1196         /*! \brief Opaque event subscription parameters for message waiting indication support. */
1197         struct ast_event_sub *mwi_event_sub;
1198         /*! \brief Delayed dialing for E911.  Overlap digits for ISDN. */
1199         char dialdest[256];
1200 #ifdef HAVE_DAHDI_LINEREVERSE_VMWI
1201         struct dahdi_vmwi_info mwisend_setting;                         /*!< Which VMWI methods to use */
1202         unsigned int mwisend_fsk: 1;            /*! Variable for enabling FSK MWI handling in chan_dahdi */
1203         unsigned int mwisend_rpas:1;            /*! Variable for enabling Ring Pulse Alert before MWI FSK Spill */
1204 #endif
1205         int distinctivering;                            /*!< Which distinctivering to use */
1206         int dtmfrelax;                                  /*!< whether to run in relaxed DTMF mode */
1207         /*! \brief Holding place for event injected from outside normal operation. */
1208         int fake_event;
1209         /*!
1210          * \brief Minimal time period (ms) between the answer polarity
1211          * switch and hangup polarity switch.
1212          */
1213         int polarityonanswerdelay;
1214         /*! \brief Start delay time if polarityonanswerdelay is nonzero. */
1215         struct timeval polaritydelaytv;
1216         /*!
1217          * \brief Send caller ID on FXS after this many rings. Set to 1 for US.
1218          * \note Set from the "sendcalleridafter" value read in from chan_dahdi.conf
1219          */
1220         int sendcalleridafter;
1221         /*! \brief Current line interface polarity. POLARITY_IDLE, POLARITY_REV */
1222         int polarity;
1223         /*! \brief DSP feature flags: DSP_FEATURE_xxx */
1224         int dsp_features;
1225 #if defined(HAVE_SS7)
1226         /*! \brief SS7 control parameters */
1227         struct sig_ss7_linkset *ss7;
1228 #endif  /* defined(HAVE_SS7) */
1229 #ifdef HAVE_OPENR2
1230         struct dahdi_mfcr2 *mfcr2;
1231         openr2_chan_t *r2chan;
1232         openr2_calling_party_category_t mfcr2_recvd_category;
1233         openr2_calling_party_category_t mfcr2_category;
1234         int mfcr2_dnis_index;
1235         int mfcr2_ani_index;
1236         int mfcr2call:1;
1237         int mfcr2_answer_pending:1;
1238         int mfcr2_charge_calls:1;
1239         int mfcr2_allow_collect_calls:1;
1240         int mfcr2_forced_release:1;
1241         int mfcr2_dnis_matched:1;
1242         int mfcr2_call_accepted:1;
1243         int mfcr2_accept_on_offer:1;
1244         int mfcr2_progress_sent:1;
1245 #endif
1246         /*! \brief DTMF digit in progress.  0 when no digit in progress. */
1247         char begindigit;
1248         /*! \brief TRUE if confrence is muted. */
1249         int muting;
1250         void *sig_pvt;
1251         struct ast_cc_config_params *cc_params;
1252         /* DAHDI channel names may differ greatly from the
1253          * string that was provided to an app such as Dial. We
1254          * need to save the original string passed to dahdi_request
1255          * for call completion purposes. This way, we can replicate
1256          * the original dialed string later.
1257          */
1258         char dialstring[AST_CHANNEL_NAME];
1259 };
1260
1261 #define DATA_EXPORT_DAHDI_PVT(MEMBER)                                   \
1262         MEMBER(dahdi_pvt, cid_rxgain, AST_DATA_DOUBLE)                  \
1263         MEMBER(dahdi_pvt, rxgain, AST_DATA_DOUBLE)                      \
1264         MEMBER(dahdi_pvt, txgain, AST_DATA_DOUBLE)                      \
1265         MEMBER(dahdi_pvt, txdrc, AST_DATA_DOUBLE)                       \
1266         MEMBER(dahdi_pvt, rxdrc, AST_DATA_DOUBLE)                       \
1267         MEMBER(dahdi_pvt, adsi, AST_DATA_BOOLEAN)                       \
1268         MEMBER(dahdi_pvt, answeronpolarityswitch, AST_DATA_BOOLEAN)     \
1269         MEMBER(dahdi_pvt, busydetect, AST_DATA_BOOLEAN)                 \
1270         MEMBER(dahdi_pvt, callreturn, AST_DATA_BOOLEAN)                 \
1271         MEMBER(dahdi_pvt, callwaiting, AST_DATA_BOOLEAN)                \
1272         MEMBER(dahdi_pvt, callwaitingcallerid, AST_DATA_BOOLEAN)        \
1273         MEMBER(dahdi_pvt, cancallforward, AST_DATA_BOOLEAN)             \
1274         MEMBER(dahdi_pvt, canpark, AST_DATA_BOOLEAN)                    \
1275         MEMBER(dahdi_pvt, confirmanswer, AST_DATA_BOOLEAN)              \
1276         MEMBER(dahdi_pvt, destroy, AST_DATA_BOOLEAN)                    \
1277         MEMBER(dahdi_pvt, didtdd, AST_DATA_BOOLEAN)                     \
1278         MEMBER(dahdi_pvt, dialednone, AST_DATA_BOOLEAN)                 \
1279         MEMBER(dahdi_pvt, dialing, AST_DATA_BOOLEAN)                    \
1280         MEMBER(dahdi_pvt, digital, AST_DATA_BOOLEAN)                    \
1281         MEMBER(dahdi_pvt, dnd, AST_DATA_BOOLEAN)                        \
1282         MEMBER(dahdi_pvt, echobreak, AST_DATA_BOOLEAN)                  \
1283         MEMBER(dahdi_pvt, echocanbridged, AST_DATA_BOOLEAN)             \
1284         MEMBER(dahdi_pvt, echocanon, AST_DATA_BOOLEAN)                  \
1285         MEMBER(dahdi_pvt, faxhandled, AST_DATA_BOOLEAN)                 \
1286         MEMBER(dahdi_pvt, usefaxbuffers, AST_DATA_BOOLEAN)              \
1287         MEMBER(dahdi_pvt, bufferoverrideinuse, AST_DATA_BOOLEAN)        \
1288         MEMBER(dahdi_pvt, firstradio, AST_DATA_BOOLEAN)                 \
1289         MEMBER(dahdi_pvt, hanguponpolarityswitch, AST_DATA_BOOLEAN)     \
1290         MEMBER(dahdi_pvt, hardwaredtmf, AST_DATA_BOOLEAN)               \
1291         MEMBER(dahdi_pvt, hidecallerid, AST_DATA_BOOLEAN)               \
1292         MEMBER(dahdi_pvt, hidecalleridname, AST_DATA_BOOLEAN)           \
1293         MEMBER(dahdi_pvt, ignoredtmf, AST_DATA_BOOLEAN)                 \
1294         MEMBER(dahdi_pvt, immediate, AST_DATA_BOOLEAN)                  \
1295         MEMBER(dahdi_pvt, inalarm, AST_DATA_BOOLEAN)                    \
1296         MEMBER(dahdi_pvt, mate, AST_DATA_BOOLEAN)                       \
1297         MEMBER(dahdi_pvt, outgoing, AST_DATA_BOOLEAN)                   \
1298         MEMBER(dahdi_pvt, permcallwaiting, AST_DATA_BOOLEAN)            \
1299         MEMBER(dahdi_pvt, priindication_oob, AST_DATA_BOOLEAN)          \
1300         MEMBER(dahdi_pvt, priexclusive, AST_DATA_BOOLEAN)               \
1301         MEMBER(dahdi_pvt, pulse, AST_DATA_BOOLEAN)                      \
1302         MEMBER(dahdi_pvt, pulsedial, AST_DATA_BOOLEAN)                  \
1303         MEMBER(dahdi_pvt, restartpending, AST_DATA_BOOLEAN)             \
1304         MEMBER(dahdi_pvt, restrictcid, AST_DATA_BOOLEAN)                \
1305         MEMBER(dahdi_pvt, threewaycalling, AST_DATA_BOOLEAN)            \
1306         MEMBER(dahdi_pvt, transfer, AST_DATA_BOOLEAN)                   \
1307         MEMBER(dahdi_pvt, use_callerid, AST_DATA_BOOLEAN)               \
1308         MEMBER(dahdi_pvt, use_callingpres, AST_DATA_BOOLEAN)            \
1309         MEMBER(dahdi_pvt, usedistinctiveringdetection, AST_DATA_BOOLEAN)        \
1310         MEMBER(dahdi_pvt, dahditrcallerid, AST_DATA_BOOLEAN)                    \
1311         MEMBER(dahdi_pvt, transfertobusy, AST_DATA_BOOLEAN)                     \
1312         MEMBER(dahdi_pvt, mwimonitor_neon, AST_DATA_BOOLEAN)                    \
1313         MEMBER(dahdi_pvt, mwimonitor_fsk, AST_DATA_BOOLEAN)                     \
1314         MEMBER(dahdi_pvt, mwimonitor_rpas, AST_DATA_BOOLEAN)                    \
1315         MEMBER(dahdi_pvt, mwimonitoractive, AST_DATA_BOOLEAN)                   \
1316         MEMBER(dahdi_pvt, mwisendactive, AST_DATA_BOOLEAN)                      \
1317         MEMBER(dahdi_pvt, inservice, AST_DATA_BOOLEAN)                          \
1318         MEMBER(dahdi_pvt, locallyblocked, AST_DATA_BOOLEAN)                     \
1319         MEMBER(dahdi_pvt, remotelyblocked, AST_DATA_BOOLEAN)                    \
1320         MEMBER(dahdi_pvt, manages_span_alarms, AST_DATA_BOOLEAN)                \
1321         MEMBER(dahdi_pvt, use_smdi, AST_DATA_BOOLEAN)                           \
1322         MEMBER(dahdi_pvt, context, AST_DATA_STRING)                             \
1323         MEMBER(dahdi_pvt, defcontext, AST_DATA_STRING)                          \
1324         MEMBER(dahdi_pvt, description, AST_DATA_STRING)                         \
1325         MEMBER(dahdi_pvt, exten, AST_DATA_STRING)                               \
1326         MEMBER(dahdi_pvt, language, AST_DATA_STRING)                            \
1327         MEMBER(dahdi_pvt, mohinterpret, AST_DATA_STRING)                        \
1328         MEMBER(dahdi_pvt, mohsuggest, AST_DATA_STRING)                          \
1329         MEMBER(dahdi_pvt, parkinglot, AST_DATA_STRING)
1330
1331 AST_DATA_STRUCTURE(dahdi_pvt, DATA_EXPORT_DAHDI_PVT);
1332
1333 static struct dahdi_pvt *iflist = NULL; /*!< Main interface list start */
1334 static struct dahdi_pvt *ifend = NULL;  /*!< Main interface list end */
1335
1336 #if defined(HAVE_PRI)
1337 static struct dahdi_parms_pseudo {
1338         int buf_no;                                     /*!< Number of buffers */
1339         int buf_policy;                         /*!< Buffer policy */
1340         int faxbuf_no;              /*!< Number of Fax buffers */
1341         int faxbuf_policy;          /*!< Fax buffer policy */
1342 } dahdi_pseudo_parms;
1343 #endif  /* defined(HAVE_PRI) */
1344
1345 /*! \brief Channel configuration from chan_dahdi.conf .
1346  * This struct is used for parsing the [channels] section of chan_dahdi.conf.
1347  * Generally there is a field here for every possible configuration item.
1348  *
1349  * The state of fields is saved along the parsing and whenever a 'channel'
1350  * statement is reached, the current dahdi_chan_conf is used to configure the
1351  * channel (struct dahdi_pvt)
1352  *
1353  * \see dahdi_chan_init for the default values.
1354  */
1355 struct dahdi_chan_conf {
1356         struct dahdi_pvt chan;
1357 #ifdef HAVE_PRI
1358         struct dahdi_pri pri;
1359 #endif
1360
1361 #if defined(HAVE_SS7)
1362         struct dahdi_ss7 ss7;
1363 #endif  /* defined(HAVE_SS7) */
1364
1365 #ifdef HAVE_OPENR2
1366         struct dahdi_mfcr2_conf mfcr2;
1367 #endif
1368         struct dahdi_params timing;
1369         int is_sig_auto; /*!< Use channel signalling from DAHDI? */
1370         /*! Continue configuration even if a channel is not there. */
1371         int ignore_failed_channels;
1372
1373         /*!
1374          * \brief The serial port to listen for SMDI data on
1375          * \note Set from the "smdiport" string read in from chan_dahdi.conf
1376          */
1377         char smdi_port[SMDI_MAX_FILENAME_LEN];
1378 };
1379
1380 /*! returns a new dahdi_chan_conf with default values (by-value) */
1381 static struct dahdi_chan_conf dahdi_chan_conf_default(void)
1382 {
1383         /* recall that if a field is not included here it is initialized
1384          * to 0 or equivalent
1385          */
1386         struct dahdi_chan_conf conf = {
1387 #ifdef HAVE_PRI
1388                 .pri.pri = {
1389                         .nsf = PRI_NSF_NONE,
1390                         .switchtype = PRI_SWITCH_NI2,
1391                         .dialplan = PRI_UNKNOWN + 1,
1392                         .localdialplan = PRI_NATIONAL_ISDN + 1,
1393                         .nodetype = PRI_CPE,
1394                         .qsigchannelmapping = DAHDI_CHAN_MAPPING_PHYSICAL,
1395
1396 #if defined(HAVE_PRI_CCSS)
1397                         .cc_ptmp_recall_mode = 1,/* specificRecall */
1398                         .cc_qsig_signaling_link_req = 1,/* retain */
1399                         .cc_qsig_signaling_link_rsp = 1,/* retain */
1400 #endif  /* defined(HAVE_PRI_CCSS) */
1401
1402                         .minunused = 2,
1403                         .idleext = "",
1404                         .idledial = "",
1405                         .internationalprefix = "",
1406                         .nationalprefix = "",
1407                         .localprefix = "",
1408                         .privateprefix = "",
1409                         .unknownprefix = "",
1410                         .colp_send = SIG_PRI_COLP_UPDATE,
1411                         .resetinterval = -1,
1412                 },
1413 #endif
1414 #if defined(HAVE_SS7)
1415                 .ss7.ss7 = {
1416                         .called_nai = SS7_NAI_NATIONAL,
1417                         .calling_nai = SS7_NAI_NATIONAL,
1418                         .internationalprefix = "",
1419                         .nationalprefix = "",
1420                         .subscriberprefix = "",
1421                         .unknownprefix = ""
1422                 },
1423 #endif  /* defined(HAVE_SS7) */
1424 #ifdef HAVE_OPENR2
1425                 .mfcr2 = {
1426                         .variant = OR2_VAR_ITU,
1427                         .mfback_timeout = -1,
1428                         .metering_pulse_timeout = -1,
1429                         .max_ani = 10,
1430                         .max_dnis = 4,
1431                         .get_ani_first = -1,
1432 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 1
1433                         .skip_category_request = -1,
1434 #endif
1435                         .call_files = 0,
1436                         .allow_collect_calls = 0,
1437                         .charge_calls = 1,
1438                         .accept_on_offer = 1,
1439                         .forced_release = 0,
1440                         .double_answer = 0,
1441                         .immediate_accept = -1,
1442 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 2
1443                         .dtmf_dialing = -1,
1444                         .dtmf_detection = -1,
1445                         .dtmf_time_on = OR2_DEFAULT_DTMF_ON,
1446                         .dtmf_time_off = OR2_DEFAULT_DTMF_OFF,
1447 #endif
1448 #if defined(OR2_LIB_INTERFACE) && OR2_LIB_INTERFACE > 3
1449                         .dtmf_end_timeout = -1,
1450 #endif
1451                         .logdir = "",
1452                         .r2proto_file = "",
1453                         .loglevel = OR2_LOG_ERROR | OR2_LOG_WARNING,
1454                         .category = OR2_CALLING_PARTY_CATEGORY_NATIONAL_SUBSCRIBER
1455                 },
1456 #endif
1457                 .chan = {
1458                         .context = "default",
1459                         .cid_num = "",
1460                         .cid_name = "",
1461                         .cid_tag = "",
1462                         .mohinterpret = "default",
1463                         .mohsuggest = "",
1464                         .parkinglot = "",
1465                         .transfertobusy = 1,
1466
1467                         .cid_signalling = CID_SIG_BELL,
1468                         .cid_start = CID_START_RING,
1469                         .dahditrcallerid = 0,
1470                         .use_callerid = 1,
1471                         .sig = -1,
1472                         .outsigmod = -1,
1473
1474                         .cid_rxgain = +5.0,
1475
1476                         .tonezone = -1,
1477
1478                         .echocancel.head.tap_length = 1,
1479
1480                         .busycount = 3,
1481
1482                         .accountcode = "",
1483
1484                         .mailbox = "",
1485
1486 #ifdef HAVE_DAHDI_LINEREVERSE_VMWI
1487                         .mwisend_fsk = 1,
1488 #endif
1489                         .polarityonanswerdelay = 600,
1490
1491                         .sendcalleridafter = DEFAULT_CIDRINGS,
1492
1493                         .buf_policy = DAHDI_POLICY_IMMEDIATE,
1494                         .buf_no = numbufs,
1495                         .usefaxbuffers = 0,
1496                         .cc_params = ast_cc_config_params_init(),
1497                 },
1498                 .timing = {
1499                         .prewinktime = -1,
1500                         .preflashtime = -1,
1501                         .winktime = -1,
1502                         .flashtime = -1,
1503                         .starttime = -1,
1504                         .rxwinktime = -1,
1505                         .rxflashtime = -1,
1506                         .debouncetime = -1
1507                 },
1508                 .is_sig_auto = 1,
1509                 .smdi_port = "/dev/ttyS0",
1510         };
1511
1512         return conf;
1513 }
1514
1515
1516 static struct ast_channel *dahdi_request(const char *type, struct ast_format_cap *cap, const struct ast_channel *requestor, const char *data, int *cause);
1517 static int dahdi_digit_begin(struct ast_channel *ast, char digit);
1518 static int dahdi_digit_end(struct ast_channel *ast, char digit, unsigned int duration);
1519 static int dahdi_sendtext(struct ast_channel *c, const char *text);
1520 static int dahdi_call(struct ast_channel *ast, const char *rdest, int timeout);
1521 static int dahdi_hangup(struct ast_channel *ast);
1522 static int dahdi_answer(struct ast_channel *ast);
1523 static struct ast_frame *dahdi_read(struct ast_channel *ast);
1524 static int dahdi_write(struct ast_channel *ast, struct ast_frame *frame);
1525 static struct ast_frame *dahdi_exception(struct ast_channel *ast);
1526 static int dahdi_indicate(struct ast_channel *chan, int condition, const void *data, size_t datalen);
1527 static int dahdi_fixup(struct ast_channel *oldchan, struct ast_channel *newchan);
1528 static int dahdi_setoption(struct ast_channel *chan, int option, void *data, int datalen);
1529 static int dahdi_queryoption(struct ast_channel *chan, int option, void *data, int *datalen);
1530 static int dahdi_func_read(struct ast_channel *chan, const char *function, char *data, char *buf, size_t len);
1531 static int dahdi_func_write(struct ast_channel *chan, const char *function, char *data, const char *value);
1532 static int dahdi_devicestate(const char *data);
1533 static int dahdi_cc_callback(struct ast_channel *inbound, const char *dest, ast_cc_callback_fn callback);
1534
1535 static struct ast_channel_tech dahdi_tech = {
1536         .type = "DAHDI",
1537         .description = tdesc,
1538         .requester = dahdi_request,
1539         .send_digit_begin = dahdi_digit_begin,
1540         .send_digit_end = dahdi_digit_end,
1541         .send_text = dahdi_sendtext,
1542         .call = dahdi_call,
1543         .hangup = dahdi_hangup,
1544         .answer = dahdi_answer,
1545         .read = dahdi_read,
1546         .write = dahdi_write,
1547         .bridge = dahdi_bridge,
1548         .exception = dahdi_exception,
1549         .indicate = dahdi_indicate,
1550         .fixup = dahdi_fixup,
1551         .setoption = dahdi_setoption,
1552         .queryoption = dahdi_queryoption,
1553         .func_channel_read = dahdi_func_read,
1554         .func_channel_write = dahdi_func_write,
1555         .devicestate = dahdi_devicestate,
1556         .cc_callback = dahdi_cc_callback,
1557 };
1558
1559 #define GET_CHANNEL(p) ((p)->channel)
1560
1561 #define SIG_PRI_LIB_HANDLE_CASES        \
1562         SIG_PRI:                                                \
1563         case SIG_BRI:                                   \
1564         case SIG_BRI_PTMP
1565
1566 /*!
1567  * \internal
1568  * \brief Determine if sig_pri handles the signaling.
1569  * \since 1.8
1570  *
1571  * \param signaling Signaling to determine if is for sig_pri.
1572  *
1573  * \return TRUE if the signaling is for sig_pri.
1574  */
1575 static inline int dahdi_sig_pri_lib_handles(int signaling)
1576 {
1577         int handles;
1578
1579         switch (signaling) {
1580         case SIG_PRI_LIB_HANDLE_CASES:
1581                 handles = 1;
1582                 break;
1583         default:
1584                 handles = 0;
1585                 break;
1586         }
1587
1588         return handles;
1589 }
1590
1591 static enum analog_sigtype dahdisig_to_analogsig(int sig)
1592 {
1593         switch (sig) {
1594         case SIG_FXOLS:
1595                 return ANALOG_SIG_FXOLS;
1596         case SIG_FXOGS:
1597                 return ANALOG_SIG_FXOGS;
1598         case SIG_FXOKS:
1599                 return ANALOG_SIG_FXOKS;
1600         case SIG_FXSLS:
1601                 return ANALOG_SIG_FXSLS;
1602         case SIG_FXSGS:
1603                 return ANALOG_SIG_FXSGS;
1604         case SIG_FXSKS:
1605                 return ANALOG_SIG_FXSKS;
1606         case SIG_EMWINK:
1607                 return ANALOG_SIG_EMWINK;
1608         case SIG_EM:
1609                 return ANALOG_SIG_EM;
1610         case SIG_EM_E1:
1611                 return ANALOG_SIG_EM_E1;
1612         case SIG_FEATD:
1613                 return ANALOG_SIG_FEATD;
1614         case SIG_FEATDMF:
1615                 return ANALOG_SIG_FEATDMF;
1616         case SIG_E911:
1617                 return SIG_E911;
1618         case SIG_FGC_CAMA:
1619                 return ANALOG_SIG_FGC_CAMA;
1620         case SIG_FGC_CAMAMF:
1621                 return ANALOG_SIG_FGC_CAMAMF;
1622         case SIG_FEATB:
1623                 return ANALOG_SIG_FEATB;
1624         case SIG_SFWINK:
1625                 return ANALOG_SIG_SFWINK;
1626         case SIG_SF:
1627                 return ANALOG_SIG_SF;
1628         case SIG_SF_FEATD:
1629                 return ANALOG_SIG_SF_FEATD;
1630         case SIG_SF_FEATDMF:
1631                 return ANALOG_SIG_SF_FEATDMF;
1632         case SIG_FEATDMF_TA:
1633                 return ANALOG_SIG_FEATDMF_TA;
1634         case SIG_SF_FEATB:
1635                 return ANALOG_SIG_FEATB;
1636         default:
1637                 return -1;
1638         }
1639 }
1640
1641
1642 static int analog_tone_to_dahditone(enum analog_tone tone)
1643 {
1644         switch (tone) {
1645         case ANALOG_TONE_RINGTONE:
1646                 return DAHDI_TONE_RINGTONE;
1647         case ANALOG_TONE_STUTTER:
1648                 return DAHDI_TONE_STUTTER;
1649         case ANALOG_TONE_CONGESTION:
1650                 return DAHDI_TONE_CONGESTION;
1651         case ANALOG_TONE_DIALTONE:
1652                 return DAHDI_TONE_DIALTONE;
1653         case ANALOG_TONE_DIALRECALL:
1654                 return DAHDI_TONE_DIALRECALL;
1655         case ANALOG_TONE_INFO:
1656                 return DAHDI_TONE_INFO;
1657         default:
1658                 return -1;
1659         }
1660 }
1661
1662 static int analogsub_to_dahdisub(enum analog_sub analogsub)
1663 {
1664         int index;
1665
1666         switch (analogsub) {
1667         case ANALOG_SUB_REAL:
1668                 index = SUB_REAL;
1669                 break;
1670         case ANALOG_SUB_CALLWAIT:
1671                 index = SUB_CALLWAIT;
1672                 break;
1673         case ANALOG_SUB_THREEWAY:
1674                 index = SUB_THREEWAY;
1675                 break;
1676         default:
1677                 ast_log(LOG_ERROR, "Unidentified sub!\n");
1678                 index = SUB_REAL;
1679         }
1680
1681         return index;
1682 }
1683
1684 static enum analog_event dahdievent_to_analogevent(int event);
1685 static int bump_gains(struct dahdi_pvt *p);
1686 static int dahdi_setlinear(int dfd, int linear);
1687
1688 static int my_start_cid_detect(void *pvt, int cid_signalling)
1689 {
1690         struct dahdi_pvt *p = pvt;
1691         int index = SUB_REAL;
1692         p->cs = callerid_new(cid_signalling);
1693         if (!p->cs) {
1694                 ast_log(LOG_ERROR, "Unable to alloc callerid\n");
1695                 return -1;
1696         }
1697         bump_gains(p);
1698         dahdi_setlinear(p->subs[index].dfd, 0);
1699
1700         return 0;
1701 }
1702
1703 static int my_stop_cid_detect(void *pvt)
1704 {
1705         struct dahdi_pvt *p = pvt;
1706         int index = SUB_REAL;
1707         if (p->cs)
1708                 callerid_free(p->cs);
1709         dahdi_setlinear(p->subs[index].dfd, p->subs[index].linear);
1710         return 0;
1711 }
1712
1713 static int my_get_callerid(void *pvt, char *namebuf, char *numbuf, enum analog_event *ev, size_t timeout)
1714 {
1715         struct dahdi_pvt *p = pvt;
1716         struct analog_pvt *analog_p = p->sig_pvt;
1717         struct pollfd poller;
1718         char *name, *num;
1719         int index = SUB_REAL;
1720         int res;
1721         unsigned char buf[256];
1722         int flags;
1723         struct ast_format tmpfmt;
1724
1725         poller.fd = p->subs[SUB_REAL].dfd;
1726         poller.events = POLLPRI | POLLIN;
1727         poller.revents = 0;
1728
1729         res = poll(&poller, 1, timeout);
1730
1731         if (poller.revents & POLLPRI) {
1732                 *ev = dahdievent_to_analogevent(dahdi_get_event(p->subs[SUB_REAL].dfd));
1733                 return 1;
1734         }
1735
1736         if (poller.revents & POLLIN) {
1737                 /*** NOTES ***/
1738                 /* Change API: remove cid_signalling from get_callerid, add a new start_cid_detect and stop_cid_detect function
1739                  * to enable slin mode and allocate cid detector. get_callerid should be able to be called any number of times until
1740                  * either a timeout occurs or CID is detected (returns 0). returning 1 should be event received, and -1 should be
1741                  * a failure and die, and returning 2 means no event was received. */
1742                 res = read(p->subs[index].dfd, buf, sizeof(buf));
1743                 if (res < 0) {
1744                         if (errno != ELAST) {
1745                                 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1746                                 callerid_free(p->cs);
1747                                 return -1;
1748                         }
1749                 }
1750
1751                 if (analog_p->ringt > 0) {
1752                         if (!(--analog_p->ringt)) {
1753                                 /* only return if we timeout from a ring event */
1754                                 return -1;
1755                         }
1756                 }
1757
1758                 if (p->cid_signalling == CID_SIG_V23_JP) {
1759                         res = callerid_feed_jp(p->cs, buf, res, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1760                 } else {
1761                         res = callerid_feed(p->cs, buf, res, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1762                 }
1763                 if (res < 0) {
1764                         /*
1765                          * The previous diagnostic message output likely
1766                          * explains why it failed.
1767                          */
1768                         ast_log(LOG_WARNING, "Failed to decode CallerID\n");
1769                         return -1;
1770                 }
1771
1772                 if (res == 1) {
1773                         callerid_get(p->cs, &name, &num, &flags);
1774                         if (name)
1775                                 ast_copy_string(namebuf, name, ANALOG_MAX_CID);
1776                         if (num)
1777                                 ast_copy_string(numbuf, num, ANALOG_MAX_CID);
1778
1779                         ast_debug(1, "CallerID number: %s, name: %s, flags=%d\n", num, name, flags);
1780                         return 0;
1781                 }
1782         }
1783
1784         *ev = ANALOG_EVENT_NONE;
1785         return 2;
1786 }
1787
1788 static const char *event2str(int event);
1789 static int restore_gains(struct dahdi_pvt *p);
1790
1791 static int my_distinctive_ring(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
1792 {
1793         unsigned char buf[256];
1794         int distMatches;
1795         int curRingData[RING_PATTERNS];
1796         int receivedRingT;
1797         int counter1;
1798         int counter;
1799         int i;
1800         int res;
1801         int checkaftercid = 0;
1802
1803         struct dahdi_pvt *p = pvt;
1804         struct analog_pvt *analog_p = p->sig_pvt;
1805
1806         if (ringdata == NULL) {
1807                 ringdata = curRingData;
1808         } else {
1809                 checkaftercid = 1;
1810         }
1811
1812         /* We must have a ring by now, so, if configured, lets try to listen for
1813          * distinctive ringing */
1814         if ((checkaftercid && distinctiveringaftercid) || !checkaftercid) {
1815                 /* Clear the current ring data array so we don't have old data in it. */
1816                 for (receivedRingT = 0; receivedRingT < RING_PATTERNS; receivedRingT++)
1817                         ringdata[receivedRingT] = 0;
1818                 receivedRingT = 0;
1819                 if (checkaftercid && distinctiveringaftercid)
1820                         ast_verb(3, "Detecting post-CID distinctive ring\n");
1821                 /* Check to see if context is what it should be, if not set to be. */
1822                 else if (strcmp(p->context,p->defcontext) != 0) {
1823                         ast_copy_string(p->context, p->defcontext, sizeof(p->context));
1824                         ast_channel_context_set(chan, p->defcontext);
1825                 }
1826
1827                 for (;;) {
1828                         i = DAHDI_IOMUX_READ | DAHDI_IOMUX_SIGEVENT;
1829                         if ((res = ioctl(p->subs[idx].dfd, DAHDI_IOMUX, &i))) {
1830                                 ast_log(LOG_WARNING, "I/O MUX failed: %s\n", strerror(errno));
1831                                 ast_hangup(chan);
1832                                 return 1;
1833                         }
1834                         if (i & DAHDI_IOMUX_SIGEVENT) {
1835                                 res = dahdi_get_event(p->subs[idx].dfd);
1836                                 if (res == DAHDI_EVENT_NOALARM) {
1837                                         p->inalarm = 0;
1838                                         analog_p->inalarm = 0;
1839                                 }
1840                                 ast_log(LOG_NOTICE, "Got event %d (%s)...\n", res, event2str(res));
1841                                 res = 0;
1842                                 /* Let us detect distinctive ring */
1843
1844                                 ringdata[receivedRingT] = analog_p->ringt;
1845
1846                                 if (analog_p->ringt < analog_p->ringt_base/2)
1847                                         break;
1848                                 /* Increment the ringT counter so we can match it against
1849                                    values in chan_dahdi.conf for distinctive ring */
1850                                 if (++receivedRingT == RING_PATTERNS)
1851                                         break;
1852                         } else if (i & DAHDI_IOMUX_READ) {
1853                                 res = read(p->subs[idx].dfd, buf, sizeof(buf));
1854                                 if (res < 0) {
1855                                         if (errno != ELAST) {
1856                                                 ast_log(LOG_WARNING, "read returned error: %s\n", strerror(errno));
1857                                                 ast_hangup(chan);
1858                                                 return 1;
1859                                         }
1860                                         break;
1861                                 }
1862                                 if (analog_p->ringt > 0) {
1863                                         if (!(--analog_p->ringt)) {
1864                                                 res = -1;
1865                                                 break;
1866                                         }
1867                                 }
1868                         }
1869                 }
1870         }
1871         if ((checkaftercid && usedistinctiveringdetection) || !checkaftercid) {
1872                 /* this only shows up if you have n of the dring patterns filled in */
1873                 ast_verb(3, "Detected ring pattern: %d,%d,%d\n",ringdata[0],ringdata[1],ringdata[2]);
1874                 for (counter = 0; counter < 3; counter++) {
1875                 /* Check to see if the rings we received match any of the ones in chan_dahdi.conf for this channel */
1876                         distMatches = 0;
1877                         /* this only shows up if you have n of the dring patterns filled in */
1878                         ast_verb(3, "Checking %d,%d,%d\n",
1879                                         p->drings.ringnum[counter].ring[0],
1880                                         p->drings.ringnum[counter].ring[1],
1881                                         p->drings.ringnum[counter].ring[2]);
1882                         for (counter1 = 0; counter1 < 3; counter1++) {
1883                                 ast_verb(3, "Ring pattern check range: %d\n", p->drings.ringnum[counter].range);
1884                                 if (p->drings.ringnum[counter].ring[counter1] == -1) {
1885                                         ast_verb(3, "Pattern ignore (-1) detected, so matching pattern %d regardless.\n",
1886                                         ringdata[counter1]);
1887                                         distMatches++;
1888                                 } else if (ringdata[counter1] <= (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range) &&
1889                                                                                 ringdata[counter1] >= (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range)) {
1890                                         ast_verb(3, "Ring pattern matched in range: %d to %d\n",
1891                                         (p->drings.ringnum[counter].ring[counter1] - p->drings.ringnum[counter].range),
1892                                         (p->drings.ringnum[counter].ring[counter1] + p->drings.ringnum[counter].range));
1893                                         distMatches++;
1894                                 }
1895                         }
1896
1897                         if (distMatches == 3) {
1898                                 /* The ring matches, set the context to whatever is for distinctive ring.. */
1899                                 ast_copy_string(p->context, S_OR(p->drings.ringContext[counter].contextData, p->defcontext), sizeof(p->context));
1900                                 ast_channel_context_set(chan, S_OR(p->drings.ringContext[counter].contextData, p->defcontext));
1901                                 ast_verb(3, "Distinctive Ring matched context %s\n",p->context);
1902                                 break;
1903                         }
1904                 }
1905         }
1906         /* Restore linear mode (if appropriate) for Caller*ID processing */
1907         dahdi_setlinear(p->subs[idx].dfd, p->subs[idx].linear);
1908         restore_gains(p);
1909
1910         return 0;
1911 }
1912
1913 static int my_stop_callwait(void *pvt)
1914 {
1915         struct dahdi_pvt *p = pvt;
1916         p->callwaitingrepeat = 0;
1917         p->cidcwexpire = 0;
1918         p->cid_suppress_expire = 0;
1919
1920         return 0;
1921 }
1922
1923 static int send_callerid(struct dahdi_pvt *p);
1924 static int save_conference(struct dahdi_pvt *p);
1925 static int restore_conference(struct dahdi_pvt *p);
1926
1927 static int my_callwait(void *pvt)
1928 {
1929         struct dahdi_pvt *p = pvt;
1930         struct ast_format tmpfmt;
1931         p->callwaitingrepeat = CALLWAITING_REPEAT_SAMPLES;
1932         if (p->cidspill) {
1933                 ast_log(LOG_WARNING, "Spill already exists?!?\n");
1934                 ast_free(p->cidspill);
1935         }
1936
1937         /*
1938          * SAS: Subscriber Alert Signal, 440Hz for 300ms
1939          * CAS: CPE Alert Signal, 2130Hz * 2750Hz sine waves
1940          */
1941         if (!(p->cidspill = ast_malloc(2400 /* SAS */ + 680 /* CAS */ + READ_SIZE * 4)))
1942                 return -1;
1943         save_conference(p);
1944         /* Silence */
1945         memset(p->cidspill, 0x7f, 2400 + 600 + READ_SIZE * 4);
1946         if (!p->callwaitrings && p->callwaitingcallerid) {
1947                 ast_gen_cas(p->cidspill, 1, 2400 + 680, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1948                 p->callwaitcas = 1;
1949                 p->cidlen = 2400 + 680 + READ_SIZE * 4;
1950         } else {
1951                 ast_gen_cas(p->cidspill, 1, 2400, ast_format_set(&tmpfmt, AST_LAW(p), 0));
1952                 p->callwaitcas = 0;
1953                 p->cidlen = 2400 + READ_SIZE * 4;
1954         }
1955         p->cidpos = 0;
1956         send_callerid(p);
1957
1958         return 0;
1959 }
1960
1961 static int my_send_callerid(void *pvt, int cwcid, struct ast_party_caller *caller)
1962 {
1963         struct dahdi_pvt *p = pvt;
1964         struct ast_format tmpfmt;
1965
1966         ast_debug(2, "Starting cid spill\n");
1967
1968         if (p->cidspill) {
1969                 ast_log(LOG_WARNING, "cidspill already exists??\n");
1970                 ast_free(p->cidspill);
1971         }
1972
1973         if ((p->cidspill = ast_malloc(MAX_CALLERID_SIZE))) {
1974                 if (cwcid == 0) {
1975                         p->cidlen = ast_callerid_generate(p->cidspill,
1976                                 caller->id.name.str,
1977                                 caller->id.number.str,
1978                                 ast_format_set(&tmpfmt, AST_LAW(p), 0));
1979                 } else {
1980                         ast_verb(3, "CPE supports Call Waiting Caller*ID.  Sending '%s/%s'\n",
1981                                 caller->id.name.str, caller->id.number.str);
1982                         p->callwaitcas = 0;
1983                         p->cidcwexpire = 0;
1984                         p->cidlen = ast_callerid_callwaiting_generate(p->cidspill,
1985                                 caller->id.name.str,
1986                                 caller->id.number.str,
1987                                 ast_format_set(&tmpfmt, AST_LAW(p), 0));
1988                         p->cidlen += READ_SIZE * 4;
1989                 }
1990                 p->cidpos = 0;
1991                 p->cid_suppress_expire = 0;
1992                 send_callerid(p);
1993         }
1994         return 0;
1995 }
1996
1997 static int my_dsp_reset_and_flush_digits(void *pvt)
1998 {
1999         struct dahdi_pvt *p = pvt;
2000         if (p->dsp)
2001                 ast_dsp_digitreset(p->dsp);
2002
2003         return 0;
2004 }
2005
2006 static int my_dsp_set_digitmode(void *pvt, enum analog_dsp_digitmode mode)
2007 {
2008         struct dahdi_pvt *p = pvt;
2009
2010         if (p->channel == CHAN_PSEUDO)
2011                 ast_log(LOG_ERROR, "You have assumed incorrectly sir!\n");
2012
2013         if (mode == ANALOG_DIGITMODE_DTMF) {
2014                 /* If we do hardware dtmf, no need for a DSP */
2015                 if (p->hardwaredtmf) {
2016                         if (p->dsp) {
2017                                 ast_dsp_free(p->dsp);
2018                                 p->dsp = NULL;
2019                         }
2020                         return 0;
2021                 }
2022
2023                 if (!p->dsp) {
2024                         p->dsp = ast_dsp_new();
2025                         if (!p->dsp) {
2026                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
2027                                 return -1;
2028                         }
2029                 }
2030
2031                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_DTMF | p->dtmfrelax);
2032         } else if (mode == ANALOG_DIGITMODE_MF) {
2033                 if (!p->dsp) {
2034                         p->dsp = ast_dsp_new();
2035                         if (!p->dsp) {
2036                                 ast_log(LOG_ERROR, "Unable to allocate DSP\n");
2037                                 return -1;
2038                         }
2039                 }
2040                 ast_dsp_set_digitmode(p->dsp, DSP_DIGITMODE_MF | p->dtmfrelax);
2041         }
2042         return 0;
2043 }
2044
2045 static int dahdi_wink(struct dahdi_pvt *p, int index);
2046
2047 static int my_wink(void *pvt, enum analog_sub sub)
2048 {
2049         struct dahdi_pvt *p = pvt;
2050         int index = analogsub_to_dahdisub(sub);
2051         if (index != SUB_REAL) {
2052                 ast_log(LOG_ERROR, "We used a sub other than SUB_REAL (incorrect assumption sir)\n");
2053         }
2054         return dahdi_wink(p, index);
2055 }
2056
2057 static void wakeup_sub(struct dahdi_pvt *p, int a);
2058
2059 static int reset_conf(struct dahdi_pvt *p);
2060
2061 static inline int dahdi_confmute(struct dahdi_pvt *p, int muted);
2062
2063 static void my_handle_dtmf(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
2064 {
2065         struct ast_frame *f = *dest;
2066         struct dahdi_pvt *p = pvt;
2067         int idx = analogsub_to_dahdisub(analog_index);
2068
2069         ast_debug(1, "%s DTMF digit: 0x%02X '%c' on %s\n",
2070                 f->frametype == AST_FRAME_DTMF_BEGIN ? "Begin" : "End",
2071                 f->subclass.integer, f->subclass.integer, ast_channel_name(ast));
2072
2073         if (f->subclass.integer == 'f') {
2074                 if (f->frametype == AST_FRAME_DTMF_END) {
2075                         /* Fax tone -- Handle and return NULL */
2076                         if ((p->callprogress & CALLPROGRESS_FAX) && !p->faxhandled) {
2077                                 /* If faxbuffers are configured, use them for the fax transmission */
2078                                 if (p->usefaxbuffers && !p->bufferoverrideinuse) {
2079                                         struct dahdi_bufferinfo bi = {
2080                                                 .txbufpolicy = p->faxbuf_policy,
2081                                                 .bufsize = p->bufsize,
2082                                                 .numbufs = p->faxbuf_no
2083                                         };
2084                                         int res;
2085
2086                                         if ((res = ioctl(p->subs[idx].dfd, DAHDI_SET_BUFINFO, &bi)) < 0) {
2087                                                 ast_log(LOG_WARNING, "Channel '%s' unable to set buffer policy, reason: %s\n", ast_channel_name(ast), strerror(errno));
2088                                         } else {
2089                                                 p->bufferoverrideinuse = 1;
2090                                         }
2091                                 }
2092                                 p->faxhandled = 1;
2093                                 if (p->dsp) {
2094                                         p->dsp_features &= ~DSP_FEATURE_FAX_DETECT;
2095                                         ast_dsp_set_features(p->dsp, p->dsp_features);
2096                                         ast_debug(1, "Disabling FAX tone detection on %s after tone received\n", ast_channel_name(ast));
2097                                 }
2098                                 if (strcmp(ast_channel_exten(ast), "fax")) {
2099                                         const char *target_context = S_OR(ast_channel_macrocontext(ast), ast_channel_context(ast));
2100
2101                                         /* We need to unlock 'ast' here because ast_exists_extension has the
2102                                          * potential to start autoservice on the channel. Such action is prone
2103                                          * to deadlock.
2104                                          */
2105                                         ast_mutex_unlock(&p->lock);
2106                                         ast_channel_unlock(ast);
2107                                         if (ast_exists_extension(ast, target_context, "fax", 1,
2108                                                 S_COR(ast_channel_caller(ast)->id.number.valid, ast_channel_caller(ast)->id.number.str, NULL))) {
2109                                                 ast_channel_lock(ast);
2110                                                 ast_mutex_lock(&p->lock);
2111                                                 ast_verb(3, "Redirecting %s to fax extension\n", ast_channel_name(ast));
2112                                                 /* Save the DID/DNIS when we transfer the fax call to a "fax" extension */
2113                                                 pbx_builtin_setvar_helper(ast, "FAXEXTEN", ast_channel_exten(ast));
2114                                                 if (ast_async_goto(ast, target_context, "fax", 1))
2115                                                         ast_log(LOG_WARNING, "Failed to async goto '%s' into fax of '%s'\n", ast_channel_name(ast), target_context);
2116                                         } else {
2117                                                 ast_channel_lock(ast);
2118                                                 ast_mutex_lock(&p->lock);
2119                                                 ast_log(LOG_NOTICE, "Fax detected, but no fax extension\n");
2120                                         }
2121                                 } else {
2122                                         ast_debug(1, "Already in a fax extension, not redirecting\n");
2123                                 }
2124                         } else {
2125                                 ast_debug(1, "Fax already handled\n");
2126                         }
2127                         dahdi_confmute(p, 0);
2128                 }
2129                 p->subs[idx].f.frametype = AST_FRAME_NULL;
2130                 p->subs[idx].f.subclass.integer = 0;
2131                 *dest = &p->subs[idx].f;
2132         }
2133 }
2134
2135 static void my_lock_private(void *pvt)
2136 {
2137         struct dahdi_pvt *p = pvt;
2138         ast_mutex_lock(&p->lock);
2139 }
2140
2141 static void my_unlock_private(void *pvt)
2142 {
2143         struct dahdi_pvt *p = pvt;
2144         ast_mutex_unlock(&p->lock);
2145 }
2146
2147 static void my_deadlock_avoidance_private(void *pvt)
2148 {
2149         struct dahdi_pvt *p = pvt;
2150
2151         DEADLOCK_AVOIDANCE(&p->lock);
2152 }
2153
2154 /*!
2155  * \internal
2156  * \brief Post an AMI DAHDI channel association event.
2157  * \since 1.8
2158  *
2159  * \param p DAHDI private pointer
2160  * \param chan Channel associated with the private pointer
2161  *
2162  * \return Nothing
2163  */
2164 static void dahdi_ami_channel_event(struct dahdi_pvt *p, struct ast_channel *chan)
2165 {
2166         char ch_name[20];
2167
2168         if (p->channel < CHAN_PSEUDO) {
2169                 /* No B channel */
2170                 snprintf(ch_name, sizeof(ch_name), "no-media (%d)", p->channel);
2171         } else if (p->channel == CHAN_PSEUDO) {
2172                 /* Pseudo channel */
2173                 strcpy(ch_name, "pseudo");
2174         } else {
2175                 /* Real channel */
2176                 snprintf(ch_name, sizeof(ch_name), "%d", p->channel);
2177         }
2178         ast_manager_event(chan, EVENT_FLAG_CALL, "DAHDIChannel",
2179                 "Channel: %s\r\n"
2180                 "Uniqueid: %s\r\n"
2181                 "DAHDISpan: %d\r\n"
2182                 "DAHDIChannel: %s\r\n",
2183                 ast_channel_name(chan),
2184                 ast_channel_uniqueid(chan),
2185                 p->span,
2186                 ch_name);
2187 }
2188
2189 #ifdef HAVE_PRI
2190 /*!
2191  * \internal
2192  * \brief Post an AMI DAHDI channel association event.
2193  * \since 1.8
2194  *
2195  * \param pvt DAHDI private pointer
2196  * \param chan Channel associated with the private pointer
2197  *
2198  * \return Nothing
2199  */
2200 static void my_ami_channel_event(void *pvt, struct ast_channel *chan)
2201 {
2202         struct dahdi_pvt *p = pvt;
2203
2204         dahdi_ami_channel_event(p, chan);
2205 }
2206 #endif
2207
2208 /* linear_mode = 0 - turn linear mode off, >0 - turn linear mode on
2209 *       returns the last value of the linear setting
2210 */
2211 static int my_set_linear_mode(void *pvt, enum analog_sub sub, int linear_mode)
2212 {
2213         struct dahdi_pvt *p = pvt;
2214         int oldval;
2215         int idx = analogsub_to_dahdisub(sub);
2216
2217         dahdi_setlinear(p->subs[idx].dfd, linear_mode);
2218         oldval = p->subs[idx].linear;
2219         p->subs[idx].linear = linear_mode ? 1 : 0;
2220         return oldval;
2221 }
2222
2223 static void my_set_inthreeway(void *pvt, enum analog_sub sub, int inthreeway)
2224 {
2225         struct dahdi_pvt *p = pvt;
2226         int idx = analogsub_to_dahdisub(sub);
2227
2228         p->subs[idx].inthreeway = inthreeway;
2229 }
2230
2231 static int get_alarms(struct dahdi_pvt *p);
2232 static void handle_alarms(struct dahdi_pvt *p, int alms);
2233 static void my_get_and_handle_alarms(void *pvt)
2234 {
2235         int res;
2236         struct dahdi_pvt *p = pvt;
2237
2238         res = get_alarms(p);
2239         handle_alarms(p, res);
2240 }
2241
2242 static void *my_get_sigpvt_bridged_channel(struct ast_channel *chan)
2243 {
2244         struct dahdi_pvt *p = ast_channel_tech_pvt(ast_bridged_channel(chan));
2245         if (p)
2246                 return p->sig_pvt;
2247         else
2248                 return NULL;
2249 }
2250
2251 static int my_get_sub_fd(void *pvt, enum analog_sub sub)
2252 {
2253         struct dahdi_pvt *p = pvt;
2254         int dahdi_sub = analogsub_to_dahdisub(sub);
2255         return p->subs[dahdi_sub].dfd;
2256 }
2257
2258 static void my_set_cadence(void *pvt, int *cid_rings, struct ast_channel *ast)
2259 {
2260         struct dahdi_pvt *p = pvt;
2261
2262         /* Choose proper cadence */
2263         if ((p->distinctivering > 0) && (p->distinctivering <= num_cadence)) {
2264                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, &cadences[p->distinctivering - 1]))
2265                         ast_log(LOG_WARNING, "Unable to set distinctive ring cadence %d on '%s': %s\n", p->distinctivering, ast_channel_name(ast), strerror(errno));
2266                 *cid_rings = cidrings[p->distinctivering - 1];
2267         } else {
2268                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETCADENCE, NULL))
2269                         ast_log(LOG_WARNING, "Unable to reset default ring on '%s': %s\n", ast_channel_name(ast), strerror(errno));
2270                 *cid_rings = p->sendcalleridafter;
2271         }
2272 }
2273
2274 static void my_set_alarm(void *pvt, int in_alarm)
2275 {
2276         struct dahdi_pvt *p = pvt;
2277
2278         p->inalarm = in_alarm;
2279 }
2280
2281 static void my_set_dialing(void *pvt, int is_dialing)
2282 {
2283         struct dahdi_pvt *p = pvt;
2284
2285         p->dialing = is_dialing;
2286 }
2287
2288 static void my_set_outgoing(void *pvt, int is_outgoing)
2289 {
2290         struct dahdi_pvt *p = pvt;
2291
2292         p->outgoing = is_outgoing;
2293 }
2294
2295 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2296 static void my_set_digital(void *pvt, int is_digital)
2297 {
2298         struct dahdi_pvt *p = pvt;
2299
2300         p->digital = is_digital;
2301 }
2302 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2303
2304 #if defined(HAVE_SS7)
2305 static void my_set_inservice(void *pvt, int is_inservice)
2306 {
2307         struct dahdi_pvt *p = pvt;
2308
2309         p->inservice = is_inservice;
2310 }
2311 #endif  /* defined(HAVE_SS7) */
2312
2313 #if defined(HAVE_SS7)
2314 static void my_set_locallyblocked(void *pvt, int is_blocked)
2315 {
2316         struct dahdi_pvt *p = pvt;
2317
2318         p->locallyblocked = is_blocked;
2319 }
2320 #endif  /* defined(HAVE_SS7) */
2321
2322 #if defined(HAVE_SS7)
2323 static void my_set_remotelyblocked(void *pvt, int is_blocked)
2324 {
2325         struct dahdi_pvt *p = pvt;
2326
2327         p->remotelyblocked = is_blocked;
2328 }
2329 #endif  /* defined(HAVE_SS7) */
2330
2331 static void my_set_ringtimeout(void *pvt, int ringt)
2332 {
2333         struct dahdi_pvt *p = pvt;
2334         p->ringt = ringt;
2335 }
2336
2337 static void my_set_waitingfordt(void *pvt, struct ast_channel *ast)
2338 {
2339         struct dahdi_pvt *p = pvt;
2340
2341         if (p->waitfordialtone && CANPROGRESSDETECT(p) && p->dsp) {
2342                 ast_debug(1, "Defer dialing for %dms or dialtone\n", p->waitfordialtone);
2343                 gettimeofday(&p->waitingfordt, NULL);
2344                 ast_setstate(ast, AST_STATE_OFFHOOK);
2345         }
2346 }
2347
2348 static int my_check_waitingfordt(void *pvt)
2349 {
2350         struct dahdi_pvt *p = pvt;
2351
2352         if (p->waitingfordt.tv_usec) {
2353                 return 1;
2354         }
2355
2356         return 0;
2357 }
2358
2359 static void my_set_confirmanswer(void *pvt, int flag)
2360 {
2361         struct dahdi_pvt *p = pvt;
2362         p->confirmanswer = flag;
2363 }
2364
2365 static int my_check_confirmanswer(void *pvt)
2366 {
2367         struct dahdi_pvt *p = pvt;
2368         if (p->confirmanswer) {
2369                 return 1;
2370         }
2371
2372         return 0;
2373 }
2374
2375 static void my_set_callwaiting(void *pvt, int callwaiting_enable)
2376 {
2377         struct dahdi_pvt *p = pvt;
2378
2379         p->callwaiting = callwaiting_enable;
2380 }
2381
2382 static void my_cancel_cidspill(void *pvt)
2383 {
2384         struct dahdi_pvt *p = pvt;
2385
2386         ast_free(p->cidspill);
2387         p->cidspill = NULL;
2388         restore_conference(p);
2389 }
2390
2391 static int my_confmute(void *pvt, int mute)
2392 {
2393         struct dahdi_pvt *p = pvt;
2394         return dahdi_confmute(p, mute);
2395 }
2396
2397 static void my_set_pulsedial(void *pvt, int flag)
2398 {
2399         struct dahdi_pvt *p = pvt;
2400         p->pulsedial = flag;
2401 }
2402
2403 static void my_set_new_owner(void *pvt, struct ast_channel *new_owner)
2404 {
2405         struct dahdi_pvt *p = pvt;
2406
2407         p->owner = new_owner;
2408 }
2409
2410 static const char *my_get_orig_dialstring(void *pvt)
2411 {
2412         struct dahdi_pvt *p = pvt;
2413
2414         return p->dialstring;
2415 }
2416
2417 static void my_increase_ss_count(void)
2418 {
2419         ast_mutex_lock(&ss_thread_lock);
2420         ss_thread_count++;
2421         ast_mutex_unlock(&ss_thread_lock);
2422 }
2423
2424 static void my_decrease_ss_count(void)
2425 {
2426         ast_mutex_lock(&ss_thread_lock);
2427         ss_thread_count--;
2428         ast_cond_signal(&ss_thread_complete);
2429         ast_mutex_unlock(&ss_thread_lock);
2430 }
2431
2432 static void my_all_subchannels_hungup(void *pvt)
2433 {
2434         struct dahdi_pvt *p = pvt;
2435         int res, law;
2436
2437         p->faxhandled = 0;
2438         p->didtdd = 0;
2439
2440         if (p->dsp) {
2441                 ast_dsp_free(p->dsp);
2442                 p->dsp = NULL;
2443         }
2444
2445         p->law = p->law_default;
2446         law = p->law_default;
2447         res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETLAW, &law);
2448         if (res < 0)
2449                 ast_log(LOG_WARNING, "Unable to set law on channel %d to default: %s\n", p->channel, strerror(errno));
2450
2451         dahdi_setlinear(p->subs[SUB_REAL].dfd, 0);
2452
2453 #if 1
2454         {
2455         int i;
2456         p->owner = NULL;
2457         /* Cleanup owners here */
2458         for (i = 0; i < 3; i++) {
2459                 p->subs[i].owner = NULL;
2460         }
2461         }
2462 #endif
2463
2464         reset_conf(p);
2465         if (num_restart_pending == 0) {
2466                 restart_monitor();
2467         }
2468 }
2469
2470 static int conf_del(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index);
2471
2472 static int my_conf_del(void *pvt, enum analog_sub sub)
2473 {
2474         struct dahdi_pvt *p = pvt;
2475         int x = analogsub_to_dahdisub(sub);
2476
2477         return conf_del(p, &p->subs[x], x);
2478 }
2479
2480 static int conf_add(struct dahdi_pvt *p, struct dahdi_subchannel *c, int index, int slavechannel);
2481
2482 static int my_conf_add(void *pvt, enum analog_sub sub)
2483 {
2484         struct dahdi_pvt *p = pvt;
2485         int x = analogsub_to_dahdisub(sub);
2486
2487         return conf_add(p, &p->subs[x], x, 0);
2488 }
2489
2490 static int isslavenative(struct dahdi_pvt *p, struct dahdi_pvt **out);
2491
2492 static int my_complete_conference_update(void *pvt, int needconference)
2493 {
2494         struct dahdi_pvt *p = pvt;
2495         int needconf = needconference;
2496         int x;
2497         int useslavenative;
2498         struct dahdi_pvt *slave = NULL;
2499
2500         useslavenative = isslavenative(p, &slave);
2501
2502         /* If we have a slave, add him to our conference now. or DAX
2503            if this is slave native */
2504         for (x = 0; x < MAX_SLAVES; x++) {
2505                 if (p->slaves[x]) {
2506                         if (useslavenative)
2507                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p));
2508                         else {
2509                                 conf_add(p, &p->slaves[x]->subs[SUB_REAL], SUB_REAL, 0);
2510                                 needconf++;
2511                         }
2512                 }
2513         }
2514         /* If we're supposed to be in there, do so now */
2515         if (p->inconference && !p->subs[SUB_REAL].inthreeway) {
2516                 if (useslavenative)
2517                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(slave));
2518                 else {
2519                         conf_add(p, &p->subs[SUB_REAL], SUB_REAL, 0);
2520                         needconf++;
2521                 }
2522         }
2523         /* If we have a master, add ourselves to his conference */
2524         if (p->master) {
2525                 if (isslavenative(p->master, NULL)) {
2526                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, GET_CHANNEL(p->master));
2527                 } else {
2528                         conf_add(p->master, &p->subs[SUB_REAL], SUB_REAL, 0);
2529                 }
2530         }
2531         if (!needconf) {
2532                 /* Nobody is left (or should be left) in our conference.
2533                    Kill it. */
2534                 p->confno = -1;
2535         }
2536
2537         return 0;
2538 }
2539
2540 static int check_for_conference(struct dahdi_pvt *p);
2541
2542 static int my_check_for_conference(void *pvt)
2543 {
2544         struct dahdi_pvt *p = pvt;
2545         return check_for_conference(p);
2546 }
2547
2548 static void my_swap_subchannels(void *pvt, enum analog_sub a, struct ast_channel *ast_a,  enum analog_sub b, struct ast_channel *ast_b)
2549 {
2550         struct dahdi_pvt *p = pvt;
2551         int da, db;
2552         int tchan;
2553         int tinthreeway;
2554
2555         da = analogsub_to_dahdisub(a);
2556         db = analogsub_to_dahdisub(b);
2557
2558         tchan = p->subs[da].chan;
2559         p->subs[da].chan = p->subs[db].chan;
2560         p->subs[db].chan = tchan;
2561
2562         tinthreeway = p->subs[da].inthreeway;
2563         p->subs[da].inthreeway = p->subs[db].inthreeway;
2564         p->subs[db].inthreeway = tinthreeway;
2565
2566         p->subs[da].owner = ast_a;
2567         p->subs[db].owner = ast_b;
2568
2569         if (ast_a)
2570                 ast_channel_set_fd(ast_a, 0, p->subs[da].dfd);
2571         if (ast_b)
2572                 ast_channel_set_fd(ast_b, 0, p->subs[db].dfd);
2573
2574         wakeup_sub(p, a);
2575         wakeup_sub(p, b);
2576
2577         return;
2578 }
2579
2580 static struct ast_channel *dahdi_new(struct dahdi_pvt *i, int state, int startpbx, int idx, int law, const char *linkedid);
2581
2582 static struct ast_channel *my_new_analog_ast_channel(void *pvt, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
2583 {
2584         struct dahdi_pvt *p = pvt;
2585         int dsub = analogsub_to_dahdisub(sub);
2586
2587         return dahdi_new(p, state, startpbx, dsub, 0, requestor ? ast_channel_linkedid(requestor) : "");
2588 }
2589
2590 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2591 static int dahdi_setlaw(int dfd, int law)
2592 {
2593         int res;
2594         res = ioctl(dfd, DAHDI_SETLAW, &law);
2595         if (res)
2596                 return res;
2597         return 0;
2598 }
2599 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2600
2601 #if defined(HAVE_PRI)
2602 static struct ast_channel *my_new_pri_ast_channel(void *pvt, int state, enum sig_pri_law law, char *exten, const struct ast_channel *requestor)
2603 {
2604         struct dahdi_pvt *p = pvt;
2605         int audio;
2606         int newlaw = -1;
2607
2608         switch (p->sig) {
2609         case SIG_PRI_LIB_HANDLE_CASES:
2610                 if (((struct sig_pri_chan *) p->sig_pvt)->no_b_channel) {
2611                         /* PRI nobch pseudo channel.  Does not handle ioctl(DAHDI_AUDIOMODE) */
2612                         break;
2613                 }
2614                 /* Fall through */
2615         default:
2616                 /* Set to audio mode at this point */
2617                 audio = 1;
2618                 if (ioctl(p->subs[SUB_REAL].dfd, DAHDI_AUDIOMODE, &audio) == -1) {
2619                         ast_log(LOG_WARNING, "Unable to set audio mode on channel %d to %d: %s\n",
2620                                 p->channel, audio, strerror(errno));
2621                 }
2622                 break;
2623         }
2624
2625         if (law != SIG_PRI_DEFLAW) {
2626                 dahdi_setlaw(p->subs[SUB_REAL].dfd, (law == SIG_PRI_ULAW) ? DAHDI_LAW_MULAW : DAHDI_LAW_ALAW);
2627         }
2628
2629         ast_copy_string(p->exten, exten, sizeof(p->exten));
2630
2631         switch (law) {
2632                 case SIG_PRI_DEFLAW:
2633                         newlaw = 0;
2634                         break;
2635                 case SIG_PRI_ALAW:
2636                         newlaw = DAHDI_LAW_ALAW;
2637                         break;
2638                 case SIG_PRI_ULAW:
2639                         newlaw = DAHDI_LAW_MULAW;
2640                         break;
2641         }
2642         return dahdi_new(p, state, 0, SUB_REAL, newlaw, requestor ? ast_channel_linkedid(requestor) : "");
2643 }
2644 #endif  /* defined(HAVE_PRI) */
2645
2646 static int set_actual_gain(int fd, float rxgain, float txgain, float rxdrc, float txdrc, int law);
2647
2648 #if defined(HAVE_PRI) || defined(HAVE_SS7)
2649 /*!
2650  * \internal
2651  * \brief Open the PRI/SS7 channel media path.
2652  * \since 1.8
2653  *
2654  * \param p Channel private control structure.
2655  *
2656  * \return Nothing
2657  */
2658 static void my_pri_ss7_open_media(void *p)
2659 {
2660         struct dahdi_pvt *pvt = p;
2661         int res;
2662         int dfd;
2663         int set_val;
2664
2665         dfd = pvt->subs[SUB_REAL].dfd;
2666
2667         /* Open the media path. */
2668         set_val = 1;
2669         res = ioctl(dfd, DAHDI_AUDIOMODE, &set_val);
2670         if (res < 0) {
2671                 ast_log(LOG_WARNING, "Unable to enable audio mode on channel %d (%s)\n",
2672                         pvt->channel, strerror(errno));
2673         }
2674
2675         /* Set correct companding law for this call. */
2676         res = dahdi_setlaw(dfd, pvt->law);
2677         if (res < 0) {
2678                 ast_log(LOG_WARNING, "Unable to set law on channel %d\n", pvt->channel);
2679         }
2680
2681         /* Set correct gain for this call. */
2682         if (pvt->digital) {
2683                 res = set_actual_gain(dfd, 0, 0, pvt->rxdrc, pvt->txdrc, pvt->law);
2684         } else {
2685                 res = set_actual_gain(dfd, pvt->rxgain, pvt->txgain, pvt->rxdrc, pvt->txdrc,
2686                         pvt->law);
2687         }
2688         if (res < 0) {
2689                 ast_log(LOG_WARNING, "Unable to set gains on channel %d\n", pvt->channel);
2690         }
2691
2692         if (pvt->dsp_features && pvt->dsp) {
2693                 ast_dsp_set_features(pvt->dsp, pvt->dsp_features);
2694                 pvt->dsp_features = 0;
2695         }
2696 }
2697 #endif  /* defined(HAVE_PRI) || defined(HAVE_SS7) */
2698
2699 #if defined(HAVE_PRI)
2700 /*!
2701  * \internal
2702  * \brief Ask DAHDI to dial the given dial string.
2703  * \since 1.8.11
2704  *
2705  * \param p Channel private control structure.
2706  * \param dial_string String to pass to DAHDI to dial.
2707  *
2708  * \note The channel private lock needs to be held when calling.
2709  *
2710  * \return Nothing
2711  */
2712 static void my_pri_dial_digits(void *p, const char *dial_string)
2713 {
2714         struct dahdi_dialoperation zo = {
2715                 .op = DAHDI_DIAL_OP_APPEND,
2716         };
2717         struct dahdi_pvt *pvt = p;
2718         int res;
2719
2720         snprintf(zo.dialstr, sizeof(zo.dialstr), "T%s", dial_string);
2721         ast_debug(1, "Channel %d: Sending '%s' to DAHDI_DIAL.\n", pvt->channel, zo.dialstr);
2722         res = ioctl(pvt->subs[SUB_REAL].dfd, DAHDI_DIAL, &zo);
2723         if (res) {
2724                 ast_log(LOG_WARNING, "Channel %d: Couldn't dial '%s': %s\n",
2725                         pvt->channel, dial_string, strerror(errno));
2726         } else {
2727                 pvt->dialing = 1;
2728         }
2729 }
2730 #endif  /* defined(HAVE_PRI) */
2731
2732 static int unalloc_sub(struct dahdi_pvt *p, int x);
2733
2734 static int my_unallocate_sub(void *pvt, enum analog_sub analogsub)
2735 {
2736         struct dahdi_pvt *p = pvt;
2737
2738         return unalloc_sub(p, analogsub_to_dahdisub(analogsub));
2739 }
2740
2741 static int alloc_sub(struct dahdi_pvt *p, int x);
2742
2743 static int my_allocate_sub(void *pvt, enum analog_sub analogsub)
2744 {
2745         struct dahdi_pvt *p = pvt;
2746
2747         return alloc_sub(p, analogsub_to_dahdisub(analogsub));
2748 }
2749
2750 static int has_voicemail(struct dahdi_pvt *p);
2751
2752 static int my_has_voicemail(void *pvt)
2753 {
2754         struct dahdi_pvt *p = pvt;
2755
2756         return has_voicemail(p);
2757 }
2758
2759 static int my_play_tone(void *pvt, enum analog_sub sub, enum analog_tone tone)
2760 {
2761         struct dahdi_pvt *p = pvt;
2762         int index;
2763
2764         index = analogsub_to_dahdisub(sub);
2765
2766         return tone_zone_play_tone(p->subs[index].dfd, analog_tone_to_dahditone(tone));
2767 }
2768
2769 static enum analog_event dahdievent_to_analogevent(int event)
2770 {
2771         enum analog_event res;
2772
2773         switch (event) {
2774         case DAHDI_EVENT_ONHOOK:
2775                 res = ANALOG_EVENT_ONHOOK;
2776                 break;
2777         case DAHDI_EVENT_RINGOFFHOOK:
2778                 res = ANALOG_EVENT_RINGOFFHOOK;
2779                 break;
2780         case DAHDI_EVENT_WINKFLASH:
2781                 res = ANALOG_EVENT_WINKFLASH;
2782                 break;
2783         case DAHDI_EVENT_ALARM:
2784                 res = ANALOG_EVENT_ALARM;
2785                 break;
2786         case DAHDI_EVENT_NOALARM:
2787                 res = ANALOG_EVENT_NOALARM;
2788                 break;
2789         case DAHDI_EVENT_DIALCOMPLETE:
2790                 res = ANALOG_EVENT_DIALCOMPLETE;
2791                 break;
2792         case DAHDI_EVENT_RINGERON:
2793                 res = ANALOG_EVENT_RINGERON;
2794                 break;
2795         case DAHDI_EVENT_RINGEROFF:
2796                 res = ANALOG_EVENT_RINGEROFF;
2797                 break;
2798         case DAHDI_EVENT_HOOKCOMPLETE:
2799                 res = ANALOG_EVENT_HOOKCOMPLETE;
2800                 break;
2801         case DAHDI_EVENT_PULSE_START:
2802                 res = ANALOG_EVENT_PULSE_START;
2803                 break;
2804         case DAHDI_EVENT_POLARITY:
2805                 res = ANALOG_EVENT_POLARITY;
2806                 break;
2807         case DAHDI_EVENT_RINGBEGIN:
2808                 res = ANALOG_EVENT_RINGBEGIN;
2809                 break;
2810         case DAHDI_EVENT_EC_DISABLED:
2811                 res = ANALOG_EVENT_EC_DISABLED;
2812                 break;
2813         case DAHDI_EVENT_REMOVED:
2814                 res = ANALOG_EVENT_REMOVED;
2815                 break;
2816         case DAHDI_EVENT_NEONMWI_ACTIVE:
2817                 res = ANALOG_EVENT_NEONMWI_ACTIVE;
2818                 break;
2819         case DAHDI_EVENT_NEONMWI_INACTIVE:
2820                 res = ANALOG_EVENT_NEONMWI_INACTIVE;
2821                 break;
2822 #ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
2823         case DAHDI_EVENT_TX_CED_DETECTED:
2824                 res = ANALOG_EVENT_TX_CED_DETECTED;
2825                 break;
2826         case DAHDI_EVENT_RX_CED_DETECTED:
2827                 res = ANALOG_EVENT_RX_CED_DETECTED;
2828                 break;
2829         case DAHDI_EVENT_EC_NLP_DISABLED:
2830                 res = ANALOG_EVENT_EC_NLP_DISABLED;
2831                 break;
2832         case DAHDI_EVENT_EC_NLP_ENABLED:
2833                 res = ANALOG_EVENT_EC_NLP_ENABLED;
2834                 break;
2835 #endif
2836         case DAHDI_EVENT_PULSEDIGIT:
2837                 res = ANALOG_EVENT_PULSEDIGIT;
2838                 break;
2839         case DAHDI_EVENT_DTMFDOWN:
2840                 res = ANALOG_EVENT_DTMFDOWN;
2841                 break;
2842         case DAHDI_EVENT_DTMFUP:
2843                 res = ANALOG_EVENT_DTMFUP;
2844                 break;
2845         default:
2846                 switch(event & 0xFFFF0000) {
2847                 case DAHDI_EVENT_PULSEDIGIT:
2848                 case DAHDI_EVENT_DTMFDOWN:
2849                 case DAHDI_EVENT_DTMFUP:
2850                         /* The event includes a digit number in the low word.
2851                          * Converting it to a 'enum analog_event' would remove
2852                          * that information. Thus it is returned as-is.
2853                          */
2854                         return event;
2855                 }
2856
2857                 res = ANALOG_EVENT_ERROR;
2858                 break;
2859         }
2860
2861         return res;
2862 }
2863
2864 static inline int dahdi_wait_event(int fd);
2865
2866 static int my_wait_event(void *pvt)
2867 {
2868         struct dahdi_pvt *p = pvt;
2869
2870         return dahdi_wait_event(p->subs[SUB_REAL].dfd);
2871 }
2872
2873 static int my_get_event(void *pvt)
2874 {
2875         struct dahdi_pvt *p = pvt;
2876         int res;
2877
2878         if (p->fake_event) {
2879                 res = p->fake_event;
2880                 p->fake_event = 0;
2881         } else
2882                 res = dahdi_get_event(p->subs[SUB_REAL].dfd);
2883
2884         return dahdievent_to_analogevent(res);
2885 }
2886
2887 static int my_is_off_hook(void *pvt)
2888 {
2889         struct dahdi_pvt *p = pvt;
2890         int res;
2891         struct dahdi_params par;
2892
2893         memset(&par, 0, sizeof(par));
2894
2895         if (p->subs[SUB_REAL].dfd > -1)
2896                 res = ioctl(p->subs[SUB_REAL].dfd, DAHDI_GET_PARAMS, &par);
2897         else {
2898                 /* Assume not off hook on CVRS */
2899                 res = 0;
2900                 par.rxisoffhook = 0;
2901         }
2902         if (res) {
2903                 ast_log(LOG_WARNING, "Unable to check hook state on channel %d: %s\n", p->channel, strerror(errno));
2904         }
2905
2906         if ((p->sig == SIG_FXSKS) || (p->sig == SIG_FXSGS)) {
2907                 /* When "onhook" that means no battery on the line, and thus
2908                 it is out of service..., if it's on a TDM card... If it's a channel
2909                 bank, there is no telling... */
2910                 return (par.rxbits > -1) || par.rxisoffhook;
2911         }
2912
2913         return par.rxisoffhook;
2914 }
2915
2916 static void dahdi_enable_ec(struct dahdi_pvt *p);
2917 static void dahdi_disable_ec(struct dahdi_pvt *p);
2918
2919 static int my_set_echocanceller(void *pvt, int enable)
2920 {
2921         struct dahdi_pvt *p = pvt;
2922
2923         if (enable)
2924                 dahdi_enable_ec(p);
2925         else
2926                 dahdi_disable_ec(p);
2927
2928         return 0;
2929 }
2930
2931 static int dahdi_ring_phone(struct dahdi_pvt *p);
2932
2933 static int my_ring(void *pvt)
2934 {
2935         struct dahdi_pvt *p = pvt;
2936
2937         return dahdi_ring_phone(p);
2938 }
2939
2940 static int my_flash(void *pvt)
2941 {
2942         struct dahdi_pvt *p = pvt;
2943         int func = DAHDI_FLASH;
2944         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &func);
2945 }
2946
2947 static inline int dahdi_set_hook(int fd, int hs);
2948
2949 static int my_off_hook(void *pvt)
2950 {
2951         struct dahdi_pvt *p = pvt;
2952         return dahdi_set_hook(p->subs[SUB_REAL].dfd, DAHDI_OFFHOOK);
2953 }
2954
2955 static void my_set_needringing(void *pvt, int value)
2956 {
2957         struct dahdi_pvt *p = pvt;
2958         p->subs[SUB_REAL].needringing = value;
2959 }
2960
2961 static void my_set_polarity(void *pvt, int value)
2962 {
2963         struct dahdi_pvt *p = pvt;
2964
2965         if (p->channel == CHAN_PSEUDO) {
2966                 return;
2967         }
2968         p->polarity = value;
2969         ioctl(p->subs[SUB_REAL].dfd, DAHDI_SETPOLARITY, &value);
2970 }
2971
2972 static void my_start_polarityswitch(void *pvt)
2973 {
2974         struct dahdi_pvt *p = pvt;
2975
2976         if (p->answeronpolarityswitch || p->hanguponpolarityswitch) {
2977                 my_set_polarity(pvt, 0);
2978         }
2979 }
2980
2981 static void my_answer_polarityswitch(void *pvt)
2982 {
2983         struct dahdi_pvt *p = pvt;
2984
2985         if (!p->answeronpolarityswitch) {
2986                 return;
2987         }
2988
2989         my_set_polarity(pvt, 1);
2990 }
2991
2992 static void my_hangup_polarityswitch(void *pvt)
2993 {
2994         struct dahdi_pvt *p = pvt;
2995
2996         if (!p->hanguponpolarityswitch) {
2997                 return;
2998         }
2999
3000         if (p->answeronpolarityswitch) {
3001                 my_set_polarity(pvt, 0);
3002         } else {
3003                 my_set_polarity(pvt, 1);
3004         }
3005 }
3006
3007 static int my_start(void *pvt)
3008 {
3009         struct dahdi_pvt *p = pvt;
3010         int x = DAHDI_START;
3011
3012         return ioctl(p->subs[SUB_REAL].dfd, DAHDI_HOOK, &x);
3013 }
3014
3015 static int my_dial_digits(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
3016 {
3017         int index = analogsub_to_dahdisub(sub);
3018         int res;
3019         struct dahdi_pvt *p = pvt;
3020         struct dahdi_dialoperation ddop;
3021
3022         if (dop->op != ANALOG_DIAL_OP_REPLACE) {
3023                 ast_log(LOG_ERROR, "Fix the dial_digits callback!\n");
3024                 return -1;
3025         }
3026
3027         if (sub != ANALOG_SUB_REAL) {
3028                 ast_log(LOG_ERROR, "Trying to dial_digits '%s' on channel %d subchannel %d\n",
3029                         dop->dialstr, p->channel, sub);
3030                 return -1;
3031         }
3032
3033         ddop.op = DAHDI_DIAL_OP_REPLACE;
3034         ast_copy_string(ddop.dialstr, dop->dialstr, sizeof(ddop.dialstr));
3035
3036         ast_debug(1, "Channel %d: Sending '%s' to DAHDI_DIAL.\n", p->channel, ddop.dialstr);
3037
3038         res = ioctl(p->subs[index].dfd, DAHDI_DIAL, &ddop);
3039         if (res == -1) {
3040                 ast_debug(1, "DAHDI_DIAL ioctl failed on %s: %s\n", ast_channel_name(p->owner), strerror(errno));
3041         }
3042
3043         return res;
3044 }
3045
3046 static void dahdi_train_ec(struct dahdi_pvt *p);
3047
3048 static int my_train_echocanceller(void *pvt)
3049 {
3050         struct dahdi_pvt *p = pvt;
3051
3052         dahdi_train_ec(p);
3053
3054         return 0;
3055 }
3056
3057 static int my_is_dialing(void *pvt, enum analog_sub sub)
3058 {
3059         struct dahdi_pvt *p = pvt;
3060         int index;
3061         int x;
3062
3063         index = analogsub_to_dahdisub(sub);
3064
3065         if (ioctl(p->subs[index].dfd, DAHDI_DIALING, &x)) {
3066                 ast_debug(1, "DAHDI_DIALING ioctl failed!\n");
3067                 return -1;
3068         }
3069
3070         return x;
3071 }
3072
3073 static int my_on_hook(void *pvt)
3074 {
3075         struct dahdi_pvt *p = pvt;
3076         return dahdi_set_hook(p->subs[ANALOG_SUB_REAL].dfd, DAHDI_ONHOOK);
3077 }
3078
3079 #if defined(HAVE_PRI)
3080 static void my_pri_fixup_chans(void *chan_old, void *chan_new)
3081 {
3082         struct dahdi_pvt *old_chan = chan_old;
3083         struct dahdi_pvt *new_chan = chan_new;
3084
3085         new_chan->owner = old_chan->owner;
3086         old_chan->owner = NULL;
3087         if (new_chan->owner) {
3088                 ast_channel_tech_pvt_set(new_chan->owner, new_chan);
3089                 ast_channel_internal_fd_set(new_chan->owner, 0, new_chan->subs[SUB_REAL].dfd);
3090                 new_chan->subs[SUB_REAL].owner = old_chan->subs[SUB_REAL].owner;
3091                 old_chan->subs[SUB_REAL].owner = NULL;
3092         }
3093         /* Copy any DSP that may be present */
3094         new_chan->dsp = old_chan->dsp;
3095         new_chan->dsp_features = old_chan->dsp_features;
3096         old_chan->dsp = NULL;
3097         old_chan->dsp_features = 0;
3098
3099         /* Transfer flags from the old channel. */
3100         new_chan->dialing = old_chan->dialing;
3101         new_chan->digital = old_chan->digital;
3102         new_chan->outgoing = old_chan->outgoing;
3103         old_chan->dialing = 0;
3104         old_chan->digital = 0;
3105         old_chan->outgoing = 0;
3106
3107         /* More stuff to transfer to the new channel. */
3108         new_chan->law = old_chan->law;
3109         strcpy(new_chan->dialstring, old_chan->dialstring);
3110 }
3111 #endif  /* defined(HAVE_PRI) */
3112
3113 #if defined(HAVE_PRI)
3114 static int sig_pri_tone_to_dahditone(enum sig_pri_tone tone)
3115 {
3116         switch (tone) {
3117         case SIG_PRI_TONE_RINGTONE:
3118                 return DAHDI_TONE_RINGTONE;
3119         case SIG_PRI_TONE_STUTTER:
3120                 return DAHDI_TONE_STUTTER;
3121         case SIG_PRI_TONE_CONGESTION:
3122                 return DAHDI_TONE_CONGESTION;
3123         case SIG_PRI_TONE_DIALTONE:
3124                 return DAHDI_TONE_DIALTONE;
3125         case SIG_PRI_TONE_DIALRECALL:
3126                 return DAHDI_TONE_DIALRECALL;
3127         case SIG_PRI_TONE_INFO:
3128                 return DAHDI_TONE_INFO;
3129         case SIG_PRI_TONE_BUSY:
3130                 return DAHDI_TONE_BUSY;
3131         default:
3132                 return -1;
3133         }
3134 }
3135 #endif  /* defined(HAVE_PRI) */
3136
3137 #if defined(HAVE_PRI)
3138 static void my_handle_dchan_exception(struct sig_pri_span *pri, int index)
3139 {
3140         int x;
3141
3142         ioctl(pri->fds[index], DAHDI_GETEVENT, &x);
3143         switch (x) {
3144         case DAHDI_EVENT_NONE:
3145                 break;
3146         case DAHDI_EVENT_ALARM:
3147         case DAHDI_EVENT_NOALARM:
3148                 if (sig_pri_is_alarm_ignored(pri)) {
3149                         break;
3150                 }
3151                 /* Fall through */
3152         default:
3153                 ast_log(LOG_NOTICE, "PRI got event: %s (%d) on D-channel of span %d\n",
3154                         event2str(x), x, pri->span);
3155                 break;
3156         }
3157         /* Keep track of alarm state */
3158         switch (x) {
3159         case DAHDI_EVENT_ALARM:
3160                 pri_event_alarm(pri, index, 0);
3161                 break;
3162         case DAHDI_EVENT_NOALARM:
3163                 pri_event_noalarm(pri, index, 0);
3164                 break;
3165         default:
3166                 break;
3167         }
3168 }
3169 #endif  /* defined(HAVE_PRI) */
3170
3171 #if defined(HAVE_PRI)
3172 static int my_pri_play_tone(void *pvt, enum sig_pri_tone tone)
3173 {
3174         struct dahdi_pvt *p = pvt;
3175
3176         return tone_zone_play_tone(p->subs[SUB_REAL].dfd, sig_pri_tone_to_dahditone(tone));
3177 }
3178 #endif  /* defined(HAVE_PRI) */
3179
3180 #if defined(HAVE_PRI) || defined(HAVE_SS7)
3181 /*!
3182  * \internal
3183  * \brief Set the caller id information.
3184  * \since 1.8
3185  *
3186  * \param pvt DAHDI private structure
3187  * \param caller Caller-id information to set.
3188  *
3189  * \return Nothing
3190  */
3191 static void my_set_callerid(void *pvt, const struct ast_party_caller *caller)
3192 {
3193         struct dahdi_pvt *p = pvt;
3194
3195         ast_copy_string(p->cid_num,
3196                 S_COR(caller->id.number.valid, caller->id.number.str, ""),
3197                 sizeof(p->cid_num));
3198         ast_copy_string(p->cid_name,
3199                 S_COR(caller->id.name.valid, caller->id.name.str, ""),
3200         &nb