1 /* $NetBSD: machines.c,v 1.6 2020/05/25 20:47:24 christos Exp $ */
2
3 /* machines.c - provide special support for peculiar architectures
4 *
5 * Real bummers unite !
6 *
7 */
8
9 #ifdef HAVE_CONFIG_H
10 #include "config.h"
11 #endif
12
13 #include "ntp.h"
14 #include "ntp_machine.h"
15 #include "ntp_syslog.h"
16 #include "ntp_stdlib.h"
17 #include "ntp_unixtime.h"
18 #include "lib_strbuf.h"
19 #include "ntp_debug.h"
20
21 #ifdef HAVE_UNISTD_H
22 #include <unistd.h>
23 #endif
24
25 #ifdef SYS_WINNT
26 int _getch(void); /* Declare the one function rather than include conio.h */
27 #else
28
29 #ifdef SYS_VXWORKS
30 #include "taskLib.h"
31 #include "sysLib.h"
32 #include "time.h"
33 #include "ntp_syslog.h"
34
35 /* some translations to the world of vxWorkings -casey */
36 /* first some netdb type things */
37 #include "ioLib.h"
38 #include <socket.h>
39 int h_errno;
40
gethostbyname(char * name)41 struct hostent *gethostbyname(char *name)
42 {
43 struct hostent *host1;
44 h_errno = 0; /* we are always successful!!! */
45 host1 = (struct hostent *) emalloc (sizeof(struct hostent));
46 host1->h_name = name;
47 host1->h_addrtype = AF_INET;
48 host1->h_aliases = name;
49 host1->h_length = 4;
50 host1->h_addr_list[0] = (char *)hostGetByName (name);
51 host1->h_addr_list[1] = NULL;
52 return host1;
53 }
54
gethostbyaddr(char * name,int size,int addr_type)55 struct hostent *gethostbyaddr(char *name, int size, int addr_type)
56 {
57 struct hostent *host1;
58 h_errno = 0; /* we are always successful!!! */
59 host1 = (struct hostent *) emalloc (sizeof(struct hostent));
60 host1->h_name = name;
61 host1->h_addrtype = AF_INET;
62 host1->h_aliases = name;
63 host1->h_length = 4;
64 host1->h_addr_list = NULL;
65 return host1;
66 }
67
getservbyname(char * name,char * type)68 struct servent *getservbyname (char *name, char *type)
69 {
70 struct servent *serv1;
71 serv1 = (struct servent *) emalloc (sizeof(struct servent));
72 serv1->s_name = "ntp"; /* official service name */
73 serv1->s_aliases = NULL; /* alias list */
74 serv1->s_port = 123; /* port # */
75 serv1->s_proto = "udp"; /* protocol to use */
76 return serv1;
77 }
78
79 /* second
80 * vxworks thinks it has insomnia
81 * we have to sleep for number of seconds
82 */
83
84 #define CLKRATE sysClkRateGet()
85
86 /* I am not sure how valid the granularity is - it is from G. Eger's port */
87 #define CLK_GRANULARITY 1 /* Granularity of system clock in usec */
88 /* Used to round down # usecs/tick */
89 /* On a VCOM-100, PIT gets 8 MHz clk, */
90 /* & it prescales by 32, thus 4 usec */
91 /* on mv167, granularity is 1usec anyway*/
92 /* To defeat rounding, set to 1 */
93 #define USECS_PER_SEC MILLION /* Microseconds per second */
94 #define TICK (((USECS_PER_SEC / CLKRATE) / CLK_GRANULARITY) * CLK_GRANULARITY)
95
96 /* emulate unix sleep
97 * casey
98 */
sleep(int seconds)99 void sleep(int seconds)
100 {
101 taskDelay(seconds*TICK);
102 }
103 /* emulate unix alarm
104 * that pauses and calls SIGALRM after the seconds are up...
105 * so ... taskDelay() fudged for seconds should amount to the same thing.
106 * casey
107 */
alarm(int seconds)108 void alarm (int seconds)
109 {
110 sleep(seconds);
111 }
112
113 #endif /* SYS_VXWORKS */
114
115 #ifdef SYS_PTX /* Does PTX still need this? */
116 /*#include <sys/types.h> */
117 #include <sys/procstats.h>
118
119 int
gettimeofday(struct timeval * tvp)120 gettimeofday(
121 struct timeval *tvp
122 )
123 {
124 /*
125 * hi, this is Sequents sneak path to get to a clock
126 * this is also the most logical syscall for such a function
127 */
128 return (get_process_stats(tvp, PS_SELF, (struct procstats *) 0,
129 (struct procstats *) 0));
130 }
131 #endif /* SYS_PTX */
132
133 #ifdef MPE
134 /* This is a substitute for bind() that if called for an AF_INET socket
135 port less than 1024, GETPRIVMODE() and GETUSERMODE() calls will be done. */
136
137 #undef bind
138 #include <sys/types.h>
139 #include <sys/socket.h>
140 #include <netinet/in.h>
141 #include <sys/un.h>
142
143 extern void GETPRIVMODE(void);
144 extern void GETUSERMODE(void);
145
146 int __ntp_mpe_bind(int s, void *addr, int addrlen);
147
__ntp_mpe_bind(int s,void * addr,int addrlen)148 int __ntp_mpe_bind(int s, void *addr, int addrlen) {
149 int priv = 0;
150 int result;
151
152 if (addrlen == sizeof(struct sockaddr_in)) { /* AF_INET */
153 if (((struct sockaddr_in *)addr)->sin_port > 0 &&
154 ((struct sockaddr_in *)addr)->sin_port < 1024) {
155 priv = 1;
156 GETPRIVMODE();
157 }
158 /* ((struct sockaddr_in *)addr)->sin_addr.s_addr = 0; */
159 result = bind(s,addr,addrlen);
160 if (priv == 1) GETUSERMODE();
161 } else /* AF_UNIX */
162 result = bind(s,addr,addrlen);
163
164 return result;
165 }
166
167 /*
168 * MPE stupidly requires sfcntl() to be used on sockets instead of fcntl(),
169 * so we define a wrapper to analyze the file descriptor and call the correct
170 * function.
171 */
172
173 #undef fcntl
174 #include <errno.h>
175 #include <fcntl.h>
176
177 int __ntp_mpe_fcntl(int fd, int cmd, int arg);
178
__ntp_mpe_fcntl(int fd,int cmd,int arg)179 int __ntp_mpe_fcntl(int fd, int cmd, int arg) {
180 int len;
181 struct sockaddr sa;
182
183 extern int sfcntl(int, int, int);
184
185 len = sizeof sa;
186 if (getsockname(fd, &sa, &len) == -1) {
187 if (errno == EAFNOSUPPORT) /* AF_UNIX socket */
188 return sfcntl(fd, cmd, arg);
189 if (errno == ENOTSOCK) /* file or pipe */
190 return fcntl(fd, cmd, arg);
191 return (-1); /* unknown getsockname() failure */
192 } else /* AF_INET socket */
193 return sfcntl(fd, cmd, arg);
194 }
195
196 /*
197 * Setitimer emulation support. Note that we implement this using alarm(),
198 * and since alarm() only delivers one signal, we must re-enable the alarm
199 * by enabling our own SIGALRM setitimer_mpe_handler routine to be called
200 * before the real handler routine and re-enable the alarm at that time.
201 *
202 * Note that this solution assumes that sigaction(SIGALRM) is called before
203 * calling setitimer(). If it should ever to become necessary to support
204 * sigaction(SIGALRM) after calling setitimer(), it will be necessary to trap
205 * those sigaction() calls.
206 */
207
208 #include <limits.h>
209 #include <signal.h>
210
211 /*
212 * Some global data that needs to be shared between setitimer() and
213 * setitimer_mpe_handler().
214 */
215
216 struct {
217 unsigned long current_msec; /* current alarm() value in effect */
218 unsigned long interval_msec; /* next alarm() value from setitimer */
219 unsigned long value_msec; /* first alarm() value from setitimer */
220 struct itimerval current_itimerval; /* current itimerval in effect */
221 struct sigaction oldact; /* SIGALRM state saved by setitimer */
222 } setitimer_mpe_ctx = { 0, 0, 0 };
223
224 /*
225 * Undocumented, unsupported function to do alarm() in milliseconds.
226 */
227
228 extern unsigned int px_alarm(unsigned long, int *);
229
230 /*
231 * The SIGALRM handler routine enabled by setitimer(). Re-enable the alarm or
232 * restore the original SIGALRM setting if no more alarms are needed. Then
233 * call the original SIGALRM handler (if any).
234 */
235
setitimer_mpe_handler(int sig)236 static RETSIGTYPE setitimer_mpe_handler(int sig)
237 {
238 int alarm_hpe_status;
239
240 /* Update the new current alarm value */
241
242 setitimer_mpe_ctx.current_msec = setitimer_mpe_ctx.interval_msec;
243
244 if (setitimer_mpe_ctx.interval_msec > 0) {
245 /* Additional intervals needed; re-arm the alarm timer */
246 px_alarm(setitimer_mpe_ctx.interval_msec,&alarm_hpe_status);
247 } else {
248 /* No more intervals, so restore previous original SIGALRM handler */
249 sigaction(SIGALRM, &setitimer_mpe_ctx.oldact, NULL);
250 }
251
252 /* Call the original SIGALRM handler if it is a function and not just a flag */
253
254 if (setitimer_mpe_ctx.oldact.sa_handler != SIG_DFL &&
255 setitimer_mpe_ctx.oldact.sa_handler != SIG_ERR &&
256 setitimer_mpe_ctx.oldact.sa_handler != SIG_IGN)
257 (*setitimer_mpe_ctx.oldact.sa_handler)(SIGALRM);
258
259 }
260
261 /*
262 * Our implementation of setitimer().
263 */
264
265 int
setitimer(int which,struct itimerval * value,struct itimerval * ovalue)266 setitimer(int which, struct itimerval *value,
267 struct itimerval *ovalue)
268 {
269
270 int alarm_hpe_status;
271 unsigned long remaining_msec, value_msec, interval_msec;
272 struct sigaction newact;
273
274 /*
275 * Convert the initial interval to milliseconds
276 */
277
278 if (value->it_value.tv_sec > (UINT_MAX / 1000))
279 value_msec = UINT_MAX;
280 else
281 value_msec = value->it_value.tv_sec * 1000;
282
283 value_msec += value->it_value.tv_usec / 1000;
284
285 /*
286 * Convert the reset interval to milliseconds
287 */
288
289 if (value->it_interval.tv_sec > (UINT_MAX / 1000))
290 interval_msec = UINT_MAX;
291 else
292 interval_msec = value->it_interval.tv_sec * 1000;
293
294 interval_msec += value->it_interval.tv_usec / 1000;
295
296 if (value_msec > 0 && interval_msec > 0) {
297 /*
298 * We'll be starting an interval timer that will be repeating, so we need to
299 * insert our own SIGALRM signal handler to schedule the repeats.
300 */
301
302 /* Read the current SIGALRM action */
303
304 if (sigaction(SIGALRM, NULL, &setitimer_mpe_ctx.oldact) < 0) {
305 fprintf(stderr,"MPE setitimer old handler failed, errno=%d\n",errno);
306 return -1;
307 }
308
309 /* Initialize the new action to call our SIGALRM handler instead */
310
311 newact.sa_handler = &setitimer_mpe_handler;
312 newact.sa_mask = setitimer_mpe_ctx.oldact.sa_mask;
313 newact.sa_flags = setitimer_mpe_ctx.oldact.sa_flags;
314
315 if (sigaction(SIGALRM, &newact, NULL) < 0) {
316 fprintf(stderr,"MPE setitimer new handler failed, errno=%d\n",errno);
317 return -1;
318 }
319 }
320
321 /*
322 * Return previous itimerval if desired
323 */
324
325 if (ovalue != NULL) *ovalue = setitimer_mpe_ctx.current_itimerval;
326
327 /*
328 * Save current parameters for later usage
329 */
330
331 setitimer_mpe_ctx.current_itimerval = *value;
332 setitimer_mpe_ctx.current_msec = value_msec;
333 setitimer_mpe_ctx.value_msec = value_msec;
334 setitimer_mpe_ctx.interval_msec = interval_msec;
335
336 /*
337 * Schedule the first alarm
338 */
339
340 remaining_msec = px_alarm(value_msec, &alarm_hpe_status);
341 if (alarm_hpe_status == 0)
342 return (0);
343 else
344 return (-1);
345 }
346
347 /*
348 * MPE lacks gettimeofday(), so we define our own.
349 */
350
gettimeofday(struct timeval * tvp)351 int gettimeofday(struct timeval *tvp)
352
353 {
354 /* Documented, supported MPE functions. */
355 extern void GETPRIVMODE(void);
356 extern void GETUSERMODE(void);
357
358 /* Undocumented, unsupported MPE functions. */
359 extern long long get_time(void);
360 extern void get_time_change_info(long long *, char *, char *);
361 extern long long ticks_to_micro(long long);
362
363 char pwf_since_boot, recover_pwf_time;
364 long long mpetime, offset_ticks, offset_usec;
365
366 GETPRIVMODE();
367 mpetime = get_time(); /* MPE local time usecs since Jan 1 1970 */
368 get_time_change_info(&offset_ticks, &pwf_since_boot, &recover_pwf_time);
369 offset_usec = ticks_to_micro(offset_ticks); /* UTC offset usecs */
370 GETUSERMODE();
371
372 mpetime = mpetime - offset_usec; /* Convert from local time to UTC */
373 tvp->tv_sec = mpetime / 1000000LL;
374 tvp->tv_usec = mpetime % 1000000LL;
375
376 return 0;
377 }
378
379 /*
380 * MPE lacks settimeofday(), so we define our own.
381 */
382
383 #define HAVE_SETTIMEOFDAY
384
settimeofday(struct timeval * tvp)385 int settimeofday(struct timeval *tvp)
386
387 {
388 /* Documented, supported MPE functions. */
389 extern void GETPRIVMODE(void);
390 extern void GETUSERMODE(void);
391
392 /* Undocumented, unsupported MPE functions. */
393 extern void get_time_change_info(long long *, char *, char *);
394 extern void initialize_system_time(long long, int);
395 extern void set_time_correction(long long, int, int);
396 extern long long ticks_to_micro(long long);
397
398 char pwf_since_boot, recover_pwf_time;
399 long long big_sec, big_usec, mpetime, offset_ticks, offset_usec;
400
401 big_sec = tvp->tv_sec;
402 big_usec = tvp->tv_usec;
403 mpetime = (big_sec * 1000000LL) + big_usec; /* Desired UTC microseconds */
404
405 GETPRIVMODE();
406 set_time_correction(0LL,0,0); /* Cancel previous time correction, if any */
407 get_time_change_info(&offset_ticks, &pwf_since_boot, &recover_pwf_time);
408 offset_usec = ticks_to_micro(offset_ticks); /* UTC offset microseconds */
409 mpetime = mpetime + offset_usec; /* Convert from UTC to local time */
410 initialize_system_time(mpetime,1);
411 GETUSERMODE();
412
413 return 0;
414 }
415 #endif /* MPE */
416
417 #define SET_TOD_UNDETERMINED 0
418 #define SET_TOD_CLOCK_SETTIME 1
419 #define SET_TOD_SETTIMEOFDAY 2
420 #define SET_TOD_STIME 3
421
422 const char * const set_tod_used[] = {
423 "undetermined",
424 "clock_settime",
425 "settimeofday",
426 "stime"
427 };
428
429 pset_tod_using set_tod_using = NULL;
430
431
432 int
ntp_set_tod(struct timeval * tvp,void * tzp)433 ntp_set_tod(
434 struct timeval *tvp,
435 void *tzp
436 )
437 {
438 static int tod;
439 int rc;
440 int saved_errno;
441
442 TRACE(1, ("In ntp_set_tod\n"));
443 rc = -1;
444 saved_errno = 0;
445
446 #ifdef HAVE_CLOCK_SETTIME
447 if (rc && (SET_TOD_CLOCK_SETTIME == tod || !tod)) {
448 struct timespec ts;
449
450 /* Convert timeval to timespec */
451 ts.tv_sec = tvp->tv_sec;
452 ts.tv_nsec = 1000 * tvp->tv_usec;
453
454 errno = 0;
455 rc = clock_settime(CLOCK_REALTIME, &ts);
456 saved_errno = errno;
457 TRACE(1, ("ntp_set_tod: clock_settime: %d %m\n", rc));
458 if (!tod && !rc)
459 tod = SET_TOD_CLOCK_SETTIME;
460
461 }
462 #endif /* HAVE_CLOCK_SETTIME */
463 #ifdef HAVE_SETTIMEOFDAY
464 if (rc && (SET_TOD_SETTIMEOFDAY == tod || !tod)) {
465 struct timeval adjtv;
466
467 /*
468 * Some broken systems don't reset adjtime() when the
469 * clock is stepped.
470 */
471 adjtv.tv_sec = adjtv.tv_usec = 0;
472 adjtime(&adjtv, NULL);
473 errno = 0;
474 rc = SETTIMEOFDAY(tvp, tzp);
475 saved_errno = errno;
476 TRACE(1, ("ntp_set_tod: settimeofday: %d %m\n", rc));
477 if (!tod && !rc)
478 tod = SET_TOD_SETTIMEOFDAY;
479 }
480 #endif /* HAVE_SETTIMEOFDAY */
481 #ifdef HAVE_STIME
482 if (rc && (SET_TOD_STIME == tod || !tod)) {
483 long tp = tvp->tv_sec;
484
485 errno = 0;
486 rc = stime(&tp); /* lie as bad as SysVR4 */
487 saved_errno = errno;
488 TRACE(1, ("ntp_set_tod: stime: %d %m\n", rc));
489 if (!tod && !rc)
490 tod = SET_TOD_STIME;
491 }
492 #endif /* HAVE_STIME */
493
494 errno = saved_errno; /* for %m below */
495 TRACE(1, ("ntp_set_tod: Final result: %s: %d %m\n",
496 set_tod_used[tod], rc));
497 /*
498 * Say how we're setting the time of day
499 */
500 if (!rc && NULL != set_tod_using) {
501 (*set_tod_using)(set_tod_used[tod]);
502 set_tod_using = NULL;
503 }
504
505 if (rc)
506 errno = saved_errno;
507
508 return rc;
509 }
510
511 #endif /* not SYS_WINNT */
512
513 #if defined (SYS_WINNT) || defined (SYS_VXWORKS) || defined(MPE)
514 /* getpass is used in ntpq.c and ntpdc.c */
515
516 char *
getpass(const char * prompt)517 getpass(const char * prompt)
518 {
519 int c, i;
520 static char password[32];
521
522 fprintf(stderr, "%s", prompt);
523 fflush(stderr);
524
525 for (i=0; i<sizeof(password)-1 && ((c=_getch())!='\n' && c!='\r'); i++) {
526 password[i] = (char) c;
527 }
528 password[i] = '\0';
529
530 fputc('\n', stderr);
531 fflush(stderr);
532
533 return password;
534 }
535 #endif /* SYS_WINNT */
536