Asterisk - The Open Source Telephony Project GIT-master-d856a3e
Macros | Functions | Variables
sig_analog.c File Reference

Analog signaling module. More...

#include "asterisk.h"
#include <errno.h>
#include <ctype.h>
#include "asterisk/utils.h"
#include "asterisk/options.h"
#include "asterisk/pickup.h"
#include "asterisk/pbx.h"
#include "asterisk/file.h"
#include "asterisk/callerid.h"
#include "asterisk/say.h"
#include "asterisk/manager.h"
#include "asterisk/astdb.h"
#include "asterisk/features.h"
#include "asterisk/causes.h"
#include "asterisk/features_config.h"
#include "asterisk/bridge.h"
#include "asterisk/parking.h"
#include "sig_analog.h"
Include dependency graph for sig_analog.c:

Go to the source code of this file.

Macros

#define analog_get_index(ast, p, nullok)   _analog_get_index(ast, p, nullok, __PRETTY_FUNCTION__, __LINE__)
 
#define ANALOG_NEED_MFDETECT(p)   (((p)->sig == ANALOG_SIG_FEATDMF) || ((p)->sig == ANALOG_SIG_FEATDMF_TA) || ((p)->sig == ANALOG_SIG_E911) || ((p)->sig == ANALOG_SIG_FGC_CAMA) || ((p)->sig == ANALOG_SIG_FGC_CAMAMF) || ((p)->sig == ANALOG_SIG_FEATB))
 
#define gen_analog_field_callback(type, callback_name, def_value)
 
#define ISTRUNK(p)
 
#define MIN_MS_SINCE_FLASH   ( (2000) )
 
#define POLARITY_IDLE   0
 
#define POLARITY_REV   1
 

Functions

static struct ast_frame__analog_handle_event (struct analog_pvt *p, struct ast_channel *ast)
 
static void * __analog_ss_thread (void *data)
 
static int _analog_get_index (struct ast_channel *ast, struct analog_pvt *p, int nullok, const char *fname, unsigned long line)
 
static void analog_all_subchannels_hungup (struct analog_pvt *p)
 
static int analog_alloc_sub (struct analog_pvt *p, enum analog_sub x)
 
int analog_answer (struct analog_pvt *p, struct ast_channel *ast)
 
static void analog_answer_polarityswitch (struct analog_pvt *p)
 
static int analog_attempt_transfer (struct analog_pvt *p)
 
int analog_available (struct analog_pvt *p)
 
int analog_call (struct analog_pvt *p, struct ast_channel *ast, const char *rdest, int timeout)
 
static int analog_callwait (struct analog_pvt *p)
 
static void analog_cancel_cidspill (struct analog_pvt *p)
 
static int analog_canmatch_featurecode (const char *pickupexten, const char *exten)
 
