new: events.stream module enabled by default

main.go

@@ -21,6 +21,7 @@ func main() {
 	fmt.Printf("%s v%s\n", core.Name, core.Version)
 	fmt.Printf("Build: date=%s os=%s arch=%s\n\n", core.BuildDate, runtime.GOOS, runtime.GOARCH)
 
+	sess.Register(session_modules.NewEventsStream(sess))
 	sess.Register(session_modules.NewProber(sess))
 	sess.Register(session_modules.NewDiscovery(sess))
 	sess.Register(session_modules.NewArpSpoofer(sess))
@@ -32,6 +33,10 @@ func main() {
 		sess.Events.Log(session.FATAL, "%s", err)
 	}
 
+	if err = sess.Run("events.stream on"); err != nil {
+		sess.Events.Log(session.FATAL, "%s", err)
+	}
+
 	defer sess.Close()
 
 	if *sess.Options.Commands != "" {

session/events.go

@@ -5,8 +5,6 @@ import (
 	"os"
 	"sync"
 	"time"
-
-	"github.com/evilsocket/bettercap-ng/core"
 )
 
 const (
@@ -32,23 +30,21 @@ func NewEvent(tag string, data interface{}) Event {
 	}
 }
 
-func (e Event) Print() {
-	fmt.Printf("[%s] [%s] %v\n", e.Time, core.Green(e.Tag), e.Data)
-}
-
 type EventPool struct {
-	debug  bool
-	silent bool
-	events []Event
-	lock   *sync.Mutex
+	NewEvents chan Event
+	debug     bool
+	silent    bool
+	events    []Event
+	lock      *sync.Mutex
 }
 
 func NewEventPool(debug bool, silent bool) *EventPool {
 	return &EventPool{
-		debug:  debug,
-		silent: silent,
-		events: make([]Event, 0),
-		lock:   &sync.Mutex{},
+		NewEvents: make(chan Event),
+		debug:     debug,
+		silent:    silent,
+		events:    make([]Event, 0),
+		lock:      &sync.Mutex{},
 	}
 }
 
@@ -57,7 +53,12 @@ func (p *EventPool) Add(tag string, data interface{}) {
 	defer p.lock.Unlock()
 	e := NewEvent(tag, data)
 	p.events = append([]Event{e}, p.events...)
-	e.Print()
+
+	select {
+	case p.NewEvents <- e:
+		break
+	default:
+	}
 }
 
 func (p *EventPool) Log(level int, format string, args ...interface{}) {

session/modules/events_stream.go

@@ -0,0 +1,94 @@
+package session_modules
+
+import (
+	"fmt"
+
+	"github.com/evilsocket/bettercap-ng/core"
+	"github.com/evilsocket/bettercap-ng/session"
+)
+
+type EventsStream struct {
+	session.SessionModule
+	quit chan bool
+}
+
+func NewEventsStream(s *session.Session) *EventsStream {
+	stream := &EventsStream{
+		SessionModule: session.NewSessionModule("events.stream", s),
+		quit:          make(chan bool),
+	}
+
+	stream.AddHandler(session.NewModuleHandler("events.stream on", "",
+		"Start events stream.",
+		func(args []string) error {
+			return stream.Start()
+		}))
+
+	stream.AddHandler(session.NewModuleHandler("events.stream off", "",
+		"Stop events stream.",
+		func(args []string) error {
+			return stream.Stop()
+		}))
+
+	stream.AddHandler(session.NewModuleHandler("events.clear", "",
+		"Clear events stream.",
+		func(args []string) error {
+			stream.Session.Events.Clear()
+			return nil
+		}))
+
+	return stream
+}
+
+func (s EventsStream) Name() string {
+	return "Events Stream"
+}
+
+func (s EventsStream) Description() string {
+	return "Print events as a continuous stream."
+}
+
+func (s EventsStream) Author() string {
+	return "Simone Margaritelli <evilsocket@protonmail.com>"
+}
+
+func (s *EventsStream) Start() error {
+	if s.Running() == false {
+		s.SetRunning(true)
+
+		go func() {
+			for {
+				var e session.Event
+				select {
+				case e = <-s.Session.Events.NewEvents:
+					fmt.Printf("[%s] [%s] %v\n", e.Time.UTC().Format("2006-01-02 15:04:05"), core.Green(e.Tag), e.Data)
+					break
+
+				case <-s.quit:
+					return
+				}
+			}
+		}()
+
+		return nil
+	} else {
+		return fmt.Errorf("Events stream already started.")
+	}
+
+}
+
+func (s *EventsStream) Stop() error {
+	if s.Running() == true {
+		s.SetRunning(false)
+		s.quit <- true
+		return nil
+	} else {
+		return fmt.Errorf("Events stream already stopped.")
+	}
+}
+
+func (p EventsStream) OnSessionEnded(s *session.Session) {
+	if p.Running() {
+		p.Stop()
+	}
+}

session/modules/net_recon.go

@@ -70,8 +70,6 @@ func (d *Discovery) Start() error {
 		d.SetRunning(true)
 
 		go func() {
-			d.Session.Events.Log(session.INFO, "Network discovery started.")
-
 			for {
 				select {
 				case <-time.After(time.Duration(d.refresh) * time.Second):
@@ -127,7 +125,6 @@ func (d *Discovery) Start() error {
 					d.before = d.current
 
 				case <-d.quit:
-					d.Session.Events.Log(session.INFO, "Network discovery stopped.")
 					return
 				}
 			}