Main Page | Class Hierarchy | Class List | File List | Class Members | File Members

regutil.h File Reference

#include <nt.h>
#include <ntrtl.h>
#include <nturtl.h>
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <errno.h>
#include <ctype.h>
#include <string.h>
#include <fcntl.h>
#include <malloc.h>
#include <sys\types.h>
#include <sys\stat.h>

Go to the source code of this file.

Classes

struct  _REG_UNICODE_FILE

Defines

#define VALUE_BUFFER_SIZE   (4096 * 100)

Typedefs

typedef _REG_UNICODE_FILE REG_UNICODE_FILE
typedef _REG_UNICODE_FILE * PREG_UNICODE_FILE

Functions

void RegInitialize (void)
NTSTATUS RegReadBinaryFile (IN PUNICODE_STRING FileName, OUT PVOID *ValueBuffer, OUT PULONG ValueLength)
NTSTATUS RegLoadAsciiFileAsUnicode (IN PUNICODE_STRING FileName, OUT PREG_UNICODE_FILE UnicodeFile)
BOOLEAN RegGetNextLine (IN OUT PREG_UNICODE_FILE UnicodeFile, OUT PULONG IndentAmount, OUT PWSTR *FirstEqual)
BOOLEAN RegGetKeyValue (IN PUNICODE_STRING KeyValue, IN OUT PREG_UNICODE_FILE UnicodeFile, OUT PULONG ValueType, OUT PVOID *ValueBuffer, OUT PULONG ValueLength)
BOOLEAN RegGetMultiString (IN OUT PUNICODE_STRING ValueString, OUT PUNICODE_STRING MultiString)
void RegDumpKeyValue (FILE *fh, PKEY_VALUE_FULL_INFORMATION KeyValueInformation, ULONG IndentLevel)
BOOLEAN RegInitializeSecurity (VOID)
BOOLEAN RegCreateSecurity (IN PUNICODE_STRING Description, OUT PSECURITY_DESCRIPTOR SecurityDescriptor)
VOID RegDestroySecurity (IN PSECURITY_DESCRIPTOR SecurityDescriptor)

Variables

BOOLEAN DebugOutput
BOOLEAN SummaryOutput

Define Documentation

#define VALUE_BUFFER_SIZE   (4096 * 100)
 

Definition at line 39 of file regutil.h.

Referenced by main().

Typedef Documentation

typedef struct _REG_UNICODE_FILE * PREG_UNICODE_FILE
 

Referenced by RegLoadAsciiFileAsUnicode().

typedef struct _REG_UNICODE_FILE REG_UNICODE_FILE
 

Referenced by RegReadMultiSzFile(), and RiInitializeRegistryFromAsciiFile().

Function Documentation

BOOLEAN RegCreateSecurity (  IN PUNICODE_STRING  Description,
OUT PSECURITY_DESCRIPTOR  SecurityDescriptor
) 
 

VOID RegDestroySecurity (  IN PSECURITY_DESCRIPTOR  SecurityDescriptor  ) 
 

void RegDumpKeyValue (  FILE *  fh,
PKEY_VALUE_FULL_INFORMATION  KeyValueInformation,
ULONG  IndentLevel
) 
 

Definition at line 555 of file config/utils/regutil.c.

References L, NULL, Size, SummaryOutput, USHORT, and ValueName.

Referenced by DumpValues(). 

