Use STACK_MAX

[wimlib] / src / ntfs-3g_capture.c

diff --git a/src/ntfs-3g_capture.c b/src/ntfs-3g_capture.c
index 27c446a05b3a787c6c51ac2314fdef5cb93f5b61..6daf0a54720afaa2a31bb1a75bfbc4546c213d1f 100644 (file)
--- a/src/ntfs-3g_capture.c
+++ b/src/ntfs-3g_capture.c
@@ -78,6 +78,7 @@ int
 read_ntfs_file_prefix(const struct wim_lookup_table_entry *lte,
                      u64 size,
                      consume_data_callback_t cb,
+                     u32 in_chunk_size,
                      void *ctx_or_buf,
                      int _ignored_flags)
 {
@@ -88,6 +89,7 @@ read_ntfs_file_prefix(const struct wim_lookup_table_entry *lte,
        s64 pos;
        s64 bytes_remaining;
        void *out_buf;
+       bool out_buf_malloced;
        int ret;
 
        ni = ntfs_pathname_to_inode(vol, NULL, loc->path);
@@ -103,30 +105,44 @@ read_ntfs_file_prefix(const struct wim_lookup_table_entry *lte,
                goto out_close_ntfs_inode;
        }
 
-       if (cb)
-               out_buf = alloca(WIM_CHUNK_SIZE);
-       else
+       out_buf_malloced = false;
+       if (cb) {
+               if (in_chunk_size <= STACK_MAX) {
+                       out_buf = alloca(in_chunk_size);
+               } else {
+                       out_buf = MALLOC(in_chunk_size);
+                       if (out_buf == NULL) {
+                               ret = WIMLIB_ERR_NOMEM;
+                               goto out_close_ntfs_attr;
+                       }
+                       out_buf_malloced = true;
+               }
+       } else {
                out_buf = ctx_or_buf;
+       }
        pos = (loc->is_reparse_point) ? 8 : 0;
        bytes_remaining = size;
        while (bytes_remaining) {
-               s64 to_read = min(bytes_remaining, WIM_CHUNK_SIZE);
+               s64 to_read = min(bytes_remaining, in_chunk_size);
                if (ntfs_attr_pread(na, pos, to_read, out_buf) != to_read) {
                        ERROR_WITH_ERRNO("Error reading \"%"TS"\"", loc->path);
                        ret = WIMLIB_ERR_NTFS_3G;
-                       goto out_close_ntfs_attr;
+                       goto out_free_memory;
                }
                pos += to_read;
                bytes_remaining -= to_read;
                if (cb) {
                        ret = cb(out_buf, to_read, ctx_or_buf);
                        if (ret)
-                               goto out_close_ntfs_attr;
+                               goto out_free_memory;
                } else {
                        out_buf += to_read;
                }
        }
        ret = 0;
+out_free_memory:
+       if (out_buf_malloced)
+               FREE(out_buf);
 out_close_ntfs_attr:
        ntfs_attr_close(na);
 out_close_ntfs_inode:
@@ -545,22 +561,16 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 {
        le32 attributes;
        int ret;
-       struct wim_dentry *root;
+       struct wim_dentry *root = NULL;
        struct wim_inode *inode;
        ATTR_TYPES stream_type;
 
+       params->progress.scan.cur_path = path;
+
        if (exclude_path(path, path_len, params->config, false)) {
                /* Exclude a file or directory tree based on the capture
                 * configuration file */
-               if ((params->add_flags & WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE)
-                   && params->progress_func)
-               {
-                       union wimlib_progress_info info;
-                       info.scan.cur_path = path;
-                       info.scan.status = WIMLIB_SCAN_DENTRY_EXCLUDED;
-                       params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
-               }
-               root = NULL;
+               do_capture_progress(params, WIMLIB_SCAN_DENTRY_EXCLUDED);
                ret = 0;
                goto out;
        }
@@ -569,48 +579,43 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
        ret = ntfs_get_ntfs_attrib(ni, (char*)&attributes, sizeof(attributes));
        if (ret != sizeof(attributes)) {
                ERROR_WITH_ERRNO("Failed to get NTFS attributes from \"%s\"", path);
-               return WIMLIB_ERR_NTFS_3G;
+               ret = WIMLIB_ERR_NTFS_3G;
+               goto out;
        }
 
        if ((attributes & (FILE_ATTRIBUTE_DIRECTORY |
                           FILE_ATTRIBUTE_ENCRYPTED)) == FILE_ATTRIBUTE_ENCRYPTED)
        {
-               if ((params->add_flags & WIMLIB_ADD_FLAG_EXCLUDE_VERBOSE)
-                   && params->progress_func)
+               if (params->add_flags & WIMLIB_ADD_FLAG_NO_UNSUPPORTED_EXCLUDE)
                {
-                       union wimlib_progress_info info;
-                       info.scan.cur_path = path;
-                       info.scan.status = WIMLIB_SCAN_DENTRY_UNSUPPORTED;
-                       params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
+                       ERROR("Can't archive unsupported encrypted file \"%s\"", path);
+                       ret = WIMLIB_ERR_UNSUPPORTED_FILE;
+                       goto out;
                }
-               root = NULL;
+               do_capture_progress(params, WIMLIB_SCAN_DENTRY_UNSUPPORTED);
                ret = 0;
                goto out;
        }
 
-       if ((params->add_flags & WIMLIB_ADD_FLAG_VERBOSE)
-           && params->progress_func)
-       {
-               union wimlib_progress_info info;
-               info.scan.cur_path = path;
-               info.scan.status = WIMLIB_SCAN_DENTRY_OK;
-               params->progress_func(WIMLIB_PROGRESS_MSG_SCAN_DENTRY, &info);
-       }
+       do_capture_progress(params, WIMLIB_SCAN_DENTRY_OK);
 
        /* Create a WIM dentry with an associated inode, which may be shared */
        ret = inode_table_new_dentry(&params->inode_table,
                                     path_basename_with_len(path, path_len),
                                     ni->mft_no, 0, false, &root);
        if (ret)
-               return ret;
+               goto out;
 
        if (name_type & FILE_NAME_WIN32) /* Win32 or Win32+DOS name (rather than POSIX) */
                root->is_win32_name = 1;
 
        inode = root->d_inode;
 
-       if (inode->i_nlink > 1) /* Shared inode; nothing more to do */
+       if (inode->i_nlink > 1) {
+               /* Shared inode; nothing more to do */
+               ret = 0;
                goto out;
+       }
 
        inode->i_creation_time    = le64_to_cpu(ni->creation_time);
        inode->i_last_write_time  = le64_to_cpu(ni->last_data_change_time);
@@ -669,7 +674,7 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
 
        if (!(params->add_flags & WIMLIB_ADD_FLAG_NO_ACLS)) {
                struct SECURITY_CONTEXT sec_ctx;
-               char _sd[1];
+               char _sd[4096];
                char *sd;
 
                /* Get security descriptor */
@@ -677,7 +682,8 @@ build_dentry_tree_ntfs_recursive(struct wim_dentry **root_ret,
                sec_ctx.vol = vol;
 
                errno = 0;
-               ret = ntfs_get_ntfs_acl(&sec_ctx, ni, _sd, sizeof(_sd));
+               sd = _sd;
+               ret = ntfs_get_ntfs_acl(&sec_ctx, ni, sd, sizeof(_sd));
                if (ret > sizeof(_sd)) {
                        sd = alloca(ret);
                        ret = ntfs_get_ntfs_acl(&sec_ctx, ni, sd, ret);