libcm/cmUdpNet.c

#include "cmPrefix.h"
#include "cmGlobal.h"
#include "cmRpt.h"
#include "cmErr.h"
#include "cmCtx.h"
#include "cmMem.h"
#include "cmMallocDebug.h"
#include "cmUdpPort.h"
#include "cmJson.h"
#include "cmUdpNet.h"
#include "cmTime.h"

typedef struct cmUdpNode_str
{
  cmChar_t*             label;
  unsigned              id;
  struct sockaddr_in    addr;
  cmUdpPort_t           port;
  struct cmUdpNode_str* link;
} cmUdpNode_t;

typedef struct
{
  cmErr_t            err;
  cmUdpNetCallback_t cbFunc;
  void*              cbArg;
  unsigned           timeOutMs;
  unsigned           nodeId;
  cmChar_t*          nodeLabel;
  cmUdpNode_t*       list;
  cmUdpH_t           udpH;
} cmUdpNet_t;

cmUdpNetH_t cmUdpNetNullHandle = cmSTATIC_NULL_HANDLE;

cmUdpNet_t* _cmUnHandleToPtr( cmUdpNetH_t h )
{
  cmUdpNet_t* p = (cmUdpNet_t*)h.h;
  assert(p !=NULL );
  return p;
}

cmUnRC_t _cmUdpNetFinal( cmUdpNet_t* p )
{
  // release the node list
  while( p->list != NULL)
  {
    cmUdpNode_t* np = p->list->link;
    cmMemFree(p->list->label);
    cmMemFree(p->list);
    p->list = np;
  }
 
  cmMemFree(p->nodeLabel);

  p->nodeLabel = NULL;
  p->cbFunc    = NULL;
  p->cbArg     = NULL;
  p->nodeId    = cmInvalidId;

  return kOkUnRC;
}

cmUnRC_t _cmUdpNetFree( cmUdpNet_t* p )
{
  cmUnRC_t rc;
  if((rc = _cmUdpNetFinal(p)) != kOkUnRC )
    return rc;
  
  // release the UDP port
  if( cmUdpFree(&p->udpH) != kOkUdpRC )
    return cmErrMsg(&p->err,kUdpPortFailUnRC,"The UDP port release failed.");

  cmMemFree(p);
  return kOkUnRC;
}


cmUdpNode_t* _cmUnFindLabel( cmUdpNet_t* p, const cmChar_t* label )
{
  cmUdpNode_t* np = p->list;
  for(; np != NULL; np = np->link )
    if( strcmp(np->label,label) == 0 )
      return np;

  return NULL;
}

cmUdpNode_t* _cmUnFindId( cmUdpNet_t* p, unsigned id )
{
  cmUdpNode_t* np = p->list;
  for(; np != NULL; np = np->link )
    if( np->id == id )
      return np;

  return NULL;
}

void _cmUdpNetCallback( void* cbArg, const char* data, unsigned dataByteCnt, const struct sockaddr_in* fromAddr )
{
  cmUdpNet_t* p = (cmUdpNet_t*)cbArg;
  
  if( p->cbFunc != NULL )
  {
    cmUdpNetH_t h;
    cmUdpNode_t* np = p->list;
    h.h = p;

    // locate the source node in the node list to get the source node id
    for(; np != NULL; np = np->link)
      if( np->addr.sin_addr.s_addr == fromAddr->sin_addr.s_addr )
      {
        // forward the call to the networks callback function
        p->cbFunc(p->cbArg,h,data,dataByteCnt,np->id);
        break;
      }

    if( np == NULL )
      cmErrMsg(&p->err,kNodeNotFoundUnRC,"A callback source node could not be identified.");

  }    
}

cmUnRC_t cmUdpNetAlloc(cmCtx_t* ctx,  cmUdpNetH_t*  hp)
{
  cmUnRC_t rc;
  if((rc = cmUdpNetFree(hp)) != kOkUnRC )
    return rc;

  cmUdpNet_t* p = cmMemAllocZ(cmUdpNet_t,1);

  cmErrSetup(&p->err,&ctx->rpt,"UDP Network");

  if( cmUdpAlloc(ctx,&p->udpH) != kOkUdpRC )
    return cmErrMsg(&p->err,kUdpPortFailUnRC,"UDP port allocation failed.");

  p->nodeId = cmInvalidId;
  hp->h = p;

  return kOkUnRC;
}

