/*
* objectEntryDelete - Delete a object from structure objectEntry
* @objectEntry: pointer to root structure
* @obejctEntryOID: pointer to the deleted objectEntryOID
*
* return 0-no obj. was deleted, 1-OID was deleted,2-OID,AID was deleted,
* 3-OID,AID,HID was deleted
*/
int
objectEntryDelete(ORTEDomain *d,ObjectEntryOID *objectEntryOID,Boolean destroy) {
ObjectEntryHID *objectEntryHID;
ObjectEntryAID *objectEntryAID;
int result=0;
debug(8,10) ("objectEntryDelete: start\n");
if (!objectEntryOID) return result;
objectEntryHID=objectEntryOID->objectEntryHID;
objectEntryAID=objectEntryOID->objectEntryAID;
//Destroy object on level OID
eventDetach(d,
objectEntryOID->objectEntryAID,
&objectEntryOID->expirationPurgeTimer,
0);
eventDetach(d,
objectEntryOID->objectEntryAID,
&objectEntryOID->sendCallBackDelayTimer,
0);
FREE(objectEntryOID->attributes);
if (objectEntryAID->aobject==objectEntryOID) {
objectEntryAID->aobject=NULL;
debug(8,5) ("objectEntry: Object: %#10.8x deleted from AID\n",objectEntryOID->oid);
}
if (destroy) {
ObjectEntryOID_delete(objectEntryAID,objectEntryOID);
FREE(objectEntryOID);
}
debug(8,5) ("objectEntry: Object: %#10.8x deleted\n",objectEntryOID->oid);
result=1;
//Destroy object on level AID
if (ObjectEntryOID_is_empty(objectEntryAID)) {
debug(8,5) ("objectEntry: App : %#10.8x deleted\n",objectEntryAID->aid);
if (destroy) {
ObjectEntryAID_delete(objectEntryHID,objectEntryAID);
FREE(objectEntryAID);
}
result=2;
}
//Destroy object on level HID
if (ObjectEntryAID_is_empty(objectEntryHID)) {
debug(8,5) ("objectEntry: Host : %#10.8x deleted\n",objectEntryHID->hid);
if (destroy) {
ObjectEntryHID_delete(&d->objectEntry,objectEntryHID);
FREE(objectEntryHID);
}
result=3;
}
debug(8,10) ("objectEntryDelete: finished\n");
return result;
}
void
objectEntryRefreshApp(ORTEDomain *d,ObjectEntryOID *objectEntryOID) {
if (!objectEntryOID) return;
if ((objectEntryOID->oid!=OID_APP) ||
(objectEntryOID->guid.aid==AID_UNKNOWN) ||
(!gavl_cmp_guid(&objectEntryOID->guid,&d->guid))) return;
eventDetach(d,
objectEntryOID->objectEntryAID,
&objectEntryOID->expirationPurgeTimer,
0);
eventAdd(d,
objectEntryOID->objectEntryAID,
&objectEntryOID->expirationPurgeTimer,
0,
"ExpirationTimer",
objectEntryExpirationTimer,
NULL,
objectEntryOID,
&((AppParams*)objectEntryOID->attributes)->expirationTime);
debug(8,3) ("refreshed: 0x%x-0x%x\n",
objectEntryOID->objectEntryHID->hid,
objectEntryOID->objectEntryAID->aid);
}
void
RTPSAck(ORTEDomain *d, CDR_Codec *cdrCodec, MessageInterpret *mi, IPAddress senderIPAddress)
{
GUID_RTPS readerGUID;
CSTWriter *cstWriter = NULL;
CSTRemoteReader *cstRemoteReader;
CSChangeForReader *csChangeForReader;
StateMachineSend stateMachineSendNew;
ObjectId roid, woid;
SequenceNumber sn, isn;
char queue = 1;
CDR_Endianness data_endian;
CORBA_octet flags;
char f_bit;
/* restore flag possition in submessage */
cdrCodec->rptr -= 3;
/* flags */
CDR_get_octet(cdrCodec, (CORBA_octet *)&flags);
f_bit = flags & 2;
/* move reading possition to begin of submessage */
cdrCodec->rptr += 2;
/* next data are sent in big endianing */
data_endian = cdrCodec->data_endian;
cdrCodec->data_endian = FLAG_BIG_ENDIAN;
/* readerObjectId */
CDR_get_ulong(cdrCodec, (CORBA_unsigned_long *)&roid);
/* writerObjectId */
CDR_get_ulong(cdrCodec, (CORBA_unsigned_long *)&woid);
cdrCodec->data_endian = data_endian;
/* SeqNumber */
CDR_get_ulong(cdrCodec, (CORBA_unsigned_long *)&sn.high);
CDR_get_ulong(cdrCodec, (CORBA_unsigned_long *)&sn.low);
readerGUID.hid = mi->sourceHostId;
readerGUID.aid = mi->sourceAppId;
readerGUID.oid = roid;
debug(47, 3) ("recv: RTPS ACK%c(0x%x) from 0x%x-0x%x\n",
f_bit ? 'F' : 'f',
woid, mi->sourceHostId, mi->sourceAppId);
/* Manager */
if ((d->guid.aid & 0x03) == MANAGER) {
switch (woid) {
case OID_WRITE_APPSELF:
pthread_rwlock_wrlock(&d->writerApplicationSelf.lock);
cstWriter = &d->writerApplicationSelf;
readerGUID.hid = senderIPAddress;
readerGUID.aid = AID_UNKNOWN;
readerGUID.oid = roid;
eventDetach(d,
cstWriter->objectEntryOID->objectEntryAID,
&cstWriter->registrationTimer,
0); //common timer
break;
case OID_WRITE_MGR:
pthread_rwlock_wrlock(&d->writerManagers.lock);
cstWriter = &d->writerManagers;
break;
case OID_WRITE_APP:
pthread_rwlock_wrlock(&d->writerApplications.lock);
cstWriter = &d->writerApplications;
break;
}
}
/* Application */
if ((d->guid.aid & 0x03) == MANAGEDAPPLICATION) {
switch (roid) {
case OID_READ_APP:
case OID_READ_APPSELF:
pthread_rwlock_wrlock(&d->writerApplicationSelf.lock);
cstWriter = &d->writerApplicationSelf;
eventDetach(d,
cstWriter->objectEntryOID->objectEntryAID,
&cstWriter->registrationTimer,
0); //common timer
break;
case OID_READ_PUBL:
pthread_rwlock_wrlock(&d->writerPublications.lock);
cstWriter = &d->writerPublications;
break;
case OID_READ_SUBS:
pthread_rwlock_wrlock(&d->writerSubscriptions.lock);
cstWriter = &d->writerSubscriptions;
break;
default:
if ((woid & 0x07) == OID_PUBLICATION) {
GUID_RTPS guid = d->guid;
guid.oid = woid;
pthread_rwlock_rdlock(&d->publications.lock);
cstWriter = CSTWriter_find(&d->publications, &guid);
pthread_rwlock_wrlock(&cstWriter->lock);
queue = 2;
}
break;
}
}
if (!cstWriter) {
if ((woid & 0x07) == OID_PUBLICATION)
pthread_rwlock_unlock(&d->publications.lock);
return;
}
cstRemoteReader = CSTRemoteReader_find(cstWriter, &readerGUID);
if (!cstRemoteReader) {
pthread_rwlock_unlock(&cstWriter->lock);
if ((woid & 0x07) == OID_PUBLICATION)
pthread_rwlock_unlock(&d->publications.lock);
return;
}
stateMachineSendNew = NOTHNIGTOSEND;
csChangeForReader = CSChangeForReader_first(cstRemoteReader);
while (csChangeForReader) {
isn = csChangeForReader->csChange->sn;
if (SeqNumberCmp(csChangeForReader->csChange->gapSN, noneSN) > 0) {
SeqNumberAdd(isn, csChangeForReader->csChange->sn, csChangeForReader->csChange->gapSN);
SeqNumberDec(isn, isn);
}
if (SeqNumberCmp(isn, sn) < 0) { //ACK
if (csChangeForReader->commStateChFReader != ACKNOWLEDGED) {
CSChangeForReader *csChangeForReaderDestroyed;
csChangeForReaderDestroyed = csChangeForReader;
csChangeForReader->commStateChFReader = ACKNOWLEDGED;
csChangeForReader =
CSChangeForReader_next(cstRemoteReader, csChangeForReader);
if ((woid & 0x07) == OID_PUBLICATION) {
CSTWriterDestroyCSChangeForReader(
csChangeForReaderDestroyed, ORTE_TRUE);
}
} else {
csChangeForReader =
CSChangeForReader_next(cstRemoteReader, csChangeForReader);
}
} else { //NACK
if (csChangeForReader->commStateChFReader != TOSEND) {
csChangeForReader->commStateChFReader = TOSEND;
cstRemoteReader->commStateToSentCounter++;
}
stateMachineSendNew = MUSTSENDDATA;
csChangeForReader =
CSChangeForReader_next(cstRemoteReader, csChangeForReader);
}
}
if ((cstRemoteReader->commStateSend == NOTHNIGTOSEND) &&
(stateMachineSendNew == MUSTSENDDATA)) {
cstRemoteReader->commStateSend = stateMachineSendNew;
eventDetach(d,
cstRemoteReader->sobject->objectEntryAID,
&cstRemoteReader->delayResponceTimer,
queue);
if (queue == 1) {
eventAdd(d,
cstRemoteReader->sobject->objectEntryAID,
&cstRemoteReader->delayResponceTimer,
queue, //metatraffic timer
"CSTWriterSendTimer",
CSTWriterSendTimer,
&cstRemoteReader->cstWriter->lock,
cstRemoteReader,
&cstRemoteReader->cstWriter->params.delayResponceTime);
} else {
eventAdd(d,
cstRemoteReader->sobject->objectEntryAID,
&cstRemoteReader->delayResponceTimer,
queue, //userdata timer
"CSTWriterSendStrictTimer",
CSTWriterSendStrictTimer,
&cstRemoteReader->cstWriter->lock,
cstRemoteReader,
&cstRemoteReader->cstWriter->params.delayResponceTime);
}
}
if (stateMachineSendNew == NOTHNIGTOSEND) {
cstRemoteReader->commStateSend = NOTHNIGTOSEND;
if (queue == 1) {
eventDetach(d,
cstRemoteReader->sobject->objectEntryAID,
&cstRemoteReader->delayResponceTimer,
queue);
} else {
eventDetach(d,
cstRemoteReader->sobject->objectEntryAID,
&cstRemoteReader->repeatAnnounceTimer,
queue);
}
}
if ((!f_bit) && (cstRemoteReader->commStateSend == NOTHNIGTOSEND)) {
cstRemoteReader->commStateHB = MUSTSENDHB;
eventDetach(d,
cstRemoteReader->sobject->objectEntryAID,
&cstRemoteReader->delayResponceTimer,
queue);
if (queue == 1) {
eventAdd(d,
cstRemoteReader->sobject->objectEntryAID,
&cstRemoteReader->delayResponceTimer,
queue, //metatraffic timer
"CSTWriterSendTimer",
CSTWriterSendTimer,
&cstRemoteReader->cstWriter->lock,
cstRemoteReader,
&cstRemoteReader->cstWriter->params.delayResponceTime);
} else {
eventAdd(d,
cstRemoteReader->sobject->objectEntryAID,
&cstRemoteReader->delayResponceTimer,
queue, //userdata timer
"CSTWriterSendStrictTimer",
CSTWriterSendStrictTimer,
&cstRemoteReader->cstWriter->lock,
cstRemoteReader,
&cstRemoteReader->cstWriter->params.delayResponceTime);
}
}
pthread_rwlock_unlock(&cstWriter->lock);
if ((woid & 0x07) == OID_PUBLICATION)
pthread_rwlock_unlock(&d->publications.lock);
}
