init

Author: extrame

dir.go

@@ -0,0 +1,35 @@
+package ole2
+
+import (
+	"unicode/utf16"
+)
+
+const (
+	EMPTY       = iota
+	USERSTORAGE = iota
+	USERSTREAM  = iota
+	LOCKBYTES   = iota
+	PROPERTY    = iota
+	ROOT        = iota
+)
+
+type File struct {
+	NameBts   [32]uint16
+	Bsize     uint16
+	Type      byte
+	Flag      byte
+	Left      uint32
+	Right     uint32
+	Child     uint32
+	Guid      [8]uint16
+	Userflags uint32
+	Time      [2]uint64
+	Sstart    uint32
+	Size      uint32
+	Proptype  uint32
+}
+
+func (d *File) Name() string {
+	runes := utf16.Decode(d.NameBts[:d.Bsize/2-1])
+	return string(runes)
+}

header.go

@@ -0,0 +1,42 @@
+package ole2
+
+import (
+	"bytes"
+	"encoding/binary"
+	"fmt"
+)
+
+type Header struct {
+	Id        [2]uint32
+	Clid      [4]uint32
+	Verminor  uint16
+	Verdll    uint16
+	Byteorder uint16
+	Lsectorb  uint16
+	Lssectorb uint16
+	_         uint16
+	_         uint64
+
+	Cfat     uint32 //Total number of sectors used for the sector allocation table
+	Dirstart uint32 //SecID of first sector of the directory stream
+
+	_ uint32
+
+	Sectorcutoff uint32 //Minimum size of a standard stream
+	Sfatstart    uint32 //SecID of first sector of the short-sector allocation table
+	Csfat        uint32 //Total number of sectors used for the short-sector allocation table
+	Difstart     uint32 //SecID of first sector of the master sector allocation table
+	Cdif         uint32 //Total number of sectors used for the master sector allocation table
+	Msat         [109]uint32
+}
+
+func parseHeader(bts []byte) (*Header, error) {
+	buf := bytes.NewBuffer(bts)
+	header := new(Header)
+	binary.Read(buf, binary.LittleEndian, header)
+	if header.Id[0] != 0xE011CFD0 || header.Id[1] != 0xE11AB1A1 || header.Byteorder != 0xFFFE {
+		return nil, fmt.Errorf("not an excel file")
+	}
+
+	return header, nil
+}

ole.go

@@ -0,0 +1,129 @@
+package ole2
+
+import (
+	"encoding/binary"
+	"io"
+)
+
+var ENDOFCHAIN = uint32(0xFFFFFFFE) //-2
+var FREESECT = uint32(0xFFFFFFFF)   // -1
+
+type Ole struct {
+	header   *Header
+	Lsector  uint32
+	Lssector uint32
+	SecID    []uint32
+	SSecID   []uint32
+	Files    []File
+	bts      []byte
+}
+
+func Open(bts []byte, charset string) (ole *Ole, err error) {
+	var header *Header
+	if header, err = parseHeader(bts[:512]); err == nil {
+		ole = new(Ole)
+		ole.bts = bts
+		ole.header = header
+		ole.Lsector = 512 //TODO
+		ole.Lssector = 64 //TODO
+		ole.bts = bts
+		ole.readMSAT()
+		return ole, nil
+	}
+
+	return nil, err
+}
+
+func (o *Ole) ListDir() (dir []*File, err error) {
+	sector := o.stream_read(o.header.Dirstart, 0)
+	dir = make([]*File, 0)
+	for {
+		d := new(File)
+		err = binary.Read(sector, binary.LittleEndian, d)
+		if err == nil && d.Type != EMPTY {
+			dir = append(dir, d)
+		} else {
+			break
+		}
+
+	}
+
+	return
+}
+
+func (o *Ole) OpenFile(file *File) io.ReadSeeker {
+	if file.Size < o.header.Sectorcutoff {
+		return o.short_stream_read(file.Sstart, file.Size)
+	} else {
+		return o.stream_read(file.Sstart, file.Size)
+	}
+}
+
+// Read MSAT
+func (o *Ole) readMSAT() {
+	// int sectorNum;
+
+	count := uint32(109)
+	if o.header.Cfat < 109 {
+		count = o.header.Cfat
+	}
+
+	for i := uint32(0); i < count; i++ {
+		sector := o.sector_read(o.header.Msat[i])
+		sids := sector.AllValues(o.Lsector)
+
+		o.SecID = append(o.SecID, sids...)
+	}
+
+	for sid := o.header.Difstart; sid != ENDOFCHAIN; {
+		sector := o.sector_read(sid)
+		sids := sector.MsatValues(o.Lsector)
+
+		for _, sid := range sids {
+			sector := o.sector_read(sid)
+			sids := sector.AllValues(o.Lsector)
+
+			o.SecID = append(o.SecID, sids...)
+		}
+
+		sid = sector.NextSid(o.Lsector)
+	}
+
+	for i := uint32(0); i < o.header.Csfat; i++ {
+		sid := o.header.Sfatstart
+
+		if sid != ENDOFCHAIN {
+			sector := o.sector_read(sid)
+
+			sids := sector.MsatValues(o.Lsector)
+
+			o.SSecID = append(o.SSecID, sids...)
+
+			sid = sector.NextSid(o.Lsector)
+		}
+	}
+
+}
+
+func (o *Ole) stream_read(sid uint32, size uint32) *StreamReader {
+	return &StreamReader{o.SecID, sid, o, sid, 0, o.Lsector, int64(size), 0}
+}
+
+func (o *Ole) short_stream_read(sid uint32, size uint32) *StreamReader {
+	return &StreamReader{o.SSecID, sid, o, sid, 0, o.Lssector, int64(size), 0}
+}
+
+func (o *Ole) sector_read(sid uint32) Sector {
+	pos := o.sector_pos(sid, o.Lsector)
+	bts := o.bts[pos : pos+o.Lsector]
+	return Sector(bts)
+}
+
+func (o *Ole) short_sector_read(sid uint32) Sector {
+	pos := o.sector_pos(sid, o.Lssector)
+	return Sector(o.bts[pos : pos+o.Lssector])
+}
+
+func (o *Ole) sector_pos(sid uint32, size uint32) uint32 {
+	return 512 + sid*size
+}

