Неразрешенный внешний символ при вызове методов класса в сторонней программе (dll)

#include <Windows.h>
#include <WinBase.h>
#include <string>
#include <conio.h>
#include <Lmcons.h>
#include <Aclapi.h>
#include "Shlwapi.h"
 
#pragma once
#pragma comment(lib, "Shlwapi.lib")
#pragma comment(lib, "Advapi32.lib")
 
 
#define EOF_POINTER_METHOD 1
#define EOF_READ_METHOD 2
 
bool SetPrivelege(char *privelege, bool EnableDisable = true);
bool IsFileExist(char *FName);
bool Copy(char *OldFName, char *NewFName, bool IsReplase = false);
bool Move(char *OldFName, char *NewFName, bool IsReplace = false);
bool Delete(char *FName);
bool CreateDir(char *DirPath);
bool RemoveDir(char *DirPath, bool delsubfiles = true);
bool SetArttributes(char *FName, DWORD64 attributes = FILE_ATTRIBUTE_NORMAL);
bool SetACL(char *FilePath, char *Username, DWORD access = GENERIC_ALL, ACCESS_MODE accessmode = GRANT_ACCESS);
bool GetACL(char *FilePath, ACL *acl);
DWORD GetArttributes(char *FName);
std::string GetFileNameInDirbyNumber(char *DirPath, DWORD number);
std::string GetThisUserName();
 
class FileWork
{
public:
    FileWork();
    ~FileWork();
    UINT64 GetSize();
    HANDLE GetFileHandle();
    DWORD GetSeek();
    DWORD GetArttributes();
    bool SetACL(char *Username, DWORD access = GENERIC_ALL, ACCESS_MODE accessmode = GRANT_ACCESS);
    bool SetAttributes(DWORD attributes = FILE_ATTRIBUTE_NORMAL);
    bool Lock(DWORD offsLow, DWORD offHigh, DWORD toLockLow, DWORD toLockHigh);
    bool Unlock(DWORD offsLow, DWORD offHigh, DWORD toLockLow, DWORD toLockHigh);
    bool SetEOF(DWORD pos = 0);
    bool AdvancedCreate(char *FileName, DWORD Access = GENERIC_READ | GENERIC_WRITE, DWORD ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE, SECURITY_ATTRIBUTES *SecrAttr = NULL, DWORD CreateDisp = OPEN_ALWAYS, DWORD Attributes = FILE_ATTRIBUTE_NORMAL);
    bool NormalCreate(char *FileName, DWORD Access = GENERIC_READ | GENERIC_WRITE, DWORD ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE, DWORD CreateDisp = OPEN_ALWAYS);
    bool BaseCreate(char *FileName, DWORD CreateDisp = OPEN_ALWAYS);
    bool AdvancedWrite(void *buffer, DWORD NumberOfBytesToWrite, DWORD *NumberOfBytesWritten = NULL, OVERLAPPED *ovl = NULL);
    bool NormalWrite(void *buffer, DWORD NumberOfBytesToWrite, OVERLAPPED *ovl = NULL);
    bool AdvancedRead(void *buffer, DWORD NumberOfBytesToRead, DWORD *NumberOfBytesReaden = NULL, OVERLAPPED *ovl = NULL);
    bool NormalRead(void *buffer, DWORD NumberOfBytesRead, OVERLAPPED *ovl = NULL);
    bool IsEOF(DWORD method = EOF_POINTER_METHOD, OVERLAPPED *ov = NULL);
    bool Seek(INT64 pos, DWORD basepos = FILE_BEGIN);
    bool Close();
    bool Flush();
private:
    char *m_FName;
    HANDLE m_Fhandle;
    DWORD m_Access;
    DWORD m_ShareMode;
    SECURITY_ATTRIBUTES *m_SecrAttr;
    DWORD m_CreateDisp;
    DWORD m_Attributes;
};

#include "FileWork.h"
 
FileWork::FileWork()
{
}
 
 
FileWork::~FileWork()
{
}
 
HANDLE FileWork::GetFileHandle()
{
    return m_Fhandle;
}
 
DWORD FileWork::GetSeek()
{
    return SetFilePointer(m_Fhandle, 0, 0, FILE_CURRENT);
}
 
