void handleDelayResp(MsgHeader *header, Octet *msgIbuf, ssize_t length, Boolean isFromSelf, PtpClock *ptpClock)
{
MsgDelayResp *resp;
if(length < DELAY_RESP_PACKET_LENGTH)
{
ERROR("short delay request message\n");
toState(PTP_FAULTY, ptpClock);
return;
}
switch(ptpClock->port_state)
{
case PTP_SLAVE:
if(isFromSelf)
{
DBG("handleDelayResp: ignore from self\n");
return;
}
resp = &ptpClock->msgTmp.resp;
msgUnpackDelayResp(ptpClock->msgIbuf, resp);
if( ptpClock->sentDelayReq
&& resp->requestingSourceSequenceId == ptpClock->sentDelayReqSequenceId
&& resp->requestingSourceCommunicationTechnology == ptpClock->port_communication_technology
&& resp->requestingSourcePortId == ptpClock->port_id_field
&& !memcmp(resp->requestingSourceUuid, ptpClock->port_uuid_field, PTP_UUID_LENGTH)
&& header->sourceCommunicationTechnology == ptpClock->parent_communication_technology
&& header->sourcePortId == ptpClock->parent_port_id
&& !memcmp(header->sourceUuid, ptpClock->parent_uuid, PTP_UUID_LENGTH) )
{
ptpClock->sentDelayReq = FALSE;
toInternalTime(&ptpClock->delay_req_receive_time, &resp->delayReceiptTimestamp, &ptpClock->halfEpoch);
if(ptpClock->delay_req_send_time.seconds)
{
updateDelay(&ptpClock->delay_req_send_time, &ptpClock->delay_req_receive_time,
&ptpClock->owd_filt, ptpClock);
ptpClock->delay_req_send_time.seconds = 0;
ptpClock->delay_req_send_time.nanoseconds = 0;
ptpClock->delay_req_receive_time.seconds = 0;
ptpClock->delay_req_receive_time.nanoseconds = 0;
}
}
else
{
DBGV("handleDelayResp: unwanted\n");
}
break;
default:
DBGV("handleDelayResp: disreguard\n");
return;
}
}
static void handleDelayResp(PtpClock *ptpClock, Boolean isFromSelf)
{
Boolean isFromCurrentParent = FALSE;
Boolean isCurrentRequest = FALSE;
TimeInternal correctionField;
switch (ptpClock->portDS.delayMechanism)
{
case E2E:
DBGV("handleDelayResp: received\n");
if (ptpClock->msgIbufLength < DELAY_RESP_LENGTH)
{
ERROR("handleDelayResp: short message\n");
toState(ptpClock, PTP_FAULTY);
return;
}
switch (ptpClock->portDS.portState)
{
case PTP_INITIALIZING:
case PTP_FAULTY:
case PTP_DISABLED:
case PTP_LISTENING:
DBGV("handleDelayResp: disreguard\n");
return;
case PTP_UNCALIBRATED:
case PTP_SLAVE:
msgUnpackDelayResp(ptpClock->msgIbuf, &ptpClock->msgTmp.resp);
isFromCurrentParent = isSamePortIdentity(
&ptpClock->parentDS.parentPortIdentity,
&ptpClock->msgTmpHeader.sourcePortIdentity);
isCurrentRequest = isSamePortIdentity(
&ptpClock->portDS.portIdentity,
&ptpClock->msgTmp.resp.requestingPortIdentity);
if (((ptpClock->sentDelayReqSequenceId - 1) == ptpClock->msgTmpHeader.sequenceId)
&& isCurrentRequest && isFromCurrentParent)
{
/* TODO: revisit 11.3 */
toInternalTime(&ptpClock->timestamp_delayReqRecieve, &ptpClock->msgTmp.resp.receiveTimestamp);
scaledNanosecondsToInternalTime(&ptpClock->msgTmpHeader.correctionfield, &correctionField);
updateDelay(ptpClock, &ptpClock->timestamp_delayReqSend, &ptpClock->timestamp_delayReqRecieve, &correctionField);
ptpClock->portDS.logMinDelayReqInterval = ptpClock->msgTmpHeader.logMessageInterval;
}
else
{
DBGV("handleDelayResp: doesn't match with the delayReq\n");
break;
}
}
break;
case P2P:
ERROR("handleDelayResp: disreguard in P2P mode\n");
break;
default:
break;
}
}
void
handleDelayResp(MsgHeader *header, Octet *msgIbuf, ssize_t length,
Boolean isFromSelf, RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
if (ptpClock->delayMechanism == E2E) {
Boolean isFromCurrentParent = FALSE;
TimeInternal requestReceiptTimestamp;
TimeInternal correctionField;
DBGV("delayResp message received : \n");
if(length < DELAY_RESP_LENGTH) {
ERROR("short DelayResp message\n");
toState(PTP_FAULTY, rtOpts, ptpClock);
return;
}
switch(ptpClock->portState) {
case PTP_INITIALIZING:
case PTP_FAULTY:
case PTP_DISABLED:
case PTP_UNCALIBRATED:
case PTP_LISTENING:
DBGV("HandledelayResp : disregard\n");
return;
case PTP_SLAVE:
msgUnpackDelayResp(ptpClock->msgIbuf,
&ptpClock->msgTmp.resp);
if ((memcmp(ptpClock->parentPortIdentity.clockIdentity,
header->sourcePortIdentity.clockIdentity,
CLOCK_IDENTITY_LENGTH) == 0 ) &&
(ptpClock->parentPortIdentity.portNumber ==
header->sourcePortIdentity.portNumber))
isFromCurrentParent = TRUE;
if ((memcmp(ptpClock->portIdentity.clockIdentity,
ptpClock->msgTmp.resp.requestingPortIdentity.clockIdentity,
CLOCK_IDENTITY_LENGTH) == 0) &&
((ptpClock->sentDelayReqSequenceId - 1)==
header->sequenceId) &&
(ptpClock->portIdentity.portNumber ==
ptpClock->msgTmp.resp.requestingPortIdentity.portNumber)
&& isFromCurrentParent) {
DBG("==> Handle DelayResp (%d)\n",
header->sequenceId);
if (!ptpClock->waitingForDelayResp) {
break;
}
ptpClock->waitingForDelayResp = FALSE;
toInternalTime(&requestReceiptTimestamp,
&ptpClock->msgTmp.resp.receiveTimestamp);
ptpClock->delay_req_receive_time.seconds =
requestReceiptTimestamp.seconds;
ptpClock->delay_req_receive_time.nanoseconds =
requestReceiptTimestamp.nanoseconds;
integer64_to_internalTime(
header->correctionfield,
&correctionField);
/*
send_time = delay_req_send_time (received as CMSG in handleEvent)
recv_time = requestReceiptTimestamp (received inside delayResp)
*/
updateDelay(&ptpClock->owd_filt,
rtOpts,ptpClock, &correctionField);
if (ptpClock->waiting_for_first_delayresp) {
ptpClock->waiting_for_first_delayresp = FALSE;
NOTICE(" received first DelayResp from Master\n");
}
if (rtOpts->ignore_delayreq_interval_master == 0) {
DBGV("current delay_req: %d new delay req: %d \n",
ptpClock->logMinDelayReqInterval,
header->logMessageInterval);
/* Accept new DelayReq value from the Master */
if (ptpClock->logMinDelayReqInterval != header->logMessageInterval) {
NOTICE(" received new DelayReq frequency %d from Master (was: %d)\n",
header->logMessageInterval, ptpClock->logMinDelayReqInterval );
}
// collect new value indicated from the Master
ptpClock->logMinDelayReqInterval = header->logMessageInterval;
/* FIXME: the actual rearming of this timer with the new value only happens later in doState()/issueDelayReq() */
} else {
if (ptpClock->logMinDelayReqInterval != rtOpts->subsequent_delayreq) {
NOTICE(" received new DelayReq frequency %d from command line (was: %d)\n",
rtOpts->subsequent_delayreq, ptpClock->logMinDelayReqInterval);
}
ptpClock->logMinDelayReqInterval = rtOpts->subsequent_delayreq;
}
} else {
DBG("HandledelayResp : delayResp doesn't match with the delayReq. \n");
break;
}
}
} else { /* (Peer to Peer mode) */
ERROR("Delay messages are disregarded in Peer to Peer mode \n");
}
}