00560 {
00561     PULONG p;
00562     PWSTR pw, pw1;
00563     ULONG i, j, k, m, cbPrefix;
00564     UNICODE_STRING ValueName;
00565     PUCHAR pbyte;
00566 
00567     cbPrefix = fprintf( fh, "%.*s",
00568                         IndentLevel,
00569                         "                                                                                  "
00570                       );
00571     ValueName.Buffer = (PWSTR)&(KeyValueInformation->Name[0]);
00572     ValueName.Length = (USHORT)KeyValueInformation->NameLength;
00573     ValueName.MaximumLength = (USHORT)KeyValueInformation->NameLength;
00574 
00575     if (ValueName.Length) {
00576         cbPrefix += fprintf( fh, "%wZ ", &ValueName );
00577         }
00578     cbPrefix += fprintf( fh, "= " );
00579 
00580     if (KeyValueInformation->DataLength == 0) {
00581         fprintf( fh, " [no data] \n");
00582         return;
00583     }
00584 
00585     switch( KeyValueInformation->Type ) {
00586     case REG_SZ:
00587     case REG_EXPAND_SZ:
00588 
00589         if (KeyValueInformation->Type == REG_EXPAND_SZ) {
00590             cbPrefix += fprintf( fh, "REG_EXPAND_SZ " );
00591         }
00592         pw = (PWSTR)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
00593         *(PWSTR)((PCHAR)pw + KeyValueInformation->DataLength) = UNICODE_NULL;
00594         i = 0;
00595         while (*pw) {
00596             if ((cbPrefix + wcslen(pw)) > 80) {
00597                 pw1 = pw;
00598                 while (*pw1 && *pw1 > L' ') {
00599                     pw1++;
00600                 }
00601 
00602                 if (*pw1) {
00603                     *pw1++ = UNICODE_NULL;
00604                     while (*pw1 && *pw1 <= L' ') {
00605                         pw1++;
00606                     }
00607                 }
00608             } else {
00609                 pw1 = NULL;
00610             }
00611             if (i > 0) {
00612                 fprintf( fh, " \\\n%.*s",
00613                          cbPrefix,
00614                          "                                                                                  "
00615                        );
00616             }
00617 
00618             fprintf( fh, "%ws", pw );
00619             if (!pw1) {
00620                 break;
00621                 }
00622             i++;
00623             pw = pw1;
00624         }
00625         break;
00626 
00627     case REG_BINARY:
00628         fprintf( fh, "REG_BINARY 0x%08lx", KeyValueInformation->DataLength );
00629         p = (PULONG)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
00630         i = (KeyValueInformation->DataLength + 3) / sizeof( ULONG );
00631         if (!SummaryOutput || i <= 8) {
00632             for (j=0; j<i; j++) {
00633                 if ((j % 8) == 0) {
00634                     fprintf( fh, "\n%.*s",
00635                              IndentLevel+4,
00636                              "                                                                                  "
00637                            );
00638                     }
00639 
00640                 fprintf( fh, "0x%08lx  ", *p++ );
00641                 }
00642             }
00643         else {
00644             fprintf( fh, " *** value display suppressed ***" );
00645             }
00646         fprintf( fh, "\n" );
00647         break;
00648 
00649 //  case REG_DWORD_LITTLE_ENDIAN:
00650     case REG_DWORD:
00651         fprintf( fh, "REG_DWORD 0x%08lx",
00652                  *((PULONG)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset))
00653                );
00654         break;
00655 
00656     case REG_DWORD_BIG_ENDIAN:
00657         fprintf( fh, "REG_DWORD_BIG_ENDIAN 0x%08lx",
00658                  *((PULONG)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset))
00659                );
00660         break;
00661 
00662     case REG_LINK:
00663         fprintf( fh, "REG_LINK %ws",
00664                  ((PWSTR)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset))
00665                );
00666         break;
00667 
00668     case REG_MULTI_SZ:
00669         cbPrefix += fprintf( fh, "REG_MULTI_SZ " );
00670         pw = (PWSTR)((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
00671         i  = 0;
00672         if (*pw)
00673         while (i < ((KeyValueInformation->DataLength-1) / sizeof(WCHAR))) {
00674             if (i > 0) {
00675                 fprintf( fh, " \\\n%.*s",
00676                          cbPrefix,
00677                          "                                                                                  "
00678                        );
00679             }
00680             fprintf(fh, "\"%ws\" ",pw+i);
00681             do {
00682                 ++i;
00683             } while ( pw[i] != UNICODE_NULL );
00684             ++i;
00685         }
00686         break;
00687 
00688     case REG_RESOURCE_LIST:
00689     case REG_FULL_RESOURCE_DESCRIPTOR:
00690         {
00691         PCM_RESOURCE_LIST ResourceList = ((PCM_RESOURCE_LIST)((PCHAR)KeyValueInformation +
00692                                           KeyValueInformation->DataOffset));
00693         PCM_FULL_RESOURCE_DESCRIPTOR FullDescriptor;
00694         PCM_PARTIAL_RESOURCE_DESCRIPTOR PartialResourceDescriptor;
00695         ULONG k, l, count;
00696         PWSTR TypeName;
00697         PWSTR FlagName;
00698         ULONG Size = KeyValueInformation->DataLength;
00699 
00700         if (KeyValueInformation->Type == REG_RESOURCE_LIST) {
00701 
00702             fprintf( fh, "   REG_RESOURCE_LIST\n");
00703 
00704             fprintf( fh, "%.*sNumber of Full resource Descriptors = %d",
00705                      IndentLevel,
00706                      "                                                                                  ",
00707                      ResourceList->Count
00708                    );
00709 
00710              count = ResourceList->Count;
00711              FullDescriptor = &ResourceList->List[0];
00712 
00713         } else {
00714 
00715             fprintf( fh, "   REG_FULL_RESOURCE_DESCRIPTOR\n");
00716             count = 1;
00717             FullDescriptor = ((PCM_FULL_RESOURCE_DESCRIPTOR)
00718                 ((PCHAR)KeyValueInformation + KeyValueInformation->DataOffset));
00719 
00720         }
00721 
00722         for (i=0; i< count; i++) {
00723 
00724             fprintf( fh, "\n%.*sPartial List number %d\n",
00725                      IndentLevel+4,
00726                      "                                                                                  ",
00727                      i
00728                    );
00729 
00730             switch(FullDescriptor->InterfaceType) {
00731 
00732             case Internal:      TypeName = L"Internal";         break;
00733             case Isa:           TypeName = L"Isa";              break;
00734             case Eisa:          TypeName = L"Eisa";             break;
00735             case MicroChannel:  TypeName = L"MicroChannel";     break;
00736             case TurboChannel:  TypeName = L"TurboChannel";     break;
00737             case PCIBus:        TypeName = L"PCI";              break;
00738             case VMEBus:        TypeName = L"VME";              break;
00739             case NuBus:         TypeName = L"NuBus";            break;
00740             case PCMCIABus:     TypeName = L"PCMCIA";           break;
00741             case CBus:          TypeName = L"CBUS";             break;
00742             case MPIBus:        TypeName = L"MPI";              break;
00743 
00744             default:
00745                 TypeName = L"***invalid bus type***";
00746                 break;
00747             }
00748 
00749             fprintf( fh, "%.*sINTERFACE_TYPE %ws\n",
00750                      IndentLevel+8,
00751                      "                                                                                  ",
00752                      TypeName
00753                    );
00754 
00755             fprintf( fh, "%.*sBUS_NUMBER  %d\n",
00756                      IndentLevel+8,
00757                      "                                                                                  ",
00758                      FullDescriptor->BusNumber
00759                    );
00760 
00761             //
00762             // This is a basic test to see if the data format is right.
00763             // We know at least some video resource list are bogus ...
00764             //
00765 
00766             if (Size < FullDescriptor->PartialResourceList.Count *
00767                          sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR) ) {
00768 
00769                 fprintf( fh, "\n%.*s *** !!! Invalid ResourceList !!! *** \n",
00770                          IndentLevel+8,
00771                          "                                                                                  ",
00772                          i
00773                        );
00774 
00775                 break;
00776             }
00777 
00778             Size -= FullDescriptor->PartialResourceList.Count *
00779                          sizeof(CM_PARTIAL_RESOURCE_DESCRIPTOR);
00780 
00781 
00782 
00783             for (j=0; j<FullDescriptor->PartialResourceList.Count; j++) {
00784 
00785                 fprintf( fh, "%.*sDescriptor number %d\n",
00786                          IndentLevel+12,
00787                          "                                                                                  ",
00788                          j
00789                        );
00790 
00791                 PartialResourceDescriptor =
00792             &(FullDescriptor->PartialResourceList.PartialDescriptors[j]);
00793 
00794                 switch(PartialResourceDescriptor->ShareDisposition) {
00795 
00796                 case CmResourceShareUndetermined:
00797                     TypeName = L"CmResourceShareUndetermined";
00798                     break;
00799                 case CmResourceShareDeviceExclusive:
00800                     TypeName = L"CmResourceDeviceExclusive";
00801                     break;
00802                 case CmResourceShareDriverExclusive:
00803                     TypeName = L"CmResourceDriverExclusive";
00804                     break;
00805                 case CmResourceShareShared:
00806                     TypeName = L"CmResourceShared";
00807                     break;
00808                 default:
00809                     TypeName = L"***invalid share disposition***";
00810                     break;
00811                 }
00812 
00813                 fprintf( fh, "%.*sShare Disposition %ws\n",
00814                          IndentLevel+12,
00815                          "                                                                                  ",
00816                          TypeName
00817                        );
00818 
00819                 FlagName = L"***invalid Flags";
00820 
00821                 switch(PartialResourceDescriptor->Type) {
00822 
00823                 case CmResourceTypeNull:
00824                     TypeName = L"NULL";
00825                     FlagName = L"***Unused";
00826                     break;
00827                 case CmResourceTypePort:
00828                     TypeName = L"PORT";
00829                     if (PartialResourceDescriptor->Flags == CM_RESOURCE_PORT_MEMORY) {
00830                         FlagName = L"CM_RESOURCE_PORT_MEMORY";
00831                     }
00832                     if (PartialResourceDescriptor->Flags == CM_RESOURCE_PORT_IO) {
00833                         FlagName = L"CM_RESOURCE_PORT_IO";
00834                     }
00835                     break;
00836                 case CmResourceTypeInterrupt:
00837                     TypeName = L"INTERRUPT";
00838                     if (PartialResourceDescriptor->Flags == CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE) {
00839                         FlagName = L"CM_RESOURCE_INTERRUPT_LEVEL_SENSITIVE";
00840                     }
00841                     if (PartialResourceDescriptor->Flags == CM_RESOURCE_INTERRUPT_LATCHED) {
00842                         FlagName = L"CM_RESOURCE_INTERRUPT_LATCHED";
00843                     }
00844                     break;
00845                 case CmResourceTypeMemory:
00846                     TypeName = L"MEMORY";
00847                     if (PartialResourceDescriptor->Flags == CM_RESOURCE_MEMORY_READ_WRITE) {
00848                         FlagName = L"CM_RESOURCE_MEMORY_READ_WRITE";
00849                     }
00850                     if (PartialResourceDescriptor->Flags == CM_RESOURCE_MEMORY_READ_ONLY) {
00851                         FlagName = L"CM_RESOURCE_MEMORY_READ_ONLY";
00852                     }
00853                     if (PartialResourceDescriptor->Flags == CM_RESOURCE_MEMORY_WRITE_ONLY) {
00854                         FlagName = L"CM_RESOURCE_MEMORY_WRITE_ONLY";
00855                     }
00856                     break;
00857                 case CmResourceTypeDma:
00858                     TypeName = L"DMA";
00859                     FlagName = L"***Unused";
00860                     break;
00861                 case CmResourceTypeDeviceSpecific:
00862                     TypeName = L"DEVICE SPECIFIC";
00863                     FlagName = L"***Unused";
00864                     break;
00865                 default:
00866                     TypeName = L"***invalid type***";
00867                     break;
00868                 }
00869 
00870                 fprintf( fh, "%.*sTYPE              %ws\n",
00871                          IndentLevel+12,
00872                          "                                                                                  ",
00873                          TypeName
00874                        );
00875 
00876                 fprintf( fh, "%.*sFlags             %ws\n",
00877                          IndentLevel+12,
00878                          "                                                                                  ",
00879                          FlagName
00880                        );
00881 
00882                 switch(PartialResourceDescriptor->Type) {
00883 
00884                 case CmResourceTypePort:
00885                     fprintf( fh, "%.*sSTART 0x%08lx  LENGTH 0x%08lx\n",
00886                              IndentLevel+12,
00887                              "                                                                                  ",
00888                              PartialResourceDescriptor->u.Port.Start.LowPart,
00889                              PartialResourceDescriptor->u.Port.Length
00890                            );
00891                     break;
00892 
00893                 case CmResourceTypeInterrupt:
00894                     fprintf( fh, "%.*sLEVEL %d  VECTOR %d  AFFINITY %d\n",
00895                              IndentLevel+12,
00896                              "                                                                                  ",
00897                              PartialResourceDescriptor->u.Interrupt.Level,
00898                              PartialResourceDescriptor->u.Interrupt.Vector,
00899                              PartialResourceDescriptor->u.Interrupt.Affinity
00900                            );
00901                     break;
00902 
00903                 case CmResourceTypeMemory:
00904                     fprintf( fh, "%.*sSTART 0x%08lx%08lx  LENGTH 0x%08lx\n",
00905                              IndentLevel+12,
00906                              "                                                                                  ",
00907                              PartialResourceDescriptor->u.Memory.Start.HighPart,
00908                              PartialResourceDescriptor->u.Memory.Start.LowPart,
00909                              PartialResourceDescriptor->u.Memory.Length
00910                            );
00911                     break;
00912 
00913                 case CmResourceTypeDma:
00914                     fprintf( fh, "%.*sCHANNEL %d  PORT %d\n",
00915                              IndentLevel+12,
00916                              "                                                                                  ",
00917                              PartialResourceDescriptor->u.Dma.Channel,
00918                              PartialResourceDescriptor->u.Dma.Port
00919                            );
00920                     break;
00921 
00922                 case CmResourceTypeDeviceSpecific:
00923                     fprintf( fh, "%.*sDataSize 0x%08lx\n",
00924                              IndentLevel+12,
00925                              "                                                                                  ",
00926                              PartialResourceDescriptor->u.DeviceSpecificData.DataSize
00927                            );
00928 
00929                     p = (PULONG)(PartialResourceDescriptor + 1);
00930                     k = (PartialResourceDescriptor->u.DeviceSpecificData.DataSize + 3) / sizeof( ULONG );
00931                     for (l=0; l<k; l++) {
00932                         if ((l % 8) == 0) {
00933                             fprintf( fh, "\n%.*s",
00934                                 IndentLevel+12,
00935                                 "                                                                                  "
00936                                );
00937                         }
00938 
00939                         fprintf( fh, "0x%08lx  ", *p++ );
00940                     }
00941                     fprintf( fh, "\n" );
00942                     break;
00943 
00944                 default:
00945                     fprintf( fh, "%.*s*** Unknown resource list type: %c ****\n",
00946                              IndentLevel+12,
00947                              "                                                                                  ",
00948                              PartialResourceDescriptor->Type
00949                            );
00950                     break;
00951                 }
00952 
00953                 fprintf( fh, "\n" );
00954             }
00955 
00956             FullDescriptor = (PCM_FULL_RESOURCE_DESCRIPTOR) (PartialResourceDescriptor+1);
00957         }
00958 
00959         break;
00960         }
00961 
00962     case REG_NONE:
00963     default:
00964         if (KeyValueInformation->Type == REG_NONE) {
00965             fprintf( fh, "REG_NONE\n");
00966             }
00967         else {
00968             fprintf( fh, "*** Unknown registry type (%08lx)",
00969                      KeyValueInformation->Type
00970                    );
00971             }
00972         fprintf( fh, "%.*s",
00973              IndentLevel,
00974              "                                                                                  "
00975              );
00976         fprintf( fh, "    Length: 0x%lx\n", KeyValueInformation->DataLength );
00977                 fprintf( fh, "\n%.*s",
00978                     IndentLevel,
00979                     "                                                                                  "
00980                     );
00981         fprintf( fh, "      Data: ");
00982         pbyte = ((PUCHAR)KeyValueInformation + KeyValueInformation->DataOffset);
00983         for ( k=0, m=1; k<KeyValueInformation->DataLength; k++,m++) {
00984             fprintf( fh, "%02x ", (*pbyte) );
00985             pbyte++;
00986 
00987             if (m==8) {
00988                 fprintf( fh, "\n%.*s",
00989                     IndentLevel+12,
00990                     "                                                                                  "
00991                     );
00992                 m=0;
00993             }
00994         }
00995         break;
00996     }
00997 
00998     fprintf( fh, "\n" );
00999     return;
01000 }

