a71ece51 |
1 | /* cli.c |
2c9e3090 |
2 | * Greg Cook, 27/Jun/2016 |
a71ece51 |
3 | */ |
4 | |
2c9e3090 |
5 | /* CRC RevEng: arbitrary-precision CRC calculator and algorithm finder |
a78a3d9d |
6 | * Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook |
a71ece51 |
7 | * |
8 | * This file is part of CRC RevEng. |
9 | * |
10 | * CRC RevEng is free software: you can redistribute it and/or modify |
11 | * it under the terms of the GNU General Public License as published by |
12 | * the Free Software Foundation, either version 3 of the License, or |
13 | * (at your option) any later version. |
14 | * |
15 | * CRC RevEng is distributed in the hope that it will be useful, |
16 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
17 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
18 | * GNU General Public License for more details. |
19 | * |
20 | * You should have received a copy of the GNU General Public License |
2c9e3090 |
21 | * along with CRC RevEng. If not, see <https://www.gnu.org/licenses/>. |
a71ece51 |
22 | */ |
23 | |
2c9e3090 |
24 | /* 2016-06-27: -P sets width like -k |
25 | * 2015-04-03: added -z |
a71ece51 |
26 | * 2013-09-16: do not search with -M |
27 | * 2013-06-11: uprog() suppresses first progress report |
28 | * 2013-04-22: uprog() prints poly same as mtostr() |
29 | * 2013-02-07: added -q, uprog(), removed -W, R_ODDLY |
30 | * 2012-05-24: -D dumps parameters of all models |
31 | * 2012-03-03: added code to test sort order of model table |
32 | * 2012-02-20: set stdin to binary (MinGW). offer -D if preset unknown. |
33 | * 2011-09-06: -s reads arguments once. stdin not closed. |
34 | * 2011-09-06: fixed bad argument-freeing loops. |
35 | * 2011-08-27: validates BMP_C() |
36 | * 2011-08-26: validates BMPBIT and BMPSUB |
37 | * 2011-08-25: fixed Init/Xorout reflection logic in -V and -v |
38 | * 2011-01-17: fixed ANSI C warnings |
39 | * 2011-01-15: added NOFORCE |
40 | * 2011-01-14: added -k, -P |
41 | * 2011-01-10: reorganised switches, added -V, -X |
42 | * 2010-12-26: renamed CRC RevEng |
43 | * 2010-12-18: implemented -c, -C |
44 | * 2010-12-14: added and implemented -d, -D, fixed -ipx entry |
45 | * 2010-12-11: implemented -e. first tests |
46 | * 2010-12-10: finalised option processing. started input validation |
47 | * 2010-12-07: started cli |
48 | */ |
49 | |
50 | #include <stdio.h> |
51 | #include <stdlib.h> |
52 | #include "getopt.h" |
53 | #ifdef _WIN32 |
54 | # include <io.h> |
55 | # include <fcntl.h> |
56 | # ifndef STDIN_FILENO |
57 | # define STDIN_FILENO 0 |
58 | # endif /* STDIN_FILENO */ |
59 | #endif /* _WIN32 */ |
60 | |
61 | #include "reveng.h" |
62 | |
63 | static FILE *oread(const char *); |
64 | static poly_t rdpoly(const char *, int, int); |
65 | static void usage(void); |
66 | |
67 | static const char *myname = "reveng"; /* name of our program */ |
68 | |
69 | int reveng_main(int argc, char *argv[]) { |
70 | /* Command-line interface for CRC RevEng. |
71 | * Process options and switches in the argument list and |
72 | * run the required function. |
73 | */ |
74 | |
75 | /* default values */ |
76 | model_t model = { |
77 | PZERO, /* no CRC polynomial, user must specify */ |
78 | PZERO, /* Init = 0 */ |
79 | P_BE, /* RefIn = false, RefOut = false, plus P_RTJUST setting in reveng.h */ |
80 | PZERO, /* XorOut = 0 */ |
81 | PZERO, /* check value unused */ |
82 | NULL /* no model name */ |
83 | }; |
84 | int ibperhx = 8, obperhx = 8; |
85 | int rflags = 0, uflags = 0; /* search and UI flags */ |
86 | |
87 | unsigned long width = 0UL; |
88 | int c, mode = 0, args, psets, pass; |
89 | poly_t apoly, crc, qpoly = PZERO, *apolys, *pptr = NULL, *qptr = NULL; |
90 | model_t pset = model, *candmods, *mptr; |
91 | char *string; |
92 | |
93 | myname = argv[0]; |
94 | |
95 | /* stdin must be binary */ |
96 | #ifdef _WIN32 |
97 | _setmode(STDIN_FILENO, _O_BINARY); |
98 | #endif /* _WIN32 */ |
99 | |
100 | SETBMP(); |
101 | |
102 | pos=0; |
103 | optind=1; |
104 | do { |
105 | c=getopt(argc, argv, "?A:BDFLMP:SVXa:bcdefhi:k:lm:p:q:rstuvw:x:yz"); |
106 | switch(c) { |
107 | case 'A': /* A: bits per output character */ |
108 | case 'a': /* a: bits per character */ |
109 | if((obperhx = atoi(optarg)) > BMP_BIT) { |
110 | fprintf(stderr,"%s: argument to -%c must be between 1 and %d\n", myname, c, BMP_BIT); |
111 | return 0; |
112 | //exit(EXIT_FAILURE); |
113 | } |
114 | if(c == 'a') ibperhx = obperhx; |
115 | break; |
116 | case 'b': /* b big-endian (RefIn = false, RefOut = false ) */ |
117 | model.flags &= ~P_REFIN; |
118 | rflags |= R_HAVERI; |
119 | /* fall through: */ |
120 | case 'B': /* B big-endian output (RefOut = false) */ |
121 | model.flags &= ~P_REFOUT; |
122 | rflags |= R_HAVERO; |
123 | mnovel(&model); |
124 | /* fall through: */ |
125 | case 'r': /* r right-justified */ |
126 | model.flags |= P_RTJUST; |
127 | break; |
128 | case 'c': /* c calculate CRC */ |
129 | case 'D': /* D list primary model names */ |
130 | case 'd': /* d dump CRC model */ |
131 | case 'e': /* e echo arguments */ |
132 | case 's': /* s search for algorithm */ |
133 | case 'v': /* v calculate reversed CRC */ |
134 | if(mode) { |
135 | fprintf(stderr,"%s: more than one mode switch specified. Use %s -h for help.\n", myname, myname); |
136 | return 0; |
137 | //exit(EXIT_FAILURE); |
138 | } |
139 | mode = c; |
140 | break; |
141 | case 'F': /* F force search */ |
142 | #ifndef NOFORCE |
143 | uflags |= C_FORCE; |
144 | #endif |
145 | break; |
146 | case 'f': /* f arguments are filenames */ |
147 | uflags |= C_INFILE; |
148 | break; |
149 | case 'h': /* h get help / usage */ |
150 | case 'u': /* u get help / usage */ |
151 | case '?': /* ? get help / usage */ |
152 | default: |
153 | usage(); |
154 | return 0; |
155 | //exit(EXIT_FAILURE); |
156 | break; |
157 | case 'i': /* i: Init value */ |
158 | pptr = &model.init; |
159 | rflags |= R_HAVEI; |
2c9e3090 |
160 | goto ipqx; |
161 | case 'P': /* P: reversed polynomial */ |
a71ece51 |
162 | case 'k': /* k: polynomial in Koopman notation */ |
163 | pfree(&model.spoly); |
164 | model.spoly = strtop(optarg, 0, 4); |
165 | pkchop(&model.spoly); |
166 | width = plen(model.spoly); |
167 | rflags |= R_HAVEP; |
2c9e3090 |
168 | if(c == 'P') |
169 | prcp(&model.spoly); |
a71ece51 |
170 | mnovel(&model); |
171 | break; |
172 | case 'l': /* l little-endian input and output */ |
173 | model.flags |= P_REFIN; |
174 | rflags |= R_HAVERI; |
175 | /* fall through: */ |
176 | case 'L': /* L little-endian output */ |
177 | model.flags |= P_REFOUT; |
178 | rflags |= R_HAVERO; |
179 | mnovel(&model); |
180 | /* fall through: */ |
181 | case 't': /* t left-justified */ |
182 | model.flags &= ~P_RTJUST; |
183 | break; |
184 | case 'm': /* m: select preset CRC model */ |
185 | if(!(c = mbynam(&model, optarg))) { |
186 | fprintf(stderr,"%s: preset model '%s' not found. Use %s -D to list presets.\n", myname, optarg, myname); |
187 | return 0; |
188 | //exit(EXIT_FAILURE); |
189 | } |
60e86577 |
190 | if(c < 0){ |
a71ece51 |
191 | uerror("no preset models available"); |
60e86577 |
192 | return 0; |
193 | } |
a71ece51 |
194 | /* must set width so that parameter to -ipx is not zeroed */ |
195 | width = plen(model.spoly); |
196 | rflags |= R_HAVEP | R_HAVEI | R_HAVERI | R_HAVERO | R_HAVEX; |
197 | break; |
198 | case 'M': /* M non-augmenting algorithm */ |
199 | model.flags &= ~P_MULXN; |
200 | break; |
a71ece51 |
201 | case 'p': /* p: polynomial */ |
202 | pptr = &model.spoly; |
203 | rflags &= ~R_HAVEQ; |
204 | rflags |= R_HAVEP; |
2c9e3090 |
205 | ipqx: |
a71ece51 |
206 | pfree(pptr); |
207 | *pptr = strtop(optarg, 0, 4); |
208 | pright(pptr, width); |
a71ece51 |
209 | mnovel(&model); |
210 | break; |
211 | case 'q': /* q: range end polynomial */ |
212 | pptr = &qpoly; |
213 | rflags &= ~R_HAVEP; |
214 | rflags |= R_HAVEQ; |
2c9e3090 |
215 | goto ipqx; |
a71ece51 |
216 | case 'S': /* s space between output characters */ |
217 | model.flags |= P_SPACE; |
218 | break; |
219 | case 'V': /* v reverse algorithm */ |
220 | /* Distinct from the -v switch as the |
221 | * user will have to reverse his or her |
222 | * own arguments. The user cannot dump |
223 | * the model generated by -v either. |
224 | */ |
225 | mrev(&model); |
226 | break; |
227 | case 'w': /* w: CRC width = order - 1 */ |
2c9e3090 |
228 | /* no validation, WONTFIX */ |
a71ece51 |
229 | width = (unsigned long) atol(optarg); |
230 | break; |
231 | case 'X': /* X print uppercase hex */ |
232 | model.flags |= P_UPPER; |
233 | break; |
234 | case 'x': /* x: XorOut value */ |
235 | pptr = &model.xorout; |
236 | rflags |= R_HAVEX; |
2c9e3090 |
237 | goto ipqx; |
a71ece51 |
238 | case 'y': /* y little-endian byte order in files */ |
239 | model.flags |= P_LTLBYT; |
240 | break; |
241 | case 'z': /* z raw binary arguments */ |
242 | model.flags |= P_DIRECT; |
243 | break; |
244 | case -1: /* no more options, continue */ |
245 | ; |
246 | } |
247 | } while(c != -1); |
248 | |
249 | /* canonicalise the model, so the one we dump is the one we |
250 | * calculate with (not with -s, spoly may be blank which will |
251 | * normalise to zero and clear init and xorout.) |
252 | */ |
253 | if(mode != 's') |
254 | mcanon(&model); |
255 | |
256 | switch(mode) { |
257 | case 'v': /* v calculate reversed CRC */ |
258 | /* Distinct from the -V switch as this causes |
259 | * the arguments and output to be reversed as well. |
260 | */ |
261 | /* reciprocate Poly */ |
262 | prcp(&model.spoly); |
263 | |
264 | /* mrev() does: |
265 | * if(refout) prev(init); else prev(xorout); |
266 | * but here the entire argument polynomial is |
267 | * reflected, not just the characters, so RefIn |
268 | * and RefOut are not inverted as with -V. |
269 | * Consequently Init is the mirror image of the |
270 | * one resulting from -V, and so we have: |
271 | */ |
272 | if(~model.flags & P_REFOUT) { |
273 | prev(&model.init); |
274 | prev(&model.xorout); |
275 | } |
276 | |
277 | /* swap init and xorout */ |
278 | apoly = model.init; |
279 | model.init = model.xorout; |
280 | model.xorout = apoly; |
281 | |
282 | /* fall through: */ |
283 | case 'c': /* c calculate CRC */ |
284 | |
285 | /* validate inputs */ |
286 | /* if(plen(model.spoly) == 0) { |
287 | * fprintf(stderr,"%s: no polynomial specified for -%c (add -w WIDTH -p POLY)\n", myname, mode); |
288 | * exit(EXIT_FAILURE); |
289 | * } |
290 | */ |
291 | |
292 | /* in the Williams model, xorout is applied after the refout stage. |
293 | * as refout is part of ptostr(), we reverse xorout here. |
294 | */ |
295 | if(model.flags & P_REFOUT) |
296 | prev(&model.xorout); |
297 | |
298 | for(; optind < argc; ++optind) { |
299 | if(uflags & C_INFILE) |
300 | apoly = rdpoly(argv[optind], model.flags, ibperhx); |
301 | else |
302 | apoly = strtop(argv[optind], model.flags, ibperhx); |
303 | |
304 | if(mode == 'v') |
305 | prev(&apoly); |
306 | |
307 | crc = pcrc(apoly, model.spoly, model.init, model.xorout, model.flags); |
308 | |
309 | if(mode == 'v') |
310 | prev(&crc); |
311 | |
312 | string = ptostr(crc, model.flags, obperhx); |
313 | puts(string); |
314 | free(string); |
315 | pfree(&crc); |
316 | pfree(&apoly); |
317 | } |
318 | break; |
319 | case 'D': /* D dump all models */ |
320 | args = mcount(); |
60e86577 |
321 | if(!args){ |
a71ece51 |
322 | uerror("no preset models available"); |
60e86577 |
323 | return 0; |
324 | } |
a71ece51 |
325 | for(mode = 0; mode < args; ++mode) { |
326 | mbynum(&model, mode); |
327 | mcanon(&model); |
328 | ufound(&model); |
329 | } |
330 | break; |
331 | case 'd': /* d dump CRC model */ |
332 | /* maybe we don't want to do this: |
333 | * either attaching names to arbitrary models or forcing to a preset |
334 | * mmatch(&model, M_OVERWR); |
335 | */ |
60e86577 |
336 | if(~model.flags & P_MULXN){ |
a71ece51 |
337 | uerror("not a Williams model compliant algorithm"); |
60e86577 |
338 | return 0; |
339 | } |
a71ece51 |
340 | string = mtostr(&model); |
341 | puts(string); |
342 | free(string); |
343 | break; |
344 | case 'e': /* e echo arguments */ |
345 | for(; optind < argc; ++optind) { |
346 | if(uflags & C_INFILE) |
347 | apoly = rdpoly(argv[optind], model.flags, ibperhx); |
348 | else |
349 | apoly = strtop(argv[optind], model.flags, ibperhx); |
350 | |
351 | psum(&apoly, model.init, 0UL); |
352 | string = ptostr(apoly, model.flags, obperhx); |
353 | puts(string); |
354 | free(string); |
355 | pfree(&apoly); |
356 | } |
357 | break; |
358 | case 's': /* s search for algorithm */ |
60e86577 |
359 | if(!width){ |
a71ece51 |
360 | uerror("must specify positive -k or -w before -s"); |
60e86577 |
361 | return 0; |
362 | } |
363 | if(~model.flags & P_MULXN){ |
a71ece51 |
364 | uerror("cannot search for non-Williams compliant models"); |
60e86577 |
365 | return 0; |
366 | } |
a71ece51 |
367 | praloc(&model.spoly, width); |
368 | praloc(&model.init, width); |
369 | praloc(&model.xorout, width); |
370 | if(!plen(model.spoly)) |
371 | palloc(&model.spoly, width); |
372 | else |
373 | width = plen(model.spoly); |
374 | |
375 | /* special case if qpoly is zero, search to end of range */ |
376 | if(!ptst(qpoly)) |
377 | rflags &= ~R_HAVEQ; |
378 | |
379 | /* allocate argument array */ |
380 | args = argc - optind; |
60e86577 |
381 | if(!(apolys = malloc(args * sizeof(poly_t)))){ |
a71ece51 |
382 | uerror("cannot allocate memory for argument list"); |
60e86577 |
383 | return 0; |
384 | } |
a71ece51 |
385 | |
386 | for(pptr = apolys; optind < argc; ++optind) { |
387 | if(uflags & C_INFILE) |
388 | *pptr++ = rdpoly(argv[optind], model.flags, ibperhx); |
389 | else |
390 | *pptr++ = strtop(argv[optind], model.flags, ibperhx); |
391 | } |
392 | /* exit value of pptr is used hereafter! */ |
393 | |
394 | /* if endianness not specified, try |
395 | * little-endian then big-endian. |
396 | * NB: crossed-endian algorithms will not be |
397 | * searched. |
398 | */ |
399 | |
400 | /* scan against preset models */ |
401 | if(~uflags & C_FORCE) { |
402 | pass = 0; |
403 | do { |
404 | psets = mcount(); |
405 | while(psets) { |
406 | mbynum(&pset, --psets); |
407 | /* skip if different width, or refin or refout don't match */ |
408 | if(plen(pset.spoly) != width || (model.flags ^ pset.flags) & (P_REFIN | P_REFOUT)) |
409 | continue; |
410 | /* skip if the preset doesn't match specified parameters */ |
411 | if(rflags & R_HAVEP && pcmp(&model.spoly, &pset.spoly)) |
412 | continue; |
413 | if(rflags & R_HAVEI && psncmp(&model.init, &pset.init)) |
414 | continue; |
415 | if(rflags & R_HAVEX && psncmp(&model.xorout, &pset.xorout)) |
416 | continue; |
417 | apoly = pclone(pset.xorout); |
418 | if(pset.flags & P_REFOUT) |
419 | prev(&apoly); |
420 | for(qptr = apolys; qptr < pptr; ++qptr) { |
421 | crc = pcrc(*qptr, pset.spoly, pset.init, apoly, 0); |
422 | if(ptst(crc)) { |
423 | pfree(&crc); |
424 | break; |
425 | } else |
426 | pfree(&crc); |
427 | } |
428 | pfree(&apoly); |
429 | if(qptr == pptr) { |
430 | /* the selected model solved all arguments */ |
431 | mcanon(&pset); |
432 | ufound(&pset); |
433 | uflags |= C_RESULT; |
434 | } |
435 | } |
436 | mfree(&pset); |
437 | |
438 | /* toggle refIn/refOut and reflect arguments */ |
439 | if(~rflags & R_HAVERI) { |
440 | model.flags ^= P_REFIN | P_REFOUT; |
441 | for(qptr = apolys; qptr < pptr; ++qptr) |
442 | prevch(qptr, ibperhx); |
443 | } |
444 | } while(~rflags & R_HAVERI && ++pass < 2); |
445 | } |
446 | if(uflags & C_RESULT) { |
447 | for(qptr = apolys; qptr < pptr; ++qptr) |
448 | pfree(qptr); |
fe144f12 |
449 | return 1; |
a71ece51 |
450 | //exit(EXIT_SUCCESS); |
451 | } |
60e86577 |
452 | if(!(model.flags & P_REFIN) != !(model.flags & P_REFOUT)){ |
a71ece51 |
453 | uerror("cannot search for crossed-endian models"); |
60e86577 |
454 | return 0; |
455 | } |
a71ece51 |
456 | pass = 0; |
457 | do { |
458 | mptr = candmods = reveng(&model, qpoly, rflags, args, apolys); |
459 | if(mptr && plen(mptr->spoly)) |
460 | uflags |= C_RESULT; |
461 | while(mptr && plen(mptr->spoly)) { |
462 | /* results were printed by the callback |
463 | * string = mtostr(mptr); |
464 | * puts(string); |
465 | * free(string); |
466 | */ |
467 | mfree(mptr++); |
468 | } |
469 | free(candmods); |
470 | if(~rflags & R_HAVERI) { |
471 | model.flags ^= P_REFIN | P_REFOUT; |
472 | for(qptr = apolys; qptr < pptr; ++qptr) |
473 | prevch(qptr, ibperhx); |
474 | } |
475 | } while(~rflags & R_HAVERI && ++pass < 2); |
476 | for(qptr = apolys; qptr < pptr; ++qptr) |
477 | pfree(qptr); |
478 | free(apolys); |
479 | if(~uflags & C_RESULT) |
480 | uerror("no models found"); |
481 | break; |
482 | default: /* no mode specified */ |
483 | fprintf(stderr, "%s: no mode switch specified. Use %s -h for help.\n", myname, myname); |
a71ece51 |
484 | //exit(EXIT_FAILURE); |
485 | } |
486 | |
487 | return 1; |
488 | //exit(EXIT_SUCCESS); |
489 | } |
490 | |
491 | void |
492 | ufound(const model_t *model) { |
493 | /* Callback function to report each model found */ |
494 | char *string; |
495 | |
496 | if(!model) return; |
497 | /* generated models will be canonical */ |
498 | string = mtostr(model); |
499 | puts(string); |
500 | free(string); |
501 | } |
502 | |
503 | void |
504 | uerror(const char *msg) { |
505 | /* Callback function to report fatal errors */ |
506 | fprintf(stderr, "%s: %s\n", myname, msg); |
507 | return; |
508 | //exit(EXIT_FAILURE); |
509 | } |
510 | |
511 | void |
512 | uprog(const poly_t gpoly, int flags, unsigned long seq) { |
513 | /* Callback function to report search progress */ |
514 | char *string; |
515 | |
516 | /* Suppress first report in CLI */ |
517 | if(!seq) |
518 | return; |
519 | string = ptostr(gpoly, P_RTJUST, 4); |
520 | fprintf(stderr, "%s: searching: width=%ld poly=0x%s refin=%s refout=%s\n", |
521 | myname, plen(gpoly), string, |
522 | (flags & P_REFIN ? "true" : "false"), |
523 | (flags & P_REFOUT ? "true" : "false") |
524 | ); |
525 | free(string); |
526 | } |
527 | |
528 | static poly_t |
529 | rdpoly(const char *name, int flags, int bperhx) { |
530 | /* read poly from file in chunks and report errors */ |
531 | |
532 | poly_t apoly = PZERO, chunk = PZERO; |
533 | FILE *input; |
534 | |
535 | input = oread(name); |
536 | while(!feof(input) && !ferror(input)) { |
537 | chunk = filtop(input, BUFFER, flags, bperhx); |
538 | psum(&apoly, chunk, plen(apoly)); |
539 | pfree(&chunk); |
540 | } |
541 | if(ferror(input)) { |
542 | fprintf(stderr,"%s: error condition on file '%s'\n", myname, name); |
543 | exit(EXIT_FAILURE); |
544 | } |
545 | /* close file unless stdin */ |
546 | if(input == stdin) |
547 | /* reset EOF condition */ |
548 | clearerr(input); |
549 | else if(fclose(input)) { |
550 | fprintf(stderr,"%s: error closing file '%s'\n", myname, name); |
551 | exit(EXIT_FAILURE); |
552 | } |
553 | return(apoly); |
554 | } |
555 | |
556 | static FILE * |
557 | oread(const char *name) { |
558 | /* open file for reading and report errors */ |
559 | FILE *handle; |
560 | |
561 | /* recognise special name '-' as standard input */ |
562 | if(*name == '-' && name[1] == '\0') |
563 | return(stdin); |
564 | if(!(handle = fopen(name, "rb"))) { |
565 | fprintf(stderr, "%s: cannot open '%s' for reading\n", myname, name); |
566 | return 0; |
567 | //exit(EXIT_FAILURE); |
568 | } |
569 | return(handle); |
570 | } |
571 | |
572 | static void |
573 | usage(void) { |
574 | /* print usage if asked, or if syntax incorrect */ |
575 | fprintf(stderr, |
2c9e3090 |
576 | "CRC RevEng: arbitrary-precision CRC calculator and algorithm finder\n" |
a71ece51 |
577 | "Usage:\t"); |
578 | fputs(myname, stderr); |
579 | fprintf(stderr, |
580 | "\t-cdDesvhu? [-bBfFlLMrStVXyz]\n" |
581 | "\t\t[-a BITS] [-A OBITS] [-i INIT] [-k KPOLY] [-m MODEL]\n" |
582 | "\t\t[-p POLY] [-P RPOLY] [-q QPOLY] [-w WIDTH] [-x XOROUT]\n" |
583 | "\t\t[STRING...]\n" |
584 | "Options:\n" |
585 | "\t-a BITS\t\tbits per character (1 to %d)\n" |
586 | "\t-A OBITS\tbits per output character (1 to %d)\n" |
587 | "\t-i INIT\t\tinitial register value\n" |
588 | "\t-k KPOLY\tgenerator in Koopman notation (implies WIDTH)\n" |
589 | "\t-m MODEL\tpreset CRC algorithm\n" |
590 | "\t-p POLY\t\tgenerator or search range start polynomial\n" |
2c9e3090 |
591 | "\t-P RPOLY\treversed generator polynomial (implies WIDTH)\n", |
a71ece51 |
592 | BMP_BIT, BMP_BIT); |
593 | fprintf(stderr, |
594 | "\t-q QPOLY\tsearch range end polynomial\n" |
595 | "\t-w WIDTH\tregister size, in bits\n" |
596 | "\t-x XOROUT\tfinal register XOR value\n" |
597 | "Modifier switches:\n" |
598 | "\t-b big-endian CRC\t\t-B big-endian CRC output\n" |
599 | "\t-f read files named in STRINGs\t-F find presets less quickly\n" |
600 | "\t-l little-endian CRC\t\t-L little-endian CRC output\n" |
601 | "\t-M non-augmenting algorithm\t-r right-justified output\n" |
602 | "\t-S print spaces between chars\t-t left-justified output\n" |
603 | "\t-V reverse algorithm only\t-X print uppercase hex\n" |
604 | "\t-y low bytes first in files\t-z raw binary STRINGs\n"); |
605 | fprintf(stderr, |
606 | "Mode switches:\n" |
607 | "\t-c calculate CRCs\t\t-d dump algorithm parameters\n" |
608 | "\t-D list preset algorithms\t-e echo (and reformat) input\n" |
609 | "\t-s search for algorithm\t\t-v calculate reversed CRCs\n" |
02984d68 |
610 | "\t-g search for alg given hex+crc\t-h | -u | -? show this help\n" |
611 | "Common Use Examples:\n" |
612 | "\t reveng -g 01020304e3\n" |
613 | "\t Searches for a known/common crc preset that computes the crc\n" |
614 | "\t on the end of the given hex string\n" |
615 | "\t reveng -w 8 -s 01020304e3 010204039d\n" |
616 | "\t Searches for any possible 8 bit width crc calc that computes\n" |
617 | "\t the crc on the end of the given hex string(s)\n" |
618 | "\t reveng -m CRC-8 -c 01020304\n" |
619 | "\t Calculates the crc-8 of the given hex string\n" |
620 | "\t reveng -D\n" |
621 | "\t Outputs a list of all known/common crc models with their\n" |
622 | "\t preset values\n" |
a71ece51 |
623 | "\n" |
a78a3d9d |
624 | "Copyright (C) 2010, 2011, 2012, 2013, 2014, 2015, 2016 Gregory Cook\n" |
a71ece51 |
625 | "This is free software; see the source for copying conditions. There is NO\n" |
626 | "warranty; not even for MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.\n" |
627 | "Version " |
628 | VERSION |
629 | "\t\t\t\t <http://reveng.sourceforge.net/>\n"); |
630 | } |