C / C++ / MFC

I'm going with it, it produces the results I need.

27-Oct-11 9:14

I need to get a registry value which is REG_MULTI_SZ, so I can get each name and go on to the next registry key and get the version number.

In regedit the values are
MSSQLServer
MicrosoftSMBiz
SQLExpress

The raw data that I pull out is. eg is verbatim
'M' '0' 'S' '0' 'S' '0' 'Q' '0' 'L' '0'
The end of each word is '0' '0' '0' and the very end is '\0\0\0\0'

My goal is to make a char array that can run through strtok_s,
So I wrote this, but overall in the end, I want to terminate the new array with '\0', so I can remeasure the length of characters. I wanted to return a value that is not the full 1024.

char rgValue[1024];
char szInstance[1024];

Get the Registry value
// do work

ndx = 0;
                szRgVal = sizeof(rgValue);

                for(int i=0; i < szRgVal; i++) {
                    if (!rgValue[i] == '\0\0\0') {
                        szInstance[ndx++] = rgValue[i];
                    }
                    else {
                        szInstance[ndx++] = ';';
                    }

                    i++;
                }

                maxStr = strlen(szInstance);
                szInstance[maxStr-0] = (char)'\0';

I really wanted to terminate the char array at the end of the chars so I can get the strlen of 36 or so, but strlen is always 1033 1024.

MSSQLServer; MICROSOFTSMLBIZ; SQLEXPRESS;\0TTTTTTTTTT

Here is my question.
Is my for loop bad coding practice? Or should I try to add the '\0' in the for loop at the end of the chars I want, and then remeasure with strlen?

jkirkerx27-Oct-11 10:33

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

27-Oct-11 10:33

So I modified it a bit, and I got what I wanted, oh. I passed the value back the calling function as a char, and extracted the names out of the char array, and called the version registry function, so far no side effects.

ndx = 0;
                doubleZero = false;
                szRgVal = sizeof(rgValue);

                for(int i=0; i < szRgVal; i++) {
                    if (!rgValue[i] == '\0\0') {
                        szInstance[ndx++] = rgValue[i];
                        doubleZero = false;
                    }
                    else {
                        if (doubleZero == false) {
                            szInstance[ndx++] = ';';
                            doubleZero = true;
                        }
                        else {
                            szInstance[ndx++] = '\0';
                            break;
                        }
                    }
                    i++;
                }

                maxStr = strlen(szInstance);
                szInstance[maxStr-0] = (char)'\0';
                printf(" SQL Server Instance: %s %i\n", szInstance, strlen(szInstance) );

Adorjáni Alpár27-Oct-11 10:50

Adorjáni Alpár

27-Oct-11 10:50

if statement is very wrong
'\0\0\0' quote will be used as a single '\0' character
and the ! sign not the equation modifies to != , it will be a bool negation of rgValue[i] character and gives true when rgValue[i] is '\0' and false otherwise and this bool value will be compared to the '\0\0\0' value what is false as bool type

I recommend this:

C++

ndx = 0;
szRgVal = sizeof(rgValue);
 
