id int32 0 167k | repo stringlengths 5 54 | path stringlengths 4 155 | func_name stringlengths 1 118 | original_string stringlengths 52 85.5k | language stringclasses 1
value | code stringlengths 52 85.5k | code_tokens list | docstring stringlengths 6 2.61k | docstring_tokens list | sha stringlengths 40 40 | url stringlengths 85 252 |
|---|---|---|---|---|---|---|---|---|---|---|---|
163,600 | btcsuite/btcd | rpcwebsocket.go | handleNotifyReceived | func handleNotifyReceived(wsc *wsClient, icmd interface{}) (interface{}, error) {
cmd, ok := icmd.(*btcjson.NotifyReceivedCmd)
if !ok {
return nil, btcjson.ErrRPCInternal
}
// Decode addresses to validate input, but the strings slice is used
// directly if these are all ok.
err := checkAddressValidity(cmd.Addresses, wsc.server.cfg.ChainParams)
if err != nil {
return nil, err
}
wsc.server.ntfnMgr.RegisterTxOutAddressRequests(wsc, cmd.Addresses)
return nil, nil
} | go | func handleNotifyReceived(wsc *wsClient, icmd interface{}) (interface{}, error) {
cmd, ok := icmd.(*btcjson.NotifyReceivedCmd)
if !ok {
return nil, btcjson.ErrRPCInternal
}
// Decode addresses to validate input, but the strings slice is used
// directly if these are all ok.
err := checkAddressValidity(cmd.Addresses, wsc.server.cfg.ChainParams)
if err != nil {
return nil, err
}
wsc.server.ntfnMgr.RegisterTxOutAddressRequests(wsc, cmd.Addresses)
return nil, nil
} | [
"func",
"handleNotifyReceived",
"(",
"wsc",
"*",
"wsClient",
",",
"icmd",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"cmd",
",",
"ok",
":=",
"icmd",
".",
"(",
"*",
"btcjson",
".",
"NotifyReceivedCmd",
")",
"\n",
"... | // handleNotifyReceived implements the notifyreceived command extension for
// websocket connections. | [
"handleNotifyReceived",
"implements",
"the",
"notifyreceived",
"command",
"extension",
"for",
"websocket",
"connections",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcwebsocket.go#L1887-L1902 |
163,601 | btcsuite/btcd | rpcwebsocket.go | handleStopNotifySpent | func handleStopNotifySpent(wsc *wsClient, icmd interface{}) (interface{}, error) {
cmd, ok := icmd.(*btcjson.StopNotifySpentCmd)
if !ok {
return nil, btcjson.ErrRPCInternal
}
outpoints, err := deserializeOutpoints(cmd.OutPoints)
if err != nil {
return nil, err
}
for _, outpoint := range outpoints {
wsc.server.ntfnMgr.UnregisterSpentRequest(wsc, outpoint)
}
return nil, nil
} | go | func handleStopNotifySpent(wsc *wsClient, icmd interface{}) (interface{}, error) {
cmd, ok := icmd.(*btcjson.StopNotifySpentCmd)
if !ok {
return nil, btcjson.ErrRPCInternal
}
outpoints, err := deserializeOutpoints(cmd.OutPoints)
if err != nil {
return nil, err
}
for _, outpoint := range outpoints {
wsc.server.ntfnMgr.UnregisterSpentRequest(wsc, outpoint)
}
return nil, nil
} | [
"func",
"handleStopNotifySpent",
"(",
"wsc",
"*",
"wsClient",
",",
"icmd",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"cmd",
",",
"ok",
":=",
"icmd",
".",
"(",
"*",
"btcjson",
".",
"StopNotifySpentCmd",
")",
"\n",
... | // handleStopNotifySpent implements the stopnotifyspent command extension for
// websocket connections. | [
"handleStopNotifySpent",
"implements",
"the",
"stopnotifyspent",
"command",
"extension",
"for",
"websocket",
"connections",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcwebsocket.go#L1906-L1922 |
163,602 | btcsuite/btcd | rpcwebsocket.go | handleStopNotifyReceived | func handleStopNotifyReceived(wsc *wsClient, icmd interface{}) (interface{}, error) {
cmd, ok := icmd.(*btcjson.StopNotifyReceivedCmd)
if !ok {
return nil, btcjson.ErrRPCInternal
}
// Decode addresses to validate input, but the strings slice is used
// directly if these are all ok.
err := checkAddressValidity(cmd.Addresses, wsc.server.cfg.ChainParams)
if err != nil {
return nil, err
}
for _, addr := range cmd.Addresses {
wsc.server.ntfnMgr.UnregisterTxOutAddressRequest(wsc, addr)
}
return nil, nil
} | go | func handleStopNotifyReceived(wsc *wsClient, icmd interface{}) (interface{}, error) {
cmd, ok := icmd.(*btcjson.StopNotifyReceivedCmd)
if !ok {
return nil, btcjson.ErrRPCInternal
}
// Decode addresses to validate input, but the strings slice is used
// directly if these are all ok.
err := checkAddressValidity(cmd.Addresses, wsc.server.cfg.ChainParams)
if err != nil {
return nil, err
}
for _, addr := range cmd.Addresses {
wsc.server.ntfnMgr.UnregisterTxOutAddressRequest(wsc, addr)
}
return nil, nil
} | [
"func",
"handleStopNotifyReceived",
"(",
"wsc",
"*",
"wsClient",
",",
"icmd",
"interface",
"{",
"}",
")",
"(",
"interface",
"{",
"}",
",",
"error",
")",
"{",
"cmd",
",",
"ok",
":=",
"icmd",
".",
"(",
"*",
"btcjson",
".",
"StopNotifyReceivedCmd",
")",
"... | // handleStopNotifyReceived implements the stopnotifyreceived command extension
// for websocket connections. | [
"handleStopNotifyReceived",
"implements",
"the",
"stopnotifyreceived",
"command",
"extension",
"for",
"websocket",
"connections",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcwebsocket.go#L1926-L1944 |
163,603 | btcsuite/btcd | rpcwebsocket.go | checkAddressValidity | func checkAddressValidity(addrs []string, params *chaincfg.Params) error {
for _, addr := range addrs {
_, err := btcutil.DecodeAddress(addr, params)
if err != nil {
return &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidAddressOrKey,
Message: fmt.Sprintf("Invalid address or key: %v",
addr),
}
}
}
return nil
} | go | func checkAddressValidity(addrs []string, params *chaincfg.Params) error {
for _, addr := range addrs {
_, err := btcutil.DecodeAddress(addr, params)
if err != nil {
return &btcjson.RPCError{
Code: btcjson.ErrRPCInvalidAddressOrKey,
Message: fmt.Sprintf("Invalid address or key: %v",
addr),
}
}
}
return nil
} | [
"func",
"checkAddressValidity",
"(",
"addrs",
"[",
"]",
"string",
",",
"params",
"*",
"chaincfg",
".",
"Params",
")",
"error",
"{",
"for",
"_",
",",
"addr",
":=",
"range",
"addrs",
"{",
"_",
",",
"err",
":=",
"btcutil",
".",
"DecodeAddress",
"(",
"addr... | // checkAddressValidity checks the validity of each address in the passed
// string slice. It does this by attempting to decode each address using the
// current active network parameters. If any single address fails to decode
// properly, the function returns an error. Otherwise, nil is returned. | [
"checkAddressValidity",
"checks",
"the",
"validity",
"of",
"each",
"address",
"in",
"the",
"passed",
"string",
"slice",
".",
"It",
"does",
"this",
"by",
"attempting",
"to",
"decode",
"each",
"address",
"using",
"the",
"current",
"active",
"network",
"parameters"... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcwebsocket.go#L1950-L1962 |
163,604 | btcsuite/btcd | rpcwebsocket.go | deserializeOutpoints | func deserializeOutpoints(serializedOuts []btcjson.OutPoint) ([]*wire.OutPoint, error) {
outpoints := make([]*wire.OutPoint, 0, len(serializedOuts))
for i := range serializedOuts {
blockHash, err := chainhash.NewHashFromStr(serializedOuts[i].Hash)
if err != nil {
return nil, rpcDecodeHexError(serializedOuts[i].Hash)
}
index := serializedOuts[i].Index
outpoints = append(outpoints, wire.NewOutPoint(blockHash, index))
}
return outpoints, nil
} | go | func deserializeOutpoints(serializedOuts []btcjson.OutPoint) ([]*wire.OutPoint, error) {
outpoints := make([]*wire.OutPoint, 0, len(serializedOuts))
for i := range serializedOuts {
blockHash, err := chainhash.NewHashFromStr(serializedOuts[i].Hash)
if err != nil {
return nil, rpcDecodeHexError(serializedOuts[i].Hash)
}
index := serializedOuts[i].Index
outpoints = append(outpoints, wire.NewOutPoint(blockHash, index))
}
return outpoints, nil
} | [
"func",
"deserializeOutpoints",
"(",
"serializedOuts",
"[",
"]",
"btcjson",
".",
"OutPoint",
")",
"(",
"[",
"]",
"*",
"wire",
".",
"OutPoint",
",",
"error",
")",
"{",
"outpoints",
":=",
"make",
"(",
"[",
"]",
"*",
"wire",
".",
"OutPoint",
",",
"0",
"... | // deserializeOutpoints deserializes each serialized outpoint. | [
"deserializeOutpoints",
"deserializes",
"each",
"serialized",
"outpoint",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcwebsocket.go#L1965-L1977 |
163,605 | btcsuite/btcd | rpcwebsocket.go | unspentSlice | func (r *rescanKeys) unspentSlice() []*wire.OutPoint {
ops := make([]*wire.OutPoint, 0, len(r.unspent))
for op := range r.unspent {
opCopy := op
ops = append(ops, &opCopy)
}
return ops
} | go | func (r *rescanKeys) unspentSlice() []*wire.OutPoint {
ops := make([]*wire.OutPoint, 0, len(r.unspent))
for op := range r.unspent {
opCopy := op
ops = append(ops, &opCopy)
}
return ops
} | [
"func",
"(",
"r",
"*",
"rescanKeys",
")",
"unspentSlice",
"(",
")",
"[",
"]",
"*",
"wire",
".",
"OutPoint",
"{",
"ops",
":=",
"make",
"(",
"[",
"]",
"*",
"wire",
".",
"OutPoint",
",",
"0",
",",
"len",
"(",
"r",
".",
"unspent",
")",
")",
"\n",
... | // unspentSlice returns a slice of currently-unspent outpoints for the rescan
// lookup keys. This is primarily intended to be used to register outpoints
// for continuous notifications after a rescan has completed. | [
"unspentSlice",
"returns",
"a",
"slice",
"of",
"currently",
"-",
"unspent",
"outpoints",
"for",
"the",
"rescan",
"lookup",
"keys",
".",
"This",
"is",
"primarily",
"intended",
"to",
"be",
"used",
"to",
"register",
"outpoints",
"for",
"continuous",
"notifications"... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcwebsocket.go#L1987-L1994 |
163,606 | btcsuite/btcd | rpcwebsocket.go | recoverFromReorg | func recoverFromReorg(chain *blockchain.BlockChain, minBlock, maxBlock int32,
lastBlock *chainhash.Hash) ([]chainhash.Hash, error) {
hashList, err := chain.HeightRange(minBlock, maxBlock)
if err != nil {
rpcsLog.Errorf("Error looking up block range: %v", err)
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCDatabase,
Message: "Database error: " + err.Error(),
}
}
if lastBlock == nil || len(hashList) == 0 {
return hashList, nil
}
blk, err := chain.BlockByHash(&hashList[0])
if err != nil {
rpcsLog.Errorf("Error looking up possibly reorged block: %v",
err)
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCDatabase,
Message: "Database error: " + err.Error(),
}
}
jsonErr := descendantBlock(lastBlock, blk)
if jsonErr != nil {
return nil, jsonErr
}
return hashList, nil
} | go | func recoverFromReorg(chain *blockchain.BlockChain, minBlock, maxBlock int32,
lastBlock *chainhash.Hash) ([]chainhash.Hash, error) {
hashList, err := chain.HeightRange(minBlock, maxBlock)
if err != nil {
rpcsLog.Errorf("Error looking up block range: %v", err)
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCDatabase,
Message: "Database error: " + err.Error(),
}
}
if lastBlock == nil || len(hashList) == 0 {
return hashList, nil
}
blk, err := chain.BlockByHash(&hashList[0])
if err != nil {
rpcsLog.Errorf("Error looking up possibly reorged block: %v",
err)
return nil, &btcjson.RPCError{
Code: btcjson.ErrRPCDatabase,
Message: "Database error: " + err.Error(),
}
}
jsonErr := descendantBlock(lastBlock, blk)
if jsonErr != nil {
return nil, jsonErr
}
return hashList, nil
} | [
"func",
"recoverFromReorg",
"(",
"chain",
"*",
"blockchain",
".",
"BlockChain",
",",
"minBlock",
",",
"maxBlock",
"int32",
",",
"lastBlock",
"*",
"chainhash",
".",
"Hash",
")",
"(",
"[",
"]",
"chainhash",
".",
"Hash",
",",
"error",
")",
"{",
"hashList",
... | // recoverFromReorg attempts to recover from a detected reorganize during a
// rescan. It fetches a new range of block shas from the database and
// verifies that the new range of blocks is on the same fork as a previous
// range of blocks. If this condition does not hold true, the JSON-RPC error
// for an unrecoverable reorganize is returned. | [
"recoverFromReorg",
"attempts",
"to",
"recover",
"from",
"a",
"detected",
"reorganize",
"during",
"a",
"rescan",
".",
"It",
"fetches",
"a",
"new",
"range",
"of",
"block",
"shas",
"from",
"the",
"database",
"and",
"verifies",
"that",
"the",
"new",
"range",
"o... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcwebsocket.go#L2281-L2310 |
163,607 | btcsuite/btcd | rpcwebsocket.go | descendantBlock | func descendantBlock(prevHash *chainhash.Hash, curBlock *btcutil.Block) error {
curHash := &curBlock.MsgBlock().Header.PrevBlock
if !prevHash.IsEqual(curHash) {
rpcsLog.Errorf("Stopping rescan for reorged block %v "+
"(replaced by block %v)", prevHash, curHash)
return &ErrRescanReorg
}
return nil
} | go | func descendantBlock(prevHash *chainhash.Hash, curBlock *btcutil.Block) error {
curHash := &curBlock.MsgBlock().Header.PrevBlock
if !prevHash.IsEqual(curHash) {
rpcsLog.Errorf("Stopping rescan for reorged block %v "+
"(replaced by block %v)", prevHash, curHash)
return &ErrRescanReorg
}
return nil
} | [
"func",
"descendantBlock",
"(",
"prevHash",
"*",
"chainhash",
".",
"Hash",
",",
"curBlock",
"*",
"btcutil",
".",
"Block",
")",
"error",
"{",
"curHash",
":=",
"&",
"curBlock",
".",
"MsgBlock",
"(",
")",
".",
"Header",
".",
"PrevBlock",
"\n",
"if",
"!",
... | // descendantBlock returns the appropriate JSON-RPC error if a current block
// fetched during a reorganize is not a direct child of the parent block hash. | [
"descendantBlock",
"returns",
"the",
"appropriate",
"JSON",
"-",
"RPC",
"error",
"if",
"a",
"current",
"block",
"fetched",
"during",
"a",
"reorganize",
"is",
"not",
"a",
"direct",
"child",
"of",
"the",
"parent",
"block",
"hash",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcwebsocket.go#L2314-L2322 |
163,608 | btcsuite/btcd | btcec/ciphering.go | Decrypt | func Decrypt(priv *PrivateKey, in []byte) ([]byte, error) {
// IV + Curve params/X/Y + 1 block + HMAC-256
if len(in) < aes.BlockSize+70+aes.BlockSize+sha256.Size {
return nil, errInputTooShort
}
// read iv
iv := in[:aes.BlockSize]
offset := aes.BlockSize
// start reading pubkey
if !bytes.Equal(in[offset:offset+2], ciphCurveBytes[:]) {
return nil, errUnsupportedCurve
}
offset += 2
if !bytes.Equal(in[offset:offset+2], ciphCoordLength[:]) {
return nil, errInvalidXLength
}
offset += 2
xBytes := in[offset : offset+32]
offset += 32
if !bytes.Equal(in[offset:offset+2], ciphCoordLength[:]) {
return nil, errInvalidYLength
}
offset += 2
yBytes := in[offset : offset+32]
offset += 32
pb := make([]byte, 65)
pb[0] = byte(0x04) // uncompressed
copy(pb[1:33], xBytes)
copy(pb[33:], yBytes)
// check if (X, Y) lies on the curve and create a Pubkey if it does
pubkey, err := ParsePubKey(pb, S256())
if err != nil {
return nil, err
}
// check for cipher text length
if (len(in)-aes.BlockSize-offset-sha256.Size)%aes.BlockSize != 0 {
return nil, errInvalidPadding // not padded to 16 bytes
}
// read hmac
messageMAC := in[len(in)-sha256.Size:]
// generate shared secret
ecdhKey := GenerateSharedSecret(priv, pubkey)
derivedKey := sha512.Sum512(ecdhKey)
keyE := derivedKey[:32]
keyM := derivedKey[32:]
// verify mac
hm := hmac.New(sha256.New, keyM)
hm.Write(in[:len(in)-sha256.Size]) // everything is hashed
expectedMAC := hm.Sum(nil)
if !hmac.Equal(messageMAC, expectedMAC) {
return nil, ErrInvalidMAC
}
// start decryption
block, err := aes.NewCipher(keyE)
if err != nil {
return nil, err
}
mode := cipher.NewCBCDecrypter(block, iv)
// same length as ciphertext
plaintext := make([]byte, len(in)-offset-sha256.Size)
mode.CryptBlocks(plaintext, in[offset:len(in)-sha256.Size])
return removePKCSPadding(plaintext)
} | go | func Decrypt(priv *PrivateKey, in []byte) ([]byte, error) {
// IV + Curve params/X/Y + 1 block + HMAC-256
if len(in) < aes.BlockSize+70+aes.BlockSize+sha256.Size {
return nil, errInputTooShort
}
// read iv
iv := in[:aes.BlockSize]
offset := aes.BlockSize
// start reading pubkey
if !bytes.Equal(in[offset:offset+2], ciphCurveBytes[:]) {
return nil, errUnsupportedCurve
}
offset += 2
if !bytes.Equal(in[offset:offset+2], ciphCoordLength[:]) {
return nil, errInvalidXLength
}
offset += 2
xBytes := in[offset : offset+32]
offset += 32
if !bytes.Equal(in[offset:offset+2], ciphCoordLength[:]) {
return nil, errInvalidYLength
}
offset += 2
yBytes := in[offset : offset+32]
offset += 32
pb := make([]byte, 65)
pb[0] = byte(0x04) // uncompressed
copy(pb[1:33], xBytes)
copy(pb[33:], yBytes)
// check if (X, Y) lies on the curve and create a Pubkey if it does
pubkey, err := ParsePubKey(pb, S256())
if err != nil {
return nil, err
}
// check for cipher text length
if (len(in)-aes.BlockSize-offset-sha256.Size)%aes.BlockSize != 0 {
return nil, errInvalidPadding // not padded to 16 bytes
}
// read hmac
messageMAC := in[len(in)-sha256.Size:]
// generate shared secret
ecdhKey := GenerateSharedSecret(priv, pubkey)
derivedKey := sha512.Sum512(ecdhKey)
keyE := derivedKey[:32]
keyM := derivedKey[32:]
// verify mac
hm := hmac.New(sha256.New, keyM)
hm.Write(in[:len(in)-sha256.Size]) // everything is hashed
expectedMAC := hm.Sum(nil)
if !hmac.Equal(messageMAC, expectedMAC) {
return nil, ErrInvalidMAC
}
// start decryption
block, err := aes.NewCipher(keyE)
if err != nil {
return nil, err
}
mode := cipher.NewCBCDecrypter(block, iv)
// same length as ciphertext
plaintext := make([]byte, len(in)-offset-sha256.Size)
mode.CryptBlocks(plaintext, in[offset:len(in)-sha256.Size])
return removePKCSPadding(plaintext)
} | [
"func",
"Decrypt",
"(",
"priv",
"*",
"PrivateKey",
",",
"in",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"// IV + Curve params/X/Y + 1 block + HMAC-256",
"if",
"len",
"(",
"in",
")",
"<",
"aes",
".",
"BlockSize",
"+",
"70",
"... | // Decrypt decrypts data that was encrypted using the Encrypt function. | [
"Decrypt",
"decrypts",
"data",
"that",
"was",
"encrypted",
"using",
"the",
"Encrypt",
"function",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcec/ciphering.go#L121-L196 |
163,609 | btcsuite/btcd | btcec/ciphering.go | removePKCSPadding | func removePKCSPadding(src []byte) ([]byte, error) {
length := len(src)
padLength := int(src[length-1])
if padLength > aes.BlockSize || length < aes.BlockSize {
return nil, errInvalidPadding
}
return src[:length-padLength], nil
} | go | func removePKCSPadding(src []byte) ([]byte, error) {
length := len(src)
padLength := int(src[length-1])
if padLength > aes.BlockSize || length < aes.BlockSize {
return nil, errInvalidPadding
}
return src[:length-padLength], nil
} | [
"func",
"removePKCSPadding",
"(",
"src",
"[",
"]",
"byte",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"length",
":=",
"len",
"(",
"src",
")",
"\n",
"padLength",
":=",
"int",
"(",
"src",
"[",
"length",
"-",
"1",
"]",
")",
"\n",
"if",
"p... | // removePKCSPadding removes padding from data that was added with addPKCSPadding | [
"removePKCSPadding",
"removes",
"padding",
"from",
"data",
"that",
"was",
"added",
"with",
"addPKCSPadding"
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcec/ciphering.go#L208-L216 |
163,610 | btcsuite/btcd | database/internal/treap/common.go | nodeSize | func nodeSize(node *treapNode) uint64 {
return nodeFieldsSize + uint64(len(node.key)+len(node.value))
} | go | func nodeSize(node *treapNode) uint64 {
return nodeFieldsSize + uint64(len(node.key)+len(node.value))
} | [
"func",
"nodeSize",
"(",
"node",
"*",
"treapNode",
")",
"uint64",
"{",
"return",
"nodeFieldsSize",
"+",
"uint64",
"(",
"len",
"(",
"node",
".",
"key",
")",
"+",
"len",
"(",
"node",
".",
"value",
")",
")",
"\n",
"}"
] | // nodeSize returns the number of bytes the specified node occupies including
// the struct fields and the contents of the key and value. | [
"nodeSize",
"returns",
"the",
"number",
"of",
"bytes",
"the",
"specified",
"node",
"occupies",
"including",
"the",
"struct",
"fields",
"and",
"the",
"contents",
"of",
"the",
"key",
"and",
"value",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/database/internal/treap/common.go#L47-L49 |
163,611 | btcsuite/btcd | database/internal/treap/common.go | newTreapNode | func newTreapNode(key, value []byte, priority int) *treapNode {
return &treapNode{key: key, value: value, priority: priority}
} | go | func newTreapNode(key, value []byte, priority int) *treapNode {
return &treapNode{key: key, value: value, priority: priority}
} | [
"func",
"newTreapNode",
"(",
"key",
",",
"value",
"[",
"]",
"byte",
",",
"priority",
"int",
")",
"*",
"treapNode",
"{",
"return",
"&",
"treapNode",
"{",
"key",
":",
"key",
",",
"value",
":",
"value",
",",
"priority",
":",
"priority",
"}",
"\n",
"}"
] | // newTreapNode returns a new node from the given key, value, and priority. The
// node is not initially linked to any others. | [
"newTreapNode",
"returns",
"a",
"new",
"node",
"from",
"the",
"given",
"key",
"value",
"and",
"priority",
".",
"The",
"node",
"is",
"not",
"initially",
"linked",
"to",
"any",
"others",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/database/internal/treap/common.go#L53-L55 |
163,612 | btcsuite/btcd | database/internal/treap/common.go | At | func (s *parentStack) At(n int) *treapNode {
index := s.index - n - 1
if index < 0 {
return nil
}
if index < staticDepth {
return s.items[index]
}
return s.overflow[index-staticDepth]
} | go | func (s *parentStack) At(n int) *treapNode {
index := s.index - n - 1
if index < 0 {
return nil
}
if index < staticDepth {
return s.items[index]
}
return s.overflow[index-staticDepth]
} | [
"func",
"(",
"s",
"*",
"parentStack",
")",
"At",
"(",
"n",
"int",
")",
"*",
"treapNode",
"{",
"index",
":=",
"s",
".",
"index",
"-",
"n",
"-",
"1",
"\n",
"if",
"index",
"<",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"if",
"index",
"<",
"s... | // At returns the item n number of items from the top of the stack, where 0 is
// the topmost item, without removing it. It returns nil if n exceeds the
// number of items on the stack. | [
"At",
"returns",
"the",
"item",
"n",
"number",
"of",
"items",
"from",
"the",
"top",
"of",
"the",
"stack",
"where",
"0",
"is",
"the",
"topmost",
"item",
"without",
"removing",
"it",
".",
"It",
"returns",
"nil",
"if",
"n",
"exceeds",
"the",
"number",
"of... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/database/internal/treap/common.go#L78-L89 |
163,613 | btcsuite/btcd | database/internal/treap/common.go | Pop | func (s *parentStack) Pop() *treapNode {
if s.index == 0 {
return nil
}
s.index--
if s.index < staticDepth {
node := s.items[s.index]
s.items[s.index] = nil
return node
}
node := s.overflow[s.index-staticDepth]
s.overflow[s.index-staticDepth] = nil
return node
} | go | func (s *parentStack) Pop() *treapNode {
if s.index == 0 {
return nil
}
s.index--
if s.index < staticDepth {
node := s.items[s.index]
s.items[s.index] = nil
return node
}
node := s.overflow[s.index-staticDepth]
s.overflow[s.index-staticDepth] = nil
return node
} | [
"func",
"(",
"s",
"*",
"parentStack",
")",
"Pop",
"(",
")",
"*",
"treapNode",
"{",
"if",
"s",
".",
"index",
"==",
"0",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"s",
".",
"index",
"--",
"\n",
"if",
"s",
".",
"index",
"<",
"staticDepth",
"{",
"no... | // Pop removes the top item from the stack. It returns nil if the stack is
// empty. | [
"Pop",
"removes",
"the",
"top",
"item",
"from",
"the",
"stack",
".",
"It",
"returns",
"nil",
"if",
"the",
"stack",
"is",
"empty",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/database/internal/treap/common.go#L93-L108 |
163,614 | btcsuite/btcd | database/internal/treap/common.go | Push | func (s *parentStack) Push(node *treapNode) {
if s.index < staticDepth {
s.items[s.index] = node
s.index++
return
}
// This approach is used over append because reslicing the slice to pop
// the item causes the compiler to make unneeded allocations. Also,
// since the max number of items is related to the tree depth which
// requires expontentially more items to increase, only increase the cap
// one item at a time. This is more intelligent than the generic append
// expansion algorithm which often doubles the cap.
index := s.index - staticDepth
if index+1 > cap(s.overflow) {
overflow := make([]*treapNode, index+1)
copy(overflow, s.overflow)
s.overflow = overflow
}
s.overflow[index] = node
s.index++
} | go | func (s *parentStack) Push(node *treapNode) {
if s.index < staticDepth {
s.items[s.index] = node
s.index++
return
}
// This approach is used over append because reslicing the slice to pop
// the item causes the compiler to make unneeded allocations. Also,
// since the max number of items is related to the tree depth which
// requires expontentially more items to increase, only increase the cap
// one item at a time. This is more intelligent than the generic append
// expansion algorithm which often doubles the cap.
index := s.index - staticDepth
if index+1 > cap(s.overflow) {
overflow := make([]*treapNode, index+1)
copy(overflow, s.overflow)
s.overflow = overflow
}
s.overflow[index] = node
s.index++
} | [
"func",
"(",
"s",
"*",
"parentStack",
")",
"Push",
"(",
"node",
"*",
"treapNode",
")",
"{",
"if",
"s",
".",
"index",
"<",
"staticDepth",
"{",
"s",
".",
"items",
"[",
"s",
".",
"index",
"]",
"=",
"node",
"\n",
"s",
".",
"index",
"++",
"\n",
"ret... | // Push pushes the passed item onto the top of the stack. | [
"Push",
"pushes",
"the",
"passed",
"item",
"onto",
"the",
"top",
"of",
"the",
"stack",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/database/internal/treap/common.go#L111-L132 |
163,615 | btcsuite/btcd | peer/peer.go | newNetAddress | func newNetAddress(addr net.Addr, services wire.ServiceFlag) (*wire.NetAddress, error) {
// addr will be a net.TCPAddr when not using a proxy.
if tcpAddr, ok := addr.(*net.TCPAddr); ok {
ip := tcpAddr.IP
port := uint16(tcpAddr.Port)
na := wire.NewNetAddressIPPort(ip, port, services)
return na, nil
}
// addr will be a socks.ProxiedAddr when using a proxy.
if proxiedAddr, ok := addr.(*socks.ProxiedAddr); ok {
ip := net.ParseIP(proxiedAddr.Host)
if ip == nil {
ip = net.ParseIP("0.0.0.0")
}
port := uint16(proxiedAddr.Port)
na := wire.NewNetAddressIPPort(ip, port, services)
return na, nil
}
// For the most part, addr should be one of the two above cases, but
// to be safe, fall back to trying to parse the information from the
// address string as a last resort.
host, portStr, err := net.SplitHostPort(addr.String())
if err != nil {
return nil, err
}
ip := net.ParseIP(host)
port, err := strconv.ParseUint(portStr, 10, 16)
if err != nil {
return nil, err
}
na := wire.NewNetAddressIPPort(ip, uint16(port), services)
return na, nil
} | go | func newNetAddress(addr net.Addr, services wire.ServiceFlag) (*wire.NetAddress, error) {
// addr will be a net.TCPAddr when not using a proxy.
if tcpAddr, ok := addr.(*net.TCPAddr); ok {
ip := tcpAddr.IP
port := uint16(tcpAddr.Port)
na := wire.NewNetAddressIPPort(ip, port, services)
return na, nil
}
// addr will be a socks.ProxiedAddr when using a proxy.
if proxiedAddr, ok := addr.(*socks.ProxiedAddr); ok {
ip := net.ParseIP(proxiedAddr.Host)
if ip == nil {
ip = net.ParseIP("0.0.0.0")
}
port := uint16(proxiedAddr.Port)
na := wire.NewNetAddressIPPort(ip, port, services)
return na, nil
}
// For the most part, addr should be one of the two above cases, but
// to be safe, fall back to trying to parse the information from the
// address string as a last resort.
host, portStr, err := net.SplitHostPort(addr.String())
if err != nil {
return nil, err
}
ip := net.ParseIP(host)
port, err := strconv.ParseUint(portStr, 10, 16)
if err != nil {
return nil, err
}
na := wire.NewNetAddressIPPort(ip, uint16(port), services)
return na, nil
} | [
"func",
"newNetAddress",
"(",
"addr",
"net",
".",
"Addr",
",",
"services",
"wire",
".",
"ServiceFlag",
")",
"(",
"*",
"wire",
".",
"NetAddress",
",",
"error",
")",
"{",
"// addr will be a net.TCPAddr when not using a proxy.",
"if",
"tcpAddr",
",",
"ok",
":=",
... | // newNetAddress attempts to extract the IP address and port from the passed
// net.Addr interface and create a bitcoin NetAddress structure using that
// information. | [
"newNetAddress",
"attempts",
"to",
"extract",
"the",
"IP",
"address",
"and",
"port",
"from",
"the",
"passed",
"net",
".",
"Addr",
"interface",
"and",
"create",
"a",
"bitcoin",
"NetAddress",
"structure",
"using",
"that",
"information",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L292-L326 |
163,616 | btcsuite/btcd | peer/peer.go | String | func (p *Peer) String() string {
return fmt.Sprintf("%s (%s)", p.addr, directionString(p.inbound))
} | go | func (p *Peer) String() string {
return fmt.Sprintf("%s (%s)", p.addr, directionString(p.inbound))
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"String",
"(",
")",
"string",
"{",
"return",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"p",
".",
"addr",
",",
"directionString",
"(",
"p",
".",
"inbound",
")",
")",
"\n",
"}"
] | // String returns the peer's address and directionality as a human-readable
// string.
//
// This function is safe for concurrent access. | [
"String",
"returns",
"the",
"peer",
"s",
"address",
"and",
"directionality",
"as",
"a",
"human",
"-",
"readable",
"string",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L488-L490 |
163,617 | btcsuite/btcd | peer/peer.go | UpdateLastBlockHeight | func (p *Peer) UpdateLastBlockHeight(newHeight int32) {
p.statsMtx.Lock()
log.Tracef("Updating last block height of peer %v from %v to %v",
p.addr, p.lastBlock, newHeight)
p.lastBlock = newHeight
p.statsMtx.Unlock()
} | go | func (p *Peer) UpdateLastBlockHeight(newHeight int32) {
p.statsMtx.Lock()
log.Tracef("Updating last block height of peer %v from %v to %v",
p.addr, p.lastBlock, newHeight)
p.lastBlock = newHeight
p.statsMtx.Unlock()
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"UpdateLastBlockHeight",
"(",
"newHeight",
"int32",
")",
"{",
"p",
".",
"statsMtx",
".",
"Lock",
"(",
")",
"\n",
"log",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"p",
".",
"addr",
",",
"p",
".",
"lastBlock",
",",
"n... | // UpdateLastBlockHeight updates the last known block for the peer.
//
// This function is safe for concurrent access. | [
"UpdateLastBlockHeight",
"updates",
"the",
"last",
"known",
"block",
"for",
"the",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L495-L501 |
163,618 | btcsuite/btcd | peer/peer.go | UpdateLastAnnouncedBlock | func (p *Peer) UpdateLastAnnouncedBlock(blkHash *chainhash.Hash) {
log.Tracef("Updating last blk for peer %v, %v", p.addr, blkHash)
p.statsMtx.Lock()
p.lastAnnouncedBlock = blkHash
p.statsMtx.Unlock()
} | go | func (p *Peer) UpdateLastAnnouncedBlock(blkHash *chainhash.Hash) {
log.Tracef("Updating last blk for peer %v, %v", p.addr, blkHash)
p.statsMtx.Lock()
p.lastAnnouncedBlock = blkHash
p.statsMtx.Unlock()
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"UpdateLastAnnouncedBlock",
"(",
"blkHash",
"*",
"chainhash",
".",
"Hash",
")",
"{",
"log",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"p",
".",
"addr",
",",
"blkHash",
")",
"\n\n",
"p",
".",
"statsMtx",
".",
"Lock",
"... | // UpdateLastAnnouncedBlock updates meta-data about the last block hash this
// peer is known to have announced.
//
// This function is safe for concurrent access. | [
"UpdateLastAnnouncedBlock",
"updates",
"meta",
"-",
"data",
"about",
"the",
"last",
"block",
"hash",
"this",
"peer",
"is",
"known",
"to",
"have",
"announced",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L507-L513 |
163,619 | btcsuite/btcd | peer/peer.go | AddKnownInventory | func (p *Peer) AddKnownInventory(invVect *wire.InvVect) {
p.knownInventory.Add(invVect)
} | go | func (p *Peer) AddKnownInventory(invVect *wire.InvVect) {
p.knownInventory.Add(invVect)
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"AddKnownInventory",
"(",
"invVect",
"*",
"wire",
".",
"InvVect",
")",
"{",
"p",
".",
"knownInventory",
".",
"Add",
"(",
"invVect",
")",
"\n",
"}"
] | // AddKnownInventory adds the passed inventory to the cache of known inventory
// for the peer.
//
// This function is safe for concurrent access. | [
"AddKnownInventory",
"adds",
"the",
"passed",
"inventory",
"to",
"the",
"cache",
"of",
"known",
"inventory",
"for",
"the",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L519-L521 |
163,620 | btcsuite/btcd | peer/peer.go | StatsSnapshot | func (p *Peer) StatsSnapshot() *StatsSnap {
p.statsMtx.RLock()
p.flagsMtx.Lock()
id := p.id
addr := p.addr
userAgent := p.userAgent
services := p.services
protocolVersion := p.advertisedProtoVer
p.flagsMtx.Unlock()
// Get a copy of all relevant flags and stats.
statsSnap := &StatsSnap{
ID: id,
Addr: addr,
UserAgent: userAgent,
Services: services,
LastSend: p.LastSend(),
LastRecv: p.LastRecv(),
BytesSent: p.BytesSent(),
BytesRecv: p.BytesReceived(),
ConnTime: p.timeConnected,
TimeOffset: p.timeOffset,
Version: protocolVersion,
Inbound: p.inbound,
StartingHeight: p.startingHeight,
LastBlock: p.lastBlock,
LastPingNonce: p.lastPingNonce,
LastPingMicros: p.lastPingMicros,
LastPingTime: p.lastPingTime,
}
p.statsMtx.RUnlock()
return statsSnap
} | go | func (p *Peer) StatsSnapshot() *StatsSnap {
p.statsMtx.RLock()
p.flagsMtx.Lock()
id := p.id
addr := p.addr
userAgent := p.userAgent
services := p.services
protocolVersion := p.advertisedProtoVer
p.flagsMtx.Unlock()
// Get a copy of all relevant flags and stats.
statsSnap := &StatsSnap{
ID: id,
Addr: addr,
UserAgent: userAgent,
Services: services,
LastSend: p.LastSend(),
LastRecv: p.LastRecv(),
BytesSent: p.BytesSent(),
BytesRecv: p.BytesReceived(),
ConnTime: p.timeConnected,
TimeOffset: p.timeOffset,
Version: protocolVersion,
Inbound: p.inbound,
StartingHeight: p.startingHeight,
LastBlock: p.lastBlock,
LastPingNonce: p.lastPingNonce,
LastPingMicros: p.lastPingMicros,
LastPingTime: p.lastPingTime,
}
p.statsMtx.RUnlock()
return statsSnap
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"StatsSnapshot",
"(",
")",
"*",
"StatsSnap",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n\n",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"id",
":=",
"p",
".",
"id",
"\n",
"addr",
":=",
"p",
... | // StatsSnapshot returns a snapshot of the current peer flags and statistics.
//
// This function is safe for concurrent access. | [
"StatsSnapshot",
"returns",
"a",
"snapshot",
"of",
"the",
"current",
"peer",
"flags",
"and",
"statistics",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L526-L560 |
163,621 | btcsuite/btcd | peer/peer.go | ID | func (p *Peer) ID() int32 {
p.flagsMtx.Lock()
id := p.id
p.flagsMtx.Unlock()
return id
} | go | func (p *Peer) ID() int32 {
p.flagsMtx.Lock()
id := p.id
p.flagsMtx.Unlock()
return id
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"ID",
"(",
")",
"int32",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"id",
":=",
"p",
".",
"id",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"id",
"\n",
"}"
] | // ID returns the peer id.
//
// This function is safe for concurrent access. | [
"ID",
"returns",
"the",
"peer",
"id",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L565-L571 |
163,622 | btcsuite/btcd | peer/peer.go | NA | func (p *Peer) NA() *wire.NetAddress {
p.flagsMtx.Lock()
na := p.na
p.flagsMtx.Unlock()
return na
} | go | func (p *Peer) NA() *wire.NetAddress {
p.flagsMtx.Lock()
na := p.na
p.flagsMtx.Unlock()
return na
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"NA",
"(",
")",
"*",
"wire",
".",
"NetAddress",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"na",
":=",
"p",
".",
"na",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"na... | // NA returns the peer network address.
//
// This function is safe for concurrent access. | [
"NA",
"returns",
"the",
"peer",
"network",
"address",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L576-L582 |
163,623 | btcsuite/btcd | peer/peer.go | Services | func (p *Peer) Services() wire.ServiceFlag {
p.flagsMtx.Lock()
services := p.services
p.flagsMtx.Unlock()
return services
} | go | func (p *Peer) Services() wire.ServiceFlag {
p.flagsMtx.Lock()
services := p.services
p.flagsMtx.Unlock()
return services
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"Services",
"(",
")",
"wire",
".",
"ServiceFlag",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"services",
":=",
"p",
".",
"services",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
"re... | // Services returns the services flag of the remote peer.
//
// This function is safe for concurrent access. | [
"Services",
"returns",
"the",
"services",
"flag",
"of",
"the",
"remote",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L603-L609 |
163,624 | btcsuite/btcd | peer/peer.go | UserAgent | func (p *Peer) UserAgent() string {
p.flagsMtx.Lock()
userAgent := p.userAgent
p.flagsMtx.Unlock()
return userAgent
} | go | func (p *Peer) UserAgent() string {
p.flagsMtx.Lock()
userAgent := p.userAgent
p.flagsMtx.Unlock()
return userAgent
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"UserAgent",
"(",
")",
"string",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"userAgent",
":=",
"p",
".",
"userAgent",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"userAgent... | // UserAgent returns the user agent of the remote peer.
//
// This function is safe for concurrent access. | [
"UserAgent",
"returns",
"the",
"user",
"agent",
"of",
"the",
"remote",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L614-L620 |
163,625 | btcsuite/btcd | peer/peer.go | LastAnnouncedBlock | func (p *Peer) LastAnnouncedBlock() *chainhash.Hash {
p.statsMtx.RLock()
lastAnnouncedBlock := p.lastAnnouncedBlock
p.statsMtx.RUnlock()
return lastAnnouncedBlock
} | go | func (p *Peer) LastAnnouncedBlock() *chainhash.Hash {
p.statsMtx.RLock()
lastAnnouncedBlock := p.lastAnnouncedBlock
p.statsMtx.RUnlock()
return lastAnnouncedBlock
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"LastAnnouncedBlock",
"(",
")",
"*",
"chainhash",
".",
"Hash",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n",
"lastAnnouncedBlock",
":=",
"p",
".",
"lastAnnouncedBlock",
"\n",
"p",
".",
"statsMtx",
".",
"RU... | // LastAnnouncedBlock returns the last announced block of the remote peer.
//
// This function is safe for concurrent access. | [
"LastAnnouncedBlock",
"returns",
"the",
"last",
"announced",
"block",
"of",
"the",
"remote",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L625-L631 |
163,626 | btcsuite/btcd | peer/peer.go | LastPingNonce | func (p *Peer) LastPingNonce() uint64 {
p.statsMtx.RLock()
lastPingNonce := p.lastPingNonce
p.statsMtx.RUnlock()
return lastPingNonce
} | go | func (p *Peer) LastPingNonce() uint64 {
p.statsMtx.RLock()
lastPingNonce := p.lastPingNonce
p.statsMtx.RUnlock()
return lastPingNonce
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"LastPingNonce",
"(",
")",
"uint64",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n",
"lastPingNonce",
":=",
"p",
".",
"lastPingNonce",
"\n",
"p",
".",
"statsMtx",
".",
"RUnlock",
"(",
")",
"\n\n",
"return"... | // LastPingNonce returns the last ping nonce of the remote peer.
//
// This function is safe for concurrent access. | [
"LastPingNonce",
"returns",
"the",
"last",
"ping",
"nonce",
"of",
"the",
"remote",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L636-L642 |
163,627 | btcsuite/btcd | peer/peer.go | LastPingTime | func (p *Peer) LastPingTime() time.Time {
p.statsMtx.RLock()
lastPingTime := p.lastPingTime
p.statsMtx.RUnlock()
return lastPingTime
} | go | func (p *Peer) LastPingTime() time.Time {
p.statsMtx.RLock()
lastPingTime := p.lastPingTime
p.statsMtx.RUnlock()
return lastPingTime
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"LastPingTime",
"(",
")",
"time",
".",
"Time",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n",
"lastPingTime",
":=",
"p",
".",
"lastPingTime",
"\n",
"p",
".",
"statsMtx",
".",
"RUnlock",
"(",
")",
"\n\n"... | // LastPingTime returns the last ping time of the remote peer.
//
// This function is safe for concurrent access. | [
"LastPingTime",
"returns",
"the",
"last",
"ping",
"time",
"of",
"the",
"remote",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L647-L653 |
163,628 | btcsuite/btcd | peer/peer.go | LastPingMicros | func (p *Peer) LastPingMicros() int64 {
p.statsMtx.RLock()
lastPingMicros := p.lastPingMicros
p.statsMtx.RUnlock()
return lastPingMicros
} | go | func (p *Peer) LastPingMicros() int64 {
p.statsMtx.RLock()
lastPingMicros := p.lastPingMicros
p.statsMtx.RUnlock()
return lastPingMicros
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"LastPingMicros",
"(",
")",
"int64",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n",
"lastPingMicros",
":=",
"p",
".",
"lastPingMicros",
"\n",
"p",
".",
"statsMtx",
".",
"RUnlock",
"(",
")",
"\n\n",
"retur... | // LastPingMicros returns the last ping micros of the remote peer.
//
// This function is safe for concurrent access. | [
"LastPingMicros",
"returns",
"the",
"last",
"ping",
"micros",
"of",
"the",
"remote",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L658-L664 |
163,629 | btcsuite/btcd | peer/peer.go | VersionKnown | func (p *Peer) VersionKnown() bool {
p.flagsMtx.Lock()
versionKnown := p.versionKnown
p.flagsMtx.Unlock()
return versionKnown
} | go | func (p *Peer) VersionKnown() bool {
p.flagsMtx.Lock()
versionKnown := p.versionKnown
p.flagsMtx.Unlock()
return versionKnown
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"VersionKnown",
"(",
")",
"bool",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"versionKnown",
":=",
"p",
".",
"versionKnown",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
"return",
"ve... | // VersionKnown returns the whether or not the version of a peer is known
// locally.
//
// This function is safe for concurrent access. | [
"VersionKnown",
"returns",
"the",
"whether",
"or",
"not",
"the",
"version",
"of",
"a",
"peer",
"is",
"known",
"locally",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L670-L676 |
163,630 | btcsuite/btcd | peer/peer.go | VerAckReceived | func (p *Peer) VerAckReceived() bool {
p.flagsMtx.Lock()
verAckReceived := p.verAckReceived
p.flagsMtx.Unlock()
return verAckReceived
} | go | func (p *Peer) VerAckReceived() bool {
p.flagsMtx.Lock()
verAckReceived := p.verAckReceived
p.flagsMtx.Unlock()
return verAckReceived
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"VerAckReceived",
"(",
")",
"bool",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"verAckReceived",
":=",
"p",
".",
"verAckReceived",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
"return",... | // VerAckReceived returns whether or not a verack message was received by the
// peer.
//
// This function is safe for concurrent access. | [
"VerAckReceived",
"returns",
"whether",
"or",
"not",
"a",
"verack",
"message",
"was",
"received",
"by",
"the",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L682-L688 |
163,631 | btcsuite/btcd | peer/peer.go | ProtocolVersion | func (p *Peer) ProtocolVersion() uint32 {
p.flagsMtx.Lock()
protocolVersion := p.protocolVersion
p.flagsMtx.Unlock()
return protocolVersion
} | go | func (p *Peer) ProtocolVersion() uint32 {
p.flagsMtx.Lock()
protocolVersion := p.protocolVersion
p.flagsMtx.Unlock()
return protocolVersion
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"ProtocolVersion",
"(",
")",
"uint32",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"protocolVersion",
":=",
"p",
".",
"protocolVersion",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
"ret... | // ProtocolVersion returns the negotiated peer protocol version.
//
// This function is safe for concurrent access. | [
"ProtocolVersion",
"returns",
"the",
"negotiated",
"peer",
"protocol",
"version",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L693-L699 |
163,632 | btcsuite/btcd | peer/peer.go | LastBlock | func (p *Peer) LastBlock() int32 {
p.statsMtx.RLock()
lastBlock := p.lastBlock
p.statsMtx.RUnlock()
return lastBlock
} | go | func (p *Peer) LastBlock() int32 {
p.statsMtx.RLock()
lastBlock := p.lastBlock
p.statsMtx.RUnlock()
return lastBlock
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"LastBlock",
"(",
")",
"int32",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n",
"lastBlock",
":=",
"p",
".",
"lastBlock",
"\n",
"p",
".",
"statsMtx",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"lastBloc... | // LastBlock returns the last block of the peer.
//
// This function is safe for concurrent access. | [
"LastBlock",
"returns",
"the",
"last",
"block",
"of",
"the",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L704-L710 |
163,633 | btcsuite/btcd | peer/peer.go | LastSend | func (p *Peer) LastSend() time.Time {
return time.Unix(atomic.LoadInt64(&p.lastSend), 0)
} | go | func (p *Peer) LastSend() time.Time {
return time.Unix(atomic.LoadInt64(&p.lastSend), 0)
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"LastSend",
"(",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Unix",
"(",
"atomic",
".",
"LoadInt64",
"(",
"&",
"p",
".",
"lastSend",
")",
",",
"0",
")",
"\n",
"}"
] | // LastSend returns the last send time of the peer.
//
// This function is safe for concurrent access. | [
"LastSend",
"returns",
"the",
"last",
"send",
"time",
"of",
"the",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L715-L717 |
163,634 | btcsuite/btcd | peer/peer.go | LastRecv | func (p *Peer) LastRecv() time.Time {
return time.Unix(atomic.LoadInt64(&p.lastRecv), 0)
} | go | func (p *Peer) LastRecv() time.Time {
return time.Unix(atomic.LoadInt64(&p.lastRecv), 0)
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"LastRecv",
"(",
")",
"time",
".",
"Time",
"{",
"return",
"time",
".",
"Unix",
"(",
"atomic",
".",
"LoadInt64",
"(",
"&",
"p",
".",
"lastRecv",
")",
",",
"0",
")",
"\n",
"}"
] | // LastRecv returns the last recv time of the peer.
//
// This function is safe for concurrent access. | [
"LastRecv",
"returns",
"the",
"last",
"recv",
"time",
"of",
"the",
"peer",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L722-L724 |
163,635 | btcsuite/btcd | peer/peer.go | LocalAddr | func (p *Peer) LocalAddr() net.Addr {
var localAddr net.Addr
if atomic.LoadInt32(&p.connected) != 0 {
localAddr = p.conn.LocalAddr()
}
return localAddr
} | go | func (p *Peer) LocalAddr() net.Addr {
var localAddr net.Addr
if atomic.LoadInt32(&p.connected) != 0 {
localAddr = p.conn.LocalAddr()
}
return localAddr
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"LocalAddr",
"(",
")",
"net",
".",
"Addr",
"{",
"var",
"localAddr",
"net",
".",
"Addr",
"\n",
"if",
"atomic",
".",
"LoadInt32",
"(",
"&",
"p",
".",
"connected",
")",
"!=",
"0",
"{",
"localAddr",
"=",
"p",
".",
... | // LocalAddr returns the local address of the connection.
//
// This function is safe fo concurrent access. | [
"LocalAddr",
"returns",
"the",
"local",
"address",
"of",
"the",
"connection",
".",
"This",
"function",
"is",
"safe",
"fo",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L729-L735 |
163,636 | btcsuite/btcd | peer/peer.go | TimeConnected | func (p *Peer) TimeConnected() time.Time {
p.statsMtx.RLock()
timeConnected := p.timeConnected
p.statsMtx.RUnlock()
return timeConnected
} | go | func (p *Peer) TimeConnected() time.Time {
p.statsMtx.RLock()
timeConnected := p.timeConnected
p.statsMtx.RUnlock()
return timeConnected
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"TimeConnected",
"(",
")",
"time",
".",
"Time",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n",
"timeConnected",
":=",
"p",
".",
"timeConnected",
"\n",
"p",
".",
"statsMtx",
".",
"RUnlock",
"(",
")",
"\n... | // TimeConnected returns the time at which the peer connected.
//
// This function is safe for concurrent access. | [
"TimeConnected",
"returns",
"the",
"time",
"at",
"which",
"the",
"peer",
"connected",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L754-L760 |
163,637 | btcsuite/btcd | peer/peer.go | TimeOffset | func (p *Peer) TimeOffset() int64 {
p.statsMtx.RLock()
timeOffset := p.timeOffset
p.statsMtx.RUnlock()
return timeOffset
} | go | func (p *Peer) TimeOffset() int64 {
p.statsMtx.RLock()
timeOffset := p.timeOffset
p.statsMtx.RUnlock()
return timeOffset
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"TimeOffset",
"(",
")",
"int64",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n",
"timeOffset",
":=",
"p",
".",
"timeOffset",
"\n",
"p",
".",
"statsMtx",
".",
"RUnlock",
"(",
")",
"\n\n",
"return",
"timeO... | // TimeOffset returns the number of seconds the local time was offset from the
// time the peer reported during the initial negotiation phase. Negative values
// indicate the remote peer's time is before the local time.
//
// This function is safe for concurrent access. | [
"TimeOffset",
"returns",
"the",
"number",
"of",
"seconds",
"the",
"local",
"time",
"was",
"offset",
"from",
"the",
"time",
"the",
"peer",
"reported",
"during",
"the",
"initial",
"negotiation",
"phase",
".",
"Negative",
"values",
"indicate",
"the",
"remote",
"p... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L767-L773 |
163,638 | btcsuite/btcd | peer/peer.go | StartingHeight | func (p *Peer) StartingHeight() int32 {
p.statsMtx.RLock()
startingHeight := p.startingHeight
p.statsMtx.RUnlock()
return startingHeight
} | go | func (p *Peer) StartingHeight() int32 {
p.statsMtx.RLock()
startingHeight := p.startingHeight
p.statsMtx.RUnlock()
return startingHeight
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"StartingHeight",
"(",
")",
"int32",
"{",
"p",
".",
"statsMtx",
".",
"RLock",
"(",
")",
"\n",
"startingHeight",
":=",
"p",
".",
"startingHeight",
"\n",
"p",
".",
"statsMtx",
".",
"RUnlock",
"(",
")",
"\n\n",
"retur... | // StartingHeight returns the last known height the peer reported during the
// initial negotiation phase.
//
// This function is safe for concurrent access. | [
"StartingHeight",
"returns",
"the",
"last",
"known",
"height",
"the",
"peer",
"reported",
"during",
"the",
"initial",
"negotiation",
"phase",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L779-L785 |
163,639 | btcsuite/btcd | peer/peer.go | WantsHeaders | func (p *Peer) WantsHeaders() bool {
p.flagsMtx.Lock()
sendHeadersPreferred := p.sendHeadersPreferred
p.flagsMtx.Unlock()
return sendHeadersPreferred
} | go | func (p *Peer) WantsHeaders() bool {
p.flagsMtx.Lock()
sendHeadersPreferred := p.sendHeadersPreferred
p.flagsMtx.Unlock()
return sendHeadersPreferred
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"WantsHeaders",
"(",
")",
"bool",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"sendHeadersPreferred",
":=",
"p",
".",
"sendHeadersPreferred",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
... | // WantsHeaders returns if the peer wants header messages instead of
// inventory vectors for blocks.
//
// This function is safe for concurrent access. | [
"WantsHeaders",
"returns",
"if",
"the",
"peer",
"wants",
"header",
"messages",
"instead",
"of",
"inventory",
"vectors",
"for",
"blocks",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L791-L797 |
163,640 | btcsuite/btcd | peer/peer.go | IsWitnessEnabled | func (p *Peer) IsWitnessEnabled() bool {
p.flagsMtx.Lock()
witnessEnabled := p.witnessEnabled
p.flagsMtx.Unlock()
return witnessEnabled
} | go | func (p *Peer) IsWitnessEnabled() bool {
p.flagsMtx.Lock()
witnessEnabled := p.witnessEnabled
p.flagsMtx.Unlock()
return witnessEnabled
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"IsWitnessEnabled",
"(",
")",
"bool",
"{",
"p",
".",
"flagsMtx",
".",
"Lock",
"(",
")",
"\n",
"witnessEnabled",
":=",
"p",
".",
"witnessEnabled",
"\n",
"p",
".",
"flagsMtx",
".",
"Unlock",
"(",
")",
"\n\n",
"return... | // IsWitnessEnabled returns true if the peer has signalled that it supports
// segregated witness.
//
// This function is safe for concurrent access. | [
"IsWitnessEnabled",
"returns",
"true",
"if",
"the",
"peer",
"has",
"signalled",
"that",
"it",
"supports",
"segregated",
"witness",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L803-L809 |
163,641 | btcsuite/btcd | peer/peer.go | PushAddrMsg | func (p *Peer) PushAddrMsg(addresses []*wire.NetAddress) ([]*wire.NetAddress, error) {
addressCount := len(addresses)
// Nothing to send.
if addressCount == 0 {
return nil, nil
}
msg := wire.NewMsgAddr()
msg.AddrList = make([]*wire.NetAddress, addressCount)
copy(msg.AddrList, addresses)
// Randomize the addresses sent if there are more than the maximum allowed.
if addressCount > wire.MaxAddrPerMsg {
// Shuffle the address list.
for i := 0; i < wire.MaxAddrPerMsg; i++ {
j := i + rand.Intn(addressCount-i)
msg.AddrList[i], msg.AddrList[j] = msg.AddrList[j], msg.AddrList[i]
}
// Truncate it to the maximum size.
msg.AddrList = msg.AddrList[:wire.MaxAddrPerMsg]
}
p.QueueMessage(msg, nil)
return msg.AddrList, nil
} | go | func (p *Peer) PushAddrMsg(addresses []*wire.NetAddress) ([]*wire.NetAddress, error) {
addressCount := len(addresses)
// Nothing to send.
if addressCount == 0 {
return nil, nil
}
msg := wire.NewMsgAddr()
msg.AddrList = make([]*wire.NetAddress, addressCount)
copy(msg.AddrList, addresses)
// Randomize the addresses sent if there are more than the maximum allowed.
if addressCount > wire.MaxAddrPerMsg {
// Shuffle the address list.
for i := 0; i < wire.MaxAddrPerMsg; i++ {
j := i + rand.Intn(addressCount-i)
msg.AddrList[i], msg.AddrList[j] = msg.AddrList[j], msg.AddrList[i]
}
// Truncate it to the maximum size.
msg.AddrList = msg.AddrList[:wire.MaxAddrPerMsg]
}
p.QueueMessage(msg, nil)
return msg.AddrList, nil
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"PushAddrMsg",
"(",
"addresses",
"[",
"]",
"*",
"wire",
".",
"NetAddress",
")",
"(",
"[",
"]",
"*",
"wire",
".",
"NetAddress",
",",
"error",
")",
"{",
"addressCount",
":=",
"len",
"(",
"addresses",
")",
"\n\n",
"... | // PushAddrMsg sends an addr message to the connected peer using the provided
// addresses. This function is useful over manually sending the message via
// QueueMessage since it automatically limits the addresses to the maximum
// number allowed by the message and randomizes the chosen addresses when there
// are too many. It returns the addresses that were actually sent and no
// message will be sent if there are no entries in the provided addresses slice.
//
// This function is safe for concurrent access. | [
"PushAddrMsg",
"sends",
"an",
"addr",
"message",
"to",
"the",
"connected",
"peer",
"using",
"the",
"provided",
"addresses",
".",
"This",
"function",
"is",
"useful",
"over",
"manually",
"sending",
"the",
"message",
"via",
"QueueMessage",
"since",
"it",
"automatic... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L819-L845 |
163,642 | btcsuite/btcd | peer/peer.go | PushGetBlocksMsg | func (p *Peer) PushGetBlocksMsg(locator blockchain.BlockLocator, stopHash *chainhash.Hash) error {
// Extract the begin hash from the block locator, if one was specified,
// to use for filtering duplicate getblocks requests.
var beginHash *chainhash.Hash
if len(locator) > 0 {
beginHash = locator[0]
}
// Filter duplicate getblocks requests.
p.prevGetBlocksMtx.Lock()
isDuplicate := p.prevGetBlocksStop != nil && p.prevGetBlocksBegin != nil &&
beginHash != nil && stopHash.IsEqual(p.prevGetBlocksStop) &&
beginHash.IsEqual(p.prevGetBlocksBegin)
p.prevGetBlocksMtx.Unlock()
if isDuplicate {
log.Tracef("Filtering duplicate [getblocks] with begin "+
"hash %v, stop hash %v", beginHash, stopHash)
return nil
}
// Construct the getblocks request and queue it to be sent.
msg := wire.NewMsgGetBlocks(stopHash)
for _, hash := range locator {
err := msg.AddBlockLocatorHash(hash)
if err != nil {
return err
}
}
p.QueueMessage(msg, nil)
// Update the previous getblocks request information for filtering
// duplicates.
p.prevGetBlocksMtx.Lock()
p.prevGetBlocksBegin = beginHash
p.prevGetBlocksStop = stopHash
p.prevGetBlocksMtx.Unlock()
return nil
} | go | func (p *Peer) PushGetBlocksMsg(locator blockchain.BlockLocator, stopHash *chainhash.Hash) error {
// Extract the begin hash from the block locator, if one was specified,
// to use for filtering duplicate getblocks requests.
var beginHash *chainhash.Hash
if len(locator) > 0 {
beginHash = locator[0]
}
// Filter duplicate getblocks requests.
p.prevGetBlocksMtx.Lock()
isDuplicate := p.prevGetBlocksStop != nil && p.prevGetBlocksBegin != nil &&
beginHash != nil && stopHash.IsEqual(p.prevGetBlocksStop) &&
beginHash.IsEqual(p.prevGetBlocksBegin)
p.prevGetBlocksMtx.Unlock()
if isDuplicate {
log.Tracef("Filtering duplicate [getblocks] with begin "+
"hash %v, stop hash %v", beginHash, stopHash)
return nil
}
// Construct the getblocks request and queue it to be sent.
msg := wire.NewMsgGetBlocks(stopHash)
for _, hash := range locator {
err := msg.AddBlockLocatorHash(hash)
if err != nil {
return err
}
}
p.QueueMessage(msg, nil)
// Update the previous getblocks request information for filtering
// duplicates.
p.prevGetBlocksMtx.Lock()
p.prevGetBlocksBegin = beginHash
p.prevGetBlocksStop = stopHash
p.prevGetBlocksMtx.Unlock()
return nil
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"PushGetBlocksMsg",
"(",
"locator",
"blockchain",
".",
"BlockLocator",
",",
"stopHash",
"*",
"chainhash",
".",
"Hash",
")",
"error",
"{",
"// Extract the begin hash from the block locator, if one was specified,",
"// to use for filterin... | // PushGetBlocksMsg sends a getblocks message for the provided block locator
// and stop hash. It will ignore back-to-back duplicate requests.
//
// This function is safe for concurrent access. | [
"PushGetBlocksMsg",
"sends",
"a",
"getblocks",
"message",
"for",
"the",
"provided",
"block",
"locator",
"and",
"stop",
"hash",
".",
"It",
"will",
"ignore",
"back",
"-",
"to",
"-",
"back",
"duplicate",
"requests",
".",
"This",
"function",
"is",
"safe",
"for",... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L851-L889 |
163,643 | btcsuite/btcd | peer/peer.go | PushGetHeadersMsg | func (p *Peer) PushGetHeadersMsg(locator blockchain.BlockLocator, stopHash *chainhash.Hash) error {
// Extract the begin hash from the block locator, if one was specified,
// to use for filtering duplicate getheaders requests.
var beginHash *chainhash.Hash
if len(locator) > 0 {
beginHash = locator[0]
}
// Filter duplicate getheaders requests.
p.prevGetHdrsMtx.Lock()
isDuplicate := p.prevGetHdrsStop != nil && p.prevGetHdrsBegin != nil &&
beginHash != nil && stopHash.IsEqual(p.prevGetHdrsStop) &&
beginHash.IsEqual(p.prevGetHdrsBegin)
p.prevGetHdrsMtx.Unlock()
if isDuplicate {
log.Tracef("Filtering duplicate [getheaders] with begin hash %v",
beginHash)
return nil
}
// Construct the getheaders request and queue it to be sent.
msg := wire.NewMsgGetHeaders()
msg.HashStop = *stopHash
for _, hash := range locator {
err := msg.AddBlockLocatorHash(hash)
if err != nil {
return err
}
}
p.QueueMessage(msg, nil)
// Update the previous getheaders request information for filtering
// duplicates.
p.prevGetHdrsMtx.Lock()
p.prevGetHdrsBegin = beginHash
p.prevGetHdrsStop = stopHash
p.prevGetHdrsMtx.Unlock()
return nil
} | go | func (p *Peer) PushGetHeadersMsg(locator blockchain.BlockLocator, stopHash *chainhash.Hash) error {
// Extract the begin hash from the block locator, if one was specified,
// to use for filtering duplicate getheaders requests.
var beginHash *chainhash.Hash
if len(locator) > 0 {
beginHash = locator[0]
}
// Filter duplicate getheaders requests.
p.prevGetHdrsMtx.Lock()
isDuplicate := p.prevGetHdrsStop != nil && p.prevGetHdrsBegin != nil &&
beginHash != nil && stopHash.IsEqual(p.prevGetHdrsStop) &&
beginHash.IsEqual(p.prevGetHdrsBegin)
p.prevGetHdrsMtx.Unlock()
if isDuplicate {
log.Tracef("Filtering duplicate [getheaders] with begin hash %v",
beginHash)
return nil
}
// Construct the getheaders request and queue it to be sent.
msg := wire.NewMsgGetHeaders()
msg.HashStop = *stopHash
for _, hash := range locator {
err := msg.AddBlockLocatorHash(hash)
if err != nil {
return err
}
}
p.QueueMessage(msg, nil)
// Update the previous getheaders request information for filtering
// duplicates.
p.prevGetHdrsMtx.Lock()
p.prevGetHdrsBegin = beginHash
p.prevGetHdrsStop = stopHash
p.prevGetHdrsMtx.Unlock()
return nil
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"PushGetHeadersMsg",
"(",
"locator",
"blockchain",
".",
"BlockLocator",
",",
"stopHash",
"*",
"chainhash",
".",
"Hash",
")",
"error",
"{",
"// Extract the begin hash from the block locator, if one was specified,",
"// to use for filteri... | // PushGetHeadersMsg sends a getblocks message for the provided block locator
// and stop hash. It will ignore back-to-back duplicate requests.
//
// This function is safe for concurrent access. | [
"PushGetHeadersMsg",
"sends",
"a",
"getblocks",
"message",
"for",
"the",
"provided",
"block",
"locator",
"and",
"stop",
"hash",
".",
"It",
"will",
"ignore",
"back",
"-",
"to",
"-",
"back",
"duplicate",
"requests",
".",
"This",
"function",
"is",
"safe",
"for"... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L895-L934 |
163,644 | btcsuite/btcd | peer/peer.go | PushRejectMsg | func (p *Peer) PushRejectMsg(command string, code wire.RejectCode, reason string, hash *chainhash.Hash, wait bool) {
// Don't bother sending the reject message if the protocol version
// is too low.
if p.VersionKnown() && p.ProtocolVersion() < wire.RejectVersion {
return
}
msg := wire.NewMsgReject(command, code, reason)
if command == wire.CmdTx || command == wire.CmdBlock {
if hash == nil {
log.Warnf("Sending a reject message for command "+
"type %v which should have specified a hash "+
"but does not", command)
hash = &zeroHash
}
msg.Hash = *hash
}
// Send the message without waiting if the caller has not requested it.
if !wait {
p.QueueMessage(msg, nil)
return
}
// Send the message and block until it has been sent before returning.
doneChan := make(chan struct{}, 1)
p.QueueMessage(msg, doneChan)
<-doneChan
} | go | func (p *Peer) PushRejectMsg(command string, code wire.RejectCode, reason string, hash *chainhash.Hash, wait bool) {
// Don't bother sending the reject message if the protocol version
// is too low.
if p.VersionKnown() && p.ProtocolVersion() < wire.RejectVersion {
return
}
msg := wire.NewMsgReject(command, code, reason)
if command == wire.CmdTx || command == wire.CmdBlock {
if hash == nil {
log.Warnf("Sending a reject message for command "+
"type %v which should have specified a hash "+
"but does not", command)
hash = &zeroHash
}
msg.Hash = *hash
}
// Send the message without waiting if the caller has not requested it.
if !wait {
p.QueueMessage(msg, nil)
return
}
// Send the message and block until it has been sent before returning.
doneChan := make(chan struct{}, 1)
p.QueueMessage(msg, doneChan)
<-doneChan
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"PushRejectMsg",
"(",
"command",
"string",
",",
"code",
"wire",
".",
"RejectCode",
",",
"reason",
"string",
",",
"hash",
"*",
"chainhash",
".",
"Hash",
",",
"wait",
"bool",
")",
"{",
"// Don't bother sending the reject mes... | // PushRejectMsg sends a reject message for the provided command, reject code,
// reject reason, and hash. The hash will only be used when the command is a tx
// or block and should be nil in other cases. The wait parameter will cause the
// function to block until the reject message has actually been sent.
//
// This function is safe for concurrent access. | [
"PushRejectMsg",
"sends",
"a",
"reject",
"message",
"for",
"the",
"provided",
"command",
"reject",
"code",
"reject",
"reason",
"and",
"hash",
".",
"The",
"hash",
"will",
"only",
"be",
"used",
"when",
"the",
"command",
"is",
"a",
"tx",
"or",
"block",
"and",... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L942-L970 |
163,645 | btcsuite/btcd | peer/peer.go | readMessage | func (p *Peer) readMessage(encoding wire.MessageEncoding) (wire.Message, []byte, error) {
n, msg, buf, err := wire.ReadMessageWithEncodingN(p.conn,
p.ProtocolVersion(), p.cfg.ChainParams.Net, encoding)
atomic.AddUint64(&p.bytesReceived, uint64(n))
if p.cfg.Listeners.OnRead != nil {
p.cfg.Listeners.OnRead(p, n, msg, err)
}
if err != nil {
return nil, nil, err
}
// Use closures to log expensive operations so they are only run when
// the logging level requires it.
log.Debugf("%v", newLogClosure(func() string {
// Debug summary of message.
summary := messageSummary(msg)
if len(summary) > 0 {
summary = " (" + summary + ")"
}
return fmt.Sprintf("Received %v%s from %s",
msg.Command(), summary, p)
}))
log.Tracef("%v", newLogClosure(func() string {
return spew.Sdump(msg)
}))
log.Tracef("%v", newLogClosure(func() string {
return spew.Sdump(buf)
}))
return msg, buf, nil
} | go | func (p *Peer) readMessage(encoding wire.MessageEncoding) (wire.Message, []byte, error) {
n, msg, buf, err := wire.ReadMessageWithEncodingN(p.conn,
p.ProtocolVersion(), p.cfg.ChainParams.Net, encoding)
atomic.AddUint64(&p.bytesReceived, uint64(n))
if p.cfg.Listeners.OnRead != nil {
p.cfg.Listeners.OnRead(p, n, msg, err)
}
if err != nil {
return nil, nil, err
}
// Use closures to log expensive operations so they are only run when
// the logging level requires it.
log.Debugf("%v", newLogClosure(func() string {
// Debug summary of message.
summary := messageSummary(msg)
if len(summary) > 0 {
summary = " (" + summary + ")"
}
return fmt.Sprintf("Received %v%s from %s",
msg.Command(), summary, p)
}))
log.Tracef("%v", newLogClosure(func() string {
return spew.Sdump(msg)
}))
log.Tracef("%v", newLogClosure(func() string {
return spew.Sdump(buf)
}))
return msg, buf, nil
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"readMessage",
"(",
"encoding",
"wire",
".",
"MessageEncoding",
")",
"(",
"wire",
".",
"Message",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"n",
",",
"msg",
",",
"buf",
",",
"err",
":=",
"wire",
".",
"Read... | // readMessage reads the next bitcoin message from the peer with logging. | [
"readMessage",
"reads",
"the",
"next",
"bitcoin",
"message",
"from",
"the",
"peer",
"with",
"logging",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1008-L1038 |
163,646 | btcsuite/btcd | peer/peer.go | writeMessage | func (p *Peer) writeMessage(msg wire.Message, enc wire.MessageEncoding) error {
// Don't do anything if we're disconnecting.
if atomic.LoadInt32(&p.disconnect) != 0 {
return nil
}
// Use closures to log expensive operations so they are only run when
// the logging level requires it.
log.Debugf("%v", newLogClosure(func() string {
// Debug summary of message.
summary := messageSummary(msg)
if len(summary) > 0 {
summary = " (" + summary + ")"
}
return fmt.Sprintf("Sending %v%s to %s", msg.Command(),
summary, p)
}))
log.Tracef("%v", newLogClosure(func() string {
return spew.Sdump(msg)
}))
log.Tracef("%v", newLogClosure(func() string {
var buf bytes.Buffer
_, err := wire.WriteMessageWithEncodingN(&buf, msg, p.ProtocolVersion(),
p.cfg.ChainParams.Net, enc)
if err != nil {
return err.Error()
}
return spew.Sdump(buf.Bytes())
}))
// Write the message to the peer.
n, err := wire.WriteMessageWithEncodingN(p.conn, msg,
p.ProtocolVersion(), p.cfg.ChainParams.Net, enc)
atomic.AddUint64(&p.bytesSent, uint64(n))
if p.cfg.Listeners.OnWrite != nil {
p.cfg.Listeners.OnWrite(p, n, msg, err)
}
return err
} | go | func (p *Peer) writeMessage(msg wire.Message, enc wire.MessageEncoding) error {
// Don't do anything if we're disconnecting.
if atomic.LoadInt32(&p.disconnect) != 0 {
return nil
}
// Use closures to log expensive operations so they are only run when
// the logging level requires it.
log.Debugf("%v", newLogClosure(func() string {
// Debug summary of message.
summary := messageSummary(msg)
if len(summary) > 0 {
summary = " (" + summary + ")"
}
return fmt.Sprintf("Sending %v%s to %s", msg.Command(),
summary, p)
}))
log.Tracef("%v", newLogClosure(func() string {
return spew.Sdump(msg)
}))
log.Tracef("%v", newLogClosure(func() string {
var buf bytes.Buffer
_, err := wire.WriteMessageWithEncodingN(&buf, msg, p.ProtocolVersion(),
p.cfg.ChainParams.Net, enc)
if err != nil {
return err.Error()
}
return spew.Sdump(buf.Bytes())
}))
// Write the message to the peer.
n, err := wire.WriteMessageWithEncodingN(p.conn, msg,
p.ProtocolVersion(), p.cfg.ChainParams.Net, enc)
atomic.AddUint64(&p.bytesSent, uint64(n))
if p.cfg.Listeners.OnWrite != nil {
p.cfg.Listeners.OnWrite(p, n, msg, err)
}
return err
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"writeMessage",
"(",
"msg",
"wire",
".",
"Message",
",",
"enc",
"wire",
".",
"MessageEncoding",
")",
"error",
"{",
"// Don't do anything if we're disconnecting.",
"if",
"atomic",
".",
"LoadInt32",
"(",
"&",
"p",
".",
"disc... | // writeMessage sends a bitcoin message to the peer with logging. | [
"writeMessage",
"sends",
"a",
"bitcoin",
"message",
"to",
"the",
"peer",
"with",
"logging",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1041-L1079 |
163,647 | btcsuite/btcd | peer/peer.go | isAllowedReadError | func (p *Peer) isAllowedReadError(err error) bool {
// Only allow read errors in regression test mode.
if p.cfg.ChainParams.Net != wire.TestNet {
return false
}
// Don't allow the error if it's not specifically a malformed message error.
if _, ok := err.(*wire.MessageError); !ok {
return false
}
// Don't allow the error if it's not coming from localhost or the
// hostname can't be determined for some reason.
host, _, err := net.SplitHostPort(p.addr)
if err != nil {
return false
}
if host != "127.0.0.1" && host != "localhost" {
return false
}
// Allowed if all checks passed.
return true
} | go | func (p *Peer) isAllowedReadError(err error) bool {
// Only allow read errors in regression test mode.
if p.cfg.ChainParams.Net != wire.TestNet {
return false
}
// Don't allow the error if it's not specifically a malformed message error.
if _, ok := err.(*wire.MessageError); !ok {
return false
}
// Don't allow the error if it's not coming from localhost or the
// hostname can't be determined for some reason.
host, _, err := net.SplitHostPort(p.addr)
if err != nil {
return false
}
if host != "127.0.0.1" && host != "localhost" {
return false
}
// Allowed if all checks passed.
return true
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"isAllowedReadError",
"(",
"err",
"error",
")",
"bool",
"{",
"// Only allow read errors in regression test mode.",
"if",
"p",
".",
"cfg",
".",
"ChainParams",
".",
"Net",
"!=",
"wire",
".",
"TestNet",
"{",
"return",
"false",
... | // isAllowedReadError returns whether or not the passed error is allowed without
// disconnecting the peer. In particular, regression tests need to be allowed
// to send malformed messages without the peer being disconnected. | [
"isAllowedReadError",
"returns",
"whether",
"or",
"not",
"the",
"passed",
"error",
"is",
"allowed",
"without",
"disconnecting",
"the",
"peer",
".",
"In",
"particular",
"regression",
"tests",
"need",
"to",
"be",
"allowed",
"to",
"send",
"malformed",
"messages",
"... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1084-L1108 |
163,648 | btcsuite/btcd | peer/peer.go | maybeAddDeadline | func (p *Peer) maybeAddDeadline(pendingResponses map[string]time.Time, msgCmd string) {
// Setup a deadline for each message being sent that expects a response.
//
// NOTE: Pings are intentionally ignored here since they are typically
// sent asynchronously and as a result of a long backlock of messages,
// such as is typical in the case of initial block download, the
// response won't be received in time.
deadline := time.Now().Add(stallResponseTimeout)
switch msgCmd {
case wire.CmdVersion:
// Expects a verack message.
pendingResponses[wire.CmdVerAck] = deadline
case wire.CmdMemPool:
// Expects an inv message.
pendingResponses[wire.CmdInv] = deadline
case wire.CmdGetBlocks:
// Expects an inv message.
pendingResponses[wire.CmdInv] = deadline
case wire.CmdGetData:
// Expects a block, merkleblock, tx, or notfound message.
pendingResponses[wire.CmdBlock] = deadline
pendingResponses[wire.CmdMerkleBlock] = deadline
pendingResponses[wire.CmdTx] = deadline
pendingResponses[wire.CmdNotFound] = deadline
case wire.CmdGetHeaders:
// Expects a headers message. Use a longer deadline since it
// can take a while for the remote peer to load all of the
// headers.
deadline = time.Now().Add(stallResponseTimeout * 3)
pendingResponses[wire.CmdHeaders] = deadline
}
} | go | func (p *Peer) maybeAddDeadline(pendingResponses map[string]time.Time, msgCmd string) {
// Setup a deadline for each message being sent that expects a response.
//
// NOTE: Pings are intentionally ignored here since they are typically
// sent asynchronously and as a result of a long backlock of messages,
// such as is typical in the case of initial block download, the
// response won't be received in time.
deadline := time.Now().Add(stallResponseTimeout)
switch msgCmd {
case wire.CmdVersion:
// Expects a verack message.
pendingResponses[wire.CmdVerAck] = deadline
case wire.CmdMemPool:
// Expects an inv message.
pendingResponses[wire.CmdInv] = deadline
case wire.CmdGetBlocks:
// Expects an inv message.
pendingResponses[wire.CmdInv] = deadline
case wire.CmdGetData:
// Expects a block, merkleblock, tx, or notfound message.
pendingResponses[wire.CmdBlock] = deadline
pendingResponses[wire.CmdMerkleBlock] = deadline
pendingResponses[wire.CmdTx] = deadline
pendingResponses[wire.CmdNotFound] = deadline
case wire.CmdGetHeaders:
// Expects a headers message. Use a longer deadline since it
// can take a while for the remote peer to load all of the
// headers.
deadline = time.Now().Add(stallResponseTimeout * 3)
pendingResponses[wire.CmdHeaders] = deadline
}
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"maybeAddDeadline",
"(",
"pendingResponses",
"map",
"[",
"string",
"]",
"time",
".",
"Time",
",",
"msgCmd",
"string",
")",
"{",
"// Setup a deadline for each message being sent that expects a response.",
"//",
"// NOTE: Pings are inte... | // maybeAddDeadline potentially adds a deadline for the appropriate expected
// response for the passed wire protocol command to the pending responses map. | [
"maybeAddDeadline",
"potentially",
"adds",
"a",
"deadline",
"for",
"the",
"appropriate",
"expected",
"response",
"for",
"the",
"passed",
"wire",
"protocol",
"command",
"to",
"the",
"pending",
"responses",
"map",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1134-L1169 |
163,649 | btcsuite/btcd | peer/peer.go | stallHandler | func (p *Peer) stallHandler() {
// These variables are used to adjust the deadline times forward by the
// time it takes callbacks to execute. This is done because new
// messages aren't read until the previous one is finished processing
// (which includes callbacks), so the deadline for receiving a response
// for a given message must account for the processing time as well.
var handlerActive bool
var handlersStartTime time.Time
var deadlineOffset time.Duration
// pendingResponses tracks the expected response deadline times.
pendingResponses := make(map[string]time.Time)
// stallTicker is used to periodically check pending responses that have
// exceeded the expected deadline and disconnect the peer due to
// stalling.
stallTicker := time.NewTicker(stallTickInterval)
defer stallTicker.Stop()
// ioStopped is used to detect when both the input and output handler
// goroutines are done.
var ioStopped bool
out:
for {
select {
case msg := <-p.stallControl:
switch msg.command {
case sccSendMessage:
// Add a deadline for the expected response
// message if needed.
p.maybeAddDeadline(pendingResponses,
msg.message.Command())
case sccReceiveMessage:
// Remove received messages from the expected
// response map. Since certain commands expect
// one of a group of responses, remove
// everything in the expected group accordingly.
switch msgCmd := msg.message.Command(); msgCmd {
case wire.CmdBlock:
fallthrough
case wire.CmdMerkleBlock:
fallthrough
case wire.CmdTx:
fallthrough
case wire.CmdNotFound:
delete(pendingResponses, wire.CmdBlock)
delete(pendingResponses, wire.CmdMerkleBlock)
delete(pendingResponses, wire.CmdTx)
delete(pendingResponses, wire.CmdNotFound)
default:
delete(pendingResponses, msgCmd)
}
case sccHandlerStart:
// Warn on unbalanced callback signalling.
if handlerActive {
log.Warn("Received handler start " +
"control command while a " +
"handler is already active")
continue
}
handlerActive = true
handlersStartTime = time.Now()
case sccHandlerDone:
// Warn on unbalanced callback signalling.
if !handlerActive {
log.Warn("Received handler done " +
"control command when a " +
"handler is not already active")
continue
}
// Extend active deadlines by the time it took
// to execute the callback.
duration := time.Since(handlersStartTime)
deadlineOffset += duration
handlerActive = false
default:
log.Warnf("Unsupported message command %v",
msg.command)
}
case <-stallTicker.C:
// Calculate the offset to apply to the deadline based
// on how long the handlers have taken to execute since
// the last tick.
now := time.Now()
offset := deadlineOffset
if handlerActive {
offset += now.Sub(handlersStartTime)
}
// Disconnect the peer if any of the pending responses
// don't arrive by their adjusted deadline.
for command, deadline := range pendingResponses {
if now.Before(deadline.Add(offset)) {
continue
}
log.Debugf("Peer %s appears to be stalled or "+
"misbehaving, %s timeout -- "+
"disconnecting", p, command)
p.Disconnect()
break
}
// Reset the deadline offset for the next tick.
deadlineOffset = 0
case <-p.inQuit:
// The stall handler can exit once both the input and
// output handler goroutines are done.
if ioStopped {
break out
}
ioStopped = true
case <-p.outQuit:
// The stall handler can exit once both the input and
// output handler goroutines are done.
if ioStopped {
break out
}
ioStopped = true
}
}
// Drain any wait channels before going away so there is nothing left
// waiting on this goroutine.
cleanup:
for {
select {
case <-p.stallControl:
default:
break cleanup
}
}
log.Tracef("Peer stall handler done for %s", p)
} | go | func (p *Peer) stallHandler() {
// These variables are used to adjust the deadline times forward by the
// time it takes callbacks to execute. This is done because new
// messages aren't read until the previous one is finished processing
// (which includes callbacks), so the deadline for receiving a response
// for a given message must account for the processing time as well.
var handlerActive bool
var handlersStartTime time.Time
var deadlineOffset time.Duration
// pendingResponses tracks the expected response deadline times.
pendingResponses := make(map[string]time.Time)
// stallTicker is used to periodically check pending responses that have
// exceeded the expected deadline and disconnect the peer due to
// stalling.
stallTicker := time.NewTicker(stallTickInterval)
defer stallTicker.Stop()
// ioStopped is used to detect when both the input and output handler
// goroutines are done.
var ioStopped bool
out:
for {
select {
case msg := <-p.stallControl:
switch msg.command {
case sccSendMessage:
// Add a deadline for the expected response
// message if needed.
p.maybeAddDeadline(pendingResponses,
msg.message.Command())
case sccReceiveMessage:
// Remove received messages from the expected
// response map. Since certain commands expect
// one of a group of responses, remove
// everything in the expected group accordingly.
switch msgCmd := msg.message.Command(); msgCmd {
case wire.CmdBlock:
fallthrough
case wire.CmdMerkleBlock:
fallthrough
case wire.CmdTx:
fallthrough
case wire.CmdNotFound:
delete(pendingResponses, wire.CmdBlock)
delete(pendingResponses, wire.CmdMerkleBlock)
delete(pendingResponses, wire.CmdTx)
delete(pendingResponses, wire.CmdNotFound)
default:
delete(pendingResponses, msgCmd)
}
case sccHandlerStart:
// Warn on unbalanced callback signalling.
if handlerActive {
log.Warn("Received handler start " +
"control command while a " +
"handler is already active")
continue
}
handlerActive = true
handlersStartTime = time.Now()
case sccHandlerDone:
// Warn on unbalanced callback signalling.
if !handlerActive {
log.Warn("Received handler done " +
"control command when a " +
"handler is not already active")
continue
}
// Extend active deadlines by the time it took
// to execute the callback.
duration := time.Since(handlersStartTime)
deadlineOffset += duration
handlerActive = false
default:
log.Warnf("Unsupported message command %v",
msg.command)
}
case <-stallTicker.C:
// Calculate the offset to apply to the deadline based
// on how long the handlers have taken to execute since
// the last tick.
now := time.Now()
offset := deadlineOffset
if handlerActive {
offset += now.Sub(handlersStartTime)
}
// Disconnect the peer if any of the pending responses
// don't arrive by their adjusted deadline.
for command, deadline := range pendingResponses {
if now.Before(deadline.Add(offset)) {
continue
}
log.Debugf("Peer %s appears to be stalled or "+
"misbehaving, %s timeout -- "+
"disconnecting", p, command)
p.Disconnect()
break
}
// Reset the deadline offset for the next tick.
deadlineOffset = 0
case <-p.inQuit:
// The stall handler can exit once both the input and
// output handler goroutines are done.
if ioStopped {
break out
}
ioStopped = true
case <-p.outQuit:
// The stall handler can exit once both the input and
// output handler goroutines are done.
if ioStopped {
break out
}
ioStopped = true
}
}
// Drain any wait channels before going away so there is nothing left
// waiting on this goroutine.
cleanup:
for {
select {
case <-p.stallControl:
default:
break cleanup
}
}
log.Tracef("Peer stall handler done for %s", p)
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"stallHandler",
"(",
")",
"{",
"// These variables are used to adjust the deadline times forward by the",
"// time it takes callbacks to execute. This is done because new",
"// messages aren't read until the previous one is finished processing",
"// (wh... | // stallHandler handles stall detection for the peer. This entails keeping
// track of expected responses and assigning them deadlines while accounting for
// the time spent in callbacks. It must be run as a goroutine. | [
"stallHandler",
"handles",
"stall",
"detection",
"for",
"the",
"peer",
".",
"This",
"entails",
"keeping",
"track",
"of",
"expected",
"responses",
"and",
"assigning",
"them",
"deadlines",
"while",
"accounting",
"for",
"the",
"time",
"spent",
"in",
"callbacks",
".... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1174-L1317 |
163,650 | btcsuite/btcd | peer/peer.go | shouldLogWriteError | func (p *Peer) shouldLogWriteError(err error) bool {
// No logging when the peer is being forcibly disconnected.
if atomic.LoadInt32(&p.disconnect) != 0 {
return false
}
// No logging when the remote peer has been disconnected.
if err == io.EOF {
return false
}
if opErr, ok := err.(*net.OpError); ok && !opErr.Temporary() {
return false
}
return true
} | go | func (p *Peer) shouldLogWriteError(err error) bool {
// No logging when the peer is being forcibly disconnected.
if atomic.LoadInt32(&p.disconnect) != 0 {
return false
}
// No logging when the remote peer has been disconnected.
if err == io.EOF {
return false
}
if opErr, ok := err.(*net.OpError); ok && !opErr.Temporary() {
return false
}
return true
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"shouldLogWriteError",
"(",
"err",
"error",
")",
"bool",
"{",
"// No logging when the peer is being forcibly disconnected.",
"if",
"atomic",
".",
"LoadInt32",
"(",
"&",
"p",
".",
"disconnect",
")",
"!=",
"0",
"{",
"return",
... | // shouldLogWriteError returns whether or not the passed error, which is
// expected to have come from writing to the remote peer in the outHandler,
// should be logged. | [
"shouldLogWriteError",
"returns",
"whether",
"or",
"not",
"the",
"passed",
"error",
"which",
"is",
"expected",
"to",
"have",
"come",
"from",
"writing",
"to",
"the",
"remote",
"peer",
"in",
"the",
"outHandler",
"should",
"be",
"logged",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1693-L1708 |
163,651 | btcsuite/btcd | peer/peer.go | outHandler | func (p *Peer) outHandler() {
out:
for {
select {
case msg := <-p.sendQueue:
switch m := msg.msg.(type) {
case *wire.MsgPing:
// Only expects a pong message in later protocol
// versions. Also set up statistics.
if p.ProtocolVersion() > wire.BIP0031Version {
p.statsMtx.Lock()
p.lastPingNonce = m.Nonce
p.lastPingTime = time.Now()
p.statsMtx.Unlock()
}
}
p.stallControl <- stallControlMsg{sccSendMessage, msg.msg}
err := p.writeMessage(msg.msg, msg.encoding)
if err != nil {
p.Disconnect()
if p.shouldLogWriteError(err) {
log.Errorf("Failed to send message to "+
"%s: %v", p, err)
}
if msg.doneChan != nil {
msg.doneChan <- struct{}{}
}
continue
}
// At this point, the message was successfully sent, so
// update the last send time, signal the sender of the
// message that it has been sent (if requested), and
// signal the send queue to the deliver the next queued
// message.
atomic.StoreInt64(&p.lastSend, time.Now().Unix())
if msg.doneChan != nil {
msg.doneChan <- struct{}{}
}
p.sendDoneQueue <- struct{}{}
case <-p.quit:
break out
}
}
<-p.queueQuit
// Drain any wait channels before we go away so we don't leave something
// waiting for us. We have waited on queueQuit and thus we can be sure
// that we will not miss anything sent on sendQueue.
cleanup:
for {
select {
case msg := <-p.sendQueue:
if msg.doneChan != nil {
msg.doneChan <- struct{}{}
}
// no need to send on sendDoneQueue since queueHandler
// has been waited on and already exited.
default:
break cleanup
}
}
close(p.outQuit)
log.Tracef("Peer output handler done for %s", p)
} | go | func (p *Peer) outHandler() {
out:
for {
select {
case msg := <-p.sendQueue:
switch m := msg.msg.(type) {
case *wire.MsgPing:
// Only expects a pong message in later protocol
// versions. Also set up statistics.
if p.ProtocolVersion() > wire.BIP0031Version {
p.statsMtx.Lock()
p.lastPingNonce = m.Nonce
p.lastPingTime = time.Now()
p.statsMtx.Unlock()
}
}
p.stallControl <- stallControlMsg{sccSendMessage, msg.msg}
err := p.writeMessage(msg.msg, msg.encoding)
if err != nil {
p.Disconnect()
if p.shouldLogWriteError(err) {
log.Errorf("Failed to send message to "+
"%s: %v", p, err)
}
if msg.doneChan != nil {
msg.doneChan <- struct{}{}
}
continue
}
// At this point, the message was successfully sent, so
// update the last send time, signal the sender of the
// message that it has been sent (if requested), and
// signal the send queue to the deliver the next queued
// message.
atomic.StoreInt64(&p.lastSend, time.Now().Unix())
if msg.doneChan != nil {
msg.doneChan <- struct{}{}
}
p.sendDoneQueue <- struct{}{}
case <-p.quit:
break out
}
}
<-p.queueQuit
// Drain any wait channels before we go away so we don't leave something
// waiting for us. We have waited on queueQuit and thus we can be sure
// that we will not miss anything sent on sendQueue.
cleanup:
for {
select {
case msg := <-p.sendQueue:
if msg.doneChan != nil {
msg.doneChan <- struct{}{}
}
// no need to send on sendDoneQueue since queueHandler
// has been waited on and already exited.
default:
break cleanup
}
}
close(p.outQuit)
log.Tracef("Peer output handler done for %s", p)
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"outHandler",
"(",
")",
"{",
"out",
":",
"for",
"{",
"select",
"{",
"case",
"msg",
":=",
"<-",
"p",
".",
"sendQueue",
":",
"switch",
"m",
":=",
"msg",
".",
"msg",
".",
"(",
"type",
")",
"{",
"case",
"*",
"w... | // outHandler handles all outgoing messages for the peer. It must be run as a
// goroutine. It uses a buffered channel to serialize output messages while
// allowing the sender to continue running asynchronously. | [
"outHandler",
"handles",
"all",
"outgoing",
"messages",
"for",
"the",
"peer",
".",
"It",
"must",
"be",
"run",
"as",
"a",
"goroutine",
".",
"It",
"uses",
"a",
"buffered",
"channel",
"to",
"serialize",
"output",
"messages",
"while",
"allowing",
"the",
"sender"... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1713-L1781 |
163,652 | btcsuite/btcd | peer/peer.go | pingHandler | func (p *Peer) pingHandler() {
pingTicker := time.NewTicker(pingInterval)
defer pingTicker.Stop()
out:
for {
select {
case <-pingTicker.C:
nonce, err := wire.RandomUint64()
if err != nil {
log.Errorf("Not sending ping to %s: %v", p, err)
continue
}
p.QueueMessage(wire.NewMsgPing(nonce), nil)
case <-p.quit:
break out
}
}
} | go | func (p *Peer) pingHandler() {
pingTicker := time.NewTicker(pingInterval)
defer pingTicker.Stop()
out:
for {
select {
case <-pingTicker.C:
nonce, err := wire.RandomUint64()
if err != nil {
log.Errorf("Not sending ping to %s: %v", p, err)
continue
}
p.QueueMessage(wire.NewMsgPing(nonce), nil)
case <-p.quit:
break out
}
}
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"pingHandler",
"(",
")",
"{",
"pingTicker",
":=",
"time",
".",
"NewTicker",
"(",
"pingInterval",
")",
"\n",
"defer",
"pingTicker",
".",
"Stop",
"(",
")",
"\n\n",
"out",
":",
"for",
"{",
"select",
"{",
"case",
"<-",... | // pingHandler periodically pings the peer. It must be run as a goroutine. | [
"pingHandler",
"periodically",
"pings",
"the",
"peer",
".",
"It",
"must",
"be",
"run",
"as",
"a",
"goroutine",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1784-L1803 |
163,653 | btcsuite/btcd | peer/peer.go | QueueMessage | func (p *Peer) QueueMessage(msg wire.Message, doneChan chan<- struct{}) {
p.QueueMessageWithEncoding(msg, doneChan, wire.BaseEncoding)
} | go | func (p *Peer) QueueMessage(msg wire.Message, doneChan chan<- struct{}) {
p.QueueMessageWithEncoding(msg, doneChan, wire.BaseEncoding)
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"QueueMessage",
"(",
"msg",
"wire",
".",
"Message",
",",
"doneChan",
"chan",
"<-",
"struct",
"{",
"}",
")",
"{",
"p",
".",
"QueueMessageWithEncoding",
"(",
"msg",
",",
"doneChan",
",",
"wire",
".",
"BaseEncoding",
")... | // QueueMessage adds the passed bitcoin message to the peer send queue.
//
// This function is safe for concurrent access. | [
"QueueMessage",
"adds",
"the",
"passed",
"bitcoin",
"message",
"to",
"the",
"peer",
"send",
"queue",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1808-L1810 |
163,654 | btcsuite/btcd | peer/peer.go | QueueInventory | func (p *Peer) QueueInventory(invVect *wire.InvVect) {
// Don't add the inventory to the send queue if the peer is already
// known to have it.
if p.knownInventory.Exists(invVect) {
return
}
// Avoid risk of deadlock if goroutine already exited. The goroutine
// we will be sending to hangs around until it knows for a fact that
// it is marked as disconnected and *then* it drains the channels.
if !p.Connected() {
return
}
p.outputInvChan <- invVect
} | go | func (p *Peer) QueueInventory(invVect *wire.InvVect) {
// Don't add the inventory to the send queue if the peer is already
// known to have it.
if p.knownInventory.Exists(invVect) {
return
}
// Avoid risk of deadlock if goroutine already exited. The goroutine
// we will be sending to hangs around until it knows for a fact that
// it is marked as disconnected and *then* it drains the channels.
if !p.Connected() {
return
}
p.outputInvChan <- invVect
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"QueueInventory",
"(",
"invVect",
"*",
"wire",
".",
"InvVect",
")",
"{",
"// Don't add the inventory to the send queue if the peer is already",
"// known to have it.",
"if",
"p",
".",
"knownInventory",
".",
"Exists",
"(",
"invVect",... | // QueueInventory adds the passed inventory to the inventory send queue which
// might not be sent right away, rather it is trickled to the peer in batches.
// Inventory that the peer is already known to have is ignored.
//
// This function is safe for concurrent access. | [
"QueueInventory",
"adds",
"the",
"passed",
"inventory",
"to",
"the",
"inventory",
"send",
"queue",
"which",
"might",
"not",
"be",
"sent",
"right",
"away",
"rather",
"it",
"is",
"trickled",
"to",
"the",
"peer",
"in",
"batches",
".",
"Inventory",
"that",
"the"... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1840-L1855 |
163,655 | btcsuite/btcd | peer/peer.go | Connected | func (p *Peer) Connected() bool {
return atomic.LoadInt32(&p.connected) != 0 &&
atomic.LoadInt32(&p.disconnect) == 0
} | go | func (p *Peer) Connected() bool {
return atomic.LoadInt32(&p.connected) != 0 &&
atomic.LoadInt32(&p.disconnect) == 0
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"Connected",
"(",
")",
"bool",
"{",
"return",
"atomic",
".",
"LoadInt32",
"(",
"&",
"p",
".",
"connected",
")",
"!=",
"0",
"&&",
"atomic",
".",
"LoadInt32",
"(",
"&",
"p",
".",
"disconnect",
")",
"==",
"0",
"\n... | // Connected returns whether or not the peer is currently connected.
//
// This function is safe for concurrent access. | [
"Connected",
"returns",
"whether",
"or",
"not",
"the",
"peer",
"is",
"currently",
"connected",
".",
"This",
"function",
"is",
"safe",
"for",
"concurrent",
"access",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1860-L1863 |
163,656 | btcsuite/btcd | peer/peer.go | Disconnect | func (p *Peer) Disconnect() {
if atomic.AddInt32(&p.disconnect, 1) != 1 {
return
}
log.Tracef("Disconnecting %s", p)
if atomic.LoadInt32(&p.connected) != 0 {
p.conn.Close()
}
close(p.quit)
} | go | func (p *Peer) Disconnect() {
if atomic.AddInt32(&p.disconnect, 1) != 1 {
return
}
log.Tracef("Disconnecting %s", p)
if atomic.LoadInt32(&p.connected) != 0 {
p.conn.Close()
}
close(p.quit)
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"Disconnect",
"(",
")",
"{",
"if",
"atomic",
".",
"AddInt32",
"(",
"&",
"p",
".",
"disconnect",
",",
"1",
")",
"!=",
"1",
"{",
"return",
"\n",
"}",
"\n\n",
"log",
".",
"Tracef",
"(",
"\"",
"\"",
",",
"p",
"... | // Disconnect disconnects the peer by closing the connection. Calling this
// function when the peer is already disconnected or in the process of
// disconnecting will have no effect. | [
"Disconnect",
"disconnects",
"the",
"peer",
"by",
"closing",
"the",
"connection",
".",
"Calling",
"this",
"function",
"when",
"the",
"peer",
"is",
"already",
"disconnected",
"or",
"in",
"the",
"process",
"of",
"disconnecting",
"will",
"have",
"no",
"effect",
"... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1868-L1878 |
163,657 | btcsuite/btcd | peer/peer.go | readRemoteVersionMsg | func (p *Peer) readRemoteVersionMsg() error {
// Read their version message.
remoteMsg, _, err := p.readMessage(wire.LatestEncoding)
if err != nil {
return err
}
// Notify and disconnect clients if the first message is not a version
// message.
msg, ok := remoteMsg.(*wire.MsgVersion)
if !ok {
reason := "a version message must precede all others"
rejectMsg := wire.NewMsgReject(msg.Command(), wire.RejectMalformed,
reason)
_ = p.writeMessage(rejectMsg, wire.LatestEncoding)
return errors.New(reason)
}
// Detect self connections.
if !allowSelfConns && sentNonces.Exists(msg.Nonce) {
return errors.New("disconnecting peer connected to self")
}
// Negotiate the protocol version and set the services to what the remote
// peer advertised.
p.flagsMtx.Lock()
p.advertisedProtoVer = uint32(msg.ProtocolVersion)
p.protocolVersion = minUint32(p.protocolVersion, p.advertisedProtoVer)
p.versionKnown = true
p.services = msg.Services
p.flagsMtx.Unlock()
log.Debugf("Negotiated protocol version %d for peer %s",
p.protocolVersion, p)
// Updating a bunch of stats including block based stats, and the
// peer's time offset.
p.statsMtx.Lock()
p.lastBlock = msg.LastBlock
p.startingHeight = msg.LastBlock
p.timeOffset = msg.Timestamp.Unix() - time.Now().Unix()
p.statsMtx.Unlock()
// Set the peer's ID, user agent, and potentially the flag which
// specifies the witness support is enabled.
p.flagsMtx.Lock()
p.id = atomic.AddInt32(&nodeCount, 1)
p.userAgent = msg.UserAgent
// Determine if the peer would like to receive witness data with
// transactions, or not.
if p.services&wire.SFNodeWitness == wire.SFNodeWitness {
p.witnessEnabled = true
}
p.flagsMtx.Unlock()
// Once the version message has been exchanged, we're able to determine
// if this peer knows how to encode witness data over the wire
// protocol. If so, then we'll switch to a decoding mode which is
// prepared for the new transaction format introduced as part of
// BIP0144.
if p.services&wire.SFNodeWitness == wire.SFNodeWitness {
p.wireEncoding = wire.WitnessEncoding
}
// Invoke the callback if specified.
if p.cfg.Listeners.OnVersion != nil {
rejectMsg := p.cfg.Listeners.OnVersion(p, msg)
if rejectMsg != nil {
_ = p.writeMessage(rejectMsg, wire.LatestEncoding)
return errors.New(rejectMsg.Reason)
}
}
// Notify and disconnect clients that have a protocol version that is
// too old.
//
// NOTE: If minAcceptableProtocolVersion is raised to be higher than
// wire.RejectVersion, this should send a reject packet before
// disconnecting.
if uint32(msg.ProtocolVersion) < MinAcceptableProtocolVersion {
// Send a reject message indicating the protocol version is
// obsolete and wait for the message to be sent before
// disconnecting.
reason := fmt.Sprintf("protocol version must be %d or greater",
MinAcceptableProtocolVersion)
rejectMsg := wire.NewMsgReject(msg.Command(), wire.RejectObsolete,
reason)
_ = p.writeMessage(rejectMsg, wire.LatestEncoding)
return errors.New(reason)
}
return nil
} | go | func (p *Peer) readRemoteVersionMsg() error {
// Read their version message.
remoteMsg, _, err := p.readMessage(wire.LatestEncoding)
if err != nil {
return err
}
// Notify and disconnect clients if the first message is not a version
// message.
msg, ok := remoteMsg.(*wire.MsgVersion)
if !ok {
reason := "a version message must precede all others"
rejectMsg := wire.NewMsgReject(msg.Command(), wire.RejectMalformed,
reason)
_ = p.writeMessage(rejectMsg, wire.LatestEncoding)
return errors.New(reason)
}
// Detect self connections.
if !allowSelfConns && sentNonces.Exists(msg.Nonce) {
return errors.New("disconnecting peer connected to self")
}
// Negotiate the protocol version and set the services to what the remote
// peer advertised.
p.flagsMtx.Lock()
p.advertisedProtoVer = uint32(msg.ProtocolVersion)
p.protocolVersion = minUint32(p.protocolVersion, p.advertisedProtoVer)
p.versionKnown = true
p.services = msg.Services
p.flagsMtx.Unlock()
log.Debugf("Negotiated protocol version %d for peer %s",
p.protocolVersion, p)
// Updating a bunch of stats including block based stats, and the
// peer's time offset.
p.statsMtx.Lock()
p.lastBlock = msg.LastBlock
p.startingHeight = msg.LastBlock
p.timeOffset = msg.Timestamp.Unix() - time.Now().Unix()
p.statsMtx.Unlock()
// Set the peer's ID, user agent, and potentially the flag which
// specifies the witness support is enabled.
p.flagsMtx.Lock()
p.id = atomic.AddInt32(&nodeCount, 1)
p.userAgent = msg.UserAgent
// Determine if the peer would like to receive witness data with
// transactions, or not.
if p.services&wire.SFNodeWitness == wire.SFNodeWitness {
p.witnessEnabled = true
}
p.flagsMtx.Unlock()
// Once the version message has been exchanged, we're able to determine
// if this peer knows how to encode witness data over the wire
// protocol. If so, then we'll switch to a decoding mode which is
// prepared for the new transaction format introduced as part of
// BIP0144.
if p.services&wire.SFNodeWitness == wire.SFNodeWitness {
p.wireEncoding = wire.WitnessEncoding
}
// Invoke the callback if specified.
if p.cfg.Listeners.OnVersion != nil {
rejectMsg := p.cfg.Listeners.OnVersion(p, msg)
if rejectMsg != nil {
_ = p.writeMessage(rejectMsg, wire.LatestEncoding)
return errors.New(rejectMsg.Reason)
}
}
// Notify and disconnect clients that have a protocol version that is
// too old.
//
// NOTE: If minAcceptableProtocolVersion is raised to be higher than
// wire.RejectVersion, this should send a reject packet before
// disconnecting.
if uint32(msg.ProtocolVersion) < MinAcceptableProtocolVersion {
// Send a reject message indicating the protocol version is
// obsolete and wait for the message to be sent before
// disconnecting.
reason := fmt.Sprintf("protocol version must be %d or greater",
MinAcceptableProtocolVersion)
rejectMsg := wire.NewMsgReject(msg.Command(), wire.RejectObsolete,
reason)
_ = p.writeMessage(rejectMsg, wire.LatestEncoding)
return errors.New(reason)
}
return nil
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"readRemoteVersionMsg",
"(",
")",
"error",
"{",
"// Read their version message.",
"remoteMsg",
",",
"_",
",",
"err",
":=",
"p",
".",
"readMessage",
"(",
"wire",
".",
"LatestEncoding",
")",
"\n",
"if",
"err",
"!=",
"nil",... | // readRemoteVersionMsg waits for the next message to arrive from the remote
// peer. If the next message is not a version message or the version is not
// acceptable then return an error. | [
"readRemoteVersionMsg",
"waits",
"for",
"the",
"next",
"message",
"to",
"arrive",
"from",
"the",
"remote",
"peer",
".",
"If",
"the",
"next",
"message",
"is",
"not",
"a",
"version",
"message",
"or",
"the",
"version",
"is",
"not",
"acceptable",
"then",
"return... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1883-L1975 |
163,658 | btcsuite/btcd | peer/peer.go | localVersionMsg | func (p *Peer) localVersionMsg() (*wire.MsgVersion, error) {
var blockNum int32
if p.cfg.NewestBlock != nil {
var err error
_, blockNum, err = p.cfg.NewestBlock()
if err != nil {
return nil, err
}
}
theirNA := p.na
// If we are behind a proxy and the connection comes from the proxy then
// we return an unroutable address as their address. This is to prevent
// leaking the tor proxy address.
if p.cfg.Proxy != "" {
proxyaddress, _, err := net.SplitHostPort(p.cfg.Proxy)
// invalid proxy means poorly configured, be on the safe side.
if err != nil || p.na.IP.String() == proxyaddress {
theirNA = wire.NewNetAddressIPPort(net.IP([]byte{0, 0, 0, 0}), 0,
theirNA.Services)
}
}
// Create a wire.NetAddress with only the services set to use as the
// "addrme" in the version message.
//
// Older nodes previously added the IP and port information to the
// address manager which proved to be unreliable as an inbound
// connection from a peer didn't necessarily mean the peer itself
// accepted inbound connections.
//
// Also, the timestamp is unused in the version message.
ourNA := &wire.NetAddress{
Services: p.cfg.Services,
}
// Generate a unique nonce for this peer so self connections can be
// detected. This is accomplished by adding it to a size-limited map of
// recently seen nonces.
nonce := uint64(rand.Int63())
sentNonces.Add(nonce)
// Version message.
msg := wire.NewMsgVersion(ourNA, theirNA, nonce, blockNum)
msg.AddUserAgent(p.cfg.UserAgentName, p.cfg.UserAgentVersion,
p.cfg.UserAgentComments...)
// Advertise local services.
msg.Services = p.cfg.Services
// Advertise our max supported protocol version.
msg.ProtocolVersion = int32(p.cfg.ProtocolVersion)
// Advertise if inv messages for transactions are desired.
msg.DisableRelayTx = p.cfg.DisableRelayTx
return msg, nil
} | go | func (p *Peer) localVersionMsg() (*wire.MsgVersion, error) {
var blockNum int32
if p.cfg.NewestBlock != nil {
var err error
_, blockNum, err = p.cfg.NewestBlock()
if err != nil {
return nil, err
}
}
theirNA := p.na
// If we are behind a proxy and the connection comes from the proxy then
// we return an unroutable address as their address. This is to prevent
// leaking the tor proxy address.
if p.cfg.Proxy != "" {
proxyaddress, _, err := net.SplitHostPort(p.cfg.Proxy)
// invalid proxy means poorly configured, be on the safe side.
if err != nil || p.na.IP.String() == proxyaddress {
theirNA = wire.NewNetAddressIPPort(net.IP([]byte{0, 0, 0, 0}), 0,
theirNA.Services)
}
}
// Create a wire.NetAddress with only the services set to use as the
// "addrme" in the version message.
//
// Older nodes previously added the IP and port information to the
// address manager which proved to be unreliable as an inbound
// connection from a peer didn't necessarily mean the peer itself
// accepted inbound connections.
//
// Also, the timestamp is unused in the version message.
ourNA := &wire.NetAddress{
Services: p.cfg.Services,
}
// Generate a unique nonce for this peer so self connections can be
// detected. This is accomplished by adding it to a size-limited map of
// recently seen nonces.
nonce := uint64(rand.Int63())
sentNonces.Add(nonce)
// Version message.
msg := wire.NewMsgVersion(ourNA, theirNA, nonce, blockNum)
msg.AddUserAgent(p.cfg.UserAgentName, p.cfg.UserAgentVersion,
p.cfg.UserAgentComments...)
// Advertise local services.
msg.Services = p.cfg.Services
// Advertise our max supported protocol version.
msg.ProtocolVersion = int32(p.cfg.ProtocolVersion)
// Advertise if inv messages for transactions are desired.
msg.DisableRelayTx = p.cfg.DisableRelayTx
return msg, nil
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"localVersionMsg",
"(",
")",
"(",
"*",
"wire",
".",
"MsgVersion",
",",
"error",
")",
"{",
"var",
"blockNum",
"int32",
"\n",
"if",
"p",
".",
"cfg",
".",
"NewestBlock",
"!=",
"nil",
"{",
"var",
"err",
"error",
"\n"... | // localVersionMsg creates a version message that can be used to send to the
// remote peer. | [
"localVersionMsg",
"creates",
"a",
"version",
"message",
"that",
"can",
"be",
"used",
"to",
"send",
"to",
"the",
"remote",
"peer",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L1979-L2037 |
163,659 | btcsuite/btcd | peer/peer.go | writeLocalVersionMsg | func (p *Peer) writeLocalVersionMsg() error {
localVerMsg, err := p.localVersionMsg()
if err != nil {
return err
}
return p.writeMessage(localVerMsg, wire.LatestEncoding)
} | go | func (p *Peer) writeLocalVersionMsg() error {
localVerMsg, err := p.localVersionMsg()
if err != nil {
return err
}
return p.writeMessage(localVerMsg, wire.LatestEncoding)
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"writeLocalVersionMsg",
"(",
")",
"error",
"{",
"localVerMsg",
",",
"err",
":=",
"p",
".",
"localVersionMsg",
"(",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"p",
".",
... | // writeLocalVersionMsg writes our version message to the remote peer. | [
"writeLocalVersionMsg",
"writes",
"our",
"version",
"message",
"to",
"the",
"remote",
"peer",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L2040-L2047 |
163,660 | btcsuite/btcd | peer/peer.go | negotiateInboundProtocol | func (p *Peer) negotiateInboundProtocol() error {
if err := p.readRemoteVersionMsg(); err != nil {
return err
}
return p.writeLocalVersionMsg()
} | go | func (p *Peer) negotiateInboundProtocol() error {
if err := p.readRemoteVersionMsg(); err != nil {
return err
}
return p.writeLocalVersionMsg()
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"negotiateInboundProtocol",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"p",
".",
"readRemoteVersionMsg",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"writeLocalVers... | // negotiateInboundProtocol waits to receive a version message from the peer
// then sends our version message. If the events do not occur in that order then
// it returns an error. | [
"negotiateInboundProtocol",
"waits",
"to",
"receive",
"a",
"version",
"message",
"from",
"the",
"peer",
"then",
"sends",
"our",
"version",
"message",
".",
"If",
"the",
"events",
"do",
"not",
"occur",
"in",
"that",
"order",
"then",
"it",
"returns",
"an",
"err... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L2052-L2058 |
163,661 | btcsuite/btcd | peer/peer.go | negotiateOutboundProtocol | func (p *Peer) negotiateOutboundProtocol() error {
if err := p.writeLocalVersionMsg(); err != nil {
return err
}
return p.readRemoteVersionMsg()
} | go | func (p *Peer) negotiateOutboundProtocol() error {
if err := p.writeLocalVersionMsg(); err != nil {
return err
}
return p.readRemoteVersionMsg()
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"negotiateOutboundProtocol",
"(",
")",
"error",
"{",
"if",
"err",
":=",
"p",
".",
"writeLocalVersionMsg",
"(",
")",
";",
"err",
"!=",
"nil",
"{",
"return",
"err",
"\n",
"}",
"\n\n",
"return",
"p",
".",
"readRemoteVer... | // negotiateOutboundProtocol sends our version message then waits to receive a
// version message from the peer. If the events do not occur in that order then
// it returns an error. | [
"negotiateOutboundProtocol",
"sends",
"our",
"version",
"message",
"then",
"waits",
"to",
"receive",
"a",
"version",
"message",
"from",
"the",
"peer",
".",
"If",
"the",
"events",
"do",
"not",
"occur",
"in",
"that",
"order",
"then",
"it",
"returns",
"an",
"er... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L2063-L2069 |
163,662 | btcsuite/btcd | peer/peer.go | AssociateConnection | func (p *Peer) AssociateConnection(conn net.Conn) {
// Already connected?
if !atomic.CompareAndSwapInt32(&p.connected, 0, 1) {
return
}
p.conn = conn
p.timeConnected = time.Now()
if p.inbound {
p.addr = p.conn.RemoteAddr().String()
// Set up a NetAddress for the peer to be used with AddrManager. We
// only do this inbound because outbound set this up at connection time
// and no point recomputing.
na, err := newNetAddress(p.conn.RemoteAddr(), p.services)
if err != nil {
log.Errorf("Cannot create remote net address: %v", err)
p.Disconnect()
return
}
p.na = na
}
go func() {
if err := p.start(); err != nil {
log.Debugf("Cannot start peer %v: %v", p, err)
p.Disconnect()
}
}()
} | go | func (p *Peer) AssociateConnection(conn net.Conn) {
// Already connected?
if !atomic.CompareAndSwapInt32(&p.connected, 0, 1) {
return
}
p.conn = conn
p.timeConnected = time.Now()
if p.inbound {
p.addr = p.conn.RemoteAddr().String()
// Set up a NetAddress for the peer to be used with AddrManager. We
// only do this inbound because outbound set this up at connection time
// and no point recomputing.
na, err := newNetAddress(p.conn.RemoteAddr(), p.services)
if err != nil {
log.Errorf("Cannot create remote net address: %v", err)
p.Disconnect()
return
}
p.na = na
}
go func() {
if err := p.start(); err != nil {
log.Debugf("Cannot start peer %v: %v", p, err)
p.Disconnect()
}
}()
} | [
"func",
"(",
"p",
"*",
"Peer",
")",
"AssociateConnection",
"(",
"conn",
"net",
".",
"Conn",
")",
"{",
"// Already connected?",
"if",
"!",
"atomic",
".",
"CompareAndSwapInt32",
"(",
"&",
"p",
".",
"connected",
",",
"0",
",",
"1",
")",
"{",
"return",
"\n... | // AssociateConnection associates the given conn to the peer. Calling this
// function when the peer is already connected will have no effect. | [
"AssociateConnection",
"associates",
"the",
"given",
"conn",
"to",
"the",
"peer",
".",
"Calling",
"this",
"function",
"when",
"the",
"peer",
"is",
"already",
"connected",
"will",
"have",
"no",
"effect",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L2112-L2142 |
163,663 | btcsuite/btcd | peer/peer.go | newPeerBase | func newPeerBase(origCfg *Config, inbound bool) *Peer {
// Default to the max supported protocol version if not specified by the
// caller.
cfg := *origCfg // Copy to avoid mutating caller.
if cfg.ProtocolVersion == 0 {
cfg.ProtocolVersion = MaxProtocolVersion
}
// Set the chain parameters to testnet if the caller did not specify any.
if cfg.ChainParams == nil {
cfg.ChainParams = &chaincfg.TestNet3Params
}
// Set the trickle interval if a non-positive value is specified.
if cfg.TrickleInterval <= 0 {
cfg.TrickleInterval = DefaultTrickleInterval
}
p := Peer{
inbound: inbound,
wireEncoding: wire.BaseEncoding,
knownInventory: newMruInventoryMap(maxKnownInventory),
stallControl: make(chan stallControlMsg, 1), // nonblocking sync
outputQueue: make(chan outMsg, outputBufferSize),
sendQueue: make(chan outMsg, 1), // nonblocking sync
sendDoneQueue: make(chan struct{}, 1), // nonblocking sync
outputInvChan: make(chan *wire.InvVect, outputBufferSize),
inQuit: make(chan struct{}),
queueQuit: make(chan struct{}),
outQuit: make(chan struct{}),
quit: make(chan struct{}),
cfg: cfg, // Copy so caller can't mutate.
services: cfg.Services,
protocolVersion: cfg.ProtocolVersion,
}
return &p
} | go | func newPeerBase(origCfg *Config, inbound bool) *Peer {
// Default to the max supported protocol version if not specified by the
// caller.
cfg := *origCfg // Copy to avoid mutating caller.
if cfg.ProtocolVersion == 0 {
cfg.ProtocolVersion = MaxProtocolVersion
}
// Set the chain parameters to testnet if the caller did not specify any.
if cfg.ChainParams == nil {
cfg.ChainParams = &chaincfg.TestNet3Params
}
// Set the trickle interval if a non-positive value is specified.
if cfg.TrickleInterval <= 0 {
cfg.TrickleInterval = DefaultTrickleInterval
}
p := Peer{
inbound: inbound,
wireEncoding: wire.BaseEncoding,
knownInventory: newMruInventoryMap(maxKnownInventory),
stallControl: make(chan stallControlMsg, 1), // nonblocking sync
outputQueue: make(chan outMsg, outputBufferSize),
sendQueue: make(chan outMsg, 1), // nonblocking sync
sendDoneQueue: make(chan struct{}, 1), // nonblocking sync
outputInvChan: make(chan *wire.InvVect, outputBufferSize),
inQuit: make(chan struct{}),
queueQuit: make(chan struct{}),
outQuit: make(chan struct{}),
quit: make(chan struct{}),
cfg: cfg, // Copy so caller can't mutate.
services: cfg.Services,
protocolVersion: cfg.ProtocolVersion,
}
return &p
} | [
"func",
"newPeerBase",
"(",
"origCfg",
"*",
"Config",
",",
"inbound",
"bool",
")",
"*",
"Peer",
"{",
"// Default to the max supported protocol version if not specified by the",
"// caller.",
"cfg",
":=",
"*",
"origCfg",
"// Copy to avoid mutating caller.",
"\n",
"if",
"cf... | // newPeerBase returns a new base bitcoin peer based on the inbound flag. This
// is used by the NewInboundPeer and NewOutboundPeer functions to perform base
// setup needed by both types of peers. | [
"newPeerBase",
"returns",
"a",
"new",
"base",
"bitcoin",
"peer",
"based",
"on",
"the",
"inbound",
"flag",
".",
"This",
"is",
"used",
"by",
"the",
"NewInboundPeer",
"and",
"NewOutboundPeer",
"functions",
"to",
"perform",
"base",
"setup",
"needed",
"by",
"both",... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L2155-L2191 |
163,664 | btcsuite/btcd | peer/peer.go | NewOutboundPeer | func NewOutboundPeer(cfg *Config, addr string) (*Peer, error) {
p := newPeerBase(cfg, false)
p.addr = addr
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
port, err := strconv.ParseUint(portStr, 10, 16)
if err != nil {
return nil, err
}
if cfg.HostToNetAddress != nil {
na, err := cfg.HostToNetAddress(host, uint16(port), 0)
if err != nil {
return nil, err
}
p.na = na
} else {
p.na = wire.NewNetAddressIPPort(net.ParseIP(host), uint16(port), 0)
}
return p, nil
} | go | func NewOutboundPeer(cfg *Config, addr string) (*Peer, error) {
p := newPeerBase(cfg, false)
p.addr = addr
host, portStr, err := net.SplitHostPort(addr)
if err != nil {
return nil, err
}
port, err := strconv.ParseUint(portStr, 10, 16)
if err != nil {
return nil, err
}
if cfg.HostToNetAddress != nil {
na, err := cfg.HostToNetAddress(host, uint16(port), 0)
if err != nil {
return nil, err
}
p.na = na
} else {
p.na = wire.NewNetAddressIPPort(net.ParseIP(host), uint16(port), 0)
}
return p, nil
} | [
"func",
"NewOutboundPeer",
"(",
"cfg",
"*",
"Config",
",",
"addr",
"string",
")",
"(",
"*",
"Peer",
",",
"error",
")",
"{",
"p",
":=",
"newPeerBase",
"(",
"cfg",
",",
"false",
")",
"\n",
"p",
".",
"addr",
"=",
"addr",
"\n\n",
"host",
",",
"portStr"... | // NewOutboundPeer returns a new outbound bitcoin peer. | [
"NewOutboundPeer",
"returns",
"a",
"new",
"outbound",
"bitcoin",
"peer",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/peer/peer.go#L2200-L2225 |
163,665 | btcsuite/btcd | wire/message.go | makeEmptyMessage | func makeEmptyMessage(command string) (Message, error) {
var msg Message
switch command {
case CmdVersion:
msg = &MsgVersion{}
case CmdVerAck:
msg = &MsgVerAck{}
case CmdGetAddr:
msg = &MsgGetAddr{}
case CmdAddr:
msg = &MsgAddr{}
case CmdGetBlocks:
msg = &MsgGetBlocks{}
case CmdBlock:
msg = &MsgBlock{}
case CmdInv:
msg = &MsgInv{}
case CmdGetData:
msg = &MsgGetData{}
case CmdNotFound:
msg = &MsgNotFound{}
case CmdTx:
msg = &MsgTx{}
case CmdPing:
msg = &MsgPing{}
case CmdPong:
msg = &MsgPong{}
case CmdGetHeaders:
msg = &MsgGetHeaders{}
case CmdHeaders:
msg = &MsgHeaders{}
case CmdAlert:
msg = &MsgAlert{}
case CmdMemPool:
msg = &MsgMemPool{}
case CmdFilterAdd:
msg = &MsgFilterAdd{}
case CmdFilterClear:
msg = &MsgFilterClear{}
case CmdFilterLoad:
msg = &MsgFilterLoad{}
case CmdMerkleBlock:
msg = &MsgMerkleBlock{}
case CmdReject:
msg = &MsgReject{}
case CmdSendHeaders:
msg = &MsgSendHeaders{}
case CmdFeeFilter:
msg = &MsgFeeFilter{}
case CmdGetCFilters:
msg = &MsgGetCFilters{}
case CmdGetCFHeaders:
msg = &MsgGetCFHeaders{}
case CmdGetCFCheckpt:
msg = &MsgGetCFCheckpt{}
case CmdCFilter:
msg = &MsgCFilter{}
case CmdCFHeaders:
msg = &MsgCFHeaders{}
case CmdCFCheckpt:
msg = &MsgCFCheckpt{}
default:
return nil, fmt.Errorf("unhandled command [%s]", command)
}
return msg, nil
} | go | func makeEmptyMessage(command string) (Message, error) {
var msg Message
switch command {
case CmdVersion:
msg = &MsgVersion{}
case CmdVerAck:
msg = &MsgVerAck{}
case CmdGetAddr:
msg = &MsgGetAddr{}
case CmdAddr:
msg = &MsgAddr{}
case CmdGetBlocks:
msg = &MsgGetBlocks{}
case CmdBlock:
msg = &MsgBlock{}
case CmdInv:
msg = &MsgInv{}
case CmdGetData:
msg = &MsgGetData{}
case CmdNotFound:
msg = &MsgNotFound{}
case CmdTx:
msg = &MsgTx{}
case CmdPing:
msg = &MsgPing{}
case CmdPong:
msg = &MsgPong{}
case CmdGetHeaders:
msg = &MsgGetHeaders{}
case CmdHeaders:
msg = &MsgHeaders{}
case CmdAlert:
msg = &MsgAlert{}
case CmdMemPool:
msg = &MsgMemPool{}
case CmdFilterAdd:
msg = &MsgFilterAdd{}
case CmdFilterClear:
msg = &MsgFilterClear{}
case CmdFilterLoad:
msg = &MsgFilterLoad{}
case CmdMerkleBlock:
msg = &MsgMerkleBlock{}
case CmdReject:
msg = &MsgReject{}
case CmdSendHeaders:
msg = &MsgSendHeaders{}
case CmdFeeFilter:
msg = &MsgFeeFilter{}
case CmdGetCFilters:
msg = &MsgGetCFilters{}
case CmdGetCFHeaders:
msg = &MsgGetCFHeaders{}
case CmdGetCFCheckpt:
msg = &MsgGetCFCheckpt{}
case CmdCFilter:
msg = &MsgCFilter{}
case CmdCFHeaders:
msg = &MsgCFHeaders{}
case CmdCFCheckpt:
msg = &MsgCFCheckpt{}
default:
return nil, fmt.Errorf("unhandled command [%s]", command)
}
return msg, nil
} | [
"func",
"makeEmptyMessage",
"(",
"command",
"string",
")",
"(",
"Message",
",",
"error",
")",
"{",
"var",
"msg",
"Message",
"\n",
"switch",
"command",
"{",
"case",
"CmdVersion",
":",
"msg",
"=",
"&",
"MsgVersion",
"{",
"}",
"\n\n",
"case",
"CmdVerAck",
"... | // makeEmptyMessage creates a message of the appropriate concrete type based
// on the command. | [
"makeEmptyMessage",
"creates",
"a",
"message",
"of",
"the",
"appropriate",
"concrete",
"type",
"based",
"on",
"the",
"command",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L93-L187 |
163,666 | btcsuite/btcd | wire/message.go | readMessageHeader | func readMessageHeader(r io.Reader) (int, *messageHeader, error) {
// Since readElements doesn't return the amount of bytes read, attempt
// to read the entire header into a buffer first in case there is a
// short read so the proper amount of read bytes are known. This works
// since the header is a fixed size.
var headerBytes [MessageHeaderSize]byte
n, err := io.ReadFull(r, headerBytes[:])
if err != nil {
return n, nil, err
}
hr := bytes.NewReader(headerBytes[:])
// Create and populate a messageHeader struct from the raw header bytes.
hdr := messageHeader{}
var command [CommandSize]byte
readElements(hr, &hdr.magic, &command, &hdr.length, &hdr.checksum)
// Strip trailing zeros from command string.
hdr.command = string(bytes.TrimRight(command[:], string(0)))
return n, &hdr, nil
} | go | func readMessageHeader(r io.Reader) (int, *messageHeader, error) {
// Since readElements doesn't return the amount of bytes read, attempt
// to read the entire header into a buffer first in case there is a
// short read so the proper amount of read bytes are known. This works
// since the header is a fixed size.
var headerBytes [MessageHeaderSize]byte
n, err := io.ReadFull(r, headerBytes[:])
if err != nil {
return n, nil, err
}
hr := bytes.NewReader(headerBytes[:])
// Create and populate a messageHeader struct from the raw header bytes.
hdr := messageHeader{}
var command [CommandSize]byte
readElements(hr, &hdr.magic, &command, &hdr.length, &hdr.checksum)
// Strip trailing zeros from command string.
hdr.command = string(bytes.TrimRight(command[:], string(0)))
return n, &hdr, nil
} | [
"func",
"readMessageHeader",
"(",
"r",
"io",
".",
"Reader",
")",
"(",
"int",
",",
"*",
"messageHeader",
",",
"error",
")",
"{",
"// Since readElements doesn't return the amount of bytes read, attempt",
"// to read the entire header into a buffer first in case there is a",
"// s... | // readMessageHeader reads a bitcoin message header from r. | [
"readMessageHeader",
"reads",
"a",
"bitcoin",
"message",
"header",
"from",
"r",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L198-L219 |
163,667 | btcsuite/btcd | wire/message.go | discardInput | func discardInput(r io.Reader, n uint32) {
maxSize := uint32(10 * 1024) // 10k at a time
numReads := n / maxSize
bytesRemaining := n % maxSize
if n > 0 {
buf := make([]byte, maxSize)
for i := uint32(0); i < numReads; i++ {
io.ReadFull(r, buf)
}
}
if bytesRemaining > 0 {
buf := make([]byte, bytesRemaining)
io.ReadFull(r, buf)
}
} | go | func discardInput(r io.Reader, n uint32) {
maxSize := uint32(10 * 1024) // 10k at a time
numReads := n / maxSize
bytesRemaining := n % maxSize
if n > 0 {
buf := make([]byte, maxSize)
for i := uint32(0); i < numReads; i++ {
io.ReadFull(r, buf)
}
}
if bytesRemaining > 0 {
buf := make([]byte, bytesRemaining)
io.ReadFull(r, buf)
}
} | [
"func",
"discardInput",
"(",
"r",
"io",
".",
"Reader",
",",
"n",
"uint32",
")",
"{",
"maxSize",
":=",
"uint32",
"(",
"10",
"*",
"1024",
")",
"// 10k at a time",
"\n",
"numReads",
":=",
"n",
"/",
"maxSize",
"\n",
"bytesRemaining",
":=",
"n",
"%",
"maxSi... | // discardInput reads n bytes from reader r in chunks and discards the read
// bytes. This is used to skip payloads when various errors occur and helps
// prevent rogue nodes from causing massive memory allocation through forging
// header length. | [
"discardInput",
"reads",
"n",
"bytes",
"from",
"reader",
"r",
"in",
"chunks",
"and",
"discards",
"the",
"read",
"bytes",
".",
"This",
"is",
"used",
"to",
"skip",
"payloads",
"when",
"various",
"errors",
"occur",
"and",
"helps",
"prevent",
"rogue",
"nodes",
... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L225-L239 |
163,668 | btcsuite/btcd | wire/message.go | WriteMessageN | func WriteMessageN(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) (int, error) {
return WriteMessageWithEncodingN(w, msg, pver, btcnet, BaseEncoding)
} | go | func WriteMessageN(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) (int, error) {
return WriteMessageWithEncodingN(w, msg, pver, btcnet, BaseEncoding)
} | [
"func",
"WriteMessageN",
"(",
"w",
"io",
".",
"Writer",
",",
"msg",
"Message",
",",
"pver",
"uint32",
",",
"btcnet",
"BitcoinNet",
")",
"(",
"int",
",",
"error",
")",
"{",
"return",
"WriteMessageWithEncodingN",
"(",
"w",
",",
"msg",
",",
"pver",
",",
"... | // WriteMessageN writes a bitcoin Message to w including the necessary header
// information and returns the number of bytes written. This function is the
// same as WriteMessage except it also returns the number of bytes written. | [
"WriteMessageN",
"writes",
"a",
"bitcoin",
"Message",
"to",
"w",
"including",
"the",
"necessary",
"header",
"information",
"and",
"returns",
"the",
"number",
"of",
"bytes",
"written",
".",
"This",
"function",
"is",
"the",
"same",
"as",
"WriteMessage",
"except",
... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L244-L246 |
163,669 | btcsuite/btcd | wire/message.go | WriteMessage | func WriteMessage(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) error {
_, err := WriteMessageN(w, msg, pver, btcnet)
return err
} | go | func WriteMessage(w io.Writer, msg Message, pver uint32, btcnet BitcoinNet) error {
_, err := WriteMessageN(w, msg, pver, btcnet)
return err
} | [
"func",
"WriteMessage",
"(",
"w",
"io",
".",
"Writer",
",",
"msg",
"Message",
",",
"pver",
"uint32",
",",
"btcnet",
"BitcoinNet",
")",
"error",
"{",
"_",
",",
"err",
":=",
"WriteMessageN",
"(",
"w",
",",
"msg",
",",
"pver",
",",
"btcnet",
")",
"\n",
... | // WriteMessage writes a bitcoin Message to w including the necessary header
// information. This function is the same as WriteMessageN except it doesn't
// doesn't return the number of bytes written. This function is mainly provided
// for backwards compatibility with the original API, but it's also useful for
// callers that don't care about byte counts. | [
"WriteMessage",
"writes",
"a",
"bitcoin",
"Message",
"to",
"w",
"including",
"the",
"necessary",
"header",
"information",
".",
"This",
"function",
"is",
"the",
"same",
"as",
"WriteMessageN",
"except",
"it",
"doesn",
"t",
"doesn",
"t",
"return",
"the",
"number"... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L253-L256 |
163,670 | btcsuite/btcd | wire/message.go | WriteMessageWithEncodingN | func WriteMessageWithEncodingN(w io.Writer, msg Message, pver uint32,
btcnet BitcoinNet, encoding MessageEncoding) (int, error) {
totalBytes := 0
// Enforce max command size.
var command [CommandSize]byte
cmd := msg.Command()
if len(cmd) > CommandSize {
str := fmt.Sprintf("command [%s] is too long [max %v]",
cmd, CommandSize)
return totalBytes, messageError("WriteMessage", str)
}
copy(command[:], []byte(cmd))
// Encode the message payload.
var bw bytes.Buffer
err := msg.BtcEncode(&bw, pver, encoding)
if err != nil {
return totalBytes, err
}
payload := bw.Bytes()
lenp := len(payload)
// Enforce maximum overall message payload.
if lenp > MaxMessagePayload {
str := fmt.Sprintf("message payload is too large - encoded "+
"%d bytes, but maximum message payload is %d bytes",
lenp, MaxMessagePayload)
return totalBytes, messageError("WriteMessage", str)
}
// Enforce maximum message payload based on the message type.
mpl := msg.MaxPayloadLength(pver)
if uint32(lenp) > mpl {
str := fmt.Sprintf("message payload is too large - encoded "+
"%d bytes, but maximum message payload size for "+
"messages of type [%s] is %d.", lenp, cmd, mpl)
return totalBytes, messageError("WriteMessage", str)
}
// Create header for the message.
hdr := messageHeader{}
hdr.magic = btcnet
hdr.command = cmd
hdr.length = uint32(lenp)
copy(hdr.checksum[:], chainhash.DoubleHashB(payload)[0:4])
// Encode the header for the message. This is done to a buffer
// rather than directly to the writer since writeElements doesn't
// return the number of bytes written.
hw := bytes.NewBuffer(make([]byte, 0, MessageHeaderSize))
writeElements(hw, hdr.magic, command, hdr.length, hdr.checksum)
// Write header.
n, err := w.Write(hw.Bytes())
totalBytes += n
if err != nil {
return totalBytes, err
}
// Write payload.
n, err = w.Write(payload)
totalBytes += n
return totalBytes, err
} | go | func WriteMessageWithEncodingN(w io.Writer, msg Message, pver uint32,
btcnet BitcoinNet, encoding MessageEncoding) (int, error) {
totalBytes := 0
// Enforce max command size.
var command [CommandSize]byte
cmd := msg.Command()
if len(cmd) > CommandSize {
str := fmt.Sprintf("command [%s] is too long [max %v]",
cmd, CommandSize)
return totalBytes, messageError("WriteMessage", str)
}
copy(command[:], []byte(cmd))
// Encode the message payload.
var bw bytes.Buffer
err := msg.BtcEncode(&bw, pver, encoding)
if err != nil {
return totalBytes, err
}
payload := bw.Bytes()
lenp := len(payload)
// Enforce maximum overall message payload.
if lenp > MaxMessagePayload {
str := fmt.Sprintf("message payload is too large - encoded "+
"%d bytes, but maximum message payload is %d bytes",
lenp, MaxMessagePayload)
return totalBytes, messageError("WriteMessage", str)
}
// Enforce maximum message payload based on the message type.
mpl := msg.MaxPayloadLength(pver)
if uint32(lenp) > mpl {
str := fmt.Sprintf("message payload is too large - encoded "+
"%d bytes, but maximum message payload size for "+
"messages of type [%s] is %d.", lenp, cmd, mpl)
return totalBytes, messageError("WriteMessage", str)
}
// Create header for the message.
hdr := messageHeader{}
hdr.magic = btcnet
hdr.command = cmd
hdr.length = uint32(lenp)
copy(hdr.checksum[:], chainhash.DoubleHashB(payload)[0:4])
// Encode the header for the message. This is done to a buffer
// rather than directly to the writer since writeElements doesn't
// return the number of bytes written.
hw := bytes.NewBuffer(make([]byte, 0, MessageHeaderSize))
writeElements(hw, hdr.magic, command, hdr.length, hdr.checksum)
// Write header.
n, err := w.Write(hw.Bytes())
totalBytes += n
if err != nil {
return totalBytes, err
}
// Write payload.
n, err = w.Write(payload)
totalBytes += n
return totalBytes, err
} | [
"func",
"WriteMessageWithEncodingN",
"(",
"w",
"io",
".",
"Writer",
",",
"msg",
"Message",
",",
"pver",
"uint32",
",",
"btcnet",
"BitcoinNet",
",",
"encoding",
"MessageEncoding",
")",
"(",
"int",
",",
"error",
")",
"{",
"totalBytes",
":=",
"0",
"\n\n",
"//... | // WriteMessageWithEncodingN writes a bitcoin Message to w including the
// necessary header information and returns the number of bytes written.
// This function is the same as WriteMessageN except it also allows the caller
// to specify the message encoding format to be used when serializing wire
// messages. | [
"WriteMessageWithEncodingN",
"writes",
"a",
"bitcoin",
"Message",
"to",
"w",
"including",
"the",
"necessary",
"header",
"information",
"and",
"returns",
"the",
"number",
"of",
"bytes",
"written",
".",
"This",
"function",
"is",
"the",
"same",
"as",
"WriteMessageN",... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L263-L328 |
163,671 | btcsuite/btcd | wire/message.go | ReadMessageWithEncodingN | func ReadMessageWithEncodingN(r io.Reader, pver uint32, btcnet BitcoinNet,
enc MessageEncoding) (int, Message, []byte, error) {
totalBytes := 0
n, hdr, err := readMessageHeader(r)
totalBytes += n
if err != nil {
return totalBytes, nil, nil, err
}
// Enforce maximum message payload.
if hdr.length > MaxMessagePayload {
str := fmt.Sprintf("message payload is too large - header "+
"indicates %d bytes, but max message payload is %d "+
"bytes.", hdr.length, MaxMessagePayload)
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Check for messages from the wrong bitcoin network.
if hdr.magic != btcnet {
discardInput(r, hdr.length)
str := fmt.Sprintf("message from other network [%v]", hdr.magic)
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Check for malformed commands.
command := hdr.command
if !utf8.ValidString(command) {
discardInput(r, hdr.length)
str := fmt.Sprintf("invalid command %v", []byte(command))
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Create struct of appropriate message type based on the command.
msg, err := makeEmptyMessage(command)
if err != nil {
discardInput(r, hdr.length)
return totalBytes, nil, nil, messageError("ReadMessage",
err.Error())
}
// Check for maximum length based on the message type as a malicious client
// could otherwise create a well-formed header and set the length to max
// numbers in order to exhaust the machine's memory.
mpl := msg.MaxPayloadLength(pver)
if hdr.length > mpl {
discardInput(r, hdr.length)
str := fmt.Sprintf("payload exceeds max length - header "+
"indicates %v bytes, but max payload size for "+
"messages of type [%v] is %v.", hdr.length, command, mpl)
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Read payload.
payload := make([]byte, hdr.length)
n, err = io.ReadFull(r, payload)
totalBytes += n
if err != nil {
return totalBytes, nil, nil, err
}
// Test checksum.
checksum := chainhash.DoubleHashB(payload)[0:4]
if !bytes.Equal(checksum[:], hdr.checksum[:]) {
str := fmt.Sprintf("payload checksum failed - header "+
"indicates %v, but actual checksum is %v.",
hdr.checksum, checksum)
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Unmarshal message. NOTE: This must be a *bytes.Buffer since the
// MsgVersion BtcDecode function requires it.
pr := bytes.NewBuffer(payload)
err = msg.BtcDecode(pr, pver, enc)
if err != nil {
return totalBytes, nil, nil, err
}
return totalBytes, msg, payload, nil
} | go | func ReadMessageWithEncodingN(r io.Reader, pver uint32, btcnet BitcoinNet,
enc MessageEncoding) (int, Message, []byte, error) {
totalBytes := 0
n, hdr, err := readMessageHeader(r)
totalBytes += n
if err != nil {
return totalBytes, nil, nil, err
}
// Enforce maximum message payload.
if hdr.length > MaxMessagePayload {
str := fmt.Sprintf("message payload is too large - header "+
"indicates %d bytes, but max message payload is %d "+
"bytes.", hdr.length, MaxMessagePayload)
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Check for messages from the wrong bitcoin network.
if hdr.magic != btcnet {
discardInput(r, hdr.length)
str := fmt.Sprintf("message from other network [%v]", hdr.magic)
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Check for malformed commands.
command := hdr.command
if !utf8.ValidString(command) {
discardInput(r, hdr.length)
str := fmt.Sprintf("invalid command %v", []byte(command))
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Create struct of appropriate message type based on the command.
msg, err := makeEmptyMessage(command)
if err != nil {
discardInput(r, hdr.length)
return totalBytes, nil, nil, messageError("ReadMessage",
err.Error())
}
// Check for maximum length based on the message type as a malicious client
// could otherwise create a well-formed header and set the length to max
// numbers in order to exhaust the machine's memory.
mpl := msg.MaxPayloadLength(pver)
if hdr.length > mpl {
discardInput(r, hdr.length)
str := fmt.Sprintf("payload exceeds max length - header "+
"indicates %v bytes, but max payload size for "+
"messages of type [%v] is %v.", hdr.length, command, mpl)
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Read payload.
payload := make([]byte, hdr.length)
n, err = io.ReadFull(r, payload)
totalBytes += n
if err != nil {
return totalBytes, nil, nil, err
}
// Test checksum.
checksum := chainhash.DoubleHashB(payload)[0:4]
if !bytes.Equal(checksum[:], hdr.checksum[:]) {
str := fmt.Sprintf("payload checksum failed - header "+
"indicates %v, but actual checksum is %v.",
hdr.checksum, checksum)
return totalBytes, nil, nil, messageError("ReadMessage", str)
}
// Unmarshal message. NOTE: This must be a *bytes.Buffer since the
// MsgVersion BtcDecode function requires it.
pr := bytes.NewBuffer(payload)
err = msg.BtcDecode(pr, pver, enc)
if err != nil {
return totalBytes, nil, nil, err
}
return totalBytes, msg, payload, nil
} | [
"func",
"ReadMessageWithEncodingN",
"(",
"r",
"io",
".",
"Reader",
",",
"pver",
"uint32",
",",
"btcnet",
"BitcoinNet",
",",
"enc",
"MessageEncoding",
")",
"(",
"int",
",",
"Message",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"totalBytes",
":=",
"0",... | // ReadMessageWithEncodingN reads, validates, and parses the next bitcoin Message
// from r for the provided protocol version and bitcoin network. It returns the
// number of bytes read in addition to the parsed Message and raw bytes which
// comprise the message. This function is the same as ReadMessageN except it
// allows the caller to specify which message encoding is to to consult when
// decoding wire messages. | [
"ReadMessageWithEncodingN",
"reads",
"validates",
"and",
"parses",
"the",
"next",
"bitcoin",
"Message",
"from",
"r",
"for",
"the",
"provided",
"protocol",
"version",
"and",
"bitcoin",
"network",
".",
"It",
"returns",
"the",
"number",
"of",
"bytes",
"read",
"in",... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L336-L416 |
163,672 | btcsuite/btcd | wire/message.go | ReadMessageN | func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []byte, error) {
return ReadMessageWithEncodingN(r, pver, btcnet, BaseEncoding)
} | go | func ReadMessageN(r io.Reader, pver uint32, btcnet BitcoinNet) (int, Message, []byte, error) {
return ReadMessageWithEncodingN(r, pver, btcnet, BaseEncoding)
} | [
"func",
"ReadMessageN",
"(",
"r",
"io",
".",
"Reader",
",",
"pver",
"uint32",
",",
"btcnet",
"BitcoinNet",
")",
"(",
"int",
",",
"Message",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"return",
"ReadMessageWithEncodingN",
"(",
"r",
",",
"pver",
",",... | // ReadMessageN reads, validates, and parses the next bitcoin Message from r for
// the provided protocol version and bitcoin network. It returns the number of
// bytes read in addition to the parsed Message and raw bytes which comprise the
// message. This function is the same as ReadMessage except it also returns the
// number of bytes read. | [
"ReadMessageN",
"reads",
"validates",
"and",
"parses",
"the",
"next",
"bitcoin",
"Message",
"from",
"r",
"for",
"the",
"provided",
"protocol",
"version",
"and",
"bitcoin",
"network",
".",
"It",
"returns",
"the",
"number",
"of",
"bytes",
"read",
"in",
"addition... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L423-L425 |
163,673 | btcsuite/btcd | wire/message.go | ReadMessage | func ReadMessage(r io.Reader, pver uint32, btcnet BitcoinNet) (Message, []byte, error) {
_, msg, buf, err := ReadMessageN(r, pver, btcnet)
return msg, buf, err
} | go | func ReadMessage(r io.Reader, pver uint32, btcnet BitcoinNet) (Message, []byte, error) {
_, msg, buf, err := ReadMessageN(r, pver, btcnet)
return msg, buf, err
} | [
"func",
"ReadMessage",
"(",
"r",
"io",
".",
"Reader",
",",
"pver",
"uint32",
",",
"btcnet",
"BitcoinNet",
")",
"(",
"Message",
",",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"_",
",",
"msg",
",",
"buf",
",",
"err",
":=",
"ReadMessageN",
"(",
"r",
... | // ReadMessage reads, validates, and parses the next bitcoin Message from r for
// the provided protocol version and bitcoin network. It returns the parsed
// Message and raw bytes which comprise the message. This function only differs
// from ReadMessageN in that it doesn't return the number of bytes read. This
// function is mainly provided for backwards compatibility with the original
// API, but it's also useful for callers that don't care about byte counts. | [
"ReadMessage",
"reads",
"validates",
"and",
"parses",
"the",
"next",
"bitcoin",
"Message",
"from",
"r",
"for",
"the",
"provided",
"protocol",
"version",
"and",
"bitcoin",
"network",
".",
"It",
"returns",
"the",
"parsed",
"Message",
"and",
"raw",
"bytes",
"whic... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/message.go#L433-L436 |
163,674 | btcsuite/btcd | database/internal/treap/treapiter.go | limitIterator | func (iter *Iterator) limitIterator() bool {
if iter.node == nil {
return false
}
node := iter.node
if iter.startKey != nil && bytes.Compare(node.key, iter.startKey) < 0 {
iter.node = nil
return false
}
if iter.limitKey != nil && bytes.Compare(node.key, iter.limitKey) >= 0 {
iter.node = nil
return false
}
return true
} | go | func (iter *Iterator) limitIterator() bool {
if iter.node == nil {
return false
}
node := iter.node
if iter.startKey != nil && bytes.Compare(node.key, iter.startKey) < 0 {
iter.node = nil
return false
}
if iter.limitKey != nil && bytes.Compare(node.key, iter.limitKey) >= 0 {
iter.node = nil
return false
}
return true
} | [
"func",
"(",
"iter",
"*",
"Iterator",
")",
"limitIterator",
"(",
")",
"bool",
"{",
"if",
"iter",
".",
"node",
"==",
"nil",
"{",
"return",
"false",
"\n",
"}",
"\n\n",
"node",
":=",
"iter",
".",
"node",
"\n",
"if",
"iter",
".",
"startKey",
"!=",
"nil... | // limitIterator clears the current iterator node if it is outside of the range
// specified when the iterator was created. It returns whether the iterator is
// valid. | [
"limitIterator",
"clears",
"the",
"current",
"iterator",
"node",
"if",
"it",
"is",
"outside",
"of",
"the",
"range",
"specified",
"when",
"the",
"iterator",
"was",
"created",
".",
"It",
"returns",
"whether",
"the",
"iterator",
"is",
"valid",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/database/internal/treap/treapiter.go#L25-L42 |
163,675 | btcsuite/btcd | btcjson/chainsvrresults.go | MarshalJSON | func (v *Vin) MarshalJSON() ([]byte, error) {
if v.IsCoinBase() {
coinbaseStruct := struct {
Coinbase string `json:"coinbase"`
Sequence uint32 `json:"sequence"`
Witness []string `json:"witness,omitempty"`
}{
Coinbase: v.Coinbase,
Sequence: v.Sequence,
Witness: v.Witness,
}
return json.Marshal(coinbaseStruct)
}
if v.HasWitness() {
txStruct := struct {
Txid string `json:"txid"`
Vout uint32 `json:"vout"`
ScriptSig *ScriptSig `json:"scriptSig"`
Witness []string `json:"txinwitness"`
Sequence uint32 `json:"sequence"`
}{
Txid: v.Txid,
Vout: v.Vout,
ScriptSig: v.ScriptSig,
Witness: v.Witness,
Sequence: v.Sequence,
}
return json.Marshal(txStruct)
}
txStruct := struct {
Txid string `json:"txid"`
Vout uint32 `json:"vout"`
ScriptSig *ScriptSig `json:"scriptSig"`
Sequence uint32 `json:"sequence"`
}{
Txid: v.Txid,
Vout: v.Vout,
ScriptSig: v.ScriptSig,
Sequence: v.Sequence,
}
return json.Marshal(txStruct)
} | go | func (v *Vin) MarshalJSON() ([]byte, error) {
if v.IsCoinBase() {
coinbaseStruct := struct {
Coinbase string `json:"coinbase"`
Sequence uint32 `json:"sequence"`
Witness []string `json:"witness,omitempty"`
}{
Coinbase: v.Coinbase,
Sequence: v.Sequence,
Witness: v.Witness,
}
return json.Marshal(coinbaseStruct)
}
if v.HasWitness() {
txStruct := struct {
Txid string `json:"txid"`
Vout uint32 `json:"vout"`
ScriptSig *ScriptSig `json:"scriptSig"`
Witness []string `json:"txinwitness"`
Sequence uint32 `json:"sequence"`
}{
Txid: v.Txid,
Vout: v.Vout,
ScriptSig: v.ScriptSig,
Witness: v.Witness,
Sequence: v.Sequence,
}
return json.Marshal(txStruct)
}
txStruct := struct {
Txid string `json:"txid"`
Vout uint32 `json:"vout"`
ScriptSig *ScriptSig `json:"scriptSig"`
Sequence uint32 `json:"sequence"`
}{
Txid: v.Txid,
Vout: v.Vout,
ScriptSig: v.ScriptSig,
Sequence: v.Sequence,
}
return json.Marshal(txStruct)
} | [
"func",
"(",
"v",
"*",
"Vin",
")",
"MarshalJSON",
"(",
")",
"(",
"[",
"]",
"byte",
",",
"error",
")",
"{",
"if",
"v",
".",
"IsCoinBase",
"(",
")",
"{",
"coinbaseStruct",
":=",
"struct",
"{",
"Coinbase",
"string",
"`json:\"coinbase\"`",
"\n",
"Sequence"... | // MarshalJSON provides a custom Marshal method for Vin. | [
"MarshalJSON",
"provides",
"a",
"custom",
"Marshal",
"method",
"for",
"Vin",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcjson/chainsvrresults.go#L334-L377 |
163,676 | btcsuite/btcd | wire/msgheaders.go | AddBlockHeader | func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error {
if len(msg.Headers)+1 > MaxBlockHeadersPerMsg {
str := fmt.Sprintf("too many block headers in message [max %v]",
MaxBlockHeadersPerMsg)
return messageError("MsgHeaders.AddBlockHeader", str)
}
msg.Headers = append(msg.Headers, bh)
return nil
} | go | func (msg *MsgHeaders) AddBlockHeader(bh *BlockHeader) error {
if len(msg.Headers)+1 > MaxBlockHeadersPerMsg {
str := fmt.Sprintf("too many block headers in message [max %v]",
MaxBlockHeadersPerMsg)
return messageError("MsgHeaders.AddBlockHeader", str)
}
msg.Headers = append(msg.Headers, bh)
return nil
} | [
"func",
"(",
"msg",
"*",
"MsgHeaders",
")",
"AddBlockHeader",
"(",
"bh",
"*",
"BlockHeader",
")",
"error",
"{",
"if",
"len",
"(",
"msg",
".",
"Headers",
")",
"+",
"1",
">",
"MaxBlockHeadersPerMsg",
"{",
"str",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
... | // AddBlockHeader adds a new block header to the message. | [
"AddBlockHeader",
"adds",
"a",
"new",
"block",
"header",
"to",
"the",
"message",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/msgheaders.go#L26-L35 |
163,677 | btcsuite/btcd | btcd.go | removeRegressionDB | func removeRegressionDB(dbPath string) error {
// Don't do anything if not in regression test mode.
if !cfg.RegressionTest {
return nil
}
// Remove the old regression test database if it already exists.
fi, err := os.Stat(dbPath)
if err == nil {
btcdLog.Infof("Removing regression test database from '%s'", dbPath)
if fi.IsDir() {
err := os.RemoveAll(dbPath)
if err != nil {
return err
}
} else {
err := os.Remove(dbPath)
if err != nil {
return err
}
}
}
return nil
} | go | func removeRegressionDB(dbPath string) error {
// Don't do anything if not in regression test mode.
if !cfg.RegressionTest {
return nil
}
// Remove the old regression test database if it already exists.
fi, err := os.Stat(dbPath)
if err == nil {
btcdLog.Infof("Removing regression test database from '%s'", dbPath)
if fi.IsDir() {
err := os.RemoveAll(dbPath)
if err != nil {
return err
}
} else {
err := os.Remove(dbPath)
if err != nil {
return err
}
}
}
return nil
} | [
"func",
"removeRegressionDB",
"(",
"dbPath",
"string",
")",
"error",
"{",
"// Don't do anything if not in regression test mode.",
"if",
"!",
"cfg",
".",
"RegressionTest",
"{",
"return",
"nil",
"\n",
"}",
"\n\n",
"// Remove the old regression test database if it already exists... | // removeRegressionDB removes the existing regression test database if running
// in regression test mode and it already exists. | [
"removeRegressionDB",
"removes",
"the",
"existing",
"regression",
"test",
"database",
"if",
"running",
"in",
"regression",
"test",
"mode",
"and",
"it",
"already",
"exists",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcd.go#L176-L200 |
163,678 | btcsuite/btcd | btcd.go | blockDbPath | func blockDbPath(dbType string) string {
// The database name is based on the database type.
dbName := blockDbNamePrefix + "_" + dbType
if dbType == "sqlite" {
dbName = dbName + ".db"
}
dbPath := filepath.Join(cfg.DataDir, dbName)
return dbPath
} | go | func blockDbPath(dbType string) string {
// The database name is based on the database type.
dbName := blockDbNamePrefix + "_" + dbType
if dbType == "sqlite" {
dbName = dbName + ".db"
}
dbPath := filepath.Join(cfg.DataDir, dbName)
return dbPath
} | [
"func",
"blockDbPath",
"(",
"dbType",
"string",
")",
"string",
"{",
"// The database name is based on the database type.",
"dbName",
":=",
"blockDbNamePrefix",
"+",
"\"",
"\"",
"+",
"dbType",
"\n",
"if",
"dbType",
"==",
"\"",
"\"",
"{",
"dbName",
"=",
"dbName",
... | // dbPath returns the path to the block database given a database type. | [
"dbPath",
"returns",
"the",
"path",
"to",
"the",
"block",
"database",
"given",
"a",
"database",
"type",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcd.go#L203-L211 |
163,679 | btcsuite/btcd | btcd.go | warnMultipleDBs | func warnMultipleDBs() {
// This is intentionally not using the known db types which depend
// on the database types compiled into the binary since we want to
// detect legacy db types as well.
dbTypes := []string{"ffldb", "leveldb", "sqlite"}
duplicateDbPaths := make([]string, 0, len(dbTypes)-1)
for _, dbType := range dbTypes {
if dbType == cfg.DbType {
continue
}
// Store db path as a duplicate db if it exists.
dbPath := blockDbPath(dbType)
if fileExists(dbPath) {
duplicateDbPaths = append(duplicateDbPaths, dbPath)
}
}
// Warn if there are extra databases.
if len(duplicateDbPaths) > 0 {
selectedDbPath := blockDbPath(cfg.DbType)
btcdLog.Warnf("WARNING: There are multiple block chain databases "+
"using different database types.\nYou probably don't "+
"want to waste disk space by having more than one.\n"+
"Your current database is located at [%v].\nThe "+
"additional database is located at %v", selectedDbPath,
duplicateDbPaths)
}
} | go | func warnMultipleDBs() {
// This is intentionally not using the known db types which depend
// on the database types compiled into the binary since we want to
// detect legacy db types as well.
dbTypes := []string{"ffldb", "leveldb", "sqlite"}
duplicateDbPaths := make([]string, 0, len(dbTypes)-1)
for _, dbType := range dbTypes {
if dbType == cfg.DbType {
continue
}
// Store db path as a duplicate db if it exists.
dbPath := blockDbPath(dbType)
if fileExists(dbPath) {
duplicateDbPaths = append(duplicateDbPaths, dbPath)
}
}
// Warn if there are extra databases.
if len(duplicateDbPaths) > 0 {
selectedDbPath := blockDbPath(cfg.DbType)
btcdLog.Warnf("WARNING: There are multiple block chain databases "+
"using different database types.\nYou probably don't "+
"want to waste disk space by having more than one.\n"+
"Your current database is located at [%v].\nThe "+
"additional database is located at %v", selectedDbPath,
duplicateDbPaths)
}
} | [
"func",
"warnMultipleDBs",
"(",
")",
"{",
"// This is intentionally not using the known db types which depend",
"// on the database types compiled into the binary since we want to",
"// detect legacy db types as well.",
"dbTypes",
":=",
"[",
"]",
"string",
"{",
"\"",
"\"",
",",
"\"... | // warnMultipleDBs shows a warning if multiple block database types are detected.
// This is not a situation most users want. It is handy for development however
// to support multiple side-by-side databases. | [
"warnMultipleDBs",
"shows",
"a",
"warning",
"if",
"multiple",
"block",
"database",
"types",
"are",
"detected",
".",
"This",
"is",
"not",
"a",
"situation",
"most",
"users",
"want",
".",
"It",
"is",
"handy",
"for",
"development",
"however",
"to",
"support",
"m... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcd.go#L216-L244 |
163,680 | btcsuite/btcd | wire/msgversion.go | HasService | func (msg *MsgVersion) HasService(service ServiceFlag) bool {
return msg.Services&service == service
} | go | func (msg *MsgVersion) HasService(service ServiceFlag) bool {
return msg.Services&service == service
} | [
"func",
"(",
"msg",
"*",
"MsgVersion",
")",
"HasService",
"(",
"service",
"ServiceFlag",
")",
"bool",
"{",
"return",
"msg",
".",
"Services",
"&",
"service",
"==",
"service",
"\n",
"}"
] | // HasService returns whether the specified service is supported by the peer
// that generated the message. | [
"HasService",
"returns",
"whether",
"the",
"specified",
"service",
"is",
"supported",
"by",
"the",
"peer",
"that",
"generated",
"the",
"message",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/msgversion.go#L62-L64 |
163,681 | btcsuite/btcd | wire/msgversion.go | NewMsgVersion | func NewMsgVersion(me *NetAddress, you *NetAddress, nonce uint64,
lastBlock int32) *MsgVersion {
// Limit the timestamp to one second precision since the protocol
// doesn't support better.
return &MsgVersion{
ProtocolVersion: int32(ProtocolVersion),
Services: 0,
Timestamp: time.Unix(time.Now().Unix(), 0),
AddrYou: *you,
AddrMe: *me,
Nonce: nonce,
UserAgent: DefaultUserAgent,
LastBlock: lastBlock,
DisableRelayTx: false,
}
} | go | func NewMsgVersion(me *NetAddress, you *NetAddress, nonce uint64,
lastBlock int32) *MsgVersion {
// Limit the timestamp to one second precision since the protocol
// doesn't support better.
return &MsgVersion{
ProtocolVersion: int32(ProtocolVersion),
Services: 0,
Timestamp: time.Unix(time.Now().Unix(), 0),
AddrYou: *you,
AddrMe: *me,
Nonce: nonce,
UserAgent: DefaultUserAgent,
LastBlock: lastBlock,
DisableRelayTx: false,
}
} | [
"func",
"NewMsgVersion",
"(",
"me",
"*",
"NetAddress",
",",
"you",
"*",
"NetAddress",
",",
"nonce",
"uint64",
",",
"lastBlock",
"int32",
")",
"*",
"MsgVersion",
"{",
"// Limit the timestamp to one second precision since the protocol",
"// doesn't support better.",
"return... | // NewMsgVersion returns a new bitcoin version message that conforms to the
// Message interface using the passed parameters and defaults for the remaining
// fields. | [
"NewMsgVersion",
"returns",
"a",
"new",
"bitcoin",
"version",
"message",
"that",
"conforms",
"to",
"the",
"Message",
"interface",
"using",
"the",
"passed",
"parameters",
"and",
"defaults",
"for",
"the",
"remaining",
"fields",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/msgversion.go#L223-L239 |
163,682 | btcsuite/btcd | wire/msgversion.go | validateUserAgent | func validateUserAgent(userAgent string) error {
if len(userAgent) > MaxUserAgentLen {
str := fmt.Sprintf("user agent too long [len %v, max %v]",
len(userAgent), MaxUserAgentLen)
return messageError("MsgVersion", str)
}
return nil
} | go | func validateUserAgent(userAgent string) error {
if len(userAgent) > MaxUserAgentLen {
str := fmt.Sprintf("user agent too long [len %v, max %v]",
len(userAgent), MaxUserAgentLen)
return messageError("MsgVersion", str)
}
return nil
} | [
"func",
"validateUserAgent",
"(",
"userAgent",
"string",
")",
"error",
"{",
"if",
"len",
"(",
"userAgent",
")",
">",
"MaxUserAgentLen",
"{",
"str",
":=",
"fmt",
".",
"Sprintf",
"(",
"\"",
"\"",
",",
"len",
"(",
"userAgent",
")",
",",
"MaxUserAgentLen",
"... | // validateUserAgent checks userAgent length against MaxUserAgentLen | [
"validateUserAgent",
"checks",
"userAgent",
"length",
"against",
"MaxUserAgentLen"
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/wire/msgversion.go#L242-L249 |
163,683 | btcsuite/btcd | upgrade.go | dirEmpty | func dirEmpty(dirPath string) (bool, error) {
f, err := os.Open(dirPath)
if err != nil {
return false, err
}
defer f.Close()
// Read the names of a max of one entry from the directory. When the
// directory is empty, an io.EOF error will be returned, so allow it.
names, err := f.Readdirnames(1)
if err != nil && err != io.EOF {
return false, err
}
return len(names) == 0, nil
} | go | func dirEmpty(dirPath string) (bool, error) {
f, err := os.Open(dirPath)
if err != nil {
return false, err
}
defer f.Close()
// Read the names of a max of one entry from the directory. When the
// directory is empty, an io.EOF error will be returned, so allow it.
names, err := f.Readdirnames(1)
if err != nil && err != io.EOF {
return false, err
}
return len(names) == 0, nil
} | [
"func",
"dirEmpty",
"(",
"dirPath",
"string",
")",
"(",
"bool",
",",
"error",
")",
"{",
"f",
",",
"err",
":=",
"os",
".",
"Open",
"(",
"dirPath",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n",
"defer",
... | // dirEmpty returns whether or not the specified directory path is empty. | [
"dirEmpty",
"returns",
"whether",
"or",
"not",
"the",
"specified",
"directory",
"path",
"is",
"empty",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/upgrade.go#L14-L29 |
163,684 | btcsuite/btcd | upgrade.go | oldBtcdHomeDir | func oldBtcdHomeDir() string {
// Search for Windows APPDATA first. This won't exist on POSIX OSes.
appData := os.Getenv("APPDATA")
if appData != "" {
return filepath.Join(appData, "btcd")
}
// Fall back to standard HOME directory that works for most POSIX OSes.
home := os.Getenv("HOME")
if home != "" {
return filepath.Join(home, ".btcd")
}
// In the worst case, use the current directory.
return "."
} | go | func oldBtcdHomeDir() string {
// Search for Windows APPDATA first. This won't exist on POSIX OSes.
appData := os.Getenv("APPDATA")
if appData != "" {
return filepath.Join(appData, "btcd")
}
// Fall back to standard HOME directory that works for most POSIX OSes.
home := os.Getenv("HOME")
if home != "" {
return filepath.Join(home, ".btcd")
}
// In the worst case, use the current directory.
return "."
} | [
"func",
"oldBtcdHomeDir",
"(",
")",
"string",
"{",
"// Search for Windows APPDATA first. This won't exist on POSIX OSes.",
"appData",
":=",
"os",
".",
"Getenv",
"(",
"\"",
"\"",
")",
"\n",
"if",
"appData",
"!=",
"\"",
"\"",
"{",
"return",
"filepath",
".",
"Join",... | // oldBtcdHomeDir returns the OS specific home directory btcd used prior to
// version 0.3.3. This has since been replaced with btcutil.AppDataDir, but
// this function is still provided for the automatic upgrade path. | [
"oldBtcdHomeDir",
"returns",
"the",
"OS",
"specific",
"home",
"directory",
"btcd",
"used",
"prior",
"to",
"version",
"0",
".",
"3",
".",
"3",
".",
"This",
"has",
"since",
"been",
"replaced",
"with",
"btcutil",
".",
"AppDataDir",
"but",
"this",
"function",
... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/upgrade.go#L34-L49 |
163,685 | btcsuite/btcd | upgrade.go | upgradeDBPathNet | func upgradeDBPathNet(oldDbPath, netName string) error {
// Prior to version 0.2.0, the database was named the same thing for
// both sqlite and leveldb. Use heuristics to figure out the type
// of the database and move it to the new path and name introduced with
// version 0.2.0 accordingly.
fi, err := os.Stat(oldDbPath)
if err == nil {
oldDbType := "sqlite"
if fi.IsDir() {
oldDbType = "leveldb"
}
// The new database name is based on the database type and
// resides in a directory named after the network type.
newDbRoot := filepath.Join(filepath.Dir(cfg.DataDir), netName)
newDbName := blockDbNamePrefix + "_" + oldDbType
if oldDbType == "sqlite" {
newDbName = newDbName + ".db"
}
newDbPath := filepath.Join(newDbRoot, newDbName)
// Create the new path if needed.
err = os.MkdirAll(newDbRoot, 0700)
if err != nil {
return err
}
// Move and rename the old database.
err := os.Rename(oldDbPath, newDbPath)
if err != nil {
return err
}
}
return nil
} | go | func upgradeDBPathNet(oldDbPath, netName string) error {
// Prior to version 0.2.0, the database was named the same thing for
// both sqlite and leveldb. Use heuristics to figure out the type
// of the database and move it to the new path and name introduced with
// version 0.2.0 accordingly.
fi, err := os.Stat(oldDbPath)
if err == nil {
oldDbType := "sqlite"
if fi.IsDir() {
oldDbType = "leveldb"
}
// The new database name is based on the database type and
// resides in a directory named after the network type.
newDbRoot := filepath.Join(filepath.Dir(cfg.DataDir), netName)
newDbName := blockDbNamePrefix + "_" + oldDbType
if oldDbType == "sqlite" {
newDbName = newDbName + ".db"
}
newDbPath := filepath.Join(newDbRoot, newDbName)
// Create the new path if needed.
err = os.MkdirAll(newDbRoot, 0700)
if err != nil {
return err
}
// Move and rename the old database.
err := os.Rename(oldDbPath, newDbPath)
if err != nil {
return err
}
}
return nil
} | [
"func",
"upgradeDBPathNet",
"(",
"oldDbPath",
",",
"netName",
"string",
")",
"error",
"{",
"// Prior to version 0.2.0, the database was named the same thing for",
"// both sqlite and leveldb. Use heuristics to figure out the type",
"// of the database and move it to the new path and name in... | // upgradeDBPathNet moves the database for a specific network from its
// location prior to btcd version 0.2.0 and uses heuristics to ascertain the old
// database type to rename to the new format. | [
"upgradeDBPathNet",
"moves",
"the",
"database",
"for",
"a",
"specific",
"network",
"from",
"its",
"location",
"prior",
"to",
"btcd",
"version",
"0",
".",
"2",
".",
"0",
"and",
"uses",
"heuristics",
"to",
"ascertain",
"the",
"old",
"database",
"type",
"to",
... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/upgrade.go#L54-L89 |
163,686 | btcsuite/btcd | upgrade.go | upgradeDBPaths | func upgradeDBPaths() error {
// Prior to version 0.2.0, the databases were in the "db" directory and
// their names were suffixed by "testnet" and "regtest" for their
// respective networks. Check for the old database and update it to the
// new path introduced with version 0.2.0 accordingly.
oldDbRoot := filepath.Join(oldBtcdHomeDir(), "db")
upgradeDBPathNet(filepath.Join(oldDbRoot, "btcd.db"), "mainnet")
upgradeDBPathNet(filepath.Join(oldDbRoot, "btcd_testnet.db"), "testnet")
upgradeDBPathNet(filepath.Join(oldDbRoot, "btcd_regtest.db"), "regtest")
// Remove the old db directory.
return os.RemoveAll(oldDbRoot)
} | go | func upgradeDBPaths() error {
// Prior to version 0.2.0, the databases were in the "db" directory and
// their names were suffixed by "testnet" and "regtest" for their
// respective networks. Check for the old database and update it to the
// new path introduced with version 0.2.0 accordingly.
oldDbRoot := filepath.Join(oldBtcdHomeDir(), "db")
upgradeDBPathNet(filepath.Join(oldDbRoot, "btcd.db"), "mainnet")
upgradeDBPathNet(filepath.Join(oldDbRoot, "btcd_testnet.db"), "testnet")
upgradeDBPathNet(filepath.Join(oldDbRoot, "btcd_regtest.db"), "regtest")
// Remove the old db directory.
return os.RemoveAll(oldDbRoot)
} | [
"func",
"upgradeDBPaths",
"(",
")",
"error",
"{",
"// Prior to version 0.2.0, the databases were in the \"db\" directory and",
"// their names were suffixed by \"testnet\" and \"regtest\" for their",
"// respective networks. Check for the old database and update it to the",
"// new path introduce... | // upgradeDBPaths moves the databases from their locations prior to btcd
// version 0.2.0 to their new locations. | [
"upgradeDBPaths",
"moves",
"the",
"databases",
"from",
"their",
"locations",
"prior",
"to",
"btcd",
"version",
"0",
".",
"2",
".",
"0",
"to",
"their",
"new",
"locations",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/upgrade.go#L93-L105 |
163,687 | btcsuite/btcd | upgrade.go | upgradeDataPaths | func upgradeDataPaths() error {
// No need to migrate if the old and new home paths are the same.
oldHomePath := oldBtcdHomeDir()
newHomePath := defaultHomeDir
if oldHomePath == newHomePath {
return nil
}
// Only migrate if the old path exists and the new one doesn't.
if fileExists(oldHomePath) && !fileExists(newHomePath) {
// Create the new path.
btcdLog.Infof("Migrating application home path from '%s' to '%s'",
oldHomePath, newHomePath)
err := os.MkdirAll(newHomePath, 0700)
if err != nil {
return err
}
// Move old btcd.conf into new location if needed.
oldConfPath := filepath.Join(oldHomePath, defaultConfigFilename)
newConfPath := filepath.Join(newHomePath, defaultConfigFilename)
if fileExists(oldConfPath) && !fileExists(newConfPath) {
err := os.Rename(oldConfPath, newConfPath)
if err != nil {
return err
}
}
// Move old data directory into new location if needed.
oldDataPath := filepath.Join(oldHomePath, defaultDataDirname)
newDataPath := filepath.Join(newHomePath, defaultDataDirname)
if fileExists(oldDataPath) && !fileExists(newDataPath) {
err := os.Rename(oldDataPath, newDataPath)
if err != nil {
return err
}
}
// Remove the old home if it is empty or show a warning if not.
ohpEmpty, err := dirEmpty(oldHomePath)
if err != nil {
return err
}
if ohpEmpty {
err := os.Remove(oldHomePath)
if err != nil {
return err
}
} else {
btcdLog.Warnf("Not removing '%s' since it contains files "+
"not created by this application. You may "+
"want to manually move them or delete them.",
oldHomePath)
}
}
return nil
} | go | func upgradeDataPaths() error {
// No need to migrate if the old and new home paths are the same.
oldHomePath := oldBtcdHomeDir()
newHomePath := defaultHomeDir
if oldHomePath == newHomePath {
return nil
}
// Only migrate if the old path exists and the new one doesn't.
if fileExists(oldHomePath) && !fileExists(newHomePath) {
// Create the new path.
btcdLog.Infof("Migrating application home path from '%s' to '%s'",
oldHomePath, newHomePath)
err := os.MkdirAll(newHomePath, 0700)
if err != nil {
return err
}
// Move old btcd.conf into new location if needed.
oldConfPath := filepath.Join(oldHomePath, defaultConfigFilename)
newConfPath := filepath.Join(newHomePath, defaultConfigFilename)
if fileExists(oldConfPath) && !fileExists(newConfPath) {
err := os.Rename(oldConfPath, newConfPath)
if err != nil {
return err
}
}
// Move old data directory into new location if needed.
oldDataPath := filepath.Join(oldHomePath, defaultDataDirname)
newDataPath := filepath.Join(newHomePath, defaultDataDirname)
if fileExists(oldDataPath) && !fileExists(newDataPath) {
err := os.Rename(oldDataPath, newDataPath)
if err != nil {
return err
}
}
// Remove the old home if it is empty or show a warning if not.
ohpEmpty, err := dirEmpty(oldHomePath)
if err != nil {
return err
}
if ohpEmpty {
err := os.Remove(oldHomePath)
if err != nil {
return err
}
} else {
btcdLog.Warnf("Not removing '%s' since it contains files "+
"not created by this application. You may "+
"want to manually move them or delete them.",
oldHomePath)
}
}
return nil
} | [
"func",
"upgradeDataPaths",
"(",
")",
"error",
"{",
"// No need to migrate if the old and new home paths are the same.",
"oldHomePath",
":=",
"oldBtcdHomeDir",
"(",
")",
"\n",
"newHomePath",
":=",
"defaultHomeDir",
"\n",
"if",
"oldHomePath",
"==",
"newHomePath",
"{",
"ret... | // upgradeDataPaths moves the application data from its location prior to btcd
// version 0.3.3 to its new location. | [
"upgradeDataPaths",
"moves",
"the",
"application",
"data",
"from",
"its",
"location",
"prior",
"to",
"btcd",
"version",
"0",
".",
"3",
".",
"3",
"to",
"its",
"new",
"location",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/upgrade.go#L109-L166 |
163,688 | btcsuite/btcd | btcjson/register.go | String | func (fl UsageFlag) String() string {
// No flags are set.
if fl == 0 {
return "0x0"
}
// Add individual bit flags.
s := ""
for flag := UFWalletOnly; flag < highestUsageFlagBit; flag <<= 1 {
if fl&flag == flag {
s += usageFlagStrings[flag] + "|"
fl -= flag
}
}
// Add remaining value as raw hex.
s = strings.TrimRight(s, "|")
if fl != 0 {
s += "|0x" + strconv.FormatUint(uint64(fl), 16)
}
s = strings.TrimLeft(s, "|")
return s
} | go | func (fl UsageFlag) String() string {
// No flags are set.
if fl == 0 {
return "0x0"
}
// Add individual bit flags.
s := ""
for flag := UFWalletOnly; flag < highestUsageFlagBit; flag <<= 1 {
if fl&flag == flag {
s += usageFlagStrings[flag] + "|"
fl -= flag
}
}
// Add remaining value as raw hex.
s = strings.TrimRight(s, "|")
if fl != 0 {
s += "|0x" + strconv.FormatUint(uint64(fl), 16)
}
s = strings.TrimLeft(s, "|")
return s
} | [
"func",
"(",
"fl",
"UsageFlag",
")",
"String",
"(",
")",
"string",
"{",
"// No flags are set.",
"if",
"fl",
"==",
"0",
"{",
"return",
"\"",
"\"",
"\n",
"}",
"\n\n",
"// Add individual bit flags.",
"s",
":=",
"\"",
"\"",
"\n",
"for",
"flag",
":=",
"UFWall... | // String returns the UsageFlag in human-readable form. | [
"String",
"returns",
"the",
"UsageFlag",
"in",
"human",
"-",
"readable",
"form",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcjson/register.go#L50-L72 |
163,689 | btcsuite/btcd | btcjson/register.go | baseKindString | func baseKindString(rt reflect.Type) string {
numIndirects := 0
for rt.Kind() == reflect.Ptr {
numIndirects++
rt = rt.Elem()
}
return fmt.Sprintf("%s%s", strings.Repeat("*", numIndirects), rt.Kind())
} | go | func baseKindString(rt reflect.Type) string {
numIndirects := 0
for rt.Kind() == reflect.Ptr {
numIndirects++
rt = rt.Elem()
}
return fmt.Sprintf("%s%s", strings.Repeat("*", numIndirects), rt.Kind())
} | [
"func",
"baseKindString",
"(",
"rt",
"reflect",
".",
"Type",
")",
"string",
"{",
"numIndirects",
":=",
"0",
"\n",
"for",
"rt",
".",
"Kind",
"(",
")",
"==",
"reflect",
".",
"Ptr",
"{",
"numIndirects",
"++",
"\n",
"rt",
"=",
"rt",
".",
"Elem",
"(",
"... | // baseKindString returns the base kind for a given reflect.Type after
// indirecting through all pointers. | [
"baseKindString",
"returns",
"the",
"base",
"kind",
"for",
"a",
"given",
"reflect",
".",
"Type",
"after",
"indirecting",
"through",
"all",
"pointers",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcjson/register.go#L95-L103 |
163,690 | btcsuite/btcd | btcjson/register.go | isAcceptableKind | func isAcceptableKind(kind reflect.Kind) bool {
switch kind {
case reflect.Chan:
fallthrough
case reflect.Complex64:
fallthrough
case reflect.Complex128:
fallthrough
case reflect.Func:
fallthrough
case reflect.Ptr:
fallthrough
case reflect.Interface:
return false
}
return true
} | go | func isAcceptableKind(kind reflect.Kind) bool {
switch kind {
case reflect.Chan:
fallthrough
case reflect.Complex64:
fallthrough
case reflect.Complex128:
fallthrough
case reflect.Func:
fallthrough
case reflect.Ptr:
fallthrough
case reflect.Interface:
return false
}
return true
} | [
"func",
"isAcceptableKind",
"(",
"kind",
"reflect",
".",
"Kind",
")",
"bool",
"{",
"switch",
"kind",
"{",
"case",
"reflect",
".",
"Chan",
":",
"fallthrough",
"\n",
"case",
"reflect",
".",
"Complex64",
":",
"fallthrough",
"\n",
"case",
"reflect",
".",
"Comp... | // isAcceptableKind returns whether or not the passed field type is a supported
// type. It is called after the first pointer indirection, so further pointers
// are not supported. | [
"isAcceptableKind",
"returns",
"whether",
"or",
"not",
"the",
"passed",
"field",
"type",
"is",
"a",
"supported",
"type",
".",
"It",
"is",
"called",
"after",
"the",
"first",
"pointer",
"indirection",
"so",
"further",
"pointers",
"are",
"not",
"supported",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcjson/register.go#L108-L125 |
163,691 | btcsuite/btcd | btcjson/register.go | MustRegisterCmd | func MustRegisterCmd(method string, cmd interface{}, flags UsageFlag) {
if err := RegisterCmd(method, cmd, flags); err != nil {
panic(fmt.Sprintf("failed to register type %q: %v\n", method,
err))
}
} | go | func MustRegisterCmd(method string, cmd interface{}, flags UsageFlag) {
if err := RegisterCmd(method, cmd, flags); err != nil {
panic(fmt.Sprintf("failed to register type %q: %v\n", method,
err))
}
} | [
"func",
"MustRegisterCmd",
"(",
"method",
"string",
",",
"cmd",
"interface",
"{",
"}",
",",
"flags",
"UsageFlag",
")",
"{",
"if",
"err",
":=",
"RegisterCmd",
"(",
"method",
",",
"cmd",
",",
"flags",
")",
";",
"err",
"!=",
"nil",
"{",
"panic",
"(",
"f... | // MustRegisterCmd performs the same function as RegisterCmd except it panics
// if there is an error. This should only be called from package init
// functions. | [
"MustRegisterCmd",
"performs",
"the",
"same",
"function",
"as",
"RegisterCmd",
"except",
"it",
"panics",
"if",
"there",
"is",
"an",
"error",
".",
"This",
"should",
"only",
"be",
"called",
"from",
"package",
"init",
"functions",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcjson/register.go#L272-L277 |
163,692 | btcsuite/btcd | btcjson/register.go | RegisteredCmdMethods | func RegisteredCmdMethods() []string {
registerLock.Lock()
defer registerLock.Unlock()
methods := make([]string, 0, len(methodToInfo))
for k := range methodToInfo {
methods = append(methods, k)
}
sort.Sort(sort.StringSlice(methods))
return methods
} | go | func RegisteredCmdMethods() []string {
registerLock.Lock()
defer registerLock.Unlock()
methods := make([]string, 0, len(methodToInfo))
for k := range methodToInfo {
methods = append(methods, k)
}
sort.Sort(sort.StringSlice(methods))
return methods
} | [
"func",
"RegisteredCmdMethods",
"(",
")",
"[",
"]",
"string",
"{",
"registerLock",
".",
"Lock",
"(",
")",
"\n",
"defer",
"registerLock",
".",
"Unlock",
"(",
")",
"\n\n",
"methods",
":=",
"make",
"(",
"[",
"]",
"string",
",",
"0",
",",
"len",
"(",
"me... | // RegisteredCmdMethods returns a sorted list of methods for all registered
// commands. | [
"RegisteredCmdMethods",
"returns",
"a",
"sorted",
"list",
"of",
"methods",
"for",
"all",
"registered",
"commands",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/btcjson/register.go#L281-L292 |
163,693 | btcsuite/btcd | rpcclient/mining.go | Receive | func (r FutureGenerateResult) Receive() ([]*chainhash.Hash, error) {
res, err := receiveFuture(r)
if err != nil {
return nil, err
}
// Unmarshal result as a list of strings.
var result []string
err = json.Unmarshal(res, &result)
if err != nil {
return nil, err
}
// Convert each block hash to a chainhash.Hash and store a pointer to
// each.
convertedResult := make([]*chainhash.Hash, len(result))
for i, hashString := range result {
convertedResult[i], err = chainhash.NewHashFromStr(hashString)
if err != nil {
return nil, err
}
}
return convertedResult, nil
} | go | func (r FutureGenerateResult) Receive() ([]*chainhash.Hash, error) {
res, err := receiveFuture(r)
if err != nil {
return nil, err
}
// Unmarshal result as a list of strings.
var result []string
err = json.Unmarshal(res, &result)
if err != nil {
return nil, err
}
// Convert each block hash to a chainhash.Hash and store a pointer to
// each.
convertedResult := make([]*chainhash.Hash, len(result))
for i, hashString := range result {
convertedResult[i], err = chainhash.NewHashFromStr(hashString)
if err != nil {
return nil, err
}
}
return convertedResult, nil
} | [
"func",
"(",
"r",
"FutureGenerateResult",
")",
"Receive",
"(",
")",
"(",
"[",
"]",
"*",
"chainhash",
".",
"Hash",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"receiveFuture",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"nil",... | // Receive waits for the response promised by the future and returns a list of
// block hashes generated by the call. | [
"Receive",
"waits",
"for",
"the",
"response",
"promised",
"by",
"the",
"future",
"and",
"returns",
"a",
"list",
"of",
"block",
"hashes",
"generated",
"by",
"the",
"call",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcclient/mining.go#L23-L47 |
163,694 | btcsuite/btcd | rpcclient/mining.go | GenerateAsync | func (c *Client) GenerateAsync(numBlocks uint32) FutureGenerateResult {
cmd := btcjson.NewGenerateCmd(numBlocks)
return c.sendCmd(cmd)
} | go | func (c *Client) GenerateAsync(numBlocks uint32) FutureGenerateResult {
cmd := btcjson.NewGenerateCmd(numBlocks)
return c.sendCmd(cmd)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GenerateAsync",
"(",
"numBlocks",
"uint32",
")",
"FutureGenerateResult",
"{",
"cmd",
":=",
"btcjson",
".",
"NewGenerateCmd",
"(",
"numBlocks",
")",
"\n",
"return",
"c",
".",
"sendCmd",
"(",
"cmd",
")",
"\n",
"}"
] | // GenerateAsync returns an instance of a type that can be used to get
// the result of the RPC at some future time by invoking the Receive function on
// the returned instance.
//
// See Generate for the blocking version and more details. | [
"GenerateAsync",
"returns",
"an",
"instance",
"of",
"a",
"type",
"that",
"can",
"be",
"used",
"to",
"get",
"the",
"result",
"of",
"the",
"RPC",
"at",
"some",
"future",
"time",
"by",
"invoking",
"the",
"Receive",
"function",
"on",
"the",
"returned",
"instan... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcclient/mining.go#L54-L57 |
163,695 | btcsuite/btcd | rpcclient/mining.go | Generate | func (c *Client) Generate(numBlocks uint32) ([]*chainhash.Hash, error) {
return c.GenerateAsync(numBlocks).Receive()
} | go | func (c *Client) Generate(numBlocks uint32) ([]*chainhash.Hash, error) {
return c.GenerateAsync(numBlocks).Receive()
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"Generate",
"(",
"numBlocks",
"uint32",
")",
"(",
"[",
"]",
"*",
"chainhash",
".",
"Hash",
",",
"error",
")",
"{",
"return",
"c",
".",
"GenerateAsync",
"(",
"numBlocks",
")",
".",
"Receive",
"(",
")",
"\n",
"}"... | // Generate generates numBlocks blocks and returns their hashes. | [
"Generate",
"generates",
"numBlocks",
"blocks",
"and",
"returns",
"their",
"hashes",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcclient/mining.go#L60-L62 |
163,696 | btcsuite/btcd | rpcclient/mining.go | Receive | func (r FutureGetGenerateResult) Receive() (bool, error) {
res, err := receiveFuture(r)
if err != nil {
return false, err
}
// Unmarshal result as a boolean.
var result bool
err = json.Unmarshal(res, &result)
if err != nil {
return false, err
}
return result, nil
} | go | func (r FutureGetGenerateResult) Receive() (bool, error) {
res, err := receiveFuture(r)
if err != nil {
return false, err
}
// Unmarshal result as a boolean.
var result bool
err = json.Unmarshal(res, &result)
if err != nil {
return false, err
}
return result, nil
} | [
"func",
"(",
"r",
"FutureGetGenerateResult",
")",
"Receive",
"(",
")",
"(",
"bool",
",",
"error",
")",
"{",
"res",
",",
"err",
":=",
"receiveFuture",
"(",
"r",
")",
"\n",
"if",
"err",
"!=",
"nil",
"{",
"return",
"false",
",",
"err",
"\n",
"}",
"\n\... | // Receive waits for the response promised by the future and returns true if the
// server is set to mine, otherwise false. | [
"Receive",
"waits",
"for",
"the",
"response",
"promised",
"by",
"the",
"future",
"and",
"returns",
"true",
"if",
"the",
"server",
"is",
"set",
"to",
"mine",
"otherwise",
"false",
"."
] | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcclient/mining.go#L70-L84 |
163,697 | btcsuite/btcd | rpcclient/mining.go | GetGenerateAsync | func (c *Client) GetGenerateAsync() FutureGetGenerateResult {
cmd := btcjson.NewGetGenerateCmd()
return c.sendCmd(cmd)
} | go | func (c *Client) GetGenerateAsync() FutureGetGenerateResult {
cmd := btcjson.NewGetGenerateCmd()
return c.sendCmd(cmd)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetGenerateAsync",
"(",
")",
"FutureGetGenerateResult",
"{",
"cmd",
":=",
"btcjson",
".",
"NewGetGenerateCmd",
"(",
")",
"\n",
"return",
"c",
".",
"sendCmd",
"(",
"cmd",
")",
"\n",
"}"
] | // GetGenerateAsync returns an instance of a type that can be used to get
// the result of the RPC at some future time by invoking the Receive function on
// the returned instance.
//
// See GetGenerate for the blocking version and more details. | [
"GetGenerateAsync",
"returns",
"an",
"instance",
"of",
"a",
"type",
"that",
"can",
"be",
"used",
"to",
"get",
"the",
"result",
"of",
"the",
"RPC",
"at",
"some",
"future",
"time",
"by",
"invoking",
"the",
"Receive",
"function",
"on",
"the",
"returned",
"ins... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcclient/mining.go#L91-L94 |
163,698 | btcsuite/btcd | rpcclient/mining.go | SetGenerateAsync | func (c *Client) SetGenerateAsync(enable bool, numCPUs int) FutureSetGenerateResult {
cmd := btcjson.NewSetGenerateCmd(enable, &numCPUs)
return c.sendCmd(cmd)
} | go | func (c *Client) SetGenerateAsync(enable bool, numCPUs int) FutureSetGenerateResult {
cmd := btcjson.NewSetGenerateCmd(enable, &numCPUs)
return c.sendCmd(cmd)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"SetGenerateAsync",
"(",
"enable",
"bool",
",",
"numCPUs",
"int",
")",
"FutureSetGenerateResult",
"{",
"cmd",
":=",
"btcjson",
".",
"NewSetGenerateCmd",
"(",
"enable",
",",
"&",
"numCPUs",
")",
"\n",
"return",
"c",
"."... | // SetGenerateAsync returns an instance of a type that can be used to get the
// result of the RPC at some future time by invoking the Receive function on the
// returned instance.
//
// See SetGenerate for the blocking version and more details. | [
"SetGenerateAsync",
"returns",
"an",
"instance",
"of",
"a",
"type",
"that",
"can",
"be",
"used",
"to",
"get",
"the",
"result",
"of",
"the",
"RPC",
"at",
"some",
"future",
"time",
"by",
"invoking",
"the",
"Receive",
"function",
"on",
"the",
"returned",
"ins... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcclient/mining.go#L117-L120 |
163,699 | btcsuite/btcd | rpcclient/mining.go | GetHashesPerSecAsync | func (c *Client) GetHashesPerSecAsync() FutureGetHashesPerSecResult {
cmd := btcjson.NewGetHashesPerSecCmd()
return c.sendCmd(cmd)
} | go | func (c *Client) GetHashesPerSecAsync() FutureGetHashesPerSecResult {
cmd := btcjson.NewGetHashesPerSecCmd()
return c.sendCmd(cmd)
} | [
"func",
"(",
"c",
"*",
"Client",
")",
"GetHashesPerSecAsync",
"(",
")",
"FutureGetHashesPerSecResult",
"{",
"cmd",
":=",
"btcjson",
".",
"NewGetHashesPerSecCmd",
"(",
")",
"\n",
"return",
"c",
".",
"sendCmd",
"(",
"cmd",
")",
"\n",
"}"
] | // GetHashesPerSecAsync returns an instance of a type that can be used to get
// the result of the RPC at some future time by invoking the Receive function on
// the returned instance.
//
// See GetHashesPerSec for the blocking version and more details. | [
"GetHashesPerSecAsync",
"returns",
"an",
"instance",
"of",
"a",
"type",
"that",
"can",
"be",
"used",
"to",
"get",
"the",
"result",
"of",
"the",
"RPC",
"at",
"some",
"future",
"time",
"by",
"invoking",
"the",
"Receive",
"function",
"on",
"the",
"returned",
... | 96897255fd17525dd12426345d279533780bc4e1 | https://github.com/btcsuite/btcd/blob/96897255fd17525dd12426345d279533780bc4e1/rpcclient/mining.go#L155-L158 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.