Leaked source code of windows server 2003
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.

348 lines
11 KiB

  1. This whole while is dead.
  2. ///*++
  3. //Copyright (c) 1990 Microsoft Corporation
  4. //Module Name:
  5. // srvatom.c
  6. //Abstract:
  7. // This file contains the Global Atom manager API routines
  8. //Author:
  9. // Steve Wood (stevewo) 29-Oct-1990
  10. //Revision History:
  11. //--*/
  12. //#include "basesrv.h"
  13. ////
  14. //// Pointer to User function that returns a pointer to the
  15. //// global atom table associated with the windowstation
  16. //// userd by the specified thread.
  17. ////
  18. //NTSTATUS (*_UserGetGlobalAtomTable)(
  19. // HANDLE hThread,
  20. // PVOID *GlobalAtomTable
  21. // );
  22. ////
  23. //// Pointer to User function that sets a pointer to the
  24. //// global atom table into the windowstation associated
  25. //// with the specified thread.
  26. ////
  27. //NTSTATUS (*_UserSetGlobalAtomTable)(
  28. // HANDLE hThread,
  29. // PVOID GlobalAtomTable
  30. // );
  31. //NTSTATUS
  32. //BaseSrvGetGlobalAtomTable(
  33. // PVOID *GlobalAtomTable
  34. // )
  35. //{
  36. // STRING ProcedureName;
  37. // ANSI_STRING DllName;
  38. // UNICODE_STRING DllName_U;
  39. // HANDLE UserServerModuleHandle;
  40. // static BOOL fInit = FALSE;
  41. // NTSTATUS Status;
  42. // if ( _UserGetGlobalAtomTable == NULL ) {
  43. // if ( fInit == TRUE ) {
  44. // //
  45. // // If the exported atom routines cannot be found, deny access
  46. // //
  47. // return( STATUS_ACCESS_DENIED );
  48. // }
  49. // fInit = TRUE;
  50. // //
  51. // // Load pointers to the functions in winsrv.dll
  52. // //
  53. // RtlInitAnsiString( &DllName, "winsrv" );
  54. // RtlAnsiStringToUnicodeString( &DllName_U, &DllName, TRUE );
  55. // Status = LdrGetDllHandle(
  56. // UNICODE_NULL,
  57. // NULL,
  58. // &DllName_U,
  59. // (PVOID *)&UserServerModuleHandle
  60. // );
  61. // RtlFreeUnicodeString( &DllName_U );
  62. // if ( NT_SUCCESS(Status) ) {
  63. // //
  64. // // Now get the routined to query and set the
  65. // // atom table pointer.
  66. // //
  67. // RtlInitString( &ProcedureName, "_UserGetGlobalAtomTable" );
  68. // Status = LdrGetProcedureAddress(
  69. // (PVOID)UserServerModuleHandle,
  70. // &ProcedureName,
  71. // 0L,
  72. // (PVOID *)&_UserGetGlobalAtomTable
  73. // );
  74. // RtlInitString( &ProcedureName, "_UserSetGlobalAtomTable" );
  75. // Status = LdrGetProcedureAddress(
  76. // (PVOID)UserServerModuleHandle,
  77. // &ProcedureName,
  78. // 0L,
  79. // (PVOID *)&_UserSetGlobalAtomTable
  80. // );
  81. // }
  82. // //
  83. // // Deny access upon failure
  84. // //
  85. // if ( !NT_SUCCESS(Status) )
  86. // return( STATUS_ACCESS_DENIED );
  87. // }
  88. // Status = (*_UserGetGlobalAtomTable)(
  89. // CSR_SERVER_QUERYCLIENTTHREAD()->ThreadHandle,
  90. // GlobalAtomTable);
  91. // if ( !NT_SUCCESS(Status) ) {
  92. // return Status;
  93. // }
  94. //
  95. // //
  96. // // Lock the heap until the call is complete.
  97. // //
  98. // RtlLockHeap( BaseSrvHeap );
  99. // //
  100. // // If there is an atom table, return it.
  101. // //
  102. // if ( *GlobalAtomTable ) {
  103. // return STATUS_SUCCESS;
  104. // }
  105. // Status = BaseRtlCreateAtomTable( 37,
  106. // (USHORT)~MAXINTATOM,
  107. // GlobalAtomTable
  108. // );
  109. // if ( NT_SUCCESS(Status) ) {
  110. // Status = (*_UserSetGlobalAtomTable)(
  111. // CSR_SERVER_QUERYCLIENTTHREAD()->ThreadHandle,
  112. // *GlobalAtomTable);
  113. // if ( !NT_SUCCESS(Status) ) {
  114. // BaseRtlDestroyAtomTable( *GlobalAtomTable );
  115. // }
  116. // }
  117. // if ( !NT_SUCCESS(Status) ) {
  118. // RtlUnlockHeap( BaseSrvHeap );
  119. // }
  120. // return Status;
  121. //}
  122. //ULONG
  123. //BaseSrvDestroyGlobalAtomTable(
  124. // IN OUT PCSR_API_MSG m,
  125. // IN OUT PCSR_REPLY_STATUS ReplyStatus
  126. // )
  127. //{
  128. // PBASE_DESTROYGLOBALATOMTABLE_MSG a = (PBASE_DESTROYGLOBALATOMTABLE_MSG)&m->u.ApiMessageData;
  129. // return BaseRtlDestroyAtomTable(a->GlobalAtomTable);
  130. //}
  131. //ULONG
  132. //BaseSrvGlobalAddAtom(
  133. // IN OUT PCSR_API_MSG m,
  134. // IN OUT PCSR_REPLY_STATUS ReplyStatus
  135. // )
  136. //{
  137. // PBASE_GLOBALATOMNAME_MSG a = (PBASE_GLOBALATOMNAME_MSG)&m->u.ApiMessageData;
  138. // PVOID GlobalAtomTable;
  139. // NTSTATUS Status;
  140. // UNICODE_STRING AtomName;
  141. // AtomName = a->AtomName;
  142. // if (a->AtomNameInClient) {
  143. // AtomName.Buffer = RtlAllocateHeap( BaseSrvHeap,
  144. // MAKE_TAG( TMP_TAG ),
  145. // AtomName.Length
  146. // );
  147. // if (AtomName.Buffer == NULL) {
  148. // return (ULONG)STATUS_NO_MEMORY;
  149. // }
  150. // Status = NtReadVirtualMemory( CSR_SERVER_QUERYCLIENTTHREAD()->Process->ProcessHandle,
  151. // a->AtomName.Buffer,
  152. // AtomName.Buffer,
  153. // AtomName.Length,
  154. // NULL
  155. // );
  156. // }
  157. // else {
  158. // Status = STATUS_SUCCESS;
  159. // }
  160. // if (NT_SUCCESS( Status )) {
  161. // Status = BaseSrvGetGlobalAtomTable(&GlobalAtomTable);
  162. // if (NT_SUCCESS( Status )) {
  163. // Status = BaseRtlAddAtomToAtomTable( GlobalAtomTable,
  164. // &AtomName,
  165. // NULL,
  166. // &a->Atom
  167. // );
  168. // RtlUnlockHeap( BaseSrvHeap );
  169. // }
  170. // }
  171. // if (a->AtomNameInClient) {
  172. // RtlFreeHeap( BaseSrvHeap, 0, AtomName.Buffer );
  173. // }
  174. // return( (ULONG)Status );
  175. // ReplyStatus; // get rid of unreferenced parameter warning message
  176. //}
  177. //ULONG
  178. //BaseSrvGlobalFindAtom(
  179. // IN OUT PCSR_API_MSG m,
  180. // IN OUT PCSR_REPLY_STATUS ReplyStatus
  181. // )
  182. //{
  183. // PBASE_GLOBALATOMNAME_MSG a = (PBASE_GLOBALATOMNAME_MSG)&m->u.ApiMessageData;
  184. // PVOID GlobalAtomTable;
  185. // UNICODE_STRING AtomName;
  186. // NTSTATUS Status;
  187. // AtomName = a->AtomName;
  188. // if (a->AtomNameInClient) {
  189. // AtomName.Buffer = RtlAllocateHeap( BaseSrvHeap,
  190. // MAKE_TAG( TMP_TAG ),
  191. // AtomName.Length
  192. // );
  193. // if (AtomName.Buffer == NULL) {
  194. // return (ULONG)STATUS_NO_MEMORY;
  195. // }
  196. // Status = NtReadVirtualMemory( CSR_SERVER_QUERYCLIENTTHREAD()->Process->ProcessHandle,
  197. // a->AtomName.Buffer,
  198. // AtomName.Buffer,
  199. // AtomName.Length,
  200. // NULL
  201. // );
  202. // }
  203. // else {
  204. // Status = STATUS_SUCCESS;
  205. // }
  206. // if (NT_SUCCESS( Status )) {
  207. // Status = BaseSrvGetGlobalAtomTable(&GlobalAtomTable);
  208. // if (NT_SUCCESS( Status )) {
  209. // Status = BaseRtlLookupAtomInAtomTable( GlobalAtomTable,
  210. // &AtomName,
  211. // NULL,
  212. // &a->Atom
  213. // );
  214. // RtlUnlockHeap( BaseSrvHeap );
  215. // }
  216. // }
  217. // if (a->AtomNameInClient) {
  218. // RtlFreeHeap( BaseSrvHeap, 0, AtomName.Buffer );
  219. // }
  220. // return( (ULONG)Status );
  221. // ReplyStatus; // get rid of unreferenced parameter warning message
  222. //}
  223. //ULONG
  224. //BaseSrvGlobalDeleteAtom(
  225. // IN OUT PCSR_API_MSG m,
  226. // IN OUT PCSR_REPLY_STATUS ReplyStatus
  227. // )
  228. //{
  229. // PBASE_GLOBALDELETEATOM_MSG a = (PBASE_GLOBALDELETEATOM_MSG)&m->u.ApiMessageData;
  230. // PVOID GlobalAtomTable;
  231. // NTSTATUS Status;
  232. // Status = BaseSrvGetGlobalAtomTable(&GlobalAtomTable);
  233. // if (NT_SUCCESS( Status )) {
  234. // Status = BaseRtlDeleteAtomFromAtomTable( GlobalAtomTable,
  235. // a->Atom
  236. // );
  237. // RtlUnlockHeap( BaseSrvHeap );
  238. // }
  239. // return( (ULONG)Status );
  240. // ReplyStatus; // get rid of unreferenced parameter warning message
  241. //}
  242. //ULONG
  243. //BaseSrvGlobalGetAtomName(
  244. // IN OUT PCSR_API_MSG m,
  245. // IN OUT PCSR_REPLY_STATUS ReplyStatus
  246. // )
  247. //{
  248. // PBASE_GLOBALATOMNAME_MSG a = (PBASE_GLOBALATOMNAME_MSG)&m->u.ApiMessageData;
  249. // UNICODE_STRING AtomName;
  250. // PVOID GlobalAtomTable;
  251. // NTSTATUS Status;
  252. // AtomName = a->AtomName;
  253. // if (a->AtomNameInClient) {
  254. // AtomName.Buffer = RtlAllocateHeap( BaseSrvHeap,
  255. // MAKE_TAG( TMP_TAG ),
  256. // AtomName.MaximumLength
  257. // );
  258. // if (AtomName.Buffer == NULL) {
  259. // return (ULONG)STATUS_NO_MEMORY;
  260. // }
  261. // }
  262. // Status = BaseSrvGetGlobalAtomTable(&GlobalAtomTable);
  263. // if (NT_SUCCESS( Status )) {
  264. // Status = BaseRtlQueryAtomInAtomTable( GlobalAtomTable,
  265. // a->Atom,
  266. // &AtomName,
  267. // NULL,
  268. // NULL
  269. // );
  270. // a->AtomName.Length = AtomName.Length;
  271. // if (NT_SUCCESS( Status ) && a->AtomNameInClient) {
  272. // Status = NtWriteVirtualMemory( CSR_SERVER_QUERYCLIENTTHREAD()->Process->ProcessHandle,
  273. // a->AtomName.Buffer,
  274. // AtomName.Buffer,
  275. // AtomName.Length,
  276. // NULL
  277. // );
  278. // }
  279. // RtlUnlockHeap( BaseSrvHeap );
  280. // }
  281. // if (a->AtomNameInClient) {
  282. // RtlFreeHeap( BaseSrvHeap, 0, AtomName.Buffer );
  283. // }
  284. // return( (ULONG)Status );
  285. // ReplyStatus; // get rid of unreferenced parameter warning message
  286. //}