BOOLEAN RegGetKeyValue (  IN PUNICODE_STRING  KeyValue,
IN OUT PREG_UNICODE_FILE  UnicodeFile,
OUT PULONG  ValueType,
OUT PVOID *  ValueBuffer,
OUT PULONG  ValueLength
) 
 

Definition at line 1096 of file config/utils/regutil.c.

References FALSE, L, n, NT_SUCCESS, NTSTATUS(), NULL, NUMBER_DATE_TIME_FIELDS, RegGetMultiString(), RegGetNextLine(), RegReadBinaryFile(), RegReadMultiSzFile(), RiDeleteKeyword, RiFalseKeyword, RiNoKeyword, RiOffKeyword, RiOnKeyword, RiRegBinaryFileKeyword, RiRegBinaryKeyword, RiRegDateKeyword, RiRegDwordKeyword, RiRegExpandSzKeyword, RiRegKeyword, RiRegLinkKeyword, RiRegMultiSzFileKeyword, RiRegMultiSzKeyword, RiRegNoneKeyword, RiRegSzKeyword, RiTrueKeyword, RiYesKeyword, RtlAllocateHeap, RtlFreeHeap, RtlPrefixUnicodeString(), RtlUnicodeStringToInteger(), Status, TRUE, USHORT, and ValueBuffer.

