void test_IPv4Address() {
const char* ADDR = "192.0.2.10";
sockaddr_u input = CreateSockaddr4(ADDR);
struct addrinfo inputA = CreateAddrinfo(&input);
TEST_ASSERT_EQUAL_STRING(ADDR, ss_to_str(&input));
TEST_ASSERT_EQUAL_STRING(ADDR, addrinfo_to_str(&inputA));
}
/* Convert a struct addrinfo to a string containing the address in style
* of inet_ntoa
*/
char *
addrinfo_to_str (
const struct addrinfo *addr
)
{
sockaddr_u s;
ZERO(s);
memcpy(&s, addr->ai_addr, min(sizeof(s), addr->ai_addrlen));
return ss_to_str(&s);
}
/* Convert a struct addrinfo to a string containing the address in style
* of inet_ntoa
*/
char *
addrinfo_to_str (
struct addrinfo *addr
)
{
sockaddr_u s;
memset(&s, 0, sizeof(s));
memcpy(&s, addr->ai_addr, min(sizeof(s), addr->ai_addrlen));
return ss_to_str(&s);
}
TEST(utilities, IPv4Address) {
const char* ADDR = "192.0.2.10";
sockaddr_u input = CreateSockaddr4(ADDR, 123);
struct addrinfo inputA = CreateAddrinfo(&input);
/* coverity[leaked_storage] */
TEST_ASSERT_EQUAL_STRING(ADDR, ss_to_str(&input));
/* coverity[leaked_storage] */
TEST_ASSERT_EQUAL_STRING(ADDR, addrinfo_to_str(&inputA));
/* coverity[leaked_storage] */
}
void test_IPv6Address() {
const struct in6_addr address = {
0x20, 0x01, 0x0d, 0xb8,
0x85, 0xa3, 0x08, 0xd3,
0x13, 0x19, 0x8a, 0x2e,
0x03, 0x70, 0x73, 0x34
};
const char * expected = "2001:db8:85a3:8d3:1319:8a2e:370:7334";
sockaddr_u input;
struct addrinfo inputA;
memset(&input, 0, sizeof(input));
input.sa6.sin6_family = AF_INET6;
input.sa6.sin6_addr = address;
TEST_ASSERT_EQUAL_STRING(expected, ss_to_str(&input));
inputA = CreateAddrinfo(&input);
TEST_ASSERT_EQUAL_STRING(expected, addrinfo_to_str(&inputA));
}
int
process_pkt (
struct pkt *rpkt,
sockaddr_u *sas,
int pkt_len,
int mode,
struct pkt *spkt,
const char * func_name
)
{
unsigned int key_id = 0;
struct key *pkt_key = NULL;
int is_authentic = 0;
unsigned int exten_words, exten_words_used = 0;
int mac_size;
/*
* Parse the extension field if present. We figure out whether
* an extension field is present by measuring the MAC size. If
* the number of words following the packet header is 0, no MAC
* is present and the packet is not authenticated. If 1, the
* packet is a crypto-NAK; if 3, the packet is authenticated
* with DES; if 5, the packet is authenticated with MD5; if 6,
* the packet is authenticated with SHA. If 2 or 4, the packet
* is a runt and discarded forthwith. If greater than 6, an
* extension field is present, so we subtract the length of the
* field and go around again.
*/
if (pkt_len < (int)LEN_PKT_NOMAC || (pkt_len & 3) != 0) {
unusable:
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp %s: Funny packet length: %i. Discarding package.\n", func_name, pkt_len);
return PACKET_UNUSEABLE;
}
/* skip past the extensions, if any */
exten_words = ((unsigned)pkt_len - LEN_PKT_NOMAC) >> 2;
while (exten_words > 6) {
unsigned int exten_len;
exten_len = ntohl(rpkt->exten[exten_words_used]) & 0xffff;
exten_len = (exten_len + 7) >> 2; /* convert to words, add 1 */
if (exten_len > exten_words || exten_len < 5)
goto unusable;
exten_words -= exten_len;
exten_words_used += exten_len;
}
switch (exten_words) {
case 1:
key_id = ntohl(rpkt->exten[exten_words_used]);
printf("Crypto NAK = 0x%08x\n", key_id);
break;
case 5:
case 6:
/* Look for the key used by the server in the specified keyfile
* and if existent, fetch it or else leave the pointer untouched */
key_id = ntohl(rpkt->exten[exten_words_used]);
get_key(key_id, &pkt_key);
if (!pkt_key) {
printf("unrecognized key ID = 0x%08x\n", key_id);
break;
}
/* Seems like we've got a key with matching keyid */
/* Generate a md5sum of the packet with the key from our keyfile
* and compare those md5sums */
mac_size = exten_words << 2;
if (!auth_md5((char *)rpkt, pkt_len - mac_size, mac_size - 4, pkt_key)) {
break;
}
/* Yay! Things worked out! */
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(sas);
printf("sntp %s: packet received from %s successfully authenticated using key id %i.\n",
func_name, hostname, key_id);
free(hostname);
}
is_authentic = 1;
break;
case 0:
break;
default:
goto unusable;
break;
}
if (!is_authentic) {
if (ENABLED_OPT(AUTHENTICATION)) {
/* We want a authenticated packet */
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(sas);
printf("sntp %s: packet received from %s is not authentic. Will discard it.\n",
func_name, hostname);
free(hostname);
}
return SERVER_AUTH_FAIL;
}
/* We don't know if the user wanted authentication so let's
* use it anyways */
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(sas);
printf("sntp %s: packet received from %s is not authentic. Authentication not enforced.\n",
func_name, hostname);
free(hostname);
}
}
/* Check for server's ntp version */
if (PKT_VERSION(rpkt->li_vn_mode) < NTP_OLDVERSION ||
PKT_VERSION(rpkt->li_vn_mode) > NTP_VERSION) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp %s: Packet shows wrong version (%i)\n",
func_name, PKT_VERSION(rpkt->li_vn_mode));
return SERVER_UNUSEABLE;
}
/* We want a server to sync with */
if (PKT_MODE(rpkt->li_vn_mode) != mode &&
PKT_MODE(rpkt->li_vn_mode) != MODE_PASSIVE) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp %s: mode %d stratum %i\n", func_name,
PKT_MODE(rpkt->li_vn_mode), rpkt->stratum);
return SERVER_UNUSEABLE;
}
/* Stratum is unspecified (0) check what's going on */
if (STRATUM_PKT_UNSPEC == rpkt->stratum) {
char *ref_char;
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp %s: Stratum unspecified, going to check for KOD (stratum: %i)\n",
func_name, rpkt->stratum);
ref_char = (char *) &rpkt->refid;
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp %s: Packet refid: %c%c%c%c\n", func_name,
ref_char[0], ref_char[1], ref_char[2], ref_char[3]);
/* If it's a KOD packet we'll just use the KOD information */
if (ref_char[0] != 'X') {
if (strncmp(ref_char, "DENY", 4) == 0)
return KOD_DEMOBILIZE;
if (strncmp(ref_char, "RSTR", 4) == 0)
return KOD_DEMOBILIZE;
if (strncmp(ref_char, "RATE", 4) == 0)
return KOD_RATE;
/* There are other interesting kiss codes which might be interesting for authentication */
}
}
/* If the server is not synced it's not really useable for us */
if (LEAP_NOTINSYNC == PKT_LEAP(rpkt->li_vn_mode)) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp %s: Server not in sync, skipping this server\n", func_name);
return SERVER_UNUSEABLE;
}
/*
* Decode the org timestamp and make sure we're getting a response
* to our last request, but only if we're not in broadcast mode.
*/
#ifdef DEBUG
printf("rpkt->org:\n");
l_fp_output(&rpkt->org, stdout);
printf("spkt->xmt:\n");
l_fp_output(&spkt->xmt, stdout);
#endif
if (mode != MODE_BROADCAST && !L_ISEQU(&rpkt->org, &spkt->xmt)) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp process_pkt: pkt.org and peer.xmt differ\n");
return PACKET_UNUSEABLE;
}
return pkt_len;
}
/* Receive data from broadcast. Couldn't finish that. Need to do some digging
* here, especially for protocol independence and IPv6 multicast */
int
recv_bcst_data (
SOCKET rsock,
char *rdata,
int rdata_len,
sockaddr_u *sas,
sockaddr_u *ras
)
{
char *buf;
int btrue = 1;
int recv_bytes = 0;
int rdy_socks;
GETSOCKNAME_SOCKLEN_TYPE ss_len;
struct timeval timeout_tv;
fd_set bcst_fd;
#ifdef MCAST
struct ip_mreq mdevadr;
TYPEOF_IP_MULTICAST_LOOP mtrue = 1;
#endif
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
struct ipv6_mreq mdevadr6;
#endif
setsockopt(rsock, SOL_SOCKET, SO_REUSEADDR, &btrue, sizeof(btrue));
if (IS_IPV4(sas)) {
if (bind(rsock, &sas->sa, SOCKLEN(sas)) < 0) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recv_bcst_data: Couldn't bind() address %s:%d.\n",
stoa(sas), SRCPORT(sas));
}
#ifdef MCAST
if (setsockopt(rsock, IPPROTO_IP, IP_MULTICAST_LOOP, &mtrue, sizeof(mtrue)) < 0) {
/* some error message regarding setting up multicast loop */
return BROADCAST_FAILED;
}
mdevadr.imr_multiaddr.s_addr = NSRCADR(sas);
mdevadr.imr_interface.s_addr = htonl(INADDR_ANY);
if (mdevadr.imr_multiaddr.s_addr == ~(unsigned)0) {
if (ENABLED_OPT(NORMALVERBOSE)) {
printf("sntp recv_bcst_data: %s:%d is not a broad-/multicast address, aborting...\n",
stoa(sas), SRCPORT(sas));
}
return BROADCAST_FAILED;
}
if (setsockopt(rsock, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mdevadr, sizeof(mdevadr)) < 0) {
if (ENABLED_OPT(NORMALVERBOSE)) {
buf = ss_to_str(sas);
printf("sntp recv_bcst_data: Couldn't add IP membership for %s\n", buf);
free(buf);
}
}
#endif /* MCAST */
}
#ifdef ISC_PLATFORM_HAVEIPV6
else if (IS_IPV6(sas)) {
if (bind(rsock, &sas->sa, SOCKLEN(sas)) < 0) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recv_bcst_data: Couldn't bind() address.\n");
}
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
if (setsockopt(rsock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP, &btrue, sizeof (btrue)) < 0) {
/* some error message regarding setting up multicast loop */
return BROADCAST_FAILED;
}
memset(&mdevadr6, 0, sizeof(mdevadr6));
mdevadr6.ipv6mr_multiaddr = SOCK_ADDR6(sas);
if (!IN6_IS_ADDR_MULTICAST(&mdevadr6.ipv6mr_multiaddr)) {
if (ENABLED_OPT(NORMALVERBOSE)) {
buf = ss_to_str(sas);
printf("sntp recv_bcst_data: %s is not a broad-/multicast address, aborting...\n", buf);
free(buf);
}
return BROADCAST_FAILED;
}
if (setsockopt(rsock, IPPROTO_IPV6, IPV6_JOIN_GROUP,
&mdevadr6, sizeof(mdevadr6)) < 0) {
if (ENABLED_OPT(NORMALVERBOSE)) {
buf = ss_to_str(sas);
printf("sntp recv_bcst_data: Couldn't join group for %s\n", buf);
free(buf);
}
}
#endif /* INCLUDE_IPV6_MULTICAST_SUPPORT */
}
#endif /* ISC_PLATFORM_HAVEIPV6 */
FD_ZERO(&bcst_fd);
FD_SET(rsock, &bcst_fd);
if (ENABLED_OPT(TIMEOUT))
timeout_tv.tv_sec = (int) atol(OPT_ARG(TIMEOUT));
else
timeout_tv.tv_sec = 68; /* ntpd broadcasts every 64s */
timeout_tv.tv_usec = 0;
rdy_socks = select(rsock + 1, &bcst_fd, 0, 0, &timeout_tv);
switch (rdy_socks) {
case -1:
if (ENABLED_OPT(NORMALVERBOSE))
perror("sntp recv_bcst_data: select()");
return BROADCAST_FAILED;
break;
case 0:
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recv_bcst_data: select() reached timeout (%u sec), aborting.\n",
(unsigned)timeout_tv.tv_sec);
return BROADCAST_FAILED;
break;
default:
ss_len = sizeof(*ras);
recv_bytes = recvfrom(rsock, rdata, rdata_len, 0, &ras->sa, &ss_len);
break;
}
if (recv_bytes == -1) {
if (ENABLED_OPT(NORMALVERBOSE))
perror("sntp recv_bcst_data: recvfrom:");
recv_bytes = BROADCAST_FAILED;
}
#ifdef MCAST
if (IS_IPV4(sas))
setsockopt(rsock, IPPROTO_IP, IP_DROP_MEMBERSHIP, &btrue, sizeof(btrue));
#endif
#ifdef INCLUDE_IPV6_MULTICAST_SUPPORT
if (IS_IPV6(sas))
setsockopt(rsock, IPPROTO_IPV6, IPV6_LEAVE_GROUP, &btrue, sizeof(btrue));
#endif
return recv_bytes;
}
/* Fetch data, check if it's data for us and whether it's useable or not. If not, return
* a failure code so we can delete this server from our list and continue with another one.
*/
int
recvpkt (
SOCKET rsock,
struct pkt *rpkt,
struct pkt *spkt
)
{
sockaddr_u sender;
char *rdata /* , done */;
register int a;
int has_mac, is_authentic, pkt_len, orig_pkt_len;
/* Much space, just to be sure */
rdata = emalloc(sizeof(char) * 256);
pkt_len = recvdata(rsock, &sender, rdata, 256);
#if 0 /* done uninitialized */
if (!done) {
/* Do something about it, first check for a maximum length of ntp packets,
* probably that's something we can avoid
*/
}
#endif
if (pkt_len < 0) {
if (ENABLED_OPT(NORMALVERBOSE)) {
printf("sntp recvpkt failed: %d.\n", pkt_len);
}
free(rdata);
return pkt_len;
}
/* Some checks to see if that packet is intended for us */
/* No MAC, no authentication */
if (LEN_PKT_NOMAC == pkt_len)
has_mac = 0;
/* If there's more than just the NTP packet it should be a MAC */
else if (pkt_len > LEN_PKT_NOMAC)
has_mac = pkt_len - LEN_PKT_NOMAC;
else {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recvpkt: Funny packet length: %i. Discarding package.\n", pkt_len);
free(rdata);
return PACKET_UNUSEABLE;
}
/* Packet too big */
if (pkt_len > LEN_PKT_MAC) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recvpkt: Received packet is too big (%i bytes), trying again to get a useable packet\n",
pkt_len);
free(rdata);
return PACKET_UNUSEABLE;
}
orig_pkt_len = pkt_len;
pkt_len = min(pkt_len, sizeof(struct pkt));
for (a = 0; a < pkt_len; a++)
/* FIXME! */
if (a < orig_pkt_len)
((char *) rpkt)[a] = rdata[a];
else
((char *) rpkt)[a] = 0;
free(rdata);
rdata = NULL;
/* MAC could be useable for us */
if (has_mac) {
/* Two more things that the MAC must conform to */
if(has_mac > MAX_MAC_LEN || has_mac % 4 != 0) {
is_authentic = 0; /* Or should we discard this packet? */
}
else {
if (MAX_MAC_LEN == has_mac) {
struct key *pkt_key = NULL;
/*
* Look for the key used by the server in the specified keyfile
* and if existent, fetch it or else leave the pointer untouched
*/
get_key(rpkt->mac[0], &pkt_key);
/* Seems like we've got a key with matching keyid */
if (pkt_key != NULL) {
/*
* Generate a md5sum of the packet with the key from our keyfile
* and compare those md5sums
*/
if (!auth_md5((char *) rpkt, has_mac, pkt_key)) {
if (ENABLED_OPT(AUTHENTICATION)) {
/* We want a authenticated packet */
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(&sender);
printf("sntp recvpkt: Broadcast packet received from %s is not authentic. Will discard this packet.\n",
hostname);
free(hostname);
}
return SERVER_AUTH_FAIL;
}
else {
/*
* We don't know if the user wanted authentication so let's
* use it anyways
*/
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(&sender);
printf("sntp recvpkt: Broadcast packet received from %s is not authentic. Authentication not enforced.\n",
hostname);
free(hostname);
}
is_authentic = 0;
}
}
else {
/* Yay! Things worked out! */
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(&sender);
printf("sntp recvpkt: Broadcast packet received from %s successfully authenticated using key id %i.\n",
hostname, rpkt->mac[0]);
free(hostname);
}
is_authentic = 1;
}
}
}
}
}
/* Check for server's ntp version */
if (PKT_VERSION(rpkt->li_vn_mode) < NTP_OLDVERSION ||
PKT_VERSION(rpkt->li_vn_mode) > NTP_VERSION) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recvpkt: Packet got wrong version (%i)\n", PKT_VERSION(rpkt->li_vn_mode));
return SERVER_UNUSEABLE;
}
/* We want a server to sync with */
if (PKT_MODE(rpkt->li_vn_mode) != MODE_SERVER &&
PKT_MODE(rpkt->li_vn_mode) != MODE_PASSIVE) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recvpkt: mode %d stratum %i\n",
PKT_MODE(rpkt->li_vn_mode), rpkt->stratum);
return SERVER_UNUSEABLE;
}
/* Stratum is unspecified (0) check what's going on */
if (STRATUM_PKT_UNSPEC == rpkt->stratum) {
char *ref_char;
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recvpkt: Stratum unspecified, going to check for KOD (stratum: %i)\n", rpkt->stratum);
ref_char = (char *) &rpkt->refid;
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recvpkt: Packet refid: %c%c%c%c\n", ref_char[0], ref_char[1], ref_char[2], ref_char[3]);
/* If it's a KOD packet we'll just use the KOD information */
if (ref_char[0] != 'X') {
if (!strncmp(ref_char, "DENY", 4))
return KOD_DEMOBILIZE;
if (!strncmp(ref_char, "RSTR", 4))
return KOD_DEMOBILIZE;
if (!strncmp(ref_char, "RATE", 4))
return KOD_RATE;
/* There are other interesting kiss codes which might be interesting for authentication */
}
}
/* If the server is not synced it's not really useable for us */
if (LEAP_NOTINSYNC == PKT_LEAP(rpkt->li_vn_mode)) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recvpkt: Server not in sync, skipping this server\n");
return SERVER_UNUSEABLE;
}
/*
* Decode the org timestamp and make sure we're getting a response
* to our last request.
*/
#ifdef DEBUG
printf("rpkt->org:\n");
l_fp_output(&rpkt->org, stdout);
printf("spkt->xmt:\n");
l_fp_output(&spkt->xmt, stdout);
#endif
if (!L_ISEQU(&rpkt->org, &spkt->xmt)) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recvpkt: pkt.org and peer.xmt differ\n");
return PACKET_UNUSEABLE;
}
return pkt_len;
}
int
recv_bcst_pkt (
SOCKET rsock,
struct pkt *rpkt,
sockaddr_u *sas
)
{
sockaddr_u sender;
register int a;
int is_authentic, has_mac = 0, orig_pkt_len;
char *rdata = emalloc(sizeof(char) * 256);
int pkt_len = recv_bcst_data(rsock, rdata, 256, sas, &sender);
if (pkt_len < 0) {
free(rdata);
return BROADCAST_FAILED;
}
/* No MAC, no authentication */
if (LEN_PKT_NOMAC == pkt_len)
has_mac = 0;
/* If there's more than just the NTP packet it should be a MAC */
else if(pkt_len > LEN_PKT_NOMAC)
has_mac = pkt_len - LEN_PKT_NOMAC;
else
if(ENABLED_OPT(NORMALVERBOSE)) {
printf("sntp recv_bcst_pkt: Funny packet length: %i. Discarding package.\n", pkt_len);
free(rdata);
return PACKET_UNUSEABLE;
}
/* Packet too big */
if(pkt_len > LEN_PKT_NOMAC + MAX_MAC_LEN) {
if(ENABLED_OPT(NORMALVERBOSE))
printf("sntp recv_bcst_pkt: Received packet is too big (%i bytes), trying again to get a useFable packet\n",
pkt_len);
free(rdata);
return PACKET_UNUSEABLE;
}
orig_pkt_len = pkt_len;
pkt_len = min(pkt_len, sizeof(struct pkt));
/* Let's copy the received data to the packet structure */
for (a = 0; a < pkt_len; a++)
if (a < orig_pkt_len)
((char *)rpkt)[a] = rdata[a];
else
((char *)rpkt)[a] = 0;
free(rdata);
/* MAC could be useable for us */
if (has_mac) {
/* Two more things that the MAC must conform to */
if (has_mac > MAX_MAC_LEN || has_mac % 4 != 0) {
is_authentic = 0; /* Or should we discard this packet? */
}
else {
if (MAX_MAC_LEN == has_mac) {
struct key *pkt_key = NULL;
/* Look for the key used by the server in the specified keyfile
* and if existent, fetch it or else leave the pointer untouched */
get_key(rpkt->mac[0], &pkt_key);
/* Seems like we've got a key with matching keyid */
if (pkt_key != NULL) {
/* Generate a md5sum of the packet with the key from our keyfile
* and compare those md5sums */
if (!auth_md5((char *) rpkt, has_mac, pkt_key)) {
if (ENABLED_OPT(AUTHENTICATION)) {
/* We want a authenticated packet */
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(sas);
printf("sntp recv_bcst_pkt: Broadcast packet received from %s is not authentic. Will discard this packet.\n",
hostname);
free(hostname);
}
return SERVER_AUTH_FAIL;
}
else {
/* We don't know if the user wanted authentication so let's
* use it anyways */
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(sas);
printf("sntp recv_bcst_pkt: Broadcast packet received from %s is not authentic. Authentication not enforced.\n",
hostname);
free(hostname);
}
is_authentic = 0;
}
}
else {
/* Yay! Things worked out! */
if (ENABLED_OPT(NORMALVERBOSE)) {
char *hostname = ss_to_str(sas);
printf("sntp recv_bcst_pkt: Broadcast packet received from %s successfully authenticated using key id %i.\n",
hostname, rpkt->mac[0]);
free(hostname);
}
is_authentic = 1;
}
}
}
}
}
/* Check for server's ntp version */
if (PKT_VERSION(rpkt->li_vn_mode) < NTP_OLDVERSION ||
PKT_VERSION(rpkt->li_vn_mode) > NTP_VERSION) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recv_bcst_pkt: Packet shows wrong version (%i)\n",
PKT_VERSION(rpkt->li_vn_mode));
return SERVER_UNUSEABLE;
}
/* We want a server to sync with */
if (PKT_MODE(rpkt->li_vn_mode) != MODE_BROADCAST
&& PKT_MODE(rpkt->li_vn_mode) != MODE_PASSIVE) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recv_bcst_pkt: mode %d stratum %i\n",
PKT_MODE(rpkt->li_vn_mode), rpkt->stratum);
return SERVER_UNUSEABLE;
}
if (STRATUM_PKT_UNSPEC == rpkt->stratum) {
char *ref_char;
if (ENABLED_OPT(NORMALVERBOSE))
printf("sntp recv_bcst_pkt: Stratum unspecified, going to check for KOD (stratum: %i)\n", rpkt->stratum);
ref_char = (char *) &rpkt->refid;
/* If it's a KOD packet we'll just use the KOD information */
if (ref_char[0] != 'X') {
if (strncmp(ref_char, "DENY", 4))
return KOD_DEMOBILIZE;
if (strncmp(ref_char, "RSTR", 4))
return KOD_DEMOBILIZE;
if (strncmp(ref_char, "RATE", 4))
return KOD_RATE;
/* There are other interesting kiss codes which might be interesting for authentication */
}
}
/* If the server is not synced it's not really useable for us */
if (LEAP_NOTINSYNC == PKT_LEAP(rpkt->li_vn_mode)) {
if (ENABLED_OPT(NORMALVERBOSE))
printf("recv_bcst_pkt: Server not in sync, skipping this server\n");
return SERVER_UNUSEABLE;
}
return pkt_len;
}
