static void switchEcho(int tokenCount, char **tokens)
{
int state;
if (tokenCount < 2)
{
printText("Echo on or off?");
return;
}
switch (*(tokens[1]))
{
case '0':
state = 0;
oK(_echo(&state));
break;
case '1':
state = 1;
oK(_echo(&state));
break;
default:
printText("Echo on or off?");
}
}
Object Sdr_list_insert_last(char *file, int line, Sdr sdrv, Object list,
Address data)
{
SdrList listBuffer;
Object elt;
SdrListElt eltBuffer;
if (!(sdr_in_xn(sdrv)))
{
oK(_iEnd(file, line, _notInXnMsg()));
return 0;
}
joinTrace(sdrv, file, line);
if (list == 0)
{
oK(_xniEnd(file, line, "list", sdrv));
return 0;
}
/* create new element */
elt = _sdrzalloc(sdrv, sizeof(SdrListElt));
if (elt == 0)
{
oK(_iEnd(file, line, "elt"));
return 0;
}
sdr_list__elt_clear(&eltBuffer);
eltBuffer.list = list;
eltBuffer.data = data;
/* insert new element at the end of the list */
sdrFetch(listBuffer, (Address) list);
eltBuffer.prev = listBuffer.last;
eltBuffer.next = 0;
sdrPut((Address) elt, eltBuffer);
if (listBuffer.last != 0)
{
sdrFetch(eltBuffer, (Address) listBuffer.last);
eltBuffer.next = elt;
sdrPut((Address) listBuffer.last, eltBuffer);
}
else
{
listBuffer.first = elt;
}
listBuffer.last = elt;
listBuffer.length += 1;
sdrPut((Address) list, listBuffer);
return elt;
}
int dtn2_addPlan(char *nodeNm, FwdDirective *defaultDir)
{
Sdr sdr = getIonsdr();
char nodeName[SDRSTRING_BUFSZ];
Object nextPlan;
Dtn2Plan plan;
Object planObj;
CHKERR(nodeNm && defaultDir);
if (filterNodeName(nodeName, nodeNm) < 0)
{
return 0;
}
CHKERR(sdr_begin_xn(sdr));
if (locatePlan(nodeName, &nextPlan) != 0)
{
sdr_exit_xn(sdr);
writeMemoNote("[?] Duplicate plan", nodeNm);
return 0;
}
/* Okay to add this plan to the database. */
plan.nodeName = sdr_string_create(sdr, nodeName);
memcpy((char *) &plan.defaultDirective, (char *) defaultDir,
sizeof(FwdDirective));
plan.rules = sdr_list_create(sdr);
planObj = sdr_malloc(sdr, sizeof(Dtn2Plan));
if (planObj)
{
if (nextPlan)
{
oK(sdr_list_insert_before(sdr, nextPlan, planObj));
}
else
{
oK(sdr_list_insert_last(sdr,
(_dtn2Constants())->plans, planObj));
}
sdr_write(sdr, planObj, (char *) &plan, sizeof(Dtn2Plan));
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't add plan.", nodeNm);
return -1;
}
return 1;
}
static void executeDelete(int tokenCount, char **tokens)
{
time_t refTime;
time_t timestamp;
uvast fromNodeNbr;
uvast toNodeNbr;
if (tokenCount < 2)
{
printText("Delete what?");
return;
}
if (tokenCount != 5)
{
SYNTAX_ERROR;
return;
}
if (tokens[2][0] == '*')
{
timestamp = 0;
}
else
{
refTime = _referenceTime(NULL);
timestamp = readTimestampUTC(tokens[2], refTime);
if (timestamp == 0)
{
SYNTAX_ERROR;
return;
}
}
fromNodeNbr = strtouvast(tokens[3]);
toNodeNbr = strtouvast(tokens[4]);
if (strcmp(tokens[1], "contact") == 0)
{
oK(rfx_remove_contact(timestamp, fromNodeNbr, toNodeNbr));
//oK(_forecastNeeded(1));
return;
}
if (strcmp(tokens[1], "range") == 0)
{
oK(rfx_remove_range(timestamp, fromNodeNbr, toNodeNbr));
return;
}
SYNTAX_ERROR;
}
static PsmPartition _ionwm(sm_WmParms *parms)
{
static int ionSmId = 0;
static PsmView ionWorkingMemory;
static PsmPartition ionwm = NULL;
static int memmgrIdx;
static MemAllocator wmtake = allocFromIonMemory;
static MemDeallocator wmrelease = releaseToIonMemory;
static MemAtoPConverter wmatop = ionMemAtoP;
static MemPtoAConverter wmptoa = ionMemPtoA;
if (parms)
{
if (parms->wmSize == -1) /* Destroy. */
{
if (ionwm)
{
memmgr_destroy(ionSmId, &ionwm);
}
ionSmId = 0;
ionwm = NULL;
memmgrIdx = -1;
oK(_ionMemory(&memmgrIdx));
return NULL;
}
/* Opening ION working memory. */
if (ionwm) /* Redundant. */
{
return ionwm;
}
ionwm = &ionWorkingMemory;
if (memmgr_open(parms->wmKey, parms->wmSize,
&parms->wmAddress, &ionSmId, parms->wmName,
&ionwm, &memmgrIdx, wmtake, wmrelease,
wmatop, wmptoa) < 0)
{
putErrmsg("Can't open ION working memory.", NULL);
return NULL;
}
oK(_ionMemory(&memmgrIdx));
}
return ionwm;
}
Object Sdr_list_insert(char *file, int line, Sdr sdrv, Object list,
Address data, SdrListCompareFn compare, void *argData)
{
SdrList listBuffer;
SdrListElt eltBuffer;
Object elt;
if (!(sdr_in_xn(sdrv)))
{
oK(_iEnd(file, line, _notInXnMsg()));
return 0;
}
if (list == 0)
{
oK(_xniEnd(file, line, "list", sdrv));
return 0;
}
/* If not sorted list, just append to the end of the list. */
if (compare == (SdrListCompareFn) NULL)
{
return Sdr_list_insert_last(file, line, sdrv, list, data);
}
/* Application claims that this list is sorted. Find
* position to insert new data into list. Start from end
* of list to keep sort stable; sort sequence is implicitly
* FIFO within key, i.e., we insert element AFTER the last
* element in the table with the same key value. */
sdrFetch(listBuffer, (Address) list);
for (elt = listBuffer.last; elt != 0; elt = eltBuffer.prev)
{
sdrFetch(eltBuffer, (Address) elt);
if (compare(sdrv, eltBuffer.data, argData) <= 0) break;
}
/* Insert into list at this point. */
if (elt == 0)
{
return Sdr_list_insert_first(file, line, sdrv, list, data);
}
return Sdr_list_insert_after(file, line, sdrv, elt, data);
}
void ionDropVdb()
{
PsmPartition wm = getIonwm();
char *ionvdbName = _ionvdbName();
PsmAddress vdbAddress;
PsmAddress elt;
char *stop = NULL;
if (psm_locate(wm, ionvdbName, &vdbAddress, &elt) < 0)
{
putErrmsg("Failed searching for vdb.", NULL);
return;
}
if (elt)
{
dropVdb(wm, vdbAddress); /* Destroy Vdb. */
psm_free(wm, vdbAddress);
if (psm_uncatlg(wm, ionvdbName) < 0)
{
putErrmsg("Failed uncataloging vdb.", NULL);
}
}
oK(_ionvdb(&stop)); /* Forget old Vdb. */
}
static void executeAdd(int tokenCount, char **tokens)
{
if (tokenCount < 2)
{
printText("Add what?");
return;
}
if (strcmp(tokens[1], "profile") == 0)
{
if (tokenCount != 10 && tokenCount != 9)
{
SYNTAX_ERROR;
return;
}
oK(addProfile(strtol(tokens[2], NULL, 0),
strtol(tokens[3], NULL, 0),
strtol(tokens[4], NULL, 0),
strtol(tokens[5], NULL, 0),
strtol(tokens[6], NULL, 0),
tokens[7], tokens[8], tokens[9]));
return;
}
SYNTAX_ERROR;
}
static void handleQuit()
{
int stop = 0;
oK(_running(&stop));
ionPauseAttendant(_attendant(NULL));
}
static void interruptThread() /* Shuts down LSO. */
{
void *erase = NULL;
sm_SemEnd(_pmqlsoSemaphore(NULL));
oK(sm_TaskVar(&erase));
}
static void handleQuit()
{
int stop = 0;
oK(_running(&stop));
ltp_interrupt(_clientId(NULL));
}
static int runPitcher()
{
AmsModule me;
AmsEvent evt;
AmsStateType state;
AmsChangeType change;
int zn, nn, rn, dcn, dzn, sn, pr, textlen;
unsigned char fl;
AmsSequence sequence;
AmsDiligence diligence;
char buffer[80];
isprintf(buffer, sizeof buffer, "Hello from %d.", (int) getpid());
textlen = strlen(buffer) + 1;
oK(ams_register(NULL, NULL, "amsdemo", "test", "", "pitch", &me));
while (1)
{
if (ams_get_event(me, AMS_BLOCKING, &evt) < 0) return 0;
ams_parse_notice(evt, &state, &change, &zn, &nn, &rn, &dcn,
&dzn, &sn, &pr, &fl, &sequence, &diligence);
ams_recycle_event(evt);
if (state == AmsInvitationState && sn == 1)
{
printf("%d sending '%s'.\n", (int) getpid(), buffer);
fflush(stdout);
ams_send(me, -1, zn, nn, 1, 0, 0, textlen, buffer, 0);
ams_unregister(me); return 0;
}
}
}
void removeEmbargo(IonNode *node, uvast neighborNodeNbr)
{
PsmPartition ionwm = getIonwm();
PsmAddress elt;
PsmAddress addr;
Embargo *embargo;
CHKVOID(node);
for (elt = sm_list_first(ionwm, node->embargoes); elt;
elt = sm_list_next(ionwm, elt))
{
addr = sm_list_data(ionwm, elt);
embargo = (Embargo *) psp(ionwm, addr);
CHKVOID(embargo);
if (embargo->nodeNbr < neighborNodeNbr)
{
continue;
}
if (embargo->nodeNbr > neighborNodeNbr)
{
return; /* Embargo not found. */
}
break; /* Found the embargo to remove. */
}
if (elt == 0)
{
return; /* Embargo not found. */
}
oK(sm_list_delete(ionwm, elt, NULL, NULL));
psm_free(ionwm, addr);
}
static void shutDownAmsd()
{
int stop = 0;
isignal(SIGINT, shutDownAmsd);
oK(_amsdRunning(&stop));
}
int dtn2Init()
{
Sdr sdr = getIonsdr();
Object dtn2dbObject;
DtnDB dtn2dbBuf;
/* Recover the DTN database, creating it if necessary. */
CHKERR(sdr_begin_xn(sdr));
dtn2dbObject = sdr_find(sdr, DTN_DBNAME, NULL);
switch (dtn2dbObject)
{
case -1: /* SDR error. */
sdr_cancel_xn(sdr);
putErrmsg("Failed seeking DTN database in SDR.", NULL);
return -1;
case 0: /* Not found; must create new DB. */
dtn2dbObject = sdr_malloc(sdr, sizeof(DtnDB));
if (dtn2dbObject == 0)
{
sdr_cancel_xn(sdr);
putErrmsg("No space for DTN database.", NULL);
return -1;
}
memset((char *) &dtn2dbBuf, 0, sizeof(DtnDB));
dtn2dbBuf.plans = sdr_list_create(sdr);
sdr_write(sdr, dtn2dbObject, (char *) &dtn2dbBuf,
sizeof(DtnDB));
sdr_catlg(sdr, DTN_DBNAME, 0, dtn2dbObject);
if (sdr_end_xn(sdr))
{
putErrmsg("Can't create DTN database.", NULL);
return -1;
}
break;
default: /* Found DB in the SDR. */
sdr_exit_xn(sdr);
}
oK(_dtn2dbObject(&dtn2dbObject));
oK(_dtn2Constants());
return 0;
}
static void handleQuit()
{
int stop = 0;
PUTS("BP reception interrupted.");
oK(_running(&stop));
bp_interrupt(_bpsap(NULL));
}
void writeTimestampUTC(time_t timestamp, char *timestampBuffer)
{
struct tm ts;
CHKVOID(timestampBuffer);
oK(gmtime_r(×tamp, &ts));
isprintf(timestampBuffer, 20, timestampOutFormat,
ts.tm_year + 1900, ts.tm_mon + 1, ts.tm_mday,
ts.tm_hour, ts.tm_min, ts.tm_sec);
}
void Sdr_list_destroy(char *file, int line, Sdr sdrv, Object list,
SdrListDeleteFn deleteFn, void *arg)
{
SdrList listBuffer;
Object elt;
Object next;
SdrListElt eltBuffer;
if (!(sdr_in_xn(sdrv)))
{
oK(_iEnd(file, line, _notInXnMsg()));
return;
}
joinTrace(sdrv, file, line);
if (list == 0)
{
oK(_xniEnd(file, line, "list", sdrv));
return;
}
sdrFetch(listBuffer, (Address) list);
for (elt = listBuffer.first; elt != 0; elt = next)
{
sdrFetch(eltBuffer, (Address) elt);
next = eltBuffer.next;
if (deleteFn)
{
deleteFn(sdrv, eltBuffer.data, arg);
}
/* just in case user mistakenly accesses later... */
sdr_list__elt_clear(&eltBuffer);
sdrPut((Address) elt, eltBuffer);
sdrFree(elt);
}
/* just in case user mistakenly accesses later... */
sdr_list__clear(&listBuffer);
sdrPut((Address) list, listBuffer);
sdrFree(list);
}
void ionDetach()
{
#if defined (VXWORKS) || defined (bionic)
return;
#elif defined (RTEMS)
sm_TaskForget(sm_TaskIdSelf());
#else
Sdr ionsdr = _ionsdr(NULL);
if (ionsdr)
{
sdr_stop_using(ionsdr);
ionsdr = NULL; /* To reset to NULL. */
oK(_ionsdr(&ionsdr));
}
#ifdef mingw
oK(_winsock(1));
#endif
#endif
}
static void ionReleaseZcoSpace(IonVdb *vdb)
{
/* If there are any remaining claims then let the
* next claimant in the queue (possibly this claimant,
* now re-appended to semaphore's FIFO) take a shot. */
if (vdb->zcoClaims > 0)
{
oK(sm_SemGive(vdb->zcoSemaphore));
}
}
void ionTerminate()
{
Sdr sdr = _ionsdr(NULL);
Object obj = 0;
sm_WmParms ionwmParms;
char *ionvdbName = NULL;
if (sdr)
{
sdr_destroy(sdr);
sdr = NULL;
oK(_ionsdr(&sdr)); /* To reset to NULL. */
}
oK(_iondbObject(&obj));
ionwmParms.wmKey = 0;
ionwmParms.wmSize = -1;
ionwmParms.wmAddress = NULL;
oK(_ionwm(&ionwmParms));
oK(_ionvdb(&ionvdbName));
}
void Sm_rbt_clear(char *file, int line, PsmPartition partition,
PsmAddress rbt, SmRbtDeleteFn deleteFn, void *arg)
{
SmRbt *rbtPtr;
CHKVOID(partition);
CHKVOID(rbt);
rbtPtr = (SmRbt *) psp(partition, rbt);
oK(lockSmrbt(rbtPtr));
destroyRbtNodes(file, line, partition, rbtPtr, deleteFn, arg);
unlockSmrbt(rbtPtr);
}
void Sdr_list_user_data_set(char *file, int line, Sdr sdrv, Object list,
Address data)
{
SdrList listBuffer;
if (!(sdr_in_xn(sdrv)))
{
oK(_iEnd(file, line, _notInXnMsg()));
return;
}
joinTrace(sdrv, file, line);
if (list == 0)
{
oK(_xniEnd(file, line, "list", sdrv));
return;
}
sdrFetch(listBuffer, list);
listBuffer.userData = data;
sdrPut((Address) list, listBuffer);
}
Object Sdr_list_create(char *file, int line, Sdr sdrv)
{
Object list;
SdrList listBuffer;
if (!(sdr_in_xn(sdrv)))
{
oK(_iEnd(file, line, _notInXnMsg()));
return 0;
}
joinTrace(sdrv, file, line);
list = _sdrzalloc(sdrv, sizeof(SdrList));
if (list == 0)
{
oK(_iEnd(file, line, "list"));
return 0;
}
sdr_list__clear(&listBuffer);
sdrPut((Address) list, listBuffer);
return list;
}
void ionDetach()
{
#if defined (VXWORKS) || defined (RTEMS)
return;
#else
Sdr ionsdr = _ionsdr(NULL);
if (ionsdr)
{
sdr_stop_using(ionsdr);
ionsdr = NULL; /* To reset to NULL. */
oK(_ionsdr(&ionsdr));
}
#endif
}
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);
}
void Sm_rbt_destroy(char *file, int line, PsmPartition partition,
PsmAddress rbt, SmRbtDeleteFn deleteFn, void *arg)
{
SmRbt *rbtPtr;
CHKVOID(partition);
CHKVOID(rbt);
rbtPtr = (SmRbt *) psp(partition, rbt);
oK(lockSmrbt(rbtPtr));
destroyRbtNodes(file, line, partition, rbtPtr, deleteFn, arg);
/* Now destroy the tree itself. */
sm_SemDelete(rbtPtr->lock);
/* just in case user mistakenly accesses later... */
eraseTree(rbtPtr);
Psm_free(file, line, partition, rbt);
}
static DWORD WINAPI waitForSigterm(LPVOID parm)
{
DWORD processId;
char eventName[32];
HANDLE event;
processId = GetCurrentProcessId();
sprintf(eventName, "%u.sigterm", (unsigned int) processId);
event = CreateEvent(NULL, FALSE, FALSE, eventName);
if (event == NULL)
{
putErrmsg("Can't create sigterm event.", utoa(GetLastError()));
return 0;
}
oK(WaitForSingleObject(event, INFINITE));
raise(SIGTERM);
CloseHandle(event);
return 0;
}
int Psm_add_catlg(char *file, int line, PsmPartition partition)
{
PartitionMap *map;
PsmAddress catlg;
if (!partition)
{
oK(_iEnd(file, line, "partition"));
return -1;
}
map = (PartitionMap *) (partition->space);
lockPartition(map);
if (map->directory != 0)
{
unlockPartition(map);
_putErrmsg(file, line, "Partition already has root value; \
erase it first.", NULL);
return -1;
}
static void lockPartition(PartitionMap *map)
{
int selfTask;
pthread_t selfThread;
CHKVOID(map->status == MANAGED);
selfTask = sm_TaskIdSelf();
selfThread = pthread_self();
if (map->ownerTask == selfTask
&& pthread_equal(map->ownerThread, selfThread))
{
map->depth++;
return;
}
CHKVOID(map->semaphore != -1);
oK(sm_SemTake(map->semaphore));
map->ownerThread = selfThread;
map->ownerTask = selfTask;
map->depth = 1;
}
