Add BRSKI (CCM) commissioning and sim-hosts support

.github/workflows/test.yml

@@ -85,6 +85,27 @@ jobs:
       - name: Test single OT-version
         run: |
           ./script/test py-unittests
+
+  py-ver-unittests:
+    name: Unittests-Version (${{ matrix.os }})
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+    strategy:
+      fail-fast: false
+      matrix:
+        python-version: ['3.10']
+        os: [ubuntu-22.04]
+    env:
+      HOMEBREW_NO_AUTO_UPDATE: 1
+    steps:
+      - uses: actions/setup-go@v5
+        with:
+          go-version: '1.22'
+      - name: Set up Python
+        uses: actions/setup-python@v5
+        with:
+          python-version: ${{ matrix.python-version }}
+      - uses: actions/checkout@v3
       - name: Test multiple OT-versions
         run: |
           ./script/test py-ver-unittests

cli/CmdRunner.go

@@ -39,6 +39,8 @@ import (
 	"github.com/pkg/errors"
 	"gopkg.in/yaml.v3"
 
+	"net/netip"
+
 	"github.com/openthread/ot-ns/dispatcher"
 	"github.com/openthread/ot-ns/logger"
 	"github.com/openthread/ot-ns/progctx"
@@ -321,6 +323,8 @@ func (rt *CmdRunner) execute(cmd *Command, output io.Writer) {
 		rt.executeSave(cc, cmd.Save)
 	} else if cmd.Send != nil {
 		rt.executeSend(cc, cmd.Send)
+	} else if cmd.Host != nil {
+		rt.executeHost(cc, cmd.Host)
 	} else {
 		logger.Panicf("unimplemented command: %#v", cmd)
 	}
@@ -1467,3 +1471,55 @@ func (rt *CmdRunner) executeSend(cc *CommandContext, cmd *SendCmd) {
 		}
 	})
 }
+
+func (rt *CmdRunner) executeHost(cc *CommandContext, cmd *HostCmd) {
+	rt.postAsyncWait(cc, func(sim *simulation.Simulation) {
+		var addr netip.Addr
+		var err error
+
+		if cmd.IpAddr != nil {
+			addr, err = netip.ParseAddr(cmd.IpAddr.Addr)
+			if err != nil {
+				cc.errorf("invalid IPv6 address argument: '%s'", cmd.IpAddr.Addr)
+				return
+			}
+		}
+
+		host := simulation.SimHostEndpoint{
+			HostName:   cmd.Hostname,
+			Ip6Addr:    addr,
+			Port:       cmd.Port,
+			PortMapped: cmd.PortMapped,
+		}
+
+		switch cmd.SubCmd {
+		case "add":
+			if cmd.Port == 0 || cmd.PortMapped == 0 {
+				cc.errorf("invalid port argument(s)")
+				return
+			}
+			if err = sim.SimHosts().AddHost(host); err != nil {
+				cc.errorf("could not add host: %v", err)
+				return
+			}
+		case "del":
+			if len(cmd.Hostname) == 0 {
+				cc.errorf("missing <hostname> or <ipaddr> argument")
+				return
+			}
+			addr, _ = netip.ParseAddr(cmd.Hostname)
+			for h := range sim.SimHosts().Hosts {
+				if cmd.Hostname == h.HostName || addr == h.Ip6Addr {
+					sim.SimHosts().RemoveHost(h)
+				}
+			}
+
+		case "list":
+			sh := sim.SimHosts()
+			cc.outputf("Hostname                                 Destination IPv6 address                DstPort MapPort RxBytes  TxBytes\n")
+			for h := range sim.SimHosts().Hosts {
+				cc.outputf("%-40s %-40s % 6d % 6d % 8d % 8d\n", h.HostName, h.Ip6Addr.String(), h.Port, h.PortMapped, sh.GetRxBytes(&h), sh.GetTxBytes(&h))
+			}
+		}
+	})
+}

cli/README.md

