gboolean tagsistant_wal_apply_log(dbi_conn dbi, const gchar *log_entry, const gchar *last_tstamp) { gboolean parsed = FALSE; gchar *wal_entry_path = g_strdup_printf("%s/wal/%s", tagsistant.repository, log_entry); if (!wal_entry_path) { dbg('s', LOG_ERR, "WAL: error opening %s/wal/%s", tagsistant.repository, log_entry); return (FALSE); } GFile *f = g_file_new_for_path(wal_entry_path); if (f) { GFileInputStream *s = g_file_read(f, NULL, NULL); if (s) { GDataInputStream *ds = g_data_input_stream_new(G_INPUT_STREAM(s)); if (ds) { while (1) { gsize size; GError *error = NULL; gchar *line = g_data_input_stream_read_line(ds, &size, NULL, &error); if (line) { if (!tagsistant_wal_apply_line(dbi, line, last_tstamp)) break; } else { if (!error) { // last line read parsed = TRUE; } else { dbg('s', LOG_ERR, "WAL: error parsing line: %s", error->message); g_error_free(error); } break; } } g_object_unref(ds); } g_object_unref(s); } g_object_unref(f); } g_free(wal_entry_path); return (parsed); }
gboolean rejilla_image_format_cue_bin_byte_swap (gchar *uri, GCancellable *cancel, GError **error) { GFile *file; gchar *line; GFileInputStream *input; GDataInputStream *stream; gboolean is_audio = FALSE; gboolean is_binary = FALSE; file = g_file_new_for_uri (uri); input = g_file_read (file, cancel, error); if (!input) { g_object_unref (file); return FALSE; } stream = g_data_input_stream_new (G_INPUT_STREAM (input)); g_object_unref (input); while ((line = g_data_input_stream_read_line (stream, NULL, cancel, error))) { const gchar *ptr; if ((ptr = strstr (line, "FILE"))) { if (strstr (ptr, "BINARY")) is_binary = TRUE; } else if ((ptr = strstr (line, "TRACK"))) { if (strstr (ptr, "AUDIO")) is_audio = TRUE; } g_free (line); } g_object_unref (stream); g_object_unref (file); return is_binary && is_audio; }
/** * pk_package_sack_add_packages_from_file * @sack: a valid #PkPackageSack instance * @file: a valid package-list file * @error: a %GError to put the error code and message in, or %NULL * * Adds packages from package-list file to a PkPackageSack. * * Return value: %TRUE if there were no errors. * **/ gboolean pk_package_sack_add_packages_from_file (PkPackageSack *sack, GFile *file, GError **error) { GError *error_local = NULL; gboolean ret = TRUE; GFileInputStream *is; GDataInputStream *input; g_return_val_if_fail (PK_IS_PACKAGE_SACK (sack), FALSE); is = g_file_read (file, NULL, &error_local); if (is == NULL) { g_propagate_error (error, error_local); return FALSE; } input = g_data_input_stream_new (G_INPUT_STREAM (is)); /* read package info file line by line */ while (TRUE) { gchar *line; line = g_data_input_stream_read_line (input, NULL, NULL, &error_local); if (line == NULL) break; g_strstrip (line); pk_package_sack_add_packages_from_line (sack, line, &error_local); if (error_local != NULL) { g_propagate_error (error, error_local); ret = FALSE; break; } } g_object_unref (input); g_object_unref (is); return ret; }
gboolean _http_response_read_from_stream_real(HttpPackage * package, GDataInputStream * data_stream, gsize * length, GCancellable * cancellable, GError ** error) { HttpResponsePrivate * priv = http_response_get_instance_private(HTTP_RESPONSE(package)); gboolean done = TRUE; gsize count = 0,total_count = 0; gchar * string_response = g_data_input_stream_read_line(data_stream,&total_count,cancellable,error); if(string_response) { static gchar version[10]; static gint code = HTTP_RESPONSE_INVALID; sscanf(string_response,"%s %d",version,&code); int iresponse; for(iresponse = 0;iresponse < HTTP_RESPONSE_INVALID;iresponse++) { if(_http_response_codes[iresponse] == code) { priv->code = (HttpResponseCode)iresponse; break; } } priv->version = g_strtod(version + 5,NULL); done = HTTP_PACKAGE_CLASS(http_response_parent_class)->read_from_stream(package,data_stream,&count,cancellable,error); total_count += count; if(length) *length = total_count; g_free(string_response); } else done = FALSE; return done; }
gboolean _http_package_read_from_stream_real(HttpPackage * package, GDataInputStream * data_stream, gsize * length, GCancellable * cancellable, GError ** error) { http_package_reset(package); gsize count = 0; gchar * content = NULL; gboolean can_continue = TRUE; do { content = g_data_input_stream_read_line(data_stream,&count,cancellable,error); if(content != NULL) { can_continue = count > 0; if(can_continue) { gchar ** split_content = g_strsplit(content,":",2); if(split_content[0] && split_content[1]) { g_strstrip(split_content[0]); g_strstrip(split_content[1]); http_package_set_string(package,split_content[0],split_content[1],-1); } g_strfreev(split_content); } g_free(content); } else can_continue = FALSE; }while(can_continue); return TRUE; }
static gboolean grep_literal (GFile *f, const char *string, gboolean *out_matches, GCancellable *cancellable, GError **error) { gboolean ret = FALSE; gboolean ret_matches = FALSE; ot_lobj GInputStream *in = NULL; ot_lobj GDataInputStream *datain = NULL; ot_lfree char *line = NULL; in = (GInputStream*)g_file_read (f, cancellable, error); if (!in) goto out; datain = (GDataInputStream*)g_data_input_stream_new (in); if (!in) goto out; while ((line = g_data_input_stream_read_line (datain, NULL, cancellable, error)) != NULL) { if (strstr (line, string)) { ret_matches = TRUE; break; } g_free (line); } ret = TRUE; if (out_matches) *out_matches = ret_matches; out: return ret; }
/* like g_data_input_stream_read_line() but sets error if there's no content to read */ static gchar * _my_g_data_input_stream_read_line (GDataInputStream *dis, gsize *out_line_length, GCancellable *cancellable, GError **error) { gchar *ret; g_return_val_if_fail (error == NULL || *error == NULL, NULL); ret = g_data_input_stream_read_line (dis, out_line_length, cancellable, error); if (ret == NULL && error != NULL && *error == NULL) { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Unexpected lack of content trying to read a line")); } return ret; }
static gboolean sysroot_stdout_ready_cb (GPollableInputStream *pollable_stream, StdoutClosure *closure) { glnx_unref_object RpmostreedSysroot *sysroot = NULL; glnx_unref_object RpmostreedTransaction *transaction = NULL; GMemoryInputStream *memory_stream; GBufferedInputStream *buffered_stream; char buffer[1024]; gconstpointer stream_buffer; gsize stream_buffer_size; gsize total_bytes_read = 0; gboolean have_line = FALSE; GError *local_error = NULL; sysroot = g_weak_ref_get (&closure->sysroot); if (sysroot != NULL) transaction = rpmostreed_transaction_monitor_ref_active_transaction (sysroot->transaction_monitor); /* XXX Would very much like g_buffered_input_stream_fill_nonblocking(). * Much of this function is a clumsy and inefficient attempt to * achieve the same thing. * * See: https://bugzilla.gnome.org/726797 */ buffered_stream = G_BUFFERED_INPUT_STREAM (closure->data_stream); memory_stream = (GMemoryInputStream *) g_filter_input_stream_get_base_stream (G_FILTER_INPUT_STREAM (buffered_stream)); while (local_error == NULL) { gssize n_read; n_read = g_pollable_input_stream_read_nonblocking (pollable_stream, buffer, sizeof (buffer), NULL, &local_error); if (n_read > 0) { /* XXX Gotta use GBytes so the data gets copied. */ g_autoptr(GBytes) bytes = g_bytes_new (buffer, n_read); g_memory_input_stream_add_bytes (memory_stream, bytes); total_bytes_read += n_read; } } if (!g_error_matches (local_error, G_IO_ERROR, G_IO_ERROR_WOULD_BLOCK)) goto out; g_clear_error (&local_error); read_another_line: /* Fill the buffered stream with the data we just put in the * memory stream, then peek at the buffer to see if it's safe * to call g_data_input_stream_read_line() without blocking. * * XXX Oye, there's gotta be an easier way to do this... */ /* This should never fail since it's just reading from memory. */ g_buffered_input_stream_fill (buffered_stream, total_bytes_read, NULL, NULL); stream_buffer = g_buffered_input_stream_peek_buffer (buffered_stream, &stream_buffer_size); have_line = (memchr (stream_buffer, '\n', stream_buffer_size) != NULL); if (have_line) { g_autofree char *line = NULL; gsize length; line = g_data_input_stream_read_line (closure->data_stream, &length, NULL, &local_error); if (local_error != NULL) goto out; /* If there's an active transaction, forward the line to the * transaction's owner through the "Message" signal. Otherwise * dump it to the non-redirected standard output stream. */ if (transaction != NULL) { rpmostree_transaction_emit_message (RPMOSTREE_TRANSACTION (transaction), line); } else { /* This is essentially puts(), don't care about errors. */ g_output_stream_write_all (closure->real_stdout, line, length, NULL, NULL, NULL); g_output_stream_write_all (closure->real_stdout, "\n", 1, NULL, NULL, NULL); } goto read_another_line; } out: if (local_error != NULL) { g_warning ("Failed to read stdout pipe: %s", local_error->message); g_clear_error (&local_error); } return G_SOURCE_CONTINUE; }
RejillaImageFormat rejilla_image_format_identify_cuesheet (const gchar *uri, GCancellable *cancel, GError **error) { GFile *file; gchar *line; GFileInputStream *input; GDataInputStream *stream; RejillaImageFormat format; file = g_file_new_for_uri (uri); input = g_file_read (file, cancel, error); if (!input) { g_object_unref (file); return FALSE; } stream = g_data_input_stream_new (G_INPUT_STREAM (input)); g_object_unref (input); format = REJILLA_IMAGE_FORMAT_NONE; while ((line = g_data_input_stream_read_line (stream, NULL, cancel, error))) { /* Keywords for cdrdao cuesheets */ if (strstr (line, "CD_ROM_XA") || strstr (line, "CD_ROM") || strstr (line, "CD_DA") || strstr (line, "CD_TEXT")) { format = REJILLA_IMAGE_FORMAT_CDRDAO; g_free (line); break; } else if (strstr (line, "TRACK")) { /* NOTE: there is also "AUDIO" but it's common to both */ /* CDRDAO */ if (strstr (line, "MODE1") || strstr (line, "MODE1_RAW") || strstr (line, "MODE2_FORM1") || strstr (line, "MODE2_FORM2") || strstr (line, "MODE_2_RAW") || strstr (line, "MODE2_FORM_MIX") || strstr (line, "MODE2")) { format = REJILLA_IMAGE_FORMAT_CDRDAO; g_free (line); break; } /* .CUE file */ else if (strstr (line, "CDG") || strstr (line, "MODE1/2048") || strstr (line, "MODE1/2352") || strstr (line, "MODE2/2336") || strstr (line, "MODE2/2352") || strstr (line, "CDI/2336") || strstr (line, "CDI/2352")) { format = REJILLA_IMAGE_FORMAT_CUE; g_free (line); break; } } else if (strstr (line, "FILE")) { if (strstr (line, "MOTOROLA") || strstr (line, "BINARY") || strstr (line, "AIFF") || strstr (line, "WAVE") || strstr (line, "MP3")) { format = REJILLA_IMAGE_FORMAT_CUE; g_free (line); break; } } g_free (line); line = NULL; } g_object_unref (stream); g_object_unref (file); REJILLA_BURN_LOG_WITH_FULL_TYPE (REJILLA_TRACK_TYPE_IMAGE, format, REJILLA_BURN_FLAG_NONE, "Detected"); return format; }
JS_EXPORT_API JSObjectRef installer_get_timezone_list () { GRAB_CTX (); gsize index = 0; GError *error = NULL; GFile *file = NULL; GFileInputStream *input = NULL; GDataInputStream *data_input = NULL; JSObjectRef timezones = json_array_create (); file = g_file_new_for_path ("/usr/share/zoneinfo/zone.tab"); if (!g_file_query_exists (file, NULL)) { g_warning ("get timezone list:zone.tab not exists\n"); goto out; } input = g_file_read (file, NULL, &error); if (error != NULL){ g_warning ("get timezone list:read zone.tab error->%s", error->message); goto out; } data_input = g_data_input_stream_new ((GInputStream *) input); if (data_input == NULL) { g_warning ("get timezone list:get data input stream failed\n"); goto out; } char *data = (char *) 1; while (data) { data = g_data_input_stream_read_line (data_input, NULL, NULL, NULL); if (data == NULL) { break; } if (g_str_has_prefix (data, "#")){ g_debug ("get timezone list:comment line, just pass"); continue; } else { gchar **line = g_strsplit (data, "\t", -1); if (line == NULL) { g_warning ("get timezone list:split %s failed\n", data); } else { json_array_insert (timezones, index, jsvalue_from_cstr (get_global_context (), line[2])); index++; g_strfreev (line); } } } goto out; out: if (file != NULL) { g_object_unref (file); } if (data_input != NULL) { g_object_unref (data_input); } if (input != NULL) { g_object_unref (input); } if (error != NULL) { g_error_free (error); error = NULL; } UNGRAB_CTX (); return timezones; }
viewlist* viewlist_construct_view_start (GType object_type, world_wide* w, const gchar* full_path) { viewlist* self = NULL; world_wide* _tmp0_; const gchar* _tmp1_; gchar* _tmp2_ = NULL; GError * _inner_error_ = NULL; g_return_val_if_fail (full_path != NULL, NULL); self = (viewlist*) playlist_construct (object_type); _tmp0_ = w; ((screen*) self)->world = _tmp0_; _tmp1_ = full_path; _tmp2_ = remove_slashes (_tmp1_); _g_free0 (((playlist*) self)->m3u_path); ((playlist*) self)->m3u_path = _tmp2_; { gchar* line = NULL; const gchar* _tmp3_; GFile* _tmp4_ = NULL; GFile* file; GFile* _tmp5_; GFileInputStream* _tmp6_ = NULL; GFileInputStream* _tmp7_; GFileInputStream* _tmp8_; GDataInputStream* _tmp9_; GDataInputStream* _tmp10_; GDataInputStream* in_stream; _tmp3_ = ((playlist*) self)->m3u_path; _tmp4_ = g_file_new_for_path (_tmp3_); file = _tmp4_; _tmp5_ = file; _tmp6_ = g_file_read (_tmp5_, NULL, &_inner_error_); _tmp7_ = _tmp6_; if (_inner_error_ != NULL) { _g_object_unref0 (file); _g_free0 (line); goto __catch6_g_error; } _tmp8_ = _tmp7_; _tmp9_ = g_data_input_stream_new ((GInputStream*) _tmp8_); _tmp10_ = _tmp9_; _g_object_unref0 (_tmp8_); in_stream = _tmp10_; while (TRUE) { GDataInputStream* _tmp11_; gchar* _tmp12_ = NULL; gchar* _tmp13_; const gchar* _tmp14_; const gchar* _tmp15_; _tmp11_ = in_stream; _tmp12_ = g_data_input_stream_read_line (_tmp11_, NULL, NULL, &_inner_error_); _tmp13_ = _tmp12_; if (_inner_error_ != NULL) { _g_object_unref0 (in_stream); _g_object_unref0 (file); _g_free0 (line); goto __catch6_g_error; } _g_free0 (line); line = _tmp13_; _tmp14_ = line; if (!(_tmp14_ != NULL)) { break; } _tmp15_ = line; if (g_strcmp0 (_tmp15_, "") != 0) { const gchar* _tmp16_; gchar* _tmp17_; _tmp16_ = line; _tmp17_ = g_strdup (_tmp16_); ((playlist*) self)->entry = g_list_append (((playlist*) self)->entry, _tmp17_); } } _g_object_unref0 (in_stream); _g_object_unref0 (file); _g_free0 (line); } goto __finally6; __catch6_g_error: { GError* err = NULL; world_wide* _tmp18_; dbg* _tmp19_; const gchar* _tmp20_; gchar* _tmp21_; gchar* _tmp22_; gchar* _tmp23_; gchar* _tmp24_; GError* _tmp25_; const gchar* _tmp26_; gchar* _tmp27_; gchar* _tmp28_; err = _inner_error_; _inner_error_ = NULL; _tmp18_ = ((screen*) self)->world; _tmp19_ = _tmp18_->debug; _tmp20_ = ((playlist*) self)->m3u_path; _tmp21_ = g_strconcat ("Read text file error: ", _tmp20_, NULL); _tmp22_ = _tmp21_; _tmp23_ = g_strconcat (_tmp22_, ": ", NULL); _tmp24_ = _tmp23_; _tmp25_ = err; _tmp26_ = _tmp25_->message; _tmp27_ = g_strconcat (_tmp24_, _tmp26_, NULL); _tmp28_ = _tmp27_; dbg_add (_tmp19_, _tmp28_); _g_free0 (_tmp28_); _g_free0 (_tmp24_); _g_free0 (_tmp22_); _g_error_free0 (err); } __finally6: if (_inner_error_ != NULL) { g_critical ("file %s: line %d: uncaught error: %s (%s, %d)", __FILE__, __LINE__, _inner_error_->message, g_quark_to_string (_inner_error_->domain), _inner_error_->code); g_clear_error (&_inner_error_); return NULL; } return self; }
gboolean gimp_curves_config_load_cruft (GimpCurvesConfig *config, GInputStream *input, GError **error) { GDataInputStream *data_input; gint index[5][GIMP_CURVE_N_CRUFT_POINTS]; gint value[5][GIMP_CURVE_N_CRUFT_POINTS]; gchar *line; gsize line_len; gint i, j; g_return_val_if_fail (GIMP_IS_CURVES_CONFIG (config), FALSE); g_return_val_if_fail (G_IS_INPUT_STREAM (input), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); data_input = g_data_input_stream_new (input); line_len = 64; line = g_data_input_stream_read_line (data_input, &line_len, NULL, error); if (! line) return FALSE; if (strcmp (line, "# GIMP Curves File") != 0) { g_set_error_literal (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_PARSE, _("not a GIMP Curves file")); g_object_unref (data_input); g_free (line); return FALSE; } for (i = 0; i < 5; i++) { for (j = 0; j < GIMP_CURVE_N_CRUFT_POINTS; j++) { gchar *x_str = NULL; gchar *y_str = NULL; if (! (x_str = g_data_input_stream_read_upto (data_input, " ", -1, NULL, NULL, error)) || ! g_data_input_stream_read_byte (data_input, NULL, error) || ! (y_str = g_data_input_stream_read_upto (data_input, " ", -1, NULL, NULL, error)) || ! g_data_input_stream_read_byte (data_input, NULL, error)) { g_free (x_str); g_free (y_str); g_object_unref (data_input); return FALSE; } if (sscanf (x_str, "%d", &index[i][j]) != 1 || sscanf (y_str, "%d", &value[i][j]) != 1) { g_set_error_literal (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_PARSE, _("Parse error, didn't find 2 integers")); g_free (x_str); g_free (y_str); g_object_unref (data_input); return FALSE; } g_free (x_str); g_free (y_str); } } g_object_unref (data_input); g_object_freeze_notify (G_OBJECT (config)); for (i = 0; i < 5; i++) { GimpCurve *curve = config->curve[i]; gimp_data_freeze (GIMP_DATA (curve)); gimp_curve_set_curve_type (curve, GIMP_CURVE_SMOOTH); gimp_curve_set_n_points (curve, GIMP_CURVE_N_CRUFT_POINTS); gimp_curve_reset (curve, FALSE); for (j = 0; j < GIMP_CURVE_N_CRUFT_POINTS; j++) { if (index[i][j] < 0 || value[i][j] < 0) gimp_curve_set_point (curve, j, -1.0, -1.0); else gimp_curve_set_point (curve, j, (gdouble) index[i][j] / 255.0, (gdouble) value[i][j] / 255.0); } gimp_data_thaw (GIMP_DATA (curve)); } g_object_thaw_notify (G_OBJECT (config)); return TRUE; }
static gboolean goa_smtp_auth_starttls_sync (GoaMailAuth *_auth, GCancellable *cancellable, GError **error) { GoaSmtpAuth *auth = GOA_SMTP_AUTH (_auth); GDataInputStream *input; GDataOutputStream *output; gboolean ret; gboolean starttls_supported; gchar *domain; gchar *request; gchar *response; starttls_supported = FALSE; domain = NULL; request = NULL; response = NULL; ret = FALSE; domain = smtp_auth_get_domain (auth, error); if (domain == NULL) goto out; input = goa_mail_auth_get_input (_auth); output = goa_mail_auth_get_output (_auth); /* Check the greeting */ if (!smtp_auth_check_greeting (input, cancellable, error)) goto out; /* Send EHLO */ request = g_strdup_printf ("EHLO %s\r\n", domain); g_debug ("> %s", request); if (!g_data_output_stream_put_string (output, request, cancellable, error)) goto out; g_clear_pointer (&request, g_free); /* Check if STARTTLS is supported or not */ ehlo_again: response = g_data_input_stream_read_line (input, NULL, cancellable, error); if (response == NULL) goto out; g_debug ("< %s", response); if (smtp_auth_check_421 (response, error)) goto out; if (smtp_auth_check_not_250 (response, error)) goto out; if (g_str_has_prefix (response + 4, "STARTTLS")) starttls_supported = TRUE; if (response[3] == '-') { g_free (response); goto ehlo_again; } else if (!starttls_supported) { g_set_error (error, GOA_ERROR, GOA_ERROR_NOT_SUPPORTED, _("Server does not support STARTTLS")); goto out; } g_clear_pointer (&response, g_free); /* Send STARTTLS */ request = g_strdup ("STARTTLS\r\n"); g_debug ("> %s", request); if (!g_data_output_stream_put_string (output, request, cancellable, error)) goto out; g_clear_pointer (&request, g_free); response = g_data_input_stream_read_line (input, NULL, cancellable, error); if (response == NULL) goto out; g_debug ("< %s", response); if (smtp_auth_check_454 (response, error)) goto out; if (smtp_auth_check_not_220 (response, error)) goto out; g_clear_pointer (&response, g_free); /* There won't be a greeting after this */ auth->greeting_absent = TRUE; ret = TRUE; out: g_free (domain); g_free (response); g_free (request); return ret; }
static gboolean goa_smtp_auth_run_sync (GoaMailAuth *_auth, GCancellable *cancellable, GError **error) { GoaSmtpAuth *auth = GOA_SMTP_AUTH (_auth); GDataInputStream *input; GDataOutputStream *output; gboolean ret; gchar *auth_arg_base64; gchar *auth_arg_plain; gchar *domain; gchar *password; gchar *request; gchar *response; gsize auth_arg_plain_len; auth_arg_base64 = NULL; auth_arg_plain = NULL; domain = NULL; password = NULL; request = NULL; response = NULL; ret = FALSE; password = smtp_auth_get_password (auth, cancellable, error); if (password == NULL) goto out; domain = smtp_auth_get_domain (auth, error); if (domain == NULL) goto out; input = goa_mail_auth_get_input (_auth); output = goa_mail_auth_get_output (_auth); /* Check the greeting, if there is one */ if (!auth->greeting_absent) { if (!smtp_auth_check_greeting (input, cancellable, error)) goto out; } /* Send EHLO */ request = g_strdup_printf ("EHLO %s\r\n", domain); g_debug ("> %s", request); if (!g_data_output_stream_put_string (output, request, cancellable, error)) goto out; g_clear_pointer (&request, g_free); /* Check which SASL mechanisms are supported */ ehlo_again: response = g_data_input_stream_read_line (input, NULL, cancellable, error); if (response == NULL) goto out; g_debug ("< %s", response); if (smtp_auth_check_421 (response, error)) goto out; if (smtp_auth_check_not_250 (response, error)) goto out; if (g_str_has_prefix (response + 4, "AUTH")) { auth->auth_supported = TRUE; if (strstr (response, "PLAIN") != NULL) auth->plain_supported = TRUE; else if (strstr (response, "LOGIN") != NULL) auth->login_supported = TRUE; } if (response[3] == '-') { g_free (response); goto ehlo_again; } else if (!auth->auth_supported) { ret = TRUE; goto out; } else if (!auth->login_supported && !auth->plain_supported) { g_set_error (error, GOA_ERROR, GOA_ERROR_NOT_SUPPORTED, _("Unknown authentication mechanism")); goto out; } g_clear_pointer (&response, g_free); /* Try different SASL mechanisms */ if (auth->plain_supported) { /* AUTH PLAIN */ auth_arg_plain = g_strdup_printf ("%s%c%s%c%s", auth->username, '\0', auth->username, '\0', password); auth_arg_plain_len = 2 * strlen (auth->username) + 2 + strlen (password); auth_arg_base64 = g_base64_encode ((guchar *) auth_arg_plain, auth_arg_plain_len); request = g_strdup_printf ("AUTH PLAIN %s\r\n", auth_arg_base64); g_debug ("> AUTH PLAIN ********************"); if (!g_data_output_stream_put_string (output, request, cancellable, error)) goto out; g_clear_pointer (&request, g_free); } else { /* AUTH LOGIN */ auth_arg_plain = g_strdup (auth->username); auth_arg_plain_len = strlen (auth->username); auth_arg_base64 = g_base64_encode ((guchar *) auth_arg_plain, auth_arg_plain_len); request = g_strdup_printf ("AUTH LOGIN %s\r\n", auth_arg_base64); g_debug ("> AUTH LOGIN ********************"); if (!g_data_output_stream_put_string (output, request, cancellable, error)) goto out; g_clear_pointer (&request, g_free); response = g_data_input_stream_read_line (input, NULL, cancellable, error); if (response == NULL) goto out; g_debug ("< %s", response); if (smtp_auth_check_not_334_login_password (response, error)) goto out; g_free (auth_arg_plain); g_free (auth_arg_base64); auth_arg_plain = g_strdup (password); auth_arg_plain_len = strlen (password); auth_arg_base64 = g_base64_encode ((guchar *) auth_arg_plain, auth_arg_plain_len); request = g_strdup_printf ("%s\r\n", auth_arg_base64); g_debug ("> ********************"); if (!g_data_output_stream_put_string (output, request, cancellable, error)) goto out; g_clear_pointer (&request, g_free); } response = g_data_input_stream_read_line (input, NULL, cancellable, error); if (response == NULL) goto out; g_debug ("< %s", response); if (smtp_auth_check_not_235 (response, error)) goto out; g_clear_pointer (&response, g_free); ret = TRUE; out: g_free (auth_arg_base64); g_free (auth_arg_plain); g_free (domain); g_free (password); g_free (response); g_free (request); return ret; }
/** * katja_dl_real_generate_cache: **/ void katja_dl_real_generate_cache(KatjaPkgtools *pkgtools, const gchar *tmpl) { gchar **line_tokens, **pkg_tokens, *line, *collection_name = NULL, *list_filename; GFile *list_file; GFileInputStream *fin; GDataInputStream *data_in; sqlite3_stmt *statement = NULL, *pkglist_collection_statement = NULL, *pkglist_statement = NULL; /* Check if the temporary directory for this repository exists. If so the file metadata have to be generated */ list_filename = g_build_filename(tmpl, pkgtools->name->str, "IndexFile", NULL); list_file = g_file_new_for_path(list_filename); fin = g_file_read(list_file, NULL, NULL); g_object_unref(list_file); g_free(list_filename); if (!fin) goto out; /* Remove the old entries from this repository */ if (sqlite3_prepare_v2(katja_pkgtools_db, "DELETE FROM repos WHERE repo LIKE @repo", -1, &statement, NULL) == SQLITE_OK) { sqlite3_bind_text(statement, 1, pkgtools->name->str, -1, SQLITE_TRANSIENT); sqlite3_step(statement); sqlite3_finalize(statement); } if (sqlite3_prepare_v2(katja_pkgtools_db, "INSERT INTO repos (repo_order, repo) VALUES (@repo_order, @repo)", -1, &statement, NULL) != SQLITE_OK) goto out; sqlite3_bind_int(statement, 1, pkgtools->order); sqlite3_bind_text(statement, 2, pkgtools->name->str, -1, SQLITE_TRANSIENT); sqlite3_step(statement); sqlite3_finalize(statement); /* Insert new records */ if ((sqlite3_prepare_v2(katja_pkgtools_db, "INSERT INTO pkglist (full_name, name, ver, arch, " "summary, desc, compressed, uncompressed, cat, repo_order, ext) " "VALUES (@full_name, @name, @ver, @arch, @summary, " "@desc, @compressed, @uncompressed, 'desktop-gnome', @repo_order, @ext)", -1, &pkglist_statement, NULL) != SQLITE_OK) || (sqlite3_prepare_v2(katja_pkgtools_db, "INSERT INTO pkglist (full_name, name, ver, arch, " "summary, desc, compressed, uncompressed, cat, repo_order) " "VALUES (@full_name, @name, @ver, @arch, @summary, " "@desc, @compressed, @uncompressed, 'collections', @repo_order)", -1, &pkglist_collection_statement, NULL) != SQLITE_OK)) goto out; data_in = g_data_input_stream_new(G_INPUT_STREAM(fin)); sqlite3_exec(katja_pkgtools_db, "BEGIN TRANSACTION", NULL, NULL, NULL); while ((line = g_data_input_stream_read_line(data_in, NULL, NULL, NULL))) { line_tokens = g_strsplit(line, ":", 0); if ((g_strv_length(line_tokens) > 6) && (!pkgtools->blacklist || !g_regex_match(pkgtools->blacklist, line_tokens[0], 0, NULL))) { pkg_tokens = katja_pkgtools_cut_pkg(line_tokens[0]); /* If the katja_pkgtools_cut_pkg doesn't return a full name and an extension, it is a collection. * We save its name in this case */ if (!pkg_tokens[3] && !collection_name) { collection_name = g_strdup(pkg_tokens[0]); statement = pkglist_collection_statement; sqlite3_bind_text(statement, 1, line_tokens[0], -1, SQLITE_TRANSIENT); } else { statement = pkglist_statement; sqlite3_bind_text(statement, 1, pkg_tokens[3], -1, SQLITE_TRANSIENT); sqlite3_bind_text(statement, 10, pkg_tokens[4], -1, SQLITE_TRANSIENT); } sqlite3_bind_text(statement, 2, pkg_tokens[0], -1, SQLITE_TRANSIENT); sqlite3_bind_text(statement, 3, pkg_tokens[1], -1, SQLITE_TRANSIENT); sqlite3_bind_text(statement, 4, pkg_tokens[2], -1, SQLITE_TRANSIENT); sqlite3_bind_text(statement, 5, line_tokens[2], -1, SQLITE_TRANSIENT); sqlite3_bind_text(statement, 6, line_tokens[2], -1, SQLITE_TRANSIENT); sqlite3_bind_int(statement, 7, atoi(line_tokens[5])); sqlite3_bind_int(statement, 8, atoi(line_tokens[5])); sqlite3_bind_int(statement, 9, pkgtools->order); sqlite3_step(statement); sqlite3_clear_bindings(statement); sqlite3_reset(statement); g_strfreev(pkg_tokens); } g_strfreev(line_tokens); g_free(line); } /* Create a collection entry */ if (collection_name && g_seekable_seek(G_SEEKABLE(data_in), 0, G_SEEK_SET, NULL, NULL) && (sqlite3_prepare_v2(katja_pkgtools_db, "INSERT INTO collections (name, repo_order, collection_pkg) " "VALUES (@name, @repo_order, @collection_pkg)", -1, &statement, NULL) == SQLITE_OK)) { while ((line = g_data_input_stream_read_line(data_in, NULL, NULL, NULL))) { line_tokens = g_strsplit(line, ":", 0); if ((g_strv_length(line_tokens) > 6) && (!pkgtools->blacklist || !g_regex_match(pkgtools->blacklist, line_tokens[0], 0, NULL))) { pkg_tokens = katja_pkgtools_cut_pkg(line_tokens[0]); /* If not a collection itself */ if (pkg_tokens[3]) { /* Save this package as a part of the collection */ sqlite3_bind_text(statement, 1, collection_name, -1, SQLITE_TRANSIENT); sqlite3_bind_int(statement, 2, pkgtools->order); sqlite3_bind_text(statement, 3, pkg_tokens[0], -1, SQLITE_TRANSIENT); sqlite3_step(statement); sqlite3_clear_bindings(statement); sqlite3_reset(statement); } g_strfreev(pkg_tokens); } g_strfreev(line_tokens); g_free(line); } sqlite3_finalize(statement); } g_free(collection_name); sqlite3_exec(katja_pkgtools_db, "END TRANSACTION", NULL, NULL, NULL); g_object_unref(data_in); out: sqlite3_finalize(pkglist_statement); sqlite3_finalize(pkglist_collection_statement); if (fin) g_object_unref(fin); }
guint g_vfs_ftp_connection_receive (GVfsFtpConnection *conn, char *** reply, GCancellable * cancellable, GError ** error) { char *line; enum { FIRST_LINE, MULTILINE, DONE } reply_state = FIRST_LINE; GPtrArray *lines; guint response = 0; g_return_val_if_fail (conn != NULL, 0); g_return_val_if_fail (conn->waiting_for_reply, 0); if (reply) lines = g_ptr_array_new_with_free_func (g_free); else lines = NULL; while (reply_state != DONE) { line = g_data_input_stream_read_line (conn->commands_in, NULL, cancellable, error); if (line == NULL) { if (error && *error == NULL) g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_CLOSED, _("Unexpected end of stream")); goto fail; } g_debug ("<-%2d -- %s\r\n", conn->debug_id, line); if (lines) g_ptr_array_add (lines, line); if (reply_state == FIRST_LINE) { if (line[0] <= '0' || line[0] > '5' || line[1] < '0' || line[1] > '9' || line[2] < '0' || line[2] > '9') { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Invalid reply")); goto fail; } response = 100 * (line[0] - '0') + 10 * (line[1] - '0') + (line[2] - '0'); if (line[3] == ' ') reply_state = DONE; else if (line[3] == '-') reply_state = MULTILINE; else { g_set_error_literal (error, G_IO_ERROR, G_IO_ERROR_FAILED, _("Invalid reply")); goto fail; } } else { if (line[0] - '0' == response / 100 && line[1] - '0' == (response / 10) % 10 && line[2] - '0' == response % 10 && line[3] == ' ') reply_state = DONE; } if (!lines) g_free (line); } if (lines) { g_ptr_array_add (lines, NULL); *reply = (char **) g_ptr_array_free (lines, FALSE); } /* 1xx commands are intermediate commands and require a further * message from the server to complete */ if (response >= 200) conn->waiting_for_reply = FALSE; return response; fail: if (lines) g_ptr_array_free (lines, TRUE); else g_free (line); return 0; }
/** * as_distro_details_init: **/ static void as_distro_details_init (AsDistroDetails *distro) { GFile* f = NULL; gchar *line; GError *error = NULL; AsDistroDetailsPrivate *priv = GET_PRIVATE (distro); as_distro_details_set_id (distro, "unknown"); as_distro_details_set_name (distro, ""); as_distro_details_set_version (distro, ""); /* load configuration */ priv->keyf = g_key_file_new (); g_key_file_load_from_file (priv->keyf, AS_CONFIG_NAME, G_KEY_FILE_NONE, NULL); /* get details about the distribution we are running on */ f = g_file_new_for_path ("/etc/os-release"); if (g_file_query_exists (f, NULL)) { GDataInputStream *dis; GFileInputStream *fis; fis = g_file_read (f, NULL, &error); if (error != NULL) goto out; dis = g_data_input_stream_new ((GInputStream*) fis); g_object_unref (fis); while ((line = g_data_input_stream_read_line (dis, NULL, NULL, &error)) != NULL) { gchar **data; gchar *dvalue; if (error != NULL) { g_object_unref (dis); goto out; } data = g_strsplit (line, "=", 2); if (g_strv_length (data) != 2) { g_strfreev (data); g_free (line); continue; } dvalue = data[1]; if (g_str_has_prefix (dvalue, "\"")) { gchar *tmpstr; tmpstr = g_strndup (dvalue + 1, strlen(dvalue) - 2); g_free (dvalue); dvalue = tmpstr; } if (g_strcmp0 (data[0], "ID") == 0) as_distro_details_set_id (distro, dvalue); else if (g_strcmp0 (data[0], "NAME") == 0) as_distro_details_set_name (distro, dvalue); else if (g_strcmp0 (data[0], "VERSION_ID") == 0) as_distro_details_set_version (distro, dvalue); g_free (line); } } out: if (error != NULL) g_error_free (error); g_object_unref (f); }
gint checksum_file_list_parse_checksum_file (CheckcopyFileList * list, GFile *root, GFile *file) { CheckcopyFileListPrivate *priv = GET_PRIVATE (list); GDataInputStream * in; gchar * line; gsize length; GCancellable *cancel; GError * error = NULL; GFile * parent; gchar * prefix; gint n = 0; cancel = checkcopy_get_cancellable (); parent = g_file_get_parent (file); prefix = g_file_get_relative_path (root, parent); in = g_data_input_stream_new (G_INPUT_STREAM (g_file_read (file, cancel, &error))); while ((line = g_data_input_stream_read_line (in, &length, cancel, &error)) != NULL) { gchar *c; if (*line == ';' || *line == '#') { /* skip comment lines */ continue; } /* find the end of the first column */ for (c = line; *c != ' ' && *c != '\0'; c++); /* make sure we found some chars and we don't just have one column */ if (c != line && *c != '\0') { gchar * checksum = NULL; gchar * filename = NULL; CheckcopyFileInfo * info; CheckcopyChecksumType checksum_type; /* found a checksum, parse the line into * checksum and filename */ n++; *c = '\0'; c++; checksum = g_strdup (line); checksum_type = checkcopy_file_info_get_checksum_type (line); /* skip spaces */ while (*c == ' ' && *c != '\0') c++; /* some programs mark filenames with a star */ if (*c == '*') c++; /* rest of the line is the file name */ if (prefix != NULL && *prefix != '\0') filename = g_strconcat (prefix, G_DIR_SEPARATOR_S, c, NULL); else filename = g_strdup (c); info = checkcopy_file_list_grab_info (list, filename); if (info->status == CHECKCOPY_STATUS_NONE) { info->checksum = checksum; info->checksum_type = checksum_type; checkcopy_file_list_transition (list, info, CHECKCOPY_STATUS_VERIFIABLE); DBG ("Parsed checksum for %s", info->relname); if (priv->verify_only) { checkcopy_worker_add_file (g_file_resolve_relative_path (root, filename)); } } else { /* We saw the file before the checksum. * * Verify it now. */ DBG ("%s was copied already, verifying it immediately", filename); if (!g_str_equal (info->checksum, checksum)) { /* Verification failed. We want to display the checksum * the file is supposed to have in the gui, so switch * the two variables. */ gchar * ts; ts = info->checksum; info->checksum = checksum; checksum = ts; /* TODO: display the checksum which the file actually has */ g_free (checksum); checkcopy_file_list_transition (list, info, CHECKCOPY_STATUS_VERIFICATION_FAILED); } } } g_free (line); } g_object_unref (parent); g_free (prefix); g_input_stream_close (G_INPUT_STREAM (in), cancel, &error); return n; }
static gboolean on_incoming_connection(GThreadedSocketService *service, GSocketConnection *connection, GObject *source_object, OwrImageServer *image_server) { GOutputStream *bos; GDataInputStream *dis; gchar *error_body, *error_header = NULL, *response_header = NULL; gchar *line, *tag; gsize line_length, i; guint content_length = 0; OwrImageRenderer *image_renderer; GBytes *image; gconstpointer image_data; gsize image_data_size = 0; OWR_UNUSED(service); OWR_UNUSED(source_object); g_return_val_if_fail(OWR_IS_IMAGE_SERVER(image_server), TRUE); bos = g_buffered_output_stream_new(g_io_stream_get_output_stream(G_IO_STREAM(connection))); dis = g_data_input_stream_new(g_io_stream_get_input_stream(G_IO_STREAM(connection))); g_data_input_stream_set_newline_type(dis, G_DATA_STREAM_NEWLINE_TYPE_CR_LF); error_body = "404 Not Found"; error_header = g_strdup_printf(HTTP_RESPONSE_HEADER_TEMPLATE, 404, "Not Found", "text/plain", (guint)strlen(error_body)); while (TRUE) { line = g_data_input_stream_read_line(dis, &line_length, NULL, NULL); if (!line) break; if (line_length > 6) { tag = g_strdup(line + 7); for (i = 0; i < strlen(tag); i++) { if (tag[i] == '-') { tag[i] = '\0'; break; } } } else tag = NULL; g_free(line); while ((line = g_data_input_stream_read_line(dis, &line_length, NULL, NULL))) { g_free(line); if (!line_length) { /* got all request headers */ break; } } if (!line) break; g_mutex_lock(&image_server->priv->image_renderers_mutex); image_renderer = tag ? g_hash_table_lookup(image_server->priv->image_renderers, tag) : NULL; g_mutex_unlock(&image_server->priv->image_renderers_mutex); image = image_renderer ? _owr_image_renderer_pull_bmp_image(image_renderer) : NULL; if (!image) { g_output_stream_write(bos, error_header, strlen(error_header), NULL, NULL); g_output_stream_write(bos, error_body, strlen(error_body), NULL, NULL); break; } image_data = g_bytes_get_data(image, &image_data_size); if (content_length != image_data_size) { content_length = image_data_size; g_free(response_header); response_header = g_strdup_printf(HTTP_RESPONSE_HEADER_TEMPLATE, 200, "OK", "image/bmp", content_length); g_buffered_output_stream_set_buffer_size(G_BUFFERED_OUTPUT_STREAM(bos), strlen(response_header) + content_length); } g_output_stream_write(bos, response_header, strlen(response_header), NULL, NULL); g_output_stream_write(bos, image_data, image_data_size, NULL, NULL); g_output_stream_flush(bos, NULL, NULL); g_bytes_unref(image); } g_free(response_header); g_free(error_header); g_object_unref(dis); g_object_unref(bos); return FALSE; }
static void web_handler (ShpHttpRequest request, const gchar * path, const gchar * query, GSocketConnection * connection, gpointer user_data) { ShpRest *self = SHP_REST (user_data); GFile *file; GFileInputStream *input_stream; GDataInputStream *data; GError *error = NULL; GOutputStream *out; gchar *line; ShpJsonNode *node; out = g_io_stream_get_output_stream (G_IO_STREAM (connection)); if (request != SHP_HTTP_GET) { g_debug ("rest: unsupported request type"); send_error (out, 400, "Invalid request"); return; } if (self->config_file == NULL) { g_warning ("rest: config file not specified"); send_error (out, 500, "Internal server error"); return; } /* FIXME: load file at start */ file = g_file_new_for_path (self->config_file); input_stream = g_file_read (file, NULL, &error); if (!input_stream) { g_warning ("rest: error reading config file: %s", error->message); g_clear_error (&error); send_error (out, 500, "Internal server error"); return; } data = g_data_input_stream_new (G_INPUT_STREAM (input_stream)); node = shp_json_node_new_object (NULL); while (TRUE) { guint i; gchar **options_list; ShpJsonNode *obj = NULL; ShpJsonNode *arr = NULL; //plugin:device-type:type1,option1:type2,option2 line = g_data_input_stream_read_line (data, NULL, NULL, NULL); if (!line) break; g_debug ("rest: config file line: %s", line); options_list = g_strsplit (line, ":", 0); for (i = 0; options_list[i] != NULL; i++) { ShpJsonNode *child; ShpJsonNode *grand_child; gchar **params; switch (i) { case 0: obj = shp_json_node_new_object (options_list[i]); break; case 1: child = shp_json_node_new_string ("device-type", options_list[i]); shp_json_node_append_element (obj, child); break; case 2: arr = shp_json_node_new_array ("display-options"); /* fall trhough */ default: params = g_strsplit (options_list[i], " ", 0); if (params && params[0] && params[1] && !params[2]) { child = shp_json_node_new_object (NULL); grand_child = shp_json_node_new_string ("option", params[0]); shp_json_node_append_element (child, grand_child); grand_child = shp_json_node_new_string ("type", params[1]); shp_json_node_append_element (child, grand_child); shp_json_node_append_element (arr, child); } g_strfreev (params); break; } } g_strfreev (options_list); if (obj != NULL) { if (arr != NULL) shp_json_node_append_element (obj, arr); shp_json_node_append_element (node, obj); } g_free (line); } g_object_unref (input_stream); g_object_unref (file); send_ok (out, node); shp_json_node_free (node); }
gboolean rejilla_image_format_get_cdrdao_size (gchar *uri, guint64 *sectors, guint64 *size_img, GCancellable *cancel, GError **error) { GFile *file; gchar *line; GFile *parent; gint64 cue_size = 0; GFileInputStream *input; GDataInputStream *stream; file = g_file_new_for_uri (uri); input = g_file_read (file, cancel, error); if (!input) { g_object_unref (file); return FALSE; } stream = g_data_input_stream_new (G_INPUT_STREAM (input)); g_object_unref (input); parent = g_file_get_parent (file); while ((line = g_data_input_stream_read_line (stream, NULL, cancel, error))) { gchar *ptr; if ((ptr = strstr (line, "DATAFILE"))) { gint64 size_file; ptr += 8; if (rejilla_image_format_get_DATAFILE_info (ptr, parent, &size_file, error)) cue_size += size_file; } else if ((ptr = strstr (line, "FILE"))) { gint64 size_file; ptr += 4; /* first number is the position, the second the size, * number after '#' is the offset (in bytes). */ if (rejilla_image_format_get_FILE_info (ptr, parent, &size_file, error)) cue_size += size_file; } else if ((ptr = strstr (line, "AUDIOFILE"))) { gint64 size_file; ptr += 4; /* first number is the position, the second the size, * number after '#' is the offset (in bytes). */ if (rejilla_image_format_get_FILE_info (ptr, parent, &size_file, error)) cue_size += size_file; } else if ((ptr = strstr (line, "SILENCE"))) { gint64 size_silence; ptr += 7; if (isspace (*ptr) && rejilla_image_format_get_MSF_address (ptr, &size_silence)) cue_size += size_silence; } else if ((ptr = strstr (line, "PREGAP"))) { gint64 size_pregap; ptr += 6; if (isspace (*ptr) && rejilla_image_format_get_MSF_address (ptr, &size_pregap)) cue_size += size_pregap; } else if ((ptr = strstr (line, "ZERO"))) { gint64 size_zero; ptr += 4; if (isspace (*ptr) && rejilla_image_format_get_MSF_address (ptr, &size_zero)) cue_size += size_zero; } g_free (line); } g_object_unref (parent); g_object_unref (stream); g_object_unref (file); if (sectors) *sectors = cue_size; if (size_img) *size_img = cue_size * 2352; return TRUE; }
static gboolean spawn_x_server (State *state, gboolean allow_remote_connections, GCancellable *cancellable) { GPtrArray *arguments = NULL; GSubprocessLauncher *launcher = NULL; GSubprocess *subprocess = NULL; GInputStream *input_stream = NULL; GDataInputStream *data_stream = NULL; GError *error = NULL; char *auth_file; gboolean is_running = FALSE; int ret; int pipe_fds[2]; char *display_fd_string = NULL; char *vt_string = NULL; char *display_number; gsize display_number_size; auth_file = prepare_auth_file (); g_debug ("Running X server"); ret = g_unix_open_pipe (pipe_fds, FD_CLOEXEC, &error); if (!ret) { g_debug ("could not open pipe: %s", error->message); goto out; } arguments = g_ptr_array_new (); launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_STDIN_INHERIT); g_subprocess_launcher_setenv (launcher, "XORG_RUN_AS_USER_OK", "1", TRUE); g_subprocess_launcher_take_fd (launcher, pipe_fds[1], DISPLAY_FILENO); if (g_getenv ("XDG_VTNR") != NULL) { int vt; vt = atoi (g_getenv ("XDG_VTNR")); if (vt > 0 && vt < 64) { vt_string = g_strdup_printf ("vt%d", vt); } } display_fd_string = g_strdup_printf ("%d", DISPLAY_FILENO); g_ptr_array_add (arguments, X_SERVER); if (vt_string != NULL) { g_ptr_array_add (arguments, vt_string); } g_ptr_array_add (arguments, "-displayfd"); g_ptr_array_add (arguments, display_fd_string); g_ptr_array_add (arguments, "-auth"); g_ptr_array_add (arguments, auth_file); /* If we were compiled with Xserver >= 1.17 we need to specify * '-listen tcp' as the X server dosen't listen on tcp sockets * by default anymore. In older versions we need to pass * -nolisten tcp to disable listening on tcp sockets. */ #ifdef HAVE_XSERVER_THAT_DEFAULTS_TO_LOCAL_ONLY if (allow_remote_connections) { g_ptr_array_add (arguments, "-listen"); g_ptr_array_add (arguments, "tcp"); } #else if (!allow_remote_connections) { g_ptr_array_add (arguments, "-nolisten"); g_ptr_array_add (arguments, "tcp"); } #endif g_ptr_array_add (arguments, "-background"); g_ptr_array_add (arguments, "none"); g_ptr_array_add (arguments, "-noreset"); g_ptr_array_add (arguments, "-keeptty"); g_ptr_array_add (arguments, "-verbose"); if (state->debug_enabled) { g_ptr_array_add (arguments, "7"); } else { g_ptr_array_add (arguments, "3"); } if (state->debug_enabled) { g_ptr_array_add (arguments, "-core"); } g_ptr_array_add (arguments, NULL); subprocess = g_subprocess_launcher_spawnv (launcher, (const char * const *) arguments->pdata, &error); g_free (display_fd_string); g_clear_object (&launcher); g_ptr_array_free (arguments, TRUE); if (subprocess == NULL) { g_debug ("could not start X server: %s", error->message); goto out; } input_stream = g_unix_input_stream_new (pipe_fds[0], TRUE); data_stream = g_data_input_stream_new (input_stream); g_clear_object (&input_stream); display_number = g_data_input_stream_read_line (data_stream, &display_number_size, cancellable, &error); if (error != NULL) { g_debug ("could not read display string from X server: %s", error->message); goto out; } if (display_number == NULL) { g_debug ("X server did not write display string"); goto out; } state->display_name = g_strdup_printf (":%s", display_number); g_clear_pointer (&display_number, g_free); state->auth_file = g_strdup (auth_file); state->x_subprocess = g_object_ref (subprocess); g_subprocess_wait_async (state->x_subprocess, cancellable, (GAsyncReadyCallback) on_x_server_finished, state); is_running = TRUE; out: g_clear_pointer (&auth_file, g_free); g_clear_object (&data_stream); g_clear_object (&subprocess); g_clear_object (&launcher); g_clear_error (&error); return is_running; }
gboolean rejilla_image_format_get_cue_size (gchar *uri, guint64 *blocks, guint64 *size_img, GCancellable *cancel, GError **error) { GFile *file; gchar *line; gint64 cue_size = 0; GFileInputStream *input; GDataInputStream *stream; file = g_file_new_for_uri (uri); input = g_file_read (file, cancel, error); if (!input) { g_object_unref (file); return FALSE; } stream = g_data_input_stream_new (G_INPUT_STREAM (input)); g_object_unref (input); while ((line = g_data_input_stream_read_line (stream, NULL, cancel, error))) { const gchar *ptr; if ((ptr = strstr (line, "FILE"))) { GFileInfo *info; gchar *file_path; GFile *file_img = NULL; ptr += 4; /* get the path (NOTE: if ptr is NULL file_path as well) */ ptr = rejilla_image_format_read_path (ptr, &file_path); if (!ptr) { g_object_unref (stream); g_object_unref (file); g_free (line); return FALSE; } /* check if the path is relative, if so then add the root path */ if (file_path && !g_path_is_absolute (file_path)) { GFile *parent; parent = g_file_get_parent (file); file_img = g_file_resolve_relative_path (parent, file_path); g_object_unref (parent); } else if (file_path) { gchar *img_uri; gchar *scheme; scheme = g_file_get_uri_scheme (file); img_uri = g_strconcat (scheme, "://", file_path, NULL); g_free (scheme); file_img = g_file_new_for_commandline_arg (img_uri); g_free (img_uri); } g_free (file_path); /* NOTE: follow symlink if any */ info = g_file_query_info (file_img, G_FILE_ATTRIBUTE_STANDARD_SIZE, G_FILE_QUERY_INFO_NONE, NULL, error); g_object_unref (file_img); if (!info) { g_free (line); g_object_unref (file); g_object_unref (stream); return FALSE; } cue_size += g_file_info_get_size (info); g_object_unref (info); } else if ((ptr = strstr (line, "PREGAP"))) { ptr += 6; if (isspace (*ptr)) { gint64 size_pregap; ptr ++; ptr = rejilla_image_format_get_MSF_address (ptr, &size_pregap); if (ptr) cue_size += size_pregap * 2352; } } else if ((ptr = strstr (line, "POSTGAP"))) { ptr += 7; if (isspace (*ptr)) { gint64 size_postgap; ptr ++; ptr = rejilla_image_format_get_MSF_address (ptr, &size_postgap); if (ptr) cue_size += size_postgap * 2352; } } g_free (line); } g_object_unref (stream); g_object_unref (file); if (size_img) *size_img = cue_size; if (blocks) *blocks = REJILLA_BYTES_TO_SECTORS (cue_size, 2352); return TRUE; }
static gboolean spawn_bus (State *state, GCancellable *cancellable) { GPtrArray *arguments = NULL; GSubprocessLauncher *launcher = NULL; GSubprocess *subprocess = NULL; GInputStream *input_stream = NULL; GDataInputStream *data_stream = NULL; GError *error = NULL; const char *bus_env = NULL; char *bus_address_fd_string; char *bus_address = NULL; gsize bus_address_size; gboolean is_running = FALSE; int ret; int pipe_fds[2]; g_debug ("Running session message bus"); bus_env = g_getenv ("DBUS_SESSION_BUS_ADDRESS"); if (bus_env != NULL) { g_debug ("session message bus already running, not starting another one"); state->bus_address = g_strdup (bus_env); return TRUE; } ret = g_unix_open_pipe (pipe_fds, FD_CLOEXEC, &error); if (!ret) { g_debug ("could not open pipe: %s", error->message); goto out; } arguments = g_ptr_array_new (); launcher = g_subprocess_launcher_new (G_SUBPROCESS_FLAGS_NONE); g_subprocess_launcher_setenv (launcher, "DISPLAY", state->display_name, TRUE); g_subprocess_launcher_setenv (launcher, "XAUTHORITY", state->auth_file, TRUE); g_subprocess_launcher_take_fd (launcher, pipe_fds[1], BUS_ADDRESS_FILENO); bus_address_fd_string = g_strdup_printf ("%d", BUS_ADDRESS_FILENO); g_ptr_array_add (arguments, "dbus-daemon"); g_ptr_array_add (arguments, "--print-address"); g_ptr_array_add (arguments, bus_address_fd_string); g_ptr_array_add (arguments, "--session"); g_ptr_array_add (arguments, NULL); subprocess = g_subprocess_launcher_spawnv (launcher, (const char * const *) arguments->pdata, &error); g_free (bus_address_fd_string); g_clear_object (&launcher); g_ptr_array_free (arguments, TRUE); if (subprocess == NULL) { g_debug ("could not start dbus-daemon: %s", error->message); goto out; } input_stream = g_unix_input_stream_new (pipe_fds[0], TRUE); data_stream = g_data_input_stream_new (input_stream); g_clear_object (&input_stream); bus_address = g_data_input_stream_read_line (data_stream, &bus_address_size, cancellable, &error); if (error != NULL) { g_debug ("could not read address from session message bus: %s", error->message); goto out; } if (bus_address == NULL) { g_debug ("session message bus did not write address"); goto out; } state->bus_address = bus_address; state->bus_subprocess = g_object_ref (subprocess); g_subprocess_wait_async (state->bus_subprocess, cancellable, (GAsyncReadyCallback) on_bus_finished, state); is_running = TRUE; out: g_clear_object (&data_stream); g_clear_object (&subprocess); g_clear_object (&launcher); g_clear_error (&error); return is_running; }
gboolean rclib_lyric_load_file(const gchar *filename, guint index) { RCLibLyricParsedData *parsed_data; gchar *line; GFile *file; GFileInputStream *input_stream; GDataInputStream *data_stream; gsize line_len; gint64 time = -1; RCLibLyricPrivate *priv; GSequenceIter *iter; RCLibLyricData *lyric_data; rclib_lyric_clean(index); if(lyric_instance==NULL) return FALSE; if(filename==NULL) return FALSE; priv = RCLIB_LYRIC(lyric_instance)->priv; if(priv==NULL) return FALSE; file = g_file_new_for_path(filename); if(file==NULL) return FALSE; if(!g_file_query_exists(file, NULL)) { g_object_unref(file); return FALSE; } input_stream = g_file_read(file, NULL, NULL); g_object_unref(file); if(input_stream==NULL) return FALSE; data_stream = g_data_input_stream_new(G_INPUT_STREAM(input_stream)); g_object_unref(input_stream); if(data_stream==NULL) return FALSE; g_data_input_stream_set_newline_type(data_stream, G_DATA_STREAM_NEWLINE_TYPE_ANY); if(index==1) parsed_data = &(priv->parsed_data2); else parsed_data = &(priv->parsed_data1); if(index!=1) index = 0; while((line=g_data_input_stream_read_line(data_stream, &line_len, NULL, NULL))!=NULL) { rclib_lyric_add_line(parsed_data, priv->regex, priv->encoding, line, line_len); g_free(line); } g_object_unref(data_stream); for(iter = g_sequence_get_end_iter(parsed_data->seq); !g_sequence_iter_is_begin(iter);) { iter = g_sequence_iter_prev(iter); lyric_data = g_sequence_get(iter); if(lyric_data==NULL) continue; if(time>=0) { lyric_data->length = time - lyric_data->time; } time = lyric_data->time; } parsed_data->filename = g_strdup(filename); g_signal_emit(lyric_instance, lyric_signals[SIGNAL_LYRIC_READY], 0, index); return TRUE; }
GList * gimp_palette_load (GimpContext *context, GFile *file, GInputStream *input, GError **error) { GimpPalette *palette = NULL; GimpPaletteEntry *entry; GDataInputStream *data_input; gchar *str; gsize str_len; gchar *tok; gint r, g, b; gint linenum; g_return_val_if_fail (G_IS_FILE (file), NULL); g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); data_input = g_data_input_stream_new (input); r = g = b = 0; linenum = 1; str_len = 1024; str = gimp_data_input_stream_read_line_always (data_input, &str_len, NULL, error); if (! str) goto failed; if (! g_str_has_prefix (str, "GIMP Palette")) { g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ, _("Missing magic header.")); g_free (str); goto failed; } g_free (str); palette = g_object_new (GIMP_TYPE_PALETTE, "mime-type", "application/x-gimp-palette", NULL); linenum++; str_len = 1024; str = gimp_data_input_stream_read_line_always (data_input, &str_len, NULL, error); if (! str) goto failed; if (g_str_has_prefix (str, "Name: ")) { gchar *utf8; utf8 = gimp_any_to_utf8 (g_strstrip (str + strlen ("Name: ")), -1, _("Invalid UTF-8 string in palette file '%s'"), gimp_file_get_utf8_name (file)); gimp_object_take_name (GIMP_OBJECT (palette), utf8); g_free (str); linenum++; str_len = 1024; str = gimp_data_input_stream_read_line_always (data_input, &str_len, NULL, error); if (! str) goto failed; if (g_str_has_prefix (str, "Columns: ")) { gint columns; if (! gimp_ascii_strtoi (g_strstrip (str + strlen ("Columns: ")), NULL, 10, &columns)) { g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ, _("Invalid column count.")); g_free (str); goto failed; } if (columns < 0 || columns > 256) { g_message (_("Reading palette file '%s': " "Invalid number of columns in line %d. " "Using default value."), gimp_file_get_utf8_name (file), linenum); columns = 0; } gimp_palette_set_columns (palette, columns); g_free (str); linenum++; str_len = 1024; str = gimp_data_input_stream_read_line_always (data_input, &str_len, NULL, error); if (! str) goto failed; } } else /* old palette format */ { gimp_object_take_name (GIMP_OBJECT (palette), g_path_get_basename (gimp_file_get_utf8_name (file))); } while (str) { GError *my_error = NULL; if (str[0] != '#' && str[0] != '\0') { tok = strtok (str, " \t"); if (tok) r = atoi (tok); else g_message (_("Reading palette file '%s': " "Missing RED component in line %d."), gimp_file_get_utf8_name (file), linenum); tok = strtok (NULL, " \t"); if (tok) g = atoi (tok); else g_message (_("Reading palette file '%s': " "Missing GREEN component in line %d."), gimp_file_get_utf8_name (file), linenum); tok = strtok (NULL, " \t"); if (tok) b = atoi (tok); else g_message (_("Reading palette file '%s': " "Missing BLUE component in line %d."), gimp_file_get_utf8_name (file), linenum); /* optional name */ tok = strtok (NULL, "\n"); if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) g_message (_("Reading palette file '%s': " "RGB value out of range in line %d."), gimp_file_get_utf8_name (file), linenum); /* don't call gimp_palette_add_entry here, it's rather inefficient */ entry = g_slice_new0 (GimpPaletteEntry); gimp_rgba_set_uchar (&entry->color, (guchar) r, (guchar) g, (guchar) b, 255); entry->name = g_strdup (tok ? tok : _("Untitled")); entry->position = gimp_palette_get_n_colors (palette); palette->colors = g_list_prepend (palette->colors, entry); palette->n_colors++; } g_free (str); linenum++; str_len = 1024; str = g_data_input_stream_read_line (data_input, &str_len, NULL, &my_error); if (! str && my_error) { g_message (_("Reading palette file '%s': " "Read %d colors from truncated file: %s"), gimp_file_get_utf8_name (file), g_list_length (palette->colors), my_error->message); g_clear_error (&my_error); } } palette->colors = g_list_reverse (palette->colors); g_object_unref (data_input); return g_list_prepend (NULL, palette); failed: g_object_unref (data_input); if (palette) g_object_unref (palette); g_prefix_error (error, _("In line %d of palette file: "), linenum); return NULL; }
GList * gimp_brush_generated_load (GimpContext *context, GFile *file, GInputStream *input, GError **error) { GimpBrush *brush; GDataInputStream *data_input; gchar *string; gsize string_len; gint linenum; gchar *name = NULL; GimpBrushGeneratedShape shape = GIMP_BRUSH_GENERATED_CIRCLE; gboolean have_shape = FALSE; gint spikes = 2; gdouble spacing; gdouble radius; gdouble hardness; gdouble aspect_ratio; gdouble angle; g_return_val_if_fail (G_IS_FILE (file), NULL); g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); data_input = g_data_input_stream_new (input); /* make sure the file we are reading is the right type */ linenum = 1; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; if (! g_str_has_prefix (string, "GIMP-VBR")) { g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ, _("Not a GIMP brush file.")); g_free (string); goto failed; } g_free (string); /* make sure we are reading a compatible version */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; if (! g_str_has_prefix (string, "1.0")) { if (! g_str_has_prefix (string, "1.5")) { g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ, _("Unknown GIMP brush version.")); g_free (string); goto failed; } else { have_shape = TRUE; } } g_free (string); /* read name */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; g_strstrip (string); /* the empty string is not an allowed name */ if (strlen (string) < 1) { name = g_strdup (_("Untitled")); } else { name = gimp_any_to_utf8 (string, -1, _("Invalid UTF-8 string in brush file '%s'."), gimp_file_get_utf8_name (file)); } g_free (string); if (have_shape) { GEnumClass *enum_class; GEnumValue *shape_val; enum_class = g_type_class_peek (GIMP_TYPE_BRUSH_GENERATED_SHAPE); /* read shape */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; g_strstrip (string); shape_val = g_enum_get_value_by_nick (enum_class, string); if (! shape_val) { g_set_error (error, GIMP_DATA_ERROR, GIMP_DATA_ERROR_READ, _("Unknown GIMP brush shape.")); g_free (string); goto failed; } g_free (string); shape = shape_val->value; } /* read brush spacing */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; spacing = g_ascii_strtod (string, NULL); g_free (string); /* read brush radius */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; radius = g_ascii_strtod (string, NULL); g_free (string); if (have_shape) { /* read number of spikes */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; spikes = CLAMP (atoi (string), 2, 20); g_free (string); } /* read brush hardness */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; hardness = g_ascii_strtod (string, NULL); g_free (string); /* read brush aspect_ratio */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; aspect_ratio = g_ascii_strtod (string, NULL); g_free (string); /* read brush angle */ linenum++; string_len = 256; string = g_data_input_stream_read_line (data_input, &string_len, NULL, error); if (! string) goto failed; angle = g_ascii_strtod (string, NULL); g_free (string); g_object_unref (data_input); brush = GIMP_BRUSH (gimp_brush_generated_new (name, shape, radius, spikes, hardness, aspect_ratio, angle)); g_free (name); gimp_brush_set_spacing (brush, spacing); return g_list_prepend (NULL, brush); failed: g_object_unref (data_input); if (name) g_free (name); g_prefix_error (error, _("In line %d of brush file: "), linenum); return NULL; }
GList * gimp_palette_load_css (GimpContext *context, GFile *file, GInputStream *input, GError **error) { GimpPalette *palette; GDataInputStream *data_input; gchar *name; GRegex *regex; gchar *buf; g_return_val_if_fail (G_IS_FILE (file), NULL); g_return_val_if_fail (G_IS_INPUT_STREAM (input), NULL); g_return_val_if_fail (error == NULL || *error == NULL, NULL); regex = g_regex_new (".*color.*:(?P<param>.*);", G_REGEX_CASELESS, 0, error); if (! regex) return NULL; name = g_path_get_basename (gimp_file_get_utf8_name (file)); palette = GIMP_PALETTE (gimp_palette_new (context, name)); g_free (name); data_input = g_data_input_stream_new (input); do { gsize buf_len = 1024; buf = g_data_input_stream_read_line (data_input, &buf_len, NULL, NULL); if (buf) { GMatchInfo *matches; if (g_regex_match (regex, buf, 0, &matches)) { GimpRGB color; gchar *word = g_match_info_fetch_named (matches, "param"); if (gimp_rgb_parse_css (&color, word, -1)) { if (! gimp_palette_find_entry (palette, &color, NULL)) { gimp_palette_add_entry (palette, -1, NULL, &color); } } g_free (word); } g_match_info_free (matches); g_free (buf); } } while (buf); g_regex_unref (regex); g_object_unref (data_input); return g_list_prepend (NULL, palette); }
gboolean gimp_levels_config_load_cruft (GimpLevelsConfig *config, GInputStream *input, GError **error) { GDataInputStream *data_input; gint low_input[5]; gint high_input[5]; gint low_output[5]; gint high_output[5]; gdouble gamma[5]; gchar *line; gsize line_len; gint i; g_return_val_if_fail (GIMP_IS_LEVELS_CONFIG (config), FALSE); g_return_val_if_fail (G_IS_INPUT_STREAM (input), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); data_input = g_data_input_stream_new (input); line_len = 64; line = g_data_input_stream_read_line (data_input, &line_len, NULL, error); if (! line) return FALSE; if (strcmp (line, "# GIMP Levels File") != 0) { g_set_error_literal (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_PARSE, _("not a GIMP Levels file")); g_object_unref (data_input); g_free (line); return FALSE; } g_free (line); for (i = 0; i < 5; i++) { gchar float_buf[32]; gchar *endp; gint fields; line_len = 64; line = g_data_input_stream_read_line (data_input, &line_len, NULL, error); if (! line) { g_object_unref (data_input); return FALSE; } fields = sscanf (line, "%d %d %d %d %31s", &low_input[i], &high_input[i], &low_output[i], &high_output[i], float_buf); g_free (line); if (fields != 5) goto error; gamma[i] = g_ascii_strtod (float_buf, &endp); if (endp == float_buf || errno == ERANGE) goto error; } g_object_unref (data_input); g_object_freeze_notify (G_OBJECT (config)); for (i = 0; i < 5; i++) { config->low_input[i] = low_input[i] / 255.0; config->high_input[i] = high_input[i] / 255.0; config->low_output[i] = low_output[i] / 255.0; config->high_output[i] = high_output[i] / 255.0; config->gamma[i] = gamma[i]; } g_object_notify (G_OBJECT (config), "gamma"); g_object_notify (G_OBJECT (config), "low-input"); g_object_notify (G_OBJECT (config), "high-input"); g_object_notify (G_OBJECT (config), "low-output"); g_object_notify (G_OBJECT (config), "high-output"); g_object_thaw_notify (G_OBJECT (config)); return TRUE; error: g_object_unref (data_input); g_set_error_literal (error, GIMP_CONFIG_ERROR, GIMP_CONFIG_ERROR_PARSE, _("parse error")); return FALSE; }
static gboolean pk_backend_config_parse (PkBackendConfig *config, const gchar *filename, PkBackendConfigSection *section, GError **error) { GFile *file; GFileInputStream *is; GDataInputStream *input; gchar *key, *str, *line = NULL; guint num = 1; GError *e = NULL; g_return_val_if_fail (config != NULL, FALSE); g_return_val_if_fail (filename != NULL, FALSE); file = g_file_new_for_path (filename); is = g_file_read (file, NULL, &e); if (is == NULL) { g_propagate_error (error, e); g_object_unref (file); return FALSE; } input = g_data_input_stream_new (G_INPUT_STREAM (is)); for (;; g_free (line), ++num) { line = g_data_input_stream_read_line (input, NULL, NULL, &e); if (line != NULL) { g_strstrip (line); } else { break; } /* skip empty lines */ if (*line == '\0' || *line == '#') { continue; } /* remove trailing comments */ for (str = line; *str != '\0' && *str != '#'; ++str); *str-- = '\0'; /* change sections */ if (*line == '[' && *str == ']') { *str = '\0'; str = line + 1; if (*str == '\0') { g_set_error (&e, ALPM_ERROR, ALPM_ERR_CONFIG_INVALID, "empty section name"); break; } section = pk_backend_config_enter_section (config, str); continue; } /* parse a directive */ if (section == NULL) { g_set_error (&e, ALPM_ERROR, ALPM_ERR_CONFIG_INVALID, "directive must belong to a section"); break; } str = line; key = strsep (&str, "="); g_strchomp (key); if (str != NULL) { g_strchug (str); } if (str == NULL) { /* set a boolean directive */ if (pk_backend_config_section_match (section, "options") == 0 && pk_backend_config_set_boolean (config, key)) { continue; } /* report error below */ } else if (g_strcmp0 (key, "Include") == 0) { gsize i; glob_t match = { 0 }; /* ignore globbing errors */ if (glob (str, GLOB_NOCHECK, NULL, &match) != 0) { continue; } /* parse the files that matched */ for (i = 0; i < match.gl_pathc; ++i) { if (!pk_backend_config_parse (config, match.gl_pathv[i], section, &e)) { break; } } globfree (&match); if (e != NULL) { break; } else { continue; } } else if (pk_backend_config_section_match (section, "options") == 0) { /* set a string or list directive */ if (pk_backend_config_set_string (config, key, str) || pk_backend_config_set_list (config, key, str)) { continue; } /* report error below */ } else if (g_strcmp0 (key, "Server") == 0) { if (!pk_backend_config_add_server (config, section, str, &e)) { break; } else { continue; } } if (g_strcmp0 (key, "SigLevel") == 0 && str != NULL) { pk_backend_config_add_siglevel (config, section, str); continue; } /* report errors from above */ g_set_error (&e, ALPM_ERROR, ALPM_ERR_CONFIG_INVALID, "unrecognised directive '%s'", key); break; } g_object_unref (input); g_object_unref (is); g_object_unref (file); if (e != NULL) { g_propagate_prefixed_error (error, e, "%s:%u", filename, num); return FALSE; } else { return TRUE; } }