예제 #1
0
        private void Dispose(bool disposing)
        {
            // Check to see if Dispose has already been called.
            if (!this.disposed)
            {
                if (disposing)
                {
                    if (m_workbookData != null)
                    {
                        m_workbookData.Dispose();
                    }

                    if (m_sheets != null)
                    {
                        m_sheets.Clear();
                    }
                }

                m_workbookData = null;
                m_sheets       = null;
                m_stream       = null;
                m_globals      = null;
                m_encoding     = null;
                m_hdr          = null;

                disposed = true;
            }
        }
 public XlsBiffStream(XlsHeader hdr, uint streamStart, bool isMini, XlsRootDirectory rootDir)
     : base(hdr, streamStart, isMini, rootDir)
 {
     bytes    = base.ReadStream();
     m_size   = bytes.Length;
     m_offset = 0;
 }
 /// <summary>
 /// Constructor
 /// </summary>
 /// <param name="bytes">byte array representing current object</param>
 /// <param name="header"></param>
 public XlsDirectoryEntry(byte[] bytes, XlsHeader header)
 {
     if (bytes.Length < Length)
     {
         throw new BiffRecordException(Errors.ErrorDirectoryEntryArray);
     }
     m_bytes  = bytes;
     m_header = header;
 }
예제 #4
0
 public XlsStream(XlsHeader hdr, uint startSector, bool isMini, XlsRootDirectory rootDir)
 {
     m_fileStream  = hdr.FileStream;
     m_fat         = hdr.FAT;
     m_hdr         = hdr;
     m_startSector = startSector;
     m_isMini      = isMini;
     m_rootDir     = rootDir;
     CalculateMiniFat(rootDir);
 }
예제 #5
0
        private void fail(string message)
        {
            m_exceptionMessage = message;
            m_isValid          = false;

            m_file.Close();
            m_isClosed = true;

            m_workbookData = null;
            m_sheets       = null;
            m_stream       = null;
            m_globals      = null;
            m_encoding     = null;
            m_hdr          = null;
        }
예제 #6
0
        /// <summary>
        /// Constructs FAT table from list of sectors
        /// </summary>
        /// <param name="hdr">XlsHeader</param>
        /// <param name="sectors">Sectors list</param>
        /// <param name="sizeOfSector"></param>
        /// <param name="isMini"></param>
        /// <param name="rootDir"></param>
        public XlsFat(XlsHeader hdr, List <uint> sectors, int sizeOfSector, bool isMini, XlsRootDirectory rootDir)
        {
            m_isMini          = isMini;
            m_rootDir         = rootDir;
            m_hdr             = hdr;
            m_sectors_for_fat = sectors.Count;
            sizeOfSector      = hdr.SectorSize;
            uint sector = 0, prevSector = 0;

            //calc offset of stream . If mini stream then find mini stream container stream
            //long offset = 0;
            //if (rootDir != null)
            //	offset = isMini ? (hdr.MiniFatFirstSector + 1) * hdr.SectorSize : 0;

            byte[] buff = new byte[sizeOfSector];
            Stream file = hdr.FileStream;

            using (MemoryStream ms = new MemoryStream(sizeOfSector * m_sectors_for_fat))
            {
                lock (file)
                {
                    for (int i = 0; i < sectors.Count; i++)
                    {
                        sector = sectors[i];
                        if (prevSector == 0 || (sector - prevSector) != 1)
                        {
                            file.Seek((sector + 1) * sizeOfSector, SeekOrigin.Begin);
                        }
                        prevSector = sector;
                        file.Read(buff, 0, sizeOfSector);
                        ms.Write(buff, 0, sizeOfSector);
                    }
                }
                ms.Seek(0, SeekOrigin.Begin);
                BinaryReader rd = new BinaryReader(ms);
                m_sectors = (int)ms.Length / 4;
                m_fat     = new List <uint>(m_sectors);
                for (int i = 0; i < m_sectors; i++)
                {
                    m_fat.Add(rd.ReadUInt32());
                }
                rd.Close();
                ms.Close();
            }
        }
예제 #7
0
        /// <summary>
        /// Reads Excel header from Stream
        /// </summary>
        /// <param name="file">Stream with Excel file</param>
        /// <returns>XlsHeader representing specified file</returns>
        public static XlsHeader ReadHeader(Stream file)
        {
            XlsHeader hdr = new XlsHeader(file);

            lock (file)
            {
                file.Seek(0, SeekOrigin.Begin);
                file.Read(hdr.m_bytes, 0, 512);
            }
            if (!hdr.IsSignatureValid)
            {
                throw new HeaderException(Errors.ErrorHeaderSignature);
            }
            if (hdr.ByteOrder != 0xFFFE)
            {
                throw new FormatException(Errors.ErrorHeaderOrder);
            }
            return(hdr);
        }
        /// <summary>
        /// Creates Root Directory catalog from XlsHeader
        /// </summary>
        /// <param name="hdr">XlsHeader object</param>
        public XlsRootDirectory(XlsHeader hdr)
        {
            XlsStream stream = new XlsStream(hdr, hdr.RootDirectoryEntryStart, false, null);

            byte[]                   array = stream.ReadStream();
            byte[]                   tmp;
            XlsDirectoryEntry        entry;
            List <XlsDirectoryEntry> entries = new List <XlsDirectoryEntry>();

            for (int i = 0; i < array.Length; i += XlsDirectoryEntry.Length)
            {
                tmp = new byte[XlsDirectoryEntry.Length];
                Buffer.BlockCopy(array, i, tmp, 0, tmp.Length);
                entries.Add(new XlsDirectoryEntry(tmp, hdr));
            }
            m_entries = entries;
            for (int i = 0; i < entries.Count; i++)
            {
                entry = entries[i];
                if (m_root == null && entry.EntryType == STGTY.STGTY_ROOT)
                {
                    m_root = entry;
                }
                if (entry.ChildSid != (uint)FATMARKERS.FAT_FreeSpace)
                {
                    entry.Child = entries[(int)entry.ChildSid];
                }
                if (entry.LeftSiblingSid != (uint)FATMARKERS.FAT_FreeSpace)
                {
                    entry.LeftSibling = entries[(int)entry.LeftSiblingSid];
                }
                if (entry.RightSiblingSid != (uint)FATMARKERS.FAT_FreeSpace)
                {
                    entry.RightSibling = entries[(int)entry.RightSiblingSid];
                }
            }
            stream.CalculateMiniFat(this);
        }