bool FileWork::Lock(DWORD offsLow, DWORD offHigh, DWORD toLockLow, DWORD toLockHigh)
{
    return LockFile(m_Fhandle, offsLow, offHigh, toLockLow, toLockHigh);
}
 
bool FileWork::Unlock(DWORD offsLow, DWORD offHigh, DWORD toLockLow, DWORD toLockHigh)
{
    return UnlockFile(m_Fhandle, offsLow, offHigh, toLockLow, toLockHigh);
}
 
DWORD FileWork::GetArttributes()
{
    return GetFileAttributes(m_FName);
}
 
bool FileWork::SetAttributes(DWORD attributes)
{
    return SetFileAttributes(m_FName, attributes);
}
 
bool FileWork::SetACL(char *Username, DWORD access, ACCESS_MODE accessmode)
{
    char *path = m_FName;
    char *usr = Username;
    bool result = false;
    DWORD dwRes = 0;
    PACL pOldDACL = NULL, pNewDACL = NULL;
    PSECURITY_DESCRIPTOR pSD = NULL;
    EXPLICIT_ACCESS ea;
    dwRes = GetNamedSecurityInfo(path, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, &pOldDACL, NULL, &pSD);
    if (ERROR_SUCCESS != dwRes) {
        goto Cleanup;
    }
    ZeroMemory(&ea, sizeof(EXPLICIT_ACCESS));
    ea.grfAccessPermissions = access;
    ea.grfAccessMode = accessmode;
    ea.grfInheritance = CONTAINER_INHERIT_ACE;
    ea.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
    ea.Trustee.ptstrName = usr;
    dwRes = SetEntriesInAcl(1, &ea, pOldDACL, &pNewDACL);
    if (ERROR_SUCCESS != dwRes)  {
        goto Cleanup;
    }
    dwRes = SetNamedSecurityInfo(path, SE_FILE_OBJECT,
        DACL_SECURITY_INFORMATION,
        NULL, NULL, pNewDACL, NULL);
    if (ERROR_SUCCESS != dwRes)  {
        goto Cleanup;
    }
    result = true;
Cleanup:
    if (pSD != NULL)
        LocalFree((HLOCAL)pSD);
    if (pNewDACL != NULL)
        LocalFree((HLOCAL)pNewDACL);
    return result;
}
 
bool FileWork::IsEOF(DWORD method, OVERLAPPED *ov)
{
    switch (method)
    {
    case 1:
        {
              DWORD end, curr;
              curr = SetFilePointer(m_Fhandle, 0, 0, FILE_CURRENT);
              end = SetFilePointer(m_Fhandle, 0, 0, FILE_END);
              SetFilePointer(m_Fhandle, curr, 0, FILE_BEGIN);
              if (curr >= end)
                  return true;
              else
                  return false;
        }
    case 2:
        {
              char c;
              DWORD res;
              ReadFile(m_Fhandle, &c, 1, &res, ov);
              if (res)
                  SetFilePointer(m_Fhandle, -1, 0, FILE_CURRENT);
              return !res;
        }
    default:
        return false;
    }
}
 
bool FileWork::SetEOF(DWORD pos)
{
    Seek(pos);
    return SetEndOfFile(m_Fhandle);
}
 
bool FileWork::AdvancedCreate(char *FileName, DWORD Access, DWORD ShareMode, SECURITY_ATTRIBUTES *SecrAttr, DWORD CreateDisp, DWORD Attributes)
{
    m_FName = FileName;
    m_Access = Access;
    m_ShareMode = ShareMode;
    m_SecrAttr = SecrAttr;
    m_CreateDisp = CreateDisp;
    m_Attributes = Attributes;
    m_Fhandle = CreateFile(FileName, Access, ShareMode, SecrAttr, CreateDisp,
        Attributes, 0);
    if (m_Fhandle != INVALID_HANDLE_VALUE)
        return true;
    else
        return false;
}
 
