0b26490ce3aa266274fc36d5fe597829da47c0c0
[reactos.git] / reactos / ntoskrnl / ob / sdcache.c
1 /* $Id: sdcache.c,v 1.1 2004/07/16 17:19:15 ekohl Exp $
2 *
3 * COPYRIGHT: See COPYING in the top level directory
4 * PROJECT: ReactOS kernel
5 * FILE: ntoskrnl/ps/kill.c
6 * PURPOSE: Terminating a thread
7 * PROGRAMMER: David Welch (welch@cwcom.net)
8 * UPDATE HISTORY:
9 * Created 22/05/98
10 */
11
12 /* INCLUDES *****************************************************************/
13
14 #include <ddk/ntddk.h>
15 #include <internal/ob.h>
16
17 #define NDEBUG
18 #include <internal/debug.h>
19
20
21 /* TYPES ********************************************************************/
22
23 typedef struct _SD_CACHE_ENTRY
24 {
25 LIST_ENTRY ListEntry;
26 ULONG HashValue;
27 ULONG Index;
28 ULONG RefCount;
29 } SD_CACHE_ENTRY, *PSD_CACHE_ENTRY;
30
31
32 /* GLOBALS ******************************************************************/
33
34 PLIST_ENTRY ObpSdCache;
35 KSPIN_LOCK ObpSdCacheSpinLock;
36 KIRQL ObpSdCacheIrql;
37
38
39 #define SD_CACHE_ENTRIES 0x100
40
41 /* FUNCTIONS ****************************************************************/
42
43 NTSTATUS
44 ObpInitSdCache(VOID)
45 {
46 ULONG i;
47
48 ObpSdCache = ExAllocatePool(NonPagedPool,
49 SD_CACHE_ENTRIES * sizeof(LIST_ENTRY));
50 if (ObpSdCache == NULL)
51 {
52 return STATUS_INSUFFICIENT_RESOURCES;
53 }
54
55 for (i = 0; i < SD_CACHE_ENTRIES; i++)
56 {
57 InitializeListHead(&ObpSdCache[i]);
58 }
59
60 KeInitializeSpinLock(&ObpSdCacheSpinLock);
61
62 return STATUS_SUCCESS;
63 }
64
65
66 static VOID
67 ObpSdCacheLock(VOID)
68 {
69 KeAcquireSpinLock(&ObpSdCacheSpinLock,
70 &ObpSdCacheIrql);
71 }
72
73
74 static VOID
75 ObpSdCacheUnlock(VOID)
76 {
77 KeReleaseSpinLock(&ObpSdCacheSpinLock,
78 ObpSdCacheIrql);
79 }
80
81
82 static ULONG
83 ObpHash(PVOID Buffer,
84 ULONG Length)
85 {
86 PUCHAR Ptr;
87 ULONG Value;
88 ULONG i;
89
90 Ptr = (PUCHAR)Buffer;
91 Value = 0;
92 for (i = 0; i < Length; i++)
93 {
94 Value += *Ptr;
95 Ptr++;
96 }
97
98 return Value;
99 }
100
101
102 static ULONG
103 ObpHashSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor)
104 {
105 ULONG Value;
106 BOOLEAN Defaulted;
107 BOOLEAN DaclPresent;
108 BOOLEAN SaclPresent;
109 PSID Owner = NULL;
110 PSID Group = NULL;
111 PACL Dacl = NULL;
112 PACL Sacl = NULL;
113
114 RtlGetOwnerSecurityDescriptor(SecurityDescriptor,
115 &Owner,
116 &Defaulted);
117
118 RtlGetGroupSecurityDescriptor(SecurityDescriptor,
119 &Group,
120 &Defaulted);
121
122 RtlGetDaclSecurityDescriptor(SecurityDescriptor,
123 &DaclPresent,
124 &Dacl,
125 &Defaulted);
126
127 RtlGetSaclSecurityDescriptor(SecurityDescriptor,
128 &SaclPresent,
129 &Sacl,
130 &Defaulted);
131
132 Value = 0;
133 if (Owner != NULL)
134 {
135 Value += ObpHash(Owner, RtlLengthSid(Owner));
136 }
137
138 if (Group != NULL)
139 {
140 Value += ObpHash(Group, RtlLengthSid(Group));
141 }
142
143 if (DaclPresent == TRUE && Dacl != NULL)
144 {
145 Value += ObpHash(Dacl, Dacl->AclSize);
146 }
147
148 if (SaclPresent == TRUE && Sacl != NULL)
149 {
150 Value += ObpHash(Sacl, Sacl->AclSize);
151 }
152
153 return Value;
154 }
155
156
157 static PSD_CACHE_ENTRY
158 ObpCreateCacheEntry(IN PSECURITY_DESCRIPTOR SecurityDescriptor,
159 IN ULONG HashValue,
160 IN ULONG Index,
161 OUT PSECURITY_DESCRIPTOR *NewSD)
162 {
163 PSECURITY_DESCRIPTOR Sd;
164 PSD_CACHE_ENTRY CacheEntry;
165 ULONG Length;
166
167 DPRINT("ObpCreateCacheEntry() called\n");
168
169 Length = RtlLengthSecurityDescriptor(SecurityDescriptor);
170
171 CacheEntry = ExAllocatePool(NonPagedPool,
172 sizeof(SD_CACHE_ENTRY) + Length);
173 if (CacheEntry == NULL)
174 {
175 DPRINT1("ExAllocatePool() failed\n");
176 return NULL;
177 }
178
179 CacheEntry->HashValue = HashValue;
180 CacheEntry->Index = Index;
181 CacheEntry->RefCount = 1;
182
183 Sd = (PSECURITY_DESCRIPTOR)(CacheEntry + 1);
184 RtlCopyMemory(Sd,
185 SecurityDescriptor,
186 Length);
187
188 *NewSD = Sd;
189
190 DPRINT("ObpCreateCacheEntry() done\n");
191
192 return CacheEntry;
193 }
194
195
196 static BOOLEAN
197 ObpCompareSecurityDescriptors(IN PSECURITY_DESCRIPTOR Sd1,
198 IN PSECURITY_DESCRIPTOR Sd2)
199 {
200 ULONG Length1;
201 ULONG Length2;
202
203 Length1 = RtlLengthSecurityDescriptor(Sd1);
204 Length2 = RtlLengthSecurityDescriptor(Sd2);
205 if (Length1 != Length2)
206 return FALSE;
207
208 if (RtlCompareMemory(Sd1, Sd2, Length1) != Length1)
209 return FALSE;
210
211 return TRUE;
212 }
213
214
215 NTSTATUS
216 ObpAddSecurityDescriptor(IN PSECURITY_DESCRIPTOR SourceSD,
217 OUT PSECURITY_DESCRIPTOR *DestinationSD)
218 {
219 PSECURITY_DESCRIPTOR Sd;
220 PLIST_ENTRY CurrentEntry;
221 PSD_CACHE_ENTRY CacheEntry;
222 ULONG HashValue;
223 ULONG Index;
224 NTSTATUS Status;
225
226 DPRINT("ObpAddSecurityDescriptor() called\n");
227
228 HashValue = ObpHashSecurityDescriptor(SourceSD);
229 Index = HashValue & 0xFF;
230
231 ObpSdCacheLock();
232
233 if (!IsListEmpty(&ObpSdCache[Index]))
234 {
235 CurrentEntry = ObpSdCache[Index].Flink;
236 while (CurrentEntry != &ObpSdCache[Index])
237 {
238 CacheEntry = CONTAINING_RECORD(CurrentEntry,
239 SD_CACHE_ENTRY,
240 ListEntry);
241 Sd = (PSECURITY_DESCRIPTOR)(CacheEntry + 1);
242
243 if (CacheEntry->HashValue == HashValue &&
244 ObpCompareSecurityDescriptors(SourceSD, Sd))
245 {
246 CacheEntry->RefCount++;
247 DPRINT("RefCount %lu\n", CacheEntry->RefCount);
248 *DestinationSD = Sd;
249
250 ObpSdCacheUnlock();
251
252 DPRINT("ObpAddSecurityDescriptor() done\n");
253
254 return STATUS_SUCCESS;
255 }
256
257 CurrentEntry = CurrentEntry->Flink;
258 }
259 }
260
261 CacheEntry = ObpCreateCacheEntry(SourceSD,
262 HashValue,
263 Index,
264 DestinationSD);
265 if (CacheEntry == NULL)
266 {
267 DPRINT1("ObpCreateCacheEntry() failed\n");
268 Status = STATUS_INSUFFICIENT_RESOURCES;
269 }
270 else
271 {
272 DPRINT("RefCount 1\n");
273 InsertTailList(&ObpSdCache[Index], &CacheEntry->ListEntry);
274 Status = STATUS_SUCCESS;
275 }
276
277 ObpSdCacheUnlock();
278
279 DPRINT("ObpAddSecurityDescriptor() done\n");
280
281 return Status;
282 }
283
284
285 NTSTATUS
286 ObpRemoveSecurityDescriptor(IN PSECURITY_DESCRIPTOR SecurityDescriptor)
287 {
288 PSD_CACHE_ENTRY CacheEntry;
289
290 DPRINT("ObpRemoveSecurityDescriptor() called\n");
291
292 ObpSdCacheLock();
293
294 CacheEntry = (PSD_CACHE_ENTRY)((ULONG_PTR)SecurityDescriptor - sizeof(SD_CACHE_ENTRY));
295
296 CacheEntry->RefCount--;
297 DPRINT("RefCount %lu\n", CacheEntry->RefCount);
298 if (CacheEntry->RefCount == 0)
299 {
300 DPRINT("Remove cache entry\n");
301 RemoveEntryList(&CacheEntry->ListEntry);
302 ExFreePool(CacheEntry);
303 }
304
305 ObpSdCacheUnlock();
306
307 DPRINT("ObpRemoveSecurityDescriptor() done\n");
308
309 return STATUS_SUCCESS;
310 }
311
312 /* EOF */