Referenced by RiInitializeRegistryFromAsciiFile(). 

01103 {
01104     ULONG PrefixLength;
01105     PWSTR s;
01106     PULONG p;
01107     ULONG n;
01108     NTSTATUS Status;
01109     ULONG IndentAmount;
01110     PWSTR FirstEqual;
01111     UNICODE_STRING KeyValue;
01112     UNICODE_STRING MultiValue;
01113     BOOLEAN GetDataFromBinaryFile = FALSE;
01114     BOOLEAN GetDataFromMultiSzFile = FALSE;
01115     BOOLEAN ParseDateTime = FALSE;
01116 
01117     KeyValue = *InitialKeyValue;
01118     if (RtlPrefixUnicodeString( &RiDeleteKeyword, &KeyValue, TRUE )) {
01119         *ValueBuffer = NULL;
01120         return( TRUE );
01121         }
01122     else
01123     if (!RtlPrefixUnicodeString( &RiRegKeyword, &KeyValue, TRUE )) {
01124         *ValueType = REG_SZ;
01125         PrefixLength = 0;
01126         }
01127     else
01128     if (RtlPrefixUnicodeString( &RiRegNoneKeyword, &KeyValue, TRUE )) {
01129         *ValueType = REG_NONE;
01130         PrefixLength = RiRegNoneKeyword.Length;
01131         }
01132     else
01133     if (RtlPrefixUnicodeString( &RiRegSzKeyword, &KeyValue, TRUE )) {
01134         *ValueType = REG_SZ;
01135         PrefixLength = RiRegSzKeyword.Length;
01136         }
01137     else
01138     if (RtlPrefixUnicodeString( &RiRegExpandSzKeyword, &KeyValue, TRUE )) {
01139         *ValueType = REG_EXPAND_SZ;
01140         PrefixLength = RiRegExpandSzKeyword.Length;
01141         }
01142     else
01143     if (RtlPrefixUnicodeString( &RiRegDwordKeyword, &KeyValue, TRUE )) {
01144         *ValueType = REG_DWORD;
01145         PrefixLength = RiRegDwordKeyword.Length;
01146         }
01147     else
01148     if (RtlPrefixUnicodeString( &RiRegBinaryFileKeyword, &KeyValue, TRUE )) {
01149         *ValueType = REG_BINARY;
01150         PrefixLength = RiRegBinaryFileKeyword.Length;
01151         GetDataFromBinaryFile = TRUE;
01152         }
01153     else
01154     if (RtlPrefixUnicodeString( &RiRegBinaryKeyword, &KeyValue, TRUE )) {
01155         *ValueType = REG_BINARY;
01156         PrefixLength = RiRegBinaryKeyword.Length;
01157         }
01158     else
01159     if (RtlPrefixUnicodeString( &RiRegLinkKeyword, &KeyValue, TRUE )) {
01160         *ValueType = REG_LINK;
01161         PrefixLength = RiRegLinkKeyword.Length;
01162         }
01163     else
01164     if (RtlPrefixUnicodeString( &RiRegMultiSzFileKeyword, &KeyValue, TRUE)) {
01165         *ValueType = REG_MULTI_SZ;
01166         PrefixLength = RiRegMultiSzFileKeyword.Length;
01167         GetDataFromMultiSzFile = TRUE;
01168         }
01169     else
01170     if (RtlPrefixUnicodeString( &RiRegMultiSzKeyword, &KeyValue, TRUE)) {
01171         *ValueType = REG_MULTI_SZ;
01172         PrefixLength = RiRegMultiSzKeyword.Length;
01173         }
01174     else
01175     if (RtlPrefixUnicodeString( &RiRegDateKeyword, &KeyValue, TRUE )) {
01176         *ValueType = REG_BINARY;
01177         ParseDateTime = TRUE;
01178         PrefixLength = RiRegDateKeyword.Length;
01179         }
01180     else {
01181         return( FALSE );
01182         }
01183 
01184     if (*ValueType != REG_NONE) {
01185         s = (PWSTR)
01186             ((PCHAR)KeyValue.Buffer + PrefixLength);
01187         KeyValue.Length -= (USHORT)PrefixLength;
01188         while (KeyValue.Length != 0 && *s <= L' ') {
01189             s++;
01190             KeyValue.Length -= sizeof( WCHAR );
01191             }
01192         KeyValue.Buffer = s;
01193         }
01194     else {
01195         *ValueType = REG_SZ;
01196         }
01197 
01198 
01199     if (GetDataFromBinaryFile) {
01200         Status = RegReadBinaryFile( &KeyValue, ValueBuffer, ValueLength );
01201         if (NT_SUCCESS( Status )) {
01202             return( TRUE );
01203             }
01204         else {
01205             fprintf( stderr, "REGINI: Unable to read data from %wZ - Status == %lx\n", &KeyValue, Status );
01206             return( FALSE );
01207             }
01208         }
01209 
01210     if (GetDataFromMultiSzFile) {
01211         Status = RegReadMultiSzFile( &KeyValue, ValueBuffer, ValueLength );
01212         if (NT_SUCCESS( Status )) {
01213             return( TRUE );
01214             }
01215         else {
01216             fprintf( stderr, "REGINI: Unable to read data from %wZ - Status == %lx\n", &KeyValue, Status );
01217             return( FALSE );
01218             }
01219         }
01220 
01221     switch( *ValueType ) {
01222     case REG_SZ:
01223     case REG_EXPAND_SZ:
01224     case REG_LINK:
01225         *ValueLength = KeyValue.Length + sizeof( UNICODE_NULL );
01226         *ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, *ValueLength );
01227         if (*ValueBuffer == NULL) {
01228             return( FALSE );
01229             }
01230 
01231         RtlMoveMemory( *ValueBuffer, KeyValue.Buffer, KeyValue.Length );
01232         ((PWSTR)*ValueBuffer)[ KeyValue.Length / sizeof( WCHAR ) ] = UNICODE_NULL;
01233         return( TRUE );
01234 
01235     case REG_DWORD:
01236         *ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, sizeof( ULONG ) );
01237         if (*ValueBuffer == NULL) {
01238             return( FALSE );
01239             }
01240 
01241         if (RtlPrefixUnicodeString( &RiTrueKeyword, &KeyValue, TRUE ) ||
01242             RtlPrefixUnicodeString( &RiYesKeyword, &KeyValue, TRUE ) ||
01243             RtlPrefixUnicodeString( &RiOnKeyword, &KeyValue, TRUE )
01244            ) {
01245             *(PULONG)*ValueBuffer = (ULONG)TRUE;
01246             }
01247         else
01248         if (RtlPrefixUnicodeString( &RiFalseKeyword, &KeyValue, TRUE ) ||
01249             RtlPrefixUnicodeString( &RiNoKeyword, &KeyValue, TRUE ) ||
01250             RtlPrefixUnicodeString( &RiOffKeyword, &KeyValue, TRUE )
01251            ) {
01252             *(PULONG)*ValueBuffer = (ULONG)FALSE;
01253             }
01254         else {
01255             Status = RtlUnicodeStringToInteger( &KeyValue, 0, (PULONG)*ValueBuffer );
01256             if (!NT_SUCCESS( Status )) {
01257                 fprintf( stderr, "REGINI: CharToInteger( %wZ ) failed - Status == %lx\n", &KeyValue, Status );
01258                 RtlFreeHeap( RtlProcessHeap(), 0, *ValueBuffer );
01259                 return( FALSE );
01260                 }
01261             }
01262 
01263         *ValueLength = sizeof( ULONG );
01264         return( TRUE );
01265 
01266     case REG_BINARY:
01267         if (ParseDateTime) {
01268 #define NUMBER_DATE_TIME_FIELDS 6
01269             ULONG FieldIndexes[ NUMBER_DATE_TIME_FIELDS  ] = {1, 2, 0, 3, 4, 7};
01270             //
01271             // Month/Day/Year HH:MM DayOfWeek
01272             //
01273 
01274             ULONG CurrentField = 0;
01275             PCSHORT Fields;
01276             TIME_FIELDS DateTimeFields;
01277             UNICODE_STRING Field;
01278             ULONG FieldValue;
01279 
01280             RtlZeroMemory( &DateTimeFields, sizeof( DateTimeFields ) );
01281             Fields = &DateTimeFields.Year;
01282             while (KeyValue.Length) {
01283                 if (CurrentField >= 7) {
01284                     return( FALSE );
01285                     }
01286 
01287                 s = KeyValue.Buffer;
01288                 while (KeyValue.Length && *s == L' ') {
01289                     KeyValue.Length--;
01290                     s++;
01291                     }
01292 
01293                 Field.Buffer = s;
01294                 while (KeyValue.Length) {
01295                     if (CurrentField == (NUMBER_DATE_TIME_FIELDS-1)) {
01296                         }
01297                     else
01298                     if (*s < L'0' || *s > L'9') {
01299                         break;
01300                         }
01301 
01302                     KeyValue.Length--;
01303                     s++;
01304                     }
01305 
01306                 Field.Length = (USHORT)((PCHAR)s - (PCHAR)Field.Buffer);
01307                 Field.MaximumLength = Field.Length;
01308 
01309                 if (KeyValue.Length) {
01310                     KeyValue.Length--;
01311                     s++;
01312                     }
01313                 KeyValue.Buffer = s;
01314 
01315                 if (CurrentField == (NUMBER_DATE_TIME_FIELDS-1)) {
01316                     if (Field.Length < 3) {
01317                         printf( "REGINI: %wZ invalid day of week length\n", &Field );
01318                         return FALSE;
01319                         }
01320 
01321                     if (DateTimeFields.Year != 0) {
01322                         printf( "REGINI: Year must be zero to specify day of week\n" );
01323                         return FALSE;
01324                         }
01325 
01326                     if (!_wcsnicmp( Field.Buffer, L"SUN", 3 )) {
01327                         FieldValue = 0;
01328                         }
01329                     else
01330                     if (!_wcsnicmp( Field.Buffer, L"MON", 3 )) {
01331                         FieldValue = 1;
01332                         }
01333                     else
01334                     if (!_wcsnicmp( Field.Buffer, L"TUE", 3 )) {
01335                         FieldValue = 2;
01336                         }
01337                     else
01338                     if (!_wcsnicmp( Field.Buffer, L"WED", 3 )) {
01339                         FieldValue = 3;
01340                         }
01341                     else
01342                     if (!_wcsnicmp( Field.Buffer, L"THU", 3 )) {
01343                         FieldValue = 4;
01344                         }
01345                     else
01346                     if (!_wcsnicmp( Field.Buffer, L"FRI", 3 )) {
01347                         FieldValue = 5;
01348                         }
01349                     else
01350                     if (!_wcsnicmp( Field.Buffer, L"SAT", 3 )) {
01351                         FieldValue = 6;
01352                         }
01353                     else {
01354                         printf( "REGINI: %wZ invalid day of week\n", &Field );
01355                         return FALSE;
01356                         }
01357                     }
01358                 else {
01359                     Status = RtlUnicodeStringToInteger( &Field, 10, &FieldValue );
01360                     if (!NT_SUCCESS( Status )) {
01361                         return( FALSE );
01362                         }
01363                     }
01364 
01365                 Fields[ FieldIndexes[ CurrentField++ ] ] = (CSHORT)FieldValue;
01366                 }
01367 
01368             if (DateTimeFields.Year == 0) {
01369                 if (DateTimeFields.Day > 5) {
01370                     printf( "REGINI: Day must be 0 - 5 if year is zero.\n" );
01371                     return FALSE;
01372                     }
01373                 }
01374             else
01375             if (DateTimeFields.Year < 100) {
01376                 DateTimeFields.Year += 1900;
01377                 }
01378 
01379             *ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, sizeof( DateTimeFields ) );
01380             *ValueLength = sizeof( DateTimeFields );
01381             RtlMoveMemory( *ValueBuffer, &DateTimeFields, sizeof( DateTimeFields ) );
01382             return TRUE;
01383             }
01384         else {
01385             Status = RtlUnicodeStringToInteger( &KeyValue, 0, ValueLength );
01386             if (!NT_SUCCESS( Status )) {
01387                 return( FALSE );
01388                 }
01389             s = KeyValue.Buffer;
01390             while (KeyValue.Length != 0 && *s > L' ') {
01391                 s++;
01392                 KeyValue.Length -= sizeof( WCHAR );
01393                 }
01394             KeyValue.Buffer = s;
01395             }
01396         break;
01397 
01398     case REG_MULTI_SZ:
01399         *ValueLength = 0;
01400         *ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, KeyValue.Length + sizeof( UNICODE_NULL ) );
01401         while (RegGetMultiString(&KeyValue, &MultiValue)) {
01402             RtlMoveMemory( (PUCHAR)*ValueBuffer + *ValueLength,
01403                            MultiValue.Buffer,
01404                            MultiValue.Length );
01405             *ValueLength += MultiValue.Length;
01406             ((PWSTR)*ValueBuffer)[ *ValueLength / sizeof(WCHAR) ] = UNICODE_NULL;
01407             *ValueLength += sizeof(UNICODE_NULL);
01408         }
01409         ((PWSTR)*ValueBuffer)[ *ValueLength / sizeof(WCHAR) ] = UNICODE_NULL;
01410         *ValueLength += sizeof(UNICODE_NULL);
01411 
01412         return( TRUE );
01413 
01414     default:
01415         return( FALSE );
01416     }
01417 
01418     *ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, *ValueLength );
01419     p = *ValueBuffer;
01420     n = (*ValueLength + sizeof( ULONG ) - 1) / sizeof( ULONG );
01421     while (n--) {
01422         if (KeyValue.Length == 0) {
01423             if (!RegGetNextLine( UnicodeFile, &IndentAmount, &FirstEqual )) {
01424                 RtlFreeHeap( RtlProcessHeap(), 0, *ValueBuffer );
01425                 return( FALSE );
01426                 }
01427             KeyValue.Buffer = UnicodeFile->BeginLine;
01428             KeyValue.Length = (USHORT)
01429                 ((PCHAR)UnicodeFile->EndOfLine - (PCHAR)UnicodeFile->BeginLine);
01430             KeyValue.MaximumLength = KeyValue.Length;
01431             }
01432 
01433         s = KeyValue.Buffer;
01434         while (KeyValue.Length != 0 && *s <= L' ') {
01435             s++;
01436             KeyValue.Length -= sizeof( WCHAR );
01437             }
01438         KeyValue.Buffer = s;
01439         if (KeyValue.Length != 0) {
01440             Status = RtlUnicodeStringToInteger( &KeyValue, 0, p );
01441             if (!NT_SUCCESS( Status )) {
01442                 RtlFreeHeap( RtlProcessHeap(), 0, *ValueBuffer );
01443                 return( FALSE );
01444                 }
01445             p++;
01446 
01447             s = KeyValue.Buffer;
01448             while (KeyValue.Length != 0 && *s > L' ') {
01449                 s++;
01450                 KeyValue.Length -= sizeof( WCHAR );
01451                 }
01452             KeyValue.Buffer = s;
01453             }
01454         }
01455 
01456     return( TRUE );
01457 }

