int main() { uint32_t i, irecvd, idiff; ut_connection utc; ut_init(&utc); for (i=0; i < 1000; i++) { irecvd = ut_next_index(&utc); idiff = i - irecvd; printf("%lu\t%lu\t%d\n", i, irecvd, idiff); } return 0; }
err_status_t test_rdb_db() { rdb_t rdb; uint32_t idx, ircvd; ut_connection utc; err_status_t err; if (rdb_init(&rdb) != err_status_ok) { printf("rdb_init failed\n"); return err_status_init_fail; } /* test sequential insertion */ for (idx=0; idx < num_trials; idx++) { err = rdb_check_add(&rdb, idx); if (err) return err; } /* test for false positives */ for (idx=0; idx < num_trials; idx++) { err = rdb_check_expect_failure(&rdb, idx); if (err) return err; } /* re-initialize */ if (rdb_init(&rdb) != err_status_ok) { printf("rdb_init failed\n"); return err_status_fail; } /* test non-sequential insertion */ ut_init(&utc); for (idx=0; idx < num_trials; idx++) { ircvd = ut_next_index(&utc); err = rdb_check_unordered(&rdb, ircvd); if (err) return err; } return err_status_ok; }
srtp_err_status_t test_rdb_db() { srtp_rdb_t rdb; uint32_t idx, ircvd; ut_connection utc; srtp_err_status_t err; if (srtp_rdb_init(&rdb) != srtp_err_status_ok) { printf("rdb_init failed\n"); return srtp_err_status_init_fail; } /* test sequential insertion */ for (idx = 0; idx < num_trials; idx++) { err = rdb_check_add(&rdb, idx); if (err) return err; } /* test for false positives */ for (idx = 0; idx < num_trials; idx++) { err = rdb_check_expect_failure(&rdb, idx); if (err) return err; } /* re-initialize */ if (srtp_rdb_init(&rdb) != srtp_err_status_ok) { printf("rdb_init failed\n"); return srtp_err_status_fail; } /* test non-sequential insertion */ ut_init(&utc); for (idx = 0; idx < num_trials; idx++) { ircvd = ut_next_index(&utc); err = rdb_check_add_unordered(&rdb, ircvd); if (err) return err; err = rdb_check_expect_failure(&rdb, ircvd); if (err) return err; } /* re-initialize */ if (srtp_rdb_init(&rdb) != srtp_err_status_ok) { printf("rdb_init failed\n"); return srtp_err_status_fail; } /* test insertion with large gaps */ for (idx = 0, ircvd = 0; idx < num_trials; idx++, ircvd += (1 << (srtp_cipher_rand_u32_for_tests() % 10))) { err = rdb_check_add(&rdb, ircvd); if (err) return err; err = rdb_check_expect_failure(&rdb, ircvd); if (err) return err; } /* re-initialize */ if (srtp_rdb_init(&rdb) != srtp_err_status_ok) { printf("rdb_init failed\n"); return srtp_err_status_fail; } /* test loss of first 513 packets */ for (idx = 0; idx < num_trials; idx++) { err = rdb_check_add(&rdb, idx + 513); if (err) return err; } /* test for false positives */ for (idx = 0; idx < num_trials + 513; idx++) { err = rdb_check_expect_failure(&rdb, idx); if (err) return err; } /* test for key expired */ if (srtp_rdb_init(&rdb) != srtp_err_status_ok) { printf("rdb_init failed\n"); return srtp_err_status_fail; } rdb.window_start = 0x7ffffffe; if (srtp_rdb_increment(&rdb) != srtp_err_status_ok) { printf("srtp_rdb_increment of 0x7ffffffe failed\n"); return srtp_err_status_fail; } if (srtp_rdb_get_value(&rdb) != 0x7fffffff) { printf("rdb valiue was not 0x7fffffff\n"); return srtp_err_status_fail; } if (srtp_rdb_increment(&rdb) != srtp_err_status_key_expired) { printf("srtp_rdb_increment of 0x7fffffff did not return " "srtp_err_status_key_expired\n"); return srtp_err_status_fail; } if (srtp_rdb_get_value(&rdb) != 0x7fffffff) { printf("rdb valiue was not 0x7fffffff\n"); return srtp_err_status_fail; } return srtp_err_status_ok; }
err_status_t test_replay_dbx(int num_trials, unsigned long ws) { rdbx_t rdbx; uint32_t idx, ircvd; ut_connection utc; err_status_t status; int num_fp_trials; status = rdbx_init(&rdbx, ws); if (status) { printf("replay_init failed with error code %d\n", status); exit(1); } /* * test sequential insertion */ printf("\ttesting sequential insertion..."); for (idx=0; idx < (uint32_t)num_trials; idx++) { status = rdbx_check_add(&rdbx, idx); if (status) return status; } printf("passed\n"); /* * test for false positives by checking all of the index * values which we've just added * * note that we limit the number of trials here, since allowing the * rollover counter to roll over would defeat this test */ num_fp_trials = num_trials % 0x10000; if (num_fp_trials == 0) { printf("warning: no false positive tests performed\n"); } printf("\ttesting for false positives..."); for (idx=0; idx < (uint32_t)num_fp_trials; idx++) { status = rdbx_check_expect_failure(&rdbx, idx); if (status) return status; } printf("passed\n"); /* re-initialize */ rdbx_uninit(&rdbx); if (rdbx_init(&rdbx, ws) != err_status_ok) { printf("replay_init failed\n"); return err_status_init_fail; } /* * test non-sequential insertion * * this test covers only fase negatives, since the values returned * by ut_next_index(...) are distinct */ ut_init(&utc); printf("\ttesting non-sequential insertion..."); for (idx=0; idx < (uint32_t)num_trials; idx++) { ircvd = ut_next_index(&utc); status = rdbx_check_unordered(&rdbx, ircvd); if (status) return status; } printf("passed\n"); /* * test a replay condition close to zero. */ rdbx_uninit(&rdbx); if (rdbx_init(&rdbx, ws) != err_status_ok) { printf("replay_init failed\n"); return err_status_init_fail; } printf("\ttesting replay close to zero..."); status = rdbx_check_add(&rdbx, 1); if (status) return status; status = rdbx_check_expect_failure(&rdbx, 64500); if (status) return status; status = rdbx_check_add(&rdbx, 2); if (status) return status; printf("passed\n"); rdbx_uninit(&rdbx); return err_status_ok; }
srtp_err_status_t roc_test(int num_trials) { srtp_xtd_seq_num_t local, est, ref; ut_connection utc; int i, num_bad_est = 0; int delta; uint32_t ircvd; double failure_rate; srtp_index_init(&local); srtp_index_init(&ref); srtp_index_init(&est); printf("\n\ttesting sequential insertion..."); for (i=0; i < 2048; i++) { delta = srtp_index_guess(&local, &est, (uint16_t) ref); #if ROC_VERBOSE printf("%lld, %lld, %d\n", ref, est, i); #endif if (ref != est) { #if ROC_VERBOSE printf(" *bad estimate*\n"); #endif ++num_bad_est; } srtp_index_advance(&ref, 1); } failure_rate = (double) num_bad_est / num_trials; if (failure_rate > 0.01) { printf("error: failure rate too high (%d bad estimates in %d trials)\n", num_bad_est, num_trials); return srtp_err_status_algo_fail; } printf("done\n"); printf("\ttesting non-sequential insertion..."); srtp_index_init(&local); srtp_index_init(&ref); srtp_index_init(&est); ut_init(&utc); for (i=0; i < num_trials; i++) { /* get next seq num from unreliable transport simulator */ ircvd = ut_next_index(&utc); /* set ref to value of ircvd */ ref = ircvd; /* estimate index based on low bits of ircvd */ delta = srtp_index_guess(&local, &est, (uint16_t) ref); #if ROC_VERBOSE printf("ref: %lld, local: %lld, est: %lld, ircvd: %d, delta: %d\n", ref, local, est, ircvd, delta); #endif if (local + delta != est) { printf(" *bad delta*: local %llu + delta %d != est %llu\n", (unsigned long long)local, delta, (unsigned long long)est); return srtp_err_status_algo_fail; } /* now update local srtp_xtd_seq_num_t as necessary */ if (delta > 0) srtp_index_advance(&local, delta); if (ref != est) { #if ROC_VERBOSE printf(" *bad estimate*\n"); #endif /* record failure event */ ++num_bad_est; /* reset local value to correct value */ local = ref; } } failure_rate = (double) num_bad_est / num_trials; if (failure_rate > 0.01) { printf("error: failure rate too high (%d bad estimates in %d trials)\n", num_bad_est, num_trials); return srtp_err_status_algo_fail; } printf("done\n"); return srtp_err_status_ok; }