/**
* ntfs_log_parse_option - Act upon command line options
* @option: Option flag
*
* Delegate some of the work of parsing the command line. All the options begin
* with "--log-". Options cause log levels to be enabled in @ntfs_log (the
* global logging structure).
*
* Note: The "colour" option changes the logging handler.
*
* Returns: TRUE Option understood
* FALSE Invalid log option
*/
BOOL1 ntfs_log_parse_option(const char *option)
{
if (strcmp(option, "--log-debug") == 0) {
ntfs_log_set_levels(NTFS_LOG_LEVEL_DEBUG);
return TRUE;
} else if (strcmp(option, "--log-verbose") == 0) {
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
return TRUE;
} else if (strcmp(option, "--log-quiet") == 0) {
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
return TRUE;
} else if (strcmp(option, "--log-trace") == 0) {
ntfs_log_set_levels(NTFS_LOG_LEVEL_TRACE);
return TRUE;
}
ntfs_log_debug("Unknown logging option '%s'\n", option);
return FALSE;
}
char *parse_mount_options(ntfs_fuse_context_t *ctx,
const struct ntfs_options *popts, BOOL low_fuse)
{
char *options, *s, *opt, *val, *ret = NULL;
const char *orig_opts = popts->options;
BOOL no_def_opts = FALSE;
int default_permissions = 0;
int permissions = 0;
int acl = 0;
int want_permissions = 0;
int intarg;
const struct DEFOPTION *poptl;
ctx->secure_flags = 0;
#ifdef HAVE_SETXATTR /* extended attributes interface required */
ctx->efs_raw = FALSE;
#endif /* HAVE_SETXATTR */
ctx->compression = DEFAULT_COMPRESSION;
options = strdup(orig_opts ? orig_opts : "");
if (!options) {
ntfs_log_perror("%s: strdup failed", EXEC_NAME);
return NULL;
}
s = options;
while (s && *s && (val = strsep(&s, ","))) {
opt = strsep(&val, "=");
poptl = optionlist;
while (poptl->name && strcmp(poptl->name,opt))
poptl++;
if (poptl->name) {
if ((poptl->flags & FLGOPT_BOGUS)
&& bogus_option_value(val, opt))
goto err_exit;
if ((poptl->flags & FLGOPT_OCTAL)
&& (!val
|| !sscanf(val, "%o", &intarg))) {
ntfs_log_error("'%s' option needs an octal value\n",
opt);
goto err_exit;
}
if (poptl->flags & FLGOPT_DECIMAL) {
if ((poptl->flags & FLGOPT_OPTIONAL) && !val)
intarg = 0;
else
if (!val
|| !sscanf(val, "%i", &intarg)) {
ntfs_log_error("'%s' option "
"needs a decimal value\n",
opt);
goto err_exit;
}
}
if ((poptl->flags & FLGOPT_STRING)
&& missing_option_value(val, opt))
goto err_exit;
switch (poptl->type) {
case OPT_RO :
case OPT_FAKE_RW :
ctx->ro = TRUE;
break;
case OPT_NOATIME :
ctx->atime = ATIME_DISABLED;
break;
case OPT_ATIME :
ctx->atime = ATIME_ENABLED;
break;
case OPT_RELATIME :
ctx->atime = ATIME_RELATIVE;
break;
case OPT_DMTIME :
if (!intarg)
intarg = DEFAULT_DMTIME;
ctx->dmtime = intarg*10000000LL;
break;
case OPT_NO_DEF_OPTS :
no_def_opts = TRUE; /* Don't add default options. */
ctx->silent = FALSE; /* cancel default silent */
break;
case OPT_DEFAULT_PERMISSIONS :
default_permissions = 1;
break;
case OPT_PERMISSIONS :
permissions = 1;
break;
#if POSIXACLS
case OPT_ACL :
acl = 1;
break;
#endif
case OPT_UMASK :
ctx->dmask = ctx->fmask = intarg;
want_permissions = 1;
break;
case OPT_FMASK :
ctx->fmask = intarg;
want_permissions = 1;
break;
case OPT_DMASK :
ctx->dmask = intarg;
want_permissions = 1;
break;
case OPT_UID :
ctx->uid = intarg;
want_permissions = 1;
break;
case OPT_GID :
ctx->gid = intarg;
want_permissions = 1;
break;
case OPT_SHOW_SYS_FILES :
ctx->show_sys_files = TRUE;
break;
case OPT_HIDE_HID_FILES :
ctx->hide_hid_files = TRUE;
break;
case OPT_HIDE_DOT_FILES :
ctx->hide_dot_files = TRUE;
break;
case OPT_WINDOWS_NAMES :
ctx->windows_names = TRUE;
break;
case OPT_IGNORE_CASE :
if (low_fuse)
ctx->ignore_case = TRUE;
else {
ntfs_log_error("'%s' is an unsupported option.\n",
poptl->name);
goto err_exit;
}
break;
case OPT_COMPRESSION :
ctx->compression = TRUE;
break;
case OPT_NOCOMPRESSION :
ctx->compression = FALSE;
break;
case OPT_SILENT :
ctx->silent = TRUE;
break;
case OPT_RECOVER :
ctx->recover = TRUE;
break;
case OPT_NORECOVER :
ctx->recover = FALSE;
break;
case OPT_REMOVE_HIBERFILE :
ctx->hiberfile = TRUE;
break;
case OPT_SYNC :
ctx->sync = TRUE;
break;
#ifdef FUSE_CAP_BIG_WRITES
case OPT_BIG_WRITES :
ctx->big_writes = TRUE;
break;
#endif
case OPT_LOCALE :
ntfs_set_char_encoding(val);
break;
#if defined(__APPLE__) || defined(__DARWIN__)
#ifdef ENABLE_NFCONV
case OPT_NFCONV :
if (ntfs_macosx_normalize_filenames(1)) {
ntfs_log_error("ntfs_macosx_normalize_filenames(1) failed!\n");
goto err_exit;
}
break;
case OPT_NONFCONV :
if (ntfs_macosx_normalize_filenames(0)) {
ntfs_log_error("ntfs_macosx_normalize_filenames(0) failed!\n");
goto err_exit;
}
break;
#endif /* ENABLE_NFCONV */
#endif /* defined(__APPLE__) || defined(__DARWIN__) */
case OPT_STREAMS_INTERFACE :
if (!strcmp(val, "none"))
ctx->streams = NF_STREAMS_INTERFACE_NONE;
else if (!strcmp(val, "xattr"))
ctx->streams = NF_STREAMS_INTERFACE_XATTR;
else if (!strcmp(val, "openxattr"))
ctx->streams = NF_STREAMS_INTERFACE_OPENXATTR;
else if (!low_fuse && !strcmp(val, "windows"))
ctx->streams = NF_STREAMS_INTERFACE_WINDOWS;
else {
ntfs_log_error("Invalid named data streams "
"access interface.\n");
goto err_exit;
}
break;
case OPT_USER_XATTR :
ctx->streams = NF_STREAMS_INTERFACE_XATTR;
break;
case OPT_NOAUTO :
/* Don't pass noauto option to fuse. */
break;
case OPT_DEBUG :
ctx->debug = TRUE;
ntfs_log_set_levels(NTFS_LOG_LEVEL_DEBUG);
ntfs_log_set_levels(NTFS_LOG_LEVEL_TRACE);
break;
case OPT_NO_DETACH :
ctx->no_detach = TRUE;
break;
case OPT_REMOUNT :
ntfs_log_error("Remounting is not supported at present."
" You have to umount volume and then "
"mount it once again.\n");
goto err_exit;
case OPT_BLKSIZE :
ntfs_log_info("WARNING: blksize option is ignored "
"because ntfs-3g must calculate it.\n");
break;
case OPT_INHERIT :
/*
* do not overwrite inherited permissions
* in create()
*/
ctx->inherit = TRUE;
break;
case OPT_ADDSECURIDS :
/*
* create security ids for files being read
* with an individual security attribute
*/
ctx->secure_flags |= (1 << SECURITY_ADDSECURIDS);
break;
case OPT_STATICGRPS :
/*
* use static definition of groups
* for file access control
*/
ctx->secure_flags |= (1 << SECURITY_STATICGRPS);
break;
case OPT_USERMAPPING :
ctx->usermap_path = strdup(val);
if (!ctx->usermap_path) {
ntfs_log_error("no more memory to store "
"'usermapping' option.\n");
goto err_exit;
}
break;
#ifdef HAVE_SETXATTR /* extended attributes interface required */
#ifdef XATTR_MAPPINGS
case OPT_XATTRMAPPING :
ctx->xattrmap_path = strdup(val);
if (!ctx->xattrmap_path) {
ntfs_log_error("no more memory to store "
"'xattrmapping' option.\n");
goto err_exit;
}
break;
#endif /* XATTR_MAPPINGS */
case OPT_EFS_RAW :
ctx->efs_raw = TRUE;
break;
#endif /* HAVE_SETXATTR */
case OPT_FSNAME : /* Filesystem name. */
/*
* We need this to be able to check whether filesystem
* mounted or not.
* (falling through to default)
*/
default :
ntfs_log_error("'%s' is an unsupported option.\n",
poptl->name);
goto err_exit;
}
if ((poptl->flags & FLGOPT_APPEND)
&& (ntfs_strappend(&ret, poptl->name)
|| ntfs_strappend(&ret, ",")))
goto err_exit;
} else { /* Probably FUSE option. */
if (ntfs_strappend(&ret, opt))
goto err_exit;
if (val) {
if (ntfs_strappend(&ret, "="))
goto err_exit;
if (ntfs_strappend(&ret, val))
goto err_exit;
}
if (ntfs_strappend(&ret, ","))
goto err_exit;
}
}
if (!no_def_opts && ntfs_strappend(&ret, def_opts))
goto err_exit;
if ((default_permissions || (permissions && !acl))
&& ntfs_strappend(&ret, "default_permissions,"))
goto err_exit;
/* The atime options exclude each other */
if (ctx->atime == ATIME_RELATIVE && ntfs_strappend(&ret, "relatime,"))
goto err_exit;
else if (ctx->atime == ATIME_ENABLED && ntfs_strappend(&ret, "atime,"))
goto err_exit;
else if (ctx->atime == ATIME_DISABLED && ntfs_strappend(&ret, "noatime,"))
goto err_exit;
if (ntfs_strappend(&ret, "fsname="))
goto err_exit;
if (ntfs_strappend(&ret, popts->device))
goto err_exit;
if (permissions && !acl)
ctx->secure_flags |= (1 << SECURITY_DEFAULT);
if (acl)
ctx->secure_flags |= (1 << SECURITY_ACL);
if (want_permissions)
ctx->secure_flags |= (1 << SECURITY_WANTED);
if (ctx->ro)
ctx->secure_flags &= ~(1 << SECURITY_ADDSECURIDS);
exit:
free(options);
return ret;
err_exit:
free(ret);
ret = NULL;
goto exit;
}
/**
* 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
*/
static int parse_options(int argc, char **argv)
{
static const char *sopt = "-a:fh?i:n:qVvr";
static const struct option lopt[] = {
{ "attribute", required_argument, NULL, 'a' },
{ "attribute-name", required_argument, NULL, 'n' },
{ "force", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "inode", required_argument, NULL, 'i' },
{ "quiet", no_argument, NULL, 'q' },
{ "version", no_argument, NULL, 'V' },
{ "verbose", no_argument, NULL, 'v' },
{ "raw", no_argument, NULL, 'r' },
{ NULL, 0, NULL, 0 }
};
int c = -1;
int err = 0;
int ver = 0;
int help = 0;
int levels = 0;
ATTR_TYPES attr = AT_UNUSED;
opterr = 0; /* We'll handle the errors, thank you. */
opts.inode = -1;
opts.attr = cpu_to_le32(-1);
opts.attr_name = NULL;
opts.attr_name_len = 0;
while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) {
switch (c) {
case 1: /* A non-option argument */
if (!opts.device) {
opts.device = argv[optind - 1];
} else if (!opts.file) {
opts.file = argv[optind - 1];
} else {
ntfs_log_error("You must specify exactly one "
"file.\n");
err++;
}
break;
case 'a':
if (opts.attr != cpu_to_le32(-1)) {
ntfs_log_error("You must specify exactly one "
"attribute.\n");
} else if (parse_attribute(optarg, &attr) > 0) {
opts.attr = attr;
break;
} else {
ntfs_log_error("Couldn't parse attribute.\n");
}
err++;
break;
case 'f':
opts.force++;
break;
case 'h':
case '?':
if (strncmp (argv[optind-1], "--log-", 6) == 0) {
if (!ntfs_log_parse_option (argv[optind-1]))
err++;
break;
}
help++;
break;
case 'i':
if (opts.inode != -1)
ntfs_log_error("You must specify exactly one inode.\n");
else if (utils_parse_size(optarg, &opts.inode, FALSE))
break;
else
ntfs_log_error("Couldn't parse inode number.\n");
err++;
break;
case 'n':
opts.attr_name_len = ntfs_mbstoucs(optarg,
&opts.attr_name);
if (opts.attr_name_len < 0) {
ntfs_log_perror("Invalid attribute name '%s'",
optarg);
usage();
}
case 'q':
opts.quiet++;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 'V':
ver++;
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
case 'r':
opts.raw = TRUE;
break;
default:
ntfs_log_error("Unknown option '%s'.\n", argv[optind-1]);
err++;
break;
}
}
/* Make sure we're in sync with the log levels */
levels = ntfs_log_get_levels();
if (levels & NTFS_LOG_LEVEL_VERBOSE)
opts.verbose++;
if (!(levels & NTFS_LOG_LEVEL_QUIET))
opts.quiet++;
if (help || ver) {
opts.quiet = 0;
} else {
if (opts.device == NULL) {
ntfs_log_error("You must specify a device.\n");
err++;
} else if (opts.file == NULL && opts.inode == -1) {
ntfs_log_error("You must specify a file or inode "
"with the -i option.\n");
err++;
} else if (opts.file != NULL && opts.inode != -1) {
ntfs_log_error("You can't specify both a file and inode.\n");
err++;
}
if (opts.quiet && opts.verbose) {
ntfs_log_error("You may not use --quiet and --verbose at the "
"same time.\n");
err++;
}
}
if (ver)
version();
if (help || err)
usage();
return (!err && !help && !ver);
}
/**
* 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
*/
static int parse_options(int argc, char *argv[])
{
static const char *sopt = "-fh?nqvV";
static const struct option lopt[] = {
{ "force", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "no-action", no_argument, NULL, 'n' },
{ "quiet", no_argument, NULL, 'q' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 },
};
int c = -1;
int err = 0;
int ver = 0;
int help = 0;
int levels = 0;
opterr = 0; /* We'll handle the errors, thank you. */
while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) {
switch (c) {
case 1: /* A non-option argument */
if (!err && !opts.device)
opts.device = argv[optind-1];
else if (!err && !opts.label)
opts.label = argv[optind-1];
else
err++;
break;
case 'f':
opts.force++;
break;
case 'h':
case '?':
if (strncmp (argv[optind-1], "--log-", 6) == 0) {
if (!ntfs_log_parse_option (argv[optind-1]))
err++;
break;
}
help++;
break;
case 'n':
opts.noaction++;
break;
case 'q':
opts.quiet++;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
case 'V':
ver++;
break;
default:
ntfs_log_error("Unknown option '%s'.\n", argv[optind-1]);
err++;
break;
}
}
/* Make sure we're in sync with the log levels */
levels = ntfs_log_get_levels();
if (levels & NTFS_LOG_LEVEL_VERBOSE)
opts.verbose++;
if (!(levels & NTFS_LOG_LEVEL_QUIET))
opts.quiet++;
if (help || ver) {
opts.quiet = 0;
} else {
if (opts.device == NULL) {
if (argc > 1)
ntfs_log_error("You must specify a device.\n");
err++;
}
if (opts.quiet && opts.verbose) {
ntfs_log_error("You may not use --quiet and --verbose at "
"the same time.\n");
err++;
}
}
if (ver)
version();
if (help || err)
usage();
return (!err && !help && !ver);
}
/**
* 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
*/
static int parse_options(int argc, char **argv)
{
static const char *sopt = "-c:F:fh?I:ilqs:vV";
static const struct option lopt[] = {
{ "cluster", required_argument, NULL, 'c' },
{ "filename", required_argument, NULL, 'F' },
{ "force", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "info", no_argument, NULL, 'i' },
{ "inode", required_argument, NULL, 'I' },
{ "last", no_argument, NULL, 'l' },
{ "quiet", no_argument, NULL, 'q' },
{ "sector", required_argument, NULL, 's' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 }
};
int c = -1;
int err = 0;
int ver = 0;
int help = 0;
int levels = 0;
char *end = NULL;
opterr = 0; /* We'll handle the errors, thank you. */
opts.action = act_none;
opts.range_begin = -1;
opts.range_end = -1;
while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) {
switch (c) {
case 1: /* A non-option argument */
if (!opts.device) {
opts.device = argv[optind-1];
} else {
opts.device = NULL;
err++;
}
break;
case 'c':
if ((opts.action == act_none) &&
(utils_parse_range(optarg, &opts.range_begin, &opts.range_end, FALSE)))
opts.action = act_cluster;
else
opts.action = act_error;
break;
case 'F':
if (opts.action == act_none) {
opts.action = act_file;
opts.filename = optarg;
} else {
opts.action = act_error;
}
break;
case 'f':
opts.force++;
break;
case 'h':
case '?':
if (strncmp (argv[optind-1], "--log-", 6) == 0) {
if (!ntfs_log_parse_option (argv[optind-1]))
err++;
break;
}
help++;
break;
case 'I':
if (opts.action == act_none) {
opts.action = act_inode;
opts.inode = strtol(optarg, &end, 0);
if (end && *end)
err++;
} else {
opts.action = act_error;
}
break;
case 'i':
if (opts.action == act_none)
opts.action = act_info;
else
opts.action = act_error;
break;
case 'l':
if (opts.action == act_none)
opts.action = act_last;
else
opts.action = act_error;
break;
case 'q':
opts.quiet++;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 's':
if ((opts.action == act_none) &&
(utils_parse_range(optarg, &opts.range_begin, &opts.range_end, FALSE)))
opts.action = act_sector;
else
opts.action = act_error;
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
case 'V':
ver++;
break;
default:
if ((optopt == 'c') || (optopt == 's'))
ntfs_log_error("Option '%s' requires an argument.\n", argv[optind-1]);
else
ntfs_log_error("Unknown option '%s'.\n", argv[optind-1]);
err++;
break;
}
}
/* Make sure we're in sync with the log levels */
levels = ntfs_log_get_levels();
if (levels & NTFS_LOG_LEVEL_VERBOSE)
opts.verbose++;
if (!(levels & NTFS_LOG_LEVEL_QUIET))
opts.quiet++;
if (help || ver) {
opts.quiet = 0;
} else {
if (opts.action == act_none)
opts.action = act_info;
if (opts.action == act_info)
opts.quiet = 0;
if (opts.device == NULL) {
if (argc > 1)
ntfs_log_error("You must specify exactly one device.\n");
err++;
}
if (opts.quiet && opts.verbose) {
ntfs_log_error("You may not use --quiet and --verbose at the same time.\n");
err++;
}
if (opts.action == act_error) {
ntfs_log_error("You may only specify one action: --info, --cluster, --sector or --last.\n");
err++;
} else if (opts.range_begin > opts.range_end) {
ntfs_log_error("The range must be in ascending order.\n");
err++;
}
}
if (ver)
version();
if (help || err)
usage();
return (!err && !help && !ver);
}
/**
* 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
*/
static int parse_options(int argc, char **argv)
{
static const char *sopt = "-fh?i:k:qVv";
static const struct option lopt[] = {
{"force", no_argument, NULL, 'f'},
{"help", no_argument, NULL, 'h'},
{"inode", required_argument, NULL, 'i'},
{"keyfile", required_argument, NULL, 'k'},
{"quiet", no_argument, NULL, 'q'},
{"version", no_argument, NULL, 'V'},
{"verbose", no_argument, NULL, 'v'},
{NULL, 0, NULL, 0}
};
int c = -1;
int err = 0;
int ver = 0;
int help = 0;
opterr = 0; /* We'll handle the errors, thank you. */
opts.inode = -1;
while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) {
switch (c) {
case 1: /* A non-option argument */
if (!opts.device)
opts.device = argv[optind - 1];
else if (!opts.file)
opts.file = argv[optind - 1];
else {
ntfs_log_error("You must specify exactly one "
"file.\n");
err++;
}
break;
case 'f':
opts.force++;
break;
case 'h':
case '?':
help++;
break;
case 'k':
if (!opts.keyfile)
opts.keyfile = argv[optind - 1];
else {
ntfs_log_error("You must specify exactly one "
"key file.\n");
err++;
}
break;
case 'i':
if (opts.inode != -1)
ntfs_log_error("You must specify exactly one "
"inode.\n");
else if (utils_parse_size(optarg, &opts.inode, FALSE))
break;
else
ntfs_log_error("Couldn't parse inode number.\n");
err++;
break;
case 'q':
opts.quiet++;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 'V':
ver++;
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
default:
ntfs_log_error("Unknown option '%s'.\n",
argv[optind - 1]);
err++;
break;
}
}
if (help || ver) {
opts.quiet = 0;
ntfs_log_set_levels(NTFS_LOG_LEVEL_QUIET);
} else {
if (!opts.keyfile) {
ntfs_log_error("You must specify a key file.\n");
err++;
} else if (opts.device == NULL) {
ntfs_log_error("You must specify a device.\n");
err++;
} else if (opts.file == NULL && opts.inode == -1) {
ntfs_log_error("You must specify a file or inode with "
"the -i option.\n");
err++;
} else if (opts.file != NULL && opts.inode != -1) {
ntfs_log_error("You can't specify both a file and "
"inode.\n");
err++;
}
if (opts.quiet && opts.verbose) {
ntfs_log_error("You may not use --quiet and --verbose "
"at the same time.\n");
err++;
}
}
if (ver)
version();
if (help || err)
usage();
return (!err && !help && !ver);
}
/**
* 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
*/
static int parse_options(int argc, char *argv[])
{
static const char *sopt = "-fh?IinqvV";
static const struct option lopt[] = {
{ "force", no_argument, NULL, 'f' },
{ "help", no_argument, NULL, 'h' },
{ "new-serial", optional_argument, NULL, 'I' },
{ "new-half-serial", optional_argument, NULL, 'i' },
{ "no-action", no_argument, NULL, 'n' },
{ "quiet", no_argument, NULL, 'q' },
{ "verbose", no_argument, NULL, 'v' },
{ "version", no_argument, NULL, 'V' },
{ NULL, 0, NULL, 0 },
};
int c = -1;
int err = 0;
int ver = 0;
int help = 0;
int levels = 0;
char *endserial;
opterr = 0; /* We'll handle the errors, thank you. */
while ((c = getopt_long(argc, argv, sopt, lopt, NULL)) != -1) {
switch (c) {
case 1: /* A non-option argument */
if (!err && !opts.device)
opts.device = argv[optind-1];
else if (!err && !opts.label)
opts.label = argv[optind-1];
else
err++;
break;
case 'f':
opts.force++;
break;
case 'h':
help++;
break;
case 'I' : /* not proposed as a short option letter */
if (optarg) {
opts.serial = strtoull(optarg, &endserial, 16);
if (*endserial)
ntfs_log_error("Bad hexadecimal serial number.\n");
}
opts.new_serial |= 2;
break;
case 'i' : /* not proposed as a short option letter */
if (optarg) {
opts.serial = strtoull(optarg, &endserial, 16)
<< 32;
if (*endserial)
ntfs_log_error("Bad hexadecimal serial number.\n");
}
opts.new_serial |= 1;
break;
case 'n':
opts.noaction++;
break;
case 'q':
opts.quiet++;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
case 'V':
ver++;
break;
case '?':
if (strncmp (argv[optind-1], "--log-", 6) == 0) {
if (!ntfs_log_parse_option (argv[optind-1]))
err++;
break;
}
/* fall through */
default:
ntfs_log_error("Unknown option '%s'.\n", argv[optind-1]);
err++;
break;
}
}
/* Make sure we're in sync with the log levels */
levels = ntfs_log_get_levels();
if (levels & NTFS_LOG_LEVEL_VERBOSE)
opts.verbose++;
if (!(levels & NTFS_LOG_LEVEL_QUIET))
opts.quiet++;
if (help || ver) {
opts.quiet = 0;
} else {
if (opts.device == NULL) {
if (argc > 1)
ntfs_log_error("You must specify a device.\n");
err++;
}
if (opts.quiet && opts.verbose) {
ntfs_log_error("You may not use --quiet and --verbose at "
"the same time.\n");
err++;
}
}
if (ver)
version();
if (help || err)
usage();
/* tri-state 0 : done, 1 : error, -1 : proceed */
return (err ? 1 : (help || ver ? 0 : -1));
}
dir_partition_t dir_partition_ntfs_init(disk_t *disk_car, const partition_t *partition, dir_data_t *dir_data, const int verbose, const int expert)
{
#if defined(HAVE_LIBNTFS) || defined(HAVE_LIBNTFS3G)
struct ntfs_device *dev;
my_data_t *my_data=NULL;
ntfs_volume *vol=NULL;
#ifdef NTFS_LOG_LEVEL_VERBOSE
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
ntfs_log_set_handler(ntfs_log_handler_stderr);
#endif
dev = ntfs_device_alloc("/", 0, &ntfs_device_testdisk_io_ops, NULL);
if (dev)
{
my_data=(my_data_t *)MALLOC(sizeof(*my_data));
my_data->partition=partition;
my_data->disk_car=disk_car;
my_data->offset=0;
dev->d_private=my_data;
/* Call ntfs_device_mount() to do the actual mount. */
#ifdef MS_RDONLY
vol = ntfs_device_mount(dev, MS_RDONLY);
#else
vol = ntfs_device_mount(dev, NTFS_MNT_RDONLY);
#endif
#ifdef HAVE_NTFS_VOLUME_STARTUP
if(!vol) {
#ifdef MS_RDONLY
vol = ntfs_volume_startup(dev, MS_RDONLY);
#else
vol = ntfs_volume_startup(dev, NTFS_MNT_RDONLY);
#endif
if(vol)
{
log_warning("NTFS filesystem needs to be repaired.\n");
}
}
#endif
}
if (!vol) {
free(my_data);
ntfs_device_free(dev);
return DIR_PART_EIO;
}
if (vol->flags & VOLUME_IS_DIRTY) {
log_warning("NTFS Volume is dirty.\n");
}
{
struct ntfs_dir_struct *ls=(struct ntfs_dir_struct *)MALLOC(sizeof(*ls));
ls->dir_list=NULL;
ls->vol=vol;
ls->my_data=my_data;
ls->dir_data=dir_data;
#ifdef HAVE_ICONV
if ((ls->cd = iconv_open("UTF-8", "UTF-16LE")) == (iconv_t)(-1))
{
log_error("ntfs_ucstoutf8: iconv_open failed\n");
}
#endif
strncpy(dir_data->current_directory,"/",sizeof(dir_data->current_directory));
dir_data->current_inode=FILE_root;
dir_data->param=FLAG_LIST_ADS;
if(expert!=0)
dir_data->param|=FLAG_LIST_SYSTEM;
dir_data->verbose=verbose;
dir_data->capabilities=CAPA_LIST_ADS;
dir_data->get_dir=&ntfs_dir;
dir_data->copy_file=&ntfs_copy;
dir_data->close=&dir_partition_ntfs_close;
dir_data->local_dir=NULL;
dir_data->private_dir_data=ls;
}
return DIR_PART_OK;
#else
return DIR_PART_ENOSYS;
#endif
}
/**
* parse_options
*/
static void parse_options(int argc, char *argv[])
{
long long ll;
char *s, *s2;
int c;
opt_alloc_len = 0;
opt_alloc_offs = 0;
if (argc && *argv)
EXEC_NAME = *argv;
fprintf(stderr, "%s v%s (libntfs-3g)\n", EXEC_NAME, VERSION);
while ((c = getopt_long(argc, argv, "fh?no:qvVl:", lopt, NULL)) != EOF) {
switch (c) {
case 'f':
opts.force = 1;
break;
case 'n':
opts.no_size_change = 1;
break;
case 'N': /* Not proposed as a short option */
opts.no_action = 1;
break;
case 'q':
opts.quiet = 1;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
case 'V':
/* Version number already printed */
license();
exit(0);
case 'l':
ll = option_value(argv[optind - 1]);
if ((ll <= 0)
|| (ll >= LLONG_MAX && errno == ERANGE))
err_usage("Invalid length : %s\n",
argv[optind - 1]);
opt_alloc_len = ll;
break;
case 'o':
ll = option_value(argv[optind - 1]);
if ((ll < 0)
|| (ll >= LLONG_MAX && errno == ERANGE))
err_usage("Invalid offset : %s\n",
argv[optind - 1]);
opt_alloc_offs = ll;
break;
case 'h':
usage(0);
case '?':
default:
usage(1);
}
}
if (!opt_alloc_len) {
err_usage("Missing allocation length\n");
}
ntfs_log_verbose("length = %lli = 0x%llx\n",
(long long)opt_alloc_len, (long long)opt_alloc_len);
ntfs_log_verbose("offset = %lli = 0x%llx\n",
(long long)opt_alloc_offs, (long long)opt_alloc_offs);
if (optind == argc)
usage(1);
if (opts.verbose > 1)
ntfs_log_set_levels(NTFS_LOG_LEVEL_DEBUG | NTFS_LOG_LEVEL_TRACE |
NTFS_LOG_LEVEL_VERBOSE | NTFS_LOG_LEVEL_QUIET);
/* Get the device. */
dev_name = argv[optind++];
ntfs_log_verbose("device name = %s\n", dev_name);
if (optind == argc)
usage(1);
/* Get the file name. */
file_name = argv[optind++];
ntfs_log_verbose("file name = \"%s\"\n", file_name);
/* Get the attribute type, if specified. */
if (optind == argc) {
attr_type = AT_DATA;
attr_name = AT_UNNAMED;
attr_name_len = 0;
} else {
unsigned long ul;
s = argv[optind++];
ul = strtoul(s, &s2, 0);
if (*s2 || !ul || (ul >= ULONG_MAX && errno == ERANGE))
err_usage("Invalid attribute type %s: %s\n", s,
strerror(errno));
attr_type = cpu_to_le32(ul);
/* Get the attribute name, if specified. */
if (optind != argc) {
s = argv[optind++];
/* Convert the string to little endian Unicode. */
attr_name_len = ntfs_mbstoucs(s, &attr_name);
if ((int)attr_name_len < 0)
err_usage("Invalid attribute name "
"\"%s\": %s\n",
s, strerror(errno));
/* Keep hold of the original string. */
s2 = s;
s = argv[optind++];
if (optind != argc)
usage(1);
} else {
attr_name = AT_UNNAMED;
attr_name_len = 0;
}
}
ntfs_log_verbose("attribute type = 0x%lx\n",
(unsigned long)le32_to_cpu(attr_type));
if (attr_name == AT_UNNAMED)
ntfs_log_verbose("attribute name = \"\" (UNNAMED)\n");
else
ntfs_log_verbose("attribute name = \"%s\" (length %u "
"Unicode characters)\n", s2,
(unsigned int)attr_name_len);
}
/**
* parse_options
*/
static void parse_options(int argc, char *argv[])
{
long long ll;
char *s, *s2;
int c;
if (argc && *argv)
EXEC_NAME = *argv;
fprintf(stderr, "%s v%s (libntfs-3g)\n", EXEC_NAME, VERSION);
while ((c = getopt(argc, argv, "fh?nqvVl")) != EOF)
switch (c) {
case 'f':
opts.force = 1;
break;
case 'n':
opts.no_action = 1;
break;
case 'q':
opts.quiet = 1;
ntfs_log_clear_levels(NTFS_LOG_LEVEL_QUIET);
break;
case 'v':
opts.verbose++;
ntfs_log_set_levels(NTFS_LOG_LEVEL_VERBOSE);
break;
case 'V':
/* Version number already printed, so just exit. */
exit(0);
case 'l':
copyright();
license();
exit(0);
case 'h':
case '?':
default:
usage();
}
if (optind == argc)
usage();
if (opts.verbose > 1)
ntfs_log_set_levels(NTFS_LOG_LEVEL_DEBUG | NTFS_LOG_LEVEL_TRACE |
NTFS_LOG_LEVEL_VERBOSE | NTFS_LOG_LEVEL_QUIET);
/* Get the device. */
dev_name = argv[optind++];
ntfs_log_verbose("device name = %s\n", dev_name);
if (optind == argc)
usage();
/* Get the inode. */
ll = strtoll(argv[optind++], &s, 0);
if (*s || !ll || (ll >= LLONG_MAX && errno == ERANGE))
err_exit("Invalid inode number: %s\n", argv[optind - 1]);
inode = ll;
ntfs_log_verbose("inode = %lli\n", (long long)inode);
if (optind == argc)
usage();
/* Get the attribute type, if specified. */
s = argv[optind++];
if (optind == argc) {
attr_type = AT_DATA;
attr_name = AT_UNNAMED;
attr_name_len = 0;
} else {
unsigned long ul;
ul = strtoul(s, &s2, 0);
if (*s2 || !ul || (ul >= ULONG_MAX && errno == ERANGE))
err_exit("Invalid attribute type %s: %s\n", s,
strerror(errno));
attr_type = ul;
/* Get the attribute name, if specified. */
s = argv[optind++];
if (optind != argc) {
/* Convert the string to little endian Unicode. */
attr_name_len = ntfs_mbstoucs(s, &attr_name);
if ((int)attr_name_len < 0)
err_exit("Invalid attribute name \"%s\": %s\n",
s, strerror(errno));
/* Keep hold of the original string. */
s2 = s;
s = argv[optind++];
if (optind != argc)
usage();
} else {
attr_name = AT_UNNAMED;
attr_name_len = 0;
}
}
ntfs_log_verbose("attribute type = 0x%x\n", (unsigned int)attr_type);
if (attr_name == AT_UNNAMED)
ntfs_log_verbose("attribute name = \"\" (UNNAMED)\n");
else
ntfs_log_verbose("attribute name = \"%s\" (length %u Unicode "
"characters)\n", s2,
(unsigned int)attr_name_len);
/* Get the new length. */
ll = strtoll(s, &s2, 0);
if (*s2 || ll < 0 || (ll >= LLONG_MAX && errno == ERANGE))
err_exit("Invalid new length: %s\n", s);
new_len = ll;
ntfs_log_verbose("new length = %lli\n", (long long)new_len);
}