Beispiel #1
0
 private void CreateValue(List <RegChange> rollbackRegistry)
 {
     if (rollbackRegistry != null)
     {
         RegChange regChange = new RegChange(RegOperations.CreateValue, RegBasekey, SubKey, Is32BitKey, ValueName);
         try
         {
             using (RegistryKey registryKey = ReturnOpenKey(SubKey))
             {
                 regChange.RegValueKind = registryKey.GetValueKind(ValueName);
                 regChange.ValueData    = registryKey.GetValue(ValueName, null, RegistryValueOptions.DoNotExpandEnvironmentNames);
             }
         }
         catch (Exception)
         {
             regChange.RegOperation = RegOperations.RemoveValue;
         }
         rollbackRegistry.Add(regChange);
     }
     if (rollbackRegistry != null)
     {
         BackupCreateKeyTree(rollbackRegistry);
     }
     using (RegistryKey registryKey2 = ReturnCreateKey())
     {
         registryKey2.SetValue(ValueName, (RegValueKind == RegistryValueKind.MultiString) ? StringToMultiString(ValueData) : ValueData, RegValueKind);
     }
 }
        void CreateValue(List <RegChange> rollbackRegistry)
        {
            if (rollbackRegistry != null)
            {
                RegChange origValue = new RegChange(RegOperations.CreateValue, RegBasekey, SubKey, Is32BitKey, ValueName);

                try
                {
                    using (RegistryKey rk = ReturnOpenKey(SubKey))
                    {
                        //create a rollback to the previous value
                        origValue.RegValueKind = rk.GetValueKind(ValueName);
                        origValue.ValueData    = rk.GetValue(ValueName, null, RegistryValueOptions.DoNotExpandEnvironmentNames);
                    }
                }
                catch (Exception)
                {
                    origValue.RegOperation = RegOperations.RemoveValue;
                }

                rollbackRegistry.Add(origValue);
            }

            //backup any new subtree creations
            if (rollbackRegistry != null)
            {
                BackupCreateKeyTree(rollbackRegistry);
            }

            //set the new registry value
            using (RegistryKey regValue = ReturnCreateKey())
            {
                regValue.SetValue(ValueName,
                                  RegValueKind == RegistryValueKind.MultiString
                        ? StringToMultiString(ValueData)
                        : ValueData,
                                  RegValueKind);
            }
        }
        void CreateValue(List<RegChange> rollbackRegistry)
        {
            if (rollbackRegistry != null)
            {
                RegChange origValue = new RegChange(RegOperations.CreateValue, RegBasekey, SubKey, Is32BitKey, ValueName);

                try
                {
                    using (RegistryKey rk = ReturnOpenKey(SubKey))
                    {
                        //create a rollback to the previous value
                        origValue.RegValueKind = rk.GetValueKind(ValueName);
                        origValue.ValueData = rk.GetValue(ValueName, null, RegistryValueOptions.DoNotExpandEnvironmentNames);
                    }
                }
                catch (Exception)
                {
                    origValue.RegOperation = RegOperations.RemoveValue;
                }

                rollbackRegistry.Add(origValue);
            }

            //backup any new subtree creations
            if (rollbackRegistry != null)
                BackupCreateKeyTree(rollbackRegistry);

            //set the new registry value
            using (RegistryKey regValue = ReturnCreateKey())
            {
                regValue.SetValue(ValueName,
                    RegValueKind == RegistryValueKind.MultiString
                        ? StringToMultiString(ValueData)
                        : ValueData,
                    RegValueKind);
            }
        }
