release/src/router/ntfs-3g/ntfsprogs/ntfscluster.c

   1 /**
   2  * ntfscluster - Part of the Linux-NTFS project.
   3  *
   4  * Copyright (c) 2002-2003 Richard Russon
   5  * Copyright (c) 2005 Anton Altaparmakov
   6  * Copyright (c) 2005-2006 Szabolcs Szakacsits
   7  *
   8  * This utility will locate the owner of any given sector or cluster.
   9  *
  10  * This program is free software; you can redistribute it and/or modify
  11  * it under the terms of the GNU General Public License as published by
  12  * the Free Software Foundation; either version 2 of the License, or
  13  * (at your option) any later version.
  14  *
  15  * This program is distributed in the hope that it will be useful,
  16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18  * GNU General Public License for more details.
  19  *
  20  * You should have received a copy of the GNU General Public License
  21  * along with this program (in the main directory of the Linux-NTFS
  22  * distribution in the file COPYING); if not, write to the Free Software
  23  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  24  */
  25
  26 #include "config.h"
  27
  28 #ifdef HAVE_STDIO_H
  29 #include <stdio.h>
  30 #endif
  31 #ifdef HAVE_GETOPT_H
  32 #include <getopt.h>
  33 #endif
  34 #ifdef HAVE_STDLIB_H
  35 #include <stdlib.h>
  36 #endif
  37 #ifdef HAVE_STRING_H
  38 #include <string.h>
  39 #endif
  40 #ifdef HAVE_LIMITS_H
  41 #include <limits.h>
  42 #endif
  43
  44 #include "ntfscluster.h"
  45 #include "types.h"
  46 #include "attrib.h"
  47 #include "utils.h"
  48 #include "volume.h"
  49 #include "debug.h"
  50 #include "dir.h"
  51 #include "cluster.h"
  52 /* #include "version.h" */
  53 #include "logging.h"
  54
  55 static const char *EXEC_NAME = "ntfscluster";
  56 static struct options opts;
  57
  58 /**
  59  * version - Print version information about the program
  60  *
  61  * Print a copyright statement and a brief description of the program.
  62  *
  63  * Return:  none
  64  */
  65 static void version(void)
  66 {
  67         ntfs_log_info("\n%s v%s (libntfs-3g) - Find the owner of any given sector or "
  68                         "cluster.\n\n", EXEC_NAME, VERSION);
  69         ntfs_log_info("Copyright (c) 2002-2003 Richard Russon\n");
  70         ntfs_log_info("Copyright (c) 2005 Anton Altaparmakov\n");
  71         ntfs_log_info("Copyright (c) 2005-2006 Szabolcs Szakacsits\n");
  72         ntfs_log_info("\n%s\n%s%s\n", ntfs_gpl, ntfs_bugs, ntfs_home);
  73 }
  74
  75 /**
  76  * usage - Print a list of the parameters to the program
  77  *
  78  * Print a list of the parameters and options for the program.
  79  *
  80  * Return:  none
  81  */
  82 static void usage(void)
  83 {
  84         ntfs_log_info("\nUsage: %s [options] device\n"
  85                 "    -i, --info           Print information about the volume (default)\n"
  86                 "\n"
  87                 "    -c, --cluster RANGE  Look for objects in this range of clusters\n"
  88                 "    -s, --sector RANGE   Look for objects in this range of sectors\n"
  89                 "    -I, --inode NUM      Show information about this inode\n"
  90                 "    -F, --filename NAME  Show information about this file\n"
  91         /*      "    -l, --last           Find the last file on the volume\n" */
  92                 "\n"
  93                 "    -f, --force          Use less caution\n"
  94                 "    -q, --quiet          Less output\n"
  95                 "    -v, --verbose        More output\n"
  96                 "    -V, --version        Version information\n"
  97                 "    -h, --help           Print this help\n\n",
  98                 EXEC_NAME);
  99         ntfs_log_info("%s%s\n", ntfs_bugs, ntfs_home);
 100 }
 101
 102 /**
 103  * parse_options - Read and validate the programs command line
 104  *
 105  * Read the command line, verify the syntax and parse the options.
 106  * This function is very long, but quite simple.
 107  *
 108  * Return:  1 Success
 109  *          0 Error, one or more problems
 110  */
 111 static int parse_options(int argc, char **argv)
 112 {
 113         static const char *sopt = "-c:F:fh?I:ilqs:vV";
 114         static const struct option lopt[] = {
 115                 { "cluster",    required_argument,      NULL, 'c' },
 116                 { "filename",   required_argument,      NULL, 'F' },
 117                 { "force",      no_argument,            NULL, 'f' },
 118                 { "help",       no_argument,            NULL, 'h' },
 119                 { "info",       no_argument,            NULL, 'i' },
 120                 { "inode",      required_argument,      NULL, 'I' },
 121                 { "last",       no_argument,            NULL, 'l' },
 122                 { "quiet",      no_argument,            NULL, 'q' },
 123                 { "sector",     required_argument,      NULL, 's' },
 124                 { "verbose",    no_argument,            NULL, 'v' },
 125                 { "version",    no_argument,            NULL, 'V' },
 126                 { NULL,         0,                      NULL, 0   }
 127         };
 128
 129         int c = -1;
 130         int err  = 0;
 131         int ver  = 0;
 132         int help = 0;
 133         int levels = 0;
 134         char *end = NULL;
 135
 136         opterr = 0; /* We'll handle the errors, thank you. */
 137
 138         opts.action      = act_none;
 139         opts.range_begin = -1;
 140         opts.range_end   = -1;
 141
 142         while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) {
 143                 switch (c) {
 144                 case 1: /* A non-option argument */
 145                         if (!opts.device) {
 146                                 opts.device = argv[optind-1];
 147                         } else {
 148                                 opts.device = NULL;
 149                                 err++;
 150                         }
 151                         break;
 152
 153                 case 'c':
 154                         if ((opts.action == act_none) &&
 155                             (utils_parse_range(optarg, &opts.range_begin, &opts.range_end, FALSE)))
 156                                 opts.action = act_cluster;
 157                         else
 158                                 opts.action = act_error;
 159                         break;
 160                 case 'F':
 161                         if (opts.action == act_none) {
 162                                 opts.action = act_file;
 163                                 opts.filename = optarg;
 164                         } else {
 165                                 opts.action = act_error;
 166                         }
 167                         break;
 168                 case 'f':
 169                         opts.force++;
 170                         break;
 171                 case 'h':
 172                 case '?':
 173                         if (strncmp (argv[optind-1], "--log-", 6) == 0) {
 174                                 if (!ntfs_log_parse_option (argv[optind-1]))
 175                                         err++;
 176                                 break;
 177                         }
 178                         help++;
 179                         break;
 180                 case 'I':
 181                         if (opts.action == act_none) {
 182                                 opts.action = act_inode;
 183                                 opts.inode = strtol(optarg, &end, 0);
 184                                 if (end && *end)
 185                                         err++;
 186                         } else {
 187                                 opts.action = act_error;
 188                         }
 189                         break;
 190                 case 'i':
 191                         if (opts.action == act_none)
 192                                 opts.action = act_info;
 193                         else
 194                                 opts.action = act_error;
 195                         break;
 196                 case 'l':
 197                         if (opts.action == act_none)
 198                                 opts.action = act_last;
 199                         else
 200                                 opts.action = act_error;
 201                         break;
 202                 case 'q':
 203                         opts.quiet++;
 204                         ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
 205                         break;
 206                 case 's':
 207                         if ((opts.action == act_none) &&
 208                             (utils_parse_range(optarg, &opts.range_begin, &opts.range_end, FALSE)))
 209                                 opts.action = act_sector;
 210                         else
 211                                 opts.action = act_error;
 212                         break;
 213                 case 'v':
 214                         opts.verbose++;
 215                         ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
 216                         break;
 217                 case 'V':
 218                         ver++;
 219                         break;
 220                 default:
 221                         if ((optopt == 'c') || (optopt == 's'))
 222                                 ntfs_log_error("Option '%s' requires an argument.\n", argv[optind-1]);
 223                         else
 224                                 ntfs_log_error("Unknown option '%s'.\n", argv[optind-1]);
 225                         err++;
 226                         break;
 227                 }
 228         }
 229
 230         /* Make sure we're in sync with the log levels */
 231         levels = ntfs_log_get_levels();
 232         if (levels & NTFS_LOG_LEVEL_VERBOSE)
 233                 opts.verbose++;
 234         if (!(levels & NTFS_LOG_LEVEL_QUIET))
 235                 opts.quiet++;
 236
 237         if (help || ver) {
 238                 opts.quiet = 0;
 239         } else {
 240                 if (opts.action == act_none)
 241                         opts.action = act_info;
 242                 if (opts.action == act_info)
 243                         opts.quiet = 0;
 244
 245                 if (opts.device == NULL) {
 246                         if (argc > 1)
 247                                 ntfs_log_error("You must specify exactly one device.\n");
 248                         err++;
 249                 }
 250
 251                 if (opts.quiet && opts.verbose) {
 252                         ntfs_log_error("You may not use --quiet and --verbose at the same time.\n");
 253                         err++;
 254                 }
 255
 256                 if (opts.action == act_error) {
 257                         ntfs_log_error("You may only specify one action: --info, --cluster, --sector or --last.\n");
 258                         err++;
 259                 } else if (opts.range_begin > opts.range_end) {
 260                         ntfs_log_error("The range must be in ascending order.\n");
 261                         err++;
 262                 }
 263         }
 264
 265         if (ver)
 266                 version();
 267         if (help || err)
 268                 usage();
 269
 270         return (!err && !help && !ver);
 271 }
 272
 273
 274 /**
 275  * info
 276  */
 277 static int info(ntfs_volume *vol)
 278 {
 279         u64 a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u;
 280         int cb, sb, cps;
 281         u64 uc = 0, mc = 0, fc = 0;
 282
 283         struct mft_search_ctx *m_ctx;
 284         ntfs_attr_search_ctx *a_ctx;
 285         runlist_element *rl;
 286         ATTR_RECORD *rec;
 287         int z;
 288         int inuse = 0;
 289
 290         m_ctx = mft_get_search_ctx(vol);
 291         m_ctx->flags_search = FEMR_IN_USE | FEMR_METADATA | FEMR_BASE_RECORD | FEMR_NOT_BASE_RECORD;
 292         while (mft_next_record(m_ctx) == 0) {
 293
 294                 if (!(m_ctx->flags_match & FEMR_IN_USE))
 295                         continue;
 296
 297                 inuse++;
 298
 299                 a_ctx = ntfs_attr_get_search_ctx(m_ctx->inode, NULL);
 300
 301                 while ((rec = find_attribute(AT_UNUSED, a_ctx))) {
 302
 303                         if (!rec->non_resident)
 304                                 continue;
 305
 306                         rl = ntfs_mapping_pairs_decompress(vol, rec, NULL);
 307
 308                         for (z = 0; rl[z].length > 0; z++)
 309                         {
 310                                 if (rl[z].lcn >= 0) {
 311                                         if (m_ctx->flags_match & FEMR_METADATA)
 312                                                 mc += rl[z].length;
 313                                         else
 314                                                 uc += rl[z].length;
 315                                 }
 316
 317                         }
 318
 319                         free(rl);
 320                 }
 321
 322                 ntfs_attr_put_search_ctx(a_ctx);
 323         }
 324         mft_put_search_ctx(m_ctx);
 325
 326         cb  = vol->cluster_size_bits;
 327         sb  = vol->sector_size_bits;
 328         cps = cb - sb;
 329
 330         fc  = vol->nr_clusters-mc-uc;
 331         fc  <<= cb;
 332         mc  <<= cb;
 333         uc  <<= cb;
 334
 335         a = vol->sector_size;
 336         b = vol->cluster_size;
 337         c = 1 << cps;
 338         d = vol->nr_clusters << cb;
 339         e = vol->nr_clusters;
 340         f = vol->nr_clusters >> cps;
 341         g = vol->mft_na->initialized_size >> vol->mft_record_size_bits;
 342         h = inuse;
 343         i = h * 100 / g;
 344         j = fc;
 345         k = fc >> sb;
 346         l = fc >> cb;
 347         m = fc * 100 / b / e;
 348         n = uc;
 349         o = uc >> sb;
 350         p = uc >> cb;
 351         q = uc * 100 / b / e;
 352         r = mc;
 353         s = mc >> sb;
 354         t = mc >> cb;
 355         u = mc * 100 / b / e;
 356
 357         ntfs_log_info("bytes per sector        : %llu\n", (unsigned long long)a);
 358         ntfs_log_info("bytes per cluster       : %llu\n", (unsigned long long)b);
 359         ntfs_log_info("sectors per cluster     : %llu\n", (unsigned long long)c);
 360         ntfs_log_info("bytes per volume        : %llu\n", (unsigned long long)d);
 361         ntfs_log_info("sectors per volume      : %llu\n", (unsigned long long)e);
 362         ntfs_log_info("clusters per volume     : %llu\n", (unsigned long long)f);
 363         ntfs_log_info("initialized mft records : %llu\n", (unsigned long long)g);
 364         ntfs_log_info("mft records in use      : %llu\n", (unsigned long long)h);
 365         ntfs_log_info("mft records percentage  : %llu\n", (unsigned long long)i);
 366         ntfs_log_info("bytes of free space     : %llu\n", (unsigned long long)j);
 367         ntfs_log_info("sectors of free space   : %llu\n", (unsigned long long)k);
 368         ntfs_log_info("clusters of free space  : %llu\n", (unsigned long long)l);
 369         ntfs_log_info("percentage free space   : %llu\n", (unsigned long long)m);
 370         ntfs_log_info("bytes of user data      : %llu\n", (unsigned long long)n);
 371         ntfs_log_info("sectors of user data    : %llu\n", (unsigned long long)o);
 372         ntfs_log_info("clusters of user data   : %llu\n", (unsigned long long)p);
 373         ntfs_log_info("percentage user data    : %llu\n", (unsigned long long)q);
 374         ntfs_log_info("bytes of metadata       : %llu\n", (unsigned long long)r);
 375         ntfs_log_info("sectors of metadata     : %llu\n", (unsigned long long)s);
 376         ntfs_log_info("clusters of metadata    : %llu\n", (unsigned long long)t);
 377         ntfs_log_info("percentage metadata     : %llu\n", (unsigned long long)u);
 378
 379         return 0;
 380 }
 381
 382 /**
 383  * dump_file
 384  */
 385 static int dump_file(ntfs_volume *vol, ntfs_inode *ino)
 386 {
 387         char buffer[1024];
 388         ntfs_attr_search_ctx *ctx;
 389         ATTR_RECORD *rec;
 390         int i;
 391         runlist *runs;
 392
 393         utils_inode_get_name(ino, buffer, sizeof(buffer));
 394
 395         ntfs_log_info("Dump: %s\n", buffer);
 396
 397         ctx = ntfs_attr_get_search_ctx(ino, NULL);
 398
 399         while ((rec = find_attribute(AT_UNUSED, ctx))) {
 400                 ntfs_log_info("    0x%02x - ", rec->type);
 401                 if (rec->non_resident) {
 402                         ntfs_log_info("non-resident\n");
 403                         runs = ntfs_mapping_pairs_decompress(vol, rec, NULL);
 404                         if (runs) {
 405                                 ntfs_log_info("             VCN     LCN     Length\n");
 406                                 for (i = 0; runs[i].length > 0; i++) {
 407                                         ntfs_log_info("        %8lld %8lld %8lld\n",
 408                                                         (long long)runs[i].vcn,
 409                                                         (long long)runs[i].lcn,
 410                                                         (long long)
 411                                                         runs[i].length);
 412                                 }
 413                                 free(runs);
 414                         }
 415                 } else {
 416                         ntfs_log_info("resident\n");
 417                 }
 418         }
 419
 420         ntfs_attr_put_search_ctx(ctx);
 421         return 0;
 422 }
 423
 424 /**
 425  * print_match
 426  */
 427 static int print_match(ntfs_inode *ino, ATTR_RECORD *attr,
 428         runlist_element *run, void *data __attribute__((unused)))
 429 {
 430         char *buffer;
 431
 432         if (!ino || !attr || !run)
 433                 return 1;
 434
 435         buffer = malloc(MAX_PATH);
 436         if (!buffer) {
 437                 ntfs_log_error("!buffer\n");
 438                 return 1;
 439         }
 440
 441         utils_inode_get_name(ino, buffer, MAX_PATH);
 442         ntfs_log_info("Inode %llu %s", (unsigned long long)ino->mft_no, buffer);
 443
 444         utils_attr_get_name(ino->vol, attr, buffer, MAX_PATH);
 445         ntfs_log_info("/%s\n", buffer);
 446
 447         free(buffer);
 448         return 0;
 449 }
 450
 451 /**
 452  * find_last
 453  */
 454 static int find_last(ntfs_inode *ino, ATTR_RECORD *attr, runlist_element *run,
 455         void *data)
 456 {
 457         struct match *m;
 458
 459         if (!ino || !attr || !run || !data)
 460                 return 1;
 461
 462         m = data;
 463
 464         if ((run->lcn + run->length) > m->lcn) {
 465                 m->inum = ino->mft_no;
 466                 m->lcn  = run->lcn + run->length;
 467         }
 468
 469         return 0;
 470 }
 471
 472 /**
 473  * main - Begin here
 474  *
 475  * Start from here.
 476  *
 477  * Return:  0  Success, the program worked
 478  *          1  Error, something went wrong
 479  */
 480 int main(int argc, char *argv[])
 481 {
 482         ntfs_volume *vol;
 483         ntfs_inode *ino = NULL;
 484         struct match m;
 485         int result = 1;
 486
 487         ntfs_log_set_handler(ntfs_log_handler_outerr);
 488
 489         if (!parse_options(argc, argv))
 490                 return 1;
 491
 492         utils_set_locale();
 493
 494         vol = utils_mount_volume(opts.device, NTFS_MNT_RDONLY |
 495                         (opts.force ? NTFS_MNT_RECOVER : 0));
 496         if (!vol)
 497                 return 1;
 498
 499         switch (opts.action) {
 500                 case act_sector:
 501                         if (opts.range_begin == opts.range_end)
 502                                 ntfs_log_quiet("Searching for sector %llu\n",
 503                                                 (unsigned long long)opts.range_begin);
 504                         else
 505                                 ntfs_log_quiet("Searching for sector range %llu-%llu\n", (unsigned long long)opts.range_begin, (unsigned long long)opts.range_end);
 506                         /* Convert to clusters */
 507                         opts.range_begin >>= (vol->cluster_size_bits - vol->sector_size_bits);
 508                         opts.range_end   >>= (vol->cluster_size_bits - vol->sector_size_bits);
 509                         result = cluster_find(vol, opts.range_begin, opts.range_end, (cluster_cb*)&print_match, NULL);
 510                         break;
 511                 case act_cluster:
 512                         if (opts.range_begin == opts.range_end)
 513                                 ntfs_log_quiet("Searching for cluster %llu\n",
 514                                                 (unsigned long long)opts.range_begin);
 515                         else
 516                                 ntfs_log_quiet("Searching for cluster range %llu-%llu\n", (unsigned long long)opts.range_begin, (unsigned long long)opts.range_end);
 517                         result = cluster_find(vol, opts.range_begin, opts.range_end, (cluster_cb*)&print_match, NULL);
 518                         break;
 519                 case act_file:
 520                         ino = ntfs_pathname_to_inode(vol, NULL, opts.filename);
 521                         if (ino)
 522                                 result = dump_file(vol, ino);
 523                         break;
 524                 case act_inode:
 525                         ino = ntfs_inode_open(vol, opts.inode);
 526                         if (ino) {
 527                                 result = dump_file(vol, ino);
 528                                 ntfs_inode_close(ino);
 529                         } else {
 530                                 ntfs_log_error("Cannot open inode %llu\n",
 531                                                 (unsigned long long)opts.inode);
 532                         }
 533                         break;
 534                 case act_last:
 535                         memset(&m, 0, sizeof(m));
 536                         m.lcn = -1;
 537                         result = cluster_find(vol, 0, LONG_MAX, (cluster_cb*)&find_last, &m);
 538                         if (m.lcn >= 0) {
 539                                 ino = ntfs_inode_open(vol, m.inum);
 540                                 if (ino) {
 541                                         result = dump_file(vol, ino);
 542                                         ntfs_inode_close(ino);
 543                                 } else {
 544                                         ntfs_log_error("Cannot open inode %llu\n",
 545                                                         (unsigned long long)
 546                                                         opts.inode);
 547                                 }
 548                                 result = 0;
 549                         } else {
 550                                 result = 1;
 551                         }
 552                         break;
 553                 case act_info:
 554                 default:
 555                         result = info(vol);
 556                         break;
 557         }
 558
 559         ntfs_umount(vol, FALSE);
 560         return result;
 561 }
 562
 563