static void analog_cb_handle_dtmf (struct analog_pvt *p, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
 
static int analog_check_confirmanswer (struct analog_pvt *p)
 
static int analog_check_for_conference (struct analog_pvt *p)
 
static int analog_check_waitingfordt (struct analog_pvt *p)
 
const char * analog_cidstart_to_str (enum analog_cid_start cid_start)
 
const char * analog_cidtype_to_str (unsigned int cid_type)
 
int analog_config_complete (struct analog_pvt *p)
 
static int analog_confmute (struct analog_pvt *p, int mute)
 
static void analog_deadlock_avoidance_private (struct analog_pvt *p)
 
static void analog_decrease_ss_count (void)
 
void analog_delete (struct analog_pvt *doomed)
 Delete the analog private structure. More...
 
static int analog_dial_digits (struct analog_pvt *p, enum analog_sub sub, struct analog_dialoperation *dop)
 
static int analog_distinctive_ring (struct ast_channel *chan, struct analog_pvt *p, int idx, int *ringdata)
 
int analog_dnd (struct analog_pvt *p, int flag)
 
static int analog_dsp_reset_and_flush_digits (struct analog_pvt *p)
 
static int analog_dsp_set_digitmode (struct analog_pvt *p, enum analog_dsp_digitmode mode)
 
static char * analog_event2str (enum analog_event event)
 
struct ast_frameanalog_exception (struct analog_pvt *p, struct ast_channel *ast)
 
int analog_fixup (struct ast_channel *oldchan, struct ast_channel *newchan, void *newp)
 
static int analog_flash (struct analog_pvt *p)
 
void analog_free (struct analog_pvt *p)
 
static void analog_get_and_handle_alarms (struct analog_pvt *p)
 
static void * analog_get_bridged_channel (struct ast_channel *chan)
 
static int analog_get_callerid (struct analog_pvt *p, char *name, char *number, enum analog_event *ev, size_t timeout)
 
static int analog_get_event (struct analog_pvt *p)
 
static const char * analog_get_orig_dialstring (struct analog_pvt *p)
 
static int analog_get_sub_fd (struct analog_pvt *p, enum analog_sub sub)
 
void analog_handle_dtmf (struct analog_pvt *p, struct ast_channel *ast, enum analog_sub idx, struct ast_frame **dest)
 
void * analog_handle_init_event (struct analog_pvt *i, int event)
 
static int analog_handle_notify_message (struct ast_channel *chan, struct analog_pvt *p, int cid_flags, int neon_mwievent)
 
static int analog_handles_digit (struct ast_frame *f)
 
int analog_hangup (struct analog_pvt *p, struct ast_channel *ast)
 
static void analog_hangup_polarityswitch (struct analog_pvt *p)
 
static int analog_has_voicemail (struct analog_pvt *p)
 
static int analog_have_progressdetect (struct analog_pvt *p)
 
static void analog_increase_ss_count (void)
 
static int analog_is_dialing (struct analog_pvt *p, enum analog_sub index)
 
static int analog_is_off_hook (struct analog_pvt *p)
 
static void analog_lock_private (struct analog_pvt *p)
 
static void analog_lock_sub_owner (struct analog_pvt *pvt, enum analog_sub sub_idx)
 
static int analog_my_getsigstr (struct ast_channel *chan, char *str, const char *term, int ms)
 
struct analog_pvtanalog_new (enum analog_sigtype signallingtype, void *private_data)
 
static struct ast_channelanalog_new_ast_channel (struct analog_pvt *p, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
 
static int analog_off_hook (struct analog_pvt *p)
 
static int analog_on_hook (struct analog_pvt *p)
 
static int analog_play_tone (struct analog_pvt *p, enum analog_sub sub, enum analog_tone tone)
 
static void analog_publish_channel_alarm_clear (int channel)
 
static void analog_publish_dnd_state (int channel, const char *status)
 
struct ast_channelanalog_request (struct analog_pvt *p, int *callwait, const struct ast_channel *requestor)
 
static int analog_ring (struct analog_pvt *p)
 
static int analog_send_callerid (struct analog_pvt *p, int cwcid, struct ast_party_caller *caller)
 
static void analog_set_alarm (struct analog_pvt *p, int in_alarm)
 
static void analog_set_cadence (struct analog_pvt *p, struct ast_channel *chan)
 
static void analog_set_callwaiting (struct analog_pvt *p, int callwaiting_enable)
 
static void analog_set_confirmanswer (struct analog_pvt *p, int flag)
 
static void analog_set_dialing (struct analog_pvt *p, int is_dialing)
 
static int analog_set_echocanceller (struct analog_pvt *p, int enable)
 
static void analog_set_inthreeway (struct analog_pvt *p, enum analog_sub sub, int inthreeway)
 
static int analog_set_linear_mode (struct analog_pvt *p, enum analog_sub sub, int linear_mode)
 
static void analog_set_needringing (struct analog_pvt *p, int value)
 
static void analog_set_new_owner (struct analog_pvt *p, struct ast_channel *new_owner)
 
static void analog_set_outgoing (struct analog_pvt *p, int is_outgoing)
 
static void analog_set_pulsedial (struct analog_pvt *p, int flag)
 
static void analog_set_ringtimeout (struct analog_pvt *p, int ringt)
 
static void analog_set_waitingfordt (struct analog_pvt *p, struct ast_channel *ast)
 
const char * analog_sigtype_to_str (enum analog_sigtype sigtype)
 
int analog_ss_thread_start (struct analog_pvt *p, struct ast_channel *chan)
 
static int analog_start (struct analog_pvt *p)
 
static int analog_start_cid_detect (struct analog_pvt *p, int cid_signalling)
 
static void analog_start_polarityswitch (struct analog_pvt *p)
 
static int analog_stop_callwait (struct analog_pvt *p)
 
static int analog_stop_cid_detect (struct analog_pvt *p)
 
enum analog_cid_start analog_str_to_cidstart (const char *value)
 
unsigned int analog_str_to_cidtype (const char *name)
 
enum analog_sigtype analog_str_to_sigtype (const char *name)
 
static void analog_swap_subs (struct analog_pvt *p, enum analog_sub a, enum analog_sub b)
 
static int analog_train_echocanceller (struct analog_pvt *p)
 
static int analog_unalloc_sub (struct analog_pvt *p, enum analog_sub x)
 
static void analog_unlock_private (struct analog_pvt *p)
 
static int analog_update_conf (struct analog_pvt *p)
 
static int analog_wait_event (struct analog_pvt *p)
 
static int analog_wink (struct analog_pvt *p, enum analog_sub index)
 
 gen_analog_field_callback (int, firstdigit_timeout, ANALOG_FIRST_DIGIT_TIMEOUT)
 
 gen_analog_field_callback (int, interdigit_timeout, ANALOG_INTER_DIGIT_TIMEOUT)
 
 gen_analog_field_callback (int, matchdigit_timeout, ANALOG_MATCH_DIGIT_TIMEOUT)
 

Variables

static char analog_defaultcic [64] = ""
 
static char analog_defaultozz [64] = ""
 
struct {
   unsigned int   cid_type
 
   const char *   name
 
cidtypes []
 
struct {
   const char *   name
 
   enum analog_sigtype   sigtype
 
sigtypes []
 

Detailed Description

Analog signaling module.

Author
Matthew Fredrickson cresl.nosp@m.in@d.nosp@m.igium.nosp@m..com

Definition in file sig_analog.c.

Macro Definition Documentation

◆ analog_get_index

#define analog_get_index (   ast,
  p,
  nullok 
)    _analog_get_index(ast, p, nullok, __PRETTY_FUNCTION__, __LINE__)

Definition at line 407 of file sig_analog.c.

◆ ANALOG_NEED_MFDETECT

#define ANALOG_NEED_MFDETECT (   p)    (((p)->sig == ANALOG_SIG_FEATDMF) || ((p)->sig == ANALOG_SIG_FEATDMF_TA) || ((p)->sig == ANALOG_SIG_E911) || ((p)->sig == ANALOG_SIG_FGC_CAMA) || ((p)->sig == ANALOG_SIG_FGC_CAMAMF) || ((p)->sig == ANALOG_SIG_FEATB))

Definition at line 1713 of file sig_analog.c.

◆ gen_analog_field_callback

#define gen_analog_field_callback (   type,
  callback_name,
  def_value 
)

Definition at line 219 of file sig_analog.c.

◆ ISTRUNK

#define ISTRUNK (   p)
Value:
((p->sig == ANALOG_SIG_FXSLS) || (p->sig == ANALOG_SIG_FXSKS) || \
(p->sig == ANALOG_SIG_FXSGS))
@ ANALOG_SIG_FXSLS
Definition: sig_analog.h:50
@ ANALOG_SIG_FXSGS
Definition: sig_analog.h:52
@ ANALOG_SIG_FXSKS
Definition: sig_analog.h:51

Definition at line 107 of file sig_analog.c.

◆ MIN_MS_SINCE_FLASH

#define MIN_MS_SINCE_FLASH   ( (2000) )

2000 ms

Definition at line 64 of file sig_analog.c.

◆ POLARITY_IDLE

#define POLARITY_IDLE   0
Note
Define if you want to check the hook state for an FXO (FXS signalled) interface before dialing on it. Certain FXO interfaces always think they're out of service with this method however.

Definition at line 62 of file sig_analog.c.

◆ POLARITY_REV

#define POLARITY_REV   1

Definition at line 63 of file sig_analog.c.

Function Documentation

◆ __analog_handle_event()

static struct ast_frame * __analog_handle_event ( struct analog_pvt p,
struct ast_channel ast 
)
static

< Digits (or equivalent) have been dialed

< Remote end is ringing

< Line is up

< Line is ringing

< Channel is down and available

< Channel is down, but reserved

< Channel is off hook

< Line is busy

< Digits (or equivalent) have been dialed while offhook

< Channel has detected an incoming call and is waiting for ring

< Digits (or equivalent) have been dialed

< Remote end is ringing

< Line is up

< Line is ringing

Definition at line 2773 of file sig_analog.c.

2774{
2775 int res, x;
2776 int mysig;
2777 int idx;
2778 char *c;
2779 pthread_t threadid;
2780 struct ast_channel *chan;
2781 struct ast_frame *f;
2782 struct ast_control_pvt_cause_code *cause_code = NULL;
2783 int data_size = sizeof(*cause_code);
2784 char *subclass = NULL;
2785
2786 ast_debug(1, "%s %d\n", __FUNCTION__, p->channel);
2787
2788 idx = analog_get_index(ast, p, 0);
2789 if (idx < 0) {
2790 return &ast_null_frame;
2791 }
2792 if (idx != ANALOG_SUB_REAL) {
2793 ast_log(LOG_ERROR, "We got an event on a non real sub. Fix it!\n");
2794 }
2795
2796 mysig = p->sig;
2797 if (p->outsigmod > -1) {
2798 mysig = p->outsigmod;
2799 }
2800
2801 p->subs[idx].f.frametype = AST_FRAME_NULL;
2802 p->subs[idx].f.subclass.integer = 0;
2803 p->subs[idx].f.datalen = 0;
2804 p->subs[idx].f.samples = 0;
2805 p->subs[idx].f.mallocd = 0;
2806 p->subs[idx].f.offset = 0;
2807 p->subs[idx].f.src = "dahdi_handle_event";
2808 p->subs[idx].f.data.ptr = NULL;
2809 f = &p->subs[idx].f;
2810
2811 res = analog_get_event(p);
2812
2813 ast_debug(1, "Got event %s(%d) on channel %d (index %u)\n", analog_event2str(res), res, p->channel, idx);
2814
2817 ast_debug(1, "Detected %sdigit '%c'\n", (res & ANALOG_EVENT_PULSEDIGIT) ? "pulse ": "", res & 0xff);
2818 analog_confmute(p, 0);
2821 p->subs[idx].f.subclass.integer = res & 0xff;
2822 analog_handle_dtmf(p, ast, idx, &f);
2823 } else {
2824 ast_debug(1, "Dropping pulse digit '%c' because pulse dialing disabled on channel %d\n", res & 0xff, p->channel);
2825 }
2826 return f;
2827 }
2828
2829 if (res & ANALOG_EVENT_DTMFDOWN) {
2830 ast_debug(1, "DTMF Down '%c'\n", res & 0xff);
2831 /* Mute conference */
2832 analog_confmute(p, 1);
2834 p->subs[idx].f.subclass.integer = res & 0xff;
2835 analog_handle_dtmf(p, ast, idx, &f);
2836 return f;
2837 }
2838
2839 switch (res) {
2840 case ANALOG_EVENT_ALARM:
2843 /* add length of "ANALOG " */
2844 data_size += 7;
2845 subclass = analog_event2str(res);
2846 data_size += strlen(subclass);
2847 cause_code = ast_alloca(data_size);
2848 memset(cause_code, 0, data_size);
2851 snprintf(cause_code->code, data_size - sizeof(*cause_code) + 1, "ANALOG %s", subclass);
2852 break;
2853 default:
2854 break;
2855 }
2856
2857 switch (res) {
2859 ast_verb(3, "Channel %d echo canceller disabled due to CED detection\n", p->channel);
2861 break;
2862#ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
2864 ast_verb(3, "Channel %d detected a CED tone towards the network.\n", p->channel);
2865 break;
2867 ast_verb(3, "Channel %d detected a CED tone from the network.\n", p->channel);
2868 break;
2870 ast_verb(3, "Channel %d echo canceller disabled its NLP.\n", p->channel);
2871 break;
2873 ast_verb(3, "Channel %d echo canceller enabled its NLP.\n", p->channel);
2874 break;
2875#endif
2877 /* Stop tone if there's a pulse start and the PBX isn't started */
2878 if (!ast_channel_pbx(ast))
2880 break;
2882 if (p->inalarm) {
2883 break;
2884 }
2885 x = analog_is_dialing(p, idx);
2886 if (!x) { /* if not still dialing in driver */
2888 if (p->echobreak) {
2890 ast_copy_string(p->dop.dialstr, p->echorest, sizeof(p->dop.dialstr));
2893 p->echobreak = 0;
2894 } else {
2895 analog_set_dialing(p, 0);
2896 if ((mysig == ANALOG_SIG_E911) || (mysig == ANALOG_SIG_FGC_CAMA) || (mysig == ANALOG_SIG_FGC_CAMAMF)) {
2897 /* if thru with dialing after offhook */
2902 break;
2903 } else { /* if to state wait for offhook to dial rest */
2904 /* we now wait for off hook */
2906 }
2907 }
2910 ast_debug(1, "Done dialing, but waiting for progress detection before doing more...\n");
2911 } else if (analog_check_confirmanswer(p) || (!p->dialednone
2912 && ((mysig == ANALOG_SIG_EM) || (mysig == ANALOG_SIG_EM_E1)
2913 || (mysig == ANALOG_SIG_EMWINK) || (mysig == ANALOG_SIG_FEATD)
2914 || (mysig == ANALOG_SIG_FEATDMF_TA) || (mysig == ANALOG_SIG_FEATDMF)
2915 || (mysig == ANALOG_SIG_E911) || (mysig == ANALOG_SIG_FGC_CAMA)
2916 || (mysig == ANALOG_SIG_FGC_CAMAMF) || (mysig == ANALOG_SIG_FEATB)
2917 || (mysig == ANALOG_SIG_SF) || (mysig == ANALOG_SIG_SFWINK)
2918 || (mysig == ANALOG_SIG_SF_FEATD) || (mysig == ANALOG_SIG_SF_FEATDMF)
2919 || (mysig == ANALOG_SIG_SF_FEATB)))) {
2921 } else if (!p->answeronpolarityswitch) {
2925 /* If aops=0 and hops=1, this is necessary */
2927 } else {
2928 /* Start clean, so we can catch the change to REV polarity when party answers */
2930 }
2931 }
2932 }
2933 }
2934 break;
2935 case ANALOG_EVENT_ALARM:
2936 analog_set_alarm(p, 1);
2940 if (p->calledsubscriberheld && (p->sig == ANALOG_SIG_FXOLS || p->sig == ANALOG_SIG_FXOGS || p->sig == ANALOG_SIG_FXOKS) && idx == ANALOG_SUB_REAL) {
2941 ast_debug(4, "Channel state on %s is %d\n", ast_channel_name(ast), ast_channel_state(ast));
2942 /* Called Subscriber Held: don't let the called party hang up on an incoming call immediately (if it's the only call). */
2944 ast_debug(2, "Letting this call hang up normally, since it's not the only call\n");
2945 } else if (!p->owner || !p->subs[ANALOG_SUB_REAL].owner || ast_channel_state(ast) != AST_STATE_UP) {
2946 ast_debug(2, "Called Subscriber Held does not apply: channel state is %d\n", ast_channel_state(ast));
2947 } else if (!p->owner || !p->subs[ANALOG_SUB_REAL].owner || strcmp(ast_channel_appl(p->subs[ANALOG_SUB_REAL].owner), "AppDial")) {
2948 /* Called Subscriber held only applies to incoming calls, not outgoing calls.
2949 * We can't use p->outgoing because that is always true, for both incoming and outgoing calls, so it's not accurate.
2950 * We can check the channel application/data instead.
2951 * For incoming calls to the channel, it will look like: AppDial / (Outgoing Line)
2952 * We only want this behavior for regular calls anyways (and not, say, Queue),
2953 * so this would actually work great. But accessing ast_channel_appl can cause a crash if there are no calls left,
2954 * so this check must occur AFTER we confirm the channel state *is* still UP.
2955 */
2956 ast_debug(2, "Called Subscriber Held does not apply: not an incoming call\n");
2957 } else if (analog_is_off_hook(p)) {
2958 ast_log(LOG_WARNING, "Got ONHOOK but channel %d is off hook?\n", p->channel); /* Shouldn't happen */
2959 } else {
2960 ast_verb(3, "Holding incoming call %s for channel %d\n", ast_channel_name(ast), p->channel);
2961 /* Inhibit dahdi_hangup from getting called, and do nothing else now.
2962 * When the DAHDI channel goes off hook again, it'll just get reconnected with the incoming call,
2963 * to which, as far as its concerned, nothing has happened. */
2964 p->cshactive = 1; /* Keep track that this DAHDI channel is currently being held by an incoming call. */
2965 break;
2966 }
2967 }
2968 ast_queue_control_data(ast, AST_CONTROL_PVT_CAUSE_CODE, cause_code, data_size);
2969 ast_channel_hangupcause_hash_set(ast, cause_code, data_size);
2970 switch (p->sig) {
2971 case ANALOG_SIG_FXOLS:
2972 case ANALOG_SIG_FXOGS:
2973 case ANALOG_SIG_FXOKS:
2975 p->fxsoffhookstate = 0;
2976 p->onhooktime = time(NULL);
2977 p->msgstate = -1;
2978 /* Check for some special conditions regarding call waiting */
2979 if (idx == ANALOG_SUB_REAL) {
2980 /* The normal line was hung up */
2981 if (p->subs[ANALOG_SUB_CALLWAIT].owner) {
2982 /* Need to hold the lock for real-call, private, and call-waiting call */
2984 if (!p->subs[ANALOG_SUB_CALLWAIT].owner) {
2985 /*
2986 * The call waiting call disappeared.
2987 * This is now a normal hangup.
2988 */
2990 return NULL;
2991 }
2992
2993 /* There's a call waiting call, so ring the phone, but make it unowned in the meantime */
2995 ast_verb(3, "Channel %d still has (callwait) call, ringing phone\n", p->channel);
2999 /* Don't start streaming audio yet if the incoming call isn't up yet */
3001 analog_set_dialing(p, 1);
3002 }
3003 /* Unlock the call-waiting call that we swapped to real-call. */
3005 analog_ring(p);
3006 } else if (p->subs[ANALOG_SUB_THREEWAY].owner) {
3007 unsigned int mssinceflash;
3008
3009 /* Need to hold the lock for real-call, private, and 3-way call */
3011 if (!p->subs[ANALOG_SUB_THREEWAY].owner) {
3012 ast_log(LOG_NOTICE, "Whoa, threeway disappeared kinda randomly.\n");
3013 /* Just hangup */
3014 return NULL;
3015 }
3016 if (p->owner != ast) {
3018 ast_log(LOG_WARNING, "This isn't good...\n");
3019 /* Just hangup */
3020 return NULL;
3021 }
3022
3023 mssinceflash = ast_tvdiff_ms(ast_tvnow(), p->flashtime);
3024 ast_debug(1, "Last flash was %u ms ago\n", mssinceflash);
3025 if (mssinceflash < MIN_MS_SINCE_FLASH) {
3026 /* It hasn't been long enough since the last flashook. This is probably a bounce on
3027 hanging up. Hangup both channels now */
3028 ast_debug(1, "Looks like a bounced flash, hanging up both calls on %d\n", p->channel);
3032 } else if ((ast_channel_pbx(ast)) || (ast_channel_state(ast) == AST_STATE_UP)) {
3033 if (p->transfer) {
3034 /* In any case this isn't a threeway call anymore */
3037
3038 /* Only attempt transfer if the phone is ringing; why transfer to busy tone eh? */
3039 if (!p->transfertobusy && ast_channel_state(ast) == AST_STATE_BUSY) {
3040 /* Swap subs and dis-own channel */
3042 /* Unlock the 3-way call that we swapped to real-call. */
3045 /* Ring the phone */
3046 analog_ring(p);
3047 } else if (!analog_attempt_transfer(p)) {
3048 /*
3049 * Transfer successful. Don't actually hang up at this point.
3050 * Let our channel legs of the calls die off as the transfer
3051 * percolates through the core.
3052 */
3053 break;
3054 }
3055 } else {
3058 }
3059 } else {
3060 /* Swap subs and dis-own channel */
3062 /* Unlock the 3-way call that we swapped to real-call. */
3065 /* Ring the phone */
3066 analog_ring(p);
3067 }
3068 }
3069 } else {
3070 ast_log(LOG_WARNING, "Got a hangup and my index is %u?\n", idx);
3071 }
3072 /* Fall through */
3073 default:
3075 return NULL;
3076 }
3077 break;
3079 if (p->inalarm) {
3080 break;
3081 }
3082 /* for E911, its supposed to wait for offhook then dial
3083 the second half of the dial string */
3084 if (((mysig == ANALOG_SIG_E911) || (mysig == ANALOG_SIG_FGC_CAMA) || (mysig == ANALOG_SIG_FGC_CAMAMF)) && (ast_channel_state(ast) == AST_STATE_DIALING_OFFHOOK)) {
3085 c = strchr(p->dialdest, '/');
3086 if (c) {
3087 c++;
3088 } else {
3089 c = p->dialdest;
3090 }
3091
3092 if (*c) {
3093 int numchars = snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*0%s#", c);
3094 if (numchars >= sizeof(p->dop.dialstr)) {
3095 ast_log(LOG_WARNING, "Dial string '%s' truncated\n", c);
3096 }
3097 } else {
3098 ast_copy_string(p->dop.dialstr,"M*2#", sizeof(p->dop.dialstr));
3099 }
3100
3101 if (strlen(p->dop.dialstr) > 4) {
3102 memset(p->echorest, 'w', sizeof(p->echorest) - 1);
3103 strcpy(p->echorest + (p->echotraining / 401) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2);
3104 p->echorest[sizeof(p->echorest) - 1] = '\0';
3105 p->echobreak = 1;
3106 p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0';
3107 } else {
3108 p->echobreak = 0;
3109 }
3110 if (analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop)) {
3111 analog_on_hook(p);
3112 return NULL;
3113 }
3114 analog_set_dialing(p, 1);
3115 return &p->subs[idx].f;
3116 }
3117 switch (p->sig) {
3118 case ANALOG_SIG_FXOLS:
3119 case ANALOG_SIG_FXOGS:
3120 case ANALOG_SIG_FXOKS:
3121 p->fxsoffhookstate = 1;
3122 switch (ast_channel_state(ast)) {
3123 case AST_STATE_RINGING:
3128 /* Make sure it stops ringing */
3130 analog_off_hook(p);
3131 ast_debug(1, "channel %d answered\n", p->channel);
3132
3133 /* Cancel any running CallerID spill */
3135
3136 analog_set_dialing(p, 0);
3137 p->callwaitcas = 0;
3139 /* Ignore answer if "confirm answer" is enabled */
3140 p->subs[idx].f.frametype = AST_FRAME_NULL;
3141 p->subs[idx].f.subclass.integer = 0;
3142 } else if (!ast_strlen_zero(p->dop.dialstr)) {
3143 /* nick@dccinc.com 4/3/03 - fxo should be able to do deferred dialing */
3144 res = analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop);
3145 if (res) {
3146 p->dop.dialstr[0] = '\0';
3147 return NULL;
3148 } else {
3149 ast_debug(1, "Sent FXO deferred digit string: %s\n", p->dop.dialstr);
3150 p->subs[idx].f.frametype = AST_FRAME_NULL;
3151 p->subs[idx].f.subclass.integer = 0;
3152 analog_set_dialing(p, 1);
3153 }
3154 p->dop.dialstr[0] = '\0';
3156 } else {
3159 }
3160 return &p->subs[idx].f;
3161 case AST_STATE_DOWN:
3163 ast_channel_rings_set(ast, 1);
3166 ast_debug(1, "channel %d picked up\n", p->channel);
3167 return &p->subs[idx].f;
3168 case AST_STATE_UP:
3169 /* Make sure it stops ringing */
3170 analog_off_hook(p);
3171 /* Okay -- probably call waiting */
3173 break;
3174 case AST_STATE_RESERVED:
3175 /* Start up dialtone */
3176 if (analog_has_voicemail(p)) {
3178 } else {
3180 }
3181 break;
3182 default:
3183 ast_log(LOG_WARNING, "FXO phone off hook in weird state %u??\n", ast_channel_state(ast));
3184 }
3185 break;
3186 case ANALOG_SIG_FXSLS:
3187 case ANALOG_SIG_FXSGS:
3188 case ANALOG_SIG_FXSKS:
3189 if (ast_channel_state(ast) == AST_STATE_RING) {
3191 }
3192
3193 /* Fall through */
3194 case ANALOG_SIG_EM:
3195 case ANALOG_SIG_EM_E1:
3196 case ANALOG_SIG_EMWINK:
3197 case ANALOG_SIG_FEATD:
3198 case ANALOG_SIG_FEATDMF:
3200 case ANALOG_SIG_E911:
3203 case ANALOG_SIG_FEATB:
3204 case ANALOG_SIG_SF:
3205 case ANALOG_SIG_SFWINK:
3209 switch (ast_channel_state(ast)) {
3210 case AST_STATE_PRERING:
3212 /* Fall through */
3213 case AST_STATE_DOWN:
3214 case AST_STATE_RING:
3215 ast_debug(1, "Ring detected\n");
3218 break;
3219 case AST_STATE_RINGING:
3220 case AST_STATE_DIALING:
3221 if (p->outgoing) {
3222 ast_debug(1, "Line answered\n");
3224 p->subs[idx].f.frametype = AST_FRAME_NULL;
3225 p->subs[idx].f.subclass.integer = 0;
3226 } else {
3230 }
3231 break;
3232 }
3233 /* Fall through */
3234 default:
3235 ast_log(LOG_WARNING, "Ring/Off-hook in strange state %u on channel %d\n", ast_channel_state(ast), p->channel);
3236 break;
3237 }
3238 break;
3239 default:
3240 ast_log(LOG_WARNING, "Don't know how to handle ring/off hook for signalling %d\n", p->sig);
3241 break;
3242 }
3243 break;
3245 switch (p->sig) {
3246 case ANALOG_SIG_FXSLS:
3247 case ANALOG_SIG_FXSGS:
3248 case ANALOG_SIG_FXSKS:
3249 if (ast_channel_state(ast) == AST_STATE_RING) {
3251 }
3252 break;
3253 default:
3254 break;
3255 }
3256 break;
3258 if (p->inalarm) break;
3260 if (ast_channel_rings(ast) == p->cidrings) {
3261 analog_send_callerid(p, 0, &p->caller);
3262 }
3263
3264 if (ast_channel_rings(ast) > p->cidrings) {
3266 p->callwaitcas = 0;
3267 }
3270 break;
3272 break;
3274 analog_set_alarm(p, 0);
3276 break;
3278 if (p->inalarm) {
3279 break;
3280 }
3281 /* Remember last time we got a flash-hook */
3282 gettimeofday(&p->flashtime, NULL);
3283 switch (mysig) {
3284 case ANALOG_SIG_FXOLS:
3285 case ANALOG_SIG_FXOGS:
3286 case ANALOG_SIG_FXOKS:
3287 ast_debug(1, "Winkflash, index: %u, normal: %d, callwait: %d, thirdcall: %d\n",
3289
3290 /* Cancel any running CallerID spill */
3292 p->callwaitcas = 0;
3293
3294 if (idx != ANALOG_SUB_REAL) {
3295 ast_log(LOG_WARNING, "Got flash hook with index %u on channel %d?!?\n", idx, p->channel);
3296 goto winkflashdone;
3297 }
3298
3299 if (p->subs[ANALOG_SUB_CALLWAIT].owner) {
3300 /* Need to hold the lock for real-call, private, and call-waiting call */
3302 if (!p->subs[ANALOG_SUB_CALLWAIT].owner) {
3303 /*
3304 * The call waiting call dissappeared.
3305 * Let's just ignore this flash-hook.
3306 */
3307 ast_log(LOG_NOTICE, "Whoa, the call-waiting call disappeared.\n");
3308 goto winkflashdone;
3309 }
3310
3311 /* Swap to call-wait */
3315 ast_debug(1, "Making %s the new owner\n", ast_channel_name(p->owner));
3319 }
3321
3322 /* Start music on hold if appropriate */
3325 }
3328
3329 /* Unlock the call-waiting call that we swapped to real-call. */
3331 } else if (!p->subs[ANALOG_SUB_THREEWAY].owner) {
3332 if (!p->threewaycalling) {
3333 /* Just send a flash if no 3-way calling */
3335 goto winkflashdone;
3336 } else if (!analog_check_for_conference(p)) {
3337 ast_callid callid = 0;
3338 int callid_created;
3339 char cid_num[256];
3340 char cid_name[256];
3341
3342 cid_num[0] = '\0';
3343 cid_name[0] = '\0';
3344 if (p->dahditrcallerid && p->owner) {
3348 sizeof(cid_num));
3349 }
3353 sizeof(cid_name));
3354 }
3355 }
3356 /* XXX This section needs much more error checking!!! XXX */
3357 /* Start a 3-way call if feasible */
3358 if (!((ast_channel_pbx(ast)) ||
3359 (ast_channel_state(ast) == AST_STATE_UP) ||
3360 (ast_channel_state(ast) == AST_STATE_RING))) {
3361 ast_debug(1, "Flash when call not up or ringing\n");
3362 goto winkflashdone;
3363 }
3365 ast_log(LOG_WARNING, "Unable to allocate three-way subchannel\n");
3366 goto winkflashdone;
3367 }
3368
3369 callid_created = ast_callid_threadstorage_auto(&callid);
3370
3371 /*
3372 * Make new channel
3373 *
3374 * We cannot hold the p or ast locks while creating a new
3375 * channel.
3376 */
3378 ast_channel_unlock(ast);
3380 ast_channel_lock(ast);
3382 if (!chan) {
3384 "Cannot allocate new call structure on channel %d\n",
3385 p->channel);
3387 ast_callid_threadstorage_auto_clean(callid, callid_created);
3388 goto winkflashdone;
3389 }
3390 if (p->dahditrcallerid) {
3391 if (!p->origcid_num) {
3393 }
3394 if (!p->origcid_name) {
3396 }
3397 ast_copy_string(p->cid_num, cid_num, sizeof(p->cid_num));
3398 ast_copy_string(p->cid_name, cid_name, sizeof(p->cid_name));
3399 }
3400 /* Swap things around between the three-way and real call */
3402 /* Disable echo canceller for better dialing */
3405 if (res) {
3406 ast_log(LOG_WARNING, "Unable to start dial recall tone on channel %d\n", p->channel);
3407 }
3408 analog_set_new_owner(p, chan);
3409 p->ss_astchan = chan;
3411 ast_log(LOG_WARNING, "Unable to start simple switch on channel %d\n", p->channel);
3414 ast_hangup(chan);
3415 } else {
3416 ast_verb(3, "Started three way call on channel %d\n", p->channel);
3417
3418 /* Start music on hold */
3420 }
3421 ast_callid_threadstorage_auto_clean(callid, callid_created);
3422 }
3423 } else {
3424 /* Already have a 3 way call */
3425 enum analog_sub orig_3way_sub;
3426
3427 /* Need to hold the lock for real-call, private, and 3-way call */
3429 if (!p->subs[ANALOG_SUB_THREEWAY].owner) {
3430 /*
3431 * The 3-way call dissappeared.
3432 * Let's just ignore this flash-hook.
3433 */
3434 ast_log(LOG_NOTICE, "Whoa, the 3-way call disappeared.\n");
3435 goto winkflashdone;
3436 }
3437 orig_3way_sub = ANALOG_SUB_THREEWAY;
3438
3440 /* Call is already up, drop the last person */
3441 ast_debug(1, "Got flash with three way call up, dropping last call on %d\n", p->channel);
3442 /* If the primary call isn't answered yet, use it */
3445 /* Swap back -- we're dropping the real 3-way that isn't finished yet*/
3447 orig_3way_sub = ANALOG_SUB_REAL;
3449 }
3450 /* Drop the last call and stop the conference */
3451 ast_verb(3, "Dropping three-way call on %s\n", ast_channel_name(p->subs[ANALOG_SUB_THREEWAY].owner));
3455 } else {
3456 /* Lets see what we're up to */
3457 if (((ast_channel_pbx(ast)) || (ast_channel_state(ast) == AST_STATE_UP)) &&
3459 ast_verb(3, "Building conference call with %s and %s\n",
3462 /* Put them in the threeway, and flip */
3466 orig_3way_sub = ANALOG_SUB_REAL;
3467 ast_queue_unhold(p->subs[orig_3way_sub].owner);
3469 } else {
3470 ast_verb(3, "Dumping incomplete call on %s\n", ast_channel_name(p->subs[ANALOG_SUB_THREEWAY].owner));
3472 orig_3way_sub = ANALOG_SUB_REAL;
3477 }
3478 }
3479 ast_channel_unlock(p->subs[orig_3way_sub].owner);
3480 }
3481winkflashdone:
3483 break;
3484 case ANALOG_SIG_EM:
3485 case ANALOG_SIG_EM_E1:
3486 case ANALOG_SIG_FEATD:
3487 case ANALOG_SIG_SF:
3488 case ANALOG_SIG_SFWINK:
3490 case ANALOG_SIG_FXSLS:
3491 case ANALOG_SIG_FXSGS:
3492 if (p->dialing) {
3493 ast_debug(1, "Ignoring wink on channel %d\n", p->channel);
3494 } else {
3495 ast_debug(1, "Got wink in weird state %u on channel %d\n", ast_channel_state(ast), p->channel);
3496 }
3497 break;
3499 switch (p->whichwink) {
3500 case 0:
3501 ast_debug(1, "ANI2 set to '%d' and ANI is '%s'\n", ast_channel_caller(p->owner)->ani2,
3504 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%d%s#",
3508 break;
3509 case 1:
3510 ast_copy_string(p->dop.dialstr, p->finaldial, sizeof(p->dop.dialstr));
3511 break;
3512 case 2:
3513 ast_log(LOG_WARNING, "Received unexpected wink on channel of type ANALOG_SIG_FEATDMF_TA\n");
3514 return NULL;
3515 }
3516 p->whichwink++;
3517 /* Fall through */
3518 case ANALOG_SIG_FEATDMF:
3519 case ANALOG_SIG_E911:
3522 case ANALOG_SIG_FEATB:
3525 case ANALOG_SIG_EMWINK:
3526 /* FGD MF and EMWINK *Must* wait for wink */
3527 if (!ast_strlen_zero(p->dop.dialstr)) {
3528 res = analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop);
3529 if (res) {
3530 p->dop.dialstr[0] = '\0';
3531 return NULL;
3532 } else {
3533 ast_debug(1, "Sent deferred digit string on channel %d: %s\n", p->channel, p->dop.dialstr);
3534 }
3535 }
3536 p->dop.dialstr[0] = '\0';
3537 break;
3538 default:
3539 ast_log(LOG_WARNING, "Don't know how to handle ring/off hook for signalling %d\n", p->sig);
3540 }
3541 break;
3543 if (p->inalarm) break;
3545 break;
3546 }
3547 switch (mysig) {
3548 case ANALOG_SIG_FXSLS: /* only interesting for FXS */
3549 case ANALOG_SIG_FXSGS:
3550 case ANALOG_SIG_FXSKS:
3551 case ANALOG_SIG_EM:
3552 case ANALOG_SIG_EM_E1:
3553 case ANALOG_SIG_EMWINK:
3554 case ANALOG_SIG_FEATD:
3555 case ANALOG_SIG_SF:
3556 case ANALOG_SIG_SFWINK:
3558 if (!ast_strlen_zero(p->dop.dialstr)) {
3559 res = analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop);
3560 if (res) {
3561 p->dop.dialstr[0] = '\0';
3562 return NULL;
3563 } else {
3564 ast_debug(1, "Sent deferred digit string on channel %d: %s\n", p->channel, p->dop.dialstr);
3565 }
3566 }
3567 p->dop.dialstr[0] = '\0';
3569 break;
3570 case ANALOG_SIG_FEATDMF:
3572 case ANALOG_SIG_E911:
3575 case ANALOG_SIG_FEATB:
3578 ast_debug(1, "Got hook complete in MF FGD, waiting for wink now on channel %d\n",p->channel);
3579 break;
3580 default:
3581 break;
3582 }
3583 break;
3585 /*
3586 * If we get a Polarity Switch event, this could be
3587 * due to line seizure, remote end connect or remote end disconnect.
3588 *
3589 * Check to see if we should change the polarity state and
3590 * mark the channel as UP or if this is an indication
3591 * of remote end disconnect.
3592 */
3593
3594 if (p->polarityonanswerdelay > 0) {
3595 /* check if event is not too soon after OffHook or Answer */
3597 switch (ast_channel_state(ast)) {
3598 case AST_STATE_DIALING: /*!< Digits (or equivalent) have been dialed */
3599 case AST_STATE_RINGING: /*!< Remote end is ringing */
3600 if (p->answeronpolarityswitch) {
3601 ast_debug(1, "Answering on polarity switch! channel %d\n", p->channel);
3604 if (p->hanguponpolarityswitch) {
3606 }
3607 } else {
3608 ast_debug(1, "Ignore Answer on polarity switch, channel %d\n", p->channel);
3609 }
3610 break;
3611
3612 case AST_STATE_UP: /*!< Line is up */
3613 case AST_STATE_RING: /*!< Line is ringing */
3614 if (p->hanguponpolarityswitch) {
3615 ast_debug(1, "HangingUp on polarity switch! channel %d\n", p->channel);
3616 ast_queue_control_data(ast, AST_CONTROL_PVT_CAUSE_CODE, cause_code, data_size);
3617 ast_channel_hangupcause_hash_set(ast, cause_code, data_size);
3620 } else {
3621 ast_debug(1, "Ignore Hangup on polarity switch, channel %d\n", p->channel);
3622 }
3623 break;
3624
3625 case AST_STATE_DOWN: /*!< Channel is down and available */
3626 case AST_STATE_RESERVED: /*!< Channel is down, but reserved */
3627 case AST_STATE_OFFHOOK: /*!< Channel is off hook */
3628 case AST_STATE_BUSY: /*!< Line is busy */
3629 case AST_STATE_DIALING_OFFHOOK: /*!< Digits (or equivalent) have been dialed while offhook */
3630 case AST_STATE_PRERING: /*!< Channel has detected an incoming call and is waiting for ring */
3631 default:
3633 ast_debug(1, "Ignoring Polarity switch on channel %d, state %u\n", p->channel, ast_channel_state(ast));
3634 }
3635 break;
3636 }
3637
3638 } else {
3639 /* event is too soon after OffHook or Answer */
3640 switch (ast_channel_state(ast)) {
3641 case AST_STATE_DIALING: /*!< Digits (or equivalent) have been dialed */
3642 case AST_STATE_RINGING: /*!< Remote end is ringing */
3643 if (p->answeronpolarityswitch) {
3644 ast_debug(1, "Polarity switch detected but NOT answering (too close to OffHook event) on channel %d, state %u\n", p->channel, ast_channel_state(ast));
3645 }
3646 break;
3647
3648 case AST_STATE_UP: /*!< Line is up */
3649 case AST_STATE_RING: /*!< Line is ringing */
3650 if (p->hanguponpolarityswitch) {
3651 ast_debug(1, "Polarity switch detected but NOT hanging up (too close to Answer event) on channel %d, state %u\n", p->channel, ast_channel_state(ast));
3652 }
3653 break;
3654
3655 default:
3657 ast_debug(1, "Polarity switch detected (too close to previous event) on channel %d, state %u\n", p->channel, ast_channel_state(ast));
3658 }
3659 break;
3660 }
3661 }
3662 }
3663
3664 /* Added more log_debug information below to provide a better indication of what is going on */
3665 ast_debug(1, "Polarity Reversal event occured - DEBUG 2: channel %d, state %u, pol= %d, aonp= %d, honp= %d, pdelay= %d, tv= %" PRIi64 "\n", p->channel, ast_channel_state(ast), p->polarity, p->answeronpolarityswitch, p->hanguponpolarityswitch, p->polarityonanswerdelay, ast_tvdiff_ms(ast_tvnow(), p->polaritydelaytv) );
3666 break;
3667 default:
3668 ast_debug(1, "Dunno what to do with event %d on channel %d\n", res, p->channel);
3669 }
3670 return &p->subs[idx].f;
3671}
#define ast_alloca(size)
call __builtin_alloca to ensure we get gcc builtin semantics
Definition: astmm.h:288
#define ast_strdup(str)
A wrapper for strdup()
Definition: astmm.h:241
#define ast_log
Definition: astobj2.c:42
#define AST_CAUSE_NETWORK_OUT_OF_ORDER
Definition: causes.h:121
#define AST_CAUSE_NO_ANSWER
Definition: causes.h:109
#define AST_CAUSE_NORMAL_CLEARING
Definition: causes.h:106
const char * ast_channel_name(const struct ast_channel *chan)
void ast_channel_rings_set(struct ast_channel *chan, int value)
void ast_hangup(struct ast_channel *chan)
Hang up a channel.
Definition: channel.c:2560
int ast_channel_rings(const struct ast_channel *chan)
#define ast_channel_lock(chan)
Definition: channel.h:2968
int ast_queue_control(struct ast_channel *chan, enum ast_control_frame_type control)
Queue a control frame without payload.
Definition: channel.c:1250
int ast_queue_control_data(struct ast_channel *chan, enum ast_control_frame_type control, const void *data, size_t datalen)
Queue a control frame with payload.
Definition: channel.c:1257
const char * ast_channel_appl(const struct ast_channel *chan)
int ast_queue_hangup_with_cause(struct ast_channel *chan, int cause)
Queue a hangup frame with hangupcause set.
Definition: channel.c:1185
int ast_softhangup(struct ast_channel *chan, int cause)
Softly hangup up a channel.
Definition: channel.c:2490
void ast_channel_hangupcause_hash_set(struct ast_channel *chan, const struct ast_control_pvt_cause_code *cause_code, int datalen)
Sets the HANGUPCAUSE hash and optionally the SIP_CAUSE hash on the given channel.
Definition: channel.c:4365
int ast_queue_unhold(struct ast_channel *chan)
Queue an unhold frame.
Definition: channel.c:1235
int ast_queue_hold(struct ast_channel *chan, const char *musicclass)
Queue a hold frame.
Definition: channel.c:1210
#define AST_CHANNEL_NAME
Definition: channel.h:173
@ AST_SOFTHANGUP_EXPLICIT
Definition: channel.h:1168
@ AST_SOFTHANGUP_DEV
Definition: channel.h:1141
int ast_softhangup_nolock(struct ast_channel *chan, int cause)
Softly hangup up a channel (no channel lock)
Definition: channel.c:2477
struct ast_pbx * ast_channel_pbx(const struct ast_channel *chan)
struct ast_party_caller * ast_channel_caller(struct ast_channel *chan)
#define ast_channel_unlock(chan)
Definition: channel.h:2969
ast_channel_state
ast_channel states
Definition: channelstate.h:35
@ AST_STATE_RING
Definition: channelstate.h:40
@ AST_STATE_DIALING_OFFHOOK
Definition: channelstate.h:44
@ AST_STATE_RINGING
Definition: channelstate.h:41
@ AST_STATE_PRERING
Definition: channelstate.h:45
@ AST_STATE_DOWN
Definition: channelstate.h:36
@ AST_STATE_OFFHOOK
Definition: channelstate.h:38
@ AST_STATE_BUSY
Definition: channelstate.h:43
@ AST_STATE_DIALING
Definition: channelstate.h:39
@ AST_STATE_UP
Definition: channelstate.h:42
@ AST_STATE_RESERVED
Definition: channelstate.h:37
int ast_setstate(struct ast_channel *chan, enum ast_channel_state)
Change the state of a channel.
Definition: channel.c:7408
@ AST_FRAME_NULL
@ AST_FRAME_DTMF_END
@ AST_FRAME_DTMF_BEGIN
@ AST_FRAME_CONTROL
@ AST_CONTROL_RING
@ AST_CONTROL_OFFHOOK
@ AST_CONTROL_ANSWER
@ AST_CONTROL_RINGING
@ AST_CONTROL_FLASH
@ AST_CONTROL_PVT_CAUSE_CODE
struct ast_frame ast_null_frame
Definition: main/frame.c:79
void ast_callid_threadstorage_auto_clean(ast_callid callid, int callid_created)
Use in conjunction with ast_callid_threadstorage_auto. Cleans up the references and if the callid was...
Definition: logger.c:2378
#define ast_debug(level,...)
Log a DEBUG message.
unsigned int ast_callid
int ast_callid_threadstorage_auto(ast_callid *callid)
Checks thread storage for a callid and stores a reference if it exists. If not, then a new one will b...
Definition: logger.c:2356
#define LOG_ERROR
#define ast_verb(level,...)
#define LOG_NOTICE
#define LOG_WARNING
#define NULL
Definition: resample.c:96
static void analog_publish_channel_alarm_clear(int channel)
Definition: sig_analog.c:2760
static void analog_set_alarm(struct analog_pvt *p, int in_alarm)
Definition: sig_analog.c:903
static int analog_alloc_sub(struct analog_pvt *p, enum analog_sub x)
Definition: sig_analog.c:368
static int analog_send_callerid(struct analog_pvt *p, int cwcid, struct ast_party_caller *caller)
Definition: sig_analog.c:391
static int analog_update_conf(struct analog_pvt *p)
Definition: sig_analog.c:743
static void analog_unlock_private(struct analog_pvt *p)
Definition: sig_analog.c:560
static int analog_unalloc_sub(struct analog_pvt *p, enum analog_sub x)
Definition: sig_analog.c:381
static int analog_is_off_hook(struct analog_pvt *p)
Definition: sig_analog.c:489
static int analog_dial_digits(struct analog_pvt *p, enum analog_sub sub, struct analog_dialoperation *dop)
Definition: sig_analog.c:521
static void analog_set_new_owner(struct analog_pvt *p, struct ast_channel *new_owner)
Definition: sig_analog.c:446
static struct ast_channel * analog_new_ast_channel(struct analog_pvt *p, int state, int startpbx, enum analog_sub sub, const struct ast_channel *requestor)
Definition: sig_analog.c:454
static void * __analog_ss_thread(void *data)
Definition: sig_analog.c:1740
static int analog_attempt_transfer(struct analog_pvt *p)
Definition: sig_analog.c:710
static void analog_set_needringing(struct analog_pvt *p, int value)
Definition: sig_analog.c:623
static int analog_check_waitingfordt(struct analog_pvt *p)
Definition: sig_analog.c:926
static int analog_train_echocanceller(struct analog_pvt *p)
Definition: sig_analog.c:481
static void analog_set_dialing(struct analog_pvt *p, int is_dialing)
Definition: sig_analog.c:895
static int analog_ring(struct analog_pvt *p)
Definition: sig_analog.c:497
static int analog_check_for_conference(struct analog_pvt *p)
Definition: sig_analog.c:545
void analog_handle_dtmf(struct analog_pvt *p, struct ast_channel *ast, enum analog_sub idx, struct ast_frame **dest)
Definition: sig_analog.c:1593
static void analog_set_ringtimeout(struct analog_pvt *p, int ringt)
Definition: sig_analog.c:911
static char * analog_event2str(enum analog_event event)
Definition: sig_analog.c:265
static void analog_lock_sub_owner(struct analog_pvt *pvt, enum analog_sub sub_idx)
Definition: sig_analog.c:599
static void analog_lock_private(struct analog_pvt *p)
Definition: sig_analog.c:567
static int analog_have_progressdetect(struct analog_pvt *p)
Definition: sig_analog.c:210
#define analog_get_index(ast, p, nullok)
Definition: sig_analog.c:407
static int analog_confmute(struct analog_pvt *p, int mute)
Definition: sig_analog.c:958
static void analog_answer_polarityswitch(struct analog_pvt *p)
Definition: sig_analog.c:645
static int analog_on_hook(struct analog_pvt *p)
Definition: sig_analog.c:529
static void analog_get_and_handle_alarms(struct analog_pvt *p)
Definition: sig_analog.c:1690
static int analog_stop_callwait(struct analog_pvt *p)
Definition: sig_analog.c:862
static void analog_set_pulsedial(struct analog_pvt *p, int flag)
Definition: sig_analog.c:966
static int analog_has_voicemail(struct analog_pvt *p)
Definition: sig_analog.c:682
static int analog_off_hook(struct analog_pvt *p)
Definition: sig_analog.c:615
static int analog_play_tone(struct analog_pvt *p, enum analog_sub sub, enum analog_tone tone)
Definition: sig_analog.c:438
#define MIN_MS_SINCE_FLASH
Definition: sig_analog.c:64
static int analog_get_event(struct analog_pvt *p)
Definition: sig_analog.c:194
static int analog_set_echocanceller(struct analog_pvt *p, int enable)
Definition: sig_analog.c:473
static void analog_set_inthreeway(struct analog_pvt *p, enum analog_sub sub, int inthreeway)
Definition: sig_analog.c:982
#define POLARITY_IDLE
Definition: sig_analog.c:62
static int analog_check_confirmanswer(struct analog_pvt *p)
Definition: sig_analog.c:942
static int analog_is_dialing(struct analog_pvt *p, enum analog_sub index)
Definition: sig_analog.c:690
static void analog_cancel_cidspill(struct analog_pvt *p)
Definition: sig_analog.c:951
static void analog_swap_subs(struct analog_pvt *p, enum analog_sub a, enum analog_sub b)
Definition: sig_analog.c:348
#define POLARITY_REV
Definition: sig_analog.c:63
static int analog_get_sub_fd(struct analog_pvt *p, enum analog_sub sub)
Definition: sig_analog.c:1705
static void analog_start_polarityswitch(struct analog_pvt *p)
Definition: sig_analog.c:639
@ ANALOG_DIALMODE_PULSE
Definition: sig_analog.h:121
@ ANALOG_DIALMODE_BOTH
Definition: sig_analog.h:120
@ ANALOG_EVENT_HOOKCOMPLETE
Definition: sig_analog.h:89
@ ANALOG_EVENT_DTMFDOWN
Definition: sig_analog.h:104
@ ANALOG_EVENT_RINGEROFF
Definition: sig_analog.h:88
@ ANALOG_EVENT_PULSE_START
Definition: sig_analog.h:90
@ ANALOG_EVENT_TX_CED_DETECTED
Definition: sig_analog.h:97
@ ANALOG_EVENT_RINGBEGIN
Definition: sig_analog.h:92
@ ANALOG_EVENT_ONHOOK
Definition: sig_analog.h:81
@ ANALOG_EVENT_EC_DISABLED
Definition: sig_analog.h:93
@ ANALOG_EVENT_WINKFLASH
Definition: sig_analog.h:83
@ ANALOG_EVENT_PULSEDIGIT
Definition: sig_analog.h:103
@ ANALOG_EVENT_RINGERON
Definition: sig_analog.h:87
@ ANALOG_EVENT_RX_CED_DETECTED
Definition: sig_analog.h:98
@ ANALOG_EVENT_ALARM
Definition: sig_analog.h:84
@ ANALOG_EVENT_DIALCOMPLETE
Definition: sig_analog.h:86
@ ANALOG_EVENT_EC_NLP_ENABLED
Definition: sig_analog.h:100
@ ANALOG_EVENT_POLARITY
Definition: sig_analog.h:91
@ ANALOG_EVENT_DTMFUP
Definition: sig_analog.h:105
@ ANALOG_EVENT_EC_NLP_DISABLED
Definition: sig_analog.h:99
@ ANALOG_EVENT_RINGOFFHOOK
Definition: sig_analog.h:82
@ ANALOG_EVENT_NOALARM
Definition: sig_analog.h:85
@ ANALOG_DIAL_OP_REPLACE
Definition: sig_analog.h:134
analog_sub
Definition: sig_analog.h:108
@ ANALOG_SUB_THREEWAY
Definition: sig_analog.h:111
@ ANALOG_SUB_REAL
Definition: sig_analog.h:109
@ ANALOG_SUB_CALLWAIT
Definition: sig_analog.h:110
@ ANALOG_SIG_FEATD
Definition: sig_analog.h:56
@ ANALOG_SIG_FEATDMF_TA
Definition: sig_analog.h:66
@ ANALOG_SIG_FGC_CAMAMF
Definition: sig_analog.h:60
@ ANALOG_SIG_FXOLS
Definition: sig_analog.h:47
@ ANALOG_SIG_FEATDMF
Definition: sig_analog.h:57
@ ANALOG_SIG_EM_E1
Definition: sig_analog.h:55
@ ANALOG_SIG_EMWINK
Definition: sig_analog.h:53
@ ANALOG_SIG_FXOKS
Definition: sig_analog.h:48
@ ANALOG_SIG_SF
Definition: sig_analog.h:63
@ ANALOG_SIG_FGC_CAMA
Definition: sig_analog.h:59
@ ANALOG_SIG_EM
Definition: sig_analog.h:54
@ ANALOG_SIG_FXOGS
Definition: sig_analog.h:49
@ ANALOG_SIG_SF_FEATB
Definition: sig_analog.h:67
@ ANALOG_SIG_SF_FEATDMF
Definition: sig_analog.h:65
@ ANALOG_SIG_SFWINK
Definition: sig_analog.h:62
@ ANALOG_SIG_E911
Definition: sig_analog.h:58
@ ANALOG_SIG_FEATB
Definition: sig_analog.h:61
@ ANALOG_SIG_SF_FEATD
Definition: sig_analog.h:64
@ ANALOG_TONE_CONGESTION
Definition: sig_analog.h:73
@ ANALOG_TONE_DIALTONE
Definition: sig_analog.h:74
@ ANALOG_TONE_DIALRECALL
Definition: sig_analog.h:75
@ ANALOG_TONE_STUTTER
Definition: sig_analog.h:72
#define S_COR(a, b, c)
returns the equivalent of logic or for strings, with an additional boolean check: second one if not e...
Definition: strings.h:87
static force_inline int attribute_pure ast_strlen_zero(const char *s)
Definition: strings.h:65
void ast_copy_string(char *dst, const char *src, size_t size)
Size-limited null-terminating string copy.
Definition: strings.h:425
char dialdest[256]
Definition: sig_analog.h:362
unsigned int dahditrcallerid
Definition: sig_analog.h:296
struct analog_dialoperation dop
Definition: sig_analog.h:280
int polarityonanswerdelay
Definition: sig_analog.h:324
char cid_num[AST_MAX_EXTENSION]
Definition: sig_analog.h:328
char * origcid_name
Definition: sig_analog.h:368
struct timeval flashtime
Definition: sig_analog.h:364
unsigned int outgoing
Definition: sig_analog.h:340
int whichwink
Definition: sig_analog.h:365
char * origcid_num
Definition: sig_analog.h:367
enum analog_sigtype outsigmod
Definition: sig_analog.h:320
unsigned int answeronpolarityswitch
Definition: sig_analog.h:291
unsigned int threewaycalling
Definition: sig_analog.h:303
int echotraining
Definition: sig_analog.h:322
int msgstate
-1 = unknown, 0 = no messages, 1 = new messages available
Definition: sig_analog.h:284
int onhooktime
Definition: sig_analog.h:281
struct timeval polaritydelaytv
Definition: sig_analog.h:361
unsigned int hanguponpolarityswitch
Definition: sig_analog.h:297
int cidrings
Definition: sig_analog.h:358
unsigned int callwaitcas
TRUE if Call Waiting (CW) CPE Alert Signal (CAS) is being sent.
Definition: sig_analog.h:348
unsigned int echobreak
Definition: sig_analog.h:338
unsigned int cshactive
Definition: sig_analog.h:334
struct ast_channel * owner
Definition: sig_analog.h:277
enum analog_sigtype sig
Definition: sig_analog.h:273
unsigned int dialednone
Definition: sig_analog.h:335
char echorest[20]
Definition: sig_analog.h:359
int ringt_base
Definition: sig_analog.h:376
int fxsoffhookstate
Definition: sig_analog.h:282
enum analog_dialmode dialmode
Definition: sig_analog.h:321
struct analog_subchannel subs[3]
Definition: sig_analog.h:279
char finaldial[64]
Definition: sig_analog.h:366
unsigned int transfer
Definition: sig_analog.h:305
unsigned int transfertobusy
Definition: sig_analog.h:306
unsigned int inalarm
Definition: sig_analog.h:341
char cid_name[AST_MAX_EXTENSION]
Definition: sig_analog.h:329
unsigned int calledsubscriberheld
Definition: sig_analog.h:292
char mohsuggest[MAX_MUSICCLASS]
Definition: sig_analog.h:327
int polarity
Definition: sig_analog.h:360
struct ast_channel * ss_astchan
Definition: sig_analog.h:372
unsigned int dialing
Definition: sig_analog.h:336
struct ast_party_caller caller
Definition: sig_analog.h:355
struct ast_frame f
Definition: sig_analog.h:265
unsigned int inthreeway
Definition: sig_analog.h:266
struct ast_channel * owner
Definition: sig_analog.h:264
Main Channel structure associated with a channel.
char chan_name[AST_CHANNEL_NAME]
Data structure associated with a single frame of data.
struct ast_frame_subclass subclass
union ast_frame::@226 data
enum ast_frame_type frametype
const char * src
struct ast_party_id id
Caller party ID.
Definition: channel.h:422
int ani2
Automatic Number Identification 2 (Info Digits)
Definition: channel.h:435
struct ast_party_id ani
Automatic Number Identification (ANI)
Definition: channel.h:429
struct ast_party_name name
Subscriber name.
Definition: channel.h:342
struct ast_party_number number
Subscriber phone number.
Definition: channel.h:344
unsigned char valid
TRUE if the name information is valid/present.
Definition: channel.h:281
char * str
Subscriber name (Malloced)
Definition: channel.h:266
unsigned char valid
TRUE if the number information is valid/present.
Definition: channel.h:299
char * str
Subscriber phone number (Malloced)
Definition: channel.h:293
static struct test_val c
int64_t ast_tvdiff_ms(struct timeval end, struct timeval start)
Computes the difference (in milliseconds) between two struct timeval instances.
Definition: time.h:107
struct timeval ast_tvnow(void)
Returns current timeval. Meant to replace calls to gettimeofday().
Definition: time.h:159
#define ast_pthread_create_detached(a, b, c, d)
Definition: utils.h:588

