contrib/ntp/sntp/tests/g_packetHandling.cpp

   1 #include "g_sntptest.h"
   2
   3 extern "C" {
   4 #include "kod_management.h"
   5 #include "main.h"
   6 #include "networking.h"
   7 #include "ntp.h"
   8 };
   9
  10 class mainTest : public sntptest {
  11 protected:
  12         ::testing::AssertionResult LfpEquality(const l_fp &expected, const l_fp &actual) {
  13                 if (L_ISEQU(&expected, &actual)) {
  14                         return ::testing::AssertionSuccess();
  15                 } else {
  16                         return ::testing::AssertionFailure()
  17                                 << " expected: " << lfptoa(&expected, FRACTION_PREC)
  18                                 << " (" << expected.l_ui << "." << expected.l_uf << ")"
  19                                 << " but was: " << lfptoa(&actual, FRACTION_PREC)
  20                                 << " (" << actual.l_ui << "." << actual.l_uf << ")";
  21                 }
  22         }
  23 };
  24
  25 TEST_F(mainTest, GenerateUnauthenticatedPacket) {
  26         pkt testpkt;
  27
  28         timeval xmt;
  29         GETTIMEOFDAY(&xmt, NULL);
  30         xmt.tv_sec += JAN_1970;
  31
  32         EXPECT_EQ(LEN_PKT_NOMAC,
  33                           generate_pkt(&testpkt, &xmt, 0, NULL));
  34
  35         EXPECT_EQ(LEAP_NOTINSYNC, PKT_LEAP(testpkt.li_vn_mode));
  36         EXPECT_EQ(NTP_VERSION, PKT_VERSION(testpkt.li_vn_mode));
  37         EXPECT_EQ(MODE_CLIENT, PKT_MODE(testpkt.li_vn_mode));
  38
  39         EXPECT_EQ(STRATUM_UNSPEC, PKT_TO_STRATUM(testpkt.stratum));
  40         EXPECT_EQ(8, testpkt.ppoll);
  41
  42         l_fp expected_xmt, actual_xmt;
  43         TVTOTS(&xmt, &expected_xmt);
  44         NTOHL_FP(&testpkt.xmt, &actual_xmt);
  45         EXPECT_TRUE(LfpEquality(expected_xmt, actual_xmt));
  46 }
  47
  48 TEST_F(mainTest, GenerateAuthenticatedPacket) {
  49         key testkey;
  50         testkey.next = NULL;
  51         testkey.key_id = 30;
  52         testkey.key_len = 9;
  53         memcpy(testkey.key_seq, "123456789", testkey.key_len);
  54         memcpy(testkey.type, "MD5", 3);
  55
  56         pkt testpkt;
  57
  58         timeval xmt;
  59         GETTIMEOFDAY(&xmt, NULL);
  60         xmt.tv_sec += JAN_1970;
  61
  62         const int EXPECTED_PKTLEN = LEN_PKT_NOMAC + MAX_MD5_LEN;
  63
  64         EXPECT_EQ(EXPECTED_PKTLEN,
  65                           generate_pkt(&testpkt, &xmt, testkey.key_id, &testkey));
  66
  67         EXPECT_EQ(LEAP_NOTINSYNC, PKT_LEAP(testpkt.li_vn_mode));
  68         EXPECT_EQ(NTP_VERSION, PKT_VERSION(testpkt.li_vn_mode));
  69         EXPECT_EQ(MODE_CLIENT, PKT_MODE(testpkt.li_vn_mode));
  70
  71         EXPECT_EQ(STRATUM_UNSPEC, PKT_TO_STRATUM(testpkt.stratum));
  72         EXPECT_EQ(8, testpkt.ppoll);
  73
  74         l_fp expected_xmt, actual_xmt;
  75         TVTOTS(&xmt, &expected_xmt);
  76         NTOHL_FP(&testpkt.xmt, &actual_xmt);
  77         EXPECT_TRUE(LfpEquality(expected_xmt, actual_xmt));
  78
  79         EXPECT_EQ(testkey.key_id, ntohl(testpkt.exten[0]));
  80
  81         char expected_mac[MAX_MD5_LEN];
  82         ASSERT_EQ(MAX_MD5_LEN - 4, // Remove the key_id, only keep the mac.
  83                           make_mac((char*)&testpkt, LEN_PKT_NOMAC, MAX_MD5_LEN, &testkey, expected_mac));
  84         EXPECT_TRUE(memcmp(expected_mac, (char*)&testpkt.exten[1], MAX_MD5_LEN -4) == 0);
  85 }
  86
  87 TEST_F(mainTest, OffsetCalculationPositiveOffset) {
  88         pkt rpkt;
  89
  90         rpkt.precision = -16; // 0,000015259
  91         rpkt.rootdelay = HTONS_FP(DTOUFP(0.125));
  92         rpkt.rootdisp = HTONS_FP(DTOUFP(0.25));
  93         // Synch Distance: (0.125+0.25)/2.0 == 0.1875
  94         l_fp reftime;
  95         get_systime(&reftime);
  96         HTONL_FP(&reftime, &rpkt.reftime);
  97
  98         l_fp tmp;
  99
 100         // T1 - Originate timestamp
 101         tmp.l_ui = 1000000000UL;
 102         tmp.l_uf = 0UL;
 103         HTONL_FP(&tmp, &rpkt.org);
 104
 105         // T2 - Receive timestamp
 106         tmp.l_ui = 1000000001UL;
 107         tmp.l_uf = 2147483648UL;
 108         HTONL_FP(&tmp, &rpkt.rec);
 109
 110         // T3 - Transmit timestamp
 111         tmp.l_ui = 1000000002UL;
 112         tmp.l_uf = 0UL;
 113         HTONL_FP(&tmp, &rpkt.xmt);
 114
 115         // T4 - Destination timestamp as standard timeval
 116         tmp.l_ui = 1000000001UL;
 117         tmp.l_uf = 0UL;
 118         timeval dst;
 119         TSTOTV(&tmp, &dst);
 120         dst.tv_sec -= JAN_1970;
 121
 122         double offset, precision, synch_distance;
 123         offset_calculation(&rpkt, LEN_PKT_NOMAC, &dst, &offset, &precision, &synch_distance);
 124
 125         EXPECT_DOUBLE_EQ(1.25, offset);
 126         EXPECT_DOUBLE_EQ(1. / ULOGTOD(16), precision);
 127         // 1.1250150000000001 ?
 128         EXPECT_DOUBLE_EQ(1.125015, synch_distance);
 129 }
 130
 131 TEST_F(mainTest, OffsetCalculationNegativeOffset) {
 132         pkt rpkt;
 133
 134         rpkt.precision = -1;
 135         rpkt.rootdelay = HTONS_FP(DTOUFP(0.5));
 136         rpkt.rootdisp = HTONS_FP(DTOUFP(0.5));
 137         // Synch Distance is (0.5+0.5)/2.0, or 0.5
 138         l_fp reftime;
 139         get_systime(&reftime);
 140         HTONL_FP(&reftime, &rpkt.reftime);
 141
 142         l_fp tmp;
 143
 144         // T1 - Originate timestamp
 145         tmp.l_ui = 1000000001UL;
 146         tmp.l_uf = 0UL;
 147         HTONL_FP(&tmp, &rpkt.org);
 148
 149         // T2 - Receive timestamp
 150         tmp.l_ui = 1000000000UL;
 151         tmp.l_uf = 2147483648UL;
 152         HTONL_FP(&tmp, &rpkt.rec);
 153
 154         // T3 - Transmit timestamp
 155         tmp.l_ui = 1000000001UL;
 156         tmp.l_uf = 2147483648UL;
 157         HTONL_FP(&tmp, &rpkt.xmt);
 158
 159         // T4 - Destination timestamp as standard timeval
 160         tmp.l_ui = 1000000003UL;
 161         tmp.l_uf = 0UL;
 162         timeval dst;
 163         TSTOTV(&tmp, &dst);
 164         dst.tv_sec -= JAN_1970;
 165
 166         double offset, precision, synch_distance;
 167         offset_calculation(&rpkt, LEN_PKT_NOMAC, &dst, &offset, &precision, &synch_distance);
 168
 169         EXPECT_DOUBLE_EQ(-1, offset);
 170         EXPECT_DOUBLE_EQ(1. / ULOGTOD(1), precision);
 171         EXPECT_DOUBLE_EQ(1.3333483333333334, synch_distance);
 172 }
 173
 174 TEST_F(mainTest, HandleUnusableServer) {
 175         pkt             rpkt;
 176         sockaddr_u      host;
 177         int             rpktl;
 178
 179         ZERO(rpkt);
 180         ZERO(host);
 181         rpktl = SERVER_UNUSEABLE;
 182         EXPECT_EQ(-1, handle_pkt(rpktl, &rpkt, &host, ""));
 183 }
 184
 185 TEST_F(mainTest, HandleUnusablePacket) {
 186         pkt             rpkt;
 187         sockaddr_u      host;
 188         int             rpktl;
 189
 190         ZERO(rpkt);
 191         ZERO(host);
 192         rpktl = PACKET_UNUSEABLE;
 193         EXPECT_EQ(1, handle_pkt(rpktl, &rpkt, &host, ""));
 194 }
 195
 196 TEST_F(mainTest, HandleServerAuthenticationFailure) {
 197         pkt             rpkt;
 198         sockaddr_u      host;
 199         int             rpktl;
 200
 201         ZERO(rpkt);
 202         ZERO(host);
 203         rpktl = SERVER_AUTH_FAIL;
 204         EXPECT_EQ(1, handle_pkt(rpktl, &rpkt, &host, ""));
 205 }
 206
 207 TEST_F(mainTest, HandleKodDemobilize) {
 208         const char *    HOSTNAME = "192.0.2.1";
 209         const char *    REASON = "DENY";
 210         pkt             rpkt;
 211         sockaddr_u      host;
 212         int             rpktl;
 213         kod_entry *     entry;
 214
 215         rpktl = KOD_DEMOBILIZE;
 216         ZERO(rpkt);
 217         memcpy(&rpkt.refid, REASON, 4);
 218         ZERO(host);
 219         host.sa4.sin_family = AF_INET;
 220         host.sa4.sin_addr.s_addr = inet_addr(HOSTNAME);
 221
 222         // Test that the KOD-entry is added to the database.
 223         kod_init_kod_db("/dev/null", TRUE);
 224
 225         EXPECT_EQ(1, handle_pkt(rpktl, &rpkt, &host, HOSTNAME));
 226
 227         ASSERT_EQ(1, search_entry(HOSTNAME, &entry));
 228         EXPECT_TRUE(memcmp(REASON, entry->type, 4) == 0);
 229 }
 230
 231 TEST_F(mainTest, HandleKodRate) {
 232         pkt             rpkt;
 233         sockaddr_u      host;
 234         int             rpktl;
 235
 236         ZERO(rpkt);
 237         ZERO(host);
 238         rpktl = KOD_RATE;
 239         EXPECT_EQ(1, handle_pkt(rpktl, &rpkt, &host, ""));
 240 }
 241
 242 TEST_F(mainTest, HandleCorrectPacket) {
 243         pkt             rpkt;
 244         sockaddr_u      host;
 245         int             rpktl;
 246         l_fp            now;
 247
 248         // We don't want our testing code to actually change the system clock.
 249         ASSERT_FALSE(ENABLED_OPT(STEP));
 250         ASSERT_FALSE(ENABLED_OPT(SLEW));
 251
 252         get_systime(&now);
 253         HTONL_FP(&now, &rpkt.reftime);
 254         HTONL_FP(&now, &rpkt.org);
 255         HTONL_FP(&now, &rpkt.rec);
 256         HTONL_FP(&now, &rpkt.xmt);
 257         rpktl = LEN_PKT_NOMAC;
 258         ZERO(host);
 259         AF(&host) = AF_INET;
 260
 261         EXPECT_EQ(0, handle_pkt(rpktl, &rpkt, &host, ""));
 262 }
 263
 264 /* packetHandling.cpp */