static char * decode_estring (unsigned char **in, unsigned char *inend, GError **err) { unsigned char *inptr, *start; char *qstring = NULL; inptr = *in; while (inptr < inend && *inptr == ' ') inptr++; if (inptr == inend) { *in = inptr; set_error (err, in); return NULL; } if (strncmp ((const char *) inptr, "NIL", 3) != 0) { if (*inptr == '(') { gboolean first = TRUE; GString *str = NULL; if (*inptr != '(') { *in = inptr; set_error (err, in); return NULL; } str = g_string_new (""); inptr++; /* My '(' */ while (*inptr == '(') { char *separator = NULL; char *name = NULL; char *user = NULL; char *server = NULL; inptr++; /* My '(' */ if (!first) g_string_append (str, ", "); first = FALSE; name = decode_qstring (&inptr, inend, err); separator = decode_qstring (&inptr, inend, err); user = decode_qstring (&inptr, inend, err); server = decode_qstring (&inptr, inend, err); if (name) { g_string_append (str, name); g_string_append (str, " <"); } if (user && server) { g_string_append (str, user); g_string_append_c (str, '@'); } if (server) g_string_append (str, server); if (name) g_string_append_c (str, '>'); if (separator) g_free (separator); if (name) g_free (name); if (user) g_free (user); if (server) g_free (server); if (*inptr != ')') { *in = inptr; set_error (err, in); g_string_free (str, TRUE); return NULL; } inptr++; /* My ')' */ /* Read spaces */ while (inptr < inend && *inptr == ' ') inptr++; } /* TODO: check for ')' */ if (*inptr != ')') g_warning ("strange"); inptr++; /* My ')' */ qstring = str->str; g_string_free (str, FALSE); } else { if (strncmp ((const char *) inptr, "NIL", 3) != 0) { if (*inptr != '"') { *in = inptr; set_error (err, in); return NULL; } inptr++; start = inptr; while (inptr < inend) { if (*inptr == '"' && inptr[-1] != '\\') break; inptr++; } qstring = g_strndup ((const char *) start, inptr - start); unescape_qstring (qstring); if (*inptr != '"') { *in = inptr; g_free (qstring); set_error (err, in); return NULL; } inptr++; } else inptr += 3; } } else inptr += 3; *in = inptr; return qstring; }
/* * @node must be a <command> tag */ static gchar * help_xml_doc_to_string_single_command (xmlNodePtr node, gint width, gboolean color_term) { g_assert (!strcmp ((gchar*) node->name, "command")); /* create output string */ GString *string; string = g_string_new (""); for (node = node->children; node; node = node->next) { xmlChar *data = NULL; if (!strcmp ((gchar*) node->name, "shortdescription")) { data = xmlNodeGetContent (node); if (data) { append_to_string (string, (gchar*) data, width, 0); g_string_append (string, "\n"); } } else if (!strcmp ((gchar*) node->name, "usage") || !strcmp ((gchar*) node->name, "example")) { if (!strcmp ((gchar*) node->name, "usage")) append_to_string (string, _("Usage"), width, 0); else append_to_string (string, _("Example"), width, 0); g_string_append (string, ":\n"); xmlNodePtr snode; for (snode = node->children; snode; snode = snode->next) { if (!strcmp ((gchar*) snode->name, "synopsis")) { data = xmlNodeGetContent (snode); if (data) { append_to_string (string, "> ", width, 3); gchar *tmp; tmp = g_strdup_printf ("%s%s%s", base_tool_output_color_s (BASE_TOOL_COLOR_BOLD, color_term), data, base_tool_output_color_s (BASE_TOOL_COLOR_RESET, color_term)); append_to_string (string, tmp, width, 3); g_free (tmp); g_string_append_c (string, '\n'); } } else if (!strcmp ((gchar*) snode->name, "comment")) { data = xmlNodeGetContent (snode); if (data) { append_to_string (string, (gchar*) data, width, 6); g_string_append_c (string, '\n'); } } else if (!strcmp ((gchar*) snode->name, "raw")) { data = xmlNodeGetContent (snode); if (data) { append_raw_to_string (string, (gchar*) data, width, 6); g_string_append (string, "\n\n"); } } if (data) xmlFree (data); data = NULL; } } if (data) xmlFree (data); } return g_string_free (string, FALSE); }
/* let the user select its preferred completion */ void editcmd_dialog_completion_show (WEdit * edit, int max_len, int word_len, struct selection *compl, int num_compl) { int start_x, start_y, offset, i; char *curr = NULL; Dlg_head *compl_dlg; WListbox *compl_list; int compl_dlg_h; /* completion dialog height */ int compl_dlg_w; /* completion dialog width */ /* calculate the dialog metrics */ compl_dlg_h = num_compl + 2; compl_dlg_w = max_len + 4; start_x = edit->curs_col + edit->start_col - (compl_dlg_w / 2) + EDIT_TEXT_HORIZONTAL_OFFSET + option_line_state_width; start_y = edit->curs_row + EDIT_TEXT_VERTICAL_OFFSET + 1; if (start_x < 0) start_x = 0; if (compl_dlg_w > COLS) compl_dlg_w = COLS; if (compl_dlg_h > LINES - 2) compl_dlg_h = LINES - 2; offset = start_x + compl_dlg_w - COLS; if (offset > 0) start_x -= offset; offset = start_y + compl_dlg_h - LINES; if (offset > 0) start_y -= (offset + 1); /* create the dialog */ compl_dlg = create_dlg (start_y, start_x, compl_dlg_h, compl_dlg_w, dialog_colors, NULL, "[Completion]", NULL, DLG_COMPACT); /* create the listbox */ compl_list = listbox_new (1, 1, compl_dlg_h - 2, compl_dlg_w - 2, NULL); /* add the dialog */ add_widget (compl_dlg, compl_list); /* fill the listbox with the completions */ for (i = num_compl - 1; i >= 0; i--) /* reverse order */ listbox_add_item (compl_list, LISTBOX_APPEND_AT_END, 0, (char *) compl[i].text, NULL); /* pop up the dialog and apply the choosen completion */ if (run_dlg (compl_dlg) == B_ENTER) { listbox_get_current (compl_list, &curr, NULL); if (curr) { #ifdef HAVE_CHARSET GString *temp, *temp2; temp = g_string_new(""); for (curr += word_len; *curr; curr++) g_string_append_c(temp, *curr); temp2 = str_convert_to_input (temp->str); if (temp2 && temp2->len){ g_string_free(temp, TRUE); temp = temp2; } else g_string_free(temp2, TRUE); for (curr = temp->str; *curr; curr++) edit_insert (edit, *curr); g_string_free(temp, TRUE); #else for (curr += word_len; *curr; curr++) edit_insert (edit, *curr); #endif } } /* destroy dialog before return */ destroy_dlg (compl_dlg); }
static gboolean commit_editor (OstreeRepo *repo, const char *branch, char **subject, char **body, GCancellable *cancellable, GError **error) { g_autofree char *input = NULL; g_autofree char *output = NULL; gboolean ret = FALSE; g_autoptr(GString) bodybuf = NULL; char **lines = NULL; int i; input = g_strdup_printf ("\n" "# Please enter the commit message for your changes. The first line will\n" "# become the subject, and the remainder the body. Lines starting\n" "# with '#' will be ignored, and an empty message aborts the commit." "%s%s%s%s%s%s\n" , branch ? "\n#\n# Branch: " : "", branch ? branch : "" , *subject ? "\n" : "", *subject ? *subject : "" , *body ? "\n" : "", *body ? *body : "" ); *subject = NULL; *body = NULL; output = ot_editor_prompt (repo, input, cancellable, error); if (output == NULL) goto out; lines = g_strsplit (output, "\n", -1); for (i = 0; lines[i] != NULL; i++) { g_strchomp (lines[i]); /* Lines starting with # are skipped */ if (lines[i][0] == '#') continue; /* Blank lines before body starts are skipped */ if (lines[i][0] == '\0') { if (!bodybuf) continue; } if (!*subject) { *subject = g_strdup (lines[i]); } else if (!bodybuf) { bodybuf = g_string_new (lines[i]); } else { g_string_append_c (bodybuf, '\n'); g_string_append (bodybuf, lines[i]); } } if (!*subject) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, "Aborting commit due to empty commit subject."); goto out; } if (bodybuf) { *body = g_string_free (bodybuf, FALSE); g_strchomp (*body); bodybuf = NULL; } ret = TRUE; out: g_strfreev (lines); return ret; }
static void options_form_param_changed_cb (G_GNUC_UNUSED GdauiBasicForm *form, G_GNUC_UNUSED GdaHolder *param, G_GNUC_UNUSED gboolean is_user_modif, TablePreferences *tpref) { GtkTreeIter iter; if (tpref->priv->save_plugin_changes && gtk_combo_box_get_active_iter (GTK_COMBO_BOX (tpref->priv->plugins_combo), &iter)) { GdauiPlugin *plugin; GError *error = NULL; GString *plugin_all = NULL; gtk_tree_model_get (tpref->priv->plugins_model, &iter, PL_COLUMN_PLUGIN, &plugin, -1); if (plugin) { plugin_all = g_string_new (plugin->plugin_name); if (tpref->priv->options_wid) { GdaSet *plist; GSList *list; gboolean first = TRUE; plist = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (tpref->priv->options_wid)); for (list = plist->holders; list; list = list->next) { GdaHolder *holder; const GValue *cvalue; gchar *str, *r1, *r2; holder = GDA_HOLDER (list->data); if (! gda_holder_is_valid (holder)) continue; cvalue = gda_holder_get_value (holder); if (G_VALUE_TYPE (cvalue) == GDA_TYPE_NULL) continue; if (first) { g_string_append_c (plugin_all, ':'); first = FALSE; } else g_string_append_c (plugin_all, ';'); str = gda_value_stringify (cvalue); r1 = gda_rfc1738_encode (str); g_free (str); r2 = gda_rfc1738_encode (gda_holder_get_id (holder)); g_string_append_printf (plugin_all, "%s=%s", r2, r1); g_free (r1); g_free (r2); } } } g_signal_handlers_block_by_func (tpref->priv->columns_store, G_CALLBACK (columns_model_row_changed_cb), tpref); if (tpref->priv->current_table && tpref->priv->current_column && ! t_connection_set_table_column_attribute (tpref->priv->tcnc, tpref->priv->current_table, tpref->priv->current_column, T_CONNECTION_COLUMN_PLUGIN, plugin_all ? plugin_all->str : NULL, &error)) { TO_IMPLEMENT; /* FIXME: add a notice somewhere in the UI */ g_warning ("Error: %s\n", error && error->message ? error->message : _("No detail")); g_clear_error (&error); } g_signal_handlers_unblock_by_func (tpref->priv->columns_store, G_CALLBACK (columns_model_row_changed_cb), tpref); if (plugin_all) g_string_free (plugin_all, TRUE); } set_preview_widget (tpref); }
static gboolean decode_filename (const char *filename, char **service, char **type, char **domain) { const char *p; char *end; GString *string; *service = NULL; *type = NULL; *domain = NULL; string = g_string_new (NULL); p = filename; while (*p && *p != '.') { if (*p == '\\') { p++; switch (*p) { case 's': g_string_append_c (string, '/'); break; case '\\': g_string_append_c (string, '\\'); break; case '.': g_string_append_c (string, '.'); break; default: g_string_free (string, TRUE); return FALSE; } } else { g_string_append_c (string, *p); } p++; } *service = g_string_free (string, FALSE); if (*p == 0) goto error; p++; end = strchr (p, '.'); if (end == NULL) goto error; end = strchr (end+1, '.'); if (end == NULL) goto error; *end = 0; *type = g_strdup (p); p = end + 1; if (*p == 0 || *p == '.') goto error; *domain = g_strdup (p); return TRUE; error: g_free (*service); g_free (*type); return FALSE; }
static char * str_utf8_create_key_gen (const char *text, int case_sen, gchar * (*keygen) (const gchar * text, gssize size)) { char *result; if (case_sen) result = str_utf8_normalize (text); else { gboolean dot; GString *fixed; const char *start, *end; char *fold, *key; dot = text[0] == '.'; fixed = g_string_sized_new (16); if (!dot) start = text; else { start = text + 1; g_string_append_c (fixed, '.'); } while (!g_utf8_validate (start, -1, &end) && start[0] != '\0') { if (start != end) { fold = g_utf8_casefold (start, end - start); key = keygen (fold, -1); g_string_append (fixed, key); g_free (key); g_free (fold); } g_string_append_c (fixed, end[0]); start = end + 1; } if (start == text) { fold = g_utf8_casefold (start, -1); result = keygen (fold, -1); g_free (fold); g_string_free (fixed, TRUE); } else if (dot && (start == text + 1)) { fold = g_utf8_casefold (start, -1); key = keygen (fold, -1); g_string_append (fixed, key); g_free (key); g_free (fold); result = g_string_free (fixed, FALSE); } else { if (start[0] != '\0' && start != end) { fold = g_utf8_casefold (start, end - start); key = keygen (fold, -1); g_string_append (fixed, key); g_free (key); g_free (fold); } result = g_string_free (fixed, FALSE); } } return result; }
gchar * gda_web_render_CREATE_TABLE (GdaServerProvider *provider, GdaConnection *cnc, GdaServerOperation *op, GError **error) { GString *string; const GValue *value; gboolean allok = TRUE; gboolean hasfields = FALSE; gint nrows; gint i; gboolean first; GSList *pkfields = NULL; /* list of GValue* composing the pkey */ gint nbpkfields = 0; gchar *tmp; /* CREATE TABLE */ string = g_string_new ("CREATE TABLE "); tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/TABLE_DEF_P/TABLE_NAME", error); if (!tmp) { g_string_free (string, TRUE); return NULL; } g_string_append (string, tmp); g_free (tmp); g_string_append (string, " ("); /* FIELDS */ if (allok) { GdaServerOperationNode *node; node = gda_server_operation_get_node_info (op, "/FIELDS_A"); g_assert (node); /* finding if there is a composed primary key */ nrows = gda_data_model_get_n_rows (node->model); for (i = 0; i < nrows; i++) { value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_PKEY/%d", i); if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) { tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/FIELDS_A/@COLUMN_NAME/%d", error, i); if (!tmp) { g_string_free (string, TRUE); return NULL; } pkfields = g_slist_append (pkfields, tmp); nbpkfields++; } } /* manually defined fields */ first = TRUE; for (i = 0; i < nrows; i++) { hasfields = TRUE; if (first) first = FALSE; else g_string_append (string, ", "); tmp = gda_server_operation_get_sql_identifier_at (op, cnc, provider, "/FIELDS_A/@COLUMN_NAME/%d", error, i); if (!tmp) { g_string_free (string, TRUE); return NULL; } g_string_append (string, tmp); g_free (tmp); g_string_append_c (string, ' '); value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_TYPE/%d", i); g_string_append (string, g_value_get_string (value)); value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_DEFAULT/%d", i); if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) { const gchar *str = g_value_get_string (value); if (str && *str) { g_string_append (string, " DEFAULT "); g_string_append (string, str); } } value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_NNUL/%d", i); if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) g_string_append (string, " NOT NULL"); value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_UNIQUE/%d", i); if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) g_string_append (string, " UNIQUE"); if (nbpkfields == 1) { value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_PKEY/%d", i); if (value && G_VALUE_HOLDS (value, G_TYPE_BOOLEAN) && g_value_get_boolean (value)) g_string_append (string, " PRIMARY KEY"); } value = gda_server_operation_get_value_at (op, "/FIELDS_A/@COLUMN_CHECK/%d", i); if (value && G_VALUE_HOLDS (value, G_TYPE_STRING)) { const gchar *str = g_value_get_string (value); if (str && *str) { g_string_append (string, " CHECK ("); g_string_append (string, str); g_string_append_c (string, ')'); } } } } /* composed primary key */ if (nbpkfields > 1) { GSList *list; g_string_append (string, ", PRIMARY KEY ("); for (list = pkfields; list; list = list->next) { if (list != pkfields) g_string_append (string, ", "); g_string_append (string, (gchar*) list->data); } g_string_append_c (string, ')'); } g_slist_foreach (pkfields, (GFunc) g_free, NULL); g_slist_free (pkfields); g_string_append (string, ")"); if (!hasfields) { allok = FALSE; g_set_error (error, GDA_SERVER_OPERATION_ERROR, GDA_SERVER_OPERATION_INCORRECT_VALUE_ERROR, "%s", _("Table to create must have at least one row")); } return g_string_free (string, FALSE); }
gboolean nm_supplicant_config_add_setting_8021x (NMSupplicantConfig *self, NMSetting8021x *setting, const char *con_uuid, guint32 mtu, gboolean wired) { NMSupplicantConfigPrivate *priv; char *tmp; const char *peapver, *value, *path; gboolean success, added; GString *phase1, *phase2; GBytes *bytes; gboolean fast = FALSE; guint32 i, num_eap; gboolean fast_provisoning_allowed = FALSE; const char *ca_path_override = NULL, *ca_cert_override = NULL; guint32 frag, hdrs; gs_free char *frag_str = NULL; g_return_val_if_fail (NM_IS_SUPPLICANT_CONFIG (self), FALSE); g_return_val_if_fail (setting != NULL, FALSE); g_return_val_if_fail (con_uuid != NULL, FALSE); priv = NM_SUPPLICANT_CONFIG_GET_PRIVATE (self); value = nm_setting_802_1x_get_password (setting); if (value) { if (!add_string_val (self, value, "password", FALSE, TRUE)) return FALSE; } else { bytes = nm_setting_802_1x_get_password_raw (setting); if (bytes) { success = nm_supplicant_config_add_option (self, "password", (const char *) g_bytes_get_data (bytes, NULL), g_bytes_get_size (bytes), TRUE); if (!success) { nm_log_warn (LOGD_SUPPLICANT, "Error adding password-raw to supplicant config."); return FALSE; } } } value = nm_setting_802_1x_get_pin (setting); if (!add_string_val (self, value, "pin", FALSE, TRUE)) return FALSE; if (wired) { if (!add_string_val (self, "IEEE8021X", "key_mgmt", FALSE, FALSE)) return FALSE; /* Wired 802.1x must always use eapol_flags=0 */ if (!add_string_val (self, "0", "eapol_flags", FALSE, FALSE)) return FALSE; nm_supplicant_config_set_ap_scan (self, 0); } ADD_STRING_LIST_VAL (setting, 802_1x, eap_method, eap_methods, "eap", ' ', TRUE, FALSE); /* Check EAP method for special handling: PEAP + GTC, FAST */ num_eap = nm_setting_802_1x_get_num_eap_methods (setting); for (i = 0; i < num_eap; i++) { const char *method = nm_setting_802_1x_get_eap_method (setting, i); if (method && (strcasecmp (method, "fast") == 0)) { fast = TRUE; priv->fast_required = TRUE; } } /* Adjust the fragment size according to MTU, but do not set it higher than 1280-14 * for better compatibility */ hdrs = 14; /* EAPOL + EAP-TLS */ frag = 1280 - hdrs; if (mtu > hdrs) frag = CLAMP (mtu - hdrs, 100, frag); frag_str = g_strdup_printf ("%u", frag); if (!nm_supplicant_config_add_option (self, "fragment_size", frag_str, -1, FALSE)) return FALSE; phase1 = g_string_new (NULL); peapver = nm_setting_802_1x_get_phase1_peapver (setting); if (peapver) { if (!strcmp (peapver, "0")) g_string_append (phase1, "peapver=0"); else if (!strcmp (peapver, "1")) g_string_append (phase1, "peapver=1"); } if (nm_setting_802_1x_get_phase1_peaplabel (setting)) { if (phase1->len) g_string_append_c (phase1, ' '); g_string_append_printf (phase1, "peaplabel=%s", nm_setting_802_1x_get_phase1_peaplabel (setting)); } value = nm_setting_802_1x_get_phase1_fast_provisioning (setting); if (value) { if (phase1->len) g_string_append_c (phase1, ' '); g_string_append_printf (phase1, "fast_provisioning=%s", value); if (strcmp (value, "0") != 0) fast_provisoning_allowed = TRUE; } if (phase1->len) { if (!add_string_val (self, phase1->str, "phase1", FALSE, FALSE)) { g_string_free (phase1, TRUE); return FALSE; } } g_string_free (phase1, TRUE); phase2 = g_string_new (NULL); if (nm_setting_802_1x_get_phase2_auth (setting) && !fast_provisoning_allowed) { tmp = g_ascii_strup (nm_setting_802_1x_get_phase2_auth (setting), -1); g_string_append_printf (phase2, "auth=%s", tmp); g_free (tmp); } if (nm_setting_802_1x_get_phase2_autheap (setting)) { if (phase2->len) g_string_append_c (phase2, ' '); tmp = g_ascii_strup (nm_setting_802_1x_get_phase2_autheap (setting), -1); g_string_append_printf (phase2, "autheap=%s", tmp); g_free (tmp); } if (phase2->len) { if (!add_string_val (self, phase2->str, "phase2", FALSE, FALSE)) { g_string_free (phase2, TRUE); return FALSE; } } g_string_free (phase2, TRUE); /* PAC file */ path = nm_setting_802_1x_get_pac_file (setting); if (path) { if (!add_string_val (self, path, "pac_file", FALSE, FALSE)) return FALSE; } else { /* PAC file is not specified. * If provisioning is allowed, use an blob format. */ if (fast_provisoning_allowed) { char *blob_name = g_strdup_printf ("blob://pac-blob-%s", con_uuid); if (!add_string_val (self, blob_name, "pac_file", FALSE, FALSE)) { g_free (blob_name); return FALSE; } g_free (blob_name); } else { /* This is only error for EAP-FAST; don't disturb other methods. */ if (fast) { nm_log_err (LOGD_SUPPLICANT, "EAP-FAST error: no PAC file provided and " "automatic PAC provisioning is disabled."); return FALSE; } } } /* If user wants to use system CA certs, either populate ca_path (if the path * is a directory) or ca_cert (the path is a file name) */ if (nm_setting_802_1x_get_system_ca_certs (setting)) { if (g_file_test (SYSTEM_CA_PATH, G_FILE_TEST_IS_DIR)) ca_path_override = SYSTEM_CA_PATH; else ca_cert_override = SYSTEM_CA_PATH; } /* CA path */ path = nm_setting_802_1x_get_ca_path (setting); path = ca_path_override ? ca_path_override : path; if (path) { if (!add_string_val (self, path, "ca_path", FALSE, FALSE)) return FALSE; } /* Phase2 CA path */ path = nm_setting_802_1x_get_phase2_ca_path (setting); path = ca_path_override ? ca_path_override : path; if (path) { if (!add_string_val (self, path, "ca_path2", FALSE, FALSE)) return FALSE; } /* CA certificate */ if (ca_cert_override) { if (!add_string_val (self, ca_cert_override, "ca_cert", FALSE, FALSE)) return FALSE; } else { switch (nm_setting_802_1x_get_ca_cert_scheme (setting)) { case NM_SETTING_802_1X_CK_SCHEME_BLOB: bytes = nm_setting_802_1x_get_ca_cert_blob (setting); ADD_BLOB_VAL (bytes, "ca_cert", con_uuid); break; case NM_SETTING_802_1X_CK_SCHEME_PATH: path = nm_setting_802_1x_get_ca_cert_path (setting); if (!add_string_val (self, path, "ca_cert", FALSE, FALSE)) return FALSE; break; default: break; } } /* Phase 2 CA certificate */ if (ca_cert_override) { if (!add_string_val (self, ca_cert_override, "ca_cert2", FALSE, FALSE)) return FALSE; } else { switch (nm_setting_802_1x_get_phase2_ca_cert_scheme (setting)) { case NM_SETTING_802_1X_CK_SCHEME_BLOB: bytes = nm_setting_802_1x_get_phase2_ca_cert_blob (setting); ADD_BLOB_VAL (bytes, "ca_cert2", con_uuid); break; case NM_SETTING_802_1X_CK_SCHEME_PATH: path = nm_setting_802_1x_get_phase2_ca_cert_path (setting); if (!add_string_val (self, path, "ca_cert2", FALSE, FALSE)) return FALSE; break; default: break; } } /* Subject match */ value = nm_setting_802_1x_get_subject_match (setting); if (!add_string_val (self, value, "subject_match", FALSE, FALSE)) return FALSE; value = nm_setting_802_1x_get_phase2_subject_match (setting); if (!add_string_val (self, value, "subject_match2", FALSE, FALSE)) return FALSE; /* altSubjectName match */ ADD_STRING_LIST_VAL (setting, 802_1x, altsubject_match, altsubject_matches, "altsubject_match", ';', FALSE, FALSE); ADD_STRING_LIST_VAL (setting, 802_1x, phase2_altsubject_match, phase2_altsubject_matches, "altsubject_match2", ';', FALSE, FALSE); /* Private key */ added = FALSE; switch (nm_setting_802_1x_get_private_key_scheme (setting)) { case NM_SETTING_802_1X_CK_SCHEME_BLOB: bytes = nm_setting_802_1x_get_private_key_blob (setting); ADD_BLOB_VAL (bytes, "private_key", con_uuid); added = TRUE; break; case NM_SETTING_802_1X_CK_SCHEME_PATH: path = nm_setting_802_1x_get_private_key_path (setting); if (!add_string_val (self, path, "private_key", FALSE, FALSE)) return FALSE; added = TRUE; break; default: break; } if (added) { NMSetting8021xCKFormat format; NMSetting8021xCKScheme scheme; format = nm_setting_802_1x_get_private_key_format (setting); scheme = nm_setting_802_1x_get_private_key_scheme (setting); if ( scheme == NM_SETTING_802_1X_CK_SCHEME_PATH || format == NM_SETTING_802_1X_CK_FORMAT_PKCS12) { /* Only add the private key password for PKCS#12 blobs and * all path schemes, since in both of these cases the private key * isn't decrypted at all. */ value = nm_setting_802_1x_get_private_key_password (setting); if (!add_string_val (self, value, "private_key_passwd", FALSE, TRUE)) return FALSE; } if (format != NM_SETTING_802_1X_CK_FORMAT_PKCS12) { /* Only add the client cert if the private key is not PKCS#12, as * wpa_supplicant configuration directs us to do. */ switch (nm_setting_802_1x_get_client_cert_scheme (setting)) { case NM_SETTING_802_1X_CK_SCHEME_BLOB: bytes = nm_setting_802_1x_get_client_cert_blob (setting); ADD_BLOB_VAL (bytes, "client_cert", con_uuid); break; case NM_SETTING_802_1X_CK_SCHEME_PATH: path = nm_setting_802_1x_get_client_cert_path (setting); if (!add_string_val (self, path, "client_cert", FALSE, FALSE)) return FALSE; break; default: break; } } } /* Phase 2 private key */ added = FALSE; switch (nm_setting_802_1x_get_phase2_private_key_scheme (setting)) { case NM_SETTING_802_1X_CK_SCHEME_BLOB: bytes = nm_setting_802_1x_get_phase2_private_key_blob (setting); ADD_BLOB_VAL (bytes, "private_key2", con_uuid); added = TRUE; break; case NM_SETTING_802_1X_CK_SCHEME_PATH: path = nm_setting_802_1x_get_phase2_private_key_path (setting); if (!add_string_val (self, path, "private_key2", FALSE, FALSE)) return FALSE; added = TRUE; break; default: break; } if (added) { NMSetting8021xCKFormat format; NMSetting8021xCKScheme scheme; format = nm_setting_802_1x_get_phase2_private_key_format (setting); scheme = nm_setting_802_1x_get_phase2_private_key_scheme (setting); if ( scheme == NM_SETTING_802_1X_CK_SCHEME_PATH || format == NM_SETTING_802_1X_CK_FORMAT_PKCS12) { /* Only add the private key password for PKCS#12 blobs and * all path schemes, since in both of these cases the private key * isn't decrypted at all. */ value = nm_setting_802_1x_get_phase2_private_key_password (setting); if (!add_string_val (self, value, "private_key2_passwd", FALSE, TRUE)) return FALSE; } if (format != NM_SETTING_802_1X_CK_FORMAT_PKCS12) { /* Only add the client cert if the private key is not PKCS#12, as * wpa_supplicant configuration directs us to do. */ switch (nm_setting_802_1x_get_phase2_client_cert_scheme (setting)) { case NM_SETTING_802_1X_CK_SCHEME_BLOB: bytes = nm_setting_802_1x_get_phase2_client_cert_blob (setting); ADD_BLOB_VAL (bytes, "client_cert2", con_uuid); break; case NM_SETTING_802_1X_CK_SCHEME_PATH: path = nm_setting_802_1x_get_phase2_client_cert_path (setting); if (!add_string_val (self, path, "client_cert2", FALSE, FALSE)) return FALSE; break; default: break; } } } value = nm_setting_802_1x_get_identity (setting); if (!add_string_val (self, value, "identity", FALSE, FALSE)) return FALSE; value = nm_setting_802_1x_get_anonymous_identity (setting); if (!add_string_val (self, value, "anonymous_identity", FALSE, FALSE)) return FALSE; return TRUE; }
/* print_rtf_localized_typography -- convert to "smart" typography */ void print_rtf_localized_typography(GString *out, int character, scratch_pad *scratch) { if (!extension(EXT_SMART, scratch->extensions)) { g_string_append_c(out, character); return; } switch (character) { case LSQUOTE: switch (scratch->language) { case SWEDISH: g_string_append_printf(out, "’"); break; case FRENCH: g_string_append_printf(out,"'"); break; case GERMAN: g_string_append_printf(out,"‚"); break; case GERMANGUILL: g_string_append_printf(out,"›"); break; default: g_string_append_printf(out,"\\'91"); } break; case RSQUOTE: switch (scratch->language) { case GERMAN: g_string_append_printf(out,"‘"); break; case GERMANGUILL: g_string_append_printf(out,"‹"); break; default: g_string_append_printf(out,"\\'92"); } break; case APOS: g_string_append_printf(out,"\\'27"); break; case LDQUOTE: switch (scratch->language) { case DUTCH: case GERMAN: g_string_append_printf(out,"„"); break; case GERMANGUILL: g_string_append_printf(out,"»"); break; case FRENCH: g_string_append_printf(out,"«"); break; case SWEDISH: g_string_append_printf(out, "”"); break; default: g_string_append_printf(out,"\\'93"); } break; case RDQUOTE: switch (scratch->language) { case SWEDISH: case DUTCH: g_string_append_printf(out,"”"); break; case GERMAN: g_string_append_printf(out,"“"); break; case GERMANGUILL: g_string_append_printf(out,"«"); break; case FRENCH: g_string_append_printf(out,"»"); break; default: g_string_append_printf(out,"\\'94"); } break; case NDASH: g_string_append_printf(out,"\\'96"); break; case MDASH: g_string_append_printf(out,"\\'97"); break; case ELLIP: g_string_append_printf(out,"\\'85"); break; default:; } }
static gchar * gda_sql_statement_update_serialize (gpointer stmt) { GString *string; gchar *str; GSList *list; GdaSqlStatementUpdate *update = (GdaSqlStatementUpdate *) stmt; g_return_val_if_fail (stmt, NULL); string = g_string_new ("\"contents\":{"); /* table name */ g_string_append (string, "\"table\":"); str = gda_sql_table_serialize (update->table); g_string_append (string, str); g_free (str); /* fields */ g_string_append (string, ",\"fields\":"); if (update->fields_list) { g_string_append_c (string, '['); for (list = update->fields_list; list; list = list->next) { if (list != update->fields_list) g_string_append_c (string, ','); str = gda_sql_field_serialize ((GdaSqlField *) list->data); g_string_append (string, str); g_free (str); } g_string_append_c (string, ']'); } else g_string_append (string, "null"); /* expressions */ g_string_append (string, ",\"expressions\":"); if (update->expr_list) { g_string_append_c (string, '['); for (list = update->expr_list; list; list = list->next) { if (list != update->expr_list) g_string_append_c (string, ','); str = gda_sql_expr_serialize ((GdaSqlExpr *) list->data); g_string_append (string, str); g_free (str); } g_string_append_c (string, ']'); } else g_string_append (string, "null"); /* condition */ if (update->cond) { g_string_append (string, ",\"condition\":"); str = gda_sql_expr_serialize (update->cond); g_string_append (string, str); g_free (str); } /* conflict clause */ if (update->on_conflict) { g_string_append (string, ",\"on_conflict\":"); str = _json_quote_string (update->on_conflict); g_string_append (string, str); g_free (str); } g_string_append_c (string, '}'); str = string->str; g_string_free (string, FALSE); return str; }
static gboolean convert_var_to_tmpfiles_d (GOutputStream *tmpfiles_out, GFile *yumroot, GFile *dir, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gs_unref_object GFileEnumerator *direnum = NULL; gsize bytes_written; direnum = g_file_enumerate_children (dir, "standard::name,standard::type,unix::mode,standard::symlink-target,unix::uid,unix::gid", G_FILE_QUERY_INFO_NOFOLLOW_SYMLINKS, cancellable, error); if (!direnum) { g_prefix_error (error, "Enumerating /var in '%s'", gs_file_get_path_cached (dir)); goto out; } while (TRUE) { GFileInfo *file_info; GFile *child; GString *tmpfiles_d_buf; gs_free char *tmpfiles_d_line = NULL; char filetype_c; gs_free char *relpath = NULL; if (!gs_file_enumerator_iterate (direnum, &file_info, &child, cancellable, error)) goto out; if (!file_info) break; switch (g_file_info_get_file_type (file_info)) { case G_FILE_TYPE_DIRECTORY: filetype_c = 'd'; break; case G_FILE_TYPE_SYMBOLIC_LINK: filetype_c = 'L'; break; default: g_print ("Ignoring non-directory/non-symlink '%s'\n", gs_file_get_path_cached (child)); continue; } tmpfiles_d_buf = g_string_new (""); g_string_append_c (tmpfiles_d_buf, filetype_c); g_string_append_c (tmpfiles_d_buf, ' '); relpath = g_file_get_relative_path (yumroot, child); g_assert (relpath); g_string_append_c (tmpfiles_d_buf, '/'); g_string_append (tmpfiles_d_buf, relpath); if (filetype_c == 'd') { guint mode = g_file_info_get_attribute_uint32 (file_info, "unix::mode"); mode &= ~S_IFMT; g_string_append_printf (tmpfiles_d_buf, " 0%02o", mode); g_string_append_printf (tmpfiles_d_buf, " %d %d - -", g_file_info_get_attribute_uint32 (file_info, "unix::uid"), g_file_info_get_attribute_uint32 (file_info, "unix::gid")); if (!convert_var_to_tmpfiles_d (tmpfiles_out, yumroot, child, cancellable, error)) goto out; } else { g_string_append (tmpfiles_d_buf, " - - - - "); g_string_append (tmpfiles_d_buf, g_file_info_get_symlink_target (file_info)); } g_string_append_c (tmpfiles_d_buf, '\n'); tmpfiles_d_line = g_string_free (tmpfiles_d_buf, FALSE); if (!g_output_stream_write_all (tmpfiles_out, tmpfiles_d_line, strlen (tmpfiles_d_line), &bytes_written, cancellable, error)) goto out; } ret = TRUE; out: return ret; }
// concatenate folder and file to new path and try create folder and empty file. // If folder create failed, post UG_MESSAGE_ERROR_FOLDER_CREATE_FAILED. // If file exist, it will change filename and post UG_MESSAGE_DATA_FILE_CHANGED. // if function succeeded, return new path and it's folder length. gchar* ug_plugin_create_file (UgPlugin* plugin, const gchar* folder, const gchar* file, guint* folder_len) { GString* gstr; const gchar* tail_str; guint head_len; guint location_len; guint count; int fd; if (folder == NULL && file == NULL) { ug_plugin_post (plugin, ug_message_new_error (UG_MESSAGE_ERROR_FILE_CREATE_FAILED, NULL)); return NULL; } // concatenate full path gstr = g_string_sized_new (80); if (folder) { g_string_append (gstr, folder); if (gstr->len && gstr->str [gstr->len -1] != G_DIR_SEPARATOR) g_string_append_c (gstr, G_DIR_SEPARATOR); } if (file) g_string_append (gstr, file); // get location_len (length of path exclude filename). tail_str = strrchr (gstr->str, G_DIR_SEPARATOR); if (tail_str == NULL) location_len = 0; else location_len = tail_str - gstr->str + 1; // + G_DIR_SEPARATOR // create folder if (location_len && ug_create_dir_all (gstr->str, location_len) == -1) { ug_plugin_post (plugin, ug_message_new_error (UG_MESSAGE_ERROR_FOLDER_CREATE_FAILED, NULL)); return g_string_free (gstr, TRUE); } // get head_len (length of folder + primary filename) // and tail_str ('.' + filename extension) tail_str = strrchr (gstr->str + location_len, '.'); if (tail_str == NULL) tail_str = gstr->str + gstr->len; head_len = tail_str - gstr->str; tail_str = g_strdup (tail_str); // create file for (count=0; count < 10000; count++) { // fd = open (gstr->str, O_CREAT | O_EXCL | O_RDWR, // S_IREAD | S_IWRITE | S_IRGRP | S_IROTH); fd = ug_fd_open (gstr->str, UG_FD_O_CREATE | UG_FD_O_EXCL | UG_FD_O_RDWR, UG_FD_S_IREAD | UG_FD_S_IWRITE | UG_FD_S_IRGRP | UG_FD_S_IROTH); if (fd != -1) { // close (fd); ug_fd_close (fd); break; } g_string_truncate (gstr, head_len); g_string_append_printf (gstr, "(%d)", count); g_string_append (gstr, tail_str); } // free tail_str g_free ((gpointer) tail_str); // result if (count == 10000) { ug_plugin_post (plugin, ug_message_new_error (UG_MESSAGE_ERROR_FILE_CREATE_FAILED, NULL)); return g_string_free (gstr, TRUE); } if (count > 0) { ug_plugin_post (plugin, ug_message_new_data (UG_MESSAGE_DATA_FILE_CHANGED, gstr->str + location_len)); } if (folder_len) *folder_len = location_len; return g_string_free (gstr, FALSE); }
static estr_t _str_convert (GIConv coder, const char *string, int size, GString * buffer) { estr_t state = ESTR_SUCCESS; gssize left; gsize bytes_read = 0; gsize bytes_written = 0; errno = 0; /* FIXME: is it really needed? */ if (coder == INVALID_CONV) return ESTR_FAILURE; if (string == NULL || buffer == NULL) return ESTR_FAILURE; /* if (! used_class.is_valid_string (string)) { return ESTR_FAILURE; } */ if (size < 0) size = strlen (string); else { left = strlen (string); if (left < size) size = left; } left = size; g_iconv (coder, NULL, NULL, NULL, NULL); while (left != 0) { gchar *tmp_buff; GError *error = NULL; tmp_buff = g_convert_with_iconv ((const gchar *) string, left, coder, &bytes_read, &bytes_written, &error); if (error != NULL) { int code = error->code; g_error_free (error); error = NULL; switch (code) { case G_CONVERT_ERROR_NO_CONVERSION: /* Conversion between the requested character sets is not supported. */ tmp_buff = g_strnfill (strlen (string), '?'); g_string_append (buffer, tmp_buff); g_free (tmp_buff); return ESTR_FAILURE; case G_CONVERT_ERROR_ILLEGAL_SEQUENCE: /* Invalid byte sequence in conversion input. */ if ((tmp_buff == NULL) && (bytes_read != 0)) /* recode valid byte sequence */ tmp_buff = g_convert_with_iconv ((const gchar *) string, bytes_read, coder, NULL, NULL, NULL); if (tmp_buff != NULL) { g_string_append (buffer, tmp_buff); g_free (tmp_buff); } if ((int) bytes_read >= left) return ESTR_PROBLEM; string += bytes_read + 1; size -= (bytes_read + 1); left -= (bytes_read + 1); g_string_append_c (buffer, *(string - 1)); state = ESTR_PROBLEM; break; case G_CONVERT_ERROR_PARTIAL_INPUT: /* Partial character sequence at end of input. */ g_string_append (buffer, tmp_buff); g_free (tmp_buff); if ((int) bytes_read < left) { left = left - bytes_read; tmp_buff = g_strnfill (left, '?'); g_string_append (buffer, tmp_buff); g_free (tmp_buff); } return ESTR_PROBLEM; case G_CONVERT_ERROR_BAD_URI: /* Don't know how handle this error :( */ case G_CONVERT_ERROR_NOT_ABSOLUTE_PATH: /* Don't know how handle this error :( */ case G_CONVERT_ERROR_FAILED: /* Conversion failed for some reason. */ default: g_free (tmp_buff); return ESTR_FAILURE; } } else if (tmp_buff == NULL) { g_string_append (buffer, string); return ESTR_PROBLEM; } else if (*tmp_buff == '\0') { g_free (tmp_buff); g_string_append (buffer, string); return state; } else { g_string_append (buffer, tmp_buff); g_free (tmp_buff); string += bytes_read; left -= bytes_read; } } return state; }
static void query (void) { static GimpParamDef args[] = { { GIMP_PDB_INT32, "run-mode", "The run mode { RUN-INTERACTIVE (0), RUN-NONINTERACTIVE (1) }" }, { GIMP_PDB_IMAGE, "image", "Input image (unused)" }, { GIMP_PDB_DRAWABLE, "drawable", "Input drawable" }, { GIMP_PDB_STRING, "decompose-type", NULL }, { GIMP_PDB_INT32, "layers-mode", "Create channels as layers in a single image" } }; static const GimpParamDef return_vals[] = { { GIMP_PDB_IMAGE, "new-image", "Output gray image" }, { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" }, { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" }, { GIMP_PDB_IMAGE, "new-image", "Output gray image (N/A for single channel extract)" } }; GString *type_desc; int i; type_desc = g_string_new ("What to decompose: "); g_string_append_c (type_desc, '"'); g_string_append (type_desc, extract[0].type); g_string_append_c (type_desc, '"'); for (i = 1; i < G_N_ELEMENTS (extract); i++) { g_string_append (type_desc, ", "); g_string_append_c (type_desc, '"'); g_string_append (type_desc, extract[i].type); g_string_append_c (type_desc, '"'); } args[3].description = type_desc->str; gimp_install_procedure (PLUG_IN_PROC, N_("Decompose an image into separate colorspace components"), "This function creates new gray images with " "different channel information in each of them", "Peter Kirchgessner", "Peter Kirchgessner", "1997", N_("_Decompose..."), "RGB*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_vals), args, return_vals); gimp_install_procedure (PLUG_IN_PROC_REG, N_("Decompose an image into separate colorspace components"), "This function creates new gray images with " "different channel information in each of them. " "Pixels in the foreground color will appear black " "in all output images. This can be used for " "things like crop marks that have to show up on " "all channels.", "Peter Kirchgessner", "Peter Kirchgessner, Clarence Risher", "1997", N_("_Decompose..."), "RGB*", GIMP_PLUGIN, G_N_ELEMENTS (args), G_N_ELEMENTS (return_vals), args, return_vals); gimp_plugin_menu_register (PLUG_IN_PROC_REG, "<Image>/Colors/Components"); g_string_free (type_desc, TRUE); }
static void jabber_bosh_connection_send(PurpleBOSHConnection *conn, const PurpleBOSHPacketType type, const char *data) { PurpleHTTPConnection *chosen; GString *packet = NULL; if (type != PACKET_FLUSH && type != PACKET_TERMINATE) { /* * Unless this is a flush (or session terminate, which needs to be * sent immediately), queue up the data and start a timer to flush * the buffer. */ if (data) { int len = data ? strlen(data) : 0; purple_circ_buffer_append(conn->pending, data, len); } if (purple_debug_is_verbose()) purple_debug_misc("jabber", "bosh: %p has %" G_GSIZE_FORMAT " bytes in " "the buffer.\n", conn, conn->pending->bufused); if (conn->send_timer == 0) conn->send_timer = purple_timeout_add_seconds(BUFFER_SEND_IN_SECS, send_timer_cb, conn); return; } chosen = find_available_http_connection(conn); if (!chosen) { /* * For non-ordinary traffic, we can't 'buffer' it, so use the * first connection. */ chosen = conn->connections[0]; if (chosen->state != HTTP_CONN_CONNECTED) { purple_debug_warning("jabber", "Unable to find a ready BOSH " "connection. Ignoring send of type 0x%02x.\n", type); return; } } /* We're flushing the send buffer, so remove the send timer */ if (conn->send_timer != 0) { purple_timeout_remove(conn->send_timer); conn->send_timer = 0; } packet = g_string_new(NULL); g_string_printf(packet, "<body " "rid='%" G_GUINT64_FORMAT "' " "sid='%s' " "to='%s' " "xml:lang='en' " "xmlns='http://jabber.org/protocol/httpbind' " "xmlns:xmpp='urn:xmpp:xbosh'", ++conn->rid, conn->sid, conn->js->user->domain); if (conn->js->reinit) { packet = g_string_append(packet, " xmpp:restart='true'/>"); /* TODO: Do we need to wait for a response? */ conn->js->reinit = FALSE; } else { gsize read_amt; if (type == PACKET_TERMINATE) packet = g_string_append(packet, " type='terminate'"); packet = g_string_append_c(packet, '>'); while ((read_amt = purple_circ_buffer_get_max_read(conn->pending)) > 0) { packet = g_string_append_len(packet, conn->pending->outptr, read_amt); purple_circ_buffer_mark_read(conn->pending, read_amt); } if (data) packet = g_string_append(packet, data); packet = g_string_append(packet, "</body>"); } http_connection_send_request(chosen, packet); }
static GError * _client_manage_reply(struct gridd_client_s *client, MESSAGE reply) { GError *err; gint status = 0; gchar *message = NULL; if (!metaXClient_reply_simple(reply, &status, &message, NULL)) return NEWERROR(500, "Invalid reply"); switch (status / 100) { case 0: err = NEWERROR(status, "net error: %s", message); g_free(message); metautils_pclose(&(client->fd)); client->step = STATUS_FAILED; return err; case 1: /* Informational reply : */ g_get_current_time(&(client->tv_step)); client->step = REP_READING_SIZE; g_free(message); return NULL; case 2: g_get_current_time(&(client->tv_step)); client->step = (status==200) ? STATUS_OK : REP_READING_SIZE; if (client->step == STATUS_OK) { if (!client->keepalive) metautils_pclose(&(client->fd)); } g_free(message); if (client->on_reply) { if (!client->on_reply(client->ctx, reply)) return NEWERROR(500, "Handler error"); } return NULL; case 3: /* redirection */ if (status == CODE_REDIRECT) { /* Reset the context */ _client_reset_reply(client); _client_reset_cnx(client); client->sent_bytes = 0; if ((++ client->nb_redirects) > 7) { g_free(message); return NEWERROR(CODE_TOOMANY_REDIRECT, "Too many redirections"); } /* Save the current URL to avoid looping, and check * for a potential loop */ g_string_append_c(client->past_url, '|'); g_string_append(client->past_url, client->url); if (_client_looped(client, message)) { g_free(message); return NEWERROR(CODE_LOOP_REDIRECT, "Looping on redirections"); } /* Replace the URL */ memset(client->url, 0, sizeof(client->url)); g_strlcpy(client->url, message, sizeof(client->url)-1); if (NULL != (err = _client_connect(client))) { g_free(message); g_prefix_error(&err, "Redirection error: Connect error: "); return err; } g_free(message); return NULL; } /* FALLTHROUGH */ default: /* all other are considered errors */ err = NEWERROR(status, "Request error: %s", message); g_free(message); if (!client->keepalive) _client_reset_cnx(client); _client_reset_reply(client); return err; } }
gchar * util_create_json(int n, ...) { va_list args; va_start(args, n); const gchar *key, *cval; gdouble dval; gint ival; guint uival; gulong ulval; glong lval; gboolean bval; gchar *ret; gint type; setlocale(LC_NUMERIC, "C"); GString *string = g_string_new("{"); for (int i=0; i<n; i++) { type = va_arg(args, gint); key = va_arg(args, gchar*); g_string_append_printf(string, "\"%s\":", key); switch (type) { case CHAR : cval = va_arg(args, gchar*); if (cval == NULL) g_string_append(string, "null"); else { g_string_append_c(string, '"'); while (*cval) { if ( *cval == '"' || *cval == '/' || *cval == '\\' || *cval == '\b' || *cval == '\f' || *cval == '\n' || *cval == '\r' || *cval == '\t') g_string_append_c(string, '\\'); g_string_append_c(string, *cval); cval++; } g_string_append_c(string, '"'); } break; case INTEGER : ival = va_arg(args, gint); g_string_append_printf(string, "%d", ival); break; case UINTEGER : uival = va_arg(args, guint); g_string_append_printf(string, "%u", uival); break; case LONG : lval = va_arg(args, glong); g_string_append_printf(string, "%ld", lval); break; case ULONG : ulval = va_arg(args, gulong); g_string_append_printf(string, "%lu", ulval); break; case DOUBLE : dval = va_arg(args, double); g_string_append_printf(string, "%f", dval); break; case BOOLEAN: bval = va_arg(args, gboolean); g_string_append_printf(string, "%s", bval ? "true" : "false"); break; default : g_string_append(string, "null"); break; } if (i<n-1) g_string_append_c(string, ','); } va_end(args); g_string_append_c(string, '}'); ret = string->str; g_string_free(string, false); return ret; }
void feed_parser_atom10_start(void *data, const gchar *el, const gchar **attr) { FeedParserCtx *ctx = (FeedParserCtx *)data; gchar *a = NULL; if( ctx->depth == 1 ) { if( !strcmp(el, "entry") ) { /* Start of new feed item found. * Create a new FeedItem, freeing the one we already have, if any. */ if( ctx->curitem != NULL ) feed_item_free(ctx->curitem); ctx->curitem = feed_item_new(ctx->feed); ctx->location = FEED_LOC_ATOM10_ENTRY; } else if( !strcmp(el, "author") ) { /* Start of author info for the feed found. * Set correct location. */ ctx->location = FEED_LOC_ATOM10_AUTHOR; } else if( !strcmp(el, "link") ) { if (!feed_parser_get_attribute_value(attr, "rel")) { /* Link tag for the feed */ g_free(ctx->feed->link); ctx->feed->link = g_strdup(feed_parser_get_attribute_value(attr, "href")); } } else ctx->location = FEED_LOC_ATOM10_NONE; } else if( ctx->depth == 2 ) { /* Make sure we are in one of known locations within the XML structure. * This condition should never be true on a valid Atom feed. */ if (ctx->location != FEED_LOC_ATOM10_AUTHOR && ctx->location != FEED_LOC_ATOM10_ENTRY) { ctx->depth++; return; } if( !strcmp(el, "author") ) { /* Start of author info for current feed item. * Set correct location. */ ctx->location = FEED_LOC_ATOM10_AUTHOR; } else if( !strcmp(el, "link") ) { /* Capture item URL, from the "url" XML attribute. */ if (ctx->curitem && ctx->location == FEED_LOC_ATOM10_ENTRY) ctx->curitem->url = g_strdup(feed_parser_get_attribute_value(attr, "href")); } else if( !strcmp(el, "source") ) { ctx->location = FEED_LOC_ATOM10_SOURCE; } else ctx->location = FEED_LOC_ATOM10_ENTRY; if( !strcmp(el, "title") && ctx->curitem != NULL) { a = feed_parser_get_attribute_value(attr, "type"); if( !a || !strcmp(a, "text") ) ctx->curitem->title_format = FEED_ITEM_TITLE_TEXT; else if( !strcmp(a, "html") ) ctx->curitem->title_format = FEED_ITEM_TITLE_HTML; else if( !strcmp(a, "xhtml") ) ctx->curitem->title_format = FEED_ITEM_TITLE_XHTML; else ctx->curitem->title_format = FEED_ITEM_TITLE_UNKNOWN; } else if (!strcmp(el, "content") && ctx->curitem != NULL) { ctx->location = FEED_LOC_ATOM10_CONTENT; a = feed_parser_get_attribute_value(attr, "type"); if (a && !strcmp(a, "xhtml")) { ctx->curitem->xhtml_content = TRUE; ctx->xhtml_str = g_string_new(NULL); } } } else if (ctx->depth >= 3) { if (ctx->location == FEED_LOC_ATOM10_CONTENT && ctx->curitem != NULL && ctx->curitem->xhtml_content) { guint i; GString *txt = ctx->xhtml_str; g_string_append_c(txt, '<'); g_string_append(txt, el); for (i = 0; attr[i] != NULL && attr[i+1] != NULL; i += 2) { g_string_append_printf(txt, " %s='%s'", attr[i], attr[i+1]); } g_string_append_c(txt, '>'); } } ctx->depth++; }
static void do_percent_subst (EggDesktopFile *desktop_file, char code, GString *str, GSList **documents, gboolean in_single_quotes, gboolean in_double_quotes) { GSList *d; char *doc; switch (code) { case '%': g_string_append_c (str, '%'); break; case 'F': case 'U': for (d = *documents; d; d = d->next) { doc = d->data; g_string_append (str, " "); append_quoted_word (str, doc, in_single_quotes, in_double_quotes); } *documents = NULL; break; case 'f': case 'u': if (*documents) { doc = (*documents)->data; g_string_append (str, " "); append_quoted_word (str, doc, in_single_quotes, in_double_quotes); *documents = (*documents)->next; } break; case 'i': if (desktop_file->icon) { g_string_append (str, "--icon "); append_quoted_word (str, desktop_file->icon, in_single_quotes, in_double_quotes); } break; case 'c': if (desktop_file->name) { append_quoted_word (str, desktop_file->name, in_single_quotes, in_double_quotes); } break; case 'k': if (desktop_file->source) { append_quoted_word (str, desktop_file->source, in_single_quotes, in_double_quotes); } break; case 'D': case 'N': case 'd': case 'n': case 'v': case 'm': /* Deprecated; skip */ break; default: g_warning ("Unrecognized %%-code '%%%c' in Exec", code); break; } }
static void gimp_tag_popup_toggle_tag (GimpTagPopup *popup, PopupTagData *tag_data) { gchar **current_tags; GString *tag_str; gint length; gint i; gboolean tag_toggled_off = FALSE; if (tag_data->state == GTK_STATE_NORMAL) { tag_data->state = GTK_STATE_SELECTED; } else if (tag_data->state == GTK_STATE_SELECTED) { tag_data->state = GTK_STATE_NORMAL; } else { return; } current_tags = gimp_tag_entry_parse_tags (GIMP_TAG_ENTRY (popup->combo_entry)); tag_str = g_string_new (""); length = g_strv_length (current_tags); for (i = 0; i < length; i++) { if (! gimp_tag_compare_with_string (tag_data->tag, current_tags[i])) { tag_toggled_off = TRUE; } else { if (tag_str->len) { g_string_append (tag_str, gimp_tag_entry_get_separator ()); g_string_append_c (tag_str, ' '); } g_string_append (tag_str, current_tags[i]); } } if (! tag_toggled_off) { /* this tag was not selected yet, so it needs to be toggled on */ if (tag_str->len) { g_string_append (tag_str, gimp_tag_entry_get_separator ()); g_string_append_c (tag_str, ' '); } g_string_append (tag_str, gimp_tag_get_name (tag_data->tag)); } gimp_tag_entry_set_tag_string (GIMP_TAG_ENTRY (popup->combo_entry), tag_str->str); g_string_free (tag_str, TRUE); g_strfreev (current_tags); if (GIMP_TAG_ENTRY (popup->combo_entry)->mode == GIMP_TAG_ENTRY_MODE_QUERY) { GimpTaggedContainer *container; container = GIMP_TAG_ENTRY (popup->combo_entry)->container; for (i = 0; i < popup->tag_count; i++) { if (popup->tag_data[i].state != GTK_STATE_SELECTED) { popup->tag_data[i].state = GTK_STATE_INSENSITIVE; } } gimp_container_foreach (GIMP_CONTAINER (container), (GFunc) gimp_tag_popup_check_can_toggle, popup); } }
static char * parse_exec (EggDesktopFile *desktop_file, GSList **documents, GError **error) { char *exec, *p, *command; gboolean escape, single_quot, double_quot; GString *gs; exec = g_key_file_get_string (desktop_file->key_file, EGG_DESKTOP_FILE_GROUP, EGG_DESKTOP_FILE_KEY_EXEC, error); if (!exec) return NULL; /* Build the command */ gs = g_string_new (NULL); escape = single_quot = double_quot = FALSE; for (p = exec; *p != '\0'; p++) { if (escape) { escape = FALSE; g_string_append_c (gs, *p); } else if (*p == '\\') { if (!single_quot) escape = TRUE; g_string_append_c (gs, *p); } else if (*p == '\'') { g_string_append_c (gs, *p); if (!single_quot && !double_quot) single_quot = TRUE; else if (single_quot) single_quot = FALSE; } else if (*p == '"') { g_string_append_c (gs, *p); if (!single_quot && !double_quot) double_quot = TRUE; else if (double_quot) double_quot = FALSE; } else if (*p == '%' && p[1]) { do_percent_subst (desktop_file, p[1], gs, documents, single_quot, double_quot); p++; } else g_string_append_c (gs, *p); } g_free (exec); command = g_string_free (gs, FALSE); /* Prepend "xdg-terminal " if needed (FIXME: use gvfs) */ if (g_key_file_has_key (desktop_file->key_file, EGG_DESKTOP_FILE_GROUP, EGG_DESKTOP_FILE_KEY_TERMINAL, NULL)) { GError *terminal_error = NULL; gboolean use_terminal = g_key_file_get_boolean (desktop_file->key_file, EGG_DESKTOP_FILE_GROUP, EGG_DESKTOP_FILE_KEY_TERMINAL, &terminal_error); if (terminal_error) { g_free (command); g_propagate_error (error, terminal_error); return NULL; } if (use_terminal) { gs = g_string_new ("xdg-terminal "); append_quoted_word (gs, command, FALSE, FALSE); g_free (command); command = g_string_free (gs, FALSE); } } return command; }
static void g_scanner_get_token_ll (GScanner *scanner, GTokenType *token_p, GTokenValue *value_p, guint *line_p, guint *position_p) { GScannerConfig *config; GTokenType token; gboolean in_comment_multi; gboolean in_comment_single; gboolean in_string_sq; gboolean in_string_dq; GString *gstring; GTokenValue value; guchar ch; config = scanner->config; (*value_p).v_int64 = 0; if ((scanner->text >= scanner->text_end && scanner->input_fd < 0) || scanner->token == G_TOKEN_EOF) { *token_p = G_TOKEN_EOF; return; } in_comment_multi = FALSE; in_comment_single = FALSE; in_string_sq = FALSE; in_string_dq = FALSE; gstring = NULL; do /* while (ch != 0) */ { gboolean dotted_float = FALSE; ch = g_scanner_get_char (scanner, line_p, position_p); value.v_int64 = 0; token = G_TOKEN_NONE; /* this is *evil*, but needed ;( * we first check for identifier first character, because it * might interfere with other key chars like slashes or numbers */ if (config->scan_identifier && ch && strchr (config->cset_identifier_first, ch)) goto identifier_precedence; switch (ch) { case 0: token = G_TOKEN_EOF; (*position_p)++; /* ch = 0; */ break; case '/': if (!config->scan_comment_multi || g_scanner_peek_next_char (scanner) != '*') goto default_case; g_scanner_get_char (scanner, line_p, position_p); token = G_TOKEN_COMMENT_MULTI; in_comment_multi = TRUE; gstring = g_string_new (NULL); while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0) { if (ch == '*' && g_scanner_peek_next_char (scanner) == '/') { g_scanner_get_char (scanner, line_p, position_p); in_comment_multi = FALSE; break; } else gstring = g_string_append_c (gstring, ch); } ch = 0; break; case '\'': if (!config->scan_string_sq) goto default_case; token = G_TOKEN_STRING; in_string_sq = TRUE; gstring = g_string_new (NULL); while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0) { if (ch == '\'') { in_string_sq = FALSE; break; } else gstring = g_string_append_c (gstring, ch); } ch = 0; break; case '"': if (!config->scan_string_dq) goto default_case; token = G_TOKEN_STRING; in_string_dq = TRUE; gstring = g_string_new (NULL); while ((ch = g_scanner_get_char (scanner, line_p, position_p)) != 0) { if (ch == '"') { in_string_dq = FALSE; break; } else { if (ch == '\\') { ch = g_scanner_get_char (scanner, line_p, position_p); switch (ch) { guint i; guint fchar; case 0: break; case '\\': gstring = g_string_append_c (gstring, '\\'); break; case 'n': gstring = g_string_append_c (gstring, '\n'); break; case 't': gstring = g_string_append_c (gstring, '\t'); break; case 'r': gstring = g_string_append_c (gstring, '\r'); break; case 'b': gstring = g_string_append_c (gstring, '\b'); break; case 'f': gstring = g_string_append_c (gstring, '\f'); break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': i = ch - '0'; fchar = g_scanner_peek_next_char (scanner); if (fchar >= '0' && fchar <= '7') { ch = g_scanner_get_char (scanner, line_p, position_p); i = i * 8 + ch - '0'; fchar = g_scanner_peek_next_char (scanner); if (fchar >= '0' && fchar <= '7') { ch = g_scanner_get_char (scanner, line_p, position_p); i = i * 8 + ch - '0'; } } gstring = g_string_append_c (gstring, i); break; default: gstring = g_string_append_c (gstring, ch); break; } } else gstring = g_string_append_c (gstring, ch); } } ch = 0; break; case '.': if (!config->scan_float) goto default_case; token = G_TOKEN_FLOAT; dotted_float = TRUE; ch = g_scanner_get_char (scanner, line_p, position_p); goto number_parsing; case '$': if (!config->scan_hex_dollar) goto default_case; token = G_TOKEN_HEX; ch = g_scanner_get_char (scanner, line_p, position_p); goto number_parsing; case '0': if (config->scan_octal) token = G_TOKEN_OCTAL; else token = G_TOKEN_INT; ch = g_scanner_peek_next_char (scanner); if (config->scan_hex && (ch == 'x' || ch == 'X')) { token = G_TOKEN_HEX; g_scanner_get_char (scanner, line_p, position_p); ch = g_scanner_get_char (scanner, line_p, position_p); if (ch == 0) { token = G_TOKEN_ERROR; value.v_error = G_ERR_UNEXP_EOF; (*position_p)++; break; } if (g_scanner_char_2_num (ch, 16) < 0) { token = G_TOKEN_ERROR; value.v_error = G_ERR_DIGIT_RADIX; ch = 0; break; } } else if (config->scan_binary && (ch == 'b' || ch == 'B')) { token = G_TOKEN_BINARY; g_scanner_get_char (scanner, line_p, position_p); ch = g_scanner_get_char (scanner, line_p, position_p); if (ch == 0) { token = G_TOKEN_ERROR; value.v_error = G_ERR_UNEXP_EOF; (*position_p)++; break; } if (g_scanner_char_2_num (ch, 10) < 0) { token = G_TOKEN_ERROR; value.v_error = G_ERR_NON_DIGIT_IN_CONST; ch = 0; break; } } else ch = '0'; /* fall through */ case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': number_parsing: { gboolean in_number = TRUE; gchar *endptr; if (token == G_TOKEN_NONE) token = G_TOKEN_INT; gstring = g_string_new (dotted_float ? "0." : NULL); gstring = g_string_append_c (gstring, ch); do /* while (in_number) */ { gboolean is_E; is_E = token == G_TOKEN_FLOAT && (ch == 'e' || ch == 'E'); ch = g_scanner_peek_next_char (scanner); if (g_scanner_char_2_num (ch, 36) >= 0 || (config->scan_float && ch == '.') || (is_E && (ch == '+' || ch == '-'))) { ch = g_scanner_get_char (scanner, line_p, position_p); switch (ch) { case '.': if (token != G_TOKEN_INT && token != G_TOKEN_OCTAL) { value.v_error = token == G_TOKEN_FLOAT ? G_ERR_FLOAT_MALFORMED : G_ERR_FLOAT_RADIX; token = G_TOKEN_ERROR; in_number = FALSE; } else { token = G_TOKEN_FLOAT; gstring = g_string_append_c (gstring, ch); } break; case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9': gstring = g_string_append_c (gstring, ch); break; case '-': case '+': if (token != G_TOKEN_FLOAT) { token = G_TOKEN_ERROR; value.v_error = G_ERR_NON_DIGIT_IN_CONST; in_number = FALSE; } else gstring = g_string_append_c (gstring, ch); break; case 'e': case 'E': if ((token != G_TOKEN_HEX && !config->scan_float) || (token != G_TOKEN_HEX && token != G_TOKEN_OCTAL && token != G_TOKEN_FLOAT && token != G_TOKEN_INT)) { token = G_TOKEN_ERROR; value.v_error = G_ERR_NON_DIGIT_IN_CONST; in_number = FALSE; } else { if (token != G_TOKEN_HEX) token = G_TOKEN_FLOAT; gstring = g_string_append_c (gstring, ch); } break; default: if (token != G_TOKEN_HEX) { token = G_TOKEN_ERROR; value.v_error = G_ERR_NON_DIGIT_IN_CONST; in_number = FALSE; } else gstring = g_string_append_c (gstring, ch); break; } } else in_number = FALSE; } while (in_number); endptr = NULL; if (token == G_TOKEN_FLOAT) value.v_float = g_strtod (gstring->str, &endptr); else { guint64 ui64 = 0; switch (token) { case G_TOKEN_BINARY: ui64 = g_ascii_strtoull (gstring->str, &endptr, 2); break; case G_TOKEN_OCTAL: ui64 = g_ascii_strtoull (gstring->str, &endptr, 8); break; case G_TOKEN_INT: ui64 = g_ascii_strtoull (gstring->str, &endptr, 10); break; case G_TOKEN_HEX: ui64 = g_ascii_strtoull (gstring->str, &endptr, 16); break; default: ; } if (scanner->config->store_int64) value.v_int64 = ui64; else value.v_int = ui64; } if (endptr && *endptr) { token = G_TOKEN_ERROR; if (*endptr == 'e' || *endptr == 'E') value.v_error = G_ERR_NON_DIGIT_IN_CONST; else value.v_error = G_ERR_DIGIT_RADIX; } g_string_free (gstring, TRUE); gstring = NULL; ch = 0; } /* number_parsing:... */ break; default: default_case: { if (config->cpair_comment_single && ch == config->cpair_comment_single[0]) { token = G_TOKEN_COMMENT_SINGLE; in_comment_single = TRUE; gstring = g_string_new (NULL); ch = g_scanner_get_char (scanner, line_p, position_p); while (ch != 0) { if (ch == config->cpair_comment_single[1]) { in_comment_single = FALSE; ch = 0; break; } gstring = g_string_append_c (gstring, ch); ch = g_scanner_get_char (scanner, line_p, position_p); } } else if (config->scan_identifier && ch && strchr (config->cset_identifier_first, ch)) { identifier_precedence: if (config->cset_identifier_nth && ch && strchr (config->cset_identifier_nth, g_scanner_peek_next_char (scanner))) { token = G_TOKEN_IDENTIFIER; gstring = g_string_new (NULL); gstring = g_string_append_c (gstring, ch); do { ch = g_scanner_get_char (scanner, line_p, position_p); gstring = g_string_append_c (gstring, ch); ch = g_scanner_peek_next_char (scanner); } while (ch && strchr (config->cset_identifier_nth, ch)); ch = 0; } else if (config->scan_identifier_1char) { token = G_TOKEN_IDENTIFIER; value.v_identifier = g_new0 (gchar, 2); value.v_identifier[0] = ch; ch = 0; } } if (ch) { if (config->char_2_token) token = ch; else { token = G_TOKEN_CHAR; value.v_char = ch; } ch = 0; } } /* default_case:... */ break; } g_assert (ch == 0 && token != G_TOKEN_NONE); /* paranoid */ } while (ch != 0); if (in_comment_multi || in_comment_single || in_string_sq || in_string_dq) { token = G_TOKEN_ERROR; if (gstring) { g_string_free (gstring, TRUE); gstring = NULL; } (*position_p)++; if (in_comment_multi || in_comment_single) value.v_error = G_ERR_UNEXP_EOF_IN_COMMENT; else /* (in_string_sq || in_string_dq) */ value.v_error = G_ERR_UNEXP_EOF_IN_STRING; } if (gstring) { value.v_string = gstring->str; g_string_free (gstring, FALSE); gstring = NULL; } if (token == G_TOKEN_IDENTIFIER) { if (config->scan_symbols) { GScannerKey *key; guint scope_id; scope_id = scanner->scope_id; key = g_scanner_lookup_internal (scanner, scope_id, value.v_identifier); if (!key && scope_id && scanner->config->scope_0_fallback) key = g_scanner_lookup_internal (scanner, 0, value.v_identifier); if (key) { g_free (value.v_identifier); token = G_TOKEN_SYMBOL; value.v_symbol = key->value; } } if (token == G_TOKEN_IDENTIFIER && config->scan_identifier_NULL && strlen (value.v_identifier) == 4) { gchar *null_upper = "NULL"; gchar *null_lower = "null"; if (scanner->config->case_sensitive) { if (value.v_identifier[0] == null_upper[0] && value.v_identifier[1] == null_upper[1] && value.v_identifier[2] == null_upper[2] && value.v_identifier[3] == null_upper[3]) token = G_TOKEN_IDENTIFIER_NULL; } else { if ((value.v_identifier[0] == null_upper[0] || value.v_identifier[0] == null_lower[0]) && (value.v_identifier[1] == null_upper[1] || value.v_identifier[1] == null_lower[1]) && (value.v_identifier[2] == null_upper[2] || value.v_identifier[2] == null_lower[2]) && (value.v_identifier[3] == null_upper[3] || value.v_identifier[3] == null_lower[3])) token = G_TOKEN_IDENTIFIER_NULL; } } } *token_p = token; *value_p = value; }
static struct http_parsing_result_s http_parse(struct http_parser_s *parser, const guint8 *data, gsize available) { gsize consumed = 0; struct http_parsing_result_s _build_rc(int status, const gchar *msg) { struct http_parsing_result_s rc; if (msg) parser->error = NEWERROR(0, "%s", msg); rc.status = status; rc.consumed = consumed; return rc; } while (consumed < available) { guint8 d = data[consumed]; gint64 max; switch (parser->step) { case STEP_FIRST_R0: if (d == '\r') parser->step = STEP_FIRST_N0; else g_string_append_c(parser->buf, d); ++ consumed; continue; case STEP_FIRST_N0: if (d == '\n') { if (!_manage_and_renew_command(parser, parser->buf)) return _build_rc(HPRC_ERROR, "CMD parsing error"); parser->step = STEP_SEP_R0; ++ consumed; continue; } return _build_rc(HPRC_ERROR, "CMD parsing error"); case STEP_SEP_R0: if (d == '\r') parser->step = STEP_SEP_N0; else { if (!_manage_and_renew_header(parser, parser->buf)) return _build_rc(HPRC_ERROR, "HDR parsing error"); g_string_append_c(parser->buf, d); parser->step = STEP_HEADERS_R0; } ++ consumed; continue; case STEP_SEP_N0: if (d == '\n') { ++ consumed; if (!_manage_and_renew_header(parser, parser->buf)) return _build_rc(HPRC_ERROR, "HDR parsing error"); parser->step = STEP_BODY_ASIS; if (parser->content_read >= parser->content_length) return _build_rc(HPRC_SUCCESS, NULL); continue; } return _build_rc(HPRC_ERROR, "SEP parsing error"); case STEP_HEADERS_R0: if (d == '\r') parser->step = STEP_HEADERS_N0; else g_string_append_c(parser->buf, d); ++ consumed; continue; case STEP_HEADERS_N0: if (d == '\n') { parser->step = STEP_SEP_R0; ++ consumed; continue; } return _build_rc(HPRC_ERROR, "HDR parsing error"); case STEP_BODY_ASIS: max = available - consumed; if (max > (parser->content_length - parser->content_read)) max = parser->content_length - parser->content_read; if (parser->body_provider) parser->body_provider(data+consumed, max); consumed += max; parser->content_read += max; if (parser->content_read >= parser->content_length) return _build_rc(HPRC_SUCCESS, NULL); continue; } } return _build_rc(HPRC_MORE, NULL); }
static void set_preview_widget (TablePreferences *tpref) { GtkWidget *preview = NULL; GtkTreeIter iter; if (!tpref->priv->current_column) return; if (gtk_combo_box_get_active_iter (GTK_COMBO_BOX (tpref->priv->plugins_combo), &iter)) { GdauiPlugin *plugin; GtkTreeModel *model; GType gtype; gtype = tpref->priv->current_column->gtype; model = tpref->priv->plugins_model; gtk_tree_model_get (model, &iter, PL_COLUMN_PLUGIN, &plugin, -1); if (plugin) { GString *string = NULL; if (tpref->priv->options_wid) { GdaSet *plist; GSList *list; plist = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (tpref->priv->options_wid)); for (list = plist->holders; list; list = list->next) { GdaHolder *holder; holder = GDA_HOLDER (list->data); if (gda_holder_is_valid (holder)) { const GValue *cvalue; cvalue = gda_holder_get_value (holder); if (cvalue && (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)) { gchar *str = gda_value_stringify (cvalue); gchar *r1, *r2; if (!string) string = g_string_new (""); else g_string_append_c (string, ';'); r1 = gda_rfc1738_encode (gda_holder_get_id (holder)); r2 = gda_rfc1738_encode (str); g_free (str); g_string_append_printf (string, "%s=%s", r1, r2); g_free (r1); g_free (r2); } } } } if (string) { g_string_prepend_c (string, ':'); g_string_prepend (string, plugin->plugin_name); preview = GTK_WIDGET (gdaui_new_data_entry (gtype, string->str)); g_string_free (string, TRUE); } else preview = GTK_WIDGET (gdaui_new_data_entry (gtype, plugin->plugin_name)); } else preview = GTK_WIDGET (gdaui_new_data_entry (gtype, NULL)); } GValue *prev_value = NULL; if (tpref->priv->preview_wid) { prev_value = gdaui_data_entry_get_value (GDAUI_DATA_ENTRY (tpref->priv->preview_wid)); gtk_widget_destroy (tpref->priv->preview_wid); gtk_widget_show (tpref->priv->preview_none); tpref->priv->preview_wid = NULL; } if (preview) { if (prev_value && (G_VALUE_TYPE (prev_value) == gdaui_data_entry_get_value_type (GDAUI_DATA_ENTRY (preview)))) gdaui_data_entry_set_value (GDAUI_DATA_ENTRY (preview), prev_value); gdaui_data_entry_set_attributes (GDAUI_DATA_ENTRY (preview), 0, GDA_VALUE_ATTR_ACTIONS_SHOWN); tpref->priv->preview_wid = preview; gtk_box_pack_start (GTK_BOX (tpref->priv->preview_vbox), preview, TRUE, TRUE, 0); gtk_widget_hide (tpref->priv->preview_none); gtk_widget_show (tpref->priv->preview_wid); } if (prev_value) gda_value_free (prev_value); }
/* Save all settings, return 0 on success. */ static int save_settings (SettingsDlg *dialog) { GtkWidget *errwdg; if (!dialog->modified) return 0; /* No need to save anything. */ if ((errwdg = check_default_key (dialog))) { gtk_widget_grab_focus (errwdg); return -1; } #ifdef ENABLE_KEYSERVER_SUPPORT if (!dialog->gnupg21) { if ((errwdg = check_default_keyserver (dialog))) { gpa_window_error (_("The URL given for the keyserver is not valid."), GTK_WIDGET (dialog)); gtk_widget_grab_focus (errwdg); return -1; } } #endif /*ENABLE_KEYSERVER_SUPPORT*/ if ( dialog->akl.enabled && (errwdg = check_akl (dialog))) { gpa_window_error (_("The data given for \"Auto key locate\" is not valid."), GTK_WIDGET (dialog)); gtk_widget_grab_focus (errwdg); return -1; } gpa_options_set_default_key (gpa_options_get_instance (), dialog->default_key.key); #ifdef ENABLE_KEYSERVER_SUPPORT if (!dialog->gnupg21) gpa_options_set_default_keyserver (gpa_options_get_instance (), dialog->keyserver.url); #endif /*ENABLE_KEYSERVER_SUPPORT*/ if (!dialog->akl.enabled) ; else if (dialog->akl.method_idx == -1) ; /* oops: none selected. */ else if (!akl_table[dialog->akl.method_idx].list) { /* Custom setting: Do nothing. */ } else { const char *methods = akl_table[dialog->akl.method_idx].list; GString *newakl; newakl = g_string_new (""); for (; *methods; methods++) { if (newakl->len) g_string_append_c (newakl, ','); switch (*methods) { case 'n': g_string_append (newakl, "nodefault"); break; case 'l': g_string_append (newakl, "local"); break; case 'c': g_string_append (newakl, "cert"); break; case 'L': g_string_append (newakl, "ldap"); break; case 'k': g_string_append (newakl, "keyserver"); break; case 'D': g_string_append_printf (newakl, "kdns://%s/?at=_kdnscert&usevc=1", dialog->akl.ip_addr ? dialog->akl.ip_addr : ""); break; default: if (newakl->len) g_string_truncate (newakl, newakl->len - 1); break; } } gpa_store_gpgconf_string ("gpg", "auto-key-locate", newakl->str); g_string_free (newakl, TRUE); } return 0; }
/* * parses @str, and appends to @string lines which are @width large, if @offset is >0, then * leave that amount of spaces. If @width <= 0, then only adds @offset spaces at the beginning of each * new line. */ static void append_to_string (GString *string, gchar *str, gint width, gint offset) { g_assert (string); if (!str) return; if ((width <= 0) && (offset <= 0)) { g_string_append (string, str); return; } if (offset < 0) offset = 0; /* replace @WORD@ by <WORD> */ gchar *ptr; gboolean in = FALSE; for (ptr = str; *ptr; ptr++) { if (*ptr == '@') { if (in) { *ptr = '>'; in = FALSE; } else { *ptr = '<'; in = TRUE; } } } /* actual work */ gboolean firstword = TRUE; gint clen = 0; if ((string->str) && (string->len > 0) && (string->str[string->len - 1] != '\n')) { for (ptr = string->str + (string->len -1); (ptr >= string->str) && (*ptr != '\n'); ptr --) clen++; } if (!strcmp (str, "> ")) { if (offset > 0) { gint i; for (i = 0; i < offset; i++) g_string_append_c (string, ' '); } g_string_append (string, str); return; } for (ptr = str; *ptr; ) { /* skip spaces */ if ((*ptr == ' ') || (*ptr == '\t') || (*ptr == '\n') || (*ptr == '\r')) { ptr++; continue; } /* find end of next word */ gchar *next; gint wlen; for (wlen = 0, next = ptr; *next && (*next != ' ') && (*next != '\t') && (*next != '\n') && (*next != '\r'); wlen ++, next = g_utf8_next_char (next)); if (wlen >= width - offset) { const gchar *n2; for (n2 = ptr; n2 < next; n2++) { g_string_append_c (string, *n2); } ptr = next; firstword = FALSE; g_string_append_c (string, '\n'); clen = 0; continue; } else if ((width > 0) && ((wlen + clen) >= width)) { /* cut here */ g_string_append_c (string, '\n'); clen = 0; continue; } else { /* copy word */ if (clen == 0) { if (offset > 0) { gint i; for (i = 0; i < offset; i++) { g_string_append_c (string, ' '); clen++; } } } else if (!firstword) { g_string_append_c (string, ' '); clen++; } const gchar *n2; for (n2 = ptr; n2 < next; n2++) { g_string_append_c (string, *n2); clen++; } ptr = next; firstword = FALSE; } } }
static gchar * tmplayer_parse_line (ParserState * state, const gchar * line, guint line_num) { GstClockTime ts = GST_CLOCK_TIME_NONE; const gchar *text_start = NULL; gboolean multiline = FALSE; gchar *ret = NULL; gchar divc = '\0'; guint h, m, s, l = 1; if (sscanf (line, "%u:%02u:%02u,%u%c", &h, &m, &s, &l, &divc) == 5 && (divc == '=')) { GST_LOG ("multiline format %u %u %u %u", h, m, s, l); ts = GST_SECOND * ((((h * 60) + m) * 60) + s); text_start = strchr (line, '='); multiline = TRUE; } else if (sscanf (line, "%u:%02u:%02u%c", &h, &m, &s, &divc) == 4 && (divc == '=' || divc == ':')) { GST_LOG ("single line format %u %u %u %u %c", h, m, s, l, divc); ts = GST_SECOND * ((((h * 60) + m) * 60) + s); text_start = strchr (line + 6, divc); } else if (line[0] == '\0' && state->buf->len > 0 && GST_CLOCK_TIME_IS_VALID (state->start_time)) { /* if we get an empty line (could be the end of the file, but doesn't have * to be), just push whatever is still in the buffer without a duration */ GST_LOG ("empty line, and there's still text in the buffer"); ret = tmplayer_process_buffer (state); state->duration = GST_CLOCK_TIME_NONE; return ret; } else { GST_WARNING ("failed to parse line: '%s'", line); return NULL; } /* if this is a line without text, or the first line in a multiline file, * process and return the data in the buffer, which is the previous line(s) */ if (text_start == NULL || text_start[1] == '\0' || (l == 1 && state->buf->len > 0)) { if (GST_CLOCK_TIME_IS_VALID (state->start_time) && state->start_time < ts && line_num > 0) { ret = tmplayer_process_buffer (state); state->duration = ts - state->start_time; /* ..and append current line's text (if there is any) for the next round. * We don't have to store ts as pending_start_time, since we deduce the * durations from the start times anyway, so as long as the parser just * forwards state->start_time by duration after it pushes the line we * are about to return it will all be good. */ g_string_append (state->buf, text_start + 1); } else if (line_num > 0) { GST_WARNING ("end of subtitle unit but no valid start time?!"); } } else { if (l > 1) g_string_append_c (state->buf, '\n'); g_string_append (state->buf, text_start + 1); state->start_time = ts; } GST_LOG ("returning: '%s'", GST_STR_NULL (ret)); return ret; }
static gint sc_speller_check_word(GeanyDocument *doc, gint line_number, const gchar *word, gint start_pos, gint end_pos) { gsize n_suggs = 0; gchar *word_to_check; gint offset; g_return_val_if_fail(sc_speller_dict != NULL, 0); g_return_val_if_fail(doc != NULL, 0); g_return_val_if_fail(word != NULL, 0); g_return_val_if_fail(start_pos >= 0 && end_pos >= 0, 0); if (EMPTY(word)) return 0; /* ignore numbers or words starting with digits */ if (isdigit(*word)) return 0; /* ignore non-text */ if (! sc_speller_is_text(doc, start_pos)) return 0; /* strip punctuation and white space */ word_to_check = strip_word(word, &offset); if (! NZV(word_to_check)) { g_free(word_to_check); return 0; } /* recalculate start_pos and end_pos */ start_pos += offset; end_pos = start_pos + strlen(word_to_check); /* early out if the word is spelled correctly */ if (enchant_dict_check(sc_speller_dict, word_to_check, -1) == 0) { g_free(word_to_check); return 0; } editor_indicator_set_on_range(doc->editor, GEANY_INDICATOR_ERROR, start_pos, end_pos); if (sc_info->use_msgwin && line_number != -1) { gsize j; gchar **suggs; GString *str; str = g_string_sized_new(256); suggs = enchant_dict_suggest(sc_speller_dict, word_to_check, -1, &n_suggs); if (suggs != NULL) { g_string_append_printf(str, "line %d: %s | ", line_number + 1, word_to_check); g_string_append(str, _("Try: ")); /* Now find the misspellings in the line, limit suggestions to a maximum of 15 (for now) */ for (j = 0; j < MIN(n_suggs, 15); j++) { g_string_append(str, suggs[j]); g_string_append_c(str, ' '); } msgwin_msg_add(COLOR_RED, line_number + 1, doc, "%s", str->str); if (suggs != NULL && n_suggs > 0) enchant_dict_free_string_list(sc_speller_dict, suggs); } g_string_free(str, TRUE); } g_free(word_to_check); return n_suggs; }
static cb_ret_t enter (WInput * lc_cmdline) { char *cmd = lc_cmdline->buffer; if (!command_prompt) return MSG_HANDLED; /* Any initial whitespace should be removed at this point */ while (*cmd == ' ' || *cmd == '\t' || *cmd == '\n') cmd++; if (!*cmd) return MSG_HANDLED; if (strncmp (cmd, "cd ", 3) == 0 || strcmp (cmd, "cd") == 0) { do_cd_command (cmd); input_clean (lc_cmdline); return MSG_HANDLED; } else if (strcmp (cmd, "exit") == 0) { input_assign_text (lc_cmdline, ""); if (!quiet_quit_cmd ()) return MSG_NOT_HANDLED; } else { GString *command; size_t i; if (!vfs_current_is_local ()) { message (D_ERROR, MSG_ERROR, _("Cannot execute commands on non-local filesystems")); return MSG_NOT_HANDLED; } #ifdef ENABLE_SUBSHELL /* Check this early before we clean command line * (will be checked again by shell_execute) */ if (mc_global.tty.use_subshell && subshell_state != INACTIVE) { message (D_ERROR, MSG_ERROR, _("The shell is already running a command")); return MSG_NOT_HANDLED; } #endif command = g_string_sized_new (32); for (i = 0; cmd[i] != '\0'; i++) { if (cmd[i] != '%') g_string_append_c (command, cmd[i]); else { char *s; s = expand_format (NULL, cmd[++i], TRUE); g_string_append (command, s); g_free (s); } } input_clean (lc_cmdline); shell_execute (command->str, 0); g_string_free (command, TRUE); #ifdef ENABLE_SUBSHELL if ((quit & SUBSHELL_EXIT) != 0) { if (quiet_quit_cmd ()) return MSG_HANDLED; quit = 0; /* restart subshell */ if (mc_global.tty.use_subshell) init_subshell (); } if (mc_global.tty.use_subshell) do_load_prompt (); #endif } return MSG_HANDLED; }