|
From: Leroy, L. <lod...@ba...> - 2003-07-17 14:59:21
|
/**
* ntfsls - Part of the Linux-NTFS project.
*
* Copyright (c) 2003 Lode Leroy
*
* This utility will list a directory's files.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program (in the main directory of the Linux-NTFS
* distribution in the file COPYING); if not, write to the Free =
Software
* Foundation,Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 =
USA
*/
#include "config.h"
#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#include <getopt.h>
#include <string.h>
#include "types.h"
#include "mft.h"
#include "attrib.h"
#include "layout.h"
#include "inode.h"
#include "utils.h"
#include "dir.h"
static const char *EXEC_NAME =3D "ntfsls";
static struct options {
char *device; /* Device/File to work with */
int quiet; /* Less output */
int verbose; /* Extra output */
int force; /* Override common sense */
int all;
int sys;
int dos;
int lng;
int inode;
int classify;
int readonly;
int hidden;
int archive;
int system;
char *path;
} opts;
GEN_PRINTF (Eprintf, stderr, NULL, FALSE)
GEN_PRINTF (Vprintf, stdout, &opts.verbose, TRUE)
GEN_PRINTF (Qprintf, stdout, &opts.quiet, FALSE)
/**
* version - Print version information about the program
*
* Print a copyright statement and a brief description of the program.
*
* Return: none
*/
void version (void)
{
printf ("\n%s v%s - Display information about an NTFS Volume.\n\n",
EXEC_NAME, VERSION);
printf ("Copyright (c)\n");
printf (" 2003 Lode Leroy\n");
printf ("\n%s\n%s%s\n", ntfs_gpl, ntfs_bugs, ntfs_home);
}
/**
* usage - Print a list of the parameters to the program
*
* Print a list of the parameters and options for the program.
*
* Return: none
*/
void usage (void)
{
printf ("\nUsage: %s [options] -d /dev/hda1 -p /WINDOWS\n"
"\n"
" -d --device NTFS volume\n"
" -p --path Relative path to the directory\n"
" -l --long Display long info\n"
" -F --classify Display classification\n"
" -f --force Use less caution\n"
" -q --quiet Less output\n"
" -v --verbose More output\n"
" -V --version Display version information\n"
" -h --help Display this help\n"
" -a Display all files\n"
" -x Use short (DOS 8.3) names\n"
" -s Display system files\n"
"\n",
EXEC_NAME);
printf ("%s%s\n", ntfs_bugs, ntfs_home);
}
/**
* parse_options - Read and validate the programs command line
*
* Read the command line, verify the syntax and parse the options.
* This function is very long, but quite simple.
*
* Return: 1 Success
* 0 Error, one or more problems
*/
int parse_options (int argc, char *argv[])
{
static const char *sopt =3D "-fh?qvVd:p:asxliFRHSA";
static const struct option lopt[] =3D {
{ "device", required_argument, NULL, 'd' },
{ "path", required_argument, NULL, 'p' },
{ "all", no_argument, NULL, 'a' },
{ "sys", no_argument, NULL, 's' },
{ "long", no_argument, NULL, 'l' },
{ "inode", no_argument, NULL, 'i' },
{ "classify", no_argument, NULL, 'F' },
{ "system", no_argument, NULL, 'S' },
{ "dos", no_argument, NULL, 'x' },
{ "force", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "quiet", no_argument, NULL, 'q' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 },
};
char c =3D -1;
int err =3D 0;
int ver =3D 0;
int help =3D 0;
opterr =3D 0; /* We'll handle the errors, thank you. */
memset(&opts, 0, sizeof(opts));
opts.device =3D "/dev/hda1";
opts.path =3D "/";
while ((c =3D getopt_long (argc, argv, sopt, lopt, NULL)) !=3D -1) {
switch (c) {
case 'd': /* A non-option argument */
opts.device =3D argv[optind-1];
break;
case 'p':
opts.path =3D optarg;
break;
case 'f':
opts.force++;
break;
case 'h':
case '?':
help++;
break;
case 'q':
opts.quiet++;
break;
case 'v':
opts.verbose++;
break;
case 'V':
ver++;
break;
case 'x':
opts.dos++;
break;
case 'l':
opts.lng++;
break;
case 'i':
opts.inode++;
break;
case 'F':
opts.classify++;
break;
case 'a':
opts.all++;
break;
case 's':
opts.sys++;
break;
case 'R':
opts.readonly++;
break;
case 'H':
opts.hidden++;
break;
case 'S':
opts.system++;
break;
case 'A':
opts.archive++;
break;
default:
Eprintf ("Unknown option '%s'.\n", argv[optind-1]);
err++;
break;
}
}
if (help || ver) {
opts.quiet =3D 0;
} else {
if (opts.device =3D=3D NULL) {
if (argc > 1)
Eprintf ("You must specify exactly one device.\n");
err++;
}
if (opts.quiet && opts.verbose) {
Eprintf ("You may not use --quiet and --verbose at the same =
time.\n");
err++;
}
}
if (ver)
version();
if (help || err)
usage();
return (!err && !help && !ver);
}
/**
* ucstos - convert unicode-character string to ASCII
* @dest: points to buffer to receive the converted string
* @src: points to string to convert
* @maxlen: size of @dest buffer in bytes
*
* Return the number of characters written to @dest, not including the
* terminating null byte. If a unicode character was encountered which =
could
* not be converted -1 is returned.
*/
int ucstos(char *dest, const uchar_t *src, int maxlen)
{
uchar_t u;
int i;
/* Need one byte for null terminator. */
maxlen--;
for (i =3D 0; i < maxlen; i++) {
u =3D le16_to_cpu(src[i]);
if (!u)
break;
if (u & 0xff00)
return -1;
dest[i] =3D u & 0xff;
}
dest[i] =3D 0;
return i;
}
/**
* stoucs - convert ASCII string to unicode-character string
* @dest: points to buffer to receive the converted string
* @src: points to string to convert
* @maxlen: size of @dest buffer in bytes
*
* Return the number of characters written to @dest, not including the
* terminating null unicode character.
*/
int stoucs(uchar_t *dest, const char *src, int maxlen)
{
char c;
int i;
/* Need two bytes for null terminator. */
maxlen -=3D 2;
for (i =3D 0; i < maxlen; i++) {
c =3D src[i];
if (!c)
break;
dest[i] =3D cpu_to_le16(c);
}
dest[i] =3D cpu_to_le16('\0');
return i;
}
/* Dump a block of memory starting at buf. Display length bytes. The =
displayed
index of the first byte is start */
void dump_mem(unsigned char *buf, int start, int length)
{
int offs,i;
for(offs=3D0;offs<length;offs+=3D16)
{
printf("%8.8X ",start+offs);
for(i=3D0;i<16;i++)printf(offs+i<length?"%2X ":" =
",buf[offs+i]);
for(i=3D0;i<16;i++)
if (offs+i>=3Dlength) { putchar(' '); } else
if(buf[offs+i]>31 && =
buf[offs+i]<128)putchar(buf[offs+i]
);
else putchar('.');
putchar('\n');
}
}
typedef struct {
ntfs_volume* vol;
} ntfsls_dirent;
int
list_entry(ntfsls_dirent* dirent, const uchar_t* name,=20
const int name_len, const int name_type, const s64 pos,
const MFT_REF mref, const unsigned dt_type) {
char filename[200];
ucstos(filename, name, min(name_len+1,sizeof(filename)));
//printf("[%s\t,%d,%d]\n", filename, name_type, dt_type);
if ((filename[0] =3D=3D '$') && (!opts.sys)) {
return 0;
} else
if (name_type =3D=3D 0 && !opts.all) {
return 0;
}
if (((name_type & 3) =3D=3D 1) && (opts.dos!=3D0)) {
return 0;
}
if (((name_type & 3) =3D=3D 2) && (opts.dos!=3D1)) {
return 0;
}
if (dt_type =3D=3D NTFS_DT_DIR && opts.classify) {
sprintf(filename+strlen(filename),"/");
}
if (!opts.lng) {
printf(filename);
printf("\n");
} else {
ntfs_inode *ni =3D NULL;
MFT_RECORD *mrec =3D NULL;
ntfs_attr_search_ctx *ctx =3D NULL;
FILE_NAME_ATTR *file_name_attr =3D NULL;
ATTR_RECORD *attr =3D NULL;
time_t ntfs_time;
ni =3D ntfs_inode_open(dirent->vol, mref);
if (!ni) {=20
return -1;=20
}
//dump_mem(ni, 0, sizeof(ntfs_inode));
if (ntfs_file_record_read(dirent->vol, mref, &mrec, NULL)) {
return -1;
}
//dump_mem(mrec, 0, 512);
ctx =3D ntfs_attr_get_search_ctx(ni, mrec);
if (!ctx) {=20
return -1;=20
}
if(ntfs_attr_lookup(AT_FILE_NAME, AT_UNNAMED, 0, 0, 0, NULL, 0, =
ctx)) {
return -1;
}
attr =3D ctx->attr;
//dump_mem(attr, 0, sizeof(*attr));
file_name_attr =3D (FILE_NAME_ATTR*)((char *)attr + =
le16_to_cpu(attr->value_offset));
if (!file_name_attr) {
return -1;
}
//dump_mem(file_name_attr, 0, sizeof(*file_name_attr));
ntfs_time =3D ntfs2utc (sle64_to_cpu =
(file_name_attr->last_data_change_time));
char t_buf[26];
strcpy(t_buf, ctime(&ntfs_time));
t_buf[16] =3D '\0';
=20
s64 filesize =3D 0;
#if 0
if (!filesize) {
filesize =3D sle64_to_cpu(file_name_attr->data_size);
}
#endif
if (dt_type !=3D NTFS_DT_DIR && !filesize) {
if(!ntfs_attr_lookup(AT_DATA, AT_UNNAMED, 0, 0, 0, NULL, 0, ctx)) {
attr =3D ctx->attr;
//dump_mem(attr, 0, sizeof(*attr));
if (!attr->non_resident) {
filesize =3D attr->value_length;
} else {
filesize =3D attr->data_size;
}
}
}
if (opts.inode) {
printf("%12lld %18lld %s\n", filesize, mref, filename);
} else {
printf("%12lld %s %s\n", filesize, t_buf+4, filename);
}
}
=09
return 0;
}
/**
* main - Begin here
*
* Start from here.
*
* Return: 0 Success, the program worked
* 1 Error, something went wrong
*/
int main(int argc, char **argv)
{
ntfs_volume *vol;
if (!parse_options (argc, argv))
return 1;
utils_set_locale();
vol =3D utils_mount_volume (opts.device, MS_RDONLY, opts.force);
if (!vol)
return 2;
s64 pos =3D 0;
u64 ino;
ntfs_inode* ni =3D vol->mft_ni;
uchar_t unicode[100];
int len;
ni =3D ntfs_inode_open(vol, FILE_root);
char* p =3D opts.path;
while (p && *p && *p =3D=3D '/') p++;
while (p && *p) {
char* q =3D strchr(p, '/');
if (q !=3D NULL) {
*q =3D '\0';
q++;
}
len =3D stoucs(unicode, p, sizeof(unicode));
ino =3D ntfs_inode_lookup_by_name(ni, unicode, len);
ni =3D ntfs_inode_open(vol, ino);
p =3D q;
while (p && *p && *p =3D=3D '/') p++;
}
ntfsls_dirent dirent;
dirent.vol =3D vol;
ntfs_readdir(ni, &pos, &dirent, list_entry);
ntfs_umount (vol, FALSE);
return 0;
}
/*
* Local Variables:
* c-basic-offset:4
* tab-width:8
* End:
*/
|
