/* 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;
}