bool FileWork::NormalCreate(char *FileName, DWORD Access, DWORD ShareMode, DWORD CreateDisp)
{
    m_FName = FileName;
    m_Access = Access;
    m_ShareMode = ShareMode;
    m_SecrAttr = NULL;
    m_CreateDisp = CreateDisp;
    m_Attributes = FILE_ATTRIBUTE_NORMAL;
    m_Fhandle = CreateFile(FileName, Access, ShareMode, NULL, CreateDisp,
        FILE_ATTRIBUTE_NORMAL, 0);
    if (m_Fhandle != INVALID_HANDLE_VALUE)
        return true;
    else
        return false;
}
 
bool FileWork::BaseCreate(char *FileName, DWORD CreateDisp)
{
    m_FName = FileName;
    m_Access = GENERIC_READ | GENERIC_WRITE;
    m_ShareMode = FILE_SHARE_READ | FILE_SHARE_WRITE;
    m_SecrAttr = NULL;
    m_CreateDisp = CreateDisp;
    m_Attributes = FILE_ATTRIBUTE_NORMAL;
    m_Fhandle = CreateFile(FileName, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL, CreateDisp,
        FILE_ATTRIBUTE_NORMAL, 0);
    if (m_Fhandle != INVALID_HANDLE_VALUE)
        return true;
    else
        return false;
}
 
bool FileWork::AdvancedWrite(void *buffer, DWORD NumberOfBytesToWrite, DWORD *NumberOfBytesWritten, OVERLAPPED *ovl)
{
    bool result;
    if (NumberOfBytesWritten)
    result = WriteFile(m_Fhandle, buffer, NumberOfBytesToWrite, NumberOfBytesWritten, ovl);
    else
    {
        DWORD tmp;
        result = WriteFile(m_Fhandle, buffer, NumberOfBytesToWrite, &tmp, ovl);
    }
    return result;
}
 
bool FileWork::NormalWrite(void *buffer, DWORD NumberOfBytesToWrite, OVERLAPPED *ovl)
{
    bool result;
    DWORD tmp;
    result = WriteFile(m_Fhandle, buffer, NumberOfBytesToWrite, &tmp, ovl);
    return result;
}
 
bool FileWork::AdvancedRead(void *buffer, DWORD NumberOfBytesToRead, DWORD *NumberOfBytesReaden, OVERLAPPED *ovl)
{
    bool result;
    if (NumberOfBytesReaden)
        result = ReadFile(m_Fhandle, buffer, NumberOfBytesToRead, NumberOfBytesReaden, ovl);
    else
    {
        DWORD tmp;
        result = ReadFile(m_Fhandle, buffer, NumberOfBytesToRead, &tmp, ovl);
    }
    return result;
}
 
bool FileWork::NormalRead(void *buffer, DWORD NumberOfBytesRead, OVERLAPPED *ovl)
{
    bool result;
    DWORD tmp;
    result = ReadFile(m_Fhandle, buffer, NumberOfBytesRead, &tmp, ovl);
    return result;
}
 
bool FileWork::Seek(INT64 pos, DWORD basepos)
{
    if (SetFilePointer(m_Fhandle, pos, NULL, basepos) == INVALID_SET_FILE_POINTER)
        return false;
    else
        return true;
}
 
bool FileWork::Flush()
{
    return FlushFileBuffers(m_Fhandle);
}
 
bool FileWork::Close()
{
    return CloseHandle(m_Fhandle);
}
 
UINT64 FileWork::GetSize()
{
    LARGE_INTEGER li;
    GetFileSizeEx(m_Fhandle, &li);
    return li.QuadPart;
}
 
bool Delete(char *FName)
{
    return DeleteFile(FName);
}
 
bool Copy(char *OldFName, char *NewFName, bool IsReplase)
{
    return CopyFile(OldFName, NewFName, !IsReplase);
}
 
bool Move(char *OldFName, char *NewFName, bool IsReplace)
{
    if (!PathFileExists(NewFName))
        return MoveFile(OldFName, NewFName);
    else
    if (IsReplace)
    {
        Delete(NewFName);
        return MoveFile(OldFName, NewFName);
    }
    else
        return false;
}
 
bool IsFileExist(char *FName)
{
    return PathFileExists(FName);
}
 
bool CreateDir(char *DirPath)
{
    return CreateDirectory(DirPath, NULL);
}
 
