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