Beispiel #4
0
        public static UpdateDetails Load(string fileName)
        {
            UpdateDetails updateDetails = new UpdateDetails();

            try
            {
                using (FileStream fileStream = new FileStream(fileName, FileMode.Open, FileAccess.Read))
                {
                    if (!ReadFiles.IsHeaderValid(fileStream, "IUUDFV2"))
                    {
                        throw new ArgumentException("Incorrect file identifier.");
                    }
                    UpdateFile updateFile = new UpdateFile();
                    int        num        = 0;
                    byte       b          = (byte)fileStream.ReadByte();
                    while (!ReadFiles.ReachedEndByte(fileStream, b, byte.MaxValue))
                    {
                        switch (b)
                        {
                        case 32:
                            updateDetails.RegistryModifications = new List <RegChange>(ReadFiles.ReadInt(fileStream));
                            break;

                        case 33:
                            updateDetails.UpdateFiles = new List <UpdateFile>(ReadFiles.ReadInt(fileStream));
                            break;

                        case 142:
                            updateDetails.RegistryModifications.Add(RegChange.ReadFromStream(fileStream));
                            break;

                        case 48:
                            updateDetails.PreviousCommonDesktopShortcuts.Add(ReadFiles.ReadDeprecatedString(fileStream));
                            break;

                        case 49:
                            updateDetails.PreviousCommonSMenuShortcuts.Add(ReadFiles.ReadDeprecatedString(fileStream));
                            break;

                        case 54:
                            updateDetails.PreviousCUserDesktopShortcuts.Add(ReadFiles.ReadString(fileStream));
                            break;

                        case 55:
                            updateDetails.PreviousCUserSMenuShortcuts.Add(ReadFiles.ReadString(fileStream));
                            break;

                        case 50:
                            updateDetails.ServicesToStop.Add(ReadFiles.ReadString(fileStream));
                            break;

                        case 51:
                            updateDetails.ServicesToStart.Add(new StartService(ReadFiles.ReadString(fileStream)));
                            break;

                        case 52:
                            updateDetails.ServicesToStart[updateDetails.ServicesToStart.Count - 1].Arguments = new string[ReadFiles.ReadInt(fileStream)];
                            num = 0;
                            break;

                        case 53:
                            updateDetails.ServicesToStart[updateDetails.ServicesToStart.Count - 1].Arguments[num] = ReadFiles.ReadString(fileStream);
                            num++;
                            break;

                        case 64:
                            updateFile.RelativePath = ReadFiles.ReadDeprecatedString(fileStream);
                            break;

                        case 65:
                            updateFile.Execute = ReadFiles.ReadBool(fileStream);
                            break;

                        case 66:
                            updateFile.ExBeforeUpdate = ReadFiles.ReadBool(fileStream);
                            break;

                        case 67:
                            updateFile.CommandLineArgs = ReadFiles.ReadDeprecatedString(fileStream);
                            break;

                        case 68:
                            updateFile.IsNETAssembly = ReadFiles.ReadBool(fileStream);
                            break;

                        case 69:
                            updateFile.WaitForExecution = ReadFiles.ReadBool(fileStream);
                            break;

                        case 143:
                            updateFile.RollbackOnNonZeroRet = true;
                            break;

                        case 77:
                            if (updateFile.RetExceptions == null)
                            {
                                updateFile.RetExceptions = new List <int>();
                            }
                            updateFile.RetExceptions.Add(ReadFiles.ReadInt(fileStream));
                            break;

                        case 70:
                            updateFile.DeleteFile = ReadFiles.ReadBool(fileStream);
                            break;

                        case 71:
                            updateFile.DeltaPatchRelativePath = ReadFiles.ReadDeprecatedString(fileStream);
                            break;

                        case 72:
                            updateFile.NewFileAdler32 = ReadFiles.ReadLong(fileStream);
                            break;

                        case 73:
                            updateFile.CPUVersion = (CPUVersion)ReadFiles.ReadInt(fileStream);
                            break;

                        case 74:
                            updateFile.ProcessWindowStyle = (ProcessWindowStyle)ReadFiles.ReadInt(fileStream);
                            break;

                        case 78:
                            updateFile.ElevationType = (ElevationType)ReadFiles.ReadInt(fileStream);
                            break;

                        case 75:
                            updateFile.FrameworkVersion = (FrameworkVersion)ReadFiles.ReadInt(fileStream);
                            break;

                        case 76:
                            updateFile.RegisterCOMDll = (COMRegistration)ReadFiles.ReadInt(fileStream);
                            break;

                        case 155:
                            updateDetails.UpdateFiles.Add(updateFile);
                            updateFile = new UpdateFile();
                            break;

                        case 141:
                            updateDetails.ShortcutInfos.Add(ShortcutInfo.LoadFromStream(fileStream));
                            break;

                        case 96:
                            updateDetails.FoldersToDelete.Add(ReadFiles.ReadDeprecatedString(fileStream));
                            break;

                        default:
                            ReadFiles.SkipField(fileStream, b);
                            break;
                        }
                        b = (byte)fileStream.ReadByte();
                    }
                    return(updateDetails);
                }
            }
            catch (Exception ex)
            {
                throw new Exception("The update details file failed to open.\n\nFull details: " + ex.Message);
            }
        }
        public static ServerFile Load(string fileName, string updatePathVar, string customUrlArgs)
        {
            ServerFile serv = new ServerFile();

            byte[] fileIDBytes = new byte[7];

            Stream fs = null;

            try
            {
                fs = new FileStream(fileName, FileMode.Open, FileAccess.Read);

                // Read the first 7 bytes of identification data
                fs.Read(fileIDBytes, 0, 7);
            }
            catch (Exception)
            {
                if (fs != null)
                {
                    fs.Close();
                }

                throw;
            }

            // check for compression (see if PKZip header is there)
            if (fileIDBytes[0] == 0x50 && fileIDBytes[1] == 0x4B && fileIDBytes[2] == 0x03 && fileIDBytes[3] == 0x04)
            {
                // decompress the "actual" server file to memory
                fs.Close();

                using (ZipFile zip = ZipFile.Read(fileName))
                {
                    fs = new MemoryStream();

                    zip["0"].Extract(fs);
                }


                fs.Position = 0;

                // Read the first 7 bytes of identification data
                fs.Read(fileIDBytes, 0, 7);
            }


            // see if the file is in the correct server format

            string fileID = Encoding.UTF8.GetString(fileIDBytes);

            if (fileID != "IUSDFV2")
            {
                //free up the file so it can be deleted
                fs.Close();
                throw new Exception("The downloaded server file does not have the correct identifier. This is usually caused by file corruption.");
            }



            serv.VersionChoices.Add(new VersionChoice());

            byte bType = (byte)fs.ReadByte();

            while (!ReadFiles.ReachedEndByte(fs, bType, 0xFF))
            {
                switch (bType)
                {
                case 0x01:    //Read New Version
                    serv.NewVersion = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x07:     //Min Client version
                    serv.MinClientVersion = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x0B:     //The version to update from
                    if (serv.VersionChoices.Count > 1 || serv.VersionChoices[0].Version != null)
                    {
                        serv.VersionChoices.Add(new VersionChoice());
                    }

                    serv.VersionChoices[serv.VersionChoices.Count - 1].Version = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x03:    //Add update file site

                    string updateSite = ReadFiles.ReadDeprecatedString(fs);

                    if (updatePathVar != null)
                    {
                        updateSite = updateSite.Replace("%updatepath%", updatePathVar);
                    }

                    updateSite = updateSite.Replace("%urlargs%", customUrlArgs ?? string.Empty);

                    ClientFile.AddUniqueString(updateSite, serv.VersionChoices[serv.VersionChoices.Count - 1].FileSites);

                    break;

                case 0x80:     //the changes text is in RTF format
                    serv.VersionChoices[serv.VersionChoices.Count - 1].RTFChanges = true;
                    break;

                case 0x04:    //Read Changes
                    serv.VersionChoices[serv.VersionChoices.Count - 1].Changes = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x09:    //update's filesize
                    serv.VersionChoices[serv.VersionChoices.Count - 1].FileSize = ReadFiles.ReadLong(fs);
                    break;

                case 0x08:    //update's Adler32 checksum
                    serv.VersionChoices[serv.VersionChoices.Count - 1].Adler32 = ReadFiles.ReadLong(fs);
                    break;

                case 0x14:     // signed SHA1 hash
                    serv.VersionChoices[serv.VersionChoices.Count - 1].SignedSHA1Hash = ReadFiles.ReadByteArray(fs);
                    break;

                case 0x0A:     //Installing to which directories?
                    serv.VersionChoices[serv.VersionChoices.Count - 1].InstallingTo = (InstallingTo)ReadFiles.ReadInt(fs);
                    break;

                case 0x8E:     //the RegChanges (built with wyBuid 2.6.11.4 and below)
                    if (RegChange.ReadFromStream(fs).RegBasekey != RegBasekeys.HKEY_CURRENT_USER)
                    {
                        serv.VersionChoices[serv.VersionChoices.Count - 1].InstallingTo |= InstallingTo.NonCurrentUserReg;
                    }
                    break;

                case 0x20:
                    serv.NoUpdateToLatestLinkText = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x21:
                    serv.NoUpdateToLatestLinkURL = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x0F:
                    //skip over the integer (4 bytes) length
                    //this is just used to trick pre-1.0 Final versions
                    //of wyUpdate to correctly read the server file correctly
                    fs.Position += 4;
                    break;

                default:
                    ReadFiles.SkipField(fs, bType);
                    break;
                }

                bType = (byte)fs.ReadByte();
            }

            fs.Close();

            return(serv);
        }
