src/flashtool.cpp

   1 #ifdef ENABLE_FLASHTOOL
   2 /**********************************************
   3 *
   4 *       $Revision: 1.11 $
   5 *
   6 **********************************************/
   7
   8 #include <flashtool.h>
   9 #include <enigma.h>
  10
  11 #include <lib/gui/emessage.h>
  12 #include <lib/gui/eprogress.h>
  13 #include <lib/dvb/decoder.h>
  14
  15 #include <sys/wait.h>
  16 #include <sys/reboot.h>
  17 #include <unistd.h>
  18 #include <signal.h>
  19 #include <dirent.h>
  20
  21 #include <fcntl.h>
  22 #include <sys/ioctl.h>
  23 #include <sys/mount.h>
  24 #include <linux/version.h>
  25 #if (LINUX_VERSION_CODE > KERNEL_VERSION(2,6,7)) && (LINUX_VERSION_CODE < KERNEL_VERSION(2,6,18))
  26 #include <linux/compiler.h>
  27 #endif
  28 #include <mtd/mtd-user.h>
  29
  30 class FlashProgressWindow: public eWindow
  31 {
  32 public:
  33         eProgress progress;
  34         FlashProgressWindow(const char *);
  35 };
  36
  37 FlashProgressWindow::FlashProgressWindow(const char *wtext)
  38         :eWindow(0), progress(this)
  39 {
  40         move(ePoint(100,250));
  41         cresize(eSize(470,50));
  42         setText(wtext);
  43         progress.move(ePoint(10,10));
  44         progress.resize(eSize(450,30));
  45 }
  46
  47
  48 eFlashtoolMain::eFlashtoolMain()
  49         :eListBoxWindow<eListBoxEntryText>(_("Flashtool"), 2, 350)
  50 {
  51         move(ePoint(150, 100));
  52         new eListBoxEntryText(&list, _("Save image or part of it"), (void *)0);
  53         new eListBoxEntryText(&list, _("Flash image or part of it"), (void *)1);
  54         CONNECT(list.selected, eFlashtoolMain::sel_item);
  55 }
  56
  57 void eFlashtoolMain::sel_item(eListBoxEntryText *sel)
  58 {
  59         if (sel)
  60         {
  61                 int flashtool=(int)sel->getKey();
  62                 /*if (flashtool==-1)
  63                 {
  64                         close(0);
  65                         return;
  66                 }*/
  67
  68                 hide();
  69                 eFlashtool flash(flashtool);
  70                 flash.show();
  71                 flash.exec();
  72                 flash.hide();
  73                 show();
  74         }
  75 }
  76
  77 eFlashtoolMain::~eFlashtoolMain()
  78 {
  79 }
  80
  81 eFlashtool::eFlashtool(int direction)
  82         :eListBoxWindow<eListBoxEntryText>(_("Partitions"), 12, 400)
  83 {
  84         /* direction == 0   -->  read
  85          * direction == 1   -->  write
  86          */
  87
  88         flashimage = direction;
  89         move(ePoint(150, 100));
  90         //new eListBoxEntryText(&list, _("back"), (void *)-1);
  91
  92         FILE* fd = fopen("/proc/mtd", "r");
  93         if (!fd)
  94         {
  95                 perror("cannot read /proc/mtd");
  96                 return;
  97         }
  98
  99         int entries = 0;
 100         char buf[1000];
 101         fgets(buf,sizeof(buf), fd);
 102         while(!feof(fd))
 103         {
 104                 if (fgets(buf, sizeof(buf), fd) != NULL)
 105                 {
 106                         char mtdname[50] = "";
 107                         int mtdnr = 0;
 108                         int mtdsize = 0;
 109                         int mtderasesize = 0;
 110                         sscanf(buf, "mtd%d: %x %x \"%[a-zA-Z0-9 =/+`äö<>@^°!?'.:,_-()#\\]\"\n", &mtdnr, &mtdsize, &mtderasesize, mtdname);
 111                         new eListBoxEntryText(&list, _(mtdname), (void*)mtdnr);
 112                         entries++;
 113                 }
 114         }
 115         fclose(fd);
 116
 117         cresize(eSize(400, 10 + entries * eListBoxEntryText::getEntryHeight()));
 118         list.move(ePoint(10, 5));
 119         list.resize(eSize(getClientSize().width() - 20, getClientSize().height() - 5));
 120
 121         CONNECT(list.selected, eFlashtool::sel_item);
 122 }
 123
 124 eFlashtool::~eFlashtool()
 125 {
 126 }
 127
 128 void eFlashtool::sel_item(eListBoxEntryText *sel)
 129 {
 130         if (sel)
 131         {
 132                 mtd = (int)sel->getKey();
 133
 134                 /*if (mtd == -1)
 135                 {
 136                         eWidget::accept();
 137                         return;
 138                 }*/
 139
 140                 hide();
 141
 142                 char destination[100];
 143                 eFlashtoolSource imagesource(flashimage);
 144                 imagesource.show();
 145                 int res = imagesource.exec();
 146                 imagesource.hide();
 147                 strcpy(destination, imagesource.getDestination());
 148
 149                 if (res == 2)
 150                         if (flashimage == 0)
 151                                 readmtd(destination);
 152                         else
 153                         {
 154                                 eMessageBox box(_("Do you really want to flash a new image now?"), _("Flash"), eMessageBox::btYes|eMessageBox::btNo|eMessageBox::iconWarning, eMessageBox::btNo);
 155                                 box.show();
 156                                 int res = box.exec();
 157                                 box.hide();
 158                                 if (res == eMessageBox::btYes)
 159                                         programm(destination);
 160                         }
 161                 show();
 162         }
 163 }
 164
 165 void eFlashtool::programm(char filename[])
 166 {
 167         char mtddev[20];
 168
 169         sprintf(mtddev,"/dev/mtd/%d", mtd);
 170
 171         if (access(filename, R_OK) == 0)
 172         {
 173                 int fd1, fd2;
 174                 unsigned long filesize;
 175
 176                 hide();
 177
 178                 if ((fd1 = open(filename, O_RDONLY)) < 0)
 179                 {
 180                         eMessageBox box(_("Can't read image!"), _("Flash"), eMessageBox::iconInfo|eMessageBox::btOK);
 181                         box.show();
 182                         box.exec();
 183                         box.hide();
 184                         return;
 185                 }
 186
 187                 filesize = lseek(fd1, 0, SEEK_END);
 188                 lseek(fd1, 0, SEEK_SET);
 189
 190                 if (filesize==0)
 191                 {
 192                         eMessageBox box(_("Image has file size of 0 bytes!"), _("Flash"), eMessageBox::iconInfo|eMessageBox::btOK);
 193                         box.show();
 194                         box.exec();
 195                         box.hide();
 196                         return;
 197                 }
 198
 199                 if ((fd2 = open(mtddev, O_WRONLY)) < 0)
 200                 {
 201                         eMessageBox box(_("Can't open mtd!"), _("Flash"), eMessageBox::iconInfo|eMessageBox::btOK);
 202                         box.show();
 203                         box.exec();
 204                         box.hide();
 205                         ::close(fd2);
 206                         return;
 207                 }
 208
 209                 mtd_info_t meminfo;
 210                 if (ioctl(fd2, MEMGETINFO, &meminfo) != 0)
 211                 {
 212                         return;
 213                 }
 214
 215                 if (filesize > meminfo.size)
 216                 {
 217                         eMessageBox box(_("Image size is too big! Can't flash!"), _("Flash"), eMessageBox::iconInfo|eMessageBox::btOK);
 218                         box.show();
 219                         box.exec();
 220                         box.hide();
 221                         return;
 222                 }
 223
 224                 if (filesize < ((meminfo.size/100)*70))
 225                 {
 226                         eMessageBox box(_("Image size is too small! Do you really want to flash it?"), _("Flash"), eMessageBox::btYes|eMessageBox::btNo|eMessageBox::iconWarning, eMessageBox::btNo);
 227                         box.show();
 228                         int res=box.exec();
 229                         box.hide();
 230                         if (res == eMessageBox::btNo)
 231                         {
 232                                 return;
 233                         }
 234                 }
 235
 236                 eMessageBox mb(_("Please wait... do NOT switch off the receiver!"),_("flashing in progress"), eMessageBox::iconWarning);
 237                 mb.show();
 238
 239                 sync();
 240                 Decoder::Flush();
 241
 242                 // without this nice we have not enough priority for
 243                 // file operations... then the update ist very slow on the
 244                 // dreambox
 245                 nice(-10);
 246
 247                 printf("Starting erasing %s...\n",mtddev);
 248
 249                 if (!erase())
 250                 {
 251                         eMessageBox box(_("Erase error!"), _("Flash"), eMessageBox::iconInfo|eMessageBox::btOK);
 252                         box.show();
 253                         box.exec();
 254                         box.hide();
 255                         return;
 256                 }
 257
 258                 FlashProgressWindow wnd(_("Writing image to flash...\n"));
 259                 wnd.show();
 260
 261                 char buf[meminfo.erasesize];
 262                 long fsize = filesize;
 263
 264                 printf("flashing now...\n");
 265                 while (fsize > 0)
 266                 {
 267                         long block = fsize;
 268                         if (block>(long)sizeof(buf))
 269                         {
 270                                 block = sizeof(buf);
 271                         }
 272                         read(fd1, buf, block);
 273                         write(fd2, buf, block);
 274                         fsize -= block;
 275                         wnd.progress.setPerc(((filesize - fsize) * 100) / filesize);
 276                 }
 277
 278                 ::close(fd1);
 279                 ::close(fd2);
 280                 wnd.hide();
 281                 mb.hide();
 282                 printf("finished\n");
 283                 eMessageBox mbend(_("Flashing successful! restarting..."),
 284                                 _("flashing ok"),eMessageBox::btOK|eMessageBox::iconInfo);
 285                 mbend.show();
 286                 mbend.exec();
 287                 mbend.hide();
 288                 ::reboot(RB_AUTOBOOT);
 289                 system("reboot");
 290                 return;
 291         }
 292         else
 293         {
 294                 eMessageBox box(_("Image not found!"), _("Flash"), eMessageBox::iconWarning|eMessageBox::btOK);
 295                 box.show();
 296                 box.exec();
 297                 box.hide();
 298         }
 299 }
 300
 301 bool eFlashtool::erase()
 302 {
 303         int fd;
 304         mtd_info_t meminfo;
 305         erase_info_t erase;
 306
 307         eString mtddev;
 308         mtddev.sprintf("/dev/mtd/%d", mtd);
 309
 310         if ((fd = open(mtddev.c_str(), O_RDWR)) < 0)
 311         {
 312                 return false;
 313         }
 314
 315         if (ioctl(fd, MEMGETINFO, &meminfo) != 0)
 316         {
 317                 return false;
 318         }
 319
 320         FlashProgressWindow wnd(_("Erasing flash..."));
 321         wnd.show();
 322         erase.length = meminfo.erasesize;
 323         for (erase.start = 0; erase.start < meminfo.size; erase.start += meminfo.erasesize)
 324         {
 325
 326                 printf("\rErasing %u KByte @ %x -- %2u %% complete.",
 327                                  meminfo.erasesize / 1024, erase.start,
 328                                  erase.start * 100 / meminfo.size);
 329
 330                 wnd.progress.setPerc(erase.start * 100 / meminfo.size);
 331                 if (ioctl(fd, MEMERASE, &erase) != 0)
 332                 {
 333                         ::close(fd);
 334                         return false;
 335                 }
 336         }
 337
 338         ::close(fd);
 339         wnd.hide();
 340         return true;
 341 }
 342
 343 bool eFlashtool::readmtd(char destination[])
 344 {
 345         int fd1, fd2;
 346         char mtddev[50];
 347         long filesize;
 348         mtd_info_t meminfo;
 349
 350         FILE *fd = fopen("/.version", "r");
 351
 352         char filename[50];
 353         sprintf(filename, "%s/mtd%d.img", destination, mtd);
 354         if (fd)
 355         {
 356                 char buffer[100];
 357                 fgets(buffer, sizeof(buffer), fd);
 358                 fclose(fd);
 359                 char date[9];
 360                 char time[5];
 361                 sscanf(buffer,"version=%*2s%*2s%8s%4s", date, time);
 362                 sprintf(filename,"%s/%s_%s_mtd%d.img", destination, date, time, mtd);
 363         }
 364
 365         sprintf(mtddev, "/dev/mtd/%d", mtd);
 366
 367         if ((fd1 = open(mtddev, O_RDONLY)) < 0)
 368         {
 369                 eMessageBox box(_("Can't open mtd device!"), _("Flash"), eMessageBox::iconWarning|eMessageBox::btOK);
 370                 box.show();
 371                 box.exec();
 372                 box.hide();
 373                 return false;
 374         }
 375
 376         if (ioctl(fd1, MEMGETINFO, &meminfo) != 0)
 377         {
 378                 return false;
 379         }
 380
 381         if ((fd2 = open(filename, O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR  |  S_IRGRP | S_IWGRP  |  S_IROTH | S_IWOTH)) < 0)
 382         {
 383                 eString message = eString(_("Can't open ")) + eString(destination) + eString(_(" for writing!"));
 384                 eMessageBox box(message.c_str(), _("Flash"), eMessageBox::iconWarning|eMessageBox::btOK);
 385                 box.show();
 386                 box.exec();
 387                 box.hide();
 388                 ::close(fd1);
 389                 return false;
 390         }
 391
 392         filesize = meminfo.size;
 393
 394         eMessageBox mb(_("Please wait while partition is being saved..."),_("saving in progress"), eMessageBox::iconInfo);
 395         mb.show();
 396
 397         FlashProgressWindow wnd(_("Read Flash..."));
 398         wnd.show();
 399         char buf[meminfo.erasesize];
 400         long fsize = filesize;
 401         while(fsize > 0)
 402         {
 403                 long block = fsize;
 404                 if (block > (long)sizeof(buf))
 405                         block = sizeof(buf);
 406                 read(fd1, &buf, block);
 407                 write(fd2, &buf, block);
 408                 fsize -= block;
 409                 wnd.progress.setPerc(((filesize - fsize) * 100) / filesize);
 410         }
 411         ::close(fd1);
 412         ::close(fd2);
 413         wnd.hide();
 414
 415         eString message = eString(_("Image saved to: ")) + eString(filename);
 416         eMessageBox boxend(message.c_str(), _("Flash"), eMessageBox::iconInfo|eMessageBox::btOK);
 417         boxend.show();
 418         boxend.exec();
 419         boxend.hide();
 420
 421         mb.hide();
 422
 423         return true;
 424 }
 425
 426 eFlashtoolImageView::eFlashtoolImageView(char folder[])
 427         :eListBoxWindow<eListBoxEntryText>(_("Image list"), 11, 530)
 428 {
 429         new eListBoxEntryText(&list, _("back"), (void *)new eString("back"), 0, "Choose your image and press OK...");
 430
 431         move(ePoint(100, 100));
 432         int entries = 2;
 433         struct dirent **namelist;
 434         int n = scandir(folder, &namelist, 0, alphasort);
 435         if (n < 0)
 436         {
 437                 perror("no flash images available");
 438         }
 439         else
 440         {
 441                 for(int count = 0; count < n; count++)
 442                 {
 443                         eString filen = namelist[count]->d_name;
 444                         int pos = filen.find(".img");
 445                         if (pos != -1)
 446                         {
 447                                 char tmp[100];
 448                                 char helptext[100];
 449                                 int fd1;
 450                                 sprintf(tmp, "%s/%s", folder, filen.c_str());
 451                                 if ((fd1 = open(tmp, O_RDONLY)) < 0)
 452                                         sprintf(helptext, "WARNING: can't open this image!");
 453                                 else
 454                                 {
 455                                         int filesize = lseek(fd1, 0, SEEK_END);
 456                                         lseek(fd1, 0, SEEK_SET);
 457                                         sprintf(helptext, "Image size: %d byte\n", filesize);
 458                                         ::close(fd1);
 459                                 }
 460
 461                                 new eListBoxEntryText(&list, filen, (void *)new eString(tmp), 0, helptext);
 462                                 entries++;
 463                         }
 464                         free(namelist[count]);
 465                 }
 466                 free(namelist);
 467         }
 468
 469         cresize(eSize(530, 10 + (entries > 10 ? 10 : entries) * eListBoxEntryText::getEntryHeight()));
 470         list.move(ePoint(10, 5));
 471         list.resize(eSize(getClientSize().width() - 20, getClientSize().height() - 30));
 472
 473         CONNECT(list.selected, eFlashtoolImageView::sel_item);
 474
 475         statusbar = new eStatusBar(this);
 476         statusbar->move(ePoint(0, clientrect.height() - 30));
 477         statusbar->resize(eSize(clientrect.width(), 30));
 478         statusbar->setText("");
 479         statusbar->loadDeco();
 480 }
 481
 482 void eFlashtoolImageView::sel_item(eListBoxEntryText *sel)
 483 {
 484         if (sel)
 485         {
 486                 sprintf(buffer,((eString *)sel->getKey())->c_str());
 487                 close(1);
 488         }
 489         else
 490                 close(0);
 491 }
 492
 493 char* eFlashtoolImageView::getFilename()
 494 {
 495         return buffer;
 496 }
 497
 498 eFlashtoolImageView::~eFlashtoolImageView()
 499 {
 500 }
 501
 502 eFlashtoolSource::eFlashtoolSource(int direction)
 503 #ifndef DISABLE_FILE
 504         :eListBoxWindow<eListBoxEntryText>(_("Save to..."), 5, 400)
 505 #else
 506         :eListBoxWindow<eListBoxEntryText>(_("Save to..."), 3, 400)
 507 #endif
 508 {
 509         flash = false;
 510
 511         if (direction == 1)
 512         {
 513                 setText(_("Select source..."));
 514                 flash = true;
 515         }
 516
 517         move(ePoint(150, 100));
 518         //new eListBoxEntryText(&list, _("back"), (void *)"back");
 519         new eListBoxEntryText(&list, "tmp", (void *)"/tmp");
 520 #ifndef DISABLE_FILE
 521         if (access("/hdd/images", W_OK) == 0)
 522                 new eListBoxEntryText(&list, "HDD", (void *)"/hdd/images");
 523         if (access("/var/mnt/usb/images", W_OK) == 0)
 524                 new eListBoxEntryText(&list, "USB", (void *)"/var/mnt/usb/images");
 525 #endif
 526         if (access("/var/mnt/nfs/images", W_OK) == 0)
 527                 new eListBoxEntryText(&list, "NFS", (void *)"/var/mnt/nfs/images");
 528         if (access("/var/mnt/cifs/images", W_OK) == 0)
 529                 new eListBoxEntryText(&list, "CIFS", (void *)"/var/mnt/cifs/images");
 530         CONNECT(list.selected, eFlashtoolSource::sel_item);
 531 }
 532
 533 void eFlashtoolSource::sel_item(eListBoxEntryText *sel)
 534 {
 535         if (sel)
 536         {
 537                 strcpy(buffer, (char *)sel->getKey());
 538
 539                 if (strcmp(buffer, "back") == 0)
 540                 {
 541                         close(1);
 542                         return;
 543                 }
 544
 545                 hide();
 546
 547                 int res = 1;
 548                 if (flash)
 549                 {
 550                         eFlashtoolImageView image(buffer);
 551                         image.show();
 552                         res = image.exec();
 553                         image.hide();
 554                         strcpy(buffer, image.getFilename());
 555                 }
 556                 if (strcmp(buffer, "back") == 0 || res == 0)
 557                         show();
 558                 else
 559                         close(2);
 560         }
 561 }
 562
 563 char* eFlashtoolSource::getDestination()
 564 {
 565         return buffer;
 566 }
 567
 568 eFlashtoolSource::~eFlashtoolSource()
 569 {
 570 }
 571
 572 #endif // ENABLE_FLASHTOOL