ShuriZma
/
desmume
mirror of https://github.com/TASEmulators/desmume.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cleanup: remove md5 (it was deactivated, and we should use libretro-common's if we readd it 

cleanup: move valuearray into guid which was the only place using it. we should probably then move guid into movie later, since it's unlikely anything else will use it.
This commit is contained in:
zeromus 2016-11-27 15:13:33 -06:00
parent 4a922b927d
commit 574815124a
8 changed files with 18 additions and 324 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
desmume/src/frontend/posix/Makefile.am
View File

@ -59,7 +59,7 @@ libdesmume_a_SOURCES = \
../../utils/ConvertUTF.c ../../utils/ConvertUTF.h ../../utils/guid.cpp ../../utils/guid.h \ ../../utils/ConvertUTF.c ../../utils/ConvertUTF.h ../../utils/guid.cpp ../../utils/guid.h \
../../utils/emufat.cpp ../../utils/emufat.h utils/emufat_types.h \ ../../utils/emufat.cpp ../../utils/emufat.h utils/emufat_types.h \
../../utils/fsnitro.cpp ../../utils/fsnitro.h \ ../../utils/fsnitro.cpp ../../utils/fsnitro.h \
../../utils/md5.cpp ../../utils/md5.h utils/valuearray.h ../../utils/xstring.cpp ../../utils/xstring.h \ ../../utils/xstring.cpp ../../utils/xstring.h \
../../utils/decrypt/crc.cpp ../../utils/decrypt/crc.h ../../utils/decrypt/decrypt.cpp \ ../../utils/decrypt/crc.cpp ../../utils/decrypt/crc.h ../../utils/decrypt/decrypt.cpp \
../../utils/decrypt/decrypt.h ../../utils/decrypt/header.cpp ../../utils/decrypt/header.h \ ../../utils/decrypt/decrypt.h ../../utils/decrypt/header.cpp ../../utils/decrypt/header.h \
../../utils/task.cpp ../../utils/task.h \ ../../utils/task.cpp ../../utils/task.h \

3
desmume/src/frontend/windows/DeSmuME.vcxproj
View File

@ -202,7 +202,6 @@
<ClCompile Include="..\..\gdbstub\gdbstub.cpp" /> <ClCompile Include="..\..\gdbstub\gdbstub.cpp" />
<ClCompile Include="..\..\utils\ConvertUTF.c" /> <ClCompile Include="..\..\utils\ConvertUTF.c" />
<ClCompile Include="..\..\utils\guid.cpp" /> <ClCompile Include="..\..\utils\guid.cpp" />
<ClCompile Include="..\..\utils\md5.cpp" />
<ClCompile Include="..\..\utils\task.cpp" /> <ClCompile Include="..\..\utils\task.cpp" />
<ClCompile Include="..\..\utils\xstring.cpp" /> <ClCompile Include="..\..\utils\xstring.cpp" />
<ClCompile Include="..\..\utils\decrypt\crc.cpp" /> <ClCompile Include="..\..\utils\decrypt\crc.cpp" />
@ -481,9 +480,7 @@
<ClInclude Include="..\gdbstub.h" /> <ClInclude Include="..\gdbstub.h" />
<ClInclude Include="..\utils\ConvertUTF.h" /> <ClInclude Include="..\utils\ConvertUTF.h" />
<ClInclude Include="..\utils\guid.h" /> <ClInclude Include="..\utils\guid.h" />
<ClInclude Include="..\utils\md5.h" />
<ClInclude Include="..\utils\task.h" /> <ClInclude Include="..\utils\task.h" />
<ClInclude Include="..\utils\valuearray.h" />
<ClInclude Include="..\utils\decrypt\crc.h" /> <ClInclude Include="..\utils\decrypt\crc.h" />
<ClInclude Include="..\utils\decrypt\decrypt.h" /> <ClInclude Include="..\utils\decrypt\decrypt.h" />
<ClInclude Include="..\utils\decrypt\header.h" /> <ClInclude Include="..\utils\decrypt\header.h" />

9
desmume/src/frontend/windows/DeSmuME.vcxproj.filters
View File