Beispiel #6
0
        public static RegChange ReadFromStream(Stream fs)
        {
            RegChange regChange = new RegChange();
            bool      flag      = false;
            byte      b         = (byte)fs.ReadByte();

            while (!ReadFiles.ReachedEndByte(fs, b, 158))
            {
                switch (b)
                {
                case 1:
                    regChange.RegOperation = (RegOperations)ReadFiles.ReadInt(fs);
                    break;

                case 2:
                    regChange.RegBasekey = (RegBasekeys)ReadFiles.ReadInt(fs);
                    break;

                case 3:
                    regChange.RegValueKind = (RegistryValueKind)ReadFiles.ReadInt(fs);
                    break;

                case 4:
                    regChange.SubKey = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 5:
                    regChange.ValueName = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 6:
                    if (regChange.RegValueKind != RegistryValueKind.ExpandString && regChange.RegValueKind != RegistryValueKind.String)
                    {
                        regChange.RegValueKind = RegistryValueKind.String;
                    }
                    regChange.ValueData = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 128:
                    flag = true;
                    break;

                case 129:
                    regChange.Is32BitKey = true;
                    break;

                case 7:
                    switch (regChange.RegValueKind)
                    {
                    case RegistryValueKind.Binary:
                        if (flag)
                        {
                            regChange.ValueData = ReadFiles.ReadDeprecatedString(fs);
                        }
                        else
                        {
                            regChange.ValueData = ReadFiles.ReadByteArray(fs);
                        }
                        break;

                    case RegistryValueKind.DWord:
                        regChange.ValueData = ReadFiles.ReadInt(fs);
                        break;

                    case RegistryValueKind.QWord:
                        regChange.ValueData = ReadFiles.ReadLong(fs);
                        break;

                    case RegistryValueKind.String:
                    case RegistryValueKind.ExpandString:
                    case RegistryValueKind.MultiString:
                        regChange.ValueData = ReadFiles.ReadDeprecatedString(fs);
                        break;
                    }
                    break;

                default:
                    ReadFiles.SkipField(fs, b);
                    break;
                }
                b = (byte)fs.ReadByte();
            }
            return(regChange);
        }
