Arduino C/C++ changing function name

Question

Hey all I'm new to the C world so here is my question.

I have the following .h and .cpp file that looks like the following:

.h:

#ifndef Sha256_h
#define Sha256_h
#include "sha256_config.h"

#if defined(SHA256_LINUX)
    class Sha256Class
#else
    class Sha256Class : public Print
#endif
{
  public:
    union _buffer {
        uint8_t b[BLOCK_LENGTH];
        uint32_t w[BLOCK_LENGTH/4];
    };

    union _state {
        uint8_t b[HASH_LENGTH];
        uint32_t w[HASH_LENGTH/4];
    };

    void init(void);
    void initHmac(const uint8_t* secret, int secretLength);
    uint8_t* result(void);
    uint8_t* resultHmac(void);

    #if  defined(SHA256_LINUX)
        virtual size_t write(uint8_t);
        size_t write_L(const char *str);
        size_t write_L(const uint8_t *buffer, size_t size);
        size_t print(const char* str);  
        double millis();
    #else
        virtual size_t write(uint8_t);
        using Print::write;
    #endif

  private:
    void pad();
    void addUncounted(uint8_t data);
    void hashBlock();
    uint32_t ror32(uint32_t number, uint8_t bits);
    _buffer buffer;
    uint8_t bufferOffset;
    _state state;
    uint32_t byteCount;
    uint8_t keyBuffer[BLOCK_LENGTH];
    uint8_t innerHash[HASH_LENGTH];

    #if defined(SHA256_LINUX)
        timeval tv;
    #endif
};

extern Sha256Class Sha256;
#endif

.cpp:

#include "sha256.h"

uint32_t sha256K[] PROGMEM = {
  0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5,0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5,
  0xd807aa98,0x12835b01,0x243185be,0x550c7dc3,0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174,
  0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc,0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da,
  0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7,0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967,
  0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13,0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85,
  0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3,0xd192e819,0xd6990624,0xf40e3585,0x106aa070,
  0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5,0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3,
  0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208,0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2
};

#define BUFFER_SIZE 64

uint8_t sha256InitState[] PROGMEM = {
  0x67,0xe6,0x09,0x6a,
  0x85,0xae,0x67,0xbb,
  0x72,0xf3,0x6e,0x3c,
  0x3a,0xf5,0x4f,0xa5,
  0x7f,0x52,0x0e,0x51,
  0x8c,0x68,0x05,0x9b,
  0xab,0xd9,0x83,0x1f,
  0x19,0xcd,0xe0,0x5b
};

void Sha256Class::init(void) {
  memcpy_P(state.b,sha256InitState,32);
  byteCount = 0;
  bufferOffset = 0;
}

uint32_t Sha256Class::ror32(uint32_t number, uint8_t bits) {
  return ((number << (32-bits)) | (number >> bits));
}

void Sha256Class::hashBlock() {
  uint8_t i;
  uint32_t a,b,c,d,e,f,g,h,t1,t2;

  a=state.w[0];
  b=state.w[1];
  c=state.w[2];
  d=state.w[3];
  e=state.w[4];
  f=state.w[5];
  g=state.w[6];
  h=state.w[7];

  for (i=0; i<64; i++) {
    if (i>=16) {
      t1 = buffer.w[i&15] + buffer.w[(i-7)&15];
      t2 = buffer.w[(i-2)&15];
      t1 += ror32(t2,17) ^ ror32(t2,19) ^ (t2>>10);
      t2 = buffer.w[(i-15)&15];
      t1 += ror32(t2,7) ^ ror32(t2,18) ^ (t2>>3);
      buffer.w[i&15] = t1;
    }

    t1 = h;
    t1 += ror32(e,6) ^ ror32(e,11) ^ ror32(e,25);
    t1 += g ^ (e & (g ^ f));
    t1 += pgm_read_dword(sha256K+i);
    t1 += buffer.w[i&15];
    t2 = ror32(a,2) ^ ror32(a,13) ^ ror32(a,22);
    t2 += ((b & c) | (a & (b | c)));
    h=g; g=f; f=e; e=d+t1; d=c; c=b; b=a; a=t1+t2;
  }

  state.w[0] += a;
  state.w[1] += b;
  state.w[2] += c;
  state.w[3] += d;
  state.w[4] += e;
  state.w[5] += f;
  state.w[6] += g;
  state.w[7] += h;
}

void Sha256Class::addUncounted(uint8_t data) {
  buffer.b[bufferOffset ^ 3] = data;
  bufferOffset++;

  if (bufferOffset == BUFFER_SIZE) {
    hashBlock();
    bufferOffset = 0;
  }
}

size_t Sha256Class::write(uint8_t data) {
  ++byteCount;
  addUncounted(data);

  return 1;
}