@ -159,9 +159,6 @@
<ClCompile Include="..\..\utils\guid.cpp"> <ClCompile Include="..\..\utils\guid.cpp">
<Filter>utils</Filter> <Filter>utils</Filter>
</ClCompile> </ClCompile>
<ClCompile Include="..\..\utils\md5.cpp">
<Filter>utils</Filter>
</ClCompile>
<ClCompile Include="..\..\utils\task.cpp"> <ClCompile Include="..\..\utils\task.cpp">
<Filter>utils</Filter> <Filter>utils</Filter>
</ClCompile> </ClCompile>
@ -923,15 +920,9 @@
<ClInclude Include="..\utils\guid.h"> <ClInclude Include="..\utils\guid.h">
<Filter>utils</Filter> <Filter>utils</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\utils\md5.h">
<Filter>utils</Filter>
</ClInclude>
<ClInclude Include="..\utils\task.h"> <ClInclude Include="..\utils\task.h">
<Filter>utils</Filter> <Filter>utils</Filter>
</ClInclude> </ClInclude>
<ClInclude Include="..\utils\valuearray.h">
<Filter>utils</Filter>
</ClInclude>
<ClInclude Include="..\utils\decrypt\crc.h"> <ClInclude Include="..\utils\decrypt\crc.h">
<Filter>utils\decrypt</Filter> <Filter>utils\decrypt</Filter>
</ClInclude> </ClInclude>

2
desmume/src/movie.h
View File

@ -38,7 +38,7 @@ typedef struct
u32 rerecord_count; u32 rerecord_count;
bool poweron; bool poweron;
u32 emu_version_used; u32 emu_version_used;
MD5DATA md5_of_rom_used; //MD5DATA md5_of_rom_used;
std::string name_of_rom_used; std::string name_of_rom_used;
std::vector<std::wstring> comments; std::vector<std::wstring> comments;

17
desmume/src/utils/guid.h
View File

