byte_string.cc

// Copyright (c) 2011 The Chromium OS Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#include "shill/byte_string.h"

#include <netinet/in.h>
#include <string.h>

#include <algorithm>

#include <base/string_number_conversions.h>

using std::distance;
using std::min;
using std::string;
using std::vector;

namespace shill {

ByteString::ByteString(const ByteString &b) {
  data_.assign(Vector::const_iterator(b.begin_), b.data_.end());
  begin_ = data_.begin();
}

ByteString &ByteString::operator=(const ByteString &b) {
  data_.assign(Vector::const_iterator(b.begin_), b.data_.end());
  begin_ = data_.begin();
  return *this;
}

unsigned char *ByteString::GetData() {
  return (GetLength() == 0) ? NULL : &*begin_;
}

const unsigned char *ByteString::GetConstData() const {
  return (GetLength() == 0) ? NULL : &*begin_;
}

size_t ByteString::GetLength() const {
  return distance(Vector::const_iterator(begin_), data_.end());
}

ByteString ByteString::GetSubstring(size_t offset, size_t length) const {
  if (offset > GetLength()) {
    offset = GetLength();
  }
  if (length > GetLength() - offset) {
    length = GetLength() - offset;
  }
  return ByteString(GetConstData() + offset, length);
}

// static
ByteString ByteString::CreateFromCPUUInt32(uint32 val) {
  return ByteString(reinterpret_cast<unsigned char *>(&val), sizeof(val));
}

// static
ByteString ByteString::CreateFromNetUInt32(uint32 val) {
  return CreateFromCPUUInt32(ntohl(val));
}

// static
ByteString ByteString::CreateFromHexString(const string &hex_string) {
  vector<uint8> bytes;
  if (!base::HexStringToBytes(hex_string, &bytes)) {
    return ByteString();
  }
  return ByteString(&bytes.front(), bytes.size());
}

bool ByteString::ConvertToCPUUInt32(uint32 *val) const {
  if (val == NULL || GetLength() != sizeof(*val)) {
    return false;
  }
  memcpy(val, GetConstData(), sizeof(*val));

  return true;
}

bool ByteString::ConvertToNetUInt32(uint32 *val) const {
  if (!ConvertToCPUUInt32(val)) {
    return false;
  }
  *val = ntohl(*val);
  return true;
}

template <typename T>
bool ByteString::ConvertByteOrderAsUIntArray(T (*converter)(T)) {
  size_t length = GetLength();
  if ((length % sizeof(T)) != 0) {
    return false;
  }
  for (Vector::iterator i = begin_; i != data_.end(); i += sizeof(T)) {
    // Take care of word alignment.
    T val;
    memcpy(&val, &(*i), sizeof(T));
    val = converter(val);
    memcpy(&(*i), &val, sizeof(T));
  }
  return true;
}

bool ByteString::ConvertFromNetToCPUUInt32Array() {
  return ConvertByteOrderAsUIntArray(ntohl);
}

bool ByteString::ConvertFromCPUToNetUInt32Array() {
  return ConvertByteOrderAsUIntArray(htonl);
}

bool ByteString::IsZero() const {
  for (Vector::const_iterator i = begin_; i != data_.end(); ++i) {
    if (*i != 0) {
      return false;
    }
  }
  return true;
}

bool ByteString::BitwiseAnd(const ByteString &b) {
  if (GetLength() != b.GetLength()) {
    return false;
  }
  Vector::iterator lhs(begin_);
  Vector::const_iterator rhs(b.begin_);
  while (lhs != data_.end()) {
    *lhs++ &= *rhs++;
  }
  return true;
}

bool ByteString::BitwiseOr(const ByteString &b) {
  if (GetLength() != b.GetLength()) {
    return false;
  }
  Vector::iterator lhs(begin_);
  Vector::const_iterator rhs(b.begin_);
  while (lhs != data_.end()) {
    *lhs++ |= *rhs++;
  }
  return true;
}

void ByteString::BitwiseInvert() {
  for (Vector::iterator i = begin_; i != data_.end(); ++i) {
    *i = ~*i;
  }
}

bool ByteString::Equals(const ByteString &b) const {
  if (GetLength() != b.GetLength()) {
    return false;
  }
  Vector::const_iterator lhs(begin_);
  Vector::const_iterator rhs(b.begin_);
  while(lhs != data_.end()) {
    if (*lhs++ != *rhs++) {
      return false;
    }
  }
  return true;
}

void ByteString::Append(const ByteString &b) {
  // Save and reapply offset since |insert| may reallocate the memory and
  // invalidate the iterator.
  size_t offset = distance(data_.begin(), begin_);
  data_.insert(data_.end(), Vector::const_iterator(b.begin_), b.data_.end());
  begin_ = data_.begin() + offset;
}

void ByteString::Clear() {
  data_.clear();
  begin_ = data_.begin();
}

void ByteString::Resize(int size) {
  // Save and reapply offset since |resize| may reallocate the memory and
  // invalidate the iterator.
  size_t offset = distance(data_.begin(), begin_);
  data_.resize(size + offset, 0);
  begin_ = data_.begin() + offset;
}

string ByteString::HexEncode() const {
  return base::HexEncode(GetConstData(), GetLength());
}

void ByteString::RemovePrefix(size_t offset) {
  if (offset >= GetLength()) {
    begin_ = data_.end();
  } else {
    begin_ += offset;
  }
}

// static
bool ByteString::IsLessThan(const ByteString &lhs, const ByteString &rhs) {
  size_t byte_count = min(lhs.GetLength(), rhs.GetLength());
  int result = memcmp(lhs.GetConstData(), rhs.GetConstData(), byte_count);
  if (result == 0) {
    return byte_count == lhs.GetLength();
  }
  return result < 0;
}

}  // namespace shill