void issueDelayResp(TimeInternal *time, MsgHeader *header, PtpClock *ptpClock)
{
TimeRepresentation delayReceiptTimestamp;
++ptpClock->last_general_event_sequence_number;
fromInternalTime(time, &delayReceiptTimestamp, ptpClock->halfEpoch);
msgPackDelayResp(ptpClock->msgObuf, header, &delayReceiptTimestamp, ptpClock);
if(!netSendGeneral(ptpClock->msgObuf, DELAY_RESP_PACKET_LENGTH, ptpClock))
toState(PTP_FAULTY, ptpClock);
else
DBGV("sent delay response message\n");
}
void issueManagement(MsgHeader *header, MsgManagement *manage, PtpClock *ptpClock)
{
UInteger16 length;
++ptpClock->last_general_event_sequence_number;
if(!(length = msgPackManagementResponse(ptpClock->msgObuf, header, manage, ptpClock)))
return;
if(!netSendGeneral(ptpClock->msgObuf, length, ptpClock))
toState(PTP_FAULTY, ptpClock);
else
DBGV("sent management message\n");
}
/*Pack and send on general multicast ip adress an Announce message*/
void
issueAnnounce(RunTimeOpts *rtOpts,PtpClock *ptpClock)
{
msgPackAnnounce(ptpClock->msgObuf,ptpClock);
if (!netSendGeneral(ptpClock->msgObuf,ANNOUNCE_LENGTH,
&ptpClock->netPath, 0)) {
toState(PTP_FAULTY,rtOpts,ptpClock);
DBGV("Announce message can't be sent -> FAULTY state \n");
} else {
DBGV("Announce MSG sent ! \n");
ptpClock->sentAnnounceSequenceId++;
}
}
void issueFollowup(TimeInternal *time, PtpClock *ptpClock)
{
TimeRepresentation preciseOriginTimestamp;
++ptpClock->last_general_event_sequence_number;
fromInternalTime(time, &preciseOriginTimestamp, ptpClock->halfEpoch);
msgPackFollowUp(ptpClock->msgObuf, ptpClock->last_sync_event_sequence_number, &preciseOriginTimestamp, ptpClock);
if(!netSendGeneral(ptpClock->msgObuf, FOLLOW_UP_PACKET_LENGTH, ptpClock))
toState(PTP_FAULTY, ptpClock);
else
DBGV("sent followup message\n");
}
/*Pack and send on general multicast ip adress an Announce message*/
static void issueAnnounce(PtpClock *ptpClock)
{
msgPackAnnounce(ptpClock, ptpClock->msgObuf);
if (!netSendGeneral(&ptpClock->netPath, ptpClock->msgObuf, ANNOUNCE_LENGTH))
{
ERROR("issueAnnounce: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issueAnnounce\n");
ptpClock->sentAnnounceSequenceId++;
}
}
/*Pack and send on event multicast ip adress a DelayResp message*/
static void issueDelayResp(PtpClock *ptpClock, const TimeInternal *time, const MsgHeader * delayReqHeader)
{
Timestamp requestReceiptTimestamp;
fromInternalTime(time, &requestReceiptTimestamp);
msgPackDelayResp(ptpClock, ptpClock->msgObuf, delayReqHeader, &requestReceiptTimestamp);
if (!netSendGeneral(&ptpClock->netPath, ptpClock->msgObuf, PDELAY_RESP_LENGTH))
{
ERROR("issueDelayResp: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issueDelayResp\n");
}
}
/*Pack and send on general multicast ip adress a FollowUp message*/
void
issueFollowup(TimeInternal *time,RunTimeOpts *rtOpts,PtpClock *ptpClock)
{
Timestamp preciseOriginTimestamp;
fromInternalTime(time,&preciseOriginTimestamp);
msgPackFollowUp(ptpClock->msgObuf,&preciseOriginTimestamp,ptpClock);
if (!netSendGeneral(ptpClock->msgObuf,FOLLOW_UP_LENGTH,
&ptpClock->netPath, 0)) {
toState(PTP_FAULTY,rtOpts,ptpClock);
DBGV("FollowUp message can't be sent -> FAULTY state \n");
} else {
DBGV("FollowUp MSG sent ! \n");
}
}
/*Pack and send on general multicast ip adress a FollowUp message*/
static void issueFollowup(PtpClock *ptpClock, const TimeInternal *time)
{
Timestamp preciseOriginTimestamp;
fromInternalTime(time, &preciseOriginTimestamp);
msgPackFollowUp(ptpClock, ptpClock->msgObuf, &preciseOriginTimestamp);
if (!netSendGeneral(&ptpClock->netPath, ptpClock->msgObuf, FOLLOW_UP_LENGTH))
{
ERROR("issueFollowup: can't sent\n");
toState(ptpClock, PTP_FAULTY);
}
else
{
DBGV("issueFollowup\n");
}
}
/*Pack and send on event multicast ip adress a DelayResp message*/
void
issueDelayResp(TimeInternal *time,MsgHeader *header,RunTimeOpts *rtOpts, PtpClock *ptpClock)
{
Timestamp requestReceiptTimestamp;
fromInternalTime(time,&requestReceiptTimestamp);
msgPackDelayResp(ptpClock->msgObuf,header,&requestReceiptTimestamp,
ptpClock);
Integer32 dst = 0;
#ifdef PTP_EXPERIMENTAL
if (rtOpts->do_hybrid_mode) {
dst = ptpClock->LastSlaveAddr;
}
#endif
if (!netSendGeneral(ptpClock->msgObuf,PDELAY_RESP_LENGTH,
&ptpClock->netPath, dst)) {
toState(PTP_FAULTY,rtOpts,ptpClock);
DBGV("delayResp message can't be sent -> FAULTY state \n");
} else {
DBGV("PDelayResp MSG sent ! \n");
}
}
void probe(PtpClock *ptpClock)
{
UInteger16 i;
UInteger16 length;
TimeInternal interval, now, finish;
/* check */
if(ptpClock->runTimeOpts.probe_management_key == PTP_MM_UPDATE_DEFAULT_DATA_SET
|| ptpClock->runTimeOpts.probe_management_key == PTP_MM_UPDATE_GLOBAL_TIME_PROPERTIES
|| ptpClock->runTimeOpts.probe_management_key == PTP_MM_SET_SYNC_INTERVAL)
{
ERROR("send not supported for that management message\n");
return;
}
/* init */
if(!netInit(ptpClock))
{
ERROR("failed to initialize network\n");
return;
}
initData(ptpClock);
msgPackHeader(ptpClock->msgObuf, ptpClock);
memset(&ptpClock->msgTmp.manage, 0, sizeof(MsgManagement));
ptpClock->msgTmp.manage.targetCommunicationTechnology = PTP_DEFAULT;
/* send */
for(i = 0; i < KEY_ARRAY_LEN; ++i)
{
if(ptpClock->runTimeOpts.probe_management_key > 0)
{
ptpClock->msgTmp.manage.managementMessageKey = ptpClock->runTimeOpts.probe_management_key;
ptpClock->msgTmp.manage.recordKey = ptpClock->runTimeOpts.probe_record_key;
}
else
ptpClock->msgTmp.manage.managementMessageKey = management_key_array[i];
if(!(length = msgPackManagement(ptpClock->msgObuf, &ptpClock->msgTmp.manage, ptpClock)))
{
ERROR("failed to pack management message\n");
return;
}
printf("\n(sending managementMessageKey %hhu)\n", ptpClock->msgTmp.manage.managementMessageKey);
if(!netSendGeneral(ptpClock->msgObuf, length, ptpClock))
{
ERROR("failed to send message\n");
return;
}
if(ptpClock->runTimeOpts.probe_management_key > 0)
break;
}
timerNow(&finish);
finish.seconds += PTP_SYNC_INTERVAL_TIMEOUT(ptpClock->sync_interval);
for(;;)
{
interval.seconds = PTP_SYNC_INTERVAL_TIMEOUT(ptpClock->sync_interval);
interval.nanoseconds = 0;
netSelect(&interval, ptpClock);
netRecvEvent(ptpClock->msgIbuf, NULL, ptpClock);
if(netRecvGeneral(ptpClock->msgIbuf, ptpClock))
{
msgUnpackHeader(ptpClock->msgIbuf, &ptpClock->msgTmpHeader);
if(ptpClock->msgTmpHeader.control == PTP_MANAGEMENT_MESSAGE)
{
msgUnpackManagement(ptpClock->msgIbuf, &ptpClock->msgTmp.manage);
msgUnpackManagementPayload(ptpClock->msgIbuf, &ptpClock->msgTmp.manage);
displayManagement(&ptpClock->msgTmpHeader, &ptpClock->msgTmp.manage);
}
fflush(stdout);
}
timerNow(&now);
if( now.seconds > finish.seconds || (now.seconds == finish.seconds
&& now.nanoseconds > finish.nanoseconds) )
break;
}
/* done */
printf("\n");
ptpdShutdown();
exit(0);
}
