mirror of
https://github.com/ipfs/kubo.git
synced 2025-09-10 09:52:20 +08:00
3ead2443e5
This allows direct access to the earlier protocol-specific Resolve implementations. The guts of each protocol-specific resolver are in the internal resolveOnce method, and we've added a new: ResolveN(ctx, name, depth) method to the public interface. There's also: Resolve(ctx, name) which wraps ResolveN using DefaultDepthLimit. The extra API endpoint is intended to reduce the likelyhood of clients accidentally calling the more dangerous ResolveN with a nonsensically high or infinite depth. On IRC on 2015-05-17, Juan said: 15:34 <jbenet> If 90% of uses is the reduced API with no chance to screw it up, that's a huge win. 15:34 <wking> Why would those 90% not just set depth=0 or depth=1, depending on which they need? 15:34 <jbenet> Because people will start writing `r.Resolve(ctx, name, d)` where d is a variable. 15:35 <wking> And then accidentally set that variable to some huge number? 15:35 <jbenet> Grom experience, i've seen this happen _dozens_ of times. people screw trivial things up. 15:35 <wking> Why won't those same people be using ResolveN? 15:36 <jbenet> Because almost every example they see will tell them to use Resolve(), and they will mostly stay away from ResolveN. The per-prodocol versions also resolve recursively within their protocol. For example: DNSResolver.Resolve(ctx, "ipfs.io", 0) will recursively resolve DNS links until the referenced value is no longer a DNS link. I also renamed the multi-protocol ipfs NameSystem (defined in namesys/namesys.go) to 'mpns' (for Multi-Protocol Name System), because I wasn't clear on whether IPNS applied to the whole system or just to to the DHT-based system. The new name is unambiguously multi-protocol, which is good. It would be nice to have a distinct name for the DHT-based link system. Now that resolver output is always prefixed with a namespace and unprefixed mpns resolver input is interpreted as /ipfs/, core/corehttp/ipns_hostname.go can dispense with it's old manual /ipfs/ injection. Now that the Resolver interface handles recursion, we don't need the resolveRecurse helper in core/pathresolver.go. The pathresolver cleanup also called for an adjustment to FromSegments to more easily get slash-prefixed paths. Now that recursive resolution with the namesys/namesys.go composite resolver always gets you to an /ipfs/... path, there's no need for the /ipns/ special case in fuse/ipns/ipns_unix.go. Now that DNS links can be things other than /ipfs/ or DHT-link references (e.g. they could be /ipns/<domain-name> references) I've also loosened the ParsePath logic to only attempt multihash validation on IPFS paths. It checks to ensure that other paths have a known-protocol prefix, but otherwise leaves them alone. I also changed some key-stringification from .Pretty() to .String() following the potential deprecation mentioned in util/key.go.
107 lines
3.1 KiB
Go
107 lines
3.1 KiB
Go
package namesys
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
proto "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/gogo/protobuf/proto"
|
|
mh "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multihash"
|
|
"github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
|
|
|
|
pb "github.com/ipfs/go-ipfs/namesys/internal/pb"
|
|
path "github.com/ipfs/go-ipfs/path"
|
|
routing "github.com/ipfs/go-ipfs/routing"
|
|
u "github.com/ipfs/go-ipfs/util"
|
|
)
|
|
|
|
var log = u.Logger("namesys")
|
|
|
|
// routingResolver implements NSResolver for the main IPFS SFS-like naming
|
|
type routingResolver struct {
|
|
routing routing.IpfsRouting
|
|
}
|
|
|
|
// NewRoutingResolver constructs a name resolver using the IPFS Routing system
|
|
// to implement SFS-like naming on top.
|
|
func NewRoutingResolver(route routing.IpfsRouting) Resolver {
|
|
if route == nil {
|
|
panic("attempt to create resolver with nil routing system")
|
|
}
|
|
|
|
return &routingResolver{routing: route}
|
|
}
|
|
|
|
// newRoutingResolver returns a resolver instead of a Resolver.
|
|
func newRoutingResolver(route routing.IpfsRouting) resolver {
|
|
if route == nil {
|
|
panic("attempt to create resolver with nil routing system")
|
|
}
|
|
|
|
return &routingResolver{routing: route}
|
|
}
|
|
|
|
// Resolve implements Resolver.
|
|
func (r *routingResolver) Resolve(ctx context.Context, name string) (path.Path, error) {
|
|
return r.ResolveN(ctx, name, DefaultDepthLimit)
|
|
}
|
|
|
|
// ResolveN implements Resolver.
|
|
func (r *routingResolver) ResolveN(ctx context.Context, name string, depth int) (path.Path, error) {
|
|
return resolve(ctx, r, name, depth, "/ipns/")
|
|
}
|
|
|
|
// resolveOnce implements resolver. Uses the IPFS routing system to
|
|
// resolve SFS-like names.
|
|
func (r *routingResolver) resolveOnce(ctx context.Context, name string) (path.Path, error) {
|
|
log.Debugf("RoutingResolve: '%s'", name)
|
|
hash, err := mh.FromB58String(name)
|
|
if err != nil {
|
|
log.Warning("RoutingResolve: bad input hash: [%s]\n", name)
|
|
return "", err
|
|
}
|
|
// name should be a multihash. if it isn't, error out here.
|
|
|
|
// use the routing system to get the name.
|
|
// /ipns/<name>
|
|
h := []byte("/ipns/" + string(hash))
|
|
|
|
ipnsKey := u.Key(h)
|
|
val, err := r.routing.GetValue(ctx, ipnsKey)
|
|
if err != nil {
|
|
log.Warning("RoutingResolve get failed.")
|
|
return "", err
|
|
}
|
|
|
|
entry := new(pb.IpnsEntry)
|
|
err = proto.Unmarshal(val, entry)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
// name should be a public key retrievable from ipfs
|
|
pubkey, err := routing.GetPublicKey(r.routing, ctx, hash)
|
|
if err != nil {
|
|
return "", err
|
|
}
|
|
|
|
hsh, _ := pubkey.Hash()
|
|
log.Debugf("pk hash = %s", u.Key(hsh))
|
|
|
|
// check sig with pk
|
|
if ok, err := pubkey.Verify(ipnsEntryDataForSig(entry), entry.GetSignature()); err != nil || !ok {
|
|
return "", fmt.Errorf("Invalid value. Not signed by PrivateKey corresponding to %v", pubkey)
|
|
}
|
|
|
|
// ok sig checks out. this is a valid name.
|
|
|
|
// check for old style record:
|
|
valh, err := mh.Cast(entry.GetValue())
|
|
if err != nil {
|
|
// Not a multihash, probably a new record
|
|
return path.ParsePath(string(entry.GetValue()))
|
|
} else {
|
|
// Its an old style multihash record
|
|
log.Warning("Detected old style multihash record")
|
|
return path.FromKey(u.Key(valh)), nil
|
|
}
|
|
}
|