郵件模組開發3 1)判斷文件大小2)文件上傳代碼

文件大小判斷!

if (strAttachFile!="")

{

CFileFind finder;

if (!finder.FindFile(strAttachFile)) {

output.Format("Can not find the file: %s",strAttachFile);

AfxMessageBox(output);

return;

}

finder.FindNextFile();

output.Format("The file:%s AttachSize is %d",strAttachFile,finder.GetLength());

AfxMessageBox(output);

}

文件傳輸

.h頭文件

// UploadManager.h: interface for the CUploadManager class.

//////////////////////////////////////////////////////////////////////

#if !defined(AFX_UPLOADMANAGER_H__66BA30A7_E2DA_4F36_8733_C73E95F4B101__INCLUDED_)

#define AFX_UPLOADMANAGER_H__66BA30A7_E2DA_4F36_8733_C73E95F4B101__INCLUDED_

#if _MSC_VER > 1000

#pragma once

#endif // _MSC_VER > 1000

class CUploadManager

{

public:

CUploadManager();

virtual ~CUploadManager();

public:

void OnDeleteRet(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP);

void SetCallback(ECPUPLOADFILECALLBACK pFunc, LPVOID pParm);

void OnBufCfm(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP){SetEvent(m_EventBufRet);}

void Release();

BOOL Initial();

BOOL IsRunning(){return m_bIsRunning;}

void ThreadStart(CString strFilePathName);

BOOL StartReq(CString strFilePathName, DWORD dwMeetingID);

void SetParm(DWORD dwMaxNetDataNum, DWORD dwPackageSize);

void SetTransclt(ITransClt* pTransClt){m_pTransClt = pTransClt;}

void OnCancelRet(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP)

{if(m_pCallback) m_pCallback(ECP_UF_CANCEL, 0, 0, m_pParm); Release();}

void Cancel();

void DircectCancel();

void OnReceive(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP);

BOOL GetUploadState(){return m_bIsRunning;};

void SetUpLoadMode(BOOL bDirect){m_bDirect = bDirect;}

static DWORD WINAPI InterceptionThread(LPVOID lpv);

HANDLE m_hSvrRespond;

CWinThread * m_pThreadInter;

private:

LPVOID m_pParm;

ECPUPLOADFILECALLBACK m_pCallback;

void OnEndRet(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP);

void End();

void OnStartRet(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP);

BOOL SendBuffer(LPBYTE lpBuf, DWORD dwSize);

DWORD ThreadProc(CString strFilePathName);

static DWORD WINAPI Thread(LPVOID lpv);

BOOL m_bStop;

BOOL m_bIsRunning;

BOOL m_bDirect;

DWORD m_dwPreSendTime;

DWORD m_dwWaitTimeLen;

DWORD m_dwID;

DWORD m_dwPackageSize;

DWORD m_dwMaxNetDataNum;

DWORD m_dwMeetingID;

DWORD m_dwFileLen;

ITransClt * m_pTransClt;

CWinThread * m_pThread;

HANDLE m_EventStartRet;

HANDLE m_EventBufRet;

HANDLE m_EventThreadStart;

};

#endif // !defined(AFX_UPLOADMANAGER_H__66BA30A7_E2DA_4F36_8733_C73E95F4B101__INCLUDED_)

.cpp文件

// UploadManager.cpp: implementation of the CUploadManager class.

//////////////////////////////////////////////////////////////////////

#include "stdafx.h"

#include "ECPFileTrans.h"

#include "UploadManager.h"

#ifdef _DEBUG

#undef THIS_FILE

static char THIS_FILE[]=__FILE__;

#define new DEBUG_NEW

#endif

extern BOOL g_bSuccessDeleteUploadFile;

extern HANDLE g_EventDeleteUploadFile;

typedef struct _tag_UPLOAD_THREAD_PARAM

{

CUploadManager * pUploadManager;

char szFilePathName[MAX_PATH];

_tag_UPLOAD_THREAD_PARAM()

{

ZeroMemory(this, sizeof(_tag_UPLOAD_THREAD_PARAM));

};

} UPLOAD_THREAD_PARAM, *PUPLOAD_THREAD_PARAM;

//////////////////////////////////////////////////////////////////////

// Construction/Destruction

//////////////////////////////////////////////////////////////////////

CUploadManager::CUploadManager()

{

m_pTransClt = NULL;

m_pThread = NULL;

m_pParm = NULL;

m_dwMaxNetDataNum = 25600; //200Kb

m_dwPackageSize = 1024; //8Kb

m_dwPreSendTime = -1;

m_dwWaitTimeLen = 0;

m_dwID = 0;

m_dwMeetingID = 0;

m_dwFileLen = 0;

m_bStop = FALSE;

m_bIsRunning = FALSE;

m_bDirect = FALSE;

m_hSvrRespond = CreateEvent(NULL, TRUE, FALSE, NULL);

ResetEvent(m_hSvrRespond);

}

