kenmirrors
/
freeswitch
mirror of https://github.com/signalwire/freeswitch.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity

changed file names 

git-svn-id: http://svn.freeswitch.org/svn/freeswitch/trunk@6099 d0543943-73ff-0310-b7d9-9358b9ac24b2
This commit is contained in:
Łukasz Zwierko 2007-10-31 17:28:37 +00:00
parent 9191273060
commit 2a1f2a0243
4 changed files with 946 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

258
src/mod/endpoints/mod_opal/mod_opal.cpp Normal file
View File

@ -0,0 +1,258 @@
/*
* mod_opalh323.cpp
*
* Opal-H323 gluer for Freeswitch
* This file implements fontend of OpalH323 module functions
* that is all functions that are used for communication
* between FreeSWITCH core and this module
*
*
* Copyright (c) 2007 Lukasz Zwierko (lzwierko@gmail.com)
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
*
* The Initial Developer of the Original Code is Lukasz Zwierko (lzwierko@gmail.com)
*
* Contributor(s):
*
* $Log: mod_opalh323.cpp,v $
*
* Revision 1.00 2007/10/24 07:29:52 lzwierko
* Initial revision
*/
#include "mod_opal.h"
#include "opal_backend.h"
#include <switch.h>
/*
* IO routines handlers definitions for H323
*/
static switch_call_cause_t opalh323_outgoing_channel(switch_core_session_t *, switch_caller_profile_t *, switch_core_session_t **, switch_memory_pool_t **);
static switch_status_t opalh323_read_frame(switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int);
static switch_status_t opalh323_write_frame(switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int);
static switch_status_t opalh323_kill_channel(switch_core_session_t *, int);
static switch_status_t opalh323_waitfor_read(switch_core_session_t *, int, int);
static switch_status_t opalh323_waitfor_write(switch_core_session_t *, int, int);
static switch_status_t opalh323_send_dtmf(switch_core_session_t *, char *);
static switch_status_t opalh323_receive_message(switch_core_session_t *, switch_core_session_message_t *);
static switch_status_t opalh323_receive_event(switch_core_session_t *, switch_event_t *);
static switch_status_t opalh323_state_change(switch_core_session_t *);
static switch_status_t opalh323_read_video_frame(switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int);
static switch_status_t opalh323_write_video_frame(switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int);
/*
* Event handlers declaration for H323
*/
static switch_status_t opalh323_on_init(switch_core_session_t *session);
static switch_status_t opalh323_on_ring(switch_core_session_t *session);
static switch_status_t opalh323_on_execute(switch_core_session_t *session);
static switch_status_t opalh323_on_hangup(switch_core_session_t *session);
static switch_status_t opalh323_on_loopback(switch_core_session_t *session);
static switch_status_t opalh323_on_transmit(switch_core_session_t *session);
/**
* Declaration of private variables
*/
static FSOpalManager *opal_manager = NULL;
static switch_memory_pool_t *opal_pool = NULL;
static switch_endpoint_interface_t *opalh323_endpoint_interface;
/*
* IO routines handlers set declaration
*/
static switch_io_routines_t opalh323_io_routines = {
/*.outgoing_channel */ opalh323_outgoing_channel,
/*.read_frame */ opalh323_read_frame,
/*.write_frame */ opalh323_write_frame,
/*.kill_channel */ opalh323_kill_channel,
/*.waitfor_read */ opalh323_waitfor_read,
/*.waitfor_read */ opalh323_waitfor_write,
/*.send_dtmf */ opalh323_send_dtmf,
/*.receive_message */ opalh323_receive_message,
/*.receive_event */ opalh323_receive_event,
/*.state_change*/ opalh323_state_change,
/*.read_video_frame*/ opalh323_read_video_frame,
/*.write_video_frame*/ opalh323_write_video_frame
};
static switch_state_handler_table_t opalh323_event_handlers = {
/*.on_init */ opalh323_on_init,
/*.on_ring */ opalh323_on_ring,
/*.on_execute */ opalh323_on_execute,
/*.on_hangup */ opalh323_on_hangup,
/*.on_loopback */ opalh323_on_loopback,
/*.on_transmit */ opalh323_on_transmit
};
/*
* Loadable FreeSWITCH module functions declaration
*/
SWITCH_MODULE_LOAD_FUNCTION(mod_opal_load);
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_opal_shutdown);
SWITCH_MODULE_DEFINITION(mod_opal, mod_opal_load, mod_opal_shutdown, NULL);
/*
* This function is called on module load
* It sets up:
* 1. frontend - interface to FreeSWITCH core
* 2. backend - inerface to OPAL core
*
*/
SWITCH_MODULE_LOAD_FUNCTION(mod_opal_load)
{
/* frontend initialization*/
*module_interface =NULL;
*module_interface = switch_loadable_module_create_module_interface(pool, modname);
assert(*module_interface);
if(!module_interface)
{
return SWITCH_STATUS_MEMERR;
}
opalh323_endpoint_interface = (switch_endpoint_interface_t*)switch_loadable_module_create_interface(*module_interface, SWITCH_ENDPOINT_INTERFACE);
opalh323_endpoint_interface->interface_name = "OPALH323";
opalh323_endpoint_interface->io_routines = &opalh323_io_routines;
opalh323_endpoint_interface->state_handler = &opalh323_event_handlers;
/* backend initialization */
opal_manager = new FSOpalManager();
assert(opal_manager);
if(!opal_manager)
{
return SWITCH_STATUS_MEMERR;
}
if(!opal_manager->initialize(modname,pool,opalh323_endpoint_interface))
{
delete opal_manager;
return SWITCH_STATUS_FALSE; /* if can't initialize return general error */
}
/* indicate that the module should continue to be loaded */
return SWITCH_STATUS_SUCCESS;
}
/*
* This functionis called on module teardown
* It releases all internal resources, i.e.
* it dealocates OPAL core
*
*/
SWITCH_MODULE_SHUTDOWN_FUNCTION(mod_opalh323_shutdown)
{
/* deallocate OPAL manager */
delete opal_manager;
return SWITCH_STATUS_SUCCESS;
}
/*
* IO routines handlers definitions
*/
static switch_call_cause_t opalh323_outgoing_channel(
switch_core_session_t *session,
switch_caller_profile_t *outbound_profile,
switch_core_session_t **new_session,
switch_memory_pool_t **pool)
{
return opal_manager->io_outgoing_channel(session,outbound_profile,new_session,pool);
}
static switch_status_t opalh323_read_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flags, int stream_id)
{
return opal_manager->io_read_frame(session,frame,timeout,flags,stream_id);
}
static switch_status_t opalh323_write_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flags, int stream_id)
{
return opal_manager->io_write_frame(session,frame,timeout,flags,stream_id);
}
static switch_status_t opalh323_kill_channel(switch_core_session_t *session, int sig)
{
return opal_manager->io_kill_channel(session,sig);
}
static switch_status_t opalh323_waitfor_read(switch_core_session_t *session, int ms, int stream_id)
{
return opal_manager->io_waitfor_read(session,ms,stream_id);
}
static switch_status_t opalh323_waitfor_write(switch_core_session_t *session, int ms, int stream_id)
{
return opal_manager->io_waitfor_write(session,ms,stream_id);
}
static switch_status_t opalh323_send_dtmf(switch_core_session_t *session, char *dtmf)
{
return opal_manager->io_send_dtmf(session,dtmf);
}
static switch_status_t opalh323_receive_message(switch_core_session_t *session, switch_core_session_message_t *msg)
{
return opal_manager->io_receive_message(session,msg);
}
static switch_status_t opalh323_receive_event(switch_core_session_t *session, switch_event_t *event)
{
return opal_manager->io_receive_event(session,event);
}
static switch_status_t opalh323_state_change(switch_core_session_t *session)
{
return opal_manager->io_state_change(session);
}
static switch_status_t opalh323_read_video_frame(switch_core_session_t *session, switch_frame_t **frame, int timeout, switch_io_flag_t flag, int stream_id)
{
return opal_manager->io_read_video_frame(session,frame,timeout,flag,stream_id);
}
static switch_status_t opalh323_write_video_frame(switch_core_session_t *session, switch_frame_t *frame, int timeout, switch_io_flag_t flag, int stream_id)
{
return opal_manager->io_write_video_frame(session,frame,timeout,flag,stream_id);
}
/*
* Event handlers
*/
static switch_status_t opalh323_on_init(switch_core_session_t *session)
{
return opal_manager->callback_on_init(session);
}
static switch_status_t opalh323_on_ring(switch_core_session_t *session)
{
return opal_manager->callback_on_ring(session);
}
static switch_status_t opalh323_on_execute(switch_core_session_t *session)
{
return opal_manager->callback_on_execute(session);
}
static switch_status_t opalh323_on_hangup(switch_core_session_t *session)
{
return opal_manager->callback_on_hangup(session);
}
static switch_status_t opalh323_on_loopback(switch_core_session_t *session)
{
return opal_manager->callback_on_loopback(session);
}
static switch_status_t opalh323_on_transmit(switch_core_session_t *session)
{
return opal_manager->callback_on_transmit(session);
}