pss.go

@@ -0,0 +1,19 @@
+package ole2
+
+import ()
+
+type PSS struct {
+	name      [64]byte
+	bsize     uint16
+	typ       byte
+	flag      byte
+	left      uint32
+	right     uint32
+	child     uint32
+	guid      [16]uint16
+	userflags uint32
+	time      [2]uint64
+	sstart    uint32
+	size      uint32
+	_         uint32
+}

sector.go

@@ -0,0 +1,37 @@
+package ole2
+
+import (
+	"bytes"
+	"encoding/binary"
+)
+
+type Sector []byte
+
+func (s *Sector) Uint32(bit uint32) uint32 {
+	return binary.LittleEndian.Uint32((*s)[bit : bit+4])
+}
+
+func (s *Sector) NextSid(size uint32) uint32 {
+	return s.Uint32(size - 4)
+}
+
+func (s *Sector) MsatValues(size uint32) []uint32 {
+
+	return s.values(size, int(size/4-1))
+}
+
+func (s *Sector) AllValues(size uint32) []uint32 {
+
+	return s.values(size, int(size/4))
+}
+
+func (s *Sector) values(size uint32, length int) []uint32 {
+
+	var res = make([]uint32, length)
+
+	buf := bytes.NewBuffer((*s))
+
+	binary.Read(buf, binary.LittleEndian, res)
+
+	return res
+}

stream.go

@@ -0,0 +1,13 @@
+package ole2
+
+type Stream struct {
+	Ole     *Ole
+	Start   uint32
+	Pos     uint32
+	Cfat    int
+	Size    int
+	Fatpos  uint32
+	Bufsize uint32
+	Eof     byte
+	Sfat    bool
+}

stream_reader.go

@@ -0,0 +1,80 @@
+package ole2
+
+import (
+	"io"
+	"log"
+)
+
+var DEBUG = false
+
+type StreamReader struct {
+	sat              []uint32
+	start            uint32
+	ole              *Ole
+	offset_of_sector uint32
+	offset_in_sector uint32
+	size_sector      uint32
+	size             int64
+	offset           int64
+}
+
+func (r *StreamReader) Read(p []byte) (n int, err error) {
+	if r.offset_of_sector == ENDOFCHAIN {
+		return 0, io.EOF
+	}
+	for i := 0; i < len(p); i++ {
+		if r.offset_in_sector >= r.size_sector {
+			r.offset_in_sector = 0
+			r.offset_of_sector = r.sat[r.offset_of_sector]
+			if r.offset_of_sector == ENDOFCHAIN {
+				return i, io.EOF
+			}
+		}
+		pos := r.ole.sector_pos(r.offset_of_sector, r.size_sector) + r.offset_in_sector
+		p[i] = r.ole.bts[pos]
+		if DEBUG {
+			log.Printf("pos:%x,bit:%x", pos, p[i])
+		}
+		r.offset_in_sector++
+		r.offset++
+		if r.offset == int64(r.size) {
+			return i + 1, io.EOF
+		}
+	}
+	return len(p), nil
+}
+
+func (r *StreamReader) Seek(offset int64, whence int) (offset_result int64, err error) {
+
+	if whence == 0 {
+		r.offset_of_sector = r.start
+		r.offset_in_sector = 0
+		r.offset = offset
+	} else {
+		r.offset += offset
+	}
+
+	if r.offset_of_sector == ENDOFCHAIN {
+		return r.offset, io.EOF
+	}
+
+	for offset >= int64(r.size_sector-r.offset_in_sector) {
+		r.offset_of_sector = r.sat[r.offset_of_sector]
+		offset -= int64(r.size_sector - r.offset_in_sector)
+		r.offset_in_sector = 0
+		if r.offset_of_sector == ENDOFCHAIN {
+			err = io.EOF
+			goto return_res
+		}
+	}
+
+	if r.size <= r.offset {
+		err = io.EOF
+		r.offset = r.size
+	} else {
+		r.offset_in_sector += uint32(offset)
+	}
+return_res:
+	offset_result = r.offset
+	return
+}