topaLE
/
ni-buildsystem
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Browse Source

- remove vinfo plugin code; new location is ni-neutrino-plugins repo

master
vanhofen 7 years ago
parent
df55eb3f70
commit
2350edab0e
5 changed files with 2 additions and 723 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 241
      archive-sources/vinfo/md5.c
  2. 46
      archive-sources/vinfo/md5.h
  3. 387
      archive-sources/vinfo/vinfo.c
  4. 47
      archive-sources/vinfo/vinfo.h
  5. 4
      make/plugins.mk

241
archive-sources/vinfo/md5.c
View File

@ -1,241 +0,0 @@
/*
* This code implements the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was
* written by Colin Plumb in 1993, no copyright is claimed.
* This code is in the public domain; do with it what you wish.
*
* Equivalent code is available from RSA Data Security, Inc.
* This code has been tested against that, and is equivalent,
* except that you don't need to include two pages of legalese
* with every copy.
*
* To compute the message digest of a chunk of bytes, declare an
* MD5Context structure, pass it to MD5Init, call MD5Update as
* needed on buffers full of bytes, and then call MD5Final, which
* will fill a supplied 16-byte array with the digest.
*
* Changed so as no longer to depend on Colin Plumb's `usual.h' header
* definitions; now uses stuff from dpkg's config.h.
* - Ian Jackson <ijackson@nyx.cs.du.edu>.
* Still in the public domain.
*/
#include <string.h> /* for memcpy() */
#include "md5.h"
/* HAS_BIGENDIAN_WORDS auskommentiertt wg. ppc-architektur */
/* #ifdef HAS_BIGENDIAN_WORDS */
void
byteSwap(UWORD32 *buf, unsigned words)
{
md5byte *p = (md5byte *)buf;
do {
*buf++ = (UWORD32)((unsigned)p[3] << 8 | p[2]) << 16 |
((unsigned)p[1] << 8 | p[0]);
p += 4;
} while (--words);
}
/*
#else
#define byteSwap(buf,words)
#endif
*/
/*
* Start MD5 accumulation. Set bit count to 0 and buffer to mysterious
* initialization constants.
*/
void
MD5Init(struct MD5Context *ctx)
{
ctx->buf[0] = 0x67452301;
ctx->buf[1] = 0xefcdab89;
ctx->buf[2] = 0x98badcfe;
ctx->buf[3] = 0x10325476;
ctx->bytes[0] = 0;
ctx->bytes[1] = 0;
}
/*
* Update context to reflect the concatenation of another buffer full
* of bytes.
*/
void
MD5Update(struct MD5Context *ctx, md5byte const *buf, unsigned len)
{
UWORD32 t;
/* Update byte count */
t = ctx->bytes[0];
if ((ctx->bytes[0] = t + len) < t)
ctx->bytes[1]++; /* Carry from low to high */
t = 64 - (t & 0x3f); /* Space available in ctx->in (at least 1) */
if (t > len) {
memcpy((md5byte *)ctx->in + 64 - t, buf, len);
return;
}
/* First chunk is an odd size */
memcpy((md5byte *)ctx->in + 64 - t, buf, t);
byteSwap(ctx->in, 16);
MD5Transform(ctx->buf, ctx->in);
buf += t;
len -= t;
/* Process data in 64-byte chunks */
while (len >= 64) {
memcpy(ctx->in, buf, 64);
byteSwap(ctx->in, 16);
MD5Transform(ctx->buf, ctx->in);
buf += 64;
len -= 64;
}
/* Handle any remaining bytes of data. */
memcpy(ctx->in, buf, len);
}
/*
* Final wrapup - pad to 64-byte boundary with the bit pattern
* 1 0* (64-bit count of bits processed, MSB-first)
*/
void
MD5Final(md5byte digest[16], struct MD5Context *ctx)
{
int count = ctx->bytes[0] & 0x3f; /* Number of bytes in ctx->in */
md5byte *p = (md5byte *)ctx->in + count;
/* Set the first char of padding to 0x80. There is always room. */
*p++ = 0x80;
/* Bytes of padding needed to make 56 bytes (-8..55) */
count = 56 - 1 - count;
if (count < 0) { /* Padding forces an extra block */
memset(p, 0, count + 8);
byteSwap(ctx->in, 16);
MD5Transform(ctx->buf, ctx->in);
p = (md5byte *)ctx->in;
count = 56;
}
memset(p, 0, count);
byteSwap(ctx->in, 14);
/* Append length in bits and transform */
ctx->in[14] = ctx->bytes[0] << 3;
ctx->in[15] = ctx->bytes[1] << 3 | ctx->bytes[0] >> 29;
MD5Transform(ctx->buf, ctx->in);
byteSwap(ctx->buf, 4);
memcpy(digest, ctx->buf, 16);
memset(ctx, 0, sizeof(ctx)); /* In case it's sensitive */
}
#ifndef ASM_MD5
/* The four core functions - F1 is optimized somewhat */
/* #define F1(x, y, z) (x & y | ~x & z) */
#define F1(x, y, z) (z ^ (x & (y ^ z)))
#define F2(x, y, z) F1(z, x, y)
#define F3(x, y, z) (x ^ y ^ z)
#define F4(x, y, z) (y ^ (x | ~z))
/* This is the central step in the MD5 algorithm. */
#define MD5STEP(f,w,x,y,z,in,s) \
(w += f(x,y,z) + in, w = (w<<s | w>>(32-s)) + x)
/*
* The core of the MD5 algorithm, this alters an existing MD5 hash to
* reflect the addition of 16 longwords of new data. MD5Update blocks
* the data and converts bytes into longwords for this routine.
*/
void
MD5Transform(UWORD32 buf[4], UWORD32 const in[16])
{
register UWORD32 a, b, c, d;
a = buf[0];
b = buf[1];
c = buf[2];
d = buf[3];
MD5STEP(F1, a, b, c, d, in[0] + 0xd76aa478, 7);
MD5STEP(F1, d, a, b, c, in[1] + 0xe8c7b756, 12);
MD5STEP(F1, c, d, a, b, in[2] + 0x242070db, 17);
MD5STEP(F1, b, c, d, a, in[3] + 0xc1bdceee, 22);
MD5STEP(F1, a, b, c, d, in[4] + 0xf57c0faf, 7);
MD5STEP(F1, d, a, b, c, in[5] + 0x4787c62a, 12);
MD5STEP(F1, c, d, a, b, in[6] + 0xa8304613, 17);
MD5STEP(F1, b, c, d, a, in[7] + 0xfd469501, 22);
MD5STEP(F1, a, b, c, d, in[8] + 0x698098d8, 7);
MD5STEP(F1, d, a, b, c, in[9] + 0x8b44f7af, 12);
MD5STEP(F1, c, d, a, b, in[10] + 0xffff5bb1, 17);
MD5STEP(F1, b, c, d, a, in[11] + 0x895cd7be, 22);
MD5STEP(F1, a, b, c, d, in[12] + 0x6b901122, 7);
MD5STEP(F1, d, a, b, c, in[13] + 0xfd987193, 12);
MD5STEP(F1, c, d, a, b, in[14] + 0xa679438e, 17);
MD5STEP(F1, b, c, d, a, in[15] + 0x49b40821, 22);
MD5STEP(F2, a, b, c, d, in[1] + 0xf61e2562, 5);
MD5STEP(F2, d, a, b, c, in[6] + 0xc040b340, 9);
MD5STEP(F2, c, d, a, b, in[11] + 0x265e5a51, 14);
MD5STEP(F2, b, c, d, a, in[0] + 0xe9b6c7aa, 20);
MD5STEP(F2, a, b, c, d, in[5] + 0xd62f105d, 5);
MD5STEP(F2, d, a, b, c, in[10] + 0x02441453, 9);
MD5STEP(F2, c, d, a, b, in[15] + 0xd8a1e681, 14);
MD5STEP(F2, b, c, d, a, in[4] + 0xe7d3fbc8, 20);
MD5STEP(F2, a, b, c, d, in[9] + 0x21e1cde6, 5);
MD5STEP(F2, d, a, b, c, in[14] + 0xc33707d6, 9);
MD5STEP(F2, c, d, a, b, in[3] + 0xf4d50d87, 14);
MD5STEP(F2, b, c, d, a, in[8] + 0x455a14ed, 20);
MD5STEP(F2, a, b, c, d, in[13] + 0xa9e3e905, 5);
MD5STEP(F2, d, a, b, c, in[2] + 0xfcefa3f8, 9);
MD5STEP(F2, c, d, a, b, in[7] + 0x676f02d9, 14);
MD5STEP(F2, b, c, d, a, in[12] + 0x8d2a4c8a, 20);
MD5STEP(F3, a, b, c, d, in[5] + 0xfffa3942, 4);
MD5STEP(F3, d, a, b, c, in[8] + 0x8771f681, 11);
MD5STEP(F3, c, d, a, b, in[11] + 0x6d9d6122, 16);
MD5STEP(F3, b, c, d, a, in[14] + 0xfde5380c, 23);
MD5STEP(F3, a, b, c, d, in[1] + 0xa4beea44, 4);
MD5STEP(F3, d, a, b, c, in[4] + 0x4bdecfa9, 11);
MD5STEP(F3, c, d, a, b, in[7] + 0xf6bb4b60, 16);
MD5STEP(F3, b, c, d, a, in[10] + 0xbebfbc70, 23);
MD5STEP(F3, a, b, c, d, in[13] + 0x289b7ec6, 4);
MD5STEP(F3, d, a, b, c, in[0] + 0xeaa127fa, 11);
MD5STEP(F3, c, d, a, b, in[3] + 0xd4ef3085, 16);
MD5STEP(F3, b, c, d, a, in[6] + 0x04881d05, 23);
MD5STEP(F3, a, b, c, d, in[9] + 0xd9d4d039, 4);
MD5STEP(F3, d, a, b, c, in[12] + 0xe6db99e5, 11);
MD5STEP(F3, c, d, a, b, in[15] + 0x1fa27cf8, 16);
MD5STEP(F3, b, c, d, a, in[2] + 0xc4ac5665, 23);
MD5STEP(F4, a, b, c, d, in[0] + 0xf4292244, 6);
MD5STEP(F4, d, a, b, c, in[7] + 0x432aff97, 10);
MD5STEP(F4, c, d, a, b, in[14] + 0xab9423a7, 15);
MD5STEP(F4, b, c, d, a, in[5] + 0xfc93a039, 21);
MD5STEP(F4, a, b, c, d, in[12] + 0x655b59c3, 6);
MD5STEP(F4, d, a, b, c, in[3] + 0x8f0ccc92, 10);
MD5STEP(F4, c, d, a, b, in[10] + 0xffeff47d, 15);
MD5STEP(F4, b, c, d, a, in[1] + 0x85845dd1, 21);
MD5STEP(F4, a, b, c, d, in[8] + 0x6fa87e4f, 6);
MD5STEP(F4, d, a, b, c, in[15] + 0xfe2ce6e0, 10);
MD5STEP(F4, c, d, a, b, in[6] + 0xa3014314, 15);
MD5STEP(F4, b, c, d, a, in[13] + 0x4e0811a1, 21);
MD5STEP(F4, a, b, c, d, in[4] + 0xf7537e82, 6);
MD5STEP(F4, d, a, b, c, in[11] + 0xbd3af235, 10);
MD5STEP(F4, c, d, a, b, in[2] + 0x2ad7d2bb, 15);
MD5STEP(F4, b, c, d, a, in[9] + 0xeb86d391, 21);
buf[0] += a;
buf[1] += b;
buf[2] += c;
buf[3] += d;
}
#endif

