开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp客户端 > 查看源码
WarFsys.cpp
资源名称：warftpd.zip　[点击查看]
上传用户：surprise9
上传日期：2007-01-04
资源大小：426k
文件大小：21k
源码类别：

Ftp客户端

开发平台：

Visual C++

WarFsys.cpp：源码内容
  1. // This is part of the WAR SOFTWARE SERIES initiated by Jarle Aase
  2. // Copyright 1996 by Jarle Aase. All rights reserved.
  3. // See the "War Software Series Licende Agreement" for details concerning 
  4. // use and distribution.
  5. // ---
  6. // This source code, executables and programs containing source code or
  7. // binaries or proprietetary technology from the War Software Series are
  8. // NOT alloed used, viewed or tested by any governmental agencies in
  9. // any countries. This includes the government, departments, police, 
  10. // military etc.
  11. // ---
  12. // This file is intended for use with Tab space = 2
  13. // Created and maintained in MSVC Developer Studio
  14. // ---
  15. // NAME : WarFsys.cpp
  16. // PURPOSE : Header file for all file systems used by the War daemons
  17. // PROGRAM : 
  18. // DATE : March 11 1997
  19. // AUTHOR : Jarle Aase
  20. // ---
  21. //
  22. // Overview:
  23. // This dll provides the higher levels in the server with file system calls.
  24. // The file system support UNIX/VFsys file attributes, VFsys and Win95/NT 4 
  25. // soft-links and true multithread/multiprocess access.
  26. //
  27. // Only one file system dll might be running at one time pr. machine. All
  28. // daemons will share the same file system.
  29. //
  30. // Exports are done in the .def file.
  31. // 
  32. // REVISION HISTORY
  33. // 
  35. #include "stdafx.h"
  36. #include "WarSoftware.h"
  39. #ifdef _DEBUG
  40. #define new DEBUG_NEW
  41. #undef THIS_FILE
  42. static char THIS_FILE[] = __FILE__;
  43. #endif
  47. ////////////////////////////////////////////////////////////////////////////////////
  48. // File system.
  50. CLinkedList CUserFsys::m_ObjectList; 
  51. HINSTANCE CUserFsys::m_hFsys;
  52. HWND CUserFsys::m_Fsys_hWnd;
  54. CUserFsys::CUserFsys(LPVOID *pRef)
  55. {
  56. m_IsAdmin = 0;
  57. m_IsSystem = 0;
  58. m_CallbackPending = 0;
  59. m_IsZombie = 0;
  61. m_User = INVALID_USER_VALUE;
  62. m_Class = INVALID_USER_VALUE;
  63. m_hNTsec = NULL;
  64. m_pRef = pRef;
  66. m_CWD = "";
  67. }
  69. CUserFsys::~CUserFsys()
  70. {
  71. CWarFile *pFile;
  73. while(pFile = (CWarFile *)m_OpenFiles.FirstPtr())
  74. pFile->Destroy();
  76. if (m_pRef && (*m_pRef == this))
  77. *m_pRef = NULL;
  78. }
  80. BOOL CUserFsys::StartFileSystem(LPCSTR IniPath)
  81. {
  82. CString IniPathBuf;
  83. if (IniPath == NULL)
  84. {
  85. IniPathBuf = GetStartupPath();
  86. LPSTR p = IniPathBuf.GetBuffer(1);
  87. p = strrchr(p, '\');
  88. if (*p)
  89. *p = 0;
  90. IniPathBuf.ReleaseBuffer();
  91. IniPathBuf += "\Fsys\Fsys.ini";
  92. IniPath = IniPathBuf;
  93. }
  95. // Load the file system dll
  96. CString FsysName;
  97. GetPrivateProfileString("fsys", "driver", "VfSys.dll", FsysName.GetBuffer(MAX_PATH), MAX_PATH, IniPath);
  98. FsysName.ReleaseBuffer();
  100. CLog::GetLog()->LogMsg(LOGF_SYSTEM,"CUserFsys::StartFileSystem() - Starting file system '%s'", FsysName);
  101. m_hFsys = LoadLibrary(FsysName);
  102. if (m_hFsys == NULL)
  103. {
  104. CLog::GetLog()->LogMsg(LOGF_ERROR,"CUserFsys::StartFileSystem() - Failed to load file system '%s'. %s",
  105. FsysName, GetLastErrorText());
  106. return FALSE;
  107. }
  109. BOOL (*OpenFsys)(HWND *phWnd, LPCSTR IniFilePath);
  110. if ((OpenFsys = (BOOL (*)(HWND *, LPCSTR))GetProcAddress(m_hFsys, "?OpenFsys@@YAHPAPAUHWND__@@PBD@Z")) == NULL)
  111. {
  112. FreeLibrary(m_hFsys);
  113. m_hFsys = NULL;
  114. CLog::GetLog()->LogMsg(LOGF_ERROR,"CUserFsys::StartFileSystem() - Failed to resolve OpenFsys() in dll '%s'. %s",
  115. FsysName, GetLastErrorText());
  116. return FALSE;
  117. }
  119. if (!OpenFsys(&m_Fsys_hWnd, IniPath))
  120. {
  121. CLog::GetLog()->LogMsg(LOGF_ERROR,"CUserFsys::StartFileSystem() - OpenFsys() in dll '%s' failed. %s",
  122. FsysName, GetLastErrorText());
  123. FreeLibrary(m_hFsys);
  124. m_hFsys = NULL;
  125. }
  127. return TRUE;
  128. }
  130. void CUserFsys::CloseFileSystem()
  131. {
  132. if (m_hFsys)
  133. {
  134. SendMessage(m_Fsys_hWnd,FSM_QUIT,0,0);
  135. FreeLibrary((HMODULE)m_hFsys);
  136. m_hFsys = NULL;
  137. }
  138. }
  140. void CUserFsys::LogMsg(int flag, LPCSTR Format, ...)
  141. {
  142. if (!ShouldLog(CLog::GetLog(), flag))
  143. return;
  145. {
  146. CString cBuf;
  147. ASSERT(AfxIsValidString(Format, FALSE));
  149. cBuf.Format("%s: %s", "CUserFsys", Format);
  151. va_list argList;
  152. va_start(argList, Format);
  153. CLog::GetLog()->LogMsgV(flag, cBuf, argList);
  154. va_end(argList);
  155. }
  156. }
  159. BOOL CUserFsys::ProcessRequest(int Type, WPARAM wParam, LPARAM lParam)
  160. {
  161. if (m_CallbackPending)
  162. {
  163. LogMsg(LOGF_ERROR,"ProcessRequest() - There is alredy a request pending. Call aborted.");
  164. return FALSE;
  165. }
  167. if (!IsWindow(m_Fsys_hWnd))
  168. {
  169. LogMsg(LOGF_ERROR,"ProcessRequest() - Fsys_hWnd is invalid. Call aborted.");
  170. return FALSE;
  171. }
  173. if (!SetOnHold())
  174. {
  175. LogMsg(LOGF_WARNINGS,"ProcessRequest() - SetOnHold() returned FALSE. Call aborted.");
  176. return FALSE;
  177. }
  179. m_Output.Empty();
  181. if (!SendMessage(m_Fsys_hWnd, Type, wParam, lParam))
  182. {
  183. CheckForZombie();
  184. ReleaseHold();
  185. return FALSE;
  186. }
  188. m_CallbackPending = TRUE;
  189. m_LastReqType = Type;
  191. return TRUE;
  192. }
  194. void CUserFsys::CheckForZombie()
  195. {
  196. if (m_IsZombie)
  197. throw this;
  198. }
  200. BOOL CUserFsys::SetOnHold()
  201. {
  202. ASSERT(FALSE); // Must be overridden
  203. return FALSE;
  204. }
  206. void CUserFsys::ReleaseHold()
  207. {
  208. ASSERT(FALSE); // Must be overridden
  209. }
  211. // Entry point for results
  212. void CUserFsys::OnCallback(LPARAM lParam)
  213. {
  214. ASSERT(m_CallbackPending);
  215. m_CallbackPending = 0;
  217. if (m_IsZombie)
  218. {
  219. delete this;
  220. return;
  221. }
  223. ReleaseHold();
  225. if (m_FsysErrno)
  226. {
  227. int lastError = ERROR_GEN_FAILURE;
  228. switch(m_FsysErrno)
  229. {
  230. case FSE_PERMISSION_DENIED: lastError = ERROR_ACCESS_DENIED; break;
  231. case FSE_UNKNOWN_CALL: lastError = ERROR_INVALID_FUNCTION; break;
  232. case FSE_NO_ROOTPATH: lastError = ERROR_INVALID_DRIVE; break;
  233. case FSE_BAD_ROOTPATH: lastError = ERROR_INVALID_DRIVE; break;
  234. case FSE_BAD_PATH: lastError = ERROR_INVALID_DATA; break;
  235. case FSE_PATH_NOT_FOUND: lastError = ERROR_ACCESS_DENIED; break;
  236. }
  237. SetLastError(lastError);
  238. }
  240. switch(m_LastReqType)
  241. {
  242. case FSM_CREATEUSER:
  243. OnCreate(m_FsysErrno);
  244. break;
  245. case FSM_CREATEFILE:
  246. OnCreateFile(m_FsysErrno);
  247. break;
  248. case FSM_CHDIR:
  249. OnChdir(m_FsysErrno);
  250. break;
  251. case FSM_PRPCMDLINE:
  252. OnPrpCmdLine(m_FsysErrno);
  253. break;
  254. case FSM_LIST:
  255. OnList(m_FsysErrno);
  256. break;
  257. case FSM_WLST:
  258. OnWlist(m_FsysErrno);
  259. break;
  260. case FSM_CHMOD:
  261. OnChmod(m_FsysErrno);
  262. break;
  263. case FSM_FSYSSTAT:
  264. OnFsysStat(m_FsysErrno);
  265. break;
  266. case FSM_CREATEDIR:
  267. OnCreateDirectory(m_FsysErrno);
  268. break;
  269. case FSM_DELEDIR:
  270. OnDeleteDirectory(m_FsysErrno);
  271. break;
  272. case FSM_DELEFILE:
  273. OnDeleteFile(m_FsysErrno);
  274. break;
  275. case FSM_DELE:
  276. OnDeleteGeneric(m_FsysErrno);
  277. break;
  278. case FSM_LINK:
  279. OnLinkFile(m_FsysErrno);
  280. break;
  281. case FSM_MOVE:
  282. OnMoveFile(m_FsysErrno);
  283. break;
  284. case FSM_STAT:
  285. OnStat(m_FsysErrno);
  286. break;
  287. }
  288. }
  290. // Try to log a user on to the file system
  291. // Roots in the format <VfSysPath>,<UserPath>
  292. BOOL CUserFsys::Create(
  293.  LPCSTR Roots, 
  294.  LPCSTR Home, 
  295.  USER User, 
  296.  USER Class, 
  297.  LPCSTR Name, 
  298.  DWORD Umask, 
  299.  USER AssignTo)
  300. {
  301. m_Name = Name ? Name : "uninitialized-name";
  302. m_User = User;
  303. m_Class = Class;
  304. m_Home = Home;
  305. m_FsysPath1 = Roots;
  306. m_AssignTo = AssignTo;
  307. m_Umask = Umask;
  309. return ProcessRequest(FSM_CREATEUSER, (WPARAM)this, 0);
  310. }
  312. // Log a user out from the file system. Called by the user.
  313. void CUserFsys::Logout()
  314. {
  315. if (m_CallbackPending)
  316. {
  317. m_IsZombie = TRUE;
  318. return;
  319. }
  320. delete this;
  321. }
  323. BOOL CUserFsys::OnCreate(int nErrorCode)
  324. {
  325. return TRUE;
  326. }
  328. BOOL CUserFsys::OnChdir(int nErrorCode)
  329. {
  330. return TRUE;
  331. }
  333. BOOL CUserFsys::OnPrpCmdLine(int nErrorCode)
  334. {
  335. return TRUE;
  336. }
  338. BOOL CUserFsys::OnList(int nErrorCode)
  339. {
  340. return TRUE;
  341. }
  343. BOOL CUserFsys::OnWlist(int nErrorCode)
  344. {
  345. return TRUE;
  346. }
  348. BOOL CUserFsys::OnChmod(int nErrorCode)
  349. {
  350. return TRUE;
  351. }
  353. BOOL CUserFsys::OnCreateFile(int nErrorCode)
  354. {
  355. if (m_CreateHdr.pFile->m_IsZombie || nErrorCode)
  356. {
  357. m_CreateHdr.pFile->m_ProtectFromDelete++; // Prevent callback to destroy object
  358. try
  359. {
  360. if (!m_CreateHdr.pFile->m_IsZombie)
  361. m_CreateHdr.Callback(m_CreateHdr.pFile ,FALSE , m_CreateHdr.lParam);
  362. }
  363. catch(...)
  364. {
  365. CLog::GetLog()->LogMsg(LOGF_WARNINGS,"CUserFsys::OnCreateFile(%d) - Caught unknown exception.", nErrorCode);
  366. return FALSE;
  367. }
  369. m_CreateHdr.pFile->m_ProtectFromDelete--;
  370. m_CreateHdr.pFile->Destroy();
  371. return FALSE;
  372. }
  374. m_CreateHdr.Callback(m_CreateHdr.pFile ,TRUE , m_CreateHdr.lParam);
  375. return TRUE;
  376. }
  378. BOOL CUserFsys::OnFsysStat(int nErrorCode)
  379. {
  380. return TRUE;
  381. }
  383. BOOL CUserFsys::OnCreateDirectory(int nErrorCode)
  384. {
  385. return TRUE;
  386. }
  388. BOOL CUserFsys::OnDeleteDirectory(int nErrorCode)
  389. {
  390. return TRUE;
  391. }
  393. BOOL CUserFsys::OnDeleteFile(int nErrorCode)
  394. {
  395. return TRUE;
  396. }
  398. BOOL CUserFsys::OnDeleteGeneric(int nErrorCode)
  399. {
  400. return TRUE;
  401. }
  403. BOOL CUserFsys::OnLinkFile(int nErrorCode)
  404. {
  405. return TRUE;
  406. }
  408. BOOL CUserFsys::OnMoveFile(int nErrorCode)
  409. {
  410. return TRUE;
  411. }
  413. BOOL CUserFsys::OnStat(int nErrorCode)
  414. {
  415. return TRUE;
  416. }
  419. BOOL CUserFsys::BldFileInfoList(CFileInfoList& FileList, LPCSTR Path, BOOL ListDir)
  420. {
  421. return FALSE;
  422. }
  424. BOOL CUserFsys::ChDir(LPCSTR Path)
  425. {
  426. m_FsysPath1 = Path;
  427. return ProcessRequest(FSM_CHDIR, (WPARAM)this, 0);
  428. }
  430. BOOL CUserFsys::ChMod(CCmdArgs& Args)
  431. {
  432. m_Args = Args;
  433. return ProcessRequest(FSM_CHMOD, (WPARAM)this, 0);
  434. }
  436. BOOL CUserFsys::CreateFile(LPCSTR Path, CREATE_HDR *pHdr)
  437. {
  438. if (pHdr->HdrLen != sizeof(CREATE_HDR))
  439. {
  440. LogMsg(LOGF_ERROR,"CUserFsys::CreateFile() - CREATE_HDR length mismatch");
  441. ASSERT(FALSE);
  442. return FALSE;
  443. }
  444. m_FsysPath1 = Path;
  445. m_CreateHdr = *pHdr;
  447. return ProcessRequest(FSM_CREATEFILE, (WPARAM)this, 0);
  448. }
  450. BOOL CUserFsys::FsysStat()
  451. {
  452. return ProcessRequest(FSM_FSYSSTAT, (WPARAM)this, 0);
  453. }
  455. BOOL CUserFsys::CreateDirectory(LPCSTR FsysPath)
  456. {
  457. m_FsysPath1 = FsysPath;
  458. return ProcessRequest(FSM_CREATEDIR, (WPARAM)this, 0);
  459. }
  461. BOOL CUserFsys::DeleteDirectory(LPCSTR FsysPath)
  462. {
  463. m_FsysPath1 = FsysPath;
  464. return ProcessRequest(FSM_DELEDIR, (WPARAM)this, 0);
  465. }
  467. BOOL CUserFsys::DeleteFile(LPCSTR FsysPath)
  468. {
  469. m_FsysPath1 = FsysPath;
  470. return ProcessRequest(FSM_DELEFILE, (WPARAM)this, 0);
  471. }
  473. BOOL CUserFsys::DeleteGeneric(LPCSTR FsysPath)
  474. {
  475. m_FsysPath1 = FsysPath;
  476. return ProcessRequest(FSM_DELE, (WPARAM)this, 0);
  477. }
  479. BOOL CUserFsys::LinkFile(LPCSTR FromPath, LPCSTR ToPath)
  480. {
  481. m_FsysPath1 = FromPath;
  482. m_FsysPath2 = ToPath;
  483. return ProcessRequest(FSM_LINK, (WPARAM)this, 0);
  484. }
  486. // Move and rename
  487. BOOL CUserFsys::MoveFile(LPCSTR FromPath, LPCSTR ToPath)
  488. {
  489. m_FsysPath1 = FromPath;
  490. m_FsysPath2 = ToPath;
  491. return ProcessRequest(FSM_MOVE, (WPARAM)this, 0);
  492. }
  494. BOOL CUserFsys::Stat(LPCSTR FsysPath)
  495. {
  496. m_FsysPath1 = FsysPath;
  497. return ProcessRequest(FSM_STAT, (WPARAM)this, 0);
  498. }
  500. ///////////////////////////////////////////////////////////////////////////
  501. // CFileInfo - support class for Find*File()
  503. CFileInfo::CFileInfo()
  504. {
  505. m_Comment.Empty();
  506. m_Hide = FALSE;
  507. m_pMoreUsers = NULL;
  508. m_SpecialNewFilePerms = 0;
  509. }
  511. CFileInfo::~CFileInfo()
  512. {
  513. if (m_pMoreUsers)
  514. delete m_pMoreUsers;
  515. }
  518. CString CFileInfo::MakeFileNameASCII()
  519. {
  520. CString cBuf = FileName();
  521. LPSTR p = cBuf.GetBuffer(1);
  522. while(*p)
  523. {
  524. if (!isprint(*p))
  525. *p = '?';
  526. }
  527. cBuf.ReleaseBuffer();
  528. return cBuf;
  529. }
  531. BOOL CFileInfo::Hide(int State)
  532. {
  533. if ((State == FALSE) || (State == TRUE))
  534. m_Hide = State;
  535. return m_Hide;
  536. }
  539. int CFileInfo::GetInode()
  540. {
  541. return (int)this;
  542. }
  544. int CFileInfo::GetLinks()
  545. {
  546. return m_Links;
  547. }
  551. ///////////////////////////////////////////////////////////////////////////
  552. // CFileInfoList - Representation of files, typically in one directory.
  554. CFileInfoList::CFileInfoList()
  555. {
  556. m_MaxCols = 0;
  557. m_Prev = NULL;
  558. }
  560. CFileInfoList::~CFileInfoList()
  561. {
  562. // Delete the nodes
  563. CFileInfo *Info;
  564. while(Info = (CFileInfo *)m_List.GetAndDeleteFirst())
  565. {
  566. ASSERT(AfxIsValidAddress(Info, sizeof(CFileInfo)));
  567. delete Info;
  568. }
  569. }
  571. void CFileInfoList::Add(CFileInfo *Node)
  572. {
  573. ASSERT(AfxIsValidAddress(Node,sizeof(CFileInfo)));
  574. int Len = strlen(Node->FileName());
  575. m_MaxCols = max(Len, m_MaxCols);
  577. m_List.AddLast((LPVOID)Node);
  578. }
  580. CFileInfo *CFileInfoList::GetNext(CFileInfo *Current)
  581. {
  582. if (Current)
  583. {
  584. ASSERT(AfxIsValidAddress(Current,sizeof(CFileInfo)));
  585. if (m_Prev && (m_List.Ptr(m_Prev) == Current))
  586. m_Prev = m_List.Next(m_Prev);
  587. else
  588. {
  589. if (m_Prev = m_List.FindPtr(Current))
  590. m_Prev = m_List.Next(m_Prev);
  591. }
  592. }
  593. else
  594. m_Prev = m_List.First();
  596. return m_Prev ? (CFileInfo *)m_List.Ptr(m_Prev) : NULL;
  597. }
  599. void CFileInfoList::Sort(int (*SortFunc)(const void *, const void *))
  600. {
  601. m_List.Sort(SortFunc);
  602. }
  605. // List in War's own listing format.
  606. // "Filename" size date flags owner class "comment"
  607. // Date is a 64 bit hex number, giving the precision of FILETIME
  608. // Size is a 64 bit hex number.
  609. // Flags is a 32 bit hex number 
  610. // " characters in the string is preceeded with  and \ represents
  611. // a single backslash.
  613. BOOL CFileInfoList::ListRaw(CString& cReturnBuf, DWORD Flags)
  614. {
  615. CFileInfo *Info;
  616. CString cBuf;
  617. FILETIME *ft;
  618. LPCSTR FileName;
  620. cReturnBuf.Empty();
  622. __int64 MyDate;
  623. __int64 MySize;
  625. for(Info = NULL; Info = GetNext(Info);)
  626. {
  627. cBuf.Empty();
  628. char buf[64];
  630. FileName = Info->FileName();
  631. ASSERT(AfxIsValidString(FileName));
  633. ft = Info->GetModifyTime();
  634. MyDate = ft->dwHighDateTime;
  635. MyDate = MyDate << 32;
  636. MyDate |= ft->dwLowDateTime;
  638. MySize = Info->GetFileLength();
  640. cBuf += '"';
  641. cBuf += FileName;
  642. cBuf += "" ";
  644. *buf = 0;
  645. sprintf(buf, "%I64d ", MySize);
  646. cBuf += buf;
  648. *buf = 0;
  649. sprintf(buf, "%I64x ", MyDate);
  650. cBuf += buf;
  652. *buf = 0;
  653. sprintf(buf, "%X ", Info->m_Flags);
  654. cBuf += buf;
  656. *buf = 0;
  657. sprintf(buf, "%X ", Info->m_User);
  658. cBuf += buf;
  660. *buf = 0;
  661. sprintf(buf, "%X ", Info->m_Group);
  662. cBuf += buf;
  664. cBuf += '"';
  665. cBuf += Info->m_Comment;
  666. cBuf += ""rn";
  669. // CString does not support __I64
  670. //cBuf.Format(""%s" %I64x %I64x %X %X %X "%s"n",
  671. // FileName, MySize, MyDate, Info->m_Flags, Info->m_User, Info->m_Group,
  672. // Info->m_Comment);
  674. cReturnBuf += cBuf;
  675. }
  677. return TRUE;
  678. }
  680. ////////////////////////////////////////////////////////////////////////////////
  681. // CWarFile
  683. CWarFile::CWarFile(CUserFsys *pFsys)
  684. {
  685. m_hFile = INVALID_HANDLE_VALUE;
  686. m_DEV = NULL;
  687. m_Path = "";
  688. m_pFsys = pFsys;
  689. m_CallbackPending = FALSE;
  690. m_IsZombie = FALSE;
  691. m_ProtectFromDelete = FALSE;
  692. }
  694. CWarFile::~CWarFile()
  695. {
  696. if (m_hFile != INVALID_HANDLE_VALUE)
  697. Close();
  699. CLog::GetLog()->LogMsg(LOGF_DEBUG,"CWarFile::~CWarFile() - %x killed.", (int)this);
  700. }
  703. void CWarFile::Close()
  704. {
  705. CLog::GetLog()->LogMsg(LOGF_DEBUG,"CWarFile::Close() - Closing file");
  707. if (IsOpen())
  708. {
  709. if (m_pFsys)
  710. {
  711. // Tell the file system that we are trough..
  712. // This call has no callback.
  713. SendMessage(m_pFsys->GetFsys_hWnd(), FSM_CLOSEFILE, NULL,*(WPARAM *)&m_smNode);
  714. }
  716. if (m_DEV)
  717. m_DEV->CloseHandle(m_hFile);
  718. else
  719. CloseHandle(m_hFile);
  720. }
  722. m_hFile = INVALID_HANDLE_VALUE;
  723. if (m_pFsys)
  724. {
  725. CLog::GetLog()->LogMsg(LOGF_DEBUG,"CWarFile::Close() - Removed %x from m_OpenFiles.", (int)this);
  726. m_pFsys->m_OpenFiles.DeletePtr((LPVOID)this);
  727. }
  728. }
  730. void CWarFile::Destroy()
  731. {
  732. try
  733. {
  734. Close();
  736. ASSERT(m_CallbackPending == FALSE);
  738. if (m_ProtectFromDelete || (m_pFsys && m_pFsys->m_CallbackPending))
  739. m_IsZombie = TRUE;
  740. else
  741. delete this;
  742. }
  743. catch(...)
  744. {
  745. CLog::GetLog()->LogMsg(LOGF_WARNINGS,"CWarFile::Destroy() - caught unknown exception.");
  746. return;
  747. }
  748. }
  750. DWORD CWarFile::GetFileAttributes()
  751. {
  752. ASSERT(FALSE);
  753. return 0;
  754. }
  756. UINT CWarFile::GetDriveType()
  757. {
  758. ASSERT(FALSE);
  759. return 0;
  760. };
  762. FLEN CWarFile::GetFileSize()
  763. {
  764. FLEN Rval = 0;
  765. int err = 0;
  767. if (m_DEV)
  768. Rval = m_DEV->GetFileSize(m_hFile);
  769. else
  770. {
  771. DWORD LoDWord, HiDWord;
  772. LoDWord = ::GetFileSize(m_hFile, &HiDWord);
  773. if ((LoDWord == 0xFFFFFFFF) && ((err = GetLastError()) != NO_ERROR))
  774. {
  775. Rval = INVALID_FLEN_VALUE;
  776. SetLastError(err);
  777. }
  779. Rval = (FLEN)((FLEN)HiDWord * (FLEN)MAXDWORD) + (FLEN)LoDWord;
  780. }
  782. return Rval;
  783. }
  785. FLEN CWarFile::Seek(FLEN lsOfs, UINT nFrom )
  786. {
  787. FLEN Rval;
  789. if (m_DEV)
  790. Rval = m_DEV->Seek(m_hFile, lsOfs, nFrom);
  791. else
  792. {
  793. DWORD LoDWord, HiDWord;
  795. LoDWord = LODWORD(lsOfs);
  796. HiDWord = HIDWORD(lsOfs);
  798. LoDWord = SetFilePointer(m_hFile, LoDWord, (PLONG)&HiDWord, nFrom);
  800. if ((LoDWord == 0xFFFFFFFF) && (GetLastError() != NO_ERROR))
  801. return INVALID_FLEN_VALUE;
  803. Rval = (FLEN)((FLEN)HiDWord * (FLEN)MAXDWORD) + (FLEN)LoDWord;
  804. }
  805. return Rval;
  806. }
  808. BOOL CWarFile::Create(
  809.     LPCTSTR lpFileName, // pointer to name of the file 
  810.     DWORD dwDesiredAccess, // access (read-write) mode 
  811.     DWORD dwShareMode, // share mode 
  812.     LPSECURITY_ATTRIBUTES lpSecurityAttributes, // pointer to security descriptor 
  813.     DWORD dwCreationDistribution, // how to create 
  814.     DWORD dwFlagsAndAttributes, // file attributes 
  815.     HANDLE hTemplateFile,  // handle to file with attributes to copy  
  816. DWORD Flags,
  817. LPARAM lParam, // Callback data
  818. void (*Callback)(CWarFile *, BOOL, LPARAM) // Callback function
  819.    )
  820. {
  821. BOOL Rval = FALSE;
  822. if (m_hFile != INVALID_HANDLE_VALUE)
  823. {
  824. ASSERT(FALSE); // File is open!
  825. SetLastError(ERROR_ALREADY_ASSIGNED);
  826. return FALSE;
  827. }
  829. // If this is a DOS style file, use the native IO calls
  830. if (lpFileName && isalpha(lpFileName[0]) && (lpFileName[1] == ':'))
  831. m_pFsys = NULL;
  833. m_DEV = NULL;
  834. m_Path = lpFileName;
  836. if (m_pFsys)
  837. {
  838. CREATE_HDR CreateHdr;
  839. CreateHdr.HdrLen = sizeof(CREATE_HDR);
  840. CreateHdr.dwDesiredAccess = dwDesiredAccess;
  841. CreateHdr.dwShareMode = dwShareMode;
  842. CreateHdr.lpSecurityAttributes = lpSecurityAttributes;
  843. CreateHdr.dwCreationDistribution = dwCreationDistribution;
  844. CreateHdr.dwFlagsAndAttributes = dwFlagsAndAttributes;
  845. CreateHdr.hTemplateFile = hTemplateFile;
  846. CreateHdr.Flags = Flags;
  847. CreateHdr.lParam = lParam;
  848. CreateHdr.Callback = Callback;
  849. CreateHdr.pFile = this;
  850. m_hFile = (HANDLE) HANDLE_PENDING;
  851. m_pFsys->CreateFile(lpFileName, &CreateHdr);
  852. }
  853. else
  854. {
  855. // Look for special flags...
  856. if (!ProcessFlagsLocal(Flags))
  857. return FALSE;
  859. m_hFile = ::CreateFile(
  860. lpFileName,
  861. dwDesiredAccess,
  862. dwShareMode,
  863. lpSecurityAttributes,
  864. dwCreationDistribution,
  865. dwFlagsAndAttributes,
  866. hTemplateFile);
  867. }
  869. if (m_pFsys && (m_hFile != INVALID_HANDLE_VALUE))
  870. {
  871. CLog::GetLog()->LogMsg(LOGF_DEBUG,"CWarFile::Create() - Added %x to m_OpenFiles.", (int)this);
  872. m_pFsys->m_OpenFiles.AddFirst((LPVOID)this);
  873. }
  875. return m_hFile != INVALID_HANDLE_VALUE;
  876. }
  879. BOOL CWarFile::ProcessFlagsLocal(DWORD Flags)
  880. {
  881. if (Flags & UNIQUE_NAME)
  882. {
  883. // Unique file name
  884. CLog::GetLog()->LogMsg(LOGF_ERROR,"CWarFile::ProcessFlagsLocal(%s) - UNIQUE_NAME is illegal without fsys",
  885. m_Path);
  886. return FALSE;
  887. }
  889. return TRUE;
  890. }
  892. BOOL CWarFile::Read(
  893.     LPVOID lpBuffer, // address of buffer that receives data  
  894.     DWORD nNumberOfBytesToRead, // number of bytes to read 
  895.     LPDWORD lpNumberOfBytesRead, // address of number of bytes read 
  896.     LPOVERLAPPED lpOverlapped  // address of structure for data 
  897.    )
  898. {
  899. if (m_DEV)
  900. return m_DEV->ReadFile(m_hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);
  902. return ::ReadFile(m_hFile, lpBuffer, nNumberOfBytesToRead, lpNumberOfBytesRead, lpOverlapped);
  903. }
  905. BOOL CWarFile::ReadEx(
  906.     LPVOID lpBuffer, // address of buffer 
  907.     DWORD nNumberOfBytesToRead, // number of bytes to read 
  908.     LPOVERLAPPED lpOverlapped, // address of offset 
  909.     LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine  // address of completion routine 
  910.    )  
  911. {
  912. if (m_DEV)
  913. return m_DEV->ReadFileEx(m_hFile, lpBuffer, nNumberOfBytesToRead, lpOverlapped, lpCompletionRoutine);
  915. return ::ReadFileEx(m_hFile, lpBuffer, nNumberOfBytesToRead, lpOverlapped, lpCompletionRoutine);
  916. }
  918. BOOL CWarFile::Write(
  919.     LPCVOID lpBuffer, // pointer to data to write to file 
  920.     DWORD nNumberOfBytesToWrite, // number of bytes to write 
  921.     LPDWORD lpNumberOfBytesWritten, // pointer to number of bytes written 
  922.     LPOVERLAPPED lpOverlapped  // pointer to structure needed for overlapped I/O
  923.    )
  924. {
  925. if (m_DEV)
  926. return m_DEV->WriteFile(m_hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);
  928. return ::WriteFile(m_hFile, lpBuffer, nNumberOfBytesToWrite, lpNumberOfBytesWritten, lpOverlapped);
  929. }
  931. BOOL CWarFile::WriteEx(
  932.     LPCVOID lpBuffer,  // pointer to input buffer
  933.     DWORD nNumberOfBytesToWrite,  // number of bytes to write
  934.     LPOVERLAPPED lpOverlapped,  // pointer to async. i/o data
  935.     LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine  // ptr. to completion routine
  936.    )
  937. {
  938. if (m_DEV)
  939. return m_DEV->WriteFileEx(m_hFile, lpBuffer, nNumberOfBytesToWrite, lpOverlapped, lpCompletionRoutine);
  941. return ::WriteFileEx(m_hFile, lpBuffer, nNumberOfBytesToWrite, lpOverlapped, lpCompletionRoutine);
  942. }