cmRtNet.h/c: Implement simplified net synch. protocol.

cmRtNet.c

 
 enum
 {
-  kLocalNetFl    = 0x01,
-  kSockAddrNetFl = 0x02,
-  kRegNodeNetFl  = 0x04,
-  kRecvNodeNetFl = 0x08
+  kLocalNodeNetFl = 0x01,
+  kValidNodeNetFl = 0x02
 };
 
 typedef enum
 {
-  kSendHelloStNetId = 0,
-  kWaitHelloAckStNetId,
-  kSendEndpointStNetId,
-  kWaitEndpointAckStNetId,
-  kDoneStNetId,
-  kErrorStNetId,
-  kInvalidStNetId,
-} cmRtNetNodeState_t;
-
-typedef enum
-{
   kHelloSelNetId,
-  kHelloAckSelNetId,
+  kNodeSelNetId,
   kEndpointSelNetId,
   kEndpointAckSelNetId,
-  kDoneSelNetId
+  kDoneSelNetId,
 } cmRtNetSelId_t;
 
 typedef struct cmRtNetEnd_str
 {
-  cmChar_t*              endPtLabel;
-  unsigned               endPtId;
+  cmChar_t*              label;
+  unsigned               id;
   struct cmRtNetEnd_str* link;
 } cmRtNetEnd_t;
 
   cmChar_t*               addr;
   cmUdpPort_t             port;
   unsigned                flags;
-  cmRtNetNodeState_t      state;
-  unsigned                epIdx;         // tracks the next endpoint to send during sync-mode
+  unsigned                endPtIdx;       // tracks the next endpoint to send during sync-mode
+  unsigned                endPtCnt;       // local-node=actual cnt of endpt's remote-node:expected cnt of endpt's
   cmTimeSpec_t            lastSendTime;
   cmRtNetEnd_t*           ends;
   struct cmRtNetNode_str* link;
   void*           cbArg;
   cmRtNetNode_t*  nodes;
   cmRtNetNode_t*  localNode;
-  bool            syncModeFl;
-  bool            masterFl;
   unsigned        udpRecvBufByteCnt;
   unsigned        udpTimeOutMs;
   unsigned        interSyncSendTimeMs;
 {
   cmRtSysMsgHdr_t hdr;
   cmRtNetSelId_t  selId;
-  const cmChar_t* endPtLabel;
-  unsigned        endPtId;
+  const cmChar_t* label;  // node     or endpoint label
+  unsigned        id;     // endptCnt or endpoint id
 } cmRtNetSyncMsg_t;
 
 cmRtNetH_t cmRtNetNullHandle = cmSTATIC_NULL_HANDLE;
 
   cmRtNetNode_t* np = p->nodes;
   for(; np!=NULL; np=np->link)
-    if( cmIsFlag(np->flags,kSockAddrNetFl) && np->sockaddr.sin_addr.s_addr == saddr->sin_addr.s_addr && np->sockaddr.sin_port == saddr->sin_port )
+    if( np->sockaddr.sin_addr.s_addr == saddr->sin_addr.s_addr && np->sockaddr.sin_port == saddr->sin_port )
       return np;
   
   return NULL;
   while( ep != NULL )
   {
     cmRtNetEnd_t* nep = ep->link;
-    cmMemFree(ep->endPtLabel);
+    cmMemFree(ep->label);
     cmMemFree(ep);
     ep = nep;
   }
 
 cmRtNetRC_t  _cmRtNetReleaseNode( cmRtNet_t* p, cmRtNetNode_t* np )
 {
-  // we should never release the local node via this function
-  assert( np != p->localNode );
-
   cmRtNetNode_t* cnp = p->nodes;
   cmRtNetNode_t* pnp = NULL;
 
   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, unsigned flags )
