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(DWORD len)
 247 {
 248         if ( len > (DWORD)(mBuffer.size() - mReadPos) )
 249         {
 250                 kDebug(14150) << "Buffer::getBlock(DWORD): mBuffer underflow!!!" << endl;
 251                 len = mBuffer.size() - mReadPos;
 252         }
 253
 254         QByteArray ch;
 255         ch.resize( len );
 256
 257         for ( DWORD i = 0; i < len; i++ )
 258         {
 259                 ch[i] = getByte();
 260         }
 261
 262         return ch;
 263 }
 264
 265 QByteArray Buffer::getBBlock(WORD len)
 266 {
 267         QByteArray data = QByteArray::fromRawData( mBuffer.data() + mReadPos, len);
 268         mReadPos += len;
 269         return data;
 270 }
 271
 272
 273 WORD *Buffer::getWordBlock(WORD len)
 274 {
 275         kDebug(14150) << k_funcinfo << "of length " << len << endl;
 276         WORD *ch=new WORD[len+1];
 277         for (unsigned int i=0; i<len; i++)
 278         {
 279                 ch[i]=getWord();
 280         }
 281         ch[len]=0;
 282         return ch;
 283 }
 284
 285
 286 QByteArray Buffer::getLEBlock(WORD len)
 287 {
 288         QByteArray ch;
 289         for (unsigned int i=0;i<len;i++)
 290                 ch += getLEByte();
 291
 292         return ch;
 293 }
 294
 295 int Buffer::addTLV32(const WORD type, const DWORD data)
 296 {
 297         addWord(type);
 298         addWord(0x0004); //4 bytes long
 299         return addDWord(data);
 300 }
 301
 302 int Buffer::addLETLV32(const WORD type, const DWORD data)
 303 {
 304         addLEWord(type);
 305         addLEWord(0x0004); //4 bytes long
 306         return addLEDWord(data);
 307 }
 308
 309 int Buffer::addTLV16(const WORD type, const WORD data)
 310 {
 311         addWord(type);
 312         addWord(0x0002); //2 bytes long
 313         return addWord(data);
 314 }
 315
 316 int Buffer::addLETLV16(const WORD type, const WORD data)
 317 {
 318         addLEWord(type);
 319         addLEWord(0x0002); //2 bytes long
 320         return addLEWord(data);
 321 }
 322
 323 int Buffer::addTLV8(const WORD type, const BYTE data)
 324 {
 325         addWord(type);
 326         addWord(0x0001); //1 byte long
 327         return addByte(data);
 328 }
 329
 330 int Buffer::addLETLV8(const WORD type, const BYTE data)
 331 {
 332         addLEWord(type);
 333         addLEWord(0x0001); //1 byte long
 334         return addLEByte(data);
 335 }
 336
 337 TLV Buffer::getTLV()
 338 {
 339         TLV t;
 340         if(bytesAvailable() >= 4)
 341         {
 342                 t.type = getWord();
 343                 t.length = getWord();
 344                 if ( t )
 345                         t.data = getBlock( t.length );
 346                 /*else
 347                         kDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "Invalid TLV in buffer" << endl;*/
 348         }
 349
 350         //kDebug(OSCAR_RAW_DEBUG) << k_funcinfo << "TLV data is " << t.data << endl;
 351         return t;
 352 }
 353
 354 QList<TLV> Buffer::getTLVList()
 355 {
 356         QList<TLV> ql;
 357
 358         while (mReadPos < mBuffer.size())
 359         {
 360                 TLV t;
 361
 362                 t = getTLV();
 363                 if ( !t )
 364                 {
 365                         kDebug(14150) << k_funcinfo << "Invalid TLV found" << endl;
 366                         continue;
 367                 }
 368
 369                 //kDebug(14150) << k_funcinfo << "got TLV(" << t.type << ")" << endl;
 370                 ql.append(t);
 371         }
 372
 373         return ql;
 374 }
 375
 376 int Buffer::addChatTLV(const WORD type, const WORD exchange,
 377         const QString &roomname, const WORD instance)
 378 {
 379         addWord(type);
 380         addWord(0x0005 + roomname.length());
 381         addWord(exchange);
 382         addByte(roomname.length());
 383         addString(roomname.toLatin1()); // TODO: check encoding
 384
 385         return addWord(instance);
 386 }
 387
 388 void Buffer::expandBuffer(unsigned int inc)
 389 {
 390         mBuffer.resize(mBuffer.size()+inc);
 391 }
 392
 393 QByteArray Buffer::getLNTS()
 394 {
 395         WORD len = getWord() - 1;
 396         QByteArray qcs( getBlock(len) );
 397         skipBytes( 1 );
 398         return qcs;
 399 }
 400
 401 QByteArray Buffer::getLELNTS()
 402 {
 403         WORD len = getLEWord() - 1;
 404         QByteArray qcs( getBlock(len) );
 405         skipBytes( 1 );
 406         return qcs;
 407 }
 408
 409 int Buffer::addLNTS(const char *s)
 410 {
 411         unsigned int len = strlen(s);
 412
 413         addLEWord(len+1);
 414         if(len > 0)
 415                 addString(s, len);
 416         int ret = addByte(0x00);
 417         return ret;
 418 }
 419
 420 int Buffer::addLELNTS(const char *s)
 421 {
 422         unsigned int len = strlen(s);
 423         int ret = addLEWord(len+1);
 424         if(len > 0)
 425                 ret = addLEString(s, len);
 426         ret = addByte(0x00);
 427         return ret;
 428 }
 429
 430 int Buffer::addBSTR(const char * s)
 431 {
 432         unsigned int len = strlen(s);
 433         int ret = addWord(len);
 434         if(len > 0)
 435                 ret = addString(s, len);
 436         return ret;
 437 }
 438
 439 QByteArray Buffer::getBSTR()
 440 {
 441         WORD len = getWord();
 442         QByteArray qba( getBlock(len) );
 443         return qba;
 444 }
 445
 446 int Buffer::addBUIN(const char * s)
 447 {
 448         unsigned int len = strlen(s);
 449         int ret = addByte(len);
 450         ret = addString(s, len);
 451         return ret;
 452 }
 453
 454 QByteArray Buffer::getBUIN()
 455 {
 456         BYTE len = getByte();
 457         QByteArray qba( getBlock(len) );
 458         return qba;
 459 }
 460
 461 QByteArray Buffer::buffer() const
 462 {
 463         return mBuffer;
 464 }
 465
 466 int Buffer::length() const
 467 {
 468         return mBuffer.size();
 469 }
 470
 471 int Buffer::bytesAvailable() const
 472 {
 473         return (mBuffer.size() - mReadPos);
 474 }
 475
 476
 477
 478 QString Buffer::toString() const
 479 {
 480         // line format:
 481         //00 03 00 0b 00 00 90 b8 f5 9f 09 31 31 33 37 38   |;tJ�..........|
 482
 483         int i = 0;
 484         QString output = "\n";
 485         QString hex, ascii;
 486
 487         QByteArray::ConstIterator it;
 488         for ( it = mBuffer.begin(); it != mBuffer.end(); ++it )
 489         {
 490                 i++;
 491
 492                 unsigned char c = static_cast<unsigned char>(*it);
 493
 494                 if ( c < 0x10 )
 495                         hex.append("0");
 496                 hex.append(QString("%1 ").arg(c, 0, 16));
 497
 498                 ascii.append(isprint(c) ? c : '.');
 499
 500                 if (i == 16)
 501                 {
 502                         output += hex + "   |" + ascii + "|\n";
 503                         i=0;
 504                         hex.clear();
 505                         ascii.clear();
 506                 }
 507         }
 508
 509         if(!hex.isEmpty())
 510                 output += hex.leftJustified(48, ' ') + "   |" + ascii.leftJustified(16, ' ') + '|';
 511         output.append('\n');
 512
 513         return output;
 514 }
 515
 516 QString Buffer::peekBSTR()
 517 {
 518         int lastPos = mReadPos;
 519         QByteArray qba = getBSTR();
 520         mReadPos = lastPos;
 521         return QString( qba );
 522 }
 523 QString Buffer::peekBUIN()
 524 {
 525         int lastPos = mReadPos;
 526         QByteArray qba = getBUIN();
 527         mReadPos = lastPos;
 528         return QString( qba );
 529 }
 530
 531
 532 int Buffer::addGuid( const Guid & g )
 533 {
 534         if (g.isValid())
 535                 return addString( g.data() );
 536         return mBuffer.size();
 537 }
 538
 539
 540 Guid Buffer::getGuid()
 541 {
 542         return Guid(getBBlock(16)); //block or bblock?
 543 }
 544
 545 int Buffer::addLEBlock( const QByteArray& block )
 546 {
 547         int ret = addLEWord( block.length() );
 548         if ( block.length() > 0 )
 549                 ret = addString( block );
 550
 551         return ret;
 552 }
 553
 554 QByteArray Buffer::addLEBlock()
 555 {
 556         DWORD len = getLEWord();
 557         return getBlock( len );
 558 }
 559
 560 int Buffer::addLEDBlock( const QByteArray& block )
 561 {
 562         int ret = addLEDWord( block.length() );
 563         if ( block.length() > 0 )
 564                 ret = addString( block );
 565
 566         return ret;
 567 }
 568
 569 QByteArray Buffer::getLEDBlock()
 570 {
 571         DWORD len = getLEDWord();
 572         return getBlock( len );
 573 }
 574
 575 Buffer::operator QByteArray() const
 576 {
 577         return mBuffer;
 578 }
 579 //kate: tab-width 4; indent-mode csands;