179 lines
3.3 KiB
Go
179 lines
3.3 KiB
Go
package multiaddr
|
||
|
||
import (
|
||
"bytes"
|
||
"fmt"
|
||
"strings"
|
||
|
||
"github.com/multiformats/go-varint"
|
||
)
|
||
|
||
func stringToBytes(s string) ([]byte, error) {
|
||
// consume trailing slashes
|
||
s = strings.TrimRight(s, "/")
|
||
|
||
var b bytes.Buffer
|
||
sp := strings.Split(s, "/")
|
||
|
||
if sp[0] != "" {
|
||
return nil, fmt.Errorf("failed to parse multiaddr %q: must begin with /", s)
|
||
}
|
||
|
||
// consume first empty elem
|
||
sp = sp[1:]
|
||
|
||
if len(sp) == 0 {
|
||
return nil, fmt.Errorf("failed to parse multiaddr %q: empty multiaddr", s)
|
||
}
|
||
|
||
for len(sp) > 0 {
|
||
name := sp[0]
|
||
p := ProtocolWithName(name)
|
||
if p.Code == 0 {
|
||
return nil, fmt.Errorf("failed to parse multiaddr %q: unknown protocol %s", s, sp[0])
|
||
}
|
||
_, _ = b.Write(p.VCode)
|
||
sp = sp[1:]
|
||
|
||
if p.Size == 0 { // no length.
|
||
continue
|
||
}
|
||
|
||
if len(sp) < 1 {
|
||
return nil, fmt.Errorf("failed to parse multiaddr %q: unexpected end of multiaddr", s)
|
||
}
|
||
|
||
if p.Path {
|
||
// it's a path protocol (terminal).
|
||
// consume the rest of the address as the next component.
|
||
sp = []string{"/" + strings.Join(sp, "/")}
|
||
}
|
||
|
||
a, err := p.Transcoder.StringToBytes(sp[0])
|
||
if err != nil {
|
||
return nil, fmt.Errorf("failed to parse multiaddr %q: invalid value %q for protocol %s: %s", s, sp[0], p.Name, err)
|
||
}
|
||
if p.Size < 0 { // varint size.
|
||
_, _ = b.Write(varint.ToUvarint(uint64(len(a))))
|
||
}
|
||
b.Write(a)
|
||
sp = sp[1:]
|
||
}
|
||
|
||
return b.Bytes(), nil
|
||
}
|
||
|
||
func validateBytes(b []byte) (err error) {
|
||
if len(b) == 0 {
|
||
return fmt.Errorf("empty multiaddr")
|
||
}
|
||
for len(b) > 0 {
|
||
code, n, err := ReadVarintCode(b)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
b = b[n:]
|
||
p := ProtocolWithCode(code)
|
||
if p.Code == 0 {
|
||
return fmt.Errorf("no protocol with code %d", code)
|
||
}
|
||
|
||
if p.Size == 0 {
|
||
continue
|
||
}
|
||
|
||
n, size, err := sizeForAddr(p, b)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
b = b[n:]
|
||
|
||
if len(b) < size || size < 0 {
|
||
return fmt.Errorf("invalid value for size %d", len(b))
|
||
}
|
||
|
||
err = p.Transcoder.ValidateBytes(b[:size])
|
||
if err != nil {
|
||
return err
|
||
}
|
||
|
||
b = b[size:]
|
||
}
|
||
|
||
return nil
|
||
}
|
||
|
||
func readComponent(b []byte) (int, Component, error) {
|
||
var offset int
|
||
code, n, err := ReadVarintCode(b)
|
||
if err != nil {
|
||
return 0, Component{}, err
|
||
}
|
||
offset += n
|
||
|
||
p := ProtocolWithCode(code)
|
||
if p.Code == 0 {
|
||
return 0, Component{}, fmt.Errorf("no protocol with code %d", code)
|
||
}
|
||
|
||
if p.Size == 0 {
|
||
return offset, Component{
|
||
bytes: b[:offset],
|
||
offset: offset,
|
||
protocol: p,
|
||
}, nil
|
||
}
|
||
|
||
n, size, err := sizeForAddr(p, b[offset:])
|
||
if err != nil {
|
||
return 0, Component{}, err
|
||
}
|
||
|
||
offset += n
|
||
|
||
if len(b[offset:]) < size || size < 0 {
|
||
return 0, Component{}, fmt.Errorf("invalid value for size %d", len(b[offset:]))
|
||
}
|
||
|
||
return offset + size, Component{
|
||
bytes: b[:offset+size],
|
||
protocol: p,
|
||
offset: offset,
|
||
}, nil
|
||
}
|
||
|
||
func bytesToString(b []byte) (ret string, err error) {
|
||
if len(b) == 0 {
|
||
return "", fmt.Errorf("empty multiaddr")
|
||
}
|
||
var buf strings.Builder
|
||
|
||
for len(b) > 0 {
|
||
n, c, err := readComponent(b)
|
||
if err != nil {
|
||
return "", err
|
||
}
|
||
b = b[n:]
|
||
c.writeTo(&buf)
|
||
}
|
||
|
||
return buf.String(), nil
|
||
}
|
||
|
||
func sizeForAddr(p Protocol, b []byte) (skip, size int, err error) {
|
||
switch {
|
||
case p.Size > 0:
|
||
return 0, (p.Size / 8), nil
|
||
case p.Size == 0:
|
||
return 0, 0, nil
|
||
default:
|
||
size, n, err := ReadVarintCode(b)
|
||
if err != nil {
|
||
return 0, 0, err
|
||
}
|
||
return n, size, nil
|
||
}
|
||
}
|