func compile(source io.ReadSeeker, targetname string) os.Error {
O, err := getArchSym()
if err != nil {
return err
}
gc := O + "g"
gl := O + "l"
tempobj := path.Join(os.TempDir(), targetname+"."+O)
_, err = source.Seek(0, 0)
if err != nil {
return err
}
bufsource := bufio.NewReader(source)
var insource io.Reader = bufsource
if line, err := bufsource.ReadString('\n'); err != nil && err != os.EOF ||
len(line) < 2 || line[:2] != "#!" {
_, err := source.Seek(0, 0)
if err != nil {
return err
}
insource = source
}
err = run(gc, []string{gc, "-o", tempobj, "/dev/stdin"}, insource)
if err != nil {
return err
}
err = run(gl, []string{gl, "-o", path.Join(storedir, targetname),
tempobj},
nil)
return err
}
func NewFS(r io.ReadSeeker) *FS {
bpb32 := &BPB32{}
err := binary.Read(r, binary.LittleEndian, bpb32)
if err != nil {
// TODO error handling
}
fs := &FS{bpb32, UnknownType, r}
t := fs.DetermineType()
switch t {
case FAT32:
fs.Type = FAT32
return fs
case FAT12, FAT16:
// reread the BPB, this time for the correct fs type
bpb16 := &BPB16{}
r.Seek(0, 0)
err := binary.Read(r, binary.LittleEndian, bpb16)
if err != nil {
// TODO error handling
}
bpb32 = &BPB32{bpb16.BPBBase, BPB32Base{0, 0, 0, 0, 0, 0, [12]byte{}}, bpb16.BPB16Base}
fs = &FS{bpb32, t, r}
}
return fs
}
func (t *TarInfo) Load(file io.ReadSeeker) {
var reader *tar.Reader
file.Seek(0, 0)
gzipReader, err := gzip.NewReader(file)
if err != nil {
// likely not a gzip compressed file
file.Seek(0, 0)
reader = tar.NewReader(file)
} else {
reader = tar.NewReader(gzipReader)
}
for {
header, err := reader.Next()
if err == io.EOF {
// end of tar file
break
} else if err != nil {
// error occured
logger.Debug("[TarInfoLoad] Error when reading tar stream tarsum. Disabling TarSum, TarFilesInfo. Error: %s", err.Error())
t.Error = TarError(err.Error())
return
}
t.TarSum.Append(header, reader)
t.TarFilesInfo.Append(header)
}
}
func ReadLine(file io.ReadSeeker) (string, error) {
localBuffer := make([]byte, 0)
offset, err := file.Seek(0, 1)
if err != nil {
return "", err
}
if lastOffset != offset {
nextIndex = bufferSize
}
for {
newChar, err := getNext(file)
if err != nil {
return "", err
}
localBuffer = append(localBuffer, newChar)
if newChar == '\n' {
offset += len(localBuffer)
lastOffset = offset
_, err = file.Seek(offset, 0)
if err != nil {
return "", err
}
return string(localBuffer), nil
}
}
}
func (p *putter) retryRequest(method, urlStr string, body io.ReadSeeker, h http.Header) (resp *http.Response, err error) {
for i := 0; i < p.c.NTry; i++ {
var req *http.Request
req, err = http.NewRequest(method, urlStr, body)
if err != nil {
return
}
for k := range h {
for _, v := range h[k] {
req.Header.Add(k, v)
}
}
p.b.Sign(req)
resp, err = p.c.Client.Do(req)
if err == nil {
return
}
logger.debugPrintln(err)
if body != nil {
if _, err = body.Seek(0, 0); err != nil {
return
}
}
}
return
}
func (table *hheaTable) init(file io.ReadSeeker, entry *tableDirEntry) (err error) {
if _, err = file.Seek(int64(entry.offset), os.SEEK_SET); err != nil {
return
}
// No advantage to using a buffered reader here.
if err = table.version.Read(file); err != nil {
return
}
err = readValues(file,
&table.ascent,
&table.descent,
&table.lineGap,
&table.advanceWidthMax,
&table.minLeftSideBearing,
&table.minRightSideBearing,
&table.xMaxExtent,
&table.caretSlopeRise,
&table.caretSlopeRun,
&table.caretOffset,
&table.reserved1,
&table.reserved2,
&table.reserved3,
&table.reserved4,
&table.metricDataFormat,
&table.numOfLongHorMetrics,
)
return
}
func ChooseCompressAlgo(path string, rs io.ReadSeeker) (AlgorithmType, error) {
buf := make([]byte, Threshold)
bytesRead, err := rs.Read(buf)
if err != nil {
return AlgoNone, err
}
if _, errSeek := rs.Seek(0, os.SEEK_SET); err != nil {
return AlgoNone, errSeek
}
mime := guessMime(path, buf)
compressAble := isCompressable(mime)
if !compressAble || int64(bytesRead) != Threshold {
return AlgoNone, nil
}
if strings.HasPrefix(mime, "text/") {
return AlgoLZ4, nil
} else {
return AlgoSnappy, nil
}
}
func checkSignature(ks *Keystore, prefix string, signed, signature io.ReadSeeker) (*openpgp.Entity, error) {
acidentifier, err := types.NewACIdentifier(prefix)
if err != nil {
return nil, err
}
keyring, err := ks.loadKeyring(acidentifier.String())
if err != nil {
return nil, fmt.Errorf("keystore: error loading keyring %v", err)
}
entities, err := openpgp.CheckArmoredDetachedSignature(keyring, signed, signature)
if err == io.EOF {
// When the signature is binary instead of armored, the error is io.EOF.
// Let's try with binary signatures as well
if _, err := signed.Seek(0, 0); err != nil {
return nil, fmt.Errorf("error seeking ACI file: %v", err)
}
if _, err := signature.Seek(0, 0); err != nil {
return nil, fmt.Errorf("error seeking signature file: %v", err)
}
entities, err = openpgp.CheckDetachedSignature(keyring, signed, signature)
}
if err == io.EOF {
// otherwise, the client failure is just "EOF", which is not helpful
return nil, fmt.Errorf("keystore: no valid signatures found in signature file")
}
return entities, err
}
func (f *nameFetcher) validate(app *discovery.App, aciFile, ascFile io.ReadSeeker) error {
v, err := newValidator(aciFile)
if err != nil {
return err
}
if err := v.ValidateName(app.Name.String()); err != nil {
return err
}
if err := v.ValidateLabels(app.Labels); err != nil {
return err
}
entity, err := v.ValidateWithSignature(f.Ks, ascFile)
if err != nil {
return err
}
if _, err := aciFile.Seek(0, 0); err != nil {
return errwrap.Wrap(errors.New("error seeking ACI file"), err)
}
printIdentities(entity)
return nil
}
// Skips both the ID3V2 tags and optional VBR headers
func getFirstRealFrameOffset(src io.ReadSeeker) (int64, error) {
var hdr FrameHeader
var xing XingHeader
off, err := getFirstFrameOffset(src)
if err != nil {
return 0, err
}
_, err = src.Seek(off, 0)
if err != nil {
return 0, err
}
bs := make([]byte, 8192)
_, err = io.ReadAtLeast(src, bs, 4)
if err != nil {
return 0, err
}
err = hdr.Parse(bs)
if err != nil {
return 0, err
}
if xing.Parse(bs[:int(hdr.Size)]) {
return off + hdr.Size, nil
}
return off, nil
}
// tail returns the start of last nth line.
// * If n < 0, return the beginning of the file.
// * If n >= 0, return the beginning of last nth line.
// Notice that if the last line is incomplete (no end-of-line), it will not be counted
// as one line.
func tail(f io.ReadSeeker, n int64) (int64, error) {
if n < 0 {
return 0, nil
}
size, err := f.Seek(0, os.SEEK_END)
if err != nil {
return 0, err
}
var left, cnt int64
buf := make([]byte, blockSize)
for right := size; right > 0 && cnt <= n; right -= blockSize {
left = right - blockSize
if left < 0 {
left = 0
buf = make([]byte, right)
}
if _, err := f.Seek(left, os.SEEK_SET); err != nil {
return 0, err
}
if _, err := f.Read(buf); err != nil {
return 0, err
}
cnt += int64(bytes.Count(buf, eol))
}
for ; cnt > n; cnt-- {
idx := bytes.Index(buf, eol) + 1
buf = buf[idx:]
left += int64(idx)
}
return left, nil
}
func NewMp4Media(reader io.ReadSeeker) (fd *Mp4Media, err error) {
fd = &Mp4Media{}
h := next_box_header(reader)
ftyp := next_box_body(reader, h).to_ftyp()
fd.brand = string(ftyp.major_brand[:])
log.Println(h.box_type(), ftyp.major_brand)
L:
for {
h = next_box_header(reader)
if h.size == 0 {
break
}
switch string(h.typ[:]) {
default:
reader.Seek(int64(h.body_size), 1)
case "moov":
// mo, _ := reader.Seek(0, 1)
// fd.moov_offset = mo - (h.size - h.body_size)
fd.moov_body_length = h.body_size
fd.from_moov(next_box_body(reader, h))
break L
case "mdat":
// mo, _ := reader.Seek(0, 1)
// fd.mdat_offset = mo - (h.size - h.body_size)
fd.mdat_body_length = h.body_size
reader.Seek(int64(h.body_size), 1)
}
}
return
}
func (table *headTable) init(file io.ReadSeeker, entry *tableDirEntry) (err error) {
if _, err = file.Seek(int64(entry.offset), os.SEEK_SET); err != nil {
return
}
// No advantage to using a buffered reader here.
if err = table.version.Read(file); err != nil {
return
}
if err = table.fontRevision.Read(file); err != nil {
return
}
err = readValues(file,
&table.checkSumAdjustment,
&table.magicNumber,
&table.flags,
&table.unitsPerEm,
&table.created,
&table.modified,
&table.xMin,
&table.yMin,
&table.xMax,
&table.yMax,
&table.macStyle,
&table.lowestRecPPEM,
&table.fontDirectionHint,
&table.indexToLocFormat,
&table.glyphDataFormat,
)
return
}
// dumpChunk extracts a compressed chunk from the given reader and
// dumps its NBT tag contents.
func dumpChunk(w io.Writer, r io.ReadSeeker, offset int64) error {
address := offset*sectorSize + 4
_, err := r.Seek(address, 0)
if err != nil {
return err
}
var scheme [1]byte
_, err = io.ReadFull(r, scheme[:])
if err != nil {
return err
}
var rr io.ReadCloser
switch scheme[0] {
case 1:
rr, err = gzip.NewReader(r)
case 2:
rr, err = zlib.NewReader(r)
default:
return fmt.Errorf("chunk(%d); invalid compression scheme: %d", offset, scheme[0])
}
if err != nil {
return err
}
err = dump(w, rr)
rr.Close()
return err
}
func newOffsetReader(buf io.ReadSeeker, offset int64) *offsetReader {
reader := &offsetReader{}
buf.Seek(offset, 0)
reader.buf = buf
return reader
}
func blobDetails(contents io.ReadSeeker) (bref blob.Ref, size uint32, err error) {
s1 := sha1.New()
if _, err = contents.Seek(0, 0); err != nil {
return
}
defer func() {
if _, seekErr := contents.Seek(0, 0); seekErr != nil {
if err == nil {
err = seekErr
} else {
err = fmt.Errorf("%s, cannot seek back: %v", err, seekErr)
}
}
}()
sz, err := io.CopyN(s1, contents, constants.MaxBlobSize+1)
if err == nil || err == io.EOF {
bref, err = blob.RefFromHash(s1), nil
} else {
err = fmt.Errorf("error reading contents: %v", err)
return
}
if sz > constants.MaxBlobSize {
err = fmt.Errorf("blob size cannot be bigger than %d", constants.MaxBlobSize)
}
size = uint32(sz)
return
}
// Read GPT partition
// Have to set to first byte of GPT Header (usually start of second sector on disk)
func ReadTable(reader io.ReadSeeker, SectorSize uint64) (table Table, err error) {
table.SectorSize = SectorSize
table.Header, err = readHeader(reader, SectorSize)
if err != nil {
return
}
if seekDest, ok := mul(int64(SectorSize), int64(table.Header.PartitionsTableStartLBA)); ok {
reader.Seek(seekDest, 0)
} else {
err = fmt.Errorf("Seek overflow when read partition tables")
return
}
for i := uint32(0); i < table.Header.PartitionsArrLen; i++ {
var p Partition
p, err = readPartition(reader, table.Header.PartitionEntrySize)
if err != nil {
return
}
table.Partitions = append(table.Partitions, p)
}
if table.Header.PartitionsCRC != table.calcPartitionsCRC() {
err = fmt.Errorf("Bad partitions crc")
return
}
return
}
// Parses a new tag
func ParseTag(readSeeker io.ReadSeeker) *Tag {
header := ParseHeader(readSeeker)
if header == nil {
return nil
}
t := NewTag(header.version)
t.Header = header
var frame Framer
size := int(t.size)
for size > 0 {
frame = t.frameConstructor(readSeeker)
if frame == nil {
break
}
id := frame.Id()
t.frames[id] = append(t.frames[id], frame)
frame.setOwner(t)
size -= t.frameHeaderSize + int(frame.Size())
}
t.padding = uint(size)
if _, err := readSeeker.Seek(int64(HeaderSize+t.Size()), os.SEEK_SET); err != nil {
return nil
}
return t
}
func readStringTable(fh *FileHeader, r io.ReadSeeker) (StringTable, error) {
// COFF string table is located right after COFF symbol table.
if fh.PointerToSymbolTable <= 0 {
return nil, nil
}
offset := fh.PointerToSymbolTable + COFFSymbolSize*fh.NumberOfSymbols
_, err := r.Seek(int64(offset), seekStart)
if err != nil {
return nil, fmt.Errorf("fail to seek to string table: %v", err)
}
var l uint32
err = binary.Read(r, binary.LittleEndian, &l)
if err != nil {
return nil, fmt.Errorf("fail to read string table length: %v", err)
}
// string table length includes itself
if l <= 4 {
return nil, nil
}
l -= 4
buf := make([]byte, l)
_, err = io.ReadFull(r, buf)
if err != nil {
return nil, fmt.Errorf("fail to read string table: %v", err)
}
return StringTable(buf), nil
}
func (gateway Gateway) NewRequest(method, path, accessToken string, body io.ReadSeeker) (req *Request, apiErr error) {
if body != nil {
body.Seek(0, 0)
}
request, err := http.NewRequest(method, path, body)
if err != nil {
apiErr = errors.NewWithError("Error building request", err)
return
}
if accessToken != "" {
request.Header.Set("Authorization", accessToken)
}
request.Header.Set("accept", "application/json")
request.Header.Set("content-type", "application/json")
request.Header.Set("User-Agent", "go-cli "+cf.Version+" / "+runtime.GOOS)
if body != nil {
switch v := body.(type) {
case *os.File:
fileStats, err := v.Stat()
if err != nil {
break
}
request.ContentLength = fileStats.Size()
}
}
req = &Request{HttpReq: request, SeekableBody: body}
return
}
func (g *getter) retryRequest(method, urlStr string, body io.ReadSeeker) (resp *http.Response, err error) {
for i := 0; i < g.c.NTry; i++ {
time.Sleep(time.Duration(math.Exp2(float64(i))) * 100 * time.Millisecond) // exponential back-off
var req *http.Request
req, err = http.NewRequest(method, urlStr, body)
if err != nil {
logger.debugPrintf("NewRequest error on attempt %d: retrying url: %s, error: %s", i, urlStr, err)
return
}
g.b.Sign(req)
resp, err = g.c.Client.Do(req)
// This is a completely successful request. We check for non error, non nil respond and OK status code.
// return without retrying.
if err == nil && resp != nil && resp.StatusCode == 200 {
return
}
logger.debugPrintf("Client error on attempt %d: retrying url: %s, error: %s", i, urlStr, err)
if body != nil {
if _, err = body.Seek(0, 0); err != nil {
logger.debugPrintf("retryRequest body ERROR", errgo.Mask(err))
return
}
}
}
return
}
func decodeSample(r io.ReadSeeker) (Sample, error) {
format, length, err := uint32(0), uint32(0), error(nil)
err = binary.Read(r, binary.BigEndian, &format)
if err != nil {
return nil, err
}
err = binary.Read(r, binary.BigEndian, &length)
if err != nil {
return nil, err
}
switch format {
case TypeCounterSample:
return decodeCounterSample(r)
case TypeFlowSample:
return decodeFlowSample(r)
default:
_, err = r.Seek(int64(length), 1)
if err != nil {
return nil, err
}
return nil, ErrUnknownSampleType
}
}
func (r *multiReadSeeker) Read(b []byte) (int, error) {
if r.pos == nil {
r.pos = &pos{0, 0}
}
bCap := int64(cap(b))
buf := bytes.NewBuffer(nil)
var rdr io.ReadSeeker
for _, rdr = range r.readers[r.pos.idx:] {
readBytes, err := io.CopyN(buf, rdr, bCap)
if err != nil && err != io.EOF {
return -1, err
}
bCap -= readBytes
if bCap == 0 {
break
}
}
rdrPos, err := rdr.Seek(0, os.SEEK_CUR)
if err != nil {
return -1, err
}
r.pos = &pos{r.posIdx[rdr], rdrPos}
return buf.Read(b)
}
//Reads fieldinfo from DBF header, starting at pos 32.
//Reads fields until it finds the Header record terminator (0x0D).
func readHeaderFields(r io.ReadSeeker) ([]FieldHeader, error) {
fields := []FieldHeader{}
offset := int64(32)
b := make([]byte, 1)
for {
//Check if we are at 0x0D by reading one byte ahead
if _, err := r.Seek(offset, 0); err != nil {
return nil, err
}
if _, err := r.Read(b); err != nil {
return nil, err
}
if b[0] == 0x0D {
break
}
//Position back one byte and read the field
if _, err := r.Seek(-1, 1); err != nil {
return nil, err
}
field := FieldHeader{}
err := binary.Read(r, binary.LittleEndian, &field)
if err != nil {
return nil, err
}
fields = append(fields, field)
offset += 32
}
return fields, nil
}
func maybeDecompress(rs io.ReadSeeker) (io.Reader, error) {
// TODO(jonboulle): this is a bit redundant with detectValType
typ, err := aci.DetectFileType(rs)
if err != nil {
return nil, err
}
if _, err := rs.Seek(0, 0); err != nil {
return nil, err
}
var r io.Reader
switch typ {
case aci.TypeGzip:
r, err = gzip.NewReader(rs)
if err != nil {
return nil, fmt.Errorf("error reading gzip: %v", err)
}
case aci.TypeBzip2:
r = bzip2.NewReader(rs)
case aci.TypeXz:
r = aci.XzReader(rs)
case aci.TypeTar:
r = rs
case aci.TypeUnknown:
return nil, errors.New("unknown filetype")
default:
// should never happen
panic(fmt.Sprintf("bad type returned from DetectFileType: %v", typ))
}
return r, nil
}
// SumID3v2 constructs a checksum of MP3 audio file data (assumed to have ID3v2 tags) provided by the
// io.ReadSeeker which is metadata invariant.
func SumID3v2(r io.ReadSeeker) (string, error) {
header, err := readID3v2Header(r)
if err != nil {
return "", fmt.Errorf("error reading ID3v2 header: %v", err)
}
_, err = r.Seek(int64(header.Size), os.SEEK_CUR)
if err != nil {
return "", fmt.Errorf("error seeking to end of ID3V2 header: %v", err)
}
n, err := sizeToEndOffset(r, 128)
if err != nil {
return "", fmt.Errorf("error determining read size to ID3v1 header: %v", err)
}
// TODO: remove this check?????
if n < 0 {
return "", fmt.Errorf("file size must be greater than 128 bytes for MP3: %v bytes", n)
}
h := sha1.New()
_, err = io.CopyN(h, r, n)
if err != nil {
return "", fmt.Errorf("error reading %v bytes: %v", n, err)
}
return hashSum(h), nil
}
// NewUnpacker returns a pointer to Unpacker which can be used to read
// individual Blobs from a pack.
func NewUnpacker(k *crypto.Key, rd io.ReadSeeker) (*Unpacker, error) {
var err error
ls := binary.Size(uint32(0))
// reset to the end to read header length
_, err = rd.Seek(-int64(ls), 2)
if err != nil {
return nil, fmt.Errorf("seeking to read header length failed: %v", err)
}
var length uint32
err = binary.Read(rd, binary.LittleEndian, &length)
if err != nil {
return nil, fmt.Errorf("reading header length failed: %v", err)
}
// reset to the beginning of the header
_, err = rd.Seek(-int64(ls)-int64(length), 2)
if err != nil {
return nil, fmt.Errorf("seeking to read header length failed: %v", err)
}
// read header
hrd, err := crypto.DecryptFrom(k, io.LimitReader(rd, int64(length)))
if err != nil {
return nil, err
}
var entries []Blob
pos := uint(0)
for {
e := headerEntry{}
err = binary.Read(hrd, binary.LittleEndian, &e)
if err == io.EOF {
break
}
if err != nil {
return nil, err
}
entries = append(entries, Blob{
Type: e.Type,
Length: uint(e.Length),
ID: e.ID,
Offset: pos,
})
pos += uint(e.Length)
}
p := &Unpacker{
rd: rd,
k: k,
Entries: entries,
}
return p, nil
}
// Sum creates a checksum of the audio file data provided by the io.ReadSeeker which is metadata
// (ID3, MP4) invariant.
func Sum(r io.ReadSeeker) (string, error) {
b, err := readBytes(r, 11)
if err != nil {
return "", err
}
_, err = r.Seek(-11, os.SEEK_CUR)
if err != nil {
return "", fmt.Errorf("could not seek back to original position: %v", err)
}
switch {
case string(b[0:4]) == "fLaC":
return SumFLAC(r)
case string(b[4:11]) == "ftypM4A":
return SumAtoms(r)
case string(b[0:3]) == "ID3":
return SumID3v2(r)
}
h, err := SumID3v1(r)
if err != nil {
if err == ErrNotID3v1 {
return SumAll(r)
}
return "", err
}
return h, nil
}
// computeHash - Calculates MD5 and SHA256 for an input read Seeker.
func (c Client) computeHash(reader io.ReadSeeker) (md5Sum, sha256Sum []byte, size int64, err error) {
// MD5 and SHA256 hasher.
var hashMD5, hashSHA256 hash.Hash
// MD5 and SHA256 hasher.
hashMD5 = md5.New()
hashWriter := io.MultiWriter(hashMD5)
if c.signature.isV4() {
hashSHA256 = sha256.New()
hashWriter = io.MultiWriter(hashMD5, hashSHA256)
}
size, err = io.Copy(hashWriter, reader)
if err != nil {
return nil, nil, 0, err
}
// Seek back reader to the beginning location.
if _, err := reader.Seek(0, 0); err != nil {
return nil, nil, 0, err
}
// Finalize md5shum and sha256 sum.
md5Sum = hashMD5.Sum(nil)
if c.signature.isV4() {
sha256Sum = hashSHA256.Sum(nil)
}
return md5Sum, sha256Sum, size, nil
}
func (cOff chunkOffTs) readPreChunk(r io.ReadSeeker) (*preChunk, error) {
pc := preChunk{ts: cOff.ts}
if _, err := r.Seek(cOff.offset, 0); err != nil {
return nil, err
}
lr := io.LimitReader(r, cOff.size)
var length uint32
if err := binary.Read(lr, binary.BigEndian, &length); err != nil {
return nil, err
}
lr = io.LimitReader(lr, int64(length))
compType, err := kagus.ReadByte(lr)
if err != nil {
return nil, err
}
pc.compression = compType
buf := new(bytes.Buffer)
if _, err := io.Copy(buf, lr); err != nil {
return nil, err
}
pc.data = buf.Bytes()
return &pc, err
}