cmUnRC_t cmUdpNetAllocJson( 
  cmCtx_t*           ctx, 
  cmUdpNetH_t*       hp,
  cmJsonH_t          jsH,
  cmUdpNetCallback_t cbFunc,
  void*              cbArg,
  unsigned           flags)
{
  cmUnRC_t rc;

  if((rc = cmUdpNetAlloc(ctx,hp)) != kOkUnRC )
    return rc;

  if((rc = cmUdpNetInitJson(*hp,jsH,cbFunc,cbArg)) != kOkUnRC )
  {
    if( cmIsFlag(flags,kNetOptionalUnFl) )
      rc = kOkUnRC;

    goto errLabel;
  }

  if((rc = cmUdpNetEnableListen(*hp,cmIsFlag(flags,kListenUnFl))) != kOkUnRC )
    goto errLabel;

 errLabel:
  if( rc != kOkUnRC )
    cmUdpNetFree(hp);

  return rc;
}


cmUnRC_t cmUdpNetFree( cmUdpNetH_t* hp )
{
  cmUnRC_t rc = kOkUnRC;

  if( hp == NULL || cmUdpNetIsValid(*hp)==false )
    return kOkUnRC;

  cmUdpNet_t* p = _cmUnHandleToPtr(*hp);

  if((rc = _cmUdpNetFree(p)) != kOkUnRC )
    return rc;

  hp->h = NULL;

  return rc;
}


cmUnRC_t cmUdpNetInit( 
  cmUdpNetH_t         h,  
  const cmChar_t*     nodeLabel,
  unsigned            nodeId,
  cmUdpPort_t         nodeSocketPort,
  cmUdpNetCallback_t  cbFunc,
  void*               cbArg,
  unsigned            recvBufByteCnt,
  unsigned            socketRecvTimeOutMs )
{
  cmUnRC_t rc;
  cmUdpNet_t* p = _cmUnHandleToPtr(h);

  if((rc = _cmUdpNetFinal(p)) != kOkUnRC )
    return rc;

  // create the UDP port
  if( cmUdpInit(p->udpH,nodeSocketPort,kBlockingUdpFl,_cmUdpNetCallback,p,NULL,0,recvBufByteCnt,socketRecvTimeOutMs) != kOkUdpRC )
  {
    rc = cmErrMsg(&p->err,kUdpPortFailUnRC,"The UDP port create failed.");
    goto errLabel;
  }

  p->cbFunc    = cbFunc;
  p->cbArg     = cbArg;
  p->timeOutMs = socketRecvTimeOutMs;
  p->nodeId    = nodeId;
  p->nodeLabel = cmMemAllocStr(nodeLabel);
  p->list      = NULL;

 errLabel:

  if( rc != kOkUnRC )
    _cmUdpNetFinal(p);
  
  return rc;
}

cmUnRC_t _cmUnParseMemberErr( cmUdpNet_t* p, cmJsRC_t jsRC, const cmChar_t* errLabel, const cmChar_t* objectLabel )
{
  if( jsRC == kNodeNotFoundJsRC && errLabel != NULL )
    return cmErrMsg(&p->err,kJsonFailUnRC,"The required field '%s'was not found in the UDP network resource tree in the object '%s'.",errLabel,cmStringNullGuard(objectLabel));

  return cmErrMsg(&p->err,kJsonFailUnRC,"JSON parsing failed on the UDP network resource object '%s'.",cmStringNullGuard(objectLabel));

}


