drivers/sac/driver/util.c

   1 /*
   2  * PROJECT:     ReactOS Drivers
   3  * LICENSE:     BSD - See COPYING.ARM in the top level directory
   4  * FILE:        drivers/sac/driver/util.c
   5  * PURPOSE:     Driver for the Server Administration Console (SAC) for EMS
   6  * PROGRAMMERS: ReactOS Portable Systems Group
   7  */
   8
   9 /* INCLUDES *******************************************************************/
  10
  11 #include "sacdrv.h"
  12
  13 #include <ndk/rtlfuncs.h>
  14
  15 /* GLOBALS ********************************************************************/
  16
  17 PCHAR Utf8ConversionBuffer;
  18 ULONG Utf8ConversionBufferSize = PAGE_SIZE;
  19
  20 PSAC_MACHINE_INFO MachineInformation;
  21
  22 PVOID RequestSacCmdEventObjectBody;
  23 PKEVENT RequestSacCmdEventWaitObjectBody;
  24 PVOID RequestSacCmdSuccessEventObjectBody;
  25 PKEVENT RequestSacCmdSuccessEventWaitObjectBody;
  26 PVOID RequestSacCmdFailureEventObjectBody;
  27 PKEVENT RequestSacCmdFailureEventWaitObjectBody;
  28 PFILE_OBJECT ServiceProcessFileObject;
  29 BOOLEAN HaveUserModeServiceCmdEventInfo;
  30
  31 PSAC_MESSAGE_ENTRY GlobalMessageTable;
  32 ULONG GlobalMessageTableCount;
  33
  34 LONG SerialPortConsumerIndex, SerialPortProducerIndex;
  35 PCHAR SerialPortBuffer;
  36
  37 /* FUNCTIONS ******************************************************************/
  38
  39 BOOLEAN
  40 NTAPI
  41 SacTranslateUtf8ToUnicode(IN CHAR Utf8Char,
  42                           IN PCHAR Utf8Buffer,
  43                           OUT PWCHAR Utf8Value)
  44 {
  45     ULONG i;
  46
  47     /* Find out how many valid characters we have in the buffer */
  48     i = 0;
  49     while (Utf8Buffer[i++] && (i < 3));
  50
  51     /* If we have at least 3, shift everything by a byte */
  52     if (i >= 3)
  53     {
  54         /* The last input character goes at the end */
  55         Utf8Buffer[0] = Utf8Buffer[1];
  56         Utf8Buffer[1] = Utf8Buffer[2];
  57         Utf8Buffer[2] = Utf8Char;
  58     }
  59     else
  60     {
  61         /* We don't have more than 3 characters, place the input at the index */
  62         Utf8Buffer[i] = Utf8Char;
  63     }
  64
  65     /* Print to debugger */
  66     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SacTranslateUtf8ToUnicode - About to decode the UTF8 buffer.\n");
  67     SAC_DBG(SAC_DBG_ENTRY_EXIT, "                                  UTF8[0]: 0x%02lx UTF8[1]: 0x%02lx UTF8[2]: 0x%02lx\n",
  68             Utf8Buffer[0],
  69             Utf8Buffer[1],
  70             Utf8Buffer[2]);
  71
  72     /* Is this a simple ANSI character? */
  73     if (!(Utf8Char & 0x80))
  74     {
  75         /* Return it as Unicode, nothing left to do */
  76         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SACDRV: SacTranslateUTf8ToUnicode - Case1\n");
  77         *Utf8Value = (WCHAR)Utf8Char;
  78         Utf8Buffer[0] = Utf8Buffer[1];
  79         Utf8Buffer[1] = Utf8Buffer[2];
  80         Utf8Buffer[2] = UNICODE_NULL;
  81         return TRUE;
  82     }
  83
  84     /* Anything else is not yet supported */
  85     ASSERT(FALSE);
  86     return FALSE;
  87 }
  88
  89 BOOLEAN
  90 NTAPI
  91 SacTranslateUnicodeToUtf8(IN PWCHAR SourceBuffer,
  92                           IN ULONG SourceBufferLength,
  93                           OUT PCHAR DestinationBuffer,
  94                           IN ULONG DestinationBufferSize,
  95                           OUT PULONG UTF8Count,
  96                           OUT PULONG ProcessedCount)
  97 {
  98     *UTF8Count = 0;
  99     *ProcessedCount = 0;
 100
 101     while ((*SourceBuffer) &&
 102            (*UTF8Count < DestinationBufferSize) &&
 103            (*ProcessedCount < SourceBufferLength))
 104     {
 105         if (*SourceBuffer & 0xFF80)
 106         {
 107             if (*SourceBuffer & 0xF800)
 108             {
 109                 if ((*UTF8Count + 3) >= DestinationBufferSize) break;
 110                 DestinationBuffer[*UTF8Count] = ((*SourceBuffer >> 12) & 0xF) | 0xE0;
 111                 ++*UTF8Count;
 112                 DestinationBuffer[*UTF8Count] = ((*SourceBuffer >> 6) & 0x3F) | 0x80;
 113             }
 114             else
 115             {
 116                 if ((*UTF8Count + 2) >= DestinationBufferSize) break;
 117                 DestinationBuffer[*UTF8Count] = ((*SourceBuffer >> 6) & 31) | 0xC0;
 118             }
 119             ++*UTF8Count;
 120             DestinationBuffer[*UTF8Count] = (*SourceBuffer & 0x3F) | 0x80;
 121         }
 122         else
 123         {
 124             DestinationBuffer[*UTF8Count] = (*SourceBuffer & 0x7F);
 125         }
 126
 127         ++*UTF8Count;
 128         ++*ProcessedCount;
 129         ++SourceBuffer;
 130     }
 131
 132     ASSERT(*ProcessedCount <= SourceBufferLength);
 133     ASSERT(*UTF8Count <= DestinationBufferSize);
 134     return TRUE;
 135 }
 136
 137 PWCHAR
 138 NTAPI
 139 GetMessage(IN ULONG MessageIndex)
 140 {
 141     PSAC_MESSAGE_ENTRY MessageEntry;
 142     ULONG i;
 143     PWCHAR MessageData = NULL;
 144
 145     /* Loop all cached messages */
 146     for (i = 0; i < GlobalMessageTableCount; i++)
 147     {
 148         /* Check if this one matches the index */
 149         MessageEntry = &GlobalMessageTable[i];
 150         if (MessageEntry->Index == MessageIndex)
 151         {
 152             /* It does, return the buffer */
 153             MessageData = MessageEntry->Buffer;
 154             break;
 155         }
 156     }
 157
 158     /* We should always find it */
 159     if (!MessageData) ASSERT(FALSE);
 160     return MessageData;
 161 }
 162
 163 NTSTATUS
 164 NTAPI
 165 UTF8EncodeAndSend(IN PWCHAR String)
 166 {
 167     ULONG ProcessedCount, Utf8Count, i;
 168     NTSTATUS Status = STATUS_SUCCESS;
 169
 170     /* Call the translator routine */
 171     if (SacTranslateUnicodeToUtf8(String,
 172                                   wcslen(String),
 173                                   Utf8ConversionBuffer,
 174                                   Utf8ConversionBufferSize,
 175                                   &Utf8Count,
 176                                   &ProcessedCount))
 177     {
 178         /* Loop every character */
 179         for (i = 0; i < Utf8Count; i++)
 180         {
 181             /* Send it to the terminal */
 182             Status = HeadlessDispatch(HeadlessCmdPutData,
 183                                       &Utf8ConversionBuffer[i],
 184                                       sizeof(Utf8ConversionBuffer[i]),
 185                                       NULL,
 186                                       NULL);
 187             if (!NT_SUCCESS(Status)) break;
 188         }
 189     }
 190     else
 191     {
 192         /* Conversion failed */
 193         Status = STATUS_UNSUCCESSFUL;
 194     }
 195
 196     /* All done */
 197     return Status;
 198 }
 199
 200 VOID
 201 NTAPI
 202 SacFormatMessage(IN PWCHAR FormattedString,
 203                  IN PWCHAR MessageString,
 204                  IN ULONG MessageSize)
 205 {
 206     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SacFormatMessage: Entering.\n");
 207
 208     /* Check if any of the parameters are NULL or zero */
 209     if (!(MessageString) || !(FormattedString) || !(MessageSize))
 210     {
 211         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SacFormatMessage: Exiting with invalid parameters.\n");
 212         return;
 213     }
 214
 215     /* Keep going as long as there's still characters */
 216     while ((MessageString[0]) && (MessageSize))
 217     {
 218         /* Is it a non-formatting character? */
 219         if (MessageString[0] != L'%')
 220         {
 221             /* Just write it back into the buffer and keep going */
 222             *FormattedString++ = MessageString[0];
 223             MessageString++;
 224         }
 225         else
 226         {
 227             /* Go over the format characters we recognize */
 228             switch (MessageString[1])
 229             {
 230                 case L'0':
 231                     *FormattedString = UNICODE_NULL;
 232                     return;
 233
 234                 case L'%':
 235                     *FormattedString++ = L'%';
 236                     break;
 237
 238                 case L'\\':
 239                     *FormattedString++ = L'\r';
 240                     *FormattedString++ = L'\n';
 241                     break;
 242
 243                 case L'r':
 244                     *FormattedString++ = L'\r';
 245                     break;
 246
 247                 case L'b':
 248                     *FormattedString++ = L' ';
 249                     break;
 250
 251                 case L'.':
 252                     *FormattedString++ = L'.';
 253                     break;
 254
 255                 case L'!':
 256                     *FormattedString++ = L'!';
 257                     break;
 258
 259                 default:
 260                     /* Only move forward one character */
 261                     MessageString--;
 262                     break;
 263             }
 264
 265             /* Move forward two characters */
 266             MessageString += 2;
 267         }
 268
 269         /* Move to the next character*/
 270         MessageSize--;
 271     }
 272
 273     /* All done */
 274     *FormattedString = UNICODE_NULL;
 275     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SacFormatMessage: Exiting.\n");
 276 }
 277
 278 NTSTATUS
 279 NTAPI
 280 PreloadGlobalMessageTable(IN PVOID ImageBase)
 281 {
 282     NTSTATUS Status, Status2;
 283     ULONG MessageId, TotalLength, TextSize, i;
 284     PWCHAR StringBuffer;
 285     PMESSAGE_RESOURCE_ENTRY MessageEntry;
 286     PAGED_CODE();
 287     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC PreloadGlobalMessageTable: Entering.\n");
 288
 289     /* Nothing to do if we already have a table */
 290     Status = STATUS_SUCCESS;
 291     if (GlobalMessageTable) goto Exit;
 292
 293     /* Loop through up to 200 messages */
 294     TotalLength = 0;
 295     for (MessageId = 1; MessageId != SAC_MAX_MESSAGES; MessageId++)
 296     {
 297         /* Find this message ID in the string table*/
 298         Status2 = RtlFindMessage(ImageBase,
 299                                  11,
 300                                  LANG_NEUTRAL,
 301                                  MessageId,
 302                                  &MessageEntry);
 303         if (NT_SUCCESS(Status2))
 304         {
 305             /* Make sure it's Unicode */
 306             ASSERT(MessageEntry->Flags & MESSAGE_RESOURCE_UNICODE);
 307
 308             /* Remove the space taken up by the OS header, and add our own */
 309             TotalLength += MessageEntry->Length -
 310                            FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text) +
 311                            sizeof(SAC_MESSAGE_ENTRY);
 312
 313             /* One more in the table */
 314             GlobalMessageTableCount++;
 315         }
 316     }
 317
 318     /* We should've found at least one message... */
 319     if (!TotalLength)
 320     {
 321         /* Bail out otherwise */
 322         SAC_DBG(SAC_DBG_INIT, "SAC PreloadGlobalMessageTable: No Messages.\n");
 323         Status = STATUS_INVALID_PARAMETER;
 324         goto Exit;
 325     }
 326
 327     /* Allocate space for the buffers and headers */
 328     GlobalMessageTable = SacAllocatePool(TotalLength, GLOBAL_BLOCK_TAG);
 329     if (!GlobalMessageTable)
 330     {
 331         /* Bail out if we couldn't allocate it */
 332         Status = STATUS_NO_MEMORY;
 333         goto Exit;
 334     }
 335
 336     /* All the buffers are going to be at the end of the table */
 337     StringBuffer = (PWCHAR)(&GlobalMessageTable[GlobalMessageTableCount]);
 338
 339     /* Now loop over our entries again */
 340     for (i = 0, MessageId = 1; MessageId != SAC_MAX_MESSAGES; MessageId++)
 341     {
 342         /* Make sure the message is still there...! */
 343         Status2 = RtlFindMessage(ImageBase,
 344                                  11,
 345                                  LANG_NEUTRAL,
 346                                  MessageId,
 347                                  &MessageEntry);
 348         if (NT_SUCCESS(Status2))
 349         {
 350             /* Write the entry in the message table*/
 351             GlobalMessageTable[i].Index = MessageId;
 352             GlobalMessageTable[i].Buffer = StringBuffer;
 353
 354             /* The structure includes the size of the header, elide it */
 355             TextSize = MessageEntry->Length -
 356                        FIELD_OFFSET(MESSAGE_RESOURCE_ENTRY, Text);
 357
 358             /* Format the message into the entry. It should be same or smaller */
 359             SacFormatMessage(StringBuffer, (PWCHAR)MessageEntry->Text, TextSize);
 360             ASSERT((ULONG)(wcslen(StringBuffer)*sizeof(WCHAR)) <= TextSize);
 361
 362             /* Move to the next buffer space */
 363             StringBuffer += (TextSize / sizeof(WCHAR));
 364
 365             /* Move to the next entry, make sure the status is full success */
 366             i++;
 367             Status = STATUS_SUCCESS;
 368         }
 369     }
 370
 371 Exit:
 372     /* All done, return the status code */
 373     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC TearDownGlobalMessageTable: Exiting with status 0x%0x\n", Status);
 374     return Status;
 375 }
 376
 377 NTSTATUS
 378 NTAPI
 379 TearDownGlobalMessageTable(VOID)
 380 {
 381     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC TearDownGlobalMessageTable: Entering.\n");
 382
 383     /* Free the table if one existed */
 384     if (GlobalMessageTable) SacFreePool(GlobalMessageTable);
 385
 386     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC TearDownGlobalMessageTable: Exiting\n");
 387     return STATUS_SUCCESS;
 388 }
 389
 390 NTSTATUS
 391 NTAPI
 392 GetRegistryValueBuffer(IN PCWSTR KeyName,
 393                        IN PWCHAR ValueName,
 394                        IN PKEY_VALUE_PARTIAL_INFORMATION* Buffer)
 395 {
 396     NTSTATUS Status;
 397     OBJECT_ATTRIBUTES ObjectAttributes;
 398     UNICODE_STRING DestinationString;
 399     HANDLE Handle;
 400     ULONG ResultLength = 0;
 401     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: Entering.\n");
 402     CHECK_PARAMETER1(KeyName);
 403     CHECK_PARAMETER2(ValueName);
 404
 405     /* Open the specified key */
 406     RtlInitUnicodeString(&DestinationString, KeyName);
 407     InitializeObjectAttributes(&ObjectAttributes,
 408                                &DestinationString,
 409                                OBJ_CASE_INSENSITIVE,
 410                                NULL,
 411                                NULL);
 412     Status = ZwOpenKey(&Handle,
 413                        KEY_WRITE | SYNCHRONIZE | KEY_READ,
 414                        &ObjectAttributes);
 415     if (!NT_SUCCESS(Status))
 416     {
 417         /* Bail out on failure */
 418         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: failed ZwOpenKey: %X.\n", Status);
 419         return Status;
 420     }
 421
 422     /* Query the size of the key */
 423     RtlInitUnicodeString(&DestinationString, ValueName);
 424     Status = ZwQueryValueKey(Handle,
 425                              &DestinationString,
 426                              KeyValuePartialInformation,
 427                              NULL,
 428                              0,
 429                              &ResultLength);
 430     if (!ResultLength) return Status;
 431
 432     /* Allocate the buffer for the partial info structure and our integer data */
 433     ResultLength += sizeof(ULONG);
 434     *Buffer = SacAllocatePool(ResultLength, GLOBAL_BLOCK_TAG);
 435     if (!*Buffer)
 436     {
 437         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: failed allocation\n");
 438         return Status;
 439     }
 440
 441     /* Now read the data */
 442     Status = ZwQueryValueKey(Handle,
 443                              &DestinationString,
 444                              KeyValuePartialInformation,
 445                              *Buffer,
 446                              ResultLength,
 447                              &ResultLength);
 448     if (!NT_SUCCESS(Status))
 449     {
 450         /* Free the buffer if we couldn't read the data */
 451         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC GetRegistryValueBuffer: failed ZwQueryValueKey: %X.\n", Status);
 452         SacFreePool(*Buffer);
 453     }
 454
 455     /* Return the result */
 456     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: Exiting.\n");
 457     return Status;
 458 }
 459
 460 NTSTATUS
 461 NTAPI
 462 SetRegistryValue(IN PCWSTR KeyName,
 463                  IN PWCHAR ValueName,
 464                  IN ULONG Type,
 465                  IN PVOID Data,
 466                  IN ULONG DataSize)
 467 {
 468     NTSTATUS Status;
 469     OBJECT_ATTRIBUTES ObjectAttributes;
 470     UNICODE_STRING DestinationString;
 471     HANDLE Handle;
 472     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: Entering.\n");
 473     CHECK_PARAMETER1(KeyName);
 474     CHECK_PARAMETER2(ValueName);
 475     CHECK_PARAMETER4(Data);
 476
 477     /* Open the specified key */
 478     RtlInitUnicodeString(&DestinationString, KeyName);
 479     InitializeObjectAttributes(&ObjectAttributes,
 480                                &DestinationString,
 481                                OBJ_CASE_INSENSITIVE,
 482                                NULL,
 483                                NULL);
 484     Status = ZwOpenKey(&Handle,
 485                        KEY_WRITE | SYNCHRONIZE | KEY_READ,
 486                        &ObjectAttributes);
 487     if (!NT_SUCCESS(Status))
 488     {
 489         /* Bail out on failure */
 490         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: failed ZwOpenKey: %X.\n", Status);
 491         return Status;
 492     }
 493
 494     /* Set the specified value */
 495     RtlInitUnicodeString(&DestinationString, ValueName);
 496     Status = ZwSetValueKey(Handle, &DestinationString, 0, Type, Data, DataSize);
 497     if (!NT_SUCCESS(Status))
 498     {
 499         /* Print error on failure */
 500         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: failed ZwSetValueKey: %X.\n", Status);
 501     }
 502
 503     /* Close the handle and exit */
 504     NtClose(Handle);
 505     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC SetRegistryValue: Exiting.\n");
 506     return Status;
 507 }
 508
 509 NTSTATUS
 510 NTAPI
 511 CopyRegistryValueData(IN PVOID* Buffer,
 512                       IN PKEY_VALUE_PARTIAL_INFORMATION PartialInfo)
 513 {
 514     NTSTATUS Status = STATUS_SUCCESS;
 515     CHECK_PARAMETER1(Buffer);
 516     CHECK_PARAMETER2(PartialInfo);
 517
 518     /* Allocate space for registry data */
 519     *Buffer = SacAllocatePool(PartialInfo->DataLength, GLOBAL_BLOCK_TAG);
 520     if (*Buffer)
 521     {
 522         /* Copy the data into the buffer */
 523         RtlCopyMemory(*Buffer, PartialInfo->Data, PartialInfo->DataLength);
 524     }
 525     else
 526     {
 527         /* Set the correct error code */
 528         SAC_DBG(SAC_DBG_UTIL, "SAC CopyRegistryValueBuffer: Failed ALLOCATE.\n");
 529         Status = STATUS_NO_MEMORY;
 530     }
 531
 532     /* Return the result */
 533     return Status;
 534 }
 535
 536 NTSTATUS
 537 NTAPI
 538 TranslateMachineInformationXML(IN PWCHAR *Buffer,
 539                                IN PWCHAR ExtraData)
 540 {
 541     NTSTATUS Status;
 542     SIZE_T Size;
 543     PWCHAR p;
 544     CHECK_PARAMETER1(Buffer);
 545
 546     /* Start by believing the world is beautiful */
 547     Status = STATUS_SUCCESS;
 548
 549     /* First, the header */
 550     Size = wcslen(L"<machine-info>\r\n");
 551
 552     /* Do we have a machine name? */
 553     if (MachineInformation->MachineName)
 554     {
 555         /* Go and add it in */
 556         Size += wcslen(MachineInformation->MachineName);
 557         Size += wcslen(L"<name>%s</name>\r\n");
 558     }
 559
 560     /* Do we have a GUID? */
 561     if (MachineInformation->MachineGuid)
 562     {
 563         /* Go and add it in */
 564         Size += wcslen(MachineInformation->MachineGuid);
 565         Size += wcslen(L"<guid>%s</guid>\r\n");
 566     }
 567
 568     /* Do we know the processor? */
 569     if (MachineInformation->ProcessorArchitecture)
 570     {
 571         /* Go and add it in */
 572         Size += wcslen(MachineInformation->ProcessorArchitecture);
 573         Size += wcslen(L"<processor-architecture>%s</processor-architecture>\r\n");
 574     }
 575
 576     /* Do we have the version? */
 577     if (MachineInformation->MajorVersion)
 578     {
 579         /* Go and add it in */
 580         Size += wcslen(MachineInformation->MajorVersion);
 581         Size += wcslen(L"<os-version>%s</os-version>\r\n");
 582     }
 583
 584     /* Do we have the build? */
 585     if (MachineInformation->BuildNumber)
 586     {
 587         /* Go and add it in */
 588         Size += wcslen(MachineInformation->BuildNumber);
 589         Size += wcslen(L"<os-build-number>%s</os-build-number>\r\n");
 590     }
 591
 592     /* Do we have the product type? */
 593     if (MachineInformation->ProductType)
 594     {
 595         /* Go and add it in */
 596         Size += wcslen(MachineInformation->ProductType);
 597         Size += wcslen(L"<os-product>%s</os-product>\r\n");
 598     }
 599
 600     /* Do we have a service pack? */
 601     if (MachineInformation->ServicePack)
 602     {
 603         /* Go and add it in */
 604         Size += wcslen(MachineInformation->ServicePack);
 605         Size += wcslen(L"<os-service-pack>%s</os-service-pack>\r\n");
 606     }
 607
 608     /* Anything else we need to know? Add it in too */
 609     if (ExtraData) Size += wcslen(ExtraData);
 610
 611     /* Finally, add the footer */
 612     Size += wcslen(L"</machine-info>\r\n");
 613
 614     /* Convert to bytes and add a NULL */
 615     Size += sizeof(ANSI_NULL);
 616     Size *= sizeof(WCHAR);
 617
 618     /* Allocate space for the buffer */
 619     p = SacAllocatePool(Size, GLOBAL_BLOCK_TAG);
 620     *Buffer = p;
 621     if (!p) return STATUS_NO_MEMORY;
 622
 623     wcscpy(p, L"<machine-info>\r\n");
 624     p += wcslen(L"<machine-info>\r\n");
 625
 626     if (MachineInformation->MachineName)
 627     {
 628         p += swprintf(p,
 629                       L"<name>%s</name>\r\n",
 630                       MachineInformation->MachineName);
 631     }
 632
 633     if (MachineInformation->MachineGuid)
 634     {
 635         p += swprintf(p,
 636                       L"<guid>%s</guid>\r\n",
 637                       MachineInformation->MachineGuid);
 638     }
 639
 640     if (MachineInformation->ProcessorArchitecture)
 641     {
 642         p += swprintf(p,
 643                       L"<processor-architecture>%s</processor-architecture>\r\n",
 644                       MachineInformation->ProcessorArchitecture);
 645     }
 646
 647     if (MachineInformation->MajorVersion)
 648     {
 649         p += swprintf(p,
 650                       L"<os-version>%s</os-version>\r\n",
 651                       MachineInformation->MajorVersion);
 652     }
 653
 654     if (MachineInformation->BuildNumber)
 655     {
 656         p += swprintf(p,
 657                       L"<os-build-number>%s</os-build-number>\r\n",
 658                       MachineInformation->BuildNumber);
 659     }
 660
 661     if (MachineInformation->ProductType)
 662     {
 663         p += swprintf(p,
 664                       L"<os-product>%s</os-product>\r\n",
 665                       MachineInformation->ProductType);
 666     }
 667
 668     if (MachineInformation->ServicePack)
 669     {
 670         p += swprintf(p,
 671                       L"<os-service-pack>%s</os-service-pack>\r\n",
 672                       MachineInformation->ServicePack);
 673     }
 674
 675     if (ExtraData)
 676     {
 677         wcscpy(p, ExtraData);
 678         p += wcslen(ExtraData);
 679     }
 680
 681     wcscpy(p, L"</machine-info>\r\n");
 682     SAC_DBG(SAC_DBG_ENTRY_EXIT, "MachineInformation: %S\n", *Buffer);
 683     ASSERT((((ULONG)wcslen(*Buffer) + 1) * sizeof(WCHAR)) <= Size);
 684     return Status;
 685 }
 686
 687 VOID
 688 NTAPI
 689 InitializeMachineInformation(VOID)
 690 {
 691     NTSTATUS Status;
 692     PWCHAR GuidString, MajorVersion, ServicePack, BuildNumber, MessageBuffer;
 693     PWCHAR ProductType;
 694     ULONG SuiteTypeMessage;
 695     BOOLEAN SetupInProgress = FALSE;
 696     GUID SystemGuid;
 697     SIZE_T RealSize, Size, OutputSize;
 698     PKEY_VALUE_PARTIAL_INFORMATION PartialInfo;
 699     RTL_OSVERSIONINFOEXW VersionInformation;
 700     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC Initialize Machine Information : Entering.\n");
 701
 702     /* Don't do anything if we already queried this */
 703     if (MachineInformation)
 704     {
 705         SAC_DBG(SAC_DBG_MACHINE, "SAC Initialize Machine Information:: MachineInformationBuffer already initialized.\n");
 706         return;
 707     }
 708
 709     /* Allocate the machine information */
 710     MachineInformation = SacAllocatePool(sizeof(*MachineInformation),
 711                                          GLOBAL_BLOCK_TAG);
 712     if (!MachineInformation)
 713     {
 714         goto Fail;
 715     }
 716
 717     /* Zero it out for now */
 718     RtlZeroMemory(MachineInformation, sizeof(*MachineInformation));
 719
 720     /* Query OS version */
 721     RtlZeroMemory(&VersionInformation, sizeof(VersionInformation));
 722     VersionInformation.dwOSVersionInfoSize = sizeof(VersionInformation);
 723     Status = RtlGetVersion((PRTL_OSVERSIONINFOW)&VersionInformation);
 724     if (!NT_SUCCESS(Status))
 725     {
 726         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (2).\n");
 727         goto Fail;
 728     }
 729
 730     /* Check if setup is in progress */
 731     Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\Setup",
 732                                     L"SystemSetupInProgress",
 733                                     &PartialInfo);
 734     if (NT_SUCCESS(Status))
 735     {
 736         /* The key is there, is the value set? */
 737         if (*(PULONG)PartialInfo->Data) SetupInProgress = TRUE;
 738         SacFreePool(PartialInfo);
 739         if (SetupInProgress)
 740         {
 741             /* Yes, so we'll use a special hostname to identify this */
 742             MessageBuffer = GetMessage(SAC_UNINITIALIZED_MSG);
 743             Size = wcslen(MessageBuffer);
 744             ASSERT(Size > 0);
 745             RealSize = Size * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 746
 747             /* Make room for it and copy it in there */
 748             MachineInformation->MachineName = SacAllocatePool(RealSize,
 749                                                               GLOBAL_BLOCK_TAG);
 750             if (MachineInformation->MachineName)
 751             {
 752                 wcscpy(MachineInformation->MachineName, MessageBuffer);
 753             }
 754         }
 755     }
 756
 757     /* If we are not in setup mode, or if we failed to check... */
 758     if (!SetupInProgress)
 759     {
 760         /* Query the computer name */
 761         Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\"
 762                                         L"CurrentControlSet\\Control\\"
 763                                         L"ComputerName\\ComputerName",
 764                                         L"ComputerName",
 765                                         &PartialInfo);
 766         if (!NT_SUCCESS(Status))
 767         {
 768             /* It's not critical, but we won't have it */
 769             SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Failed to get machine name.\n");
 770         }
 771         else
 772         {
 773             /* We have the name, copy it from the registry */
 774             Status = CopyRegistryValueData((PVOID*)&MachineInformation->
 775                                            MachineName,
 776                                            PartialInfo);
 777             SacFreePool(PartialInfo);
 778             if (!NT_SUCCESS(Status))
 779             {
 780                 SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (20).\n");
 781                 goto Fail;
 782             }
 783         }
 784     }
 785
 786     /* Next step, try to get the machine GUID */
 787     RtlZeroMemory(&SystemGuid, sizeof(SystemGuid));
 788     OutputSize = sizeof(SystemGuid);
 789     Status = HeadlessDispatch(HeadlessCmdQueryGUID,
 790                               NULL,
 791                               0,
 792                               &SystemGuid,
 793                               &OutputSize);
 794     if (!NT_SUCCESS(Status))
 795     {
 796         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Failed to get Machine GUID.\n");
 797     }
 798     else
 799     {
 800         /* We have it -- make room for it */
 801         GuidString = SacAllocatePool(0x50, GLOBAL_BLOCK_TAG);
 802         if (!GuidString)
 803         {
 804             SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (31).\n");
 805             goto Fail;
 806         }
 807
 808         /* Build the string with the GUID in it, and save the ppointer to it */
 809         swprintf(GuidString,
 810                  L"%08lx-%04x-%04x-%02x%02x-%02x%02x%02x%02x%02x%02x",
 811                  SystemGuid.Data1,
 812                  SystemGuid.Data2,
 813                  SystemGuid.Data3,
 814                  SystemGuid.Data4[0],
 815                  SystemGuid.Data4[1],
 816                  SystemGuid.Data4[2],
 817                  SystemGuid.Data4[3],
 818                  SystemGuid.Data4[4],
 819                  SystemGuid.Data4[5],
 820                  SystemGuid.Data4[6],
 821                  SystemGuid.Data4[7]);
 822         MachineInformation->MachineGuid = GuidString;
 823     }
 824
 825     /* Next, query the processor architecture */
 826     Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\"
 827                                     L"CurrentControlSet\\Control\\"
 828                                     L"Session Manager\\Environment",
 829                                     L"PROCESSOR_ARCHITECTURE",
 830                                     &PartialInfo);
 831     if (!NT_SUCCESS(Status))
 832     {
 833         /* It's not critical, but we won't have it */
 834         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (30).\n");
 835     }
 836     else
 837     {
 838         /* We have it! Copy the value from the registry */
 839         Status = CopyRegistryValueData((PVOID*)&MachineInformation->
 840                                        ProcessorArchitecture,
 841                                        PartialInfo);
 842         SacFreePool(PartialInfo);
 843         if (!NT_SUCCESS(Status))
 844         {
 845             SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (30).\n");
 846             goto Fail;
 847         }
 848     }
 849
 850     /* Now allocate a buffer for the OS version number */
 851     MajorVersion = SacAllocatePool(0x18, GLOBAL_BLOCK_TAG);
 852     if (!MajorVersion)
 853     {
 854         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (50).\n");
 855         goto Fail;
 856     }
 857
 858     /* Build the buffer and set a pointer to it */
 859     swprintf(MajorVersion,
 860              L"%d.%d",
 861              VersionInformation.dwMajorVersion,
 862              VersionInformation.dwMinorVersion);
 863     MachineInformation->MajorVersion = MajorVersion;
 864
 865     /* Now allocate a buffer for the OS build number */
 866     BuildNumber = SacAllocatePool(0xC, GLOBAL_BLOCK_TAG);
 867     if (!BuildNumber)
 868     {
 869         SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC InitializeMachineInformation: Exiting (60).\n");
 870         goto Fail;
 871     }
 872
 873     /* Build the buffer and set a pointer to it */
 874     swprintf(BuildNumber, L"%d", VersionInformation.dwBuildNumber);
 875     MachineInformation->BuildNumber = BuildNumber;
 876
 877     /* Now check what kind of SKU this is */
 878     if (ExVerifySuite(DataCenter))
 879     {
 880         SuiteTypeMessage = SAC_DATACENTER_SUITE_MSG;
 881     }
 882     else if (ExVerifySuite(EmbeddedNT))
 883     {
 884         SuiteTypeMessage = SAC_EMBEDDED_SUITE_MSG;
 885     }
 886     else if (ExVerifySuite(Enterprise))
 887     {
 888         SuiteTypeMessage = SAC_ENTERPRISE_SUITE_MSG;
 889     }
 890     else
 891     {
 892         /* Unknown or perhaps a client SKU */
 893         SuiteTypeMessage = SAC_NO_SUITE_MSG;
 894     }
 895
 896     /* Get the string that corresponds to the SKU type */
 897     MessageBuffer = GetMessage(SuiteTypeMessage);
 898     if (!MessageBuffer)
 899     {
 900         /* We won't have it, but this isn't critical */
 901         SAC_DBG(SAC_DBG_INIT, "SAC InitializeMachineInformation: Failed to get product type.\n");
 902     }
 903     else
 904     {
 905         /* Calculate the size we need to hold the string */
 906         Size = wcslen(MessageBuffer);
 907         ASSERT(Size > 0);
 908         RealSize = Size * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 909
 910         /* Allocate a buffer for it */
 911         ProductType = SacAllocatePool(RealSize, GLOBAL_BLOCK_TAG);
 912         if (!ProductType)
 913         {
 914             SAC_DBG(SAC_DBG_INIT, "SAC InitializeMachineInformation: Failed product type memory allocation.\n");
 915             goto Fail;
 916         }
 917
 918         /* Copy the string and set the pointer */
 919         RtlCopyMemory(ProductType, MessageBuffer, RealSize);
 920         MachineInformation->ProductType = ProductType;
 921     }
 922
 923     /* Check if this is a SP version or RTM version */
 924     if (VersionInformation.wServicePackMajor)
 925     {
 926         /* This is a service pack, allocate a buffer for the version */
 927         ServicePack = SacAllocatePool(0x18, GLOBAL_BLOCK_TAG);
 928         if (ServicePack)
 929         {
 930             /* Build the buffer and set a pointer to it */
 931             swprintf(ServicePack,
 932                      L"%d.%d",
 933                      VersionInformation.wServicePackMajor,
 934                      VersionInformation.wServicePackMinor);
 935             MachineInformation->ServicePack = ServicePack;
 936
 937             /* We've collected all the machine info and are done! */
 938             return;
 939         }
 940
 941         /* This is the failure path */
 942         SAC_DBG(SAC_DBG_INIT, "SAC InitializeMachineInformation: Failed service pack memory allocation.\n");
 943     }
 944     else
 945     {
 946         /* Get a generic string that indicates there's no service pack */
 947         MessageBuffer = GetMessage(SAC_NO_DATA_MSG);
 948         Size = wcslen(MessageBuffer);
 949         ASSERT(Size > 0);
 950         RealSize = Size * sizeof(WCHAR) + sizeof(UNICODE_NULL);
 951
 952         /* Allocate memory for the "no service pack" string */
 953         ServicePack = SacAllocatePool(RealSize, GLOBAL_BLOCK_TAG);
 954         if (ServicePack)
 955         {
 956             /* Copy the buffer and set a pointer to it */
 957             RtlCopyMemory(ServicePack, MessageBuffer, RealSize);
 958             MachineInformation->ServicePack = ServicePack;
 959
 960             /* We've collected all the machine info and are done! */
 961             return;
 962         }
 963
 964         SAC_DBG(SAC_DBG_INIT, "SAC InitializeMachineInformation: Failed service pack memory allocation.\n");
 965     }
 966
 967 Fail:
 968     /* In the failure path, always cleanup the machine information buffer */
 969     if (MachineInformation)
 970     {
 971         SacFreePool(MachineInformation);
 972     }
 973     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC Initialize Machine Information : Exiting with error.\n");
 974 }
 975
 976 NTSTATUS
 977 NTAPI
 978 GetCommandConsoleLaunchingPermission(OUT PBOOLEAN Permission)
 979 {
 980     NTSTATUS Status;
 981     PKEY_VALUE_PARTIAL_INFORMATION Dummy;
 982
 983     /* Assume success and read the key */
 984     *Permission = TRUE;
 985     Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\sacdrv",
 986                                     L"DisableCmdSessions",
 987                                     &Dummy);
 988     if (Status == STATUS_OBJECT_NAME_NOT_FOUND)
 989     {
 990         /* The default is success */
 991         Status = STATUS_SUCCESS;
 992     }
 993     else
 994     {
 995         /* Only if the key is present and set, do we disable permission */
 996         if (NT_SUCCESS(Status)) *Permission = FALSE;
 997     }
 998
 999     /* Return status */