References __analog_ss_thread(), analog_alloc_sub(), analog_answer_polarityswitch(), analog_attempt_transfer(), analog_cancel_cidspill(), analog_check_confirmanswer(), analog_check_for_conference(), analog_check_waitingfordt(), analog_confmute(), analog_dial_digits(), ANALOG_DIAL_OP_REPLACE, ANALOG_DIALMODE_BOTH, ANALOG_DIALMODE_PULSE, analog_event2str(), ANALOG_EVENT_ALARM, ANALOG_EVENT_DIALCOMPLETE, ANALOG_EVENT_DTMFDOWN, ANALOG_EVENT_DTMFUP, ANALOG_EVENT_EC_DISABLED, ANALOG_EVENT_EC_NLP_DISABLED, ANALOG_EVENT_EC_NLP_ENABLED, ANALOG_EVENT_HOOKCOMPLETE, ANALOG_EVENT_NOALARM, ANALOG_EVENT_ONHOOK, ANALOG_EVENT_POLARITY, ANALOG_EVENT_PULSE_START, ANALOG_EVENT_PULSEDIGIT, ANALOG_EVENT_RINGBEGIN, ANALOG_EVENT_RINGEROFF, ANALOG_EVENT_RINGERON, ANALOG_EVENT_RINGOFFHOOK, ANALOG_EVENT_RX_CED_DETECTED, ANALOG_EVENT_TX_CED_DETECTED, ANALOG_EVENT_WINKFLASH, analog_get_and_handle_alarms(), analog_get_event(), analog_get_index, analog_get_sub_fd(), analog_handle_dtmf(), analog_has_voicemail(), analog_have_progressdetect(), analog_is_dialing(), analog_is_off_hook(), analog_lock_private(), analog_lock_sub_owner(), analog_new_ast_channel(), analog_off_hook(), analog_on_hook(), analog_play_tone(), analog_publish_channel_alarm_clear(), analog_ring(), analog_send_callerid(), analog_set_alarm(), analog_set_dialing(), analog_set_echocanceller(), analog_set_inthreeway(), analog_set_needringing(), analog_set_new_owner(), analog_set_pulsedial(), analog_set_ringtimeout(), ANALOG_SIG_E911, ANALOG_SIG_EM, ANALOG_SIG_EM_E1, ANALOG_SIG_EMWINK, ANALOG_SIG_FEATB, ANALOG_SIG_FEATD, ANALOG_SIG_FEATDMF, ANALOG_SIG_FEATDMF_TA, ANALOG_SIG_FGC_CAMA, ANALOG_SIG_FGC_CAMAMF, ANALOG_SIG_FXOGS, ANALOG_SIG_FXOKS, ANALOG_SIG_FXOLS, ANALOG_SIG_FXSGS, ANALOG_SIG_FXSKS, ANALOG_SIG_FXSLS, ANALOG_SIG_SF, ANALOG_SIG_SF_FEATB, ANALOG_SIG_SF_FEATD, ANALOG_SIG_SF_FEATDMF, ANALOG_SIG_SFWINK, analog_start_polarityswitch(), analog_stop_callwait(), ANALOG_SUB_CALLWAIT, ANALOG_SUB_REAL, ANALOG_SUB_THREEWAY, analog_swap_subs(), ANALOG_TONE_CONGESTION, ANALOG_TONE_DIALRECALL, ANALOG_TONE_DIALTONE, ANALOG_TONE_STUTTER, analog_train_echocanceller(), analog_unalloc_sub(), analog_unlock_private(), analog_update_conf(), ast_party_caller::ani, ast_party_caller::ani2, analog_pvt::answeronpolarityswitch, ast_alloca, ast_callid_threadstorage_auto(), ast_callid_threadstorage_auto_clean(), ast_control_pvt_cause_code::ast_cause, AST_CAUSE_NETWORK_OUT_OF_ORDER, AST_CAUSE_NO_ANSWER, AST_CAUSE_NORMAL_CLEARING, ast_channel_appl(), ast_channel_caller(), ast_channel_hangupcause_hash_set(), ast_channel_lock, AST_CHANNEL_NAME, ast_channel_name(), ast_channel_pbx(), ast_channel_rings(), ast_channel_rings_set(), ast_channel_unlock, AST_CONTROL_ANSWER, AST_CONTROL_FLASH, AST_CONTROL_OFFHOOK, AST_CONTROL_PVT_CAUSE_CODE, AST_CONTROL_RING, AST_CONTROL_RINGING, ast_copy_string(), ast_debug, AST_FRAME_CONTROL, AST_FRAME_DTMF_BEGIN, AST_FRAME_DTMF_END, AST_FRAME_NULL, ast_hangup(), ast_log, ast_null_frame, ast_pthread_create_detached, ast_queue_control(), ast_queue_control_data(), ast_queue_hangup_with_cause(), ast_queue_hold(), ast_queue_unhold(), ast_setstate(), ast_softhangup(), AST_SOFTHANGUP_DEV, AST_SOFTHANGUP_EXPLICIT, ast_softhangup_nolock(), AST_STATE_BUSY, AST_STATE_DIALING, AST_STATE_DIALING_OFFHOOK, AST_STATE_DOWN, AST_STATE_OFFHOOK, AST_STATE_PRERING, AST_STATE_RESERVED, AST_STATE_RING, AST_STATE_RINGING, AST_STATE_UP, ast_strdup, ast_strlen_zero(), ast_tvdiff_ms(), ast_tvnow(), ast_verb, c, analog_pvt::calledsubscriberheld, analog_pvt::caller, analog_pvt::callwaitcas, ast_control_pvt_cause_code::chan_name, analog_pvt::channel, analog_pvt::cid_name, analog_pvt::cid_num, analog_pvt::cidrings, ast_control_pvt_cause_code::code, analog_pvt::cshactive, analog_pvt::dahditrcallerid, ast_frame::data, ast_frame::datalen, analog_pvt::dialdest, analog_pvt::dialednone, analog_pvt::dialing, analog_pvt::dialmode, analog_dialoperation::dialstr, analog_pvt::dop, analog_pvt::echobreak, analog_pvt::echorest, analog_pvt::echotraining, analog_subchannel::f, analog_pvt::finaldial, analog_pvt::flashtime, ast_frame::frametype, analog_pvt::fxsoffhookstate, analog_pvt::hanguponpolarityswitch, ast_party_caller::id, analog_pvt::inalarm, ast_frame_subclass::integer, analog_subchannel::inthreeway, LOG_ERROR, LOG_NOTICE, LOG_WARNING, ast_frame::mallocd, MIN_MS_SINCE_FLASH, analog_pvt::mohsuggest, analog_pvt::msgstate, ast_party_id::name, NULL, ast_party_id::number, ast_frame::offset, analog_pvt::onhooktime, analog_dialoperation::op, analog_pvt::origcid_name, analog_pvt::origcid_num, analog_pvt::outgoing, analog_pvt::outsigmod, analog_subchannel::owner, analog_pvt::owner, analog_pvt::polarity, POLARITY_IDLE, POLARITY_REV, analog_pvt::polaritydelaytv, analog_pvt::polarityonanswerdelay, ast_frame::ptr, analog_pvt::ringt_base, S_COR, ast_frame::samples, analog_pvt::sig, ast_frame::src, analog_pvt::ss_astchan, ast_party_name::str, ast_party_number::str, ast_frame::subclass, analog_pvt::subs, analog_pvt::threewaycalling, analog_pvt::transfer, analog_pvt::transfertobusy, ast_party_name::valid, ast_party_number::valid, and analog_pvt::whichwink.

