int main(int argc, char **argv)
{
Sdr sdr;
Object txExtent;
Object txBundleZco;
Object txNewBundle;
BpDelivery rxDlv;
int rxContentLength;
ZcoReader rxReader;
int rxLen;
char rxContent[sizeof(testLine)];
/* Start ION */
ionstart_default_config("loopback-ltp/loopback.ionrc",
NULL,
"loopback-ltp/loopback.ltprc",
"loopback-ltp/loopback.bprc",
"loopback-ltp/loopback.ipnrc",
NULL);
/* Attach to ION */
fail_unless(bp_attach() >= 0);
sdr = bp_get_sdr();
/* Send the loopback bundle */
sdr_begin_xn(sdr);
txExtent = sdr_malloc(sdr, sizeof(testLine) - 1);
fail_unless(txExtent != 0);
sdr_write(sdr, txExtent, testLine, sizeof(testLine) - 1);
txBundleZco = zco_create(sdr, ZcoSdrSource, txExtent, 0, sizeof(testLine) - 1);
fail_unless(sdr_end_xn(sdr) >= 0 && txBundleZco != 0);
fail_unless(bp_send(NULL, testEid, NULL, 300, BP_STD_PRIORITY,
NoCustodyRequested, 0, 0, NULL, txBundleZco, &txNewBundle) > 0);
/* Receive the loopback bundle */
fail_unless(bp_open(testEid, &rxSap) >= 0);
fail_unless(bp_receive(rxSap, &rxDlv, IONTEST_DEFAULT_RECEIVE_WAIT) >= 0);
fail_unless(rxDlv.result == BpPayloadPresent);
sdr_begin_xn(sdr);
rxContentLength = zco_source_data_length(sdr, rxDlv.adu);
fail_unless(rxContentLength == sizeof(testLine) - 1);
zco_start_receiving(rxDlv.adu, &rxReader);
rxLen = zco_receive_source(sdr, &rxReader, rxContentLength,
rxContent);
fail_unless(rxLen == rxContentLength);
fail_unless(sdr_end_xn(sdr) >= 0);
bp_release_delivery(&rxDlv, 1);
bp_close(rxSap);
/* Detach from ION */
writeErrmsgMemos();
bp_detach();
/* Compare the received data */
rxContent[sizeof(rxContent) - 1] = '\0';
fail_unless(strncmp(rxContent, testLine, sizeof(testLine)) == 0);
/* Stop ION */
ionstop();
CHECK_FINISH;
}
int bpcounter(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ownEid = (char *) a1;
int maxCount = a2;
#else
int main(int argc, char **argv)
{
char *ownEid = (argc > 1 ? argv[1] : NULL);
int maxCount = (argc > 2 ? atoi(argv[2]) : 0);
#endif
BpSAP sap;
Sdr sdr;
BpDelivery dlv;
int stop = 0;
time_t startTime = 0;
int bytesReceived;
int bundlesReceived = 0;
time_t endTime;
long interval;
if (ownEid == NULL)
{
PUTS("Usage: bpcounter <own endpoint ID> [<max count>]");
return 0;
}
if (maxCount < 1)
{
maxCount = 2000000000;
}
if (bp_attach() < 0)
{
putErrmsg("Can't attach to BP.", NULL);
return 0;
}
if (bp_open(ownEid, &sap) < 0)
{
putErrmsg("Can't open own endpoint.", ownEid);
return 0;
}
oK(_bpsap(&sap));
sdr = bp_get_sdr();
bundlesReceived = 0;
bytesReceived = 0;
isignal(SIGALRM, printCount);
alarm(5);
isignal(SIGINT, handleQuit);
while (_running(NULL))
{
if (bp_receive(sap, &dlv, BP_BLOCKING) < 0)
{
putErrmsg("bpcounter bundle reception failed.", NULL);
oK(_running(&stop));
continue;
}
if (dlv.result == BpPayloadPresent)
{
if ((bundlesReceived = _bundleCount(1)) == 1)
{
startTime = time(NULL);
}
bytesReceived += zco_length(sdr, dlv.adu);
}
bp_release_delivery(&dlv, 1);
if (bundlesReceived == maxCount)
{
oK(_running(&stop));
}
}
if (bundlesReceived > 0)
{
endTime = time(NULL);
interval = endTime - startTime;
PUTMEMO("Time (seconds)", itoa(interval));
if (interval > 0)
{
PUTMEMO("Throughput (bytes per second)",
itoa(bytesReceived / interval));
}
}
bp_close(sap);
PUTMEMO("Stopping bpcounter; bundles received", itoa(bundlesReceived));
bp_detach();
return 0;
}
static void *receivePdus(void *parm)
{
RxThreadParms *parms = (RxThreadParms *) parm;
char ownEid[64];
Sdr sdr;
BpDelivery dlv;
int contentLength;
ZcoReader reader;
unsigned char *buffer;
buffer = MTAKE(CFDP_MAX_PDU_SIZE);
if (buffer == NULL)
{
putErrmsg("bputa receiver thread can't get buffer.", NULL);
parms->running = 0;
return NULL;
}
isprintf(ownEid, sizeof ownEid, "ipn:" UVAST_FIELDSPEC ".%u",
getOwnNodeNbr(), CFDP_RECV_SVC_NBR);
if (bp_open(ownEid, &(parms->rxSap)) < 0)
{
MRELEASE(buffer);
putErrmsg("CFDP can't open own 'recv' endpoint.", ownEid);
parms->running = 0;
return NULL;
}
sdr = bp_get_sdr();
writeMemo("[i] bputa input has started.");
while (parms->running)
{
if (bp_receive(parms->rxSap, &dlv, BP_BLOCKING) < 0)
{
putErrmsg("bputa bundle reception failed.", NULL);
parms->running = 0;
continue;
}
switch (dlv.result)
{
case BpEndpointStopped:
parms->running = 0;
break;
case BpPayloadPresent:
contentLength = zco_source_data_length(sdr, dlv.adu);
CHKNULL(sdr_begin_xn(sdr));
zco_start_receiving(dlv.adu, &reader);
if (zco_receive_source(sdr, &reader, contentLength,
(char *) buffer) < 0)
{
sdr_cancel_xn(sdr);
putErrmsg("bputa can't receive bundle ADU.",
itoa(contentLength));
parms->running = 0;
continue;
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("bputa can't handle bundle delivery.",
NULL);
parms->running = 0;
continue;
}
if (cfdpHandleInboundPdu(buffer, contentLength) < 0)
{
putErrmsg("bputa can't handle inbound PDU.",
NULL);
parms->running = 0;
}
break;
default:
break;
}
bp_release_delivery(&dlv, 1);
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
bp_close(parms->rxSap);
MRELEASE(buffer);
writeMemo("[i] bputa input has stopped.");
return NULL;
}
int bpecho(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ownEid = (char *) a1;
#else
int main(int argc, char **argv)
{
char *ownEid = (argc > 1 ? argv[1] : NULL);
#endif
/* Indication marks: "." for BpPayloadPresent (1),
"*" for BpReceptionTimedOut (2).
"!" for BpReceptionInterrupted (3). */
static char dlvmarks[] = "?.*!";
BpSAP sap;
Sdr sdr;
int running = 1;
char dataToSend[ADU_LEN] = "x";
Object bundleZco;
Object newBundle;
Object extent;
BpDelivery dlv;
char sourceEid[1024];
if (ownEid == NULL)
{
PUTS("Usage: bpecho <own endpoint ID>");
return 0;
}
if (bp_attach() < 0)
{
putErrmsg("Can't attach to BP.", NULL);
return 0;
}
if (bp_open(ownEid, &sap) < 0)
{
putErrmsg("Can't open own endpoint.", NULL);
return 0;
}
oK(_bpsap(&sap));
sdr = bp_get_sdr();
isignal(SIGINT, handleQuit);
while (1)
{
/* Wait for a bundle from the driver. */
while (running)
{
if (bp_receive(sap, &dlv, BP_BLOCKING) < 0)
{
bp_close(sap);
putErrmsg("bpecho bundle reception failed.",
NULL);
return 1;
}
putchar(dlvmarks[dlv.result]);
fflush(stdout);
if (dlv.result == BpReceptionInterrupted)
{
running = 0;
continue;
}
if (dlv.result == BpPayloadPresent)
{
istrcpy(sourceEid, dlv.bundleSourceEid,
sizeof sourceEid);
bp_release_delivery(&dlv, 1);
break; /* Out of reception loop. */
}
bp_release_delivery(&dlv, 1);
}
if (!running) /* Benchmark run terminated. */
{
break; /* Out of main loop. */
}
/* Now send acknowledgment bundle. */
sdr_begin_xn(sdr);
extent = sdr_malloc(sdr, ADU_LEN);
if (extent == 0)
{
sdr_cancel_xn(sdr);
putErrmsg("No space for ZCO extent.", NULL);
break; /* Out of main loop. */
}
sdr_write(sdr, extent, dataToSend, ADU_LEN);
bundleZco = zco_create(sdr, ZcoSdrSource, extent, 0, ADU_LEN);
if (sdr_end_xn(sdr) < 0 || bundleZco == 0)
{
putErrmsg("Can't create ZCO.", NULL);
break; /* Out of main loop. */
}
if (bp_send(sap, BP_BLOCKING, sourceEid, NULL, 300,
BP_STD_PRIORITY, NoCustodyRequested,
0, 0, NULL, bundleZco, &newBundle) < 1)
{
putErrmsg("bpecho can't send echo bundle.", NULL);
break; /* Out of main loop. */
}
}
bp_close(sap);
writeErrmsgMemos();
bp_detach();
return 0;
}