for(int i=0; i < szRgVal; i++) {
  if (rgValue[i] == '\0' && rgValue[i+1] == '\0' && rgValue[i+2] == '\0' && rgValue[i+3] == '\0') {
    szInstance[ndx++] = '\0'; //very end
    break;
  }
  else {
    if (rgValue[i] == '\0' && rgValue[i+1] == '\0' && rgValue[i+2] == '\0') {
      szInstance[ndx++] = ';'; //word end
      i++;
    }
  else
    szInstance[ndx++] = rgValue[i];
  i++;
}

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

jkirkerx27-Oct-11 11:48

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

27-Oct-11 11:48

I thought about that, how can I compare 2 bytes in a row with i that represents 1 byte. Didn't think about i+1 and i+2 and so forth.

I had the right idea at least!

After I wrote the first version I posted, I started wondering if I was crazy, in the way I handled the returned value.

I wasn't expecting a code rewrite that is paste and go!, but I thank you for taking the time to do so. Nice to know I was on the right track, and I actually learned something this week.

Sincerely

jkirkerx

jkirkerx27-Oct-11 13:28

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

27-Oct-11 13:28

This part doesn't work, it never registers, I ran the code through debug and stepped through it, but it's hard to follow the 3 zero sequence.

Day is over, get back to it tomorrow, no worries I will figure it out.

else {
   if (rgValue[i] == '\0' && rgValue[i+1] == '\0' && rgValue[i+2] == '\0') {
     szInstance[ndx++] = ';'; //word end
     i++;
   }

Peter_in_278027-Oct-11 13:39

Peter_in_2780

27-Oct-11 13:39

One word: UNICODE.

Peter

Software rusts. Simon Stephenson, ca 1994.

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

jkirkerx28-Oct-11 6:24

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

28-Oct-11 6:24

I thought about that last night,

Should I just left it as unicode, so it don't run into the lang issue down the road when I make the french version.

Richard MacCutchan27-Oct-11 21:59

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

27-Oct-11 21:59

Stop, stop!
You have totally misinterpreted the data you are looking at. This is a Unicode (aka UTF16) string where each character is 16 bits wide rather than the 8 used by ASCII. You must either convert the string to ASCII in order to process it correctly (via WideCharToMultiByte()[^]), or make your program Unicode aware. I would also be interested to know how you are extracting this value from the registry as I was under the impression that strings are automatically converted for non-Unicode programs.

Unrequited desire is character building. OriginalGriff
I'm sitting here giving you a standing ovation - Len Goodman

jkirkerx28-Oct-11 6:41

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

28-Oct-11 6:41

This is code I copied from the net and modified in the my first week of c++. In the other uses of the code, I used a CString, but this time i needed to modify the results. It didn't dawn on me till I was bowling last night that the result is Unicode, and I should leave it as Unicode, so I can support French and Spanish. I think SQL Server Instances can be named UniCode, thus that's why the registry values are stored that way.

Alright, lesson learned.

char* CA_Registry::_get_SQLServer_InstalledInstances( void )
{
	HKEY keyHandle;
	char rgValue[1024];
	char szInstance[1024];
	CString regPath = L"SOFTWARE\\Microsoft\\Microsoft SQL Server\\";
	CString regReq = L"InstalledInstances";
	DWORD size1 = sizeof(rgValue);
	DWORD Type;
	DWORD dwType = 0;
	DWORD regStatus = REG_MULTI_SZ;

	int ndx=0;
	int szRgVal=0;
	int maxStr=0;
	bool doubleZero;
			
	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0, KEY_QUERY_VALUE, &keyHandle) == ERROR_SUCCESS) {
		dwType = REG_MULTI_SZ;
		regStatus = RegQueryValueEx( keyHandle, regReq, NULL, &Type, (LPBYTE)rgValue, &size1);
			
		switch ( regStatus ) {
			case ERROR_SUCCESS:
				ndx = 0;
				doubleZero = false;
				szRgVal = sizeof(rgValue);
	
				for(int i=0; i < szRgVal; i++) {
                    if (!rgValue[i] == '\0\0') {
                        szInstance[ndx++] = rgValue[i];
                        doubleZero = false;
                    }
                    else {
                        if (doubleZero == false) {
                            szInstance[ndx++] = ';';
                            doubleZero = true;
                        }
                        else {
                            szInstance[ndx++] = '\0';
                            break;
                        }
                    }
                    i++;
				}
	
				maxStr = strlen(szInstance);	
				szInstance[maxStr-0] = (char)'\0';
				printf(" SQL Server Instance: %s %i\n", szInstance, strlen(szInstance) );				
								
				RegCloseKey(keyHandle);
				cout << "key was read successfully\n";
				break;

			case ERROR_MORE_DATA:
				cout << "Buffer too small\n";
				break;			

			default:			
				cout << "Count not read key\n";
		}
	}
	else {
		cout << "Can not open key";
		cin.ignore();
	}
	
	int strSize = sizeof(szInstance);	
	char *szReturnValue = new char[strSize];	
	for(int i = 0; i < strSize; i++) {
		szReturnValue[i]=szInstance[i];		
	}	
	maxStr=strlen(szReturnValue);	
	szReturnValue[maxStr-0]=(char)'\0';

	return szReturnValue;

	delete [] szReturnValue;
}