46
archive-sources/vinfo/md5.h
View File

@ -1,46 +0,0 @@
/*
* This is the header file for the MD5 message-digest algorithm.
* The algorithm is due to Ron Rivest. This code was
* written by Colin Plumb in 1993, no copyright is claimed.
* This code is in the public domain; do with it what you wish.
*
* Equivalent code is available from RSA Data Security, Inc.
* This code has been tested against that, and is equivalent,
* except that you don't need to include two pages of legalese
* with every copy.
*
* To compute the message digest of a chunk of bytes, declare an
* MD5Context structure, pass it to MD5Init, call MD5Update as
* needed on buffers full of bytes, and then call MD5Final, which
* will fill a supplied 16-byte array with the digest.
*
* Changed so as no longer to depend on Colin Plumb's `usual.h'
* header definitions; now uses stuff from dpkg's config.h
* - Ian Jackson <ijackson@nyx.cs.du.edu>.
* Still in the public domain.
*/
#ifndef MD5_H
#define MD5_H
#if (defined AIX ||defined HPUX || defined SUN || defined NMP)
#define HAS_BIGENDIAN_WORDS 1
#else
#undef HAS_BIGENDIAN_WORDS
#endif
typedef unsigned char md5byte;
typedef unsigned int UWORD32;
struct MD5Context {
UWORD32 buf[4];
UWORD32 bytes[2];
UWORD32 in[16];
};
void MD5Init(struct MD5Context *context);
void MD5Update(struct MD5Context *context, md5byte const *buf, unsigned len);
void MD5Final(unsigned char digest[16], struct MD5Context *context);
void MD5Transform(UWORD32 buf[4], UWORD32 const in[16]);
#endif /* !MD5_H */

