cmRtNet.h/c: Completed initial working cmRtNetTest().

cmRtNet.c

 enum
 {
   kLocalNetFl    = 0x01,
-  kSockAddrNetFl = 0x02
+  kSockAddrNetFl = 0x02,
+  kRegNodeNetFl  = 0x04,
+  kRecvNodeNetFl = 0x08
 };
 
 typedef enum
   kHelloSelNetId,
   kHelloAckSelNetId,
   kEndpointSelNetId,
-  kEndpointAckSelNetId
+  kEndpointAckSelNetId,
+  kDoneSelNetId
 } cmRtNetSelId_t;
 
 typedef struct cmRtNetEnd_str
   cmUdpPort_t             port;
   unsigned                flags;
   cmRtNetNodeState_t      state;
-  unsigned                epIdx;
+  unsigned                epIdx;         // tracks the next endpoint to send during sync-mode
   cmTimeSpec_t            lastSendTime;
   cmRtNetEnd_t*           ends;
   struct cmRtNetNode_str* link;
   cmRtNetNode_t*  nodes;
   cmRtNetNode_t*  localNode;
   bool            syncModeFl;
+  bool            masterFl;
   unsigned        udpRecvBufByteCnt;
   unsigned        udpTimeOutMs;
   unsigned        interSyncSendTimeMs;
   return cmErrMsg(&p->err,kNodeNotFoundNetRC,"Node to release not found.");
 }
 
-cmRtNetRC_t _cmRtNetCreateNode( cmRtNet_t* p, const cmChar_t* label, const cmChar_t* addr, cmUdpPort_t port, const struct sockaddr_in* saddr )
+cmRtNetRC_t _cmRtNetCreateNode( cmRtNet_t* p, const cmChar_t* label, const cmChar_t* addr, cmUdpPort_t port, const struct sockaddr_in* saddr, unsigned flags )
 {
   cmRtNetRC_t rc = kOkNetRC;
   cmRtNetNode_t* np;
   np->label = cmMemAllocStr(label);
   np->addr  = addr==NULL ? NULL : cmMemAllocStr(addr);
   np->port  = port;
-  np->flags = cmEnaFlag(np->flags,kLocalNetFl,localNodeFl);
+  np->flags = cmEnaFlag(flags,kLocalNetFl,localNodeFl);
   np->link  = p->nodes;
   p->nodes  = np;
 
 
   // store this nodes current sync state
   cmRtNetNodeState_t orgState = np->state;
-  np->state = nextStId;
+
+  if( nextStId != kInvalidStNetId )
+    np->state = nextStId;
 
  
   // send the msg
   cmRtNetRC_t rc;
 
   // create a node
-  if((rc = _cmRtNetCreateNode(p,nodeLabel,ipAddr, port, NULL)) != kOkNetRC )
+  if((rc = _cmRtNetCreateNode(p,nodeLabel,ipAddr, port, NULL, kRegNodeNetFl)) != kOkNetRC )
     return rc;
 
   // if this is not the local node
   cmRtNet_t* p = _cmRtNetHandleToPtr(h);
 
   p->syncModeFl = true;
-  
+  p->masterFl   = true;
   return rc;
 }
 
 
   if( np->state != expectedState )
   {
-    rc = cmErrMsg(&p->err,kNodeStateErrNetRC,"Node '%s' expected in state %i was in state %i.",kWaitHelloAckStNetId,np->state);
+    rc = cmErrMsg(&p->err,kNodeStateErrNetRC,"Node '%s' expected in state %i was in state %i.",cmStringNullGuard(np->label),kWaitHelloAckStNetId,np->state);
     np->state = kErrorStNetId;
     goto errLabel;
   }
 
   np->state = nextState;
 
+  // if we are about to send another endpoint - incr the endpoint index
+  if( nextState == kSendEndpointStNetId )
+    np->epIdx += 1;
+
  errLabel:
   return rc;
 }
   cmRtNetNode_t*   np = NULL;
   cmRtNetSyncMsg_t m;
 