39
src/mod/endpoints/mod_opal/mod_opal.h Normal file
View File

@ -0,0 +1,39 @@
/*
* mod_opalh323.h
*
* Opal-H323 gluer for Freeswitch header file
*
* Copyright (c) 2007 Lukasz Zwierko (lzwierko@gmail.com)
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
*
* The Initial Developer of the Original Code is Lukasz Zwierko (lzwierko@gmail.com)
*
* Contributor(s): ______________________________________.
*
* $Log: mod_opalh323.cpp,v $
*
* Revision 1.00 2007/10/24 07:29:52 lzwierko
* Initial revision
*/
#ifndef __FREESWITCH_MOD_OPAL__
#define __FREESWITCH_MOD_OPAL__
#define HAVE_APR /* what do I need this for?? copied from mod_sofia */
#include <switch.h>
#include <switch_version.h>
#define MODNAME "mod_opal"
#endif /* __FREESWITCH_MOD_OPAL__ */

517
src/mod/endpoints/mod_opal/opal_backend.cpp Normal file
View File

@ -0,0 +1,517 @@
/*
* opalh323_backend.cpp
*
* Backend for OpalH323 module, implements
* H323 handling via OPAL library
*
* Copyright (c) 2007 Lukasz Zwierko (lzwierko@gmail.com)
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
*
* The Initial Developer of the Original Code is Lukasz Zwierko (lzwierko@gmail.com)
*
* Contributor(s):
*
* $Log: opalh323_backend.cpp,v $
*
* Revision 1.00 2007/10/24 07:29:52 lzwierko
* Initial revision
*/
#include <switch.h>
#include "opal_backend.h"
/**
* Private structre
*/
typedef struct OpalH323Private_s
{
OpalConnection *m_opalConnection; /** pointer to OpalConnection object */
switch_mutex_t *m_mutex; /** mutex for synchonizing access to session object */
switch_caller_profile_t *m_callerProfile; /** caller profile */
} OpalH323Private_t;
static bool OpalH323Private_Create(OpalH323Private_t **o_private, switch_core_session_t *i_session)
{
*o_private = (OpalH323Private_t *)switch_core_session_alloc(i_session, sizeof(OpalH323Private_t));
if(!o_private)
{
assert(0);
return false;
}
if(SWITCH_STATUS_SUCCESS != switch_mutex_init(&(*o_private)->m_mutex, SWITCH_MUTEX_NESTED, switch_core_session_get_pool(i_session)))
{
assert(0);
return false;
}
return true;
}
static bool OpalH323Private_Delete(OpalH323Private_t *o_private)
{
return (switch_mutex_destroy(o_private->m_mutex)==SWITCH_STATUS_SUCCESS);
}
/** Default constructor
*
*/
FSOpalManager::FSOpalManager() :
m_isInitialized(false),
m_pH323Endpoint(NULL),
m_pMemoryPool(NULL),
m_pH323EndpointInterface(NULL),
m_pSessionsHashTable(NULL),
m_pSessionsHashTableMutex(NULL)
{
}
/** Destructor
*
*/
FSOpalManager::~FSOpalManager()
{
/**
* Destroy all allocated resources, if any
*/
if(m_isInitialized)
{
delete m_pH323Endpoint;
switch_mutex_destroy(m_pSessionsHashTableMutex);
switch_core_hash_destroy(&m_pSessionsHashTable);
}
}
/**
* Method does real initialization of the manager
*/
bool FSOpalManager::initialize(
const char* i_modName,
switch_memory_pool_t* i_memoryPool,
switch_endpoint_interface_t *i_endpointInterface
)
{
/* check if not initialized */
assert(m_isInitialized);
/* check input parameters */
assert(i_modName);
assert(i_memoryPool);
assert(i_endpointInterface);
m_pModuleName = i_modName;
m_pMemoryPool = i_memoryPool;
m_pH323EndpointInterface = i_endpointInterface;
/**
* Create hash table for storing pointers to session objects,
* Each OpalConnection object will retreive it's session object using
* its callToken as a key
*/
if(switch_core_hash_init(&m_pSessionsHashTable,m_pMemoryPool)!=SWITCH_STATUS_SUCCESS)
{
assert(0);
return false;
}
if(switch_mutex_init(&m_pSessionsHashTableMutex,SWITCH_MUTEX_UNNESTED,m_pMemoryPool)!=SWITCH_STATUS_SUCCESS)
{
assert(0);
switch_core_hash_destroy(&m_pSessionsHashTable);
return false;
}
/* create h323 endpoint */
m_pH323Endpoint = new H323EndPoint( *(static_cast<OpalManager*>(this)) ); ///TODO, replace prefix and signaling port by values from configuration
if(!m_pH323Endpoint)
{
assert(0);
switch_core_hash_destroy(&m_pSessionsHashTable);
switch_mutex_destroy(m_pSessionsHashTableMutex);
return false;
}
/**
* To do-> add codecs to capabilities (for call contol)
* m_pH323Endpoint->AddCapability();
*/
m_pH323Endpoint->DisableFastStart(false); ///TODO this should be configurable
m_pH323Endpoint->DisableH245Tunneling(false); ///TODO this should be configurable
///TODO gatekeeper use should be configurable, I think that sevral options should be implemented in config file: use, dont use, use one of specified with priorities, try to reconnect to the topmost...
///TODO m_pH323Endpoint->SetInitialBandwidth(initialBandwidth);
///TODO m_pH323Endpoint->SetVendorIdentifierInfo()
///TODO address should be configurable, should allow creaeing listeners on multiple interfaces
OpalTransportAddress opalTransportAddress("0.0.0.0",1720); //for time being create listener on all ip's and default port
if(!m_pH323Endpoint->StartListeners(opalTransportAddress))
{
assert(0);
switch_core_hash_destroy(&m_pSessionsHashTable);
switch_mutex_destroy(m_pSessionsHashTableMutex);
delete m_pH323Endpoint;
return false;
}
/* at this point OPAL is ready to go */
m_isInitialized = true;
return true;
}
switch_core_session_t* FSOpalManager::getSessionToken(const PString &i_token)
{
assert(m_pSessionsHashTable);
assert(m_pSessionsHashTableMutex);
return static_cast<switch_core_session_t*>(switch_core_hash_find_locked(m_pSessionsHashTable,(const char*)i_token,m_pSessionsHashTableMutex));
}
void FSOpalManager::saveSessionToken(const PString &i_token,switch_core_session_t* i_session)
{
assert(m_pSessionsHashTable);
assert(m_pSessionsHashTableMutex);
switch_core_hash_insert_locked(m_pSessionsHashTable,(const char*)i_token,i_session,m_pSessionsHashTableMutex);
}
void FSOpalManager::deleteSessionToken(const PString &i_token)
{
assert(m_pSessionsHashTable);
assert(m_pSessionsHashTableMutex);
switch_core_hash_delete_locked(m_pSessionsHashTable,(const char*)i_token,m_pSessionsHashTableMutex);
}
BOOL FSOpalManager::OnIncomingConnection(
OpalConnection & connection, ///< Connection that is calling
unsigned options, ///< options for new connection (can't use default as overrides will fail)
OpalConnection::StringOptions * stringOptions
)
{
//TODO check if options and stringOptions fields ever apply
return OnIncomingConnection(connection);
}
BOOL FSOpalManager::OnIncomingConnection(
OpalConnection & connection, ///< Connection that is calling
unsigned options ///< options for new connection (can't use default as overrides will fail)
)
{
//TODO, check if options field ever applies
return OnIncomingConnection(connection);
}
BOOL FSOpalManager::OnIncomingConnection(
OpalConnection & connection ///< Connection that is calling
)
{
/* allocate new session in switch core*/
switch_core_session_t *session = switch_core_session_request(m_pH323EndpointInterface , NULL);
assert(session);
if(!session)
{
///TODO add cause to the connection
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate session object?\n");
return FALSE;
}
/* allocate private resources */
OpalH323Private_t *tech_pvt = NULL;
if(!OpalH323Private_Create(&tech_pvt,session))
{
///TODO add cause to the connection
switch_core_session_destroy(&session);
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Could not allocate private object?\n");
return false;
}
tech_pvt->m_opalConnection = &connection;
/** Save private data in session private data, and save session in hash tabel, under GetToken() key */
switch_core_session_set_private(session,static_cast<void*>(tech_pvt)); ///save private data in session context
/** Before adding this session to sessions hash table,
* lock he mutex so no concurrent
* callback can be runing for this connection
* probably other callbacks are called from this task
* but carfulness wont bite
*/
switch_mutex_lock(tech_pvt->m_mutex);
/** insert connection to hash table */
saveSessionToken(connection.GetToken(),session); ///save pointer to session in hash table, for later retreival
/** Create calling side profile */
tech_pvt->m_callerProfile = switch_caller_profile_new(
switch_core_session_get_pool(session),
(const char*)connection.GetRemotePartyName(), /** username */
"default", /** TODO -> this should be configurable by core */
(const char*)connection.GetRemotePartyName(), /** caller_id_name */
(const char*)connection.GetRemotePartyNumber(), /** caller_id_number */
(const char*)connection.GetRemotePartyAddress(), /** network addr */
NULL, /** ANI */
NULL, /** ANI II */
NULL, /** RDNIS */
m_pModuleName, /** source */
NULL, /** TODO -> set context */
(const char*)connection.GetCalledDestinationNumber() /** destination_number */
);
if(!tech_pvt->m_callerProfile) /* should never error */
{
deleteSessionToken(connection.GetToken());
switch_mutex_unlock(tech_pvt->m_mutex);
OpalH323Private_Delete(tech_pvt);
switch_core_session_destroy(&session);
assert(0);
return false;
}
/** Set up sessions channel */
switch_channel_t *channel = switch_core_session_get_channel(session);
switch_channel_set_name(channel,(const char*)connection.GetToken());
switch_channel_set_caller_profile(channel, tech_pvt->m_callerProfile);
switch_channel_set_state(channel, CS_INIT);
/** Set up codecs for the channel ??? */
/***Mark incoming call as AnsweredPending ??? */
/** lunch thread */
if (switch_core_session_thread_launch(session) != SWITCH_STATUS_SUCCESS)
{
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_CRIT, "Error spawning thread\n");
deleteSessionToken(connection.GetToken());
switch_mutex_unlock(tech_pvt->m_mutex);
OpalH323Private_Delete(tech_pvt);
switch_core_session_destroy(&session);
assert(0);
return false;
}
switch_mutex_unlock(tech_pvt->m_mutex);
/* the connection can be continued!!! */
return TRUE;
}
/**
* FS ON_INIT callback handler
*
*/
switch_status_t FSOpalManager::callback_on_init(switch_core_session_t *io_session)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
/**
* FS ON_INIT callback handler
*
*/
switch_status_t FSOpalManager::callback_on_ring(switch_core_session_t *io_session)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
/**
* FS ON_EXECUTE callback handler
*
*/
switch_status_t FSOpalManager::callback_on_execute(switch_core_session_t *io_session)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
/**
* FS ON_HANGUP callback handler
*
*/
switch_status_t FSOpalManager::callback_on_hangup(switch_core_session_t *io_session)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
/**
* FS ON_LOOPBACK callback handler
*
*/
switch_status_t FSOpalManager::callback_on_loopback(switch_core_session_t *io_session)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
/**
* FS ON_TRANSMIT callback handler
*
*/
switch_status_t FSOpalManager::callback_on_transmit(switch_core_session_t *io_session)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_call_cause_t FSOpalManager::io_outgoing_channel(switch_core_session_t *i_session, switch_caller_profile_t *i_profile, switch_core_session_t **o_newSession, switch_memory_pool_t **o_memPool)
{
assert(m_isInitialized);
return SWITCH_CAUSE_SUCCESS;
}
switch_status_t FSOpalManager::io_read_frame(switch_core_session_t *i_session, switch_frame_t **o_frame, int i_timout, switch_io_flag_t i_flag, int i_streamId)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_write_frame(switch_core_session_t *i_session, switch_frame_t *i_frame, int i_timeout, switch_io_flag_t i_flag, int i_streamId)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_kill_channel(switch_core_session_t *i_session, int sig)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_waitfor_read(switch_core_session_t *i_session, int i_ms, int i_streamId)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_waitfor_write(switch_core_session_t *i_session, int i_ms, int i_streamId)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_send_dtmf(switch_core_session_t *i_session, char *i_dtmf)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_receive_message(switch_core_session_t *i_session, switch_core_session_message_t *i_message)
{
assert(m_isInitialized);
OpalH323Private_t* tech_prv = static_cast<OpalH323Private_t*>(switch_core_session_get_private(i_session));
assert(tech_prv);
switch_mutex_lock(tech_prv->m_mutex);
switch(i_message->message_id)
{
case SWITCH_MESSAGE_REDIRECT_AUDIO:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_REDIRECT_AUDIO\n");
break;
case SWITCH_MESSAGE_TRANSMIT_TEXT:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_TRANSMIT_TEXT\n");
break;
case SWITCH_MESSAGE_INDICATE_ANSWER:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_ANSWER\n");
/* set call answer */
//tech_prv->m_opalConnection->AnsweringCall(AnswerCallNow);
break;
case SWITCH_MESSAGE_INDICATE_PROGRESS:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_PROGRESS\n");
break;
case SWITCH_MESSAGE_INDICATE_BRIDGE:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_BRIDGE\n");
break;
case SWITCH_MESSAGE_INDICATE_UNBRIDGE:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_UNBRIDGE\n");
break;
case SWITCH_MESSAGE_INDICATE_TRANSFER:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_TRANSFER\n");
break;
case SWITCH_MESSAGE_INDICATE_RINGING:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_RINGING\n");
break;
case SWITCH_MESSAGE_INDICATE_MEDIA:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_MEDIA\n");
break;
case SWITCH_MESSAGE_INDICATE_NOMEDIA:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_NOMEDIA\n");
break;
case SWITCH_MESSAGE_INDICATE_HOLD:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_HOLD\n");
break;
case SWITCH_MESSAGE_INDICATE_UNHOLD:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_UNHOLD\n");
break;
case SWITCH_MESSAGE_INDICATE_REDIRECT:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_REDIRECT\n");
break;
case SWITCH_MESSAGE_INDICATE_REJECT:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_REJECT\n");
break;
case SWITCH_MESSAGE_INDICATE_BROADCAST:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_BROADCAST\n");
break;
case SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT:
//switch_log_printf(SWITCH_CHANNEL_LOG, SWITCH_LOG_DEBUG "SWITCH_MESSAGE_INDICATE_MEDIA_REDIRECT\n");
break;
}
switch_mutex_unlock(tech_prv->m_mutex);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_receive_event(switch_core_session_t *i_session, switch_event_t *i_event)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_state_change(switch_core_session_t *)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_read_video_frame(switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}
switch_status_t FSOpalManager::io_write_video_frame(switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int)
{
assert(m_isInitialized);
return SWITCH_STATUS_SUCCESS;
}

132
src/mod/endpoints/mod_opal/opal_backend.h Normal file
View File

@ -0,0 +1,132 @@
/*
* opalh323_backend.cpp
*
* Backend for OpalH323 module, implements
* H323 handling via OPAL library
*
* Copyright (c) 2007 Lukasz Zwierko (lzwierko@gmail.com)
*
* The contents of this file are subject to the Mozilla Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/MPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
*
* The Initial Developer of the Original Code is Lukasz Zwierko (lzwierko@gmail.com)
*
* Contributor(s):
*
* $Log: opalh323_backend.cpp,v $
*
* Revision 1.00 2007/10/24 07:29:52 lzwierko
* Initial revision
*/
#ifndef __FREESWITCH_OPAL_BACKEND__
#define __FREESWITCH_OPAL_BACKEND__
#include <switch.h>
#include <ptlib.h>
#include <opal/buildopts.h>
#include <opal/manager.h>
#include <h323/h323ep.h>
/** This class is OpalManager implementation
* for FreeSWITCH OpalH323 module.
* All methods are inherited from base OpalManagerClass.
* Event callbacks will be filed with valid code
* Additional functions have been implemented to be called, or called by
*/
class FSOpalManager : public OpalManager
{
PCLASSINFO(FSOpalManager, PObject);
public:
/** Default constructor
*
*/
FSOpalManager();
/** Destructor
*
*/
~FSOpalManager();
/**
* Method does real initialization of the manager
*/
bool initialize(
const char* i_modName,
switch_memory_pool_t* i_memoryPool,
switch_endpoint_interface_t *i_endpointInterface
);
/** FS callback handlers declarations
*
*/
switch_status_t callback_on_init(switch_core_session_t *io_session);
switch_status_t callback_on_ring(switch_core_session_t *io_session);
switch_status_t callback_on_execute(switch_core_session_t *io_session);
switch_status_t callback_on_hangup(switch_core_session_t *io_session);
switch_status_t callback_on_loopback(switch_core_session_t *io_session);
switch_status_t callback_on_transmit(switch_core_session_t *io_session);
/** FS io functions
*
*/
switch_call_cause_t io_outgoing_channel(switch_core_session_t *, switch_caller_profile_t *, switch_core_session_t **, switch_memory_pool_t **);
switch_status_t io_read_frame(switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int);
switch_status_t io_write_frame(switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int);
switch_status_t io_kill_channel(switch_core_session_t *, int);
switch_status_t io_waitfor_read(switch_core_session_t *, int, int);
switch_status_t io_waitfor_write(switch_core_session_t *, int, int);
switch_status_t io_send_dtmf(switch_core_session_t *, char *);
switch_status_t io_receive_message(switch_core_session_t *, switch_core_session_message_t *);
switch_status_t io_receive_event(switch_core_session_t *, switch_event_t *);
switch_status_t io_state_change(switch_core_session_t *);
switch_status_t io_read_video_frame(switch_core_session_t *, switch_frame_t **, int, switch_io_flag_t, int);
switch_status_t io_write_video_frame(switch_core_session_t *, switch_frame_t *, int, switch_io_flag_t, int);
virtual BOOL OnIncomingConnection(
OpalConnection & connection, ///< Connection that is calling
unsigned options, ///< options for new connection (can't use default as overrides will fail)
OpalConnection::StringOptions * stringOptions
);
virtual BOOL OnIncomingConnection(
OpalConnection & connection, ///< Connection that is calling
unsigned options ///< options for new connection (can't use default as overrides will fail)
);
virtual BOOL OnIncomingConnection(
OpalConnection & connection ///< Connection that is calling
);
private:
void saveSessionToken(const PString &i_token,switch_core_session_t* i_session);
switch_core_session_t* getSessionToken(const PString &i_token);
void deleteSessionToken(const PString &i_token);
const char *m_pModuleName; /* name of this module */
bool m_isInitialized; /* true if module has been initialized properly */
H323EndPoint *m_pH323Endpoint; /* h323 endpoint control */
switch_memory_pool_t *m_pMemoryPool; /* FS memory pool */
switch_endpoint_interface_t *m_pH323EndpointInterface; /* FS endpoint inerface */
switch_hash_t *m_pSessionsHashTable; /* Stores pointrs to session object for each Opal connection */
switch_mutex_t *m_pSessionsHashTableMutex; /* Protects hash table */
};
#endif /* __FREESWITCH_OPAL_BACKEND__ */