db.c

/***
Copyright 2010-2026 by Omar Alejandro Herrera Reyna

    Caume Data Security Engine, also known as CaumeDSE is released under the
    GNU General Public License by the Copyright holder, with the additional
    exemption that compiling, linking, and/or using OpenSSL is allowed.

    LICENSE

    This file is part of Caume Data Security Engine, also called CaumeDSE.

    CaumeDSE is free software: you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation, either version 3 of the License, or
    (at your option) any later version.

    CaumeDSE is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with CaumeDSE.  If not, see <http://www.gnu.org/licenses/>.

    INCLUDED SOFTWARE

    This product includes software developed by the OpenSSL Project
    for use in the OpenSSL Toolkit (http://www.openssl.org/).
    This product includes cryptographic software written by
    Eric Young (eay@cryptsoft.com).
    This product includes software written by
    Tim Hudson (tjh@cryptsoft.com).

    This product includes software from the SQLite library that is in
    the public domain (http://www.sqlite.org/copyright.html).

    This product includes software from the GNU Libmicrohttpd project, Copyright
    © 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
    2008, 2009, 2010 , 2011, 2012 Free Software Foundation, Inc.

    This product includes software from Perl5, which is Copyright (C) 1993-2005,
    by Larry Wall and others.

***/
#include "common.h"

static int cmeDBApplyPragmas(sqlite3 *pDB, const char *functionName, const char *filename, const char *pragmas)
{
    int result;
    char *errorMessage=NULL;

    result=sqlite3_exec(pDB,pragmas,NULL,NULL,&errorMessage);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: %s(), sqlite3_exec() PRAGMA error for database '%s': %s\n",
                functionName,filename,(errorMessage)?errorMessage:sqlite3_errmsg(pDB));
#endif
        sqlite3_free(errorMessage);
        return(1);
    }
    sqlite3_free(errorMessage);
    return(0);
}

typedef struct
{
    const char *tableName;
    const char *columnName;
    const char *columnType;
} cmeInternalDBColumnSpec;

static int cmeDBTableExists(sqlite3 *pDB, const char *tableName, int *exists)
{
    int result;
    sqlite3_stmt *stmt=NULL;

    *exists=0;
    result=sqlite3_prepare_v2(pDB,
                              "SELECT 1 FROM sqlite_master WHERE type='table' AND name=? LIMIT 1;",
                              -1,&stmt,NULL);
    if (result!=SQLITE_OK)
    {
        return(1);
    }
    sqlite3_bind_text(stmt,1,tableName,-1,SQLITE_TRANSIENT);
    result=sqlite3_step(stmt);
    if (result==SQLITE_ROW)
    {
        *exists=1;
        result=SQLITE_DONE;
    }
    sqlite3_finalize(stmt);
    return((result==SQLITE_DONE)?0:2);
}

static int cmeDBColumnMatches(sqlite3 *pDB, const cmeInternalDBColumnSpec *columnSpec, int *matches)
{
    int result;
    sqlite3_stmt *stmt=NULL;
    char *query=NULL;
    const unsigned char *name=NULL;
    const unsigned char *type=NULL;
    #define cmeDBColumnMatchesFree() \
        do { \
            cmeFree(query); \
            if (stmt) { sqlite3_finalize(stmt); stmt=NULL; } \
        } while (0); //Local free() macro.

    *matches=0;
    cmeStrConstrAppend(&query,"PRAGMA table_info(\"%s\");",columnSpec->tableName);
    result=sqlite3_prepare_v2(pDB,query,-1,&stmt,NULL);
    if (result!=SQLITE_OK)
    {
        cmeDBColumnMatchesFree();
        return(1);
    }
    while ((result=sqlite3_step(stmt))==SQLITE_ROW)
    {
        name=sqlite3_column_text(stmt,1);
        type=sqlite3_column_text(stmt,2);
        if ((name)&&(!strcmp((const char *)name,columnSpec->columnName)))
        {
            if ((type)&&(!strcasecmp((const char *)type,columnSpec->columnType)))
            {
                *matches=1;
            }
            cmeDBColumnMatchesFree();
            return(0);
        }
    }
    cmeDBColumnMatchesFree();
    return((result==SQLITE_DONE)?0:2);
}

static int cmeCheckInternalDBColumns(sqlite3 *pDB, const cmeInternalDBColumnSpec *columns,
                                     int numColumns, const char *dbClass)
{
    int cont,result,matches=0,exists=0;

    for (cont=0;cont<numColumns;cont++)
    {
        result=cmeDBTableExists(pDB,columns[cont].tableName,&exists);
        if ((result)||(!exists))
        {
#ifdef ERROR_LOG
            if (!getenv("CDSE_SUPPRESS_SCHEMA_ERROR_LOG"))
            {
                fprintf(stderr,"CaumeDSE Error: cmeCheckInternalDBSchema(), missing table '%s' in %s.\n",
                        columns[cont].tableName,dbClass);
            }
#endif
            return(1);
        }
        result=cmeDBColumnMatches(pDB,&columns[cont],&matches);
        if ((result)||(!matches))
        {
#ifdef ERROR_LOG
            if (!getenv("CDSE_SUPPRESS_SCHEMA_ERROR_LOG"))
            {
                fprintf(stderr,"CaumeDSE Error: cmeCheckInternalDBSchema(), missing or wrong-type column '%s.%s' in %s.\n",
                        columns[cont].tableName,columns[cont].columnName,dbClass);
            }
#endif
            return(2);
        }
    }
    return(0);
}

static int cmeGetInternalDBSchemaValue(sqlite3 *pDB, const char *key, char **value)
{
    int result;
    sqlite3_stmt *stmt=NULL;
    const unsigned char *dbValue=NULL;

    *value=NULL;
    result=sqlite3_prepare_v2(pDB,
                              "SELECT value FROM " cmeInternalDBSchemaMetaTableName
                              " WHERE key=? LIMIT 1;",-1,&stmt,NULL);
    if (result!=SQLITE_OK)
    {
        return(1);
    }
    sqlite3_bind_text(stmt,1,key,-1,SQLITE_TRANSIENT);
    result=sqlite3_step(stmt);
    if (result==SQLITE_ROW)
    {
        dbValue=sqlite3_column_text(stmt,0);
        if (dbValue)
        {
            cmeStrConstrAppend(value,"%s",(const char *)dbValue);
        }
        sqlite3_finalize(stmt);
        return(0);
    }
    sqlite3_finalize(stmt);
    return((result==SQLITE_DONE)?2:3);
}

static int cmeCheckInternalDBSchemaMetadata(sqlite3 *pDB, const char *dbClass)
{
    int result,version;
    char *schemaClass=NULL;
    char *schemaVersion=NULL;
    char *migrationState=NULL;
    #define cmeCheckInternalDBSchemaMetadataFree() \
        do { \
            cmeFree(schemaClass); \
            cmeFree(schemaVersion); \
            cmeFree(migrationState); \
        } while (0); //Local free() macro.

    result=cmeGetInternalDBSchemaValue(pDB,"schemaClass",&schemaClass);
    result|=cmeGetInternalDBSchemaValue(pDB,"schemaVersion",&schemaVersion);
    result|=cmeGetInternalDBSchemaValue(pDB,"migrationState",&migrationState);
    if ((result)||(!schemaClass)||(!schemaVersion)||(!migrationState))
    {
#ifdef ERROR_LOG
        if (!getenv("CDSE_SUPPRESS_SCHEMA_ERROR_LOG"))
        {
            fprintf(stderr,"CaumeDSE Error: cmeCheckInternalDBSchema(), incomplete schema metadata for %s.\n",
                    dbClass);
        }
#endif
        cmeCheckInternalDBSchemaMetadataFree();
        return(1);
    }
    version=atoi(schemaVersion);
    if ((!schemaVersion[0])||(version<1)||(version>cmeInternalDBSchemaVersion))
    {
#ifdef ERROR_LOG
        if (!getenv("CDSE_SUPPRESS_SCHEMA_ERROR_LOG"))
        {
            fprintf(stderr,"CaumeDSE Error: cmeCheckInternalDBSchema(), incompatible schema version '%s' for %s; current is %d.\n",
                    schemaVersion,dbClass,cmeInternalDBSchemaVersion);
        }
#endif
        cmeCheckInternalDBSchemaMetadataFree();
        return(2);
    }
    if ((strcmp(schemaClass,dbClass))||(strcmp(migrationState,"complete")))
    {
#ifdef ERROR_LOG
        if (!getenv("CDSE_SUPPRESS_SCHEMA_ERROR_LOG"))
        {
            fprintf(stderr,"CaumeDSE Error: cmeCheckInternalDBSchema(), schema metadata mismatch for %s.\n",
                    dbClass);
        }
#endif
        cmeCheckInternalDBSchemaMetadataFree();
        return(3);
    }
    cmeCheckInternalDBSchemaMetadataFree();
    return(0);
}

static const cmeInternalDBColumnSpec cmeInternalDBLogsColumns[]={
    {cmeIDDLogsDBTransactionsTableName,cmeIDDanydb_id_name,"INTEGER"},
    {cmeIDDLogsDBTransactionsTableName,cmeIDDanydb_userId_name,"TEXT"},
    {cmeIDDLogsDBTransactionsTableName,cmeIDDLogsDBTransactions_requestMethod_name,"TEXT"},
    {cmeIDDLogsDBTransactionsTableName,cmeIDDLogsDBTransactions_responseCode_name,"TEXT"},
    {cmeIDDLogsDBTransactionsTableName,cmeIDDLogsDBTransactions_authenticated_name,"TEXT"}
};

static const cmeInternalDBColumnSpec cmeInternalDBResourcesColumns[]={
    {cmeIDDResourcesDBDocumentsTableName,cmeIDDanydb_id_name,"INTEGER"},
    {cmeIDDResourcesDBDocumentsTableName,cmeIDDResourcesDBDocuments_documentId_name,"TEXT"},
    {cmeIDDResourcesDBDocumentsTableName,cmeIDDResourcesDBDocuments_documentIdLookup_name,"TEXT"},
    {cmeIDDResourcesDBUsersTableName,cmeIDDResourcesDBUsers_basicAuthPwdHash_name,"TEXT"},
    {cmeIDDResourcesDBStorageTableName,cmeIDDResourcesDBStorage_accessPath_name,"TEXT"},
    {cmeIDDResourcesDBOrganizationsTableName,cmeIDDResourcesDBOrganizations_publicKey_name,"TEXT"}
};

static const cmeInternalDBColumnSpec cmeInternalDBResourcesLegacyColumns[]={
    {cmeIDDResourcesDBDocumentsTableName,cmeIDDanydb_id_name,"INTEGER"},
    {cmeIDDResourcesDBDocumentsTableName,cmeIDDResourcesDBDocuments_documentId_name,"TEXT"},
    {cmeIDDResourcesDBUsersTableName,cmeIDDResourcesDBUsers_basicAuthPwdHash_name,"TEXT"},
    {cmeIDDResourcesDBStorageTableName,cmeIDDResourcesDBStorage_accessPath_name,"TEXT"},
    {cmeIDDResourcesDBOrganizationsTableName,cmeIDDResourcesDBOrganizations_publicKey_name,"TEXT"}
};

static const cmeInternalDBColumnSpec cmeInternalDBRolesColumns[]={
    {cmeIDDResourcesDBDocumentsTableName,cmeIDDRolesDBAnyTable__get_name,"TEXT"},
    {cmeIDDResourcesDBUsersTableName,cmeIDDRolesDBAnyTable__post_name,"TEXT"},
    {cmeIDDResourcesDBOrganizationsTableName,cmeIDDRolesDBAnyTable__delete_name,"TEXT"},
    {cmeIDDResourcesDBStorageTableName,cmeIDDRolesDBAnyTable__options_name,"TEXT"},
    {cmeIDDLogsDBTransactionsTableName,cmeIDDRolesDBAnyTable_orgResourceId_name,"TEXT"},
    {"meta",cmeIDDRolesDBAnyTable_userResourceId_name,"TEXT"}
};

static const cmeInternalDBColumnSpec cmeInternalDBColumnFileColumns[]={
    {cmeIDDColumnFileDataTableName,cmeIDDColumnFileData_value_name,"TEXT"},
    {cmeIDDColumnFileDataTableName,cmeIDDColumnFileData_rowOrder_name,"TEXT"},
    {cmeIDDColumnFileMetaTableName,cmeIDDColumnFileMeta_attribute_name,"TEXT"},
    {cmeIDDColumnFileMetaTableName,cmeIDDColumnFileMeta_attributeData_name,"TEXT"}
};

static int cmeCheckInternalDBClassColumns(sqlite3 *pDB, const char *dbClass, int useLegacy)
{
    if (!strcmp(dbClass,cmeInternalDBSchemaClassLogs))
    {
        return(cmeCheckInternalDBColumns(pDB,cmeInternalDBLogsColumns,
               sizeof(cmeInternalDBLogsColumns)/sizeof(cmeInternalDBLogsColumns[0]),dbClass));
    }
    if (!strcmp(dbClass,cmeInternalDBSchemaClassResources))
    {
        if (useLegacy)
        {
            return(cmeCheckInternalDBColumns(pDB,cmeInternalDBResourcesLegacyColumns,
                   sizeof(cmeInternalDBResourcesLegacyColumns)/sizeof(cmeInternalDBResourcesLegacyColumns[0]),dbClass));
        }
        return(cmeCheckInternalDBColumns(pDB,cmeInternalDBResourcesColumns,
               sizeof(cmeInternalDBResourcesColumns)/sizeof(cmeInternalDBResourcesColumns[0]),dbClass));
    }
    if (!strcmp(dbClass,cmeInternalDBSchemaClassRoles))
    {
        return(cmeCheckInternalDBColumns(pDB,cmeInternalDBRolesColumns,
               sizeof(cmeInternalDBRolesColumns)/sizeof(cmeInternalDBRolesColumns[0]),dbClass));
    }
    if (!strcmp(dbClass,cmeInternalDBSchemaClassColumnFile))
    {
        return(cmeCheckInternalDBColumns(pDB,cmeInternalDBColumnFileColumns,
               sizeof(cmeInternalDBColumnFileColumns)/sizeof(cmeInternalDBColumnFileColumns[0]),dbClass));
    }
    return(1);
}

int cmeSetInternalDBSchemaVersion(sqlite3 *pDB, const char *dbClass)
{
    int result;
    char *sqlQuery=NULL;
    #define cmeSetInternalDBSchemaVersionFree() \
        do { \
            cmeFree(sqlQuery); \
        } while (0); //Local free() macro.

    cmeStrConstrAppend(&sqlQuery,
                       "BEGIN TRANSACTION; "
                       "CREATE TABLE IF NOT EXISTS " cmeInternalDBSchemaMetaTableName
                       " (key TEXT PRIMARY KEY, value TEXT NOT NULL); "
                       "INSERT OR REPLACE INTO " cmeInternalDBSchemaMetaTableName
                       " (key,value) VALUES "
                       "('schemaClass','%s'),"
                       "('schemaVersion','%d'),"
                       "('definitionsVersion','%s'),"
                       "('migrationState','complete'); "
                       "COMMIT;",
                       dbClass,cmeInternalDBSchemaVersion,cmeInternalDBDefinitionsVersion);
    result=cmeSQLRows(pDB,sqlQuery,NULL,NULL);
    cmeSetInternalDBSchemaVersionFree();
    return(result?1:0);
}

int cmeCheckInternalDBSchema(sqlite3 *pDB, const char *dbClass, int allowLegacy)
{
    int result,hasMeta=0;

    result=cmeDBTableExists(pDB,cmeInternalDBSchemaMetaTableName,&hasMeta);
    if (result)
    {
        return(1);
    }
    if (!hasMeta)
    {
        if (!allowLegacy)
        {
#ifdef ERROR_LOG
            if (!getenv("CDSE_SUPPRESS_SCHEMA_ERROR_LOG"))
            {
                fprintf(stderr,"CaumeDSE Error: cmeCheckInternalDBSchema(), missing schema metadata for %s.\n",
                        dbClass);
            }
#endif
            return(2);
        }
        return(cmeCheckInternalDBClassColumns(pDB,dbClass,1)?3:0);
    }
    result=cmeCheckInternalDBSchemaMetadata(pDB,dbClass);
    if (result)
    {
        return(4);
    }
    return(cmeCheckInternalDBClassColumns(pDB,dbClass,0)?5:0);
}

static int cmeEnsureLogsDBTextColumn(sqlite3 *pDB, const char *columnName)
{
    int result,matches=0;
    char *sqlQuery=NULL;
    cmeInternalDBColumnSpec columnSpec={cmeIDDLogsDBTransactionsTableName,columnName,"TEXT"};
    #define cmeEnsureLogsDBTextColumnFree() \
        do { \
            cmeFree(sqlQuery); \
        } while (0); //Local free() macro.

    result=cmeDBColumnMatches(pDB,&columnSpec,&matches);
    if ((!result)&&(matches))
    {
        return(0);
    }
    cmeStrConstrAppend(&sqlQuery,"ALTER TABLE " cmeIDDLogsDBTransactionsTableName " ADD COLUMN %s TEXT;",
                       columnName);
    result=sqlite3_exec(pDB,sqlQuery,NULL,NULL,NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeEnsureLogsDBTransactionsSchema(), can't add LogsDB column '%s': %s.\n",
                columnName,sqlite3_errmsg(pDB));
#endif
        cmeEnsureLogsDBTextColumnFree();
        return(1);
    }
    cmeEnsureLogsDBTextColumnFree();
    return(0);
}

int cmeEnsureLogsDBTransactionsSchema(sqlite3 *pDB)
{
    int cont,result,exists=0;
    char *sqlQuery=NULL;
    const char *columns[]={
        cmeIDDanydb_userId_name,
        cmeIDDanydb_orgId_name,
        cmeIDDanydb_salt_name,
        cmeIDDLogsDBTransactions_requestMethod_name,
        cmeIDDLogsDBTransactions_requestUrl_name,
        cmeIDDLogsDBTransactions_requestHeaders_name,
        cmeIDDLogsDBTransactions_startTimestamp_name,
        cmeIDDLogsDBTransactions_endTimestamp_name,
        cmeIDDLogsDBTransactions_requestDataSize_name,
        cmeIDDLogsDBTransactions_responseDataSize_name,
        cmeIDDLogsDBTransactions_orgResourceId_name,
        cmeIDDLogsDBTransactions_requestIPAddress_name,
        cmeIDDLogsDBTransactions_responseCode_name,
        cmeIDDLogsDBTransactions_responseHeaders_name,
        cmeIDDLogsDBTransactions_authenticated_name
    };
    #define cmeEnsureLogsDBTransactionsSchemaFree() \
        do { \
            cmeFree(sqlQuery); \
        } while (0); //Local free() macro.

    result=cmeDBTableExists(pDB,cmeIDDLogsDBTransactionsTableName,&exists);
    if (result)
    {
        return(1);
    }
    if (!exists)
    {
        cmeStrConstrAppend(&sqlQuery,
                           "CREATE TABLE " cmeIDDLogsDBTransactionsTableName
                           " (id INTEGER PRIMARY KEY, userId TEXT, orgId TEXT, salt TEXT,"
                           " requestMethod TEXT, requestUrl TEXT, requestHeaders TEXT, startTimestamp TEXT,"
                           " endTimestamp TEXT, requestDataSize TEXT, responseDataSize TEXT, orgResourceId TEXT,"
                           " requestIPAddress TEXT, responseCode TEXT, responseHeaders TEXT, authenticated TEXT);");
        result=sqlite3_exec(pDB,sqlQuery,NULL,NULL,NULL);
        if (result!=SQLITE_OK)
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeEnsureLogsDBTransactionsSchema(), can't create LogsDB transactions table: %s.\n",
                    sqlite3_errmsg(pDB));
#endif
            cmeEnsureLogsDBTransactionsSchemaFree();
            return(2);
        }
        cmeFree(sqlQuery);
    }
    for (cont=0;cont<(int)(sizeof(columns)/sizeof(columns[0]));cont++)
    {
        if (cmeEnsureLogsDBTextColumn(pDB,columns[cont]))
        {
            cmeEnsureLogsDBTransactionsSchemaFree();
            return(3);
        }
    }
    cmeStrConstrAppend(&sqlQuery,
                       "CREATE INDEX IF NOT EXISTS idx_log_transactions_uo ON "
                       cmeIDDLogsDBTransactionsTableName "(orgId,userId);");
    result=sqlite3_exec(pDB,sqlQuery,NULL,NULL,NULL);
    cmeEnsureLogsDBTransactionsSchemaFree();
    return((result==SQLITE_OK)?0:4);
}

