Split ByteBuffer into writer/reader objects.

webrtc/base/socketadapters.cc

 /*
  *  Copyright 2004 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 543 matching lines @@
   }
 }
 
 void AsyncSocksProxySocket::OnConnectEvent(AsyncSocket* socket) {
   SendHello();
 }
 
 void AsyncSocksProxySocket::ProcessInput(char* data, size_t* len) {
   ASSERT(state_ < SS_TUNNEL);
 
-  ByteBuffer response(data, *len);
+  ByteBufferReader response(data, *len);
 
   if (state_ == SS_HELLO) {
     uint8_t ver, method;
     if (!response.ReadUInt8(&ver) ||
         !response.ReadUInt8(&method))
       return;
 
     if (ver != 5) {
       Error(0);
       return;
@@ skipping 56 matching lines @@
     } else {
       Error(0);
       return;
     }
 
     state_ = SS_TUNNEL;
   }
 
   // Consume parsed data
   *len = response.Length();
-  memcpy(data, response.Data(), *len);
+  memmove(data, response.Data(), *len);
 
   if (state_ != SS_TUNNEL)
     return;
 
   bool remainder = (*len > 0);
   BufferInput(false);
   SignalConnectEvent(this);
 
   // FIX: if SignalConnect causes the socket to be destroyed, we are in trouble
   if (remainder)
     SignalReadEvent(this);  // TODO: signal this??
 }
 
 void AsyncSocksProxySocket::SendHello() {
-  ByteBuffer request;
+  ByteBufferWriter request;
   request.WriteUInt8(5);    // Socks Version
   if (user_.empty()) {
     request.WriteUInt8(1);  // Authentication Mechanisms
     request.WriteUInt8(0);  // No authentication
   } else {
     request.WriteUInt8(2);  // Authentication Mechanisms
     request.WriteUInt8(0);  // No authentication
     request.WriteUInt8(2);  // Username/Password
   }
   DirectSend(request.Data(), request.Length());
   state_ = SS_HELLO;
 }
 
 void AsyncSocksProxySocket::SendAuth() {
-  ByteBuffer request;
+  ByteBufferWriter request;
   request.WriteUInt8(1);           // Negotiation Version
   request.WriteUInt8(static_cast<uint8_t>(user_.size()));
   request.WriteString(user_);      // Username
   request.WriteUInt8(static_cast<uint8_t>(pass_.GetLength()));
   size_t len = pass_.GetLength() + 1;
   char * sensitive = new char[len];
   pass_.CopyTo(sensitive, true);
   request.WriteString(sensitive);  // Password
   memset(sensitive, 0, len);
   delete [] sensitive;
   DirectSend(request.Data(), request.Length());
   state_ = SS_AUTH;
 }
 
 void AsyncSocksProxySocket::SendConnect() {
-  ByteBuffer request;
+  ByteBufferWriter request;
   request.WriteUInt8(5);              // Socks Version
   request.WriteUInt8(1);              // CONNECT
   request.WriteUInt8(0);              // Reserved
   if (dest_.IsUnresolvedIP()) {
     std::string hostname = dest_.hostname();
     request.WriteUInt8(3);            // DOMAINNAME
     request.WriteUInt8(static_cast<uint8_t>(hostname.size()));
     request.WriteString(hostname);    // Destination Hostname
   } else {
     request.WriteUInt8(1);            // IPV4
@@ skipping 14 matching lines @@
 
 AsyncSocksProxyServerSocket::AsyncSocksProxyServerSocket(AsyncSocket* socket)
     : AsyncProxyServerSocket(socket, kBufferSize), state_(SS_HELLO) {
   BufferInput(true);
 }
 
 void AsyncSocksProxyServerSocket::ProcessInput(char* data, size_t* len) {
   // TODO: See if the whole message has arrived
   ASSERT(state_ < SS_CONNECT_PENDING);
 
-  ByteBuffer response(data, *len);
+  ByteBufferReader response(data, *len);
   if (state_ == SS_HELLO) {
     HandleHello(&response);
   } else if (state_ == SS_AUTH) {
     HandleAuth(&response);
   } else if (state_ == SS_CONNECT) {
     HandleConnect(&response);
   }
 
   // Consume parsed data
   *len = response.Length();
-  memcpy(data, response.Data(), *len);
+  memmove(data, response.Data(), *len);
 }
 
-void AsyncSocksProxyServerSocket::DirectSend(const ByteBuffer& buf) {
+void AsyncSocksProxyServerSocket::DirectSend(const ByteBufferWriter& buf) {
   BufferedReadAdapter::DirectSend(buf.Data(), buf.Length());
 }
 
-void AsyncSocksProxyServerSocket::HandleHello(ByteBuffer* request) {
+void AsyncSocksProxyServerSocket::HandleHello(ByteBufferReader* request) {
   uint8_t ver, num_methods;
   if (!request->ReadUInt8(&ver) ||
       !request->ReadUInt8(&num_methods)) {
     Error(0);
     return;
   }
 
   if (ver != 5) {
     Error(0);
     return;
@@ skipping 11 matching lines @@
   if (method == 0) {
     state_ = SS_CONNECT;
   } else if (method == 2) {
     state_ = SS_AUTH;
   } else {
     state_ = SS_ERROR;
   }
 }
 
 void AsyncSocksProxyServerSocket::SendHelloReply(uint8_t method) {
-  ByteBuffer response;
+  ByteBufferWriter response;
   response.WriteUInt8(5);  // Socks Version
   response.WriteUInt8(method);  // Auth method
   DirectSend(response);
 }
 
-void AsyncSocksProxyServerSocket::HandleAuth(ByteBuffer* request) {
+void AsyncSocksProxyServerSocket::HandleAuth(ByteBufferReader* request) {
   uint8_t ver, user_len, pass_len;
   std::string user, pass;
   if (!request->ReadUInt8(&ver) ||
       !request->ReadUInt8(&user_len) ||
       !request->ReadString(&user, user_len) ||
       !request->ReadUInt8(&pass_len) ||
       !request->ReadString(&pass, pass_len)) {
     Error(0);
     return;
   }
 
   // TODO: Allow for checking of credentials.
   SendAuthReply(0);
   state_ = SS_CONNECT;
 }
 
 void AsyncSocksProxyServerSocket::SendAuthReply(uint8_t result) {
-  ByteBuffer response;
+  ByteBufferWriter response;
   response.WriteUInt8(1);  // Negotiation Version
   response.WriteUInt8(result);
   DirectSend(response);
 }
 
-void AsyncSocksProxyServerSocket::HandleConnect(ByteBuffer* request) {
+void AsyncSocksProxyServerSocket::HandleConnect(ByteBufferReader* request) {
   uint8_t ver, command, reserved, addr_type;
   uint32_t ip;
   uint16_t port;
   if (!request->ReadUInt8(&ver) ||
       !request->ReadUInt8(&command) ||
       !request->ReadUInt8(&reserved) ||
       !request->ReadUInt8(&addr_type) ||
       !request->ReadUInt32(&ip) ||
       !request->ReadUInt16(&port)) {
       Error(0);
       return;
   }
 
   if (ver != 5 || command != 1 ||
       reserved != 0 || addr_type != 1) {
       Error(0);
       return;
   }
 
   SignalConnectRequest(this, SocketAddress(ip, port));
   state_ = SS_CONNECT_PENDING;
 }
 
 void AsyncSocksProxyServerSocket::SendConnectResult(int result,
                                                     const SocketAddress& addr) {
   if (state_ != SS_CONNECT_PENDING)
     return;
 
-  ByteBuffer response;
+  ByteBufferWriter response;
   response.WriteUInt8(5);  // Socks version
   response.WriteUInt8((result != 0));  // 0x01 is generic error
   response.WriteUInt8(0);  // reserved
   response.WriteUInt8(1);  // IPv4 address
   response.WriteUInt32(addr.ip());
   response.WriteUInt16(addr.port());
   DirectSend(response);
   BufferInput(false);
   state_ = SS_TUNNEL;
 }
@@ skipping 61 matching lines @@
 void LoggingSocketAdapter::OnCloseEvent(AsyncSocket * socket, int err) {
   LogMultiline(level_, label_.c_str(), false, NULL, 0, hex_mode_, &lms_);
   LogMultiline(level_, label_.c_str(), true, NULL, 0, hex_mode_, &lms_);
   LOG_V(level_) << label_ << " Closed with error: " << err;
   AsyncSocketAdapter::OnCloseEvent(socket, err);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
 }  // namespace rtc