+cmRtNetRC_t _cmRtNetCreateNode( cmRtNet_t* p, const cmChar_t* label, const cmChar_t* addr, cmUdpPort_t port, const struct sockaddr_in* saddr, unsigned flags, unsigned endPtCnt )
 {
   cmRtNetRC_t rc = kOkNetRC;
   cmRtNetNode_t* np;
 
   if((np = _cmRtNetFindNode(p,label)) != NULL )
     return cmErrMsg(&p->err,kDuplLabelNetRC,"The node label '%s' is already in use.",cmStringNullGuard(label));
-
-  bool localNodeFl = addr==NULL && saddr==NULL;
   
-  if( localNodeFl && p->localNode != NULL )
-    return cmErrMsg(&p->err,kDuplLocalNetRC,"The local node '%s' has already been set.",cmStringNullGuard(p->localNode->label));
-
-  np = cmMemAllocZ(cmRtNetNode_t,1);
-  np->label = cmMemAllocStr(label);
-  np->addr  = addr==NULL ? NULL : cmMemAllocStr(addr);
-  np->port  = port;
-  np->flags = cmEnaFlag(flags,kLocalNetFl,localNodeFl);
-  np->link  = p->nodes;
-  p->nodes  = np;
-
-  if( localNodeFl )
-    p->localNode = np;
-
-  if( saddr != NULL )
-    np->sockaddr = *saddr;
-  else
-  {
-    if( cmUdpInitAddr(p->udpH, np->addr, np->port, &np->sockaddr ) != kOkUdpRC )
-    {
-      rc = cmErrMsg(&p->err,kUdpPortFailNetRC,"IP::port to socket address conversion failed.");
-      goto errLabel;
-    }
-  }
-
-  np->flags = cmSetFlag(np->flags,kSockAddrNetFl);
+  np           = cmMemAllocZ(cmRtNetNode_t,1);
+  np->label    = cmMemAllocStr(label);
+  np->sockaddr = *saddr;
+  np->addr     = addr==NULL ? NULL : cmMemAllocStr(addr);
+  np->port     = port;
+  np->flags    = flags;
+  np->endPtCnt = endPtCnt;
+  np->link     = p->nodes;
+  p->nodes     = np;
 
- errLabel:
   return rc;
 }
 
 {
   cmRtNetEnd_t* ep = np->ends;
   for(; ep!=NULL; ep=ep->link)
-    if( strcmp(ep->endPtLabel,endPtLabel)==0 )
+    if( strcmp(ep->label,endPtLabel)==0 )
       return ep;
   return NULL;
 }
   cmRtNetRC_t   rc = kOkNetRC;
   cmRtNetEnd_t* ep = cmMemAllocZ(cmRtNetEnd_t,1);
 
-  ep->endPtLabel = cmMemAllocStr(endPtLabel);
-  ep->endPtId    = endPtId;
+  ep->label = cmMemAllocStr(endPtLabel);
+  ep->id    = endPtId;
   ep->link      = np->ends;
   np->ends      = ep;
 
 }
 
 unsigned _cmRtNetSyncMsgSerialByteCount( const cmRtNetSyncMsg_t* m )
-{ return sizeof(cmRtNetSyncMsg_t) + (m->endPtLabel==NULL ? 1 : strlen(m->endPtLabel) + 1); }
+{ return sizeof(cmRtNetSyncMsg_t) + (m->label==NULL ? 1 : strlen(m->label) + 1); }
 
 cmRtNetRC_t _cmRtNetSerializeSyncMsg( cmRtNet_t* p, const cmRtNetSyncMsg_t* m, void* buf, unsigned n )
 {
     return cmErrMsg(&p->err,kBufToSmallNetRC,"Serialize buffer too small.");
 
   memcpy(b,m,sizeof(*m));
-  strcpy(b + sizeof(*m),m->endPtLabel==NULL ? "" : m->endPtLabel);
+  strcpy(b + sizeof(*m),m->label==NULL ? "" : m->label);
   return kOkNetRC;
 }
 
   memcpy(m,buf,sizeof(*m));
   const cmRtNetSyncMsg_t* mp = (const cmRtNetSyncMsg_t*)buf;
   const cmChar_t*   s  = (const cmChar_t*)(mp+1);
-  m->endPtLabel = cmMemAllocStr(s);
+  m->label = cmMemAllocStr(s);
   return kOkNetRC;
 }
 
