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 21int _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> 34int h_errno; 35 36struct 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 50struct 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 63struct 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 */ 94void 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 */ 103void 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 114int 115gettimeofday( 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 130port 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 138extern void GETPRIVMODE(void); 139extern void GETUSERMODE(void); 140 141int __ntp_mpe_bind(int s, void *addr, int addrlen); 142 143int __ntp_mpe_bind(int s, void *addr, int addrlen) { 144 int priv = 0; 145 int result; 146 147if (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 159return 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 172int __ntp_mpe_fcntl(int fd, int cmd, int arg); 173 174int __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 211struct { 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 223extern 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 231static RETSIGTYPE setitimer_mpe_handler(int sig) 232{ 233int alarm_hpe_status; 234 235/* Update the new current alarm value */ 236 237setitimer_mpe_ctx.current_msec = setitimer_mpe_ctx.interval_msec; 238 239if (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 249if (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 260int 261setitimer(int which, struct itimerval *value, 262 struct itimerval *ovalue) 263{ 264 265int alarm_hpe_status; 266unsigned long remaining_msec, value_msec, interval_msec; 267struct sigaction newact; 268 269/* 270 * Convert the initial interval to milliseconds 271 */ 272 273if (value->it_value.tv_sec > (UINT_MAX / 1000)) 274 value_msec = UINT_MAX; 275else 276 value_msec = value->it_value.tv_sec * 1000; 277 278value_msec += value->it_value.tv_usec / 1000; 279 280/* 281 * Convert the reset interval to milliseconds 282 */ 283 284if (value->it_interval.tv_sec > (UINT_MAX / 1000)) 285 interval_msec = UINT_MAX; 286else 287 interval_msec = value->it_interval.tv_sec * 1000; 288 289interval_msec += value->it_interval.tv_usec / 1000; 290 291if (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 320if (ovalue != NULL) *ovalue = setitimer_mpe_ctx.current_itimerval; 321 322/* 323 * Save current parameters for later usage 324 */ 325 326setitimer_mpe_ctx.current_itimerval = *value; 327setitimer_mpe_ctx.current_msec = value_msec; 328setitimer_mpe_ctx.value_msec = value_msec; 329setitimer_mpe_ctx.interval_msec = interval_msec; 330 331/* 332 * Schedule the first alarm 333 */ 334 335remaining_msec = px_alarm(value_msec, &alarm_hpe_status); 336if (alarm_hpe_status == 0) 337 return (0); 338else 339 return (-1); 340} 341 342/* 343 * MPE lacks gettimeofday(), so we define our own. 344 */ 345 346int gettimeofday(struct timeval *tvp) 347 348{ 349/* Documented, supported MPE functions. */ 350extern void GETPRIVMODE(void); 351extern void GETUSERMODE(void); 352 353/* Undocumented, unsupported MPE functions. */ 354extern long long get_time(void); 355extern void get_time_change_info(long long *, char *, char *); 356extern long long ticks_to_micro(long long); 357 358char pwf_since_boot, recover_pwf_time; 359long long mpetime, offset_ticks, offset_usec; 360 361GETPRIVMODE(); 362mpetime = get_time(); /* MPE local time usecs since Jan 1 1970 */ 363get_time_change_info(&offset_ticks, &pwf_since_boot, &recover_pwf_time); 364offset_usec = ticks_to_micro(offset_ticks); /* UTC offset usecs */ 365GETUSERMODE(); 366 367mpetime = mpetime - offset_usec; /* Convert from local time to UTC */ 368tvp->tv_sec = mpetime / 1000000LL; 369tvp->tv_usec = mpetime % 1000000LL; 370 371return 0; 372} 373 374/* 375 * MPE lacks settimeofday(), so we define our own. 376 */ 377 378#define HAVE_SETTIMEOFDAY 379 380int settimeofday(struct timeval *tvp) 381 382{ 383/* Documented, supported MPE functions. */ 384extern void GETPRIVMODE(void); 385extern void GETUSERMODE(void); 386 387/* Undocumented, unsupported MPE functions. */ 388extern void get_time_change_info(long long *, char *, char *); 389extern void initialize_system_time(long long, int); 390extern void set_time_correction(long long, int, int); 391extern long long ticks_to_micro(long long); 392 393char pwf_since_boot, recover_pwf_time; 394long long big_sec, big_usec, mpetime, offset_ticks, offset_usec; 395 396big_sec = tvp->tv_sec; 397big_usec = tvp->tv_usec; 398mpetime = (big_sec * 1000000LL) + big_usec; /* Desired UTC microseconds */ 399 400GETPRIVMODE(); 401set_time_correction(0LL,0,0); /* Cancel previous time correction, if any */ 402get_time_change_info(&offset_ticks, &pwf_since_boot, &recover_pwf_time); 403offset_usec = ticks_to_micro(offset_ticks); /* UTC offset microseconds */ 404mpetime = mpetime + offset_usec; /* Convert from UTC to local time */ 405initialize_system_time(mpetime,1); 406GETUSERMODE(); 407 408return 0; 409} 410#endif /* MPE */ 411 412const char *set_tod_using = "UNKNOWN"; 413 414int 415ntp_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 498char * 499getpass(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) 517void 518ntp_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