static void _new_map_del_node (MAP map, struct map_node *n)
{
/* remove node from old hash list */
mhlist_del_init(&n->hnode);
/* remove from entry list */
mlist_del(&n->lnode);
/* add it back to the pool */
mlist_add(&n->lnode, &map->pool);
map->num--;
}
static void _stp_map_sort (MAP map, int keynum, int dir,
map_get_key_fn get_key)
{
struct mlist_head *p, *q, *e, *tail;
int nmerges, psize, qsize, i, insize = 1;
struct mlist_head *head = &map->head;
if (mlist_empty(head))
return;
do {
tail = head;
p = mlist_next(head);
nmerges = 0;
while (p) {
nmerges++;
q = p;
psize = 0;
for (i = 0; i < insize; i++) {
psize++;
q = mlist_next(q) == head ? NULL : mlist_next(q);
if (!q)
break;
}
qsize = insize;
while (psize > 0 || (qsize > 0 && q)) {
if (psize && (!qsize || !q ||
!_stp_cmp(p, q, keynum, dir, get_key))) {
e = p;
p = mlist_next(p) == head ? NULL : mlist_next(p);
psize--;
} else {
e = q;
q = mlist_next(q) == head ? NULL : mlist_next(q);
qsize--;
}
/* now put 'e' on tail of list and make it our new tail */
mlist_del(e);
mlist_add(e, tail);
tail = e;
}
p = q;
}
insize += insize;
} while (nmerges > 1);
}
/** Get the top values from an array.
* Sorts an array such that the start of the array contains the top
* or bottom 'n' values. Use this when sorting the entire array
* would be too time-consuming and you are only interested in the
* highest or lowest values.
*
* @param map Map
* @param n Top (or bottom) number of elements. 0 sorts the entire array.
* @param keynum 0 for the value, or a positive number for the key number to sort on.
* @param dir Sort Direction. -1 for low-to-high. 1 for high-to-low.
* @sa _stp_map_sort()
*/
static void _stp_map_sortn(MAP map, int n, int keynum, int dir,
map_get_key_fn get_key)
{
if (n == 0 || n > 30) {
_stp_map_sort(map, keynum, dir, get_key);
} else {
struct mlist_head *head = &map->head;
struct mlist_head *c, *a, *last, *tmp;
int num, swaps = 1;
if (mlist_empty(head))
return;
/* start off with a modified bubble sort of the first n elements */
while (swaps) {
num = n;
swaps = 0;
a = mlist_next(head);
c = mlist_next(mlist_next(a));
while ((mlist_next(a) != head) && (--num > 0)) {
if (_stp_cmp(a, mlist_next(a), keynum, dir, get_key)) {
swaps++;
_stp_swap(a, mlist_next(a));
}
a = mlist_prev(c);
c = mlist_next(c);
}
}
/* Now use a kind of insertion sort for the rest of the array. */
/* Each element is tested to see if it should be be in the top 'n' */
last = a;
a = mlist_next(a);
while (a != head) {
tmp = mlist_next(a);
c = last;
while (c != head && _stp_cmp(c, a, keynum, dir, get_key))
c = mlist_prev(c);
if (c != last) {
mlist_del(a);
mlist_add(a, c);
last = mlist_prev(last);
}
a = tmp;
}
}
}
/*----------------------------------------------------------------------------*/
void zrtp_session_down(zrtp_session_t *session)
{
int i =0;
if (!session) {
return;
}
/* Stop ZRTP engine and clear all crypto sources for every stream in the session. */
zrtp_mutex_lock(session->streams_protector);
for(i=0; i<ZRTP_MAX_STREAMS_PER_SESSION; i++) {
zrtp_stream_t *the_stream = &session->streams[i];
zrtp_stream_stop(the_stream);
}
zrtp_mutex_unlock(session->streams_protector);
/* Release memory allocated on initialization */
if (session->secrets.rs1) {
zrtp_sys_free(session->secrets.rs1);
}
if (session->secrets.rs2) {
zrtp_sys_free(session->secrets.rs2);
}
if (session->secrets.auxs) {
zrtp_sys_free(session->secrets.auxs);
}
if (session->secrets.pbxs) {
zrtp_sys_free(session->secrets.pbxs);
}
/* We don't need the session key anymore - clear it */
zrtp_wipe_zstring(ZSTR_GV(session->zrtpsess));
/* Removing session from the global list */
zrtp_mutex_lock(session->zrtp->sessions_protector);
mlist_del(&session->_mlist);
zrtp_mutex_unlock(session->zrtp->sessions_protector);
zrtp_mutex_destroy(session->streams_protector);
zrtp_mutex_destroy(session->init_protector);
zrtp_sys_free(session);
}
static void _stp_map_clear(MAP map)
{
struct map_node *m;
map->num = 0;
while (!mlist_empty(&map->head)) {
m = mlist_map_node(mlist_next(&map->head));
/* remove node from old hash list */
mhlist_del_init(&m->hnode);
/* remove from entry list */
mlist_del(&m->lnode);
/* add to free pool */
mlist_add(&m->lnode, &map->pool);
}
}
/* swap function for bubble sort */
static inline void _stp_swap (struct mlist_head *a, struct mlist_head *b)
{
mlist_del(a);
mlist_add(a, b);
}
