AutoConnect/src/AutoConnectCredential.cpp

/**
 *	AutoConnectCredential class implementation.
 *	@file	AutoConnectCredential.cpp
 *	@author	hieromon@gmail.com
 *	@version	0.9.5
 *	@date	2018-02-17
 *	@copyright	MIT license.
 */

#include <EEPROM.h>
#include "AutoConnectCredential.h"

#define AC_IDENTIFIER "AC_CREDT"
#define AC_HEADERSIZE ((int)(_offset + sizeof(AC_IDENTIFIER) - 1 + sizeof(uint8_t) + sizeof(uint16_t)))

/**
 *  AutoConnectCredential constructor takes the available count of saved
 *  entries.
 *  A stored credential data structure in EEPROM.
 *   0      7 8 9a b                                  (t)
 *  +--------+-+--+-----------------+-----------------+--+
 *  |AC_CREDT|e|ss|ssid\0pass\0bssid|ssid\0pass\0bssid|\0|
 *  +--------+-+--+-----------------+-----------------+--+
 *  AC_CREDT : Identifier. 8 characters.
 *  e  : Number of contained entries(uint8_t).
 *  ss : Container size, excluding ID and number of entries(uint16_t).
 *  ssid: SSID string with null termination.
 *  password : Password string with null termination.
 *  bssid : BSSID 6 bytes.
 *  t  : The end of the container is a continuous '\0'.
 *  The AC_CREDT identifier is at the beginning of the area.
 *  SSID and PASSWORD are terminated by '\ 0'.
 *  Free area are filled with FF, which is reused as an area for insertion.
 */
AutoConnectCredential::AutoConnectCredential() {
  _offset = AC_IDENTIFIER_OFFSET;
  _allocateEntry();
}

AutoConnectCredential::AutoConnectCredential(uint16_t offset) {
  // Save offset for the credential area.
  _offset = offset;
  _allocateEntry();
}

void AutoConnectCredential::_allocateEntry(void) {
  char    id_c[sizeof(AC_IDENTIFIER) - 1];
  uint8_t c;

  EEPROM.begin(AC_HEADERSIZE);

  // Validate the save area of the EEPROM.
  // If it is a valid area, retrieve the stored number of entries,
  // if the identifier is not saved, initialize the EEPROM area.
  _dp = _offset;
  for (c = 0; c < sizeof(id_c); c++) {
    id_c[c] = static_cast<char>(EEPROM.read(_dp++));
  }
  if (!strncmp(id_c, AC_IDENTIFIER, sizeof(id_c))) {
    _entries = EEPROM.read(static_cast<int>(_dp++));
    _containSize = EEPROM.read(static_cast<int>(_dp++));
    _containSize += EEPROM.read(static_cast<int>(_dp)) << 8;
  }
  else {
    _entries = 0;
    _containSize = 0;
  }

  EEPROM.end();
}

/**
 *  The destructor ends EEPROM access.
 */
AutoConnectCredential::~AutoConnectCredential() {
  EEPROM.end();
}

/**
 *  Delete the credential entry for the specified SSID in the EEPROM.
 *  @param  ssid    A SSID character string to be deleted.
 *  @retval true    The entry successfully delete.
 *          false   Could not deleted.
 */
bool AutoConnectCredential::del(const char* ssid) {
  struct station_config entry;
  bool  rc = false;

  if (load(ssid, &entry) >= 0) {
    // Saved credential detected, _ep has the entry location.
    EEPROM.begin(AC_HEADERSIZE + _containSize);
    _dp = _ep;

    // Erase SSID
    while (EEPROM.read(_dp) != 0x00)
      EEPROM.write(_dp++, 0xff);

    // Erase Password
    EEPROM.write(_dp++, 0xff);
    while (EEPROM.read(_dp) != 0x00)
      EEPROM.write(_dp++, 0xff);

    // Erase BSSID
    EEPROM.write(_dp++, 0xff);
    for (uint8_t i = 0; i < sizeof(station_config::bssid); i++)
      EEPROM.write(_dp++, 0xff);

    // End 0xff writing, update headers.
    _entries--;
    EEPROM.write(_offset + static_cast<int>(sizeof(AC_IDENTIFIER)) - 1, _entries);

    // commit it.
    rc = EEPROM.commit();
    delay(10);
    EEPROM.end();
  }
  return rc;
}

/**
 *  Load the credential entry for the specified SSID from the EEPROM.
 *  The credentials are stored to the station_config structure which specified
 *  by *config as the SSID and password.
 *  @param  ssid    A SSID character string to be loaded.
 *  @param  config  A station_config structure pointer.
 *  @retval The entry number of the SSID in EEPROM. If the number less than 0,
 *  the specified SSID was not found.
 */
int8_t AutoConnectCredential::load(const char* ssid, struct station_config* config) {
  int8_t  entry = -1;

  _dp = AC_HEADERSIZE;
  if (_entries) {
    EEPROM.begin(AC_HEADERSIZE + _containSize);
    for (uint8_t i = 0; i < _entries; i++) {
      _retrieveEntry(reinterpret_cast<char*>(config->ssid), reinterpret_cast<char*>(config->password), config->bssid);
      if (!strcmp(ssid, (const char*)config->ssid)) {
        entry = i;
        break;
      }
    }
    EEPROM.end();
  }
  return entry;
}

