1 /*! 2 * \file sccp_channel.h 3 * \brief SCCP Channel Header 4 * \author Sergio Chersovani <mlists [at] c-net.it> 5 * \date 6 * \note Reworked, but based on chan_sccp code. 7 * The original chan_sccp driver that was made by Zozo which itself was derived from the chan_skinny driver. 8 * Modified by Jan Czmok and Julien Goodwin 9 * \note This program is free software and may be modified and distributed under the terms of the GNU Public License. 10 * See the LICENSE file at the top of the source tree. 11 */ 12 13 #pragma once 14 15 #include "sccp_rtp.h" 16 17 #define sccp_channel_retain(_x) sccp_refcount_retain_type(sccp_channel_t, _x) 18 #define sccp_channel_release(_x) sccp_refcount_release_type(sccp_channel_t, _x) 19 #define sccp_channel_refreplace(_x, _y) sccp_refcount_refreplace_type(sccp_channel_t, _x, _y) 20 21 __BEGIN_C_EXTERN__ 22 /*! 23 * \brief SCCP Channel Structure 24 * \note This contains the current channel information 25 */ 26 struct sccp_channel { 27 const uint32_t callid; /*!< Call ID */ 28 const uint32_t passthrupartyid; /*!< Pass Through ID */ 29 sccp_channelstate_t state; /*!< Internal channel state SCCP_CHANNELSTATE_* */ 30 sccp_channelstate_t previousChannelState; /*!< Previous channel state SCCP_CHANNELSTATE_* */ 31 sccp_channelstatereason_t channelStateReason; /*!< Reason the new/current state was set (for example to handle HOLD differently for transfer then normal) */ 32 skinny_calltype_t calltype; /*!< Skinny Call Type as SKINNY_CALLTYPE_* */ 33 sccp_mutex_t lock; 34 35 PBX_CHANNEL_TYPE *owner; /*!< Asterisk Channel Owner */ 36 sccp_line_t * const line; /*!< SCCP Line */ 37 SCCP_LIST_ENTRY (sccp_channel_t) list; /*!< Channel Linked List */ 38 char dialedNumber[SCCP_MAX_EXTENSION]; /*!< Last Dialed Number */ 39 const char * const designator; 40 sccp_subscription_id_t subscriptionId; 41 boolean_t answered_elsewhere; /*!< Answered Elsewhere */ 42 boolean_t privacy; /*!< Private */ 43 boolean_t peerIsSCCP; /*!< Indicates that channel-peer is also SCCP */ 44 sccp_video_mode_t videomode; /*!< Video Mode (0 off - 1 user - 2 auto) */ 45 46 devicePtr (*getDevice)(constChannelPtr channel); /*!< function to retrieve refcounted device */ 47 lineDevicePtr (*getLineDevice)(constChannelPtr channel); /*!< function to retrieve refcounted linedevice */ 48 void (*setDevice)(channelPtr channel, constDevicePtr device, boolean_t activate); /*!< set refcounted device connected to the channel */ 49 char currentDeviceId[StationMaxDeviceNameSize]; /*!< Returns a constant char of the Device Id if available */ 50 51 sccp_private_channel_data_t * const privateData; 52 53 skinny_capabilities_t capabilities; /*!< our channel Capability in preference order */ 54 skinny_capabilities_t preferences; 55 skinny_capabilities_t remoteCapabilities; 56 57 #if ASTERISK_VERSION_GROUP >= 113 58 struct ast_format_cap *caps; 59 #endif 60 struct { 61 uint32_t digittimeout; /*!< Digit Timeout on Dialing State (Enbloc-Emu) */ 62 uint32_t totaldigittime; /*!< Total Time used to enter Number (Enbloc-Emu) */ 63 uint32_t totaldigittimesquared; /*!< Total Time Squared used to enter Number (Enbloc-Emu) */ 64 boolean_t deactivate; /*!< Deactivate Enbloc-Emulation (Time Deviation Found) */ 65 } enbloc; 66 67 struct { 68 #ifndef SCCP_ATOMIC 69 sccp_mutex_t lock; 70 #endif 71 volatile CAS32_TYPE deny; 72 int digittimeout_id; /*!< Schedule for Timeout on Dialing State */ 73 int hangup_id; /*!< Automatic hangup after invalid/congested indication */ 74 int cfwd_noanswer_id; /*!< Forward call when noanswer */ 75 } scheduler; 76 77 sccp_dtmfmode_t dtmfmode; /*!< DTMF Mode (0 inband - 1 outofband) */ 78 struct { 79 sccp_rtp_t audio; /*!< Asterisk RTP */ 80 sccp_rtp_t video; /*!< Video RTP session */ 81 //sccp_rtp_t text; /*!< Video RTP session */ 82 uint8_t peer_dtmfmode; 83 } rtp; 84 85 skinny_ringtype_t ringermode; /*!< Ringer Mode */ 86 87 /* don't allow sccp phones to monitor (hint) this call */ 88 sccp_softswitch_t softswitch_action; /*!< Simple Switch Action. This is used in dial thread to collect numbers for callforward, pickup and so on -FS */ 89 uint16_t ss_data; /*!< Simple Switch Integer param */ 90 uint16_t subscribers; /*!< Used to determine if a sharedline should be hungup immediately, if everybody declined the call */ 91 92 int32_t maxBitRate; 93 94 sccp_conference_t *conference; /*!< are we part of a conference? */ /*! \todo to be removed instead of conference_id */ 95 uint32_t conference_id; /*!< Conference ID (might be safer to use instead of conference) */ 96 uint32_t conference_participant_id; /*!< Conference Participant ID */ 97 98 void (*setMicrophone)(channelPtr c, boolean_t on); 99 boolean_t (*hangupRequest) (constChannelPtr channel); 100 boolean_t (*isMicrophoneEnabled) (void); 101 boolean_t (*wantsEarlyRTP)(void); 102 boolean_t (*progressSent)(void); 103 void (*setTone)(constChannelPtr c, skinny_tone_t tone, skinny_toneDirection_t direction); 104 void (*setEarlyRTP)(channelPtr c, boolean_t state); 105 void (*makeProgress)(channelPtr c); 106 const char *const musicclass; /*!< Music Class */ 107 108 sccp_channel_t *parentChannel; /*!< if we are a cfwd channel, our parent is this */ 109 boolean_t isBarged; 110 boolean_t isBarging; 111 boolean_t isHangingUp; 112 boolean_t isRunningPbxThread; 113 114 sccp_autoanswer_t autoanswer_type; /*!< Auto Answer Type */ 115 uint16_t autoanswer_cause; /*!< Auto Answer Cause */ 116 pbx_event_subscription_t * parking_sub; 117 118 #if ASTERISK_VERSION_GROUP >= 111 119 pbx_callid_t pbx_callid; 120 #endif 121 }; /*!< SCCP Channel Structure */ 122 123 /*! 124 * \brief SCCP Currently Selected Channel Structure 125 */ 126 struct sccp_selectedchannel { 127 sccp_channel_t *channel; /*!< SCCP Channel */ 128 SCCP_LIST_ENTRY (sccp_selectedchannel_t) list; /*!< Selected Channel Linked List Entry */ 129 }; /*!< SCCP Selected Channel Structure */ 130 /* live cycle */ 131 SCCP_API channelPtr SCCP_CALL sccp_channel_allocate(constLinePtr l, constDevicePtr device); // device is optional 132 SCCP_API PBX_CHANNEL_TYPE * SCCP_CALL sccp_channel_lock_full(channelPtr c, boolean_t retry_indefinitly); 133 SCCP_API channelPtr SCCP_CALL sccp_channel_getEmptyChannel(constLinePtr l, constDevicePtr d, channelPtr maybe_c, skinny_calltype_t calltype, PBX_CHANNEL_TYPE * parentChannel, const void *ids); // retrieve or allocate new channel 134 SCCP_API channelPtr SCCP_CALL sccp_channel_newcall(constLinePtr l, constDevicePtr device, const char *dial, skinny_calltype_t calltype, PBX_CHANNEL_TYPE * parentChannel, const void *ids); 135 136 SCCP_API int SCCP_CALL sccp_getCallCount(constLineDevicePtr ld); 137 SCCP_API void SCCP_CALL sccp_channel_updateChannelCapability(channelPtr channel); 138 SCCP_API sccp_callinfo_t * const SCCP_CALL sccp_channel_getCallInfo(constChannelPtr channel); 139 SCCP_API void SCCP_CALL sccp_channel_send_callinfo(constDevicePtr device, constChannelPtr channel); 140 SCCP_API void SCCP_CALL sccp_channel_send_callinfo2(constChannelPtr channel); 141 SCCP_API void SCCP_CALL sccp_channel_setChannelstate(channelPtr channel, sccp_channelstate_t state); 142 SCCP_API void SCCP_CALL sccp_channel_display_callInfo(constChannelPtr channel); 143 SCCP_API void SCCP_CALL sccp_channel_set_callingparty(constChannelPtr channel, const char *name, const char *number); 144 SCCP_API boolean_t SCCP_CALL sccp_channel_set_originalCallingparty(constChannelPtr channel, char * name, char * number); 145 SCCP_API void SCCP_CALL sccp_channel_set_calledparty(constChannelPtr channel, const char * name, const char * number); 146 SCCP_API boolean_t SCCP_CALL sccp_channel_set_originalCalledparty(constChannelPtr channel, char * name, char * number); 147 SCCP_API void SCCP_CALL sccp_channel_set_calleridPresentation(constChannelPtr channel, sccp_callerid_presentation_t presentation); 148 SCCP_API boolean_t SCCP_CALL sccp_channel_finishHolePunch(constChannelPtr channel); 149 SCCP_API boolean_t SCCP_CALL sccp_channel_isAnswering(constChannelPtr c); 150 SCCP_API void SCCP_CALL sccp_channel_openReceiveChannel(constChannelPtr channel); 151 SCCP_API int SCCP_CALL sccp_channel_receiveChannelOpen(devicePtr d, channelPtr c); 152 SCCP_API void SCCP_CALL sccp_channel_closeReceiveChannel(constChannelPtr channel, boolean_t KeepPortOpen); 153 #if UNUSEDCODE // 2015-11-01 154 SCCP_API void SCCP_CALL sccp_channel_updateReceiveChannel(constChannelPtr c); 155 #endif 156 SCCP_API void SCCP_CALL sccp_channel_startMediaTransmission(constChannelPtr channel); 157 SCCP_API int SCCP_CALL sccp_channel_mediaTransmissionStarted(devicePtr d, channelPtr c); 158 SCCP_API void SCCP_CALL sccp_channel_stopMediaTransmission(constChannelPtr channel, boolean_t KeepPortOpen); 159 SCCP_API void SCCP_CALL sccp_channel_updateMediaTransmission(constChannelPtr channel); 160 SCCP_API void SCCP_CALL sccp_channel_openMultiMediaReceiveChannel(constChannelPtr channel); 161 SCCP_API int SCCP_CALL sccp_channel_receiveMultiMediaChannelOpen(constDevicePtr d, channelPtr c); 162 SCCP_API void SCCP_CALL sccp_channel_closeMultiMediaReceiveChannel(constChannelPtr channel, boolean_t KeepPortOpen); 163 #if UNUSEDCODE // 2015-11-01 164 SCCP_API void SCCP_CALL sccp_channel_updateMultiMediaReceiveChannel(constChannelPtr channel); 165 #endif 166 SCCP_API void SCCP_CALL sccp_channel_startMultiMediaTransmission(constChannelPtr channel); 167 SCCP_API int SCCP_CALL sccp_channel_multiMediaTransmissionStarted(constDevicePtr d, channelPtr c); 168 SCCP_API void SCCP_CALL sccp_channel_stopMultiMediaTransmission(constChannelPtr channel, boolean_t KeepPortOpen); 169 #if UNUSEDCODE // 2015-11-01 170 SCCP_API void SCCP_CALL sccp_channel_updateMultiMediaTransmission(constChannelPtr channel); 171 #endif 172 173 SCCP_API sccp_rtp_status_t SCCP_CALL sccp_channel_closeAllMediaTransmitAndReceive(constChannelPtr channel); 174 175 SCCP_API boolean_t SCCP_CALL sccp_channel_transfer_on_hangup(constChannelPtr channel); 176 SCCP_INLINE void SCCP_CALL sccp_channel_stop_schedule_digittimout(constChannelPtr channel); 177 SCCP_INLINE void SCCP_CALL sccp_channel_schedule_hangup(constChannelPtr channel, int timeout); 178 SCCP_INLINE void SCCP_CALL sccp_channel_schedule_digittimeout(constChannelPtr channel, int timeout); 179 SCCP_INLINE void SCCP_CALL sccp_channel_schedule_cfwd_noanswer(constChannelPtr channel, int timeout); 180 SCCP_INLINE void SCCP_CALL sccp_channel_stop_schedule_cfwd_noanswer(constChannelPtr channel); 181 SCCP_API void SCCP_CALL sccp_channel_end_forwarding_channel(channelPtr orig_channel); 182 SCCP_API void SCCP_CALL sccp_channel_endcall(channelPtr channel); 183 SCCP_API void SCCP_CALL sccp_channel_StatisticsRequest(constChannelPtr channel); 184 SCCP_API void SCCP_CALL sccp_channel_answer(constDevicePtr device, channelPtr channel); 185 SCCP_API void SCCP_CALL sccp_channel_stop_and_deny_scheduled_tasks(constChannelPtr channel); 186 SCCP_API void SCCP_CALL sccp_channel_addCleanupJob(channelPtr c, void *(*function_p) (void *), void *arg_p); 187 SCCP_API void SCCP_CALL sccp_channel_clean(channelPtr channel); 188 SCCP_API void SCCP_CALL sccp_channel_transfer(channelPtr channel, constDevicePtr device); 189 SCCP_API void SCCP_CALL sccp_channel_transfer_release(devicePtr d, channelPtr c); 190 SCCP_API void SCCP_CALL sccp_channel_transfer_cancel(devicePtr d, channelPtr c); 191 SCCP_API void SCCP_CALL sccp_channel_transfer_complete(channelPtr sccp_destination_local_channel); 192 SCCP_API int SCCP_CALL sccp_channel_hold(channelPtr channel); 193 SCCP_API int SCCP_CALL sccp_channel_resume(constDevicePtr device, channelPtr channel, boolean_t swap_channels); 194 SCCP_API int SCCP_CALL sccp_channel_forward(constChannelPtr sccp_channel_parent, constLineDevicePtr ld, const char * fwdNumber); 195 SCCP_API devicePtr SCCP_CALL sccp_channel_getDevice(constChannelPtr channel); 196 SCCP_API lineDevicePtr SCCP_CALL sccp_channel_getLineDevice(constChannelPtr channel); 197 SCCP_API void SCCP_CALL sccp_channel_setDevice(channelPtr channel, constDevicePtr device, boolean_t activate); 198 199 #ifdef CS_SCCP_PARK 200 SCCP_API void SCCP_CALL sccp_channel_park(constChannelPtr channel); 201 #endif 202 203 SCCP_API boolean_t SCCP_CALL sccp_channel_setPreferredCodec(channelPtr c, const char * data); 204 SCCP_API sccp_video_mode_t SCCP_CALL sccp_channel_getVideoMode(constChannelPtr c); 205 SCCP_API boolean_t SCCP_CALL sccp_channel_setVideoMode(channelPtr c, const char *data); 206 SCCP_API int SCCP_CALL sccp_channel_callwaiting_tone_interval(constDevicePtr device, constChannelPtr channel); 207 208 // find channel 209 SCCP_API channelPtr SCCP_CALL sccp_channel_find_byid(uint32_t callid); 210 SCCP_API channelPtr SCCP_CALL sccp_find_channel_on_line_byid(constLinePtr l, uint32_t id); 211 SCCP_API channelPtr SCCP_CALL sccp_channel_find_bypassthrupartyid(uint32_t passthrupartyid); 212 SCCP_API channelPtr SCCP_CALL sccp_channel_find_bystate_on_line(constLinePtr l, sccp_channelstate_t state); 213 SCCP_API channelPtr SCCP_CALL sccp_channel_find_bystate_on_device(constDevicePtr device, sccp_channelstate_t state); 214 SCCP_API channelPtr SCCP_CALL sccp_find_channel_by_lineInstance_and_callid(constDevicePtr d, const uint32_t lineInstance, const uint32_t callid); 215 SCCP_API channelPtr SCCP_CALL sccp_find_channel_by_buttonIndex_and_callid(constDevicePtr d, const uint32_t buttonIndex, const uint32_t callid); 216 SCCP_API channelPtr SCCP_CALL sccp_channel_find_on_device_bypassthrupartyid(constDevicePtr d, uint32_t passthrupartyid); 217 SCCP_API sccp_selectedchannel_t * SCCP_CALL sccp_device_find_selectedchannel(constDevicePtr d, constChannelPtr channel); 218 SCCP_API uint8_t SCCP_CALL sccp_device_selectedchannels_count(constDevicePtr device); 219 __END_C_EXTERN__ 220 // kate: indent-width 8; replace-tabs off; indent-mode cstyle; auto-insert-doxygen on; line-numbers on; tab-indents on; keep-extra-spaces off; auto-brackets off; 221