BOOLEAN RegGetMultiString (  IN OUT PUNICODE_STRING  ValueString,
OUT PUNICODE_STRING  MultiString
) 
 

Definition at line 1009 of file config/utils/regutil.c.

References FALSE, L, and TRUE.

Referenced by RegGetKeyValue(), and RegReadMultiSzFile(). 

01016                    :
01017 
01018     This routine parses multi-strings of the form
01019 
01020         "foo" "bar" "bletch"
01021 
01022     Each time it is called, it strips the first string in quotes from
01023     the input string, and returns it as the multi-string.
01024 
01025     INPUT ValueString: "foo" "bar" "bletch"
01026 
01027     OUTPUT ValueString: "bar" "bletch"
01028            MultiString: foo
01029 
01030 Arguments:
01031 
01032     ValueString - Supplies the string from which the multi-string will be
01033                   parsed
01034                 - Returns the remaining string after the multi-string is
01035                   removed
01036 
01037     MultiString - Returns the multi-string removed from ValueString
01038 
01039 Return Value:
01040 
01041     TRUE - multi-string found and removed.
01042 
01043     FALSE - no more multi-strings remaining.
01044 
01045 --*/
01046 
01047 {
01048     //
01049     // Find the first quote mark.
01050     //
01051     while ((*(ValueString->Buffer) != L'"') &&
01052            (ValueString->Length > 0)) {
01053         ++ValueString->Buffer;
01054         ValueString->Length -= sizeof(WCHAR);
01055         ValueString->MaximumLength -= sizeof(WCHAR);
01056     }
01057 
01058     if (ValueString->Length == 0) {
01059         return(FALSE);
01060     }
01061 
01062     //
01063     // We have found the start of the multi-string.  Now find the end,
01064     // building up our return MultiString as we go.
01065     //
01066     ++ValueString->Buffer;
01067     ValueString->Length -= sizeof(WCHAR);
01068     ValueString->MaximumLength -= sizeof(WCHAR);
01069     MultiString->Buffer = ValueString->Buffer;
01070     MultiString->Length = 0;
01071     MultiString->MaximumLength = 0;
01072     while ((*(ValueString->Buffer) != L'"') &&
01073            (ValueString->Length > 0)) {
01074         ++ValueString->Buffer;
01075         ValueString->Length -= sizeof(WCHAR);
01076         ValueString->MaximumLength -= sizeof(WCHAR);
01077 
01078         MultiString->Length += sizeof(WCHAR);
01079         MultiString->MaximumLength += sizeof(WCHAR);
01080     }
01081 
01082     if (ValueString->Length == 0) {
01083         return(FALSE);
01084     }
01085 
01086     ++ValueString->Buffer;
01087     ValueString->Length -= sizeof(WCHAR);
01088     ValueString->MaximumLength -= sizeof(WCHAR);
01089 
01090     return( TRUE );
01091 
01092 }

