![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to monkey.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / registry|
Return to monkey.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / registry |
1.1 ! root 1: /*************************************************************************\ ! 2: * ! 3: * PROGRAM: Monkey: the Registry Monkey Utility. ! 4: * PURPOSE: To demonstrate Registry API. ! 5: * COMMENTS: ! 6: * ! 7: \*************************************************************************/ ! 8: ! 9: ! 10: #include <windows.h> ! 11: #include <string.h> ! 12: #include <stdlib.h> ! 13: #include <stdio.h> ! 14: #include "monkey.h" ! 15: ! 16: ! 17: HANDLE hInst; ! 18: HWND hDlg; ! 19: ! 20: HANDLE hHeap; ! 21: ! 22: ! 23: /*************************************************************************\ ! 24: * ! 25: * FUNCTION: WinMain(HANDLE, HANDLE, LPSTR, int) ! 26: * ! 27: * PURPOSE: Creates the dialogbox. ! 28: * ! 29: * COMMENTS: ! 30: * ! 31: \*************************************************************************/ ! 32: ! 33: int APIENTRY WinMain (HINSTANCE hInstance, ! 34: HINSTANCE hPrevInstance, ! 35: LPSTR lpCmdLine, ! 36: int nCmdShow) ! 37: ! 38: ! 39: { ! 40: DWORD retCode; ! 41: ! 42: UNREFERENCED_PARAMETER( nCmdShow ); ! 43: UNREFERENCED_PARAMETER( lpCmdLine ); ! 44: UNREFERENCED_PARAMETER( hPrevInstance ); ! 45: ! 46: hInst = hInstance; ! 47: hHeap = HeapCreate (HEAP_SERIALIZE, 0, 0); ! 48: ! 49: retCode = DialogBox ((HANDLE)hInst, (LPCSTR)"MonkeyDlg", ! 50: NULL, (DLGPROC)MonkeyDlgProc); ! 51: ! 52: HeapDestroy (hHeap); ! 53: return (retCode); ! 54: ! 55: } ! 56: ! 57: /************************************************************************\ ! 58: * ! 59: * FUNCTION: MonkeyDlgProc(); ! 60: * ! 61: * PURPOSE: Handle the Monkey dialog box messages. ! 62: * ! 63: * MESSAGES: ! 64: * ! 65: * WM_INITDIALOG - Posts WM_GETFIRSTKEY message. ! 66: * ! 67: * WM_GETFIRSTKEY - Puts the first 4 pre-defined keys in the listbox. ! 68: * ! 69: * IDL_LISTBOX - Trapped when an item in the left hand listbox ! 70: * has been double clicked. It posts a IDB_NEXT message. ! 71: * ! 72: * IDL_LISTBOX2 - Trapped when an item in the right hand listbox has ! 73: * been double clicked. It basically calls DisplayKeyData, ! 74: * which fills the Value edit fields with the data from ! 75: * the current key's specified value information. ! 76: * ! 77: * IDB_PRINT - Basically calls PrintTree() which does a recursive ! 78: * print of the Registry from the current key to the ! 79: * end of it's branches. ! 80: * ! 81: * IDB_BACK - Sets the dialog box with the information from the ! 82: * previously selected key (one closer to the root of ! 83: * the registry, the parent of the current key). ! 84: * ! 85: * IDB_NEXT - Sets the dialog box with the information on the ! 86: * selected key child. ! 87: * ! 88: * IDR_FULL - Sets a global variable used to determine if the ! 89: * user wants to print full Registry information ! 90: * or only information from keys that have value ! 91: * associated with it. Variable is set to TRUE. ! 92: * ! 93: * IDR_TRIMMED - Same as above, only the variable is set to FALSE. ! 94: * ! 95: \************************************************************************/ ! 96: ! 97: int APIENTRY MonkeyDlgProc (HWND hDlg, WORD wMsg, LONG wParam, LONG lParam) ! 98: { ! 99: ULONG KeyClassLength = 256; ! 100: ULONG KeyNameLength = 256; ! 101: DWORD indexLB; ! 102: CHAR *putNullAt; ! 103: ! 104: static CHAR RegPath[MAX_PATH] = ""; ! 105: static CHAR NameLBSelect[256] = ""; ! 106: static HKEY hKeyRoot; ! 107: static DWORD RegLevel; ! 108: static BOOL FullBranches = TRUE; ! 109: ! 110: static HANDLE hFile = INVALID_HANDLE_VALUE; ! 111: static HANDLE hBootIni; ! 112: ! 113: UNREFERENCED_PARAMETER( lParam ); ! 114: ! 115: switch (wMsg) ! 116: { ! 117: case WM_INITDIALOG: ! 118: // Post a message to get the first 4 pre-defined keys, and set ! 119: // Full Branches to be the print default. ! 120: PostMessage (hDlg, WM_GETFIRSTKEY, 0, 0); ! 121: CheckDlgButton (hDlg, IDR_FULL, TRUE); ! 122: return (0); ! 123: ! 124: case WM_GETFIRSTKEY: ! 125: // Initialize by putting the first 4 predefined keys of the ! 126: // registry in the list box. ! 127: ! 128: SendMessage (GetDlgItem(hDlg, IDL_LISTBOX), ! 129: LB_ADDSTRING, 0, (LONG)"HKEY_LOCAL_MACHINE"); ! 130: ! 131: SendMessage (GetDlgItem(hDlg, IDL_LISTBOX), ! 132: LB_ADDSTRING, 0, (LONG)"HKEY_CURRENT_USER"); ! 133: ! 134: SendMessage (GetDlgItem(hDlg, IDL_LISTBOX), ! 135: LB_ADDSTRING, 0, (LONG)"HKEY_USERS"); ! 136: ! 137: SendMessage (GetDlgItem(hDlg, IDL_LISTBOX), ! 138: LB_ADDSTRING, 0, (LONG)"HKEY_CLASSES_ROOT"); ! 139: ! 140: hKeyRoot = 0; // Initialize hKeyRoot. ! 141: return (0); ! 142: ! 143: case WM_SYSCOMMAND: ! 144: if (wParam == SC_CLOSE) ! 145: { ! 146: EndDialog (hDlg, TRUE); ! 147: if (hFile != INVALID_HANDLE_VALUE) ! 148: CloseHandle (hFile); ! 149: return (TRUE); ! 150: } ! 151: break; ! 152: ! 153: case WM_COMMAND: ! 154: ! 155: switch (LOWORD(wParam)) ! 156: { ! 157: case IDR_FULL: ! 158: // If Full Branches pressed, set global var to TRUE. ! 159: FullBranches = TRUE; ! 160: return (0); ! 161: ! 162: case IDR_TRIMMED: ! 163: // If Trimmed Branches pressed, set global var to FALSE. ! 164: FullBranches = FALSE; ! 165: return (0); ! 166: ! 167: case IDL_LISTBOX: ! 168: // If double click in left hand listbox, clear Value ! 169: // edit fields, and execute Next functionality. ! 170: if ( HIWORD (wParam) == LBN_DBLCLK) ! 171: { ! 172: SetDlgItemText (hDlg, IDE_VALUE1, ""); ! 173: SetDlgItemText (hDlg, IDE_VALUE2, ""); ! 174: PostMessage (hDlg, WM_COMMAND, IDB_NEXT, 0); ! 175: } ! 176: return (0); ! 177: ! 178: case IDL_LISTBOX2: ! 179: // If double click right hand listbox, clear Value edit ! 180: // fields, then display the key's data. ! 181: if ( HIWORD (wParam) == LBN_DBLCLK) ! 182: { ! 183: SetDlgItemText (hDlg, IDE_VALUE1, ""); ! 184: SetDlgItemText (hDlg, IDE_VALUE2, ""); ! 185: DisplayKeyData (hDlg, RegPath, hKeyRoot); ! 186: } ! 187: return (0); ! 188: ! 189: case IDB_PRINT: ! 190: ! 191: MessageBox (NULL, "Sorry, due to last minute changes in the system, this feature was removed. It may be replaced in a future version.", ! 192: "Last Minute Note.", MB_OK); ! 193: return (0); ! 194: ! 195: case IDB_NEXT: ! 196: // Get the index of the cursor selection ! 197: // in the list box. ! 198: indexLB = SendMessage (GetDlgItem (hDlg, IDL_LISTBOX), ! 199: LB_GETCURSEL, 0, 0); ! 200: ! 201: // If nothing is selected, flag user and return, otherwise ! 202: // process the selected key. ! 203: // LB_ERR indicates nothing selected. ! 204: if (indexLB == LB_ERR) ! 205: { ! 206: MessageBox (hDlg, "Please select an item from the list box", ! 207: "Registry Monkey Utility", MB_OK); ! 208: return (0); ! 209: } ! 210: ! 211: // If listbox item 0 is pressed, user wants to move ! 212: // back up. Execute the Back functionality. ! 213: if (indexLB == 0 && hKeyRoot) ! 214: { ! 215: PostMessage (hDlg, WM_COMMAND, IDB_BACK, 0); ! 216: return (0); ! 217: } ! 218: ! 219: ! 220: // Get text from selection in LB. ! 221: SendMessage (GetDlgItem (hDlg, IDL_LISTBOX), ! 222: LB_GETTEXT, indexLB, (LPARAM)NameLBSelect); ! 223: ! 224: // Put name of chosen item in Name field. ! 225: SetDlgItemText (hDlg, IDE_NAME, NameLBSelect); ! 226: ! 227: // Then clear ListBox entries. ! 228: SendMessage (GetDlgItem (hDlg, IDL_LISTBOX), ! 229: LB_RESETCONTENT, 0, 0); ! 230: SendMessage (GetDlgItem (hDlg, IDL_LISTBOX2), ! 231: LB_RESETCONTENT, 0, 0); ! 232: ! 233: EnumerateLevel (hDlg, NameLBSelect, RegPath, &hKeyRoot); ! 234: ! 235: return (0); ! 236: ! 237: ! 238: ! 239: case IDB_BACK: ! 240: ! 241: // For this case (hRootKey = 0)you're at the top level already. ! 242: // Tell the user, then return ! 243: if (!hKeyRoot) ! 244: { ! 245: MessageBox (hDlg, "Top Level: You can not backup any further.", ! 246: "Registry Monkey Utility", MB_OK); ! 247: return (0); ! 248: } ! 249: ! 250: //For all remaining cases, clear the listboxes. ! 251: SendMessage (GetDlgItem (hDlg, IDL_LISTBOX), ! 252: LB_RESETCONTENT, 0, 0); ! 253: SendMessage (GetDlgItem (hDlg, IDL_LISTBOX2), ! 254: LB_RESETCONTENT, 0, 0); ! 255: ! 256: ! 257: ! 258: // If hRootKey has a value, but the pathname is blank, ! 259: // then you must be 1 level deep, reset to level 0 by ! 260: // posting WM_GETFIRSTKEY. ! 261: if (strcmp (RegPath, "") == 0) ! 262: { ! 263: SetDlgItemText (hDlg, IDE_NAME, ""); ! 264: PostMessage (hDlg, WM_GETFIRSTKEY, 0, 0); ! 265: return (0); ! 266: } ! 267: ! 268: ! 269: // Two cases left. One in which the path has only one ! 270: // key name in it, and no back slash character (meaning ! 271: // strrchr() will return NULL); and one the other case ! 272: // where there are more than one key name in the path ( ! 273: // and at least one back slash for strrchr(). If this ! 274: // is the first case, we want to fakeout EnumerateLevel ! 275: // into thinking we just picked one of the pre-defined keys, ! 276: // and then re-enumerate it's child keys. ! 277: if ((putNullAt = strrchr (RegPath, '\\')) == NULL) ! 278: { ! 279: RegPath[0] = '\0'; ! 280: ! 281: switch ((DWORD)hKeyRoot) ! 282: { ! 283: case (DWORD)HKEY_LOCAL_MACHINE: ! 284: strcpy (NameLBSelect, "HKEY_LOCAL_MACHINE"); ! 285: break; ! 286: ! 287: case (DWORD)HKEY_USERS: ! 288: strcpy (NameLBSelect, "HKEY_USERS"); ! 289: break; ! 290: ! 291: case (DWORD)HKEY_CURRENT_USER: ! 292: strcpy (NameLBSelect, "HKEY_CURRENT_USER"); ! 293: break; ! 294: ! 295: case (DWORD)HKEY_CLASSES_ROOT: ! 296: strcpy (NameLBSelect, "HKEY_CLASSES_ROOT"); ! 297: break; ! 298: } ! 299: SetDlgItemText (hDlg, IDE_NAME, NameLBSelect); ! 300: hKeyRoot = 0; ! 301: EnumerateLevel (hDlg, NameLBSelect, RegPath, &hKeyRoot); ! 302: } ! 303: else ! 304: { ! 305: // In the final case, we can just trim the last key ! 306: // name off the path, and re-enumerate the level. ! 307: *putNullAt = '\0'; ! 308: putNullAt = strrchr (RegPath, '\\'); ! 309: ! 310: if (putNullAt) ! 311: { ! 312: strcpy (NameLBSelect, putNullAt+1); ! 313: *putNullAt = '\0'; ! 314: } ! 315: else ! 316: { ! 317: strcpy (NameLBSelect, RegPath); ! 318: *RegPath = '\0'; ! 319: } ! 320: SetDlgItemText (hDlg, IDE_NAME, NameLBSelect); ! 321: EnumerateLevel (hDlg, NameLBSelect, RegPath, &hKeyRoot); ! 322: } ! 323: return (0); ! 324: ! 325: default: ! 326: return (0); ! 327: ! 328: } ! 329: ! 330: } ! 331: return (FALSE); ! 332: ! 333: } ! 334: ! 335: ! 336: ! 337: ! 338: /************************************************************************\ ! 339: * ! 340: * FUNCTION: EnumerateLevel(); ! 341: * ! 342: * PURPOSE: To get a valid key handle (either to determine if the one sent ! 343: * to the function was one of the pre-defined, or to open a key ! 344: * specified by the path), and to pass that key handle along ! 345: * to QueryKey(). ! 346: * ! 347: * To enumerate the children of a key, you must have ! 348: * an open handle to it. The four top keys of the ! 349: * Registry are predefined and open for use: ! 350: * HKEY_LOCAL_MACHINE, HKEY_USERS, HKEY_CURRENT_USER, ! 351: * and HKEY_CLASSES_ROOT. These 4 can be used for ! 352: * RegEnumKey as is; but to RegEnumKey on any of the ! 353: * children of these you must first have an open key ! 354: * handle to the child. ! 355: * ! 356: * If hKeyRoot != 0, assume you are lower than the ! 357: * first level of the Registry and the user is trying ! 358: * to enumerate one of the children. First calculate ! 359: * the name of the child, and then use RegOpenKey to ! 360: * get an open handle. ! 361: * ! 362: * If hKeyRoot == 0, assume you are at the top level ! 363: * of the Registry, and set the hKey to be enumerated ! 364: * to be one of the 4 predefined values, the specific ! 365: * one indicated by the ListBox selection. ! 366: * ! 367: \************************************************************************/ ! 368: VOID EnumerateLevel (HWND hDlg, LPTSTR NameLBSelect, ! 369: LPTSTR RegPath, HANDLE *hKeyRoot) ! 370: { ! 371: ! 372: HANDLE hKey; ! 373: HDC hDC; ! 374: DWORD retCode; ! 375: CHAR Buf[80]; ! 376: RECT rect; ! 377: ! 378: ! 379: if (*hKeyRoot) ! 380: { ! 381: // If RegPath is not NULL, then ! 382: // you have to add a backslash to the ! 383: // path name before appending the next ! 384: // level child name. ! 385: if (strcmp (RegPath, "") != 0) ! 386: strcat (RegPath, "\\"); ! 387: ! 388: // Add the next level child name. ! 389: strcat (RegPath, NameLBSelect); ! 390: ! 391: // Use RegOpenKeyEx() with the new ! 392: // Registry path to get an open handle ! 393: // to the child key you want to ! 394: // enumerate. ! 395: retCode = RegOpenKeyEx (*hKeyRoot, RegPath, ! 396: 0, ! 397: KEY_ENUMERATE_SUB_KEYS | ! 398: KEY_EXECUTE | ! 399: KEY_QUERY_VALUE, ! 400: &hKey); ! 401: ! 402: if (retCode != ERROR_SUCCESS) ! 403: { ! 404: if (retCode == ERROR_ACCESS_DENIED) ! 405: wsprintf (Buf, "Error: unable to open key. Probably due to security reasons."); ! 406: else ! 407: wsprintf (Buf, "Error: Unable to open key, RegOpenKey = %d, Line = %d", ! 408: retCode, __LINE__); ! 409: ! 410: MessageBox (hDlg, Buf, "", MB_OK); ! 411: PostMessage (hDlg, WM_COMMAND, IDB_BACK, 0); ! 412: return; ! 413: } ! 414: ! 415: } ! 416: else ! 417: { ! 418: // Set the *hKeyRoot handle based ! 419: // on the text taken from the ListBox. ! 420: ! 421: if (strcmp (NameLBSelect, "HKEY_CLASSES_ROOT") == 0) ! 422: *hKeyRoot = HKEY_CLASSES_ROOT; ! 423: ! 424: if (strcmp (NameLBSelect, "HKEY_USERS") == 0) ! 425: *hKeyRoot = HKEY_USERS; ! 426: ! 427: if (strcmp (NameLBSelect, "HKEY_LOCAL_MACHINE") == 0) ! 428: *hKeyRoot = HKEY_LOCAL_MACHINE; ! 429: ! 430: if (strcmp (NameLBSelect, "HKEY_CURRENT_USER") == 0) ! 431: *hKeyRoot = HKEY_CURRENT_USER; ! 432: ! 433: hKey = *hKeyRoot; // hKey is used in RegEnumKey(). ! 434: ! 435: }//end if/else *hKeyRoot ! 436: ! 437: QueryKey (hDlg, hKey); ! 438: ! 439: ! 440: RegCloseKey (hKey); // Close the key handle. ! 441: ! 442: rect.top = 0; rect.left = 5; rect.right = 1200; rect.bottom = 25; ! 443: hDC = GetDC (hDlg); ! 444: FillRect (hDC, &rect, GetStockObject(WHITE_BRUSH)); ! 445: TextOut (hDC, 5, 5, RegPath, strlen(RegPath)); ! 446: ReleaseDC (hDlg, hDC); ! 447: ! 448: ! 449: ! 450: } ! 451: ! 452: ! 453: /************************************************************************\ ! 454: * ! 455: * FUNCTION: QueryKey(); ! 456: * ! 457: * PURPOSE: To display the key's children (subkeys) and the names of ! 458: * the Values associated with it. This function uses RegEnumKey, ! 459: * RegEnumValue, and RegQueryInfoKey. ! 460: * ! 461: \************************************************************************/ ! 462: VOID QueryKey (HWND hDlg, HANDLE hKey) ! 463: { ! 464: CHAR KeyName[MAX_PATH]; ! 465: CHAR ClassName[MAX_PATH] = ""; // Buffer for class name. ! 466: DWORD dwcClassLen = MAX_PATH; // Length of class string. ! 467: DWORD dwcSubKeys; // Number of sub keys. ! 468: DWORD dwcMaxSubKey; // Longest sub key size. ! 469: DWORD dwcMaxClass; // Longest class string. ! 470: DWORD dwcValues; // Number of values for this key. ! 471: DWORD dwcMaxValueName; // Longest Value name. ! 472: DWORD dwcMaxValueData; // Longest Value data. ! 473: DWORD dwcSecDesc; // Security descriptor. ! 474: FILETIME ftLastWriteTime; // Last write time. ! 475: ! 476: DWORD i; ! 477: DWORD retCode; ! 478: ! 479: DWORD j; ! 480: DWORD retValue; ! 481: CHAR ValueName[MAX_VALUE_NAME]; ! 482: DWORD dwcValueName = MAX_VALUE_NAME; ! 483: CHAR Buf[80]; ! 484: ! 485: ! 486: // Get Class name, Value count. ! 487: ! 488: RegQueryInfoKey (hKey, // Key handle. ! 489: ClassName, // Buffer for class name. ! 490: &dwcClassLen, // Length of class string. ! 491: NULL, // Reserved. ! 492: &dwcSubKeys, // Number of sub keys. ! 493: &dwcMaxSubKey, // Longest sub key size. ! 494: &dwcMaxClass, // Longest class string. ! 495: &dwcValues, // Number of values for this key. ! 496: &dwcMaxValueName, // Longest Value name. ! 497: &dwcMaxValueData, // Longest Value data. ! 498: &dwcSecDesc, // Security descriptor. ! 499: &ftLastWriteTime); // Last write time. ! 500: ! 501: SetDlgItemText (hDlg, IDE_CLASS, ClassName); ! 502: SetDlgItemInt (hDlg, IDE_CVALUES, dwcValues, FALSE); ! 503: ! 504: SendMessage (GetDlgItem (hDlg, IDL_LISTBOX), ! 505: LB_ADDSTRING, 0, (LONG)".."); ! 506: ! 507: // Loop until RegEnumKey fails, get ! 508: // the name of each child and enter ! 509: // it into the box. ! 510: ! 511: // Enumerate the Child Keys. ! 512: ! 513: SetCursor (LoadCursor (NULL, IDC_WAIT)); ! 514: for (i=0, retCode = ERROR_SUCCESS; retCode == ERROR_SUCCESS; i++) ! 515: { ! 516: retCode = RegEnumKey (hKey, i, ! 517: KeyName, MAX_PATH); ! 518: ! 519: if (retCode == (DWORD)ERROR_SUCCESS) ! 520: SendMessage (GetDlgItem(hDlg, IDL_LISTBOX), ! 521: LB_ADDSTRING, 0, (LONG)KeyName); ! 522: } ! 523: SetCursor (LoadCursor (NULL, IDC_ARROW)); ! 524: ! 525: ! 526: // Enumerate the Key Values ! 527: SetCursor (LoadCursor (NULL, IDC_WAIT)); ! 528: ! 529: if (dwcValues) ! 530: for (j = 0, retValue = ERROR_SUCCESS; j < dwcValues; j++) ! 531: { ! 532: dwcValueName = MAX_VALUE_NAME; ! 533: ValueName[0] = '\0'; ! 534: retValue = RegEnumValue (hKey, j, ValueName, ! 535: &dwcValueName, ! 536: NULL, ! 537: NULL, //&dwType, ! 538: NULL, //&bData, ! 539: NULL); //&bcData); ! 540: if (retValue != (DWORD)ERROR_SUCCESS && ! 541: retValue != ERROR_INSUFFICIENT_BUFFER) ! 542: { ! 543: wsprintf (Buf, "Line:%d 0 based index = %d, retValue = %d, ValueLen = %d", ! 544: __LINE__, j, retValue, dwcValueName); ! 545: MessageBox (hDlg, Buf, "Debug", MB_OK); ! 546: } ! 547: ! 548: Buf[0] = '\0'; ! 549: if (!strlen(ValueName)) ! 550: strcpy (ValueName, "<NO NAME>"); ! 551: wsprintf (Buf, "%d) %s ", j, ValueName); ! 552: SendMessage (GetDlgItem (hDlg, IDL_LISTBOX2), ! 553: LB_ADDSTRING, 0, (LONG)Buf); ! 554: ! 555: }// end for(;;) ! 556: ! 557: SetCursor (LoadCursor (NULL, IDC_ARROW)); ! 558: ! 559: } ! 560: ! 561: ! 562: ! 563: /************************************************************************\ ! 564: * ! 565: * FUNCTION: DisplayKeyData(); ! 566: * ! 567: * PURPOSE: To display the keys values and value types to the Value edit ! 568: * field. This function is called when the right hand listbox ! 569: * is double clicked. The functionality is much like that found ! 570: * in the function PrintTree, please see it for more details. ! 571: * ! 572: \************************************************************************/ ! 573: ! 574: ! 575: VOID DisplayKeyData (HWND hDlg, CHAR *RegPath, HANDLE hKeyRoot) ! 576: { ! 577: HANDLE hKey; ! 578: DWORD dwLBIndex; ! 579: CHAR Buf[LINE_LEN]; ! 580: CHAR ValueName[MAX_VALUE_NAME]; ! 581: DWORD cbValueName = MAX_VALUE_NAME; ! 582: DWORD dwType; ! 583: DWORD retCode; ! 584: ! 585: CHAR ClassName[MAX_PATH]; ! 586: DWORD dwcClassLen = MAX_PATH; ! 587: DWORD dwcSubKeys; ! 588: DWORD dwcMaxSubKey; ! 589: DWORD dwcMaxClass; ! 590: DWORD dwcValues; ! 591: DWORD dwcMaxValueName; ! 592: DWORD dwcMaxValueData; ! 593: DWORD dwcSecDesc; ! 594: FILETIME ftLastWriteTime; ! 595: ! 596: ! 597: BYTE *bData; ! 598: DWORD cbData; ! 599: ! 600: CHAR *outBuf; ! 601: DWORD i; ! 602: DWORD cStrLen; ! 603: ! 604: CHAR *BinaryStrBuf; ! 605: CHAR ByteBuf[4]; ! 606: ! 607: CHAR *ptr; ! 608: ! 609: // OPEN THE KEY. ! 610: ! 611: // LBIndex should == value index. ! 612: dwLBIndex = SendMessage (GetDlgItem (hDlg, IDL_LISTBOX2), ! 613: LB_GETCURSEL, 0, 0); ! 614: ! 615: retCode = RegOpenKeyEx (hKeyRoot, // Key handle at root level. ! 616: RegPath, // Path name of child key. ! 617: 0, // Reserved. ! 618: KEY_EXECUTE, // Requesting read access. ! 619: &hKey); // Address of key to be returned. ! 620: ! 621: if (retCode) ! 622: { ! 623: wsprintf (Buf, "Error: RegOpenKeyEx = %d", retCode); ! 624: MessageBox (hDlg, Buf, "DisplayKeyData()", MB_OK); ! 625: return; ! 626: } ! 627: ! 628: // ADD A QUERY AND ALLOCATE A BUFFER FOR BDATA. ! 629: ! 630: retCode = ! 631: RegQueryInfoKey (hKey, // Key handle. ! 632: ClassName, // Buffer for class name. ! 633: &dwcClassLen, // Length of class string. ! 634: NULL, // Reserved. ! 635: &dwcSubKeys, // Number of sub keys. ! 636: &dwcMaxSubKey, // Longest sub key size. ! 637: &dwcMaxClass, // Longest class string. ! 638: &dwcValues, // Number of values for this key. ! 639: &dwcMaxValueName, // Longest Value name. ! 640: &dwcMaxValueData, // Longest Value data. ! 641: &dwcSecDesc, // Security descriptor. ! 642: &ftLastWriteTime); // Last write time. ! 643: ! 644: if (retCode) ! 645: { ! 646: wsprintf (Buf, "Error: RegQIK = %d, %d", retCode, __LINE__); ! 647: MessageBox (hDlg, Buf, "", MB_OK); ! 648: } ! 649: ! 650: bData = HeapAlloc (hHeap, dwcMaxValueData); ! 651: cbData = dwcMaxValueData; ! 652: ! 653: ! 654: // ENUMERATE THE KEY. ! 655: ! 656: retCode = RegEnumValue (hKey, // Key handle returned from RegOpenKeyEx. ! 657: dwLBIndex, // Value index, taken from listbox. ! 658: ValueName, // Name of value. ! 659: &cbValueName,// Size of value name. ! 660: NULL, // Reserved, dword = NULL. ! 661: &dwType, // Type of data. ! 662: bData, // Data buffer. ! 663: &cbData); // Size of data buffer. ! 664: ! 665: if (retCode) ! 666: { ! 667: ! 668: if (dwType < REG_FULL_RESOURCE_DESCRIPTOR) ! 669: { ! 670: wsprintf (Buf, "Error: RegEnumValue = %d, cbData = %d, line %d", ! 671: retCode, cbData, __LINE__); ! 672: MessageBox (hDlg, Buf, "", MB_OK); ! 673: } ! 674: } ! 675: ! 676: ! 677: switch (dwType) ! 678: { ! 679: // REG_NONE ( 0 ) // No value type ! 680: // REG_SZ ( 1 ) // Unicode nul terminated string ! 681: // REG_EXPAND_SZ ( 2 ) // Unicode nul terminated string ! 682: // (with environment variable references) ! 683: // REG_BINARY ( 3 ) // Free form binary ! 684: // REG_DWORD ( 4 ) // 32-bit number ! 685: // REG_DWORD_LITTLE_ENDIAN ( 4 ) // 32-bit number (same as REG_DWORD) ! 686: // REG_DWORD_BIG_ENDIAN ( 5 ) // 32-bit number ! 687: // REG_LINK ( 6 ) // Symbolic Link (unicode) ! 688: // REG_MULTI_SZ ( 7 ) // Multiple Unicode strings ! 689: // REG_RESOURCE_LIST ( 8 ) // Resource list in the resource map ! 690: // REG_FULL_RESOURCE_DESCRIPTOR ( 9 ) // Resource list in the hardware description ! 691: ! 692: case REG_NONE: ! 693: SetDlgItemText (hDlg, IDE_VALUE1, "REG_NONE: No defined value type."); ! 694: break; ! 695: ! 696: case REG_SZ: ! 697: SetDlgItemText (hDlg, IDE_VALUE1, "REG_SZ: A null-terminated Unicode string."); ! 698: ! 699: outBuf = HeapAlloc (hHeap, cbData + 2); ! 700: *outBuf = '\0'; ! 701: ! 702: strcat (outBuf, "\""); ! 703: strcat (outBuf, bData); ! 704: strcat (outBuf, "\""); ! 705: ! 706: SetDlgItemText (hDlg, IDE_VALUE2, outBuf); ! 707: HeapFree (hHeap, outBuf); ! 708: break; ! 709: ! 710: case REG_EXPAND_SZ: ! 711: SetDlgItemText (hDlg, IDE_VALUE1, "REG_EXPAND_SZ: A String referencing environment variables i.e. PATH."); ! 712: outBuf = HeapAlloc (hHeap, cbData + 2); ! 713: *outBuf = '\0'; ! 714: ! 715: strcat (outBuf, "\""); ! 716: strcat (outBuf, bData); ! 717: strcat (outBuf, "\""); ! 718: ! 719: SetDlgItemText (hDlg, IDE_VALUE2, outBuf); ! 720: HeapFree (hHeap, outBuf); ! 721: break; ! 722: ! 723: case REG_BINARY: ! 724: ! 725: SetDlgItemText (hDlg, IDE_VALUE1, "REG_BINARY: Freeform binary data."); ! 726: SetCursor (LoadCursor (NULL, IDC_WAIT)); ! 727: ! 728: BinaryStrBuf = HeapAlloc (hHeap, (3 * cbData) + 1); ! 729: if (BinaryStrBuf) ! 730: { ! 731: *BinaryStrBuf = '\0'; ! 732: *ByteBuf = '\0'; ! 733: for (i = 0; i < cbData; i++) ! 734: { ! 735: sprintf (ByteBuf, "%02x ", (BYTE)bData[i]); ! 736: strcat (BinaryStrBuf, ByteBuf); ! 737: } ! 738: SetDlgItemText (hDlg, IDE_VALUE2, BinaryStrBuf); ! 739: } ! 740: else ! 741: { ! 742: MessageBox (hDlg, "Error: BinaryStrBuf = malloc failed", ! 743: "Debug: DisplayKeyData", MB_OK); ! 744: } ! 745: SetDlgItemText (hDlg, IDL_LISTBOX2, BinaryStrBuf); ! 746: HeapFree (hHeap, BinaryStrBuf); ! 747: SetCursor (LoadCursor (NULL, IDC_ARROW)); ! 748: ! 749: break; ! 750: ! 751: case REG_DWORD: ! 752: SetDlgItemText (hDlg, IDE_VALUE1, "REG_DWORD: A 32 bit number."); ! 753: SetDlgItemInt (hDlg, IDE_VALUE2, *bData, TRUE); ! 754: break; ! 755: ! 756: case REG_DWORD_BIG_ENDIAN: ! 757: SetDlgItemText (hDlg, IDE_VALUE1, "REG_DWORD_BIG_ENDIAN: A 32 bit number in big endian format."); ! 758: SetDlgItemInt (hDlg, IDE_VALUE2, *bData, TRUE); ! 759: break; ! 760: ! 761: case REG_LINK: ! 762: SetDlgItemText (hDlg, IDE_VALUE1, "REG_LINK: A Unicode symbolic link."); ! 763: SetDlgItemText (hDlg, IDE_VALUE2, bData); ! 764: break; ! 765: ! 766: case REG_MULTI_SZ: ! 767: SetDlgItemText (hDlg, IDE_VALUE1, "REG_MULTI_SZ: An array of null-terminated strings."); ! 768: SetCursor (LoadCursor (NULL, IDC_WAIT)); ! 769: // Count the NULLs in the buffer to ! 770: // find out how many strings there are. ! 771: ! 772: for (i=0, cStrLen=4; i < cbData; i++) ! 773: if (!bData[i]) ! 774: cStrLen+=4; // Add room for two quotes and two ! 775: // spaced per string. ! 776: ! 777: outBuf = HeapAlloc (hHeap, cbData + cStrLen); ! 778: ! 779: ptr = bData; // Set ptr to beginning of buffer. ! 780: *outBuf = '\0'; // Initialize output string. ! 781: ! 782: strcat (outBuf, "{ "); // Do first bracket. ! 783: while (*ptr) // Loop til you hit 2 NULLs in a row. ! 784: { ! 785: strcat (outBuf, "\""); // Put quotes around each string. ! 786: strcat (outBuf, ptr); ! 787: strcat (outBuf, "\" "); ! 788: ptr += strlen(ptr)+1; ! 789: } ! 790: strcat (outBuf, "}"); // Add final bracket. ! 791: SetDlgItemText (hDlg, IDE_VALUE2, outBuf); ! 792: ! 793: SetCursor (LoadCursor (NULL, IDC_ARROW)); ! 794: HeapFree (hHeap, outBuf); // free output string. ! 795: break; ! 796: ! 797: ! 798: case REG_RESOURCE_LIST: // CM_RESOURCE_LIST is kind of complex, ! 799: // it's defined in ntconfig.h. Print ! 800: // it as a free formed binary data now, ! 801: // and structure it later with a ! 802: // different release. ! 803: SetDlgItemText (hDlg, IDE_VALUE1, "REG_RESOURCE_LIST: A device-driver resource list."); ! 804: ! 805: BinaryStrBuf = HeapAlloc (hHeap, (3 * cbData) + 1); ! 806: if (BinaryStrBuf) ! 807: { ! 808: *BinaryStrBuf = '\0'; ! 809: *ByteBuf = '\0'; ! 810: for (i = 0; i < cbData; i++) ! 811: { ! 812: sprintf (ByteBuf, "%02x ", (BYTE)bData[i]); ! 813: strcat (BinaryStrBuf, ByteBuf); ! 814: } ! 815: SetDlgItemText (hDlg, IDE_VALUE2, BinaryStrBuf); ! 816: } ! 817: else ! 818: { ! 819: MessageBox (hDlg, "Error: BinaryStrBuf = malloc failed", ! 820: "Debug: DisplayKeyData", MB_OK); ! 821: } ! 822: SetDlgItemText (hDlg, IDL_LISTBOX2, BinaryStrBuf); ! 823: HeapFree (hHeap, BinaryStrBuf); ! 824: ! 825: break; ! 826: ! 827: case REG_FULL_RESOURCE_DESCRIPTOR: ! 828: SetDlgItemText (hDlg, IDE_VALUE1, "REG_FULL_RESOURCE_DESCRIPTOR: A resource list in the hardware description."); ! 829: break; ! 830: ! 831: ! 832: ! 833: default: ! 834: wsprintf (Buf, "Undefine in this verion of the Registry Monkey. %d", ! 835: dwType); ! 836: SetDlgItemText (hDlg, IDE_VALUE1, Buf); ! 837: break; ! 838: ! 839: } // end switch ! 840: ! 841: ! 842: HeapFree (hHeap, bData); ! 843: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.