-cmRtNetRC_t _cmRtNetSendSyncMsg( cmRtNet_t* p, cmRtNetNode_t* np, cmRtNetSelId_t selId, const cmChar_t* endPtLabel, unsigned endPtId, cmRtNetNodeState_t nextStId )
+cmRtNetRC_t _cmRtNetSendSyncMsg( cmRtNet_t* p, cmRtNetNode_t* np, cmRtNetSelId_t selId, const cmChar_t* msgLabel, unsigned msgId )
 {
   cmRtNetSyncMsg_t m;
   cmRtNetRC_t      rc = kOkNetRC;
   m.hdr.rtSubIdx = cmInvalidIdx;
   m.hdr.selId    = kNetSyncSelRtId;
   m.selId        = selId;
-  m.endPtLabel    = endPtLabel;
-  m.endPtId       = endPtId;
+  m.label        = msgLabel;
+  m.id           = msgId;
 
   // determine size of msg to send
   unsigned n  = _cmRtNetSyncMsgSerialByteCount(&m);
   if((rc = _cmRtNetSerializeSyncMsg(p,&m,buf,n)) != kOkNetRC )
     return rc;
 
-  // store this nodes current sync state
-  cmRtNetNodeState_t orgState = np->state;
-
-  if( nextStId != kInvalidStNetId )
-    np->state = nextStId;
-
  
   // send the msg
-  if( cmIsFlag(np->flags,kSockAddrNetFl) == false )
-    udpRC = cmUdpSend2(p->udpH, buf, n, np->addr, np->port );
+  if( np==p->localNode )
+    udpRC = cmUdpSend2(p->udpH, buf, n, "255.255.255.255", np->port );
   else
     udpRC = cmUdpSendTo(p->udpH, buf, n, &np->sockaddr );
 
   if( udpRC != kOkUdpRC )
   {
     rc = cmErrMsg(&p->err,kUdpPortFailNetRC,"Sync msg. send on UDP port failed.");
-    np->state = orgState;  // restore node state so we can try again
   }
   else
   {
   return p->udpH;
 }
 
-
-cmRtNetRC_t cmRtNetCreateNode( cmRtNetH_t h, const cmChar_t* nodeLabel, const cmChar_t* ipAddr, cmUdpPort_t port )
+cmRtNetRC_t  _cmRtNetSendEndpointReplyMsg( cmRtNet_t* p, cmRtNetNode_t* np )
 {
-  cmRtNet_t*  p = _cmRtNetHandleToPtr(h);
-  cmRtNetRC_t rc;
+  cmRtNetRC_t     rc = kOkNetRC;
+  cmRtNetEnd_t*   ep;
+  const cmChar_t* msgLabel = NULL;
+  unsigned        msgId    = cmInvalidId;  
+  cmRtNetSelId_t  selId    = kEndpointSelNetId;
+  const cmChar_t* rptLabel = "endpoint";
 
-  // create a node
-  if((rc = _cmRtNetCreateNode(p,nodeLabel,ipAddr, port, NULL, kRegNodeNetFl)) != kOkNetRC )
-    return rc;
+  if( np == NULL )
+    return cmErrMsg(&p->err,kNodeNotFoundNetRC,"The net node associated with an endpoint reply was not found.");
 
-  // if this is not the local node
-  if( ipAddr != NULL )
-    return rc;
-
-  // if this is the local node then initialze the local socket
-  if( cmUdpInit(p->udpH,port,kNonBlockingUdpFl,p->cbFunc,p->cbArg,NULL,0,p->udpRecvBufByteCnt,p->udpTimeOutMs) != kOkUdpRC )
+  // if all of the endpoints have been sent to this node ...
+  if((ep = _cmRtNetIndexToEndpoint(p,p->localNode,np->endPtIdx)) == NULL )
   {
-    rc = cmErrMsg(&p->err,kUdpPortFailNetRC,"The UDP port initialization failed.");
-    goto errLabel;
-  }
-
-  // begin listening on the local port
-  if( cmUdpEnableListen(p->udpH, true ) != kOkUdpRC )
-  {
-    rc = cmErrMsg(&p->err,kUdpPortFailNetRC,"The UDP port failed to enter 'listen' mode.");
-    goto errLabel;
-  }
-
-
- errLabel:
-  return rc;
-}
-
-cmRtNetRC_t cmRtNetRegisterEndPoint( cmRtNetH_t h, const cmChar_t* endPtLabel, unsigned endPtId )
-{
-  cmRtNet_t* p = _cmRtNetHandleToPtr(h);
-
-  if( p->localNode == NULL )
-    return cmErrMsg(&p->err,kLocalNodeNetRC,"Local endpoints may not be added if a local node has not been defined.");
-
-  return _cmRtNetCreateEndpoint(p, p->localNode,endPtLabel,endPtId );
-
-}
-
-cmRtNetRC_t cmRtNetClearAll( cmRtNetH_t h )
-{
-  cmRtNet_t* p = _cmRtNetHandleToPtr(h);
-  _cmRtNetReleaseNodes(p);
-  return kOkNetRC;
-}
-
-cmRtNetRC_t cmRtNetBeginSyncMode( cmRtNetH_t h )
-{
-  cmRtNetRC_t rc = kOkNetRC;
-  
-  cmRtNet_t* p = _cmRtNetHandleToPtr(h);
-
-  p->syncModeFl = true;
-  p->masterFl   = true;
-  return rc;
-}
-
-bool      cmRtNetIsInSyncMode(  cmRtNetH_t h )
-{
-  cmRtNet_t* p = _cmRtNetHandleToPtr(h);
-
-  return p->syncModeFl;
-}
-
-
-// Used by slaves to send the master an 'ack' msg.
-cmRtNetRC_t _cmRtNetSendAck( cmRtNet_t* p, cmRtNetSelId_t ackSelId, const struct sockaddr_in* saddr )
-{
-  cmRtNetNode_t* np;
-
-  if((np = _cmRtNetFindNodeFromSockAddr(p,saddr)) == NULL )
-    return cmErrMsg(&p->err,kNodeNotFoundNetRC,"The net node associated with an ack cmd was not found. Ack not sent.");
-
-  return _cmRtNetSendSyncMsg(p,np,ackSelId,NULL,cmInvalidId,kInvalidStNetId);
-}
-
-// Used by master to update state upon receipt of 'ack' msg
-cmRtNetRC_t _cmRtNetRecvAck( cmRtNet_t* p, const struct sockaddr_in* fromAddr, cmRtNetNodeState_t expectedState, cmRtNetNodeState_t nextState )
-{
-  cmRtNetNode_t* np;
-  cmRtNetRC_t rc = kOkNetRC;
-
-  if((np = _cmRtNetFindNodeFromSockAddr(p,fromAddr)) == NULL )
-  {
-    rc = cmErrMsg(&p->err,kNodeNotFoundNetRC,"The net node associated with a  ack receive was not found.");
-    goto errLabel;
+    if( np->endPtIdx == p->localNode->endPtCnt )
+    {
+      selId = kDoneSelNetId;
+      rptLabel = "done";
+    }
+    else
+    {
+      selId = kEndpointAckSelNetId;
+      rptLabel = "ep ack";
+    }
+   
   }
-
-  if( np->state != expectedState )
+  else
   {
-    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;
+    msgLabel = ep->label;
+    msgId    = ep->id;
   }
 
-  np->state = nextState;
+  // notify the remote node that all endpoints have been sent
+  if((rc = _cmRtNetSendSyncMsg(p,np,selId,msgLabel,msgId )) != kOkNetRC )
+    rc = cmErrMsg(&p->err,rc,"Send '%s' to %s:%s:%i failed.",rptLabel,cmStringNullGuard(np->label),cmStringNullGuard(np->addr),np->port);
+  else
+    _cmRtNetRpt(p,"Sent %s.\n",cmStringNullGuard(rptLabel));
 
-  // if we are about to send another endpoint - incr the endpoint index
-  if( nextState == kSendEndpointStNetId )
-    np->epIdx += 1;
+  np->endPtIdx += 1;
 
- errLabel:
   return rc;
+  
 }
 
-
-cmRtNetRC_t  cmRtNetSyncModeRecv( cmRtNetH_t h, const char* data, unsigned dataByteCnt, const struct sockaddr_in* fromAddr )
+// When the network message recieve function (See cmRtNetAlloc() 'cbFunc') 
+// receives a message with the cmRtSysMsgHdr_t.selId == kNetSyncSelRtId
+// it should call this function to update the current sync state of the
+// cmRtNet.
+cmRtNetRC_t  _cmRtNetSyncModeRecv( cmRtNet_t* p, const char* data, unsigned dataByteCnt, const struct sockaddr_in* fromAddr )
 {
-  cmRtNet_t*       p  = _cmRtNetHandleToPtr(h);
   cmRtNetRC_t      rc = kOkNetRC;
-  cmRtNetNode_t*   np = NULL;
   cmRtNetSyncMsg_t m;
-
-  m.endPtLabel = NULL;
+  m.label = NULL;
 
   assert( cmRtNetIsSyncModeMsg(data,dataByteCnt));
   
 
   assert( m.hdr.selId == kNetSyncSelRtId );
 
+  // attempt to locate the remote node which sent the msg
+  cmRtNetNode_t* np = _cmRtNetFindNodeFromSockAddr(p,fromAddr);
+
   switch( m.selId )
   {
-    
-    case kHelloSelNetId: // slave response
+    case kHelloSelNetId:    
+    case kNodeSelNetId: 
       {
-        _cmRtNetRpt(p,"rcv hello\n");
-
-        // attempt to locate the remote node which sent the endpoint 
-        if((np = _cmRtNetFindNodeFromSockAddr(p,fromAddr)) != NULL )
+        // if the node already exists ...
+        if( np != NULL )
         {
-          // delete the existing node because we are about to get new info. about it.
+          // ... delete it because we are about to get new info. about it.
           if((rc =  _cmRtNetReleaseNode(p,np )) != kOkNetRC )
             goto errLabel;
         }
 
         //  create a node proxy to represent the remote node
-        if(( rc = _cmRtNetCreateNode(p,m.endPtLabel,NULL,0,fromAddr,kRecvNodeNetFl)) != kOkNetRC )
-          goto errLabel;
+        // (Note:m.id == remote node endpoint count (i.e. the count of endpoints expected for the remote node.))
+        if(( rc = _cmRtNetCreateNode(p,m.label,NULL,0,fromAddr,0,m.id)) != kOkNetRC )
+          goto errLabel;        
 
-        // send an ackknowledgement of the 'hello' msg
-        rc = _cmRtNetSendAck(p,kHelloAckSelNetId,fromAddr);
+        // send response
+        switch( m.selId )
+        {
+          case kHelloSelNetId:
+            _cmRtNetRpt(p,"rcv hello\n"); // reply with local node
+            rc = _cmRtNetSendSyncMsg( p, np, kNodeSelNetId, NULL, p->localNode->endPtCnt );
+            break;
+
+          case kNodeSelNetId:
+            _cmRtNetRpt(p,"rcv node\n");
+            _cmRtNetSendEndpointReplyMsg( p, np ); // reply with first endpoint
+            break;
+
+          default:
+            assert(0);
+        }
 
       }
       break;
 
     
-    case kEndpointSelNetId: // slave response
+    case kEndpointAckSelNetId:
+    case kDoneSelNetId:
+      rc = _cmRtNetSendEndpointReplyMsg(p,np);
+      break;
+
+    case kEndpointSelNetId: 
       {
         cmRtNetEnd_t* ep;
 
-        _cmRtNetRpt(p,"rcv endpoint\n");
 
-        // locate the remote node which sent the endpoint
-        if((np = _cmRtNetFindNodeFromSockAddr(p,fromAddr)) == NULL )
+        // verify the remote node exists.
+        if( np == NULL )
         {
           rc = cmErrMsg(&p->err,kNodeNotFoundNetRC,"The net node associated with an endpoint receive was not found.");
           goto errLabel;
         }
         
         // attempt to find the end point 
-        if((ep = _cmRtNetFindNodeEnd(np,m.endPtLabel)) != NULL )
-          ep->endPtId = m.endPtId; // the endpoint was found update the endPtId
+        if((ep = _cmRtNetFindNodeEnd(np,m.label)) != NULL )
+          ep->id = m.id; // the endpoint was found update the endPtId
         else
         {
           // create a local proxy for the endpoint
-          if((rc = _cmRtNetCreateEndpoint(p,np,m.endPtLabel,m.endPtId)) != kOkNetRC )
+          if((rc = _cmRtNetCreateEndpoint(p,np,m.label,m.id)) != kOkNetRC )
             goto errLabel;
         }
 
-        // ack. the endpoint msg
-        rc = _cmRtNetSendAck(p,kEndpointAckSelNetId,fromAddr);
-      }
-      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);
-      }
-      break;
-
-    case kEndpointAckSelNetId: // master response
-      {
-        assert( p->syncModeFl );  
-        _cmRtNetRpt(p,"rcv endpoint ack\n");
-        rc = _cmRtNetRecvAck(p,fromAddr,kWaitEndpointAckStNetId,kSendEndpointStNetId);
+        // reply with a local endpoint or 'done' msg
+        rc = _cmRtNetSendEndpointReplyMsg( p, np );
       }
       break;
 
     default:
+      assert(0);
       break;
   }
 
  errLabel:
 
