src/data.cc

   1 ///
   2 /// \file       data.cc
   3 ///             Classes to help manage pre-determined data files.
   4 ///
   5
   6 /*
   7     Copyright (C) 2005-2007, Net Direct Inc. (http://www.netdirect.ca/)
   8
   9     This program is free software; you can redistribute it and/or modify
  10     it under the terms of the GNU General Public License as published by
  11     the Free Software Foundation; either version 2 of the License, or
  12     (at your option) any later version.
  13
  14     This program is distributed in the hope that it will be useful,
  15     but WITHOUT ANY WARRANTY; without even the implied warranty of
  16     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  17
  18     See the GNU General Public License in the COPYING file at the
  19     root directory of this project for more details.
  20 */
  21
  22 #include "data.h"
  23 #include <fstream>
  24 #include <sstream>
  25 #include <iomanip>
  26 #include <string>
  27 #include <stdexcept>
  28
  29 //#define __DEBUG_MODE__
  30 #include "debug.h"
  31
  32
  33 using namespace std;
  34
  35
  36 namespace Barry {
  37
  38 inline bool IsHexData(const std::string &s)
  39 {
  40         const char *str = s.c_str();
  41         for( int i = 0; i < 4 && *str; str++, i++ )
  42                 if( *str != ' ' )
  43                         return false;
  44
  45         for( int i = 0; i < 8 && *str; str++, i++ ) {
  46                 const char *hexchars = "0123456789abcdef";
  47                 if( strchr(hexchars, *str) == NULL )
  48                         return false;
  49         }
  50
  51         if( *str != ':' )
  52                 return false;
  53
  54         return true;
  55 }
  56
  57
  58
  59 ///////////////////////////////////////////////////////////////////////////////
  60 // Data class
  61
  62 bool Data::bPrintAscii = true;
  63
  64 Data::Data()
  65         : m_data(new unsigned char[0x4000]),
  66         m_bufsize(0x4000),
  67         m_datasize(0),
  68         m_endpoint(-1),
  69         m_externalData(0),
  70         m_external(false)
  71 {
  72         memset(m_data, 0, m_bufsize);
  73 }
  74
  75 Data::Data(int endpoint, size_t startsize)
  76         : m_data(new unsigned char[startsize]),
  77         m_bufsize(startsize),
  78         m_datasize(0),
  79         m_endpoint(endpoint),
  80         m_externalData(0),
  81         m_external(false)
  82 {
  83         memset(m_data, 0, m_bufsize);
  84 }
  85
  86 Data::Data(const void *ValidData, size_t size)
  87         : m_data(0),
  88         m_bufsize(0),
  89         m_datasize(size),
  90         m_endpoint(-1),
  91         m_externalData((const unsigned char*)ValidData),
  92         m_external(true)
  93 {
  94 }
  95
  96 Data::Data(const Data &other)
  97         : m_data(other.m_bufsize ? new unsigned char[other.m_bufsize] : 0),
  98         m_bufsize(other.m_bufsize),
  99         m_datasize(other.m_datasize),
 100         m_endpoint(other.m_endpoint),
 101         m_externalData(other.m_externalData),
 102         m_external(other.m_external)
 103 {
 104         // copy over the raw data
 105         if( !m_external )
 106                 memcpy(m_data, other.m_data, other.m_bufsize);
 107 }
 108
 109 Data::~Data()
 110 {
 111         delete [] m_data;
 112 }
 113
 114 void Data::MakeSpace(size_t desiredsize)
 115 {
 116         if( m_bufsize < desiredsize ) {
 117                 desiredsize += 1024;    // get a proper chunk
 118                 unsigned char *newbuf = new unsigned char[desiredsize];
 119                 memcpy(newbuf, m_data, m_bufsize);
 120                 memset(newbuf + m_bufsize, 0, desiredsize - m_bufsize);
 121                 delete [] m_data;
 122                 m_data = newbuf;
 123                 m_bufsize = desiredsize;
 124         }
 125 }
 126
 127 // perform the copy on write operation if needed
 128 void Data::CopyOnWrite(size_t desiredsize)
 129 {
 130         if( m_external ) {
 131                 // make room
 132                 MakeSpace(std::max(desiredsize, m_datasize));
 133
 134                 // copy it over
 135                 memcpy(m_data, m_externalData, m_datasize);
 136
 137                 // not external anymore
 138                 m_external = false;
 139         }
 140 }
 141
 142 void Data::InputHexLine(istream &is)
 143 {
 144         unsigned int values[16];
 145         size_t index = 0;
 146
 147         size_t address;
 148         is >> setbase(16) >> address;
 149         if( !is )
 150                 return;         // nothing to do
 151
 152         is.ignore();            // eat the ':'
 153
 154         while( is && index < 16 ) {
 155                 is >> setbase(16) >> values[index];
 156                 if( is )
 157                         index++;
 158         }
 159
 160         dout("InputHexLine: read " << index << " bytes");
 161
 162         CopyOnWrite(address + index);
 163         MakeSpace(address + index);     // make space for the new
 164         m_datasize = std::max(address + index, m_datasize);
 165         while( index-- )
 166                 m_data[address + index] = (unsigned char) values[index];
 167         return;
 168 }
 169
 170 void Data::DumpHexLine(ostream &os, size_t index, size_t size) const
 171 {
 172         ios::fmtflags oldflags = os.setf(ios::right);
 173
 174         // index
 175         os << "    ";
 176         os << setbase(16) << setfill('0') << setw(8)
 177            << index << ": ";
 178
 179         // hex byte data
 180         for( size_t i = 0; i < size; i++ ) {
 181                 if( (index+i) < GetSize() ) {
 182                         os << setbase(16) << setfill('0')
 183                            << setw(2) << setprecision(2)
 184                            << (unsigned int) GetData()[index + i] << ' ';
 185                 }
 186                 else {
 187                         os << "   ";
 188                 }
 189         }
 190
 191         // printable data
 192         if( bPrintAscii ) {
 193                 locale loc = os.getloc();
 194                 os << ' ';
 195                 for( size_t i = 0; i < size && (index+i) < GetSize(); i++ ) {
 196                         ostream::traits_type::char_type c = GetData()[index + i];
 197                         os << setbase(10) << (char) (isprint(c, loc) ? c : '.');
 198                 }
 199         }
 200
 201         os << "\n";
 202         os.flags(oldflags);
 203 }
 204
 205 void Data::DumpHex(ostream &os) const
 206 {
 207         for( size_t address = 0; address < GetSize(); address += 16 ) {
 208                 DumpHexLine(os, address, 16);
 209         }
 210 }
 211
 212 unsigned char * Data::GetBuffer(size_t requiredsize)
 213 {
 214         CopyOnWrite(requiredsize);
 215         if( requiredsize > 0 )
 216                 MakeSpace(requiredsize);
 217         return m_data;
 218 }
 219
 220 void Data::ReleaseBuffer(int datasize)
 221 {
 222         assert( datasize >= 0 || datasize == -1 );
 223         assert( datasize == -1 || (unsigned int)datasize <= m_bufsize );
 224         assert( !m_external );
 225
 226         if( m_external )
 227                 return;
 228         if( datasize >= 0 && (unsigned int)datasize > m_bufsize ) {
 229                 dout("ReleaseBuffer called with datasize("
 230                         << std::dec << datasize << ") > m_bufsize("
 231                         << m_bufsize << ")");
 232                 return;
 233         }
 234
 235         if( datasize >= 0 ) {
 236                 m_datasize = datasize;
 237         }
 238         else {
 239                 // search for last non-zero value in buffer
 240                 m_datasize = m_bufsize - 1;
 241                 while( m_datasize && m_data[m_datasize] == 0 )
 242                         --m_datasize;
 243         }
 244 }
 245
 246 /// Append bytes of data based on str
 247 void Data::AppendHexString(const char *str)
 248 {
 249         CopyOnWrite(m_datasize + 512);
 250
 251         std::istringstream iss(str);
 252         unsigned int byte;
 253         while( iss >> hex >> byte ) {
 254                 MakeSpace(m_datasize + 1);
 255                 m_data[m_datasize] = (unsigned char) byte;
 256                 m_datasize++;
 257         }
 258 }
 259
 260 /// set buffer to 0 and remove all data
 261 void Data::Zap()
 262 {
 263         if( !m_external )
 264                 memset(m_data, 0, m_bufsize);
 265         m_datasize = 0;
 266 }
 267
 268 Data & Data::operator=(const Data &other)
 269 {
 270         if( this == &other )
 271                 return *this;
 272
 273         // don't remove our current buffer, only grow it if needed
 274         MakeSpace(other.m_bufsize);
 275         memcpy(m_data, other.m_data, other.m_bufsize);
 276
 277         // then copy over the data state
 278         m_datasize = other.m_datasize;
 279         m_endpoint = other.m_endpoint;
 280         m_externalData = other.m_externalData;
 281         m_external = other.m_external;
 282         return *this;
 283 }
 284
 285 istream& operator>> (istream &is, Data &data)
 286 {
 287         data.InputHexLine(is);
 288         return is;
 289 }
 290
 291 ostream& operator<< (ostream &os, const Data &data)
 292 {
 293         data.DumpHex(os);
 294         return os;
 295 }
 296
 297
 298 ///////////////////////////////////////////////////////////////////////////////
 299 // Diff class
 300
 301 Diff::Diff(const Data &old, const Data &new_)
 302         : m_old(old), m_new(new_)
 303 {
 304 }
 305
 306 void Diff::Compare(ostream &os, size_t index, size_t size) const
 307 {
 308         size_t min = std::min(m_old.GetSize(), m_new.GetSize());
 309
 310         // index
 311         os << ">   ";
 312         os << setbase(16) << setfill('0') << setw(8)
 313            << index << ": ";
 314
 315         // diff data
 316         for( size_t i = 0; i < size; i++ ) {
 317                 size_t address = index + i;
 318
 319                 // if data is available, print the diff
 320                 if( address < min ) {
 321                         if( m_old.GetData()[address] != m_new.GetData()[address] ) {
 322                                 // differ, print hex
 323                                 os << setbase(16) << setfill('0')
 324                                    << setw(2) << setprecision(2)
 325                                    << (unsigned int) m_new.GetData()[address] << ' ';
 326                         }
 327                         else {
 328                                 // same, just print spaces
 329                                 os << "   ";
 330                         }
 331                 }
 332                 else {
 333                         // one of the buffers is shorter...
 334                         if( address < m_new.GetSize() ) {
 335                                 // new still has data, print it
 336                                 os << setbase(16) << setfill('0')
 337                                    << setw(2) << setprecision(2)
 338                                    << (unsigned int) m_new.GetData()[address]
 339                                    << ' ';
 340                         }
 341                         else if( address < m_old.GetSize() ) {
 342                                 // new is out of data and old still has some
 343                                 os << "XX ";
 344                         }
 345                         else {
 346                                 // no more data, just print spaces
 347                                 os << "   ";
 348                         }
 349                 }
 350         }
 351
 352         // printable data, just dump new
 353         if( Data::PrintAscii() ) {
 354                 os << ' ';
 355                 for( size_t i = 0; i < size && (index+i) < m_new.GetSize(); i++ ) {
 356                         int c = m_new.GetData()[index + i];
 357                         os << setbase(10) << (char) (isprint(c) ? c : '.');
 358                 }
 359         }
 360
 361         os << "\n";
 362 }
 363
 364 void Diff::Dump(std::ostream &os) const
 365 {
 366         if( m_old.GetSize() != m_new.GetSize() )
 367                 os << "sizes differ: "
 368                    << m_old.GetSize() << " != " << m_new.GetSize() << endl;
 369
 370         size_t max = std::max(m_old.GetSize(), m_new.GetSize());
 371         for( size_t i = 0; i < max; i += 16 ) {
 372                 m_old.DumpHexLine(os, i, 16);
 373                 Compare(os, i, 16);
 374         }
 375 }
 376
 377 ostream& operator<< (ostream &os, const Diff &diff)
 378 {
 379         diff.Dump(os);
 380         return os;
 381 }
 382
 383
 384 ///////////////////////////////////////////////////////////////////////////////
 385 // Utility functions
 386
 387 static bool IsEndpointStart(const std::string &line, int &endpoint)
 388 {
 389         if( strncmp(line.c_str(), "sep: ", 5) == 0 ||
 390             strncmp(line.c_str(), "rep: ", 5) == 0 )
 391         {
 392                 endpoint = atoi(line.c_str() + 5);
 393                 return true;
 394         }
 395         return false;
 396 }
 397
 398 bool LoadDataArray(const string &filename, std::vector<Data> &array)
 399 {
 400         ifstream in(filename.c_str());
 401         return ReadDataArray(in, array);
 402 }
 403
 404 bool ReadDataArray(std::istream &is, std::vector<Data> &array)
 405 {
 406         if( !is )
 407                 return false;
 408
 409         bool bInEndpoint = false;
 410         unsigned int nCurrent = 0;
 411         size_t nLargestSize = 0x100;
 412         while( is ) {
 413                 string line;
 414                 getline(is, line);
 415                 int endpoint;
 416                 if( bInEndpoint ) {
 417                         if( IsHexData(line) ) {
 418                                 istringstream sline(line);
 419                                 sline >> array[nCurrent];
 420                                 continue;
 421                         }
 422                         else {
 423                                 nLargestSize = std::max(nLargestSize,
 424                                         array[nCurrent].GetBufSize());
 425                                 bInEndpoint = false;
 426                         }
 427                 }
 428
 429                 // check if this line starts a new endpoint
 430                 if( IsEndpointStart(line, endpoint) ) {
 431                         bInEndpoint = true;
 432                         Data chunk(endpoint, nLargestSize);
 433                         array.push_back(chunk);
 434                         nCurrent = array.size() - 1;
 435                 }
 436         }
 437         return true;
 438 }
 439
 440 } // namespace Barry
 441
 442
 443 #ifdef __TEST_MODE__
 444
 445 #include <iostream>
 446 #include <iomanip>
 447 #include "data.h"
 448
 449 using namespace std;
 450
 451 int main()
 452 {
 453         typedef std::vector<Data> DataVec;
 454         DataVec array;
 455         if( !LoadDataArray("data/parsed.log", array) ) {
 456                 cout << "Can't load file" << endl;
 457                 return 1;
 458         }
 459
 460         DataVec::iterator i = array.begin();
 461         Data::PrintAscii(false);
 462         for( ; i != array.end(); i++ ) {
 463                 cout << "Endpoint: " << i->GetEndpoint() << endl;
 464                 cout << *i;
 465                 cout << "\n\n";
 466         }
 467
 468
 469         Data one, two;
 470         one.GetBuffer()[0] = 0x01;
 471         one.ReleaseBuffer(1);
 472         two.GetBuffer()[0] = 0x02;
 473         two.ReleaseBuffer(2);
 474
 475         cout << Diff(one, two) << endl;
 476         cout << Diff(two, one) << endl;
 477
 478         two.GetBuffer();
 479         two.ReleaseBuffer(32);
 480         cout << Diff(one, two) << endl;
 481 }
 482
 483 #endif
 484