int cmeDBCreateOpen (const char *filename, sqlite3 **ppDB)
{
    int result;

    result = sqlite3_open_v2(filename, ppDB,SQLITE_OPEN_READWRITE|
                             SQLITE_OPEN_CREATE|SQLITE_OPEN_FULLMUTEX, NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeDBCreateOpen(), sqlite_open_v2() error: %s\n",
                sqlite3_errmsg(*ppDB));
#endif
        sqlite3_close(*ppDB);
        return(1);
    }
    else
    {
        if (strcmp(filename,":memory:") &&
            cmeDBApplyPragmas(*ppDB,"cmeDBCreateOpen",filename,
                              "PRAGMA journal_mode=WAL; PRAGMA synchronous=NORMAL; PRAGMA cache_size=-8000;"))
        {
            sqlite3_close(*ppDB);
            *ppDB=NULL;
            return(2);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeDBCreateOpen(), Created/opened sqlite3 database file: %s.\n",filename);
#endif
        return(0);
    }
}

int cmeMemDBCreateOpen (sqlite3 **ppDB)
{
    int result;

    result = sqlite3_open_v2(":memory:", ppDB,SQLITE_OPEN_READWRITE|
                             SQLITE_OPEN_CREATE|SQLITE_OPEN_FULLMUTEX, NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemDBCreateOpen(), sqlite_open_v2() error: %s\n",
                sqlite3_errmsg(*ppDB));
#endif
        sqlite3_close(*ppDB);
        return(1);
    }
    else
    {
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemDBCreateOpen(), Created/opened sqlite3 memory database.\n");
#endif
        return(0);
    }
}

int cmeDBOpen (const char *filename, sqlite3 **ppDB)
{
    int result;

    result = sqlite3_open_v2(filename, ppDB,SQLITE_OPEN_READWRITE|
                             SQLITE_OPEN_FULLMUTEX, NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeDBOpen(), sqlite_open_v2() error: %s\n",
                sqlite3_errmsg(*ppDB));
#endif
        //sqlite3_close(*ppDB);
        return(1);
    }
    else
    {
        if (cmeDBApplyPragmas(*ppDB,"cmeDBOpen",filename,
                              "PRAGMA synchronous=NORMAL; PRAGMA cache_size=-8000;"))
        {
            sqlite3_close(*ppDB);
            *ppDB=NULL;
            return(2);
        }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeDBOpen(), Opened sqlite3 database file: %s.\n",filename);
#endif
        return(0);
    }
}

int cmeDBClose (sqlite3 *ppDB)
{
    int  result=0;
    result=sqlite3_close(ppDB);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeDBClose(), sqlite_close() error: %s\n",
                sqlite3_errmsg(ppDB));
#endif
        return(1);
    }
    else
    {
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeDBClose(), Closed sqlite3 database file.\n");
#endif
        return(0);
    }
}

//Based on code from: http://www.sqlite.org/backup.html
int cmeMemDBLoadOrSaveVacuum(sqlite3 *pInMemory, const char *zFilename, int isSave, int vacuumBeforeSave)
{
    int result=0;
    sqlite3 *pFile=NULL;
    sqlite3_backup *pBackup=NULL;
    sqlite3 *pTo=NULL;
    sqlite3 *pFrom=NULL;

    if(isSave) // we save
    {
        result=cmeDBCreateOpen(zFilename,&pFile);
    }
    else //we load
    {
        result=cmeDBOpen(zFilename,&pFile);
    }
    if (result) //Error Opening or creating file.
    {
        return(1);
    }
    else //Everything is ok now.
    {
        // If this is a 'load' operation (isSave==0), then data is copied
        // from the database file to database pInMemory.
        // Otherwise, data is copied from pInMemory to pFile.
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeDBMemLoadOrSave(), Opened DB file %s for "
                "R/W successfuly. isSave: %d vacuumBeforeSave: %d \n",zFilename, isSave, vacuumBeforeSave);
#endif
        if ((isSave)&&(vacuumBeforeSave))
        {
            result=sqlite3_exec(pInMemory,"VACUUM;",NULL,NULL,NULL);
            if (result)
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemDBLoadOrSaveVacuum(), sqlite3_exec() VACUUM error for memory DB before saving to '%s': %s\n",
                        zFilename,sqlite3_errmsg(pInMemory));
#endif
                cmeDBClose(pFile);
                return(2);
            }
        }
        pFrom = (isSave ? pInMemory : pFile);
        pTo   = (isSave ? pFile     : pInMemory);
        // Set up the backup procedure to copy from the "main" database of
        // connection pFile to the main database of connection pInMemory.
        pBackup = sqlite3_backup_init(pTo, "main", pFrom, "main");
        if( pBackup )
        {
          (void)sqlite3_backup_step(pBackup, -1);  //Copy full database at once.
          (void)sqlite3_backup_finish(pBackup);
        }
        result = sqlite3_errcode(pTo);
    }
    cmeDBClose(pFile); // Close the database connection opened on database file zFilename
    return (result);
}

int cmeMemDBLoadOrSave(sqlite3 *pInMemory, const char *zFilename, int isSave)
{
    return(cmeMemDBLoadOrSaveVacuum(pInMemory,zFilename,isSave,0));
}

int cmeSQLIterate (const char *args,int numCols,char **pStrResults,char **pColNames)
{
    int cont,cont2,result;
    int maxResults=0;
    int returnedResults=0;
    char **perlResults=NULL;
    char *fName=NULL;
    char *sqlStatemnt=NULL;
    #define cmeSQLIterateFree() \
        do { \
            cmeFree(fName); \
            cmeFree(sqlStatemnt); \
            if (perlResults) \
            { \
               for (cont=0; cont<returnedResults;cont++) \
               { \
                   cmeFree(perlResults[cont]); \
               } \
               cmeFree(perlResults); \
            } \
        } while (0); //Local free() macro.

    cmeStrConstrAppend(&fName,"%s",(char *)args);
    maxResults=numCols;
    perlResults=(char **)malloc((sizeof(char *))*numCols);
    if (!cmeResultMemTable)//If this is the first iteration (i.e. cmeResultMemTable==NULL).
    {
        cmeResultMemTableCols=numCols; //Set column names of Tmp MemTable.
        cmeResultMemTable=(char **)malloc(sizeof(char*)*numCols); //There can't be more results than there are columns (as of this version).

        result=cmePerlParserScriptFunction(cmeDefaultPerlColNameSetupFunction,cdsePerl,pColNames,numCols,     //Send column names on first iteration to special subroutine "cmePERLProcessColumnNames"
                                           perlResults,maxResults,&returnedResults);
        if (result)  //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeSQLIterate(), Error in cmePerlParserScriptFunction()"
                    ": %d.\n",result);
#endif
            cmeSQLIterateFree();
            return(result);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeSQLIterate(), Prepared %d results"
                " from perl function %s (first iteration).\n",returnedResults,cmeDefaultPerlColNameSetupFunction);
#endif
        for(cont=0;cont<numCols;cont++) //Copy column names
        {
            cmeResultMemTable[cont]=NULL;
            if (returnedResults==numCols) // If script returned column names (modified?) then use them
            {
                cmeStrConstrAppend(&(cmeResultMemTable[cont]),"%s",perlResults[numCols -1 -cont]);
            }
            else //Otherwise use the column names provided to this function
            {
                cmeStrConstrAppend(&(cmeResultMemTable[cont]),"%s",pColNames[cont]);
            }
        }
        cmeResultMemTableRows=0; //Column names are always included (row 0), even if row count ignores them.
    }
    for (cont=0; cont<returnedResults;cont++) //Free results from first iteration (columns), if any...
    {
       cmeFree(perlResults[cont]);
    }
    cmeResultMemTableRows++; //Increase the number of rows included in the Tmp MemTable.
    cmeResultMemTable=(char **)realloc(cmeResultMemTable,sizeof(char*)*(cmeResultMemTableCols*cmeResultMemTableRows+numCols)); //Add space for one additional row
    if (!cmeResultMemTable) //Realloc error.
    {
        return(1);
    }
    for (cont=(cmeResultMemTableCols*cmeResultMemTableRows);cont<(cmeResultMemTableCols*cmeResultMemTableRows+numCols);cont++)
    {
        cmeResultMemTable[cont]=NULL; //initialize new row pointers.
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeSQLIterate(), Prepared to iterate on a row with"
            " the following %d columns and values:\n",numCols);
    for (cont=0; cont<numCols; cont++)
    {
        fprintf(stdout,"\t\t%d) col.name:%s value:%s\n",cont+1,pColNames[cont],pStrResults[cont]);
    }
#endif
    result=cmePerlParserScriptFunction(fName,cdsePerl,pStrResults,numCols,
                                        perlResults,maxResults,&returnedResults);
    if (result)  //Error
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeSQLIterate(), Error in cmePerlParserScriptFunction()"
                ": %d.\n",result);
#endif
        cmeSQLIterateFree();
        return(result);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeSQLIterate(), Prepared %d results"
            " from perl function %s.\n",returnedResults,fName);
#endif
    cont2=cmeResultMemTableCols*cmeResultMemTableRows;
    for (cont=returnedResults-1; cont>=0; cont--)         //pop results from the stack in reverse (correct) order
    {
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeSQLIterate(), cmePerlParserScriptFunction() result %d:"
                " %s.\n",cont+1,perlResults[cont]);
#endif
        cmeStrConstrAppend(&(cmeResultMemTable[cont2]),"%s",perlResults[cont]);
        cont2++;
    }
    cmeSQLIterateFree();
    return(0);
}

int cmeSQLRows (sqlite3 *db, const char *sqlQuery, char *perlScriptName,
                PerlInterpreter *myPerl)
{
    int result,cont,numCols;
    int regCount=0;
    int rowCapacity=0; // current allocated row count for doubling-realloc strategy
    sqlite3_stmt *sqlStatemnt=NULL;
    char **columnNames=NULL;
    char **columnValues=NULL;
    const char *pSqlInstruction=NULL;
    const char *tail;
    const char *errMsg;
    #define cmeSQLRowsFree() \
        do { \
            cmeFree(columnNames); \
            cmeFree(columnValues); \
        } while (0); //Local free() macro.

    if (myPerl==NULL) //No Callback function defined
    {
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeSQLRows(), sqlite3_exec() to be called with "
                "no Callback function. Query:\n%s\n",sqlQuery);
#endif
        //0) Open connection to Database; this is done outside of this function (DB is assumed to be open).
        //1) Prepare SQL statement:
        pSqlInstruction=sqlQuery;
        do
        {
            numCols=-1; //Reset column counter for each SQL instruction.
            sqlStatemnt=NULL;
            result = sqlite3_prepare_v2(db,pSqlInstruction,-1,&sqlStatemnt,&tail);
            if (result) // Error
            {
    #ifdef ERROR_LOG
                errMsg=sqlite3_errmsg(db);
                fprintf(stderr,"CaumeDSE Error: cmeSQLRows(), sqlite3_prepare_v2() error: %s\n",
                        errMsg);
    #endif
                cmeSQLRowsFree();
                return(2);
            }
            if (!sqlStatemnt)
            {
                break;
            }
            //2) Execute statement and get each result row:
            while (sqlite3_step(sqlStatemnt) == SQLITE_ROW)
            {
                if (numCols==-1) //First cycle.
                {
                    numCols=sqlite3_data_count(sqlStatemnt);                //Get number of columns in row.
                    columnNames=(char **)malloc(sizeof(char *)*numCols);    //Reserve memory for column names' string pointers.
                    columnValues=(char **)malloc(sizeof(char *)*numCols);   //Reserve memory for column values' string pointers.
                    for (cont=0;cont<numCols;cont++) //Point to column names.
                    {
                        columnNames[cont]=(char *)sqlite3_column_name(sqlStatemnt,cont);
                    }
                    if (cmeResultMemTable)//cmeResultMemTable is not empty, free all variables.
                    {
                        cmeResultMemTableClean();
                    }
                    //Insert column names into new table:
                    cmeResultMemTableCols=numCols; //Set column names of Tmp MemTable.
                    rowCapacity=8; // Initial capacity; grows by doubling.
                    cmeResultMemTable=(char **)malloc(sizeof(char*)*(size_t)numCols*(1+rowCapacity));
                    for(cont=0;cont<numCols*(1+rowCapacity);cont++) cmeResultMemTable[cont]=NULL;
                    for(cont=0;cont<numCols;cont++) //Copy column names into row 0.
                    {
                        cmeStrConstrAppend(&(cmeResultMemTable[cont]),"%s",columnNames[cont]);
                    }
                    cmeResultMemTableRows=0; //Column names are always included (row 0), even if row count ignores them.
                }
                cmeResultMemTableRows++; //Increase the number of rows included in the Tmp MemTable.
                if (cmeResultMemTableRows>rowCapacity) //Grow with doubling to avoid O(n^2) realloc.
                {
                    int newCap=rowCapacity*2;
                    cmeResultMemTable=(char **)realloc(cmeResultMemTable,sizeof(char*)*(size_t)numCols*(1+newCap));
                    if (!cmeResultMemTable) { return(1); }
                    for (cont=numCols*(1+rowCapacity);cont<numCols*(1+newCap);cont++)
                        cmeResultMemTable[cont]=NULL;
                    rowCapacity=newCap;
                }
                for (cont=(cmeResultMemTableCols*cmeResultMemTableRows);cont<(cmeResultMemTableCols*cmeResultMemTableRows+numCols);cont++)
                {
                    cmeResultMemTable[cont]=NULL; //initialize new row pointers.
                }
                for (cont=0;cont<numCols;cont++) //Point to column values; copy values to new row.
                {
                    columnValues[cont]=(char *)sqlite3_column_text(sqlStatemnt,cont);
                    cmeStrConstrAppend(&(cmeResultMemTable[cmeResultMemTableCols*cmeResultMemTableRows+cont]),"%s",columnValues[cont]);
                }
                regCount++;
            }
    #ifdef DEBUG
            fprintf(stdout,"CaumeDSE Debug: cmeSQLRows(), sqlite3_step() cycle finished; '%d' result rows were obtained.\n",
                    regCount);
    #endif
            //3) Finalize statement:
            sqlite3_finalize(sqlStatemnt);
            //3.5) Cycle for next SQL instruction. if available
            pSqlInstruction=tail;
        } while (sqlStatemnt);
        // Trim over-allocated pointer array to exact row count.
        if (cmeResultMemTable && rowCapacity>cmeResultMemTableRows)
        {
            char **tmp=(char **)realloc(cmeResultMemTable,sizeof(char*)*(size_t)cmeResultMemTableCols*(1+cmeResultMemTableRows));
            if (tmp) cmeResultMemTable=tmp;
        }
        //4)  Close DB connection; this will be done outside of this function.
    }
    else //Callback function required
    {
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeSQLRows(), sqlite3_exec() to be called with "
                "Callback Perl function: Script name: %s. Query:\n%s\n",
                perlScriptName,sqlQuery);
#endif
        //0) Open connection to Database; this is done outside of this function (DB is assumed to be open).
        //1) Prepare SQL statement:
        pSqlInstruction=sqlQuery;
        do
        {
            numCols=-1; //Reset column counter for each SQL instruction.
            sqlStatemnt=NULL;
            result = sqlite3_prepare_v2(db,pSqlInstruction,-1,&sqlStatemnt,&tail);
            if (result) // Error
            {
    #ifdef ERROR_LOG
                errMsg=sqlite3_errmsg(db);
                fprintf(stderr,"CaumeDSE Error: cmeSQLRows(), sqlite3_prepare_v2() error: %s\n",
                        errMsg);
    #endif
                cmeSQLRowsFree();
                return(2);
            }
            if (!sqlStatemnt)
            {
                break;
            }
            //2) Execute statement and get each result row:
            while (sqlite3_step(sqlStatemnt) == SQLITE_ROW)
            {
                if (numCols==-1) //First cycle.
                {
                    numCols=sqlite3_data_count(sqlStatemnt);                //Get number of columns in row.
                    columnNames=(char **)malloc(sizeof(char *)*numCols);    //Reserve memory for column names' string pointers.
                    columnValues=(char **)malloc(sizeof(char *)*numCols);   //Reserve memory for column values' string pointers.
                    for (cont=0;cont<numCols;cont++) //Point to column names.
                    {
                        columnNames[cont]=(char *)sqlite3_column_name(sqlStatemnt,cont);
                    }
                    if (cmeResultMemTable)//cmeResultMemTable is not empty, free all variables.
                    {
                        cmeResultMemTableClean(); //Reuse central clean function (NULL-safe, caches strlen).
                    }
                }
                for (cont=0;cont<numCols;cont++) //Point to column values.
                {
                    columnValues[cont]=(char *)sqlite3_column_text(sqlStatemnt,cont);
                }
                //Parse each row with the script iteration function:
                cmeSQLIterate(perlScriptName,numCols,columnValues,columnNames);
                regCount++;
            }
    #ifdef DEBUG
            fprintf(stdout,"CaumeDSE Debug: cmeSQLRows(), sqlite3_step() cycle finished; '%d' result rows were obtained.\n",
                    regCount);
    #endif
            //3) Finalize statement:
            sqlite3_finalize(sqlStatemnt);
            //3.5) Cycle for next SQL instruction. if available
            pSqlInstruction=tail;
        } while (sqlStatemnt);
        //4)  Close DB connection; this will be done outside of this function.
    }
    cmeSQLRowsFree();
    return(0);
}

int cmeResultMemTableClean ()
{
    int cont,cont2;
    char *_p;

    if (cmeResultMemTable)//cmeResultMemTable is not empty, free all variables.
    {
        for (cont2=0;cont2<=cmeResultMemTableRows;cont2++) //Process each row. (Note that column names are put in row 0; we need to include this row).
        {
            for(cont=0;cont<cmeResultMemTableCols;cont++) //Process each column.
            {
                _p=cmeResultMemTable[cont2*cmeResultMemTableCols+cont];
                if (_p) { memset(_p,0,strlen(_p)); } //Wipe sensitive data; cache length to avoid redundant strlen in memset.
                cmeFree(cmeResultMemTable[cont2*cmeResultMemTableCols+cont]);
            }
        }
        cmeFree(cmeResultMemTable);
        cmeResultMemTableCols=0;
        cmeResultMemTableRows=0;
    }
    return(0);
}

int cmeMemTable (sqlite3 *db, const char *sqlQuery,char ***pQueryResult,
                 int *numRows, int *numColumns)
{
    // sqlite3_get_table() is used here because its result format is required by
    // cmeMemTableFinal()/sqlite3_free_table().  The deprecated PRAGMA
    // "empty_result_callbacks = ON" has been removed from all callers; sqlite3_get_table
    // already returns column names for empty tables without that PRAGMA.
    char *pzErrmsg=NULL;
    sqlite3_get_table(db, sqlQuery, pQueryResult, numRows, numColumns, &pzErrmsg);
    if (pzErrmsg!=NULL)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemTable(), sqlite3_get_table() error: %s\n",
                pzErrmsg);
        sqlite3_free(pzErrmsg);
#endif
        return(1);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemTable(), sqlite3_get_table() successful (%d rows, %d cols).\n",
            *numRows,*numColumns);
#endif
    return(0);
}
int cmeMemTableFinal (char **QueryResult)
{
    sqlite3_free_table(QueryResult);
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeSQLTableFinal(), sqlite3_free_table() executed.\n");
#endif
    return(0);
}