387
archive-sources/vinfo/vinfo.c
View File

@ -1,387 +0,0 @@
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "vinfo.h"
#include "md5.h"
static struct md5emu md5emu_versions[] =
{
{"21cfa58e94ea12e93cb344361cfca0d3","2011/02/21"}, // cs2gbox
{"60290d667a8fceb8e61ed568416fa7e5","v2.1B"}, // NI cs2gbox [Mar 04 2011]
{"627bf42e18d100418b8eb26aeb208f05","v2.1C"}, // NI cs2gbox [Aug 14 2011]
{"3ade7732b3259b372b9c61c6260730aa","v2.2A"}, // NI cs2gbox [Aug 16 2011]
{"ae7adbf886156b5e699a9b71cb8c3fed","v2.1C 2012"}, // NI cs2gbox [2012]
};
static struct mgcamd mgcamd_versions[] =
{
{"2282041518e3cf58d706e127adfa97b0","1.35a 2010/01/26"},
{"4a0f1ef99d09f8e386ff2b03f8dc5a24","1.35a 2010/07/30"},
{"291a3f7a9ba3f7cc0afe79b058650464","1.35a Austria-SAT"},
{"cd60d00cd76d66214c0b57d3181447b7","1.35a 2014/02/03"}, //by mixvt (compiled Feb 3 2014 19:20:06)
{"0d7206cc96c050fd7d4fa4a777c44503","1.35c Austria-/Canalsat"},
};
s_string searchstring[] = {
{ "compiled %s %s)", 17 }, // mgcamd
{ "Butter-team", 15 }, // newcs
{ "started version", 16 }, // oscam version old
{ "cardserver %s, version", 23 }, // oscam version new
{ "svn, build #", 12 }, // oscam build
{ "svn, build r", 12 }, // oscam build new
{ "EMU: ", 5 }, // doscam
{ "svn", 31 }, // gbox svn
//{ "gbox_cfg, trace", -27 }, // gbox git - old function
{ "Linux@ARM", 55 }, // gbox git
};
void Usage()
{
printf("%s\n", VERSION);
printf("Usage: vinfo <CAM-Code> <Path to emu>\n");
printf("\tInfo: get emu-information offline\n");
printf("\tSupportboard: %s\n", SUPPORT);
printf("\tCopyright: %s\n\n", COPYRIGHT);
printf("<CAM-Code> (Supported Binarys):\n");
printf(" NEWCS\n");
printf(" MGCAMD\n");
printf(" GBOX.NET\n");
printf(" OSEMU\n");
printf(" OSCAM\n");
printf(" NCAM\n");
printf(" DOSCAM\n");
printf(" CS2GBOX\n");
}
static char *trim(char *txt)
{
register int l;
register char *p1, *p2;
if (*txt==' ')
{
for (p1=p2=txt;
(*p1==' ') || (*p1=='\t') || (*p1=='\n') || (*p1=='\r');
p1++){};
while (*p1)
*p2++=*p1++;
*p2='\0';
}
if ((l=strlen(txt))>0)
for (p1=txt+l-1;
(*p1==' ') || (*p1=='\t') || (*p1=='\n') || (*p1=='\r');
*p1--='\0'){};
return(txt);
}
FILE *OpenBinFile(char *file)
{
FILE *fh;
if (!(fh=fopen(file, "rb")))
{
perror("Can`t open file");
exit(EXIT_FAILURE);
}
return(fh);
}
long Search(FILE *fh, s_string *string, int emu)
{
long found_pos; // Rückgabewert
char buffer[1024]; // Gröe des Lesebuffers
char * p; // temp. Zeiger für buffer erstellen
int slen = strlen(string[emu].str); // Länge der Zeichenkette für Überlappung ermitteln
//printf("string: %i (%s)\n", slen, string[emu].str);
int idx;
int found = 0;
long sp = 0; // fr berlappung
//printf("--> String: %s\n", string[emu].str);
int szread;
while ((szread = fread(buffer, 1, sizeof(buffer), fh)))
{
p = buffer;
for ( idx = 0; idx < szread; idx++ )
{
switch (emu)
{
/*
case CAMD3:
if (p[0] == '\0' && p[1] == string[emu].str[0] && p[2] == string[emu].str[1])
{
found_pos = ftell(fh)-szread+idx;
return(found_pos);
}
break;
*/ default:
if ( *p == string[emu].str[0] )
{
found = ( strstr( p, string[emu].str ) == p );
if (found)
{
found_pos = ftell(fh)-szread+idx;
return(found_pos);
}
}
}
p++;
}
sp += ( sizeof(buffer) - slen );
fseek( fh, sp, SEEK_SET );
szread = fread(buffer,1,sizeof(buffer), fh );
}
return(0);
}
void Emu (char *file, s_string *search, int emu)
{
FILE *fh;
fh = OpenBinFile(file);
strcpy(version,"keine Informationen gefunden");
long pos = Search(fh, searchstring, emu);
//printf("pos: %ld\n", pos);
if (pos == 0)
fclose(fh);
else
{
fseek(fh, pos+searchstring[emu].offset, SEEK_SET);
fscanf(fh, COMPILE_STRING, version);
fclose(fh);
}
}
int mdfile(FILE *fp, unsigned char *digest)
{
unsigned char buf[1024];
struct MD5Context ctx;
int n;
MD5Init(&ctx);
while ((n = fread(buf, 1, sizeof(buf), fp)) > 0)
MD5Update(&ctx, buf, n);
MD5Final(digest, &ctx);
if (ferror(fp))
return -1;
return 0;
}
int ret_md5_sum(int emu)
{
switch (emu)
{
case MD5EMU:
return sizeof(md5emu_versions) / sizeof(*md5emu_versions);
case MGCAMD:
return sizeof(mgcamd_versions) / sizeof(*mgcamd_versions);
default:
return 0;
}
}
char *DetectMD5Version(unsigned char *p, int emu)
{
int count;
char md5string[40]="";
char tmp[6];
for (count=0; count<16; count++)
{
sprintf((char*) &tmp, "%02x", p[count] );
strcat(md5string, tmp);
}
int anz = ret_md5_sum(emu);
for(count=0; count<anz; count++)
{
switch (emu)
{
case MD5EMU:
if (strcmp(md5emu_versions[count].md5, md5string)==0)
return md5emu_versions[count].v_name;
case MGCAMD:
if (strcmp(mgcamd_versions[count].md5, md5string)==0)
return mgcamd_versions[count].v_name;
}
}
return "Version unbekannt";
}
int File_check(const char * str)
{
FILE * Existance;
if ( ( Existance = fopen(str, "r+") ) == 0)
return(false);
else
fclose(Existance);
return(true);
}
void GBoxHandling(char *file, s_string *search)
{
FILE *fh;
if (File_check("/tmp/gbox.ver"))
{
fh=fopen("/tmp/gbox.ver", "r");
fscanf(fh, "%40s", version);
fclose(fh);
printf("%s ",version);
}
Emu(file, search, GBOX);
if (strstr(version, "keine Informationen gefunden")) {
Emu(file, search, GBOX_GIT);
printf("GIT #");
}
else {
printf("SVN #");
}
}
void MgcamdHandling(char *file, s_string *search)
{
FILE *fh;
fh = OpenBinFile(file);
unsigned char digest[16];
mdfile(fh, digest);
strcpy(version, DetectMD5Version(digest, MGCAMD));
fclose(fh);
if (strstr(version, "Version unbekannt"))
Emu(file, search, MGCAMD);
}
int OscamHandling(char *file)
{
FILE *pipe_reader;
char *ptr;
char *buffer;
char str[128] = "";
ssize_t read;
size_t len;
int ret = 0;
snprintf(str, sizeof(str), "%s -V", file);
buffer=NULL;
if (!(pipe_reader = popen (str, "r")))
printf("[OscamHandling] popen error\n");
strcpy(str,"");
while ((read = getline(&buffer, &len, pipe_reader)) != -1)
{
if ((ptr = strstr(buffer, "Version:"))) {
printf("%s\n",trim(ptr+8));
ret=1;
}
}
pclose(pipe_reader);
if(buffer)
free(buffer);
if(ret != 1)
printf("%s\n", version);
return(ret);
}
void md5emuHandling(char *file, s_string *search)
{
FILE *fh;
fh = OpenBinFile(file);
unsigned char digest[16];
mdfile(fh, digest);
strcpy(version, DetectMD5Version(digest, MD5EMU));
fclose(fh);
}
int main(int argc, char **argv)
{
switch (argc)
{
case 3:
if (strstr(argv[1], "MGCAMD"))
MgcamdHandling(argv[2], searchstring);
else if (strstr(argv[1], "NEWCS"))
Emu(argv[2], searchstring, NEWCS);
else if (strstr(argv[1], "OSEMU"))
strcpy(version, "n/a");
else if (strstr(argv[1], "OSCAM"))
Emu(argv[2], searchstring, OSCAM_VERSION);
else if (strstr(argv[1], "NCAM"))
Emu(argv[2], searchstring, OSCAM_VERSION_NEW);
else if (strstr(argv[1], "CS2GBOX"))
md5emuHandling(argv[2], searchstring);
else if (strstr(argv[1], "GBOX.NET"))
GBoxHandling(argv[2], searchstring);
else
Usage();
break;
default:
Usage();
exit(1);
}
#if 0
if (strstr(version, "keine Informationen gefunden"))
{
if (strstr(argv[1], "NEWCAMD"))
Emu(argv[2], searchstring, NEWCAMD_OLD);
else if (strstr(argv[1], "CCCAM"))
Emu(argv[2], searchstring, CCCAM_OLD);
else if (strstr(argv[1], "RDGD"))
Emu(argv[2], searchstring, RDGD_NEW);
else if (strstr(argv[1], "NEWCS"))
Emu(argv[2], searchstring, NEWCS_07);
else if (strstr(argv[1], "EVOCAMD"))
{
Emu(argv[2], searchstring, EVOCAMD_NEW);
sscanf(version, "%[^ ]", version);
}
else if (strstr(argv[1], "SCAM"))
ScamHandling(argv[2]);
}
if (strstr(version, "Compiled on"))
Emu(argv[2], searchstring, NEWCS_NEW);
#endif
if (strstr(argv[1], "OSCAM"))
{
int doscam = 0;
if (strstr(version, "keine Informationen gefunden"))
Emu(argv[2], searchstring, OSCAM_VERSION_NEW);
if (!strstr(version, "keine Informationen gefunden"))
printf("%s", version);
Emu(argv[2], searchstring, DOSCAM);
if(strstr(version, "Key"))
doscam = 1;
Emu(argv[2], searchstring, OSCAM_BUILD);
if(strstr(version, "keine Informationen gefunden"))
Emu(argv[2], searchstring, OSCAM_BUILD_NEW);
if (!strstr(version, "keine Informationen gefunden"))
printf(" SVN #%s %s\n", version, (doscam?"(DOSCam)":""));
else
OscamHandling(argv[2]);
}
else
{
printf("%s\n", version);
}
exit(EXIT_SUCCESS);
}

