From a6163888f3c56123b1db313743c6147ba498732c Mon Sep 17 00:00:00 2001 From: Yuval Adam Date: Fri, 8 Aug 2014 14:42:07 +0300 Subject: Add third_party libs --- third_party/ptpd-1.1.0/src/dep/sys.c | 282 +++++++++++++++++++++++++++++++++++ 1 file changed, 282 insertions(+) create mode 100644 third_party/ptpd-1.1.0/src/dep/sys.c (limited to 'third_party/ptpd-1.1.0/src/dep/sys.c') diff --git a/third_party/ptpd-1.1.0/src/dep/sys.c b/third_party/ptpd-1.1.0/src/dep/sys.c new file mode 100644 index 0000000..9e1221e --- /dev/null +++ b/third_party/ptpd-1.1.0/src/dep/sys.c @@ -0,0 +1,282 @@ +/** + * @file sys.c + * @date Tue Jul 20 16:19:46 2010 + * + * @brief Code to call kernel time routines and also display server statistics. + * + * + */ + +#include "../ptpd.h" + + +int +isTimeInternalNegative(const TimeInternal * p) +{ + return (p->seconds < 0) || (p->nanoseconds < 0); +} + + +int +snprint_TimeInternal(char *s, int max_len, const TimeInternal * p) +{ + int len = 0; + + if (isTimeInternalNegative(p)) + len += snprintf(&s[len], max_len - len, "-"); + + len += snprintf(&s[len], max_len - len, "%d.%09d", + abs(p->seconds), abs(p->nanoseconds)); + + return len; +} + + + +int +snprint_ClockIdentity(char *s, int max_len, const Octet uuid[PTP_UUID_LENGTH], const char *info) +{ + int len = 0; + int i; + + if (info) + len += snprintf(&s[len], max_len - len, "%s", info); + + for (i = 0; ;) { + len += snprintf(&s[len], max_len - len, "%02x", (unsigned char) uuid[i]); + + if (++i >= PTP_UUID_LENGTH) + break; + + // uncomment the line below to print a separator after each byte except the last one + // len += snprintf(&s[len], max_len - len, "%s", "-"); + } + + return len; +} + + +int +snprint_PortIdentity(char *s, int max_len, const Octet uuid[PTP_UUID_LENGTH], + UInteger16 portId, const char *info) +{ + int len = 0; + + if (info) + len += snprintf(&s[len], max_len - len, "%s", info); + + len += snprint_ClockIdentity(&s[len], max_len - len, uuid, NULL); + len += snprintf(&s[len], max_len - len, ":%02x", portId); + return len; +} + + +void +message(int priority, const char *format, ...) +{ + extern RunTimeOpts rtOpts; + va_list ap; + va_start(ap, format); + if(rtOpts.useSysLog) { + static Boolean logOpened; + if(!logOpened) { + openlog("ptpd", 0, LOG_USER); + logOpened = TRUE; + } + vsyslog(priority, format, ap); + } else { + fprintf(stderr, "(ptpd %s) ", + priority == LOG_EMERG ? "emergency" : + priority == LOG_ALERT ? "alert" : + priority == LOG_CRIT ? "critical" : + priority == LOG_ERR ? "error" : + priority == LOG_WARNING ? "warning" : + priority == LOG_NOTICE ? "notice" : + priority == LOG_INFO ? "info" : + priority == LOG_DEBUG ? "debug" : + "???"); + vfprintf(stderr, format, ap); + } + va_end(ap); +} + +char * +translatePortState(PtpClock *ptpClock) +{ + char *s; + switch(ptpClock->port_state) { + case PTP_INITIALIZING: s = "init"; break; + case PTP_FAULTY: s = "flt"; break; + case PTP_LISTENING: s = "lstn"; break; + case PTP_PASSIVE: s = "pass"; break; + case PTP_UNCALIBRATED: s = "uncl"; break; + case PTP_SLAVE: s = "slv"; break; + case PTP_PRE_MASTER: s = "pmst"; break; + case PTP_MASTER: s = "mst"; break; + case PTP_DISABLED: s = "dsbl"; break; + default: s = "?"; break; + } + return s; +} + +void +displayStats(RunTimeOpts * rtOpts, PtpClock * ptpClock) +{ + static int start = 1; + static char sbuf[SCREEN_BUFSZ]; + int len = 0; + struct timeval now; + char time_str[MAXTIMESTR]; + + if (start && rtOpts->csvStats) { + start = 0; + printf("timestamp, state, clock ID, one way delay, " + "offset from master, master to slave, " + "slave to master, drift, variance"); + fflush(stdout); + } + memset(sbuf, ' ', sizeof(sbuf)); + + gettimeofday(&now, 0); + strftime(time_str, MAXTIMESTR, "%Y-%m-%d %X", localtime(&now.tv_sec)); + + len += snprintf(sbuf + len, sizeof(sbuf) - len, "%s%s:%06d, %s", + rtOpts->csvStats ? "\n" : "\rstate: ", + time_str, (int)now.tv_usec, + translatePortState(ptpClock)); + + if (ptpClock->port_state == PTP_SLAVE) { + len += snprint_PortIdentity(sbuf + len, sizeof(sbuf) - len, + ptpClock->parent_uuid, ptpClock->parent_port_id, ", "); + + /* + * if grandmaster ID differs from parent port ID then also + * print GM ID + */ + if (memcmp(ptpClock->grandmaster_uuid_field, + ptpClock->parent_uuid, PTP_UUID_LENGTH)) { + len += snprint_ClockIdentity(sbuf + len, + sizeof(sbuf) - len, + ptpClock->grandmaster_uuid_field, + " GM:"); + } + + len += snprintf(sbuf + len, sizeof(sbuf) - len, ", "); + + if (!rtOpts->csvStats) + len += snprintf(sbuf + len, + sizeof(sbuf) - len, "owd: "); + + len += snprint_TimeInternal(sbuf + len, sizeof(sbuf) - len, + &ptpClock->one_way_delay); + + len += snprintf(sbuf + len, sizeof(sbuf) - len, ", "); + + if (!rtOpts->csvStats) + len += snprintf(sbuf + len, sizeof(sbuf) - len, + "ofm: "); + + len += snprint_TimeInternal(sbuf + len, sizeof(sbuf) - len, + &ptpClock->offset_from_master); + + len += snprintf(sbuf + len, sizeof(sbuf) - len, + ", %s%d.%09d" ", %s%d.%09d", + rtOpts->csvStats ? "" : "stm: ", + ptpClock->slave_to_master_delay.seconds, + abs(ptpClock->slave_to_master_delay.nanoseconds), + rtOpts->csvStats ? "" : "mts: ", + ptpClock->master_to_slave_delay.seconds, + abs(ptpClock->master_to_slave_delay.nanoseconds)); + + len += snprintf(sbuf + len, sizeof(sbuf) - len, + ", %s%d", + rtOpts->csvStats ? "" : "drift: ", + ptpClock->observed_drift); + + len += snprintf(sbuf + len, sizeof(sbuf) - len, + ", %s%d", + rtOpts->csvStats ? "" : "var: ", + ptpClock->observed_variance); + } + else { + if (ptpClock->port_state == PTP_MASTER) { + len += snprint_ClockIdentity(sbuf + len, sizeof(sbuf) - len, + ptpClock->clock_uuid_field, " (ID:"); + len += snprintf(sbuf + len, sizeof(sbuf) - len, ")"); + } + } + write(1, sbuf, rtOpts->csvStats ? len : SCREEN_MAXSZ + 1); +} + +Boolean +nanoSleep(TimeInternal * t) +{ + struct timespec ts, tr; + + ts.tv_sec = t->seconds; + ts.tv_nsec = t->nanoseconds; + + if (nanosleep(&ts, &tr) < 0) { + t->seconds = tr.tv_sec; + t->nanoseconds = tr.tv_nsec; + return FALSE; + } + return TRUE; +} + +void +getTime(TimeInternal * time) +{ +#if defined(linux) + + struct timeval tv; + gettimeofday(&tv, 0); + time->seconds = tv.tv_sec; + time->nanoseconds = tv.tv_usec * 1000; + +#else /* FreeBSD */ + + struct timespec tp; + if (clock_gettime(CLOCK_REALTIME, &tp) < 0) { + PERROR("clock_gettime() failed, exiting."); + exit(0); + } + time->seconds = tp.tv_sec; + time->nanoseconds = tp.tv_nsec; +#endif /* FreeBSD or Linux */ +} + +void +setTime(TimeInternal * time) +{ + struct timeval tv; + + tv.tv_sec = time->seconds; + tv.tv_usec = time->nanoseconds / 1000; + settimeofday(&tv, 0); + + NOTIFY("resetting system clock to %ds %dns\n", + time->seconds, time->nanoseconds); +} + +UInteger16 +getRand(UInteger32 * seed) +{ + return rand_r((unsigned int *)seed); +} + +Boolean +adjFreq(Integer32 adj) +{ + struct timex t; + + if (adj > ADJ_FREQ_MAX) + adj = ADJ_FREQ_MAX; + else if (adj < -ADJ_FREQ_MAX) + adj = -ADJ_FREQ_MAX; + + t.modes = MOD_FREQUENCY; + t.freq = adj * ((1 << 16) / 1000); + + return !adjtimex(&t); +} -- cgit v1.3.1