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