CUploadManager::~CUploadManager()

{

}

void CUploadManager::OnReceive(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP)

{

DWORD dwCmd = 0;

dwCmd = pCmd->dwCmd;

switch(dwCmd)

{

case CMD_FT_UPLOAD_START_RET:

OnStartRet(pCmd, uHandle, pIP);

break;

case CMD_FT_UPLOAD_BUFFER_CFM:

OnBufCfm(pCmd, uHandle, pIP);

SetEvent(m_hSvrRespond);

break;

case CMD_FT_UPLOAD_CANCEL_RET:

OnCancelRet(pCmd, uHandle, pIP);

SetEvent(m_hSvrRespond);

break;

case CMD_FT_UPLOAD_END_RET:

OnEndRet(pCmd, uHandle, pIP);

SetEvent(m_hSvrRespond);

break;

case CMD_FT_DELETE_UPLOAD_FILE_RET:

OnDeleteRet(pCmd, uHandle, pIP);

SetEvent(m_hSvrRespond);

break;

default:

break;

}

DWORD WINAPI CUploadManager::Thread(LPVOID lpv)

{

PUPLOAD_THREAD_PARAM pUploadThreadParam = NULL;

CUploadManager * pUploadManager = NULL;

CString strFilePathName = _T("");

pUploadThreadParam = (PUPLOAD_THREAD_PARAM)lpv;

pUploadManager = pUploadThreadParam->pUploadManager;

strFilePathName = (CString)pUploadThreadParam->szFilePathName;

return pUploadManager->ThreadProc(strFilePathName);

}

DWORD CUploadManager::ThreadProc(CString strFilePathName)

{

CFile file;

DWORD dwSize = 0;

DWORD dwLenAllProc = 0;

DWORD dwPackageSize = 0;

DWORD dwSizeRead = 0;

PECP_FT_UPLOAD_BUFFER pFtBuf = NULL;

int nPercent = 0;

if(!file.Open(strFilePathName, CFile::modeRead | CFile::shareDenyWrite))

return 0;

SetEvent(m_EventThreadStart);

m_bStop = FALSE;

dwLenAllProc = file.GetLength();

while(!m_bStop)

{

//check if data package size modified

if(dwPackageSize != m_dwPackageSize)

{

dwPackageSize = m_dwPackageSize;

pFtBuf = (PECP_FT_UPLOAD_BUFFER)realloc(pFtBuf, dwPackageSize + sizeof(ECP_FT_UPLOAD_BUFFER));

if(NULL == pFtBuf)

break;

}

//process read buffer from file

pFtBuf->dwMeetID = theApp.m_dwMeetID;

pFtBuf->dwID = m_dwID;

pFtBuf->dwStartPos = dwSize;

file.Seek(dwSize, CFile::begin);

pFtBuf->dwSize = file.ReadHuge(pFtBuf->pBuf, dwPackageSize);

dwSizeRead = pFtBuf->dwSize;

if(0 == dwSizeRead)

break;

//send buffer

SendBuffer((LPBYTE)pFtBuf, dwSizeRead + sizeof(ECP_FT_UPLOAD_BUFFER));

if(m_bDirect && dwSize == 0)

Sleep(200);

//continue

dwSize += pFtBuf->dwSize;

nPercent = dwSize * 100 / dwLenAllProc;

m_pCallback(ECP_UF_PROGRESS, (DWORD)nPercent, 0, m_pParm);

}

free(pFtBuf);

file.Close();

//process end normally

if(dwSize == dwLenAllProc)

End();

return dwSize;

}

BOOL CUploadManager::SendBuffer(LPBYTE lpBuf, DWORD dwSize)

{

BOOL bResult = FALSE;

PCMD_HEAD pHead = NULL;

DWORD dwCurrent = 0;

pHead = (PCMD_HEAD)new BYTE[sizeof(CMD_HEAD) + dwSize];

if(NULL == pHead)

return FALSE;

memset(pHead, 0, sizeof(CMD_HEAD) + dwSize);

if(!m_bDirect)

pHead->dwCmd = CMD_FT_UPLOAD_BUFFER_NTF;

else

pHead->dwCmd = CMD_FT_UPLOAD_BUFFER_DIRECT;

pHead->nBufSize = dwSize;

memcpy(pHead->pBuf, lpBuf, dwSize);

if(m_dwPreSendTime != -1)

{

dwCurrent = GetTickCount();

if(m_dwWaitTimeLen > dwCurrent - m_dwPreSendTime)

Sleep(m_dwWaitTimeLen - (dwCurrent - m_dwPreSendTime));

}

if(NULL != m_pTransClt)

bResult = m_pTransClt->SendToServer(pHead, sizeof(CMD_HEAD) + dwSize);

if(NULL != pHead)

{

delete [] pHead;

pHead = NULL;

}

//record current state

m_dwPreSendTime = GetTickCount();

m_dwWaitTimeLen = (dwSize * 1000) / m_dwMaxNetDataNum;

return bResult;

}

void CUploadManager::OnStartRet(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP)

{

m_dwID = *(DWORD *)pCmd->pBuf;

m_pCallback(ECP_UF_START, 0, 0, m_pParm);

Sleep(200);//give the client time to create press dialog

SetEvent(m_EventStartRet);

}

void CUploadManager::OnEndRet(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP)

{

m_pCallback(ECP_UF_END, 1, m_dwID, m_pParm);

Release();

}

void CUploadManager::End()

{

PCMD_HEAD pHead = NULL;

PECP_FT_UPLOAD_END_REQ pInfo = NULL;

m_pThread = NULL;

pHead = (PCMD_HEAD)new BYTE[sizeof(CMD_HEAD) + sizeof(ECP_FT_UPLOAD_END_REQ)];

if(NULL == pHead)

return;

memset(pHead, 0, sizeof(CMD_HEAD) + sizeof(ECP_FT_UPLOAD_END_REQ));

pHead->dwCmd = CMD_FT_UPLOAD_END_REQ;

pHead->nBufSize = sizeof(ECP_FT_UPLOAD_END_REQ);

pInfo = (PECP_FT_UPLOAD_END_REQ)pHead->pBuf;

pInfo->dwID = m_dwID;

pInfo->dwMeetingID = m_dwMeetingID;

pInfo->dwFileLen = m_dwFileLen;

m_pTransClt->SendToServer(pHead, sizeof(CMD_HEAD) + sizeof(ECP_FT_UPLOAD_END_REQ));

if(NULL != pHead)

{

delete [] pHead;

pHead = NULL;

}

void CUploadManager::Cancel()

{

PCMD_HEAD pHead = NULL;

m_bStop = TRUE;

WaitForSingleObject(*m_pThread, INFINITE);

m_pThread = NULL;

m_bIsRunning = FALSE;

pHead = (PCMD_HEAD)new BYTE[sizeof(CMD_HEAD) + sizeof(DWORD)];

if(NULL == pHead)

return;

memset(pHead, 0, sizeof(CMD_HEAD) + sizeof(DWORD));

pHead->dwCmd = CMD_FT_UPLOAD_CANCEL_REQ;

pHead->nBufSize = sizeof(DWORD);

memcpy(pHead->pBuf, &m_dwID, sizeof(DWORD));

if(NULL != m_pTransClt)

m_pTransClt->SendToServer(pHead, sizeof(CMD_HEAD) + sizeof(DWORD));

if(NULL != pHead)

{

delete [] pHead;

pHead = NULL;

}

void CUploadManager::SetParm(DWORD dwMaxNetDataNum, DWORD dwPackageSize)

{

m_dwMaxNetDataNum = dwMaxNetDataNum;

m_dwPackageSize = (dwPackageSize > dwMaxNetDataNum) ? dwMaxNetDataNum : dwPackageSize;

}

BOOL CUploadManager::StartReq(CString strFilePathName, DWORD dwMeetingID)

{

PCMD_HEAD pHead = NULL;

PECP_FT_UPLOAD_START_REQ pInfo = NULL;

CFile file;

CString strWarn;

CString strFileName;

DWORD dwFileLen = 0;

if(!file.Open(strFilePathName, CFile::modeRead | CFile::shareDenyWrite))

{

strWarn = _T("Cannot Open File : /"") + strFilePathName + _T("/"");

OutputDebugString(strWarn);

return FALSE;

}

dwFileLen = file.GetLength();

strFileName = file.GetFileName();

file.Close();

pHead = (PCMD_HEAD)new BYTE[sizeof(CMD_HEAD) + sizeof(ECP_FT_UPLOAD_START_REQ)];

if(NULL == pHead)

return FALSE;

memset(pHead, 0, sizeof(CMD_HEAD) + sizeof(ECP_FT_UPLOAD_START_REQ));

pHead->dwCmd = CMD_FT_UPLOAD_START_REQ;

pHead->nBufSize = sizeof(ECP_FT_UPLOAD_START_REQ);

pInfo = (PECP_FT_UPLOAD_START_REQ)pHead->pBuf;

pInfo->dwFileLen = dwFileLen;

pInfo->dwMeetingID = dwMeetingID;

m_pTransClt->SendToServer(pHead, sizeof(CMD_HEAD) + sizeof(ECP_FT_UPLOAD_START_REQ));

if(NULL != pHead)

{

delete [] pHead;

pHead = NULL;

}

m_EventStartRet = CreateEvent(NULL, FALSE, FALSE, NULL);

if(WAIT_TIMEOUT == WaitForSingleObject(m_EventStartRet, 5000))

return FALSE;

return TRUE;

}

void CUploadManager::ThreadStart(CString strFilePathName)

{

//start upload thread

UPLOAD_THREAD_PARAM Param;

Param.pUploadManager = this;

strcpy(Param.szFilePathName, strFilePathName);

if(m_pThread == NULL)

{

m_pThread = AfxBeginThread((AFX_THREADPROC)Thread,

&Param,

THREAD_PRIORITY_NORMAL,

CREATE_SUSPENDED,

NULL);

m_pThread->ResumeThread();

m_EventThreadStart = CreateEvent(NULL, FALSE, FALSE, NULL);

WaitForSingleObject(m_EventThreadStart, INFINITE);

}

BOOL CUploadManager::Initial()

{

m_bIsRunning = TRUE;

m_pThreadInter = NULL;

m_pThreadInter = AfxBeginThread((AFX_THREADPROC)InterceptionThread,

this,

THREAD_PRIORITY_NORMAL,

NULL);

ResetEvent(m_hSvrRespond);

return TRUE;

}

DWORD WINAPI CUploadManager::InterceptionThread(LPVOID lpv)

{

CUploadManager *pThis = (CUploadManager *)lpv;

while(pThis->m_bIsRunning)

{

DWORD dwReturn = WaitForSingleObject(pThis->m_hSvrRespond,15000);

if(WAIT_TIMEOUT == dwReturn)

{

pThis->m_bIsRunning = FALSE;

pThis->Release();

pThis->m_pCallback(ECP_UF_OUTOF_CONNECT,0L,0L,pThis->m_pParm);

}

ResetEvent(pThis->m_hSvrRespond);

}

return 0;

}

void CUploadManager::Release()

{

m_bIsRunning = FALSE;

m_pTransClt = NULL;

m_pThread = NULL;

m_dwMaxNetDataNum = 25600; //200Kb

m_dwPackageSize = 1024; //8Kb

m_dwPreSendTime = -1;

m_dwWaitTimeLen = 0;

m_dwID = 0;

m_dwMeetingID = 0;

m_dwFileLen = 0;

m_bDirect = FALSE;

}

void CUploadManager::SetCallback(ECPUPLOADFILECALLBACK pFunc, LPVOID pParm)

{

m_pCallback = pFunc;

m_pParm = pParm;

}

void CUploadManager::OnDeleteRet(PCMD_HEAD pCmd, UINT uHandle, PIP_ADDR pIP)

{

PECP_FT_DELETE_UPLOAD_FILE_RET pInfo = NULL;

pInfo = (PECP_FT_DELETE_UPLOAD_FILE_RET)pCmd->pBuf;

g_bSuccessDeleteUploadFile = pInfo->bIsSuccess;

SetEvent(g_EventDeleteUploadFile);

}

使用

void ECPUploadFileSetCallback(ECPUPLOADFILECALLBACK pFunc, LPVOID pParm)

{

g_Upload.SetCallback(pFunc, pParm);

}

void ECPUploadFile(CString strFilePathName, DWORD dwMeetingID, ITransClt * pTransClt, DWORD dwMaxNetDataNum, DWORD dwPackageSize)

{

if(g_Upload.IsRunning())

{

OutputDebugString("Upload thread is runing, Pls wait.");

return;

}

g_Upload.Initial();

g_Upload.SetParm(dwMaxNetDataNum, dwPackageSize);

g_Upload.SetTransclt(pTransClt);

if(!g_Upload.StartReq(strFilePathName, dwMeetingID))

{

OutputDebugString("Request start upload fail.");

g_Upload.Release();

return;

}

theApp.m_dwMeetID = dwMeetingID;

//thread start.

g_Upload.ThreadStart(strFilePathName);

}

void ECPUploadFileCancel()

{

g_Upload.Cancel();

}

外層調用

::ECPUploadFileSetCallback(UploadFileCallback, this);

::ECPUploadFile(theFilePath,

-1,

m_pTransClt,

1000*128,

8*128);

郵件模組開發3 1)判斷文件大小2)文件上傳代碼

985 碩士程序員，空窗 4 個月沒有 Offer！

一文搞懂 Spring 循環依賴

賽博鬥地主——使用大語言模型扮演Agent智能體玩牌類遊戲。

VScode右鍵打開(添加到右鍵)

記一次 .NET某工控視覺自動化系統卡死分析

WindowsServer--SQL Server搭建主從同步實現讀寫分離 - 事務性分發

java由於越界導致的報錯

vc學習(2005-01)

郵件模組開發3 1)判斷文件大小2)文件上傳代碼

Mail模組雜記2.doc

視頻會議

可以變成藍屏的reg文件

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結