rbutil/rbutilqt/installbootloader.cpp

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  *
   9  *   Copyright (C) 2007 by Dominik Wenger
  10  *   $Id$
  11  *
  12  * All files in this archive are subject to the GNU General Public License.
  13  * See the file COPYING in the source tree root for full license agreement.
  14  *
  15  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  16  * KIND, either express or implied.
  17  *
  18  ****************************************************************************/
  19
  20 #include "installbootloader.h"
  21 #include "irivertools/checksums.h"
  22
  23 BootloaderInstaller::BootloaderInstaller(QObject* parent): QObject(parent)
  24 {
  25
  26 }
  27
  28 void BootloaderInstaller::install(ProgressloggerInterface* dp)
  29 {
  30     m_dp = dp;
  31     m_install = true;
  32     m_dp->addItem(tr("Starting bootloader installation"),LOGINFO);
  33     connect(this, SIGNAL(done(bool)), this, SLOT(installEnded(bool)));
  34
  35     if(m_bootloadermethod == "gigabeatf")
  36     {
  37         // connect internal signal
  38         connect(this,SIGNAL(prepare()),this,SLOT(gigabeatPrepare()));
  39         connect(this,SIGNAL(finish()),this,SLOT(gigabeatFinish()));
  40     }
  41     else if(m_bootloadermethod == "iaudio")
  42     {
  43         // connect internal signal
  44         connect(this,SIGNAL(prepare()),this,SLOT(iaudioPrepare()));
  45         connect(this,SIGNAL(finish()),this,SLOT(iaudioFinish()));
  46     }
  47     else if(m_bootloadermethod == "h10")
  48     {
  49         // connect internal signal
  50         connect(this,SIGNAL(prepare()),this,SLOT(h10Prepare()));
  51         connect(this,SIGNAL(finish()),this,SLOT(h10Finish()));
  52     }
  53     else if(m_bootloadermethod == "ipodpatcher")
  54     {
  55         // connect internal signal
  56         connect(this,SIGNAL(prepare()),this,SLOT(ipodPrepare()));
  57         connect(this,SIGNAL(finish()),this,SLOT(ipodFinish()));
  58     }
  59     else if(m_bootloadermethod == "sansapatcher")
  60     {
  61         // connect internal signal
  62         connect(this,SIGNAL(prepare()),this,SLOT(sansaPrepare()));
  63         connect(this,SIGNAL(finish()),this,SLOT(sansaFinish()));
  64     }
  65     else if(m_bootloadermethod == "fwpatcher")
  66     {
  67         // connect internal signal
  68         connect(this,SIGNAL(prepare()),this,SLOT(iriverPrepare()));
  69         connect(this,SIGNAL(finish()),this,SLOT(iriverFinish()));
  70     }
  71     else
  72     {
  73         m_dp->addItem(tr("unsupported install Method"),LOGERROR);
  74         emit done(true);
  75         return;
  76     }
  77
  78     emit prepare();
  79 }
  80
  81 void BootloaderInstaller::uninstall(ProgressloggerInterface* dp)
  82 {
  83     m_dp = dp;
  84     m_install = false;
  85     m_dp->addItem(tr("Starting bootloader uninstallation"),LOGINFO);
  86     connect(this, SIGNAL(done(bool)), this, SLOT(installEnded(bool)));
  87
  88     if(m_bootloadermethod == "gigabeatf")
  89     {
  90        // connect internal signal
  91        connect(this,SIGNAL(prepare()),this,SLOT(gigabeatPrepare()));
  92     }
  93     else if(m_bootloadermethod == "iaudio")
  94     {
  95         m_dp->addItem(tr("No uninstallation possible"),LOGWARNING);
  96         emit done(true);
  97         return;
  98     }
  99     else if(m_bootloadermethod == "iaudio")
 100     {
 101         // connect internal signal
 102        connect(this,SIGNAL(prepare()),this,SLOT(h10Prepare()));
 103     }
 104     else if(m_bootloadermethod == "ipodpatcher")
 105     {
 106         // connect internal signal
 107         connect(this,SIGNAL(prepare()),this,SLOT(ipodPrepare()));
 108     }
 109     else if(m_bootloadermethod == "sansapatcher")
 110     {
 111         // connect internal signal
 112         connect(this,SIGNAL(prepare()),this,SLOT(sansaPrepare()));
 113     }
 114     else if(m_bootloadermethod == "fwpatcher")
 115     {
 116         m_dp->addItem(tr("No uninstallation possible"),LOGWARNING);
 117         emit done(true);
 118         return;
 119     }
 120     else
 121     {
 122         m_dp->addItem(tr("unsupported install Method"),LOGERROR);
 123         emit done(true);
 124         return;
 125     }
 126
 127     emit prepare();
 128 }
 129
 130 void BootloaderInstaller::downloadRequestFinished(int id, bool error)
 131 {
 132     qDebug() << "BootloaderInstall::downloadRequestFinished" << id << error;
 133     qDebug() << "error:" << getter->errorString();
 134
 135     downloadDone(error);
 136 }
 137
 138 void BootloaderInstaller::downloadDone(bool error)
 139 {
 140     qDebug() << "Install::downloadDone, error:" << error;
 141
 142      // update progress bar
 143
 144     int max = m_dp->getProgressMax();
 145     if(max == 0) {
 146         max = 100;
 147         m_dp->setProgressMax(max);
 148     }
 149     m_dp->setProgressValue(max);
 150     if(getter->httpResponse() != 200) {
 151         m_dp->addItem(tr("Download error: received HTTP error %1.").arg(getter->httpResponse()),LOGERROR);
 152         m_dp->abort();
 153         emit done(true);
 154         return;
 155     }
 156     if(error) {
 157         m_dp->addItem(tr("Download error: %1").arg(getter->errorString()),LOGERROR);
 158         m_dp->abort();
 159         emit done(true);
 160         return;
 161     }
 162     else m_dp->addItem(tr("Download finished."),LOGOK);
 163
 164     emit finish();
 165
 166 }
 167
 168 void BootloaderInstaller::updateDataReadProgress(int read, int total)
 169 {
 170     m_dp->setProgressMax(total);
 171     m_dp->setProgressValue(read);
 172     qDebug() << "progress:" << read << "/" << total;
 173 }
 174
 175
 176 void BootloaderInstaller::installEnded(bool error)
 177 {
 178     (void) error;
 179     m_dp->abort();
 180 }
 181
 182 bool BootloaderInstaller::downloadInfo()
 183 {
 184     // try to get the current build information
 185    infodownloader = new HttpGet(this);
 186
 187    connect(infodownloader, SIGNAL(done(bool)), this, SLOT(infoDownloadDone(bool)));
 188    connect(infodownloader, SIGNAL(requestFinished(int, bool)), this, SLOT(infoRequestFinished(int, bool)));
 189
 190    infodownloader->setProxy(m_proxy);
 191
 192    qDebug() << "downloading bootloader info";
 193    infodownloader->setFile(&bootloaderInfo);
 194    infodownloader->getFile(QUrl(m_bootloaderinfoUrl));
 195
 196    // block until its downloaded
 197    qDebug() << "Waiting for Download finished";
 198    infoDownloaded=false;
 199    infoError = false;
 200    while(!infoDownloaded )
 201        QApplication::processEvents();
 202    return !infoError;
 203 }
 204
 205 void BootloaderInstaller::infoDownloadDone(bool error)
 206 {
 207     if(error)
 208     {
 209         qDebug() << "network error:" << infodownloader->error();
 210         return;
 211     }
 212     qDebug() << "network status:" << infodownloader->error();
 213
 214     infoDownloaded = true;
 215 }
 216
 217 void BootloaderInstaller::infoRequestFinished(int id, bool error)
 218 {
 219
 220     if(error)
 221     {
 222         QString errorString;
 223         errorString = tr("Network error: %1. Please check your network and proxy settings.")
 224                .arg(infodownloader->errorString());
 225         if(error) QMessageBox::about(NULL, "Network Error", errorString);
 226           qDebug() << "downloadDone:" << id << error;
 227
 228         infoError = true;
 229         infoDownloaded = true;
 230     }
 231     qDebug() << "infoRequestFinished:" << id << error;
 232 }
 233
 234
 235 void BootloaderInstaller::createInstallLog()
 236 {
 237     m_dp->addItem(tr("Creating installation log"),LOGINFO);
 238     QSettings installlog(m_mountpoint + "/.rockbox/rbutil.log", QSettings::IniFormat, 0);
 239
 240     bootloaderInfo.open();
 241     QSettings info(bootloaderInfo.fileName(), QSettings::IniFormat, this);
 242     bootloaderInfo.close();
 243     info.beginGroup(m_device);
 244
 245     installlog.beginGroup("Bootloader");
 246     installlog.setValue("md5sum",info.value("md5sum").toString());
 247     installlog.endGroup();
 248     installlog.sync();
 249 }
 250
 251 void BootloaderInstaller::removeInstallLog()
 252 {
 253     m_dp->addItem(tr("Editing installation log"),LOGINFO);
 254     QSettings installlog(m_mountpoint + "/.rockbox/rbutil.log", QSettings::IniFormat, 0);
 255     installlog.beginGroup("Bootloader");
 256     installlog.remove("md5sum");
 257     installlog.endGroup();
 258     installlog.sync();
 259 }
 260
 261
 262 bool BootloaderInstaller::uptodate()
 263 {
 264     QString installedMd5;
 265     QString serverMd5;
 266
 267     QSettings installlog(m_mountpoint + "/.rockbox/rbutil.log", QSettings::IniFormat, 0);
 268     installlog.beginGroup("Bootloader");
 269     installedMd5 = installlog.value("md5sum").toString();
 270     installlog.endGroup();
 271
 272     bootloaderInfo.open();
 273     QSettings info(bootloaderInfo.fileName(), QSettings::IniFormat, this);
 274     bootloaderInfo.close();
 275     info.beginGroup(m_device);
 276     serverMd5 = info.value("md5sum").toString();
 277     info.endGroup();
 278
 279     if(installedMd5 != serverMd5)
 280         return false;
 281     else
 282         return true;
 283 }
 284
 285 /**************************************************
 286 *** gigabeat secific code
 287 ***************************************************/
 288
 289 void BootloaderInstaller::gigabeatPrepare()
 290 {
 291     if(m_install)         // Installation
 292     {
 293         QString url = m_bootloaderUrlBase + "/gigabeat/" + m_bootloadername;
 294
 295         m_dp->addItem(tr("Downloading file %1.%2")
 296             .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 297
 298         // temporary file needs to be opened to get the filename
 299         downloadFile.open();
 300         m_tempfilename = downloadFile.fileName();
 301         downloadFile.close();
 302         // get the real file.
 303         getter = new HttpGet(this);
 304         getter->setProxy(m_proxy);
 305         getter->setFile(&downloadFile);
 306         getter->getFile(QUrl(url));
 307         // connect signals from HttpGet
 308         connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 309         connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 310         connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 311    }
 312    else                 //UnInstallation
 313    {
 314         QString firmware = m_mountpoint + "/GBSYSTEM/FWIMG/FWIMG01.DAT";
 315         QString firmwareOrig = firmware.append(".ORIG");
 316
 317         QFileInfo firmwareOrigFI(firmwareOrig);
 318
 319         // check if original firmware exists
 320         if(!firmwareOrigFI.exists())
 321         {
 322              m_dp->addItem(tr("Could not find the Original Firmware at: %1")
 323                     .arg(firmwareOrig),LOGERROR);
 324             emit done(true);
 325             return;
 326         }
 327
 328         QFile firmwareFile(firmware);
 329         QFile firmwareOrigFile(firmwareOrig);
 330
 331         //remove modified firmware
 332         if(!firmwareFile.remove())
 333         {
 334              m_dp->addItem(tr("Could not remove the Firmware at: %1")
 335                     .arg(firmware),LOGERROR);
 336             emit done(true);
 337             return;
 338         }
 339
 340         //copy  original firmware
 341         if(!firmwareOrigFile.copy(firmware))
 342         {
 343              m_dp->addItem(tr("Could not copy the Firmware from: %1 to %2")
 344                     .arg(firmwareOrig,firmware),LOGERROR);
 345             emit done(true);
 346             return;
 347         }
 348
 349         removeInstallLog();
 350
 351         emit done(false);  //success
 352    }
 353
 354 }
 355
 356 void BootloaderInstaller::gigabeatFinish()
 357 {
 358     // this step is only need for installation, so no code for uninstall here
 359
 360     m_dp->addItem(tr("Finishing bootloader install"),LOGINFO);
 361
 362     QString firmware = m_mountpoint + "/GBSYSTEM/FWIMG/" + m_bootloadername;
 363
 364     QFileInfo firmwareFI(firmware);
 365
 366     // check if firmware exists
 367     if(!firmwareFI.exists())
 368     {
 369         m_dp->addItem(tr("Could not find the Firmware at: %1")
 370             .arg(firmware),LOGERROR);
 371         emit done(true);
 372         return;
 373     }
 374
 375     QString firmwareOrig = firmware;
 376     firmwareOrig.append(".ORIG");
 377     QFileInfo firmwareOrigFI(firmwareOrig);
 378
 379     // rename the firmware, if there is no original firmware there
 380     if(!firmwareOrigFI.exists())
 381     {
 382         QFile firmwareFile(firmware);
 383         if(!firmwareFile.rename(firmwareOrig))
 384         {
 385             m_dp->addItem(tr("Could not rename: %1 to %2")
 386                                 .arg(firmware,firmwareOrig),LOGERROR);
 387             emit done(true);
 388             return;
 389         }
 390     }
 391     else // or remove the normal firmware, if the original is there
 392     {
 393         QFile firmwareFile(firmware);
 394         firmwareFile.remove();
 395     }
 396
 397     //copy the firmware
 398     if(!downloadFile.copy(firmware))
 399     {
 400         m_dp->addItem(tr("Could not copy: %1 to %2")
 401                                 .arg(m_tempfilename,firmware),LOGERROR);
 402         emit done(true);
 403         return;
 404     }
 405
 406     downloadFile.remove();
 407
 408     createInstallLog();
 409
 410     m_dp->addItem(tr("Bootloader install finished successfully."),LOGOK);
 411     m_dp->addItem(tr("To finish the Bootloader installation, follow the steps below."),LOGINFO);
 412     m_dp->addItem(tr("1. Eject/Unmount your Device."),LOGINFO);
 413     m_dp->addItem(tr("2. Unplug USB and any Power adapters."),LOGINFO);
 414     m_dp->addItem(tr("3. Hold POWER to turn the Device off."),LOGINFO);
 415     m_dp->addItem(tr("4. Toggle the Battery switch on the Device."),LOGINFO);
 416     m_dp->addItem(tr("5. Hold POWER to boot the Rockbox bootloader."),LOGINFO);
 417
 418
 419     m_dp->abort();
 420
 421     emit done(false);  // success
 422
 423 }
 424
 425 /**************************************************
 426 *** iaudio secific code
 427 ***************************************************/
 428 void BootloaderInstaller::iaudioPrepare()
 429 {
 430
 431     QString url = m_bootloaderUrlBase + "/iaudio/" + m_bootloadername;
 432
 433     m_dp->addItem(tr("Downloading file %1.%2")
 434           .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 435
 436     // temporary file needs to be opened to get the filename
 437     downloadFile.open();
 438     m_tempfilename = downloadFile.fileName();
 439     downloadFile.close();
 440     // get the real file.
 441     getter = new HttpGet(this);
 442     getter->setProxy(m_proxy);
 443     getter->setFile(&downloadFile);
 444     getter->getFile(QUrl(url));
 445     // connect signals from HttpGet
 446     connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 447     connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 448     connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 449 }
 450
 451 void BootloaderInstaller::iaudioFinish()
 452 {
 453     QString firmware = m_mountpoint + "/FIRMWARE/" + m_bootloadername;
 454
 455     //copy the firmware
 456     if(!downloadFile.copy(firmware))
 457     {
 458         m_dp->addItem(tr("Could not copy: %1 to %2")
 459                                 .arg(m_tempfilename,firmware),LOGERROR);
 460         emit done(true);
 461         return;
 462     }
 463
 464     downloadFile.remove();
 465
 466     createInstallLog();
 467
 468     m_dp->addItem(tr("Bootloader install finished successfully."),LOGOK);
 469     m_dp->addItem(tr("To finish the Bootloader installation, follow the steps below."),LOGINFO);
 470     m_dp->addItem(tr("1. Eject/Unmount your Device."),LOGINFO);
 471     m_dp->addItem(tr("2. Turn you Device OFF."),LOGINFO);
 472     m_dp->addItem(tr("3. Insert Charger."),LOGINFO);
 473
 474     m_dp->abort();
 475
 476     emit done(false);  // success
 477
 478 }
 479
 480
 481 /**************************************************
 482 *** h10 secific code
 483 ***************************************************/
 484 void BootloaderInstaller::h10Prepare()
 485 {
 486     if(m_install)         // Installation
 487     {
 488         QString url = m_bootloaderUrlBase + "/iriver/" + m_bootloadername;
 489
 490         m_dp->addItem(tr("Downloading file %1.%2")
 491           .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 492
 493         // temporary file needs to be opened to get the filename
 494         downloadFile.open();
 495         m_tempfilename = downloadFile.fileName();
 496         downloadFile.close();
 497         // get the real file.
 498         getter = new HttpGet(this);
 499         getter->setProxy(m_proxy);
 500         getter->setFile(&downloadFile);
 501         getter->getFile(QUrl(url));
 502         // connect signals from HttpGet
 503         connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 504         connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 505         connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 506     }
 507     else             // Uninstallation
 508     {
 509
 510         QString firmwarename = m_bootloadername.section('/', -1);
 511
 512         QString firmware = m_mountpoint + "/SYSTEM/" + firmwarename;
 513         QString firmwareOrig = m_mountpoint + "/SYSTEM/Original.mi4";
 514
 515         QFileInfo firmwareFI(firmware);
 516         if(!firmwareFI.exists())  //Firmware dosent exists on player
 517         {
 518             firmware = m_mountpoint + "/SYSTEM/H10EMP.mi4";   //attempt other firmwarename
 519             firmwareFI.setFile(firmware);
 520             if(!firmwareFI.exists())  //Firmware dosent exists on player
 521             {
 522                 m_dp->addItem(tr("Firmware does not exist: %1")
 523                                 .arg(firmware),LOGERROR);
 524                 emit done(true);
 525                 return;
 526             }
 527         }
 528
 529         QFileInfo firmwareOrigFI(firmwareOrig);
 530         if(!firmwareOrigFI.exists())  //Original Firmware dosent exists on player
 531         {
 532             m_dp->addItem(tr("Original Firmware does not exist: %1")
 533                                 .arg(firmwareOrig),LOGERROR);
 534             emit done(true);
 535             return;
 536         }
 537
 538         QFile firmwareFile(firmware);
 539         QFile firmwareOrigFile(firmwareOrig);
 540
 541         //remove modified firmware
 542         if(!firmwareFile.remove())
 543         {
 544              m_dp->addItem(tr("Could not remove the Firmware at: %1")
 545                     .arg(firmware),LOGERROR);
 546             emit done(true);
 547             return;
 548         }
 549
 550         //copy  original firmware
 551         if(!firmwareOrigFile.copy(firmware))
 552         {
 553              m_dp->addItem(tr("Could not copy the Firmware from: %1 to %2")
 554                     .arg(firmwareOrig,firmware),LOGERROR);
 555             emit done(true);
 556             return;
 557         }
 558
 559         removeInstallLog();
 560
 561         emit done(false);  //success
 562
 563     }
 564 }
 565
 566 void BootloaderInstaller::h10Finish()
 567 {
 568     QString firmwarename = m_bootloadername.section('/', -1);
 569
 570     QString firmware = m_mountpoint + "/SYSTEM/" + firmwarename;
 571     QString firmwareOrig = m_mountpoint + "/SYSTEM/Original.mi4";
 572
 573     QFileInfo firmwareFI(firmware);
 574
 575     if(!firmwareFI.exists())  //Firmware dosent exists on player
 576     {
 577         firmware = m_mountpoint + "/SYSTEM/H10EMP.mi4";   //attempt other firmwarename
 578         firmwareFI.setFile(firmware);
 579         if(!firmwareFI.exists())  //Firmware dosent exists on player
 580         {
 581             m_dp->addItem(tr("Firmware does not exist: %1")
 582                                 .arg(firmware),LOGERROR);
 583             emit done(true);
 584             return;
 585         }
 586     }
 587
 588     QFileInfo firmwareOrigFI(firmwareOrig);
 589
 590     if(!firmwareOrigFI.exists())  //there is already a original firmware
 591     {
 592         QFile firmwareFile(firmware);
 593         if(!firmwareFile.rename(firmwareOrig)) //rename Firmware to Original
 594         {
 595             m_dp->addItem(tr("Could not rename: %1 to %2")
 596                                 .arg(firmware,firmwareOrig),LOGERROR);
 597             emit done(true);
 598             return;
 599         }
 600     }
 601     else
 602     {
 603         QFile firmwareFile(firmware);
 604         firmwareFile.remove();
 605     }
 606         //copy the firmware
 607     if(!downloadFile.copy(firmware))
 608     {
 609         m_dp->addItem(tr("Could not copy: %1 to %2")
 610                                 .arg(m_tempfilename,firmware),LOGERROR);
 611         emit done(true);
 612         return;
 613     }
 614
 615     downloadFile.remove();
 616
 617     createInstallLog();
 618
 619     m_dp->addItem(tr("Bootloader install finished successfully."),LOGOK);
 620     m_dp->abort();
 621
 622     emit done(false);  // success
 623
 624 }
 625
 626 /**************************************************
 627 *** ipod secific code
 628 ***************************************************/
 629 int verbose =0;
 630 // reserves memory for ipodpatcher
 631 bool initIpodpatcher()
 632 {
 633     if (ipod_alloc_buffer(&sectorbuf,BUFFER_SIZE) < 0) return true;
 634       else return false;
 635 }
 636
 637 void BootloaderInstaller::ipodPrepare()
 638 {
 639     m_dp->addItem(tr("Searching for ipods"),LOGINFO);
 640     struct ipod_t ipod;
 641
 642     int n = ipod_scan(&ipod);
 643     if (n == 0)
 644     {
 645         m_dp->addItem(tr("No Ipods found"),LOGERROR);
 646         emit done(true);
 647         return;
 648     }
 649     if (n > 1)
 650     {
 651         m_dp->addItem(tr("Too many Ipods found"),LOGERROR);
 652         emit done(true);
 653     }
 654
 655     if(m_install)         // Installation
 656     {
 657
 658         QString url = m_bootloaderUrlBase + "/ipod/bootloader-" + m_bootloadername + ".ipod";
 659
 660         m_dp->addItem(tr("Downloading file %1.%2")
 661           .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 662
 663         // temporary file needs to be opened to get the filename
 664         downloadFile.open();
 665         m_tempfilename = downloadFile.fileName();
 666         downloadFile.close();
 667         // get the real file.
 668         getter = new HttpGet(this);
 669         getter->setProxy(m_proxy);
 670         getter->setFile(&downloadFile);
 671         getter->getFile(QUrl(url));
 672         // connect signals from HttpGet
 673         connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 674         connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 675         connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 676     }
 677     else                 // Uninstallation
 678     {
 679         if (ipod_open(&ipod, 0) < 0)
 680         {
 681             m_dp->addItem(tr("could not open ipod"),LOGERROR);
 682             emit done(true);
 683             return;
 684         }
 685
 686         if (read_partinfo(&ipod,0) < 0)
 687         {
 688             m_dp->addItem(tr("could not read partitiontable"),LOGERROR);
 689             emit done(true);
 690             return;
 691         }
 692
 693         if (ipod.pinfo[0].start==0)
 694         {
 695             m_dp->addItem(tr("No partition 0 on disk"),LOGERROR);
 696
 697             int i;
 698             double sectors_per_MB = (1024.0*1024.0)/ipod.sector_size;
 699             m_dp->addItem(tr("[INFO] Part    Start Sector    End Sector   Size (MB)   Type\n"),LOGINFO);
 700             for ( i = 0; i < 4; i++ )
 701             {
 702                 if (ipod.pinfo[i].start != 0)
 703                 {
 704                     m_dp->addItem(tr("[INFO]    %1      %2    %3  %4   %5 (%6)").arg(
 705                         i).arg(
 706                         ipod.pinfo[i].start).arg(
 707                         ipod.pinfo[i].start+ipod.pinfo[i].size-1).arg(
 708                         ipod.pinfo[i].size/sectors_per_MB).arg(
 709                         get_parttype(ipod.pinfo[i].type)).arg(
 710                         ipod.pinfo[i].type),LOGINFO);
 711                 }
 712             }
 713             emit done(true);
 714             return;
 715         }
 716
 717         read_directory(&ipod);
 718
 719         if (ipod.nimages <= 0)
 720         {
 721             m_dp->addItem(tr("Failed to read firmware directory"),LOGERROR);
 722             emit done(true);
 723             return;
 724         }
 725         if (getmodel(&ipod,(ipod.ipod_directory[0].vers>>8)) < 0)
 726         {
 727             m_dp->addItem(tr("Unknown version number in firmware (%1)").arg(
 728                 ipod.ipod_directory[0].vers),LOGERROR);
 729             emit done(true);
 730             return;
 731         }
 732
 733         if (ipod.macpod)
 734         {
 735             m_dp->addItem(tr("Warning this is a MacPod, Rockbox doesnt work on "
 736                     "this. Convert it to WinPod\n"
 737                     "See http://www.rockbox.org/wiki/IpodConverstionToFAT32"),
 738                     LOGWARNING);
 739             emit done(true);
 740             return;
 741         }
 742
 743         if (ipod_reopen_rw(&ipod) < 0)
 744         {
 745             m_dp->addItem(tr("Could not open Ipod in RW mode"),LOGERROR);
 746             emit done(true);
 747             return;
 748         }
 749
 750         if (ipod.ipod_directory[0].entryOffset==0) {
 751             m_dp->addItem(tr("No bootloader detected."),LOGERROR);
 752             emit done(true);
 753             return;
 754         }
 755
 756         if (delete_bootloader(&ipod)==0)
 757         {
 758             m_dp->addItem(tr("Successfully removed Bootloader"),LOGOK);
 759             removeInstallLog();
 760             emit done(false);
 761             ipod_close(&ipod);
 762             return;
 763         }
 764         else
 765         {
 766             m_dp->addItem(tr("--delete-bootloader failed."),LOGERROR);
 767             emit done(true);
 768             ipod_close(&ipod);
 769             return;
 770         }
 771     }
 772 }
 773
 774 void BootloaderInstaller::ipodFinish()
 775 {
 776     struct ipod_t ipod;
 777     ipod_scan(&ipod);
 778
 779     if (ipod_open(&ipod, 0) < 0)
 780     {
 781         m_dp->addItem(tr("could not open ipod"),LOGERROR);
 782         emit done(true);
 783         return;
 784     }
 785
 786     if (read_partinfo(&ipod,0) < 0)
 787     {
 788         m_dp->addItem(tr("could not read partitiontable"),LOGERROR);
 789         emit done(true);
 790         return;
 791     }
 792
 793     if (ipod.pinfo[0].start==0)
 794     {
 795         m_dp->addItem(tr("No partition 0 on disk"),LOGERROR);
 796
 797         int i;
 798         double sectors_per_MB = (1024.0*1024.0)/ipod.sector_size;
 799
 800         m_dp->addItem(tr("[INFO] Part    Start Sector    End Sector   Size (MB)   Type\n"),LOGINFO);
 801
 802         for ( i = 0; i < 4; i++ )
 803         {
 804          if (ipod.pinfo[i].start != 0)
 805          {
 806             m_dp->addItem(tr("[INFO]    %1      %2    %3  %4   %5 (%6)").arg(
 807                     i).arg(
 808                    ipod.pinfo[i].start).arg(
 809                    ipod.pinfo[i].start+ipod.pinfo[i].size-1).arg(
 810                    ipod.pinfo[i].size/sectors_per_MB).arg(
 811                    get_parttype(ipod.pinfo[i].type)).arg(
 812                    ipod.pinfo[i].type),LOGWARNING);
 813          }
 814         }
 815         emit done(true);
 816         return;
 817     }
 818
 819     read_directory(&ipod);
 820
 821     if (ipod.nimages <= 0)
 822     {
 823         m_dp->addItem(tr("Failed to read firmware directory"),LOGERROR);
 824         emit done(true);
 825         return;
 826     }
 827     if (getmodel(&ipod,(ipod.ipod_directory[0].vers>>8)) < 0)
 828     {
 829         m_dp->addItem(tr("Unknown version number in firmware (%1)").arg(
 830                 ipod.ipod_directory[0].vers),LOGERROR);
 831         emit done(true);
 832         return;
 833     }
 834
 835     if (ipod.macpod)
 836     {
 837         m_dp->addItem(tr("Warning this is a MacPod, Rockbox doesnt work on "
 838                 "this. Convert it to WinPod\n"
 839                 "See http://www.rockbox.org/wiki/IpodConverstionToFAT32"),
 840                 LOGWARNING);
 841         emit done(true);
 842         return;
 843     }
 844
 845     if (ipod_reopen_rw(&ipod) < 0)
 846     {
 847         m_dp->addItem(tr("Could not open Ipod in RW mode"),LOGERROR);
 848         emit done(true);
 849         return;
 850     }
 851
 852     if (add_bootloader(&ipod, m_tempfilename.toLatin1().data(), FILETYPE_DOT_IPOD)==0)
 853     {
 854         m_dp->addItem(tr("Successfully added Bootloader"),LOGOK);
 855         createInstallLog();
 856         emit done(false);
 857         ipod_close(&ipod);
 858         return;
 859     }
 860     else
 861     {
 862         m_dp->addItem(tr("failed to add Bootloader"),LOGERROR);
 863         ipod_close(&ipod);
 864         emit done(true);
 865         return;
 866     }
 867 }
 868
 869 /**************************************************
 870 *** sansa secific code
 871 ***************************************************/
 872 // reserves memory for sansapatcher
 873 bool initSansapatcher()
 874 {
 875       if (sansa_alloc_buffer(&sectorbuf,BUFFER_SIZE) < 0) return true;
 876       else return false;
 877 }
 878
 879
 880 void BootloaderInstaller::sansaPrepare()
 881 {
 882     m_dp->addItem(tr("Searching for sansas"),LOGINFO);
 883     struct sansa_t sansa;
 884
 885     int n = sansa_scan(&sansa);
 886     if (n == 0)
 887     {
 888         m_dp->addItem(tr("No Sansa found"),LOGERROR);
 889         emit done(true);
 890         return;
 891     }
 892     if (n > 1)
 893     {
 894         m_dp->addItem(tr("Too many Sansas found"),LOGERROR);
 895         emit done(true);
 896     }
 897
 898     if(m_install)         // Installation
 899     {
 900         QString url = m_bootloaderUrlBase + "/sandisk-sansa/"
 901                 + QString(sansa.targetname) + "/" + m_bootloadername;
 902
 903         m_dp->addItem(tr("Downloading file %1.%2")
 904           .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 905
 906         // temporary file needs to be opened to get the filename
 907         downloadFile.open();
 908         m_tempfilename = downloadFile.fileName();
 909         downloadFile.close();
 910         // get the real file.
 911         getter = new HttpGet(this);
 912         getter->setProxy(m_proxy);
 913         getter->setFile(&downloadFile);
 914         getter->getFile(QUrl(url));
 915         // connect signals from HttpGet
 916         connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 917         connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 918         connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 919     }
 920     else                 // Uninstallation
 921     {
 922
 923         if (sansa_open(&sansa, 0) < 0)
 924         {
 925             m_dp->addItem(tr("could not open Sansa"),LOGERROR);
 926             emit done(true);
 927             return;
 928         }
 929
 930         if (sansa_read_partinfo(&sansa,0) < 0)
 931         {
 932             m_dp->addItem(tr("could not read partitiontable"),LOGERROR);
 933             emit done(true);
 934             return;
 935         }
 936
 937         int i = is_sansa(&sansa);
 938         if (i < 0) {
 939             m_dp->addItem(tr("Disk is not a Sansa (%1), aborting.").arg(i),LOGERROR);
 940             emit done(true);
 941             return;
 942         }
 943
 944         if (sansa.hasoldbootloader)
 945         {
 946             m_dp->addItem(tr("********************************************\n"
 947                                        "OLD ROCKBOX INSTALLATION DETECTED, ABORTING.\n"
 948                                        "You must reinstall the original Sansa firmware before running\n"
 949                                        "sansapatcher for the first time.\n"
 950                                        "See http://www.rockbox.org/twiki/bin/view/Main/SansaE200Install\n"
 951                                        "*********************************************\n"),LOGERROR);
 952             emit done(true);
 953             return;
 954         }
 955
 956
 957         if (sansa_reopen_rw(&sansa) < 0)
 958         {
 959             m_dp->addItem(tr("Could not open Sansa in RW mode"),LOGERROR);
 960             emit done(true);
 961             return;
 962         }
 963
 964         if (sansa_delete_bootloader(&sansa)==0)
 965         {
 966             m_dp->addItem(tr("Successfully removed Bootloader"),LOGOK);
 967             removeInstallLog();
 968             emit done(false);
 969             sansa_close(&sansa);
 970             return;
 971         }
 972         else
 973         {
 974             m_dp->addItem(tr("--delete-bootloader failed."),LOGERROR);
 975             emit done(true);
 976             sansa_close(&sansa);
 977             return;
 978         }
 979     }
 980 }
 981
 982 void BootloaderInstaller::sansaFinish()
 983 {
 984     struct sansa_t sansa;
 985     sansa_scan(&sansa);
 986
 987     if (sansa_open(&sansa, 0) < 0)
 988     {
 989         m_dp->addItem(tr("could not open Sansa"),LOGERROR);
 990         emit done(true);
 991         return;
 992     }
 993
 994     if (sansa_read_partinfo(&sansa,0) < 0)
 995     {
 996         m_dp->addItem(tr("could not read partitiontable"),LOGERROR);
 997         emit done(true);
 998         return;
 999     }
1000
1001
1002     int i = is_sansa(&sansa);
1003     if (i < 0) {
1004
1005         m_dp->addItem(tr("Disk is not a Sansa (%1), aborting.").arg(i),LOGERROR);
1006         emit done(true);
1007         return;
1008     }
1009
1010     if (sansa.hasoldbootloader)
1011     {
1012         m_dp->addItem(tr("********************************************\n"
1013                                        "OLD ROCKBOX INSTALLATION DETECTED, ABORTING.\n"
1014                                        "You must reinstall the original Sansa firmware before running\n"
1015                                        "sansapatcher for the first time.\n"
1016                                        "See http://www.rockbox.org/twiki/bin/view/Main/SansaE200Install\n"
1017                                        "*********************************************\n"),LOGERROR);
1018         emit done(true);
1019         return;
1020     }
1021
1022     if (sansa_reopen_rw(&sansa) < 0)
1023     {
1024         m_dp->addItem(tr("Could not open Sansa in RW mode"),LOGERROR);
1025         emit done(true);
1026         return;
1027     }
1028
1029     if (sansa_add_bootloader(&sansa, m_tempfilename.toLatin1().data(), FILETYPE_MI4)==0)
1030     {
1031         m_dp->addItem(tr("Successfully added Bootloader"),LOGOK);
1032         createInstallLog();
1033         emit done(false);
1034         sansa_close(&sansa);
1035         return;
1036     }
1037     else
1038     {
1039         m_dp->addItem(tr("failed to add Bootloader"),LOGERROR);
1040         sansa_close(&sansa);
1041         emit done(true);
1042         return;
1043     }
1044
1045 }
1046
1047 /**************************************************
1048 *** iriver /fwpatcher  secific code
1049 ***************************************************/
1050
1051 void BootloaderInstaller::iriverPrepare()
1052 {
1053     char md5sum_str[32];
1054     if (!FileMD5(m_origfirmware, md5sum_str)) {
1055         m_dp->addItem(tr("Could not MD5Sum original firmware"),LOGERROR);
1056         emit done(true);
1057         return;
1058     }
1059
1060     /* Check firmware against md5sums in h120sums and h100sums */
1061     series = 0;
1062     table_entry = intable(md5sum_str, &h120pairs[0],
1063                           sizeof(h120pairs)/sizeof(struct sumpairs));
1064     if (table_entry >= 0) {
1065         series = 120;
1066     }
1067     else
1068     {
1069         table_entry = intable(md5sum_str, &h100pairs[0],
1070                               sizeof(h100pairs)/sizeof(struct sumpairs));
1071         if (table_entry >= 0)
1072         {
1073             series = 100;
1074         }
1075         else
1076         {
1077             table_entry = intable(md5sum_str, &h300pairs[0],
1078                                   sizeof(h300pairs)/sizeof(struct sumpairs));
1079             if (table_entry >= 0)
1080                 series = 300;
1081         }
1082     }
1083     if (series == 0)
1084     {
1085         m_dp->addItem(tr("Could not detect firmware type"),LOGERROR);
1086         emit done(true);
1087         return;
1088     }
1089
1090     QString url = m_bootloaderUrlBase + "/iriver/" + m_bootloadername;
1091
1092     m_dp->addItem(tr("Downloading file %1.%2")
1093         .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
1094
1095     // temporary file needs to be opened to get the filename
1096     downloadFile.open();
1097     m_tempfilename = downloadFile.fileName();
1098     downloadFile.close();
1099     // get the real file.
1100     getter = new HttpGet(this);
1101     getter->setProxy(m_proxy);
1102     getter->setFile(&downloadFile);
1103     getter->getFile(QUrl(url));
1104     // connect signals from HttpGet
1105     connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
1106     connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
1107     connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
1108 }
1109
1110 void BootloaderInstaller::iriverFinish()
1111 {
1112     // Patch firmware
1113     char md5sum_str[32];
1114     struct sumpairs *sums = 0;
1115     int origin = 0;
1116
1117     /* get pointer to the correct bootloader.bin */
1118     switch(series) {
1119         case 100:
1120             sums = &h100pairs[0];
1121             origin = 0x1f0000;
1122             break;
1123         case 120:
1124             sums = &h120pairs[0];
1125             origin = 0x1f0000;
1126             break;
1127         case 300:
1128             sums = &h300pairs[0];
1129             origin = 0x3f0000;
1130             break;
1131     }
1132
1133     // temporary files needs to be opened to get the filename
1134     QTemporaryFile firmwareBin, newBin, newHex;
1135     firmwareBin.open();
1136     newBin.open();
1137     newHex.open();
1138     QString firmwareBinName = firmwareBin.fileName();
1139     QString newBinName = newBin.fileName();
1140     QString newHexName = newHex.fileName();
1141     firmwareBin.close();
1142     newBin.close();
1143     newHex.close();
1144
1145     // iriver decode
1146     if (iriver_decode(m_origfirmware, firmwareBinName, FALSE, STRIP_NONE,m_dp) == -1)
1147     {
1148         m_dp->addItem(tr("Error in descramble"),LOGERROR);
1149         firmwareBin.remove();
1150         newBin.remove();
1151         newHex.remove();
1152         emit done(true);
1153         return;
1154     }
1155     //  mkboot
1156     if (!mkboot(firmwareBinName, newBinName, m_tempfilename, origin,m_dp))
1157     {
1158         m_dp->addItem(tr("Error in patching"),LOGERROR);
1159         firmwareBin.remove();
1160         newBin.remove();
1161         newHex.remove();
1162         emit done(true);
1163         return;
1164     }
1165     // iriver_encode
1166     if (iriver_encode(newBinName, newHexName, FALSE,m_dp) == -1)
1167     {
1168         m_dp->addItem(tr("Error in scramble"),LOGERROR);
1169         firmwareBin.remove();
1170         newBin.remove();
1171         newHex.remove();
1172         emit done(true);
1173         return;
1174     }
1175
1176     /* now md5sum it */
1177     if (!FileMD5(newHexName, md5sum_str))
1178     {
1179         m_dp->addItem(tr("Error in checksumming"),LOGERROR);
1180         firmwareBin.remove();
1181         newBin.remove();
1182         newHex.remove();
1183         emit done(true);
1184         return;
1185     }
1186     if (strncmp(sums[table_entry].patched, md5sum_str, 32) == 0) {
1187         /* delete temp files */
1188         firmwareBin.remove();
1189         newBin.remove();
1190     }
1191
1192     // Load patched Firmware to player
1193     QString dest;
1194     if(series == 100)
1195             dest = m_mountpoint + "/ihp_100.hex";
1196     else if(series == 120)
1197             dest = m_mountpoint + "/ihp_120.hex";
1198     else if(series == 300)
1199             dest = m_mountpoint + "/H300.hex";
1200
1201     // copy file
1202     QFile destfile(dest);
1203     if(destfile.exists()) destfile.remove();
1204     if(!newHex.copy(dest))
1205     {
1206         m_dp->addItem(tr("Could not copy: %1 to %2")
1207                                 .arg(newHexName,dest),LOGERROR);
1208         emit done(true);
1209         return;
1210     }
1211
1212     downloadFile.remove();
1213     newHex.remove();
1214
1215     createInstallLog();
1216
1217     m_dp->addItem(tr("Bootloader install finished successfully."),LOGOK);
1218     m_dp->addItem(tr("To finish the Bootloader installation, follow the steps below."),LOGINFO);
1219     m_dp->addItem(tr("1. Eject/Unmount your Device."),LOGINFO);
1220     m_dp->addItem(tr("2. Boot into the original Firmware."),LOGINFO);
1221     m_dp->addItem(tr("3. Use the Firmware flash option in the Original Firmware."),LOGINFO);
1222     m_dp->addItem(tr("4. Reboot."),LOGINFO);
1223     m_dp->abort();
1224
1225     emit done(false);  // success
1226
1227
1228 }