Richard MacCutchan28-Oct-11 6:57

Re: Sanity Check on Registry Value REG_MULTI_SZ - format value

28-Oct-11 6:57

You are making a dangerous mistake in this code, in that you are mixing ANSI and Unicode, but without fully understanding it. You should change all your char declarations to WCHAR or switch the project setting, Character Set in General properties, from Unicode to Multi-byte.

Unrequited desire is character building. OriginalGriff
I'm sitting here giving you a standing ovation - Len Goodman

jkirkerx28-Oct-11 7:17

I rewrote the my function for WCHAR

28-Oct-11 7:17

That's the mistake from yesterday I posted in full.

Today I will fix the 2 registry programs, I was thinking wchar_t, but I'll go with WCHAR.

The following registry function , is ran after the one I posted above, so you can get an idea of what I'm doing. I wrote the char stuff by myself, with no help, hope it passes. I started changing the code to wchar so I know the code doesn't work, it's just foresight.

I run the first program, return the values and seperate the names, and then loop through the names with the program below to get the versions

wchar_t* CA_Registry::_get_SQLServer_Version( const wchar_t *szSQLInstance )
{
	HKEY keyHandle;
	
	char rgValue [1024];
	char szVersion[1024];

	// Declare the Prefix and Suffix of the Reg Key
	char szRegPath[125];
	char *szRegPath_Prefix = "SOFTWARE\\Microsoft\\Microsoft SQL Server\\";
	char *szRegPath_Suffix = "\\MSSQLServer\\CurrentVersion\\";

	// Calculate the String Lengths
	int iRegPath_Prefix = strlen(szRegPath_Prefix);
	//int iRegPath_Instance = strlen(szSQLInstance);
	int iRegPath_Suffix = strlen(szRegPath_Suffix);
	
	//Build the Char Arrays
	strncpy_s(szRegPath, _countof(szRegPath), szRegPath_Prefix, iRegPath_Prefix);
	//strncat_s(szRegPath, _countof(szRegPath), szSQLInstance, iRegPath_Instance);
	strncat_s(szRegPath, _countof(szRegPath), szRegPath_Suffix, iRegPath_Suffix);
	
	// Convert the Char Arrays to Wide String
	int buffSize = (int)strlen(szRegPath) + 1;
	LPWSTR lpRegPath = new wchar_t[buffSize];
	MultiByteToWideChar(CP_ACP, 0, szRegPath, buffSize, lpRegPath, buffSize);
	
	LPWSTR lpRegReq = L"CurrentVersion";
		
	DWORD size1 = sizeof(rgValue);
	DWORD Type;
	DWORD dwType = 0;
	DWORD regStatus = REG_SZ;

	int ndx=0;
	int szRgVal;
	int maxStr;	
			
	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, lpRegPath, 0, KEY_QUERY_VALUE, &keyHandle) == ERROR_SUCCESS) {
		
		dwType = REG_SZ;
		regStatus = RegQueryValueEx( keyHandle, lpRegReq, NULL, &Type, (LPBYTE)rgValue,&size1);
			
		switch ( regStatus ) {
			case ERROR_SUCCESS:
				ndx=0;
				szRgVal=sizeof(rgValue);
	
				for(int i=0;i<szRgVal;i++) {
					szVersion[ndx++]=rgValue[i];
					i++;
				}
	
				maxStr=strlen(szVersion);	
				szVersion[maxStr-0]=(char)'\0';
				printf(" Binary path: %s %i\n", szVersion, strlen(szVersion) );				
								
				RegCloseKey(keyHandle);
				cout << "key was read successfully\n";
				break;

			case ERROR_MORE_DATA:
				cout << "Buffer too small\n";
				break;			

			default:			
				cout << "Count not read key\n";
		}
	}
	else {
		cout << "Can not open key";
		cin.ignore();
	}

	// Free the Memory
	delete [] lpRegPath;

	int strLength = strlen(szVersion);
	wchar_t *szReturnValue = new wchar_t[strLength];
	for (int i = 0; i < strLength; i++) {
		szReturnValue[i] = szVersion[i];
	}
	szReturnValue[ strLength ] = '\0';	
	return szReturnValue;

	delete [] szReturnValue;	
}

