static void handleDelayReq(PtpClock *ptpClock, TimeInternal *time, Boolean isFromSelf)
{
switch (ptpClock->portDS.delayMechanism)
{
case E2E:
DBGV("handleDelayReq: received\n");
if (ptpClock->msgIbufLength < DELAY_REQ_LENGTH)
{
ERROR("handleDelayReq: short message\n");
toState(ptpClock, PTP_FAULTY);
return;
}
switch (ptpClock->portDS.portState)
{
case PTP_INITIALIZING:
case PTP_FAULTY:
case PTP_DISABLED:
case PTP_UNCALIBRATED:
case PTP_LISTENING:
DBGV("handleDelayReq: disreguard\n");
return;
case PTP_SLAVE:
DBGV("handleDelayReq: disreguard\n");
// if (isFromSelf)
// {
// /* waitingForLoopback? */
// /* Get sending timestamp from IP stack with So_TIMESTAMP*/
// ptpClock->delay_req_send_time = *time;
// /*Add latency*/
// addTime(&ptpClock->delay_req_send_time, &ptpClock->delay_req_send_time, &rtOpts->outboundLatency);
// break;
// }
break;
case PTP_MASTER:
/* TODO: manage the value of ptpClock->logMinDelayReqInterval form logSyncInterval to logSyncInterval + 5 */
issueDelayResp(ptpClock, time, &ptpClock->msgTmpHeader);
break;
default:
DBG("handleDelayReq: unrecognized state\n");
break;
}
break;
case P2P:
ERROR("handleDelayReq: disreguard in P2P mode\n");
break;
default:
/* none */
break;
}
}
void handleDelayReq(MsgHeader *header, Octet *msgIbuf, ssize_t length, TimeInternal *time, Boolean badTime, Boolean isFromSelf, PtpClock *ptpClock)
{
if(length < DELAY_REQ_PACKET_LENGTH)
{
ERROR("short delay request message\n");
toState(PTP_FAULTY, ptpClock);
return;
}
switch(ptpClock->port_state)
{
case PTP_MASTER:
if(isFromSelf)
{
DBG("handleDelayReq: ignore from self\n");
return;
}
if( header->sourceCommunicationTechnology == ptpClock->clock_communication_technology
|| header->sourceCommunicationTechnology == PTP_DEFAULT
|| ptpClock->clock_communication_technology == PTP_DEFAULT )
{
if( badTime )
NOTIFY("avoid inaccurate DelayResp because of bad time stamp\n");
else
issueDelayResp(time, &ptpClock->msgTmpHeader, ptpClock);
}
break;
case PTP_SLAVE:
if(isFromSelf)
{
DBG("handleDelayReq: self\n");
ptpClock->delay_req_send_time.seconds = time->seconds;
ptpClock->delay_req_send_time.nanoseconds = time->nanoseconds;
addTime(&ptpClock->delay_req_send_time, &ptpClock->delay_req_send_time, &ptpClock->runTimeOpts.outboundLatency);
if(ptpClock->delay_req_receive_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;
}
}
break;
default:
DBGV("handleDelayReq: disreguard\n");
return;
}
}
void
handleDelayReq(MsgHeader *header, Octet *msgIbuf, ssize_t length,
TimeInternal *time, Boolean isFromSelf,
RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
if (ptpClock->delayMechanism == E2E) {
DBGV("delayReq message received : \n");
if (length < DELAY_REQ_LENGTH) {
ERROR("short DelayReq 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:
case PTP_PASSIVE:
DBGV("HandledelayReq : disregard\n");
return;
case PTP_SLAVE:
if (isFromSelf) {
DBG("==> Handle DelayReq (%d)\n",
header->sequenceId);
if ((ptpClock->sentDelayReqSequenceId - 1) != header->sequenceId) {
INFO("HandledelayReq : disreguard delayreq because of wrong SeqNo\n");
break;
}
/*
* Get sending timestamp from IP stack
* with SO_TIMESTAMP
*/
/*
* Make sure we process the REQ _before_ the RESP. While we could do this by any order,
* (because it's implicitly indexed by (ptpClock->sentDelayReqSequenceId - 1), this is
* now made explicit
*/
ptpClock->waitingForDelayResp = TRUE;
ptpClock->delay_req_send_time.seconds =
time->seconds;
ptpClock->delay_req_send_time.nanoseconds =
time->nanoseconds;
/*Add latency*/
addTime(&ptpClock->delay_req_send_time,
&ptpClock->delay_req_send_time,
&rtOpts->outboundLatency);
break;
} else {
DBG2("HandledelayReq : disreguard delayreq from other client\n");
}
break;
case PTP_MASTER:
msgUnpackHeader(ptpClock->msgIbuf,
&ptpClock->delayReqHeader);
#ifdef PTP_EXPERIMENTAL
// remember IP address of this client for -U option
ptpClock->LastSlaveAddr = ptpClock->netPath.lastRecvAddr;
#endif
issueDelayResp(time,&ptpClock->delayReqHeader,
rtOpts,ptpClock);
break;
default:
DBG("do unrecognized state2\n");
break;
}
} else /* (Peer to Peer mode) */
ERROR("Delay messages are ignored in Peer to Peer mode\n");
}