1000     return Status;
1001 }
1002
1003 NTSTATUS
1004 NTAPI
1005 ImposeSacCmdServiceStartTypePolicy(VOID)
1006 {
1007     NTSTATUS Status;
1008     PKEY_VALUE_PARTIAL_INFORMATION Buffer = NULL;
1009     PULONG Data;
1010
1011     /* Read the service start type*/
1012     Status = GetRegistryValueBuffer(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\sacsvr",
1013                                     L"Start",
1014                                     &Buffer);
1015     if (!NT_SUCCESS(Status)) return Status;
1016
1017     /* If there's no start type, fail, as this is unusual */
1018     if (!Buffer) return STATUS_UNSUCCESSFUL;
1019
1020     /* Read the value */
1021     Status = CopyRegistryValueData((PVOID*)&Data, Buffer);
1022     SacFreePool(Buffer);
1023     if (!NT_SUCCESS(Status)) return Status;
1024
1025     /* Check what the current start type is */
1026     switch (*Data)
1027     {
1028         /* It's boot, system, or disabled */
1029         case 1:
1030         case 2:
1031         case 4:
1032             /* Leave it as is */
1033             return Status;
1034
1035         case 3:
1036
1037             /* It's set to automatic, set it to system instead */
1038             *Data = 2;
1039             Status = SetRegistryValue(L"\\Registry\\Machine\\System\\CurrentControlSet\\Services\\sacsvr",
1040                                       L"Start",
1041                                       REG_DWORD,
1042                                       Data,
1043                                       sizeof(ULONG));
1044             if (!NT_SUCCESS(Status))
1045             {
1046                 SAC_DBG(SAC_DBG_INIT, "SAC ImposeSacCmdServiceStartTypePolicy: Failed SetRegistryValue: %X\n", Status);
1047             }
1048             break;
1049
1050         default:
1051             ASSERT(FALSE);
1052     }
1053
1054     return Status;
1055 }
1056
1057 VOID
1058 NTAPI
1059 InitializeCmdEventInfo(VOID)
1060 {
1061     /* Check if we were already initialized */
1062     if (HaveUserModeServiceCmdEventInfo)
1063     {
1064         /* Full state expected */
1065         ASSERT(RequestSacCmdEventObjectBody);
1066         ASSERT(RequestSacCmdSuccessEventObjectBody);
1067         ASSERT(RequestSacCmdFailureEventObjectBody);
1068
1069         /* Dereference each wait object in turn */
1070         if (RequestSacCmdEventObjectBody)
1071         {
1072             ObDereferenceObject(RequestSacCmdEventObjectBody);
1073         }
1074
1075         if (RequestSacCmdSuccessEventObjectBody)
1076         {
1077             ObDereferenceObject(RequestSacCmdSuccessEventObjectBody);
1078         }
1079
1080         if (RequestSacCmdFailureEventObjectBody)
1081         {
1082             ObDereferenceObject(RequestSacCmdFailureEventObjectBody);
1083         }
1084     }
1085
1086     /* Claer everything */
1087     RequestSacCmdEventObjectBody = NULL;
1088     RequestSacCmdEventWaitObjectBody = NULL;
1089     RequestSacCmdSuccessEventObjectBody = NULL;
1090     RequestSacCmdSuccessEventWaitObjectBody = NULL;
1091     RequestSacCmdFailureEventObjectBody = NULL;
1092     RequestSacCmdFailureEventWaitObjectBody = NULL;
1093     ServiceProcessFileObject = NULL;
1094
1095     /* Reset state */
1096     HaveUserModeServiceCmdEventInfo = FALSE;
1097 }
1098
1099 NTSTATUS
1100 NTAPI
1101 RegisterBlueScreenMachineInformation(VOID)
1102 {
1103     PWCHAR XmlBuffer;
1104     PHEADLESS_CMD_SET_BLUE_SCREEN_DATA BsBuffer;
1105     SIZE_T Length, HeaderLength, TotalLength;
1106     NTSTATUS Status;
1107     ULONG i;
1108
1109     /* Create the XML buffer and make sure it's OK */
1110     Status = TranslateMachineInformationXML(&XmlBuffer, NULL);
1111     CHECK_PARAMETER_WITH_STATUS(NT_SUCCESS(Status), Status);
1112     CHECK_PARAMETER_WITH_STATUS(XmlBuffer, STATUS_UNSUCCESSFUL);
1113
1114     /* Compute the sizes and allocate a buffer for it */
1115     Length = wcslen(XmlBuffer);
1116     HeaderLength = strlen("MACHINEINFO");
1117     TotalLength = HeaderLength +
1118                   Length +
1119                   sizeof(*BsBuffer) +
1120                   2 * sizeof(ANSI_NULL);
1121     BsBuffer = SacAllocatePool(TotalLength, GLOBAL_BLOCK_TAG);
1122     CHECK_PARAMETER_WITH_STATUS(BsBuffer, STATUS_NO_MEMORY);
1123
1124     /* Copy the XML property name */
1125     strcpy((PCHAR)BsBuffer->Data, "MACHINEINFO");
1126     BsBuffer->ValueIndex = HeaderLength + sizeof(ANSI_NULL);
1127
1128     /* Copy the data and NULL-terminate it */
1129     for (i = 0; i < Length; i++)
1130     {
1131         BsBuffer->Data[BsBuffer->ValueIndex + i] = XmlBuffer[i];
1132     }
1133     BsBuffer->Data[BsBuffer->ValueIndex + i] = ANSI_NULL;
1134
1135     /* Let the OS save the buffer for later */
1136     Status = HeadlessDispatch(HeadlessCmdSetBlueScreenData,
1137                               BsBuffer,
1138                               TotalLength,
1139                               NULL,
1140                               NULL);
1141
1142     /* Failure or not, we don't need this anymore */
1143     SacFreePool(BsBuffer);
1144     SacFreePool(XmlBuffer);
1145
1146     /* Return the result */
1147     SAC_DBG(SAC_DBG_ENTRY_EXIT, "SAC Initialize Machine Information: Exiting.\n");
1148     return Status;
1149 }
1150
1151 VOID
1152 NTAPI
1153 FreeMachineInformation(VOID)
1154 {
1155     ASSERT(MachineInformation);
1156
1157     /* Free every cached string of machine information */
1158     if (MachineInformation->MachineName) SacFreePool(MachineInformation);
1159     if (MachineInformation->MachineGuid) SacFreePool(MachineInformation->MachineGuid);
1160     if (MachineInformation->ProcessorArchitecture) SacFreePool(MachineInformation->ProcessorArchitecture);
1161     if (MachineInformation->MajorVersion) SacFreePool(MachineInformation->MajorVersion);
1162     if (MachineInformation->BuildNumber) SacFreePool(MachineInformation->BuildNumber);
1163     if (MachineInformation->ProductType) SacFreePool(MachineInformation->ProductType);
1164     if (MachineInformation->ServicePack) SacFreePool(MachineInformation->ServicePack);
1165 }
1166
1167 BOOLEAN
1168 NTAPI
1169 VerifyEventWaitable(IN HANDLE Handle,
1170                     OUT PVOID *WaitObject,
1171                     OUT PVOID *ActualWaitObject)
1172 {
1173     PVOID Object;
1174     NTSTATUS Status;
1175     POBJECT_TYPE ObjectType;
1176
1177     /* Reference the object */
1178     Status = ObReferenceObjectByHandle(Handle,
1179                                        EVENT_ALL_ACCESS,
1180                                        NULL,
1181                                        KernelMode,
1182                                        &Object,
1183                                        NULL);
1184     *WaitObject = Object;
1185     if (!NT_SUCCESS(Status))
1186     {
1187         SAC_DBG(SAC_DBG_INIT, "SAC VerifyEventWaitable: Unable to reference event object (%lx)\n", Status);
1188         return FALSE;
1189     }
1190
1191     /* Check if the object itself is NOT being used */
1192     ObjectType = OBJECT_TO_OBJECT_HEADER(Object)->Type;
1193     if (ObjectType->TypeInfo.UseDefaultObject == FALSE)
1194     {
1195         /* Get the actual object that's being used for the wait */
1196         *ActualWaitObject = (PVOID)((ULONG_PTR)Object +
1197                                     (ULONG_PTR)ObjectType->DefaultObject);
1198         return TRUE;
1199     }
1200
1201     /* Drop the reference we took */
1202     SAC_DBG(SAC_DBG_INIT, "SAC VerifyEventWaitable: event object not waitable!\n");
1203     ObDereferenceObject(*WaitObject);
1204     return FALSE;
1205 }
1206
1207 NTSTATUS
1208 NTAPI
1209 SerialBufferGetChar(OUT PCHAR Char)
1210 {
1211     /* Check if nothing's been produced yet */
1212     if (SerialPortConsumerIndex == SerialPortProducerIndex)
1213     {
1214         return STATUS_NO_DATA_DETECTED;
1215     }
1216
1217     /* Consume the produced character and clear it*/
1218     *Char = SerialPortBuffer[SerialPortConsumerIndex];
1219     SerialPortBuffer[SerialPortConsumerIndex] = ANSI_NULL;
1220
1221     /* Advance the index and return success */
1222     _InterlockedExchange(&SerialPortConsumerIndex,
1223                          (SerialPortConsumerIndex + 1) &
1224                          (SAC_SERIAL_PORT_BUFFER_SIZE - 1));
1225     return STATUS_SUCCESS;
1226 }
1227
1228 ULONG
1229 NTAPI
1230 GetMessageLineCount(IN ULONG MessageIndex)
1231 {
1232     ULONG LineCount = 0;
1233     PWCHAR Buffer;
1234
1235     /* Get the message buffer */
1236     Buffer = GetMessage(MessageIndex);
1237     if (Buffer)
1238     {
1239         /* Scan it looking for new lines, and increment the count each time */
1240         while (*Buffer) if (*Buffer++ == L'\n') ++LineCount;
1241     }
1242
1243     /* Return the line count */
1244     return LineCount;
1245 }
1246
1247 ULONG
1248 ConvertAnsiToUnicode(
1249     IN PWCHAR pwch,
1250     IN PCHAR pch,
1251     IN ULONG length
1252     )
1253 {
1254     return STATUS_NOT_IMPLEMENTED;
1255 }
1256
1257 BOOLEAN
1258 IsCmdEventRegistrationProcess(
1259     IN PFILE_OBJECT FileObject
1260     )
1261 {
1262     return FALSE;
1263 }
1264
1265 NTSTATUS
1266 InvokeUserModeService(
1267     VOID
1268     )
1269 {
1270     return STATUS_NOT_IMPLEMENTED;
1271 }
1272
1273 NTSTATUS
1274 TranslateMachineInformationText(
1275     IN PWCHAR Buffer)
1276 {
1277     return STATUS_NOT_IMPLEMENTED;
1278 }
1279
1280 NTSTATUS
1281 CopyAndInsertStringAtInterval(
1282     IN PWCHAR SourceStr,
1283     IN ULONG Interval,
1284     IN PWCHAR InsertStr,
1285     OUT PWCHAR pDestStr
1286     )
1287 {
1288     return STATUS_NOT_IMPLEMENTED;
1289 }
1290
1291 NTSTATUS
1292 RegisterSacCmdEvent(
1293     IN PVOID Object,
1294     IN PKEVENT SetupCmdEvent[]
1295     )
1296 {
1297     return STATUS_NOT_IMPLEMENTED;
1298 }
1299
1300 NTSTATUS
1301 UnregisterSacCmdEvent(
1302     IN PFILE_OBJECT FileObject
1303     )
1304 {
1305     return STATUS_NOT_IMPLEMENTED;
1306 }