monkey.c

<Win2k系统编程>源码.次数为国人自编,内容丰富,还是不错的.

        *hKeyRoot = HKEY_CURRENT_USER;

      hKey = *hKeyRoot;     // hKey is used in RegEnumKey().

      }//end if/else *hKeyRoot

      QueryKey (hDlg, hKey);


      RegCloseKey (hKey);   // Close the key handle.

//      rect.top = 0; rect.left = 5; rect.right = 1200; rect.bottom = 25;
//      hDC = GetDC (hDlg);
//      FillRect (hDC, &rect, GetStockObject(WHITE_BRUSH));
//      TextOut (hDC, 5, 5, RegPath, strlen(RegPath));
//      ReleaseDC (hDlg, hDC);
      SetDlgItemText (hDlg, IDE_TEXTOUT, RegPath);


  }


/************************************************************************\
*
*  FUNCTION: QueryKey();
*
*  PURPOSE:  To display the key's children (subkeys) and the names of
*            the Values associated with it.  This function uses RegEnumKey,
*            RegEnumValue, and RegQueryInfoKey.
*
\************************************************************************/
VOID QueryKey (HWND hDlg, HANDLE hKey)
  {
  CHAR     KeyName[MAX_PATH];
  CHAR     ClassName[MAX_PATH] = ""; // Buffer for class name.
  DWORD    dwcClassLen = MAX_PATH;   // Length of class string.
  DWORD    dwcSubKeys;               // Number of sub keys.
  DWORD    dwcMaxSubKey;             // Longest sub key size.
  DWORD    dwcMaxClass;              // Longest class string.
  DWORD    dwcValues;                // Number of values for this key.
  DWORD    dwcMaxValueName;          // Longest Value name.
  DWORD    dwcMaxValueData;          // Longest Value data.
  DWORD    dwcSecDesc;               // Security descriptor.
  FILETIME ftLastWriteTime;          // Last write time.

  DWORD i;
  DWORD retCode;

  DWORD j;
  DWORD retValue;
  CHAR  ValueName[MAX_VALUE_NAME];
  DWORD dwcValueName = MAX_VALUE_NAME;
  CHAR  Buf[80];
  CHAR  lpBuffer[80];


  // Get Class name, Value count.

  RegQueryInfoKey (hKey,              // Key handle.
                   ClassName,         // Buffer for class name.
                   &dwcClassLen,      // Length of class string.
                   NULL,              // Reserved.
                   &dwcSubKeys,       // Number of sub keys.
                   &dwcMaxSubKey,     // Longest sub key size.
                   &dwcMaxClass,      // Longest class string.
                   &dwcValues,        // Number of values for this key.
                   &dwcMaxValueName,  // Longest Value name.
                   &dwcMaxValueData,  // Longest Value data.
                   &dwcSecDesc,       // Security descriptor.
                   &ftLastWriteTime); // Last write time.

  SetDlgItemText (hDlg, IDE_CLASS, ClassName);
  SetDlgItemInt  (hDlg, IDE_CVALUES, dwcValues, FALSE);

  SendMessage (GetDlgItem (hDlg, IDL_LISTBOX),
               LB_ADDSTRING, 0, (LONG)"..");

                                       // Loop until RegEnumKey fails, get
                                       // the name of each child and enter
                                       // it into the box.

  // Enumerate the Child Keys.

  SetCursor (LoadCursor (NULL, IDC_WAIT));
  for (i=0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++)
    {
    retCode = RegEnumKey (hKey, i,
                          KeyName, MAX_PATH);

    if (retCode == (DWORD)ERROR_SUCCESS)
      SendMessage (GetDlgItem(hDlg, IDL_LISTBOX),
                   LB_ADDSTRING, 0, (LONG)KeyName);
    }
  SetCursor (LoadCursor (NULL, IDC_ARROW));


  // Enumerate the Key Values
        SetCursor (LoadCursor (NULL, IDC_WAIT));

        if (dwcValues)
          for (j = 0, retValue = ERROR_SUCCESS; j < dwcValues; j++)
            {
            dwcValueName = MAX_VALUE_NAME;
            ValueName[0] = '\0';
            retValue = RegEnumValue (hKey, j, ValueName,
                                     &dwcValueName,
                                     NULL,
                                     NULL,               //&dwType,
                                     NULL,               //&bData,
                                     NULL);              //&bcData);
            if (retValue != (DWORD)ERROR_SUCCESS &&
                retValue != ERROR_INSUFFICIENT_BUFFER)
              {
              LoadString(hInst, IDS_REGERR, lpBuffer, sizeof(lpBuffer));
              wsprintf (Buf, lpBuffer, __LINE__, j, retValue, dwcValueName);
              LoadString(hInst, IDS_DEBUG, lpBuffer, sizeof(lpBuffer));
              MessageBox (hDlg, Buf, lpBuffer, MB_OK);
              }

            Buf[0] = '\0';
            if (!strlen(ValueName)) {
              LoadString(hInst, IDS_NONAME, lpBuffer, sizeof(lpBuffer));
              strcpy (ValueName, lpBuffer);
            }
            wsprintf (Buf, "%d) %s ", j, ValueName);
            SendMessage (GetDlgItem (hDlg, IDL_LISTBOX2),
                           LB_ADDSTRING, 0, (LONG)Buf);

            }// end for(;;)

        SetCursor (LoadCursor (NULL, IDC_ARROW));

  }



