You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1654 lines
45 KiB
1654 lines
45 KiB
#include "precomp.h"
|
|
#include "call.h"
|
|
#include "callto.h"
|
|
#include "conf.h"
|
|
#include "confroom.h"
|
|
#include "confpolicies.h"
|
|
#include "confutil.h"
|
|
#include "nmldap.h"
|
|
|
|
|
|
const int CCallto::s_iMaxCalltoLength = 255;
|
|
const int CCallto::s_iMaxAddressLength = 255;
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::CCallto. //
|
|
//--------------------------------------------------------------------------//
|
|
CCallto::CCallto(void):
|
|
m_bUnescapedAddressOnly( false ),
|
|
m_ulDestination( INADDR_NONE ),
|
|
m_bGatekeeperEnabled( false ),
|
|
m_pszGatekeeperName( NULL ),
|
|
m_ulGatekeeperAddress( INADDR_NONE ),
|
|
m_bGatewayEnabled( false ),
|
|
m_pszGatewayName( NULL ),
|
|
m_ulGatewayAddress( INADDR_NONE ),
|
|
m_pszDefaultIlsServerName( NULL ),
|
|
m_pszCalltoBuffer( NULL ),
|
|
m_pszDisplayName( NULL )
|
|
{
|
|
} // End of CCallto::CCallto.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::~CCallto. //
|
|
//--------------------------------------------------------------------------//
|
|
CCallto::~CCallto(void)
|
|
{
|
|
delete [] m_pszGatekeeperName;
|
|
delete [] m_pszGatewayName;
|
|
delete [] m_pszDefaultIlsServerName;
|
|
delete [] m_pszCalltoBuffer;
|
|
delete [] m_pszDisplayName;
|
|
|
|
} // End of CCallto::~CCallto.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::Callto. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::Callto
|
|
(
|
|
const TCHAR * const pszCallto, // pointer to the callto url to try to place the call with...
|
|
const TCHAR * const pszDisplayName, // pointer to the display name to use...
|
|
const NM_ADDR_TYPE nmType, // callto type to resolve this callto as...
|
|
const bool bAddressOnly, // the pszCallto parameter is to be interpreted as a pre-unescaped addressing component vs a full callto...
|
|
const bool * const pbSecurityPreference, // pointer to security preference, NULL for none. must be "compatible" with secure param if present...
|
|
const bool bAddToMru, // whether or not save in mru...
|
|
const bool bUIEnabled, // whether or not to perform user interaction on errors...
|
|
const HWND hwndParent, // if bUIEnabled is true this is the window to parent error/status windows to...
|
|
INmCall ** const ppInternalCall // out pointer to INmCall * to receive INmCall * generated by placing call...
|
|
){
|
|
ASSERT( pszCallto != NULL );
|
|
ASSERT( (hwndParent == NULL) || IsWindow( hwndParent ) );
|
|
|
|
HRESULT hrResult;
|
|
|
|
// These members need to be reset at the beginning of every call...
|
|
m_bUIEnabled = bUIEnabled;
|
|
m_hwndParent = hwndParent;
|
|
m_ulDestination = INADDR_NONE;
|
|
m_bUnescapedAddressOnly = bAddressOnly;
|
|
m_pszDisplayName = PszAlloc( pszDisplayName );
|
|
|
|
m_Parameters.SetParams( NULL ); // Need to reset all parameter settings too...
|
|
|
|
// Process the callto...
|
|
if( (hrResult = Parse( pszCallto )) == S_OK )
|
|
{
|
|
// Validate that the security specified (if any) is compatible with current NM state.
|
|
bool bValidatedSecurity;
|
|
|
|
if( (hrResult = GetValidatedSecurity( pbSecurityPreference, bValidatedSecurity )) == S_OK )
|
|
{
|
|
if( (hrResult = Resolve( nmType )) == S_OK )
|
|
{
|
|
hrResult = PlaceCall( pszCallto, bAddToMru, bValidatedSecurity, ppInternalCall );
|
|
}
|
|
}
|
|
}
|
|
|
|
if( FAILED( hrResult ) && m_bUIEnabled )
|
|
{
|
|
DisplayCallError( hrResult, (pszDisplayName != NULL)? pszDisplayName: pszCallto );
|
|
}
|
|
|
|
delete [] m_pszCalltoBuffer;
|
|
delete [] m_pszDisplayName;
|
|
m_pszCalltoBuffer = NULL;
|
|
m_pszDisplayName = NULL;
|
|
|
|
return( hrResult );
|
|
|
|
} // End of CCallto::Callto.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::Parse. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::Parse
|
|
(
|
|
const TCHAR * const pszCallto // pointer to the callto url to parse...
|
|
){
|
|
ASSERT( pszCallto != NULL );
|
|
ASSERT( m_ulDestination == INADDR_NONE );
|
|
|
|
HRESULT hrResult;
|
|
|
|
if( (m_pszCalltoBuffer = PszAlloc( pszCallto )) == NULL ) // Make a copy that we can modify in place...
|
|
{
|
|
hrResult = E_OUTOFMEMORY;
|
|
}
|
|
else if( TrimSzCallto( m_pszCalltoBuffer ) == 0 ) // Remove any leading/trailing blanks...
|
|
{
|
|
hrResult = NM_CALLERR_PARAM_ERROR; // Entire string was blanks...
|
|
}
|
|
else
|
|
{
|
|
hrResult = S_OK;
|
|
|
|
m_pszParsePos = m_pszCalltoBuffer;
|
|
|
|
if( !m_bUnescapedAddressOnly )
|
|
{
|
|
// Skip over "callto:" or "callto://" which mean nothing to us now...
|
|
static const TCHAR pszCallto2[] = TEXT( "callto:" );
|
|
static const TCHAR pszDoubleSlash[] = TEXT( "//" );
|
|
|
|
if( StrCmpNI_literal( m_pszCalltoBuffer, pszCallto2 ) )
|
|
{
|
|
m_pszParsePos = m_pszCalltoBuffer + strlen_literal( pszCallto2 );
|
|
|
|
if( StrCmpNI_literal( m_pszParsePos, pszDoubleSlash ) )
|
|
{
|
|
m_pszParsePos += strlen_literal( pszDoubleSlash );
|
|
}
|
|
}
|
|
|
|
int iLength = lstrlen( m_pszCalltoBuffer );
|
|
|
|
if( m_pszCalltoBuffer[ iLength - 1 ] == '/' )
|
|
{
|
|
m_pszCalltoBuffer[ iLength - 1 ] = '\0'; // The shell seems to add a trailing slash before calling us...
|
|
}
|
|
}
|
|
|
|
// Break the callto into two pieces at the start of the parameters (if any)...
|
|
m_pszParameters = StrChr( m_pszCalltoBuffer, '+' );
|
|
|
|
if( m_pszParameters != NULL )
|
|
{
|
|
if( m_bUnescapedAddressOnly )
|
|
{
|
|
// Sorry but '+' not allowed in addressing component...
|
|
hrResult = NM_CALLERR_INVALID_ADDRESS;
|
|
}
|
|
else
|
|
{
|
|
*m_pszParameters++ = '\0';
|
|
}
|
|
}
|
|
|
|
if( hrResult == S_OK )
|
|
{
|
|
// Make sure we have something left before going on...
|
|
if( m_pszParsePos[ 0 ] == '\0' )
|
|
{
|
|
hrResult = NM_CALLERR_NO_ADDRESS;
|
|
}
|
|
else
|
|
{
|
|
// Not really a parsing thing but what we have at this point is conveiniently
|
|
// exactly what we want to use for a display name if one wasn't specified so
|
|
// save a copy of it before ParseAddress breaks it up into pieces...
|
|
if( m_pszDisplayName == NULL )
|
|
{
|
|
m_pszDisplayName = PszAlloc( m_pszParsePos );
|
|
}
|
|
|
|
if( m_pszParameters != NULL )
|
|
{
|
|
// Send the parameters off to be parsed...
|
|
hrResult = m_Parameters.SetParams( m_pszParameters );
|
|
}
|
|
|
|
if( hrResult == S_OK )
|
|
{
|
|
// Go parse the addressing component...
|
|
hrResult = ParseAddress();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of CCallto::Parse.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::ParseAddress. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::ParseAddress(void)
|
|
{
|
|
ASSERT( m_pszCalltoBuffer != NULL );
|
|
|
|
HRESULT hrResult = NM_CALLERR_INVALID_ADDRESS;
|
|
|
|
if( m_Parameters.GetBooleanParam( TEXT( "h323" ), true ) && inGatekeeperMode() )
|
|
{
|
|
m_pszAddress = m_pszParsePos;
|
|
hrResult = S_OK; // Bless you gatekeeper...
|
|
}
|
|
else if( StrChr( m_pszParsePos, '=' ) == NULL ) // We're not going to allow the address component to contain an '='...
|
|
{
|
|
// The address is allowed to be one of these formats...
|
|
// (1) string
|
|
// (2) server/email
|
|
// (3) server:port/email
|
|
// This means it may contain at most one ':', at most one '/',
|
|
// and given a ':', there must be a following '/'...
|
|
|
|
TCHAR * const pszColon = StrChr( m_pszParsePos, ':' );
|
|
TCHAR * const pszSlash = StrChr( m_pszParsePos, '/' );
|
|
|
|
if( (pszSlash == NULL) && (pszColon == NULL) )
|
|
{
|
|
// It's a valid simple (1) string format...
|
|
m_pszAddress = m_pszParsePos;
|
|
m_pszIlsServer = NULL;
|
|
m_uiIlsPort = DEFAULT_LDAP_PORT;
|
|
m_pszEmail = m_pszParsePos;
|
|
|
|
if( m_bUnescapedAddressOnly )
|
|
{
|
|
hrResult = S_OK; // Done...
|
|
}
|
|
else
|
|
{
|
|
// Need to unescape m_pszAddress but not m_pszEmail because it points to the same place...
|
|
hrResult = Unescape( m_pszAddress );
|
|
}
|
|
}
|
|
else if( (pszSlash != NULL) && (pszColon == NULL) )
|
|
{
|
|
if( StrChr( pszSlash + 1, '/' ) == NULL )
|
|
{
|
|
// No colon and only one slash so it's a valid (2) format
|
|
// as long as each side is non zero length...
|
|
if( (pszSlash > m_pszParsePos) && (lstrlen( pszSlash ) > 1) )
|
|
{
|
|
m_pszAddress = TEXT( "" );
|
|
m_pszIlsServer = m_pszParsePos;
|
|
m_uiIlsPort = DEFAULT_LDAP_PORT;
|
|
m_pszEmail = pszSlash + 1;
|
|
*pszSlash = '\0';
|
|
|
|
if( m_bUnescapedAddressOnly )
|
|
{
|
|
hrResult = S_OK; // Done...
|
|
}
|
|
else
|
|
{
|
|
if( (hrResult = Unescape( m_pszIlsServer )) == S_OK )
|
|
{
|
|
hrResult = Unescape( m_pszEmail );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else if( (pszSlash != NULL) && (pszColon != NULL) )
|
|
{
|
|
// Make sure the ':' preceeds the '/' and there's only one of each...
|
|
if( (pszColon < pszSlash) && (StrChr( pszSlash + 1, '/') == NULL) && (StrChr( pszColon + 1, ':' ) == NULL) )
|
|
{
|
|
// One colon and one slash in the correct order so it's a valid (3) format as long
|
|
// as all three pieces are non zero length and the port piece is a number...
|
|
if( (pszColon > m_pszParsePos) && (pszSlash > pszColon + 1) && (lstrlen( pszSlash ) > 1) )
|
|
{
|
|
// We're not in gatekeeper mode so break it up into server, port, and email...
|
|
m_pszAddress = TEXT( "" );
|
|
m_pszIlsServer = m_pszParsePos;
|
|
m_pszEmail = pszSlash + 1;
|
|
*pszColon = '\0';
|
|
*pszSlash = '\0';
|
|
|
|
if( m_bUnescapedAddressOnly )
|
|
{
|
|
hrResult = DecimalStringToUINT( pszColon + 1, m_uiIlsPort );
|
|
}
|
|
else
|
|
{
|
|
if( (hrResult = Unescape( m_pszIlsServer )) == S_OK )
|
|
{
|
|
if( (hrResult = Unescape( m_pszEmail )) == S_OK )
|
|
{
|
|
if( (hrResult = Unescape( pszColon + 1 )) == S_OK )
|
|
{
|
|
hrResult = DecimalStringToUINT( pszColon + 1, m_uiIlsPort );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of CCallto::ParseAddress.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::Resolve. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::Resolve
|
|
(
|
|
const NM_ADDR_TYPE nmType // callto type to resolve this callto as...
|
|
){
|
|
HRESULT hrResult;
|
|
|
|
// First set our address type...
|
|
|
|
if( (nmType != NM_ADDR_UNKNOWN) && (nmType != NM_ADDR_CALLTO) )
|
|
{
|
|
m_nmAddressType = nmType;
|
|
}
|
|
else
|
|
{
|
|
const TCHAR * const pszType = m_Parameters.GetParam( TEXT( "type" ), NULL );
|
|
|
|
if(NULL != pszType)
|
|
{
|
|
if( lstrcmpi( pszType, TEXT( "phone" ) ) == 0 )
|
|
{
|
|
m_nmAddressType = NM_ADDR_ALIAS_E164;
|
|
}
|
|
else if( lstrcmpi( pszType, TEXT( "ip" ) ) == 0 )
|
|
{
|
|
m_nmAddressType = NM_ADDR_IP;
|
|
}
|
|
else if( lstrcmpi( pszType, TEXT( "host" ) ) == 0 )
|
|
{
|
|
m_nmAddressType = NM_ADDR_MACHINENAME;
|
|
}
|
|
else if( lstrcmpi( pszType, TEXT( "directory" ) ) == 0 )
|
|
{
|
|
m_nmAddressType = NM_ADDR_ULS;
|
|
}
|
|
else
|
|
{
|
|
m_nmAddressType = NM_ADDR_UNKNOWN;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_nmAddressType = NM_ADDR_UNKNOWN;
|
|
}
|
|
}
|
|
|
|
// Then see what we should do with it...
|
|
|
|
if( m_Parameters.GetBooleanParam( TEXT( "h323" ), true ) && inGatekeeperMode() )
|
|
{
|
|
if (!IsGatekeeperLoggedOn() && !IsGatekeeperLoggingOn())
|
|
{
|
|
hrResult = NM_CALLERR_NOT_REGISTERED;
|
|
}
|
|
else
|
|
{
|
|
// We can always send anything to the gatekeeper for actual resolution...
|
|
if( (hrResult = GetGatekeeperIpAddress( m_ulDestination )) == S_OK )
|
|
{
|
|
if( m_nmAddressType == NM_ADDR_ALIAS_E164 ) // should this also check for NM_ADDR_H323_GATEWAY???
|
|
{
|
|
CleanupE164StringEx( m_pszAddress );
|
|
}
|
|
else
|
|
{
|
|
m_nmAddressType = NM_ADDR_ALIAS_ID;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
switch( m_nmAddressType )
|
|
{
|
|
case NM_ADDR_ALIAS_ID:
|
|
{
|
|
hrResult = NM_CALLERR_NO_GATEKEEPER;
|
|
}
|
|
break;
|
|
|
|
case NM_ADDR_ALIAS_E164:
|
|
case NM_ADDR_H323_GATEWAY:
|
|
{
|
|
if( inGatewayMode() )
|
|
{
|
|
if( (hrResult = GetGatewayIpAddress( m_ulDestination )) == S_OK )
|
|
{
|
|
// Explicit phone types are also still resolvable in gateway mode...
|
|
CleanupE164StringEx( m_pszAddress );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hrResult = NM_CALLERR_NO_PHONE_SUPPORT;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NM_ADDR_IP:
|
|
{
|
|
if( (hrResult = GetIpAddress( m_pszAddress, m_ulDestination )) != S_OK )
|
|
{
|
|
hrResult = NM_CALLERR_INVALID_IPADDRESS;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NM_ADDR_MACHINENAME:
|
|
{
|
|
if( (hrResult = GetIpAddressFromHostName( m_pszAddress, m_ulDestination )) != S_OK )
|
|
{
|
|
hrResult = NM_CALLERR_HOST_RESOLUTION_FAILED;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case NM_ADDR_ULS:
|
|
{
|
|
// Ils types need to be resolved against an ils...
|
|
hrResult = GetIpAddressFromIls( m_ulDestination );
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
// If we get here the type was unspecified (Automatic or 2.xx)...
|
|
// Our order of precedence is ipaddress,hostname,ils,fail...
|
|
// We will not try phone since it didn't explicitly have a phone type...
|
|
|
|
if( (hrResult = GetIpAddress( m_pszAddress, m_ulDestination )) == S_OK )
|
|
{
|
|
m_nmAddressType = NM_ADDR_IP;
|
|
}
|
|
else
|
|
{
|
|
// It's not a valid ip address so try it next as a host name...
|
|
if( (hrResult = GetIpAddressFromHostName( m_pszAddress, m_ulDestination )) == S_OK )
|
|
{
|
|
m_nmAddressType = NM_ADDR_MACHINENAME;
|
|
}
|
|
else
|
|
{
|
|
// It's not a valid host name either so try it finally as an ils lookup...
|
|
if ( (hrResult = GetIpAddressFromIls( m_ulDestination )) == S_OK )
|
|
{
|
|
m_nmAddressType = NM_ADDR_ULS;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of CCallto::Resolve.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::PlaceCall. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::PlaceCall
|
|
(
|
|
const TCHAR * const pszCallto, // pointer to the original callto...
|
|
const bool bAddToMru, // whether or not save in mru...
|
|
const bool bSecure, // whether or not to place the call securely...
|
|
INmCall ** const ppInternalCall // out pointer to INmCall * to receive INmCall * generated by placing call...
|
|
){
|
|
ASSERT( m_ulDestination != INADDR_NONE );
|
|
|
|
const TCHAR * const pszConferenceName = m_Parameters.GetParam( TEXT( "conference" ), NULL );
|
|
const TCHAR * const pszPassword = m_Parameters.GetParam( TEXT( "password" ), NULL );
|
|
const bool bH323 = m_Parameters.GetBooleanParam( TEXT( "h323" ), true );
|
|
const bool bAV = m_Parameters.GetBooleanParam( TEXT( "av" ), true );
|
|
const bool bData = m_Parameters.GetBooleanParam( TEXT( "data" ), true );
|
|
const TCHAR * const pszAlias = NULL;
|
|
const TCHAR * const pszE164 = NULL;
|
|
HRESULT hrResult;
|
|
|
|
if( IsLocalIpAddress( m_ulDestination ) )
|
|
{
|
|
// We don't want to go any further if we are attempting to call ourselves...
|
|
hrResult = NM_CALLERR_LOOPBACK;
|
|
}
|
|
else
|
|
{
|
|
// Map to old style call flags...
|
|
|
|
DWORD dwCallFlags = 0;
|
|
|
|
if( pszConferenceName != NULL )
|
|
{
|
|
dwCallFlags |= CRPCF_JOIN;
|
|
}
|
|
|
|
if( bH323 )
|
|
{
|
|
dwCallFlags |= CRPCF_H323CC;
|
|
}
|
|
|
|
if( bSecure )
|
|
{
|
|
dwCallFlags |= CRPCF_SECURE;
|
|
}
|
|
else if( bAV )
|
|
{
|
|
if( g_uMediaCaps & (CAPFLAG_RECV_AUDIO | CAPFLAG_SEND_AUDIO) )
|
|
{
|
|
dwCallFlags |= CRPCF_AUDIO;
|
|
}
|
|
|
|
if( g_uMediaCaps & (CAPFLAG_RECV_VIDEO | CAPFLAG_SEND_VIDEO) )
|
|
{
|
|
dwCallFlags |= CRPCF_VIDEO;
|
|
}
|
|
}
|
|
|
|
if( bData )
|
|
{
|
|
dwCallFlags |= CRPCF_DATA | CRPCF_T120;
|
|
}
|
|
|
|
if (((CRPCF_T120 | CRPCF_DATA) != (dwCallFlags & (CRPCF_T120 | CRPCF_DATA))) &&
|
|
((CRPCF_H323CC | CRPCF_AUDIO) != ( dwCallFlags & (CRPCF_H323CC | CRPCF_AUDIO))) &&
|
|
((CRPCF_H323CC | CRPCF_VIDEO) != ( dwCallFlags & (CRPCF_H323CC | CRPCF_VIDEO))))
|
|
|
|
{
|
|
hrResult = NM_CALLERR_UNKNOWN;
|
|
}
|
|
|
|
CConfRoom * pConfRoom = ::GetConfRoom();
|
|
ASSERT(pConfRoom);
|
|
|
|
if (_Module.IsUIActive())
|
|
{
|
|
pConfRoom->BringToFront();
|
|
}
|
|
|
|
if( !(pConfRoom->GetMeetingPermissions() & NM_PERMIT_OUTGOINGCALLS) )
|
|
{
|
|
ERROR_OUT( ("CCallto::PlaceCall: meeting setting permissions do not permit outgoing calls...") );
|
|
}
|
|
else
|
|
{
|
|
CCall * pCall = new CCall( pszCallto, m_pszDisplayName, m_nmAddressType, bAddToMru, FALSE );
|
|
|
|
if( pCall == NULL )
|
|
{
|
|
ERROR_OUT( ("CCallto::PlaceCall: CCall object not created...") );
|
|
hrResult = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
pCall->AddRef(); // Protect against another thread canceling this call
|
|
|
|
IncrementBusyOperations();
|
|
{
|
|
const TCHAR * pszCallAlias = (m_nmAddressType == NM_ADDR_ULS)? m_pszEmail: m_pszAddress;
|
|
const char * const pszDestination = inet_ntoa( *reinterpret_cast<in_addr *>(&m_ulDestination) );
|
|
|
|
hrResult = pCall->PlaceCall( dwCallFlags, // call flags bit mask, is there a good reason why they're not named?
|
|
m_nmAddressType, // address type.
|
|
pszDestination, // setup address.
|
|
pszDestination, // destination address.
|
|
pszCallAlias, // alias.
|
|
NULL, // callto url.
|
|
pszConferenceName, // conference name.
|
|
pszPassword, // conference password.
|
|
NULL ); // user data.
|
|
}
|
|
DecrementBusyOperations();
|
|
|
|
if( FAILED( hrResult ) && (pCall->GetState() == NM_CALL_INVALID) )
|
|
{
|
|
// just release the call to free the data
|
|
// otherwise wait for the call state to be changed
|
|
pCall->Release();
|
|
}
|
|
|
|
if( ppInternalCall )
|
|
{
|
|
*ppInternalCall = pCall->GetINmCall();
|
|
(*ppInternalCall)->AddRef();
|
|
}
|
|
|
|
pCall->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of CCallto::PlaceCall.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::GetValidatedSecurity. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::GetValidatedSecurity
|
|
(
|
|
const bool * const pbSecurityPreference, // pointer to security preference, NULL for none. must be "compatible" with secure param if present...
|
|
bool & bValidatedSecurity // out bool reference to recieve validated security setting
|
|
){
|
|
HRESULT hrResult;
|
|
|
|
// First figure out what security setting is desired...
|
|
|
|
if( pbSecurityPreference != NULL )
|
|
{
|
|
// A preference was specified so use it.
|
|
bValidatedSecurity = *pbSecurityPreference;
|
|
}
|
|
else
|
|
{
|
|
// No preference was specified either so check for secure param
|
|
// passing the current system settings to use as the default.
|
|
|
|
bool bUserAlterable;
|
|
bool bDefaultSecurity;
|
|
|
|
CConfRoom::get_securitySettings( bUserAlterable, bDefaultSecurity );
|
|
|
|
bValidatedSecurity = m_Parameters.GetBooleanParam( TEXT( "secure" ), bDefaultSecurity );
|
|
}
|
|
|
|
// And then validate that the desired setting is allowed...
|
|
|
|
int iSecurityPolicy = ConfPolicies::GetSecurityLevel();
|
|
|
|
if( (bValidatedSecurity && (iSecurityPolicy == DISABLED_POL_SECURITY)) ||
|
|
((!bValidatedSecurity) && (iSecurityPolicy == REQUIRED_POL_SECURITY)) )
|
|
{
|
|
// There was a mismatch between what they want and what they can have...
|
|
// Set security to what they can have and return mismatch error...
|
|
|
|
bValidatedSecurity = (iSecurityPolicy == REQUIRED_POL_SECURITY);
|
|
hrResult = NM_CALLERR_SECURITY_MISMATCH;
|
|
}
|
|
else
|
|
{
|
|
hrResult = S_OK;
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of CCallto::GetValidatedSecurity.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::inGatekeeperMode. //
|
|
//--------------------------------------------------------------------------//
|
|
bool CCallto::inGatekeeperMode(void)
|
|
{
|
|
return(ConfPolicies::CallingMode_GateKeeper == ConfPolicies::GetCallingMode() );
|
|
|
|
} // End of CCallto::inGatekeeperMode.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::SetGatekeeperEnabled. //
|
|
//--------------------------------------------------------------------------//
|
|
void CCallto::SetGatekeeperEnabled
|
|
(
|
|
const bool bEnabled // new Gatekeeper state
|
|
){
|
|
|
|
m_bGatekeeperEnabled = bEnabled;
|
|
|
|
} // End of CCallto::SetGatekeeperEnabled.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::SetGatekeeperName. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::SetGatekeeperName
|
|
(
|
|
const TCHAR * const pszGatekeeperName // pointer to new Gatekeeper name
|
|
){
|
|
|
|
if( lstrcmpi( pszGatekeeperName, m_pszGatekeeperName ) != 0 )
|
|
{
|
|
delete [] m_pszGatekeeperName;
|
|
|
|
m_pszGatekeeperName = PszAlloc( pszGatekeeperName );
|
|
m_ulGatekeeperAddress = INADDR_NONE; // We reset this cached value when the name changes...
|
|
}
|
|
|
|
ASSERT( (m_pszGatekeeperName != NULL) || (pszGatekeeperName == NULL) );
|
|
|
|
return( ((pszGatekeeperName != NULL) && (m_pszGatekeeperName == NULL))? E_OUTOFMEMORY: S_OK );
|
|
|
|
} // End of CCallto::SetGatekeeperName.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::GetGatekeeperIpAddress. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::GetGatekeeperIpAddress
|
|
(
|
|
unsigned long & ulIpAddress // out unsigned long reference to receive gatekeeper IP address
|
|
){
|
|
ASSERT( m_pszGatekeeperName != NULL );
|
|
|
|
if( m_ulGatekeeperAddress == INADDR_NONE )
|
|
{
|
|
GetIpAddressFromHostName( m_pszGatekeeperName, m_ulGatekeeperAddress );
|
|
}
|
|
|
|
ulIpAddress = m_ulGatekeeperAddress;
|
|
|
|
return( (m_ulGatekeeperAddress != INADDR_NONE)? S_OK: NM_CALLERR_NO_GATEKEEPER );
|
|
|
|
} // End of CCallto::GetGatekeeperIpAddress.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::inGatewayMode. //
|
|
//--------------------------------------------------------------------------//
|
|
bool CCallto::inGatewayMode(void)
|
|
{
|
|
|
|
return( (m_bGatewayEnabled && (m_pszGatewayName != NULL)) || (m_Parameters.GetParam( TEXT( "gateway" ), NULL ) != NULL) );
|
|
|
|
} // End of CCallto::inGatewayMode.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::SetGatewayEnabled. //
|
|
//--------------------------------------------------------------------------//
|
|
void CCallto::SetGatewayEnabled
|
|
(
|
|
const bool bEnabled // new Gateway state
|
|
){
|
|
|
|
m_bGatewayEnabled = bEnabled;
|
|
|
|
} // End of CCallto::SetGatewayEnabled.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::SetGatewayName. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::SetGatewayName
|
|
(
|
|
const TCHAR * const pszGatewayName // pointer to new Gateway name
|
|
){
|
|
|
|
if( lstrcmpi( pszGatewayName, m_pszGatewayName ) != 0 )
|
|
{
|
|
delete [] m_pszGatewayName;
|
|
|
|
m_pszGatewayName = PszAlloc( pszGatewayName );
|
|
m_ulGatewayAddress = INADDR_NONE; // We reset this cached value when the name changes...
|
|
}
|
|
|
|
ASSERT( (m_pszGatewayName != NULL) || (pszGatewayName == NULL) );
|
|
|
|
return( ((pszGatewayName != NULL) && (m_pszGatewayName == NULL))? E_OUTOFMEMORY: S_OK );
|
|
|
|
} // End of CCallto::SetGatewayName.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::GetGatewayIpAddress. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::GetGatewayIpAddress
|
|
(
|
|
unsigned long & ulIpAddress // out unsigned long reference to receive gateway IP address
|
|
){
|
|
|
|
const TCHAR * const pszGateway = m_Parameters.GetParam( TEXT( "gateway" ), NULL );
|
|
|
|
if( pszGateway != NULL )
|
|
{
|
|
// A non-default gateway was specified with this callto...
|
|
GetIpAddressFromHostName( pszGateway, ulIpAddress );
|
|
}
|
|
else
|
|
{
|
|
if( m_ulGatewayAddress == INADDR_NONE )
|
|
{
|
|
GetIpAddressFromHostName( m_pszGatewayName, m_ulGatewayAddress );
|
|
}
|
|
|
|
ulIpAddress = m_ulGatewayAddress;
|
|
}
|
|
|
|
return( (ulIpAddress != INADDR_NONE)? S_OK: NM_CALLERR_NO_GATEWAY );
|
|
|
|
} // End of CCallto::GetGatewayIpAddress.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::SetIlsServerName. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::SetIlsServerName
|
|
(
|
|
const TCHAR * const pszServerName // pointer to new default Ils server name
|
|
){
|
|
|
|
delete [] m_pszDefaultIlsServerName;
|
|
|
|
m_pszDefaultIlsServerName = PszAlloc( pszServerName );
|
|
|
|
ASSERT( (m_pszDefaultIlsServerName != NULL) || (pszServerName == NULL) );
|
|
|
|
return( ((pszServerName != NULL) && (m_pszDefaultIlsServerName == NULL))? E_OUTOFMEMORY: S_OK );
|
|
|
|
} // End of CCallto::SetIlsServerName.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::GetIpAddressFromIls. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT CCallto::GetIpAddressFromIls
|
|
(
|
|
unsigned long & ulIpAddress // out unsigned long reference to receive IP address
|
|
){
|
|
ASSERT( m_pszEmail != NULL );
|
|
|
|
HRESULT hrResult;
|
|
|
|
const TCHAR * const pszActiveIlsServer = (m_pszIlsServer != NULL)? m_pszIlsServer: m_pszDefaultIlsServerName;
|
|
|
|
if( pszActiveIlsServer == NULL )
|
|
{
|
|
hrResult = NM_CALLERR_NO_ILS;
|
|
}
|
|
|
|
if( g_pLDAP == NULL )
|
|
{
|
|
g_pLDAP = new CNmLDAP;
|
|
}
|
|
|
|
ASSERT( g_pLDAP != NULL );
|
|
|
|
if( g_pLDAP == NULL )
|
|
{
|
|
hrResult = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
TCHAR szIpAddress[ 64 ];
|
|
|
|
hrResult = g_pLDAP->ResolveUser( m_pszEmail, pszActiveIlsServer, szIpAddress, ARRAY_ELEMENTS( szIpAddress ), m_uiIlsPort );
|
|
|
|
if( hrResult == S_OK )
|
|
{
|
|
// Verify that it gave back a good IP address...
|
|
hrResult = GetIpAddress( szIpAddress, ulIpAddress );
|
|
}
|
|
|
|
if( hrResult != S_OK )
|
|
{
|
|
hrResult = NM_CALLERR_ILS_RESOLUTION_FAILED;
|
|
}
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of CCallto::GetIpAddressFromIls.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCallto::DoUserValidation //
|
|
//--------------------------------------------------------------------------//
|
|
bool CCallto::DoUserValidation(const TCHAR * const pszCallto)
|
|
{
|
|
bool bRet = false;
|
|
CCallto callto;
|
|
TCHAR szCaption[MAX_PATH];
|
|
TCHAR *pszText = NULL;
|
|
|
|
// Parse input string to retrieve display name
|
|
if(FAILED(callto.Parse(pszCallto)))
|
|
goto Exit;
|
|
|
|
// Verify we have a valid display name
|
|
if(NULL == callto.m_pszDisplayName)
|
|
goto Exit;
|
|
|
|
// Allocate message buffer. MAX_PATH represents max format string size
|
|
pszText = new TCHAR[_tcslen(callto.m_pszDisplayName) + MAX_PATH];
|
|
if(NULL == pszText)
|
|
goto Exit;
|
|
|
|
// Compose message string
|
|
if(!FLoadString1(IDS_JOIN_PERMISSION, pszText, callto.m_pszDisplayName))
|
|
goto Exit;
|
|
|
|
if(!FLoadString(IDS_MSGBOX_TITLE, szCaption, CCHMAX(szCaption)))
|
|
goto Exit;
|
|
|
|
// Display message box
|
|
if(IDOK != MessageBox(NULL, pszText, szCaption, MB_ICONWARNING | MB_OKCANCEL | MB_TOPMOST))
|
|
goto Exit;
|
|
|
|
bRet = true;
|
|
Exit:
|
|
// Free allocated buffer
|
|
if(NULL != pszText)
|
|
{
|
|
delete [] pszText;
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCalltoParams::CCalltoParams. //
|
|
//--------------------------------------------------------------------------//
|
|
CCalltoParams::CCalltoParams(void):
|
|
m_chNameDelimiter( '+' ),
|
|
m_chValueDelimiter( '=' ),
|
|
m_pszParams( NULL ),
|
|
m_iCount( 0 )
|
|
{
|
|
} // End of CCalltoParams::CCalltoParams.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCalltoParams::CCalltoParams. //
|
|
//--------------------------------------------------------------------------//
|
|
CCalltoParams::~CCalltoParams()
|
|
{
|
|
|
|
delete [] m_pszParams;
|
|
|
|
} // End of CCalltoParams::~CCalltoParams.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCalltoParams::SetParams. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT
|
|
CCalltoParams::SetParams
|
|
(
|
|
const TCHAR * const pszParams
|
|
){
|
|
|
|
HRESULT hrResult;
|
|
|
|
delete [] m_pszParams;
|
|
|
|
m_pszParams = NULL;
|
|
m_iCount = 0;
|
|
|
|
if( pszParams == NULL )
|
|
{
|
|
hrResult = S_OK;
|
|
}
|
|
else if( (m_pszParams = new TCHAR [ lstrlen( pszParams ) + 1 ]) == NULL )
|
|
{
|
|
hrResult = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
hrResult = S_OK;
|
|
|
|
lstrcpy( m_pszParams, pszParams );
|
|
|
|
TCHAR * pszPos = m_pszParams;
|
|
TCHAR * pszEnd;
|
|
|
|
while( (*pszPos != '\0') && (m_iCount < ARRAY_ELEMENTS( m_pszNames )) )
|
|
{
|
|
m_pszNames[ m_iCount ] = pszPos;
|
|
m_pszValues[ m_iCount ] = NULL;
|
|
|
|
while( *pszPos != '\0' )
|
|
{
|
|
if( (*pszPos == '+') || (*pszPos == '=') )
|
|
{
|
|
break;
|
|
}
|
|
|
|
pszPos = CharNext( pszPos );
|
|
}
|
|
|
|
if( *pszPos != '=' )
|
|
{
|
|
// Valueless param...
|
|
|
|
if( m_pszNames[ m_iCount ] == pszPos )
|
|
{
|
|
hrResult = NM_CALLERR_PARAM_ERROR; // Can't have zero length param names...
|
|
break;
|
|
}
|
|
|
|
pszEnd = pszPos;
|
|
pszPos = CharNext( pszPos );
|
|
|
|
if( (pszPos != pszEnd) && (*pszPos == '\0') )
|
|
{
|
|
hrResult = NM_CALLERR_PARAM_ERROR; // Can't have trailing + or =...
|
|
break;
|
|
}
|
|
|
|
*pszEnd = '\0';
|
|
m_iCount++;
|
|
}
|
|
else
|
|
{
|
|
// Value follows...
|
|
pszEnd = pszPos;
|
|
pszPos = CharNext( pszPos );
|
|
*pszEnd = '\0';
|
|
|
|
m_pszValues[ m_iCount ] = pszPos;
|
|
|
|
while( *pszPos != '\0' )
|
|
{
|
|
if( (*pszPos == '+') || (*pszPos == '=') )
|
|
{
|
|
break;
|
|
}
|
|
|
|
pszPos = CharNext( pszPos );
|
|
}
|
|
|
|
if( (*pszPos == '=') || (m_pszValues[ m_iCount ] == pszPos) )
|
|
{
|
|
hrResult = NM_CALLERR_PARAM_ERROR; // Can't have '=' or zero length param names...
|
|
break;
|
|
}
|
|
|
|
pszEnd = pszPos;
|
|
pszPos = CharNext( pszPos );
|
|
|
|
if( (pszPos != pszEnd) && (*pszPos == '\0') )
|
|
{
|
|
hrResult = NM_CALLERR_PARAM_ERROR; // Can't have trailing + or =...
|
|
break;
|
|
}
|
|
|
|
*pszEnd = '\0';
|
|
m_iCount++;
|
|
}
|
|
}
|
|
|
|
if( hrResult == S_OK )
|
|
{
|
|
if( m_iCount == ARRAY_ELEMENTS( m_pszNames ) )
|
|
{
|
|
hrResult = NM_CALLERR_PARAM_ERROR; // Too many params...
|
|
}
|
|
else
|
|
{
|
|
for( int nn = 0; nn < m_iCount; nn++ )
|
|
{
|
|
if( (hrResult = Unescape( m_pszNames[ nn ] )) != S_OK )
|
|
{
|
|
break;
|
|
}
|
|
|
|
if( m_pszValues[ nn ] != NULL )
|
|
{
|
|
if( (hrResult = Unescape( m_pszValues[ nn ] )) != S_OK )
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of CCalltoParams::SetParams.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCalltoParams::GetParam. //
|
|
//--------------------------------------------------------------------------//
|
|
const TCHAR * const
|
|
CCalltoParams::GetParam
|
|
(
|
|
const TCHAR * const pszName,
|
|
const TCHAR * const pszDefaultValue
|
|
) const
|
|
{
|
|
ASSERT( pszName != NULL );
|
|
|
|
TCHAR * pszValue = NULL;
|
|
|
|
if( m_pszParams != NULL )
|
|
{
|
|
for( int nn = 0; nn < m_iCount; nn++ )
|
|
{
|
|
if( lstrcmpi( pszName, m_pszNames[ nn ] ) == 0 )
|
|
{
|
|
pszValue = m_pszValues[ nn ];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return( (pszValue == NULL)? pszDefaultValue: pszValue );
|
|
|
|
} // End of CCalltoParams::GetParam.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CCalltoParams::GetBooleanParam. //
|
|
//--------------------------------------------------------------------------//
|
|
bool
|
|
CCalltoParams::GetBooleanParam
|
|
(
|
|
const TCHAR * const pszParamName,
|
|
const bool bDefaultValue
|
|
) const
|
|
{
|
|
ASSERT( pszParamName != NULL );
|
|
|
|
const TCHAR * const pszValue = GetParam( pszParamName, NULL );
|
|
bool bResult;
|
|
|
|
if( pszValue == NULL ) // this parameter wasn't specified...
|
|
{
|
|
bResult = bDefaultValue;
|
|
}
|
|
else if( *pszValue == 0 ) // this parameter was specified but with no value...
|
|
{
|
|
bResult = true;
|
|
}
|
|
else if( (lstrcmpi( pszValue, TEXT( "1" ) ) == 0) ||
|
|
(lstrcmpi( pszValue, TEXT( "true" ) ) == 0) ||
|
|
(lstrcmpi( pszValue, TEXT( "y" ) ) == 0) ||
|
|
(lstrcmpi( pszValue, TEXT( "yes" ) ) == 0) ||
|
|
(lstrcmpi( pszValue, TEXT( "on" ) ) == 0) )
|
|
{
|
|
bResult = true;
|
|
}
|
|
else if( (lstrcmpi( pszValue, TEXT( "0" ) ) == 0) ||
|
|
(lstrcmpi( pszValue, TEXT( "false" ) ) == 0) ||
|
|
(lstrcmpi( pszValue, TEXT( "n" ) ) == 0) ||
|
|
(lstrcmpi( pszValue, TEXT( "no" ) ) == 0) ||
|
|
(lstrcmpi( pszValue, TEXT( "off" ) ) == 0) )
|
|
{
|
|
bResult = false;
|
|
}
|
|
else
|
|
{
|
|
bResult = bDefaultValue;
|
|
}
|
|
|
|
return( bResult );
|
|
|
|
} // End of CCalltoParams::GetBooleanParam.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// IsLocalIpAddress. //
|
|
//--------------------------------------------------------------------------//
|
|
bool IsLocalIpAddress
|
|
(
|
|
const unsigned long ulIpAddress // IP Address to verify is not local
|
|
){
|
|
bool bResult = (ulIpAddress == INADDR_LOOPBACK); // First check right away if it's the prefined loop back ip address...
|
|
|
|
if( !bResult )
|
|
{
|
|
char szHostName[ MAX_PATH ];
|
|
|
|
// Get our own local hostname...
|
|
if( gethostname( szHostName, ARRAY_ELEMENTS( szHostName ) ) == SOCKET_ERROR )
|
|
{
|
|
WARNING_OUT( ("IsLocalIpAddress: gethostname() failed with error=%s", PszWSALastError()) );
|
|
}
|
|
else
|
|
{
|
|
// Now find out which IP addresses are associated with it...
|
|
HOSTENT * pHostEnt = gethostbyname( szHostName );
|
|
|
|
if( pHostEnt == NULL )
|
|
{
|
|
WARNING_OUT( ("IsLocalIpAddress: gethostbyname() failed with error=%s", PszWSALastError()) );
|
|
}
|
|
else if( (pHostEnt->h_addrtype != AF_INET) || (pHostEnt->h_length != sizeof( ulIpAddress )) )
|
|
{
|
|
WARNING_OUT( ("IsLocalIpAddress: gethostbyname() returned unexpected address type: 0x%08X (%d)", pHostEnt->h_addrtype, pHostEnt->h_addrtype) );
|
|
}
|
|
else
|
|
{
|
|
ASSERT( reinterpret_cast<unsigned long **>(pHostEnt->h_addr_list) != NULL );
|
|
|
|
// Compare all the IP addresses associated with this machine to see if any of them match the one specified...
|
|
for( unsigned long ** ppIpAddress = reinterpret_cast<unsigned long **>(pHostEnt->h_addr_list); *ppIpAddress != NULL; ppIpAddress++ )
|
|
{
|
|
if( **ppIpAddress == ulIpAddress )
|
|
{
|
|
bResult = true;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return( bResult );
|
|
|
|
} // End of IsLocalIpAddress.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// DecimalStringToUINT. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT DecimalStringToUINT
|
|
(
|
|
const TCHAR * const pszDecimalString, // Pointer to string to convert...
|
|
unsigned int & uiValue // out unsigned int reference to receive converted value...
|
|
){
|
|
ASSERT( pszDecimalString != NULL );
|
|
|
|
HRESULT hrResult;
|
|
|
|
if( lstrlen( pszDecimalString ) > 10 )
|
|
{
|
|
hrResult = E_INVALIDARG; // Limit it to billions....
|
|
}
|
|
else
|
|
{
|
|
hrResult = S_OK;
|
|
|
|
const TCHAR * pszDigit;
|
|
|
|
for( pszDigit = pszDecimalString, uiValue = 0; *pszDigit != '\0'; pszDigit = CharNext( pszDigit ) )
|
|
{
|
|
if( (*pszDigit < '0') || (*pszDigit > '9') )
|
|
{
|
|
// There's a non digit character in the string so fail...
|
|
hrResult = E_INVALIDARG;
|
|
break;
|
|
}
|
|
|
|
uiValue = (uiValue * 10) + *pszDigit - '0';
|
|
}
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of DecimalStringToUINT.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// TrimSzCallto. //
|
|
//--------------------------------------------------------------------------//
|
|
int TrimSzCallto
|
|
(
|
|
TCHAR * const pszSrc // Pointer to string to trim blanks from in place...
|
|
){
|
|
ASSERT( pszSrc != NULL );
|
|
|
|
TCHAR * pszFirst;
|
|
int iResult;
|
|
|
|
for( pszFirst = pszSrc; *pszFirst == ' '; pszFirst = CharNext( pszFirst ) ){};
|
|
|
|
if( *pszFirst == '\0' )
|
|
{
|
|
*pszSrc = '\0';
|
|
iResult = 0;
|
|
}
|
|
else
|
|
{
|
|
TCHAR * pszLast;
|
|
TCHAR * psz;
|
|
|
|
for( pszLast = pszFirst, psz = pszFirst; *psz != '\0'; psz = CharNext( psz ) )
|
|
{
|
|
if( *psz != ' ' )
|
|
{
|
|
pszLast = psz;
|
|
}
|
|
}
|
|
|
|
pszLast = CharNext( pszLast );
|
|
*pszLast = '\0';
|
|
|
|
lstrcpy( pszSrc, pszFirst );
|
|
iResult = lstrlen( pszSrc );
|
|
}
|
|
|
|
return( iResult );
|
|
|
|
} // End of TrimSzCallto.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// GetIpAddress. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT GetIpAddress
|
|
(
|
|
const TCHAR * const pszIpAddress, // pointer to dotted IP address string
|
|
unsigned long & ulIpAddress // out unsigned long reference to receive IP address
|
|
){
|
|
ASSERT( pszIpAddress != NULL );
|
|
|
|
ulIpAddress = INADDR_NONE;
|
|
|
|
int ipByte = 0;
|
|
int parts = 0;
|
|
const TCHAR * ptr = pszIpAddress;
|
|
bool newPart = true;
|
|
bool result = true;
|
|
|
|
while( result && (*ptr != NULL) && (parts <= 4) )
|
|
{
|
|
if( (*ptr >= '0') && (*ptr <= '9') )
|
|
{
|
|
if( newPart )
|
|
{
|
|
parts++;
|
|
newPart = false;
|
|
}
|
|
|
|
ipByte = (ipByte * 10) + (*ptr - '0');
|
|
|
|
if( ipByte > 255 )
|
|
{
|
|
result = false;
|
|
}
|
|
}
|
|
else if( *ptr == '.' )
|
|
{
|
|
newPart = true;
|
|
ipByte = 0;
|
|
}
|
|
else
|
|
{
|
|
result = false;
|
|
}
|
|
|
|
ptr++;
|
|
}
|
|
|
|
if( result && (parts == 4) )
|
|
{
|
|
#if !defined( UNICODE )
|
|
ulIpAddress = inet_addr( pszIpAddress );
|
|
#else
|
|
char * ansiIPAddress;
|
|
int size;
|
|
|
|
size = WideCharToMultiByte( CP_ACP, // code page
|
|
0, // performance and mapping flags
|
|
ipAddress, // address of wide-character string
|
|
-1, // number of characters in string
|
|
NULL, // address of buffer for new string
|
|
0, // size of buffer
|
|
NULL, // address of default for unmappable characters
|
|
NULL ); // address of flag set when default char. used
|
|
|
|
if( (ansiIPAddress = new char [ size ]) != NULL )
|
|
{
|
|
size = WideCharToMultiByte( CP_ACP, // code page
|
|
0, // performance and mapping flags
|
|
pszIpAddress, // address of wide-character string
|
|
-1, // number of characters in string
|
|
ansiIPAddress, // address of buffer for new string
|
|
size, // size of buffer
|
|
NULL, // address of default for unmappable characters
|
|
NULL ); // address of flag set when default char. used
|
|
|
|
if( size != 0 )
|
|
{
|
|
ulIpAddress = inet_addr( ansiIPAddress );
|
|
}
|
|
|
|
delete [] ansiIPAddress;
|
|
}
|
|
#endif // !defined( UNICODE )
|
|
}
|
|
|
|
return( (ulIpAddress != INADDR_NONE)? S_OK: E_FAIL );
|
|
|
|
} // End of GetIpAddress.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// GetIpAddressFromHostName. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT GetIpAddressFromHostName
|
|
(
|
|
const TCHAR * const pszName, // pointer to host name to get IP address of
|
|
unsigned long & ulIpAddress // out unsigned long reference to receive IP address
|
|
){
|
|
ASSERT( pszName != NULL );
|
|
|
|
HRESULT hrResult = E_FAIL;
|
|
|
|
if( pszName[ 0 ] == '\0' )
|
|
{
|
|
ulIpAddress = INADDR_NONE;
|
|
}
|
|
else if( (hrResult = GetIpAddress( pszName, ulIpAddress )) != S_OK )
|
|
{
|
|
// Wasn't already in dotted IP address form...
|
|
|
|
HOSTENT * pHostEnt;
|
|
#if !defined( UNICODE )
|
|
TCHAR * pszOemName = new TCHAR [ lstrlen( pszName ) + 1 ];
|
|
|
|
if( pszOemName == NULL )
|
|
{
|
|
hrResult = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
lstrcpy( pszOemName, pszName );
|
|
CharUpper ( pszOemName );
|
|
CharToOem( pszOemName, pszOemName );
|
|
|
|
pHostEnt = gethostbyname( pszOemName );
|
|
|
|
if( pHostEnt == NULL )
|
|
{
|
|
WARNING_OUT( ("GetIpAddressFromHostName: gethostbyname() failed with error=%s", PszWSALastError()) );
|
|
}
|
|
else if( (pHostEnt->h_addrtype != AF_INET) || (pHostEnt->h_length != sizeof( ulIpAddress )) )
|
|
{
|
|
WARNING_OUT( ("GetIpAddressFromHostName: gethostbyname() returned unexpected address type: 0x%08X (%d)", pHostEnt->h_addrtype, pHostEnt->h_addrtype) );
|
|
}
|
|
else
|
|
{
|
|
if( pHostEnt->h_addr_list[ 0 ] != NULL )
|
|
{
|
|
ulIpAddress = *reinterpret_cast<unsigned long *>(pHostEnt->h_addr_list[ 0 ]); // Just use the first IP address
|
|
hrResult = S_OK;
|
|
}
|
|
}
|
|
|
|
delete [] pszOemName;
|
|
}
|
|
#else
|
|
// Need to figure out OEM'ing the name...
|
|
|
|
char * pszMultiByteName;
|
|
int iSize;
|
|
|
|
iSize = WideCharToMultiByte( CP_ACP, // code page
|
|
0, // performance and mapping flags
|
|
pszName, // address of wide-character string
|
|
-1, // number of characters in string
|
|
NULL, // address of buffer for new string
|
|
0, // size of buffer
|
|
NULL, // address of default for unmappable characters
|
|
NULL ); // address of flag set when default char. used
|
|
|
|
if( (pszMultiByteName = new char [ iSize ]) == NULL )
|
|
{
|
|
hrResult = E_OUTOFMEMORY;
|
|
}
|
|
else
|
|
{
|
|
iSize = WideCharToMultiByte( CP_ACP, // code page
|
|
0, // performance and mapping flags
|
|
pszName, // address of wide-character string
|
|
-1, // number of characters in string
|
|
pszMultiByteName, // address of buffer for new string
|
|
iSize, // size of buffer
|
|
NULL, // address of default for unmappable characters
|
|
NULL ); // address of flag set when default char. used
|
|
|
|
if( iSize != 0 )
|
|
{
|
|
pHostEnt = gethostbyname( ansiHost );
|
|
|
|
if( pHostEnt == NULL )
|
|
{
|
|
WARNING_OUT( ("GetIpAddressFromHostName: gethostbyname() failed with error=%s", PszWSALastError()) );
|
|
}
|
|
else if( (pHostEnt->h_addrtype != AF_INET) || (pHostEnt->h_length != sizeof( ulIpAddress )) )
|
|
{
|
|
WARNING_OUT( ("GetIpAddressFromHostName: gethostbyname() returned unexpected address type: 0x%08X (%d)", pHostEnt->h_addrtype, pHostEnt->h_addrtype) );
|
|
}
|
|
else
|
|
{
|
|
if( pHostEnt->h_addr_list[ 0 ] != NULL )
|
|
{
|
|
ulIpAddress = *reinterpret_cast<unsigned long *>(pHostEnt->h_addr_list[ 0 ]); // Just use the first IP address
|
|
hrResult = S_OK;
|
|
}
|
|
}
|
|
}
|
|
|
|
delete [] pszMultiByteName;
|
|
}
|
|
#endif // !defined( UNICODE )
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of GetIpAddressFromHostName.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// IsPhoneNumber. //
|
|
//--------------------------------------------------------------------------//
|
|
bool IsPhoneNumber
|
|
(
|
|
const TCHAR * pszPhone // string to check for invalid phone number characters
|
|
){
|
|
ASSERT( pszPhone != NULL );
|
|
ASSERT( pszPhone[ 0 ] != '\0' );
|
|
|
|
bool bResult = true;
|
|
|
|
while( pszPhone[ 0 ] != '\0' )
|
|
{
|
|
switch( pszPhone[ 0 ] )
|
|
{
|
|
case '0':
|
|
case '1':
|
|
case '2':
|
|
case '3':
|
|
case '4':
|
|
case '5':
|
|
case '6':
|
|
case '7':
|
|
case '8':
|
|
case '9':
|
|
case '(':
|
|
case ')':
|
|
case '#':
|
|
case '*':
|
|
case '-':
|
|
case ',':
|
|
case ' ':
|
|
break;
|
|
|
|
default:
|
|
bResult = false;
|
|
break;
|
|
}
|
|
|
|
pszPhone++;
|
|
}
|
|
|
|
return( bResult );
|
|
|
|
} // End of IsPhoneNumber.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// bCanCallAsPhoneNumber. //
|
|
//--------------------------------------------------------------------------//
|
|
bool bCanCallAsPhoneNumber
|
|
(
|
|
const TCHAR * const pszPhone
|
|
){
|
|
ASSERT( pszPhone != NULL );
|
|
ASSERT( pszPhone[ 0 ] != '\0' );
|
|
|
|
bool bResult = FALSE;
|
|
|
|
if( IsPhoneNumber( pszPhone ) )
|
|
{
|
|
if( ConfPolicies::CallingMode_GateKeeper == ConfPolicies::GetCallingMode() )
|
|
{
|
|
bResult = true;
|
|
}
|
|
else
|
|
{
|
|
RegEntry reConf( CONFERENCING_KEY, HKEY_CURRENT_USER );
|
|
|
|
bResult = (reConf.GetNumber( REGVAL_USE_H323_GATEWAY ) != 0);
|
|
}
|
|
}
|
|
|
|
return( bResult );
|
|
|
|
} // End of bCanCallAsPhoneNumber.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// unescape. //
|
|
//--------------------------------------------------------------------------//
|
|
HRESULT Unescape
|
|
(
|
|
TCHAR * const pszSrc // pointer to string to unescape in place
|
|
){
|
|
ASSERT( pszSrc != NULL );
|
|
|
|
TCHAR * pszPercentSign;
|
|
HRESULT hrResult;
|
|
|
|
for( hrResult = S_OK, pszPercentSign = pszSrc; pszPercentSign != NULL; )
|
|
{
|
|
if( (pszPercentSign = StrChr( pszPercentSign, '%' )) != NULL )
|
|
{
|
|
TCHAR chHighNibble = pszPercentSign[ 1 ];
|
|
|
|
if( ((chHighNibble >= '0') && (chHighNibble <= '9')) ||
|
|
((chHighNibble >= 'a') && (chHighNibble <= 'f')) ||
|
|
((chHighNibble >= 'A') && (chHighNibble <= 'F')) )
|
|
{
|
|
TCHAR chLowNibble = pszPercentSign[ 2 ];
|
|
|
|
if( ((chLowNibble >= '0') && (chLowNibble <= '9')) ||
|
|
((chLowNibble >= 'a') && (chLowNibble <= 'f')) ||
|
|
((chLowNibble >= 'A') && (chLowNibble <= 'F')) )
|
|
{
|
|
chHighNibble = ((chHighNibble >= '0') && (chHighNibble <= '9'))? chHighNibble - '0':
|
|
((chHighNibble >= 'a') && (chHighNibble <= 'f'))? chHighNibble - 'a' + 10: chHighNibble - 'A' + 10;
|
|
chLowNibble = ((chLowNibble >= '0') && (chLowNibble <= '9'))? chLowNibble - '0':
|
|
((chLowNibble >= 'a') && (chLowNibble <= 'f'))? chLowNibble - 'a' + 10: chLowNibble - 'A' + 10;
|
|
|
|
*pszPercentSign++ = (chHighNibble << 4) | chLowNibble;
|
|
lstrcpy( pszPercentSign, &pszPercentSign[ 2 ] );
|
|
}
|
|
else
|
|
{
|
|
hrResult = NM_CALLERR_UNESCAPE_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
hrResult = NM_CALLERR_UNESCAPE_ERROR;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
return( hrResult );
|
|
|
|
} // End of Unescape.
|