buffer.cpp

   1 /*
   2  *  anytun
   3  *
   4  *  The secure anycast tunneling protocol (satp) defines a protocol used
   5  *  for communication between any combination of unicast and anycast
   6  *  tunnel endpoints.  It has less protocol overhead than IPSec in Tunnel
   7  *  mode and allows tunneling of every ETHER TYPE protocol (e.g.
   8  *  ethernet, ip, arp ...). satp directly includes cryptography and
   9  *  message authentication based on the methodes used by SRTP.  It is
  10  *  intended to deliver a generic, scaleable and secure solution for
  11  *  tunneling and relaying of packets of any protocol.
  12  *
  13  *
  14  *  Copyright (C) 2007 anytun.org <satp@wirdorange.org>
  15  *
  16  *  This program is free software; you can redistribute it and/or modify
  17  *  it under the terms of the GNU General Public License version 2
  18  *  as published by the Free Software Foundation.
  19  *
  20  *  This program is distributed in the hope that it will be useful,
  21  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  22  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  23  *  GNU General Public License for more details.
  24  *
  25  *  You should have received a copy of the GNU General Public License
  26  *  along with this program (see the file COPYING included with this
  27  *  distribution); if not, write to the Free Software Foundation, Inc.,
  28  *  59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  29  */
  30
  31 #include <stdexcept>
  32 #include <string>
  33 #include <cstdio>
  34 #include <iostream>
  35 #include <boost/archive/text_oarchive.hpp>
  36 #include <boost/archive/text_iarchive.hpp>
  37 #include "datatypes.h"
  38 #include "buffer.h"
  39
  40 Buffer::Buffer() : buf_(0), length_(0)
  41 {
  42 }
  43
  44 Buffer::Buffer(u_int32_t length) : length_(length)
  45 {
  46   buf_ = new u_int8_t[length_];
  47   if(buf_)
  48     std::memset(buf_, 0, length_);
  49   else
  50     length_ = 0;
  51 }
  52
  53 Buffer::Buffer(u_int8_t* data, u_int32_t length) : length_(length)
  54 {
  55   buf_ = new u_int8_t[length_];
  56   if(buf_)
  57     std::memcpy(buf_, data, length_);
  58   else
  59     length_ = 0;
  60 }
  61
  62 Buffer::~Buffer()
  63 {
  64   if(buf_)
  65     delete[] buf_;
  66 }
  67
  68 Buffer::Buffer(const Buffer &src) : length_(src.length_)
  69 {
  70   buf_ = new u_int8_t[length_];
  71   if(buf_)
  72     std::memcpy(buf_, src.buf_, length_);
  73   else
  74     length_ = 0;
  75 }
  76
  77 void Buffer::operator=(const Buffer &src)
  78 {
  79   if(buf_)
  80     delete[] buf_;
  81
  82   length_ = src.length_;
  83
  84   buf_ = new u_int8_t[length_];
  85   if(buf_)
  86     std::memcpy(buf_, src.buf_, length_);
  87   else
  88     length_ = 0;
  89 }
  90
  91
  92
  93 bool Buffer::operator==(const Buffer &cmp) const
  94 {
  95   if(length_ != cmp.length_)
  96     return false;
  97
  98   if(!std::memcmp(buf_, cmp.buf_, length_))
  99     return true;
 100
 101   return false;
 102 }
 103
 104
 105 u_int32_t Buffer::resizeFront(u_int32_t new_length)
 106 {
 107   if(length_ == new_length)
 108     return length_;
 109
 110   u_int8_t *tmp = new u_int8_t[new_length];
 111   if(!tmp)
 112     return length_;
 113
 114   if(buf_)
 115   {
 116     u_int8_t *src=buf_, *dest=tmp;
 117     if(length_ < new_length)
 118       dest = &dest[new_length - length_];
 119     else
 120       src = &src[length_ - new_length];
 121     u_int32_t len = length_ < new_length ? length_ : new_length;
 122     std::memcpy(dest, src, len);
 123     delete[] buf_;
 124   }
 125
 126   length_ = new_length;
 127   buf_ = tmp;
 128   return length_;
 129 }
 130
 131 u_int32_t Buffer::resizeBack(u_int32_t new_length)
 132 {
 133   if(length_ == new_length)
 134     return length_;
 135
 136   u_int8_t *tmp = new u_int8_t[new_length];
 137   if(!tmp)
 138     return length_;
 139
 140   if(buf_)
 141   {
 142     u_int32_t len = length_ < new_length ? length_ : new_length;
 143     std::memcpy(tmp, buf_, len);
 144     delete[] buf_;
 145   }
 146
 147   length_ = new_length;
 148   buf_ = tmp;
 149   return length_;
 150 }
 151
 152 u_int32_t Buffer::getLength() const
 153 {
 154   return length_;
 155 }
 156
 157 u_int8_t* Buffer::getBuf()
 158 {
 159   return buf_;
 160 }
 161
 162 u_int8_t& Buffer::operator[](u_int32_t index)
 163 {
 164   if(index >= length_)
 165     throw std::out_of_range("buffer::operator[]");
 166
 167   return buf_[index];
 168 }
 169
 170 u_int8_t Buffer::operator[](u_int32_t index) const
 171 {
 172   if(index >= length_)
 173     throw std::out_of_range("buffer::operator[] const");
 174
 175   return buf_[index];
 176 }
 177
 178 Buffer::operator u_int8_t*() // just for write/read tun
 179 {
 180   return buf_;
 181 }
 182
 183 std::string Buffer::getHexDump() const
 184 {
 185   char text[10];
 186   std::string ret = "";
 187
 188   for( u_int32_t index = 0; index < length_; index++ )
 189   {
 190     std::sprintf(text, "%#4x", buf_[index]);
 191     ret += text;
 192     ret += "";
 193     if( ((index+1) % 10) == 0 )
 194       ret += '\n';
 195   }
 196   return ret;
 197 }
 198
 199 Buffer Buffer::operator^(const Buffer &xor_by) const
 200 {
 201   Buffer res(length_);
 202   if( xor_by.getLength() > length_ )
 203     throw std::out_of_range("buffer::operator^ const");
 204
 205   for( u_int32_t index = 0; index < xor_by.getLength(); index++ )
 206     res[index] = buf_[index] ^ xor_by[index];
 207
 208   return res;
 209 }
 210
 211 Buffer Buffer::leftByteShift(u_int32_t width) const
 212 {
 213   Buffer res(length_+width);
 214
 215   for( u_int32_t index = 0; index < length_; index++ )
 216     res[index+width] = buf_[index];
 217
 218   return res;
 219 }
 220
 221 Buffer Buffer::rightByteShift(u_int32_t width) const
 222 {
 223   Buffer res(length_);
 224
 225   for( u_int32_t index = 0; index < length_-width; index++ )
 226     res[index] = buf_[index+width];
 227
 228   return res;
 229 }
 230