Source code of Windows XP (NT5)
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

607 lines
19 KiB

  1. //+-------------------------------------------------------------------------
  2. //
  3. // Microsoft Windows
  4. // Copyright (C) Microsoft Corporation, 1995
  5. //
  6. // File: dclassInfo.cxx
  7. //
  8. // Contents: Display registry class information
  9. //
  10. // Functions: classInfoHelp
  11. // displayclassInfo
  12. //
  13. //
  14. // History: 06-01-95 BruceMa Created
  15. //
  16. //
  17. //--------------------------------------------------------------------------
  18. // DOLATERIFEVER: Add threading model flags
  19. #include <ole2int.h>
  20. #include <windows.h>
  21. #include "ole.h"
  22. #include "dinfolvl.h"
  23. #include "debnot.h"
  24. BOOL ScanCLSID(char *szClsid, CLSID *pClsid);
  25. void FormatCLSID(REFGUID rguid, LPSTR lpsz);
  26. static void GetSomeClsidValues(HKEY hKey,
  27. char *szName,
  28. char *szInprocHandler,
  29. char *szInprocHandler32,
  30. char *szInprocServer,
  31. char *szInprocServer32,
  32. char *szLocalServer,
  33. char *szLocalServer32,
  34. char *szProgid,
  35. char *szTreatAs,
  36. char *szAutoConvertTo,
  37. char *szOle1Class);
  38. static void DisplayValues(PNTSD_EXTENSION_APIS lpExtensionApis,
  39. char *szName,
  40. char *szInprocHandler,
  41. char *szInprocHandler32,
  42. char *szInprocServer,
  43. char *szInprocServer32,
  44. char *szLocalServer,
  45. char *szLocalServer32,
  46. char *szProgid,
  47. char *szTreatAs,
  48. char *szAutoConvertTo,
  49. char *szOle1Class);
  50. static void MungePath(char *szPath);
  51. static DWORD dwRESERVED = 0;
  52. //+-------------------------------------------------------------------------
  53. //
  54. // Function: classInfoHelp
  55. //
  56. // Synopsis: Display a menu for the command 'id'
  57. //
  58. // Arguments: -
  59. //
  60. // Returns: -
  61. //
  62. // History: 07-Mar-95 BruceMa Created
  63. //
  64. //--------------------------------------------------------------------------
  65. void classInfoHelp(PNTSD_EXTENSION_APIS lpExtensionApis)
  66. {
  67. Printf("ci - Display registry class information\n");
  68. Printf("ci clsid - Display registry class information for clsid\n");
  69. }
  70. //+-------------------------------------------------------------------------
  71. //
  72. // Function: displayclassInfo
  73. //
  74. // Synopsis: Display/set debug info levels
  75. //
  76. // Arguments: [hProcess] - Handle of this process
  77. // [lpExtensionApis] - Table of extension functions
  78. // [CLSID *] - Get info for this clsid
  79. //
  80. // Returns: -
  81. //
  82. // History: 07-Mar-95 BruceMa Created
  83. //
  84. //--------------------------------------------------------------------------
  85. BOOL displayClassInfo(HANDLE hProcess,
  86. PNTSD_EXTENSION_APIS lpExtensionApis,
  87. CLSID *pClsid)
  88. {
  89. HKEY hKey;
  90. char szCLSID[CLSIDSTR_MAX];
  91. char szClsid[5 + 1 + CLSIDSTR_MAX];
  92. char szName[64];
  93. char szInprocHandler[64];
  94. char szInprocHandler32[64];
  95. char szInprocServer[64];
  96. char szInprocServer32[64];
  97. char szLocalServer[64];
  98. char szLocalServer32[64];
  99. char szProgid[64];
  100. char szTreatAs[64];
  101. char szAutoConvertTo[64];
  102. char szOle1Class[64];
  103. // Information for a specific clsid?
  104. if (pClsid)
  105. {
  106. // Prepare to open the "...CLSID\<clsid>" key
  107. FormatCLSID(*pClsid, szCLSID);
  108. lstrcpy(szClsid, "CLSID\\");
  109. lstrcat(szClsid, szCLSID);
  110. // Open the key for the specified clsid
  111. if (RegOpenKeyEx(HKEY_CLASSES_ROOT, szClsid, dwRESERVED,
  112. KEY_READ, &hKey) != ERROR_SUCCESS)
  113. {
  114. return FALSE;
  115. }
  116. // Read interesting values for this clsid
  117. GetSomeClsidValues(hKey,
  118. szName,
  119. szInprocHandler,
  120. szInprocHandler32,
  121. szInprocServer,
  122. szInprocServer32,
  123. szLocalServer,
  124. szLocalServer32,
  125. szProgid,
  126. szTreatAs,
  127. szAutoConvertTo,
  128. szOle1Class);
  129. // Only display "interesting" entries
  130. if ((szInprocHandler[0] &&
  131. _stricmp(szInprocHandler, "ole2.dll") != 0) ||
  132. (szInprocHandler32[0] &&
  133. _stricmp(szInprocHandler32, "ole32.dll") != 0) ||
  134. (szInprocServer[0] &&
  135. _stricmp(szInprocServer, "ole2.dll") != 0) ||
  136. (szInprocServer32[0] &&
  137. _stricmp(szInprocServer32, "ole32.dll") != 0) ||
  138. szLocalServer[0] ||
  139. szLocalServer32[0] ||
  140. szTreatAs[0] ||
  141. szAutoConvertTo[0])
  142. {
  143. // Display them
  144. DisplayValues(lpExtensionApis,
  145. szName,
  146. szInprocHandler,
  147. szInprocHandler32,
  148. szInprocServer,
  149. szInprocServer32,
  150. szLocalServer,
  151. szLocalServer32,
  152. szProgid,
  153. szTreatAs,
  154. szAutoConvertTo,
  155. szOle1Class);
  156. }
  157. // Close registry handle and return success
  158. CloseHandle(hKey);
  159. return TRUE;
  160. }
  161. // Else display all of them
  162. else
  163. {
  164. HKEY hKey2;
  165. DWORD dwErr;
  166. DWORD cbSubKey = 0;
  167. char szClsid[64];
  168. DWORD cbClsid;
  169. DWORD cbClass;
  170. FILETIME sLastWrite;
  171. // Open the key for the root "CLSID"
  172. if (RegOpenKeyEx(HKEY_CLASSES_ROOT, "CLSID", dwRESERVED,
  173. KEY_ENUMERATE_SUB_KEYS, &hKey) != ERROR_SUCCESS)
  174. {
  175. return FALSE;
  176. }
  177. // Enumerate over the keys under "HKEY_CLASSES_ROOT\CLSID"
  178. do
  179. {
  180. // Enumerate the next subkey
  181. cbClsid = 64;
  182. dwErr = RegEnumKeyEx(hKey, cbSubKey, szClsid, &cbClsid,
  183. NULL, NULL, NULL, &sLastWrite);
  184. // Prepare for next subkey
  185. cbSubKey++;
  186. // If it does look like a clsid, skip it
  187. CLSID clsid;
  188. if (!ScanCLSID(szClsid, &clsid))
  189. {
  190. continue;
  191. }
  192. // Open this clsid key
  193. if (RegOpenKeyEx(hKey, szClsid, dwRESERVED,
  194. KEY_READ, &hKey2) != ERROR_SUCCESS)
  195. {
  196. return FALSE;
  197. }
  198. // Get the interesting values
  199. GetSomeClsidValues(hKey2,
  200. szName,
  201. szInprocHandler,
  202. szInprocHandler32,
  203. szInprocServer,
  204. szInprocServer32,
  205. szLocalServer,
  206. szLocalServer32,
  207. szProgid,
  208. szTreatAs,
  209. szAutoConvertTo,
  210. szOle1Class);
  211. // Only display "interesting" entries
  212. if ((szInprocHandler[0] &&
  213. _stricmp(szInprocHandler, "ole2.dll") != 0) ||
  214. (szInprocHandler32[0] &&
  215. _stricmp(szInprocHandler32, "ole32.dll") != 0) ||
  216. (szInprocServer[0] &&
  217. _stricmp(szInprocServer, "ole2.dll") != 0) ||
  218. (szInprocServer32[0] &&
  219. _stricmp(szInprocServer32, "ole32.dll") != 0) ||
  220. szLocalServer[0] ||
  221. szLocalServer32[0] ||
  222. szTreatAs[0] ||
  223. szAutoConvertTo[0])
  224. {
  225. // Display the clsid
  226. Printf("%s ", szClsid);
  227. // Display its values
  228. DisplayValues(lpExtensionApis,
  229. szName,
  230. szInprocHandler,
  231. szInprocHandler32,
  232. szInprocServer,
  233. szInprocServer32,
  234. szLocalServer,
  235. szLocalServer32,
  236. szProgid,
  237. szTreatAs,
  238. szAutoConvertTo,
  239. szOle1Class);
  240. }
  241. // Close registry handle
  242. CloseHandle(hKey2);
  243. } until_(dwErr == ERROR_NO_MORE_ITEMS || dwErr != ERROR_SUCCESS);
  244. // Close clsid registry handle
  245. CloseHandle(hKey);
  246. return TRUE;
  247. }
  248. }
  249. //+-------------------------------------------------------------------------
  250. //
  251. // Function: GetSomeClsidValues
  252. //
  253. // Synopsis: Given an open registry key to a clsid, read some of
  254. // the more interesting subkey values
  255. //
  256. // Arguments: [hkey] Open registry key
  257. // [szName] Where to store the name
  258. // [szInprocHandler] Where to store the InprocHandler
  259. // [szInprocHandler32] Where to store the InprocHandler32
  260. // [szInprocServer] Where to store the InprocServer
  261. // [szInprocServer32] Where to store the InprocServer32
  262. // [szLocalServer] Where to store the LocalServer
  263. // [szLocalServer32] Where to store the LocalServer32
  264. // [ProgId] Where to store the ProgId
  265. // [TreatAs] Where to store the TreatAs
  266. // [AutoConvertTo] Where to store the AutoConvertTo
  267. // [Ole1Class] Where to store the Ole1Class
  268. //
  269. // Returns: -
  270. //
  271. // History: 01-Jun-95 BruceMa Created
  272. //
  273. //--------------------------------------------------------------------------
  274. static void GetSomeClsidValues(HKEY hKey,
  275. char *szName,
  276. char *szInprocHandler,
  277. char *szInprocHandler32,
  278. char *szInprocServer,
  279. char *szInprocServer32,
  280. char *szLocalServer,
  281. char *szLocalServer32,
  282. char *szProgId,
  283. char *szTreatAs,
  284. char *szAutoConvertTo,
  285. char *szOle1Class)
  286. {
  287. DWORD dwRESERVED = 0;
  288. HKEY hKey2;
  289. DWORD dwValueType;
  290. DWORD cbValue;
  291. // Initialize
  292. szName[0] = '\0';
  293. szInprocHandler[0] = '\0';
  294. szInprocHandler32[0] = '\0';
  295. szInprocServer[0] = '\0';
  296. szInprocServer32[0] = '\0';
  297. szLocalServer[0] = '\0';
  298. szLocalServer32[0] = '\0';
  299. szProgId[0] = '\0';
  300. szTreatAs[0] = '\0';
  301. szAutoConvertTo[0] = '\0';
  302. szOle1Class[0] = '\0';
  303. // Name
  304. cbValue = 64;
  305. if (RegQueryValueEx(hKey, NULL, NULL, &dwValueType,
  306. (LPBYTE) szName, &cbValue) != ERROR_SUCCESS)
  307. {
  308. return;
  309. }
  310. // InprocHandler
  311. if (RegOpenKeyEx(hKey, "InprocHandler", dwRESERVED,
  312. KEY_READ, &hKey2) == ERROR_SUCCESS)
  313. {
  314. cbValue = 64;
  315. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  316. (LPBYTE) szInprocHandler, &cbValue);
  317. MungePath(szInprocHandler);
  318. CloseHandle(hKey2);
  319. }
  320. // InprocHandler32
  321. if (RegOpenKeyEx(hKey, "InprocHandler32", dwRESERVED,
  322. KEY_READ, &hKey2) == ERROR_SUCCESS)
  323. {
  324. cbValue = 64;
  325. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  326. (LPBYTE) szInprocHandler32, &cbValue);
  327. MungePath(szInprocHandler32);
  328. CloseHandle(hKey2);
  329. }
  330. // InprocServer
  331. if (RegOpenKeyEx(hKey, "InprocServer", dwRESERVED,
  332. KEY_READ, &hKey2) == ERROR_SUCCESS)
  333. {
  334. cbValue = 64;
  335. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  336. (LPBYTE) szInprocServer, &cbValue);
  337. MungePath(szInprocServer);
  338. CloseHandle(hKey2);
  339. }
  340. // InprocServer32
  341. if (RegOpenKeyEx(hKey, "InprocServer32", dwRESERVED,
  342. KEY_READ, &hKey2) == ERROR_SUCCESS)
  343. {
  344. cbValue = 64;
  345. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  346. (LPBYTE) szInprocServer32, &cbValue);
  347. MungePath(szInprocServer32);
  348. CloseHandle(hKey2);
  349. }
  350. // LocalServer
  351. if (RegOpenKeyEx(hKey, "LocalServer", dwRESERVED,
  352. KEY_READ, &hKey2) == ERROR_SUCCESS)
  353. {
  354. cbValue = 64;
  355. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  356. (LPBYTE) szLocalServer, &cbValue);
  357. MungePath(szLocalServer);
  358. CloseHandle(hKey2);
  359. }
  360. // LocalServer32
  361. if (RegOpenKeyEx(hKey, "LocalServer32", dwRESERVED,
  362. KEY_READ, &hKey2) == ERROR_SUCCESS)
  363. {
  364. cbValue = 64;
  365. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  366. (LPBYTE) szLocalServer32, &cbValue);
  367. MungePath(szLocalServer32);
  368. CloseHandle(hKey2);
  369. }
  370. // ProgId
  371. if (RegOpenKeyEx(hKey, "ProgId", dwRESERVED,
  372. KEY_READ, &hKey2) == ERROR_SUCCESS)
  373. {
  374. cbValue = 64;
  375. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  376. (LPBYTE) szProgId, &cbValue);
  377. CloseHandle(hKey2);
  378. }
  379. // TreatAs
  380. if (RegOpenKeyEx(hKey, "TreatAs", dwRESERVED,
  381. KEY_READ, &hKey2) == ERROR_SUCCESS)
  382. {
  383. cbValue = 64;
  384. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  385. (LPBYTE) szTreatAs, &cbValue);
  386. CloseHandle(hKey2);
  387. }
  388. // AutoConvertTo
  389. if (RegOpenKeyEx(hKey, "AutoConvertTo", dwRESERVED,
  390. KEY_READ, &hKey2) == ERROR_SUCCESS)
  391. {
  392. cbValue = 64;
  393. RegQueryValueEx(hKey2, NULL, NULL, &dwValueType,
  394. (LPBYTE) szAutoConvertTo, &cbValue);
  395. CloseHandle(hKey2);
  396. }
  397. // Ole1Class
  398. if (RegOpenKeyEx(hKey, "Ole1Class", dwRESERVED,
  399. KEY_READ, &hKey2) == ERROR_SUCCESS)
  400. {
  401. szOle1Class[0] = '1';
  402. CloseHandle(hKey2);
  403. }
  404. }
  405. //+-------------------------------------------------------------------------
  406. //
  407. // Function: DisplayValues
  408. //
  409. // Synopsis: Display the values read above
  410. //
  411. // Arguments: [hkey] Open registry key
  412. // [szName] Where to store the name
  413. // [szInprocHandler] Where to store the InprocHandler
  414. // [szInprocHandler32] Where to store the InprocHandler32
  415. // [szInprocServer] Where to store the InprocServer
  416. // [szInprocServer32] Where to store the InprocServer32
  417. // [szLocalServer] Where to store the LocalServer
  418. // [szLocalServer32] Where to store the LocalServer32
  419. // [ProgId] Where to store the ProgId
  420. // [TreatAs] Where to store the TreatAs
  421. // [AutoConvertTo] Where to store the AutoConvertTo
  422. // [Ole1Class] Where to store the Ole1Class
  423. //
  424. // Returns: -
  425. //
  426. // History: 01-Jun-95 BruceMa Created
  427. //
  428. //--------------------------------------------------------------------------
  429. static void DisplayValues(PNTSD_EXTENSION_APIS lpExtensionApis,
  430. char *szName,
  431. char *szInprocHandler,
  432. char *szInprocHandler32,
  433. char *szInprocServer,
  434. char *szInprocServer32,
  435. char *szLocalServer,
  436. char *szLocalServer32,
  437. char *szProgId,
  438. char *szTreatAs,
  439. char *szAutoConvertTo,
  440. char *szOle1Class)
  441. {
  442. // Display the name
  443. Printf("%s ", szName);
  444. // Display ProgId (if unique)
  445. if (szProgId[0] && lstrcmp(szProgId, szName) != 0)
  446. {
  447. Printf("%s ", szProgId);
  448. }
  449. // Display the server executable
  450. if (szLocalServer[0])
  451. {
  452. Printf("%s ", szLocalServer32);
  453. }
  454. else if (szInprocServer32[0])
  455. {
  456. Printf("%s ", szInprocServer32);
  457. }
  458. else if (szLocalServer[0])
  459. {
  460. Printf("%s(16) ", szLocalServer);
  461. }
  462. else if (szInprocServer[0])
  463. {
  464. Printf("%s(16) ", szInprocServer);
  465. }
  466. // Display handler information
  467. if (szInprocHandler32[0] &&
  468. _stricmp(szInprocHandler32, "ole32.dll") != 0)
  469. {
  470. Printf("Hndlr: %s ", szInprocHandler32);
  471. }
  472. else if (szInprocHandler[0] &&
  473. _stricmp(szInprocHandler, "ole2.dll") != 0)
  474. {
  475. Printf("Hndlr: %s(16) ", szInprocHandler);
  476. }
  477. // Display any TreatAs or AutoConvertTo information
  478. if (szTreatAs[0])
  479. {
  480. Printf("TA: %s", szTreatAs);
  481. }
  482. if (szAutoConvertTo[0])
  483. {
  484. Printf("ACT: %s", szAutoConvertTo);
  485. }
  486. // Check if this is an ole1 class
  487. if (szOle1Class[0])
  488. {
  489. Printf("ole1 class");
  490. }
  491. // We're done
  492. Printf("\n");
  493. }
  494. //+-------------------------------------------------------------------------
  495. //
  496. // Function: MungePath
  497. //
  498. // Synopsis: Remove directory components from a file path
  499. //
  500. // Arguments: [szPath] Path to munge
  501. //
  502. // Returns: -
  503. //
  504. // History: 01-Jun-95 BruceMa Created
  505. //
  506. //--------------------------------------------------------------------------
  507. static void MungePath(char *szPath)
  508. {
  509. int cbLen = lstrlen(szPath);
  510. DWORD cbPath;
  511. for (cbPath = cbLen; cbPath > 0 && szPath[cbPath] != '\\'; cbPath--)
  512. {
  513. }
  514. if (cbPath > 0)
  515. {
  516. lstrcpy(szPath, &szPath[cbPath + 1]);
  517. }
  518. }