Golang ReadSeeker.Seek方法代码示例

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
}