type io.Reader
350 uses
io (current package)
io.go#L86: type Reader interface {
io.go#L132: Reader
io.go#L138: Reader
io.go#L150: Reader
io.go#L157: Reader
io.go#L164: Reader
io.go#L177: Reader
io.go#L190: ReadFrom(r Reader) (n int64, err error)
io.go#L329: func ReadAtLeast(r Reader, buf []byte, min int) (n int, err error) {
io.go#L353: func ReadFull(r Reader, buf []byte) (n int, err error) {
io.go#L363: func CopyN(dst Writer, src Reader, n int64) (written int64, err error) {
io.go#L387: func Copy(dst Writer, src Reader) (written int64, err error) {
io.go#L398: func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
io.go#L407: func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
io.go#L461: func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
io.go#L468: R Reader // underlying reader
io.go#L618: func TeeReader(r Reader, w Writer) Reader {
io.go#L623: r Reader
io.go#L662: func (discard) ReadFrom(r Reader) (n int64, err error) {
io.go#L682: func NopCloser(r Reader) ReadCloser {
io.go#L690: Reader
io.go#L696: Reader
io.go#L709: func ReadAll(r Reader) ([]byte, error) {
multi.go#L14: readers []Reader
multi.go#L73: func MultiReader(readers ...Reader) Reader {
multi.go#L74: r := make([]Reader, len(readers))
bufio
bufio.go#L37: rd io.Reader // reader provided by the client
bufio.go#L50: func NewReaderSize(rd io.Reader, size int) *Reader {
bufio.go#L62: func NewReader(rd io.Reader) *Reader {
bufio.go#L74: func (b *Reader) Reset(r io.Reader) {
bufio.go#L87: func (b *Reader) reset(buf []byte, r io.Reader) {
bufio.go#L784: func (b *Writer) ReadFrom(r io.Reader) (n int64, err error) {
scan.go#L30: r io.Reader // The reader provided by the client.
scan.go#L89: func NewScanner(r io.Reader) *Scanner {
bytes
buffer.go#L224: func (b *Buffer) ReadFrom(r io.Reader) (n int64, err error) {
compress/flate
inflate.go#L74: Reset(r io.Reader, dict []byte) error
inflate.go#L262: io.Reader
inflate.go#L750: func (f *decompressor) makeReader(r io.Reader) {
inflate.go#L786: func (f *decompressor) Reset(r io.Reader, dict []byte) error {
inflate.go#L807: func NewReader(r io.Reader) io.ReadCloser {
inflate.go#L826: func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser {
compress/gzip
gunzip.go#L92: func NewReader(r io.Reader) (*Reader, error) {
gunzip.go#L103: func (z *Reader) Reset(r io.Reader) error {
compress/zlib
reader.go#L64: Reset(r io.Reader, dict []byte) error
reader.go#L74: func NewReader(r io.Reader) (io.ReadCloser, error) {
reader.go#L83: func NewReaderDict(r io.Reader, dict []byte) (io.ReadCloser, error) {
reader.go#L133: func (z *reader) Reset(r io.Reader, dict []byte) error {
crypto
crypto.go#L198: Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)
crypto.go#L215: SignMessage(rand io.Reader, msg []byte, opts SignerOpts) (signature []byte, err error)
crypto.go#L237: Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error)
crypto.go#L245: func SignMessage(signer Signer, rand io.Reader, msg []byte, opts SignerOpts) (signature []byte, err error) {
crypto/cipher
io.go#L16: R io.Reader
crypto/dsa
dsa.go#L66: func GenerateParameters(params *Parameters, rand io.Reader, sizes ParameterSizes) error {
dsa.go#L164: func GenerateKey(priv *PrivateKey, rand io.Reader) error {
dsa.go#L218: func Sign(random io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
crypto/ecdh
ecdh.go#L24: GenerateKey(rand io.Reader) (*PrivateKey, error)
nist.go#L19: generate func(io.Reader) (*ecdh.PrivateKey, error)
nist.go#L29: func (c *nistCurve) GenerateKey(r io.Reader) (*PrivateKey, error) {
nist.go#L169: generate: func(r io.Reader) (*ecdh.PrivateKey, error) {
nist.go#L192: generate: func(r io.Reader) (*ecdh.PrivateKey, error) {
nist.go#L215: generate: func(r io.Reader) (*ecdh.PrivateKey, error) {
x25519.go#L37: func (c *x25519Curve) GenerateKey(r io.Reader) (*PrivateKey, error) {
crypto/ecdsa
ecdsa.go#L323: func (priv *PrivateKey) Sign(random io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) {
ecdsa.go#L336: func GenerateKey(c elliptic.Curve, r io.Reader) (*PrivateKey, error) {
ecdsa.go#L362: func generateFIPS[P ecdsa.Point[P]](curve elliptic.Curve, c *ecdsa.Curve[P], rand io.Reader) (*PrivateKey, error) {
ecdsa.go#L382: func SignASN1(r io.Reader, priv *PrivateKey, hash []byte) ([]byte, error) {
ecdsa.go#L408: func signFIPS[P ecdsa.Point[P]](c *ecdsa.Curve[P], priv *PrivateKey, rand io.Reader, hash []byte) ([]byte, error) {
ecdsa_legacy.go#L22: func generateLegacy(c elliptic.Curve, rand io.Reader) (*PrivateKey, error) {
ecdsa_legacy.go#L69: func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
ecdsa_legacy.go#L88: func signLegacy(priv *PrivateKey, csprng io.Reader, hash []byte) (sig []byte, err error) {
ecdsa_legacy.go#L205: func randFieldElement(c elliptic.Curve, rand io.Reader) (k *big.Int, err error) {
crypto/ed25519
ed25519.go#L97: func (priv PrivateKey) Sign(rand io.Reader, message []byte, opts crypto.SignerOpts) (signature []byte, err error) {
ed25519.go#L151: func GenerateKey(random io.Reader) (PublicKey, PrivateKey, error) {
crypto/elliptic
elliptic.go#L75: func GenerateKey(curve Curve, rand io.Reader) (priv []byte, x, y *big.Int, err error) {
crypto/internal/fips140/drbg
rand.go#L81: var testingReader io.Reader
rand.go#L88: func SetTestingReader(r io.Reader) {
rand.go#L102: func ReadWithReader(r io.Reader, b []byte) error {
crypto/internal/fips140/ecdh
ecdh.go#L139: func GenerateKey[P Point[P]](c *Curve[P], rand io.Reader) (*PrivateKey, error) {
crypto/internal/fips140/ecdsa
ecdsa.go#L199: func GenerateKey[P Point[P]](c *Curve[P], rand io.Reader) (*PrivateKey, error) {
ecdsa.go#L281: func Sign[P Point[P], H hash.Hash](c *Curve[P], h func() H, priv *PrivateKey, rand io.Reader, hash []byte) (*Signature, error) {
crypto/internal/fips140/rsa
keygen.go#L17: func GenerateKey(rand io.Reader, bits int) (*PrivateKey, error) {
keygen.go#L181: func randomPrime(rand io.Reader, bits int) ([]byte, error) {
pkcs1v22.go#L269: func SignPSS(rand io.Reader, priv *PrivateKey, hash hash.Hash, hashed []byte, saltLength int) ([]byte, error) {
pkcs1v22.go#L373: func EncryptOAEP(hash, mgfHash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error) {
crypto/internal/fips140only
fips140only.go#L32: func ApprovedRandomReader(r io.Reader) bool {
crypto/internal/rand
rand.go#L36: var Reader io.Reader = reader{}
rand.go#L46: func SetTestingReader(r io.Reader) {
rand.go#L56: func CustomReader(r io.Reader) io.Reader {
rand.go#L70: func IsDefaultReader(r io.Reader) bool {
rand_fips140v1.26.go#L14: func fips140SetTestingReader(r io.Reader) {
crypto/internal/randutil
randutil.go#L20: func MaybeReadByte(r io.Reader) {
crypto/rand
rand.go#L34: var Reader io.Reader = rand.Reader
util.go#L21: func Prime(r io.Reader, bits int) (*big.Int, error) {
util.go#L71: func Int(rand io.Reader, max *big.Int) (n *big.Int, err error) {
crypto/rsa
fips.go#L65: func SignPSS(random io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error) {
fips.go#L194: func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error) {
fips.go#L205: func EncryptOAEPWithOptions(random io.Reader, pub *PublicKey, msg []byte, opts *OAEPOptions) ([]byte, error) {
fips.go#L212: func encryptOAEP(hash hash.Hash, mgfHash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error) {
fips.go#L262: func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) ([]byte, error) {
fips.go#L321: func SignPKCS1v15(random io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error) {
pkcs1v15.go#L50: func EncryptPKCS1v15(random io.Reader, pub *PublicKey, msg []byte) ([]byte, error) {
pkcs1v15.go#L113: func DecryptPKCS1v15(random io.Reader, priv *PrivateKey, ciphertext []byte) ([]byte, error) {
pkcs1v15.go#L181: func DecryptPKCS1v15SessionKey(random io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error {
pkcs1v15.go#L270: func nonZeroRandomBytes(s []byte, random io.Reader) (err error) {
rsa.go#L161: func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) {
rsa.go#L172: func (priv *PrivateKey) Decrypt(rand io.Reader, ciphertext []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error) {
rsa.go#L312: func GenerateKey(random io.Reader, bits int) (*PrivateKey, error) {
rsa.go#L429: func GenerateMultiPrimeKey(random io.Reader, nprimes int, bits int) (*PrivateKey, error) {
crypto/tls
common.go#L571: Rand io.Reader
common.go#L1167: func (c *Config) rand() io.Reader {
conn.go#L479: func (hc *halfConn) encrypt(record, payload []byte, rand io.Reader) ([]byte, error) {
conn.go#L807: R io.Reader
conn.go#L828: func (c *Conn) readFromUntil(r io.Reader, n int) error {
key_agreement.go#L381: func generateECDHEKey(rand io.Reader, curveID CurveID) (*ecdh.PrivateKey, error) {
key_schedule.go#L66: keyShares(rand io.Reader) (*keySharePrivateKeys, []keyShare, error)
key_schedule.go#L69: serverSharedSecret(rand io.Reader, clientKeyShare []byte) ([]byte, keyShare, error)
key_schedule.go#L120: func (ke *ecdhKeyExchange) keyShares(rand io.Reader) (*keySharePrivateKeys, []keyShare, error) {
key_schedule.go#L128: func (ke *ecdhKeyExchange) serverSharedSecret(rand io.Reader, clientKeyShare []byte) ([]byte, keyShare, error) {
key_schedule.go#L168: func (ke *hybridKeyExchange) keyShares(rand io.Reader) (*keySharePrivateKeys, []keyShare, error) {
key_schedule.go#L200: func (ke *hybridKeyExchange) serverSharedSecret(rand io.Reader, clientKeyShare []byte) ([]byte, keyShare, error) {
crypto/x509
pem_decrypt.go#L195: func EncryptPEMBlock(rand io.Reader, blockType string, data, password []byte, alg PEMCipher) (*pem.Block, error) {
x509.go#L1588: func signTBS(tbs []byte, key crypto.Signer, sigAlg SignatureAlgorithm, rand io.Reader) ([]byte, error) {
x509.go#L1679: func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv any) ([]byte, error) {
x509.go#L1855: func (c *Certificate) CreateCRL(rand io.Reader, priv any, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) {
x509.go#L2068: func CreateCertificateRequest(rand io.Reader, template *CertificateRequest, priv any) (csr []byte, err error) {
x509.go#L2417: func CreateRevocationList(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error) {
encoding/base64
base64.go#L439: r io.Reader
base64.go#L623: wrapped io.Reader
base64.go#L648: func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
encoding/binary
binary.go#L258: func Read(r io.Reader, order ByteOrder, data any) error {
encoding/hex
hex.go#L194: r io.Reader
hex.go#L202: func NewDecoder(r io.Reader) io.Reader {
encoding/json
stream.go#L17: r io.Reader
stream.go#L33: func NewDecoder(r io.Reader) *Decoder {
stream.go#L85: func (dec *Decoder) Buffered() io.Reader {
fmt
scan.go#L121: func Fscan(r io.Reader, a ...any) (n int, err error) {
scan.go#L130: func Fscanln(r io.Reader, a ...any) (n int, err error) {
scan.go#L141: func Fscanf(r io.Reader, format string, a ...any) (n int, err error) {
scan.go#L305: reader io.Reader
scan.go#L383: func newScanState(r io.Reader, nlIsSpace, nlIsEnd bool) (s *ss, old ssave) {
github.com/andybalholm/brotli
reader.go#L23: func NewReader(src io.Reader) *Reader {
reader.go#L33: func (r *Reader) Reset(src io.Reader) error {
state.go#L90: src io.Reader
github.com/coder/websocket
compress.go#L137: func getFlateReader(r io.Reader, dict []byte) io.Reader {
compress.go#L138: fr, ok := flateReaderPool.Get().(io.Reader)
compress.go#L146: func putFlateReader(fr io.Reader) {
dial.go#L124: func dial(ctx context.Context, urls string, opts *DialOptions, rand io.Reader) (_ *Conn, _ *http.Response, err error) {
dial.go#L230: func secWebSocketKey(rr io.Reader) (string, error) {
dial.go#L321: func getBufioReader(r io.Reader) *bufio.Reader {
netconn.go#L112: reader io.Reader
read.go#L35: func (c *Conn) Reader(ctx context.Context) (MessageType, io.Reader, error) {
read.go#L369: func (c *Conn) reader(ctx context.Context) (_ MessageType, _ io.Reader, err error) {
read.go#L403: flateReader io.Reader
read.go#L502: r io.Reader
read.go#L507: func newLimitReader(c *Conn, r io.Reader, limit int64) *limitReader {
read.go#L516: func (lr *limitReader) reset(r io.Reader) {
github.com/go-faster/jx
dec.go#L78: reader io.Reader
dec.go#L95: func Decode(reader io.Reader, bufSize int) *Decoder {
dec.go#L123: func (d *Decoder) Reset(reader io.Reader) {
dec_raw.go#L14: orig io.Reader
github.com/gotd/td/crypto
bind.go#L104: func EncryptBindMessage(rand io.Reader, permKey AuthKey, msgID int64, inner *BindAuthKeyInner) ([]byte, error) {
cipher.go#L7: rand io.Reader
cipher.go#L12: func (c Cipher) Rand() io.Reader {
cipher.go#L17: func NewClientCipher(rand io.Reader) Cipher {
cipher.go#L22: func NewServerCipher(rand io.Reader) Cipher {
data_with_hash.go#L46: func DataWithHash(data []byte, randomSource io.Reader) ([]byte, error) {
exchange.go#L41: func EncryptExchangeAnswer(rand io.Reader, answer, key, iv []byte) (dst []byte, err error) {
pq.go#L28: func DecomposePQ(pq *big.Int, randSource io.Reader) (p, q *big.Int, err error) { // nolint:gocognit
rand.go#L10: func RandInt64n(randSource io.Reader, n int64) (int64, error) {
rand.go#L22: func RandInt64(randSource io.Reader) (int64, error) {
rand.go#L34: func RandInt128(randSource io.Reader) (bin.Int128, error) {
rand.go#L46: func RandInt256(randSource io.Reader) (bin.Int256, error) {
rand_notjs.go#L12: func DefaultRand() io.Reader {
rsa_hashed.go#L13: func RSAEncryptHashed(data []byte, key *rsa.PublicKey, randomSource io.Reader) ([]byte, error) {
rsa_pad.go#L34: func RSAPad(data []byte, key *rsa.PublicKey, randomSource io.Reader) ([]byte, error) {
session_id.go#L11: func NewSessionID(reader io.Reader) (int64, error) {
github.com/gotd/td/crypto/srp
srp.go#L18: random io.Reader
srp.go#L22: func NewSRP(random io.Reader) SRP {
github.com/gotd/td/exchange
client.go#L14: rand io.Reader
flow.go#L35: rand io.Reader
flow.go#L51: func (e Exchanger) WithRand(reader io.Reader) Exchanger {
generator.go#L25: rand io.Reader
server.go#L14: rand io.Reader
github.com/gotd/td/mtproto
conn.go#L64: rand io.Reader
options.go#L32: Random io.Reader
github.com/gotd/td/mtproxy/faketls
client_hello.go#L37: func generateClientHello(rand io.Reader, domain string) ([]byte, error) {
client_hello.go#L71: rand io.Reader,
faketls.go#L16: rand io.Reader
faketls.go#L28: func NewFakeTLS(r io.Reader, conn io.ReadWriter) *FakeTLS {
record.go#L22: func readRecord(r io.Reader) (record, error) {
server_hello.go#L17: func readServerHello(r io.Reader, clientRandom [32]byte, secret []byte) error {
github.com/gotd/td/mtproxy/obfuscated2
keys.go#L54: func generateKeys(randSource io.Reader, protocol [4]byte, secret []byte, dc int) (keys, error) {
keys_util.go#L29: func generateInit(randSource io.Reader) (init [64]byte, err error) {
obfuscated2.go#L13: rand io.Reader
obfuscated2.go#L20: func NewObfuscated2(r io.Reader, conn io.ReadWriter) *Obfuscated2 {
github.com/gotd/td/mtproxy/obfuscator
dialer.go#L17: func Obfuscated2(rand io.Reader, conn net.Conn) *Conn {
dialer.go#L25: func FakeTLS(rand io.Reader, conn net.Conn) *Conn {
obfuscator.go#L25: func newTLS(rand io.Reader, conn io.ReadWriter) tls {
github.com/gotd/td/proto
gzip.go#L43: func (g *gzipPool) GetReader(r io.Reader) (*gzip.Reader, error) {
gzip.go#L113: reader io.Reader
github.com/gotd/td/proto/codec
abridged.go#L36: func (i Abridged) ReadHeader(r io.Reader) error {
abridged.go#L73: func (i Abridged) Read(r io.Reader, b *bin.Buffer) error {
abridged.go#L119: func readAbridged(r io.Reader, b *bin.Buffer) error {
codec.go#L17: ReadHeader(r io.Reader) error
codec.go#L21: Read(r io.Reader, b *bin.Buffer) error
codec.go#L32: func readLen(r io.Reader, b *bin.Buffer) (int, error) {
full.go#L27: func (i *Full) ReadHeader(r io.Reader) (err error) {
full.go#L45: func (i *Full) Read(r io.Reader, b *bin.Buffer) error {
full.go#L77: func readFull(r io.Reader, seqNo int, b *bin.Buffer) error {
intermediate.go#L35: func (i Intermediate) ReadHeader(r io.Reader) (err error) {
intermediate.go#L71: func (i Intermediate) Read(r io.Reader, b *bin.Buffer) error {
intermediate.go#L98: func readIntermediate(r io.Reader, b *bin.Buffer, padding bool) error {
no_header.go#L16: func (NoHeader) ReadHeader(io.Reader) error {
padded_intermediate.go#L36: func (i PaddedIntermediate) ReadHeader(r io.Reader) error {
padded_intermediate.go#L72: func (i PaddedIntermediate) Read(r io.Reader, b *bin.Buffer) error {
padded_intermediate.go#L80: func writePaddedIntermediate(randSource io.Reader, w io.Writer, b *bin.Buffer) error {
padded_intermediate.go#L98: func readPaddedIntermediate(r io.Reader, b *bin.Buffer) error {
github.com/gotd/td/session/tdesktop
file.go#L74: func fromFile(r io.Reader) (*tdesktopFile, error) {
github.com/gotd/td/syncio
reader.go#L10: r io.Reader
reader.go#L15: func NewReader(r io.Reader) *Reader {
github.com/gotd/td/telegram
client.go#L130: rand io.Reader // immutable
options.go#L73: Random io.Reader
github.com/gotd/td/telegram/auth
client.go#L12: rand io.Reader
client.go#L20: rand io.Reader,
flow.go#L315: func Test(randReader io.Reader, dc int) UserAuthenticator {
github.com/gotd/td/telegram/dcs
mtproxy.go#L27: rand io.Reader
mtproxy.go#L93: Rand io.Reader
plain.go#L25: rand io.Reader
plain.go#L214: Rand io.Reader
websocket.go#L25: rand io.Reader
websocket.go#L76: Rand io.Reader
github.com/gotd/td/transport
codec.go#L14: ReadHeader(r io.Reader) error
codec.go#L18: Read(r io.Reader, b *bin.Buffer) error
detect_codec.go#L12: func detectCodec(c io.Reader) (Codec, io.Reader, error) {
listener.go#L34: reader io.Reader
obfuscated.go#L20: reader io.Reader
websocket.go#L115: reader io.Reader
github.com/klauspost/compress/flate
inflate.go#L74: Reset(r io.Reader, dict []byte) error
inflate.go#L285: io.Reader
inflate.go#L768: func makeReader(r io.Reader) Reader {
inflate.go#L795: func (f *decompressor) Reset(r io.Reader, dict []byte) error {
inflate.go#L827: func NewReaderOpts(r io.Reader, opts ...ReaderOpt) io.ReadCloser {
inflate.go#L852: func NewReader(r io.Reader) io.ReadCloser {
inflate.go#L863: func NewReaderDict(r io.Reader, dict []byte) io.ReadCloser {
github.com/klauspost/compress/gzip
gunzip.go#L94: func NewReader(r io.Reader) (*Reader, error) {
gunzip.go#L105: func (z *Reader) Reset(r io.Reader) error {
github.com/klauspost/compress/internal/snapref
decode.go#L79: func NewReader(r io.Reader) *Reader {
decode.go#L91: r io.Reader
decode.go#L103: func (r *Reader) Reset(reader io.Reader) {
github.com/klauspost/compress/zstd
bytebuf.go#L78: r io.Reader
decoder.go#L67: _ = io.Reader(&Decoder{})
decoder.go#L84: func NewReader(r io.Reader, opts ...DOption) (*Decoder, error) {
decoder.go#L166: func (d *Decoder) Reset(r io.Reader) error {
decoder.go#L240: func (d *Decoder) ResetWithOptions(r io.Reader, opts ...DOption) error {
decoder.go#L640: func (d *Decoder) startSyncDecoder(r io.Reader) error {
decoder.go#L655: func (d *Decoder) startStreamDecoder(ctx context.Context, r io.Reader, output chan decodeOutput) {
encoder.go#L372: func (e *Encoder) ReadFrom(r io.Reader) (n int64, err error) {
frameenc.go#L120: func skippableFrame(dst []byte, total int, r io.Reader) ([]byte, error) {
fse_decoder.go#L186: func (s *fseDecoder) mustReadFrom(r io.Reader) {
snappy.go#L73: r io.Reader
snappy.go#L82: func (r *SnappyConverter) Convert(in io.Reader, w io.Writer) (int64, error) {
zip.go#L31: func newZipReader(opts ...DOption) func(r io.Reader) io.ReadCloser {
zip.go#L40: return func(r io.Reader) io.ReadCloser {
zip.go#L139: func ZipDecompressor(opts ...DOption) func(r io.Reader) io.ReadCloser {
github.com/refraction-networking/utls
common.go#L556: Rand io.Reader
common.go#L1152: func (c *Config) rand() io.Reader {
conn.go#L483: func (hc *halfConn) encrypt(record, payload []byte, rand io.Reader) ([]byte, error) {
conn.go#L802: R io.Reader
conn.go#L823: func (c *Conn) readFromUntil(r io.Reader, n int) error {
key_schedule.go#L64: func generateECDHEKey(rand io.Reader, curveID CurveID) (*ecdh.PrivateKey, error) {
u_handshake_client.go#L53: decompressed io.Reader
golang.org/x/crypto/hkdf
hkdf.go#L90: func Expand(hash func() hash.Hash, pseudorandomKey, info []byte) io.Reader {
hkdf.go#L97: func New(hash func() hash.Hash, secret, salt, info []byte) io.Reader {
golang.org/x/crypto/sha3
shake.go#L24: io.Reader
hash
hash.go#L82: io.Reader
image
format.go#L21: decode func(io.Reader) (Image, error)
format.go#L22: decodeConfig func(io.Reader) (Config, error)
format.go#L37: func RegisterFormat(name, magic string, decode func(io.Reader) (Image, error), decodeConfig func(io.Reader) (Config, error)) {
format.go#L46: io.Reader
format.go#L51: func asReader(r io.Reader) reader {
format.go#L87: func Decode(r io.Reader) (Image, string, error) {
format.go#L101: func DecodeConfig(r io.Reader) (Config, string, error) {
internal/saferio
io.go#L28: func ReadData(r io.Reader, n uint64) ([]byte, error) {
mime
encodedword.go#L194: CharsetReader func(charset string, input io.Reader) (io.Reader, error)
mime/multipart
formdata.go#L288: io.Reader
multipart.go#L66: r io.Reader
multipart.go#L119: func NewReader(r io.Reader, boundary string) *Reader {
multipart.go#L136: r io.Reader
mime/quotedprintable
reader.go#L24: func NewReader(r io.Reader) *Reader {
net
net.go#L756: func (noReadFrom) ReadFrom(io.Reader) (int64, error) {
net.go#L770: func genericReadFrom(c *TCPConn, r io.Reader) (n int64, err error) {
net.go#L842: _ io.Reader = (*Buffers)(nil)
sendfile.go#L24: func sendFile(c *netFD, r io.Reader) (written int64, err error, handled bool) {
splice_linux.go#L19: func spliceFrom(c *netFD, r io.Reader) (written int64, err error, handled bool) {
tcpsock.go#L161: func (c *TCPConn) ReadFrom(r io.Reader) (int64, error) {
tcpsock_posix.go#L47: func (c *TCPConn) readFrom(r io.Reader) (int64, error) {
net/http
client.go#L856: func Post(url, contentType string, body io.Reader) (resp *Response, err error) {
client.go#L874: func (c *Client) Post(url, contentType string, body io.Reader) (resp *Response, err error) {
fs.go#L115: io.Reader
fs.go#L318: var sendContent io.Reader = content
h2_bundle.go#L1798: func http2ReadFrameHeader(r io.Reader) (http2FrameHeader, error) {
h2_bundle.go#L1804: func http2readFrameHeader(buf []byte, r io.Reader) (http2FrameHeader, error) {
h2_bundle.go#L1834: r io.Reader
h2_bundle.go#L2003: func http2NewFramer(w io.Writer, r io.Reader) *http2Framer {
h2_bundle.go#L3882: io.Reader
h2_bundle.go#L10451: func http2gzipPoolGet(r io.Reader) (*gzip.Reader, error) {
request.go#L862: func NewRequest(method, url string, body io.Reader) (*Request, error) {
request.go#L889: func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
request.go#L1277: var reader io.Reader = r.Body
response.go#L280: io.Reader
server.go#L589: func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
server.go#L857: func newBufioReader(r io.Reader) *bufio.Reader {
transfer.go#L63: Body io.Reader
transfer.go#L210: go func(body io.Reader) {
transfer.go#L413: func (t *transferWriter) doBodyCopy(dst io.Writer, src io.Reader) (n int64, err error) {
transfer.go#L429: func (t *transferWriter) unwrapBody() io.Reader {
transfer.go#L812: src io.Reader
transfer.go#L1095: io.Reader
transfer.go#L1101: func unwrapNopCloser(r io.Reader) (underlyingReader io.Reader, isNopCloser bool) {
transfer.go#L1104: return reflect.ValueOf(r).Field(0).Interface().(io.Reader), true
transfer.go#L1113: func isKnownInMemoryReader(r io.Reader) bool {
transport.go#L2018: func (w persistConnWriter) ReadFrom(r io.Reader) (n int64, err error) {
transport.go#L3131: func gzipPoolGet(r io.Reader) (*gzip.Reader, error) {
net/http/internal
chunked.go#L29: func NewChunkedReader(r io.Reader) io.Reader {
net/textproto
reader.go#L334: func (r *Reader) DotReader() io.Reader {
os
file.go#L175: func (f *File) ReadFrom(r io.Reader) (n int64, err error) {
file.go#L192: func (noReadFrom) ReadFrom(io.Reader) (int64, error) {
file.go#L204: func genericReadFrom(f *File, r io.Reader) (int64, error) {
zero_copy_linux.go#L42: func (f *File) readFrom(r io.Reader) (written int64, handled bool, err error) {
zero_copy_linux.go#L59: func (f *File) spliceToFile(r io.Reader) (written int64, handled bool, err error) {
zero_copy_linux.go#L89: func (f *File) copyFileRange(r io.Reader) (written int64, handled bool, err error) {
zero_copy_posix.go#L26: func tryLimitedReader(r io.Reader) (*io.LimitedReader, io.Reader, int64) {
vendor/golang.org/x/text/transform
transform.go#L111: r io.Reader
transform.go#L134: func NewReader(r io.Reader, t Transformer) *Reader {
vendor/golang.org/x/text/unicode/norm
readwriter.go#L74: r io.Reader
readwriter.go#L119: func (f Form) Reader(r io.Reader) io.Reader {
 |
The pages are generated with Golds v0.8.4. (GOOS=linux GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @zigo_101 (reachable from the left QR code) to get the latest news of Golds. |