Golang Buffer.Read方法代码示例

func MarshalPoint(pt abstract.Point) []byte {
	buf := new(bytes.Buffer)
	ptByte := make([]byte, SecretSize)
	pt.MarshalTo(buf)
	buf.Read(ptByte)
	return ptByte
}

func (s Servent) MessageWithCallback(message uint8, buffer *bytes.Buffer, callback Callback) (err error) {
	conn, err := net.Dial("tcp", s.Addr)
	if err != nil {
		return err
	}

	defer conn.Close()

	binary.Write(conn, binary.LittleEndian, message)
	binary.Write(conn, binary.LittleEndian, uint64(buffer.Len()))

	bytes := make([]byte, 2048)
	for {
		_, err := buffer.Read(bytes)
		if err == io.EOF {
			break
		}
		if err != nil {
			return err
		}
		binary.Write(conn, binary.LittleEndian, bytes)
	}

	if callback != nil {
		err = callback(conn)
		if err != nil {
			return err
		}
	}

	return nil
}

func newSourceChannel(cs *SourceChannel) error {
	f, err := os.Open("/dev/urandom")
	if err != nil {
		return err
	}
	buf := new(bytes.Buffer)
	io.CopyN(buf, f, 4096)
	f.Close()
	go func() {
		for {
			if buf.Len() == 0 {
				return
			}
			e := make([]byte, 24)
			_, err := buf.Read(e)
			if err != nil {
				fmt.Fprintf(os.Stderr, "tunafish: error on buffer (%v)\n", err)
				return

			}
			if cs.In == nil {
				return
			}
			cs.In <- e
			<-time.After(30 * time.Millisecond)
		}
	}()
	return nil
}

// Get next XML doc from an io.Reader as a Map value.  Returns Map value and pointer to raw XML.
//	NOTE: Due to the implementation of xml.Decoder, the raw XML off the reader is buffered to *[]byte
//	      using a ByteReader. If the io.Reader is an os.File, there may be significant performance impact.
//	      See the examples - getmetrics1.go through getmetrics4.go - for comparative use cases on a large
//	      data set. If the io.Reader is wrapping a []byte value in-memory, however, such as http.Request.Body
//	      you CAN use it to efficiently unmarshal an XML and retrieve the raw XML in a single call.
func NewMapXmlReaderRaw(xmlReader io.Reader, cast ...bool) (Map, *[]byte, error) {
	var r bool
	if len(cast) == 1 {
		r = cast[0]
	}
	// create TeeReader so we can retrieve raw XML
	wb := new(bytes.Buffer)
	trdr := myTeeReader(xmlReader, wb) // see code at EOF

	// build the node tree
	n, err := xmlReaderToTree(trdr)

	// retrieve the raw XML that was decoded
	b := make([]byte, wb.Len())
	_, _ = wb.Read(b)

	if err != nil {
		return nil, &b, err
	}

	// create the Map value
	m := make(map[string]interface{})
	m[n.key] = n.treeToMap(r)

	return m, &b, nil
}

func (a *OfpActionVendorPort) Read(b []byte) (n int, err error) {
	a.Length = a.Len()
	buf := new(bytes.Buffer)
	err = binary.Write(buf, binary.BigEndian, a)
	n, err = buf.Read(b)
	return
}

// Writer implements io.Writer, this function encodes a message  using
// crypto.nacl.box.Seal, then prepends a random generated nonce to it,
// and writes it to s.w encoded using binary.Write
func (s SecureWriter) Write(message []byte) (n int, err error) {
	if len(message) > MAX_BYTE_LENGTH {
		return 0, errors.New("The data to be encoded is to big")
	}

	nonce := GenerateNonce()

	// Use box.Seal to encode the data
	var out []byte
	encText := box.Seal(out, message, &nonce, s.pub, s.priv)

	// The nonce will be preceding the binary data of the message
	binaryData := append(nonce[:], encText...)

	// Encode the nonce + encodedMsg using binary.Write
	buf := new(bytes.Buffer)
	err = binary.Write(buf, binary.LittleEndian, binaryData)

	// Get the size of encoded data and prepend it in format [2]byte
	size := uint16(buf.Len())
	dataSize := make([]byte, 2)
	binary.LittleEndian.PutUint16(dataSize, size)

	data := make([]byte, size)
	n, err = buf.Read(data)

	data = append(dataSize, data...)

	// Data will be:
	// |length [2]byte| binary encoded data [length]byte
	n, err = s.w.Write(data)
	return n, err
}

