src/vfs/undelfs/undelfs.c

   1 /*
   2    UnDel File System: Midnight Commander file system.
   3
   4    This file system is intended to be used together with the
   5    ext2fs library to recover files from ext2fs file systems.
   6
   7    Parts of this program were taken from the lsdel.c and dump.c files
   8    written by Ted Ts'o (tytso@mit.edu) for the ext2fs package.
   9
  10    Copyright (C) 1995, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004,
  11    2005, 2007, 2011
  12    The Free Software Foundation, Inc.
  13
  14    Written by:
  15    Miguel de Icaza, 1995
  16    Norbert Warmuth, 1997
  17    Pavel Machek, 2000
  18
  19    This file is part of the Midnight Commander.
  20
  21    The Midnight Commander is free software: you can redistribute it
  22    and/or modify it under the terms of the GNU General Public License as
  23    published by the Free Software Foundation, either version 3 of the License,
  24    or (at your option) any later version.
  25
  26    The Midnight Commander is distributed in the hope that it will be useful,
  27    but WITHOUT ANY WARRANTY; without even the implied warranty of
  28    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  29    GNU General Public License for more details.
  30
  31    You should have received a copy of the GNU General Public License
  32    along with this program.  If not, see <http://www.gnu.org/licenses/>.
  33  */
  34
  35 /**
  36  * \file
  37  * \brief Source: UnDel File System
  38  *
  39  * Assumptions:
  40  *
  41  * 1. We don't handle directories (thus undelfs_get_path is easy to write).
  42  * 2. Files are on the local file system (we do not support vfs files
  43  *    because we would have to provide an io_manager for the ext2fs tools,
  44  *    and I don't think it would be too useful to undelete files
  45  */
  46
  47 #include <config.h>
  48
  49 #include <errno.h>
  50 #include <stdio.h>
  51 #include <stdlib.h>
  52 #include <fcntl.h>
  53
  54 #ifdef HAVE_EXT2FS_EXT2_FS_H
  55 #include <ext2fs/ext2_fs.h>
  56 #else
  57 /* asm/types.h defines its own umode_t */
  58 #undef umode_t
  59 #include <linux/ext2_fs.h>
  60 #endif
  61
  62 #include <ext2fs/ext2fs.h>
  63 #include <ctype.h>
  64
  65 #include "lib/global.h"
  66
  67 #include "lib/widget.h"         /* message() */
  68 #include "lib/vfs/utilvfs.h"
  69 #include "lib/vfs/vfs.h"
  70
  71 #include "undelfs.h"
  72
  73 /*** global variables ****************************************************************************/
  74
  75 /*** file scope macro definitions ****************************************************************/
  76
  77 /* To generate the . and .. entries use -2 */
  78 #define READDIR_PTR_INIT 0
  79
  80 #define undelfs_stat undelfs_lstat
  81
  82 /*** file scope type declarations ****************************************************************/
  83
  84 struct deleted_info
  85 {
  86     ext2_ino_t ino;
  87     unsigned short mode;
  88     unsigned short uid;
  89     unsigned short gid;
  90     unsigned long size;
  91     time_t dtime;
  92     int num_blocks;
  93     int free_blocks;
  94 };
  95
  96 struct lsdel_struct
  97 {
  98     ext2_ino_t inode;
  99     int num_blocks;
 100     int free_blocks;
 101     int bad_blocks;
 102 };
 103
 104 typedef struct
 105 {
 106     int f_index;                /* file index into delarray */
 107     char *buf;
 108     int error_code;             /*  */
 109     off_t pos;                  /* file position */
 110     off_t current;              /* used to determine current position in itereate */
 111     gboolean finished;
 112     ext2_ino_t inode;
 113     int bytes_read;
 114     off_t size;
 115
 116     /* Used by undelfs_read: */
 117     char *dest_buffer;          /* destination buffer */
 118     size_t count;               /* bytes to read */
 119 } undelfs_file;
 120
 121 /*** file scope variables ************************************************************************/
 122
 123 /* We only allow one opened ext2fs */
 124 static char *ext2_fname;
 125 static ext2_filsys fs = NULL;
 126 static struct lsdel_struct lsd;
 127 static struct deleted_info *delarray;
 128 static int num_delarray, max_delarray;
 129 static char *block_buf;
 130 static const char *undelfserr = N_("undelfs: error");
 131 static int readdir_ptr;
 132 static int undelfs_usage;
 133 static struct vfs_class vfs_undelfs_ops;
 134
 135 /*** file scope functions ************************************************************************/
 136 /* --------------------------------------------------------------------------------------------- */
 137
 138 static void
 139 undelfs_shutdown (void)
 140 {
 141     if (fs)
 142         ext2fs_close (fs);
 143     fs = NULL;
 144     g_free (ext2_fname);
 145     ext2_fname = NULL;
 146     g_free (delarray);
 147     delarray = NULL;
 148     g_free (block_buf);
 149     block_buf = NULL;
 150 }
 151
 152 /* --------------------------------------------------------------------------------------------- */
 153
 154 static void
 155 undelfs_get_path (const vfs_path_t * vpath, char **fsname, char **file)
 156 {
 157     const char *p, *dirname;
 158     const vfs_path_element_t *path_element;
 159
 160     path_element = vfs_path_get_by_index (vpath, -1);
 161
 162     /* To look like filesystem, we have virtual directories
 163        undel://XXX, which have no subdirectories. XXX is replaced with
 164        hda5, sdb8 etc, which is assumed to live under /dev.
 165        -- pavel@ucw.cz */
 166
 167     dirname = path_element->path;
 168
 169     *fsname = NULL;
 170
 171     if (strncmp (dirname, "undel://", 8) != 0)
 172         return;
 173
 174     dirname += 8;
 175
 176     /* Since we don't allow subdirectories, it's easy to get a filename,
 177      * just scan backwards for a slash */
 178     if (*dirname == 0)
 179         return;
 180
 181     p = dirname + strlen (dirname);
 182 #if 0
 183     /* Strip trailing ./
 184      */
 185     if (p - dirname > 2 && *(p - 1) == '/' && *(p - 2) == '.')
 186         *(p = p - 2) = 0;
 187 #endif
 188
 189     while (p > dirname)
 190     {
 191         if (*p == '/')
 192         {
 193             char *tmp;
 194
 195             *file = g_strdup (p + 1);
 196             tmp = g_strndup (dirname, p - dirname);
 197             *fsname = g_strconcat ("/dev/", tmp, (char *) NULL);
 198             g_free (tmp);
 199             return;
 200         }
 201         p--;
 202     }
 203     *file = g_strdup ("");
 204     *fsname = g_strconcat ("/dev/", dirname, (char *) NULL);
 205 }
 206
 207 /* --------------------------------------------------------------------------------------------- */
 208
 209 static int
 210 undelfs_lsdel_proc (ext2_filsys _fs, blk_t * block_nr, int blockcnt, void *private)
 211 {
 212     struct lsdel_struct *_lsd = (struct lsdel_struct *) private;
 213     (void) blockcnt;
 214     _lsd->num_blocks++;
 215
 216     if (*block_nr < _fs->super->s_first_data_block || *block_nr >= _fs->super->s_blocks_count)
 217     {
 218         _lsd->bad_blocks++;
 219         return BLOCK_ABORT;
 220     }
 221
 222     if (!ext2fs_test_block_bitmap (_fs->block_map, *block_nr))
 223         _lsd->free_blocks++;
 224
 225     return 0;
 226 }
 227
 228 /* --------------------------------------------------------------------------------------------- */
 229 /**
 230  * Load information about deleted files.
 231  * Don't abort if there is not enough memory - load as much as we can.
 232  */
 233
 234 static int
 235 undelfs_loaddel (void)
 236 {
 237     int retval, count;
 238     ext2_ino_t ino;
 239     struct ext2_inode inode;
 240     ext2_inode_scan scan;
 241
 242     max_delarray = 100;
 243     num_delarray = 0;
 244     delarray = g_try_malloc (sizeof (struct deleted_info) * max_delarray);
 245     if (!delarray)
 246     {
 247         message (D_ERROR, undelfserr, _("not enough memory"));
 248         return 0;
 249     }
 250     block_buf = g_try_malloc (fs->blocksize * 3);
 251     if (!block_buf)
 252     {
 253         message (D_ERROR, undelfserr, _("while allocating block buffer"));
 254         goto free_delarray;
 255     }
 256     retval = ext2fs_open_inode_scan (fs, 0, &scan);
 257     if (retval != 0)
 258     {
 259         message (D_ERROR, undelfserr, _("open_inode_scan: %d"), retval);
 260         goto free_block_buf;
 261     }
 262     retval = ext2fs_get_next_inode (scan, &ino, &inode);
 263     if (retval != 0)
 264     {
 265         message (D_ERROR, undelfserr, _("while starting inode scan %d"), retval);
 266         goto error_out;
 267     }
 268     count = 0;
 269     while (ino)
 270     {
 271         if ((count++ % 1024) == 0)
 272             vfs_print_message (_("undelfs: loading deleted files information %d inodes"), count);
 273         if (inode.i_dtime == 0)
 274             goto next;
 275
 276         if (S_ISDIR (inode.i_mode))
 277             goto next;
 278
 279         lsd.inode = ino;
 280         lsd.num_blocks = 0;
 281         lsd.free_blocks = 0;
 282         lsd.bad_blocks = 0;
 283
 284         retval = ext2fs_block_iterate (fs, ino, 0, block_buf, undelfs_lsdel_proc, &lsd);
 285         if (retval)
 286         {
 287             message (D_ERROR, undelfserr, _("while calling ext2_block_iterate %d"), retval);
 288             goto next;
 289         }
 290         if (lsd.free_blocks && !lsd.bad_blocks)
 291         {
 292             if (num_delarray >= max_delarray)
 293             {
 294                 struct deleted_info *delarray_new = g_try_realloc (delarray,
 295                                                                    sizeof (struct deleted_info) *
 296                                                                    (max_delarray + 50));
 297                 if (!delarray_new)
 298                 {
 299                     message (D_ERROR, undelfserr, _("no more memory while reallocating array"));
 300                     goto error_out;
 301                 }
 302                 delarray = delarray_new;
 303                 max_delarray += 50;
 304             }
 305
 306             delarray[num_delarray].ino = ino;
 307             delarray[num_delarray].mode = inode.i_mode;
 308             delarray[num_delarray].uid = inode.i_uid;
 309             delarray[num_delarray].gid = inode.i_gid;
 310             delarray[num_delarray].size = inode.i_size;
 311             delarray[num_delarray].dtime = inode.i_dtime;
 312             delarray[num_delarray].num_blocks = lsd.num_blocks;
 313             delarray[num_delarray].free_blocks = lsd.free_blocks;
 314             num_delarray++;
 315         }
 316
 317       next:
 318         retval = ext2fs_get_next_inode (scan, &ino, &inode);
 319         if (retval)
 320         {
 321             message (D_ERROR, undelfserr, _("while doing inode scan %d"), retval);
 322             goto error_out;
 323         }
 324     }
 325     readdir_ptr = READDIR_PTR_INIT;
 326     ext2fs_close_inode_scan (scan);
 327     return 1;
 328
 329   error_out:
 330     ext2fs_close_inode_scan (scan);
 331   free_block_buf:
 332     g_free (block_buf);
 333     block_buf = NULL;
 334   free_delarray:
 335     g_free (delarray);
 336     delarray = NULL;
 337     return 0;
 338 }
 339
 340 /* --------------------------------------------------------------------------------------------- */
 341
 342 static void *
 343 undelfs_opendir (const vfs_path_t * vpath)
 344 {
 345     char *file, *f;
 346     const vfs_path_element_t *path_element;
 347
 348     path_element = vfs_path_get_by_index (vpath, -1);
 349     undelfs_get_path (vpath, &file, &f);
 350     if (!file)
 351         return 0;
 352
 353     /* We don't use the file name */
 354     g_free (f);
 355
 356     if (!ext2_fname || strcmp (ext2_fname, file))
 357     {
 358         undelfs_shutdown ();
 359         ext2_fname = file;
 360     }
 361     else
 362     {
 363         /* To avoid expensive re-scannings */
 364         readdir_ptr = READDIR_PTR_INIT;
 365         g_free (file);
 366         return fs;
 367     }
 368
 369     if (ext2fs_open (ext2_fname, 0, 0, 0, unix_io_manager, &fs))
 370     {
 371         message (D_ERROR, undelfserr, _("Cannot open file %s"), ext2_fname);
 372         return 0;
 373     }
 374     vfs_print_message (_("undelfs: reading inode bitmap..."));
 375     if (ext2fs_read_inode_bitmap (fs))
 376     {
 377         message (D_ERROR, undelfserr, _("Cannot load inode bitmap from:\n%s"), ext2_fname);
 378         goto quit_opendir;
 379     }
 380     vfs_print_message (_("undelfs: reading block bitmap..."));
 381     if (ext2fs_read_block_bitmap (fs))
 382     {
 383         message (D_ERROR, undelfserr, _("Cannot load block bitmap from:\n%s"), ext2_fname);
 384         goto quit_opendir;
 385     }
 386     /* Now load the deleted information */
 387     if (!undelfs_loaddel ())
 388         goto quit_opendir;
 389     vfs_print_message (_("%s: done."), path_element->class->name);
 390     return fs;
 391   quit_opendir:
 392     vfs_print_message (_("%s: failure"), path_element->class->name);
 393     ext2fs_close (fs);
 394     fs = NULL;
 395     return 0;
 396 }
 397
 398 /* --------------------------------------------------------------------------------------------- */
 399
 400 static void *
 401 undelfs_readdir (void *vfs_info)
 402 {
 403     static union vfs_dirent undelfs_readdir_data;
 404     static char *const dirent_dest = undelfs_readdir_data.dent.d_name;
 405
 406     if (vfs_info != fs)
 407     {
 408         message (D_ERROR, undelfserr, _("vfs_info is not fs!"));
 409         return NULL;
 410     }
 411     if (readdir_ptr == num_delarray)
 412         return NULL;
 413     if (readdir_ptr < 0)
 414         strcpy (dirent_dest, readdir_ptr == -2 ? "." : "..");
 415     else
 416         g_snprintf (dirent_dest, MC_MAXPATHLEN, "%ld:%d",
 417                     (long) delarray[readdir_ptr].ino, delarray[readdir_ptr].num_blocks);
 418     readdir_ptr++;
 419
 420     compute_namelen (&undelfs_readdir_data.dent);
 421
 422     return &undelfs_readdir_data;
 423 }
 424
 425 /* --------------------------------------------------------------------------------------------- */
 426
 427 static int
 428 undelfs_closedir (void *vfs_info)
 429 {
 430     (void) vfs_info;
 431     return 0;
 432 }
 433
 434 /* --------------------------------------------------------------------------------------------- */
 435 /* We do not support lseek */
 436
 437 static void *
 438 undelfs_open (const vfs_path_t * vpath, int flags, mode_t mode)
 439 {
 440     char *file, *f;
 441     ext2_ino_t inode, i;
 442     undelfs_file *p = NULL;
 443     (void) flags;
 444     (void) mode;
 445
 446     /* Only allow reads on this file system */
 447     undelfs_get_path (vpath, &file, &f);
 448     if (!file)
 449         return 0;
 450
 451     if (!ext2_fname || strcmp (ext2_fname, file))
 452     {
 453         message (D_ERROR, undelfserr, _("You have to chdir to extract files first"));
 454         g_free (file);
 455         g_free (f);
 456         return 0;
 457     }
 458     inode = atol (f);
 459
 460     /* Search the file into delarray */
 461     for (i = 0; i < (ext2_ino_t) num_delarray; i++)
 462     {
 463         if (inode != delarray[i].ino)
 464             continue;
 465
 466         /* Found: setup all the structures needed by read */
 467         p = (undelfs_file *) g_try_malloc (((gsize) sizeof (undelfs_file)));
 468         if (!p)
 469         {
 470             g_free (file);
 471             g_free (f);
 472             return 0;
 473         }
 474         p->buf = g_try_malloc (fs->blocksize);
 475         if (!p->buf)
 476         {
 477             g_free (p);
 478             g_free (file);
 479             g_free (f);
 480             return 0;
 481         }
 482         p->inode = inode;
 483         p->finished = FALSE;
 484         p->f_index = i;
 485         p->error_code = 0;
 486         p->pos = 0;
 487         p->size = delarray[i].size;
 488     }
 489     g_free (file);
 490     g_free (f);
 491     undelfs_usage++;
 492     return p;
 493 }
 494
 495 /* --------------------------------------------------------------------------------------------- */
 496
 497 static int
 498 undelfs_close (void *vfs_info)
 499 {
 500     undelfs_file *p = vfs_info;
 501     g_free (p->buf);
 502     g_free (p);
 503     undelfs_usage--;
 504     return 0;
 505 }
 506
 507 /* --------------------------------------------------------------------------------------------- */
 508
 509 static int
 510 undelfs_dump_read (ext2_filsys param_fs, blk_t * blocknr, int blockcnt, void *private)
 511 {
 512     int copy_count;
 513     undelfs_file *p = (undelfs_file *) private;
 514
 515     if (blockcnt < 0)
 516         return 0;
 517
 518     if (*blocknr)
 519     {
 520         p->error_code = io_channel_read_blk (param_fs->io, *blocknr, 1, p->buf);
 521         if (p->error_code)
 522             return BLOCK_ABORT;
 523     }
 524     else
 525         memset (p->buf, 0, param_fs->blocksize);
 526
 527     if (p->pos + (off_t) p->count < p->current)
 528     {
 529         p->finished = TRUE;
 530         return BLOCK_ABORT;
 531     }
 532     if (p->pos > p->current + param_fs->blocksize)
 533     {
 534         p->current += param_fs->blocksize;
 535         return 0;               /* we have not arrived yet */
 536     }
 537
 538     /* Now, we know we have to extract some data */
 539     if (p->pos >= p->current)
 540     {
 541
 542         /* First case: starting pointer inside this block */
 543         if (p->pos + (off_t) p->count <= p->current + param_fs->blocksize)
 544         {
 545             /* Fully contained */
 546             copy_count = p->count;
 547             p->finished = (p->count != 0);
 548         }
 549         else
 550         {
 551             /* Still some more data */
 552             copy_count = param_fs->blocksize - (p->pos - p->current);
 553         }
 554         memcpy (p->dest_buffer, p->buf + (p->pos - p->current), copy_count);
 555     }
 556     else
 557     {
 558         /* Second case: we already have passed p->pos */
 559         if (p->pos + (off_t) p->count < p->current + param_fs->blocksize)
 560         {
 561             copy_count = (p->pos + p->count) - p->current;
 562             p->finished = (p->count != 0);
 563         }
 564         else
 565         {
 566             copy_count = param_fs->blocksize;
 567         }
 568         memcpy (p->dest_buffer, p->buf, copy_count);
 569     }
 570     p->dest_buffer += copy_count;
 571     p->current += param_fs->blocksize;
 572     if (p->finished)
 573     {
 574         return BLOCK_ABORT;
 575     }
 576     return 0;
 577 }
 578
 579 /* --------------------------------------------------------------------------------------------- */
 580
 581 static ssize_t
 582 undelfs_read (void *vfs_info, char *buffer, size_t count)
 583 {
 584     undelfs_file *p = vfs_info;
 585     int retval;
 586
 587     p->dest_buffer = buffer;
 588     p->current = 0;
 589     p->finished = FALSE;
 590     p->count = count;
 591
 592     if (p->pos + (off_t) p->count > p->size)
 593     {
 594         p->count = p->size - p->pos;
 595     }
 596     retval = ext2fs_block_iterate (fs, p->inode, 0, NULL, undelfs_dump_read, p);
 597     if (retval)
 598     {
 599         message (D_ERROR, undelfserr, _("while iterating over blocks"));
 600         return -1;
 601     }
 602     if (p->error_code && !p->finished)
 603         return 0;
 604     p->pos = p->pos + (p->dest_buffer - buffer);
 605     return p->dest_buffer - buffer;
 606 }
 607
 608 /* --------------------------------------------------------------------------------------------- */
 609
 610 static long
 611 undelfs_getindex (char *path)
 612 {
 613     ext2_ino_t inode = atol (path);
 614     int i;
 615
 616     for (i = 0; i < num_delarray; i++)
 617     {
 618         if (delarray[i].ino == inode)
 619             return i;
 620     }
 621     return -1;
 622 }
 623
 624 /* --------------------------------------------------------------------------------------------- */
 625
 626 static int
 627 undelfs_stat_int (int inode_index, struct stat *buf)
 628 {
 629     buf->st_dev = 0;
 630     buf->st_ino = delarray[inode_index].ino;
 631     buf->st_mode = delarray[inode_index].mode;
 632     buf->st_nlink = 1;
 633     buf->st_uid = delarray[inode_index].uid;
 634     buf->st_gid = delarray[inode_index].gid;
 635     buf->st_size = delarray[inode_index].size;
 636     buf->st_atime = delarray[inode_index].dtime;
 637     buf->st_ctime = delarray[inode_index].dtime;
 638     buf->st_mtime = delarray[inode_index].dtime;
 639     return 0;
 640 }
 641
 642 /* --------------------------------------------------------------------------------------------- */
 643
 644 static int
 645 undelfs_lstat (const vfs_path_t * vpath, struct stat *buf)
 646 {
 647     int inode_index;
 648     char *file, *f;
 649
 650     undelfs_get_path (vpath, &file, &f);
 651     if (!file)
 652         return 0;
 653
 654     /* When called from save_cwd_stats we get an incorrect file and f here:
 655        e.g. incorrect                         correct
 656        path = "undel:/dev/sda1"          path="undel:/dev/sda1/401:1"
 657        file = "/dev"                     file="/dev/sda1"
 658        f    = "sda1"                     f   ="401:1"
 659        If the first char in f is no digit -> return error */
 660     if (!isdigit (*f))
 661     {
 662         g_free (file);
 663         g_free (f);
 664         return -1;
 665     }
 666
 667     if (!ext2_fname || strcmp (ext2_fname, file))
 668     {
 669         message (D_ERROR, undelfserr, _("You have to chdir to extract files first"));
 670         g_free (file);
 671         g_free (f);
 672         return 0;
 673     }
 674     inode_index = undelfs_getindex (f);
 675     g_free (file);
 676     g_free (f);
 677
 678     if (inode_index == -1)
 679         return -1;
 680
 681     return undelfs_stat_int (inode_index, buf);
 682 }
 683
 684 /* --------------------------------------------------------------------------------------------- */
 685
 686 static int
 687 undelfs_fstat (void *vfs_info, struct stat *buf)
 688 {
 689     undelfs_file *p = vfs_info;
 690
 691     return undelfs_stat_int (p->f_index, buf);
 692 }
 693
 694 /* --------------------------------------------------------------------------------------------- */
 695
 696 static int
 697 undelfs_chdir (const vfs_path_t * vpath)
 698 {
 699     char *file, *f;
 700     int fd;
 701
 702     undelfs_get_path (vpath, &file, &f);
 703     if (!file)
 704         return -1;
 705
 706     /* We may use access because ext2 file systems are local */
 707     /* this could be fixed by making an ext2fs io manager to use */
 708     /* our vfs, but that is left as an excercise for the reader */
 709     fd = open (file, O_RDONLY);
 710     if (fd == -1)
 711     {
 712         message (D_ERROR, undelfserr, _("Cannot open file \"%s\""), file);
 713         g_free (f);
 714         g_free (file);
 715         return -1;
 716     }
 717     close (fd);
 718     g_free (f);
 719     g_free (file);
 720     return 0;
 721 }
 722
 723 /* --------------------------------------------------------------------------------------------- */
 724
 725 /* this has to stay here for now: vfs layer does not know how to emulate it */
 726 static off_t
 727 undelfs_lseek (void *vfs_info, off_t offset, int whence)
 728 {
 729     (void) vfs_info;
 730     (void) offset;
 731     (void) whence;
 732
 733     return -1;
 734 }
 735
 736 /* --------------------------------------------------------------------------------------------- */
 737
 738 static vfsid
 739 undelfs_getid (const vfs_path_t * vpath)
 740 {
 741     char *fname, *fsname;
 742
 743     undelfs_get_path (vpath, &fsname, &fname);
 744
 745     if (!fsname)
 746         return NULL;
 747     g_free (fname);
 748     g_free (fsname);
 749     return (vfsid) fs;
 750 }
 751
 752 /* --------------------------------------------------------------------------------------------- */
 753
 754 static int
 755 undelfs_nothingisopen (vfsid id)
 756 {
 757     (void) id;
 758
 759     return !undelfs_usage;
 760 }
 761
 762 /* --------------------------------------------------------------------------------------------- */
 763
 764 static void
 765 undelfs_free (vfsid id)
 766 {
 767     (void) id;
 768
 769     undelfs_shutdown ();
 770 }
 771
 772 /* --------------------------------------------------------------------------------------------- */
 773
 774 #ifdef ENABLE_NLS
 775 static int
 776 undelfs_init (struct vfs_class *me)
 777 {
 778     (void) me;
 779
 780     undelfserr = _(undelfserr);
 781     return 1;
 782 }
 783 #else
 784 #define undelfs_init NULL
 785 #endif
 786
 787 /* --------------------------------------------------------------------------------------------- */
 788 /*** public functions ****************************************************************************/
 789 /* --------------------------------------------------------------------------------------------- */
 790 /**
 791  * This function overrides com_err() from libcom_err library.
 792  * It is used in libext2fs to report errors.
 793  */
 794
 795 void
 796 com_err (const char *whoami, long err_code, const char *fmt, ...)
 797 {
 798     va_list ap;
 799     char *str;
 800
 801     va_start (ap, fmt);
 802     str = g_strdup_vprintf (fmt, ap);
 803     va_end (ap);
 804
 805     message (D_ERROR, _("Ext2lib error"), "%s (%s: %ld)", str, whoami, err_code);
 806     g_free (str);
 807 }
 808
 809 /* --------------------------------------------------------------------------------------------- */
 810
 811 void
 812 init_undelfs (void)
 813 {
 814     vfs_undelfs_ops.name = "undelfs";
 815     vfs_undelfs_ops.prefix = "undel";
 816     vfs_undelfs_ops.init = undelfs_init;
 817     vfs_undelfs_ops.open = undelfs_open;
 818     vfs_undelfs_ops.close = undelfs_close;
 819     vfs_undelfs_ops.read = undelfs_read;
 820     vfs_undelfs_ops.opendir = undelfs_opendir;
 821     vfs_undelfs_ops.readdir = undelfs_readdir;
 822     vfs_undelfs_ops.closedir = undelfs_closedir;
 823     vfs_undelfs_ops.stat = undelfs_stat;
 824     vfs_undelfs_ops.lstat = undelfs_lstat;
 825     vfs_undelfs_ops.fstat = undelfs_fstat;
 826     vfs_undelfs_ops.chdir = undelfs_chdir;
 827     vfs_undelfs_ops.lseek = undelfs_lseek;
 828     vfs_undelfs_ops.getid = undelfs_getid;
 829     vfs_undelfs_ops.nothingisopen = undelfs_nothingisopen;
 830     vfs_undelfs_ops.free = undelfs_free;
 831     vfs_register_class (&vfs_undelfs_ops);
 832 }
 833
 834 /* --------------------------------------------------------------------------------------------- */