-  cmMemFree((cmChar_t*)m.endPtLabel);
+  cmMemFree((cmChar_t*)m.label);
   return rc;
 }
 
+void _cmRtNetRecv( void* cbArg, const char* data, unsigned dataByteCnt, const struct sockaddr_in* fromAddr )
+{
+  cmRtNet_t* p = (cmRtNet_t*)cbArg;
+  
+  if( cmRtNetIsSyncModeMsg(data,dataByteCnt))
+    _cmRtNetSyncModeRecv(p,data,dataByteCnt,fromAddr);
+  else
+    p->cbFunc(p->cbArg,data,dataByteCnt,fromAddr);
+  
+}
+
+
 
-cmRtNetRC_t _cmRtNetSendNodeSync( cmRtNet_t* p, cmRtNetNode_t* np )
+cmRtNetRC_t cmRtNetRegisterLocalNode( cmRtNetH_t h, const cmChar_t* nodeLabel, const cmChar_t* ipAddr, cmUdpPort_t port )
 {
-  cmRtNetRC_t rc = kOkNetRC;
+  cmRtNet_t*  p = _cmRtNetHandleToPtr(h);
+  cmRtNetRC_t rc;
+  struct sockaddr_in sockaddr;
+
+  // release the local node
+  if( p->localNode != NULL )
+  {    
+    _cmRtNetReleaseNode(p,p->localNode);
+    p->localNode = NULL;
+  }
 
-  switch( np->state )
+  // if this is the local node then initialze the local socket
+  if( cmUdpInit(p->udpH,port,kNonBlockingUdpFl,_cmRtNetRecv,p,NULL,0,p->udpRecvBufByteCnt,p->udpTimeOutMs) != kOkUdpRC )
   {
-    case kSendHelloStNetId:
-      {
-        np->epIdx = -1;
+    rc = cmErrMsg(&p->err,kUdpPortFailNetRC,"The UDP port initialization failed.");
+    goto errLabel;
+  }
 
-        // 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;
+  // get the socket address
+  if( cmUdpInitAddr(p->udpH, ipAddr, port, &sockaddr ) != kOkUdpRC )
+  {
+    rc = cmErrMsg(&p->err,kUdpPortFailNetRC,"IP::port to socket address conversion failed.");
+    goto errLabel;
+  }
 
-    case kSendEndpointStNetId:
-      {
-        cmRtNetEnd_t* ep;
+  // create the local node
+  if((rc = _cmRtNetCreateNode(p,nodeLabel, ipAddr, port, &sockaddr, kLocalNodeNetFl, 0)) != kOkNetRC )
+    goto errLabel;
 
-        // if all of the endpoints have been sent to this node ...
-        if((ep = _cmRtNetIndexToEndpoint(p,p->localNode,np->epIdx)) == NULL )
-        {
-          // 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,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,"%s sent endpoint %s\n",cmStringNullGuard(np->label),cmStringNullGuard(ep->endPtLabel));
+  // the last created node is always the first node on the list
+  p->localNode = p->nodes;
 
-        }
-      }
-      break;
+  // begin listening on the local port
+  if( cmUdpEnableListen(p->udpH, true ) != kOkUdpRC )
+  {
+    rc = cmErrMsg(&p->err,kUdpPortFailNetRC,"The UDP port failed to enter 'listen' mode.");
+    goto errLabel;
+  }
 
-    case kWaitHelloAckStNetId:
-    case kWaitEndpointAckStNetId:
-      {
-        cmTimeSpec_t t;
-        cmTimeGet(&t);
-        unsigned twentySecs = 20000000;
-        if( cmTimeElapsedMicros(&np->lastSendTime,&t) > twentySecs)
-        {
-          const cmChar_t* ackStr = np->state==kWaitHelloAckStNetId ? "hello" : "endpoint";
-          rc = cmErrMsg(&p->err,kTimeOutErrNetRC,"The node %s:%s:%i did not give a '%s' acknowledge.",cmStringNullGuard(np->label),cmStringNullGuard(np->addr),np->port,ackStr);         
-        }
-      }
-      break;
 
-    default:
-      break;
-  }
-      
-  // if an error occurred put the node into an error state
-  if( rc != kOkNetRC )
-    np->state = kErrorStNetId;
-      
+ errLabel:
   return rc;
 }
 
