X-Git-Url: https://wimlib.net/git/?a=blobdiff_plain;f=src%2Fresource.c;h=8c88129626795b3a3a2c0e76f17c6a66b56cfd1a;hb=ca8727cf22a445adc20eb1f8b7a12b8eededc32d;hp=7a5d1718a631cae9b24c194b531850bacf7de8cb;hpb=062465170ddb4520ca6fbc64a0f6e27e786de101;p=wimlib diff --git a/src/resource.c b/src/resource.c index 7a5d1718..8c881296 100644 --- a/src/resource.c +++ b/src/resource.c @@ -38,6 +38,10 @@ #include #include +#ifdef HAVE_ALLOCA_H +# include +#endif + /* Write @n bytes from @buf to the file descriptor @fd, retrying on internupt * and on short writes. * @@ -90,10 +94,13 @@ full_read(int fd, void *buf, size_t n) * Returns zero on success, nonzero on failure. */ static int -read_compressed_resource(FILE *fp, u64 resource_compressed_size, +read_compressed_resource(FILE *fp, + u64 resource_compressed_size, u64 resource_uncompressed_size, - u64 resource_offset, int resource_ctype, - u64 len, u64 offset, + u64 resource_offset, + int resource_ctype, + u64 len, + u64 offset, consume_data_callback_t cb, void *ctx_or_buf) { @@ -122,7 +129,8 @@ read_compressed_resource(FILE *fp, u64 resource_compressed_size, * follows the chunk table and therefore must have an offset of 0. */ - /* Calculate how many chunks the resource conists of in its entirety. */ + /* Calculate how many chunks the resource consists of in its entirety. + * */ u64 num_chunks = (resource_uncompressed_size + WIM_CHUNK_SIZE - 1) / WIM_CHUNK_SIZE; /* As mentioned, the first chunk has no entry in the chunk table. */ @@ -149,9 +157,22 @@ read_compressed_resource(FILE *fp, u64 resource_compressed_size, if (end_chunk != num_chunks - 1) num_needed_chunks++; - /* Declare the chunk table. It will only contain offsets for the chunks - * that are actually needed for this read. */ - u64 chunk_offsets[num_needed_chunks]; + /* Allocate the chunk table. It will only contain offsets for the + * chunks that are actually needed for this read. */ + u64 *chunk_offsets; + bool chunk_offsets_malloced; + if (num_needed_chunks < 1000) { + chunk_offsets = alloca(num_needed_chunks * sizeof(u64)); + chunk_offsets_malloced = false; + } else { + chunk_offsets = malloc(num_needed_chunks * sizeof(u64)); + if (!chunk_offsets) { + ERROR("Failed to allocate chunk table " + "with %"PRIu64" entries", num_needed_chunks); + return WIMLIB_ERR_NOMEM; + } + chunk_offsets_malloced = true; + } /* Set the implicit offset of the first chunk if it is included in the * needed chunks. @@ -193,28 +214,28 @@ read_compressed_resource(FILE *fp, u64 resource_compressed_size, /* Number of bytes we need to read from the chunk table. */ size_t size = num_needed_chunk_entries * chunk_entry_size; - { - u8 chunk_tab_buf[size]; + /* Read the raw data into the end of the chunk_offsets array to + * avoid allocating another array. */ + void *chunk_tab_buf = (void*)&chunk_offsets[num_needed_chunks] - size; - if (fread(chunk_tab_buf, 1, size, fp) != size) - goto read_error; + if (fread(chunk_tab_buf, 1, size, fp) != size) + goto read_error; - /* Now fill in chunk_offsets from the entries we have read in - * chunk_tab_buf. */ + /* Now fill in chunk_offsets from the entries we have read in + * chunk_tab_buf. */ - u64 *chunk_tab_p = chunk_offsets; - if (start_chunk == 0) - chunk_tab_p++; + u64 *chunk_tab_p = chunk_offsets; + if (start_chunk == 0) + chunk_tab_p++; - if (chunk_entry_size == 4) { - u32 *entries = (u32*)chunk_tab_buf; - while (num_needed_chunk_entries--) - *chunk_tab_p++ = le32_to_cpu(*entries++); - } else { - u64 *entries = (u64*)chunk_tab_buf; - while (num_needed_chunk_entries--) - *chunk_tab_p++ = le64_to_cpu(*entries++); - } + if (chunk_entry_size == 4) { + u32 *entries = (u32*)chunk_tab_buf; + while (num_needed_chunk_entries--) + *chunk_tab_p++ = le32_to_cpu(*entries++); + } else { + u64 *entries = (u64*)chunk_tab_buf; + while (num_needed_chunk_entries--) + *chunk_tab_p++ = le64_to_cpu(*entries++); } /* Done with the chunk table now. We must now seek to the first chunk @@ -226,10 +247,11 @@ read_compressed_resource(FILE *fp, u64 resource_compressed_size, goto read_error; /* Pointer to current position in the output buffer for uncompressed - * data. */ + * data. Alternatively, if using a callback function, we repeatedly + * fill a temporary buffer to feed data into the callback function. */ u8 *out_p; if (cb) - out_p = alloca(32768); + out_p = alloca(WIM_CHUNK_SIZE); else out_p = ctx_or_buf; @@ -298,11 +320,11 @@ read_compressed_resource(FILE *fp, u64 resource_compressed_size, * is equal to the uncompressed chunk size. */ if (compressed_chunk_size == uncompressed_chunk_size) { /* Uncompressed chunk */ - if (start_offset != 0) if (fseeko(fp, start_offset, SEEK_CUR)) goto read_error; - if (fread(out_p, 1, partial_chunk_size, fp) != partial_chunk_size) + if (fread(cb ? out_p + start_offset : out_p, + 1, partial_chunk_size, fp) != partial_chunk_size) goto read_error; } else { /* Compressed chunk */ @@ -341,7 +363,8 @@ read_compressed_resource(FILE *fp, u64 resource_compressed_size, } if (cb) { /* Feed the data to the callback function */ - ret = cb(out_p, partial_chunk_size, ctx_or_buf); + ret = cb(out_p + start_offset, + partial_chunk_size, ctx_or_buf); if (ret) goto out; } else { @@ -355,6 +378,8 @@ read_compressed_resource(FILE *fp, u64 resource_compressed_size, ret = 0; out: + if (chunk_offsets_malloced) + FREE(chunk_offsets); return ret; read_error: @@ -438,7 +463,7 @@ put_resource_entry(void *p, const struct resource_entry *entry) static FILE * wim_get_fp(WIMStruct *w) { -#ifdef WITH_FUSE +#if defined(WITH_FUSE) || defined(ENABLE_MULTITHREADED_COMPRESSION) pthread_mutex_lock(&w->fp_tab_mutex); FILE *fp; @@ -457,9 +482,9 @@ wim_get_fp(WIMStruct *w) ERROR_WITH_ERRNO("Failed to open `%"TS"'", w->filename); out_unlock: pthread_mutex_unlock(&w->fp_tab_mutex); -#else /* WITH_FUSE */ +#else /* WITH_FUSE || ENABLE_MULTITHREADED_COMPRESSION */ fp = w->fp; -#endif /* !WITH_FUSE */ +#endif /* !WITH_FUSE && !ENABLE_MULTITHREADED_COMPRESSION */ return fp; } @@ -467,7 +492,7 @@ static int wim_release_fp(WIMStruct *w, FILE *fp) { int ret = 0; -#ifdef WITH_FUSE +#if defined(WITH_FUSE) || defined(ENABLE_MULTITHREADED_COMPRESSION) FILE **fp_tab; pthread_mutex_lock(&w->fp_tab_mutex); @@ -491,7 +516,7 @@ wim_release_fp(WIMStruct *w, FILE *fp) w->num_allocated_fps += 4; out_unlock: pthread_mutex_unlock(&w->fp_tab_mutex); -#endif /* WITH_FUSE */ +#endif /* WITH_FUSE || ENABLE_MULTITHREADED_COMPRESSION */ return ret; } @@ -508,22 +533,18 @@ read_partial_wim_resource(const struct wim_lookup_table_entry *lte, int ret; wimlib_assert(lte->resource_location == RESOURCE_IN_WIM); - wimlib_assert(offset + size <= lte->resource_entry.original_size); wim = lte->wim; - - if (flags & WIMLIB_RESOURCE_FLAG_MULTITHREADED) { + if (flags & WIMLIB_RESOURCE_FLAG_THREADSAFE_READ) { wim_fp = wim_get_fp(wim); if (!wim_fp) { - ret = -1; + ret = WIMLIB_ERR_READ; goto out; } } else { wim_fp = lte->wim->fp; } - wimlib_assert(wim_fp != NULL); - if (lte->resource_entry.flags & WIM_RESHDR_FLAG_COMPRESSED && !(flags & WIMLIB_RESOURCE_FLAG_RAW)) { @@ -551,7 +572,7 @@ read_partial_wim_resource(const struct wim_lookup_table_entry *lte, while (size) { size_t bytes_to_read = min(WIM_CHUNK_SIZE, size); size_t bytes_read = fread(buf, 1, bytes_to_read, wim_fp); - + if (bytes_read != bytes_to_read) goto read_error; ret = cb(buf, bytes_read, ctx_or_buf); @@ -568,11 +589,17 @@ read_partial_wim_resource(const struct wim_lookup_table_entry *lte, } goto out_release_fp; read_error: - ERROR_WITH_ERRNO("Error reading data from WIM"); + if (ferror(wim_fp)) + ERROR_WITH_ERRNO("Error reading data from WIM"); + else + ERROR("Unexpected EOF in WIM!"); ret = WIMLIB_ERR_READ; out_release_fp: - if (flags & WIMLIB_RESOURCE_FLAG_MULTITHREADED) - ret |= wim_release_fp(wim, wim_fp); + if (flags & WIMLIB_RESOURCE_FLAG_THREADSAFE_READ) { + int ret2 = wim_release_fp(wim, wim_fp); + if (ret == 0) + ret = ret2; + } out: if (ret) { if (errno == 0) @@ -588,7 +615,7 @@ read_partial_wim_resource_into_buf(const struct wim_lookup_table_entry *lte, bool threadsafe) { return read_partial_wim_resource(lte, size, NULL, buf, - threadsafe ? WIMLIB_RESOURCE_FLAG_MULTITHREADED : 0, + threadsafe ? WIMLIB_RESOURCE_FLAG_THREADSAFE_READ : 0, offset); } @@ -603,6 +630,7 @@ read_wim_resource_prefix(const struct wim_lookup_table_entry *lte, } +#ifndef __WIN32__ static int read_file_on_disk_prefix(const struct wim_lookup_table_entry *lte, u64 size, @@ -649,6 +677,7 @@ out_close: close(fd); return ret; } +#endif /* !__WIN32__ */ static int read_buffer_prefix(const struct wim_lookup_table_entry *lte, @@ -691,10 +720,12 @@ typedef int (*read_resource_prefix_handler_t)(const struct wim_lookup_table_entr * When using a callback function, it is called with chunks up to 32768 bytes in * size until the resource is exhausted. * - * If the resource is located in a WIM file, @flags can be - * WIMLIB_RESOURCE_FLAG_MULTITHREADED if it must be safe to access the resource - * concurrently by multiple threads, or WIMLIB_RESOURCE_FLAG_RAW if the raw - * compressed data is to be supplied instead of the uncompressed data. + * If the resource is located in a WIM file, @flags can be: + * * WIMLIB_RESOURCE_FLAG_THREADSAFE_READ if it must be safe to access the resource + * concurrently by multiple threads. + * * WIMLIB_RESOURCE_FLAG_RAW if the raw compressed data is to be supplied + * instead of the uncompressed data. + * Otherwise, the @flags are ignored. */ int read_resource_prefix(const struct wim_lookup_table_entry *lte, @@ -703,7 +734,9 @@ read_resource_prefix(const struct wim_lookup_table_entry *lte, { static const read_resource_prefix_handler_t handlers[] = { [RESOURCE_IN_WIM] = read_wim_resource_prefix, + #ifndef __WIN32__ [RESOURCE_IN_FILE_ON_DISK] = read_file_on_disk_prefix, + #endif [RESOURCE_IN_ATTACHED_BUFFER] = read_buffer_prefix, #ifdef WITH_FUSE [RESOURCE_IN_STAGING_FILE] = read_file_on_disk_prefix, @@ -728,7 +761,7 @@ read_full_resource_into_buf(const struct wim_lookup_table_entry *lte, return read_resource_prefix(lte, wim_resource_size(lte), NULL, buf, - thread_safe ? WIMLIB_RESOURCE_FLAG_MULTITHREADED : 0); + thread_safe ? WIMLIB_RESOURCE_FLAG_THREADSAFE_READ : 0); } struct extract_ctx { @@ -779,8 +812,8 @@ extract_wim_resource(const struct wim_lookup_table_entry *lte, print_lookup_table_entry(lte, stderr); if (lte->resource_location == RESOURCE_IN_WIM) ERROR("The WIM file appears to be corrupt!"); - ret = WIMLIB_ERR_INVALID_RESOURCE_HASH; #endif + ret = WIMLIB_ERR_INVALID_RESOURCE_HASH; } } } else { @@ -811,6 +844,29 @@ extract_wim_resource_to_fd(const struct wim_lookup_table_entry *lte, return extract_wim_resource(lte, size, extract_wim_chunk_to_fd, &fd); } + +static int +sha1_chunk(const void *buf, size_t len, void *ctx) +{ + sha1_update(ctx, buf, len); + return 0; +} + +/* Calculate the SHA1 message digest of a stream. */ +int +sha1_resource(struct wim_lookup_table_entry *lte) +{ + int ret; + SHA_CTX sha_ctx; + + sha1_init(&sha_ctx); + ret = read_resource_prefix(lte, wim_resource_size(lte), + sha1_chunk, &sha_ctx, 0); + if (ret == 0) + sha1_final(lte->hash, &sha_ctx); + return ret; +} + /* * Copies the file resource specified by the lookup table entry @lte from the * input WIM to the output WIM that has its FILE * given by