void fixed_jump(tinymt32_t * tiny, const char * poly_str,
uint64_t lower_step,
uint64_t upper_step,
uint32_t seed)
{
tinymt32_t new_tiny_z;
tinymt32_t * new_tiny = &new_tiny_z;
char jump_str[100];
polynomial charcteristic;
polynomial jump_poly;
polynomial tee;
strtop(&charcteristic, poly_str);
tee.ar[0] = 2;
tee.ar[1] = 0;
polynomial_power_mod(&jump_poly,
&tee,
lower_step,
upper_step,
&charcteristic);
memset(jump_str, 0, sizeof(jump_str));
ptostr(jump_str, &jump_poly);
printf("lower_step: %"PRIu64" upper_step:%"PRIu64"\n",
lower_step, upper_step);
printf("jump_poly:%s\n", jump_str);
printf("check data:\n");
printf("seed = %u\n", seed);
tinymt32_init(tiny, seed);
*new_tiny = *tiny;
printf("before:\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
printf("%10"PRIu32" ", tinymt32_generate_uint32(tiny));
}
printf("\n");
}
/* period jump */
tinymt32_jump(new_tiny,
lower_step,
upper_step,
poly_str);
printf("after:\n");
for (int i = 0; i < 3; i++) {
for (int j = 0; j < 5; j++) {
printf("%10"PRIu32" ", tinymt32_generate_uint32(new_tiny));
}
printf("\n");
}
}
void
uprog(const poly_t gpoly, int flags, unsigned long seq) {
/* Callback function to report search progress */
char *string;
/* Suppress first report in CLI */
if(!seq)
return;
string = ptostr(gpoly, P_RTJUST, 4);
fprintf(stderr, "%s: searching: width=%ld poly=0x%s refin=%s refout=%s\n",
myname, plen(gpoly), string,
(flags & P_REFIN ? "true" : "false"),
(flags & P_REFOUT ? "true" : "false")
);
free(string);
}
int
main(int argc, char *argv[]) {
/* Command-line interface for CRC RevEng.
* Process options and switches in the argument list and
* run the required function.
*/
/* default values */
model_t model = {
PZERO, /* no CRC polynomial, user must specify */
PZERO, /* Init = 0 */
P_BE, /* RefIn = false, RefOut = false, plus P_RTJUST setting in reveng.h */
PZERO, /* XorOut = 0 */
PZERO, /* check value unused */
NULL /* no model name */
};
int ibperhx = 8, obperhx = 8;
int rflags = 0, uflags = 0; /* search and UI flags */
unsigned long width = 0UL;
int c, mode = 0, args, psets, pass;
poly_t apoly, crc, qpoly = PZERO, *apolys, *pptr = NULL, *qptr = NULL;
model_t pset = model, *candmods, *mptr;
char *string;
myname = argv[0];
/* stdin must be binary */
#ifdef _WIN32
_setmode(STDIN_FILENO, _O_BINARY);
#endif /* _WIN32 */
SETBMP();
do {
c=getopt(argc, argv, "?A:BDFLMP:SVXa:bcdefhi:k:lm:p:q:rstuvw:x:y");
switch(c) {
case 'A': /* A: bits per output character */
case 'a': /* a: bits per character */
if((obperhx = atoi(optarg)) > BMP_BIT) {
fprintf(stderr,"%s: argument to -%c must be between 1 and %d\n", myname, c, BMP_BIT);
exit(EXIT_FAILURE);
}
if(c == 'a') ibperhx = obperhx;
break;
case 'b': /* b big-endian (RefIn = false, RefOut = false ) */
model.flags &= ~P_REFIN;
rflags |= R_HAVERI;
/* fall through: */
case 'B': /* B big-endian output (RefOut = false) */
model.flags &= ~P_REFOUT;
rflags |= R_HAVERO;
mnovel(&model);
/* fall through: */
case 'r': /* r right-justified */
model.flags |= P_RTJUST;
break;
case 'c': /* c calculate CRC */
case 'D': /* D list primary model names */
case 'd': /* d dump CRC model */
case 'e': /* e echo arguments */
case 's': /* s search for algorithm */
case 'v': /* v calculate reversed CRC */
if(mode) {
fprintf(stderr,"%s: more than one mode switch specified. Use %s -h for help.\n", myname, myname);
exit(EXIT_FAILURE);
}
mode = c;
break;
case 'F': /* F force search */
#ifndef NOFORCE
uflags |= C_FORCE;
#endif
break;
case 'f': /* f arguments are filenames */
uflags |= C_INFILE;
break;
case 'h': /* h get help / usage */
case 'u': /* u get help / usage */
case '?': /* ? get help / usage */
default:
usage();
exit(EXIT_FAILURE);
break;
case 'i': /* i: Init value */
pptr = &model.init;
rflags |= R_HAVEI;
goto ippx;
case 'k': /* k: polynomial in Koopman notation */
pfree(&model.spoly);
model.spoly = strtop(optarg, 0, 4);
pkchop(&model.spoly);
width = plen(model.spoly);
rflags |= R_HAVEP;
mnovel(&model);
break;
case 'l': /* l little-endian input and output */
model.flags |= P_REFIN;
rflags |= R_HAVERI;
/* fall through: */
case 'L': /* L little-endian output */
model.flags |= P_REFOUT;
rflags |= R_HAVERO;
mnovel(&model);
/* fall through: */
case 't': /* t left-justified */
model.flags &= ~P_RTJUST;
break;
case 'm': /* m: select preset CRC model */
if(!(c = mbynam(&model, optarg))) {
fprintf(stderr,"%s: preset model '%s' not found. Use %s -D to list presets.\n", myname, optarg, myname);
exit(EXIT_FAILURE);
}
if(c < 0)
uerror("no preset models available");
/* must set width so that parameter to -ipx is not zeroed */
width = plen(model.spoly);
rflags |= R_HAVEP | R_HAVEI | R_HAVERI | R_HAVERO | R_HAVEX;
break;
case 'M': /* M non-augmenting algorithm */
model.flags &= ~P_MULXN;
break;
case 'P': /* P: reversed polynomial */
case 'p': /* p: polynomial */
pptr = &model.spoly;
rflags &= ~R_HAVEQ;
rflags |= R_HAVEP;
ippx:
pfree(pptr);
*pptr = strtop(optarg, 0, 4);
pright(pptr, width);
if(c == 'P')
prev(pptr);
mnovel(&model);
break;
case 'q': /* q: range end polynomial */
pptr = &qpoly;
rflags &= ~R_HAVEP;
rflags |= R_HAVEQ;
goto ippx;
case 'S': /* s space between output characters */
model.flags |= P_SPACE;
break;
case 'V': /* v reverse algorithm */
/* Distinct from the -v switch as the
* user will have to reverse his or her
* own arguments. The user cannot dump
* the model generated by -v either.
*/
mrev(&model);
break;
case 'w': /* w: CRC width = order - 1 */
width = (unsigned long) atol(optarg);
break;
case 'X': /* X print uppercase hex */
model.flags |= P_UPPER;
break;
case 'x': /* x: XorOut value */
pptr = &model.xorout;
rflags |= R_HAVEX;
goto ippx;
case 'y': /* y little-endian byte order in files */
model.flags |= P_LTLBYT;
break;
case -1: /* no more options, continue */
;
}
} while(c != -1);
/* canonicalise the model, so the one we dump is the one we
* calculate with (not with -s, spoly may be blank which will
* normalise to zero and clear init and xorout.)
*/
if(mode != 's')
mcanon(&model);
switch(mode) {
case 'v': /* v calculate reversed CRC */
/* Distinct from the -V switch as this causes
* the arguments and output to be reversed as well.
*/
/* reciprocate Poly */
prcp(&model.spoly);
/* mrev() does:
* if(refout) prev(init); else prev(xorout);
* but here the entire argument polynomial is
* reflected, not just the characters, so RefIn
* and RefOut are not inverted as with -V.
* Consequently Init is the mirror image of the
* one resulting from -V, and so we have:
*/
if(~model.flags & P_REFOUT) {
prev(&model.init);
prev(&model.xorout);
}
/* swap init and xorout */
apoly = model.init;
model.init = model.xorout;
model.xorout = apoly;
/* fall through: */
case 'c': /* c calculate CRC */
/* validate inputs */
/* if(plen(model.spoly) == 0) {
* fprintf(stderr,"%s: no polynomial specified for -%c (add -w WIDTH -p POLY)\n", myname, mode);
* exit(EXIT_FAILURE);
* }
*/
/* in the Williams model, xorout is applied after the refout stage.
* as refout is part of ptostr(), we reverse xorout here.
*/
if(model.flags & P_REFOUT)
prev(&model.xorout);
for(; optind < argc; ++optind) {
if(uflags & C_INFILE)
apoly = rdpoly(argv[optind], model.flags, ibperhx);
else
apoly = strtop(argv[optind], model.flags, ibperhx);
if(mode == 'v')
prev(&apoly);
crc = pcrc(apoly, model.spoly, model.init, model.xorout, model.flags);
if(mode == 'v')
prev(&crc);
string = ptostr(crc, model.flags, obperhx);
puts(string);
free(string);
pfree(&crc);
pfree(&apoly);
}
break;
case 'D': /* D dump all models */
args = mcount();
if(!args)
uerror("no preset models available");
for(mode = 0; mode < args; ++mode) {
mbynum(&model, mode);
mcanon(&model);
ufound(&model);
}
break;
case 'd': /* d dump CRC model */
/* maybe we don't want to do this:
* either attaching names to arbitrary models or forcing to a preset
* mmatch(&model, M_OVERWR);
*/
if(~model.flags & P_MULXN)
uerror("not a Williams model compliant algorithm");
string = mtostr(&model);
puts(string);
free(string);
break;
case 'e': /* e echo arguments */
for(; optind < argc; ++optind) {
if(uflags & C_INFILE)
apoly = rdpoly(argv[optind], model.flags, ibperhx);
else
apoly = strtop(argv[optind], model.flags, ibperhx);
psum(&apoly, model.init, 0UL);
string = ptostr(apoly, model.flags, obperhx);
puts(string);
free(string);
pfree(&apoly);
}
break;
case 's': /* s search for algorithm */
if(!width)
uerror("must specify positive -k or -w before -s");
if(~model.flags & P_MULXN)
uerror("cannot search for non-Williams compliant models");
praloc(&model.spoly, width);
praloc(&model.init, width);
praloc(&model.xorout, width);
if(!plen(model.spoly))
palloc(&model.spoly, width);
else
width = plen(model.spoly);
/* special case if qpoly is zero, search to end of range */
if(!ptst(qpoly))
rflags &= ~R_HAVEQ;
/* allocate argument array */
args = argc - optind;
if(!(apolys = malloc(args * sizeof(poly_t))))
uerror("cannot allocate memory for argument list");
for(pptr = apolys; optind < argc; ++optind) {
if(uflags & C_INFILE)
*pptr++ = rdpoly(argv[optind], model.flags, ibperhx);
else
*pptr++ = strtop(argv[optind], model.flags, ibperhx);
}
/* exit value of pptr is used hereafter! */
/* if endianness not specified, try
* little-endian then big-endian.
* NB: crossed-endian algorithms will not be
* searched.
*/
/* scan against preset models */
if(~uflags & C_FORCE) {
pass = 0;
do {
psets = mcount();
while(psets) {
mbynum(&pset, --psets);
/* skip if different width, or refin or refout don't match */
if(plen(pset.spoly) != width || (model.flags ^ pset.flags) & (P_REFIN | P_REFOUT))
continue;
/* skip if the preset doesn't match specified parameters */
if(rflags & R_HAVEP && pcmp(&model.spoly, &pset.spoly))
continue;
if(rflags & R_HAVEI && psncmp(&model.init, &pset.init))
continue;
if(rflags & R_HAVEX && psncmp(&model.xorout, &pset.xorout))
continue;
apoly = pclone(pset.xorout);
if(pset.flags & P_REFOUT)
prev(&apoly);
for(qptr = apolys; qptr < pptr; ++qptr) {
crc = pcrc(*qptr, pset.spoly, pset.init, apoly, 0);
if(ptst(crc)) {
pfree(&crc);
break;
} else
pfree(&crc);
}
pfree(&apoly);
if(qptr == pptr) {
/* the selected model solved all arguments */
mcanon(&pset);
ufound(&pset);
uflags |= C_RESULT;
}
}
mfree(&pset);
/* toggle refIn/refOut and reflect arguments */
if(~rflags & R_HAVERI) {
model.flags ^= P_REFIN | P_REFOUT;
for(qptr = apolys; qptr < pptr; ++qptr)
prevch(qptr, ibperhx);
}
} while(~rflags & R_HAVERI && ++pass < 2);
}
if(uflags & C_RESULT) {
for(qptr = apolys; qptr < pptr; ++qptr)
pfree(qptr);
exit(EXIT_SUCCESS);
}
if(!(model.flags & P_REFIN) != !(model.flags & P_REFOUT))
uerror("cannot search for crossed-endian models");
pass = 0;
do {
mptr = candmods = reveng(&model, qpoly, rflags, args, apolys);
if(mptr && plen(mptr->spoly))
uflags |= C_RESULT;
while(mptr && plen(mptr->spoly)) {
/* results were printed by the callback
* string = mtostr(mptr);
* puts(string);
* free(string);
*/
mfree(mptr++);
}
free(candmods);
if(~rflags & R_HAVERI) {
model.flags ^= P_REFIN | P_REFOUT;
for(qptr = apolys; qptr < pptr; ++qptr)
prevch(qptr, ibperhx);
}
} while(~rflags & R_HAVERI && ++pass < 2);
for(qptr = apolys; qptr < pptr; ++qptr)
pfree(qptr);
free(apolys);
if(~uflags & C_RESULT)
uerror("no models found");
break;
default: /* no mode specified */
fprintf(stderr, "%s: no mode switch specified. Use %s -h for help.\n", myname, myname);
exit(EXIT_FAILURE);
}
exit(EXIT_SUCCESS);
}
