static bool rar_restart_solid(ar_archive_rar *rar)
{
ar_archive *ar = &rar->super;
size_t current_offset = ar->entry_offset;
log("Restarting decompression for solid entry");
if (!ar_parse_entry_at(ar, 0)) {
ar_parse_entry_at(ar, current_offset);
return false;
}
while (ar->entry_offset != current_offset) {
size_t size = ar->entry_size_uncompressed;
rar->entry.restart_solid = false;
while (size > 0) {
unsigned char buffer[1024];
if (!ar_entry_uncompress(ar, buffer, min(size, sizeof(buffer)))) {
ar_parse_entry_at(ar, current_offset);
return false;
}
size -= min(size, sizeof(buffer));
}
if (!ar_parse_entry(ar)) {
ar_parse_entry_at(ar, current_offset);
return false;
}
}
rar->entry.restart_solid = false;
return true;
}
static bool rar_restart_solid(ar_archive *ar)
{
ar_archive_rar *rar = (ar_archive_rar *)ar;
off64_t current_offset = ar->entry_offset;
log("Restarting decompression for solid entry");
if (!ar_parse_entry_at(ar, ar->entry_offset_first)) {
ar_parse_entry_at(ar, current_offset);
return false;
}
while (ar->entry_offset < current_offset) {
size_t size = ar->entry_size_uncompressed;
rar->solid.restart = false;
while (size > 0) {
unsigned char buffer[1024];
size_t count = mins(size, sizeof(buffer));
if (!ar_entry_uncompress(ar, buffer, count)) {
ar_parse_entry_at(ar, current_offset);
return false;
}
size -= count;
}
if (!ar_parse_entry(ar)) {
ar_parse_entry_at(ar, current_offset);
return false;
}
}
rar->solid.restart = false;
return true;
}
int main(int argc, char *argv[])
{
ar_stream *stream = NULL;
ar_archive *ar = NULL;
int entry_count = 1;
int entry_skips = 0;
int error_step = 1;
#if !defined(NDEBUG) && defined(_MSC_VER)
if (!IsDebuggerPresent()) {
_CrtSetReportMode(_CRT_WARN, _CRTDBG_MODE_FILE);
_CrtSetReportFile(_CRT_WARN, _CRTDBG_FILE_STDERR);
}
_CrtSetDbgFlag(_CRTDBG_ALLOC_MEM_DF | _CRTDBG_LEAK_CHECK_DF);
#endif
FailIf(argc != 2, "Syntax: %s <filename.ext>", argv[0]);
stream = ar_open_file(argv[1]);
FailIf(!stream, "Error: File \"%s\" not found!", argv[1]);
printf("Parsing \"%s\":\n", argv[1]);
ar = ar_open_any_archive(stream, strrchr(argv[1], '.'));
FailIf(!ar, "Error: No valid %s archive!", "RAR, ZIP, 7Z or TAR");
while (ar_parse_entry(ar)) {
size_t size = ar_entry_get_size(ar);
printf("%02d. %s (@%" PRIi64 ")\n", entry_count++, ar_entry_get_name(ar), ar_entry_get_offset(ar));
while (size > 0) {
unsigned char buffer[1024];
size_t count = size < sizeof(buffer) ? size : sizeof(buffer);
if (!ar_entry_uncompress(ar, buffer, count))
break;
size -= count;
}
if (size > 0) {
fprintf(stderr, "Warning: Failed to uncompress... skipping\n");
entry_skips++;
}
}
FailIf(!ar_at_eof(ar), "Error: Failed to parse entry %d!", entry_count);
error_step = entry_skips > 0 ? 1000 + entry_skips : 0;
CleanUp:
ar_close_archive(ar);
ar_close(stream);
return error_step;
}
int readData(ARCHIVE * archive, rawData * buffer, uint64_t length)
{
if(archive->currentEntryLength == UINT64_MAX)
{
archive->currentEntryLength = (uint64_t) archive->utils.get_size(archive);
if((int64_t) archive->currentEntryLength < 0)
{
archive->currentEntryLength = UINT64_MAX;
return -1;
}
}
if(length > archive->currentEntryLength)
length = archive->currentEntryLength;
if(!ar_entry_uncompress(archive->archive, buffer, length))
return -1;
archive->currentEntryLength -= length;
return (int) length;
}
char *ArchFile::GetFileDataByIdx(size_t fileindex, size_t *len)
{
if (fileindex >= filenames.Count())
return nullptr;
if (!ar || !ar_parse_entry_at(ar, filepos.At(fileindex)))
return GetFileFromFallback(fileindex, len);
size_t size = ar_entry_get_size(ar);
if (size > SIZE_MAX - 3)
return nullptr;
ScopedMem<char> data((char *)malloc(size + 3));
if (!data)
return nullptr;
if (!ar_entry_uncompress(ar, data, size))
return GetFileFromFallback(fileindex, len);
// zero-terminate for convenience
data[size] = data[size + 1] = data[size + 2] = '\0';
if (len)
*len = size;
return data.StealData();
}
static bool tar_parse_entry(ar_archive *ar, off64_t offset)
{
ar_archive_tar *tar = (ar_archive_tar *)ar;
char *longname;
if (!ar_seek(ar->stream, offset, SEEK_SET)) {
warn("Couldn't seek to offset %" PRIi64, offset);
return false;
}
if (!tar_parse_header(tar)) {
warn("Invalid tar header data @%" PRIi64, offset);
return false;
}
if (!tar->entry.checksum) {
ar->at_eof = true;
return false;
}
ar->entry_offset = offset;
ar->entry_offset_next = offset + TAR_BLOCK_SIZE + (tar->entry.filesize + TAR_BLOCK_SIZE - 1) / TAR_BLOCK_SIZE * TAR_BLOCK_SIZE;
ar->entry_size_uncompressed = tar->entry.filesize;
ar->entry_filetime = tar->entry.mtime;
tar->bytes_done = 0;
switch (tar->entry.filetype) {
case TYPE_FILE:
case TYPE_FILE_OLD:
return true;
case TYPE_DIRECTORY:
log("Skipping directory entry \"%s\"", tar_get_name(ar));
return tar_parse_entry(ar, ar->entry_offset_next);
case TYPE_LONGNAME:
longname = malloc(tar->entry.filesize + 1);
if (!longname) {
log("Falling back to the short filename on OOM");
return tar_parse_entry(ar, ar->entry_offset_next);
}
if (!ar_entry_uncompress(ar, longname, tar->entry.filesize)) {
free(longname);
return false;
}
longname[tar->entry.filesize] = '\0';
if (!tar_parse_entry(ar, ar->entry_offset_next)) {
free(longname);
return false;
}
ar->entry_offset = offset;
/* name could be in any encoding, assume UTF-8 or whatever (DOS) */
if (ar_is_valid_utf8(longname)) {
tar->entry.name = longname;
}
else {
tar->entry.name = ar_conv_dos_to_utf8(longname);
free(longname);
}
return true;
default:
warn("Unknown entry type '%c'", tar->entry.filetype);
return true;
}
}