+  m.endPtLabel = NULL;
+
   assert( cmRtNetIsSyncModeMsg(data,dataByteCnt));
   
   if( _cmRtNetDeserializeSyncMsg(data,dataByteCnt,&m) != kOkNetRC )
         }
 
         //  create a node proxy to represent the remote node
-        if(( rc = _cmRtNetCreateNode(p,m.endPtLabel,NULL,0,fromAddr)) != kOkNetRC )
+        if(( rc = _cmRtNetCreateNode(p,m.endPtLabel,NULL,0,fromAddr,kRecvNodeNetFl)) != kOkNetRC )
           goto errLabel;
 
         // send an ackknowledgement of the 'hello' msg
         rc = _cmRtNetSendAck(p,kHelloAckSelNetId,fromAddr);
+
       }
       break;
 
 
         _cmRtNetRpt(p,"rcv endpoint\n");
 
-
         // locate the remote node which sent the endpoint
         if((np = _cmRtNetFindNodeFromSockAddr(p,fromAddr)) == NULL )
         {
       }
       break;
 
+    case kDoneSelNetId:
+      {
+        _cmRtNetRpt(p,"rcv done\n");
+
+        if( p->masterFl==false  )
+          p->syncModeFl = true;
+      }
+      break;
+
     case kHelloAckSelNetId: // master response
-      assert( p->syncModeFl );
-      _cmRtNetRpt(p,"rcv hello ack\n");
-      rc = _cmRtNetRecvAck(p,fromAddr,kWaitHelloAckStNetId,kSendEndpointStNetId);
+      {
+        assert( p->syncModeFl );
+        _cmRtNetRpt(p,"rcv hello ack\n");
+        rc = _cmRtNetRecvAck(p,fromAddr,kWaitHelloAckStNetId,kSendEndpointStNetId);
+      }
       break;
 
     case kEndpointAckSelNetId: // master response
-      assert( p->syncModeFl );  
-      _cmRtNetRpt(p,"rcv endpoint ack\n");
-      rc = _cmRtNetRecvAck(p,fromAddr,kWaitEndpointAckStNetId,kSendEndpointStNetId);
+      {
+        assert( p->syncModeFl );  
+        _cmRtNetRpt(p,"rcv endpoint ack\n");
+        rc = _cmRtNetRecvAck(p,fromAddr,kWaitEndpointAckStNetId,kSendEndpointStNetId);
+      }
       break;
 
     default:
   }
 
  errLabel:
