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); } } } }
void ltpei_destroy_extension(Sdr sdr, Object elt, void *arg) { Object addr; LtpExtensionOutbound ext; addr = sdr_list_data(sdr, elt); sdr_read(sdr, (char *) &ext, addr, sizeof(LtpExtensionOutbound)); if (ext.value) { sdr_free(sdr, ext.value); } sdr_free(sdr, addr); }
int dtn2_removePlan(char *nodeNm) { Sdr sdr = getIonsdr(); char nodeName[SDRSTRING_BUFSZ]; Object elt; Object planObj; OBJ_POINTER(Dtn2Plan, plan); CHKERR(nodeNm); if (filterNodeName(nodeName, nodeNm) < 0) { return 0; } CHKERR(sdr_begin_xn(sdr)); elt = locatePlan(nodeName, NULL); if (elt == 0) { sdr_exit_xn(sdr); writeMemoNote("[?] Unknown plan", nodeNm); return 0; } planObj = sdr_list_data(sdr, elt); GET_OBJ_POINTER(sdr, Dtn2Plan, plan, planObj); if (sdr_list_length(sdr, plan->rules) > 0) { sdr_exit_xn(sdr); writeMemoNote("[?] Can't remove plan; still has rules", nodeNm); return 0; } /* Okay to remove this plan from the database. */ sdr_list_delete(sdr, elt, NULL, NULL); dtn2_destroyDirective(&(plan->defaultDirective)); sdr_list_destroy(sdr, plan->rules, NULL, NULL); sdr_free(sdr, plan->nodeName); sdr_free(sdr, planObj); if (sdr_end_xn(sdr) < 0) { putErrmsg("Can't remove plan.", nodeNm); return -1; } return 1; }
int db_forget(Object *primitiveObj, Object *descObj, Object list) { Sdr sdr = getIonsdr(); Object elt; if((primitiveObj == NULL) || (descObj == NULL) || (list == 0)) { AMP_DEBUG_ERR("db_forget","Bad Params.",NULL); return -1; } CHKERR(sdr_begin_xn(sdr)); if(*primitiveObj != 0) { sdr_free(sdr, *primitiveObj); } if(*descObj != 0) { elt = sdr_list_first(sdr, list); while(elt) { if(sdr_list_data(sdr, elt) == *descObj) { sdr_list_delete(sdr, elt, NULL, NULL); sdr_free(sdr, *descObj); elt = 0; } else { elt = sdr_list_next(sdr, elt); } } } sdr_end_xn(sdr); /* Forget now invalid SDR pointers. */ *descObj = 0; *primitiveObj = 0; return 1; }
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; }
void destroyIonDb(char *iondbName) { Sdr sdr = getIonsdr(); IonDB iondbBuf; Object iondbObj; iondbObj = sdr_find(sdr, iondbName, NULL); if (iondbObj == NULL) return; sdr_read(sdr, (char *) &iondbBuf, iondbObj, sizeof(IonDB)); sdr_list_destroy(sdr, iondbBuf.contacts, NULL, NULL); sdr_list_destroy(sdr, iondbBuf.ranges, NULL, NULL); sdr_free(sdr, iondbObj); //fprintf(stderr, "ionDb destroyed: %d\n", getOwnNodeNbr()); }
static void releaseSdrAcsSignal(Object signalLElt) { Sdr bpSdr = getIonsdr(); Sdr acsSdr = getAcssdr(); Object signalAddr; SdrAcsSignal signal; SdrAcsPendingCust pendingCust; assert(signalLElt != 0); ASSERT_ACSSDR_XN; ASSERT_BPSDR_XN; if (acsSdr == NULL) { putErrmsg("Can't release ACS, SDR not available.", NULL); return; } signalAddr = sdr_list_data(acsSdr, signalLElt); if (signalAddr == 0) { ACSLOG_ERROR("Can't derefence ACS signal to release it."); return; } sdr_peek(acsSdr, signal, signalAddr); sdr_peek(acsSdr, pendingCust, signal.pendingCustAddr); /* Destroy the objects this AcsSignal contains */ sdr_list_destroy(acsSdr, signal.acsFills, releaseSdrAcsFill, NULL); if(signal.acsDue != 0) { destroyBpTimelineEvent(signal.acsDue); } if(signal.serializedZco != 0) { zco_destroy(bpSdr, signal.serializedZco); } /* Destroy this AcsSignal */ sdr_free(acsSdr, signalAddr); sdr_list_delete(acsSdr, signalLElt, NULL, NULL); }
static void releaseSdrAcsFill(Sdr sdr, Object elt, void *arg) { sdr_free(sdr, sdr_list_data(sdr, elt)); }
static int dispatchEvents(Sdr sdr, Object events, time_t currentTime) { Object elt; Object eventObj; OBJ_POINTER(BpEvent, event); int result; while (1) { sdr_begin_xn(sdr); CHKERR(ionLocked()); /* In case of killm. */ elt = sdr_list_first(sdr, events); if (elt == 0) /* No more events to dispatch. */ { sdr_exit_xn(sdr); return 0; } eventObj = sdr_list_data(sdr, elt); GET_OBJ_POINTER(sdr, BpEvent, event, eventObj); if (event->time > currentTime) { /* This is the first future event. */ sdr_exit_xn(sdr); return 0; } switch (event->type) { case expiredTTL: result = bpDestroyBundle(event->ref, 1); /* Note that bpDestroyBundle() always * erases the bundle's timeline event, * so we must NOT do so here. */ break; /* Out of switch. */ case xmitOverdue: result = bpReforwardBundle(event->ref); /* Note that bpReforwardBundle() always * erases the bundle's xmitOverdue event, * so we must NOT do so here. */ break; /* Out of switch. */ case ctDue: result = bpReforwardBundle(event->ref); /* Note that bpReforwardBundle() always * erases the bundle's ctDue event, so * we must NOT do so here. */ break; /* Out of switch. */ default: /* Spurious event; erase. */ sdr_free(sdr, eventObj); sdr_list_delete(sdr, elt, NULL, NULL); result = 0; /* Event is ignored. */ } if (result != 0) /* Dispatching failed. */ { sdr_cancel_xn(sdr); putErrmsg("Failed handing BP event.", NULL); return result; } if (sdr_end_xn(sdr) < 0) { putErrmsg("Failed dispatching BP event.", NULL); return -1; } } }
static int dispatchEvents(Sdr sdr, Object events, time_t currentTime) { Object elt; Object eventObj; LtpEvent event; int result; while (1) { sdr_begin_xn(sdr); elt = sdr_list_first(sdr, events); if (elt == 0) /* No more events to dispatch. */ { sdr_exit_xn(sdr); return 0; } eventObj = sdr_list_data(sdr, elt); sdr_read(sdr, (char *) &event, eventObj, sizeof(LtpEvent)); if (event.scheduledTime > currentTime) { /* This is the first future event. */ sdr_exit_xn(sdr); return 0; } sdr_free(sdr, eventObj); sdr_list_delete(sdr, elt, NULL, NULL); switch (event.type) { case LtpResendCheckpoint: result = ltpResendCheckpoint(event.refNbr2, event.refNbr3); break; /* Out of switch. */ case LtpResendXmitCancel: result = ltpResendXmitCancel(event.refNbr2); break; /* Out of switch. */ case LtpResendReport: result = ltpResendReport(event.refNbr1, event.refNbr2, event.refNbr3); break; /* Out of switch. */ case LtpResendRecvCancel: result = ltpResendRecvCancel(event.refNbr1, event.refNbr2); break; /* Out of switch. */ default: /* Spurious event. */ result = 0; /* Event is ignored. */ } if (result < 0) /* Dispatching failed. */ { sdr_cancel_xn(sdr); putErrmsg("failed handing LTP event", NULL); return result; } if (sdr_end_xn(sdr) < 0) { putErrmsg("failed dispatching LTP event", NULL); return -1; } } }
/* * This function writes an item and its associated descriptor into the SDR, * allocating space for each, and adding the SDR descriptor pointer to a * given SDR list. * * item : The serialized item to store in the SDR. * item_len: The size of the serialized item. * *itemObj: The SDR pointer to the serialized item in the SDR. * desc : The item descriptor being written to the SDR. * desc_len: The size of the item descriptor. * *descObj: The SDR pointer to the item's descriptor object in the SDR. * list : The SDR list holding the item descriptor (at *descrObj). */ int db_persist(uint8_t *item, uint32_t item_len, Object *itemObj, void *desc, uint32_t desc_len, Object *descObj, Object list) { Sdr sdr = getIonsdr(); CHKERR(sdr_begin_xn(sdr)); /* Step 1: Allocate a descriptor object for this item in the SDR. */ if((*descObj = sdr_malloc(sdr, desc_len)) == 0) { sdr_cancel_xn(sdr); AMP_DEBUG_ERR("db_persist", "Can't allocate descriptor of size %d.", desc_len); return -1; } /* Step 2: Allocate space for the serialized rule in the SDR. */ if((*itemObj = sdr_malloc(sdr, item_len)) == 0) { sdr_free(sdr, *descObj); sdr_cancel_xn(sdr); *descObj = 0; AMP_DEBUG_ERR("db_persist", "Unable to allocate Item in SDR. Size %d.", item_len); return -1; } /* Step 3: Write the item to the SDR. */ sdr_write(sdr, *itemObj, (char *) item, item_len); /* Step 4: Write the item descriptor to the SDR. */ sdr_write(sdr, *descObj, (char *) desc, desc_len); /* Step 5: Save the descriptor in the AgentDB active rules list. */ if (sdr_list_insert_last(sdr, list, *descObj) == 0) { sdr_free(sdr, *itemObj); sdr_free(sdr, *descObj); sdr_cancel_xn(sdr); *itemObj = 0; *descObj = 0; AMP_DEBUG_ERR("db_persist", "Unable to insert item Descr. in SDR.", NULL); return -1; } if(sdr_end_xn(sdr)) { AMP_DEBUG_ERR("db_persist", "Can't create Agent database.", NULL); return -1; } return 1; }
static void deleteContact(PsmAddress cxaddr) { Sdr sdr = getIonsdr(); PsmPartition ionwm = getIonwm(); IonVdb *vdb = getIonVdb(); time_t currentTime = getUTCTime(); IonCXref *cxref; Object obj; IonEvent event; IonNeighbor *neighbor; PsmAddress nextElt; cxref = (IonCXref *) psp(ionwm, cxaddr); /* Delete contact events from timeline. */ event.ref = cxaddr; if (cxref->startXmit) { event.time = cxref->startXmit; event.type = IonStartXmit; sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); } if (cxref->stopXmit) { event.time = cxref->stopXmit; event.type = IonStopXmit; sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); } if (cxref->startFire) { event.time = cxref->startFire; event.type = IonStartFire; sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); } if (cxref->stopFire) { event.time = cxref->stopFire; event.type = IonStopFire; sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); } if (cxref->startRecv) { event.time = cxref->startRecv; event.type = IonStartRecv; sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); } if (cxref->stopRecv) { event.time = cxref->stopRecv; event.type = IonStopRecv; sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); } if (cxref->purgeTime) { event.time = cxref->purgeTime; event.type = IonPurgeContact; sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); } /* Apply to current state as necessary. */ if (currentTime >= cxref->startXmit && currentTime <= cxref->stopXmit) { neighbor = findNeighbor(vdb, cxref->toNode, &nextElt); if (neighbor) { neighbor->xmitRate = 0; } } if (currentTime >= cxref->startFire && currentTime <= cxref->stopFire) { neighbor = findNeighbor(vdb, cxref->fromNode, &nextElt); if (neighbor) { neighbor->fireRate = 0; } } if (currentTime >= cxref->startRecv && currentTime <= cxref->stopRecv) { neighbor = findNeighbor(vdb, cxref->fromNode, &nextElt); if (neighbor) { neighbor->recvRate = 0; } } /* Delete contact from index. */ if (cxref->toTime > currentTime) /* Affects routes. */ { vdb->lastEditTime = currentTime; } sm_rbt_delete(ionwm, vdb->contactIndex, rfx_order_contacts, cxref, rfx_erase_data, NULL); /* Delete contact from non-volatile database. */ obj = sdr_list_data(sdr, cxref->contactElt); sdr_list_delete(sdr, cxref->contactElt, NULL, NULL); sdr_free(sdr, obj); }
static void deleteRange(PsmAddress rxaddr, int conditional) { Sdr sdr = getIonsdr(); PsmPartition ionwm = getIonwm(); IonVdb *vdb = getIonVdb(); time_t currentTime = getUTCTime(); IonRXref *rxref; Object obj; IonEvent event; IonNeighbor *neighbor; PsmAddress nextElt; rxref = (IonRXref *) psp(ionwm, rxaddr); /* Delete range from non-volatile database. */ if (rxref->rangeElt) /* An asserted range. */ { if (conditional) /* Delete only if imputed. */ { return; /* Retain asserted range. */ } /* Unconditional deletion; remove range from DB. */ obj = sdr_list_data(sdr, rxref->rangeElt); sdr_free(sdr, obj); sdr_list_delete(sdr, rxref->rangeElt, NULL, NULL); } /* Delete range events from timeline. */ event.ref = rxaddr; event.time = rxref->fromTime; if (rxref->rangeElt) { event.type = IonStartAssertedRange; } else { event.type = IonStartImputedRange; } sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); event.time = rxref->toTime; if (rxref->rangeElt) { event.type = IonStopAssertedRange; } else { event.type = IonStopImputedRange; } sm_rbt_delete(ionwm, vdb->timeline, rfx_order_events, &event, rfx_erase_data, NULL); /* Apply to current state as necessary. */ if (currentTime >= rxref->fromTime && currentTime <= rxref->toTime) { if (rxref->fromNode == getOwnNodeNbr()) { neighbor = findNeighbor(vdb, rxref->toNode, &nextElt); if (neighbor) { neighbor->owltOutbound = 0; } } if (rxref->toNode == getOwnNodeNbr()) { neighbor = findNeighbor(vdb, rxref->fromNode, &nextElt); if (neighbor) { neighbor->owltInbound = 0; } } } /* Delete range from index. */ if (rxref->toTime > currentTime) /* Affects routes. */ { vdb->lastEditTime = currentTime; } sm_rbt_delete(ionwm, vdb->rangeIndex, rfx_order_ranges, rxref, rfx_erase_data, NULL); }