IDA_new/gf-complete/src/gf_method.c

   1 /*
   2  * GF-Complete: A Comprehensive Open Source Library for Galois Field Arithmetic
   3  * James S. Plank, Ethan L. Miller, Kevin M. Greenan,
   4  * Benjamin A. Arnold, John A. Burnum, Adam W. Disney, Allen C. McBride.
   5  *
   6  * gf_method.c
   7  *
   8  * Parses argv to figure out the mult_type and arguments.  Returns the gf.
   9  */
  10
  11 #include <stdio.h>
  12 #include <stdint.h>
  13 #include <string.h>
  14 #include <stdlib.h>
  15 #include <time.h>
  16
  17 #include "gf_complete.h"
  18 #include "gf_int.h"
  19 #include "gf_method.h"
  20
  21 int create_gf_from_argv(gf_t *gf, int w, int argc, char **argv, int starting)
  22 {
  23   int mult_type, divide_type, region_type;
  24   int arg1, arg2;
  25   uint64_t prim_poly;
  26   gf_t *base;
  27
  28   mult_type = GF_MULT_DEFAULT;
  29   region_type = GF_REGION_DEFAULT;
  30   divide_type = GF_DIVIDE_DEFAULT;
  31   prim_poly = 0;
  32   base = NULL;
  33   arg1 = 0;
  34   arg2 = 0;
  35   while (1) {
  36     if (argc > starting) {
  37       if (strcmp(argv[starting], "-m") == 0) {
  38         starting++;
  39         if (mult_type != GF_MULT_DEFAULT) {
  40           if (base != NULL) gf_free(base, 1);
  41           _gf_errno = GF_E_TWOMULT;
  42           return 0;
  43         }
  44         if (strcmp(argv[starting], "SHIFT") == 0) {
  45           mult_type = GF_MULT_SHIFT;
  46           starting++;
  47         } else if (strcmp(argv[starting], "CARRY_FREE") == 0) {
  48           mult_type = GF_MULT_CARRY_FREE;
  49           starting++;
  50         } else if (strcmp(argv[starting], "CARRY_FREE_GK") == 0) {
  51           mult_type = GF_MULT_CARRY_FREE_GK;
  52           starting++;
  53         } else if (strcmp(argv[starting], "GROUP") == 0) {
  54           mult_type = GF_MULT_GROUP;
  55           if (argc < starting + 3) {
  56             _gf_errno = GF_E_GROUPAR;
  57             return 0;
  58           }
  59           if (sscanf(argv[starting+1], "%d", &arg1) == 0 ||
  60               sscanf(argv[starting+2], "%d", &arg2) == 0) {
  61             _gf_errno = GF_E_GROUPNU;
  62             return 0;
  63           }
  64           starting += 3;
  65         } else if (strcmp(argv[starting], "BYTWO_p") == 0) {
  66           mult_type = GF_MULT_BYTWO_p;
  67           starting++;
  68         } else if (strcmp(argv[starting], "BYTWO_b") == 0) {
  69           mult_type = GF_MULT_BYTWO_b;
  70           starting++;
  71         } else if (strcmp(argv[starting], "TABLE") == 0) {
  72           mult_type = GF_MULT_TABLE;
  73           starting++;
  74         } else if (strcmp(argv[starting], "LOG") == 0) {
  75           mult_type = GF_MULT_LOG_TABLE;
  76           starting++;
  77         } else if (strcmp(argv[starting], "LOG_ZERO") == 0) {
  78           mult_type = GF_MULT_LOG_ZERO;
  79           starting++;
  80         } else if (strcmp(argv[starting], "LOG_ZERO_EXT") == 0) {
  81           mult_type = GF_MULT_LOG_ZERO_EXT;
  82           starting++;
  83         } else if (strcmp(argv[starting], "SPLIT") == 0) {
  84           mult_type = GF_MULT_SPLIT_TABLE;
  85           if (argc < starting + 3) {
  86             _gf_errno = GF_E_SPLITAR;
  87             return 0;
  88           }
  89           if (sscanf(argv[starting+1], "%d", &arg1) == 0 ||
  90               sscanf(argv[starting+2], "%d", &arg2) == 0) {
  91             _gf_errno = GF_E_SPLITNU;
  92             return 0;
  93           }
  94           starting += 3;
  95         } else if (strcmp(argv[starting], "COMPOSITE") == 0) {
  96           mult_type = GF_MULT_COMPOSITE;
  97           if (argc < starting + 2) { _gf_errno = GF_E_FEWARGS; return 0; }
  98           if (sscanf(argv[starting+1], "%d", &arg1) == 0) {
  99             _gf_errno = GF_E_COMP_A2;
 100             return 0;
 101           }
 102           starting += 2;
 103           base = (gf_t *) malloc(sizeof(gf_t));
 104           starting = create_gf_from_argv(base, w/arg1, argc, argv, starting);
 105           if (starting == 0) {
 106             free(base);
 107             return 0;
 108           }
 109         } else {
 110           _gf_errno = GF_E_UNKNOWN;
 111           return 0;
 112         }
 113       } else if (strcmp(argv[starting], "-r") == 0) {
 114         starting++;
 115         if (strcmp(argv[starting], "DOUBLE") == 0) {
 116           region_type |= GF_REGION_DOUBLE_TABLE;
 117           starting++;
 118         } else if (strcmp(argv[starting], "QUAD") == 0) {
 119           region_type |= GF_REGION_QUAD_TABLE;
 120           starting++;
 121         } else if (strcmp(argv[starting], "LAZY") == 0) {
 122           region_type |= GF_REGION_LAZY;
 123           starting++;
 124         } else if (strcmp(argv[starting], "SIMD") == 0) {
 125           region_type |= GF_REGION_SIMD;
 126           starting++;
 127         } else if (strcmp(argv[starting], "NOSIMD") == 0) {
 128           region_type |= GF_REGION_NOSIMD;
 129           starting++;
 130         } else if (strcmp(argv[starting], "SSE") == 0) {
 131           region_type |= GF_REGION_SIMD;
 132           starting++;
 133         } else if (strcmp(argv[starting], "NOSSE") == 0) {
 134           region_type |= GF_REGION_NOSIMD;
 135           starting++;
 136         } else if (strcmp(argv[starting], "CAUCHY") == 0) {
 137           region_type |= GF_REGION_CAUCHY;
 138           starting++;
 139         } else if (strcmp(argv[starting], "ALTMAP") == 0) {
 140           region_type |= GF_REGION_ALTMAP;
 141           starting++;
 142         } else {
 143           if (base != NULL) gf_free(base, 1);
 144           _gf_errno = GF_E_UNK_REG;
 145           return 0;
 146         }
 147       } else if (strcmp(argv[starting], "-p") == 0) {
 148         starting++;
 149         if (sscanf(argv[starting], "%llx", (long long unsigned int *)(&prim_poly)) == 0) {
 150           if (base != NULL) gf_free(base, 1);
 151           _gf_errno = GF_E_POLYSPC;
 152           return 0;
 153         }
 154         starting++;
 155       } else if (strcmp(argv[starting], "-d") == 0) {
 156         starting++;
 157         if (divide_type != GF_DIVIDE_DEFAULT) {
 158           if (base != NULL) gf_free(base, 1);
 159           _gf_errno = GF_E_TWO_DIV;
 160           return 0;
 161         } else if (strcmp(argv[starting], "EUCLID") == 0) {
 162           divide_type = GF_DIVIDE_EUCLID;
 163           starting++;
 164         } else if (strcmp(argv[starting], "MATRIX") == 0) {
 165           divide_type = GF_DIVIDE_MATRIX;
 166           starting++;
 167         } else {
 168           _gf_errno = GF_E_UNK_DIV;
 169           return 0;
 170         }
 171       } else if (strcmp(argv[starting], "-") == 0) {
 172          /*
 173          printf("Scratch size: %d\n", gf_scratch_size(w,
 174                                       mult_type, region_type, divide_type, arg1, arg2));
 175          */
 176         if (gf_init_hard(gf, w, mult_type, region_type, divide_type,
 177                          prim_poly, arg1, arg2, base, NULL) == 0) {
 178           if (base != NULL) gf_free(base, 1);
 179           return 0;
 180         } else
 181           return starting + 1;
 182       } else {
 183         if (base != NULL) gf_free(base, 1);
 184         _gf_errno = GF_E_UNKFLAG;
 185         return 0;
 186       }
 187     } else {
 188       if (base != NULL) gf_free(base, 1);
 189       _gf_errno = GF_E_FEWARGS;
 190       return 0;
 191     }
 192   }
 193 }