/**
 *  Load the credential entry for the specified number from the EEPROM.
 *  The credentials are stored to the station_config structure which specified
 *  by *config as the SSID and password.
 *  @param  entry   A number of entry to be loaded.
 *  @param  config  A station_config structure pointer.
 *  @retval true    The entry number of the SSID in EEPROM.
 *          false   The number is not available.
 */
bool AutoConnectCredential::load(int8_t entry, struct station_config* config) {
  _dp = AC_HEADERSIZE;
  if (_entries && entry < _entries) {
    EEPROM.begin(AC_HEADERSIZE + _containSize);
    while (entry-- >= 0)
      _retrieveEntry(reinterpret_cast<char*>(config->ssid), reinterpret_cast<char*>(config->password), config->bssid);
    EEPROM.end();
    return true;
  }
  else {
    return false;
  }
}

/**
 *  Save SSID and password to EEPROM.
 *  When the same SSID already exists, it will be replaced. If the current
 *  entry size insufficient for the new entry, the entry will be appended
 *  and increase whole size. Its previous areas are freed with FF and reused.
 *  @param  config  A pointer to the station_config structure storing SSID and password.
 *  @retval true    Successfully saved.
 *  @retval false   EEPROM commit failed.
 */
bool AutoConnectCredential::save(const struct station_config* config) {
  static const char _id[] = AC_IDENTIFIER;
  struct station_config  stage;
  int8_t  entry;
  bool    rep = false;

  // Detect same entry for replacement.
  entry = load((const char*)(config->ssid), &stage);

  // Saving start.
  EEPROM.begin(AC_HEADERSIZE + _containSize + sizeof(struct station_config));

  // Determine insertion or replacement.
  if (entry >= 0) {
    // An entry with the same SSID was found, release the area for replacement.
    _dp = _ep;
    for (uint8_t dm = 2; dm; _dp++) {
      if (EEPROM.read(_dp) == '\0')
        dm--;
      EEPROM.write(_dp, 0xff);    // Clear SSID, Passphrase
    }
    for (uint8_t i = 0; i < sizeof(station_config::bssid); i++)
      EEPROM.write(_dp++, 0xff);  // Clear BSSID
  }
  else {
    // Same entry not found. increase the entry.
    _entries++;
    int i;
    for (i = 0; i < static_cast<int>(sizeof(_id)) - 1; i++)
      EEPROM.write(i + _offset, (uint8_t)_id[i]);
    EEPROM.write(i + _offset, _entries);
  }

  // Seek insertion point, evaluate capacity to insert the new entry.
  uint8_t eSize = strlen((const char*)config->ssid) + strlen((const char*)config->password) + sizeof(station_config::bssid) + 2;
  for (_dp = AC_HEADERSIZE; _dp < _containSize + AC_HEADERSIZE; _dp++) {
    if (EEPROM.read(_dp) == 0xff) {
      uint8_t fp = _dp;
      while (EEPROM.read(++_dp) == 0xff) {}
      if (_dp - fp >= eSize) {
        _dp = fp;
        rep = true;
        break;
      }
      _dp--;
    }
  }

  // Save new entry
  uint8_t         c;
  const uint8_t*  dt;
  dt = config->ssid;
  do {  // Write SSID
    c = *dt++;
    EEPROM.write(_dp++, c);
  } while (c != '\0');
  dt = config->password;
  do {  // Write password
    c = *dt++;
    EEPROM.write(_dp++, c);
  } while (c != '\0');
  for (uint8_t i = 0; i < sizeof(station_config::bssid); i++)
    EEPROM.write(_dp++, config->bssid[i]);  // write BSSID
  // Terminate container, mark to the end of credential area.
  // When the entry is replaced, not mark a terminator.
  if (!rep) {
    EEPROM.write(_dp, '\0');

    // Update container size
    _containSize = _dp - AC_HEADERSIZE;
    EEPROM.write(_offset + sizeof(AC_IDENTIFIER) - 1 + sizeof(uint8_t), (uint8_t)_containSize);
    EEPROM.write(_offset + sizeof(AC_IDENTIFIER) - 1 + sizeof(uint8_t) + 1, (uint8_t)(_containSize >> 8));
  }

  bool rc = EEPROM.commit();
  delay(10);
  EEPROM.end();

  return rc;
}

/**
 *  Get the SSID and password from EEPROM indicated by _dp as the pointer
 *  of current read address. FF is skipped as unavailable area.
 *  @param  ssid      A SSID storing address.
 *  @param  password  A password storing address.
 */
void AutoConnectCredential::_retrieveEntry(char* ssid, char* password, uint8_t* bssid) {
  uint8_t ec;

  // Skip unavailable entry.
  while ((ec = EEPROM.read(_dp++)) == 0xff) {}

  // Retrieve SSID
  _ep = _dp - 1;
  *ssid++ = ec;
  do {
    ec = EEPROM.read(_dp++);
    *ssid++ = ec;
  } while (ec != '\0');
  // Retrieve Password
  do {
    ec = EEPROM.read(_dp++);
    *password++ = ec;
  } while (ec != '\0');
  // Retrieve BSSID
  for (uint8_t i = 0; i < sizeof(station_config::bssid); i++) {
    bssid[i] = EEPROM.read(_dp++);
  }
}