src/utils/plasmamule/qt-emc.cpp

   1 //
   2 // This file is part of the aMule Project.
   3 //
   4 // Copyright (c) 2010-2011 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         return QString("Unknown Error-Code");
  92 }
  93
  94 const QStringList qtEmc::getLinks()
  95 {
  96         return list;
  97 }
  98
  99 const bool qtEmc::isValid()
 100 {
 101         return valid;
 102 }
 103
 104 bool qtEmc::readBinary(QFile &collection)
 105 {
 106         int fileSize;
 107         QString fileHash, fileName;
 108         quint8 rating, sFileSize, tag, tagType;
 109         quint16 length, mFileSize;
 110         quint32 lFileSize, llength, tagCount;
 111         quint64 xlFileSize;
 112
 113         QDataStream in(&collection);
 114         in.setByteOrder(QDataStream::LittleEndian);
 115
 116         in >> emcVersion >> headerTagCount;
 117
 118         if (in.atEnd())
 119         {
 120                 errorCode = CorruptFile;
 121                 return FALSE;
 122         } else if (emcVersion > 0x02)
 123         {
 124                 return readText(collection);
 125         }
 126
 127         for (int i=1; i<=headerTagCount; i++)
 128         {
 129                 in >> tagType >> tagFormat;
 130
 131                 if (in.atEnd())
 132                 {
 133                         errorCode = CorruptFile;
 134                         return FALSE;
 135                 }
 136
 137                 if (tagFormat != 1)
 138                 {
 139                         lastTag = tag;
 140                         errorCode = BadTagFormat;
 141                         return FALSE;
 142                 }
 143
 144                 in >> tag;
 145
 146                 if (in.atEnd())
 147                 {
 148                         errorCode = CorruptFile;
 149                         return FALSE;
 150                 }
 151
 152                 switch (tag)
 153                 {
 154                         case 0x01: //FT_FILENAME
 155                         {
 156                                 in >> length;
 157
 158                                 if (in.atEnd())
 159                                 {
 160                                         errorCode = CorruptFile;
 161                                         return FALSE;
 162                                 }
 163
 164                                 char* buffer = new char[length];
 165                                 in.readRawData(buffer, length);
 166
 167                                 name = QString(buffer);
 168
 169                                 delete [] buffer;
 170                                 break;
 171                         }
 172
 173                         case 0x31: //FT_COLLECTIONAUTHOR
 174                         {
 175                                 in >> length;
 176
 177                                 if (in.atEnd())
 178                                 {
 179                                         errorCode = CorruptFile;
 180                                         return FALSE;
 181                                 }
 182
 183                                 char* buffer = new char[length];
 184                                 in.readRawData(buffer, length);
 185
 186                                 author = QString(buffer);
 187
 188                                 delete [] buffer;
 189                                 break;
 190                         }
 191
 192                         case 0x32: //FT_COLLECTIONAUTHORKEY
 193                         {
 194                                 in >> llength;
 195
 196                                 if (in.atEnd())
 197                                 {
 198                                         errorCode = CorruptFile;
 199                                         return FALSE;
 200                                 }
 201
 202                                 char* buffer = new char[llength];
 203                                 in.readRawData(buffer, llength);
 204                                 authorKey = QString(buffer);
 205
 206                                 delete [] buffer;
 207                                 break;
 208                         }
 209
 210                         default:
 211                         {
 212                                 lastTag = tag;
 213                                 errorCode = UnknownTag;
 214                                 return FALSE;
 215                         }
 216
 217                         break;
 218                 }
 219         }
 220
 221         in >> fileCount;
 222
 223         if (in.atEnd())
 224         {
 225                 errorCode = CorruptFile;
 226                 return FALSE;
 227         }
 228
 229         for (int i=1; i<=fileCount; i++)
 230         {
 231                 fileHash.clear();
 232                 fileName.clear();
 233
 234                 in >> tagCount;
 235
 236                 if (in.atEnd())
 237                 {
 238                         errorCode = CorruptFile;
 239                         return FALSE;
 240                 }
 241
 242                 if (tagCount > 5)
 243                 {
 244                         lastTag = tagCount;
 245                         errorCode = WrongTagCount;
 246                         return FALSE;
 247                 }
 248
 249                 for (int j=1; j<=tagCount; j++)
 250                 {
 251                         in >> tag;
 252
 253                         if (in.atEnd())
 254                         {
 255                                 errorCode = CorruptFile;
 256                                 return FALSE;
 257                         }
 258
 259                         in >> tagType;
 260
 261                         if (in.atEnd())
 262                         {
 263                                 errorCode = CorruptFile;
 264                                 return FALSE;
 265                         }
 266
 267                         switch (tagType)
 268                         {
 269                                 case 0x01: // FT_FILENAME
 270                                 {
 271                                         switch (tag)
 272                                         {
 273                                                 case 0x82:
 274                                                 {
 275                                                         in >> length;
 276
 277                                                         if (in.atEnd())
 278                                                         {
 279                                                                 errorCode = CorruptFile;
 280                                                                 return FALSE;
 281                                                         }
 282
 283                                                         char* buffer = new char[length];
 284                                                         in.readRawData(buffer, length);
 285                                                         fileName = QString().fromLocal8Bit(buffer, length).trimmed();
 286
 287                                                         if (fileName.length() > length)
 288                                                         {
 289                                                                 fileName.chop(fileName.length() - length);
 290                                                         } else if (fileName.length() == length)
 291                                                         {
 292                                                                 int pos=0;
 293
 294                                                                 for (int k=0; k<length; k++)
 295                                                                 {
 296                                                                         if (fileName.at(k) != buffer[k+pos])
 297                                                                         {
 298                                                                                 pos++;
 299                                                                         }
 300                                                                 }
 301
 302                                                                 fileName.chop(pos);
 303                                                         }
 304
 305                                                         delete [] buffer;
 306
 307                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 308                                                         {
 309                                                                 errorCode = CorruptFile;
 310                                                                 return FALSE;
 311                                                         }
 312
 313                                                         break;
 314                                                 }
 315
 316                                                 default:
 317                                                 {
 318                                                         if (((tag^0x80) >= 0x11) && ((tag^0x80) <= 0x20))
 319                                                         {
 320
 321                                                                 length = (tag^0x80) - 0x10;
 322
 323                                                                 char* buffer = new char[length];
 324                                                                 in.readRawData(buffer, length);
 325                                                                 fileName = QString().fromLocal8Bit(buffer, length).trimmed();
 326
 327                                                                 if (fileName.length() > length)
 328                                                                 {
 329                                                                         fileName.chop(fileName.length() - length);
 330                                                                 } else if (fileName.length() == length)
 331                                                                 {
 332                                                                         int pos=0;
 333
 334                                                                         for (int k=0; k<length; k++)
 335                                                                         {
 336                                                                                 if (fileName.at(k) != buffer[k+pos])
 337                                                                                 {
 338                                                                                         pos++;
 339                                                                                 }
 340                                                                         }
 341
 342                                                                         fileName.chop(pos);
 343                                                                 }
 344
 345                                                                 delete [] buffer;
 346
 347                                                                 if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 348                                                                 {
 349                                                                         errorCode = CorruptFile;
 350                                                                         return FALSE;
 351                                                                 }
 352                                                         } else {
 353                                                                 lastTag = tag;
 354                                                                 lastTagType = tagType;
 355                                                                 errorCode = UnknownTag;
 356                                                                 return FALSE;
 357                                                         }
 358                                                 }
 359                                         }
 360
 361                                         break;
 362                                 }
 363
 364                                 case 0x02: //FT_FILESIZE
 365                                 {
 366                                         switch (tag)
 367                                         {
 368                                                 case 0x83:
 369                                                 {
 370                                                         in >> lFileSize;
 371                                                         fileSize = lFileSize;
 372
 373                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 374                                                         {
 375                                                                 errorCode = CorruptFile;
 376                                                                 return FALSE;
 377                                                         }
 378
 379                                                         break;
 380                                                 }
 381
 382                                                 case 0x88:
 383                                                 {
 384                                                         in >> mFileSize;
 385                                                         fileSize = mFileSize;
 386
 387                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 388                                                         {
 389                                                                 errorCode = CorruptFile;
 390                                                                 return FALSE;
 391                                                         }
 392
 393                                                         break;
 394                                                 }
 395
 396                                                 case 0x89:
 397                                                 {
 398                                                         in >> sFileSize;
 399                                                         fileSize = sFileSize;
 400
 401                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 402                                                         {
 403                                                                 errorCode = CorruptFile;
 404                                                                 return FALSE;
 405                                                         }
 406
 407                                                         break;
 408                                                 }
 409
 410                                                 case 0x8b:
 411                                                 {
 412                                                         in >> xlFileSize;
 413                                                         fileSize = xlFileSize;
 414
 415                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 416                                                         {
 417                                                                 errorCode = CorruptFile;
 418                                                                 return FALSE;
 419                                                         }
 420
 421                                                         break;
 422                                                 }
 423
 424                                                 default:
 425                                                 {
 426                                                         lastTag = tag;
 427                                                         lastTagType = tagType;
 428                                                         errorCode = UnknownTag;
 429                                                         return FALSE;
 430                                                 }
 431                                         }
 432
 433                                         break;
 434                                 }
 435
 436                                 case 0x28: //FT_FILEHASH
 437                                 {
 438                                         switch (tag)
 439                                         {
 440                                                 case 0x81: //FT_FILEHASH
 441                                                 {
 442                                                         char* buffer = new char[16];
 443                                                         in.readRawData(buffer, 16);
 444
 445                                                         if (in.atEnd() && (j != tagCount) && (i =! fileCount))
 446                                                         {
 447                                                                 errorCode = CorruptFile;
 448                                                                 return FALSE;
 449                                                         }
 450
 451                                                         for (int pos = 0; pos < 16; pos++)
 452                                                         {
 453                                                                 fileHash.append(QString().setNum(((buffer[pos] >> 4) & 0xF), 16));
 454                                                                 fileHash.append(QString().setNum((buffer[pos] & 0x0F), 16));
 455                                                         }
 456
 457                                                         delete [] buffer;
 458                                                         break;
 459                                                 }
 460
 461                                                 default:
 462                                                 {
 463                                                         lastTag = tag;
 464                                                         lastTagType = tagType;
 465                                                         errorCode = UnknownTag;
 466                                                         return FALSE;
 467                                                 }
 468                                         }
 469
 470                                         break;
 471                                 }
 472 // The comment is read correctly. It will be stored when I know what to do with it.
 473                                 case 0xf6: //FT_FILECOMMENT
 474                                 {
 475                                         if ((tag^0x80) == 0x02)
 476                                         {
 477                                                 in >> length;
 478
 479                                                 if (in.atEnd())
 480                                                 {
 481                                                         errorCode = CorruptFile;
 482                                                         return FALSE;
 483                                                 }
 484                                         } else {
 485                                                 length = ((tag^0x80)-0x10);
 486                                         }
 487
 488                                         char* buffer = new char[length];
 489                                         in.readRawData(buffer, length);
 490
 491                                         delete [] buffer;
 492                                         break;
 493                                 }
 494 // The file-rating is read correctly. It will be stored when I know what to do with it.
 495                                 case 0xf7: //FT_FILERATING
 496                                 {
 497                                         in >> rating;
 498
 499                                         break;
 500                                 }
 501
 502                                 default:
 503                                 {
 504                                         lastTagType = tagType;
 505                                         errorCode = UnknownTagType;
 506                                         return FALSE;
 507                                 }
 508                         }
 509                 }
 510
 511                 list.append(QString("ed2k://|file|%1|%2|%3|/").arg(fileName).arg(fileSize).arg(fileHash));
 512         }
 513
 514         return TRUE;
 515 }
 516
 517 bool qtEmc::readText(QFile &collection)
 518 {
 519         quint8 character;
 520         QString tmp;
 521
 522         collection.seek(0);
 523         QDataStream in(&collection);
 524         in.setByteOrder(QDataStream::LittleEndian);
 525
 526         for (int i=0; i<=6; i++)
 527         {
 528                 in >> character;
 529                 tmp.append(character);
 530         }
 531
 532         if (tmp == "ed2k://")
 533         {
 534                 while (!in.atEnd())
 535                 {
 536                         in >> character;
 537
 538                         if (character == 0x0d)
 539                         {
 540                                 list.append(tmp);
 541                                 tmp.clear();
 542                         } else if (character != 0x0a)
 543                         {
 544                                 tmp.append(character);
 545                         }
 546                 }
 547         } else {
 548                         errorCode = BadFileFormat;
 549                         return FALSE;
 550         }
 551
 552         return TRUE;
 553 }