cmUnRC_t cmUdpNetInitJson( 
  cmUdpNetH_t        h, 
  cmJsonH_t          jsH,
  cmUdpNetCallback_t cbFunc,
  void*              cbArg)
{
  cmUnRC_t        rc;
  cmUdpNet_t*     p           = _cmUnHandleToPtr(h);
  cmJsonNode_t*   unp;
  cmJsonNode_t*   nap;
  const cmChar_t* errLabelPtr = NULL;
  cmJsRC_t        jsRC;
  unsigned        port,recvBufByteCnt,timeOutMs;
  const cmChar_t* localLabel;
  const cmChar_t* topLabel = "udpnet";
  unsigned        nodeCnt  = 0;
  unsigned        i;

  typedef struct
  {
    const cmChar_t* label;
    const cmChar_t* addr;
    unsigned        id;    
  } unNode_t;

  unNode_t* a = NULL;

  unNode_t* localPtr = NULL;

  if((rc = _cmUdpNetFinal(p)) != kOkUnRC )
    return rc;

  if((unp = cmJsonFindValue(jsH,topLabel,NULL,kObjectTId )) == NULL )
  {
    return cmErrMsg(&p->err,kJsonFailUnRC,"The JSON 'udpnet' element was not found.");
  }
  if(( jsRC = cmJsonMemberValues( unp, &errLabelPtr, 
        "port",           kIntTId,   &port,
        "recvBufByteCnt", kIntTId,   &recvBufByteCnt,
        "timeOutMs",      kIntTId,   &timeOutMs,
        "local",          kStringTId,&localLabel,
        "nodeArray",      kArrayTId, &nap,
        NULL )) != kOkJsRC )
  {
    rc = _cmUnParseMemberErr(p, jsRC, errLabelPtr, topLabel );
    goto errLabel;
  }

  
  // get a count of the number of nodes
  if((nodeCnt = cmJsonChildCount(nap)) == 0 )
  {
    rc = cmErrMsg(&p->err,kJsonFailUnRC,"The JSON 'udpnet' node array appears to be empty.");
    goto errLabel;
  }

  // allocate a temporary array to hold the node list
  a = cmMemAllocZ(unNode_t,nodeCnt);

  // for each remote node
  for(i=0; i<nodeCnt; ++i)
  {
    const cmJsonNode_t* naep = cmJsonArrayElementC(nap,i);

    // read the JSON recd
    if(( jsRC = cmJsonMemberValues( naep, &errLabelPtr, 
          "label", kStringTId, &a[i].label,
          "id",    kIntTId,    &a[i].id,
          "addr",  kStringTId, &a[i].addr,
          NULL )) != kOkJsRC )
    {
      rc = _cmUnParseMemberErr(p, jsRC, errLabelPtr, "nodeArray" );
      goto errLabel;
    }
    
    // track which node is the local node
    if( strcmp(localLabel,a[i].label) == 0 )
      localPtr = a + i;
  }

  // if no local node was located
  if( localPtr == NULL )
  {
    rc = cmErrMsg(&p->err, kJsonFailUnRC,"The local node label '%s' was not found.",cmStringNullGuard(localLabel));
    goto errLabel;
  }

  // initialize the network object
  if((rc = cmUdpNetInit(h,localPtr->label, localPtr->id, port, cbFunc, cbArg, recvBufByteCnt, timeOutMs )) != kOkUnRC )
    goto errLabel;

  // register each remote node
  for(i=0; i<nodeCnt; ++i)
    if( a + i != localPtr )
      if((rc = cmUdpNetRegisterRemote(h,a[i].label,a[i].id,a[i].addr,port)) != kOkUnRC )
        goto errLabel;
    
 errLabel:
  cmMemFree(a);

  if( rc != kOkUnRC )
    _cmUdpNetFinal(p);
  
  return rc;
}

bool cmUdpNetIsInitialized( cmUdpNetH_t h )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);
  return p->nodeId != cmInvalidId;
}

cmUnRC_t cmUdpNetFinal( cmUdpNetH_t h )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);
  return _cmUdpNetFinal(p);
}

cmUnRC_t cmUdpNetEnableListen( cmUdpNetH_t h, bool enableFl )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);

  if( cmUdpEnableListen(p->udpH,enableFl) != kOkUdpRC )
    return cmErrMsg(&p->err,kUdpPortFailUnRC,"UDP port listen %s failed.",enableFl?"enable":"disable");

  return kOkUnRC;
}

bool     cmUdpNetIsValid( cmUdpNetH_t h )
{ return h.h != NULL; }

unsigned        cmUdpNetLocalNodeId( cmUdpNetH_t h )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);
  return p->nodeId;
}

const cmChar_t* cmUdpNetLocalNodeLabel( cmUdpNetH_t h )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);
  return p->nodeLabel;
}