-
-
-cmRtNetRC_t cmRtNetSyncModeSend( cmRtNetH_t h )
+cmRtNetRC_t cmRtNetRegisterEndPoint( cmRtNetH_t h, const cmChar_t* endPtLabel, unsigned endPtId )
 {
   cmRtNetRC_t rc = kOkNetRC;
-  cmRtNet_t*  p  = _cmRtNetHandleToPtr(h);
+  cmRtNet_t* p = _cmRtNetHandleToPtr(h);
 
-  if( p->syncModeFl == false )
-    return rc;
-  
-  unsigned     activeCnt = 0;
-  cmRtNetNode_t* np        = p->nodes;
-  for(; np != NULL; np=np->link )
-  {
-    bool fl = (p->masterFl && cmIsFlag(np->flags,kRegNodeNetFl)) || (p->masterFl==false && cmIsFlag(np->flags,kRecvNodeNetFl));
+  if( p->localNode == NULL )
+    return cmErrMsg(&p->err,kLocalNodeNetRC,"Local endpoints may not be added if a local node has not been defined.");
 
-    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");
-  }
+  if((rc = _cmRtNetCreateEndpoint(p, p->localNode,endPtLabel,endPtId )) == kOkNetRC )
+    p->localNode->endPtCnt += 1;
 
   return rc;
 }
 
