static int loadMibFromRcSource(char *mibSource)
{
int sourceFile;
LoadMibState state;
char buf[256];
int length;
int result = 0;
if (*mibSource == '\0') /* Use default file name. */
{
mibSource = "mib.amsrc";
}
sourceFile = iopen(mibSource, O_RDONLY, 0777);
if (sourceFile < 0)
{
putSysErrmsg("Can't open MIB source file", mibSource);
return -1;
}
memset((char *) &state, 0, sizeof state);
state.abandoned = 0;
state.currentOperation = LoadDormant;
state.lineNbr = 0;
while (1)
{
if (igets(sourceFile, buf, sizeof(buf), &length) == NULL)
{
if (length == 0) /* End of file. */
{
break; /* Out of loop. */
}
putErrmsg("Failed reading MIB.", mibSource);
break; /* Out of loop. */
}
state.lineNbr++;
if (rcParse(&state, buf, length) < 0)
{
isprintf(buf, sizeof buf, "amsrc error at line %d.",
state.lineNbr);
writeMemo(buf);
result = -1;
break; /* Out of loop. */
}
if (state.abandoned)
{
writeMemo("[?] Abandoning MIB load.");
result = -1;
break; /* Out of loop. */
}
}
close(sourceFile);
return result;
}
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 terminateReceiverThread(ReceiverThreadParms *parms)
{
int senderSocket;
writeErrmsgMemos();
writeMemo("[i] brsscla receiver thread stopping.");
pthread_mutex_lock(parms->mutex);
if (parms->bundleSocket != -1)
{
closesocket(parms->bundleSocket);
if (parms->ductNbr != (unsigned int) -1)
{
senderSocket = parms->ductNbr - parms->baseDuctNbr;
if (parms->brsSockets[senderSocket] ==
parms->bundleSocket)
{
/* Stop sender thread transmission
* over this socket. Note: does
* not halt the sender thread. */
parms->brsSockets[senderSocket] = -1;
}
}
parms->bundleSocket = -1;
}
lyst_delete(parms->elt);
pthread_mutex_unlock(parms->mutex);
MRELEASE(parms);
}
int psm_set_root(PsmPartition partition, PsmAddress root)
{
PartitionMap *map;
int err = 0;
CHKERR(partition);
map = (PartitionMap *) (partition->space);
lockPartition(map);
if (map->directory != 0)
{
putErrmsg("Partition already has root value; erase it first.",
NULL);
err = -1;
}
else
{
if (root == 0)
{
writeMemo("[i] New partition root value is zero.");
}
map->directory = root;
}
unlockPartition(map);
return err;
}
void showUtcDelta()
{
IonVdb *ionvdb = getIonVdb();
char buffer[80];
sprintf(buffer, "[i] Delta from UTC is %d.", ionvdb->deltaFromUTC);
writeMemo(buffer);
}
static void sptracePrint(char *txt)
{
char buffer[256];
isprintf(buffer, sizeof buffer, "sptrace (pid %d) %s", sm_TaskIdSelf(),
txt);
writeMemo(buffer);
}
static void printText(char *text)
{
if(_echo(NULL))
{
writeMemo(text);
}
PUTS(text);
}
int bpstats(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
if (bp_attach() < 0)
{
putErrmsg("bpstats can't attach to BP.", NULL);
return 0;
}
writeMemo("[i] Start of statistics snapshot...");
reportAllStateStats();
writeMemo("[i] ...end of statistics snapshot.");
bp_detach();
return 0;
}
int dtn2_updateRule(char *nodeNm, char *demux, FwdDirective *directive)
{
Sdr sdr = getIonsdr();
char nodeName[SDRSTRING_BUFSZ];
Object elt;
OBJ_POINTER(Dtn2Plan, plan);
Object ruleAddr;
Dtn2Rule ruleBuf;
CHKERR(nodeNm && demux && directive);
if (*demux == '\0')
{
writeMemo("[?] Zero-length DTN2 rule demux.");
return 0;
}
if (filterNodeName(nodeName, nodeNm) < 0)
{
return 0;
}
CHKERR(sdr_begin_xn(sdr));
elt = locatePlan(nodeName, NULL);
if (elt == 0)
{
sdr_exit_xn(sdr);
writeMemoNote("[?] No plan defined for this node", nodeNm);
return 0;
}
GET_OBJ_POINTER(sdr, Dtn2Plan, plan, sdr_list_data(sdr, elt));
dtn2_findRule(nodeName, demux, plan, &ruleAddr, &elt);
if (elt == 0)
{
sdr_exit_xn(sdr);
writeMemoNote("[?] Unknown rule", demux);
return 0;
}
/* All parameters validated, okay to update the rule. */
sdr_stage(sdr, (char *) &ruleBuf, ruleAddr, sizeof(Dtn2Rule));
dtn2_destroyDirective(&ruleBuf.directive);
memcpy((char *) &ruleBuf.directive, (char *) directive,
sizeof(FwdDirective));
sdr_write(sdr, ruleAddr, (char *) &ruleBuf, sizeof(Dtn2Rule));
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't update rule.", NULL);
return -1;
}
return 1;
}
void ionProd(unsigned long fromNode, unsigned long toNode,
unsigned long xmitRate, unsigned int owlt)
{
Sdr ionsdr = _ionsdr(NULL);
time_t fromTime;
time_t toTime;
Object elt;
char textbuf[RFX_NOTE_LEN];
if (ionsdr == NULL)
{
if (ionAttach() < 0)
{
writeMemo("[?] ionProd: node not initialized yet.");
return;
}
}
fromTime = getUTCTime(); /* The current time. */
toTime = fromTime + 14400; /* Four hours later. */
elt = rfx_insert_range(fromTime, toTime, fromNode, toNode, owlt);
if (elt == 0)
{
writeMemoNote("[?] ionProd: range insertion failed.",
utoa(owlt));
return;
}
writeMemo("ionProd: range inserted.");
writeMemo(rfx_print_range(sdr_list_data(ionsdr, elt), textbuf));
elt = rfx_insert_contact(fromTime, toTime, fromNode, toNode, xmitRate);
if (elt == 0)
{
writeMemoNote("[?] ionProd: contact insertion failed.",
utoa(xmitRate));
return;
}
writeMemo("ionProd: contact inserted.");
writeMemo(rfx_print_contact(sdr_list_data(ionsdr, elt), textbuf));
}
void inferUtcDelta(char *correctUtcTimeStamp)
{
IonVdb *ionvdb = getIonVdb();
time_t correctUtcTime = readTimestampUTC(correctUtcTimeStamp, 0);
time_t clocktime = getUTCTime() + ionvdb->deltaFromUTC;
int delta = clocktime - correctUtcTime;
char buffer[80];
CHKVOID(setDeltaFromUTC(delta) == 0);
sprintf(buffer, "[i] Delta from UTC revised, is now %d.", delta);
writeMemo(buffer);
}
int dtn2_removeRule(char *nodeNm, char *demux)
{
Sdr sdr = getIonsdr();
char nodeName[SDRSTRING_BUFSZ];
Object elt;
OBJ_POINTER(Dtn2Plan, plan);
Object ruleAddr;
OBJ_POINTER(Dtn2Rule, rule);
CHKERR(nodeNm && demux);
if (*demux == '\0')
{
writeMemo("[?] Zero-length DTN2 rule demux.");
return 0;
}
if (filterNodeName(nodeName, nodeNm) < 0)
{
return 0;
}
CHKERR(sdr_begin_xn(sdr));
elt = locatePlan(nodeName, NULL);
if (elt == 0)
{
sdr_exit_xn(sdr);
writeMemoNote("[?] No plan defined for this node", nodeNm);
return 0;
}
GET_OBJ_POINTER(sdr, Dtn2Plan, plan, sdr_list_data(sdr, elt));
dtn2_findRule(nodeName, demux, plan, &ruleAddr, &elt);
if (elt == 0)
{
sdr_exit_xn(sdr);
writeMemoNote("[?] Unknown rule", demux);
return 0;
}
/* All parameters validated, okay to remove the rule. */
GET_OBJ_POINTER(sdr, Dtn2Rule, rule, ruleAddr);
dtn2_destroyDirective(&(rule->directive));
sdr_free(sdr, ruleAddr);
sdr_list_delete(sdr, elt, NULL, NULL);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't remove rule.", NULL);
return -1;
}
return 1;
}
static void noteLoadError(LoadMibState *state, char *text)
{
char buf[256];
#ifdef NOEXPAT
isprintf(buf, sizeof buf, "[?] MIB load error at line %d of file: %s",
state->lineNbr, text);
#else
XML_Parser parser = state->parser;
isprintf(buf, sizeof buf, "[?] MIB load error at line %d of file: %s",
(int) XML_GetCurrentLineNumber(parser), text);
#endif
writeMemo(buf);
state->abandoned = 1;
}
rtems_task Init(rtems_task_argument ignored)
{
puts("Inside Init(), creating configuration files.");
createIonConfigFiles();
puts("Inside Init(), spawning ION startup tasks.");
if (startDTN() < 0)
{
writeMemo("[?] Can't start ION.");
}
testLoopback();
snooze(1);
puts("Stopping ION.");
oK(stopDTN(0, 0, 0, 0, 0, 0, 0, 0, 0, 0));
puts("ION stopped.");
exit(0);
}
static void *handleMessages(void *parm)
{
/* Main loop for message reception and handling. */
ReceiverThreadParms *rtp = (ReceiverThreadParms *) parm;
int segLength;
char msgbuf[PMQLSA_MSGSIZE];
unsigned int mqp; /* Priority of rec'd msg. */
iblock(SIGTERM);
while (rtp->running)
{
segLength = mq_receive(rtp->mq, msgbuf, sizeof msgbuf, &mqp);
switch (segLength)
{
case 1: /* Normal stop. */
continue;
case -1:
putSysErrmsg("pmqlsi failed receiving msg", NULL);
pthread_kill(rtp->mainThread, SIGTERM);
rtp->running = 0;
continue;
}
if (ltpHandleInboundSegment(msgbuf, segLength) < 0)
{
putErrmsg("Can't handle inbound segment.", NULL);
pthread_kill(rtp->mainThread, SIGTERM);
rtp->running = 0;
continue;
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
writeErrmsgMemos();
writeMemo("[i] pmqlsi receiver thread has ended.");
return NULL;
}
static int ionWaitForZcoSpace(IonVdb *vdb)
{
int result;
vdb->zcoClaimants += 1;
result = sm_SemTake(vdb->zcoSemaphore);
if (result == 0)
{
if (sm_SemEnded(vdb->zcoSemaphore))
{
writeMemo("[i] ZCO space semaphore ended.");
}
else
{
vdb->zcoClaims -= 1;
result = 1;
}
}
return result;
}
static void *handleDatagrams(void *parm)
{
/* Main loop for UDP datagram reception and handling. */
ReceiverThreadParms *rtp = (ReceiverThreadParms *) parm;
char *procName = "udplsi";
char *buffer;
int segmentLength;
struct sockaddr_in fromAddr;
socklen_t fromSize;
snooze(1); /* Let main thread become interruptable. */
buffer = MTAKE(UDPLSA_BUFSZ);
if (buffer == NULL)
{
putErrmsg("udplsi can't get UDP buffer.", NULL);
ionKillMainThread(procName);
return NULL;
}
/* Can now start receiving bundles. On failure, take
* down the LSI. */
while (rtp->running)
{
fromSize = sizeof fromAddr;
segmentLength = irecvfrom(rtp->linkSocket, buffer, UDPLSA_BUFSZ,
0, (struct sockaddr *) &fromAddr, &fromSize);
switch (segmentLength)
{
case -1:
putSysErrmsg("Can't acquire segment", NULL);
ionKillMainThread(procName);
/* Intentional fall-through to next case. */
case 1: /* Normal stop. */
rtp->running = 0;
continue;
}
if (ltpHandleInboundSegment(buffer, segmentLength) < 0)
{
putErrmsg("Can't handle inbound segment.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
continue;
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
writeErrmsgMemos();
writeMemo("[i] udplsi receiver thread has ended.");
/* Free resources. */
MRELEASE(buffer);
return NULL;
}
int dtn2_addRule(char *nodeNm, char *demux, FwdDirective *directive)
{
Sdr sdr = getIonsdr();
char nodeName[SDRSTRING_BUFSZ];
Object elt;
OBJ_POINTER(Dtn2Plan, plan);
Object nextRule;
Dtn2Rule ruleBuf;
Object addr;
CHKERR(nodeNm && demux && directive);
if (*demux == '\0')
{
writeMemo("[?] Zero-length DTN2 rule demux.");
return 0;
}
if (filterNodeName(nodeName, nodeNm) < 0)
{
return 0;
}
CHKERR(sdr_begin_xn(sdr));
elt = locatePlan(nodeName, NULL);
if (elt == 0)
{
sdr_exit_xn(sdr);
writeMemoNote("[?] No plan defined for this node", nodeNm);
return 0;
}
GET_OBJ_POINTER(sdr, Dtn2Plan, plan, sdr_list_data(sdr, elt));
if (locateRule(plan, demux, &nextRule) != 0)
{
sdr_exit_xn(sdr);
writeMemoNote("[?] Duplicate rule", demux);
return 0;
}
/* All parameters validated, okay to add the rule. */
memset((char *) &ruleBuf, 0, sizeof(Dtn2Rule));
ruleBuf.demux = sdr_string_create(sdr, demux);
memcpy((char *) &ruleBuf.directive, (char *) directive,
sizeof(FwdDirective));
addr = sdr_malloc(sdr, sizeof(Dtn2Rule));
if (addr)
{
if (nextRule)
{
elt = sdr_list_insert_before(sdr, nextRule, addr);
}
else
{
elt = sdr_list_insert_last(sdr, plan->rules, addr);
}
sdr_write(sdr, addr, (char *) &ruleBuf, sizeof(Dtn2Rule));
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't add rule.", NULL);
return -1;
}
return 1;
}
static int checkNodeListParms(IonParms *parms, char *wdName,
unsigned long nodeNbr)
{
char *nodeListDir;
char nodeListFileName[265];
int nodeListFile;
int lineNbr = 0;
int lineLen;
char lineBuf[256];
unsigned long lineNodeNbr;
int lineWmKey;
char lineSdrName[MAX_SDR_NAME + 1];
char lineWdName[256];
int result;
nodeListDir = getenv("ION_NODE_LIST_DIR");
if (nodeListDir == NULL) /* Single node on machine. */
{
if (parms->wmKey == 0)
{
parms->wmKey = ION_DEFAULT_SM_KEY;
}
if (parms->wmKey != ION_DEFAULT_SM_KEY)
{
putErrmsg("Config parms wmKey != default.",
itoa(ION_DEFAULT_SM_KEY));
return -1;
}
if (parms->sdrName[0] == '\0')
{
istrcpy(parms->sdrName, ION_DEFAULT_SDR_NAME,
sizeof parms->sdrName);
}
if (strcmp(parms->sdrName, ION_DEFAULT_SDR_NAME) != 0)
{
putErrmsg("Config parms sdrName != default.",
ION_DEFAULT_SDR_NAME);
return -1;
}
return 0;
}
/* Configured for multi-node operation. */
isprintf(nodeListFileName, sizeof nodeListFileName, "%.255s%cion_nodes",
nodeListDir, ION_PATH_DELIMITER);
if (nodeNbr == 0) /* Just attaching. */
{
nodeListFile = open(nodeListFileName, O_RDONLY, 0);
}
else /* Initializing the node. */
{
nodeListFile = open(nodeListFileName, O_RDWR | O_CREAT, 00666);
}
if (nodeListFile < 0)
{
putSysErrmsg("Can't open ion_nodes file", nodeListFileName);
writeMemo("[?] Remove ION_NODE_LIST_DIR from env?");
return -1;
}
while (1)
{
if (igets(nodeListFile, lineBuf, sizeof lineBuf, &lineLen)
== NULL)
{
if (lineLen < 0)
{
close(nodeListFile);
putErrmsg("Failed reading ion_nodes file.",
nodeListFileName);
return -1;
}
break; /* End of file. */
}
lineNbr++;
if (sscanf(lineBuf, "%lu %d %31s %255s", &lineNodeNbr,
&lineWmKey, lineSdrName, lineWdName) < 4)
{
close(nodeListFile);
putErrmsg("Syntax error at line#", itoa(lineNbr));
writeMemoNote("[?] Repair ion_nodes file.",
nodeListFileName);
return -1;
}
if (lineNodeNbr == nodeNbr) /* Match. */
{
/* lineNodeNbr can't be zero (we never
* write such lines to the file), so this
* must be matching non-zero node numbers.
* So we are re-initializing this node. */
close(nodeListFile);
if (strcmp(lineWdName, wdName) != 0)
{
putErrmsg("CWD conflict at line#",
itoa(lineNbr));
writeMemoNote("[?] Repair ion_nodes file.",
nodeListFileName);
return -1;
}
if (parms->wmKey == 0)
{
parms->wmKey = lineWmKey;
}
if (parms->wmKey != lineWmKey)
{
putErrmsg("WmKey conflict at line#",
itoa(lineNbr));
writeMemoNote("[?] Repair ion_nodes file.",
nodeListFileName);
return -1;
}
if (parms->sdrName[0] == '\0')
{
istrcpy(parms->sdrName, lineSdrName,
sizeof parms->sdrName);
}
if (strcmp(parms->sdrName, lineSdrName) != 0)
{
putErrmsg("SdrName conflict at line#",
itoa(lineNbr));
writeMemoNote("[?] Repair ion_nodes file.",
nodeListFileName);
return -1;
}
return 0;
}
/* lineNodeNbr does not match nodeNbr (which may
* be zero). */
if (strcmp(lineWdName, wdName) == 0) /* Match. */
{
close(nodeListFile);
if (nodeNbr == 0) /* Attaching. */
{
parms->wmKey = lineWmKey;
istrcpy(parms->sdrName, lineSdrName,
MAX_SDR_NAME + 1);
return 0;
}
/* Reinitialization conflict. */
putErrmsg("NodeNbr conflict at line#", itoa(lineNbr));
writeMemoNote("[?] Repair ion_nodes file.",
nodeListFileName);
return -1;
}
/* Haven't found matching line yet. Continue. */
}
/* No matching lines in file. */
if (nodeNbr == 0) /* Attaching to existing node. */
{
close(nodeListFile);
putErrmsg("No node has been initialized in this directory.",
wdName);
return -1;
}
/* Initializing, so append line to the nodes list file. */
if (parms->wmKey == 0)
{
parms->wmKey = ION_DEFAULT_SM_KEY;
}
if (parms->sdrName[0] == '\0')
{
istrcpy(parms->sdrName, ION_DEFAULT_SDR_NAME,
sizeof parms->sdrName);
}
isprintf(lineBuf, sizeof lineBuf, "%lu %d %.31s %.255s\n",
nodeNbr, parms->wmKey, parms->sdrName, wdName);
result = iputs(nodeListFile, lineBuf);
close(nodeListFile);
if (result < 0)
{
putErrmsg("Failed writing to ion_nodes file.", NULL);
return -1;
}
return 0;
}
int readIonParms(char *configFileName, IonParms *parms)
{
char ownHostName[MAXHOSTNAMELEN + 1];
char *endOfHostName;
char configFileNameBuffer[PATHLENMAX + 1 + 9 + 1];
int configFile;
char buffer[512];
int lineNbr;
char line[256];
int lineLength;
int result;
char *cursor;
int i;
char *tokens[2];
int tokenCount;
/* Set defaults. */
CHKERR(parms);
memset((char *) parms, 0, sizeof(IonParms));
parms->wmSize = 5000000;
parms->wmAddress = 0; /* Dyamically allocated. */
parms->configFlags = SDR_IN_DRAM;
parms->heapWords = 250000;
parms->heapKey = SM_NO_KEY;
istrcpy(parms->pathName, "/usr/ion", sizeof parms->pathName);
/* Determine name of config file. */
if (configFileName == NULL)
{
#ifdef ION_NO_DNS
ownHostName[0] = '\0';
#else
if (getNameOfHost(ownHostName, MAXHOSTNAMELEN) < 0)
{
writeMemo("[?] Can't get name of local host.");
return -1;
}
#endif
/* Find end of high-order part of host name. */
if ((endOfHostName = strchr(ownHostName, '.')) != NULL)
{
*endOfHostName = 0;
}
isprintf(configFileNameBuffer, sizeof configFileNameBuffer,
"%.256s.ionconfig", ownHostName);
configFileName = configFileNameBuffer;
}
/* Get overrides from config file. */
configFile = open(configFileName, O_RDONLY, 0777);
if (configFile < 0)
{
if (errno == ENOENT) /* No overrides apply. */
{
writeMemo("[i] admin pgm using default SDR parms.");
printIonParms(parms);
return 0;
}
isprintf(buffer, sizeof buffer, "[?] admin pgm can't open SDR \
config file '%.255s': %.64s", configFileName, system_error_msg());
writeMemo(buffer);
return -1;
}
isprintf(buffer, sizeof buffer, "[i] admin pgm using SDR parm \
overrides from %.255s.", configFileName);
writeMemo(buffer);
lineNbr = 0;
while (1)
{
if (igets(configFile, line, sizeof line, &lineLength) == NULL)
{
if (lineLength == 0)
{
result = 0;
printIonParms(parms);
}
else
{
result = -1;
writeErrMemo("admin pgm SDR config file igets \
failed");
}
break; /* Done. */
}
lineNbr++;
if (lineLength < 1)
{
continue; /* Empty line. */
}
if (line[0] == '#') /* Comment only. */
{
continue;
}
tokenCount = 0;
for (cursor = line, i = 0; i < 2; i++)
{
if (*cursor == '\0')
{
tokens[i] = NULL;
}
else
{
findToken((char **) &cursor, &(tokens[i]));
tokenCount++;
}
}
if (tokenCount != 2)
{
isprintf(buffer, sizeof buffer, "[?] incomplete SDR \
configuration file line (%d).", lineNbr);
writeMemo(buffer);
result = -1;
break;
}
if (strcmp(tokens[0], "wmKey") == 0)
{
parms->wmKey = atoi(tokens[1]);
continue;
}
if (strcmp(tokens[0], "wmSize") == 0)
{
parms->wmSize = atoi(tokens[1]);
continue;
}
if (strcmp(tokens[0], "wmAddress") == 0)
{
parms->wmAddress = (char *) atol(tokens[1]);
continue;
}
if (strcmp(tokens[0], "sdrName") == 0)
{
istrcpy(parms->sdrName, tokens[1],
sizeof(parms->sdrName));
continue;
}
if (strcmp(tokens[0], "configFlags") == 0)
{
parms->configFlags = atoi(tokens[1]);
continue;
}
if (strcmp(tokens[0], "heapWords") == 0)
{
parms->heapWords = atoi(tokens[1]);
continue;
}
if (strcmp(tokens[0], "heapKey") == 0)
{
parms->heapKey = atoi(tokens[1]);
continue;
}
if (strcmp(tokens[0], "pathName") == 0)
{
istrcpy(parms->pathName, tokens[1],
sizeof(parms->pathName));
continue;
}
isprintf(buffer, sizeof buffer, "[?] unknown SDR config \
keyword '%.32s' at line %d.", tokens[0], lineNbr);
writeMemo(buffer);
result = -1;
break;
}
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 bp_receive(BpSAP sap, BpDelivery *dlvBuffer, int timeoutSeconds)
{
Sdr sdr = getIonsdr();
VEndpoint *vpoint;
OBJ_POINTER(Endpoint, endpoint);
Object dlvElt;
Object bundleAddr;
Bundle bundle;
TimerParms timerParms;
pthread_t timerThread;
int result;
char *dictionary;
CHKERR(sap && dlvBuffer);
if (timeoutSeconds < BP_BLOCKING)
{
putErrmsg("Illegal timeout interval.", itoa(timeoutSeconds));
return -1;
}
vpoint = sap->vpoint;
sdr_begin_xn(sdr);
if (vpoint->appPid != sm_TaskIdSelf())
{
sdr_exit_xn(sdr);
putErrmsg("Can't receive: not owner of endpoint.",
itoa(vpoint->appPid));
return -1;
}
if (sm_SemEnded(vpoint->semaphore))
{
sdr_exit_xn(sdr);
writeMemo("[?] Endpoint has been stopped.");
/* End task, but without error. */
return -1;
}
/* Get oldest bundle in delivery queue, if any; wait
* for one if necessary. */
GET_OBJ_POINTER(sdr, Endpoint, endpoint, sdr_list_data(sdr,
vpoint->endpointElt));
dlvElt = sdr_list_first(sdr, endpoint->deliveryQueue);
if (dlvElt == 0)
{
sdr_exit_xn(sdr);
if (timeoutSeconds == BP_POLL)
{
dlvBuffer->result = BpReceptionTimedOut;
return 0;
}
/* Wait for semaphore to be given, either by the
* deliverBundle() function or by timer thread. */
if (timeoutSeconds == BP_BLOCKING)
{
timerParms.interval = -1;
}
else /* This is a receive() with a deadline. */
{
timerParms.interval = timeoutSeconds;
timerParms.semaphore = vpoint->semaphore;
if (pthread_create(&timerThread, NULL, timerMain,
&timerParms) < 0)
{
putSysErrmsg("Can't enable interval timer",
NULL);
return -1;
}
}
/* Take endpoint semaphore. */
if (sm_SemTake(vpoint->semaphore) < 0)
{
putErrmsg("Can't take endpoint semaphore.", NULL);
return -1;
}
if (sm_SemEnded(vpoint->semaphore))
{
writeMemo("[i] Endpoint has been stopped.");
/* End task, but without error. */
return -1;
}
/* Have taken the semaphore, one way or another. */
sdr_begin_xn(sdr);
dlvElt = sdr_list_first(sdr, endpoint->deliveryQueue);
if (dlvElt == 0) /* Still nothing. */
{
/* Either sm_SemTake() was interrupted
* or else timer thread gave semaphore. */
sdr_exit_xn(sdr);
if (timerParms.interval == 0)
{
/* Timer expired. */
dlvBuffer->result = BpReceptionTimedOut;
pthread_join(timerThread, NULL);
}
else /* Interrupted. */
{
dlvBuffer->result = BpReceptionInterrupted;
if (timerParms.interval != -1)
{
pthread_cancel(timerThread);
pthread_join(timerThread, NULL);
}
}
return 0;
}
else /* Bundle was delivered. */
{
if (timerParms.interval != -1)
{
pthread_cancel(timerThread);
pthread_join(timerThread, NULL);
}
}
}
/* At this point, we have got a dlvElt and are in an SDR
* transaction. */
bundleAddr = sdr_list_data(sdr, dlvElt);
sdr_stage(sdr, (char *) &bundle, bundleAddr, sizeof(Bundle));
dictionary = retrieveDictionary(&bundle);
if (dictionary == (char *) &bundle)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't retrieve dictionary.", NULL);
return -1;
}
/* Now fill in the data indication structure. */
dlvBuffer->result = BpPayloadPresent;
if (printEid(&bundle.id.source, dictionary,
&dlvBuffer->bundleSourceEid) < 0)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't print source EID.", NULL);
return -1;
}
dlvBuffer->bundleCreationTime.seconds = bundle.id.creationTime.seconds;
dlvBuffer->bundleCreationTime.count = bundle.id.creationTime.count;
dlvBuffer->adminRecord = bundle.bundleProcFlags & BDL_IS_ADMIN;
dlvBuffer->adu = zco_add_reference(sdr, bundle.payload.content);
dlvBuffer->ackRequested = bundle.bundleProcFlags & BDL_APP_ACK_REQUEST;
/* Now before returning we send delivery status report
* if it is requested. */
if (SRR_FLAGS(bundle.bundleProcFlags) & BP_DELIVERED_RPT)
{
bundle.statusRpt.flags |= BP_DELIVERED_RPT;
getCurrentDtnTime(&bundle.statusRpt.deliveryTime);
}
if (bundle.statusRpt.flags)
{
result = sendStatusRpt(&bundle, dictionary);
if (result < 0)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't send status report.", NULL);
return -1;
}
}
/* Finally delete the delivery list element and, if
* possible, destroy the bundle itself. */
if (dictionary)
{
MRELEASE(dictionary);
}
sdr_list_delete(sdr, dlvElt, (SdrListDeleteFn) NULL, NULL);
bundle.dlvQueueElt = 0;
sdr_write(sdr, bundleAddr, (char *) &bundle, sizeof(Bundle));
if (bpDestroyBundle(bundleAddr, 0) < 0)
{
sdr_cancel_xn(sdr);
putErrmsg("Can't destroy bundle.", NULL);
return -1;
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Failure in bundle reception.", NULL);
return -1;
}
return 0;
}
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;
}
static void *handleNotices(void *parm)
{
/* Main loop for LTP notice reception and handling. */
Sdr sdr = getIonsdr();
ReceiverThreadParms *rtp = (ReceiverThreadParms *) parm;
char *procName = "ltpcli";
AcqWorkArea *redWork;
AcqWorkArea *greenWork;
LtpNoticeType type;
LtpSessionId sessionId;
unsigned char reasonCode;
unsigned char endOfBlock;
unsigned int dataOffset;
unsigned int dataLength;
Object data; /* ZCO reference. */
unsigned int greenBuflen = 0;
char *greenBuffer = NULL;
snooze(1); /* Let main thread become interruptable. */
if (ltp_open(BpLtpClientId) < 0)
{
putErrmsg("ltpcli can't open client access.",
itoa(BpLtpClientId));
ionKillMainThread(procName);
return NULL;
}
redWork = bpGetAcqArea(rtp->vduct);
greenWork = bpGetAcqArea(rtp->vduct);
if (redWork == NULL || greenWork == NULL)
{
ltp_close(BpLtpClientId);
putErrmsg("ltpcli can't get acquisition work areas", NULL);
ionKillMainThread(procName);
return NULL;
}
/* Can now start receiving notices. On failure, take
* down the CLI. */
while (rtp->running)
{
if (ltp_get_notice(BpLtpClientId, &type, &sessionId,
&reasonCode, &endOfBlock, &dataOffset,
&dataLength, &data) < 0)
{
putErrmsg("Can't get LTP notice.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
continue;
}
switch (type)
{
case LtpExportSessionComplete: /* Xmit success. */
if (data == 0) /* Ignore it. */
{
break; /* Out of switch. */
}
if (bpHandleXmitSuccess(data, 0) < 0)
{
putErrmsg("Crashed on xmit success.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
break; /* Out of switch. */
}
CHKNULL(sdr_begin_xn(sdr));
zco_destroy(sdr, data);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Crashed on data cleanup.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
}
break; /* Out of switch. */
case LtpExportSessionCanceled: /* Xmit failure. */
if (data == 0) /* Ignore it. */
{
break; /* Out of switch. */
}
if (bpHandleXmitFailure(data) < 0)
{
putErrmsg("Crashed on xmit failure.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
break; /* Out of switch. */
}
CHKNULL(sdr_begin_xn(sdr));
zco_destroy(sdr, data);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Crashed on data cleanup.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
}
break; /* Out of switch. */
case LtpImportSessionCanceled:
/* None of the red data for the import
* session (if any) have been received
* yet, so nothing to discard. In case
* part or all of the import session was
* green data, force deletion of retained
* data. */
sessionId.sourceEngineId = 0;
sessionId.sessionNbr = 0;
if (handleGreenSegment(greenWork, &sessionId,
0, 0, 0, 0, NULL, NULL) < 0)
{
putErrmsg("Can't cancel green session.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
}
break; /* Out of switch. */
case LtpRecvRedPart:
if (!endOfBlock)
{
/* Block is partially red and
* partially green. Too risky
* to wait for green EOB before
* clearing the work area, so
* just discard the data. */
CHKNULL(sdr_begin_xn(sdr));
zco_destroy(sdr, data);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Crashed: partially red.",
NULL);
ionKillMainThread(procName);
rtp->running = 0;
}
break; /* Out of switch. */
}
if (acquireRedBundles(redWork, data,
sessionId.sourceEngineId) < 0)
{
putErrmsg("Can't acquire bundle(s).", NULL);
ionKillMainThread(procName);
rtp->running = 0;
}
break; /* Out of switch. */
case LtpRecvGreenSegment:
if (handleGreenSegment(greenWork, &sessionId,
endOfBlock, dataOffset, dataLength,
data, &greenBuflen, &greenBuffer) < 0)
{
putErrmsg("Can't handle green segment.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
}
/* Discard the ZCO in any case. */
CHKNULL(sdr_begin_xn(sdr));
zco_destroy(sdr, data);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Crashed: green segment.", NULL);
ionKillMainThread(procName);
rtp->running = 0;
}
break; /* Out of switch. */
default:
break; /* Out of switch. */
}
/* Make sure other tasks have a chance to run. */
sm_TaskYield();
}
writeErrmsgMemos();
writeMemo("[i] ltpcli receiver thread has ended.");
/* Free resources. */
if (greenBuffer)
{
MRELEASE(greenBuffer);
}
bpReleaseAcqArea(greenWork);
bpReleaseAcqArea(redWork);
ltp_close(BpLtpClientId);
return NULL;
}
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;
}
void sptrace_report(PsmPartition trace, int verbose)
{
PsmAddress traceHeaderAddress;
TraceHeader *trh;
PsmAddress elt;
TraceItem *item;
char *fileName;
char buffer[384];
int len;
char buf2[256];
if (!trace) return;
traceHeaderAddress = psm_get_root(trace);
trh = (TraceHeader *) psp(trace, traceHeaderAddress);
CHKVOID(trh);
for (elt = sm_list_first(trace, trh->log); elt;
elt = sm_list_next(trace, elt))
{
item = (TraceItem *) psp(trace, sm_list_data(trace, elt));
CHKVOID(item);
fileName = (char *) psp(trace, item->fileName);
isprintf(buffer, sizeof buffer, "(%5d) at line %6d of %32.32s \
(pid %5d): ", item->opNbr, item->lineNbr, fileName, item->taskId);
len = strlen(buffer);
switch (item->opType)
{
case OP_ALLOCATE:
isprintf(buf2, sizeof buf2, "allocated object %6ld of \
size %6d, ", item->objectAddress, item->objectSize);
istrcpy(buffer + len, buf2, sizeof buffer - len);
if (item->refOpNbr == 0)
{
len = strlen(buffer);
istrcpy(buffer + len, "never freed",
sizeof buffer - len);
}
else
{
if (!verbose)
{
continue;
}
len = strlen(buffer);
fileName = (char *) psp(trace,
item->refFileName);
isprintf(buf2, sizeof buf2, "freed in (%5d) \
at line %6d of %32.32s (pid %5d)", item->refOpNbr, item->refLineNbr, fileName,
item->refTaskId);
istrcpy(buffer + len, buf2,
sizeof buffer - len);
}
break;
case OP_MEMO:
isprintf(buf2, sizeof buf2, "re %6ld, '%.128s'",
item->objectAddress,
(char *) psp(trace, item->msg));
istrcpy(buffer + len, buf2, sizeof buffer - len);
break;
case OP_FREE:
isprintf(buf2, sizeof buf2, "freed object %6ld, ",
item->objectAddress);
istrcpy(buffer + len, buf2, sizeof buffer - len);
if (item->refOpNbr == 0)
{
len = strlen(buffer);
istrcpy(buffer + len, "not currently allocated",
sizeof buffer - len);
}
else
{
if (!verbose)
{
continue;
}
len = strlen(buffer);
fileName = (char *) psp(trace,
item->refFileName);
CHKVOID(fileName);
isprintf(buf2, sizeof buf2, "allocated in \
(%5d) at line %6d of %32.32s (pid %5d)", item->refOpNbr, item->refLineNbr,
fileName, item->refTaskId);
istrcpy(buffer + len, buf2,
sizeof buffer - len);
}
break;
}
writeMemo(buffer);
}
}
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 acsInitialize(long heapWords, int logLevel)
{
AcsDB acsdbBuf;
unsigned long zero = 0; /* sdr_stow() wants this */
if (heapWords == 0)
{
/* Caller wants us to supply a default. */
heapWords = ACS_SDR_DEFAULT_HEAPWORDS;
}
if (ionAttach() < 0)
{
putErrmsg("Can't attach to ION.", NULL);
return -1;
}
{
Sdr sdr = getIonsdr();
IonDB iondb;
char *pathname = iondb.parmcopy.pathName;
CHKERR(sdr_begin_xn(sdr));
sdr_read(sdr, (char *) &iondb, getIonDbObject(), sizeof(IonDB));
sdr_exit_xn(sdr);
#if 0
{
char text[100];
sprintf( text, "ION parms pathname : %s", pathname );
writeMemo( text );
}
#endif
if (sdr_load_profile(acssdrName, SDR_IN_DRAM, heapWords,
SM_NO_KEY, pathname, NULL) < 0)
{
putErrmsg("Unable to load SDR profile for ACS.", NULL);
return -1;
} else {
writeMemo("ACS SDR profile loaded.");
}
}
acsSdr = sdr_start_using(acssdrName);
if (acsSdr == NULL)
{
putErrmsg("Can't start using SDR for ACS.", NULL);
return -1;
}
if (getAcssdr() < 0)
{
putErrmsg("ACS can't find ACS SDR.", NULL);
return -1;
}
CHKERR(sdr_begin_xn(acsSdr));
acsdbObject = sdr_find(acsSdr, acsDbName, NULL);
switch (acsdbObject)
{
case -1: /* SDR error. */
sdr_cancel_xn(acsSdr);
putErrmsg("Can't seek ACS database in SDR.", NULL);
return -1;
case 0: /* Not found must create new DB. */
memset((char *) &acsdbBuf, 0, sizeof(AcsDB));
acsdbBuf.pendingCusts = sdr_list_create(acsSdr);
acsdbBuf.logLevel = logLevel;
acsdbBuf.cidHash = sdr_hash_create(acsSdr, sizeof(AcsCustodyId),
ACS_CIDHASH_ROWCOUNT, 1);
acsdbBuf.bidHash = sdr_hash_create(acsSdr, sizeof(AcsBundleId),
ACS_BIDHASH_ROWCOUNT, 1);
acsdbBuf.id = sdr_stow(acsSdr, zero);
acsdbObject = sdr_malloc(acsSdr, sizeof(AcsDB));
if (acsdbObject == 0)
{
sdr_cancel_xn(acsSdr);
putErrmsg("No space for ACS database.", NULL);
return -1;
}
sdr_write(acsSdr, acsdbObject, (char *) &acsdbBuf, sizeof(AcsDB));
sdr_catlg(acsSdr, acsDbName, 0, acsdbObject);
if (sdr_end_xn(acsSdr))
{
putErrmsg("Can't create ACS database.", NULL);
return -1;
}
break;
default:
sdr_exit_xn(acsSdr);
}
acsConstants = &acsConstantsBuf;
CHKERR(sdr_begin_xn(acsSdr));
sdr_read(acsSdr, (char *) acsConstants, acsdbObject, sizeof(AcsDB));
sdr_exit_xn(acsSdr);
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;
}
