fixed build errs

netmux got replaced for the most part by swarm.

bitswap/bitswap.go

 package bitswap
 
 import (
-	"github.com/jbenet/go-ipfs/blocks"
-	mh "github.com/jbenet/go-multihash"
-
-	"time"
+  "time"
+  mh "github.com/jbenet/go-multihash"
+  blocks "github.com/jbenet/go-ipfs/blocks"
+  u "github.com/jbenet/go-ipfs/util"
 )
 
 // aliases
 
 type Ledger struct {
 	Owner mh.Multihash
-
 	Partner mh.Multihash
-
 	BytesSent uint64
-
 	BytesRecv uint64
-
 	Timestamp *time.Time
 }
 
 type BitSwap struct {
-	Ledgers  map[string]*Ledger
-	HaveList map[string]*blocks.Block
-	WantList []*multihash.Multihash
+  Ledgers map[u.Key]*Ledger  // key is peer.ID
+  HaveList map[u.Key]*blocks.Block // key is multihash
+  WantList []*mh.Multihash
 }

netmux/interface.go

-package netmux
-
-import (
-	"net"
-)
-
-// An interface is the module connecting netmux
-// to various networks (tcp, udp, webrtc, etc).
-// It keeps the relevant connections open.
-type Interface struct {
-
-	// Interface network (e.g. udp4, tcp6)
-	Network string
-
-	// Own network address
-	Address         string
-	ResolvedAddress *net.UDPAddr
-
-	// Connection
-	conn net.Conn
-
-	// next packets + close control channels
-	Input  chan *Packet
-	Output chan *Packet
-	Closed chan bool
-	Errors chan error
-}
-
-func NewUDPInterface(network, addr string) (*Interface, error) {
-	raddr, err := net.ResolveUDPAddr(network, addr)
-	if err != nil {
-		return nil, err
-	}
-
-	conn, err := net.ListenUDP(network, raddr)
-	if err != nil {
-		return nil, err
-	}
-
-	i := &Interface{
-		Network:         network,
-		Address:         addr,
-		ResolvedAddress: raddr,
-		conn:            conn,
-	}
-
-	go i.processUDPInput()
-	go i.processOutput()
-	return i, nil
-}
-
-func (i *Interface) processOutput() {
-	for {
-		select {
-		case <-i.Closed:
-			break
-
-		case buffer := <-i.Output:
-			i.conn.Write([]byte(buffer.Data))
-		}
-	}
-}
-
-func (i *Interface) processUDPInput() {
-	for {
-		select {
-		case <-i.Closed:
-			break
-
-		}
-	}
-}
-
-func (i *Interface) Read(buffer []byte) bool {
-	_, err := i.conn.Read(buffer)
-	if err != nil {
-		i.Errors <- err
-		i.Close()
-		return false
-	}
-	return true
-}
-
-func (i *Interface) Close() {
-	// closing net connection
-	err := i.conn.Close()
-	if err != nil {
-		i.Errors <- err
-	}
-
-	// closing channels
-	close(i.Input)
-	close(i.Output)
-	close(i.Closed)
-	close(i.Errors)
-}

netmux/netmux.go

-package netmux
-
-// The netmux module provides a "network multiplexer".
-// The core idea is to have the client be able to connect to
-// many different networks (potentially over different transports)
-// and multiplex everything over one interface.
-
-type Netmux struct {
-	// the list of NetMux interfaces
-	Interfaces []*Interface
-
-	// The channels to send/recv from
-	Incoming <-chan *Packet
-	Outgoing chan<- *Packet
-
-	// internally managed other side of channels
-	incomingSrc chan<- *Packet
-	outgoingSrc <-chan *Packet
-}
-
-// Warning: will probably change to adopt multiaddr format
-type Packet struct {
-	// the network addresses to send to
-	// e.g. tcp4://127.0.0.1:12345
-	NetAddrTo string
-
-	// the network addresses to recv from
-	// e.g. tcp4://127.0.0.1:12345
-	// may be left blank to select one automatically.
-	NetAddrFrom string
-
-	// the data to send.
-	Data []byte
-}
-
-func NewNetmux() *Netmux {
-	n := &Netmux{}
-
-	// setup channels
-	och := make(chan *Packet)
-	ich := make(chan *Packet)
-	n.Incoming, n.incomingSrc = ich, ich
-	n.Outgoing, n.outgoingSrc = och, och
-
-	return n
-}