func getFcgiOutput(br *bytes.Buffer) *bytes.Buffer {
	var output bytes.Buffer
	for {
		var h fcgiHeader
		err := binary.Read(br, binary.BigEndian, &h)
		if err == os.EOF {
			break
		}

		content := make([]byte, h.ContentLength)
		br.Read(content)

		//read padding
		if h.PaddingLength > 0 {
			padding := make([]byte, h.PaddingLength)
			br.Read(padding)
		}

		if h.Type == fcgiStdout {
			output.Write(content)
		}
	}

	return &output
}

func (f *OFFlowMod) Read(b []byte) (n int, err error) {

	f.Header.Length = f.ComputeLength()
	buf := new(bytes.Buffer)
	buf.ReadFrom(f.Header)
	//	fmt.Println("FlowMod Read1: Header: ", buf.Bytes())
	buf.ReadFrom(f.OFMatch)
	//	fmt.Println("FlowMod Read2: Match: ", buf.Bytes())
	binary.Write(buf, binary.BigEndian, f.Cookie)
	//	fmt.Println("FlowMod Read3: Cookie: ", buf.Bytes())
	binary.Write(buf, binary.BigEndian, f.Command)
	binary.Write(buf, binary.BigEndian, f.IdleTimeout)
	binary.Write(buf, binary.BigEndian, f.HardTimeout)
	binary.Write(buf, binary.BigEndian, f.Priority)
	binary.Write(buf, binary.BigEndian, f.BufferID)
	binary.Write(buf, binary.BigEndian, f.OutPort)
	binary.Write(buf, binary.BigEndian, f.Flags)
	binary.Write(buf, binary.BigEndian, f.Action.Type)
	binary.Write(buf, binary.BigEndian, f.Action.Length)
	binary.Write(buf, binary.BigEndian, f.Action.Port)
	binary.Write(buf, binary.BigEndian, f.Action.MaxLen)

	//	fmt.Println("FlowMod Read4: all: ", buf.Bytes())

	n, err = buf.Read(b)
	if err != nil {
		return
	}
	return n, io.EOF
}

func decodeAmf0Utf8(buffer *bytes.Buffer) (v string, err error) {
	// len
	var length int16
	if err = binary.Read(buffer, binary.BigEndian, &length); err != nil {
		err = Amf0StringLengthRead
		return
	}

	// empty string
	if length <= 0 {
		return
	}

	// data
	data := make([]byte, length)
	if _, err = buffer.Read(data); err != nil {
		err = Amf0StringDataRead
		return
	}

	// support utf8-1 only
	// 1.3.1 Strings and UTF-8
	// UTF8-1 = %x00-7F
	// TODO: support other utf-8 strings

	v = string(data)

	return
}

func (hq *HashQuery) Parse() error {
	// Require HTTP POST
	if hq.Method != "POST" {
		return ErrorInvalidMethod(hq.Method)
	}
	hq.responseChan = make(ResponseChan)
	var body *bytes.Buffer
	{
		defer hq.Body.Close()
		buf, err := ioutil.ReadAll(hq.Body)
		if err != nil {
			return err
		}
		body = bytes.NewBuffer(buf)
	}
	// Parse hashquery POST data
	n, err := recon.ReadInt(body)
	if err != nil {
		return err
	}
	hq.Digests = make([]string, n)
	for i := 0; i < n; i++ {
		hashlen, err := recon.ReadInt(body)
		if err != nil {
			return err
		}
		hash := make([]byte, hashlen)
		_, err = body.Read(hash)
		if err != nil {
			return err
		}
		hq.Digests[i] = hex.EncodeToString(hash)
	}
	return nil
}

func (a *ActionEnqueue) Read(b []byte) (n int, err error) {
	buf := new(bytes.Buffer)
	if err = binary.Write(buf, binary.BigEndian, a.Type); err != nil {
		return
	}
	n += 2
	if err = binary.Write(buf, binary.BigEndian, a.Length); err != nil {
		return
	}
	n += 2
	if err = binary.Write(buf, binary.BigEndian, a.Port); err != nil {
		return
	}
	n += 2
	if err = binary.Write(buf, binary.BigEndian, a.pad); err != nil {
		return
	}
	n += 6
	if err = binary.Write(buf, binary.BigEndian, a.QueueID); err != nil {
		return
	}
	n += 4
	if n, err = buf.Read(b); n == 0 {
		return
	}
	return n, io.EOF
}

func (tags *EventHeaderTags) Decode(buffer *bytes.Buffer) bool {
	b := make([]byte, 2)
	realLen, err := buffer.Read(b)
	if err != nil || realLen != 2 {
		return false
	}
	tags.magic = binary.BigEndian.Uint16(b)
	if tags.magic != MAGIC_NUMBER {
		return false
	}
	if token, ok := DecodeStringValue(buffer); nil == ok {
		ss := strings.Split(token, _splitter)
		if len(ss) > 1 {
			tags.Token = ss[1]
			tags.UserToken = ss[0]
		} else if len(ss) == 1 {
			tags.Token = token
		} else {
			return false
		}
	} else {
		return false
	}
	return true
}

