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: installbootloader.cpp 13990 2007-07-25 22:26:10Z Dominik Wenger $
  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
 183 /**************************************************
 184 *** gigabeat secific code
 185 ***************************************************/
 186
 187 void BootloaderInstaller::gigabeatPrepare()
 188 {
 189     if(m_install)         // Installation
 190     {
 191         QString url = m_bootloaderUrlBase + "/gigabeat/" + m_bootloadername;
 192
 193         m_dp->addItem(tr("Downloading file %1.%2")
 194             .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 195
 196         // temporary file needs to be opened to get the filename
 197         downloadFile.open();
 198         m_tempfilename = downloadFile.fileName();
 199         downloadFile.close();
 200         // get the real file.
 201         getter = new HttpGet(this);
 202         getter->setProxy(m_proxy);
 203         getter->setFile(&downloadFile);
 204         getter->getFile(QUrl(url));
 205         // connect signals from HttpGet
 206         connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 207         connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 208         connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 209    }
 210    else                 //UnInstallation
 211    {
 212         QString firmware = m_mountpoint + "/GBSYSTEM/FWIMG/FWIMG01.DAT";
 213         QString firmwareOrig = firmware.append(".ORIG");
 214
 215         QFileInfo firmwareOrigFI(firmwareOrig);
 216
 217         // check if original firmware exists
 218         if(!firmwareOrigFI.exists())
 219         {
 220              m_dp->addItem(tr("Could not find the Original Firmware at: %1")
 221                     .arg(firmwareOrig),LOGERROR);
 222             emit done(true);
 223             return;
 224         }
 225
 226         QFile firmwareFile(firmware);
 227         QFile firmwareOrigFile(firmwareOrig);
 228
 229         //remove modified firmware
 230         if(!firmwareFile.remove())
 231         {
 232              m_dp->addItem(tr("Could not remove the Firmware at: %1")
 233                     .arg(firmware),LOGERROR);
 234             emit done(true);
 235             return;
 236         }
 237
 238         //copy  original firmware
 239         if(!firmwareOrigFile.copy(firmware))
 240         {
 241              m_dp->addItem(tr("Could not copy the Firmware from: %1 to %2")
 242                     .arg(firmwareOrig,firmware),LOGERROR);
 243             emit done(true);
 244             return;
 245         }
 246
 247         emit done(false);  //success
 248    }
 249
 250 }
 251
 252 void BootloaderInstaller::gigabeatFinish()
 253 {
 254     // this step is only need for installation, so no code for uninstall here
 255
 256     m_dp->addItem(tr("Finishing bootloader install"),LOGINFO);
 257
 258     QString firmware = m_mountpoint + "/GBSYSTEM/FWIMG/" + m_bootloadername;
 259
 260     QFileInfo firmwareFI(firmware);
 261
 262     // check if firmware exists
 263     if(!firmwareFI.exists())
 264     {
 265         m_dp->addItem(tr("Could not find the Firmware at: %1")
 266             .arg(firmware),LOGERROR);
 267         emit done(true);
 268         return;
 269     }
 270
 271     QString firmwareOrig = firmware;
 272     firmwareOrig.append(".ORIG");
 273     QFileInfo firmwareOrigFI(firmwareOrig);
 274
 275     // rename the firmware, if there is no original firmware there
 276     if(!firmwareOrigFI.exists())
 277     {
 278         QFile firmwareFile(firmware);
 279         if(!firmwareFile.rename(firmwareOrig))
 280         {
 281             m_dp->addItem(tr("Could not rename: %1 to %2")
 282                                 .arg(firmware,firmwareOrig),LOGERROR);
 283             emit done(true);
 284             return;
 285         }
 286     }
 287     else // or remove the normal firmware, if the original is there
 288     {
 289         QFile firmwareFile(firmware);
 290         firmwareFile.remove();
 291     }
 292
 293     //copy the firmware
 294     if(!downloadFile.copy(firmware))
 295     {
 296         m_dp->addItem(tr("Could not copy: %1 to %2")
 297                                 .arg(m_tempfilename,firmware),LOGERROR);
 298         emit done(true);
 299         return;
 300     }
 301
 302     downloadFile.remove();
 303
 304     m_dp->addItem(tr("Bootloader install finished successfully."),LOGOK);
 305     m_dp->abort();
 306
 307     emit done(false);  // success
 308
 309 }
 310
 311 /**************************************************
 312 *** iaudio secific code
 313 ***************************************************/
 314 void BootloaderInstaller::iaudioPrepare()
 315 {
 316
 317     QString url = m_bootloaderUrlBase + "/iaudio/" + m_bootloadername;
 318
 319     m_dp->addItem(tr("Downloading file %1.%2")
 320           .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 321
 322     // temporary file needs to be opened to get the filename
 323     downloadFile.open();
 324     m_tempfilename = downloadFile.fileName();
 325     downloadFile.close();
 326     // get the real file.
 327     getter = new HttpGet(this);
 328     getter->setProxy(m_proxy);
 329     getter->setFile(&downloadFile);
 330     getter->getFile(QUrl(url));
 331     // connect signals from HttpGet
 332     connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 333     connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 334     connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 335 }
 336
 337 void BootloaderInstaller::iaudioFinish()
 338 {
 339     QString firmware = m_mountpoint + "/FIRMWARE/" + m_bootloadername;
 340
 341     //copy the firmware
 342     if(!downloadFile.copy(firmware))
 343     {
 344         m_dp->addItem(tr("Could not copy: %1 to %2")
 345                                 .arg(m_tempfilename,firmware),LOGERROR);
 346         emit done(true);
 347         return;
 348     }
 349
 350     downloadFile.remove();
 351
 352     m_dp->addItem(tr("Bootloader install finished successfully."),LOGOK);
 353     m_dp->abort();
 354
 355     emit done(false);  // success
 356
 357 }
 358
 359
 360 /**************************************************
 361 *** h10 secific code
 362 ***************************************************/
 363 void BootloaderInstaller::h10Prepare()
 364 {
 365     if(m_install)         // Installation
 366     {
 367         QString url = m_bootloaderUrlBase + "/iriver/" + m_bootloadername;
 368
 369         m_dp->addItem(tr("Downloading file %1.%2")
 370           .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 371
 372         // temporary file needs to be opened to get the filename
 373         downloadFile.open();
 374         m_tempfilename = downloadFile.fileName();
 375         downloadFile.close();
 376         // get the real file.
 377         getter = new HttpGet(this);
 378         getter->setProxy(m_proxy);
 379         getter->setFile(&downloadFile);
 380         getter->getFile(QUrl(url));
 381         // connect signals from HttpGet
 382         connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 383         connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 384         connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 385     }
 386     else             // Uninstallation
 387     {
 388
 389         QString firmwarename = m_bootloadername.section('/', -1);
 390
 391         QString firmware = m_mountpoint + "/SYSTEM/" + firmwarename;
 392         QString firmwareOrig = m_mountpoint + "/SYSTEM/Original.mi4";
 393
 394         QFileInfo firmwareFI(firmware);
 395         if(!firmwareFI.exists())  //Firmware dosent exists on player
 396         {
 397             firmware = m_mountpoint + "/SYSTEM/H10EMP.mi4";   //attempt other firmwarename
 398             firmwareFI.setFile(firmware);
 399             if(!firmwareFI.exists())  //Firmware dosent exists on player
 400             {
 401                 m_dp->addItem(tr("Firmware doesn not exist: %1")
 402                                 .arg(firmware),LOGERROR);
 403                 emit done(true);
 404                 return;
 405             }
 406         }
 407
 408         QFileInfo firmwareOrigFI(firmwareOrig);
 409         if(!firmwareOrigFI.exists())  //Original Firmware dosent exists on player
 410         {
 411             m_dp->addItem(tr("Original Firmware doesn not exist: %1")
 412                                 .arg(firmwareOrig),LOGERROR);
 413             emit done(true);
 414             return;
 415         }
 416
 417         QFile firmwareFile(firmware);
 418         QFile firmwareOrigFile(firmwareOrig);
 419
 420         //remove modified firmware
 421         if(!firmwareFile.remove())
 422         {
 423              m_dp->addItem(tr("Could not remove the Firmware at: %1")
 424                     .arg(firmware),LOGERROR);
 425             emit done(true);
 426             return;
 427         }
 428
 429         //copy  original firmware
 430         if(!firmwareOrigFile.copy(firmware))
 431         {
 432              m_dp->addItem(tr("Could not copy the Firmware from: %1 to %2")
 433                     .arg(firmwareOrig,firmware),LOGERROR);
 434             emit done(true);
 435             return;
 436         }
 437
 438         emit done(false);  //success
 439
 440     }
 441 }
 442
 443 void BootloaderInstaller::h10Finish()
 444 {
 445     QString firmwarename = m_bootloadername.section('/', -1);
 446
 447     QString firmware = m_mountpoint + "/SYSTEM/" + firmwarename;
 448     QString firmwareOrig = m_mountpoint + "/SYSTEM/Original.mi4";
 449
 450     QFileInfo firmwareFI(firmware);
 451
 452     if(!firmwareFI.exists())  //Firmware dosent exists on player
 453     {
 454         firmware = m_mountpoint + "/SYSTEM/H10EMP.mi4";   //attempt other firmwarename
 455         firmwareFI.setFile(firmware);
 456         if(!firmwareFI.exists())  //Firmware dosent exists on player
 457         {
 458             m_dp->addItem(tr("Firmware does not exist: %1")
 459                                 .arg(firmware),LOGERROR);
 460             emit done(true);
 461             return;
 462         }
 463     }
 464
 465     QFileInfo firmwareOrigFI(firmwareOrig);
 466
 467     if(!firmwareOrigFI.exists())  //there is already a original firmware
 468     {
 469         QFile firmwareFile(firmware);
 470         if(!firmwareFile.rename(firmwareOrig)) //rename Firmware to Original
 471         {
 472             m_dp->addItem(tr("Could not rename: %1 to %2")
 473                                 .arg(firmware,firmwareOrig),LOGERROR);
 474             emit done(true);
 475             return;
 476         }
 477     }
 478     else
 479     {
 480         QFile firmwareFile(firmware);
 481         firmwareFile.remove();
 482     }
 483         //copy the firmware
 484     if(!downloadFile.copy(firmware))
 485     {
 486         m_dp->addItem(tr("Could not copy: %1 to %2")
 487                                 .arg(m_tempfilename,firmware),LOGERROR);
 488         emit done(true);
 489         return;
 490     }
 491
 492     downloadFile.remove();
 493
 494     m_dp->addItem(tr("Bootloader install finished successfully."),LOGOK);
 495     m_dp->abort();
 496
 497     emit done(false);  // success
 498
 499 }
 500
 501 /**************************************************
 502 *** ipod secific code
 503 ***************************************************/
 504 int verbose =0;
 505 // reserves memory for ipodpatcher
 506 bool initIpodpatcher()
 507 {
 508     if (ipod_alloc_buffer(&sectorbuf,BUFFER_SIZE) < 0) return true;
 509       else return false;
 510 }
 511
 512 void BootloaderInstaller::ipodPrepare()
 513 {
 514     m_dp->addItem(tr("Searching for ipods"),LOGINFO);
 515     struct ipod_t ipod;
 516
 517     int n = ipod_scan(&ipod);
 518     if (n == 0)
 519     {
 520         m_dp->addItem(tr("No Ipods found"),LOGERROR);
 521         emit done(true);
 522         return;
 523     }
 524     if (n > 1)
 525     {
 526         m_dp->addItem(tr("Too many Ipods found"),LOGERROR);
 527         emit done(true);
 528     }
 529
 530     if(m_install)         // Installation
 531     {
 532
 533         QString url = m_bootloaderUrlBase + "/ipod/bootloader-" + m_bootloadername + ".ipod";
 534
 535         m_dp->addItem(tr("Downloading file %1.%2")
 536           .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 537
 538         // temporary file needs to be opened to get the filename
 539         downloadFile.open();
 540         m_tempfilename = downloadFile.fileName();
 541         downloadFile.close();
 542         // get the real file.
 543         getter = new HttpGet(this);
 544         getter->setProxy(m_proxy);
 545         getter->setFile(&downloadFile);
 546         getter->getFile(QUrl(url));
 547         // connect signals from HttpGet
 548         connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 549         connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 550         connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 551     }
 552     else                 // Uninstallation
 553     {
 554         if (ipod_open(&ipod, 0) < 0)
 555         {
 556             m_dp->addItem(tr("could not open ipod"),LOGERROR);
 557             emit done(true);
 558             return;
 559         }
 560
 561         if (read_partinfo(&ipod,0) < 0)
 562         {
 563             m_dp->addItem(tr("could not read partitiontable"),LOGERROR);
 564             emit done(true);
 565             return;
 566         }
 567
 568         if (ipod.pinfo[0].start==0)
 569         {
 570             m_dp->addItem(tr("No partition 0 on disk"),LOGERROR);
 571
 572             int i;
 573             double sectors_per_MB = (1024.0*1024.0)/ipod.sector_size;
 574             m_dp->addItem(tr("[INFO] Part    Start Sector    End Sector   Size (MB)   Type\n"),LOGINFO);
 575             for ( i = 0; i < 4; i++ )
 576             {
 577                 if (ipod.pinfo[i].start != 0)
 578                 {
 579                     m_dp->addItem(tr("[INFO]    %1      %2    %3  %4   %5 (%6)").arg(
 580                         i).arg(
 581                         ipod.pinfo[i].start).arg(
 582                         ipod.pinfo[i].start+ipod.pinfo[i].size-1).arg(
 583                         ipod.pinfo[i].size/sectors_per_MB).arg(
 584                         get_parttype(ipod.pinfo[i].type)).arg(
 585                         ipod.pinfo[i].type),LOGINFO);
 586                 }
 587             }
 588             emit done(true);
 589             return;
 590         }
 591
 592         read_directory(&ipod);
 593
 594         if (ipod.nimages <= 0)
 595         {
 596             m_dp->addItem(tr("Failed to read firmware directory"),LOGERROR);
 597             emit done(true);
 598             return;
 599         }
 600         if (getmodel(&ipod,(ipod.ipod_directory[0].vers>>8)) < 0)
 601         {
 602             m_dp->addItem(tr("Unknown version number in firmware (%1)").arg(
 603                 ipod.ipod_directory[0].vers),LOGERROR);
 604             emit done(true);
 605             return;
 606         }
 607
 608         if (ipod.macpod)
 609         {
 610             m_dp->addItem(tr("Warning this is a MacPod, Rockbox doesnt work on this. Convert it to WinPod"),LOGWARNING);
 611         }
 612
 613         if (ipod_reopen_rw(&ipod) < 0)
 614         {
 615             m_dp->addItem(tr("Could not open Ipod in RW mode"),LOGERROR);
 616             emit done(true);
 617             return;
 618         }
 619
 620         if (ipod.ipod_directory[0].entryOffset==0) {
 621             m_dp->addItem(tr("No bootloader detected."),LOGERROR);
 622             emit done(true);
 623             return;
 624         }
 625
 626         if (delete_bootloader(&ipod)==0)
 627         {
 628             m_dp->addItem(tr("Successfully removed Bootloader"),LOGOK);
 629             emit done(false);
 630             ipod_close(&ipod);
 631             return;
 632         }
 633         else
 634         {
 635             m_dp->addItem(tr("--delete-bootloader failed."),LOGERROR);
 636             emit done(true);
 637             ipod_close(&ipod);
 638             return;
 639         }
 640     }
 641 }
 642
 643 void BootloaderInstaller::ipodFinish()
 644 {
 645     struct ipod_t ipod;
 646     ipod_scan(&ipod);
 647
 648     if (ipod_open(&ipod, 0) < 0)
 649     {
 650         m_dp->addItem(tr("could not open ipod"),LOGERROR);
 651         emit done(true);
 652         return;
 653     }
 654
 655     if (read_partinfo(&ipod,0) < 0)
 656     {
 657         m_dp->addItem(tr("could not read partitiontable"),LOGERROR);
 658         emit done(true);
 659         return;
 660     }
 661
 662     if (ipod.pinfo[0].start==0)
 663     {
 664         m_dp->addItem(tr("No partition 0 on disk"),LOGERROR);
 665
 666         int i;
 667         double sectors_per_MB = (1024.0*1024.0)/ipod.sector_size;
 668
 669         m_dp->addItem(tr("[INFO] Part    Start Sector    End Sector   Size (MB)   Type\n"),LOGINFO);
 670
 671         for ( i = 0; i < 4; i++ )
 672         {
 673          if (ipod.pinfo[i].start != 0)
 674          {
 675             m_dp->addItem(tr("[INFO]    %1      %2    %3  %4   %5 (%6)").arg(
 676                     i).arg(
 677                    ipod.pinfo[i].start).arg(
 678                    ipod.pinfo[i].start+ipod.pinfo[i].size-1).arg(
 679                    ipod.pinfo[i].size/sectors_per_MB).arg(
 680                    get_parttype(ipod.pinfo[i].type)).arg(
 681                    ipod.pinfo[i].type),LOGWARNING);
 682          }
 683         }
 684         emit done(true);
 685         return;
 686     }
 687
 688     read_directory(&ipod);
 689
 690     if (ipod.nimages <= 0)
 691     {
 692         m_dp->addItem(tr("Failed to read firmware directory"),LOGERROR);
 693         emit done(true);
 694         return;
 695     }
 696     if (getmodel(&ipod,(ipod.ipod_directory[0].vers>>8)) < 0)
 697     {
 698         m_dp->addItem(tr("Unknown version number in firmware (%1)").arg(
 699                 ipod.ipod_directory[0].vers),LOGERROR);
 700         emit done(true);
 701         return;
 702     }
 703
 704     if (ipod.macpod)
 705     {
 706         m_dp->addItem(tr("Warning this is a MacPod, Rockbox doesnt work on this. Convert it to WinPod"),LOGWARNING);
 707     }
 708
 709     if (ipod_reopen_rw(&ipod) < 0)
 710     {
 711         m_dp->addItem(tr("Could not open Ipod in RW mode"),LOGERROR);
 712         emit done(true);
 713         return;
 714     }
 715
 716     if (add_bootloader(&ipod, m_tempfilename.toLatin1().data(), FILETYPE_DOT_IPOD)==0)
 717     {
 718         m_dp->addItem(tr("Successfully added Bootloader"),LOGOK);
 719         emit done(false);
 720         ipod_close(&ipod);
 721         return;
 722     }
 723     else
 724     {
 725         m_dp->addItem(tr("failed to add Bootloader"),LOGERROR);
 726         ipod_close(&ipod);
 727         emit done(true);
 728         return;
 729     }
 730 }
 731
 732 /**************************************************
 733 *** sansa secific code
 734 ***************************************************/
 735 // reserves memory for sansapatcher
 736 bool initSansaPatcher()
 737 {
 738       if (sansa_alloc_buffer(&sectorbuf,BUFFER_SIZE) < 0) return true;
 739       else return false;
 740 }
 741
 742
 743 void BootloaderInstaller::sansaPrepare()
 744 {
 745     m_dp->addItem(tr("Searching for sansas"),LOGINFO);
 746     struct sansa_t sansa;
 747
 748     int n = sansa_scan(&sansa);
 749     if (n == 0)
 750     {
 751         m_dp->addItem(tr("No Sansa found"),LOGERROR);
 752         emit done(true);
 753         return;
 754     }
 755     if (n > 1)
 756     {
 757         m_dp->addItem(tr("Too many Sansas found"),LOGERROR);
 758         emit done(true);
 759     }
 760
 761     if(m_install)         // Installation
 762     {
 763         QString url = m_bootloaderUrlBase + "/sandisk-sansa/e200/" + m_bootloadername;
 764
 765         m_dp->addItem(tr("Downloading file %1.%2")
 766           .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 767
 768         // temporary file needs to be opened to get the filename
 769         downloadFile.open();
 770         m_tempfilename = downloadFile.fileName();
 771         downloadFile.close();
 772         // get the real file.
 773         getter = new HttpGet(this);
 774         getter->setProxy(m_proxy);
 775         getter->setFile(&downloadFile);
 776         getter->getFile(QUrl(url));
 777         // connect signals from HttpGet
 778         connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 779         connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 780         connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 781     }
 782     else                 // Uninstallation
 783     {
 784
 785         if (sansa_open(&sansa, 0) < 0)
 786         {
 787             m_dp->addItem(tr("could not open Sansa"),LOGERROR);
 788             emit done(true);
 789             return;
 790         }
 791
 792         if (sansa_read_partinfo(&sansa,0) < 0)
 793         {
 794             m_dp->addItem(tr("could not read partitiontable"),LOGERROR);
 795             emit done(true);
 796             return;
 797         }
 798
 799         int i = is_e200(&sansa);
 800         if (i < 0) {
 801             m_dp->addItem(tr("Disk is not an E200 (%1), aborting.").arg(i),LOGERROR);
 802             emit done(true);
 803             return;
 804         }
 805
 806         if (sansa.hasoldbootloader)
 807         {
 808             m_dp->addItem(tr("********************************************\n"
 809                                        "OLD ROCKBOX INSTALLATION DETECTED, ABORTING.\n"
 810                                        "You must reinstall the original Sansa firmware before running\n"
 811                                        "sansapatcher for the first time.\n"
 812                                        "See http://www.rockbox.org/twiki/bin/view/Main/SansaE200Install\n"
 813                                        "*********************************************\n"),LOGERROR);
 814             emit done(true);
 815             return;
 816         }
 817
 818
 819         if (sansa_reopen_rw(&sansa) < 0)
 820         {
 821             m_dp->addItem(tr("Could not open Sansa in RW mode"),LOGERROR);
 822             emit done(true);
 823             return;
 824         }
 825
 826         if (sansa_delete_bootloader(&sansa)==0)
 827         {
 828             m_dp->addItem(tr("Successfully removed Bootloader"),LOGOK);
 829             emit done(false);
 830             sansa_close(&sansa);
 831             return;
 832         }
 833         else
 834         {
 835             m_dp->addItem(tr("--delete-bootloader failed."),LOGERROR);
 836             emit done(true);
 837             sansa_close(&sansa);
 838             return;
 839         }
 840     }
 841 }
 842
 843 void BootloaderInstaller::sansaFinish()
 844 {
 845     struct sansa_t sansa;
 846     sansa_scan(&sansa);
 847
 848     if (sansa_open(&sansa, 0) < 0)
 849     {
 850         m_dp->addItem(tr("could not open Sansa"),LOGERROR);
 851         emit done(true);
 852         return;
 853     }
 854
 855     if (sansa_read_partinfo(&sansa,0) < 0)
 856     {
 857         m_dp->addItem(tr("could not read partitiontable"),LOGERROR);
 858         emit done(true);
 859         return;
 860     }
 861
 862
 863     int i = is_e200(&sansa);
 864     if (i < 0) {
 865
 866         m_dp->addItem(tr("Disk is not an E200 (%1), aborting.").arg(i),LOGERROR);
 867         emit done(true);
 868         return;
 869     }
 870
 871     if (sansa.hasoldbootloader)
 872     {
 873         m_dp->addItem(tr("********************************************\n"
 874                                        "OLD ROCKBOX INSTALLATION DETECTED, ABORTING.\n"
 875                                        "You must reinstall the original Sansa firmware before running\n"
 876                                        "sansapatcher for the first time.\n"
 877                                        "See http://www.rockbox.org/twiki/bin/view/Main/SansaE200Install\n"
 878                                        "*********************************************\n"),LOGERROR);
 879         emit done(true);
 880         return;
 881     }
 882
 883     if (sansa_reopen_rw(&sansa) < 0)
 884     {
 885         m_dp->addItem(tr("Could not open Sansa in RW mode"),LOGERROR);
 886         emit done(true);
 887         return;
 888     }
 889
 890     if (sansa_add_bootloader(&sansa, m_tempfilename.toLatin1().data(), FILETYPE_MI4)==0)
 891     {
 892         m_dp->addItem(tr("Successfully added Bootloader"),LOGOK);
 893         emit done(false);
 894         sansa_close(&sansa);
 895         return;
 896     }
 897     else
 898     {
 899         m_dp->addItem(tr("failed to add Bootloader"),LOGERROR);
 900         sansa_close(&sansa);
 901         emit done(true);
 902         return;
 903     }
 904
 905 }
 906
 907 /**************************************************
 908 *** iriver /fwpatcher  secific code
 909 ***************************************************/
 910
 911 void BootloaderInstaller::iriverPrepare()
 912 {
 913     char md5sum_str[32];
 914     if (!FileMD5(m_origfirmware, md5sum_str)) {
 915         m_dp->addItem(tr("Could not MD5Sum original firmware"),LOGERROR);
 916         emit done(true);
 917         return;
 918     }
 919
 920     /* Check firmware against md5sums in h120sums and h100sums */
 921     series = 0;
 922     table_entry = intable(md5sum_str, &h120pairs[0],
 923                           sizeof(h120pairs)/sizeof(struct sumpairs));
 924     if (table_entry >= 0) {
 925         series = 120;
 926     }
 927     else
 928     {
 929         table_entry = intable(md5sum_str, &h100pairs[0],
 930                               sizeof(h100pairs)/sizeof(struct sumpairs));
 931         if (table_entry >= 0)
 932         {
 933             series = 100;
 934         }
 935         else
 936         {
 937             table_entry = intable(md5sum_str, &h300pairs[0],
 938                                   sizeof(h300pairs)/sizeof(struct sumpairs));
 939             if (table_entry >= 0)
 940                 series = 300;
 941         }
 942     }
 943     if (series == 0)
 944     {
 945         m_dp->addItem(tr("Could not detect firmware type"),LOGERROR);
 946         emit done(true);
 947         return;
 948     }
 949
 950     QString url = m_bootloaderUrlBase + "/iriver/" + m_bootloadername;
 951
 952     m_dp->addItem(tr("Downloading file %1.%2")
 953         .arg(QFileInfo(url).baseName(), QFileInfo(url).completeSuffix()),LOGINFO);
 954
 955     // temporary file needs to be opened to get the filename
 956     downloadFile.open();
 957     m_tempfilename = downloadFile.fileName();
 958     downloadFile.close();
 959     // get the real file.
 960     getter = new HttpGet(this);
 961     getter->setProxy(m_proxy);
 962     getter->setFile(&downloadFile);
 963     getter->getFile(QUrl(url));
 964     // connect signals from HttpGet
 965     connect(getter, SIGNAL(done(bool)), this, SLOT(downloadDone(bool)));
 966     connect(getter, SIGNAL(dataReadProgress(int, int)), this, SLOT(updateDataReadProgress(int, int)));
 967     connect(m_dp, SIGNAL(aborted()), getter, SLOT(abort()));
 968 }
 969
 970 void BootloaderInstaller::iriverFinish()
 971 {
 972     // Patch firmware
 973     char md5sum_str[32];
 974     struct sumpairs *sums = 0;
 975     int origin = 0;
 976
 977     /* get pointer to the correct bootloader.bin */
 978     switch(series) {
 979         case 100:
 980             sums = &h100pairs[0];
 981             origin = 0x1f0000;
 982             break;
 983         case 120:
 984             sums = &h120pairs[0];
 985             origin = 0x1f0000;
 986             break;
 987         case 300:
 988             sums = &h300pairs[0];
 989             origin = 0x3f0000;
 990             break;
 991     }
 992
 993     // temporary files needs to be opened to get the filename
 994     QTemporaryFile firmwareBin, newBin, newHex;
 995     firmwareBin.open();
 996     newBin.open();
 997     newHex.open();
 998     QString firmwareBinName = firmwareBin.fileName();
 999     QString newBinName = newBin.fileName();
1000     QString newHexName = newHex.fileName();
1001     firmwareBin.close();
1002     newBin.close();
1003     newHex.close();
1004
1005     // iriver decode
1006     if (iriver_decode(m_origfirmware, firmwareBinName, FALSE, STRIP_NONE,m_dp) == -1)
1007     {
1008         m_dp->addItem(tr("Error in descramble"),LOGERROR);
1009         firmwareBin.remove();
1010         newBin.remove();
1011         newHex.remove();
1012         emit done(true);
1013         return;
1014     }
1015     //  mkboot
1016     if (!mkboot(firmwareBinName, newBinName, m_tempfilename, origin,m_dp))
1017     {
1018         m_dp->addItem(tr("Error in patching"),LOGERROR);
1019         firmwareBin.remove();
1020         newBin.remove();
1021         newHex.remove();
1022         emit done(true);
1023         return;
1024     }
1025     // iriver_encode
1026     if (iriver_encode(newBinName, newHexName, FALSE,m_dp) == -1)
1027     {
1028         m_dp->addItem(tr("Error in scramble"),LOGERROR);
1029         firmwareBin.remove();
1030         newBin.remove();
1031         newHex.remove();
1032         emit done(true);
1033         return;
1034     }
1035
1036     /* now md5sum it */
1037     if (!FileMD5(newHexName, md5sum_str))
1038     {
1039         m_dp->addItem(tr("Error in checksumming"),LOGERROR);
1040         firmwareBin.remove();
1041         newBin.remove();
1042         newHex.remove();
1043         emit done(true);
1044         return;
1045     }
1046     if (strncmp(sums[table_entry].patched, md5sum_str, 32) == 0) {
1047         /* delete temp files */
1048         firmwareBin.remove();
1049         newBin.remove();
1050     }
1051
1052     // Load patched Firmware to player
1053     QString dest;
1054     if(series == 100)
1055             dest = m_mountpoint + "/ihp_100.hex";
1056     else if(series == 120)
1057             dest = m_mountpoint + "/ihp_120.hex";
1058     else if(series == 300)
1059             dest = m_mountpoint + "/H300.hex";
1060     // copy file
1061     if(!newHex.copy(dest))
1062     {
1063         m_dp->addItem(tr("Could not copy: %1 to %2")
1064                                 .arg(newHexName,dest),LOGERROR);
1065         emit done(true);
1066         return;
1067     }
1068
1069     downloadFile.remove();
1070     newHex.remove();
1071
1072     m_dp->addItem(tr("Bootloader install finished successfully."),LOGOK);
1073     m_dp->abort();
1074
1075     emit done(false);  // success
1076
1077
1078 }