unsigned   cmUdpNetNodeLabelToId( cmUdpNetH_t h, const cmChar_t* label )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);

  // if the network was not initialized then nodeLabel == NULL
  if( p->nodeLabel == NULL )
    return cmInvalidId;

  // if 'label' refers to the local node
  if( strcmp(label,p->nodeLabel) == 0 )
    return p->nodeId;

  // otherwise search the remote node list
  cmUdpNode_t* np = p->list;
  for(; np != NULL; np = np->link )
    if( strcmp(np->label,label) == 0 )
      return np->id;

  return cmInvalidId;
}

const cmChar_t*   cmUdpNetNodeIdToLabel( cmUdpNetH_t h, unsigned id )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);

  // if 'id' refers to the local node
  if( id == p->nodeId )
    return p->nodeLabel;

  // otherwise search the remote node list
  cmUdpNode_t* np = p->list;
  for(; np != NULL; np = np->link )
    if( np->id == id )
      return np->label;

  return NULL;
}

unsigned        cmUdpNetNodeCount( cmUdpNetH_t h )
{
  unsigned     cnt = 0;
  cmUdpNet_t*  p   = _cmUnHandleToPtr(h);
  cmUdpNode_t* np  = p->list;
  for(; np != NULL; np = np->link )
    ++cnt;

  return cnt;
}

unsigned        cmUdpNetNodeId(    cmUdpNetH_t h, unsigned nodeIdx )
{
  unsigned     cnt = 0;
  cmUdpNet_t*  p   = _cmUnHandleToPtr(h);
  cmUdpNode_t* np  = p->list;

  for(; np != NULL; np = np->link )
    if( cnt == nodeIdx )
      return np->id;

  return cmInvalidId;

}


cmUnRC_t cmUdpNetRegisterRemote( 
  cmUdpNetH_t h, 
  const cmChar_t* remoteNodeLabel,
  unsigned        remoteNodeId,
  const char*     remoteNodeSockAddr,
  cmUdpPort_t     remoteNodePort )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);
  struct sockaddr_in addr;

  if( remoteNodeLabel == NULL || strlen(remoteNodeLabel)==0 )
    return cmErrMsg(&p->err,kInvalidNodeLabelUnRC,"The node label must contain a non-empty string.");

  if( _cmUnFindLabel(p,remoteNodeLabel) != NULL )
    return cmErrMsg(&p->err,kDuplicateNodeLabelUnRC,"The node label '%s' is already in use.",cmStringNullGuard(remoteNodeLabel));

  if( _cmUnFindId(p,remoteNodeId) != NULL )
    return cmErrMsg(&p->err,kDuplicateNodeIdUnRC,"The node id '%i' is already in use.",remoteNodeId);

  if( cmUdpInitAddr(p->udpH, remoteNodeSockAddr, remoteNodePort, &addr ) != kOkUdpRC )
    return cmErrMsg(&p->err,kInvalidNodeAddrUnRC,"The node address '%s' port:%i  is not valid.",cmStringNullGuard(remoteNodeSockAddr),remoteNodePort);

  cmUdpNode_t* np = cmMemAllocZ(cmUdpNode_t,1);

  np->label = cmMemAllocStr(remoteNodeLabel);
  np->id    = remoteNodeId;
  np->addr  = addr;
  np->port  = remoteNodePort;
  np->link  = p->list;
  p->list   = np;

  return kOkUnRC;
}

cmUnRC_t cmUdpNetSendById(    cmUdpNetH_t h, unsigned remoteNodeId, const void* data, unsigned dataByteCnt )
{
  cmUdpNet_t*     p = _cmUnHandleToPtr(h);
  cmUdpNode_t* np;
  
  if((np = _cmUnFindId(p,remoteNodeId)) == NULL )
    return cmErrMsg(&p->err,kNodeNotFoundUnRC,"The remote node (id=%i) was not found.",remoteNodeId);

  if( cmUdpSendTo(p->udpH, data, dataByteCnt, &np->addr ) != kOkUdpRC )
    return cmErrMsg(&p->err,kSendFailUnRC,"An attempt to send to a remote node with id=%i failed.",remoteNodeId);

  return kOkUnRC;
}