Beispiel #7
0
        public static UpdateDetails Load(string fileName)
#endif
        {
            UpdateDetails updtDetails = new UpdateDetails();

            try
            {
#if CLIENT
                using (FileStream fs = new FileStream(fileName, FileMode.Open, FileAccess.Read))
#endif
                {
                    // Read back the file identification data, if any
                    if (!ReadFiles.IsHeaderValid(fs, "IUUDFV2"))
                    {
                        throw new ArgumentException("Incorrect file identifier.");
                    }

                    UpdateFile tempUpdateFile        = new UpdateFile();
                    int        lastStartServiceArgOn = 0;

                    byte bType = (byte)fs.ReadByte();
                    while (!ReadFiles.ReachedEndByte(fs, bType, 0xFF))
                    {
                        switch (bType)
                        {
                        case 0x20:    //num reg changes
                            updtDetails.RegistryModifications = new List <RegChange>(ReadFiles.ReadInt(fs));
                            break;

                        case 0x21:    //num file infos
                            updtDetails.UpdateFiles = new List <UpdateFile>(ReadFiles.ReadInt(fs));
                            break;

                        case 0x8E:
                            updtDetails.RegistryModifications.Add(RegChange.ReadFromStream(fs));
                            break;

                        case 0x30:
                            updtDetails.PreviousCommonDesktopShortcuts.Add(ReadFiles.ReadDeprecatedString(fs));
                            break;

                        case 0x31:
                            updtDetails.PreviousCommonSMenuShortcuts.Add(ReadFiles.ReadDeprecatedString(fs));
                            break;

                        case 0x36:
                            updtDetails.PreviousCUserDesktopShortcuts.Add(ReadFiles.ReadString(fs));
                            break;

                        case 0x37:
                            updtDetails.PreviousCUserSMenuShortcuts.Add(ReadFiles.ReadString(fs));
                            break;

                        case 0x32:     //service to stop
                            updtDetails.ServicesToStop.Add(ReadFiles.ReadString(fs));
                            break;

                        case 0x33:     //service to start
                            updtDetails.ServicesToStart.Add(new StartService(ReadFiles.ReadString(fs)));
                            break;

                        case 0x34:     // number of start arguments for the last service
                            updtDetails.ServicesToStart[updtDetails.ServicesToStart.Count - 1].Arguments =
                                new string[ReadFiles.ReadInt(fs)];
                            lastStartServiceArgOn = 0;
                            break;

                        case 0x35:
                            updtDetails.ServicesToStart[updtDetails.ServicesToStart.Count - 1].Arguments[
                                lastStartServiceArgOn] = ReadFiles.ReadString(fs);
                            lastStartServiceArgOn++;
                            break;

                        case 0x40:
                            tempUpdateFile.RelativePath = ReadFiles.ReadDeprecatedString(fs);
                            break;

                        case 0x41:
                            tempUpdateFile.Execute = ReadFiles.ReadBool(fs);
                            break;

                        case 0x42:
                            tempUpdateFile.ExBeforeUpdate = ReadFiles.ReadBool(fs);
                            break;

                        case 0x43:
                            tempUpdateFile.CommandLineArgs = ReadFiles.ReadDeprecatedString(fs);
                            break;

                        case 0x44:
                            tempUpdateFile.IsNETAssembly = ReadFiles.ReadBool(fs);
                            break;

                        case 0x45:
                            tempUpdateFile.WaitForExecution = ReadFiles.ReadBool(fs);
                            break;

                        case 0x8F:
                            tempUpdateFile.RollbackOnNonZeroRet = true;
                            break;

                        case 0x4D:
                            if (tempUpdateFile.RetExceptions == null)
                            {
                                tempUpdateFile.RetExceptions = new List <int>();
                            }

                            tempUpdateFile.RetExceptions.Add(ReadFiles.ReadInt(fs));
                            break;

                        case 0x46:
                            tempUpdateFile.DeleteFile = ReadFiles.ReadBool(fs);
                            break;

                        case 0x47:
                            tempUpdateFile.DeltaPatchRelativePath = ReadFiles.ReadDeprecatedString(fs);
                            break;

                        case 0x48:
                            tempUpdateFile.NewFileAdler32 = ReadFiles.ReadLong(fs);
                            break;

                        case 0x49:
                            tempUpdateFile.CPUVersion = (CPUVersion)ReadFiles.ReadInt(fs);
                            break;

                        case 0x4A:
                            tempUpdateFile.ProcessWindowStyle = (System.Diagnostics.ProcessWindowStyle)ReadFiles.ReadInt(fs);
                            break;

                        case 0x4E:
                            tempUpdateFile.ElevationType = (ElevationType)ReadFiles.ReadInt(fs);
                            break;

                        case 0x4B:
                            tempUpdateFile.FrameworkVersion = (FrameworkVersion)ReadFiles.ReadInt(fs);
                            break;

                        case 0x4C:
                            tempUpdateFile.RegisterCOMDll = (COMRegistration)ReadFiles.ReadInt(fs);
                            break;

                        case 0x9B:    //end of file
                            updtDetails.UpdateFiles.Add(tempUpdateFile);
                            tempUpdateFile = new UpdateFile();
                            break;

                        case 0x8D:
                            updtDetails.ShortcutInfos.Add(ShortcutInfo.LoadFromStream(fs));
                            break;

                        case 0x60:
                            updtDetails.FoldersToDelete.Add(ReadFiles.ReadDeprecatedString(fs));
                            break;

                        default:
                            ReadFiles.SkipField(fs, bType);
                            break;
                        }

                        bType = (byte)fs.ReadByte();
                    }
                }
            }
            catch (Exception ex)
            {
                throw new Exception("The update details file failed to open.\n\nFull details: " + ex.Message);
            }

            return(updtDetails);
        }
 RegChange ParseRegChange(RegChange reg)
 {
     if (reg.RegValueKind == RegistryValueKind.MultiString ||
         reg.RegValueKind == RegistryValueKind.String)
     {
         reg.ValueData = ParseText((string)reg.ValueData);
     }
     return reg;
 }