+cmRtNetRC_t cmRtNetClearAll( cmRtNetH_t h )
+{
+  cmRtNet_t* p = _cmRtNetHandleToPtr(h);
+  _cmRtNetReleaseNodes(p);
+  return kOkNetRC;
+}
+
+cmRtNetRC_t cmRtNetBeginSyncMode( cmRtNetH_t h )
+{
+  cmRtNet_t* p = _cmRtNetHandleToPtr(h);
+
+  // broadcast 'node' msg
+  return _cmRtNetSendSyncMsg( p, p->localNode, kHelloSelNetId, NULL, p->localNode->endPtCnt );
+}
+
+
 
 cmRtNetRC_t cmRtNetReceive( cmRtNetH_t h )
 {
   cmRtNet_t* p = _cmRtNetHandleToPtr(h);
   cmRpt_t* rpt = p->err.rpt;
 
-  cmRptPrintf(rpt,"Sync Mode:%s\n",p->syncModeFl ? "ON" : "OFF");
 
   cmRtNetNode_t* np = p->nodes;
   for(; np!=NULL; np=np->link)
     if( np->addr != NULL )
       cmRptPrintf(rpt,"%s ",np->addr );
 
-    if( cmIsFlag(np->flags,kLocalNetFl) )
+    if( cmIsFlag(np->flags,kLocalNodeNetFl) )
       cmRptPrintf(rpt,"LOCAL ");
 
-    if( cmIsFlag(np->flags,kSockAddrNetFl) )
-      cmRptPrintf(rpt,"%s ",cmStringNullGuard(cmUdpAddrToString(p->udpH,&np->sockaddr)));
+    cmRptPrintf(rpt,"%s ",cmStringNullGuard(cmUdpAddrToString(p->udpH,&np->sockaddr)));
 
     if( np->port != cmInvalidId )
       cmRptPrintf(rpt,"%i ",np->port );
     cmRtNetEnd_t* ep = np->ends;
     for(; ep!=NULL; ep=ep->link)
     {
-      cmRptPrintf(rpt,"  endpt: %i %s\n",ep->endPtId,cmStringNullGuard(ep->endPtLabel));
+      cmRptPrintf(rpt,"  endpt: %i %s\n",ep->id,cmStringNullGuard(ep->label ));
     }
   }
 }
 
 void _cmRtNetTestRecv( void* cbArg, const char* data, unsigned dataByteCnt, const struct sockaddr_in* fromAddr )
 {
-  _cmRtNetTest_t* p = (_cmRtNetTest_t*)cbArg;
+  //_cmRtNetTest_t* p = (_cmRtNetTest_t*)cbArg;
 
-  if( cmRtNetIsSyncModeMsg(data,dataByteCnt))
-    cmRtNetSyncModeRecv(p->netH,data,dataByteCnt,fromAddr);
 
 }
 
 
   if( cmRtNetIsValid(p->netH) )
   {
-    if( cmRtNetIsInSyncMode(p->netH) )
-      cmRtNetSyncModeSend(p->netH);
-
     cmRtNetReceive(p->netH);
   }
 
   cmRtNetRC_t     rc   = kOkNetRC;
   memset(&t,0,sizeof(t));
 
