Split ByteBuffer into writer/reader objects.

webrtc/p2p/base/stun.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.
  */
 
 #include "webrtc/p2p/base/stun.h"
 
 #include <string.h>
 
 #include "webrtc/base/byteorder.h"
 #include "webrtc/base/common.h"
 #include "webrtc/base/crc32.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/messagedigest.h"
 #include "webrtc/base/scoped_ptr.h"
 #include "webrtc/base/stringencode.h"
 
-using rtc::ByteBuffer;
+using rtc::ByteBufferReader;
+using rtc::ByteBufferWriter;
 
 namespace cricket {
 
 const char STUN_ERROR_REASON_TRY_ALTERNATE_SERVER[] = "Try Alternate Server";
 const char STUN_ERROR_REASON_BAD_REQUEST[] = "Bad Request";
 const char STUN_ERROR_REASON_UNAUTHORIZED[] = "Unauthorized";
 const char STUN_ERROR_REASON_FORBIDDEN[] = "Forbidden";
 const char STUN_ERROR_REASON_STALE_CREDENTIALS[] = "Stale Credentials";
 const char STUN_ERROR_REASON_ALLOCATION_MISMATCH[] = "Allocation Mismatch";
 const char STUN_ERROR_REASON_STALE_NONCE[] = "Stale Nonce";
@@ skipping 178 matching lines @@
 bool StunMessage::AddMessageIntegrity(const char* key,
                                       size_t keylen) {
   // Add the attribute with a dummy value. Since this is a known attribute, it
   // can't fail.
   StunByteStringAttribute* msg_integrity_attr =
       new StunByteStringAttribute(STUN_ATTR_MESSAGE_INTEGRITY,
           std::string(kStunMessageIntegritySize, '0'));
   VERIFY(AddAttribute(msg_integrity_attr));
 
   // Calculate the HMAC for the message.
-  rtc::ByteBuffer buf;
+  ByteBufferWriter buf;
   if (!Write(&buf))
     return false;
 
   int msg_len_for_hmac = static_cast<int>(
       buf.Length() - kStunAttributeHeaderSize - msg_integrity_attr->length());
   char hmac[kStunMessageIntegritySize];
   size_t ret = rtc::ComputeHmac(rtc::DIGEST_SHA_1,
                                       key, keylen,
                                       buf.Data(), msg_len_for_hmac,
                                       hmac, sizeof(hmac));
@@ skipping 40 matching lines @@
 }
 
 bool StunMessage::AddFingerprint() {
   // Add the attribute with a dummy value. Since this is a known attribute,
   // it can't fail.
   StunUInt32Attribute* fingerprint_attr =
      new StunUInt32Attribute(STUN_ATTR_FINGERPRINT, 0);
   VERIFY(AddAttribute(fingerprint_attr));
 
   // Calculate the CRC-32 for the message and insert it.
-  rtc::ByteBuffer buf;
+  ByteBufferWriter buf;
   if (!Write(&buf))
     return false;
 
   int msg_len_for_crc32 = static_cast<int>(
       buf.Length() - kStunAttributeHeaderSize - fingerprint_attr->length());
   uint32_t c = rtc::ComputeCrc32(buf.Data(), msg_len_for_crc32);
 
   // Insert the correct CRC-32, XORed with a constant, into the attribute.
   fingerprint_attr->SetValue(c ^ STUN_FINGERPRINT_XOR_VALUE);
   return true;
 }
 
-bool StunMessage::Read(ByteBuffer* buf) {
+bool StunMessage::Read(ByteBufferReader* buf) {
   if (!buf->ReadUInt16(&type_))
     return false;
 
   if (type_ & 0x8000) {
     // RTP and RTCP set the MSB of first byte, since first two bits are version,
     // and version is always 2 (10). If set, this is not a STUN packet.
     return false;
   }
 
   if (!buf->ReadUInt16(&length_))
@@ skipping 42 matching lines @@
       if (!attr->Read(buf))
         return false;
       attrs_->push_back(attr);
     }
   }
 
   ASSERT(buf->Length() == rest);
   return true;
 }
 