int cmeMemTableToMemDB (sqlite3 *dstMemDB, const char **srcMemTable, const int numRows,
                        const int numCols, char *sqlTableName)
{
    int cont,cont2,bindCol,result;
    int rowsBlocks;
    int rowsLastBlock;
    int currentRow=1;
    int rowsInBlock;
    char *sqlInsertQuery=NULL;
    char *sqlCreateCols=NULL;
    char *sqlInsertCols=NULL;
    char *sanitizedStr=NULL;
    sqlite3_stmt *insertStmt=NULL;
    const char *defaultTableName="data";
    #define cmeMemTableToMemDBFree() \
        do { \
            if (insertStmt) { sqlite3_finalize(insertStmt); insertStmt=NULL; } \
            cmeFree(sqlInsertQuery); \
            cmeFree(sqlInsertCols); \
            cmeFree(sqlCreateCols); \
            cmeFree(sanitizedStr); \
        } while (0); //Local free() macro.

    if (!numCols) //If MemTable is empty, we do nothing and exit
    {
        cmeMemTableToMemDBFree();
        return(0);
    }
    if(!sqlTableName) //if table name is empty; assign a default name
    {
        sqlTableName=(char *)defaultTableName;
    }
    rowsBlocks=numRows / cmeDefaultInsertSqlRows;
    rowsLastBlock=numRows % cmeDefaultInsertSqlRows;
    cmeStrConstrAppend(&sqlCreateCols,"id INTEGER PRIMARY KEY,"); //First add the ID.
    for (cont=0;cont<numCols;cont++) //Create sqlCreateCols string.
    {
        cmeFree(sanitizedStr);
        cmeSanitizeStrForSQL(srcMemTable[cont],&sanitizedStr); //Sanitize parameter for use in SQL statement.
        cmeStrConstrAppend(&sqlCreateCols,"'%s' TEXT",sanitizedStr);  //first row, contains the column name.
        cmeStrConstrAppend(&sqlInsertCols,"'%s'",sanitizedStr);
        if ((cont+1) < numCols) //If there is still another element pending, add comma.
        {
           cmeStrConstrAppend(&sqlCreateCols,",");
           cmeStrConstrAppend(&sqlInsertCols,",");
        }
    }
    cmeStrConstrAppend(&sqlInsertQuery,"BEGIN TRANSACTION; CREATE TABLE \"%s\" (%s); COMMIT;",
                       sqlTableName,sqlCreateCols); // Create table 'memtable'
    result=cmeSQLRows(dstMemDB,sqlInsertQuery,NULL,NULL);
    if (result) //Check Error Type
    {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemTableToMemDB(), cmeSQLRows() Error, can't "
                    "create table: %s (%s) !\n",sqlTableName,sqlCreateCols);
#endif
        cmeMemTableToMemDBFree();
        return(1);
    }
    cmeFree(sqlInsertQuery);
    cmeStrConstrAppend(&sqlInsertQuery,"INSERT INTO \"%s\" (%s) VALUES (",sqlTableName,sqlInsertCols);
    for (cont=0;cont<numCols;cont++)
    {
        cmeStrConstrAppend(&sqlInsertQuery,"?");
        if ((cont+1)<numCols)
        {
            cmeStrConstrAppend(&sqlInsertQuery,",");
        }
    }
    cmeStrConstrAppend(&sqlInsertQuery,");");
    result=sqlite3_prepare_v2(dstMemDB,sqlInsertQuery,-1,&insertStmt,NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemTableToMemDB(), sqlite3_prepare_v2() Error, can't "
                "prepare insert for table: %s; error: %s !\n",sqlTableName,sqlite3_errmsg(dstMemDB));
#endif
        cmeMemTableToMemDBFree();
        return(2);
    }
    for (cont=0; cont <= rowsBlocks; cont++) //process all full blocks plus the final partial block.
    {
        rowsInBlock=(cont<rowsBlocks) ? cmeDefaultInsertSqlRows : rowsLastBlock;
        if (!rowsInBlock)
        {
            continue;
        }
        if (cmeSQLRows(dstMemDB,"BEGIN TRANSACTION;",NULL,NULL))
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemTableToMemDB(), cmeSQLRows() Error, can't "
                    "begin transaction for table: %s !\n",sqlTableName);
#endif
            cmeMemTableToMemDBFree();
            return(3);
        }
        for (cont2=0; cont2 < rowsInBlock; cont2++) //Process all rows.
        {
            for (bindCol=0; bindCol<numCols; bindCol++) //Bind all fields in row.
            {
                result=sqlite3_bind_text(insertStmt,bindCol+1,srcMemTable[(currentRow*numCols)+bindCol],-1,SQLITE_TRANSIENT);
                if (result!=SQLITE_OK)
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemTableToMemDB(), sqlite3_bind_text() Error, can't "
                            "bind value %d for table: %s; error: %s !\n",bindCol+1,sqlTableName,sqlite3_errmsg(dstMemDB));
#endif
                    cmeSQLRows(dstMemDB,"ROLLBACK;",NULL,NULL);
                    cmeMemTableToMemDBFree();
                    return(4);
                }
            }
            result=sqlite3_step(insertStmt);
            if (result!=SQLITE_DONE)
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemTableToMemDB(), sqlite3_step() Error, can't "
                        "insert values in table: %s; error: %s !\n",sqlTableName,sqlite3_errmsg(dstMemDB));
#endif
                cmeSQLRows(dstMemDB,"ROLLBACK;",NULL,NULL);
                cmeMemTableToMemDBFree();
                return(5);
            }
            sqlite3_reset(insertStmt);
            sqlite3_clear_bindings(insertStmt);
            currentRow++;
        }
        if (cmeSQLRows(dstMemDB,"COMMIT;",NULL,NULL))
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemTableToMemDB(), cmeSQLRows() Error, can't "
                    "commit inserts in table: %s !\n",sqlTableName);
#endif
            cmeSQLRows(dstMemDB,"ROLLBACK;",NULL,NULL);
            cmeMemTableToMemDBFree();
            return(6);
        }
    }
    cmeMemTableToMemDBFree();
    return (0);
}

int cmeMemTableShuffle(char **sqlTable, const int numRows, const int numCols, const int skipHeaderRows,
                       const int skipIdCols)    //Implements Durstenfeld's shuffling algorithm
                                                //http://en.wikipedia.org/wiki/Fisher%E2%80%93Yates_shuffle
{
    int cont, cont2, rndIdx;
    unsigned int randomInt=0;
    unsigned char *prngBuf=NULL;
    unsigned char *prngBufStr=NULL;
    char *valueTmp=NULL;
    #define cmeMemTableShuffleFree() \
        do { \
            cmeFree(prngBuf); \
            cmeFree(prngBufStr); \
            valueTmp=NULL; \
        } while (0); //Local free() macro.

#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemTableShuffle(), preparing to shuffle MemTable with %d rows (not counting header row)"
            " and %d columns; headers to skip: %d; columns to skip: %d.\n",numRows,numCols,skipHeaderRows,
            skipIdCols);
#endif
    for (cont=numRows;cont>=skipHeaderRows; cont--) //Not cont=numRows-1, since we need to consider the header row.
    {
        cmePrngGetBytes(&prngBuf,sizeof(int));
        cmeBytesToHexstr(prngBuf,&prngBufStr,sizeof(int));
        sscanf((char *)prngBufStr,"%X",&randomInt);
        cmeFree(prngBuf);
        cmeFree(prngBufStr);
        rndIdx=(int)(randomInt%numRows);
        if (rndIdx<=(skipHeaderRows-1)) //Hits a row we need to skip.
        {
            rndIdx=(numRows); //Then exchange with a row at the other end.
        }
        for (cont2=(numCols-1);cont2>=skipIdCols;cont2--)
        {
            valueTmp=sqlTable[(cont*numCols)+cont2];
            sqlTable[(cont*numCols)+cont2]=sqlTable[(rndIdx*numCols)+cont2];
            sqlTable[(rndIdx*numCols)+cont2]=valueTmp;
        }
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemTableShuffle(), finished shuffling MemTable with %d rows"
            " and %d columns; headers to skip: %d; columns to skip: %d.\n",numRows,numCols,skipHeaderRows,
            skipIdCols);
#endif
    cmeMemTableShuffleFree();
    return (0);
}

int cmeMemTableOrder(char **sqlTable, const int numRows, const int numCols, const int orderIdxCol, const int skipHeaderRows,
                       const int skipIdCols)
{
    int cont,cont2,cont3;
    char *valueTmp=NULL;
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemTableOrder(), preparing to reorder MemTable with %d rows (not counting header row)"
            " and %d columns; headers to skip: %d; columns to skip: %d.\n",numRows,numCols,skipHeaderRows,
            skipIdCols);
#endif
    for (cont=numRows;cont>=skipHeaderRows; cont--) //Not cont=numRows-1, since we need to consider the header row.
    {
        for (cont2=cont;cont2>=skipHeaderRows; cont2--) //Search every row <= current row for the one that belongs to this position, and swap them.
        {
            if (cont==atoi(sqlTable[(cont2*numCols)+orderIdxCol])) //We found the right row. Swap and break.
            {
                for (cont3=(numCols-1);cont3>=skipIdCols;cont3--)
                {
                    valueTmp=sqlTable[(cont*numCols)+cont3];
                    sqlTable[(cont*numCols)+cont3]=sqlTable[(cont2*numCols)+cont3];
                    sqlTable[(cont2*numCols)+cont3]=valueTmp;
                }
                break;
            }
        }
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemTableOrder(), finished ordering MemTable with %d rows"
            " and %d columns; headers to skip: %d; columns to skip: %d.\n",numRows,numCols,skipHeaderRows,
            skipIdCols);
#endif
    return (0);
}

static int cmeMemSecureDBStoreValueHMAC(sqlite3 *memSecureDB, char **memData,
                                        int numRowsData, char **currentDataSalt,
                                        const char *orgKey, const char *targetColumn,
                                        const char *attributeName, int computeError,
                                        int updateError)
{
    int cont,result,written;
    char *currentDataId=NULL;
    char *currentDataMAC=NULL;
    char *sqlQuery=NULL;
    sqlite3_stmt *updateDataStmt=NULL;
    #define cmeMemSecureDBStoreValueHMACFree() \
        do { \
            if (updateDataStmt) { sqlite3_finalize(updateDataStmt); updateDataStmt=NULL; } \
            cmeFree(currentDataId); \
            cmeFree(currentDataMAC); \
            cmeFree(sqlQuery); \
        } while (0)

    cmeStrConstrAppend(&sqlQuery,"UPDATE data SET %s=? WHERE id=?;",targetColumn);
    result=sqlite3_prepare_v2(memSecureDB,sqlQuery,-1,&updateDataStmt,NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_prepare_v2() Error"
                " can't prepare %s update: %s !\n",attributeName,sqlite3_errmsg(memSecureDB));
#endif
        cmeMemSecureDBStoreValueHMACFree();
        return(computeError);
    }
    for(cont=1;cont<=numRowsData;cont++)
    {
        cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cmeIDDColumnFileDataNumCols*cont+cmeIDDanydb_id]));
        result=cmeHMACByteString(
            (const unsigned char*)memData[cmeIDDColumnFileDataNumCols*cont+cmeIDDColumnFileData_value],
            (unsigned char**)&currentDataMAC,
            strlen(memData[cmeIDDColumnFileDataNumCols*cont+cmeIDDColumnFileData_value]),
            &written,cmeDefaultMACAlg,&(currentDataSalt[cont-1]),orgKey);
        if (result)
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeHMACByteString() Error, can't "
                    "compute %s for 'value' in data row id %s with algorithm %s!\n",
                    attributeName,currentDataId,cmeDefaultMACAlg);
#endif
            cmeMemSecureDBStoreValueHMACFree();
            return(computeError);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), computed %s"
                " for 'value' in row id %s. macLen=%d.\n",attributeName,currentDataId,written);
#endif
        if (cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeSQLRows() Error, can't "
                    "begin %s update transaction for data row id %s!\n",attributeName,currentDataId);
#endif
            cmeMemSecureDBStoreValueHMACFree();
            return(updateError);
        }
        result=sqlite3_bind_text(updateDataStmt,1,currentDataMAC,-1,SQLITE_TRANSIENT);
        if (result==SQLITE_OK)
        {
            result=sqlite3_bind_int(updateDataStmt,2,atoi(currentDataId));
        }
        cmeFree(currentDataMAC);
        if (result==SQLITE_OK)
        {
            result=sqlite3_step(updateDataStmt);
        }
        if (result!=SQLITE_DONE)
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_step() Error, can't "
                    "store %s for data row id %s: %s!\n",attributeName,currentDataId,sqlite3_errmsg(memSecureDB));
#endif
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeMemSecureDBStoreValueHMACFree();
            return(updateError);
        }
        sqlite3_reset(updateDataStmt);
        sqlite3_clear_bindings(updateDataStmt);
        if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeSQLRows() Error, can't "
                    "commit %s update transaction for data row id %s!\n",attributeName,currentDataId);
#endif
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeMemSecureDBStoreValueHMACFree();
            return(updateError);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), stored %s for row id %s in table data.\n",
                attributeName,currentDataId);
#endif
        cmeFree(currentDataId);
    }
    cmeMemSecureDBStoreValueHMACFree();
    return(0);
}

int cmeMemSecureDBProtect (sqlite3 *memSecureDB, const char *orgKey)
{
    int cont,result,written;
    int cont2=0;
    int numColsData=0;
    int numRowsData=0;
    int numColsPMeta=0;
    int numRowsPMeta=0;
    char **memData=NULL;
    char **memProtectMetaData=NULL;
    char **currentDataSalt=NULL;
    char *currentEncB64Data=NULL;
    char *currentMetaAttribute=NULL;
    char *currentMetaAttributeData=NULL;
    char *currentMetaId=NULL;
    char *currentMetaSalt=NULL;
    char *currentMetaUserId=NULL;
    char *currentMetaOrgId=NULL;
    char *currentDataId=NULL;
    char *currentDataEncAlg=NULL;
    char *sqlQuery=NULL;
    char *sanitizedStr=NULL;
    unsigned char *rndBytes=NULL;
    char **memDataEncrypted=NULL;
    int numRowsEncrypted=0;
    int numColsEncrypted=0;
    cmeCryptoProfile cryptoProfile;
    sqlite3_stmt *updateDataSaltStmt=NULL;
    sqlite3_stmt *updateDataFullStmt=NULL;
    sqlite3_stmt *updateDataProtectStmt=NULL;
    sqlite3_stmt *updateMetaProtectStmt=NULL;
    #define cmeMemSecureDBProtectFree() \
        do { \
            if (updateDataSaltStmt) { sqlite3_finalize(updateDataSaltStmt); updateDataSaltStmt=NULL; } \
            if (updateDataFullStmt) { sqlite3_finalize(updateDataFullStmt); updateDataFullStmt=NULL; } \
            if (updateDataProtectStmt) { sqlite3_finalize(updateDataProtectStmt); updateDataProtectStmt=NULL; } \
            if (updateMetaProtectStmt) { sqlite3_finalize(updateMetaProtectStmt); updateMetaProtectStmt=NULL; } \
            cmeFree(currentEncB64Data); \
            cmeFree(currentMetaAttribute); \
            cmeFree(currentMetaAttributeData); \
            cmeFree(currentMetaId); \
            cmeFree(currentMetaSalt); \
            cmeFree(currentMetaUserId); \
            cmeFree(currentMetaOrgId); \
            cmeFree(currentDataId); \
            cmeFree(currentDataEncAlg); \
            cmeFree(sqlQuery); \
            cmeFree(sanitizedStr); \
            cmeFree(rndBytes); \
            if (memData) \
            { \
                cmeMemTableFinal(memData); \
                memData=NULL; \
            } \
            if (memProtectMetaData) \
            { \
                cmeMemTableFinal(memProtectMetaData); \
                memProtectMetaData=NULL; \
            } \
            if (memDataEncrypted) \
            { \
                cmeMemTableFinal(memDataEncrypted); \
                memDataEncrypted=NULL; \
            } \
            if (currentDataSalt) \
            { \
                for (cont=0;cont<numRowsData;cont++) \
                { \
                    cmeFree(currentDataSalt[cont]); \
                } \
                cmeFree(currentDataSalt); \
            } \
        } while (0); //Local free() macro.

    //Get information from table meta (we assume tables meta and data have not been protected yet).
    result=cmeMemTable(memSecureDB,"SELECT * FROM meta;",&memProtectMetaData,&numRowsPMeta,&numColsPMeta);
    if (result) //Error
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeMemTable() Error"
                " can't execute 'SELECT * FROM meta;'!\n");
#endif
        cmeMemSecureDBProtectFree();
        return(1);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), cmeMemTable() loaded memSecureDB, table meta.\n");
#endif
    //Get information from table data (we assume tables meta and data have not been protected yet).
    result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memData,&numRowsData,&numColsData);
    if (result) //Error
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeMemTable() Error"
                " can't execute 'SELECT * FROM data;'!\n");
#endif
        cmeMemSecureDBProtectFree();
        return(2);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), cmeMemTable() loaded memSecureDB, table data.\n");
#endif
    //Create salt array for data and update in data table. We skip first row of headers.
    currentDataSalt=(char **)malloc(sizeof(char **)*(numRowsData));  //Salt array will be freed at the end of function.
    result=sqlite3_prepare_v2(memSecureDB,"UPDATE data SET salt=? WHERE id=?;",-1,&updateDataSaltStmt,NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_prepare_v2() Error"
                " can't prepare salt update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
        cmeMemSecureDBProtectFree();
        return(3);
    }
    if (cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeSQLRows() Error"
                " can't begin salt update transaction!\n");
#endif
        cmeMemSecureDBProtectFree();
        return(3);
    }
    for (cont=1;cont<=numRowsData;cont++)
    {
        cmeGetRndSaltAnySize(&(currentDataSalt[cont-1]),cmeDefaultSecureDBSaltLen);
        //Update Salt info in data table.
        cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cmeIDDColumnFileDataNumCols*cont+cmeIDDanydb_id])); //sanitize currentDataId with atoi()
        result=sqlite3_bind_text(updateDataSaltStmt,1,currentDataSalt[cont-1],-1,SQLITE_TRANSIENT);
        if (result==SQLITE_OK)
        {
            result=sqlite3_bind_int(updateDataSaltStmt,2,atoi(currentDataId));
        }
        if (result==SQLITE_OK)
        {
            result=sqlite3_step(updateDataSaltStmt);
        }
        if (result!=SQLITE_DONE)
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_step() Error"
                    " can't update salt for data id %s: %s !\n",currentDataId,sqlite3_errmsg(memSecureDB));
#endif
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeMemSecureDBProtectFree();
            return(3);
        }
        sqlite3_reset(updateDataSaltStmt);
        sqlite3_clear_bindings(updateDataSaltStmt);
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), updated 'salt' in data table "
                " for id: %s.\n",currentDataId);
#endif
        cmeFree(currentDataId);
    }
    if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeSQLRows() Error"
                " can't commit salt update transaction!\n");
#endif
        cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
        cmeMemSecureDBProtectFree();
        return(3);
    }
    //Apply each protection mecanism to the table:
    result=sqlite3_prepare_v2(memSecureDB,
                              "UPDATE meta SET attribute=?,attributeData=?,userId=?,orgId=?,salt=? WHERE id=?;",
                              -1,&updateMetaProtectStmt,NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_prepare_v2() Error"
                " can't prepare protected meta update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
        cmeMemSecureDBProtectFree();
        return(17);
    }
    for (cont=1; cont<=numRowsPMeta; cont++) //Iterate on each protection row in meta.
    {
        cmeGetRndSaltAnySize(&currentMetaSalt,cmeDefaultSecureDBSaltLen);

        cmeStrConstrAppend(&currentMetaAttribute,"%s",memProtectMetaData[cont*              //Get meta.attribute
                           cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute]);
        cmeStrConstrAppend(&currentMetaAttributeData,"%s",memProtectMetaData[cont*          //Get meta.attributeData
                           cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attributeData]);
        cmeStrConstrAppend(&currentMetaUserId,"%s",memProtectMetaData[cont*
                           cmeIDDColumnFileMetaNumCols+cmeIDDanydb_userId]);                //Get meta.userId
        cmeStrConstrAppend(&currentMetaOrgId,"%s",memProtectMetaData[cont*
                           cmeIDDColumnFileMetaNumCols+cmeIDDanydb_orgId]);                 //Get meta.orgId
        cmeStrConstrAppend(&currentMetaId,"%d",atoi(memProtectMetaData[cont*
                           cmeIDDColumnFileMetaNumCols+cmeIDDanydb_id]));                   //Get meta.id; sanitize it with atoi().
        // Check if protection attribute = "name".
        if (!strncmp(memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute],
                     cmeIDDColumnFileMeta_attribute_0, sizeof(cmeIDDColumnFileMeta_attribute_0)))
        {
#ifdef DEBUG
            fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(): 'name' will be protected by default in Meta.\n");
#endif
        }
        // Check if protection attribute = "shuffle".
        else if (!strncmp(memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute],
                     cmeIDDColumnFileMeta_attribute_1, sizeof(cmeIDDColumnFileMeta_attribute_1)))
        {
            cmeMemTableShuffle(memData,numRowsData,numColsData,1,1);
#ifdef DEBUG
            fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), shuffle protection applied to table Data.\n");
