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;
}
static gchar *
unix_shadow_to_string (const gchar *value, const gchar *attname)
{
/* value is the number of days since 1970-01-01 */
gint64 i64;
gchar *endptr [1];
if (!value || !*value)
return NULL;
i64 = g_ascii_strtoll (value, endptr, 10);
if (**endptr != '\0')
return NULL;
if ((i64 == -1) &&
(!strcmp (attname, "shadowInactive") ||
!strcmp (attname, "shadowMin") ||
!strcmp (attname, "shadowExpire")))
return g_strdup (_("Non activated"));
else if ((i64 == 99999) && !strcmp (attname, "shadowMax"))
return g_strdup ("Always valid");
if ((i64 >= G_MAXUINT) || (i64 < 0))
return NULL;
if (!strcmp (attname, "shadowMax") ||
!strcmp (attname, "shadowMin") ||
!strcmp (attname, "shadowInactive"))
return NULL;
GDate *date;
date = g_date_new_dmy (1, 1, 1970);
g_date_add_days (date, (guint) i64);
if (! g_date_valid (date)) {
g_date_free (date);
return NULL;
}
GdaDataHandler *dh;
GValue tvalue;
gchar *str;
memset (&tvalue, 0, sizeof (GValue));
g_value_init (&tvalue, G_TYPE_DATE);
g_value_take_boxed (&tvalue, date);
dh = gda_data_handler_get_default (G_TYPE_DATE);
str = gda_data_handler_get_str_from_value (dh, &tvalue);
g_value_reset (&tvalue);
return str;
}
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);
}
/*
* 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;
}
/*
* REM: if @attr_names is not NULL, then @cols_size will have the same number of items
*
* - Optionally called once with @out_max_prefix_size not %NULL and @in_string %NULL => compute
* cols_size[x] and *out_max_prefix_size
* - Called once with @in_string not %NULL and @out_max_prefix_size %NULL
*/
static void
tree_node_to_string (GdaTreeNode *node, gboolean has_parent, gboolean has_next_sibling,
const gchar *prefix,
gchar **attr_names, guint *cols_size, guint max_prefix_size,
guint *out_max_prefix_size, GString *in_string)
{
gchar *pipe = "|";
gchar *prefix2 = "|- ";
gchar *prefix3 = "`- ";
pipe = "│";
prefix2 = "├─ ";
prefix3 = "└─ ";
#define SEP " "
const GValue *cvalue;
gchar *p;
const gchar *cstr;
guint i;
/* prefix */
if (has_next_sibling)
p = g_strdup_printf ("%s%s", prefix, prefix2);
else
p = g_strdup_printf ("%s%s", prefix, prefix3);
if (in_string)
g_string_append (in_string, p);
i = g_utf8_strlen (p, -1);
g_free (p);
/* node name */
cvalue = gda_tree_node_get_node_attribute (node, GDA_ATTRIBUTE_NAME);
cstr = cvalue && g_value_get_string (cvalue)? g_value_get_string (cvalue) : "???";
if (in_string)
g_string_append (in_string, cstr);
/* padding */
if (in_string) {
for (i = i + g_utf8_strlen (cstr, -1); i < max_prefix_size; i++)
g_string_append_c (in_string, ' ');
}
else {
guint size = i;
if (g_utf8_validate (cstr, -1, NULL))
size += g_utf8_strlen (cstr, -1);
else
size += strlen (cstr);
*out_max_prefix_size = MAX (size, *out_max_prefix_size);
}
/* some node's attributes */
if (attr_names) {
for (i = 0; attr_names[i] && *attr_names[i]; i++) {
guint colsize = 0;
if (in_string) {
if (cols_size [i] == 0)
continue; /* ignore this attribute as it's not set */
g_string_append (in_string, SEP);
}
cvalue = gda_tree_node_get_node_attribute (node, attr_names[i]);
if (cvalue && (G_VALUE_TYPE (cvalue) != GDA_TYPE_NULL)) {
gchar *tmp = NULL;
if (G_VALUE_TYPE (cvalue) == G_TYPE_FLOAT)
tmp = g_strdup_printf ("%.01f", g_value_get_float (cvalue));
else {
GdaDataHandler *dh;
dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
if (dh)
tmp = gda_data_handler_get_str_from_value (dh, cvalue);
else
tmp = gda_value_stringify (cvalue);
}
if (in_string) {
gboolean right = FALSE;
if ((G_VALUE_TYPE (cvalue) == G_TYPE_INT) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_UINT) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_INT64) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_UINT64) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_FLOAT) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_DOUBLE) ||
(G_VALUE_TYPE (cvalue) == G_TYPE_CHAR) ||
(G_VALUE_TYPE (cvalue) == GDA_TYPE_SHORT) ||
(G_VALUE_TYPE (cvalue) == GDA_TYPE_USHORT))
right = TRUE;
if (right) {
/* right align */
guint j;
for (j = tmp ? g_utf8_strlen (tmp, -1) : 0; j < cols_size [i]; j++)
g_string_append_c (in_string, ' ');
if (tmp) {
if (g_utf8_strlen (tmp, -1) > cols_size[i])
tmp [cols_size [i]] = 0;
g_string_append (in_string, tmp);
}
}
else {
/* left align */
if (tmp) {
if (g_utf8_strlen (tmp, -1) > cols_size[i])
tmp [cols_size [i]] = 0;
g_string_append (in_string, tmp);
}
guint j;
for (j = tmp ? g_utf8_strlen (tmp, -1) : 0; j < cols_size [i]; j++)
g_string_append_c (in_string, ' ');
}
}
else {
if (tmp) {
if (g_utf8_validate (tmp, -1, NULL))
colsize += g_utf8_strlen (tmp, -1);
else
colsize += strlen (tmp);
}
cols_size [i] = MAX (cols_size [i], colsize);
}
g_free (tmp);
}
else if (in_string) {
guint j;
for (j = 0; j < cols_size [i]; j++)
g_string_append_c (in_string, ' ');
}
}
}
if (in_string)
g_string_append_c (in_string, '\n');
/* children */
gchar *ch_prefix;
if (has_next_sibling)
ch_prefix = g_strdup_printf ("%s%s ", prefix, pipe);
else
ch_prefix = g_strdup_printf ("%s ", prefix);
GSList *top, *list;
top = gda_tree_node_get_children (node);
for (list = top; list; list = list->next)
tree_node_to_string (GDA_TREE_NODE (list->data), TRUE, list->next ? TRUE : FALSE,
ch_prefix, attr_names, cols_size, max_prefix_size,
out_max_prefix_size, in_string);
g_slist_free (top);
g_free (ch_prefix);
}
static void
entry_info_fetched_done (EntryProperties *eprop, GdaLdapEntry *entry)
{
GtkTextBuffer *tbuffer;
GtkTextIter start, end;
TConnection *tcnc = eprop->priv->tcnc;
tbuffer = eprop->priv->text;
gtk_text_buffer_get_start_iter (tbuffer, &start);
gtk_text_buffer_get_end_iter (tbuffer, &end);
gtk_text_buffer_delete (tbuffer, &start, &end);
guint i;
GtkTextIter current;
gtk_text_buffer_get_start_iter (tbuffer, ¤t);
/* DN */
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, _("Distinguished Name:"), -1,
"section", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1, "starter", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, entry->dn, -1,
"data", NULL);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
/* other attributes */
const gchar *basedn;
GdaDataHandler *ts_dh = NULL;
basedn = t_connection_ldap_get_base_dn (tcnc);
for (i = 0; i < entry->nb_attributes; i++) {
GdaLdapAttribute *attr;
gchar *tmp;
attr = entry->attributes [i];
tmp = g_strdup_printf ("%s:", attr->attr_name);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, tmp, -1, "section", NULL);
g_free (tmp);
gtk_text_buffer_insert (tbuffer, ¤t, "\n", -1);
guint j;
for (j = 0; j < attr->nb_values; j++) {
const GValue *cvalue;
cvalue = attr->values [j];
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, " ", -1,
"starter", NULL);
if (G_VALUE_TYPE (cvalue) == GDA_TYPE_BINARY) {
GValue *copyvalue;
GtkTextTagTable *table;
GtkTextTag *tag;
GtkTextMark *mark;
copyvalue = gda_value_copy (cvalue);
table = gtk_text_buffer_get_tag_table (tbuffer);
tag = gtk_text_tag_new (NULL);
gtk_text_tag_table_add (table, tag);
g_object_set_data_full ((GObject*) tag, "binvalue",
copyvalue, (GDestroyNotify) gda_value_free);
g_object_unref ((GObject*) tag);
mark = gtk_text_buffer_create_mark (tbuffer, NULL, ¤t, TRUE);
GdkPixbuf *pixbuf;
pixbuf = data_to_pixbuf (cvalue);
if (pixbuf) {
gtk_text_buffer_insert_pixbuf (tbuffer, ¤t, pixbuf);
g_object_unref (pixbuf);
}
else {
GdaDataHandler *dh;
dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
if (dh)
tmp = gda_data_handler_get_str_from_value (dh, cvalue);
else
tmp = gda_value_stringify (cvalue);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
tmp, -1,
"data", NULL);
g_free (tmp);
}
GtkTextIter before;
gtk_text_buffer_get_iter_at_mark (tbuffer, &before, mark);
gtk_text_buffer_apply_tag (tbuffer, tag, &before, ¤t);
gtk_text_buffer_delete_mark (tbuffer, mark);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
"\n", 1,
"data", NULL);
}
else {
GdaDataHandler *dh;
dh = gda_data_handler_get_default (G_VALUE_TYPE (cvalue));
if (dh)
tmp = gda_data_handler_get_str_from_value (dh, cvalue);
else
tmp = gda_value_stringify (cvalue);
if (tmp) {
if (*tmp &&
((basedn && g_str_has_suffix (tmp, basedn)) || !basedn) &&
gda_ldap_is_dn (tmp)) {
/* we have a DN */
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (tbuffer, NULL,
"foreground", "blue",
"weight", PANGO_WEIGHT_NORMAL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
g_object_set_data_full (G_OBJECT (tag), "dn",
g_strdup (tmp), g_free);
gtk_text_buffer_insert_with_tags (tbuffer, ¤t,
tmp, -1,
tag, NULL);
}
else if (attr->attr_name &&
!g_ascii_strcasecmp (attr->attr_name, "objectClass")) {
GtkTextTag *tag;
tag = gtk_text_buffer_create_tag (tbuffer, NULL,
"foreground", "blue",
"weight", PANGO_WEIGHT_NORMAL,
"underline", PANGO_UNDERLINE_SINGLE,
NULL);
g_object_set_data_full (G_OBJECT (tag), "class",
g_strdup (tmp), g_free);
gtk_text_buffer_insert_with_tags (tbuffer, ¤t,
tmp, -1,
tag, NULL);
}
else
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, tmp, -1,
"data", NULL);
gchar *extrainfo = NULL;
if (!strncmp (attr->attr_name, "shadow", 6) &&
(!strcmp (attr->attr_name, "shadowLastChange") ||
!strcmp (attr->attr_name, "shadowMax") ||
!strcmp (attr->attr_name, "shadowMin") ||
!strcmp (attr->attr_name, "shadowInactive") ||
!strcmp (attr->attr_name, "shadowExpire")))
extrainfo = unix_shadow_to_string (tmp, attr->attr_name);
else if (!strcmp (attr->attr_name, "badPasswordTime") ||
!strcmp (attr->attr_name, "lastLogon") ||
!strcmp (attr->attr_name, "pwdLastSet") ||
!strcmp (attr->attr_name, "accountExpires") ||
!strcmp (attr->attr_name, "lockoutTime") ||
!strcmp (attr->attr_name, "lastLogonTimestamp"))
extrainfo = ad_1601_timestamp_to_string (tmp, attr->attr_name);
else if (!strcmp (attr->attr_name, "userAccountControl"))
extrainfo = ad_1601_uac_to_string (tmp);
else if (!strcmp (attr->attr_name, "sAMAccountType"))
extrainfo = ad_sam_account_type_to_string (tmp);
if (extrainfo) {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
" ", 1,
"data", NULL);
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
extrainfo, -1,
"convdata", NULL);
g_free (extrainfo);
}
g_free (tmp);
}
else {
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t, _("Can't display attribute value"), -1,
"error", NULL);
}
gtk_text_buffer_insert_with_tags_by_name (tbuffer, ¤t,
"\n", 1,
"data", NULL);
}
}
}
if (ts_dh)
g_object_unref (ts_dh);
gda_ldap_entry_free (entry);
if (eprop->priv->text_search && gtk_widget_get_visible (eprop->priv->text_search))
text_search_rerun (TEXT_SEARCH (eprop->priv->text_search));
}
static gchar *
ad_1601_timestamp_to_string (const gchar *value, const gchar *attname)
{
/* value is the number of 100 nanoseconds since 1601-01-01 UTC */
gint64 i64;
gchar *endptr [1];
if (!value || !*value)
return NULL;
i64 = g_ascii_strtoll (value, endptr, 10);
if (**endptr != '\0')
return NULL;
if (i64 == 0x7FFFFFFFFFFFFFFF)
return g_strdup (_("Never"));
if (i64 == 0 && attname) {
if (!strcmp (attname, "accountExpires"))
return g_strdup (_("Never"));
else
return g_strdup (_("Unknown"));
}
i64 = (i64 / (guint64) 10000000);
if (i64 < (gint64) 11644473600)
return NULL;
i64 = i64 - (guint64) 11644473600;
if (i64 >= G_MAXINT)
return NULL;
GdaDataHandler *dh;
struct tm *stm;
GValue tvalue;
GdaTimestamp ts;
time_t nsec = (time_t) i64;
gchar *str;
#ifdef HAVE_LOCALTIME_R
struct tm tmpstm;
stm = localtime_r (&nsec, &tmpstm);
#elif HAVE_LOCALTIME_S
struct tm tmpstm;
if (localtime_s (&tmpstm, &nsec) == 0)
stm = &tmpstm;
else
stm = NULL;
#else
stm = localtime (&nsec);
#endif
if (!stm)
return NULL;
memset (&ts, 0, sizeof (GdaTimestamp));
ts.year = stm->tm_year + 1900;
ts.month = stm->tm_mon + 1;
ts.day = stm->tm_mday;
ts.hour = stm->tm_hour;
ts.minute = stm->tm_min;
ts.second = stm->tm_sec;
ts.timezone = GDA_TIMEZONE_INVALID;
memset (&tvalue, 0, sizeof (GValue));
gda_value_set_timestamp (&tvalue, &ts);
dh = gda_data_handler_get_default (GDA_TYPE_TIMESTAMP);
str = gda_data_handler_get_str_from_value (dh, &tvalue);
g_value_reset (&tvalue);
return str;
}
