/**
* change_label - change the current label on a device
* @dev: device to change the label on
* @mnt_flags: mount flags of the device or 0 if not mounted
* @mnt_point: mount point of the device or NULL
* @label: the new label
*
* Change the label on the device @dev to @label.
*/
static int change_label(ntfs_volume *vol, char *label)
{
ntfschar *new_label = NULL;
int label_len;
int result = 0;
label_len = ntfs_mbstoucs(label, &new_label);
if (label_len == -1) {
ntfs_log_perror("Unable to convert label string to Unicode");
return 1;
}
else if (label_len*sizeof(ntfschar) > 0x100) {
ntfs_log_warning("New label is too long. Maximum %u characters "
"allowed. Truncating %u excess characters.\n",
(unsigned)(0x100 / sizeof(ntfschar)),
(unsigned)(label_len -
(0x100 / sizeof(ntfschar))));
label_len = 0x100 / sizeof(ntfschar);
label[label_len] = const_cpu_to_le16(0);
}
if(!opts.noaction)
result = ntfs_volume_rename(vol, new_label, label_len) ? 1 : 0;
free(new_label);
return result;
}
/**
* change_label - change the current label on a device
* @dev: device to change the label on
* @mnt_flags: mount flags of the device or 0 if not mounted
* @mnt_point: mount point of the device or NULL
* @label: the new label
*
* Change the label on the device @dev to @label.
*/
static int change_label(ntfs_volume *vol, unsigned long mnt_flags, char *label, BOOL force)
{
ntfschar *new_label = NULL;
int label_len;
int result = 0;
//XXX significant?
if (mnt_flags & NTFS_MF_MOUNTED) {
/* If not the root fs or mounted read/write, refuse change. */
if (!(mnt_flags & NTFS_MF_ISROOT) ||
!(mnt_flags & NTFS_MF_READONLY)) {
if (!force) {
ntfs_log_error("Refusing to change label on "
"read-%s mounted device %s.\n",
mnt_flags & NTFS_MF_READONLY ?
"only" : "write", opts.device);
return 1;
}
}
}
label_len = ntfs_mbstoucs(label, &new_label);
if (label_len == -1) {
ntfs_log_perror("Unable to convert label string to Unicode");
return 1;
}
else if (label_len*sizeof(ntfschar) > 0x100) {
ntfs_log_warning("New label is too long. Maximum %u characters "
"allowed. Truncating %u excess characters.\n",
(unsigned)(0x100 / sizeof(ntfschar)),
(unsigned)(label_len -
(0x100 / sizeof(ntfschar))));
label_len = 0x100 / sizeof(ntfschar);
label[label_len] = const_cpu_to_le16(0);
}
if(!opts.noaction)
result = ntfs_volume_rename(vol, new_label, label_len) ? 1 : 0;
free(new_label);
return result;
}
/**
* 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);
}
status_t
fs_open_attrib(fs_volume *_vol, fs_vnode *_node, const char *name,
int openMode, void **_cookie)
{
nspace *ns = (nspace*)_vol->private_volume;
vnode *node = (vnode*)_node->private_node;
attrcookie *cookie = NULL;
ntfschar *uname = NULL;
int ulen;
ntfs_inode *ni = NULL;
ntfs_attr *na = NULL;
status_t result = B_NO_ERROR;
TRACE("%s - ENTER\n", __FUNCTION__);
LOCK_VOL(ns);
if (node == NULL) {
result = EINVAL;
goto exit;
}
ni = ntfs_inode_open(ns->ntvol, node->vnid);
if (ni == NULL) {
result = errno;
goto exit;
}
// UXA demangling TODO
// check for EA first... TODO: WRITEME
// check for a named stream
if (true) {
uname = ntfs_calloc(MAX_PATH);
ulen = ntfs_mbstoucs(name, &uname);
if (ulen < 0) {
result = EILSEQ;
goto exit;
}
na = ntfs_attr_open(ni, AT_DATA, uname, ulen);
if (na) {
if (openMode & O_TRUNC) {
if (ntfs_attr_truncate(na, 0))
result = errno;
}
} else {
result = ENOENT;
goto exit;
}
}
cookie = (attrcookie*)ntfs_calloc(sizeof(attrcookie));
if (cookie != NULL) {
cookie->omode = openMode;
*_cookie = (void*)cookie;
cookie->inode = ni;
cookie->stream = na;
ni = NULL;
na = NULL;
} else
result = ENOMEM;
exit:
if (uname)
free(uname);
if (na)
ntfs_attr_close(na);
if (ni)
ntfs_inode_close(ni);
TRACE("%s - EXIT, result is %s\n", __FUNCTION__, strerror(result));
UNLOCK_VOL(ns);
return result;
}
status_t
fs_open_attrib(fs_volume *_vol, fs_vnode *_node, const char *name,
int openMode, void **_cookie)
{
nspace *ns = (nspace*)_vol->private_volume;
vnode *node = (vnode*)_node->private_node;
attrcookie *cookie = NULL;
ntfschar *uname = NULL;
int ulen;
ntfs_inode *ni = NULL;
ntfs_attr *na = NULL;
status_t result = B_NO_ERROR;
uint32 type = B_XATTR_TYPE;
TRACE("%s - ENTER - name: [%s] vnid: %d\n", __FUNCTION__, name, node->vnid);
LOCK_VOL(ns);
if (node == NULL) {
result = EINVAL;
goto exit;
}
ni = ntfs_inode_open(ns->ntvol, node->vnid);
if (ni == NULL) {
result = errno;
goto exit;
}
// UXA demangling TODO
// check for EA first... TODO: WRITEME
// check for a named stream
if (true) {
char ntfs_attr_name[MAX_PATH] = {0};
strcat(ntfs_attr_name, kHaikuAttrPrefix);
strcat(ntfs_attr_name, name);
uname = ntfs_calloc(MAX_PATH);
ulen = ntfs_mbstoucs(ntfs_attr_name, &uname);
if (ulen < 0) {
result = EILSEQ;
goto exit;
}
na = ntfs_attr_open(ni, AT_DATA, uname, ulen);
if (na != NULL) {
if (openMode & O_TRUNC) {
if (ns->flags & B_FS_IS_READONLY) {
result = B_READ_ONLY_DEVICE;
goto exit;
} else {
if (ntfs_attr_truncate(na, sizeof(uint32))) {
result = errno;
goto exit;
}
}
}
if (ntfs_attr_pread(na, 0, sizeof(uint32), &type) != sizeof(uint32)) {
result = errno;
goto exit;
}
} else {
result = ENOENT;
goto exit;
}
}
cookie = (attrcookie*)ntfs_calloc(sizeof(attrcookie));
if (cookie != NULL) {
cookie->omode = openMode;
cookie->vnid = node->vnid;
cookie->uname = uname;
cookie->uname_len = ulen;
cookie->type = type;
*_cookie = (void*)cookie;
uname = NULL;
} else
result = ENOMEM;
exit:
if (uname != NULL)
free(uname);
if (na != NULL)
ntfs_attr_close(na);
if (ni != NULL)
ntfs_inode_close(ni);
TRACE("%s - EXIT, result is %s\n", __FUNCTION__, strerror(result));
UNLOCK_VOL(ns);
return result;
}
status_t
fs_remove_attrib(fs_volume *_vol, fs_vnode *_node, const char* name)
{
nspace *ns = (nspace *)_vol->private_volume;
vnode *node = (vnode *)_node->private_node;
char ntfs_attr_name[MAX_PATH]={0};
ntfschar *uname = NULL;
int ulen;
ntfs_inode *ni = NULL;
status_t result = B_NO_ERROR;
TRACE("%s - ENTER - name: [%s]\n", __FUNCTION__, name);
if (ns->flags & B_FS_IS_READONLY) {
ERROR("ntfs is read-only\n");
return B_READ_ONLY_DEVICE;
}
LOCK_VOL(ns);
if (node == NULL) {
result = EINVAL;
goto exit;
}
ni = ntfs_inode_open(ns->ntvol, node->vnid);
if (ni == NULL) {
result = errno;
goto exit;
}
strcat(ntfs_attr_name, kHaikuAttrPrefix);
strcat(ntfs_attr_name, name);
uname = ntfs_calloc(MAX_PATH);
ulen = ntfs_mbstoucs(ntfs_attr_name, &uname);
if (ulen < 0) {
result = EILSEQ;
goto exit;
}
if (ntfs_attr_remove(ni, AT_DATA, uname, ulen)) {
result = ENOENT;
goto exit;
}
if (!(ni->flags & FILE_ATTR_ARCHIVE)) {
ni->flags |= FILE_ATTR_ARCHIVE;
NInoFileNameSetDirty(ni);
}
notify_attribute_changed(ns->id, MREF(ni->mft_no), name, B_ATTR_REMOVED);
exit:
if (uname != NULL)
free(uname);
if (ni != NULL)
ntfs_inode_close(ni);
TRACE("%s - EXIT, result is %s\n", __FUNCTION__, strerror(result));
UNLOCK_VOL(ns);
return result;
}
static int ntfs_copy(disk_t *disk_car, const partition_t *partition, dir_data_t *dir_data, const file_info_t *file)
{
const unsigned long int first_inode=file->st_ino;
ntfs_inode *inode;
struct ntfs_dir_struct *ls=(struct ntfs_dir_struct*)dir_data->private_dir_data;
inode = ntfs_inode_open (ls->vol, first_inode);
if (!inode) {
log_error("ntfs_copy: ntfs_inode_open failed for %s\n", dir_data->current_directory);
return -1;
}
{
char *buffer;
char *new_file;
ntfs_attr *attr=NULL;
FILE *f_out;
char *stream_name;
s64 offset;
u32 block_size;
buffer = (char *)MALLOC(bufsize);
if (!buffer)
{
ntfs_inode_close(inode);
return -2;
}
stream_name=strrchr(dir_data->current_directory, ':');
if(stream_name)
stream_name++;
if(stream_name != NULL)
{
ntfschar *stream_name_ucs=NULL;
#ifdef NTFS_MBSTOUCS_HAVE_TWO_ARGUMENTS
const int len=ntfs_mbstoucs(stream_name, &stream_name_ucs);
#else
const int len=ntfs_mbstoucs(stream_name, &stream_name_ucs, 0);
#endif
if(len < 0)
log_error("ntfs_mbstoucs failed\n");
else
attr = ntfs_attr_open(inode, AT_DATA, stream_name_ucs, len);
}
else
attr = ntfs_attr_open(inode, AT_DATA, NULL, 0);
if (!attr)
{
log_error("Cannot find attribute type 0x%lx.\n", (long) AT_DATA);
free(buffer);
ntfs_inode_close(inode);
return -3;
}
if ((inode->mft_no < 2) && (attr->type == AT_DATA))
block_size = ls->vol->mft_record_size;
else if (attr->type == AT_INDEX_ALLOCATION)
block_size = index_get_size(inode);
else
block_size = 0;
#if defined(__CYGWIN__) || defined(__MINGW32__)
if(stream_name)
{
/* fopen() create normal files instead of ADS with ':' replaced by an UTF char
* replace ':' by '_' instead */
stream_name--;
*stream_name='_';
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
}
else
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
#else
f_out=fopen_local(&new_file, dir_data->local_dir, dir_data->current_directory);
#endif
if(!f_out)
{
log_critical("Can't create file %s: %s\n",new_file, strerror(errno));
free(new_file);
ntfs_attr_close(attr);
free(buffer);
ntfs_inode_close(inode);
return -4;
}
offset = 0;
for (;;)
{
s64 bytes_read, written;
if (block_size > 0) {
// These types have fixup
bytes_read = ntfs_attr_mst_pread(attr, offset, 1, block_size, buffer);
bytes_read *= block_size;
} else {
bytes_read = ntfs_attr_pread(attr, offset, bufsize, buffer);
}
//ntfs_log_info("read %lld bytes\n", bytes_read);
if (bytes_read < 0) {
log_error("ERROR: Couldn't read file");
break;
}
if (!bytes_read)
break;
written = fwrite(buffer, 1, bytes_read, f_out);
if (written != bytes_read)
{
log_error("ERROR: Couldn't output all data!");
break;
}
offset += bytes_read;
}
fclose(f_out);
set_date(new_file, file->td_atime, file->td_mtime);
free(new_file);
ntfs_attr_close(attr);
free(buffer);
}
/* Finished with the inode; release it. */
ntfs_inode_close(inode);
return 0;
}
status_t
fs_walk(fs_volume *_vol, fs_vnode *_dir, const char *file, ino_t *vnid)
{
nspace *ns = (nspace*)_vol->private_volume;
vnode *baseNode = (vnode*)_dir->private_node;
vnode *newNode = NULL;
ntfschar *unicode = NULL;
ntfs_inode *bi = NULL;
status_t result = B_NO_ERROR;
int len;
LOCK_VOL(ns);
ERRPRINT("fs_walk - ENTER : find for \"%s\"\n",file);
if (ns == NULL || _dir == NULL || file == NULL || vnid == NULL) {
result = EINVAL;
goto exit;
}
if (!strcmp(file, ".")) {
*vnid = baseNode->vnid;
if (get_vnode(_vol, *vnid, (void**)&newNode) != 0)
result = ENOENT;
} else if (!strcmp(file, "..") && baseNode->vnid != FILE_root) {
*vnid = baseNode->parent_vnid;
if (get_vnode(_vol, *vnid, (void**)&newNode) != 0)
result = ENOENT;
} else {
unicode = ntfs_calloc(MAX_PATH);
len = ntfs_mbstoucs(file, &unicode);
if (len < 0) {
result = EILSEQ;
goto exit;
}
bi = ntfs_inode_open(ns->ntvol, baseNode->vnid);
if (!bi) {
result = ENOENT;
goto exit;
}
*vnid = MREF(ntfs_inode_lookup_by_name(bi, unicode, len));
ERRPRINT("fs_walk - VNID = %d\n",*vnid);
ntfs_inode_close(bi);
free(unicode);
if (*vnid == (u64)-1) {
result = EINVAL;
goto exit;
}
if (get_vnode(_vol, *vnid, (void**)&newNode) != 0)
result = ENOENT;
if (newNode!=NULL)
newNode->parent_vnid = baseNode->vnid;
}
exit:
ERRPRINT("fs_walk - EXIT, result is %s\n", strerror(result));
UNLOCK_VOL(ns);
return result;
}
/**
* 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);
}
/**
* ntfs_mbstoucs - convert a multibyte string to a little endian Unicode string
* @ins: input multibyte string buffer
* @outs: on return contains the (allocated) output Unicode string
* @outs_len: length of output buffer in Unicode characters
*
* Convert the input multibyte string @ins, from the current locale into the
* corresponding little endian, 2-byte Unicode string.
*
* If *@outs is NULL, the function allocates the string and the caller is
* responsible for calling free(*@outs); when finished with it.
*
* On success the function returns the number of Unicode characters written to
* the output string *@outs (>= 0), not counting the terminating Unicode NULL
* character. If the output string buffer was allocated, *@outs is set to it.
*
* On error, -1 is returned, and errno is set to the error code. The following
* error codes can be expected:
* EINVAL Invalid arguments (e.g. @ins or @outs is NULL).
* EILSEQ The input string cannot be represented as a Unicode
* string according to the current locale.
* ENAMETOOLONG Destination buffer is too small for input string.
* ENOMEM Not enough memory to allocate destination buffer.
*/
int ntfs_mbstoucs(const char *ins, ntfschar **outs, int outs_len)
{
ntfschar *ucs;
const char *s;
wchar_t wc;
int i, o, cnt, ins_len, ucs_len, ins_size;
#ifdef HAVE_MBSINIT
mbstate_t mbstate;
#endif
if (!ins || !outs) {
errno = EINVAL;
return -1;
}
ucs = *outs;
ucs_len = outs_len;
if (ucs && !ucs_len) {
errno = ENAMETOOLONG;
return -1;
}
/* Determine the size of the multi-byte string in bytes. */
ins_size = strlen(ins);
/* Determine the length of the multi-byte string. */
s = ins;
#if defined(HAVE_MBSINIT)
memset(&mbstate, 0, sizeof(mbstate));
ins_len = mbsrtowcs(NULL, (const char **)&s, 0, &mbstate);
#ifdef __CYGWIN32__
if (!ins_len && *ins) {
/* Older Cygwin had broken mbsrtowcs() implementation. */
ins_len = strlen(ins);
}
#endif
#elif !defined(DJGPP)
ins_len = mbstowcs(NULL, s, 0);
#else
/* Eeek!!! DJGPP has broken mbstowcs() implementation!!! */
ins_len = strlen(ins);
#endif
if (ins_len == -1)
return ins_len;
#ifdef HAVE_MBSINIT
if ((s != ins) || !mbsinit(&mbstate)) {
#else
if (s != ins) {
#endif
errno = EILSEQ;
return -1;
}
/* Add the NULL terminator. */
ins_len++;
if (!ucs) {
ucs_len = ins_len;
ucs = (ntfschar*)malloc(ucs_len * sizeof(ntfschar));
if (!ucs)
return -1;
}
#ifdef HAVE_MBSINIT
memset(&mbstate, 0, sizeof(mbstate));
#else
mbtowc(NULL, NULL, 0);
#endif
for (i = o = cnt = 0; i < ins_size; i += cnt, o++) {
/* Reallocate memory if necessary or abort. */
if (o >= ucs_len) {
ntfschar *tc;
if (ucs == *outs) {
errno = ENAMETOOLONG;
return -1;
}
/*
* We will never get here but hey, it's only a bit of
* extra code...
*/
ucs_len = (ucs_len * sizeof(ntfschar) + 64) & ~63;
tc = (ntfschar*)realloc(ucs, ucs_len);
if (!tc)
goto err_out;
ucs = tc;
ucs_len /= sizeof(ntfschar);
}
/* Convert the multibyte character to a wide character. */
#ifdef HAVE_MBSINIT
cnt = mbrtowc(&wc, ins + i, ins_size - i, &mbstate);
#else
cnt = mbtowc(&wc, ins + i, ins_size - i);
#endif
if (!cnt)
break;
if (cnt == -1)
goto err_out;
if (cnt < -1) {
ntfs_log_trace("Eeek. cnt = %i\n", cnt);
errno = EINVAL;
goto err_out;
}
/* Make sure we are not overflowing the NTFS Unicode set. */
if ((unsigned long)wc >= (unsigned long)(1 <<
(8 * sizeof(ntfschar)))) {
errno = EILSEQ;
goto err_out;
}
/* Convert the CPU wide character to a LE Unicode character. */
ucs[o] = cpu_to_le16(wc);
}
#ifdef HAVE_MBSINIT
/* Make sure we are back in the initial state. */
if (!mbsinit(&mbstate)) {
ntfs_log_trace("Eeek. mbstate not in initial state!\n");
errno = EILSEQ;
goto err_out;
}
#endif
/* Now write the NULL character. */
ucs[o] = cpu_to_le16(L'\0');
if (*outs != ucs)
*outs = ucs;
return o;
err_out:
if (ucs != *outs) {
int eo = errno;
free(ucs);
errno = eo;
}
return -1;
}
/**
* ntfs_upcase_table_build - build the default upcase table for NTFS
* @uc: destination buffer where to store the built table
* @uc_len: size of destination buffer in bytes
*
* ntfs_upcase_table_build() builds the default upcase table for NTFS and
* stores it in the caller supplied buffer @uc of size @uc_len.
*
* Note, @uc_len must be at least 128kiB in size or bad things will happen!
*/
void ntfs_upcase_table_build(ntfschar *uc, u32 uc_len)
{
static int uc_run_table[][3] = { /* Start, End, Add */
{0x0061, 0x007B, -32}, {0x0451, 0x045D, -80}, {0x1F70, 0x1F72, 74},
{0x00E0, 0x00F7, -32}, {0x045E, 0x0460, -80}, {0x1F72, 0x1F76, 86},
{0x00F8, 0x00FF, -32}, {0x0561, 0x0587, -48}, {0x1F76, 0x1F78, 100},
{0x0256, 0x0258, -205}, {0x1F00, 0x1F08, 8}, {0x1F78, 0x1F7A, 128},
{0x028A, 0x028C, -217}, {0x1F10, 0x1F16, 8}, {0x1F7A, 0x1F7C, 112},
{0x03AC, 0x03AD, -38}, {0x1F20, 0x1F28, 8}, {0x1F7C, 0x1F7E, 126},
{0x03AD, 0x03B0, -37}, {0x1F30, 0x1F38, 8}, {0x1FB0, 0x1FB2, 8},
{0x03B1, 0x03C2, -32}, {0x1F40, 0x1F46, 8}, {0x1FD0, 0x1FD2, 8},
{0x03C2, 0x03C3, -31}, {0x1F51, 0x1F52, 8}, {0x1FE0, 0x1FE2, 8},
{0x03C3, 0x03CC, -32}, {0x1F53, 0x1F54, 8}, {0x1FE5, 0x1FE6, 7},
{0x03CC, 0x03CD, -64}, {0x1F55, 0x1F56, 8}, {0x2170, 0x2180, -16},
{0x03CD, 0x03CF, -63}, {0x1F57, 0x1F58, 8}, {0x24D0, 0x24EA, -26},
{0x0430, 0x0450, -32}, {0x1F60, 0x1F68, 8}, {0xFF41, 0xFF5B, -32},
{0}
};
static int uc_dup_table[][2] = { /* Start, End */
{0x0100, 0x012F}, {0x01A0, 0x01A6}, {0x03E2, 0x03EF}, {0x04CB, 0x04CC},
{0x0132, 0x0137}, {0x01B3, 0x01B7}, {0x0460, 0x0481}, {0x04D0, 0x04EB},
{0x0139, 0x0149}, {0x01CD, 0x01DD}, {0x0490, 0x04BF}, {0x04EE, 0x04F5},
{0x014A, 0x0178}, {0x01DE, 0x01EF}, {0x04BF, 0x04BF}, {0x04F8, 0x04F9},
{0x0179, 0x017E}, {0x01F4, 0x01F5}, {0x04C1, 0x04C4}, {0x1E00, 0x1E95},
{0x018B, 0x018B}, {0x01FA, 0x0218}, {0x04C7, 0x04C8}, {0x1EA0, 0x1EF9},
{0}
};
static int uc_byte_table[][2] = { /* Offset, Value */
{0x00FF, 0x0178}, {0x01AD, 0x01AC}, {0x01F3, 0x01F1}, {0x0269, 0x0196},
{0x0183, 0x0182}, {0x01B0, 0x01AF}, {0x0253, 0x0181}, {0x026F, 0x019C},
{0x0185, 0x0184}, {0x01B9, 0x01B8}, {0x0254, 0x0186}, {0x0272, 0x019D},
{0x0188, 0x0187}, {0x01BD, 0x01BC}, {0x0259, 0x018F}, {0x0275, 0x019F},
{0x018C, 0x018B}, {0x01C6, 0x01C4}, {0x025B, 0x0190}, {0x0283, 0x01A9},
{0x0192, 0x0191}, {0x01C9, 0x01C7}, {0x0260, 0x0193}, {0x0288, 0x01AE},
{0x0199, 0x0198}, {0x01CC, 0x01CA}, {0x0263, 0x0194}, {0x0292, 0x01B7},
{0x01A8, 0x01A7}, {0x01DD, 0x018E}, {0x0268, 0x0197},
{0}
};
int i, r;
memset((char*)uc, 0, uc_len);
uc_len >>= 1;
if (uc_len > 65536)
uc_len = 65536;
for (i = 0; (u32)i < uc_len; i++)
uc[i] = i;
for (r = 0; uc_run_table[r][0]; r++)
for (i = uc_run_table[r][0]; i < uc_run_table[r][1]; i++)
uc[i] += uc_run_table[r][2];
for (r = 0; uc_dup_table[r][0]; r++)
for (i = uc_dup_table[r][0]; i < uc_dup_table[r][1]; i += 2)
uc[i + 1]--;
for (r = 0; uc_byte_table[r][0]; r++)
uc[uc_byte_table[r][0]] = uc_byte_table[r][1];
}
/**
* ntfs_str2ucs - convert a string to a valid NTFS file name
* @s: input string
* @len: length of output buffer in Unicode characters
*
* Convert the input @s string into the corresponding little endian,
* 2-byte Unicode string. The length of the converted string is less
* or equal to the maximum length allowed by the NTFS format (255).
*
* If @s is NULL then return AT_UNNAMED.
*
* On success the function returns the Unicode string in an allocated
* buffer and the caller is responsible to free it when it's not needed
* anymore.
*
* On error NULL is returned and errno is set to the error code.
*/
ntfschar *ntfs_str2ucs(const char *s, int *len)
{
ntfschar *ucs = NULL;
if (s && ((*len = ntfs_mbstoucs(s, &ucs, 0)) == -1)) {
ntfs_log_perror("Couldn't convert '%s' to Unicode", s);
return NULL;
}
if (*len > 0xff) {
free(ucs);
errno = ENAMETOOLONG;
return NULL;
}
if (!ucs || !*len) {
ucs = AT_UNNAMED;
*len = 0;
}
return ucs;
}
/**
* change_label - change the current label on a device
* @dev: device to change the label on
* @mnt_flags: mount flags of the device or 0 if not mounted
* @mnt_point: mount point of the device or NULL
* @label: the new label
*
* Change the label on the device @dev to @label.
*/
static int change_label(ntfs_volume *vol, unsigned long mnt_flags, char *label, BOOL force)
{
ntfs_attr_search_ctx *ctx;
ntfschar *new_label = NULL;
ATTR_RECORD *a;
int label_len;
int result = 0;
//XXX significant?
if (mnt_flags & NTFS_MF_MOUNTED) {
/* If not the root fs or mounted read/write, refuse change. */
if (!(mnt_flags & NTFS_MF_ISROOT) ||
!(mnt_flags & NTFS_MF_READONLY)) {
if (!force) {
ntfs_log_error("Refusing to change label on "
"read-%s mounted device %s.\n",
mnt_flags & NTFS_MF_READONLY ?
"only" : "write", opts.device);
return 1;
}
}
}
ctx = ntfs_attr_get_search_ctx(vol->vol_ni, NULL);
if (!ctx) {
ntfs_log_perror("Failed to get attribute search context");
goto err_out;
}
if (ntfs_attr_lookup(AT_VOLUME_NAME, AT_UNNAMED, 0, 0, 0, NULL, 0,
ctx)) {
if (errno != ENOENT) {
ntfs_log_perror("Lookup of $VOLUME_NAME attribute failed");
goto err_out;
}
/* The volume name attribute does not exist. Need to add it. */
a = NULL;
} else {
a = ctx->attr;
if (a->non_resident) {
ntfs_log_error("Error: Attribute $VOLUME_NAME must be "
"resident.\n");
goto err_out;
}
}
label_len = ntfs_mbstoucs(label, &new_label, 0);
if (label_len == -1) {
ntfs_log_perror("Unable to convert label string to Unicode");
goto err_out;
}
label_len *= sizeof(ntfschar);
if (label_len > 0x100) {
ntfs_log_error("New label is too long. Maximum %u characters "
"allowed. Truncating excess characters.\n",
(unsigned)(0x100 / sizeof(ntfschar)));
label_len = 0x100;
new_label[label_len / sizeof(ntfschar)] = 0;
}
if (a) {
if (resize_resident_attribute_value(ctx->mrec, a, label_len)) {
ntfs_log_perror("Error resizing resident attribute");
goto err_out;
}
} else {
/* sizeof(resident attribute record header) == 24 */
int asize = (24 + label_len + 7) & ~7;
u32 biu = le32_to_cpu(ctx->mrec->bytes_in_use);
if (biu + asize > le32_to_cpu(ctx->mrec->bytes_allocated)) {
errno = ENOSPC;
ntfs_log_perror("Error adding resident attribute");
goto err_out;
}
a = ctx->attr;
memmove((u8*)a + asize, a, biu - ((u8*)a - (u8*)ctx->mrec));
ctx->mrec->bytes_in_use = cpu_to_le32(biu + asize);
a->type = AT_VOLUME_NAME;
a->length = cpu_to_le32(asize);
a->non_resident = 0;
a->name_length = 0;
a->name_offset = cpu_to_le16(24);
a->flags = cpu_to_le16(0);
a->instance = ctx->mrec->next_attr_instance;
ctx->mrec->next_attr_instance = cpu_to_le16((le16_to_cpu(
ctx->mrec->next_attr_instance) + 1) & 0xffff);
a->u.res.value_length = cpu_to_le32(label_len);
a->u.res.value_offset = a->name_offset;
a->u.res.resident_flags = 0;
a->u.res.reservedR = 0;
}
memcpy((u8*)a + le16_to_cpu(a->u.res.value_offset), new_label, label_len);
if (!opts.noaction && ntfs_inode_sync(vol->vol_ni)) {
ntfs_log_perror("Error writing MFT Record to disk");
goto err_out;
}
result = 0;
err_out:
free(new_label);
return result;
}
int ntfs_change_label(ntfs_volume *vol, char *label)
{
ntfs_attr_search_ctx *ctx;
ntfschar *new_label = NULL;
ATTR_RECORD *a;
int label_len;
int result = 0;
ctx = ntfs_attr_get_search_ctx(vol->vol_ni, NULL);
if (!ctx) {
ntfs_log_perror("Failed to get attribute search context");
goto err_out;
}
if (ntfs_attr_lookup(AT_VOLUME_NAME, AT_UNNAMED, 0, 0, 0, NULL, 0,
ctx)) {
if (errno != ENOENT) {
ntfs_log_perror("Lookup of $VOLUME_NAME attribute failed");
goto err_out;
}
/* The volume name attribute does not exist. Need to add it. */
a = NULL;
} else {
a = ctx->attr;
if (a->non_resident) {
ntfs_log_error("Error: Attribute $VOLUME_NAME must be "
"resident.\n");
goto err_out;
}
}
label_len = ntfs_mbstoucs(label, &new_label);
if (label_len == -1) {
ntfs_log_perror("Unable to convert label string to Unicode");
goto err_out;
}
label_len *= sizeof(ntfschar);
if (label_len > 0x100) {
ntfs_log_error("New label is too long. Maximum %u characters "
"allowed. Truncating excess characters.\n",
(unsigned)(0x100 / sizeof(ntfschar)));
label_len = 0x100;
new_label[label_len / sizeof(ntfschar)] = cpu_to_le16(L'\0');
}
if (a) {
if (resize_resident_attribute_value(ctx->mrec, a, label_len)) {
ntfs_log_perror("Error resizing resident attribute");
goto err_out;
}
} else {
/* sizeof(resident attribute record header) == 24 */
int asize = (24 + label_len + 7) & ~7;
u32 biu = le32_to_cpu(ctx->mrec->bytes_in_use);
if (biu + asize > le32_to_cpu(ctx->mrec->bytes_allocated)) {
errno = ENOSPC;
ntfs_log_perror("Error adding resident attribute");
goto err_out;
}
a = ctx->attr;
memmove((u8*)a + asize, a, biu - ((u8*)a - (u8*)ctx->mrec));
ctx->mrec->bytes_in_use = cpu_to_le32(biu + asize);
a->type = AT_VOLUME_NAME;
a->length = cpu_to_le32(asize);
a->non_resident = 0;
a->name_length = 0;
a->name_offset = cpu_to_le16(24);
a->flags = cpu_to_le16(0);
a->instance = ctx->mrec->next_attr_instance;
ctx->mrec->next_attr_instance = cpu_to_le16((le16_to_cpu(
ctx->mrec->next_attr_instance) + 1) & 0xffff);
a->value_length = cpu_to_le32(label_len);
a->value_offset = a->name_offset;
a->resident_flags = 0;
a->reservedR = 0;
}
memcpy((u8*)a + le16_to_cpu(a->value_offset), new_label, label_len);
if (ntfs_inode_sync(vol->vol_ni)) {
ntfs_log_perror("Error writing MFT Record to disk");
goto err_out;
}
result = 0;
err_out:
ntfs_attr_put_search_ctx(ctx);
free(new_label);
return result;
}
