Golang Reader.Read方法代码示例

// readBlob reads an OSC Blob from the blob byte array. Padding bytes are removed
// from the reader and not returned.
func readBlob(reader *bufio.Reader) (blob []byte, n int, err error) {
	// First, get the length
	var blobLen int
	if err = binary.Read(reader, binary.BigEndian, &blobLen); err != nil {
		return nil, 0, err
	}
	n = 4 + blobLen

	// Read the data
	blob = make([]byte, blobLen)
	if _, err = reader.Read(blob); err != nil {
		return nil, 0, err
	}

	// Remove the padding bytes
	numPadBytes := padBytesNeeded(blobLen)
	if numPadBytes > 0 {
		n += numPadBytes
		dummy := make([]byte, numPadBytes)
		if _, err = reader.Read(dummy); err != nil {
			return nil, 0, err
		}
	}

	return blob, n, nil
}

func (rb *ReaderBase) readBulk(r *bufio.Reader) (err error) {
	err = rb.readIneger(r)
	if err != nil {
		return
	}
	if rb.integer == -1 {
		rb.bulk = nil
		return
	}
	rb.bulk = make([]byte, rb.integer)

	n := 0
	written := 0

	for written < rb.integer {
		buf := make([]byte, rb.integer-written)
		n, err = r.Read(buf)
		if err != nil {
			return
		}

		if n > 0 {
			copy(rb.bulk[written:], buf[0:n])
			written += n
		}
	}
	err = rb.readCrLf(r)
	return
}

func handshake(client net.Conn, config *Config) (bouncer *BouncerConfig, remainder []byte) {
	// Setup a buffered reader over the client.
	var reader *bufio.Reader = bufio.NewReader(client)

	// Attempt to handshake with the client and determine the requested config.
	var match chan *BouncerConfig = make(chan *BouncerConfig, 1)
	go seekshake(reader, config, match)

	// Block until handshake is done or we hit our timeout.
	select {
	case bouncer = <-match:
		// Grab the remaining portion of the handshake.
		remainder = make([]byte, reader.Buffered())
		reader.Read(remainder)

		if bouncer != nil {
			log.Printf("LOGIN %s", client.RemoteAddr())
		} else {
			log.Printf("REJECT %s", client.RemoteAddr())
		}
		return bouncer, remainder
	case <-time.After(time.Duration(config.Auth.Timeout) * time.Second):
		log.Printf("TIMEOUT %s", client.RemoteAddr())
		return nil, []byte{}
	}
}

func (mcs *MemcacheServer) handleSet(addr string, reader *bufio.Reader, writer *bufio.Writer, args []string) {
	if len(args) > 6 || len(args) < 5 {
		writer.WriteString("ERROR\r\n")
		writer.Flush()
		return
	}
	// args[1] key
	// args[2] flags
	// args[3] exptime
	// args[4] bytes
	// args[5] noreply

	mcs.Logger.Debug("Memcache", "[%s] -> Set %s", addr, args)

	expirytime, err := strconv.Atoi(args[3])
	if err != nil {
		writer.WriteString("SERVER_ERROR\r\n")
		writer.Flush()
		return
	}

	flags, err := strconv.Atoi(args[2])
	flags = flags & 0xFFFF
	if err != nil {
		writer.WriteString("SERVER_ERROR\r\n")
		writer.Flush()
		return
	}

	bytes, err := strconv.Atoi(args[4])
	if err != nil {
		writer.WriteString("SERVER_ERROR\r\n")
		writer.Flush()
		return
	}

	var buf []byte = make([]byte, bytes, bytes)
	n, err := reader.Read(buf)
	if err != nil || n != len(buf) {
		writer.WriteString("SERVER_ERROR\r\n")
		writer.Flush()
		return
	}

	_, err = reader.ReadString('\n')
	if err != nil {
		writer.WriteString("SERVER_ERROR\r\n")
		writer.Flush()
		return
	}

	var expparam *time.Time = nil
	if expirytime != 0 {
		expiry := time.Now().UTC().Add(time.Duration(expirytime) * time.Second)
		expparam = &expiry
	}
	mcs.Server.SetKey(args[1], buf[:], int16(flags), expparam)
	writer.WriteString("STORED\r\n")
	writer.Flush()
}

