/*
** Load the record ID rid and up to N-1 closest descendants into
** the "ok" table.
*/
void compute_descendants(int rid, int N) {
Bag seen;
PQueue queue;
Stmt ins;
Stmt q;
bag_init(&seen);
pqueue_init(&queue);
bag_insert(&seen, rid);
pqueue_insert(&queue, rid, 0.0, 0);
db_prepare(&ins, "INSERT OR IGNORE INTO ok VALUES(:rid)");
db_prepare(&q, "SELECT cid, mtime FROM plink WHERE pid=:rid");
while( (N--)>0 && (rid = pqueue_extract(&queue, 0))!=0 ) {
db_bind_int(&ins, ":rid", rid);
db_step(&ins);
db_reset(&ins);
db_bind_int(&q, ":rid", rid);
while( db_step(&q)==SQLITE_ROW ) {
int pid = db_column_int(&q, 0);
double mtime = db_column_double(&q, 1);
if( bag_insert(&seen, pid) ) {
pqueue_insert(&queue, pid, mtime, 0);
}
}
db_reset(&q);
}
bag_clear(&seen);
pqueue_clear(&queue);
db_finalize(&ins);
db_finalize(&q);
}
int
main(void)
{
pitem *item;
pqueue pq;
pq = pqueue_new();
item = pitem_new(3, NULL);
pqueue_insert(pq, item);
item = pitem_new(1, NULL);
pqueue_insert(pq, item);
item = pitem_new(2, NULL);
pqueue_insert(pq, item);
item = pqueue_find(pq, 1);
fprintf(stderr, "found %ld\n", item->priority);
item = pqueue_find(pq, 2);
fprintf(stderr, "found %ld\n", item->priority);
item = pqueue_find(pq, 3);
fprintf(stderr, "found %ld\n", item ? item->priority: 0);
pqueue_print(pq);
for(item = pqueue_pop(pq); item != NULL; item = pqueue_pop(pq))
pitem_free(item);
pqueue_free(pq);
return 0;
}
int main(void)
{
int i;
int p;
pqueue_t *pq;
node_t *ns;
node_t *n;
/* We will need (N + 1) slots in "pris" vector. Extra one slot for spare
* usages. */
pris = malloc(5 * sizeof(int *));
for (i = 0; i < 5; i++)
pris[i] = malloc(2 * sizeof(int));
pris[0][0] = 4; pris[0][1] = 2;
pris[1][0] = 3; pris[1][1] = 7;
pris[2][0] = 3; pris[2][1] = 1;
pris[3][0] = 5; pris[3][1] = 6;
p = 4; /* Initialize spare slot. */
pq = pqueue_init(10, cmp_pri, get_pri, set_pri, get_pos, set_pos);
ns = malloc(4 * sizeof(node_t));
ns[0].pri = 0; ns[0].val = 0; pqueue_insert(pq, &ns[0]);
ns[1].pri = 1; ns[0].val = 1; pqueue_insert(pq, &ns[1]);
ns[2].pri = 2; ns[0].val = 2; pqueue_insert(pq, &ns[2]);
ns[3].pri = 3; ns[0].val = 3; pqueue_insert(pq, &ns[3]);
printf("initial:\n"); pqueue_print(pq, stdout, pr_node);
n = pqueue_pop(pq);
printf("[pop] pri: %d, val: %d, real-pri: [%d %d]\n",
n->pri, n->val, pris[n->pri][0], pris[n->pri][1]);
printf("after first pop:\n"); pqueue_print(pq, stdout, pr_node);
pris[p][0] = 3; pris[p][1] = 0;
pqueue_change_priority(pq, p, &ns[3]); /* 3: (5,6) -> (3,0) */
p = 3; /* Move spare slot to 3. */
printf("after 3: (5,6) -> (3,0):\n"); pqueue_print(pq, stdout, pr_node);
pris[p][0] = 3; pris[p][1] = -1;
pqueue_change_priority(pq, p, &ns[0]); /* 0: (4,2) -> (3,-1) */
p = 0; /* Move spare slot to 0. */
printf("after 0: (4,2) -> (3,-1):\n"); pqueue_print(pq, stdout, pr_node);
while ((n = pqueue_pop(pq)))
printf("[pop] pri: %d, val: %d, real-pri: [%d %d]\n",
n->pri, n->val, pris[n->pri][0], pris[n->pri][1]);
pqueue_free(pq);
free(ns);
free(pris);
return 0;
}
void test_pqueue_is_empty_after_last_element_is_removed(void)
{
setup();
pqueue_insert(pqueue, (void *) 0UL);
pqueue_insert(pqueue, (void *) 1UL);
pqueue_remove_top(pqueue);
pqueue_remove_top(pqueue);
assert_true(pqueue_is_empty(pqueue));
teardown();
}
void test_pqueue_returns_highest_priority_element_first(void)
{
setup();
pqueue_insert(pqueue, (void *) 2UL);
pqueue_insert(pqueue, (void *) 1UL);
pqueue_insert(pqueue, (void *) 0UL);
assert_ptr_equals((void *) 0UL, pqueue_remove_top(pqueue));
assert_ptr_equals((void *) 1UL, pqueue_remove_top(pqueue));
assert_ptr_equals((void *) 2UL, pqueue_remove_top(pqueue));
teardown();
}
squeue_event *squeue_add_tv(squeue_t *q, struct timeval *tv, void *data)
{
squeue_event *evt;
if (!q)
return NULL;
evt = calloc(1, sizeof(*evt));
if (!evt)
return NULL;
/* we can't schedule events in the past */
if (tv->tv_sec < time(NULL))
tv->tv_sec = time(NULL);
evt->when.tv_sec = tv->tv_sec;
if (sizeof(evt->when.tv_sec) > 4) {
/*
* Only use bottom sizeof(pqueue_pri_t)-SQ_BITS bits on
* 64-bit systems, or we may get entries at the head
* of the queue are actually scheduled to run several
* hundred thousand years from now.
*/
evt->when.tv_sec &= (1ULL << ((sizeof(pqueue_pri_t) * 8) - SQ_BITS)) - 1;
}
evt->when.tv_usec = tv->tv_usec;
evt->data = data;
evt->pri = evt_compute_pri(&evt->when);
if (!pqueue_insert(q, evt))
return evt;
free(evt);
return NULL;
}
int update(float value, float* time, int i)
/* update gridpoint i with new value and modify wave front */
{
int its;
#ifdef _OPENMP
its = omp_get_thread_num();
#else
its = 0;
#endif
/* only update when smaller than current value */
if (value < time[i]) {
time[i] = value;
if (in[its][i] == SF_OUT) {
in[its][i] = SF_FRONT;
pqueue_insert(time+i);
return 1;
} else {
assert(in[its][i] == SF_FRONT);
pqueue_update(i);
}
}
return 0;
}
} T_END_TEST
T_TEST(t_pqueue_alt_insert) {
struct pqueue* q = pqueue_create(comp);
int i;
int num = 10;
T_ASSERT(q);
for (i = 0; i < num; i++) {
T_ASSERT(0 == pqueue_insert(q, (void*)((i % 2) ? i : num - i - (num % 2 ? 1 : 2))));
}
T_ASSERT(!pqueue_is_empty(q));
i = 0;
while (!pqueue_is_empty(q)) {
T_ASSERT(i == (int)pqueue_peek(q));
T_ASSERT(i == (int)pqueue_pop(q));
i++;
}
T_ASSERT(i == num);
pqueue_destroy(q);
} T_END_TEST
squeue_event *squeue_add_tv(squeue_t *q, struct timeval *tv, void *data)
{
squeue_event *evt;
if (!q)
return NULL;
evt = calloc(1, sizeof(*evt));
if (!evt)
return NULL;
/* we can't schedule events in the past */
if (tv->tv_sec < time(NULL))
tv->tv_sec = time(NULL);
evt->when.tv_sec = tv->tv_sec;
evt->when.tv_usec = tv->tv_usec;
evt->data = data;
evt->pri = evt_compute_pri(&evt->when);
if (!pqueue_insert(q, evt))
return evt;
return NULL;
}
static int
dtls1_buffer_handshake_fragment(SSL *s, struct hm_header_st* msg_hdr)
{
hm_fragment *frag = NULL;
pitem *item = NULL;
PQ_64BIT seq64;
frag = dtls1_hm_fragment_new(msg_hdr->frag_len);
if ( frag == NULL)
goto err;
memcpy(frag->fragment, &(s->init_buf->data[s->init_num]),
msg_hdr->frag_len + DTLS1_HM_HEADER_LENGTH);
memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr));
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, msg_hdr->seq);
item = pitem_new(seq64, frag);
if ( item == NULL)
goto err;
pq_64bit_free(&seq64);
pqueue_insert(s->d1->buffered_messages, item);
return 1;
err:
if ( frag != NULL) dtls1_hm_fragment_free(frag);
if ( item != NULL) OPENSSL_free(item);
return 0;
}
int put_parcel(PQueue *parcels, const Parcel *parcel) {
Parcel *data;
/*****************************************************************************
* *
* Allocate storage for the parcel. *
* *
*****************************************************************************/
if ((data = (Parcel *)malloc(sizeof(Parcel))) == NULL)
return -1;
/*****************************************************************************
* *
* Insert the parcel into the priority queue. *
* *
*****************************************************************************/
memcpy(data, parcel, sizeof(Parcel));
if (pqueue_insert(parcels, data) != 0)
return -1;
return 0;
}
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 int
dtls1_process_out_of_seq_message(SSL *s, struct hm_header_st* msg_hdr, int *ok)
{
int i=-1;
hm_fragment *frag = NULL;
pitem *item = NULL;
PQ_64BIT seq64;
unsigned long frag_len = msg_hdr->frag_len;
if ((msg_hdr->frag_off+frag_len) > msg_hdr->msg_len)
goto err;
if (msg_hdr->seq <= s->d1->handshake_read_seq)
{
unsigned char devnull [256];
while (frag_len)
{
i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
devnull,
frag_len>sizeof(devnull)?sizeof(devnull):frag_len,0);
if (i<=0) goto err;
frag_len -= i;
}
}
frag = dtls1_hm_fragment_new(frag_len);
if ( frag == NULL)
goto err;
memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr));
if (frag_len)
{
/* read the body of the fragment (header has already been read */
i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
frag->fragment,frag_len,0);
if (i<=0 || (unsigned long)i!=frag_len)
goto err;
}
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, msg_hdr->seq);
item = pitem_new(seq64, frag);
pq_64bit_free(&seq64);
if ( item == NULL)
goto err;
pqueue_insert(s->d1->buffered_messages, item);
return DTLS1_HM_FRAGMENT_RETRY;
err:
if ( frag != NULL) dtls1_hm_fragment_free(frag);
if ( item != NULL) OPENSSL_free(item);
*ok = 0;
return i;
}
void test_pqueue_is_not_empty_after_insert(void)
{
setup();
pqueue_insert(pqueue, (void *) 0UL);
assert_false(pqueue_is_empty(pqueue));
teardown();
}
int
dtls1_buffer_message(SSL *s, int is_ccs)
{
pitem *item;
hm_fragment *frag;
PQ_64BIT seq64;
unsigned int epoch = s->d1->w_epoch;
/* this function is called immediately after a message has
* been serialized */
OPENSSL_assert(s->init_off == 0);
frag = dtls1_hm_fragment_new(s->init_num);
memcpy(frag->fragment, s->init_buf->data, s->init_num);
if ( is_ccs)
{
OPENSSL_assert(s->d1->w_msg_hdr.msg_len +
DTLS1_CCS_HEADER_LENGTH <= (unsigned int)s->init_num);
epoch++;
}
else
{
OPENSSL_assert(s->d1->w_msg_hdr.msg_len +
DTLS1_HM_HEADER_LENGTH == (unsigned int)s->init_num);
}
frag->msg_header.msg_len = s->d1->w_msg_hdr.msg_len;
frag->msg_header.seq = s->d1->w_msg_hdr.seq;
frag->msg_header.type = s->d1->w_msg_hdr.type;
frag->msg_header.frag_off = 0;
frag->msg_header.frag_len = s->d1->w_msg_hdr.msg_len;
frag->msg_header.is_ccs = is_ccs;
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, epoch<<16 | frag->msg_header.seq);
item = pitem_new(seq64, frag);
pq_64bit_free(&seq64);
if ( item == NULL)
{
dtls1_hm_fragment_free(frag);
return 0;
}
#if 0
fprintf( stderr, "buffered messge: \ttype = %xx\n", msg_buf->type);
fprintf( stderr, "\t\t\t\t\tlen = %d\n", msg_buf->len);
fprintf( stderr, "\t\t\t\t\tseq_num = %d\n", msg_buf->seq_num);
#endif
pqueue_insert(s->d1->sent_messages, item);
return 1;
}
int
main(void)
{
pitem *item;
pqueue pq;
int one = 1;
int two = 2;
int three = 3;
pq = pqueue_new();
item = pitem_new((unsigned char*)&three, NULL);
pqueue_insert(pq, item);
item = pitem_new((unsigned char*)&one, NULL);
pqueue_insert(pq, item);
item = pitem_new((unsigned char*)&two, NULL);
pqueue_insert(pq, item);
item = pqueue_find(pq, (unsigned char*)&one);
TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR, "found %ld\n", item->priority);
item = pqueue_find(pq, (unsigned char*)&two);
TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR, "found %ld\n", item->priority);
item = pqueue_find(pq, (unsigned char*)&three);
TINYCLR_SSL_FPRINTF(OPENSSL_TYPE__FILE_STDERR, "found %ld\n", item ? item->priority: 0);
pqueue_print(pq);
for(item = pqueue_pop(pq); item != NULL; item = pqueue_pop(pq))
pitem_free(item);
pqueue_free(pq);
return 0;
}
int main(void)
{
pitem *item;
pqueue pq;
pq = pqueue_new();
item = pitem_new(prio3, NULL);
pqueue_insert(pq, item);
item = pitem_new(prio1, NULL);
pqueue_insert(pq, item);
item = pitem_new(prio2, NULL);
pqueue_insert(pq, item);
item = pqueue_find(pq, prio1);
fprintf(stderr, "found %p\n", item->priority);
item = pqueue_find(pq, prio2);
fprintf(stderr, "found %p\n", item->priority);
item = pqueue_find(pq, prio3);
fprintf(stderr, "found %p\n", item ? item->priority : 0);
pqueue_print(pq);
if (!pqueue_test(pq))
return 1;
for (item = pqueue_pop(pq); item != NULL; item = pqueue_pop(pq))
pitem_free(item);
pqueue_free(pq);
return 0;
}
} T_END_TEST
T_TEST(t_pqueue_duplicate) {
struct pqueue* q = pqueue_create(comp);
void* v = (void*)0xdeadbeef;
T_ASSERT(q);
T_ASSERT(0 == pqueue_insert(q, v));
T_ASSERT(0 == pqueue_insert(q, v));
T_ASSERT(!pqueue_is_empty(q));
T_ASSERT(v == pqueue_peek(q));
T_ASSERT(v == pqueue_pop(q));
T_ASSERT(!pqueue_is_empty(q));
T_ASSERT(v == pqueue_peek(q));
T_ASSERT(v == pqueue_pop(q));
T_ASSERT(pqueue_is_empty(q));
pqueue_destroy(q);
} T_END_TEST
int neighbors_nearsource(float* time /* time */,
float* xs /* source location [3] */)
/* initialize point source */
{
int its;
int ic, i, j, is[3];
double delta[3], delta2;
#ifdef _OPENMP
its = omp_get_thread_num();
#else
its = 0;
#endif
/* initialize everywhere */
for (i=0; i < n[0]*n[1]*n[2]; i++) {
in[its][i] = SF_OUT;
time[i] = SF_HUGE;
offsets[its][i] = -1;
}
/* Find index of the source location and project it to the grid */
delta2 = 0.;
for (j=0; j < 3; j++) {
is[j] = xs[j]/d[j]+0.5;
if (is[j] < 0) {
is[j]=0;
} else if (is[j] >= n[j]) {
is[j]=n[j]-1;
}
delta[j] = xs[j]-is[j]*d[j];
delta2 += delta[j]*delta[j];
}
/* source index */
ic = is[0]+n[0]*(is[1]+n[1]*is[2]);
/* initialize source */
time[ic] = sqrtf(((double)v[ic])*delta2);
/* TEMP: the next line seems to be redundant; to be checked later...*/
in[its][ic] = SF_IN;
pqueue_insert(time+ic);
return (n[0]*n[1]*n[2]-1);
}
int main (int argc, char *argv[])
{
int i;
struct pqueue *pqueue;
pqueue = pqueue_create(0, compare, NULL);
if (pqueue == NULL) {
return -1;
}
for (i = 1; i < argc; i++) {
pqueue_insert(pqueue, argv[i]);
}
printf("%s ", (char *) pqueue_pop(pqueue));
printf("%s ", (char *) pqueue_pop(pqueue));
printf("%s ", (char *) pqueue_pop(pqueue));
pqueue_destroy(pqueue);
return 0;
}
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;
}
//doesn't check for existence
Element * hash_table_insert(Key key, HashTable * hash_table,int alloc_size){
int hashval = hash_value(key,hash_table->number_buckets);
return pqueue_insert(key, &(hash_table->table[hashval]), hash_table->kmer_size,alloc_size);
}
static int
dtls1_process_out_of_seq_message(SSL *s, struct hm_header_st* msg_hdr, int *ok)
{
int i=-1;
hm_fragment *frag = NULL;
pitem *item = NULL;
PQ_64BIT seq64;
unsigned long frag_len = msg_hdr->frag_len;
if ((msg_hdr->frag_off+frag_len) > msg_hdr->msg_len)
goto err;
/* Try to find item in queue, to prevent duplicate entries */
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, msg_hdr->seq);
item = pqueue_find(s->d1->buffered_messages, seq64);
pq_64bit_free(&seq64);
/* If we already have an entry and this one is a fragment,
* don't discard it and rather try to reassemble it.
*/
if (item != NULL && frag_len < msg_hdr->msg_len)
item = NULL;
/* Discard the message if sequence number was already there, is
* too far in the future, already in the queue or if we received
* a FINISHED before the SERVER_HELLO, which then must be a stale
* retransmit.
*/
if (msg_hdr->seq <= s->d1->handshake_read_seq ||
msg_hdr->seq > s->d1->handshake_read_seq + 10 || item != NULL ||
(s->d1->handshake_read_seq == 0 && msg_hdr->type == SSL3_MT_FINISHED))
{
unsigned char devnull [256];
while (frag_len)
{
i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
devnull,
frag_len>sizeof(devnull)?sizeof(devnull):frag_len,0);
if (i<=0) goto err;
frag_len -= i;
}
}
else
{
if (frag_len && frag_len < msg_hdr->msg_len)
return dtls1_reassemble_fragment(s, msg_hdr, ok);
frag = dtls1_hm_fragment_new(frag_len, 0);
if ( frag == NULL)
goto err;
memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr));
if (frag_len)
{
/* read the body of the fragment (header has already been read) */
i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
frag->fragment,frag_len,0);
if (i<=0 || (unsigned long)i!=frag_len)
goto err;
}
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, msg_hdr->seq);
item = pitem_new(seq64, frag);
pq_64bit_free(&seq64);
if ( item == NULL)
goto err;
pqueue_insert(s->d1->buffered_messages, item);
}
return DTLS1_HM_FRAGMENT_RETRY;
err:
if ( frag != NULL) dtls1_hm_fragment_free(frag);
if ( item != NULL) OPENSSL_free(item);
*ok = 0;
return i;
}
static int
dtls1_reassemble_fragment(SSL *s, struct hm_header_st* msg_hdr, int *ok)
{
hm_fragment *frag = NULL;
pitem *item = NULL;
int i = -1, is_complete;
PQ_64BIT seq64;
unsigned long frag_len = msg_hdr->frag_len, max_len;
if ((msg_hdr->frag_off+frag_len) > msg_hdr->msg_len)
goto err;
/* Determine maximum allowed message size. Depends on (user set)
* maximum certificate length, but 16k is minimum.
*/
if (DTLS1_HM_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH < s->max_cert_list)
max_len = s->max_cert_list;
else
max_len = DTLS1_HM_HEADER_LENGTH + SSL3_RT_MAX_ENCRYPTED_LENGTH;
if ((msg_hdr->frag_off+frag_len) > max_len)
goto err;
/* Try to find item in queue */
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, msg_hdr->seq);
item = pqueue_find(s->d1->buffered_messages, seq64);
pq_64bit_free(&seq64);
if (item == NULL)
{
frag = dtls1_hm_fragment_new(msg_hdr->msg_len, 1);
if ( frag == NULL)
goto err;
memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr));
frag->msg_header.frag_len = frag->msg_header.msg_len;
frag->msg_header.frag_off = 0;
}
else
{
frag = (hm_fragment*) item->data;
if (frag->msg_header.msg_len != msg_hdr->msg_len)
{
item = NULL;
frag = NULL;
goto err;
}
}
/* If message is already reassembled, this must be a
* retransmit and can be dropped.
*/
if (frag->reassembly == NULL)
{
unsigned char devnull [256];
while (frag_len)
{
i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
devnull,
frag_len>sizeof(devnull)?sizeof(devnull):frag_len,0);
if (i<=0) goto err;
frag_len -= i;
}
return DTLS1_HM_FRAGMENT_RETRY;
}
/* read the body of the fragment (header has already been read */
i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
frag->fragment + msg_hdr->frag_off,frag_len,0);
if (i<=0 || (unsigned long)i!=frag_len)
goto err;
RSMBLY_BITMASK_MARK(frag->reassembly, (long)msg_hdr->frag_off,
(long)(msg_hdr->frag_off + frag_len));
RSMBLY_BITMASK_IS_COMPLETE(frag->reassembly, (long)msg_hdr->msg_len,
is_complete);
if (is_complete)
{
OPENSSL_free(frag->reassembly);
frag->reassembly = NULL;
}
if (item == NULL)
{
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, msg_hdr->seq);
item = pitem_new(seq64, frag);
pq_64bit_free(&seq64);
if (item == NULL)
{
i = -1;
goto err;
}
pqueue_insert(s->d1->buffered_messages, item);
}
return DTLS1_HM_FRAGMENT_RETRY;
err:
if (frag != NULL) dtls1_hm_fragment_free(frag);
if (item != NULL) OPENSSL_free(item);
*ok = 0;
return i;
}
int
dtls1_buffer_message(SSL *s, int is_ccs)
{
pitem *item;
hm_fragment *frag;
PQ_64BIT seq64;
/* this function is called immediately after a message has
* been serialized */
OPENSSL_assert(s->init_off == 0);
frag = dtls1_hm_fragment_new(s->init_num, 0);
memcpy(frag->fragment, s->init_buf->data, s->init_num);
if ( is_ccs)
{
OPENSSL_assert(s->d1->w_msg_hdr.msg_len +
DTLS1_CCS_HEADER_LENGTH <= (unsigned int)s->init_num);
}
else
{
OPENSSL_assert(s->d1->w_msg_hdr.msg_len +
DTLS1_HM_HEADER_LENGTH == (unsigned int)s->init_num);
}
frag->msg_header.msg_len = s->d1->w_msg_hdr.msg_len;
frag->msg_header.seq = s->d1->w_msg_hdr.seq;
frag->msg_header.type = s->d1->w_msg_hdr.type;
frag->msg_header.frag_off = 0;
frag->msg_header.frag_len = s->d1->w_msg_hdr.msg_len;
frag->msg_header.is_ccs = is_ccs;
/* save current state*/
frag->msg_header.saved_retransmit_state.enc_write_ctx = s->enc_write_ctx;
frag->msg_header.saved_retransmit_state.write_hash = s->write_hash;
frag->msg_header.saved_retransmit_state.compress = s->compress;
frag->msg_header.saved_retransmit_state.session = s->session;
frag->msg_header.saved_retransmit_state.epoch = s->d1->w_epoch;
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64,
dtls1_get_queue_priority(frag->msg_header.seq,
frag->msg_header.is_ccs));
item = pitem_new(seq64, frag);
pq_64bit_free(&seq64);
if ( item == NULL)
{
dtls1_hm_fragment_free(frag);
return 0;
}
#if 0
fprintf( stderr, "buffered messge: \ttype = %xx\n", msg_buf->type);
fprintf( stderr, "\t\t\t\t\tlen = %d\n", msg_buf->len);
fprintf( stderr, "\t\t\t\t\tseq_num = %d\n", msg_buf->seq_num);
#endif
pqueue_insert(s->d1->sent_messages, item);
return 1;
}
/*
* Solves the puzzle and prints results.
* Returns 1 on success and 0 on nonexistence of a solution.
*/
static int solve(int *start, int *end)
{
Grid *root, *goal, *cur, *child, *iter, **result;
Pqueue *pq;
Set *visited;
int goal_grid_code, child_code;
int i, ch;
int path_length;
root = (Grid *) malloc(sizeof(Grid));
memcpy(root->g, start, sizeof(int) * 9);
root->parent = NULL;
root->hole = 1;
root->depth = 0;
goal = (Grid *) malloc(sizeof(Grid));
memcpy(goal->g, end, sizeof(int) * 9);
goal_grid_code = grid_code(goal);
get_correct_positions(goal);
path_length = 0;
i = 0;
pq = pqueue_new();
visited = set_new(4);
pqueue_insert(pq, root);
set_insert(visited, grid_code(root));
while (!empty(pq)) {
cur = pqueue_extract_min(pq);
if (verbose) {
fprintf(output, "%d.\n", ++i);
fprintf(output, "Depth: %d\n", cur->depth);
fprintf(output, "Grid:\n");
grid_print(output, cur);
fprintf(output, "f: %2d\n", weight(cur));
fprintf(output, "\n");
}
if (grid_code(cur) == goal_grid_code)
break;
ch = 0;
#define ADD_CHILD() { \
child_code = grid_code(child); \
if (!set_contains(visited, child_code)) { \
set_insert(visited, child_code); \
pqueue_insert(pq, child); \
cur->child[ch++] = child; \
} else \
free(child); \
}
/* Hole not on the left wall. */
if (cur->hole % 3 > 0) {
child = make_child(cur);
grid_move_hole(child, child->hole - 1);
ADD_CHILD();
}
/* Hole not on the right wall. */
if (cur->hole % 3 < 2) {
child = make_child(cur);
grid_move_hole(child, child->hole + 1);
ADD_CHILD();
}
/* Hole not on the top wall. */
if (cur->hole / 3 > 0) {
child = make_child(cur);
grid_move_hole(child, child->hole - 3);
ADD_CHILD();
}
/* Hole not on the bottom wall. */
if (cur->hole / 3 < 2) {
child = make_child(cur);
grid_move_hole(child, child->hole + 3);
ADD_CHILD();
}
#undef ADD_CHILD
/* End of children character. */
cur->child[ch] = NULL;
if (verbose) {
fprintf(output, "Children:\n");
grid_children(output, cur);
fprintf(output, "------------------------\n");
fprintf(output, "\n");
STEP();
}
}
if (grid_code(cur) != goal_grid_code)
return 0;
/* Collect result path. */
for (iter = cur; iter != NULL; iter = iter->parent)
path_length ++;
result = (Grid**) malloc(sizeof(Grid*) * path_length);
i = path_length - 1;
for (iter = cur; iter != NULL; iter = iter->parent)
result[i--] = iter;
if (verbose)
fprintf(output, "Solution sequence:\n");
for (i = 0; i < path_length; i++) {
grid_print(output, result[i]);
STEP();
fprintf(output, "\n");
}
/* Clean up. */
grid_dispose(root);
set_dispose(visited);
pqueue_dispose(pq);
free(result);
free(goal);
return 1;
}
/**
* Expects a file like:
**/
void read_data_events(char *mmaped_file) {
/** Header **/
FILE *data = open_file(mmaped_file);
if(!data) {
printf("#Warning: data file %s not found\n", mmaped_file);
return;
}
if(!data_events)
data_events = pqueue_init(10, cmp_pri, get_pri, set_pri, get_pos, set_pos);
rbtree metadata = rbtree_create();
char line[512];
struct data_ev *event;
int nb_lines = 0;
uint64_t type;
while(fgets(line, sizeof(line), data)) {
nb_lines++;
event = malloc(sizeof(*event));
if(sscanf(line, "%lu %lu %lu %lu %d %u", &event->rdt, &event->malloc.begin, &event->malloc.end, &type, &event->cpu, &event->tid) != 6) {
goto test_info;
}
if(type == 0) { // free
event->type = FREE;
} else if(type == 2) { // munmap
event->type = FREE; //munmap is not handled correctly yet => fake free
} else { // malloc / mmap
event->type = MALLOC;
event->malloc.end = event->malloc.begin + event->malloc.end;
if(type == 1) {
char * val = rbtree_lookup(metadata, (void*)event->rdt, pointer_cmp);
if(val)
event->malloc.info = val;
else
asprintf(&event->malloc.info, "datasize%lu-%d", event->malloc.end - event->malloc.begin, nb_lines);
} else {
/*#define MAP_SHARED 0x01
#define MAP_PRIVATE 0x02*/
if(event->malloc.end - event->malloc.begin == 8392704) { /* All stacks seem to be of that size */
asprintf(&event->malloc.info, "thread-stack-%d", nb_lines);
} else if(type & 0x01) {
asprintf(&event->malloc.info, "mmap-shared%lu-%d", event->malloc.end - event->malloc.begin, nb_lines);
} else if(type & 0x02) {
asprintf(&event->malloc.info, "mmap-priv%lu-%d", event->malloc.end - event->malloc.begin, nb_lines);
} else {
asprintf(&event->malloc.info, "mmap-??%lu-%d", event->malloc.end - event->malloc.begin, nb_lines);
}
}
}
pqueue_insert(data_events, event);
total_data_samples++;
continue;
test_info:;
uint64_t time, loc;
int read;
if(sscanf(line, "#%lu 0x%lx %n\n", &time, &loc, &read) != 2) {
//printf("fail %s %d\n", line, read);
goto fail;
}
char *met_value = strdup(line + read);
int met_len = strlen(met_value)-1;
if(met_len < 5) // malloc probably not correctly resolved
asprintf(&met_value, "%lu", time);
else
met_value[met_len] = '\0';
rbtree_insert(metadata, (void*)time, met_value, pointer_cmp);
fail:
//printf("#Unrecognized line: %s", line);
free(event);
continue;
}
if(!active_data)
active_data = rbtree_create();
if(verbose)
printf("#All data events added successfully ; now processing samples\n");
}
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;
}
static int
dtls1_process_out_of_seq_message(SSL *s, struct hm_header_st* msg_hdr, int *ok)
{
int i=-1;
hm_fragment *frag = NULL;
pitem *item = NULL;
PQ_64BIT seq64;
unsigned long frag_len = msg_hdr->frag_len;
if ((msg_hdr->frag_off+frag_len) > msg_hdr->msg_len)
goto err;
/* Try to find item in queue, to prevent duplicate entries */
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, msg_hdr->seq);
item = pqueue_find(s->d1->buffered_messages, seq64);
pq_64bit_free(&seq64);
/* Discard the message if sequence number was already there, is
* too far in the future or the fragment is already in the queue */
if (msg_hdr->seq <= s->d1->handshake_read_seq ||
msg_hdr->seq > s->d1->handshake_read_seq + 10 || item != NULL)
{
unsigned char devnull [256];
while (frag_len)
{
i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
devnull,
frag_len>sizeof(devnull)?sizeof(devnull):frag_len,0);
if (i<=0) goto err;
frag_len -= i;
}
}
if (frag_len)
{
frag = dtls1_hm_fragment_new(frag_len);
if ( frag == NULL)
goto err;
memcpy(&(frag->msg_header), msg_hdr, sizeof(*msg_hdr));
/* read the body of the fragment (header has already been read) */
i = s->method->ssl_read_bytes(s,SSL3_RT_HANDSHAKE,
frag->fragment,frag_len,0);
if (i<=0 || (unsigned long)i!=frag_len)
goto err;
pq_64bit_init(&seq64);
pq_64bit_assign_word(&seq64, msg_hdr->seq);
item = pitem_new(seq64, frag);
pq_64bit_free(&seq64);
if ( item == NULL)
goto err;
pqueue_insert(s->d1->buffered_messages, item);
}
return DTLS1_HM_FRAGMENT_RETRY;
err:
if ( frag != NULL) dtls1_hm_fragment_free(frag);
if ( item != NULL) OPENSSL_free(item);
*ok = 0;
return i;
}
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;
}