Beispiel #9
0
        public static RegChange ReadFromStream(Stream fs)
        {
            RegChange tempReg = new RegChange();

            bool isBinaryString = false;

            byte bType = (byte)fs.ReadByte();

            //read until the end byte is detected
            while (!ReadFiles.ReachedEndByte(fs, bType, 0x9E))
            {
                switch (bType)
                {
                    case 0x01://RegOperation
                        tempReg.RegOperation = (RegOperations)ReadFiles.ReadInt(fs);
                        break;
                    case 0x02://load basekey
                        tempReg.RegBasekey = (RegBasekeys)ReadFiles.ReadInt(fs);
                        break;
                    case 0x03://load valuekind
                        tempReg.RegValueKind = (RegistryValueKind)ReadFiles.ReadInt(fs);
                        break;
                    case 0x04://subkey
                        tempReg.SubKey = ReadFiles.ReadDeprecatedString(fs);
                        break;
                    case 0x05://value name
                        tempReg.ValueName = ReadFiles.ReadDeprecatedString(fs);
                        break;
                    case 0x06: //Depreciated: Use 0x07. All 0x06 will be converted to a string "ValueKind"
                        if (tempReg.RegValueKind != RegistryValueKind.ExpandString
                            && tempReg.RegValueKind != RegistryValueKind.String)
                        {
                            //Read in the entry,if it's
                            tempReg.RegValueKind = RegistryValueKind.String;
                        }

                        tempReg.ValueData = ReadFiles.ReadDeprecatedString(fs);
                        break;
                    case 0x80:
                        isBinaryString = true;
                        break;
                    case 0x81:
                        tempReg.Is32BitKey = true;
                        break;
                    case 0x07: //Value data
                        switch (tempReg.RegValueKind)
                        {
                            case RegistryValueKind.Binary:

                                if (isBinaryString)
                                    tempReg.ValueData = ReadFiles.ReadDeprecatedString(fs);
                                else
                                    tempReg.ValueData = ReadFiles.ReadByteArray(fs);

                                break;
                            case RegistryValueKind.DWord:
                                tempReg.ValueData = ReadFiles.ReadInt(fs);
                                break;
                            case RegistryValueKind.QWord:
                                tempReg.ValueData = ReadFiles.ReadLong(fs);
                                break;
                            case RegistryValueKind.ExpandString:
                            case RegistryValueKind.MultiString:
                            case RegistryValueKind.String:
                                tempReg.ValueData = ReadFiles.ReadDeprecatedString(fs);
                                break;
                        }
                        break;
                    default:
                        ReadFiles.SkipField(fs, bType);
                        break;
                }

                bType = (byte)fs.ReadByte();
            }

            return tempReg;
        }