jkirkerx28-Oct-11 8:22

28-Oct-11 8:22

I rewrote the function for WCHAR. It works, I get the result that I wanted, and it's Unicode I believe. I'm pretty sure I got it right, but I need an expert to evaluate it. I'm not sure if the extra wchar array copy is needed at the bottom to pass the value back to the calling function. Plus I'm back to the Original question, but in hindsight, all it does is replaces the \0 with a ;, and re terminates the array.

WCHAR* CA_Registry::_get_SQLServer_InstalledInstances( void )
{
	HKEY keyHandle;
	WCHAR rgValue[1024];
	WCHAR szInstance[1024];
	CString regPath = L"SOFTWARE\\Microsoft\\Microsoft SQL Server\\";
	CString regReq = L"InstalledInstances";
	DWORD size1 = sizeof(rgValue);
	DWORD Type;
	DWORD dwType = 0;
	DWORD regStatus = REG_MULTI_SZ;

	int ndx;;
	size_t szRgVal;
	int maxStr;
	bool doubleZero;

	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0, KEY_QUERY_VALUE, &keyHandle) == ERROR_SUCCESS) {
		dwType = REG_MULTI_SZ;
		regStatus = RegQueryValueEx( keyHandle, regReq, NULL, &Type, (LPBYTE)rgValue, &size1);
			
		switch ( regStatus ) {
			case ERROR_SUCCESS:								
				
				ndx = 0;
                doubleZero = false;
                szRgVal = sizeof(rgValue);
 
                for(int i=0; i < szRgVal; i++) {
                    if (!rgValue[i] == L'\0') {
                        szInstance[ndx++] = rgValue[i];
                        doubleZero = false;
                    }
                    else {
                        if (doubleZero == false) {
                            szInstance[ndx++] = L';';
                            doubleZero = true;
                        }
                        else {
                            szInstance[ndx++] = L'\0\0';
                            break;
                        }
                    }                    
				}

				maxStr = wcslen(szInstance);
                szInstance[maxStr-0] = (char)'\0';
                printf(" SQL Server Instance: %s %i\n", szInstance, wcslen(szInstance) );				
				
				RegCloseKey(keyHandle);
				cout << "key was read successfully\n";
				break;

			case ERROR_MORE_DATA:
				cout << "Buffer too small\n";
				break;			

			default:			
				cout << "Count not read key\n";
		}
	}
	else {
		cout << "Can not open key";
		cin.ignore();
	}
	
	int strSize = sizeof(szInstance);	
	WCHAR *szReturnValue = new wchar_t[strSize];	
	for(int i = 0; i < strSize; i++) {
		szReturnValue[i]=szInstance[i];		
	}	
	strSize=wcslen(szReturnValue);	
	szReturnValue[strSize-0]=(WCHAR)L'\0';

	return szReturnValue;

	delete [] szReturnValue;
}

Richard MacCutchan28-Oct-11 23:13

28-Oct-11 23:13

