[RPCSS]
[reactos.git] / reactos / base / services / rpcss / irotp.c
1 /*
2 * Running Object Table
3 *
4 * Copyright 2007 Robert Shearman
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <irot_s.h>
22 #include <wine/list.h>
23 #include <wine/debug.h>
24
25 WINE_DEFAULT_DEBUG_CHANNEL(rpcss);
26
27 /* define the structure of the running object table elements */
28 struct rot_entry
29 {
30 struct list entry;
31 InterfaceData *object; /* marshaled running object*/
32 InterfaceData *moniker; /* marshaled moniker that identifies this object */
33 MonikerComparisonData *moniker_data; /* moniker comparison data that identifies this object */
34 DWORD cookie; /* cookie identifying this object */
35 FILETIME last_modified;
36 LONG refs;
37 };
38
39 static struct list RunningObjectTable = LIST_INIT(RunningObjectTable);
40
41 static CRITICAL_SECTION csRunningObjectTable;
42 static CRITICAL_SECTION_DEBUG critsect_debug =
43 {
44 0, 0, &csRunningObjectTable,
45 { &critsect_debug.ProcessLocksList, &critsect_debug.ProcessLocksList },
46 0, 0, { (DWORD_PTR)(__FILE__ ": csRunningObjectTable") }
47 };
48 static CRITICAL_SECTION csRunningObjectTable = { &critsect_debug, -1, 0, 0, 0, 0 };
49
50 static LONG last_cookie = 1;
51
52 static inline void rot_entry_release(struct rot_entry *rot_entry)
53 {
54 if (!InterlockedDecrement(&rot_entry->refs))
55 {
56 HeapFree(GetProcessHeap(), 0, rot_entry->object);
57 HeapFree(GetProcessHeap(), 0, rot_entry->moniker);
58 HeapFree(GetProcessHeap(), 0, rot_entry->moniker_data);
59 HeapFree(GetProcessHeap(), 0, rot_entry);
60 }
61 }
62
63 HRESULT __cdecl IrotRegister(
64 IrotHandle h,
65 const MonikerComparisonData *data,
66 const InterfaceData *obj,
67 const InterfaceData *mk,
68 const FILETIME *time,
69 DWORD grfFlags,
70 IrotCookie *cookie,
71 IrotContextHandle *ctxt_handle)
72 {
73 struct rot_entry *rot_entry;
74 struct rot_entry *existing_rot_entry;
75 HRESULT hr;
76
77 if (grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT))
78 {
79 WINE_ERR("Invalid grfFlags: 0x%08x\n", grfFlags & ~(ROTFLAGS_REGISTRATIONKEEPSALIVE|ROTFLAGS_ALLOWANYCLIENT));
80 return E_INVALIDARG;
81 }
82
83 rot_entry = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*rot_entry));
84 if (!rot_entry)
85 return E_OUTOFMEMORY;
86
87 rot_entry->refs = 1;
88 rot_entry->object = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceData, abData[obj->ulCntData]));
89 if (!rot_entry->object)
90 {
91 rot_entry_release(rot_entry);
92 return E_OUTOFMEMORY;
93 }
94 rot_entry->object->ulCntData = obj->ulCntData;
95 memcpy(&rot_entry->object->abData, obj->abData, obj->ulCntData);
96
97 rot_entry->last_modified = *time;
98
99 rot_entry->moniker = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(InterfaceData, abData[mk->ulCntData]));
100 if (!rot_entry->moniker)
101 {
102 rot_entry_release(rot_entry);
103 return E_OUTOFMEMORY;
104 }
105 rot_entry->moniker->ulCntData = mk->ulCntData;
106 memcpy(&rot_entry->moniker->abData, mk->abData, mk->ulCntData);
107
108 rot_entry->moniker_data = HeapAlloc(GetProcessHeap(), 0, FIELD_OFFSET(MonikerComparisonData, abData[data->ulCntData]));
109 if (!rot_entry->moniker_data)
110 {
111 rot_entry_release(rot_entry);
112 return E_OUTOFMEMORY;
113 }
114 rot_entry->moniker_data->ulCntData = data->ulCntData;
115 memcpy(&rot_entry->moniker_data->abData, data->abData, data->ulCntData);
116
117 EnterCriticalSection(&csRunningObjectTable);
118
119 hr = S_OK;
120
121 LIST_FOR_EACH_ENTRY(existing_rot_entry, &RunningObjectTable, struct rot_entry, entry)
122 {
123 if ((existing_rot_entry->moniker_data->ulCntData == data->ulCntData) &&
124 !memcmp(&data->abData, &existing_rot_entry->moniker_data->abData, data->ulCntData))
125 {
126 hr = MK_S_MONIKERALREADYREGISTERED;
127 WINE_TRACE("moniker already registered with cookie %d\n", existing_rot_entry->cookie);
128 break;
129 }
130 }
131
132 list_add_tail(&RunningObjectTable, &rot_entry->entry);
133
134 LeaveCriticalSection(&csRunningObjectTable);
135
136 /* gives a registration identifier to the registered object*/
137 *cookie = rot_entry->cookie = InterlockedIncrement(&last_cookie);
138 *ctxt_handle = rot_entry;
139
140 return hr;
141 }
142
143 HRESULT __cdecl IrotRevoke(
144 IrotHandle h,
145 IrotCookie cookie,
146 IrotContextHandle *ctxt_handle,
147 PInterfaceData *obj,
148 PInterfaceData *mk)
149 {
150 struct rot_entry *rot_entry;
151
152 WINE_TRACE("%d\n", cookie);
153
154 EnterCriticalSection(&csRunningObjectTable);
155 LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, struct rot_entry, entry)
156 {
157 if (rot_entry->cookie == cookie)
158 {
159 HRESULT hr = S_OK;
160
161 list_remove(&rot_entry->entry);
162 LeaveCriticalSection(&csRunningObjectTable);
163
164 *obj = MIDL_user_allocate(FIELD_OFFSET(InterfaceData, abData[rot_entry->object->ulCntData]));
165 *mk = MIDL_user_allocate(FIELD_OFFSET(InterfaceData, abData[rot_entry->moniker->ulCntData]));
166 if (*obj && *mk)
167 {
168 (*obj)->ulCntData = rot_entry->object->ulCntData;
169 memcpy((*obj)->abData, rot_entry->object->abData, (*obj)->ulCntData);
170 (*mk)->ulCntData = rot_entry->moniker->ulCntData;
171 memcpy((*mk)->abData, rot_entry->moniker->abData, (*mk)->ulCntData);
172 }
173 else
174 {
175 MIDL_user_free(*obj);
176 MIDL_user_free(*mk);
177 hr = E_OUTOFMEMORY;
178 }
179
180 rot_entry_release(rot_entry);
181 *ctxt_handle = NULL;
182 return hr;
183 }
184 }
185 LeaveCriticalSection(&csRunningObjectTable);
186
187 return E_INVALIDARG;
188 }
189
190 HRESULT __cdecl IrotIsRunning(
191 IrotHandle h,
192 const MonikerComparisonData *data)
193 {
194 const struct rot_entry *rot_entry;
195 HRESULT hr = S_FALSE;
196
197 WINE_TRACE("\n");
198
199 EnterCriticalSection(&csRunningObjectTable);
200
201 LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, const struct rot_entry, entry)
202 {
203 if ((rot_entry->moniker_data->ulCntData == data->ulCntData) &&
204 !memcmp(&data->abData, &rot_entry->moniker_data->abData, data->ulCntData))
205 {
206 hr = S_OK;
207 break;
208 }
209 }
210 LeaveCriticalSection(&csRunningObjectTable);
211
212 return hr;
213 }
214
215 HRESULT __cdecl IrotGetObject(
216 IrotHandle h,
217 const MonikerComparisonData *moniker_data,
218 PInterfaceData *obj,
219 IrotCookie *cookie)
220 {
221 const struct rot_entry *rot_entry;
222
223 WINE_TRACE("%p\n", moniker_data);
224
225 *cookie = 0;
226
227 EnterCriticalSection(&csRunningObjectTable);
228
229 LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, const struct rot_entry, entry)
230 {
231 HRESULT hr = S_OK;
232 if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
233 !memcmp(&moniker_data->abData, &rot_entry->moniker_data->abData, moniker_data->ulCntData))
234 {
235 *obj = MIDL_user_allocate(FIELD_OFFSET(InterfaceData, abData[rot_entry->object->ulCntData]));
236 if (*obj)
237 {
238 (*obj)->ulCntData = rot_entry->object->ulCntData;
239 memcpy((*obj)->abData, rot_entry->object->abData, (*obj)->ulCntData);
240
241 *cookie = rot_entry->cookie;
242 }
243 else
244 hr = E_OUTOFMEMORY;
245
246 LeaveCriticalSection(&csRunningObjectTable);
247
248 return hr;
249 }
250 }
251
252 LeaveCriticalSection(&csRunningObjectTable);
253
254 return MK_E_UNAVAILABLE;
255 }
256
257 HRESULT __cdecl IrotNoteChangeTime(
258 IrotHandle h,
259 IrotCookie cookie,
260 const FILETIME *last_modified_time)
261 {
262 struct rot_entry *rot_entry;
263
264 WINE_TRACE("%d %p\n", cookie, last_modified_time);
265
266 EnterCriticalSection(&csRunningObjectTable);
267 LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, struct rot_entry, entry)
268 {
269 if (rot_entry->cookie == cookie)
270 {
271 rot_entry->last_modified = *last_modified_time;
272 LeaveCriticalSection(&csRunningObjectTable);
273 return S_OK;
274 }
275 }
276 LeaveCriticalSection(&csRunningObjectTable);
277
278 return E_INVALIDARG;
279 }
280
281 HRESULT __cdecl IrotGetTimeOfLastChange(
282 IrotHandle h,
283 const MonikerComparisonData *moniker_data,
284 FILETIME *time)
285 {
286 const struct rot_entry *rot_entry;
287 HRESULT hr = MK_E_UNAVAILABLE;
288
289 WINE_TRACE("%p\n", moniker_data);
290
291 memset(time, 0, sizeof(*time));
292
293 EnterCriticalSection(&csRunningObjectTable);
294 LIST_FOR_EACH_ENTRY(rot_entry, &RunningObjectTable, const struct rot_entry, entry)
295 {
296 if ((rot_entry->moniker_data->ulCntData == moniker_data->ulCntData) &&
297 !memcmp(&moniker_data->abData, &rot_entry->moniker_data->abData, moniker_data->ulCntData))
298 {
299 *time = rot_entry->last_modified;
300 hr = S_OK;
301 break;
302 }
303 }
304 LeaveCriticalSection(&csRunningObjectTable);
305
306 return hr;
307 }
308
309 HRESULT __cdecl IrotEnumRunning(
310 IrotHandle h,
311 PInterfaceList *list)
312 {
313 const struct rot_entry *rot_entry;
314 HRESULT hr = S_OK;
315 ULONG moniker_count = 0;
316 ULONG i = 0;
317
318 WINE_TRACE("\n");
319
320 EnterCriticalSection(&csRunningObjectTable);
321
322 LIST_FOR_EACH_ENTRY( rot_entry, &RunningObjectTable, const struct rot_entry, entry )
323 moniker_count++;
324
325 *list = MIDL_user_allocate(FIELD_OFFSET(InterfaceList, interfaces[moniker_count]));
326 if (*list)
327 {
328 (*list)->size = moniker_count;
329 LIST_FOR_EACH_ENTRY( rot_entry, &RunningObjectTable, const struct rot_entry, entry )
330 {
331 (*list)->interfaces[i] = MIDL_user_allocate(FIELD_OFFSET(InterfaceData, abData[rot_entry->moniker->ulCntData]));
332 if (!(*list)->interfaces[i])
333 {
334 ULONG end = i - 1;
335 for (i = 0; i < end; i++)
336 MIDL_user_free((*list)->interfaces[i]);
337 MIDL_user_free(*list);
338 hr = E_OUTOFMEMORY;
339 break;
340 }
341 (*list)->interfaces[i]->ulCntData = rot_entry->moniker->ulCntData;
342 memcpy((*list)->interfaces[i]->abData, rot_entry->moniker->abData, rot_entry->moniker->ulCntData);
343 i++;
344 }
345 }
346 else
347 hr = E_OUTOFMEMORY;
348
349 LeaveCriticalSection(&csRunningObjectTable);
350
351 return hr;
352 }
353
354 void __RPC_USER IrotContextHandle_rundown(IrotContextHandle ctxt_handle)
355 {
356 struct rot_entry *rot_entry = ctxt_handle;
357 EnterCriticalSection(&csRunningObjectTable);
358 list_remove(&rot_entry->entry);
359 LeaveCriticalSection(&csRunningObjectTable);
360 rot_entry_release(rot_entry);
361 }
362
363 void * __RPC_USER MIDL_user_allocate(SIZE_T size)
364 {
365 return HeapAlloc(GetProcessHeap(), 0, size);
366 }
367
368 void __RPC_USER MIDL_user_free(void * p)
369 {
370 HeapFree(GetProcessHeap(), 0, p);
371 }