![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to registry.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson|
Return to registry.c CVS log | Up to [WindowsNT SDKs] / mstools / samples / sdktools / image / drwatson |
1.1 root 1: /*++
2:
3: Copyright (c) 1993 Microsoft Corporation
4:
5: Module Name:
6:
7: registry.c
8:
9: Abstract:
10:
11: This file implements the apis for DRWTSN32 to access the registry.
12: All access to the registry are done in this file. If additional
13: registry control is needed then a function should be added in this file
14: and exposed to the other files in DRWTSN32.
15:
16: Author:
17:
18: Wesley Witt (wesw) 1-May-1993
19:
20: Environment:
21:
22: User Mode
23:
24: --*/
25:
26: #include <windows.h>
27: #include <stdlib.h>
28: #include <stdio.h>
29: #include <string.h>
30:
31: #include "drwatson.h"
32: #include "proto.h"
33: #include "messages.h"
34:
35:
36: //
37: // string constants for accessing the registry
38: // there is a string constant here for each key and each value
39: // that is accessed in the registry.
40: //
41: #define DRWATSON_EXE_NAME "drwtsn32.exe"
42: #define REGKEY_SOFTWARE "software\\microsoft"
43: #define REGKEY_MESSAGEFILE "EventMessageFile"
44: #define REGKEY_TYPESSUPP "TypesSupported"
45: #define REGKEY_SYSTEMROOT "%SystemRoot%\\System32\\"
46: #define REGKEY_EVENTLOG "SYSTEM\\CurrentControlSet\\Services\\EventLog\\Application\\"
47: #define REGKEY_APPNAME "ApplicationName"
48: #define REGKEY_FUNCTION "FunctionName"
49: #define REGKEY_EXCEPTIONCODE "ExceptionCode"
50: #define REGKEY_ADDRESS "Address"
51: #define REGKEY_LOG_PATH "LogFilePath"
52: #define REGKEY_DUMPSYMBOLS "DumpSymbols"
53: #define REGKEY_DUMPALLTHREADS "DumpAllThreads"
54: #define REGKEY_APPENDTOLOGFILE "AppendToLogFile"
55: #define REGKEY_INSTRUCTIONS "Instructions"
56: #define REGKEY_VISUAL "VisualNotification"
57: #define REGKEY_SOUND "SoundNotification"
58: #define REGKEY_WAVE_FILE "WaveFile"
59: #define REGKEY_NUM_CRASHES "NumberOfCrashes"
60: #define REGKEY_MAX_CRASHES "MaximumCrashes"
61: #define REGKEY_CURRENTVERSION "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion"
62: #define REGKEY_CURRENT_BUILD "CurrentBuild"
63: #define REGKEY_CURRENT_TYPE "CurrentType"
64: #define REGKEY_REG_ORGANIZATION "RegisteredOrganization"
65: #define REGKEY_REG_OWNER "RegisteredOwner"
66: #define REGKEY_AEDEBUG "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\AeDebug"
67: #define REGKEY_AUTO "Auto"
68: #define REGKEY_DEBUGGER "Debugger"
69:
70:
71: //
72: // local prototypes
73: //
74: void RegSetDWORD( HKEY hkey, char *szSubKey, DWORD dwValue );
75: void RegSetBOOL( HKEY hkey, char *szSubKey, BOOL dwValue );
76: void RegSetSZ( HKEY hkey, char *szSubKey, char *szValue );
77: void RegSetEXPANDSZ( HKEY hkey, char *szSubKey, char *szValue );
78: BOOL RegQueryBOOL( HKEY hkey, char *szSubKey );
79: DWORD RegQueryDWORD( HKEY hkey, char *szSubKey );
80: void RegQuerySZ( HKEY hkey, char *szSubKey, char *szValue );
81: BOOL RegSaveAllValues( HKEY hKeyDrWatson, POPTIONS o );
82: BOOL RegGetAllValues( POPTIONS o, HKEY hKeyDrWatson );
83: BOOL RegInitializeDefaults( HKEY hKeyDrWatson );
84: HKEY RegGetAppKey( void );
85: BOOL RegCreateEventSource( void );
86:
87:
88:
89: BOOL
90: RegGetAllValues( POPTIONS o, HKEY hKeyDrWatson )
91:
92: /*++
93:
94: Routine Description:
95:
96: This functions retrieves all registry data for DRWTSN32 and puts
97: the data in the OPTIONS structure passed in.
98:
99: Arguments:
100:
101: o - pointer to an OPTIONS structure
102: hKeyDrWatson - handle to a registry key for DRWTSN32 registry data
103:
104: Return Value:
105:
106: TRUE - retrieved all data without error
107: FALSE - errors occurred and did not get all data
108:
109: --*/
110:
111: {
112: RegQuerySZ( hKeyDrWatson, REGKEY_LOG_PATH, o->szLogPath );
113: RegQuerySZ( hKeyDrWatson, REGKEY_WAVE_FILE, o->szWaveFile );
114: o->fDumpSymbols = RegQueryBOOL( hKeyDrWatson, REGKEY_DUMPSYMBOLS );
115: o->fDumpAllThreads = RegQueryBOOL( hKeyDrWatson, REGKEY_DUMPALLTHREADS );
116: o->fAppendToLogFile = RegQueryBOOL( hKeyDrWatson, REGKEY_APPENDTOLOGFILE );
117: o->fVisual = RegQueryBOOL( hKeyDrWatson, REGKEY_VISUAL );
118: o->fSound = RegQueryBOOL( hKeyDrWatson, REGKEY_SOUND );
119: o->dwInstructions = RegQueryDWORD( hKeyDrWatson, REGKEY_INSTRUCTIONS );
120: o->dwMaxCrashes = RegQueryDWORD( hKeyDrWatson, REGKEY_MAX_CRASHES );
121:
122: return TRUE;
123: }
124:
125: BOOL
126: RegSaveAllValues( HKEY hKeyDrWatson, POPTIONS o )
127:
128: /*++
129:
130: Routine Description:
131:
132: This functions saves all registry data for DRWTSN32 that is passed
133: in via the OPTIONS structure.
134:
135: Arguments:
136:
137: hKeyDrWatson - handle to a registry key for DRWTSN32 registry data
138: o - pointer to an OPTIONS structure
139:
140: Return Value:
141:
142: TRUE - saved all data without error
143: FALSE - errors occurred and did not save all data
144:
145: --*/
146:
147: {
148: RegSetSZ( hKeyDrWatson, REGKEY_LOG_PATH, o->szLogPath );
149: RegSetSZ( hKeyDrWatson, REGKEY_WAVE_FILE, o->szWaveFile );
150: RegSetBOOL( hKeyDrWatson, REGKEY_DUMPSYMBOLS, o->fDumpSymbols );
151: RegSetBOOL( hKeyDrWatson, REGKEY_DUMPALLTHREADS, o->fDumpAllThreads );
152: RegSetBOOL( hKeyDrWatson, REGKEY_APPENDTOLOGFILE, o->fAppendToLogFile );
153: RegSetBOOL( hKeyDrWatson, REGKEY_VISUAL, o->fVisual );
154: RegSetBOOL( hKeyDrWatson, REGKEY_SOUND, o->fSound );
155: RegSetDWORD( hKeyDrWatson, REGKEY_INSTRUCTIONS, o->dwInstructions );
156: RegSetDWORD( hKeyDrWatson, REGKEY_MAX_CRASHES, o->dwMaxCrashes );
157:
158: return TRUE;
159: }
160:
161: BOOL
162: RegInitializeDefaults( HKEY hKeyDrWatson )
163:
164: /*++
165:
166: Routine Description:
167:
168: This functions initializes the registry with the default values.
169:
170: Arguments:
171:
172: hKeyDrWatson - handle to a registry key for DRWTSN32 registry data
173:
174: Return Value:
175:
176: TRUE - saved all data without error
177: FALSE - errors occurred and did not save all data
178:
179: --*/
180:
181: {
182: OPTIONS o;
183:
184: GetWindowsDirectory( o.szLogPath, sizeof(o.szLogPath) );
185: o.szWaveFile[0] = '\0';
186: o.fDumpSymbols = FALSE;
187: o.fDumpAllThreads = TRUE;
188: o.fAppendToLogFile = TRUE;
189: o.fVisual = TRUE;
190: o.fSound = FALSE;
191: o.dwInstructions = 10;
192: o.dwMaxCrashes = 10;
193:
194: RegSetNumCrashes( 0 );
195:
196: RegSaveAllValues( hKeyDrWatson, &o );
197:
198: RegCreateEventSource();
199:
200: return TRUE;
201: }
202:
203: BOOL
204: RegCreateEventSource( void )
205:
206: /*++
207:
208: Routine Description:
209:
210: This function creates an event source in the registry. The event
211: source is used by the event viewer to display the data in a
212: presentable manner.
213:
214: Arguments:
215:
216: None.
217:
218: Return Value:
219:
220: TRUE - saved all data without error
221: FALSE - errors occurred and did not save all data
222:
223: --*/
224:
225: {
226: HKEY hk;
227: char szBuf[1024];
228: DWORD dwDisp;
229: char szAppName[MAX_PATH];
230:
231: GetAppName( szAppName, sizeof(szAppName) );
232: strcpy( szBuf, REGKEY_EVENTLOG );
233: strcat( szBuf, szAppName );
234: if (RegCreateKeyEx( HKEY_LOCAL_MACHINE,
235: szBuf,
236: 0,
237: NULL,
238: REG_OPTION_NON_VOLATILE,
239: KEY_QUERY_VALUE | KEY_SET_VALUE,
240: NULL,
241: &hk,
242: &dwDisp
243: )) {
244: return FALSE;
245: }
246:
247: if (dwDisp == REG_OPENED_EXISTING_KEY) {
248: RegCloseKey(hk);
249: return TRUE;
250: }
251:
252: strcpy( szBuf, REGKEY_SYSTEMROOT );
253: strcat( szBuf, DRWATSON_EXE_NAME );
254: RegSetEXPANDSZ( hk, REGKEY_MESSAGEFILE, szBuf );
255: RegSetDWORD( hk, REGKEY_TYPESSUPP, EVENTLOG_ERROR_TYPE | EVENTLOG_WARNING_TYPE | EVENTLOG_INFORMATION_TYPE );
256:
257: RegCloseKey(hk);
258:
259: return TRUE;
260: }
261:
262: HKEY
263: RegGetAppKey( void )
264:
265: /*++
266:
267: Routine Description:
268:
269: This function gets a handle to the DRWTSN32 registry key.
270:
271: Arguments:
272:
273: None.
274:
275: Return Value:
276:
277: Valid handle - handle opened ok
278: NULL - could not open the handle
279:
280: --*/
281:
282: {
283: DWORD rc;
284: DWORD dwDisp;
285: HKEY hKeyDrWatson;
286: HKEY hKeyMicrosoft;
287: char szAppName[MAX_PATH];
288:
289: rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
290: REGKEY_SOFTWARE,
291: 0,
292: KEY_QUERY_VALUE | KEY_SET_VALUE |
293: KEY_CREATE_SUB_KEY | KEY_ENUMERATE_SUB_KEYS,
294: &hKeyMicrosoft
295: );
296:
297: if (rc != ERROR_SUCCESS) {
298: return NULL;
299: }
300:
301: GetAppName( szAppName, sizeof(szAppName) );
302:
303: rc = RegCreateKeyEx( hKeyMicrosoft,
304: szAppName,
305: 0,
306: NULL,
307: REG_OPTION_NON_VOLATILE,
308: KEY_READ | KEY_WRITE,
309: NULL,
310: &hKeyDrWatson,
311: &dwDisp
312: );
313:
314: if (rc != ERROR_SUCCESS) {
315: return NULL;
316: }
317:
318: if (dwDisp == REG_CREATED_NEW_KEY) {
319: RegInitializeDefaults( hKeyDrWatson );
320: }
321:
322: return hKeyDrWatson;
323: }
324:
325: BOOL
326: RegInitialize( POPTIONS o )
327:
328: /*++
329:
330: Routine Description:
331:
332: This function is used to initialize the OPTIONS structure passed in
333: with the current values in the registry. Note that if the registry
334: is empty then the defaults are stored in the registry and also
335: returned in the OPTIONS structure.
336:
337: Arguments:
338:
339: None.
340:
341: Return Value:
342:
343: TRUE - all data was retrieved ok
344: NULL - could not get all data
345:
346: --*/
347:
348: {
349: HKEY hKeyDrWatson;
350:
351: hKeyDrWatson = RegGetAppKey();
352: Assert( hKeyDrWatson != NULL );
353:
354: if (!RegGetAllValues( o, hKeyDrWatson )) {
355: return FALSE;
356: }
357:
358: RegCloseKey( hKeyDrWatson );
359:
360: return TRUE;
361: }
362:
363: BOOL
364: RegSave( POPTIONS o )
365:
366: /*++
367:
368: Routine Description:
369:
370: This function is used to save the data in the OPTIONS structure
371: to the registry.
372:
373: Arguments:
374:
375: o - pointer to an OPTIONS structure
376:
377: Return Value:
378:
379: TRUE - all data was saved ok
380: NULL - could not save all data
381:
382: --*/
383:
384: {
385: HKEY hKeyDrWatson;
386:
387: hKeyDrWatson = RegGetAppKey();
388: Assert( hKeyDrWatson != NULL );
389: RegSaveAllValues( hKeyDrWatson, o );
390: RegCloseKey( hKeyDrWatson );
391:
392: return TRUE;
393: }
394:
395: void
396: RegSetNumCrashes( DWORD dwNumCrashes )
397:
398: /*++
399:
400: Routine Description:
401:
402: This function changes the value in the registry that contains the
403: number of crashes that have occurred.
404:
405: Arguments:
406:
407: dwNumCrashes - the number of craches to save
408:
409: Return Value:
410:
411: None.
412:
413: --*/
414:
415: {
416: HKEY hKeyDrWatson;
417:
418: hKeyDrWatson = RegGetAppKey();
419: Assert( hKeyDrWatson != NULL );
420: RegSetDWORD( hKeyDrWatson, REGKEY_NUM_CRASHES, dwNumCrashes );
421: RegCloseKey( hKeyDrWatson );
422:
423: return;
424: }
425:
426: DWORD
427: RegGetNumCrashes( void )
428:
429: /*++
430:
431: Routine Description:
432:
433: This function get the value in the registry that contains the
434: number of crashes that have occurred.
435:
436: Arguments:
437:
438: None.
439:
440: Return Value:
441:
442: the number of craches that have occurred
443:
444: --*/
445:
446: {
447: HKEY hKeyDrWatson;
448: DWORD dwNumCrashes;
449:
450: hKeyDrWatson = RegGetAppKey();
451: Assert( hKeyDrWatson != NULL );
452: dwNumCrashes = RegQueryDWORD( hKeyDrWatson, REGKEY_NUM_CRASHES );
453: RegCloseKey( hKeyDrWatson );
454:
455: return dwNumCrashes;
456: }
457:
458: BOOLEAN
459: RegInstallDrWatson( void )
460:
461: /*++
462:
463: Routine Description:
464:
465: This function gets a handle to the DRWTSN32 registry key.
466:
467: Arguments:
468:
469: None.
470:
471: Return Value:
472:
473: Valid handle - handle opened ok
474: NULL - could not open the handle
475:
476: --*/
477:
478: {
479: DWORD rc;
480: HKEY hKeyMicrosoft;
481:
482: rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
483: REGKEY_AEDEBUG,
484: 0,
485: KEY_QUERY_VALUE | KEY_SET_VALUE,
486: &hKeyMicrosoft
487: );
488:
489: if (rc != ERROR_SUCCESS) {
490: return FALSE;
491: }
492:
493: RegSetSZ( hKeyMicrosoft, REGKEY_AUTO, "1" );
494: RegSetSZ( hKeyMicrosoft, REGKEY_DEBUGGER, "drwtsn32 -p %ld -e %ld -g" );
495:
496: RegCloseKey( hKeyMicrosoft );
497:
498: return TRUE;
499: }
500:
501: void
502: RegSetDWORD( HKEY hkey, char *szSubKey, DWORD dwValue )
503:
504: /*++
505:
506: Routine Description:
507:
508: This function changes a DWORD value in the registry using the
509: hkey and szSubKey as the registry key info.
510:
511: Arguments:
512:
513: hkey - handle to a registry key
514: szSubKey - pointer to a subkey string
515: dwValue - new registry value
516:
517: Return Value:
518:
519: None.
520:
521: --*/
522:
523: {
524: DWORD rc;
525:
526: rc = RegSetValueEx( hkey, szSubKey, 0, REG_DWORD, (LPBYTE)&dwValue, 4 );
527: Assert( rc == ERROR_SUCCESS );
528: }
529:
530: void
531: RegSetBOOL( HKEY hkey, char *szSubKey, BOOL dwValue )
532:
533: /*++
534:
535: Routine Description:
536:
537: This function changes a BOOL value in the registry using the
538: hkey and szSubKey as the registry key info.
539:
540: Arguments:
541:
542: hkey - handle to a registry key
543: szSubKey - pointer to a subkey string
544: dwValue - new registry value
545:
546: Return Value:
547:
548: None.
549:
550: --*/
551:
552: {
553: DWORD rc;
554:
555: rc = RegSetValueEx( hkey, szSubKey, 0, REG_DWORD, (LPBYTE)&dwValue, 4 );
556: Assert( rc == ERROR_SUCCESS );
557: }
558:
559: void
560: RegSetSZ( HKEY hkey, char *szSubKey, char *szValue )
561:
562: /*++
563:
564: Routine Description:
565:
566: This function changes a SZ value in the registry using the
567: hkey and szSubKey as the registry key info.
568:
569: Arguments:
570:
571: hkey - handle to a registry key
572: szSubKey - pointer to a subkey string
573: szValue - new registry value
574:
575: Return Value:
576:
577: None.
578:
579: --*/
580:
581: {
582: DWORD rc;
583:
584: rc = RegSetValueEx( hkey, szSubKey, 0, REG_SZ, szValue, strlen(szValue)+1 );
585: Assert( rc == ERROR_SUCCESS );
586: }
587:
588: void
589: RegSetEXPANDSZ( HKEY hkey, char *szSubKey, char *szValue )
590:
591: /*++
592:
593: Routine Description:
594:
595: This function changes a SZ value in the registry using the
596: hkey and szSubKey as the registry key info.
597:
598: Arguments:
599:
600: hkey - handle to a registry key
601: szSubKey - pointer to a subkey string
602: szValue - new registry value
603:
604: Return Value:
605:
606: None.
607:
608: --*/
609:
610: {
611: DWORD rc;
612:
613: rc = RegSetValueEx( hkey, szSubKey, 0, REG_EXPAND_SZ, szValue, strlen(szValue)+1 );
614: Assert( rc == ERROR_SUCCESS );
615: }
616:
617: BOOL
618: RegQueryBOOL( HKEY hkey, char *szSubKey )
619:
620: /*++
621:
622: Routine Description:
623:
624: This function queries BOOL value in the registry using the
625: hkey and szSubKey as the registry key info. If the value is not
626: found in the registry, it is added with a FALSE value.
627:
628: Arguments:
629:
630: hkey - handle to a registry key
631: szSubKey - pointer to a subkey string
632:
633: Return Value:
634:
635: TRUE or FALSE.
636:
637: --*/
638:
639: {
640: DWORD rc;
641: DWORD len;
642: DWORD dwType;
643: BOOL fValue;
644:
645: len = 4;
646: rc = RegQueryValueEx( hkey, szSubKey, 0, &dwType, (LPBYTE)&fValue, &len );
647: if (rc != ERROR_SUCCESS) {
648: if (rc == ERROR_FILE_NOT_FOUND) {
649: fValue = FALSE;
650: RegSetBOOL( hkey, szSubKey, fValue );
651: }
652: else {
653: Assert( rc == ERROR_SUCCESS );
654: }
655: }
656: else {
657: Assert( dwType == REG_DWORD );
658: }
659:
660: return fValue;
661: }
662:
663: DWORD
664: RegQueryDWORD( HKEY hkey, char *szSubKey )
665:
666: /*++
667:
668: Routine Description:
669:
670: This function queries BOOL value in the registry using the
671: hkey and szSubKey as the registry key info. If the value is not
672: found in the registry, it is added with a zero value.
673:
674: Arguments:
675:
676: hkey - handle to a registry key
677: szSubKey - pointer to a subkey string
678:
679: Return Value:
680:
681: registry value
682:
683: --*/
684:
685: {
686: DWORD rc;
687: DWORD len;
688: DWORD dwType;
689: DWORD fValue;
690:
691: len = 4;
692: rc = RegQueryValueEx( hkey, szSubKey, 0, &dwType, (LPBYTE)&fValue, &len );
693: if (rc != ERROR_SUCCESS) {
694: if (rc == ERROR_FILE_NOT_FOUND) {
695: fValue = 0;
696: RegSetDWORD( hkey, szSubKey, fValue );
697: }
698: else {
699: Assert( rc == ERROR_SUCCESS );
700: }
701: }
702: else {
703: Assert( dwType == REG_DWORD );
704: }
705:
706: return fValue;
707: }
708:
709: void
710: RegQuerySZ( HKEY hkey, char *szSubKey, char *szValue )
711:
712: /*++
713:
714: Routine Description:
715:
716: This function queries BOOL value in the registry using the
717: hkey and szSubKey as the registry key info. If the value is not
718: found in the registry, it is added with a zero value.
719:
720: Arguments:
721:
722: hkey - handle to a registry key
723: szSubKey - pointer to a subkey string
724:
725: Return Value:
726:
727: registry value
728:
729: --*/
730:
731: {
732: DWORD rc;
733: DWORD len;
734: DWORD dwType;
735: char buf[1024];
736:
737: len = sizeof(buf);
738: rc = RegQueryValueEx( hkey, szSubKey, 0, &dwType, (LPBYTE)buf, &len );
739: if (rc != ERROR_SUCCESS) {
740: if (rc == ERROR_FILE_NOT_FOUND) {
741: buf[0] = 0;
742: RegSetSZ( hkey, szSubKey, buf );
743: }
744: else {
745: Assert( rc == ERROR_SUCCESS );
746: }
747: }
748: else {
749: Assert( dwType == REG_SZ );
750: }
751:
752: strcpy( szValue, buf );
753: }
754:
755: void
756: RegLogCurrentVersion( void )
757: {
758: char buf[1024];
759: DWORD rc;
760: HKEY hKeyCurrentVersion;
761:
762: rc = RegOpenKeyEx( HKEY_LOCAL_MACHINE,
763: REGKEY_CURRENTVERSION,
764: 0,
765: KEY_QUERY_VALUE,
766: &hKeyCurrentVersion
767: );
768:
769: if (rc != ERROR_SUCCESS) {
770: return;
771: }
772:
773: RegQuerySZ( hKeyCurrentVersion,REGKEY_CURRENT_BUILD, buf );
774: lprintf( MSG_CURRENT_BUILD, buf );
775: RegQuerySZ( hKeyCurrentVersion,REGKEY_CURRENT_TYPE, buf );
776: lprintf( MSG_CURRENT_TYPE, buf );
777: RegQuerySZ( hKeyCurrentVersion,REGKEY_REG_ORGANIZATION, buf );
778: lprintf( MSG_REG_ORGANIZATION, buf );
779: RegQuerySZ( hKeyCurrentVersion,REGKEY_REG_OWNER, buf );
780: lprintf( MSG_REG_OWNER, buf );
781:
782: return;
783: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.