// ResolveN implements Resolver. func (ns *mpns) ResolveN(ctx context.Context, name string, depth int) (path.Path, error) { if strings.HasPrefix(name, "/ipfs/") { return path.ParsePath(name) } if !strings.HasPrefix(name, "/") { return path.ParsePath("/ipfs/" + name) } return resolve(ctx, ns, name, depth, "/ipns/") }
func main() { cmd := cli.App("ipget", "Retrieve and save IPFS objects.") cmd.Spec = "IPFS_PATH [-o]" hash := cmd.String(cli.StringArg{ Name: "IPFS_PATH", Value: "", Desc: "the IPFS object path", }) outFile := cmd.StringOpt("o output", "", "output file path") cmd.Action = func() { if *outFile == "" { ipfsPath, err := path.ParsePath(*hash) if err != nil { fmt.Fprintf(os.Stderr, "ParsePath failure: %s", err) os.Exit(1) } segments := ipfsPath.Segments() *outFile = segments[len(segments)-1] } if err := get(*hash, *outFile); err != nil { fmt.Fprintf(os.Stderr, "ipget failed: %s", err) os.Remove(*outFile) os.Exit(1) } } cmd.Run(os.Args) }
func tryParseDnsLink(txt string) (path.Path, error) { parts := strings.SplitN(txt, "=", 2) if len(parts) == 2 && parts[0] == "dnslink" { return path.ParsePath(parts[1]) } return "", errors.New("not a valid dnslink entry") }
// 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 := key.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", key.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(key.Key(valh)), nil } }
ShortDescription: ` 'ipfs tar cat' will export a tar file from a previously imported one in ipfs `, }, Arguments: []cmds.Argument{ cmds.StringArg("path", true, false, "ipfs path of archive to export").EnableStdin(), }, Run: func(req cmds.Request, res cmds.Response) { nd, err := req.InvocContext().GetNode() if err != nil { res.SetError(err, cmds.ErrNormal) return } p, err := path.ParsePath(req.Arguments()[0]) if err != nil { res.SetError(err, cmds.ErrNormal) return } root, err := core.Resolve(req.Context(), nd, p) if err != nil { res.SetError(err, cmds.ErrNormal) return } r, err := tar.ExportTar(req.Context(), root, nd.DAG) if err != nil { res.SetError(err, cmds.ErrNormal) return