Referenced by analog_exception().

◆ __analog_ss_thread()

static void * __analog_ss_thread ( void *  data)
static

Definition at line 1740 of file sig_analog.c.

1741{
1742 struct analog_pvt *p = data;
1743 struct ast_channel *chan = p->ss_astchan;
1744 char exten[AST_MAX_EXTENSION] = "";
1745 char exten2[AST_MAX_EXTENSION] = "";
1746 char dtmfcid[300];
1747 char dtmfbuf[300];
1748 char namebuf[ANALOG_MAX_CID];
1749 char numbuf[ANALOG_MAX_CID];
1750 char *name = NULL, *number = NULL;
1751 int flags = 0;
1752 struct ast_smdi_md_message *smdi_msg = NULL;
1753 int timeout;
1754 int getforward = 0;
1755 char *s1, *s2;
1756 int len = 0;
1757 int res;
1758 int idx;
1759 ast_callid callid;
1760 RAII_VAR(struct ast_features_pickup_config *, pickup_cfg, NULL, ao2_cleanup);
1761 const char *pickupexten;
1762
1764
1765 ast_debug(1, "%s %d\n", __FUNCTION__, p->channel);
1766
1767 ast_assert(chan != NULL);
1768
1769 if ((callid = ast_channel_callid(chan))) {
1771 }
1772
1773 /* in the bizarre case where the channel has become a zombie before we
1774 even get started here, abort safely
1775 */
1776 if (!ast_channel_tech_pvt(chan)) {
1777 ast_log(LOG_WARNING, "Channel became a zombie before simple switch could be started (%s)\n", ast_channel_name(chan));
1778 ast_hangup(chan);
1779 goto quit;
1780 }
1781
1782 ast_verb(3, "Starting simple switch on '%s'\n", ast_channel_name(chan));
1783 idx = analog_get_index(chan, p, 0);
1784 if (idx < 0) {
1785 ast_hangup(chan);
1786 goto quit;
1787 }
1788
1789 ast_channel_lock(chan);
1790 pickup_cfg = ast_get_chan_features_pickup_config(chan);
1791 if (!pickup_cfg) {
1792 ast_log(LOG_ERROR, "Unable to retrieve pickup configuration options. Unable to detect call pickup extension\n");
1793 pickupexten = "";
1794 } else {
1795 pickupexten = ast_strdupa(pickup_cfg->pickupexten);
1796 }
1797 ast_channel_unlock(chan);
1798
1800 switch (p->sig) {
1801 case ANALOG_SIG_FEATD:
1802 case ANALOG_SIG_FEATDMF:
1804 case ANALOG_SIG_E911:
1806 case ANALOG_SIG_FEATB:
1807 case ANALOG_SIG_EMWINK:
1811 case ANALOG_SIG_SFWINK:
1812 if (analog_wink(p, idx))
1813 goto quit;
1814 /* Fall through */
1815 case ANALOG_SIG_EM:
1816 case ANALOG_SIG_EM_E1:
1817 case ANALOG_SIG_SF:
1819 res = analog_play_tone(p, idx, -1);
1820
1822
1823 /* set digit mode appropriately */
1824 if (ANALOG_NEED_MFDETECT(p)) {
1826 } else {
1828 }
1829
1830 memset(dtmfbuf, 0, sizeof(dtmfbuf));
1831 /* Wait for the first digit only if immediate=no */
1832 if (!p->immediate) {
1833 /* Wait for the first digit (up to 5 seconds). */
1834 res = ast_waitfordigit(chan, 5000);
1835 } else {
1836 res = 0;
1837 }
1838 if (res > 0) {
1839 /* save first char */
1840 dtmfbuf[0] = res;
1841 switch (p->sig) {
1842 case ANALOG_SIG_FEATD:
1844 res = analog_my_getsigstr(chan, dtmfbuf + 1, "*", 3000);
1845 if (res > 0) {
1846 res = analog_my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "*", 3000);
1847 }
1848 if (res < 1) {
1850 }
1851 break;
1853 res = analog_my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
1854 if (res < 1) {
1856 }
1857 if (analog_wink(p, idx)) {
1858 goto quit;
1859 }
1860 dtmfbuf[0] = 0;
1861 /* Wait for the first digit (up to 5 seconds). */
1862 res = ast_waitfordigit(chan, 5000);
1863 if (res <= 0) {
1864 break;
1865 }
1866 dtmfbuf[0] = res;
1867 /* fall through intentionally */
1868 case ANALOG_SIG_FEATDMF:
1869 case ANALOG_SIG_E911:
1872 res = analog_my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
1873 /* if international caca, do it again to get real ANO */
1874 if ((p->sig == ANALOG_SIG_FEATDMF) && (dtmfbuf[1] != '0')
1875 && (strlen(dtmfbuf) != 14)) {
1876 if (analog_wink(p, idx)) {
1877 goto quit;
1878 }
1879 dtmfbuf[0] = 0;
1880 /* Wait for the first digit (up to 5 seconds). */
1881 res = ast_waitfordigit(chan, 5000);
1882 if (res <= 0) {
1883 break;
1884 }
1885 dtmfbuf[0] = res;
1886 res = analog_my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
1887 }
1888 if (res > 0) {
1889 /* if E911, take off hook */
1890 if (p->sig == ANALOG_SIG_E911) {
1891 analog_off_hook(p);
1892 }
1893 }
1894 if (res < 1) {
1896 }
1897 break;
1898 case ANALOG_SIG_FEATB:
1900 res = analog_my_getsigstr(chan, dtmfbuf + 1, "#", 3000);
1901 if (res < 1) {
1903 }
1904 break;
1905 case ANALOG_SIG_EMWINK:
1906 /* if we received a '*', we are actually receiving Feature Group D
1907 dial syntax, so use that mode; otherwise, fall through to normal
1908 mode
1909 */
1910 if (res == '*') {
1911 res = analog_my_getsigstr(chan, dtmfbuf + 1, "*", 3000);
1912 if (res > 0) {
1913 res = analog_my_getsigstr(chan, dtmfbuf + strlen(dtmfbuf), "*", 3000);
1914 }
1915 if (res < 1) {
1917 }
1918 break;
1919 }
1920 default:
1921 /* If we got the first digit, get the rest */
1922 len = 1;
1923 dtmfbuf[len] = '\0';
1924 while ((len < AST_MAX_EXTENSION-1) && ast_matchmore_extension(chan, ast_channel_context(chan), dtmfbuf, 1, p->cid_num)) {
1925 if (ast_exists_extension(chan, ast_channel_context(chan), dtmfbuf, 1, p->cid_num)) {
1926 timeout = analog_get_matchdigit_timeout(p);
1927 } else {
1928 timeout = analog_get_interdigit_timeout(p);
1929 }
1930 res = ast_waitfordigit(chan, timeout);
1931 if (res < 0) {
1932 ast_debug(1, "waitfordigit returned < 0...\n");
1933 ast_hangup(chan);
1934 goto quit;
1935 } else if (res) {
1936 dtmfbuf[len++] = res;
1937 dtmfbuf[len] = '\0';
1938 } else {
1939 break;
1940 }
1941 }
1942 break;
1943 }
1944 }
1945 if (res == -1) {
1946 ast_log(LOG_WARNING, "getdtmf on channel %d: %s\n", p->channel, strerror(errno));
1947 ast_hangup(chan);
1948 goto quit;
1949 } else if (res < 0) {
1950 ast_debug(1, "Got hung up before digits finished\n");
1951 ast_hangup(chan);
1952 goto quit;
1953 }
1954
1955 if (p->sig == ANALOG_SIG_FGC_CAMA || p->sig == ANALOG_SIG_FGC_CAMAMF) {
1956 /* This if block is where we process ANI for CAMA */
1957
1958 char anibuf[100];
1959 struct ast_party_caller *caller;
1960
1961 /* cnoffset is the point at which we pull the calling number out
1962 * of anibuf. Must be the number of ani_info_digits + 1 to account
1963 * for the KP, which is considered a digit. */
1964
1965 /* The 1XB with ANI-B will send a full 10 digits
1966 * or 2 digits in case of ANI failure.
1967 * (CD-95811-01 Section II, page 10)
1968 * 10 digit string example: *08320123#
1969 * 2 digit string example: *2
1970 * KP (*) and ST (#) are considered to be digits */
1971
1972 int cnoffset = p->ani_info_digits + 1;
1973 ast_debug(1, "cnoffset: %d\n", cnoffset);
1974
1975 /* This is how long to wait before the wink to start ANI spill
1976 * Pulled from chan_dahdi.conf, default is 1000ms */
1977 if (ast_safe_sleep(chan,p->ani_wink_time) == -1) {
1978 ast_hangup(chan);
1979 goto quit;
1980 }
1981 analog_off_hook(p);
1982 ast_debug(1, "Sent wink to signal ANI start\n");
1984
1985 /* ani_timeout is configured in chan_dahdi.conf. default is 10000ms.
1986 * ST, STP, ST2P, ST3P can all signal transmission complete, regardless of timeout */
1987 res = analog_my_getsigstr(chan, anibuf, "#ABC", p->ani_timeout);
1988
1989 /* so we can work with the ani buffer */
1990 pbx_builtin_setvar_helper(chan, "ANIBUF", anibuf);
1991
1992 /* as long as we get a terminating pulse OR the length of ANI buffer is at least >=2, we can treat
1993 * this as a complete spill for the purposes of setting anistart */
1994 if ((res > 0) || (strlen(anibuf) >= 2)) {
1995 char anistart[2] = "X";
1996 char f[101] = {0};
1997 if (strchr("#ABC", anibuf[strlen(anibuf) - 1])) {
1998 anistart[0] = anibuf[strlen(anibuf) - 1];
1999 anibuf[strlen(anibuf) - 1] = 0;
2000 }
2001 ast_set_callerid(chan, anibuf + cnoffset, NULL, anibuf + cnoffset);
2002
2003 caller = ast_channel_caller(chan);
2004 strncpy(f, &(anibuf[1]), MIN((int)(p->ani_info_digits), sizeof(f)-1));
2005 caller->ani2 = atoi(f);
2006
2007 anibuf[cnoffset] = 0;
2008
2009 /* so we can work with the different start pulses as used in ANI-D */
2010 pbx_builtin_setvar_helper(chan, "ANISTART", anistart);
2011 /* so we can use our ANI INFO digits in our dialplan */
2012 pbx_builtin_setvar_helper(chan, "ANI2", anibuf + 1);
2013 }
2015 }
2016
2017 ast_copy_string(exten, dtmfbuf, sizeof(exten));
2018 if (ast_strlen_zero(exten)) {
2019 ast_copy_string(exten, "s", sizeof(exten));
2020 }
2021 if (p->sig == ANALOG_SIG_FEATD || p->sig == ANALOG_SIG_EMWINK) {
2022 /* Look for Feature Group D on all E&M Wink and Feature Group D trunks */
2023 if (exten[0] == '*') {
2024 char *stringp=NULL;
2025 ast_copy_string(exten2, exten, sizeof(exten2));
2026 /* Parse out extension and callerid */
2027 stringp=exten2 +1;
2028 s1 = strsep(&stringp, "*");
2029 s2 = strsep(&stringp, "*");
2030 if (s2) {
2031 if (!ast_strlen_zero(p->cid_num)) {
2032 ast_set_callerid(chan, p->cid_num, NULL, p->cid_num);
2033 } else {
2034 ast_set_callerid(chan, s1, NULL, s1);
2035 }
2036 ast_copy_string(exten, s2, sizeof(exten));
2037 } else {
2038 ast_copy_string(exten, s1, sizeof(exten));
2039 }
2040 } else if (p->sig == ANALOG_SIG_FEATD) {
2041 ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d. Assuming E&M Wink instead\n", p->channel);
2042 }
2043 }
2044 if ((p->sig == ANALOG_SIG_FEATDMF) || (p->sig == ANALOG_SIG_FEATDMF_TA)) {
2045 if (exten[0] == '*') {
2046 char *stringp=NULL;
2047 struct ast_party_caller *caller;
2048
2049 ast_copy_string(exten2, exten, sizeof(exten2));
2050 /* Parse out extension and callerid */
2051 stringp=exten2 +1;
2052 s1 = strsep(&stringp, "#");
2053 s2 = strsep(&stringp, "#");
2054 if (s2) {
2055 if (!ast_strlen_zero(p->cid_num)) {
2056 ast_set_callerid(chan, p->cid_num, NULL, p->cid_num);
2057 } else {
2058 if (*(s1 + 2)) {
2059 ast_set_callerid(chan, s1 + 2, NULL, s1 + 2);
2060 }
2061 }
2062 ast_copy_string(exten, s2 + 1, sizeof(exten));
2063 } else {
2064 ast_copy_string(exten, s1 + 2, sizeof(exten));
2065 }
2066
2067 /* The first two digits are ani2 information. */
2068 caller = ast_channel_caller(chan);
2069 s1[2] = '\0';
2070 caller->ani2 = atoi(s1);
2071 } else {
2072 ast_log(LOG_WARNING, "Got a non-Feature Group D input on channel %d. Assuming E&M Wink instead\n", p->channel);
2073 }
2074 }
2075 if ((p->sig == ANALOG_SIG_E911) || (p->sig == ANALOG_SIG_FGC_CAMAMF)) {
2076 if (exten[0] == '*') {
2077 char *stringp=NULL;
2078 ast_copy_string(exten2, exten, sizeof(exten2));
2079 /* Parse out extension and callerid */
2080 stringp=exten2 +1;
2081 s1 = strsep(&stringp, "#");
2082 s2 = strsep(&stringp, "#");
2083 if (s2 && (*(s2 + 1) == '0')) {
2084 if (*(s2 + 2)) {
2085 ast_set_callerid(chan, s2 + 2, NULL, s2 + 2);
2086 }
2087 }
2088 if (s1) {
2089 ast_copy_string(exten, s1, sizeof(exten));
2090 } else {
2091 ast_copy_string(exten, "911", sizeof(exten));
2092 }
2093 } else {
2094 ast_log(LOG_WARNING, "A KP was expected to start signaling for Feature Group C CAMA-MF, but we got something else. Received: %s on channel %d\n", exten, p->channel);
2095 }
2096 }
2097 if (p->sig == ANALOG_SIG_FEATB) {
2098 if (exten[0] == '*') {
2099 char *stringp=NULL;
2100 ast_copy_string(exten2, exten, sizeof(exten2));
2101 /* Parse out extension and callerid */
2102 stringp=exten2 +1;
2103 s1 = strsep(&stringp, "#");
2104 ast_copy_string(exten, exten2 + 1, sizeof(exten));
2105 } else {
2106 ast_log(LOG_WARNING, "A KP was expected to start signaling for Feature Group B, but we got something else. Received: %s on channel %d\n", exten, p->channel);
2107 }
2108 }
2109 if ((p->sig == ANALOG_SIG_FEATDMF) || (p->sig == ANALOG_SIG_FEATDMF_TA)) {
2110 analog_wink(p, idx);
2111 /*
2112 * Some switches require a minimum guard time between the last
2113 * FGD wink and something that answers immediately. This
2114 * ensures it.
2115 */
2116 if (ast_safe_sleep(chan, 100)) {
2117 ast_hangup(chan);
2118 goto quit;
2119 }
2120 }
2122
2124
2125 if (ast_exists_extension(chan, ast_channel_context(chan), exten, 1,
2126 ast_channel_caller(chan)->id.number.valid ? ast_channel_caller(chan)->id.number.str : NULL)) {
2127 ast_channel_exten_set(chan, exten);
2129 res = ast_pbx_run(chan);
2130 if (res) {
2131 ast_log(LOG_WARNING, "PBX exited non-zero\n");
2133 }
2134 goto quit;
2135 } else {
2136 ast_verb(3, "Unknown extension '%s' in context '%s' requested\n", exten, ast_channel_context(chan));
2137 sleep(2);
2138 res = analog_play_tone(p, idx, ANALOG_TONE_INFO);
2139 if (res < 0) {
2140 ast_log(LOG_WARNING, "Unable to start special tone on %d\n", p->channel);
2141 } else {
2142 sleep(1);
2143 }
2144 res = ast_streamfile(chan, "ss-noservice", ast_channel_language(chan));
2145 if (res >= 0) {
2146 ast_waitstream(chan, "");
2147 }
2149 ast_hangup(chan);
2150 goto quit;
2151 }
2152 break;
2153 case ANALOG_SIG_FXOLS:
2154 case ANALOG_SIG_FXOGS:
2155 case ANALOG_SIG_FXOKS:
2156 /* Set our default presentation.
2157 * This is necessary because the presentation for each call is independent
2158 * (though the default may be the same).
2159 * For example, if hidecallerid=yes and somebody makes a call with *82,
2160 * then makes a 3-way call, the presentation for the 2nd call should still
2161 * be blocked, unless that also had a *82.
2162 * For this reason, setting hidecallerid = permhidecallerid on hangup
2163 * is NOT sufficient, as the *82 from the first call could "leak" into
2164 * subsequent ones made before a hangup, improperly leaking a number
2165 * that should have been hidden.
2166 */
2168
2169 /* Read the first digit */
2170 timeout = analog_get_firstdigit_timeout(p);
2171 /* If starting a threeway call, never timeout on the first digit so someone
2172 * can use flash-hook as a "hold" feature...
2173 * ...Unless three-way dial tone should time out to silence, in which case the default suffices. */
2175 timeout = INT_MAX;
2176 }
2177 while (len < AST_MAX_EXTENSION-1) {
2178 int is_exten_parking = 0;
2179
2180 /* Read digit unless it's supposed to be immediate, in which case the
2181 only answer is 's' */
2182 if (p->immediate) {
2183 res = 's';
2184 } else {
2185 res = ast_waitfordigit(chan, timeout);
2186 }
2187 timeout = 0;
2188 if (res < 0) {
2189 ast_debug(1, "waitfordigit returned < 0...\n");
2190 res = analog_play_tone(p, idx, -1);
2191 ast_hangup(chan);
2192 goto quit;
2193 } else if (res) {
2194 ast_debug(1,"waitfordigit returned '%c' (%d), timeout = %d\n", res, res, timeout);
2195 exten[len++]=res;
2196 exten[len] = '\0';
2197 }
2198 if (!ast_ignore_pattern(ast_channel_context(chan), exten)) {
2199 analog_play_tone(p, idx, -1);
2200 } else {
2202 }
2204 is_exten_parking = ast_parking_is_exten_park(ast_channel_context(chan), exten);
2205 }
2206 if (ast_exists_extension(chan, ast_channel_context(chan), exten, 1, p->cid_num) && !is_exten_parking) {
2207 if (!res || !ast_matchmore_extension(chan, ast_channel_context(chan), exten, 1, p->cid_num)) {
2208 if (getforward) {
2209 /* Record this as the forwarding extension */
2210 ast_copy_string(p->call_forward, exten, sizeof(p->call_forward));
2211 ast_verb(3, "Setting call forward to '%s' on channel %d\n", p->call_forward, p->channel);
2213 if (res) {
2214 break;
2215 }
2216 usleep(500000);
2217 res = analog_play_tone(p, idx, -1);
2218 sleep(1);
2219 memset(exten, 0, sizeof(exten));
2221 len = 0;
2222 getforward = 0;
2223 } else {
2224 res = analog_play_tone(p, idx, -1);
2225 ast_channel_lock(chan);
2226 ast_channel_exten_set(chan, exten);
2227
2228 /* Properly set the presentation.
2229 * We need to do this here as well, because p->hidecallerid might be set
2230 * due to permanent blocking, not star-67/star-82 usage. */
2231 if (p->hidecallerid) {
2234 } else {
2237 }
2238
2240 ast_channel_unlock(chan);
2242 res = ast_pbx_run(chan);
2243 if (res) {
2244 ast_log(LOG_WARNING, "PBX exited non-zero\n");
2246 }
2247 goto quit;
2248 }
2249 } else {
2250 /* It's a match, but they just typed a digit, and there is an ambiguous match,
2251 so just set the timeout to analog_matchdigittimeout and wait some more */
2252 timeout = analog_get_matchdigit_timeout(p);
2253 }
2254 } else if (res == 0) {
2255 ast_debug(1, "not enough digits (and no ambiguous match)...\n");
2256 if (p->threewaysilenthold) {
2257 ast_debug(1, "Nothing dialed at three-way dial tone, timed out to silent hold\n");
2258 } else {
2260 }
2262 ast_hangup(chan);
2263 goto quit;
2264 } else if (p->callwaiting && !strcmp(exten, "*70")) {
2265 ast_verb(3, "Disabling call waiting on %s\n", ast_channel_name(chan));
2266 /* Disable call waiting if enabled */
2269 if (res) {
2270 ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n",
2271 ast_channel_name(chan), strerror(errno));
2272 }
2273 len = 0;
2274 memset(exten, 0, sizeof(exten));
2275 timeout = analog_get_firstdigit_timeout(p);
2276
2277 } else if (!strcmp(exten, pickupexten)) {
2278 /* Scan all channels and see if there are any
2279 * ringing channels that have call groups
2280 * that equal this channel's pickup group
2281 */
2282 if (idx == ANALOG_SUB_REAL) {
2283 /* Switch us from Third call to Call Wait */
2284 if (p->subs[ANALOG_SUB_THREEWAY].owner) {
2285 /* If you make a threeway call and then *8# a call, it should actually
2286 look like a callwait */
2290 }
2292 if (ast_pickup_call(chan)) {
2293 ast_debug(1, "No call pickup possible...\n");
2296 }
2297 ast_hangup(chan);
2298 goto quit;
2299 } else {
2300 ast_log(LOG_WARNING, "Huh? Got *8# on call not on real\n");
2301 ast_hangup(chan);
2302 goto quit;
2303 }
2304 /* While the DMS-100 allows dialing as many *67s and *82s in succession as one's heart may desire,
2305 * the 5ESS does not, it only allows pure toggling (and only once!). So, it's not incorrect
2306 * to prevent people from dialing *67 if that won't actually do anything. */
2307 } else if (!p->hidecallerid && !strcmp(exten, "*67")) {
2308 ast_verb(3, "Blocking Caller*ID on %s\n", ast_channel_name(chan));
2309 /* Disable Caller*ID if enabled */
2310 p->hidecallerid = 1;
2314 if (res) {
2315 ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n",
2316 ast_channel_name(chan), strerror(errno));
2317 }
2318 len = 0;
2319 memset(exten, 0, sizeof(exten));
2320 timeout = analog_get_firstdigit_timeout(p);
2321 } else if (p->callreturn && !strcmp(exten, "*69")) {
2322 res = 0;
2323 if (!ast_strlen_zero(p->lastcid_num)) {
2324 res = ast_say_digit_str(chan, p->lastcid_num, "", ast_channel_language(chan));
2325 }
2326 if (!res) {
2328 }
2329 break;
2330 } else if (!strcmp(exten, "*78")) {
2331 /* Do not disturb enabled */
2332 analog_dnd(p, 1);
2334 getforward = 0;
2335 memset(exten, 0, sizeof(exten));
2336 len = 0;
2337 } else if (!strcmp(exten, "*79")) {
2338 /* Do not disturb disabled */
2339 analog_dnd(p, 0);
2341 getforward = 0;
2342 memset(exten, 0, sizeof(exten));
2343 len = 0;
2344 } else if (p->cancallforward && !strcmp(exten, "*72")) {
2346 getforward = 1;
2347 memset(exten, 0, sizeof(exten));
2348 len = 0;
2349 } else if (p->cancallforward && !strcmp(exten, "*73")) {
2350 ast_verb(3, "Cancelling call forwarding on channel %d\n", p->channel);
2352 memset(p->call_forward, 0, sizeof(p->call_forward));
2353 getforward = 0;
2354 memset(exten, 0, sizeof(exten));
2355 len = 0;
2356 } else if ((p->transfer || p->canpark) && is_exten_parking
2358 struct ast_bridge_channel *bridge_channel;
2359
2360 /*
2361 * This is a three way call, the main call being a real channel,
2362 * and we're parking the first call.
2363 */
2367 if (bridge_channel) {
2368 if (!ast_parking_blind_transfer_park(bridge_channel, ast_channel_context(chan), exten, NULL, NULL)) {
2369 /*
2370 * Swap things around between the three-way and real call so we
2371 * can hear where the channel got parked.
2372 */
2377
2378 ast_verb(3, "%s: Parked call\n", ast_channel_name(chan));
2380 ao2_ref(bridge_channel, -1);
2381 goto quit;
2382 }
2383 ao2_ref(bridge_channel, -1);
2384 }
2385 break;
2386 } else if (!ast_strlen_zero(p->lastcid_num) && !strcmp(exten, "*60")) {
2387 ast_verb(3, "Blacklisting number %s\n", p->lastcid_num);
2388 res = ast_db_put("blacklist", p->lastcid_num, "1");
2389 if (!res) {
2391 memset(exten, 0, sizeof(exten));
2392 len = 0;
2393 }
2394 } else if (p->hidecallerid && !strcmp(exten, "*82")) {
2395 ast_verb(3, "Allowing Caller*ID on %s\n", ast_channel_name(chan));
2396 /* Enable Caller*ID if enabled */
2397 p->hidecallerid = 0;
2401 if (res) {
2402 ast_log(LOG_WARNING, "Unable to do dial recall on channel %s: %s\n",
2403 ast_channel_name(chan), strerror(errno));
2404 }
2405 len = 0;
2406 memset(exten, 0, sizeof(exten));
2407 timeout = analog_get_firstdigit_timeout(p);
2408 } else if (!strcmp(exten, "*0")) {
2409 struct ast_channel *nbridge = p->subs[ANALOG_SUB_THREEWAY].owner;
2410 struct analog_pvt *pbridge = NULL;
2411 /* set up the private struct of the bridged one, if any */
2412 if (nbridge) {
2413 pbridge = analog_get_bridged_channel(nbridge);
2414 }
2415 if (pbridge && ISTRUNK(pbridge)) {
2416 /* Clear out the dial buffer */
2417 p->dop.dialstr[0] = '\0';
2418 /* flash hookswitch */
2419 if ((analog_flash(pbridge) == -1) && (errno != EINPROGRESS)) {
2421 "Unable to flash-hook bridged trunk from channel %s: %s\n",
2422 ast_channel_name(nbridge), strerror(errno));
2423 }
2428 ast_hangup(chan);
2429 goto quit;
2430 } else {
2433 analog_play_tone(p, idx, -1);
2437 ast_hangup(chan);
2438 goto quit;
2439 }
2440 } else if (!ast_canmatch_extension(chan, ast_channel_context(chan), exten, 1,
2441 ast_channel_caller(chan)->id.number.valid ? ast_channel_caller(chan)->id.number.str : NULL)
2442 && !analog_canmatch_featurecode(pickupexten, exten)) {
2443 ast_debug(1, "Can't match %s from '%s' in context %s\n", exten,
2444 ast_channel_caller(chan)->id.number.valid && ast_channel_caller(chan)->id.number.str
2445 ? ast_channel_caller(chan)->id.number.str : "<Unknown Caller>",
2446 ast_channel_context(chan));
2447 break;
2448 }
2449 if (!timeout) {
2450 timeout = analog_get_interdigit_timeout(p);
2451 }
2452 if (len && !ast_ignore_pattern(ast_channel_context(chan), exten)) {
2453 analog_play_tone(p, idx, -1);
2454 }
2455 }
2456 break;
2457 case ANALOG_SIG_FXSLS:
2458 case ANALOG_SIG_FXSGS:
2459 case ANALOG_SIG_FXSKS:
2460 /* check for SMDI messages */
2461 if (p->use_smdi && p->smdi_iface) {
2463 if (smdi_msg != NULL) {
2464 ast_channel_exten_set(chan, smdi_msg->fwd_st);
2465
2466 if (smdi_msg->type == 'B')
2467 pbx_builtin_setvar_helper(chan, "_SMDI_VM_TYPE", "b");
2468 else if (smdi_msg->type == 'N')
2469 pbx_builtin_setvar_helper(chan, "_SMDI_VM_TYPE", "u");
2470
2471 ast_debug(1, "Received SMDI message on %s\n", ast_channel_name(chan));
2472 } else {
2473 ast_log(LOG_WARNING, "SMDI enabled but no SMDI message present\n");
2474 }
2475 }
2476
2477 if (p->use_callerid && (p->cid_signalling == CID_SIG_SMDI && smdi_msg)) {
2478 number = smdi_msg->calling_st;
2479
2480 /* If we want caller id, we're in a prering state due to a polarity reversal
2481 * and we're set to use a polarity reversal to trigger the start of caller id,
2482 * grab the caller id and wait for ringing to start... */
2483 } else if (p->use_callerid && (ast_channel_state(chan) == AST_STATE_PRERING
2487 /* If set to use DTMF CID signalling, listen for DTMF */
2488 if (p->cid_signalling == CID_SIG_DTMF) {
2489 int k = 0;
2490 int oldlinearity;
2491 int timeout_ms;
2492 int ms;
2493 struct timeval start = ast_tvnow();
2494 ast_debug(1, "Receiving DTMF cid on channel %s\n", ast_channel_name(chan));
2495
2496 oldlinearity = analog_set_linear_mode(p, idx, 0);
2497
2498 /*
2499 * We are the only party interested in the Rx stream since
2500 * we have not answered yet. We don't need or even want DTMF
2501 * emulation. The DTMF digits can come so fast that emulation
2502 * can drop some of them.
2503 */
2504 ast_channel_lock(chan);
2506 ast_channel_unlock(chan);
2507 timeout_ms = 4000;/* This is a typical OFF time between rings. */
2508 for (;;) {
2509 struct ast_frame *f;
2510
2511 ms = ast_remaining_ms(start, timeout_ms);
2512 res = ast_waitfor(chan, ms);
2513 if (res <= 0) {
2514 /*
2515 * We do not need to restore the analog_set_linear_mode()
2516 * or AST_FLAG_END_DTMF_ONLY flag settings since we
2517 * are hanging up the channel.
2518 */
2520 "DTMFCID timed out waiting for ring. Exiting simple switch\n");
2521 ast_hangup(chan);
2522 goto quit;
2523 }
2524 f = ast_read(chan);
2525 if (!f) {
2526 break;
2527 }
2528 if (f->frametype == AST_FRAME_DTMF) {
2529 if (k < ARRAY_LEN(dtmfbuf) - 1) {
2530 dtmfbuf[k++] = f->subclass.integer;
2531 }
2532 ast_debug(1, "CID got digit '%c'\n", f->subclass.integer);
2533 start = ast_tvnow();
2534 }
2535 ast_frfree(f);
2536 if (ast_channel_state(chan) == AST_STATE_RING ||
2538 break; /* Got ring */
2539 }
2540 }
2541 ast_channel_lock(chan);
2543 ast_channel_unlock(chan);
2544 dtmfbuf[k] = '\0';
2545
2546 analog_set_linear_mode(p, idx, oldlinearity);
2547
2548 /* Got cid and ring. */
2549 ast_debug(1, "CID got string '%s'\n", dtmfbuf);
2550 callerid_get_dtmf(dtmfbuf, dtmfcid, &flags);
2551 ast_debug(1, "CID is '%s', flags %d\n", dtmfcid, flags);
2552 /* If first byte is NULL, we have no cid */
2553 if (!ast_strlen_zero(dtmfcid)) {
2554 number = dtmfcid;
2555 } else {
2556 number = NULL;
2557 }
2558
2559 /* If set to use V23 Signalling, launch our FSK gubbins and listen for it */
2560 } else if ((p->cid_signalling == CID_SIG_V23) || (p->cid_signalling == CID_SIG_V23_JP)) {
2561 namebuf[0] = 0;
2562 numbuf[0] = 0;
2563
2565 int timeout = 10000; /* Ten seconds */
2566 struct timeval start = ast_tvnow();
2567 enum analog_event ev;
2568 int off_ms;
2569 int ms;
2570 struct timeval off_start;
2571
2573 /* Disable distinctive ring timeout count */
2575 }
2576 while ((ms = ast_remaining_ms(start, timeout))) {
2577 res = analog_get_callerid(p, namebuf, numbuf, &ev, ms);
2578 if (res < 0) {
2580 "CallerID returned with error on channel '%s'\n",
2581 ast_channel_name(chan));
2582 break;
2583 }
2584 if (res == 0) {
2585 break;
2586 }
2587 if (res != 1) {
2588 continue;
2589 }
2590 if (ev == ANALOG_EVENT_NOALARM) {
2591 analog_set_alarm(p, 0);
2592 }
2593 if (p->cid_signalling == CID_SIG_V23_JP) {
2594 if (ev == ANALOG_EVENT_RINGBEGIN) {
2595 analog_off_hook(p);
2596 usleep(1);
2597 }
2598 } else {
2599 break;
2600 }
2601 }
2602
2603 name = namebuf;
2604 number = numbuf;
2605
2606 if (p->cid_signalling == CID_SIG_V23_JP) {
2607 analog_on_hook(p);
2608 usleep(1);
2609 }
2610
2611 /* Finished with Caller*ID, now wait for a ring to make sure there really is a call coming */
2612 off_start = ast_tvnow();
2613 off_ms = 4000;/* This is a typical OFF time between rings. */
2614 while ((ms = ast_remaining_ms(off_start, off_ms))) {
2615 struct ast_frame *f;
2616
2617 res = ast_waitfor(chan, ms);
2618 if (res <= 0) {
2620 "CID timed out waiting for ring. Exiting simple switch\n");
2622 ast_hangup(chan);
2623 goto quit;
2624 }
2625 if (!(f = ast_read(chan))) {
2626 ast_log(LOG_WARNING, "Hangup received waiting for ring. Exiting simple switch\n");
2628 ast_hangup(chan);
2629 goto quit;
2630 }
2631 ast_frfree(f);
2632 if (ast_channel_state(chan) == AST_STATE_RING ||
2634 break; /* Got ring */
2635 }
2636
2637 res = analog_distinctive_ring(chan, p, idx, NULL);
2639 if (res) {
2640 goto quit;
2641 }
2642 } else {
2643 ast_log(LOG_WARNING, "Unable to get caller ID space\n");
2644 }
2645 } else {
2647 "Channel %s in prering state, but I have nothing to do. Terminating simple switch, should be restarted by the actual ring.\n",
2648 ast_channel_name(chan));
2649 ast_hangup(chan);
2650 goto quit;
2651 }
2652 } else if (p->use_callerid && p->cid_start == ANALOG_CID_START_RING) {
2653 namebuf[0] = 0;
2654 numbuf[0] = 0;
2655
2657 int timeout = 10000; /* Ten seconds */
2658 struct timeval start = ast_tvnow();
2659 enum analog_event ev;
2660 int ring_data[RING_PATTERNS] = { 0 };
2661 int ring_data_idx = 0;
2662 int ms;
2663
2665 /* Disable distinctive ring timeout count */
2667 }
2668 while ((ms = ast_remaining_ms(start, timeout))) {
2669 res = analog_get_callerid(p, namebuf, numbuf, &ev, ms);
2670 if (res < 0) {
2672 "CallerID returned with error on channel '%s'\n",
2673 ast_channel_name(chan));
2674 break;
2675 }
2676 if (res == 0) {
2677 break;
2678 }
2679 if (res != 1) {
2680 continue;
2681 }
2682 if (ev == ANALOG_EVENT_NOALARM) {
2683 analog_set_alarm(p, 0);
2684 } else if (ev == ANALOG_EVENT_POLARITY
2686 && p->polarity == POLARITY_REV) {
2687 ast_debug(1,
2688 "Hanging up due to polarity reversal on channel %d while detecting callerid\n",
2689 p->channel);
2692 ast_hangup(chan);
2693 goto quit;
2694 } else if (ev == ANALOG_EVENT_RINGOFFHOOK
2696 && ring_data_idx < RING_PATTERNS) {
2697 /*
2698 * Detect callerid while collecting possible
2699 * distinctive ring pattern.
2700 */
2701 ring_data[ring_data_idx] = p->ringt;
2702 ++ring_data_idx;
2703 }
2704 }
2705
2706 name = namebuf;
2707 number = numbuf;
2708
2709 res = analog_distinctive_ring(chan, p, idx, ring_data);
2711 if (res) {
2712 goto quit;
2713 }
2714 } else {
2715 ast_log(LOG_WARNING, "Unable to get caller ID space\n");
2716 }
2717 }
2718
2719 if (number) {
2721 }
2723
2724 analog_handle_notify_message(chan, p, flags, -1);
2725
2726 ast_channel_lock(chan);
2728 ast_channel_rings_set(chan, 1);
2729 ast_channel_unlock(chan);
2731 res = ast_pbx_run(chan);
2732 if (res) {
2733 ast_hangup(chan);
2734 ast_log(LOG_WARNING, "PBX exited non-zero\n");
2735 }
2736 goto quit;
2737 default:
2738 ast_log(LOG_WARNING, "Don't know how to handle simple switch with signalling %s on channel %d\n", analog_sigtype_to_str(p->sig), p->channel);
2739 break;
2740 }
2742 if (res < 0) {
2743 ast_log(LOG_WARNING, "Unable to play congestion tone on channel %d\n", p->channel);
2744 }
2745 ast_hangup(chan);
2746quit:
2747 ao2_cleanup(smdi_msg);
2749 return NULL;
2750}
int ast_db_put(const char *family, const char *key, const char *value)
Store value addressed by family/key.
Definition: main/db.c:341
#define ast_strdupa(s)
duplicate a string in memory from the stack
Definition: astmm.h:298
#define ao2_cleanup(obj)
Definition: astobj2.h:1934
#define ao2_ref(o, delta)
Reference/unreference an object and return the old refcount.
Definition: astobj2.h:459
#define CID_SIG_V23_JP
Definition: callerid.h:63
#define AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED
Definition: callerid.h:449
#define CID_SIG_SMDI
Definition: callerid.h:64
void ast_shrink_phone_number(char *n)
Shrink a phone number in place to just digits (more accurately it just removes ()'s,...
Definition: callerid.c:1101
#define CID_SIG_DTMF
Definition: callerid.h:62
#define CID_SIG_V23
Definition: callerid.h:61
void callerid_get_dtmf(char *cidstring, char *number, int *flags)
Get and parse DTMF-based callerid.
Definition: callerid.c:211
#define AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED
Definition: callerid.h:437
void ast_channel_exten_set(struct ast_channel *chan, const char *value)
int ast_waitfordigit(struct ast_channel *c, int ms)
Waits for a digit.
Definition: channel.c:3194
void * ast_channel_tech_pvt(const struct ast_channel *chan)
int ast_waitfor(struct ast_channel *chan, int ms)
Wait for input on a channel.
Definition: channel.c:3181
struct ast_flags * ast_channel_flags(struct ast_channel *chan)
ast_callid ast_channel_callid(const struct ast_channel *chan)
const char * ast_channel_context(const struct ast_channel *chan)
struct ast_frame * ast_read(struct ast_channel *chan)
Reads a frame.
Definition: channel.c:4276
void ast_set_callerid(struct ast_channel *chan, const char *cid_num, const char *cid_name, const char *cid_ani)
Set caller ID number, name and ANI and generate AMI event.
Definition: channel.c:7356
const char * ast_channel_language(const struct ast_channel *chan)
struct ast_bridge_channel * ast_channel_get_bridge_channel(struct ast_channel *chan)
Get a reference to the channel's bridge pointer.
Definition: channel.c:10604
@ AST_FLAG_END_DTMF_ONLY
Definition: channel.h:1027
int ast_safe_sleep(struct ast_channel *chan, int ms)
Wait for a specified amount of time, looking for hangups.
Definition: channel.c:1593
#define AST_MAX_EXTENSION
Definition: channel.h:134
int ast_streamfile(struct ast_channel *c, const char *filename, const char *preflang)
Streams a file.
Definition: file.c:1293
int ast_waitstream(struct ast_channel *c, const char *breakon)
Waits for a stream to stop or digit to be pressed.
Definition: file.c:1840
static int len(struct ast_channel *chan, const char *cmd, char *data, char *buf, size_t buflen)
char * strsep(char **str, const char *delims)
struct ast_features_pickup_config * ast_get_chan_features_pickup_config(struct ast_channel *chan)
Get the pickup configuration options for a channel.
#define AST_FRAME_DTMF
#define ast_frfree(fr)
int ast_callid_threadassoc_add(ast_callid callid)
Adds a known callid to thread storage of the calling thread.
Definition: logger.c:2320
int errno
int ast_parking_blind_transfer_park(struct ast_bridge_channel *parker, const char *context, const char *exten, transfer_channel_cb parked_channel_cb, struct transfer_channel_data *parked_channel_data)
Perform a blind transfer to a parking extension.
Definition: parking.c:143
int ast_parking_is_exten_park(const char *context, const char *exten)
Determine if the context/exten is a "parking" extension.
Definition: parking.c:179
int ast_parking_provider_registered(void)
Check whether a parking provider is registered.
Definition: parking.c:241
enum ast_pbx_result ast_pbx_run(struct ast_channel *c)
Execute the PBX in the current thread.
Definition: pbx.c:4755
int ast_exists_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Determine whether an extension exists.
Definition: pbx.c:4175
int pbx_builtin_setvar_helper(struct ast_channel *chan, const char *name, const char *value)
Add a variable to the channel variable stack, removing the most recently set value for the same name.
int ast_canmatch_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Looks for a valid matching extension.
Definition: pbx.c:4190
int ast_ignore_pattern(const char *context, const char *pattern)
Checks to see if a number should be ignored.
Definition: pbx.c:6879
int ast_matchmore_extension(struct ast_channel *c, const char *context, const char *exten, int priority, const char *callerid)
Looks to see if adding anything to this extension might match something. (exists ^ canmatch)
Definition: pbx.c:4195
int ast_pickup_call(struct ast_channel *chan)
Pickup a call.
Definition: pickup.c:199
int ast_say_digit_str(struct ast_channel *chan, const char *num, const char *ints, const char *lang)
says digits of a string
Definition: channel.c:8281
static void analog_set_callwaiting(struct analog_pvt *p, int callwaiting_enable)
Definition: sig_analog.c:880
static int analog_my_getsigstr(struct ast_channel *chan, char *str, const char *term, int ms)
Definition: sig_analog.c:1635
static int analog_stop_cid_detect(struct analog_pvt *p)
Definition: sig_analog.c:170
static int analog_dsp_reset_and_flush_digits(struct analog_pvt *p)
Definition: sig_analog.c:428
static void analog_increase_ss_count(void)
Definition: sig_analog.c:1664
static void * analog_get_bridged_channel(struct ast_channel *chan)
Definition: sig_analog.c:1697
static int analog_handle_notify_message(struct ast_channel *chan, struct analog_pvt *p, int cid_flags, int neon_mwievent)
Definition: sig_analog.c:1655
static int analog_canmatch_featurecode(const char *pickupexten, const char *exten)
Definition: sig_analog.c:1715
static int analog_flash(struct analog_pvt *p)
Definition: sig_analog.c:505
static int analog_set_linear_mode(struct analog_pvt *p, enum analog_sub sub, int linear_mode)
Definition: sig_analog.c:973
int analog_dnd(struct analog_pvt *p, int flag)
Definition: sig_analog.c:4165
static int analog_dsp_set_digitmode(struct analog_pvt *p, enum analog_dsp_digitmode mode)
Definition: sig_analog.c:659
const char * name
Definition: sig_analog.c:70
static void analog_decrease_ss_count(void)
Definition: sig_analog.c:1671
static int analog_wait_event(struct analog_pvt *p)
Definition: sig_analog.c:202
#define ISTRUNK(p)
Definition: sig_analog.c:107
static int analog_get_callerid(struct analog_pvt *p, char *name, char *number, enum analog_event *ev, size_t timeout)
Definition: sig_analog.c:178
static int analog_wink(struct analog_pvt *p, enum analog_sub index)
Definition: sig_analog.c:674
const char * analog_sigtype_to_str(enum analog_sigtype sigtype)
Definition: sig_analog.c:123
static int analog_start_cid_detect(struct analog_pvt *p, int cid_signalling)
Definition: sig_analog.c:162
static int analog_distinctive_ring(struct ast_channel *chan, struct analog_pvt *p, int idx, int *ringdata)
Definition: sig_analog.c:1678
#define ANALOG_NEED_MFDETECT(p)
Definition: sig_analog.c:1713
#define ANALOG_MAX_CID
Definition: sig_analog.h:33
@ ANALOG_DIGITMODE_DTMF
Definition: sig_analog.h:115
@ ANALOG_DIGITMODE_MF
Definition: sig_analog.h:116
#define ANALOG_SMDI_MD_WAIT_TIMEOUT
Definition: sig_analog.h:32
#define RING_PATTERNS
Definition: sig_analog.h:35
analog_event
Definition: sig_analog.h:79
@ ANALOG_TONE_INFO
Definition: sig_analog.h:76
@ ANALOG_CID_START_RING
Definition: sig_analog.h:129
@ ANALOG_CID_START_DTMF_NOALERT
Definition: sig_analog.h:130
@ ANALOG_CID_START_POLARITY
Definition: sig_analog.h:127
@ ANALOG_CID_START_POLARITY_IN
Definition: sig_analog.h:128
struct ast_smdi_md_message * ast_smdi_md_message_wait(struct ast_smdi_interface *iface, int timeout)
Get the next SMDI message from the queue.
Definition: res_smdi.c:539
unsigned int immediate
Definition: sig_analog.h:298
unsigned int threewaysilenthold
Definition: sig_analog.h:304
unsigned int canpark
Definition: sig_analog.h:295
unsigned int permhidecallerid
Definition: sig_analog.h:301
unsigned int ani_wink_time
Definition: sig_analog.h:289
unsigned int usedistinctiveringdetection
Definition: sig_analog.h:308
unsigned int callwaiting
Definition: sig_analog.h:333
char call_forward[AST_MAX_EXTENSION]
Definition: sig_analog.h:369
enum analog_cid_start cid_start
Definition: sig_analog.h:326
unsigned int hidecallerid
Definition: sig_analog.h:339
unsigned int callreturn
Definition: sig_analog.h:293
unsigned int use_smdi
TRUE if SMDI (Simplified Message Desk Interface) is enabled.
Definition: sig_analog.h:313
unsigned int ani_timeout
Definition: sig_analog.h:288
unsigned int ani_info_digits
Definition: sig_analog.h:287
unsigned int cancallforward
Definition: sig_analog.h:294
char lastcid_num[AST_MAX_EXTENSION]
Definition: sig_analog.h:353
int cid_signalling
Definition: sig_analog.h:323
unsigned int use_callerid
Definition: sig_analog.h:307
struct ast_smdi_interface * smdi_iface
The SMDI interface to get SMDI messages from.
Definition: sig_analog.h:315
Structure that contains information regarding a channel in a bridge.
struct ast_channel * chan
char exten[AST_MAX_EXTENSION]
struct ast_flags flags
Configuration relating to call pickup.
unsigned int flags
Caller Party information.
Definition: channel.h:420
int presentation
Q.931 encoded presentation-indicator encoded field.
Definition: channel.h:279
int presentation
Q.931 presentation-indicator and screening-indicator encoded fields.
Definition: channel.h:297
An SMDI message desk message.
Definition: smdi.h:65
char calling_st[SMDI_MAX_STATION_NUM_LEN+1]
Definition: smdi.h:70
char fwd_st[SMDI_MAX_STATION_NUM_LEN+1]
Definition: smdi.h:69
Number structure.
Definition: app_followme.c:154
int ast_remaining_ms(struct timeval start, int max_ms)
Calculate remaining milliseconds given a starting timestamp and upper bound.
Definition: utils.c:2281
#define RAII_VAR(vartype, varname, initval, dtor)
Declare a variable that will call a destructor function when it goes out of scope.
Definition: utils.h:941
#define ast_assert(a)
Definition: utils.h:739
#define MIN(a, b)
Definition: utils.h:231
#define ast_clear_flag(p, flag)
Definition: utils.h:77
#define ast_set_flag(p, flag)
Definition: utils.h:70
#define ARRAY_LEN(a)
Definition: utils.h:666

References analog_alloc_sub(), analog_canmatch_featurecode(), ANALOG_CID_START_DTMF_NOALERT, ANALOG_CID_START_POLARITY, ANALOG_CID_START_POLARITY_IN, ANALOG_CID_START_RING, analog_decrease_ss_count(), ANALOG_DIGITMODE_DTMF, ANALOG_DIGITMODE_MF, analog_distinctive_ring(), analog_dnd(), analog_dsp_reset_and_flush_digits(), analog_dsp_set_digitmode(), ANALOG_EVENT_NOALARM, ANALOG_EVENT_POLARITY, ANALOG_EVENT_RINGBEGIN, ANALOG_EVENT_RINGOFFHOOK, analog_flash(), analog_get_bridged_channel(), analog_get_callerid(), analog_get_index, analog_handle_notify_message(), analog_increase_ss_count(), analog_lock_private(), ANALOG_MAX_CID, analog_my_getsigstr(), ANALOG_NEED_MFDETECT, analog_off_hook(), analog_on_hook(), analog_play_tone(), analog_set_alarm(), analog_set_callwaiting(), analog_set_echocanceller(), analog_set_linear_mode(), analog_set_new_owner(), analog_set_ringtimeout(), ANALOG_SIG_E911, ANALOG_SIG_EM, ANALOG_SIG_EM_E1, ANALOG_SIG_EMWINK, ANALOG_SIG_FEATB, ANALOG_SIG_FEATD, ANALOG_SIG_FEATDMF, ANALOG_SIG_FEATDMF_TA, ANALOG_SIG_FGC_CAMA, ANALOG_SIG_FGC_CAMAMF, ANALOG_SIG_FXOGS, ANALOG_SIG_FXOKS, ANALOG_SIG_FXOLS, ANALOG_SIG_FXSGS, ANALOG_SIG_FXSKS, ANALOG_SIG_FXSLS, ANALOG_SIG_SF, ANALOG_SIG_SF_FEATB, ANALOG_SIG_SF_FEATD, ANALOG_SIG_SF_FEATDMF, ANALOG_SIG_SFWINK, analog_sigtype_to_str(), ANALOG_SMDI_MD_WAIT_TIMEOUT, analog_start_cid_detect(), analog_stop_cid_detect(), ANALOG_SUB_CALLWAIT, ANALOG_SUB_REAL, ANALOG_SUB_THREEWAY, analog_swap_subs(), ANALOG_TONE_CONGESTION, ANALOG_TONE_DIALRECALL, ANALOG_TONE_DIALTONE, ANALOG_TONE_INFO, analog_unalloc_sub(), analog_unlock_private(), analog_wait_event(), analog_wink(), ast_party_caller::ani2, analog_pvt::ani_info_digits, analog_pvt::ani_timeout, analog_pvt::ani_wink_time, ao2_cleanup, ao2_ref, ARRAY_LEN, ast_assert, ast_callid_threadassoc_add(), ast_canmatch_extension(), ast_channel_caller(), ast_channel_callid(), ast_channel_context(), ast_channel_exten_set(), ast_channel_flags(), ast_channel_get_bridge_channel(), ast_channel_language(), ast_channel_lock, ast_channel_name(), ast_channel_rings_set(), ast_channel_tech_pvt(), ast_channel_unlock, ast_clear_flag, ast_copy_string(), ast_db_put(), ast_debug, ast_exists_extension(), AST_FLAG_END_DTMF_ONLY, AST_FRAME_DTMF, ast_frfree, ast_get_chan_features_pickup_config(), ast_hangup(), ast_ignore_pattern(), ast_log, ast_matchmore_extension(), AST_MAX_EXTENSION, ast_parking_blind_transfer_park(), ast_parking_is_exten_park(), ast_parking_provider_registered(), ast_pbx_run(), ast_pickup_call(), AST_PRES_ALLOWED_USER_NUMBER_NOT_SCREENED, AST_PRES_PROHIB_USER_NUMBER_NOT_SCREENED, ast_queue_unhold(), ast_read(), ast_remaining_ms(), ast_safe_sleep(), ast_say_digit_str(), ast_set_callerid(), ast_set_flag, ast_setstate(), ast_shrink_phone_number(), ast_smdi_md_message_wait(), AST_STATE_PRERING, AST_STATE_RING, AST_STATE_RINGING, ast_strdupa, ast_streamfile(), ast_strlen_zero(), ast_tvnow(), ast_verb, ast_waitfor(), ast_waitfordigit(), ast_waitstream(), analog_pvt::call_forward, callerid_get_dtmf(), ast_smdi_md_message::calling_st, analog_pvt::callreturn, analog_pvt::callwaiting, analog_pvt::cancallforward, analog_pvt::canpark, ast_bridge_channel::chan, analog_pvt::channel, analog_pvt::cid_num, CID_SIG_DTMF, CID_SIG_SMDI, CID_SIG_V23, CID_SIG_V23_JP, analog_pvt::cid_signalling, analog_pvt::cid_start, analog_dialoperation::dialstr, analog_pvt::dop, errno, ast_channel::exten, ast_frame::flags, ast_channel::flags, ast_frame::frametype, ast_smdi_md_message::fwd_st, analog_pvt::hanguponpolarityswitch, analog_pvt::hidecallerid, ast_party_caller::id, analog_pvt::immediate, ast_frame_subclass::integer, ISTRUNK, analog_pvt::lastcid_num, len(), LOG_ERROR, LOG_WARNING, MIN, name, ast_party_id::name, NULL, ast_party_id::number, analog_subchannel::owner, pbx_builtin_setvar_helper(), analog_pvt::permhidecallerid, analog_pvt::polarity, POLARITY_IDLE, POLARITY_REV, ast_party_name::presentation, ast_party_number::presentation, RAII_VAR, RING_PATTERNS, analog_pvt::ringt, analog_pvt::ringt_base, analog_pvt::sig, analog_pvt::smdi_iface, analog_pvt::ss_astchan, strsep(), ast_frame::subclass, analog_pvt::subs, analog_pvt::threewaysilenthold, analog_pvt::transfer, ast_smdi_md_message::type, analog_pvt::use_callerid, analog_pvt::use_smdi, and analog_pvt::usedistinctiveringdetection.

Referenced by __analog_handle_event(), analog_handle_init_event(), and analog_ss_thread_start().

◆ _analog_get_index()

static int _analog_get_index ( struct ast_channel ast,
struct analog_pvt p,
int  nullok,
const char *  fname,
unsigned long  line 
)
static

Definition at line 408 of file sig_analog.c.

409{
410 int res;
411 if (p->subs[ANALOG_SUB_REAL].owner == ast) {
412 res = ANALOG_SUB_REAL;
413 } else if (p->subs[ANALOG_SUB_CALLWAIT].owner == ast) {
415 } else if (p->subs[ANALOG_SUB_THREEWAY].owner == ast) {
417 } else {
418 res = -1;
419 if (!nullok) {
421 "Unable to get index for '%s' on channel %d (%s(), line %lu)\n",
422 ast ? ast_channel_name(ast) : "", p->channel, fname, line);
423 }
424 }
425 return res;
426}