You've pretty much nailed it, but I have done some tidying up and fixed a couple of minor issues in the code as follows:

C++

WCHAR* CA_Registry::_get_SQLServer_InstalledInstances( void )
{
    HKEY keyHandle;
    WCHAR rgValue[1024];
//  WCHAR szInstance[1024]; // not needed
    // no point in using CString for constant strings
    WCHAR* regPath = L"SOFTWARE\\Microsoft\\Microsoft SQL Server\\";
    WCHAR* regReq = L"InstalledInstances";
    DWORD size1 = sizeof(rgValue);
    // Type; removed as no longer used
    // no need to initialise dwType to zero here
    DWORD dwType;
    // no need to initialise regStatus to REG_MULTI_SZ here
    DWORD regStatus;
 
    int ndx;
    WCHAR *szReturnValue = NULL;
/* variables not needed
    size_t szRgVal;
    int maxStr;
    bool doubleZero;
*/ 
    if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0, KEY_QUERY_VALUE, &keyHandle) == ERROR_SUCCESS) {
    // no need to initialise dwType to REG_MULTI_SZ here
        regStatus = RegQueryValueEx( keyHandle, regReq, NULL, &dwType, (LPBYTE)rgValue, &size1);
			
        RegCloseKey(keyHandle);	// we're done with the registry so close the key here
        switch ( regStatus ) {
        case ERROR_SUCCESS:								
/*
 * rewrote this part to use standard (Unicode) functions
            ndx = 0;
            doubleZero = false;
            szRgVal = sizeof(rgValue);
 
            for(int i=0; i < szRgVal; i++) {
                if (!rgValue[i] == L'\0') {
                    szInstance[ndx++] = rgValue[i];
                    doubleZero = false;
                }
                else {
                    if (doubleZero == false) {
                        szInstance[ndx++] = L';';
                        doubleZero = true;
                    }
                    else {
                        szInstance[ndx++] = L'\0\0';
                        break;
                    }
                }                    
            }
 */
            // scan the strings, replacing single nulls by semi-colons
            {
                WCHAR* pszString = rgValue;
                while (*pszString)
                {
                    ndx = wcslen(pszString);
                    // add string length so we point at trailing null character
                    pszString += ndx;
                    if (pszString[1] != L'\0')
                    *pszString++ = L';';    // add semi-colon if not the last string
                }
            }
            /* removed this redundant code
            maxStr = wcslen(szInstance);
            szInstance[maxStr-0] = (char)'\0';
            */
            ndx = wcslen(rgValue);	// we need this value below
            // this also needs to be wprintf, as rgValue is Unicode
            wprintf(L" SQL Server Instance: %s %i\n", rgValue, ndx);				
            // following statement is redundant, we already have the printf
            // cout << "key was read successfully\n";

            // copy to new buffer here
            szReturnValue = new wchar_t[ndx + 1]; // +1 for trailing null character
            wcscpy_s(szReturnValue, ndx + 1, rgValue);
            break;
 
        case ERROR_MORE_DATA:
            cout << "Buffer too small\n";
            // your challenge is to fix the code to handle this be allocating a larger buffer
            break;			
 
        default:			
            cout << "Could not read key\n";
        }
    }
    else {
        cout << "Can not open key";
        cin.ignore();
    }
/* moved this functionality to within success case above
    int strSize = sizeof(szInstance);	
    WCHAR *szReturnValue = new wchar_t[strSize];	
        for(int i = 0; i < strSize; i++) {
        szReturnValue[i]=szInstance[i];		    
    }	
    strSize=wcslen(szReturnValue);	
    szReturnValue[strSize-0]=(WCHAR)L'\0';
 */
    return szReturnValue;  // set above
    // this delete statement will never be reached! Also the calling function needs to delete the buffer when finished with it 
//  delete [] szReturnValue;
}

