222 , m_server_no_context_takeover(
false)
223 , m_client_no_context_takeover(
false)
224 , m_server_max_window_bits(15)
225 , m_client_max_window_bits(15)
226 , m_server_max_window_bits_mode(mode::accept)
227 , m_client_max_window_bits_mode(mode::accept)
228 , m_initialized(
false)
229 , m_compress_buffer_size(8192)
231 m_dstate.zalloc = Z_NULL;
232 m_dstate.zfree = Z_NULL;
233 m_dstate.opaque = Z_NULL;
235 m_istate.zalloc = Z_NULL;
236 m_istate.zfree = Z_NULL;
237 m_istate.opaque = Z_NULL;
238 m_istate.avail_in = 0;
239 m_istate.next_in = Z_NULL;
243 if (!m_initialized) {
247 int ret = deflateEnd(&m_dstate);
254 ret = inflateEnd(&m_istate);
264
265
266
267
268
269
270
271
272
273 lib::error_code
init(
bool is_server) {
274 uint8_t deflate_bits;
275 uint8_t inflate_bits;
278 deflate_bits = m_server_max_window_bits;
279 inflate_bits = m_client_max_window_bits;
281 deflate_bits = m_client_max_window_bits;
282 inflate_bits = m_server_max_window_bits;
285 int ret = deflateInit2(
287 Z_DEFAULT_COMPRESSION,
307 m_compress_buffer.reset(
new unsigned char[m_compress_buffer_size]);
308 m_decompress_buffer.reset(
new unsigned char[m_compress_buffer_size]);
309 if ((m_server_no_context_takeover && is_server) ||
310 (m_client_no_context_takeover && !is_server))
312 m_flush = Z_FULL_FLUSH;
314 m_flush = Z_SYNC_FLUSH;
316 m_initialized =
true;
317 return lib::error_code();
322
323
324
325
332
333
334
335
336
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
363 m_server_no_context_takeover =
true;
368
369
370
371
372
373
374
375
376
377
378
379
380
382 m_client_no_context_takeover =
true;
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
425 m_server_max_window_bits = bits;
426 m_server_max_window_bits_mode = mode;
428 return lib::error_code();
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
470 m_client_max_window_bits = bits;
471 m_client_max_window_bits_mode = mode;
473 return lib::error_code();
478
479
480
481
482
485 return "permessage-deflate; client_no_context_takeover; client_max_window_bits";
490
491
492
493
494
495
497 return lib::error_code();
502
503
504
505
506
507
508
512 http::attribute_list::const_iterator it;
513 for (it = offer.begin(); it != offer.end(); ++it) {
514 if (it->first ==
"server_no_context_takeover") {
515 negotiate_server_no_context_takeover(it->second,ret.first);
516 }
else if (it->first ==
"client_no_context_takeover") {
517 negotiate_client_no_context_takeover(it->second,ret.first);
518 }
else if (it->first ==
"server_max_window_bits") {
519 negotiate_server_max_window_bits(it->second,ret.first);
520 }
else if (it->first ==
"client_max_window_bits") {
521 negotiate_client_max_window_bits(it->second,ret.first);
531 if (ret.first == lib::error_code()) {
533 ret.second = generate_response();
541
542
543
544
545
546
547
548 lib::error_code
compress(std::string
const & in, std::string & out) {
549 if (!m_initialized) {
556 uint8_t buf[6] = {0x02, 0x00, 0x00, 0x00, 0xff, 0xff};
557 out.append((
char *)(buf),6);
558 return lib::error_code();
561 m_dstate.avail_in = in.size();
562 m_dstate.next_in = (
unsigned char *)(
const_cast<
char *>(in.data()));
566 m_dstate.avail_out = m_compress_buffer_size;
567 m_dstate.next_out = m_compress_buffer.get();
569 deflate(&m_dstate, m_flush);
571 output = m_compress_buffer_size - m_dstate.avail_out;
573 out.append((
char *)(m_compress_buffer.get()),output);
574 }
while (m_dstate.avail_out == 0);
576 return lib::error_code();
581
582
583
584
585
586 lib::error_code
decompress(uint8_t
const * buf, size_t len, std::string &
589 if (!m_initialized) {
595 m_istate.avail_in = len;
596 m_istate.next_in =
const_cast<
unsigned char *>(buf);
599 m_istate.avail_out = m_compress_buffer_size;
600 m_istate.next_out = m_decompress_buffer.get();
602 ret = inflate(&m_istate, Z_SYNC_FLUSH);
604 if (ret == Z_NEED_DICT || ret == Z_DATA_ERROR || ret == Z_MEM_ERROR) {
609 reinterpret_cast<
char *>(m_decompress_buffer.get()),
610 m_compress_buffer_size - m_istate.avail_out
612 }
while (m_istate.avail_out == 0);
614 return lib::error_code();
619
620
621 std::string generate_response() {
622 std::string ret =
"permessage-deflate";
624 if (m_server_no_context_takeover) {
625 ret +=
"; server_no_context_takeover";
628 if (m_client_no_context_takeover) {
629 ret +=
"; client_no_context_takeover";
634 s <<
int(m_server_max_window_bits);
635 ret +=
"; server_max_window_bits="+s.str();
640 s <<
int(m_client_max_window_bits);
641 ret +=
"; client_max_window_bits="+s.str();
649
650
651
652 void negotiate_server_no_context_takeover(std::string
const & value,
653 lib::error_code & ec)
655 if (!value.empty()) {
660 m_server_no_context_takeover =
true;
665
666
667
668 void negotiate_client_no_context_takeover(std::string
const & value,
669 lib::error_code & ec)
671 if (!value.empty()) {
676 m_client_no_context_takeover =
true;
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701 void negotiate_server_max_window_bits(std::string
const & value,
702 lib::error_code & ec)
704 uint8_t bits = uint8_t(atoi(value.c_str()));
712 switch (m_server_max_window_bits_mode) {
717 m_server_max_window_bits = bits;
720 m_server_max_window_bits = std::min(bits,m_server_max_window_bits);
731 if (m_server_max_window_bits == 8) {
732 m_server_max_window_bits = 9;
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757 void negotiate_client_max_window_bits(std::string
const & value,
758 lib::error_code & ec)
760 uint8_t bits = uint8_t(atoi(value.c_str()));
772 switch (m_client_max_window_bits_mode) {
777 m_client_max_window_bits = bits;
780 m_client_max_window_bits = std::min(bits,m_client_max_window_bits);
791 if (m_client_max_window_bits == 8) {
792 m_client_max_window_bits = 9;
797 bool m_server_no_context_takeover;
798 bool m_client_no_context_takeover;
799 uint8_t m_server_max_window_bits;
800 uint8_t m_client_max_window_bits;
801 mode::value m_server_max_window_bits_mode;
802 mode::value m_client_max_window_bits_mode;
806 size_t m_compress_buffer_size;
807 lib::unique_ptr_uchar_array m_compress_buffer;
808 lib::unique_ptr_uchar_array m_decompress_buffer;