References ANALOG_SUB_CALLWAIT, ANALOG_SUB_REAL, ANALOG_SUB_THREEWAY, ast_channel_name(), ast_log, analog_pvt::channel, LOG_WARNING, analog_subchannel::owner, and analog_pvt::subs.

◆ analog_all_subchannels_hungup()

static void analog_all_subchannels_hungup ( struct analog_pvt p)
static

Definition at line 553 of file sig_analog.c.

554{
557 }
558}
struct analog_callback analog_callbacks
Definition: chan_dahdi.c:3616
void(*const all_subchannels_hungup)(void *pvt)
Definition: sig_analog.h:220
void * chan_pvt
Definition: sig_analog.h:275

References analog_callback::all_subchannels_hungup, analog_callbacks, and analog_pvt::chan_pvt.

Referenced by analog_hangup().

◆ analog_alloc_sub()

static int analog_alloc_sub ( struct analog_pvt p,
enum analog_sub  x 
)
static

Definition at line 368 of file sig_analog.c.

369{
371 int res;
373 if (!res) {
374 p->subs[x].allocd = 1;
375 }
376 return res;
377 }
378 return 0;
379}
int(*const allocate_sub)(void *pvt, enum analog_sub sub)
Definition: sig_analog.h:202
unsigned int allocd
Definition: sig_analog.h:268