func (m *OfpMatch) Read(b []byte) (n int, err error) {
	// Any non-zero value fields should not be wildcarded.
	if m.InPort != 0 {
		m.Wildcards = m.Wildcards ^ OFPFW_IN_PORT
	}
	if m.DLSrc.String() != "00:00:00:00:00:00" {
		m.Wildcards = m.Wildcards ^ OFPFW_DL_SRC
	}
	if m.DLDst.String() != "00:00:00:00:00:00" {
		m.Wildcards = m.Wildcards ^ OFPFW_DL_DST
	}
	if m.DLVLAN != 0 {
		m.Wildcards = m.Wildcards ^ OFPFW_DL_VLAN
	}
	if m.DLVLANPcp != 0 {
		m.Wildcards = m.Wildcards ^ OFPFW_DL_VLAN_PCP
	}
	if m.DLType != 0 {
		m.Wildcards = m.Wildcards ^ OFPFW_DL_TYPE
	}
	if m.NWTos != 0 {
		m.Wildcards = m.Wildcards ^ OFPFW_NW_TOS
	}
	if m.NWProto != 0 {
		m.Wildcards = m.Wildcards ^ OFPFW_NW_PROTO
	}
	if m.NWSrc.String() != "0.0.0.0" {
		m.Wildcards = m.Wildcards ^ OFPFW_NW_SRC_ALL
	}
	if m.NWDst.String() != "0.0.0.0" {
		m.Wildcards = m.Wildcards ^ OFPFW_NW_DST_ALL
	}
	if m.TPSrc != 0 {
		m.Wildcards = m.Wildcards ^ OFPFW_TP_SRC
	}
	if m.TPDst != 0 {
		m.Wildcards = m.Wildcards ^ OFPFW_TP_DST
	}
	buf := new(bytes.Buffer)
	binary.Write(buf, binary.BigEndian, m.Wildcards)
	binary.Write(buf, binary.BigEndian, m.InPort)
	binary.Write(buf, binary.BigEndian, m.DLSrc)
	binary.Write(buf, binary.BigEndian, m.DLDst)
	binary.Write(buf, binary.BigEndian, m.DLVLAN)
	binary.Write(buf, binary.BigEndian, m.DLVLANPcp)
	binary.Write(buf, binary.BigEndian, m.Pad)
	binary.Write(buf, binary.BigEndian, m.DLType)
	binary.Write(buf, binary.BigEndian, m.NWTos)
	binary.Write(buf, binary.BigEndian, m.NWProto)
	binary.Write(buf, binary.BigEndian, m.Pad1)
	binary.Write(buf, binary.BigEndian, m.NWSrc)
	binary.Write(buf, binary.BigEndian, m.NWDst)
	binary.Write(buf, binary.BigEndian, m.TPSrc)
	binary.Write(buf, binary.BigEndian, m.TPDst)
	n, err = buf.Read(b)
	if n == 0 {
		return
	}
	return n, io.EOF
}

func TestExtOrPortSendTransport(t *testing.T) {
	tests := [...]struct {
		methodName string
		expected   []byte
	}{
		{"", []byte("\x00\x02\x00\x00")},
		{"a", []byte("\x00\x02\x00\x01a")},
		{"alpha", []byte("\x00\x02\x00\x05alpha")},
	}

	for _, test := range tests {
		var buf bytes.Buffer
		err := extOrPortSendTransport(&buf, test.methodName)
		if err != nil {
			t.Errorf("%q unexpectedly returned an error: %s", test.methodName, err)
		}
		p := make([]byte, 1024)
		n, err := buf.Read(p)
		if err != nil {
			t.Fatal(err)
		}
		output := p[:n]
		if !bytes.Equal(output, test.expected) {
			t.Errorf("%q → %s (expected %s)", test.methodName,
				fmtBytes(output), fmtBytes(test.expected))
		}
	}
}

func (t *Connection) submitResp(seq uint32, buf *bytes.Buffer) (
	err error) {
	_, err = t.getContext(seq)
	if err != nil {
		glog.Error(err)
		return
	}
	// MsgID 10 octetString
	msgID := make([]byte, 10)
	_, err = buf.Read(msgID)
	if err != nil {
		return
	}
	// status
	var status uint32
	err = binary.Read(buf, binary.BigEndian, &status)
	if err != nil {
		return
	}
	if status != STATUS_OK {
		err = fmt.Errorf("Submit seq %d failed, status = %d", seq, status)
	}
	glog.Infof("Submit seq %d MsgID 0x%x", seq, msgID)
	return
}