/* machines.c - provide special support for peculiar architectures * * Real bummers unite ! * */ #ifdef HAVE_CONFIG_H #include "config.h" #endif #include "ntp.h" #include "ntp_machine.h" #include "ntp_syslog.h" #include "ntp_stdlib.h" #include "ntp_unixtime.h" #include "ntp_debug.h" #include "ntp_tty.h" #ifdef HAVE_UNISTD_H #include #endif #ifdef SYS_WINNT #include #else #ifdef SYS_VXWORKS #include "taskLib.h" #include "sysLib.h" #include "time.h" #include "ntp_syslog.h" /* some translations to the world of vxWorkings -casey */ /* first some netdb type things */ #include "ioLib.h" #include int h_errno; struct hostent *gethostbyname(char *name) { struct hostent *host1; h_errno = 0; /* we are always successful!!! */ host1 = (struct hostent *) emalloc (sizeof(struct hostent)); host1->h_name = name; host1->h_addrtype = AF_INET; host1->h_aliases = name; host1->h_length = 4; host1->h_addr_list[0] = (char *)hostGetByName (name); host1->h_addr_list[1] = NULL; return host1; } struct hostent *gethostbyaddr(char *name, int size, int addr_type) { struct hostent *host1; h_errno = 0; /* we are always successful!!! */ host1 = (struct hostent *) emalloc (sizeof(struct hostent)); host1->h_name = name; host1->h_addrtype = AF_INET; host1->h_aliases = name; host1->h_length = 4; host1->h_addr_list = NULL; return host1; } struct servent *getservbyname (char *name, char *type) { struct servent *serv1; serv1 = (struct servent *) emalloc (sizeof(struct servent)); serv1->s_name = "ntp"; /* official service name */ serv1->s_aliases = NULL; /* alias list */ serv1->s_port = 123; /* port # */ serv1->s_proto = "udp"; /* protocol to use */ return serv1; } /* second * vxworks thinks it has insomnia * we have to sleep for number of seconds */ #define CLKRATE sysClkRateGet() /* I am not sure how valid the granularity is - it is from G. Eger's port */ #define CLK_GRANULARITY 1 /* Granularity of system clock in usec */ /* Used to round down # usecs/tick */ /* On a VCOM-100, PIT gets 8 MHz clk, */ /* & it prescales by 32, thus 4 usec */ /* on mv167, granularity is 1usec anyway*/ /* To defeat rounding, set to 1 */ #define USECS_PER_SEC MILLION /* Microseconds per second */ #define TICK (((USECS_PER_SEC / CLKRATE) / CLK_GRANULARITY) * CLK_GRANULARITY) /* emulate unix sleep * casey */ void sleep(int seconds) { taskDelay(seconds*TICK); } /* emulate unix alarm * that pauses and calls SIGALRM after the seconds are up... * so ... taskDelay() fudged for seconds should amount to the same thing. * casey */ void alarm (int seconds) { sleep(seconds); } #endif /* SYS_VXWORKS */ #ifdef SYS_PTX /* Does PTX still need this? */ /*#include */ #include int gettimeofday( struct timeval *tvp ) { /* * hi, this is Sequents sneak path to get to a clock * this is also the most logical syscall for such a function */ return (get_process_stats(tvp, PS_SELF, (struct procstats *) 0, (struct procstats *) 0)); } #endif /* SYS_PTX */ #ifdef MPE /* This is a substitute for bind() that if called for an AF_INET socket port less than 1024, GETPRIVMODE() and GETUSERMODE() calls will be done. */ #undef bind #include #include #include #include extern void GETPRIVMODE(void); extern void GETUSERMODE(void); int __ntp_mpe_bind(int s, void *addr, int addrlen); int __ntp_mpe_bind(int s, void *addr, int addrlen) { int priv = 0; int result; if (addrlen == sizeof(struct sockaddr_in)) { /* AF_INET */ if (((struct sockaddr_in *)addr)->sin_port > 0 && ((struct sockaddr_in *)addr)->sin_port < 1024) { priv = 1; GETPRIVMODE(); } /* ((struct sockaddr_in *)addr)->sin_addr.s_addr = 0; */ result = bind(s,addr,addrlen); if (priv == 1) GETUSERMODE(); } else /* AF_UNIX */ result = bind(s,addr,addrlen); return result; } /* * MPE stupidly requires sfcntl() to be used on sockets instead of fcntl(), * so we define a wrapper to analyze the file descriptor and call the correct * function. */ #undef fcntl #include #include int __ntp_mpe_fcntl(int fd, int cmd, int arg); int __ntp_mpe_fcntl(int fd, int cmd, int arg) { int len; struct sockaddr sa; extern int sfcntl(int, int, int); len = sizeof sa; if (getsockname(fd, &sa, &len) == -1) { if (errno == EAFNOSUPPORT) /* AF_UNIX socket */ return sfcntl(fd, cmd, arg); if (errno == ENOTSOCK) /* file or pipe */ return fcntl(fd, cmd, arg); return (-1); /* unknown getsockname() failure */ } else /* AF_INET socket */ return sfcntl(fd, cmd, arg); } /* * Setitimer emulation support. Note that we implement this using alarm(), * and since alarm() only delivers one signal, we must re-enable the alarm * by enabling our own SIGALRM setitimer_mpe_handler routine to be called * before the real handler routine and re-enable the alarm at that time. * * Note that this solution assumes that sigaction(SIGALRM) is called before * calling setitimer(). If it should ever to become necessary to support * sigaction(SIGALRM) after calling setitimer(), it will be necessary to trap * those sigaction() calls. */ #include #include /* * Some global data that needs to be shared between setitimer() and * setitimer_mpe_handler(). */ struct { unsigned long current_msec; /* current alarm() value in effect */ unsigned long interval_msec; /* next alarm() value from setitimer */ unsigned long value_msec; /* first alarm() value from setitimer */ struct itimerval current_itimerval; /* current itimerval in effect */ struct sigaction oldact; /* SIGALRM state saved by setitimer */ } setitimer_mpe_ctx = { 0, 0, 0 }; /* * Undocumented, unsupported function to do alarm() in milliseconds. */ extern unsigned int px_alarm(unsigned long, int *); /* * The SIGALRM handler routine enabled by setitimer(). Re-enable the alarm or * restore the original SIGALRM setting if no more alarms are needed. Then * call the original SIGALRM handler (if any). */ static RETSIGTYPE setitimer_mpe_handler(int sig) { int alarm_hpe_status; /* Update the new current alarm value */ setitimer_mpe_ctx.current_msec = setitimer_mpe_ctx.interval_msec; if (setitimer_mpe_ctx.interval_msec > 0) { /* Additional intervals needed; re-arm the alarm timer */ px_alarm(setitimer_mpe_ctx.interval_msec,&alarm_hpe_status); } else { /* No more intervals, so restore previous original SIGALRM handler */ sigaction(SIGALRM, &setitimer_mpe_ctx.oldact, NULL); } /* Call the original SIGALRM handler if it is a function and not just a flag */ if (setitimer_mpe_ctx.oldact.sa_handler != SIG_DFL && setitimer_mpe_ctx.oldact.sa_handler != SIG_ERR && setitimer_mpe_ctx.oldact.sa_handler != SIG_IGN) (*setitimer_mpe_ctx.oldact.sa_handler)(SIGALRM); } /* * Our implementation of setitimer(). */ int setitimer(int which, struct itimerval *value, struct itimerval *ovalue) { int alarm_hpe_status; unsigned long remaining_msec, value_msec, interval_msec; struct sigaction newact; /* * Convert the initial interval to milliseconds */ if (value->it_value.tv_sec > (UINT_MAX / 1000)) value_msec = UINT_MAX; else value_msec = value->it_value.tv_sec * 1000; value_msec += value->it_value.tv_usec / 1000; /* * Convert the reset interval to milliseconds */ if (value->it_interval.tv_sec > (UINT_MAX / 1000)) interval_msec = UINT_MAX; else interval_msec = value->it_interval.tv_sec * 1000; interval_msec += value->it_interval.tv_usec / 1000; if (value_msec > 0 && interval_msec > 0) { /* * We'll be starting an interval timer that will be repeating, so we need to * insert our own SIGALRM signal handler to schedule the repeats. */ /* Read the current SIGALRM action */ if (sigaction(SIGALRM, NULL, &setitimer_mpe_ctx.oldact) < 0) { fprintf(stderr,"MPE setitimer old handler failed, errno=%d\n",errno); return -1; } /* Initialize the new action to call our SIGALRM handler instead */ newact.sa_handler = &setitimer_mpe_handler; newact.sa_mask = setitimer_mpe_ctx.oldact.sa_mask; newact.sa_flags = setitimer_mpe_ctx.oldact.sa_flags; if (sigaction(SIGALRM, &newact, NULL) < 0) { fprintf(stderr,"MPE setitimer new handler failed, errno=%d\n",errno); return -1; } } /* * Return previous itimerval if desired */ if (ovalue != NULL) *ovalue = setitimer_mpe_ctx.current_itimerval; /* * Save current parameters for later usage */ setitimer_mpe_ctx.current_itimerval = *value; setitimer_mpe_ctx.current_msec = value_msec; setitimer_mpe_ctx.value_msec = value_msec; setitimer_mpe_ctx.interval_msec = interval_msec; /* * Schedule the first alarm */ remaining_msec = px_alarm(value_msec, &alarm_hpe_status); if (alarm_hpe_status == 0) return (0); else return (-1); } /* * MPE lacks gettimeofday(), so we define our own. */ int gettimeofday(struct timeval *tvp) { /* Documented, supported MPE functions. */ extern void GETPRIVMODE(void); extern void GETUSERMODE(void); /* Undocumented, unsupported MPE functions. */ extern long long get_time(void); extern void get_time_change_info(long long *, char *, char *); extern long long ticks_to_micro(long long); char pwf_since_boot, recover_pwf_time; long long mpetime, offset_ticks, offset_usec; GETPRIVMODE(); mpetime = get_time(); /* MPE local time usecs since Jan 1 1970 */ get_time_change_info(&offset_ticks, &pwf_since_boot, &recover_pwf_time); offset_usec = ticks_to_micro(offset_ticks); /* UTC offset usecs */ GETUSERMODE(); mpetime = mpetime - offset_usec; /* Convert from local time to UTC */ tvp->tv_sec = mpetime / 1000000LL; tvp->tv_usec = mpetime % 1000000LL; return 0; } /* * MPE lacks settimeofday(), so we define our own. */ #define HAVE_SETTIMEOFDAY int settimeofday(struct timeval *tvp) { /* Documented, supported MPE functions. */ extern void GETPRIVMODE(void); extern void GETUSERMODE(void); /* Undocumented, unsupported MPE functions. */ extern void get_time_change_info(long long *, char *, char *); extern void initialize_system_time(long long, int); extern void set_time_correction(long long, int, int); extern long long ticks_to_micro(long long); char pwf_since_boot, recover_pwf_time; long long big_sec, big_usec, mpetime, offset_ticks, offset_usec; big_sec = tvp->tv_sec; big_usec = tvp->tv_usec; mpetime = (big_sec * 1000000LL) + big_usec; /* Desired UTC microseconds */ GETPRIVMODE(); set_time_correction(0LL,0,0); /* Cancel previous time correction, if any */ get_time_change_info(&offset_ticks, &pwf_since_boot, &recover_pwf_time); offset_usec = ticks_to_micro(offset_ticks); /* UTC offset microseconds */ mpetime = mpetime + offset_usec; /* Convert from UTC to local time */ initialize_system_time(mpetime,1); GETUSERMODE(); return 0; } #endif /* MPE */ #define SET_TOD_UNDETERMINED 0 #define SET_TOD_CLOCK_SETTIME 1 #define SET_TOD_SETTIMEOFDAY 2 #define SET_TOD_STIME 3 const char * const set_tod_used[] = { "undetermined", "clock_settime", "settimeofday", "stime" }; pset_tod_using set_tod_using = NULL; int ntp_set_tod( struct timeval *tvp, void *tzp ) { static int tod; int rc; int saved_errno; TRACE(1, ("In ntp_set_tod\n")); rc = -1; saved_errno = 0; #ifdef HAVE_CLOCK_SETTIME if (rc && (SET_TOD_CLOCK_SETTIME == tod || !tod)) { struct timespec ts; /* Convert timeval to timespec */ ts.tv_sec = tvp->tv_sec; ts.tv_nsec = 1000 * tvp->tv_usec; errno = 0; rc = clock_settime(CLOCK_REALTIME, &ts); saved_errno = errno; TRACE(1, ("ntp_set_tod: clock_settime: %d %m\n", rc)); if (!tod && !rc) tod = SET_TOD_CLOCK_SETTIME; } #endif /* HAVE_CLOCK_SETTIME */ #ifdef HAVE_SETTIMEOFDAY if (rc && (SET_TOD_SETTIMEOFDAY == tod || !tod)) { struct timeval adjtv; /* * Some broken systems don't reset adjtime() when the * clock is stepped. */ adjtv.tv_sec = adjtv.tv_usec = 0; adjtime(&adjtv, NULL); errno = 0; rc = SETTIMEOFDAY(tvp, tzp); saved_errno = errno; TRACE(1, ("ntp_set_tod: settimeofday: %d %m\n", rc)); if (!tod && !rc) tod = SET_TOD_SETTIMEOFDAY; } #endif /* HAVE_SETTIMEOFDAY */ #ifdef HAVE_STIME if (rc && (SET_TOD_STIME == tod || !tod)) { long tp = tvp->tv_sec; errno = 0; rc = stime(&tp); /* lie as bad as SysVR4 */ saved_errno = errno; TRACE(1, ("ntp_set_tod: stime: %d %m\n", rc)); if (!tod && !rc) tod = SET_TOD_STIME; } #endif /* HAVE_STIME */ errno = saved_errno; /* for %m below */ TRACE(1, ("ntp_set_tod: Final result: %s: %d %m\n", set_tod_used[tod], rc)); /* * Say how we're setting the time of day */ if (!rc && NULL != set_tod_using) { (*set_tod_using)(set_tod_used[tod]); set_tod_using = NULL; } if (rc) errno = saved_errno; return rc; } #endif /* not SYS_WINNT */ #if defined (SYS_WINNT) || defined (SYS_VXWORKS) || defined(MPE) /* getpass is used in ntpq.c and ntpdc.c */ char * getpass(const char * prompt) { int c, i; static char password[32]; fprintf(stderr, "%s", prompt); fflush(stderr); for (i=0; i= 0; ++i) { if (baudTable[i][0] == symBaud) { break; } } return baudTable[i][1]; } #if 0 /* unused */ int numBaud2symBaud(int numBaud) { int i; for (i = 0; baudTable[i][1] >= 0; ++i) { if (baudTable[i][1] == numBaud) { break; } } return baudTable[i][0]; } #endif /* unused fn */