/* ** 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; }