kopete/protocols/oscar/liboscar/buffer.cpp

   1 /***************************************************************************
   2                           buffer.cpp  -  description
   3                              -------------------
   4     begin                : Thu Jun 6 2002
   5
   6     Copyright (c) 2002 by Tom Linsky <twl6@po.cwru.edu>
   7     Copyright (c) 2004,2005 by Matt Rogers <mattr@kde.org>
   8     Kopete    (c) 2002-2005 by the Kopete developers  <kopete-devel@kde.org>
   9
  10     *************************************************************************
  11     *                                                                       *
  12     * This program is free software; you can redistribute it and/or modify  *
  13     * it under the terms of the GNU General Public License as published by  *
  14     * the Free Software Foundation; either version 2 of the License, or     *
  15     * (at your option) any later version.                                   *
  16     *                                                                       *
  17     *************************************************************************
  18 */
  19
  20 #include "buffer.h"
  21
  22 #include <ctype.h>
  23 #include <kdebug.h>
  24 #include <kapplication.h>
  25
  26
  27 Buffer::Buffer()
  28 {
  29         mReadPos=0;
  30 }
  31
  32 Buffer::Buffer( const Buffer& other )
  33 {
  34         mBuffer =  other.mBuffer;
  35         mReadPos = other.mReadPos;
  36 }
  37
  38 Buffer::Buffer(const char *b, int len)
  39 {
  40         mBuffer = QByteArray::fromRawData( b, len );
  41         mReadPos = 0;
  42 }
  43
  44 Buffer::Buffer( const QByteArray& data )
  45 {
  46         mBuffer = data;
  47         mReadPos = 0;
  48 }
  49
  50
  51 Buffer::~Buffer()
  52 {
  53 }
  54
  55
  56 int Buffer::addByte(const BYTE b)
  57 {
  58         expandBuffer(1);
  59         mBuffer[mBuffer.size()-1] = b;
  60
  61         return mBuffer.size();
  62 }
  63
  64 int Buffer::addLEByte(const BYTE b)
  65 {
  66         expandBuffer(1);
  67         mBuffer[mBuffer.size()-1] = ((b) & 0xff);
  68
  69         return mBuffer.size();
  70 }
  71
  72
  73 int Buffer::addWord(const WORD w)
  74 {
  75         expandBuffer(2);
  76         mBuffer[mBuffer.size()-2] = ((w & 0xff00) >> 8);
  77         mBuffer[mBuffer.size()-1] = (w & 0x00ff);
  78
  79         return mBuffer.size();
  80 }
  81
  82 int Buffer::addLEWord(const WORD w)
  83 {
  84         expandBuffer(2);
  85         mBuffer[mBuffer.size()-2] = (unsigned char) ((w >> 0) & 0xff);
  86         mBuffer[mBuffer.size()-1] = (unsigned char) ((w >> 8) & 0xff);
  87
  88         return mBuffer.size();
  89 }
  90
  91
  92 int Buffer::addDWord(const DWORD dw)
  93 {
  94         expandBuffer(4);
  95         mBuffer[mBuffer.size()-4] = (dw & 0xff000000) >> 24;
  96         mBuffer[mBuffer.size()-3] = (dw & 0x00ff0000) >> 16;
  97         mBuffer[mBuffer.size()-2] = (dw & 0x0000ff00) >> 8;
  98         mBuffer[mBuffer.size()-1] = (dw & 0x000000ff);
  99
 100         return mBuffer.size();
 101 }
 102
 103 int Buffer::addLEDWord(const DWORD dw)
 104 {
 105         expandBuffer(4);
 106         mBuffer[mBuffer.size()-4] = (unsigned char) ((dw >> 0) & 0xff);
 107         mBuffer[mBuffer.size()-3] = (unsigned char) ((dw >>  8) & 0xff);
 108         mBuffer[mBuffer.size()-2] = (unsigned char) ((dw >> 16) & 0xff);
 109         mBuffer[mBuffer.size()-1] = (unsigned char) ((dw >> 24) & 0xff);
 110
 111         return mBuffer.size();
 112 }
 113
 114 int Buffer::addString( const QByteArray& s )
 115 {
 116         mBuffer.append( s );
 117         return mBuffer.size();
 118 }
 119
 120 int Buffer::addString(QByteArray s, DWORD len)
 121 {
 122         Q_UNUSED( len );
 123         return addString( s );
 124 }
 125
 126 int Buffer::addString( const char* s, DWORD len )
 127 {
 128         QByteArray qba( s, len );
 129         return addString( qba );
 130 }
 131
 132 int Buffer::addString(const unsigned char* s, DWORD len)
 133 {
 134         QByteArray qba( (const char*) s, len );
 135         return addString( qba );
 136 }
 137
 138 int Buffer::addLEString(const char *s, const DWORD len)
 139 {
 140         unsigned int pos = mBuffer.size();
 141         expandBuffer(len);
 142         //concatenate the new string onto the buffer
 143         for(unsigned int i=0; i<len; i++)
 144         {
 145                 mBuffer[pos+i]=((s[i]) & 0xff);
 146         }
 147         return mBuffer.size();
 148 }
 149
 150
 151 void Buffer::clear()
 152 {
 153         mBuffer.truncate( 0 );
 154         mReadPos=0;
 155 }
 156
 157 int Buffer::addTLV( const TLV& t )
 158 {
 159         return addTLV( t.type, t.data );
 160 }
 161
 162 int Buffer::addTLV( WORD type, const QByteArray& data )
 163 {
 164         addWord( type );
 165         addWord( data.length() );
 166         return addString( data );
 167 }
 168
 169 int Buffer::addLETLV( WORD type, const QByteArray& data )
 170 {
 171         addLEWord( type );
 172         addLEWord( data.length() );
 173         return addString( data );
 174 }
 175
 176 BYTE Buffer::getByte()
 177 {
 178         BYTE thebyte = 0x00;
 179
 180         if(mReadPos < mBuffer.size())
 181         {
 182                 thebyte = mBuffer[mReadPos];
 183                 mReadPos++;
 184         }
 185         else
 186                 kDebug(14150) << "Buffer::getByte(): mBuffer empty" << endl;
 187
 188         return thebyte;
 189 }
 190
 191 void Buffer::skipBytes( int bytesToSkip )
 192 {
 193         if (mReadPos < mBuffer.size())
 194                 mReadPos += bytesToSkip;
 195 }
 196
 197 BYTE Buffer::getLEByte()
 198 {
 199         BYTE b = getByte();
 200         return (b & 0xff);
 201 }
 202
 203 WORD Buffer::getWord()
 204 {
 205         WORD theword, theword2, retword;
 206         theword = getByte();
 207         theword2 = getByte();
 208         retword = (theword << 8) | theword2;
 209         return retword;
 210 }
 211
 212 WORD Buffer::getLEWord()
 213 {
 214         WORD theword1, theword2, retword;
 215         theword1 = getLEByte();
 216         theword2 = getLEByte();
 217         retword = (theword2 << 8) | theword1;
 218         return retword;
 219 }
 220
 221 DWORD Buffer::getDWord()
 222 {
 223         DWORD word1, word2;
 224         DWORD retdword;
 225         word1 = getWord();
 226         word2 = getWord();
 227         retdword = (word1 << 16) | word2;
 228         return retdword;
 229 }
 230
 231 DWORD Buffer::getLEDWord()
 232 {
 233         DWORD word1, word2, retdword;
 234         word1 = getLEWord();
 235         word2 = getLEWord();
 236         retdword = (word2 << 16) | word1;
 237         return retdword;
 238 }
 239
 240 void Buffer::setBuf(char *b, const WORD len)
 241 {
 242         mBuffer = QByteArray::fromRawData(b, len);
 243         mReadPos = 0;
 244 }
 245
 246 QByteArray Buffer::getBlock(WORD len)
 247 {
 248         QByteArray ch;
 249         ch.resize( len );
 250
 251         for ( int i = 0; i < len; i++ )
 252         {
 253                 ch[i] = getByte();
 254         }
 255
 256         return ch;
 257 }
 258
 259 QByteArray Buffer::getBBlock(WORD len)
 260 {
 261         QByteArray data = QByteArray::fromRawData( mBuffer.data() + mReadPos, len);
 262         mReadPos += len;
 263         return data;
 264 }
 265
 266
 267 WORD *Buffer::getWordBlock(WORD len)
 268 {
 269         kDebug(14150) << k_funcinfo << "of length " << len << endl;
 270         WORD *ch=new WORD[len+1];
 271         for (unsigned int i=0; i<len; i++)
 272         {
 273                 ch[i]=getWord();
 274         }
 275         ch[len]=0;
 276         return ch;
 277 }
 278
 279
 280 QByteArray Buffer::getLEBlock(WORD len)
 281 {
 282         QByteArray ch;
 283         for (unsigned int i=0;i<len;i++)
 284                 ch += getLEByte();
 285
 286         return ch;
 287 }
 288
 289 int Buffer::addTLV16(const WORD type, const WORD data)
 290 {
 291         addWord(type);
 292         addWord(0x0002); //2 bytes long
 293         return addWord(data);
 294 }
 295
 296 int Buffer::addLETLV16(const WORD type, const WORD data)
 297 {
 298         addLEWord(type);
 299         addLEWord(0x0002); //2 bytes long
 300         return addLEWord(data);
 301 }
 302
 303 int Buffer::addTLV8(const WORD type, const BYTE data)
 304 {
 305         addWord(type);
 306         addWord(0x0001); //1 byte long
 307         return addByte(data);
 308 }
 309
 310 int Buffer::addLETLV8(const WORD type, const BYTE data)
 311 {
 312         addLEWord(type);
 313         addLEWord(0x0001); //1 byte long
 314         return addLEByte(data);
 315 }
 316
 317 TLV Buffer::getTLV()
 318 {
 319         TLV t;
 320         if(bytesAvailable() >= 4)
 321         {
 322                 t.type = getWord();
 323                 t.length = getWord();
 324                 if ( t )
 325                         t.data = getBlock( t.length );
 326                 /*else
 327                         kDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "Invalid TLV in buffer" << endl;*/
 328         }
 329
 330         //kDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "TLV data is " << t.data << endl;
 331         return t;
 332 }
 333
 334 QList<TLV> Buffer::getTLVList()
 335 {
 336         QList<TLV> ql;
 337
 338         while (mReadPos < mBuffer.size())
 339         {
 340                 TLV t;
 341
 342                 t = getTLV();
 343                 if ( !t )
 344                 {
 345                         kDebug(14150) << k_funcinfo << "Invalid TLV found" << endl;
 346                         continue;
 347                 }
 348
 349                 //kDebug(14150) << k_funcinfo << "got TLV(" << t.type << ")" << endl;
 350                 ql.append(t);
 351         }
 352
 353         return ql;
 354 }
 355
 356 int Buffer::addChatTLV(const WORD type, const WORD exchange,
 357         const QString &roomname, const WORD instance)
 358 {
 359         addWord(type);
 360         addWord(0x0005 + roomname.length());
 361         addWord(exchange);
 362         addByte(roomname.length());
 363         addString(roomname.toLatin1(), roomname.length()); // TODO: check encoding
 364
 365         return addWord(instance);
 366 }
 367
 368 void Buffer::expandBuffer(unsigned int inc)
 369 {
 370         mBuffer.resize(mBuffer.size()+inc);
 371 }
 372
 373 QByteArray Buffer::getLNTS()
 374 {
 375         WORD len = getWord() - 1;
 376         QByteArray qcs( getBlock(len) );
 377         skipBytes( 1 );
 378         return qcs;
 379 }
 380
 381 QByteArray Buffer::getLELNTS()
 382 {
 383         WORD len = getLEWord() - 1;
 384         QByteArray qcs( getBlock(len) );
 385         skipBytes( 1 );
 386         return qcs;
 387 }
 388
 389 int Buffer::addLNTS(const char *s)
 390 {
 391         unsigned int len = strlen(s);
 392
 393         addLEWord(len+1);
 394         if(len > 0)
 395                 addString(s, len);
 396         int ret = addByte(0x00);
 397         return ret;
 398 }
 399
 400 int Buffer::addLELNTS(const char *s)
 401 {
 402         unsigned int len = strlen(s);
 403         int ret = addLEWord(len+1);
 404         if(len > 0)
 405                 ret = addLEString(s, len);
 406         ret = addByte(0x00);
 407         return ret;
 408 }
 409
 410 int Buffer::addBSTR(const char * s)
 411 {
 412         unsigned int len = strlen(s);
 413         int ret = addWord(len);
 414         if(len > 0)
 415                 ret = addString(s, len);
 416         return ret;
 417 }
 418
 419 QByteArray Buffer::getBSTR()
 420 {
 421         WORD len = getWord();
 422         QByteArray qba( getBlock(len) );
 423         return qba;
 424 }
 425
 426 int Buffer::addBUIN(const char * s)
 427 {
 428         unsigned int len = strlen(s);
 429         int ret = addByte(len);
 430         ret = addString(s, len);
 431         return ret;
 432 }
 433
 434 QByteArray Buffer::getBUIN()
 435 {
 436         BYTE len = getByte();
 437         QByteArray qba( getBlock(len) );
 438         return qba;
 439 }
 440
 441 QByteArray Buffer::buffer() const
 442 {
 443         return mBuffer;
 444 }
 445
 446 int Buffer::length() const
 447 {
 448         return mBuffer.size();
 449 }
 450
 451 int Buffer::bytesAvailable() const
 452 {
 453         return (mBuffer.size() - mReadPos);
 454 }
 455
 456
 457
 458 QString Buffer::toString() const
 459 {
 460         // line format:
 461         //00 03 00 0b 00 00 90 b8 f5 9f 09 31 31 33 37 38   |;tJ�..........|
 462
 463         int i = 0;
 464         QString output = "\n";
 465         QString hex, ascii;
 466
 467         QByteArray::ConstIterator it;
 468         for ( it = mBuffer.begin(); it != mBuffer.end(); ++it )
 469         {
 470                 i++;
 471
 472                 unsigned char c = static_cast<unsigned char>(*it);
 473
 474                 if ( c < 0x10 )
 475                         hex.append("0");
 476                 hex.append(QString("%1 ").arg(c, 0, 16));
 477
 478                 ascii.append(isprint(c) ? c : '.');
 479
 480                 if (i == 16)
 481                 {
 482                         output += hex + "   |" + ascii + "|\n";
 483                         i=0;
 484                         hex.clear();
 485                         ascii.clear();
 486                 }
 487         }
 488
 489         if(!hex.isEmpty())
 490                 output += hex.leftJustified(48, ' ') + "   |" + ascii.leftJustified(16, ' ') + '|';
 491         output.append('\n');
 492
 493         return output;
 494 }
 495
 496 QString Buffer::peekBSTR()
 497 {
 498         int lastPos = mReadPos;
 499         QByteArray qba = getBSTR();
 500         mReadPos = lastPos;
 501         return QString( qba );
 502 }
 503 QString Buffer::peekBUIN()
 504 {
 505         int lastPos = mReadPos;
 506         QByteArray qba = getBUIN();
 507         mReadPos = lastPos;
 508         return QString( qba );
 509 }
 510
 511
 512 int Buffer::addGuid( const Guid & g )
 513 {
 514         if (g.isValid())
 515                 return addString( g.data() );
 516         return mBuffer.size();
 517 }
 518
 519
 520 Guid Buffer::getGuid()
 521 {
 522         return Guid(getBBlock(16)); //block or bblock?
 523 }
 524
 525
 526 Buffer::operator QByteArray() const
 527 {
 528         return mBuffer;
 529 }
 530 //kate: tab-width 4; indent-mode csands;