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