예제 #9
0
        private void readWorkBookGlobals()
        {
            //Read Header
            try
            {
                m_hdr = XlsHeader.ReadHeader(m_file);
            }
            catch (HeaderException ex)
            {
                fail(ex.Message);
                return;
            }
            catch (FormatException ex)
            {
                fail(ex.Message);
                return;
            }

            XlsRootDirectory  dir           = new XlsRootDirectory(m_hdr);
            XlsDirectoryEntry workbookEntry = dir.FindEntry(WORKBOOK) ?? dir.FindEntry(BOOK);

            if (workbookEntry == null)
            {
                fail(Errors.ErrorStreamWorkbookNotFound); return;
            }

            if (workbookEntry.EntryType != STGTY.STGTY_STREAM)
            {
                fail(Errors.ErrorWorkbookIsNotStream); return;
            }

            m_stream = new XlsBiffStream(m_hdr, workbookEntry.StreamFirstSector, workbookEntry.IsEntryMiniStream, dir);

            m_globals = new XlsWorkbookGlobals();

            m_stream.Seek(0, SeekOrigin.Begin);

            XlsBiffRecord rec = m_stream.Read();
            XlsBiffBOF    bof = rec as XlsBiffBOF;

            if (bof == null || bof.Type != BIFFTYPE.WorkbookGlobals)
            {
                fail(Errors.ErrorWorkbookGlobalsInvalidData); return;
            }

            bool sst = false;

            m_version = bof.Version;
            m_sheets  = new List <XlsWorksheet>();

            while (null != (rec = m_stream.Read()))
            {
                switch (rec.ID)
                {
                case BIFFRECORDTYPE.INTERFACEHDR:
                    m_globals.InterfaceHdr = (XlsBiffInterfaceHdr)rec;
                    break;

                case BIFFRECORDTYPE.BOUNDSHEET:
                    XlsBiffBoundSheet sheet = (XlsBiffBoundSheet)rec;

                    if (sheet.Type != XlsBiffBoundSheet.SheetType.Worksheet)
                    {
                        break;
                    }

                    sheet.IsV8        = isV8();
                    sheet.UseEncoding = m_encoding;

                    m_sheets.Add(new XlsWorksheet(m_globals.Sheets.Count, sheet));
                    m_globals.Sheets.Add(sheet);

                    break;

                case BIFFRECORDTYPE.MMS:
                    m_globals.MMS = rec;
                    break;

                case BIFFRECORDTYPE.COUNTRY:
                    m_globals.Country = rec;
                    break;

                case BIFFRECORDTYPE.CODEPAGE:

                    m_globals.CodePage = (XlsBiffSimpleValueRecord)rec;

                    try
                    {
                        m_encoding = Encoding.GetEncoding(m_globals.CodePage.Value);
                    }
                    catch (ArgumentException)
                    {
                        // Warning - Password protection
                    }

                    break;

                case BIFFRECORDTYPE.FONT:
                case BIFFRECORDTYPE.FONT_V34:
                    m_globals.Fonts.Add(rec);
                    break;

                case BIFFRECORDTYPE.FORMAT_V23:
                {
                    var fmt = (XlsBiffFormatString)rec;
                    fmt.UseEncoding = m_encoding;
                    m_globals.Formats.Add((ushort)m_globals.Formats.Count, fmt);
                }
                break;

                case BIFFRECORDTYPE.FORMAT:
                {
                    var fmt = (XlsBiffFormatString)rec;
                    m_globals.Formats.Add(fmt.Index, fmt);
                }
                break;

                case BIFFRECORDTYPE.XF:
                case BIFFRECORDTYPE.XF_V4:
                case BIFFRECORDTYPE.XF_V3:
                case BIFFRECORDTYPE.XF_V2:
                    m_globals.ExtendedFormats.Add(rec);
                    break;

                case BIFFRECORDTYPE.SST:
                    m_globals.SST = (XlsBiffSST)rec;
                    sst           = true;
                    break;

                case BIFFRECORDTYPE.CONTINUE:
                    if (!sst)
                    {
                        break;
                    }
                    XlsBiffContinue contSST = (XlsBiffContinue)rec;
                    m_globals.SST.Append(contSST);
                    break;

                case BIFFRECORDTYPE.EXTSST:
                    m_globals.ExtSST = rec;
                    sst = false;
                    break;

                case BIFFRECORDTYPE.PROTECT:
                case BIFFRECORDTYPE.PASSWORD:
                case BIFFRECORDTYPE.PROT4REVPASSWORD:
                    //IsProtected
                    break;

                case BIFFRECORDTYPE.EOF:
                    if (m_globals.SST != null)
                    {
                        m_globals.SST.ReadStrings();
                    }
                    return;

                default:
                    continue;
                }
            }
        }