apps/plugins/disktidy.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id$
   9  *
  10  * Copyright (C) 2005 David Dent
  11  *
  12  * This program is free software; you can redistribute it and/or
  13  * modify it under the terms of the GNU General Public License
  14  * as published by the Free Software Foundation; either version 2
  15  * of the License, or (at your option) any later version.
  16  *
  17  * This software is distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY
  18  * KIND, either express or implied.
  19  *
  20  ****************************************************************************/
  21 #include "plugin.h"
  22 #include "errno.h"
  23
  24
  25 static int removed = 0; /* number of items removed */
  26
  27 /* function return values */
  28 enum tidy_return
  29 {
  30     TIDY_RETURN_OK = 0,
  31     TIDY_RETURN_ERROR = 1,
  32     TIDY_RETURN_USB = 2,
  33     TIDY_RETURN_ABORT = 3,
  34 };
  35
  36 #define MAX_TYPES 64
  37 struct tidy_type {
  38     char filestring[64];
  39     int  pre;
  40     int  post;
  41     bool directory;
  42     bool remove;
  43 } tidy_types[MAX_TYPES];
  44 int tidy_type_count;
  45 bool tidy_loaded_and_changed = false;
  46
  47 #define DEFAULT_FILES PLUGIN_APPS_DIR "/disktidy.config"
  48 #define CUSTOM_FILES  PLUGIN_APPS_DIR "/disktidy_custom.config"
  49
  50 void add_item(const char* name, int index)
  51 {
  52     char *a;
  53     struct tidy_type *entry = tidy_types + index;
  54     rb->strcpy(entry->filestring, name);
  55     if (name[rb->strlen(name)-1] == '/')
  56     {
  57         entry->directory = true;
  58         entry->filestring[rb->strlen(name)-1] = '\0';
  59     }
  60     else
  61         entry->directory = false;
  62     a = rb->strchr(name, '*');
  63     if (a)
  64     {
  65         entry->pre = a - name;
  66         entry->post = rb->strlen(a+1);
  67     }
  68     else
  69     {
  70         entry->pre = -1;
  71         entry->post = -1;
  72     }
  73 }
  74
  75 static int find_file_string(const char *file, char *last_group)
  76 {
  77     char temp[MAX_PATH];
  78     int i = 0, idx_last_group = -1;
  79     bool folder = false;
  80     rb->strcpy(temp, file);
  81     if (temp[rb->strlen(temp)-1] == '/')
  82     {
  83         folder = true;
  84         temp[rb->strlen(temp)-1] = '\0';
  85     }
  86     while (i<tidy_type_count)
  87     {
  88         if (!rb->strcmp(tidy_types[i].filestring, temp) &&
  89             folder == tidy_types[i].directory)
  90             return i;
  91         else if (!rb->strcmp(tidy_types[i].filestring, last_group))
  92             idx_last_group = i;
  93         i++;
  94     }
  95     /* not found, so insert it into its group */
  96     if (file[0] != '<' && idx_last_group != -1)
  97     {
  98         for (i=idx_last_group; i<tidy_type_count; i++)
  99         {
 100             if (tidy_types[i].filestring[0] == '<')
 101             {
 102                 idx_last_group = i;
 103                 break;
 104             }
 105         }
 106         /* shift items up one */
 107         for (i=tidy_type_count;i>idx_last_group;i--)
 108         {
 109             rb->memcpy(&tidy_types[i], &tidy_types[i-1], sizeof(struct tidy_type));
 110         }
 111         tidy_type_count++;
 112         add_item(file, idx_last_group+1);
 113         return idx_last_group+1;
 114     }
 115     return i;
 116 }
 117
 118 bool tidy_load_file(const char* file)
 119 {
 120     int fd = rb->open(file, O_RDONLY), i;
 121     char buf[MAX_PATH], *str, *remove;
 122     char last_group[MAX_PATH] = "";
 123     bool new;
 124     if (fd < 0)
 125         return false;
 126     while ((tidy_type_count < MAX_TYPES) &&
 127             rb->read_line(fd, buf, MAX_PATH))
 128     {
 129         if (rb->settings_parseline(buf, &str, &remove))
 130         {
 131             i = find_file_string(str, last_group);
 132             new = (i >= tidy_type_count);
 133             if (!rb->strcmp(remove, "yes"))
 134                 tidy_types[i].remove = true;
 135             else tidy_types[i].remove = false;
 136             if (new)
 137             {
 138                 i = tidy_type_count;
 139                 add_item(str, i);
 140                 tidy_type_count++;
 141             }
 142             if (str[0] == '<')
 143                 rb->strcpy(last_group, str);
 144         }
 145     }
 146     rb->close(fd);
 147     return true;
 148 }
 149
 150 static bool match(struct tidy_type *tidy_type, char *string, int len)
 151 {
 152     char *pattern = tidy_type->filestring;
 153     if (tidy_type->pre < 0)
 154     {
 155         /* no '*', just compare. */
 156         return (rb->strcmp(pattern, string) == 0);
 157     }
 158     /* pattern is too long for the string. avoid 'ab*bc' matching 'abc'. */
 159     if (len < tidy_type->pre + tidy_type->post)
 160         return false;
 161     /* pattern has '*', compare former part of '*' to the begining of
 162        the string and compare next part of '*' to the end of string. */
 163     return (rb->strncmp(pattern, string, tidy_type->pre) == 0 &&
 164             rb->strcmp(pattern + tidy_type->pre + 1,
 165                         string + len - tidy_type->post) == 0);
 166 }
 167
 168 bool tidy_remove_item(char *item, int attr)
 169 {
 170     int i;
 171     int len;
 172     bool ret = false;
 173     len = rb->strlen(item);
 174     for (i=0; ret == false && i < tidy_type_count; i++)
 175     {
 176         if (match(&tidy_types[i], item, len))
 177         {
 178             if (!tidy_types[i].remove)
 179                 return false;
 180             if (attr&ATTR_DIRECTORY)
 181                 ret = tidy_types[i].directory;
 182             else ret = true;
 183         }
 184     }
 185     return ret;
 186 }
 187
 188 void tidy_lcd_status(const char *name)
 189 {
 190     /* display status text */
 191     rb->lcd_clear_display();
 192     rb->lcd_puts(0, 0, "Working ...");
 193     rb->lcd_puts(0, 1, name);
 194 #ifdef HAVE_LCD_BITMAP
 195     rb->lcd_putsf(0, 2, "Cleaned up %d items", removed);
 196 #endif
 197     rb->lcd_update();
 198 }
 199
 200 int tidy_path_append_entry(char *path, struct dirent *entry, int *path_length)
 201 {
 202     int name_len = rb->strlen(entry->d_name);
 203     /* for the special case of path="/" this is one bigger but it's not a problem */
 204     int new_length = *path_length + name_len + 1;
 205
 206     /* check overflow (keep space for trailing zero) */
 207     if(new_length >= MAX_PATH)
 208         return 0;
 209
 210     /* special case for path <> "/" */
 211     if(rb->strcmp(path, "/") != 0)
 212     {
 213         rb->strcat(path + *path_length, "/");
 214         (*path_length)++;
 215     }
 216     /* strcat is unsafe but the previous check normally avoid any problem */
 217     /* use path_length to optimise */
 218
 219     rb->strcat(path + *path_length, entry->d_name);
 220     *path_length += name_len;
 221
 222     return 1;
 223 }
 224
 225 void tidy_path_remove_entry(char *path, int old_path_length, int *path_length)
 226 {
 227     path[old_path_length] = '\0';
 228     *path_length = old_path_length;
 229 }
 230
 231 /* Removes the directory specified by 'path'. This includes recursively
 232    removing all files and directories in that directory.
 233    path is assumed to be array of size MAX_PATH.
 234 */
 235 enum tidy_return tidy_removedir(char *path, int *path_length)
 236 {
 237     /* delete directory */
 238     struct dirent *entry;
 239     enum tidy_return status = TIDY_RETURN_OK;
 240     int button;
 241     DIR *dir;
 242     int old_path_length = *path_length;
 243
 244     /* display status text */
 245     tidy_lcd_status(path);
 246
 247     rb->yield();
 248
 249     dir = rb->opendir(path);
 250     if (dir)
 251     {
 252         while((status == TIDY_RETURN_OK) && ((entry = rb->readdir(dir)) != 0))
 253         /* walk directory */
 254         {
 255             /* check for user input and usb connect */
 256             button = rb->get_action(CONTEXT_STD, TIMEOUT_NOBLOCK);
 257             if (button == ACTION_STD_CANCEL)
 258             {
 259                 rb->closedir(dir);
 260                 return TIDY_RETURN_ABORT;
 261             }
 262             if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 263             {
 264                 rb->closedir(dir);
 265                 return TIDY_RETURN_USB;
 266             }
 267
 268             rb->yield();
 269
 270             /* get absolute path */
 271             /* returns an error if path is too long */
 272             if(!tidy_path_append_entry(path, entry, path_length))
 273                 /* silent error */
 274                 continue;
 275
 276             struct dirinfo info = rb->dir_get_info(dir, entry);
 277             if (info.attribute & ATTR_DIRECTORY)
 278             {
 279                 /* dir ignore "." and ".." */
 280                 if ((rb->strcmp(entry->d_name, ".") != 0) && \
 281                     (rb->strcmp(entry->d_name, "..") != 0))
 282                 {
 283                     status = tidy_removedir(path, path_length);
 284                 }
 285             }
 286             else
 287             {
 288                 /* file */
 289                 removed++;
 290                 rb->remove(path);
 291             }
 292
 293             /* restore path */
 294             tidy_path_remove_entry(path, old_path_length, path_length);
 295         }
 296         rb->closedir(dir);
 297         /* rmdir */
 298         removed++;
 299         rb->rmdir(path);
 300     }
 301     else
 302     {
 303         status = TIDY_RETURN_ERROR;
 304     }
 305     return status;
 306 }
 307
 308 /* path is assumed to be array of size MAX_PATH */
 309 enum tidy_return tidy_clean(char *path, int *path_length)
 310 {
 311     /* deletes junk files and dirs left by system */
 312     struct dirent *entry;
 313     enum tidy_return status = TIDY_RETURN_OK;
 314     int button;
 315     DIR *dir;
 316     int old_path_length = *path_length;
 317
 318     /* display status text */
 319     tidy_lcd_status(path);
 320
 321     rb->yield();
 322
 323     dir = rb->opendir(path);
 324     if (dir)
 325     {
 326         while((status == TIDY_RETURN_OK) && ((entry = rb->readdir(dir)) != 0))
 327         /* walk directory */
 328         {
 329             struct dirinfo info = rb->dir_get_info(dir, entry);
 330             /* check for user input and usb connect */
 331             button = rb->get_action(CONTEXT_STD, TIMEOUT_NOBLOCK);
 332             if (button == ACTION_STD_CANCEL)
 333             {
 334                 rb->closedir(dir);
 335                 return TIDY_RETURN_ABORT;
 336             }
 337             if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 338             {
 339                 rb->closedir(dir);
 340                 return TIDY_RETURN_USB;
 341             }
 342
 343             rb->yield();
 344
 345             if (info.attribute & ATTR_DIRECTORY)
 346             {
 347                 /* directory ignore "." and ".." */
 348                 if ((rb->strcmp(entry->d_name, ".") != 0) && \
 349                     (rb->strcmp(entry->d_name, "..") != 0))
 350                 {
 351                     /* get absolute path */
 352                     /* returns an error if path is too long */
 353                     if(!tidy_path_append_entry(path, entry, path_length))
 354                         /* silent error */
 355                         continue;
 356
 357                     if (tidy_remove_item(entry->d_name, info.attribute))
 358                     {
 359                         /* delete dir */
 360                         status = tidy_removedir(path, path_length);
 361                     }
 362                     else
 363                     {
 364                         /* dir not deleted so clean it */
 365                         status = tidy_clean(path, path_length);
 366                     }
 367
 368                     /* restore path */
 369                     tidy_path_remove_entry(path, old_path_length, path_length);
 370                 }
 371             }
 372             else
 373             {
 374                 /* file */
 375                 if (tidy_remove_item(entry->d_name, info.attribute))
 376                 {
 377                     /* get absolute path */
 378                     /* returns an error if path is too long */
 379                     if(!tidy_path_append_entry(path, entry, path_length))
 380                         /* silent error */
 381                         continue;
 382
 383                     removed++; /* increment removed files counter */
 384                     /* delete file */
 385                     rb->remove(path);
 386
 387                     /* restore path */
 388                     tidy_path_remove_entry(path, old_path_length, path_length);
 389                 }
 390             }
 391         }
 392         rb->closedir(dir);
 393         return status;
 394     }
 395     else
 396     {
 397         return TIDY_RETURN_ERROR;
 398     }
 399 }
 400
 401 enum tidy_return tidy_do(void)
 402 {
 403     /* clean disk and display num of items removed */
 404     enum tidy_return status;
 405     char path[MAX_PATH];
 406     int path_length;
 407
 408 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 409     rb->cpu_boost(true);
 410 #endif
 411
 412     rb->strcpy(path, "/");
 413     path_length = rb->strlen(path);
 414     status = tidy_clean(path, &path_length);
 415
 416 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 417     rb->cpu_boost(false);
 418 #endif
 419
 420     if ((status == TIDY_RETURN_OK) || (status == TIDY_RETURN_ABORT))
 421     {
 422         rb->lcd_clear_display();
 423         if (status == TIDY_RETURN_ABORT)
 424         {
 425             rb->splash(HZ, "User aborted");
 426             rb->lcd_clear_display();
 427         }
 428         rb->splashf(HZ*2, "Cleaned up %d items", removed);
 429     }
 430     return status;
 431 }
 432
 433 enum themable_icons get_icon(int item, void * data)
 434 {
 435     (void)data;
 436     if (tidy_types[item].filestring[0] == '<') /* special type */
 437         return Icon_Folder;
 438     else if (tidy_types[item].remove)
 439         return Icon_Cursor;
 440     else
 441         return Icon_NOICON;
 442 }
 443
 444 static const char* get_name(int selected_item, void * data,
 445                             char * buffer, size_t buffer_len)
 446 {
 447     (void)data;
 448     if (tidy_types[selected_item].directory)
 449     {
 450         rb->snprintf(buffer, buffer_len, "%s/",
 451                      tidy_types[selected_item].filestring);
 452         return buffer;
 453     }
 454     return tidy_types[selected_item].filestring;
 455 }
 456
 457 int list_action_callback(int action, struct gui_synclist *lists)
 458 {
 459     if (action == ACTION_STD_OK)
 460     {
 461         int selection = rb->gui_synclist_get_sel_pos(lists);
 462         if (tidy_types[selection].filestring[0] == '<')
 463         {
 464             int i;
 465             if (!rb->strcmp(tidy_types[selection].filestring, "< ALL >"))
 466             {
 467                 for (i=0; i<tidy_type_count; i++)
 468                 {
 469                     if (tidy_types[i].filestring[0] != '<')
 470                         tidy_types[i].remove = true;
 471                 }
 472             }
 473             else if (!rb->strcmp(tidy_types[selection].filestring, "< NONE >"))
 474             {
 475                 for (i=0; i<tidy_type_count; i++)
 476                 {
 477                     if (tidy_types[i].filestring[0] != '<')
 478                         tidy_types[i].remove = false;
 479                 }
 480             }
 481             else /* toggle all untill the next <> */
 482             {
 483                 selection++;
 484                 while (selection < tidy_type_count &&
 485                        tidy_types[selection].filestring[0] != '<')
 486                 {
 487                     tidy_types[selection].remove = !tidy_types[selection].remove;
 488                     selection++;
 489                 }
 490             }
 491         }
 492         else
 493             tidy_types[selection].remove = !tidy_types[selection].remove;
 494         tidy_loaded_and_changed = true;
 495         return ACTION_REDRAW;
 496     }
 497     return action;
 498 }
 499
 500 enum tidy_return tidy_lcd_menu(void)
 501 {
 502     int selection = 0;
 503     enum tidy_return status = TIDY_RETURN_OK;
 504     bool menu_quit = false;
 505
 506     MENUITEM_STRINGLIST(menu, "Disktidy Menu", NULL,
 507                         "Start Cleaning", "Files to Clean",
 508                         "Quit");
 509
 510     while (!menu_quit)
 511     {
 512         switch(rb->do_menu(&menu, &selection, NULL, false))
 513         {
 514             case 0:
 515                 menu_quit = true;   /* start cleaning */
 516                 break;
 517
 518             case 1:
 519             {
 520                 struct simplelist_info list;
 521                 rb->simplelist_info_init(&list, "Files to Clean",
 522                                          tidy_type_count, NULL);
 523                 list.get_icon = get_icon;
 524                 list.get_name = get_name;
 525                 list.action_callback = list_action_callback;
 526                 rb->simplelist_show_list(&list);
 527             }
 528             break;
 529
 530             default:
 531                 status = TIDY_RETURN_ABORT; /* exit plugin */
 532                 menu_quit = true;
 533                 break;
 534         }
 535     }
 536     return status;
 537 }
 538
 539 /* Creates a file and writes information about what files to
 540    delete and what to keep to it.
 541    Returns true iff the file was successfully created.
 542 */
 543 static bool save_config(const char *file_name)
 544 {
 545     int fd, i;
 546     bool result;
 547
 548     fd = rb->creat(file_name, 0666);
 549     result = (fd >= 0);
 550
 551     if (result)
 552     {
 553         for (i=0; i<tidy_type_count; i++)
 554         {
 555             rb->fdprintf(fd, "%s%s: %s\n", tidy_types[i].filestring,
 556                          tidy_types[i].directory ? "/" : "",
 557                          tidy_types[i].remove ? "yes" : "no");
 558         }
 559         rb->close(fd);
 560     }
 561     else
 562     {
 563         DEBUGF("Could not create file %s\n", file_name);
 564     }
 565
 566     return result;
 567 }
 568
 569 /* this is the plugin entry point */
 570 enum plugin_status plugin_start(const void* parameter)
 571 {
 572     enum tidy_return status;
 573     (void)parameter;
 574
 575     tidy_type_count = 0;
 576     tidy_load_file(DEFAULT_FILES);
 577     tidy_load_file(CUSTOM_FILES);
 578     if (tidy_type_count == 0)
 579     {
 580         rb->splash(3*HZ, "Missing disktidy.config file");
 581         return PLUGIN_ERROR;
 582     }
 583     status = tidy_lcd_menu();
 584     if (tidy_loaded_and_changed)
 585     {
 586         save_config(CUSTOM_FILES);
 587     }
 588     if (status == TIDY_RETURN_ABORT)
 589         return PLUGIN_OK;
 590     while (true)
 591     {
 592             status = tidy_do();
 593
 594             switch (status)
 595             {
 596                 case TIDY_RETURN_OK:
 597                     return PLUGIN_OK;
 598                 case TIDY_RETURN_ERROR:
 599                     return PLUGIN_ERROR;
 600                 case TIDY_RETURN_USB:
 601                     return PLUGIN_USB_CONNECTED;
 602                 case TIDY_RETURN_ABORT:
 603                     return PLUGIN_OK;
 604             }
 605     }
 606
 607     if (rb->default_event_handler(rb->button_get(false)) == SYS_USB_CONNECTED)
 608         return PLUGIN_USB_CONNECTED;
 609
 610     rb->yield();
 611
 612     return PLUGIN_OK;
 613 }