BOOLEAN RegGetNextLine (  IN OUT PREG_UNICODE_FILE  UnicodeFile,
OUT PULONG  IndentAmount,
OUT PWSTR *  FirstEqual
) 
 

Definition at line 473 of file config/utils/regutil.c.

References DebugOutput, FALSE, L, NULL, and TRUE.

Referenced by RegGetKeyValue(), and RiInitializeRegistryFromAsciiFile(). 

00478 {
00479     PWSTR s, s1;
00480 
00481     while (TRUE) {
00482         if (!(s = UnicodeFile->NextLine)) {
00483             return( FALSE );
00484             }
00485 
00486         *IndentAmount = 0;
00487         while (*s <= L' ') {
00488             if (*s == L' ') {
00489                 *IndentAmount += 1;
00490                 }
00491             else
00492             if (*s == L'\t') {
00493                 *IndentAmount = ((*IndentAmount + 8) -
00494                                  (*IndentAmount % 8)
00495                                 );
00496                 }
00497 
00498             if (++s >= UnicodeFile->EndOfFile) {
00499                 return( FALSE );
00500                 }
00501             }
00502 
00503         UnicodeFile->BeginLine = s;
00504 
00505         *FirstEqual = NULL;
00506         UnicodeFile->NextLine = NULL;
00507         while (s < UnicodeFile->EndOfFile) {
00508             if (*s == L'=') {
00509                 if (*FirstEqual == NULL) {
00510                     *FirstEqual = s;
00511                     }
00512                 }
00513             else
00514             if (*s == L'\n') {
00515                 s1 = s;
00516                 while (s > UnicodeFile->BeginLine && s[ -1 ] <= L' ') {
00517                     s--;
00518                     }
00519                 UnicodeFile->EndOfLine = s;
00520                 do {
00521                     if (++s1 >= UnicodeFile->EndOfFile) {
00522                         s1 = NULL;
00523                         break;
00524                         }
00525                     }
00526                 while (*s1 == L'\r' || *s1 == L'\n');
00527 
00528                 UnicodeFile->NextLine = s1;
00529                 break;
00530                 }
00531 
00532             if (++s == UnicodeFile->EndOfFile) {
00533                 break;
00534                 }
00535             }
00536 
00537         if (UnicodeFile->EndOfLine > UnicodeFile->BeginLine) {
00538             if (DebugOutput) {
00539                 fprintf( stderr, "%02u  %.*ws\n",
00540                          *IndentAmount,
00541                          UnicodeFile->EndOfLine - UnicodeFile->BeginLine,
00542                          UnicodeFile->BeginLine
00543                        );
00544                 }
00545 
00546             return( TRUE );
00547             }
00548         }
00549 
00550     return( FALSE );
00551 }

void RegInitialize (  void   ) 
 

Definition at line 45 of file config/utils/regutil.c.

References L, RiDeleteKeyword, RiFalseKeyword, RiNoKeyword, RiOffKeyword, RiOnKeyword, RiRegBinaryFileKeyword, RiRegBinaryKeyword, RiRegDateKeyword, RiRegDwordKeyword, RiRegExpandSzKeyword, RiRegKeyword, RiRegLinkKeyword, RiRegMultiSzFileKeyword, RiRegMultiSzKeyword, RiRegNoneKeyword, RiRegSzKeyword, RiTrueKeyword, RiYesKeyword, and RtlInitUnicodeString().

Referenced by main(). 

