Exemple #1
0
func FindPeer(n *core.IpfsNode, cmdparts []string) (string, error) {
	out := new(bytes.Buffer)
	if len(cmdparts) < 3 {
		return fmt.Sprintln("findpeer: '# findpeer peerid'"), ErrArgCount
	}

	var search peer.ID
	if cmdparts[2][0] == '$' {
		n, err := strconv.Atoi(cmdparts[2][1:])
		if err != nil {
			return "", err
		}
		if n >= len(controllers) {
			return "", errors.New("specified peernum out of range")
		}
		search = controllers[n].PeerID()
	} else {
		search = peer.ID(b58.Decode(cmdparts[2]))
	}
	fmt.Fprintf(out, "Searching for peer: %s\n", search)

	ctx, _ := context.WithDeadline(context.TODO(), time.Now().Add(time.Second*5))
	p, err := n.Routing.FindPeer(ctx, search)
	if err != nil {
		return "", err
	}

	fmt.Fprintf(out, "%Got peer: %s\n", p)
	return out.String(), nil
}
Exemple #2
0
// 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
}
Exemple #3
0
func parseOpts() (options, error) {
	o := options{}

	flag.StringVar(&o.keyS, "k", "", "key to use (in base58)")
	flag.BoolVar(&o.encrypt, "e", false, "encrypt mode")
	flag.BoolVar(&o.decrypt, "d", false, "decrypt mode")
	flag.BoolVar(&o.keygen, "key-gen", false, "generate a key")

	flag.Usage = usage
	flag.Parse()

	if !onlyOne(o.keygen, o.encrypt, o.decrypt) {
		return o, fmt.Errorf("must choose either -e or -d or --key-gen")
	}

	if !o.keygen {
		o.keyS = strings.TrimSpace(o.keyS)
		o.key = b58.Decode(o.keyS)
		if o.keyS == "" || o.key == nil {
			return o, fmt.Errorf("must provide a key in base58 with -k")
		}

		if len(o.key) < senc.KeyLength {
			return o, fmt.Errorf("key too short. must be 256 bits, decoded.")
		} else if len(o.key) > senc.KeyLength {
			return o, fmt.Errorf("key too short. must be 256 bits, decoded.")
		}
	}

	return o, nil
}
Exemple #4
0
func streamCipherReaderForKey(key string, r io.ReadCloser) (io.ReadCloser, error) {

	keyData := base58.Decode(key)
	if len(keyData) == 0 {
		return nil, ErrInvalidKey
	}

	return streamCipherReaderForKeyData(keyData[0], keyData[1:], r)
}
Exemple #5
0
// 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
	}
	_, err := mh.Cast(out)
	if err != nil {
		return false
	}
	return true
}
Exemple #6
0
// 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
}
Exemple #7
0
func Decode(encoding, digest string) (mh.Multihash, error) {
	switch encoding {
	case "raw":
		return mh.Cast([]byte(digest))
	case "hex":
		return hex.DecodeString(digest)
	case "base58":
		return base58.Decode(digest), nil
	case "base64":
		return base64.StdEncoding.DecodeString(digest)
	default:
		return nil, fmt.Errorf("unknown encoding: %s", encoding)
	}
}
Exemple #8
0
func readEntry(scanner *bufio.Scanner) (ent Entry, ent_hash string) {
	line := scanner.Text()
	if len(line) > 0 && line == "-" {
		// New style entries
		var key, val string
		for {
			if !scanner.Scan() {
				break
			}
			line = scanner.Text()
			if line == "" {
				break
			}
			if line[0] == '\t' {
				val += "\n" + line[1:]
			} else {
				if key != "" {
					readEntryAttr(&ent, key, val)
					key = ""
				}
				s := strings.SplitN(line, "=", 2)
				if len(s) == 2 {
					key = s[0]
					val = s[1]
				}
			}
		}
		if key != "" {
			readEntryAttr(&ent, key, val)
		}
	} else {
		elems := strings.SplitN(line, "\t", 2)
		f := DecodePath(elems[1])
		ent = Entry{
			Path: f,
			Hash: []byte(elems[0]),
		}
	}
	if ent.Path != "" {
		ent_hash = string(ent.Hash)
		ent.Hash = base58.Decode(ent_hash)
	}
	return
}
Exemple #9
0
func readEntryAttr(ent *Entry, key, val string) {
	switch key {
	case "p":
		ent.Path = val
		break
	case "h":
		ent.Hash = base58.Decode(val)
		break
	case "u":
		ent.Uuid = val
		break
	case "I":
		ent.Device = StringDevice(val)
		ent.Inode = StringInode(val)
		break
	default:
		break
	}
}
Exemple #10
0
// B58KeyDecode returns Key from a b58 encoded string
func B58KeyDecode(s string) Key {
	return Key(string(b58.Decode(s)))
}