cmUnRC_t cmUdpNetSendByLabel( cmUdpNetH_t h, const cmChar_t* remoteNodeLabel, const void* data, unsigned dataByteCnt )
{
  cmUdpNet_t*     p = _cmUnHandleToPtr(h);
  cmUdpNode_t* np;
  
  if((np = _cmUnFindLabel(p,remoteNodeLabel)) == NULL )
    return cmErrMsg(&p->err,kNodeNotFoundUnRC,"The remote node (label=%s) was not found.",cmStringNullGuard(remoteNodeLabel));

  if( cmUdpSendTo(p->udpH, data, dataByteCnt, &np->addr ) != kOkUdpRC )
    return cmErrMsg(&p->err,kSendFailUnRC,"An attempt to send to the remote node labeled:%s failed.",cmStringNullGuard(remoteNodeLabel));

  return kOkUnRC;
}

cmUnRC_t cmUdpNetReceive(  cmUdpNetH_t h, unsigned* msgCntPtr )
{
  cmUnRC_t rc        = kOkUnRC;
  unsigned maxMsgCnt = 0;
  unsigned msgCnt    = 0;

  if( msgCntPtr == NULL )
    maxMsgCnt = cmInvalidCnt;
  else
    maxMsgCnt = *msgCntPtr;

  cmUdpNet_t* p = _cmUnHandleToPtr(h);
  if( cmUdpIsValid(p->udpH ) )
  {
    for(msgCnt=0; (maxMsgCnt==cmInvalidCnt || msgCnt<maxMsgCnt) && cmUdpAvailDataByteCount(p->udpH); ++msgCnt )
    {
      if( cmUdpGetAvailData(p->udpH,NULL,NULL,NULL) != kOkUdpRC )
      {
        rc = cmErrMsg(&p->err,kGetDataFailUnRC,"An attempt to get available message data failed.");
        break;
      }
    }
  }

  if( msgCntPtr != NULL )
    *msgCntPtr = msgCnt;

  return rc;
}

cmUnRC_t cmUdpNetPrintNodes( cmUdpNetH_t h, cmRpt_t* rpt )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);
  cmUdpNode_t* np = p->list;
  unsigned i;
  for(i=0; np != NULL; np = np->link, ++i )
    cmRptPrintf(rpt,"%5i %5i %s\n",i,np->id,np->label);

  return kOkUnRC;
}

void cmUdpNetReport( cmUdpNetH_t h, cmRpt_t* rpt )
{
  cmUdpNet_t* p = _cmUnHandleToPtr(h);
  cmUdpReport(p->udpH,rpt);
  
}

//=========================================================================================
typedef struct
{
  cmTimeSpec_t t;
  unsigned     localNodeId;
  cmUdpNetH_t  h;
} _cmUdpNetTestMsg_t;

void _cmUdpNetTestCb( void* cbArg, cmUdpNetH_t h, const char* data, unsigned dataByteCnt, unsigned remoteNodeId )
{
  cmRpt_t* rpt = (cmRpt_t*)cbArg;
  cmRptPrintf(rpt,"recv - id:%i %s\n",remoteNodeId, data);
}

void _cmUdpNetTestCb2( void* cbArg, cmUdpNetH_t h, const char* data, unsigned dataByteCnt, unsigned remoteNodeId )
{
  _cmUdpNetTestMsg_t* m = (_cmUdpNetTestMsg_t*)data;
  cmRpt_t* rpt = (cmRpt_t*)cbArg;

  assert( dataByteCnt == sizeof(_cmUdpNetTestMsg_t));

  if( m->localNodeId == cmUdpNetLocalNodeId(h) )
  {
    cmTimeSpec_t t;
    cmTimeGet(&t);
    cmRptPrintf(rpt,"elapsed:%i\n", cmTimeElapsedMicros(&m->t,&t));
  }
  else
  {
    cmRptPrintf(rpt,"echo\n");
    cmUdpNetSendById(h,m->localNodeId,&m,sizeof(*m));
  }
  
  
}


const cmChar_t* _cmUdpNetTestGetOpt( int argc, char* argv[], const char* opt )
{
  unsigned i;
  for(i=0; i<argc; ++i)
    if( strcmp(argv[i],opt) == 0 )
      return argv[i+1];

  return NULL;
}

