#include "wimlib/reparse.h"
#include "wimlib/security.h"
+/* NTFS-3g 2013 renamed MS_RDONLY to NTFS_MNT_RDONLY. We can't check for the
+ * existence of NTFS_MNT_RDONLY at compilation time because it's an enum. We
+ * also can't check for MS_RDONLY being missing because it's also a system
+ * constant. So check if the NTFS-3g specific MS_IGNORE_HIBERFILE is defined;
+ * if yes, then we need to use the old MS_RDONLY. */
+#ifdef MS_IGNORE_HIBERFILE
+# define NTFS_MNT_RDONLY MS_RDONLY
+#endif
+
/* A reference-counted NTFS volume than is automatically unmounted when the
* reference count reaches 0 */
struct ntfs_volume_wrapper {
u64 mft_no;
ATTR_TYPES attr_type;
u32 attr_name_nchars;
- utf16lechar *attr_name;
+ ntfschar *attr_name;
u64 sort_key;
};
free_ntfs_location(struct ntfs_location *loc)
{
put_ntfs_volume(loc->volume);
- FREE(loc->attr_name);
+ if (loc->attr_name != AT_UNNAMED)
+ FREE(loc->attr_name);
FREE(loc);
}
struct ntfs_location *new = memdup(loc, sizeof(*loc));
if (!new)
goto err0;
- if (loc->attr_name) {
+ if (loc->attr_name != AT_UNNAMED) {
new->attr_name = utf16le_dup(loc->attr_name);
if (!new->attr_name)
goto err1;
return cmp_u64(loc1->sort_key, loc2->sort_key);
}
+/* Read rptag and rpreserved from the NTFS inode and save them in the WIM inode.
+ */
static int
-read_reparse_tag(ntfs_inode *ni, struct ntfs_location *loc,
- u32 *reparse_tag_ret)
+read_reparse_header(ntfs_inode *ni, struct wim_inode *inode)
{
- int ret;
- le32 reparse_tag;
+ struct {
+ le32 rptag;
+ le16 rpdatalen;
+ le16 rpreserved;
+ } hdr;
+ s64 res;
ntfs_attr *na;
- na = open_ntfs_attr(ni, loc);
- if (!na) {
- ret = WIMLIB_ERR_NTFS_3G;
- goto out;
- }
+ na = ntfs_attr_open(ni, AT_REPARSE_POINT, AT_UNNAMED, 0);
+ if (!na)
+ return WIMLIB_ERR_NTFS_3G;
+
+ res = ntfs_attr_pread(na, 0, sizeof(hdr), &hdr);
- if (ntfs_attr_pread(na, 0, sizeof(reparse_tag),
- &reparse_tag) != sizeof(reparse_tag))
- {
- ERROR_WITH_ERRNO("Error reading reparse data");
- ret = WIMLIB_ERR_NTFS_3G;
- goto out_close_ntfs_attr;
- }
- *reparse_tag_ret = le32_to_cpu(reparse_tag);
- ret = 0;
-out_close_ntfs_attr:
ntfs_attr_close(na);
-out:
- return ret;
+ if (res != sizeof(hdr))
+ return WIMLIB_ERR_NTFS_3G;
+
+ inode->i_reparse_tag = le32_to_cpu(hdr.rptag);
+ inode->i_rp_reserved = le16_to_cpu(hdr.rpreserved);
+ return 0;
}
static int
return 0;
}
+/*
+ * Add a new stream to the specified inode, with duplicate checking.
+ *
+ * This works around a problem where NTFS-3g can list multiple unnamed data
+ * streams for a single file. In this case we can only keep one. We'll prefer
+ * one that is nonempty.
+ */
+static int
+add_stream(struct wim_inode *inode, const char *path, int stream_type,
+ const utf16lechar *stream_name, struct blob_descriptor **blob_p,
+ struct list_head *unhashed_blobs)
+{
+ struct blob_descriptor *blob = *blob_p;
+ struct wim_inode_stream *strm;
+
+ strm = inode_get_stream(inode, stream_type, stream_name);
+ if (unlikely(strm)) {
+ /* Stream already existed. */
+ if (!blob)
+ return 0;
+ if (stream_blob_resolved(strm)) {
+ WARNING("\"%s\" has multiple nonempty streams "
+ "with the same type and name! Only the first "
+ "will be saved.", path);
+ return 0;
+ }
+ inode_replace_stream_blob(inode, strm, blob, NULL);
+ } else {
+ strm = inode_add_stream(inode, stream_type, stream_name, blob);
+ if (unlikely(!strm))
+ return WIMLIB_ERR_NOMEM;
+ }
+ prepare_unhashed_blob(blob, inode, strm->stream_id, unhashed_blobs);
+ *blob_p = NULL;
+ return 0;
+
+}
+
/* Save information about an NTFS attribute (stream) to a WIM inode. */
static int
scan_ntfs_attr(struct wim_inode *inode,
ntfs_inode *ni,
const char *path,
- size_t path_len,
struct list_head *unhashed_blobs,
struct ntfs_volume_wrapper *volume,
ATTR_TYPES type,
const ATTR_RECORD *record)
{
- const u64 data_size = ntfs_get_attribute_value_length(record);
+ u64 data_size = ntfs_get_attribute_value_length(record);
const u32 name_nchars = record->name_length;
struct blob_descriptor *blob = NULL;
- utf16lechar *stream_name = NULL;
- struct wim_inode_stream *strm;
+ utf16lechar *stream_name = (utf16lechar *)NO_STREAM_NAME;
int ret;
if (unlikely(name_nchars)) {
}
}
+ if (unlikely(type == AT_REPARSE_POINT)) {
+ if (data_size < REPARSE_DATA_OFFSET) {
+ ERROR("Reparse point attribute of \"%s\" "
+ "is too short!", path);
+ ret = WIMLIB_ERR_INVALID_REPARSE_DATA;
+ goto out_cleanup;
+ }
+ data_size -= REPARSE_DATA_OFFSET;
+
+ ret = read_reparse_header(ni, inode);
+ if (ret) {
+ ERROR_WITH_ERRNO("Error reading reparse point header "
+ "of \"%s\"", path);
+ goto out_cleanup;
+ }
+ }
+
/* If the stream is non-empty, set up a blob descriptor for it. */
if (data_size != 0) {
blob = new_blob_descriptor();
goto out_cleanup;
}
- blob->ntfs_loc = CALLOC(1, sizeof(struct ntfs_location));
+ blob->ntfs_loc = MALLOC(sizeof(struct ntfs_location));
if (unlikely(!blob->ntfs_loc)) {
ret = WIMLIB_ERR_NOMEM;
goto out_cleanup;
blob->blob_location = BLOB_IN_NTFS_VOLUME;
blob->size = data_size;
blob->ntfs_loc->volume = get_ntfs_volume(volume);
- blob->ntfs_loc->attr_type = type;
blob->ntfs_loc->mft_no = ni->mft_no;
+ blob->ntfs_loc->attr_type = type;
if (unlikely(name_nchars)) {
+ blob->ntfs_loc->attr_name_nchars = name_nchars;
blob->ntfs_loc->attr_name = utf16le_dup(stream_name);
if (!blob->ntfs_loc->attr_name) {
ret = WIMLIB_ERR_NOMEM;
goto out_cleanup;
}
- blob->ntfs_loc->attr_name_nchars = name_nchars;
+ } else {
+ blob->ntfs_loc->attr_name_nchars = 0;
+ blob->ntfs_loc->attr_name = AT_UNNAMED;
}
ret = set_attr_sort_key(ni, blob->ntfs_loc);
if (ret)
goto out_cleanup;
-
- if (unlikely(type == AT_REPARSE_POINT)) {
- if (blob->size < REPARSE_DATA_OFFSET) {
- ERROR("Reparse data of \"%s\" "
- "is invalid (only %"PRIu64" bytes)!",
- path, data_size);
- ret = WIMLIB_ERR_INVALID_REPARSE_DATA;
- goto out_cleanup;
- }
- blob->size -= REPARSE_DATA_OFFSET;
- ret = read_reparse_tag(ni, blob->ntfs_loc,
- &inode->i_reparse_tag);
- if (ret)
- goto out_cleanup;
- }
}
- strm = inode_add_stream(inode,
- attr_type_to_wimlib_stream_type(type),
- stream_name ? stream_name : NO_STREAM_NAME,
- blob);
- if (unlikely(!strm)) {
- ret = WIMLIB_ERR_NOMEM;
- goto out_cleanup;
- }
- prepare_unhashed_blob(blob, inode, strm->stream_id, unhashed_blobs);
- blob = NULL;
- ret = 0;
+ ret = add_stream(inode, path, attr_type_to_wimlib_stream_type(type),
+ stream_name, &blob, unhashed_blobs);
out_cleanup:
free_blob_descriptor(blob);
- FREE(stream_name);
+ if (stream_name != NO_STREAM_NAME)
+ FREE(stream_name);
return ret;
}
scan_ntfs_attrs_with_type(struct wim_inode *inode,
ntfs_inode *ni,
const char *path,
- size_t path_len,
struct list_head *unhashed_blobs,
struct ntfs_volume_wrapper *volume,
ATTR_TYPES type)
ret = scan_ntfs_attr(inode,
ni,
path,
- path_len,
unhashed_blobs,
volume,
type,
{
const struct dos_name_node *node;
- if (dentry->is_win32_name) {
+ if (dentry->d_is_win32_name) {
node = lookup_dos_name(map, dentry->d_inode->i_ino);
if (node) {
dentry->d_short_name = utf16le_dupz(node->dos_name,
goto out;
}
- /* Ignore . and .. entries */
- ret = 0;
- if ((name_nchars == 1 && name[0] == cpu_to_le16('.')) ||
- (name_nchars == 2 && name[0] == cpu_to_le16('.') &&
- name[1] == cpu_to_le16('.')))
- goto out;
-
ret = utf16le_to_tstr(name, name_nbytes, &mbs_name, &mbs_name_nbytes);
if (ret)
goto out;
+ if (should_ignore_filename(mbs_name, mbs_name_nbytes))
+ goto out_free_mbs_name;
+
path_len = ctx->path_len;
if (path_len != 1)
ctx->path[path_len++] = '/';
ret = ntfs_3g_build_dentry_tree_recursive(&child, mref, ctx->path,
path_len, name_type,
ctx->volume, ctx->params);
- if (child)
- dentry_add_child(ctx->parent, child);
+ attach_scanned_tree(ctx->parent, child, ctx->params->blob_table);
+out_free_mbs_name:
FREE(mbs_name);
out:
ctx->ret = ret;
struct wim_inode *inode = NULL;
ntfs_inode *ni = NULL;
- ret = try_exclude(path, path_len, params);
- if (ret < 0) /* Excluded? */
+ ret = try_exclude(path, params);
+ if (unlikely(ret < 0)) /* Excluded? */
goto out_progress;
- if (ret > 0) /* Error? */
+ if (unlikely(ret > 0)) /* Error? */
goto out;
ni = ntfs_inode_open(volume->vol, mref);
goto out;
if (name_type & FILE_NAME_WIN32) /* Win32 or Win32+DOS name (rather than POSIX) */
- root->is_win32_name = 1;
+ root->d_is_win32_name = 1;
inode = root->d_inode;
if (attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
/* Scan the reparse point stream. */
- ret = scan_ntfs_attrs_with_type(inode, ni, path, path_len,
+ ret = scan_ntfs_attrs_with_type(inode, ni, path,
params->unhashed_blobs,
volume, AT_REPARSE_POINT);
if (ret)
* may have named data streams. Nondirectories (including reparse
* points) can have an unnamed data stream as well as named data
* streams. */
- ret = scan_ntfs_attrs_with_type(inode, ni, path, path_len,
- params->unhashed_blobs,
+ ret = scan_ntfs_attrs_with_type(inode, ni, path, params->unhashed_blobs,
volume, AT_DATA);
if (ret)
goto out;
if (!volume)
return WIMLIB_ERR_NOMEM;
- /* NTFS-3g 2013 renamed the "read-only" mount flag from MS_RDONLY to
- * NTFS_MNT_RDONLY.
- *
- * Unfortunately we can't check for defined(NTFS_MNT_RDONLY) because
- * NTFS_MNT_RDONLY is an enumerated constant. Also, the NTFS-3g headers
- * don't seem to contain any explicit version information. So we have
- * to rely on a test done at configure time to detect whether
- * NTFS_MNT_RDONLY should be used. */
-#ifdef HAVE_NTFS_MNT_RDONLY
- /* NTFS-3g 2013 */
vol = ntfs_mount(device, NTFS_MNT_RDONLY);
-#elif defined(MS_RDONLY)
- /* NTFS-3g 2011, 2012 */
- vol = ntfs_mount(device, MS_RDONLY);
-#else
- #error "Can't find NTFS_MNT_RDONLY or MS_RDONLY flags"
-#endif
if (!vol) {
ERROR_WITH_ERRNO("Failed to mount NTFS volume \"%s\" read-only",
device);
git://wimlib.net / wimlib / blobdiff