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.
1120 lines
27 KiB
1120 lines
27 KiB
/********************************************************************************
|
|
/ This is the base file to the Microsoft JScript Proxy Configuration
|
|
/ This file implements the code to provide the script site and the JSProxy psuedo
|
|
/ object for the script engine to call against.
|
|
/
|
|
/ Created 11/27/96 larrysu
|
|
/
|
|
/
|
|
/
|
|
/
|
|
/
|
|
/
|
|
/
|
|
/
|
|
/
|
|
*/
|
|
#include "jsproxy.h"
|
|
|
|
|
|
/*******************************************************************************
|
|
* JSProxy functions.
|
|
********************************************************************************/
|
|
CJSProxy::CJSProxy()
|
|
{
|
|
m_refCount = 1;
|
|
m_fDestroyable = FALSE;
|
|
m_fInitialized = FALSE;
|
|
m_pCallout = NULL;
|
|
}
|
|
|
|
CJSProxy::~CJSProxy()
|
|
{
|
|
if(m_fInitialized)
|
|
DeInit();
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::Init(AUTO_PROXY_HELPER_APIS* pAPHA)
|
|
{
|
|
|
|
m_strings[0] = L"isPlainHostName";
|
|
m_strings[1] = L"dnsDomainIs";
|
|
m_strings[2] = L"localHostOrDomainIs";
|
|
m_strings[3] = L"isResolvable";
|
|
m_strings[4] = L"isInNet";
|
|
m_strings[5] = L"dnsResolve";
|
|
m_strings[6] = L"myIpAddress";
|
|
m_strings[7] = L"dnsDomainLevels";
|
|
m_strings[8] = L"shExpMatch";
|
|
m_strings[9] = L"weekdayRange";
|
|
m_strings[10] = L"dateRange";
|
|
m_strings[11] = L"timeRange";
|
|
m_strings[12] = L"alert";
|
|
|
|
m_pCallout = pAPHA;
|
|
m_fInitialized = TRUE;
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::DeInit()
|
|
{
|
|
m_pCallout = NULL;
|
|
m_fInitialized = FALSE;
|
|
return S_OK;
|
|
}
|
|
//IDispatch functions for JSProxy. I want these to be light and fast.
|
|
STDMETHODIMP CJSProxy::GetIDsOfNames(REFIID riid, OLECHAR** rgszNames,UINT cNames, LCID lcid, DISPID FAR* rgdispid)
|
|
{
|
|
// Use addition of first 4 chars to make quick cheesy hash of which function wants to be called.
|
|
// These are values are #defined in JSProxy.h
|
|
HRESULT hr = S_OK;
|
|
long strval = 0;
|
|
unsigned long nameindex = 0;
|
|
OLECHAR* currentName = NULL;
|
|
|
|
if (!*rgszNames)
|
|
return E_POINTER;
|
|
if (cNames < 1)
|
|
return E_INVALIDARG;
|
|
|
|
while (nameindex < cNames)
|
|
{
|
|
currentName = rgszNames[nameindex];
|
|
if (currentName == NULL)
|
|
break;
|
|
|
|
strval = currentName[0]+currentName[1]+currentName[2]+currentName[3]+currentName[4];
|
|
|
|
switch (strval)
|
|
{
|
|
|
|
case VAL_myIpAddress :
|
|
if (StrCmpW(m_strings[6],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_myIpAddress;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_isInNet :
|
|
if (StrCmpW(m_strings[4],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_isInNet;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_dateRange :
|
|
if (StrCmpW(m_strings[10],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_dateRange;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_dnsDomainIs : // This is also VAL_dnsDomainLevels check for both strings.
|
|
if (StrCmpW(m_strings[7],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_dnsDomainLevels;
|
|
else
|
|
{
|
|
if (StrCmpW(m_strings[1],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_dnsDomainIs;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
}
|
|
break;
|
|
|
|
case VAL_isPlainHostName :
|
|
if (StrCmpW(m_strings[0],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_isPlainHostName;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_dnsResolve :
|
|
if (StrCmpW(m_strings[5],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_dnsResolve;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_timeRange :
|
|
if (StrCmpW(m_strings[11],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_timeRange;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_isResolvable :
|
|
if (StrCmpW(m_strings[3],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_isResolvable;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_shExpMatch :
|
|
if (StrCmpW(m_strings[8],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_shExpMatch;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_localHostOrDomainIs :
|
|
if (StrCmpW(m_strings[2],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_localHostOrDomainIs;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_weekdayRange :
|
|
if (StrCmpW(m_strings[9],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_weekdayRange;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
case VAL_alert :
|
|
if (StrCmpW(m_strings[12],currentName) == 0)
|
|
rgdispid[nameindex] = DISPID_alert;
|
|
else
|
|
{
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
}
|
|
break;
|
|
|
|
default :
|
|
rgdispid[nameindex] = DISPID_UNKNOWN;
|
|
hr = DISP_E_UNKNOWNNAME;
|
|
break;
|
|
|
|
}
|
|
nameindex++;
|
|
}
|
|
return hr;
|
|
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::Invoke(
|
|
DISPID dispidMember,
|
|
REFIID riid,
|
|
LCID lcid,
|
|
WORD wFlags,
|
|
DISPPARAMS* pdispparams,
|
|
VARIANT* pvarResult,
|
|
EXCEPINFO* pexcepinfo,
|
|
UINT* puArgErr)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (dispidMember > 0x000d)
|
|
return DISP_E_MEMBERNOTFOUND;
|
|
|
|
if (!(wFlags & (DISPATCH_PROPERTYGET|DISPATCH_METHOD)))
|
|
{
|
|
return DISP_E_MEMBERNOTFOUND;
|
|
}
|
|
|
|
// The big switch based on DISPID!
|
|
switch (dispidMember)
|
|
{
|
|
/*****************************************************************************
|
|
Calling isPlainHostName
|
|
*****************************************************************************/
|
|
case DISPID_isPlainHostName :
|
|
{
|
|
// look in the DISPARAMS to make sure the signiture is correct for this function.
|
|
if (pdispparams->cArgs != 1)
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
if (pdispparams->cNamedArgs > 0)
|
|
hr = DISP_E_NONAMEDARGS;
|
|
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
VARIANT arg1;
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[0].vt == VT_BSTR)
|
|
arg1 = pdispparams->rgvarg[0];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg1,&(pdispparams->rgvarg[0]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
// call isPlainHostName.
|
|
hr = isPlainHostName(arg1.bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling dnsDomainIs
|
|
*****************************************************************************/
|
|
case DISPID_dnsDomainIs :
|
|
{
|
|
if (pdispparams->cArgs != 2)
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
if (pdispparams->cNamedArgs > 0)
|
|
{
|
|
hr = DISP_E_NONAMEDARGS;
|
|
break;
|
|
}
|
|
|
|
VARIANT arg1;
|
|
VARIANT arg2;
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[0].vt == VT_BSTR)
|
|
arg2 = pdispparams->rgvarg[0];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg2,&(pdispparams->rgvarg[0]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
if (pdispparams->rgvarg[1].vt == VT_BSTR)
|
|
arg1 = pdispparams->rgvarg[1];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg1,&(pdispparams->rgvarg[1]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
// call dnsDomainIs
|
|
hr = dnsDomainIs(arg1.bstrVal,arg2.bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling localHostOrDomainIs
|
|
*****************************************************************************/
|
|
case DISPID_localHostOrDomainIs :
|
|
{
|
|
if (pdispparams->cArgs != 2)
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
if (pdispparams->cNamedArgs > 0)
|
|
{
|
|
hr = DISP_E_NONAMEDARGS;
|
|
break;
|
|
}
|
|
|
|
VARIANT arg1;
|
|
VARIANT arg2;
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[0].vt == VT_BSTR)
|
|
arg2 = pdispparams->rgvarg[0];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg2,&(pdispparams->rgvarg[0]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
if (pdispparams->rgvarg[1].vt == VT_BSTR)
|
|
arg1 = pdispparams->rgvarg[1];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg1,&(pdispparams->rgvarg[1]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
// call localHostOrDomainIs
|
|
hr = localHostOrDomainIs(arg1.bstrVal,arg2.bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling isResolvable
|
|
*****************************************************************************/
|
|
case DISPID_isResolvable :
|
|
{
|
|
if (pdispparams->cArgs != 1)
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
if (pdispparams->cNamedArgs > 0)
|
|
{
|
|
hr = DISP_E_NONAMEDARGS;
|
|
break;
|
|
}
|
|
|
|
VARIANT arg1;
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[0].vt == VT_BSTR)
|
|
arg1 = pdispparams->rgvarg[0];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg1,&(pdispparams->rgvarg[0]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
// call isResolvable
|
|
hr = isResolvable(arg1.bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling isInNet
|
|
*****************************************************************************/
|
|
case DISPID_isInNet :
|
|
{
|
|
int x;
|
|
|
|
if (pdispparams->cArgs != 3)
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
if (pdispparams->cNamedArgs > 0)
|
|
{
|
|
hr = DISP_E_NONAMEDARGS;
|
|
break;
|
|
}
|
|
|
|
VARIANT args[3];
|
|
|
|
for (x=0;x<3;x++)
|
|
{
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[x].vt == VT_BSTR)
|
|
args[x] = pdispparams->rgvarg[x];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&args[x],&(pdispparams->rgvarg[x]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (FAILED(hr))
|
|
{
|
|
pvarResult->vt = VT_BOOL;
|
|
pvarResult->boolVal = VARIANT_FALSE;
|
|
hr = S_OK;
|
|
break;
|
|
}
|
|
// call isInNet. Args need to be reversed
|
|
hr = isInNet(args[2].bstrVal,args[1].bstrVal,args[0].bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling dnsResolve
|
|
*****************************************************************************/
|
|
case DISPID_dnsResolve :
|
|
{
|
|
if (pdispparams->cArgs != 1)
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
if (pdispparams->cNamedArgs > 0)
|
|
{
|
|
hr = DISP_E_NONAMEDARGS;
|
|
break;
|
|
}
|
|
|
|
VARIANT arg1;
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[0].vt == VT_BSTR)
|
|
arg1 = pdispparams->rgvarg[0];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg1,&(pdispparams->rgvarg[0]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
// call dnsResolve
|
|
hr = dnsResolve(arg1.bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling myIpAddress
|
|
*****************************************************************************/
|
|
case DISPID_myIpAddress :
|
|
// Should have no args and 1 named arg and the name should be DISPATCH_PROPERTYGET!
|
|
/* if (pdispparams->cNamedArgs != 1)
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
*/
|
|
// call myIpAddress
|
|
hr = myIpAddress(pvarResult);
|
|
break;
|
|
/*****************************************************************************
|
|
Calling dnsDomainLevels
|
|
*****************************************************************************/
|
|
case DISPID_dnsDomainLevels :
|
|
{
|
|
if (pdispparams->cArgs != 1)
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
if (pdispparams->cNamedArgs > 0)
|
|
{
|
|
hr = DISP_E_NONAMEDARGS;
|
|
break;
|
|
}
|
|
|
|
VARIANT arg1;
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[0].vt == VT_BSTR)
|
|
arg1 = pdispparams->rgvarg[0];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg1,&(pdispparams->rgvarg[0]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
// call dnsDomainLevels
|
|
hr = dnsDomainLevels(arg1.bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling shExpMatch
|
|
*****************************************************************************/
|
|
case DISPID_shExpMatch :
|
|
{
|
|
if (pdispparams->cArgs != 2)
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
if (pdispparams->cNamedArgs > 0)
|
|
{
|
|
hr = DISP_E_NONAMEDARGS;
|
|
break;
|
|
}
|
|
|
|
VARIANT arg1;
|
|
VARIANT arg2;
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[0].vt == VT_BSTR)
|
|
arg2 = pdispparams->rgvarg[0];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg2,&(pdispparams->rgvarg[0]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
if (pdispparams->rgvarg[1].vt == VT_BSTR)
|
|
arg1 = pdispparams->rgvarg[1];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg1,&(pdispparams->rgvarg[1]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
// call isPlainHostName.
|
|
hr = shExpMatch(arg1.bstrVal,arg2.bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling weekdayRange
|
|
*****************************************************************************/
|
|
case DISPID_weekdayRange :
|
|
{
|
|
unsigned int x;
|
|
|
|
if ((pdispparams->cArgs > 3) || (pdispparams->cArgs < 1))
|
|
{
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
break;
|
|
}
|
|
if (pdispparams->cNamedArgs > 0)
|
|
{
|
|
hr = DISP_E_NONAMEDARGS;
|
|
break;
|
|
}
|
|
|
|
VARIANT* args[3] = {NULL,NULL,NULL};
|
|
|
|
for (x=0;x<pdispparams->cArgs;x++)
|
|
{
|
|
args[x] = new(VARIANT);
|
|
if( !(args[x]) )
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
break;
|
|
}
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[x].vt == VT_BSTR)
|
|
*args[x] = pdispparams->rgvarg[x];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(args[x],&(pdispparams->rgvarg[x]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
if (FAILED(hr))
|
|
break;
|
|
// call isInNet. Args need to be reversed
|
|
switch (pdispparams->cArgs)
|
|
{
|
|
case 1:
|
|
hr = weekdayRange(args[0]->bstrVal,NULL,NULL,pvarResult);
|
|
break;
|
|
case 2:
|
|
if ((args[0]->bstrVal[0] == 'G') || (args[0]->bstrVal[0] == 'g'))
|
|
hr = weekdayRange(args[1]->bstrVal,NULL,args[0]->bstrVal,pvarResult);
|
|
else
|
|
hr = weekdayRange(args[1]->bstrVal,args[0]->bstrVal,NULL,pvarResult);
|
|
break;
|
|
case 3:
|
|
hr = weekdayRange(args[2]->bstrVal,args[1]->bstrVal,args[0]->bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Calling dateRange
|
|
*****************************************************************************/
|
|
case DISPID_dateRange :
|
|
break;
|
|
/*****************************************************************************
|
|
Calling timeRange
|
|
*****************************************************************************/
|
|
case DISPID_timeRange :
|
|
break;
|
|
/*****************************************************************************
|
|
Calling alert
|
|
*****************************************************************************/
|
|
case DISPID_alert :
|
|
{
|
|
// look in the DISPARAMS to make sure the signiture is correct for this function.
|
|
if (pdispparams->cArgs != 1)
|
|
hr = DISP_E_BADPARAMCOUNT;
|
|
if (pdispparams->cNamedArgs > 0)
|
|
hr = DISP_E_NONAMEDARGS;
|
|
|
|
if (FAILED(hr))
|
|
break;
|
|
|
|
VARIANT arg1;
|
|
|
|
// check the type of the variant in the disparams and if it is a bstr use it
|
|
if (pdispparams->rgvarg[0].vt == VT_BSTR)
|
|
arg1 = pdispparams->rgvarg[0];
|
|
// otherwise change it into one! if this fails the return an error.
|
|
else
|
|
{
|
|
hr = VariantChangeType(&arg1,&(pdispparams->rgvarg[0]),NULL,VT_BSTR);
|
|
if (FAILED(hr))
|
|
{
|
|
hr = DISP_E_TYPEMISMATCH;
|
|
break;
|
|
}
|
|
}
|
|
// call alert.
|
|
hr = alert(arg1.bstrVal,pvarResult);
|
|
break;
|
|
}
|
|
/*****************************************************************************
|
|
Default returning error code
|
|
*****************************************************************************/
|
|
default:
|
|
hr = DISP_E_MEMBERNOTFOUND;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
// JScript Auto-Proxy config functions.
|
|
STDMETHODIMP CJSProxy::isPlainHostName(BSTR host, VARIANT* retval)
|
|
{
|
|
WCHAR *currentch;
|
|
BOOL bfound = FALSE;
|
|
|
|
if (!host || !retval)
|
|
return E_POINTER;
|
|
|
|
retval->vt = VT_BOOL;
|
|
|
|
// check to detemine whether this is a plain host name!
|
|
currentch = host;
|
|
while ((*currentch != '\0') && !bfound)
|
|
{
|
|
if (*currentch == '.')
|
|
bfound = TRUE;
|
|
else
|
|
currentch++;
|
|
}
|
|
|
|
if (bfound)
|
|
retval->boolVal = VARIANT_FALSE;
|
|
else
|
|
retval->boolVal = VARIANT_TRUE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::dnsDomainIs(BSTR host,BSTR domain, VARIANT* retval)
|
|
{
|
|
WCHAR *result = NULL;
|
|
|
|
if (!host || !domain || !retval)
|
|
return E_POINTER;
|
|
|
|
result = StrStrW(host,domain);
|
|
retval->vt = VT_BOOL;
|
|
if (result)
|
|
retval->boolVal = VARIANT_TRUE;
|
|
else
|
|
retval->boolVal = VARIANT_FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::localHostOrDomainIs(BSTR host,BSTR hostdom, VARIANT* retval)
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
if (!host || !hostdom || !retval)
|
|
return E_POINTER;
|
|
|
|
// check to see if it is a local host
|
|
hr = isPlainHostName(host,retval);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (retval->boolVal != VARIANT_TRUE)
|
|
{
|
|
//
|
|
// this is a strange function, if its not a local hostname
|
|
// we do a strait compare against the passed in domain
|
|
// string. If its not a direct match, then its FALSE,
|
|
// even if the root of the domain/hostname are the same.
|
|
// Blame Netscape for this, we are just following their
|
|
// behavior and docs.
|
|
//
|
|
|
|
if ( StrCmpIW(host, hostdom) == 0 )
|
|
{
|
|
retval->boolVal = VARIANT_TRUE;
|
|
}
|
|
else
|
|
{
|
|
retval->boolVal = VARIANT_FALSE;
|
|
}
|
|
|
|
}
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
// Functions that need to call back on wininet.
|
|
STDMETHODIMP CJSProxy::isResolvable(BSTR host, VARIANT* retval)
|
|
{
|
|
|
|
if (!host || !retval)
|
|
return E_POINTER;
|
|
// call into wininet provided functions!
|
|
retval->vt = VT_BOOL;
|
|
if (m_pCallout)
|
|
{
|
|
MAKE_ANSIPTR_FROMWIDE(szhost,host);
|
|
if (m_pCallout->IsResolvable(szhost))
|
|
retval->boolVal = VARIANT_TRUE;
|
|
else
|
|
retval->boolVal = VARIANT_FALSE;
|
|
}
|
|
else
|
|
retval->boolVal = VARIANT_FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::isInNet(BSTR host, BSTR pattern, BSTR mask, VARIANT* retval)
|
|
{
|
|
VARIANT myretval;
|
|
HRESULT hr = S_OK;
|
|
|
|
// call into wininet provided functions!
|
|
if (!host || !pattern || !mask || !retval)
|
|
return E_POINTER;
|
|
// call into wininet provided functions!
|
|
retval->vt = VT_BOOL;
|
|
VariantInit(&myretval);
|
|
|
|
if (m_pCallout)
|
|
{
|
|
hr = dnsResolve(host,&myretval);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
if (myretval.vt != VT_BSTR)
|
|
{
|
|
VariantClear(&myretval);
|
|
retval->boolVal = VARIANT_FALSE;
|
|
return hr;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
VariantClear(&myretval);
|
|
retval->boolVal = VARIANT_FALSE;
|
|
return hr;
|
|
}
|
|
|
|
// Fallthrough to code to check IP/pattern and mask!
|
|
|
|
MAKE_ANSIPTR_FROMWIDE(szhost,myretval.bstrVal);
|
|
MAKE_ANSIPTR_FROMWIDE(szpattern,pattern);
|
|
MAKE_ANSIPTR_FROMWIDE(szmask,mask);
|
|
|
|
// Check to see if IP address from dnsResolve matches the pattern/mask!
|
|
if ( m_pCallout->IsInNet(szhost, szpattern, szmask ) )
|
|
retval->boolVal = VARIANT_TRUE;
|
|
else
|
|
retval->boolVal = VARIANT_FALSE;
|
|
}
|
|
else
|
|
retval->boolVal = VARIANT_FALSE;
|
|
|
|
VariantClear(&myretval);
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::dnsResolve(BSTR host, VARIANT* retval)
|
|
{
|
|
char ipaddress[16];
|
|
DWORD dwretval;
|
|
DWORD dwipsize = 16;
|
|
|
|
if (!host || !retval)
|
|
return E_POINTER;
|
|
// call into wininet provided functions!
|
|
|
|
if (m_pCallout)
|
|
{
|
|
MAKE_ANSIPTR_FROMWIDE(szhost,host);
|
|
dwretval = m_pCallout->ResolveHostName(szhost,ipaddress,&dwipsize);
|
|
if (dwretval == ERROR_SUCCESS)
|
|
{
|
|
retval->vt = VT_BSTR;
|
|
retval->bstrVal = MakeWideStrFromAnsi((LPSTR)ipaddress,STR_BSTR);
|
|
}
|
|
else
|
|
{
|
|
retval->vt = VT_BOOL;
|
|
retval->boolVal = VARIANT_FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retval->vt = VT_BOOL;
|
|
retval->boolVal = VARIANT_FALSE;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::myIpAddress(VARIANT* retval)
|
|
{
|
|
char ipaddress[16];
|
|
DWORD dwretval;
|
|
DWORD dwipsize = 16;
|
|
|
|
if (!retval)
|
|
return E_POINTER;
|
|
// call into wininet provided functions!
|
|
|
|
if (m_pCallout)
|
|
{
|
|
dwretval = m_pCallout->GetIPAddress(ipaddress,&dwipsize);
|
|
if (dwretval == ERROR_SUCCESS)
|
|
{
|
|
retval->vt = VT_BSTR;
|
|
retval->bstrVal = MakeWideStrFromAnsi((LPSTR)ipaddress,STR_BSTR);
|
|
}
|
|
else
|
|
{
|
|
retval->vt = VT_BOOL;
|
|
retval->boolVal = VARIANT_FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
retval->vt = VT_BOOL;
|
|
retval->boolVal = VARIANT_FALSE;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// Back to functions implemented here.
|
|
STDMETHODIMP CJSProxy::dnsDomainLevels(BSTR host, VARIANT* retval)
|
|
{
|
|
WCHAR *currentch;
|
|
DWORD dwlevels = 0;
|
|
|
|
if (!host || !retval)
|
|
return E_POINTER;
|
|
|
|
retval->vt = VT_I4;
|
|
|
|
// check to detemine whether this is a plain host name!
|
|
currentch = host;
|
|
while (*currentch != L'\0')
|
|
{
|
|
if (*currentch == L'.')
|
|
dwlevels++;
|
|
|
|
currentch++;
|
|
}
|
|
|
|
retval->lVal = dwlevels;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::shExpMatch(BSTR str, BSTR shexp, VARIANT* retval)
|
|
{
|
|
|
|
if (!str || !shexp || !retval)
|
|
return E_POINTER;
|
|
|
|
retval->vt = VT_BOOL;
|
|
// convert BSTR to ansi - these macros allocate memory that is freed when they
|
|
// go out of scope! No need to free!
|
|
MAKE_ANSIPTR_FROMWIDE(szstr, str);
|
|
MAKE_ANSIPTR_FROMWIDE(szshexp, shexp);
|
|
// Call into the regular expression matching code.
|
|
if (match(szstr,szshexp))
|
|
retval->boolVal = VARIANT_TRUE;
|
|
else
|
|
retval->boolVal = VARIANT_FALSE;
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// These are to do last!!!.
|
|
STDMETHODIMP CJSProxy::weekdayRange(BSTR wd1, BSTR wd2, BSTR gmt, VARIANT* retval)
|
|
{
|
|
SYSTEMTIME systime;
|
|
SYSTEMTIME loctime;
|
|
char szday[4];
|
|
int today = -1;
|
|
int day1 = -1; // days are as follows SUN = 0; MON = 1; ...;SAT = 6.
|
|
int day2 = -1;
|
|
BOOL bIsInRange = FALSE;
|
|
|
|
if (!wd1)
|
|
return E_POINTER;
|
|
if (gmt)
|
|
GetSystemTime(&systime);
|
|
|
|
GetDateFormat(//LOCALE_SYSTEM_DEFAULT,
|
|
MAKELCID(MAKELANGID(LANG_ENGLISH,SUBLANG_ENGLISH_US),SORT_DEFAULT),
|
|
NULL,
|
|
gmt? &systime:NULL,
|
|
"ddd",
|
|
szday,
|
|
4);
|
|
|
|
if (szday)
|
|
{
|
|
int lcv;
|
|
//convert all chars to upper if lowercase (don't use runtimes)
|
|
for (lcv=0;lcv<3;lcv++)
|
|
{
|
|
if ((short)szday[lcv] > 90)
|
|
szday[lcv]-=32;
|
|
}
|
|
|
|
today = ConvertAnsiDayToInt(szday);
|
|
}
|
|
|
|
if (today == -1)
|
|
return E_FAIL;
|
|
|
|
// compare day ranges!
|
|
if (wd2)
|
|
{
|
|
// These are by definition in ALL CAPS
|
|
MAKE_ANSIPTR_FROMWIDE(szwd1, wd1);
|
|
MAKE_ANSIPTR_FROMWIDE(szwd2, wd2);
|
|
if (szwd1 && szwd2)
|
|
{
|
|
day1 = ConvertAnsiDayToInt(szwd1);
|
|
day2 = ConvertAnsiDayToInt(szwd2);
|
|
}
|
|
|
|
if ((day1 == -1) || (day2 == -1))
|
|
return E_INVALIDARG;
|
|
|
|
if (day1 < day2)
|
|
{
|
|
if ((today >= day1) && (today <= day2))
|
|
bIsInRange = TRUE;
|
|
else
|
|
bIsInRange = FALSE;
|
|
}
|
|
else if ( day1 == day2 )
|
|
{
|
|
if (today == day1)
|
|
{
|
|
bIsInRange = TRUE;
|
|
}
|
|
else
|
|
{
|
|
bIsInRange = FALSE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ((today >= day1) || (today <= day2))
|
|
bIsInRange = TRUE;
|
|
else
|
|
bIsInRange = FALSE;
|
|
}
|
|
|
|
}
|
|
else // only one day to check!
|
|
{
|
|
MAKE_ANSIPTR_FROMWIDE(szwd1, wd1);
|
|
if (lstrcmp(szday,szwd1) == 0)
|
|
bIsInRange = TRUE;
|
|
else
|
|
bIsInRange = FALSE;
|
|
}
|
|
|
|
if (bIsInRange)
|
|
{
|
|
retval->vt = VT_BOOL;
|
|
retval->boolVal = VARIANT_TRUE;
|
|
}
|
|
else
|
|
{
|
|
retval->vt = VT_BOOL;
|
|
retval->boolVal = VARIANT_FALSE;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::dateRange(long day, BSTR month, BSTR gmt, VARIANT* retval)
|
|
{
|
|
return S_OK;
|
|
}
|
|
STDMETHODIMP CJSProxy::timeRange(long hour, long min, long sec, BSTR gmt, VARIANT* retval)
|
|
{
|
|
return S_OK;
|
|
}
|
|
|
|
STDMETHODIMP CJSProxy::alert(BSTR message, VARIANT* retval)
|
|
{
|
|
if (!message)
|
|
return E_POINTER;
|
|
|
|
// Return true if available...not needed?
|
|
if (retval)
|
|
{
|
|
retval->vt = VT_BOOL;
|
|
retval->vt = VARIANT_TRUE;
|
|
}
|
|
|
|
MAKE_ANSIPTR_FROMWIDE(szMessage,message);
|
|
|
|
// Display the alert which isn't truly modal to the browser.
|
|
// Getting the appropriate window handle will be quite a chore from here.
|
|
MessageBox(
|
|
NULL,
|
|
szMessage,
|
|
TEXT("Microsoft Internet Explorer"),
|
|
MB_OK | MB_ICONEXCLAMATION | MB_TOPMOST | MB_TASKMODAL
|
|
);
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
// don't yet know what to do with ProxyConfig.bindings.
|
|
//ProxyConfig.bindings
|