| OLD | NEW |
|---|
| (Empty) | |
| 1 // Copyright (c) 2010 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 "web2socket_conn.h" |
| 6 |
| 7 #include <stdio.h> |
| 8 #include <stdlib.h> |
| 9 #include <string.h> |
| 10 |
| 11 #include <algorithm> |
| 12 #include <limits> |
| 13 #include <vector> |
| 14 |
| 15 #include <arpa/inet.h> |
| 16 #include <errno.h> |
| 17 #include <netinet/in.h> |
| 18 #include <signal.h> |
| 19 #include <sys/types.h> |
| 20 #include <sys/wait.h> |
| 21 |
| 22 #include "base/base64.h" |
| 23 #include "base/logging.h" |
| 24 #include "base/string_util.h" |
| 25 #include "third_party/libevent/evdns.h" |
| 26 |
| 27 namespace { |
| 28 |
| 29 const uint8_t kSpaceOctet = 0x20; |
| 30 const uint8_t kCRLF[] = "\r\n"; |
| 31 const uint8_t kCRLFCRLF[] = "\r\n\r\n"; |
| 32 |
| 33 int CountSpaces(const std::string& s) { |
| 34 int rv = 0; |
| 35 for (size_t i = 0; i < s.size(); ++i) |
| 36 rv += (s[i] == kSpaceOctet); |
| 37 return rv; |
| 38 } |
| 39 |
| 40 std::string FetchLowerCasedASCIISnippet(uint8_t* begin, uint8_t* end) { |
| 41 std::string rv; |
| 42 for (; begin < end; ++begin) { |
| 43 if (!isascii(*begin)) |
| 44 return rv; |
| 45 rv += base::ToLowerASCII(*begin); |
| 46 } |
| 47 return rv; |
| 48 } |
| 49 |
| 50 // Returns true on success. |
| 51 bool FetchDecimalDigits(const std::string& s, uint32_t* result) { |
| 52 *result = 0; |
| 53 bool got_something = false; |
| 54 for (size_t i = 0; i < s.size(); ++i) { |
| 55 if (IsAsciiDigit(s[i])) { |
| 56 got_something = true; |
| 57 if (*result > std::numeric_limits<uint32_t>::max() / 10) |
| 58 return false; |
| 59 *result *= 10; |
| 60 int digit = s[i] - '0'; |
| 61 if (*result > std::numeric_limits<uint32_t>::max() - digit) |
| 62 return false; |
| 63 *result += digit; |
| 64 } |
| 65 } |
| 66 return got_something; |
| 67 } |
| 68 |
| 69 // Returns true on success. |
| 70 bool FetchNamePort(uint8_t* begin, uint8_t* end, |
| 71 std::string* name, uint32_t* port) { |
| 72 name->assign(begin, end); |
| 73 *port = 22; |
| 74 if (begin == end) |
| 75 return false; |
| 76 for (uint8_t* pos = end; --pos != begin;) { |
| 77 if (!IsAsciiDigit(*pos)) { |
| 78 if (*pos == ':' && end - pos > 1) { |
| 79 if (!FetchDecimalDigits(std::string(pos + 1, end), port) || |
| 80 *port <= 0 || |
| 81 *port >= (1 << 16)) { |
| 82 return false; |
| 83 } |
| 84 name->assign(begin, pos); |
| 85 } |
| 86 break; |
| 87 } |
| 88 } |
| 89 return !name->empty(); |
| 90 } |
| 91 |
| 92 inline size_t strlen(const uint8_t* s) { |
| 93 return ::strlen(reinterpret_cast<const char*>(s)); |
| 94 } |
| 95 |
| 96 } // namespace |
| 97 |
| 98 Conn::Conn(Web2SocketServ* master) |
| 99 : master_(master), |
| 100 phase_(PHASE_WAIT_HANDSHAKE), |
| 101 destresolution_ipv4_failed_(false), |
| 102 destresolution_ipv6_failed_(false) { |
| 103 while (token_map_.find(last_token_) != token_map_.end()) { |
| 104 token_ = last_token_ = |
| 105 reinterpret_cast<Token>(reinterpret_cast<size_t>(last_token_) + 1); |
| 106 } |
| 107 token_map_[token_] = this; |
| 108 // Schedule timeout for initial phase of connection. |
| 109 evtimer_set(&destconnect_timeout_event_, |
| 110 &OnDestConnectTimeout, token_); |
| 111 event_base_set(master_->evbase(), |
| 112 &destconnect_timeout_event_); |
| 113 struct timeval tv; |
| 114 tv.tv_sec = 30; |
| 115 tv.tv_usec = 0; |
| 116 evtimer_add(&destconnect_timeout_event_, &tv); |
| 117 } |
| 118 |
| 119 Conn::~Conn() { |
| 120 phase_ = PHASE_DEFUNCT; |
| 121 event_del(&destconnect_timeout_event_); |
| 122 if (token_map_[token_] == this) |
| 123 token_map_.erase(token_); |
| 124 } |
| 125 |
| 126 Conn* Conn::Get(Token token) { |
| 127 TokenMap::iterator it = token_map_.find(token); |
| 128 if (it == token_map_.end()) |
| 129 return NULL; |
| 130 Conn* cs = it->second; |
| 131 if (cs == NULL || |
| 132 cs->token_ != token || |
| 133 cs->master_ == NULL || |
| 134 cs->phase_ < 0 || |
| 135 cs->phase_ > PHASE_SHUT || |
| 136 !cs->master_->IsConnSane(cs)) { |
| 137 return NULL; |
| 138 } |
| 139 return cs; |
| 140 } |
| 141 |
| 142 void Conn::Shut() { |
| 143 if (phase_ >= PHASE_SHUT) |
| 144 return; |
| 145 master_->MarkConnImportance(this, false); |
| 146 if (primchan_.sock >= 0 && primchan_.bev != NULL) { |
| 147 static const uint8_t closing_handshake[9] = { 0 }; |
| 148 bufferevent_write(primchan_.bev, |
| 149 closing_handshake, sizeof(closing_handshake)); |
| 150 } |
| 151 phase_ = PHASE_SHUT; |
| 152 } |
| 153 |
| 154 Conn::Status Conn::ConsumeHeader(struct evbuffer* evb) { |
| 155 uint8_t* buf = EVBUFFER_DATA(evb); |
| 156 size_t buf_size = EVBUFFER_LENGTH(evb); |
| 157 |
| 158 static const uint8_t kGetMagic[] = "GET /echo "; |
| 159 static const uint8_t kKeyValueDelimiter[] = ": "; |
| 160 |
| 161 if (buf_size <= 0) |
| 162 return STATUS_INCOMPLETE; |
| 163 if (!buf) |
| 164 return STATUS_ABORT; |
| 165 if (!std::equal(buf, buf + std::min(buf_size, strlen(kGetMagic)), |
| 166 kGetMagic)) { |
| 167 // Data head does not match what is expected. |
| 168 return STATUS_ABORT; |
| 169 } |
| 170 |
| 171 if (buf_size >= Web2SocketServ::kReadBufferLimit) |
| 172 return STATUS_ABORT; |
| 173 uint8_t* buf_end = buf + buf_size; |
| 174 uint8_t* term_pos = std::search(buf, buf_end, kCRLFCRLF, |
| 175 kCRLFCRLF + strlen(kCRLFCRLF)); |
| 176 uint8_t key3[8]; // Notation (key3) matches websocket RFC. |
| 177 if (buf_end - term_pos < |
| 178 static_cast<ptrdiff_t>(strlen(kCRLFCRLF) + sizeof(key3))) { |
| 179 return STATUS_INCOMPLETE; |
| 180 } |
| 181 term_pos += strlen(kCRLFCRLF); |
| 182 memcpy(key3, term_pos, sizeof(key3)); |
| 183 term_pos += sizeof(key3); |
| 184 // First line is "GET /echo" line, so we skip it. |
| 185 uint8_t* pos = std::search(buf, term_pos, kCRLF, kCRLF + strlen(kCRLF)); |
| 186 if (pos == term_pos) |
| 187 return STATUS_ABORT; |
| 188 for (;;) { |
| 189 pos += strlen(kCRLF); |
| 190 if (term_pos - pos < |
| 191 static_cast<ptrdiff_t>(sizeof(key3) + strlen(kCRLF))) { |
| 192 return STATUS_ABORT; |
| 193 } |
| 194 if (term_pos - pos == |
| 195 static_cast<ptrdiff_t>(sizeof(key3) + strlen(kCRLF))) { |
| 196 break; |
| 197 } |
| 198 uint8_t* npos = std::search(pos, term_pos, kKeyValueDelimiter, |
| 199 kKeyValueDelimiter + strlen(kKeyValueDelimiter))
; |
| 200 if (npos == term_pos) |
| 201 return STATUS_ABORT; |
| 202 std::string key = FetchLowerCasedASCIISnippet(pos, npos); |
| 203 pos = std::search(npos += strlen(kKeyValueDelimiter), term_pos, |
| 204 kCRLF, kCRLF + strlen(kCRLF)); |
| 205 if (pos == term_pos) |
| 206 return STATUS_ABORT; |
| 207 if (!key.empty()) |
| 208 header_fields_[key] = FetchLowerCasedASCIISnippet(npos, pos); |
| 209 } |
| 210 |
| 211 // Values of Upgrade and Connection fields are hardcoded in the protocol. |
| 212 if (header_fields_["upgrade"] != "websocket" || |
| 213 header_fields_["connection"] != "upgrade") { |
| 214 return STATUS_ABORT; |
| 215 } |
| 216 |
| 217 if (!master_->origin().empty() && |
| 218 master_->origin() != "any") { |
| 219 if (header_fields_["origin"] != master_->origin()) |
| 220 return STATUS_ABORT; |
| 221 } |
| 222 |
| 223 static const std::string kSecKey1 = "sec-websocket-key1"; |
| 224 static const std::string kSecKey2 = "sec-websocket-key2"; |
| 225 uint32_t key_number1, key_number2; |
| 226 if (!FetchDecimalDigits(header_fields_[kSecKey1], |
| 227 &key_number1) || |
| 228 !FetchDecimalDigits(header_fields_[kSecKey2], |
| 229 &key_number2)) { |
| 230 return STATUS_ABORT; |
| 231 } |
| 232 |
| 233 // We limit incoming header size so following numbers shall not be too high. |
| 234 int spaces1 = CountSpaces(header_fields_[kSecKey1]); |
| 235 int spaces2 = CountSpaces(header_fields_[kSecKey2]); |
| 236 if (spaces1 == 0 || |
| 237 spaces2 == 0 || |
| 238 key_number1 % spaces1 != 0 || |
| 239 key_number2 % spaces2 != 0) { |
| 240 return STATUS_ABORT; |
| 241 } |
| 242 |
| 243 uint8_t challenge[4 + 4 + sizeof(key3)]; |
| 244 uint32_t part1 = htonl(key_number1 / spaces1); |
| 245 uint32_t part2 = htonl(key_number2 / spaces2); |
| 246 memcpy(challenge, &part1, 4); |
| 247 memcpy(challenge + 4, &part2, 4); |
| 248 memcpy(challenge + sizeof(challenge) - sizeof(key3), key3, sizeof(key3)); |
| 249 MD5Sum(challenge, sizeof(challenge), &handshake_response_); |
| 250 |
| 251 evbuffer_drain(evb, term_pos - buf); |
| 252 return STATUS_OK; |
| 253 } |
| 254 |
| 255 bool Conn::EmitHandshake(struct bufferevent* bev) { |
| 256 std::vector<std::string> boilerplate; |
| 257 boilerplate.push_back("HTTP/1.1 101 WebSocket Protocol Handshake"); |
| 258 boilerplate.push_back("Upgrade: WebSocket"); |
| 259 boilerplate.push_back("Connection: Upgrade"); |
| 260 |
| 261 { |
| 262 // Take care of Location field. |
| 263 char buf[128]; |
| 264 int rv = snprintf(buf, sizeof(buf), |
| 265 "Sec-WebSocket-Location: ws://%s/echo", |
| 266 header_fields_["host"].c_str()); |
| 267 if (rv <= 0 || rv + 0u >= sizeof(buf)) |
| 268 return false; |
| 269 boilerplate.push_back(buf); |
| 270 } |
| 271 { |
| 272 // Take care of Origin field. |
| 273 if (header_fields_.find("origin") != header_fields_.end()) { |
| 274 char buf[128]; |
| 275 int rv = snprintf(buf, sizeof(buf), |
| 276 "Sec-WebSocket-Origin: %s", |
| 277 header_fields_["origin"].c_str()); |
| 278 if (rv <= 0 || rv + 0u >= sizeof(buf)) |
| 279 return false; |
| 280 boilerplate.push_back(buf); |
| 281 } |
| 282 } |
| 283 |
| 284 boilerplate.push_back(""); |
| 285 for (size_t i = 0; i < boilerplate.size(); ++i) { |
| 286 if (bufferevent_write(bev, boilerplate[i].c_str(), |
| 287 boilerplate[i].size()) || |
| 288 bufferevent_write(bev, kCRLF, strlen(kCRLF))) { |
| 289 return false; |
| 290 } |
| 291 } |
| 292 return !bufferevent_write(bev, &handshake_response_, |
| 293 sizeof(handshake_response_)); |
| 294 } |
| 295 |
| 296 Conn::Status Conn::ConsumeDestframe(struct evbuffer* evb) { |
| 297 uint8_t* buf = EVBUFFER_DATA(evb); |
| 298 size_t buf_size = EVBUFFER_LENGTH(evb); |
| 299 |
| 300 if (buf_size < 1) |
| 301 return STATUS_INCOMPLETE; |
| 302 if (buf[0] != 0) |
| 303 return STATUS_ABORT; |
| 304 if (buf_size < 1 + 1) |
| 305 return STATUS_INCOMPLETE; |
| 306 uint8_t* buf_end = buf + buf_size; |
| 307 uint8_t* term_pos = std::find(buf + 1, buf_end, 0xff); |
| 308 if (term_pos == buf_end) { |
| 309 if (buf_size >= Web2SocketServ::kReadBufferLimit) { |
| 310 // So big and still worth nothing. |
| 311 return STATUS_ABORT; |
| 312 } |
| 313 return STATUS_INCOMPLETE; |
| 314 } |
| 315 if (!FetchNamePort(buf + 1, term_pos, &destname_, &destport_)) |
| 316 return STATUS_ABORT; |
| 317 evbuffer_drain(evb, term_pos - buf + 1); |
| 318 return STATUS_OK; |
| 319 } |
| 320 |
| 321 Conn::Status Conn::ConsumeFrameHeader(struct evbuffer* evb) { |
| 322 uint8_t* buf = EVBUFFER_DATA(evb); |
| 323 size_t buf_size = EVBUFFER_LENGTH(evb); |
| 324 |
| 325 if (buf_size < 1) |
| 326 return STATUS_INCOMPLETE; |
| 327 if (buf[0] != 0) |
| 328 return STATUS_ABORT; |
| 329 evbuffer_drain(evb, 1); |
| 330 return STATUS_OK; |
| 331 } |
| 332 |
| 333 Conn::Status Conn::ProcessFrameData(struct evbuffer* evb) { |
| 334 uint8_t* buf = EVBUFFER_DATA(evb); |
| 335 size_t buf_size = EVBUFFER_LENGTH(evb); |
| 336 |
| 337 if (buf_size < 1) |
| 338 return STATUS_INCOMPLETE; |
| 339 uint8_t* buf_end = buf + buf_size; |
| 340 uint8_t* term_pos = std::find(buf, buf_end, 0xff); |
| 341 bool term_detected = (term_pos != buf_end); |
| 342 if (term_detected) |
| 343 buf_size = term_pos - buf; |
| 344 switch (phase_) { |
| 345 case PHASE_INSIDE_FRAME_BASE64: { |
| 346 if (term_detected && buf_size % 4) { |
| 347 // base64 is encoded in chunks of 4 bytes. |
| 348 return STATUS_ABORT; |
| 349 } |
| 350 if (buf_size < 4) { |
| 351 DCHECK(!term_detected); |
| 352 return STATUS_INCOMPLETE; |
| 353 } |
| 354 size_t bytes_to_process_atm = (buf_size / 4) * 4; |
| 355 std::string out_bytes; |
| 356 base::Base64Decode(std::string(buf, buf + bytes_to_process_atm), |
| 357 &out_bytes); |
| 358 evbuffer_drain(evb, bytes_to_process_atm); |
| 359 DCHECK(destchan_.bev != NULL); |
| 360 if (bufferevent_write(destchan_.bev, |
| 361 out_bytes.c_str(), out_bytes.size())) { |
| 362 return STATUS_ABORT; |
| 363 } |
| 364 break; |
| 365 } |
| 366 case PHASE_INSIDE_FRAME_SKIP: { |
| 367 evbuffer_drain(evb, buf_size); |
| 368 break; |
| 369 } |
| 370 default: { |
| 371 return STATUS_ABORT; |
| 372 } |
| 373 } |
| 374 if (term_detected) { |
| 375 evbuffer_drain(evb, 1); |
| 376 return STATUS_OK; |
| 377 } |
| 378 return STATUS_INCOMPLETE; |
| 379 } |
| 380 |
| 381 bool Conn::TryConnectDest(const struct sockaddr* addr, |
| 382 socklen_t addrlen) { |
| 383 if (destchan_.sock >= 0 || |
| 384 destchan_.bev != NULL) { |
| 385 return false; |
| 386 } |
| 387 destchan_.sock = socket(addr->sa_family, SOCK_STREAM, 0); |
| 388 if (destchan_.sock < 0) |
| 389 return false; |
| 390 if (!Web2SocketServ::SetNonBlock(destchan_.sock)) |
| 391 return false; |
| 392 if (connect(destchan_.sock, addr, addrlen)) { |
| 393 if (errno != EINPROGRESS) |
| 394 return false; |
| 395 } |
| 396 destchan_.bev = bufferevent_new(destchan_.sock, |
| 397 &OnDestchanRead, |
| 398 &OnDestchanWrite, |
| 399 &OnDestchanError, |
| 400 token_); |
| 401 if (destchan_.bev == NULL) |
| 402 return false; |
| 403 if (bufferevent_base_set(master_->evbase(), destchan_.bev)) |
| 404 return false; |
| 405 bufferevent_setwatermark(destchan_.bev, EV_READ, |
| 406 0, Web2SocketServ::kReadBufferLimit); |
| 407 return !bufferevent_enable(destchan_.bev, EV_READ | EV_WRITE); |
| 408 } |
| 409 |
| 410 // static |
| 411 void Conn::OnPrimchanRead(struct bufferevent* bev, Token token) { |
| 412 Conn* cs = Conn::Get(token); |
| 413 if (bev == NULL || |
| 414 cs == NULL || |
| 415 bev != cs->primchan_.bev) { |
| 416 // Sanity check failed. |
| 417 return; |
| 418 } |
| 419 if (EVBUFFER_LENGTH(EVBUFFER_INPUT(bev)) <= 0) |
| 420 return; |
| 421 cs->master_->MarkConnImportance(cs, true); |
| 422 for (;;) { |
| 423 switch (cs->phase_) { |
| 424 case PHASE_WAIT_HANDSHAKE: { |
| 425 switch (cs->ConsumeHeader(EVBUFFER_INPUT(bev))) { |
| 426 case STATUS_OK: { |
| 427 break; |
| 428 } |
| 429 case STATUS_INCOMPLETE: { |
| 430 return; |
| 431 } |
| 432 case STATUS_ABORT: |
| 433 default: { |
| 434 cs->master_->ZapConn(cs); |
| 435 return; |
| 436 } |
| 437 } |
| 438 // Header consumed OK. Do respond. |
| 439 if (!cs->EmitHandshake(bev)) { |
| 440 cs->master_->ZapConn(cs); |
| 441 return; |
| 442 } |
| 443 cs->phase_ = PHASE_WAIT_DESTFRAME; |
| 444 return; |
| 445 } |
| 446 case PHASE_WAIT_DESTFRAME: { |
| 447 switch (cs->ConsumeDestframe(EVBUFFER_INPUT(bev))) { |
| 448 case STATUS_OK: { |
| 449 { |
| 450 struct sockaddr_in sa; |
| 451 memset(&sa, 0, sizeof(sa)); |
| 452 sa.sin_port = htons(cs->destport_); |
| 453 if (inet_pton(sa.sin_family = AF_INET, |
| 454 cs->destname_.c_str(), |
| 455 &sa.sin_addr) == 1) { |
| 456 // valid IPv4 address supplied. |
| 457 if (cs->TryConnectDest((struct sockaddr*)&sa, sizeof(sa))) { |
| 458 cs->phase_ = PHASE_WAIT_DESTCONNECT; |
| 459 return; |
| 460 } |
| 461 } |
| 462 } |
| 463 { |
| 464 if (cs->destname_.size() >= 2 && |
| 465 cs->destname_[0] == '[' && |
| 466 cs->destname_[cs->destname_.size() - 1] == ']') { |
| 467 // Literal IPv6 address in brackets. |
| 468 cs->destname_ = |
| 469 cs->destname_.substr(1, cs->destname_.size() - 2); |
| 470 } |
| 471 struct sockaddr_in6 sa; |
| 472 memset(&sa, 0, sizeof(sa)); |
| 473 sa.sin6_port = htons(cs->destport_); |
| 474 if (inet_pton(sa.sin6_family = AF_INET6, |
| 475 cs->destname_.c_str(), |
| 476 &sa.sin6_addr) == 1) { |
| 477 // valid IPv6 address supplied. |
| 478 if (cs->TryConnectDest((struct sockaddr*)&sa, sizeof(sa))) { |
| 479 cs->phase_ = PHASE_WAIT_DESTCONNECT; |
| 480 return; |
| 481 } |
| 482 } |
| 483 } |
| 484 // Try to asynchronously perform DNS resolution. |
| 485 evdns_resolve_ipv4(cs->destname_.c_str(), 0, |
| 486 &OnDestResolutionIPv4, token); |
| 487 evdns_resolve_ipv6(cs->destname_.c_str(), 0, |
| 488 &OnDestResolutionIPv6, token); |
| 489 cs->phase_ = PHASE_WAIT_DESTCONNECT; |
| 490 return; |
| 491 } |
| 492 case STATUS_INCOMPLETE: { |
| 493 return; |
| 494 } |
| 495 case STATUS_ABORT: |
| 496 default: { |
| 497 cs->Shut(); |
| 498 return; |
| 499 } |
| 500 } |
| 501 } |
| 502 case PHASE_WAIT_DESTCONNECT: { |
| 503 if (EVBUFFER_LENGTH(EVBUFFER_INPUT(bev)) >= |
| 504 Web2SocketServ::kReadBufferLimit) { |
| 505 cs->Shut(); |
| 506 } |
| 507 return; |
| 508 } |
| 509 case PHASE_OUTSIDE_FRAME: { |
| 510 switch (cs->ConsumeFrameHeader(EVBUFFER_INPUT(bev))) { |
| 511 case STATUS_OK: { |
| 512 cs->phase_ = PHASE_INSIDE_FRAME_BASE64; |
| 513 // Process remaining data if any. |
| 514 break; |
| 515 } |
| 516 case STATUS_SKIP: { |
| 517 cs->phase_ = PHASE_INSIDE_FRAME_SKIP; |
| 518 // Process remaining data if any. |
| 519 break; |
| 520 } |
| 521 case STATUS_INCOMPLETE: { |
| 522 return; |
| 523 } |
| 524 case STATUS_ABORT: |
| 525 default: { |
| 526 cs->Shut(); |
| 527 return; |
| 528 } |
| 529 } |
| 530 break; |
| 531 } |
| 532 case PHASE_INSIDE_FRAME_BASE64: |
| 533 case PHASE_INSIDE_FRAME_SKIP: { |
| 534 switch (cs->ProcessFrameData(EVBUFFER_INPUT(bev))) { |
| 535 case STATUS_OK: { |
| 536 cs->phase_ = PHASE_OUTSIDE_FRAME; |
| 537 // Handle remaining data if any. |
| 538 break; |
| 539 } |
| 540 case STATUS_INCOMPLETE: { |
| 541 return; |
| 542 } |
| 543 case STATUS_ABORT: |
| 544 default: { |
| 545 cs->Shut(); |
| 546 return; |
| 547 } |
| 548 } |
| 549 break; |
| 550 } |
| 551 case PHASE_SHUT: { |
| 552 evbuffer_drain(EVBUFFER_INPUT(bev), |
| 553 EVBUFFER_LENGTH(EVBUFFER_INPUT(bev))); |
| 554 return; |
| 555 } |
| 556 case PHASE_DEFUNCT: |
| 557 default: { |
| 558 // Must not reach here. |
| 559 cs->master_->ZapConn(cs); |
| 560 return; |
| 561 } |
| 562 } |
| 563 } |
| 564 } |
| 565 |
| 566 // static |
| 567 void Conn::OnPrimchanWrite(struct bufferevent* bev, Token token) { |
| 568 Conn* cs = Conn::Get(token); |
| 569 if (bev == NULL || |
| 570 cs == NULL || |
| 571 bev != cs->primchan_.bev) { |
| 572 // Sanity check failed. |
| 573 return; |
| 574 } |
| 575 if (cs->phase_ >= PHASE_SHUT) { |
| 576 cs->master_->ZapConn(cs); |
| 577 return; |
| 578 } |
| 579 if (cs->phase_ > PHASE_WAIT_DESTCONNECT) |
| 580 OnDestchanRead(cs->destchan_.bev, token); |
| 581 } |
| 582 |
| 583 // static |
| 584 void Conn::OnPrimchanError(struct bufferevent* bev, |
| 585 short what, Token token) { |
| 586 Conn* cs = Conn::Get(token); |
| 587 if (bev == NULL || |
| 588 cs == NULL || |
| 589 bev != cs->primchan_.bev) { |
| 590 // Sanity check failed. |
| 591 return; |
| 592 } |
| 593 if (cs->phase_ >= PHASE_SHUT) |
| 594 cs->master_->ZapConn(cs); |
| 595 else |
| 596 cs->Shut(); |
| 597 } |
| 598 |
| 599 // static |
| 600 void Conn::OnDestResolutionIPv4(int result, char type, |
| 601 int count, int ttl, |
| 602 void* addr_list, Token token) { |
| 603 Conn* cs = Conn::Get(token); |
| 604 if (cs == NULL) { |
| 605 // Sanity check failed. |
| 606 return; |
| 607 } |
| 608 if (cs->phase_ != PHASE_WAIT_DESTCONNECT) |
| 609 return; |
| 610 if (result == DNS_ERR_NONE && |
| 611 count >= 1 && |
| 612 addr_list != NULL && |
| 613 type == DNS_IPv4_A) { |
| 614 for (int i = 0; i < count; ++i) { |
| 615 struct sockaddr_in sa; |
| 616 memset(&sa, 0, sizeof(sa)); |
| 617 sa.sin_family = AF_INET; |
| 618 sa.sin_port = htons(cs->destport_); |
| 619 DCHECK(sizeof(sa.sin_addr) == sizeof(struct in_addr)); |
| 620 memcpy(&sa.sin_addr, |
| 621 static_cast<struct in_addr*>(addr_list) + i, |
| 622 sizeof(sa.sin_addr)); |
| 623 if (cs->TryConnectDest((struct sockaddr*)&sa, sizeof(sa))) |
| 624 return; |
| 625 } |
| 626 } |
| 627 cs->destresolution_ipv4_failed_ = true; |
| 628 if (cs->destresolution_ipv4_failed_ && cs->destresolution_ipv6_failed_) |
| 629 cs->Shut(); |
| 630 } |
| 631 |
| 632 // static |
| 633 void Conn::OnDestResolutionIPv6(int result, char type, |
| 634 int count, int ttl, |
| 635 void* addr_list, Token token) { |
| 636 Conn* cs = Conn::Get(token); |
| 637 if (cs == NULL) { |
| 638 // Sanity check failed. |
| 639 return; |
| 640 } |
| 641 if (cs->phase_ != PHASE_WAIT_DESTCONNECT) |
| 642 return; |
| 643 if (result == DNS_ERR_NONE && |
| 644 count >= 1 && |
| 645 addr_list != NULL && |
| 646 type == DNS_IPv6_AAAA) { |
| 647 for (int i = 0; i < count; ++i) { |
| 648 struct sockaddr_in6 sa; |
| 649 memset(&sa, 0, sizeof(sa)); |
| 650 sa.sin6_family = AF_INET6; |
| 651 sa.sin6_port = htons(cs->destport_); |
| 652 DCHECK(sizeof(sa.sin6_addr) == sizeof(struct in6_addr)); |
| 653 memcpy(&sa.sin6_addr, |
| 654 static_cast<struct in6_addr*>(addr_list) + i, |
| 655 sizeof(sa.sin6_addr)); |
| 656 if (cs->TryConnectDest((struct sockaddr*)&sa, sizeof(sa))) |
| 657 return; |
| 658 } |
| 659 } |
| 660 cs->destresolution_ipv6_failed_ = true; |
| 661 if (cs->destresolution_ipv4_failed_ && cs->destresolution_ipv6_failed_) |
| 662 cs->Shut(); |
| 663 } |
| 664 |
| 665 // static |
| 666 void Conn::OnDestConnectTimeout(int, short, Token token) { |
| 667 Conn* cs = Conn::Get(token); |
| 668 if (cs == NULL) { |
| 669 // Sanity check failed. |
| 670 } |
| 671 if (cs->phase_ > PHASE_WAIT_DESTCONNECT) |
| 672 return; |
| 673 cs->Shut(); |
| 674 } |
| 675 |
| 676 // static |
| 677 void Conn::OnDestchanRead(struct bufferevent* bev, Token token) { |
| 678 Conn* cs = Conn::Get(token); |
| 679 if (bev == NULL || |
| 680 cs == NULL || |
| 681 bev != cs->destchan_.bev) { |
| 682 // Sanity check failed. |
| 683 return; |
| 684 } |
| 685 if (EVBUFFER_LENGTH(EVBUFFER_INPUT(bev)) <= 0) |
| 686 return; |
| 687 if (cs->primchan_.bev == NULL) { |
| 688 cs->master_->ZapConn(cs); |
| 689 return; |
| 690 } |
| 691 cs->master_->MarkConnImportance(cs, true); |
| 692 std::string out_bytes; |
| 693 base::Base64Encode( |
| 694 std::string( |
| 695 static_cast<const char*>(static_cast<void*>( |
| 696 EVBUFFER_DATA(EVBUFFER_INPUT(bev)))), |
| 697 EVBUFFER_LENGTH(EVBUFFER_INPUT(bev))), |
| 698 &out_bytes); |
| 699 evbuffer_drain(EVBUFFER_INPUT(bev), EVBUFFER_LENGTH(EVBUFFER_INPUT(bev))); |
| 700 static const uint8_t frame_header[] = { 0x00 }; |
| 701 static const uint8_t frame_terminator[] = { 0xff }; |
| 702 if (bufferevent_write(cs->primchan_.bev, |
| 703 frame_header, sizeof(frame_header)) || |
| 704 bufferevent_write(cs->primchan_.bev, |
| 705 out_bytes.c_str(), out_bytes.size()) || |
| 706 bufferevent_write(cs->primchan_.bev, |
| 707 frame_terminator, sizeof(frame_terminator))) { |
| 708 cs->Shut(); |
| 709 } |
| 710 } |
| 711 |
| 712 // static |
| 713 void Conn::OnDestchanWrite(struct bufferevent* bev, Token token) { |
| 714 Conn* cs = Conn::Get(token); |
| 715 if (bev == NULL || |
| 716 cs == NULL || |
| 717 bev != cs->destchan_.bev) { |
| 718 // Sanity check failed. |
| 719 return; |
| 720 } |
| 721 if (cs->phase_ == PHASE_WAIT_DESTCONNECT) |
| 722 cs->phase_ = PHASE_OUTSIDE_FRAME; |
| 723 OnPrimchanRead(cs->primchan_.bev, token); |
| 724 } |
| 725 |
| 726 // static |
| 727 void Conn::OnDestchanError(struct bufferevent* bev, |
| 728 short what, Token token) { |
| 729 Conn* cs = Conn::Get(token); |
| 730 if (bev == NULL || |
| 731 cs == NULL || |
| 732 bev != cs->destchan_.bev) { |
| 733 // Sanity check failed. |
| 734 return; |
| 735 } |
| 736 if (cs->phase_ >= PHASE_SHUT) |
| 737 cs->master_->ZapConn(cs); |
| 738 else |
| 739 cs->Shut(); |
| 740 } |
| 741 |
| 742 Conn::Token Conn::last_token_ = 0; |
| 743 Conn::TokenMap Conn::token_map_; |
| OLD | NEW |
|---|
Chromium Code Reviews
