void pqueue_free(Priority_Queue *Q, int free_keys) {
int i = 0;
if(free_keys) { for(;i < pqueue_size(Q); i++) { free(((void **)Q->arr[i])[1]); } }
for(i = 0; i < pqueue_size(Q); i++) {
free(((void **)Q->arr[i])[0]); //all the priorities (int *)
free((void **)Q->arr[i]);
}
free(Q->arr);
Q->arr = NULL;
Q->size = 0;
Q->h_size = 0;
}
int get_parcel(PQueue *parcels, Parcel *parcel)
{
Parcel *data;
if (pqueue_size(parcels) == 0)
{
/* Return that there are no parcels. */
return -1;
}
else
{
if (pqueue_extract(parcels, (void **)data) != 0)
{
/* Return that a parcel could not be retrieved. */
return -1;
}
else
{
/* Pass back the highest-priority parcel. */
memcpy(parcel, data, sizeof(Parcel));
free(data);
}
}
return 0;
}
static void
log_state (GstDtlsConnection * self, const gchar * str)
{
GstDtlsConnectionPrivate *priv = self->priv;
guint states = 0;
states |= (! !SSL_is_init_finished (priv->ssl) << 0);
states |= (! !SSL_in_init (priv->ssl) << 4);
states |= (! !SSL_in_before (priv->ssl) << 8);
states |= (! !SSL_in_connect_init (priv->ssl) << 12);
states |= (! !SSL_in_accept_init (priv->ssl) << 16);
states |= (! !SSL_want_write (priv->ssl) << 20);
states |= (! !SSL_want_read (priv->ssl) << 24);
#if OPENSSL_VERSION_NUMBER < 0x10100001L
GST_LOG_OBJECT (self, "%s: role=%s buf=(%d,%p:%d/%d) %x|%x %s",
str,
priv->is_client ? "client" : "server",
pqueue_size (priv->ssl->d1->sent_messages),
priv->bio_buffer,
priv->bio_buffer_offset,
priv->bio_buffer_len,
states, SSL_get_state (priv->ssl), SSL_state_string_long (priv->ssl));
#else
GST_LOG_OBJECT (self, "%s: role=%s buf=(%p:%d/%d) %x|%x %s",
str,
priv->is_client ? "client" : "server",
priv->bio_buffer,
priv->bio_buffer_offset,
priv->bio_buffer_len,
states, SSL_get_state (priv->ssl), SSL_state_string_long (priv->ssl));
#endif
}
int dtls1_buffer_record(SSL *s, record_pqueue *queue, unsigned char *priority)
{
DTLS1_RECORD_DATA *rdata;
pitem *item;
/* Limit the size of the queue to prevent DOS attacks */
if (pqueue_size(queue->q) >= 100)
return 0;
rdata = OPENSSL_malloc(sizeof(*rdata));
item = pitem_new(priority, rdata);
if (rdata == NULL || item == NULL) {
OPENSSL_free(rdata);
pitem_free(item);
SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);
return -1;
}
rdata->packet = s->rlayer.packet;
rdata->packet_length = s->rlayer.packet_length;
memcpy(&(rdata->rbuf), &s->rlayer.rbuf, sizeof(SSL3_BUFFER));
memcpy(&(rdata->rrec), &s->rlayer.rrec, sizeof(SSL3_RECORD));
item->data = rdata;
#ifndef OPENSSL_NO_SCTP
/* Store bio_dgram_sctp_rcvinfo struct */
if (BIO_dgram_is_sctp(SSL_get_rbio(s)) &&
(SSL_get_state(s) == TLS_ST_SR_FINISHED
|| SSL_get_state(s) == TLS_ST_CR_FINISHED)) {
BIO_ctrl(SSL_get_rbio(s), BIO_CTRL_DGRAM_SCTP_GET_RCVINFO,
sizeof(rdata->recordinfo), &rdata->recordinfo);
}
#endif
s->rlayer.packet = NULL;
s->rlayer.packet_length = 0;
memset(&s->rlayer.rbuf, 0, sizeof(s->rlayer.rbuf));
memset(&s->rlayer.rrec, 0, sizeof(s->rlayer.rrec));
if (!ssl3_setup_buffers(s)) {
SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);
OPENSSL_free(rdata->rbuf.buf);
OPENSSL_free(rdata);
pitem_free(item);
return (-1);
}
/* insert should not fail, since duplicates are dropped */
if (pqueue_insert(queue->q, item) == NULL) {
SSLerr(SSL_F_DTLS1_BUFFER_RECORD, ERR_R_INTERNAL_ERROR);
OPENSSL_free(rdata->rbuf.buf);
OPENSSL_free(rdata);
pitem_free(item);
return (-1);
}
return (1);
}
static void print_pqueue(PQueue *pqueue) {
int i;
/*****************************************************************************
* *
* Display the priority queue in level order. *
* *
*****************************************************************************/
fprintf(stdout, "Priority queue size is %d\n", pqueue_size(pqueue));
for (i = 0; i < pqueue_size(pqueue); i++)
fprintf(stdout, "Node=%03d\n", *(int *)pqueue->tree[i]);
return;
}
END_TEST
START_TEST(test_pqueue_enqueue)
{
PriorityQueue *pq = pqueue_new();
ck_assert_msg(pq != NULL, "Priority queue should not be NULL.");
pqueue_enqueue(pq, tree_new());
ck_assert_int_eq(pqueue_size(pq), 1);
pqueue_enqueue(pq, tree_new());
ck_assert_int_eq(pqueue_size(pq), 2);
pqueue_enqueue(pq, tree_new());
ck_assert_int_eq(pqueue_size(pq), 3);
pqueue_enqueue(pq, tree_new());
ck_assert_int_eq(pqueue_size(pq), 4);
pqueue_free(pq);
}
//this returns the priority --> useful, but how to do remove well then? should i
//do get priority? and then revert search to give pos in array?
int pqueue_search(Priority_Queue *Q, void *key, int comparator(void *data1, void *data2)) {
int i = 0;
for(;i < pqueue_size(Q); i++) {
if(comparator(((void **)Q->arr[i])[1], key) == 0) {
return *(int *)((void **)Q->arr[i])[0];
}
}
return -1;
}
static struct proc* pdequeue()
{
struct proc *p;
if(pqueue_size() == 0) return 0;
else{
p = pheap_pop();
return p;
}
}
static int trivial() {
pqueue q = pqueue_new();
if (q == NULL) {
return 0;
}
int32_t data = 0xdeadbeef;
uint8_t priority[8] = {0};
pitem *item = pitem_new(priority, &data);
if (item == NULL ||
pqueue_insert(q, item) != item ||
pqueue_size(q) != 1 ||
pqueue_peek(q) != item ||
pqueue_pop(q) != item ||
pqueue_size(q) != 0 ||
pqueue_pop(q) != NULL) {
return 0;
}
pitem_free(item);
pqueue_free(q);
return 1;
}
void squeue_destroy(squeue_t *q, int flags)
{
unsigned int i;
if (!q || pqueue_size(q) < 1)
return;
/*
* Using two separate loops is a lot faster than
* doing 1 cmp+branch for every queued item
*/
if (flags & SQUEUE_FREE_DATA) {
for (i = 0; i < pqueue_size(q); i++) {
free(((squeue_event *)q->d[i + 1])->data);
free(q->d[i + 1]);
}
} else {
for (i = 0; i < pqueue_size(q); i++) {
free(q->d[i + 1]);
}
}
pqueue_free(q);
}
int main(int argc, char **argv) {
PQueue pqueue;
void *data;
int intval[30],
i;
/*****************************************************************************
* *
* Initialize the priority queue. *
* *
*****************************************************************************/
pqueue_init(&pqueue, compare_int, NULL);
/*****************************************************************************
* *
* Perform some priority queue operations. *
* *
*****************************************************************************/
i = 0;
intval[i] = 5;
fprintf(stdout, "Inserting %03d\n", intval[i]);
if (pqueue_insert(&pqueue, &intval[i]) != 0)
return 1;
print_pqueue(&pqueue);
i++;
intval[i] = 10;
fprintf(stdout, "Inserting %03d\n", intval[i]);
if (pqueue_insert(&pqueue, &intval[i]) != 0)
return 1;
print_pqueue(&pqueue);
i++;
intval[i] = 20;
fprintf(stdout, "Inserting %03d\n", intval[i]);
if (pqueue_insert(&pqueue, &intval[i]) != 0)
return 1;
print_pqueue(&pqueue);
i++;
intval[i] = 1;
fprintf(stdout, "Inserting %03d\n", intval[i]);
if (pqueue_insert(&pqueue, &intval[i]) != 0)
return 1;
print_pqueue(&pqueue);
i++;
intval[i] = 25;
fprintf(stdout, "Inserting %03d\n", intval[i]);
if (pqueue_insert(&pqueue, &intval[i]) != 0)
return 1;
print_pqueue(&pqueue);
i++;
intval[i] = 22;
fprintf(stdout, "Inserting %03d\n", intval[i]);
if (pqueue_insert(&pqueue, &intval[i]) != 0)
return 1;
print_pqueue(&pqueue);
i++;
intval[i] = 12;
fprintf(stdout, "Inserting %03d\n", intval[i]);
if (pqueue_insert(&pqueue, &intval[i]) != 0)
return 1;
print_pqueue(&pqueue);
i++;
while (pqueue_size(&pqueue) > 0) {
fprintf(stdout, "Peeking at the highest priority element..Value=%03d\n",
*(int *)pqueue_peek(&pqueue));
if (pqueue_extract(&pqueue, (void **)&data) != 0)
return 1;
fprintf(stdout, "Extracting %03d\n", *(int *)data);
print_pqueue(&pqueue);
}
/*****************************************************************************
* *
* Destroy the priority queue. *
* *
*****************************************************************************/
fprintf(stdout, "Destroying the pqueue\n");
pqueue_destroy(&pqueue);
return 0;
}
END_TEST
START_TEST(test_pqueue_dequeue)
{
PriorityQueue *pq = pqueue_new();
ck_assert_msg(pq != NULL, "Priority queue should not be NULL.");
TreeNode *t = tree_new();
t->type = LEAF;
t->freq.v = 10;
t->freq.c = 'c';
t->left = NULL;
t->right = NULL;
pqueue_enqueue(pq, t);
ck_assert_int_eq(pqueue_size(pq), 1);
t = tree_new();
t->type = LEAF;
t->freq.v = 15;
t->freq.c = 'x';
t->left = NULL;
t->right = NULL;
pqueue_enqueue(pq, t);
ck_assert_int_eq(pqueue_size(pq), 2);
t = tree_new();
t->type = LEAF;
t->freq.v = 9;
t->freq.c = 'q';
t->left = NULL;
t->right = NULL;
pqueue_enqueue(pq, t);
ck_assert_int_eq(pqueue_size(pq), 3);
t = tree_new();
t->type = LEAF;
t->freq.v = 999;
t->freq.c = 'a';
t->left = NULL;
t->right = NULL;
pqueue_enqueue(pq, t);
ck_assert_int_eq(pqueue_size(pq), 4);
t = pqueue_dequeue(pq);
ck_assert_int_eq(t->freq.c, 'q');
ck_assert_int_eq(pqueue_size(pq), 3);
free(t);
t = pqueue_dequeue(pq);
ck_assert_int_eq(t->freq.c, 'c');
ck_assert_int_eq(pqueue_size(pq), 2);
free(t);
t = pqueue_dequeue(pq);
ck_assert_int_eq(t->freq.c, 'x');
ck_assert_int_eq(pqueue_size(pq), 1);
free(t);
t = pqueue_dequeue(pq);
ck_assert_int_eq(t->freq.c, 'a');
ck_assert_int_eq(pqueue_size(pq), 0);
free(t);
pqueue_free(pq);
}
void pqueue_walk(Priority_Queue *Q, void (*f)(void *key)) {
int i = 0;
for(; i < pqueue_size(Q); i++) { f(((void **)Q->arr[i])[1]); }
}
static int penqueue(struct proc *p)
{
if(pqueue_size() == PQUEUE_MAX) return -1;
pheap_push(p);
return 0;
}
static int build_tree(int *freqs, BiTree **tree) {
BiTree *init,
*merge,
*left,
*right;
PQueue pqueue;
HuffNode *data;
int size,
c;
/*****************************************************************************
* *
* Initialize the priority queue of binary trees. *
* *
*****************************************************************************/
*tree = NULL;
pqueue_init(&pqueue, compare_freq, destroy_tree);
for (c = 0; c <= UCHAR_MAX; c++) {
if (freqs[c] != 0) {
/***********************************************************************
* *
* Set up a binary tree for the current symbol and its frequency. *
* *
***********************************************************************/
if ((init = (BiTree *)malloc(sizeof(BiTree))) == NULL) {
pqueue_destroy(&pqueue);
return -1;
}
bitree_init(init, free);
if ((data = (HuffNode *)malloc(sizeof(HuffNode))) == NULL) {
pqueue_destroy(&pqueue);
return -1;
}
data->symbol = c;
data->freq = freqs[c];
if (bitree_ins_left(init, NULL, data) != 0) {
free(data);
bitree_destroy(init);
free(init);
pqueue_destroy(&pqueue);
return -1;
}
/***********************************************************************
* *
* Insert the binary tree into the priority queue. *
* *
***********************************************************************/
if (pqueue_insert(&pqueue, init) != 0) {
bitree_destroy(init);
free(init);
pqueue_destroy(&pqueue);
return -1;
}
}
}
/*****************************************************************************
* *
* Build a Huffman tree by merging trees in the priority queue. *
* *
*****************************************************************************/
size = pqueue_size(&pqueue);
for (c = 1; c <= size - 1; c++) {
/**************************************************************************
* *
* Allocate storage for the next merged tree. *
* *
**************************************************************************/
if ((merge = (BiTree *)malloc(sizeof(BiTree))) == NULL) {
pqueue_destroy(&pqueue);
return -1;
}
/**************************************************************************
* *
* Extract the two trees whose root nodes have the smallest frequencies. *
* *
**************************************************************************/
if (pqueue_extract(&pqueue, (void **)&left) != 0) {
pqueue_destroy(&pqueue);
free(merge);
return -1;
}
if (pqueue_extract(&pqueue, (void **)&right) != 0) {
pqueue_destroy(&pqueue);
free(merge);
return -1;
}
/**************************************************************************
* *
* Allocate storage for the data in the root node of the merged tree. *
* *
**************************************************************************/
if ((data = (HuffNode *)malloc(sizeof(HuffNode))) == NULL) {
pqueue_destroy(&pqueue);
free(merge);
return -1;
}
memset(data, 0, sizeof(HuffNode));
/**************************************************************************
* *
* Sum the frequencies in the root nodes of the trees being merged. *
* *
**************************************************************************/
data->freq = ((HuffNode *)bitree_data(bitree_root(left)))->freq +
((HuffNode *)bitree_data(bitree_root(right)))->freq;
/**************************************************************************
* *
* Merge the two trees. *
* *
**************************************************************************/
if (bitree_merge(merge, left, right, data) != 0) {
pqueue_destroy(&pqueue);
free(merge);
return -1;
}
/**************************************************************************
* *
* Insert the merged tree into the priority queue and free the others. *
* *
**************************************************************************/
if (pqueue_insert(&pqueue, merge) != 0) {
pqueue_destroy(&pqueue);
bitree_destroy(merge);
free(merge);
return -1;
}
free(left);
free(right);
}
/*****************************************************************************
* *
* The last tree in the priority queue is the Huffman tree. *
* *
*****************************************************************************/
if (pqueue_extract(&pqueue, (void **)tree) != 0) {
pqueue_destroy(&pqueue);
return -1;
}
else {
pqueue_destroy(&pqueue);
}
return 0;
}
unsigned int squeue_size(squeue_t *q)
{
if (!q)
return 0;
return pqueue_size(q);
}
static int fixed_random() {
/* Random order of 10 elements, chosen by
* random.choice(list(itertools.permutations(range(10)))) */
int ordering[NUM_ITEMS] = {9, 6, 3, 4, 0, 2, 7, 1, 8, 5};
int i;
pqueue q = pqueue_new();
uint8_t priority[8] = {0};
piterator iter;
pitem *curr, *item;
if (q == NULL) {
return 0;
}
/* Insert the elements */
for (i = 0; i < NUM_ITEMS; i++) {
priority[7] = ordering[i];
item = pitem_new(priority, &ordering[i]);
if (pqueue_insert(q, item) != item) {
return 0;
}
}
/* Insert the elements again. This inserts duplicates and should
* fail. */
for (i = 0; i < NUM_ITEMS; i++) {
priority[7] = ordering[i];
item = pitem_new(priority, &ordering[i]);
if (pqueue_insert(q, item) != NULL) {
return 0;
}
pitem_free(item);
}
if (pqueue_size(q) != NUM_ITEMS) {
return 0;
}
/* Iterate over the elements. */
iter = pqueue_iterator(q);
curr = pqueue_next(&iter);
if (curr == NULL) {
return 0;
}
while (1) {
pitem *next = pqueue_next(&iter);
int *curr_data, *next_data;
if (next == NULL) {
break;
}
curr_data = (int*)curr->data;
next_data = (int*)next->data;
if (*curr_data >= *next_data) {
return 0;
}
curr = next;
}
pqueue_free(q);
return 1;
}
