BodgeMaster
/
NORM-mirror
mirror of https://github.com/USNavalResearchLaboratory/norm.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
NORM-mirror/examples/normDataRecv.cpp

256 lines
9.9 KiB
C++
Executable File
Raw Blame History

/******************************************************************************
Simple NORM_OBJECT_DATA receiver example app using the NORM API
USAGE:
normDataRecv
BUILD (Unix):
g++ -o normDataRecv normDataRecv.cpp -D_FILE_OFFSET_BITS=64 -I../include/ \
../lib/libnorm.a ../protolib/lib/libProtokit.a \
-lpthread
(for MacOS/BSD, add "-lresolv")
(for Solaris, add "-lnsl -lsocket -lresolv")
******************************************************************************/
// Notes:
// 1) The program exits once a single file has been received ...
// 2) The received file is written to the <rxCacheDirectory>
// 3) The program also will exit on <CTRL-C> from user
// 4) "normDataRecv" should be started before "normFileSend"
#include "normApi.h" // for NORM API
#include "normMessage.h"
#include "protoAddress.h" // for ProtoAddress for easy mcast test
#include <stdio.h> // for printf(), etc
#include <stdlib.h> // for srand()
#include <string.h> // for strrchr()
#include <sys/time.h> // for gettimeofday()
// Usage: normDataRecv [addr <addr>/<port>]
#include "protoBitmask.h"
void Usage()
{
fprintf(stderr, "Usage: normDataRecv [addr <addr>/<port>]\n");
}
int main(int argc, char* argv[])
{
// Initialize default parameters.
char sessionAddr[256];
strcpy(sessionAddr, "224.1.2.3");
UINT16 sessionPort = 6003;
// Parse command-line for any parameters
int i = 1;
while (i < argc)
{
if (0 == strcmp("addr", argv[1]))
{
i++;
if (i == argc)
{
fprintf(stderr, "normDataRecv error: missing \"addr\" arguments\n");
Usage();
return -1;
}
strcpy(sessionAddr, argv[i++]);
char* ptr = strchr(sessionAddr, '/');
if (NULL != ptr)
{
*ptr = '\0';
sessionPort = atoi(ptr+1);
}
}
else
{
fprintf(stderr, "normDataRecv error: invalid command \"%s\"\n", argv[i]);
Usage();
return -1;
}
}
// 1) Create a NORM API "NormInstance"
NormInstanceHandle instance = NormCreateInstance();
// 2) Create a NormSession using default "automatic" local node id
fprintf(stderr, "joining session at addr/port %s/%hu\n", sessionAddr, sessionPort);
NormSessionHandle session = NormCreateSession(instance,
sessionAddr,
sessionPort,
2);//NORM_NODE_ANY);
// NOTE: These are debugging routines available
// (not necessary for normal app use)
NormSetDebugLevel(3);
// Uncomment to turn on debug NORM message tracing
//NormSetMessageTrace(session, true);
// Uncomment to turn on some random packet loss for testing
//NormSetRxLoss(session, 10.0); // 10% packet loss
struct timeval currentTime;
gettimeofday(&currentTime, NULL);
// Uncomment to get different packet loss patterns from run to run
srand(currentTime.tv_sec); // seed random number generator
// Uncomment if unicast NACKing is desired
// (We "cheat" here and use the Protolib "ProtoAddress" class
// that NORM happens to use under the hood as well)
ProtoAddress theAddr;
theAddr.ResolveFromString(sessionAddr);
if (!theAddr.IsMulticast())
{
NormSetDefaultUnicastNack(session, true);
// Set the tx port equal to session port so sender socket
// and make it "connected" to the remote sender address (sessionAddr) and port (sessionPort+1)
// (This assumes the remote sender address/port is known (sessionAddr/sessionPort+1 in this case)
NormSetTxPort(session, sessionPort);
NormSetRxPortReuse(session, true, NULL, sessionAddr, sessionPort+1);
}
else
{
// Uncomment to allow multiple NORM processes on same session port number
//NormSetRxPortReuse(session, true, sessionAddr);
// NormSetDefaultUnicastNack(session, true);
}
// Set a big rx cache for our current testing
NormSetRxCacheLimit(session, 4096);
// 3) Start the receiver with 1 Mbyte buffer per sender
NormStartReceiver(session, 1024*1024);
struct timeval startTime, endTime; // to measure object transfer time
// 4) Enter NORM event loop
bool keepGoing = true;
while (keepGoing)
{
NormEvent theEvent;
if (!NormGetNextEvent(instance, &theEvent)) continue;
switch (theEvent.type)
{
case NORM_RX_OBJECT_NEW:
gettimeofday(&startTime, NULL);
//fprintf(stderr, "normDataRecv: NORM_RX_OBJECT_NEW event ...\n");
break;
case NORM_RX_OBJECT_INFO:
// Assume info contains '/' delimited <path/fileName> string
//fprintf(stderr, "normDataRecv: NORM_RX_OBJECT_INFO event ...\n");
if (NORM_OBJECT_DATA == NormObjectGetType(theEvent.object))
{
char dataInfo[8192];
unsigned int nameLen = NormObjectGetInfo(theEvent.object, dataInfo, 8191);
dataInfo[nameLen] = '\0';
//fprintf(stderr, "normDataRecv: info = \"%s\"\n", dataInfo);
}
break;
case NORM_RX_OBJECT_UPDATED:
{
//fprintf(stderr, "normDataRecv: NORM_RX_OBJECT_UPDATE event ...\n");
// Uncomment this stuff to monitor file receive progress
// (At high packet rates, you may want to be careful here and
// only calculate/post updates occasionally rather than for
// each and every RX_OBJECT_UPDATE event)
//NormSize objectSize = NormObjectGetSize(theEvent.object);
//NormSize completed = objectSize - NormObjectGetBytesPending(theEvent.object);
//double percentComplete = 100.0 * ((double)completed/(double)objectSize);
//fprintf(stderr, "normDataRecv: object>%p completion status %lu/%lu (%3.0lf%%)\n",
// theEvent.object, (unsigned long)completed, (unsigned long)objectSize, percentComplete);
break;
}
case NORM_RX_OBJECT_COMPLETED:
{
gettimeofday(&endTime, NULL);
//fprintf(stderr, "normDataRecv: NORM_RX_OBJECT_COMPLETED event ...\n");
unsigned int objSize = NormObjectGetSize(theEvent.object);
const char* dataPtr = NormDataAccessData(theEvent.object);
// next 3 lines are temp for normMsgr testing
// Validate that the data is complete/accurate
// a) compare data size against the size embedded in the "INFO"
char dataInfo[8192];
unsigned int nameLen = NormObjectGetInfo(theEvent.object, dataInfo, 8191);
dataInfo[nameLen] = '\0';
unsigned int dataCount, dataLen;
if (2 != sscanf(dataInfo, "NORM_OBJECT_DATA count>%u size>%u", &dataCount, &dataLen))
{
fprintf(stderr, "normDataRecv error: received NORM_OBJECT_DATA with invalid INFO?!\n");
return -1;
}
if (objSize != dataLen)
{
fprintf(stderr, "normDataRecv error: received NORM_OBJECT_DATA with bad object size?!\n");
return -1;
}
// b) check the data content
char data = *dataPtr;
for (unsigned int i = 0; i < dataLen; i++)
{
if (dataPtr[i] != data)
{
fprintf(stderr, "normDataRecv error: received bad NORM_OBJECT_DATA!\n");
return -1;
}
}
double transferTime = endTime.tv_sec - startTime.tv_sec;
if (endTime.tv_usec > startTime.tv_usec)
transferTime += 1.0e-06 * (double)(endTime.tv_usec - startTime.tv_usec);
else
transferTime -= 1.0e-06 * (double)(startTime.tv_usec - endTime.tv_usec);
double transferRate = (8.0/1000.0) * (double)objSize / transferTime;
fprintf(stderr, "normDataRecv: transfer duration %lf sec at %lf kbps\n", transferTime, transferRate);
//fprintf(stderr, "normDataRecv: object>%p count>%d size>%u data>%.64s ...\n",
// theEvent.object, dataCount, objSize, dataPtr);
// NOTE: Since we did not "retain" or "detach data" from this
// received data object, it (and its data) will be deleted upon
// the next call to "NormGetNextEvent()".
//keepGoing = false;
break;
}
case NORM_RX_OBJECT_ABORTED:
fprintf(stderr, "normDataRecv: NORM_RX_OBJECT_ABORTED event ...\n");
break;
case NORM_REMOTE_SENDER_NEW:
fprintf(stderr, "normDataRecv: NORM_REMOTE_SENDER_NEW event ...\n");
break;
case NORM_REMOTE_SENDER_ACTIVE:
fprintf(stderr, "normDataRecv: NORM_REMOTE_SENDER_ACTIVE event ...\n");
break;
case NORM_REMOTE_SENDER_INACTIVE:
fprintf(stderr, "normDataRecv: NORM_REMOTE_SENDER_INACTIVE event ...\n");
break;
default:
//fprintf(stderr, "normDataRecv: Got event type: %d\n", theEvent.type);
break;
} // end switch(theEvent.type)
}
NormStopReceiver(session);
NormDestroySession(session);
NormDestroyInstance(instance);
fprintf(stderr, "normDataRecv: Done.\n");
return 0;
} // end main()
Reference in New Issue View Git Blame Copy Permalink