1 // Copyright 2013 The Chromium Authors. All rights reserved. 2 // Use of this source code is governed by a BSD-style license that can be 3 // found in the LICENSE file. 4 5 #include "net/tools/balsa/balsa_headers.h" 6 7 #include <stdio.h> 8 #include <algorithm> 9 #include <string> 10 #include <utility> 11 #include <vector> 12 13 #include "base/containers/hash_tables.h" 14 #include "base/logging.h" 15 #include "base/port.h" 16 #include "base/strings/string_piece.h" 17 #include "base/strings/stringprintf.h" 18 #include "net/tools/balsa/balsa_enums.h" 19 #include "net/tools/balsa/buffer_interface.h" 20 #include "net/tools/balsa/simple_buffer.h" 21 #include "third_party/tcmalloc/chromium/src/base/googleinit.h" 22 23 #if defined(COMPILER_MSVC) 24 #include <string.h> 25 #define snprintf _snprintf 26 #define strncasecmp _strnicmp 27 #else 28 #include <strings.h> 29 #endif 30 31 namespace { 32 33 const char kContentLength[] = "Content-Length"; 34 const char kTransferEncoding[] = "Transfer-Encoding"; 35 const char kSpaceChar = ' '; 36 37 #if defined(COMPILER_MSVC) 38 base::hash_set<base::StringPiece, 39 net::StringPieceCaseCompare> g_multivalued_headers; 40 #else 41 base::hash_set<base::StringPiece, 42 net::StringPieceCaseHash, 43 net::StringPieceCaseEqual> g_multivalued_headers; 44 #endif 45 46 void InitMultivaluedHeaders() { 47 g_multivalued_headers.insert("accept"); 48 g_multivalued_headers.insert("accept-charset"); 49 g_multivalued_headers.insert("accept-encoding"); 50 g_multivalued_headers.insert("accept-language"); 51 g_multivalued_headers.insert("accept-ranges"); 52 g_multivalued_headers.insert("allow"); 53 g_multivalued_headers.insert("cache-control"); 54 g_multivalued_headers.insert("connection"); 55 g_multivalued_headers.insert("content-encoding"); 56 g_multivalued_headers.insert("content-language"); 57 g_multivalued_headers.insert("expect"); 58 g_multivalued_headers.insert("if-match"); 59 g_multivalued_headers.insert("if-none-match"); 60 g_multivalued_headers.insert("pragma"); 61 g_multivalued_headers.insert("proxy-authenticate"); 62 g_multivalued_headers.insert("te"); 63 g_multivalued_headers.insert("trailer"); 64 g_multivalued_headers.insert("transfer-encoding"); 65 g_multivalued_headers.insert("upgrade"); 66 g_multivalued_headers.insert("vary"); 67 g_multivalued_headers.insert("via"); 68 g_multivalued_headers.insert("warning"); 69 g_multivalued_headers.insert("www-authenticate"); 70 // Not mentioned in RFC 2616, but it can have multiple values. 71 g_multivalued_headers.insert("set-cookie"); 72 } 73 74 REGISTER_MODULE_INITIALIZER(multivalued_headers, InitMultivaluedHeaders()); 75 76 const int kFastToBufferSize = 32; // I think 22 is adequate, but anyway.. 77 78 } // namespace 79 80 namespace net { 81 82 BalsaHeaders::iterator_base::iterator_base() : headers_(NULL), idx_(0) { } 83 84 BalsaHeaders::iterator_base::iterator_base(const iterator_base& it) 85 : headers_(it.headers_), 86 idx_(it.idx_) { 87 } 88 89 std::ostream& BalsaHeaders::iterator_base::operator<<(std::ostream& os) const { 90 os << "[" << this->headers_ << ", " << this->idx_ << "]"; 91 return os; 92 } 93 94 BalsaHeaders::iterator_base::iterator_base(const BalsaHeaders* headers, 95 HeaderLines::size_type index) 96 : headers_(headers), 97 idx_(index) { 98 } 99 100 BalsaBuffer::~BalsaBuffer() { 101 CleanupBlocksStartingFrom(0); 102 } 103 104 // Returns the total amount of memory used by the buffer blocks. 105 size_t BalsaBuffer::GetTotalBufferBlockSize() const { 106 size_t buffer_size = 0; 107 for (Blocks::const_iterator iter = blocks_.begin(); 108 iter != blocks_.end(); 109 ++iter) { 110 buffer_size += iter->buffer_size; 111 } 112 return buffer_size; 113 } 114 115 void BalsaBuffer::WriteToContiguousBuffer(const base::StringPiece& sp) { 116 if (sp.empty()) { 117 return; 118 } 119 CHECK(can_write_to_contiguous_buffer_); 120 DCHECK_GE(blocks_.size(), 1u); 121 if (blocks_[0].buffer == NULL && sp.size() <= blocksize_) { 122 blocks_[0] = AllocBlock(); 123 memcpy(blocks_[0].start_of_unused_bytes(), sp.data(), sp.size()); 124 } else if (blocks_[0].bytes_free < sp.size()) { 125 // the first block isn't big enough, resize it. 126 const size_t old_storage_size_used = blocks_[0].bytes_used(); 127 const size_t new_storage_size = old_storage_size_used + sp.size(); 128 char* new_storage = new char[new_storage_size]; 129 char* old_storage = blocks_[0].buffer; 130 if (old_storage_size_used) { 131 memcpy(new_storage, old_storage, old_storage_size_used); 132 } 133 memcpy(new_storage + old_storage_size_used, sp.data(), sp.size()); 134 blocks_[0].buffer = new_storage; 135 blocks_[0].bytes_free = sp.size(); 136 blocks_[0].buffer_size = new_storage_size; 137 delete[] old_storage; 138 } else { 139 memcpy(blocks_[0].start_of_unused_bytes(), sp.data(), sp.size()); 140 } 141 blocks_[0].bytes_free -= sp.size(); 142 } 143 144 base::StringPiece BalsaBuffer::Write(const base::StringPiece& sp, 145 Blocks::size_type* block_buffer_idx) { 146 if (sp.empty()) { 147 return sp; 148 } 149 char* storage = Reserve(sp.size(), block_buffer_idx); 150 memcpy(storage, sp.data(), sp.size()); 151 return base::StringPiece(storage, sp.size()); 152 } 153 154 char* BalsaBuffer::Reserve(size_t size, 155 Blocks::size_type* block_buffer_idx) { 156 // There should always be a 'first_block', even if it 157 // contains nothing. 158 DCHECK_GE(blocks_.size(), 1u); 159 BufferBlock* block = NULL; 160 Blocks::size_type block_idx = can_write_to_contiguous_buffer_ ? 1 : 0; 161 for (; block_idx < blocks_.size(); ++block_idx) { 162 if (blocks_[block_idx].bytes_free >= size) { 163 block = &blocks_[block_idx]; 164 break; 165 } 166 } 167 if (block == NULL) { 168 if (blocksize_ < size) { 169 blocks_.push_back(AllocCustomBlock(size)); 170 } else { 171 blocks_.push_back(AllocBlock()); 172 } 173 block = &blocks_.back(); 174 } 175 176 char* storage = block->start_of_unused_bytes(); 177 block->bytes_free -= size; 178 if (block_buffer_idx) { 179 *block_buffer_idx = block_idx; 180 } 181 return storage; 182 } 183 184 void BalsaBuffer::Clear() { 185 CHECK(!blocks_.empty()); 186 if (blocksize_ == blocks_[0].buffer_size) { 187 CleanupBlocksStartingFrom(1); 188 blocks_[0].bytes_free = blocks_[0].buffer_size; 189 } else { 190 CleanupBlocksStartingFrom(0); 191 blocks_.push_back(AllocBlock()); 192 } 193 DCHECK_GE(blocks_.size(), 1u); 194 can_write_to_contiguous_buffer_ = true; 195 } 196 197 void BalsaBuffer::Swap(BalsaBuffer* b) { 198 blocks_.swap(b->blocks_); 199 std::swap(can_write_to_contiguous_buffer_, 200 b->can_write_to_contiguous_buffer_); 201 std::swap(blocksize_, b->blocksize_); 202 } 203 204 void BalsaBuffer::CopyFrom(const BalsaBuffer& b) { 205 CleanupBlocksStartingFrom(0); 206 blocks_.resize(b.blocks_.size()); 207 for (Blocks::size_type i = 0; i < blocks_.size(); ++i) { 208 blocks_[i] = CopyBlock(b.blocks_[i]); 209 } 210 blocksize_ = b.blocksize_; 211 can_write_to_contiguous_buffer_ = b.can_write_to_contiguous_buffer_; 212 } 213 214 BalsaBuffer::BalsaBuffer() 215 : blocksize_(kDefaultBlocksize), can_write_to_contiguous_buffer_(true) { 216 blocks_.push_back(AllocBlock()); 217 } 218 219 BalsaBuffer::BalsaBuffer(size_t blocksize) : 220 blocksize_(blocksize), can_write_to_contiguous_buffer_(true) { 221 blocks_.push_back(AllocBlock()); 222 } 223 224 BalsaBuffer::BufferBlock BalsaBuffer::AllocBlock() { 225 return AllocCustomBlock(blocksize_); 226 } 227 228 BalsaBuffer::BufferBlock BalsaBuffer::AllocCustomBlock(size_t blocksize) { 229 return BufferBlock(new char[blocksize], blocksize, blocksize); 230 } 231 232 BalsaBuffer::BufferBlock BalsaBuffer::CopyBlock(const BufferBlock& b) { 233 BufferBlock block = b; 234 if (b.buffer == NULL) { 235 return block; 236 } 237 238 block.buffer = new char[b.buffer_size]; 239 memcpy(block.buffer, b.buffer, b.bytes_used()); 240 return block; 241 } 242 243 void BalsaBuffer::CleanupBlocksStartingFrom(Blocks::size_type start_idx) { 244 for (Blocks::size_type i = start_idx; i < blocks_.size(); ++i) { 245 delete[] blocks_[i].buffer; 246 } 247 blocks_.resize(start_idx); 248 } 249 250 BalsaHeaders::const_header_lines_key_iterator::const_header_lines_key_iterator( 251 const const_header_lines_key_iterator& other) 252 : iterator_base(other), 253 key_(other.key_) { 254 } 255 256 BalsaHeaders::const_header_lines_key_iterator::const_header_lines_key_iterator( 257 const BalsaHeaders* headers, 258 HeaderLines::size_type index, 259 const base::StringPiece& key) 260 : iterator_base(headers, index), 261 key_(key) { 262 } 263 264 BalsaHeaders::const_header_lines_key_iterator::const_header_lines_key_iterator( 265 const BalsaHeaders* headers, 266 HeaderLines::size_type index) 267 : iterator_base(headers, index) { 268 } 269 270 BalsaHeaders::BalsaHeaders() 271 : balsa_buffer_(4096), 272 content_length_(0), 273 content_length_status_(BalsaHeadersEnums::NO_CONTENT_LENGTH), 274 parsed_response_code_(0), 275 firstline_buffer_base_idx_(0), 276 whitespace_1_idx_(0), 277 non_whitespace_1_idx_(0), 278 whitespace_2_idx_(0), 279 non_whitespace_2_idx_(0), 280 whitespace_3_idx_(0), 281 non_whitespace_3_idx_(0), 282 whitespace_4_idx_(0), 283 end_of_firstline_idx_(0), 284 transfer_encoding_is_chunked_(false) { 285 } 286 287 BalsaHeaders::~BalsaHeaders() {} 288 289 void BalsaHeaders::Clear() { 290 balsa_buffer_.Clear(); 291 transfer_encoding_is_chunked_ = false; 292 content_length_ = 0; 293 content_length_status_ = BalsaHeadersEnums::NO_CONTENT_LENGTH; 294 parsed_response_code_ = 0; 295 firstline_buffer_base_idx_ = 0; 296 whitespace_1_idx_ = 0; 297 non_whitespace_1_idx_ = 0; 298 whitespace_2_idx_ = 0; 299 non_whitespace_2_idx_ = 0; 300 whitespace_3_idx_ = 0; 301 non_whitespace_3_idx_ = 0; 302 whitespace_4_idx_ = 0; 303 end_of_firstline_idx_ = 0; 304 header_lines_.clear(); 305 } 306 307 void BalsaHeaders::Swap(BalsaHeaders* other) { 308 // Protect against swapping with self. 309 if (this == other) return; 310 311 balsa_buffer_.Swap(&other->balsa_buffer_); 312 313 bool tmp_bool = transfer_encoding_is_chunked_; 314 transfer_encoding_is_chunked_ = other->transfer_encoding_is_chunked_; 315 other->transfer_encoding_is_chunked_ = tmp_bool; 316 317 size_t tmp_size_t = content_length_; 318 content_length_ = other->content_length_; 319 other->content_length_ = tmp_size_t; 320 321 BalsaHeadersEnums::ContentLengthStatus tmp_status = 322 content_length_status_; 323 content_length_status_ = other->content_length_status_; 324 other->content_length_status_ = tmp_status; 325 326 tmp_size_t = parsed_response_code_; 327 parsed_response_code_ = other->parsed_response_code_; 328 other->parsed_response_code_ = tmp_size_t; 329 330 BalsaBuffer::Blocks::size_type tmp_blk_idx = firstline_buffer_base_idx_; 331 firstline_buffer_base_idx_ = other->firstline_buffer_base_idx_; 332 other->firstline_buffer_base_idx_ = tmp_blk_idx; 333 334 tmp_size_t = whitespace_1_idx_; 335 whitespace_1_idx_ = other->whitespace_1_idx_; 336 other->whitespace_1_idx_ = tmp_size_t; 337 338 tmp_size_t = non_whitespace_1_idx_; 339 non_whitespace_1_idx_ = other->non_whitespace_1_idx_; 340 other->non_whitespace_1_idx_ = tmp_size_t; 341 342 tmp_size_t = whitespace_2_idx_; 343 whitespace_2_idx_ = other->whitespace_2_idx_; 344 other->whitespace_2_idx_ = tmp_size_t; 345 346 tmp_size_t = non_whitespace_2_idx_; 347 non_whitespace_2_idx_ = other->non_whitespace_2_idx_; 348 other->non_whitespace_2_idx_ = tmp_size_t; 349 350 tmp_size_t = whitespace_3_idx_; 351 whitespace_3_idx_ = other->whitespace_3_idx_; 352 other->whitespace_3_idx_ = tmp_size_t; 353 354 tmp_size_t = non_whitespace_3_idx_; 355 non_whitespace_3_idx_ = other->non_whitespace_3_idx_; 356 other->non_whitespace_3_idx_ = tmp_size_t; 357 358 tmp_size_t = whitespace_4_idx_; 359 whitespace_4_idx_ = other->whitespace_4_idx_; 360 other->whitespace_4_idx_ = tmp_size_t; 361 362 tmp_size_t = end_of_firstline_idx_; 363 end_of_firstline_idx_ = other->end_of_firstline_idx_; 364 other->end_of_firstline_idx_ = tmp_size_t; 365 366 swap(header_lines_, other->header_lines_); 367 } 368 369 void BalsaHeaders::CopyFrom(const BalsaHeaders& other) { 370 // Protect against copying with self. 371 if (this == &other) return; 372 373 balsa_buffer_.CopyFrom(other.balsa_buffer_); 374 transfer_encoding_is_chunked_ = other.transfer_encoding_is_chunked_; 375 content_length_ = other.content_length_; 376 content_length_status_ = other.content_length_status_; 377 parsed_response_code_ = other.parsed_response_code_; 378 firstline_buffer_base_idx_ = other.firstline_buffer_base_idx_; 379 whitespace_1_idx_ = other.whitespace_1_idx_; 380 non_whitespace_1_idx_ = other.non_whitespace_1_idx_; 381 whitespace_2_idx_ = other.whitespace_2_idx_; 382 non_whitespace_2_idx_ = other.non_whitespace_2_idx_; 383 whitespace_3_idx_ = other.whitespace_3_idx_; 384 non_whitespace_3_idx_ = other.non_whitespace_3_idx_; 385 whitespace_4_idx_ = other.whitespace_4_idx_; 386 end_of_firstline_idx_ = other.end_of_firstline_idx_; 387 header_lines_ = other.header_lines_; 388 } 389 390 void BalsaHeaders::AddAndMakeDescription(const base::StringPiece& key, 391 const base::StringPiece& value, 392 HeaderLineDescription* d) { 393 CHECK(d != NULL); 394 // + 2 to size for ": " 395 size_t line_size = key.size() + 2 + value.size(); 396 BalsaBuffer::Blocks::size_type block_buffer_idx = 0; 397 char* storage = balsa_buffer_.Reserve(line_size, &block_buffer_idx); 398 size_t base_idx = storage - GetPtr(block_buffer_idx); 399 400 char* cur_loc = storage; 401 memcpy(cur_loc, key.data(), key.size()); 402 cur_loc += key.size(); 403 *cur_loc = ':'; 404 ++cur_loc; 405 *cur_loc = ' '; 406 ++cur_loc; 407 memcpy(cur_loc, value.data(), value.size()); 408 *d = HeaderLineDescription(base_idx, 409 base_idx + key.size(), 410 base_idx + key.size() + 2, 411 base_idx + key.size() + 2 + value.size(), 412 block_buffer_idx); 413 } 414 415 void BalsaHeaders::AppendOrPrependAndMakeDescription( 416 const base::StringPiece& key, 417 const base::StringPiece& value, 418 bool append, 419 HeaderLineDescription* d) { 420 // Figure out how much space we need to reserve for the new header size. 421 size_t old_value_size = d->last_char_idx - d->value_begin_idx; 422 if (old_value_size == 0) { 423 AddAndMakeDescription(key, value, d); 424 return; 425 } 426 base::StringPiece old_value(GetPtr(d->buffer_base_idx) + d->value_begin_idx, 427 old_value_size); 428 429 BalsaBuffer::Blocks::size_type block_buffer_idx = 0; 430 // + 3 because we potentially need to add ": ", and "," to the line. 431 size_t new_size = key.size() + 3 + old_value_size + value.size(); 432 char* storage = balsa_buffer_.Reserve(new_size, &block_buffer_idx); 433 size_t base_idx = storage - GetPtr(block_buffer_idx); 434 435 base::StringPiece first_value = old_value; 436 base::StringPiece second_value = value; 437 if (!append) { // !append == prepend 438 first_value = value; 439 second_value = old_value; 440 } 441 char* cur_loc = storage; 442 memcpy(cur_loc, key.data(), key.size()); 443 cur_loc += key.size(); 444 *cur_loc = ':'; 445 ++cur_loc; 446 *cur_loc = ' '; 447 ++cur_loc; 448 memcpy(cur_loc, first_value.data(), first_value.size()); 449 cur_loc += first_value.size(); 450 *cur_loc = ','; 451 ++cur_loc; 452 memcpy(cur_loc, second_value.data(), second_value.size()); 453 454 *d = HeaderLineDescription(base_idx, 455 base_idx + key.size(), 456 base_idx + key.size() + 2, 457 base_idx + new_size, 458 block_buffer_idx); 459 } 460 461 // Removes all keys value pairs with key 'key' starting at 'start'. 462 void BalsaHeaders::RemoveAllOfHeaderStartingAt(const base::StringPiece& key, 463 HeaderLines::iterator start) { 464 while (start != header_lines_.end()) { 465 start->skip = true; 466 ++start; 467 start = GetHeaderLinesIterator(key, start); 468 } 469 } 470 471 void BalsaHeaders::HackHeader(const base::StringPiece& key, 472 const base::StringPiece& value) { 473 // See TODO in balsa_headers.h 474 const HeaderLines::iterator end = header_lines_.end(); 475 const HeaderLines::iterator begin = header_lines_.begin(); 476 HeaderLines::iterator i = GetHeaderLinesIteratorNoSkip(key, begin); 477 if (i != end) { 478 // First, remove all of the header lines including this one. We want to 479 // remove before replacing, in case our replacement ends up being appended 480 // at the end (and thus would be removed by this call) 481 RemoveAllOfHeaderStartingAt(key, i); 482 // Now add the replacement, at this location. 483 AddAndMakeDescription(key, value, &(*i)); 484 return; 485 } 486 AppendHeader(key, value); 487 } 488 489 void BalsaHeaders::HackAppendToHeader(const base::StringPiece& key, 490 const base::StringPiece& append_value) { 491 // See TODO in balsa_headers.h 492 const HeaderLines::iterator end = header_lines_.end(); 493 const HeaderLines::iterator begin = header_lines_.begin(); 494 495 HeaderLines::iterator i = GetHeaderLinesIterator(key, begin); 496 if (i == end) { 497 HackHeader(key, append_value); 498 return; 499 } 500 501 AppendOrPrependAndMakeDescription(key, append_value, true, &(*i)); 502 } 503 504 void BalsaHeaders::ReplaceOrAppendHeader(const base::StringPiece& key, 505 const base::StringPiece& value) { 506 const HeaderLines::iterator end = header_lines_.end(); 507 const HeaderLines::iterator begin = header_lines_.begin(); 508 HeaderLines::iterator i = GetHeaderLinesIterator(key, begin); 509 if (i != end) { 510 // First, remove all of the header lines including this one. We want to 511 // remove before replacing, in case our replacement ends up being appended 512 // at the end (and thus would be removed by this call) 513 RemoveAllOfHeaderStartingAt(key, i); 514 // Now, take the first instance and replace it. This will remove the 515 // 'skipped' tag if the replacement is done in-place. 516 AddAndMakeDescription(key, value, &(*i)); 517 return; 518 } 519 AppendHeader(key, value); 520 } 521 522 void BalsaHeaders::AppendHeader(const base::StringPiece& key, 523 const base::StringPiece& value) { 524 HeaderLineDescription hld; 525 AddAndMakeDescription(key, value, &hld); 526 header_lines_.push_back(hld); 527 } 528 529 void BalsaHeaders::AppendToHeader(const base::StringPiece& key, 530 const base::StringPiece& value) { 531 AppendOrPrependToHeader(key, value, true); 532 } 533 534 void BalsaHeaders::PrependToHeader(const base::StringPiece& key, 535 const base::StringPiece& value) { 536 AppendOrPrependToHeader(key, value, false); 537 } 538 539 base::StringPiece BalsaHeaders::GetValueFromHeaderLineDescription( 540 const HeaderLineDescription& line) const { 541 DCHECK_GE(line.last_char_idx, line.value_begin_idx); 542 return base::StringPiece(GetPtr(line.buffer_base_idx) + line.value_begin_idx, 543 line.last_char_idx - line.value_begin_idx); 544 } 545 546 const base::StringPiece BalsaHeaders::GetHeader( 547 const base::StringPiece& key) const { 548 DCHECK(!IsMultivaluedHeader(key)) 549 << "Header '" << key << "' may consist of multiple lines. Do not " 550 << "use BalsaHeaders::GetHeader() or you may be missing some of its " 551 << "values."; 552 const HeaderLines::const_iterator end = header_lines_.end(); 553 const HeaderLines::const_iterator begin = header_lines_.begin(); 554 HeaderLines::const_iterator i = GetConstHeaderLinesIterator(key, begin); 555 if (i == end) { 556 return base::StringPiece(); 557 } 558 return GetValueFromHeaderLineDescription(*i); 559 } 560 561 BalsaHeaders::const_header_lines_iterator BalsaHeaders::GetHeaderPosition( 562 const base::StringPiece& key) const { 563 const HeaderLines::const_iterator end = header_lines_.end(); 564 const HeaderLines::const_iterator begin = header_lines_.begin(); 565 HeaderLines::const_iterator i = GetConstHeaderLinesIterator(key, begin); 566 if (i == end) { 567 return header_lines_end(); 568 } 569 570 return const_header_lines_iterator(this, (i - begin)); 571 } 572 573 BalsaHeaders::const_header_lines_key_iterator BalsaHeaders::GetIteratorForKey( 574 const base::StringPiece& key) const { 575 HeaderLines::const_iterator i = 576 GetConstHeaderLinesIterator(key, header_lines_.begin()); 577 if (i == header_lines_.end()) { 578 return header_lines_key_end(); 579 } 580 581 const HeaderLines::const_iterator begin = header_lines_.begin(); 582 return const_header_lines_key_iterator(this, (i - begin), key); 583 } 584 585 void BalsaHeaders::AppendOrPrependToHeader(const base::StringPiece& key, 586 const base::StringPiece& value, 587 bool append) { 588 HeaderLines::iterator i = GetHeaderLinesIterator(key, header_lines_.begin()); 589 if (i == header_lines_.end()) { 590 // The header did not exist already. Instead of appending to an existing 591 // header simply append the key/value pair to the headers. 592 AppendHeader(key, value); 593 return; 594 } 595 HeaderLineDescription hld = *i; 596 597 AppendOrPrependAndMakeDescription(key, value, append, &hld); 598 599 // Invalidate the old header line and add the new one. 600 i->skip = true; 601 header_lines_.push_back(hld); 602 } 603 604 BalsaHeaders::HeaderLines::const_iterator 605 BalsaHeaders::GetConstHeaderLinesIterator( 606 const base::StringPiece& key, 607 BalsaHeaders::HeaderLines::const_iterator start) const { 608 const HeaderLines::const_iterator end = header_lines_.end(); 609 for (HeaderLines::const_iterator i = start; i != end; ++i) { 610 const HeaderLineDescription& line = *i; 611 if (line.skip) { 612 continue; 613 } 614 const size_t key_len = line.key_end_idx - line.first_char_idx; 615 616 if (key_len != key.size()) { 617 continue; 618 } 619 if (strncasecmp(GetPtr(line.buffer_base_idx) + line.first_char_idx, 620 key.data(), key_len) == 0) { 621 DCHECK_GE(line.last_char_idx, line.value_begin_idx); 622 return i; 623 } 624 } 625 return end; 626 } 627 628 BalsaHeaders::HeaderLines::iterator BalsaHeaders::GetHeaderLinesIteratorNoSkip( 629 const base::StringPiece& key, 630 BalsaHeaders::HeaderLines::iterator start) { 631 const HeaderLines::iterator end = header_lines_.end(); 632 for (HeaderLines::iterator i = start; i != end; ++i) { 633 const HeaderLineDescription& line = *i; 634 const size_t key_len = line.key_end_idx - line.first_char_idx; 635 636 if (key_len != key.size()) { 637 continue; 638 } 639 if (strncasecmp(GetPtr(line.buffer_base_idx) + line.first_char_idx, 640 key.data(), key_len) == 0) { 641 DCHECK_GE(line.last_char_idx, line.value_begin_idx); 642 return i; 643 } 644 } 645 return end; 646 } 647 648 BalsaHeaders::HeaderLines::iterator BalsaHeaders::GetHeaderLinesIterator( 649 const base::StringPiece& key, 650 BalsaHeaders::HeaderLines::iterator start) { 651 const HeaderLines::iterator end = header_lines_.end(); 652 for (HeaderLines::iterator i = start; i != end; ++i) { 653 const HeaderLineDescription& line = *i; 654 if (line.skip) { 655 continue; 656 } 657 const size_t key_len = line.key_end_idx - line.first_char_idx; 658 659 if (key_len != key.size()) { 660 continue; 661 } 662 if (strncasecmp(GetPtr(line.buffer_base_idx) + line.first_char_idx, 663 key.data(), key_len) == 0) { 664 DCHECK_GE(line.last_char_idx, line.value_begin_idx); 665 return i; 666 } 667 } 668 return end; 669 } 670 671 void BalsaHeaders::GetAllOfHeader( 672 const base::StringPiece& key, std::vector<base::StringPiece>* out) const { 673 for (const_header_lines_key_iterator it = GetIteratorForKey(key); 674 it != header_lines_end(); ++it) { 675 out->push_back(it->second); 676 } 677 } 678 679 bool BalsaHeaders::HasNonEmptyHeader(const base::StringPiece& key) const { 680 for (const_header_lines_key_iterator it = GetIteratorForKey(key); 681 it != header_lines_key_end(); ++it) { 682 if (!it->second.empty()) 683 return true; 684 } 685 return false; 686 } 687 688 void BalsaHeaders::GetAllOfHeaderAsString(const base::StringPiece& key, 689 std::string* out) const { 690 const_header_lines_iterator it = header_lines_begin(); 691 const_header_lines_iterator end = header_lines_end(); 692 693 for (; it != end; ++it) { 694 if (key == it->first) { 695 if (!out->empty()) { 696 out->append(","); 697 } 698 out->append(std::string(it->second.data(), it->second.size())); 699 } 700 } 701 } 702 703 // static 704 bool BalsaHeaders::IsMultivaluedHeader(const base::StringPiece& header) { 705 return g_multivalued_headers.find(header) != g_multivalued_headers.end(); 706 } 707 708 void BalsaHeaders::RemoveAllOfHeader(const base::StringPiece& key) { 709 HeaderLines::iterator it = GetHeaderLinesIterator(key, header_lines_.begin()); 710 RemoveAllOfHeaderStartingAt(key, it); 711 } 712 713 void BalsaHeaders::RemoveAllHeadersWithPrefix(const base::StringPiece& key) { 714 for (HeaderLines::size_type i = 0; i < header_lines_.size(); ++i) { 715 if (header_lines_[i].skip) { 716 continue; 717 } 718 HeaderLineDescription& line = header_lines_[i]; 719 const size_t key_len = line.key_end_idx - line.first_char_idx; 720 if (key_len < key.size()) { 721 // If the key given to us is longer than this header, don't consider it. 722 continue; 723 } 724 if (!strncasecmp(GetPtr(line.buffer_base_idx) + line.first_char_idx, 725 key.data(), key.size())) { 726 line.skip = true; 727 } 728 } 729 } 730 731 size_t BalsaHeaders::GetMemoryUsedLowerBound() const { 732 return (sizeof(*this) + 733 balsa_buffer_.GetTotalBufferBlockSize() + 734 header_lines_.capacity() * sizeof(HeaderLineDescription)); 735 } 736 737 size_t BalsaHeaders::GetSizeForWriteBuffer() const { 738 // First add the space required for the first line + CRLF 739 size_t write_buf_size = whitespace_4_idx_ - non_whitespace_1_idx_ + 2; 740 // Then add the space needed for each header line to write out + CRLF. 741 const HeaderLines::size_type end = header_lines_.size(); 742 for (HeaderLines::size_type i = 0; i < end; ++i) { 743 const HeaderLineDescription& line = header_lines_[i]; 744 if (!line.skip) { 745 // Add the key size and ": ". 746 write_buf_size += line.key_end_idx - line.first_char_idx + 2; 747 // Add the value size and the CRLF 748 write_buf_size += line.last_char_idx - line.value_begin_idx + 2; 749 } 750 } 751 // Finally tag on the terminal CRLF. 752 return write_buf_size + 2; 753 } 754 755 void BalsaHeaders::DumpToString(std::string* str) const { 756 const base::StringPiece firstline = first_line(); 757 const int buffer_length = 758 OriginalHeaderStreamEnd() - OriginalHeaderStreamBegin(); 759 // First check whether the header object is empty. 760 if (firstline.empty() && buffer_length == 0) { 761 str->append("\n<empty header>\n"); 762 return; 763 } 764 765 // Then check whether the header is in a partially parsed state. If so, just 766 // dump the raw data. 767 if (balsa_buffer_.can_write_to_contiguous_buffer()) { 768 base::StringAppendF(str, "\n<incomplete header len: %d>\n%.*s\n", 769 buffer_length, buffer_length, 770 OriginalHeaderStreamBegin()); 771 return; 772 } 773 774 // If the header is complete, then just dump them with the logical key value 775 // pair. 776 str->reserve(str->size() + GetSizeForWriteBuffer()); 777 base::StringAppendF(str, "\n %.*s\n", 778 static_cast<int>(firstline.size()), 779 firstline.data()); 780 BalsaHeaders::const_header_lines_iterator i = header_lines_begin(); 781 for (; i != header_lines_end(); ++i) { 782 base::StringAppendF(str, " %.*s: %.*s\n", 783 static_cast<int>(i->first.size()), i->first.data(), 784 static_cast<int>(i->second.size()), i->second.data()); 785 } 786 } 787 788 void BalsaHeaders::SetFirstLine(const base::StringPiece& line) { 789 base::StringPiece new_line = balsa_buffer_.Write(line, 790 &firstline_buffer_base_idx_); 791 whitespace_1_idx_ = new_line.data() - GetPtr(firstline_buffer_base_idx_); 792 non_whitespace_1_idx_ = whitespace_1_idx_; 793 whitespace_4_idx_ = whitespace_1_idx_ + line.size(); 794 whitespace_2_idx_ = whitespace_4_idx_; 795 non_whitespace_2_idx_ = whitespace_4_idx_; 796 whitespace_3_idx_ = whitespace_4_idx_; 797 non_whitespace_3_idx_ = whitespace_4_idx_; 798 end_of_firstline_idx_ = whitespace_4_idx_; 799 } 800 801 void BalsaHeaders::SetContentLength(size_t length) { 802 // If the content-length is already the one we want, don't do anything. 803 if (content_length_status_ == BalsaHeadersEnums::VALID_CONTENT_LENGTH && 804 content_length_ == length) { 805 return; 806 } 807 const base::StringPiece content_length(kContentLength, 808 sizeof(kContentLength) - 1); 809 // If header state indicates that there is either a content length or 810 // transfer encoding header, remove them before adding the new content 811 // length. There is always the possibility that client can manually add 812 // either header directly and cause content_length_status_ or 813 // transfer_encoding_is_chunked_ to be inconsistent with the actual header. 814 // In the interest of efficiency, however, we will assume that clients will 815 // use the header object correctly and thus we will not scan the all headers 816 // each time this function is called. 817 if (content_length_status_ != BalsaHeadersEnums::NO_CONTENT_LENGTH) { 818 RemoveAllOfHeader(content_length); 819 } else if (transfer_encoding_is_chunked_) { 820 const base::StringPiece transfer_encoding(kTransferEncoding, 821 sizeof(kTransferEncoding) - 1); 822 RemoveAllOfHeader(transfer_encoding); 823 transfer_encoding_is_chunked_ = false; 824 } 825 content_length_status_ = BalsaHeadersEnums::VALID_CONTENT_LENGTH; 826 content_length_ = length; 827 // FastUInt64ToBuffer is supposed to use a maximum of kFastToBufferSize bytes. 828 char buffer[kFastToBufferSize]; 829 int len_converted = snprintf(buffer, sizeof(buffer), "%zd", length); 830 CHECK_GT(len_converted, 0); 831 const base::StringPiece length_str(buffer, len_converted); 832 AppendHeader(content_length, length_str); 833 } 834 835 void BalsaHeaders::SetChunkEncoding(bool chunk_encode) { 836 if (transfer_encoding_is_chunked_ == chunk_encode) { 837 return; 838 } 839 if (content_length_status_ != BalsaHeadersEnums::NO_CONTENT_LENGTH && 840 chunk_encode) { 841 // Want to change to chunk encoding, but have content length. Arguably we 842 // can leave this step out, since transfer-encoding overrides 843 // content-length. 844 const base::StringPiece content_length(kContentLength, 845 sizeof(kContentLength) - 1); 846 RemoveAllOfHeader(content_length); 847 content_length_status_ = BalsaHeadersEnums::NO_CONTENT_LENGTH; 848 content_length_ = 0; 849 } 850 const base::StringPiece transfer_encoding(kTransferEncoding, 851 sizeof(kTransferEncoding) - 1); 852 if (chunk_encode) { 853 const char kChunked[] = "chunked"; 854 const base::StringPiece chunked(kChunked, sizeof(kChunked) - 1); 855 AppendHeader(transfer_encoding, chunked); 856 } else { 857 RemoveAllOfHeader(transfer_encoding); 858 } 859 transfer_encoding_is_chunked_ = chunk_encode; 860 } 861 862 // See the comment about this function in the header file for a 863 // warning about its usage. 864 void BalsaHeaders::SetFirstlineFromStringPieces( 865 const base::StringPiece& firstline_a, 866 const base::StringPiece& firstline_b, 867 const base::StringPiece& firstline_c) { 868 size_t line_size = (firstline_a.size() + 869 firstline_b.size() + 870 firstline_c.size() + 871 2); 872 char* storage = balsa_buffer_.Reserve(line_size, &firstline_buffer_base_idx_); 873 char* cur_loc = storage; 874 875 memcpy(cur_loc, firstline_a.data(), firstline_a.size()); 876 cur_loc += firstline_a.size(); 877 878 *cur_loc = ' '; 879 ++cur_loc; 880 881 memcpy(cur_loc, firstline_b.data(), firstline_b.size()); 882 cur_loc += firstline_b.size(); 883 884 *cur_loc = ' '; 885 ++cur_loc; 886 887 memcpy(cur_loc, firstline_c.data(), firstline_c.size()); 888 889 whitespace_1_idx_ = storage - GetPtr(firstline_buffer_base_idx_); 890 non_whitespace_1_idx_ = whitespace_1_idx_; 891 whitespace_2_idx_ = non_whitespace_1_idx_ + firstline_a.size(); 892 non_whitespace_2_idx_ = whitespace_2_idx_ + 1; 893 whitespace_3_idx_ = non_whitespace_2_idx_ + firstline_b.size(); 894 non_whitespace_3_idx_ = whitespace_3_idx_ + 1; 895 whitespace_4_idx_ = non_whitespace_3_idx_ + firstline_c.size(); 896 end_of_firstline_idx_ = whitespace_4_idx_; 897 } 898 899 void BalsaHeaders::SetRequestMethod(const base::StringPiece& method) { 900 // This is the first of the three parts of the firstline. 901 if (method.size() <= (whitespace_2_idx_ - non_whitespace_1_idx_)) { 902 non_whitespace_1_idx_ = whitespace_2_idx_ - method.size(); 903 char* stream_begin = GetPtr(firstline_buffer_base_idx_); 904 memcpy(stream_begin + non_whitespace_1_idx_, 905 method.data(), 906 method.size()); 907 } else { 908 // The new method is too large to fit in the space available for the old 909 // one, so we have to reformat the firstline. 910 SetFirstlineFromStringPieces(method, request_uri(), request_version()); 911 } 912 } 913 914 void BalsaHeaders::SetResponseVersion(const base::StringPiece& version) { 915 // Note: There is no difference between request_method() and 916 // response_Version(). Thus, a function to set one is equivalent to a 917 // function to set the other. We maintain two functions for this as it is 918 // much more descriptive, and makes code more understandable. 919 SetRequestMethod(version); 920 } 921 922 void BalsaHeaders::SetRequestUri(const base::StringPiece& uri) { 923 SetFirstlineFromStringPieces(request_method(), uri, request_version()); 924 } 925 926 void BalsaHeaders::SetResponseCode(const base::StringPiece& code) { 927 // Note: There is no difference between request_uri() and response_code(). 928 // Thus, a function to set one is equivalent to a function to set the other. 929 // We maintain two functions for this as it is much more descriptive, and 930 // makes code more understandable. 931 SetRequestUri(code); 932 } 933 934 void BalsaHeaders::SetParsedResponseCodeAndUpdateFirstline( 935 size_t parsed_response_code) { 936 char buffer[kFastToBufferSize]; 937 int len_converted = snprintf(buffer, sizeof(buffer), 938 "%zd", parsed_response_code); 939 CHECK_GT(len_converted, 0); 940 SetResponseCode(base::StringPiece(buffer, len_converted)); 941 } 942 943 void BalsaHeaders::SetRequestVersion(const base::StringPiece& version) { 944 // This is the last of the three parts of the firstline. 945 // Since whitespace_3_idx and non_whitespace_3_idx may point to the same 946 // place, we ensure below that any available space includes space for a 947 // litteral space (' ') character between the second component and the third 948 // component. If the space between whitespace_3_idx_ and 949 // end_of_firstline_idx_ is >= to version.size() + 1 (for the space), then we 950 // can update the firstline in-place. 951 char* stream_begin = GetPtr(firstline_buffer_base_idx_); 952 if (version.size() + 1 <= end_of_firstline_idx_ - whitespace_3_idx_) { 953 *(stream_begin + whitespace_3_idx_) = kSpaceChar; 954 non_whitespace_3_idx_ = whitespace_3_idx_ + 1; 955 whitespace_4_idx_ = non_whitespace_3_idx_ + version.size(); 956 memcpy(stream_begin + non_whitespace_3_idx_, 957 version.data(), 958 version.size()); 959 } else { 960 // The new version is to large to fit in the space available for the old 961 // one, so we have to reformat the firstline. 962 SetFirstlineFromStringPieces(request_method(), request_uri(), version); 963 } 964 } 965 966 void BalsaHeaders::SetResponseReasonPhrase(const base::StringPiece& reason) { 967 // Note: There is no difference between request_version() and 968 // response_reason_phrase(). Thus, a function to set one is equivalent to a 969 // function to set the other. We maintain two functions for this as it is 970 // much more descriptive, and makes code more understandable. 971 SetRequestVersion(reason); 972 } 973 974 } // namespace net 975