References analog_callback::allocate_sub, analog_subchannel::allocd, analog_callbacks, analog_pvt::chan_pvt, analog_pvt::subs, and ast_channel::x.

Referenced by __analog_handle_event(), __analog_ss_thread(), and analog_request().

◆ analog_answer()

int analog_answer ( struct analog_pvt p,
struct ast_channel ast 
)

Definition at line 1490 of file sig_analog.c.

1491{
1492 int res = 0;
1493 int idx;
1494 int oldstate = ast_channel_state(ast);
1495
1496 ast_debug(1, "%s %d\n", __FUNCTION__, p->channel);
1498 idx = analog_get_index(ast, p, 1);
1499 if (idx < 0) {
1500 idx = ANALOG_SUB_REAL;
1501 }
1502 switch (p->sig) {
1503 case ANALOG_SIG_FXSLS:
1504 case ANALOG_SIG_FXSGS:
1505 case ANALOG_SIG_FXSKS:
1507 /* Fall through */
1508 case ANALOG_SIG_EM:
1509 case ANALOG_SIG_EM_E1:
1510 case ANALOG_SIG_EMWINK:
1511 case ANALOG_SIG_FEATD:
1512 case ANALOG_SIG_FEATDMF:
1514 case ANALOG_SIG_E911:
1517 case ANALOG_SIG_FEATB:
1518 case ANALOG_SIG_SF:
1519 case ANALOG_SIG_SFWINK:
1523 case ANALOG_SIG_FXOLS:
1524 case ANALOG_SIG_FXOGS:
1525 case ANALOG_SIG_FXOKS:
1526 /* Pick up the line */
1527 ast_debug(1, "Took %s off hook\n", ast_channel_name(ast));
1528 if (p->hanguponpolarityswitch) {
1529 gettimeofday(&p->polaritydelaytv, NULL);
1530 }
1531 res = analog_off_hook(p);
1532 analog_play_tone(p, idx, -1);
1533 analog_set_dialing(p, 0);
1534 if ((idx == ANALOG_SUB_REAL) && p->subs[ANALOG_SUB_THREEWAY].inthreeway) {
1535 if (oldstate == AST_STATE_RINGING) {
1536 ast_debug(1, "Finally swapping real and threeway\n");
1540 }
1541 }
1542
1543 switch (p->sig) {
1544 case ANALOG_SIG_FXSLS:
1545 case ANALOG_SIG_FXSKS:
1546 case ANALOG_SIG_FXSGS:
1549 break;
1550 case ANALOG_SIG_FXOLS:
1551 case ANALOG_SIG_FXOKS:
1552 case ANALOG_SIG_FXOGS:
1554 break;
1555 default:
1556 break;
1557 }
1558 break;
1559 default:
1560 ast_log(LOG_WARNING, "Don't know how to answer signalling %d (channel %d)\n", p->sig, p->channel);
1561 res = -1;
1562 break;
1563 }
1565 return res;
1566}

References analog_answer_polarityswitch(), analog_get_index, analog_off_hook(), analog_play_tone(), analog_set_dialing(), analog_set_echocanceller(), analog_set_new_owner(), analog_set_ringtimeout(), ANALOG_SIG_E911, ANALOG_SIG_EM, ANALOG_SIG_EM_E1, ANALOG_SIG_EMWINK, ANALOG_SIG_FEATB, ANALOG_SIG_FEATD, ANALOG_SIG_FEATDMF, ANALOG_SIG_FEATDMF_TA, ANALOG_SIG_FGC_CAMA, ANALOG_SIG_FGC_CAMAMF, ANALOG_SIG_FXOGS, ANALOG_SIG_FXOKS, ANALOG_SIG_FXOLS, ANALOG_SIG_FXSGS, ANALOG_SIG_FXSKS, ANALOG_SIG_FXSLS, ANALOG_SIG_SF, ANALOG_SIG_SF_FEATB, ANALOG_SIG_SF_FEATD, ANALOG_SIG_SF_FEATDMF, ANALOG_SIG_SFWINK, ANALOG_SUB_REAL, ANALOG_SUB_THREEWAY, analog_swap_subs(), analog_train_echocanceller(), ast_channel_name(), ast_debug, ast_log, ast_setstate(), AST_STATE_RINGING, AST_STATE_UP, analog_pvt::channel, analog_pvt::hanguponpolarityswitch, analog_subchannel::inthreeway, LOG_WARNING, NULL, analog_subchannel::owner, analog_pvt::polaritydelaytv, analog_pvt::sig, and analog_pvt::subs.

Referenced by dahdi_answer().

◆ analog_answer_polarityswitch()

static void analog_answer_polarityswitch ( struct analog_pvt p)
static

Definition at line 645 of file sig_analog.c.

646{
649 }
650}
void(*const answer_polarityswitch)(void *pvt)
Switch FXS line polarity, based on answeronpolarityswitch=yes.
Definition: sig_analog.h:174