func deserializeByReader(reader *bufio.Reader) (*pb.MobileSuiteProtobuf, error) {
	buff, _ := reader.Peek(4)
	data := bytes.NewBuffer(buff)
	var length int32
	err := binary.Read(data, binary.BigEndian, &length)
	if err != nil {
		return nil, err
	}
	fmt.Println(length)
	if int32(reader.Buffered()) < length+4 {
		return nil, err
	}

	pack := make([]byte, int(4+length))
	_, err = reader.Read(pack)
	if err != nil {
		return nil, err
	}
	msg := pack[4:]
	var dst pb.MobileSuiteProtobuf
	proto.Unmarshal(msg, &dst)
	fmt.Println(&dst)

	var testMsg pb.TestMessage
	proto.Unmarshal(dst.Message, &testMsg)
	fmt.Println(&testMsg)

	return &dst, nil
}

func readBodyIdentity(r *bufio.Reader, dst []byte) ([]byte, error) {
	dst = dst[:cap(dst)]
	if len(dst) == 0 {
		dst = make([]byte, 1024)
	}
	offset := 0
	for {
		nn, err := r.Read(dst[offset:])
		if nn <= 0 {
			if err != nil {
				if err == io.EOF {
					return dst[:offset], nil
				}
				return dst[:offset], err
			}
			panic(fmt.Sprintf("BUG: bufio.Read() returned (%d, nil)", nn))
		}
		offset += nn
		if len(dst) == offset {
			b := make([]byte, round2(2*offset))
			copy(b, dst)
			dst = b
		}
	}
}

func (cmd *cmdSync) PSyncPipeCopy(c net.Conn, br *bufio.Reader, bw *bufio.Writer, offset int64, copyto io.Writer) (int64, error) {
	defer c.Close()
	var nread atomic2.Int64
	go func() {
		defer c.Close()
		for {
			time.Sleep(time.Second * 5)
			if err := sendPSyncAck(bw, offset+nread.Get()); err != nil {
				return
			}
		}
	}()

	var p = make([]byte, 8192)
	for {
		n, err := br.Read(p)
		if err != nil {
			return nread.Get(), nil
		}
		if _, err := copyto.Write(p[:n]); err != nil {
			return nread.Get(), err
		}
		nread.Add(int64(n))
	}
}

// decodeP6 reads a binary pixmap
func decodeP6(r *bufio.Reader, img draw.Image, width, height uint) {
	var x, y, pix int

	mask := byte(readU(r))
	mul := 255 / mask
	data := make([]byte, width*height*3)

	space(r)

	_, err := r.Read(data)
	check(err)

	for y = 0; y < int(height); y++ {
		for x = 0; x < int(width); x++ {
			img.Set(x, y, color.RGBA{
				(data[pix] & mask) * mul,
				(data[pix+1] & mask) * mul,
				(data[pix+2] & mask) * mul,
				0xff,
			})

			pix += 3
		}
	}
}

func readSection(reader *bufio.Reader, readN int) ([]byte, error) {
	buf := make([]byte, readN)

	var err error
	n := 0
	for n < readN {
		m, err := reader.Read(buf[n:])
		if err != nil {
			break
		}
		n += m
	}

	if err != nil {
		return buf, err
	}

	end, err := reader.ReadString('\n')
	switch {
	case n != readN:
		return buf, io.ErrUnexpectedEOF
	case err == io.EOF:
		// That's ok
	case err != nil:
		return buf, err
	case end != "\r\n":
		return buf, errors.New("Unexpected end of section")
	}
	return buf, nil
}

//读取规定长度的数据
func (self LengthBasedFrameDecoder) Read(reader *bufio.Reader) (*bytes.Buffer, error) {
	var length int32

	err := Read(reader, b.BigEndian, &length)
	if nil != err {
		return nil, err
	} else if length <= 0 {
		return nil, errors.New("TOO SHORT PACKET")
	}

	if length > self.MaxFrameLength {
		return nil, errors.New("TOO LARGE PACKET!")
	}

	buff := make([]byte, int(length))
	tmp := buff
	l := 0
	for {
		rl, err := reader.Read(tmp)
		if nil != err {
			return nil, err
		}
		l += rl

		if l < int(length) {
			tmp = tmp[rl:]
			continue
		} else {
			break
		}
	}
	return bytes.NewBuffer(buff), nil
}

