+ it = it->next;
+ }
+ return 0;
+}
+
+
+int calc_multi_timeout_interval(multi_timeout_handler* mth)
+{
+ GSList* it = mth->timeout_list;
+ timeout* t = it->data;
+ int min_interval = t->interval_msec;
+ it = it->next;
+ while (it) {
+ t = it->data;
+ if (t->interval_msec < min_interval)
+ min_interval = t->interval_msec;
+ it = it->next;
+ }
+ return min_interval;
+}
+
+
+void create_multi_timeout(timeout* t1, timeout* t2)
+{
+ multi_timeout* mt1 = malloc(sizeof(multi_timeout));
+ multi_timeout* mt2 = malloc(sizeof(multi_timeout));
+ multi_timeout_handler* mth = malloc(sizeof(multi_timeout_handler));
+ timeout* real_timeout = malloc(sizeof(timeout));
+
+ mth->timeout_list = 0;
+ mth->timeout_list = g_slist_prepend(mth->timeout_list, t1);
+ mth->timeout_list = g_slist_prepend(mth->timeout_list, t2);
+ mth->parent_timeout = real_timeout;
+
+ g_hash_table_insert(multi_timeouts, t1, mth);
+ g_hash_table_insert(multi_timeouts, t2, mth);
+ g_hash_table_insert(multi_timeouts, real_timeout, mth);
+
+ t1->multi_timeout = mt1;
+ t2->multi_timeout = mt2;
+ // set real_timeout->multi_timeout to something, such that we see in add_timeout_intern that
+ // it is already a multi_timeout (we never use it, except of checking for 0 ptr)
+ real_timeout->multi_timeout = (void*)real_timeout;
+
+ timeout_list = g_slist_remove(timeout_list, t1);
+ timeout_list = g_slist_remove(timeout_list, t2);
+
+ update_multi_timeout_values(mth);
+}
+
+
+void append_multi_timeout(timeout* t1, timeout* t2)
+{
+ if (t2->multi_timeout) {
+ // swap t1 and t2 such that t1 is the multi timeout
+ timeout* tmp = t2;
+ t2 = t1;
+ t1 = tmp;
+ }
+
+ multi_timeout* mt = malloc(sizeof(multi_timeout));
+ multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t1);
+
+ mth->timeout_list = g_slist_prepend(mth->timeout_list, t2);
+ g_hash_table_insert(multi_timeouts, t2, mth);
+
+ t2->multi_timeout = mt;
+
+ update_multi_timeout_values(mth);
+}
+
+
+void update_multi_timeout_values(multi_timeout_handler* mth)
+{
+ int interval = calc_multi_timeout_interval(mth);
+ int next_timeout_msec = interval;
+
+ struct timespec cur_time;
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);
+
+ GSList* it = mth->timeout_list;
+ struct timespec diff_time;
+ while (it) {
+ timeout* t = it->data;
+ t->multi_timeout->count_to_expiration = t->interval_msec / interval;
+ timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
+ int msec_to_expiration = diff_time.tv_sec*1000 + diff_time.tv_nsec/1000000;
+ int count_left = msec_to_expiration / interval + (msec_to_expiration%interval != 0);
+ t->multi_timeout->current_count = t->multi_timeout->count_to_expiration - count_left;
+ if (msec_to_expiration < next_timeout_msec)
+ next_timeout_msec = msec_to_expiration;
+ it = it->next;
+ }
+
+ mth->parent_timeout->interval_msec = interval;
+ timeout_list = g_slist_remove(timeout_list, mth->parent_timeout);
+ add_timeout_intern(next_timeout_msec, interval, callback_multi_timeout, mth, mth->parent_timeout);
+}
+
+
+void callback_multi_timeout(void* arg)
+{
+ multi_timeout_handler* mth = arg;
+ struct timespec cur_time;
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ GSList* it = mth->timeout_list;
+ while (it) {
+ timeout* t = it->data;
+ if (++t->multi_timeout->current_count >= t->multi_timeout->count_to_expiration) {
+ t->_callback(t->arg);
+ t->multi_timeout->current_count = 0;
+ t->timeout_expires = add_msec_to_timespec(cur_time, t->interval_msec);
+ }
+ it = it->next;
+ }
+}
+
+
+void remove_from_multi_timeout(timeout* t)
+{
+ multi_timeout_handler* mth = g_hash_table_lookup(multi_timeouts, t);
+ g_hash_table_remove(multi_timeouts, t);
+
+ mth->timeout_list = g_slist_remove(mth->timeout_list, t);
+ free(t->multi_timeout);
+ t->multi_timeout = 0;
+
+ if (g_slist_length(mth->timeout_list) == 1) {
+ timeout* last_timeout = mth->timeout_list->data;
+ free(last_timeout->multi_timeout);
+ last_timeout->multi_timeout = 0;
+ g_hash_table_remove(multi_timeouts, last_timeout);
+ g_hash_table_remove(multi_timeouts, mth->parent_timeout);
+ mth->parent_timeout->multi_timeout = 0;
+ stop_timeout(mth->parent_timeout);
+ free(mth);
+
+ struct timespec cur_time, diff_time;
+ clock_gettime(CLOCK_MONOTONIC, &cur_time);
+ timespec_subtract(&diff_time, &t->timeout_expires, &cur_time);
+ int msec_to_expiration = diff_time.tv_sec*1000 + diff_time.tv_nsec/1000000;
+ add_timeout_intern(msec_to_expiration, last_timeout->interval_msec, last_timeout->_callback, last_timeout->arg, last_timeout);