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