Document size judgment!
IF (StrattachFile! = "")
{
CFILEFIND FINDER;
IF (! Finder.findfile) {
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);
}
file transfer
Had file
// 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 overce
#ENDIF / / 100 m _ _
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) {setVent (m_eventbufret);
Void release ();
BOOL initial ();
Bool isrunning () {return m_bisrunning;
Void ThreadStart (CString Strfilepathname);
Bool StartReq (CSTRING STRFILEPATHNAME, DWORD DWMEETIID);
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_PARM); 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_HSVRRRRESPOND;
CWINTHREAD * m_PTHREADINTER;
Private:
LPVOID M_PPARM;
ECPUPLOADFILECALLBACK M_PCALLBACK; Void Oneund (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_DWFILEN;
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 file
// 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_HSVRRRRESPOND = CreateEvent (NULL, TRUE, FALSE, NULL);
ResetEvent (m_hsvrrrespond);
}
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_hsvrreespond);
Break;
Case cmd_ft_upload_cancel_ret:
Oncancelret (PCMD, UHANDLE, PIP);
SetEvent (m_hsvrreespond);
Break;
Case CMD_FT_UPLOAD_END_RET:
OneundRet (PCMD, UHANDLE, PIP);
SetEvent (m_hsvrreespond);
Break;
Case cmd_ft_delete_upload_file_ret:
Ondeleteret (PCMD, UHANDLE, PIP);
SetEvent (m_hsvrreespond);
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 = PUPLOADTHREADPAR_> PuploadManager;
Strfilepathname = (cstring) PUPLOADTHREADPAR_> SZFILEPATHNAME;
Return PuploadManager-> ThreadProc (StrfilePathname);
}
DWORD CUPLOADMANAGER :: ThreadProc (CString Strfilepathname)
{
Cfile file; dWord dwsize = 0;
DWORD dwlenallproc = 0;
DWORD dwPackagesize = 0;
DWORD DWSIREAD = 0;
PECP_FT_UPLOAD_BUFFER PFTBUF = NULL;
INT npercent = 0;
IF (! file.open (strfilepathname, cfile :: moderad | cfile :: sharednywrite))
Return 0;
SetEvent (m_eventthreadstart);
m_bstop = false;
DWLENALLPROC = file.getlength ();
While (! m_bstop)
{
// Check if Data package size modifie
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);
DWSREAD = PFTBUF-> DWSIZE;
IF (0 == DWSREAD)
Break;
// send buffer
SendBuffer ((lpbyte) PFTBUF, DWSIZEREAD SIZEOF (ECP_FT_UPLOAD_BUFFER);
IF (m_bdirect && dwsize == 0)
Sleep (200);
//undinue
DWSIZE = PFTBUF-> DWSIZE;
NPERCENT = DWSIZE * 100 / dwlenallproc;
M_pCallback (ECP_UF_PROGRESS, (DWORD) NPERCENT, 0, M_PARM);
}
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_dwweittimelen> 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 :: Oneundret (PCMD_HEAD PCMD, UINT UHANDLE, PIP_ADDR PIP)
{
M_pcallback (ECP_UF_END, 1, M_DWID, M_PARM);
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 (Phet, Sizeof (cmd_head) sizeof (dword));
IF (NULL! = PHEAD)
{
delete [] PHEAD;
PHEAD = NULL;
}
}
Void CuployadManager :: 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 :: moderad | cfile :: sharednywrite))
{
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,
0,
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,
0,
0,
NULL);
ResetEvent (m_hsvrrrespond);
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_hsvrreespond);
}
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);
}
use
Void ECPUPLOADFILESETCALLBACK (ECPUPLOADFILECALLBACK PFUNC, LPVOID PPARM) {
g_upload.setcallback (PFUNC, PPARM);
}
Void EcpuploadFile (CString Strfilepathname, DWORD DWMEETIID, ITRANSCLT * PTRANSCLT, DWORD DWMAXNETDATANUM, DWORD DWPACKAGESIZE)
{
IF (g_upload.ismrunning ())
{
OutputDebugstring ("Upload Thread is Runing, PLS Wait.");
Return;
}
g_upload.initial ();
g_upload.setparm (dwmaxnetdatanum, dwpackages);
g_upload.settransCLT (PTRANSCLT);
IF (! g_upload.startreq (strfilepathname, dwmeeting))
{
OutputDebugstring ("Request Start Upload Fail.");
g_upload.release ();
Return;
}
THEAPP.M_DWMEETID = dwmeetingid;
// Thread start.
g_upload.threadstart (strfilepathname);
}
Void ecpuploadFilecancel ()
{
g_upload.cancel ();
}
Outer call
:: ECPUPLOADFILESETCALLBACK (UPLOADFILECALLBACK, THIS);
:: EcpuploadFile (ThefilePath,
-1,
M_PTRANSCLT,
1000 * 128,
8 * 128);
