static dlist *
do_layout(MainWin *mw, dlist *clients, Window focus, Window leader)
{
unsigned long desktop = wm_get_current_desktop(mw->dpy);
unsigned int width, height;
float factor;
int xoff, yoff;
dlist *iter, *tmp;
/* Update the client table, pick the ones we want and sort them */
clients = update_clients(mw, clients, 0);
if(mw->cod)
dlist_free(mw->cod);
tmp = dlist_first(dlist_find_all(clients, (dlist_match_func)clientwin_validate_func, &desktop));
if(leader != None)
{
mw->cod = dlist_first(dlist_find_all(tmp, clientwin_check_group_leader_func, (void*)&leader));
dlist_free(tmp);
} else
mw->cod = tmp;
if(! mw->cod)
return clients;
dlist_sort(mw->cod, clientwin_sort_func, 0);
/* Move the mini windows around */
layout_run(mw, mw->cod, &width, &height);
factor = (float)(mw->width - 100) / width;
if(factor * height > mw->height - 100)
factor = (float)(mw->height - 100) / height;
xoff = (mw->width - (float)width * factor) / 2;
yoff = (mw->height - (float)height * factor) / 2;
mainwin_transform(mw, factor);
for(iter = mw->cod; iter; iter = iter->next)
clientwin_move((ClientWin*)iter->data, factor, xoff, yoff);
/* Get the currently focused window and select which mini-window to focus */
iter = dlist_find(mw->cod, clientwin_cmp_func, (void *)focus);
if(! iter)
iter = mw->cod;
mw->focus = (ClientWin*)iter->data;
mw->focus->focused = 1;
/* Map the client windows */
for(iter = mw->cod; iter; iter = iter->next)
clientwin_map((ClientWin*)iter->data);
XWarpPointer(mw->dpy, None, mw->focus->mini.window, 0, 0, 0, 0, mw->focus->mini.width / 2, mw->focus->mini.height / 2);
return clients;
}
static void
dir_focus(ClientWin *cw, match_func match, dist_func func)
{
float diff = 0.0;
ClientWin *candidate = NULL;
dlist *iter, *candidates;
candidates = dlist_first(dlist_find_all(cw->mainwin->cod, (dlist_match_func)match, &cw->mini));
if(! candidates)
return;
for(iter = dlist_first(candidates); iter; iter = iter->next)
{
ClientWin *win = (ClientWin *)iter->data;
float distance = func(&cw->mini, &win->mini);
if(! candidate || distance < diff)
{
candidate = win;
diff = distance;
}
}
XWarpPointer(candidate->mainwin->ps->dpy, None, candidate->mini.window, 0, 0, 0, 0, candidate->mini.width / 2, candidate->mini.height / 2);
XSetInputFocus(candidate->mainwin->ps->dpy, candidate->mini.window, RevertToParent, CurrentTime);
dlist_free(candidates);
}
EXPORTED void dlist_splat(struct dlist *parent, struct dlist *child)
{
struct dlist *prev = NULL;
struct dlist *replace;
/* find old record */
for (replace = parent->head; replace; replace = replace->next) {
if (replace == child) break;
prev = replace;
}
assert(replace);
if (child->head) {
/* stitch in children */
if (prev) prev->next = child->head;
else parent->head = child->head;
if (child->next) child->tail->next = child->next;
else parent->tail = child->tail;
}
else {
/* just remove the record */
if (prev) prev->next = child->next;
else parent->head = child->next;
if (!child->next) parent->tail = prev;
}
/* remove the node itself, carefully blanking out
* the now unlinked children */
child->head = NULL;
child->tail = NULL;
dlist_free(&child);
}
static int do_unuser(const char *userid)
{
const char *cmd = "UNUSER";
struct mailbox *mailbox = NULL;
struct dlist *kl;
int r;
/* nothing to do if there's no userid */
if (!userid || !userid[0]) {
syslog(LOG_WARNING, "ignoring attempt to %s() without userid", __func__);
return 0;
}
/* check local mailbox first */
char *inbox = mboxname_user_mbox(userid, NULL);
r = mailbox_open_irl(inbox, &mailbox);
/* only remove from server if there's no local mailbox */
if (r == IMAP_MAILBOX_NONEXISTENT) {
kl = dlist_setatom(NULL, cmd, userid);
sync_send_apply(kl, sync_out);
dlist_free(&kl);
r = sync_parse_response(cmd, sync_in, NULL);
if (r == IMAP_MAILBOX_NONEXISTENT) r = 0;
}
mailbox_close(&mailbox);
free(inbox);
return r;
}
static int do_unuser(const char *userid)
{
const char *cmd = "UNUSER";
struct mailbox *mailbox = NULL;
char buf[MAX_MAILBOX_BUFFER];
struct dlist *kl;
int r;
/* check local mailbox first */
(sync_namespace.mboxname_tointernal)(&sync_namespace, "INBOX",
userid, buf);
r = mailbox_open_irl(buf, &mailbox);
/* only remove from server if there's no local mailbox */
if (r == IMAP_MAILBOX_NONEXISTENT) {
kl = dlist_setatom(NULL, cmd, userid);
sync_send_apply(kl, sync_out);
dlist_free(&kl);
r = sync_parse_response(cmd, sync_in, NULL);
if (r == IMAP_MAILBOX_NONEXISTENT) r = 0;
}
mailbox_close(&mailbox);
return r;
}
/**
* Handle input command.
*
* This function should return 0, even if the command failed.
* Return of != 0 means the event loop will quit.
*/
static int handle_input_command(const dstring* string) {
dstrlist* list;
dstring** argv;
unsigned int argc;
int error;
ENetPacket* packet;
if (string->len == 0) {
/* empty command */
return 0;
} else if (string->data[0] == '/') {
/* local command */
/* parse the command */
list = dstrlex_parse(string, &error);
if (list == NULL) {
fprintf(stderr, "Failed to parse command string '%s': %s\n", string->data, dstrlex_errstr(error));
return 0;
}
/* convert list to vector */
argc = list->size;
argv = dlist_tovector(list);
dlist_free(list);
/* select command to execute */
if (dcmpcs(argv[0], "/connect") == 0) {
error = cmd_connect(argc, argv);
} else if (dcmpcs(argv[0], "/disconnect") == 0) {
error = cmd_disconnect(argc, argv);
} else if (dcmpcs(argv[0], "/quit") == 0) {
error = cmd_quit(argc, argv);
} else if (dcmpcs(argv[0], "/mute") == 0) {
error = cmd_mute(argc, argv);
} else if (dcmpcs(argv[0], "/deafen") == 0) {
error = cmd_deafen(argc, argv);
} else {
fprintf(stderr, "Unknown command '%s'\n", argv[0]->data);
error = 0;
}
dvec_free(argv);
return error;
} else if (client.state == SVCECLIENT_STATE_CONNECTED) {
/* send to server if connected */
mutex_lock(&client.network_lock);
packet = enet_packet_create(string->data, string->len, ENET_PACKET_FLAG_RELIABLE);
enet_peer_send(client.client, 0, packet);
mutex_unlock(&client.network_lock);
} else if (client.state == SVCECLIENT_STATE_CONNECTING) {
/* server command but still connecting */
fprintf(stderr, "Can't send command to server, still connecting.\n");
} else {
/* server command but not connected */
fprintf(stderr, "Can't send command to server, not connected.\n");
}
return 0;
}
static int unload_module(void) {
msgs_unhook(&default_msgs, pd_exec);
dlist_free(&pairs);
table_free(&contracts);
config_destroy(cfg);
return unregister_application(app);
}
/**
* @brief Remove all list entries matching data
* @param list The list list pointer
* @param data The data to match
* @return The new list lister
*/
struct dlist *dlist_delete_all(struct dlist *list, void *data)
{
struct dlist *n = NULL, *t = list;
while (t) {
if (t->data != data)
t = t->next;
else {
n = t->next;
if (t->prev)
t->prev->next = n;
else
list = n;
if (n)
n->prev = t->prev;
if (t == list)
list = list->next;
dlist_free(t);
t = n;
}
}
return list;
}
/**
* @brief Pulls an list out of a list and frees it
* @param list The list list pointer
* @param link The list to delete
* @return The new list lister
*/
struct dlist *dlist_delete_link(struct dlist *list, struct dlist *link)
{
list = _remove_link(list, link);
dlist_free(link);
return list;
}
static void handle_server_decoded_msg(const dstring* string) {
dstrlist* list;
dstring** argv;
int argc;
int error;
list = dstrlex_parse(string, &error);
if (list == NULL) {
fprintf(stderr, "Failed to parse string command: %s\n", dstrlex_errstr(error));
return;
}
/* convert list to vector */
argc = list->size;
argv = dlist_tovector(list);
dlist_free(list);
if (dcmpcs(argv[0], "SSET") == 0) {
scmd_sset(string, argc, argv);
} else if (dcmpcs(argv[0], "YARE") == 0) {
scmd_yare(string, argc, argv);
} else if (dcmpcs(argv[0], "PADD") == 0) {
scmd_padd(string, argc, argv);
} else if (dcmpcs(argv[0], "PDEL") == 0) {
scmd_pdel(string, argc, argv);
} else if (dcmpcs(argv[0], "PSET") == 0) {
scmd_pset(string, argc, argv);
} else if (dcmpcs(argv[0], "MESG") == 0) {
scmd_mesg(string, argc, argv);
} else {
fprintf(stderr, "Unrecognized command from server '%s'.\n", argv[0]->data);
}
dvec_free(argv);
}
/* FIXME */
void kdfree(void *value) {
struct kvd *kvd = (struct kvd *)value;
dstr_free(kvd->key);
dlist_free(&kvd->u.dlist);
FREE(kvd);
}
static int want_append_message(struct dlist *dlist,
struct sync_msgid_list *keep_message_guids)
{
struct dlist *di, *next;
for (di = dlist->head; di; di = next) {
struct message_guid *guid = NULL;
/* save next pointer now in case we need to unstitch */
next = di->next;
if (!dlist_tofile(di, NULL, &guid, NULL, NULL))
continue;
if (!sync_msgid_lookup(keep_message_guids, guid)) {
syslog(LOG_DEBUG, "%s: MESSAGE no longer needed: %s",
__func__, message_guid_encode(guid));
dlist_unstitch(dlist, di);
dlist_unlink_files(di);
dlist_free(&di);
}
}
if (dlist->head) {
syslog(LOG_DEBUG, "%s: keeping MESSAGE line", __func__);
return 1;
}
syslog(LOG_DEBUG, "%s: MESSAGE line has no more messages", __func__);
return 0;
}
void htable_free(htable_t* ht, op_unary_t free_node)
{
int i;
for (i = 0; i < ht->size; i++) {
dlist_free(&ht->buckets[i], free_node);
}
free(ht->buckets);
}
/**
* @brief Free and entire list
* @param list The starting point of a list to destory
* @return void
*/
void dlist_destroy(struct dlist *list)
{
struct dlist *h = list->next;
do {
h = list->next;
dlist_free(h);
} while (h != list);
}
static int reload_module(void) {
msgs_unhook(&default_msgs, pd_exec);
dlist_free(&pairs);
table_clear(contracts);
config_destroy(cfg);
load_config();
if (msgs_hook(&default_msgs, pd_exec, NULL) == -1)
return MODULE_LOAD_FAILURE;
return MODULE_LOAD_SUCCESS;
}
void test_dlist_create(void)
{
test_dlist = dlist_create();
assert_true(test_dlist != NULL);
assert_true(dlist_size(test_dlist) == 0);
assert_true(dlist_is_empty(test_dlist));
dlist_free(test_dlist);
test_dlist = NULL;
}
/*
* Write out the quota entry 'quota'
*/
EXPORTED int quota_write(struct quota *quota, struct txn **tid)
{
int r;
int qrlen;
int res;
struct buf buf = BUF_INITIALIZER;
struct dlist *dl = NULL;
if (!quota->root) return IMAP_QUOTAROOT_NONEXISTENT;
qrlen = strlen(quota->root);
if (!qrlen) return IMAP_QUOTAROOT_NONEXISTENT;
dl = dlist_newkvlist(NULL, NULL);
for (res = 0; res < QUOTA_NUMRESOURCES; res++) {
struct dlist *item = dlist_newlist(dl, quota_db_names[res]);
dlist_setnum64(item, NULL, quota->useds[res]);
if (quota->limits[res] != QUOTA_UNLIMITED)
dlist_setnum64(item, NULL, quota->limits[res]);
}
if (quota->scanmbox) {
struct dlist *scan = dlist_newkvlist(dl, "SCAN");
dlist_setatom(scan, "MBOX", quota->scanmbox);
for (res = 0; res < QUOTA_NUMRESOURCES; res++)
dlist_setnum64(scan, quota_db_names[res], quota->scanuseds[res]);
}
dlist_printbuf(dl, 0, &buf);
r = cyrusdb_store(qdb, quota->root, qrlen, buf.s, buf.len, tid);
switch (r) {
case CYRUSDB_OK:
r = 0;
break;
case CYRUSDB_AGAIN:
r = IMAP_AGAIN;
break;
default:
syslog(LOG_ERR, "DBERROR: error storing %s: %s",
quota->root, cyrusdb_strerror(r));
r = IMAP_IOERROR;
break;
}
dlist_free(&dl);
buf_free(&buf);
return r;
}
static dlist *
update_clients(MainWin *mw, dlist *clients, Bool *touched)
{
dlist *stack, *iter;
stack = dlist_first(wm_get_stack(mw->dpy));
iter = clients = dlist_first(clients);
if(touched)
*touched = False;
/* Terminate clients that are no longer managed */
while(iter)
{
ClientWin *cw = (ClientWin *)iter->data;
if(! dlist_find_data(stack, (void *)cw->client.window))
{
dlist *tmp = iter->next;
clientwin_destroy((ClientWin *)iter->data, True);
clients = dlist_remove(iter);
iter = tmp;
if(touched)
*touched = True;
continue;
}
clientwin_update(cw);
iter = iter->next;
}
/* Add new clients */
for(iter = dlist_first(stack); iter; iter = iter->next)
{
ClientWin *cw = (ClientWin*)dlist_find(clients, clientwin_cmp_func, iter->data);
if(! cw && (Window)iter->data != mw->window)
{
cw = clientwin_create(mw, (Window)iter->data);
if(! cw)
continue;
clients = dlist_add(clients, cw);
clientwin_update(cw);
if(touched)
*touched = True;
}
}
dlist_free(stack);
return clients;
}
/* FIXME */
void u_command(client c) {
dstr pkey, skey;
dlist_t dlist;
if (dstr_length(c->argv[0]) == 1) {
add_reply_error(c, "index can't be empty\r\n");
return;
}
pkey = dstr_new(c->argv[0] + 1);
skey = dstr_new(pkey);
if (c->argc > 1) {
int i;
for (i = 1; i < c->argc; ++i) {
skey = dstr_cat(skey, ",");
skey = dstr_cat(skey, c->argv[i]);
}
}
table_rwlock_wrlock(subscribers);
if ((dlist = table_get_value(subscribers, pkey))) {
struct kvd *kvd;
if (NEW(kvd)) {
dlist_node_t node, node2;
kvd->key = skey;
if ((node = dlist_find(dlist, kvd))) {
FREE(kvd);
kvd = (struct kvd *)dlist_node_value(node);
if ((node2 = dlist_find(kvd->u.dlist, c)))
dlist_remove(kvd->u.dlist, node2);
if (dlist_length(kvd->u.dlist) == 0) {
dlist_remove(dlist, node);
kdfree(kvd);
}
if (dlist_length(dlist) == 0) {
table_remove(subscribers, pkey);
dlist_free(&dlist);
}
} else
FREE(kvd);
} else
add_reply_error(c, "error allocating memory for kvd");
}
table_rwlock_unlock(subscribers);
dstr_free(skey);
dstr_free(pkey);
add_reply_string(c, "\r\n", 2);
}
/*
* cleanup_list
*
* helper function to remove scamper_fd_poll structures from any lists.
*/
static void cleanup_list(dlist_t *list)
{
scamper_fd_poll_t *poll;
if(list == NULL) return;
while((poll = dlist_head_pop(list)) != NULL)
{
poll->list = NULL;
poll->node = NULL;
}
dlist_free(list);
return;
}
static void _dlist_free_children(struct dlist *dl)
{
struct dlist *next;
struct dlist *i;
if (!dl) return;
i = dl->head;
while (i) {
next = i->next;
dlist_free(&i);
i = next;
}
dl->head = dl->tail = NULL;
}
HIDDEN int parse_backup_line(struct protstream *in, time_t *ts,
struct buf *cmd, struct dlist **kin)
{
struct dlist *dl = NULL;
struct buf buf = BUF_INITIALIZER;
int64_t t;
int c;
c = prot_getc(in);
if (c == '#')
eatline(in, c);
else
prot_ungetc(c, in);
c = getint64(in, &t);
if (c == EOF)
goto fail;
c = getword(in, &buf);
if (c == EOF)
goto fail;
c = dlist_parse(&dl, /*parsekeys*/ 1, 1, in);
if (!dl) {
fprintf(stderr, "\ndidn't parse dlist, error %i\n", c);
goto fail;
}
if (c == '\r') c = prot_getc(in);
if (c != '\n') {
fprintf(stderr, "expected newline, got '%c'\n", c);
eatline(in, c);
goto fail;
}
if (kin) *kin = dl;
if (cmd) buf_copy(cmd, &buf);
if (ts) *ts = (time_t) t;
buf_free(&buf);
return c;
fail:
if (dl) dlist_free(&dl);
buf_free(&buf);
return c;
}
/* FIXME */
void uall_command(client c) {
dstr res = get_indices();
dstr *fields = NULL;
int nfield = 0, i;
RTRIM(res);
fields = dstr_split_len(res, dstr_length(res), ",", 1, &nfield);
for (i = 1; i < nfield; ++i) {
dstr pkey = dstr_new(fields[i]);
dstr skey = dstr_new(pkey);
dlist_t dlist;
table_rwlock_wrlock(subscribers);
if ((dlist = table_get_value(subscribers, pkey))) {
struct kvd *kvd;
if (NEW(kvd)) {
dlist_node_t node, node2;
kvd->key = skey;
if ((node = dlist_find(dlist, kvd))) {
FREE(kvd);
kvd = (struct kvd *)dlist_node_value(node);
if ((node2 = dlist_find(kvd->u.dlist, c)))
dlist_remove(kvd->u.dlist, node2);
if (dlist_length(kvd->u.dlist) == 0) {
dlist_remove(dlist, node);
kdfree(kvd);
}
if (dlist_length(dlist) == 0) {
table_remove(subscribers, pkey);
dlist_free(&dlist);
}
} else
FREE(kvd);
} else
add_reply_error(c, "error allocating memory for kvd");
}
table_rwlock_unlock(subscribers);
dstr_free(skey);
dstr_free(pkey);
}
add_reply_string(c, "\r\n", 2);
dstr_free(res);
}
int main() {
dlist *list;
list = dlist_new();
dlist_append(list, strdup("one"));
dlist_append(list, strdup("two"));
dlist_foreach(list, print_string_cb, NULL);
dlist_foreach(list, string_to_upper_cb, NULL);
dlist_foreach(list, print_string_cb, NULL);
dlist_foreach(list, free_string_cb, NULL);
dlist_free(list);
return 0;
}
void scamper_rtsock_cleanup()
{
#ifndef _WIN32
rtsock_pair_t *pair;
if(pairs != NULL)
{
while((pair = dlist_head_pop(pairs)) != NULL)
{
pair->node = NULL;
rtsock_pair_free(pair);
}
dlist_free(pairs);
pairs = NULL;
}
#endif
return;
}
/**
* @brief Remove a list list matching data
* @param list The list list pointer
* @param data The data to match
* @return The new list lister
*/
struct dlist *dlist_delete(struct dlist *list, void *data)
{
struct dlist *t = list;
while (t) {
if (t->data == data) {
if (t->prev)
t->prev->next = t->next;
if (t->next)
t->next->prev = t->prev;
if (t == list)
list = list->next;
dlist_free(t);
break;
}
t = t->next;
}
return list;
}
EXPORTED int dlist_parsemap(struct dlist **dlp, int parsekey,
const char *base, unsigned len)
{
struct protstream *stream;
int c;
struct dlist *dl = NULL;
stream = prot_readmap(base, len);
prot_setisclient(stream, 1); /* don't sync literals */
c = dlist_parse(&dl, parsekey, stream, NULL);
prot_free(stream);
if (c != EOF) {
dlist_free(&dl);
return IMAP_IOERROR; /* failed to slurp entire buffer */
}
*dlp = dl;
return 0;
}
static dlist *
update_clients(MainWin *mw, dlist *clients)
{
dlist *stack, *iter;
stack = dlist_first(wm_get_stack(mw->dpy));
iter = clients = dlist_first(clients);
while(iter)
{
ClientWin *cw = (ClientWin *)iter->data;
if(! dlist_find_data(stack, (void *)cw->client.window))
{
dlist *tmp = iter->next;
clientwin_destroy((ClientWin *)iter->data);
clients = dlist_remove(iter);
iter = tmp;
continue;
}
clientwin_update(cw);
iter = iter->next;
}
for(iter = dlist_first(stack); iter; iter = iter->next)
{
ClientWin *cw = (ClientWin*)dlist_find(clients, clientwin_cmp_func, iter->data);
if(! cw)
{
cw = clientwin_create(mw, (Window)iter->data);
if(! cw)
continue;
clients = dlist_add(clients, cw);
clientwin_update(cw);
}
}
dlist_free(stack);
return clients;
}
void scamper_task_cleanup(void)
{
if(tx_ip != NULL)
{
splaytree_free(tx_ip, NULL);
tx_ip = NULL;
}
if(tx_nd != NULL)
{
splaytree_free(tx_nd, NULL);
tx_nd = NULL;
}
if(sniff != NULL)
{
dlist_free(sniff);
sniff = NULL;
}
return;
}
/* verify that each message exists within the chunk the index claims */
static int verify_chunk_messages(struct backup *backup, struct backup_chunk *chunk,
struct gzuncat *gzuc, unsigned level,
int verbose, FILE *out)
{
int r;
struct verify_message_rock vmrock = {
gzuc,
(level & BACKUP_VERIFY_MESSAGE_GUIDS),
NULL,
0,
verbose,
out,
};
if (out && verbose)
fprintf(out, "checking chunk %d messages...\n", chunk->id);
r = gzuc_member_start_from(gzuc, chunk->offset);
if (!r) {
r = backup_message_foreach(backup, chunk->id, NULL,
_verify_message_cb, &vmrock);
gzuc_member_end(gzuc, NULL);
}
if (vmrock.cached_dlist) {
dlist_unlink_files(vmrock.cached_dlist);
dlist_free(&vmrock.cached_dlist);
}
syslog(LOG_DEBUG, "%s: chunk %d %s!\n", __func__, chunk->id,
r ? "failed" : "passed");
if (out && verbose)
fprintf(out, "%s\n", r ? "error" : "ok");
return r;
}
