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