0x5eal/rbxts-pako
1
0
Fork 0
mirror of https://github.com/0x5eal/rbxts-pako.git synced 2025-04-04 10:50:59 +01:00
Code Issues Projects Releases Packages Wiki Activity

Fix bug in deflate_stored() for zero-length input.

Browse source 
bc5503b224
This commit is contained in:
Alex Kocharin 2022-06-10 16:47:41 +03:00
parent 49d5060e87
commit 14eb66909b
1 changed files with 22 additions and 21 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

43
lib/zlib/deflate.js
View file

@ -496,17 +496,20 @@ const deflate_stored = (s, flush) => {
* possible. If flushing, copy the remaining available input to next_out as * possible. If flushing, copy the remaining available input to next_out as
* stored blocks, if there is enough space. * stored blocks, if there is enough space.
*/ */
let len, left, have, last; let len, left, have, last = 0;
let used = s.strm.avail_in; let used = s.strm.avail_in;
for (;;) { do {
/* Set len to the maximum size block that we can copy directly with the /* Set len to the maximum size block that we can copy directly with the
* available input data and output space. Set left to how much of that * available input data and output space. Set left to how much of that
* would be copied from what's left in the window. * would be copied from what's left in the window.
*/ */
len = 65535/* MAX_STORED */; /* maximum deflate stored block length */ len = 65535/* MAX_STORED */; /* maximum deflate stored block length */
have = (s.bi_valid + 42) >> 3; /* number of header bytes */ have = (s.bi_valid + 42) >> 3; /* number of header bytes */
if (s.strm.avail_out < have) { /* need room for header */
break;
}
/* maximum stored block length that will fit in avail_out: */ /* maximum stored block length that will fit in avail_out: */
have = s.strm.avail_out > have ? s.strm.avail_out - have : 0; have = s.strm.avail_out - have;
left = s.strstart - s.block_start; /* bytes left in window */ left = s.strstart - s.block_start; /* bytes left in window */
if (len > left + s.strm.avail_in) { if (len > left + s.strm.avail_in) {
len = left + s.strm.avail_in; /* limit len to the input */ len = left + s.strm.avail_in; /* limit len to the input */
@ -523,8 +526,9 @@ const deflate_stored = (s, flush) => {
* copying to the window and the pending buffer instead. Also don't * copying to the window and the pending buffer instead. Also don't
* write an empty block when flushing -- deflate() does that. * write an empty block when flushing -- deflate() does that.
*/ */
if (len < min_block && (len === 0 || flush === Z_NO_FLUSH || if (len < min_block && ((len === 0 && flush !== Z_FINISH) ||
len - left !== s.strm.avail_in)) { flush === Z_NO_FLUSH ||
len - left !== s.strm.avail_in)) {
break; break;
} }
@ -569,7 +573,7 @@ const deflate_stored = (s, flush) => {
s.strm.avail_out -= len; s.strm.avail_out -= len;
s.strm.total_out += len; s.strm.total_out += len;
} }
} } while (last === 0);
/* Update the sliding window with the last s->w_size bytes of the copied /* Update the sliding window with the last s->w_size bytes of the copied
* data, or append all of the copied data to the existing window if less * data, or append all of the copied data to the existing window if less
@ -606,13 +610,15 @@ const deflate_stored = (s, flush) => {
s.insert += used > s.w_size - s.insert ? s.w_size - s.insert : used; s.insert += used > s.w_size - s.insert ? s.w_size - s.insert : used;
} }
/* If flushing or finishing and all input has been consumed, then done. If /* If the last block was written to next_out, then done. */
* the code above couldn't write a complete block to next_out, then the if (last) {
* code following this won't be able to either. return BS_FINISH_DONE;
*/ }
if (flush !== Z_NO_FLUSH && s.strm.avail_in === 0 &&
s.strstart === s.block_start) { /* If flushing and all input has been consumed, then done. */
return flush === Z_FINISH ? BS_FINISH_DONE : BS_BLOCK_DONE; if (flush !== Z_NO_FLUSH && flush !== Z_FINISH &&
s.strm.avail_in === 0 && s.strstart === s.block_start) {
return BS_BLOCK_DONE;
} }
/* Fill the window with any remaining input. */ /* Fill the window with any remaining input. */
@ -647,21 +653,18 @@ const deflate_stored = (s, flush) => {
min_block = have > s.w_size ? s.w_size : have; min_block = have > s.w_size ? s.w_size : have;
left = s.strstart - s.block_start; left = s.strstart - s.block_start;
if (left >= min_block || if (left >= min_block ||
(left && flush !== Z_NO_FLUSH && s.strm.avail_in === 0 && ((left || flush === Z_FINISH) && flush !== Z_NO_FLUSH &&
left <= have)) { s.strm.avail_in === 0 && left <= have)) {
len = left > have ? have : left; len = left > have ? have : left;
last = flush === Z_FINISH && s.strm.avail_in === 0 && last = flush === Z_FINISH && s.strm.avail_in === 0 &&
len === left ? 1 : 0; len === left ? 1 : 0;
_tr_stored_block(s, s.block_start, len, last); _tr_stored_block(s, s.block_start, len, last);
s.block_start += len; s.block_start += len;
flush_pending(s.strm); flush_pending(s.strm);
if (last) {
return BS_FINISH_STARTED;
}
} }
/* We've done all we can with the available input and output. */ /* We've done all we can with the available input and output. */
return BS_NEED_MORE; return last ? BS_FINISH_STARTED : BS_NEED_MORE;
}; };
@ -1840,8 +1843,6 @@ const deflate = (strm, flush) => {
} }
} }
} }
//Assert(strm->avail_out > 0, "bug2");
//if (strm.avail_out <= 0) { throw new Error("bug2");}
if (flush !== Z_FINISH) { return Z_OK; } if (flush !== Z_FINISH) { return Z_OK; }
if (s.wrap <= 0) { return Z_STREAM_END; } if (s.wrap <= 0) { return Z_STREAM_END; }