void button_new_config_callback(GtkWidget *widget, gpointer data) { Distribution_Tab *tab = data; Distribution_Dialog *dist_dialog = g_slice_alloc0(sizeof (Distribution_Dialog)); dist_dialog->tmp_prefs = g_slice_alloc0(sizeof (XKB_Preferences)); GtkWidget *dialog = build_dialog_layout_variant_management(NULL, dist_dialog); gint result = gtk_dialog_run(GTK_DIALOG(dialog)); Layout *layout; Variant *variant; if ((result == GTK_RESPONSE_ACCEPT) && (dist_dialog->active_layout != NULL && dist_dialog->active_variant != NULL)) { layout = xkb_rules_get_layout(rules, NULL, dist_dialog->active_layout); variant = xkb_rules_layout_get_variant(layout, NULL, dist_dialog->active_variant); xkb_preferences_layout_variant_append(user_prefs, layout->id, variant->id); list_store_update(tab->store); } else { } /* TODO: Memory clean must be performed */ xkb_preferences_set_to_env(user_prefs); gtk_widget_destroy(dialog); }
static BotCTransPath * _path_new(int nlinks) { BotCTransPath * path = g_slice_new(BotCTransPath); path->nlinks = nlinks; path->links = g_slice_alloc0(nlinks*sizeof(BotCTransLink*)); path->invert = g_slice_alloc0(nlinks*sizeof(int)); return path; }
void salut_set_gesture_to_track (Salut *self, GestId id, void (*callback) (gpointer), gpointer callback_data) { if (self->gest_id == id) empty_gesture_list (self->gesture_list, self->gesture_list_length); else { free_gesture_list (self->gesture_list, self->gesture_list_length); self->gesture_list = NULL; self->gesture_list_length = 0; } self->gesture_index = 0; switch (id) { case NONE: case TOTAL_GESTURES: case HAND_METAL: case HAND_EAST_COAST: case HAND_INDIAN: break; case BOW: self->gesture_list_length = 3; self->gesture_list = g_slice_alloc0 (self->gesture_list_length * sizeof (SkeltrackJoint)); break; case HAND_WAVE: self->gesture_list_length = 6; self->gesture_list = g_slice_alloc0 (self->gesture_list_length * sizeof (SkeltrackJoint)); break; case CURTSY: self->gesture_list_length = 2; self->gesture_list = g_slice_alloc0 (self->gesture_list_length * sizeof (SkeltrackJoint)); break; case KISS: self->gesture_list_length = 3; self->gesture_list = g_slice_alloc0 (self->gesture_list_length * sizeof (SkeltrackJoint)); break; } self->gest_id = id; self->callback = callback; self->callback_data = callback_data; }
static struct rspamd_lua_cryptobox_hash * rspamd_lua_hash_create (const gchar *type) { struct rspamd_lua_cryptobox_hash *h; h = g_slice_alloc0 (sizeof (*h)); if (type) { if (g_ascii_strcasecmp (type, "md5") == 0) { h->is_ssl = TRUE; h->c = EVP_MD_CTX_create (); EVP_DigestInit (h->c, EVP_md5 ()); goto ret; } else if (g_ascii_strcasecmp (type, "sha1") == 0 || g_ascii_strcasecmp (type, "sha") == 0) { h->is_ssl = TRUE; h->c = EVP_MD_CTX_create (); EVP_DigestInit (h->c, EVP_sha1 ()); goto ret; } else if (g_ascii_strcasecmp (type, "sha256") == 0) { h->is_ssl = TRUE; h->c = EVP_MD_CTX_create (); EVP_DigestInit (h->c, EVP_sha256 ()); goto ret; } else if (g_ascii_strcasecmp (type, "sha512") == 0) { h->is_ssl = TRUE; h->c = EVP_MD_CTX_create (); EVP_DigestInit (h->c, EVP_sha512 ()); goto ret; } else if (g_ascii_strcasecmp (type, "sha384") == 0) { h->is_ssl = TRUE; h->c = EVP_MD_CTX_create (); EVP_DigestInit (h->c, EVP_sha384 ()); goto ret; } } h->h = g_slice_alloc0 (sizeof (*h->h)); rspamd_cryptobox_hash_init (h->h, NULL, 0); ret: return h; }
gpointer rspamd_redis_init (struct rspamd_stat_ctx *ctx, struct rspamd_config *cfg, struct rspamd_statfile *st) { struct redis_stat_ctx *backend; struct rspamd_statfile_config *stf = st->stcf; struct rspamd_redis_stat_elt *st_elt; const ucl_object_t *obj; gboolean ret = FALSE; backend = g_slice_alloc0 (sizeof (*backend)); /* First search in backend configuration */ obj = ucl_object_lookup (st->classifier->cfg->opts, "backend"); if (obj != NULL && ucl_object_type (obj) == UCL_OBJECT) { ret = rspamd_redis_try_ucl (backend, obj, cfg, stf->symbol); } /* Now try statfiles config */ if (!ret) { ret = rspamd_redis_try_ucl (backend, stf->opts, cfg, stf->symbol); } /* Now try classifier config */ if (!ret) { ret = rspamd_redis_try_ucl (backend, st->classifier->cfg->opts, cfg, stf->symbol); } if (!ret) { msg_err_config ("cannot init redis backend for %s", stf->symbol); g_slice_free1 (sizeof (*backend), backend); return NULL; } stf->clcf->flags |= RSPAMD_FLAG_CLASSIFIER_INCREMENTING_BACKEND; backend->stcf = stf; st_elt = g_slice_alloc0 (sizeof (*st_elt)); st_elt->ev_base = ctx->ev_base; st_elt->ctx = backend; backend->stat_elt = rspamd_stat_ctx_register_async ( rspamd_redis_async_stat_cb, rspamd_redis_async_stat_fin, st_elt, REDIS_STAT_TIMEOUT); st_elt->async = backend->stat_elt; return (gpointer)backend; }
struct rspamd_re_runtime * rspamd_re_cache_runtime_new (struct rspamd_re_cache *cache) { struct rspamd_re_runtime *rt; g_assert (cache != NULL); rt = g_slice_alloc0 (sizeof (*rt)); rt->cache = cache; REF_RETAIN (cache); rt->checked = g_slice_alloc0 (NBYTES (cache->nre)); rt->results = g_slice_alloc0 (cache->nre); return rt; }
rspamd_regexp_t * rspamd_re_cache_add (struct rspamd_re_cache *cache, rspamd_regexp_t *re, enum rspamd_re_type type, gpointer type_data, gsize datalen) { guint64 class_id; struct rspamd_re_class *re_class; rspamd_regexp_t *nre; struct rspamd_re_cache_elt *elt; g_assert (cache != NULL); g_assert (re != NULL); class_id = rspamd_re_cache_class_id (type, type_data, datalen); re_class = g_hash_table_lookup (cache->re_classes, &class_id); if (re_class == NULL) { re_class = g_slice_alloc0 (sizeof (*re_class)); re_class->id = class_id; re_class->type_len = datalen; re_class->type = type; re_class->re = g_hash_table_new_full (rspamd_regexp_hash, rspamd_regexp_equal, NULL, (GDestroyNotify)rspamd_regexp_unref); if (datalen > 0) { re_class->type_data = g_slice_alloc (datalen); memcpy (re_class->type_data, type_data, datalen); } g_hash_table_insert (cache->re_classes, &re_class->id, re_class); } if ((nre = g_hash_table_lookup (re_class->re, rspamd_regexp_get_id (re))) == NULL) { /* * We set re id based on the global position in the cache */ elt = g_slice_alloc0 (sizeof (*elt)); /* One ref for re_class */ nre = rspamd_regexp_ref (re); rspamd_regexp_set_cache_id (re, cache->nre++); /* One ref for cache */ elt->re = rspamd_regexp_ref (re); g_ptr_array_add (cache->re, elt); rspamd_regexp_set_class (re, re_class); g_hash_table_insert (re_class->re, rspamd_regexp_get_id (nre), nre); } return nre; }
struct MessageNewViewData * message_new_view_show(struct Window *win, GHashTable * options) { struct MessageNewViewData *data = g_slice_alloc0(sizeof(struct MessageNewViewData)); data->win = win; data->mode = MODE_CONTENT; data->content = NULL; data->recipients = g_ptr_array_new(); data->messages_sent = 0; if (options != NULL) { char *recipient = g_hash_table_lookup(options, "recipient"); if (recipient != NULL) { char *name = g_hash_table_lookup(options, "name"); if (!name || !*name) name = "Number"; GHashTable *properties = g_hash_table_new_full(g_str_hash, g_str_equal, free, free); g_hash_table_insert(properties, strdup("name"), strdup(name)); g_hash_table_insert(properties, strdup("number"), strdup(recipient)); g_ptr_array_add(data->recipients, properties); } } window_frame_show(win, data, frame_content_show, frame_content_hide); window_show(win); return data; }
void * _pygi_boxed_alloc (GIBaseInfo *info, gsize *size_out) { gsize size; /* FIXME: Remove when bgo#622711 is fixed */ if (g_registered_type_info_get_g_type (info) == G_TYPE_VALUE) { size = sizeof (GValue); } else { switch (g_base_info_get_type (info)) { case GI_INFO_TYPE_UNION: size = g_union_info_get_size ( (GIUnionInfo *) info); break; case GI_INFO_TYPE_BOXED: case GI_INFO_TYPE_STRUCT: size = g_struct_info_get_size ( (GIStructInfo *) info); break; default: PyErr_Format (PyExc_TypeError, "info should be Boxed or Union, not '%d'", g_base_info_get_type (info)); return NULL; } } if( size_out != NULL) *size_out = size; return g_slice_alloc0 (size); }
static gchar * lua_map_read (rspamd_mempool_t *pool, gchar *chunk, gint len, struct map_cb_data *data) { struct lua_map_callback_data *cbdata, *old; if (data->cur_data == NULL) { cbdata = g_slice_alloc0 (sizeof (*cbdata)); old = (struct lua_map_callback_data *)data->prev_data; cbdata->L = old->L; cbdata->ref = old->ref; data->cur_data = cbdata; } else { cbdata = (struct lua_map_callback_data *)data->cur_data; } if (cbdata->data == NULL) { cbdata->data = g_string_new_len (chunk, len); } else { g_string_append_len (cbdata->data, chunk, len); } return NULL; }
// --------------------------------------------------------------------------- // UgPlugin : UgPlugin is a base structure for downloading. // UgPlugin* ug_plugin_new (const UgPluginInterface* iface, UgDataset* dataset) { UgPlugin* plugin; UgPluginInitFunc init; // plugin = g_malloc0 (iface->instance_size); plugin = g_slice_alloc0 (iface->instance_size); // initialize base data plugin->iface = iface; g_mutex_init (&plugin->lock); // plugin->state = UG_STATE_NULL; plugin->ref_count = 1; init = iface->init; if (init) { // If plugin initial failed, free resource and return NULL. if (init (plugin, dataset) == FALSE) { g_mutex_clear (&plugin->lock); // g_free (plugin); g_slice_free1 (iface->instance_size, plugin); return NULL; } } return plugin; }
void rspamd_stat_init (struct rspamd_config *cfg) { guint i; if (stat_ctx == NULL) { stat_ctx = g_slice_alloc0 (sizeof (*stat_ctx)); } stat_ctx->backends = stat_backends; stat_ctx->backends_count = G_N_ELEMENTS (stat_backends); stat_ctx->classifiers = stat_classifiers; stat_ctx->classifiers_count = G_N_ELEMENTS (stat_classifiers); stat_ctx->tokenizers = stat_tokenizers; stat_ctx->tokenizers_count = G_N_ELEMENTS (stat_tokenizers); stat_ctx->caches = stat_caches; stat_ctx->caches_count = G_N_ELEMENTS (stat_caches); /* Init backends */ for (i = 0; i < stat_ctx->backends_count; i ++) { stat_ctx->backends[i].ctx = stat_ctx->backends[i].init (stat_ctx, cfg); msg_debug ("added backend %s", stat_ctx->backends[i].name); } /* Init caches */ for (i = 0; i < stat_ctx->caches_count; i ++) { stat_ctx->caches[i].ctx = stat_ctx->caches[i].init (stat_ctx, cfg); msg_debug ("added cache %s", stat_ctx->caches[i].name); } }
static void digital_clock_init(DigitalClock * dclock) { DigitalClockPriv *priv; GtkWidget *w = GTK_WIDGET(dclock); dclock->priv = DIGITAL_CLOCK_GET_PRIV(dclock); priv = dclock->priv; priv->x = priv->y = 0; priv->width = priv->height = -1; priv->fsiz = 0; priv->mode12 = TRUE; priv->time_val=g_slice_alloc0(LENTIMESTR); // g_signal_connect (G_OBJECT (dclock), "draw", G_CALLBACK (_draw), dclock); dclock->priv->timeoutid = g_timeout_add(TimeOutVal, (GSourceFunc) flushtime_cb, dclock); GtkStyleContext *stylecontext = gtk_widget_get_style_context(w); gtk_style_context_add_class(stylecontext, GTK_STYLE_CLASS_BUTTON); gtk_style_context_add_class(stylecontext, "suggested-action"); gtk_widget_set_hexpand(w,TRUE); gtk_widget_set_vexpand(w,TRUE); }
static void tidy_grid_real_add (ClutterContainer *container, ClutterActor *actor) { TidyGridPrivate *priv; TidyGridActorData *data; g_return_if_fail (TIDY_IS_GRID (container)); priv = TIDY_GRID (container)->priv; g_object_ref (actor); clutter_actor_set_parent (actor, CLUTTER_ACTOR (container)); data = g_slice_alloc0 (sizeof (TidyGridActorData)); priv->list = g_list_append (priv->list, actor); g_hash_table_insert (priv->hash_table, actor, data); g_signal_emit_by_name (container, "actor-added", actor); clutter_actor_queue_relayout (CLUTTER_ACTOR (container)); g_object_unref (actor); }
static GstPad * fs_funnel_request_new_pad (GstElement * element, GstPadTemplate * templ, const gchar * name) { GstPad *sinkpad; FsFunnelPadPrivate *priv = g_slice_alloc0 (sizeof(FsFunnelPadPrivate)); GST_DEBUG_OBJECT (element, "requesting pad"); sinkpad = gst_pad_new_from_template (templ, name); gst_pad_set_chain_function (sinkpad, GST_DEBUG_FUNCPTR (fs_funnel_chain)); gst_pad_set_event_function (sinkpad, GST_DEBUG_FUNCPTR (fs_funnel_event)); gst_pad_set_getcaps_function (sinkpad, GST_DEBUG_FUNCPTR (fs_funnel_getcaps)); gst_pad_set_bufferalloc_function (sinkpad, GST_DEBUG_FUNCPTR (fs_funnel_buffer_alloc)); gst_segment_init (&priv->segment, GST_FORMAT_UNDEFINED); gst_pad_set_element_private (sinkpad, priv); gst_pad_set_active (sinkpad, TRUE); gst_element_add_pad (element, sinkpad); return sinkpad; }
static gboolean gst_imx_pxp_alloc_phys_mem(GstImxPhysMemAllocator *allocator, GstImxPhysMemory *memory, gssize size) { /* allocate cacheable physically contiguous memory block */ int ret; struct pxp_mem_desc *mem_desc = g_slice_alloc0(sizeof(struct pxp_mem_desc)); mem_desc->size = size; mem_desc->mtype = MEMORY_TYPE_CACHED; ret = ioctl(gst_imx_pxp_get_fd(), PXP_IOC_GET_PHYMEM, mem_desc); if (ret != 0) { GST_ERROR_OBJECT(allocator, "could not allocate %u bytes of physical memory: %s", size, strerror(errno)); g_slice_free1(size, mem_desc); return FALSE; } else { memory->phys_addr = (gst_imx_phys_addr_t)(mem_desc->phys_addr); memory->internal = mem_desc; GST_INFO_OBJECT(allocator, "allocated %u bytes of physical memory, paddr %" GST_IMX_PHYS_ADDR_FORMAT, size, memory->phys_addr); return TRUE; } }
static struct httpc* _httpc_new() { gint err; gchar sid[33]; GString *buff = qev_buffer_get(); struct httpc *hc = g_slice_alloc0(sizeof(*hc)); _uuid(sid); hc->polling = test_socket(); hc->waiting = test_socket(); hc->aq = g_async_queue_new(); hc->sid = g_strdup(sid); hc->th_run = TRUE; g_mutex_init(&hc->lock); hc->th = g_thread_new("httpc", _httpc_thread, hc); g_string_printf(buff, INIT_HEADERS, hc->sid); err = send(hc->polling, buff->str, buff->len, 0); ck_assert_int_eq(err, buff->len); qev_buffer_put(buff); _next(hc, "/qio/callback/1:0={\"code\":200,\"data\":\"localhost\"}"); return hc; }
void uprof_context_add_counter (UProfContext *context, UProfCounter *counter) { /* We check if we have actually seen this counter before; it might be that * it belongs to a dynamic shared object that has been reloaded */ UProfCounterState *state = uprof_context_get_counter_result (context, counter->name); /* If we have seen this counter before see if it is being added from a * new location and track that location if so. */ if (G_UNLIKELY (state)) { _uprof_object_state_add_location (UPROF_OBJECT_STATE (state), counter->filename, counter->line, counter->function); } else { state = g_slice_alloc0 (sizeof (UProfCounterState)); _uprof_object_state_init (UPROF_OBJECT_STATE (state), context, counter->name, counter->description); _uprof_object_state_add_location (UPROF_OBJECT_STATE (state), counter->filename, counter->line, counter->function); state->disabled = context->disabled; context->counters = g_list_prepend (context->counters, state); } counter->state = state; _uprof_context_dirty_resolved_state (context); }
/* agent must be locked */ static struct ice_candidate_pair *__pair_candidate(struct interface_address *addr, struct ice_agent *ag, struct ice_candidate *cand, struct packet_stream *ps) { struct ice_candidate_pair *pair; if (addr->family != family_from_address(&cand->endpoint.ip46)) return NULL; pair = g_slice_alloc0(sizeof(*pair)); pair->agent = ag; pair->remote_candidate = cand; pair->local_address = addr; pair->packet_stream = ps; if (cand->component_id != 1) PAIR_SET(pair, FROZEN); __do_ice_pair_priority(pair); __new_stun_transaction(pair); g_queue_push_tail(&ag->candidate_pairs, pair); g_hash_table_insert(ag->pair_hash, pair, pair); g_tree_insert(ag->all_pairs, pair, pair); ilog(LOG_DEBUG, "Created candidate pair "PAIR_FORMAT" between %s and %s, type %s", PAIR_FMT(pair), smart_ntop_buf(&addr->addr), smart_ntop_ep_buf(&cand->endpoint), ice_candidate_type_str(cand->type)); return pair; }
/* agent must be locked */ static struct ice_candidate_pair *__pair_candidate(struct stream_fd *sfd, struct ice_agent *ag, struct ice_candidate *cand) { struct ice_candidate_pair *pair; if (sfd->socket.family != cand->endpoint.address.family) return NULL; pair = g_slice_alloc0(sizeof(*pair)); pair->agent = ag; pair->remote_candidate = cand; pair->local_intf = sfd->local_intf; pair->sfd = sfd; if (cand->component_id != 1) PAIR_SET(pair, FROZEN); __do_ice_pair_priority(pair); __new_stun_transaction(pair); g_queue_push_tail(&ag->candidate_pairs, pair); g_hash_table_insert(ag->pair_hash, pair, pair); g_tree_insert(ag->all_pairs, pair, pair); ilog(LOG_DEBUG, "Created candidate pair "PAIR_FORMAT" between %s and %s, type %s", PAIR_FMT(pair), sockaddr_print_buf(&sfd->socket.local.address), endpoint_print_buf(&cand->endpoint), ice_candidate_type_str(cand->type)); return pair; }
PP_Resource ppb_flash_menu_create(PP_Instance instance_id, const struct PP_Flash_Menu *menu_data) { struct pp_instance_s *pp_i = tables_get_pp_instance(instance_id); if (!pp_i) { trace_error("%s, bad instance\n", __func__); return 0; } PP_Resource flash_menu = pp_resource_allocate(PP_RESOURCE_FLASH_MENU, pp_i); if (pp_resource_get_type(flash_menu) != PP_RESOURCE_FLASH_MENU) { trace_error("%s, resource allocation failure\n", __func__); return 0; } struct flash_menu_create_param_s *p = g_slice_alloc0(sizeof(*p)); p->flash_menu = flash_menu; p->menu_data = menu_data; p->m_loop = ppb_message_loop_get_current(); p->depth = ppb_message_loop_get_depth(p->m_loop) + 1; ppb_message_loop_post_work_with_result(p->m_loop, PP_MakeCCB(flash_menu_create_comt, p), 0, PP_OK, p->depth, __func__); ppb_message_loop_run_nested(p->m_loop); g_slice_free1(sizeof(*p), p); return flash_menu; }
static int streams_parse_func(char **a, void **ret, void *p) { struct stream_params *sp; u_int32_t ip; int *i; i = p; sp = g_slice_alloc0(sizeof(*sp)); SP_SET(sp, SEND); SP_SET(sp, RECV); sp->protocol = &transport_protocols[PROTO_RTP_AVP]; ip = inet_addr(a[0]); if (ip == -1) goto fail; in4_to_6(&sp->rtp_endpoint.ip46, ip); sp->rtp_endpoint.port = atoi(a[1]); sp->index = ++(*i); sp->consecutive_ports = 1; sp->rtcp_endpoint = sp->rtp_endpoint; sp->rtcp_endpoint.port++; if (!sp->rtp_endpoint.port && strcmp(a[1], "0")) goto fail; *ret = sp; return 0; fail: ilog(LOG_WARNING, "Failed to parse a media stream: %s:%s", a[0], a[1]); g_slice_free1(sizeof(*sp), sp); return -1; }
gpointer g_mem_chunk_alloc0 (GMemChunk *mem_chunk) { g_return_val_if_fail (mem_chunk != NULL, NULL); return g_slice_alloc0 (mem_chunk->alloc_size); }
void *moloch_size_alloc(int size, int zero) { size += 8; void *mem = (zero?g_slice_alloc0(size):g_slice_alloc(size)); memcpy(mem, &size, 4); return mem + 8; }
struct sdp_chopper *sdp_chopper_new(str *input) { struct sdp_chopper *c = g_slice_alloc0(sizeof(*c)); c->input = input; c->chunk = g_string_chunk_new(512); c->iov = g_array_new(0, 0, sizeof(struct iovec)); return c; }
sprite_ol_t* add_sprite_ol(home_t* p_home, home_proto_t* p_proto) { sprite_ol_t* p = g_slice_alloc0(sizeof(sprite_ol_t)); update_sprite_head_info(p_proto, p); g_hash_table_insert(p_home->sprites, &p->id, p); add_online_user(p_home, p_proto->onlineid); return p; }
/** * ncm_matrix_new0: * @nrows: number of rows * @ncols: number of columns * * This function allocates memory for a new #NcmMatrix of doubles * with @nrows rows and @ncols columns and sets all elements to zero. * * Returns: (transfer full): A new #NcmMatrix. */ NcmMatrix * ncm_matrix_new0 (const guint nrows, const guint ncols) { gdouble *d = g_slice_alloc0 (sizeof(gdouble) * nrows * ncols); NcmMatrix *cm = ncm_matrix_new_full (d, nrows, ncols, ncols, NULL, NULL); cm->type = NCM_MATRIX_SLICE; return cm; }
struct event_base * rspamd_prepare_worker (struct rspamd_worker *worker, const char *name, void (*accept_handler)(int, short, void *), gboolean load_lua) { struct event_base *ev_base; struct event *accept_events; GList *cur; struct rspamd_worker_listen_socket *ls; #ifdef WITH_PROFILER extern void _start (void), etext (void); monstartup ((u_long) & _start, (u_long) & etext); #endif gperf_profiler_init (worker->srv->cfg, name); worker->srv->pid = getpid (); worker->signal_events = g_hash_table_new_full (g_direct_hash, g_direct_equal, NULL, g_free); ev_base = event_init (); rspamd_worker_init_signals (worker, ev_base); rspamd_control_worker_add_default_handler (worker, ev_base); #ifdef WITH_HIREDIS rspamd_redis_pool_config (worker->srv->cfg->redis_pool, worker->srv->cfg, ev_base); #endif /* Accept all sockets */ if (accept_handler) { cur = worker->cf->listen_socks; while (cur) { ls = cur->data; if (ls->fd != -1) { accept_events = g_slice_alloc0 (sizeof (struct event) * 2); event_set (&accept_events[0], ls->fd, EV_READ | EV_PERSIST, accept_handler, worker); event_base_set (ev_base, &accept_events[0]); event_add (&accept_events[0], NULL); worker->accept_events = g_list_prepend (worker->accept_events, accept_events); } cur = g_list_next (cur); } } if (load_lua) { struct rspamd_config *cfg = worker->srv->cfg; rspamd_lua_run_postloads (cfg->lua_state, cfg, ev_base, worker); } return ev_base; }
static void _add_app( const gchar *name, const gchar *path) { guint i; gboolean ok; qio_app_cb cb; GString *full_path = qev_buffer_get(); guint *magic_num = NULL; struct app *app = g_slice_alloc0(sizeof(*app)); app->name = g_strdup(name); if (strspn(path, PATH_STARTERS) == 0) { g_string_printf(full_path, "%s/%s", PATH_LIB_DIR, path); } else { g_string_assign(full_path, path); } app->mod = g_module_open(full_path->str, G_MODULE_BIND_LOCAL); ASSERT(app->mod != NULL, "Could not open app %s: %s", name, g_module_error()); /* * For config: unloading modules causes segfaults on exit because the * modules can be closed an removed from memory. Keep them in memory at * all times: not like they can be removed at runtime anyway. */ g_module_make_resident(app->mod); for (i = 0; i < _apps->len; i++) { struct app *oapp = g_ptr_array_index(_apps, i); ASSERT(app->mod != oapp->mod, "Duplicate app detected %s (%s).", name, full_path->str); } ok = g_module_symbol(app->mod, "__qio_is_app", (void*)&magic_num) && *magic_num == QIO_MAGIC_NUM; ASSERT(ok, "Loaded module is not a QuickIO app: %s (%s)", name, full_path->str) #define X(fn) \ ASSERT(g_module_symbol(app->mod, "__qio_app_" G_STRINGIFY(fn), (void*)&cb), \ "App missing default QuickIO function %s: %s (%s)", \ "__qio_app_" G_STRINGIFY(fn), name, full_path->str); \ app->fn = cb; CALLBACKS #undef X ASSERT(app->init(), "Could not initialize app (%s): init() failed", name); g_ptr_array_add(_apps, app); qev_buffer_put(full_path); }
void event_queue_enqueue(event_queue *queue, guint time, void (*func)(guint, void *), void *data) { event_queue_entry *entry = g_slice_alloc0(sizeof(event_queue_entry)); entry->time = time; entry->func = func; entry->data = data; g_sequence_insert_sorted(queue->queue, entry, (gint (*)(gconstpointer, gconstpointer, gpointer)) event_queue_entry_compare, NULL); }