void destroy_pool(pool *p) {
if (p == NULL) {
return;
}
pr_alarms_block();
if (p->parent) {
if (p->parent->sub_pools == p) {
p->parent->sub_pools = p->sub_next;
}
if (p->sub_prev) {
p->sub_prev->sub_next = p->sub_next;
}
if (p->sub_next) {
p->sub_next->sub_prev = p->sub_prev;
}
}
clear_pool(p);
free_blocks(p->first, p->tag);
pr_alarms_unblock();
#ifdef PR_DEVEL_NO_POOL_FREELIST
/* If configured explicitly to do so, call free(3) on the freelist after
* a pool is destroyed. This can be useful for tracking down use-after-free
* and other memory issues using libraries such as dmalloc.
*/
pool_release_free_block_list();
#endif /* PR_EVEL_NO_POOL_FREELIST */
}
int main(int argc, char *argv[])
{
int retval = EXIT_FAILURE;
int opt;
int fd=-1;
int val=0;
int r;
while ((opt = getopt(argc, argv, "h")) != -1) {
switch (opt) {
case 'h':
usage();
exit(EXIT_SUCCESS);
break;
default: /* '?' */
usage();
exit(EXIT_FAILURE);
}
}
if (argc - optind < 1) {
fprintf(stderr, "Missing action\n");
usage();
exit(EXIT_FAILURE);
}
const char *action = argv[optind];
int action_argc = argc - optind;
char **action_argv = &argv[optind];
fd = open("/dev/urandom", O_RDWR);
if (fd == -1) {
perror("Failed to open /dev/urandom");
exit(EXIT_FAILURE);
}
if (strcmp(action, "get_entropy_cnt") == 0) {
retval = get_entropy_cnt(fd, action_argc, action_argv);
} else if (strcmp(action, "add_entropy_cnt") == 0) {
retval = add_entropy_cnt(fd, action_argc, action_argv);
} else if (strcmp(action, "add_entropy") == 0) {
retval = add_entropy(fd, action_argc, action_argv);
} else if (strcmp(action, "add_random") == 0) {
retval = add_random(fd, action_argc, action_argv);
} else if (strcmp(action, "clear_pool") == 0) {
retval = clear_pool(fd, action_argc, action_argv);
} else {
fprintf(stderr, "Unknown action: %s\n", action);
usage();
retval = EXIT_FAILURE;
}
close(fd);
return retval;
}
void destroy_pool(pool *p) {
if (p == NULL)
return;
pr_alarms_block();
if (p->parent) {
if (p->parent->sub_pools == p)
p->parent->sub_pools = p->sub_next;
if (p->sub_prev)
p->sub_prev->sub_next = p->sub_next;
if (p->sub_next)
p->sub_next->sub_prev = p->sub_prev;
}
clear_pool(p);
free_blocks(p->first, p->tag);
pr_alarms_unblock();
}
void test(void) {
card_t pool_cards[POOL_SIZE];
card_t* pool[POOL_SIZE];
card_t pool_cards2[POOL_SIZE];
card_t* pool2[POOL_SIZE];
card_t** compare_result;
int i, j;
byte_t random_size;
printf("\nresolve tests:\n\n");
printf("\nrandom pools:\n");
for (i = 0; i < CASES_COUNT; ++i) {
clear_pool(pool);
randomize_pool(pool, pool_cards);
printf("pool: "); print_pool(pool, POOL_SIZE);
resolve_pool(pool, POOL_SIZE);
}
printf("\npre-defined pools:\n\n");
for (i = 0; i < (sizeof(resolve_data)/(sizeof(char*))) / POOL_SIZE; i++) {
for (j = 0; j < POOL_SIZE; ++j) {
card_fill(pool_cards[j], resolve_data[i][j]);
pool[j] = &pool_cards[j];
}
printf("pool: "); print_pool(pool, POOL_SIZE);
sort_by_rank(pool, POOL_SIZE);
printf(" sorted: "); print_pool(pool, POOL_SIZE);
resolve_pool(pool, POOL_SIZE);
}
printf("\ncomparison tests:\n\n");
for (i = 0; i < CASES_COUNT; ++i) {
clear_pool(pool);
randomize_pool(pool, pool_cards);
printf("pool1: "); print_pool(pool, POOL_SIZE);
resolve_pool(pool, POOL_SIZE);
clear_pool(pool2);
randomize_pool(pool2, pool_cards2);
printf("pool2: "); print_pool(pool2, POOL_SIZE);
resolve_pool(pool2, POOL_SIZE);
compare_result = pok_compare(pool, pool2);
if (compare_result == pool)
printf("pool 1 is stronger\n");
else if (compare_result == pool2)
printf("pool 2 is stronger\n");
else {
printf("tie!\n");
}
}
printf("\nincomplete pools:\n\n");
for (i = 0; i < CASES_COUNT; ++i) {
random_size = rand() % POOL_SIZE + 1;
clear_pool(pool);
randomize_pool(pool, pool_cards);
printf("pool: "); print_pool(pool, random_size);
resolve_pool(pool, random_size);
}
/*while(1) {
clear_pool(pool);
randomize_pool(pool, pool_cards);
result = pok_resolve(pool);
sort_by_rank(pool);
if (result.kind == STRAIGHTF) {
print_pool(pool, POOL_SIZE);
resolve_pool(pool);
}
}*/
}
static void clear_queue(struct interrupt_queue *_q)
{
_q->first = NULL;
clear_pool(&_q->pool);
}
static void clear_queue(void)
{
q.first = NULL;
clear_pool(&q.pool);
}
static void clear_queue(usf_state_t * state)
{
state->q.first = NULL;
clear_pool(&state->q.pool);
}