func (be *BlockExtractor) SaveJSON(block interfaces.DatabaseBatchable) error {
	data, err := block.(interfaces.Printable).JSONByte()
	if err != nil {
		return err
	}

	var out bytes.Buffer
	json.Indent(&out, data, "", "\t")
	data = out.Next(out.Len())

	strChainID := fmt.Sprintf("%x", block.GetChainID().Bytes())
	dir := be.DataStorePath + strChainID
	if FileNotExists(dir) {
		err := os.MkdirAll(dir, 0777)
		if err == nil {
			fmt.Println("Created directory " + dir)
		} else {
			return err
		}
	}

	err = ioutil.WriteFile(fmt.Sprintf(dir+"/storeJSON.%09d.block", block.GetDatabaseHeight()), data, 0777)
	if err != nil {
		return err
	}
	return nil
}
Beispiel #2
0
func Tokenize(buf *bytes.Buffer) []interface{} {
	if buf.Len() == 0 {
		return nil
	}
	r := []interface{}{}

	acc := ""
	for buf.Len() > 0 {
		c := rune(buf.Next(1)[0])

		if unicode.IsLetter(c) || unicode.IsNumber(c) || c == '"' {
			acc += string(c)
		} else if c == '(' {
			var nested []interface{} = Tokenize(buf)
			r = append(r, nested)
		} else if c == ')' {
			break
		} else {
			if acc != "" {
				r = append(r, acc)
			}
			acc = ""
		}

	}
	if acc != "" {
		r = append(r, acc)
	}
	return r
}
func (be *BlockExtractor) SaveEntryJSON(entry interfaces.DatabaseBatchable, blockHeight uint32) error {
	data, err := entry.(interfaces.Printable).JSONByte()
	if err != nil {
		return err
	}

	var out bytes.Buffer
	json.Indent(&out, data, "", "\t")
	data = out.Next(out.Len())

	strChainID := fmt.Sprintf("%x", entry.GetChainID().Bytes())
	dir := be.DataStorePath + strChainID + "/entries"
	if FileNotExists(dir) {
		err := os.MkdirAll(dir, 0777)
		if err == nil {
			fmt.Println("Created directory " + dir)
		} else {
			return err
		}
	}

	err = ioutil.WriteFile(fmt.Sprintf(dir+"/storeJSON.%09d.%v.entry", blockHeight, entry.DatabasePrimaryIndex().String()), data, 0777)
	if err != nil {
		return err
	}
	return nil
}
Beispiel #4
0
func parseSegmentRunTable(r *bytes.Buffer) error {
	b, err := ReadBox(r)
	if err != nil {
		return err
	}
	if b.Type != "asrt" {
		return fmt.Errorf("%s: not a Segment Run Table box", b.Type)
	}
	r = bytes.NewBuffer(b.Data)
	r.Next(4)
	qualities, err := readStringList(r)
	_ = qualities
	if err != nil {
		return parseError{"quality entries", err}
	}
	var runCount uint32
	err = binary.Read(r, binary.BigEndian, &runCount)
	if err != nil {
		return parseError{"run count", err}
	}
	run := make([][2]uint32, runCount)
	err = binary.Read(r, binary.BigEndian, &run)
	if err != nil {
		return parseError{"segment runs", err}
	}
	log.Println(run)
	return nil
}
Beispiel #5
0
func Save(receipt *Receipt) error {
	data, err := receipt.JSONByte()
	if err != nil {
		return err
	}

	var out bytes.Buffer
	json.Indent(&out, data, "", "\t")
	data = out.Next(out.Len())

	entryID := receipt.Entry.Key
	dir := DataStorePath // + entryID
	if FileNotExists(dir) {
		err := os.MkdirAll(dir, 0777)
		if err == nil {
			fmt.Println("Created directory " + dir)
		} else {
			return err
		}
	}

	fmt.Printf("Saving %v\n", fmt.Sprintf(dir+"/storeJSON.%v.block", entryID))

	err = ioutil.WriteFile(fmt.Sprintf(dir+"/storeJSON.%v.block", entryID), data, 0777)
	if err != nil {
		return err
	}
	return nil
}
Beispiel #6
0
// fills recv_buffer with a chunk of data starting with a 32-bit
// integer representing the size of the remainder.  Reads the size out
// of recv_buffer before returning, so all the data you see in
// recv_buffer is the payload, not including the size.
func readSizePrefixedChunk(conn net.Conn, recv_buffer *bytes.Buffer) error {
	recv_slice := make([]byte, 500)
	n, err := conn.Read(recv_slice)
	if err != nil {
		return err
	}
	fmt.Printf("read %d bytes, err is %v\n", n, err)
	recv_buffer.Write(recv_slice[:n])
	for recv_buffer.Len() < 4 {
		time.Sleep(time.Millisecond)
		n, err := conn.Read(recv_slice)
		if err != nil {
			return err
		}
		recv_buffer.Write(recv_slice[:n])
		fmt.Printf("read2 %d bytes, err is %v\n", n, err)
	}
	size_slice := recv_buffer.Next(4)
	response_size := int(size_slice[0]) | int(size_slice[1])<<8 | int(size_slice[2])<<16 | int(size_slice[3])<<24
	fmt.Printf("response size is %d\n", response_size)

	for recv_buffer.Len() < response_size {
		time.Sleep(time.Millisecond)
		n, err := conn.Read(recv_slice)
		if err != nil {
			return err
		}
		recv_buffer.Write(recv_slice[:n])
		fmt.Printf("read3 %d bytes, err is %v\n", n, err)
	}
	return nil
}
Beispiel #7
0
func decode_rikeying_chunk(srcAddr *string, r *bytes.Buffer, handler chunk_handler) {
	//fmt.Println("[RIKeying Chunk]")

	var responderSessionId uint32
	binary.Read(r, binary.BigEndian, &responderSessionId)

	skrcLength := decode_vlu(r)
	sessionKeyResponderComponent := r.Bytes()[:skrcLength]
	r.Next(int(skrcLength))

	//signature := r.Bytes()

	//fmt.Printf("responderSessionId:%d\nsignature:%v\n",
	//	responderSessionId, signature)

	//fmt.Println("sessionKeyResponderComponent:")
	//fmt.Println(sessionKeyResponderComponent)
	//dump_options(sessionKeyResponderComponent)

	//
	//dh_pub_num := sessionKeyResponderComponent[len(sessionKeyResponderComponent)-128:]
	//fmt.Printf("resdoner-dh-number:%v\n", dh_pub_num)

	if handler != nil {
		handler.recv_rikeying(srcAddr, responderSessionId, sessionKeyResponderComponent)
	}
}
Beispiel #8
0
// Parse metadata/markdown file
func (j *JSONMetadataParser) Init(b *bytes.Buffer) bool {
	m := make(map[string]interface{})

	err := json.Unmarshal(b.Bytes(), &m)
	if err != nil {
		var offset int

		if jerr, ok := err.(*json.SyntaxError); !ok {
			return false
		} else {
			offset = int(jerr.Offset)
		}

		m = make(map[string]interface{})
		err = json.Unmarshal(b.Next(offset-1), &m)
		if err != nil {
			return false
		}
	}

	j.metadata = NewMetadata(m)
	j.markdown = bytes.NewBuffer(b.Bytes())

	return true
}
Beispiel #9
0
// Next returns the next n bytes from buf.
func Next(buf *bytes.Buffer, n int) []byte {
	b := buf.Next(n)
	if len(b) != n {
		panic(NewBsonError("unexpected EOF"))
	}
	return b[:n:n]
}
Beispiel #10
0
func readUint16(buf *bytes.Buffer) (uint16, error) {
	if buf.Len() < 2 {
		return 0, glog.NewError("Insufficient buffer size. Expecting %d, got %d.", 2, buf.Len())
	}

	return binary.BigEndian.Uint16(buf.Next(2)), nil
}
Beispiel #11
0
func ListenTo(url string) (net.Conn, chan []byte) {
	con, err := net.Dial("tcp", url)
	deny(err)
	ch := make(chan []byte)

	go func() {
		var replyBuffer bytes.Buffer
		readBuffer := make([]byte, 1024)
		for {
			con.SetDeadline(time.Now().Add(time.Minute))
			bytesRead, err := con.Read(readBuffer)
			if err != nil {
				close(ch)
				log.Printf("ListenTo connection error: %s", err)
				return
			}
			replyBuffer.Write(readBuffer[:bytesRead])

			lines := bytes.SplitAfter(replyBuffer.Bytes(), []byte("\n"))
			for _, line := range lines[:len(lines)-1] {
				n := len(line)
				if n > 1 {
					lineCopy := make([]byte, n)
					copy(lineCopy, line)
					ch <- lineCopy
				}
				replyBuffer.Next(n)
			}
		}
	}()

	return con, ch
}
Beispiel #12
0
func (t *http2Server) writeHeaders(s *Stream, b *bytes.Buffer, endStream bool) error {
	first := true
	endHeaders := false
	var err error
	// Sends the headers in a single batch.
	for !endHeaders {
		size := t.hBuf.Len()
		if size > http2MaxFrameLen {
			size = http2MaxFrameLen
		} else {
			endHeaders = true
		}
		if first {
			p := http2.HeadersFrameParam{
				StreamID:      s.id,
				BlockFragment: b.Next(size),
				EndStream:     endStream,
				EndHeaders:    endHeaders,
			}
			err = t.framer.writeHeaders(endHeaders, p)
			first = false
		} else {
			err = t.framer.writeContinuation(endHeaders, s.id, endHeaders, b.Next(size))
		}
		if err != nil {
			t.Close()
			return connectionErrorf(true, err, "transport: %v", err)
		}
	}
	return nil
}
Beispiel #13
0
func (gaugeListener *GaugeListener) processMessages(buffer *bytes.Buffer) {
	for {
		messageLength, bytesRead := proto.DecodeVarint(buffer.Bytes())
		if messageLength > 0 && messageLength < uint64(buffer.Len()) {
			message := &gauge_messages.Message{}
			messageBoundary := int(messageLength) + bytesRead
			err := proto.Unmarshal(buffer.Bytes()[bytesRead:messageBoundary], message)
			if err != nil {
				log.Printf("Failed to read proto message: %s\n", err.Error())
			} else {
				if *message.MessageType == gauge_messages.Message_KillProcessRequest {
					gaugeListener.connection.Close()
					os.Exit(0)
				}
				if *message.MessageType == gauge_messages.Message_SuiteExecutionResult {
					result := message.GetSuiteExecutionResult()
					gaugeListener.onResultHandler(result)
				}
				buffer.Next(messageBoundary)
				if buffer.Len() == 0 {
					return
				}
			}
		} else {
			return
		}
	}
}
Beispiel #14
0
// parsePacket publishes event according to data parsed
func (n *Driver) parsePacket(buf *bytes.Buffer) {
	for buf.Len() > 0 {
		b, _ := buf.ReadByte()
		switch b {
		case CodeEx:
			n.Publish(n.Event("extended"), nil)
		case CodeSignalQuality:
			ret, _ := buf.ReadByte()
			n.Publish(n.Event("signal"), ret)
		case CodeAttention:
			ret, _ := buf.ReadByte()
			n.Publish(n.Event("attention"), ret)
		case CodeMeditation:
			ret, _ := buf.ReadByte()
			n.Publish(n.Event("meditation"), ret)
		case CodeBlink:
			ret, _ := buf.ReadByte()
			n.Publish(n.Event("blink"), ret)
		case CodeWave:
			buf.Next(1)
			var ret = make([]byte, 2)
			buf.Read(ret)
			n.Publish(n.Event("wave"), int16(ret[0])<<8|int16(ret[1]))
		case CodeAsicEEG:
			ret := make([]byte, 25)
			i, _ := buf.Read(ret)
			if i == 25 {
				n.Publish(n.Event("eeg"), n.parseEEG(ret))
			}
		}
	}
}
Beispiel #15
0
func EncodePayloadAsBinary(pkts []*Packet, callback EncodeCallback) {
	if len(pkts) == 0 {
		callback([]byte{})
	}

	buf := new(bytes.Buffer)
	estLen := 0
	for _, pkt := range pkts {
		// Estimated length of buffer
		// 1(binary indicator) + 4(length bytes) + 1(255) + len(pkt.Data)
		estLen += 6 + len(pkt.Data)
	}
	buf.Grow(estLen)
	for _, pkt := range pkts {
		EncodePacket(pkt, true, func(data []byte) {
			buf.WriteByte(1)
			length := len(data)
			bitsBuf := make([]byte, 10)
			bits := 0
			for length > 0 {
				bitsBuf[bits] = byte(length % 10)
				bits++
				length = length / 10
			}
			for i := bits - 1; i >= 0; i-- {
				buf.WriteByte(bitsBuf[i])
			}
			buf.WriteByte(255)
			buf.Write(data)
		})
	}
	callback(buf.Next(buf.Len()))
}
Beispiel #16
0
func nextBinaryString(buf *bytes.Buffer) (int, string) {
	intBytes := buf.Next(4)
	intVal := int(intBytes[3]) | int(intBytes[2])<<8 | int(intBytes[1])<<16 | int(intBytes[0])<<24

	strBytes := buf.Next(intVal)
	return intVal, string(strBytes)
}
func aboutCommonInterfaces() {
	{
		in := new(bytes.Buffer)
		in.WriteString("hello world")

		out := new(bytes.Buffer)

		out.Write(in.Bytes())

		/*
		   Your code goes here.
		   Hint, use these resources:

		   $ godoc -http=:8080
		   $ open http://localhost:8080/pkg/io/
		   $ open http://localhost:8080/pkg/bytes/
		*/

		assert(out.String() == "hello world") // get data from the io.Reader to the io.Writer
	}

	{
		in := new(bytes.Buffer)
		in.WriteString("hello world")

		out := new(bytes.Buffer)
		out.Write(in.Next(5))

		assert(out.String() == "hello") // duplicate only a portion of the io.Reader
	}
}
Beispiel #18
0
func readUint16(buf *bytes.Buffer) (uint16, error) {
	read := buf.Next(2)
	if len(read) != 2 {
		return 0, ErrInvalid
	}
	return binary.BigEndian.Uint16(read), nil
}
Beispiel #19
0
func EncodePayload(pkts []*Packet, supportsBinary bool, callback EncodeCallback) {
	if supportsBinary {
		EncodePayloadAsBinary(pkts, callback)
		return
	}

	if len(pkts) == 0 {
		callback([]byte("0:"))
		return
	}

	buf := new(bytes.Buffer)
	estLen := 0
	for _, pkt := range pkts {
		// sample encoded: 102:bxmessage
		// message is in base 64
		estLen += 6 + len(pkt.Data)*2
	}
	buf.Grow(estLen)
	for _, pkt := range pkts {
		EncodePacket(pkt, supportsBinary, func(data []byte) {
			buf.Write([]byte(strconv.FormatInt(int64(len(data)), 10)))
			buf.WriteByte(':')
			buf.Write(data)
		})
	}
	callback(buf.Next(buf.Len()))
}
Beispiel #20
0
/*
   FUNCTION: sendEncryptedData(port uint16, data, ip string, mode int)
   RETURNS: Nothing
   ARGUMENTS:
               uint16 port - the port to send the data to
               string ip   - the ip to send the data to
               string data - the data to send
               int mode    - the mode of the send, either CMD or FTRANSFER (command/file transfer)
   ABOUT:
   Sends encrypted data over UDP covertly to the specified ip and port. Sends a completetion packet after the end
   of any transfer.
*/
func sendEncryptedData(port uint16, data, ip string, mode int) {

	var tmpBuffer bytes.Buffer
	var buffer []byte
	tmp := encrypt_data([]byte(data))
	tmpBuffer.Write(tmp)

	if tmpBuffer.Len()%2 != 0 {
		tmpBuffer.WriteByte(0)
	}

	size := tmpBuffer.Len()
	for p := 0; p <= size; p = p + 2 {

		if p == size && mode == CMD {
			temp := []byte{0, 0}
			buffer = craftPacket(temp, ip, SND_CMPLETE, []byte{})
		} else if p == size && mode == FTRANSFER {
			temp := []byte{0, 0}
			buffer = craftPacket(temp, ip, FSND_CMPLETE, []byte{})
		} else {
			temp := tmpBuffer.Next(2)
			buffer = craftPacket(temp, ip, port, []byte{})
		}

		if buffer == nil { // if original query was invalid
			fmt.Print("Buffer error, returned nil.\n")
			continue
		}

		err := handle.WritePacketData(buffer)
		checkError(err)
	}
}
Beispiel #21
0
func (ev *EncryptEventV2) Decode(buffer *bytes.Buffer) (err error) {
	ev.EncryptType, err = DecodeUInt32Value(buffer)
	if err != nil {
		return err
	}
	length, err := DecodeUInt32Value(buffer)
	if err != nil {
		return
	}
	switch ev.EncryptType {
	case ENCRYPTER_NONE:
		err, ev.Ev = DecodeEvent(buffer)
		return err
	case ENCRYPTER_SE1:
		newbuf := util.SimpleDecrypt(bytes.NewBuffer(buffer.Next(int(length))))
		err, ev.Ev = DecodeEvent(newbuf)
		newbuf.Reset()
	case ENCRYPTER_RC4:
		src := buffer.Next(int(length))
		dst := make([]byte, int(length))
		cipher, _ := rc4.NewCipher([]byte(rc4Key))
		cipher.XORKeyStream(dst, src)
		err, ev.Ev = DecodeEvent(bytes.NewBuffer(dst))
	default:
		return errors.New("Not supported encrypt type:" + strconv.Itoa(int(ev.EncryptType)))
	}
	return err
}
Beispiel #22
0
func (header *idHeader) read(buffer *bytes.Buffer) {
	b, _ := buffer.ReadByte()
	if b != 1 {
		panic(fmt.Sprintf("Header type == %d, expected type == 1.", b))
	}

	if string(buffer.Next(6)) != "vorbis" {
		panic("vorbis string not found in id header")
	}

	binary.Read(buffer, binary.LittleEndian, &header.idHeaderFixed)
	var block_sizes uint8
	binary.Read(buffer, binary.LittleEndian, &block_sizes)
	header.Blocksize_0 = int(1 << (block_sizes & 0x0f))
	header.Blocksize_1 = int(1 << ((block_sizes & 0xf0) >> 4))

	var framing uint8
	binary.Read(buffer, binary.LittleEndian, &framing)
	if framing != 1 {
		panic("Id header not properly framed")
	}

	if header.Version != 0 {
		panic(fmt.Sprintf("Unexpected version number in id header: %d", header.Version))
	}
	if header.Channels == 0 {
		panic("Channels set to zero in id header")
	}
	if header.Sample_rate == 0 {
		panic("Sample rate set to zero in id header")
	}
	if header.Blocksize_0 != 64 &&
		header.Blocksize_0 != 128 &&
		header.Blocksize_0 != 256 &&
		header.Blocksize_0 != 512 &&
		header.Blocksize_0 != 1024 &&
		header.Blocksize_0 != 2048 &&
		header.Blocksize_0 != 4096 &&
		header.Blocksize_0 != 8192 {
		panic(fmt.Sprintf("Invalid block 0 size: %d", header.Blocksize_0))
	}
	if header.Blocksize_1 != 64 &&
		header.Blocksize_1 != 128 &&
		header.Blocksize_1 != 256 &&
		header.Blocksize_1 != 512 &&
		header.Blocksize_1 != 1024 &&
		header.Blocksize_1 != 2048 &&
		header.Blocksize_1 != 4096 &&
		header.Blocksize_1 != 8192 {
		panic(fmt.Sprintf("Invalid block 1 size: %d", header.Blocksize_1))
	}
	if header.Blocksize_0 > header.Blocksize_1 {
		panic(fmt.Sprintf("Block 0 size > block 1 size: %d > %d", header.Blocksize_0, header.Blocksize_1))
	}

	if buffer.Len() > 0 {
		// TODO: Shouldn't be anything leftover, log a warning?
	}
}
Beispiel #23
0
func decode_string(buff *bytes.Buffer) string {
	msb := getByte(buff)
	lsb := getByte(buff)

	pLen := (uint16(msb) << 8) | uint16(lsb)

	return string(buff.Next(int(pLen)))
}
Beispiel #24
0
func EncodeBase64Packet(pkt *Packet, callback EncodeCallback) {
	buf := new(bytes.Buffer)
	buf.Grow(2 + len(pkt.Data)*2)
	buf.WriteByte('b')
	buf.Write([]byte(strconv.FormatInt(int64(Packets[pkt.Type]), 10)))
	buf.Write([]byte(base64.StdEncoding.EncodeToString(pkt.Data)))
	callback(buf.Next(buf.Len()))
}
Beispiel #25
0
func GetRawCode(buffer *bytes.Buffer) (rawCode string, err error) {
	rawCode = string(buffer.Next(4))
	if !temp.IsRawCode(rawCode) {
		return "", errorsutil.Errorf("Illegal raw code: [% X]", rawCode)
	}

	return rawCode, nil
}
Beispiel #26
0
func ExportDatabaseJSON(db interfaces.IDatabase, convertNames bool) error {
	fmt.Printf("Exporting the database\n")
	if db == nil {
		return nil
	}
	buckets, err := db.ListAllBuckets()
	if err != nil {
		return err
	}
	answer := map[string]interface{}{}
	for _, bucket := range buckets {
		m := map[string]interface{}{}
		data, keys, err := db.GetAll(bucket, new(primitives.ByteSlice))
		if err != nil {
			return err
		}
		for i, key := range keys {
			m[fmt.Sprintf("%x", key)] = data[i]
		}
		if convertNames == true {
			answer[KeyToName(bucket)] = m
		} else {
			answer[fmt.Sprintf("%x", bucket)] = m
		}
	}

	data, err := primitives.EncodeJSON(answer)
	if err != nil {
		return err
	}

	var out bytes.Buffer
	json.Indent(&out, data, "", "\t")
	data = out.Next(out.Len())
	/*
		dir := be.DataStorePath
		if dir != "" {
			if FileNotExists(dir) {
				err := os.MkdirAll(dir, 0777)
				if err == nil {
					fmt.Println("Created directory " + dir)
				} else {
					return err
				}
			}
		}
		if dir != "" {
			dir = dir + "/db.txt"
		} else {
			dir = "db.txt"
		}*/
	dir := "db.txt"
	err = ioutil.WriteFile(dir, data, 0777)
	if err != nil {
		return err
	}
	return nil
}
Beispiel #27
0
// Reads one attribute into a structure.
// dest must be a pointer to a struct.
func readAttribute(r *bytes.Buffer, dest interface{}) (er error) {
	var attr syscall.RtAttr
	er = binary.Read(r, SystemEndianness, &attr)
	if er != nil {
		return er
	}
	dataLen := int(attr.Len) - syscall.SizeofRtAttr
	value, type_spec, er := getDestinationAndType(dest, attr.Type)
	switch true {
	case er != nil:
		return er
	case type_spec == "none":
		value.Set(reflect.ValueOf(true))
	case type_spec == "fixed":
		// The payload is a binary struct
		if !value.CanAddr() {
			return fmt.Errorf("trying to read fixed-width data in a non addressable field!")
		}
		er = binary.Read(r, SystemEndianness, value.Addr().Interface())
	case type_spec == "bytes":
		// The payload is a raw sequence of bytes
		buf := make([]byte, dataLen)
		_, er = r.Read(buf[:])
		value.Set(reflect.ValueOf(buf))
	case type_spec == "string":
		// The payload is a NUL-terminated byte array
		if value.Type().Kind() != reflect.String {
			return fmt.Errorf("unable to fill field of type %s with string!", value.Type())
		}
		buf := make([]byte, dataLen)
		_, er = r.Read(buf[:])
		s := string(buf[:len(buf)-1])
		value.Set(reflect.ValueOf(s))
	case type_spec == "nested":
		// The payload is a seralized sequence of attributes
		// <header> (<header1> <attribute1> ... <header n> <attribute n>)
		if !value.CanAddr() {
			return fmt.Errorf("trying to read nested attributes to a non addressable field!")
		}
		buf := make([]byte, dataLen)
		_, er = r.Read(buf[:])
		er = ReadManyAttributes(bytes.NewBuffer(buf), value.Addr().Interface())
	case type_spec == "nestedlist":
		// The payload is a sequence of nested attributes, each of them carrying
		// a payload describing a struct with attributes
		// <header (4 bytes)> <payload>
		// where payload is
		// <header1> <nested attributes 1> ... <headern> <nested attributes n>
		buf := make([]byte, dataLen)
		_, er = r.Read(buf[:])
		er = readNestedAttributeList(bytes.NewBuffer(buf), value)
	default:
		return fmt.Errorf("Invalid format tag %s: expecting 'fixed', 'bytes', 'string', or 'nested'", type_spec)
	}
	r.Next(netlinkPadding(dataLen))
	return er
}
Beispiel #28
0
func ReadCString(buf *bytes.Buffer) string {
	index := bytes.IndexByte(buf.Bytes(), 0)
	if index < 0 {
		panic(NewBsonError("Unexpected EOF"))
	}
	// Read including null termination, but
	// return the string without the null.
	return hack.String(buf.Next(index + 1)[:index])
}
Beispiel #29
0
func DecodeFloat64(buf *bytes.Buffer, kind byte) float64 {
	switch kind {
	case Number:
		return float64(math.Float64frombits(Pack.Uint64(buf.Next(8))))
	case Null:
		return 0
	}
	panic(NewBsonError("Unexpected data type %v for int", kind))
}
Beispiel #30
0
func DecodeInt32(buf *bytes.Buffer, kind byte) int32 {
	switch kind {
	case Int:
		return int32(Pack.Uint32(buf.Next(4)))
	case Null:
		return 0
	}
	panic(NewBsonError("Unexpected data type %v for int", kind))
}