/************************************************************************\
*
*  FUNCTION: DisplayKeyData();
*
*  PURPOSE:  To display the keys values and value types to the Value edit
*            field.  This function is called when the right hand listbox
*            is double clicked.  The functionality is much like that found
*            in the function PrintTree, please see it for more details.
*
\************************************************************************/


VOID DisplayKeyData (HWND hDlg, CHAR *RegPath, HANDLE hKeyRoot)
  {
  HKEY   hKey;
  DWORD  dwLBIndex;
  CHAR   Buf[LINE_LEN];
  CHAR   ValueName[MAX_VALUE_NAME];
  DWORD  cbValueName = MAX_VALUE_NAME;
  DWORD  dwType;
  DWORD  retCode;
  CHAR   lpBuffer[128];
  CHAR   lpBuffer2[128];

  CHAR   ClassName[MAX_PATH];
  DWORD  dwcClassLen = MAX_PATH;
  DWORD  dwcSubKeys;
  DWORD  dwcMaxSubKey;
  DWORD  dwcMaxClass;
  DWORD  dwcValues;
  DWORD  dwcMaxValueName;
  DWORD  dwcMaxValueData;
  DWORD  dwcSecDesc;
  FILETIME  ftLastWriteTime;


  BYTE   *bData;
  DWORD  cbData;

  CHAR   *outBuf;
  DWORD  i;
  DWORD  cStrLen;

  CHAR   *BinaryStrBuf;
  CHAR   ByteBuf[4];

  CHAR   *ptr;

  // OPEN THE KEY.

                                // LBIndex should == value index.
  dwLBIndex = SendMessage (GetDlgItem (hDlg, IDL_LISTBOX2),
                           LB_GETCURSEL, 0, 0);

  retCode = RegOpenKeyEx (hKeyRoot,    // Key handle at root level.
                          RegPath,     // Path name of child key.
                          0,           // Reserved.
                          KEY_EXECUTE, // Requesting read access.
                          &hKey);      // Address of key to be returned.

  if (retCode)
    {
    LoadString(hInst, IDS_REGOPENERR, lpBuffer, sizeof(lpBuffer));
    wsprintf (Buf, lpBuffer, retCode);
    MessageBox (hDlg, Buf, "DisplayKeyData()", MB_OK);
    return;
    }

// ADD A QUERY AND ALLOCATE A BUFFER FOR BDATA.

  retCode =
  RegQueryInfoKey (hKey,              // Key handle.
                   ClassName,         // Buffer for class name.
                   &dwcClassLen,      // Length of class string.
                   NULL,              // Reserved.
                   &dwcSubKeys,       // Number of sub keys.
                   &dwcMaxSubKey,     // Longest sub key size.
                   &dwcMaxClass,      // Longest class string.
                   &dwcValues,        // Number of values for this key.
                   &dwcMaxValueName,  // Longest Value name.
                   &dwcMaxValueData,  // Longest Value data.
                   &dwcSecDesc,       // Security descriptor.
                   &ftLastWriteTime); // Last write time.

   if (retCode)
    {
    LoadString(hInst, IDS_REGQUERYERR, lpBuffer, sizeof(lpBuffer));
    wsprintf (Buf, lpBuffer, retCode, __LINE__);
    MessageBox (hDlg, Buf, "", MB_OK);
    }

   bData = HeapAlloc (hHeap, 0, dwcMaxValueData);
   cbData = dwcMaxValueData;


  // ENUMERATE THE KEY.

  retCode = RegEnumValue (hKey,        // Key handle returned from RegOpenKeyEx.
                          dwLBIndex,   // Value index, taken from listbox.
                          ValueName,   // Name of value.
                          &cbValueName,// Size of value name.
                          NULL,        // Reserved, dword = NULL.
                          &dwType,     // Type of data.
                          bData,       // Data buffer.
                          &cbData);    // Size of data buffer.

  if (retCode != ERROR_SUCCESS)
    {

    if (dwType < REG_FULL_RESOURCE_DESCRIPTOR)
      {
      LoadString(hInst, IDS_REGENUMERR, lpBuffer, sizeof(lpBuffer));
      wsprintf (Buf, lpBuffer, retCode, cbData, __LINE__);
      MessageBox (hDlg, Buf, "", MB_OK);
      }
    }


  switch (dwType)
    {
//    REG_NONE                    ( 0 )   // No value type
//    REG_SZ                      ( 1 )   // Unicode nul terminated string
//    REG_EXPAND_SZ               ( 2 )   // Unicode nul terminated string
                                            // (with environment variable references)
//    REG_BINARY                  ( 3 )   // Free form binary
//    REG_DWORD                   ( 4 )   // 32-bit number
//    REG_DWORD_LITTLE_ENDIAN     ( 4 )   // 32-bit number (same as REG_DWORD)
//    REG_DWORD_BIG_ENDIAN        ( 5 )   // 32-bit number
//    REG_LINK                    ( 6 )   // Symbolic Link (unicode)
//    REG_MULTI_SZ                ( 7 )   // Multiple Unicode strings
//    REG_RESOURCE_LIST           ( 8 )   // Resource list in the resource map
//    REG_FULL_RESOURCE_DESCRIPTOR ( 9 )  // Resource list in the hardware description

    case REG_NONE:
      LoadString(hInst, IDS_REGNONE, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);
      break;

    case REG_SZ:
      LoadString(hInst, IDS_REGSZ, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);

      outBuf = HeapAlloc (hHeap, 0, cbData + 2);
      *outBuf = '\0';

      strcat (outBuf, "\"");
      strcat (outBuf, bData);
      strcat (outBuf, "\"");

      SetDlgItemText (hDlg, IDE_VALUE2, outBuf);
      HeapFree (hHeap, 0, outBuf);
      break;

    case REG_EXPAND_SZ:
      LoadString(hInst, IDS_REGEXPSZ, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);
      outBuf = HeapAlloc (hHeap, 0, cbData + 2);
      *outBuf = '\0';

      strcat (outBuf, "\"");
      strcat (outBuf, bData);
      strcat (outBuf, "\"");

      SetDlgItemText (hDlg, IDE_VALUE2, outBuf);
      HeapFree (hHeap, 0, outBuf);
      break;

    case REG_BINARY:
      LoadString(hInst, IDS_REGBIN, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);
      SetCursor (LoadCursor (NULL, IDC_WAIT));

      BinaryStrBuf = HeapAlloc (hHeap, 0, (3 * cbData) + 1);
      if (BinaryStrBuf)
        {
        *BinaryStrBuf = '\0';
        *ByteBuf = '\0';
        for (i = 0; i < cbData; i++)
          {
          sprintf (ByteBuf, "%02x ", (BYTE)bData[i]);
          strcat (BinaryStrBuf, ByteBuf);
          }
        SetDlgItemText (hDlg, IDE_VALUE2, BinaryStrBuf);
        }
      else
        {
        LoadString(hInst, IDS_MALLOCERR, lpBuffer, sizeof(lpBuffer));
        LoadString(hInst, IDS_DBGTITLE, lpBuffer2, sizeof(lpBuffer2));
        MessageBox (hDlg, lpBuffer, lpBuffer2, MB_OK);
        }
      SetDlgItemText (hDlg, IDL_LISTBOX2, BinaryStrBuf);
      HeapFree (hHeap, 0, BinaryStrBuf);
      SetCursor (LoadCursor (NULL, IDC_ARROW));

      break;

    case REG_DWORD:
      LoadString(hInst, IDS_REGDWORD, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);
      SetDlgItemInt (hDlg, IDE_VALUE2, *(UINT *)bData, FALSE);
      break;

    case REG_DWORD_BIG_ENDIAN:
      LoadString(hInst, IDS_REGBIGEND, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);
      SetDlgItemInt (hDlg, IDE_VALUE2, *(UINT *)bData, TRUE);
      break;

    case REG_LINK:
      LoadString(hInst, IDS_REGLINK, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);
      SetDlgItemText (hDlg, IDE_VALUE2, bData);
      break;

    case REG_MULTI_SZ:
      LoadString(hInst, IDS_REGMULTI, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);
      SetCursor (LoadCursor (NULL, IDC_WAIT));
                                       // Count the NULLs in the buffer to
                                       // find out how many strings there are.

      for (i=0, cStrLen=4; i < cbData; i++)
        if (!bData[i])
          cStrLen+=4;                  // Add room for two quotes and two
                                       // spaced per string.

      outBuf = HeapAlloc (hHeap, 0, cbData + cStrLen);

      ptr = bData;                     // Set ptr to beginning of buffer.
      *outBuf = '\0';                  // Initialize output string.

      strcat (outBuf, "{ ");           // Do first bracket.
      while (*ptr)                     // Loop til you hit 2 NULLs in a row.
        {
         strcat (outBuf, "\"");        // Put quotes around each string.
         strcat (outBuf, ptr);
         strcat (outBuf, "\"  ");
         ptr += strlen(ptr)+1;
        }
      strcat (outBuf, "}");            // Add final bracket.
      SetDlgItemText (hDlg, IDE_VALUE2, outBuf);

      SetCursor (LoadCursor (NULL, IDC_ARROW));
      HeapFree (hHeap, 0, outBuf);                 // free output string.
      break;


    case REG_RESOURCE_LIST:            // CM_RESOURCE_LIST is complex.  Print it
                                       // as a free formed binary data for now.

      LoadString(hInst, IDS_REGRESLST, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);

      BinaryStrBuf = HeapAlloc (hHeap, 0, (3 * cbData) + 1);
      if (BinaryStrBuf)
        {
        *BinaryStrBuf = '\0';
        *ByteBuf = '\0';
        for (i = 0; i < cbData; i++)
          {
          sprintf (ByteBuf, "%02x ", (BYTE)bData[i]);
          strcat (BinaryStrBuf, ByteBuf);
          }
        SetDlgItemText (hDlg, IDE_VALUE2, BinaryStrBuf);
        }
      else
        {
        LoadString(hInst, IDS_MALLOCERR, lpBuffer, sizeof(lpBuffer));
        LoadString(hInst, IDS_DBGTITLE, lpBuffer2, sizeof(lpBuffer2));
        MessageBox (hDlg, lpBuffer, lpBuffer2, MB_OK);
        }
      SetDlgItemText (hDlg, IDL_LISTBOX2, BinaryStrBuf);
      HeapFree (hHeap, 0, BinaryStrBuf);

      break;

    case REG_FULL_RESOURCE_DESCRIPTOR:
      LoadString(hInst, IDS_REGFULLDESC, lpBuffer, sizeof(lpBuffer));
      SetDlgItemText (hDlg, IDE_VALUE1, lpBuffer);
      break;



    default:
      LoadString(hInst, IDS_REGUNDEFINE, lpBuffer, sizeof(lpBuffer));
      wsprintf (Buf, lpBuffer, dwType);
      SetDlgItemText (hDlg, IDE_VALUE1, Buf);
      break;

    } // end switch


    HeapFree (hHeap, 0, bData);
  }