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 /* Do not lock 'libntfs' here as we are already locked
 306  * inside ntfs_readdir().
 307  */
 308 static int libntfs_gnomevfs_read_directory_filldir(struct libntfs_directory *libntfs_directory /* dirent */,
 309                 const uchar_t *name,const int name_len,const int name_type,const s64 pos,const MFT_REF mref,const unsigned dt_type)
 310 {
 311 GnomeVFSFileInfo *file_info;
 312
 313         g_return_val_if_fail(libntfs_directory!=NULL,-1);
 314         g_return_val_if_fail(name!=NULL,-1);
 315         g_return_val_if_fail(name_len>=0,-1);
 316         g_return_val_if_fail(pos>=0,-1);
 317
 318         if (name_len>0 && name[0]=='$') /* system directory; FIXME: What is its proper identification? */
 319                 return 0;       /* continue traversal */
 320
 321         file_info=gnome_vfs_file_info_new();
 322         file_info->name=libntfs_uchar_to_utf8(name,name_len);
 323         file_info->valid_fields=0;
 324
 325         switch (dt_type) {
 326                 case NTFS_DT_FIFO: file_info->type=GNOME_VFS_FILE_TYPE_FIFO;             break;
 327                 case NTFS_DT_CHR:  file_info->type=GNOME_VFS_FILE_TYPE_CHARACTER_DEVICE; break;
 328                 case NTFS_DT_DIR:  file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY;        break;
 329                 case NTFS_DT_BLK:  file_info->type=GNOME_VFS_FILE_TYPE_BLOCK_DEVICE;     break;
 330                 case NTFS_DT_REG:  file_info->type=GNOME_VFS_FILE_TYPE_REGULAR;          break;
 331                 case NTFS_DT_LNK:  file_info->type=GNOME_VFS_FILE_TYPE_SYMBOLIC_LINK;    break;
 332                 case NTFS_DT_SOCK: file_info->type=GNOME_VFS_FILE_TYPE_SOCKET;           break;
 333                 /* FIXME: What is 'NTFS_DT_WHT'? */
 334                 default: file_info->type=GNOME_VFS_FILE_TYPE_UNKNOWN;
 335                 }
 336         if (file_info->type!=GNOME_VFS_FILE_TYPE_UNKNOWN)
 337                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 338
 339         /* Detect 'file_info->size': */
 340         if (file_info->type==GNOME_VFS_FILE_TYPE_REGULAR) {
 341 ntfs_inode *inode;
 342
 343                 inode=ntfs_inode_open(libntfs_directory->inode->vol,mref);
 344                 /* FIXME: Check failed 'inode' open. */
 345                 if (inode) {
 346 ntfs_attr *attr;
 347 int errint;
 348
 349                         attr=ntfs_attr_open(
 350                                         inode,  /* ni */
 351                                         AT_DATA,        /* type */
 352                                         NULL,   /* name */
 353                                         0);     /* name_len */
 354                         /* FIXME: Check failed 'attr' open. */
 355                         if (attr) {
 356                                 file_info->size=attr->data_size;        /* FIXME: Is 'data_size' the right field? */
 357                                 file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE;
 358                                 ntfs_attr_close(attr);
 359                                 }
 360                         errint=ntfs_inode_close(inode);
 361                         /* FIXME: Check 'errint'. */
 362                         }
 363                 }
 364
 365         libntfs_directory->file_info_list=g_list_prepend(libntfs_directory->file_info_list,file_info);
 366
 367         return 0;       /* continue traversal */
 368 }
 369
 370
 371 static GnomeVFSResult libntfs_gnomevfs_read_directory(GnomeVFSMethod *method,
 372                 GnomeVFSMethodHandle *method_handle,GnomeVFSFileInfo *file_info,GnomeVFSContext *context)
 373 {
 374 GnomeVFSResult errvfsresult;
 375 struct libntfs_directory *libntfs_directory;
 376
 377         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 378         libntfs_directory=(struct libntfs_directory *)method_handle;
 379         g_return_val_if_fail(libntfs_directory!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 380         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 381
 382         if (!libntfs_directory->file_info_list) {
 383 int errint;
 384 s64 pos;
 385
 386                 pos=0;  /* read from the start; incl. "." and ".." entries */
 387                 G_LOCK(libntfs);
 388                 errint=ntfs_readdir(
 389                                 libntfs_directory->inode,       /* dir_ni */
 390                                 &pos,   /* pos */
 391                                 libntfs_directory,      /* dirent */
 392                                 (ntfs_filldir_t)libntfs_gnomevfs_read_directory_filldir);       /* filldir */
 393                 G_UNLOCK(libntfs);
 394                 if (errint)
 395                         return GNOME_VFS_ERROR_INTERNAL;
 396
 397                 libntfs_directory->file_info_list=g_list_prepend(libntfs_directory->file_info_list,NULL);       /* EOF */
 398                 libntfs_directory->file_info_list=g_list_reverse(libntfs_directory->file_info_list);
 399                 }
 400
 401         if (!libntfs_directory->file_info_list->data) {
 402                 g_assert(libntfs_directory->file_info_list->next==NULL);
 403                 errvfsresult=GNOME_VFS_ERROR_EOF;
 404                 }
 405         else {
 406                 /* Cut first list item. */
 407                 gnome_vfs_file_info_copy(
 408                                 file_info,      /* dest */
 409                                 libntfs_directory->file_info_list->data);       /* src */
 410                 gnome_vfs_file_info_unref(libntfs_directory->file_info_list->data);
 411                 errvfsresult=GNOME_VFS_OK;
 412                 }
 413         libntfs_directory->file_info_list=g_list_delete_link(
 414                         libntfs_directory->file_info_list,libntfs_directory->file_info_list);
 415         return errvfsresult;
 416 }
 417
 418
 419 struct libntfs_file {
 420         ntfs_inode *inode;
 421         ntfs_attr *attr;
 422         s64 pos;
 423         };
 424
 425 static GnomeVFSResult libntfs_open_attr(struct libntfs_file *libntfs_file)
 426 {
 427         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 428         g_return_val_if_fail(libntfs_file->inode!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 429
 430         if (!libntfs_file->attr) {
 431                 G_LOCK(libntfs);
 432                 libntfs_file->attr=ntfs_attr_open(
 433                                 libntfs_file->inode,    /* ni */
 434                                 AT_DATA,        /* type */
 435                                 NULL,   /* name */
 436                                 0);     /* name_len */
 437                 G_UNLOCK(libntfs);
 438                 if (!libntfs_file->attr)
 439                         return GNOME_VFS_ERROR_BAD_FILE;
 440                 libntfs_file->pos=0;
 441                 }
 442
 443         return GNOME_VFS_OK;
 444 }
 445
 446 static GnomeVFSResult libntfs_gnomevfs_open(GnomeVFSMethod *method,
 447                 GnomeVFSMethodHandle **method_handle_return,GnomeVFSURI *uri,GnomeVFSOpenMode mode,GnomeVFSContext *context)
 448 {
 449 GnomeVFSResult errvfsresult;
 450 ntfs_volume *volume;
 451 ntfs_inode *inode;
 452 struct libntfs_file *libntfs_file;
 453
 454         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 455         g_return_val_if_fail(method_handle_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 456
 457         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume,uri)))
 458                 return errvfsresult;
 459
 460         if (mode & GNOME_VFS_OPEN_WRITE)
 461                 return GNOME_VFS_ERROR_READ_ONLY_FILE_SYSTEM;
 462
 463         if (GNOME_VFS_OK!=(errvfsresult=inode_open_by_pathname(&inode,volume,uri->text)))
 464                 return errvfsresult;
 465
 466         libntfs_new(libntfs_file);
 467         libntfs_file->inode=inode;
 468         libntfs_file->attr=NULL;
 469
 470         *method_handle_return=(GnomeVFSMethodHandle *)libntfs_file;
 471         return errvfsresult;
 472 }
 473
 474
 475 static GnomeVFSResult libntfs_gnomevfs_create(GnomeVFSMethod *method,
 476                 GnomeVFSMethodHandle **method_handle_return,GnomeVFSURI *uri,GnomeVFSOpenMode mode,gboolean exclusive,guint perm,
 477                 GnomeVFSContext *context)
 478 {
 479 GnomeVFSResult errvfsresult;
 480 ntfs_volume *volume;
 481
 482         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 483         g_return_val_if_fail(method_handle_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 484
 485         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume,uri)))
 486                 return errvfsresult;
 487
 488         return GNOME_VFS_ERROR_READ_ONLY_FILE_SYSTEM;
 489 }
 490
 491
 492 static GnomeVFSResult libntfs_gnomevfs_close(GnomeVFSMethod *method,
 493                 GnomeVFSMethodHandle *method_handle,GnomeVFSContext *context)
 494 {
 495 struct libntfs_file *libntfs_file;
 496 int errint;
 497
 498         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 499         libntfs_file=(struct libntfs_file *)method_handle;
 500         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 501
 502         if (libntfs_file->attr) {
 503                 G_LOCK(libntfs);
 504                 ntfs_attr_close(libntfs_file->attr);
 505                 G_UNLOCK(libntfs);
 506                 }
 507         G_LOCK(libntfs);
 508         errint=ntfs_inode_close(libntfs_file->inode);
 509         G_UNLOCK(libntfs);
 510         if (errint)
 511                 g_return_val_if_reached(GNOME_VFS_ERROR_INTERNAL);
 512
 513         g_free(libntfs_file);
 514
 515         return GNOME_VFS_OK;
 516 }
 517
 518
 519 static GnomeVFSResult libntfs_gnomevfs_read(GnomeVFSMethod *method,GnomeVFSMethodHandle *method_handle,
 520                 gpointer buffer,GnomeVFSFileSize num_bytes,GnomeVFSFileSize *bytes_read_return,GnomeVFSContext *context)
 521 {
 522 GnomeVFSResult errvfsresult;
 523 struct libntfs_file *libntfs_file;
 524 s64 count_s64,got;
 525
 526         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 527         libntfs_file=(struct libntfs_file *)method_handle;
 528         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 529         g_return_val_if_fail(buffer!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 530         g_return_val_if_fail(bytes_read_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 531
 532         if (GNOME_VFS_OK!=(errvfsresult=libntfs_open_attr(libntfs_file)))
 533                 return errvfsresult;
 534
 535         count_s64=num_bytes;
 536         g_assert((GnomeVFSFileSize)count_s64==num_bytes);
 537         G_LOCK(libntfs);
 538         got=ntfs_attr_pread(libntfs_file->attr,libntfs_file->pos,count_s64,buffer);
 539         G_UNLOCK(libntfs);
 540         if (got==-1)
 541                 return GNOME_VFS_ERROR_IO;
 542
 543         libntfs_file->pos+=got;
 544         *bytes_read_return=got;
 545         g_assert((s64)*bytes_read_return==got);
 546
 547         return GNOME_VFS_OK;
 548 }
 549
 550
 551 static GnomeVFSResult libntfs_gnomevfs_seek(GnomeVFSMethod *method,
 552                 GnomeVFSMethodHandle *method_handle,GnomeVFSSeekPosition whence,GnomeVFSFileOffset offset,GnomeVFSContext *context)
 553 {
 554 GnomeVFSResult errvfsresult;
 555 struct libntfs_file *libntfs_file;
 556
 557         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 558         libntfs_file=(struct libntfs_file *)method_handle;
 559         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 560
 561         if (GNOME_VFS_OK!=(errvfsresult=libntfs_open_attr(libntfs_file)))
 562                 return errvfsresult;
 563
 564         switch (whence) {
 565                 case GNOME_VFS_SEEK_START:
 566                         libntfs_file->pos=offset;
 567                         break;
 568                 case GNOME_VFS_SEEK_CURRENT:
 569                         libntfs_file->pos+=offset;
 570                         break;
 571                 case GNOME_VFS_SEEK_END:
 572                         g_return_val_if_reached(GNOME_VFS_ERROR_BAD_PARAMETERS);        /* FIXME: NOT IMPLEMENTED YET */
 573                 default: g_assert_not_reached();
 574                 }
 575
 576         return GNOME_VFS_OK;
 577 }
 578
 579 static GnomeVFSResult libntfs_gnomevfs_tell(GnomeVFSMethod *method,
 580                 GnomeVFSMethodHandle *method_handle,GnomeVFSFileOffset *offset_return)
 581 {
 582 GnomeVFSResult errvfsresult;
 583 struct libntfs_file *libntfs_file;
 584
 585         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 586         libntfs_file=(struct libntfs_file *)method_handle;
 587         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 588         g_return_val_if_fail(offset_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 589
 590         if (GNOME_VFS_OK!=(errvfsresult=libntfs_open_attr(libntfs_file)))
 591                 return errvfsresult;
 592
 593         *offset_return=libntfs_file->pos;
 594         g_assert(*offset_return==libntfs_file->pos);
 595
 596         return errvfsresult;
 597 }
 598
 599
 600 static gboolean libntfs_gnomevfs_is_local(GnomeVFSMethod *method,const GnomeVFSURI *uri)
 601 {
 602         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 603         g_return_val_if_fail(uri!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 604
 605         return gnome_vfs_uri_is_local(uri->parent);
 606 }
 607
 608
 609 GnomeVFSResult libntfs_gnomevfs_get_file_info_from_handle(GnomeVFSMethod *method,
 610                 GnomeVFSMethodHandle *method_handle,GnomeVFSFileInfo *file_info,GnomeVFSFileInfoOptions options,GnomeVFSContext *context)
 611 {
 612 GnomeVFSResult errvfsresult;
 613 struct libntfs_file *libntfs_file;
 614
 615         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 616         libntfs_file=(struct libntfs_file *)method_handle;
 617         g_return_val_if_fail(libntfs_file!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 618         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 619         /* handle 'options & GNOME_VFS_FILE_INFO_GET_MIME_TYPE'? */
 620
 621         file_info->valid_fields=0;
 622         file_info->name=NULL;   /* FIXME: It is complicated to read filename of open 'ntfs_inode'. */
 623
 624         if (GNOME_VFS_OK!=(errvfsresult=libntfs_open_attr(libntfs_file))) {
 625                 /* Assume we are directory: */
 626                 file_info->type=GNOME_VFS_FILE_TYPE_DIRECTORY;
 627                 /* Do not: file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 628                  * as gnome-vfs-xfer.c/copy_items() does not check 'GNOME_VFS_FILE_INFO_FIELDS_TYPE'
 629                  * and we are just bluffing we know it.
 630                  */
 631                 return GNOME_VFS_OK;
 632                 }
 633
 634         file_info->size=libntfs_file->attr->data_size;  /* FIXME: Is 'data_size' the right field? */
 635         file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_SIZE;
 636
 637         /* FIXME: We do not really know the type of 'libntfs_file'
 638          * but gnome-vfs-xfer.c/copy_items() requires 'GNOME_VFS_FILE_TYPE_REGULAR'
 639          * to copy it.
 640          */
 641         file_info->type=GNOME_VFS_FILE_TYPE_REGULAR;
 642         /* Do not: file_info->valid_fields|=GNOME_VFS_FILE_INFO_FIELDS_TYPE;
 643          * as gnome-vfs-xfer.c/copy_items() does not check 'GNOME_VFS_FILE_INFO_FIELDS_TYPE'
 644          * and we are just bluffing we know it.
 645          */
 646
 647         return errvfsresult;
 648 }
 649
 650
 651 static GnomeVFSResult libntfs_gnomevfs_get_file_info(GnomeVFSMethod *method,
 652                 GnomeVFSURI *uri,GnomeVFSFileInfo *file_info,GnomeVFSFileInfoOptions options,GnomeVFSContext *context)
 653 {
 654 GnomeVFSResult errvfsresult;
 655 GnomeVFSMethodHandle *method_handle;
 656
 657         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 658         g_return_val_if_fail(file_info!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 659         /* handle 'options & GNOME_VFS_FILE_INFO_GET_MIME_TYPE'? */
 660
 661         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_open(method,&method_handle,uri,GNOME_VFS_OPEN_READ,context)))
 662                 return errvfsresult;
 663         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_get_file_info_from_handle(method,method_handle,file_info,options,context)))
 664                 return errvfsresult;
 665         if (GNOME_VFS_OK!=(errvfsresult=libntfs_gnomevfs_close(method,method_handle,context)))
 666                 return errvfsresult;
 667
 668         return GNOME_VFS_OK;
 669 }
 670
 671
 672 GnomeVFSResult libntfs_gnomevfs_check_same_fs(GnomeVFSMethod *method,
 673                 GnomeVFSURI *a,GnomeVFSURI *b,gboolean *same_fs_return,GnomeVFSContext *context)
 674 {
 675 ntfs_volume *volume_a;
 676 ntfs_volume *volume_b;
 677 GnomeVFSResult errvfsresult;
 678
 679         g_return_val_if_fail(method==&GnomeVFSMethod_static,GNOME_VFS_ERROR_BAD_PARAMETERS);
 680         g_return_val_if_fail(same_fs_return!=NULL,GNOME_VFS_ERROR_BAD_PARAMETERS);
 681
 682         errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume_a,a);
 683         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 684
 685         errvfsresult=libntfs_gnomevfs_uri_parent_init(&volume_b,b);
 686         g_return_val_if_fail(errvfsresult==GNOME_VFS_OK,errvfsresult);
 687
 688         *same_fs_return=(volume_a==volume_b);
 689
 690         return GNOME_VFS_OK;
 691 }
 692
 693
 694 /**
 695  * libntfs_gnomevfs_init:
 696  *
 697  * Returns: Initialized structure of #GnomeVFSMethod with static methods of libntfs-gnomevfs.
 698  */
 699 GnomeVFSMethod *libntfs_gnomevfs_method_init(const gchar *method_name,const gchar *args)
 700 {
 701 struct method_name_info *method_name_info;
 702
 703         g_return_val_if_fail(method_name!=NULL,NULL);
 704         /* 'args' may be NULL if not supplied. */
 705
 706         method_name_hash_init();
 707
 708         G_LOCK(method_name_hash);
 709         method_name_info=g_hash_table_lookup(method_name_hash,method_name);
 710         if (method_name_info && strcmp(method_name_info->args,args))
 711                 method_name_info=NULL;
 712         G_UNLOCK(method_name_hash);
 713         if (!method_name_info) {
 714                 libntfs_new(method_name_info);
 715                 method_name_info->args=g_strdup(args);
 716                 G_LOCK(method_name_hash);
 717                 g_hash_table_replace(method_name_hash,g_strdup(method_name),method_name_info);
 718                 G_UNLOCK(method_name_hash);
 719                 }
 720
 721         G_LOCK(GnomeVFSMethod_static);
 722         LIBNTFS_MEMZERO(&GnomeVFSMethod_static);
 723         GnomeVFSMethod_static.method_table_size=sizeof(GnomeVFSMethod_static);
 724         GnomeVFSMethod_static.open                     =libntfs_gnomevfs_open;  /* mandatory */
 725         GnomeVFSMethod_static.create                   =libntfs_gnomevfs_create;        /* mandatory */
 726         GnomeVFSMethod_static.close                    =libntfs_gnomevfs_close;
 727         GnomeVFSMethod_static.read                     =libntfs_gnomevfs_read;
 728         GnomeVFSMethod_static.seek                     =libntfs_gnomevfs_seek;
 729         GnomeVFSMethod_static.tell                     =libntfs_gnomevfs_tell;
 730         GnomeVFSMethod_static.open_directory           =libntfs_gnomevfs_open_directory;
 731         GnomeVFSMethod_static.close_directory          =libntfs_gnomevfs_close_directory;
 732         GnomeVFSMethod_static.read_directory           =libntfs_gnomevfs_read_directory;
 733         GnomeVFSMethod_static.get_file_info            =libntfs_gnomevfs_get_file_info; /* mandatory */
 734         GnomeVFSMethod_static.get_file_info_from_handle=libntfs_gnomevfs_get_file_info_from_handle;
 735         GnomeVFSMethod_static.is_local                 =libntfs_gnomevfs_is_local;      /* mandatory */
 736         GnomeVFSMethod_static.check_same_fs            =libntfs_gnomevfs_check_same_fs;
 737         /* TODO: GnomeVFSMethodFindDirectoryFunc find_directory; */
 738         /* TODO: GnomeVFSMethodFileControlFunc file_control; */
 739         /* R/W:  GnomeVFSMethodCreateSymbolicLinkFunc create_symbolic_link; */
 740         /* R/W:  GnomeVFSMethodMonitorAddFunc monitor_add; */
 741         /* R/W:  GnomeVFSMethodMonitorCancelFunc monitor_cancel; */
 742         /* R/W:  GnomeVFSMethod_static.write; */
 743         /* R/W:  GnomeVFSMethod_static.truncate_handle; */
 744         /* R/W:  GnomeVFSMethod_static.make_directory; */
 745         /* R/W:  GnomeVFSMethod_static.remove_directory; */
 746         /* R/W:  GnomeVFSMethod_static.move; */
 747         /* R/W:  GnomeVFSMethod_static.unlink; */
 748         /* R/W:  GnomeVFSMethod_static.set_file_info; */
 749         /* R/W:  GnomeVFSMethod_static.truncate; */
 750         G_UNLOCK(GnomeVFSMethod_static);
 751
 752         return &GnomeVFSMethod_static;
 753 }
 754
 755
 756 /**
 757  * libntfs_gnomevfs_method_shutdown:
 758  *
 759  * Shutdowns libntfs-gnomevfs successfuly flushing all caches.
 760  *
 761  * Sad note about gnome-vfs-2.1.5 is that it never calls this function. :-)
 762  */
 763 void libntfs_gnomevfs_method_shutdown(void)
 764 {
 765         uri_parent_string_hash_init();
 766         G_LOCK(uri_parent_string_hash);
 767         g_hash_table_destroy(uri_parent_string_hash);
 768         uri_parent_string_hash=NULL;
 769         G_UNLOCK(uri_parent_string_hash);
 770
 771         method_name_hash_init();
 772         G_LOCK(method_name_hash);
 773         g_hash_table_destroy(method_name_hash);
 774         method_name_hash=NULL;
 775         G_UNLOCK(method_name_hash);
 776 }