![[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] / ntddk / src / mmedia / synth / dll|
Return to registry.c CVS log | Up to [WindowsNT SDKs] / ntddk / src / mmedia / synth / dll |
1.1 root 1: /****************************************************************************
2: *
3: * registry.c
4: *
5: * Copyright (c) 1992 Microsoft Corporation. All Rights Reserved.
6: *
7: * This file contains functions to maintain registry entries for
8: * kernel drivers installed via the drivers control panel applet.
9: *
10: * Note that the ONLY state maintained between calls here is whatever
11: * state the registry and its handles maintain.
12: *
13: * The registry entries are structured as follows :
14: * (see also winreg.h, winnt.h)
15: *
16: * HKEY_LOCAL_MACHINE
17: * SYSTEM
18: * CurrentControlSet
19: * Services
20: * DriverNode (eg sndblst)
21: * Type = SERVICE_KERNEL_DRIVER (eg)
22: * Group = "Base"
23: * ErrorControl = SERVICE_ERROR_NORMAL
24: * Start = SERVICE_SYSTEM_START |
25: * SERVICE_DEMAND_START |
26: * SERVICE_DISABLED
27: * ...
28: * Tag = A unique number ???
29: *
30: * Device
31: * Interrupt =
32: * Port =
33: * DMAChannel =
34: *
35: * The Driver node is set up by the services manager when we call
36: * CreateService but we have to insert the device data ourselves.
37: *
38: *
39: *
40: * The registry entries are shared between :
41: *
42: * The system loader (which uses the Services entry)
43: * The kernel driver (which reads from the Device entry)
44: * This component called from the drivers control panel applet
45: * The service control manager
46: * The Setup utility
47: *
48: * Security access
49: * ---------------
50: *
51: * The driver determines whether it can perform configuration and
52: * installation by whether it can get read and write access to the
53: * service control manager. This is required to manipulate the kernel
54: * driver database.
55: *
56: * Services controller
57: * -------------------
58: *
59: * The services controller is used because this is the only way we
60: * are allowed to load and unload kernel drivers. Only the services
61: * controller can call LoadDriver and UnloadDriver and not get 'access
62: * denied'.
63: *
64: * Note also that we can't keep the services controller handle open
65: * at the same time as the registry handle because then we can't get
66: * write access (actually we only need KEY_CREATE_SUB_KEY access) to
67: * our device parameters subkey.
68: *
69: ***************************************************************************/
70:
71: #include <stdio.h>
72: #ifdef UNICODE
73: #include <wchar.h>
74: #else
75: #include <string.h>
76: #define wcscat strcat
77: #define wcscpy strcpy
78: #define wcsicmp stricmp
79: #endif
80: #include <windows.h>
81: #include <mmsystem.h>
82: #include <winsvc.h>
83: #include <soundcfg.h>
84: #include "registry.h"
85:
86: /***************************************************************************
87: *
88: * Constants for accessing the registry
89: *
90: ***************************************************************************/
91:
92: /*
93: * Path to service node key
94: */
95:
96: #define STR_SERVICES_NODE TEXT("SYSTEM\\CurrentControlSet\\Services\\")
97:
98: /*
99: * Node sub-key for device parameters
100: */
101:
102: #define STR_DEVICE_DATA PARMS_SUBKEY
103:
104: /*
105: * Name of Base group where sound drivers normally go
106: */
107:
108: #define STR_BASE_GROUP TEXT("Base")
109:
110: /*
111: * Name of driver group for synthesizers
112: * - we use our own name here to make sure
113: * we are loaded after things like the PAS driver. (Base is a
114: * known group and drivers in it are always loaded before unknown
115: * groups like this one).
116: */
117:
118: #define STR_SYNTH_GROUP TEXT("Synthesizer Drivers")
119:
120: /*
121: * Name of service
122: */
123:
124: #define STR_DRIVER TEXT("\\Driver\\")
125:
126: /*
127: * Path to kernel drivers directory from system directory
128: */
129:
130: #define STR_DRIVERS_DIR TEXT("\\SystemRoot\\SYSTEM32\\DRIVERS\\")
131:
132: /*
133: * Extension for drivers
134: */
135:
136: #define STR_SYS_EXT TEXT(".SYS")
137:
138:
139: HKEY DrvOpenRegKey(LPTSTR DriverName)
140: {
141: TCHAR RegistryPath[MAX_PATH];
142: HKEY NodeHandle;
143:
144: //
145: // Create the path to our node
146: //
147:
148: wcscpy(RegistryPath, STR_SERVICES_NODE);
149: wcscat(RegistryPath, DriverName);
150:
151: //
152: // See if we can get a registry handle to our device data
153: //
154:
155:
156: if (RegOpenKeyEx(HKEY_LOCAL_MACHINE,
157: RegistryPath,
158: 0L,
159: KEY_ALL_ACCESS,
160: &NodeHandle)
161: != ERROR_SUCCESS) {
162: return NULL;
163: } else {
164: return NodeHandle;
165: }
166: }
167:
168:
169: SC_HANDLE DrvOpenService(PREG_ACCESS RegAccess)
170: {
171: SC_HANDLE Handle;
172: Handle = OpenService(RegAccess->ServiceManagerHandle,
173: RegAccess->DriverName,
174: SERVICE_ALL_ACCESS);
175:
176: #if 0
177: if (Handle == NULL) {
178: char buf[100];
179: sprintf(buf, "OpenService failed code %d\n", GetLastError());
180: OutputDebugStringA(buf);
181: }
182: #endif
183:
184: return Handle;
185: }
186:
187: void DrvCloseService(PREG_ACCESS RegAccess, SC_HANDLE ServiceHandle)
188: {
189: CloseServiceHandle(ServiceHandle);
190: }
191:
192: /***************************************************************************
193: *
194: * Function :
195: * DrvCreateServicesNode
196: *
197: * Parameters :
198: * DriverNodeName The name of the service node. Same as the
199: * name of the driver which must be
200: * DriverNodeName.sys for the system to find it.
201: *
202: * DriverType Type of driver - see registry.h
203: *
204: * ServiceNodeKey Pointer to where to put returned handle
205: *
206: * Return code :
207: *
208: * Standard error code (see winerror.h)
209: *
210: * Description :
211: *
212: * Create the service node key
213: *
214: * The class name of the registry node is ""
215: *
216: ***************************************************************************/
217:
218: BOOL
219: DrvCreateServicesNode(LPTSTR DriverName,
220: SOUND_KERNEL_MODE_DRIVER_TYPE DriverType,
221: PREG_ACCESS RegAccess,
222: BOOL Create)
223: {
224: SERVICE_STATUS ServiceStatus;
225: SC_HANDLE ServiceHandle; // Handle to our driver 'service'
226:
227: RegAccess->DriverName = DriverName;
228:
229: //
230: // See if we can open the registry
231: //
232:
233: if (RegAccess->ServiceManagerHandle == NULL) {
234: RegAccess->ServiceManagerHandle =
235: OpenSCManager(
236: NULL, // This machine
237: NULL, // The active database
238: SC_MANAGER_ALL_ACCESS); // We want to create and change
239:
240: if (RegAccess->ServiceManagerHandle == NULL) {
241: return FALSE;
242: }
243: }
244:
245: //
246: // Open our particular service
247: //
248:
249: ServiceHandle = DrvOpenService(RegAccess);
250:
251: //
252: // See if that worked
253: //
254:
255: if (ServiceHandle == NULL &&
256: GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST) {
257: if (Create) {
258: SC_LOCK ServicesDatabaseLock;
259: TCHAR ServiceName[MAX_PATH];
260: TCHAR BinaryPath[MAX_PATH];
261:
262: wcscpy(BinaryPath, STR_DRIVERS_DIR);
263: wcscat(BinaryPath, DriverName);
264: wcscat(BinaryPath, STR_SYS_EXT);
265:
266: wcscpy(ServiceName, STR_DRIVER);
267: wcscat(ServiceName, DriverName);
268:
269: /*
270: * Lock the service controller database to avoid deadlocks
271: * we have to loop because we can't wait
272: */
273:
274:
275: for (ServicesDatabaseLock = NULL;
276: (ServicesDatabaseLock =
277: LockServiceDatabase(RegAccess->ServiceManagerHandle))
278: == NULL;
279: Sleep(100)) {
280: }
281:
282:
283: /*
284: * Create the service
285: */
286:
287:
288: ServiceHandle =
289: CreateService(
290: RegAccess->ServiceManagerHandle,
291: DriverName, // Service name
292: NULL, // ???
293: SERVICE_ALL_ACCESS, // Full access
294: SERVICE_KERNEL_DRIVER, // Kernel driver
295: SERVICE_DEMAND_START, // Start at sys start
296: SERVICE_ERROR_NORMAL, // Not a disaster if fails
297: BinaryPath, // Default path
298:
299: DriverType == SoundDriverTypeSynth ?
300: STR_SYNTH_GROUP : // Driver group
301: STR_BASE_GROUP,
302: NULL, // do not want TAG information
303: TEXT("\0"), // No dependencies
304: NULL, // ServiceName, // Driver object - optional
305: NULL); // No password
306:
307: UnlockServiceDatabase(ServicesDatabaseLock);
308: #if DBG
309: if (ServiceHandle == NULL) {
310: TCHAR buf[100];
311: wsprintf(buf, TEXT("CreateService failed code %d\n"), GetLastError());
312: OutputDebugString(buf);
313: }
314: #endif
315:
316: }
317: }
318:
319: //
320: // Check at least that it's a device driver
321: //
322:
323: if (ServiceHandle != NULL) {
324: if (!QueryServiceStatus(
325: ServiceHandle,
326: &ServiceStatus) ||
327: ServiceStatus.dwServiceType != SERVICE_KERNEL_DRIVER) {
328:
329: //
330: // Doesn't look like ours
331: //
332:
333: CloseServiceHandle(RegAccess->ServiceManagerHandle);
334: RegAccess->ServiceManagerHandle = NULL;
335: DrvCloseService(RegAccess, ServiceHandle);
336: return FALSE;
337: }
338:
339: }
340:
341: if (ServiceHandle == NULL) {
342: //
343: // Leave the SC manager handle open. We use the presence of this
344: // handle to test whether the driver can be configured (ie whether we
345: // have the access rights to get into the SC manager).
346: //
347:
348: return FALSE;
349: } else {
350: //
351: // We can't keep this handle open (even though we'd like to) because
352: // we need write access to the registry node created so that
353: // we can add device parameters
354: //
355:
356: DrvCloseService(RegAccess, ServiceHandle);
357: return TRUE;
358: }
359: }
360:
361:
362: /***************************************************************************
363: *
364: * Function :
365: * DrvCloseServicesNode
366: *
367: * Parameters :
368: * ServiceNodeKey
369: *
370: * Return code :
371: *
372: * Standard error code (see winerror.h)
373: *
374: * Description :
375: *
376: * Close our handle
377: *
378: ***************************************************************************/
379:
380: VOID
381: DrvCloseServiceManager(
382: PREG_ACCESS RegAccess)
383: {
384: if (RegAccess->ServiceManagerHandle != NULL) {
385: CloseServiceHandle(RegAccess->ServiceManagerHandle);
386: RegAccess->ServiceManagerHandle = NULL;
387: }
388: }
389:
390: /***************************************************************************
391: *
392: * Function :
393: * DrvDeleteServicesNode
394: *
395: * Parameters :
396: * DeviceName
397: *
398: * Return code :
399: *
400: * TRUE = success, FALSE = failed
401: *
402: * Description :
403: *
404: * Delete our node using the handle proviced
405: *
406: ***************************************************************************/
407:
408: BOOL
409: DrvDeleteServicesNode(
410: PREG_ACCESS RegAccess)
411: {
412: BOOL Success;
413: SC_LOCK ServicesDatabaseLock;
414: SC_HANDLE ServiceHandle;
415: HKEY NodeHandle;
416:
417: NodeHandle = DrvOpenRegKey(RegAccess->DriverName);
418:
419: //
420: // Make sure we're not accessing the registry ourselves and
421: // that there aren't any subkeys
422: //
423:
424: if (NodeHandle) {
425: RegDeleteKey(NodeHandle, STR_DEVICE_DATA);
426: RegFlushKey(NodeHandle);
427: RegCloseKey(NodeHandle);
428: }
429:
430: //
431: // Delete the service node and free tha handle
432: // (Note the service cannot be deleted until all handles are closed)
433: //
434:
435: ServiceHandle = DrvOpenService(RegAccess);
436:
437: if (ServiceHandle == NULL) {
438: LONG Error;
439: Error = GetLastError();
440: if (Error == ERROR_SERVICE_DOES_NOT_EXIST) {
441: //
442: // It's already gone !
443: //
444: return TRUE;
445: } else {
446: return FALSE; // It was there but something went wrong
447: }
448: }
449:
450: /*
451: * Lock the service controller database to avoid deadlocks
452: * we have to loop because we can't wait
453: */
454:
455:
456: for (ServicesDatabaseLock = NULL;
457: (ServicesDatabaseLock =
458: LockServiceDatabase(RegAccess->ServiceManagerHandle))
459: == NULL;
460: Sleep(100)) {
461: }
462:
463: Success = DeleteService(ServiceHandle);
464:
465: UnlockServiceDatabase(ServicesDatabaseLock);
466:
467: DrvCloseService(RegAccess, ServiceHandle);
468:
469: return Success;
470: }
471:
472:
473: /***************************************************************************
474: *
475: * Function :
476: * DrvSetDeviceParameter
477: *
478: * Parameters :
479: * ServiceNodeKey Handle to the device services node key
480: * ValueName Name of value to set
481: * Value DWORD value to set
482: *
483: * Return code :
484: *
485: * Standard error code (see winerror.h)
486: *
487: * Description :
488: *
489: * Add the value to the device parameters section under the
490: * services node.
491: * This section is created if it does not already exist.
492: *
493: ***************************************************************************/
494:
495: LONG
496: DrvSetDeviceParameter(
497: PREG_ACCESS RegAccess,
498: LPTSTR ValueName,
499: DWORD Value)
500: {
501: HKEY ServiceNodeKey;
502: HKEY ParmsKey;
503: LONG ReturnCode;
504:
505: ServiceNodeKey = DrvOpenRegKey(RegAccess->DriverName);
506:
507: if (ServiceNodeKey == NULL) {
508: return ERROR_FILE_NOT_FOUND;
509: }
510:
511: //
512: // First try to get a handle to the parameters subkey - which may
513: // involve creating the subkey
514: //
515:
516: ReturnCode = RegCreateKey(ServiceNodeKey, STR_DEVICE_DATA, &ParmsKey);
517:
518: RegCloseKey(ServiceNodeKey);
519:
520: if (ReturnCode != ERROR_SUCCESS) {
521: return ReturnCode;
522: }
523:
524: //
525: // Write the value
526: //
527:
528:
529: ReturnCode = RegSetValueEx(ParmsKey, // Registry handle
530: ValueName, // Name of item
531: 0, // Reserved 0
532: REG_DWORD, // Data type
533: (LPBYTE)&Value, // The value
534: sizeof(Value)); // Data length
535:
536: //
537: // Free the handles we created
538: //
539:
540: RegCloseKey(ParmsKey);
541:
542: return ReturnCode;
543: }
544:
545: /***************************************************************************
546: *
547: * Function :
548: * DrvCreateParamsKey
549: *
550: * Parameters :
551: * RegAccess Registry access info
552: *
553: * Return code :
554: *
555: * Standard error code (see winerror.h)
556: *
557: * Description :
558: *
559: * Create the device parameters section under the
560: * services node if it does not already exist. No values are
561: * written to the key.
562: *
563: ***************************************************************************/
564:
565: LONG
566: DrvCreateParamsKey(
567: PREG_ACCESS RegAccess)
568: {
569: HKEY ServiceNodeKey;
570: HKEY ParmsKey;
571: LONG ReturnCode;
572:
573: ServiceNodeKey = DrvOpenRegKey(RegAccess->DriverName);
574:
575: if (ServiceNodeKey == NULL) {
576: return ERROR_FILE_NOT_FOUND;
577: }
578:
579: //
580: // Try to get a handle to the parameters subkey - which may
581: // involve creating the subkey
582: //
583:
584: ReturnCode = RegCreateKey(ServiceNodeKey, STR_DEVICE_DATA, &ParmsKey);
585:
586: RegCloseKey(ServiceNodeKey);
587:
588: if (ReturnCode == ERROR_SUCCESS) {
589: RegCloseKey(ParmsKey);
590: }
591:
592: return ReturnCode;
593:
594: }
595:
596: /***************************************************************************
597: *
598: * Function :
599: * DrvQueryDeviceParameter
600: *
601: * Parameters :
602: * ServiceNodeKey Handle to the device services node key
603: * ValueName Name of value to query
604: * pValue Returned value
605: *
606: * Return code :
607: *
608: * Standard error code (see winerror.h)
609: *
610: * Description :
611: *
612: * Add the value to the device parameters section under the
613: * services node.
614: * This section is created if it does not already exist.
615: *
616: ***************************************************************************/
617:
618: LONG
619: DrvQueryDeviceParameter(
620: PREG_ACCESS RegAccess,
621: LPTSTR ValueName,
622: PDWORD pValue)
623: {
624: HKEY ServiceNodeKey;
625: HKEY ParmsKey;
626: LONG ReturnCode;
627: DWORD Index;
628:
629: ServiceNodeKey = DrvOpenRegKey(RegAccess->DriverName);
630:
631: if (ServiceNodeKey == NULL) {
632: return ERROR_FILE_NOT_FOUND;
633: }
634:
635: //
636: // First try to get a handle to the parameters subkey
637: //
638:
639: ReturnCode = RegOpenKey(ServiceNodeKey, STR_DEVICE_DATA, &ParmsKey);
640: RegCloseKey(ServiceNodeKey);
641:
642: if (ReturnCode != ERROR_SUCCESS) {
643: return ReturnCode;
644: }
645:
646: //
647: // That was OK
648: // Now we have to laboriously search the key values to
649: // see if one corresponds to the one we want
650: //
651:
652:
653: for (Index = 0; ; Index++) { // Enumerate key values
654:
655: TCHAR ThisValueName[MAX_PATH];
656: DWORD NameLength;
657: DWORD Type;
658: DWORD Value;
659: DWORD ValueLength;
660:
661: NameLength = MAX_PATH;
662: NameLength = sizeof(ThisValueName);
663: ValueLength = sizeof(Value);
664:
665: ReturnCode = RegEnumValue(ParmsKey, // Handle to key
666: Index, // Index of value
667: ThisValueName, // Where to put the name
668: &NameLength, // Length of the name
669: NULL, // Reserved NULL
670: &Type, // returns REG_... type
671: (LPBYTE)&Value, // Where to put the value
672: &ValueLength); // Max length of data
673:
674: if (ReturnCode == ERROR_SUCCESS) {
675: //
676: // We've found something - does it's name match the
677: // name we're looking for ?
678: //
679:
680: if (0 == wcsicmp(ValueName, ThisValueName)) {
681: RegCloseKey(ParmsKey);
682:
683: //
684: // If it's the wrong type there's something
685: // wrong !!
686: //
687:
688: if (Type == REG_DWORD) {
689:
690: //
691: // Return Value to caller
692: //
693:
694: *pValue = Value;
695: return ERROR_SUCCESS;
696: } else {
697: return ERROR_FILE_NOT_FOUND;
698: }
699: }
700: } else {
701: //
702: // We didn't find the value with the name we were
703: // looking for so return the default
704: //
705:
706: RegCloseKey(ParmsKey);
707: return ReturnCode;
708: }
709: }
710: }
711:
712:
713: /***************************************************************************
714: *
715: * Function :
716: * DrvLoadKernelDriver
717: *
718: * Parameters :
719: * Drivername Name of driver to load
720: *
721: * Return code :
722: *
723: * TRUE if successful, otherwise FALSE
724: *
725: * Description :
726: *
727: * Call StartService to load the driver. This assumes the services
728: * name is the driver name
729: *
730: ***************************************************************************/
731:
732: BOOL
733: DrvLoadKernelDriver(
734: PREG_ACCESS RegAccess)
735: {
736: SC_HANDLE ServiceHandle;
737: BOOL Success;
738: ServiceHandle = DrvOpenService(RegAccess);
739:
740: if (ServiceHandle == NULL) {
741: return FALSE;
742: }
743:
744: /*
745: * StartService causes the system to try to load the kernel driver
746: */
747:
748: Success = StartService(ServiceHandle, 0, NULL);
749:
750: /*
751: * If this was successful we can change the start type to system
752: * start
753: */
754:
755: if (Success) {
756: Success = ChangeServiceConfig(ServiceHandle,
757: SERVICE_NO_CHANGE,
758: SERVICE_SYSTEM_START,
759: SERVICE_NO_CHANGE,
760: NULL,
761: NULL,
762: NULL,
763: NULL,
764: NULL,
765: NULL,
766: NULL);
767: }
768: DrvCloseService(RegAccess, ServiceHandle);
769: return Success;
770: }
771:
772: /***************************************************************************
773: *
774: * Function :
775: * DrvUnLoadKernelDriver
776: *
777: * Parameters :
778: * RegAccess Access variables to registry and Service control
779: * manager
780: *
781: * Return code :
782: *
783: * TRUE if successful, otherwise FALSE
784: *
785: * Description :
786: *
787: * Call ControlService to unload the driver. This assumes the services
788: * name is the driver name
789: *
790: ***************************************************************************/
791:
792: BOOL
793: DrvUnloadKernelDriver(
794: PREG_ACCESS RegAccess)
795: {
796: SERVICE_STATUS ServiceStatus;
797: SC_HANDLE ServiceHandle;
798: BOOL Success;
799:
800:
801: ServiceHandle = DrvOpenService(RegAccess);
802: if (ServiceHandle == NULL) {
803: return GetLastError() == ERROR_SERVICE_DOES_NOT_EXIST;
804: }
805:
806: /*
807: * Set it not to load at system start until we've reconfigured
808: */
809:
810: Success = ChangeServiceConfig(ServiceHandle,
811: SERVICE_NO_CHANGE,
812: SERVICE_DEMAND_START,
813: SERVICE_NO_CHANGE,
814: NULL,
815: NULL,
816: NULL,
817: NULL,
818: NULL,
819: NULL,
820: NULL);
821:
822: if (Success) {
823: /*
824: * Don't try to unload if it's not loaded
825: */
826:
827: if (DrvIsDriverLoaded(RegAccess)) {
828:
829: /*
830: * Note that the driver object name will not be found if
831: * the driver is not loaded. However, the services manager may
832: * get in first and decide that the driver file does not exist.
833: */
834:
835: Success = ControlService(ServiceHandle,
836: SERVICE_CONTROL_STOP,
837: &ServiceStatus);
838:
839: }
840:
841: }
842:
843: DrvCloseService(RegAccess, ServiceHandle);
844: return Success;
845: }
846:
847: /***************************************************************************
848: *
849: * Function :
850: *
851: * DrvIsDriverLoaded
852: *
853: * Parameters :
854: *
855: * RegAccess Access variables to registry and Service control
856: * manager
857: *
858: * Return code :
859: *
860: * TRUE if successful, otherwise FALSE
861: *
862: * Description :
863: *
864: * See if a service by our name is started.
865: * Note - this assumes that we think our service is installed
866: *
867: ***************************************************************************/
868: BOOL
869: DrvIsDriverLoaded(
870: PREG_ACCESS RegAccess)
871: {
872: SERVICE_STATUS ServiceStatus;
873: SC_HANDLE ServiceHandle;
874: BOOL Success;
875: ServiceHandle = DrvOpenService(RegAccess);
876: if (ServiceHandle == NULL) {
877: return FALSE;
878: }
879:
880:
881: if (!QueryServiceStatus(ServiceHandle, &ServiceStatus)) {
882: DrvCloseService(RegAccess, ServiceHandle);
883: return FALSE;
884: }
885:
886: Success = ServiceStatus.dwServiceType == SERVICE_KERNEL_DRIVER &&
887: ServiceStatus.dwCurrentState == SERVICE_RUNNING;
888:
889: DrvCloseService(RegAccess, ServiceHandle);
890: return Success;
891: }
892:
893:
894: /***************************************************************************
895: *
896: * Function :
897: *
898: * DrvConfigureDriver
899: *
900: * Parameters :
901: *
902: * RegAccess Access variables to registry and Service control
903: * manager
904: *
905: * DriverName Name of the driver
906: *
907: * DriverType Type of driver (see registry.h)
908: *
909: * SetParms Callback to set the registry parameters
910: *
911: * Context Context value for callback
912: *
913: * Return code :
914: *
915: * TRUE if successful, otherwise FALSE
916: *
917: * Description :
918: *
919: * Performs the necessary operations to (re) configure a driver :
920: *
921: * 1. If the driver is already installed :
922: *
923: * Unload it if necessary
924: *
925: * Set its start type to Demand until we know we're safe
926: * (This is so the system won't load a bad config if we crash)
927: *
928: * 2. If the driver is not installed create its service entry in the
929: * registry.
930: *
931: * 3. Run the callback to set up the driver's parameters
932: *
933: * 4. Load the driver
934: *
935: * 5. If the load returns success set the start type to System start
936: *
937: ***************************************************************************/
938:
939: BOOL DrvConfigureDriver(
940: PREG_ACCESS RegAccess,
941: LPTSTR DriverName,
942: SOUND_KERNEL_MODE_DRIVER_TYPE
943: DriverType,
944: BOOL (* SetParms )(PVOID),
945: PVOID Context)
946: {
947: return
948:
949: /*
950: * If there isn't a services node create one - this is done first
951: * because this is how the driver name gets into the REG_ACCESS
952: * structure
953: */
954:
955: DrvCreateServicesNode(
956: DriverName,
957: DriverType,
958: RegAccess,
959: TRUE)
960:
961: &&
962:
963: /*
964: * Unload driver if it's loaded
965: */
966:
967: DrvUnloadKernelDriver(RegAccess)
968:
969: &&
970:
971: /*
972: * Run the callback
973: */
974:
975: (SetParms == NULL || (*SetParms)(Context))
976:
977: &&
978:
979: /*
980: * Try reloading the driver
981: */
982:
983: DrvLoadKernelDriver(RegAccess)
984:
985: ;
986:
987: }
988:
989:
990: /***************************************************************************
991: *
992: * Function :
993: *
994: * DrvRemoveDriver
995: *
996: * Parameters :
997: *
998: * RegAccess Access variables to registry and Service control
999: * manager
1000: *
1001: * Return code :
1002: *
1003: * DRVCNF_CANCEL - Error occurred
1004: *
1005: * DRVCNF_OK - Registry entry delete but driver wasn't loaded
1006: *
1007: * DRVCNF_RESTART - Driver unloaded and registry entry deleted
1008: *
1009: * Description :
1010: *
1011: * Unload the driver and remove its service control entry
1012: *
1013: ***************************************************************************/
1014:
1015: LRESULT DrvRemoveDriver(
1016: PREG_ACCESS RegAccess)
1017: {
1018: BOOL Loaded;
1019:
1020: Loaded = DrvIsDriverLoaded(RegAccess);
1021:
1022: if ((!Loaded || DrvUnloadKernelDriver(RegAccess)) &&
1023: DrvDeleteServicesNode(RegAccess)) {
1024: return Loaded ? DRVCNF_RESTART : DRVCNF_OK;
1025: } else {
1026: return DRVCNF_CANCEL;
1027: }
1028: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.