I hope my comments make sense but please let me know if they don't. I have built and tested this code but I do not have the exact content of the registry value so it may need some minor tweaking.

Unrequited desire is character building. OriginalGriff
I'm sitting here giving you a standing ovation - Len Goodman

jkirkerx29-Oct-11 7:39

29-Oct-11 7:39

I had to read it a couple of times before it soaked in, those are huge refinements, but I get it, way more optimized, and it teaches me that alot of the stuff was not needed. Let me make the mods, and I will alter the other registry function I have as well. I didn't know I had to wprintf, I thought it was just for printing to the screen in console.

Thanks

jkirkerx29-Oct-11 8:20

29-Oct-11 8:20

Works like a charm, I had to move the pszString above the switch because the compiler complained. I changed the function by hand, and only copied the ERROR_Success because it was alot to type. So I have to delete somthing in the calling function, not sure what yet.

WCHAR* CA_Registry::_get_SQLServer_InstalledInstances( void )
{
	HKEY keyHandle;
	WCHAR rgValue[1024];
	WCHAR *regPath = L"SOFTWARE\\Microsoft\\Microsoft SQL Server\\";
	WCHAR *regReq = L"InstalledInstances";
	DWORD size1 = sizeof(rgValue);
	DWORD dwType;
	DWORD regStatus;

	int ndx;
	WCHAR* pszString = rgValue;
	WCHAR *szReturnValue = NULL;
	
	if(RegOpenKeyEx(HKEY_LOCAL_MACHINE, regPath, 0, KEY_QUERY_VALUE, &keyHandle) == ERROR_SUCCESS) {
		regStatus = RegQueryValueEx( keyHandle, regReq, NULL, &dwType, (LPBYTE)rgValue, &size1);
		RegCloseKey(keyHandle);	

		switch ( regStatus ) {
			case ERROR_SUCCESS:
				// scan the strings, replacing single nulls by semi-colons
				{
					while (*pszString)
					{
						ndx = wcslen(pszString);
						// add string length so we point at trailing null character
						pszString += ndx;
						if (pszString[1] != L'\0')
						*pszString++ = L';';    // add semi-colon if not the last string
					}
				}
            
				ndx = wcslen(rgValue);	// we need this value below
				wprintf(L" SQL Server Instance: %s %i\n", rgValue, ndx);				
            
				// copy to new buffer here
				szReturnValue = new wchar_t[ndx + 1]; // +1 for trailing null character
				wcscpy_s(szReturnValue, ndx + 1, rgValue);            

				break;

			case ERROR_MORE_DATA:
				cout << "Buffer too small\n";
				break;			

			default:			
				cout << "Count not read key\n";
		}
	}
	else {
		cout << "Can not open key";
		cin.ignore();
	}

	return szReturnValue;	
}

This is the calling function just for reference, I wrote it from scratch, no help, lot cleaner than the registry functions I wrote. It's a rough draft, needs more detail, but in the end, after searching by wire, then search the local machine registry, if nothing is found, I will ask if they want to download the X86 or X64 version, and install it using an automated script that I write on the fly. It's starting to shape up now.

