void
CAM_Initialise(void)
{
-
- if (initialised) {
- CROAK("Shouldn't be initialised");
- }
-
+ assert(!initialised);
initialised = 1;
- if ((sizeof(permissions)/sizeof(permissions[0])) != N_REQUEST_TYPES) {
- CROAK("Permissions table size wrong");
- }
+ assert(sizeof (permissions) / sizeof (permissions[0]) == N_REQUEST_TYPES);
utoken = (unsigned long) time(NULL);
tx_message->status = htons(STT_INVALIDAF);
break;
case NSR_NoSuchSource:
- CROAK("Impossible");
+ assert(0);
break;
}
}
tx_message->status = htons(STT_INVALIDAF);
break;
case NSR_NoSuchSource:
- CROAK("Impossible");
+ assert(0);
break;
}
}
case NSR_TooManySources:
case NSR_AlreadyInUse:
case NSR_InvalidAF:
- CROAK("Impossible");
+ assert(0);
break;
}
}
tx_message->status = htons(STT_INACTIVE);
return;
default:
- CROAK("Impossible");
+ assert(0);
break;
}
}
tx_message->status = htons(STT_INACTIVE);
return;
default:
- CROAK("Impossible");
+ assert(0);
break;
}
}
tx_message->status = htons(STT_INACTIVE);
return;
default:
- CROAK("Impossible");
+ assert(0);
break;
}
}
allowed = 1;
break;
default:
- CROAK("Impossible");
+ assert(0);
}
if (allowed) {
iters++;
}
} while (iters < NITERS);
- if (!(best_dusec > 0)) {
- CROAK("best_dusec should be positive");
- }
+
+ assert(best_dusec > 0);
+
precision_quantum = best_dusec * 1.0e-6;
precision_log = 0;
while (best_dusec < 500000) {
/* Check that the handler is not already registered */
for (ptr = change_list.next; ptr != &change_list; ptr = ptr->next) {
if (!(ptr->handler != handler || ptr->anything != anything)) {
- CROAK("a handler is already registered");
+ assert(0);
}
}
}
}
- if (!ok) {
- CROAK("did not find a matching handler");
- }
+ assert(ok);
/* Unlink entry from the list */
ptr->next->prev = ptr->prev;
/* Check that the handler is not already registered */
for (ptr = dispersion_notify_list.next; ptr != &dispersion_notify_list; ptr = ptr->next) {
if (!(ptr->handler != handler || ptr->anything != anything)) {
- CROAK("a handler is already registered");
+ assert(0);
}
}
}
}
- if (!ok) {
- CROAK("no matching handler found");
- }
+ assert(ok);
/* Unlink entry from the list */
ptr->next->prev = ptr->prev;
{
struct timezone tz;
- if (!(gettimeofday(result, &tz) >= 0)) {
- CROAK("Could not get time of day");
+ if (gettimeofday(result, &tz) < 0) {
+ LOG_FATAL(LOGF_Local, "gettimeofday() failed");
}
}
return 0;
}
-/* ================================================== */
-/* Force a core dump and exit without doing abort() or assert(0).
- These do funny things with the call stack in the core file that is
- generated, which makes diagnosis difficult. */
-
-int
-croak(const char *file, int line, const char *msg)
-{
- int a;
- LOG(LOGS_ERR, LOGF_Util, "Unexpected condition [%s] at %s:%d, core dumped",
- msg, file, line);
- a = * (int *) 0;
- return a; /* Can't happen - this stops the optimiser optimising the
- line above */
-}
-
/* ================================================== */
LOG_FileID
LOGF_Regress,
LOGF_Sys,
LOGF_SysLinux,
+ LOGF_SysNetBSD,
LOGF_SysSolaris,
LOGF_SysSunOS,
LOGF_SysWinnt,
#define LOG_FATAL LOG_Position(__FILE__, __LINE__, ""); LOG_Fatal_Function
#endif /* defined (__GNUC__) */
-/* Like assert(0) */
-
-#if defined(LINUX) && defined(__alpha__)
-#define CROAK(message) assert(0) /* Added JGH Feb 24 2001 FIXME */
-#else
-extern int croak(const char *file, int line, const char *msg);
-#define CROAK(message) croak(__FILE__, __LINE__, message);
-#endif
-
/* File logging functions */
typedef int LOG_FileID;
break;
default:
- CROAK("Impossible");
+ assert(0);
break;
}
break;
default:
- CROAK("Impossible");
+ assert(0);
break;
}
default:
- CROAK("Impossible");
+ assert(0);
break;
}
}
report->mode = RPT_NTP_PEER;
break;
default:
- CROAK("Impossible");
+ assert(0);
}
return;
++*offline;
break;
default:
- CROAK("Impossible");
+ assert(0);
break;
}
}
double u, ui, aa;
int i;
- if (n<3) {
- CROAK("Insufficient points");
- }
+ assert(n >= 3);
W = U = 0;
for (i=0; i<n; i++) {
double piv;
int pivind;
- if (index < 0) {
- CROAK("Negative index");
- }
+ assert(index >= 0);
/* If this bit of the array is already sorted, simple! */
if (flags[index]) {
v = r - 1;
} else if (index > r) {
u = l;
- } else {
- CROAK("Impossible");
}
}
} while (1);
bhi = bmid;
rhi = rmid;
} else {
- CROAK("Impossible");
+ assert(0);
}
} while ((bhi - blo) > tol);
{
int n_to_save;
- if (!(new_first < n_samples)) {
- CROAK("new_first should be < n_samples");
- }
- if (!(new_first >= 0)) {
- CROAK("new_first should be non-negative");
- }
+ assert(new_first >= 0 && new_first < n_samples);
n_to_save = n_samples - new_first;
}
break;
default:
- CROAK("Impossible");
+ assert(0);
break;
}
break;
default:
- CROAK("Impossible");
+ assert(0);
break;
}
(int fd, SCH_FileHandler handler, SCH_ArbitraryArgument arg)
{
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
/* Don't want to allow the same fd to register a handler more than
once without deleting a previous association - this suggests
a bug somewhere else in the program. */
- if (FD_ISSET(fd, &read_fds)) {
- CROAK("File handler already registered");
- }
+ assert(!FD_ISSET(fd, &read_fds));
++n_read_fds;
{
int fds_left, fd_to_check;
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
/* Check that a handler was registered for the fd in question */
- if (!FD_ISSET(fd, &read_fds)) {
- CROAK("File handler not registered");
- }
+ assert(FD_ISSET(fd, &read_fds));
--n_read_fds;
TimerQueueEntry *new_tqe;
TimerQueueEntry *ptr;
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
new_tqe = allocate_tqe();
{
struct timeval now, then;
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
LCL_ReadRawTime(&now);
UTI_AddDoubleToTimeval(&now, delay, &then);
double diff;
double new_min_delay;
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
LCL_ReadRawTime(&now);
new_min_delay = min_delay;
TimerQueueEntry *ptr;
int ok;
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
ok = 0;
struct timeval tv, *ptv;
struct timeval now;
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
while (!need_to_exit) {
status = select(one_highest_fd, &rd, NULL, NULL, ptv);
if (status < 0) {
- if (!need_to_exit)
- CROAK("Status < 0 after select");
+ assert(need_to_exit);
} else if (status > 0) {
/* A file descriptor is ready to read */
dispatch_filehandlers(status, &rd);
} else {
- if (status != 0) {
- CROAK("Unexpected value from select");
- }
+ assert(status == 0);
/* No descriptors readable, timeout must have elapsed.
Therefore, tv must be non-null */
- if (!ptv) {
- CROAK("No descriptors or timeout?");
- }
+ assert(ptv);
/* There's nothing to do here, since the timeouts
will be dispatched at the top of the next loop
void
SCH_QuitProgram(void)
{
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
need_to_exit = 1;
}
{
SRC_Instance result;
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
result = MallocNew(struct SRC_Instance_Record);
result->stats = SST_CreateInstance(ref_id, addr);
{
int dead_index, i;
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
if (instance->index == selected_source_index) {
instance->reachable = 0;
void SRC_GetFrequencyRange(SRC_Instance instance, double *lo, double *hi)
{
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
SST_GetFrequencyRange(instance->stats, lo, hi);
return;
NTP_Leap leap_status)
{
- if (!initialised) {
- CROAK("Should be initialised");
- }
+ assert(initialised);
inst->leap_status = leap_status;
case SRC_REFCLOCK:
return UTI_RefidToString(inst->ref_id);
default:
- CROAK("Unknown source type");
+ assert(0);
}
return NULL;
}
break;
case CENTRE:
- CROAK("CENTRE cannot occur");
+ assert(0);
break;
case HIGH:
return;
if (gettimeofday(&now, &tz) < 0) {
- CROAK("gettimeofday() failed");
+ LOG_FATAL(LOGF_SysLinux, "gettimeofday() failed");
}
if (offset < 0)
if (new || nano_slew_error_start.tv_sec > 0) {
if (gettimeofday(&now, &tz) < 0) {
- CROAK("gettimeofday() failed");
+ LOG_FATAL(LOGF_SysLinux, "gettimeofday() failed");
}
}
double slew_duration;
/* Should never get here unless this is true */
- if (!fast_slewing) {
- CROAK("Should be fast slewing");
- }
+ assert(fast_slewing);
/* Now set the thing off */
if (gettimeofday(&T1, &tz) < 0) {
- CROAK("gettimeofday() failed in stop_fast_slew");
+ LOG_FATAL(LOGF_SysLinux, "gettimeofday() failed");
}
if (TMX_SetTick(current_tick) < 0) {
- CROAK("adjtimex() failed in stop_fast_slew");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
fast_slewing = 0;
assert(fast_slewing);
if (gettimeofday(&tv, &tz) < 0) {
- CROAK("gettimeofday() failed in stop_fast_slew");
+ LOG_FATAL(LOGF_SysLinux, "gettimeofday() failed");
}
UTI_DiffTimevalsToDouble(&slew_duration, &tv, &slew_start_tv);
struct timezone tz;
/* Don't want to get here if we already have an adjust on the go! */
- if (fast_slewing) {
- CROAK("Should not be fast slewing");
- }
+ assert(!fast_slewing);
if (offset_register == 0.0) {
return;
if (slow_slewing) {
offset = 0;
if (TMX_ApplyOffset(&offset) < 0) {
- CROAK("adjtimex() failed in accrue_offset");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
offset_register -= (double) offset / 1.0e6;
slow_slewing = 0;
update_slow_slew_error(0);
} else if (nano_slewing) {
if (TMX_GetPLLOffsetLeft(&offset) < 0) {
- CROAK("adjtimex() failed in accrue_offset");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
offset_register -= (double) offset / 1.0e9;
update_nano_slew_error(offset, 0);
offset = 0;
if (TMX_ApplyPLLOffset(offset) < 0) {
- CROAK("adjtimex() failed in accrue_offset");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
nano_slewing = 0;
update_nano_slew_error(offset, 1);
offset = 1.0e9 * -offset_register;
if (TMX_ApplyPLLOffset(offset) < 0) {
- CROAK("adjtimex() failed in accrue_offset");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
offset_register = 0.0;
nano_slewing = 1;
if (offset != 0) {
if (TMX_ApplyOffset(&offset) < 0) {
- CROAK("adjtimex() failed in initiate_slew");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
slow_slewing = 1;
update_slow_slew_error(offset);
/* Now set the thing off */
if (gettimeofday(&T0, &tz) < 0) {
- CROAK("gettimeofday() failed in initiate_slew");
+ LOG_FATAL(LOGF_SysLinux, "gettimeofday() failed");
}
if (TMX_SetTick(slewing_tick) < 0) {
- LOG(LOGS_INFO, LOGF_SysLinux, "c_t=%ld ta=%ld sl_t=%ld dtt=%e",
- current_tick, tick_adjust, slewing_tick, delta_total_tick);
- CROAK("adjtimex() failed to start big slew");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
/* Compute the dispersion we have introduced by changing tick this
}
if (gettimeofday(&old_time, &tz) < 0) {
- CROAK("gettimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysLinux, "gettimeofday() failed");
}
UTI_AddDoubleToTimeval(&old_time, -offset, &new_time);
if (settimeofday(&new_time, &tz) < 0) {
- CROAK("settimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysLinux, "settimeofday() failed");
}
if (gettimeofday(&old_time, &tz) < 0) {
- CROAK("gettimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysLinux, "gettimeofday() failed");
}
UTI_DiffTimevalsToDouble(&err, &old_time, &new_time);
double freq_term;
if (TMX_GetFrequency(&unscaled_freq) < 0) {
- CROAK("adjtimex failed in read_frequency");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
/* Use current_tick here rather than txc.tick, otherwise we're
switch (have_readonly_adjtime) {
case 2:
if (TMX_GetOffsetLeft(&offset) < 0) {
- CROAK("adjtimex() failed in get_offset_correction");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
break;
case 0:
toffset = 0;
if (TMX_ApplyOffset(&toffset) < 0) {
- CROAK("adjtimex() failed in get_offset_correction");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
offset = toffset;
if (TMX_ApplyOffset(&toffset) < 0) {
- CROAK("adjtimex() failed in get_offset_correction");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
break;
case 1:
if (TMX_GetOffsetLeftOld(&offset) < 0) {
- CROAK("adjtimex() failed in get_offset_correction");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
break;
default:
noffset = 0;
} else {
if (TMX_GetPLLOffsetLeft(&noffset) < 0) {
- CROAK("adjtimex() failed in get_offset_correction");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
if (noffset == 0) {
nano_slewing = 0;
offset = 0;
if (TMX_ApplyOffset(&offset) < 0) {
- CROAK("adjtimex() failed in initialise");
+ LOG_FATAL(LOGF_SysLinux, "adjtimex() failed");
}
if (have_readonly_adjtime == 2 && (TMX_GetOffsetLeft(&offset) < 0 || offset)) {
current_freq = 0.0;
if (gettimeofday(&T0, &tz) < 0) {
- CROAK("gettimeofday() failed in clock_initialise()");
+ LOG_FATAL(LOGF_SysNetBSD, "gettimeofday() failed");
}
newadj.tv_sec = 0;
newadj.tv_usec = 0;
if (adjtime(&newadj, &oldadj) < 0) {
- CROAK("adjtime() failed in clock_initialise");
+ LOG_FATAL(LOGF_SysNetBSD, "adjtime() failed");
}
}
/* Determine the amount of error built up since the last adjustment */
if (gettimeofday(&T1, &tz) < 0) {
- CROAK("gettimeofday() failed in start_adjust");
+ LOG_FATAL(LOGF_SysNetBSD, "gettimeofday() failed");
}
UTI_DiffTimevalsToDouble(&elapsed, &T1, &T0);
UTI_DiffTimevalsToDouble(&rounding_error, &newadj, &exact_newadj);
if (adjtime(&newadj, &oldadj) < 0) {
- CROAK("adjtime() failed in start_adjust");
+ LOG_FATAL(LOGF_SysNetBSD, "adjtime() failed");
}
UTI_TimevalToDouble(&oldadj, &old_adjust_remaining);
zeroadj.tv_usec = 0;
if (adjtime(&zeroadj, &remadj) < 0) {
- CROAK("adjtime() failed in stop_adjust");
+ LOG_FATAL(LOGF_SysNetBSD, "adjtime() failed");
}
if (gettimeofday(&T1, &tz) < 0) {
- CROAK("gettimeofday() failed in stop_adjust");
+ LOG_FATAL(LOGF_SysNetBSD, "gettimeofday() failed");
}
UTI_DiffTimevalsToDouble(&elapsed, &T1, &T0);
stop_adjust();
if (gettimeofday(&old_time, &tz) < 0) {
- CROAK("gettimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysNetBSD, "gettimeofday() failed");
}
UTI_AddDoubleToTimeval(&old_time, -offset, &new_time);
if (settimeofday(&new_time, &tz) < 0) {
- CROAK("settimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysNetBSD, "settimeofday() failed");
}
UTI_AddDoubleToTimeval(&T0, offset, &T1);
kt = kvm_open(NULL, NULL, NULL, O_RDONLY, NULL);
if (!kt) {
- CROAK("Cannot open kvm\n");
+ LOG_FATAL(LOGF_SysNetBSD, "Cannot open kvm");
}
if (kvm_nlist(kt, nl) < 0) {
- CROAK("Cannot read kernel symbols\n");
+ LOG_FATAL(LOGF_SysNetBSD, "Cannot read kernel symbols");
}
if (kvm_read(kt, nl[0].n_value, (char *)(&kern_tickadj), sizeof(int)) < 0) {
- CROAK("Cannot read from _tickadj\n");
+ LOG_FATAL(LOGF_SysNetBSD, "Cannot read from _tickadj");
}
if (kvm_read(kt, nl[1].n_value, (char *)(&kern_bigadj), sizeof(long)) < 0) {
current_freq = 0.0;
if (gettimeofday(&T0, &tz) < 0) {
- CROAK("gettimeofday() failed in clock_initialise()");
+ LOG_FATAL(LOGF_SysSolaris, "gettimeofday() failed");
}
newadj = GET_ZERO;
if (adjtime(&newadj, &oldadj) < 0) {
- CROAK("adjtime() failed in clock_initialise");
+ LOG_FATAL(LOGF_SysSolaris, "adjtime() failed");
}
if (adjtime(&newadj, &oldadj) < 0) {
- CROAK("adjtime() failed in clock_initialise");
+ LOG_FATAL(LOGF_SysSolaris, "adjtime() failed");
}
return;
/* Determine the amount of error built up since the last adjustment */
if (gettimeofday(&T1, &tz) < 0) {
- CROAK("gettimeofday() failed in start_adjust");
+ LOG_FATAL(LOGF_SysSolaris, "gettimeofday() failed");
}
UTI_DiffTimevalsToDouble(&elapsed, &T1, &T0);
UTI_DiffTimevalsToDouble(&rounding_error, &exact_newadj, &newadj);
if (adjtime(&newadj, &oldadj) < 0) {
- CROAK("adjtime() failed in start_adjust");
+ LOG_FATAL(LOGF_SysSolaris, "adjtime() failed");
}
UTI_TimevalToDouble(&oldadj, &old_adjust_remaining);
zeroadj = GET_ZERO;
if (adjtime(&zeroadj, &remadj) < 0) {
- CROAK("adjtime() failed in stop_adjust");
+ LOG_FATAL(LOGF_SysSolaris, "adjtime() failed");
}
if (gettimeofday(&T1, &tz) < 0) {
- CROAK("gettimeofday() failed in stop_adjust");
+ LOG_FATAL(LOGF_SysSolaris, "gettimeofday() failed");
}
UTI_DiffTimevalsToDouble(&elapsed, &T1, &T0);
stop_adjust();
if (gettimeofday(&old_time, &tz) < 0) {
- CROAK("gettimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysSolaris, "gettimeofday() failed");
}
UTI_AddDoubleToTimeval(&old_time, -offset, &new_time);
UTI_DiffTimevalsToDouble(&rounding_error, &rounded_new_time, &new_time);
if (settimeofday(&new_time, &tz) < 0) {
- CROAK("settimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysSolaris, "settimeofday() failed");
}
UTI_AddDoubleToTimeval(&T0, offset, &T1);
kvm_t *kt;
unsigned long read_back;
- if (on_off!=1 && on_off!=0) {
- CROAK("on_off should be 0 or 1");
- }
+ assert(on_off == 1 || on_off == 0);
kt = kvm_open(NULL, NULL, NULL, O_RDWR, NULL);
if (!kt) {
kvm_close(kt);
- if (read_back != on_off) {
- CROAK("read_back should equal on_off");
- }
+ assert(read_back == on_off);
#if 0
LOG(LOGS_INFO, LOGF_SysSolaris, "Set value of dosynctodr to %d", on_off);
current_freq = 0.0;
if (gettimeofday(&T0, &tz) < 0) {
- CROAK("gettimeofday() failed in clock_initialise()");
+ LOG_FATAL(LOGF_SysSunOS, "gettimeofday() failed");
}
newadj.tv_sec = 0;
newadj.tv_usec = 0;
if (adjtime(&newadj, &oldadj) < 0) {
- CROAK("adjtime() failed in clock_initialise");
+ LOG_FATAL(LOGF_SysSunOS, "adjtime() failed");
}
if (adjtime(&newadj, &oldadj) < 0) {
- CROAK("adjtime() failed in clock_initialise");
+ LOG_FATAL(LOGF_SysSunOS, "adjtime() failed");
}
return;
/* Determine the amount of error built up since the last adjustment */
if (gettimeofday(&T1, &tz) < 0) {
- CROAK("gettimeofday() failed in start_adjust");
+ LOG_FATAL(LOGF_SysSunOS, "gettimeofday() failed");
}
UTI_DiffTimevalsToDouble(&elapsed, &T1, &T0);
UTI_DiffTimevalsToDouble(&rounding_error, &newadj, &exact_newadj);
if (adjtime(&newadj, &oldadj) < 0) {
- CROAK("adjtime() failed in start_adjust");
+ LOG_FATAL(LOGF_SysSunOS, "adjtime() failed");
}
UTI_TimevalToDouble(&oldadj, &old_adjust_remaining);
zeroadj.tv_usec = 0;
if (adjtime(&zeroadj, &remadj) < 0) {
- CROAK("adjtime() failed in stop_adjust");
+ LOG_FATAL(LOGF_SysSunOS, "adjtime() failed");
}
if (gettimeofday(&T1, &tz) < 0) {
- CROAK("gettimeofday() failed in stop_adjust");
+ LOG_FATAL(LOGF_SysSunOS, "gettimeofday() failed");
}
UTI_DiffTimevalsToDouble(&elapsed, &T1, &T0);
stop_adjust();
if (gettimeofday(&old_time, &tz) < 0) {
- CROAK("gettimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysSunOS, "gettimeofday() failed");
}
UTI_AddDoubleToTimeval(&old_time, -offset, &new_time);
if (settimeofday(&new_time, &tz) < 0) {
- CROAK("settimeofday in apply_step_offset");
+ LOG_FATAL(LOGF_SysSunOS, "settimeofday() failed");
}
UTI_AddDoubleToTimeval(&T0, offset, &T1);
unsigned long our_tick = 10000;
unsigned long default_tickadj = 625;
- if (on_off!=1 && on_off!=0) {
- CROAK("on_off should be 0 or 1");
- }
+ assert(on_off == 1 || on_off == 0);
kt = kvm_open(NULL, NULL, NULL, O_RDWR, NULL);
if (!kt) {
projects / thirdparty / chrony.git / commitdiff
