Fix sparse tests windows

diff --git a/libarchive/archive_read_disk_windows.c b/libarchive/archive_read_disk_windows.c
index 8fe3485240434ee9a15bd2cb1455a68f9183175d..d82048de29950f7bf25469f8bbfbb1723d7fb631 100644 (file)
--- a/libarchive/archive_read_disk_windows.c
+++ b/libarchive/archive_read_disk_windows.c
@@ -117,7 +117,7 @@ struct filesystem {
  */
 
 #define MAX_OVERLAPPED 8
-#define BUFFER_SIZE    (1024 * 8)
+#define READ_BUFFER_SIZE       (1024 * 64) /* Default to 64KB per https://technet.microsoft.com/en-us/library/cc938632.aspx */
 #define DIRECT_IO      0/* Disabled */
 #define ASYNC_IO       1/* Enabled */
 
@@ -567,7 +567,7 @@ start_next_async_read(struct archive_read_disk *a, struct tree *t)
        /* Allocate read buffer. */
        if (olp->buff == NULL) {
                void *p;
-               size_t s = (size_t)align_num_per_sector(t, BUFFER_SIZE);
+               size_t s = (size_t)align_num_per_sector(t, READ_BUFFER_SIZE);
                p = VirtualAlloc(NULL, s, MEM_COMMIT, PAGE_READWRITE);
                if (p == NULL) {
                        archive_set_error(&a->archive, ENOMEM,
@@ -683,7 +683,7 @@ _archive_read_data_block(struct archive *_a, const void **buff,
                                break;
                } while (r == ARCHIVE_OK && t->ol_num_doing < MAX_OVERLAPPED);
        } else {
-               if (start_next_async_read(a, t) == ARCHIVE_FATAL)
+               if ((r = start_next_async_read(a, t)) == ARCHIVE_FATAL)
                        goto abort_read_data;
        }
 
@@ -2276,10 +2276,10 @@ setup_sparse_from_disk(struct archive_read_disk *a,
                                if (range.Length.QuadPart > 0)
                                        continue;
                        } else {
-                               /* The remaining data is hole. */
+                               /* The entire file is a hole. Add one data block of size 0 at the end. */
                                archive_entry_sparse_add_entry(entry,
-                                   range.FileOffset.QuadPart,
-                                   range.Length.QuadPart);
+                                   entry_size,
+                                   0);
                        }
                        break;
                } else {

diff --git a/libarchive/test/test_sparse_basic.c b/libarchive/test/test_sparse_basic.c
index 9d45f0fedc1c16425811a8296dbeb19f23690e3e..f9eac4920813cb0315b5ce7727ae4c6f36557358 100644 (file)
--- a/libarchive/test/test_sparse_basic.c
+++ b/libarchive/test/test_sparse_basic.c
@@ -118,13 +118,26 @@ create_sparse_file(const char *path, const struct sparse *s)
        assert(handle != INVALID_HANDLE_VALUE);
        assert(DeviceIoControl(handle, FSCTL_SET_SPARSE, NULL, 0,
            NULL, 0, &dmy, NULL) != 0);
+
+       unsigned int offsetSoFar = 0;
+
        while (s->type != END) {
                if (s->type == HOLE) {
-                       LARGE_INTEGER distance;
-
-                       distance.QuadPart = s->size;
-                       assert(SetFilePointerEx(handle, distance,
-                           NULL, FILE_CURRENT) != 0);
+                       LARGE_INTEGER fileOffset, beyondOffset, distanceToMove;
+                       fileOffset.QuadPart = offsetSoFar;
+                       beyondOffset.QuadPart = offsetSoFar + s->size;
+                       distanceToMove.QuadPart = s->size;
+
+                       FILE_ZERO_DATA_INFORMATION zeroInformation;
+                       zeroInformation.FileOffset = fileOffset;
+                       zeroInformation.BeyondFinalZero = beyondOffset;
+
+                       DWORD bytesReturned;
+                       assert(SetFilePointerEx(handle, distanceToMove,
+                               NULL, FILE_CURRENT) != 0);
+                       assert(SetEndOfFile(handle) != 0);
+                       assert(DeviceIoControl(handle, FSCTL_SET_ZERO_DATA, &zeroInformation,
+                               sizeof(FILE_ZERO_DATA_INFORMATION), NULL, 0, &bytesReturned, NULL) != 0);
                } else {
                        DWORD w, wr;
                        size_t size;
@@ -139,6 +152,7 @@ create_sparse_file(const char *path, const struct sparse *s)
                                size -= wr;
                        }
                }
+               offsetSoFar += s->size;
                s++;
        }
        assertEqualInt(CloseHandle(handle), 1);
@@ -484,10 +498,15 @@ DEFINE_TEST(test_sparse_basic)
         * on all platform.
         */
        const struct sparse sparse_file0[] = {
+               // 0             // 1024
                { DATA,  1024 }, { HOLE,   2048000 },
+               // 2049024       // 2051072
                { DATA,  2048 }, { HOLE,   2048000 },
+               // 4099072       // 4103168
                { DATA,  4096 }, { HOLE,  20480000 },
+               // 24583168      // 24591360
                { DATA,  8192 }, { HOLE, 204800000 },
+               // 229391360     // 229391361
                { DATA,     1 }, { END, 0 }
        };
        const struct sparse sparse_file1[] = {