Subversion Repositories bluespec_md6

#include<stdlib.h>
#include<stdio.h>
#include<sys/stat.h>
#include<assert.h>
#include<endian.h>
#include"encodeBits.h"
#include"md6.h"
 
 
const int requiredWordCount = 1<<20;
 
 
 
// reads the first bits bits out of the file 
void md6_file(char *filename, 
              char *outinput, 
              char *outresult,
              char *outsize,
               long long bits)
 
{
  FILE *inFile = fopen (filename, "rb");
  FILE *outInput = fopen (outinput, "wb"); 
  FILE *outResult = fopen (outresult, "wb");
  FILE *outSize = fopen (outsize, "wb"); 
  md6_state st;
  uint64_t bytes;
  long long bitCounter = bits;
  unsigned char data[1024];
  int err,i,j,wordCount=0;
  long long bitMin;
 
  md6_word key[md6_k];
 
  printf("Bits: %d\n", bits);
 
  for(i=0;i<md6_k;i++) {
    key[i]=0;
  }
 
  if (inFile == NULL) {
    printf ("%s can't be opened.\n", filename);
  }
 
 
  // Use this instead!
  //  md6_full_init(st,d,NULL,0,md6_default_L,md6_default_r)
  // It is legit to have fewer bytes in the key - should add this option to the HW.
  // Perhaps may want to make 512 a parameter to this function
  if (err=md6_full_init(&st,512,(char*)key,md6_k*8,md6_default_L,md6_default_r(512))) {
      printf("Error code: %d\n",err);
  }
 
  wordCount = 0;
  while ((bytes = fread (data, 1, md6_w/8, inFile)) != 0){
    char wordBuf[md6_w/8];
    int i;
 
 
    //Only swap if this word is full. otherwise, we'll screw up the
    //last byte
    for( i = 0; i < md6_w/8; i++) {
      /*  if((BYTE_ORDER == LITTLE_ENDIAN) && (bitCounter >= md6_w)) {
          wordBuf[i] = data[md6_w/8-i-1];
        }
        else{*/
          wordBuf[i] = data[i];
     }
 
 
 
    // md6_update border case uses wrong endianess
    // we may cross a bit boundary here.  In this case we want min of 
    // bitCounter/bytes*8
    bitMin = (bitCounter<bytes*8)?bitCounter:bytes*8;
    if ((err=md6_update(&st, wordBuf, bitMin))) {
      printf("Error code: %d\n",err);
    }
    wordCount++;
    bitCounter -= bitMin; 
    if((bytes != md6_w/8) || (bitCounter <= 0)) {
      break;
    }
  }
  // swap the last guy specially
  //XXX assert something about bitCounter here
  printf("bytes: %d, bits: %d, bitCounter: %d", bytes, bits, bitCounter);
  assert(bitCounter == 0);
 
 
  if ((err=md6_final(&st,NULL))) {
      printf("Error code: %d\n",err);
  } else {
    printf("\nCalled md6_final\n");
  }
 
  //Wind back
  rewind(inFile);
 
  for(i=0;i<md6_n;i++) {
    data[i]=0;
  }
 
  wordCount = 0;
  while ((bytes = fread (data, 1,md6_w/8, inFile))){
    char wordBuf[md6_w/8];        
    int i;
 
    // Bluespec is big endian
    // Really we should make the C code also big endian.
    // This has to do with zero padding in the controller.  
    // If we fail to feed the right values, we'll basically die.
    for( i = 0; i < md6_w/8; i++) {
      if(BYTE_ORDER == LITTLE_ENDIAN) {
        wordBuf[i] = data[md6_w/8-i-1];
      }
      else{
        wordBuf[i] = data[i];
      }
    }
 
 
    fprintf(outInput,PR_MD6_WORD "\n", *((md6_word*)wordBuf));       
    printf("Got %d bytes\n", bytes);
    wordCount+=bytes;
    if(bytes < (md6_w/8)) {
      break;
    }
    for(i=0;i<md6_n;i++) {
      data[i]=0;
    }
  }
 
  fprintf(outSize,"%x\n%x\n%x\n%x\n",bits,bits,bits,bits);
 
  for(; wordCount < requiredWordCount; wordCount++) {
    fprintf(outInput,PR_MD6_WORD "\n", 0);       
  }
 
  printf("Hashval: %s\n", st.hexhashval);
  for (j = 0;j<md6_c;j++) {
    char wordBuf[md6_w/8];
    int i;
 
    // Bluespec is big endian
    // XXX this code is not deployed
    for( i = 0; i < md6_w/8; i++) {
      if(BYTE_ORDER != BIG_ENDIAN) {
        wordBuf[i] = st.hashval[j*md6_w/8+(md6_w/8-i-1)];
      }
      else{
        wordBuf[i] = st.hashval[j*md6_w/8+i];
      }
    }
 
    fprintf(outResult,PR_MD6_WORD "\n",*((md6_word*)wordBuf));
  }
 
  fclose (inFile);
  fclose (outInput);
  fclose (outResult);
  fclose (outSize);
}