xeth: fixed nil pointer of filter retrieval

This fix addresses an issue with filters that were (possibly) not yet
added to the filter queues but were expected. I've added additional nil
checks making sure it doesn't crash and swapped the installation of the
filter around so it's installed before use.

Closes ethereum#1665

Author: obscuren

xeth/xeth.go

@@ -532,8 +532,10 @@ func (self *XEth) NewLogFilter(earliest, latest int64, skip, max int, address []
 	self.logMu.Lock()
 	defer self.logMu.Unlock()
 
-	var id int
 	filter := core.NewFilter(self.backend)
+	id := self.filterManager.InstallFilter(filter)
+	self.logQueue[id] = &logQueue{timeout: time.Now()}
+
 	filter.SetEarliestBlock(earliest)
 	filter.SetLatestBlock(latest)
 	filter.SetSkip(skip)
@@ -544,10 +546,10 @@ func (self *XEth) NewLogFilter(earliest, latest int64, skip, max int, address []
 		self.logMu.Lock()
 		defer self.logMu.Unlock()
 
-		self.logQueue[id].add(logs...)
+		if queue := self.logQueue[id]; queue != nil {
+			queue.add(logs...)
+		}
 	}
-	id = self.filterManager.InstallFilter(filter)
-	self.logQueue[id] = &logQueue{timeout: time.Now()}
 
 	return id
 }
@@ -556,33 +558,37 @@ func (self *XEth) NewTransactionFilter() int {
 	self.transactionMu.Lock()
 	defer self.transactionMu.Unlock()
 
-	var id int
 	filter := core.NewFilter(self.backend)
+	id := self.filterManager.InstallFilter(filter)
+	self.transactionQueue[id] = &hashQueue{timeout: time.Now()}
+
 	filter.TransactionCallback = func(tx *types.Transaction) {
 		self.transactionMu.Lock()
 		defer self.transactionMu.Unlock()
 
-		self.transactionQueue[id].add(tx.Hash())
+		if queue := self.transactionQueue[id]; queue != nil {
+			queue.add(tx.Hash())
+		}
 	}
-	id = self.filterManager.InstallFilter(filter)
-	self.transactionQueue[id] = &hashQueue{timeout: time.Now()}
 	return id
 }
 
 func (self *XEth) NewBlockFilter() int {
 	self.blockMu.Lock()
 	defer self.blockMu.Unlock()
 
-	var id int
 	filter := core.NewFilter(self.backend)
+	id := self.filterManager.InstallFilter(filter)
+	self.blockQueue[id] = &hashQueue{timeout: time.Now()}
+
 	filter.BlockCallback = func(block *types.Block, logs state.Logs) {
 		self.blockMu.Lock()
 		defer self.blockMu.Unlock()
 
-		self.blockQueue[id].add(block.Hash())
+		if queue := self.blockQueue[id]; queue != nil {
+			queue.add(block.Hash())
+		}
 	}
-	id = self.filterManager.InstallFilter(filter)
-	self.blockQueue[id] = &hashQueue{timeout: time.Now()}
 	return id
 }
 
@@ -1022,33 +1028,49 @@ func (m callmsg) Value() *big.Int               { return m.value }
 func (m callmsg) Data() []byte                  { return m.data }
 
 type logQueue struct {
+	mu sync.Mutex
+
 	logs    state.Logs
 	timeout time.Time
 	id      int
 }
 
 func (l *logQueue) add(logs ...*state.Log) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
 	l.logs = append(l.logs, logs...)
 }
 
 func (l *logQueue) get() state.Logs {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
 	l.timeout = time.Now()
 	tmp := l.logs
 	l.logs = nil
 	return tmp
 }
 
 type hashQueue struct {
+	mu sync.Mutex
+
 	hashes  []common.Hash
 	timeout time.Time
 	id      int
 }
 
 func (l *hashQueue) add(hashes ...common.Hash) {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
 	l.hashes = append(l.hashes, hashes...)
 }
 
 func (l *hashQueue) get() []common.Hash {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
 	l.timeout = time.Now()
 	tmp := l.hashes
 	l.hashes = nil