pzmd5stream.h

Go to the documentation of this file.

#ifndef PZMD5STREAM_H
#define PZMD5STREAM_H

#include "TPZStream.h"

#include <stdio.h>

#ifdef USING_OPENSSL
#include <openssl/md5.h>
#endif

class TPZMD5Stream : public TPZStream
{

#ifdef USING_OPENSSL

  MD5_CTX md5_sig;

  unsigned char digest[MD5_DIGEST_LENGTH];
#endif

  int last_status; // 1 == SUCCESS

  int compare_digests (unsigned char* d1, unsigned char* d2, unsigned int dsz)
  {
    for (unsigned i=0; i< dsz; i++)
    {
      if (d1[i] != d2[i]) 
        return -2; // d1 != d2
    }
    return 0; // no diferences.
  }
                
public:
  TPZMD5Stream() 
  {
    last_status = ResetMD5();
  }

  virtual ~TPZMD5Stream() 
    {}
  
  int CheckMD5(const std::string &filename) {
    FILE* fd = fopen(filename.c_str(),"rb" );
    if (!fd) return 1;
    int ret = CheckMD5(fd);
    fclose(fd);
    return ret;
  }

  int CheckMD5(FILE* fh) 
  {
#ifdef USING_OPENSSL
    unsigned char this_digest[MD5_DIGEST_LENGTH];
    unsigned char file_digest[MD5_DIGEST_LENGTH];

    if (last_status != 1)
      return -3;
    
    /* Read file digest. */
    size_t ret = fread(file_digest, sizeof(unsigned char), MD5_DIGEST_LENGTH, fh);
    if (ret != MD5_DIGEST_LENGTH) {
      std::cerr << "fread could not read " << MD5_DIGEST_LENGTH << " items. Read only " << ret << " bytes." << std::endl;
      // Error.
      return 2;
    }

    /* Compute this digest. */
    if (MD5_Final(this_digest, &md5_sig) != 1) {
      // Error.
        return -1;
    }
    
    return compare_digests (this_digest, file_digest, MD5_DIGEST_LENGTH);
#else
    std::cerr << "Enable -DUSING_OPENSSL to use the TPZMD5Stream class." << std::endl; 
#endif
      return 1;
  }

  int WriteMD5(const std::string &filename) {
    FILE* fd = fopen(filename.c_str(), "wb");
    if (fd == NULL) return 1;
    int ret = WriteMD5(fd);
    fclose(fd);
    return ret;
  }
  
  int WriteMD5(FILE* fh) 
  {
#ifdef USING_OPENSSL
    unsigned char digest[MD5_DIGEST_LENGTH];

    if (last_status != 1)
      return -3;
        
    if (MD5_Final(digest, &md5_sig) != 1) {
      return -1;
    }
    
    if (fwrite( (const void*) digest, sizeof(unsigned char), MD5_DIGEST_LENGTH, fh) < MD5_DIGEST_LENGTH)
      return 2;

    return 0; // Return OK
#else
    std::cerr << "Enable -DUSING_OPENSSL to use the TPZMD5Stream class." << std::endl; 
#endif
      return 1;
  }
  
  int ResetMD5() 
  {
#ifdef USING_OPENSSL
    return MD5_Init(&md5_sig);
#else
    std::cerr << "Enable -DUSING_OPENSSL to use the TPZMD5Stream class." << std::endl; 
#endif
      return 0;
  }
  
  virtual void Write(const int *p, int size) {
    Writes<int>(p,size);
  }
  virtual void Write(const int64_t *p, int size) {
    Writes<int64_t>(p,size);
  }
  virtual void Write(const unsigned int *p, int size) {
    Writes<unsigned int>(p,size);
  }
  virtual void Write(const float *p, int size) {
    Writes<float>(p,size);
  }
  virtual void Write(const double *p, int size) {
    Writes<double>(p,size);
  }
  virtual void Write(const long double *p, int size) {
    Writes<long double>(p,size);
  }
  virtual void Write(const char *p, int size) {
    Writes<char>(p,size);
  }
  virtual void Write(const std::string *p, int size) {
    int c;
    for(c=0; c<size; c++) 
      {
        int sz = p[c].size();
        Write(&sz,1);
        Write(p[c].c_str(),p[c].size());
      }
  }
  virtual void Write(const std::complex <float> *p, int size) {
    Writes< std::complex <float> >(p,size);
  }
  virtual void Write(const std::complex <double> *p, int size) {
    Writes< std::complex <double> >(p,size);
  }
  virtual void Write(const std::complex <long double> *p, int size) {
    Writes< std::complex <long double> >(p,size);
  }
  
#ifdef _AUTODIFF
    
    virtual void Write(const Fad <float> *p, int size) {
        Writes< Fad <float> >(p,size);
    }
    
    virtual void Write(const Fad <double> *p, int size) {
        Writes< Fad <double> >(p,size);
    }
    
    virtual void Write(const Fad <long double> *p, int size) {
        Writes< Fad <long double> >(p,size);
    }
    
#endif

  template<class T>
  void  Writes(const T *p, int size) {
#ifdef USING_OPENSSL
    if (last_status == 1)
      last_status = MD5_Update(&md5_sig, (const void*) p, sizeof(T)*size);
#else
    std::cerr << "Enable -DUSING_OPENSSL to use the TPZMD5Stream class." << std::endl; 
#endif
  }
#ifdef _AUTODIFF
    
    virtual void Read(Fad <float> *p, int size) {
        ReadError();
    }
    
    virtual void Read(Fad <double> *p, int size) {
        ReadError();
    }
    
    virtual void Read(Fad <long double> *p, int size) {
        ReadError();
    }
    
#endif

  virtual void Read(int *p, int size) {
    ReadError();
  }
  virtual void Read(int64_t *p, int size) {
    ReadError();
  }
  virtual void Read(unsigned int *p, int size) {
    ReadError();
  }
  virtual void Read(float *p, int size) {
    ReadError();
  }
  virtual void Read(double *p, int size) {
    ReadError();
  }
  virtual void Read(long double *p, int size) {
    ReadError();
  }
  virtual void Read(char *p, int size) {
    ReadError();
  }
  virtual void Read(std::string *p, int size) 
  {
    ReadError();
  }
  virtual void Read(std::complex <float> *p, int size) {
    ReadError();
  }
  virtual void Read(std::complex <double> *p, int size) {
    ReadError();
  }
  virtual void Read(std::complex <long double> *p, int size) {
    ReadError();
  }

  void ReadError() 
  {
    std::cerr << "ERROR: Read methods for TPZMD5Stream object invoked." << std::endl;
    return;
  }

};

#endif // PZMD5STREAM_H