cmRC_t cmUdpNetTest( cmCtx_t* ctx, int argc, char* argv[] )
{
  cmUdpNetH_t     h          = cmUdpNetNullHandle;
  cmJsonH_t       jsH        = cmJsonNullHandle;
  cmErr_t         err;
  cmRC_t          rc         = cmOkRC;
  unsigned        i          = 0;
  const cmChar_t* jsonFn;
  const cmChar_t* remoteNodeLabel;
  unsigned        strCharCnt = 31;
  cmChar_t        str[ strCharCnt + 1 ];
  bool            msgFl = false;

  enum { kUdpNetTestErrRC    = 1 };
  
  cmErrSetup(&err,&ctx->rpt,"UDP Net Test");

  // get the JSON file name
  if(( jsonFn = _cmUdpNetTestGetOpt(argc,argv,"-j")) == NULL)
    return cmErrMsg(&err,kUdpNetTestErrRC,"No JSON file name was given.");

  // get the remote node label to send too 
  if(( remoteNodeLabel= _cmUdpNetTestGetOpt(argc,argv,"-n")) == NULL )
    return cmErrMsg(&err,kUdpNetTestErrRC,"No remote node label was given.");

  // create the JSON tree
  if( cmJsonInitializeFromFile(&jsH, jsonFn, ctx ) != kOkJsRC )
  {
    rc = cmErrMsg(&err,kUdpNetTestErrRC,"JSON file init failed on '%s'.",cmStringNullGuard(jsonFn));
    goto errLabel;
  }


  if( msgFl )
  {
    // alloc/init and put the network into listening mode
    if( cmUdpNetAllocJson(ctx,&h,jsH,_cmUdpNetTestCb2,&ctx->rpt,kListenUnFl) != kOkUnRC )
    {
      rc = cmErrMsg(&err,kUdpNetTestErrRC,"UDP alloc/init/listen failed.");
      goto errLabel;
    }
  }
  else
  {
    if( cmUdpNetAlloc(ctx,&h) != kOkUnRC )
      return cmErrMsg(&err,kUdpNetTestErrRC,"UDP alloc failed.");

    if( cmUdpNetInitJson(h,jsH,_cmUdpNetTestCb,&ctx->rpt) != kOkUnRC )
    {
      rc = cmErrMsg(&err,kUdpNetTestErrRC,"UDP net init failed.");
      goto errLabel;
    }

    if( cmUdpNetEnableListen(h,true) != kOkUnRC )
    {
      rc = cmErrMsg(&err,kUdpNetTestErrRC,"UDP listen enable failed.");
      goto errLabel;
    }
  }

  cmRptPrintf(&ctx->rpt,"s=send p=print r=report\n");

  char c;
  while((c=getchar()) != 'q')
  {
    bool promptFl = true;

    switch(c)
    {
      case 's':
        {
          // form the emessage
          snprintf(str,strCharCnt,"msg=%i",i);

          // send a message to the remote node
          if( !msgFl )
            if( cmUdpNetSendByLabel(h,remoteNodeLabel,str,strlen(str)+1 ) != kOkUnRC )
              cmErrMsg(&err,kUdpNetTestErrRC,"UDP net send failed.");

          ++i;
        }
        break;

      case 't':
        {
          _cmUdpNetTestMsg_t m;
          cmTimeGet(&m.t);
          m.localNodeId = cmUdpNetLocalNodeId(h);
          m.h           = h;

          // send a message to the remote node
          if( msgFl )
            if( cmUdpNetSendByLabel(h,remoteNodeLabel,&m,sizeof(m) ) != kOkUnRC )
              cmErrMsg(&err,kUdpNetTestErrRC,"UDP net send failed.");
        }
        break;

      case 'p':
        cmUdpNetPrintNodes(h,&ctx->rpt);
        break;

      case 'r':
        cmUdpNetReport(h,&ctx->rpt);
        break;
        
      default:
        promptFl = false;
    }

    cmUdpNetReceive(h,NULL);

    if( promptFl )
      cmRptPrintf(&ctx->rpt,"%i> ",i);
  }    

 errLabel:

  if( cmUdpNetFree(&h) != kOkUnRC )
    rc = cmErrMsg(&err,kUdpNetTestErrRC,"UDP free failed.");

  if( cmJsonFinalize(&jsH) != kOkJsRC )
    rc = cmErrMsg(&err,kUdpNetTestErrRC,"JSON final fail.");

  return rc;
  
}