func readFile(path string) {
	var w *bufio.Writer = bufio.NewWriter(os.Stdout)
	defer w.Flush()

	fmt.Fprintf(w, "read file start: %s\n", path)

	file, err := os.OpenFile(path, os.O_RDONLY, 0666) // 打开文件

	if err != nil {
		fmt.Printf("open file err: %v\n", err)
		return
	}

	defer file.Close() // 延时关闭文件

	var buff []byte = make([]byte, 1024)
	var r *bufio.Reader = bufio.NewReader(file)

	for {
		n, _ := r.Read(buff)
		if n <= 0 {
			fmt.Fprintf(w, "read file end: %s %d\n", path, n)
			return
		}

		w.Write(buff[0:n])
	}
}

func appendBodyFixedSize(r *bufio.Reader, dst []byte, n int) ([]byte, error) {
	if n == 0 {
		return dst, nil
	}

	offset := len(dst)
	dstLen := offset + n
	if cap(dst) < dstLen {
		b := make([]byte, round2(dstLen))
		copy(b, dst)
		dst = b
	}
	dst = dst[:dstLen]

	for {
		nn, err := r.Read(dst[offset:])
		if nn <= 0 {
			if err != nil {
				if err == io.EOF {
					err = io.ErrUnexpectedEOF
				}
				return dst[:offset], err
			}
			panic(fmt.Sprintf("BUG: bufio.Read() returned (%d, nil)", nn))
		}
		offset += nn
		if offset == dstLen {
			return dst, nil
		}
	}
}

func readN(rd *bufio.Reader, n int) ([]byte, error) {
	// b, err := rd.ReadN(n)
	b := make([]byte, n)

	_, err := io.ReadFull(rd, b)
	if err == bufio.ErrBufferFull {
		tmp := make([]byte, n)
		r := copy(tmp, b)
		b = tmp

		for {
			nn, err := rd.Read(b[r:])
			r += nn
			if r >= n {
				// Ignore error if we read enough.
				break
			}
			if err != nil {
				return nil, err
			}
		}
	} else if err != nil {
		return nil, err
	}
	return b, nil
}

func (u *udpgwPacket) read(r *bufio.Reader) error {
	bs, err := r.Peek(2)
	if nil != err {
		return err
	}
	u.length = binary.LittleEndian.Uint16(bs)
	//binary.Read(r, binary.BigEndian, &u.length)
	r.Discard(2)
	//log.Printf("###First %d  %d %d %p", u.length, binary.BigEndian.Uint16(bs), len(bs), r)
	_, err = r.Peek(int(u.length))
	if nil != err {
		//log.Printf("### %v", err)
		return err
	}
	bodylen := u.length
	binary.Read(r, binary.BigEndian, &u.flags)
	binary.Read(r, binary.BigEndian, &u.conid)
	bodylen -= 3
	if bodylen > 0 {
		if (u.flags & flagIPv6) != 0 {
			u.addr.ip = make(net.IP, 16)

		} else {
			u.addr.ip = make(net.IP, 4)
		}
		r.Read(u.addr.ip)
		bodylen -= uint16(len(u.addr.ip))
		binary.Read(r, binary.BigEndian, &u.addr.port)
		bodylen -= 2
		u.content = make([]byte, int(bodylen))
		r.Read(u.content)
	}
	return nil
}

func readAndWriteTLS(r *bufio.Reader, w *bufio.Writer, con *tls.Conn, verbose bool) <-chan bool {
	c := make(chan bool)
	go func() {
		defer func() {
			(*con).Close()
			c <- false
		}()
		for {
			buf := make([]byte, 1024)
			message, errRead := r.Read(buf)
			if errRead != nil {
				if errRead != io.EOF {
					if verbose {
						log.Println("READ ERROR: ", errRead)
					}
				}
				break
			}
			_, errWrite := w.Write(buf[:message])
			w.Flush()
			if errWrite != nil {
				if verbose {
					log.Println("WRITE ERROR: ", errWrite)
				}
				return
			}
		}
	}()
	return c
}