// InvertKey returns a b58 decoded Datastore key
// TODO: this is hacky because it encodes every path component. some
// path components may be proper strings already...
func (b58KeyConverter) InvertKey(dsk ds.Key) ds.Key {
k := ds.NewKey("/")
for _, n := range dsk.Namespaces() {
k = k.ChildString(string(b58.Decode(n)))
}
return k
}
// IsValidHash checks whether a given hash is valid (b58 decodable, len > 0)
func IsValidHash(s string) bool {
out := b58.Decode(s)
if out == nil || len(out) == 0 {
return false
}
return true
}
func FromB58String(s string) (m Multihash, err error) {
// panic handler, in case we try accessing bytes incorrectly.
defer func() {
if e := recover(); e != nil {
m = Multihash{}
err = e.(error)
}
}()
//b58 smells like it can panic...
b := b58.Decode(s)
return Cast(b)
}
// UnmarshalJSON returns a JSON-encoded Key (string)
func (k *Key) UnmarshalJSON(mk []byte) error {
var s string
err := json.Unmarshal(mk, &s)
if err != nil {
return err
}
*k = Key(string(b58.Decode(s)))
if len(*k) == 0 && len(s) > 2 { // if b58.Decode fails, k == ""
return fmt.Errorf("Key.UnmarshalJSON: invalid b58 string: %v", mk)
}
return nil
}
// Resolve implements Resolver
// TXT records for a given domain name should contain a b58
// encoded multihash.
func (r *DNSResolver) Resolve(name string) (string, error) {
log.Info("DNSResolver resolving %v", name)
txt, err := net.LookupTXT(name)
if err != nil {
return "", err
}
for _, t := range txt {
chk := b58.Decode(t)
if len(chk) == 0 {
continue
}
_, err := mh.Cast(chk)
if err != nil {
continue
}
return t, nil
}
return "", ErrResolveFailed
}
func initIdentity(cfg *config.Identity, peers peer.Peerstore, online bool) (peer.Peer, error) {
if cfg.PeerID == "" {
return nil, debugerror.New("Identity was not set in config (was ipfs init run?)")
}
if len(cfg.PeerID) == 0 {
return nil, debugerror.New("No peer ID in config! (was ipfs init run?)")
}
// get peer from peerstore (so it is constructed there)
id := peer.ID(b58.Decode(cfg.PeerID))
self, err := peers.Get(id)
if err != nil {
return nil, err
}
self.SetType(peer.Local)
self, err = peers.Add(self)
if err != nil {
return nil, err
}
self.SetVersions(handshake.ClientVersion, handshake.IpfsVersion.String())
// when not online, don't need to parse private keys (yet)
if online {
skb, err := base64.StdEncoding.DecodeString(cfg.PrivKey)
if err != nil {
return nil, err
}
if err := self.LoadAndVerifyKeyPair(skb); err != nil {
return nil, err
}
}
return self, nil
}
// DecodePrettyID returns a b58-encoded string of the ID
func DecodePrettyID(s string) ID {
return b58.Decode(s)
}
Arguments: []cmds.Argument{
cmds.StringArg("peerid", false, false, "peer.ID of node to look up"),
},
Run: func(req cmds.Request) (interface{}, error) {
node, err := req.Context().GetNode()
if err != nil {
return nil, err
}
if len(req.Arguments()) == 0 {
return printPeer(node.Identity)
}
pid := req.Arguments()[0]
id := peer.ID(b58.Decode(pid))
if len(id) == 0 {
return nil, cmds.ClientError("Invalid peer id")
}
ctx, _ := context.WithTimeout(context.TODO(), time.Second*5)
if node.Routing == nil {
return nil, errors.New(offlineIdErrorMessage)
}
p, err := node.Routing.FindPeer(ctx, id)
if err == kb.ErrLookupFailure {
return nil, errors.New(offlineIdErrorMessage)
}
if err != nil {
return nil, err
// B58KeyDecode returns Key from a b58 encoded string
func B58KeyDecode(s string) Key {
return Key(string(b58.Decode(s)))
}
