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