aboutsummaryrefslogtreecommitdiff
path: root/src/identity/gnunet-identity-gtk_namespace_manager.c
diff options
context:
space:
mode:
Diffstat (limited to 'src/identity/gnunet-identity-gtk_namespace_manager.c')
-rw-r--r--src/identity/gnunet-identity-gtk_namespace_manager.c1069
1 files changed, 1069 insertions, 0 deletions
diff --git a/src/identity/gnunet-identity-gtk_namespace_manager.c b/src/identity/gnunet-identity-gtk_namespace_manager.c
new file mode 100644
index 00000000..ca4a14c5
--- /dev/null
+++ b/src/identity/gnunet-identity-gtk_namespace_manager.c
@@ -0,0 +1,1069 @@
1/*
2 This file is part of GNUnet
3 (C) 2005-2013 Christian Grothoff (and other contributing authors)
4
5 GNUnet is free software; you can redistribute it and/or modify
6 it under the terms of the GNU General Public License as published
7 by the Free Software Foundation; either version 3, or (at your
8 option) any later version.
9
10 GNUnet is distributed in the hope that it will be useful, but
11 WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 General Public License for more details.
14
15 You should have received a copy of the GNU General Public License
16 along with GNUnet; see the file COPYING. If not, write to the
17 Free Software Foundation, Inc., 59 Temple Place - Suite 330,
18 Boston, MA 02111-1307, USA.
19*/
20
21/**
22 * @file src/fs/gnunet-fs-gtk_namespace_manager.c
23 * @author LRN
24 */
25#include "gnunet-fs-gtk_common.h"
26#include "gnunet-fs-gtk.h"
27#include <gnunet/gnunet_util_lib.h>
28#include <gnunet/gnunet_fs_service.h>
29
30struct GNUNET_GTK_NamespaceManagerContext
31{
32 GtkBuilder *builder;
33 GtkWidget *known_ns;
34 GtkWidget *ns_order;
35 GtkWidget *ns_details;
36 GtkTreeSelection *known_ns_sel;
37 GtkTreeSelection *ns_order_sel;
38 GtkTreeSelection *ns_details_sel;
39 GtkListStore *ns_order_store;
40 GtkListStore *known_ns_store;
41 GtkListStore *ns_details_store;
42 GtkWindow *namespace_manager;
43 GtkTreeViewColumn *order_rank;
44 GtkTreeViewColumn *order_name;
45 GtkTreeViewColumn *order_id;
46 GtkWidget *details_apply_button;
47 GtkWidget *details_delete_button;
48 int sort_direction;
49 GList *deleted_namespaces;
50 struct GNUNET_CONTAINER_MetaData *uneditable_md;
51 struct GNUNET_GTK_MainWindowContext *main_ctx;
52};
53
54#define GNUNET_GTK_KNOWN_NAMESPACES_IS_MINE_COLUMN 0
55#define GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN 1
56#define GNUNET_GTK_KNOWN_NAMESPACES_NAME_COLUMN 2
57#define GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_COLUMN 3
58#define GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN 4
59#define GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN 5
60#define GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN 6
61#define GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN 7
62
63#define GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN 0
64#define GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN 1
65#define GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN 2
66#define GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_BIN_COLUMN 3
67#define GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN 4
68
69#define GNUNET_GTK_NAMESPACE_DETAILS_PLUGIN_NAME_COLUMN 0
70#define GNUNET_GTK_NAMESPACE_DETAILS_TYPE_BIN_COLUMN 1
71#define GNUNET_GTK_NAMESPACE_DETAILS_TYPE_COLUMN 2
72#define GNUNET_GTK_NAMESPACE_DETAILS_FORMAT_COLUMN 3
73#define GNUNET_GTK_NAMESPACE_DETAILS_DATA_MIME_COLUMN 4
74#define GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN 5
75
76
77static void
78sort_order_list (struct GNUNET_GTK_NamespaceManagerContext *ctx,
79 int sort_column)
80{
81 int sorted = GNUNET_NO;
82 GtkTreeIter iter;
83 gint i;
84 gint row_count;
85 gint *row_indices, *row_ints;
86 gchar **row_strings;
87
88 ctx->sort_direction = ctx->sort_direction <= 0 ? 1 : 0;
89
90 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
91 ctx->ns_order_store), NULL);
92 if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
93 ctx->ns_order_store), &iter))
94 return;
95
96 row_indices = g_new0 (gint, row_count);
97 row_ints = g_new0 (gint, row_count);
98 row_strings = g_new0 (gchar *, row_count);
99
100 for (i = 0; i < row_count; i++)
101 {
102 int an_int;
103 char *a_string;
104 row_indices[i] = i;
105 switch (sort_column)
106 {
107 case GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN:
108 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &iter,
109 sort_column, &an_int, -1);
110 row_ints[i] = an_int;
111 row_strings[i] = NULL;
112 break;
113 case GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN:
114 case GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN:
115 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &iter,
116 sort_column, &a_string, -1);
117 row_strings[i] = a_string;
118 break;
119 default:
120 row_strings[i] = NULL;
121 break;
122 }
123 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
124 ctx->ns_order_store), &iter))
125 break;
126 }
127
128 while (sorted != GNUNET_YES)
129 {
130 sorted = GNUNET_YES;
131 for (i = 0; i < row_count - 1; i++)
132 {
133 int cmp_result;
134
135 switch (sort_column)
136 {
137 case GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN:
138 cmp_result = row_ints[i] <= row_ints[i + 1] ? 0 : 1;
139 break;
140 case GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN:
141 case GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN:
142 /* FIXME: name can be UTF-8-encoded, use UTF-8-aware comparison func */
143 cmp_result = strcmp (row_strings[i], row_strings[i + 1]);
144 break;
145 default:
146 GNUNET_break (0);
147 cmp_result = 0;
148 break;
149 }
150
151 if (((ctx->sort_direction <= 0) && (cmp_result <= 0)) ||
152 ((ctx->sort_direction > 0) && (cmp_result > 0)))
153 {
154 int tmp_int, tmp_index;
155 char *tmp_string;
156 tmp_index = row_indices[i];
157 tmp_int = row_ints[i];
158 tmp_string = row_strings[i];
159 row_indices[i] = row_indices[i + 1];
160 row_ints[i] = row_ints[i + 1];
161 row_strings[i] = row_strings[i + 1];
162 row_ints[i + 1] = tmp_int;
163 row_strings[i + 1] = tmp_string;
164 row_indices[i + 1] = tmp_index;
165 sorted = GNUNET_NO;
166 }
167 }
168 }
169
170 gtk_list_store_reorder (ctx->ns_order_store, row_indices);
171
172 g_free (row_indices);
173 for (i = 0; i < row_count; i++)
174 g_free (row_strings[i]);
175 g_free (row_strings);
176 g_free (row_ints);
177}
178
179
180void
181GNUNET_GTK_namespace_manager_namespace_order_column_clicked_cb (
182 GtkTreeViewColumn *treeviewcolumn, gpointer user_data)
183{
184 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
185 if (treeviewcolumn == ctx->order_rank)
186 {
187 sort_order_list (ctx, GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN);
188 }
189 else if (treeviewcolumn == ctx->order_name)
190 {
191 sort_order_list (ctx, GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN);
192 }
193 else if (treeviewcolumn == ctx->order_id)
194 {
195 sort_order_list (ctx, GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN);
196 }
197}
198
199
200void
201GNUNET_GTK_namespace_manager_known_namespaces_delete_button_clicked_cb (
202 GtkButton *button, gpointer user_data)
203{
204 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
205 GtkTreeIter iter;
206 struct GNUNET_FS_PseudonymIdentifier *nsid;
207 GtkTreeRowReference *order_row, *known_row;
208 struct GNUNET_CONTAINER_MetaData *md;
209
210 if (FALSE == gtk_tree_selection_get_selected (ctx->known_ns_sel, NULL, &iter))
211 return;
212
213 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
214 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
215 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, &order_row,
216 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &md,
217 -1);
218 /* Make sure the store does not contain references to freed objects */
219 gtk_list_store_set (ctx->known_ns_store, &iter,
220 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, NULL,
221 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, NULL,
222 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, NULL,
223 -1);
224 GNUNET_CONTAINER_meta_data_destroy (md);
225 if (order_row != NULL)
226 {
227 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (order_row, &iter))
228 {
229 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &iter,
230 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, &known_row, -1);
231 gtk_list_store_set (ctx->ns_order_store, &iter,
232 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, NULL, -1);
233 if (known_row != NULL)
234 gtk_tree_row_reference_free (known_row);
235 gtk_list_store_remove (ctx->ns_order_store, &iter);
236 }
237 gtk_tree_row_reference_free (order_row);
238 }
239 ctx->deleted_namespaces = g_list_prepend (ctx->deleted_namespaces, nsid);
240 gtk_list_store_remove (ctx->known_ns_store, &iter);
241
242 gtk_list_store_clear (ctx->ns_details_store);
243 GNUNET_CONTAINER_meta_data_destroy (ctx->uneditable_md);
244 ctx->uneditable_md = NULL;
245}
246
247
248void
249GNUNET_GTK_namespace_manager_known_namespaces_swap_rank_button_clicked_cb (
250 GtkButton *button, gpointer user_data)
251{
252 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
253 GtkTreeIter known_iter, order_iter;
254 struct GNUNET_CRYPTO_EccPublicKey *nsid;
255 int32_t old_rank, new_rank;
256 GtkTreeRowReference *order_row, *known_row;
257
258 if (FALSE == gtk_tree_selection_get_selected (ctx->known_ns_sel, NULL, &known_iter))
259 return;
260
261 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &known_iter,
262 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
263 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, &old_rank,
264 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, &order_row,
265 -1);
266
267 if (old_rank == 0)
268 new_rank = -1;
269 else
270 new_rank = -old_rank;
271
272 gtk_list_store_set (ctx->known_ns_store, &known_iter,
273 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, new_rank,
274 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, NULL,
275 -1);
276
277 if (order_row != NULL)
278 {
279 if (new_rank < 0)
280 {
281 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (order_row, &order_iter))
282 {
283 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &order_iter,
284 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, &known_row, -1);
285 gtk_list_store_remove (ctx->ns_order_store, &order_iter);
286 if (known_row != NULL)
287 gtk_tree_row_reference_free (known_row);
288 }
289 }
290 gtk_tree_row_reference_free (order_row);
291 }
292 if (new_rank >= 0)
293 {
294 char *name, *identifier;
295 if (order_row != NULL)
296 {
297 /* This should not happen */
298 GNUNET_break (0);
299 }
300 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &known_iter,
301 GNUNET_GTK_KNOWN_NAMESPACES_NAME_COLUMN, &name,
302 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_COLUMN, &identifier,
303 -1);
304 known_row = GNUNET_GTK_get_reference_from_iter (GTK_TREE_MODEL (
305 ctx->known_ns_store), &known_iter);
306 gtk_list_store_insert_with_values (ctx->ns_order_store, &order_iter, G_MAXINT,
307 GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN, new_rank,
308 GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN, name,
309 GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN, identifier,
310 GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_BIN_COLUMN, nsid,
311 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, known_row,
312 -1);
313 g_free (name);
314 g_free (identifier);
315 order_row = GNUNET_GTK_get_reference_from_iter (GTK_TREE_MODEL (ctx->ns_order_store),
316 &order_iter);
317 gtk_list_store_set (ctx->known_ns_store, &known_iter,
318 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, order_row, -1);
319 }
320}
321
322
323void
324GNUNET_GTK_namespace_manager_namespace_order_apply_clicked_cb (
325 GtkButton *button, gpointer user_data)
326{
327 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
328 GtkTreeIter iter;
329 gint i;
330 gint row_count;
331 GtkTreeRowReference *known_row;
332
333 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
334 ctx->ns_order_store), NULL);
335 if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
336 ctx->ns_order_store), &iter))
337 return;
338
339 for (i = 0; i < row_count; i++)
340 {
341 gtk_list_store_set (ctx->ns_order_store, &iter,
342 GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN, i, -1);
343 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &iter,
344 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, &known_row, -1);
345 if (known_row == NULL)
346 {
347 /* This is not supposed to happen. What to do? */
348 GNUNET_break (0);
349 }
350 else
351 {
352 GtkTreeIter known_iter;
353 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (known_row, &known_iter))
354 {
355 gtk_list_store_set (ctx->known_ns_store, &known_iter,
356 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, i,
357 -1);
358 }
359 }
360 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
361 ctx->ns_order_store), &iter))
362 break;
363 }
364}
365
366
367void
368GNUNET_GTK_namespace_manager_namespace_details_add_button_clicked_cb (
369 GtkButton *button, gpointer user_data)
370{
371 /* FIXME: add a row to the details list. Disabled at the moment, since
372 * metadata type selection is not implemented.
373 */
374}
375
376
377void
378GNUNET_GTK_namespace_manager_namespace_details_delete_button_clicked_cb (
379 GtkButton *button, gpointer user_data)
380{
381 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
382 GtkTreeIter iter;
383
384 if (FALSE == gtk_tree_selection_get_selected (ctx->ns_details_sel, NULL, &iter))
385 return;
386
387 gtk_list_store_remove (ctx->ns_details_store, &iter);
388 gtk_widget_set_sensitive (ctx->details_apply_button, TRUE);
389}
390
391
392void
393GNUNET_GTK_namespace_manager_namespace_details_apply_button_clicked_cb (
394 GtkButton *button, gpointer user_data)
395{
396 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
397 GtkTreeIter iter, known_iter;
398 gint i;
399 gint row_count;
400 struct GNUNET_CONTAINER_MetaData *md, *old_md;
401 char *plugin_name;
402 int type;
403 char *type_name;
404 int format;
405 char *data_mime_type;
406 char *data;
407
408 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
409 ctx->ns_details_store), NULL);
410 if ((row_count > 0) && (! gtk_tree_model_get_iter_first (
411 GTK_TREE_MODEL (ctx->ns_details_store), &iter)))
412 {
413 /* This should not happen */
414 return;
415 }
416
417 if (FALSE == gtk_tree_selection_get_selected (ctx->known_ns_sel, NULL,
418 &known_iter))
419 {
420 /* This should not happen */
421 return;
422 }
423
424 md = GNUNET_CONTAINER_meta_data_create ();
425
426 for (i = 0; i < row_count; i++)
427 {
428 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_details_store), &iter,
429 GNUNET_GTK_NAMESPACE_DETAILS_PLUGIN_NAME_COLUMN, &plugin_name,
430 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_BIN_COLUMN, &type,
431 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_COLUMN, &type_name,
432 GNUNET_GTK_NAMESPACE_DETAILS_FORMAT_COLUMN, &format,
433 GNUNET_GTK_NAMESPACE_DETAILS_DATA_MIME_COLUMN, &data_mime_type,
434 GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN, &data,
435 -1);
436 GNUNET_CONTAINER_meta_data_insert (md, plugin_name,
437 type, format, data_mime_type, data, strlen (data) + 1);
438 g_free (plugin_name);
439 g_free (type_name);
440 g_free (data_mime_type);
441 g_free (data);
442 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
443 ctx->ns_details_store), &iter))
444 break;
445 }
446 GNUNET_CONTAINER_meta_data_merge (md,
447 (const struct GNUNET_CONTAINER_MetaData *) ctx->uneditable_md);
448
449 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &known_iter,
450 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &old_md,
451 -1);
452 GNUNET_CONTAINER_meta_data_destroy (old_md);
453 gtk_list_store_set (ctx->known_ns_store, &known_iter,
454 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, md,
455 -1);
456 gtk_widget_set_sensitive (ctx->details_apply_button, FALSE);
457}
458
459
460void
461GNUNET_GTK_namespace_manager_name_text_editing_started_cb (
462 GtkCellRenderer *renderer, GtkCellEditable *editable, gchar *path,
463 gpointer user_data)
464{
465 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
466
467 if (GTK_IS_ENTRY (editable))
468 {
469 GtkTreePath *tree_path;
470 GtkTreeIter iter;
471 char *non_unique_name = NULL;
472 GtkEntry *entry = GTK_ENTRY (editable);
473
474 tree_path = gtk_tree_path_new_from_string (path);
475 if (tree_path != NULL)
476 {
477 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->known_ns_store),
478 &iter, tree_path))
479 {
480 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
481 GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN, &non_unique_name,
482 -1);
483 }
484 gtk_tree_path_free (tree_path);
485 }
486 if (non_unique_name == NULL)
487 {
488 gtk_cell_editable_editing_done (editable);
489 return;
490 }
491 gtk_entry_set_text (entry, non_unique_name);
492 g_free (non_unique_name);
493 }
494}
495
496
497void
498GNUNET_GTK_namespace_manager_name_text_edited_cb (
499 GtkCellRendererText *renderer, gchar *path, gchar *new_text,
500 gpointer user_data)
501{
502 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
503 char *unique_name;
504 GtkTreeRowReference *order_row;
505
506 if (strlen (new_text) == 0)
507 return;
508
509 GtkTreePath *tree_path;
510 GtkTreeIter iter;
511 tree_path = gtk_tree_path_new_from_string (path);
512 if (tree_path != NULL)
513 {
514 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->known_ns_store),
515 &iter, tree_path))
516 {
517 struct GNUNET_CRYPTO_EccPublicKey *nsid;
518 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
519 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
520 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, &order_row,
521 -1);
522
523 unique_name = GNUNET_FS_pseudonym_name_uniquify (
524 GNUNET_FS_GTK_get_configuration (), nsid, new_text, NULL);
525
526 gtk_list_store_set (ctx->known_ns_store, &iter,
527 GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN, new_text,
528 GNUNET_GTK_KNOWN_NAMESPACES_NAME_COLUMN, unique_name,
529 -1);
530
531 if (order_row != NULL)
532 {
533 GtkTreeIter order_iter;
534 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (order_row, &order_iter))
535 {
536 gtk_list_store_set (ctx->ns_order_store, &order_iter,
537 GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN, unique_name,
538 -1);
539 }
540 }
541
542 GNUNET_free (unique_name);
543 }
544 gtk_tree_path_free (tree_path);
545 }
546}
547
548
549void
550GNUNET_GTK_namespace_manager_namespace_details_type_text_edited_cb (
551 GtkCellRendererText *renderer, gchar *path, gchar *new_text,
552 gpointer user_data)
553{
554 /* Changing metadata type is more difficult than simply entering a
555 * new string, see publication editing dialog. So this is disabled
556 * for now. In fact, it's not going to be a Text renderer when it's done.
557 */
558 /*
559 struct GNUNET_GTK_NamespaceManagerContext *ctx = cls;
560 GtkTreeIter iter;
561 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->ns_details_store),
562 &iter, path))
563 {
564 gtk_list_store_set (ctx->ns_details_store, &iter,
565 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_COLUMN, new_text,
566 -1);
567 }
568 */
569}
570
571
572void
573GNUNET_GTK_namespace_manager_namespace_details_value_text_edited_cb (
574 GtkCellRendererText *renderer, gchar *path, gchar *new_text,
575 gpointer user_data)
576{
577 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
578 GtkTreePath *tree_path;
579 GtkTreeIter iter;
580 tree_path = gtk_tree_path_new_from_string (path);
581 if (tree_path != NULL)
582 {
583 if (gtk_tree_model_get_iter (GTK_TREE_MODEL (ctx->ns_details_store),
584 &iter, tree_path))
585 {
586 char *old_text;
587 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_details_store), &iter,
588 GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN, &old_text,
589 -1);
590 if (strcmp (old_text, new_text) != 0)
591 {
592 gtk_list_store_set (ctx->ns_details_store, &iter,
593 GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN, new_text,
594 -1);
595 gtk_widget_set_sensitive (ctx->details_apply_button, TRUE);
596 }
597 g_free (old_text);
598 }
599 gtk_tree_path_free (tree_path);
600 }
601}
602
603
604/**
605 * Iterator over all known pseudonyms.
606 * Populate "known ns" and "ns order" lists.
607 *
608 * @param cls closure
609 * @param pseudonym hash code of public key of pseudonym
610 * @param md meta data known about the pseudonym
611 * @param rating the local rating of the pseudonym
612 * @return GNUNET_OK to continue iteration, GNUNET_SYSERR to abort
613 */
614static int
615populate_known_ns_list (void *cls,
616 const struct GNUNET_CRYPTO_EccPublicKey *pseudonym,
617 const char *name, const char *unique_name,
618 const struct GNUNET_CONTAINER_MetaData *md,
619 int rating)
620{
621 struct GNUNET_GTK_NamespaceManagerContext *ctx = cls;
622 struct GNUNET_CRYPTO_EccPublicKey *nsid;
623 char buf[1024];
624 char *ret;
625 GtkTreeIter known_iter, order_iter;
626 struct GNUNET_CONTAINER_MetaData *md_copy;
627 char *non_null_name, *non_null_unique_name;
628
629 nsid = GNUNET_new (struct GNUNET_CRYPTO_EccPublicKey);
630 *nsid = *pseudonym;
631
632 ret = GNUNET_STRINGS_data_to_string (nsid,
633 sizeof (struct GNUNET_CRYPTO_EccPublicKey),
634 buf,
635 sizeof (buf));
636 GNUNET_assert (NULL != ret);
637 ret[0] = '\0';
638
639 GNUNET_FS_pseudonym_get_info (GNUNET_FS_GTK_get_configuration (),
640 nsid, NULL, NULL, &non_null_name, NULL);
641 non_null_unique_name = GNUNET_FS_pseudonym_name_uniquify (
642 GNUNET_FS_GTK_get_configuration (), nsid, non_null_name, NULL);
643
644 md_copy = GNUNET_CONTAINER_meta_data_duplicate (md);
645
646 gtk_list_store_insert_with_values (ctx->known_ns_store, &known_iter, G_MAXINT,
647 GNUNET_GTK_KNOWN_NAMESPACES_IS_MINE_COLUMN, FALSE,
648 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, rating,
649 GNUNET_GTK_KNOWN_NAMESPACES_NAME_COLUMN, non_null_unique_name,
650 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_COLUMN, buf,
651 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, nsid,
652 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, NULL,
653 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, md_copy,
654 GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN, non_null_name,
655 -1);
656
657 if (rating >= 0)
658 {
659 GtkTreeRowReference *rr = GNUNET_GTK_get_reference_from_iter (GTK_TREE_MODEL (
660 ctx->known_ns_store), &known_iter);
661 gtk_list_store_insert_with_values (ctx->ns_order_store, &order_iter, G_MAXINT,
662 GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN, rating,
663 GNUNET_GTK_NAMESPACE_ORDER_NAME_COLUMN, non_null_unique_name,
664 GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_COLUMN, buf,
665 GNUNET_GTK_NAMESPACE_ORDER_IDENTIFIER_BIN_COLUMN, nsid,
666 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, rr,
667 -1);
668 rr = GNUNET_GTK_get_reference_from_iter (GTK_TREE_MODEL (ctx->ns_order_store),
669 &order_iter);
670 gtk_list_store_set (ctx->known_ns_store, &known_iter,
671 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, rr, -1);
672 }
673 GNUNET_free (non_null_name);
674 GNUNET_free (non_null_unique_name);
675
676 return GNUNET_OK;
677}
678
679
680static void
681apply_known_ns_changes (struct GNUNET_GTK_NamespaceManagerContext *ctx)
682{
683 GtkTreeIter iter;
684 gint i;
685 gint row_count;
686 struct GNUNET_CRYPTO_EccPublicKey *nsid;
687 char *name;
688 int32_t rank;
689 struct GNUNET_CONTAINER_MetaData *md;
690
691 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
692 ctx->known_ns_store), NULL);
693 if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
694 ctx->known_ns_store), &iter))
695 return;
696
697 for (i = 0; i < row_count; i++)
698 {
699 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
700 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
701 GNUNET_GTK_KNOWN_NAMESPACES_NON_UNIQUE_NAME_COLUMN, &name,
702 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &md,
703 GNUNET_GTK_KNOWN_NAMESPACES_RANK_COLUMN, &rank,
704 -1);
705 GNUNET_FS_pseudonym_set_info (GNUNET_FS_GTK_get_configuration (),
706 nsid, name, md, rank);
707 g_free (name);
708 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
709 ctx->known_ns_store), &iter))
710 break;
711 }
712#if FIXME_NAMESPACE_REMOVAL
713 while (NULL != ctx->deleted_namespaces)
714 {
715 nsid = ctx->deleted_namespaces->data;
716 if (nsid)
717 {
718 GNUNET_FS_pseudonym_remove (GNUNET_FS_GTK_get_configuration (), nsid);
719 GNUNET_free (nsid);
720 }
721 ctx->deleted_namespaces = g_list_delete_link (ctx->deleted_namespaces, ctx->deleted_namespaces);
722 }
723#endif
724}
725
726
727static void
728free_lists_contents (struct GNUNET_GTK_NamespaceManagerContext *ctx)
729{
730 GtkTreeIter iter;
731 gint i;
732 gint row_count;
733 struct GNUNET_CRYPTO_EccPublicKey *nsid;
734 GtkTreeRowReference *order_row;
735 struct GNUNET_CONTAINER_MetaData *md;
736
737 row_count = gtk_tree_model_iter_n_children (GTK_TREE_MODEL (
738 ctx->known_ns_store), NULL);
739 if (! gtk_tree_model_get_iter_first (GTK_TREE_MODEL (
740 ctx->known_ns_store), &iter))
741 return;
742
743 for (i = 0; i < row_count; i++)
744 {
745 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
746 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &nsid,
747 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, &order_row,
748 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &md,
749 -1);
750 /* Make sure the store does not contain references to freed objects */
751 gtk_list_store_set (ctx->known_ns_store, &iter,
752 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, NULL,
753 GNUNET_GTK_KNOWN_NAMESPACES_ORDER_ROW_REFERENCE_COLUMN, NULL,
754 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, NULL,
755 -1);
756 if (order_row != NULL)
757 {
758 GtkTreeIter order_iter;
759 if (GNUNET_OK == GNUNET_GTK_get_iter_from_reference (order_row, &order_iter))
760 {
761 GtkTreeRowReference *known_row;
762 gtk_tree_model_get (GTK_TREE_MODEL (ctx->ns_order_store), &order_iter,
763 GNUNET_GTK_NAMESPACE_ORDER_KNOWN_ROW_REFERENCE_COLUMN, &known_row,
764 -1);
765 if (known_row != NULL)
766 gtk_tree_row_reference_free (known_row);
767 }
768 gtk_tree_row_reference_free (order_row);
769 }
770 GNUNET_CONTAINER_meta_data_destroy (md);
771 GNUNET_free (nsid);
772 if (TRUE != gtk_tree_model_iter_next (GTK_TREE_MODEL (
773 ctx->known_ns_store), &iter))
774 break;
775 }
776
777 gtk_list_store_clear (ctx->ns_order_store);
778 gtk_list_store_clear (ctx->known_ns_store);
779 gtk_list_store_clear (ctx->ns_details_store);
780 if (ctx->uneditable_md != NULL)
781 GNUNET_CONTAINER_meta_data_destroy (ctx->uneditable_md);
782}
783
784
785void
786GNUNET_GTK_namespace_manager_dialog_response_cb (GtkDialog *dialog,
787 gint response_id, gpointer user_data)
788{
789 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
790 switch (response_id)
791 {
792 case GTK_RESPONSE_APPLY:
793 case GTK_RESPONSE_OK:
794 apply_known_ns_changes (ctx);
795 GNUNET_GTK_main_window_refresh_ns_list (ctx->main_ctx);
796 break;
797 default:
798 break;
799 }
800 switch (response_id)
801 {
802 case GTK_RESPONSE_APPLY:
803 break;
804 case GTK_RESPONSE_OK:
805 case GTK_RESPONSE_CANCEL:
806 default:
807 free_lists_contents (ctx);
808 gtk_widget_destroy (GTK_WIDGET (ctx->namespace_manager));
809 GNUNET_free (ctx);
810 }
811}
812
813
814static gboolean
815mark_as_mine (GtkTreeModel *model, GtkTreePath *path, GtkTreeIter *iter,
816 gpointer data)
817{
818 const struct GNUNET_CRYPTO_EccPublicKey *mine_id = data;
819 const struct GNUNET_CRYPTO_EccPublicKey *ns_id;
820
821 gtk_tree_model_get (model, iter,
822 GNUNET_GTK_KNOWN_NAMESPACES_IDENTIFIER_BIN_COLUMN, &ns_id, -1);
823
824 if (memcmp (ns_id, mine_id, sizeof (struct GNUNET_CRYPTO_EccPublicKey)) != 0)
825 return FALSE;
826
827 gtk_list_store_set (GTK_LIST_STORE (model), iter,
828 GNUNET_GTK_KNOWN_NAMESPACES_IS_MINE_COLUMN, TRUE, -1);
829 return TRUE;
830}
831
832
833/**
834 * Callback with information about local (!) namespaces.
835 * Contains the names of the local namespace and the global
836 * ID.
837 *
838 * @param cls closure
839 * @param name human-readable identifier of the namespace
840 * @param id hash identifier for the namespace
841 */
842static void
843mark_namespaces_as_mine (void *cls, const char *name,
844 const struct GNUNET_CRYPTO_EccPublicKey *id)
845{
846 struct GNUNET_GTK_NamespaceManagerContext *ctx = cls;
847
848 gtk_tree_model_foreach (GTK_TREE_MODEL (ctx->known_ns_store), mark_as_mine,
849 (gpointer) id);
850}
851
852
853/**
854 * Type of a function that libextractor calls for each
855 * meta data item found.
856 *
857 * @param cls closure (user-defined)
858 * @param plugin_name name of the plugin that produced this value;
859 * special values can be used (i.e. '&lt;zlib&gt;' for zlib being
860 * used in the main libextractor library and yielding
861 * meta data).
862 * @param type libextractor-type describing the meta data
863 * @param format basic format information about data
864 * @param data_mime_type mime-type of data (not of the original file);
865 * can be NULL (if mime-type is not known)
866 * @param data actual meta-data found
867 * @param data_len number of bytes in data
868 * @return 0 to continue extracting, 1 to abort
869 */
870static int
871populate_details_list (void *cls, const char *plugin_name,
872 enum EXTRACTOR_MetaType type, enum EXTRACTOR_MetaFormat format,
873 const char *data_mime_type, const char *data, size_t data_len)
874{
875 struct GNUNET_GTK_NamespaceManagerContext *ctx = cls;
876 const char *type_name;
877 char *data_utf8;
878
879 if (format == EXTRACTOR_METAFORMAT_UTF8 ||
880 format == EXTRACTOR_METAFORMAT_C_STRING)
881 {
882 type_name = EXTRACTOR_metatype_to_string (type);
883 /* TODO: translate type_name using dgettext? */
884 data_utf8 = GNUNET_FS_GTK_dubious_meta_to_utf8 (format, data, data_len);
885 if (data != NULL)
886 {
887 gtk_list_store_insert_with_values (ctx->ns_details_store, NULL, G_MAXINT,
888 GNUNET_GTK_NAMESPACE_DETAILS_PLUGIN_NAME_COLUMN, plugin_name,
889 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_BIN_COLUMN, type,
890 GNUNET_GTK_NAMESPACE_DETAILS_TYPE_COLUMN, type_name,
891 GNUNET_GTK_NAMESPACE_DETAILS_FORMAT_COLUMN,
892 EXTRACTOR_METAFORMAT_UTF8,
893 GNUNET_GTK_NAMESPACE_DETAILS_DATA_MIME_COLUMN, data_mime_type,
894 GNUNET_GTK_NAMESPACE_DETAILS_VALUE_COLUMN, data_utf8,
895 -1);
896 GNUNET_free (data_utf8);
897 return 0;
898 }
899 }
900 GNUNET_CONTAINER_meta_data_insert (ctx->uneditable_md,
901 plugin_name, type, format, data_mime_type, data, data_len);
902 return 0;
903}
904
905
906static void
907ns_details_selection_changed (GtkTreeSelection *treeselection,
908 gpointer user_data)
909{
910 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
911 GtkTreeIter iter;
912
913 if (FALSE == gtk_tree_selection_get_selected (ctx->ns_details_sel, NULL, &iter))
914 {
915 gtk_widget_set_sensitive (ctx->details_delete_button, FALSE);
916 return;
917 }
918
919 gtk_widget_set_sensitive (ctx->details_delete_button, TRUE);
920}
921
922
923static void
924known_ns_selection_changed (GtkTreeSelection *treeselection,
925 gpointer user_data)
926{
927 struct GNUNET_GTK_NamespaceManagerContext *ctx = user_data;
928 GtkTreeIter iter;
929 const struct GNUNET_CONTAINER_MetaData *md;
930
931 if (FALSE == gtk_tree_selection_get_selected (ctx->known_ns_sel, NULL, &iter))
932 return;
933
934 gtk_tree_model_get (GTK_TREE_MODEL (ctx->known_ns_store), &iter,
935 GNUNET_GTK_KNOWN_NAMESPACES_METADATA_COLUMN, &md,
936 -1);
937 if (ctx->uneditable_md != NULL)
938 GNUNET_CONTAINER_meta_data_clear (ctx->uneditable_md);
939 else
940 ctx->uneditable_md = GNUNET_CONTAINER_meta_data_create ();
941 gtk_list_store_clear (ctx->ns_details_store);
942 gtk_widget_set_sensitive (ctx->details_apply_button, FALSE);
943 if (NULL != md)
944 GNUNET_CONTAINER_meta_data_iterate ((const struct GNUNET_CONTAINER_MetaData *) md,
945 populate_details_list, ctx);
946 else
947 GNUNET_break (0);
948 gtk_widget_set_sensitive (ctx->details_apply_button, FALSE);
949}
950
951
952GtkWindow *
953GNUNET_GTK_namespace_manager_open (struct GNUNET_GTK_MainWindowContext *main_ctx)
954{
955 struct GNUNET_GTK_NamespaceManagerContext *ctx;
956
957 ctx = GNUNET_new (struct GNUNET_GTK_NamespaceManagerContext);
958 ctx->builder = GNUNET_GTK_get_new_builder ("gnunet_fs_gtk_namespace_manager.glade", ctx);
959 if (ctx->builder == NULL)
960 {
961 GNUNET_break (0);
962 GNUNET_free (ctx);
963 return NULL;
964 }
965
966 ctx->main_ctx = main_ctx;
967
968 /* initialize widget references */
969 ctx->known_ns = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
970 "GNUNET_GTK_namespace_manager_known_treeview"));
971 ctx->ns_order = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
972 "GNUNET_GTK_namespace_manager_namespace_order_treeview"));
973 ctx->ns_details = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
974 "GNUNET_GTK_namespace_manager_namespace_details_treeview"));
975 ctx->known_ns_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (
976 ctx->known_ns));
977 ctx->ns_order_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (
978 ctx->ns_order));
979 ctx->ns_details_sel = gtk_tree_view_get_selection (GTK_TREE_VIEW (
980 ctx->ns_details));
981 ctx->ns_order_store = GTK_LIST_STORE (gtk_tree_view_get_model (
982 GTK_TREE_VIEW (ctx->ns_order)));
983 ctx->known_ns_store = GTK_LIST_STORE (gtk_tree_view_get_model (
984 GTK_TREE_VIEW (ctx->known_ns)));
985 ctx->ns_details_store = GTK_LIST_STORE (gtk_tree_view_get_model (
986 GTK_TREE_VIEW (ctx->ns_details)));
987 ctx->namespace_manager = GTK_WINDOW (gtk_builder_get_object (
988 ctx->builder, "GNUNET_GTK_namespace_manager_dialog"));
989 ctx->details_apply_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
990 "GNUNET_GTK_namespace_manager_namespace_details_apply_button"));
991 ctx->details_delete_button = GTK_WIDGET (gtk_builder_get_object (ctx->builder,
992 "GNUNET_GTK_namespace_manager_namespace_details_delete_button"));
993 ctx->order_rank = gtk_tree_view_get_column (GTK_TREE_VIEW (ctx->ns_order), 0);
994 ctx->order_name = gtk_tree_view_get_column (GTK_TREE_VIEW (ctx->ns_order), 1);
995 ctx->order_id = gtk_tree_view_get_column (GTK_TREE_VIEW (ctx->ns_order), 2);
996
997 /* connect signals; FIXME-GTK3: these could be connected with (modern) Glade */
998 g_signal_connect (G_OBJECT (ctx->known_ns_sel), "changed",
999 G_CALLBACK (known_ns_selection_changed), ctx);
1000 g_signal_connect (G_OBJECT (ctx->ns_details_sel), "changed",
1001 G_CALLBACK (ns_details_selection_changed), ctx);
1002
1003 /* populate namespace model */
1004 (void) GNUNET_FS_pseudonym_list_all (GNUNET_FS_GTK_get_configuration (),
1005 populate_known_ns_list, ctx);
1006
1007#if FIXME_USE_IDENTITY_SERVICE
1008 /* mark our own namespaces as such */
1009 GNUNET_FS_namespace_list (GNUNET_FS_GTK_get_fs_handle (),
1010 &mark_namespaces_as_mine, ctx);
1011#endif
1012
1013 /* sort namespace order list by rank (initially) */
1014 sort_order_list (ctx, GNUNET_GTK_NAMESPACE_ORDER_RANK_COLUMN);
1015
1016 gtk_widget_set_sensitive (ctx->details_apply_button, FALSE);
1017
1018 /* show dialog */
1019 gtk_window_present (ctx->namespace_manager);
1020 return ctx->namespace_manager;
1021}
1022
1023
1024static void
1025ns_manager_deleted (GtkWindow *object, gpointer user_data)
1026{
1027 struct GNUNET_GTK_MainWindowContext *ctx = user_data;
1028 g_signal_handler_disconnect (object, ctx->ns_manager_delete_handler_id);
1029 g_object_unref (G_OBJECT (ctx->ns_manager));
1030 ctx->ns_manager = NULL;
1031 ctx->ns_manager_delete_handler_id = 0;
1032 return;
1033}
1034
1035
1036void
1037GNUNET_GTK_open_ns_manager (struct GNUNET_GTK_MainWindowContext *ctx)
1038{
1039 if (ctx->ns_manager != NULL)
1040 {
1041 gtk_window_present (ctx->ns_manager);
1042 return;
1043 }
1044
1045 ctx->ns_manager = GNUNET_GTK_namespace_manager_open (ctx);
1046 if (ctx->ns_manager == NULL)
1047 return;
1048
1049 g_object_ref (G_OBJECT (ctx->ns_manager));
1050 ctx->ns_manager_delete_handler_id = g_signal_connect (G_OBJECT (ctx->ns_manager), "destroy", G_CALLBACK (ns_manager_deleted), ctx);
1051}
1052
1053
1054void
1055GNUNET_GTK_main_menu_file_manage_pseudonyms_activate_cb (GtkMenuItem *menuitem,
1056 gpointer user_data)
1057{
1058 GNUNET_GTK_open_ns_manager (user_data);
1059}
1060
1061
1062void
1063namespace_selector_manage_namespaces_button_clicked_cb (GtkButton *button, gpointer user_data)
1064{
1065 GNUNET_GTK_open_ns_manager (user_data);
1066}
1067
1068
1069/* end of gnunet-fs-gtk_namespace_manager.c */
generated by cgit v1.2.3 (git 2.39.1) at 2025-01-13 01:08:56 +0000