sntpclib.c

VXWORKS源代码

  
    sntpSocket = socket (AF_INET, SOCK_DGRAM, 0);
    if (sntpSocket == -1) 
        return (ERROR);

    /* 
     * Enable broadcast option for socket in case that address is given. 
     * This use of the SNTP client is not likely, so ignore errors. If 
     * the broadcast address is used, and this call fails, the error will
     * be caught by sendto() below.
     */

    optval = 1;
    result = setsockopt (sntpSocket, SOL_SOCKET, SO_BROADCAST, 
                         (char *)&optval, sizeof (optval));

    /* Initialize SNTP message buffers. */
  
    bzero ( (char *)&sntpRequest, sizeof (sntpRequest));
    bzero ( (char *)&sntpReply, sizeof (sntpReply));
  
    sntpRequest.leapVerMode = SNTP_CLIENT_REQUEST;
  
    bzero ( (char *) &servAddr, sizeof (servAddr));
    servAddrLen = sizeof (servAddr);
  
    /* Transmit SNTP request. */
  
    if (sendto (sntpSocket, (caddr_t)&sntpRequest, sizeof(sntpRequest), 0,
                (struct sockaddr *)&dstAddr, sizeof (dstAddr)) == -1) 
        {
        close (sntpSocket);
        return (ERROR);
        }
    
    /* Convert timeout value to format needed by select() call. */

    if (timeout != WAIT_FOREVER)
        {
        clockRate = sysClkRateGet ();
        sockTimeout.tv_sec = timeout / clockRate;
        sockTimeout.tv_usec = (1000000 * timeout % clockRate) / clockRate;
        }

    /* Wait for reply at the ephemeral port selected by the sendto () call. */

    FD_ZERO (&readFds);
    FD_SET (sntpSocket, &readFds);

    if (timeout == WAIT_FOREVER)
        result = select (FD_SETSIZE, &readFds, NULL, NULL, NULL);
    else
        result = select (FD_SETSIZE, &readFds, NULL, NULL, &sockTimeout);

    if (result == -1) 
        {
        close (sntpSocket);
        return (ERROR);
        }

    if (result == 0)    /* Timeout interval expired. */
        {
        close (sntpSocket); 
        errnoSet (S_sntpcLib_TIMEOUT);
        return (ERROR);
        }

    result = recvfrom (sntpSocket, (caddr_t)&sntpReply, sizeof (sntpReply),
                       0, (struct sockaddr *)&servAddr, &servAddrLen);

    if (result == -1) 
        {
        close (sntpSocket);
        return (ERROR);	  
        }

    close (sntpSocket);

    /*
     * Return error if the server clock is unsynchronized, or the version is 
     * not supported.
     */

    if ( (sntpReply.leapVerMode & SNTP_LI_MASK) == SNTP_LI_3 ||
        sntpReply.transmitTimestampSec == 0)
        {
        errnoSet (S_sntpcLib_SERVER_UNSYNC);
        return (ERROR);
        }

    if ( (sntpReply.leapVerMode & SNTP_VN_MASK) == SNTP_VN_0 ||
        (sntpReply.leapVerMode & SNTP_VN_MASK) > SNTP_VN_3)
        {
        errnoSet (S_sntpcLib_VERSION_UNSUPPORTED);
	return (ERROR);
        }

    /* Convert the NTP timestamp to the correct format and store in clock. */

    /* Add test for 2036 base value here! */

    sntpReply.transmitTimestampSec = ntohl (sntpReply.transmitTimestampSec) - 
                                     SNTP_UNIX_OFFSET;

    /* 
     * Adjust returned value if leap seconds are present. 
     * This needs work! 
     */ 

    /* if ( (sntpReply.leapVerMode & SNTP_LI_MASK) == SNTP_LI_1)
            sntpReply.transmitTimestampSec += 1;
     else if ((sntpReply.leapVerMode & SNTP_LI_MASK) == SNTP_LI_2)
              sntpReply.transmitTimestampSec -= 1;
    */

    sntpReply.transmitTimestampFrac = ntohl (sntpReply.transmitTimestampFrac);

    pCurrTime->tv_sec = sntpReply.transmitTimestampSec;
    pCurrTime->tv_nsec = sntpcFractionToNsec (sntpReply.transmitTimestampFrac);

    return (OK);
    }