References analog_callbacks, analog_callback::answer_polarityswitch, and analog_pvt::chan_pvt.

Referenced by __analog_handle_event(), and analog_answer().

◆ analog_attempt_transfer()

static int analog_attempt_transfer ( struct analog_pvt p)
static

Definition at line 710 of file sig_analog.c.

711{
712 struct ast_channel *owner_real;
713 struct ast_channel *owner_3way;
714 enum ast_transfer_result xfer_res;
715 int res = 0;
716
717 owner_real = ast_channel_ref(p->subs[ANALOG_SUB_REAL].owner);
719
720 ast_verb(3, "TRANSFERRING %s to %s\n",
721 ast_channel_name(owner_3way), ast_channel_name(owner_real));
722
723 ast_channel_unlock(owner_real);
724 ast_channel_unlock(owner_3way);
726
727 xfer_res = ast_bridge_transfer_attended(owner_3way, owner_real);
728 if (xfer_res != AST_BRIDGE_TRANSFER_SUCCESS) {
730 res = -1;
731 }
732
733 /* Must leave with these locked. */
734 ast_channel_lock(owner_real);
736
737 ast_channel_unref(owner_real);
738 ast_channel_unref(owner_3way);
739
740 return res;
741}
ast_transfer_result
Definition: bridge.h:1098
@ AST_BRIDGE_TRANSFER_SUCCESS
Definition: bridge.h:1100
enum ast_transfer_result ast_bridge_transfer_attended(struct ast_channel *to_transferee, struct ast_channel *to_transfer_target)
Attended transfer.
Definition: bridge.c:4677
#define ast_channel_ref(c)
Increase channel reference count.
Definition: channel.h:2993
#define ast_channel_unref(c)
Decrease channel reference count.
Definition: channel.h:3004

References analog_lock_private(), ANALOG_SUB_REAL, ANALOG_SUB_THREEWAY, analog_unlock_private(), ast_bridge_transfer_attended(), AST_BRIDGE_TRANSFER_SUCCESS, ast_channel_lock, ast_channel_name(), ast_channel_ref, ast_channel_unlock, ast_channel_unref, ast_softhangup(), AST_SOFTHANGUP_DEV, ast_verb, analog_subchannel::owner, and analog_pvt::subs.

Referenced by __analog_handle_event().

◆ analog_available()

int analog_available ( struct analog_pvt p)

Definition at line 793 of file sig_analog.c.

794{
795 int offhook;
796
797 ast_debug(1, "%s %d\n", __FUNCTION__, p->channel);
798
799 /* If do not disturb, definitely not */
800 if (p->dnd) {
801 return 0;
802 }
803 /* If guard time, definitely not */
804 if (p->guardtime && (time(NULL) < p->guardtime)) {
805 return 0;
806 }
807
808 /* If line is being held, definitely not (don't allow call waitings to an on-hook phone) */
809 if (p->cshactive) {
810 return 0;
811 }
812
813 /* If no owner definitely available */
814 if (!p->owner) {
815 offhook = analog_is_off_hook(p);
816
817 /* TDM FXO card, "onhook" means out of service (no battery on the line) */
818 if ((p->sig == ANALOG_SIG_FXSLS) || (p->sig == ANALOG_SIG_FXSKS) || (p->sig == ANALOG_SIG_FXSGS)) {
819#ifdef DAHDI_CHECK_HOOKSTATE
820 if (offhook) {
821 return 1;
822 }
823 return 0;
824#endif
825 /* TDM FXS card, "offhook" means someone took the hook off so it's unavailable! */
826 } else if (offhook) {
827 ast_debug(1, "Channel %d off hook, can't use\n", p->channel);
828 /* Not available when the other end is off hook */
829 return 0;
830 }
831 return 1;
832 }
833
834 /* If it's not an FXO, forget about call wait */
835 if ((p->sig != ANALOG_SIG_FXOKS) && (p->sig != ANALOG_SIG_FXOLS) && (p->sig != ANALOG_SIG_FXOGS)) {
836 return 0;
837 }
838
839 if (!p->callwaiting) {
840 /* If they don't have call waiting enabled, then for sure they're unavailable at this point */
841 return 0;
842 }
843
845 /* If there is already a call waiting call, then we can't take a second one */
846 return 0;
847 }
848
849 if ((ast_channel_state(p->owner) != AST_STATE_UP) &&
851 /* If the current call is not up, then don't allow the call */
852 return 0;
853 }
855 /* Can't take a call wait when the three way calling hasn't been merged yet. */
856 return 0;
857 }
858 /* We're cool */
859 return 1;
860}
unsigned int dnd
Definition: sig_analog.h:337
time_t guardtime
Definition: sig_analog.h:363

References analog_subchannel::allocd, analog_is_off_hook(), ANALOG_SIG_FXOGS, ANALOG_SIG_FXOKS, ANALOG_SIG_FXOLS, ANALOG_SIG_FXSGS, ANALOG_SIG_FXSKS, ANALOG_SIG_FXSLS, ANALOG_SUB_CALLWAIT, ANALOG_SUB_THREEWAY, ast_debug, AST_STATE_RINGING, AST_STATE_UP, analog_pvt::callwaiting, analog_pvt::channel, analog_pvt::cshactive, analog_pvt::dnd, analog_pvt::guardtime, analog_subchannel::inthreeway, NULL, analog_pvt::outgoing, analog_subchannel::owner, analog_pvt::owner, analog_pvt::sig, and analog_pvt::subs.

Referenced by available().

◆ analog_call()

int analog_call ( struct analog_pvt p,
struct ast_channel ast,
const char *  rdest,
int  timeout 
)

Definition at line 990 of file sig_analog.c.

991{
992 int res, idx, mysig;
993 char *c, *n, *l;
994 char dest[256]; /* must be same length as p->dialdest */
995
996 ast_debug(1, "CALLING CID_NAME: %s CID_NUM:: %s\n",
997 S_COR(ast_channel_connected(ast)->id.name.valid, ast_channel_connected(ast)->id.name.str, ""),
998 S_COR(ast_channel_connected(ast)->id.number.valid, ast_channel_connected(ast)->id.number.str, ""));
999
1000 ast_copy_string(dest, rdest, sizeof(dest));
1001 ast_copy_string(p->dialdest, rdest, sizeof(p->dialdest));
1002
1003 if ((ast_channel_state(ast) == AST_STATE_BUSY)) {
1005 return 0;
1006 }
1007
1009 ast_log(LOG_WARNING, "analog_call called on %s, neither down nor reserved\n", ast_channel_name(ast));
1010 return -1;
1011 }
1012
1013 p->dialednone = 0;
1014 analog_set_outgoing(p, 1);
1015
1016 mysig = p->sig;
1017 if (p->outsigmod > -1) {
1018 mysig = p->outsigmod;
1019 }
1020
1021 switch (mysig) {
1022 case ANALOG_SIG_FXOLS:
1023 case ANALOG_SIG_FXOGS:
1024 case ANALOG_SIG_FXOKS:
1025 if (p->owner == ast) {
1026 /* Normal ring, on hook */
1027
1028 /* Don't send audio while on hook, until the call is answered */
1029 analog_set_dialing(p, 1);
1030 analog_set_cadence(p, ast); /* and set p->cidrings */
1031
1032 /* nick@dccinc.com 4/3/03 mods to allow for deferred dialing */
1033 c = strchr(dest, '/');
1034 if (c) {
1035 c++;
1036 }
1037 if (c && (strlen(c) < p->stripmsd)) {
1038 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
1039 c = NULL;
1040 }
1041 if (c && (strlen(c) > sizeof(p->dop.dialstr) - 3 /* "Tw\0" */)) {
1042 ast_log(LOG_WARNING, "Number '%s' is longer than %d bytes\n", c, (int)sizeof(p->dop.dialstr) - 2);
1043 c = NULL;
1044 }
1045 if (c) {
1047 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "Tw%s", c);
1048 ast_debug(1, "FXO: setup deferred dialstring: %s\n", c);
1049 } else {
1050 p->dop.dialstr[0] = '\0';
1051 }
1052
1053 if (analog_ring(p)) {
1054 ast_log(LOG_WARNING, "Unable to ring phone: %s\n", strerror(errno));
1055 return -1;
1056 }
1057 analog_set_dialing(p, 1);
1058 } else {
1059 /* Call waiting call */
1060 if (ast_channel_connected(ast)->id.number.valid && ast_channel_connected(ast)->id.number.str) {
1062 } else {
1063 p->callwait_num[0] = '\0';
1064 }
1065 if (ast_channel_connected(ast)->id.name.valid && ast_channel_connected(ast)->id.name.str) {
1067 } else {
1068 p->callwait_name[0] = '\0';
1069 }
1070
1071 /* Call waiting tone instead */
1072 if (analog_callwait(p)) {
1073 return -1;
1074 }
1075 /* Make ring-back */
1077 ast_log(LOG_WARNING, "Unable to generate call-wait ring-back on channel %s\n", ast_channel_name(ast));
1078 }
1079
1080 }
1081
1082 /* Name and Number */
1085 if (l) {
1086 ast_copy_string(p->lastcid_num, l, sizeof(p->lastcid_num));
1087 } else {
1088 p->lastcid_num[0] = '\0';
1089 }
1090 if (n) {
1091 ast_copy_string(p->lastcid_name, n, sizeof(p->lastcid_name));
1092 } else {
1093 p->lastcid_name[0] = '\0';
1094 }
1095
1096 if (p->use_callerid) {
1097 const char *qual_var;
1098
1099 /* Caller ID Name and Number */
1100 p->caller.id.name.str = p->lastcid_name;
1101 p->caller.id.number.str = p->lastcid_num;
1106
1107 /* Redirecting Reason */
1109
1110 /* Call Qualifier */
1111 ast_channel_lock(ast);
1112 /* XXX In the future, we may want to make this a CALLERID or CHANNEL property and fetch it from there. */
1113 qual_var = pbx_builtin_getvar_helper(ast, "CALL_QUALIFIER");
1114 p->call_qualifier = ast_true(qual_var) ? 1 : 0;
1115 ast_channel_unlock(ast);
1116 }
1117
1119 idx = analog_get_index(ast, p, 0);
1120 if (idx > -1) {
1121 struct ast_cc_config_params *cc_params;
1122
1123 /* This is where the initial ringing frame is queued for an analog call.
1124 * As such, this is a great time to offer CCNR to the caller if it's available.
1125 */
1126 cc_params = ast_channel_get_cc_config_params(p->subs[idx].owner);
1127 if (cc_params) {
1128 switch (ast_get_cc_monitor_policy(cc_params)) {
1130 break;
1136 break;
1137 }
1138 }
1140 }
1141 break;
1142 case ANALOG_SIG_FXSLS:
1143 case ANALOG_SIG_FXSGS:
1144 case ANALOG_SIG_FXSKS:
1146 ast_debug(1, "Ignore possible polarity reversal on line seizure\n");
1148 }
1149 /* fall through */
1150 case ANALOG_SIG_EMWINK:
1151 case ANALOG_SIG_EM:
1152 case ANALOG_SIG_EM_E1:
1153 case ANALOG_SIG_FEATD:
1154 case ANALOG_SIG_FEATDMF:
1155 case ANALOG_SIG_E911:
1158 case ANALOG_SIG_FEATB:
1159 case ANALOG_SIG_SFWINK:
1160 case ANALOG_SIG_SF:
1165 c = strchr(dest, '/');
1166 if (c) {
1167 c++;
1168 } else {
1169 c = "";
1170 }
1171 if (strlen(c) < p->stripmsd) {
1172 ast_log(LOG_WARNING, "Number '%s' is shorter than stripmsd (%d)\n", c, p->stripmsd);
1173 return -1;
1174 }
1175 res = analog_start(p);
1176 if (res < 0) {
1177 if (errno != EINPROGRESS) {
1178 return -1;
1179 }
1180 }
1181 ast_debug(1, "Dialing '%s'\n", c);
1183
1184 c += p->stripmsd;
1185
1186 switch (mysig) {
1187 case ANALOG_SIG_FEATD:
1189 if (l) {
1190 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T*%s*%s*", l, c);
1191 } else {
1192 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T**%s*", c);
1193 }
1194 break;
1195 case ANALOG_SIG_FEATDMF:
1197 if (l) {
1198 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*00%s#*%s#", l, c);
1199 } else {
1200 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*02#*%s#", c);
1201 }
1202 break;
1204 {
1205 const char *cic = "", *ozz = "";
1206
1207 /* If you have to go through a Tandem Access point you need to use this */
1208#ifndef STANDALONE
1209 ozz = pbx_builtin_getvar_helper(p->owner, "FEATDMF_OZZ");
1210 if (!ozz) {
1211 ozz = analog_defaultozz;
1212 }
1213 cic = pbx_builtin_getvar_helper(p->owner, "FEATDMF_CIC");
1214 if (!cic) {
1215 cic = analog_defaultcic;
1216 }
1217#endif
1218 if (!ozz || !cic) {
1219 ast_log(LOG_WARNING, "Unable to dial channel of type feature group D MF tandem access without CIC or OZZ set\n");
1220 return -1;
1221 }
1222 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s%s#", ozz, cic);
1223 snprintf(p->finaldial, sizeof(p->finaldial), "M*%s#", c);
1224 p->whichwink = 0;
1225 }
1226 break;
1227 case ANALOG_SIG_E911:
1228 ast_copy_string(p->dop.dialstr, "M*911#", sizeof(p->dop.dialstr));
1229 break;
1231 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%s", c);
1232 break;
1234 case ANALOG_SIG_FEATB:
1235 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "M*%s#", c);
1236 break;
1237 default:
1238 if (p->pulse) {
1239 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "P%sw", c);
1240 } else {
1241 snprintf(p->dop.dialstr, sizeof(p->dop.dialstr), "T%sw", c);
1242 }
1243 break;
1244 }
1245
1246 if (p->echotraining && (strlen(p->dop.dialstr) > 4)) {
1247 memset(p->echorest, 'w', sizeof(p->echorest) - 1);
1248 strcpy(p->echorest + (p->echotraining / 400) + 1, p->dop.dialstr + strlen(p->dop.dialstr) - 2);
1249 p->echorest[sizeof(p->echorest) - 1] = '\0';
1250 p->echobreak = 1;
1251 p->dop.dialstr[strlen(p->dop.dialstr)-2] = '\0';
1252 } else {
1253 p->echobreak = 0;
1254 }
1256 if (!res) {
1257 if (analog_dial_digits(p, ANALOG_SUB_REAL, &p->dop)) {
1258 analog_on_hook(p);
1259 return -1;
1260 }
1261 } else {
1262 ast_debug(1, "Deferring dialing...\n");
1263 }
1264 analog_set_dialing(p, 1);
1265 if (ast_strlen_zero(c)) {
1266 p->dialednone = 1;
1267 }
1269 break;
1270 default:
1271 ast_debug(1, "not yet implemented\n");
1272 return -1;
1273 }
1274 return 0;
1275}
#define AST_CC_GENERIC_MONITOR_TYPE
Definition: ccss.h:455
@ AST_CC_CCNR
Definition: ccss.h:38
@ AST_CC_MONITOR_NEVER
Definition: ccss.h:76
@ AST_CC_MONITOR_ALWAYS
Definition: ccss.h:87
@ AST_CC_MONITOR_NATIVE
Definition: ccss.h:78
@ AST_CC_MONITOR_GENERIC
Definition: ccss.h:83
enum ast_cc_monitor_policies ast_get_cc_monitor_policy(struct ast_cc_config_params *config)
Get the cc_monitor_policy.
Definition: ccss.c:876
int ast_queue_cc_frame(struct ast_channel *chan, const char *const monitor_type, const char *const dialstring, enum ast_cc_service_type service, void *private_data)
Queue an AST_CONTROL_CC frame.
Definition: ccss.c:4114
struct ast_party_redirecting * ast_channel_redirecting(struct ast_channel *chan)
struct ast_party_connected_line * ast_channel_connected(struct ast_channel *chan)
struct ast_cc_config_params * ast_channel_get_cc_config_params(struct ast_channel *chan)
Get the CCSS parameters from a channel.
Definition: channel.c:10496
@ AST_CONTROL_BUSY
const char * pbx_builtin_getvar_helper(struct ast_channel *chan, const char *name)
Return a pointer to the value of the corresponding channel variable.
static const char * analog_get_orig_dialstring(struct analog_pvt *p)
Definition: sig_analog.c:186
static char analog_defaultozz[64]
Definition: sig_analog.c:66
static int analog_callwait(struct analog_pvt *p)
Definition: sig_analog.c:871
static void analog_set_outgoing(struct analog_pvt *p, int is_outgoing)
Definition: sig_analog.c:537
static char analog_defaultcic[64]
Definition: sig_analog.c:65
static void analog_set_cadence(struct analog_pvt *p, struct ast_channel *chan)
Definition: sig_analog.c:888
static int analog_start(struct analog_pvt *p)
Definition: sig_analog.c:513
static void analog_set_waitingfordt(struct analog_pvt *p, struct ast_channel *ast)
Definition: sig_analog.c:919
@ ANALOG_TONE_RINGTONE
Definition: sig_analog.h:71
int attribute_pure ast_true(const char *val)
Make sure something is true. Determine if a string containing a boolean value is "true"....
Definition: utils.c:2199
int redirecting_reason
Definition: sig_analog.h:356
unsigned int pulse
Definition: sig_analog.h:302
char callwait_num[AST_MAX_EXTENSION]
Definition: sig_analog.h:351
char lastcid_name[AST_MAX_EXTENSION]
Definition: sig_analog.h:354
unsigned int call_qualifier
Definition: sig_analog.h:349
int stripmsd
Definition: sig_analog.h:325
char callwait_name[AST_MAX_EXTENSION]
Definition: sig_analog.h:352
struct ast_party_id id
Connected party ID.
Definition: channel.h:460
int code
enum AST_REDIRECTING_REASON value for redirection
Definition: channel.h:512
struct ast_party_redirecting_reason reason
Reason for the redirection.
Definition: channel.h:544
struct ast_party_id from
Who is redirecting the call (Sent to the party the call is redirected toward)
Definition: channel.h:529

References analog_callwait(), analog_defaultcic, analog_defaultozz, analog_dial_digits(), ANALOG_DIAL_OP_REPLACE, analog_get_index, analog_get_orig_dialstring(), analog_on_hook(), analog_play_tone(), analog_ring(), analog_set_cadence(), analog_set_dialing(), analog_set_outgoing(), analog_set_waitingfordt(), ANALOG_SIG_E911, ANALOG_SIG_EM, ANALOG_SIG_EM_E1, ANALOG_SIG_EMWINK, ANALOG_SIG_FEATB, ANALOG_SIG_FEATD, ANALOG_SIG_FEATDMF, ANALOG_SIG_FEATDMF_TA, ANALOG_SIG_FGC_CAMA, ANALOG_SIG_FGC_CAMAMF, ANALOG_SIG_FXOGS, ANALOG_SIG_FXOKS, ANALOG_SIG_FXOLS, ANALOG_SIG_FXSGS, ANALOG_SIG_FXSKS, ANALOG_SIG_FXSLS, ANALOG_SIG_SF, ANALOG_SIG_SF_FEATB, ANALOG_SIG_SF_FEATD, ANALOG_SIG_SF_FEATDMF, ANALOG_SIG_SFWINK, analog_start(), ANALOG_SUB_CALLWAIT, ANALOG_SUB_REAL, ANALOG_TONE_RINGTONE, analog_pvt::answeronpolarityswitch, AST_CC_CCNR, AST_CC_GENERIC_MONITOR_TYPE, AST_CC_MONITOR_ALWAYS, AST_CC_MONITOR_GENERIC, AST_CC_MONITOR_NATIVE, AST_CC_MONITOR_NEVER, ast_channel_connected(), ast_channel_get_cc_config_params(), ast_channel_lock, ast_channel_name(), ast_channel_redirecting(), ast_channel_unlock, AST_CONTROL_BUSY, AST_CONTROL_RINGING, ast_copy_string(), ast_debug, ast_get_cc_monitor_policy(), ast_log, ast_queue_cc_frame(), ast_queue_control(), ast_setstate(), AST_STATE_BUSY, AST_STATE_DIALING, AST_STATE_DOWN, AST_STATE_RESERVED, AST_STATE_RINGING, ast_strlen_zero(), ast_true(), ast_tvnow(), c, analog_pvt::call_qualifier, analog_pvt::caller, analog_pvt::callwait_name, analog_pvt::callwait_num, ast_party_redirecting_reason::code, analog_pvt::dialdest, analog_pvt::dialednone, analog_dialoperation::dialstr, analog_pvt::dop, analog_pvt::echobreak, analog_pvt::echorest, analog_pvt::echotraining, errno, analog_pvt::finaldial, ast_party_redirecting::from, analog_pvt::hanguponpolarityswitch, ast_party_caller::id, ast_party_connected_line::id, analog_pvt::lastcid_name, analog_pvt::lastcid_num, LOG_WARNING, name, ast_party_id::name, NULL, ast_party_id::number, analog_dialoperation::op, analog_pvt::outsigmod, analog_subchannel::owner, analog_pvt::owner, pbx_builtin_getvar_helper(), analog_pvt::polaritydelaytv, ast_party_name::presentation, ast_party_number::presentation, analog_pvt::pulse, ast_party_redirecting::reason, analog_pvt::redirecting_reason, S_COR, analog_pvt::sig, ast_party_name::str, ast_party_number::str, analog_pvt::stripmsd, analog_pvt::subs, analog_pvt::use_callerid, ast_party_name::valid, ast_party_number::valid, and analog_pvt::whichwink.

Referenced by dahdi_call().

◆ analog_callwait()

static int analog_callwait ( struct analog_pvt p)
static

Definition at line 871 of file sig_analog.c.

872{
876 }
877 return 0;
878}
int(*const callwait)(void *pvt)
Definition: sig_analog.h:197
unsigned int callwaitingcallerid
Definition: sig_analog.h:309

