_rename_output_to_orig = false;

_delete_patchfile = false;

_hash_table = nullptr;

_initiated = false;

nassertv(!buffer.is_null());

_buffer = buffer;

_version_number = 0;

_allow_multifile = true;

_patch_stream = nullptr;

_origfile_stream = nullptr;

reset_footprint_length();

if (!_initiated) {

express_cat.error()

<< "Patchfile::cleanup() - Patching has not been initiated"

<< endl;

return;

}

// close files

VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();

if (_origfile_stream != nullptr) {

vfs->close_read_file(_origfile_stream);

_origfile_stream = nullptr;

}

if (_patch_stream != nullptr) {

vfs->close_read_file(_patch_stream);

_patch_stream = nullptr;

}

_write_stream.close();

_initiated = false;

int result = initiate(patch_file, file, Filename::temporary("", "patch_"));

_rename_output_to_orig = true;

_delete_patchfile = !keep_temporary_files;

return result;

const Filename &target_file) {

if (_initiated) {

express_cat.error()

<< "Patchfile::initiate() - Patching has already been initiated"

<< endl;

return EU_error_abort;

}

nassertr(orig_file != target_file, EU_error_abort);

VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();

// Open the original file for read

nassertr(_origfile_stream == nullptr, EU_error_abort);

_orig_file = orig_file;

_orig_file.set_binary();

_origfile_stream = vfs->open_read_file(_orig_file, false);

if (_origfile_stream == nullptr) {

express_cat.error()

<< "Patchfile::initiate() - Failed to open file: " << _orig_file << endl;

return get_write_error();

}

// Open the temp file for write

_output_file = target_file;

_output_file.set_binary();

if (!_output_file.open_write(_write_stream)) {

express_cat.error()

<< "Patchfile::initiate() - Failed to open file: " << _output_file << endl;

return get_write_error();

}

if (express_cat.is_debug()) {

express_cat.debug()

<< "Patchfile using output file " << _output_file << "\n";

}

int result = internal_read_header(patch_file);

_total_bytes_processed = 0;

_initiated = true;

return result;

if (_initiated) {

express_cat.error()

<< "Patchfile::initiate() - Patching has already been initiated"

<< endl;

return EU_error_abort;

}

int result = internal_read_header(patch_file);

if (_patch_stream != nullptr) {

VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();

vfs->close_read_file(_patch_stream);

_patch_stream = nullptr;

}

return result;

// Now patch the file using the given buffer

int buflen;

int bytes_read;

uint16_t ADD_length;

uint16_t COPY_length;

int32_t COPY_offset;

if (_initiated == false) {

express_cat.error()

<< "Patchfile::run() - Patching has not been initiated"

<< endl;

return EU_error_abort;

}

nassertr(_patch_stream != nullptr, EU_error_abort);

nassertr(_origfile_stream != nullptr, EU_error_abort);

StreamReader patch_reader(*_patch_stream);

buflen = _buffer->get_length();

bytes_read = 0;

while (bytes_read < buflen) {

// read # of ADD bytes

nassertr(_buffer->get_length() >= (int)sizeof(ADD_length), false);

ADD_length = patch_reader.get_uint16();

if (_patch_stream->fail()) {

express_cat.error()

<< "Truncated patch file.\n";

return EU_error_file_invalid;

}

bytes_read += (int)ADD_length;

_total_bytes_processed += (int)ADD_length;

if (_total_bytes_processed > _total_bytes_to_process) {

express_cat.error()

<< "Runaway patch file.\n";

return EU_error_file_invalid;

}

// if there are bytes to add, read them from patch file and write them to

// output

if (express_cat.is_spam() && ADD_length != 0) {

express_cat.spam()

<< "ADD: " << ADD_length << " (to "

<< _write_stream.tellp() << ")" << endl;

}

uint32_t bytes_left = (uint32_t)ADD_length;

while (bytes_left > 0) {

uint32_t bytes_this_time = (uint32_t) min(bytes_left, (uint32_t) buflen);

_patch_stream->read(_buffer->_buffer, bytes_this_time);

if (_patch_stream->fail()) {

express_cat.error()

<< "Truncated patch file.\n";

return EU_error_file_invalid;

}

_write_stream.write(_buffer->_buffer, bytes_this_time);

bytes_left -= bytes_this_time;

}

// read # of COPY bytes

nassertr(_buffer->get_length() >= (int)sizeof(COPY_length), false);

COPY_length = patch_reader.get_uint16();

if (_patch_stream->fail()) {

express_cat.error()

<< "Truncated patch file.\n";

return EU_error_file_invalid;

}

bytes_read += (int)COPY_length;

_total_bytes_processed += (int)COPY_length;

if (_total_bytes_processed > _total_bytes_to_process) {

express_cat.error()

<< "Runaway patch file.\n";

return EU_error_file_invalid;

}

// if there are bytes to copy, read them from original file and write them

// to output

if (0 != COPY_length) {

// read copy offset

nassertr(_buffer->get_length() >= (int)sizeof(COPY_offset), false);

COPY_offset = patch_reader.get_int32();

if (_patch_stream->fail()) {

express_cat.error()

<< "Truncated patch file.\n";

return EU_error_file_invalid;

}

// seek to the copy source pos

if (_version_number < 2) {

_origfile_stream->seekg(COPY_offset, ios::beg);

} else {

_origfile_stream->seekg(COPY_offset, ios::cur);

}

if (_origfile_stream->fail()) {

express_cat.error()

<< "Invalid copy offset in patch file.\n";

return EU_error_file_invalid;

}

if (express_cat.is_spam()) {

express_cat.spam()

<< "COPY: " << COPY_length << " bytes from offset "

<< COPY_offset << " (from " << _origfile_stream->tellg()

<< " to " << _write_stream.tellp() << ")"

<< endl;

}

// read the copy bytes from original file and write them to output

uint32_t bytes_left = (uint32_t)COPY_length;

while (bytes_left > 0) {

uint32_t bytes_this_time = (uint32_t) min(bytes_left, (uint32_t) buflen);

_origfile_stream->read(_buffer->_buffer, bytes_this_time);

if (_origfile_stream->fail()) {

express_cat.error()

<< "Invalid copy length in patch file.\n";

return EU_error_file_invalid;

}

_write_stream.write(_buffer->_buffer, bytes_this_time);

bytes_left -= bytes_this_time;

}

}

// if we got a pair of zero-length ADD and COPY blocks, we're done

if ((0 == ADD_length) && (0 == COPY_length)) {

cleanup();

if (express_cat.is_debug()) {

express_cat.debug()

// << "result file = " << _result_file_length

<< " total bytes = " << _total_bytes_processed << endl;

}

// check the MD5 from the patch file against the newly patched file

{

HashVal MD5_actual;

MD5_actual.hash_file(_output_file);

if (_MD5_ofResult != MD5_actual) {

// Whoops, patching screwed up somehow.

if (_origfile_stream != nullptr) {

VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();

vfs->close_read_file(_origfile_stream);

_origfile_stream = nullptr;

}

_write_stream.close();

express_cat.info()

<< "Patching produced incorrect checksum. Got:\n"

<< " " << MD5_actual

<< "\nExpected:\n"

<< " " << _MD5_ofResult

<< "\n";

// This is a fine time to double-check the starting checksum.

if (!has_source_hash()) {

express_cat.info()

<< "No source hash in patch file to verify.\n";

} else {

HashVal MD5_orig;

MD5_orig.hash_file(_orig_file);

if (MD5_orig != get_source_hash()) {

express_cat.info()

<< "Started from incorrect source file. Got:\n"

<< " " << MD5_orig

<< "\nExpected:\n"

<< " " << get_source_hash()

<< "\n";

} else {

express_cat.info()

<< "Started from correct source file:\n"

<< " " << MD5_orig

<< "\n";

}

}

// delete the temp file and the patch file

if (_rename_output_to_orig) {

_output_file.unlink();

}

if (_delete_patchfile) {

_patch_file.unlink();

}

// return "invalid checksum"

return EU_error_invalid_checksum;

}

}

// delete the patch file

if (_delete_patchfile) {

_patch_file.unlink();

}

// rename the temp file to the original file name

if (_rename_output_to_orig) {

_orig_file.unlink();

if (!_output_file.rename_to(_orig_file)) {

express_cat.error()

<< "Patchfile::run() failed to rename temp file to: " << _orig_file

<< endl;

return EU_error_write_file_rename;

}

}

return EU_success;

}

}

return EU_ok;

int ret = initiate(patch_file, file);

if (ret < 0)

return false;

for (;;) {

ret = run();

if (ret == EU_success)

return true;

if (ret < 0)

return false;

}

return false;

int ret = initiate(patch_file, orig_file, target_file);

if (ret < 0)

return false;

for (;;) {

ret = run();

if (ret == EU_success)

return true;

if (ret < 0)

return false;

}

return false;

// Open the patch file for read

VirtualFileSystem *vfs = VirtualFileSystem::get_global_ptr();

nassertr(_patch_stream == nullptr, EU_error_abort);

_patch_file = patch_file;

_patch_file.set_binary();

_patch_stream = vfs->open_read_file(_patch_file, true);

if (_patch_stream == nullptr) {

express_cat.error()

<< "Patchfile::initiate() - Failed to open file: " << _patch_file << endl;

return get_write_error();

}

// read header, make sure the patch file is valid

StreamReader patch_reader(*_patch_stream);

// check the magic number

nassertr(_buffer->get_length() >= _v0_header_length, false);

uint32_t magic_number = patch_reader.get_uint32();

if (magic_number != _magic_number && magic_number != _v0_magic_number) {

express_cat.error()

<< "Invalid patch file: " << _patch_file << endl;

return EU_error_file_invalid;

}

_version_number = 0;

if (magic_number != _v0_magic_number) {

_version_number = patch_reader.get_uint16();

}

if (_version_number > _current_version) {

express_cat.error()

<< "Can't read version " << _version_number << " patch files: "

<< _patch_file << endl;

return EU_error_file_invalid;

}

if (_version_number >= 1) {

// Get the length of the source file.

/*uint32_t source_file_length =*/ patch_reader.get_uint32();

// get the MD5 of the source file.

_MD5_ofSource.read_stream(patch_reader);

}

// get the length of the patched result file

_total_bytes_to_process = patch_reader.get_uint32();

// get the MD5 of the resultant patched file

_MD5_ofResult.read_stream(patch_reader);

if (express_cat.is_debug()) {

express_cat.debug()

<< "Patchfile::initiate() - valid patchfile" << endl;

}

return EU_success;

#ifdef USE_MD5_FOR_HASHTABLE_INDEX_VALUES

HashVal hash;

hash.hash_buffer(buffer, _footprint_length);

// cout << uint16_t(hash.get_value(0)) << " ";

return uint16_t(hash.get_value(0));

#else

uint32_t hash_value = 0;

for(int i = 0; i < (int)_footprint_length; i++) {

// this is probably not such a good hash. to be replaced --> TRIED MD5,

// was not worth it for the execution-time hit on 800Mhz PC

hash_value ^= uint32_t(*buffer) << ((i * 2) % Patchfile::_HASH_BITS);

buffer++;

}

// use the bits that overflowed past the end of the hash bit range (this is

// intended for _HASH_BITS == 24)

hash_value ^= (hash_value >> Patchfile::_HASH_BITS);

// cout << hash_value << " ";

return hash_value & _HASH_MASK;

#endif

uint32_t *hash_table, uint32_t *link_table) {

uint32_t i;

// clear hash table

for(i = 0; i < _HASHTABLESIZE; i++) {

hash_table[i] = _NULL_VALUE;

}

// clear link table

for(i = 0; i < length_orig; i++) {

link_table[i] = _NULL_VALUE;

}

if(length_orig < _footprint_length) return;

// run through original file and hash each footprint

for(i = 0; i < (length_orig - _footprint_length); i++) {

uint32_t hash_value = calc_hash(&buffer_orig[i]);

// we must now store this file index in the hash table at the offset of

// the hash value

// to account for multiple file offsets with identical hash values, there

// is a link table with an entry for every footprint in the file. We

// create linked lists of offsets in the link table.

// first, set the value in the link table for the current offset to

// whatever the current list head is (the value in the hash table) (note

// that this only works because the hash and link tables both use

// _NULL_VALUE to indicate a null index)

link_table[i] = hash_table[hash_value];

// set the new list head; store the current offset in the hash table at

// the offset of the footprint's hash value

hash_table[hash_value] = i;

/*

}

uint32_t min_length) {

// early out: look ahead and sample the end of the minimum range

if (min_length > 2) {

if (min_length >= max_length)

return 0;

if (buf1[min_length] != buf2[min_length] ||

buf1[min_length-1] != buf2[min_length-1] ||

buf1[min_length-2] != buf2[min_length-2]) {

return 0;

}

}

uint32_t length = 0;

while ((length < max_length) && (*buf1 == *buf2)) {

buf1++, buf2++, length++;

}

return length;

uint32_t *hash_table, uint32_t *link_table, const char* buffer_orig,

uint32_t length_orig, const char* buffer_new, uint32_t length_new) {

// set length to a safe value

copy_length = 0;

// get offset of matching string (in orig file) from hash table

uint32_t hash_value = calc_hash(&buffer_new[new_pos]);

// if no match, bail

if (_NULL_VALUE == hash_table[hash_value])

return;

copy_pos = hash_table[hash_value];

// calc match length

copy_length = (uint16_t)calc_match_length(&buffer_new[new_pos],

&buffer_orig[copy_pos],

min(min((length_new - new_pos),

(length_orig - copy_pos)),

_MAX_RUN_LENGTH),

0);

// run through link table, see if we find any longer matches

uint32_t match_offset;

uint16_t match_length;

match_offset = link_table[copy_pos];

while (match_offset != _NULL_VALUE) {

match_length = (uint16_t)calc_match_length(&buffer_new[new_pos],

&buffer_orig[match_offset],

min(min((length_new - new_pos),

(length_orig - match_offset)),

_MAX_RUN_LENGTH),

copy_length);

// have we found a longer match?

if (match_length > copy_length) {

copy_pos = match_offset;

copy_length = match_length;

}

// traverse the link table

match_offset = link_table[match_offset];

}

nassertv(length == (uint16_t)length); //we only write a uint16

if (express_cat.is_spam()) {

express_cat.spam()

<< "ADD: " << length << " (to " << _add_pos << ")" << endl;

}

// write ADD length

StreamWriter patch_writer(write_stream);

patch_writer.add_uint16((uint16_t)length);

// if there are bytes to add, add them

if (length > 0) {

patch_writer.append_data(buffer, (uint16_t)length);

}

_add_pos += length;

nassertv(length == (uint16_t)length); //we only write a uint16

int32_t offset = (int)copy_pos - (int)_last_copy_pos;

if (express_cat.is_spam()) {

express_cat.spam()

<< "COPY: " << length << " bytes from offset " << offset

<< " (from " << copy_pos << " to " << _add_pos << ")" << endl;

}

// write COPY length

StreamWriter patch_writer(write_stream);

patch_writer.add_uint16((uint16_t)length);

if ((uint16_t)length != 0) {

// write COPY offset

patch_writer.add_int32(offset);

_last_copy_pos = copy_pos + length;

}

_add_pos += length;

uint32_t add_length, const char *add_buffer,

uint32_t copy_length, uint32_t copy_pos) {

if (add_length == 0 && copy_length == 0) {

// Don't accidentally emit a termination code.

return;

}

static const uint16_t max_write = 65535;

while (add_length > max_write) {

// Overflow. This chunk is too large to fit into a single ADD block, so

// we have to write it as multiple ADDs.

emit_ADD(write_stream, max_write, add_buffer);

add_buffer += max_write;

add_length -= max_write;

emit_COPY(write_stream, 0, 0);

}

emit_ADD(write_stream, add_length, add_buffer);

while (copy_length > max_write) {

// Overflow.

emit_COPY(write_stream, max_write, copy_pos);

copy_pos += max_write;

copy_length -= max_write;

emit_ADD(write_stream, 0, nullptr);

}

emit_COPY(write_stream, copy_length, copy_pos);

uint32_t add_length, const char *add_buffer,

uint32_t copy_length, uint32_t copy_pos) {

if (add_length != 0) {

if (_cache_copy_length != 0) {

// Have to flush.

cache_flush(write_stream);

}

// Add the string to the current cache.

_cache_add_data += string(add_buffer, add_length);

}

if (copy_length != 0) {

if (_cache_copy_length == 0) {

// Start a new copy phase.

_cache_copy_start = copy_pos;

_cache_copy_length = copy_length;

} else if (_cache_copy_start + _cache_copy_length == copy_pos) {

// We can just tack on the copy to what we've already got.

_cache_copy_length += copy_length;

} else {

// It's a discontinuous copy. We have to flush.

cache_flush(write_stream);

_cache_copy_start = copy_pos;

_cache_copy_length = copy_length;

}

}

emit_add_and_copy(write_stream,

_cache_add_data.size(), _cache_add_data.data(),

_cache_copy_length, _cache_copy_start);

_cache_add_data = string();

_cache_copy_length = 0;

istream &stream_orig, istream &stream_new) {

// prepare to write the patch file header

// write the patch file header

StreamWriter patch_writer(write_stream);

patch_writer.add_uint32(_magic_number);

patch_writer.add_uint16(_current_version);

stream_orig.seekg(0, ios::end);

streampos source_file_length = stream_orig.tellg();

patch_writer.add_uint32((uint32_t)source_file_length);

// calc MD5 of original file

_MD5_ofSource.hash_stream(stream_orig);

// add it to the header

_MD5_ofSource.write_stream(patch_writer);

if (express_cat.is_debug()) {

express_cat.debug()

<< "Orig: " << _MD5_ofSource << "\n";

}

stream_new.seekg(0, ios::end);

streampos result_file_length = stream_new.tellg();

patch_writer.add_uint32((uint32_t)result_file_length);

// calc MD5 of resultant patched file

_MD5_ofResult.hash_stream(stream_new);

// add it to the header

_MD5_ofResult.write_stream(patch_writer);

if (express_cat.is_debug()) {

express_cat.debug()

<< " New: " << _MD5_ofResult << "\n";

}

cache_flush(write_stream);

// write terminator (null ADD, null COPY)

emit_ADD(write_stream, 0, nullptr);

emit_COPY(write_stream, 0, 0);

uint32_t offset_orig, uint32_t offset_new,

istream &stream_orig, istream &stream_new) {

// read in original file

stream_orig.seekg(0, ios::end);

nassertr(stream_orig, false);

uint32_t source_file_length = stream_orig.tellg();

if (express_cat.is_debug()) {

express_cat.debug()

<< "Allocating " << source_file_length << " bytes to read orig\n";

}

char *buffer_orig = (char *)PANDA_MALLOC_ARRAY(source_file_length);

stream_orig.seekg(0, ios::beg);

stream_orig.read(buffer_orig, source_file_length);

// read in new file

stream_new.seekg(0, ios::end);

uint32_t result_file_length = stream_new.tellg();

nassertr(stream_new, false);

if (express_cat.is_debug()) {

express_cat.debug()

<< "Allocating " << result_file_length << " bytes to read new\n";

}

char *buffer_new = (char *)PANDA_MALLOC_ARRAY(result_file_length);

stream_new.seekg(0, ios::beg);

stream_new.read(buffer_new, result_file_length);

// allocate hashlink tables

if (_hash_table == nullptr) {

if (express_cat.is_debug()) {

express_cat.debug()

<< "Allocating hashtable of size " << _HASHTABLESIZE << " * 4\n";

}

_hash_table = (uint32_t *)PANDA_MALLOC_ARRAY(_HASHTABLESIZE * sizeof(uint32_t));

}

if (express_cat.is_debug()) {

express_cat.debug()