@ -21,7 +21,22 @@
#include <string> #include <string>
#include <cstdio> #include <cstdio>
#include "../types.h" #include "../types.h"
#include "valuearray.h"
template<typename T, int N>
struct ValueArray
{
T data[N];
T &operator[](int index) { return data[index]; }
static const int size = N;
bool operator!=(ValueArray<T,N> &other) { return !operator==(other); }
bool operator==(ValueArray<T,N> &other)
{
for(int i=0;i<size;i++)
if(data[i] != other[i])
return false;
return true;
}
};
struct Desmume_Guid : public ValueArray<u8,16> struct Desmume_Guid : public ValueArray<u8,16>
{ {

248
desmume/src/utils/md5.cpp
View File

@ -1,248 +0,0 @@
/// \file
/// \brief RFC 1321 compliant MD5 implementation,
/// RFC 1321 compliant MD5 implementation,
/// by Christophe Devine <devine@cr0.net>;
/// this program is licensed under the GPL.
//Modified October 3, 2003, to remove testing code, and add include of "types.h".
//Added simple MD5 to ASCII string conversion function.
// -Xodnizel
#include <string.h>
#include "../types.h"
#include "md5.h"
typedef u8 uint8;
typedef u16 uint16;
typedef u32 uint32;
#define GET_UINT32(n,b,i) \
{ \
(n) = ( (uint32) (b)[(i) + 3] << 24 ) \
| ( (uint32) (b)[(i) + 2] << 16 ) \
| ( (uint32) (b)[(i) + 1] << 8 ) \
| ( (uint32) (b)[(i) ] ); \
}
#define PUT_UINT32(n,b,i) \
{ \
(b)[(i) ] = (uint8) ( (n) ); \
(b)[(i) + 1] = (uint8) ( (n) >> 8 ); \
(b)[(i) + 2] = (uint8) ( (n) >> 16 ); \
(b)[(i) + 3] = (uint8) ( (n) >> 24 ); \
}
void md5_starts( struct md5_context *ctx )
{
ctx->total[0] = 0;
ctx->total[1] = 0;
ctx->state[0] = 0x67452301;
ctx->state[1] = 0xEFCDAB89;
ctx->state[2] = 0x98BADCFE;
ctx->state[3] = 0x10325476;
}
static void md5_process( struct md5_context *ctx, uint8 data[64] )
{
uint32 A, B, C, D, X[16];
GET_UINT32( X[0], data, 0 );
GET_UINT32( X[1], data, 4 );
GET_UINT32( X[2], data, 8 );
GET_UINT32( X[3], data, 12 );
GET_UINT32( X[4], data, 16 );
GET_UINT32( X[5], data, 20 );
GET_UINT32( X[6], data, 24 );
GET_UINT32( X[7], data, 28 );
GET_UINT32( X[8], data, 32 );
GET_UINT32( X[9], data, 36 );
GET_UINT32( X[10], data, 40 );
GET_UINT32( X[11], data, 44 );
GET_UINT32( X[12], data, 48 );
GET_UINT32( X[13], data, 52 );
GET_UINT32( X[14], data, 56 );
GET_UINT32( X[15], data, 60 );
#define S(x,n) ((x << n) | ((x & 0xFFFFFFFF) >> (32 - n)))
#define P(a,b,c,d,k,s,t) \
{ \
a += F(b,c,d) + X[k] + t; a = S(a,s) + b; \
}
A = ctx->state[0];
B = ctx->state[1];
C = ctx->state[2];
D = ctx->state[3];
#define F(x,y,z) (z ^ (x & (y ^ z)))
P( A, B, C, D, 0, 7, 0xD76AA478 );
P( D, A, B, C, 1, 12, 0xE8C7B756 );
P( C, D, A, B, 2, 17, 0x242070DB );
P( B, C, D, A, 3, 22, 0xC1BDCEEE );
P( A, B, C, D, 4, 7, 0xF57C0FAF );
P( D, A, B, C, 5, 12, 0x4787C62A );
P( C, D, A, B, 6, 17, 0xA8304613 );
P( B, C, D, A, 7, 22, 0xFD469501 );
P( A, B, C, D, 8, 7, 0x698098D8 );
P( D, A, B, C, 9, 12, 0x8B44F7AF );
P( C, D, A, B, 10, 17, 0xFFFF5BB1 );
P( B, C, D, A, 11, 22, 0x895CD7BE );
P( A, B, C, D, 12, 7, 0x6B901122 );
P( D, A, B, C, 13, 12, 0xFD987193 );
P( C, D, A, B, 14, 17, 0xA679438E );
P( B, C, D, A, 15, 22, 0x49B40821 );
#undef F
#define F(x,y,z) (y ^ (z & (x ^ y)))
P( A, B, C, D, 1, 5, 0xF61E2562 );
P( D, A, B, C, 6, 9, 0xC040B340 );
P( C, D, A, B, 11, 14, 0x265E5A51 );
P( B, C, D, A, 0, 20, 0xE9B6C7AA );
P( A, B, C, D, 5, 5, 0xD62F105D );
P( D, A, B, C, 10, 9, 0x02441453 );
P( C, D, A, B, 15, 14, 0xD8A1E681 );
P( B, C, D, A, 4, 20, 0xE7D3FBC8 );
P( A, B, C, D, 9, 5, 0x21E1CDE6 );
P( D, A, B, C, 14, 9, 0xC33707D6 );
P( C, D, A, B, 3, 14, 0xF4D50D87 );
P( B, C, D, A, 8, 20, 0x455A14ED );
P( A, B, C, D, 13, 5, 0xA9E3E905 );
P( D, A, B, C, 2, 9, 0xFCEFA3F8 );
P( C, D, A, B, 7, 14, 0x676F02D9 );
P( B, C, D, A, 12, 20, 0x8D2A4C8A );
#undef F
#define F(x,y,z) (x ^ y ^ z)
P( A, B, C, D, 5, 4, 0xFFFA3942 );
P( D, A, B, C, 8, 11, 0x8771F681 );
P( C, D, A, B, 11, 16, 0x6D9D6122 );
P( B, C, D, A, 14, 23, 0xFDE5380C );
P( A, B, C, D, 1, 4, 0xA4BEEA44 );
P( D, A, B, C, 4, 11, 0x4BDECFA9 );
P( C, D, A, B, 7, 16, 0xF6BB4B60 );
P( B, C, D, A, 10, 23, 0xBEBFBC70 );
P( A, B, C, D, 13, 4, 0x289B7EC6 );
P( D, A, B, C, 0, 11, 0xEAA127FA );
P( C, D, A, B, 3, 16, 0xD4EF3085 );
P( B, C, D, A, 6, 23, 0x04881D05 );
P( A, B, C, D, 9, 4, 0xD9D4D039 );
P( D, A, B, C, 12, 11, 0xE6DB99E5 );
P( C, D, A, B, 15, 16, 0x1FA27CF8 );
P( B, C, D, A, 2, 23, 0xC4AC5665 );
#undef F
#define F(x,y,z) (y ^ (x | ~z))
P( A, B, C, D, 0, 6, 0xF4292244 );
P( D, A, B, C, 7, 10, 0x432AFF97 );
P( C, D, A, B, 14, 15, 0xAB9423A7 );
P( B, C, D, A, 5, 21, 0xFC93A039 );
P( A, B, C, D, 12, 6, 0x655B59C3 );
P( D, A, B, C, 3, 10, 0x8F0CCC92 );
P( C, D, A, B, 10, 15, 0xFFEFF47D );
P( B, C, D, A, 1, 21, 0x85845DD1 );
P( A, B, C, D, 8, 6, 0x6FA87E4F );
P( D, A, B, C, 15, 10, 0xFE2CE6E0 );
P( C, D, A, B, 6, 15, 0xA3014314 );
P( B, C, D, A, 13, 21, 0x4E0811A1 );
P( A, B, C, D, 4, 6, 0xF7537E82 );
P( D, A, B, C, 11, 10, 0xBD3AF235 );
P( C, D, A, B, 2, 15, 0x2AD7D2BB );
P( B, C, D, A, 9, 21, 0xEB86D391 );
#undef F
ctx->state[0] += A;
ctx->state[1] += B;
ctx->state[2] += C;
ctx->state[3] += D;
}
void md5_update( struct md5_context *ctx, uint8 *input, uint32 length )
{
uint32 left, fill;
if( ! length ) return;
left = ( ctx->total[0] >> 3 ) & 0x3F;
fill = 64 - left;
ctx->total[0] += length << 3;
ctx->total[1] += length >> 29;
ctx->total[0] &= 0xFFFFFFFF;
ctx->total[1] += ctx->total[0] < ( length << 3 );
if( left && length >= fill )
{
memcpy( (void *) (ctx->buffer + left), (void *) input, fill );
md5_process( ctx, ctx->buffer );
length -= fill;
input += fill;
left = 0;
}
while( length >= 64 )
{
md5_process( ctx, input );
length -= 64;
input += 64;
}
if( length )
{
memcpy( (void *) (ctx->buffer + left), (void *) input, length );
}
}
static uint8 md5_padding[64] =
{
0x80, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
};
void md5_finish( struct md5_context *ctx, uint8 digest[16] )
{
uint32 last, padn;
uint8 msglen[8];
PUT_UINT32( ctx->total[0], msglen, 0 );
PUT_UINT32( ctx->total[1], msglen, 4 );
last = ( ctx->total[0] >> 3 ) & 0x3F;
padn = ( last < 56 ) ? ( 56 - last ) : ( 120 - last );
md5_update( ctx, md5_padding, padn );
md5_update( ctx, msglen, 8 );
PUT_UINT32( ctx->state[0], digest, 0 );
PUT_UINT32( ctx->state[1], digest, 4 );
PUT_UINT32( ctx->state[2], digest, 8 );
PUT_UINT32( ctx->state[3], digest, 12 );
}
/* Uses a static buffer, so beware of how it's used. */
char *md5_asciistr(MD5DATA& md5)
{
uint8* digest = md5.data;
static char str[33];
static char trans[16]={'0','1','2','3','4','5','6','7','8','9','a','b','c','d','e','f'};
int x;
for(x=0;x<16;x++)
{
str[x*2]=trans[digest[x]>>4];
str[x*2+1]=trans[digest[x]&0x0F];
}
return(str);
}

23
desmume/src/utils/md5.h
View File

@ -1,23 +0,0 @@
#ifndef _MD5_H
#define _MD5_H
#include "../types.h"
#include "valuearray.h"
struct md5_context
{
u32 total[2];
u32 state[4];
u8 buffer[64];
};
typedef ValueArray<uint8,16> MD5DATA;
void md5_starts( struct md5_context *ctx );
void md5_update( struct md5_context *ctx, u8 *input, u32 length );
void md5_finish( struct md5_context *ctx, u8 digest[16] );
/* Uses a static buffer, so beware of how it's used. */
char *md5_asciistr(MD5DATA& md5);
#endif /* md5.h */

38
desmume/src/utils/valuearray.h
View File

@ -1,38 +0,0 @@
/*
Copyright (C) 2008 DeSmuME team
This file is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 2 of the License, or
(at your option) any later version.
This file is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with the this software. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _VALUEARRAY_H_
#define _VALUEARRAY_H_
template<typename T, int N>
struct ValueArray
{
T data[N];
T &operator[](int index) { return data[index]; }
static const int size = N;
bool operator!=(ValueArray<T,N> &other) { return !operator==(other); }
bool operator==(ValueArray<T,N> &other)
{
for(int i=0;i<size;i++)
if(data[i] != other[i])
return false;
return true;
}
};
#endif