Source file src/go.mongodb.org/mongo-driver/bson/bsonrw/value_reader.go

Documentation: go.mongodb.org/mongo-driver/bson/bsonrw

     1  // Copyright (C) MongoDB, Inc. 2017-present.
     2  //
     3  // Licensed under the Apache License, Version 2.0 (the "License"); you may
     4  // not use this file except in compliance with the License. You may obtain
     5  // a copy of the License at http://www.apache.org/licenses/LICENSE-2.0
     6  
     7  package bsonrw
     8  
     9  import (
    10  	"bytes"
    11  	"encoding/binary"
    12  	"errors"
    13  	"fmt"
    14  	"io"
    15  	"math"
    16  	"sync"
    17  
    18  	"go.mongodb.org/mongo-driver/bson/bsontype"
    19  	"go.mongodb.org/mongo-driver/bson/primitive"
    20  )
    21  
    22  var _ ValueReader = (*valueReader)(nil)
    23  
    24  var vrPool = sync.Pool{
    25  	New: func() interface{} {
    26  		return new(valueReader)
    27  	},
    28  }
    29  
    30  // BSONValueReaderPool is a pool for ValueReaders that read BSON.
    31  //
    32  // Deprecated: BSONValueReaderPool will not be supported in Go Driver 2.0.
    33  type BSONValueReaderPool struct {
    34  	pool sync.Pool
    35  }
    36  
    37  // NewBSONValueReaderPool instantiates a new BSONValueReaderPool.
    38  //
    39  // Deprecated: BSONValueReaderPool will not be supported in Go Driver 2.0.
    40  func NewBSONValueReaderPool() *BSONValueReaderPool {
    41  	return &BSONValueReaderPool{
    42  		pool: sync.Pool{
    43  			New: func() interface{} {
    44  				return new(valueReader)
    45  			},
    46  		},
    47  	}
    48  }
    49  
    50  // Get retrieves a ValueReader from the pool and uses src as the underlying BSON.
    51  //
    52  // Deprecated: BSONValueReaderPool will not be supported in Go Driver 2.0.
    53  func (bvrp *BSONValueReaderPool) Get(src []byte) ValueReader {
    54  	vr := bvrp.pool.Get().(*valueReader)
    55  	vr.reset(src)
    56  	return vr
    57  }
    58  
    59  // Put inserts a ValueReader into the pool. If the ValueReader is not a BSON ValueReader nothing
    60  // is inserted into the pool and ok will be false.
    61  //
    62  // Deprecated: BSONValueReaderPool will not be supported in Go Driver 2.0.
    63  func (bvrp *BSONValueReaderPool) Put(vr ValueReader) (ok bool) {
    64  	bvr, ok := vr.(*valueReader)
    65  	if !ok {
    66  		return false
    67  	}
    68  
    69  	bvr.reset(nil)
    70  	bvrp.pool.Put(bvr)
    71  	return true
    72  }
    73  
    74  // ErrEOA is the error returned when the end of a BSON array has been reached.
    75  var ErrEOA = errors.New("end of array")
    76  
    77  // ErrEOD is the error returned when the end of a BSON document has been reached.
    78  var ErrEOD = errors.New("end of document")
    79  
    80  type vrState struct {
    81  	mode  mode
    82  	vType bsontype.Type
    83  	end   int64
    84  }
    85  
    86  // valueReader is for reading BSON values.
    87  type valueReader struct {
    88  	offset int64
    89  	d      []byte
    90  
    91  	stack []vrState
    92  	frame int64
    93  }
    94  
    95  // NewBSONDocumentReader returns a ValueReader using b for the underlying BSON
    96  // representation. Parameter b must be a BSON Document.
    97  func NewBSONDocumentReader(b []byte) ValueReader {
    98  	// TODO(skriptble): There's a lack of symmetry between the reader and writer, since the reader takes a []byte while the
    99  	// TODO writer takes an io.Writer. We should have two versions of each, one that takes a []byte and one that takes an
   100  	// TODO io.Reader or io.Writer. The []byte version will need to return a thing that can return the finished []byte since
   101  	// TODO it might be reallocated when appended to.
   102  	return newValueReader(b)
   103  }
   104  
   105  // NewBSONValueReader returns a ValueReader that starts in the Value mode instead of in top
   106  // level document mode. This enables the creation of a ValueReader for a single BSON value.
   107  func NewBSONValueReader(t bsontype.Type, val []byte) ValueReader {
   108  	stack := make([]vrState, 1, 5)
   109  	stack[0] = vrState{
   110  		mode:  mValue,
   111  		vType: t,
   112  	}
   113  	return &valueReader{
   114  		d:     val,
   115  		stack: stack,
   116  	}
   117  }
   118  
   119  func newValueReader(b []byte) *valueReader {
   120  	stack := make([]vrState, 1, 5)
   121  	stack[0] = vrState{
   122  		mode: mTopLevel,
   123  	}
   124  	return &valueReader{
   125  		d:     b,
   126  		stack: stack,
   127  	}
   128  }
   129  
   130  func (vr *valueReader) reset(b []byte) {
   131  	if vr.stack == nil {
   132  		vr.stack = make([]vrState, 1, 5)
   133  	}
   134  	vr.stack = vr.stack[:1]
   135  	vr.stack[0] = vrState{mode: mTopLevel}
   136  	vr.d = b
   137  	vr.offset = 0
   138  	vr.frame = 0
   139  }
   140  
   141  func (vr *valueReader) advanceFrame() {
   142  	if vr.frame+1 >= int64(len(vr.stack)) { // We need to grow the stack
   143  		length := len(vr.stack)
   144  		if length+1 >= cap(vr.stack) {
   145  			// double it
   146  			buf := make([]vrState, 2*cap(vr.stack)+1)
   147  			copy(buf, vr.stack)
   148  			vr.stack = buf
   149  		}
   150  		vr.stack = vr.stack[:length+1]
   151  	}
   152  	vr.frame++
   153  
   154  	// Clean the stack
   155  	vr.stack[vr.frame].mode = 0
   156  	vr.stack[vr.frame].vType = 0
   157  	vr.stack[vr.frame].end = 0
   158  }
   159  
   160  func (vr *valueReader) pushDocument() error {
   161  	vr.advanceFrame()
   162  
   163  	vr.stack[vr.frame].mode = mDocument
   164  
   165  	size, err := vr.readLength()
   166  	if err != nil {
   167  		return err
   168  	}
   169  	vr.stack[vr.frame].end = int64(size) + vr.offset - 4
   170  
   171  	return nil
   172  }
   173  
   174  func (vr *valueReader) pushArray() error {
   175  	vr.advanceFrame()
   176  
   177  	vr.stack[vr.frame].mode = mArray
   178  
   179  	size, err := vr.readLength()
   180  	if err != nil {
   181  		return err
   182  	}
   183  	vr.stack[vr.frame].end = int64(size) + vr.offset - 4
   184  
   185  	return nil
   186  }
   187  
   188  func (vr *valueReader) pushElement(t bsontype.Type) {
   189  	vr.advanceFrame()
   190  
   191  	vr.stack[vr.frame].mode = mElement
   192  	vr.stack[vr.frame].vType = t
   193  }
   194  
   195  func (vr *valueReader) pushValue(t bsontype.Type) {
   196  	vr.advanceFrame()
   197  
   198  	vr.stack[vr.frame].mode = mValue
   199  	vr.stack[vr.frame].vType = t
   200  }
   201  
   202  func (vr *valueReader) pushCodeWithScope() (int64, error) {
   203  	vr.advanceFrame()
   204  
   205  	vr.stack[vr.frame].mode = mCodeWithScope
   206  
   207  	size, err := vr.readLength()
   208  	if err != nil {
   209  		return 0, err
   210  	}
   211  	vr.stack[vr.frame].end = int64(size) + vr.offset - 4
   212  
   213  	return int64(size), nil
   214  }
   215  
   216  func (vr *valueReader) pop() {
   217  	switch vr.stack[vr.frame].mode {
   218  	case mElement, mValue:
   219  		vr.frame--
   220  	case mDocument, mArray, mCodeWithScope:
   221  		vr.frame -= 2 // we pop twice to jump over the vrElement: vrDocument -> vrElement -> vrDocument/TopLevel/etc...
   222  	}
   223  }
   224  
   225  func (vr *valueReader) invalidTransitionErr(destination mode, name string, modes []mode) error {
   226  	te := TransitionError{
   227  		name:        name,
   228  		current:     vr.stack[vr.frame].mode,
   229  		destination: destination,
   230  		modes:       modes,
   231  		action:      "read",
   232  	}
   233  	if vr.frame != 0 {
   234  		te.parent = vr.stack[vr.frame-1].mode
   235  	}
   236  	return te
   237  }
   238  
   239  func (vr *valueReader) typeError(t bsontype.Type) error {
   240  	return fmt.Errorf("positioned on %s, but attempted to read %s", vr.stack[vr.frame].vType, t)
   241  }
   242  
   243  func (vr *valueReader) invalidDocumentLengthError() error {
   244  	return fmt.Errorf("document is invalid, end byte is at %d, but null byte found at %d", vr.stack[vr.frame].end, vr.offset)
   245  }
   246  
   247  func (vr *valueReader) ensureElementValue(t bsontype.Type, destination mode, callerName string) error {
   248  	switch vr.stack[vr.frame].mode {
   249  	case mElement, mValue:
   250  		if vr.stack[vr.frame].vType != t {
   251  			return vr.typeError(t)
   252  		}
   253  	default:
   254  		return vr.invalidTransitionErr(destination, callerName, []mode{mElement, mValue})
   255  	}
   256  
   257  	return nil
   258  }
   259  
   260  func (vr *valueReader) Type() bsontype.Type {
   261  	return vr.stack[vr.frame].vType
   262  }
   263  
   264  func (vr *valueReader) nextElementLength() (int32, error) {
   265  	var length int32
   266  	var err error
   267  	switch vr.stack[vr.frame].vType {
   268  	case bsontype.Array, bsontype.EmbeddedDocument, bsontype.CodeWithScope:
   269  		length, err = vr.peekLength()
   270  	case bsontype.Binary:
   271  		length, err = vr.peekLength()
   272  		length += 4 + 1 // binary length + subtype byte
   273  	case bsontype.Boolean:
   274  		length = 1
   275  	case bsontype.DBPointer:
   276  		length, err = vr.peekLength()
   277  		length += 4 + 12 // string length + ObjectID length
   278  	case bsontype.DateTime, bsontype.Double, bsontype.Int64, bsontype.Timestamp:
   279  		length = 8
   280  	case bsontype.Decimal128:
   281  		length = 16
   282  	case bsontype.Int32:
   283  		length = 4
   284  	case bsontype.JavaScript, bsontype.String, bsontype.Symbol:
   285  		length, err = vr.peekLength()
   286  		length += 4
   287  	case bsontype.MaxKey, bsontype.MinKey, bsontype.Null, bsontype.Undefined:
   288  		length = 0
   289  	case bsontype.ObjectID:
   290  		length = 12
   291  	case bsontype.Regex:
   292  		regex := bytes.IndexByte(vr.d[vr.offset:], 0x00)
   293  		if regex < 0 {
   294  			err = io.EOF
   295  			break
   296  		}
   297  		pattern := bytes.IndexByte(vr.d[vr.offset+int64(regex)+1:], 0x00)
   298  		if pattern < 0 {
   299  			err = io.EOF
   300  			break
   301  		}
   302  		length = int32(int64(regex) + 1 + int64(pattern) + 1)
   303  	default:
   304  		return 0, fmt.Errorf("attempted to read bytes of unknown BSON type %v", vr.stack[vr.frame].vType)
   305  	}
   306  
   307  	return length, err
   308  }
   309  
   310  func (vr *valueReader) ReadValueBytes(dst []byte) (bsontype.Type, []byte, error) {
   311  	switch vr.stack[vr.frame].mode {
   312  	case mTopLevel:
   313  		length, err := vr.peekLength()
   314  		if err != nil {
   315  			return bsontype.Type(0), nil, err
   316  		}
   317  		dst, err = vr.appendBytes(dst, length)
   318  		if err != nil {
   319  			return bsontype.Type(0), nil, err
   320  		}
   321  		return bsontype.Type(0), dst, nil
   322  	case mElement, mValue:
   323  		length, err := vr.nextElementLength()
   324  		if err != nil {
   325  			return bsontype.Type(0), dst, err
   326  		}
   327  
   328  		dst, err = vr.appendBytes(dst, length)
   329  		t := vr.stack[vr.frame].vType
   330  		vr.pop()
   331  		return t, dst, err
   332  	default:
   333  		return bsontype.Type(0), nil, vr.invalidTransitionErr(0, "ReadValueBytes", []mode{mElement, mValue})
   334  	}
   335  }
   336  
   337  func (vr *valueReader) Skip() error {
   338  	switch vr.stack[vr.frame].mode {
   339  	case mElement, mValue:
   340  	default:
   341  		return vr.invalidTransitionErr(0, "Skip", []mode{mElement, mValue})
   342  	}
   343  
   344  	length, err := vr.nextElementLength()
   345  	if err != nil {
   346  		return err
   347  	}
   348  
   349  	err = vr.skipBytes(length)
   350  	vr.pop()
   351  	return err
   352  }
   353  
   354  func (vr *valueReader) ReadArray() (ArrayReader, error) {
   355  	if err := vr.ensureElementValue(bsontype.Array, mArray, "ReadArray"); err != nil {
   356  		return nil, err
   357  	}
   358  
   359  	err := vr.pushArray()
   360  	if err != nil {
   361  		return nil, err
   362  	}
   363  
   364  	return vr, nil
   365  }
   366  
   367  func (vr *valueReader) ReadBinary() (b []byte, btype byte, err error) {
   368  	if err := vr.ensureElementValue(bsontype.Binary, 0, "ReadBinary"); err != nil {
   369  		return nil, 0, err
   370  	}
   371  
   372  	length, err := vr.readLength()
   373  	if err != nil {
   374  		return nil, 0, err
   375  	}
   376  
   377  	btype, err = vr.readByte()
   378  	if err != nil {
   379  		return nil, 0, err
   380  	}
   381  
   382  	// Check length in case it is an old binary without a length.
   383  	if btype == 0x02 && length > 4 {
   384  		length, err = vr.readLength()
   385  		if err != nil {
   386  			return nil, 0, err
   387  		}
   388  	}
   389  
   390  	b, err = vr.readBytes(length)
   391  	if err != nil {
   392  		return nil, 0, err
   393  	}
   394  	// Make a copy of the returned byte slice because it's just a subslice from the valueReader's
   395  	// buffer and is not safe to return in the unmarshaled value.
   396  	cp := make([]byte, len(b))
   397  	copy(cp, b)
   398  
   399  	vr.pop()
   400  	return cp, btype, nil
   401  }
   402  
   403  func (vr *valueReader) ReadBoolean() (bool, error) {
   404  	if err := vr.ensureElementValue(bsontype.Boolean, 0, "ReadBoolean"); err != nil {
   405  		return false, err
   406  	}
   407  
   408  	b, err := vr.readByte()
   409  	if err != nil {
   410  		return false, err
   411  	}
   412  
   413  	if b > 1 {
   414  		return false, fmt.Errorf("invalid byte for boolean, %b", b)
   415  	}
   416  
   417  	vr.pop()
   418  	return b == 1, nil
   419  }
   420  
   421  func (vr *valueReader) ReadDocument() (DocumentReader, error) {
   422  	switch vr.stack[vr.frame].mode {
   423  	case mTopLevel:
   424  		// read size
   425  		size, err := vr.readLength()
   426  		if err != nil {
   427  			return nil, err
   428  		}
   429  		if int(size) != len(vr.d) {
   430  			return nil, fmt.Errorf("invalid document length")
   431  		}
   432  		vr.stack[vr.frame].end = int64(size) + vr.offset - 4
   433  		return vr, nil
   434  	case mElement, mValue:
   435  		if vr.stack[vr.frame].vType != bsontype.EmbeddedDocument {
   436  			return nil, vr.typeError(bsontype.EmbeddedDocument)
   437  		}
   438  	default:
   439  		return nil, vr.invalidTransitionErr(mDocument, "ReadDocument", []mode{mTopLevel, mElement, mValue})
   440  	}
   441  
   442  	err := vr.pushDocument()
   443  	if err != nil {
   444  		return nil, err
   445  	}
   446  
   447  	return vr, nil
   448  }
   449  
   450  func (vr *valueReader) ReadCodeWithScope() (code string, dr DocumentReader, err error) {
   451  	if err := vr.ensureElementValue(bsontype.CodeWithScope, 0, "ReadCodeWithScope"); err != nil {
   452  		return "", nil, err
   453  	}
   454  
   455  	totalLength, err := vr.readLength()
   456  	if err != nil {
   457  		return "", nil, err
   458  	}
   459  	strLength, err := vr.readLength()
   460  	if err != nil {
   461  		return "", nil, err
   462  	}
   463  	if strLength <= 0 {
   464  		return "", nil, fmt.Errorf("invalid string length: %d", strLength)
   465  	}
   466  	strBytes, err := vr.readBytes(strLength)
   467  	if err != nil {
   468  		return "", nil, err
   469  	}
   470  	code = string(strBytes[:len(strBytes)-1])
   471  
   472  	size, err := vr.pushCodeWithScope()
   473  	if err != nil {
   474  		return "", nil, err
   475  	}
   476  
   477  	// The total length should equal:
   478  	// 4 (total length) + strLength + 4 (the length of str itself) + (document length)
   479  	componentsLength := int64(4+strLength+4) + size
   480  	if int64(totalLength) != componentsLength {
   481  		return "", nil, fmt.Errorf(
   482  			"length of CodeWithScope does not match lengths of components; total: %d; components: %d",
   483  			totalLength, componentsLength,
   484  		)
   485  	}
   486  	return code, vr, nil
   487  }
   488  
   489  func (vr *valueReader) ReadDBPointer() (ns string, oid primitive.ObjectID, err error) {
   490  	if err := vr.ensureElementValue(bsontype.DBPointer, 0, "ReadDBPointer"); err != nil {
   491  		return "", oid, err
   492  	}
   493  
   494  	ns, err = vr.readString()
   495  	if err != nil {
   496  		return "", oid, err
   497  	}
   498  
   499  	oidbytes, err := vr.readBytes(12)
   500  	if err != nil {
   501  		return "", oid, err
   502  	}
   503  
   504  	copy(oid[:], oidbytes)
   505  
   506  	vr.pop()
   507  	return ns, oid, nil
   508  }
   509  
   510  func (vr *valueReader) ReadDateTime() (int64, error) {
   511  	if err := vr.ensureElementValue(bsontype.DateTime, 0, "ReadDateTime"); err != nil {
   512  		return 0, err
   513  	}
   514  
   515  	i, err := vr.readi64()
   516  	if err != nil {
   517  		return 0, err
   518  	}
   519  
   520  	vr.pop()
   521  	return i, nil
   522  }
   523  
   524  func (vr *valueReader) ReadDecimal128() (primitive.Decimal128, error) {
   525  	if err := vr.ensureElementValue(bsontype.Decimal128, 0, "ReadDecimal128"); err != nil {
   526  		return primitive.Decimal128{}, err
   527  	}
   528  
   529  	b, err := vr.readBytes(16)
   530  	if err != nil {
   531  		return primitive.Decimal128{}, err
   532  	}
   533  
   534  	l := binary.LittleEndian.Uint64(b[0:8])
   535  	h := binary.LittleEndian.Uint64(b[8:16])
   536  
   537  	vr.pop()
   538  	return primitive.NewDecimal128(h, l), nil
   539  }
   540  
   541  func (vr *valueReader) ReadDouble() (float64, error) {
   542  	if err := vr.ensureElementValue(bsontype.Double, 0, "ReadDouble"); err != nil {
   543  		return 0, err
   544  	}
   545  
   546  	u, err := vr.readu64()
   547  	if err != nil {
   548  		return 0, err
   549  	}
   550  
   551  	vr.pop()
   552  	return math.Float64frombits(u), nil
   553  }
   554  
   555  func (vr *valueReader) ReadInt32() (int32, error) {
   556  	if err := vr.ensureElementValue(bsontype.Int32, 0, "ReadInt32"); err != nil {
   557  		return 0, err
   558  	}
   559  
   560  	vr.pop()
   561  	return vr.readi32()
   562  }
   563  
   564  func (vr *valueReader) ReadInt64() (int64, error) {
   565  	if err := vr.ensureElementValue(bsontype.Int64, 0, "ReadInt64"); err != nil {
   566  		return 0, err
   567  	}
   568  
   569  	vr.pop()
   570  	return vr.readi64()
   571  }
   572  
   573  func (vr *valueReader) ReadJavascript() (code string, err error) {
   574  	if err := vr.ensureElementValue(bsontype.JavaScript, 0, "ReadJavascript"); err != nil {
   575  		return "", err
   576  	}
   577  
   578  	vr.pop()
   579  	return vr.readString()
   580  }
   581  
   582  func (vr *valueReader) ReadMaxKey() error {
   583  	if err := vr.ensureElementValue(bsontype.MaxKey, 0, "ReadMaxKey"); err != nil {
   584  		return err
   585  	}
   586  
   587  	vr.pop()
   588  	return nil
   589  }
   590  
   591  func (vr *valueReader) ReadMinKey() error {
   592  	if err := vr.ensureElementValue(bsontype.MinKey, 0, "ReadMinKey"); err != nil {
   593  		return err
   594  	}
   595  
   596  	vr.pop()
   597  	return nil
   598  }
   599  
   600  func (vr *valueReader) ReadNull() error {
   601  	if err := vr.ensureElementValue(bsontype.Null, 0, "ReadNull"); err != nil {
   602  		return err
   603  	}
   604  
   605  	vr.pop()
   606  	return nil
   607  }
   608  
   609  func (vr *valueReader) ReadObjectID() (primitive.ObjectID, error) {
   610  	if err := vr.ensureElementValue(bsontype.ObjectID, 0, "ReadObjectID"); err != nil {
   611  		return primitive.ObjectID{}, err
   612  	}
   613  
   614  	oidbytes, err := vr.readBytes(12)
   615  	if err != nil {
   616  		return primitive.ObjectID{}, err
   617  	}
   618  
   619  	var oid primitive.ObjectID
   620  	copy(oid[:], oidbytes)
   621  
   622  	vr.pop()
   623  	return oid, nil
   624  }
   625  
   626  func (vr *valueReader) ReadRegex() (string, string, error) {
   627  	if err := vr.ensureElementValue(bsontype.Regex, 0, "ReadRegex"); err != nil {
   628  		return "", "", err
   629  	}
   630  
   631  	pattern, err := vr.readCString()
   632  	if err != nil {
   633  		return "", "", err
   634  	}
   635  
   636  	options, err := vr.readCString()
   637  	if err != nil {
   638  		return "", "", err
   639  	}
   640  
   641  	vr.pop()
   642  	return pattern, options, nil
   643  }
   644  
   645  func (vr *valueReader) ReadString() (string, error) {
   646  	if err := vr.ensureElementValue(bsontype.String, 0, "ReadString"); err != nil {
   647  		return "", err
   648  	}
   649  
   650  	vr.pop()
   651  	return vr.readString()
   652  }
   653  
   654  func (vr *valueReader) ReadSymbol() (symbol string, err error) {
   655  	if err := vr.ensureElementValue(bsontype.Symbol, 0, "ReadSymbol"); err != nil {
   656  		return "", err
   657  	}
   658  
   659  	vr.pop()
   660  	return vr.readString()
   661  }
   662  
   663  func (vr *valueReader) ReadTimestamp() (t uint32, i uint32, err error) {
   664  	if err := vr.ensureElementValue(bsontype.Timestamp, 0, "ReadTimestamp"); err != nil {
   665  		return 0, 0, err
   666  	}
   667  
   668  	i, err = vr.readu32()
   669  	if err != nil {
   670  		return 0, 0, err
   671  	}
   672  
   673  	t, err = vr.readu32()
   674  	if err != nil {
   675  		return 0, 0, err
   676  	}
   677  
   678  	vr.pop()
   679  	return t, i, nil
   680  }
   681  
   682  func (vr *valueReader) ReadUndefined() error {
   683  	if err := vr.ensureElementValue(bsontype.Undefined, 0, "ReadUndefined"); err != nil {
   684  		return err
   685  	}
   686  
   687  	vr.pop()
   688  	return nil
   689  }
   690  
   691  func (vr *valueReader) ReadElement() (string, ValueReader, error) {
   692  	switch vr.stack[vr.frame].mode {
   693  	case mTopLevel, mDocument, mCodeWithScope:
   694  	default:
   695  		return "", nil, vr.invalidTransitionErr(mElement, "ReadElement", []mode{mTopLevel, mDocument, mCodeWithScope})
   696  	}
   697  
   698  	t, err := vr.readByte()
   699  	if err != nil {
   700  		return "", nil, err
   701  	}
   702  
   703  	if t == 0 {
   704  		if vr.offset != vr.stack[vr.frame].end {
   705  			return "", nil, vr.invalidDocumentLengthError()
   706  		}
   707  
   708  		vr.pop()
   709  		return "", nil, ErrEOD
   710  	}
   711  
   712  	name, err := vr.readCString()
   713  	if err != nil {
   714  		return "", nil, err
   715  	}
   716  
   717  	vr.pushElement(bsontype.Type(t))
   718  	return name, vr, nil
   719  }
   720  
   721  func (vr *valueReader) ReadValue() (ValueReader, error) {
   722  	switch vr.stack[vr.frame].mode {
   723  	case mArray:
   724  	default:
   725  		return nil, vr.invalidTransitionErr(mValue, "ReadValue", []mode{mArray})
   726  	}
   727  
   728  	t, err := vr.readByte()
   729  	if err != nil {
   730  		return nil, err
   731  	}
   732  
   733  	if t == 0 {
   734  		if vr.offset != vr.stack[vr.frame].end {
   735  			return nil, vr.invalidDocumentLengthError()
   736  		}
   737  
   738  		vr.pop()
   739  		return nil, ErrEOA
   740  	}
   741  
   742  	if err := vr.skipCString(); err != nil {
   743  		return nil, err
   744  	}
   745  
   746  	vr.pushValue(bsontype.Type(t))
   747  	return vr, nil
   748  }
   749  
   750  // readBytes reads length bytes from the valueReader starting at the current offset. Note that the
   751  // returned byte slice is a subslice from the valueReader buffer and must be converted or copied
   752  // before returning in an unmarshaled value.
   753  func (vr *valueReader) readBytes(length int32) ([]byte, error) {
   754  	if length < 0 {
   755  		return nil, fmt.Errorf("invalid length: %d", length)
   756  	}
   757  
   758  	if vr.offset+int64(length) > int64(len(vr.d)) {
   759  		return nil, io.EOF
   760  	}
   761  
   762  	start := vr.offset
   763  	vr.offset += int64(length)
   764  
   765  	return vr.d[start : start+int64(length)], nil
   766  }
   767  
   768  func (vr *valueReader) appendBytes(dst []byte, length int32) ([]byte, error) {
   769  	if vr.offset+int64(length) > int64(len(vr.d)) {
   770  		return nil, io.EOF
   771  	}
   772  
   773  	start := vr.offset
   774  	vr.offset += int64(length)
   775  	return append(dst, vr.d[start:start+int64(length)]...), nil
   776  }
   777  
   778  func (vr *valueReader) skipBytes(length int32) error {
   779  	if vr.offset+int64(length) > int64(len(vr.d)) {
   780  		return io.EOF
   781  	}
   782  
   783  	vr.offset += int64(length)
   784  	return nil
   785  }
   786  
   787  func (vr *valueReader) readByte() (byte, error) {
   788  	if vr.offset+1 > int64(len(vr.d)) {
   789  		return 0x0, io.EOF
   790  	}
   791  
   792  	vr.offset++
   793  	return vr.d[vr.offset-1], nil
   794  }
   795  
   796  func (vr *valueReader) skipCString() error {
   797  	idx := bytes.IndexByte(vr.d[vr.offset:], 0x00)
   798  	if idx < 0 {
   799  		return io.EOF
   800  	}
   801  	vr.offset += int64(idx) + 1
   802  	return nil
   803  }
   804  
   805  func (vr *valueReader) readCString() (string, error) {
   806  	idx := bytes.IndexByte(vr.d[vr.offset:], 0x00)
   807  	if idx < 0 {
   808  		return "", io.EOF
   809  	}
   810  	start := vr.offset
   811  	// idx does not include the null byte
   812  	vr.offset += int64(idx) + 1
   813  	return string(vr.d[start : start+int64(idx)]), nil
   814  }
   815  
   816  func (vr *valueReader) readString() (string, error) {
   817  	length, err := vr.readLength()
   818  	if err != nil {
   819  		return "", err
   820  	}
   821  
   822  	if int64(length)+vr.offset > int64(len(vr.d)) {
   823  		return "", io.EOF
   824  	}
   825  
   826  	if length <= 0 {
   827  		return "", fmt.Errorf("invalid string length: %d", length)
   828  	}
   829  
   830  	if vr.d[vr.offset+int64(length)-1] != 0x00 {
   831  		return "", fmt.Errorf("string does not end with null byte, but with %v", vr.d[vr.offset+int64(length)-1])
   832  	}
   833  
   834  	start := vr.offset
   835  	vr.offset += int64(length)
   836  	return string(vr.d[start : start+int64(length)-1]), nil
   837  }
   838  
   839  func (vr *valueReader) peekLength() (int32, error) {
   840  	if vr.offset+4 > int64(len(vr.d)) {
   841  		return 0, io.EOF
   842  	}
   843  
   844  	idx := vr.offset
   845  	return (int32(vr.d[idx]) | int32(vr.d[idx+1])<<8 | int32(vr.d[idx+2])<<16 | int32(vr.d[idx+3])<<24), nil
   846  }
   847  
   848  func (vr *valueReader) readLength() (int32, error) { return vr.readi32() }
   849  
   850  func (vr *valueReader) readi32() (int32, error) {
   851  	if vr.offset+4 > int64(len(vr.d)) {
   852  		return 0, io.EOF
   853  	}
   854  
   855  	idx := vr.offset
   856  	vr.offset += 4
   857  	return (int32(vr.d[idx]) | int32(vr.d[idx+1])<<8 | int32(vr.d[idx+2])<<16 | int32(vr.d[idx+3])<<24), nil
   858  }
   859  
   860  func (vr *valueReader) readu32() (uint32, error) {
   861  	if vr.offset+4 > int64(len(vr.d)) {
   862  		return 0, io.EOF
   863  	}
   864  
   865  	idx := vr.offset
   866  	vr.offset += 4
   867  	return (uint32(vr.d[idx]) | uint32(vr.d[idx+1])<<8 | uint32(vr.d[idx+2])<<16 | uint32(vr.d[idx+3])<<24), nil
   868  }
   869  
   870  func (vr *valueReader) readi64() (int64, error) {
   871  	if vr.offset+8 > int64(len(vr.d)) {
   872  		return 0, io.EOF
   873  	}
   874  
   875  	idx := vr.offset
   876  	vr.offset += 8
   877  	return int64(vr.d[idx]) | int64(vr.d[idx+1])<<8 | int64(vr.d[idx+2])<<16 | int64(vr.d[idx+3])<<24 |
   878  		int64(vr.d[idx+4])<<32 | int64(vr.d[idx+5])<<40 | int64(vr.d[idx+6])<<48 | int64(vr.d[idx+7])<<56, nil
   879  }
   880  
   881  func (vr *valueReader) readu64() (uint64, error) {
   882  	if vr.offset+8 > int64(len(vr.d)) {
   883  		return 0, io.EOF
   884  	}
   885  
   886  	idx := vr.offset
   887  	vr.offset += 8
   888  	return uint64(vr.d[idx]) | uint64(vr.d[idx+1])<<8 | uint64(vr.d[idx+2])<<16 | uint64(vr.d[idx+3])<<24 |
   889  		uint64(vr.d[idx+4])<<32 | uint64(vr.d[idx+5])<<40 | uint64(vr.d[idx+6])<<48 | uint64(vr.d[idx+7])<<56, nil
   890  }
   891  

View as plain text