func io.ReadFull

132 uses

	io (current package)
		io.go#L346: func ReadFull(r Reader, buf []byte) (n int, err error) {

	archive/zip
		reader.go#L270: 	if _, err := io.ReadFull(r, buf[:]); err != nil {
		reader.go#L295: 	if _, err := io.ReadFull(r, d); err != nil {
		reader.go#L451: 	if _, err := io.ReadFull(r, buf[:4]); err != nil {
		reader.go#L461: 	if _, err := io.ReadFull(r, buf[off:12]); err != nil {

	compress/flate
		inflate.go#L629: 	nr, err := io.ReadFull(f.r, f.buf[0:4])
		inflate.go#L660: 	cnt, err := io.ReadFull(f.r, buf)

	compress/gzip
		gunzip.go#L175: 	if _, err = io.ReadFull(z.r, z.buf[:10]); err != nil {
		gunzip.go#L199: 		if _, err = io.ReadFull(z.r, z.buf[:2]); err != nil {
		gunzip.go#L204: 		if _, err = io.ReadFull(z.r, data); err != nil {
		gunzip.go#L227: 		if _, err = io.ReadFull(z.r, z.buf[:2]); err != nil {
		gunzip.go#L260: 	if _, err := io.ReadFull(z.r, z.buf[:8]); err != nil {

	compress/zlib
		reader.go#L102: 	if _, err := io.ReadFull(z.r, z.scratch[0:4]); err != nil {
		reader.go#L138: 	_, z.err = io.ReadFull(z.r, z.scratch[0:2])
		reader.go#L152: 		_, z.err = io.ReadFull(z.r, z.scratch[0:4])

	crypto/dsa
		dsa.go#L100: 		if _, err := io.ReadFull(rand, qBytes); err != nil {
		dsa.go#L113: 			if _, err := io.ReadFull(rand, pBytes); err != nil {
		dsa.go#L168: 		_, err := io.ReadFull(rand, xBytes)
		dsa.go#L222: 			_, err = io.ReadFull(rand, buf)

	crypto/ecdsa
		ecdsa.go#L136: 	_, err = io.ReadFull(rand, b)
		ecdsa.go#L209: 	_, err = io.ReadFull(rand, entropy)

	crypto/ed25519
		ed25519.go#L104: 	if _, err := io.ReadFull(rand, seed); err != nil {

	crypto/elliptic
		elliptic.go#L292: 		_, err = io.ReadFull(rand, priv)

	crypto/rand
		rand.go#L24: 	return io.ReadFull(Reader, b)
		rand_unix.go#L130: 			_, err := io.ReadFull(r.entropy, r.seed[0:])
		rand_unix.go#L134: 			_, err = io.ReadFull(r.entropy, r.key[0:])
		util.go#L48: 		_, err = io.ReadFull(rand, bytes)
		util.go#L129: 		_, err = io.ReadFull(rand, bytes)

	crypto/rsa
		pkcs1v15.go#L179: 	_, err = io.ReadFull(rand, s)
		pkcs1v15.go#L186: 			_, err = io.ReadFull(rand, s[i:i+1])
		pss.go#L278: 	if _, err := io.ReadFull(rand, salt); err != nil {
		rsa.go#L167: 			if _, err := io.ReadFull(rand, plaintext); err != nil {
		rsa.go#L432: 	_, err := io.ReadFull(random, seed)

	crypto/tls
		common.go#L805: 		if _, err := io.ReadFull(c.rand(), c.SessionTicketKey[:]); err != nil {
		common.go#L867: 		if _, err := io.ReadFull(c.rand(), newKey[:]); err != nil {
		conn.go#L484: 			if _, err := io.ReadFull(rand, explicitNonce); err != nil {
		handshake_client.go#L103: 	_, err := io.ReadFull(config.rand(), hello.random)
		handshake_client.go#L111: 	if _, err := io.ReadFull(config.rand(), hello.sessionId); err != nil {
		handshake_server.go#L199: 	_, err := io.ReadFull(c.config.rand(), serverRandom)
		handshake_server_tls13.go#L126: 	if _, err := io.ReadFull(c.config.rand(), hs.hello.random); err != nil {
		key_agreement.go#L65: 	_, err := io.ReadFull(config.rand(), preMasterSecret[2:])
		key_schedule.go#L115: 		if _, err := io.ReadFull(rand, privateKey); err != nil {
		ticket.go#L129: 	if _, err := io.ReadFull(c.config.rand(), iv); err != nil {

	crypto/x509
		pem_decrypt.go#L202: 	if _, err := io.ReadFull(rand, iv); err != nil {

	encoding/binary
		binary.go#L166: 		if _, err := io.ReadFull(r, bs); err != nil {
		binary.go#L256: 	if _, err := io.ReadFull(r, d.buf); err != nil {

	encoding/gob
		decode.go#L120: 	n, err := io.ReadFull(r, buf[0:width])
		decode.go#L133: 	width, err = io.ReadFull(r, buf[0:n])
		decoder.go#L102: 	_, dec.err = io.ReadFull(dec.r, dec.buf.Bytes())

	fmt
		scan.go#L321: 	n, err := io.ReadFull(r.reader, r.pendBuf[:1])

	github.com/go-git/go-git/v5/plumbing/format/idxfile
		decoder.go#L61: 	if _, err := io.ReadFull(r, h); err != nil {
		decoder.go#L117: 		if _, err := io.ReadFull(r, bin); err != nil {
		decoder.go#L132: 			if _, err := io.ReadFull(r, idx.CRC32[pos]); err != nil {
		decoder.go#L145: 			if _, err := io.ReadFull(r, idx.Offset32[pos]); err != nil {
		decoder.go#L159: 		if _, err := io.ReadFull(r, idx.Offset64); err != nil {
		decoder.go#L168: 	if _, err := io.ReadFull(r, idx.PackfileChecksum[:]); err != nil {
		decoder.go#L172: 	if _, err := io.ReadFull(r, idx.IdxChecksum[:]); err != nil {

	github.com/go-git/go-git/v5/plumbing/format/index
		decoder.go#L191: 	_, err := io.ReadFull(d.r, name[:])
		decoder.go#L221: 		if n, err = io.ReadFull(d.r, header[:]); err != nil {
		decoder.go#L298: 	if _, err := io.ReadFull(d.r, h[4:]); err != nil {
		decoder.go#L311: 	if _, err := io.ReadFull(r, s); err != nil {
		decoder.go#L392: 	_, err = io.ReadFull(d.r, e.Hash[:])
		decoder.go#L436: 		if _, err := io.ReadFull(d.r, hash[:]); err != nil {
		decoder.go#L475: 	_, err = io.ReadFull(d.r, e.Hash[:])

	github.com/go-git/go-git/v5/plumbing/format/packfile
		packfile.go#L443: 	if _, err := io.ReadFull(p.file, hash[:]); err != nil {
		scanner.go#L120: 	if _, err := io.ReadFull(s.r, sig); err != nil {

	github.com/go-git/go-git/v5/plumbing/format/pktline
		scanner.go#L64: 	if _, s.err = io.ReadFull(s.r, s.payload[:l]); s.err != nil {
		scanner.go#L82: 	if _, err := io.ReadFull(s.r, s.len[:]); err != nil {

	github.com/go-git/go-git/v5/plumbing/object
		rename.go#L601: 				cnt, err = io.ReadFull(r, buf)
		tree.go#L258: 		if _, err = io.ReadFull(r, hash[:]); err != nil {

	github.com/go-git/go-git/v5/utils/binary
		read.go#L35: 		if _, err := io.ReadFull(r, buf[:]); err != nil {

	github.com/go-redis/redis/v8/internal/proto
		reader.go#L157: 	_, err = io.ReadFull(r.rd, b)
		reader.go#L282: 	_, err = io.ReadFull(r.rd, buf)

	github.com/jackc/pgconn
		pgconn.go#L335: 	if _, err = io.ReadFull(pgConn.conn, response); err != nil {

	github.com/lib/pq
		conn.go#L936: 	_, err := io.ReadFull(cn.buf, x)
		conn.go#L950: 	_, err = io.ReadFull(cn.buf, y)
		conn.go#L1028: 	_, err = io.ReadFull(cn.c, b)

	github.com/matttproud/golang_protobuf_extensions/pbutil
		decode.go#L68: 	newBytesRead, err := io.ReadFull(r, messageBuf)

	golang.org/x/crypto/openpgp
		write.go#L323: 	if _, err := io.ReadFull(config.Random(), symKey); err != nil {

	golang.org/x/crypto/openpgp/elgamal
		elgamal.go#L109: 	_, err = io.ReadFull(rand, s)
		elgamal.go#L116: 			_, err = io.ReadFull(rand, s[i:i+1])

	golang.org/x/crypto/openpgp/packet
		packet.go#L26: 	n, err = io.ReadFull(r, buf)
		packet.go#L197: 	_, err = io.ReadFull(r, buf[:1])
		symmetric_key_encrypted.go#L139: 	_, err = io.ReadFull(config.Random(), sessionKey)

	golang.org/x/crypto/openpgp/s2k
		s2k.go#L159: 	_, err = io.ReadFull(r, buf[:2])
		s2k.go#L180: 		_, err = io.ReadFull(r, buf[:8])
		s2k.go#L189: 		_, err = io.ReadFull(r, buf[:9])
		s2k.go#L212: 	if _, err := io.ReadFull(rand, salt); err != nil {

	golang.org/x/crypto/ssh
		certs.go#L421: 	if _, err := io.ReadFull(rand, c.Nonce); err != nil {
		cipher.go#L153: 	if _, err := io.ReadFull(r, s.prefix[:]); err != nil {
		cipher.go#L198: 	if _, err := io.ReadFull(r, s.packetData); err != nil {
		cipher.go#L244: 	if _, err := io.ReadFull(rand, padding); err != nil {
		cipher.go#L351: 	if _, err := io.ReadFull(rand, c.buf[1+len(packet):]); err != nil {
		cipher.go#L373: 	if _, err := io.ReadFull(r, c.prefix[:]); err != nil {
		cipher.go#L387: 	if _, err := io.ReadFull(r, c.buf); err != nil {
		cipher.go#L510: 	if _, err := io.ReadFull(r, firstBlock); err != nil {
		cipher.go#L554: 	n, err := io.ReadFull(r, c.packetData[firstBlockLength:])
		cipher.go#L612: 	if _, err := io.ReadFull(rand, p); err != nil {
		cipher.go#L675: 	if _, err := io.ReadFull(r, encryptedLength); err != nil {
		cipher.go#L700: 	if _, err := io.ReadFull(r, c.buf[4:packetEnd]); err != nil {
		cipher.go#L766: 	if _, err := io.ReadFull(rand, c.buf[5+len(payload):packetEnd]); err != nil {
		handshake.go#L456: 	io.ReadFull(rand.Reader, msg.Cookie[:])
		kex.go#L428: 	if _, err := io.ReadFull(rand, kp.priv[:]); err != nil {
		transport.go#L317: 		_, err := io.ReadFull(r, buf[:])

	golang.org/x/crypto/ssh/agent
		client.go#L347: 	if _, err = io.ReadFull(c.conn, respSizeBuf[:]); err != nil {
		client.go#L356: 	if _, err = io.ReadFull(c.conn, buf); err != nil {
		server.go#L540: 		if _, err := io.ReadFull(c, length[:]); err != nil {
		server.go#L553: 		if _, err := io.ReadFull(c, req); err != nil {

	golang.org/x/net/http2
		frame.go#L237: 	_, err := io.ReadFull(r, buf[:frameHeaderLen])
		frame.go#L500: 	if _, err := io.ReadFull(fr.r, payload); err != nil {
		server.go#L965: 		if _, err := io.ReadFull(sc.conn, buf); err != nil {

	golang.org/x/net/internal/socks
		client.go#L68: 	if _, ctxErr = io.ReadFull(c, b[:2]); ctxErr != nil {
		client.go#L109: 	if _, ctxErr = io.ReadFull(c, b[:4]); ctxErr != nil {
		client.go#L131: 		if _, err := io.ReadFull(c, b[:1]); err != nil {
		client.go#L143: 	if _, ctxErr = io.ReadFull(c, b); ctxErr != nil {
		socks.go#L305: 		if _, err := io.ReadFull(rw, b[:2]); err != nil {

	google.golang.org/grpc/internal/transport
		http2_server.go#L267: 	if _, err := io.ReadFull(t.conn, preface); err != nil {
		transport.go#L466: 	return io.ReadFull(s.trReader, p)

	mime/multipart
		writer.go#L86: 	_, err := io.ReadFull(rand.Reader, buf[:])

	net
		dnsclient_unix.go#L112: 	if _, err := io.ReadFull(c, b[:2]); err != nil {
		dnsclient_unix.go#L119: 	n, err := io.ReadFull(c, b[:l])
		parse.go#L55: 		n, err := io.ReadFull(f.file, f.data[ln:cap(f.data)])

	net/http
		fs.go#L239: 			n, _ := io.ReadFull(content, buf[:])
		h2_bundle.go#L1477: 	_, err := io.ReadFull(r, buf[:http2frameHeaderLen])
		h2_bundle.go#L1743: 	if _, err := io.ReadFull(fr.r, payload); err != nil {
		h2_bundle.go#L4536: 		if _, err := io.ReadFull(sc.conn, buf); err != nil {
		socks_bundle.go#L74: 	if _, ctxErr = io.ReadFull(c, b[:2]); ctxErr != nil {
		socks_bundle.go#L115: 	if _, ctxErr = io.ReadFull(c, b[:4]); ctxErr != nil {
		socks_bundle.go#L137: 		if _, err := io.ReadFull(c, b[:1]); err != nil {
		socks_bundle.go#L149: 	if _, ctxErr = io.ReadFull(c, b); ctxErr != nil {
		socks_bundle.go#L461: 		if _, err := io.ReadFull(rw, b[:2]); err != nil {

	net/http/internal
		chunked.go#L79: 			if _, cr.err = io.ReadFull(cr.r, cr.buf[:2]); cr.err == nil {