/** Handle a systray request. * \param embed_win The window to embed. * \param info The embedding info * \return 0 on no error. */ int systray_request_handle(xcb_window_t embed_win, xembed_info_t *info) { xembed_window_t em; xcb_get_property_cookie_t em_cookie; const uint32_t select_input_val[] = { XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_ENTER_WINDOW }; /* check if not already trayed */ if(xembed_getbywin(&globalconf.embedded, embed_win)) return -1; p_clear(&em_cookie, 1); if(!info) em_cookie = xembed_info_get_unchecked(globalconf.connection, embed_win); xcb_change_window_attributes(globalconf.connection, embed_win, XCB_CW_EVENT_MASK, select_input_val); xwindow_set_state(embed_win, XCB_ICCCM_WM_STATE_WITHDRAWN); /* we grab the window, but also make sure it's automatically reparented back * to the root window if we should die. */ xcb_change_save_set(globalconf.connection, XCB_SET_MODE_INSERT, embed_win); xcb_reparent_window(globalconf.connection, embed_win, globalconf.systray.window, 0, 0); em.win = embed_win; if(info) em.info = *info; else xembed_info_get_reply(globalconf.connection, em_cookie, &em.info); xembed_embedded_notify(globalconf.connection, em.win, globalconf.systray.window, MIN(XEMBED_VERSION, em.info.version)); xembed_window_array_append(&globalconf.embedded, em); luaA_systray_invalidate(); return 0; }
static bool stats_top_round(struct top_context *ctx) { #define TOP_CMD "EXPORT\tsession\tconnected\n" const char *const *args; pool_t tmp_pool; if (write_full(ctx->fd, TOP_CMD, strlen(TOP_CMD)) < 0) i_fatal("write(%s) failed: %m", ctx->path); /* read header */ if (ctx->headers != NULL) { args = read_next_line(ctx->input); if (args == NULL) i_fatal("read(%s) unexpectedly disconnected", ctx->path); if (*args == NULL) return TRUE; if (str_array_length(args) != ctx->headers_count) i_fatal("headers changed"); } else { ctx->headers = p_read_next_line(default_pool, ctx->input); if (ctx->headers == NULL) i_fatal("read(%s) unexpectedly disconnected", ctx->path); if (*ctx->headers == NULL) { i_free_and_null(ctx->headers); return FALSE; } ctx->headers_count = str_array_length((void *)ctx->headers); if (!stats_header_find(ctx, "last_update", &ctx->last_update_idx)) i_fatal("last_update header missing"); if (!stats_header_find(ctx, "user", &ctx->user_idx)) i_fatal("user header missing"); stats_top_get_sorting(ctx); } array_clear(&ctx->lines); p_clear(ctx->prev_pool); tmp_pool = ctx->prev_pool; ctx->prev_pool = ctx->cur_pool; ctx->cur_pool = tmp_pool; ctx->flip = !ctx->flip; stats_read(ctx); stats_drop_stale(ctx); sort_ctx = ctx; array_sort(&ctx->lines, *ctx->lines_sort); sort_ctx = NULL; return TRUE; }
/** Register systray in X. */ static void systray_register(void) { xcb_client_message_event_t ev; xcb_screen_t *xscreen = globalconf.screen; char *atom_name; xcb_intern_atom_cookie_t atom_systray_q; xcb_intern_atom_reply_t *atom_systray_r; xcb_atom_t atom_systray; /* Send requests */ if(!(atom_name = xcb_atom_name_by_screen("_NET_SYSTEM_TRAY", globalconf.default_screen))) { warn("error getting systray atom"); return; } atom_systray_q = xcb_intern_atom_unchecked(globalconf.connection, false, a_strlen(atom_name), atom_name); p_delete(&atom_name); /* Fill event */ p_clear(&ev, 1); ev.response_type = XCB_CLIENT_MESSAGE; ev.window = xscreen->root; ev.format = 32; ev.type = MANAGER; ev.data.data32[0] = XCB_CURRENT_TIME; ev.data.data32[2] = globalconf.systray.window; ev.data.data32[3] = ev.data.data32[4] = 0; if(!(atom_systray_r = xcb_intern_atom_reply(globalconf.connection, atom_systray_q, NULL))) { warn("error getting systray atom"); return; } ev.data.data32[1] = atom_systray = atom_systray_r->atom; p_delete(&atom_systray_r); xcb_set_selection_owner(globalconf.connection, globalconf.systray.window, atom_systray, XCB_CURRENT_TIME); xcb_send_event(globalconf.connection, false, xscreen->root, 0xFFFFFF, (char *) &ev); }
/** Handle a systray request. * \param embed_win The window to embed. */ int systray_request_handle(xcb_window_t embed_win, int phys_screen, xembed_info_t *info) { xembed_window_t em; xcb_get_property_cookie_t em_cookie; int i; const uint32_t select_input_val[] = { XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_ENTER_WINDOW }; /* check if not already trayed */ if(xembed_getbywin(&globalconf.embedded, embed_win)) return -1; p_clear(&em_cookie, 1); if(!info) em_cookie = xembed_info_get_unchecked(globalconf.connection, embed_win); xcb_change_window_attributes(globalconf.connection, embed_win, XCB_CW_EVENT_MASK, select_input_val); window_state_set(embed_win, XCB_WM_STATE_WITHDRAWN); xcb_reparent_window(globalconf.connection, embed_win, globalconf.screens[phys_screen].systray.window, 0, 0); em.win = embed_win; em.phys_screen = phys_screen; if(info) em.info = *info; else xembed_info_get_reply(globalconf.connection, em_cookie, &em.info); xembed_embedded_notify(globalconf.connection, em.win, globalconf.screens[phys_screen].systray.window, MIN(XEMBED_VERSION, em.info.version)); xembed_window_array_append(&globalconf.embedded, em); for(i = 0; i < globalconf.nscreen; i++) widget_invalidate_bytype(i, widget_systray); return 0; }
/** Send WM_TAKE_FOCUS client message to window * \param win destination window */ void xwindow_takefocus(xcb_window_t win) { xcb_client_message_event_t ev; /* Initialize all of event's fields first */ p_clear(&ev, 1); ev.response_type = XCB_CLIENT_MESSAGE; ev.window = win; ev.format = 32; ev.data.data32[1] = globalconf.timestamp; ev.type = WM_PROTOCOLS; ev.data.data32[0] = WM_TAKE_FOCUS; xcb_send_event(globalconf.connection, false, win, XCB_EVENT_MASK_NO_EVENT, (char *) &ev); }
/** Add a plot to a graph. * \param d The graph private data. * \param title The plot title. * \return A new plot. */ static plot_t * graph_plot_add(graph_data_t *d, const char *title) { plot_t plot; p_clear(&plot, 1); plot.title = a_strdup(title); plot.values = p_new(float, d->size); plot.lines = p_new(int, d->size); plot.max_value = 100.0; plot.vertical_gradient = true; xcolor_to_color(&globalconf.colors.fg, &plot.color_start); plot_array_append(&d->plots, plot); return &d->plots.tab[d->plots.len - 1]; }
/* * P0 = n * P1 */ void ecc_mul ( point_t* P0, point_t* P1, NN_DIGIT* n ) { int16_t i, tmp; NN_DIGIT Z0[NUMWORDS]; NN_DIGIT Z1[NUMWORDS]; /* clear point */ p_clear ( P0 ); /* convert to Jprojective coordinate */ NN_AssignZero ( Z0, NUMWORDS ); NN_AssignZero ( Z1, NUMWORDS ); Z1[0] = 0x01; tmp = NN_Bits ( n, NUMWORDS ); for ( i = tmp-1; i >= 0; i-- ) { ecc_dbl_proj ( P0, Z0, P0, Z0 ); if ( b_testbit ( n, i ) ) { #ifdef ADD_MIX c_add_mix ( P0, Z0, P0, Z0, P1 ); #else ecc_add_proj ( P0, Z0, P0, Z0, P1, Z1 ); #endif } } /* convert back to affine coordinate */ if ( !Z_is_one ( Z0 ) ) { NN_ModInv ( Z1, Z0, param.p, NUMWORDS ); NN_ModMultOpt ( Z0, Z1, Z1, param.p, param.omega, NUMWORDS ); NN_ModMultOpt ( P0->x, P0->x, Z0, param.p, param.omega, NUMWORDS ); NN_ModMultOpt ( Z0, Z0, Z1, param.p, param.omega, NUMWORDS ); NN_ModMultOpt ( P0->y, P0->y, Z0, param.p, param.omega, NUMWORDS ); } }
static void mailbox_list_index_update_info(struct mailbox_list_index_iterate_context *ctx) { struct mailbox_list_index_node *node = ctx->next_node; struct mailbox *box; p_clear(ctx->info_pool); str_truncate(ctx->path, ctx->parent_len); /* the root directory may have an empty name. in that case we'll still want to insert the separator, so check for non-NULL parent rather than non-empty path. */ if (node->parent != NULL) { str_append_c(ctx->path, mailbox_list_get_hierarchy_sep(ctx->ctx.list)); } str_append(ctx->path, node->name); ctx->info.vname = mailbox_list_get_vname(ctx->ctx.list, str_c(ctx->path)); ctx->info.vname = p_strdup(ctx->info_pool, ctx->info.vname); ctx->info.flags = 0; if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NONEXISTENT) != 0) ctx->info.flags |= MAILBOX_NONEXISTENT; else if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NOSELECT) != 0) ctx->info.flags |= MAILBOX_NOSELECT; if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NOINFERIORS) != 0) ctx->info.flags |= MAILBOX_NOINFERIORS; ctx->info.flags |= node->children != NULL ? MAILBOX_CHILDREN : MAILBOX_NOCHILDREN; if ((ctx->ctx.flags & (MAILBOX_LIST_ITER_SELECT_SUBSCRIBED | MAILBOX_LIST_ITER_RETURN_SUBSCRIBED)) != 0) { mailbox_list_set_subscription_flags(ctx->ctx.list, ctx->info.vname, &ctx->info.flags); } box = mailbox_alloc(ctx->ctx.list, ctx->info.vname, 0); mailbox_list_index_status_set_info_flags(box, node->uid, &ctx->info.flags); mailbox_free(&box); }
void env_clean(void) { #ifdef HAVE_CLEARENV if (clearenv() < 0) i_fatal("clearenv() failed"); #else char ***environ_p = env_get_environ_p(); /* Try to clear the environment. a) environ = NULL crashes on OS X. b) *environ = NULL doesn't work on FreeBSD 7.0. c) environ = emptyenv doesn't work on Haiku OS d) environ = calloc() should work everywhere */ *environ_p = calloc(1, sizeof(**environ_p)); #endif if (env_pool != NULL) p_clear(env_pool); }
void managesieve_parser_reset(struct managesieve_parser *parser) { p_clear(parser->pool); parser->line_size = 0; parser->root_list = NULL; parser->cur_list = NULL; parser->cur_type = ARG_PARSE_NONE; parser->cur_pos = 0; parser->str_first_escape = 0; parser->literal_size = 0; parser->error = NULL; parser->literal_skip_crlf = FALSE; parser->eol = FALSE; managesieve_args_realloc(parser, LIST_ALLOC_SIZE); }
static void mailbox_list_index_update_info(struct mailbox_list_index_iterate_context *ctx) { struct mailbox_list_index_node *node = ctx->next_node; struct mailbox *box; p_clear(ctx->info_pool); str_truncate(ctx->path, ctx->parent_len); if (str_len(ctx->path) > 0) { str_append_c(ctx->path, mailbox_list_get_hierarchy_sep(ctx->ctx.list)); } str_append(ctx->path, node->name); ctx->info.vname = mailbox_list_get_vname(ctx->ctx.list, str_c(ctx->path)); ctx->info.vname = p_strdup(ctx->info_pool, ctx->info.vname); ctx->info.flags = 0; if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NONEXISTENT) != 0) ctx->info.flags |= MAILBOX_NONEXISTENT; else if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NOSELECT) != 0) ctx->info.flags |= MAILBOX_NOSELECT; if ((node->flags & MAILBOX_LIST_INDEX_FLAG_NOINFERIORS) != 0) ctx->info.flags |= MAILBOX_NOINFERIORS; ctx->info.flags |= node->children != NULL ? MAILBOX_CHILDREN : MAILBOX_NOCHILDREN; if ((ctx->ctx.flags & (MAILBOX_LIST_ITER_SELECT_SUBSCRIBED | MAILBOX_LIST_ITER_RETURN_SUBSCRIBED)) != 0) { mailbox_list_set_subscription_flags(ctx->ctx.list, ctx->info.vname, &ctx->info.flags); } box = mailbox_alloc(ctx->ctx.list, ctx->info.vname, 0); mailbox_list_index_status_set_info_flags(box, node->uid, &ctx->info.flags); mailbox_free(&box); }
static void index_mail_reset(struct index_mail *mail) { struct index_mail_data *data = &mail->data; mail->mail.v.close(&mail->mail.mail); memset(data, 0, sizeof(*data)); p_clear(mail->data_pool); data->virtual_size = (uoff_t)-1; data->physical_size = (uoff_t)-1; data->save_date = (time_t)-1; data->received_date = (time_t)-1; data->sent_date.time = (uint32_t)-1; data->dont_cache_field_idx = -1U; mail->mail.mail.seq = 0; mail->mail.mail.uid = 0; mail->mail.mail.expunged = FALSE; mail->mail.mail.has_nuls = FALSE; mail->mail.mail.has_no_nuls = FALSE; mail->mail.mail.saving = FALSE; }
void imap_parser_reset(struct imap_parser *parser) { p_clear(parser->pool); parser->line_size = 0; p_array_init(&parser->root_list, parser->pool, LIST_INIT_COUNT); parser->cur_list = &parser->root_list; parser->list_arg = NULL; parser->cur_type = ARG_PARSE_NONE; parser->cur_pos = 0; parser->cur_resp_text = FALSE; parser->str_first_escape = 0; parser->literal_size = 0; parser->error = NULL; parser->literal_skip_crlf = FALSE; parser->eol = FALSE; parser->args_added_extra_eol = FALSE; parser->literal_size_return = FALSE; }
static void virtual_mail_set_seq(struct mail *mail, uint32_t seq, bool saving) { struct virtual_mail *vmail = (struct virtual_mail *)mail; struct virtual_mailbox *mbox = (struct virtual_mailbox *)mail->box; struct virtual_backend_box *bbox; const struct virtual_mail_index_record *vrec; const void *data; i_assert(!saving); mail_index_lookup_ext(mail->transaction->view, seq, mbox->virtual_ext_id, &data, NULL); vrec = data; bbox = virtual_backend_box_lookup(mbox, vrec->mailbox_id); vmail->backend_mail = backend_mail_find(vmail, bbox->box); if (vmail->backend_mail == NULL) (void)virtual_mail_set_backend_mail(mail, bbox); vmail->lost = !mail_set_uid(vmail->backend_mail, vrec->real_uid); memset(&vmail->imail.data, 0, sizeof(vmail->imail.data)); p_clear(vmail->imail.mail.data_pool); vmail->imail.data.seq = seq; mail->seq = seq; mail_index_lookup_uid(mail->transaction->view, seq, &mail->uid); if (!vmail->lost) { mail->expunged = vmail->backend_mail->expunged; mail->has_nuls = vmail->backend_mail->has_nuls; mail->has_no_nuls = vmail->backend_mail->has_no_nuls; } else { mail->expunged = TRUE; mail->has_nuls = FALSE; mail->has_no_nuls = FALSE; } }
int GxAnimate(Engine *engine, GpBox *viewport) { XEngine *xeng = GisXEngine(engine); int x, y, x1, y1; GpBox *v, *w; GpReal xmin, xmax, ymin, ymax; GpReal scalx, offx, scaly, offy; if (!xeng || !xeng->w) return 1; if (xeng->w!=xeng->win) GxDirect(engine); v = &xeng->e.transform.viewport; /* NDC */ w = &xeng->e.transform.window; /* pixels */ /* get NDC-->pixel mapping coefficients */ scalx = xeng->e.devMap.x.scale; offx = xeng->e.devMap.x.offset; scaly = xeng->e.devMap.y.scale; offy = xeng->e.devMap.y.offset; /* clip given viewport to portion of NDC space which is actually * visible now -- note that v is either gLandscape or gPortrait, * so that min<max for v; must also be true for input viewport */ GetVisibleNDC(xeng, &xmin, &xmax, &ymin, &ymax); if (viewport->xmin>xmin) xmin = viewport->xmin; if (viewport->xmax<xmax) xmax = viewport->xmax; if (viewport->ymin>ymin) ymin = viewport->ymin; if (viewport->ymax<ymax) ymax = viewport->ymax; /* install NDC-->pixel transform for animation pixmap */ v->xmin = xmin; v->xmax = xmax; v->ymin = ymin; v->ymax = ymax; /* set the engine transform to map the specified viewport into * offscreen pixels, and get (x,y) offset from full window pixels * to offscreen pixels */ w->xmin = scalx*xmin+offx; w->xmax = scalx*xmax+offx; if (w->xmax > w->xmin) { x = (int)w->xmin; w->xmax -= w->xmin; w->xmin = 0.0; } else { x = (int)w->xmax; w->xmin -= w->xmax; w->xmax = 0.0; } w->ymin = scaly*ymin+offy; w->ymax = scaly*ymax+offy; if (w->ymax > w->ymin) { y = (int)w->ymin; w->ymax -= w->ymin; w->ymin = 0.0; } else { y = (int)w->ymax; w->ymin -= w->ymax; w->ymax = 0.0; } GpDeviceMap((Engine *)xeng); /* GetXRectangle(&xeng->e.devMap, v, &x0, &y0, &x1, &y1); x1 -= x0; y1 -= y0; */ x1 = xeng->wtop; y1 = xeng->htop; /* create the offscreen pixmap */ xeng->w = p_offscreen(xeng->win, x1, y1); if (!xeng->w) { xeng->w = xeng->win; xeng->e.transform = xeng->swapped; GpDeviceMap((Engine *)xeng); return 2; } xeng->a_width = x1; xeng->a_height = y1; xeng->a_x = x; xeng->a_y = y; /* set coordinate mapping for offscreen */ ChangeMap((Engine *)xeng); /* reset mapping clip to whole visible window */ if (xeng->wtop>0) x1 = xeng->wtop+xeng->leftMargin; else x1 = xeng->leftMargin+1; if (xeng->htop>0) y1 = xeng->htop+xeng->topMargin; else y1 = xeng->topMargin+1; xeng->clipping = 1; p_clip(xeng->win, xeng->leftMargin, xeng->topMargin, x1, y1); p_clear(xeng->w); return 0; }
void test_priorityq(void) { #define PQ_MAX_ITEMS 100 static const int input[] = { 1, 2, 3, 4, 5, 6, 7, 8, -1, 8, 7, 6, 5, 4, 3, 2, 1, -1, 8, 7, 5, 6, 1, 3, 4, 2, -1, -1 }; static const int output[] = { 1, 2, 3, 4, 5, 6, 7, 8 }; struct pq_test_item *item, items[PQ_MAX_ITEMS]; struct priorityq_item *const *all_items; unsigned int i, j; struct priorityq *pq; pool_t pool; int prev; pool = pool_alloconly_create("priorityq items", 1024); /* simple tests with popping only */ test_begin("priorityq"); for (i = 0; input[i] != -1; i++) { p_clear(pool); pq = priorityq_init(cmp_int, 1); for (j = 0; input[i] != -1; i++, j++) { test_assert(priorityq_count(pq) == j); item = p_new(pool, struct pq_test_item, 1); item->num = input[i]; priorityq_add(pq, &item->item); } all_items = priorityq_items(pq); test_assert(priorityq_count(pq) == N_ELEMENTS(output)); item = (struct pq_test_item *)all_items[0]; test_assert(item->num == output[0]); for (j = 1; j < N_ELEMENTS(output); j++) { item = (struct pq_test_item *)all_items[j]; test_assert(item->num > output[0]); test_assert(item->num <= output[N_ELEMENTS(output)-1]); } for (j = 0; j < N_ELEMENTS(output); j++) { test_assert(priorityq_count(pq) == N_ELEMENTS(output) - j); item = (struct pq_test_item *)priorityq_peek(pq); test_assert(output[j] == item->num); item = (struct pq_test_item *)priorityq_pop(pq); test_assert(output[j] == item->num); } test_assert(priorityq_count(pq) == 0); test_assert(priorityq_peek(pq) == NULL); test_assert(priorityq_pop(pq) == NULL); priorityq_deinit(&pq); } test_end(); /* randomized tests, remove elements */ test_begin("priorityq randomized"); for (i = 0; i < 100; i++) { pq = priorityq_init(cmp_int, 1); for (j = 0; j < PQ_MAX_ITEMS; j++) { items[j].num = rand(); priorityq_add(pq, &items[j].item); } for (j = 0; j < PQ_MAX_ITEMS; j++) { if (rand() % 3 == 0) { priorityq_remove(pq, &items[j].item); items[j].num = -1; } } prev = 0; while (priorityq_count(pq) > 0) { item = (struct pq_test_item *)priorityq_pop(pq); test_assert(item->num >= 0 && prev <= item->num); prev = item->num; item->num = -1; } for (j = 0; j < PQ_MAX_ITEMS; j++) { test_assert(items[j].num == -1); } priorityq_deinit(&pq); } test_end(); pool_unref(&pool); }
/** Draw a graph widget. * \param ctx The draw context. * \param w The widget node we are called from. * \param offset The offset to draw at. * \param used The already used width. * \param p A pointer to the object we're drawing onto. * \return The widget width. */ static void graph_draw(widget_t *widget, draw_context_t *ctx, area_t geometry, wibox_t *p) { int margin_top, y; graph_data_t *d = widget->data; area_t rectangle; vector_t color_gradient; if(!d->plots.len) return; /* box = the plot inside the rectangle */ if(!d->box_height) d->box_height = round(ctx->height * d->height) - 2; margin_top = round((ctx->height - (d->box_height + 2)) / 2) + geometry.y; /* draw background */ rectangle.x = geometry.x + 1; rectangle.y = margin_top + 1; rectangle.width = d->size; rectangle.height = d->box_height; draw_rectangle(ctx, rectangle, 1.0, true, &d->bg); /* for plot drawing */ rectangle.y = margin_top + d->box_height + 1; /* bottom left corner as starting point */ rectangle.width = d->size; /* rectangle.height is not used */ draw_graph_setup(ctx); /* setup some drawing options */ /* gradient begin either left or on the right of the rectangle */ if(d->grow == Right) color_gradient.x = rectangle.x + rectangle.width; else color_gradient.x = rectangle.x; for(int i = 0; i < d->plots.len; i++) { plot_t *plot = &d->plots.tab[i]; switch(plot->draw_style) { case Top_Style: color_gradient.y = rectangle.y - rectangle.height; if(plot->vertical_gradient) { color_gradient.x_offset = 0; color_gradient.y_offset = rectangle.height; } else { color_gradient.y_offset = 0; if(d->grow == Right) color_gradient.x_offset = - rectangle.width; else color_gradient.x_offset = rectangle.width; } for(y = 0; y < d->size; y++) { /* reverse values (because drawing from top) */ d->draw_from[y] = d->box_height; /* i.e. no smaller value -> from top of box */ d->draw_to[y] = d->box_height - plot->lines[y]; /* i.e. on full plot -> 0 = bottom */ } draw_graph(ctx, rectangle , d->draw_from, d->draw_to, plot->index, d->grow, color_gradient, &plot->color_start, &plot->pcolor_center, &plot->pcolor_end); break; case Bottom_Style: color_gradient.y = rectangle.y; if(plot->vertical_gradient) { color_gradient.x_offset = 0; color_gradient.y_offset = - rectangle.height; } else { color_gradient.y_offset = 0; if(d->grow == Right) color_gradient.x_offset = - rectangle.width; else color_gradient.x_offset = rectangle.width; } p_clear(d->draw_from, d->size); draw_graph(ctx, rectangle, d->draw_from, plot->lines, plot->index, d->grow, color_gradient, &plot->color_start, &plot->pcolor_center, &plot->pcolor_end); break; case Line_Style: color_gradient.y = rectangle.y; if(plot->vertical_gradient) { color_gradient.x_offset = 0; color_gradient.y_offset = -rectangle.height; } else { color_gradient.y_offset = 0; if(d->grow == Right) color_gradient.x_offset = - rectangle.width; else color_gradient.x_offset = rectangle.width; } draw_graph_line(ctx, rectangle, plot->lines, plot->index, d->grow, color_gradient, &plot->color_start, &plot->pcolor_center, &plot->pcolor_end); break; } } /* draw border (after line-drawing, what paints 0-values to the border) */ rectangle.x = geometry.x; rectangle.y = margin_top; rectangle.width = d->size + 2; rectangle.height = d->box_height + 2; draw_rectangle(ctx, rectangle, 1.0, false, &d->border_color); }
/** Newindex function for graph widget. * \param L The Lua VM state. * \param token The key token. * \return The number of elements pushed on stack. */ static int luaA_graph_newindex(lua_State *L, awesome_token_t token) { size_t len; widget_t *widget = luaA_checkudata(L, 1, &widget_class); graph_data_t *d = widget->data; const char *buf; int width; position_t pos; color_t color; switch(token) { case A_TK_HEIGHT: d->height = luaL_checknumber(L, 3); break; case A_TK_WIDTH: width = luaL_checknumber(L, 3); if(width >= 2 && width != d->width) { d->width = width; d->size = d->width - 2; p_realloc(&d->draw_from, d->size); p_realloc(&d->draw_to, d->size); for(int i = 0; i < d->plots.len; i++) { plot_t *plot = &d->plots.tab[i]; p_realloc(&plot->values, d->size); p_realloc(&plot->lines, d->size); p_clear(plot->values, d->size); p_clear(plot->lines, d->size); plot->index = 0; plot->current_max = 0; plot->max_index = 0; } } else return 0; break; case A_TK_BG: if((buf = luaL_checklstring(L, 3, &len))) { if(color_init_reply(color_init_unchecked(&color, buf, len))) d->bg = color; else return 0; } break; case A_TK_BORDER_COLOR: if((buf = luaL_checklstring(L, 3, &len))) { if(color_init_reply(color_init_unchecked(&color, buf, len))) d->border_color = color; else return 0; } break; case A_TK_GROW: buf = luaL_checklstring(L, 3, &len); switch((pos = position_fromstr(buf, len))) { case Left: case Right: d->grow = pos; break; default: return 0; } break; default: return 0; } widget_invalidate_bywidget(widget); return 0; }
static void maildir_keywords_clear(struct maildir_keywords *mk) { array_clear(&mk->list); hash_table_clear(mk->hash, TRUE); p_clear(mk->pool); }
static void test_imap_match(void) { struct test_imap_match test[] = { { "", "", IMAP_MATCH_YES }, { "a", "b", IMAP_MATCH_NO }, { "foo", "foo", IMAP_MATCH_YES }, { "foo", "foo/", IMAP_MATCH_PARENT }, { "%", "", IMAP_MATCH_YES }, { "%", "foo", IMAP_MATCH_YES }, { "%", "foo/", IMAP_MATCH_PARENT }, { "%/", "foo/", IMAP_MATCH_YES }, { "%", "foo/bar", IMAP_MATCH_PARENT }, { "%/%", "foo", IMAP_MATCH_CHILDREN }, { "%/%", "foo/", IMAP_MATCH_YES }, { "foo/bar/%", "foo", IMAP_MATCH_CHILDREN }, { "foo/bar/%", "foo/", IMAP_MATCH_CHILDREN }, { "foo*", "foo", IMAP_MATCH_YES }, { "foo*", "foo/", IMAP_MATCH_YES }, { "foo*", "fobo", IMAP_MATCH_NO }, { "*foo*", "bar/foo/", IMAP_MATCH_YES }, { "*foo*", "fobo", IMAP_MATCH_CHILDREN }, { "foo*bar", "foobar/baz", IMAP_MATCH_CHILDREN | IMAP_MATCH_PARENT }, { "*foo*", "fobo", IMAP_MATCH_CHILDREN }, { "%/%/%", "foo/", IMAP_MATCH_CHILDREN }, { "%/%o/%", "foo/", IMAP_MATCH_CHILDREN }, { "%/%o/%", "foo", IMAP_MATCH_CHILDREN }, { "inbox", "inbox", IMAP_MATCH_YES }, { "inbox", "INBOX", IMAP_MATCH_NO } }; struct test_imap_match inbox_test[] = { { "inbox", "inbox", IMAP_MATCH_YES }, { "inbox", "iNbOx", IMAP_MATCH_YES }, { "i%X", "iNbOx", IMAP_MATCH_YES }, { "%I%N%B%O%X%", "inbox", IMAP_MATCH_YES }, { "i%X/foo", "iNbOx/foo", IMAP_MATCH_YES }, { "%I%N%B%O%X%/foo", "inbox/foo", IMAP_MATCH_YES }, { "i%X/foo", "inbx/foo", IMAP_MATCH_NO } }; struct imap_match_glob *glob, *glob2; unsigned int i; pool_t pool; pool = pool_alloconly_create("imap match", 1024); /* first try tests without inboxcasing */ test_begin("imap match"); for (i = 0; i < N_ELEMENTS(test); i++) { glob = imap_match_init(pool, test[i].pattern, FALSE, '/'); test_assert(imap_match(glob, test[i].input) == test[i].result); glob2 = imap_match_dup(default_pool, glob); test_assert(imap_match_globs_equal(glob, glob2)); p_clear(pool); /* test the dup after clearing first one's memory */ test_assert(imap_match(glob2, test[i].input) == test[i].result); imap_match_deinit(&glob2); } /* inboxcasing tests */ for (i = 0; i < N_ELEMENTS(inbox_test); i++) { glob = imap_match_init(pool, inbox_test[i].pattern, TRUE, '/'); test_assert(imap_match(glob, inbox_test[i].input) == inbox_test[i].result); glob2 = imap_match_dup(default_pool, glob); test_assert(imap_match_globs_equal(glob, glob2)); p_clear(pool); /* test the dup after clearing first one's memory */ test_assert(imap_match(glob2, inbox_test[i].input) == inbox_test[i].result); imap_match_deinit(&glob2); } pool_unref(&pool); test_end(); }
/** Hello, this is main. * \param argc Who knows. * \param argv Who knows. * \return EXIT_SUCCESS I hope. */ int main(int argc, char **argv) { char *confpath = NULL; int xfd, i, screen_nbr, opt, colors_nbr; xcolor_init_request_t colors_reqs[2]; ssize_t cmdlen = 1; xdgHandle xdg; xcb_generic_event_t *event; static struct option long_options[] = { { "help", 0, NULL, 'h' }, { "version", 0, NULL, 'v' }, { "config", 1, NULL, 'c' }, { "check", 0, NULL, 'k' }, { NULL, 0, NULL, 0 } }; /* event loop watchers */ ev_io xio = { .fd = -1 }; ev_check xcheck; ev_prepare a_refresh; ev_signal sigint; ev_signal sigterm; ev_signal sighup; /* clear the globalconf structure */ p_clear(&globalconf, 1); globalconf.keygrabber = LUA_REFNIL; globalconf.mousegrabber = LUA_REFNIL; buffer_init(&globalconf.startup_errors); /* save argv */ for(i = 0; i < argc; i++) cmdlen += a_strlen(argv[i]) + 1; globalconf.argv = p_new(char, cmdlen); a_strcpy(globalconf.argv, cmdlen, argv[0]); for(i = 1; i < argc; i++) { a_strcat(globalconf.argv, cmdlen, " "); a_strcat(globalconf.argv, cmdlen, argv[i]); } /* Text won't be printed correctly otherwise */ setlocale(LC_CTYPE, ""); /* Get XDG basedir data */ xdgInitHandle(&xdg); /* init lua */ luaA_init(&xdg); /* check args */ while((opt = getopt_long(argc, argv, "vhkc:", long_options, NULL)) != -1) switch(opt) { case 'v': eprint_version(); break; case 'h': exit_help(EXIT_SUCCESS); break; case 'k': if(!luaA_parserc(&xdg, confpath, false)) { fprintf(stderr, "✘ Configuration file syntax error.\n"); return EXIT_FAILURE; } else { fprintf(stderr, "✔ Configuration file syntax OK.\n"); return EXIT_SUCCESS; } case 'c': if(a_strlen(optarg)) confpath = a_strdup(optarg); else fatal("-c option requires a file name"); break; } globalconf.loop = ev_default_loop(0); ev_timer_init(&globalconf.timer, &luaA_on_timer, 0., 0.); /* register function for signals */ ev_signal_init(&sigint, exit_on_signal, SIGINT); ev_signal_init(&sigterm, exit_on_signal, SIGTERM); ev_signal_init(&sighup, restart_on_signal, SIGHUP); ev_signal_start(globalconf.loop, &sigint); ev_signal_start(globalconf.loop, &sigterm); ev_signal_start(globalconf.loop, &sighup); ev_unref(globalconf.loop); ev_unref(globalconf.loop); ev_unref(globalconf.loop); struct sigaction sa = { .sa_handler = signal_fatal, .sa_flags = 0 }; sigemptyset(&sa.sa_mask); sigaction(SIGSEGV, &sa, 0); /* XLib sucks */ XkbIgnoreExtension(True); /* X stuff */ globalconf.display = XOpenDisplay(NULL); if (globalconf.display == NULL) fatal("cannot open display"); globalconf.default_screen = XDefaultScreen(globalconf.display); globalconf.connection = XGetXCBConnection(globalconf.display); /* Double checking then everything is OK. */ if(xcb_connection_has_error(globalconf.connection)) fatal("cannot open display"); /* Prefetch all the extensions we might need */ xcb_prefetch_extension_data(globalconf.connection, &xcb_big_requests_id); xcb_prefetch_extension_data(globalconf.connection, &xcb_test_id); xcb_prefetch_extension_data(globalconf.connection, &xcb_randr_id); xcb_prefetch_extension_data(globalconf.connection, &xcb_shape_id); /* initialize dbus */ a_dbus_init(); /* Get the file descriptor corresponding to the X connection */ xfd = xcb_get_file_descriptor(globalconf.connection); ev_io_init(&xio, &a_xcb_io_cb, xfd, EV_READ); ev_io_start(globalconf.loop, &xio); ev_check_init(&xcheck, &a_xcb_check_cb); ev_check_start(globalconf.loop, &xcheck); ev_unref(globalconf.loop); ev_prepare_init(&a_refresh, &a_refresh_cb); ev_prepare_start(globalconf.loop, &a_refresh); ev_unref(globalconf.loop); /* Grab server */ xcb_grab_server(globalconf.connection); /* Make sure there are no pending events. Since we didn't really do anything * at all yet, we will just discard all events which we received so far. * The above GrabServer should make sure no new events are generated. */ xcb_aux_sync(globalconf.connection); while ((event = xcb_poll_for_event(globalconf.connection)) != NULL) { /* Make sure errors are printed */ uint8_t response_type = XCB_EVENT_RESPONSE_TYPE(event); if(response_type == 0) event_handle(event); p_delete(&event); } for(screen_nbr = 0; screen_nbr < xcb_setup_roots_length(xcb_get_setup(globalconf.connection)); screen_nbr++) { const uint32_t select_input_val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT; /* This causes an error if some other window manager is running */ xcb_change_window_attributes(globalconf.connection, xutil_screen_get(globalconf.connection, screen_nbr)->root, XCB_CW_EVENT_MASK, &select_input_val); } /* Need to xcb_flush to validate error handler */ xcb_aux_sync(globalconf.connection); /* Process all errors in the queue if any. There can be no events yet, so if * this function returns something, it must be an error. */ if (xcb_poll_for_event(globalconf.connection) != NULL) fatal("another window manager is already running"); /* Prefetch the maximum request length */ xcb_prefetch_maximum_request_length(globalconf.connection); /* check for xtest extension */ const xcb_query_extension_reply_t *xtest_query; xtest_query = xcb_get_extension_data(globalconf.connection, &xcb_test_id); globalconf.have_xtest = xtest_query->present; /* Allocate the key symbols */ globalconf.keysyms = xcb_key_symbols_alloc(globalconf.connection); xcb_get_modifier_mapping_cookie_t xmapping_cookie = xcb_get_modifier_mapping_unchecked(globalconf.connection); /* init atom cache */ atoms_init(globalconf.connection); /* init screens information */ screen_scan(); /* init default font and colors */ colors_reqs[0] = xcolor_init_unchecked(&globalconf.colors.fg, "black", sizeof("black") - 1); colors_reqs[1] = xcolor_init_unchecked(&globalconf.colors.bg, "white", sizeof("white") - 1); globalconf.font = draw_font_new("sans 8"); for(colors_nbr = 0; colors_nbr < 2; colors_nbr++) xcolor_init_reply(colors_reqs[colors_nbr]); xutil_lock_mask_get(globalconf.connection, xmapping_cookie, globalconf.keysyms, &globalconf.numlockmask, &globalconf.shiftlockmask, &globalconf.capslockmask, &globalconf.modeswitchmask); /* Get the window tree associated to this screen */ const int screen_max = xcb_setup_roots_length(xcb_get_setup(globalconf.connection)); xcb_query_tree_cookie_t tree_c[screen_max]; /* do this only for real screen */ for(screen_nbr = 0; screen_nbr < screen_max; screen_nbr++) { /* select for events */ const uint32_t change_win_vals[] = { XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT | XCB_EVENT_MASK_SUBSTRUCTURE_NOTIFY | XCB_EVENT_MASK_ENTER_WINDOW | XCB_EVENT_MASK_LEAVE_WINDOW | XCB_EVENT_MASK_STRUCTURE_NOTIFY | XCB_EVENT_MASK_PROPERTY_CHANGE | XCB_EVENT_MASK_BUTTON_PRESS | XCB_EVENT_MASK_BUTTON_RELEASE | XCB_EVENT_MASK_FOCUS_CHANGE }; tree_c[screen_nbr] = xcb_query_tree_unchecked(globalconf.connection, xutil_screen_get(globalconf.connection, screen_nbr)->root); xcb_change_window_attributes(globalconf.connection, xutil_screen_get(globalconf.connection, screen_nbr)->root, XCB_CW_EVENT_MASK, change_win_vals); ewmh_init(screen_nbr); systray_init(screen_nbr); } /* init spawn (sn) */ spawn_init(); /* we will receive events, stop grabbing server */ xcb_ungrab_server(globalconf.connection); /* Parse and run configuration file */ if (!luaA_parserc(&xdg, confpath, true)) fatal("couldn't find any rc file"); scan(tree_c); xcb_flush(globalconf.connection); /* main event loop */ ev_loop(globalconf.loop, 0); /* cleanup event loop */ ev_ref(globalconf.loop); ev_check_stop(globalconf.loop, &xcheck); ev_ref(globalconf.loop); ev_prepare_stop(globalconf.loop, &a_refresh); ev_ref(globalconf.loop); ev_io_stop(globalconf.loop, &xio); awesome_atexit(false); return EXIT_SUCCESS; }
int master_service_settings_read(struct master_service *service, const struct master_service_settings_input *input, struct master_service_settings_output *output_r, const char **error_r) { ARRAY(const struct setting_parser_info *) all_roots; const struct setting_parser_info *tmp_root; struct setting_parser_context *parser; struct istream *istream; const char *path = NULL, *error; void **sets; unsigned int i; int ret, fd = -1; time_t now, timeout; bool use_environment, retry; memset(output_r, 0, sizeof(*output_r)); if (getenv("DOVECONF_ENV") == NULL && (service->flags & MASTER_SERVICE_FLAG_NO_CONFIG_SETTINGS) == 0) { retry = service->config_fd != -1; for (;;) { fd = master_service_open_config(service, input, &path, error_r); if (fd == -1) { if (errno == EACCES) output_r->permission_denied = TRUE; return -1; } if (config_send_request(service, input, fd, path, error_r) == 0) break; i_close_fd(&fd); if (!retry) { config_exec_fallback(service, input); return -1; } /* config process died, retry connecting */ retry = FALSE; } } if (service->set_pool != NULL) { if (service->set_parser != NULL) settings_parser_deinit(&service->set_parser); p_clear(service->set_pool); } else { service->set_pool = pool_alloconly_create("master service settings", 16384); } p_array_init(&all_roots, service->set_pool, 8); tmp_root = &master_service_setting_parser_info; array_append(&all_roots, &tmp_root, 1); if (service->want_ssl_settings) { tmp_root = &master_service_ssl_setting_parser_info; array_append(&all_roots, &tmp_root, 1); } if (input->roots != NULL) { for (i = 0; input->roots[i] != NULL; i++) array_append(&all_roots, &input->roots[i], 1); } parser = settings_parser_init_list(service->set_pool, array_idx(&all_roots, 0), array_count(&all_roots), SETTINGS_PARSER_FLAG_IGNORE_UNKNOWN_KEYS); if (fd != -1) { istream = i_stream_create_fd(fd, (size_t)-1); now = time(NULL); timeout = now + CONFIG_READ_TIMEOUT_SECS; do { alarm(timeout - now); ret = config_read_reply_header(istream, path, service->set_pool, input, output_r, error_r); if (ret == 0) { ret = settings_parse_stream_read(parser, istream); if (ret < 0) *error_r = settings_parser_get_error(parser); } alarm(0); if (ret <= 0) break; /* most likely timed out, but just in case some other signal was delivered early check if we need to continue */ now = time(NULL); } while (now < timeout); i_stream_unref(&istream); if (ret != 0) { if (ret > 0) { *error_r = t_strdup_printf( "Timeout reading config from %s", path); } i_close_fd(&fd); config_exec_fallback(service, input); settings_parser_deinit(&parser); return -1; } if ((service->flags & MASTER_SERVICE_FLAG_KEEP_CONFIG_OPEN) != 0 && service->config_fd == -1 && input->config_path == NULL) service->config_fd = fd; else i_close_fd(&fd); use_environment = FALSE; } else { use_environment = TRUE; } if (use_environment || service->keep_environment) { if (settings_parse_environ(parser) < 0) { *error_r = t_strdup(settings_parser_get_error(parser)); settings_parser_deinit(&parser); return -1; } } if (array_is_created(&service->config_overrides)) { if (master_service_apply_config_overrides(service, parser, error_r) < 0) { settings_parser_deinit(&parser); return -1; } } if (!settings_parser_check(parser, service->set_pool, &error)) { *error_r = t_strdup_printf("Invalid settings: %s", error); settings_parser_deinit(&parser); return -1; } sets = settings_parser_get_list(parser); service->set = sets[0]; service->set_parser = parser; if (service->set->version_ignore && (service->flags & MASTER_SERVICE_FLAG_STANDALONE) != 0) { /* running standalone. we want to ignore plugin versions. */ service->version_string = NULL; } if (service->set->shutdown_clients) master_service_set_die_with_master(master_service, TRUE); /* if we change any settings afterwards, they're in expanded form. especially all settings from userdb are already expanded. */ settings_parse_set_expanded(service->set_parser, TRUE); return 0; }
/** The __newindex method for a textbox object. * \param L The Lua VM state. * \param token The key token. * \return The number of elements pushed on stack. */ static int luaA_textbox_newindex(lua_State *L, awesome_token_t token) { size_t len = 0; widget_t *widget = luaA_checkudata(L, 1, &widget_class); const char *buf = NULL; textbox_data_t *d = widget->data; switch(token) { case A_TK_BG_ALIGN: buf = luaL_checklstring(L, 3, &len); d->bg_align = draw_align_fromstr(buf, len); break; case A_TK_BG_RESIZE: d->bg_resize = luaA_checkboolean(L, 3); break; case A_TK_BG_IMAGE: luaA_checkudataornil(L, -1, &image_class); luaA_object_unref_item(L, 1, d->bg_image); d->bg_image = luaA_object_ref_item(L, 1, 3); break; case A_TK_BG: if(lua_isnil(L, 3)) p_clear(&d->bg, 1); else if((buf = luaL_checklstring(L, 3, &len))) color_init_reply(color_init_unchecked(&d->bg, buf, len)); break; case A_TK_ALIGN: if((buf = luaL_checklstring(L, 3, &len))) d->align = draw_align_fromstr(buf, len); break; case A_TK_VALIGN: if((buf = luaL_checklstring(L, 3, &len))) d->valign = draw_align_fromstr(buf, len); break; case A_TK_BORDER_COLOR: if((buf = luaL_checklstring(L, 3, &len))) color_init_reply(color_init_unchecked(&d->border.color, buf, len)); break; case A_TK_BORDER_WIDTH: d->border.width = luaL_checknumber(L, 3); break; case A_TK_TEXT: if(lua_isnil(L, 3) || (buf = luaL_checklstring(L, 3, &len))) { /* delete */ draw_text_context_wipe(&d->data); p_clear(&d->data, 1); if(buf) { char *text; ssize_t tlen; /* if text has been converted to UTF-8 */ if(draw_iso2utf8(buf, len, &text, &tlen)) { draw_text_context_init(&d->data, text, tlen); p_delete(&text); } else draw_text_context_init(&d->data, buf, len); d->extents = draw_text_extents(&d->data); } else p_clear(&d->extents, 1); } break; case A_TK_WIDTH: d->width = luaL_checknumber(L, 3); break; case A_TK_HEIGHT: d->height = luaL_checknumber(L, 3); break; case A_TK_WRAP: if((buf = luaL_checklstring(L, 3, &len))) switch(a_tokenize(buf, len)) { case A_TK_WORD: d->wrap = PANGO_WRAP_WORD; break; case A_TK_CHAR: d->wrap = PANGO_WRAP_CHAR; break; case A_TK_WORD_CHAR: d->wrap = PANGO_WRAP_WORD_CHAR; break; default: break; } break; case A_TK_ELLIPSIZE: if((buf = luaL_checklstring(L, 3, &len))) switch(a_tokenize(buf, len)) { case A_TK_START: d->ellip = PANGO_ELLIPSIZE_START; break; case A_TK_MIDDLE: d->ellip = PANGO_ELLIPSIZE_MIDDLE; break; case A_TK_END: d->ellip = PANGO_ELLIPSIZE_END; break; default: break; } break; default: return 0; } widget_invalidate_bywidget(widget); return 0; }
/* * scalar point multiplication * P0 = n*basepoint * pointArray is array of basepoint, pointArray[0] = basepoint, pointArray[1] = 2*basepoint ... */ void ecc_win_mul ( point_t* P0, NN_DIGIT* n, point_t* pointArray ) { int16_t i, tmp; int8_t j; NN_DIGIT windex; NN_DIGIT Z0[NUMWORDS]; NN_DIGIT Z1[NUMWORDS]; #ifndef REPEAT_DOUBLE int8_t k; #endif p_clear ( P0 ); /* Convert to Jprojective coordinate */ NN_AssignZero ( Z0, NUMWORDS ); NN_AssignZero ( Z1, NUMWORDS ); Z1[0] = 0x01; tmp = NN_Digits ( n, NUMWORDS ); for ( i = tmp - 1; i >= 0; i-- ) { for ( j = NN_DIGIT_BITS/W_BITS - 1; j >= 0; j-- ) { #ifndef REPEAT_DOUBLE for ( k = 0; k < W_BITS; k++ ) { ecc_dbl_proj ( P0, Z0, P0, Z0 ); } #else ecc_m_dbl_projective ( P0, Z0, W_BITS ); #endif windex = mask[j] & n[i]; if ( windex ) { windex = windex >> ( j*W_BITS ); #ifdef ADD_MIX c_add_mix ( P0, Z0, P0, Z0, & ( pointArray[windex-1] ) ); #else ecc_add_proj ( P0, Z0, P0, Z0, & ( pointArray[windex-1] ), Z1 ); #endif } } } /* Convert back to affine coordinate */ if ( !Z_is_one ( Z0 ) ) { NN_ModInv ( Z1, Z0, param.p, NUMWORDS ); NN_ModMultOpt ( Z0, Z1, Z1, param.p, param.omega, NUMWORDS ); NN_ModMultOpt ( P0->x, P0->x, Z0, param.p, param.omega, NUMWORDS ); NN_ModMultOpt ( Z0, Z0, Z1, param.p, param.omega, NUMWORDS ); NN_ModMultOpt ( P0->y, P0->y, Z0, param.p, param.omega, NUMWORDS ); } /* int ii; for (ii =0; ii < NUMWORDS; ii++) { printf("base %u p0x %u p0y %u\n", pointArray->x[ii], P0->x[ii], P0->y[ii]); }*/ }
void client_command_free(struct client_command_context **_cmd) { struct client_command_context *cmd = *_cmd; struct client *client = cmd->client; enum client_command_state state = cmd->state; *_cmd = NULL; i_assert(client->output_cmd_lock == NULL); /* reset input idle time because command output might have taken a long time and we don't want to disconnect client immediately then */ client->last_input = ioloop_time; timeout_reset(client->to_idle); if (cmd->cancel) { cmd->cancel = FALSE; client_send_tagline(cmd, "NO Command cancelled."); } if (!cmd->param_error) client->bad_counter = 0; if (client->input_lock == cmd) client->input_lock = NULL; if (client->mailbox_change_lock == cmd) client->mailbox_change_lock = NULL; if (cmd->parser != NULL) { if (client->free_parser == NULL) { imap_parser_reset(cmd->parser); client->free_parser = cmd->parser; } else { imap_parser_unref(&cmd->parser); } } client->command_queue_size--; DLLIST_REMOVE(&client->command_queue, cmd); cmd = NULL; if (client->command_queue == NULL) { /* no commands left in the queue, we can clear the pool */ p_clear(client->command_pool); if (client->to_idle_output != NULL) timeout_remove(&client->to_idle_output); } imap_client_notify_command_freed(client); imap_refresh_proctitle(); /* if command finished from external event, check input for more unhandled commands since we may not be executing from client_input or client_output. */ if (state == CLIENT_COMMAND_STATE_WAIT_EXTERNAL && !client->disconnected) { client_add_missing_io(client); if (client->to_delayed_input == NULL) { client->to_delayed_input = timeout_add(0, client_input, client); } } }
/** Hello, this is main. * \param argc Who knows. * \param argv Who knows. * \return EXIT_SUCCESS I hope. */ int main(int argc, char **argv) { char *confpath = NULL; int xfd, i, opt; ssize_t cmdlen = 1; xdgHandle xdg; bool no_argb = false; xcb_generic_event_t *event; xcb_query_tree_cookie_t tree_c; static struct option long_options[] = { { "help", 0, NULL, 'h' }, { "version", 0, NULL, 'v' }, { "config", 1, NULL, 'c' }, { "check", 0, NULL, 'k' }, { "no-argb", 0, NULL, 'a' }, { NULL, 0, NULL, 0 } }; /* event loop watchers */ ev_io xio = { .fd = -1 }; ev_check xcheck; ev_prepare a_refresh; ev_signal sigint; ev_signal sigterm; ev_signal sighup; /* clear the globalconf structure */ p_clear(&globalconf, 1); globalconf.keygrabber = LUA_REFNIL; globalconf.mousegrabber = LUA_REFNIL; buffer_init(&globalconf.startup_errors); /* save argv */ for(i = 0; i < argc; i++) cmdlen += a_strlen(argv[i]) + 1; awesome_argv = p_new(char, cmdlen); a_strcpy(awesome_argv, cmdlen, argv[0]); for(i = 1; i < argc; i++) { a_strcat(awesome_argv, cmdlen, " "); a_strcat(awesome_argv, cmdlen, argv[i]); } /* Text won't be printed correctly otherwise */ setlocale(LC_CTYPE, ""); /* Get XDG basedir data */ xdgInitHandle(&xdg); /* init lua */ luaA_init(&xdg); /* check args */ while((opt = getopt_long(argc, argv, "vhkc:a", long_options, NULL)) != -1) switch(opt) { case 'v': eprint_version(); break; case 'h': exit_help(EXIT_SUCCESS); break; case 'k': if(!luaA_parserc(&xdg, confpath, false)) { fprintf(stderr, "✘ Configuration file syntax error.\n"); return EXIT_FAILURE; } else { fprintf(stderr, "✔ Configuration file syntax OK.\n"); return EXIT_SUCCESS; } case 'c': if(a_strlen(optarg)) confpath = a_strdup(optarg); else fatal("-c option requires a file name"); break; case 'a': no_argb = true; break; } globalconf.loop = ev_default_loop(EVFLAG_NOSIGFD); /* register function for signals */ ev_signal_init(&sigint, exit_on_signal, SIGINT); ev_signal_init(&sigterm, exit_on_signal, SIGTERM); ev_signal_init(&sighup, restart_on_signal, SIGHUP); ev_signal_start(globalconf.loop, &sigint); ev_signal_start(globalconf.loop, &sigterm); ev_signal_start(globalconf.loop, &sighup); ev_unref(globalconf.loop); ev_unref(globalconf.loop); ev_unref(globalconf.loop); struct sigaction sa = { .sa_handler = signal_fatal, .sa_flags = 0 }; sigemptyset(&sa.sa_mask); sigaction(SIGSEGV, &sa, 0); /* X stuff */ globalconf.connection = xcb_connect(NULL, &globalconf.default_screen); if(xcb_connection_has_error(globalconf.connection)) fatal("cannot open display"); globalconf.screen = xcb_aux_get_screen(globalconf.connection, globalconf.default_screen); /* FIXME The following two assignments were swapped on purpose */ if(!no_argb) globalconf.visual = a_default_visual(globalconf.screen); if(!globalconf.visual) globalconf.visual = a_argb_visual(globalconf.screen); globalconf.default_depth = a_visual_depth(globalconf.screen, globalconf.visual->visual_id); globalconf.default_cmap = globalconf.screen->default_colormap; if(globalconf.default_depth != globalconf.screen->root_depth) { // We need our own color map if we aren't using the default depth globalconf.default_cmap = xcb_generate_id(globalconf.connection); xcb_create_colormap(globalconf.connection, XCB_COLORMAP_ALLOC_NONE, globalconf.default_cmap, globalconf.screen->root, globalconf.visual->visual_id); } /* Prefetch all the extensions we might need */ xcb_prefetch_extension_data(globalconf.connection, &xcb_big_requests_id); xcb_prefetch_extension_data(globalconf.connection, &xcb_test_id); xcb_prefetch_extension_data(globalconf.connection, &xcb_randr_id); xcb_prefetch_extension_data(globalconf.connection, &xcb_xinerama_id); /* initialize dbus */ a_dbus_init(); /* Get the file descriptor corresponding to the X connection */ xfd = xcb_get_file_descriptor(globalconf.connection); ev_io_init(&xio, &a_xcb_io_cb, xfd, EV_READ); ev_io_start(globalconf.loop, &xio); ev_check_init(&xcheck, &a_xcb_check_cb); ev_check_start(globalconf.loop, &xcheck); ev_unref(globalconf.loop); ev_prepare_init(&a_refresh, &a_refresh_cb); ev_prepare_start(globalconf.loop, &a_refresh); ev_unref(globalconf.loop); /* Grab server */ xcb_grab_server(globalconf.connection); /* Make sure there are no pending events. Since we didn't really do anything * at all yet, we will just discard all events which we received so far. * The above GrabServer should make sure no new events are generated. */ xcb_aux_sync(globalconf.connection); while ((event = xcb_poll_for_event(globalconf.connection)) != NULL) { /* Make sure errors are printed */ uint8_t response_type = XCB_EVENT_RESPONSE_TYPE(event); if(response_type == 0) event_handle(event); p_delete(&event); } { const uint32_t select_input_val = XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT; /* This causes an error if some other window manager is running */ xcb_change_window_attributes(globalconf.connection, globalconf.screen->root, XCB_CW_EVENT_MASK, &select_input_val); } /* Need to xcb_flush to validate error handler */ xcb_aux_sync(globalconf.connection); /* Process all errors in the queue if any. There can be no events yet, so if * this function returns something, it must be an error. */ if (xcb_poll_for_event(globalconf.connection) != NULL) fatal("another window manager is already running"); /* Prefetch the maximum request length */ xcb_prefetch_maximum_request_length(globalconf.connection); /* check for xtest extension */ const xcb_query_extension_reply_t *xtest_query; xtest_query = xcb_get_extension_data(globalconf.connection, &xcb_test_id); globalconf.have_xtest = xtest_query->present; /* Allocate the key symbols */ globalconf.keysyms = xcb_key_symbols_alloc(globalconf.connection); xcb_get_modifier_mapping_cookie_t xmapping_cookie = xcb_get_modifier_mapping_unchecked(globalconf.connection); /* init atom cache */ atoms_init(globalconf.connection); /* init screens information */ screen_scan(); xutil_lock_mask_get(globalconf.connection, xmapping_cookie, globalconf.keysyms, &globalconf.numlockmask, &globalconf.shiftlockmask, &globalconf.capslockmask, &globalconf.modeswitchmask); /* do this only for real screen */ ewmh_init(); systray_init(); /* init spawn (sn) */ spawn_init(); /* The default GC is just a newly created associated with a window with * depth globalconf.default_depth */ xcb_window_t tmp_win = xcb_generate_id(globalconf.connection); globalconf.gc = xcb_generate_id(globalconf.connection); xcb_create_window(globalconf.connection, globalconf.default_depth, tmp_win, globalconf.screen->root, -1, -1, 1, 1, 0, XCB_COPY_FROM_PARENT, globalconf.visual->visual_id, XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL | XCB_CW_COLORMAP, (const uint32_t []) { globalconf.screen->black_pixel, globalconf.screen->black_pixel, globalconf.default_cmap }); xcb_create_gc(globalconf.connection, globalconf.gc, tmp_win, XCB_GC_FOREGROUND | XCB_GC_BACKGROUND, (const uint32_t[]) { globalconf.screen->black_pixel, globalconf.screen->white_pixel }); xcb_destroy_window(globalconf.connection, tmp_win); /* Get the window tree associated to this screen */ tree_c = xcb_query_tree_unchecked(globalconf.connection, globalconf.screen->root); xcb_change_window_attributes(globalconf.connection, globalconf.screen->root, XCB_CW_EVENT_MASK, ROOT_WINDOW_EVENT_MASK); /* we will receive events, stop grabbing server */ xcb_ungrab_server(globalconf.connection); /* Parse and run configuration file */ if (!luaA_parserc(&xdg, confpath, true)) fatal("couldn't find any rc file"); p_delete(&confpath); xdgWipeHandle(&xdg); /* scan existing windows */ scan(tree_c); xcb_flush(globalconf.connection); /* main event loop */ ev_loop(globalconf.loop, 0); /* cleanup event loop */ ev_ref(globalconf.loop); ev_check_stop(globalconf.loop, &xcheck); ev_ref(globalconf.loop); ev_prepare_stop(globalconf.loop, &a_refresh); ev_ref(globalconf.loop); ev_io_stop(globalconf.loop, &xio); awesome_atexit(false); return EXIT_SUCCESS; }