void sig_handler()
{
/*Reset signal handlers for portability*/
isignal(SIGTERM, sig_handler);
isignal(SIGINT, sig_handler);
/*Shutdown event polling loop*/
running=0;
/*Interrupt cfdp_get_event()*/
cfdp_interrupt();
}
static void shutDownAmsd()
{
int stop = 0;
isignal(SIGINT, shutDownAmsd);
oK(_amsdRunning(&stop));
}
static int run_sdatest(uvast destEngineId)
{
SenderThreadParms parms;
pthread_t senderThread;
isignal(SIGTERM, interruptThread);
if (destEngineId)
{
/* Must start sender thread. */
parms.destEngineId = destEngineId;
parms.running = 1;
if (pthread_begin(&senderThread, NULL, sendItems, &parms))
{
putSysErrmsg("sdatest can't create send thread", NULL);
return 1;
}
}
if (sda_run(getLengthOfItem, handleItem) < 0)
{
putErrmsg("sdatest sda_run failed.", NULL);
}
if (destEngineId)
{
parms.running = 0;
pthread_join(senderThread, NULL);
}
writeErrmsgMemos();
writeMemo("[i] sdatest main thread has ended.");
ionDetach();
return 0;
}
static void handleQuit()
{
BptestState *state;
isignal(SIGINT, handleQuit);
PUTS("BP reception interrupted.");
state = _bptestState(NULL);
bp_interrupt(state->sap);
state->running = 0;
}
static void interruptThread()
{
pthread_t mainThread = brssclaMainThread(0);
isignal(SIGTERM, interruptThread);
if (mainThread != pthread_self())
{
pthread_kill(mainThread, SIGTERM);
}
}
int pmqlsi(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *mqName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *mqName = (argc > 1 ? argv[1] : NULL);
#endif
LtpVdb *vdb;
struct mq_attr mqAttributes =
{ 0, PMQLSA_MAXMSG, PMQLSA_MSGSIZE, 0 };
ReceiverThreadParms rtp;
pthread_t receiverThread;
char stop = '0';
if (mqName == NULL)
{
puts("Usage: pmqlsi <message queue name>");
return 0;
}
/* Note that ltpadmin must be run before the first
* invocation of ltplsi, to initialize the LTP database
* (as necessary) and dynamic database. */
if (ltpInit(0, 0) < 0)
{
putErrmsg("pmqlsi can't initialize LTP.", NULL);
return 1;
}
vdb = getLtpVdb();
if (vdb->lsiPid > 0 && vdb->lsiPid != sm_TaskIdSelf())
{
putErrmsg("LSI task is already started.", itoa(vdb->lsiPid));
return 1;
}
/* All command-line arguments are now validated. */
rtp.mq = mq_open(mqName, O_RDWR | O_CREAT, 0777, &mqAttributes);
if (rtp.mq == (mqd_t) -1)
{
putSysErrmsg("pmglsi can't open message queue", mqName);
return 1;
}
/* Set up signal handling; SIGTERM is shutdown signal. */
isignal(SIGTERM, interruptThread);
/* Start the receiver thread. */
rtp.running = 1;
rtp.mainThread = pthread_self();
if (pthread_create(&receiverThread, NULL, handleMessages, &rtp))
{
mq_close(rtp.mq);
putSysErrmsg("pmqlsi can't create receiver thread", NULL);
return 1;
}
/* Now sleep until interrupted by SIGTERM, at which point
* it's time to stop the link service. */
writeMemo("[i] pmqlsi is running");
snooze(2000000000);
/* Time to shut down. */
rtp.running = 0;
mq_send(rtp.mq, &stop, 1, 0); /* Tell receiver to stop. */
pthread_join(receiverThread, NULL);
mq_close(rtp.mq);
writeErrmsgMemos();
writeMemo("[i] pmqlsi duct has ended.");
return 0;
}
static void interruptThread()
{
isignal(SIGTERM, interruptThread);
}
static void interruptThread()
{
isignal(SIGTERM, interruptThread);
ionKillMainThread("brsscla");
}
int bpcp(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
/*a1 is the debug flag*/
debug=atoi((char*)a1);
/*a2 is the version option*/
if(atoi((char*)a2)==1)
{
version();
return 0;
}
{
#else
int main(int argc, char **argv)
{
int ch;
/*Parse commandline options*/
while ((ch = getopt(argc, argv, "dv")) != -1)
{
switch (ch)
{
case 'd':
/*Debug*/
debug++;
break;
case 'v':
version();
break;
default:
usage();
}
}
#endif
/*Initialize CFDP*/
if (cfdp_attach() < 0)
{
dbgprintf(0, "Error: Can't initialize CFDP. Is ION running?\n");
exit(1);
}
running=1;
#ifdef SIG_HANDLER
/*Set SIGTERM and SIGINT handlers*/
isignal(SIGTERM, sig_handler);
isignal(SIGINT, sig_handler);
#endif
poll_cfdp_messages();
#ifdef CLEAN_ON_EXIT
#if defined (VXWORKS) || defined (RTEMS)
/*DO NOTHING. VXWORKS doesn't implement system()!*/
#else
/*Cleanup all directory listing files*/
if (system("rm dirlist_* >/dev/null 2>/dev/null")<0)
{
dbgprintf(0, "Error running cleanup\n");
}
#endif
#endif
exit(0);
}
/*CFDP Event Polling loop*/
void poll_cfdp_messages()
{
char *eventTypes[] = {
"no event",
"transaction started",
"EOF sent",
"transaction finished",
"metadata received",
"file data segment received",
"EOF received",
"suspended",
"resumed",
"transaction report",
"fault",
"abandoned"
};
CfdpEventType type;
time_t time;
int reqNbr;
CfdpTransactionId transactionId;
char sourceFileNameBuf[256];
char destFileNameBuf[256];
unsigned int fileSize;
MetadataList messagesToUser;
unsigned int offset;
unsigned int length;
CfdpCondition condition;
unsigned int progress;
CfdpFileStatus fileStatus;
CfdpDeliveryCode deliveryCode;
CfdpTransactionId originatingTransactionId;
char statusReportBuf[256];
unsigned char usrmsgBuf[256];
MetadataList filestoreResponses;
uvast TID11;
uvast TID12;
/*Main Event loop*/
while (running) {
/*Grab a CFDP event*/
if (cfdp_get_event(&type, &time, &reqNbr, &transactionId,
sourceFileNameBuf, destFileNameBuf,
&fileSize, &messagesToUser, &offset, &length,
&condition, &progress, &fileStatus,
&deliveryCode, &originatingTransactionId,
statusReportBuf, &filestoreResponses) < 0)
{
dbgprintf(0, "Error: Failed getting CFDP event.", NULL);
exit(1);
}
if (type == CfdpNoEvent)
{
continue; /* Interrupted. */
}
/*Decompress transaction ID*/
cfdp_decompress_number(&TID11,&transactionId.sourceEntityNbr);
cfdp_decompress_number(&TID12,&transactionId.transactionNbr);
/*Print Event type if debugging*/
dbgprintf(1,"\nEvent: type %d, '%s', From Node: %ull, Transaction ID: %ull.%ull.\n", type,
(type > 0 && type < 12) ? eventTypes[type]
: "(unknown)",TID11, TID11, TID12);
/*Parse Messages to User to get directory information*/
while (messagesToUser)
{
/*Get user message*/
memset(usrmsgBuf, 0, 256);
if (cfdp_get_usrmsg(&messagesToUser, usrmsgBuf,
(int *) &length) < 0)
{
putErrmsg("Failed getting user msg.", NULL);
continue;
}
/*Set Null character at end of string*/
if (length > 0)
{
usrmsgBuf[length] = '\0';
dbgprintf(2,"\tUser Message '%s'\n", usrmsgBuf);
}
}
}
return;
}
int udpclo(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
#else
int main(int argc, char *argv[])
{
#endif
unsigned char *buffer;
VOutduct *vduct;
PsmAddress vductElt;
Sdr sdr;
Outduct outduct;
ClProtocol protocol;
Outflow outflows[3];
int i;
char *hostName;
unsigned short portNbr;
unsigned int hostNbr;
struct sockaddr socketName;
struct sockaddr_in *inetName;
Object bundleZco;
BpExtendedCOS extendedCOS;
char destDuctName[MAX_CL_DUCT_NAME_LEN + 1];
unsigned int bundleLength;
int ductSocket = -1;
int bytesSent;
if (bpAttach() < 0)
{
putErrmsg("udpclo can't attach to BP.", NULL);
return -1;
}
buffer = MTAKE(UDPCLA_BUFSZ);
if (buffer == NULL)
{
putErrmsg("No memory for UDP buffer in udpclo.", NULL);
return -1;
}
findOutduct("udp", "*", &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such udp duct.", "*");
MRELEASE(buffer);
return -1;
}
if (vduct->cloPid > 0 && vduct->cloPid != sm_TaskIdSelf())
{
putErrmsg("CLO task is already started for this duct.",
itoa(vduct->cloPid));
MRELEASE(buffer);
return -1;
}
/* All command-line arguments are now validated. */
sdr = getIonsdr();
sdr_read(sdr, (char *) &outduct, sdr_list_data(sdr, vduct->outductElt),
sizeof(Outduct));
sdr_read(sdr, (char *) &protocol, outduct.protocol, sizeof(ClProtocol));
if (protocol.nominalRate <= 0)
{
vduct->xmitThrottle.nominalRate = DEFAULT_UDP_RATE;
}
else
{
vduct->xmitThrottle.nominalRate = protocol.nominalRate;
}
memset((char *) outflows, 0, sizeof outflows);
outflows[0].outboundBundles = outduct.bulkQueue;
outflows[1].outboundBundles = outduct.stdQueue;
outflows[2].outboundBundles = outduct.urgentQueue;
for (i = 0; i < 3; i++)
{
outflows[i].svcFactor = 1 << i;
}
/* Set up signal handling. SIGTERM is shutdown signal. */
oK(udpcloSemaphore(&(vduct->semaphore)));
isignal(SIGTERM, shutDownClo);
/* Can now begin transmitting to remote duct. */
writeMemo("[i] udpclo is running.");
while (!(sm_SemEnded(vduct->semaphore)))
{
if (bpDequeue(vduct, outflows, &bundleZco, &extendedCOS,
destDuctName) < 0)
{
sm_SemEnd(udpcloSemaphore(NULL));/* Stop. */
continue;
}
if (bundleZco == 0) /* Interrupted. */
{
continue;
}
hostName = destDuctName;
parseSocketSpec(destDuctName, &portNbr, &hostNbr);
if (portNbr == 0)
{
portNbr = BpUdpDefaultPortNbr;
}
portNbr = htons(portNbr);
if (hostNbr == 0)
{
writeMemoNote("[?] Can't get IP address for host",
hostName);
}
hostNbr = htonl(hostNbr);
memset((char *) &socketName, 0, sizeof socketName);
inetName = (struct sockaddr_in *) &socketName;
inetName->sin_family = AF_INET;
inetName->sin_port = portNbr;
memcpy((char *) &(inetName->sin_addr.s_addr),
(char *) &hostNbr, 4);
bundleLength = zco_length(sdr, bundleZco);
bytesSent = sendBundleByUDP(&socketName, &ductSocket,
bundleLength, bundleZco, buffer);
if (bytesSent < bundleLength)
{
sm_SemEnd(udpcloSemaphore(NULL));/* Stop. */
continue;
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
if (ductSocket != -1)
{
close(ductSocket);
}
writeErrmsgMemos();
writeMemo("[i] udpclo duct has ended.");
MRELEASE(buffer);
ionDetach();
return 0;
}
int bsspclo(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ductName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *ductName = (argc > 1 ? argv[1] : NULL);
#endif
Sdr sdr;
VOutduct *vduct;
PsmAddress vductElt;
vast destEngineNbr;
Outduct outduct;
ClProtocol protocol;
Outflow outflows[3];
int i;
int running = 1;
Object bundleZco;
BpExtendedCOS extendedCOS;
char destDuctName[MAX_CL_DUCT_NAME_LEN + 1];
BsspSessionId sessionId;
unsigned char *buffer;
Lyst streams;
Bundle bundleImage;
char *dictionary = 0;
unsigned int bundleLength;
if (ductName == NULL)
{
PUTS("Usage: bsspclo [-]<destination engine number>");
return 0;
}
if (bpAttach() < 0)
{
putErrmsg("bsspclo can't attach to BP.", NULL);
return -1;
}
sdr = getIonsdr();
findOutduct("bssp", ductName, &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such bssp duct.", ductName);
return -1;
}
if (vduct->cloPid != ERROR && vduct->cloPid != sm_TaskIdSelf())
{
putErrmsg("BSSPCLO task is already started for this duct.",
itoa(vduct->cloPid));
return -1;
}
/* All command-line arguments are now validated. */
buffer = (unsigned char *) MTAKE(BP_MAX_BLOCK_SIZE);
if (buffer == NULL)
{
putErrmsg("Can't get buffer for decoding bundle ZCOs.", NULL);
return -1;
}
streams = lyst_create_using(getIonMemoryMgr());
if (streams == NULL)
{
putErrmsg("Can't create lyst of streams.", NULL);
MRELEASE(buffer);
return -1;
}
lyst_delete_set(streams, eraseStream, NULL);
CHKERR(sdr_begin_xn(sdr));
sdr_read(sdr, (char *) &outduct, sdr_list_data(sdr, vduct->outductElt),
sizeof(Outduct));
sdr_read(sdr, (char *) &protocol, outduct.protocol, sizeof(ClProtocol));
sdr_exit_xn(sdr);
destEngineNbr = strtovast(ductName);
if (protocol.nominalRate == 0)
{
vduct->xmitThrottle.nominalRate = DEFAULT_BSSP_RATE;
}
else
{
vduct->xmitThrottle.nominalRate = protocol.nominalRate;
}
memset((char *) outflows, 0, sizeof outflows);
outflows[0].outboundBundles = outduct.bulkQueue;
outflows[1].outboundBundles = outduct.stdQueue;
outflows[2].outboundBundles = outduct.urgentQueue;
for (i = 0; i < 3; i++)
{
outflows[i].svcFactor = 1 << i;
}
if (bssp_attach() < 0)
{
putErrmsg("bsspclo can't initialize BSSP.", NULL);
lyst_destroy(streams);
MRELEASE(buffer);
return -1;
}
/* Set up signal handling. SIGTERM is shutdown signal. */
oK(bsspcloSemaphore(&(vduct->semaphore)));
isignal(SIGTERM, shutDownClo);
/* Can now begin transmitting to remote duct. */
writeMemo("[i] bsspclo is running.");
while (running && !(sm_SemEnded(bsspcloSemaphore(NULL))))
{
if (bpDequeue(vduct, outflows, &bundleZco, &extendedCOS,
destDuctName, 0, -1) < 0)
{
running = 0; /* Terminate CLO. */
continue;
}
if (bundleZco == 0) /* Interrupted. */
{
continue;
}
if (decodeBundle(sdr, bundleZco, buffer, &bundleImage,
&dictionary, &bundleLength) < 0)
{
putErrmsg("Can't decode bundle ZCO.", NULL);
CHKERR(sdr_begin_xn(sdr));
zco_destroy(sdr, bundleZco);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Failed destroying ZCO.", NULL);
break;
}
continue;
}
switch (bssp_send(destEngineNbr, BpBsspClientId, bundleZco,
isInOrder(streams, &bundleImage), &sessionId))
{
case 0:
putErrmsg("Unable to send this bundle via BSSP.", NULL);
break;
case -1:
putErrmsg("BsspSend failed.", NULL);
running = 0; /* Terminate CLO. */
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
/* Note: bundleZco is destroyed later, when BSSP's
* ExportSession is closed following transmission
* of bundle ZCOs as aggregated into a block. */
}
writeErrmsgMemos();
writeMemo("[i] bsspclo duct has ended.");
lyst_destroy(streams);
MRELEASE(buffer);
ionDetach();
return 0;
}
int ltpcli(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ductName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *ductName = (argc > 1 ? argv[1] : NULL);
#endif
VInduct *vduct;
PsmAddress vductElt;
ReceiverThreadParms rtp;
pthread_t receiverThread;
if (ductName == NULL)
{
PUTS("Usage: ltpcli <local engine number>]");
return 0;
}
if (bpAttach() < 0)
{
putErrmsg("ltpcli can't attach to BP.", NULL);
return -1;
}
findInduct("ltp", ductName, &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such ltp duct.", ductName);
return -1;
}
if (vduct->cliPid != ERROR && vduct->cliPid != sm_TaskIdSelf())
{
putErrmsg("CLI task is already started for this duct.",
itoa(vduct->cliPid));
return -1;
}
/* All command-line arguments are now validated. */
if (ltp_attach() < 0)
{
putErrmsg("ltpcli can't initialize LTP.", NULL);
return -1;
}
/* Set up signal handling; SIGTERM is shutdown signal. */
ionNoteMainThread("ltpcli");
isignal(SIGTERM, interruptThread);
/* Start the receiver thread. */
rtp.vduct = vduct;
rtp.running = 1;
if (pthread_begin(&receiverThread, NULL, handleNotices, &rtp))
{
putSysErrmsg("ltpcli can't create receiver thread", NULL);
return 1;
}
/* Now sleep until interrupted by SIGTERM, at which point
* it's time to stop the induct. */
writeMemo("[i] ltpcli is running.");
ionPauseMainThread(-1);
/* Time to shut down. */
rtp.running = 0;
/* Stop the receiver thread by interrupting client access. */
ltp_interrupt(BpLtpClientId);
pthread_join(receiverThread, NULL);
writeErrmsgMemos();
writeMemo("[i] ltpcli duct has ended.");
ionDetach();
return 0;
}
int ltpclock(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
#else
int main(int argc, char *argv[])
{
#endif
Sdr sdr;
LtpDB *ltpConstants;
int state = 1;
time_t currentTime;
if (ltpInit(0, 0) < 0)
{
putErrmsg("ltpclock can't initialize LTP.", NULL);
return 1;
}
sdr = getIonsdr();
ltpConstants = getLtpConstants();
isignal(SIGTERM, shutDown);
/* Main loop: wait for event occurrence time, then
* execute applicable events. */
oK(_running(&state));
writeMemo("[i] ltpclock is running.");
while (_running(NULL))
{
/* Sleep for 1 second, then dispatch all events
* whose executions times have now been reached. */
snooze(1);
currentTime = getUTCTime();
/* Infer link state changes from rate changes
* noted in the shared ION database. */
if (manageLinks(sdr, currentTime) < 0)
{
putErrmsg("Can't manage links.", NULL);
state = 0; /* Terminate loop. */
oK(_running(&state));
continue;
}
/* Then dispatch retransmission events, as
* constrained by the new link state. */
if (dispatchEvents(sdr, ltpConstants->timeline, currentTime)
< 0)
{
putErrmsg("Can't dispatch events.", NULL);
state = 0; /* Terminate loop. */
oK(_running(&state));
continue;
}
}
writeErrmsgMemos();
writeMemo("[i] ltpclock has ended.");
ionDetach();
return 0;
}
static int run_imcadmin(char *cmdFileName)
{
int cmdFile;
char line[256];
int len;
if (bpAttach() < 0)
{
putErrmsg("imcadmin can't attach to BP.", NULL);
return -1;
}
if (imcInit() < 0)
{
putErrmsg("imcadmin can't initialize IMC database.", NULL);
return -1;
}
if (cmdFileName == NULL) /* Interactive. */
{
#ifdef FSWLOGGER
return 0;
#else
cmdFile = fileno(stdin);
isignal(SIGINT, handleQuit);
while (1)
{
printf(": ");
fflush(stdout);
if (igets(cmdFile, line, sizeof line, &len) == NULL)
{
if (len == 0)
{
break;
}
putErrmsg("igets failed.", NULL);
break; /* Out of loop. */
}
if (len == 0)
{
continue;
}
if (processLine(line, len))
{
break; /* Out of loop. */
}
}
#endif
}
else /* Scripted. */
{
cmdFile = iopen(cmdFileName, O_RDONLY, 0777);
if (cmdFile < 0)
{
PERROR("Can't open command file");
}
else
{
while (1)
{
if (igets(cmdFile, line, sizeof line, &len)
== NULL)
{
if (len == 0)
{
break; /* Loop. */
}
putErrmsg("igets failed.", NULL);
break; /* Loop. */
}
if (len == 0
|| line[0] == '#') /* Comment.*/
{
continue;
}
if (processLine(line, len))
{
break; /* Out of loop. */
}
}
close(cmdFile);
}
}
writeErrmsgMemos();
printText("Stopping imcadmin.");
ionDetach();
return 0;
}
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;
}
int amsbenchs(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
int count = a1;
int size = a2;
#else
int main(int argc, char **argv)
{
int count = (argc > 1 ? atoi(argv[1]) : 0);
int size = (argc > 2 ? atoi(argv[2]) : 0);
#endif
char *buffer;
AmsModule me;
AmsEventMgt rules;
int subjectNbr;
int content;
if (count < 1 || size < sizeof(int) || size > 65535)
{
PUTS("Usage: amsbenchs <# of msgs to send> <msg length>");
return 0;
}
buffer = malloc(size);
if (buffer == NULL)
{
putErrmsg("No memory for amsbenchs.", NULL);
return 0;
}
if (size > sizeof(int))
{
memset(buffer, ' ', size - 1);
buffer[size - 1] = '\0';
}
if (ams_register("", NULL, "amsdemo", "test", "", "benchs", &me) < 0)
{
putErrmsg("amsbenchs can't register.", NULL);
return -1;
}
memset((char *) &rules, 0, sizeof(AmsEventMgt));
rules.errHandler = reportError;
if (ams_set_event_mgr(me, &rules) < 0)
{
ams_unregister(me);
putErrmsg("amsbenchs can't set event manager.", NULL);
return -1;
}
subjectNbr = ams_lookup_subject_nbr(me, "bench");
if (subjectNbr < 0)
{
ams_unregister(me);
writeMemo("[?] amsbenchs: subject 'bench' is unknown.");
return -1;
}
snooze(1); /* Wait for subscriptions to arrive. */
while (count > 0)
{
content = htonl(count);
memcpy(buffer, (char *) &content, sizeof(int));
if (ams_publish(me, subjectNbr, 0, 0, size, buffer, 0) < 0)
{
putErrmsg("amsbenchs can't publish message.", NULL);
break;
}
count--;
}
writeErrmsgMemos();
PUTS("Message publication ended; press ^C when test is done.");
isignal(SIGINT, handleQuit);
snooze(3600);
ams_unregister(me);
return 0;
}
int pmqlso(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *mqName = (char *) a1;
uvast remoteEngineId = a2 != 0 ? strtouvast((char *) a2) : 0;
#else
int main(int argc, char *argv[])
{
char *mqName = argc > 1 ? argv[1] : NULL;
uvast remoteEngineId = argc > 2 ? strtouvast(argv[2]) : 0;
#endif
Sdr sdr;
LtpVspan *vspan;
PsmAddress vspanElt;
struct mq_attr mqAttributes = { 0, PMQLSA_MAXMSG, PMQLSA_MSGSIZE, 0 };
mqd_t mq;
int running;
int segmentLength;
char *segment;
if (remoteEngineId == 0 || mqName == NULL)
{
puts("Usage: pmqlso <message queue name> <remote engine ID>");
return 0;
}
/* Note that ltpadmin must be run before the first
* invocation of ltplso, to initialize the LTP database
* (as necessary) and dynamic database. */
if (ltpInit(0) < 0)
{
putErrmsg("pmqlso can't initialize LTP.", NULL);
return 1;
}
sdr = getIonsdr();
CHKERR(sdr_begin_xn(sdr)); /* Just to lock memory. */
findSpan(remoteEngineId, &vspan, &vspanElt);
if (vspanElt == 0)
{
sdr_exit_xn(sdr);
putErrmsg("No such engine in database.", itoa(remoteEngineId));
return 1;
}
if (vspan->lsoPid > 0 && vspan->lsoPid != sm_TaskIdSelf())
{
sdr_exit_xn(sdr);
putErrmsg("LSO task is already started for this span.",
itoa(vspan->lsoPid));
return 1;
}
/* All command-line arguments are now validated. */
sdr_exit_xn(sdr);
mq = mq_open(mqName, O_RDWR | O_CREAT, 0777, &mqAttributes);
if (mq == (mqd_t) -1)
{
putSysErrmsg("pmqlso can't open message queue", mqName);
return 1;
}
oK(_pmqlsoSemaphore(&vspan->segSemaphore));
isignal(SIGTERM, interruptThread);
/* Can now begin transmitting to remote engine. */
writeMemo("[i] pmqlso is running.");
running = 1;
while (running && !(sm_SemEnded(_pmqlsoSemaphore(NULL))))
{
segmentLength = ltpDequeueOutboundSegment(vspan, &segment);
if (segmentLength < 0)
{
running = 0; /* Terminate LSO. */
continue;
}
if (segmentLength == 0) /* Interrupted. */
{
continue;
}
if (segmentLength > PMQLSA_MSGSIZE)
{
putErrmsg("Segment is too big for PMQ LSO.",
itoa(segmentLength));
running = 0; /* Terminate LSO. */
continue;
}
if (sendSegmentByPMQ(mq, segment, segmentLength) < 0)
{
putSysErrmsg("pmqlso failed sending segment", mqName);
running = 0; /* Terminate LSO. */
continue;
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
mq_close(mq);
writeErrmsgMemos();
writeMemo("[i] pmqlso duct has ended.");
ionDetach();
return 0;
}
int dtn2fw(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
#else
int main(int argc, char *argv[])
{
#endif
int running = 1;
Sdr sdr;
VScheme *vscheme;
PsmAddress vschemeElt;
Scheme scheme;
Object elt;
Object bundleAddr;
Bundle bundle;
if (bpAttach() < 0)
{
putErrmsg("dtn2fw can't attach to BP.", NULL);
return 1;
}
if (dtn2Init(NULL) < 0)
{
putErrmsg("dtn2fw can't load routing database.", NULL);
return 1;
}
sdr = getIonsdr();
findScheme("dtn", &vscheme, &vschemeElt);
if (vschemeElt == 0)
{
putErrmsg("Scheme name for dtn2 is unknown.", "dtn");
return 1;
}
CHKZERO(sdr_begin_xn(sdr));
sdr_read(sdr, (char *) &scheme, sdr_list_data(sdr,
vscheme->schemeElt), sizeof(Scheme));
sdr_exit_xn(sdr);
oK(_dtn2fwSemaphore(&vscheme->semaphore));
isignal(SIGTERM, shutDown);
/* Main loop: wait until forwarding queue is non-empty,
* then drain it. */
writeMemo("[i] dtn2fw is running.");
while (running && !(sm_SemEnded(vscheme->semaphore)))
{
/* We wrap forwarding in an SDR transaction to
* prevent race condition with bpclock (which
* is destroying bundles as their TTLs expire). */
CHKZERO(sdr_begin_xn(sdr));
elt = sdr_list_first(sdr, scheme.forwardQueue);
if (elt == 0) /* Wait for forwarding notice. */
{
sdr_exit_xn(sdr);
if (sm_SemTake(vscheme->semaphore) < 0)
{
putErrmsg("Can't take forwarder semaphore.",
NULL);
running = 0;
}
continue;
}
bundleAddr = (Object) sdr_list_data(sdr, elt);
sdr_stage(sdr, (char *) &bundle, bundleAddr, sizeof(Bundle));
sdr_list_delete(sdr, elt, NULL, NULL);
bundle.fwdQueueElt = 0;
/* Must rewrite bundle to note removal of
* fwdQueueElt, in case the bundle is abandoned
* and bpDestroyBundle re-reads it from the
* database. */
sdr_write(sdr, bundleAddr, (char *) &bundle, sizeof(Bundle));
if (enqueueBundle(&bundle, bundleAddr) < 0)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't enqueue bundle.", NULL);
running = 0; /* Terminate loop. */
continue;
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't enqueue bundle.", NULL);
running = 0; /* Terminate loop. */
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
writeErrmsgMemos();
writeMemo("[i] dtn2fw forwarder has ended.");
ionDetach();
return 0;
}
int udplsi(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *endpointSpec = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *endpointSpec = (argc > 1 ? argv[1] : NULL);
#endif
LtpVdb *vdb;
unsigned short portNbr = 0;
unsigned int ipAddress = INADDR_ANY;
struct sockaddr socketName;
struct sockaddr_in *inetName;
ReceiverThreadParms rtp;
socklen_t nameLength;
pthread_t receiverThread;
int fd;
char quit = '\0';
/* Note that ltpadmin must be run before the first
* invocation of ltplsi, to initialize the LTP database
* (as necessary) and dynamic database. */
if (ltpInit(0) < 0)
{
putErrmsg("udplsi can't initialize LTP.", NULL);
return 1;
}
vdb = getLtpVdb();
if (vdb->lsiPid != ERROR && vdb->lsiPid != sm_TaskIdSelf())
{
putErrmsg("LSI task is already started.", itoa(vdb->lsiPid));
return 1;
}
/* All command-line arguments are now validated. */
if (endpointSpec)
{
if(parseSocketSpec(endpointSpec, &portNbr, &ipAddress) != 0)
{
putErrmsg("Can't get IP/port for endpointSpec.",
endpointSpec);
return -1;
}
}
if (portNbr == 0)
{
portNbr = LtpUdpDefaultPortNbr;
}
portNbr = htons(portNbr);
ipAddress = htonl(ipAddress);
memset((char *) &socketName, 0, sizeof socketName);
inetName = (struct sockaddr_in *) &socketName;
inetName->sin_family = AF_INET;
inetName->sin_port = portNbr;
memcpy((char *) &(inetName->sin_addr.s_addr), (char *) &ipAddress, 4);
rtp.linkSocket = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (rtp.linkSocket < 0)
{
putSysErrmsg("LSI can't open UDP socket", NULL);
return -1;
}
nameLength = sizeof(struct sockaddr);
if (reUseAddress(rtp.linkSocket)
|| bind(rtp.linkSocket, &socketName, nameLength) < 0
|| getsockname(rtp.linkSocket, &socketName, &nameLength) < 0)
{
closesocket(rtp.linkSocket);
putSysErrmsg("Can't initialize socket", NULL);
return 1;
}
/* Set up signal handling; SIGTERM is shutdown signal. */
ionNoteMainThread("udplsi");
isignal(SIGTERM, interruptThread);
/* Start the receiver thread. */
rtp.running = 1;
if (pthread_begin(&receiverThread, NULL, handleDatagrams, &rtp))
{
closesocket(rtp.linkSocket);
putSysErrmsg("udplsi can't create receiver thread", NULL);
return 1;
}
/* Now sleep until interrupted by SIGTERM, at which point
* it's time to stop the link service. */
{
char txt[500];
isprintf(txt, sizeof(txt),
"[i] udplsi is running, spec=[%s:%d].",
inet_ntoa(inetName->sin_addr), ntohs(portNbr));
writeMemo(txt);
}
ionPauseMainThread(-1);
/* Time to shut down. */
rtp.running = 0;
/* Wake up the receiver thread by sending it a 1-byte
* datagram. */
fd = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (fd >= 0)
{
isendto(fd, &quit, 1, 0, &socketName, sizeof(struct sockaddr));
closesocket(fd);
}
pthread_join(receiverThread, NULL);
closesocket(rtp.linkSocket);
writeErrmsgMemos();
writeMemo("[i] udplsi has ended.");
ionDetach();
return 0;
}
static void shutDown() /* Commands forwarder termination. */
{
isignal(SIGTERM, shutDown);
sm_SemEnd(_dtn2fwSemaphore(NULL));
}
int tcpclo(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ductName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *ductName = (argc > 1 ? argv[1] : NULL);
#endif
unsigned char *buffer;
VOutduct *vduct;
PsmAddress vductElt;
Sdr sdr;
Outduct duct;
ClProtocol protocol;
Outflow outflows[3];
int i;
char *hostName;
unsigned short portNbr;
unsigned int hostNbr;
struct sockaddr socketName;
struct sockaddr_in *inetName;
int running = 1;
pthread_mutex_t mutex;
KeepaliveThreadParms parms;
ReceiveThreadParms rparms;
pthread_t keepaliveThread;
pthread_t receiverThread;
Object bundleZco;
BpExtendedCOS extendedCOS;
char destDuctName[MAX_CL_DUCT_NAME_LEN + 1];
unsigned int bundleLength;
int ductSocket = -1;
int bytesSent;
int keepalivePeriod = 0;
VInduct *viduct;
if (ductName == NULL)
{
PUTS("Usage: tcpclo <remote host name>[:<port number>]");
return 0;
}
if (bpAttach() < 0)
{
putErrmsg("tcpclo can't attach to BP", NULL);
return 1;
}
buffer = MTAKE(TCPCLA_BUFSZ);
if (buffer == NULL)
{
putErrmsg("No memory for TCP buffer in tcpclo.", NULL);
return 1;
}
findOutduct("tcp", ductName, &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such tcp duct.", ductName);
MRELEASE(buffer);
return 1;
}
if (vduct->cloPid != ERROR && vduct->cloPid != sm_TaskIdSelf())
{
putErrmsg("CLO task is already started for this duct.",
itoa(vduct->cloPid));
MRELEASE(buffer);
return 1;
}
/* All command-line arguments are now validated. */
sdr = getIonsdr();
CHKERR(sdr_begin_xn(sdr));
sdr_read(sdr, (char *) &duct, sdr_list_data(sdr, vduct->outductElt),
sizeof(Outduct));
sdr_read(sdr, (char *) &protocol, duct.protocol, sizeof(ClProtocol));
sdr_exit_xn(sdr);
if (protocol.nominalRate == 0)
{
vduct->xmitThrottle.nominalRate = DEFAULT_TCP_RATE;
}
else
{
vduct->xmitThrottle.nominalRate = protocol.nominalRate;
}
memset((char *) outflows, 0, sizeof outflows);
outflows[0].outboundBundles = duct.bulkQueue;
outflows[1].outboundBundles = duct.stdQueue;
outflows[2].outboundBundles = duct.urgentQueue;
for (i = 0; i < 3; i++)
{
outflows[i].svcFactor = 1 << i;
}
hostName = ductName;
parseSocketSpec(ductName, &portNbr, &hostNbr);
if (portNbr == 0)
{
portNbr = BpTcpDefaultPortNbr;
}
portNbr = htons(portNbr);
if (hostNbr == 0)
{
putErrmsg("Can't get IP address for host.", hostName);
MRELEASE(buffer);
return 1;
}
hostNbr = htonl(hostNbr);
memset((char *) &socketName, 0, sizeof socketName);
inetName = (struct sockaddr_in *) &socketName;
inetName->sin_family = AF_INET;
inetName->sin_port = portNbr;
memcpy((char *) &(inetName->sin_addr.s_addr), (char *) &hostNbr, 4);
if (_tcpOutductId(&socketName, "tcp", ductName) < 0)
{
putErrmsg("Can't record TCP Outduct ID for connection.", NULL);
MRELEASE(buffer);
return -1;
}
/* Set up signal handling. SIGTERM is shutdown signal. */
oK(tcpcloSemaphore(&(vduct->semaphore)));
isignal(SIGTERM, shutDownClo);
#ifndef mingw
isignal(SIGPIPE, handleConnectionLoss);
#endif
/* Start the keepalive thread for the eventual connection. */
tcpDesiredKeepAlivePeriod = KEEPALIVE_PERIOD;
parms.cloRunning = &running;
pthread_mutex_init(&mutex, NULL);
parms.mutex = &mutex;
parms.socketName = &socketName;
parms.ductSocket = &ductSocket;
parms.keepalivePeriod = &keepalivePeriod;
if (pthread_begin(&keepaliveThread, NULL, sendKeepalives, &parms))
{
putSysErrmsg("tcpclo can't create keepalive thread", NULL);
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
return 1;
}
// Returns the VInduct Object of first induct with same protocol
// as the outduct. The VInduct is required to create an acq area.
// The Acq Area inturn uses the throttle information from VInduct
// object while receiving bundles. The throttle information
// of all inducts of the same induct will be the same, so choosing
// any induct will serve the purpose.
findVInduct(&viduct,protocol.name);
if(viduct == NULL)
{
putErrmsg("tcpclo can't get VInduct", NULL);
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
return 1;
}
rparms.vduct = viduct;
rparms.bundleSocket = &ductSocket;
rparms.mutex = &mutex;
rparms.cloRunning = &running;
if (pthread_begin(&receiverThread, NULL, receiveBundles, &rparms))
{
putSysErrmsg("tcpclo can't create receive thread", NULL);
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
return 1;
}
/* Can now begin transmitting to remote duct. */
{
char txt[500];
isprintf(txt, sizeof(txt),
"[i] tcpclo is running, spec=[%s:%d].",
inet_ntoa(inetName->sin_addr),
ntohs(inetName->sin_port));
writeMemo(txt);
}
while (running && !(sm_SemEnded(tcpcloSemaphore(NULL))))
{
if (bpDequeue(vduct, outflows, &bundleZco, &extendedCOS,
destDuctName, 0, -1) < 0)
{
running = 0; /* Terminate CLO. */
continue;
}
if (bundleZco == 0) /* Interrupted. */
{
continue;
}
CHKZERO(sdr_begin_xn(sdr));
bundleLength = zco_length(sdr, bundleZco);
sdr_exit_xn(sdr);
pthread_mutex_lock(&mutex);
bytesSent = sendBundleByTCPCL(&socketName, &ductSocket,
bundleLength, bundleZco, buffer, &keepalivePeriod);
pthread_mutex_unlock(&mutex);
if(bytesSent < 0)
{
running = 0; /* Terminate CLO. */
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
writeMemo("[i] tcpclo done sending");
if (sendShutDownMessage(&ductSocket, SHUT_DN_NO, -1, &socketName) < 0)
{
putErrmsg("Sending Shutdown message failed!!",NULL);
}
if (ductSocket != -1)
{
closesocket(ductSocket);
ductSocket=-1;
}
running = 0;
pthread_join(keepaliveThread, NULL);
writeMemo("[i] tcpclo keepalive thread killed");
pthread_join(receiverThread, NULL);
writeMemo("[i] tcpclo receiver thread killed");
writeErrmsgMemos();
writeMemo("[i] tcpclo duct has ended.");
oK(_tcpOutductId(&socketName, NULL, NULL));
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
bp_detach();
return 0;
}
int ltpcounter(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
int clientId = a1;
int maxBytes = a2;
#else
int main(int argc, char **argv)
{
int clientId = (argc > 1 ? strtol(argv[1], NULL, 0) : 0);
int maxBytes = (argc > 2 ? strtol(argv[2], NULL, 0) : 0);
#endif
IonAlarm alarm = { 5, 0, showProgress, NULL };
pthread_t alarmThread;
int state = 1;
LtpNoticeType type;
LtpSessionId sessionId;
unsigned char reasonCode;
unsigned char endOfBlock;
unsigned int dataOffset;
unsigned int dataLength;
Object data;
char buffer[255];
if (clientId < 1)
{
PUTS("Usage: ltpcounter <client ID> [<max nbr of bytes>]");
PUTS(" Max nbr of bytes defaults to 2 billion.");
return 0;
}
oK(_clientId(&clientId));
if (maxBytes < 1)
{
maxBytes = 2000000000;
}
if (ltp_attach() < 0)
{
putErrmsg("ltpcounter can't initialize LTP.", NULL);
return 1;
}
if (ltp_open(_clientId(NULL)) < 0)
{
putErrmsg("ltpcounter can't open client access.",
itoa(_clientId(NULL)));
return 1;
}
ionSetAlarm(&alarm, &alarmThread);
isignal(SIGINT, handleQuit);
oK((_running(&state)));
while (_running(NULL))
{
if (ltp_get_notice(_clientId(NULL), &type, &sessionId,
&reasonCode, &endOfBlock, &dataOffset,
&dataLength, &data) < 0)
{
putErrmsg("Can't get LTP notice.", NULL);
state = 0;
oK((_running(&state)));
continue;
}
switch (type)
{
case LtpExportSessionCanceled:
isprintf(buffer, sizeof buffer, "Transmission \
canceled: source engine " UVAST_FIELDSPEC ", session %u, reason code %d.",
sessionId.sourceEngineId,
sessionId.sessionNbr, reasonCode);
writeMemo(buffer);
if (data)
{
ltp_release_data(data);
}
break;
case LtpImportSessionCanceled:
oK(_sessionsCanceled(1));
isprintf(buffer, sizeof buffer, "Reception canceled: \
source engine " UVAST_FIELDSPEC ", session %u, reason code %d.",
sessionId.sourceEngineId,
sessionId.sessionNbr, reasonCode);
writeMemo(buffer);
break;
case LtpRecvGreenSegment:
isprintf(buffer, sizeof buffer, "Green segment \
received, discarded: source engine " UVAST_FIELDSPEC ", session %u, \
offset %u, length %u, eob=%d.", sessionId.sourceEngineId, sessionId.sessionNbr,
dataOffset, dataLength, endOfBlock);
writeMemo(buffer);
ltp_release_data(data);
break;
case LtpRecvRedPart:
oK(_blocksReceived(1));
oK(_bytesReceived(dataLength));
ltp_release_data(data);
break;
default:
break;
}
if (_bytesReceived(0) >= maxBytes)
{
state = 0;
oK((_running(&state)));
}
}
ionCancelAlarm(alarmThread);
writeErrmsgMemos();
printCount();
PUTS("Stopping ltpcounter.");
ltp_close(_clientId(NULL));
ltp_detach();
return 0;
}
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;
}
static void interruptThread()
{
isignal(SIGTERM, interruptThread);
ionKillMainThread("udplsi");
}
void handleConnectionLoss()
{
isignal(SIGPIPE, handleConnectionLoss);
}
int bpclock(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
#else
int main(int argc, char *argv[])
{
#endif
Sdr sdr;
BpDB *bpConstants;
int state = 1;
time_t currentTime;
if (bpAttach() < 0)
{
putErrmsg("bpclock can't attach to BP.", NULL);
return 1;
}
sdr = getIonsdr();
bpConstants = getBpConstants();
isignal(SIGTERM, shutDown);
/* Main loop: wait for event occurrence time, then
* execute applicable events. */
oK(_running(&state));
writeMemo("[i] bpclock is running.");
while (_running(NULL))
{
/* Sleep for 1 second, then dispatch all events
* whose executions times have now been reached. */
snooze(1);
currentTime = getUTCTime();
if (dispatchEvents(sdr, bpConstants->timeline, currentTime) < 0)
{
putErrmsg("Can't dispatch events.", NULL);
state = 0; /* Terminate loop. */
oK(_running(&state));
continue;
}
/* Also adjust throttles in response to rate
* changes noted in the shared ION database. */
if (adjustThrottles() < 0)
{
putErrmsg("Can't adjust throttles.", NULL);
state = 0; /* Terminate loop. */
oK(_running(&state));
continue;
}
/* Then apply rate control. */
applyRateControl(sdr);
}
writeErrmsgMemos();
writeMemo("[i] bpclock has ended.");
ionDetach();
return 0;
}
int bpcp(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
int t;
char* argv[5];
int argc;
/*Initialize CFDP*/
ion_cfdp_init();
/*Recursive flag is a1*/
iamrecursive = atoi((char*)a1);
if(iamrecursive!=0 && iamrecursive!=1)
{
iamrecursive=0;
}
/*Pretty progress meter always disabled*/
showprogress=0;
/*Lifetime is a2. a2=0 results in default lifetime.*/
t=strtol((char*)a2, NULL, 10);
if (t > 0)
{
parms.utParms.lifespan=t;
}
/*Custody Switch is a3. 1=ON, 0=OFF*/
t = atoi((char*)a3);
if(t==1)
{
parms.utParms.custodySwitch = SourceCustodyRequired;
}
else
{
if(t==0)
{
parms.utParms.custodySwitch = NoCustodyRequested;
}
}
/*Class of Service is a4.*/
t=strtol((char*)a4, NULL, 10);
if (t>=0 && t <= 2)
{
parms.utParms.classOfService=t;
}
/*Debug flag is a5.*/
debug=atoi((char*)a5);
if(debug>0)
{
version();
}
/*a6-a10 are files to copy/destinations*/
argc=0;
if((char*)a6!=NULL)
{
argv[argc]=(char*)a6;
argc++;
}
if((char*)a7!=NULL)
{
argv[argc]=(char*)a7;
argc++;
}
if((char*)a8!=NULL)
{
argv[argc]=(char*)a8;
argc++;
}
if((char*)a9!=NULL)
{
argv[argc]=(char*)a9;
argc++;
}
if((char*)a10!=NULL)
{
argv[argc]=(char*)a10;
argc++;
}
#else
int main(int argc, char **argv)
{
int ch;
extern char *optarg;
extern int optind;
int tmpoption;
/*Initialize CFDP*/
ion_cfdp_init();
/*Parse commandline options*/
while ((ch = getopt(argc, argv, "dqrL:C:S:v")) != -1)
{
switch (ch)
{
case 'r':
/*Recursive*/
iamrecursive = 1;
break;
case 'd':
/*Debug*/
debug++;
break;
case 'v':
/*Print Version info*/
version();
break;
case 'q':
/*Quiet*/
showprogress = 0;
break;
case 'L':
/*Lifetime*/
tmpoption=-1;
tmpoption=strtol(optarg, NULL, 10);
if (tmpoption > 0)
{
parms.utParms.lifespan=tmpoption;
}
else
{
dbgprintf(0, "Error: Invalid BP Lifetime\n");
exit_nicely(1);
}
break;
case 'C':
/*Custody Transfer*/
if (strcmp(optarg, "Yes")==0 ||
strcmp(optarg, "YES")==0 ||
strcmp(optarg, "yes")==0 ||
strcmp(optarg, "y")==0 ||
strcmp(optarg, "On")==0 ||
strcmp(optarg, "ON")==0 ||
strcmp(optarg, "on")==0 ||
strcmp(optarg, "1")==0)
{
parms.utParms.custodySwitch = SourceCustodyRequired;
}
else
{
if (strcmp(optarg, "No")==0 ||
strcmp(optarg, "NO")==0 ||
strcmp(optarg, "yes")==0 ||
strcmp(optarg, "n")==0 ||
strcmp(optarg, "Off")==0 ||
strcmp(optarg, "OFF")==0 ||
strcmp(optarg, "off")==0 ||
strcmp(optarg, "0")==0)
{
parms.utParms.custodySwitch = NoCustodyRequested;
}
else
{
dbgprintf(0, "Error: Invalid Custody Transfer Setting\n");
}
}
break;
case 'S':
/*Class of Service*/
tmpoption=-1;
tmpoption=strtol(optarg, NULL, 10);
if (tmpoption>=0 && tmpoption <= 2)
{
parms.utParms.classOfService=tmpoption;
} else {
dbgprintf(0, "Error: Invalid BP Class of Service\n");
exit_nicely(1);
}
break;
default:
usage();
}
}
argc -= optind;
argv += optind;
#endif
char *targ;
/*Initialize tmp file array*/
memset(tmp_files,0, NUM_TMP_FILES*255);
#ifdef SIG_HANDLER
/*Set SIGTERM and SIGINT handlers*/
isignal(SIGTERM, handle_sigterm);
isignal(SIGINT, handle_sigterm);
#endif
/*Additional argument checks*/
if (!isatty(STDOUT_FILENO))
{
showprogress = 0;
}
if (argc < 2)
{
usage();
}
if (argc > 2)
{
/*We are moving multiple files, destination must be a directory*/
targetshouldbedirectory = 1;
}
/*Connect to CFDP*/
if (cfdp_attach() < 0)
{
dbgprintf(0, "Error: Can't initialize CFDP. Is ION running?\n");
exit(1);
}
/*Create receiver thread*/
events_sem=sm_SemCreate(SM_NO_KEY, SM_SEM_FIFO);
if (events_sem==SM_SEM_NONE || sm_SemTake(events_sem)<0)
{
dbgprintf(0, "Error: Can't create semaphore\n");
exit(1);
}
recv_running=1;
if (pthread_begin(&rcv_thread, NULL, &rcv_msg_thread, (void*)&recv_running))
{
dbgprintf(0, "Error: Can't start message thread\n");
sm_SemDelete(events_sem);
exit(1);
}
/*Parse Paths*/
if ((targ = remote_path(argv[argc - 1])))
{
/* Last path is remote path
* Destination is remote host*/
toremote(targ, argc, argv);
}
else
{
/*Destination is localhost*/
if (targetshouldbedirectory)
{
/*If we are moving multiple files, check that destination
* is directory*/
if (is_dir(argv[argc - 1]))
{
tolocal(argc, argv);
}
else
{
dbgprintf(0, "Error: Destination is not a directory\n");
exit_nicely(1);
}
}
else
{
/*Single file copy*/
tolocal(argc, argv);
}
}
exit_nicely(0);
return 0;
}
static void shutDownClo() /* Commands CLO termination. */
{
isignal(SIGTERM, shutDownClo);
sm_SemEnd(tcpcloSemaphore(NULL));
}
int stcpclo(int a1, int a2, int a3, int a4, int a5,
int a6, int a7, int a8, int a9, int a10)
{
char *ductName = (char *) a1;
#else
int main(int argc, char *argv[])
{
char *ductName = (argc > 1 ? argv[1] : NULL);
#endif
unsigned char *buffer;
VOutduct *vduct;
PsmAddress vductElt;
Sdr sdr;
Outduct duct;
ClProtocol protocol;
Outflow outflows[3];
int i;
char *hostName;
unsigned short portNbr;
unsigned int hostNbr;
struct sockaddr socketName;
struct sockaddr_in *inetName;
int running = 1;
pthread_mutex_t mutex;
KeepaliveThreadParms parms;
pthread_t keepaliveThread;
Object bundleZco;
BpExtendedCOS extendedCOS;
char destDuctName[MAX_CL_DUCT_NAME_LEN + 1];
unsigned int bundleLength;
int ductSocket = -1;
int bytesSent;
if (ductName == NULL)
{
PUTS("Usage: stcpclo <remote host name>[:<port number>]");
return 0;
}
if (bpAttach() < 0)
{
putErrmsg("stcpclo can't attach to BP.", NULL);
return -1;
}
buffer = MTAKE(TCPCLA_BUFSZ);
if (buffer == NULL)
{
putErrmsg("No memory for TCP buffer in stcpclo.", NULL);
return -1;
}
findOutduct("stcp", ductName, &vduct, &vductElt);
if (vductElt == 0)
{
putErrmsg("No such stcp duct.", ductName);
MRELEASE(buffer);
return -1;
}
if (vduct->cloPid > 0 && vduct->cloPid != sm_TaskIdSelf())
{
putErrmsg("CLO task is already started for this duct.",
itoa(vduct->cloPid));
MRELEASE(buffer);
return -1;
}
/* All command-line arguments are now validated. */
sdr = getIonsdr();
sdr_read(sdr, (char *) &duct, sdr_list_data(sdr, vduct->outductElt),
sizeof(Outduct));
sdr_read(sdr, (char *) &protocol, duct.protocol, sizeof(ClProtocol));
if (protocol.nominalRate <= 0)
{
vduct->xmitThrottle.nominalRate = DEFAULT_TCP_RATE;
}
else
{
vduct->xmitThrottle.nominalRate = protocol.nominalRate;
}
memset((char *) outflows, 0, sizeof outflows);
outflows[0].outboundBundles = duct.bulkQueue;
outflows[1].outboundBundles = duct.stdQueue;
outflows[2].outboundBundles = duct.urgentQueue;
for (i = 0; i < 3; i++)
{
outflows[i].svcFactor = 1 << i;
}
hostName = ductName;
parseSocketSpec(ductName, &portNbr, &hostNbr);
if (portNbr == 0)
{
portNbr = BpTcpDefaultPortNbr;
}
portNbr = htons(portNbr);
if (hostNbr == 0)
{
putErrmsg("Can't get IP address for host.", hostName);
MRELEASE(buffer);
return -1;
}
hostNbr = htonl(hostNbr);
memset((char *) &socketName, 0, sizeof socketName);
inetName = (struct sockaddr_in *) &socketName;
inetName->sin_family = AF_INET;
inetName->sin_port = portNbr;
memcpy((char *) &(inetName->sin_addr.s_addr), (char *) &hostNbr, 4);
/* Set up signal handling. SIGTERM is shutdown signal. */
oK(stcpcloSemaphore(&(vduct->semaphore)));
isignal(SIGTERM, shutDownClo);
isignal(SIGPIPE, handleConnectionLoss);
/* Start the keepalive thread for the eventual connection. */
parms.cloRunning = &running;
pthread_mutex_init(&mutex, NULL);
parms.mutex = &mutex;
parms.socketName = &socketName;
parms.ductSocket = &ductSocket;
if (pthread_create(&keepaliveThread, NULL, sendKeepalives, &parms))
{
putSysErrmsg("stcpclo can't create keepalive thread", NULL);
MRELEASE(buffer);
pthread_mutex_destroy(&mutex);
return 1;
}
/* Can now begin transmitting to remote duct. */
writeMemo("[i] stcpclo is running.");
while (!(sm_SemEnded(stcpcloSemaphore(NULL))))
{
if (bpDequeue(vduct, outflows, &bundleZco, &extendedCOS,
destDuctName) < 0)
{
sm_SemEnd(stcpcloSemaphore(NULL));/* Stop. */
continue;
}
if (bundleZco == 0) /* Interrupted. */
{
continue;
}
bundleLength = zco_length(sdr, bundleZco);
pthread_mutex_lock(&mutex);
bytesSent = sendBundleByTCP(&socketName, &ductSocket,
bundleLength, bundleZco, buffer);
pthread_mutex_unlock(&mutex);
if (bytesSent < bundleLength)
{
sm_SemEnd(stcpcloSemaphore(NULL));/* Stop. */
continue;
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
running = 0; /* Terminate keepalive. */
pthread_join(keepaliveThread, NULL);
if (ductSocket != -1)
{
close(ductSocket);
}
pthread_mutex_destroy(&mutex);
writeErrmsgMemos();
writeMemo("[i] stcpclo duct has ended.");
MRELEASE(buffer);
ionDetach();
return 0;
}
