/* Returns: TRUE if FileRow value has been changed */ static gboolean update_file_size (FileRow *row, const gchar *complete_filename) { struct stat filestat; gboolean changed = TRUE; if (! g_stat (complete_filename, &filestat)) { if (row->size_value && (G_VALUE_TYPE (row->size_value) == G_TYPE_UINT) && (g_value_get_uint (row->size_value) == (guint)filestat.st_size)) changed = FALSE; else { if (row->size_value) gda_value_free (row->size_value); g_value_set_uint (row->size_value = gda_value_new (G_TYPE_UINT), filestat.st_size); } } else { if (row->size_value && gda_value_is_null (row->size_value)) changed = FALSE; else { if (row->size_value) gda_value_free (row->size_value); row->size_value = gda_value_new_null (); } } return changed; }
static void real_set_value (GdauiEntryWrapper *mgwrap, const GValue *value) { GdauiEntryString *mgstr; GdaDataHandler *dh; PangoLayout *layout; gchar *text; g_return_if_fail (GDAUI_IS_ENTRY_STRING (mgwrap)); mgstr = GDAUI_ENTRY_STRING (mgwrap); GdauiEntryStringPrivate *priv = gdaui_entry_string_get_instance_private (mgstr); dh = gdaui_data_entry_get_handler (GDAUI_DATA_ENTRY (mgwrap)); /* do we need to go into multi line mode ? */ text = gda_data_handler_get_str_from_value (dh, value); layout = gtk_widget_create_pango_layout (GTK_WIDGET (mgwrap), text); if (pango_layout_get_line_count (layout) > 1) g_object_set (G_OBJECT (mgwrap), "multiline", TRUE, NULL); g_object_unref (G_OBJECT (layout)); /* fill the single line widget */ if (value) { if (gda_value_is_null ((GValue *) value)) gdaui_entry_set_text (GDAUI_ENTRY (priv->entry), NULL); else gdaui_entry_set_text (GDAUI_ENTRY (priv->entry), text); } else gdaui_entry_set_text (GDAUI_ENTRY (priv->entry), NULL); /* fill the multiline widget */ if (value) { if (gda_value_is_null ((GValue *) value) || !text) gtk_text_buffer_set_text (priv->buffer, "", -1); else gtk_text_buffer_set_text (priv->buffer, text, -1); } else gtk_text_buffer_set_text (priv->buffer, "", -1); g_free (text); }
/* * assign_parameters_values * * Tries to assign a value for each parameter in @plist, from the context * * Returns: TRUE on success */ static gboolean assign_parameters_values (GdaReportEngine *engine, RunContext *context, GdaSet *plist, GError **error) { if (plist) { GSList *list; for (list = plist->holders; list; list = list->next) { GdaHolder *source_param; source_param = run_context_find_param (engine, context, BAD_CAST gda_holder_get_id (GDA_HOLDER (list->data))); if (!source_param) { g_set_error (error, 0, 0, _("Unknown parameter '%s'"), gda_holder_get_id (GDA_HOLDER (list->data))); return FALSE; } gda_holder_set_not_null (GDA_HOLDER (list->data), FALSE); GType ptype, source_ptype; ptype = gda_holder_get_g_type (GDA_HOLDER (list->data)); source_ptype = gda_holder_get_g_type (source_param); if (ptype == source_ptype) { if (! gda_holder_set_bind (GDA_HOLDER (list->data), source_param, error)) return FALSE; } else { const GValue *source_value; source_value = gda_holder_get_value (source_param); if (source_value && !gda_value_is_null (source_value)) { GValue *trans; trans = gda_value_new (ptype); if (g_value_transform (source_value, trans)) { if (! gda_holder_set_value (GDA_HOLDER (list->data), trans, error)) { gda_value_free (trans); return FALSE; } gda_value_free (trans); } else { gda_value_free (trans); g_set_error (error, 0, 0, _("Cannot cast parameter from type '%s' to type '%s'"), g_type_name (source_ptype), g_type_name (ptype)); return FALSE; } } else if (! gda_holder_set_value (GDA_HOLDER (list->data), NULL, error)) return FALSE; } } } return TRUE; }
static gchar * params_to_string (GdauiProviderAuthEditor *auth) { GString *string = NULL; gchar *str; GdaSet *dset; GSList *list; g_assert (auth->priv->auth_widget); if (! GDAUI_IS_BASIC_FORM (auth->priv->auth_widget)) return NULL; dset = gdaui_basic_form_get_data_set (GDAUI_BASIC_FORM (auth->priv->auth_widget)); for (list = dset->holders; list; list = list->next) { GdaHolder *param = GDA_HOLDER (list->data); if (gda_holder_is_valid (param)) { const GValue *value; value = gda_holder_get_value (param); str = NULL; if (value && !gda_value_is_null ((GValue *) value)) { GdaDataHandler *dh; GType dtype; dtype = gda_holder_get_g_type (param); dh = gda_data_handler_get_default (dtype); str = gda_data_handler_get_str_from_value (dh, value); } if (str && *str) { gchar *name; gchar *ename, *evalue; if (!string) string = g_string_new (""); else g_string_append_c (string, ';'); g_object_get (G_OBJECT (list->data), "id", &name, NULL); ename = gda_rfc1738_encode (name); evalue = gda_rfc1738_encode (str); g_string_append_printf (string, "%s=%s", ename, evalue); g_free (ename); g_free (evalue); } g_free (str); } } str = string ? string->str : NULL; if (string) g_string_free (string, FALSE); return str; }
/** * gda_data_handler_get_str_from_value: * @dh: an object which implements the #GdaDataHandler interface * @value: (allow-none): the value to be converted to a string, or %NULL * * Creates a new string which is a "user friendly" representation of the given value * (in the user's locale, specially for the dates). If the value is * NULL or is of type GDA_TYPE_NULL, the returned string is a copy of "" (empty string). * * Note: the returned value will be in the current locale representation. * * Returns: (transfer full): the new string, or %NULL if an error occurred */ gchar * gda_data_handler_get_str_from_value (GdaDataHandler *dh, const GValue *value) { g_return_val_if_fail (dh && GDA_IS_DATA_HANDLER (dh), NULL); if (! value || gda_value_is_null (value)) return g_strdup (""); g_return_val_if_fail (_accepts_g_type (dh, G_VALUE_TYPE (value)), NULL); /* Calling the real function with value != NULL and not of type GDA_TYPE_NULL */ if (GDA_DATA_HANDLER_GET_IFACE (dh)->get_str_from_value) return (GDA_DATA_HANDLER_GET_IFACE (dh)->get_str_from_value) (dh, value); return NULL; }
/* Returns: TRUE if FileRow value has been changed */ static gboolean update_file_mime (FileRow *row, const gchar *complete_filename) { gboolean changed = TRUE; GValue *value = NULL; #ifdef HAVE_GIO GFile *file; GFileInfo *info; file = g_file_new_for_path (complete_filename); info = g_file_query_info (file, G_FILE_ATTRIBUTE_STANDARD_FAST_CONTENT_TYPE, G_FILE_QUERY_INFO_NONE, NULL, NULL); if (info) { value = gda_value_new (G_TYPE_STRING); g_value_set_string (value, g_file_info_get_content_type (info)); g_object_unref (info); } else value = gda_value_new_null (); g_object_unref (file); #else value = gda_value_new_null (); #endif if (value) { if (row->mime_value && (G_VALUE_TYPE (row->mime_value) == G_TYPE_STRING) && !gda_value_compare (row->mime_value, value)) changed = FALSE; else { if (row->mime_value) gda_value_free (row->mime_value); row->mime_value = value; } } else { if (row->mime_value && gda_value_is_null (row->mime_value)) changed = FALSE; else { if (row->mime_value) gda_value_free (row->mime_value); row->mime_value = gda_value_new_null (); } } return changed; }
void sim_xml_config_set_config_max_event_tmp (SimConfig *config) { GdaDataModel *dm; GdaValue *value; gchar *query; g_return_if_fail (config); g_return_if_fail (SIM_IS_CONFIG (config)); query = g_strdup_printf ("SELECT value FROM config WHERE conf='max_event_tmp'"); dm = sim_database_execute_single_command (ossim.ossimdb, query); if (dm) { value = (GdaValue *) gda_data_model_get_value_at (dm, 0, 0); if (gda_data_model_get_n_rows(dm) !=0) //to avoid (null)-Critical: gda_value_is_null: assertion `value != NULL' failed { if (!gda_value_is_null (value)) { config->max_event_tmp = gda_value_stringify (value); } else g_log (G_LOG_DOMAIN, G_LOG_LEVEL_DEBUG, "sim_xml_config_set_config_max_event_tmp value null"); } else config->max_event_tmp = 0; } else { g_message ("Error: Config DATA MODEL ERROR"); config->max_event_tmp = 0; } g_free (query); }
/* * COMMAND: <gda_report_if> * * Creates a copy of the children of the <gda_report_if_true> or <gda_report_if_false> nodes depending on the * result of the execution of the expression * * uses node's contents: yes * requested attributes: none */ static gboolean command_gda_report_if (GdaReportEngine *engine, xmlNodePtr node, GSList **created_nodes, RunContext *context, GError **error) { GValue *value; gboolean expr_is_true = FALSE; xmlChar *prop; prop = xmlGetProp (node, BAD_CAST "expr"); if (!prop) { g_set_error (error, 0, 0, "%s", _("No expression specified")); return FALSE; } /* evaluate expression as boolean */ value = evaluate_expression (engine, context, (const gchar *) prop, error); if (!value) return FALSE; xmlFree (prop); if (value && !gda_value_is_null (value)) { if (G_VALUE_TYPE (value) == G_TYPE_BOOLEAN) expr_is_true = g_value_get_boolean (value); else { GValue *trans; trans = gda_value_new (G_TYPE_BOOLEAN); if (g_value_transform (value, trans)) { expr_is_true = g_value_get_boolean (trans); gda_value_free (trans); } else { gda_value_free (trans); g_set_error (error, 0, 0, _("Cannot cast value from type '%s' to type '%s'"), g_type_name (G_VALUE_TYPE (value)), g_type_name (G_TYPE_BOOLEAN)); return FALSE; } } gda_value_free (value); } /*g_print ("IF Expression evaluates to %d\n", expr_is_true);*/ /* find the correct sub node: <gda_report_if_true> or <gda_report_if_false> */ gchar *sub_node_name; xmlNodePtr sub_node; sub_node_name = expr_is_true ? "gda_report_if_true" : "gda_report_if_false"; for (sub_node = node->children; sub_node; sub_node = sub_node->next) { if (!strcmp ((gchar *) sub_node->name, sub_node_name)) { if (!real_run_at_node (engine, sub_node->children, context, error)) return FALSE; else { xmlNodePtr child; for (child = sub_node->children; child; child = sub_node->children) { xmlUnlinkNode (child); *created_nodes = g_slist_prepend (*created_nodes, child); } } } } *created_nodes = g_slist_reverse (*created_nodes); return TRUE; }
/* * value_to_node * * Converts @value to a string */ static xmlNodePtr value_to_node (GdaReportEngine *engine, G_GNUC_UNUSED RunContext *context, const GValue *value, GdaSet *options) { xmlNodePtr retnode = NULL; GdaHolder *converter = NULL; if (options) converter = gda_set_get_holder (options, "converter"); if (!value || gda_value_is_null (value)) retnode = xmlNewText (BAD_CAST ""); else if ((G_VALUE_TYPE (value) == GDA_TYPE_BINARY) || (G_VALUE_TYPE (value) == GDA_TYPE_BLOB)) { TO_IMPLEMENT; retnode = xmlNewText (BAD_CAST _("Binary data")); } else { GdaDataHandler *dh; gchar *str; if (!data_handlers) { /* initialize the internal data handlers */ data_handlers = g_hash_table_new_full (gtype_hash, gtype_equal, NULL, (GDestroyNotify) g_object_unref); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_INT64, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UINT64, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_BOOLEAN, gda_handler_boolean_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_DATE, gda_handler_time_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_DOUBLE, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_INT, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_NUMERIC, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_FLOAT, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_SHORT, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_USHORT, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_STRING, gda_handler_string_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_TIME, gda_handler_time_new ()); g_hash_table_insert (data_handlers, (gpointer) GDA_TYPE_TIMESTAMP, gda_handler_time_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_CHAR, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UCHAR, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_ULONG, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_LONG, gda_handler_numerical_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_GTYPE, gda_handler_type_new ()); g_hash_table_insert (data_handlers, (gpointer) G_TYPE_UINT, gda_handler_numerical_new ()); } gboolean converted = FALSE; dh = g_hash_table_lookup (data_handlers, (gpointer) G_VALUE_TYPE (value)); if (dh) str = gda_data_handler_get_str_from_value (dh, value); else str = gda_value_stringify (value); if (converter) { const GValue *cvalue; cvalue = gda_holder_get_value (converter); if ((G_VALUE_TYPE (cvalue) == G_TYPE_STRING) && g_value_get_string (cvalue)) { gchar **array; array = g_strsplit (g_value_get_string (cvalue), "::", 0); if (array[0] && !strcmp (array[0], "richtext")) { if (array[1] && !strcmp (array[1], "docbook")) { retnode = xmlNewNode (NULL, BAD_CAST "para"); parse_rich_text_to_docbook (engine, retnode, str); converted = TRUE; } else if (array[1] && !strcmp (array[1], "html")) { retnode = xmlNewNode (NULL, BAD_CAST "p"); parse_rich_text_to_html (engine, retnode, str); converted = TRUE; } } } } if (!converted) retnode = xmlNewText (BAD_CAST (str ? str : "")); g_free (str); } return retnode; }
GList * midgard_core_qb_set_object_from_query (MidgardQueryBuilder *builder, guint select_type, MidgardObject **nobject) { g_assert(builder != NULL); guint ret_rows, ret_fields; MidgardConnection *mgd = builder->priv->mgd; gchar *sql = midgard_core_qb_get_sql( builder, select_type, midgard_query_builder_get_object_select(builder, select_type)); GSList *olist = NULL; MidgardDBObjectClass *dbklass = MIDGARD_DBOBJECT_CLASS(g_type_class_peek(builder->priv->type)); if (!dbklass) { MIDGARD_ERRNO_SET_STRING (mgd, MGD_ERR_INTERNAL, "Failed to peek MidgardDBObjectClass pointer"); return NULL; } if (dbklass->dbpriv->set_from_sql) { if (select_type != MQB_SELECT_GUID) { olist = dbklass->dbpriv->set_from_sql(mgd, builder->priv->type, ((const gchar *)sql)); g_free(sql); return (GList *)olist; } } GdaDataModel *model = midgard_core_query_get_model(builder->priv->mgd, sql); g_free(sql); if(!model) return NULL; MidgardObject *object = NULL; gint rows, columns; const GValue *gvalue = NULL; ret_rows = gda_data_model_get_n_rows(model); ret_fields = gda_data_model_get_n_columns(model); /* records found , allocate as many objects as many returned rows */ GList *list = NULL; if(ret_rows == 0) { g_object_unref(model); return list; } /* We count rows only */ if(select_type == MQB_SELECT_GUID) { gvalue = midgard_data_model_get_value_at(model, 0, 0); if (!gvalue || !G_IS_VALUE (gvalue)) { g_object_unref (model); return 0; } MidgardTypeHolder *holder = g_new(MidgardTypeHolder, 1); GValue val = {0, }; g_value_init (&val, G_TYPE_INT64); g_value_transform (gvalue, &val); holder->elements = (guint)g_value_get_int64((GValue*)&val); list = g_list_append(list, holder); g_object_unref(model); g_value_unset (&val); return list; } /* Get every row */ for (rows = 0; rows < ret_rows; rows++) { if(!nobject) object = g_object_new (builder->priv->type, "connection", mgd, NULL); else object = *nobject; MGD_OBJECT_IN_STORAGE (object) = TRUE; if(dbklass->dbpriv->__set_from_sql != NULL) { dbklass->dbpriv->__set_from_sql(MIDGARD_DBOBJECT(object), model, rows); } else { /* Compute number of metadata properties */ guint n_md_props = 0; MidgardMetadata *mklass = (MidgardMetadata *)MGD_DBCLASS_METADATA_CLASS (dbklass); if (mklass) n_md_props = g_hash_table_size (MGD_DBCLASS_STORAGE_DATA (mklass)->prophash); guint __cols = n_md_props + 1; /* Add one for guid */ /* we have guid and metadata columns first */ for (columns = __cols; columns < ret_fields; columns++) { gvalue = midgard_data_model_get_value_at(model, columns, rows); const gchar *coltitle = gda_data_model_get_column_title(model, columns); GParamSpec *pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(object), coltitle); if(G_IS_VALUE(gvalue)) { if (!pspec) { g_warning("Failed to found (unregistered) %s property (%s class)", coltitle, G_OBJECT_TYPE_NAME(object)); continue; } if (G_VALUE_TYPE (gvalue) == GDA_TYPE_BINARY && G_TYPE_FUNDAMENTAL (pspec->value_type) == G_TYPE_STRING) { gchar *stringified = midgard_core_query_binary_stringify ((GValue *)gvalue); g_object_set (G_OBJECT (object), coltitle, stringified, NULL); g_free (stringified); } else if (pspec->value_type != G_VALUE_TYPE (gvalue)) { GValue _convert = {0, }; g_value_init (&_convert, pspec->value_type); if (g_value_transform (gvalue, &_convert)) { /* FIXME, remove workaround once it's fixed in GDA */ /* https://bugzilla.gnome.org/show_bug.cgi?id=617550 */ guint dbtype = mgd->priv->config->priv->dbtype; if (dbtype == MIDGARD_DB_TYPE_MYSQL && G_VALUE_TYPE (gvalue) == GDA_TYPE_BLOB) { gchar *tmp_str = __default_unescape_string (g_value_get_string (&_convert)); if (tmp_str) g_value_take_string (&_convert, tmp_str); } g_object_set_property (G_OBJECT (object), coltitle, &_convert); } else { g_warning ("Failed to convert %s to %s for %s property", G_VALUE_TYPE_NAME (gvalue), G_VALUE_TYPE_NAME (&_convert), coltitle); } g_value_unset (&_convert); } else { g_object_set_property(G_OBJECT(object), coltitle, gvalue); } } else if (gda_value_is_null(gvalue)) { switch (pspec->value_type) { case G_TYPE_INT: case G_TYPE_UINT: g_object_set(G_OBJECT(object), coltitle, 0, NULL); break; case G_TYPE_STRING: g_object_set(G_OBJECT(object), coltitle, "", NULL); break; default: g_warning("Found (%s) not a value at %d.%d (%s)", g_type_name(pspec->value_type), columns, rows, gda_data_model_get_column_title(model, columns)); break; } } } } /* Set guid */ const gchar *guid; gvalue = midgard_data_model_get_value_at(model, 0, rows); if(G_IS_VALUE(gvalue) && G_VALUE_HOLDS_STRING(gvalue)){ guid = g_value_get_string(gvalue); g_free((gchar *)MIDGARD_DBOBJECT(object)->dbpriv->guid); MIDGARD_DBOBJECT(object)->dbpriv->guid = g_strdup(guid); } /* Set metadata */ MidgardMetadata *metadata = MGD_DBOBJECT_METADATA (object); if (metadata) { GParamSpec *pspec = g_object_class_find_property(G_OBJECT_GET_CLASS(object), "metadata"); if (pspec) __mqb_set_metadata(metadata, model, rows); } list = g_list_append(list, G_OBJECT(object)); } g_object_unref(model); return list; }
static void assistant_applied_cb (GtkAssistant *assist, G_GNUC_UNUSED gpointer data) { gboolean allok = TRUE; GString *cnc_string = NULL; GdauiDsnAssistant *assistant = (GdauiDsnAssistant *) assist; g_return_if_fail (GDAUI_IS_DSN_ASSISTANT (assistant)); /* clear the internal dsn_info */ if (assistant->priv->dsn_info) { data_source_info_free (assistant->priv->dsn_info); assistant->priv->dsn_info = NULL; } /* New database creation first */ if (gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (assistant->priv->choose_toggle))) { if (!gda_server_operation_is_valid (assistant->priv->create_db_op, NULL, NULL)) { _gdaui_utility_show_error (NULL, _("Missing mandatory information, to create database")); gtk_assistant_set_current_page (assist, PAGE_CREATE_DB_INFO); return; } else { GdaProviderInfo *prov_info; GSList *dsn_params; GError *error = NULL; allok = gda_server_operation_perform_create_database (assistant->priv->create_db_op, NULL, &error); if (!allok) { gchar *str; str = g_strdup_printf (_("Error creating database: %s"), error && error->message ? error->message : _("Unknown error")); _gdaui_utility_show_error (NULL, str); g_free (str); gtk_assistant_set_current_page (assist, PAGE_CREATE_DB_INFO); return; } /* make the connection string for the data source */ prov_info = gda_config_get_provider_info (gdaui_provider_selector_get_provider (GDAUI_PROVIDER_SELECTOR (assistant->priv->general_provider))); g_return_if_fail (prov_info); for (dsn_params = prov_info->dsn_params->holders; dsn_params; dsn_params = dsn_params->next) { GdaHolder *param = GDA_HOLDER (dsn_params->data); const GValue *value; value = gda_server_operation_get_value_at (assistant->priv->create_db_op, "/DB_DEF_P/%s", gda_holder_get_id (param)); if (!value) value = gda_server_operation_get_value_at (assistant->priv->create_db_op, "/SERVER_CNX_P/%s", gda_holder_get_id (param)); if (value && !gda_value_is_null ((GValue *) value)) { gchar *str; if (dsn_params == prov_info->dsn_params->holders) cnc_string = g_string_new (""); else g_string_append (cnc_string, ";"); str = gda_value_stringify ((GValue *) value); g_string_append_printf (cnc_string, "%s=%s", gda_holder_get_id (param), str); g_free (str); } } } } /* Data source declaration */ if (allok) { assistant->priv->dsn_info = g_new0 (GdaDsnInfo, 1); assistant->priv->dsn_info->name = g_strdup (gtk_entry_get_text (GTK_ENTRY (assistant->priv->general_name))); assistant->priv->dsn_info->provider = g_strdup ( gdaui_provider_selector_get_provider ( GDAUI_PROVIDER_SELECTOR (assistant->priv->general_provider))); if (cnc_string) { assistant->priv->dsn_info->cnc_string = cnc_string->str; g_string_free (cnc_string, FALSE); } else assistant->priv->dsn_info->cnc_string = _gdaui_provider_spec_editor_get_specs (GDAUI_PROVIDER_SPEC_EDITOR (assistant->priv->provider_detail)); assistant->priv->dsn_info->description = g_strdup (gtk_entry_get_text (GTK_ENTRY (assistant->priv->general_description))); assistant->priv->dsn_info->auth_string = NULL; if (assistant->priv->auth_detail) assistant->priv->dsn_info->auth_string = _gdaui_provider_auth_editor_get_auth (GDAUI_PROVIDER_AUTH_EDITOR (assistant->priv->auth_detail)); if (gda_config_can_modify_system_config ()) assistant->priv->dsn_info->is_system = gtk_toggle_button_get_active (GTK_TOGGLE_BUTTON (assistant->priv->general_is_system)); else assistant->priv->dsn_info->is_system = FALSE; } /* notify listeners */ g_signal_emit (G_OBJECT (assistant), config_assistant_signals[FINISHED], 0, !allok); }
SimEvent * sim_event_light_new_from_dm (GdaDataModel *dm, gint row) { SimEvent *event; const GValue *value; const GdaBinary *binary; const GdaTimestamp *timestamp; struct tm tm; g_return_val_if_fail (GDA_IS_DATA_MODEL (dm), NULL); event = sim_event_new (); event->id = sim_uuid_new (); value = gda_data_model_get_value_at (dm, 0, row, NULL); if (!gda_value_is_null (value)) { binary = (GdaBinary *) gda_value_get_blob (value); event->src_ia = sim_inet_new_from_db_binary (binary->data, binary->binary_length); } value = gda_data_model_get_value_at (dm, 1, row, NULL); if (!gda_value_is_null (value)) { binary = (GdaBinary *) gda_value_get_blob (value); event->dst_ia = sim_inet_new_from_db_binary (binary->data, binary->binary_length); } value = gda_data_model_get_value_at (dm, 2, row, NULL); if (!gda_value_is_null (value)) event->src_id = sim_uuid_new_from_blob (gda_value_get_blob (value)); value = gda_data_model_get_value_at (dm, 3, row, NULL); if (!gda_value_is_null (value)) event->dst_id = sim_uuid_new_from_blob (gda_value_get_blob (value)); value = gda_data_model_get_value_at (dm, 4, row, NULL); event->src_port = gda_value_is_null (value) ? 0 : g_value_get_int (value); value = gda_data_model_get_value_at (dm, 5, row, NULL); event->dst_port = gda_value_is_null (value) ? 0 : g_value_get_int (value); value = gda_data_model_get_value_at (dm, 6, row, NULL); if (!gda_value_is_null (value)) { timestamp = gda_value_get_timestamp (value); tm.tm_year = timestamp->year - 1900; tm.tm_mon = timestamp->month - 1; tm.tm_mday = timestamp->day; tm.tm_hour = timestamp->hour - 1; tm.tm_min = timestamp->minute; tm.tm_mday = timestamp->day; tm.tm_sec = timestamp->second; tm.tm_wday = 0; tm.tm_yday = 0; tm.tm_isdst = 0; event->time = mktime (&tm); } value = gda_data_model_get_value_at (dm, 7, row, NULL); event->tzone = gda_value_is_null (value) ? 0.0 : g_value_get_float (value); return event; }
static gboolean gda_data_model_dir_set_values (GdaDataModel *model, gint row, GList *values, GError **error) { GdaDataModelDir *imodel; GList *list; gint col; FileRow *frow; gboolean has_changed = FALSE; g_return_val_if_fail (GDA_IS_DATA_MODEL_DIR (model), FALSE); g_return_val_if_fail (row >= 0, FALSE); imodel = (GdaDataModelDir *) model; g_return_val_if_fail (imodel->priv, FALSE); if (!values) return TRUE; if ((guint)row >= imodel->priv->rows->len) { gchar *str; if (imodel->priv->rows->len > 0) str = g_strdup_printf (_("Row %d out of range (0-%d)"), row, imodel->priv->rows->len - 1); else str = g_strdup_printf (_("Row %d not found (empty data model)"), row); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ROW_OUT_OF_RANGE_ERROR, "%s", str); g_free (str); return FALSE; } frow = g_ptr_array_index (imodel->priv->rows, row); for (col = 0, list = values; list; list = list->next, col++) { GValue *value = (GValue *) list->data; const GValue *cvalue = gda_data_model_get_value_at (model, col, row, error); if (!cvalue) return FALSE; if (!value || !gda_value_compare (value, cvalue)) continue; switch (col) { case COL_SIZE: case COL_MIME: case COL_MD5SUM: default: add_error (imodel, _("Column cannot be modified")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("Column cannot be modified")); return FALSE; case COL_DIRNAME: { /* check that the new dir still starts with the basedir */ const gchar *new_path; gchar *old_path; gint len, base_len; new_path = value ? g_value_get_string (value) : ""; len = strlen (new_path); base_len = strlen (imodel->priv->basedir); if ((len < base_len) || (strncmp (new_path, imodel->priv->basedir, base_len))) { add_error (imodel, _("New path must be a subpath of the base directory")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("New path must be a subpath of the base directory")); return FALSE; } old_path = compute_dirname (imodel, frow); if (dir_equal (new_path, old_path)) { g_free (old_path); g_print ("Paths are equal...\n"); break; } if (!g_mkdir_with_parents (new_path, 0755)) { gchar *new_filename; GMappedFile *old_file; gboolean allok = FALSE; gchar *filename; new_filename = g_build_filename (new_path, frow->raw_filename_value ? frow->raw_filename_value : g_value_get_string (frow->filename_value), NULL); filename = compute_filename (imodel, frow); old_file = g_mapped_file_new (filename, FALSE, NULL); if (old_file) { if (g_file_set_contents (new_filename, g_mapped_file_get_contents (old_file), g_mapped_file_get_length (old_file), NULL)) { g_unlink (filename); allok = TRUE; if (frow->data_value) { GdaBlob *blob; blob = (GdaBlob *) gda_value_get_blob (frow->data_value); if (blob && blob->op) _gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op), new_filename); } } g_mapped_file_unref (old_file); } if (!allok) { gchar *str; str = g_strdup_printf (_("Could not rename file '%s' to '%s'"), filename, new_filename); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); g_free (new_filename); g_free (filename); g_free (old_path); return FALSE; } else { /* renaming succeeded => update FileRow */ #ifndef G_OS_WIN32 g_rmdir (old_path); #endif g_free (frow->reldir); frow->reldir = g_strdup (new_path + base_len); } g_free (filename); g_free (new_filename); has_changed = TRUE; } else { gchar *str; str = g_strdup_printf (_("Could not create directory '%s'"), new_path); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); g_free (old_path); return FALSE; } g_free (old_path); break; } case COL_FILENAME: { gchar *new_filename; gchar *filename; new_filename = g_build_filename (imodel->priv->basedir, frow->reldir, g_value_get_string (value), NULL); filename = compute_filename (imodel, frow); if (g_rename (filename, new_filename)) { gchar *str; str = g_strdup_printf (_("Could not rename file '%s' to '%s'"), filename, new_filename); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); g_free (new_filename); g_free (filename); return FALSE; } else { /* renaming succeeded => update FileRow */ gda_value_free (frow->filename_value); frow->filename_value = gda_value_copy (value); if (frow->raw_filename_value) { g_free (frow->raw_filename_value); frow->raw_filename_value = g_strdup (g_value_get_string (value)); } if (frow->data_value) { GdaBlob *blob; blob = (GdaBlob *) gda_value_get_blob (frow->data_value); if (blob && blob->op) _gda_dir_blob_set_filename (GDA_DIR_BLOB_OP (blob->op), new_filename); } } g_free (new_filename); g_free (filename); has_changed = TRUE; break; } case COL_DATA: { GdaBlob *blob = NULL; if (gda_value_isa (value, GDA_TYPE_BLOB)) { blob = (GdaBlob *) gda_value_get_blob (value); } else if (gda_value_isa (value, GDA_TYPE_BINARY)) { blob = (GdaBlob *) gda_value_get_binary (value); } else if (gda_value_is_null (value)) { /* create a new empty blob */ blob = g_new0 (GdaBlob, 1); } if (blob) { GdaBlobOp *op; gchar *filename; filename = compute_filename (imodel, frow); op = _gda_dir_blob_op_new (filename); if (gda_blob_op_write_all (op, blob) < 0) { gchar *str; str = g_strdup_printf (_("Could not overwrite contents of file '%s'"), filename); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); g_object_unref (op); g_free (filename); return FALSE; } g_object_unref (op); if (gda_value_is_null (value)) g_free (blob); has_changed = FALSE; has_changed = update_file_size (frow, filename); has_changed = update_file_md5sum (frow, filename) || has_changed; has_changed = update_file_mime (frow, filename) || has_changed; g_free (filename); } else { add_error (imodel, _("Wrong type of data")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("Wrong type of data")); return FALSE; } break; } } } if (has_changed) /* signal changes to data model */ gda_data_model_row_updated ((GdaDataModel *) model, row); return TRUE; }
/* Returns: TRUE if FileRow value has been changed */ static gboolean update_file_md5sum (FileRow *row, const gchar *complete_filename) { gboolean changed = TRUE; GValue *value = NULL; /* MD5 computation */ MD5_CTX context; unsigned char digest[16]; /* Flawfinder: ignore */ GString *md5str; gint i; int fd; gpointer map; guint length; HANDLE view; /* file mapping in mem */ length = g_value_get_uint (row->size_value); if (length == 0) goto md5end; fd = open (complete_filename, O_RDONLY); /* Flawfinder: ignore */ if (fd < 0) goto md5end; #ifndef G_OS_WIN32 map = mmap (NULL, length, PROT_READ, MAP_PRIVATE, fd, 0); if (map == MAP_FAILED) { close (fd); goto md5end; } #else view = CreateFileMapping ((HANDLE) fd, NULL, PAGE_READONLY|SEC_COMMIT, 0,0 , NULL); if (!view) { close (fd); goto md5end; } map = MapViewOfFile (view, FILE_MAP_READ, 0, 0, length); if (!map) { close (fd); goto md5end; } #endif /* !G_OS_WIN32 */ MD5Init (&context); MD5Update (&context, map, length); MD5Final (digest, &context); md5str = g_string_new (""); for (i = 0; i < 16; i++) g_string_append_printf (md5str, "%02x", digest[i]); value = gda_value_new (G_TYPE_STRING); g_value_take_string (value, md5str->str); g_string_free (md5str, FALSE); #ifndef G_OS_WIN32 munmap (map, length); #else UnmapViewOfFile (map); #endif /* !G_OS_WIN32 */ close (fd); md5end: if (value) { if (row->md5sum_value && (G_VALUE_TYPE (row->md5sum_value) == G_TYPE_STRING) && !gda_value_compare (row->md5sum_value, value)) changed = FALSE; else { if (row->md5sum_value) gda_value_free (row->md5sum_value); row->md5sum_value = value; } } else { if (row->md5sum_value && gda_value_is_null (row->md5sum_value)) changed = FALSE; else { if (row->md5sum_value) gda_value_free (row->md5sum_value); row->md5sum_value = gda_value_new_null (); } } return changed; }
static gint gda_data_model_dir_append_values (GdaDataModel *model, const GList *values, GError **error) { GdaDataModelDir *imodel; const gchar *dirname = NULL, *filename = NULL; GdaBinary *bin_data = NULL; GList *list; gint col; g_return_val_if_fail (GDA_IS_DATA_MODEL_DIR (model), -1); imodel = (GdaDataModelDir *) model; g_return_val_if_fail (imodel->priv, -1); if (!values) return -1; for (col = 0, list = (GList *) values; list; list = list->next, col++) { GValue *value = (GValue *) list->data; if (!value || gda_value_is_null (value)) continue; switch (col) { case COL_SIZE: case COL_MIME: case COL_MD5SUM: default: add_error (imodel, _("Column cannot be set")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("Column cannot be set")); return -1; case COL_DIRNAME: if (G_VALUE_TYPE (value) == G_TYPE_STRING) { gint len, base_len; base_len = strlen (imodel->priv->basedir); dirname = g_value_get_string (value); len = strlen (dirname); if ((len < base_len) || (strncmp (dirname, imodel->priv->basedir, base_len))) { add_error (imodel, _("New path must be a subpath of the base directory")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("New path must be a subpath of the base directory")); return -1; } } break; case COL_FILENAME: if (G_VALUE_TYPE (value) == G_TYPE_STRING) filename = g_value_get_string (value); break; case COL_DATA: if (G_VALUE_TYPE (value) == GDA_TYPE_BLOB) bin_data = (GdaBinary *) gda_value_get_blob (value); else if (G_VALUE_TYPE (value) == GDA_TYPE_BINARY) bin_data = (GdaBinary *) gda_value_get_binary (value); break; } } if (dirname && filename && *filename) { if (!g_mkdir_with_parents (dirname, 0755)) { gchar *complete_filename; gboolean bin_to_free = FALSE; complete_filename = g_build_filename (dirname, filename, NULL); if (!bin_data) { bin_data = g_new0 (GdaBinary, 1); bin_to_free = TRUE; } if (g_file_set_contents (complete_filename, (gchar *) bin_data->data, bin_data->binary_length, NULL)) { FileRow *row; row = file_row_new (); row->reldir = g_strdup (dirname + strlen (imodel->priv->basedir)); #ifndef G_OS_WIN32 row->raw_filename_value = g_strdup (filename); #else row->raw_filename_value = NULL; /* no need top copy on Windows */ #endif g_value_set_string (row->filename_value = gda_value_new (G_TYPE_STRING), filename); /* file size */ update_file_size (row, complete_filename); /* other attributes, computed only when needed */ row->mime_value = NULL; row->md5sum_value = NULL; row->data_value = NULL; if (bin_to_free) g_free (bin_data); g_ptr_array_add (imodel->priv->rows, row); gda_data_model_row_inserted (model, imodel->priv->rows->len - 1); return imodel->priv->rows->len - 1; } else { #ifndef G_OS_WIN32 g_rmdir (dirname); #endif gchar *str; str = g_strdup_printf (_("Cannot set contents of filename '%s'"), complete_filename); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); if (bin_to_free) g_free (bin_data); return -1; } } else { gchar *str; str = g_strdup_printf (_("Cannot create directory '%s'"), dirname); add_error (imodel, str); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", str); g_free (str); return -1; } } else { add_error (imodel, _("Cannot add row: filename missing")); g_set_error (error, GDA_DATA_MODEL_ERROR, GDA_DATA_MODEL_ACCESS_ERROR, "%s", _("Cannot add row: filename missing")); return -1; } return -1; }