#endif
            result=sqlite3_prepare_v2(memSecureDB,
                                      "UPDATE data SET userId=?,orgId=?,salt=?,value=?,rowOrder=?,MAC=?,"
                                      "MACProtected=?,sign=?,signProtected=?,otphDkey=? WHERE id=?;",
                                      -1,&updateDataFullStmt,NULL);
            if (result!=SQLITE_OK)
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_prepare_v2() Error"
                        " can't prepare full data update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
                cmeMemSecureDBProtectFree();
                return(6);
            }
            for(cont2=1;cont2<=numRowsData;cont2++) //Updates all shuffled rows (leaves column 'id' untouched); protects 'rowOrder'.
            {
                cmeStrConstrAppend(&currentDataEncAlg,"%s",memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+
                               cmeIDDColumnFileMeta_attributeData]); //Get encryption algorithm.
                result=cmeGetCryptoProfile(&cryptoProfile,currentDataEncAlg);
                if (!result && cryptoProfile.implemented) //OK, supported algorithm
                {
                    //Encrypt rowOrder and update memSQL table Data:
                    cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id])); //Sanitize id with atoi().
                    //Protect 'rowOrder' (data table):
                    result=cmeProtectDBSaltedValue(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_rowOrder], &currentEncB64Data,
                                             currentDataEncAlg, &(currentDataSalt[cont2-1]), orgKey, &written);
                    if (result) //Error
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeProtectDBSaltedValue() Error, can't "
                                "protect 'rowOrder' in data table: valueLen=%zu with algorithm %s!\n",
                                strlen(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_rowOrder]),currentDataEncAlg);
#endif
                        cmeMemSecureDBProtectFree();
                        return(5);
                    }
#ifdef DEBUG
                    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected"
                            " 'rowOrder'. protectedLen=%d.\n",written);
#endif
                    result=sqlite3_bind_text(updateDataFullStmt,1,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_userId],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,2,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_orgId],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,3,currentDataSalt[cont2-1],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,4,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,5,currentEncB64Data,-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,6,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_MAC],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,7,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_MACProtected],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,8,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_sign],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,9,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_signProtected],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,10,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_otphDKey],-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_int(updateDataFullStmt,11,atoi(currentDataId));
                    cmeFree(currentEncB64Data);
                    if (result==SQLITE_OK && cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
                    {
                        result=SQLITE_ERROR;
                    }
                    if (result==SQLITE_OK)
                    {
                        result=sqlite3_step(updateDataFullStmt);
                    }
                    if (result!=SQLITE_DONE) //Error
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_step() Error"
                                " can't update shuffled data row id %s: %s !\n",currentDataId,sqlite3_errmsg(memSecureDB));
#endif
                        cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                        cmeMemSecureDBProtectFree();
                        return(6);
                    }
                    sqlite3_reset(updateDataFullStmt);
                    sqlite3_clear_bindings(updateDataFullStmt);
                    if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeSQLRows() Error"
                                " can't commit shuffled data row id %s update!\n",currentDataId);
#endif
                        cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                        cmeMemSecureDBProtectFree();
                        return(6);
                    }
#ifdef DEBUG
                    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), shuffle-protected row with id %s in table data.\n",
                            currentDataId);
#endif
                    cmeFree(currentDataId);
                    cmeFree(currentDataEncAlg);
                }
                else //Error: unsupported/unknown algorithm!
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), Error, can't "
                            "protect 'rowOrder' in data table: valueLen=%zu with algorithm %s!\n",
                            strlen(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value]),currentDataEncAlg);
#endif
                    cmeMemSecureDBProtectFree();
                    return(7);
                }
            }
            sqlite3_finalize(updateDataFullStmt);
            updateDataFullStmt=NULL;
        }
        // Check if protection attribute = "protect".
        else if (!strncmp(memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute],
                 cmeIDDColumnFileMeta_attribute_2, sizeof(cmeIDDColumnFileMeta_attribute_2)))
        {
            //Protect 'value' column in Data table, use random salt for each 'value' and store it as well:
            cmeStrConstrAppend(&currentDataEncAlg,"%s",memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+
                               cmeIDDColumnFileMeta_attributeData]); //Get encryption algorithm.
            result=cmeGetCryptoProfile(&cryptoProfile,currentDataEncAlg);
            if (!result && cryptoProfile.implemented) //OK, supported algorithm
            {
                result=sqlite3_prepare_v2(memSecureDB,
                                          "UPDATE data SET value=?,userId=?,orgId=? WHERE id=?;",
                                          -1,&updateDataProtectStmt,NULL);
                if (result!=SQLITE_OK)
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_prepare_v2() Error"
                            " can't prepare protected data update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
                    cmeMemSecureDBProtectFree();
                    return(11);
                }
                for(cont2=1;cont2<=numRowsData;cont2++)  //We skip the header row.
                {
                    cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id])); //Sanitize using atoi();
                    //Protect 'value' (data table):
                    result=cmeProtectDBSaltedValue(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value], &currentEncB64Data,
                                             currentDataEncAlg, &(currentDataSalt[cont2-1]), orgKey, &written);
                    if (result) //Error
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeProtectDBSaltedValue() Error, can't "
                                "protect 'value' in data table: valueLen=%zu with algorithm %s!\n",
                                strlen(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value]),currentDataEncAlg);
#endif
                        cmeMemSecureDBProtectFree();
                        return(8);
                    }
#ifdef DEBUG
                    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected"
                            " 'value'. protectedLen=%d.\n",written);
#endif
                    result=sqlite3_bind_text(updateDataProtectStmt,1,currentEncB64Data,-1,SQLITE_TRANSIENT);
                    cmeFree(currentEncB64Data);
                    if (result!=SQLITE_OK)
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_bind_text() Error"
                                " can't bind protected value for data row id %s: %s !\n",currentDataId,sqlite3_errmsg(memSecureDB));
#endif
                        cmeMemSecureDBProtectFree();
                        return(11);
                    }
                    //Protect 'userId' (data table):
                    result=cmeProtectDBSaltedValue (memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_userId], &currentEncB64Data,
                                              currentDataEncAlg, &(currentDataSalt[cont2-1]), orgKey, &written);
                    if (result) //Error
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeProtectDBSaltedValue() Error, can't "
                                "protect 'userId' in data table: valueLen=%zu with algorithm %s!\n",
                                strlen(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_userId]),currentDataEncAlg);
#endif
                        cmeMemSecureDBProtectFree();
                        return(9);
                    }
#ifdef DEBUG
                    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected"
                            " 'userId'. protectedLen=%d.\n",written);
#endif
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataProtectStmt,2,currentEncB64Data,-1,SQLITE_TRANSIENT);
                    cmeFree(currentEncB64Data);
                    if (result!=SQLITE_OK)
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_bind_text() Error"
                                " can't bind protected userId for data row id %s: %s !\n",currentDataId,sqlite3_errmsg(memSecureDB));
#endif
                        cmeMemSecureDBProtectFree();
                        return(11);
                    }
                    //Protect 'orgId' (data table):
                    result=cmeProtectDBSaltedValue(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_orgId], &currentEncB64Data,
                                             currentDataEncAlg, &(currentDataSalt[cont2-1]), orgKey, &written);
                    if (result) //Error
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeProtectDBSaltedValue() Error, can't "
                                "protect 'orgId' in data table: valueLen=%zu with algorithm %s!\n",
                                strlen(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_orgId]),currentDataEncAlg);
#endif
                        cmeMemSecureDBProtectFree();
                        return(10);
                    }
#ifdef DEBUG
                    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected"
                            " 'orgId'. protectedLen=%d.\n",written);
#endif
                    if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataProtectStmt,3,currentEncB64Data,-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK) result=sqlite3_bind_int(updateDataProtectStmt,4,atoi(currentDataId));
                    cmeFree(currentEncB64Data);
                    if (result==SQLITE_OK && cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
                    {
                        result=SQLITE_ERROR;
                    }
                    if (result==SQLITE_OK)
                    {
                        result=sqlite3_step(updateDataProtectStmt);
                    }
                    if (result!=SQLITE_DONE) //Error
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_step() Error"
                                " can't update protected data row id %s: %s !\n",currentDataId,sqlite3_errmsg(memSecureDB));
#endif
                        cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                        cmeMemSecureDBProtectFree();
                        return(11);
                    }
                    sqlite3_reset(updateDataProtectStmt);
                    sqlite3_clear_bindings(updateDataProtectStmt);
                    if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeSQLRows() Error"
                                " can't commit protected data row id %s update!\n",currentDataId);
#endif
                        cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                        cmeMemSecureDBProtectFree();
                        return(11);
                    }
#ifdef DEBUG
                    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected row with id %s in table data.\n",
                            currentDataId);
#endif
                    cmeFree(currentDataId);
                }
                sqlite3_finalize(updateDataProtectStmt);
                updateDataProtectStmt=NULL;
                cmeFree(currentDataEncAlg);
            }
            else //Error: unsupported/unknown algorithm!
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), Error, can't "
                        "protect 'value' in data table: %s with algorithm %s!\n",
                        memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value],currentDataEncAlg);
#endif
                cmeMemSecureDBProtectFree();
                return(12);
            }
        }
        // Check if protection attribute = "sign".
        else if (!strncmp(memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute],
                 cmeIDDColumnFileMeta_attribute_3, sizeof(cmeIDDColumnFileMeta_attribute_3)))
        {
            //Compute a keyed signature of the plaintext value and store it in sign for each data row.
            //memData snapshot always contains the original plaintext values taken before any protection.
            result=cmeMemSecureDBStoreValueHMAC(memSecureDB,memData,numRowsData,currentDataSalt,
                                                orgKey,cmeIDDColumnFileData_sign_name,
                                                cmeIDDColumnFileMeta_attribute_3,26,27);
            if (result)
            {
                cmeMemSecureDBProtectFree();
                return(result);
            }
        }
        // Check if protection attribute = "signProtected".
        else if (!strncmp(memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute],
                     cmeIDDColumnFileMeta_attribute_4, sizeof(cmeIDDColumnFileMeta_attribute_4)))
        {
            //Compute a keyed signature of the encrypted value and store it in signProtected for each data row.
            //Re-reads current (already-encrypted) values from DB since memData snapshot contains plaintext.
            result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memDataEncrypted,&numRowsEncrypted,&numColsEncrypted);
            if (result) //Error
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeMemTable() Error, can't "
                        "read 'data' table for signProtected computation!\n");
#endif
                cmeMemSecureDBProtectFree();
                return(28);
            }
            result=cmeMemSecureDBStoreValueHMAC(memSecureDB,memDataEncrypted,numRowsData,currentDataSalt,
                                                orgKey,cmeIDDColumnFileData_signProtected_name,
                                                cmeIDDColumnFileMeta_attribute_4,29,30);
            if (result)
            {
                cmeMemSecureDBProtectFree();
                return(result);
            }
            cmeMemTableFinal(memDataEncrypted);
            memDataEncrypted=NULL;
        }
        // Check if protection attribute = "MAC".
        else if (!strncmp(memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute],
                     cmeIDDColumnFileMeta_attribute_5, sizeof(cmeIDDColumnFileMeta_attribute_5)))
        {
            //Compute HMAC of plaintext value and store in MAC column for each data row.
            //memData snapshot always contains the original plaintext values taken before any protection.
            result=cmeMemSecureDBStoreValueHMAC(memSecureDB,memData,numRowsData,currentDataSalt,
                                                orgKey,cmeIDDColumnFileData_MAC_name,
                                                cmeIDDColumnFileMeta_attribute_5,21,22);
            if (result)
            {
                cmeMemSecureDBProtectFree();
                return(result);
            }
        }
        // Check if protection attribute = "MACProtected".
        else if (!strncmp(memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute],
                     cmeIDDColumnFileMeta_attribute_6, sizeof(cmeIDDColumnFileMeta_attribute_6)))
        {
            //Compute HMAC of the encrypted value and store in MACProtected column for each data row.
            //Re-reads current (already-encrypted) values from DB since memData snapshot contains plaintext.
            result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memDataEncrypted,&numRowsEncrypted,&numColsEncrypted);
            if (result) //Error
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeMemTable() Error, can't "
                        "read 'data' table for MACProtected computation!\n");
#endif
                cmeMemSecureDBProtectFree();
                return(23);
            }
            result=cmeMemSecureDBStoreValueHMAC(memSecureDB,memDataEncrypted,numRowsData,currentDataSalt,
                                                orgKey,cmeIDDColumnFileData_MACProtected_name,
                                                cmeIDDColumnFileMeta_attribute_6,24,25);
            if (result)
            {
                cmeMemSecureDBProtectFree();
                return(result);
            }
            cmeMemTableFinal(memDataEncrypted);
            memDataEncrypted=NULL;
        }
        //Finally, protect columnFile.Meta attribute, attributeData, userId and orgId in each row in meta table.
        //Protect Meta "attribute":
        result=cmeProtectDBSaltedValue(currentMetaAttribute, &currentEncB64Data,
                                 cmeDefaultEncAlg, &currentMetaSalt, orgKey, &written);
        if (result) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeProtectDBSaltedValue() Error, can't "
                    "protect Meta attribute: valueLen=%zu with algorithm %s!\n",strlen(currentMetaAttribute),cmeDefaultEncAlg);
#endif
            cmeMemSecureDBProtectFree();
            return(13);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected"
                " Meta attribute. protectedLen=%d.\n",written);
#endif
        result=sqlite3_bind_text(updateMetaProtectStmt,1,currentEncB64Data,-1,SQLITE_TRANSIENT);
        cmeFree(currentEncB64Data);
        if (result!=SQLITE_OK)
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_bind_text() Error"
                    " can't bind protected Meta attribute for row id %s: %s !\n",currentMetaId,sqlite3_errmsg(memSecureDB));
#endif
            cmeMemSecureDBProtectFree();
            return(17);
        }
        //Protect Meta "attributeData":
        result=cmeProtectDBSaltedValue(currentMetaAttributeData, &currentEncB64Data,
                                cmeDefaultEncAlg, &currentMetaSalt, orgKey, &written);
        if (result) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeProtectDBSaltedValue() Error, can't "
                    "protect Meta attributeData: valueLen=%zu with algorithm %s!\n",strlen(currentMetaAttributeData),cmeDefaultEncAlg);
#endif
            cmeMemSecureDBProtectFree();
            return(14);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected"
                " Meta attributeData. protectedLen=%d.\n",written);
#endif
        result=sqlite3_bind_text(updateMetaProtectStmt,2,currentEncB64Data,-1,SQLITE_TRANSIENT);
        cmeFree(currentEncB64Data);
        if (result!=SQLITE_OK)
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_bind_text() Error"
                    " can't bind protected Meta attributeData for row id %s: %s !\n",currentMetaId,sqlite3_errmsg(memSecureDB));
#endif
            cmeMemSecureDBProtectFree();
            return(17);
        }
        //Protect Meta "userId":
        result=cmeProtectDBSaltedValue(currentMetaUserId, &currentEncB64Data,
                                cmeDefaultEncAlg, &currentMetaSalt, orgKey, &written);
        if (result) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeProtectDBSaltedValue() Error, can't "
                    "protect Meta userId: valueLen=%zu with algorithm %s!\n",strlen(currentMetaUserId),cmeDefaultEncAlg);
#endif
            cmeMemSecureDBProtectFree();
            return(15);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected"
                " Meta userId. protectedLen=%d.\n",written);
#endif
        result=sqlite3_bind_text(updateMetaProtectStmt,3,currentEncB64Data,-1,SQLITE_TRANSIENT);
        cmeFree(currentEncB64Data);
        if (result!=SQLITE_OK)
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_bind_text() Error"
                    " can't bind protected Meta userId for row id %s: %s !\n",currentMetaId,sqlite3_errmsg(memSecureDB));
#endif
            cmeMemSecureDBProtectFree();
            return(17);
        }
        //Protect Meta "orgId":
        result=cmeProtectDBSaltedValue(currentMetaOrgId, &currentEncB64Data,
                                cmeDefaultEncAlg, &currentMetaSalt, orgKey, &written);
        if (result) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeProtectDBSaltedValue() Error, can't "
                    "protect Meta orgId: valueLen=%zu with algorithm %s!\n",strlen(currentMetaOrgId),cmeDefaultEncAlg);
#endif
            cmeMemSecureDBProtectFree();
            return(16);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected"
                " Meta orgId. protectedLen=%d.\n",written);
#endif
        result=sqlite3_bind_text(updateMetaProtectStmt,4,currentEncB64Data,-1,SQLITE_TRANSIENT);
        cmeFree(currentEncB64Data);
        if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaProtectStmt,5,currentMetaSalt,-1,SQLITE_TRANSIENT);
        if (result==SQLITE_OK) result=sqlite3_bind_int(updateMetaProtectStmt,6,atoi(currentMetaId));
        if (result==SQLITE_OK && cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
        {
            result=SQLITE_ERROR;
        }
        if (result==SQLITE_OK)
        {
            result=sqlite3_step(updateMetaProtectStmt);
        }
        if (result!=SQLITE_DONE) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), sqlite3_step() Error"
                    " can't update protected meta row id %s: %s !\n",currentMetaId,sqlite3_errmsg(memSecureDB));
#endif
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeMemSecureDBProtectFree();
            return(17);
        }
        sqlite3_reset(updateMetaProtectStmt);
        sqlite3_clear_bindings(updateMetaProtectStmt);
        if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBProtect(), cmeSQLRows() Error"
                    " can't commit protected meta row id %s update!\n",currentMetaId);
#endif
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeMemSecureDBProtectFree();
            return(17);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBProtect(), protected row with id %s in table meta.\n",
                currentMetaId);
#endif
        //Free stuff in this FOR loop
        cmeFree(currentMetaAttribute);
        cmeFree(currentMetaAttributeData);
        cmeFree(currentMetaId);
        cmeFree(currentMetaSalt);
        cmeFree(currentMetaUserId);
        cmeFree(currentMetaOrgId);
    }
    sqlite3_finalize(updateMetaProtectStmt);
    updateMetaProtectStmt=NULL;
    cmeMemSecureDBProtectFree();
    return (0);
}

