void dtn2_destroyDirective(FwdDirective *directive)
{
Sdr sdr = getIonsdr();
CHKVOID(directive);
if (directive->action == fwd)
{
CHKVOID(sdr_begin_xn(sdr));
sdr_free(sdr, directive->eid);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't destroy directive EID.", NULL);
}
return;
}
if (directive->action == xmit)
{
if (directive->destDuctName)
{
CHKVOID(sdr_begin_xn(sdr));
sdr_free(sdr, directive->destDuctName);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't destroy destDuctName.", NULL);
}
}
}
}
static void manageMtusize(int tokenCount, char **tokens)
{
Sdr sdr = getIonsdr();
Object cfdpdbObj = getCfdpDbObject();
CfdpDB cfdpdb;
int newMtusize;
if (tokenCount != 3)
{
SYNTAX_ERROR;
}
newMtusize = atoi(tokens[2]);
if (newMtusize < 0)
{
putErrmsg("mtuSize invalid.", tokens[2]);
return;
}
sdr_begin_xn(sdr);
sdr_stage(sdr, (char *) &cfdpdb, cfdpdbObj, sizeof(CfdpDB));
cfdpdb.mtuSize = newMtusize;
sdr_write(sdr, cfdpdbObj, (char *) &cfdpdb, sizeof(CfdpDB));
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't change mtuSize.", NULL);
}
}
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. */
}
PsmAddress Sm_list_create(const char *fileName, int lineNbr,
PsmPartition partition)
{
sm_SemId lock;
PsmAddress list;
SmList *listBuffer;
lock = sm_SemCreate(SM_NO_KEY, SM_SEM_FIFO);
if (lock < 0)
{
putErrmsg("Can't create semaphore for list.", NULL);
return 0;
}
list = Psm_zalloc(fileName, lineNbr, partition, sizeof(SmList));
if (list == 0)
{
sm_SemDelete(lock);
putErrmsg("Can't allocate space for list header.", NULL);
return 0;
}
listBuffer = (SmList *) psp(partition, list);
eraseList(listBuffer);
listBuffer->lock = lock;
return list;
}
static int udpComputeCsepName(char *endpointSpec, char *endpointName)
{
unsigned short portNbr;
unsigned int ipAddress;
char hostName[MAXHOSTNAMELEN + 1];
if (endpointName == NULL)
{
putErrmsg(BadParmsMemo, NULL);
return -1;
}
parseSocketSpec(endpointSpec, &portNbr, &ipAddress);
if (portNbr == 0)
{
portNbr = 2357; /* Default. */
}
if (ipAddress == 0) /* Default to local host. */
{
getNameOfHost(hostName, sizeof hostName);
ipAddress = getInternetAddress(hostName);
}
else
{
if (getInternetHostName(ipAddress, hostName) == NULL)
{
putErrmsg("Unknown host in endpoint.", endpointSpec);
return -1;
}
}
isprintf(endpointName, MAX_EP_NAME + 1, "%s:%hu", hostName, portNbr);
return 0;
}
static void manageDiscard(int tokenCount, char **tokens)
{
Sdr sdr = getIonsdr();
Object cfdpdbObj = getCfdpDbObject();
CfdpDB cfdpdb;
int newDiscard;
if (tokenCount != 3)
{
SYNTAX_ERROR;
}
newDiscard = atoi(tokens[2]);
if (newDiscard != 0 && newDiscard != 1)
{
putErrmsg("discardIncompleteFile switch invalid.", tokens[2]);
return;
}
sdr_begin_xn(sdr);
sdr_stage(sdr, (char *) &cfdpdb, cfdpdbObj, sizeof(CfdpDB));
cfdpdb.discardIncompleteFile = newDiscard;
sdr_write(sdr, cfdpdbObj, (char *) &cfdpdb, sizeof(CfdpDB));
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't change discardIncompleteFile switch.", NULL);
}
}
static void manageMaxtrnbr(int tokenCount, char **tokens)
{
Sdr sdr = getIonsdr();
Object cfdpdbObj = getCfdpDbObject();
CfdpDB cfdpdb;
int newMaxtrnbr;
if (tokenCount != 3)
{
SYNTAX_ERROR;
}
newMaxtrnbr = atoi(tokens[2]);
if (newMaxtrnbr < 0)
{
putErrmsg("maxTransactionNbr invalid.", tokens[2]);
return;
}
sdr_begin_xn(sdr);
sdr_stage(sdr, (char *) &cfdpdb, cfdpdbObj, sizeof(CfdpDB));
cfdpdb.maxTransactionNbr = newMaxtrnbr;
sdr_write(sdr, cfdpdbObj, (char *) &cfdpdb, sizeof(CfdpDB));
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't change maxTransactionNbr.", NULL);
}
}
static void manageFillchar(int tokenCount, char **tokens)
{
Sdr sdr = getIonsdr();
Object cfdpdbObj = getCfdpDbObject();
CfdpDB cfdpdb;
int newFillchar;
char *trailing;
if (tokenCount != 3)
{
SYNTAX_ERROR;
}
newFillchar = strtol(tokens[2], &trailing, 16);
if (*trailing != '\0')
{
putErrmsg("fillCharacter invalid.", tokens[2]);
return;
}
sdr_begin_xn(sdr);
sdr_stage(sdr, (char *) &cfdpdb, cfdpdbObj, sizeof(CfdpDB));
cfdpdb.fillCharacter = newFillchar;
sdr_write(sdr, cfdpdbObj, (char *) &cfdpdb, sizeof(CfdpDB));
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't change fillCharacter.", NULL);
}
}
static void manageMaxtimeouts(int tokenCount, char **tokens)
{
Sdr sdr = getIonsdr();
Object cfdpdbObj = getCfdpDbObject();
CfdpDB cfdpdb;
int newMaxtimeouts;
if (tokenCount != 3)
{
SYNTAX_ERROR;
}
newMaxtimeouts = atoi(tokens[2]);
if (newMaxtimeouts < 0)
{
putErrmsg("checkTimeoutLimit invalid.", tokens[2]);
return;
}
sdr_begin_xn(sdr);
sdr_stage(sdr, (char *) &cfdpdb, cfdpdbObj, sizeof(CfdpDB));
cfdpdb.checkTimeoutLimit = newMaxtimeouts;
sdr_write(sdr, cfdpdbObj, (char *) &cfdpdb, sizeof(CfdpDB));
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't change checkTimerPeriod.", NULL);
}
}
static int acquireBundles(AcqWorkArea *work, Object zco,
unsigned long senderEngineNbr)
{
char engineNbrString[21];
char senderEidBuffer[SDRSTRING_BUFSZ];
char *senderEid;
isprintf(engineNbrString, sizeof engineNbrString, "%lu",
senderEngineNbr);
senderEid = senderEidBuffer;
getSenderEid(&senderEid, engineNbrString);
if (bpBeginAcq(work, 0, senderEid) < 0)
{
putErrmsg("Can't begin acquisition of bundle(s).", NULL);
return -1;
}
if (bpLoadAcq(work, zco) < 0)
{
putErrmsg("Can't continue bundle acquisition.", NULL);
return -1;
}
if (bpEndAcq(work) < 0)
{
putErrmsg("Can't end acquisition of bundle(s).", NULL);
return -1;
}
return 0;
}
static void manageRequirecrc(int tokenCount, char **tokens)
{
Sdr sdr = getIonsdr();
Object cfdpdbObj = getCfdpDbObject();
CfdpDB cfdpdb;
int newRequirecrc;
if (tokenCount != 3)
{
SYNTAX_ERROR;
}
newRequirecrc = atoi(tokens[2]);
if (newRequirecrc != 0 && newRequirecrc != 1)
{
putErrmsg("crcRequired switch invalid.", tokens[2]);
return;
}
sdr_begin_xn(sdr);
sdr_stage(sdr, (char *) &cfdpdb, cfdpdbObj, sizeof(CfdpDB));
cfdpdb.crcRequired = newRequirecrc;
sdr_write(sdr, cfdpdbObj, (char *) &cfdpdb, sizeof(CfdpDB));
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Can't change crcRequired switch.", NULL);
}
}
PsmAddress Sm_list_insert_after(const char *fileName, int lineNbr,
PsmPartition partition, PsmAddress oldElt,
PsmAddress data)
{
SmListElt *oldEltBuffer;
PsmAddress list;
SmList *listBuffer;
CHKZERO(partition);
CHKZERO(oldElt);
oldEltBuffer = (SmListElt *) psp(partition, oldElt);
CHKZERO(oldEltBuffer);
if ((list = oldEltBuffer->list) == 0)
{
putErrmsg(_noListMsg(), NULL);
return 0;
}
listBuffer = (SmList *) psp(partition, list);
if (lockSmlist(listBuffer) == ERROR)
{
putErrmsg(_cannotLockMsg(), NULL);
return 0;
}
return finishInsertingAfter(fileName, lineNbr, partition, oldElt,
oldEltBuffer, list, listBuffer, data);
}
static int reforwardStrandedBundles()
{
Sdr sdr = getIonsdr();
BpDB *bpConstants = getBpConstants();
Object elt;
Object nextElt;
CHKERR(sdr_begin_xn(sdr));
for (elt = sdr_list_first(sdr, bpConstants->limboQueue); elt;
elt = nextElt)
{
nextElt = sdr_list_next(sdr, elt);
if (releaseFromLimbo(elt, 0) < 0)
{
putErrmsg("Failed releasing bundle from limbo.", NULL);
sdr_cancel_xn(sdr);
return -1;
}
}
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("brss failed limbo release on client connect.", NULL);
return -1;
}
return 0;
}
IonNode *addNode(IonVdb *ionvdb, uvast nodeNbr)
{
PsmPartition ionwm = getIonwm();
PsmAddress addr;
PsmAddress elt;
IonNode *node;
addr = psm_zalloc(ionwm, sizeof(IonNode));
if (addr == 0)
{
putErrmsg("Can't add node.", NULL);
return NULL;
}
node = (IonNode *) psp(ionwm, addr);
CHKNULL(node);
memset((char *) node, 0, sizeof(IonNode));
node->nodeNbr = nodeNbr;
elt = sm_rbt_insert(ionwm, ionvdb->nodes, addr, rfx_order_nodes, node);
if (elt == 0)
{
psm_free(ionwm, addr);
putErrmsg("Can't add node.", NULL);
return NULL;
}
node->embargoes = sm_list_create(ionwm);
return node;
}
PsmAddress Sm_rbt_create(char *file, int line, PsmPartition partition)
{
sm_SemId lock;
PsmAddress rbt;
SmRbt *rbtPtr;
lock = sm_SemCreate(SM_NO_KEY, SM_SEM_FIFO);
if (lock < 0)
{
putErrmsg("Can't create semaphore for rbt.", NULL);
return 0;
}
rbt = Psm_zalloc(file, line, partition, sizeof(SmRbt));
if (rbt == 0)
{
sm_SemDelete(lock);
putErrmsg("Can't allocate space for rbt object.", NULL);
return 0;
}
rbtPtr = (SmRbt *) psp(partition, rbt);
eraseTree(rbtPtr);
rbtPtr->lock = lock;
return rbt;
}
PsmAddress Sm_list_insert_before(const char *fileName, int lineNbr,
PsmPartition partition, PsmAddress oldElt,
PsmAddress data)
{
SmListElt *oldEltBuffer;
PsmAddress list;
SmList *listBuffer;
PsmAddress elt;
SmListElt *eltBuffer;
CHKZERO(partition);
CHKZERO(oldElt);
oldEltBuffer = (SmListElt *) psp(partition, oldElt);
CHKZERO(oldEltBuffer);
if ((list = oldEltBuffer->list) == 0)
{
putErrmsg(_noListMsg(), NULL);
return 0;
}
listBuffer = (SmList *) psp(partition, list);
if (lockSmlist(listBuffer) == ERROR)
{
putErrmsg(_cannotLockMsg(), NULL);
return 0;
}
elt = Psm_zalloc(fileName, lineNbr, partition, sizeof(SmListElt));
if (elt == 0)
{
unlockSmlist(listBuffer);
putErrmsg(_noSpaceForEltMsg(), NULL);
return 0;
}
eltBuffer = (SmListElt *) psp(partition, elt);
eraseListElt(eltBuffer);
eltBuffer->list = list;
eltBuffer->data = data;
eltBuffer->prev = oldEltBuffer->prev;
eltBuffer->next = oldElt;
if (oldEltBuffer->prev != 0)
{
eltBuffer = (SmListElt *) psp(partition, oldEltBuffer->prev);
CHKZERO(eltBuffer);
eltBuffer->next = elt;
}
else
{
listBuffer->first = elt;
}
oldEltBuffer->prev = elt;
listBuffer->length += 1;
unlockSmlist(listBuffer);
return elt;
}
Sdr getAcssdr(void)
{
static int haveTriedAcsSdr = 0;
if(acsSdr || haveTriedAcsSdr)
{
return acsSdr;
}
if (ionAttach() < 0)
{
putErrmsg("Can't attach to ION.", NULL);
return NULL;
}
haveTriedAcsSdr = 1;
acsSdr = sdr_start_using(acssdrName);
if (acsSdr == NULL)
{
//Can't start using SDR for ACS.
return NULL;
}
return acsSdr;
}
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;
}
void bp_release_delivery(BpDelivery *dlvBuffer, int releasePayload)
{
Sdr sdr = getIonsdr();
CHKVOID(dlvBuffer);
if (dlvBuffer->result == BpPayloadPresent)
{
if (dlvBuffer->bundleSourceEid)
{
MRELEASE(dlvBuffer->bundleSourceEid);
dlvBuffer->bundleSourceEid = NULL;
}
if (releasePayload)
{
if (dlvBuffer->adu)
{
sdr_begin_xn(sdr);
zco_destroy_reference(sdr, dlvBuffer->adu);
if (sdr_end_xn(sdr) < 0)
{
putErrmsg("Failed releasing delivery.",
NULL);
}
dlvBuffer->adu = 0;
}
}
}
}
PsmAddress sm_rbt_last(PsmPartition partition, PsmAddress rbt)
{
SmRbt *rbtPtr;
PsmAddress node;
PsmAddress last = 0;
SmRbtNode *nodePtr;
CHKZERO(partition);
CHKZERO(rbt);
rbtPtr = (SmRbt *) psp(partition, rbt);
CHKZERO(rbtPtr);
if (lockSmrbt(rbtPtr) == ERROR)
{
return 0;
}
node = rbtPtr->root;
while (node)
{
last = node;
nodePtr = (SmRbtNode *) psp(partition, node);
if (nodePtr == NULL)
{
putErrmsg("Corrupt red-black tree.", NULL);
last = 0;
break;
}
node = nodePtr->child[RIGHT];
}
unlockSmrbt(rbtPtr);
return last;
}
static PsmAddress createNode(char *file, int line, PsmPartition partition,
PsmAddress rbt, PsmAddress parent,
PsmAddress data, SmRbtNode **buffer)
{
PsmAddress node;
SmRbtNode *nodePtr;
node = Psm_zalloc(file, line, partition, sizeof(SmRbtNode));
if (node == 0)
{
putErrmsg("Can't allocate space for rbt node.", NULL);
return 0;
}
nodePtr = (SmRbtNode *) psp(partition, node);
nodePtr->rbt = rbt;
nodePtr->parent = parent;
nodePtr->child[LEFT] = 0;
nodePtr->child[RIGHT] = 0;
nodePtr->data = data;
if (buffer) /* Tree already has a root. */
{
nodePtr->isRed = 1;
*buffer = nodePtr;
}
else /* This is the first node in the tree. */
{
nodePtr->isRed = 0; /* Root is always black. */
}
return node;
}
Object getOrMakeCustodianByEid(Object custodians, const char *eid)
{
Object custodianAddr;
/* Try to find custodian info if it exists. */
CHKZERO(sdr_begin_xn(acsSdr));
custodianAddr = findCustodianByEid(custodians, eid);
if(sdr_end_xn(acsSdr) < 0)
{
putErrmsg("Can't search custodian database", eid);
return 0;
}
/* If no custodian info, make it. */
if(custodianAddr == 0)
{
custodianAddr = newSdrAcsCustodian(custodians, eid);
if(custodianAddr == 0)
{
ACSLOG_WARN("Couldn't record new custodian info for %s", eid);
return 0;
}
}
return custodianAddr;
}
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;
}
static int filterNodeName(char *outputNodeName, char *inputNodeName)
{
int nameLength = strlen(inputNodeName);
int last = nameLength - 1;
if (nameLength == 0 || nameLength > MAX_SDRSTRING)
{
putErrmsg("Invalid node name length.", inputNodeName);
return -1;
}
/* Note: the '~' character is used internally to
* indicate "all others" (wild card) because it's the
* last printable ASCII character and therefore always
* sorts last in any list. If the user wants to use
* '*' instead, we just change it silently. */
memcpy(outputNodeName, inputNodeName, nameLength);
outputNodeName[nameLength] = '\0';
if (outputNodeName[last] == '*')
{
outputNodeName[last] = '~';
}
return 0;
}
Sdr getAcssdr(void)
{
static int haveTriedAcsSdr = 0;
if (acsSdr || haveTriedAcsSdr)
{
return acsSdr;
}
if (ionAttach() < 0)
{
putErrmsg("Can't attach to ION.", NULL);
return NULL;
}
haveTriedAcsSdr = 1;
acsSdr = sdr_start_using(acssdrName);
if (acsSdr == NULL)
{
writeMemoNote("[i] This task is unable to exercise ACS \
because the ACS SDR is not initialized, as noted in message above",
itoa(sm_TaskIdSelf()));
}
return acsSdr;
}
static int udpParseAmsEndpoint(AmsEndpoint *dp)
{
char *colon;
char hostName[MAXHOSTNAMELEN + 1];
UdpTsep tsep;
if (dp == NULL || dp->ept == NULL)
{
errno = EINVAL;
putErrmsg("udpts can't parse AMS endpoint.", NULL);
return -1;
}
colon = strchr(dp->ept, ':');
*colon = '\0';
istrcpy(hostName, dp->ept, sizeof hostName);
*colon = ':';
tsep.portNbr = atoi(colon + 1);
tsep.ipAddress = getInternetAddress(hostName);
dp->tsep = MTAKE(sizeof(UdpTsep));
if (dp->tsep == NULL)
{
putSysErrmsg("udpts can't record parsed AMS endpoint name.",
NULL);
return -1;
}
memcpy((char *) (dp->tsep), (char *) &tsep, sizeof(UdpTsep));
/* Also parse out the QOS of this endpoint. */
dp->diligence = AmsBestEffort;
dp->sequence = AmsArrivalOrder;
return 0;
}
static int udpParseMamsEndpoint(MamsEndpoint *ep)
{
char *colon;
char hostName[MAXHOSTNAMELEN + 1];
UdpTsep tsep;
if (ep == NULL || ep->ept == NULL)
{
errno = EINVAL;
putErrmsg("udpts can't parse MAMS endpoint name.", NULL);
return -1;
}
colon = strchr(ep->ept, ':');
*colon = '\0';
istrcpy(hostName, ep->ept, sizeof hostName);
*colon = ':';
tsep.portNbr = atoi(colon + 1);
tsep.ipAddress = getInternetAddress(hostName);
ep->tsep = MTAKE(sizeof(UdpTsep));
if (ep->tsep == NULL)
{
putSysErrmsg("udpts can't record parsed MAMS endpoint name.",
NULL);
return -1;
}
memcpy((char *) (ep->tsep), (char *) &tsep, sizeof(UdpTsep));
//printf("parsed '%s' to port %d address %d.\n", ep->ept, tsep.portNbr,
//tsep.ipAddress);
return 0;
}
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 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 void handle_amsendpoint_start(LoadMibState *state, const char **atts)
{
char *tsname = NULL;
char *epspec = NULL;
char **att;
char *name;
char *value;
LystElt elt;
if (noMibYet(state)) return;
for (att = (char **) atts; *att; att++)
{
name = *att;
att++;
value = *att;
if (strcmp(name, "tsname") == 0)
{
tsname = value;
}
else if (strcmp(name, "epspec") == 0)
{
epspec = value;
}
else return noteLoadError(state, "Unknown attribute.");
}
if (tsname == NULL)
{
return noteLoadError(state, "Need name of transport service.");
}
if (epspec == NULL)
{
return noteLoadError(state, "Need AMS endpoint spec.");
}
switch (state->currentOperation)
{
case LoadAdding:
elt = createAmsEpspec(tsname, epspec);
if (elt == NULL)
{
return putErrmsg("Couldn't add AMS endpoint spec.",
NULL);
}
break;
case LoadChanging:
return noteLoadError(state, "'Change' not yet implemented.");
case LoadDeleting:
return noteLoadError(state, "'Delete' not yet implemented.");
default:
return noteLoadError(state, "Not in an operation.");
}
}
