ReactOS  0.4.15-dev-1171-gab82533
alias.c
Go to the documentation of this file.
1 /*
2  * LICENSE: GPL - See COPYING in the top level directory
3  * PROJECT: ReactOS Console Server DLL
4  * FILE: win32ss/user/winsrv/consrv/alias.c
5  * PURPOSE: Alias support functions
6  * PROGRAMMERS: Christoph Wittich
7  * Johannes Anderwald
8  */
9 
10 /* INCLUDES *******************************************************************/
11 
12 #include "consrv.h"
13 
14 #define NDEBUG
15 #include <debug.h>
16 
17 /* TYPES **********************************************************************/
18 
19 typedef struct _ALIAS_ENTRY
20 {
21  struct _ALIAS_ENTRY* Next;
25 
26 typedef struct _ALIAS_HEADER
27 {
32 
33 
34 
35 
36 BOOLEAN
38  PVOID Source,
39  USHORT SourceLength,
40  // BOOLEAN IsUnicode,
41  PWCHAR* Target,
42  PUSHORT TargetLength)
43 {
44  ASSERT(Source && Target && TargetLength);
45 
46  /* Use the console input CP for the conversion */
47  *TargetLength = MultiByteToWideChar(Console->InputCodePage, 0,
48  Source, SourceLength,
49  NULL, 0);
50  *Target = ConsoleAllocHeap(0, *TargetLength * sizeof(WCHAR));
51  if (*Target == NULL) return FALSE;
52 
53  MultiByteToWideChar(Console->InputCodePage, 0,
54  Source, SourceLength,
55  *Target, *TargetLength);
56 
57  /* The returned Length was in number of WCHARs, convert it in bytes */
58  *TargetLength *= sizeof(WCHAR);
59 
60  return TRUE;
61 }
62 
63 BOOLEAN
65  PVOID Source,
66  USHORT SourceLength,
67  // BOOLEAN IsAnsi,
68  PCHAR/* * */ Target,
69  /*P*/USHORT TargetLength)
70 {
71  ASSERT(Source && Target && TargetLength);
72 
73  /*
74  * From MSDN:
75  * "The lpMultiByteStr and lpWideCharStr pointers must not be the same.
76  * If they are the same, the function fails, and GetLastError returns
77  * ERROR_INVALID_PARAMETER."
78  */
80 
81  /* Use the console input CP for the conversion */
82  // *TargetLength = WideCharToMultiByte(Console->InputCodePage, 0,
83  // Source, SourceLength,
84  // NULL, 0, NULL, NULL);
85  // *Target = ConsoleAllocHeap(0, *TargetLength * sizeof(WCHAR));
86  // if (*Target == NULL) return FALSE;
87 
88  WideCharToMultiByte(Console->InputCodePage, 0,
89  Source, SourceLength,
90  /* * */Target, /* * */TargetLength,
91  NULL, NULL);
92 
93  // /* The returned Length was in number of WCHARs, convert it in bytes */
94  // *TargetLength *= sizeof(WCHAR);
95 
96  return TRUE;
97 }
98 
99 
100 
101 
102 /* PRIVATE FUNCTIONS **********************************************************/
103 
104 static PALIAS_HEADER
106  PVOID ExeName,
107  USHORT ExeLength,
108  BOOLEAN UnicodeExe)
109 {
110  UNICODE_STRING ExeNameU;
111 
112  PALIAS_HEADER RootHeader = Console->Aliases;
113  INT Diff;
114 
115  if (ExeName == NULL) return NULL;
116 
117  if (UnicodeExe)
118  {
119  ExeNameU.Buffer = ExeName;
120  /* Length is in bytes */
121  ExeNameU.MaximumLength = ExeLength;
122  }
123  else
124  {
126  ExeName, ExeLength,
127  &ExeNameU.Buffer, &ExeNameU.MaximumLength))
128  {
129  return NULL;
130  }
131  }
132  ExeNameU.Length = ExeNameU.MaximumLength;
133 
134  while (RootHeader)
135  {
136  Diff = RtlCompareUnicodeString(&RootHeader->ExeName, &ExeNameU, TRUE);
137  if (!Diff)
138  {
139  if (!UnicodeExe) ConsoleFreeHeap(ExeNameU.Buffer);
140  return RootHeader;
141  }
142  if (Diff > 0) break;
143 
144  RootHeader = RootHeader->Next;
145  }
146 
147  if (!UnicodeExe) ConsoleFreeHeap(ExeNameU.Buffer);
148  return NULL;
149 }
150 
151 static PALIAS_HEADER
153  PVOID ExeName,
154  USHORT ExeLength,
155  BOOLEAN UnicodeExe)
156 {
157  UNICODE_STRING ExeNameU;
158 
160 
161  if (ExeName == NULL) return NULL;
162 
163  if (UnicodeExe)
164  {
165  ExeNameU.Buffer = ExeName;
166  /* Length is in bytes */
167  ExeNameU.MaximumLength = ExeLength;
168  }
169  else
170  {
172  ExeName, ExeLength,
173  &ExeNameU.Buffer, &ExeNameU.MaximumLength))
174  {
175  return NULL;
176  }
177  }
178  ExeNameU.Length = ExeNameU.MaximumLength;
179 
180  Entry = ConsoleAllocHeap(0, sizeof(ALIAS_HEADER) + ExeNameU.Length);
181  if (!Entry)
182  {
183  if (!UnicodeExe) ConsoleFreeHeap(ExeNameU.Buffer);
184  return Entry;
185  }
186 
187  Entry->ExeName.Buffer = (PWSTR)(Entry + 1);
188  Entry->ExeName.Length = 0;
189  Entry->ExeName.MaximumLength = ExeNameU.Length;
190  RtlCopyUnicodeString(&Entry->ExeName, &ExeNameU);
191 
192  Entry->Data = NULL;
193  Entry->Next = NULL;
194 
195  if (!UnicodeExe) ConsoleFreeHeap(ExeNameU.Buffer);
196  return Entry;
197 }
198 
199 static VOID
201  PALIAS_HEADER NewHeader)
202 {
203  PALIAS_HEADER CurrentHeader;
204  PALIAS_HEADER *LastLink = RootHeader;
205  INT Diff;
206 
207  while ((CurrentHeader = *LastLink) != NULL)
208  {
209  Diff = RtlCompareUnicodeString(&NewHeader->ExeName, &CurrentHeader->ExeName, TRUE);
210  if (Diff < 0) break;
211 
212  LastLink = &CurrentHeader->Next;
213  }
214 
215  *LastLink = NewHeader;
216  NewHeader->Next = CurrentHeader;
217 }
218 
219 static PALIAS_ENTRY
222  PVOID Source,
223  USHORT SourceLength,
224  BOOLEAN Unicode)
225 {
226  UNICODE_STRING SourceU;
227 
229  INT Diff;
230 
231  if (Header == NULL || Source == NULL) return NULL;
232 
233  if (Unicode)
234  {
235  SourceU.Buffer = Source;
236  /* Length is in bytes */
237  SourceU.MaximumLength = SourceLength;
238  }
239  else
240  {
242  Source, SourceLength,
243  &SourceU.Buffer, &SourceU.MaximumLength))
244  {
245  return NULL;
246  }
247  }
248  SourceU.Length = SourceU.MaximumLength;
249 
250  Entry = Header->Data;
251  while (Entry)
252  {
253  Diff = RtlCompareUnicodeString(&Entry->Source, &SourceU, TRUE);
254  if (!Diff)
255  {
256  if (!Unicode) ConsoleFreeHeap(SourceU.Buffer);
257  return Entry;
258  }
259  if (Diff > 0) break;
260 
261  Entry = Entry->Next;
262  }
263 
264  if (!Unicode) ConsoleFreeHeap(SourceU.Buffer);
265  return NULL;
266 }
267 
268 static PALIAS_ENTRY
270  PVOID Source,
271  USHORT SourceLength,
272  PVOID Target,
273  USHORT TargetLength,
274  BOOLEAN Unicode)
275 {
276  UNICODE_STRING SourceU;
277  UNICODE_STRING TargetU;
278 
280 
281  if (Unicode)
282  {
283  SourceU.Buffer = Source;
284  TargetU.Buffer = Target;
285  /* Length is in bytes */
286  SourceU.MaximumLength = SourceLength;
287  TargetU.MaximumLength = TargetLength;
288  }
289  else
290  {
292  Source, SourceLength,
293  &SourceU.Buffer, &SourceU.MaximumLength))
294  {
295  return NULL;
296  }
297 
299  Target, TargetLength,
300  &TargetU.Buffer, &TargetU.MaximumLength))
301  {
302  ConsoleFreeHeap(SourceU.Buffer);
303  return NULL;
304  }
305  }
306  SourceU.Length = SourceU.MaximumLength;
307  TargetU.Length = TargetU.MaximumLength;
308 
309  Entry = ConsoleAllocHeap(0, sizeof(ALIAS_ENTRY) +
310  SourceU.Length + TargetU.Length);
311  if (!Entry)
312  {
313  if (!Unicode)
314  {
315  ConsoleFreeHeap(TargetU.Buffer);
316  ConsoleFreeHeap(SourceU.Buffer);
317  }
318  return Entry;
319  }
320 
321  Entry->Source.Buffer = (PWSTR)(Entry + 1);
322  Entry->Source.Length = 0;
323  Entry->Source.MaximumLength = SourceU.Length;
324  RtlCopyUnicodeString(&Entry->Source, &SourceU);
325 
326  Entry->Target.Buffer = (PWSTR)((ULONG_PTR)Entry->Source.Buffer + Entry->Source.MaximumLength);
327  Entry->Target.Length = 0;
328  Entry->Target.MaximumLength = TargetU.Length;
329  RtlCopyUnicodeString(&Entry->Target, &TargetU);
330 
331  Entry->Next = NULL;
332 
333  if (!Unicode)
334  {
335  ConsoleFreeHeap(TargetU.Buffer);
336  ConsoleFreeHeap(SourceU.Buffer);
337  }
338  return Entry;
339 }
340 
341 static VOID
343  PALIAS_ENTRY NewEntry)
344 {
345  PALIAS_ENTRY CurrentEntry;
346  PALIAS_ENTRY *LastLink = &Header->Data;
347  INT Diff;
348 
349  while ((CurrentEntry = *LastLink) != NULL)
350  {
351  Diff = RtlCompareUnicodeString(&NewEntry->Source, &CurrentEntry->Source, TRUE);
352  if (Diff < 0) break;
353 
354  LastLink = &CurrentEntry->Next;
355  }
356 
357  *LastLink = NewEntry;
358  NewEntry->Next = CurrentEntry;
359 }
360 
361 static VOID
364 {
365  PALIAS_ENTRY *LastLink = &Header->Data;
366  PALIAS_ENTRY CurEntry;
367 
368  while ((CurEntry = *LastLink) != NULL)
369  {
370  if (CurEntry == Entry)
371  {
372  *LastLink = Entry->Next;
374  return;
375  }
376  LastLink = &CurEntry->Next;
377  }
378 }
379 
380 static UINT
382  BOOLEAN IsUnicode)
383 {
384  UINT Length = 0;
385 
386  while (RootHeader)
387  {
388  Length += RootHeader->ExeName.Length + sizeof(WCHAR); // NULL-termination
389  RootHeader = RootHeader->Next;
390  }
391 
392  /*
393  * Quick and dirty way of getting the number of bytes of the
394  * corresponding ANSI string from the one in UNICODE.
395  */
396  if (!IsUnicode)
397  Length /= sizeof(WCHAR);
398 
399  return Length;
400 }
401 
402 static UINT
404  BOOLEAN IsUnicode)
405 {
406  UINT Length = 0;
407  PALIAS_ENTRY CurEntry = Header->Data;
408 
409  while (CurEntry)
410  {
411  Length += CurEntry->Source.Length;
412  Length += CurEntry->Target.Length;
413  Length += 2 * sizeof(WCHAR); // '=' and NULL-termination
414  CurEntry = CurEntry->Next;
415  }
416 
417  /*
418  * Quick and dirty way of getting the number of bytes of the
419  * corresponding ANSI string from the one in UNICODE.
420  */
421  if (!IsUnicode)
422  Length /= sizeof(WCHAR);
423 
424  return Length;
425 }
426 
427 VOID
429 {
430  PALIAS_HEADER Header, NextHeader;
431  PALIAS_ENTRY Entry, NextEntry;
432 
433  for (Header = Console->Aliases; Header; Header = NextHeader)
434  {
435  NextHeader = Header->Next;
436  for (Entry = Header->Data; Entry; Entry = NextEntry)
437  {
438  NextEntry = Entry->Next;
440  }
442  }
443 }
444 
445 
446 /* PUBLIC SERVER APIS *********************************************************/
447 
448 /* API_NUMBER: ConsolepAddAlias */
449 CON_API(SrvAddConsoleAlias,
450  CONSOLE_ADDGETALIAS, ConsoleAliasRequest)
451 {
454  PVOID lpTarget;
455 
456  if ( !CsrValidateMessageBuffer(ApiMessage,
457  (PVOID*)&ConsoleAliasRequest->Source,
458  ConsoleAliasRequest->SourceLength,
459  sizeof(BYTE)) ||
460  !CsrValidateMessageBuffer(ApiMessage,
461  (PVOID*)&ConsoleAliasRequest->Target,
462  ConsoleAliasRequest->TargetLength,
463  sizeof(BYTE)) ||
464  !CsrValidateMessageBuffer(ApiMessage,
465  (PVOID*)&ConsoleAliasRequest->ExeName,
466  ConsoleAliasRequest->ExeLength,
467  sizeof(BYTE)) )
468  {
470  }
471 
472  lpTarget = (ConsoleAliasRequest->TargetLength != 0 ? ConsoleAliasRequest->Target : NULL);
473 
475  ConsoleAliasRequest->ExeName,
476  ConsoleAliasRequest->ExeLength,
477  ConsoleAliasRequest->Unicode2);
478  if (!Header && lpTarget != NULL)
479  {
481  ConsoleAliasRequest->ExeName,
482  ConsoleAliasRequest->ExeLength,
483  ConsoleAliasRequest->Unicode2);
484  if (!Header)
485  return STATUS_NO_MEMORY;
486 
487  IntInsertAliasHeader(&Console->Aliases, Header);
488  }
489 
490  if (lpTarget == NULL) // Delete the entry
491  {
493  ConsoleAliasRequest->Source,
494  ConsoleAliasRequest->SourceLength,
495  ConsoleAliasRequest->Unicode);
496  if (!Entry)
497  return STATUS_UNSUCCESSFUL;
498 
500  }
501  else // Add the entry
502  {
504  ConsoleAliasRequest->Source,
505  ConsoleAliasRequest->SourceLength,
506  ConsoleAliasRequest->Target,
507  ConsoleAliasRequest->TargetLength,
508  ConsoleAliasRequest->Unicode);
509  if (!Entry)
510  return STATUS_NO_MEMORY;
511 
513  }
514 
515  return STATUS_SUCCESS;
516 }
517 
518 /* API_NUMBER: ConsolepGetAlias */
519 CON_API(SrvGetConsoleAlias,
520  CONSOLE_ADDGETALIAS, ConsoleAliasRequest)
521 {
524  UINT Length;
525  PVOID lpTarget;
526 
527  if ( !CsrValidateMessageBuffer(ApiMessage,
528  (PVOID*)&ConsoleAliasRequest->Source,
529  ConsoleAliasRequest->SourceLength,
530  sizeof(BYTE)) ||
531  !CsrValidateMessageBuffer(ApiMessage,
532  (PVOID*)&ConsoleAliasRequest->Target,
533  ConsoleAliasRequest->TargetLength,
534  sizeof(BYTE)) ||
535  !CsrValidateMessageBuffer(ApiMessage,
536  (PVOID*)&ConsoleAliasRequest->ExeName,
537  ConsoleAliasRequest->ExeLength,
538  sizeof(BYTE)) )
539  {
541  }
542 
543  lpTarget = ConsoleAliasRequest->Target;
544 
545  if (ConsoleAliasRequest->ExeLength == 0 || lpTarget == NULL ||
546  ConsoleAliasRequest->TargetLength == 0 || ConsoleAliasRequest->SourceLength == 0)
547  {
549  }
550 
552  ConsoleAliasRequest->ExeName,
553  ConsoleAliasRequest->ExeLength,
554  ConsoleAliasRequest->Unicode2);
555  if (!Header)
556  return STATUS_UNSUCCESSFUL;
557 
559  ConsoleAliasRequest->Source,
560  ConsoleAliasRequest->SourceLength,
561  ConsoleAliasRequest->Unicode);
562  if (!Entry)
563  return STATUS_UNSUCCESSFUL;
564 
565  if (ConsoleAliasRequest->Unicode)
566  {
567  Length = Entry->Target.Length + sizeof(WCHAR);
568  if (Length > ConsoleAliasRequest->TargetLength) // FIXME: Refine computation.
569  {
571  }
572 
573  RtlCopyMemory(lpTarget, Entry->Target.Buffer, Entry->Target.Length);
574  ConsoleAliasRequest->TargetLength = Length;
575  }
576  else
577  {
578  Length = (Entry->Target.Length + sizeof(WCHAR)) / sizeof(WCHAR);
579  if (Length > ConsoleAliasRequest->TargetLength) // FIXME: Refine computation.
580  {
582  }
583 
585  Entry->Target.Buffer, Entry->Target.Length,
586  lpTarget, Entry->Target.Length / sizeof(WCHAR));
587  ConsoleAliasRequest->TargetLength = Length;
588  }
589 
590  return STATUS_SUCCESS;
591 }
592 
593 /* API_NUMBER: ConsolepGetAliases */
594 CON_API(SrvGetConsoleAliases,
595  CONSOLE_GETALLALIASES, GetAllAliasesRequest)
596 {
598  ULONG BytesWritten = 0;
600 
601  if ( !CsrValidateMessageBuffer(ApiMessage,
602  (PVOID)&GetAllAliasesRequest->ExeName,
603  GetAllAliasesRequest->ExeLength,
604  sizeof(BYTE)) ||
605  !CsrValidateMessageBuffer(ApiMessage,
606  (PVOID)&GetAllAliasesRequest->AliasesBuffer,
607  GetAllAliasesRequest->AliasesBufferLength,
608  sizeof(BYTE)) )
609  {
611  }
612 
614  GetAllAliasesRequest->ExeName,
615  GetAllAliasesRequest->ExeLength,
616  GetAllAliasesRequest->Unicode2);
617  if (!Header)
618  {
620  goto Quit;
621  }
622 
623  if (IntGetAllConsoleAliasesLength(Header, GetAllAliasesRequest->Unicode) > GetAllAliasesRequest->AliasesBufferLength)
624  {
626  goto Quit;
627  }
628 
629  {
630  LPSTR TargetBufferA;
631  LPWSTR TargetBufferW;
632  UINT TargetBufferLength = GetAllAliasesRequest->AliasesBufferLength;
633 
634  PALIAS_ENTRY CurEntry = Header->Data;
635  UINT Offset = 0;
636  UINT SourceLength, TargetLength;
637 
638  if (GetAllAliasesRequest->Unicode)
639  {
640  TargetBufferW = GetAllAliasesRequest->AliasesBuffer;
641  TargetBufferLength /= sizeof(WCHAR);
642  }
643  else
644  {
645  TargetBufferA = GetAllAliasesRequest->AliasesBuffer;
646  }
647 
648  while (CurEntry)
649  {
650  SourceLength = CurEntry->Source.Length / sizeof(WCHAR);
651  TargetLength = CurEntry->Target.Length / sizeof(WCHAR);
652  if (Offset + TargetLength + SourceLength + 2 > TargetBufferLength)
653  {
655  break;
656  }
657 
658  if (GetAllAliasesRequest->Unicode)
659  {
660  RtlCopyMemory(&TargetBufferW[Offset], CurEntry->Source.Buffer, SourceLength * sizeof(WCHAR));
661  Offset += SourceLength;
662  TargetBufferW[Offset++] = L'=';
663  RtlCopyMemory(&TargetBufferW[Offset], CurEntry->Target.Buffer, TargetLength * sizeof(WCHAR));
664  Offset += TargetLength;
665  TargetBufferW[Offset++] = L'\0';
666  }
667  else
668  {
670  CurEntry->Source.Buffer, SourceLength * sizeof(WCHAR),
671  &TargetBufferA[Offset], SourceLength);
672  Offset += SourceLength;
673  TargetBufferA[Offset++] = '=';
675  CurEntry->Target.Buffer, TargetLength * sizeof(WCHAR),
676  &TargetBufferA[Offset], TargetLength);
677  Offset += TargetLength;
678  TargetBufferA[Offset++] = '\0';
679  }
680 
681  CurEntry = CurEntry->Next;
682  }
683 
684  if (GetAllAliasesRequest->Unicode)
685  BytesWritten = Offset * sizeof(WCHAR);
686  else
688  }
689 
690 Quit:
691  GetAllAliasesRequest->AliasesBufferLength = BytesWritten;
692 
693  return Status;
694 }
695 
696 /* API_NUMBER: ConsolepGetAliasesLength */
697 CON_API(SrvGetConsoleAliasesLength,
698  CONSOLE_GETALLALIASESLENGTH, GetAllAliasesLengthRequest)
699 {
702 
703  if (!CsrValidateMessageBuffer(ApiMessage,
704  (PVOID)&GetAllAliasesLengthRequest->ExeName,
705  GetAllAliasesLengthRequest->ExeLength,
706  sizeof(BYTE)))
707  {
709  }
710 
712  GetAllAliasesLengthRequest->ExeName,
713  GetAllAliasesLengthRequest->ExeLength,
714  GetAllAliasesLengthRequest->Unicode2);
715  if (Header)
716  {
717  GetAllAliasesLengthRequest->Length =
719  GetAllAliasesLengthRequest->Unicode);
721  }
722  else
723  {
724  GetAllAliasesLengthRequest->Length = 0;
725  }
726 
727  return Status;
728 }
729 
730 /* API_NUMBER: ConsolepGetAliasExes */
731 CON_API(SrvGetConsoleAliasExes,
732  CONSOLE_GETALIASESEXES, GetAliasesExesRequest)
733 {
735  UINT BytesWritten = 0;
736 
737  if (!CsrValidateMessageBuffer(ApiMessage,
738  (PVOID*)&GetAliasesExesRequest->ExeNames,
739  GetAliasesExesRequest->Length,
740  sizeof(BYTE)))
741  {
743  }
744 
745  if (IntGetConsoleAliasesExesLength(Console->Aliases, GetAliasesExesRequest->Unicode) > GetAliasesExesRequest->Length)
746  {
748  goto Quit;
749  }
750 
751  {
752  PALIAS_HEADER RootHeader = Console->Aliases;
753 
754  LPSTR TargetBufferA;
755  LPWSTR TargetBufferW;
756  UINT TargetBufferSize = GetAliasesExesRequest->Length;
757 
758  UINT Offset = 0;
759  UINT Length;
760 
761  if (GetAliasesExesRequest->Unicode)
762  {
763  TargetBufferW = GetAliasesExesRequest->ExeNames;
764  TargetBufferSize /= sizeof(WCHAR);
765  }
766  else
767  {
768  TargetBufferA = GetAliasesExesRequest->ExeNames;
769  }
770 
771  while (RootHeader)
772  {
773  Length = RootHeader->ExeName.Length / sizeof(WCHAR);
774  if (Offset + Length + 1 > TargetBufferSize)
775  {
777  break;
778  }
779 
780  if (GetAliasesExesRequest->Unicode)
781  {
782  RtlCopyMemory(&TargetBufferW[Offset], RootHeader->ExeName.Buffer, Length * sizeof(WCHAR));
783  Offset += Length;
784  TargetBufferW[Offset++] = L'\0';
785  }
786  else
787  {
789  RootHeader->ExeName.Buffer, Length * sizeof(WCHAR),
790  &TargetBufferA[Offset], Length);
791  Offset += Length;
792  TargetBufferA[Offset++] = '\0';
793  }
794 
795  RootHeader = RootHeader->Next;
796  }
797 
798  if (GetAliasesExesRequest->Unicode)
799  BytesWritten = Offset * sizeof(WCHAR);
800  else
802  }
803 
804 Quit:
805  GetAliasesExesRequest->Length = BytesWritten;
806 
807  return Status;
808 }
809 
810 /* API_NUMBER: ConsolepGetAliasExesLength */
811 CON_API(SrvGetConsoleAliasExesLength,
812  CONSOLE_GETALIASESEXESLENGTH, GetAliasesExesLengthRequest)
813 {
814  GetAliasesExesLengthRequest->Length =
816  GetAliasesExesLengthRequest->Unicode);
817 
818  return STATUS_SUCCESS;
819 }
820 
821 /* EOF */
signed char * PCHAR
Definition: retypes.h:7
VOID IntDeleteAllAliases(PCONSRV_CONSOLE Console)
Definition: alias.c:428
_Must_inspect_result_ _In_ PFILE_OBJECT _In_opt_ PLARGE_INTEGER _In_ ULONG _In_ FLT_IO_OPERATION_FLAGS _Out_opt_ PULONG BytesWritten
Definition: fltkernel.h:1293
NTSYSAPI VOID NTAPI RtlCopyMemory(VOID UNALIGNED *Destination, CONST VOID UNALIGNED *Source, ULONG Length)
#define WideCharToMultiByte
Definition: compat.h:111
struct _Entry Entry
Definition: kefuncs.h:627
USHORT MaximumLength
Definition: env_spec_w32.h:370
#define TRUE
Definition: types.h:120
#define STATUS_INVALID_PARAMETER
Definition: udferr_usr.h:135
uint16_t * PWSTR
Definition: typedefs.h:56
LONG NTSTATUS
Definition: precomp.h:26
static PALIAS_ENTRY IntCreateAliasEntry(PCONSRV_CONSOLE Console, PVOID Source, USHORT SourceLength, PVOID Target, USHORT TargetLength, BOOLEAN Unicode)
Definition: alias.c:269
BOOLEAN NTAPI CsrValidateMessageBuffer(IN PCSR_API_MESSAGE ApiMessage, IN PVOID *Buffer, IN ULONG ElementCount, IN ULONG ElementSize)
Definition: api.c:1426
#define ConsoleAllocHeap(Flags, Size)
Definition: heap.h:14
struct _ALIAS_HEADER * Next
Definition: alias.c:28
struct _ALIAS_ENTRY * PALIAS_ENTRY
uint16_t * PWCHAR
Definition: typedefs.h:56
char * LPSTR
Definition: xmlstorage.h:182
int32_t INT
Definition: typedefs.h:58
NTSYSAPI VOID NTAPI RtlCopyUnicodeString(PUNICODE_STRING DestinationString, PUNICODE_STRING SourceString)
#define STATUS_BUFFER_TOO_SMALL
Definition: shellext.h:69
struct _ALIAS_HEADER ALIAS_HEADER
uint32_t ULONG_PTR
Definition: typedefs.h:65
PALIAS_ENTRY Data
Definition: alias.c:30
struct _ALIAS_ENTRY * Next
Definition: alias.c:21
_In_ ULONG _In_ ULONG Offset
Definition: ntddpcm.h:101
#define FALSE
Definition: types.h:117
Definition: Header.h:8
BOOLEAN ConvertInputAnsiToUnicode(PCONSRV_CONSOLE Console, PVOID Source, USHORT SourceLength, PWCHAR *Target, PUSHORT TargetLength)
Definition: alias.c:37
unsigned char BOOLEAN
smooth NULL
Definition: ftsmooth.c:416
UNICODE_STRING Target
Definition: alias.c:23
__wchar_t WCHAR
Definition: xmlstorage.h:180
static VOID IntInsertAliasHeader(PALIAS_HEADER *RootHeader, PALIAS_HEADER NewHeader)
Definition: alias.c:200
CON_API(SrvAddConsoleAlias, CONSOLE_ADDGETALIAS, ConsoleAliasRequest)
Definition: alias.c:449
static VOID IntDeleteAliasEntry(PALIAS_HEADER Header, PALIAS_ENTRY Entry)
Definition: alias.c:362
_In_ ULONG _In_ ULONG _In_ ULONG Length
Definition: ntddpcm.h:101
_Must_inspect_result_ typedef _In_ ULONG _In_ BOOLEAN Target
Definition: iotypes.h:1088
ASSERT((InvokeOnSuccess||InvokeOnError||InvokeOnCancel) ?(CompletionRoutine !=NULL) :TRUE)
#define STATUS_UNSUCCESSFUL
Definition: udferr_usr.h:132
struct _ALIAS_HEADER * PALIAS_HEADER
Status
Definition: gdiplustypes.h:24
static const WCHAR L[]
Definition: oid.c:1250
ULONG RtlCompareUnicodeString(PUNICODE_STRING s1, PUNICODE_STRING s2, BOOLEAN UpCase)
Definition: string_lib.cpp:31
UNICODE_STRING ExeName
Definition: alias.c:29
UNICODE_STRING Source
Definition: alias.c:22
unsigned char BYTE
Definition: xxhash.c:193
Definition: alias.c:19
#define STATUS_BUFFER_OVERFLOW
Definition: shellext.h:66
unsigned short USHORT
Definition: pedump.c:61
#define STATUS_NO_MEMORY
Definition: ntstatus.h:260
unsigned int UINT
Definition: ndis.h:50
#define MultiByteToWideChar
Definition: compat.h:110
CConsole Console
#define ConsoleFreeHeap(HeapBase)
Definition: heap.h:15
BOOLEAN ConvertInputUnicodeToAnsi(PCONSRV_CONSOLE Console, PVOID Source, USHORT SourceLength, PCHAR Target, USHORT TargetLength)
Definition: alias.c:64
static PALIAS_ENTRY IntGetAliasEntry(PCONSRV_CONSOLE Console, PALIAS_HEADER Header, PVOID Source, USHORT SourceLength, BOOLEAN Unicode)
Definition: alias.c:220
static UINT IntGetAllConsoleAliasesLength(PALIAS_HEADER Header, BOOLEAN IsUnicode)
Definition: alias.c:403
unsigned int ULONG
Definition: retypes.h:1
_In_ UINT _In_ UINT _In_ PNDIS_PACKET Source
Definition: ndis.h:3167
static PALIAS_HEADER IntCreateAliasHeader(PCONSRV_CONSOLE Console, PVOID ExeName, USHORT ExeLength, BOOLEAN UnicodeExe)
Definition: alias.c:152
WCHAR * LPWSTR
Definition: xmlstorage.h:184
static UINT IntGetConsoleAliasesExesLength(PALIAS_HEADER RootHeader, BOOLEAN IsUnicode)
Definition: alias.c:381
return STATUS_SUCCESS
Definition: btrfs.c:3014
static VOID IntInsertAliasEntry(PALIAS_HEADER Header, PALIAS_ENTRY NewEntry)
Definition: alias.c:342
struct _ALIAS_ENTRY ALIAS_ENTRY
unsigned short * PUSHORT
Definition: retypes.h:2
base of all file and directory entries
Definition: entries.h:82
static PALIAS_HEADER IntFindAliasHeader(PCONSRV_CONSOLE Console, PVOID ExeName, USHORT ExeLength, BOOLEAN UnicodeExe)
Definition: alias.c:105