-bool StunMessage::Write(ByteBuffer* buf) const {
+bool StunMessage::Write(ByteBufferWriter* buf) const {
   buf->WriteUInt16(type_);
   buf->WriteUInt16(length_);
   if (!IsLegacy())
     buf->WriteUInt32(kStunMagicCookie);
   buf->WriteString(transaction_id_);
 
   for (size_t i = 0; i < attrs_->size(); ++i) {
     buf->WriteUInt16((*attrs_)[i]->type());
     buf->WriteUInt16(static_cast<uint16_t>((*attrs_)[i]->length()));
     if (!(*attrs_)[i]->Write(buf))
@@ skipping 40 matching lines @@
   return transaction_id.size() == kStunTransactionIdLength ||
       transaction_id.size() == kStunLegacyTransactionIdLength;
 }
 
 // StunAttribute
 
 StunAttribute::StunAttribute(uint16_t type, uint16_t length)
     : type_(type), length_(length) {
 }
 
-void StunAttribute::ConsumePadding(rtc::ByteBuffer* buf) const {
+void StunAttribute::ConsumePadding(ByteBufferReader* buf) const {
   int remainder = length_ % 4;
   if (remainder > 0) {
     buf->Consume(4 - remainder);
   }
 }
 
-void StunAttribute::WritePadding(rtc::ByteBuffer* buf) const {
+void StunAttribute::WritePadding(ByteBufferWriter* buf) const {
   int remainder = length_ % 4;
   if (remainder > 0) {
     char zeroes[4] = {0};
     buf->WriteBytes(zeroes, 4 - remainder);
   }
 }
 
 StunAttribute* StunAttribute::Create(StunAttributeValueType value_type,
                                      uint16_t type,
                                      uint16_t length,
@@ skipping 50 matching lines @@
 StunAddressAttribute::StunAddressAttribute(uint16_t type,
                                            const rtc::SocketAddress& addr)
     : StunAttribute(type, 0) {
   SetAddress(addr);
 }
 
 StunAddressAttribute::StunAddressAttribute(uint16_t type, uint16_t length)
     : StunAttribute(type, length) {
 }
 
-bool StunAddressAttribute::Read(ByteBuffer* buf) {
+bool StunAddressAttribute::Read(ByteBufferReader* buf) {
   uint8_t dummy;
   if (!buf->ReadUInt8(&dummy))
     return false;
 
   uint8_t stun_family;
   if (!buf->ReadUInt8(&stun_family)) {
     return false;
   }
   uint16_t port;
   if (!buf->ReadUInt16(&port))
@@ skipping 17 matching lines @@
       return false;
     }
     rtc::IPAddress ipaddr(v6addr);
     SetAddress(rtc::SocketAddress(ipaddr, port));
   } else {
     return false;
   }
   return true;
 }
 
-bool StunAddressAttribute::Write(ByteBuffer* buf) const {
+bool StunAddressAttribute::Write(ByteBufferWriter* buf) const {
   StunAddressFamily address_family = family();
   if (address_family == STUN_ADDRESS_UNDEF) {
     LOG(LS_ERROR) << "Error writing address attribute: unknown family.";
     return false;
   }
   buf->WriteUInt8(0);
   buf->WriteUInt8(address_family);
   buf->WriteUInt16(address_.port());
   switch (address_.family()) {
     case AF_INET: {
@@ skipping 50 matching lines @@
         }
         break;
       }
     }
   }
   // Invalid ip family or transaction ID, or missing owner.
   // Return an AF_UNSPEC address.
   return rtc::IPAddress();
 }
 
-bool StunXorAddressAttribute::Read(ByteBuffer* buf) {
+bool StunXorAddressAttribute::Read(ByteBufferReader* buf) {
   if (!StunAddressAttribute::Read(buf))
     return false;
   uint16_t xoredport = port() ^ (kStunMagicCookie >> 16);
   rtc::IPAddress xored_ip = GetXoredIP();
   SetAddress(rtc::SocketAddress(xored_ip, xoredport));
   return true;
 }
 
-bool StunXorAddressAttribute::Write(ByteBuffer* buf) const {
+bool StunXorAddressAttribute::Write(ByteBufferWriter* buf) const {
   StunAddressFamily address_family = family();
   if (address_family == STUN_ADDRESS_UNDEF) {
     LOG(LS_ERROR) << "Error writing xor-address attribute: unknown family.";
     return false;
   }
   rtc::IPAddress xored_ip = GetXoredIP();
   if (xored_ip.family() == AF_UNSPEC) {
     return false;
   }
   buf->WriteUInt8(0);
@@ skipping 26 matching lines @@
   ASSERT(index < 32);
   return static_cast<bool>((bits_ >> index) & 0x1);
 }
 
 void StunUInt32Attribute::SetBit(size_t index, bool value) {
   ASSERT(index < 32);
   bits_ &= ~(1 << index);
   bits_ |= value ? (1 << index) : 0;
 }
 
-bool StunUInt32Attribute::Read(ByteBuffer* buf) {
+bool StunUInt32Attribute::Read(ByteBufferReader* buf) {
   if (length() != SIZE || !buf->ReadUInt32(&bits_))
     return false;
   return true;
 }
 
-bool StunUInt32Attribute::Write(ByteBuffer* buf) const {
+bool StunUInt32Attribute::Write(ByteBufferWriter* buf) const {
   buf->WriteUInt32(bits_);
   return true;
 }
 
 StunUInt64Attribute::StunUInt64Attribute(uint16_t type, uint64_t value)
     : StunAttribute(type, SIZE), bits_(value) {
 }
 
 StunUInt64Attribute::StunUInt64Attribute(uint16_t type)
     : StunAttribute(type, SIZE), bits_(0) {
 }
 
-bool StunUInt64Attribute::Read(ByteBuffer* buf) {
+bool StunUInt64Attribute::Read(ByteBufferReader* buf) {
   if (length() != SIZE || !buf->ReadUInt64(&bits_))
     return false;
   return true;
 }
 
-bool StunUInt64Attribute::Write(ByteBuffer* buf) const {
+bool StunUInt64Attribute::Write(ByteBufferWriter* buf) const {
   buf->WriteUInt64(bits_);
   return true;
 }
 
 StunByteStringAttribute::StunByteStringAttribute(uint16_t type)
     : StunAttribute(type, 0), bytes_(NULL) {
 }
 
 StunByteStringAttribute::StunByteStringAttribute(uint16_t type,
                                                  const std::string& str)
@@ skipping 31 matching lines @@
   ASSERT(index < length());
   return static_cast<uint8_t>(bytes_[index]);
 }
 
 void StunByteStringAttribute::SetByte(size_t index, uint8_t value) {
   ASSERT(bytes_ != NULL);
   ASSERT(index < length());
   bytes_[index] = value;
 }
 
-bool StunByteStringAttribute::Read(ByteBuffer* buf) {
+bool StunByteStringAttribute::Read(ByteBufferReader* buf) {
   bytes_ = new char[length()];
   if (!buf->ReadBytes(bytes_, length())) {
     return false;
   }
 
   ConsumePadding(buf);
   return true;
 }
 
-bool StunByteStringAttribute::Write(ByteBuffer* buf) const {
+bool StunByteStringAttribute::Write(ByteBufferWriter* buf) const {
   buf->WriteBytes(bytes_, length());
   WritePadding(buf);
   return true;
 }
 
 void StunByteStringAttribute::SetBytes(char* bytes, size_t length) {
   delete [] bytes_;
   bytes_ = bytes;
   SetLength(static_cast<uint16_t>(length));
 }
@@ skipping 20 matching lines @@
 void StunErrorCodeAttribute::SetCode(int code) {
   class_ = static_cast<uint8_t>(code / 100);
   number_ = static_cast<uint8_t>(code % 100);
 }
 
 void StunErrorCodeAttribute::SetReason(const std::string& reason) {
   SetLength(MIN_SIZE + static_cast<uint16_t>(reason.size()));
   reason_ = reason;
 }
 
-bool StunErrorCodeAttribute::Read(ByteBuffer* buf) {
+bool StunErrorCodeAttribute::Read(ByteBufferReader* buf) {
   uint32_t val;
   if (length() < MIN_SIZE || !buf->ReadUInt32(&val))
     return false;
 
   if ((val >> 11) != 0)
     LOG(LS_ERROR) << "error-code bits not zero";
 
   class_ = ((val >> 8) & 0x7);
   number_ = (val & 0xff);
 
   if (!buf->ReadString(&reason_, length() - 4))
     return false;
 
   ConsumePadding(buf);
   return true;
 }
 
-bool StunErrorCodeAttribute::Write(ByteBuffer* buf) const {
+bool StunErrorCodeAttribute::Write(ByteBufferWriter* buf) const {
   buf->WriteUInt32(class_ << 8 | number_);
   buf->WriteString(reason_);
   WritePadding(buf);
   return true;
 }
 
 StunUInt16ListAttribute::StunUInt16ListAttribute(uint16_t type, uint16_t length)
     : StunAttribute(type, length) {
   attr_types_ = new std::vector<uint16_t>();
 }
@@ skipping 12 matching lines @@
 
 void StunUInt16ListAttribute::SetType(int index, uint16_t value) {
   (*attr_types_)[index] = value;
 }
 
 void StunUInt16ListAttribute::AddType(uint16_t value) {
   attr_types_->push_back(value);
   SetLength(static_cast<uint16_t>(attr_types_->size() * 2));
 }
 
-bool StunUInt16ListAttribute::Read(ByteBuffer* buf) {
+bool StunUInt16ListAttribute::Read(ByteBufferReader* buf) {
   if (length() % 2)
     return false;
 
   for (size_t i = 0; i < length() / 2; i++) {
     uint16_t attr;
     if (!buf->ReadUInt16(&attr))
       return false;
     attr_types_->push_back(attr);
   }
   // Padding of these attributes is done in RFC 5389 style. This is
   // slightly different from RFC3489, but it shouldn't be important.
   // RFC3489 pads out to a 32 bit boundary by duplicating one of the
   // entries in the list (not necessarily the last one - it's unspecified).
   // RFC5389 pads on the end, and the bytes are always ignored.
   ConsumePadding(buf);
   return true;
 }
 
-bool StunUInt16ListAttribute::Write(ByteBuffer* buf) const {
+bool StunUInt16ListAttribute::Write(ByteBufferWriter* buf) const {
   for (size_t i = 0; i < attr_types_->size(); ++i) {
     buf->WriteUInt16((*attr_types_)[i]);
   }
   WritePadding(buf);
   return true;
 }
 
 int GetStunSuccessResponseType(int req_type) {
   return IsStunRequestType(req_type) ? (req_type | 0x100) : -1;
 }
@@ skipping 37 matching lines @@
       digest, sizeof(digest));
   if (size == 0) {
     return false;
   }
 
   *hash = std::string(digest, size);
   return true;
 }
 
 }  // namespace cricket