int cmeMemSecureDBUnprotect (sqlite3 *memSecureDB, const char *orgKey)
{
    int cont,cont2,result,written;
    int numColsData=0;
    int numRowsData=0;
    int numColsPMeta=0;
    int numRowsPMeta=0;
    char **memData=NULL;
    char **memProtectMetaData=NULL;
    char *currentData=NULL;
    char *currentEncB64Data=NULL;
    char *currentMetaAttribute=NULL;
    char *currentMetaAttributeData=NULL;
    char *currentMetaId=NULL;
    char *currentMetaSalt=NULL;
    char *currentMetaUserId=NULL;
    char *currentMetaOrgId=NULL;
    char *currentDataUserId=NULL;
    char *currentDataOrgId=NULL;
    char *currentDataId=NULL;
    char *currentDataSalt=NULL;
    char *currentDataEncAlg=NULL;
    char *sanitizedStr=NULL;
    char *sqlQuery=NULL;
    char **memDataDecrypted=NULL;
    int numRowsDecrypted=0;
    int numColsDecrypted=0;
    cmeCryptoProfile cryptoProfile;
    sqlite3_stmt *updateDataRowOrderStmt=NULL;
    sqlite3_stmt *updateDataFullStmt=NULL;
    sqlite3_stmt *updateDataUserOrgSaltStmt=NULL;
    sqlite3_stmt *updateDataValueStmt=NULL;
    sqlite3_stmt *updateMetaUnprotectStmt=NULL;
    //MEMORY CLEANUP MACRO for local function.
    #define cmeMemSecureDBUnprotectFree() \
        do { \
            if (updateDataRowOrderStmt) { sqlite3_finalize(updateDataRowOrderStmt); updateDataRowOrderStmt=NULL; } \
            if (updateDataFullStmt) { sqlite3_finalize(updateDataFullStmt); updateDataFullStmt=NULL; } \
            if (updateDataUserOrgSaltStmt) { sqlite3_finalize(updateDataUserOrgSaltStmt); updateDataUserOrgSaltStmt=NULL; } \
            if (updateDataValueStmt) { sqlite3_finalize(updateDataValueStmt); updateDataValueStmt=NULL; } \
            if (updateMetaUnprotectStmt) { sqlite3_finalize(updateMetaUnprotectStmt); updateMetaUnprotectStmt=NULL; } \
            cmeFree(currentData); \
            cmeFree(currentEncB64Data); \
            cmeFree(currentMetaAttribute); \
            cmeFree(currentMetaAttributeData); \
            cmeFree(currentMetaId); \
            cmeFree(currentMetaSalt); \
            cmeFree(currentMetaUserId); \
            cmeFree(currentMetaOrgId); \
            cmeFree(currentDataUserId); \
            cmeFree(currentDataOrgId); \
            cmeFree(currentDataSalt); \
            cmeFree(currentDataEncAlg); \
            cmeFree(sanitizedStr); \
            cmeFree(sqlQuery); \
            if (memData) \
            { \
                cmeMemTableFinal(memData); \
                memData=NULL; \
            } \
            if (memProtectMetaData) \
            { \
                cmeMemTableFinal(memProtectMetaData); \
                memProtectMetaData=NULL; \
            } \
            if (memDataDecrypted) \
            { \
                cmeMemTableFinal(memDataDecrypted); \
                memDataDecrypted=NULL; \
            } \
        } while (0); //Local free() macro.

    //Get information from table meta (we assume tables meta and data are protected).
    result=cmeMemTable(memSecureDB,"SELECT * FROM meta;",&memProtectMetaData,&numRowsPMeta,&numColsPMeta);
    if (result) //Error
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeMemTable() Error "
                "can't execute 'SELECT * FROM meta;'!\n");
#endif
        cmeMemSecureDBUnprotectFree();
        return(1);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), cmeMemTable() loaded memSecureDB, table meta.\n");
#endif
    //Get information from table data (we assume tables meta and data are protected).
    result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memData,&numRowsData,&numColsData);
    if (result) //Error
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeMemTable() Error "
                "can't execute 'SELECT * FROM data;'!\n");
#endif
        cmeMemSecureDBUnprotectFree();
        return(2);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), cmeMemTable() loaded memSecureDB, table data.\n");
#endif
    //Unprotect and reverse on table data, each protection mechanism defined in table meta.
    result=sqlite3_prepare_v2(memSecureDB,
                              "UPDATE meta SET attribute=?,attributeData=?,userId=?,orgId=?,salt=? WHERE id=?;",
                              -1,&updateMetaUnprotectStmt,NULL);
    if (result!=SQLITE_OK)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_prepare_v2() Error"
                " can't prepare unprotected meta update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
        cmeMemSecureDBUnprotectFree();
        return(7);
    }
    for (cont=1; cont<=numRowsPMeta; cont++) //Iterate on each protection row in meta.
    {
        cmeStrConstrAppend(&currentMetaSalt,"%s",memProtectMetaData[cont*              //Get meta.salt
                           cmeIDDColumnFileMetaNumCols+cmeIDDanydb_salt]);
        cmeStrConstrAppend(&currentEncB64Data,"%s",memProtectMetaData[cont*            //Get prot. meta.attribute
                           cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute]);
        result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentMetaAttribute,cmeDefaultEncAlg,&currentMetaSalt,orgKey,&written);
        if (result) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                    "decrypt 'attribute' in meta table, protectedLen=%zu with algorithm %s!\n",
                    strlen(currentEncB64Data),cmeDefaultEncAlg);
#endif
            cmeMemSecureDBUnprotectFree();
            return(3);
        }
        cmeFree(currentEncB64Data);
        cmeStrConstrAppend(&currentEncB64Data,"%s",memProtectMetaData[cont*            //Get prot. meta.attributeData
                           cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attributeData]);
        result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentMetaAttributeData,cmeDefaultEncAlg,&currentMetaSalt,orgKey,&written);
        if (result) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                    "decrypt 'attributeData' in meta table, protectedLen=%zu with algorithm %s!\n",
                    strlen(currentEncB64Data),cmeDefaultEncAlg);
#endif
            cmeMemSecureDBUnprotectFree();
            return(4);
        }
        cmeFree(currentEncB64Data);
        cmeStrConstrAppend(&currentEncB64Data,"%s",memProtectMetaData[cont*            //Get prot. meta.userId
                           cmeIDDColumnFileMetaNumCols+cmeIDDanydb_userId]);
        result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentMetaUserId,cmeDefaultEncAlg,&currentMetaSalt,orgKey,&written);
        if (result) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                    "decrypt 'userId' in meta table, protectedLen=%zu with algorithm %s!\n",
                    strlen(currentEncB64Data),cmeDefaultEncAlg);
#endif
            cmeMemSecureDBUnprotectFree();
            return(5);
        }
        cmeFree(currentEncB64Data);
        cmeStrConstrAppend(&currentEncB64Data,"%s",memProtectMetaData[cont*            //Get prot. meta.orgId
                           cmeIDDColumnFileMetaNumCols+cmeIDDanydb_orgId]);
        result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentMetaOrgId,cmeDefaultEncAlg,&currentMetaSalt,orgKey,&written);
        if (result) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                    "decrypt 'orgId' in meta table, protectedLen=%zu with algorithm %s!\n",
                    strlen(currentEncB64Data),cmeDefaultEncAlg);
#endif
            cmeMemSecureDBUnprotectFree();
            return(6);
        }
        cmeFree(currentEncB64Data);
        cmeStrConstrAppend(&currentMetaId,"%d",atoi(memProtectMetaData[cont*            //Get prot. meta.id; sanitize with atoi()
                           cmeIDDColumnFileMetaNumCols+cmeIDDanydb_id]));
        result=sqlite3_bind_text(updateMetaUnprotectStmt,1,currentMetaAttribute,-1,SQLITE_TRANSIENT);
        if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaUnprotectStmt,2,currentMetaAttributeData,-1,SQLITE_TRANSIENT);
        if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaUnprotectStmt,3,currentMetaUserId,-1,SQLITE_TRANSIENT);
        if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaUnprotectStmt,4,currentMetaOrgId,-1,SQLITE_TRANSIENT);
        if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaUnprotectStmt,5,currentMetaSalt,-1,SQLITE_TRANSIENT);
        if (result==SQLITE_OK) result=sqlite3_bind_int(updateMetaUnprotectStmt,6,atoi(currentMetaId));
        if (result==SQLITE_OK && cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
        {
            result=SQLITE_ERROR;
        }
        if (result==SQLITE_OK)
        {
            result=sqlite3_step(updateMetaUnprotectStmt);
        }
        if (result!=SQLITE_DONE) //Error
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_step() Error"
                    " can't update unprotected meta row id %s: %s !\n",currentMetaId,sqlite3_errmsg(memSecureDB));
#endif
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeMemSecureDBUnprotectFree();
            return(7);
        }
        sqlite3_reset(updateMetaUnprotectStmt);
        sqlite3_clear_bindings(updateMetaUnprotectStmt);
        if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
        {
#ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeSQLRows() Error"
                    " can't commit unprotected meta row id %s update!\n",currentMetaId);
#endif
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeMemSecureDBUnprotectFree();
            return(7);
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), unprotected row with id %s in table meta.\n",
                currentMetaId);
#endif
        // Check if protection attribute = "name".
        if (!strncmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_0,
                     sizeof(cmeIDDColumnFileMeta_attribute_0)))
        {
#ifdef DEBUG
            fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(): 'name' will be unprotected by default in Meta.\n");
#endif
        }
        // Check if protection attribute = "shuffle".
        else if (!strncmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_1,
                          sizeof(cmeIDDColumnFileMeta_attribute_1)))
        {
            cmeStrConstrAppend(&currentDataEncAlg,"%s",currentMetaAttributeData); //Get encryption algorithm.
            result=cmeGetCryptoProfile(&cryptoProfile,currentDataEncAlg);
            if (result || !cryptoProfile.implemented) //Error
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), Error, "
                        "unsupported / unknown encryption algorithm: %s!\n",currentDataEncAlg);
#endif
                cmeMemSecureDBUnprotectFree();
                return(8);
            }
            result=sqlite3_prepare_v2(memSecureDB,"UPDATE data SET rowOrder=? WHERE id=?;",-1,&updateDataRowOrderStmt,NULL);
            if (result!=SQLITE_OK)
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_prepare_v2() Error"
                        " can't prepare rowOrder update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
                cmeMemSecureDBUnprotectFree();
                return(10);
            }
            for(cont2=1;cont2<=numRowsData;cont2++) //Updates all shuffled rows (leaves column 'id' untouched); unprotects 'rowOrder'.
            {
                //Decrypt rowOrder and update memSQL table Data.
                cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id])); //sanitize with atoi().
                cmeStrConstrAppend(&currentEncB64Data,"%s",memData[cmeIDDColumnFileDataNumCols*cont2+
                                     cmeIDDColumnFileData_rowOrder]); //Get encrypted B64str.
                //Unprotect 'rowOrder' (data table).

                result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentData,currentDataEncAlg,&(memData[cmeIDDColumnFileDataNumCols*cont2+
                                           cmeIDDanydb_salt]),orgKey,&written);
                cmeFree(currentEncB64Data);
                if (result) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                            "decrypt 'rowOrder' in data table with algorithm %s!\n",currentDataEncAlg);
#endif
                    cmeMemSecureDBUnprotectFree();
                    return(9);
                }
#ifdef DEBUG
                fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), decrypted 'rowOrder' in data table row: "
                        "valueLen=%d, with algorithm: %s.\n",written,currentDataEncAlg);
#endif
                result=sqlite3_bind_int(updateDataRowOrderStmt,1,atoi(currentData));
                if (result==SQLITE_OK)
                {
                    result=sqlite3_bind_int(updateDataRowOrderStmt,2,atoi(currentDataId));
                }
                cmeFree(currentData);
                if (result==SQLITE_OK && cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
                {
                    result=SQLITE_ERROR;
                }
                if (result==SQLITE_OK)
                {
                    result=sqlite3_step(updateDataRowOrderStmt);
                }
                if (result!=SQLITE_DONE) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_step() Error"
                            " can't update rowOrder for data row id %s: %s !\n",currentDataId,sqlite3_errmsg(memSecureDB));
#endif
                    cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                    cmeMemSecureDBUnprotectFree();
                    return(10);
                }
                sqlite3_reset(updateDataRowOrderStmt);
                sqlite3_clear_bindings(updateDataRowOrderStmt);
                if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeSQLRows() Error"
                            " can't commit rowOrder update for data row id %s!\n",currentDataId);
#endif
                    cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                    cmeMemSecureDBUnprotectFree();
                    return(10);
                }
                cmeFree(currentDataId);
            }
            sqlite3_finalize(updateDataRowOrderStmt);
            updateDataRowOrderStmt=NULL;
            cmeFree(currentDataEncAlg);
            cmeMemTableFinal(memData); //Free current table and reload.
            //Get shuffled (rowOrder unprotected) information from table data (we assume rowOrder has been unprotected).
            result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memData,&numRowsData,&numColsData);
            if (result) //Error
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeMemTable() Error"
                        "can't execute 'SELECT * FROM data;' for shuffled data!\n");
#endif
                cmeMemSecureDBUnprotectFree();
                return(11);
            }
#ifdef DEBUG
            fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), cmeMemTable() loaded memSecureDB,"
                    " shuffled, table data.\n");
#endif
            //Unshuffle memory table
            result=cmeMemTableOrder(memData,numRowsData,numColsData,cmeIDDColumnFileData_rowOrder,1,1);
            if (result) //Error
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), cmeMemTableOrder() Error."
                        "Can't reorder shuffled data table; error # %d!\n",result);
#endif
                cmeMemSecureDBUnprotectFree();
                return(12);
            }
#ifdef DEBUG
            fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), shuffle protection removed from table Data.\n");
#endif
            result=sqlite3_prepare_v2(memSecureDB,
                                      "UPDATE data SET userId=?,orgId=?,salt=?,value=?,rowOrder=?,MAC=?,"
                                      "MACProtected=?,sign=?,signProtected=?,otphDkey=? WHERE id=?;",
                                      -1,&updateDataFullStmt,NULL);
            if (result!=SQLITE_OK)
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_prepare_v2() Error"
                        " can't prepare unshuffled data update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
                cmeMemSecureDBUnprotectFree();
                return(13);
            }
            for (cont2=1;cont2<=numRowsData;cont2++) //Save reordered table back to DB.
            {
                result=sqlite3_bind_text(updateDataFullStmt,1,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_userId],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,2,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_orgId],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,3,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_salt],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,4,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,5,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_rowOrder],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,6,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_MAC],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,7,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_MACProtected],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,8,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_sign],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,9,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_signProtected],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataFullStmt,10,memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_otphDKey],-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_int(updateDataFullStmt,11,atoi(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id]));
                if (result==SQLITE_OK && cmeSQLRows(memSecureDB,"BEGIN TRANSACTION;",NULL,NULL))
                {
                    result=SQLITE_ERROR;
                }
                if (result==SQLITE_OK)
                {
                    result=sqlite3_step(updateDataFullStmt);
                }
                if (result!=SQLITE_DONE) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_step() Error"
                            " can't update unshuffled data row id %s: %s !\n",
                            memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id],sqlite3_errmsg(memSecureDB));
#endif
                    cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                    cmeMemSecureDBUnprotectFree();
                    return(13);
                }
                sqlite3_reset(updateDataFullStmt);
                sqlite3_clear_bindings(updateDataFullStmt);
                if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeSQLRows() Error"
                            " can't commit unshuffled data row id %s update!\n",
                            memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id]);
#endif
                    cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                    cmeMemSecureDBUnprotectFree();
                    return(13);
                }
#ifdef DEBUG
                fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), unshuffled row with id %s, in table data.\n",
                        memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id]);
#endif
            }
            sqlite3_finalize(updateDataFullStmt);
            updateDataFullStmt=NULL;
        }
        // Check if protection attribute = "protect".
        else if (!strncmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_2,
                          sizeof(cmeIDDColumnFileMeta_attribute_2)))
        {
            //Unprotect userId,orgId in each row in tabla data.
            result=sqlite3_prepare_v2(memSecureDB,
                                      "UPDATE data SET userId=?,orgId=?,salt=? WHERE id=?;",
                                      -1,&updateDataUserOrgSaltStmt,NULL);
            if (result!=SQLITE_OK)
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_prepare_v2() Error"
                        " can't prepare userId/orgId/salt update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
                cmeMemSecureDBUnprotectFree();
                return(16);
            }
            for(cont2=1;cont2<=numRowsData;cont2++)
            {
                cmeStrConstrAppend(&currentDataSalt,"%s",memData[cont2*              //Get data.salt
                                   cmeIDDColumnFileDataNumCols+cmeIDDanydb_salt]);
                cmeStrConstrAppend(&currentEncB64Data,"%s",memData[cont2*            //Get prot. data.userId
                                   cmeIDDColumnFileDataNumCols+cmeIDDanydb_userId]);

                result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentDataUserId,cmeDefaultEncAlg,&currentDataSalt,orgKey,&written);
                if (result) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                            "decrypt 'userId' in data table, protectedLen=%zu with algorithm %s!\n",
                            strlen(currentEncB64Data),cmeDefaultEncAlg);
#endif
                    cmeMemSecureDBUnprotectFree();
                    return(14);
                }
                cmeFree(currentEncB64Data);
                cmeStrConstrAppend(&currentEncB64Data,"%s",memData[cont2*            //Get prot. data.orgId
                                   cmeIDDColumnFileDataNumCols+cmeIDDanydb_orgId]);
                result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentDataOrgId,cmeDefaultEncAlg,&currentDataSalt,orgKey,&written);
                if (result) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                            "decrypt 'orgId' in data table, protectedLen=%zu with algorithm %s!\n",
                            strlen(currentEncB64Data),cmeDefaultEncAlg);
#endif
                    cmeMemSecureDBUnprotectFree();
                    return(15);
                }
                cmeFree(currentEncB64Data);
                cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cont2*            //Get prot. data.id; sanitize with atoi()
                                   cmeIDDColumnFileDataNumCols+cmeIDDanydb_id]));
                result=sqlite3_bind_text(updateDataUserOrgSaltStmt,1,currentDataUserId,-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataUserOrgSaltStmt,2,currentDataOrgId,-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataUserOrgSaltStmt,3,currentDataSalt,-1,SQLITE_TRANSIENT);
                if (result==SQLITE_OK) result=sqlite3_bind_int(updateDataUserOrgSaltStmt,4,atoi(currentDataId));
                if (result==SQLITE_OK && cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
                {
                    result=SQLITE_ERROR;
                }
                if (result==SQLITE_OK)
                {
                    result=sqlite3_step(updateDataUserOrgSaltStmt);
                }
                if (result!=SQLITE_DONE) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_step() Error"
                            " can't update userId/orgId/salt for data row id %s: %s !\n",
                            currentDataId,sqlite3_errmsg(memSecureDB));
#endif
                    cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                    cmeMemSecureDBUnprotectFree();
                    return(16);
                }
                sqlite3_reset(updateDataUserOrgSaltStmt);
                sqlite3_clear_bindings(updateDataUserOrgSaltStmt);
                if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeSQLRows() Error"
                            " can't commit userId/orgId/salt update for data row id %s!\n",currentDataId);
#endif
                    cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                    cmeMemSecureDBUnprotectFree();
                    return(16);
                }
#ifdef DEBUG
                fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), unprotected userId & orgId in row with id %s, in table data.\n",
                        currentDataId);
#endif
                cmeFree(currentDataId);
                cmeFree(currentDataSalt);
                cmeFree(currentDataUserId);
                cmeFree(currentDataOrgId);
            }
            sqlite3_finalize(updateDataUserOrgSaltStmt);
            updateDataUserOrgSaltStmt=NULL;
            //Unprotect 'value' in data table with corresponding encryption algorithm.
            cmeStrConstrAppend(&currentEncB64Data,"%s",memProtectMetaData[cont*cmeIDDColumnFileMetaNumCols+
                               cmeIDDColumnFileMeta_attributeData]); // Get encrypted, B64 str representation of encr. alg.
            result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentDataEncAlg,cmeDefaultEncAlg,&(memProtectMetaData[cont*
                                        cmeIDDColumnFileMetaNumCols+cmeIDDanydb_salt]),orgKey,&written);
            if (result) //Error
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                        "decrypt encryption algorithm in meta table: protectedLen=%zu with algorithm %s!\n",
                        strlen(currentEncB64Data),cmeDefaultEncAlg);
#endif
                cmeMemSecureDBUnprotectFree();
                return(17);
            }
            cmeFree(currentEncB64Data);
            //Unprotect 'value' column in Data table, using corresponding salt.
            result=cmeGetCryptoProfile(&cryptoProfile,currentDataEncAlg);
            if (!result && cryptoProfile.implemented) //OK, supported algorithm
            {
                result=sqlite3_prepare_v2(memSecureDB,"UPDATE data SET value=? WHERE id=?;",-1,&updateDataValueStmt,NULL);
                if (result!=SQLITE_OK)
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_prepare_v2() Error"
                            " can't prepare value update: %s !\n",sqlite3_errmsg(memSecureDB));
#endif
                    cmeMemSecureDBUnprotectFree();
                    return(19);
                }
                for(cont2=1;cont2<=numRowsData;cont2++)  //We skip the header row.
                {
                    cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id])); //Sanitize with atoi().
                    //Protect 'value (data table).
                    cmeStrConstrAppend(&currentEncB64Data,"%s",memData[cmeIDDColumnFileDataNumCols*cont2+
                                       cmeIDDColumnFileData_value]); // Get encrypted, B64 str representation of encr. alg.
                    result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentData,currentDataEncAlg,&(memData[cmeIDDColumnFileDataNumCols*
                                               cont2+cmeIDDanydb_salt]),orgKey,&written);
                    if (result) //Error
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeUnprotectDBSaltedValue() Error, can't "
                                "decrypt 'value' in data table: protectedLen=%zu with algorithm %s!\n",
                                strlen(currentEncB64Data),currentDataEncAlg);