@@ -409,6 +409,24 @@ Show help text for specific, or all, OTNS CLI commands.
 help [ <command> ]
 ```
 
+### host
+
+Add a simulated IP host for Thread nodes to communicate with.
+
+```shell
+host add "<hostname>" "<ipaddr>" <port> <maps-to-local-port>
+host del "<hostname>" | "<ipaddr>"
+host list  
+```
+
+Any UDP/TCP packets sent to an off-mesh destination by a Thread node will first be routed over the mesh to a Thread 
+Border Router (node type `br`). The BR will notify OTNS about such received packets. OTNS then looks up if any 
+simulated IP host matches the packet's destination address/port and if so, it delivers the packet locally (localhost) 
+to the mapped port number `<maps-to-local-port>`. This enables simulations with the behavior of Thread-external servers 
+to be done fully locally, without causing any real network traffic.
+
+Note: currently only IPv6 hosts are supported; IPv4 (via NAT64) may be added later.
+
 ### joins
 
 Displays finished joiner sessions.

cli/ast.go

@@ -51,6 +51,7 @@ type Command struct {
 	Exit                *ExitCmd                `| @@` //nolint
 	Go                  *GoCmd                  `| @@` //nolint
 	Help                *HelpCmd                `| @@` //nolint
+	Host                *HostCmd                `| @@` //nolint
 	Joins               *JoinsCmd               `| @@` //nolint
 	Kpi                 *KpiCmd                 `| @@` //nolint
 	Load                *LoadCmd                `| @@` //nolint
@@ -581,6 +582,16 @@ type SendCmd struct {
 	DataSize   *DataSizeFlag  `[ @@ ]`                        //nolint
 }
 
+// noinspection GoVetStructTag
+type HostCmd struct {
+	Cmd        struct{}     `"host"`                //nolint
+	SubCmd     string       `@("add"|"del"|"list")` //nolint
+	Hostname   string       `[ @String ]`           //nolint
+	IpAddr     *Ipv6Address `[ @@ ]`                //nolint
+	Port       uint16       `[ @Int ]`              //nolint
+	PortMapped uint16       `[ @Int ]`              //nolint
+}
+
 // noinspection GoVetStructTag
 type FailTimeParams struct {
 	Dummy        struct{} `"ft"`          //nolint

cli/cli_test.go

@@ -109,6 +109,9 @@ func TestParseBytes(t *testing.T) {
 	assert.Nil(t, parseBytes([]byte("go 100 speed 2"), &cmd))
 	assert.NotNil(t, cmd.Go)
 
+	assert.True(t, parseBytes([]byte("help"), &cmd) == nil && cmd.Help != nil)
+	assert.True(t, parseBytes([]byte("host add \"myhost.example.com\" \"fc00::1234\" 35683 1717"), &cmd) == nil && cmd.Host != nil)
+
 	assert.True(t, parseBytes([]byte("joins"), &cmd) == nil && cmd.Joins != nil)
 
 	assert.True(t, parseBytes([]byte("log"), &cmd) == nil && cmd.LogLevel != nil)

dispatcher/FailureCtrl_test.go

@@ -53,6 +53,9 @@ func (m mockDispatcherCallback) OnNextEventTime(nextTimeUs uint64) {
 func (m mockDispatcherCallback) OnRfSimEvent(nodeid NodeId, evt *event.Event) {
 }
 
+func (m mockDispatcherCallback) OnMsgToHost(nodeid NodeId, evt *event.Event) {
+}
+
 func mockNode1() *Node {
 	return &Node{
 		Id:     0x1,

dispatcher/Node.go

@@ -182,7 +182,6 @@ func (node *Node) sendEvent(evt *Event) {
 
 	// time keeping - move node's time to the current send-event's time.
 	node.D.alarmMgr.SetNotified(node.Id)
-	node.D.setAlive(node.Id)
 	node.CurTime += evt.Delay
 	logger.AssertTrue(node.CurTime == node.D.CurTime)
 
@@ -203,6 +202,8 @@ func (node *Node) sendEvent(evt *Event) {
 	if err != nil {
 		node.logger.Error(err)
 		node.err = err
+	} else {
+		node.D.setAlive(node.Id)
 	}
 }
 

dispatcher/coaps.go

@@ -27,7 +27,6 @@
 package dispatcher
 
 import (
-	"github.com/openthread/ot-ns/logger"
 	. "github.com/openthread/ot-ns/types"
 )
 
@@ -81,11 +80,11 @@ func (coaps *coapsHandler) OnSend(curTime uint64, nodeId NodeId, messageId int,
 
 func (coaps *coapsHandler) OnRecv(curTime uint64, nodeId NodeId, messageId int, coapType CoapType, coapCode CoapCode, uri string, peerAddr string, peerPort int) {
 	msg := coaps.findMessage(messageId, coapType, coapCode, uri)
-	if msg == nil {
-		logger.Warnf("CoAP message %d,%d,%d,%s not sent but received by Node %d", messageId, coapType, coapCode, uri, nodeId)
+	if msg == nil { // may happen if CoAP message originated from outside of mesh (external process)
 		return
 	}
 
+	// keep all received CoAP messages for KPI purposes.
 	msg.Receivers = append(msg.Receivers, CoapMessageRecvInfo{
 		Timestamp: curTime,
 		DstNode:   nodeId,
@@ -96,12 +95,11 @@ func (coaps *coapsHandler) OnRecv(curTime uint64, nodeId NodeId, messageId int,
 
 func (coaps *coapsHandler) OnSendError(nodeId NodeId, messageId int, coapType CoapType, coapCode CoapCode, uri string, peerAddr string, peerPort int, error string) {
 	msg := coaps.findMessage(messageId, coapType, coapCode, uri)
-	if msg == nil {
-		logger.Warnf("CoAP message %d,%d,%d,%s not sent but received by Node %d", messageId, coapType, coapCode, uri, nodeId)
+	if msg == nil { // may happen if CoAP message originated from outside of mesh (external process) ?
 		return
 	}
 
-	msg.Error = error
+	msg.Error = error // mark the message as having had a send error
 }
 
 func (coaps *coapsHandler) findMessage(id int, coapType CoapType, coapCode CoapCode, uri string) *CoapMessage {

dispatcher/dispatcher.go

@@ -53,18 +53,22 @@ import (
 	"github.com/openthread/ot-ns/visualize"
 )
 
+// CallbackHandler handles callbacks from Dispatcher to its managing entity (e.g. a Simulation).
 type CallbackHandler interface {
 	// OnUartWrite Notifies that the node's UART was written with data.
 	OnUartWrite(nodeid NodeId, data []byte)
 
 	// OnLogWrite Notifies that a log item wsa written to the node's log.
 	OnLogWrite(nodeid NodeId, data []byte)
 
-	// OnNextEventTime Notifies that the Dispatcher simulation will move shortly to the next event time.
+	// OnNextEventTime Notifies that the Dispatcher simulated-time will move to the next event time.
 	OnNextEventTime(nextTimeUs uint64)
 
 	// OnRfSimEvent Notifies that Dispatcher received an OT-RFSIM platform event that it didn't handle itself.
 	OnRfSimEvent(nodeid NodeId, evt *Event)
+
+	// OnMsgToHost Notifies that the Dispatcher received a message from a node, to be handled by the node's host.
+	OnMsgToHost(nodeid NodeId, event *Event)
 }
 
 // goDuration represents a particular duration of the simulation at a given speed.
@@ -84,6 +88,7 @@ type Dispatcher struct {
 		StatusPushEvents uint64
 		UartWriteEvents  uint64
 		LogWriteEvents   uint64
+		HostEvents       uint64
 		OtherEvents      uint64
 		// Packet-related event dispatching counters
 		DispatchByExtAddrSucc   uint64
@@ -168,7 +173,7 @@ func NewDispatcher(ctx *progctx.ProgCtx, cfg *Config, cbHandler CallbackHandler)
 	}
 	d.speed = d.normalizeSpeed(d.speed)
 	if d.cfg.PcapEnabled {
-		d.pcap, err = pcap.NewFile("current.pcap", cfg.PcapFrameType)
+		d.pcap, err = pcap.NewFile("current.pcap", cfg.PcapFrameType, true)
 		logger.PanicIfError(err)
 		d.waitGroup.Add(1)
 		go d.pcapFrameWriter()
@@ -376,7 +381,7 @@ func (d *Dispatcher) goSimulateForDuration(duration goDuration) {
 	}
 }
 
-// handleRecvEvent is the central handler for all events externally received from OpenThread nodes.
+// handleRecvEvent is the central handler for all events externally received from nodes/entities.
 // It may only process events immediately that are to be executed at time d.CurTime. Future events
 // will need to be queued (scheduled).
 func (d *Dispatcher) handleRecvEvent(evt *Event) {
@@ -387,7 +392,9 @@ func (d *Dispatcher) handleRecvEvent(evt *Event) {
 		return
 	}
 
-	node.conn = evt.Conn      // store socket connection for this node.
+	if node.conn == nil {
+		node.conn = evt.Conn // store socket connection for this node.
+	}
 	evt.Timestamp = d.CurTime // timestamp the incoming event
 
 	// TODO document this use (for alarm messages)
@@ -428,6 +435,16 @@ func (d *Dispatcher) handleRecvEvent(evt *Event) {
 		logger.Debugf("%s socket disconnected.", node)
 		d.setSleeping(node.Id)
 		d.alarmMgr.SetTimestamp(node.Id, Ever)
+	case EventTypeUdpToHost,
+		EventTypeIp6ToHost:
+		d.Counters.HostEvents += 1
+		d.sendMsgToHost(node, evt)
+		d.cbHandler.OnMsgToHost(node.Id, evt)
+	case EventTypeUdpFromHost,
+		EventTypeIp6FromHost:
+		d.Counters.HostEvents += 1
+		evt.MustDispatch = true // asap resend again to the target (BR) node.
+		d.eventQueue.Add(evt)
 	default:
 		d.Counters.OtherEvents += 1
 		d.cbHandler.OnRfSimEvent(node.Id, evt)
@@ -570,6 +587,9 @@ func (d *Dispatcher) processNextEvent(simSpeed float64) bool {
 						d.sendRadioCommRxStartEvents(node, evt)
 					case EventTypeRadioRxDone:
 						d.sendRadioCommRxDoneEvents(node, evt)
+					case EventTypeUdpFromHost,
+						EventTypeIp6FromHost:
+						node.sendEvent(evt) // TODO no loss on external network is simulated currently.
 					default:
 						if d.radioModel.OnEventDispatch(node.RadioNode, node.RadioNode, evt) {
 							node.sendEvent(evt)
@@ -845,6 +865,20 @@ func (d *Dispatcher) sendOneRadioFrame(evt *Event, srcnode *Node, dstnode *Node)
 	}
 }
 
+func (d *Dispatcher) sendMsgToHost(node *Node, evt *Event) {
+	if d.cfg.PcapEnabled {
+		/** TODO write IPv6 packet to a separate pcap file
+		d.pcapFrameChan <- pcap.Frame{
+			Timestamp: evt.Timestamp,
+			Data:      evt.Data,
+			Channel:   0,
+			Rssi:      RssiInvalid,
+		}
+		*/
+		node.logger.Debugf("sendMsgToHost: %v", evt)
+	}
+}
+
 func (d *Dispatcher) setAlive(nodeid NodeId) {
 	logger.AssertFalse(d.isDeleted(nodeid))
 	d.aliveNodes[nodeid] = struct{}{}
@@ -1147,6 +1181,10 @@ func (d *Dispatcher) PostAsync(task func()) {
 	d.taskChan <- task
 }
 
+func (d *Dispatcher) PostEventAsync(ev *Event) {
+	d.eventChan <- ev
+}
+
 func (d *Dispatcher) handleTasks() {
 	defer func() {
 		err := recover()