1394 lines
35 KiB
C++
1394 lines
35 KiB
C++
/****************************************************************************
|
|
*
|
|
* FILE: ConfUtil.cpp
|
|
*
|
|
* CONTENTS: CConfRoom and app level utility functions
|
|
*
|
|
****************************************************************************/
|
|
|
|
#include "precomp.h"
|
|
#include "resource.h"
|
|
#include "confwnd.h"
|
|
#include "rostinfo.h"
|
|
#include "conf.h"
|
|
#include "nmmkcert.h"
|
|
#include "certui.h"
|
|
#include <ulsreg.h>
|
|
#include <confreg.h>
|
|
#include "shlWAPI.h"
|
|
#include "confutil.h"
|
|
#include "confpolicies.h"
|
|
#include "rend.h"
|
|
|
|
|
|
HFONT g_hfontDlg = NULL; // Default dialog font
|
|
|
|
|
|
#ifdef DEBUG
|
|
HDBGZONE ghZoneOther = NULL; // Other, conf.exe specific zones
|
|
static PTCHAR _rgZonesOther[] = {
|
|
TEXT("UI"),
|
|
TEXT("API"),
|
|
TEXT("Video"),
|
|
TEXT("Wizard"),
|
|
TEXT("QoS"),
|
|
TEXT("RefCount"),
|
|
TEXT("Objects "),
|
|
TEXT("UI Msg"),
|
|
TEXT("Call Control"),
|
|
};
|
|
|
|
BOOL InitDebugZones(VOID)
|
|
{
|
|
DBGINIT(&ghZoneOther, _rgZonesOther);
|
|
return TRUE;
|
|
}
|
|
|
|
VOID DeinitDebugZones(VOID)
|
|
{
|
|
DBGDEINIT(&ghZoneOther);
|
|
}
|
|
|
|
VOID DbgMsg(UINT iZone, PSTR pszFormat,...)
|
|
{
|
|
if (GETZONEMASK(ghZoneOther) & (1 << iZone))
|
|
{
|
|
va_list v1;
|
|
va_start(v1, pszFormat);
|
|
DbgZVPrintf(ghZoneOther, iZone, pszFormat, v1);
|
|
va_end(v1);
|
|
}
|
|
}
|
|
|
|
VOID DbgMsgRefCount(PSTR pszFormat,...)
|
|
{
|
|
if (GETZONEMASK(ghZoneOther) & ZONE_REFCOUNT)
|
|
{
|
|
va_list v1;
|
|
va_start(v1, pszFormat);
|
|
DbgZVPrintf(ghZoneOther, iZONE_REFCOUNT, pszFormat, v1);
|
|
va_end(v1);
|
|
}
|
|
}
|
|
|
|
VOID DbgMsgApi(PSTR pszFormat,...)
|
|
{
|
|
if (GETZONEMASK(ghZoneOther) & ZONE_API)
|
|
{
|
|
va_list v1;
|
|
va_start(v1, pszFormat);
|
|
DbgZVPrintf(ghZoneOther, iZONE_API, pszFormat, v1);
|
|
va_end(v1);
|
|
}
|
|
}
|
|
|
|
VOID DbgMsgVideo(PSTR pszFormat,...)
|
|
{
|
|
if (GETZONEMASK(ghZoneOther) & ZONE_VIDEO)
|
|
{
|
|
va_list v1;
|
|
va_start(v1, pszFormat);
|
|
DbgZVPrintf(ghZoneOther, iZONE_VIDEO, pszFormat, v1);
|
|
va_end(v1);
|
|
}
|
|
}
|
|
|
|
VOID DbgMsgUI(PSTR pszFormat,...)
|
|
{
|
|
if (GETZONEMASK(ghZoneOther) & ZONE_UI)
|
|
{
|
|
va_list v1;
|
|
va_start(v1, pszFormat);
|
|
DbgZVPrintf(ghZoneOther, iZONE_UI, pszFormat, v1);
|
|
va_end(v1);
|
|
}
|
|
}
|
|
|
|
VOID DbgMsgCall(PSTR pszFormat,...)
|
|
{
|
|
if (GETZONEMASK(ghZoneOther) & ZONE_UI)
|
|
{
|
|
va_list v1;
|
|
va_start(v1, pszFormat);
|
|
DbgZVPrintf(ghZoneOther, iZONE_UI, pszFormat, v1);
|
|
va_end(v1);
|
|
}
|
|
}
|
|
|
|
#endif /* DEBUG */
|
|
|
|
|
|
|
|
/* F L O A D S T R I N G */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FLoadString
|
|
|
|
Load a resource string.
|
|
Assumes the buffer is valid and can hold the resource.
|
|
----------------------------------------------------------------------------*/
|
|
BOOL FLoadString(UINT id, LPTSTR lpsz, UINT cch)
|
|
{
|
|
ASSERT(NULL != _Module.GetModuleInstance());
|
|
ASSERT(NULL != lpsz);
|
|
|
|
if (0 == ::LoadString(_Module.GetResourceModule(), id, lpsz, cch))
|
|
{
|
|
ERROR_OUT(("*** Resource %d does not exist", id));
|
|
*lpsz = _T('\0');
|
|
return FALSE;
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
/* F L O A D S T R I N G 1 */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FLoadString1
|
|
|
|
Loads a resource string an formats it with the parameter.
|
|
Assumes the resource is less than MAX_PATH characters
|
|
----------------------------------------------------------------------------*/
|
|
BOOL FLoadString1(UINT id, LPTSTR lpsz, LPVOID p)
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
|
|
if (!FLoadString(id, sz, CCHMAX(sz)))
|
|
return FALSE;
|
|
|
|
wsprintf(lpsz, sz, p);
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
/* F L O A D S T R I N G 2 */
|
|
/*----------------------------------------------------------------------------
|
|
%%Function: FLoadString2
|
|
|
|
Load a resource string. Return the length.
|
|
Assumes the buffer is valid and can hold the resource.
|
|
----------------------------------------------------------------------------*/
|
|
int FLoadString2(UINT id, LPTSTR lpsz, UINT cch)
|
|
{
|
|
ASSERT(NULL != _Module.GetModuleInstance());
|
|
ASSERT(NULL != lpsz);
|
|
|
|
int length = ::LoadString(_Module.GetResourceModule(), id, lpsz, cch);
|
|
|
|
if (0 == length)
|
|
{
|
|
ERROR_OUT(("*** Resource %d does not exist", id));
|
|
*lpsz = _T('\0');
|
|
}
|
|
|
|
return length;
|
|
}
|
|
|
|
/* P S Z L O A D S T R I N G */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: PszLoadString
|
|
|
|
Return the string associated with the resource.
|
|
-------------------------------------------------------------------------*/
|
|
LPTSTR PszLoadString(UINT id)
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
|
|
if (0 == ::LoadString(::GetInstanceHandle(), id, sz, CCHMAX(sz)))
|
|
{
|
|
ERROR_OUT(("*** Resource %d does not exist", id));
|
|
sz[0] = _T('\0');
|
|
}
|
|
|
|
return PszAlloc(sz);
|
|
}
|
|
|
|
|
|
/* L O A D R E S I N T */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: LoadResInt
|
|
|
|
Return the integer associated with the resource string.
|
|
-------------------------------------------------------------------------*/
|
|
int LoadResInt(UINT id, int iDefault)
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
if (0 == ::LoadString(::GetInstanceHandle(), id, sz, CCHMAX(sz)))
|
|
return iDefault;
|
|
|
|
return RtStrToInt(sz);
|
|
}
|
|
|
|
|
|
/* F C R E A T E I L S N A M E */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: FCreateIlsName
|
|
|
|
Combine the server and email names to form an ILS name.
|
|
Return TRUE if the result fit in the buffer.
|
|
-------------------------------------------------------------------------*/
|
|
BOOL FCreateIlsName(LPTSTR pszDest, LPCTSTR pszServer, LPCTSTR pszEmail, int cchMax)
|
|
{
|
|
ASSERT(NULL != pszDest);
|
|
|
|
TCHAR szServer[MAX_PATH];
|
|
if (FEmptySz(pszServer))
|
|
{
|
|
lstrcpyn( szServer, CDirectoryManager::get_defaultServer(), CCHMAX( szServer ) );
|
|
pszServer = szServer;
|
|
}
|
|
|
|
if (FEmptySz(pszEmail))
|
|
{
|
|
WARNING_OUT(("FCreateIlsName: Null email name?"));
|
|
return FALSE;
|
|
}
|
|
|
|
int cch = lstrlen(pszServer);
|
|
lstrcpyn(pszDest, pszServer, cchMax);
|
|
if (cch >= (cchMax-2))
|
|
return FALSE;
|
|
|
|
pszDest += cch;
|
|
*pszDest++ = _T('/');
|
|
cchMax -= (cch+1);
|
|
|
|
lstrcpyn(pszDest, pszEmail, cchMax);
|
|
|
|
return (lstrlen(pszEmail) < cchMax);
|
|
}
|
|
|
|
/* G E T D E F A U L T N A M E */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: GetDefaultName
|
|
|
|
-------------------------------------------------------------------------*/
|
|
BOOL GetDefaultName(LPTSTR pszName, int nBufferMax)
|
|
{
|
|
BOOL bRet = TRUE;
|
|
|
|
ASSERT(pszName);
|
|
|
|
// First, try to get the Registered User Name from Windows:
|
|
|
|
RegEntry re(WINDOWS_CUR_VER_KEY, HKEY_LOCAL_MACHINE);
|
|
lstrcpyn(pszName, re.GetString(REGVAL_REGISTERED_OWNER), nBufferMax);
|
|
if (_T('\0') == pszName[0])
|
|
{
|
|
// The registered name was empty, try the computer name:
|
|
|
|
DWORD dwBufMax = nBufferMax;
|
|
if ((FALSE == ::GetComputerName(pszName, &dwBufMax)) ||
|
|
(_T('\0') == pszName[0]))
|
|
{
|
|
// The computer name was empty, use UNKNOWN:
|
|
bRet = FLoadString(IDS_UNKNOWN, pszName, nBufferMax);
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
|
|
/* E X T R A C T S E R V E R N A M E */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: ExtractServerName
|
|
|
|
Extract the server name from pcszAddr and copy it into pszServer.
|
|
Return a pointer to the remaining data.
|
|
|
|
Uses the default server name if none is found.
|
|
Returns a pointer to the 2nd portion of the name.
|
|
-------------------------------------------------------------------------*/
|
|
LPCTSTR ExtractServerName(LPCTSTR pcszAddr, LPTSTR pszServer, UINT cchMax)
|
|
{
|
|
LPCTSTR pchSlash = _StrChr(pcszAddr, _T('/'));
|
|
|
|
if (NULL == pchSlash)
|
|
{
|
|
lstrcpyn( pszServer, CDirectoryManager::get_defaultServer(), cchMax );
|
|
}
|
|
else
|
|
{
|
|
lstrcpyn(pszServer, pcszAddr, (int)(1 + (pchSlash - pcszAddr)));
|
|
pcszAddr = pchSlash+1;
|
|
}
|
|
return pcszAddr;
|
|
}
|
|
|
|
BOOL FBrowseForFolder(LPTSTR pszFolder, UINT cchMax, LPCTSTR pszTitle, HWND hwndParent)
|
|
{
|
|
LPITEMIDLIST pidlRoot;
|
|
SHGetSpecialFolderLocation(HWND_DESKTOP, CSIDL_DRIVES, &pidlRoot);
|
|
|
|
BROWSEINFO bi;
|
|
ClearStruct(&bi);
|
|
bi.hwndOwner = hwndParent;
|
|
bi.lpszTitle = pszTitle;
|
|
bi.ulFlags = BIF_RETURNONLYFSDIRS;
|
|
bi.pidlRoot = pidlRoot;
|
|
|
|
LPITEMIDLIST pidl = SHBrowseForFolder(&bi);
|
|
BOOL fRet = (pidl != NULL);
|
|
if (fRet)
|
|
{
|
|
ASSERT(cchMax >= MAX_PATH);
|
|
SHGetPathFromIDList(pidl, pszFolder);
|
|
ASSERT(lstrlen(pszFolder) < (int) cchMax);
|
|
}
|
|
|
|
// Get the shell's allocator to free PIDLs
|
|
LPMALLOC lpMalloc;
|
|
if (!SHGetMalloc(&lpMalloc) && (NULL != lpMalloc))
|
|
{
|
|
if (NULL != pidlRoot)
|
|
{
|
|
lpMalloc->Free(pidlRoot);
|
|
}
|
|
if (pidl)
|
|
{
|
|
lpMalloc->Free(pidl);
|
|
}
|
|
lpMalloc->Release();
|
|
}
|
|
|
|
return fRet;
|
|
}
|
|
|
|
|
|
|
|
/* D I S A B L E C O N T R O L */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: DisableControl
|
|
|
|
-------------------------------------------------------------------------*/
|
|
VOID DisableControl(HWND hdlg, int id)
|
|
{
|
|
if ((NULL != hdlg) && (0 != id))
|
|
{
|
|
HWND hwndCtrl = GetDlgItem(hdlg, id);
|
|
ASSERT(NULL != hwndCtrl);
|
|
EnableWindow(hwndCtrl, FALSE);
|
|
}
|
|
}
|
|
|
|
|
|
BOOL IsWindowActive(HWND hwnd)
|
|
{
|
|
HWND hwndFocus = GetFocus();
|
|
|
|
while (NULL != hwndFocus)
|
|
{
|
|
if (hwndFocus == hwnd)
|
|
{
|
|
return(TRUE);
|
|
}
|
|
|
|
HWND hwndParent = GetParent(hwndFocus);
|
|
if (NULL == hwndParent)
|
|
{
|
|
hwndFocus = GetWindow(hwndFocus, GW_OWNER);
|
|
}
|
|
else
|
|
{
|
|
hwndFocus = hwndParent;
|
|
}
|
|
}
|
|
|
|
return(FALSE);
|
|
}
|
|
|
|
class CDialogTranslate : public CTranslateAccel
|
|
{
|
|
public:
|
|
CDialogTranslate(HWND hwnd) : CTranslateAccel(hwnd) {}
|
|
|
|
HRESULT TranslateAccelerator(
|
|
LPMSG pMsg , //Pointer to the structure
|
|
DWORD grfModifiers //Flags describing the state of the keys
|
|
)
|
|
{
|
|
HWND hwnd = GetWindow();
|
|
|
|
return(::IsDialogMessage(hwnd, pMsg) ? S_OK : S_FALSE);
|
|
}
|
|
} ;
|
|
|
|
|
|
VOID AddTranslateAccelerator(ITranslateAccelerator* pTrans)
|
|
{
|
|
EnterCriticalSection(&dialogListCriticalSection);
|
|
if (g_pDialogList->Add(pTrans))
|
|
{
|
|
pTrans->AddRef();
|
|
}
|
|
LeaveCriticalSection(&dialogListCriticalSection);
|
|
}
|
|
|
|
VOID RemoveTranslateAccelerator(ITranslateAccelerator* pTrans)
|
|
{
|
|
EnterCriticalSection(&dialogListCriticalSection);
|
|
if (g_pDialogList->Remove(pTrans))
|
|
{
|
|
pTrans->Release();
|
|
}
|
|
LeaveCriticalSection(&dialogListCriticalSection);
|
|
}
|
|
|
|
/* A D D M O D E L E S S D L G */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: AddModelessDlg
|
|
|
|
Add the hwnd to the global dialog list
|
|
-------------------------------------------------------------------------*/
|
|
VOID AddModelessDlg(HWND hwnd)
|
|
{
|
|
ASSERT(NULL != g_pDialogList);
|
|
|
|
CDialogTranslate *pDlgTrans = new CDialogTranslate(hwnd);
|
|
if (NULL != pDlgTrans)
|
|
{
|
|
AddTranslateAccelerator(pDlgTrans);
|
|
pDlgTrans->Release();
|
|
}
|
|
}
|
|
|
|
/* R E M O V E M O D E L E S S D L G */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: RemoveModelessDlg
|
|
|
|
Remove the hwnd from the global dialog list
|
|
-------------------------------------------------------------------------*/
|
|
VOID RemoveModelessDlg(HWND hwnd)
|
|
{
|
|
ASSERT(g_pDialogList);
|
|
|
|
EnterCriticalSection(&dialogListCriticalSection);
|
|
|
|
for (int i=g_pDialogList->GetSize()-1; i>=0; --i)
|
|
{
|
|
ITranslateAccelerator *pTrans = (*g_pDialogList)[i];
|
|
ASSERT(NULL != pTrans);
|
|
|
|
HWND hwndTemp = NULL;
|
|
if (S_OK == pTrans->GetWindow(&hwndTemp) && hwndTemp == hwnd)
|
|
{
|
|
RemoveTranslateAccelerator(pTrans);
|
|
break;
|
|
}
|
|
}
|
|
|
|
LeaveCriticalSection(&dialogListCriticalSection);
|
|
|
|
}
|
|
|
|
/* K I L L S C R N S A V E R */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: KillScrnSaver
|
|
|
|
Remove the screen saver if it is active
|
|
-------------------------------------------------------------------------*/
|
|
VOID KillScrnSaver(void)
|
|
{
|
|
if (!IsWindowsNT())
|
|
return;
|
|
|
|
POINT pos;
|
|
::GetCursorPos(&pos);
|
|
::SetCursorPos(0,0);
|
|
::SetCursorPos(pos.x,pos.y);
|
|
}
|
|
|
|
/* D X P S Z */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: DxpSz
|
|
|
|
Get the width of the string in pixels.
|
|
-------------------------------------------------------------------------*/
|
|
int DxpSz(LPCTSTR pcsz)
|
|
{
|
|
HWND hwndDesktop = GetDesktopWindow();
|
|
if (NULL == hwndDesktop)
|
|
return 0;
|
|
|
|
HDC hdc = GetDC(hwndDesktop);
|
|
if (NULL == hdc)
|
|
return 0;
|
|
|
|
HFONT hFontOld = (HFONT) SelectObject(hdc, g_hfontDlg);
|
|
SIZE size;
|
|
int dxp = ::GetTextExtentPoint32(hdc, pcsz, lstrlen(pcsz), &size)
|
|
? size.cx : 0;
|
|
|
|
::SelectObject(hdc, hFontOld);
|
|
::ReleaseDC(hwndDesktop, hdc);
|
|
|
|
return dxp;
|
|
}
|
|
|
|
|
|
/* F A N S I S Z */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: FAnsiSz
|
|
|
|
Return TRUE if the string contains no DBCS characters.
|
|
-------------------------------------------------------------------------*/
|
|
BOOL FAnsiSz(LPCTSTR psz)
|
|
{
|
|
if (NULL != psz)
|
|
{
|
|
char ch;
|
|
while (_T('\0') != (ch = *psz++))
|
|
{
|
|
if (IsDBCSLeadByte(ch))
|
|
{
|
|
return FALSE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
|
|
int g_cBusyOperations = 0;
|
|
|
|
VOID DecrementBusyOperations(void)
|
|
{
|
|
g_cBusyOperations--;
|
|
|
|
POINT pt;
|
|
// Wiggle the mouse - force user to send a WM_SETCURSOR
|
|
if (::GetCursorPos(&pt))
|
|
::SetCursorPos(pt.x, pt.y);
|
|
}
|
|
|
|
VOID IncrementBusyOperations(void)
|
|
{
|
|
g_cBusyOperations++;
|
|
|
|
POINT pt;
|
|
// Wiggle the mouse - force user to send a WM_SETCURSOR
|
|
if (::GetCursorPos(&pt))
|
|
::SetCursorPos(pt.x, pt.y);
|
|
}
|
|
|
|
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// String Utilities
|
|
|
|
/* P S Z A L L O C */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: PszAlloc
|
|
|
|
-------------------------------------------------------------------------*/
|
|
LPTSTR PszAlloc(LPCTSTR pszSrc)
|
|
{
|
|
if (NULL == pszSrc)
|
|
return NULL;
|
|
|
|
LPTSTR pszDest = new TCHAR[lstrlen(pszSrc) + 1];
|
|
if (NULL != pszDest)
|
|
{
|
|
lstrcpy(pszDest, pszSrc);
|
|
}
|
|
return pszDest;
|
|
}
|
|
|
|
|
|
VOID FreePsz(LPTSTR psz)
|
|
{
|
|
delete [] psz;
|
|
}
|
|
|
|
/* L P T S T R _ T O _ B S T R */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: LPTSTR_to_BSTR
|
|
|
|
-------------------------------------------------------------------------*/
|
|
HRESULT LPTSTR_to_BSTR(BSTR *pbstr, LPCTSTR psz)
|
|
{
|
|
ASSERT(NULL != pbstr);
|
|
if (NULL == psz)
|
|
{
|
|
psz = TEXT(""); // convert NULL strings to empty strings
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
// compute the length of the required BSTR
|
|
int cch = MultiByteToWideChar(CP_ACP, 0, psz, -1, NULL, 0);
|
|
if (cch <= 0)
|
|
return E_FAIL;
|
|
|
|
// allocate the widestr, +1 for terminating null
|
|
BSTR bstr = SysAllocStringLen(NULL, cch-1); // SysAllocStringLen adds 1
|
|
if (bstr == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
MultiByteToWideChar(CP_ACP, 0, psz, -1, (LPWSTR)bstr, cch);
|
|
((LPWSTR)bstr)[cch - 1] = 0;
|
|
#else
|
|
|
|
BSTR bstr = SysAllocString(psz);
|
|
if (bstr == NULL)
|
|
return E_OUTOFMEMORY;
|
|
#endif // UNICODE
|
|
|
|
*pbstr = bstr;
|
|
return S_OK;
|
|
}
|
|
|
|
/* B S T R _ T O _ L P T S T R */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: BSTR_to_LPTSTR
|
|
|
|
-------------------------------------------------------------------------*/
|
|
HRESULT BSTR_to_LPTSTR(LPTSTR *ppsz, BSTR bstr)
|
|
{
|
|
#ifndef UNICODE
|
|
// compute the length of the required BSTR
|
|
int cch = WideCharToMultiByte(CP_ACP, 0, (LPWSTR)bstr, -1, NULL, 0, NULL, NULL);
|
|
if (cch <= 0)
|
|
return E_FAIL;
|
|
|
|
// cch is the number of BYTES required, including the null terminator
|
|
*ppsz = (LPTSTR) new char[cch];
|
|
if (*ppsz == NULL)
|
|
return E_OUTOFMEMORY;
|
|
|
|
WideCharToMultiByte(CP_ACP, 0, (LPWSTR)bstr, -1, *ppsz, cch, NULL, NULL);
|
|
return S_OK;
|
|
#else
|
|
return E_NOTIMPL;
|
|
#endif // UNICODE
|
|
}
|
|
|
|
/* P S Z F R O M B S T R */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: PszFromBstr
|
|
|
|
-------------------------------------------------------------------------*/
|
|
LPTSTR PszFromBstr(PCWSTR pwStr)
|
|
{
|
|
#ifdef UNICODE
|
|
return PszAlloc(pwStr)
|
|
#else
|
|
int cch = WideCharToMultiByte(CP_ACP, 0, pwStr, -1, NULL, 0, NULL, NULL);
|
|
if (cch <= 0)
|
|
return NULL;
|
|
|
|
// cch is the number of BYTES required, including the null terminator
|
|
LPTSTR psz = new char[cch];
|
|
if (NULL != psz)
|
|
{
|
|
WideCharToMultiByte(CP_ACP, 0, pwStr, -1, psz, cch, NULL, NULL);
|
|
}
|
|
return psz;
|
|
#endif /* UNICODE */
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////
|
|
// Connection Point Helpers
|
|
|
|
HRESULT NmAdvise(IUnknown* pUnkCP, IUnknown* pUnk, const IID& iid, LPDWORD pdw)
|
|
{
|
|
IConnectionPointContainer *pCPC;
|
|
IConnectionPoint *pCP;
|
|
HRESULT hRes = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void**)&pCPC);
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
hRes = pCPC->FindConnectionPoint(iid, &pCP);
|
|
pCPC->Release();
|
|
}
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
hRes = pCP->Advise(pUnk, pdw);
|
|
pCP->Release();
|
|
}
|
|
return hRes;
|
|
}
|
|
|
|
HRESULT NmUnadvise(IUnknown* pUnkCP, const IID& iid, DWORD dw)
|
|
{
|
|
IConnectionPointContainer *pCPC;
|
|
IConnectionPoint *pCP;
|
|
HRESULT hRes = pUnkCP->QueryInterface(IID_IConnectionPointContainer, (void**)&pCPC);
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
hRes = pCPC->FindConnectionPoint(iid, &pCP);
|
|
pCPC->Release();
|
|
}
|
|
if (SUCCEEDED(hRes))
|
|
{
|
|
hRes = pCP->Unadvise(dw);
|
|
pCP->Release();
|
|
}
|
|
return hRes;
|
|
}
|
|
|
|
extern INmSysInfo2 * g_pNmSysInfo;
|
|
|
|
////////////////////////////////////////////////////////////////////////////
|
|
// Call into the certificate generation module to generate
|
|
// a certificate matching the ULS info for secure calling:
|
|
|
|
DWORD MakeCertWrap
|
|
(
|
|
LPCSTR szFirstName,
|
|
LPCSTR szLastName,
|
|
LPCSTR szEmailName,
|
|
DWORD dwFlags
|
|
)
|
|
{
|
|
HMODULE hMakeCertLib = LoadLibrary(SZ_NMMKCERTLIB);
|
|
DWORD dwRet = -1;
|
|
|
|
if ( NULL != hMakeCertLib ) {
|
|
PFN_NMMAKECERT pfn_MakeCert =
|
|
(PFN_NMMAKECERT)GetProcAddress ( hMakeCertLib,
|
|
SZ_NMMAKECERTFUNC );
|
|
|
|
if ( NULL != pfn_MakeCert ) {
|
|
dwRet = pfn_MakeCert( szFirstName,
|
|
szLastName,
|
|
szEmailName,
|
|
NULL,
|
|
NULL,
|
|
dwFlags );
|
|
|
|
RefreshSelfIssuedCert();
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("GetProcAddress(%s) failed: %x",
|
|
SZ_NMMAKECERTFUNC, GetLastError()));
|
|
}
|
|
FreeLibrary ( hMakeCertLib );
|
|
}
|
|
else
|
|
{
|
|
ERROR_OUT(("LoadLibrary(%s) failed: %x", SZ_NMMKCERTLIB,
|
|
GetLastError()));
|
|
}
|
|
return(dwRet);
|
|
}
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////
|
|
// Icon Utilities
|
|
|
|
HIMAGELIST g_himlIconSmall = NULL;
|
|
|
|
VOID LoadIconImages(void)
|
|
{
|
|
ASSERT(NULL == g_himlIconSmall);
|
|
g_himlIconSmall = ImageList_Create(DXP_ICON_SMALL, DYP_ICON_SMALL, ILC_MASK, 1, 0);
|
|
if (NULL != g_himlIconSmall)
|
|
{
|
|
HBITMAP hBmp = ::LoadBitmap(::GetInstanceHandle(), MAKEINTRESOURCE(IDB_ICON_IMAGES));
|
|
if (NULL != hBmp)
|
|
{
|
|
ImageList_AddMasked(g_himlIconSmall, hBmp, TOOLBAR_MASK_COLOR);
|
|
::DeleteObject(hBmp);
|
|
}
|
|
}
|
|
}
|
|
|
|
VOID FreeIconImages(void)
|
|
{
|
|
if (NULL != g_himlIconSmall)
|
|
{
|
|
ImageList_Destroy(g_himlIconSmall);
|
|
g_himlIconSmall = NULL;
|
|
}
|
|
}
|
|
|
|
|
|
VOID DrawIconSmall(HDC hdc, int iIcon, int x, int y)
|
|
{
|
|
ImageList_DrawEx(g_himlIconSmall, iIcon, hdc,
|
|
x, y, DXP_ICON_SMALL, DYP_ICON_SMALL,
|
|
CLR_DEFAULT, CLR_DEFAULT, ILD_NORMAL);
|
|
}
|
|
|
|
// Get the default dialog (GUI) font for international
|
|
HFONT GetDefaultFont(void)
|
|
{
|
|
if (NULL == g_hfontDlg)
|
|
{
|
|
g_hfontDlg = (HFONT) ::GetStockObject(DEFAULT_GUI_FONT);
|
|
}
|
|
|
|
return g_hfontDlg;
|
|
}
|
|
|
|
/* F E M P T Y D L G I T E M */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: FEmptyDlgItem
|
|
|
|
Return TRUE if the dialog control is empty
|
|
-------------------------------------------------------------------------*/
|
|
BOOL FEmptyDlgItem(HWND hdlg, UINT id)
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
return (0 == GetDlgItemTextTrimmed(hdlg, id, sz, CCHMAX(sz)) );
|
|
}
|
|
|
|
|
|
|
|
/* T R I M D L G I T E M T E X T */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: TrimDlgItemText
|
|
|
|
Trim the text in the edit control and return the length of the string.
|
|
-------------------------------------------------------------------------*/
|
|
UINT TrimDlgItemText(HWND hdlg, UINT id)
|
|
{
|
|
TCHAR sz[MAX_PATH];
|
|
GetDlgItemTextTrimmed(hdlg, id, sz, CCHMAX(sz));
|
|
SetDlgItemText(hdlg, id, sz);
|
|
return lstrlen(sz);
|
|
}
|
|
|
|
/* G E T D L G I T E M T E X T T R I M M E D */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: GetDlgItemTextTrimmed
|
|
|
|
-------------------------------------------------------------------------*/
|
|
UINT GetDlgItemTextTrimmed(HWND hdlg, int id, PTCHAR psz, int cchMax)
|
|
{
|
|
UINT cch = GetDlgItemText(hdlg, id, psz, cchMax);
|
|
if (0 != cch)
|
|
{
|
|
cch = TrimSz(psz);
|
|
}
|
|
|
|
return cch;
|
|
}
|
|
|
|
|
|
/* F M T D A T E T I M E */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: FmtDateTime
|
|
|
|
Formats the system time using the current setting (MM/DD/YY HH:MM xm)
|
|
-------------------------------------------------------------------------*/
|
|
int FmtDateTime(LPSYSTEMTIME pst, LPTSTR pszDateTime, int cchMax)
|
|
{
|
|
pszDateTime[0] = _T('\0');
|
|
int cch = ::GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE,
|
|
pst, NULL, pszDateTime, cchMax);
|
|
if ((0 != cch) && ((cchMax - cch) > 0))
|
|
{
|
|
// Tack on a space and then the time.
|
|
// GetDateFormat returns count of chars
|
|
// INCLUDING the NULL terminator, hence the - 1
|
|
LPTSTR pszTime = pszDateTime + (cch - 1);
|
|
pszTime[0] = _T(' ');
|
|
pszTime[1] = _T('\0');
|
|
cch = ::GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS,
|
|
pst, NULL, &(pszTime[1]), (cchMax - cch));
|
|
}
|
|
|
|
return (cch == 0 ? 0 : lstrlen(pszDateTime));
|
|
}
|
|
|
|
/* C O M B I N E N A M E S */
|
|
/*-------------------------------------------------------------------------
|
|
%%Function: CombineNames
|
|
|
|
Combine the two names into one string.
|
|
The result is a "First Last" (or Intl'd "Last First") string
|
|
-------------------------------------------------------------------------*/
|
|
VOID CombineNames(LPTSTR pszResult, int cchResult, LPCTSTR pcszFirst, LPCTSTR pcszLast)
|
|
{
|
|
ASSERT(pszResult);
|
|
TCHAR szFmt[32]; // A small value: String is "%1 %2" or "%2 %1"
|
|
TCHAR sz[1024]; // The result (before truncating to cchResult chars)
|
|
LPCTSTR argw[2];
|
|
|
|
argw[0] = pcszFirst;
|
|
argw[1] = pcszLast;
|
|
|
|
*pszResult = _T('\0');
|
|
|
|
if (FLoadString(IDS_NAME_ORDER, szFmt, CCHMAX(szFmt)))
|
|
{
|
|
if (0 != FormatMessage(FORMAT_MESSAGE_ARGUMENT_ARRAY | FORMAT_MESSAGE_FROM_STRING,
|
|
szFmt, 0, 0, sz, CCHMAX(sz), (va_list *)argw ))
|
|
{
|
|
lstrcpyn(pszResult, sz, cchResult);
|
|
#ifndef _UNICODE
|
|
// (see bug 3907 )
|
|
// lstrcpyn() can clip a DBCS character in half at the end of the string
|
|
// we need to walk the string with ::CharNext() and replace the last byte
|
|
// with a NULL if the last byte is half of a DBCS char.
|
|
PTSTR pszSource = sz;
|
|
while (*pszSource && (pszSource - sz < cchResult))
|
|
{
|
|
PTSTR pszPrev = pszSource;
|
|
pszSource = ::CharNext(pszPrev);
|
|
// If we've reached the first character that didn't get copied into
|
|
// the destination buffer, and the previous character was a double
|
|
// byte character...
|
|
if (((pszSource - sz) == cchResult) && ::IsDBCSLeadByte(*pszPrev))
|
|
{
|
|
// Replace the destination buffer's last character with '\0'
|
|
// NOTE: pszResult[cchResult - 1] is '\0' thanks to lstrcpyn()
|
|
pszResult[cchResult - 2] = _T('\0');
|
|
break;
|
|
}
|
|
}
|
|
#endif // ! _UNICODE
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
BOOL NMGetSpecialFolderPath(
|
|
HWND hwndOwner,
|
|
LPTSTR lpszPath,
|
|
int nFolder,
|
|
BOOL fCreate)
|
|
{
|
|
LPITEMIDLIST pidl = NULL;
|
|
|
|
BOOL fRet = FALSE;
|
|
|
|
if (NOERROR == SHGetSpecialFolderLocation(NULL, nFolder, &pidl))
|
|
{
|
|
ASSERT(NULL != pidl);
|
|
|
|
if (SHGetPathFromIDList(pidl, lpszPath))
|
|
{
|
|
lstrcat(lpszPath, _TEXT("\\"));
|
|
fRet = TRUE;
|
|
}
|
|
|
|
LPMALLOC lpMalloc;
|
|
if (!SHGetMalloc(&lpMalloc))
|
|
{
|
|
ASSERT(NULL != lpMalloc);
|
|
|
|
lpMalloc->Free(pidl);
|
|
lpMalloc->Release();
|
|
}
|
|
}
|
|
return fRet;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager static data members. //
|
|
//--------------------------------------------------------------------------//
|
|
bool CDirectoryManager::m_webEnabled = true;
|
|
TCHAR CDirectoryManager::m_ils[ MAX_PATH ] = TEXT( "" );
|
|
TCHAR CDirectoryManager::m_displayName[ MAX_PATH ] = TEXT( "" );
|
|
TCHAR CDirectoryManager::m_displayNameDefault[ MAX_PATH ] = TEXT( "Microsoft Internet Directory" );
|
|
TCHAR CDirectoryManager::m_defaultServer[ MAX_PATH ] = TEXT( "" );
|
|
TCHAR CDirectoryManager::m_DomainDirectory[ MAX_PATH ] = TEXT( "" );
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::get_defaultServer. //
|
|
//--------------------------------------------------------------------------//
|
|
const TCHAR * const
|
|
CDirectoryManager::get_defaultServer(void)
|
|
{
|
|
|
|
if( m_defaultServer[ 0 ] == '\0' )
|
|
{
|
|
// defaultServer not yet loaded...
|
|
RegEntry re( ISAPI_CLIENT_KEY, HKEY_CURRENT_USER );
|
|
|
|
lstrcpyn( m_defaultServer, re.GetString( REGVAL_SERVERNAME ), CCHMAX( m_defaultServer ) );
|
|
|
|
if( (m_defaultServer[ 0 ] == '\0') && (get_DomainDirectory() != NULL) )
|
|
{
|
|
// When no default ils server has been saved in the registry we first try to default it to the
|
|
// server configured for the domain if any...
|
|
lstrcpy( m_defaultServer, m_DomainDirectory );
|
|
}
|
|
|
|
if( (m_defaultServer[ 0 ] == '\0') && isWebDirectoryEnabled() )
|
|
{
|
|
// When no default ils server has been saved in the registry we default it to m_ils...
|
|
lstrcpy( m_defaultServer, get_webDirectoryIls() );
|
|
}
|
|
}
|
|
|
|
return( m_defaultServer );
|
|
|
|
} // End of CDirectoryManager::get_defaultServer.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::set_defaultServer. //
|
|
//--------------------------------------------------------------------------//
|
|
void
|
|
CDirectoryManager::set_defaultServer
|
|
(
|
|
const TCHAR * const serverName
|
|
){
|
|
RegEntry ulsKey( ISAPI_CLIENT_KEY, HKEY_CURRENT_USER );
|
|
|
|
ulsKey.SetValue( REGVAL_SERVERNAME, serverName );
|
|
|
|
lstrcpy( m_defaultServer, serverName );
|
|
|
|
} // End of CDirectoryManager::set_defaultServer.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::isWebDirectory. //
|
|
//--------------------------------------------------------------------------//
|
|
bool
|
|
CDirectoryManager::isWebDirectory
|
|
(
|
|
const TCHAR * const directory
|
|
){
|
|
TCHAR buffer[ MAX_PATH ];
|
|
|
|
// If directory is null then the question is "is the default server the web directory?"
|
|
|
|
return( isWebDirectoryEnabled() && (lstrcmpi( (directory != NULL)? get_dnsName( directory ): get_defaultServer(), get_webDirectoryIls() ) == 0) );
|
|
|
|
} // End of CDirectoryManager::isWebDirectory.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::get_dnsName. //
|
|
//--------------------------------------------------------------------------//
|
|
const TCHAR * const
|
|
CDirectoryManager::get_dnsName
|
|
(
|
|
const TCHAR * const name
|
|
){
|
|
|
|
// Check to see if the specified name matches m_displayName...
|
|
return( (isWebDirectoryEnabled() && (lstrcmpi( name, loadDisplayName() ) == 0))? get_webDirectoryIls() : name );
|
|
|
|
} // End of CDirectoryManager::get_dnsName.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::get_displayName. //
|
|
//--------------------------------------------------------------------------//
|
|
const TCHAR * const
|
|
CDirectoryManager::get_displayName
|
|
(
|
|
const TCHAR * const name
|
|
){
|
|
|
|
// Check to see if the specified name matches m_ils...
|
|
return( (isWebDirectoryEnabled() && (lstrcmpi( name, get_webDirectoryIls() ) == 0))? loadDisplayName(): name );
|
|
|
|
} // End of CDirectoryManager::get_displayName.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::loadDisplayName. //
|
|
//--------------------------------------------------------------------------//
|
|
const TCHAR * const
|
|
CDirectoryManager::loadDisplayName(void)
|
|
{
|
|
using namespace ConfPolicies;
|
|
|
|
if( m_displayName[ 0 ] == '\0' )
|
|
{
|
|
GetWebDirInfo( NULL, 0,
|
|
NULL, 0,
|
|
m_displayName, ARRAY_ELEMENTS(m_displayName) );
|
|
|
|
if ( '\0' == m_displayName[0] )
|
|
{
|
|
lstrcpy( m_displayName, RES2T( IDS_MS_INTERNET_DIRECTORY ) );
|
|
|
|
if( m_displayName[ 0 ] == '\0' )
|
|
{
|
|
// Loading m_displayName from the resources failed... default to m_displayNameDefault...
|
|
lstrcpy( m_displayName, m_displayNameDefault );
|
|
}
|
|
}
|
|
}
|
|
|
|
return( m_displayName );
|
|
|
|
} // End of CDirectoryManager::loadDisplayName.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::get_webDirectoryUrl. //
|
|
//--------------------------------------------------------------------------//
|
|
void
|
|
CDirectoryManager::get_webDirectoryUrl(LPTSTR szWebDir, int cchmax)
|
|
{
|
|
using namespace ConfPolicies;
|
|
|
|
if ( !isWebDirectoryEnabled() )
|
|
{
|
|
szWebDir[0] = '\0';
|
|
return;
|
|
}
|
|
|
|
GetWebDirInfo( szWebDir, cchmax );
|
|
if ( '\0' != szWebDir[0] )
|
|
{
|
|
// All done
|
|
return;
|
|
}
|
|
|
|
void FormatURL(LPTSTR szURL);
|
|
|
|
lstrcpyn(szWebDir, RES2T(IDS_WEB_PAGE_FORMAT_WEBVIEW), cchmax);
|
|
FormatURL(szWebDir);
|
|
|
|
} // End of CDirectoryManager::get_webDirectoryUrl.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::get_webDirectoryIls. //
|
|
//--------------------------------------------------------------------------//
|
|
const TCHAR * const
|
|
CDirectoryManager::get_webDirectoryIls(void)
|
|
{
|
|
using namespace ConfPolicies;
|
|
|
|
if (!isWebDirectoryEnabled())
|
|
{
|
|
return(TEXT(""));
|
|
}
|
|
|
|
if ('\0' == m_ils[0])
|
|
{
|
|
GetWebDirInfo( NULL, 0,
|
|
m_ils, ARRAY_ELEMENTS(m_ils) );
|
|
if ('\0' == m_ils[0])
|
|
{
|
|
lstrcpy(m_ils, TEXT("logon.netmeeting.microsoft.com"));
|
|
}
|
|
}
|
|
|
|
return(m_ils);
|
|
|
|
} // End of CDirectoryManager::get_webDirectoryIls.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::isWebDirectoryEnabled. //
|
|
//--------------------------------------------------------------------------//
|
|
bool
|
|
CDirectoryManager::isWebDirectoryEnabled(void)
|
|
{
|
|
static bool policyChecked = false;
|
|
|
|
if( !policyChecked )
|
|
{
|
|
policyChecked = true;
|
|
m_webEnabled = !ConfPolicies::isWebDirectoryDisabled();
|
|
}
|
|
|
|
return( m_webEnabled );
|
|
|
|
} // End of CDirectoryManager::isWebDirectoryEnabled.
|
|
|
|
|
|
//--------------------------------------------------------------------------//
|
|
// CDirectoryManager::get_DomainDirectory. //
|
|
//--------------------------------------------------------------------------//
|
|
const TCHAR * const
|
|
CDirectoryManager::get_DomainDirectory(void)
|
|
{
|
|
static bool bAccessAttempted = false; // only read this info once... if it fails once assume it's not available and don't retry until restarted...
|
|
|
|
if( (!bAccessAttempted) && m_DomainDirectory[ 0 ] == '\0' )
|
|
{
|
|
bAccessAttempted = true;
|
|
|
|
// Try to obtain the configured directory for this domain...
|
|
ITRendezvous * pRendezvous;
|
|
HRESULT hrResult;
|
|
|
|
hrResult = ::CoCreateInstance( CLSID_Rendezvous, NULL, CLSCTX_ALL, IID_ITRendezvous, (void **) &pRendezvous );
|
|
|
|
if( (hrResult == S_OK) && (pRendezvous != NULL) )
|
|
{
|
|
IEnumDirectory * pEnumDirectory;
|
|
|
|
hrResult = pRendezvous->EnumerateDefaultDirectories( &pEnumDirectory );
|
|
|
|
if( (hrResult == S_OK) && (pEnumDirectory != NULL) )
|
|
{
|
|
ITDirectory * pDirectory;
|
|
bool bFoundILS = false;
|
|
|
|
do
|
|
{
|
|
hrResult = pEnumDirectory->Next( 1, &pDirectory, NULL );
|
|
|
|
if( (hrResult == S_OK) && (pDirectory != NULL) )
|
|
{
|
|
LPWSTR * ppServers;
|
|
DIRECTORY_TYPE type;
|
|
|
|
if( pDirectory->get_DirectoryType( &type ) == S_OK )
|
|
{
|
|
if( type == DT_ILS ) // Found an ILS server configured on the DS... retrieve the name and port...
|
|
{
|
|
bFoundILS = true;
|
|
|
|
BSTR pName;
|
|
|
|
if( pDirectory->get_DisplayName( &pName ) == S_OK )
|
|
{
|
|
USES_CONVERSION;
|
|
lstrcpy( m_DomainDirectory, OLE2T( pName ) );
|
|
SysFreeString( pName );
|
|
}
|
|
|
|
ITILSConfig * pITILSConfig;
|
|
|
|
hrResult = pDirectory->QueryInterface( IID_ITILSConfig, (void **) &pITILSConfig );
|
|
|
|
if( (hrResult == S_OK) && (pITILSConfig != NULL) )
|
|
{
|
|
long lPort;
|
|
|
|
if( pITILSConfig->get_Port( &lPort ) == S_OK )
|
|
{
|
|
TCHAR pszPort[ 32 ];
|
|
|
|
wsprintf( pszPort, TEXT( ":%d" ), lPort );
|
|
lstrcat( m_DomainDirectory, pszPort );
|
|
}
|
|
|
|
pITILSConfig->Release();
|
|
}
|
|
}
|
|
}
|
|
|
|
pDirectory->Release();
|
|
}
|
|
}
|
|
while( (!bFoundILS) && (hrResult == S_OK) && (pDirectory != NULL) );
|
|
|
|
pEnumDirectory->Release();
|
|
}
|
|
|
|
pRendezvous->Release();
|
|
}
|
|
}
|
|
|
|
return( (m_DomainDirectory[ 0 ] != '\0')? m_DomainDirectory: NULL );
|
|
|
|
} // End of CDirectoryManager::get_DomainDirectory.
|
|
|
|
|
|
// Returns non-empty strings if there is a web dir set by policy
|
|
bool ConfPolicies::GetWebDirInfo(
|
|
LPTSTR szURL, int cchmaxURL,
|
|
LPTSTR szServer, int cchmaxServer,
|
|
LPTSTR szName, int cchmaxName
|
|
)
|
|
{
|
|
// if the string params are messed up, just return false
|
|
ASSERT( (!szURL || ( cchmaxURL > 0 ))
|
|
&& (!szServer || ( cchmaxServer > 0 ))
|
|
&& (!szName || ( cchmaxName > 0 ))
|
|
);
|
|
|
|
bool bSuccess = false;
|
|
|
|
// Try to get the registry value
|
|
RegEntry rePol(POLICIES_KEY, HKEY_CURRENT_USER);
|
|
LPCTSTR szTemp;
|
|
|
|
szTemp = rePol.GetString( REGVAL_POL_INTRANET_WEBDIR_URL );
|
|
if( szTemp[0] )
|
|
{
|
|
if (NULL != szURL)
|
|
{
|
|
lstrcpyn( szURL, szTemp, cchmaxURL );
|
|
}
|
|
|
|
szTemp = rePol.GetString( REGVAL_POL_INTRANET_WEBDIR_SERVER );
|
|
if (szTemp[0])
|
|
{
|
|
if (NULL != szServer)
|
|
{
|
|
lstrcpyn( szServer, szTemp, cchmaxServer );
|
|
}
|
|
|
|
szTemp = rePol.GetString( REGVAL_POL_INTRANET_WEBDIR_NAME );
|
|
if( szTemp[0] )
|
|
{
|
|
if (NULL != szName)
|
|
{
|
|
lstrcpyn( szName, szTemp, cchmaxName );
|
|
}
|
|
|
|
// All three values must be specified for success
|
|
bSuccess = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!bSuccess)
|
|
{
|
|
// Empty the strings
|
|
if (NULL != szURL ) szURL [0] = '\0';
|
|
if (NULL != szServer) szServer[0] = '\0';
|
|
if (NULL != szName ) szName [0] = '\0';
|
|
}
|
|
|
|
return(bSuccess);
|
|
}
|
|
|
|
bool g_bAutoAccept = false;
|
|
|
|
bool ConfPolicies::IsAutoAcceptCallsOptionEnabled(void)
|
|
{
|
|
RegEntry rePol(POLICIES_KEY, HKEY_CURRENT_USER);
|
|
return !rePol.GetNumber( REGVAL_POL_NO_AUTOACCEPTCALLS, DEFAULT_POL_NO_AUTOACCEPTCALLS );
|
|
}
|
|
|
|
bool ConfPolicies::IsAutoAcceptCallsPersisted(void)
|
|
{
|
|
RegEntry rePol(POLICIES_KEY, HKEY_CURRENT_USER);
|
|
return 0 != rePol.GetNumber( REGVAL_POL_PERSIST_AUTOACCEPTCALLS, DEFAULT_POL_PERSIST_AUTOACCEPTCALLS );
|
|
}
|
|
|
|
bool ConfPolicies::IsAutoAcceptCallsEnabled(void)
|
|
{
|
|
bool bRet = false;
|
|
|
|
if( IsAutoAcceptCallsOptionEnabled() )
|
|
{
|
|
bRet = g_bAutoAccept;
|
|
|
|
if (IsAutoAcceptCallsPersisted())
|
|
{
|
|
// AutoAccept calls is _not_ disabled by the policy... we should check the AUTO_ACCEPT regval
|
|
RegEntry reConf(CONFERENCING_KEY, HKEY_CURRENT_USER);
|
|
if(reConf.GetNumber(REGVAL_AUTO_ACCEPT, g_bAutoAccept) )
|
|
{
|
|
bRet = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return bRet;
|
|
}
|
|
|
|
void ConfPolicies::SetAutoAcceptCallsEnabled(bool bAutoAccept)
|
|
{
|
|
g_bAutoAccept = bAutoAccept;
|
|
|
|
RegEntry reConf(CONFERENCING_KEY, HKEY_CURRENT_USER);
|
|
reConf.SetValue(REGVAL_AUTO_ACCEPT, g_bAutoAccept);
|
|
}
|