1 files changed, 123 insertions, 18 deletions

diff --git a/src/gnunet/util/address.go b/src/gnunet/util/address.go
index d272742..106e671 100644
--- a/src/gnunet/util/address.go
+++ b/src/gnunet/util/address.go
@@ -19,44 +19,81 @@
 package util
 
 import (
-        "encoding/hex"
+        "bytes"
         "fmt"
         "net"
+        "strings"
 )
 
 // Address specifies how a peer is reachable on the network.
 type Address struct {
-        Transport string // transport protocol
-        Options   uint32 `order:"big"` // address options
-        Address   []byte `size:"*"`    // address data (protocol-dependent)
+        Netw    string       ``            // network protocol
+        Options uint32       `order:"big"` // address options
+        Expires AbsoluteTime ``            // expiration date for address
+        Address []byte       `size:"*"`    // address data (protocol-dependent)
 }
 
 // NewAddress returns a new Address for the given transport and specs
 func NewAddress(transport string, addr []byte) *Address {
-        a := &Address{
-                Transport: transport,
-                Options:   0,
-                Address:   make([]byte, len(addr)),
+        return &Address{
+                Netw:    transport,
+                Options: 0,
+                Address: Clone(addr),
+                Expires: AbsoluteTimeNever(),
         }
-        copy(a.Address, addr)
-        return a
 }
 
+func NewAddressWrap(addr net.Addr) *Address {
+        return &Address{
+                Netw:    addr.Network(),
+                Options: 0,
+                Address: []byte(addr.String()),
+                Expires: AbsoluteTimeNever(),
+        }
+}
+
+// ParseAddress translates a GNUnet address string like
+// "r5n+ip+udp://1.2.3.4:6789" or "gnunet+tcp://12.3.4.5/".
+// It can also handle standard strings like "udp:127.0.0.1:6735".
+func ParseAddress(s string) (addr *Address, err error) {
+        p := strings.SplitN(s, ":", 2)
+        if len(p) != 2 {
+                err = fmt.Errorf("invalid address format: '%s'", s)
+                return
+        }
+        addr = NewAddress(p[0], []byte(strings.Trim(p[1], "/")))
+        return
+}
+
+// Equals return true if two addresses match.
+func (a *Address) Equals(b *Address) bool {
+        return a.Netw == b.Netw &&
+                a.Options == b.Options &&
+                bytes.Equal(a.Address, b.Address)
+}
+
+// StringAll returns a human-readable representation of an address.
+func (a *Address) StringAll() string {
+        return a.Netw + "://" + string(a.Address)
+}
+
+// implement net.Addr interface methods:
+
 // String returns a human-readable representation of an address.
 func (a *Address) String() string {
-        return fmt.Sprintf("Address{%s}", AddressString(a.Transport, a.Address))
+        return string(a.Address)
+}
+
+// Network returns the protocol specifier.
+func (a *Address) Network() string {
+        return a.Netw
 }
 
 //----------------------------------------------------------------------
 
 // AddressString returns a string representaion of an address.
-func AddressString(transport string, addr []byte) string {
-        if transport == "tcp" || transport == "udp" {
-                alen := len(addr)
-                port := uint(addr[alen-2])*256 + uint(addr[alen-1])
-                return fmt.Sprintf("%s:%s:%d", transport, net.IP(addr[:alen-2]).String(), port)
-        }
-        return fmt.Sprintf("%s:%s", transport, hex.EncodeToString(addr))
+func AddressString(network string, addr []byte) string {
+        return network + "://" + string(addr)
 }
 
 //----------------------------------------------------------------------
@@ -76,3 +113,71 @@ func NewIPAddress(host []byte, port uint16) *IPAddress {
         copy(ip.Host, host)
         return ip
 }
+
+//----------------------------------------------------------------------
+
+// PeerAddrList is a list of addresses per peer ID.
+type PeerAddrList struct {
+        list *Map[string, []*Address]
+}
+
+// NewPeerAddrList returns a new and empty address list.
+func NewPeerAddrList() *PeerAddrList {
+        return &PeerAddrList{
+                list: NewMap[string, []*Address](),
+        }
+}
+
+// Add address for peer. The returned mode is 0=not added, 1=new peer,
+// 2=new address
+func (a *PeerAddrList) Add(id string, addr *Address) (mode int) {
+        // check for expired address.
+        mode = 0
+        if !addr.Expires.Expired() {
+                // run add operation
+                a.list.Process(func() error {
+                        list, ok := a.list.Get(id)
+                        if !ok {
+                                list = make([]*Address, 0)
+                                mode = 1
+                        } else {
+                                for _, a := range list {
+                                        if a.Equals(addr) {
+                                                return nil
+                                        }
+                                }
+                                mode = 2
+                        }
+                        list = append(list, addr)
+                        a.list.Put(id, list)
+                        return nil
+                })
+        }
+        return
+}
+
+// Get address for peer
+func (a *PeerAddrList) Get(id string, transport string) *Address {
+        list, ok := a.list.Get(id)
+        if ok {
+                for _, addr := range list {
+                        // check for expired address.
+                        if addr.Expires.Expired() {
+                                // skip expired
+                                continue
+                        }
+                        // check for matching protocol
+                        if len(transport) > 0 && transport != addr.Netw {
+                                // skip other transports
+                                continue
+                        }
+                        return addr
+                }
+        }
+        return nil
+}
+
+// Delete a list entry by key.
+func (a *PeerAddrList) Delete(id string) {
+        a.list.Delete(id)
+}