?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Updated Slovenian translation
[nautilus.git] / libnautilus-private / nautilus-metafile.c
blob6797626ac3561f727e32f998f6822a071dc2c294
1 /* -*- Mode: C; indent-tabs-mode: t; c-basic-offset: 8; tab-width: 8 -*-*/
2
3 /* nautilus-metafile.c - server side of Nautilus::Metafile
4 *
5 * Copyright (C) 2001 Eazel, Inc.
6 * Copyright (C) 2001-2005 Free Software Foundation, Inc.
7 *
8 * This library is free software; you can redistribute it and/or
9 * modify it under the terms of the GNU Library General Public
10 * License as published by the Free Software Foundation; either
11 * version 2 of the License, or (at your option) any later version.
12 *
13 * This library is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 * Library General Public License for more details.
17 *
18 * You should have received a copy of the GNU Library General Public
19 * License along with this library; if not, write to the
20 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
21 * Boston, MA 02111-1307, USA.
22 */
23
24 #include <config.h>
25 #include "nautilus-metafile.h"
26
27 #include "nautilus-directory.h"
28 #include "nautilus-directory.h"
29 #include "nautilus-file-private.h"
30 #include "nautilus-file-utilities.h"
31 #include "nautilus-global-preferences.h"
32 #include "nautilus-metadata.h"
33 #include "nautilus-thumbnails.h"
34 #include <eel/eel-glib-extensions.h>
35 #include <eel/eel-gtk-macros.h>
36 #include <eel/eel-string.h>
37 #include <eel/eel-vfs-extensions.h>
38 #include <eel/eel-xml-extensions.h>
39 #include <glib/gurifuncs.h>
40 #include <libxml/parser.h>
41 #include <gtk/gtkmain.h>
42 #include <stdlib.h>
43 #include <time.h>
44 #include <unistd.h>
45
46 #define METAFILE_XML_VERSION "1.0"
47 #define METAFILE_PERMISSIONS 0600
48 #define METAFILES_DIRECTORY_NAME "metafiles"
49
50 enum {
51 CHANGED,
52 READY,
53 LAST_SIGNAL
54 };
55
56 static guint signals[LAST_SIGNAL] = { 0 };
57
58 /* TODO asynchronous copying/moving of metadata
59 *
60 * - potential metadata loss when a deletion is scheduled, and new metadata is copied to
61 * this location before the old deletion is consumed
62 *
63 * - if metafile read fails, and a file from that metafile is scheduled for a copy/move operation,
64 * its associated operations are not removed from pending_copies
65 *
66 * */
67
68 static char *get_file_metadata (NautilusMetafile *metafile,
69 const char *file_name,
70 const char *key,
71 const char *default_metadata);
72 static GList *get_file_metadata_list (NautilusMetafile *metafile,
73 const char *file_name,
74 const char *list_key,
75 const char *list_subkey);
76 static gboolean set_file_metadata (NautilusMetafile *metafile,
77 const char *file_name,
78 const char *key,
79 const char *default_metadata,
80 const char *metadata);
81 static gboolean set_file_metadata_list (NautilusMetafile *metafile,
82 const char *file_name,
83 const char *list_key,
84 const char *list_subkey,
85 GList *list);
86 static void rename_file_metadata (NautilusMetafile *metafile,
87 const char *old_file_name,
88 const char *new_file_name);
89 static void copy_file_metadata (NautilusMetafile *source_metafile,
90 const char *source_file_name,
91 NautilusMetafile *destination_metafile,
92 const char *destination_file_name);
93 static void real_copy_file_metadata (NautilusMetafile *source_metafile,
94 const char *source_file_name,
95 NautilusMetafile *destination_metafile,
96 const char *destination_file_name);
97 static void remove_file_metadata (NautilusMetafile *metafile,
98 const char *file_name);
99 static void real_remove_file_metadata (NautilusMetafile *metafile,
100 const char *file_name);
101 static void call_metafile_changed_for_one_file (NautilusMetafile *metafile,
102 const char *file_name);
103 static void metafile_read_restart (NautilusMetafile *metafile);
104 static void metafile_read_start (NautilusMetafile *metafile);
105 static void metafile_write_start (NautilusMetafile *metafile);
106 static void directory_request_write_metafile (NautilusMetafile *metafile);
107 static void metafile_free_metadata (NautilusMetafile *metafile);
108 static void metafile_read_cancel (NautilusMetafile *metafile);
109 static void async_read_cancel (NautilusMetafile *metafile);
110 static void set_metafile_contents (NautilusMetafile *metafile,
111 xmlDocPtr metafile_contents);
112
113 typedef struct MetafileReadState {
114 NautilusMetafile *metafile;
115 GCancellable *cancellable;
116 } MetafileReadState;
117
118 typedef struct MetafileWriteState {
119 xmlChar *buffer;
120 goffset size;
121 gboolean write_again;
122 } MetafileWriteState;
123
124 struct _NautilusMetafile {
125 GObject parent_slot;
126
127 gboolean is_read;
128
129 xmlDoc *xml;
130 GHashTable *node_hash;
131 GHashTable *changes;
132
133 /* State for reading and writing metadata. */
134 MetafileReadState *read_state;
135 guint write_idle_id;
136 MetafileWriteState *write_state;
137
138 GList *monitors;
139
140 char *private_uri;
141 char *directory_uri;
142 };
143
144 static GHashTable *metafiles;
145
146 G_DEFINE_TYPE (NautilusMetafile, nautilus_metafile, G_TYPE_OBJECT);
147
148 static void
149 nautilus_metafile_init (NautilusMetafile *metafile)
150 {
151 metafile->node_hash = g_hash_table_new (g_str_hash, g_str_equal);
152
153 }
154
155 static void
156 finalize (GObject *object)
157 {
158 NautilusMetafile *metafile;
159
160 metafile = NAUTILUS_METAFILE (object);
161
162 g_assert (metafile->write_state == NULL);
163 async_read_cancel (metafile);
164 g_assert (metafile->read_state == NULL);
165
166 g_hash_table_remove (metafiles, metafile->directory_uri);
167
168 metafile_free_metadata (metafile);
169 g_hash_table_destroy (metafile->node_hash);
170
171 g_assert (metafile->write_idle_id == 0);
172
173 g_free (metafile->private_uri);
174 g_free (metafile->directory_uri);
175
176 G_OBJECT_CLASS (nautilus_metafile_parent_class)->finalize (object);
177 }
178
179 static char *
180 escape_slashes (const char *str)
181 {
182 int n_reserved;
183 const char *p;
184 char *escaped, *e;
185
186 n_reserved = 0;
187 for (p = str; *p != 0; p++) {
188 if (*p == '%' || *p == '/') {
189 n_reserved++;
190 }
191 }
192
193 escaped = g_malloc (strlen (str) + 2*n_reserved + 1);
194
195 e = escaped;
196
197 for (p = str; *p != 0; p++) {
198 if (*p == '%') {
199 *e++ = '%';
200 *e++ = '2';
201 *e++ = '5';
202 } else if (*p == '/') {
203 *e++ = '%';
204 *e++ = '2';
205 *e++ = 'F';
206 } else {
207 *e++ = *p;
208 }
209 }
210 *e = 0;
211
212 return escaped;
213 }
214
215
216 static char *
217 construct_private_metafile_uri (const char *uri)
218 {
219 char *user_directory, *metafiles_directory;
220 char *escaped_uri, *file_name;
221 char *alternate_path, *alternate_uri;
222
223 /* Ensure that the metafiles directory exists. */
224 user_directory = nautilus_get_user_directory ();
225 metafiles_directory = g_build_filename (user_directory, METAFILES_DIRECTORY_NAME, NULL);
226 g_free (user_directory);
227 mkdir (metafiles_directory, 0700);
228
229 /* Construct a file name from the URI. */
230 escaped_uri = escape_slashes (uri);
231 file_name = g_strconcat (escaped_uri, ".xml", NULL);
232 g_free (escaped_uri);
233
234 /* Construct a URI for something in the "metafiles" directory. */
235 alternate_path = g_build_filename (metafiles_directory, file_name, NULL);
236 g_free (metafiles_directory);
237 g_free (file_name);
238 alternate_uri = g_filename_to_uri (alternate_path, NULL, NULL);
239 g_free (alternate_path);
240
241 return alternate_uri;
242 }
243
244 static void
245 nautilus_metafile_set_directory_uri (NautilusMetafile *metafile,
246 const char *directory_uri)
247 {
248 if (eel_strcmp (metafile->directory_uri, directory_uri) == 0) {
249 return;
250 }
251
252 g_free (metafile->directory_uri);
253 metafile->directory_uri = g_strdup (directory_uri);
254
255 g_free (metafile->private_uri);
256 metafile->private_uri
257 = construct_private_metafile_uri (directory_uri);
258 }
259
260 static NautilusMetafile *
261 nautilus_metafile_new (const char *directory_uri)
262 {
263 NautilusMetafile *metafile;
264
265 metafile = NAUTILUS_METAFILE (g_object_new (NAUTILUS_TYPE_METAFILE, NULL));
266
267 nautilus_metafile_set_directory_uri (metafile, directory_uri);
268
269 return metafile;
270 }
271
272 NautilusMetafile *
273 nautilus_metafile_get_for_uri (const char *directory_uri)
274 {
275 NautilusMetafile *metafile;
276 char *canonical_uri;
277 GFile *file;
278
279 g_return_val_if_fail (directory_uri != NULL, NULL);
280
281 if (metafiles == NULL) {
282 metafiles = eel_g_hash_table_new_free_at_exit
283 (g_str_hash, g_str_equal, __FILE__ ": metafiles");
284 }
285
286
287 file = g_file_new_for_uri (directory_uri);
288 canonical_uri = g_file_get_uri (file);
289 g_object_unref (file);
290
291 metafile = g_hash_table_lookup (metafiles, canonical_uri);
292
293 if (metafile != NULL) {
294 g_object_ref (metafile);
295 } else {
296 metafile = nautilus_metafile_new (canonical_uri);
297
298 g_assert (strcmp (metafile->directory_uri, canonical_uri) == 0);
299
300 g_hash_table_insert (metafiles,
301 metafile->directory_uri,
302 metafile);
303 }
304
305 g_free (canonical_uri);
306
307 return metafile;
308 }
309
310 static GList *pending_copies;
311
312 typedef struct {
313 NautilusMetafile *source_metafile;
314 char *source_file_name;
315 NautilusMetafile *destination_metafile;
316 char *destination_file_name;
317 } NautilusMetadataCopy;
318
319 static gboolean
320 nautilus_metadata_copy_equal (const NautilusMetadataCopy *a,
321 const NautilusMetadataCopy *b)
322 {
323 return (b->source_metafile == a->source_metafile)
324 && (b->destination_metafile == a->destination_metafile)
325 && (strcmp (a->source_file_name, b->source_file_name) == 0)
326 && (strcmp (a->destination_file_name, b->destination_file_name) == 0);
327 }
328
329 static NautilusMetadataCopy *
330 nautilus_metadata_get_scheduled_copy (NautilusMetafile *source_metafile,
331 const char *source_file_name,
332 NautilusMetafile *destination_metafile,
333 const char *destination_file_name)
334 {
335 NautilusMetadataCopy key, *copy;
336 GList *l;
337
338 key.source_metafile = source_metafile;
339 key.source_file_name = (char *) source_file_name;
340 key.destination_metafile = destination_metafile;
341 key.destination_file_name = (char *) destination_file_name;
342
343 for (l = pending_copies; l != NULL; l = l->next) {
344 copy = l->data;
345
346 if (nautilus_metadata_copy_equal (l->data, &key)) {
347 return copy;
348 }
349 }
350
351 return NULL;
352 }
353
354 static gboolean
355 nautilus_metadata_has_scheduled_copy (NautilusMetafile *source_metafile,
356 const char *source_file_name)
357 {
358 NautilusMetadataCopy *copy;
359 GList *l;
360
361 for (l = pending_copies; l != NULL; l = l->next) {
362 copy = l->data;
363
364 if ((copy->source_metafile == source_metafile) &&
365 (strcmp (copy->source_file_name, source_file_name) == 0)) {
366 return TRUE;
367 }
368 }
369
370 return FALSE;
371 }
372
373 static void
374 nautilus_metadata_schedule_copy (NautilusMetafile *source_metafile,
375 const char *source_file_name,
376 NautilusMetafile *destination_metafile,
377 const char *destination_file_name)
378 {
379 NautilusMetadataCopy *copy;
380
381 g_assert (!source_metafile->is_read || !destination_metafile->is_read);
382
383 copy = nautilus_metadata_get_scheduled_copy (source_metafile,
384 source_file_name,
385 destination_metafile,
386 destination_file_name);
387 if (copy == NULL) {
388 copy = g_malloc (sizeof (NautilusMetadataCopy));
389 copy->source_metafile = g_object_ref (source_metafile);
390 copy->source_file_name = g_strdup (source_file_name);
391 copy->destination_metafile = g_object_ref (destination_metafile);
392 copy->destination_file_name = g_strdup (destination_file_name);
393
394 pending_copies = g_list_prepend (pending_copies, copy);
395
396 metafile_read_start (source_metafile);
397 metafile_read_start (destination_metafile);
398 }
399 }
400
401 static void
402 nautilus_metadata_process_ready_copies (void)
403 {
404 NautilusMetadataCopy *copy;
405 GList *l, *next;
406
407 l = pending_copies;
408 while (l != NULL) {
409 copy = l->data;
410
411 next = l->next;
412
413 if (copy->source_metafile->is_read &&
414 copy->destination_metafile->is_read) {
415 real_copy_file_metadata (copy->source_metafile, copy->source_file_name,
416 copy->destination_metafile, copy->destination_file_name);
417
418 g_object_unref (copy->source_metafile);
419 g_free (copy->source_file_name);
420 g_object_unref (copy->destination_metafile);
421 g_free (copy->destination_file_name);
422 g_free (copy);
423
424 pending_copies = g_list_delete_link (pending_copies, l);
425 }
426
427 l = next;
428 }
429 }
430
431 static GList *pending_removals;
432
433 typedef struct {
434 NautilusMetafile *metafile;
435 char *file_name;
436 } NautilusMetadataRemoval;
437
438 static gboolean
439 nautilus_metadata_removal_equal (const NautilusMetadataRemoval *a,
440 const NautilusMetadataRemoval *b)
441 {
442 return ((b->metafile == a->metafile) &&
443 (strcmp (a->file_name, b->file_name) == 0));
444 }
445
446 static NautilusMetadataRemoval *
447 nautilus_metadata_get_scheduled_removal (NautilusMetafile *metafile,
448 const char *file_name)
449 {
450 NautilusMetadataRemoval key, *removal;
451 GList *l;
452
453 key.metafile = metafile;
454 key.file_name = (char *) file_name;
455
456 for (l = pending_removals; l != NULL; l = l->next) {
457 removal = l->data;
458
459 if (nautilus_metadata_removal_equal (l->data, &key)) {
460 return removal;
461 }
462 }
463
464 return NULL;
465 }
466
467 static void
468 nautilus_metadata_schedule_removal (NautilusMetafile *metafile,
469 const char *file_name)
470 {
471 NautilusMetadataRemoval *removal;
472
473 g_assert (nautilus_metadata_has_scheduled_copy (metafile, file_name));
474
475 removal = nautilus_metadata_get_scheduled_removal (metafile, file_name);
476 if (removal == NULL) {
477 removal = g_malloc (sizeof (NautilusMetadataRemoval));
478 removal->metafile = g_object_ref (metafile);
479 removal->file_name = g_strdup (file_name);
480
481 pending_removals = g_list_prepend (pending_removals, removal);
482 }
483 }
484
485 static void
486 nautilus_metadata_process_ready_removals (void)
487 {
488 NautilusMetadataRemoval *removal;
489 GList *l, *next;
490
491 l = pending_removals;
492 while (l != NULL) {
493 removal = l->data;
494
495 next = l->next;
496
497 if (!nautilus_metadata_has_scheduled_copy (removal->metafile, removal->file_name)) {
498 real_remove_file_metadata (removal->metafile, removal->file_name);
499
500 pending_removals = g_list_delete_link (pending_removals, l);
501
502 g_object_unref (removal->metafile);
503 g_free (removal->file_name);
504 }
505
506 l = next;
507 }
508 }
509
510 /* FIXME
511 * Right now we only limit the number of conccurrent reads.
512 * We may want to consider limiting writes as well.
513 */
514
515 static int num_reads_in_progress;
516 static GList *pending_reads;
517
518 #if 0
519 #define DEBUG_METADATA_IO
520 #endif
521
522 static void
523 schedule_next_read (void)
524 {
525 const int kMaxAsyncReads = 10;
526
527 GList* node;
528
529 #ifdef DEBUG_METADATA_IO
530 g_message ("schedule_next_read: %d pending reads, %d reads in progress",
531 g_list_length (pending_reads), num_reads_in_progress);
532 #endif
533
534 if (pending_reads != NULL && num_reads_in_progress <= kMaxAsyncReads) {
535 node = pending_reads;
536 pending_reads = g_list_remove_link (pending_reads, node);
537 #ifdef DEBUG_METADATA_IO
538 g_message ("schedule_next_read: %s", NAUTILUS_METAFILE (node->data)->details->directory_uri);
539 #endif
540 metafile_read_start (node->data);
541 g_list_free_1 (node);
542 ++num_reads_in_progress;
543 }
544 }
545
546 static void
547 async_read_start (NautilusMetafile *metafile)
548 {
549 if (metafile->is_read ||
550 metafile->read_state != NULL) {
551 return;
552 }
553 #ifdef DEBUG_METADATA_IO
554 g_message ("async_read_start: %s", metafile->directory_uri);
555 #endif
556 pending_reads = g_list_prepend (pending_reads, metafile);
557 schedule_next_read ();
558 }
559
560 static void
561 async_read_done (NautilusMetafile *metafile)
562 {
563 #ifdef DEBUG_METADATA_IO
564 g_message ("async_read_done: %s", metafile->directory_uri);
565 #endif
566 --num_reads_in_progress;
567 schedule_next_read ();
568 }
569
570 static void
571 async_read_cancel (NautilusMetafile *metafile)
572 {
573 GList* node;
574
575 #ifdef DEBUG_METADATA_IO
576 g_message ("async_read_cancel: %s", metafile->directory_uri);
577 #endif
578 node = g_list_find (pending_reads, metafile);
579
580 if (node != NULL) {
581 pending_reads = g_list_remove_link (pending_reads, node);
582 g_list_free_1 (node);
583 }
584
585 if (metafile->read_state != NULL) {
586 metafile_read_cancel (metafile);
587 async_read_done (metafile);
588 }
589
590 }
591
592 gboolean
593 nautilus_metafile_is_read (NautilusMetafile *metafile)
594 {
595 return metafile->is_read;
596 }
597
598 char *
599 nautilus_metafile_get (NautilusMetafile *metafile,
600 const char *file_name,
601 const char *key,
602 const char *default_value)
603 {
604 return get_file_metadata (metafile, file_name, key, default_value);
605 }
606
607 GList *
608 nautilus_metafile_get_list (NautilusMetafile *metafile,
609 const char *file_name,
610 const char *list_key,
611 const char *list_subkey)
612 {
613 return get_file_metadata_list (metafile, file_name, list_key, list_subkey);
614 }
615
616
617 void
618 nautilus_metafile_set (NautilusMetafile *metafile,
619 const char *file_name,
620 const char *key,
621 const char *default_value,
622 const char *metadata)
623 {
624 if (set_file_metadata (metafile, file_name, key, default_value, metadata)) {
625 call_metafile_changed_for_one_file (metafile, file_name);
626 }
627 }
628
629 void
630 nautilus_metafile_set_list (NautilusMetafile *metafile,
631 const char *file_name,
632 const char *list_key,
633 const char *list_subkey,
634 GList *list)
635 {
636 if (set_file_metadata_list (metafile, file_name, list_key, list_subkey, list)) {
637 call_metafile_changed_for_one_file (metafile, file_name);
638 }
639 }
640
641 void
642 nautilus_metafile_copy (NautilusMetafile *source_metafile,
643 const char *source_file_name,
644 const char *destination_directory_uri,
645 const char *destination_file_name)
646 {
647 NautilusMetafile *destination_metafile;
648
649 destination_metafile = nautilus_metafile_get_for_uri (destination_directory_uri);
650
651 copy_file_metadata (source_metafile, source_file_name,
652 destination_metafile, destination_file_name);
653
654 g_object_unref (destination_metafile);
655 }
656
657
658 void
659 nautilus_metafile_remove (NautilusMetafile *metafile,
660 const char *file_name)
661 {
662 remove_file_metadata (metafile, file_name);
663 }
664
665 void
666 nautilus_metafile_rename (NautilusMetafile *metafile,
667 const char *old_file_name,
668 const char *new_file_name)
669 {
670 rename_file_metadata (metafile, old_file_name, new_file_name);
671 }
672
673 void
674 nautilus_metafile_rename_directory (NautilusMetafile *metafile,
675 const char *new_directory_uri)
676 {
677 nautilus_metafile_set_directory_uri (metafile, new_directory_uri);
678 }
679
680 void
681 nautilus_metafile_load (NautilusMetafile *metafile)
682 {
683 async_read_start (metafile);
684 }
685
686 static gboolean
687 notify_metafile_ready_idle (gpointer user_data)
688 {
689 NautilusMetafile *metafile;
690 metafile = user_data;
691
692 g_signal_emit (metafile, signals[READY], 0);
693 g_object_unref (metafile);
694 return FALSE;
695 }
696
697 static void
698 nautilus_metafile_notify_metafile_ready (NautilusMetafile *metafile, gboolean in_idle)
699 {
700 if (in_idle) {
701 g_idle_add (notify_metafile_ready_idle, g_object_ref (metafile));
702 } else {
703 g_signal_emit (metafile, signals[READY], 0);
704 }
705 }
706
707 typedef struct {
708 NautilusMetafile *metafile;
709 GList *file_names;
710 } ChangedData;
711
712 static gboolean
713 metafile_changed_idle (gpointer user_data)
714 {
715 ChangedData *data;
716
717 data = user_data;
718
719 g_signal_emit (data->metafile, signals[CHANGED], 0, data->file_names);
720
721 g_object_unref (data->metafile);
722 eel_g_list_free_deep (data->file_names);
723 g_free (data);
724
725 return FALSE;
726 }
727
728 static void
729 call_metafile_changed (NautilusMetafile *metafile,
730 GList *file_names)
731 {
732 ChangedData *data;
733
734 data = g_new (ChangedData, 1);
735 data->metafile = g_object_ref (metafile);
736 data->file_names = eel_g_str_list_copy (file_names);
737
738 g_idle_add (metafile_changed_idle, data);
739 }
740
741 #if 0
742 static void
743 file_list_filler_ghfunc (gpointer key,
744 gpointer value,
745 gpointer user_data)
746 {
747 Nautilus_FileNameList *file_names;
748
749 file_names = user_data;
750
751 file_names->_buffer [file_names->_length] = key;
752
753 ++file_names->_length;
754 }
755
756 void
757 call_metafile_changed_for_all_files_mentioned_in_metafile (NautilusMetafile *metafile)
758 {
759 CORBA_unsigned_long len;
760 Nautilus_FileNameList file_names;
761
762 len = g_hash_table_size (metafile->node_hash);
763
764 if (len > 0) {
765 file_names._maximum = len;
766 file_names._length = 0;
767 file_names._buffer = g_new (CORBA_char *, len);
768
769 g_hash_table_foreach (metafile->node_hash,
770 file_list_filler_ghfunc,
771 &file_names);
772
773 call_metafile_changed (metafile, &file_names);
774
775 g_free (file_names._buffer);
776 }
777 }
778 #endif
779
780 static void
781 call_metafile_changed_for_one_file (NautilusMetafile *metafile,
782 const char *file_name)
783 {
784 GList l;
785
786 l.next = NULL;
787 l.prev = NULL;
788 l.data = (void *)file_name;
789
790 call_metafile_changed (metafile, &l);
791 }
792
793 typedef struct {
794 gboolean is_list;
795 union {
796 char *string;
797 GList *string_list;
798 } value;
799 char *default_value;
800 } MetadataValue;
801
802 static char *
803 get_metadata_from_node (xmlNode *node,
804 const char *key,
805 const char *default_metadata)
806 {
807 xmlChar *property;
808 char *result;
809
810 g_return_val_if_fail (key != NULL, NULL);
811 g_return_val_if_fail (key[0] != '\0', NULL);
812
813 property = xmlGetProp (node, key);
814 if (property == NULL) {
815 result = g_strdup (default_metadata);
816 } else {
817 result = g_strdup (property);
818 }
819 xmlFree (property);
820
821 return result;
822 }
823
824 static GList *
825 get_metadata_list_from_node (xmlNode *node,
826 const char *list_key,
827 const char *list_subkey)
828 {
829 return eel_xml_get_property_for_children
830 (node, list_key, list_subkey);
831 }
832
833 static xmlNode *
834 create_metafile_root (NautilusMetafile *metafile)
835 {
836 xmlNode *root;
837
838 if (metafile->xml == NULL) {
839 set_metafile_contents (metafile, xmlNewDoc (METAFILE_XML_VERSION));
840 }
841 root = xmlDocGetRootElement (metafile->xml);
842 if (root == NULL) {
843 root = xmlNewDocNode (metafile->xml, NULL, "directory", NULL);
844 xmlDocSetRootElement (metafile->xml, root);
845 }
846
847 return root;
848 }
849
850 static xmlNode *
851 get_file_node (NautilusMetafile *metafile,
852 const char *file_name,
853 gboolean create)
854 {
855 GHashTable *hash;
856 xmlNode *root, *node;
857 char *escaped_file_name;
858
859 g_assert (NAUTILUS_IS_METAFILE (metafile));
860
861 hash = metafile->node_hash;
862 node = g_hash_table_lookup (hash, file_name);
863 if (node != NULL) {
864 return node;
865 }
866
867 if (create) {
868 root = create_metafile_root (metafile);
869 node = xmlNewChild (root, NULL, "file", NULL);
870 escaped_file_name = g_uri_escape_string (file_name, NULL, 0);
871 xmlSetProp (node, "name", escaped_file_name);
872 g_free (escaped_file_name);
873 g_hash_table_insert (hash, xmlMemStrdup (file_name), node);
874 return node;
875 }
876
877 return NULL;
878 }
879
880 static void
881 set_file_node_timestamp (xmlNode *node)
882 {
883 char time_str[21];
884
885 /* 2^64 turns out to be 20 characters */
886 snprintf (time_str, 20, "%ld", time (NULL));
887 time_str [20] = '\0';
888 xmlSetProp (node, "timestamp", time_str);
889 }
890
891 static char *
892 get_metadata_string_from_metafile (NautilusMetafile *metafile,
893 const char *file_name,
894 const char *key,
895 const char *default_metadata)
896 {
897 xmlNode *node;
898
899 node = get_file_node (metafile, file_name, FALSE);
900 return get_metadata_from_node (node, key, default_metadata);
901 }
902
903 static GList *
904 get_metadata_list_from_metafile (NautilusMetafile *metafile,
905 const char *file_name,
906 const char *list_key,
907 const char *list_subkey)
908 {
909 xmlNode *node;
910
911 node = get_file_node (metafile, file_name, FALSE);
912 return get_metadata_list_from_node (node, list_key, list_subkey);
913 }
914
915 static gboolean
916 set_metadata_string_in_metafile (NautilusMetafile *metafile,
917 const char *file_name,
918 const char *key,
919 const char *default_metadata,
920 const char *metadata)
921 {
922 char *old_metadata;
923 gboolean old_metadata_matches;
924 const char *value;
925 xmlNode *node;
926 xmlAttr *property_node;
927
928 /* If the data in the metafile is already correct, do nothing. */
929 old_metadata = get_file_metadata
930 (metafile, file_name, key, default_metadata);
931
932 old_metadata_matches = eel_strcmp (old_metadata, metadata) == 0;
933 g_free (old_metadata);
934 if (old_metadata_matches) {
935 return FALSE;
936 }
937
938 /* Data that matches the default is represented in the tree by
939 * the lack of an attribute.
940 */
941 if (eel_strcmp (default_metadata, metadata) == 0) {
942 value = NULL;
943 } else {
944 value = metadata;
945 }
946
947 /* Get or create the node. */
948 node = get_file_node (metafile, file_name, value != NULL);
949
950 if (node != NULL) {
951 /* Set the timestamp */
952 set_file_node_timestamp (node);
953
954 /* Add or remove a property node. */
955 property_node = xmlSetProp (node, key, value);
956 if (value == NULL) {
957 xmlRemoveProp (property_node);
958 }
959 }
960
961 /* Since we changed the tree, arrange for it to be written. */
962 directory_request_write_metafile (metafile);
963 return TRUE;
964 }
965
966 static gboolean
967 set_metadata_list_in_metafile (NautilusMetafile *metafile,
968 const char *file_name,
969 const char *list_key,
970 const char *list_subkey,
971 GList *list)
972 {
973 xmlNode *node, *child, *next;
974 gboolean changed;
975 GList *p;
976 xmlChar *property;
977
978 /* Get or create the node. */
979 node = get_file_node (metafile, file_name, list != NULL);
980
981 /* Work with the list. */
982 changed = FALSE;
983 if (node == NULL) {
984 g_assert (list == NULL);
985 } else {
986 p = list;
987
988 /* Remove any nodes except the ones we expect. */
989 for (child = eel_xml_get_children (node);
990 child != NULL;
991 child = next) {
992
993 next = child->next;
994 if (strcmp (child->name, list_key) == 0) {
995 property = xmlGetProp (child, list_subkey);
996 if (property != NULL && p != NULL
997 && strcmp (property, (char *) p->data) == 0) {
998 p = p->next;
999 } else {
1000 xmlUnlinkNode (child);
1001 xmlFreeNode (child);
1002 changed = TRUE;
1003 }
1004 xmlFree (property);
1005 }
1006 }
1007
1008 /* Add any additional nodes needed. */
1009 for (; p != NULL; p = p->next) {
1010 child = xmlNewChild (node, NULL, list_key, NULL);
1011 xmlSetProp (child, list_subkey, p->data);
1012 changed = TRUE;
1013 }
1014
1015 /* Set the timestamp */
1016 set_file_node_timestamp (node);
1017 }
1018
1019 if (!changed) {
1020 return FALSE;
1021 }
1022
1023 directory_request_write_metafile (metafile);
1024 return TRUE;
1025 }
1026
1027 static MetadataValue *
1028 metadata_value_new (const char *default_metadata, const char *metadata)
1029 {
1030 MetadataValue *value;
1031
1032 value = g_new0 (MetadataValue, 1);
1033
1034 value->default_value = g_strdup (default_metadata);
1035 value->value.string = g_strdup (metadata);
1036
1037 return value;
1038 }
1039
1040 static MetadataValue *
1041 metadata_value_new_list (GList *metadata)
1042 {
1043 MetadataValue *value;
1044
1045 value = g_new0 (MetadataValue, 1);
1046
1047 value->is_list = TRUE;
1048 value->value.string_list = eel_g_str_list_copy (metadata);
1049
1050 return value;
1051 }
1052
1053 static void
1054 metadata_value_destroy (MetadataValue *value)
1055 {
1056 if (value == NULL) {
1057 return;
1058 }
1059
1060 if (!value->is_list) {
1061 g_free (value->value.string);
1062 } else {
1063 eel_g_list_free_deep (value->value.string_list);
1064 }
1065 g_free (value->default_value);
1066 g_free (value);
1067 }
1068
1069 static gboolean
1070 metadata_value_equal (const MetadataValue *value_a,
1071 const MetadataValue *value_b)
1072 {
1073 if (value_a->is_list != value_b->is_list) {
1074 return FALSE;
1075 }
1076
1077 if (!value_a->is_list) {
1078 return eel_strcmp (value_a->value.string,
1079 value_b->value.string) == 0
1080 && eel_strcmp (value_a->default_value,
1081 value_b->default_value) == 0;
1082 } else {
1083 g_assert (value_a->default_value == NULL);
1084 g_assert (value_b->default_value == NULL);
1085
1086 return eel_g_str_list_equal
1087 (value_a->value.string_list,
1088 value_b->value.string_list);
1089 }
1090 }
1091
1092 static gboolean
1093 set_metadata_in_metafile (NautilusMetafile *metafile,
1094 const char *file_name,
1095 const char *key,
1096 const char *subkey,
1097 const MetadataValue *value)
1098 {
1099 gboolean changed;
1100
1101 if (!value->is_list) {
1102 g_assert (subkey == NULL);
1103 changed = set_metadata_string_in_metafile
1104 (metafile, file_name, key,
1105 value->default_value,
1106 value->value.string);
1107 } else {
1108 g_assert (value->default_value == NULL);
1109 changed = set_metadata_list_in_metafile
1110 (metafile, file_name, key, subkey,
1111 value->value.string_list);
1112 }
1113
1114 return changed;
1115 }
1116
1117 static char *
1118 get_metadata_string_from_table (NautilusMetafile *metafile,
1119 const char *file_name,
1120 const char *key,
1121 const char *default_metadata)
1122 {
1123 GHashTable *directory_table, *file_table;
1124 MetadataValue *value;
1125
1126 /* Get the value from the hash table. */
1127 directory_table = metafile->changes;
1128 file_table = directory_table == NULL ? NULL
1129 : g_hash_table_lookup (directory_table, file_name);
1130 value = file_table == NULL ? NULL
1131 : g_hash_table_lookup (file_table, key);
1132 if (value == NULL) {
1133 return g_strdup (default_metadata);
1134 }
1135
1136 /* Convert it to a string. */
1137 g_assert (!value->is_list);
1138 if (eel_strcmp (value->value.string, value->default_value) == 0) {
1139 return g_strdup (default_metadata);
1140 }
1141 return g_strdup (value->value.string);
1142 }
1143
1144 static GList *
1145 get_metadata_list_from_table (NautilusMetafile *metafile,
1146 const char *file_name,
1147 const char *key,
1148 const char *subkey)
1149 {
1150 GHashTable *directory_table, *file_table;
1151 char *combined_key;
1152 MetadataValue *value;
1153
1154 /* Get the value from the hash table. */
1155 directory_table = metafile->changes;
1156 file_table = directory_table == NULL ? NULL
1157 : g_hash_table_lookup (directory_table, file_name);
1158 if (file_table == NULL) {
1159 return NULL;
1160 }
1161 combined_key = g_strconcat (key, "/", subkey, NULL);
1162 value = g_hash_table_lookup (file_table, combined_key);
1163 g_free (combined_key);
1164 if (value == NULL) {
1165 return NULL;
1166 }
1167
1168 /* Copy the list and return it. */
1169 g_assert (value->is_list);
1170 return eel_g_str_list_copy (value->value.string_list);
1171 }
1172
1173 static guint
1174 str_or_null_hash (gconstpointer str)
1175 {
1176 return str == NULL ? 0 : g_str_hash (str);
1177 }
1178
1179 static gboolean
1180 str_or_null_equal (gconstpointer str_a, gconstpointer str_b)
1181 {
1182 if (str_a == NULL) {
1183 return str_b == NULL;
1184 }
1185 if (str_b == NULL) {
1186 return FALSE;
1187 }
1188 return g_str_equal (str_a, str_b);
1189 }
1190
1191 static gboolean
1192 set_metadata_eat_value (NautilusMetafile *metafile,
1193 const char *file_name,
1194 const char *key,
1195 const char *subkey,
1196 MetadataValue *value)
1197 {
1198 GHashTable *directory_table, *file_table;
1199 gboolean changed;
1200 char *combined_key;
1201 MetadataValue *old_value;
1202
1203 if (metafile->is_read) {
1204 changed = set_metadata_in_metafile
1205 (metafile, file_name, key, subkey, value);
1206 metadata_value_destroy (value);
1207 } else {
1208 /* Create hash table only when we need it.
1209 * We'll destroy it when we finish reading the metafile.
1210 */
1211 directory_table = metafile->changes;
1212 if (directory_table == NULL) {
1213 directory_table = g_hash_table_new
1214 (str_or_null_hash, str_or_null_equal);
1215 metafile->changes = directory_table;
1216 }
1217 file_table = g_hash_table_lookup (directory_table, file_name);
1218 if (file_table == NULL) {
1219 file_table = g_hash_table_new (g_str_hash, g_str_equal);
1220 g_hash_table_insert (directory_table,
1221 g_strdup (file_name), file_table);
1222 }
1223
1224 /* Find the entry in the hash table. */
1225 if (subkey == NULL) {
1226 combined_key = g_strdup (key);
1227 } else {
1228 combined_key = g_strconcat (key, "/", subkey, NULL);
1229 }
1230 old_value = g_hash_table_lookup (file_table, combined_key);
1231
1232 /* Put the change into the hash. Delete the old change. */
1233 changed = old_value == NULL || !metadata_value_equal (old_value, value);
1234 if (changed) {
1235 g_hash_table_insert (file_table, combined_key, value);
1236 if (old_value != NULL) {
1237 /* The hash table keeps the old key. */
1238 g_free (combined_key);
1239 metadata_value_destroy (old_value);
1240 }
1241 } else {
1242 g_free (combined_key);
1243 metadata_value_destroy (value);
1244 }
1245 }
1246
1247 return changed;
1248 }
1249
1250 static void
1251 free_file_table_entry (gpointer key, gpointer value, gpointer user_data)
1252 {
1253 g_assert (user_data == NULL);
1254
1255 g_free (key);
1256 metadata_value_destroy (value);
1257 }
1258
1259 static void
1260 free_directory_table_entry (gpointer key, gpointer value, gpointer user_data)
1261 {
1262 g_assert (user_data == NULL);
1263 g_assert (value != NULL);
1264
1265 g_free (key);
1266 g_hash_table_foreach (value, free_file_table_entry, NULL);
1267 g_hash_table_destroy (value);
1268 }
1269
1270 static void
1271 destroy_metadata_changes_hash_table (GHashTable *directory_table)
1272 {
1273 if (directory_table == NULL) {
1274 return;
1275 }
1276 g_hash_table_foreach (directory_table, free_directory_table_entry, NULL);
1277 g_hash_table_destroy (directory_table);
1278 }
1279
1280 static void
1281 destroy_xml_string_key (gpointer key, gpointer value, gpointer user_data)
1282 {
1283 g_assert (key != NULL);
1284 g_assert (user_data == NULL);
1285 g_assert (value != NULL);
1286
1287 xmlFree (key);
1288 }
1289
1290 static void
1291 metafile_free_metadata (NautilusMetafile *metafile)
1292 {
1293 g_return_if_fail (NAUTILUS_IS_METAFILE (metafile));
1294
1295 g_hash_table_foreach (metafile->node_hash,
1296 destroy_xml_string_key, NULL);
1297 xmlFreeDoc (metafile->xml);
1298 destroy_metadata_changes_hash_table (metafile->changes);
1299 }
1300
1301 static char *
1302 get_file_metadata (NautilusMetafile *metafile,
1303 const char *file_name,
1304 const char *key,
1305 const char *default_metadata)
1306 {
1307 g_return_val_if_fail (NAUTILUS_IS_METAFILE (metafile), NULL);
1308 g_return_val_if_fail (!eel_str_is_empty (file_name), NULL);
1309 g_return_val_if_fail (!eel_str_is_empty (key), NULL);
1310
1311 if (metafile->is_read) {
1312 return get_metadata_string_from_metafile
1313 (metafile, file_name, key, default_metadata);
1314 } else {
1315 return get_metadata_string_from_table
1316 (metafile, file_name, key, default_metadata);
1317 }
1318 }
1319
1320 static GList *
1321 get_file_metadata_list (NautilusMetafile *metafile,
1322 const char *file_name,
1323 const char *list_key,
1324 const char *list_subkey)
1325 {
1326 g_return_val_if_fail (NAUTILUS_IS_METAFILE (metafile), NULL);
1327 g_return_val_if_fail (!eel_str_is_empty (file_name), NULL);
1328 g_return_val_if_fail (!eel_str_is_empty (list_key), NULL);
1329 g_return_val_if_fail (!eel_str_is_empty (list_subkey), NULL);
1330
1331 if (metafile->is_read) {
1332 return get_metadata_list_from_metafile
1333 (metafile, file_name, list_key, list_subkey);
1334 } else {
1335 return get_metadata_list_from_table
1336 (metafile, file_name, list_key, list_subkey);
1337 }
1338 }
1339
1340 static gboolean
1341 set_file_metadata (NautilusMetafile *metafile,
1342 const char *file_name,
1343 const char *key,
1344 const char *default_metadata,
1345 const char *metadata)
1346 {
1347 MetadataValue *value;
1348
1349 g_return_val_if_fail (NAUTILUS_IS_METAFILE (metafile), FALSE);
1350 g_return_val_if_fail (!eel_str_is_empty (file_name), FALSE);
1351 g_return_val_if_fail (!eel_str_is_empty (key), FALSE);
1352
1353 if (metafile->is_read) {
1354 return set_metadata_string_in_metafile (metafile, file_name, key,
1355 default_metadata, metadata);
1356 } else {
1357 value = metadata_value_new (default_metadata, metadata);
1358 return set_metadata_eat_value (metafile, file_name,
1359 key, NULL, value);
1360 }
1361 }
1362
1363 static gboolean
1364 set_file_metadata_list (NautilusMetafile *metafile,
1365 const char *file_name,
1366 const char *list_key,
1367 const char *list_subkey,
1368 GList *list)
1369 {
1370 MetadataValue *value;
1371
1372 g_return_val_if_fail (NAUTILUS_IS_METAFILE (metafile), FALSE);
1373 g_return_val_if_fail (!eel_str_is_empty (file_name), FALSE);
1374 g_return_val_if_fail (!eel_str_is_empty (list_key), FALSE);
1375 g_return_val_if_fail (!eel_str_is_empty (list_subkey), FALSE);
1376
1377 if (metafile->is_read) {
1378 return set_metadata_list_in_metafile (metafile, file_name,
1379 list_key, list_subkey, list);
1380 } else {
1381 value = metadata_value_new_list (list);
1382 return set_metadata_eat_value (metafile, file_name,
1383 list_key, list_subkey, value);
1384 }
1385 }
1386
1387 static char *
1388 metafile_get_file_uri (NautilusMetafile *metafile,
1389 const char *file_name)
1390 {
1391 char *escaped_file_name, *uri;
1392
1393 g_return_val_if_fail (NAUTILUS_IS_METAFILE (metafile), NULL);
1394 g_return_val_if_fail (file_name != NULL, NULL);
1395
1396 escaped_file_name = g_uri_escape_string (file_name, G_URI_RESERVED_CHARS_ALLOWED_IN_PATH, FALSE);
1397
1398 uri = g_build_filename (metafile->directory_uri, escaped_file_name, NULL);
1399 g_free (escaped_file_name);
1400 return uri;
1401 }
1402
1403 static void
1404 rename_file_metadata (NautilusMetafile *metafile,
1405 const char *old_file_name,
1406 const char *new_file_name)
1407 {
1408 gboolean found;
1409 gpointer key, value;
1410 xmlNode *file_node;
1411 GHashTable *hash;
1412 char *old_file_uri, *new_file_uri;
1413 char *escaped;
1414
1415 g_return_if_fail (NAUTILUS_IS_METAFILE (metafile));
1416 g_return_if_fail (old_file_name != NULL);
1417 g_return_if_fail (new_file_name != NULL);
1418
1419 remove_file_metadata (metafile, new_file_name);
1420
1421 if (metafile->is_read) {
1422 /* Move data in XML document if present. */
1423 hash = metafile->node_hash;
1424 found = g_hash_table_lookup_extended
1425 (hash, old_file_name, &key, &value);
1426 if (found) {
1427 g_assert (strcmp ((const char *) key, old_file_name) == 0);
1428 file_node = value;
1429 g_hash_table_remove (hash,
1430 old_file_name);
1431 xmlFree (key);
1432 g_hash_table_insert (hash,
1433 xmlMemStrdup (new_file_name), value);
1434 escaped = g_uri_escape_string (new_file_name, NULL, FALSE);
1435 xmlSetProp (file_node, "name", escaped);
1436 g_free (escaped);
1437 directory_request_write_metafile (metafile);
1438 }
1439 } else {
1440 /* Move data in hash table. */
1441 /* FIXME: If there's data for this file in the
1442 * metafile on disk, this doesn't arrange for that
1443 * data to be moved to the new name.
1444 */
1445 hash = metafile->changes;
1446 found = g_hash_table_lookup_extended
1447 (hash, old_file_name, &key, &value);
1448 if (found) {
1449 g_hash_table_remove (hash, old_file_name);
1450 g_free (key);
1451 g_hash_table_insert (hash, g_strdup (new_file_name), value);
1452 }
1453 }
1454
1455 /* Rename the thumbnails for the file, if any. */
1456 old_file_uri = metafile_get_file_uri (metafile, old_file_name);
1457 new_file_uri = metafile_get_file_uri (metafile, new_file_name);
1458 nautilus_update_thumbnail_file_renamed (old_file_uri, new_file_uri);
1459 g_free (old_file_uri);
1460 g_free (new_file_uri);
1461 }
1462
1463 typedef struct {
1464 NautilusMetafile *metafile;
1465 const char *file_name;
1466 } ChangeContext;
1467
1468 static void
1469 apply_one_change (gpointer key, gpointer value, gpointer callback_data)
1470 {
1471 ChangeContext *context;
1472 const char *hash_table_key, *separator, *metadata_key, *subkey;
1473 char *key_prefix;
1474
1475 g_assert (key != NULL);
1476 g_assert (value != NULL);
1477 g_assert (callback_data != NULL);
1478
1479 context = callback_data;
1480
1481 /* Break the key in half. */
1482 hash_table_key = key;
1483 separator = strchr (hash_table_key, '/');
1484 if (separator == NULL) {
1485 key_prefix = NULL;
1486 metadata_key = hash_table_key;
1487 subkey = NULL;
1488 } else {
1489 key_prefix = g_strndup (hash_table_key, separator - hash_table_key);
1490 metadata_key = key_prefix;
1491 subkey = separator + 1;
1492 }
1493
1494 /* Set the metadata. */
1495 set_metadata_in_metafile (context->metafile, context->file_name,
1496 metadata_key, subkey, value);
1497 g_free (key_prefix);
1498 }
1499
1500 static void
1501 apply_file_changes (NautilusMetafile *metafile,
1502 const char *file_name,
1503 GHashTable *changes)
1504 {
1505 ChangeContext context;
1506
1507 g_assert (NAUTILUS_IS_METAFILE (metafile));
1508 g_assert (file_name != NULL);
1509 g_assert (changes != NULL);
1510
1511 context.metafile = metafile;
1512 context.file_name = file_name;
1513
1514 g_hash_table_foreach (changes, apply_one_change, &context);
1515 }
1516
1517 static void
1518 apply_one_file_changes (gpointer key, gpointer value, gpointer callback_data)
1519 {
1520 apply_file_changes (callback_data, key, value);
1521 g_hash_table_destroy (value);
1522 }
1523
1524 static void
1525 nautilus_metafile_apply_pending_changes (NautilusMetafile *metafile)
1526 {
1527 if (metafile->changes == NULL) {
1528 return;
1529 }
1530 g_hash_table_foreach (metafile->changes,
1531 apply_one_file_changes, metafile);
1532 g_hash_table_destroy (metafile->changes);
1533 metafile->changes = NULL;
1534 }
1535
1536 static void
1537 real_copy_file_metadata (NautilusMetafile *source_metafile,
1538 const char *source_file_name,
1539 NautilusMetafile *destination_metafile,
1540 const char *destination_file_name)
1541 {
1542 xmlNodePtr source_node, node, root;
1543 GHashTable *hash, *changes;
1544 char *escaped;
1545
1546 real_remove_file_metadata (destination_metafile, destination_file_name);
1547 g_assert (get_file_node (destination_metafile, destination_file_name, FALSE) == NULL);
1548
1549 source_node = get_file_node (source_metafile, source_file_name, FALSE);
1550 if (source_node != NULL) {
1551 node = xmlCopyNode (source_node, TRUE);
1552 root = create_metafile_root (destination_metafile);
1553 xmlAddChild (root, node);
1554 escaped = g_uri_escape_string (destination_file_name, NULL, FALSE);
1555 xmlSetProp (node, "name", escaped);
1556 g_free (escaped);
1557 set_file_node_timestamp (node);
1558 g_hash_table_insert (destination_metafile->node_hash,
1559 xmlMemStrdup (destination_file_name), node);
1560 directory_request_write_metafile (destination_metafile);
1561 }
1562
1563 hash = source_metafile->changes;
1564 if (hash != NULL) {
1565 changes = g_hash_table_lookup (hash, source_file_name);
1566 if (changes != NULL) {
1567 apply_file_changes (destination_metafile,
1568 destination_file_name,
1569 changes);
1570 }
1571 }
1572 }
1573
1574 static void
1575 copy_file_metadata (NautilusMetafile *source_metafile,
1576 const char *source_file_name,
1577 NautilusMetafile *destination_metafile,
1578 const char *destination_file_name)
1579 {
1580 char *source_file_uri;
1581 char *destination_file_uri;
1582
1583 g_return_if_fail (NAUTILUS_IS_METAFILE (source_metafile));
1584 g_return_if_fail (source_file_name != NULL);
1585 g_return_if_fail (NAUTILUS_IS_METAFILE (destination_metafile));
1586 g_return_if_fail (destination_file_name != NULL);
1587
1588 if (source_metafile->is_read
1589 && destination_metafile->is_read) {
1590 real_copy_file_metadata (source_metafile,
1591 source_file_name,
1592 destination_metafile,
1593 destination_file_name);
1594 } else {
1595 nautilus_metadata_schedule_copy (source_metafile,
1596 source_file_name,
1597 destination_metafile,
1598 destination_file_name);
1599 }
1600
1601 /* Copy the thumbnail for the file, if any. */
1602 source_file_uri = metafile_get_file_uri (source_metafile, source_file_name);
1603 destination_file_uri = metafile_get_file_uri (destination_metafile, destination_file_name);
1604 nautilus_update_thumbnail_file_copied (source_file_uri, destination_file_uri);
1605 g_free (source_file_uri);
1606 g_free (destination_file_uri);
1607 }
1608
1609 static void
1610 real_remove_file_metadata (NautilusMetafile *metafile,
1611 const char *file_name)
1612 {
1613 gboolean found;
1614 gpointer key, value;
1615 xmlNode *file_node;
1616 GHashTable *hash;
1617
1618 g_return_if_fail (NAUTILUS_IS_METAFILE (metafile));
1619 g_return_if_fail (file_name != NULL);
1620
1621 if (metafile->is_read) {
1622 /* Remove data in XML document if present. */
1623 hash = metafile->node_hash;
1624 found = g_hash_table_lookup_extended
1625 (hash, file_name, &key, &value);
1626 if (found) {
1627 g_assert (strcmp ((const char *) key, file_name) == 0);
1628 file_node = value;
1629 g_hash_table_remove (hash,
1630 file_name);
1631 xmlFree (key);
1632 xmlUnlinkNode (file_node);
1633 xmlFreeNode (file_node);
1634 directory_request_write_metafile (metafile);
1635 }
1636 } else {
1637 /* Remove data from hash table. */
1638 /* FIXME: If there's data for this file on the
1639 * metafile on disk, this does not arrange for it to
1640 * be removed when the metafile is later read.
1641 */
1642 hash = metafile->changes;
1643 if (hash != NULL) {
1644 found = g_hash_table_lookup_extended
1645 (hash, file_name, &key, &value);
1646 if (found) {
1647 g_hash_table_remove (hash, file_name);
1648 g_free (key);
1649 destroy_metadata_changes_hash_table (value);
1650 }
1651 }
1652 }
1653 }
1654
1655 static void
1656 remove_file_metadata (NautilusMetafile *metafile,
1657 const char *file_name)
1658 {
1659 char *file_uri;
1660
1661 g_return_if_fail (NAUTILUS_IS_METAFILE (metafile));
1662 g_return_if_fail (file_name != NULL);
1663
1664 if (nautilus_metadata_has_scheduled_copy (metafile, file_name)) {
1665 nautilus_metadata_schedule_removal (metafile, file_name);
1666 } else {
1667 real_remove_file_metadata (metafile, file_name);
1668 }
1669
1670 /* Delete the thumbnails for the file, if any. */
1671 file_uri = metafile_get_file_uri (metafile, file_name);
1672 nautilus_remove_thumbnail_for_file (file_uri);
1673 g_free (file_uri);
1674 }
1675
1676 static void
1677 set_metafile_contents (NautilusMetafile *metafile,
1678 xmlDocPtr metafile_contents)
1679 {
1680 GHashTable *hash;
1681 xmlNodePtr node;
1682 xmlChar *name;
1683 char *unescaped_name;
1684
1685 g_return_if_fail (NAUTILUS_IS_METAFILE (metafile));
1686 g_return_if_fail (metafile->xml == NULL);
1687
1688 if (metafile_contents == NULL) {
1689 return;
1690 }
1691
1692 metafile->xml = metafile_contents;
1693
1694 /* Populate the node hash table. */
1695 hash = metafile->node_hash;
1696 for (node = eel_xml_get_root_children (metafile_contents);
1697 node != NULL; node = node->next) {
1698 if (strcmp (node->name, "file") == 0) {
1699 name = xmlGetProp (node, "name");
1700 unescaped_name = g_uri_unescape_string (name, "/");
1701 xmlFree (name);
1702 if (unescaped_name == NULL ||
1703 g_hash_table_lookup (hash, unescaped_name) != NULL) {
1704 /* FIXME: Should we delete duplicate nodes as we discover them? */
1705 g_free (unescaped_name);
1706 } else {
1707 g_hash_table_insert (hash, unescaped_name, node);
1708 }
1709 }
1710 }
1711 }
1712
1713 static void
1714 metafile_read_cancel (NautilusMetafile *metafile)
1715 {
1716 if (metafile->read_state != NULL) {
1717 g_cancellable_cancel (metafile->read_state->cancellable);
1718 metafile->read_state->metafile = NULL;
1719 metafile->read_state = NULL;
1720 }
1721 }
1722
1723 static void
1724 metafile_read_state_free (MetafileReadState *state)
1725 {
1726 g_object_unref (state->cancellable);
1727 g_free (state);
1728 }
1729
1730 static void
1731 metafile_read_mark_done (NautilusMetafile *metafile, gboolean callback_in_idle)
1732 {
1733 metafile_read_state_free (metafile->read_state);
1734 metafile->read_state = NULL;
1735
1736 metafile->is_read = TRUE;
1737
1738 /* Move over the changes to the metafile that were in the hash table. */
1739 nautilus_metafile_apply_pending_changes (metafile);
1740
1741 /* Tell change-watchers that we have update information. */
1742 nautilus_metafile_notify_metafile_ready (metafile, callback_in_idle);
1743
1744 async_read_done (metafile);
1745 }
1746
1747 static void
1748 metafile_read_done_callback (GObject *source_object,
1749 GAsyncResult *res,
1750 gpointer user_data)
1751 {
1752 MetafileReadState *state;
1753 NautilusMetafile *metafile;
1754 gsize file_size;
1755 char *file_contents;
1756
1757 state = user_data;
1758
1759 if (state->metafile == NULL) {
1760 /* Operation was cancelled. Bail out */
1761 metafile_read_state_free (state);
1762 return;
1763 }
1764
1765 metafile = state->metafile;
1766 g_assert (metafile->xml == NULL);
1767
1768 if (g_file_load_contents_finish (G_FILE (source_object),
1769 res,
1770 &file_contents, &file_size,
1771 NULL, NULL)) {
1772 set_metafile_contents (metafile, xmlParseMemory (file_contents, file_size));
1773 g_free (file_contents);
1774 }
1775
1776 metafile_read_mark_done (metafile, FALSE);
1777
1778 nautilus_metadata_process_ready_copies ();
1779 nautilus_metadata_process_ready_removals ();
1780 }
1781
1782 static void
1783 metafile_read_restart (NautilusMetafile *metafile)
1784 {
1785 GFile *location;
1786 MetafileReadState *state;
1787
1788 state = g_new0 (MetafileReadState, 1);
1789 state->metafile = metafile;
1790 state->cancellable = g_cancellable_new ();
1791
1792 metafile->read_state = state;
1793
1794 location = g_file_new_for_uri (metafile->private_uri);
1795
1796 g_file_load_contents_async (location, state->cancellable,
1797 metafile_read_done_callback, state);
1798
1799 g_object_unref (location);
1800 }
1801
1802 static gboolean
1803 allow_metafile (NautilusMetafile *metafile)
1804 {
1805 const char *uri;
1806
1807 g_assert (NAUTILUS_IS_METAFILE (metafile));
1808
1809 /* Note that this inhibits both reading and writing metadata
1810 * completely. In the future we may want to inhibit writing to
1811 * the real directory while allowing parallel-directory
1812 * metadata.
1813 */
1814
1815 /* For now, hard-code these schemes. Perhaps we should
1816 * hardcode the schemes that are good for metadata instead of
1817 * the schemes that are bad for it.
1818 */
1819 /* FIXME bugzilla.gnome.org 42434:
1820 * We need to handle this in a better way. Perhaps a
1821 * better way can wait until we have support for metadata
1822 * access inside gnome-vfs.
1823 */
1824 uri = metafile->directory_uri;
1825 if (eel_uri_is_search (uri) ||
1826 eel_istr_has_prefix (uri, "gnome-help:") ||
1827 eel_istr_has_prefix (uri, "help:")
1828 ) {
1829 return FALSE;
1830 }
1831
1832 return TRUE;
1833 }
1834
1835 static void
1836 metafile_read_start (NautilusMetafile *metafile)
1837 {
1838 g_assert (NAUTILUS_IS_METAFILE (metafile));
1839
1840 if (metafile->is_read ||
1841 metafile->read_state != NULL) {
1842 return;
1843 }
1844
1845 if (!allow_metafile (metafile)) {
1846 metafile_read_mark_done (metafile, TRUE);
1847 } else {
1848 metafile_read_restart (metafile);
1849 }
1850 }
1851
1852 static void
1853 metafile_write_done (NautilusMetafile *metafile)
1854 {
1855 if (metafile->write_state->write_again) {
1856 metafile_write_start (metafile);
1857 return;
1858 }
1859
1860 xmlFree (metafile->write_state->buffer);
1861 g_free (metafile->write_state);
1862 metafile->write_state = NULL;
1863 g_object_unref (metafile);
1864 }
1865
1866 static void
1867 metafile_write_failed (NautilusMetafile *metafile)
1868 {
1869 metafile_write_done (metafile);
1870 }
1871
1872 static void
1873 metafile_write_succeeded (NautilusMetafile *metafile)
1874 {
1875 metafile_write_done (metafile);
1876 }
1877
1878 static int
1879 write_all (int fd, const char *buffer, int size)
1880 {
1881 int size_remaining;
1882 const char *p;
1883 ssize_t result;
1884
1885 p = buffer;
1886 size_remaining = size;
1887 while (size_remaining != 0) {
1888 result = write (fd, p, size_remaining);
1889 if (result <= 0 || result > size_remaining) {
1890 return -1;
1891 }
1892 p += result;
1893 size_remaining -= result;
1894 }
1895
1896 return size;
1897 }
1898
1899 static void
1900 metafile_write_local (NautilusMetafile *metafile,
1901 const char *metafile_path)
1902 {
1903 char *temp_path;
1904 int fd;
1905 gboolean failed;
1906
1907 /* Do this synchronously, since it's likely to be local. Use
1908 * mkstemp to prevent security exploits by making symbolic
1909 * links named .nautilus-metafile.xml.
1910 */
1911
1912 temp_path = g_strconcat (metafile_path, "XXXXXX", NULL);
1913 failed = FALSE;
1914
1915 fd = mkstemp (temp_path);
1916 if (fd == -1) {
1917 failed = TRUE;
1918 }
1919 if (!failed && fchmod (fd, METAFILE_PERMISSIONS) == -1) {
1920 failed = TRUE;
1921 }
1922 if (!failed && write_all (fd,
1923 metafile->write_state->buffer,
1924 metafile->write_state->size) == -1) {
1925 failed = TRUE;
1926 }
1927 if (fd != -1 && close (fd) == -1) {
1928 failed = TRUE;
1929 }
1930 if (failed && fd != -1) {
1931 unlink (temp_path);
1932 }
1933 if (!failed && rename (temp_path, metafile_path) == -1) {
1934 failed = TRUE;
1935 }
1936 g_free (temp_path);
1937
1938 if (failed) {
1939 metafile_write_failed (metafile);
1940 } else {
1941 metafile_write_succeeded (metafile);
1942 }
1943 }
1944
1945 static void
1946 metafile_write_start (NautilusMetafile *metafile)
1947 {
1948 const char *metafile_uri;
1949 char *metafile_path;
1950
1951 g_assert (NAUTILUS_IS_METAFILE (metafile));
1952
1953 metafile->write_state->write_again = FALSE;
1954
1955 metafile_uri = metafile->private_uri;
1956
1957 metafile_path = g_filename_from_uri (metafile_uri, NULL, NULL);
1958 g_assert (metafile_path != NULL);
1959
1960 metafile_write_local (metafile, metafile_path);
1961 g_free (metafile_path);
1962 }
1963
1964 static void
1965 metafile_write (NautilusMetafile *metafile)
1966 {
1967 int xml_doc_size;
1968
1969 g_assert (NAUTILUS_IS_METAFILE (metafile));
1970
1971 g_object_ref (metafile);
1972
1973 /* If we are already writing, then just remember to do it again. */
1974 if (metafile->write_state != NULL) {
1975 g_object_unref (metafile);
1976 metafile->write_state->write_again = TRUE;
1977 return;
1978 }
1979
1980 /* Don't write anything if there's nothing to write.
1981 * At some point, we might want to change this to actually delete
1982 * the metafile in this case.
1983 */
1984 if (metafile->xml == NULL) {
1985 g_object_unref (metafile);
1986 return;
1987 }
1988
1989 /* Create the write state. */
1990 metafile->write_state = g_new0 (MetafileWriteState, 1);
1991 xmlDocDumpMemory (metafile->xml,
1992 &metafile->write_state->buffer,
1993 &xml_doc_size);
1994 metafile->write_state->size = xml_doc_size;
1995 metafile_write_start (metafile);
1996 }
1997
1998 static gboolean
1999 metafile_write_idle_callback (gpointer callback_data)
2000 {
2001 NautilusMetafile *metafile;
2002
2003 metafile = NAUTILUS_METAFILE (callback_data);
2004
2005 metafile->write_idle_id = 0;
2006 metafile_write (metafile);
2007
2008 g_object_unref (metafile);
2009
2010 return FALSE;
2011 }
2012
2013 static void
2014 directory_request_write_metafile (NautilusMetafile *metafile)
2015 {
2016 g_assert (NAUTILUS_IS_METAFILE (metafile));
2017
2018 if (!allow_metafile (metafile)) {
2019 return;
2020 }
2021
2022 /* Set up an idle task that will write the metafile. */
2023 if (metafile->write_idle_id == 0) {
2024 g_object_ref (metafile);
2025 metafile->write_idle_id =
2026 g_idle_add (metafile_write_idle_callback, metafile);
2027 }
2028 }
2029
2030 static void
2031 nautilus_metafile_class_init (NautilusMetafileClass *klass)
2032 {
2033 G_OBJECT_CLASS (klass)->finalize = finalize;
2034
2035 signals[CHANGED] = g_signal_new ("changed",
2036 NAUTILUS_TYPE_METAFILE,
2037 G_SIGNAL_RUN_LAST,
2038 0,
2039 NULL, NULL,
2040 g_cclosure_marshal_VOID__POINTER,
2041 G_TYPE_NONE, 1, G_TYPE_POINTER);
2042 signals[READY] = g_signal_new ("ready",
2043 NAUTILUS_TYPE_METAFILE,
2044 G_SIGNAL_RUN_LAST,
2045 0,
2046 NULL, NULL,
2047 g_cclosure_marshal_VOID__VOID,
2048 G_TYPE_NONE, 0);
2049 }
Nautilus File Manager (svn mirror)