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 /* path is assumed to be array of size MAX_PATH */
 232 enum tidy_return tidy_removedir(char *path, int *path_length)
 233 {
 234     /* delete directory */
 235     struct dirent *entry;
 236     enum tidy_return status = TIDY_RETURN_OK;
 237     int button;
 238     DIR *dir;
 239     int old_path_length = *path_length;
 240
 241     /* display status text */
 242     tidy_lcd_status(path);
 243
 244     rb->yield();
 245
 246     dir = rb->opendir(path);
 247     if (dir)
 248     {
 249         while((status == TIDY_RETURN_OK) && ((entry = rb->readdir(dir)) != 0))
 250         /* walk directory */
 251         {
 252             /* check for user input and usb connect */
 253             button = rb->get_action(CONTEXT_STD, TIMEOUT_NOBLOCK);
 254             if (button == ACTION_STD_CANCEL)
 255             {
 256                 rb->closedir(dir);
 257                 return TIDY_RETURN_ABORT;
 258             }
 259             if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 260             {
 261                 rb->closedir(dir);
 262                 return TIDY_RETURN_USB;
 263             }
 264
 265             rb->yield();
 266
 267             /* get absolute path */
 268             /* returns an error if path is too long */
 269             if(!tidy_path_append_entry(path, entry, path_length))
 270                 /* silent error */
 271                 continue;
 272
 273             struct dirinfo info = rb->dir_get_info(dir, entry);
 274             if (info.attribute & ATTR_DIRECTORY)
 275             {
 276                 /* dir ignore "." and ".." */
 277                 if ((rb->strcmp(entry->d_name, ".") != 0) && \
 278                     (rb->strcmp(entry->d_name, "..") != 0))
 279                 {
 280                     status = tidy_removedir(path, path_length);
 281                 }
 282             }
 283             else
 284             {
 285                 /* file */
 286                 removed++;
 287                 rb->remove(path);
 288             }
 289
 290             /* restore path */
 291             tidy_path_remove_entry(path, old_path_length, path_length);
 292         }
 293         rb->closedir(dir);
 294         /* rmdir */
 295         removed++;
 296         rb->rmdir(path);
 297     }
 298     else
 299     {
 300         status = TIDY_RETURN_ERROR;
 301     }
 302     return status;
 303 }
 304
 305 /* path is assumed to be array of size MAX_PATH */
 306 enum tidy_return tidy_clean(char *path, int *path_length)
 307 {
 308     /* deletes junk files and dirs left by system */
 309     struct dirent *entry;
 310     enum tidy_return status = TIDY_RETURN_OK;
 311     int button;
 312     DIR *dir;
 313     int old_path_length = *path_length;
 314
 315     /* display status text */
 316     tidy_lcd_status(path);
 317
 318     rb->yield();
 319
 320     dir = rb->opendir(path);
 321     if (dir)
 322     {
 323         while((status == TIDY_RETURN_OK) && ((entry = rb->readdir(dir)) != 0))
 324         /* walk directory */
 325         {
 326             struct dirinfo info = rb->dir_get_info(dir, entry);
 327             /* check for user input and usb connect */
 328             button = rb->get_action(CONTEXT_STD, TIMEOUT_NOBLOCK);
 329             if (button == ACTION_STD_CANCEL)
 330             {
 331                 rb->closedir(dir);
 332                 return TIDY_RETURN_ABORT;
 333             }
 334             if (rb->default_event_handler(button) == SYS_USB_CONNECTED)
 335             {
 336                 rb->closedir(dir);
 337                 return TIDY_RETURN_USB;
 338             }
 339
 340             rb->yield();
 341
 342             if (info.attribute & ATTR_DIRECTORY)
 343             {
 344                 /* directory ignore "." and ".." */
 345                 if ((rb->strcmp(entry->d_name, ".") != 0) && \
 346                     (rb->strcmp(entry->d_name, "..") != 0))
 347                 {
 348                     /* get absolute path */
 349                     /* returns an error if path is too long */
 350                     if(!tidy_path_append_entry(path, entry, path_length))
 351                         /* silent error */
 352                         continue;
 353
 354                     if (tidy_remove_item(entry->d_name, info.attribute))
 355                     {
 356                         /* delete dir */
 357                         status = tidy_removedir(path, path_length);
 358                     }
 359                     else
 360                     {
 361                         /* dir not deleted so clean it */
 362                         status = tidy_clean(path, path_length);
 363                     }
 364
 365                     /* restore path */
 366                     tidy_path_remove_entry(path, old_path_length, path_length);
 367                 }
 368             }
 369             else
 370             {
 371                 /* file */
 372                 if (tidy_remove_item(entry->d_name, info.attribute))
 373                 {
 374                     /* get absolute path */
 375                     /* returns an error if path is too long */
 376                     if(!tidy_path_append_entry(path, entry, path_length))
 377                         /* silent error */
 378                         continue;
 379
 380                     removed++; /* increment removed files counter */
 381                     /* delete file */
 382                     rb->remove(path);
 383
 384                     /* restore path */
 385                     tidy_path_remove_entry(path, old_path_length, path_length);
 386                 }
 387             }
 388         }
 389         rb->closedir(dir);
 390         return status;
 391     }
 392     else
 393     {
 394         return TIDY_RETURN_ERROR;
 395     }
 396 }
 397
 398 enum tidy_return tidy_do(void)
 399 {
 400     /* clean disk and display num of items removed */
 401     enum tidy_return status;
 402     char path[MAX_PATH];
 403     int path_length;
 404
 405 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 406     rb->cpu_boost(true);
 407 #endif
 408
 409     rb->strcpy(path, "/");
 410     path_length = rb->strlen(path);
 411     status = tidy_clean(path, &path_length);
 412
 413 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 414     rb->cpu_boost(false);
 415 #endif
 416
 417     if ((status == TIDY_RETURN_OK) || (status == TIDY_RETURN_ABORT))
 418     {
 419         rb->lcd_clear_display();
 420         if (status == TIDY_RETURN_ABORT)
 421         {
 422             rb->splash(HZ, "User aborted");
 423             rb->lcd_clear_display();
 424         }
 425         rb->splashf(HZ*2, "Cleaned up %d items", removed);
 426     }
 427     return status;
 428 }
 429
 430 enum themable_icons get_icon(int item, void * data)
 431 {
 432     (void)data;
 433     if (tidy_types[item].filestring[0] == '<') /* special type */
 434         return Icon_Folder;
 435     else if (tidy_types[item].remove)
 436         return Icon_Cursor;
 437     else
 438         return Icon_NOICON;
 439 }
 440
 441 static const char* get_name(int selected_item, void * data,
 442                             char * buffer, size_t buffer_len)
 443 {
 444     (void)data;
 445     if (tidy_types[selected_item].directory)
 446     {
 447         rb->snprintf(buffer, buffer_len, "%s/",
 448                      tidy_types[selected_item].filestring);
 449         return buffer;
 450     }
 451     return tidy_types[selected_item].filestring;
 452 }
 453
 454 int list_action_callback(int action, struct gui_synclist *lists)
 455 {
 456     if (action == ACTION_STD_OK)
 457     {
 458         int selection = rb->gui_synclist_get_sel_pos(lists);
 459         if (tidy_types[selection].filestring[0] == '<')
 460         {
 461             int i;
 462             if (!rb->strcmp(tidy_types[selection].filestring, "< ALL >"))
 463             {
 464                 for (i=0; i<tidy_type_count; i++)
 465                 {
 466                     if (tidy_types[i].filestring[0] != '<')
 467                         tidy_types[i].remove = true;
 468                 }
 469             }
 470             else if (!rb->strcmp(tidy_types[selection].filestring, "< NONE >"))
 471             {
 472                 for (i=0; i<tidy_type_count; i++)
 473                 {
 474                     if (tidy_types[i].filestring[0] != '<')
 475                         tidy_types[i].remove = false;
 476                 }
 477             }
 478             else /* toggle all untill the next <> */
 479             {
 480                 selection++;
 481                 while (selection < tidy_type_count &&
 482                        tidy_types[selection].filestring[0] != '<')
 483                 {
 484                     tidy_types[selection].remove = !tidy_types[selection].remove;
 485                     selection++;
 486                 }
 487             }
 488         }
 489         else
 490             tidy_types[selection].remove = !tidy_types[selection].remove;
 491         tidy_loaded_and_changed = true;
 492         return ACTION_REDRAW;
 493     }
 494     return action;
 495 }
 496
 497 enum tidy_return tidy_lcd_menu(void)
 498 {
 499     int selection = 0;
 500     enum tidy_return status = TIDY_RETURN_OK;
 501     bool menu_quit = false;
 502
 503     MENUITEM_STRINGLIST(menu, "Disktidy Menu", NULL,
 504                         "Start Cleaning", "Files to Clean",
 505                         "Quit");
 506
 507     while (!menu_quit)
 508     {
 509         switch(rb->do_menu(&menu, &selection, NULL, false))
 510         {
 511             case 0:
 512                 menu_quit = true;   /* start cleaning */
 513                 break;
 514
 515             case 1:
 516             {
 517                 struct simplelist_info list;
 518                 rb->simplelist_info_init(&list, "Files to Clean",
 519                                          tidy_type_count, NULL);
 520                 list.get_icon = get_icon;
 521                 list.get_name = get_name;
 522                 list.action_callback = list_action_callback;
 523                 rb->simplelist_show_list(&list);
 524             }
 525             break;
 526
 527             default:
 528                 status = TIDY_RETURN_ABORT; /* exit plugin */
 529                 menu_quit = true;
 530                 break;
 531         }
 532     }
 533     return status;
 534 }
 535
 536 /* Creates a file and writes information about what files to
 537    delete and what to keep to it.
 538    Returns true iff the file was successfully created.
 539 */
 540 static bool save_config(const char *file_name)
 541 {
 542     int fd, i;
 543     bool result;
 544
 545     fd = rb->creat(file_name, 0666);
 546     result = (fd >= 0);
 547
 548     if (result)
 549     {
 550         for (i=0; i<tidy_type_count; i++)
 551         {
 552             rb->fdprintf(fd, "%s%s: %s\n", tidy_types[i].filestring,
 553                          tidy_types[i].directory ? "/" : "",
 554                          tidy_types[i].remove ? "yes" : "no");
 555         }
 556         rb->close(fd);
 557     }
 558     else
 559     {
 560         DEBUGF("Could not create file %s\n", file_name);
 561     }
 562
 563     return result;
 564 }
 565
 566 /* this is the plugin entry point */
 567 enum plugin_status plugin_start(const void* parameter)
 568 {
 569     enum tidy_return status;
 570     (void)parameter;
 571
 572     tidy_type_count = 0;
 573     tidy_load_file(DEFAULT_FILES);
 574     tidy_load_file(CUSTOM_FILES);
 575     if (tidy_type_count == 0)
 576     {
 577         rb->splash(3*HZ, "Missing disktidy.config file");
 578         return PLUGIN_ERROR;
 579     }
 580     status = tidy_lcd_menu();
 581     if (tidy_loaded_and_changed)
 582     {
 583         save_config(CUSTOM_FILES);
 584     }
 585     if (status == TIDY_RETURN_ABORT)
 586         return PLUGIN_OK;
 587     while (true)
 588     {
 589             status = tidy_do();
 590
 591             switch (status)
 592             {
 593                 case TIDY_RETURN_OK:
 594                     return PLUGIN_OK;
 595                 case TIDY_RETURN_ERROR:
 596                     return PLUGIN_ERROR;
 597                 case TIDY_RETURN_USB:
 598                     return PLUGIN_USB_CONNECTED;
 599                 case TIDY_RETURN_ABORT:
 600                     return PLUGIN_OK;
 601             }
 602     }
 603
 604     if (rb->default_event_handler(rb->button_get(false)) == SYS_USB_CONNECTED)
 605         return PLUGIN_USB_CONNECTED;
 606
 607     rb->yield();
 608
 609     return PLUGIN_OK;
 610 }