apps/plugins/md5sum.c

   1 /***************************************************************************
   2  *             __________               __   ___.
   3  *   Open      \______   \ ____   ____ |  | _\_ |__   _______  ___
   4  *   Source     |       _//  _ \_/ ___\|  |/ /| __ \ /  _ \  \/  /
   5  *   Jukebox    |    |   (  <_> )  \___|    < | \_\ (  <_> > <  <
   6  *   Firmware   |____|_  /\____/ \___  >__|_ \|___  /\____/__/\_ \
   7  *                     \/            \/     \/    \/            \/
   8  * $Id: $
   9  *
  10  * Copyright (C) 2008 Antoine Cellerier <dionoea -at- videolan -dot- org>
  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
  22 #include "plugin.h"
  23 #include "lib/md5.h"
  24
  25 PLUGIN_HEADER
  26
  27 static const struct plugin_api *rb;
  28
  29 MEM_FUNCTION_WRAPPERS(rb);
  30
  31 #define BUFFERSIZE 16384
  32
  33 static int count = 0;
  34 static int done = 0;
  35 static bool quit = false;
  36
  37 static int hash( char *string, const char *path )
  38 {
  39     static char buffer[BUFFERSIZE];
  40     ssize_t len;
  41     struct md5_s md5;
  42     int in = rb->open( path, O_RDONLY );
  43     if( in < 0 ) return -1;
  44
  45     InitMD5( &md5 );
  46     while( !quit && ( len = rb->read( in, buffer, sizeof(buffer) ) ) > 0 )
  47     {
  48         AddMD5( &md5, buffer, len );
  49
  50         if( rb->get_action(CONTEXT_STD, TIMEOUT_NOBLOCK) == ACTION_STD_CANCEL )
  51             quit = true;
  52     }
  53
  54     EndMD5( &md5 );
  55
  56     psz_md5_hash( string, &md5 );
  57
  58     rb->close( in );
  59     return 0;
  60 }
  61
  62 static void hash_file( int out, const char *path )
  63 {
  64     if( out < 0 )
  65         count++;
  66     else
  67     {
  68         char string[MD5_STRING_LENGTH+1];
  69         int status;
  70         done++;
  71         rb->splashf( 0, "%d / %d : %s", done, count, path );
  72         status = hash( string, path );
  73
  74         if( quit )
  75             return;
  76
  77         if( status )
  78             rb->write( out, "error", 5 );
  79         else
  80             rb->write( out, string, MD5_STRING_LENGTH );
  81         rb->write( out, "  ", 2 );
  82         rb->write( out, path, rb->strlen( path ) );
  83         rb->write( out, "\n", 1 );
  84
  85         rb->yield();
  86     }
  87 }
  88
  89 static void hash_dir( int out, const char *path )
  90 {
  91     DIR *dir;
  92     struct dirent *entry;
  93
  94     dir = rb->opendir( path );
  95     if( dir )
  96     {
  97         while( !quit && ( entry = rb->readdir( dir ) ) )
  98         {
  99             char childpath[MAX_PATH];
 100             rb->snprintf( childpath, MAX_PATH, "%s/%s",
 101                           rb->strcmp( path, "/" ) ? path : "", entry->d_name );
 102             if( entry->attribute & ATTR_DIRECTORY )
 103             {
 104                 if( rb->strcmp( entry->d_name, "." )
 105                     && rb->strcmp( entry->d_name, ".." ) )
 106                 {
 107                     /* Got a sub directory */
 108                     hash_dir( out, childpath );
 109                 }
 110             }
 111             else
 112             {
 113                 /* Got a file */
 114                 hash_file( out, childpath );
 115             }
 116         }
 117         rb->closedir( dir );
 118     }
 119 }
 120
 121 static void hash_list( int out, const char *path )
 122 {
 123     int list = rb->open( path, O_RDONLY );
 124     char newpath[MAX_PATH];
 125     if( list < 0 ) return;
 126
 127     while( !quit && rb->read_line( list, newpath, MAX_PATH ) > 0 )
 128     {
 129         DIR *dir = rb->opendir( newpath );
 130         if( dir )
 131         {
 132             rb->closedir( dir );
 133             hash_dir( out, newpath );
 134         }
 135         else
 136         {
 137             hash_file( out, newpath );
 138         }
 139     }
 140
 141     rb->close( list );
 142 }
 143
 144 static void hash_check( int out, const char *path )
 145 {
 146     int list = rb->open( path, O_RDONLY );
 147     char line[MD5_STRING_LENGTH+1+MAX_PATH+1];
 148     int len;
 149     if( list < 0 ) return;
 150
 151     while( !quit && ( len = rb->read_line( list, line, MD5_STRING_LENGTH+1+MAX_PATH+1 ) ) > 0 )
 152     {
 153         if( out < 0 )
 154             count++;
 155         else
 156         {
 157             const char *filename = rb->strchr( line, ' ' );
 158             done++;
 159             rb->splashf( 0, "%d / %d : %s", done, count, filename );
 160             if( !filename || len < MD5_STRING_LENGTH + 2 )
 161             {
 162                 const char error[] = "Malformed input line ... skipping";
 163                 rb->write( out, error, rb->strlen( error ) );
 164             }
 165             else
 166             {
 167                 char string[MD5_STRING_LENGTH+1];
 168                 while( *filename == ' ' )
 169                     filename++;
 170                 rb->write( out, filename, rb->strlen( filename ) );
 171                 rb->write( out, ": ", 2 );
 172                 if( hash( string, filename ) )
 173                     rb->write( out, "FAILED open or read", 19 );
 174                 else if( rb->strncasecmp( line, string, MD5_STRING_LENGTH ) )
 175                     rb->write( out, "FAILED", 6 );
 176                 else
 177                     rb->write( out, "OK", 2 );
 178             }
 179             rb->write( out, "\n", 1 );
 180         }
 181     }
 182
 183     rb->close( list );
 184 }
 185
 186 enum plugin_status plugin_start(const struct plugin_api* api, const void* parameter)
 187 {
 188     const char *arg = (const char *)parameter; /* input file name, if any */
 189     int out = -1; /* output file descriptor */
 190     char filename[MAX_PATH]; /* output file name */
 191
 192     void (*action)( int, const char * ) = NULL;
 193
 194     md5_init( api );
 195     rb = api;
 196 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 197     rb->cpu_boost( true );
 198 #endif
 199
 200     if( arg && *arg )
 201     {
 202         const char *ext = rb->strrchr( arg, '.' );
 203         DIR *dir;
 204         rb->snprintf( filename, MAX_PATH, "%s.md5sum", arg );
 205
 206         if( ext )
 207         {
 208             if( !rb->strcmp( ext, ".md5" ) || !rb->strcmp( ext, ".md5sum" ) )
 209             {
 210                 rb->snprintf( filename + ( ext - arg ),
 211                               MAX_PATH + rb->strlen( ext ) - rb->strlen( arg ),
 212                               ".md5check" );
 213                 /* Lets check the sums */
 214                 action = hash_check;
 215             }
 216             else if( !rb->strcmp( ext, ".md5list" ) ) /* ugly */
 217             {
 218                 /* Hash listed files */
 219                 action = hash_list;
 220             }
 221         }
 222
 223         if( !action )
 224         {
 225             dir = rb->opendir( arg );
 226             if( dir )
 227             {
 228                 api->closedir( dir );
 229
 230                 /* Hash the directory's content recursively */
 231                 action = hash_dir;
 232             }
 233             else
 234             {
 235                 /* Hash the file */
 236                 action = hash_file;
 237             }
 238         }
 239     }
 240     else
 241     {
 242         rb->snprintf( filename, MAX_PATH, "/everything.md5sum" );
 243         /* Hash the whole filesystem */
 244         action = hash_dir;
 245         arg = "/";
 246     }
 247
 248     rb->lcd_puts( 0, 1, "Output file:" );
 249     rb->lcd_puts( 0, 2, filename );
 250
 251     count = 0;
 252     done = 0;
 253     action( out, arg );
 254
 255     out = rb->open( filename, O_WRONLY|O_CREAT|O_TRUNC );
 256     if( out < 0 ) return PLUGIN_ERROR;
 257     action( out, arg );
 258     rb->close( out );
 259 #ifdef HAVE_ADJUSTABLE_CPU_FREQ
 260     rb->cpu_boost( false );
 261 #endif
 262     return PLUGIN_OK;
 263 }