Beispiel #10
0
        public static RegChange ReadFromStream(Stream fs)
        {
            RegChange tempReg = new RegChange();

            bool isBinaryString = false;

            byte bType = (byte)fs.ReadByte();

            //read until the end byte is detected
            while (!ReadFiles.ReachedEndByte(fs, bType, 0x9E))
            {
                switch (bType)
                {
                case 0x01:    //RegOperation
                    tempReg.RegOperation = (RegOperations)ReadFiles.ReadInt(fs);
                    break;

                case 0x02:    //load basekey
                    tempReg.RegBasekey = (RegBasekeys)ReadFiles.ReadInt(fs);
                    break;

                case 0x03:    //load valuekind
                    tempReg.RegValueKind = (RegistryValueKind)ReadFiles.ReadInt(fs);
                    break;

                case 0x04:    //subkey
                    tempReg.SubKey = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x05:    //value name
                    tempReg.ValueName = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x06:     //Depreciated: Use 0x07. All 0x06 will be converted to a string "ValueKind"
                    if (tempReg.RegValueKind != RegistryValueKind.ExpandString &&
                        tempReg.RegValueKind != RegistryValueKind.String)
                    {
                        //Read in the entry,if it's
                        tempReg.RegValueKind = RegistryValueKind.String;
                    }

                    tempReg.ValueData = ReadFiles.ReadDeprecatedString(fs);
                    break;

                case 0x80:
                    isBinaryString = true;
                    break;

                case 0x81:
                    tempReg.Is32BitKey = true;
                    break;

                case 0x07:     //Value data
                    switch (tempReg.RegValueKind)
                    {
                    case RegistryValueKind.Binary:

                        if (isBinaryString)
                        {
                            tempReg.ValueData = ReadFiles.ReadDeprecatedString(fs);
                        }
                        else
                        {
                            tempReg.ValueData = ReadFiles.ReadByteArray(fs);
                        }

                        break;

                    case RegistryValueKind.DWord:
                        tempReg.ValueData = ReadFiles.ReadInt(fs);
                        break;

                    case RegistryValueKind.QWord:
                        tempReg.ValueData = ReadFiles.ReadLong(fs);
                        break;

                    case RegistryValueKind.ExpandString:
                    case RegistryValueKind.MultiString:
                    case RegistryValueKind.String:
                        tempReg.ValueData = ReadFiles.ReadDeprecatedString(fs);
                        break;
                    }
                    break;

                default:
                    ReadFiles.SkipField(fs, bType);
                    break;
                }

                bType = (byte)fs.ReadByte();
            }

            return(tempReg);
        }