src/gnome-vfs-method.c

   1 /* $Id$
   2  * gnome-vfs init/shutdown implementation of interface to libntfs
   3  * Copyright (C) 2003 Jan Kratochvil <project-captive@jankratochvil.net>
   4  *
   5  * This program is free software; you can redistribute it and/or modify
   6  * it under the terms of the GNU General Public License as published by
   7  * the Free Software Foundation; exactly version 2 of June 1991 is required
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program; if not, write to the Free Software
  16  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  17  */
  18
  19
  20 #include "config.h"
  21
  22 #undef FALSE
  23 #undef TRUE
  24 #include <ntfs/types.h> /* for 'FALSE'/'TRUE' libntfs definition */
  25 #define FALSE FALSE
  26 #define TRUE TRUE
  27
  28 #include "gnome-vfs-method.h"   /* self */
  29 #include <libgnomevfs/gnome-vfs-method.h>
  30 #include <glib/gmessages.h>
  31 #include "gnome-vfs-module.h"
  32 #include <glib/ghash.h>
  33 #include <string.h>
  34 #include <libgnomevfs/gnome-vfs-utils.h>
  35
  36 #include <ntfs/volume.h>
  37 #include <ntfs/dir.h>
  38
  39
  40 static GnomeVFSMethod GnomeVFSMethod_static;
  41 G_LOCK_DEFINE_STATIC(GnomeVFSMethod_static);
  42
  43
  44 /* map: (gchar *)method_name -> (struct method_name_info *) */
  45 static GHashTable *method_name_hash;
  46 G_LOCK_DEFINE_STATIC(method_name_hash);
  47
  48 struct method_name_info {
  49         gchar *args;
  50         };
  51
  52 static void method_name_hash_key_destroy_func(gchar *key)
  53 {
  54         g_return_if_fail(key!=NULL);
  55
  56         g_free(key);
  57 }
  58
  59 static void method_name_hash_value_destroy_func(struct method_name_info *value)
  60 {
  61         g_return_if_fail(value!=NULL);
  62
  63         g_free(value->args);
  64         g_free(value);
  65 }
  66
  67 static void method_name_hash_init(void)
  68 {
  69         G_LOCK(method_name_hash);
  70         if (!method_name_hash) {
  71                 method_name_hash=g_hash_table_new_full(
  72                                 g_str_hash,     /* hash_func */
  73                                 g_str_equal,    /* key_equal_func */
  74                                 (GDestroyNotify)method_name_hash_key_destroy_func,      /* key_destroy_func */
  75                                 (GDestroyNotify)method_name_hash_value_destroy_func);   /* value_destroy_func */
  76                 }
  77         G_UNLOCK(method_name_hash);
  78 }
  79
  80
  81 /* map: (gchar *)uri_parent_string "method_name:uri_parent" -> (ntfs_volume *) */
  82 static GHashTable *uri_parent_string_hash;
  83 G_LOCK_DEFINE_STATIC(uri_parent_string_hash);
  84
  85 static void uri_parent_string_hash_key_destroy_func(gchar *key)
  86 {
  87         g_return_if_fail(key!=NULL);
  88
  89         g_free(key);
  90 }
  91
  92 static void uri_parent_string_hash_value_destroy_func(ntfs_volume *value)
  93 {
  94         g_return_if_fail(value!=NULL);
  95
  96         ntfs_umount(    /* errors ignored */
  97                         value,  /* vol */
  98                         TRUE);  /* force; possibly loose modifications */
  99 }
 100
 101 static void uri_parent_string_hash_init(void)
 102 {
 103         G_LOCK(uri_parent_string_hash);
 104         if (!uri_parent_string_hash) {
 105                 uri_parent_string_hash=g_hash_table_new_full(
 106                                 g_str_hash,     /* hash_func */
 107                                 g_str_equal,    /* key_equal_func */
 108                                 (GDestroyNotify)uri_parent_string_hash_key_destroy_func,        /* key_destroy_func */
 109                                 (GDestroyNotify)uri_parent_string_hash_value_destroy_func);     /* value_destroy_func */
 110                 }
 111         G_UNLOCK(uri_parent_string_hash);
 112 }
 113
 114
 115 static GnomeVFSResult libntfs_gnomevfs_uri_parent_init(ntfs_volume **volume_return,GnomeVFSURI *uri)
 116 {
 117 gchar *uri_parent_string;
 118 gchar *uri_parent_string_parent;
 119 ntfs_volume *volume;
 120
 121         g_return_val_if_fail(uri!=NULL,GNOME_VFS_ERROR_INVALID_URI);
 122         g_return_val_if_fail(volume_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 123
 124         uri_parent_string_hash_init();
 125
 126         if (!uri->parent)
 127                 return GNOME_VFS_ERROR_INVALID_URI;
 128         if (!uri->text) /* not needed here but we don't permit non-specific fs-image reference */
 129                 return GNOME_VFS_ERROR_INVALID_URI;
 130         uri_parent_string_parent=gnome_vfs_uri_to_string(uri->parent,GNOME_VFS_URI_HIDE_NONE);
 131         g_assert(uri_parent_string_parent!=NULL);
 132
 133         uri_parent_string=g_strdup_printf("%s:%s",uri->method_string,uri_parent_string_parent);
 134         g_assert(uri_parent_string!=NULL);
 135
 136         G_LOCK(uri_parent_string_hash);
 137         volume=g_hash_table_lookup(uri_parent_string_hash,uri_parent_string);
 138         G_UNLOCK(uri_parent_string_hash);
 139         if (!volume) {
 140 struct method_name_info *method_name_info;
 141
 142                 G_LOCK(method_name_hash);
 143                 method_name_info=g_hash_table_lookup(method_name_hash,uri->method_string);
 144                 G_UNLOCK(method_name_hash);
 145                 if (!method_name_info)
 146                         g_return_val_if_reached(GNOME_VFS_ERROR_INVALID_URI);   /* should not happend */
 147
 148                 if (strcmp(uri->parent->method_string,"file")) {        /* TODO: Generic GnomeVFS filter. */
 149                         g_free(uri_parent_string);
 150                         return GNOME_VFS_ERROR_INVALID_URI;
 151                         }
 152
 153                 if (!(volume=ntfs_mount(uri->parent->text,MS_RDONLY))) {
 154                         g_free(uri_parent_string);
 155                         return GNOME_VFS_ERROR_WRONG_FORMAT;
 156                         }
 157
 158                 G_LOCK(uri_parent_string_hash);
 159                 g_hash_table_insert(uri_parent_string_hash,g_strdup(uri_parent_string),volume);
 160                 G_UNLOCK(uri_parent_string_hash);
 161                 }
 162         g_free(uri_parent_string);
 163
 164         *volume_return=volume;
 165         return GNOME_VFS_OK;
 166 }
 167
 168
 169 static GnomeVFSResult inode_open_by_pathname(ntfs_inode **inode_return,ntfs_volume *volume,const gchar *pathname)
 170 {
 171 MFT_REF mref;
 172 ntfs_inode *inode;
 173 gchar *pathname_parse,*pathname_next;
 174 int errint;
 175
 176         g_return_val_if_fail(inode_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 177         g_return_val_if_fail(volume!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 178         g_return_val_if_fail(pathname!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 179
 180         pathname=g_path_skip_root(pathname);
 181         pathname_parse=g_alloca(strlen(pathname)+1);
 182         strcpy(pathname_parse,pathname);
 183         mref=FILE_root;
 184         for (;;) {
 185 uchar_t *pathname_parse_ucs2;
 186 gchar *pathname_parse_unescaped;
 187 int i;
 188
 189                 G_LOCK(libntfs);
 190                 inode=ntfs_inode_open(volume,mref);
 191                 G_UNLOCK(libntfs);
 192                 if (!inode)
 193                         return GNOME_VFS_ERROR_NOT_FOUND;
 194                 if (!*pathname_parse) {
 195                         *inode_return=inode;
 196                         return GNOME_VFS_OK;
 197                         }
 198                 for (pathname_next=pathname_parse;*pathname_next && *pathname_next!=G_DIR_SEPARATOR;pathname_next++);
 199                 if (*pathname_next)
 200                         *pathname_next++='\0';  /* terminate current path element */
 201                 while (*pathname_next==G_DIR_SEPARATOR)
 202                         pathname_next++;
 203                 /* FIXME: Is 'pathname' utf8? */
 204                 pathname_parse_unescaped=gnome_vfs_unescape_string(pathname_parse,
 205                                 NULL);  /* illegal_characters */
 206                 libntfs_newn(pathname_parse_ucs2,strlen(pathname_parse_unescaped)+1);
 207                 for (i=0;pathname_parse_unescaped[i];i++)
 208                         pathname_parse_ucs2[i]=pathname_parse_unescaped[i];
 209                 pathname_parse_ucs2[i]=0;
 210                 g_free(pathname_parse_unescaped);
 211                 G_LOCK(libntfs);
 212                 mref=ntfs_inode_lookup_by_name(inode,pathname_parse_ucs2,i);
 213                 G_UNLOCK(libntfs);
 214                 g_free(pathname_parse_ucs2);
 215                 if ((MFT_REF)-1==mref)
 216                         return GNOME_VFS_ERROR_NOT_FOUND;
 217                 G_LOCK(libntfs);
 218                 errint=ntfs_inode_close(inode);
 219                 G_UNLOCK(libntfs);
 220                 if (errint)
 221                         g_return_val_if_reached(GNOME_VFS_ERROR_INTERNAL);
 222                 pathname_parse=pathname_next;
 223                 }
 224         /* NOTREACHED */
 225 }
 226
 227
 228 struct libntfs_directory {
 229         ntfs_inode *inode;
 230         GList *file_info_list;  /* of (GnomeVFSFileInfo *); last item has ->data==NULL */
 231         };
 232
 233 static GnomeVFSResult libntfs_gnomevfs_open_directory(GnomeVFSMethod *method,
 234                 GnomeVFSMethodHandle **method_handle,GnomeVFSURI *uri,GnomeVFSFileInfoOptions options,GnomeVFSContext *context)
 235 {
 236 GnomeVFSResult errvfsresult;
 237 ntfs_volume *volume;
 238 ntfs_inode *inode;
 239 struct libntfs_directory *libntfs_directory;
 240
 241         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 242         g_return_val_if_fail(method_handle!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 243
 244         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume,uri)))
 245                 return errvfsresult;
 246
 247         if (GNOME_VFS_OK!=(errvfsresult=inode_open_by_pathname(&inode,volume,uri->text)))
 248                 return errvfsresult;
 249
 250         libntfs_new(libntfs_directory);
 251         libntfs_directory->inode=inode;
 252         libntfs_directory->file_info_list=NULL;
 253
 254         *method_handle=(GnomeVFSMethodHandle *)libntfs_directory;
 255         return errvfsresult;
 256 }
 257
 258
 259 static GnomeVFSResult libntfs_gnomevfs_close_directory(GnomeVFSMethod *method,
 260                 GnomeVFSMethodHandle *method_handle,GnomeVFSContext *context)
 261 {
 262 struct libntfs_directory *libntfs_directory;
 263 int errint;
 264
 265         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 266         libntfs_directory=(struct libntfs_directory *)method_handle;
 267         g_return_val_if_fail(libntfs_directory!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 268
 269         G_LOCK(libntfs);
 270         errint=ntfs_inode_close(libntfs_directory->inode);
 271         G_UNLOCK(libntfs);
 272         if (errint)
 273                 g_return_val_if_reached(GNOME_VFS_ERROR_INTERNAL);
 274
 275         if (libntfs_directory->file_info_list) {
 276 GList *last_l;
 277
 278                 /* Prevent gnome_vfs_file_info_list_free() and its gnome_vfs_file_info_unref()
 279                  * on the last 'file_info_list' items as it is EOF with NULL '->data'.
 280                  */
 281                 last_l=g_list_last(libntfs_directory->file_info_list);
 282                 g_assert(last_l->data==NULL);
 283                 libntfs_directory->file_info_list=g_list_delete_link(libntfs_directory->file_info_list,last_l);
 284                 gnome_vfs_file_info_list_free(libntfs_directory->file_info_list);
 285                 }
 286
 287         g_free(libntfs_directory);
 288
 289         return GNOME_VFS_OK;
 290 }
 291
 292
 293 static gchar *libntfs_uchar_to_utf8(const uchar_t *name,const int name_len)
 294 {
 295 GString *gstring;
 296 int i;
 297
 298         gstring=g_string_sized_new(name_len);
 299         for (i=0;i<name_len;i++)
 300                 gstring=g_string_append_unichar(gstring,name[i]);
 301         return g_string_free(gstring,   /* returns utf8-formatted string */
 302                         FALSE); /* free_segment */
 303 }
 304
 305 static int libntfs_gnomevfs_read_directory_filldir(struct libntfs_directory *libntfs_directory /* dirent */,
 306                 const uchar_t *name,const int name_len,const int name_type,const s64 pos,const MFT_REF mref,const unsigned dt_type)
 307 {
 308 GnomeVFSFileInfo *file_info;
 309
 310         g_return_val_if_fail(libntfs_directory!=NULL,-1);
 311         g_return_val_if_fail(name!=NULL,-1);
 312         g_return_val_if_fail(name_len>=0,-1);
 313         g_return_val_if_fail(pos>=0,-1);
 314
 315         if (name_len>0 && name[0]=='$') /* system directory; FIXME: What is its proper identification? */
 316                 return 0;       /* continue traversal */
 317
 318         file_info=gnome_vfs_file_info_new();
 319         file_info->name=libntfs_uchar_to_utf8(name,name_len);
 320         file_info->valid_fields=0;
 321
 322         switch (dt_type) {
 323                 case NTFS_DT_FIFO: file_info->type=GNOME_VFS_FILE_TYPE_FIFO;             break;
 324                 case NTFS_DT_CHR:  file_info->type=GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE; break;
 325                 case NTFS_DT_DIR:  file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY;        break;
 326                 case NTFS_DT_BLK:  file_info->type=GNOME_VFS_FILE_TYPE_BLOCK_DEVICE;     break;
 327                 case NTFS_DT_REG:  file_info->type=GNOME_VFS_FILE_TYPE_REGULAR;          break;
 328                 case NTFS_DT_LNK:  file_info->type=GNOME_VFS_FILE_TYPE_SYMBOLIC_LINK;    break;
 329                 case NTFS_DT_SOCK: file_info->type=GNOME_VFS_FILE_TYPE_SOCKET;           break;
 330                 /* FIXME: What is 'NTFS_DT_WHT'? */
 331                 default: file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN;
 332                 }
 333         if (file_info->type!=GNOME_VFS_FILE_TYPE_UNKNOWN)
 334                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 335
 336         libntfs_directory->file_info_list=g_list_prepend(libntfs_directory->file_info_list,file_info);
 337
 338         return 0;       /* continue traversal */
 339 }
 340
 341
 342 static GnomeVFSResult libntfs_gnomevfs_read_directory(GnomeVFSMethod *method,
 343                 GnomeVFSMethodHandle *method_handle,GnomeVFSFileInfo *file_info,GnomeVFSContext *context)
 344 {
 345 GnomeVFSResult errvfsresult;
 346 struct libntfs_directory *libntfs_directory;
 347
 348         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 349         libntfs_directory=(struct libntfs_directory *)method_handle;
 350         g_return_val_if_fail(libntfs_directory!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 351         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 352
 353         if (!libntfs_directory->file_info_list) {
 354 int errint;
 355 s64 pos;
 356
 357                 pos=0;  /* read from the start; incl. "." and ".." entries */
 358                 G_LOCK(libntfs);
 359                 errint=ntfs_readdir(
 360                                 libntfs_directory->inode,       /* dir_ni */
 361                                 &pos,   /* pos */
 362                                 libntfs_directory,      /* dirent */
 363                                 (ntfs_filldir_t)libntfs_gnomevfs_read_directory_filldir);       /* filldir */
 364                 G_UNLOCK(libntfs);
 365                 if (errint)
 366                         return GNOME_VFS_ERROR_INTERNAL;
 367
 368                 libntfs_directory->file_info_list=g_list_prepend(libntfs_directory->file_info_list,NULL);       /* EOF */
 369                 libntfs_directory->file_info_list=g_list_reverse(libntfs_directory->file_info_list);
 370                 }
 371
 372         if (!libntfs_directory->file_info_list->data) {
 373                 g_assert(libntfs_directory->file_info_list->next==NULL);
 374                 errvfsresult=GNOME_VFS_ERROR_EOF;
 375                 }
 376         else {
 377                 /* Cut first list item. */
 378                 gnome_vfs_file_info_copy(
 379                                 file_info,      /* dest */
 380                                 libntfs_directory->file_info_list->data);       /* src */
 381                 gnome_vfs_file_info_unref(libntfs_directory->file_info_list->data);
 382                 errvfsresult=GNOME_VFS_OK;
 383                 }
 384         libntfs_directory->file_info_list=g_list_delete_link(
 385                         libntfs_directory->file_info_list,libntfs_directory->file_info_list);
 386         return errvfsresult;
 387 }
 388
 389
 390 struct libntfs_file {
 391         ntfs_inode *inode;
 392         ntfs_attr *attr;
 393         s64 pos;
 394         };
 395
 396 static GnomeVFSResult libntfs_open_attr(struct libntfs_file *libntfs_file)
 397 {
 398         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 399         g_return_val_if_fail(libntfs_file->inode!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 400
 401         if (!libntfs_file->attr) {
 402                 G_LOCK(libntfs);
 403                 libntfs_file->attr=ntfs_attr_open(
 404                                 libntfs_file->inode,    /* ni */
 405                                 AT_DATA,        /* type */
 406                                 NULL,   /* name */
 407                                 0);     /* name_len */
 408                 G_UNLOCK(libntfs);
 409                 if (!libntfs_file->attr)
 410                         return GNOME_VFS_ERROR_BAD_FILE;
 411                 libntfs_file->pos=0;
 412                 }
 413
 414         return GNOME_VFS_OK;
 415 }
 416
 417 static GnomeVFSResult libntfs_gnomevfs_open(GnomeVFSMethod *method,
 418                 GnomeVFSMethodHandle **method_handle_return,GnomeVFSURI *uri,GnomeVFSOpenMode mode,GnomeVFSContext *context)
 419 {
 420 GnomeVFSResult errvfsresult;
 421 ntfs_volume *volume;
 422 ntfs_inode *inode;
 423 struct libntfs_file *libntfs_file;
 424
 425         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 426         g_return_val_if_fail(method_handle_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 427
 428         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume,uri)))
 429                 return errvfsresult;
 430
 431         if (mode & GNOME_VFS_OPEN_WRITE)
 432                 return GNOME_VFS_ERROR_READ_ONLY_FILE_SYSTEM;
 433
 434         if (GNOME_VFS_OK!=(errvfsresult=inode_open_by_pathname(&inode,volume,uri->text)))
 435                 return errvfsresult;
 436
 437         libntfs_new(libntfs_file);
 438         libntfs_file->inode=inode;
 439         libntfs_file->attr=NULL;
 440
 441         *method_handle_return=(GnomeVFSMethodHandle *)libntfs_file;
 442         return errvfsresult;
 443 }
 444
 445
 446 static GnomeVFSResult libntfs_gnomevfs_create(GnomeVFSMethod *method,
 447                 GnomeVFSMethodHandle **method_handle_return,GnomeVFSURI *uri,GnomeVFSOpenMode mode,gboolean exclusive,guint perm,
 448                 GnomeVFSContext *context)
 449 {
 450 GnomeVFSResult errvfsresult;
 451 ntfs_volume *volume;
 452
 453         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 454         g_return_val_if_fail(method_handle_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 455
 456         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume,uri)))
 457                 return errvfsresult;
 458
 459         return GNOME_VFS_ERROR_READ_ONLY_FILE_SYSTEM;
 460 }
 461
 462
 463 static GnomeVFSResult libntfs_gnomevfs_close(GnomeVFSMethod *method,
 464                 GnomeVFSMethodHandle *method_handle,GnomeVFSContext *context)
 465 {
 466 struct libntfs_file *libntfs_file;
 467 int errint;
 468
 469         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 470         libntfs_file=(struct libntfs_file *)method_handle;
 471         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 472
 473         if (libntfs_file->attr) {
 474                 G_LOCK(libntfs);
 475                 ntfs_attr_close(libntfs_file->attr);
 476                 G_UNLOCK(libntfs);
 477                 }
 478         G_LOCK(libntfs);
 479         errint=ntfs_inode_close(libntfs_file->inode);
 480         G_UNLOCK(libntfs);
 481         if (errint)
 482                 g_return_val_if_reached(GNOME_VFS_ERROR_INTERNAL);
 483
 484         g_free(libntfs_file);
 485
 486         return GNOME_VFS_OK;
 487 }
 488
 489
 490 static GnomeVFSResult libntfs_gnomevfs_read(GnomeVFSMethod *method,GnomeVFSMethodHandle *method_handle,
 491                 gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return,GnomeVFSContext *context)
 492 {
 493 GnomeVFSResult errvfsresult;
 494 struct libntfs_file *libntfs_file;
 495 s64 count_s64,got;
 496
 497         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 498         libntfs_file=(struct libntfs_file *)method_handle;
 499         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 500         g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 501         g_return_val_if_fail(bytes_read_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 502
 503         if (GNOME_VFS_OK!=(errvfsresult=libntfs_open_attr(libntfs_file)))
 504                 return errvfsresult;
 505
 506         count_s64=num_bytes;
 507         g_assert((GnomeVFSFileSize)count_s64==num_bytes);
 508         G_LOCK(libntfs);
 509         got=ntfs_attr_pread(libntfs_file->attr,libntfs_file->pos,count_s64,buffer);
 510         G_UNLOCK(libntfs);
 511         if (got==-1)
 512                 return GNOME_VFS_ERROR_IO;
 513
 514         libntfs_file->pos+=got;
 515         *bytes_read_return=got;
 516         g_assert((s64)*bytes_read_return==got);
 517
 518         return GNOME_VFS_OK;
 519 }
 520
 521
 522 static GnomeVFSResult libntfs_gnomevfs_seek(GnomeVFSMethod *method,
 523                 GnomeVFSMethodHandle *method_handle,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset,GnomeVFSContext *context)
 524 {
 525 GnomeVFSResult errvfsresult;
 526 struct libntfs_file *libntfs_file;
 527
 528         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 529         libntfs_file=(struct libntfs_file *)method_handle;
 530         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 531
 532         if (GNOME_VFS_OK!=(errvfsresult=libntfs_open_attr(libntfs_file)))
 533                 return errvfsresult;
 534
 535         switch (whence) {
 536                 case GNOME_VFS_SEEK_START:
 537                         libntfs_file->pos=offset;
 538                         break;
 539                 case GNOME_VFS_SEEK_CURRENT:
 540                         libntfs_file->pos+=offset;
 541                         break;
 542                 case GNOME_VFS_SEEK_END:
 543                         g_return_val_if_reached(GNOME_VFS_ERROR_BAD_PARAMETERS);        /* FIXME: NOT IMPLEMENTED YET */
 544                 default: g_assert_not_reached();
 545                 }
 546
 547         return GNOME_VFS_OK;
 548 }
 549
 550 static GnomeVFSResult libntfs_gnomevfs_tell(GnomeVFSMethod *method,
 551                 GnomeVFSMethodHandle *method_handle,GnomeVFSFileOffset *offset_return)
 552 {
 553 GnomeVFSResult errvfsresult;
 554 struct libntfs_file *libntfs_file;
 555
 556         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 557         libntfs_file=(struct libntfs_file *)method_handle;
 558         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 559         g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 560
 561         if (GNOME_VFS_OK!=(errvfsresult=libntfs_open_attr(libntfs_file)))
 562                 return errvfsresult;
 563
 564         *offset_return=libntfs_file->pos;
 565         g_assert(*offset_return==libntfs_file->pos);
 566
 567         return errvfsresult;
 568 }
 569
 570
 571 static gboolean libntfs_gnomevfs_is_local(GnomeVFSMethod *method,const GnomeVFSURI *uri)
 572 {
 573         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 574         g_return_val_if_fail(uri!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 575
 576         return gnome_vfs_uri_is_local(uri->parent);
 577 }
 578
 579
 580 GnomeVFSResult libntfs_gnomevfs_get_file_info_from_handle(GnomeVFSMethod *method,
 581                 GnomeVFSMethodHandle *method_handle,GnomeVFSFileInfo *file_info,GnomeVFSFileInfoOptions options,GnomeVFSContext *context)
 582 {
 583 GnomeVFSResult errvfsresult;
 584 struct libntfs_file *libntfs_file;
 585
 586         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 587         libntfs_file=(struct libntfs_file *)method_handle;
 588         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 589         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 590         /* handle 'options & GNOME_VFS_FILE_INFO_GET_MIME_TYPE'? */
 591
 592         file_info->valid_fields=0;
 593         file_info->name=NULL;   /* FIXME: It is complicated to read filename of open 'ntfs_inode'. */
 594
 595         if (GNOME_VFS_OK!=(errvfsresult=libntfs_open_attr(libntfs_file))) {
 596                 /* Assume we are directory: */
 597                 file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY;
 598                 /* Do not: file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 599                  * as gnome-vfs-xfer.c/copy_items() does not check 'GNOME_VFS_FILE_INFO_FIELDS_TYPE'
 600                  * and we are just bluffing we know it.
 601                  */
 602                 return GNOME_VFS_OK;
 603                 }
 604
 605         file_info->size=libntfs_file->attr->data_size;  /* FIXME: Is 'data_size' the right field? */
 606         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE;
 607
 608         /* FIXME: We do not really know the type of 'libntfs_file'
 609          * but gnome-vfs-xfer.c/copy_items() requires 'GNOME_VFS_FILE_TYPE_REGULAR'
 610          * to copy it.
 611          */
 612         file_info->type=GNOME_VFS_FILE_TYPE_REGULAR;
 613         /* Do not: file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 614          * as gnome-vfs-xfer.c/copy_items() does not check 'GNOME_VFS_FILE_INFO_FIELDS_TYPE'
 615          * and we are just bluffing we know it.
 616          */
 617
 618         return errvfsresult;
 619 }
 620
 621
 622 static GnomeVFSResult libntfs_gnomevfs_get_file_info(GnomeVFSMethod *method,
 623                 GnomeVFSURI *uri,GnomeVFSFileInfo *file_info,GnomeVFSFileInfoOptions options,GnomeVFSContext *context)
 624 {
 625 GnomeVFSResult errvfsresult;
 626 GnomeVFSMethodHandle *method_handle;
 627
 628         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 629         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 630         /* handle 'options & GNOME_VFS_FILE_INFO_GET_MIME_TYPE'? */
 631
 632         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_open(method,&method_handle,uri,GNOME_VFS_OPEN_READ,context)))
 633                 return errvfsresult;
 634         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_get_file_info_from_handle(method,method_handle,file_info,options,context)))
 635                 return errvfsresult;
 636         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_close(method,method_handle,context)))
 637                 return errvfsresult;
 638
 639         return GNOME_VFS_OK;
 640 }
 641
 642
 643 GnomeVFSResult libntfs_gnomevfs_check_same_fs(GnomeVFSMethod *method,
 644                 GnomeVFSURI *a,GnomeVFSURI *b,gboolean *same_fs_return,GnomeVFSContext *context)
 645 {
 646 ntfs_volume *volume_a;
 647 ntfs_volume *volume_b;
 648 GnomeVFSResult errvfsresult;
 649
 650         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 651         g_return_val_if_fail(same_fs_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 652
 653         errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume_a,a);
 654         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 655
 656         errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume_b,b);
 657         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 658
 659         *same_fs_return=(volume_a==volume_b);
 660
 661         return GNOME_VFS_OK;
 662 }
 663
 664
 665 /**
 666  * libntfs_gnomevfs_init:
 667  *
 668  * Returns: Initialized structure of #GnomeVFSMethod with static methods of libntfs-gnomevfs.
 669  */
 670 GnomeVFSMethod *libntfs_gnomevfs_method_init(const gchar *method_name,const gchar *args)
 671 {
 672 struct method_name_info *method_name_info;
 673
 674         g_return_val_if_fail(method_name!=NULL,NULL);
 675         /* 'args' may be NULL if not supplied. */
 676
 677         method_name_hash_init();
 678
 679         G_LOCK(method_name_hash);
 680         method_name_info=g_hash_table_lookup(method_name_hash,method_name);
 681         if (method_name_info && strcmp(method_name_info->args,args))
 682                 method_name_info=NULL;
 683         G_UNLOCK(method_name_hash);
 684         if (!method_name_info) {
 685                 libntfs_new(method_name_info);
 686                 method_name_info->args=g_strdup(args);
 687                 G_LOCK(method_name_hash);
 688                 g_hash_table_replace(method_name_hash,g_strdup(method_name),method_name_info);
 689                 G_UNLOCK(method_name_hash);
 690                 }
 691
 692         G_LOCK(GnomeVFSMethod_static);
 693         LIBNTFS_MEMZERO(&GnomeVFSMethod_static);
 694         GnomeVFSMethod_static.method_table_size=sizeof(GnomeVFSMethod_static);
 695         GnomeVFSMethod_static.open                     =libntfs_gnomevfs_open;  /* mandatory */
 696         GnomeVFSMethod_static.create                   =libntfs_gnomevfs_create;        /* mandatory */
 697         GnomeVFSMethod_static.close                    =libntfs_gnomevfs_close;
 698         GnomeVFSMethod_static.read                     =libntfs_gnomevfs_read;
 699         GnomeVFSMethod_static.seek                     =libntfs_gnomevfs_seek;
 700         GnomeVFSMethod_static.tell                     =libntfs_gnomevfs_tell;
 701         GnomeVFSMethod_static.open_directory           =libntfs_gnomevfs_open_directory;
 702         GnomeVFSMethod_static.close_directory          =libntfs_gnomevfs_close_directory;
 703         GnomeVFSMethod_static.read_directory           =libntfs_gnomevfs_read_directory;
 704         GnomeVFSMethod_static.get_file_info            =libntfs_gnomevfs_get_file_info; /* mandatory */
 705         GnomeVFSMethod_static.get_file_info_from_handle=libntfs_gnomevfs_get_file_info_from_handle;
 706         GnomeVFSMethod_static.is_local                 =libntfs_gnomevfs_is_local;      /* mandatory */
 707         GnomeVFSMethod_static.check_same_fs            =libntfs_gnomevfs_check_same_fs;
 708         /* TODO: GnomeVFSMethodFindDirectoryFunc find_directory; */
 709         /* TODO: GnomeVFSMethodFileControlFunc file_control; */
 710         /* R/W:  GnomeVFSMethodCreateSymbolicLinkFunc create_symbolic_link; */
 711         /* R/W:  GnomeVFSMethodMonitorAddFunc monitor_add; */
 712         /* R/W:  GnomeVFSMethodMonitorCancelFunc monitor_cancel; */
 713         /* R/W:  GnomeVFSMethod_static.write; */
 714         /* R/W:  GnomeVFSMethod_static.truncate_handle; */
 715         /* R/W:  GnomeVFSMethod_static.make_directory; */
 716         /* R/W:  GnomeVFSMethod_static.remove_directory; */
 717         /* R/W:  GnomeVFSMethod_static.move; */
 718         /* R/W:  GnomeVFSMethod_static.unlink; */
 719         /* R/W:  GnomeVFSMethod_static.set_file_info; */
 720         /* R/W:  GnomeVFSMethod_static.truncate; */
 721         G_UNLOCK(GnomeVFSMethod_static);
 722
 723         return &GnomeVFSMethod_static;
 724 }
 725
 726
 727 /**
 728  * libntfs_gnomevfs_method_shutdown:
 729  *
 730  * Shutdowns libntfs-gnomevfs successfuly flushing all caches.
 731  *
 732  * Sad note about gnome-vfs-2.1.5 is that it never calls this function. :-)
 733  */
 734 void libntfs_gnomevfs_method_shutdown(void)
 735 {
 736         uri_parent_string_hash_init();
 737         G_LOCK(uri_parent_string_hash);
 738         g_hash_table_destroy(uri_parent_string_hash);
 739         uri_parent_string_hash=NULL;
 740         G_UNLOCK(uri_parent_string_hash);
 741
 742         method_name_hash_init();
 743         G_LOCK(method_name_hash);
 744         g_hash_table_destroy(method_name_hash);
 745         method_name_hash=NULL;
 746         G_UNLOCK(method_name_hash);
 747 }