47
archive-sources/vinfo/vinfo.h
View File

@ -1,47 +0,0 @@
#ifndef VINFO_H_
#define VINFO_H_
#define VERSION "vinfo Version 3.27"
#define SUPPORT "www.neutrino-images.de"
#define COPYRIGHT "luke777, FlatTV"
enum {false, true};
enum {MGCAMD, NEWCS, OSCAM_VERSION, OSCAM_VERSION_NEW, OSCAM_BUILD, OSCAM_BUILD_NEW, DOSCAM, GBOX, GBOX_GIT, MD5EMU };
typedef struct _s_string {
char *str;
int offset;
} s_string;
struct md5emu
{
char md5[35];
char v_name[20];
};
struct mgcamd
{
char md5[35];
char v_name[25];
};
char version[40] = "keine Informationen gefunden";
const char COMPILE_STRING[] = "%[0-9.a-zA-Z ]";
const char COMPILE_STRING_NOSPACE[] = "%[0-9.a-zA-Z]";
// Funktionsdeklarationen =====================================================
void Usage();
FILE *OpenBinFile(char *file);
long Search(FILE *fh, s_string *string, int emu);
void Emu (char *file, s_string *search, int emu);
void GBoxHandling(char *file, s_string *search);
void MgcamdHandling(char *file, s_string *search);
int OscamHandling(char *file);
void md5emuHandling(char *file, s_string *search);
// MD5 Funktionsdeklaration
int mdfile(FILE *fp, unsigned char *digest);
int ret_md5_sum(int emu);
char *DetectMD5Version(unsigned char *p, int emu);
#endif /*VINFO_H_*/

4
make/plugins.mk
View File

@ -170,9 +170,9 @@ FritzInfoMonitor_setup: $(SOURCE_DIR)/$(NI_NEUTRINO-PLUGINS) $(LIBPLUGINS)
install -m644 $(SOURCE_DIR)/$(NI_NEUTRINO-PLUGINS)/FritzInfoMonitor/FritzInfoMonitor_setup.cfg $(LIBPLUGINS)/
install -m644 $(SOURCE_DIR)/$(NI_NEUTRINO-PLUGINS)/FritzInfoMonitor/FritzInfoMonitor_setup_hint.png $(LIBPLUGINS)/
vinfo: $(BIN)/vinfo
vinfo: $(SOURCE_DIR)/$(NI_NEUTRINO-PLUGINS) $(BIN)/vinfo
$(BIN)/vinfo: $(BIN)
pushd $(SOURCES)/vinfo && \
pushd $(SOURCE_DIR)/$(NI_NEUTRINO-PLUGINS)/vinfo && \
$(TARGET)-gcc $(TARGET_CFLAGS) -o $@ vinfo.c md5.c
EPGscan: $(LIBPLUGINS) $(VARCONFIG)

Write Preview
Loading…
Cancel
Save