2014-01-23 11:14:01 -08:00
|
|
|
package eth
|
|
|
|
|
|
|
|
import (
|
|
|
|
"container/list"
|
2014-05-12 06:08:21 -07:00
|
|
|
"fmt"
|
2014-02-14 14:56:09 -08:00
|
|
|
"github.com/ethereum/eth-go/ethchain"
|
|
|
|
"github.com/ethereum/eth-go/ethdb"
|
2014-05-05 06:15:14 -07:00
|
|
|
"github.com/ethereum/eth-go/ethrpc"
|
2014-02-14 14:56:09 -08:00
|
|
|
"github.com/ethereum/eth-go/ethutil"
|
|
|
|
"github.com/ethereum/eth-go/ethwire"
|
2014-02-10 11:59:31 -08:00
|
|
|
"io/ioutil"
|
2014-01-23 11:14:01 -08:00
|
|
|
"log"
|
2014-05-12 06:08:21 -07:00
|
|
|
"math/rand"
|
2014-01-23 11:14:01 -08:00
|
|
|
"net"
|
2014-02-10 11:59:31 -08:00
|
|
|
"net/http"
|
2014-02-02 10:22:39 -08:00
|
|
|
"strconv"
|
2014-05-12 06:08:21 -07:00
|
|
|
"strings"
|
2014-02-02 07:15:39 -08:00
|
|
|
"sync"
|
2014-01-23 11:14:01 -08:00
|
|
|
"sync/atomic"
|
|
|
|
"time"
|
|
|
|
)
|
|
|
|
|
|
|
|
func eachPeer(peers *list.List, callback func(*Peer, *list.Element)) {
|
|
|
|
// Loop thru the peers and close them (if we had them)
|
|
|
|
for e := peers.Front(); e != nil; e = e.Next() {
|
|
|
|
if peer, ok := e.Value.(*Peer); ok {
|
|
|
|
callback(peer, e)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
const (
|
|
|
|
processReapingTimeout = 60 // TODO increase
|
|
|
|
)
|
|
|
|
|
|
|
|
type Ethereum struct {
|
|
|
|
// Channel for shutting down the ethereum
|
|
|
|
shutdownChan chan bool
|
2014-02-02 10:22:39 -08:00
|
|
|
quit chan bool
|
2014-01-23 11:14:01 -08:00
|
|
|
// DB interface
|
|
|
|
//db *ethdb.LDBDatabase
|
2014-02-08 12:02:09 -08:00
|
|
|
db ethutil.Database
|
2014-03-05 01:57:32 -08:00
|
|
|
// State manager for processing new blocks and managing the over all states
|
|
|
|
stateManager *ethchain.StateManager
|
2014-01-23 11:14:01 -08:00
|
|
|
// The transaction pool. Transaction can be pushed on this pool
|
|
|
|
// for later including in the blocks
|
2014-03-05 01:42:51 -08:00
|
|
|
txPool *ethchain.TxPool
|
|
|
|
// The canonical chain
|
|
|
|
blockChain *ethchain.BlockChain
|
2014-01-23 11:14:01 -08:00
|
|
|
// Peers (NYI)
|
|
|
|
peers *list.List
|
|
|
|
// Nonce
|
|
|
|
Nonce uint64
|
2014-02-01 12:30:54 -08:00
|
|
|
|
|
|
|
Addr net.Addr
|
2014-02-22 16:57:45 -08:00
|
|
|
Port string
|
2014-02-01 12:30:54 -08:00
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
peerMut sync.Mutex
|
|
|
|
|
|
|
|
// Capabilities for outgoing peers
|
|
|
|
serverCaps Caps
|
2014-02-02 10:22:39 -08:00
|
|
|
|
|
|
|
nat NAT
|
2014-02-08 12:02:09 -08:00
|
|
|
|
|
|
|
// Specifies the desired amount of maximum peers
|
|
|
|
MaxPeers int
|
2014-03-10 03:53:02 -07:00
|
|
|
|
|
|
|
reactor *ethutil.ReactorEngine
|
2014-05-02 04:35:25 -07:00
|
|
|
|
2014-05-05 06:15:14 -07:00
|
|
|
RpcServer *ethrpc.JsonRpcServer
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-02-02 10:44:47 -08:00
|
|
|
func New(caps Caps, usePnp bool) (*Ethereum, error) {
|
2014-02-25 02:21:03 -08:00
|
|
|
db, err := ethdb.NewLDBDatabase("database")
|
2014-02-14 16:34:18 -08:00
|
|
|
//db, err := ethdb.NewMemDatabase()
|
2014-01-23 11:14:01 -08:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2014-02-02 10:44:47 -08:00
|
|
|
var nat NAT
|
|
|
|
if usePnp {
|
|
|
|
nat, err = Discover()
|
|
|
|
if err != nil {
|
2014-02-21 16:53:25 -08:00
|
|
|
ethutil.Config.Log.Debugln("UPnP failed", err)
|
2014-02-02 10:44:47 -08:00
|
|
|
}
|
2014-02-02 10:22:39 -08:00
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
ethutil.Config.Db = db
|
|
|
|
|
|
|
|
nonce, _ := ethutil.RandomUint64()
|
|
|
|
ethereum := &Ethereum{
|
|
|
|
shutdownChan: make(chan bool),
|
2014-02-02 10:22:39 -08:00
|
|
|
quit: make(chan bool),
|
2014-01-23 11:14:01 -08:00
|
|
|
db: db,
|
|
|
|
peers: list.New(),
|
|
|
|
Nonce: nonce,
|
2014-02-02 07:15:39 -08:00
|
|
|
serverCaps: caps,
|
2014-02-02 10:22:39 -08:00
|
|
|
nat: nat,
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
2014-03-10 03:53:02 -07:00
|
|
|
ethereum.reactor = ethutil.NewReactorEngine()
|
|
|
|
|
2014-03-05 01:42:51 -08:00
|
|
|
ethereum.txPool = ethchain.NewTxPool(ethereum)
|
|
|
|
ethereum.blockChain = ethchain.NewBlockChain(ethereum)
|
2014-03-05 01:57:32 -08:00
|
|
|
ethereum.stateManager = ethchain.NewStateManager(ethereum)
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-02-22 16:57:45 -08:00
|
|
|
// Start the tx pool
|
2014-03-05 01:42:51 -08:00
|
|
|
ethereum.txPool.Start()
|
2014-02-22 16:57:45 -08:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
return ethereum, nil
|
|
|
|
}
|
|
|
|
|
2014-03-10 03:53:02 -07:00
|
|
|
func (s *Ethereum) Reactor() *ethutil.ReactorEngine {
|
|
|
|
return s.reactor
|
|
|
|
}
|
|
|
|
|
2014-03-05 01:42:51 -08:00
|
|
|
func (s *Ethereum) BlockChain() *ethchain.BlockChain {
|
|
|
|
return s.blockChain
|
|
|
|
}
|
|
|
|
|
2014-03-05 01:57:32 -08:00
|
|
|
func (s *Ethereum) StateManager() *ethchain.StateManager {
|
|
|
|
return s.stateManager
|
2014-03-05 01:42:51 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) TxPool() *ethchain.TxPool {
|
|
|
|
return s.txPool
|
|
|
|
}
|
|
|
|
|
2014-05-12 04:39:37 -07:00
|
|
|
func (s *Ethereum) ServerCaps() Caps {
|
|
|
|
return s.serverCaps
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
func (s *Ethereum) AddPeer(conn net.Conn) {
|
|
|
|
peer := NewPeer(conn, s, true)
|
|
|
|
|
2014-05-12 07:36:14 -07:00
|
|
|
if peer != nil {
|
|
|
|
if s.peers.Len() < s.MaxPeers {
|
|
|
|
s.peers.PushBack(peer)
|
|
|
|
peer.Start()
|
|
|
|
} else {
|
|
|
|
ethutil.Config.Log.Debugf("[SERV] Max connected peers reached. Not adding incoming peer.")
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) ProcessPeerList(addrs []string) {
|
|
|
|
for _, addr := range addrs {
|
|
|
|
// TODO Probably requires some sanity checks
|
|
|
|
s.ConnectToPeer(addr)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) ConnectToPeer(addr string) error {
|
2014-02-17 16:34:06 -08:00
|
|
|
if s.peers.Len() < s.MaxPeers {
|
|
|
|
var alreadyConnected bool
|
|
|
|
|
2014-05-12 06:08:21 -07:00
|
|
|
ahost, _, _ := net.SplitHostPort(addr)
|
|
|
|
var chost string
|
|
|
|
|
|
|
|
ips, err := net.LookupIP(ahost)
|
|
|
|
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
} else {
|
|
|
|
// If more then one ip is available try stripping away the ipv6 ones
|
|
|
|
if len(ips) > 1 {
|
|
|
|
var ipsv4 []net.IP
|
|
|
|
// For now remove the ipv6 addresses
|
|
|
|
for _, ip := range ips {
|
|
|
|
if strings.Contains(ip.String(), "::") {
|
|
|
|
continue
|
|
|
|
} else {
|
|
|
|
ipsv4 = append(ipsv4, ip)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if len(ipsv4) == 0 {
|
|
|
|
return fmt.Errorf("[SERV] No IPV4 addresses available for hostname")
|
|
|
|
}
|
|
|
|
|
|
|
|
// Pick a random ipv4 address, simulating round-robin DNS.
|
|
|
|
rand.Seed(time.Now().UTC().UnixNano())
|
|
|
|
i := rand.Intn(len(ipsv4))
|
|
|
|
chost = ipsv4[i].String()
|
|
|
|
} else {
|
|
|
|
if len(ips) == 0 {
|
|
|
|
return fmt.Errorf("[SERV] No IPs resolved for the given hostname")
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
chost = ips[0].String()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-02-17 16:34:06 -08:00
|
|
|
eachPeer(s.peers, func(p *Peer, v *list.Element) {
|
|
|
|
if p.conn == nil {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
phost, _, _ := net.SplitHostPort(p.conn.RemoteAddr().String())
|
|
|
|
|
2014-05-12 06:08:21 -07:00
|
|
|
if phost == chost {
|
2014-02-17 16:34:06 -08:00
|
|
|
alreadyConnected = true
|
2014-05-12 06:08:21 -07:00
|
|
|
ethutil.Config.Log.Debugf("[SERV] Peer %s already added.\n", chost)
|
2014-02-17 16:34:06 -08:00
|
|
|
return
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
if alreadyConnected {
|
|
|
|
return nil
|
2014-01-30 16:12:48 -08:00
|
|
|
}
|
|
|
|
|
2014-02-17 16:34:06 -08:00
|
|
|
peer := NewOutboundPeer(addr, s, s.serverCaps)
|
2014-01-30 16:12:48 -08:00
|
|
|
|
2014-02-17 16:34:06 -08:00
|
|
|
s.peers.PushBack(peer)
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-02-17 16:34:06 -08:00
|
|
|
log.Printf("[SERV] Adding peer %d / %d\n", s.peers.Len(), s.MaxPeers)
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) OutboundPeers() []*Peer {
|
|
|
|
// Create a new peer slice with at least the length of the total peers
|
|
|
|
outboundPeers := make([]*Peer, s.peers.Len())
|
|
|
|
length := 0
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
2014-01-31 02:18:10 -08:00
|
|
|
if !p.inbound && p.conn != nil {
|
2014-01-23 11:14:01 -08:00
|
|
|
outboundPeers[length] = p
|
|
|
|
length++
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
return outboundPeers[:length]
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) InboundPeers() []*Peer {
|
|
|
|
// Create a new peer slice with at least the length of the total peers
|
|
|
|
inboundPeers := make([]*Peer, s.peers.Len())
|
|
|
|
length := 0
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
|
|
|
if p.inbound {
|
|
|
|
inboundPeers[length] = p
|
|
|
|
length++
|
|
|
|
}
|
|
|
|
})
|
|
|
|
|
|
|
|
return inboundPeers[:length]
|
|
|
|
}
|
|
|
|
|
2014-01-31 02:57:56 -08:00
|
|
|
func (s *Ethereum) InOutPeers() []*Peer {
|
2014-02-02 07:15:39 -08:00
|
|
|
// Reap the dead peers first
|
|
|
|
s.reapPeers()
|
|
|
|
|
2014-01-31 02:57:56 -08:00
|
|
|
// Create a new peer slice with at least the length of the total peers
|
|
|
|
inboundPeers := make([]*Peer, s.peers.Len())
|
|
|
|
length := 0
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
2014-02-02 07:15:39 -08:00
|
|
|
// Only return peers with an actual ip
|
|
|
|
if len(p.host) > 0 {
|
|
|
|
inboundPeers[length] = p
|
|
|
|
length++
|
|
|
|
}
|
2014-01-31 02:57:56 -08:00
|
|
|
})
|
|
|
|
|
|
|
|
return inboundPeers[:length]
|
|
|
|
}
|
|
|
|
|
2014-02-01 16:39:06 -08:00
|
|
|
func (s *Ethereum) Broadcast(msgType ethwire.MsgType, data []interface{}) {
|
2014-01-23 13:32:50 -08:00
|
|
|
msg := ethwire.NewMessage(msgType, data)
|
2014-02-02 07:15:39 -08:00
|
|
|
s.BroadcastMsg(msg)
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) BroadcastMsg(msg *ethwire.Msg) {
|
2014-01-23 11:14:01 -08:00
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
2014-01-23 13:32:50 -08:00
|
|
|
p.QueueMessage(msg)
|
2014-01-23 11:14:01 -08:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2014-01-31 02:57:56 -08:00
|
|
|
func (s *Ethereum) Peers() *list.List {
|
|
|
|
return s.peers
|
|
|
|
}
|
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
func (s *Ethereum) reapPeers() {
|
|
|
|
s.peerMut.Lock()
|
|
|
|
defer s.peerMut.Unlock()
|
|
|
|
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
|
|
|
if atomic.LoadInt32(&p.disconnect) == 1 || (p.inbound && (time.Now().Unix()-p.lastPong) > int64(5*time.Minute)) {
|
|
|
|
s.peers.Remove(e)
|
|
|
|
}
|
|
|
|
})
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
func (s *Ethereum) ReapDeadPeerHandler() {
|
|
|
|
reapTimer := time.NewTicker(processReapingTimeout * time.Second)
|
|
|
|
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-reapTimer.C:
|
|
|
|
s.reapPeers()
|
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Start the ethereum
|
2014-05-09 07:09:28 -07:00
|
|
|
func (s *Ethereum) Start(seed bool) {
|
2014-01-27 13:13:46 -08:00
|
|
|
// Bind to addr and port
|
2014-02-22 16:57:45 -08:00
|
|
|
ln, err := net.Listen("tcp", ":"+s.Port)
|
2014-01-23 11:14:01 -08:00
|
|
|
if err != nil {
|
2014-02-01 16:39:06 -08:00
|
|
|
log.Println("Connection listening disabled. Acting as client")
|
2014-01-23 11:14:01 -08:00
|
|
|
} else {
|
|
|
|
// Starting accepting connections
|
2014-02-21 16:53:25 -08:00
|
|
|
ethutil.Config.Log.Infoln("Ready and accepting connections")
|
2014-02-02 07:15:39 -08:00
|
|
|
// Start the peer handler
|
|
|
|
go s.peerHandler(ln)
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-02-02 10:44:47 -08:00
|
|
|
if s.nat != nil {
|
|
|
|
go s.upnpUpdateThread()
|
|
|
|
}
|
2014-02-02 10:22:39 -08:00
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
// Start the reaping processes
|
2014-02-02 07:15:39 -08:00
|
|
|
go s.ReapDeadPeerHandler()
|
2014-01-23 11:14:01 -08:00
|
|
|
|
2014-05-09 07:09:28 -07:00
|
|
|
if seed {
|
|
|
|
s.Seed()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Ethereum) Seed() {
|
|
|
|
ethutil.Config.Log.Debugln("Seeding")
|
|
|
|
// DNS Bootstrapping
|
|
|
|
_, nodes, err := net.LookupSRV("eth", "tcp", "ethereum.org")
|
|
|
|
if err == nil {
|
|
|
|
peers := []string{}
|
|
|
|
// Iterate SRV nodes
|
|
|
|
for _, n := range nodes {
|
|
|
|
target := n.Target
|
|
|
|
port := strconv.Itoa(int(n.Port))
|
|
|
|
// Resolve target to ip (Go returns list, so may resolve to multiple ips?)
|
|
|
|
addr, err := net.LookupHost(target)
|
|
|
|
if err == nil {
|
|
|
|
for _, a := range addr {
|
|
|
|
// Build string out of SRV port and Resolved IP
|
|
|
|
peer := net.JoinHostPort(a, port)
|
|
|
|
log.Println("Found DNS Bootstrap Peer:", peer)
|
|
|
|
peers = append(peers, peer)
|
2014-03-17 02:37:37 -07:00
|
|
|
}
|
2014-05-09 07:09:28 -07:00
|
|
|
} else {
|
|
|
|
log.Println("Couldn't resolve :", target)
|
2014-03-17 02:37:37 -07:00
|
|
|
}
|
|
|
|
}
|
2014-05-09 07:09:28 -07:00
|
|
|
// Connect to Peer list
|
|
|
|
s.ProcessPeerList(peers)
|
|
|
|
} else {
|
|
|
|
// Fallback to servers.poc3.txt
|
|
|
|
resp, err := http.Get("http://www.ethereum.org/servers.poc3.txt")
|
|
|
|
if err != nil {
|
|
|
|
log.Println("Fetching seed failed:", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
defer resp.Body.Close()
|
|
|
|
body, err := ioutil.ReadAll(resp.Body)
|
|
|
|
if err != nil {
|
|
|
|
log.Println("Reading seed failed:", err)
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
s.ConnectToPeer(string(body))
|
2014-02-11 09:46:28 -08:00
|
|
|
}
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
2014-02-02 07:15:39 -08:00
|
|
|
func (s *Ethereum) peerHandler(listener net.Listener) {
|
|
|
|
for {
|
|
|
|
conn, err := listener.Accept()
|
|
|
|
if err != nil {
|
2014-02-21 16:53:25 -08:00
|
|
|
ethutil.Config.Log.Debugln(err)
|
2014-02-02 07:15:39 -08:00
|
|
|
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
|
|
|
|
go s.AddPeer(conn)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-01-23 11:14:01 -08:00
|
|
|
func (s *Ethereum) Stop() {
|
|
|
|
// Close the database
|
|
|
|
defer s.db.Close()
|
|
|
|
|
|
|
|
eachPeer(s.peers, func(p *Peer, e *list.Element) {
|
|
|
|
p.Stop()
|
|
|
|
})
|
|
|
|
|
2014-02-02 10:22:39 -08:00
|
|
|
close(s.quit)
|
|
|
|
|
2014-05-06 05:15:02 -07:00
|
|
|
if s.RpcServer != nil {
|
|
|
|
s.RpcServer.Stop()
|
|
|
|
}
|
2014-03-05 01:42:51 -08:00
|
|
|
s.txPool.Stop()
|
2014-03-05 01:57:32 -08:00
|
|
|
s.stateManager.Stop()
|
2014-02-08 12:02:09 -08:00
|
|
|
|
2014-02-28 07:45:29 -08:00
|
|
|
close(s.shutdownChan)
|
2014-01-23 11:14:01 -08:00
|
|
|
}
|
|
|
|
|
|
|
|
// This function will wait for a shutdown and resumes main thread execution
|
|
|
|
func (s *Ethereum) WaitForShutdown() {
|
|
|
|
<-s.shutdownChan
|
|
|
|
}
|
2014-02-02 10:22:39 -08:00
|
|
|
|
|
|
|
func (s *Ethereum) upnpUpdateThread() {
|
|
|
|
// Go off immediately to prevent code duplication, thereafter we renew
|
|
|
|
// lease every 15 minutes.
|
2014-05-01 13:14:20 -07:00
|
|
|
timer := time.NewTimer(5 * time.Minute)
|
2014-02-22 16:57:45 -08:00
|
|
|
lport, _ := strconv.ParseInt(s.Port, 10, 16)
|
2014-02-02 10:22:39 -08:00
|
|
|
first := true
|
|
|
|
out:
|
|
|
|
for {
|
|
|
|
select {
|
|
|
|
case <-timer.C:
|
2014-02-02 10:44:47 -08:00
|
|
|
var err error
|
|
|
|
_, err = s.nat.AddPortMapping("TCP", int(lport), int(lport), "eth listen port", 20*60)
|
2014-02-02 10:22:39 -08:00
|
|
|
if err != nil {
|
2014-02-21 16:53:25 -08:00
|
|
|
ethutil.Config.Log.Debugln("can't add UPnP port mapping:", err)
|
2014-02-02 10:22:39 -08:00
|
|
|
break out
|
|
|
|
}
|
|
|
|
if first && err == nil {
|
2014-02-02 10:44:47 -08:00
|
|
|
_, err = s.nat.GetExternalAddress()
|
2014-02-02 10:22:39 -08:00
|
|
|
if err != nil {
|
2014-02-21 16:53:25 -08:00
|
|
|
ethutil.Config.Log.Debugln("UPnP can't get external address:", err)
|
2014-02-02 10:22:39 -08:00
|
|
|
continue out
|
|
|
|
}
|
|
|
|
first = false
|
|
|
|
}
|
|
|
|
timer.Reset(time.Minute * 15)
|
|
|
|
case <-s.quit:
|
|
|
|
break out
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
timer.Stop()
|
|
|
|
|
|
|
|
if err := s.nat.DeletePortMapping("TCP", int(lport), int(lport)); err != nil {
|
2014-02-21 16:53:25 -08:00
|
|
|
ethutil.Config.Log.Debugln("unable to remove UPnP port mapping:", err)
|
2014-02-02 10:22:39 -08:00
|
|
|
} else {
|
2014-02-21 16:53:25 -08:00
|
|
|
ethutil.Config.Log.Debugln("succesfully disestablished UPnP port mapping")
|
2014-02-02 10:22:39 -08:00
|
|
|
}
|
|
|
|
}
|