+
+  cmMemFree((cmChar_t*)m.endPtLabel);
   return rc;
 }
 
   switch( np->state )
   {
     case kSendHelloStNetId:
-      // send a 'hello' to this remote node
-      if((rc = _cmRtNetSendSyncMsg(p,np,kHelloSelNetId,p->localNode->label, cmInvalidId, kWaitHelloAckStNetId )) != kOkNetRC )
-        rc = cmErrMsg(&p->err,rc,"Send 'hello' to %s:%s:%i failed.",cmStringNullGuard(np->label),cmStringNullGuard(np->addr),np->port);
-      else
-        _cmRtNetRpt(p,"send hello\n");
+      {
+        np->epIdx = -1;
+
+        // send a 'hello' to this remote node
+        if((rc = _cmRtNetSendSyncMsg(p,np,kHelloSelNetId,p->localNode->label, cmInvalidId, kWaitHelloAckStNetId )) != kOkNetRC )
+          rc = cmErrMsg(&p->err,rc,"Send 'hello' to %s:%s:%i failed.",cmStringNullGuard(np->label),cmStringNullGuard(np->addr),np->port);
+        else
+          _cmRtNetRpt(p,"%s sent hello\n",cmStringNullGuard(np->label));
+      }
       break;
 
     case kSendEndpointStNetId:
 
         // if all of the endpoints have been sent to this node ...
         if((ep = _cmRtNetIndexToEndpoint(p,p->localNode,np->epIdx)) == NULL )
-          np->state = kDoneStNetId; // ... we are done
+        {
+          // notify the remote node that all endpoints have been sent
+          if((rc = _cmRtNetSendSyncMsg(p,np,kDoneSelNetId,p->localNode->label,cmInvalidId, kDoneStNetId )) != kOkNetRC )
+            rc = cmErrMsg(&p->err,rc,"Send 'done' to %s:%s:%i failed.",cmStringNullGuard(np->label),cmStringNullGuard(np->addr),np->port);
+          else
+            _cmRtNetRpt(p,"Node %s done.\n",cmStringNullGuard(np->label));
+        }
         else
         {
           // send an endpoint to this node 
-          if((rc = _cmRtNetSendSyncMsg(p,np,kHelloSelNetId,ep->endPtLabel, ep->endPtId, kWaitEndpointAckStNetId )) != kOkNetRC )
+          if((rc = _cmRtNetSendSyncMsg(p,np,kEndpointSelNetId,ep->endPtLabel, ep->endPtId, kWaitEndpointAckStNetId )) != kOkNetRC )
             rc = cmErrMsg(&p->err,rc,"Endpoint (%s index:%i) transmission to %s:%s:%i failed.",cmStringNullGuard(ep->endPtLabel),cmStringNullGuard(np->label),cmStringNullGuard(np->addr),np->port);
           else
-            _cmRtNetRpt(p,"send endpoint\n");
+            _cmRtNetRpt(p,"%s sent endpoint %s\n",cmStringNullGuard(np->label),cmStringNullGuard(ep->endPtLabel));
 
         }
       }
   unsigned     activeCnt = 0;
   cmRtNetNode_t* np        = p->nodes;
   for(; np != NULL; np=np->link )
-    if( np != p->localNode && np->state != kDoneStNetId && np->state != kErrorStNetId )
+  {
+    bool fl = (p->masterFl && cmIsFlag(np->flags,kRegNodeNetFl)) || (p->masterFl==false && cmIsFlag(np->flags,kRecvNodeNetFl));
+
+    if( fl && np != p->localNode && np->state != kDoneStNetId && np->state != kErrorStNetId  )
     {
       _cmRtNetSendNodeSync(p,np);
       activeCnt += 1;
     }
-    
+  }
+ 
   if( activeCnt == 0 )
+  {
     p->syncModeFl = false;
+    _cmRtNetRpt(p,"sync mode complete.\n");
+  }
 
   return rc;
 }
   cmRptPrintf(&ctx->rpt,"%s q=quit\n", mstrFl ? "Master: " : "Slave: ");
   while( (c=getchar()) != 'q' )
   {
+    switch(c)
+    {
+      case 'r':
+        cmRtNetReport(p->netH);
+        break;
+    }
     
   }
 

cmRtNet.h

      {
        if( cmRtNetIsSyncModeMsg(dataV,dataN) )
          cmRtNetSyncModeRecv(dataV,dataN,addr)
-     }   
+     } 
+
+
+     The 'master' is the machine which cmRtNetBeginSyncMode() is called on.
+     1) 'master' sends local endpoints to all registered remote nodes.
+     2) When a 'slave' receives the kDoneSelNetId msg it transmits
+     it's own local endpoints back to the master.
+
+     a. Each node in the node list has a type id:
+       1. local 
+       2. registered - remote node that was explicitely registered on a master
+       3. received   - remote node that was received from a master
+
+     b. 
+       1. All nodes are created in the 'send-hello' state.
+       2. If a master machine is in 'sync-mode' then it systematically sends
+       each of it's local endpoints to all 'registered' nodes.
+       3. When a slave machine recives a 'hello' it creates a
+       'received' node.
+       4. When a slave machine recieves a 'done' it enters sync mode
+       and systematically sends each of its local endpoints to
+       the 'done' source.
+       
+
+   Protocol:
+     1. A: broadcast - 'hello'
+     2. Bs: respond 'hello' ack
+     3. A: send local node and endpoints to each responder
+     4. A: send done
+     5. Bs: send local endpoints to A
+
+
    */  
 
 #ifdef __cplusplus