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