static void* inner_start_thread (void *arg) { StartInfo *start_info = (StartInfo *) arg; void *t_arg = start_info->arg; int res; void *(*start_func)(void*) = start_info->start_routine; guint32 flags = start_info->flags; void *result; HANDLE handle; MonoThreadInfo *info; /* Register the thread with the io-layer */ handle = wapi_create_thread_handle (); if (!handle) { res = MONO_SEM_POST (&(start_info->registered)); g_assert (!res); return NULL; } start_info->handle = handle; info = mono_thread_info_attach (&result); MONO_PREPARE_BLOCKING info->runtime_thread = TRUE; info->handle = handle; if (flags & CREATE_SUSPENDED) { info->create_suspended = TRUE; MONO_SEM_INIT (&info->create_suspended_sem, 0); } /* start_info is not valid after this */ res = MONO_SEM_POST (&(start_info->registered)); g_assert (!res); start_info = NULL; if (flags & CREATE_SUSPENDED) { while (MONO_SEM_WAIT (&info->create_suspended_sem) != 0 && errno == EINTR); MONO_SEM_DESTROY (&info->create_suspended_sem); } MONO_FINISH_BLOCKING /* Run the actual main function of the thread */ result = start_func (t_arg); /* mono_thread_info_detach (); */ #if defined(__native_client__) nacl_shutdown_gc_thread(); #endif wapi_thread_handle_set_exited (handle, GPOINTER_TO_UINT (result)); /* This is needed by mono_threads_core_unregister () which is called later */ info->handle = NULL; g_assert (mono_threads_get_callbacks ()->thread_exit); mono_threads_get_callbacks ()->thread_exit (NULL); g_assert_not_reached (); return result; }
void mono_gc_conservatively_scan_area (void *start, void *end) { g_assert_not_reached (); }
gsize* mono_gc_get_bitmap_for_descr (void *descr, int *numbits) { g_assert_not_reached (); return NULL; }
MonoMethod* mono_gc_get_specific_write_barrier (gboolean is_concurrent) { g_assert_not_reached (); return NULL; }
guint8* mono_gc_get_card_table (int *shift_bits, gpointer *card_mask) { g_assert_not_reached (); return NULL; }
static GtkWidget * csm_get_dialog (CsmDialogLogoutType type, GdkScreen *screen, guint32 activate_time) { CsmLogoutDialog *logout_dialog; GtkWidget *dialog_image; const char *primary_text; const char *icon_name; if (current_dialog != NULL) { gtk_widget_destroy (GTK_WIDGET (current_dialog)); } logout_dialog = g_object_new (CSM_TYPE_LOGOUT_DIALOG, NULL); current_dialog = logout_dialog; gtk_window_set_title (GTK_WINDOW (logout_dialog), ""); logout_dialog->priv->type = type; icon_name = NULL; primary_text = NULL; switch (type) { case CSM_DIALOG_LOGOUT_TYPE_LOGOUT: icon_name = CSM_ICON_LOGOUT; primary_text = _("Log out of this system now?"); logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_LOGOUT; if (csm_logout_supports_switch_user (logout_dialog)) { gtk_dialog_add_button (GTK_DIALOG (logout_dialog), _("_Switch User"), CSM_LOGOUT_RESPONSE_SWITCH_USER); } gtk_dialog_add_button (GTK_DIALOG (logout_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); gtk_dialog_add_button (GTK_DIALOG (logout_dialog), _("_Log Out"), CSM_LOGOUT_RESPONSE_LOGOUT); break; case CSM_DIALOG_LOGOUT_TYPE_SHUTDOWN: icon_name = CSM_ICON_SHUTDOWN; primary_text = _("Shut down this system now?"); logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_SHUTDOWN; if (csm_logout_supports_system_suspend (logout_dialog)) { gtk_dialog_add_button (GTK_DIALOG (logout_dialog), _("S_uspend"), CSM_LOGOUT_RESPONSE_SLEEP); } if (csm_logout_supports_system_hibernate (logout_dialog)) { gtk_dialog_add_button (GTK_DIALOG (logout_dialog), _("_Hibernate"), CSM_LOGOUT_RESPONSE_HIBERNATE); } if (csm_logout_supports_reboot (logout_dialog)) { gtk_dialog_add_button (GTK_DIALOG (logout_dialog), _("_Restart"), CSM_LOGOUT_RESPONSE_REBOOT); } gtk_dialog_add_button (GTK_DIALOG (logout_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (csm_logout_supports_shutdown (logout_dialog)) { gtk_dialog_add_button (GTK_DIALOG (logout_dialog), _("_Shut Down"), CSM_LOGOUT_RESPONSE_SHUTDOWN); } break; case CSM_DIALOG_LOGOUT_TYPE_REBOOT: icon_name = CSM_ICON_SHUTDOWN; primary_text = _("Restart this system now?"); logout_dialog->priv->default_response = CSM_LOGOUT_RESPONSE_REBOOT; gtk_dialog_add_button (GTK_DIALOG (logout_dialog), GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL); if (csm_logout_supports_reboot (logout_dialog)) { gtk_dialog_add_button (GTK_DIALOG (logout_dialog), _("_Restart"), CSM_LOGOUT_RESPONSE_REBOOT); } break; default: g_assert_not_reached (); } dialog_image = gtk_message_dialog_get_image (GTK_MESSAGE_DIALOG (logout_dialog)); gtk_image_set_from_icon_name (GTK_IMAGE (dialog_image), icon_name, GTK_ICON_SIZE_DIALOG); gtk_window_set_icon_name (GTK_WINDOW (logout_dialog), icon_name); gtk_window_set_position (GTK_WINDOW (logout_dialog), GTK_WIN_POS_CENTER_ALWAYS); gtk_message_dialog_set_markup (GTK_MESSAGE_DIALOG (logout_dialog), primary_text); gtk_dialog_set_default_response (GTK_DIALOG (logout_dialog), logout_dialog->priv->default_response); gtk_window_set_screen (GTK_WINDOW (logout_dialog), screen); return GTK_WIDGET (logout_dialog); }
static void attach_widgets (GtkTextView *text_view) { GtkTextIter iter; GtkTextBuffer *buffer; int i; buffer = gtk_text_view_get_buffer (text_view); gtk_text_buffer_get_start_iter (buffer, &iter); i = 0; while (find_anchor (&iter)) { GtkTextChildAnchor *anchor; GtkWidget *widget; anchor = gtk_text_iter_get_child_anchor (&iter); if (i == 0) { widget = gtk_button_new_with_label ("Click Me"); g_signal_connect (widget, "clicked", G_CALLBACK (easter_egg_callback), NULL); } else if (i == 1) { widget = gtk_combo_box_text_new (); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Option 1"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Option 2"); gtk_combo_box_text_append_text (GTK_COMBO_BOX_TEXT (widget), "Option 3"); } else if (i == 2) { widget = gtk_scale_new (GTK_ORIENTATION_HORIZONTAL, NULL); gtk_range_set_range (GTK_RANGE (widget), 0, 100); gtk_widget_set_size_request (widget, 70, -1); } else if (i == 3) { gchar *filename = demo_find_file ("floppybuddy.gif", NULL); widget = gtk_image_new_from_file (filename); g_free (filename); } else if (i == 4) { widget = gtk_entry_new (); } else { widget = NULL; /* avoids a compiler warning */ g_assert_not_reached (); } gtk_text_view_add_child_at_anchor (text_view, widget, anchor); gtk_widget_show_all (widget); ++i; } }
static void gdict_pref_dialog_init (GdictPrefDialog *dialog) { gchar *font; GError *error = NULL; gtk_window_set_default_size (GTK_WINDOW (dialog), DEFAULT_MIN_WIDTH, DEFAULT_MIN_HEIGHT); gtk_container_set_border_width (GTK_CONTAINER (dialog), 5); gtk_box_set_spacing (GTK_BOX (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), 2); gtk_dialog_set_has_separator (GTK_DIALOG (dialog), FALSE); /* add buttons */ gtk_dialog_add_button (GTK_DIALOG (dialog), "gtk-help", GTK_RESPONSE_HELP); gtk_dialog_add_button (GTK_DIALOG (dialog), "gtk-close", GTK_RESPONSE_ACCEPT); dialog->gconf_client = gconf_client_get_default (); gconf_client_add_dir (dialog->gconf_client, GDICT_GCONF_DIR, GCONF_CLIENT_PRELOAD_ONELEVEL, NULL); dialog->notify_id = gconf_client_notify_add (dialog->gconf_client, GDICT_GCONF_DIR, gdict_pref_dialog_gconf_notify_cb, dialog, NULL, NULL); /* get the UI from the GtkBuilder file */ dialog->builder = gtk_builder_new (); gtk_builder_add_from_file (dialog->builder, GDICT_PREFERENCES_UI, &error); if (error) { g_critical ("Unable to load the preferences user interface: %s", error->message); g_error_free (error); g_assert_not_reached (); } /* the main widget */ gtk_container_add (GTK_CONTAINER (gtk_dialog_get_content_area (GTK_DIALOG (dialog))), GTK_WIDGET (gtk_builder_get_object (dialog->builder, "preferences_root"))); /* keep all the interesting widgets around */ dialog->notebook = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "preferences_notebook")); dialog->sources_view = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "sources_treeview")); build_sources_view (dialog); dialog->active_source = gdict_gconf_get_string_with_default (dialog->gconf_client, GDICT_GCONF_SOURCE_KEY, GDICT_DEFAULT_SOURCE_NAME); dialog->sources_add = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "add_button")); gtk_widget_set_tooltip_text (dialog->sources_add, _("Add a new dictionary source")); g_signal_connect (dialog->sources_add, "clicked", G_CALLBACK (source_add_clicked_cb), dialog); dialog->sources_remove = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "remove_button")); gtk_widget_set_tooltip_text (dialog->sources_remove, _("Remove the currently selected dictionary source")); g_signal_connect (dialog->sources_remove, "clicked", G_CALLBACK (source_remove_clicked_cb), dialog); font = gconf_client_get_string (dialog->gconf_client, GDICT_GCONF_PRINT_FONT_KEY, NULL); if (!font) font = g_strdup (GDICT_DEFAULT_PRINT_FONT); dialog->font_button = GTK_WIDGET (gtk_builder_get_object (dialog->builder, "print_font_button")); gtk_font_button_set_font_name (GTK_FONT_BUTTON (dialog->font_button), font); gtk_widget_set_tooltip_text (dialog->font_button, _("Set the font used for printing the definitions")); g_signal_connect (dialog->font_button, "font-set", G_CALLBACK (font_button_font_set_cb), dialog); g_free (font); gtk_widget_show_all (dialog->notebook); /* we want to intercept the response signal before any other * callbacks might be attached by the users of the * GdictPrefDialog widget. */ g_signal_connect (dialog, "response", G_CALLBACK (response_cb), NULL); }
static void goo_ti_post_processor_validate (GooComponent* component) { g_assert (GOO_IS_TI_POST_PROCESSOR (component)); GooTiPostProcessor* self = GOO_TI_POST_PROCESSOR (component); g_assert (component->cur_state == OMX_StateLoaded); /* params */ { g_assert (self->video_pipeline >= 1 && self->video_pipeline <= 2); /* this is temporal */ self->background_color->nOutputDev = 0; g_assert (self->background_color->nColor >= 0x000000 && self->background_color->nColor <= 0xffffff); /* this is temporal */ self->transcolor_key->nOutputDev = 0; self->transcolor_key->nKeyType = 1; g_assert (self->transcolor_key->nColor >= 0x000000 && self->transcolor_key->nColor <= 0xffffff); } /* input */ { GooIterator* iter = goo_component_iterate_input_ports (component); goo_iterator_nth (iter, 0); GooPort* port = GOO_PORT (goo_iterator_get_current (iter)); g_assert (port != NULL); OMX_PARAM_PORTDEFINITIONTYPE* param; param = GOO_PORT_GET_DEFINITION (port); /* let's use the max available resolution. */ ResolutionInfo rinfo = goo_get_resolution ("sxvga"); g_assert ((param->format.video.nFrameWidth <= rinfo.width) && (param->format.video.nFrameHeight <= rinfo.height)); param->format.video.cMIMEType = "video/x-raw-yuv"; switch (param->format.video.eColorFormat) { case OMX_COLOR_FormatYUV420PackedPlanar: /* I420 */ param->nBufferSize = param->format.video.nFrameWidth * param->format.video.nFrameHeight * 1.5; break; case OMX_COLOR_FormatYCbYCr: /* YUY2? */ case OMX_COLOR_FormatCbYCrY: /* UYVY? */ case OMX_COLOR_Format16bitRGB565: /* RGB */ param->nBufferSize = param->format.video.nFrameWidth * param->format.video.nFrameHeight * 2; break; default: GOO_OBJECT_DEBUG (self, "Invalid color format"); g_assert_not_reached (); } param->format.video.eCompressionFormat = OMX_VIDEO_CodingUnused; g_object_unref (iter); g_object_unref (port); } GOO_OBJECT_DEBUG (self, ""); return; }
static gboolean median_dialog(MedianBgArgs *args) { enum { RESPONSE_RESET = 1 }; GtkWidget *dialog, *table, *spin; MedianBgControls controls; gint response, row; gdouble q; dialog = gtk_dialog_new_with_buttons(_("Median Level"), NULL, 0, _("_Reset"), RESPONSE_RESET, GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, GTK_STOCK_OK, GTK_RESPONSE_OK, NULL); gtk_dialog_set_has_separator(GTK_DIALOG(dialog), FALSE); gtk_dialog_set_default_response(GTK_DIALOG(dialog), GTK_RESPONSE_OK); table = gtk_table_new(5, 4, FALSE); gtk_table_set_row_spacings(GTK_TABLE(table), 2); gtk_table_set_col_spacings(GTK_TABLE(table), 6); gtk_container_set_border_width(GTK_CONTAINER(table), 4); gtk_box_pack_start(GTK_BOX(GTK_DIALOG(dialog)->vbox), table, FALSE, FALSE, 4); row = 0; controls.in_update = TRUE; q = args->pixelsize/args->valform->magnitude; gwy_debug("q = %f", q); controls.radius = gtk_adjustment_new(q*args->size, q, 16384*q, q, 10*q, 0); spin = gwy_table_attach_hscale(table, row, _("Real _radius:"), args->valform->units, controls.radius, GWY_HSCALE_SQRT); gtk_spin_button_set_digits(GTK_SPIN_BUTTON(spin), args->valform->precision); g_object_set_data(G_OBJECT(controls.radius), "controls", &controls); g_signal_connect(controls.radius, "value-changed", G_CALLBACK(radius_changed_cb), args); row++; controls.size = gtk_adjustment_new(args->size, 1, 16384, 1, 10, 0); spin = gwy_table_attach_hscale(table, row, _("_Pixel radius:"), "px", controls.size, GWY_HSCALE_SQRT); g_object_set_data(G_OBJECT(controls.size), "controls", &controls); g_signal_connect(controls.size, "value-changed", G_CALLBACK(size_changed_cb), args); row++; controls.do_extract = gtk_check_button_new_with_mnemonic(_("E_xtract background")); gtk_table_attach(GTK_TABLE(table), controls.do_extract, 0, 4, row, row+1, GTK_FILL, 0, 0, 0); gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(controls.do_extract), args->do_extract); g_signal_connect(controls.do_extract, "toggled", G_CALLBACK(do_extract_changed_cb), args); row++; controls.in_update = FALSE; gtk_widget_show_all(dialog); do { response = gtk_dialog_run(GTK_DIALOG(dialog)); switch (response) { case GTK_RESPONSE_CANCEL: case GTK_RESPONSE_DELETE_EVENT: gtk_widget_destroy(dialog); case GTK_RESPONSE_NONE: return FALSE; break; case GTK_RESPONSE_OK: break; case RESPONSE_RESET: args->size = median_defaults.size; args->do_extract = median_defaults.do_extract; median_dialog_update(&controls, args); break; default: g_assert_not_reached(); break; } } while (response != GTK_RESPONSE_OK); gtk_widget_destroy(dialog); return TRUE; }
static void arv_gc_float_node_pre_remove_child (ArvDomNode *self, ArvDomNode *child) { g_assert_not_reached (); }
static int _client_manage_input(struct network_client_s *client) { guint total, size; int _notify(void) { if (!client->transport.notify_input) return RC_PROCESSED; if (!data_slab_sequence_has_data(&(client->input))) { /* drain the data */ data_slab_sequence_clean_data(&(client->input)); return RC_PROCESSED; } GRID_TRACE2("fd=%d passing %u/%"G_GSIZE_FORMAT" to transport %p", client->fd, total, data_slab_sequence_size(&(client->input)), client->transport.notify_input); return client->transport.notify_input(client); } EXTRA_ASSERT(client != NULL); EXTRA_ASSERT(client->fd >= 0); for (size=SLAB_STARTSIZE, total=0; total < ROUND_MAXSIZE ;) { int rc; struct data_slab_s *in = data_slab_make_empty(size); switch (rc = _ds_feed(client->fd, in)) { case RC_ERROR: data_slab_free(in); return RC_ERROR; case RC_NODATA: /* no more data to expect */ case RC_NOTREADY: if (!in->data.buffer.end) data_slab_free(in); else { data_slab_sequence_append(&(client->input), in); total += in->data.buffer.end; } in = NULL; if (RC_NODATA == _notify()) rc = RC_NODATA; return rc; case RC_PROCESSED: if (!in->data.buffer.end) data_slab_free(in); else { data_slab_sequence_append(&(client->input), in); total += in->data.buffer.end; } size = SLAB_MAXSIZE; in = NULL; break; default: g_assert_not_reached(); } } return _notify(); }
/** * Initiate an UDP RPC transaction. * * The message held in ``data'' is sent to the specified address and port. * Upon reception of a reply from that host, the callback is invoked. * If no reply is received after some time, the callaback is also invoked. * * @param what type of RPC, for logging (static string) * @param addr address where RPC should be sent to * @param port port where RPC should be sent to * @param data message data to send * @param len length of data to send * @param timeout timeout in milliseconds to get a reply * @param cb callback to invoke on reply or timeout * @param arg additionnal callback argument * * @return 0 if OK, -1 if we could not initiate the RPC, with errno set. */ int urpc_send(const char *what, host_addr_t addr, uint16 port, const void *data, size_t len, unsigned long timeout, urpc_cb_t cb, void *arg) { struct urpc_cb *ucb; struct gnutella_socket *s; host_addr_t bind_addr = zero_host_addr; gnet_host_t to; ssize_t r; /* * Create anonymous socket to send/receive the RPC. */ switch (host_addr_net(addr)) { case NET_TYPE_IPV4: bind_addr = ipv4_unspecified; break; case NET_TYPE_IPV6: bind_addr = ipv6_unspecified; break; case NET_TYPE_LOCAL: case NET_TYPE_NONE: g_assert_not_reached(); } s = socket_udp_listen(bind_addr, 0, urpc_received); if (NULL == s) { if (GNET_PROPERTY(udp_debug)) { g_warning("unable to create anonymous UDP %s socket for %s RPC: %m", net_type_to_string(host_addr_net(bind_addr)), what); } return -1; } /* * Send the message. */ gnet_host_set(&to, addr, port); r = (s->wio.sendto)(&s->wio, &to, data, len); /* * Reset errno if there was no "real" error to prevent getting a * bogus and possibly misleading error message later. */ if ((ssize_t) -1 == r) { if (GNET_PROPERTY(udp_debug)) { g_warning("unable to send UDP %s RPC to %s: %m", what, host_addr_port_to_string(addr, port)); } } else { errno = 0; } if (len != UNSIGNED(r)) { if ((ssize_t) -1 != r) { if (GNET_PROPERTY(udp_debug)) { g_warning("unable to send whole %zu-byte UDP %s RPC to %s: " "only sent %zu byte%s", len, what, host_addr_port_to_string(addr, port), r, 1 == r ? "" : "s"); } } socket_free_null(&s); errno = EIO; return -1; } /* * Make sure socket_udp_event() will only process replies one at a time * since we're going to close the anonymous UDP socket as soon as we * get a reply. */ socket_set_single(s, TRUE); /* * Message was sent, wait for the answer. */ WALLOC(ucb); ucb->magic = URPC_CB_MAGIC; ucb->addr = addr; ucb->port = port; ucb->s = s; ucb->cb = cb; ucb->arg = arg; ucb->timeout_ev = cq_main_insert(timeout, urpc_timed_out, ucb); ucb->what = what; htable_insert(pending, s, ucb); return 0; }
void mrp_time2_align_next (MrpTime *t, MrpTimeUnit unit) { GDateWeekday weekday; GDateMonth month; g_return_if_fail (t != NULL); switch (unit) { case MRP_TIME_UNIT_HOUR: t->min = 0; t->sec = 0; mrp_time2_add_hours (t, 1); break; case MRP_TIME_UNIT_TWO_HOURS: t->min = 0; t->sec = 0; mrp_time2_add_hours (t, 2 - t->hour % 2); break; case MRP_TIME_UNIT_HALFDAY: t->min = 0; t->sec = 0; if (t->hour < 12) { t->hour = 12; } else { t->hour = 0; mrp_time2_add_days (t, 1); } break; case MRP_TIME_UNIT_DAY: t->hour = 0; t->min = 0; t->sec = 0; mrp_time2_add_days (t, 1); break; case MRP_TIME_UNIT_WEEK: /* FIXME: We currently hardcode monday as week start .*/ weekday = g_date_get_weekday (&t->date); t->hour = 0; t->min = 0; t->sec = 0; mrp_time2_add_days (t, 8 - weekday); break; case MRP_TIME_UNIT_MONTH: t->hour = 0; t->min = 0; t->sec = 0; g_date_set_day (&t->date, 1); g_date_add_months (&t->date, 1); break; case MRP_TIME_UNIT_QUARTER: t->hour = 0; t->min = 0; t->sec = 0; g_date_set_day (&t->date, 1); month = g_date_get_month (&t->date); if (month >= 1 && month <= 3) { g_date_set_month (&t->date, 4); } else if (month >= 4 && month <= 6) { g_date_set_month (&t->date, 7); } else if (month >= 7 && month <= 9) { g_date_set_month (&t->date, 10); } else if (month >= 10 && month <= 12) { g_date_set_month (&t->date, 1); g_date_add_years (&t->date, 1); } break; case MRP_TIME_UNIT_HALFYEAR: g_date_set_day (&t->date, 1); t->hour = 0; t->min = 0; t->sec = 0; month = g_date_get_month (&t->date); if (month >= 1 && month <= 6) { g_date_set_month (&t->date, 7); } else if (month >= 7 && month <= 12) { g_date_set_month (&t->date, 1); g_date_add_years (&t->date, 1); } break; case MRP_TIME_UNIT_YEAR: t->hour = 0; t->min = 0; t->sec = 0; g_date_set_day (&t->date, 1); g_date_set_month (&t->date, 1); g_date_add_years (&t->date, 1); break; case MRP_TIME_UNIT_NONE: default: g_assert_not_reached (); } }
gboolean gimp_plug_in_open (GimpPlugIn *plug_in, GimpPlugInCallMode call_mode, gboolean synchronous) { gint my_read[2]; gint my_write[2]; gchar **envp; const gchar *args[9]; gchar **argv; gint argc; gchar *interp, *interp_arg; gchar *read_fd, *write_fd; const gchar *mode; gchar *stm; GError *error = NULL; gboolean debug; guint debug_flag; guint spawn_flags; g_return_val_if_fail (GIMP_IS_PLUG_IN (plug_in), FALSE); g_return_val_if_fail (plug_in->call_mode == GIMP_PLUG_IN_CALL_NONE, FALSE); /* Open two pipes. (Bidirectional communication). */ if ((pipe (my_read) == -1) || (pipe (my_write) == -1)) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Unable to run plug-in \"%s\"\n(%s)\n\npipe() failed: %s", gimp_object_get_name (GIMP_OBJECT (plug_in)), gimp_filename_to_utf8 (plug_in->prog), g_strerror (errno)); return FALSE; } #if defined(G_WITH_CYGWIN) /* Set to binary mode */ setmode (my_read[0], _O_BINARY); setmode (my_write[0], _O_BINARY); setmode (my_read[1], _O_BINARY); setmode (my_write[1], _O_BINARY); #endif #ifdef G_OS_WIN32 /* Prevent the plug-in from inheriting our ends of the pipes */ SetHandleInformation ((HANDLE) _get_osfhandle (my_read[0]), HANDLE_FLAG_INHERIT, 0); SetHandleInformation ((HANDLE) _get_osfhandle (my_write[1]), HANDLE_FLAG_INHERIT, 0); #endif plug_in->my_read = g_io_channel_unix_new (my_read[0]); plug_in->my_write = g_io_channel_unix_new (my_write[1]); plug_in->his_read = g_io_channel_unix_new (my_write[0]); plug_in->his_write = g_io_channel_unix_new (my_read[1]); g_io_channel_set_encoding (plug_in->my_read, NULL, NULL); g_io_channel_set_encoding (plug_in->my_write, NULL, NULL); g_io_channel_set_encoding (plug_in->his_read, NULL, NULL); g_io_channel_set_encoding (plug_in->his_write, NULL, NULL); g_io_channel_set_buffered (plug_in->my_read, FALSE); g_io_channel_set_buffered (plug_in->my_write, FALSE); g_io_channel_set_buffered (plug_in->his_read, FALSE); g_io_channel_set_buffered (plug_in->his_write, FALSE); g_io_channel_set_close_on_unref (plug_in->my_read, TRUE); g_io_channel_set_close_on_unref (plug_in->my_write, TRUE); g_io_channel_set_close_on_unref (plug_in->his_read, TRUE); g_io_channel_set_close_on_unref (plug_in->his_write, TRUE); /* Remember the file descriptors for the pipes. */ read_fd = g_strdup_printf ("%d", g_io_channel_unix_get_fd (plug_in->his_read)); write_fd = g_strdup_printf ("%d", g_io_channel_unix_get_fd (plug_in->his_write)); switch (call_mode) { case GIMP_PLUG_IN_CALL_QUERY: mode = "-query"; debug_flag = GIMP_DEBUG_WRAP_QUERY; break; case GIMP_PLUG_IN_CALL_INIT: mode = "-init"; debug_flag = GIMP_DEBUG_WRAP_INIT; break; case GIMP_PLUG_IN_CALL_RUN: mode = "-run"; debug_flag = GIMP_DEBUG_WRAP_RUN; break; default: g_assert_not_reached (); } stm = g_strdup_printf ("%d", plug_in->manager->gimp->stack_trace_mode); interp = gimp_interpreter_db_resolve (plug_in->manager->interpreter_db, plug_in->prog, &interp_arg); argc = 0; if (interp) args[argc++] = interp; if (interp_arg) args[argc++] = interp_arg; args[argc++] = plug_in->prog; args[argc++] = "-gimp"; args[argc++] = read_fd; args[argc++] = write_fd; args[argc++] = mode; args[argc++] = stm; args[argc++] = NULL; argv = (gchar **) args; envp = gimp_environ_table_get_envp (plug_in->manager->environ_table); spawn_flags = (G_SPAWN_LEAVE_DESCRIPTORS_OPEN | G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_CHILD_INHERITS_STDIN); debug = FALSE; if (plug_in->manager->debug) { gchar **debug_argv = gimp_plug_in_debug_argv (plug_in->manager->debug, plug_in->prog, debug_flag, args); if (debug_argv) { debug = TRUE; argv = debug_argv; spawn_flags |= G_SPAWN_SEARCH_PATH; } } /* Fork another process. We'll remember the process id so that we * can later use it to kill the filter if necessary. */ if (! g_spawn_async (NULL, argv, envp, spawn_flags, gimp_plug_in_prep_for_exec, plug_in, &plug_in->pid, &error)) { gimp_message (plug_in->manager->gimp, NULL, GIMP_MESSAGE_ERROR, "Unable to run plug-in \"%s\"\n(%s)\n\n%s", gimp_object_get_name (GIMP_OBJECT (plug_in)), gimp_filename_to_utf8 (plug_in->prog), error->message); g_error_free (error); goto cleanup; } g_io_channel_unref (plug_in->his_read); plug_in->his_read = NULL; g_io_channel_unref (plug_in->his_write); plug_in->his_write = NULL; if (! synchronous) { GSource *source; source = g_io_create_watch (plug_in->my_read, G_IO_IN | G_IO_PRI | G_IO_ERR | G_IO_HUP); g_source_set_callback (source, (GSourceFunc) gimp_plug_in_recv_message, plug_in, NULL); g_source_set_can_recurse (source, TRUE); plug_in->input_id = g_source_attach (source, NULL); g_source_unref (source); } plug_in->open = TRUE; plug_in->call_mode = call_mode; gimp_plug_in_manager_add_open_plug_in (plug_in->manager, plug_in); cleanup: if (debug) g_free (argv); g_free (read_fd); g_free (write_fd); g_free (stm); g_free (interp); g_free (interp_arg); return plug_in->open; }
static gchar * spawn_dbus_daemon (const gchar *binary, const gchar *configuration, const gchar *listen_address, TestUser user, GPid *daemon_pid) { GError *error = NULL; GString *address; gint address_fd; GPtrArray *argv; #ifdef DBUS_UNIX const struct passwd *pwd = NULL; #endif if (user != TEST_USER_ME) { #ifdef DBUS_UNIX if (getuid () != 0) { g_test_skip ("cannot use alternative uid when not uid 0"); return NULL; } switch (user) { case TEST_USER_ROOT: break; case TEST_USER_MESSAGEBUS: pwd = getpwnam (DBUS_USER); if (pwd == NULL) { gchar *message = g_strdup_printf ("user '%s' does not exist", DBUS_USER); g_test_skip (message); g_free (message); return NULL; } break; case TEST_USER_OTHER: pwd = getpwnam (DBUS_TEST_USER); if (pwd == NULL) { gchar *message = g_strdup_printf ("user '%s' does not exist", DBUS_TEST_USER); g_test_skip (message); g_free (message); return NULL; } break; default: g_assert_not_reached (); } #else g_test_skip ("cannot use alternative uid on Windows"); return NULL; #endif } argv = g_ptr_array_new_with_free_func (g_free); g_ptr_array_add (argv, g_strdup (binary)); g_ptr_array_add (argv, g_strdup (configuration)); g_ptr_array_add (argv, g_strdup ("--nofork")); g_ptr_array_add (argv, g_strdup ("--print-address=1")); /* stdout */ if (listen_address != NULL) g_ptr_array_add (argv, g_strdup (listen_address)); #ifdef DBUS_UNIX g_ptr_array_add (argv, g_strdup ("--systemd-activation")); #endif g_ptr_array_add (argv, NULL); g_spawn_async_with_pipes (NULL, /* working directory */ (gchar **) argv->pdata, NULL, /* envp */ G_SPAWN_DO_NOT_REAP_CHILD | G_SPAWN_SEARCH_PATH, #ifdef DBUS_UNIX child_setup, (gpointer) pwd, #else NULL, NULL, #endif daemon_pid, NULL, /* child's stdin = /dev/null */ &address_fd, NULL, /* child's stderr = our stderr */ &error); g_assert_no_error (error); g_ptr_array_free (argv, TRUE); address = g_string_new (NULL); /* polling until the dbus-daemon writes out its address is a bit stupid, * but at least it's simple, unlike dbus-launch... in principle we could * use select() here, but life's too short */ while (1) { gssize bytes; gchar buf[4096]; gchar *newline; bytes = read (address_fd, buf, sizeof (buf)); if (bytes > 0) g_string_append_len (address, buf, bytes); newline = strchr (address->str, '\n'); if (newline != NULL) { if ((newline > address->str) && ('\r' == newline[-1])) newline -= 1; g_string_truncate (address, newline - address->str); break; } g_usleep (G_USEC_PER_SEC / 10); } g_close (address_fd, NULL); return g_string_free (address, FALSE); }
static gboolean csm_logout_dialog_timeout (gpointer data) { CsmLogoutDialog *logout_dialog; char *seconds_warning; char *secondary_text; int seconds_to_show; logout_dialog = (CsmLogoutDialog *) data; if (!logout_dialog->priv->timeout) { gtk_dialog_response (GTK_DIALOG (logout_dialog), logout_dialog->priv->default_response); return FALSE; } if (logout_dialog->priv->timeout <= 30) { seconds_to_show = logout_dialog->priv->timeout; } else { seconds_to_show = (logout_dialog->priv->timeout/10) * 10; if (logout_dialog->priv->timeout % 10) seconds_to_show += 10; } switch (logout_dialog->priv->type) { case CSM_DIALOG_LOGOUT_TYPE_LOGOUT: /* This string is shared with csm-fail-whale-dialog.c */ seconds_warning = ngettext ("You will be automatically logged " "out in %d second.", "You will be automatically logged " "out in %d seconds.", seconds_to_show); break; case CSM_DIALOG_LOGOUT_TYPE_SHUTDOWN: seconds_warning = ngettext ("This system will be automatically " "shut down in %d second.", "This system will be automatically " "shut down in %d seconds.", seconds_to_show); break; case CSM_DIALOG_LOGOUT_TYPE_REBOOT: seconds_warning = ngettext ("This system will be automatically " "restarted in %d second.", "This system will be automatically " "restarted in %d seconds.", seconds_to_show); break; default: g_assert_not_reached (); } if (!csm_system_is_login_session (logout_dialog->priv->system)) { char *name, *tmp; name = g_locale_to_utf8 (g_get_real_name (), -1, NULL, NULL, NULL); if (!name || name[0] == '\0' || strcmp (name, "Unknown") == 0) { name = g_locale_to_utf8 (g_get_user_name (), -1 , NULL, NULL, NULL); } if (!name) { name = g_strdup (g_get_user_name ()); } tmp = g_strdup_printf (_("You are currently logged in as \"%s\"."), name); secondary_text = g_strconcat (tmp, "\n", seconds_warning, NULL); g_free (tmp); g_free (name); } else { secondary_text = g_strdup (seconds_warning); } gtk_message_dialog_format_secondary_text (GTK_MESSAGE_DIALOG (logout_dialog), secondary_text, seconds_to_show, NULL); logout_dialog->priv->timeout--; g_free (secondary_text); return TRUE; }
int main_update_please(GtkWidget * update_button, gpointer data) { extern GtkWidget *connection_label; GtkWidget *dialog_vbox1; GtkWidget *vbox1; GtkWidget *hseparator3; GtkWidget *table1; GtkWidget *label3; GtkWidget *label6; GtkWidget *hseparator1; GtkWidget *label2; GtkWidget *label1; GtkWidget *dialog_action_area1; uploaded_bytes = 0.0; if (selected_site == NULL) { gnome_error_dialog("You must select a site if you want to upload the changes!"); return 0; } if (!selected_site->remote_is_different) { gfe_status("Remote and local sites are already synchronised."); return 1; } upload_total = selected_site->totalnew + selected_site->totalchanged; make_error_window(); upload_window = gnome_dialog_new("Update Progress", NULL); gtk_widget_set_usize(upload_window, 480, -2); dialog_vbox1 = GNOME_DIALOG(upload_window)->vbox; gtk_widget_show(dialog_vbox1); vbox1 = gtk_vbox_new(FALSE, 1); gtk_widget_ref(vbox1); gtk_widget_show(vbox1); gtk_box_pack_start(GTK_BOX(dialog_vbox1), vbox1, TRUE, TRUE, 0); hseparator3 = gtk_hseparator_new(); gtk_widget_ref(hseparator3); gtk_widget_show(hseparator3); gtk_box_pack_start(GTK_BOX(vbox1), hseparator3, TRUE, TRUE, 3); table1 = gtk_table_new(4, 2, FALSE); gtk_widget_show(table1); gtk_box_pack_start(GTK_BOX(vbox1), table1, TRUE, TRUE, 0); gtk_table_set_row_spacings(GTK_TABLE(table1), 1); gtk_table_set_col_spacings(GTK_TABLE(table1), 2); status_label = gtk_label_new("Click Upload to begin."); gtk_widget_show(status_label); connection_label = status_label; gtk_table_attach(GTK_TABLE(table1), status_label, 1, 2, 0, 1, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(status_label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(status_label), 7.45058e-09, 0.5); op_label = gtk_label_new(" "); gtk_widget_show(op_label); gtk_table_attach(GTK_TABLE(table1), op_label, 0, 2, 1, 2, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(op_label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(op_label), 7.45058e-09, 0.5); file_label = gtk_label_new(""); gtk_widget_show(file_label); gtk_table_attach(GTK_TABLE(table1), file_label, 0, 2, 2, 3, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(file_label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(file_label), 7.45058e-09, 0.5); label3 = gtk_label_new("Status: "); gtk_widget_show(label3); gtk_table_attach(GTK_TABLE(table1), label3, 0, 1, 0, 1, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(label3), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(label3), 7.45058e-09, 0.5); label6 = gtk_label_new("To: "); gtk_widget_show(label6); gtk_table_attach(GTK_TABLE(table1), label6, 0, 1, 3, 4, (GtkAttachOptions) (GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(label6), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(label6), 7.45058e-09, 0.5); dir_label = gtk_label_new(" "); gtk_widget_show(dir_label); gtk_table_attach(GTK_TABLE(table1), dir_label, 1, 2, 3, 4, (GtkAttachOptions) (GTK_EXPAND | GTK_FILL), (GtkAttachOptions) (0), 0, 0); gtk_label_set_justify(GTK_LABEL(dir_label), GTK_JUSTIFY_LEFT); gtk_misc_set_alignment(GTK_MISC(dir_label), 7.45058e-09, 0.5); hseparator1 = gtk_hseparator_new(); gtk_widget_show(hseparator1); gtk_box_pack_start(GTK_BOX(vbox1), hseparator1, TRUE, TRUE, 5); label2 = gtk_label_new("Current Progress"); gtk_widget_show(label2); gtk_box_pack_start(GTK_BOX(vbox1), label2, TRUE, FALSE, 2); gtk_misc_set_alignment(GTK_MISC(label2), 0.5, 1); main_progressbar = gtk_progress_bar_new(); gtk_widget_show(main_progressbar); gtk_box_pack_start(GTK_BOX(vbox1), main_progressbar, TRUE, FALSE, 0); gtk_progress_set_show_text(GTK_PROGRESS(main_progressbar), TRUE); label1 = gtk_label_new("Total Progress"); gtk_widget_show(label1); gtk_box_pack_start(GTK_BOX(vbox1), label1, TRUE, FALSE, 2); gtk_misc_set_alignment(GTK_MISC(label1), 0.5, 1); job_progressbar = gtk_progress_bar_new(); gtk_widget_show(job_progressbar); gtk_box_pack_start(GTK_BOX(vbox1), job_progressbar, TRUE, FALSE, 0); gtk_progress_set_show_text(GTK_PROGRESS(job_progressbar), TRUE); keep_going_button = gtk_check_button_new_with_label("Ignore any errors and always keep going."); gtk_widget_show(keep_going_button); gtk_box_pack_start(GTK_BOX(vbox1), keep_going_button, TRUE, TRUE, 0); dialog_action_area1 = GNOME_DIALOG(upload_window)->action_area; gtk_widget_show(dialog_action_area1); gtk_button_box_set_layout(GTK_BUTTON_BOX(dialog_action_area1), GTK_BUTTONBOX_END); gtk_button_box_set_spacing(GTK_BUTTON_BOX(dialog_action_area1), 8); gnome_dialog_append_button_with_pixmap(GNOME_DIALOG(upload_window), "Upload", GNOME_STOCK_PIXMAP_CONVERT); begin_button = g_list_last(GNOME_DIALOG(upload_window)->buttons)->data; gtk_widget_show(begin_button); GTK_WIDGET_SET_FLAGS(begin_button, GTK_CAN_DEFAULT); gnome_dialog_append_button_with_pixmap(GNOME_DIALOG(upload_window), "View Errors", GNOME_STOCK_PIXMAP_SEARCH); error_button = g_list_last(GNOME_DIALOG(upload_window)->buttons)->data; gtk_signal_connect_object(GTK_OBJECT(error_button), "clicked", GTK_SIGNAL_FUNC(gtk_widget_show), GTK_OBJECT(error_log_window)); gtk_widget_show(error_button); gtk_widget_set_sensitive(error_button, FALSE); GTK_WIDGET_SET_FLAGS(error_button, GTK_CAN_DEFAULT); gnome_dialog_append_button(GNOME_DIALOG(upload_window), GNOME_STOCK_BUTTON_CLOSE); close_button = g_list_last(GNOME_DIALOG(upload_window)->buttons)->data; gtk_signal_connect(GTK_OBJECT(close_button), "clicked", GTK_SIGNAL_FUNC(close_main_update_window), NULL); /* gtk_signal_connect_object(GTK_OBJECT(close_button), "clicked", GTK_SIGNAL_FUNC(gnome_dialog_close), (gpointer) upload_window); */ gtk_widget_show(close_button); GTK_WIDGET_SET_FLAGS(close_button, GTK_CAN_DEFAULT); if (strcmp((gchar *)data, "single") == 0) { gtk_signal_connect(GTK_OBJECT(begin_button), "clicked", GTK_SIGNAL_FUNC(start_main_update), "single"); } else if (strcmp((gchar *)data, "all") == 0) { gtk_signal_connect(GTK_OBJECT(begin_button), "clicked", GTK_SIGNAL_FUNC(start_main_update), "all"); } else { g_assert_not_reached(); } gtk_widget_show(upload_window); return 2; }
/* returns: notify_code (NC_XXXX) or 0 for success */ static gint log_reader_fetch_log(LogReader *self) { GSockAddr *sa; gint msg_count = 0; gboolean may_read = TRUE; if (self->waiting_for_preemption) may_read = FALSE; /* NOTE: this loop is here to decrease the load on the main loop, we try * to fetch a couple of messages in a single run (but only up to * fetch_limit). */ while (msg_count < self->options->fetch_limit && !main_loop_io_worker_job_quit()) { const guchar *msg; gsize msg_len; LogProtoStatus status; msg = NULL; sa = NULL; /* NOTE: may_read is used to implement multi-read checking. It * is initialized to TRUE to indicate that the protocol is * allowed to issue a read(). If multi-read is disallowed in the * protocol, it resets may_read to FALSE after the first read was issued. */ status = log_proto_server_fetch(self->proto, &msg, &msg_len, &sa, &may_read); switch (status) { case LPS_EOF: case LPS_ERROR: g_sockaddr_unref(sa); return status == LPS_ERROR ? NC_READ_ERROR : NC_CLOSE; case LPS_SUCCESS: break; default: g_assert_not_reached(); break; } if (!msg) { /* no more messages for now */ break; } if (msg_len > 0 || (self->options->flags & LR_EMPTY_LINES)) { msg_count++; if (!log_reader_handle_line(self, msg, msg_len, sa)) { /* window is full, don't generate further messages */ log_proto_server_queued(self->proto); g_sockaddr_unref(sa); break; } } log_proto_server_queued(self->proto); g_sockaddr_unref(sa); } if (self->options->flags & LR_PREEMPT) { if (log_proto_server_is_preemptable(self->proto)) { self->waiting_for_preemption = FALSE; log_pipe_notify(self->control, &self->super.super, NC_FILE_SKIP, self); } else { self->waiting_for_preemption = TRUE; } } if (msg_count == self->options->fetch_limit) self->immediate_check = TRUE; return 0; }
void mmcli_modem_run_synchronous (GDBusConnection *connection) { GError *error = NULL; if (monitor_state_flag) g_assert_not_reached (); /* Initialize context */ ctx = g_new0 (Context, 1); ctx->object = mmcli_get_modem_sync (connection, mmcli_get_common_modem_string (), &ctx->manager); ctx->modem = mm_object_get_modem (ctx->object); ctx->modem_3gpp = mm_object_get_modem_3gpp (ctx->object); ctx->modem_cdma = mm_object_get_modem_cdma (ctx->object); /* Setup operation timeout */ if (ctx->modem) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem)); if (ctx->modem_3gpp) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_3gpp)); if (ctx->modem_cdma) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_cdma)); /* Request to get info from modem? */ if (info_flag) { g_debug ("Printing modem info..."); print_modem_info (); return; } /* Request to enable the modem? */ if (enable_flag) { gboolean result; g_debug ("Synchronously enabling modem..."); result = mm_modem_enable_sync (ctx->modem, NULL, &error); enable_process_reply (result, error); return; } /* Request to disable the modem? */ if (disable_flag) { gboolean result; g_debug ("Synchronously disabling modem..."); result = mm_modem_disable_sync (ctx->modem, NULL, &error); disable_process_reply (result, error); return; } /* Request to set full power state? */ if (set_power_state_on_flag) { gboolean result; g_debug ("Synchronously setting full power..."); result = mm_modem_set_power_state_sync (ctx->modem, MM_MODEM_POWER_STATE_ON, NULL, &error); set_power_state_process_reply (result, error); return; } /* Request to set low power state? */ if (set_power_state_low_flag) { gboolean result; g_debug ("Synchronously setting low power..."); result = mm_modem_set_power_state_sync (ctx->modem, MM_MODEM_POWER_STATE_LOW, NULL, &error); set_power_state_process_reply (result, error); return; } /* Request to power off? */ if (set_power_state_off_flag) { gboolean result; g_debug ("Synchronously powering off..."); result = mm_modem_set_power_state_sync (ctx->modem, MM_MODEM_POWER_STATE_OFF, NULL, &error); set_power_state_process_reply (result, error); return; } /* Request to reset the modem? */ if (reset_flag) { gboolean result; g_debug ("Synchronously reseting modem..."); result = mm_modem_reset_sync (ctx->modem, NULL, &error); reset_process_reply (result, error); return; } /* Request to reset the modem to factory state? */ if (factory_reset_str) { gboolean result; g_debug ("Synchronously factory-reseting modem..."); result = mm_modem_factory_reset_sync (ctx->modem, factory_reset_str, NULL, &error); factory_reset_process_reply (result, error); return; } /* Request to send a command to the modem? */ if (command_str) { gchar *result; guint timeout; timeout = command_get_timeout (ctx->modem); g_debug ("Synchronously sending command to modem (%u seconds timeout)...", timeout); result = mm_modem_command_sync (ctx->modem, command_str, timeout, NULL, &error); command_process_reply (result, error); return; } /* Request to list the bearers? */ if (list_bearers_flag) { GList *result; g_debug ("Synchronously listing bearers..."); result = mm_modem_list_bearers_sync (ctx->modem, NULL, &error); list_bearers_process_reply (result, error); return; } /* Request to create a new bearer? */ if (create_bearer_str) { MMBearer *bearer; GError *error = NULL; MMBearerProperties *properties; properties = mm_bearer_properties_new_from_string (create_bearer_str, &error); if (!properties) { g_printerr ("Error parsing properties string: '%s'\n", error->message); exit (EXIT_FAILURE); } g_debug ("Synchronously creating new bearer in modem..."); bearer = mm_modem_create_bearer_sync (ctx->modem, properties, NULL, &error); g_object_unref (properties); create_bearer_process_reply (bearer, error); return; } /* Request to delete a given bearer? */ if (delete_bearer_str) { gboolean result; MMBearer *bearer; MMObject *obj = NULL; bearer = mmcli_get_bearer_sync (connection, delete_bearer_str, NULL, &obj); if (!g_str_equal (mm_object_get_path (obj), mm_modem_get_path (ctx->modem))) { g_printerr ("error: bearer '%s' not owned by modem '%s'", mm_bearer_get_path (bearer), mm_modem_get_path (ctx->modem)); exit (EXIT_FAILURE); } result = mm_modem_delete_bearer_sync (ctx->modem, mm_bearer_get_path (bearer), NULL, &error); g_object_unref (bearer); g_object_unref (obj); delete_bearer_process_reply (result, error); return; } /* Request to set capabilities in a given modem? */ if (set_current_capabilities_str) { gboolean result; MMModemCapability current_capabilities; parse_current_capabilities (¤t_capabilities); result = mm_modem_set_current_capabilities_sync (ctx->modem, current_capabilities, NULL, &error); set_current_capabilities_process_reply (result, error); return; } /* Request to set allowed modes in a given modem? */ if (set_allowed_modes_str) { MMModemMode allowed; MMModemMode preferred; gboolean result; parse_modes (&allowed, &preferred); result = mm_modem_set_current_modes_sync (ctx->modem, allowed, preferred, NULL, &error); set_current_modes_process_reply (result, error); return; } /* Request to set allowed bands in a given modem? */ if (set_current_bands_str) { gboolean result; MMModemBand *current_bands; guint n_current_bands; parse_current_bands (¤t_bands, &n_current_bands); result = mm_modem_set_current_bands_sync (ctx->modem, current_bands, n_current_bands, NULL, &error); g_free (current_bands); set_current_bands_process_reply (result, error); return; } g_warn_if_reached (); }
MonoMethod* mono_gc_get_write_barrier (void) { g_assert_not_reached (); return NULL; }
static void get_modem_ready (GObject *source, GAsyncResult *result, gpointer none) { ctx->object = mmcli_get_modem_finish (result, &ctx->manager); ctx->modem = mm_object_get_modem (ctx->object); ctx->modem_3gpp = mm_object_get_modem_3gpp (ctx->object); ctx->modem_cdma = mm_object_get_modem_cdma (ctx->object); /* Setup operation timeout */ if (ctx->modem) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem)); if (ctx->modem_3gpp) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_3gpp)); if (ctx->modem_cdma) mmcli_force_operation_timeout (G_DBUS_PROXY (ctx->modem_cdma)); if (info_flag) g_assert_not_reached (); /* Request to monitor modems? */ if (monitor_state_flag) { MMModemState current; g_signal_connect (ctx->modem, "state-changed", G_CALLBACK (state_changed), NULL); current = mm_modem_get_state (ctx->modem); g_print ("\t%s: Initial state, '%s'\n", mm_object_get_path (ctx->object), mm_modem_state_get_string (current)); /* If we get cancelled, operation done */ g_cancellable_connect (ctx->cancellable, G_CALLBACK (cancelled), NULL, NULL); return; } /* Request to enable the modem? */ if (enable_flag) { g_debug ("Asynchronously enabling modem..."); mm_modem_enable (ctx->modem, ctx->cancellable, (GAsyncReadyCallback)enable_ready, NULL); return; } /* Request to disable the modem? */ if (disable_flag) { g_debug ("Asynchronously disabling modem..."); mm_modem_disable (ctx->modem, ctx->cancellable, (GAsyncReadyCallback)disable_ready, NULL); return; } /* Request to full power the modem? */ if (set_power_state_on_flag) { g_debug ("Asynchronously setting full power..."); mm_modem_set_power_state (ctx->modem, MM_MODEM_POWER_STATE_ON, ctx->cancellable, (GAsyncReadyCallback)set_power_state_ready, NULL); return; } /* Request to low power the modem? */ if (set_power_state_low_flag) { g_debug ("Asynchronously setting low power..."); mm_modem_set_power_state (ctx->modem, MM_MODEM_POWER_STATE_LOW, ctx->cancellable, (GAsyncReadyCallback)set_power_state_ready, NULL); return; } /* Request to power off the modem? */ if (set_power_state_off_flag) { g_debug ("Asynchronously powering off..."); mm_modem_set_power_state (ctx->modem, MM_MODEM_POWER_STATE_OFF, ctx->cancellable, (GAsyncReadyCallback)set_power_state_ready, NULL); return; } /* Request to reset the modem? */ if (reset_flag) { g_debug ("Asynchronously reseting modem..."); mm_modem_reset (ctx->modem, ctx->cancellable, (GAsyncReadyCallback)reset_ready, NULL); return; } /* Request to reset the modem to factory state? */ if (factory_reset_str) { g_debug ("Asynchronously factory-reseting modem..."); mm_modem_factory_reset (ctx->modem, factory_reset_str, ctx->cancellable, (GAsyncReadyCallback)factory_reset_ready, NULL); return; } /* Request to send a command to the modem? */ if (command_str) { guint timeout; timeout = command_get_timeout (ctx->modem); g_debug ("Asynchronously sending a command to the modem (%u seconds timeout)...", timeout); mm_modem_command (ctx->modem, command_str, timeout, ctx->cancellable, (GAsyncReadyCallback)command_ready, NULL); return; } /* Request to list bearers? */ if (list_bearers_flag) { g_debug ("Asynchronously listing bearers in modem..."); mm_modem_list_bearers (ctx->modem, ctx->cancellable, (GAsyncReadyCallback)list_bearers_ready, NULL); return; } /* Request to create a new bearer? */ if (create_bearer_str) { GError *error = NULL; MMBearerProperties *properties; properties = mm_bearer_properties_new_from_string (create_bearer_str, &error); if (!properties) { g_printerr ("Error parsing properties string: '%s'\n", error->message); exit (EXIT_FAILURE); } g_debug ("Asynchronously creating new bearer in modem..."); mm_modem_create_bearer (ctx->modem, properties, ctx->cancellable, (GAsyncReadyCallback)create_bearer_ready, NULL); g_object_unref (properties); return; } /* Request to delete a given bearer? */ if (delete_bearer_str) { mmcli_get_bearer (ctx->connection, delete_bearer_str, ctx->cancellable, (GAsyncReadyCallback)get_bearer_to_delete_ready, NULL); return; } /* Request to set current capabilities in a given modem? */ if (set_current_capabilities_str) { MMModemCapability current_capabilities; parse_current_capabilities (¤t_capabilities); mm_modem_set_current_capabilities (ctx->modem, current_capabilities, ctx->cancellable, (GAsyncReadyCallback)set_current_capabilities_ready, NULL); return; } /* Request to set allowed modes in a given modem? */ if (set_allowed_modes_str) { MMModemMode allowed; MMModemMode preferred; parse_modes (&allowed, &preferred); mm_modem_set_current_modes (ctx->modem, allowed, preferred, ctx->cancellable, (GAsyncReadyCallback)set_current_modes_ready, NULL); return; } /* Request to set current bands in a given modem? */ if (set_current_bands_str) { MMModemBand *current_bands; guint n_current_bands; parse_current_bands (¤t_bands, &n_current_bands); mm_modem_set_current_bands (ctx->modem, current_bands, n_current_bands, ctx->cancellable, (GAsyncReadyCallback)set_current_bands_ready, NULL); g_free (current_bands); return; } g_warn_if_reached (); }
void mono_gc_wbarrier_value_copy_bitmap (gpointer _dest, gpointer _src, int size, unsigned bitmap) { g_assert_not_reached (); }
static gchar* thunar_sbr_number_renamer_process (ThunarxRenamer *renamer, ThunarxFileInfo *file, const gchar *text, guint idx) { ThunarSbrNumberRenamer *number_renamer = THUNAR_SBR_NUMBER_RENAMER (renamer); gboolean invalid = TRUE; gchar *endp; gchar *name; gchar *number = NULL; guint start = 0; /* check whether "start" is valid for the "mode" */ if (number_renamer->mode < THUNAR_SBR_NUMBER_MODE_ABC) { /* "start" must be a positive number */ start = strtoul (number_renamer->start, &endp, 10); invalid = (endp <= number_renamer->start || *endp != '\0'); } else if (number_renamer->mode == THUNAR_SBR_NUMBER_MODE_ABC) { /* "start" property must be 'a', 'b', 'c', etc. */ start = *number_renamer->start; invalid = (strlen (number_renamer->start) != 1 || g_ascii_tolower (start) < 'a' || g_ascii_tolower (start) > 'z'); } /* check if we have invalid settings */ if (G_UNLIKELY (invalid)) return g_strdup (text); /* format the number */ switch (number_renamer->mode) { case THUNAR_SBR_NUMBER_MODE_123: number = g_strdup_printf ("%u", start + idx); break; case THUNAR_SBR_NUMBER_MODE_010203: number = g_strdup_printf ("%02u", start + idx); break; case THUNAR_SBR_NUMBER_MODE_001002003: number = g_strdup_printf ("%03u", start + idx); break; case THUNAR_SBR_NUMBER_MODE_000100020003: number = g_strdup_printf ("%04u", start + idx); break; case THUNAR_SBR_NUMBER_MODE_ABC: if (start >= 'a' && start <= 'z') number = g_strdup_printf ("%c", (gchar) (MIN (start + idx, 'z'))); else if (start >= 'A' && start <= 'Z') number = g_strdup_printf ("%c", (gchar) (MIN (start + idx, 'Z'))); else g_assert_not_reached (); break; default: g_assert_not_reached (); break; } /* format the text */ switch (number_renamer->text_mode) { case THUNAR_SBR_TEXT_MODE_OTN: name = g_strconcat (text, number_renamer->text, number, NULL); break; case THUNAR_SBR_TEXT_MODE_NTO: name = g_strconcat (number, number_renamer->text, text, NULL); break; case THUNAR_SBR_TEXT_MODE_TN: name = g_strconcat (number_renamer->text, number, NULL); break; case THUNAR_SBR_TEXT_MODE_NT: name = g_strconcat (number, number_renamer->text, NULL); break; default: g_assert_not_reached (); break; } /* release the number */ g_free (number); /* return the new name */ return name; }
gboolean mono_gc_card_table_nursery_check (void) { g_assert_not_reached (); return TRUE; }
/** * g_callable_info_invoke: * @info: TODO * @function: TODO * @in_args: TODO * @n_in_args: TODO * @out_args: TODO * @n_out_args: TODO * @return_value: TODO * @is_method: TODO * @throws: TODO * @error: TODO * * TODO */ gboolean g_callable_info_invoke (GIFunctionInfo *info, gpointer function, const GIArgument *in_args, int n_in_args, const GIArgument *out_args, int n_out_args, GIArgument *return_value, gboolean is_method, gboolean throws, GError **error) { ffi_cif cif; ffi_type *rtype; ffi_type **atypes; GITypeInfo *tinfo; GITypeInfo *rinfo; GITypeTag rtag; GIArgInfo *ainfo; gint n_args, n_invoke_args, in_pos, out_pos, i; gpointer *args; gboolean success = FALSE; GError *local_error = NULL; gpointer error_address = &local_error; GIFFIReturnValue ffi_return_value; gpointer return_value_p; /* Will point inside the union return_value */ rinfo = g_callable_info_get_return_type ((GICallableInfo *)info); rtype = g_type_info_get_ffi_type (rinfo); rtag = g_type_info_get_tag(rinfo); in_pos = 0; out_pos = 0; n_args = g_callable_info_get_n_args ((GICallableInfo *)info); if (is_method) { if (n_in_args == 0) { g_set_error (error, G_INVOKE_ERROR, G_INVOKE_ERROR_ARGUMENT_MISMATCH, "Too few \"in\" arguments (handling this)"); goto out; } n_invoke_args = n_args+1; in_pos++; } else n_invoke_args = n_args; if (throws) /* Add an argument for the GError */ n_invoke_args ++; atypes = g_alloca (sizeof (ffi_type*) * n_invoke_args); args = g_alloca (sizeof (gpointer) * n_invoke_args); if (is_method) { atypes[0] = &ffi_type_pointer; args[0] = (gpointer) &in_args[0]; } for (i = 0; i < n_args; i++) { int offset = (is_method ? 1 : 0); ainfo = g_callable_info_get_arg ((GICallableInfo *)info, i); switch (g_arg_info_get_direction (ainfo)) { case GI_DIRECTION_IN: tinfo = g_arg_info_get_type (ainfo); atypes[i+offset] = g_type_info_get_ffi_type (tinfo); g_base_info_unref ((GIBaseInfo *)tinfo); if (in_pos >= n_in_args) { g_set_error (error, G_INVOKE_ERROR, G_INVOKE_ERROR_ARGUMENT_MISMATCH, "Too few \"in\" arguments (handling in)"); goto out; } args[i+offset] = (gpointer)&in_args[in_pos]; in_pos++; break; case GI_DIRECTION_OUT: atypes[i+offset] = &ffi_type_pointer; if (out_pos >= n_out_args) { g_set_error (error, G_INVOKE_ERROR, G_INVOKE_ERROR_ARGUMENT_MISMATCH, "Too few \"out\" arguments (handling out)"); goto out; } args[i+offset] = (gpointer)&out_args[out_pos]; out_pos++; break; case GI_DIRECTION_INOUT: atypes[i+offset] = &ffi_type_pointer; if (in_pos >= n_in_args) { g_set_error (error, G_INVOKE_ERROR, G_INVOKE_ERROR_ARGUMENT_MISMATCH, "Too few \"in\" arguments (handling inout)"); goto out; } if (out_pos >= n_out_args) { g_set_error (error, G_INVOKE_ERROR, G_INVOKE_ERROR_ARGUMENT_MISMATCH, "Too few \"out\" arguments (handling inout)"); goto out; } args[i+offset] = (gpointer)&in_args[in_pos]; in_pos++; out_pos++; break; default: g_assert_not_reached (); } g_base_info_unref ((GIBaseInfo *)ainfo); } if (throws) { args[n_invoke_args - 1] = &error_address; atypes[n_invoke_args - 1] = &ffi_type_pointer; } if (in_pos < n_in_args) { g_set_error (error, G_INVOKE_ERROR, G_INVOKE_ERROR_ARGUMENT_MISMATCH, "Too many \"in\" arguments (at end)"); goto out; } if (out_pos < n_out_args) { g_set_error (error, G_INVOKE_ERROR, G_INVOKE_ERROR_ARGUMENT_MISMATCH, "Too many \"out\" arguments (at end)"); goto out; } if (ffi_prep_cif (&cif, FFI_DEFAULT_ABI, n_invoke_args, rtype, atypes) != FFI_OK) goto out; g_return_val_if_fail (return_value, FALSE); /* See comment for GIFFIReturnValue above */ switch (rtag) { case GI_TYPE_TAG_FLOAT: return_value_p = &ffi_return_value.v_float; break; case GI_TYPE_TAG_DOUBLE: return_value_p = &ffi_return_value.v_double; break; case GI_TYPE_TAG_INT64: case GI_TYPE_TAG_UINT64: return_value_p = &ffi_return_value.v_uint64; break; default: return_value_p = &ffi_return_value.v_long; } ffi_call (&cif, function, return_value_p, args); if (local_error) { g_propagate_error (error, local_error); success = FALSE; } else { gi_type_info_extract_ffi_return_value (rinfo, &ffi_return_value, return_value); success = TRUE; } out: g_base_info_unref ((GIBaseInfo *)rinfo); return success; }
void * mono_gc_scan_object (void *obj, void *gc_data) { g_assert_not_reached (); return NULL; }
static GTokenType gimp_config_deserialize_fundamental (GValue *value, GParamSpec *prop_spec, GScanner *scanner) { GTokenType token; GType value_type; gboolean negate = FALSE; value_type = G_TYPE_FUNDAMENTAL (prop_spec->value_type); switch (value_type) { case G_TYPE_STRING: token = G_TOKEN_STRING; break; case G_TYPE_BOOLEAN: token = G_TOKEN_IDENTIFIER; break; case G_TYPE_INT: case G_TYPE_LONG: case G_TYPE_INT64: if (g_scanner_peek_next_token (scanner) == '-') { negate = TRUE; g_scanner_get_next_token (scanner); } /* fallthrough */ case G_TYPE_UINT: case G_TYPE_ULONG: case G_TYPE_UINT64: token = G_TOKEN_INT; break; case G_TYPE_FLOAT: case G_TYPE_DOUBLE: if (g_scanner_peek_next_token (scanner) == '-') { negate = TRUE; g_scanner_get_next_token (scanner); } token = G_TOKEN_FLOAT; break; default: g_assert_not_reached (); break; } if (g_scanner_peek_next_token (scanner) != token) { return token; } g_scanner_get_next_token (scanner); switch (value_type) { case G_TYPE_STRING: if (scanner_string_utf8_valid (scanner, prop_spec->name)) g_value_set_static_string (value, scanner->value.v_string); else return G_TOKEN_NONE; break; case G_TYPE_BOOLEAN: if (! g_ascii_strcasecmp (scanner->value.v_identifier, "yes") || ! g_ascii_strcasecmp (scanner->value.v_identifier, "true")) g_value_set_boolean (value, TRUE); else if (! g_ascii_strcasecmp (scanner->value.v_identifier, "no") || ! g_ascii_strcasecmp (scanner->value.v_identifier, "false")) g_value_set_boolean (value, FALSE); else { g_scanner_error (scanner, /* please don't translate 'yes' and 'no' */ _("expected 'yes' or 'no' for boolean token %s, got '%s'"), prop_spec->name, scanner->value.v_identifier); return G_TOKEN_NONE; } break; case G_TYPE_INT: g_value_set_int (value, (negate ? - scanner->value.v_int64 : scanner->value.v_int64)); break; case G_TYPE_UINT: g_value_set_uint (value, scanner->value.v_int64); break; case G_TYPE_LONG: g_value_set_long (value, (negate ? - scanner->value.v_int64 : scanner->value.v_int64)); break; case G_TYPE_ULONG: g_value_set_ulong (value, scanner->value.v_int64); break; case G_TYPE_INT64: g_value_set_int64 (value, (negate ? - scanner->value.v_int64 : scanner->value.v_int64)); break; case G_TYPE_UINT64: g_value_set_uint64 (value, scanner->value.v_int64); break; case G_TYPE_FLOAT: g_value_set_float (value, negate ? - scanner->value.v_float : scanner->value.v_float); break; case G_TYPE_DOUBLE: g_value_set_double (value, negate ? - scanner->value.v_float: scanner->value.v_float); break; default: g_assert_not_reached (); break; } return G_TOKEN_RIGHT_PAREN; }
static MonoMethod* create_allocator (int atype, int tls_key, gboolean slowpath) { int index_var, bytes_var, my_fl_var, my_entry_var; guint32 no_freelist_branch, not_small_enough_branch = 0; guint32 size_overflow_branch = 0; MonoMethodBuilder *mb; MonoMethod *res; MonoMethodSignature *csig; const char *name = NULL; WrapperInfo *info; if (atype == ATYPE_FREEPTR) { name = slowpath ? "SlowAllocPtrfree" : "AllocPtrfree"; } else if (atype == ATYPE_FREEPTR_FOR_BOX) { name = slowpath ? "SlowAllocPtrfreeBox" : "AllocPtrfreeBox"; } else if (atype == ATYPE_NORMAL) { name = slowpath ? "SlowAlloc" : "Alloc"; } else if (atype == ATYPE_GCJ) { name = slowpath ? "SlowAllocGcj" : "AllocGcj"; } else if (atype == ATYPE_STRING) { name = slowpath ? "SlowAllocString" : "AllocString"; } else { g_assert_not_reached (); } csig = mono_metadata_signature_alloc (mono_defaults.corlib, 2); if (atype == ATYPE_STRING) { csig->ret = &mono_defaults.string_class->byval_arg; csig->params [0] = &mono_defaults.int_class->byval_arg; csig->params [1] = &mono_defaults.int32_class->byval_arg; } else { csig->ret = &mono_defaults.object_class->byval_arg; csig->params [0] = &mono_defaults.int_class->byval_arg; csig->params [1] = &mono_defaults.int32_class->byval_arg; } mb = mono_mb_new (mono_defaults.object_class, name, MONO_WRAPPER_ALLOC); if (slowpath) goto always_slowpath; bytes_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg); if (atype == ATYPE_STRING) { /* a string alloator method takes the args: (vtable, len) */ /* bytes = (offsetof (MonoString, chars) + ((len + 1) * 2)); */ mono_mb_emit_ldarg (mb, 1); mono_mb_emit_icon (mb, 1); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_icon (mb, 1); mono_mb_emit_byte (mb, MONO_CEE_SHL); // sizeof (MonoString) might include padding mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, chars)); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_stloc (mb, bytes_var); } else { mono_mb_emit_ldarg (mb, 1); mono_mb_emit_stloc (mb, bytes_var); } /* this is needed for strings/arrays only as the other big types are never allocated with this method */ if (atype == ATYPE_STRING) { /* check for size */ /* if (!SMALL_ENOUGH (bytes)) jump slow_path;*/ mono_mb_emit_ldloc (mb, bytes_var); mono_mb_emit_icon (mb, (NFREELISTS-1) * GRANULARITY); not_small_enough_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BGT_UN_S); /* check for overflow */ mono_mb_emit_ldloc (mb, bytes_var); mono_mb_emit_icon (mb, sizeof (MonoString)); size_overflow_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLE_UN_S); } /* int index = INDEX_FROM_BYTES(bytes); */ index_var = mono_mb_add_local (mb, &mono_defaults.int32_class->byval_arg); mono_mb_emit_ldloc (mb, bytes_var); mono_mb_emit_icon (mb, GRANULARITY - 1); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_icon (mb, shift_amount (GRANULARITY)); mono_mb_emit_byte (mb, MONO_CEE_SHR_UN); mono_mb_emit_icon (mb, shift_amount (sizeof (gpointer))); mono_mb_emit_byte (mb, MONO_CEE_SHL); /* index var is already adjusted into bytes */ mono_mb_emit_stloc (mb, index_var); my_fl_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg); my_entry_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg); /* my_fl = ((GC_thread)tsd) -> ptrfree_freelists + index; */ mono_mb_emit_byte (mb, MONO_CUSTOM_PREFIX); mono_mb_emit_byte (mb, 0x0D); /* CEE_MONO_TLS */ mono_mb_emit_i4 (mb, tls_key); if (atype == ATYPE_FREEPTR || atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING) mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, ptrfree_freelists)); else if (atype == ATYPE_NORMAL) mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, normal_freelists)); else if (atype == ATYPE_GCJ) mono_mb_emit_icon (mb, G_STRUCT_OFFSET (struct GC_Thread_Rep, gcj_freelists)); else g_assert_not_reached (); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_ldloc (mb, index_var); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_stloc (mb, my_fl_var); /* my_entry = *my_fl; */ mono_mb_emit_ldloc (mb, my_fl_var); mono_mb_emit_byte (mb, MONO_CEE_LDIND_I); mono_mb_emit_stloc (mb, my_entry_var); /* if (EXPECT((word)my_entry >= HBLKSIZE, 1)) { */ mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_icon (mb, HBLKSIZE); no_freelist_branch = mono_mb_emit_short_branch (mb, MONO_CEE_BLT_UN_S); /* ptr_t next = obj_link(my_entry); *my_fl = next; */ mono_mb_emit_ldloc (mb, my_fl_var); mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_byte (mb, MONO_CEE_LDIND_I); mono_mb_emit_byte (mb, MONO_CEE_STIND_I); /* set the vtable and clear the words in the object */ mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_ldarg (mb, 0); mono_mb_emit_byte (mb, MONO_CEE_STIND_I); if (atype == ATYPE_FREEPTR) { int start_var, end_var, start_loop; /* end = my_entry + bytes; start = my_entry + sizeof (gpointer); */ start_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg); end_var = mono_mb_add_local (mb, &mono_defaults.int_class->byval_arg); mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_ldloc (mb, bytes_var); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_stloc (mb, end_var); mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation)); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_stloc (mb, start_var); /* * do { * *start++ = NULL; * } while (start < end); */ start_loop = mono_mb_get_label (mb); mono_mb_emit_ldloc (mb, start_var); mono_mb_emit_icon (mb, 0); mono_mb_emit_byte (mb, MONO_CEE_STIND_I); mono_mb_emit_ldloc (mb, start_var); mono_mb_emit_icon (mb, sizeof (gpointer)); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_stloc (mb, start_var); mono_mb_emit_ldloc (mb, start_var); mono_mb_emit_ldloc (mb, end_var); mono_mb_emit_byte (mb, MONO_CEE_BLT_UN_S); mono_mb_emit_byte (mb, start_loop - (mono_mb_get_label (mb) + 1)); } else if (atype == ATYPE_FREEPTR_FOR_BOX || atype == ATYPE_STRING) { /* need to clear just the sync pointer */ mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoObject, synchronisation)); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_icon (mb, 0); mono_mb_emit_byte (mb, MONO_CEE_STIND_I); } if (atype == ATYPE_STRING) { /* need to set length and clear the last char */ /* s->length = len; */ mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_icon (mb, G_STRUCT_OFFSET (MonoString, length)); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_ldarg (mb, 1); mono_mb_emit_byte (mb, MONO_CEE_STIND_I4); /* s->chars [len] = 0; */ mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_ldloc (mb, bytes_var); mono_mb_emit_icon (mb, 2); mono_mb_emit_byte (mb, MONO_CEE_SUB); mono_mb_emit_byte (mb, MONO_CEE_ADD); mono_mb_emit_icon (mb, 0); mono_mb_emit_byte (mb, MONO_CEE_STIND_I2); } /* return my_entry; */ mono_mb_emit_ldloc (mb, my_entry_var); mono_mb_emit_byte (mb, MONO_CEE_RET); mono_mb_patch_short_branch (mb, no_freelist_branch); if (not_small_enough_branch > 0) mono_mb_patch_short_branch (mb, not_small_enough_branch); if (size_overflow_branch > 0) mono_mb_patch_short_branch (mb, size_overflow_branch); /* the slow path: we just call back into the runtime */ always_slowpath: if (atype == ATYPE_STRING) { mono_mb_emit_ldarg (mb, 1); mono_mb_emit_icall (mb, mono_string_alloc); } else { mono_mb_emit_ldarg (mb, 0); mono_mb_emit_icall (mb, mono_object_new_specific); } mono_mb_emit_byte (mb, MONO_CEE_RET); info = mono_wrapper_info_create (mb, WRAPPER_SUBTYPE_NONE); info->d.alloc.gc_name = "boehm"; info->d.alloc.alloc_type = atype; res = mono_mb_create (mb, csig, 8, info); mono_mb_free (mb); mono_method_get_header (res)->init_locals = FALSE; return res; }
gboolean _g_dbus_auth_run_server (GDBusAuth *auth, GDBusAuthObserver *observer, const gchar *guid, gboolean allow_anonymous, GDBusCapabilityFlags offered_capabilities, GDBusCapabilityFlags *out_negotiated_capabilities, GCredentials **out_received_credentials, GCancellable *cancellable, GError **error) { gboolean ret; ServerState state; GDataInputStream *dis; GDataOutputStream *dos; GError *local_error; guchar byte; gchar *line; gsize line_length; GDBusAuthMechanism *mech; gchar *s; GDBusCapabilityFlags negotiated_capabilities; GCredentials *credentials; debug_print ("SERVER: initiating"); ret = FALSE; dis = NULL; dos = NULL; mech = NULL; negotiated_capabilities = 0; credentials = NULL; if (!g_dbus_is_guid (guid)) { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "The given guid `%s' is not valid", guid); goto out; } dis = G_DATA_INPUT_STREAM (g_data_input_stream_new (g_io_stream_get_input_stream (auth->priv->stream))); dos = G_DATA_OUTPUT_STREAM (g_data_output_stream_new (g_io_stream_get_output_stream (auth->priv->stream))); g_filter_input_stream_set_close_base_stream (G_FILTER_INPUT_STREAM (dis), FALSE); g_filter_output_stream_set_close_base_stream (G_FILTER_OUTPUT_STREAM (dos), FALSE); g_data_input_stream_set_newline_type (dis, G_DATA_STREAM_NEWLINE_TYPE_CR_LF); /* first read the NUL-byte (TODO: read credentials if using a unix domain socket) */ #ifdef G_OS_UNIX if (G_IS_UNIX_CONNECTION (auth->priv->stream) && g_unix_credentials_message_is_supported ()) { local_error = NULL; credentials = g_unix_connection_receive_credentials (G_UNIX_CONNECTION (auth->priv->stream), cancellable, &local_error); if (credentials == NULL) { g_propagate_error (error, local_error); goto out; } } else { local_error = NULL; byte = g_data_input_stream_read_byte (dis, cancellable, &local_error); if (local_error != NULL) { g_propagate_error (error, local_error); goto out; } } #else local_error = NULL; byte = g_data_input_stream_read_byte (dis, cancellable, &local_error); if (local_error != NULL) { g_propagate_error (error, local_error); goto out; } #endif if (credentials != NULL) { if (G_UNLIKELY (_g_dbus_debug_authentication ())) { s = g_credentials_to_string (credentials); debug_print ("SERVER: received credentials `%s'", s); g_free (s); } } else { debug_print ("SERVER: didn't receive any credentials"); } state = SERVER_STATE_WAITING_FOR_AUTH; while (TRUE) { switch (state) { case SERVER_STATE_WAITING_FOR_AUTH: debug_print ("SERVER: WaitingForAuth"); line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error); debug_print ("SERVER: WaitingForAuth, read `%s'", line); if (line == NULL) goto out; if (g_strcmp0 (line, "AUTH") == 0) { s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " "); debug_print ("SERVER: writing `%s'", s); if (!g_data_output_stream_put_string (dos, s, cancellable, error)) { g_free (s); goto out; } g_free (s); g_free (line); } else if (g_str_has_prefix (line, "AUTH ")) { gchar **tokens; const gchar *encoded; const gchar *mech_name; GType auth_mech_to_use_gtype; tokens = g_strsplit (line, " ", 0); g_free (line); switch (g_strv_length (tokens)) { case 2: /* no initial response */ mech_name = tokens[1]; encoded = NULL; break; case 3: /* initial response */ mech_name = tokens[1]; encoded = tokens[2]; break; default: g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Unexpected line `%s' while in WaitingForAuth state", line); g_strfreev (tokens); goto out; } /* TODO: record that the client has attempted to use this mechanism */ //g_debug ("client is trying `%s'", mech_name); auth_mech_to_use_gtype = find_mech_by_name (auth, mech_name); if ((auth_mech_to_use_gtype == (GType) 0) || (!allow_anonymous && g_strcmp0 (mech_name, "ANONYMOUS") == 0)) { /* We don't support this auth mechanism */ g_strfreev (tokens); s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " "); debug_print ("SERVER: writing `%s'", s); if (!g_data_output_stream_put_string (dos, s, cancellable, error)) { g_free (s); goto out; } g_free (s); /* stay in WAITING FOR AUTH */ state = SERVER_STATE_WAITING_FOR_AUTH; } else { gchar *initial_response; gsize initial_response_len; mech = g_object_new (auth_mech_to_use_gtype, "stream", auth->priv->stream, "credentials", credentials, NULL); initial_response = NULL; initial_response_len = 0; if (encoded != NULL) { initial_response = hexdecode (encoded, &initial_response_len, error); if (initial_response == NULL) { g_prefix_error (error, "Initial response is malformed: "); /* invalid encoding, disconnect! */ g_strfreev (tokens); goto out; } } _g_dbus_auth_mechanism_server_initiate (mech, initial_response, initial_response_len); g_free (initial_response); g_strfreev (tokens); change_state: switch (_g_dbus_auth_mechanism_server_get_state (mech)) { case G_DBUS_AUTH_MECHANISM_STATE_ACCEPTED: if (observer != NULL && !g_dbus_auth_observer_authorize_authenticated_peer (observer, auth->priv->stream, credentials)) { /* disconnect */ g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Cancelled via GDBusAuthObserver::authorize-authenticated-peer")); goto out; } else { s = g_strdup_printf ("OK %s\r\n", guid); debug_print ("SERVER: writing `%s'", s); if (!g_data_output_stream_put_string (dos, s, cancellable, error)) { g_free (s); goto out; } g_free (s); state = SERVER_STATE_WAITING_FOR_BEGIN; } break; case G_DBUS_AUTH_MECHANISM_STATE_REJECTED: s = get_auth_mechanisms (auth, allow_anonymous, "REJECTED ", "\r\n", " "); debug_print ("SERVER: writing `%s'", s); if (!g_data_output_stream_put_string (dos, s, cancellable, error)) { g_free (s); goto out; } g_free (s); state = SERVER_STATE_WAITING_FOR_AUTH; break; case G_DBUS_AUTH_MECHANISM_STATE_WAITING_FOR_DATA: state = SERVER_STATE_WAITING_FOR_DATA; break; case G_DBUS_AUTH_MECHANISM_STATE_HAVE_DATA_TO_SEND: { gchar *data; gsize data_len; gchar *encoded_data; data = _g_dbus_auth_mechanism_server_data_send (mech, &data_len); encoded_data = hexencode (data); s = g_strdup_printf ("DATA %s\r\n", encoded_data); g_free (encoded_data); g_free (data); debug_print ("SERVER: writing `%s'", s); if (!g_data_output_stream_put_string (dos, s, cancellable, error)) { g_free (s); goto out; } g_free (s); } goto change_state; break; default: /* TODO */ g_assert_not_reached (); break; } } } else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Unexpected line `%s' while in WaitingForAuth state", line); g_free (line); goto out; } break; case SERVER_STATE_WAITING_FOR_DATA: debug_print ("SERVER: WaitingForData"); line = _my_g_data_input_stream_read_line (dis, &line_length, cancellable, error); debug_print ("SERVER: WaitingForData, read `%s'", line); if (line == NULL) goto out; if (g_str_has_prefix (line, "DATA ")) { gchar *encoded; gchar *decoded_data; gsize decoded_data_len; encoded = g_strdup (line + 5); g_free (line); g_strstrip (encoded); decoded_data = hexdecode (encoded, &decoded_data_len, error); g_free (encoded); if (decoded_data == NULL) { g_prefix_error (error, "DATA response is malformed: "); /* invalid encoding, disconnect! */ goto out; } _g_dbus_auth_mechanism_server_data_receive (mech, decoded_data, decoded_data_len); g_free (decoded_data); /* oh man, this goto-crap is so ugly.. really need to rewrite the state machine */ goto change_state; } else { g_set_error (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Unexpected line `%s' while in WaitingForData state", line); g_free (line); } goto out; case SERVER_STATE_WAITING_FOR_BEGIN: debug_print ("SERVER: WaitingForBegin"); /* Use extremely slow (but reliable) line reader - this basically * does a recvfrom() system call per character * * (the problem with using GDataInputStream's read_line is that because of * buffering it might start reading into the first D-Bus message that * appears after "BEGIN\r\n"....) */ line = _my_g_input_stream_read_line_safe (g_io_stream_get_input_stream (auth->priv->stream), &line_length, cancellable, error); debug_print ("SERVER: WaitingForBegin, read `%s'", line); if (line == NULL) goto out; if (g_strcmp0 (line, "BEGIN") == 0) { /* YAY, done! */ ret = TRUE; g_free (line); goto out; } else if (g_strcmp0 (line, "NEGOTIATE_UNIX_FD") == 0) { g_free (line); if (offered_capabilities & G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING) { negotiated_capabilities |= G_DBUS_CAPABILITY_FLAGS_UNIX_FD_PASSING; s = "AGREE_UNIX_FD\r\n"; debug_print ("SERVER: writing `%s'", s); if (!g_data_output_stream_put_string (dos, s, cancellable, error)) goto out; } else { s = "ERROR \"fd passing not offered\"\r\n"; debug_print ("SERVER: writing `%s'", s); if (!g_data_output_stream_put_string (dos, s, cancellable, error)) goto out; } } else { g_debug ("Unexpected line `%s' while in WaitingForBegin state", line); g_free (line); s = "ERROR \"Unknown Command\"\r\n"; debug_print ("SERVER: writing `%s'", s); if (!g_data_output_stream_put_string (dos, s, cancellable, error)) goto out; } break; default: g_assert_not_reached (); break; } } g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Not implemented (server)"); out: if (mech != NULL) g_object_unref (mech); if (dis != NULL) g_object_unref (dis); if (dos != NULL) g_object_unref (dos); /* ensure return value is FALSE if error is set */ if (error != NULL && *error != NULL) { ret = FALSE; } if (ret) { if (out_negotiated_capabilities != NULL) *out_negotiated_capabilities = negotiated_capabilities; if (out_received_credentials != NULL) *out_received_credentials = credentials != NULL ? g_object_ref (credentials) : NULL; } if (credentials != NULL) g_object_unref (credentials); debug_print ("SERVER: Done, authenticated=%d", ret); return ret; }