[MSAFD] Move the default debug channel to msafd.h.
[reactos.git] / dll / win32 / msafd / misc / helpers.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS Ancillary Function Driver DLL
4 * FILE: dll/win32/msafd/misc/helpers.c
5 * PURPOSE: Helper DLL management
6 * PROGRAMMERS: Casper S. Hornstrup (chorns@users.sourceforge.net)
7 * Alex Ionescu (alex@relsoft.net)
8 * REVISIONS:
9 * CSH 01/09-2000 Created
10 * Alex 16/07/2004 - Complete Rewrite
11 */
12
13 #include <msafd.h>
14
15 #include <winreg.h>
16
17 CRITICAL_SECTION HelperDLLDatabaseLock;
18 LIST_ENTRY HelperDLLDatabaseListHead;
19
20
21 INT
22 SockGetTdiName(
23 PINT AddressFamily,
24 PINT SocketType,
25 PINT Protocol,
26 GROUP Group,
27 DWORD Flags,
28 PUNICODE_STRING TransportName,
29 PVOID *HelperDllContext,
30 PHELPER_DATA *HelperDllData,
31 PDWORD Events)
32 {
33 PHELPER_DATA HelperData;
34 PWSTR Transports;
35 PWSTR Transport;
36 PWINSOCK_MAPPING Mapping;
37 PLIST_ENTRY Helpers;
38 INT Status;
39
40 TRACE("AddressFamily %p, SocketType %p, Protocol %p, Group %u, Flags %lx, TransportName %p, HelperDllContext %p, HelperDllData %p, Events %p\n",
41 AddressFamily, SocketType, Protocol, Group, Flags, TransportName, HelperDllContext, HelperDllData, Events);
42
43 /* Check in our Current Loaded Helpers */
44 for (Helpers = SockHelpersListHead.Flink;
45 Helpers != &SockHelpersListHead;
46 Helpers = Helpers->Flink ) {
47
48 HelperData = CONTAINING_RECORD(Helpers, HELPER_DATA, Helpers);
49
50 /* See if this Mapping works for us */
51 if (SockIsTripleInMapping (HelperData->Mapping,
52 *AddressFamily,
53 *SocketType,
54 *Protocol)) {
55
56 /* Call the Helper Dll function get the Transport Name */
57 if (HelperData->WSHOpenSocket2 == NULL ) {
58
59 /* DLL Doesn't support WSHOpenSocket2, call the old one */
60 HelperData->WSHOpenSocket(AddressFamily,
61 SocketType,
62 Protocol,
63 TransportName,
64 HelperDllContext,
65 Events
66 );
67 } else {
68 HelperData->WSHOpenSocket2(AddressFamily,
69 SocketType,
70 Protocol,
71 Group,
72 Flags,
73 TransportName,
74 HelperDllContext,
75 Events
76 );
77 }
78
79 /* Return the Helper Pointers */
80 *HelperDllData = HelperData;
81 return NO_ERROR;
82 }
83 }
84
85 /* Get the Transports available */
86 Status = SockLoadTransportList(&Transports);
87
88 /* Check for error */
89 if (Status) {
90 WARN("Can't get transport list\n");
91 return Status;
92 }
93
94 /* Loop through each transport until we find one that can satisfy us */
95 for (Transport = Transports;
96 *Transports != 0;
97 Transport += wcslen(Transport) + 1) {
98 TRACE("Transport: %S\n", Transports);
99
100 /* See what mapping this Transport supports */
101 Status = SockLoadTransportMapping(Transport, &Mapping);
102
103 /* Check for error */
104 if (Status) {
105 ERR("Can't get mapping for %S\n", Transports);
106 HeapFree(GlobalHeap, 0, Transports);
107 return Status;
108 }
109
110 /* See if this Mapping works for us */
111 if (SockIsTripleInMapping(Mapping, *AddressFamily, *SocketType, *Protocol)) {
112
113 /* It does, so load the DLL associated with it */
114 Status = SockLoadHelperDll(Transport, Mapping, &HelperData);
115
116 /* Check for error */
117 if (Status) {
118 ERR("Can't load helper DLL for Transport %S.\n", Transport);
119 HeapFree(GlobalHeap, 0, Transports);
120 HeapFree(GlobalHeap, 0, Mapping);
121 return Status;
122 }
123
124 /* Call the Helper Dll function get the Transport Name */
125 if (HelperData->WSHOpenSocket2 == NULL) {
126 /* DLL Doesn't support WSHOpenSocket2, call the old one */
127 HelperData->WSHOpenSocket(AddressFamily,
128 SocketType,
129 Protocol,
130 TransportName,
131 HelperDllContext,
132 Events
133 );
134 } else {
135 HelperData->WSHOpenSocket2(AddressFamily,
136 SocketType,
137 Protocol,
138 Group,
139 Flags,
140 TransportName,
141 HelperDllContext,
142 Events
143 );
144 }
145
146 /* Return the Helper Pointers */
147 *HelperDllData = HelperData;
148 /* We actually cache these ... the can't be freed yet */
149 /*HeapFree(GlobalHeap, 0, Transports);*/
150 /*HeapFree(GlobalHeap, 0, Mapping);*/
151 return NO_ERROR;
152 }
153
154 HeapFree(GlobalHeap, 0, Mapping);
155 }
156 HeapFree(GlobalHeap, 0, Transports);
157 return WSAEINVAL;
158 }
159
160 INT
161 SockLoadTransportMapping(
162 PWSTR TransportName,
163 PWINSOCK_MAPPING *Mapping)
164 {
165 PWSTR TransportKey;
166 HKEY KeyHandle;
167 ULONG MappingSize;
168 LONG Status;
169
170 TRACE("TransportName %ws\n", TransportName);
171
172 /* Allocate a Buffer */
173 TransportKey = HeapAlloc(GlobalHeap, 0, (54 + wcslen(TransportName)) * sizeof(WCHAR));
174
175 /* Check for error */
176 if (TransportKey == NULL) {
177 ERR("Buffer allocation failed\n");
178 return WSAEINVAL;
179 }
180
181 /* Generate the right key name */
182 wcscpy(TransportKey, L"System\\CurrentControlSet\\Services\\");
183 wcscat(TransportKey, TransportName);
184 wcscat(TransportKey, L"\\Parameters\\Winsock");
185
186 /* Open the Key */
187 Status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, TransportKey, 0, KEY_READ, &KeyHandle);
188
189 /* We don't need the Transport Key anymore */
190 HeapFree(GlobalHeap, 0, TransportKey);
191
192 /* Check for error */
193 if (Status) {
194 ERR("Error reading transport mapping registry\n");
195 return WSAEINVAL;
196 }
197
198 /* Find out how much space we need for the Mapping */
199 Status = RegQueryValueExW(KeyHandle, L"Mapping", NULL, NULL, NULL, &MappingSize);
200
201 /* Check for error */
202 if (Status) {
203 ERR("Error reading transport mapping registry\n");
204 return WSAEINVAL;
205 }
206
207 /* Allocate Memory for the Mapping */
208 *Mapping = HeapAlloc(GlobalHeap, 0, MappingSize);
209
210 /* Check for error */
211 if (*Mapping == NULL) {
212 ERR("Buffer allocation failed\n");
213 return WSAEINVAL;
214 }
215
216 /* Read the Mapping */
217 Status = RegQueryValueExW(KeyHandle, L"Mapping", NULL, NULL, (LPBYTE)*Mapping, &MappingSize);
218
219 /* Check for error */
220 if (Status) {
221 ERR("Error reading transport mapping registry\n");
222 HeapFree(GlobalHeap, 0, *Mapping);
223 return WSAEINVAL;
224 }
225
226 /* Close key and return */
227 RegCloseKey(KeyHandle);
228 return 0;
229 }
230
231 INT
232 SockLoadTransportList(
233 PWSTR *TransportList)
234 {
235 ULONG TransportListSize;
236 HKEY KeyHandle;
237 LONG Status;
238
239 TRACE("Called\n");
240
241 /* Open the Transports Key */
242 Status = RegOpenKeyExW (HKEY_LOCAL_MACHINE,
243 L"SYSTEM\\CurrentControlSet\\Services\\Winsock\\Parameters",
244 0,
245 KEY_READ,
246 &KeyHandle);
247
248 /* Check for error */
249 if (Status) {
250 ERR("Error reading transport list registry\n");
251 return WSAEINVAL;
252 }
253
254 /* Get the Transport List Size */
255 Status = RegQueryValueExW(KeyHandle,
256 L"Transports",
257 NULL,
258 NULL,
259 NULL,
260 &TransportListSize);
261
262 /* Check for error */
263 if (Status) {
264 ERR("Error reading transport list registry\n");
265 return WSAEINVAL;
266 }
267
268 /* Allocate Memory for the Transport List */
269 *TransportList = HeapAlloc(GlobalHeap, 0, TransportListSize);
270
271 /* Check for error */
272 if (*TransportList == NULL) {
273 ERR("Buffer allocation failed\n");
274 return WSAEINVAL;
275 }
276
277 /* Get the Transports */
278 Status = RegQueryValueExW (KeyHandle,
279 L"Transports",
280 NULL,
281 NULL,
282 (LPBYTE)*TransportList,
283 &TransportListSize);
284
285 /* Check for error */
286 if (Status) {
287 ERR("Error reading transport list registry\n");
288 HeapFree(GlobalHeap, 0, *TransportList);
289 return WSAEINVAL;
290 }
291
292 /* Close key and return */
293 RegCloseKey(KeyHandle);
294 return 0;
295 }
296
297 INT
298 SockLoadHelperDll(
299 PWSTR TransportName,
300 PWINSOCK_MAPPING Mapping,
301 PHELPER_DATA *HelperDllData)
302 {
303 PHELPER_DATA HelperData;
304 PWSTR HelperDllName;
305 PWSTR FullHelperDllName;
306 PWSTR HelperKey;
307 HKEY KeyHandle;
308 ULONG DataSize;
309 LONG Status;
310
311 /* Allocate space for the Helper Structure and TransportName */
312 HelperData = HeapAlloc(GlobalHeap, 0, sizeof(*HelperData) + (wcslen(TransportName) + 1) * sizeof(WCHAR));
313
314 /* Check for error */
315 if (HelperData == NULL) {
316 ERR("Buffer allocation failed\n");
317 return WSAEINVAL;
318 }
319
320 /* Allocate Space for the Helper DLL Key */
321 HelperKey = HeapAlloc(GlobalHeap, 0, (54 + wcslen(TransportName)) * sizeof(WCHAR));
322
323 /* Check for error */
324 if (HelperKey == NULL) {
325 ERR("Buffer allocation failed\n");
326 HeapFree(GlobalHeap, 0, HelperData);
327 return WSAEINVAL;
328 }
329
330 /* Generate the right key name */
331 wcscpy(HelperKey, L"System\\CurrentControlSet\\Services\\");
332 wcscat(HelperKey, TransportName);
333 wcscat(HelperKey, L"\\Parameters\\Winsock");
334
335 /* Open the Key */
336 Status = RegOpenKeyExW(HKEY_LOCAL_MACHINE, HelperKey, 0, KEY_READ, &KeyHandle);
337
338 HeapFree(GlobalHeap, 0, HelperKey);
339
340 /* Check for error */
341 if (Status) {
342 ERR("Error reading helper DLL parameters\n");
343 HeapFree(GlobalHeap, 0, HelperData);
344 return WSAEINVAL;
345 }
346
347 /* Read Size of SockAddr Structures */
348 DataSize = sizeof(HelperData->MinWSAddressLength);
349 HelperData->MinWSAddressLength = 16;
350 RegQueryValueExW (KeyHandle,
351 L"MinSockaddrLength",
352 NULL,
353 NULL,
354 (LPBYTE)&HelperData->MinWSAddressLength,
355 &DataSize);
356 DataSize = sizeof(HelperData->MinWSAddressLength);
357 HelperData->MaxWSAddressLength = 16;
358 RegQueryValueExW (KeyHandle,
359 L"MaxSockaddrLength",
360 NULL,
361 NULL,
362 (LPBYTE)&HelperData->MaxWSAddressLength,
363 &DataSize);
364
365 /* Size of TDI Structures */
366 HelperData->MinTDIAddressLength = HelperData->MinWSAddressLength + 6;
367 HelperData->MaxTDIAddressLength = HelperData->MaxWSAddressLength + 6;
368
369 /* Read Delayed Acceptance Setting */
370 DataSize = sizeof(DWORD);
371 HelperData->UseDelayedAcceptance = FALSE;
372 RegQueryValueExW (KeyHandle,
373 L"UseDelayedAcceptance",
374 NULL,
375 NULL,
376 (LPBYTE)&HelperData->UseDelayedAcceptance,
377 &DataSize);
378
379 /* Allocate Space for the Helper DLL Names */
380 HelperDllName = HeapAlloc(GlobalHeap, 0, 512);
381
382 /* Check for error */
383 if (HelperDllName == NULL) {
384 ERR("Buffer allocation failed\n");
385 HeapFree(GlobalHeap, 0, HelperData);
386 return WSAEINVAL;
387 }
388
389 FullHelperDllName = HeapAlloc(GlobalHeap, 0, 512);
390
391 /* Check for error */
392 if (FullHelperDllName == NULL) {
393 ERR("Buffer allocation failed\n");
394 HeapFree(GlobalHeap, 0, HelperDllName);
395 HeapFree(GlobalHeap, 0, HelperData);
396 return WSAEINVAL;
397 }
398
399 /* Get the name of the Helper DLL*/
400 DataSize = 512;
401 Status = RegQueryValueExW (KeyHandle,
402 L"HelperDllName",
403 NULL,
404 NULL,
405 (LPBYTE)HelperDllName,
406 &DataSize);
407
408 /* Check for error */
409 if (Status) {
410 ERR("Error reading helper DLL parameters\n");
411 HeapFree(GlobalHeap, 0, FullHelperDllName);
412 HeapFree(GlobalHeap, 0, HelperDllName);
413 HeapFree(GlobalHeap, 0, HelperData);
414 return WSAEINVAL;
415 }
416
417 /* Get the Full name, expanding Environment Strings */
418 ExpandEnvironmentStringsW (HelperDllName,
419 FullHelperDllName,
420 256);
421
422 /* Load the DLL */
423 HelperData->hInstance = LoadLibraryW(FullHelperDllName);
424
425 HeapFree(GlobalHeap, 0, HelperDllName);
426 HeapFree(GlobalHeap, 0, FullHelperDllName);
427
428 if (HelperData->hInstance == NULL) {
429 ERR("Error loading helper DLL\n");
430 HeapFree(GlobalHeap, 0, HelperData);
431 return WSAEINVAL;
432 }
433
434 /* Close Key */
435 RegCloseKey(KeyHandle);
436
437 /* Get the Pointers to the Helper Routines */
438 HelperData->WSHOpenSocket = (PWSH_OPEN_SOCKET)
439 GetProcAddress(HelperData->hInstance,
440 "WSHOpenSocket");
441 HelperData->WSHOpenSocket2 = (PWSH_OPEN_SOCKET2)
442 GetProcAddress(HelperData->hInstance,
443 "WSHOpenSocket2");
444 HelperData->WSHJoinLeaf = (PWSH_JOIN_LEAF)
445 GetProcAddress(HelperData->hInstance,
446 "WSHJoinLeaf");
447 HelperData->WSHNotify = (PWSH_NOTIFY)
448 GetProcAddress(HelperData->hInstance, "WSHNotify");
449 HelperData->WSHGetSocketInformation = (PWSH_GET_SOCKET_INFORMATION)
450 GetProcAddress(HelperData->hInstance,
451 "WSHGetSocketInformation");
452 HelperData->WSHSetSocketInformation = (PWSH_SET_SOCKET_INFORMATION)
453 GetProcAddress(HelperData->hInstance,
454 "WSHSetSocketInformation");
455 HelperData->WSHGetSockaddrType = (PWSH_GET_SOCKADDR_TYPE)
456 GetProcAddress(HelperData->hInstance,
457 "WSHGetSockaddrType");
458 HelperData->WSHGetWildcardSockaddr = (PWSH_GET_WILDCARD_SOCKADDR)
459 GetProcAddress(HelperData->hInstance,
460 "WSHGetWildcardSockaddr");
461 HelperData->WSHGetBroadcastSockaddr = (PWSH_GET_BROADCAST_SOCKADDR)
462 GetProcAddress(HelperData->hInstance,
463 "WSHGetBroadcastSockaddr");
464 HelperData->WSHAddressToString = (PWSH_ADDRESS_TO_STRING)
465 GetProcAddress(HelperData->hInstance,
466 "WSHAddressToString");
467 HelperData->WSHStringToAddress = (PWSH_STRING_TO_ADDRESS)
468 GetProcAddress(HelperData->hInstance,
469 "WSHStringToAddress");
470 HelperData->WSHIoctl = (PWSH_IOCTL)
471 GetProcAddress(HelperData->hInstance,
472 "WSHIoctl");
473
474 /* Save the Mapping Structure and transport name */
475 HelperData->Mapping = Mapping;
476 wcscpy(HelperData->TransportName, TransportName);
477
478 /* Increment Reference Count */
479 HelperData->RefCount = 1;
480
481 /* Add it to our list */
482 InsertHeadList(&SockHelpersListHead, &HelperData->Helpers);
483
484 /* Return Pointers */
485 *HelperDllData = HelperData;
486 return 0;
487 }
488
489 BOOL
490 SockIsTripleInMapping(
491 PWINSOCK_MAPPING Mapping,
492 INT AddressFamily,
493 INT SocketType,
494 INT Protocol)
495 {
496 /* The Windows version returns more detailed information on which of the 3 parameters failed...we should do this later */
497 ULONG Row;
498
499 TRACE("Called, Mapping rows = %d\n", Mapping->Rows);
500
501 /* Loop through Mapping to Find a matching one */
502 for (Row = 0; Row < Mapping->Rows; Row++) {
503 TRACE("Examining: row %d: AF %d type %d proto %d\n",
504 Row,
505 (INT)Mapping->Mapping[Row].AddressFamily,
506 (INT)Mapping->Mapping[Row].SocketType,
507 (INT)Mapping->Mapping[Row].Protocol);
508
509 /* Check of all three values Match */
510 if (((INT)Mapping->Mapping[Row].AddressFamily == AddressFamily) &&
511 ((INT)Mapping->Mapping[Row].SocketType == SocketType) &&
512 ((INT)Mapping->Mapping[Row].Protocol == Protocol)) {
513 TRACE("Found\n");
514 return TRUE;
515 }
516 }
517 WARN("Not found\n");
518 return FALSE;
519 }
520
521 /* EOF */