/* --- PRIVATE FUNCTIONS ---------------------------------------------------- */
static void CallbackGroupMember(
_In_ CSV_HANDLE hOutfile,
_In_ CSV_HANDLE hDenyOutfile,
_Inout_ LPTSTR *tokens
) {
BOOL bResult = FALSE;
LPTSTR pMember = NULL;
LPTSTR next = NULL;
LPTSTR listMember = NULL;
UNREFERENCED_PARAMETER(hDenyOutfile);
if (STR_EMPTY(tokens[LdpListMember]))
return;
listMember = _tcsdup(tokens[LdpListMember]);
pMember = _tcstok_s(listMember, _T(";"), &next);
while (pMember) {
bResult = ControlWriteOutline(hOutfile, pMember, tokens[LdpListDn], CONTROL_MEMBER_KEYWORD);
if (!bResult) {
LOG(Err, _T("Cannot write outline for <%s>"), tokens[LdpListDn]);
}
pMember = _tcstok_s(NULL, _T(";"), &next);
}
free(listMember);
}
extern "C" int WINAPI _tWinMain(HINSTANCE hInstance, HINSTANCE /* hPrevInstance */,
LPTSTR lpCmdLine, int /* nShowCmd */)
{
_Module.Init(ObjectMap, hInstance, IDS_SERVICENAME);
_Module.m_bService = TRUE;
TCHAR szTokens[] = _T("-/");
TCHAR *szContext;
LPTSTR lpszToken = _tcstok_s(lpCmdLine, szTokens, &szContext);
while (lpszToken != NULL)
{
if (_tcsicmp(lpszToken, _T("UnregServer"))==0)
return _Module.UnregisterServer();
if (_tcsicmp(lpszToken, _T("RegServer"))==0)
return _Module.RegisterServer(TRUE);
if (_tcsicmp(lpszToken, _T("Embedding"))==0)
_Module.m_bService = FALSE;
if (_tcsicmp(lpszToken, _T("LocalServer"))==0)
{
_Module.SetupAsLocalServer();
return 0;
}
lpszToken = _tcstok_s(NULL, szTokens, &szContext);
}
_Module.Start();
// When we get here, the service has been stopped
return _Module.m_status.dwWin32ExitCode;
}
void LangListDialog::update()
{
if (!isCreated ())
return;
auto status = getSpellChecker()->getStatus();
ListBox_ResetContent(HLangList);
for (auto &lang : status->languageList) ListBox_AddString(HLangList, lang.aliasName.c_str ());
auto settingsCopy = *getSpellChecker()->getSettings();
wchar_t *multiLangCopy = nullptr;
wchar_t *context = nullptr;
setString (multiLangCopy, settingsCopy.spellerSettings[SpellerType::hunspell].activeMultiLanguage.data ());
int index = 0;
auto token = _tcstok_s(multiLangCopy, _T ("|"), &context);
while (token) {
index = -1;
for (int i = 0; i < static_cast<int> (status->languageList.size ()); ++i) {
if (status->languageList[i].originalName == token) {
index = i;
break;
}
}
if (index != -1)
CheckedListBox_SetCheckState(HLangList, index, BST_CHECKED);
token = _tcstok_s(NULL, _T ("|"), &context);
}
CLEAN_AND_ZERO_ARR (multiLangCopy);
}
BOOL InitInstance(HINSTANCE hInstance, int nCmdShow, LPTSTR lpCmdLine)
{
application_init();
hInst = hInstance; // Store instance handle in our global variable
HWND hWnd = CreateWindow(szWindowClass, szTitle, WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL, NULL, hInstance, NULL);
if (!hWnd)
{
return FALSE;
}
char* argv[4096];
int argc = 0;
TCHAR exename[1024], *next;
int exenameLen = GetModuleFileName(NULL, exename, 1024);
argv[argc++] = tchar_to_utf8(exename);
TCHAR* arg = _tcstok_s(lpCmdLine, _T(" "), &next);
while (arg != NULL) {
argv[argc++] = tchar_to_utf8(arg);
arg = _tcstok_s(NULL, _T(" "), &next);
}
gSkWind = create_sk_window(hWnd, argc, argv);
for (int i = 0; i < argc; ++i) {
free(argv[i]);
}
ShowWindow(hWnd, nCmdShow);
UpdateWindow(hWnd);
return TRUE;
}
int ReadImageFile(const TCHAR* filePath,vector <vector <tstring>>& dst)
{
dst.clear();
TCHAR line[1000];
FILE *file;
_tfopen_s(&file,(TCHAR*)filePath,_T("r"));
// _tfopen_s(&file,(TCHAR*)strPathName.c_str(),_T("r"));
if (file!=NULL){
while(_fgetts(line,1000,file)!=NULL){
if (line[0] == ';') //¦¹¦æ¬°µù¸Ñ
continue;
vector <tstring> vs;
TCHAR seps[] = _T(" \n\t,");
TCHAR *token1 = NULL;
TCHAR *next_token1 = NULL;
token1 = _tcstok_s(line, seps, &next_token1);
bool bHasElement = false;
while ((token1 != NULL))
{
// Get next token:
tstring str = token1;
vs.push_back(str);
token1 = _tcstok_s( NULL, seps, &next_token1);
bHasElement = true;
}
if (bHasElement)
dst.push_back(vs);
}
fclose(file);
}
return 0;
}
//! \bug Problem with Unicode
int ReadCSVFile(const TCHAR* filePath,vector <vector <tstring>>& dst){
dst.clear();
TCHAR line[1000];
FILE *file;
// file= _tfopen((TCHAR*)filePath,_T("r"));
_tfopen_s(&file,(TCHAR*)filePath,_T("r"));
if (file!=NULL){
while(_fgetts(line,1000,file)!=NULL){
vector <tstring> vs;
TCHAR seps[] = _T("\n\t,");
TCHAR *token1 = NULL;
TCHAR *next_token1 = NULL;
token1 = _tcstok_s(line, seps, &next_token1);
while ((token1 != NULL))
{
// Get next token:
tstring str = token1;
vs.push_back(str);
token1 = _tcstok_s( NULL, seps, &next_token1);
}
dst.push_back(vs);
}
fclose(file);
}
return 0;
}
void ProcessParameter(LPTSTR lpCmdLine)
{
const TCHAR* delimiter = _T(" \t\n\r");
TCHAR* context = NULL;
COLORREF dateColor = DATE_COLOR;
COLORREF timeColor = TIME_COLOR;
for (TCHAR* p = _tcstok_s(lpCmdLine, delimiter, &context); p; p = _tcstok_s(NULL, delimiter, &context)) {
if (*p == _T('-')) {
COLORREF* pColor = NULL;
if (lstrcmpi(p, _T("-date")) == 0 || lstrcmpi(p, _T("-d")) == 0) {
pColor = &dateColor;
}
if (lstrcmpi(p, _T("-time")) == 0 || lstrcmpi(p, _T("-t")) == 0) {
pColor = &timeColor;
}
if (pColor) {
TCHAR* sColor = _tcstok_s(NULL, delimiter, &context);
if (sColor) {
int n = lstrlen(sColor);
if (n == 6) {
__int32 rgb = 0;
for (unsigned char i = 0; i < n; i++) {
TCHAR c = sColor[i];
rgb <<= 4;
if (c >= _T('0') && c <= _T('9')) {
rgb += c - _T('0');
}
if (c >= _T('a') && c <= _T('f')) {
rgb += c - _T('a') + 10;
}
if (c >= _T('A') && c <= _T('F')) {
rgb += c - _T('A') + 10;
}
}
*pColor = RGB((rgb >> 16) & 0xff, (rgb >> 8) & 0xff, rgb & 0xff);
}
if (n == 3) {
__int32 rgb = 0;
for (unsigned char i = 0; i < n; i++) {
TCHAR c = sColor[i];
unsigned char delta = 0;
if (c >= _T('0') && c <= _T('9')) {
delta = c - _T('0');
}
if (c >= _T('a') && c <= _T('f')) {
delta = c - _T('a') + 10;
}
if (c >= _T('A') && c <= _T('F')) {
delta = c - _T('A') + 10;
}
rgb <<= 8;
rgb += (delta << 4) + delta;
}
*pColor = RGB((rgb >> 16) & 0xff, (rgb >> 8) & 0xff, rgb & 0xff);
}
}
}
STDMETHODIMP CLDAPQuery::pageQuery(
/* [in] */ LONG connect_id,
/* [in] */ BSTR basedn,
/* [in] */ BSTR scope,
/* [in] */ BSTR filter,
/* [in] */ BSTR attributes,
/* [in] */ ULONG total_results,
/* [retval][out] */ LONG* results_id)
{
m_errorCode = 0L;
const int id = m_connections.FindKey(connect_id);
if(id > -1)
{
ÑConnectInfo * const cinfo = m_connections.GetValueAt(id);
const PLDAP ld = cinfo->ld();
const ULONG no_limit = LDAP_NO_LIMIT;
ULONG ulScope = LDAP_SCOPE_BASE;
CString csScope = scope;
csScope.MakeLower();
if(csScope == _T("subtree"))
ulScope = LDAP_SCOPE_SUBTREE;
else if(csScope == _T("onelevel"))
ulScope = LDAP_SCOPE_ONELEVEL;
else if(csScope == _T("base"))
ulScope = LDAP_SCOPE_BASE;
CString csBaseDN = basedn;
if(csBaseDN.IsEmpty() && (ulScope == LDAP_SCOPE_ONELEVEL || (!cinfo->canFindFromRoot() && ulScope == LDAP_SCOPE_SUBTREE)))
{
csBaseDN = cinfo->defaultNamingContext();
}
CSimpleArray<PTCHAR> attributesArr;
PTCHAR nextAttributes = NULL;
CString csArrs = attributes;
PTCHAR attribute = _tcstok_s(csArrs.GetBuffer(), _T(","), &nextAttributes);
while(attribute != NULL)
{
attributesArr.Add(attribute);
attribute = _tcstok_s(NULL, _T(","), &nextAttributes);
}
csArrs.ReleaseBuffer();
attributesArr.Add(NULL); // NULL-terminated array
PLDAPSearch pPages = ldap_search_init_page(ld, csBaseDN.GetBuffer(), ulScope, CString(filter).GetBuffer(), attributesArr.GetData(), 0, NULL, NULL, no_limit, total_results, NULL);
m_errorCode = LdapGetLastError();
if(pPages)
{
*results_id = cinfo->addResult(pPages);
}
}
return S_OK;
}
int CFastStringArray::AddList(LPTSTR str, LPCTSTR fs)
{
TCHAR* context = NULL;
TCHAR* tok = _tcstok_s(str, fs, &context);
while(tok != NULL){
Add(tok);
tok = _tcstok_s(NULL, fs, &context);
}
return m_count-1;
}
/**
* \brief
*/
void DbConfig::DbPathsFromBuf(TCHAR* buf, const TCHAR* separators)
{
TCHAR* pTmp = NULL;
for (TCHAR* ptr = _tcstok_s(buf, separators, &pTmp); ptr; ptr = _tcstok_s(NULL, separators, &pTmp))
{
CPath db(ptr);
db.AsFolder();
if (db.Exists())
_libDbPaths.push_back(db);
}
}
BOOL StrNextToken(
_In_ LPTSTR str,
_In_ LPTSTR del,
_Inout_ LPTSTR *ctx,
_Out_ LPTSTR *tok
) {
if (*ctx == NULL) {
*tok = _tcstok_s(str, del, ctx);
}
else {
*tok = _tcstok_s(NULL, del, ctx);
}
return (*tok != NULL);
}
/* --- PRIVATE FUNCTIONS ---------------------------------------------------- */
static void CallbackExchRoleEntry(
_In_ CSV_HANDLE hOutfile,
_In_ CSV_HANDLE hDenyOutfile,
_Inout_ LPTSTR *tokens
) {
UNREFERENCED_PARAMETER(hDenyOutfile);
BOOL bResult = FALSE;
LPTSTR roleEntry = NULL;
LPTSTR roleEntryName = NULL;
LPTSTR listMsExchRoleEntries = NULL;
LPTSTR nextEntry = NULL;
LPTSTR nextEntryField = NULL;
LPTSTR domainDN = NULL;
LPTSTR dn = NULL;
DWORD roleEntryIndex = 0;
size_t eTSDNlen = 0;
if (!exchangeTrustedSubsystemDN) {
dn = _tcsdup(tokens[LdpListDn]);
domainDN = _tcsstr(dn, _T("dc="));
eTSDNlen = _tcslen(ETS_PARTIAL_DN) + _tcslen(domainDN) + 1;
exchangeTrustedSubsystemDN = HeapAlloc(GetProcessHeap(),HEAP_ZERO_MEMORY,eTSDNlen * sizeof(TCHAR));
if (!exchangeTrustedSubsystemDN) {
LOG(Err, _T("Cannot allocate DN string"));
}
_tcsncat_s(exchangeTrustedSubsystemDN, eTSDNlen, ETS_PARTIAL_DN, _tcslen(ETS_PARTIAL_DN));
_tcsncat_s(exchangeTrustedSubsystemDN, eTSDNlen, domainDN, _tcslen(domainDN));
}
// Do we have role entries
if (STR_EMPTY(tokens[LdpListMsExchRoleEntries]))
return;
listMsExchRoleEntries = _tcsdup(tokens[LdpListMsExchRoleEntries]);
CharLower(listMsExchRoleEntries);
roleEntry = _tcstok_s(listMsExchRoleEntries, _T(";"), &nextEntry);
while (roleEntry) {
roleEntryName = _tcstok_s(roleEntry, _T(","), &nextEntryField);
roleEntryName = _tcstok_s(NULL, _T(","), &nextEntryField);
if (IsInSetOfStrings(roleEntryName, controlRoleEntryList, CONTROL_ROLE_ENTRY_COUNT, &roleEntryIndex)) {
bResult = ControlWriteOutline(hOutfile, tokens[LdpListDn], exchangeTrustedSubsystemDN, gc_RoleEntryKeyword[roleEntryIndex]);
if (!bResult) {
LOG(Err, _T("Cannot write outline for <%s>"), tokens[LdpListDn]);
}
}
nextEntryField = NULL;
roleEntry = _tcstok_s(NULL, _T(";"), &nextEntry);
}
free(listMsExchRoleEntries);
}
std::vector<CString> Utility::ExplodeStr(LPCTSTR szString, LPCTSTR szSeparators)
{
std::vector<CString> aTokens;
CString copy = szString;
TCHAR *context = 0;
TCHAR *token = _tcstok_s(const_cast<LPTSTR>((LPCTSTR)copy), szSeparators, &context);
while (token != 0)
{
aTokens.push_back(token);
token=_tcstok_s(NULL, szSeparators, &context);
};
return aTokens;
}
int ParseSearchObject(__in LPTSTR lpszSearchObject, __out std::vector<STRING> & vecStrings)
{
if (lpszSearchObject == NULL || lpszSearchObject[0] == _T('\0')) return 0;
if (vecStrings.size() > 0) return 0;
int nCount = 0;
STRING strTemp;
if (_tcschr(lpszSearchObject, _T('*')) == NULL && _tcschr(lpszSearchObject, _T('?')) == NULL)
{
vecStrings.push_back(lpszSearchObject);
nCount++;
}
else
{
TCHAR szSeps1[] = _T("*");
LPTSTR lpszToken1 = NULL;
LPTSTR lpszNextToken1 = NULL;
lpszToken1 = _tcstok_s(lpszSearchObject, szSeps1, &lpszNextToken1);
while (lpszToken1 != NULL)
{
TCHAR szSeps2[] = _T("?");
LPTSTR lpszToken2 = NULL;
LPTSTR lpszNextToken2 = NULL;
lpszToken2 = _tcstok_s(lpszToken1, szSeps2, &lpszNextToken2);
if (lpszToken2 == NULL)
{
vecStrings.push_back(lpszToken1);
nCount++;
}
else
{
while (lpszToken2 != NULL)
{
vecStrings.push_back(lpszToken1);
nCount++;
lpszToken2 = _tcstok_s(NULL, szSeps2, &lpszNextToken2);
}
}
lpszToken1 = _tcstok_s(NULL, szSeps1, &lpszNextToken1);
}
}
return nCount;
}
PINFOCOPYDLL_API int __stdcall pinfocopy(LPCWSTR args)
{
int argc = 1;
_TCHAR* argv[256];
_TCHAR args_t[2048];
_TCHAR* next_token;
_tcscpy_s(args_t, args);
argv[argc] = _tcstok_s(args_t, L" \t\r\n", &next_token);
while(argv[argc] != NULL)
{
argc++;
argv[argc] = _tcstok_s( NULL, L" \t\r\n", &next_token);
}
return pinfocopy(argc, argv);
}
/// Writes a feedback entry to the mechanism.
///
/// @param[in] pszMessage the string to write
void CErrorFeedback::Write (const TCHAR *pszMessage) {
LOGERROR (TEXT ("A major error occurred"));
TCHAR *psz = _tcsdup (pszMessage);
if (psz) {
// TODO: Implement this as writing to a file in a known location perhaps. The caller will already have
// logged suitable messages, so we only need to report at DEBUG level.
TCHAR *pszNext;
TCHAR *pszLine = _tcstok_s (psz, TEXT ("\n"), &pszNext);
while (pszLine) {
LOGWARN (TEXT (">> ") << pszLine);
pszLine = _tcstok_s (NULL, TEXT ("\n"), &pszNext);
}
free (psz);
} else {
LOGFATAL (TEXT ("Out of memory"));
}
}
int DetectFxReadMajorVersion(TCHAR* pszVersion)
{
TCHAR *pszToken = NULL;
int iVersionPartCounter = 0;
int iVersionMajor = 0;
int iVersionMinor = 0;
int iVersionBuild = 0;
int iVersionRevision = 0;
// This registry value should be of the format
// v#.#.#####.##. Try to parse the 4 parts of
// the version here
TCHAR* tok_context;
pszToken = _tcstok_s(pszVersion+1, _T("."), &tok_context);
while (NULL != pszToken)
{
iVersionPartCounter++;
switch (iVersionPartCounter)
{
case 1:
// Convert the major version value to an integer
iVersionMajor = _tstoi(pszToken);
break;
case 2:
// Convert the minor version value to an integer
iVersionMinor = _tstoi(pszToken);
break;
case 3:
// Convert the build number value to an integer
iVersionBuild = _tstoi(pszToken);
break;
case 4:
// Convert the revision number value to an integer
iVersionRevision = _tstoi(pszToken);
break;
default:
break;
}
// Get the next part of the version number
pszToken = _tcstok_s(NULL, _T("."), &tok_context);
}
return iVersionMajor;
}
void AddToMap(TCHAR* pszArg)
{
ENSURE(pszArg != NULL);
TCHAR* psz = _tcsdup(pszArg);
if (psz == NULL)
{
AfxThrowMemoryException();
}
ASSERT(_tcschr(psz, _T(',')) != NULL);
TCHAR* pszPrefixFrom;
TCHAR* pszPrefixTo;
TCHAR* pszAddTo;
DWORD dwAddTo;
CMapInfo* pInfo;
TCHAR* pContext=NULL;
// parse each field out of the argument.
pszPrefixFrom = _tcstok_s(psz, _T(","), &pContext);
pszPrefixTo = _tcstok_s(NULL, _T(","), &pContext);
if (pszPrefixTo == NULL)
goto ParmError;
pszAddTo = _tcstok_s(NULL, _T(","), &pContext);
if (pszAddTo == NULL)
goto ParmError;
// make sure they are valid symbols/values.
if (!IsValidSymbol(pszPrefixFrom) || !IsValidSymbol(pszPrefixTo))
goto ParmError;
if (!IsValidValue(pszAddTo, dwAddTo))
goto ParmError;
// add them to the map.
pInfo = new CMapInfo;
ASSERT(pInfo);
pInfo->pszPrefixFrom = pszPrefixFrom;
pInfo->pszPrefixTo = pszPrefixTo;
pInfo->dwAddTo = dwAddTo;
aMap.Add(pInfo);
return;
ParmError:
UsageErr(_T("parameter \"%s\" not correctly formed."), pszArg);
ASSERT(FALSE);
}
TCHAR* UTBStr::tcstok(TCHAR* strToken, const TCHAR* strDelimit, TCHAR ** context)
{
#if _MSC_VER >= 1400
return _tcstok_s(strToken, strDelimit, context);
#else
UNREFERENCED_PARAMETER(context);
return _tcstok(strToken, strDelimit);
#endif
}
BOOL LPCTSTR2D3DCOLOR( LPCTSTR czSource, int nMaxStringLen, D3DCOLOR& ResultColor )
{
KG_PROCESS_ERROR(czSource);
int ColorElements[4] = {0, 0, 0, 0};
TCHAR LocalSource[128];
int nRet = _tcscpy_s(LocalSource, _countof(LocalSource), czSource);
KG_PROCESS_ERROR(nRet == 0);
TCHAR tczSeps[] = _T(" ,\t\n");
TCHAR* pToken1 = NULL;
TCHAR* pNext_Token = NULL;
pToken1 = _tcstok_s(LocalSource, tczSeps, &pNext_Token);
for(int i = 0; i < 4; i++ )
{
KG_PROCESS_ERROR(NULL != pToken1);///不能全部解释出来也是错误
int nTemp = _ttoi(pToken1);
KG_PROCESS_ERROR(nTemp >= 0 && nTemp <= 255);
ColorElements[i] = nTemp;
pToken1 = _tcstok_s(NULL, tczSeps, &pNext_Token);
}
ResultColor = D3DCOLOR_ARGB(ColorElements[0], ColorElements[1], ColorElements[2], ColorElements[3]);
return TRUE;
Exit0:
return FALSE;
}
// path operations
BOOL goCommand::initializeGoVals(void){
LPCTSTR pathSep = TEXT("\\");
LPTSTR dir = NULL;
LPTSTR start_address = NULL;
LPTSTR pkg = NULL;
dir = (LPTSTR) _tcsdup(this->currentDir);
if (dir == NULL) return FALSE;
start_address = dir;
this->goPath = (LPTSTR) calloc(MAX_PATH, sizeof(TCHAR));
if (this->goPath == NULL) {
free(start_address);
return FALSE;
}
this->goPkg = (LPTSTR) calloc(MAX_PATH, sizeof(TCHAR));
if (this->goPkg == NULL){
free(start_address);
return FALSE;
}
dir = _tcstok_s(dir, pathSep, &pkg);
_tcsncpy(this->goPath, dir, _tcslen(dir)+1);
while(dir != NULL){
if (_tcscmp(dir, TEXT("src")) == 0){
_tcsncpy(this->goPkg, pkg, _tcslen(pkg)+1);
free(start_address);
return TRUE;
}
PathAppend(this->goPath, dir);
dir = _tcstok_s(NULL, pathSep, &pkg);
}
free(start_address);
return FALSE;
}
bool CIVConnection::GetHIVola (LPCTSTR szSymbol, const dte_vec & dtes, hist_ranges_map & ranges)
{
InitRequest();
ASSERT (szSymbol);
CString strURL;
if(-1 == m_opts.m_strURL.Find(_T("http")))
{
strURL = _T("http://");
strURL += m_opts.m_strURL;
}
else
strURL = m_opts.m_strURL;
m_strRequest = strURL + _T("/ivanalyzer.asp?sid=%s&si=1&S=");
m_strRequest += szSymbol;
CString strDates;
for (dte_vec::const_iterator it = dtes.begin() ; it != dtes.end(); it++ )
{
CString strFmt;
strFmt.Format (_T("&D=%d"), *it );
strDates += strFmt;
}
m_strRequest += strDates;
if (! RequestData() )
return false;
ranges.clear();
DATE dtCurrent = (long) (DATE) COleDateTime::GetCurrentTime();
LPTSTR szResult = m_strResult.GetBuffer (0);
LPCTSTR szDelimit = _T("\r");
char* szContext = NULL;
LPTSTR szToken = _tcstok_s (szResult, szDelimit, &szContext);
while (szToken)
{
LPCTSTR szKey = _T("HiVola");
LPCTSTR szStart = _tcsstr_nocase (szToken, szKey);
if (szStart)
{
szStart += _tcslen (szKey);
CHistRangeData hrData;
long nDte = 0;
#ifndef _UNICODE
char chSep;
std::istringstream is;
#else
wchar_t chSep;
std::wistringstream is;
#endif
is.str ( szStart);
is
>> nDte >> chSep
>> hrData.m_dStrike >> chSep
>> hrData.m_dHistVolaHigh >> chSep
>> hrData.m_dHistVolaLow >> chSep
>> hrData.m_bATM;
long dtExp = static_cast<long>(dtCurrent) + nDte;
ranges.insert ( std::make_pair (dtExp, hrData) );
}
szToken = _tcstok_s (NULL, szDelimit, &szContext);
}
m_strResult.ReleaseBuffer();
return true;
}
// Message handler for about box.
LRESULT CALLBACK VirtualDimension::About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
static IPicture * picture;
switch (message)
{
case WM_INITDIALOG:
SetFocus(GetDlgItem(hDlg, IDOK));
picture = PlatformHelper::OpenImage(MAKEINTRESOURCE(IDI_VIRTUALDIMENSION));
TCHAR text[MAX_PATH];
DWORD dwHandle;
DWORD vinfSize;
LPVOID lpVersionInfo;
TCHAR * lpVal;
UINT dwValSize;
TCHAR * context;
GetModuleFileName(NULL, text, MAX_PATH);
vinfSize = GetFileVersionInfoSize(text, &dwHandle);
lpVersionInfo = malloc(vinfSize);
GetFileVersionInfo(text, dwHandle, vinfSize, lpVersionInfo);
VerQueryValue(lpVersionInfo, TEXT("\\StringFileInfo\\040904b0\\ProductName"), (LPVOID*)&lpVal, &dwValSize);
_tcsncpy_s(text, lpVal, dwValSize);
_tcscat_s(text, TEXT(" v"));
VerQueryValue(lpVersionInfo, TEXT("\\StringFileInfo\\040904b0\\ProductVersion"), (LPVOID*)&lpVal, &dwValSize);
lpVal = _tcstok_s(lpVal, TEXT(", \t"), &context);
_tcscat_s(text, lpVal);
_tcscat_s(text, TEXT("."));
lpVal = _tcstok_s(NULL, TEXT(", \t"), &context);
_tcscat_s(text, lpVal);
lpVal = _tcstok_s(NULL, TEXT(", \t"), &context);
if (*lpVal != TEXT('0'))
{
*lpVal += TEXT('a') - TEXT('0');
_tcscat_s(text, lpVal);
}
SetDlgItemText(hDlg, IDC_PRODUCT, text);
VerQueryValue(lpVersionInfo, TEXT("\\StringFileInfo\\040904b0\\LegalCopyright"), (LPVOID*)&lpVal, &dwValSize);
_tcsncpy_s(text, lpVal, dwValSize);
SetDlgItemText(hDlg, IDC_COPYRIGHT, text);
free(lpVersionInfo);
return FALSE;
case WM_COMMAND:
switch(LOWORD(wParam))
{
case IDOK:
case IDCANCEL:
EndDialog(hDlg, LOWORD(wParam));
if (picture)
{
picture->Release();
picture = NULL;
}
return TRUE;
case IDC_HOMEPAGE_LINK:
if (HIWORD(wParam) == STN_CLICKED)
{
ShellExecute(hDlg, TEXT("open"), TEXT("http://virt-dimension.sourceforge.net"),
NULL, NULL, SW_SHOWNORMAL);
}
break;
case IDC_GPL_LINK:
if (HIWORD(wParam) == STN_CLICKED)
{
ShellExecute(hDlg, TEXT("open"), TEXT("LICENSE.html"),
NULL, NULL, SW_SHOWNORMAL);
}
break;
}
break;
case WM_DRAWITEM:
if (picture)
PlatformHelper::CustomDrawIPicture(picture, (LPDRAWITEMSTRUCT)lParam, false);
return TRUE;
}
return FALSE;
}
// CMSOmniProvRowset::Execute
// 1. Parse the SQL query,
// 2. Execute the query, and
// 3. Build the initial rowset
HRESULT CMSOmniProvRowset::Execute(DBPARAMS * pParams, DBROWCOUNT* pcRowsAffected)
{
USES_CONVERSION;
CMSOmniProvRowset* pT = (CMSOmniProvRowset*) this;
CMSOmniProvRowset::ObjectLock cab((CMSOmniProvRowset*) this);
HRESULT hr;
_bstr_t m_bstrFileName;
if ( FAILED(hr=pT->GetDataSource(m_bstrFileName)) )
return hr;
// Check the property value whether read/ updatabiliy property is set or not...
_variant_t varUpd;
GetPropValue(&DBPROPSET_ROWSET,DBPROP_UPDATABILITY, &varUpd);
if ( 0 != varUpd.iVal )
{
// 1. a) Build the file's Schema m_prgColInfo from the '.sxt' file,
// b) Open the file '.txt', and
// c) Fill the m_DBFile.m_Rows structure
// Open in exclusive mode
if (!m_DBFile.Open((LPCTSTR) m_bstrFileName,true))
return DB_E_NOTABLE;
if (!m_DBFile.FillRowArray())
return E_FAIL;
}
else // Open in non-exclusive mode
{
if (!m_DBFile.Open((LPCTSTR) m_bstrFileName,false))
return DB_E_NOTABLE;
if (!m_DBFile.FillRowArray())
return E_FAIL;
}
// Validate Command
// 2. PARSE the SQL Query here (Only SELECT * FROM <Table_Name> is supported)
TCHAR sep[] = " ";
_bstr_t bstrSQL(pT->m_strCommandText);
LPTSTR pchNextToken = NULL;
TCHAR * token = _tcstok_s((TCHAR*) bstrSQL, (TCHAR*) sep, &pchNextToken);
if (!CheckTable((TCHAR*) token))
{
// The Rowset was created using the ICommand::Execute( )...
// Only "SELECT * FROM Table_Name" Queries are supported
if(_tcsicmp(token,TEXT("select")) != 0)
{
ATLTRACE2(atlTraceDBProvider,0,(const TCHAR*) (_bstr_t("Query: '")+ bstrSQL + _bstr_t("' is not a valid Query\n")));
return DB_E_ERRORSINCOMMAND;
}
ATLTRACE2(atlTraceDBProvider,0,(const TCHAR*) (_bstr_t("\tIt is a valid '")+_bstr_t(token) + _bstr_t("' Query\n")));
TCHAR szTblNm[MAX_TABLE_NAME_SIZE];
while (token != NULL)
{
_tcscpy_s(szTblNm, _countof(szTblNm), token);
token= _tcstok_s(NULL,(TCHAR*) sep, &pchNextToken);
}
if (!CheckTable((TCHAR*) szTblNm))
return DB_E_NOTABLE;
}
// Allocate proxy buffers based on the schema information
// Each CRow contains proxy buffer that the data is trasnferred to in the native
// format. This information then needs to be copied out to the file in character format
// on SetData() calls.
CreateColInfo();
AllocateProxyBuffers();
if (pcRowsAffected != NULL)
*pcRowsAffected = m_DBFile.m_Rows.GetCount();
return S_OK;
}
int parseCommandLine() {
int iRet = 0;
int iNumArgs, iNumToBeProcessed;
LPTSTR lpstrCommandArgs=GetCommandLine();
LPTSTR *rgCmdArgs=CommandLineToArgvW(lpstrCommandArgs,&iNumArgs);
// To take care of no command line arguments
if (iNumArgs <= 1 ) {
iRet = -1;
goto Cleanup;
}
// Check if one argument only and that is the /? argument
if (0==_tcsncicmp(rgCmdArgs[1],CAzGlobalOptions::HELPTAG , CAzGlobalOptions::HELPTAG_LEN)) {
DisplayUsage();
iRet = 1;
goto Cleanup;
}
// if more than one argument but not the required 2 arguments
if (iNumArgs < 3 ) {
iRet = -1;
goto Cleanup;
}
CAzGlobalOptions::m_bstrDestStoreName.Attach(CComBSTR(rgCmdArgs[1]).Copy());
CAzGlobalOptions::m_bstrSourceStoreName.Attach(CComBSTR(rgCmdArgs[2]).Copy());
CAzGlobalOptions::setDefaults();
iNumToBeProcessed = iNumArgs-3;
for (int i = 3 ; i < iNumArgs ; i++) {
// Checking for /logfile
if (0==_tcsncicmp(rgCmdArgs[i],CAzGlobalOptions::LOGFILETAG,CAzGlobalOptions::LOGFILETAG_LEN)) {
_TCHAR *strRightPart=_tcschr(rgCmdArgs[i],_TCHAR('='));
if (NULL==strRightPart) {
iRet = -1;
goto Cleanup;
}
CAzLogging::Initialize(CAzLogging::LOG_LOGFILE,&strRightPart[1]);
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i],CAzGlobalOptions::APPNAMETAG,CAzGlobalOptions::APPNAMETAG_LEN)) {
//Checking for /application flag
LPTSTR strTmp;
_TCHAR *strRightPart=_tcschr(rgCmdArgs[i],_TCHAR('='));
if (NULL==strRightPart) {
iRet = -1;
goto Cleanup;
}
CAzGlobalOptions::m_bSpecificApp=true;
_TCHAR *strAppNames =_tcstok_s(&strRightPart[1],_TEXT(","),&strTmp);
while (strAppNames!=NULL) {
CAzGlobalOptions::m_bstrAppNames.push_back(CComBSTR(strAppNames).Copy());
/* While there are tokens in "string" */
/* Get next token: */
strAppNames =_tcstok_s(NULL,_TEXT(","),&strTmp);
}
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::OVERWRITETAG , CAzGlobalOptions::OVERWRITETAG_LEN)) {
//Checking for /overwrite flag
CAzGlobalOptions::m_bOverWrite=true;
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::IGNOREMEMBERSTAG,CAzGlobalOptions::IGNOREMEMBERSTAG_LEN)) {
//Checking for /IGNOREMEMBERS flag
CAzGlobalOptions::m_bIgnoreMembers=true;
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::IGNOREPOLICYADMINSTAG , CAzGlobalOptions::IGNOREPOLICYADMINSTAG_LEN)) {
//Checking for /IGNOREPOLICYADMIN flag
CAzGlobalOptions::m_bIgnorePolicyAdmins=true;
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::VERBOSETAG , CAzGlobalOptions::VERBOSETAG_LEN)) {
CAzGlobalOptions::m_bVerbose=true;
CAzLogging::Initialize(CAzLogging::LOG_TRACE);
iNumToBeProcessed--;
} else if (0==_tcsncicmp(rgCmdArgs[i] , CAzGlobalOptions::HELPTAG , CAzGlobalOptions::HELPTAG_LEN)) {
DisplayUsage();
iNumToBeProcessed--;
iRet = 1;
goto Cleanup;
}
}
// Some additional parameters exist which donot match
// hence these are invalid flags.
if (0 != iNumToBeProcessed)
{
iRet = -1;
goto Cleanup;
}
iRet = 0;
Cleanup:
if (rgCmdArgs)
{
LocalFree(rgCmdArgs);
}
return iRet;
}
/******************************************************************
Function Name: CheckNetfxBuildNumber
Description: Retrieves the .NET Framework build number from
the registry and validates that it is not a pre-release
version number
Inputs: NONE
Results: true if the build number in the registry is greater
than or equal to the passed in version; false otherwise
******************************************************************/
bool CheckNetfxBuildNumber(const TCHAR *pszNetfxRegKeyName, const TCHAR *pszNetfxRegKeyValue, const int iRequestedVersionMajor, const int iRequestedVersionMinor, const int iRequestedVersionBuild, const int iRequestedVersionRevision)
{
TCHAR szRegValue[MAX_PATH];
TCHAR *pszToken = NULL;
TCHAR *pszNextToken = NULL;
int iVersionPartCounter = 0;
int iRegistryVersionMajor = 0;
int iRegistryVersionMinor = 0;
int iRegistryVersionBuild = 0;
int iRegistryVersionRevision = 0;
bool bRegistryRetVal = false;
// Attempt to retrieve the build number registry value
bRegistryRetVal = RegistryGetValue(HKEY_LOCAL_MACHINE, pszNetfxRegKeyName, pszNetfxRegKeyValue, NULL, (LPBYTE)szRegValue, MAX_PATH);
if (bRegistryRetVal)
{
// This registry value should be of the format
// #.#.#####.##. Try to parse the 4 parts of
// the version here
pszToken = _tcstok_s(szRegValue, _T("."), &pszNextToken);
while (NULL != pszToken)
{
iVersionPartCounter++;
switch (iVersionPartCounter)
{
case 1:
// Convert the major version value to an integer
iRegistryVersionMajor = _tstoi(pszToken);
break;
case 2:
// Convert the minor version value to an integer
iRegistryVersionMinor = _tstoi(pszToken);
break;
case 3:
// Convert the build number value to an integer
iRegistryVersionBuild = _tstoi(pszToken);
break;
case 4:
// Convert the revision number value to an integer
iRegistryVersionRevision = _tstoi(pszToken);
break;
default:
break;
}
// Get the next part of the version number
pszToken = _tcstok_s(NULL, _T("."), &pszNextToken);
}
}
// Compare the version number retrieved from the registry with
// the version number of the final release of the .NET Framework
// that we are checking
if (iRegistryVersionMajor > iRequestedVersionMajor)
{
return true;
}
else if (iRegistryVersionMajor == iRequestedVersionMajor)
{
if (iRegistryVersionMinor > iRequestedVersionMinor)
{
return true;
}
else if (iRegistryVersionMinor == iRequestedVersionMinor)
{
if (iRegistryVersionBuild > iRequestedVersionBuild)
{
return true;
}
else if (iRegistryVersionBuild == iRequestedVersionBuild)
{
if (iRegistryVersionRevision >= iRequestedVersionRevision)
{
return true;
}
}
}
}
// If we get here, the version in the registry must be less than the
// version of the final release of the .NET Framework we are checking,
// so return false
return false;
}
/**
* \brief
*/
void DbConfig::FiltersFromBuf(TCHAR* buf, const TCHAR* separators)
{
TCHAR* pTmp = NULL;
for (TCHAR* ptr = _tcstok_s(buf, separators, &pTmp); ptr; ptr = _tcstok_s(NULL, separators, &pTmp))
_pathFilters.push_back(CPath(ptr));
}
bool U2MemAnimation::LoadU2TextAnim(const U2DynString& filename)
{
U2WinFile* file = U2_NEW U2WinFile;
U2ASSERT(file);
if(file->Open(filename, _T("r")))
{
const int LINE_SIZE = 1024;
TCHAR line[LINE_SIZE];
TCHAR* szNextToken;
int groupIdx = 0;
int curveIdx = 0;
int keyIdx = 0;
InterpKeyGroup* pCurrGroup = 0;
InterpKey* pCurrInterpKey = 0;
static D3DXVECTOR4 sVec4 = VECTOR4_ZERO;
while(file->GetS(line,sizeof(line)))
{
TCHAR* szKeyword = _tcstok_s(line, U2_WHITESPACE, &szNextToken);
if(0 == szKeyword)
continue;
else if(0 == _tcscmp(szKeyword, _T("type")))
{
const TCHAR* szType = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
U2ASSERT(szType);
if(0 != _tcscmp(szType,_T("xanim")))
{
file->Close();
U2_DELETE file;
return false;
}
}
else if(0 == _tcscmp(szKeyword, _T("numgroups")))
{
const TCHAR* szNumGroups = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
U2ASSERT(szNumGroups);
int numGroups = atoi(szNumGroups);
if(0 == numGroups)
{
U2ASSERT(false);
file->Close();
U2_DELETE file;
return false;
}
SetNumInterpKeyGroups(numGroups);
}
else if(0 == _tcscmp(szKeyword, _T("numkeys")))
{
const TCHAR* szNumKeys = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
U2ASSERT(szNumKeys);
m_keyArray.Resize(atoi(szNumKeys));
}
else if(0 == _tcscmp(szKeyword, _T("group")))
{
const TCHAR* szNumInterpKeys = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szStartKey = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szNumKeys = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szKeyStride = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szKeyTime = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szFadeInFrames = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szAnimLoopType = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
U2ASSERT(szNumInterpKeys && szStartKey && szNumKeys && szKeyStride
&& szKeyTime && szFadeInFrames && szAnimLoopType);
curveIdx = 0;
pCurrGroup = &GetInterpKeyGroup(groupIdx++);
pCurrGroup->SetNumInterpKeys(atoi(szNumInterpKeys));
pCurrGroup->SetStartKey(atoi(szStartKey));
pCurrGroup->SetNumKeys(atoi(szNumKeys));
pCurrGroup->SetKeyStride(atoi(szKeyStride));
pCurrGroup->SetKeyTime(float(atof(szKeyTime)));
pCurrGroup->SetFadeInFrames(float(atof(szFadeInFrames)));
pCurrGroup->SetLoopType(U2Animation::InterpKeyGroup::StrToLoopType(szAnimLoopType));
}
else if(0 == _tcscmp(szKeyword, _T("curve")))
{
const TCHAR* szInterpType = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szFirstKeyIdx = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szIsAnimated = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szConstX = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szConstY = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szConstZ = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szConstW = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
// Check
U2ASSERT(pCurrGroup);
pCurrInterpKey = &(pCurrGroup->GetInterpKey(curveIdx++));
pCurrInterpKey->SetInterpType(U2Animation::InterpKey::StrToInterpType(szInterpType));
pCurrInterpKey->SetFirstKeyIdx(atoi(szFirstKeyIdx));
pCurrInterpKey->SetAnimated(atoi(szIsAnimated));
sVec4.x = float(atof(szConstX));
sVec4.y = float(atof(szConstY));
sVec4.z = float(atof(szConstZ));
sVec4.w = float(atof(szConstW));
pCurrInterpKey->SetConstValue(sVec4);
}
else if(0 == _tcscmp(szKeyword, _T("key")))
{
const TCHAR* szKeyX = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szKeyY = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szKeyZ = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
const TCHAR* szKeyW = _tcstok_s(0, U2_WHITESPACE, &szNextToken);
sVec4.x = float(atof(szKeyX));
sVec4.y = float(atof(szKeyY));
sVec4.z = float(atof(szKeyZ));
sVec4.w = float(atof(szKeyW));
m_keyArray[keyIdx++]= U2_NEW U2AnimKey(sVec4);
}
else
{
U2ASSERT(false);
file->Close();
U2_DELETE file;
return false;
}
}
file->Close();
U2_DELETE file;
return true;
}
FILE_LOG(logDEBUG) << _T("Open Failed");
return false;
}
BOOL MapLine(CString& strLine, BOOL fHTMLFormat )
{
static TCHAR szWhiteSpace1[] = _T("\t ");
static TCHAR szWhiteSpace2[] = _T("\t\n ");
static TCHAR szDefine[] = _T("#define");
TCHAR* pszCopy = _tcsdup(strLine);
if (pszCopy == NULL)
{
AfxThrowMemoryException();
}
TCHAR* psz;
TCHAR* pszSymbol;
TCHAR* pszValue;
DWORD dwValue;
CString strNewName;
TCHAR* pContext=NULL;
// '//{{NOHELP}}' can be placed on the line and it will not be included
if (_tcsstr(strLine, _T("//{{NOHELP}}")) != NULL)
goto RetFalse;
psz = _tcstok_s(pszCopy, szWhiteSpace1, &pContext);
if (psz == NULL)
goto RetFalse;
if (_tcscmp(psz, szDefine) != 0)
goto RetFalse;
pszSymbol = _tcstok_s(NULL, szWhiteSpace1, &pContext);
if (pszSymbol == NULL)
goto RetFalse;
pszValue = _tcstok_s(NULL, szWhiteSpace2, &pContext);
if (pszValue == NULL)
goto RetFalse;
if (!IsValidSymbol(pszSymbol))
goto RetFalse;
if (!IsValidValue(pszValue, dwValue))
goto RetFalse;
if (!MapNameValue(pszSymbol, strNewName, dwValue))
goto RetFalse;
//BLOCK: format output line
{
CString strPad(_T(' '), 40-strNewName.GetLength());
if (strPad.IsEmpty())
strPad = _T('\t');
if( fHTMLFormat )
strLine = _T("#define ") + strNewName + strPad + StringFromDword(dwValue) + _T("\n");
else
strLine = strNewName + strPad + StringFromDword(dwValue) + _T("\n");
}
ASSERT(pszCopy != NULL);
free(pszCopy);
return TRUE;
RetFalse:
ASSERT(pszCopy != NULL);
free(pszCopy);
return FALSE;
}
STDMETHODIMP CLDAPQuery::connect(
/* [in] */ BSTR username,
/* [in] */ BSTR password,
/* [in] */ BSTR host,
/* [in] */ VARIANT_BOOL usessl,
/* [retval][out] */ LONG *connect_id)
{
m_errorCode = 0L;
const ULONG no_limit = LDAP_NO_LIMIT;
PLDAP ld = NULL;
bool useSSL = (usessl==VARIANT_TRUE)? true : false;
bool canFindFromRoot = true;
CAttributesSchema *attrsSchema = NULL;
ULONG ulPort = useSSL?LDAP_SSL_PORT:LDAP_PORT;
PTCHAR port = NULL;
CString defaultNamingContext;
CString csHost = host;
CString hostname = _tcstok_s(csHost.GetBuffer(), _T(":"), &port);
if(port && _tcslen(port) > 0)
ulPort = _tcstol(port, NULL, 10);
csHost.ReleaseBuffer();
try
{
if (useSSL)
{
if((ld = ldap_sslinit(hostname.GetBuffer(), ulPort, 1))==NULL)
{
m_errorCode = LdapGetLastError();
return S_FALSE;
}
m_errorCode = ldap_set_option(ld, LDAP_OPT_SERVER_CERTIFICATE, &CertRoutine);
if (m_errorCode != LDAP_SUCCESS)
throw _T("error LDAP_OPT_SERVER_CERTIFICATE");
}
else
{
if((ld = ldap_init(hostname.GetBuffer(), ulPort))==NULL)
{
m_errorCode = LdapGetLastError();
return S_FALSE;
}
}
const ULONG version = LDAP_VERSION3;
m_errorCode = ldap_set_option(ld, LDAP_OPT_PROTOCOL_VERSION, (void*)&version);
if (m_errorCode != LDAP_SUCCESS)
throw _T("error LDAP_OPT_PROTOCOL_VERSION");
m_errorCode = ldap_set_option(ld, LDAP_OPT_SIZELIMIT, (void*)&no_limit);
if (m_errorCode != LDAP_SUCCESS)
throw _T("error LDAP_OPT_SIZELIMIT");
ld->ld_sizelimit = no_limit;
m_errorCode = ldap_set_option(ld, LDAP_OPT_TIMELIMIT, (void*)&no_limit);
if (m_errorCode != LDAP_SUCCESS)
throw _T("error LDAP_OPT_TIMELIMIT");
ld->ld_timelimit = no_limit;
m_errorCode = ldap_connect(ld, 0);
if (m_errorCode != LDAP_SUCCESS )
throw _T("error ldap_connect");
m_errorCode = ldap_bind_s(ld, CString(username).GetBuffer(), CString(password).GetBuffer(), LDAP_AUTH_SIMPLE);
if (m_errorCode != LDAP_SUCCESS)
throw _T("error LDAP_AUTH_SIMPLE");
/* Get the RootDSE and BaseDN attribute (add checks on use this code).*/
CSimpleArray<PTCHAR> a;
a.Add(_T("defaultNamingContext"));
a.Add(_T("subschemaSubentry"));
a.Add(NULL);
PLDAPMessage pBaseMsg = NULL;
if(ldap_search_s(ld, _T(""), LDAP_SCOPE_BASE, _T("(objectClass=*)"), a.GetData(), 0, &pBaseMsg) == LDAP_SUCCESS)
{
PLDAPMessage const entry = ldap_first_entry(ld, pBaseMsg);
if(entry)
{
PTCHAR * const pschema = ldap_get_values(ld, entry, _T("subschemaSubentry"));
if(pschema)
{
attrsSchema = new CAttributesSchema(ld, *pschema);
ldap_value_free(pschema);
}
//try to find one item in subtree from root, if found it is Global Catalog search
PLDAPSearch const pPages = ldap_search_init_page(ld, NULL, LDAP_SCOPE_SUBTREE, _T("(objectClass=*)"), NULL, 0, NULL, NULL, no_limit, 1, NULL);
if(pPages)
{
PLDAPMessage pMsg = NULL;
canFindFromRoot = (ldap_get_next_page_s(ld, pPages, NULL, 1, NULL, &pMsg) == LDAP_SUCCESS);
if(pMsg)
ldap_msgfree(pMsg);
ldap_search_abandon_page(ld, pPages);
}
PTCHAR * const pDefaultNamingContext = ldap_get_values(ld, entry, _T("defaultNamingContext"));
if(pDefaultNamingContext)
{
defaultNamingContext = *pDefaultNamingContext;
ldap_value_free(pDefaultNamingContext);
}
}
ldap_msgfree(pBaseMsg);
}
ÑConnectInfo * const cinfo = new ÑConnectInfo(ld, attrsSchema, defaultNamingContext, canFindFromRoot);
*connect_id = ++m_maxConnectionId;
m_connections.Add(*connect_id, cinfo);
}
catch (PTCHAR /*e*/)
{
if (ld)
ldap_unbind_s(ld);
*connect_id = -1;
return S_FALSE;
}
return S_OK;
}