void Sha256Class::pad() {
  addUncounted(0x80);

  while (bufferOffset != 56) addUncounted(0x00);

  addUncounted(0);
  addUncounted(0);
  addUncounted(0);
  addUncounted(byteCount >> 29);
  addUncounted(byteCount >> 21);
  addUncounted(byteCount >> 13);
  addUncounted(byteCount >> 5);
  addUncounted(byteCount << 3);
}


uint8_t* Sha256Class::result(void) {
  pad();

  for (int i=0; i<8; i++) {
    uint32_t a,b;

    a=state.w[i];
    b=a<<24;
    b|=(a<<8) & 0x00ff0000;
    b|=(a>>8) & 0x0000ff00;
    b|=a>>24;
    state.w[i]=b;
  }

  return state.b;
}

#define HMAC_IPAD 0x36
#define HMAC_OPAD 0x5c

uint8_t keyBuffer[BLOCK_LENGTH];
uint8_t innerHash[HASH_LENGTH];

void Sha256Class::initHmac(const uint8_t* key, int keyLength) {
  uint8_t i;

  memset(keyBuffer,0,BLOCK_LENGTH);

  if (keyLength > BLOCK_LENGTH) {
    init();
    for (;keyLength--;) write(*key++);

    memcpy(keyBuffer,result(),HASH_LENGTH);
  } else {
    memcpy(keyBuffer,key,keyLength);
  }

  init();

  for (i=0; i<BLOCK_LENGTH; i++) {
    write(keyBuffer[i] ^ HMAC_IPAD);
  }
}

uint8_t* Sha256Class::resultHmac(void) {
  uint8_t i;

  memcpy(innerHash,result(),HASH_LENGTH);
  init();

  for (i=0; i<BLOCK_LENGTH; i++) write(keyBuffer[i] ^ HMAC_OPAD);
  for (i=0; i<HASH_LENGTH; i++) write(innerHash[i]);

  return result();
}

#if defined(SHA256_LINUX)
    size_t Sha256Class::write_L(const char *str){
        if (str == NULL) return 0;

        return write_L((const uint8_t *)str, strlen(str));
    }   

    size_t Sha256Class::write_L(const uint8_t *buffer,size_t size){
        size_t n = 0;

        while (size--){
            n +=write(*buffer++);
        }

        return n;
    }

    size_t Sha256Class::print(const char *str){
        return write_L(str);
    }

    double Sha256Class::millis(){
        gettimeofday(&tv, NULL);

        return (tv.tv_sec + 0.000001 * tv.tv_usec);
    }
#endif

Sha256Class Sha256;

And how I go about calling it from my Arduino code is this:

uint8_t* hash;
uint32_t a;
unsigned long ms;
Serial.println("Test: RFC4231 4.2");
Serial.println("Expect:b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
Serial.print("Result:");
ms = micros();
Sha256.initHmac(hmacKey1,20);
Sha256.print("Hi There");
printHash(Sha256.resultHmac());
Serial.print(" Hash took : ");
Serial.print((micros() - ms));
Serial.println(" micros");
Serial.println();

What I am wanting to do is to rename the Sha256.print to Sha256.Msg . I have tried to rename the class Sha256Class : public Print to class Sha256Class : public Msg but that did not work. I also referenced anything called print and renamed it to Msg as well - still will not being able to get it working.

Answer 1

You should simply just have to change the name of the prototype in the header file, then change the name of the definition of the implementation in the cpp file, and finally remember to change the name where you are using it.

.h:

size_t print(const char* str); to size_t Msg(const char * str)

.cpp:

size_t Sha256Class::print(const char *str){
    return write_L(str);
}

to

size_t Sha256Class::Msg(const char *str){
    return write_L(str);
}

arduino file:

uint8_t* hash;
uint32_t a;
unsigned long ms;
Serial.println("Test: RFC4231 4.2");
Serial.println("Expect:b0344c61d8db38535ca8afceaf0bf12b881dc200c9833da726e9376c2e32cff7");
Serial.print("Result:");
ms = micros();
Sha256.initHmac(hmacKey1,20);
/* change from Sha256.print("Hi There") to */
Sha256.Msg("Hi There");
printHash(Sha256.resultHmac());
Serial.print(" Hash took : ");
Serial.print((micros() - ms));
Serial.println(" micros");
Serial.println();

However, since you have a #if defined(SHA256_LINUX) around the prototype in the header file it could possibly not be declared as Msg(const char *str) instead of print(const char *str) so the best solution would just be to leave the print function implemented and create a second method that does the same thing.

In response to the comment.

.h:

// Add this somewhere in the code wherever you see fit
size_t Msg(const char * str);

.cpp:

//Add this somewhere in the cide wherever you see fit
size_t Sha256Class::Msg(const char *str){
    return write_L(str);
}

And in the arduino file just call the function as you wanted it to be with the new name Sha256.Msg("Hi There");