Spot the Bug

UINT __stdcall CreateUUID()
{
    UUID uuid;
    HKEY hOpenKey = NULL;

    if( UuidCreate( &uuid ) == RPC_S_OK )
    {
        char *oldStr = NULL;
        char *tmpBin = NULL;
        int ret;

        tmpBin = (char *) &uuid;
        oldStr = new char[22];

        ret = base64encode( tmpBin, oldStr, sizeof(UUID),  22);

        // now add bytes
        char* newStr = new char[44];
        for (int i = 0; i < 22; i++)
        {
            newStr[i*2] = oldStr[i];
            newStr[i*2 + 1] = 0;
        }
        
        DWORD dwDisp;


        if( RegCreateKeyEx( HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\My Company\\Client"), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hOpenKey, &dwDisp ) == ERROR_SUCCESS )
        {
            // only update key if it doeson't exist
            if(dwDisp == REG_CREATED_NEW_KEY){
                RegSetValueEx( hOpenKey, L"MyUUID", 0, REG_SZ, (unsigned char *) (newStr), 44 );
                RegCloseKey( hOpenKey );
            }
        }
    }

    return ERROR_SUCCESS;
}

What sort of bug? Is it simply breaking, in which case you might want to try stepping through in the compiler (a good idea anyway), or is it returning an incorrect UUID, or is the registry value not being set?

Just off the top of my head -  maybe I should try your code, but using mine...



I see that the string UuidCreate() returns is longer than 22 characters...

EDIT:

What the, your encoding the raw UUID, instead of turning it into a string... hmm...

I believe that I explained it the last time you asked.  You are sending hand-coded bytes to API's expecting Unicode strings.  Use the ANSI version of the API if you don't feel like messing with Unicode.

evildictaitor wrote:

What sort of bug? Is it simply breaking, in which case you might want to try stepping through in the compiler (a good idea anyway), or is it returning an incorrect UUID, or is the registry value not being set?

JChung2006 wrote:

I believe that I explained it the last time you asked.  You are sending hand-coded bytes to API's expecting Unicode strings.  Use the ANSI version of the API if you don't feel like messing with Unicode.

OK, I'm slowing working your code into mine. But what I've found so far is that your buffers seem to be a little short... that's why I try to avoid using raw buffers...




You can see that the ATL routine requires a buffer of 26 chars.

Now I know that this particular routine does need more chars than strictly necessary (two more, I think), so my guess is that your 22 char buffer is too short...

RichardRudek wrote:

OK, I'm slowing working your code into mine. But what I've found so far is that your buffers seem to be a little short... that's why I try to avoid using raw buffers...




You can see that the ATL routine requires a buffer of 26 chars.

Now I know that this particular routine does need more chars than strictly necessary (two more, I think), so my guess is that your 22 char buffer is too short...

Larsenal wrote:


Wish I could use the ATL routine.

inline int Base64EncodeGetRequiredLength(int nSrcLen, DWORD dwFlags=ATL_BASE64_FLAG_NONE)
{
	__int64 nSrcLen4=static_cast<__int64>(nSrcLen)*4;
	ATLENSURE(nSrcLen4 <= INT_MAX);

	int nRet = static_cast<int>(nSrcLen4/3);

	if ((dwFlags & ATL_BASE64_FLAG_NOPAD) == 0)
		nRet += nSrcLen % 3;

	int nCRLFs = nRet / 76 + 1;
	int nOnLastLine = nRet % 76;

	if (nOnLastLine)
	{
		if (nOnLastLine % 4)
			nRet += 4-(nOnLastLine % 4);
	}

	nCRLFs *= 2;

	if ((dwFlags & ATL_BASE64_FLAG_NOCRLF) == 0)
		nRet += nCRLFs;

	return nRet;
}

RichardRudek wrote:



Larsenal wrote:  Wish I could use the ATL routine.

Why can't you ?

Whoever is making that decision (about ATL) knows something I don't them.

Anyway, I need to work on something else. Here's what I've done so far (having been interrupted by clients and head hunters...)





A snippet of the console output:

  Larsenal's hacks, moderated...
pxBg0Q7VeUCSG+HEEMoKcA==
  and decoded, the UUID's are equal in length, and do compare.

And a code snippet. Hopefully I've got the right bits - I was seriously tempted to rename those vars... :

  // Larsenal's hack...
//    UUID uuid;
  HKEY hOpenKey = NULL;

  if( UuidCreate( &uuid ) == RPC_S_OK )
  {
    char *oldStr = NULL;
    char *tmpBin = NULL;
    int ret;

    tmpBin = (char *) &uuid;
//        ret = base64encode( tmpBin, oldStr, sizeof(UUID),  22);
    int  za, zb, zb2;
    za = sizeof(uuid);
    zb = ATL::Base64EncodeGetRequiredLength( za );  // Cheat... :)
    
    oldStr = new char[zb];
    zb2 = zb;
    if ( ATL::Base64Encode( (BYTE *)tmpBin, za, oldStr, &zb2) )
    {
      //// now add bytes
      //char* newStr = new char[44];
      //for (int i = 0; i < zb2; i++)
      //{
      //    newStr[i*2] = oldStr[i];
      //    newStr[i*2 + 1] = 0;
      //}
      USES_CONVERSION;

      oldStr[zb2] = 0;
      LPWSTR newStr = A2W(oldStr);
      wprintf (L"\n  Larsenal's hacks, moderated...\n%s", newStr);
      
        //
        //DWORD dwDisp;
        //if( RegCreateKeyEx( HKEY_LOCAL_MACHINE, TEXT("SOFTWARE\\My Company\\Client"), 0, NULL, REG_OPTION_NON_VOLATILE, KEY_WRITE, NULL, &hOpenKey, &dwDisp ) == ERROR_SUCCESS )
        //{
        //    // only update key if it doeson't exist
        //    if(dwDisp == REG_CREATED_NEW_KEY){
        //        RegSetValueEx( hOpenKey, L"MyUUID", 0, REG_SZ, (unsigned char *) (newStr), 44 );
        //        RegCloseKey( hOpenKey );
        //    }      
    } // Base64Encode
    
    // Decoding
    za = zb2;
    zb = ATL::Base64DecodeGetRequiredLength( za );  // Cheat.
    
    tmpBin = new char[zb];
    zb2 = zb;
    if (ATL::Base64Decode( oldStr, za, (BYTE *) tmpBin , &zb2) )
    {
      printf("\n  and decoded, the UUID's are %sequal in length, and %s compare.\n",
       (zb2 == sizeof(uuid)) ? "" : "not ",
       (memcmp( &uuid, tmpBin, sizeof(uuid) ) == 0) ? "do" : "do not"
      );
    }
    else
    {
      puts("Base64Decode failed");
    }
    
    delete[] oldStr;  // Important to free char arrays... use bloody objects !
    delete[] tmpBin;  // Important to free char arrays... use bloody objects !
    
  } // UuidCreate

EDIT: added the delete[] oldStr.... read the comment... !

You using C++. Wait some people are masochist and do not think that is a bug.

odujosh wrote:

You using C++. Wait some people are masochist and do not think that is a bug.

Sure, pad the strings to make room for the “==”. But if it’s the same UUID and only failing on some machines, then I would suspect that it’s not being run as an administrator install on Vista or Server2008 machines.
It would help to know the symptoms of the failure. Does the key fail to appear after the machine is rebooted, or is the key in the registry and not being retrieved correctly; does the program crash with an access violation?