References analog_callbacks, analog_callback::callwait, analog_pvt::callwaitcas, analog_pvt::callwaitingcallerid, and analog_pvt::chan_pvt.

Referenced by analog_call().

◆ analog_cancel_cidspill()

static void analog_cancel_cidspill ( struct analog_pvt p)
static

Definition at line 951 of file sig_analog.c.

952{
955 }
956}
void(*const cancel_cidspill)(void *pvt)
Definition: sig_analog.h:247

References analog_callbacks, analog_callback::cancel_cidspill, and analog_pvt::chan_pvt.

Referenced by __analog_handle_event(), and analog_handle_init_event().

◆ analog_canmatch_featurecode()

static int analog_canmatch_featurecode ( const char *  pickupexten,
const char *  exten 
)
static

Definition at line 1715 of file sig_analog.c.

1716{
1717 int extlen = strlen(exten);
1718 if (!extlen) {
1719 return 1;
1720 }
1721 if (extlen < strlen(pickupexten) && !strncmp(pickupexten, exten, extlen)) {
1722 return 1;
1723 }
1724 /* hardcoded features are *60, *67, *69, *70, *72, *73, *78, *79, *82, *0 */
1725 if (exten[0] == '*' && extlen < 3) {
1726 if (extlen == 1) {
1727 return 1;
1728 }
1729 /* "*0" should be processed before it gets here */
1730 switch (exten[1]) {
1731 case '6':
1732 case '7':
1733 case '8':
1734 return 1;
1735 }
1736 }
1737 return 0;
1738}

Referenced by __analog_ss_thread().

◆ analog_cb_handle_dtmf()

static void analog_cb_handle_dtmf ( struct analog_pvt p,
struct ast_channel ast,
enum analog_sub  analog_index,
struct ast_frame **  dest 
)
static

Definition at line 667 of file sig_analog.c.

668{
670 analog_callbacks.handle_dtmf(p->chan_pvt, ast, analog_index, dest);
671 }
672}
void(*const handle_dtmf)(void *pvt, struct ast_channel *ast, enum analog_sub analog_index, struct ast_frame **dest)
Definition: sig_analog.h:154

References analog_callbacks, analog_pvt::chan_pvt, and analog_callback::handle_dtmf.

Referenced by analog_handle_dtmf().

◆ analog_check_confirmanswer()

static int analog_check_confirmanswer ( struct analog_pvt p)
static

Definition at line 942 of file sig_analog.c.

943{
946 }
947
948 return 0;
949}
int(*const check_confirmanswer)(void *pvt)
Definition: sig_analog.h:245

References analog_callbacks, analog_pvt::chan_pvt, and analog_callback::check_confirmanswer.

Referenced by __analog_handle_event(), and analog_handle_dtmf().

◆ analog_check_for_conference()

static int analog_check_for_conference ( struct analog_pvt p)
static

Definition at line 545 of file sig_analog.c.

546{
549 }
550 return -1;
551}
int(*const check_for_conference)(void *pvt)
Definition: sig_analog.h:223

References analog_callbacks, analog_pvt::chan_pvt, and analog_callback::check_for_conference.

Referenced by __analog_handle_event().

◆ analog_check_waitingfordt()

static int analog_check_waitingfordt ( struct analog_pvt p)
static

Definition at line 926 of file sig_analog.c.

927{
930 }
931
932 return 0;
933}
int(*const check_waitingfordt)(void *pvt)
Definition: sig_analog.h:243

References analog_callbacks, analog_pvt::chan_pvt, and analog_callback::check_waitingfordt.

Referenced by __analog_handle_event().

◆ analog_cidstart_to_str()

const char * analog_cidstart_to_str ( enum analog_cid_start  cid_start)

Definition at line 249 of file sig_analog.c.

250{
251 switch (cid_start) {
253 return "Ring";
255 return "Polarity";
257 return "Polarity_In";
259 return "DTMF";
260 }
261
262 return "Unknown";
263}

References ANALOG_CID_START_DTMF_NOALERT, ANALOG_CID_START_POLARITY, ANALOG_CID_START_POLARITY_IN, and ANALOG_CID_START_RING.

◆ analog_cidtype_to_str()

const char * analog_cidtype_to_str ( unsigned int  cid_type)

Definition at line 149 of file sig_analog.c.

150{
151 int i;
152
153 for (i = 0; i < ARRAY_LEN(cidtypes); i++) {
154 if (cid_type == cidtypes[i].cid_type) {
155 return cidtypes[i].name;
156 }
157 }
158
159 return "Unknown";
160}
static const struct @142 cidtypes[]
unsigned int cid_type
Definition: sig_analog.c:96

References ARRAY_LEN, cid_type, and cidtypes.

◆ analog_config_complete()

int analog_config_complete ( struct analog_pvt p)

Definition at line 4109 of file sig_analog.c.

4110{
4111 /* No call waiting on non FXS channels */
4112 if ((p->sig != ANALOG_SIG_FXOKS) && (p->sig != ANALOG_SIG_FXOLS) && (p->sig != ANALOG_SIG_FXOGS)) {
4113 p->permcallwaiting = 0;
4114 }
4115
4117
4118 return 0;
4119}
unsigned int permcallwaiting
Definition: sig_analog.h:300

References analog_set_callwaiting(), ANALOG_SIG_FXOGS, ANALOG_SIG_FXOKS, ANALOG_SIG_FXOLS, analog_pvt::permcallwaiting, and analog_pvt::sig.

Referenced by mkintf().

◆ analog_confmute()

static int analog_confmute ( struct analog_pvt p,
int  mute 
)
static

Definition at line 958 of file sig_analog.c.

959{
961 return analog_callbacks.confmute(p->chan_pvt, mute);
962 }
963 return 0;
964}
int(*const confmute)(void *pvt, int mute)
Definition: sig_analog.h:248

References analog_callbacks, analog_pvt::chan_pvt, and analog_callback::confmute.

Referenced by __analog_handle_event().

◆ analog_deadlock_avoidance_private()

static void analog_deadlock_avoidance_private ( struct analog_pvt p)
static

Definition at line 574 of file sig_analog.c.

575{
578 } else {
579 /* Fallback to manual avoidance if callback not present. */
581 usleep(1);
583 }
584}
void(*const deadlock_avoidance_private)(void *pvt)
Definition: sig_analog.h:149

References analog_callbacks, analog_lock_private(), analog_unlock_private(), analog_pvt::chan_pvt, and analog_callback::deadlock_avoidance_private.

Referenced by analog_lock_sub_owner().

◆ analog_decrease_ss_count()

static void analog_decrease_ss_count ( void  )
static

Definition at line 1671 of file sig_analog.c.

1672{
1675 }
1676}
void(*const decrease_ss_count)(void)
Definition: sig_analog.h:228

References analog_callbacks, and analog_callback::decrease_ss_count.

Referenced by __analog_ss_thread().

◆ analog_delete()

void analog_delete ( struct analog_pvt doomed)

Delete the analog private structure.

Since
1.8
Parameters
doomedAnalog private structure to delete.

Definition at line 4104 of file sig_analog.c.

4105{
4106 ast_free(doomed);
4107}
#define ast_free(a)
Definition: astmm.h:180

References ast_free.

Referenced by destroy_dahdi_pvt().

◆ analog_dial_digits()

static int analog_dial_digits ( struct analog_pvt p,
enum analog_sub  sub,
struct analog_dialoperation dop 
)
static

Definition at line 521 of file sig_analog.c.

522{
524 return analog_callbacks.dial_digits(p->chan_pvt, sub, dop);
525 }
526 return -1;
527}
struct stasis_forward * sub
Definition: res_corosync.c:240
int(*const dial_digits)(void *pvt, enum analog_sub sub, struct analog_dialoperation *dop)
Definition: sig_analog.h:180

References analog_callbacks, analog_pvt::chan_pvt, analog_callback::dial_digits, and sub.

Referenced by __analog_handle_event(), and analog_call().

◆ analog_distinctive_ring()

static int analog_distinctive_ring ( struct ast_channel chan,
struct analog_pvt p,
int  idx,
int *  ringdata 
)
static

Definition at line 1678 of file sig_analog.c.

1679{
1681 return 0;
1682 }
1684 return analog_callbacks.distinctive_ring(chan, p->chan_pvt, idx, ringdata);
1685 }
1686 return -1;
1687
1688}
int(*const distinctive_ring)(struct ast_channel *chan, void *pvt, int idx, int *ringdata)
Definition: sig_analog.h:230

References analog_callbacks, analog_pvt::chan_pvt, analog_callback::distinctive_ring, and analog_pvt::usedistinctiveringdetection.

Referenced by __analog_ss_thread().

◆ analog_dnd()

int analog_dnd ( struct analog_pvt p,
int  flag 
)

Definition at line 4165 of file sig_analog.c.

4166{
4167 if (flag == -1) {
4168 return p->dnd;
4169 }
4170
4171 p->dnd = flag;
4172
4173 ast_verb(3, "%s DND on channel %d\n",
4174 flag ? "Enabled" : "Disabled",
4175 p->channel);
4176 analog_publish_dnd_state(p->channel, flag ? "enabled" : "disabled");
4177
4178 return 0;
4179}
long int flag
Definition: f2c.h:83
static void analog_publish_dnd_state(int channel, const char *status)
Definition: sig_analog.c:4145

References analog_publish_dnd_state(), ast_verb, analog_pvt::channel, and analog_pvt::dnd.

Referenced by __analog_ss_thread(), and dahdi_dnd().

◆ analog_dsp_reset_and_flush_digits()

static int analog_dsp_reset_and_flush_digits ( struct analog_pvt p)
static

Definition at line 428 of file sig_analog.c.

429{
432 }
433
434 /* Return 0 since I think this is unnecessary to do in most cases it is used. Mostly only for ast_dsp */
435 return 0;
436}
int(*const dsp_reset_and_flush_digits)(void *pvt)
Definition: sig_analog.h:187

References analog_callbacks, analog_pvt::chan_pvt, and analog_callback::dsp_reset_and_flush_digits.

Referenced by __analog_ss_thread().

◆ analog_dsp_set_digitmode()

static int analog_dsp_set_digitmode ( struct analog_pvt p,
enum analog_dsp_digitmode  mode 
)
static

Definition at line 659 of file sig_analog.c.

660{
663 }
664 return -1;
665}
int(*const dsp_set_digitmode)(void *pvt, enum analog_dsp_digitmode mode)
Definition: sig_analog.h:186

References analog_callbacks, analog_pvt::chan_pvt, and analog_callback::dsp_set_digitmode.

Referenced by __analog_ss_thread(), and analog_hangup().

◆ analog_event2str()

static char * analog_event2str ( enum analog_event  event)
static

Definition at line 265 of file sig_analog.c.

266{
267 char *res;
268 switch (event) {
270 res = "ANALOG_EVENT_ONHOOK";
271 break;
273 res = "ANALOG_EVENT_RINGOFFHOOK";
274 break;
276 res = "ANALOG_EVENT_WINKFLASH";
277 break;
279 res = "ANALOG_EVENT_ALARM";
280 break;
282 res = "ANALOG_EVENT_NOALARM";
283 break;
285 res = "ANALOG_EVENT_DIALCOMPLETE";
286 break;
288 res = "ANALOG_EVENT_HOOKCOMPLETE";
289 break;
291 res = "ANALOG_EVENT_PULSE_START";
292 break;
294 res = "ANALOG_EVENT_POLARITY";
295 break;
297 res = "ANALOG_EVENT_RINGBEGIN";
298 break;
300 res = "ANALOG_EVENT_EC_DISABLED";
301 break;
303 res = "ANALOG_EVENT_RINGERON";
304 break;
306 res = "ANALOG_EVENT_RINGEROFF";
307 break;
309 res = "ANALOG_EVENT_REMOVED";
310 break;
312 res = "ANALOG_EVENT_NEONMWI_ACTIVE";
313 break;
315 res = "ANALOG_EVENT_NEONMWI_INACTIVE";
316 break;
317#ifdef HAVE_DAHDI_ECHOCANCEL_FAX_MODE
319 res = "ANALOG_EVENT_TX_CED_DETECTED";
320 break;
322 res = "ANALOG_EVENT_RX_CED_DETECTED";
323 break;
325 res = "ANALOG_EVENT_EC_NLP_DISABLED";
326 break;
328 res = "ANALOG_EVENT_EC_NLP_ENABLED";
329 break;
330#endif
332 res = "ANALOG_EVENT_PULSEDIGIT";
333 break;
335 res = "ANALOG_EVENT_DTMFDOWN";
336 break;
338 res = "ANALOG_EVENT_DTMFUP";
339 break;
340 default:
341 res = "UNKNOWN/OTHER";
342 break;
343 }
344
345 return res;
346}
@ ANALOG_EVENT_NEONMWI_ACTIVE
Definition: sig_analog.h:95
@ ANALOG_EVENT_NEONMWI_INACTIVE
Definition: sig_analog.h:96
@ ANALOG_EVENT_REMOVED
Definition: sig_analog.h:94
Definition: astman.c:222

References ANALOG_EVENT_ALARM, ANALOG_EVENT_DIALCOMPLETE, ANALOG_EVENT_DTMFDOWN, ANALOG_EVENT_DTMFUP, ANALOG_EVENT_EC_DISABLED, ANALOG_EVENT_EC_NLP_DISABLED, ANALOG_EVENT_EC_NLP_ENABLED, ANALOG_EVENT_HOOKCOMPLETE, ANALOG_EVENT_NEONMWI_ACTIVE, ANALOG_EVENT_NEONMWI_INACTIVE, ANALOG_EVENT_NOALARM, ANALOG_EVENT_ONHOOK, ANALOG_EVENT_POLARITY, ANALOG_EVENT_PULSE_START, ANALOG_EVENT_PULSEDIGIT, ANALOG_EVENT_REMOVED, ANALOG_EVENT_RINGBEGIN, ANALOG_EVENT_RINGEROFF, ANALOG_EVENT_RINGERON, ANALOG_EVENT_RINGOFFHOOK, ANALOG_EVENT_RX_CED_DETECTED, ANALOG_EVENT_TX_CED_DETECTED, and ANALOG_EVENT_WINKFLASH.

Referenced by __analog_handle_event(), analog_exception(), and analog_handle_init_event().

◆ analog_exception()

struct ast_frame * analog_exception ( struct analog_pvt p,
struct ast_channel ast 
)

Definition at line 3673 of file sig_analog.c.

3674{
3675 int res;
3676 int idx;
3677 struct ast_frame *f;
3678
3679 ast_debug(1, "%s %d\n", __FUNCTION__, p->channel);
3680
3681 idx = analog_get_index(ast, p, 1);
3682 if (idx < 0) {
3683 idx = ANALOG_SUB_REAL;
3684 }
3685
3686 p->subs[idx].f.frametype = AST_FRAME_NULL;
3687 p->subs[idx].f.datalen = 0;
3688 p->subs[idx].f.samples = 0;
3689 p->subs[idx].f.mallocd = 0;
3690 p->subs[idx].f.offset = 0;
3691 p->subs[idx].f.subclass.integer = 0;
3692 p->subs[idx].f.delivery = ast_tv(0,0);
3693 p->subs[idx].f.src = "dahdi_exception";
3694 p->subs[idx].f.data.ptr = NULL;
3695
3696 if (!p->owner) {
3697 /* If nobody owns us, absorb the event appropriately, otherwise
3698 we loop indefinitely. This occurs when, during call waiting, the
3699 other end hangs up our channel so that it no longer exists, but we
3700 have neither FLASH'd nor ONHOOK'd to signify our desire to
3701 change to the other channel. */
3702 res = analog_get_event(p);
3703
3704 /* Switch to real if there is one and this isn't something really silly... */
3705 if ((res != ANALOG_EVENT_RINGEROFF) && (res != ANALOG_EVENT_RINGERON) &&
3706 (res != ANALOG_EVENT_HOOKCOMPLETE)) {
3707 ast_debug(1, "Restoring owner of channel %d on event %d\n", p->channel, res);
3709 if (p->owner && ast != p->owner) {
3710 /*
3711 * Could this even happen?
3712 * Possible deadlock because we do not have the real-call lock.
3713 */
3714 ast_log(LOG_WARNING, "Event %s on %s is not restored owner %s\n",
3716 }
3717 if (p->owner) {
3719 }
3720 }
3721 switch (res) {
3724 if (p->owner) {
3725 ast_verb(3, "Channel %s still has call, ringing phone\n", ast_channel_name(p->owner));
3726 analog_ring(p);
3728 } else {
3729 ast_log(LOG_WARNING, "Absorbed %s, but nobody is left!?!?\n",
3730 analog_event2str(res));
3731 }
3733 break;
3736 analog_off_hook(p);
3737 if (p->owner && (ast_channel_state(p->owner) == AST_STATE_RINGING)) {
3739 analog_set_dialing(p, 0);
3740 }
3741 break;
3745 /* Do nothing */
3746 break;
3748 gettimeofday(&p->flashtime, NULL);
3749 if (p->owner) {
3750 ast_verb(3, "Channel %d flashed to other channel %s\n", p->channel, ast_channel_name(p->owner));
3752 /* Answer if necessary */
3755 }
3758 } else {
3759 ast_log(LOG_WARNING, "Absorbed %s, but nobody is left!?!?\n",
3760 analog_event2str(res));
3761 }
3763 break;
3764 default:
3765 ast_log(LOG_WARNING, "Don't know how to absorb event %s\n", analog_event2str(res));
3766 break;
3767 }
3768 f = &p->subs[idx].f;
3769 return f;
3770 }
3771 ast_debug(1, "Exception on %d, channel %d\n", ast_channel_fd(ast, 0), p->channel);
3772 /* If it's not us, return NULL immediately */
3773 if (ast != p->owner) {
3774 ast_log(LOG_WARNING, "We're %s, not %s\n", ast_channel_name(ast), ast_channel_name(p->owner));
3775 f = &p->subs[idx].f;
3776 return f;
3777 }
3778
3779 f = __analog_handle_event(p, ast);
3780 if (!f) {
3781 const char *name = ast_strdupa(ast_channel_name(ast));
3782
3783 /* Tell the CDR this DAHDI device hung up */
3785 ast_channel_unlock(ast);
3786 ast_set_hangupsource(ast, name, 0);
3787 ast_channel_lock(ast);
3789 }
3790 return f;
3791}
int ast_channel_fd(const struct ast_channel *chan, int which)
void ast_set_hangupsource(struct ast_channel *chan, const char *source, int force)
Set the source of the hangup in this channel and it's bridge.
Definition: channel.c:2518
static struct ast_frame * __analog_handle_event(struct analog_pvt *p, struct ast_channel *ast)
Definition: sig_analog.c:2773
struct timeval delivery
struct timeval ast_tv(ast_time_t sec, ast_suseconds_t usec)
Returns a timeval from sec, usec.
Definition: time.h:235

References __analog_handle_event(), analog_event2str(), ANALOG_EVENT_HOOKCOMPLETE, ANALOG_EVENT_ONHOOK, ANALOG_EVENT_RINGEROFF, ANALOG_EVENT_RINGERON, ANALOG_EVENT_RINGOFFHOOK, ANALOG_EVENT_WINKFLASH, analog_get_event(), analog_get_index, analog_lock_private(), analog_off_hook(), analog_ring(), analog_set_dialing(), analog_set_echocanceller(), analog_set_new_owner(), analog_stop_callwait(), ANALOG_SUB_REAL, analog_unlock_private(), analog_update_conf(), ast_channel_fd(), ast_channel_lock, ast_channel_name(), ast_channel_unlock, AST_CONTROL_ANSWER, ast_debug, AST_FRAME_NULL, ast_log, ast_queue_control(), ast_queue_unhold(), ast_set_hangupsource(), ast_setstate(), AST_STATE_RINGING, AST_STATE_UP, ast_strdupa, ast_tv(), ast_verb, analog_pvt::channel, ast_frame::data, ast_frame::datalen, ast_frame::delivery, analog_subchannel::f, analog_pvt::flashtime, ast_frame::frametype, ast_frame_subclass::integer, LOG_WARNING, ast_frame::mallocd, name, NULL, ast_frame::offset, analog_subchannel::owner, analog_pvt::owner, ast_frame::ptr, ast_frame::samples, ast_frame::src, ast_frame::subclass, and analog_pvt::subs.

Referenced by dahdi_exception(), and dahdi_read().

◆ analog_fixup()

int analog_fixup ( struct ast_channel oldchan,
struct ast_channel newchan,
void *  newp 
)

Definition at line 4127 of file sig_analog.c.

4128{
4129 struct analog_pvt *new_pvt = newp;
4130 int x;
4131 ast_debug(1, "New owner for channel %d is %s\n", new_pvt->channel, ast_channel_name(newchan));
4132 if (new_pvt->owner == oldchan) {
4133 analog_set_new_owner(new_pvt, newchan);
4134 }
4135 for (x = 0; x < 3; x++) {
4136 if (new_pvt->subs[x].owner == oldchan) {
4137 new_pvt->subs[x].owner = newchan;
4138 }
4139 }
4140
4141 analog_update_conf(new_pvt);
4142 return 0;
4143}

References analog_set_new_owner(), analog_update_conf(), ast_channel_name(), ast_debug, analog_pvt::channel, analog_subchannel::owner, analog_pvt::owner, and analog_pvt::subs.

Referenced by dahdi_fixup().

◆ analog_flash()

static int analog_flash ( struct analog_pvt p)
static

Definition at line 505 of file sig_analog.c.

506{
509 }
510 return -1;
511}
int(*const flash)(void *pvt)
Definition: sig_analog.h:163

References analog_callbacks, analog_pvt::chan_pvt, and analog_callback::flash.

Referenced by __analog_ss_thread().

◆ analog_free()

void analog_free ( struct analog_pvt p)

Definition at line 4121 of file sig_analog.c.

4122{
4123 ast_free(p);
4124}