Beispiel #1
0
        // u2  cbCFHeader;  /* (optional) size of per-cabinet reserved area */
        // u1  cbCFFolder;  /* (optional) size of per-folder reserved area */
        // u1  cbCFData;    /* (optional) size of per-datablock reserved area */
        // u1  abReserve[];	/* (optional) per-cabinet reserved area */
        // u1  szCabinetPrev[];	/* (optional) name of previous cabinet file */
        // u1  szDiskPrev[];	/* (optional) name of previous disk */
        // u1  szCabinetNext[];	/* (optional) name of next cabinet file */
        // u1  szDiskNext[];	/* (optional) name of next disk */

        public static CFHEADER_OPTIONAL FromStream(FileStream stream, CFHEADER_FLAGS fixedHeaderFlags)
        {
            CFHEADER_OPTIONAL optionalHeader = new CFHEADER_OPTIONAL();
            BinaryReader      reader         = new BinaryReader(stream);

            // TODO: bounds checking
            if ((fixedHeaderFlags & CFHEADER_FLAGS.RESERVE_PRESENT) == CFHEADER_FLAGS.RESERVE_PRESENT)
            {
                // cbCFHeader present
                optionalHeader.cbCFHeader = reader.ReadUInt16();

                // cbCFFolder present
                optionalHeader.cbCFFolder = reader.ReadByte();


                // cbCFData present
                optionalHeader.cbCFData = reader.ReadByte();

                // abReserve present
                optionalHeader.abReserve = reader.ReadBytes(optionalHeader.cbCFHeader);
            }
            else
            {
                // cbCFHeader not present
                optionalHeader.cbCFHeader = 0;

                // cbCFFolder not present
                optionalHeader.cbCFFolder = 0;

                // cbCFData not present
                optionalHeader.cbCFData = 0;

                // abReserve not present
                optionalHeader.abReserve = null;
            }

            if ((fixedHeaderFlags & CFHEADER_FLAGS.PREV_CABINET) == CFHEADER_FLAGS.PREV_CABINET)
            {
                // not needed for CE cabs so skip for now
                throw new NotSupportedException("CFHEADER_FLAGS.PREV_CABINET FLAG NOT SUPPORTED");
            }
            else
            {
                optionalHeader.szCabinetPrev = null;
                optionalHeader.szDiskPrev    = null;
                optionalHeader.szCabinetNext = null;
                optionalHeader.szDiskNext    = null;
            }

            if ((fixedHeaderFlags & CFHEADER_FLAGS.NEXT_CABINET) == CFHEADER_FLAGS.NEXT_CABINET)
            {
                // not needed for CE cabs so skip for now
                throw new NotSupportedException("CFHEADER_FLAGS.NEXT_CABINET FLAG NOT SUPPORTED");
            }

            // move to next DWORD boundary (struct alignment)
            // stream.Seek((4 - (stream.Position % 4)), SeekOrigin.Current);

            return(optionalHeader);
        }
        CFHEADER_FIXED(
            uint signature,
            uint reserved1,
            uint cbCabinet,
            uint reserved2,
            uint coffFiles,
            uint reserved3,
            byte versionMinor,
            byte versionMajor,
            ushort cFolders,
            ushort cFiles,
            CFHEADER_FLAGS flags,
            ushort setID,
            ushort iCabinet)
        {
            this.signature            = this.reserved1 = this.cbCabinet =
                this.reserved2        = this.coffFiles = this.reserved3 =
                    this.cFolders     = this.cFiles = this.setID =
                        this.iCabinet = this.versionMinor = this.versionMajor = 0;

            this.flags = CFHEADER_FLAGS.None;
        }