![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to msregdb.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [WindowsNT SDKs] / mstools / mssetup / sample|
Return to msregdb.c CVS log | Up to [WindowsNT SDKs] / mstools / mssetup / sample |
1.1 root 1: #ifndef STF_LITE
2: #include <windows.h>
3: #ifdef WIN32
4: #include <malloc.h>
5: #endif
6: #include "setupapi.h"
7: #include "msregdb.h"
8:
9: HANDLE hinstDLL = NULL;
10:
11: #ifdef WIN16
12: typedef LONG (APIENTRY *LPFNRCLK)(LONG);
13: typedef LONG (APIENTRY *LPFNRCRK)(LONG, LPSTR, LPSTR);
14: typedef LONG (APIENTRY *LPFNRDLK)(LONG, LPSTR);
15: typedef LONG (APIENTRY *LPFNROPK)(LONG, LPSTR, LPSTR);
16: typedef LONG (APIENTRY *LPFNRQRV)(LONG, LPSTR, LPSTR, LPSTR);
17: typedef LONG (APIENTRY *LPFNRSTV)(LONG, LPSTR, LONG, LPSTR, LONG);
18:
19: LPFNRCLK lpfnRegCloseKey;
20: LPFNRCRK lpfnRegCreateKey;
21: LPFNRDLK lpfnRegDeleteKey;
22: LPFNROPK lpfnRegOpenKey;
23: LPFNRQRV lpfnRegQueryValue;
24: LPFNRSTV lpfnRegSetValue;
25: #endif
26:
27: #ifdef WIN32
28: typedef LONG (APIENTRY *LPFNRCLK)(HKEY);
29: typedef LONG (APIENTRY *LPFNRCRK)(HKEY, LPCTSTR, PHKEY);
30: typedef LONG (APIENTRY *LPFNRDLK)(HKEY, LPCTSTR);
31: typedef LONG (APIENTRY *LPFNROPK)(HKEY, LPCTSTR, PHKEY);
32: typedef LONG (APIENTRY *LPFNRQRV)(HKEY, LPCTSTR, LPTSTR, PLONG);
33: typedef LONG (APIENTRY *LPFNRSTV)(HKEY, LPCTSTR, DWORD, LPTSTR, DWORD);
34: typedef LONG (APIENTRY *LPFNRCRKe)(HKEY, LPCTSTR, DWORD, LPTSTR, DWORD,
35: REGSAM, LPSECURITY_ATTRIBUTES, PHKEY, LPDWORD);
36: typedef LONG (APIENTRY *LPFNROPKe)(HKEY, LPCTSTR, DWORD, REGSAM, PHKEY);
37: typedef LONG (APIENTRY *LPFNRQRVe)(HKEY, LPTSTR, LPDWORD, LPDWORD, LPBYTE, LPDWORD);
38: typedef LONG (APIENTRY *LPFNRSTVe)(HKEY, LPCTSTR, DWORD, DWORD, LPBYTE, DWORD);
39: typedef LONG (APIENTRY *LPFNREK)(HKEY, DWORD, LPTSTR, LPDWORD);
40: typedef LONG (APIENTRY *LPFNRQIK)(HKEY, LPTSTR, LPDWORD, LPDWORD, LPDWORD,
41: LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, LPDWORD, PFILETIME);
42:
43: LPFNRCLK lpfnRegCloseKey;
44: LPFNRCRK lpfnRegCreateKey;
45: LPFNRDLK lpfnRegDeleteKey;
46: LPFNROPK lpfnRegOpenKey;
47: LPFNRQRV lpfnRegQueryValue;
48: LPFNRSTV lpfnRegSetValue;
49: LPFNRCRKe lpfnRegCreateKeyEx;
50: LPFNROPKe lpfnRegOpenKeyEx;
51: LPFNRQRVe lpfnRegQueryValueEx;
52: LPFNRSTVe lpfnRegSetValueEx;
53: LPFNREK lpfnRegEnumKey;
54: LPFNRQIK lpfnRegQueryInfoKey;
55: #endif
56:
57: // **************************************************************************
58: void CreateRegKey(LPSTR szKey)
59: {
60: HKEY hKey;
61: INT i;
62:
63: if ((*lpfnRegCreateKey)(HKEY_CLASSES_ROOT, szKey, &hKey)
64: > ERROR_SUCCESS)
65: {
66: i = EercErrorHandler(GRC_API_FAILED, 1, "CreateRegKey", NULL, NULL);
67: #ifdef DEBUG
68: StfApiErr(saeFail, "CreateRegKey", szKey);
69: #endif // DEBUG
70: SetupError(STFERR);
71: }
72:
73: if ((*lpfnRegCloseKey)(hKey) > ERROR_SUCCESS)
74: {
75: i = EercErrorHandler(GRC_API_FAILED, 1, "CreateRegKey", NULL, NULL);
76: #ifdef DEBUG
77: StfApiErr(saeFail, "CreateRegKey", szKey);
78: #endif // DEBUG
79: SetupError(STFERR);
80: }
81: }
82:
83:
84: // **************************************************************************
85: void CreateRegKeyValue(LPSTR szKey, LPSTR szValue)
86: {
87: if ((*lpfnRegSetValue)(HKEY_CLASSES_ROOT, (LPCTSTR)szKey, REG_SZ, szValue,
88: lstrlen(szKey)) > ERROR_SUCCESS)
89: {
90: EercErrorHandler(GRC_API_FAILED, 1, "CreateRegKeyValue", NULL, NULL);
91: #ifdef DEBUG
92: StfApiErr(saeFail, "CreateRegKeyValue",SzCat2Str((LPSTR)szKey,", ",(LPSTR)szValue));
93: #endif // DEBUG
94: SetupError(STFERR);
95: }
96: }
97:
98:
99: // **************************************************************************
100: INT DoesRegKeyExist(LPSTR szKey)
101: {
102: HKEY hKey;
103:
104: if ((*lpfnRegOpenKey)(HKEY_CLASSES_ROOT, szKey, &hKey)
105: != ERROR_SUCCESS)
106: return(0);
107:
108: (*lpfnRegCloseKey)(hKey);
109:
110: return(1);
111: }
112:
113:
114: // **************************************************************************
115: void SetRegKeyValue(LPSTR szKey, LPSTR szValue)
116: {
117: if ((*lpfnRegSetValue)(HKEY_CLASSES_ROOT, szKey, REG_SZ, szValue,
118: lstrlen(szKey)) > ERROR_SUCCESS)
119: {
120: EercErrorHandler(GRC_API_FAILED, 1, "SetRegKeyValue", NULL, NULL);
121: #ifdef DEBUG
122: StfApiErr(saeFail, "SetRegKeyValue", SzCat2Str((LPSTR)szKey, ", ", (LPSTR)szValue));
123: #endif // DEBUG
124: SetupError(STFERR);
125: }
126: }
127:
128:
129: // **************************************************************************
130: LPSTR GetRegKeyValue(LPSTR szKey, LPSTR szBuf, INT cbBuf)
131: {
132: LONG cb = cbBuf;
133:
134: if (szBuf != NULL && cbBuf > 0)
135: *szBuf = '\0';
136:
137: if (!DoesRegKeyExist(szKey))
138: return(szBuf);
139:
140: if ((*lpfnRegQueryValue)(HKEY_CLASSES_ROOT, szKey, szBuf, &cb)
141: != ERROR_SUCCESS)
142: {
143: EercErrorHandler(GRC_API_FAILED, 1, "SetRegKeyValue", NULL, NULL);
144: #ifdef DEBUG
145: StfApiErr(saeFail, "GetRegKeyValue", szKey);
146: #endif // DEBUG
147: SetupError(STFERR);
148: }
149:
150: if (cb > cbBuf)
151: {
152: DoMsgBox("Buffer Overflow", "MS-Setup Error", MB_ICONHAND+MB_OK);
153: SetupError(STFERR);
154: }
155: *(szBuf + cb) = '\0';
156:
157: return(szBuf);
158: }
159:
160:
161: // **************************************************************************
162: void DeleteRegKey(LPSTR szKey)
163: {
164: #ifdef WIN16
165: (*lpfnRegDeleteKey)(HKEY_CLASSES_ROOT, szKey);
166: #elif defined(WIN32)
167: if (DoesRegKeyExistEx(HKEY_CLASSES_ROOT, szKey))
168: {
169: //
170: // The Win32 "RegDeleteKey()" function will not delete a key
171: // that has existing subkeys (unlike the Win16 version).
172: // DeleteAllSubkeys is a recursive function that removes a
173: // complete "tree" of registry keys.
174: //
175: if (!DeleteAllSubKeys(HKEY_CLASSES_ROOT, (LPCTSTR)szKey))
176: {
177: EercErrorHandler(GRC_API_FAILED, 1, "DeleteAllSubKeys", NULL, NULL);
178: #ifdef DEBUG
179: StfApiErr(saeFail, "DeleteAllSubKeys", (LPSTR)szKey);
180: #endif // DEBUG
181: SetupError(STFERR);
182: }
183: }
184: #endif
185: }
186:
187:
188:
189: #ifdef WIN32
190:
191: //
192: // All the functions that follow are "extended" functions for
193: // Win32. They are not limited to the HKEY_CLASSES_ROOT key
194: // as the original Setup Toolkit functions are.
195: //
196:
197: BOOL DeleteAllSubKeys(HKEY hKey, LPCTSTR szKey)
198: {
199: HKEY hKey2;
200: TCHAR ClassStr[128];
201: LPTSTR szClass = ClassStr;
202: LPTSTR szSubKey;
203: LPTSTR szFullSubKey;
204: LONG lResult;
205: DWORD cchClass, dwNumSubKeys, cchMaxSubKey, cchMaxClass,
206: cValues, cchMaxValName, cbMaxValData, cbSecurityDescriptor;
207: DWORD i, cchName;
208: FILETIME ftLastWrite;
209:
210: if ((lResult = (*lpfnRegOpenKeyEx)(hKey, szKey,
211: 0, KEY_READ, &hKey2)) > ERROR_SUCCESS)
212: {
213: EercErrorHandler(GRC_API_FAILED, 1, "DeleteAllSubKeys:open", NULL, NULL);
214: #ifdef DEBUG
215: StfApiErr(saeFail, "DeleteAllSubKeys:open", (LPSTR)szKey);
216: #endif // DEBUG
217: return(FALSE);
218: }
219:
220: //
221: // First, see how many subkeys this key has.
222: //
223: cchClass=128;
224: if ((lResult = (*lpfnRegQueryInfoKey)(hKey2, szClass, &cchClass, NULL, &dwNumSubKeys,
225: &cchMaxSubKey, &cchMaxClass, &cValues, &cchMaxValName,
226: &cbMaxValData, &cbSecurityDescriptor, &ftLastWrite)) != ERROR_SUCCESS)
227: {
228: (*lpfnRegCloseKey)(hKey2);
229: return(FALSE);
230: }
231:
232: //
233: // if this key has no subkeys at all, we can remove
234: // it immediately and finish.
235: //
236: if (dwNumSubKeys == 0)
237: {
238: (*lpfnRegCloseKey)(hKey2);
239: lResult = (*lpfnRegDeleteKey)(hKey, szKey);
240: }
241: else
242: {
243: //
244: // This key has subkeys; we'll need to enumerate them
245: // and "zap" each one in turn.
246: //
247: // RegQueryInfoKey() has indicated what the maximum length
248: // of a subkey name will be for this particular key
249: // in "cchMaxSubKey", so we can allocate just what we
250: // need to hold the names.
251: //
252: szSubKey = (LPTSTR)malloc((cchMaxSubKey+1) * sizeof(TCHAR));
253: szFullSubKey = (LPTSTR)malloc((cchMaxSubKey + lstrlen(szKey) + 2)*sizeof(TCHAR));
254:
255: for (i = dwNumSubKeys; i > 0; i--)
256: {
257: cchName = cchMaxSubKey;
258: if ((lResult = (*lpfnRegEnumKey)(hKey2, i - 1,
259: szSubKey, &cchName)) == ERROR_SUCCESS)
260: {
261: //
262: // Construct the full hierarchical key name, and
263: // nuke it.
264: // (RegEnumKey just returns the name of the subkey)
265: //
266: wsprintf(szFullSubKey, "%s\\%s", szKey, szSubKey);
267: if (!DeleteAllSubKeys(hKey, szFullSubKey))
268: {
269: (*lpfnRegCloseKey)(hKey2);
270: free(szSubKey);
271: free(szFullSubKey);
272: return(FALSE);
273: }
274: }
275: else
276: {
277: if (lResult != ERROR_NO_MORE_ITEMS)
278: {
279: // Usually, you only see NO_MORE_ITEMS
280: // when you're counting up from 0 and
281: // gone past the end.
282: // Some other tragedy has befallen us.
283: //
284: EercErrorHandler(GRC_API_FAILED, 1, "DeleteAllSubKeys:enum", NULL, NULL);
285: #ifdef DEBUG
286: StfApiErr(saeFail, "DeleteAllSubKeys:Enum", (LPSTR)szKey);
287: #endif // DEBUG
288: (*lpfnRegCloseKey)(hKey2);
289: free(szSubKey);
290: free(szFullSubKey);
291: return(FALSE);
292: }
293: }
294: }
295: //
296: // Now that the count of subkeys is down to 0, we
297: // can delete ourselves.
298: //
299: (*lpfnRegCloseKey)(hKey2);
300: lResult = (*lpfnRegDeleteKey)(hKey, szKey);
301: free(szSubKey);
302: free(szFullSubKey);
303: }
304: return(TRUE);
305: }
306:
307: // **************************************************************************
308: void CreateRegKeyEx(HKEY hKey, LPCSTR szKey)
309: {
310: HKEY hKey2;
311: INT i;
312:
313: if ((*lpfnRegCreateKey)(hKey, szKey, &hKey2)
314: > ERROR_SUCCESS)
315: {
316: i = EercErrorHandler(GRC_API_FAILED, 1, "CreateRegKeyEx", NULL, NULL);
317: #ifdef DEBUG
318: StfApiErr(saeFail, "CreateRegKeyEx", (LPSTR)szKey);
319: #endif // DEBUG
320: SetupError(STFERR);
321: }
322:
323: if ((*lpfnRegCloseKey)(hKey2) > ERROR_SUCCESS)
324: {
325: i = EercErrorHandler(GRC_API_FAILED, 1, "CreateRegKeyEx", NULL, NULL);
326: #ifdef DEBUG
327: StfApiErr(saeFail, "CreateRegKeyEx", (LPSTR)szKey);
328: #endif // DEBUG
329: SetupError(STFERR);
330: }
331: }
332:
333:
334: // **************************************************************************
335: void CreateRegKeyValueEx(HKEY hKey, LPCTSTR szKey,
336: LPTSTR szValueName, DWORD dwType,
337: LPBYTE lpValueData, DWORD dwDataLen)
338: {
339: HKEY hKey2;
340:
341: if ((*lpfnRegOpenKeyEx)(hKey, szKey, 0, KEY_WRITE, &hKey2) > ERROR_SUCCESS)
342: {
343: EercErrorHandler(GRC_API_FAILED, 1, "CreateRegKeyValueEx:open", NULL, NULL);
344: #ifdef DEBUG
345: StfApiErr(saeFail, "CreateRegKeyValueEx:open", SzCat2Str((LPSTR)szKey, ", ", (LPSTR)szValueName));
346: #endif // DEBUG
347: SetupError(STFERR);
348: }
349:
350: if ((*lpfnRegSetValueEx)(hKey2, szValueName, 0, dwType, lpValueData,
351: dwDataLen) > ERROR_SUCCESS)
352: {
353: EercErrorHandler(GRC_API_FAILED, 1, "CreateRegKeyValueEx", NULL, NULL);
354: #ifdef DEBUG
355: StfApiErr(saeFail, "CreateRegKeyValueEx", SzCat2Str((LPSTR)szKey, ", ", (LPSTR)szValueName));
356: #endif // DEBUG
357: SetupError(STFERR);
358: }
359: }
360:
361:
362: // **************************************************************************
363: INT DoesRegKeyExistEx(HKEY hKey, LPCSTR szKey)
364: {
365: HKEY hKey2;
366:
367: if ((*lpfnRegOpenKey)(hKey, szKey, &hKey2)
368: != ERROR_SUCCESS)
369: return(0);
370:
371: (*lpfnRegCloseKey)(hKey2);
372:
373: return(1);
374: }
375:
376:
377: // **************************************************************************
378: void SetRegKeyValueEx(HKEY hKey, LPCTSTR szKey,
379: LPTSTR szValueName, DWORD dwType,
380: LPBYTE lpValueData, DWORD dwDataLen)
381: {
382: HKEY hKey2;
383:
384: if ((*lpfnRegOpenKeyEx)(hKey, szKey, 0, KEY_WRITE, &hKey2) > ERROR_SUCCESS)
385: {
386: EercErrorHandler(GRC_API_FAILED, 1, "SetRegKeyValueEx:open", NULL, NULL);
387: #ifdef DEBUG
388: StfApiErr(saeFail, "SetRegKeyValueEx:open", SzCat2Str((LPSTR)szKey, ", ", (LPSTR)szValueName));
389: #endif // DEBUG
390: SetupError(STFERR);
391: }
392:
393: if ((*lpfnRegSetValueEx)(hKey2, szValueName, 0, dwType, lpValueData,
394: dwDataLen) > ERROR_SUCCESS)
395: {
396: EercErrorHandler(GRC_API_FAILED, 1, "SetRegKeyValueEx", NULL, NULL);
397: #ifdef DEBUG
398: StfApiErr(saeFail, "SetRegKeyValueEx", SzCat2Str((LPSTR)szKey, ", ", (LPSTR)szValueName));
399: #endif // DEBUG
400: SetupError(STFERR);
401: }
402: }
403:
404:
405: // **************************************************************************
406: LONG GetRegKeyValueEx(HKEY hKey, LPCTSTR szKey, LPTSTR szValueName, LPDWORD lpdwType, LPBYTE lpBuf, DWORD cbBuf)
407: {
408: HKEY hKey2;
409: DWORD cb = cbBuf;
410: LONG lRetVal;
411:
412: if (!DoesRegKeyExistEx(hKey, szKey))
413: return(ERROR_BADKEY);
414:
415: if ((*lpfnRegOpenKeyEx)(hKey, szKey, 0, KEY_READ, &hKey2) > ERROR_SUCCESS)
416: {
417: EercErrorHandler(GRC_API_FAILED, 1, "GetRegKeyValueEx", NULL, NULL);
418: #ifdef DEBUG
419: StfApiErr(saeFail, "GetRegKeyValueEx", SzCat2Str((LPSTR)szKey, ", ", (LPSTR)szValueName));
420: #endif // DEBUG
421: SetupError(STFERR);
422: }
423:
424: if ((*lpfnRegQueryValueEx)(hKey2, (LPTSTR)szValueName, NULL,
425: lpdwType, lpBuf, &cb)
426: != ERROR_SUCCESS)
427: {
428: EercErrorHandler(GRC_API_FAILED, 1, "SetRegKeyValueEx", NULL, NULL);
429: #ifdef DEBUG
430: StfApiErr(saeFail, "GetRegKeyValueEx", (LPSTR)szKey);
431: #endif // DEBUG
432: SetupError(STFERR);
433: }
434:
435: if (cb > cbBuf)
436: {
437: DoMsgBox("Buffer Overflow", "MS-Setup Error", MB_ICONHAND+MB_OK);
438: SetupError(STFERR);
439: lRetVal = ERROR_MORE_DATA;
440: }
441: else
442: lRetVal = ERROR_SUCCESS;
443:
444: return(lRetVal);
445: }
446:
447:
448: // **************************************************************************
449: void DeleteRegKeyEx(HKEY hKey, LPCTSTR szKey)
450: {
451: if (DoesRegKeyExistEx(hKey, szKey))
452: {
453: //
454: // DeleteAllSubkeys is a recursive function that removes a
455: // key tree from the bottom up. The Win32 "RegDeleteKey()"
456: // function will not delete a key that has existing subkeys.
457: //
458: if (!DeleteAllSubKeys(hKey, szKey))
459: {
460: EercErrorHandler(GRC_API_FAILED, 1, "DeleteAllSubKeys", NULL, NULL);
461: #ifdef DEBUG
462: StfApiErr(saeFail, "DeleteAllSubKeys", (LPSTR)szKey);
463: #endif // DEBUG
464: SetupError(STFERR);
465: }
466: }
467: }
468:
469: #endif
470:
471: // **************************************************************************
472: BOOL FInitRegDb(void)
473: {
474: #ifdef WIN16
475: if ((hinstDLL = LoadLibrary("SHELL.DLL")) == NULL)
476: return(FALSE);
477:
478: if (hinstDLL < 32)
479: {
480: hinstDLL = NULL;
481: return(FALSE);
482: }
483: #elif defined(WIN32)
484: if ((hinstDLL = LoadLibrary("ADVAPI32.DLL")) == NULL)
485: return(FALSE);
486: #endif
487:
488: lpfnRegCloseKey = (LPFNRCLK)GetProcAddress(hinstDLL, "RegCloseKey");
489: #ifdef UNICODE
490: lpfnRegCreateKey = (LPFNRCRK)GetProcAddress(hinstDLL, "RegCreateKeyW");
491: lpfnRegDeleteKey = (LPFNRDLK)GetProcAddress(hinstDLL, "RegDeleteKeyW");
492: lpfnRegOpenKey = (LPFNROPK)GetProcAddress(hinstDLL, "RegOpenKeyW");
493: lpfnRegQueryValue = (LPFNRQRV)GetProcAddress(hinstDLL, "RegQueryValueW");
494: lpfnRegSetValue = (LPFNRSTV)GetProcAddress(hinstDLL, "RegSetValueW");
495: #else
496: lpfnRegCreateKey = (LPFNRCRK)GetProcAddress(hinstDLL, "RegCreateKeyA");
497: lpfnRegDeleteKey = (LPFNRDLK)GetProcAddress(hinstDLL, "RegDeleteKeyA");
498: lpfnRegOpenKey = (LPFNROPK)GetProcAddress(hinstDLL, "RegOpenKeyA");
499: lpfnRegQueryValue = (LPFNRQRV)GetProcAddress(hinstDLL, "RegQueryValueA");
500: lpfnRegSetValue = (LPFNRSTV)GetProcAddress(hinstDLL, "RegSetValueA");
501: #endif
502:
503: if (lpfnRegCloseKey == NULL
504: || lpfnRegCreateKey == NULL
505: || lpfnRegDeleteKey == NULL
506: || lpfnRegOpenKey == NULL
507: || lpfnRegQueryValue == NULL
508: || lpfnRegSetValue == NULL)
509: {
510: FreeLibrary(hinstDLL);
511:
512: hinstDLL = NULL;
513: return(FALSE);
514: }
515:
516: #ifdef WIN32
517: #ifdef UNICODE
518: lpfnRegCreateKeyEx = (LPFNRCRKe)GetProcAddress(hinstDLL, "RegCreateKeyExW");
519: lpfnRegOpenKeyEx = (LPFNROPKe)GetProcAddress(hinstDLL, "RegOpenKeyExW");
520: lpfnRegQueryValueEx = (LPFNRQRVe)GetProcAddress(hinstDLL, "RegQueryValueExW");
521: lpfnRegSetValueEx = (LPFNRSTVe)GetProcAddress(hinstDLL, "RegSetValueExW");
522: lpfnRegEnumKey = (LPFNREK)GetProcAddress(hinstDLL, "RegEnumKeyW");
523: lpfnRegQueryInfoKey = (LPFNRQIK)GetProcAddress(hinstDLL, "RegQueryInfoKeyW");
524: #else
525: lpfnRegCreateKeyEx = (LPFNRCRKe)GetProcAddress(hinstDLL, "RegCreateKeyExA");
526: lpfnRegOpenKeyEx = (LPFNROPKe)GetProcAddress(hinstDLL, "RegOpenKeyExA");
527: lpfnRegQueryValueEx = (LPFNRQRVe)GetProcAddress(hinstDLL, "RegQueryValueExA");
528: lpfnRegSetValueEx = (LPFNRSTVe)GetProcAddress(hinstDLL, "RegSetValueExA");
529: lpfnRegEnumKey = (LPFNREK)GetProcAddress(hinstDLL, "RegEnumKeyA");
530: lpfnRegQueryInfoKey = (LPFNRQIK)GetProcAddress(hinstDLL, "RegQueryInfoKeyA");
531: #endif // UNICODE
532: #endif // WIN32
533:
534: return(TRUE);
535: }
536:
537:
538: // **************************************************************************
539: VOID TerminateRegDb(void)
540: {
541: if (hinstDLL != NULL)
542: {
543: FreeLibrary(hinstDLL);
544:
545: hinstDLL = NULL;
546: }
547: }
548:
549:
550: #endif /* !STF_LITE */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.