type io.Reader
284 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#L364: func CopyN(dst Writer, src Reader, n int64) (written int64, err error) {
io.go#L388: func Copy(dst Writer, src Reader) (written int64, err error) {
io.go#L399: func CopyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
io.go#L408: func copyBuffer(dst Writer, src Reader, buf []byte) (written int64, err error) {
io.go#L462: func LimitReader(r Reader, n int64) Reader { return &LimitedReader{r, n} }
io.go#L469: R Reader // underlying reader
io.go#L610: func TeeReader(r Reader, w Writer) Reader {
io.go#L615: r Reader
io.go#L654: func (discard) ReadFrom(r Reader) (n int64, err error) {
io.go#L674: func NopCloser(r Reader) ReadCloser {
io.go#L682: Reader
io.go#L688: Reader
io.go#L701: 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))
io/ioutil
ioutil.go#L26: func ReadAll(r io.Reader) ([]byte, error) {
ioutil.go#L87: func NopCloser(r io.Reader) io.ReadCloser {
bufio
bufio.go#L34: rd io.Reader // reader provided by the client
bufio.go#L47: 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#L87: func NewScanner(r io.Reader) *Scanner {
bytes
buffer.go#L206: 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 {
crypto
crypto.go#L198: Sign(rand io.Reader, digest []byte, opts SignerOpts) (signature []byte, err error)
crypto.go#L220: Decrypt(rand io.Reader, msg []byte, opts DecrypterOpts) (plaintext []byte, err error)
crypto/cipher
io.go#L16: R io.Reader
crypto/dsa
dsa.go#L65: func GenerateParameters(params *Parameters, rand io.Reader, sizes ParameterSizes) error {
dsa.go#L159: func GenerateKey(priv *PrivateKey, rand io.Reader) error {
dsa.go#L205: func Sign(rand 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#L38: func (c *nistCurve[Point]) GenerateKey(rand io.Reader) (*PrivateKey, error) {
x25519.go#L35: func (c *x25519Curve) GenerateKey(rand io.Reader) (*PrivateKey, error) {
crypto/ecdsa
ecdsa.go#L149: func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) {
ecdsa.go#L158: func GenerateKey(c elliptic.Curve, rand io.Reader) (*PrivateKey, error) {
ecdsa.go#L184: func generateNISTEC[Point nistPoint[Point]](c *nistCurve[Point], rand io.Reader) (*PrivateKey, error) {
ecdsa.go#L202: func randomPoint[Point nistPoint[Point]](c *nistCurve[Point], rand io.Reader) (k *bigmod.Nat, p Point, err error) {
ecdsa.go#L256: func SignASN1(rand io.Reader, priv *PrivateKey, hash []byte) ([]byte, error) {
ecdsa.go#L291: func signNISTEC[Point nistPoint[Point]](c *nistCurve[Point], priv *PrivateKey, csprng io.Reader, hash []byte) (sig []byte, err error) {
ecdsa.go#L413: func mixedCSPRNG(rand io.Reader, priv *PrivateKey, hash []byte) (io.Reader, error) {
ecdsa_legacy.go#L20: func generateLegacy(c elliptic.Curve, rand io.Reader) (*PrivateKey, error) {
ecdsa_legacy.go#L58: func Sign(rand io.Reader, priv *PrivateKey, hash []byte) (r, s *big.Int, err error) {
ecdsa_legacy.go#L77: func signLegacy(priv *PrivateKey, csprng io.Reader, hash []byte) (sig []byte, err error) {
ecdsa_legacy.go#L170: func randFieldElement(c elliptic.Curve, rand io.Reader) (k *big.Int, err error) {
ecdsa_noasm.go#L15: func signAsm(priv *PrivateKey, csprng io.Reader, hash []byte) (sig []byte, err error) {
crypto/ed25519
ed25519.go#L88: func (priv PrivateKey) Sign(rand io.Reader, message []byte, opts crypto.SignerOpts) (signature []byte, err error) {
ed25519.go#L138: func GenerateKey(rand 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/randutil
randutil.go#L25: func MaybeReadByte(r io.Reader) {
crypto/rand
rand.go#L21: var Reader io.Reader
rand_unix.go#L35: f io.Reader
rand_unix.go#L78: r io.Reader
util.go#L16: func Prime(rand io.Reader, bits int) (*big.Int, error) {
util.go#L62: func Int(rand io.Reader, max *big.Int) (n *big.Int, err error) {
crypto/rsa
pkcs1v15.go#L41: func EncryptPKCS1v15(random io.Reader, pub *PublicKey, msg []byte) ([]byte, error) {
pkcs1v15.go#L92: func DecryptPKCS1v15(random io.Reader, priv *PrivateKey, ciphertext []byte) ([]byte, error) {
pkcs1v15.go#L153: func DecryptPKCS1v15SessionKey(random io.Reader, priv *PrivateKey, ciphertext []byte, key []byte) error {
pkcs1v15.go#L233: func nonZeroRandomBytes(s []byte, random io.Reader) (err error) {
pkcs1v15.go#L287: func SignPKCS1v15(random io.Reader, priv *PrivateKey, hash crypto.Hash, hashed []byte) ([]byte, error) {
pss.go#L292: func SignPSS(rand io.Reader, priv *PrivateKey, hash crypto.Hash, digest []byte, opts *PSSOptions) ([]byte, error) {
rsa.go#L160: func (priv *PrivateKey) Sign(rand io.Reader, digest []byte, opts crypto.SignerOpts) ([]byte, error) {
rsa.go#L171: func (priv *PrivateKey) Decrypt(rand io.Reader, ciphertext []byte, opts crypto.DecrypterOpts) (plaintext []byte, err error) {
rsa.go#L271: func GenerateKey(random io.Reader, bits int) (*PrivateKey, error) {
rsa.go#L294: func GenerateMultiPrimeKey(random io.Reader, nprimes int, bits int) (*PrivateKey, error) {
rsa.go#L516: func EncryptOAEP(hash hash.Hash, random io.Reader, pub *PublicKey, msg []byte, label []byte) ([]byte, error) {
rsa.go#L708: func DecryptOAEP(hash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) ([]byte, error) {
rsa.go#L712: func decryptOAEP(hash, mgfHash hash.Hash, random io.Reader, priv *PrivateKey, ciphertext []byte, label []byte) ([]byte, error) {
crypto/tls
common.go#L529: Rand io.Reader
common.go#L993: func (c *Config) rand() io.Reader {
conn.go#L478: func (hc *halfConn) encrypt(record, payload []byte, rand io.Reader) ([]byte, error) {
conn.go#L797: R io.Reader
conn.go#L818: func (c *Conn) readFromUntil(r io.Reader, n int) error {
key_schedule.go#L122: func generateECDHEKey(rand io.Reader, curveID CurveID) (*ecdh.PrivateKey, error) {
crypto/x509
pem_decrypt.go#L195: func EncryptPEMBlock(rand io.Reader, blockType string, data, password []byte, alg PEMCipher) (*pem.Block, error) {
x509.go#L1538: func CreateCertificate(rand io.Reader, template, parent *Certificate, pub, priv any) ([]byte, error) {
x509.go#L1711: func (c *Certificate) CreateCRL(rand io.Reader, priv any, revokedCerts []pkix.RevokedCertificate, now, expiry time.Time) (crlBytes []byte, err error) {
x509.go#L1931: func CreateCertificateRequest(rand io.Reader, template *CertificateRequest, priv any) (csr []byte, err error) {
x509.go#L2292: func CreateRevocationList(rand io.Reader, template *RevocationList, issuer *Certificate, priv crypto.Signer) ([]byte, error) {
encoding/base64
base64.go#L409: r io.Reader
base64.go#L592: wrapped io.Reader
base64.go#L617: func NewDecoder(enc *Encoding, r io.Reader) io.Reader {
encoding/binary
binary.go#L233: func Read(r io.Reader, order ByteOrder, data any) error {
encoding/hex
hex.go#L176: r io.Reader
hex.go#L184: func NewDecoder(r io.Reader) io.Reader {
encoding/json
stream.go#L15: r io.Reader
stream.go#L31: func NewDecoder(r io.Reader) *Decoder {
stream.go#L83: 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/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/internal/crypto
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#L42: 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#L36: 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/internal/crypto/srp
srp.go#L18: random io.Reader
srp.go#L22: func NewSRP(random io.Reader) SRP {
github.com/gotd/td/internal/exchange
client.go#L14: rand io.Reader
flow.go#L25: rand io.Reader
flow.go#L38: func (e Exchanger) WithRand(reader io.Reader) Exchanger {
generator.go#L25: rand io.Reader
server.go#L14: rand io.Reader
github.com/gotd/td/internal/mtproto
conn.go#L64: rand io.Reader
options.go#L31: Random io.Reader
github.com/gotd/td/internal/mtproxy/faketls
faketls.go#L16: rand io.Reader
faketls.go#L28: func NewFakeTLS(r io.Reader, conn io.ReadWriter) *FakeTLS {
record.go#L19: func readRecord(r io.Reader) (record, error) {
server_hello.go#L13: func readServerHello(r io.Reader, clientRandom [32]byte, secret []byte) error {
github.com/gotd/td/internal/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/internal/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/internal/proto
gzip.go#L43: func (g *gzipPool) GetReader(r io.Reader) (*gzip.Reader, error) {
gzip.go#L113: reader io.Reader
github.com/gotd/td/internal/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#L67: func fromFile(r io.Reader) (*tdesktopFile, error) {
github.com/gotd/td/telegram
client.go#L106: rand io.Reader // immutable
options.go#L55: Random io.Reader
github.com/gotd/td/telegram/auth
client.go#L12: rand io.Reader
client.go#L20: rand io.Reader,
flow.go#L285: 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#L189: 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#L751: func makeReader(r io.Reader) Reader {
inflate.go#L778: func (f *decompressor) Reset(r io.Reader, dict []byte) error {
inflate.go#L800: func NewReader(r io.Reader) io.ReadCloser {
inflate.go#L819: 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 {
go.uber.org/zap
http_handler.go#L129: func decodePutJSON(body io.Reader) (zapcore.Level, error) {
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) {
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#L669: func genericReadFrom(w io.Writer, r io.Reader) (n int64, err error) {
net.go#L712: _ io.Reader = (*Buffers)(nil)
sendfile_linux.go#L20: func sendFile(c *netFD, r io.Reader) (written int64, err error, handled bool) {
splice_linux.go#L17: func splice(c *netFD, r io.Reader) (written int64, err error, handled bool) {
tcpsock.go#L126: 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#L833: func Post(url, contentType string, body io.Reader) (resp *Response, err error) {
client.go#L851: func (c *Client) Post(url, contentType string, body io.Reader) (resp *Response, err error) {
fs.go#L106: io.Reader
fs.go#L267: var sendContent io.Reader = content
h2_bundle.go#L1628: func http2ReadFrameHeader(r io.Reader) (http2FrameHeader, error) {
h2_bundle.go#L1634: func http2readFrameHeader(buf []byte, r io.Reader) (http2FrameHeader, error) {
h2_bundle.go#L1664: r io.Reader
h2_bundle.go#L1831: func http2NewFramer(w io.Writer, r io.Reader) *http2Framer {
h2_bundle.go#L3719: io.Reader
request.go#L838: func NewRequest(method, url string, body io.Reader) (*Request, error) {
request.go#L864: func NewRequestWithContext(ctx context.Context, method, url string, body io.Reader) (*Request, error) {
request.go#L1231: var reader io.Reader = r.Body
response.go#L280: io.Reader
server.go#L578: func (w *response) ReadFrom(src io.Reader) (n int64, err error) {
server.go#L828: func newBufioReader(r io.Reader) *bufio.Reader {
transfer.go#L61: Body io.Reader
transfer.go#L208: go func(body io.Reader) {
transfer.go#L411: func (t *transferWriter) doBodyCopy(dst io.Writer, src io.Reader) (n int64, err error) {
transfer.go#L424: func (t *transferWriter) unwrapBody() io.Reader {
transfer.go#L806: src io.Reader
transfer.go#L1079: io.Reader
transfer.go#L1085: func unwrapNopCloser(r io.Reader) (underlyingReader io.Reader, isNopCloser bool) {
transfer.go#L1088: return reflect.ValueOf(r).Field(0).Interface().(io.Reader), true
transfer.go#L1097: func isKnownInMemoryReader(r io.Reader) bool {
transport.go#L1800: func (w persistConnWriter) ReadFrom(r io.Reader) (n int64, err error) {
net/http/internal
chunked.go#L29: func NewChunkedReader(r io.Reader) io.Reader {
net/textproto
reader.go#L308: func (r *Reader) DotReader() io.Reader {
nhooyr.io/websocket
compress.go#L138: func getFlateReader(r io.Reader, dict []byte) io.Reader {
compress.go#L139: fr, ok := flateReaderPool.Get().(io.Reader)
compress.go#L147: func putFlateReader(fr io.Reader) {
dial.go#L109: func dial(ctx context.Context, urls string, opts *DialOptions, rand io.Reader) (_ *Conn, _ *http.Response, err error) {
dial.go#L213: func secWebSocketKey(rr io.Reader) (string, error) {
dial.go#L304: func getBufioReader(r io.Reader) *bufio.Reader {
netconn.go#L112: reader io.Reader
read.go#L36: func (c *Conn) Reader(ctx context.Context) (MessageType, io.Reader, error) {
read.go#L329: func (c *Conn) reader(ctx context.Context) (_ MessageType, _ io.Reader, err error) {
read.go#L365: flateReader io.Reader
read.go#L465: r io.Reader
read.go#L470: func newLimitReader(c *Conn, r io.Reader, limit int64) *limitReader {
read.go#L479: func (lr *limitReader) reset(r io.Reader) {
os
file.go#L149: func (f *File) ReadFrom(r io.Reader) (n int64, err error) {
file.go#L160: func genericReadFrom(f *File, r io.Reader) (int64, error) {
readfrom_linux.go#L18: func (f *File) readFrom(r io.Reader) (written int64, handled bool, err error) {
readfrom_linux.go#L35: func (f *File) spliceToFile(r io.Reader) (written int64, handled bool, err error) {
readfrom_linux.go#L69: func getPollFD(r io.Reader) *poll.FD {
readfrom_linux.go#L85: func (f *File) copyFileRange(r io.Reader) (written int64, handled bool, err error) {
readfrom_linux.go#L114: func tryLimitedReader(r io.Reader) (*io.LimitedReader, io.Reader, int64) {
vendor/golang.org/x/crypto/hkdf
hkdf.go#L83: func Expand(hash func() hash.Hash, pseudorandomKey, info []byte) io.Reader {
hkdf.go#L90: func New(hash func() hash.Hash, secret, salt, info []byte) io.Reader {
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.6.7. (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 @Go100and1 (reachable from the left QR code) to get the latest news of Golds. |