#endif
                        cmeMemSecureDBUnprotectFree();
                        return(18);
                    }
                    cmeFree(currentEncB64Data);
#ifdef DEBUG
	                    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), decrypted 'value' in data table: "
	                            "valueLen=%d with algorithm %s.\n",written,currentDataEncAlg);
#endif
                    if (cmeSQLRows(memSecureDB,"BEGIN;",NULL,NULL))
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeSQLRows() Error"
                                "can't begin value update transaction for id %s!\n",currentDataId);
#endif
                        cmeMemSecureDBUnprotectFree();
                        return(19);
                    }
                    result=sqlite3_bind_text(updateDataValueStmt,1,currentData,-1,SQLITE_TRANSIENT);
                    if (result==SQLITE_OK)
                    {
                        result=sqlite3_bind_int(updateDataValueStmt,2,atoi(currentDataId));
                    }
	                    memset(currentData,0,strlen(currentData));      // Clear sensitive data
	                    cmeFree(currentData);
                    if (result==SQLITE_OK)
                    {
                        result=sqlite3_step(updateDataValueStmt);
                    }
	                    if (result!=SQLITE_DONE)
	                    {
	#ifdef ERROR_LOG
	                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sqlite3_step() Error"
	                                "can't update value for id %s: %s !\n",currentDataId,sqlite3_errmsg(memSecureDB));
	#endif
                        cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
	                        cmeMemSecureDBUnprotectFree();
	                        return(19);
	                    }
                    sqlite3_reset(updateDataValueStmt);
                    sqlite3_clear_bindings(updateDataValueStmt);
                    if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
                    {
#ifdef ERROR_LOG
                        fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeSQLRows() Error"
                                "can't commit value update transaction for id %s!\n",currentDataId);
#endif
                        cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
                        cmeMemSecureDBUnprotectFree();
                        return(19);
                    }
	#ifdef DEBUG
	                    fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), unprotected 'value' in row with id %s, in table data.\n",
	                            currentDataId);
#endif
	                    cmeFree(currentDataId);
	                }
                sqlite3_finalize(updateDataValueStmt);
                updateDataValueStmt=NULL;
	            }
            else //Error: unsupported/unknown algorithm!
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), Error, "
                        "unsupported / unknown encryption algorithm: %s!\n",currentDataEncAlg);
#endif
                cmeMemSecureDBUnprotectFree();
                return(20);
            }
            cmeFree(currentDataEncAlg);
        }
        // Check if protection attribute = "sign".
        else if (!strncmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_3,
                          sizeof(cmeIDDColumnFileMeta_attribute_3)))
        {
            //Verify keyed signature of decrypted value against stored sign column for each data row.
            //Re-reads current (already-decrypted) values from DB; "protect" unprotect must run first
            //(i.e., "protect" attribute must appear before "sign" in the meta table).
            result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memDataDecrypted,&numRowsDecrypted,&numColsDecrypted);
            if (result) //Error
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeMemTable() Error, can't "
                        "read 'data' table for sign verification!\n");
#endif
                cmeMemSecureDBUnprotectFree();
                return(26);
            }
            for(cont2=1;cont2<=numRowsData;cont2++)
            {
                cmeStrConstrAppend(&currentDataSalt,"%s",memData[cont2*cmeIDDColumnFileDataNumCols+cmeIDDanydb_salt]);
                cmeStrConstrAppend(&currentDataId,"%d",atoi(memDataDecrypted[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id]));
                result=cmeHMACByteString(
                    (const unsigned char*)memDataDecrypted[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value],
                    (unsigned char**)&currentEncB64Data,
                    strlen(memDataDecrypted[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value]),
                    &written,cmeDefaultMACAlg,&currentDataSalt,orgKey);
                if (result) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeHMACByteString() Error, can't "
                            "compute sign for 'value' in data row id %s with algorithm %s!\n",
                            currentDataId,cmeDefaultMACAlg);
#endif
                    cmeMemSecureDBUnprotectFree();
                    return(27);
                }
                if (strncmp(currentEncB64Data,
                            memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_sign],
                            written)) //Error: sign mismatch!
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), sign mismatch for row id %s "
                            "in data table! Data integrity check failed.\n",currentDataId);
#endif
                    cmeFree(currentEncB64Data);
                    cmeMemSecureDBUnprotectFree();
                    return(28);
                }
#ifdef DEBUG
                fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), verified sign"
                        " for 'value' in row id %s.\n",currentDataId);
#endif
                cmeFree(currentEncB64Data);
                cmeFree(currentDataId);
                cmeFree(currentDataSalt);
            }
            cmeMemTableFinal(memDataDecrypted);
            memDataDecrypted=NULL;
        }
        // Check if protection attribute = "signProtected".
        else if (!strncmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_4,
                          sizeof(cmeIDDColumnFileMeta_attribute_4)))
        {
            //Verify keyed signature of encrypted value against stored signProtected column for each data row.
            //Uses memData snapshot which always contains the original encrypted values taken at function start.
            for(cont2=1;cont2<=numRowsData;cont2++)
            {
                cmeStrConstrAppend(&currentDataSalt,"%s",memData[cont2*cmeIDDColumnFileDataNumCols+cmeIDDanydb_salt]);
                cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id]));
                result=cmeHMACByteString(
                    (const unsigned char*)memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value],
                    (unsigned char**)&currentEncB64Data,
                    strlen(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value]),
                    &written,cmeDefaultMACAlg,&currentDataSalt,orgKey);
                if (result) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeHMACByteString() Error, can't "
                            "compute signProtected for 'value' in data row id %s with algorithm %s!\n",
                            currentDataId,cmeDefaultMACAlg);
#endif
                    cmeMemSecureDBUnprotectFree();
                    return(29);
                }
                if (strncmp(currentEncB64Data,
                            memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_signProtected],
                            written)) //Error: signProtected mismatch!
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), signProtected mismatch for row id %s "
                            "in data table! Data integrity check failed.\n",currentDataId);
#endif
                    cmeFree(currentEncB64Data);
                    cmeMemSecureDBUnprotectFree();
                    return(30);
                }
#ifdef DEBUG
                fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), verified signProtected"
                        " for 'value' in row id %s.\n",currentDataId);
#endif
                cmeFree(currentEncB64Data);
                cmeFree(currentDataId);
                cmeFree(currentDataSalt);
            }
        }
        // Check if protection attribute = "MAC".
        else if (!strncmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_5,
                          sizeof(cmeIDDColumnFileMeta_attribute_5)))
        {
            //Verify HMAC of decrypted value against stored MAC column for each data row.
            //Re-reads current (already-decrypted) values from DB; "protect" unprotect must run first
            //(i.e., "protect" attribute must appear before "MAC" in the meta table).
            result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memDataDecrypted,&numRowsDecrypted,&numColsDecrypted);
            if (result) //Error
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeMemTable() Error, can't "
                        "read 'data' table for MAC verification!\n");
#endif
                cmeMemSecureDBUnprotectFree();
                return(21);
            }
            for(cont2=1;cont2<=numRowsData;cont2++)
            {
                cmeStrConstrAppend(&currentDataSalt,"%s",memData[cont2*cmeIDDColumnFileDataNumCols+cmeIDDanydb_salt]);
                cmeStrConstrAppend(&currentDataId,"%d",atoi(memDataDecrypted[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id]));
                result=cmeHMACByteString(
                    (const unsigned char*)memDataDecrypted[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value],
                    (unsigned char**)&currentEncB64Data,
                    strlen(memDataDecrypted[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value]),
                    &written,cmeDefaultMACAlg,&currentDataSalt,orgKey);
                if (result) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeHMACByteString() Error, can't "
                            "compute MAC for 'value' in data row id %s with algorithm %s!\n",
                            currentDataId,cmeDefaultMACAlg);
#endif
                    cmeMemSecureDBUnprotectFree();
                    return(22);
                }
                if (strncmp(currentEncB64Data,
                            memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_MAC],
                            written)) //Error: MAC mismatch!
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), MAC mismatch for row id %s "
                            "in data table! Data integrity check failed.\n",currentDataId);
#endif
                    cmeFree(currentEncB64Data);
                    cmeMemSecureDBUnprotectFree();
                    return(23);
                }
#ifdef DEBUG
                fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), verified MAC"
                        " for 'value' in row id %s.\n",currentDataId);
#endif
                cmeFree(currentEncB64Data);
                cmeFree(currentDataId);
                cmeFree(currentDataSalt);
            }
            cmeMemTableFinal(memDataDecrypted);
            memDataDecrypted=NULL;
        }
        // Check if protection attribute = "MACProtected".
        else if (!strncmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_6,
                          sizeof(cmeIDDColumnFileMeta_attribute_6)))
        {
            //Verify HMAC of encrypted value against stored MACProtected column for each data row.
            //Uses memData snapshot which always contains the original encrypted values taken at function start.
            for(cont2=1;cont2<=numRowsData;cont2++)
            {
                cmeStrConstrAppend(&currentDataSalt,"%s",memData[cont2*cmeIDDColumnFileDataNumCols+cmeIDDanydb_salt]);
                cmeStrConstrAppend(&currentDataId,"%d",atoi(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDanydb_id]));
                result=cmeHMACByteString(
                    (const unsigned char*)memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value],
                    (unsigned char**)&currentEncB64Data,
                    strlen(memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_value]),
                    &written,cmeDefaultMACAlg,&currentDataSalt,orgKey);
                if (result) //Error
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), cmeHMACByteString() Error, can't "
                            "compute MACProtected for 'value' in data row id %s with algorithm %s!\n",
                            currentDataId,cmeDefaultMACAlg);
#endif
                    cmeMemSecureDBUnprotectFree();
                    return(24);
                }
                if (strncmp(currentEncB64Data,
                            memData[cmeIDDColumnFileDataNumCols*cont2+cmeIDDColumnFileData_MACProtected],
                            written)) //Error: MACProtected mismatch!
                {
#ifdef ERROR_LOG
                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBUnprotect(), MACProtected mismatch for row id %s "
                            "in data table! Data integrity check failed.\n",currentDataId);
#endif
                    cmeFree(currentEncB64Data);
                    cmeMemSecureDBUnprotectFree();
                    return(25);
                }
#ifdef DEBUG
                fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBUnprotect(), verified MACProtected"
                        " for 'value' in row id %s.\n",currentDataId);
#endif
                cmeFree(currentEncB64Data);
                cmeFree(currentDataId);
                cmeFree(currentDataSalt);
            }
        }
        //Free stuff in this FOR loop
        cmeFree(currentMetaAttribute);
        cmeFree(currentMetaAttributeData);
        cmeFree(currentMetaId);
        cmeFree(currentMetaSalt);
        cmeFree(currentMetaUserId);
        cmeFree(currentMetaOrgId);
    }
    //Free remaining stuff.
    sqlite3_finalize(updateMetaUnprotectStmt);
    updateMetaUnprotectStmt=NULL;
    cmeMemSecureDBUnprotectFree();
    return (0);
}

int cmeProtectDBValue (const char *value, char **protectedValue, const char *encAlg, char **salt,
                       const char *orgKey, int *protectedValueLen)
{
    int result;
    if (value==NULL) //Error: no value to encrypt
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeProtectDBValue(), Error, can't "
                "encrypt NULL value with algorithm %s!\n",encAlg);
#endif
        return(1);
    }
    result=cmeProtectByteString (value, protectedValue, encAlg, salt, orgKey, protectedValueLen, strlen(value));
    if (result) //Error
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeProtectDBValue(), cmeProtectByteString() Error, can't "
                "protect 'value' len=%zu with algorithm %s!\n",strlen(value),encAlg);
#endif
        return(2);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeProtectDBValue(), protected 'value': "
            "valueLen=%zu with algorithm %s.\n",strlen(value),encAlg);
#endif
    return (0);
}

int cmeUnprotectDBValue (const char *protectedValue, char **value, const char *encAlg, char **salt,
                         const char *orgKey, int *valueLen)
{
    int result;

    *value=NULL;
    if (!protectedValue) //WARNING: null input!
    {
        *valueLen=0;
        cmeStrConstrAppend(value,"");
#ifdef DEBUG
        fprintf(stderr,"CaumeDSE Debug: cmeUnprotectDBValue(), Warning, can't "
                "decrypt 'protectedValue'=NULL with algorithm %s and key <redacted>!\n",encAlg);
#endif
        return(0); //Not an error, just a warning!
    }
    result=cmeUnprotectByteString(protectedValue,value,encAlg,salt,orgKey,valueLen,strlen(protectedValue));
    if (result) //Unprotect failed. Return empty string and signal integrity failure.
    {
        cmeFree(*value); //Clean value; we will return an empty string.
        *valueLen=0;
        cmeStrConstrAppend(value,"");
#ifdef DEBUG
        fprintf(stderr,"CaumeDSE Debug: cmeUnprotectDBValue(), cmeUnprotectByteString() Warning, can't "
                "unprotect 'protectedValue' len=%zu with algorithm %s and key <redacted>!\n",strlen(protectedValue),encAlg);
#endif
        return(2);
    }
    else //Unprotect successful.
    {
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeUnprotectDBValue(), unprotected 'protectedValue': "
                "protectedLen=%zu with algorithm %s -> valueLen=%d.\n",strlen(protectedValue),encAlg,*valueLen);
#endif
    }
    return (0);
}

int cmeProtectDBSaltedValue (const char *value, char **protectedValue, const char *encAlg, char **salt,
                             const char *orgKey, int *protectedValueLen)
{
    int result;
    char *valueSalt=NULL;
    char *saltedValue=NULL;
    #define cmeProtectDBSaltedValueFree() \
        do { \
            cmeFree(valueSalt); \
            cmeFree(saltedValue); \
        } while (0); //Local free() macro

    if (value==NULL) //Error: no value to encrypt
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeProtectDBSaltedValue(), Error, can't "
                "protect NULL value with algorithm %s!\n",encAlg);
#endif
        cmeProtectDBSaltedValueFree();
        return(1);
    }
    cmeGetRndSaltAnySize(&valueSalt,cmeDefaultValueSaltLen);  //Get random valueSalt (16 chars, 8 byte hexstring).
    cmeStrConstrAppend(&saltedValue,"%s%s",valueSalt,value);  // Append unencrypted value to valueSalt.
    result=cmeProtectDBValue(saltedValue, protectedValue, encAlg, salt, orgKey, protectedValueLen);
    if (result) //Error
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeProtectDBSaltedValue(), cmeProtectDBValue() Error, can't "
                "protect 'salted value' len=%zu with algorithm %s!\n",strlen(saltedValue),encAlg);
#endif
        cmeProtectDBSaltedValueFree();
        return(2);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeProtectDBSaltedValue(), protected 'salted value': "
            "valueLen=%zu with algorithm %s.\n",strlen(saltedValue),encAlg);
#endif
    cmeProtectDBSaltedValueFree();
    return (0);
}

int cmeUnprotectDBSaltedValue (const char *protectedValue, char **value, const char *encAlg, char **salt,
                               const char *orgKey, int *valueLen)
{
    int result;
    char *saltedValue=NULL;
    #define cmeUnProtectDBSaltedValueFree() \
        do { \
            cmeFree(saltedValue); \
        } while (0); //Local free() macro

    *value=NULL;
    if (!protectedValue) //WARNING: null input!
    {
        *valueLen=0;
        cmeStrConstrAppend(value,"");
#ifdef DEBUG
        fprintf(stderr,"CaumeDSE Debug: cmeUnprotectDBSaltedValue(), Warning, can't unprotect 'protectedValue'=NULL "
                "with algorithm %s and key <redacted>!\n",encAlg);
#endif
        cmeUnProtectDBSaltedValueFree();
        return(0); //No error, just a warning.
    }
    result=cmeUnprotectDBValue(protectedValue, &saltedValue, encAlg, salt, orgKey, valueLen);
    if (result) //Unprotect failed. Return empty string.
    {
        *valueLen=0;
        cmeStrConstrAppend(value,"");
#ifdef DEBUG
        fprintf(stderr,"CaumeDSE Debug: cmeUnprotectDBSaltedValue(), cmeUnprotectDBValue() Warning, can't "
                "unprotect 'protectedValue' len=%zu with algorithm %s and key <redacted>!\n",strlen(protectedValue),encAlg);
#endif
    }
    else //Unprotect successful.
    {
        if (*valueLen>=cmeDefaultValueSaltCharLen) //Double check that we have the right length
        {
            cmeStrConstrAppend(value,"%s",&(saltedValue[cmeDefaultValueSaltCharLen])); //We skip the first 16 characters of the 8 byte hexstr salt that is included at the beginning.
            *valueLen-=cmeDefaultValueSaltCharLen;
        }
        else
        {
            cmeStrConstrAppend(value,"%s",saltedValue); //We don't skip the first 16 characters of the 8 byte hexstr salt that is included at the beginning.
#ifdef DEBUG
            fprintf(stderr,"CaumeDSE Debug: cmeUnprotectDBSaltedValue() Warning, valueLen=%d "
                    "has incorrect valuesalt size. Unprotected it assuming it wasn't valueSalted\n",*valueLen);
#endif
        }
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeUnprotectDBSaltedValue(), unprotected 'protectedValue': "
                "protectedLen=%zu with algorithm %s -> valueLen=%d.\n",strlen(protectedValue),encAlg,*valueLen);
#endif
    }
    cmeUnProtectDBSaltedValueFree();
    return (0);
}

int cmeReprotectDBSaltedValue (const char *protectedValue, char **reprotectedValue,
                               const char *sourceEncAlg, const char *targetEncAlg,
                               char **sourceSalt, char **targetSalt,
                               const char *sourceOrgKey, const char *targetOrgKey,
                               int *reprotectedValueLen, int dryRun)
{
    int result;
    int saltedValueLen=0;
    int valueLen=0;
    char *saltedValue=NULL;
    char *value=NULL;
    cmeCryptoProfile sourceProfile;
    cmeCryptoProfile targetProfile;
    #define cmeReprotectDBSaltedValueFree() \
        do { \
            if (saltedValue) \
            { \
                OPENSSL_cleanse(saltedValue,saltedValueLen>0 ? saltedValueLen : 1); \
            } \
            if (value) \
            { \
                OPENSSL_cleanse(value,valueLen>0 ? valueLen : 1); \
            } \
            cmeFree(saltedValue); \
            cmeFree(value); \
        } while (0); //Local free() macro

    if (reprotectedValueLen)
    {
        *reprotectedValueLen=0;
    }
    if (reprotectedValue)
    {
        *reprotectedValue=NULL;
    }
    if ((!protectedValue)||(!sourceEncAlg)||(!targetEncAlg)||(!sourceSalt)||
        (!sourceOrgKey)||(!targetOrgKey)||(!reprotectedValueLen)||
        ((!dryRun)&&((!reprotectedValue)||(!targetSalt))))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeReprotectDBSaltedValue(), Error, NULL parameter.\n");
#endif
        return(1);
    }
    result=cmeGetCryptoProfile(&sourceProfile,sourceEncAlg);
    if (result||(!sourceProfile.implemented))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeReprotectDBSaltedValue(), Error, source algorithm %s is not implemented.\n",
                sourceEncAlg);
#endif
        return(2);
    }
    result=cmeGetCryptoProfile(&targetProfile,targetEncAlg);
    if (result||(!targetProfile.implemented))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeReprotectDBSaltedValue(), Error, target algorithm %s is not implemented.\n",
                targetEncAlg);
#endif
        return(3);
    }
    result=cmeUnprotectByteString(protectedValue,&saltedValue,sourceEncAlg,sourceSalt,sourceOrgKey,
                                  &saltedValueLen,strlen(protectedValue));
    if (result)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeReprotectDBSaltedValue(), Error, source value could not be unprotected.\n");
#endif
        cmeReprotectDBSaltedValueFree();
        return(4);
    }
    if (saltedValueLen<=cmeDefaultValueSaltCharLen)
    {
#ifdef DEBUG
        fprintf(stderr,"CaumeDSE Debug: cmeReprotectDBSaltedValue(), Warning, source value decrypted to an ambiguous salted length.\n");
#endif
        cmeReprotectDBSaltedValueFree();
        return(5);
    }
    if (saltedValueLen>cmeDefaultValueSaltCharLen)
    {
        cmeStrConstrAppend(&value,"%s",&(saltedValue[cmeDefaultValueSaltCharLen]));
        valueLen=saltedValueLen-cmeDefaultValueSaltCharLen;
    }
    if (dryRun)
    {
        *reprotectedValueLen=valueLen;
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeReprotectDBSaltedValue(), dry-run verified valueLen=%d from %s to %s.\n",
                valueLen,sourceEncAlg,targetEncAlg);