00046 {
00047     RtlInitUnicodeString( &RiOnKeyword, L"ON" );
00048     RtlInitUnicodeString( &RiYesKeyword, L"YES" );
00049     RtlInitUnicodeString( &RiTrueKeyword, L"TRUE" );
00050     RtlInitUnicodeString( &RiOffKeyword, L"OFF" );
00051     RtlInitUnicodeString( &RiNoKeyword, L"NO" );
00052     RtlInitUnicodeString( &RiFalseKeyword, L"FALSE" );
00053     RtlInitUnicodeString( &RiDeleteKeyword, L"DELETE" );
00054     RtlInitUnicodeString( &RiRegKeyword, L"REG_" );
00055     RtlInitUnicodeString( &RiRegNoneKeyword, L"REG_NONE" );
00056     RtlInitUnicodeString( &RiRegSzKeyword, L"REG_SZ" );
00057     RtlInitUnicodeString( &RiRegExpandSzKeyword, L"REG_EXPAND_SZ" );
00058     RtlInitUnicodeString( &RiRegDwordKeyword, L"REG_DWORD" );
00059     RtlInitUnicodeString( &RiRegBinaryKeyword, L"REG_BINARY" );
00060     RtlInitUnicodeString( &RiRegBinaryFileKeyword, L"REG_BINARYFILE" );
00061     RtlInitUnicodeString( &RiRegLinkKeyword, L"REG_LINK" );
00062     RtlInitUnicodeString( &RiRegMultiSzKeyword, L"REG_MULTI_SZ" );
00063     RtlInitUnicodeString( &RiRegMultiSzFileKeyword, L"REG_MULTISZFILE" );
00064     RtlInitUnicodeString( &RiRegDateKeyword, L"REG_DATE" );
00065 }

BOOLEAN RegInitializeSecurity (  VOID   ) 
 

NTSTATUS RegLoadAsciiFileAsUnicode (  IN PUNICODE_STRING  FileName,
OUT PREG_UNICODE_FILE  UnicodeFile
) 
 

Definition at line 259 of file config/utils/regutil.c.

References BufferSize, File, FileName, L, NT_SUCCESS, NtAllocateVirtualMemory(), NtClose(), NtFreeVirtualMemory(), NtOpenFile(), NtQueryInformationFile(), NtReadFile(), NTSTATUS(), NULL, ObjectAttributes, PREG_UNICODE_FILE, RtlAnsiCharToUnicodeChar(), Status, and TRUE.

Referenced by RegReadMultiSzFile(), and RiInitializeRegistryFromAsciiFile(). 

00263 {
00264     NTSTATUS Status;
00265     OBJECT_ATTRIBUTES ObjectAttributes;
00266     IO_STATUS_BLOCK IoStatus;
00267     HANDLE File;
00268     FILE_BASIC_INFORMATION FileDateTimeInfo;
00269     FILE_STANDARD_INFORMATION FileInformation;
00270     ULONG BufferSize, i, i1, LineCount;
00271     PVOID BufferBase;
00272     PCHAR Src, Src1;
00273     PWSTR Dst;
00274 
00275     InitializeObjectAttributes( &ObjectAttributes,
00276                                 FileName,
00277                                 OBJ_CASE_INSENSITIVE,
00278                                 (HANDLE)NULL,
00279                                 NULL
00280                               );
00281 
00282     Status = NtOpenFile( &File,
00283                          SYNCHRONIZE | GENERIC_READ,
00284                          &ObjectAttributes,
00285                          &IoStatus,
00286                          FILE_SHARE_DELETE |
00287                             FILE_SHARE_READ |
00288                             FILE_SHARE_WRITE,
00289                          FILE_SYNCHRONOUS_IO_NONALERT |
00290                             FILE_NON_DIRECTORY_FILE
00291                        );
00292     if (!NT_SUCCESS( Status )) {
00293         return( Status );
00294         }
00295 
00296     Status = NtQueryInformationFile( File,
00297                                      &IoStatus,
00298                                      (PVOID)&FileInformation,
00299                                      sizeof( FileInformation ),
00300                                      FileStandardInformation
00301                                    );
00302     if (NT_SUCCESS( Status )) {
00303         if (FileInformation.EndOfFile.HighPart) {
00304             Status = STATUS_BUFFER_OVERFLOW;
00305             }
00306         }
00307     if (!NT_SUCCESS( Status )) {
00308         NtClose( File );
00309         return( Status );
00310         }
00311 
00312 
00313     BufferSize = FileInformation.EndOfFile.LowPart * sizeof( WCHAR );
00314     BufferSize += sizeof( UNICODE_NULL );
00315     BufferBase = NULL;
00316     Status = NtAllocateVirtualMemory( NtCurrentProcess(),
00317                                       (PVOID *)&BufferBase,
00318                                       0,
00319                                       &BufferSize,
00320                                       MEM_COMMIT,
00321                                       PAGE_READWRITE
00322                                     );
00323     if (NT_SUCCESS( Status )) {
00324         Src = (PCHAR)BufferBase + ((FileInformation.EndOfFile.LowPart+1) & ~1);
00325         Dst = (PWSTR)BufferBase;
00326         Status = NtReadFile( File,
00327                              NULL,
00328                              NULL,
00329                              NULL,
00330                              &IoStatus,
00331                              Src,
00332                              FileInformation.EndOfFile.LowPart,
00333                              NULL,
00334                              NULL
00335                            );
00336 
00337         if (NT_SUCCESS( Status )) {
00338             Status = IoStatus.Status;
00339 
00340             if (NT_SUCCESS( Status )) {
00341                 if (IoStatus.Information != FileInformation.EndOfFile.LowPart) {
00342                     Status = STATUS_END_OF_FILE;
00343                     }
00344                 else {
00345                     Status = NtQueryInformationFile( File,
00346                                                      &IoStatus,
00347                                                      (PVOID)&FileDateTimeInfo,
00348                                                      sizeof( FileDateTimeInfo ),
00349                                                      FileBasicInformation
00350                                                    );
00351                     }
00352                 }
00353             }
00354 
00355         if (!NT_SUCCESS( Status )) {
00356             NtFreeVirtualMemory( NtCurrentProcess(),
00357                                  (PVOID *)&BufferBase,
00358                                  &BufferSize,
00359                                  MEM_RELEASE
00360                                );
00361             }
00362         }
00363 
00364     NtClose( File );
00365     if (!NT_SUCCESS( Status )) {
00366         return( Status );
00367         }
00368 
00369     i = 0;
00370     while (i < FileInformation.EndOfFile.LowPart) {
00371         if (i > 1 && (Src[-2] == ' ' || Src[-2] == '\t') &&
00372             Src[-1] == '\\' && (*Src == '\r' || *Src == '\n')
00373            ) {
00374             if (Dst[-1] == L'\\') {
00375                 --Dst;
00376                 }
00377             while (Dst > (PWSTR)BufferBase) {
00378                 if (Dst[-1] > L' ') {
00379                     break;
00380                     }
00381                 Dst--;
00382                 }
00383             LineCount = 0;
00384             while (i < FileInformation.EndOfFile.LowPart) {
00385                 if (*Src == '\n') {
00386                     i++;
00387                     Src++;
00388                     LineCount++;
00389                     }
00390                 else
00391                 if (*Src == '\r' &&
00392                     (i+1) < FileInformation.EndOfFile.LowPart &&
00393                     Src[ 1 ] == '\n'
00394                    ) {
00395                     i += 2;
00396                     Src += 2;
00397                     LineCount++;
00398                     }
00399                 else {
00400                     break;
00401                     }
00402                 }
00403 
00404             if (LineCount > 1) {
00405                 *Dst++ = L'\n';
00406                 }
00407             else {
00408                 *Dst++ = L' ';
00409                 while (i < FileInformation.EndOfFile.LowPart && (*Src == ' ' || *Src == '\t')) {
00410                     i++;
00411                     Src++;
00412                     }
00413                 }
00414 
00415             if (i >= FileInformation.EndOfFile.LowPart) {
00416                 break;
00417                 }
00418             }
00419         else
00420         if ((*Src == '\r' && Src[1] == '\n') || *Src == '\n') {
00421             while (TRUE) {
00422                 while (i < FileInformation.EndOfFile.LowPart && (*Src == '\r' || *Src == '\n')) {
00423                     i++;
00424                     Src++;
00425                     }
00426                 Src1 = Src;
00427                 i1 = i;
00428                 while (i1 < FileInformation.EndOfFile.LowPart && (*Src1 == ' ' || *Src1 == '\t')) {
00429                     i1++;
00430                     Src1++;
00431                     }
00432                 if (i1 < FileInformation.EndOfFile.LowPart &&
00433                     (*Src1 == '\r' && Src1[1] == '\n') || *Src1 == '\n'
00434                    ) {
00435                     Src = Src1;
00436                     i = i1;
00437                     }
00438                 else {
00439                     break;
00440                     }
00441                 }
00442 
00443             *Dst++ = L'\n';
00444             }
00445         else {
00446             i++;
00447             *Dst++ = RtlAnsiCharToUnicodeChar( &Src );
00448             }
00449         }
00450 
00451     if (NT_SUCCESS( Status )) {
00452         *Dst = UNICODE_NULL;
00453         UnicodeFile->FileContents = BufferBase;
00454         UnicodeFile->EndOfFile = Dst;
00455         UnicodeFile->BeginLine = NULL;
00456         UnicodeFile->EndOfLine = NULL;
00457         UnicodeFile->NextLine = BufferBase;
00458         UnicodeFile->LastWriteTime = FileDateTimeInfo.LastWriteTime;
00459         }
00460     else {
00461         NtFreeVirtualMemory( NtCurrentProcess(),
00462                              (PVOID *)&BufferBase,
00463                              &BufferSize,
00464                              MEM_RELEASE
00465                            );
00466         }
00467 
00468     return( Status );
00469 }

