534 lines
13 KiB
C
534 lines
13 KiB
C
/* 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 "lib_strbuf.h"
|
|
#include "ntp_debug.h"
|
|
|
|
#ifdef HAVE_UNISTD_H
|
|
#include <unistd.h>
|
|
#endif
|
|
|
|
#ifdef SYS_WINNT
|
|
int _getch(void); /* Declare the one function rather than include conio.h */
|
|
#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 <socket.h>
|
|
int h_errno;
|
|
|
|
struct hostent *gethostbyname(char *name)
|
|
{
|
|
struct hostent *host1;
|
|
h_errno = 0; /* we are always successful!!! */
|
|
host1 = (struct hostent *) malloc (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 *) malloc (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 *) malloc (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 <sys/types.h> */
|
|
#include <sys/procstats.h>
|
|
|
|
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 <sys/types.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <sys/un.h>
|
|
|
|
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 <errno.h>
|
|
#include <fcntl.h>
|
|
|
|
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 <limits.h>
|
|
#include <signal.h>
|
|
|
|
/*
|
|
* 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<sizeof(password)-1 && ((c=_getch())!='\n' && c!='\r'); i++) {
|
|
password[i] = (char) c;
|
|
}
|
|
password[i] = '\0';
|
|
|
|
fputc('\n', stderr);
|
|
fflush(stderr);
|
|
|
|
return password;
|
|
}
|
|
#endif /* SYS_WINNT */
|