src/utils/plasmamule/qt-emc.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2010 Werner Mahr (Vollstrecker) <amule@vollstreckernet.de>
   5 //
   6 // Any parts of this program contributed by third-party developers are copyrighted
   7 // by their respective authors.
   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 3 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.  See the
  17 // GNU General Public License for more details.
  18 //
  19 // You should have received a copy of the GNU General Public License
  20 // along with this program; if not, write to the Free Software
  21 // Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301, USA
  22 //
  23
  24 #include "qt-emc.h"
  25
  26 qtEmc::qtEmc(const QString &filename)
  27 {
  28
  29         QStringList files = filename.split("file://");
  30
  31         for (QStringList::const_iterator constFilesIterator = files.constBegin(); constFilesIterator != files.constEnd(); constFilesIterator++)
  32         {
  33                 if (!QString(*constFilesIterator).remove("\n").trimmed().isEmpty())
  34                 {
  35                         QFile collection(QString(*constFilesIterator).trimmed());
  36
  37                         if (collection.open (QIODevice::ReadOnly))
  38                         {
  39                                 valid = readBinary(collection);
  40                         } else {
  41                                 valid = FALSE;
  42                                 errorCode = BadFileFormat;
  43                         }
  44
  45                         collection.close();
  46                 }
  47         }
  48 }
  49
  50 const int qtEmc::getError()
  51 {
  52         return errorCode;
  53 }
  54
  55 const QString qtEmc::getErrorMessage()
  56 {
  57
  58         switch (errorCode)
  59         {
  60                 case BadFileFormat:
  61                 {
  62                         return QString("File format wasn't recognised");
  63                 }
  64
  65                 case BadTagFormat:
  66                 {
  67                         return QString("Tag format -%1- not recognized.").arg(lastTag);
  68                 }
  69
  70                 case UnknownTag:
  71                 {
  72                         return QString("An unknown Tag (%1 in type %2) was read from collection file").arg(lastTag).arg(lastTagType);
  73                 }
  74
  75                 case UnknownTagType:
  76                 {
  77                         return QString("An unknown type of tag (%1) was read from file").arg(lastTagType);
  78                 }
  79
  80                 case WrongTagCount:
  81                 {
  82                         return QString("Tag count claims to be %1").arg(lastTag);
  83                 }
  84
  85                 case CorruptFile:
  86                 {
  87                         return QString("Your collection file was corrupted and ends to Early");
  88                 }
  89         }
  90 }
  91
  92 const QStringList qtEmc::getLinks()
  93 {
  94         return list;
  95 }
  96
  97 const bool qtEmc::isValid()
  98 {
  99         return valid;
 100 }
 101
 102 bool qtEmc::readBinary(QFile &collection)
 103 {
 104         int fileSize;
 105         QString fileHash, fileName;
 106         quint8 rating, sFileSize, tag, tagType;
 107         quint16 length, mFileSize;
 108         quint32 lFileSize, llength, tagCount;
 109         quint64 xlFileSize;
 110
 111         QDataStream in(&collection);
 112         in.setByteOrder(QDataStream::LittleEndian);
 113
 114         in >> emcVersion >> headerTagCount;
 115
 116         if (in.atEnd())
 117         {
 118                 errorCode = CorruptFile;
 119                 return FALSE;
 120         } else if (emcVersion > 0x02)
 121         {
 122                 return readText(collection);
 123         }
 124
 125         for (int i=1; i<=headerTagCount; i++)
 126         {
 127                 in >> tagType >> tagFormat;
 128
 129                 if (in.atEnd())
 130                 {
 131                         errorCode = CorruptFile;
 132                         return FALSE;
 133                 }
 134
 135                 if (tagFormat != 1)
 136                 {
 137                         lastTag = tag;
 138                         errorCode = BadTagFormat;
 139                         return FALSE;
 140                 }
 141
 142                 in >> tag;
 143
 144                 if (in.atEnd())
 145                 {
 146                         errorCode = CorruptFile;
 147                         return FALSE;
 148                 }
 149
 150                 switch (tag)
 151                 {
 152                         case 0x01: //FT_FILENAME
 153                         {
 154                                 in >> length;
 155
 156                                 if (in.atEnd())
 157                                 {
 158                                         errorCode = CorruptFile;
 159                                         return FALSE;
 160                                 }
 161
 162                                 char* buffer = new char[length];
 163                                 in.readRawData(buffer, length);
 164
 165                                 name = QString(buffer);
 166
 167                                 delete [] buffer;
 168                                 break;
 169                         }
 170
 171                         case 0x31: //FT_COLLECTIONAUTHOR
 172                         {
 173                                 in >> length;
 174
 175                                 if (in.atEnd())
 176                                 {
 177                                         errorCode = CorruptFile;
 178                                         return FALSE;
 179                                 }
 180
 181                                 char* buffer = new char[length];
 182                                 in.readRawData(buffer, length);
 183
 184                                 author = QString(buffer);
 185
 186                                 delete [] buffer;
 187                                 break;
 188                         }
 189
 190                         case 0x32: //FT_COLLECTIONAUTHORKEY
 191                         {
 192                                 in >> llength;
 193
 194                                 if (in.atEnd())
 195                                 {
 196                                         errorCode = CorruptFile;
 197                                         return FALSE;
 198                                 }
 199
 200                                 char* buffer = new char[llength];
 201                                 in.readRawData(buffer, llength);
 202                                 authorKey = QString(buffer);
 203
 204                                 delete [] buffer;
 205                                 break;
 206                         }
 207
 208                         default:
 209                         {
 210                                 lastTag = tag;
 211                                 errorCode = UnknownTag;
 212                                 return FALSE;
 213                         }
 214
 215                         break;
 216                 }
 217         }
 218
 219         in >> fileCount;
 220
 221         if (in.atEnd())
 222         {
 223                 errorCode = CorruptFile;
 224                 return FALSE;
 225         }
 226
 227         for (int i=1; i<=fileCount; i++)
 228         {
 229                 fileHash.clear();
 230                 fileName.clear();
 231
 232                 in >> tagCount;
 233
 234                 if (in.atEnd())
 235                 {
 236                         errorCode = CorruptFile;
 237                         return FALSE;
 238                 }
 239
 240                 if (tagCount > 5)
 241                 {
 242                         lastTag = tagCount;
 243                         errorCode = WrongTagCount;
 244                         return FALSE;
 245                 }
 246
 247                 for (int j=1; j<=tagCount; j++)
 248                 {
 249                         in >> tag;
 250
 251                         if (in.atEnd())
 252                         {
 253                                 errorCode = CorruptFile;
 254                                 return FALSE;
 255                         }
 256
 257                         in >> tagType;
 258
 259                         if (in.atEnd())
 260                         {
 261                                 errorCode = CorruptFile;
 262                                 return FALSE;
 263                         }
 264
 265                         switch (tagType)
 266                         {
 267                                 case 0x01: // FT_FILENAME
 268                                 {
 269                                         switch (tag)
 270                                         {
 271                                                 case 0x82:
 272                                                 {
 273                                                         in >> length;
 274
 275                                                         if (in.atEnd())
 276                                                         {
 277                                                                 errorCode = CorruptFile;
 278                                                                 return FALSE;
 279                                                         }
 280
 281                                                         char* buffer = new char[length];
 282                                                         in.readRawData(buffer, length);
 283                                                         fileName = QString().fromLocal8Bit(buffer, length).trimmed();
 284
 285                                                         if (fileName.length() > length)
 286                                                         {
 287                                                                 fileName.chop(fileName.length() - length);
 288                                                         } else if (fileName.length() == length)
 289                                                         {
 290                                                                 int pos=0;
 291
 292                                                                 for (int k=0; k<length; k++)
 293                                                                 {
 294                                                                         if (fileName.at(k) != buffer[k+pos])
 295                                                                         {
 296                                                                                 pos++;
 297                                                                         }
 298                                                                 }
 299
 300                                                                 fileName.chop(pos);
 301                                                         }
 302
 303                                                         delete [] buffer;
 304
 305                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 306                                                         {
 307                                                                 errorCode = CorruptFile;
 308                                                                 return FALSE;
 309                                                         }
 310
 311                                                         break;
 312                                                 }
 313
 314                                                 default:
 315                                                 {
 316                                                         if (((tag^0x80) >= 0x11) && ((tag^0x80) <= 0x20))
 317                                                         {
 318
 319                                                                 length = (tag^0x80) - 0x10;
 320
 321                                                                 char* buffer = new char[length];
 322                                                                 in.readRawData(buffer, length);
 323                                                                 fileName = QString().fromLocal8Bit(buffer, length).trimmed();
 324
 325                                                                 if (fileName.length() > length)
 326                                                                 {
 327                                                                         fileName.chop(fileName.length() - length);
 328                                                                 } else if (fileName.length() == length)
 329                                                                 {
 330                                                                         int pos=0;
 331
 332                                                                         for (int k=0; k<length; k++)
 333                                                                         {
 334                                                                                 if (fileName.at(k) != buffer[k+pos])
 335                                                                                 {
 336                                                                                         pos++;
 337                                                                                 }
 338                                                                         }
 339
 340                                                                         fileName.chop(pos);
 341                                                                 }
 342
 343                                                                 delete [] buffer;
 344
 345                                                                 if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 346                                                                 {
 347                                                                         errorCode = CorruptFile;
 348                                                                         return FALSE;
 349                                                                 }
 350                                                         } else {
 351                                                                 lastTag = tag;
 352                                                                 lastTagType = tagType;
 353                                                                 errorCode = UnknownTag;
 354                                                                 return FALSE;
 355                                                         }
 356                                                 }
 357                                         }
 358
 359                                         break;
 360                                 }
 361
 362                                 case 0x02: //FT_FILESIZE
 363                                 {
 364                                         switch (tag)
 365                                         {
 366                                                 case 0x83:
 367                                                 {
 368                                                         in >> lFileSize;
 369                                                         fileSize = lFileSize;
 370
 371                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 372                                                         {
 373                                                                 errorCode = CorruptFile;
 374                                                                 return FALSE;
 375                                                         }
 376
 377                                                         break;
 378                                                 }
 379
 380                                                 case 0x88:
 381                                                 {
 382                                                         in >> mFileSize;
 383                                                         fileSize = mFileSize;
 384
 385                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 386                                                         {
 387                                                                 errorCode = CorruptFile;
 388                                                                 return FALSE;
 389                                                         }
 390
 391                                                         break;
 392                                                 }
 393
 394                                                 case 0x89:
 395                                                 {
 396                                                         in >> sFileSize;
 397                                                         fileSize = sFileSize;
 398
 399                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 400                                                         {
 401                                                                 errorCode = CorruptFile;
 402                                                                 return FALSE;
 403                                                         }
 404
 405                                                         break;
 406                                                 }
 407
 408                                                 case 0x8b:
 409                                                 {
 410                                                         in >> xlFileSize;
 411                                                         fileSize = xlFileSize;
 412
 413                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 414                                                         {
 415                                                                 errorCode = CorruptFile;
 416                                                                 return FALSE;
 417                                                         }
 418
 419                                                         break;
 420                                                 }
 421
 422                                                 default:
 423                                                 {
 424                                                         lastTag = tag;
 425                                                         lastTagType = tagType;
 426                                                         errorCode = UnknownTag;
 427                                                         return FALSE;
 428                                                 }
 429                                         }
 430
 431                                         break;
 432                                 }
 433
 434                                 case 0x28: //FT_FILEHASH
 435                                 {
 436                                         switch (tag)
 437                                         {
 438                                                 case 0x81: //FT_FILEHASH
 439                                                 {
 440                                                         char* buffer = new char[16];
 441                                                         in.readRawData(buffer, 16);
 442
 443                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 444                                                         {
 445                                                                 errorCode = CorruptFile;
 446                                                                 return FALSE;
 447                                                         }
 448
 449                                                         for (int pos = 0; pos < 16; pos++)
 450                                                         {
 451                                                                 fileHash.append(QString().setNum(((buffer[pos] >> 4) & 0xF), 16));
 452                                                                 fileHash.append(QString().setNum((buffer[pos] & 0x0F), 16));
 453                                                         }
 454
 455                                                         delete [] buffer;
 456                                                         break;
 457                                                 }
 458
 459                                                 default:
 460                                                 {
 461                                                         lastTag = tag;
 462                                                         lastTagType = tagType;
 463                                                         errorCode = UnknownTag;
 464                                                         return FALSE;
 465                                                 }
 466                                         }
 467
 468                                         break;
 469                                 }
 470 // The comment is read correctly. It will be stored when I know what to do with it.
 471                                 case 0xf6: //FT_FILECOMMENT
 472                                 {
 473                                         if ((tag^0x80) == 0x02)
 474                                         {
 475                                                 in >> length;
 476
 477                                                 if (in.atEnd())
 478                                                 {
 479                                                         errorCode = CorruptFile;
 480                                                         return FALSE;
 481                                                 }
 482                                         } else {
 483                                                 length = ((tag^0x80)-0x10);
 484                                         }
 485
 486                                         char* buffer = new char[length];
 487                                         in.readRawData(buffer, length);
 488
 489                                         delete [] buffer;
 490                                         break;
 491                                 }
 492 // The file-rating is read correctly. It will be stored when I know what to do with it.
 493                                 case 0xf7: //FT_FILERATING
 494                                 {
 495                                         in >> rating;
 496
 497                                         break;
 498                                 }
 499
 500                                 default:
 501                                 {
 502                                         lastTagType = tagType;
 503                                         errorCode = UnknownTagType;
 504                                         return FALSE;
 505                                 }
 506                         }
 507                 }
 508
 509                 list.append(QString("ed2k://|file|%1|%2|%3|/").arg(fileName).arg(fileSize).arg(fileHash));
 510         }
 511
 512         return TRUE;
 513 }
 514
 515 bool qtEmc::readText(QFile &collection)
 516 {
 517         quint8 character;
 518         QString tmp;
 519
 520         collection.seek(0);
 521         QDataStream in(&collection);
 522         in.setByteOrder(QDataStream::LittleEndian);
 523
 524         for (int i=0; i<=6; i++)
 525         {
 526                 in >> character;
 527                 tmp.append(character);
 528         }
 529
 530         if (tmp == "ed2k://")
 531         {
 532                 while (!in.atEnd())
 533                 {
 534                         in >> character;
 535
 536                         if (character == 0x0d)
 537                         {
 538                                 list.append(tmp);
 539                                 tmp.clear();
 540                         } else if (character != 0x0a)
 541                         {
 542                                 tmp.append(character);
 543                         }
 544                 }
 545         } else {
 546                         errorCode = BadFileFormat;
 547                         return FALSE;
 548         }
 549
 550         return TRUE;
 551 }