// 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