BOOL CA_SQLServer_Scan::_scan_Enumerate_Registry( HWND txtProgress, HWND lblServers, HWND pbProgress )
{
	CA_Registry caReg;
	BOOL bResult = FALSE;
	BOOL bInstance = FALSE;
	int instanceLength;
	WCHAR *szComputerName = NULL;
	WCHAR *szInstanceNames = NULL;
	WCHAR *szCurrentVersion = NULL;
	WCHAR szServerInstance[125];

	// Get the SQL Server instance names
	szComputerName = caReg._get_ComputerName();
	szInstanceNames = caReg._get_SQLServer_InstalledInstances();
	instanceLength = wcslen(szInstanceNames);
			
	if (instanceLength > 0) {

		WCHAR *szInstanceName = NULL;
		WCHAR *token1, *nextToken;
		WCHAR seps[] = L";";
		WCHAR vSeps[] = L".";
		token1 = wcstok_s(szInstanceNames, seps, &nextToken);
		do {
			if (token1 == NULL) { 
				break;
			}
			else {
				szInstanceName = token1;
				szCurrentVersion = caReg._get_SQLServer_Version(szInstanceName);
				
				// Parse the version Numbers
				int szVerValue = wcslen(szCurrentVersion);
				if ( szVerValue > 1 ) {
					WCHAR *szVerMajor = NULL, *szVerMinor = NULL, *szVerBuild = NULL;
					WCHAR *vToken1, *vToken2, *vToken3, *vNextToken;
					int iVerMajor=0, iVerMinor=0, iVerBuild=0;
					
					vToken1 = wcstok_s(szCurrentVersion, vSeps, &vNextToken);
					if (!vToken1 == NULL) {
						szVerMajor = vToken1;
						iVerMajor = _wtoi(szVerMajor);
					}
					
					vToken2 = wcstok_s(NULL, vSeps, &vNextToken);
					if (!vToken2 == NULL) {
						szVerMinor = vToken2;
						iVerMinor = _wtoi(szVerMinor);
					}

					vToken3 = wcstok_s(NULL, vSeps, &vNextToken);
					if (!vToken3 == NULL) {
						szVerBuild = vToken3;
						iVerBuild = _wtoi(szVerBuild);
					}

					WCHAR pbMessage[80];
					wcsncpy_s(pbMessage, _countof(pbMessage), L"Registered: ", wcslen(L"Registered: "));
					//wcsncat_s(pbMessage, _countof(pbMessage), L"LOCAL", wcslen(L"LOCAL"));
					wcsncat_s(pbMessage, _countof(pbMessage), L"\\", wcslen(L"\\"));
					wcsncat_s(pbMessage, _countof(pbMessage), szInstanceName, wcslen(szInstanceName));					
					SetWindowText(txtProgress, pbMessage);
					Sleep(500);
					
					// Analyse the Version Numbers
					switch (iVerMajor) 
					{
					case 11:
						bInstance = TRUE;
						break;
					case 10:
						bInstance = TRUE;
						break;
					case 9:
						bInstance = TRUE;
						break;
					default:
						bInstance = FALSE;
						break;
					}

					if (bInstance) {
						int iComputerName = wcslen(szComputerName);
						int iInstanceName = wcslen(szInstanceName);						
						
						// Build the Computer\\Instance
						wcsncpy_s(szServerInstance, _countof(szServerInstance), szComputerName, iComputerName);
						wcsncat_s(szServerInstance, _countof(szServerInstance), L"\\", wcslen(L"\\"));
						wcsncat_s(szServerInstance, _countof(szServerInstance), szInstanceName, iInstanceName);
						
						// Trim the wChar Array
						iInstanceName=wcslen(szServerInstance);	
						szServerInstance[iInstanceName-0]=(WCHAR)L'\0';

						// Get the Collection Count
						int iCollectionCount;
						iCollectionCount = sqlSrvCollection.Count();

						if (iCollectionCount > 0) {
							// Check for Duplicate
							WCHAR *szComparision = NULL;
							
							for (int i=0; i<iCollectionCount; i++) {
								szComparision = sqlSrvCollection[i];
								if (wcscmp(szServerInstance, szComparision) != 0) {
									int iCollection = sqlSrvCollection.Add();
									sqlSrvCollection[iCollection] = szServerInstance;
								}								
							}							
						}
						else {
							// Add the Server Instance
							int iCollection = sqlSrvCollection.Add();
							sqlSrvCollection[iCollection] = szServerInstance;
						}
					}
				}

				// Get the next token to cycle through
				token1 = wcstok_s(NULL, seps, &nextToken);

			}
		} while (TRUE);
	}
	
	return bResult;
}

Richard MacCutchan29-Oct-11 22:21