#endif
        cmeReprotectDBSaltedValueFree();
        return(0);
    }
    result=cmeProtectDBSaltedValue(value,reprotectedValue,targetEncAlg,targetSalt,targetOrgKey,reprotectedValueLen);
    if (result)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeReprotectDBSaltedValue(), Error, target value could not be protected.\n");
#endif
        cmeReprotectDBSaltedValueFree();
        return(6);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeReprotectDBSaltedValue(), re-protected valueLen=%d from %s to %s.\n",
            valueLen,sourceEncAlg,targetEncAlg);
#endif
    cmeReprotectDBSaltedValueFree();
    return (0);
}

static int cmeDBProtectedValueHasHerraduraFrame(const char *protectedValue)
{
    int written=0;
    unsigned char *decodedValue=NULL;
    int hasFrame=0;

    if (!protectedValue)
    {
        return(0);
    }
    if (!cmeB64ToStr((unsigned char *)protectedValue,&decodedValue,strlen(protectedValue),&written))
    {
        if (written>=cmeHerraduraKExFrameHeaderLen &&
            !memcmp(decodedValue,cmeHerraduraKExFrameMagic,cmeHerraduraKExFrameMagicLen))
        {
            hasFrame=1;
        }
    }
    cmeFree(decodedValue);
    return(hasFrame);
}

int cmeInventoryMemSecureDBReprotect (sqlite3 *memSecureDB, const char *orgKey,
                                      const char *targetEncAlg,
                                      cmeReprotectDBInventory *inventory)
{
    int cont,result,written=0;
    int numColsData=0;
    int numRowsData=0;
    int numColsMeta=0;
    int numRowsMeta=0;
    char **memData=NULL;
    char **memMeta=NULL;
    char *currentMetaAttribute=NULL;
    char *currentMetaAttributeData=NULL;
    char *currentMetaSalt=NULL;
    cmeCryptoProfile targetProfile;
    #define cmeInventoryMemSecureDBReprotectFree() \
        do { \
            cmeFree(currentMetaAttribute); \
            cmeFree(currentMetaAttributeData); \
            cmeFree(currentMetaSalt); \
            if (memData) \
            { \
                cmeMemTableFinal(memData); \
                memData=NULL; \
            } \
            if (memMeta) \
            { \
                cmeMemTableFinal(memMeta); \
                memMeta=NULL; \
            } \
        } while (0); //Local free() macro

    if ((!memSecureDB)||(!orgKey)||(!targetEncAlg)||(!inventory))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeInventoryMemSecureDBReprotect(), Error, NULL parameter.\n");
#endif
        return(1);
    }
    memset(inventory,0,sizeof(*inventory));
    snprintf(inventory->targetProfile,sizeof(inventory->targetProfile),"%s",targetEncAlg);
    result=cmeGetCryptoProfile(&targetProfile,targetEncAlg);
    if (result||(!targetProfile.implemented))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeInventoryMemSecureDBReprotect(), Error, target algorithm %s is not implemented.\n",
                targetEncAlg);
#endif
        return(2);
    }
    result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memData,&numRowsData,&numColsData);
    if (result)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeInventoryMemSecureDBReprotect(), cmeMemTable() Error"
                " can't execute 'SELECT * FROM data;'!\n");
#endif
        cmeInventoryMemSecureDBReprotectFree();
        return(3);
    }
    if (numColsData<cmeIDDColumnFileDataNumCols)
    {
        cmeInventoryMemSecureDBReprotectFree();
        return(4);
    }
    inventory->dataRows=numRowsData;
    for (cont=1;cont<=numRowsData;cont++)
    {
        if (cmeDBProtectedValueHasHerraduraFrame(memData[cont*numColsData+cmeIDDColumnFileData_value]))
        {
            inventory->herraduraValueRows++;
        }
        else if (memData[cont*numColsData+cmeIDDColumnFileData_value] &&
                 memData[cont*numColsData+cmeIDDColumnFileData_value][0])
        {
            inventory->legacyAESValueRows++;
        }
        else
        {
            inventory->unknownValueRows++;
        }
    }
    result=cmeMemTable(memSecureDB,"SELECT * FROM meta;",&memMeta,&numRowsMeta,&numColsMeta);
    if (result)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeInventoryMemSecureDBReprotect(), cmeMemTable() Error"
                " can't execute 'SELECT * FROM meta;'!\n");
#endif
        cmeInventoryMemSecureDBReprotectFree();
        return(5);
    }
    if (numColsMeta<cmeIDDColumnFileMetaNumCols)
    {
        cmeInventoryMemSecureDBReprotectFree();
        return(6);
    }
    inventory->metaRows=numRowsMeta;
    for (cont=1;cont<=numRowsMeta;cont++)
    {
        cmeStrConstrAppend(&currentMetaSalt,"%s",memMeta[cont*numColsMeta+cmeIDDanydb_salt]);
        result=cmeUnprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDColumnFileMeta_attribute],
                                         &currentMetaAttribute,cmeDefaultEncAlg,&currentMetaSalt,orgKey,&written);
        if (result)
        {
            cmeInventoryMemSecureDBReprotectFree();
            return(7);
        }
        result=cmeUnprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDColumnFileMeta_attributeData],
                                         &currentMetaAttributeData,cmeDefaultEncAlg,&currentMetaSalt,orgKey,&written);
        if (result)
        {
            cmeInventoryMemSecureDBReprotectFree();
            return(8);
        }
        if (!strcmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_2))
        {
            inventory->protectMetaRows++;
            inventory->protectedValueRows+=numRowsData;
            if (!inventory->sourceProfile[0])
            {
                snprintf(inventory->sourceProfile,sizeof(inventory->sourceProfile),"%s",currentMetaAttributeData);
            }
            if (!strcmp(currentMetaAttributeData,targetEncAlg))
            {
                inventory->targetProfileRows++;
            }
            else
            {
                inventory->sourceProfileRows++;
            }
        }
        cmeFree(currentMetaAttribute);
        cmeFree(currentMetaAttributeData);
        cmeFree(currentMetaSalt);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeInventoryMemSecureDBReprotect(), rows=%d protectedValues=%d source=%s target=%s legacyAES=%d herradura=%d unknown=%d.\n",
            inventory->dataRows,inventory->protectedValueRows,inventory->sourceProfile,
            inventory->targetProfile,inventory->legacyAESValueRows,inventory->herraduraValueRows,
            inventory->unknownValueRows);
#endif
    cmeInventoryMemSecureDBReprotectFree();
    return(0);
}

int cmeReprotectMemSecureDB (sqlite3 *memSecureDB, const char *sourceOrgKey,
                             const char *targetOrgKey, const char *targetEncAlg,
                             cmeReprotectDBReport *report, int dryRun)
{
    int cont,result,written=0;
    int numColsData=0;
    int numRowsData=0;
    int numColsMeta=0;
    int numRowsMeta=0;
    int protectMetaRows=0;
    int unsupportedIntegrityRows=0;
    char **memData=NULL;
    char **memMeta=NULL;
    char *protectSourceEncAlg=NULL;
    char *currentMetaAttribute=NULL;
    char *currentMetaAttributeData=NULL;
    char *currentMetaUserId=NULL;
    char *currentMetaOrgId=NULL;
    char *currentMetaSalt=NULL;
    char *currentMetaTargetSalt=NULL;
    char *newMetaAttribute=NULL;
    char *newMetaAttributeData=NULL;
    char *newMetaUserId=NULL;
    char *newMetaOrgId=NULL;
    char *newDataValue=NULL;
    char *newDataUserId=NULL;
    char *newDataOrgId=NULL;
    char *sourceDataSalt=NULL;
    char *targetDataSalt=NULL;
    sqlite3_stmt *updateDataStmt=NULL;
    sqlite3_stmt *updateMetaStmt=NULL;
    cmeCryptoProfile targetProfile;
    #define cmeReprotectMemSecureDBFree() \
        do { \
            if (updateDataStmt) { sqlite3_finalize(updateDataStmt); updateDataStmt=NULL; } \
            if (updateMetaStmt) { sqlite3_finalize(updateMetaStmt); updateMetaStmt=NULL; } \
            cmeFree(protectSourceEncAlg); \
            cmeFree(currentMetaAttribute); \
            cmeFree(currentMetaAttributeData); \
            cmeFree(currentMetaUserId); \
            cmeFree(currentMetaOrgId); \
            cmeFree(currentMetaSalt); \
            cmeFree(currentMetaTargetSalt); \
            cmeFree(newMetaAttribute); \
            cmeFree(newMetaAttributeData); \
            cmeFree(newMetaUserId); \
            cmeFree(newMetaOrgId); \
            cmeFree(newDataValue); \
            cmeFree(newDataUserId); \
            cmeFree(newDataOrgId); \
            cmeFree(sourceDataSalt); \
            cmeFree(targetDataSalt); \
            if (memData) \
            { \
                cmeMemTableFinal(memData); \
                memData=NULL; \
            } \
            if (memMeta) \
            { \
                cmeMemTableFinal(memMeta); \
                memMeta=NULL; \
            } \
        } while (0); //Local free() macro

    if ((!memSecureDB)||(!sourceOrgKey)||(!targetOrgKey)||(!targetEncAlg)||(!report))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeReprotectMemSecureDB(), Error, NULL parameter.\n");
#endif
        return(1);
    }
    memset(report,0,sizeof(*report));
    report->dryRun=dryRun ? 1 : 0;
    result=cmeGetCryptoProfile(&targetProfile,targetEncAlg);
    if (result||(!targetProfile.implemented))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeReprotectMemSecureDB(), Error, target algorithm %s is not implemented.\n",
                targetEncAlg);
#endif
        return(2);
    }
    result=cmeInventoryMemSecureDBReprotect(memSecureDB,sourceOrgKey,targetEncAlg,&(report->before));
    if (result)
    {
        return(3);
    }
    result=cmeMemTable(memSecureDB,"SELECT * FROM data;",&memData,&numRowsData,&numColsData);
    if (result||numColsData<cmeIDDColumnFileDataNumCols)
    {
        cmeReprotectMemSecureDBFree();
        return(4);
    }
    result=cmeMemTable(memSecureDB,"SELECT * FROM meta;",&memMeta,&numRowsMeta,&numColsMeta);
    if (result||numColsMeta<cmeIDDColumnFileMetaNumCols)
    {
        cmeReprotectMemSecureDBFree();
        return(5);
    }
    for (cont=1;cont<=numRowsMeta;cont++)
    {
        cmeStrConstrAppend(&currentMetaSalt,"%s",memMeta[cont*numColsMeta+cmeIDDanydb_salt]);
        result=cmeUnprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDColumnFileMeta_attribute],
                                         &currentMetaAttribute,cmeDefaultEncAlg,&currentMetaSalt,sourceOrgKey,&written);
        if (!result)
        {
            result=cmeUnprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDColumnFileMeta_attributeData],
                                             &currentMetaAttributeData,cmeDefaultEncAlg,&currentMetaSalt,sourceOrgKey,&written);
        }
        if (result)
        {
            cmeReprotectMemSecureDBFree();
            return(6);
        }
        if (!strcmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_2))
        {
            protectMetaRows++;
            cmeFree(protectSourceEncAlg);
            protectSourceEncAlg=NULL;
            cmeStrConstrAppend(&protectSourceEncAlg,"%s",currentMetaAttributeData);
        }
        else if ((!strcmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_3))||
                 (!strcmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_4))||
                 (!strcmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_5))||
                 (!strcmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_6)))
        {
            unsupportedIntegrityRows++;
        }
        cmeFree(currentMetaAttribute);
        cmeFree(currentMetaAttributeData);
        cmeFree(currentMetaSalt);
    }
    if (protectMetaRows!=1 || (!protectSourceEncAlg))
    {
#ifdef DEBUG
        fprintf(stderr,"CaumeDSE Debug: cmeReprotectMemSecureDB(), Warning, expected exactly one protect metadata row.\n");
#endif
        cmeReprotectMemSecureDBFree();
        return(7);
    }
    if (unsupportedIntegrityRows)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeReprotectMemSecureDB(), Error, MAC/sign metadata requires a dedicated recomputation workflow.\n");
#endif
        cmeReprotectMemSecureDBFree();
        return(8);
    }
    report->dataRowsReprotected=numRowsData;
    report->metaRowsReprotected=numRowsMeta;
    if (dryRun)
    {
#ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeReprotectMemSecureDB(), dry-run rows=%d meta=%d from %s to %s.\n",
                numRowsData,numRowsMeta,protectSourceEncAlg,targetEncAlg);
#endif
        cmeReprotectMemSecureDBFree();
        return(0);
    }
    result=sqlite3_prepare_v2(memSecureDB,
                              "UPDATE data SET value=?,userId=?,orgId=?,salt=? WHERE id=?;",
                              -1,&updateDataStmt,NULL);
    if (result!=SQLITE_OK)
    {
        cmeReprotectMemSecureDBFree();
        return(9);
    }
    result=sqlite3_prepare_v2(memSecureDB,
                              "UPDATE meta SET attribute=?,attributeData=?,userId=?,orgId=?,salt=? WHERE id=?;",
                              -1,&updateMetaStmt,NULL);
    if (result!=SQLITE_OK)
    {
        cmeReprotectMemSecureDBFree();
        return(10);
    }
    if (cmeSQLRows(memSecureDB,"BEGIN IMMEDIATE;",NULL,NULL))
    {
        cmeReprotectMemSecureDBFree();
        return(11);
    }
    for (cont=1;cont<=numRowsData;cont++)
    {
        cmeStrConstrAppend(&sourceDataSalt,"%s",memData[cont*numColsData+cmeIDDanydb_salt]);
        result=cmeReprotectDBSaltedValue(memData[cont*numColsData+cmeIDDColumnFileData_value],
                                         &newDataValue,protectSourceEncAlg,targetEncAlg,
                                         &sourceDataSalt,&targetDataSalt,sourceOrgKey,targetOrgKey,&written,0);
        if (!result)
        {
            result=cmeReprotectDBSaltedValue(memData[cont*numColsData+cmeIDDanydb_userId],
                                             &newDataUserId,protectSourceEncAlg,targetEncAlg,
                                             &sourceDataSalt,&targetDataSalt,sourceOrgKey,targetOrgKey,&written,0);
        }
        if (!result)
        {
            result=cmeReprotectDBSaltedValue(memData[cont*numColsData+cmeIDDanydb_orgId],
                                             &newDataOrgId,protectSourceEncAlg,targetEncAlg,
                                             &sourceDataSalt,&targetDataSalt,sourceOrgKey,targetOrgKey,&written,0);
        }
        if (!result)
        {
            result=sqlite3_bind_text(updateDataStmt,1,newDataValue,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataStmt,2,newDataUserId,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataStmt,3,newDataOrgId,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_text(updateDataStmt,4,targetDataSalt,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_int(updateDataStmt,5,atoi(memData[cont*numColsData+cmeIDDanydb_id]));
            if (result==SQLITE_OK) result=sqlite3_step(updateDataStmt);
            if (result==SQLITE_DONE) result=0;
        }
        if (result)
        {
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeReprotectMemSecureDBFree();
            return(12);
        }
        sqlite3_reset(updateDataStmt);
        sqlite3_clear_bindings(updateDataStmt);
        cmeFree(newDataValue);
        cmeFree(newDataUserId);
        cmeFree(newDataOrgId);
        cmeFree(sourceDataSalt);
        cmeFree(targetDataSalt);
    }
    for (cont=1;cont<=numRowsMeta;cont++)
    {
        cmeStrConstrAppend(&currentMetaSalt,"%s",memMeta[cont*numColsMeta+cmeIDDanydb_salt]);
        result=cmeUnprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDColumnFileMeta_attribute],
                                         &currentMetaAttribute,cmeDefaultEncAlg,&currentMetaSalt,sourceOrgKey,&written);
        if (!result)
        {
            result=cmeUnprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDColumnFileMeta_attributeData],
                                             &currentMetaAttributeData,cmeDefaultEncAlg,&currentMetaSalt,sourceOrgKey,&written);
        }
        if (!result)
        {
            result=cmeUnprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDanydb_userId],
                                             &currentMetaUserId,cmeDefaultEncAlg,&currentMetaSalt,sourceOrgKey,&written);
        }
        if (!result)
        {
            result=cmeUnprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDanydb_orgId],
                                             &currentMetaOrgId,cmeDefaultEncAlg,&currentMetaSalt,sourceOrgKey,&written);
        }
        if (!result)
        {
            const char *targetMetaAttributeData=currentMetaAttributeData;

            if (!strcmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_2))
            {
                targetMetaAttributeData=targetEncAlg;
            }
            result=cmeReprotectDBSaltedValue(memMeta[cont*numColsMeta+cmeIDDColumnFileMeta_attribute],
                                             &newMetaAttribute,cmeDefaultEncAlg,cmeDefaultEncAlg,
                                             &currentMetaSalt,&currentMetaTargetSalt,sourceOrgKey,targetOrgKey,&written,0);
            if (!result)
            {
                result=cmeProtectDBSaltedValue(targetMetaAttributeData,&newMetaAttributeData,
                                               cmeDefaultEncAlg,&currentMetaTargetSalt,targetOrgKey,&written);
            }
            if (!result)
            {
                result=cmeProtectDBSaltedValue(currentMetaUserId,&newMetaUserId,
                                               cmeDefaultEncAlg,&currentMetaTargetSalt,targetOrgKey,&written);
            }
            if (!result)
            {
                result=cmeProtectDBSaltedValue(currentMetaOrgId,&newMetaOrgId,
                                               cmeDefaultEncAlg,&currentMetaTargetSalt,targetOrgKey,&written);
            }
        }
        if (!result)
        {
            result=sqlite3_bind_text(updateMetaStmt,1,newMetaAttribute,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaStmt,2,newMetaAttributeData,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaStmt,3,newMetaUserId,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaStmt,4,newMetaOrgId,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_text(updateMetaStmt,5,currentMetaTargetSalt,-1,SQLITE_TRANSIENT);
            if (result==SQLITE_OK) result=sqlite3_bind_int(updateMetaStmt,6,atoi(memMeta[cont*numColsMeta+cmeIDDanydb_id]));
            if (result==SQLITE_OK) result=sqlite3_step(updateMetaStmt);
            if (result==SQLITE_DONE) result=0;
        }
        if (result)
        {
            cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
            cmeReprotectMemSecureDBFree();
            return(13);
        }
        sqlite3_reset(updateMetaStmt);
        sqlite3_clear_bindings(updateMetaStmt);
        cmeFree(currentMetaAttribute);
        cmeFree(currentMetaAttributeData);
        cmeFree(currentMetaUserId);
        cmeFree(currentMetaOrgId);
        cmeFree(currentMetaSalt);
        cmeFree(currentMetaTargetSalt);
        cmeFree(newMetaAttribute);
        cmeFree(newMetaAttributeData);
        cmeFree(newMetaUserId);
        cmeFree(newMetaOrgId);
    }
    if (cmeSQLRows(memSecureDB,"COMMIT;",NULL,NULL))
    {
        cmeSQLRows(memSecureDB,"ROLLBACK;",NULL,NULL);
        cmeReprotectMemSecureDBFree();
        return(14);
    }
    if (memData)
    {
        cmeMemTableFinal(memData);
        memData=NULL;
    }
    if (memMeta)
    {
        cmeMemTableFinal(memMeta);
        memMeta=NULL;
    }
    result=cmeInventoryMemSecureDBReprotect(memSecureDB,targetOrgKey,targetEncAlg,&(report->after));
    if (result)
    {
        cmeReprotectMemSecureDBFree();
        return(15);
    }
#ifdef DEBUG
    fprintf(stdout,"CaumeDSE Debug: cmeReprotectMemSecureDB(), re-protected rows=%d meta=%d from %s to %s.\n",
            report->dataRowsReprotected,report->metaRowsReprotected,protectSourceEncAlg,targetEncAlg);
#endif
    cmeReprotectMemSecureDBFree();
    return(0);
}