NTSTATUS RegReadBinaryFile (  IN PUNICODE_STRING  FileName,
OUT PVOID *  ValueBuffer,
OUT PULONG  ValueLength
) 
 

Definition at line 158 of file config/utils/regutil.c.

References File, FileName, FileNameBuffer, L, NT_SUCCESS, NtClose(), NtOpenFile(), NtQueryInformationFile(), NtReadFile(), NTSTATUS(), NULL, ObjectAttributes, RtlAllocateHeap, RtlFreeHeap, RtlInitUnicodeString(), Status, and ValueBuffer.

Referenced by RegGetKeyValue(). 

00163 {
00164     NTSTATUS Status;
00165     UNICODE_STRING NtFileName;
00166     OBJECT_ATTRIBUTES ObjectAttributes;
00167     IO_STATUS_BLOCK IoStatus;
00168     HANDLE File;
00169     FILE_STANDARD_INFORMATION FileInformation;
00170     WCHAR FileNameBuffer[ 256 ];
00171     PWSTR s;
00172 
00173     FileName->Buffer[ FileName->Length/sizeof(WCHAR) ] = UNICODE_NULL;
00174     wcscpy( FileNameBuffer, L"\\DosDevices\\" );
00175     s = wcscat( FileNameBuffer, FileName->Buffer );
00176     while (*s != UNICODE_NULL) {
00177         if (*s == L'/') {
00178             *s = L'\\';
00179             }
00180         s++;
00181         }
00182     RtlInitUnicodeString( &NtFileName, FileNameBuffer );
00183 
00184     InitializeObjectAttributes( &ObjectAttributes,
00185                                 &NtFileName,
00186                                 OBJ_CASE_INSENSITIVE,
00187                                 (HANDLE)NULL,
00188                                 NULL
00189                               );
00190 
00191     Status = NtOpenFile( &File,
00192                          SYNCHRONIZE | GENERIC_READ,
00193                          &ObjectAttributes,
00194                          &IoStatus,
00195                          FILE_SHARE_DELETE |
00196                             FILE_SHARE_READ |
00197                             FILE_SHARE_WRITE,
00198                          FILE_SYNCHRONOUS_IO_NONALERT |
00199                             FILE_NON_DIRECTORY_FILE
00200                        );
00201     if (!NT_SUCCESS( Status )) {
00202         return( Status );
00203         }
00204 
00205     Status = NtQueryInformationFile( File,
00206                                      &IoStatus,
00207                                      (PVOID)&FileInformation,
00208                                      sizeof( FileInformation ),
00209                                      FileStandardInformation
00210                                    );
00211     if (NT_SUCCESS( Status )) {
00212         if (FileInformation.EndOfFile.HighPart) {
00213             Status = STATUS_BUFFER_OVERFLOW;
00214             }
00215         }
00216     if (!NT_SUCCESS( Status )) {
00217         NtClose( File );
00218         return( Status );
00219         }
00220 
00221     *ValueLength = FileInformation.EndOfFile.LowPart;
00222     *ValueBuffer = RtlAllocateHeap( RtlProcessHeap(), 0, *ValueLength );
00223     if (*ValueBuffer == NULL) {
00224         Status = STATUS_NO_MEMORY;
00225         }
00226 
00227     if (NT_SUCCESS( Status )) {
00228         Status = NtReadFile( File,
00229                              NULL,
00230                              NULL,
00231                              NULL,
00232                              &IoStatus,
00233                              *ValueBuffer,
00234                              *ValueLength,
00235                              NULL,
00236                              NULL
00237                            );
00238 
00239         if (NT_SUCCESS( Status )) {
00240             Status = IoStatus.Status;
00241 
00242             if (NT_SUCCESS( Status )) {
00243                 if (IoStatus.Information != *ValueLength) {
00244                     Status = STATUS_END_OF_FILE;
00245                     }
00246                 }
00247             }
00248 
00249         if (!NT_SUCCESS( Status )) {
00250             RtlFreeHeap( RtlProcessHeap(), 0, *ValueBuffer );
00251             }
00252         }
00253 
00254     NtClose( File );
00255     return( Status );
00256 }

Variable Documentation

BOOLEAN DebugOutput
 

Definition at line 66 of file regutil.h.

Referenced by main(), RegGetNextLine(), and RiInitializeRegistryFromAsciiFile().

BOOLEAN SummaryOutput
 

Definition at line 67 of file regutil.h.

Referenced by main(), and RegDumpKeyValue().

Generated on Sat May 15 19:45:28 2004 for test by doxygen 1.3.7