1diff --git a/third_party/zlib/deflate.c b/third_party/zlib/deflate.c 2index 5c4022f..88b2ec0 100644 3--- a/third_party/zlib/deflate.c 4+++ b/third_party/zlib/deflate.c 5@@ -70,14 +70,15 @@ typedef enum { 6 finish_done /* finish done, accept no more input or output */ 7 } block_state; 8 9-typedef block_state (*compress_func) OF((deflate_state *s, int flush)); 10+typedef block_state (*compress_func) OF((deflate_state *s, int flush, 11+ int clas)); 12 /* Compression function. Returns the block state after the call. */ 13 14 local void fill_window OF((deflate_state *s)); 15-local block_state deflate_stored OF((deflate_state *s, int flush)); 16-local block_state deflate_fast OF((deflate_state *s, int flush)); 17+local block_state deflate_stored OF((deflate_state *s, int flush, int clas)); 18+local block_state deflate_fast OF((deflate_state *s, int flush, int clas)); 19 #ifndef FASTEST 20-local block_state deflate_slow OF((deflate_state *s, int flush)); 21+local block_state deflate_slow OF((deflate_state *s, int flush, int clas)); 22 #endif 23 local block_state deflate_rle OF((deflate_state *s, int flush)); 24 local block_state deflate_huff OF((deflate_state *s, int flush)); 25@@ -87,9 +88,9 @@ local void flush_pending OF((z_streamp strm)); 26 local int read_buf OF((z_streamp strm, Bytef *buf, unsigned size)); 27 #ifdef ASMV 28 void match_init OF((void)); /* asm code initialization */ 29- uInt longest_match OF((deflate_state *s, IPos cur_match)); 30+ uInt longest_match OF((deflate_state *s, IPos cur_match, int clas)); 31 #else 32-local uInt longest_match OF((deflate_state *s, IPos cur_match)); 33+local uInt longest_match OF((deflate_state *s, IPos cur_match, int clas)); 34 #endif 35 36 #ifdef DEBUG 37@@ -281,6 +282,9 @@ int ZEXPORT deflateInit2_(strm, level, method, windowBits, memLevel, strategy, 38 s->window = (Bytef *) ZALLOC(strm, s->w_size, 2*sizeof(Byte)); 39 s->prev = (Posf *) ZALLOC(strm, s->w_size, sizeof(Pos)); 40 s->head = (Posf *) ZALLOC(strm, s->hash_size, sizeof(Pos)); 41+ s->class_bitmap = NULL; 42+ zmemzero(&s->cookie_locations, sizeof(s->cookie_locations)); 43+ strm->clas = 0; 44 45 s->high_water = 0; /* nothing written to s->window yet */ 46 47@@ -367,6 +371,8 @@ int ZEXPORT deflateReset (strm) 48 s = (deflate_state *)strm->state; 49 s->pending = 0; 50 s->pending_out = s->pending_buf; 51+ TRY_FREE(strm, s->class_bitmap); 52+ s->class_bitmap = NULL; 53 54 if (s->wrap < 0) { 55 s->wrap = -s->wrap; /* was made negative by deflate(..., Z_FINISH); */ 56@@ -817,9 +823,26 @@ int ZEXPORT deflate (strm, flush) 57 (flush != Z_NO_FLUSH && s->status != FINISH_STATE)) { 58 block_state bstate; 59 60- bstate = s->strategy == Z_HUFFMAN_ONLY ? deflate_huff(s, flush) : 61- (s->strategy == Z_RLE ? deflate_rle(s, flush) : 62- (*(configuration_table[s->level].func))(s, flush)); 63+ if (strm->clas && s->class_bitmap == NULL) { 64+ /* This is the first time that we have seen alternative class 65+ * data. All data up till this point has been standard class. */ 66+ s->class_bitmap = (Bytef*) ZALLOC(strm, s->w_size/4, sizeof(Byte)); 67+ zmemzero(s->class_bitmap, s->w_size/4); 68+ } 69+ 70+ if (strm->clas && s->strategy == Z_RLE) { 71+ /* We haven't patched deflate_rle. */ 72+ ERR_RETURN(strm, Z_BUF_ERROR); 73+ } 74+ 75+ if (s->strategy == Z_HUFFMAN_ONLY) { 76+ bstate = deflate_huff(s, flush); 77+ } else if (s->strategy == Z_RLE) { 78+ bstate = deflate_rle(s, flush); 79+ } else { 80+ bstate = (*(configuration_table[s->level].func)) 81+ (s, flush, strm->clas); 82+ } 83 84 if (bstate == finish_started || bstate == finish_done) { 85 s->status = FINISH_STATE; 86@@ -915,6 +938,7 @@ int ZEXPORT deflateEnd (strm) 87 TRY_FREE(strm, strm->state->head); 88 TRY_FREE(strm, strm->state->prev); 89 TRY_FREE(strm, strm->state->window); 90+ TRY_FREE(strm, strm->state->class_bitmap); 91 92 ZFREE(strm, strm->state); 93 strm->state = Z_NULL; 94@@ -1046,6 +1070,57 @@ local void lm_init (s) 95 #endif 96 } 97 98+/* class_set sets bits [offset,offset+len) in s->class_bitmap to either 1 (if 99+ * class != 0) or 0 (otherwise). */ 100+local void class_set(s, offset, len, clas) 101+ deflate_state *s; 102+ IPos offset; 103+ uInt len; 104+ int clas; 105+{ 106+ IPos byte = offset >> 3; 107+ IPos bit = offset & 7; 108+ Bytef class_byte_value = clas ? 0xff : 0x00; 109+ Bytef class_bit_value = clas ? 1 : 0; 110+ static const Bytef mask[8] = {0xfe, 0xfd, 0xfb, 0xf7, 111+ 0xef, 0xdf, 0xbf, 0x7f}; 112+ 113+ if (bit) { 114+ while (len) { 115+ s->class_bitmap[byte] &= mask[bit]; 116+ s->class_bitmap[byte] |= class_bit_value << bit; 117+ bit++; 118+ len--; 119+ if (bit == 8) { 120+ bit = 0; 121+ byte++; 122+ break; 123+ } 124+ } 125+ } 126+ 127+ while (len >= 8) { 128+ s->class_bitmap[byte++] = class_byte_value; 129+ len -= 8; 130+ } 131+ 132+ while (len) { 133+ s->class_bitmap[byte] &= mask[bit]; 134+ s->class_bitmap[byte] |= class_bit_value << bit; 135+ bit++; 136+ len--; 137+ } 138+} 139+ 140+local int class_at(s, window_offset) 141+ deflate_state *s; 142+ IPos window_offset; 143+{ 144+ IPos byte = window_offset >> 3; 145+ IPos bit = window_offset & 7; 146+ return (s->class_bitmap[byte] >> bit) & 1; 147+} 148+ 149 #ifndef FASTEST 150 /* =========================================================================== 151 * Set match_start to the longest match starting at the given string and 152@@ -1060,9 +1135,10 @@ local void lm_init (s) 153 /* For 80x86 and 680x0, an optimized version will be provided in match.asm or 154 * match.S. The code will be functionally equivalent. 155 */ 156-local uInt longest_match(s, cur_match) 157+local uInt longest_match(s, cur_match, clas) 158 deflate_state *s; 159 IPos cur_match; /* current match */ 160+ int clas; 161 { 162 unsigned chain_length = s->max_chain_length;/* max hash chain length */ 163 register Bytef *scan = s->window + s->strstart; /* current string */ 164@@ -1110,6 +1186,9 @@ local uInt longest_match(s, cur_match) 165 do { 166 Assert(cur_match < s->strstart, "no future"); 167 match = s->window + cur_match; 168+ /* If the matched data is in the wrong class, skip it. */ 169+ if (s->class_bitmap && class_at(s, cur_match) != clas) 170+ continue; 171 172 /* Skip to next match if the match length cannot increase 173 * or if the match length is less than 2. Note that the checks below 174@@ -1152,6 +1231,8 @@ local uInt longest_match(s, cur_match) 175 len = (MAX_MATCH - 1) - (int)(strend-scan); 176 scan = strend - (MAX_MATCH-1); 177 178+#error "UNALIGNED_OK hasn't been patched." 179+ 180 #else /* UNALIGNED_OK */ 181 182 if (match[best_len] != scan_end || 183@@ -1168,15 +1249,23 @@ local uInt longest_match(s, cur_match) 184 scan += 2, match++; 185 Assert(*scan == *match, "match[2]?"); 186 187- /* We check for insufficient lookahead only every 8th comparison; 188- * the 256th check will be made at strstart+258. 189- */ 190- do { 191- } while (*++scan == *++match && *++scan == *++match && 192- *++scan == *++match && *++scan == *++match && 193- *++scan == *++match && *++scan == *++match && 194- *++scan == *++match && *++scan == *++match && 195- scan < strend); 196+ if (!s->class_bitmap) { 197+ /* We check for insufficient lookahead only every 8th comparison; 198+ * the 256th check will be made at strstart+258. 199+ */ 200+ do { 201+ } while (*++scan == *++match && *++scan == *++match && 202+ *++scan == *++match && *++scan == *++match && 203+ *++scan == *++match && *++scan == *++match && 204+ *++scan == *++match && *++scan == *++match && 205+ scan < strend); 206+ } else { 207+ /* We have to be mindful of the class of the data and not stray. */ 208+ do { 209+ } while (*++scan == *++match && 210+ class_at(s, match - s->window) == clas && 211+ scan < strend); 212+ } 213 214 Assert(scan <= s->window+(unsigned)(s->window_size-1), "wild scan"); 215 216@@ -1204,20 +1293,74 @@ local uInt longest_match(s, cur_match) 217 } 218 #endif /* ASMV */ 219 220+/* cookie_match is a replacement for longest_match in the case of cookie data. 221+ * Here we only wish to match the entire value so trying the partial matches in 222+ * longest_match is both wasteful and often fails to find the correct match. 223+ * 224+ * So we take the djb2 hash of the cookie and look up the last position for a 225+ * match in a special hash table. */ 226+local uInt cookie_match(s, start, len) 227+ deflate_state *s; 228+ IPos start; 229+ unsigned len; 230+{ 231+ unsigned hash = 5381; 232+ Bytef *str = s->window + start; 233+ unsigned i; 234+ IPos cookie_location; 235+ 236+ if (len >= MAX_MATCH || len == 0) 237+ return 0; 238+ 239+ for (i = 0; i < len; i++) 240+ hash = ((hash << 5) + hash) + str[i]; 241+ 242+ hash &= Z_COOKIE_HASH_MASK; 243+ cookie_location = s->cookie_locations[hash]; 244+ s->cookie_locations[hash] = start; 245+ s->match_start = 0; 246+ if (cookie_location && 247+ (start - cookie_location) > len && 248+ (start - cookie_location) < MAX_DIST(s) && 249+ len <= s->lookahead) { 250+ for (i = 0; i < len; i++) { 251+ if (s->window[start+i] != s->window[cookie_location+i] || 252+ class_at(s, cookie_location+i) != 1) { 253+ return 0; 254+ } 255+ } 256+ /* Check that we aren't matching a prefix of another cookie by ensuring 257+ * that the final byte is either a semicolon (which cannot appear in a 258+ * cookie value), or non-cookie data. */ 259+ if (s->window[cookie_location+len-1] != ';' && 260+ class_at(s, cookie_location+len) != 0) { 261+ return 0; 262+ } 263+ s->match_start = cookie_location; 264+ return len; 265+ } 266+ 267+ return 0; 268+} 269+ 270+ 271 #else /* FASTEST */ 272 273 /* --------------------------------------------------------------------------- 274 * Optimized version for FASTEST only 275 */ 276-local uInt longest_match(s, cur_match) 277+local uInt longest_match(s, cur_match, clas) 278 deflate_state *s; 279 IPos cur_match; /* current match */ 280+ int clas; 281 { 282 register Bytef *scan = s->window + s->strstart; /* current string */ 283 register Bytef *match; /* matched string */ 284 register int len; /* length of current match */ 285 register Bytef *strend = s->window + s->strstart + MAX_MATCH; 286 287+#error "This code not patched" 288+ 289 /* The code is optimized for HASH_BITS >= 8 and MAX_MATCH-2 multiple of 16. 290 * It is easy to get rid of this optimization if necessary. 291 */ 292@@ -1360,6 +1503,21 @@ local void fill_window(s) 293 */ 294 } while (--n); 295 #endif 296+ 297+ for (n = 0; n < Z_COOKIE_HASH_SIZE; n++) { 298+ if (s->cookie_locations[n] > wsize) { 299+ s->cookie_locations[n] -= wsize; 300+ } else { 301+ s->cookie_locations[n] = 0; 302+ } 303+ } 304+ 305+ if (s->class_bitmap) { 306+ zmemcpy(s->class_bitmap, s->class_bitmap + s->w_size/8, 307+ s->w_size/8); 308+ zmemzero(s->class_bitmap + s->w_size/8, s->w_size/8); 309+ } 310+ 311 more += wsize; 312 } 313 if (s->strm->avail_in == 0) return; 314@@ -1378,6 +1536,9 @@ local void fill_window(s) 315 Assert(more >= 2, "more < 2"); 316 317 n = read_buf(s->strm, s->window + s->strstart + s->lookahead, more); 318+ if (s->class_bitmap != NULL) { 319+ class_set(s, s->strstart + s->lookahead, n, s->strm->clas); 320+ } 321 s->lookahead += n; 322 323 /* Initialize the hash value now that we have some input: */ 324@@ -1459,9 +1620,10 @@ local void fill_window(s) 325 * NOTE: this function should be optimized to avoid extra copying from 326 * window to pending_buf. 327 */ 328-local block_state deflate_stored(s, flush) 329+local block_state deflate_stored(s, flush, clas) 330 deflate_state *s; 331 int flush; 332+ int clas; 333 { 334 /* Stored blocks are limited to 0xffff bytes, pending_buf is limited 335 * to pending_buf_size, and each stored block has a 5 byte header: 336@@ -1517,13 +1679,19 @@ local block_state deflate_stored(s, flush) 337 * new strings in the dictionary only for unmatched strings or for short 338 * matches. It is used only for the fast compression options. 339 */ 340-local block_state deflate_fast(s, flush) 341+local block_state deflate_fast(s, flush, clas) 342 deflate_state *s; 343 int flush; 344+ int clas; 345 { 346 IPos hash_head; /* head of the hash chain */ 347 int bflush; /* set if current block must be flushed */ 348 349+ if (clas != 0) { 350+ /* We haven't patched this code for alternative class data. */ 351+ return Z_BUF_ERROR; 352+ } 353+ 354 for (;;) { 355 /* Make sure that we always have enough lookahead, except 356 * at the end of the input file. We need MAX_MATCH bytes 357@@ -1554,7 +1722,7 @@ local block_state deflate_fast(s, flush) 358 * of window index 0 (in particular we have to avoid a match 359 * of the string with itself at the start of the input file). 360 */ 361- s->match_length = longest_match (s, hash_head); 362+ s->match_length = longest_match (s, hash_head, clas); 363 /* longest_match() sets match_start */ 364 } 365 if (s->match_length >= MIN_MATCH) { 366@@ -1613,12 +1781,25 @@ local block_state deflate_fast(s, flush) 367 * evaluation for matches: a match is finally adopted only if there is 368 * no better match at the next window position. 369 */ 370-local block_state deflate_slow(s, flush) 371+local block_state deflate_slow(s, flush, clas) 372 deflate_state *s; 373 int flush; 374+ int clas; 375 { 376 IPos hash_head; /* head of hash chain */ 377 int bflush; /* set if current block must be flushed */ 378+ uInt input_length ; 379+ int first = 1; /* first says whether this is the first iteration 380+ of the loop, below. */ 381+ 382+ if (clas == Z_CLASS_COOKIE) { 383+ if (s->lookahead) { 384+ /* Alternative class data must always be presented at the beginning 385+ * of a block. */ 386+ return Z_BUF_ERROR; 387+ } 388+ input_length = s->strm->avail_in; 389+ } 390 391 /* Process the input block. */ 392 for (;;) { 393@@ -1648,13 +1829,18 @@ local block_state deflate_slow(s, flush) 394 s->prev_length = s->match_length, s->prev_match = s->match_start; 395 s->match_length = MIN_MATCH-1; 396 397- if (hash_head != NIL && s->prev_length < s->max_lazy_match && 398- s->strstart - hash_head <= MAX_DIST(s)) { 399+ if (clas == Z_CLASS_COOKIE && first) { 400+ s->match_length = cookie_match(s, s->strstart, input_length); 401+ } else if (clas == Z_CLASS_STANDARD && 402+ hash_head != NIL && 403+ s->prev_length < s->max_lazy_match && 404+ s->strstart - hash_head <= MAX_DIST(s)) { 405 /* To simplify the code, we prevent matches with the string 406 * of window index 0 (in particular we have to avoid a match 407 * of the string with itself at the start of the input file). 408 */ 409- s->match_length = longest_match (s, hash_head); 410+ s->match_length = longest_match (s, hash_head, clas); 411+ 412 /* longest_match() sets match_start */ 413 414 if (s->match_length <= 5 && (s->strategy == Z_FILTERED 415@@ -1673,7 +1859,20 @@ local block_state deflate_slow(s, flush) 416 /* If there was a match at the previous step and the current 417 * match is not better, output the previous match: 418 */ 419- if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length) { 420+ first = 0; 421+ if (s->prev_length >= MIN_MATCH && s->match_length <= s->prev_length && 422+ /* We will only accept an exact match for Z_CLASS_COOKIE data and 423+ * we won't match Z_CLASS_HUFFMAN_ONLY data at all. */ 424+ (clas == Z_CLASS_STANDARD || (clas == Z_CLASS_COOKIE && 425+ s->prev_length == input_length && 426+ s->prev_match > 0 && 427+ /* We require that a Z_CLASS_COOKIE match be 428+ * preceded by either a semicolon (which cannot be 429+ * part of a cookie), or non-cookie data. This is 430+ * to prevent a cookie from being a suffix of 431+ * another. */ 432+ (class_at(s, s->prev_match-1) == Z_CLASS_STANDARD || 433+ *(s->window + s->prev_match-1) == ';')))) { 434 uInt max_insert = s->strstart + s->lookahead - MIN_MATCH; 435 /* Do not insert strings in hash table beyond this. */ 436 437diff --git a/third_party/zlib/deflate.h b/third_party/zlib/deflate.h 438index cbf0d1e..2fe6fd6 100644 439--- a/third_party/zlib/deflate.h 440+++ b/third_party/zlib/deflate.h 441@@ -91,6 +91,9 @@ typedef unsigned IPos; 442 * save space in the various tables. IPos is used only for parameter passing. 443 */ 444 445+#define Z_COOKIE_HASH_SIZE 256 446+#define Z_COOKIE_HASH_MASK (Z_COOKIE_HASH_SIZE-1) 447+ 448 typedef struct internal_state { 449 z_streamp strm; /* pointer back to this zlib stream */ 450 int status; /* as the name implies */ 451@@ -139,6 +142,8 @@ typedef struct internal_state { 452 uInt hash_mask; /* hash_size-1 */ 453 454 uInt hash_shift; 455+ Bytef *class_bitmap; /* bitmap of class for each byte in window */ 456+ IPos cookie_locations[Z_COOKIE_HASH_SIZE]; 457 /* Number of bits by which ins_h must be shifted at each input 458 * step. It must be such that after MIN_MATCH steps, the oldest 459 * byte no longer takes part in the hash key, that is: 460diff --git a/third_party/zlib/zlib.h b/third_party/zlib/zlib.h 461index 4d54af9..da7e971 100644 462--- a/third_party/zlib/zlib.h 463+++ b/third_party/zlib/zlib.h 464@@ -101,6 +101,7 @@ typedef struct z_stream_s { 465 int data_type; /* best guess about the data type: binary or text */ 466 uLong adler; /* adler32 value of the uncompressed data */ 467 uLong reserved; /* reserved for future use */ 468+ int clas; 469 } z_stream; 470 471 typedef z_stream FAR *z_streamp; 472@@ -207,6 +208,10 @@ typedef gz_header FAR *gz_headerp; 473 474 #define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ 475 476+#define Z_CLASS_STANDARD 0 477+#define Z_CLASS_COOKIE 1 478+#define Z_CLASS_HUFFMAN_ONLY 2 479+ 480 #define zlib_version zlibVersion() 481 /* for compatibility with versions < 1.0.2 */ 482 483@@ -1587,6 +1592,13 @@ ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, 484 ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); 485 ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); 486 ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); 487+# else 488+ ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); 489+ ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); 490+ ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); 491+ ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); 492+ ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); 493+ ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); 494 # endif 495 #else 496 ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); 497