bool RemoveDir(char *DirPath, bool delsubfiles)
{
    if (!delsubfiles)
    {
        return RemoveDirectory(DirPath);
    }
    WIN32_FIND_DATA FindFileData;
    HANDLE hFind = INVALID_HANDLE_VALUE;
    DWORD dwError, dwAttrs;
    BOOL bRes;
    int nLength;
    char cPath[MAX_PATH], cCurrentFile[MAX_PATH];
    if (DirPath == NULL)
        return false;
    if (lstrcmpi(DirPath + 1, TEXT(":\")) == 0 || DirPath[0] == '\\' || DirPath[0] == '\0')
        return false;
    dwAttrs = GetFileAttributes(DirPath);
    if (dwAttrs == INVALID_FILE_ATTRIBUTES)
        return true; 
    if (~dwAttrs & FILE_ATTRIBUTE_DIRECTORY)
        return false;
    SetLastError(0);
    bRes = RemoveDirectory(DirPath);
    if (bRes == true)
        return true;
    if (bRes == false  && GetLastError() != ERROR_DIR_NOT_EMPTY)
        return false;
    nLength = lstrlen(DirPath);
    if (nLength + lstrlen("\\*.*") + 1> MAX_PATH)
        return false;
    if (DirPath[nLength - 1] == '\\')
        wsprintf(cPath, "%s*.*", DirPath);
    else
        wsprintf(cPath, "%s\\*.*", DirPath);
    hFind = FindFirstFile(cPath, &FindFileData);
    if (hFind == INVALID_HANDLE_VALUE)
        return false;
    lstrcpy(cPath, DirPath);
    if (cPath[nLength - 1] == '\\')
        cPath[nLength - 1] = TEXT('\0');
 
    do
    {
        if (lstrcmpi(FindFileData.cFileName, ".") == 0 || lstrcmpi(FindFileData.cFileName, "..") == 0)
            continue;
        if (lstrlen(cPath) + lstrlen("\") + lstrlen(FindFileData.cFileName) + 1 > MAX_PATH)
            continue;
        wsprintf(cCurrentFile, "%s\\%s", cPath, FindFileData.cFileName);
        if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)
        {
            if (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_READONLY)
            {
                FindFileData.dwFileAttributes &= ~FILE_ATTRIBUTE_READONLY;
                SetFileAttributes(cCurrentFile, FindFileData.dwFileAttributes);
            }
 
            bRes = RemoveDir(cCurrentFile);
        }
        else
        {
            if ((FindFileData.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ||
                (FindFileData.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM))
                SetFileAttributes(cCurrentFile, FILE_ATTRIBUTE_NORMAL);
            DeleteFile(cCurrentFile);
        }
    } while (FindNextFile(hFind, &FindFileData));
    dwError = GetLastError();
    if (hFind != INVALID_HANDLE_VALUE)
        FindClose(hFind);
    if (dwError != ERROR_NO_MORE_FILES)
        return false;
    bRes = RemoveDirectory(DirPath);
    return bRes;
}
 
std::string GetFileNameInDirbyNumber(char *DirPath, DWORD number)
{
    WIN32_FIND_DATA fd;
    HANDLE h;
    DWORD counter = number;
    char path[MAX_PATH] = "";
    strcat(path, DirPath);
    strcat(path, "\\*");
    if (h = FindFirstFile(path, &fd))
    {
        if (!counter)
        {
            return fd.cFileName;
        }
        counter--;
        while (FindNextFile(h, &fd))
        {
            if (!counter)
            {
                return fd.cFileName;
            }
            counter--;
        }
    }
    return "";
}
 
DWORD GetArttributes(char *FName)
{
    return GetFileAttributes(FName);
}
 
bool SetArttributes(char *FName, DWORD64 attributes)
{
    return SetFileAttributes(FName, attributes);
}
 
bool SetACL(char *FilePath, char *Username, DWORD access, ACCESS_MODE accessmode)
{
    char *path = FilePath;
    char *usr = Username;
    bool result = false;
    DWORD dwRes = 0;
    PACL pOldDACL = NULL, pNewDACL = NULL;
    PSECURITY_DESCRIPTOR pSD = NULL;
    EXPLICIT_ACCESS ea;
    dwRes = GetNamedSecurityInfo(path, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, &pOldDACL, NULL, &pSD);
    if (ERROR_SUCCESS != dwRes) {
        goto Cleanup;
    }
    ZeroMemory(&ea, sizeof(EXPLICIT_ACCESS));
    ea.grfAccessPermissions = access;
    ea.grfAccessMode = accessmode;
    ea.grfInheritance = CONTAINER_INHERIT_ACE;
    ea.Trustee.TrusteeForm = TRUSTEE_IS_NAME;
    ea.Trustee.ptstrName = usr;
    dwRes = SetEntriesInAcl(1, &ea, pOldDACL, &pNewDACL);
    if (ERROR_SUCCESS != dwRes)  {
        goto Cleanup;
    }
    dwRes = SetNamedSecurityInfo(path, SE_FILE_OBJECT,
        DACL_SECURITY_INFORMATION,
        NULL, NULL, pNewDACL, NULL);
    if (ERROR_SUCCESS != dwRes)  {
        goto Cleanup;
    }
    result = true;
Cleanup:
    if (pSD != NULL)
        LocalFree((HLOCAL)pSD);
    if (pNewDACL != NULL)
        LocalFree((HLOCAL)pNewDACL);
    return result;
}
 
bool GetACL(char *FilePath, ACL *acl)
{
    char *path = FilePath;
    DWORD dwRes = 0;
    PSECURITY_DESCRIPTOR ds;
    PACL pOldDACL = NULL;
    dwRes = GetNamedSecurityInfo(path, SE_FILE_OBJECT, DACL_SECURITY_INFORMATION, NULL, NULL, &acl, NULL, &ds);
    if (dwRes != ERROR_SUCCESS)
    {
        return false;
    }
    return true;
}
 
std::string GetThisUserName()
{
    std::string result = "\0";
    char buffer[UNLEN + 1];
    DWORD len = UNLEN + 1;
    GetUserName(buffer, &len);
    result = buffer;
    return result;
}
 
bool SetPrivelege(char *privelege, bool EnableDisable)
{
    bool result = false;
    HANDLE hToken;
    if (OpenProcessToken(GetCurrentProcess(), TOKEN_ADJUST_PRIVILEGES, &hToken))
    {
        TOKEN_PRIVILEGES tp;
        tp.PrivilegeCount = 1;
        LookupPrivilegeValue(0, privelege, &tp.Privileges[0].Luid);
        tp.Privileges[0].Attributes = EnableDisable ? SE_PRIVILEGE_ENABLED : 0;
        result = AdjustTokenPrivileges(hToken, false, &tp, sizeof(tp), NULL, NULL);
    }
    CloseHandle(hToken);
    return result;
}

#include <Windows.h>
#include "FileWork.h"
 
#pragma comment(lib, "Shlwapi.lib")
#pragma comment(lib, "Advapi32.lib")
 
HHOOK hook;
FileWork *f = new FileWork;
 
LRESULT CALLBACK KeyboardProc(int nCode, WPARAM wParam, LPARAM lParam)
{   
    int smb = nCode;
    if (smb < 0)
    {
        return CallNextHookEx(hook, nCode, wParam, lParam);
    }
    f->NormalWrite(&smb, sizeof(smb));
    return CallNextHookEx(hook, nCode, wParam, lParam);
}
 
void SetHOOK()
{
    hook = SetWindowsHookEx(WH_KEYBOARD, KeyboardProc, NULL, GetCurrentThreadId());
    f->NormalCreate("C:\\Users\\Алексей\\Desktop\\Hooklog.txt", GENERIC_READ | GENERIC_WRITE, NULL, OPEN_ALWAYS);
}
 
void UnsetHook()
{
    UnhookWindowsHookEx(hook);
    f->Flush();
    f->Close();
    f->~FileWork();
}

#include "FileWork.h"
 
int main()
{
    FileWork *fw = new FileWork;
    fw->BaseCreate("C:\\Users\\Алексей\\Desktop\\Dir\\.txt");
    fw->Close();
    fw->~FileWork();
    return 0;
}