int cmeGetProtectDBLookupValue (const char *columnName, const char *value, const char *orgKey,
                                char **lookupValue)
{
    int result,written=0;
    char *lookupInput=NULL;
    char *lookupSalt=NULL;
    #define cmeGetProtectDBLookupValueFree() \
        do { \
            cmeFree(lookupInput); \
            cmeFree(lookupSalt); \
        } while (0); //Local free() macro

    *lookupValue=NULL;
    if ((!columnName)||(!value)||(!orgKey))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeGetProtectDBLookupValue(), Error, NULL parameter.\n");
#endif
        cmeGetProtectDBLookupValueFree();
        return(1);
    }
    cmeStrConstrAppend(&lookupInput,"CaumeDSE:protectedLookup:v1:%s:%lu:%s",
                       columnName,(unsigned long)strlen(value),value);
    cmeStrConstrAppend(&lookupSalt,"%s",cmeDefaultLookupSalt);
    result=cmeHMACByteString((const unsigned char *)lookupInput,(unsigned char **)lookupValue,strlen(lookupInput),
                             &written,cmeDefaultMACAlg,&lookupSalt,orgKey);
    if (result)
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeGetProtectDBLookupValue(), cmeHMACByteString() Error, can't "
                "compute lookup value for column '%s'!\n",columnName);
#endif
        cmeGetProtectDBLookupValueFree();
        return(2);
    }
    cmeGetProtectDBLookupValueFree();
    return(0);
}

static int cmeDBTableHasColumn (sqlite3 *pDB, const char *tableName, const char *columnName, int *hasColumn)
{
    int cont,result,numRows=0,numColumns=0;
    char *query=NULL;
    char **queryResult=NULL;
    #define cmeDBTableHasColumnFree() \
        do { \
            cmeFree(query); \
            if (queryResult) \
            { \
                cmeMemTableFinal(queryResult); \
            } \
        } while (0); //Local free() macro

    *hasColumn=0;
    cmeStrConstrAppend(&query,"PRAGMA table_info(\"%s\");",tableName);
    result=cmeMemTable(pDB,query,&queryResult,&numRows,&numColumns);
    if (result)
    {
        cmeDBTableHasColumnFree();
        return(1);
    }
    for (cont=1;cont<=numRows;cont++)
    {
        if (!strcmp(queryResult[(cont*numColumns)+1],columnName))
        {
            *hasColumn=1;
            break;
        }
    }
    cmeDBTableHasColumnFree();
    return(0);
}

int cmeEnsureResourcesDBDocumentLookups (sqlite3 *pDB)
{
    int cont,result,hasColumn=0;
    const char *lookupColumns[3]={
        cmeIDDResourcesDBDocuments_documentIdLookup_name,
        cmeIDDResourcesDBDocuments_storageIdLookup_name,
        cmeIDDResourcesDBDocuments_orgResourceIdLookup_name
    };
    const char *lookupIndexes[3]={
        "idx_doc_documentIdLookup",
        "idx_doc_storageIdLookup",
        "idx_doc_orgResourceIdLookup"
    };
    char *query=NULL;
    #define cmeEnsureResourcesDBDocumentLookupsFree() \
        do { \
            cmeFree(query); \
        } while (0); //Local free() macro

    for (cont=0;cont<3;cont++)
    {
        result=cmeDBTableHasColumn(pDB,"documents",lookupColumns[cont],&hasColumn);
        if (result)
        {
            cmeEnsureResourcesDBDocumentLookupsFree();
            return(1);
        }
        if (!hasColumn)
        {
            cmeStrConstrAppend(&query,"ALTER TABLE documents ADD COLUMN %s TEXT;",lookupColumns[cont]);
            result=sqlite3_exec(pDB,query,NULL,NULL,NULL);
            cmeFree(query);
            if (result!=SQLITE_OK)
            {
                cmeEnsureResourcesDBDocumentLookupsFree();
                return(2);
            }
        }
        cmeStrConstrAppend(&query,"CREATE INDEX IF NOT EXISTS %s ON documents(%s);",
                           lookupIndexes[cont],lookupColumns[cont]);
        result=sqlite3_exec(pDB,query,NULL,NULL,NULL);
        cmeFree(query);
        if (result!=SQLITE_OK)
        {
            cmeEnsureResourcesDBDocumentLookupsFree();
            return(3);
        }
    }
    cmeEnsureResourcesDBDocumentLookupsFree();
    return(0);
}

int cmeMemSecureDBReintegrate (sqlite3 **memSecureDB, const char *orgKey,
                               const int dbNumCols, int *dbNumReintegratedCols)
{
    int cont,cont2,cont3,cont4,result,written;
    int numColsData=0;
    int numColsPMeta=0;
    int numRowsPMeta=0;
    int *numRowsData=NULL;
    char ***memData=NULL;
    char ***memProtectMetaData=NULL;
    char **memColumnName=NULL;
    char *currentEncData=NULL;
    char *currentEncB64Data=NULL;
    char *currentMetaAttribute=NULL;
    char *currentMetaAttributeData=NULL;
    char *currentMetaId=NULL;
    char *currentMetaSalt=NULL;
    char *currentMetaUserId=NULL;
    char *currentMetaOrgId=NULL;
    sqlite3_stmt *insertReintegratedDataStmt=NULL;
    sqlite3 *tmpPtr=NULL;       //Just a tmp pointer; no need for cmeFree().
    //MEMORY CLEANUP MACRO for local function.
    #define cmeMemSecureDBReintegrateFree() \
        do { \
            if (insertReintegratedDataStmt) \
            { \
                sqlite3_finalize(insertReintegratedDataStmt); \
                insertReintegratedDataStmt=NULL; \
            } \
            cmeFree(numRowsData); \
            cmeFree(currentEncData); \
            cmeFree(currentEncB64Data); \
            cmeFree(currentMetaAttribute); \
            cmeFree(currentMetaAttributeData); \
            cmeFree(currentMetaId); \
            cmeFree(currentMetaSalt); \
            cmeFree(currentMetaUserId); \
            cmeFree(currentMetaOrgId); \
            if (memColumnName) \
            { \
                for (cont=0;cont<dbNumCols;cont++) \
                { \
                    cmeFree(memColumnName[cont]); \
                } \
                cmeFree(memColumnName); \
            } \
            if (memData) \
            { \
                for (cont=0;cont<dbNumCols;cont++) \
                { \
                    if (memData[cont]) \
                    { \
                        cmeMemTableFinal(memData[cont]); \
                    } \
                } \
                cmeFree(memData); \
            } \
            if (memProtectMetaData) \
            { \
                for (cont=0;cont<dbNumCols;cont++) \
                { \
                    if (memProtectMetaData[cont]) \
                    { \
                        cmeMemTableFinal(memProtectMetaData[cont]); \
                    } \
                } \
                cmeFree(memProtectMetaData); \
            } \
        } while (0); //Local free() macro.

    *dbNumReintegratedCols=dbNumCols;
    numRowsData=(int *)malloc(sizeof(int)*dbNumCols);
    memData=(char ***)malloc(sizeof(char **)*dbNumCols);
    memProtectMetaData=(char ***)malloc(sizeof(char **)*dbNumCols);
    memColumnName=(char **)malloc(sizeof(char *)*dbNumCols);
    for (cont=0;cont<dbNumCols;cont++)
    {
        numRowsData[cont]=0;
        memData[cont]=NULL;
        memProtectMetaData[cont]=NULL;
        memColumnName[cont]=NULL;
    }

    for (cont=0;cont<dbNumCols;cont++)
    {
        //Get information from table meta (we assume tables meta and data are protected).
        result=cmeMemTable(memSecureDB[cont],"SELECT * FROM meta;",&(memProtectMetaData[cont]),&numRowsPMeta,&numColsPMeta);
        if (result) //Error
        {
    #ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBReintegrate(), cmeMemTable() Error"
                    "can't execute 'SELECT * FROM meta;'!\n");
    #endif
            cmeMemSecureDBReintegrateFree();
            return(1);
        }
    #ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBReintegrate(), cmeMemTable() loaded memSecureDB, table meta.\n");
    #endif
        //Get information from table data (we assume tables meta and data are protected).
        result=cmeMemTable(memSecureDB[cont],"SELECT * FROM data;",&(memData[cont]),&(numRowsData[cont]),&numColsData);
        if (result) //Error
        {
    #ifdef ERROR_LOG
            fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBReintegrate(), cmeMemTable() Error"
                    "can't execute 'SELECT * FROM data;'!\n");
    #endif
            cmeMemSecureDBReintegrateFree();
            return(2);
        }
    #ifdef DEBUG
        fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBReintegrate(), cmeMemTable() loaded memSecureDB, table data.\n");
    #endif
        //Unprotect and reverse on table data, each protection mechanism defined in table meta.
        for (cont2=1; cont2<=numRowsPMeta; cont2++) //Iterate on each protection row in meta.
        {
            cmeStrConstrAppend(&currentMetaSalt,"%s",memProtectMetaData[cont][cont2*              //Get meta.salt
                               cmeIDDColumnFileMetaNumCols+cmeIDDanydb_salt]);
            cmeStrConstrAppend(&currentEncB64Data,"%s",memProtectMetaData[cont][cont2*            //Get prot. meta.attribute
                               cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attribute]);
            result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentMetaAttribute,cmeDefaultEncAlg,&currentMetaSalt,orgKey,&written);
            if (result) //Error
            {
    #ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBReintegrate(), cmeUnprotectDBSaltedValue() Error, can't "
                        "unprotect 'attribute' in meta table, protectedLen=%zu with algorithm %s!\n",
                        strlen(currentEncB64Data),cmeDefaultEncAlg);
    #endif
                cmeMemSecureDBReintegrateFree();
                return(3);
            }
            cmeFree(currentEncB64Data);
            cmeStrConstrAppend(&currentEncB64Data,"%s",memProtectMetaData[cont][cont2*            //Get prot. meta.attributeData
                               cmeIDDColumnFileMetaNumCols+cmeIDDColumnFileMeta_attributeData]);
            result=cmeUnprotectDBSaltedValue(currentEncB64Data,&currentMetaAttributeData,cmeDefaultEncAlg,&currentMetaSalt,orgKey,&written);
            if (result) //Error
            {
    #ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBReintegrate(), cmeUnprotectDBSaltedValue() Error, can't "
                        "decrypt 'attributeData' in meta table, protectedLen=%zu with algorithm %s!\n",
                        strlen(currentEncB64Data),cmeDefaultEncAlg);
    #endif
                cmeMemSecureDBReintegrateFree();
                return(4);
            }
            cmeFree(currentEncB64Data);
            // Check for name duplicates protection attribute = "name".
            if (!strncmp(currentMetaAttribute,cmeIDDColumnFileMeta_attribute_0,
                         sizeof(cmeIDDColumnFileMeta_attribute_0)))
            {
    #ifdef DEBUG
                fprintf(stdout,"CaumeDSE Debug: cmeMemSecureDBReintegrate(): 'name' checking name column duplicates to reintegrate.\n");
    #endif
                cmeStrConstrAppend(&(memColumnName[cont]),"%s",currentMetaAttributeData); //Save column Name.
                for (cont3=0;cont3<cont;cont3++) //check for duplicates with previous column names
                {
                    if ((memColumnName[cont3])&&(memColumnName[cont]))
                    {
                        if (!strcmp(memColumnName[cont3],memColumnName[cont])) //We have a duplicate!, insert data rows into first duplicate column and clear this column name.
                        {
                            result=sqlite3_prepare_v2(memSecureDB[cont3],
                                                      "INSERT INTO data "
                                                      "(id,userId,orgId,salt,value,rowOrder,MAC,sign,MACProtected,signProtected,otphDkey) "
                                                      "VALUES (NULL,?,?,?,?,?,?,?,?,?,?);",
                                                      -1,&insertReintegratedDataStmt,NULL);
                            if (result!=SQLITE_OK)
                            {
#ifdef ERROR_LOG
                                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBReintegrate(), sqlite3_prepare_v2() Error, can't "
                                        "prepare reintegrated data insert in secured DB data table!\n");
#endif
                                cmeMemSecureDBReintegrateFree();
                                return(5);
                            }
                            if (cmeSQLRows(memSecureDB[cont3],"BEGIN TRANSACTION;",NULL,NULL))
                            {
#ifdef ERROR_LOG
                                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBReintegrate(), cmeSQLRows() Error, can't "
                                        "begin reintegrated data transaction in secured DB data table!\n");
#endif
                                cmeMemSecureDBReintegrateFree();
                                return(5);
                            }
                            for (cont4=1;cont4<=numRowsData[cont];cont4++) //Insert rows, skipping column names
                            {
                                result=sqlite3_bind_text(insertReintegratedDataStmt,1,
                                                         memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDanydb_userId],
                                                         -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,2,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDanydb_orgId],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,3,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDanydb_salt],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,4,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDColumnFileData_value],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,5,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDColumnFileData_rowOrder],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,6,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDColumnFileData_MAC],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,7,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDColumnFileData_sign],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,8,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDColumnFileData_MACProtected],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,9,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDColumnFileData_signProtected],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_bind_text(insertReintegratedDataStmt,10,
                                                                                memData[cont][cmeIDDColumnFileDataNumCols*cont4+cmeIDDColumnFileData_otphDKey],
                                                                                -1,SQLITE_TRANSIENT);
                                if (result==SQLITE_OK) result=sqlite3_step(insertReintegratedDataStmt);
                                if (result!=SQLITE_DONE)
                                {
#ifdef ERROR_LOG
                                    fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBReintegrate(), sqlite3_step() Error, can't "
                                            "insert row in secured DB data table!\n");
#endif
                                    cmeSQLRows(memSecureDB[cont3],"ROLLBACK;",NULL,NULL);
                                    cmeMemSecureDBReintegrateFree();
                                    return(5);
                                }
                                sqlite3_reset(insertReintegratedDataStmt);
                                sqlite3_clear_bindings(insertReintegratedDataStmt);
                            }
                            if (cmeSQLRows(memSecureDB[cont3],"COMMIT;",NULL,NULL))
                            {
#ifdef ERROR_LOG
                                fprintf(stderr,"CaumeDSE Error: cmeMemSecureDBReintegrate(), cmeSQLRows() Error, can't "
                                        "commit reintegrated data transaction in secured DB data table!\n");
#endif
                                cmeSQLRows(memSecureDB[cont3],"ROLLBACK;",NULL,NULL);
                                cmeMemSecureDBReintegrateFree();
                                return(5);
                            }
                            sqlite3_finalize(insertReintegratedDataStmt);
                            insertReintegratedDataStmt=NULL;
                            (*dbNumReintegratedCols)--;
                            cmeFree(memColumnName[cont]); //clear current column name, since it was a duplicate (we copy all rows to the first col. name duplicate only)
                            //cmeStrConstrAppend(&(memColumnName[cont]),"*%d",cont); //Mark current column name, since it was a duplicate (we copy all rows to the first col. name duplicate only)
                        }
                    }
                }
            }
            //Free stuff in this FOR loop:
            cmeFree(currentEncB64Data);
            cmeFree(currentMetaAttribute);
            cmeFree(currentMetaAttributeData);
            cmeFree(currentMetaSalt);
        }
    }
    //Final packing of pointers (all integrated columns are moved to the first pointers).
    for (cont=0;cont<(*dbNumReintegratedCols);cont++)
    {
        if (!memColumnName[cont])//Empty column; we must move the first reintegrated column pointer to here
        {
            cont2=cont;
            while ((!memColumnName[cont2])&&(cont2<(dbNumCols-1)))
            {
                cont2++;
            }
            if (memColumnName[cont2])
            {
                cmeStrConstrAppend(&(memColumnName[cont]),"%s",memColumnName[cont2]); //copy column name (just to see where it will be moved in debugger.
                cmeFree(memColumnName[cont2]); //free moved column name.
                tmpPtr=memSecureDB[cont2]; //Now exchange pointers to column databases.
                memSecureDB[cont2]=memSecureDB[cont];
                memSecureDB[cont]=tmpPtr;
            }
        }
    }
    cmeMemSecureDBReintegrateFree();
    return (0);
}

int cmeMemTableWithTableColumnNames (sqlite3 *db, const char *tableName)
{
    int cont,result __attribute__((unused)),numCols;
    const int columnNameIndex=1;        //Index for column names within internal structure of SQLite's PRAGMA table_info().
    char *sqlQuery=NULL;
    char **tmpColumnMemTable=NULL;
        //MEMORY CLEANUP MACRO for local function.
    #define cmeMemTableWithTableColumnNamesFree() \
        do { \
            cmeFree(sqlQuery); \
        } while (0); //Local free() macro.
        //Note: results will be located in cmeResultMemTable by pointing it to tmpColumnMemTable (we don't free tmpColumnMemTable).

    cmeResultMemTableClean();
    cmeStrConstrAppend(&sqlQuery,"PRAGMA table_info(\"%s\");",tableName);
    result=cmeSQLRows(db,(const char *) sqlQuery,NULL,NULL); //Select all data; no parser script.
    numCols=cmeResultMemTableRows;
    if (numCols)
    {
        tmpColumnMemTable=(char **)malloc(sizeof(char *)*numCols); //Reserve memory for column names;
    }
    for (cont=0;cont<numCols;cont++)
    {
        tmpColumnMemTable[cont]=NULL;
        cmeStrConstrAppend(&(tmpColumnMemTable[cont]),"%s",cmeResultMemTable[cmeResultMemTableCols*(cont+1)+columnNameIndex]); //We skip headers in resultMemTable
    }
    cmeResultMemTableClean();
    cmeResultMemTable=tmpColumnMemTable;
    cmeResultMemTableCols=numCols;
    cmeResultMemTableRows=0;
    cmeMemTableWithTableColumnNamesFree();
    return (0);
}

int cmeIsSafeSQLIdentifier(const char *identifier)
{
    int cont;

    if ((!identifier)||(!identifier[0]))
    {
        return(0);
    }
    for (cont=0;identifier[cont];cont++)
    {
        if ((!isalnum((unsigned char)identifier[cont]))&&(identifier[cont]!='_'))
        {
            return(0);
        }
    }
    return(1);
}

int cmeHasUnsafeSQLInputChars(const char *sourceString)
{
    int cont;

    if (!sourceString)
    {
        return(1);
    }
    for (cont=0;sourceString[cont];cont++)
    {
        switch (sourceString[cont])
        {
            case '"':
            case '\'':
            case ';':
            case '=':
            case '`':
                return(1);
            default:
                break;
        }
    }
    return(0);
}

int cmeSanitizeStrForSQL (const char *sourceString, char **sanitizedString)
{
    int cont,cont2;
    int sourceStringLen=0;
    int sanitizedStringLen=0;

    if ((!sourceString)||(!sanitizedString)) //Error, source string or output pointer can't be NULL
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeSanitizeStrForSQL(), Error, source string or output pointer can't be NULL!\n");
#endif
        return(1);
    }
    sourceStringLen=strlen(sourceString);
    sanitizedStringLen=sourceStringLen;
    if (*sanitizedString)
    {
        cmeFree(*sanitizedString);
    }
    *sanitizedString=(char *)malloc(sizeof(char)*(sanitizedStringLen+1)); //Set length of sanitized string = length of source string to start.
    if (!(*sanitizedString))
    {
#ifdef ERROR_LOG
        fprintf(stderr,"CaumeDSE Error: cmeSanitizeStrForSQL(), malloc() Error!\n");
#endif
        return(2);
    }
    cont2=0;
    for (cont=0;cont<sourceStringLen;cont++)
    {
        if (sourceString[cont]=='\'') //If we find a single quote character, we double it in the sanitized string.
        {
            (*sanitizedString)[cont2]='\'';
            cont2++;
            sanitizedStringLen++;
            *sanitizedString=(char *)realloc(*sanitizedString, sizeof(char)*(sanitizedStringLen+1)); //Add 1 character to the sanitized string.
            if (!(*sanitizedString))
            {
#ifdef ERROR_LOG
                fprintf(stderr,"CaumeDSE Error: cmeSanitizeStrForSQL(), realloc() Error!\n");
#endif
                return(3);
            }
        }
        (*sanitizedString)[cont2]=sourceString[cont];
        cont2++;
    }
    (*sanitizedString)[cont2]='\0'; //Include ending 0 character.
    return(0);
}