socket ntp连接，打开socket出错

发布于 2019-02-15 14:56:40 浏览：2065 订阅该版

我使用rtthread的ntp例程，使用过程中建立的socket成功几次后就打不开了，什么原因了？调试信息如下图：
![ntp.png](/uploads/201902/15/145535mlodydc5yypyyyg7.png)

程序如下：
```time_t ntp_get_time(const char *host_name)
{
	rt_kprintf(" <br>-----------------begin <br>");
	int sockfd, n; // Socket file descriptor and the n return result from writing/reading from the socket.

int portno = 123; // NTP UDP port number.

time_t new_time = 0;
    struct timeval timeout;

// Using default host name when host_name is NULL
    if (host_name == NULL)
    {
        host_name = NTP_HOSTNAME;
    }

// Create and zero out the packet. All 48 bytes worth.

memset(&packet, 0, sizeof(ntp_packet));

// Set the first byte's bits to 00,011,011 for li = 0, vn = 3, and mode = 3. The rest will be left set to zero.

*((char *) &packet + 0) = 0x1b; // Represents 27 in base 10 or 00011011 in base 2.

// Create a UDP socket, convert the host-name to an IP address, set the port number,
    // connect to the server, send the packet, and then read in the return packet.

struct sockaddr_in serv_addr; // Server address data structure.
    struct hostent *server;      // Server data structure.

sockfd = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP); // Create a UDP socket.

if (sockfd < 0) {
		ntp_error("opening socket %d",rt_get_errno());
        return 0;
    }
	
	timeout.tv_sec = NTP_GET_TIMEOUT;
    timeout.tv_usec = 0;

/* set receive and send timeout option */
    setsockopt(sockfd, SOL_SOCKET, SO_RCVTIMEO, (void *) &timeout,
               sizeof(timeout));
    setsockopt(sockfd, SOL_SOCKET, SO_SNDTIMEO, (void *) &timeout,
               sizeof(timeout));

//    server = gethostbyname(host_name); // Convert URL to IP.

//    if (server == NULL) {
//        ntp_error("no such host");
//        goto __exit;
//    }
	
	// Zero out the server address structure.

memset((char *) &serv_addr, 0, sizeof(serv_addr));

serv_addr.sin_family = AF_INET;

// Copy the server's IP address to the server address structure.

serv_addr.sin_addr.s_addr = inet_addr("192.168.94.111");
    //memcpy((char *) &serv_addr.sin_addr.s_addr, (char *) server->h_addr, server->h_length);

// Convert the port number integer to network big-endian style and save it to the server address structure.

serv_addr.sin_port = htons(portno);

// Call up the server using its IP address and port number.

if (connect(sockfd, (struct sockaddr *) &serv_addr, sizeof(serv_addr)) < 0) {
        ntp_error("connecting");
        goto __exit;
    }
	
	// Send it the NTP packet it wants. If n == -1, it failed.

n = send(sockfd, (char*) &packet, sizeof(ntp_packet), 0);

if (n < 0) {
        ntp_error("writing to socket");
        goto __exit;
    }

// Wait and receive the packet back from the server. If n == -1, it failed.

n = recv(sockfd, (char*) &packet, sizeof(ntp_packet), 0);

if (n < 0) {
        if (errno == EWOULDBLOCK || errno == EAGAIN) {
            ntp_error("receive the socket timeout(%ds)", NTP_GET_TIMEOUT);
        } else {
            ntp_error("reading from socket, error code %d.", n);
        }
        goto __exit;
    }
	
	// These two fields contain the time-stamp seconds as the packet left the NTP server.
    // The number of seconds correspond to the seconds passed since 1900.
    // ntohl() converts the bit/byte order from the network's to host's "endianness".

packet.txTm_s = ntohl(packet.txTm_s); // Time-stamp seconds.
    packet.txTm_f = ntohl(packet.txTm_f); // Time-stamp fraction of a second.

// Extract the 32 bits that represent the time-stamp seconds (since NTP epoch) from when the packet left the server.
    // Subtract 70 years worth of seconds from the seconds since 1900.
    // This leaves the seconds since the UNIX epoch of 1970.
    // (1900)------------------(1970)**************************************(Time Packet Left the Server)

new_time = (time_t) (packet.txTm_s - NTP_TIMESTAMP_DELTA);

__exit:

//shutdown(sockfd, 0);
    closesocket(sockfd);
	rt_kprintf(" <br>-----------------end <br>");
    return new_time;
}```