-
   if( cmThreadCreate(&p->thH,_cmRtNetTestThreadFunc,p,&ctx->rpt) != kOkThRC )
     goto errLabel;
 
   if( hostNameStr == NULL )
     hostNameStr = "<no-host-name>";
 
-  if((rc = cmRtNetCreateNode(p->netH, hostNameStr, NULL, port )) != kOkNetRC)
+  if((rc = cmRtNetRegisterLocalNode(p->netH, hostNameStr, NULL, port )) != kOkNetRC)
     goto errLabel;
 
   if( mstrFl )
   {
-    if((rc = cmRtNetCreateNode(p->netH,"whirl", "192.168.15.109", port )) != kOkNetRC )
-      goto errLabel;
-
     if((rc = cmRtNetRegisterEndPoint(p->netH,"thunk_ep0", 0 )) != kOkNetRC )
       goto errLabel;
 

cmRtNet.h

   // Set 'ipAddr' to NULL if this is the local node.
   // During sync mode this node will attempt to sync with all
   // nodes in the node list.
-  cmRtNetRC_t cmRtNetCreateNode( cmRtNetH_t h, const cmChar_t* nodeLabel, const cmChar_t* ipAddr, cmUdpPort_t ipPort );
+  cmRtNetRC_t cmRtNetRegisterLocalNode( cmRtNetH_t h, const cmChar_t* nodeLabel, const cmChar_t* ipAddr, cmUdpPort_t ipPort );
 
 
   // Register the local endpoints.
   // an endpoint it updates it's own remote node/endpoint 
   // list.
   cmRtNetRC_t cmRtNetBeginSyncMode( cmRtNetH_t h );
-  bool        cmRtNetIsInSyncMode(  cmRtNetH_t h );
 
-  // When the network message recieve function (See cmRtNetAlloc() 'cbFunc') 
-  // receives a message with the cmRtSysMsgHdr_t.selId == kNetSyncSelRtId
-  // it should call this function to update the current sync state of the
-  // cmRtNet.
-  cmRtNetRC_t  cmRtNetSyncModeRecv( cmRtNetH_t h, const char* data, unsigned dataByteCnt, const struct sockaddr_in* fromAddr );
-
-  
-  // When in the network is in sync mode (cmRtNetIsSync()==true) 
-  // the client system must poll this function to update the networks sync state.
-  cmRtNetRC_t cmRtNetSyncModeSend( cmRtNetH_t h );
 
   // This function must be polled to receive incoming network messages
   // via the callback funcion 'cbFunc' as passed to cmRtNetAlloc()
        
 
    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
-
+     1.  A: on init bcast 'hello'
+     2.  B: on 'hello'     -  create node-A w/ ei=0      - send 'node'
+     3.  A: on 'node'      -  create node-B w/ ei=0      - send first 'endpt'
+     4.  B: on 'endpt'     -  create endpt on node-A     - ei!=en ? send 'endpt' or send 'done'
+     5.  A: on 'endpt'     -  create endpt on node-B     - ei!=en ? send 'endpt' or send 'done'
+     6.  B: on 'done'      -  mark node-A as 'valid'
+     7.  A: on 'done'      -  mark node-B as 'valid'.
 
    */