/*******************************************************************************
*
* sntpcListen - retrieve the time from an SNTP/NTP broadcast
*
* This routine listens to the SNTP/NTP port for a valid message from any 
* SNTP/NTP server executing in broadcast mode, converts the returned NTP 
* timestamp to the POSIX-compliant clock format with the UNIX base value
* (elapsed time since 00:00 GMT on January 1, 1970), and stores the result in 
* the location indicated by <pTime>.
* 
* RETURNS: OK, or ERROR if unsuccessful.
*
* ERRNO:
*  S_sntpcLib_TIMEOUT
*
* NOMANUAL
*/

LOCAL STATUS sntpcListen
    (
    u_int 		timeout,	/* timeout in ticks */
    struct timespec * 	pCurrTime	/* storage for retrieved time value */
    )
    {
    SNTP_PACKET sntpMessage;    /* buffer for message from server */
    struct sockaddr_in srcAddr;
    int sntpSocket;
    struct timeval sockTimeout;
    int clockRate;
    fd_set readFds;
    int result;
    int srcAddrLen;
 
    /* Initialize source address. */

    bzero ( (char *)&srcAddr, sizeof (srcAddr));
    srcAddr.sin_addr.s_addr = INADDR_ANY;
    srcAddr.sin_family = AF_INET;
    srcAddr.sin_port = sntpcPort;

    /* Create socket for listening. */
  
    sntpSocket = socket (AF_INET, SOCK_DGRAM, 0);
    if (sntpSocket == -1) 
        return (ERROR);
      
    result = bind (sntpSocket, (struct sockaddr *)&srcAddr, sizeof (srcAddr));
    if (result == -1) 
        {
        close (sntpSocket);
        return (ERROR);
        }

    /* Convert timeout value to format needed by select() call. */

    if (timeout != WAIT_FOREVER)
        {
        clockRate = sysClkRateGet ();
        sockTimeout.tv_sec = timeout / clockRate;
        sockTimeout.tv_usec = (1000000 * timeout % clockRate) / clockRate;
        }

    /* Wait for broadcast message from server. */

    FD_ZERO (&readFds);
    FD_SET (sntpSocket, &readFds);
      
    if (timeout == WAIT_FOREVER)
        result = select (FD_SETSIZE, &readFds, NULL, NULL, NULL);
    else
        result = select (FD_SETSIZE, &readFds, NULL, NULL, &sockTimeout);

    if (result == -1)
        {
        close (sntpSocket);
        errnoSet (S_sntpcLib_TIMEOUT);
        return (ERROR);
        }

    if (result == 0)    /* Timeout interval expired. */
        {
        close (sntpSocket);
        errnoSet (S_sntpcLib_TIMEOUT);
        return (ERROR);
        }

    result = recvfrom (sntpSocket, (caddr_t) &sntpMessage, sizeof(sntpMessage),
                       0, (struct sockaddr *) &srcAddr, &srcAddrLen);
    if (result == -1) 
        {
        close (sntpSocket);
        return (ERROR);
        }

    close (sntpSocket);

    /*
     * Return error if the server clock is unsynchronized, or the version is 
     * not supported.
     */

    if ( (sntpMessage.leapVerMode & SNTP_LI_MASK) == SNTP_LI_3 ||
        sntpMessage.transmitTimestampSec == 0)
        {
        errnoSet (S_sntpcLib_SERVER_UNSYNC);
        return (ERROR);
        }

    if ( (sntpMessage.leapVerMode & SNTP_VN_MASK) == SNTP_VN_0 ||
        (sntpMessage.leapVerMode & SNTP_VN_MASK) > SNTP_VN_3)
        {
        errnoSet (S_sntpcLib_VERSION_UNSUPPORTED);
        return (ERROR);
        }

    /* Convert the NTP timestamp to the correct format and store in clock. */

    /* Add test for 2036 base value here! */

    sntpMessage.transmitTimestampSec = 
                                     ntohl (sntpMessage.transmitTimestampSec) -
                                     SNTP_UNIX_OFFSET;

    /*
     * Adjust returned value if leap seconds are present.
     * This needs work!
     */

    /* if ( (sntpReply.leapVerMode & SNTP_LI_MASK) == SNTP_LI_1)
            sntpReply.transmitTimestampSec += 1;
     else if ((sntpReply.leapVerMode & SNTP_LI_MASK) == SNTP_LI_2)
              sntpReply.transmitTimestampSec -= 1;
    */

    sntpMessage.transmitTimestampFrac = 
                                     ntohl (sntpMessage.transmitTimestampFrac);

    pCurrTime->tv_sec = sntpMessage.transmitTimestampSec;
    pCurrTime->tv_nsec =
                       sntpcFractionToNsec (sntpMessage.transmitTimestampFrac);

    return (OK);
    }