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

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

Ftp客户端

开发平台：

Visual C++

VirtualFileSystem.cpp：源码内容
  1. // VirtualFileSystem.cpp : implementation file
  2. //
  4. #include "stdafx.h"
  5. // For now, we don't support non-daemon programs
  6. //#include "WarSoftware.h"
  7. #include "WarDaemon.h"
  8. #include "WarFsys.h"
  9. #include "VfFSys.h"
  10. #include "UnixFsysTypes.h"
  11. #include "FsysSecurity.h"
  13. #ifdef _DEBUG
  14. #define new DEBUG_NEW
  15. #undef THIS_FILE
  16. static char THIS_FILE[] = __FILE__;
  17. #endif
  19. /////////////////////////////////////////////////////////////////////////////
  20. // CVirtualFileSystem
  22. CLinkedList CVirtualFileSystem::m_FreeThreads;
  23. CLinkedList CVirtualFileSystem::m_BusyThreads;
  25. CVirtualFileSystem::CVirtualFileSystem()
  26. {
  27. }
  29. CVirtualFileSystem::~CVirtualFileSystem()
  30. {
  31. }
  33. void CVirtualFileSystem::Shutdown()
  34. {
  35. // Clean up. Only one object pr. process, so we can do it right :-)
  36. CLinkedList MyList;
  37. CWinThread *pThread;
  38. MyList = m_FreeThreads;
  39. MyList += m_BusyThreads;
  41. while(pThread = (CWinThread *) MyList.GetAndDeleteFirst())
  42. {
  43. pThread->AssertValid();
  44. if (!::PostThreadMessage(pThread->m_nThreadID, FSM_QUIT, 0, 0))
  45. {
  46. CLog::GetLog()->LogMsg(LOGF_ERROR,"CVirtualFileSystem::Shutdown() - PostThreadMessage failed: %s", 
  47. GetLastErrorText());
  48. // Patch. Just kill the linked lists..
  49. while(m_FreeThreads.GetAndDeleteFirst());
  50. while(m_BusyThreads.GetAndDeleteFirst());
  51. }
  52. }
  54. while(m_FreeThreads.GetItemCount() || m_BusyThreads.GetItemCount())
  55. Sleep(100);
  56. }
  58. BEGIN_MESSAGE_MAP(CVirtualFileSystem, CWnd)
  59. //{{AFX_MSG_MAP(CVirtualFileSystem)
  60. // NOTE - the ClassWizard will add and remove mapping macros here.
  61. //}}AFX_MSG_MAP
  63. ON_MESSAGE(FSM_CALLBACK, mhCallback)
  64. ON_MESSAGE(FSM_CREATEFILE, mhCreateFile)
  65. ON_MESSAGE(FSM_CREATEUSER, mhCreate)
  66. ON_MESSAGE(FSM_CHDIR, mhChdir)
  67. ON_MESSAGE(FSM_CHMOD, mhChmod)
  68. ON_MESSAGE(FSM_PRPCMDLINE, mhPreperePath)
  69. ON_MESSAGE(FSM_LIST, mhList)
  70. ON_MESSAGE(FSM_WLST, mhWlist)
  71. ON_MESSAGE(FSM_CLOSEFILE, mhCloseFile)
  72. ON_MESSAGE(FSM_FSYSSTAT, mhFsysstat)
  73. ON_MESSAGE(FSM_CREATEDIR, mhCreateDir)
  74. ON_MESSAGE(FSM_DELEDIR, mhDeleteDir)
  75. ON_MESSAGE(FSM_DELEFILE, mhDeleteFile)
  76. ON_MESSAGE(FSM_DELE, mhDeleteGeneric)
  77. ON_MESSAGE(FSM_LINK, mhLinkFile)
  78. ON_MESSAGE(FSM_MOVE, mhMoveFile)
  79. ON_MESSAGE(FSM_QUIT, mhQuit)
  80. ON_MESSAGE(FSM_STAT, mhStat)
  81. END_MESSAGE_MAP()
  84. // Get a free worker thread. Then, mark it as busy.
  85. // If pTherad is <> NULL, release the thread
  86. CWinThread *CVirtualFileSystem::GetThread(CWinThread *pTherad, HWND hWnd)
  87. {
  88. static CCriticalSection Lock;
  90. Lock.Lock();
  92. if (pTherad == NULL)
  93. {
  94. if ((pTherad = (CWinThread *)m_FreeThreads.GetAndDeleteFirst()) == NULL)
  95. {
  96. CFsysThread *pThreadObj = new CFsysThread;
  97. pThreadObj->m_CallbackWin = hWnd;
  98. if ((pTherad = AfxBeginThread(CFsysThread::EntryPoint, (LPVOID)pThreadObj)) == NULL)
  99. delete pThreadObj;
  100. else
  101. {
  102. pThreadObj->m_Lock.Lock();
  103. pThreadObj->m_Lock.Unlock();
  104. }
  105. }
  106. if (pTherad)
  107. {
  108. // Wait for the thread to initialize
  109. m_FreeThreads.DeletePtr((LPVOID)pTherad);
  110. m_BusyThreads.AddLast((LPVOID)pTherad);
  111. }
  112. }
  113. else
  114. {
  115. m_BusyThreads.DeletePtr(pTherad);
  116. m_FreeThreads.AddLast((LPVOID)pTherad);
  117. }
  119. Lock.Unlock();
  120. return pTherad;
  121. }
  123. // Call a worker thread and pass the request on
  124. LONG CVirtualFileSystem::ProcessRequest(int Type, WPARAM wParam, LPARAM lParam)
  125. {
  126. CWinThread *pThrd = GetThread(NULL,m_hWnd);
  127. if (!pThrd)
  128. return FALSE;
  129. ::PostThreadMessage(pThrd->m_nThreadID, Type, wParam, lParam);
  130. return TRUE;
  131. }
  133. /////////////////////////////////////////////////////////////////////////////
  134. // CVirtualFileSystem message handlers
  136. LONG CVirtualFileSystem::mhCallback( WPARAM wParam, LPARAM lParam)
  137. {
  138. CUserFsys *pFsys = (CUserFsys *)wParam;
  139. pFsys->OnCallback(lParam);
  140. return 0;
  141. }
  144. LONG CVirtualFileSystem::mhCreateFile( WPARAM wParam, LPARAM lParam)
  145. {
  146. CString Roots = (LPCSTR)lParam;
  147. return ProcessRequest(FSM_CREATEFILE, wParam, (LPARAM)(LPCSTR)Roots);
  148. }
  150. LONG CVirtualFileSystem::mhCreate( WPARAM wParam, LPARAM lParam)
  151. {
  152. CString Roots = (LPCSTR)lParam;
  153. return ProcessRequest(FSM_CREATEUSER, wParam, (LPARAM)(LPCSTR)Roots);
  154. }
  156. LONG CVirtualFileSystem::mhChdir( WPARAM wParam, LPARAM lParam)
  157. {
  158. CString Roots = (LPCSTR)lParam;
  159. return ProcessRequest(FSM_CHDIR, wParam, (LPARAM)(LPCSTR)Roots);
  160. }
  162. LONG CVirtualFileSystem::mhChmod( WPARAM wParam, LPARAM lParam)
  163. {
  164. return ProcessRequest(FSM_CHMOD, wParam, NULL);
  165. }
  167. LONG CVirtualFileSystem::mhPreperePath( WPARAM wParam, LPARAM lParam)
  168. {
  169. CString Roots = (LPCSTR)lParam;
  170. return ProcessRequest(FSM_PRPCMDLINE, wParam, (LPARAM)(LPCSTR)Roots);
  171. }
  173. LONG CVirtualFileSystem::mhList( WPARAM wParam, LPARAM lParam)
  174. {
  175. CString Roots = (LPCSTR)lParam;
  176. return ProcessRequest(FSM_LIST, wParam, (LPARAM)(LPCSTR)Roots);
  177. }
  179. LONG CVirtualFileSystem::mhWlist( WPARAM wParam, LPARAM lParam)
  180. {
  181. CString Path = (LPCSTR)lParam;
  182. return ProcessRequest(FSM_WLST, wParam, (LPARAM)(LPCSTR)Path);
  183. }
  185. LONG CVirtualFileSystem::mhCloseFile( WPARAM wParam, LPARAM lParam)
  186. {
  187. return ProcessRequest(FSM_CLOSEFILE, wParam, lParam);
  188. }
  190. LONG CVirtualFileSystem::mhFsysstat( WPARAM wParam, LPARAM lParam)
  191. {
  192. return ProcessRequest(FSM_FSYSSTAT, wParam, lParam);
  193. }
  195. LONG CVirtualFileSystem::mhCreateDir( WPARAM wParam, LPARAM lParam)
  196. {
  197. return ProcessRequest(FSM_CREATEDIR, wParam, lParam);
  198. }
  200. LONG CVirtualFileSystem::mhDeleteDir( WPARAM wParam, LPARAM lParam)
  201. {
  202. return ProcessRequest(FSM_DELEDIR, wParam, lParam);
  203. }
  205. LONG CVirtualFileSystem::mhDeleteFile( WPARAM wParam, LPARAM lParam)
  206. {
  207. return ProcessRequest(FSM_DELEFILE, wParam, lParam);
  208. }
  210. LONG CVirtualFileSystem::mhDeleteGeneric( WPARAM wParam, LPARAM lParam)
  211. {
  212. return ProcessRequest(FSM_DELE, wParam, lParam);
  213. }
  215. LONG CVirtualFileSystem::mhLinkFile( WPARAM wParam, LPARAM lParam)
  216. {
  217. return ProcessRequest(FSM_LINK, wParam, lParam);
  218. }
  220. LONG CVirtualFileSystem::mhMoveFile( WPARAM wParam, LPARAM lParam)
  221. {
  222. return ProcessRequest(FSM_MOVE, wParam, lParam);
  223. }
  225. LONG CVirtualFileSystem::mhQuit( WPARAM wParam, LPARAM lParam)
  226. {
  227. Shutdown();
  228. return TRUE;
  229. }
  231. LONG CVirtualFileSystem::mhStat( WPARAM wParam, LPARAM lParam)
  232. {
  233. return ProcessRequest(FSM_STAT, wParam, lParam);
  234. }
  237. /////////////////////////////////////////////////////////////////////////////
  238. // CFsysThread
  241. int CFsysThread::m_NumThreadsStarted = 0;
  243. CFsysThread::CFsysThread()
  244. {
  245. m_Lock.Lock();
  246. m_SeqNo = 0;
  247. m_CallbackWin = NULL;
  248. }
  250. CFsysThread::~CFsysThread()
  251. {
  252. }
  254. void CFsysThread::LogMsg(int flag, LPCSTR Format, ...)
  255. {
  256. if (!ShouldLog(CLog::GetLog(), flag))
  257. return;
  259. {
  260. CString cBuf;
  261. ASSERT(AfxIsValidString(Format, FALSE));
  263. cBuf.Format("VfSys::%s: %s", m_pFsys->m_Name, Format);
  265. va_list argList;
  266. va_start(argList, Format);
  267. CLog::GetLog()->LogMsgV(flag, cBuf, argList);
  268. va_end(argList);
  269. }
  270. }
  273. UINT CFsysThread::EntryPoint(LPVOID pParam)
  274. {
  275. CFsysThread *pMe = (CFsysThread *)pParam;
  276. return pMe->Process();
  277. }
  279. UINT CFsysThread::Process()
  280. {
  281. // Set up a message queue
  282. MSG msg;
  283. PeekMessage(&msg,NULL,0,0,PM_NOREMOVE);
  284. BOOL Rval;
  286. m_SeqNo = ++m_NumThreadsStarted;
  288. // Signal that we are ready
  289. m_Lock.Unlock();
  291. // Go into message loop
  292. CLog::GetLog()->LogMsg(LOGF_DEBUG,"CFsysThread::Process() Thread #%d (0x%08x) starting up.", m_SeqNo, AfxGetThread());
  293. while(GetMessage(&msg,NULL,0,0) == TRUE)
  294. {
  295. CUserFsys *pFsys = (CUserFsys *)msg.wParam;
  297. if (pFsys)
  298. {
  299. pFsys->m_FsysErrno = 0;
  300. pFsys->m_DOSErrno = 0;
  301. m_pFsys = pFsys;
  302. }
  304. switch(msg.message)
  305. {
  306. case FSM_QUIT:
  307. case WM_QUIT:
  308. goto done;
  310. case FSM_CREATEFILE:
  311. Rval = DoCreateFile(pFsys->m_FsysPath1);
  312. break;
  314. case FSM_CREATEUSER:
  315. Rval = DoCreateUser(pFsys->m_FsysPath1);
  316. break;
  318. case FSM_CHDIR:
  319. Rval = DoChDirUser(pFsys->m_FsysPath1);
  320. break;
  322. case FSM_CHMOD:
  323. Rval = DoChmod(pFsys->m_Args);
  324. break;
  326. case FSM_PRPCMDLINE:
  327. Rval = DoPrepereUserCmdLine(pFsys->m_FsysPath1);
  328. break;
  330. case FSM_LIST:
  331. Rval = DoList(pFsys->m_FsysPath1);
  332. break;
  334. case FSM_CLOSEFILE:
  335. Rval = TRUE;
  336. DoCloseFile(*(SMEM *)&msg.lParam);
  337. break;
  339. case FSM_WLST:
  340. Rval = DoWlist(pFsys->m_FsysPath1);
  341. break;
  343. case FSM_FSYSSTAT:
  344. Rval = DoFsysStat();
  345. break;
  347. case FSM_CREATEDIR:
  348. Rval = DoCreateDirectory(pFsys->m_FsysPath1);
  349. break;
  351. case FSM_DELEDIR:
  352. Rval = DoDeleteGeneric(pFsys->m_FsysPath1, DELE_DIR);
  353. break;
  355. case FSM_DELEFILE:
  356. Rval = DoDeleteGeneric(pFsys->m_FsysPath1, DELE_FILE);
  357. break;
  359. case FSM_DELE:
  360. Rval = DoDeleteGeneric(pFsys->m_FsysPath1, DELE_DIR | DELE_FILE);
  361. break;
  363. case FSM_LINK:
  364. Rval = DoCreateLink(pFsys->m_FsysPath1, pFsys->m_FsysPath2);
  365. break;
  367. case FSM_MOVE:
  368. Rval = DoMoveFile(pFsys->m_FsysPath1, pFsys->m_FsysPath2);
  369. break;
  371. case FSM_STAT:
  372. Rval = DoStat(pFsys->m_FsysPath1);
  373. break;
  375. default:
  376. CLog::GetLog()->LogMsg(LOGF_WARNINGS,"CFsysThread::Process() - Got unknown message %u", msg.message);
  377. pFsys->m_FsysErrno = FSE_UNKNOWN_CALL;
  378. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)pFsys, 0);
  379. }
  381. if (!Rval)
  382. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)msg.wParam, 0);
  384. // Release the thread
  385. CVirtualFileSystem::GetThread(AfxGetThread(), NULL);
  386. }
  388. done:
  389. CLog::GetLog()->LogMsg(LOGF_DEBUG,"CFsysThread::Process() Thread #%d shutting down.", m_SeqNo);
  390. CVirtualFileSystem::m_FreeThreads.DeletePtr((LPVOID)AfxGetThread());
  391. delete this;
  392. return 0;
  393. }
  395. BOOL CFsysThread::ParseRootpath(LPCSTR RootPath, CString& Name, CString& LinkPath)
  396. {
  397. CString cBuf = RootPath;
  398. LPSTR p = cBuf.GetBuffer(1);
  399. p = strchr(p, ',');
  400. if (p)
  401. *p++ = 0;
  402. cBuf.ReleaseBuffer();
  403. LinkPath = cBuf;
  404. Name = p ? p : "";
  406. return TRUE;
  407. }
  409. // Scan a path, starting at the user root...
  410. BOOL CFsysThread::ScanPath(LPCSTR Path, BOOL FullScanToPath, BOOL Recursive, BOOL Force, BOOL DoLock)
  411. {
  412. if (DoLock)
  413. pLock->WriteLock();
  415. DIR_NODE *pRoot = GetRootNode();
  416. DIR_NODE *pDir = (DIR_NODE *)pSmem->__Ptr(pRoot->Son);
  418. while(pDir)
  419. {
  420. if (pDir->FileNode.LinkTo)
  421. {
  422. CString ParsedPath = Path;
  423. ParsePath(ParsedPath);
  424. CString MyPath = pDir->FileNode.LinkTo;
  425. if (!MyPath.IsEmpty() && (MyPath[MyPath.GetLength() -1] == '/'))
  426. MyPath.ReleaseBuffer(MyPath.GetLength() -1);
  427. MyPath += ParsedPath;
  428. ::ScanPath(MyPath, FullScanToPath, Recursive, Force);
  429. }
  431. pDir = (DIR_NODE *)pSmem->__Ptr(pRoot->FileNode.Next);
  432. }
  434. if (DoLock)
  435. pLock->UnlockWrite();
  437. return TRUE;
  438. }
  440. DIR_NODE *CFsysThread::GetRootNode()
  441. {
  442. SMEM *pSM = (SMEM *)&m_pFsys->m_FsysLparam;
  443. DIR_NODE *pRoot = (DIR_NODE *)pSmem->__Ptr(*pSM);
  444. return pRoot;
  445. }
  447. BOOL CFsysThread::ParsePath(CString& OrigPath)
  448. {
  449. CString MyPath = OrigPath;
  450. int cnt = 0;
  452. LPCSTR Path = OrigPath;
  454. if (*Path != '/')
  455. {
  456. // Path is relative to 
  457. CString cBuf = m_pFsys->m_CWD;
  458. if (cBuf.GetLength() && (cBuf[cBuf.GetLength() -1] != '/'))
  459. cBuf += '/';
  460. cBuf += Path;
  461. MyPath = OrigPath = cBuf;
  462. Path = OrigPath;
  463. }
  465. char *Buf = MyPath.GetBuffer(1);
  467. while(*Path)
  468. {
  469. if (*Path == '/')
  470. {
  471. // /C/.. /C/./any  /C/any/. /C/any/../.any /C/any..
  472. if (Path[1] == '.')
  473. {
  474. if (!Path[2] || (Path[2] == '/'))
  475. {
  476. // /C/any/. style. Just ignore
  477. Path += 2;
  478. continue;
  479. }
  481. if (Path[2] == '.')
  482. {
  483. if (!Path[3] || (Path[3] == '/'))
  484. {
  485. // /C/any/.. /C/any/../test style. Move back one 
  486. if (cnt == 0)
  487. {
  488. LogMsg(LOGF_DEBUG,"RealPath(%s) - invalid ../ ", OrigPath);
  489. return FALSE;
  490. }
  491. while(--cnt && (Buf[cnt] != '/'))
  492. {
  493. ASSERT(cnt >= 0);
  494. }
  495. Path += 3;
  496. continue;
  497. }
  498. }
  499. }
  500. }
  501. // Default
  502. Buf[cnt++] = *Path++;
  503. }
  505. if (cnt == 0)
  506. OrigPath = "/"; // Never move beoind /
  507. else
  508. {
  509. Buf[cnt] = 0;
  510. OrigPath = Buf;
  511. }
  512. return TRUE;
  513. }
  515. BOOL CFsysThread::UserHasPermission(DWORD Perms, DWORD PermWanted)
  516. {
  517. if (PermWanted & NODE_EXEC)
  518. {
  519. if (!(Perms & (NODE_OEXEC | NODE_GEXEC | NODE_AEXEC)))
  520. return FALSE; // No permissions
  521. }
  523. if (PermWanted & NODE_READ)
  524. {
  525. if (!(Perms & (NODE_OREAD | NODE_GREAD | NODE_AREAD)))
  526. return FALSE; // No permissions
  527. }
  529. if (PermWanted & NODE_WRITE)
  530. {
  531. if (!(Perms & (NODE_0WRITE | NODE_GWRITE | NODE_AWRITE)))
  532. return FALSE; // No permissions
  533. }
  535. if (PermWanted & NODE_HIDE)
  536. {
  537. if (!(Perms & (NODE_OHIDE | NODE_GHIDE | NODE_AHIDE)))
  538. return FALSE; // No permissions
  539. }
  541. if (PermWanted & NODE_FREE)
  542. {
  543. if (!(Perms & (NODE_OFREE | NODE_GFREE | NODE_AFREE)))
  544. return FALSE; // No permissions
  545. }
  547. return TRUE;
  548. }
  550. // Check if a user has a desired permission to a node
  551. // Note: pDir can be any node type
  552. BOOL CFsysThread::UserHasPermission(DIR_NODE *pDir, DWORD Perm)
  553. {
  554. if (m_pFsys->m_IsAdmin || m_pFsys->m_IsSystem)
  555. return TRUE;
  557. if (pDir->FileNode.LinkTo)
  558. {
  559. SMEM smDir;
  560. FindNodeFromPath(smDir, pDir->FileNode.LinkTo); 
  561. DIR_NODE *pLinkTo = (DIR_NODE *)pSmem->__Ptr(smDir);
  562. if (pLinkTo)
  563. return UserHasPermission(pLinkTo, Perm);
  564. LogMsg(LOGF_WARNINGS,"Link '%s' is unresolved", pDir->FileNode.LinkTo);
  565. return FALSE; 
  566. }
  568. int Mask = S_IRWXO;
  569. int Perms = pDir->FileNode.Perms;
  571. if (pDir->FileNode.User == m_pFsys->m_User)
  572. Mask |= S_IRWXU;
  574. if (pDir->FileNode.Class == m_pFsys->m_Class)
  575. Mask |= S_IRWXG;
  577. BOOL HasAccess = UserHasPermission(Perms & Mask, Perm);
  579. if (!HasAccess)
  580. {
  581. // Check for additional permissions
  582. USER *pUsers = (USER *)pSmem->__Ptr(pDir->FileNode.MoreUsers);
  583. if (pUsers)
  584. {
  585. Mask |= S_IRWXG;
  586. for(int i = 0; pUsers[i] != INVALID_USER_VALUE; i++)
  587. {
  588. if ((pUsers[i] == m_pFsys->m_User) || (pUsers[i] == m_pFsys->m_Class))
  589. {
  590. HasAccess = UserHasPermission(Perms & Mask, Perm);
  591. break;
  592. }
  593. }
  594. }
  595. }
  597. return HasAccess;
  598. }
  600. // Check if the user has permission to a path.
  601. // If psmNode != NULL, return the destination node on success
  602. BOOL CFsysThread::CheckPermissions(LPCSTR Path, DWORD ReqType, DWORD Perm, SMEM *psmNode)
  603. {
  604. DIR_NODE *pRoot = GetRootNode();
  605. SMEM smDir = pRoot->Son;
  606. CPathArray PathArray;
  607. PathArray.ParsePathToArray(Path);
  608. BOOL PermissionToCreate = FALSE;
  609. DIR_NODE *pDir = NULL;
  611. for(int Index = 0; Index <= PathArray.GetUpperBound(); Index++)
  612. {
  613. smDir = Index ? FindNode(smDir, PathArray[Index]) : pRoot->Son;
  614. if (!smDir)
  615. {
  616. if (psmNode)
  617. {
  618. psmNode = 0;
  619. }
  620. return PermissionToCreate;
  621. }
  623. pDir = (DIR_NODE *)pSmem->__Ptr(smDir);
  625. if (pDir->FileNode.Perms & NODE_LINK)
  626. {
  627. // Follow link
  628. if (!FindNodeFromPath(smDir, pDir->FileNode.LinkTo))
  629. {
  630. LogMsg(LOGF_WARNINGS,"CFsysThread::CheckPermissions() - Unresolved soft link: '%s'", pDir->FileNode.LinkTo);
  631. return FALSE;
  632. }
  633. pDir = (DIR_NODE *)pSmem->__Ptr(smDir);
  634. }
  636. if (pDir->FileNode.Perms & NODE_DIR)
  637. {
  638. // Check execute permission
  639. if (!UserHasPermission(pDir, NODE_EXEC))
  640. return FALSE;
  641. }
  643. if (Index == (PathArray.GetUpperBound() - 1))
  644. {
  645. // Special case. If the user want to create something, check the
  646. // permissions on this level.
  647. if ((Perm & NODE_WRITE) && (pDir->FileNode.Perms & NODE_DIR))
  648. {
  649. PermissionToCreate = UserHasPermission(pDir, NODE_EXEC | NODE_WRITE);
  650. }
  651. }
  652. }
  654. ASSERT(pDir != NULL);
  655. if (ReqType && !(pDir->FileNode.Perms & ReqType))
  656. return FALSE;
  658. if (!UserHasPermission(pDir, Perm))
  659. return FALSE;
  661. if (psmNode)
  662. *psmNode = smDir;
  664. return TRUE;
  665. }
  668. // Look for the name in the directory, and in
  669. // hard linked subdirs
  670. SMEM CFsysThread::FindNode(SMEM& smDir, LPCSTR Name)
  671. {
  672. DIR_NODE *pDir = (DIR_NODE *)pSmem->__Ptr(smDir);
  673. SMEM Rval;
  675. Rval = 0;
  677. if (!pDir)
  678. return Rval;
  680. while(!pDir->FileNode.Name && pDir->FileNode.LinkTo)
  681. {
  682. SMEM smLinkDir;
  683. FindNodeFromPath(smLinkDir, pDir->FileNode.LinkTo); 
  684. DIR_NODE *pLinkTo = (DIR_NODE *)pSmem->__Ptr(smLinkDir);
  685. if (pLinkTo)
  686. {
  687. pDir = pLinkTo;
  688. }
  689. else
  690. {
  691. LogMsg(LOGF_WARNINGS, 
  692. "CFsysThread::FindNode(%s) - Broken link detected in file system (%s).", 
  693. Name, pDir->FileNode.LinkTo);
  694. return Rval;
  695. }
  696. }
  698. FILE_NODE *pNode = (FILE_NODE *)pSmem->__Ptr(pDir->Son);
  699. Rval = pDir->Son;
  701. while(pNode)
  702. {
  703. if (!pNode->Name && pNode->LinkTo)
  704. {
  705. SMEM smLinkDir;
  706. FindNodeFromPath(smLinkDir, pNode->LinkTo); 
  707. DIR_NODE *pLinkTo = (DIR_NODE *)pSmem->__Ptr(smDir);
  708. if (pLinkTo)
  709. {
  710. SMEM smTest = FindNode(smLinkDir, Name);
  711. if (smTest)
  712. return smTest;
  713. }
  714. else
  715. {
  716. LogMsg(LOGF_WARNINGS,"Link '%s' is unresolved", pDir->FileNode.LinkTo);
  717. }
  718. }
  719. else if (pNode->Name && !stricmp(pNode->Name, Name))
  720. break;
  721. Rval = pNode->Next;
  722. pNode = (FILE_NODE *)pSmem->__Ptr(Rval);
  723. }
  725. return Rval;
  726. }
  728. ///////////////////////////////////////////////////////////////////////////
  729. // Build a CFileInfoList
  731. BOOL CFsysThread::BldFileInfoList(CFileList& FileList, LPCSTR Path, BOOL ListDir)
  732. {
  733. CString MyPath = Path;
  734. ParsePath(MyPath);
  735. CString Pattern = "*", COrigPath = MyPath;
  736. LPSTR pp = strrchr(MyPath.GetBuffer(1), '/'), p = pp;
  738. LogMsg(LOGF_DEBUG,"BldFileInfoList() INFO: Path = '%s' and %s", Path, ListDir ? "DIR" : "FILE");
  740. if (ListDir)
  741. {
  742. if (p && !strpbrk(p, "*?"))
  743. {
  744. if (AddFileInfoListPath(FileList, MyPath, Pattern))
  745. return TRUE;
  746. }
  747. }
  749. if (p && (p >= pp))
  750. {
  751. *p++ = 0;
  752. Pattern = p;
  753. }
  754. else
  755. {
  756. LogMsg(LOGF_DEBUG,"BldFileInfoList() - Cannot list '%s'.", Path);
  757. return FALSE;
  758. }
  760. AddFileInfoListPath(FileList, MyPath, Pattern);
  762. return TRUE;
  763. }
  765. int CFsysThread::AddFileInfoListPath(CFileList& FileList, LPCSTR Path, LPCSTR Pattern)
  766. {
  767. SMEM smNode;
  769. // Get the dir to list
  770. if (!CheckPermissions(Path, NODE_DIR, NODE_READ, &smNode))
  771. {
  772. LogMsg(LOGF_DEBUG,"AddFileInfoListPath() - Permission denied on '%s'.", Path);
  773. return FALSE;
  774. }
  776. return AddFileInfoListPath(FileList, smNode, Pattern);
  777. }
  779. int CFsysThread::AddFileInfoListPath(CFileList& FileList, SMEM smDir, LPCSTR Pattern)
  780. {
  781. int Count = 0;
  782. DIR_NODE *pDir = (DIR_NODE *)pSmem->__Ptr(smDir);
  783. SMEM Rval;
  785. Rval = 0;
  787. if (!pDir)
  788. return Count;
  790. while(!pDir->FileNode.Name && pDir->FileNode.LinkTo)
  791. {
  792. SMEM smLinkDir;
  793. FindNodeFromPath(smLinkDir, pDir->FileNode.LinkTo); 
  794. DIR_NODE *pLinkTo = (DIR_NODE *)pSmem->__Ptr(smLinkDir);
  795. if (pLinkTo)
  796. {
  797. pDir = pLinkTo;
  798. }
  799. }
  802. FILE_NODE *pNode = (FILE_NODE *)pSmem->__Ptr(pDir->Son);
  803. if (!pNode)
  804. LogMsg(LOGF_DEBUG,"AddFileInfoListPath() - pNode is NULL. Nothing to list...");
  806. while(pNode)
  807. {
  808. if (!pNode->Name && pNode->LinkTo)
  809. {
  810. SMEM smLinkDir;
  811. FindNodeFromPath(smLinkDir, pNode->LinkTo); 
  812. DIR_NODE *pLinkTo = (DIR_NODE *)pSmem->__Ptr(smDir);
  813. if (pLinkTo)
  814. {
  815. Count += AddFileInfoListPath(FileList, smLinkDir, Pattern);
  816. }
  817. else
  818. {
  819. LogMsg(LOGF_WARNINGS,"Link '%s' is unresolved", pDir->FileNode.LinkTo);
  820. }
  821. }
  822. else if (pNode->Name 
  823. && PatternMatchesName(pNode->Name, Pattern) 
  824. && (m_pFsys->m_IsAdmin || !UserHasPermission(pNode->Perms, NODE_HIDE)))
  825. {
  826. ++Count;
  827. FileList.Add(pNode);
  828. }
  829. Rval = pNode->Next;
  830. pNode = (FILE_NODE *)pSmem->__Ptr(Rval);
  831. }
  833. return Count;
  834. }
  836. ////////////////////////////////////////////////////////////////////////////////////////
  837. // User functions
  839. // Create a root node for the user, with mappings to all the path's in the 
  840. // RootPaths string. 
  841. BOOL CFsysThread::DoCreateUser(LPCSTR RootPaths)
  842. {
  843. CStringArray Roots;
  844. SMEM smUserRoot;
  845. CString Name, LinkPath;
  847. CString cBuf = RootPaths;
  848. LPSTR p = cBuf.GetBuffer(1);
  849. for(p = strtok(p, "rn"); p;  p = strtok(NULL, "rn"))
  850. Roots.Add(p);
  852. if (Roots.GetUpperBound() < 0)
  853. {
  854. LogMsg(LOGF_WARNINGS,"User has no valid root path(s).");
  855. m_pFsys->m_FsysErrno = FSE_NO_ROOTPATH;
  856. return FALSE;
  857. }
  859. // Create the users root node
  860. if (!CreateDirNode(smUserRoot, "", NULL, NULL, NULL, NULL))
  861. {
  862. LogMsg(LOGF_WARNINGS,"Failed to create users root node");
  863. m_pFsys->m_FsysErrno = FSE_BAD_ROOTPATH;
  864. return FALSE;
  865. }
  867. // Create link nodes
  868. for(int i = 0; i <= Roots.GetUpperBound(); i++)
  869. {
  870. SMEM smDir;
  871. ParseRootpath(Roots[i], Name, LinkPath);
  872. CreateDirNode(smDir, Name, NULL, LinkPath, &smUserRoot, NULL);
  873. }
  875. *(SMEM *)&m_pFsys->m_FsysLparam = smUserRoot;
  877. if (!m_pFsys->m_Home.IsEmpty() && !ChDir(m_pFsys->m_Home))
  878. {
  879. LogMsg(LOGF_WARNINGS,"Failed to chdir to (users home) '%s'", m_pFsys->m_Home);
  880. goto cd_to_root;
  881. }
  882. else if (!ChDir("/")) // Fallbakc to root path
  883. {
  884. cd_to_root:
  885. LogMsg(LOGF_WARNINGS,"Failed to chdir to (users root) /");
  886. return FALSE;
  887. }
  889. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  890. LogMsg(LOGF_DEBUG,"Created root node for the users file system.");
  892. return TRUE;
  893. }
  895. // Close a file.
  896. // No callback
  897. void CFsysThread::DoCloseFile(SMEM smNode)
  898. {
  899. pLock->WriteLock();
  901. FILE_NODE *pNode = (FILE_NODE *)pSmem->__Ptr(smNode);
  902. pNode->f_OpenCnt--;
  903. if (pNode->f_Deleted)
  904. DeleteNode(smNode);
  905. else
  906. {
  907. if (pNode->f_Locked)
  908. {
  909. ASSERT(pNode->f_OpenCnt == 0);
  910. pNode->f_Locked = FALSE;
  911. ::ScanDir(pNode->Father, pNode->RealName ? pNode->RealName : pNode->Name, TRUE);
  912. }
  913. else if (pNode->f_CopyToHome)
  914. {
  915. ASSERT(FALSE); // Not yet implemented
  916. }
  917. }
  919. pLock->UnlockWrite();
  920. }
  922. // Create/Open a file
  923. BOOL CFsysThread::DoCreateFile(LPCSTR Path)
  924. {
  925. CString cMyPath = Path;
  926. SMEM smFileNode;
  927. DWORD Perms = 0;
  928. smFileNode = 0;
  930. if (m_pFsys->m_CreateHdr.dwDesiredAccess & GENERIC_READ)
  931. Perms |= NODE_READ;
  933. if (m_pFsys->m_CreateHdr.dwDesiredAccess & GENERIC_WRITE)
  934. Perms |= NODE_WRITE;
  936. if (!ParsePath(cMyPath))
  937. {
  938. m_pFsys->m_FsysErrno = FSE_BAD_PATH;
  939. return FALSE;
  940. }
  942. ScanPath(cMyPath, FALSE, FALSE, FALSE);
  944. pLock->WriteLock();
  946. if (!CheckPermissions(cMyPath, 0, Perms, &smFileNode))
  947. {
  948. pLock->UnlockWrite();
  949. m_pFsys->m_FsysErrno = FSE_PERMISSION_DENIED;
  950. return FALSE;
  951. }
  953. // Handle unique file name
  954. #define MAX_CNT 20
  956. if (m_pFsys->m_CreateHdr.Flags & CWarFile::UNIQUE_NAME)
  957. {
  958. int Count = -1;
  959. SMEM smIgnore;
  960. for(Count = 0; Count < MAX_CNT; Count++)
  961. {
  962. CString cBuf;
  963. if (Count)
  964. cBuf.Format("%s(%d)", Path, Count);
  965. else
  966. cBuf = Path;
  968. if (!CheckPermissions(cBuf, 0, 0, &smIgnore) && CheckPermissions(cBuf, 0, NODE_WRITE, &smIgnore))
  969. {
  970. cMyPath = cBuf;
  971. smFileNode = smIgnore;
  972. break;
  973. }
  974. }
  976. if (Count == MAX_CNT)
  977. {
  978. pLock->UnlockWrite();
  979. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - Can not create unique file name.", Path);
  980. return FALSE;
  981. }
  982. m_pFsys->m_CreateHdr.dwCreationDistribution &= ~(CREATE_ALWAYS | OPEN_EXISTING | OPEN_ALWAYS | TRUNCATE_EXISTING);
  983. m_pFsys->m_CreateHdr.dwCreationDistribution |= CREATE_NEW;
  984. }
  986. // Now, open the file...
  987. FILE_NODE *pNode = (FILE_NODE *)pSmem->__Ptr(smFileNode);
  988. HANDLE hNewFileHandle = INVALID_HANDLE_VALUE;
  989. SMEM smParentDir;
  990. smParentDir = 0;
  991. SMEM smFsys;
  992. CString FsysPath;
  993. FILE_SYSTEM *pFsys = NULL;
  994. CDeviceDriver *pDev = NULL;
  996. if (pNode == NULL)
  997. {
  998. // New file.
  999. if (m_pFsys->m_CreateHdr.dwDesiredAccess & GENERIC_WRITE)
  1000. {
  1001. // Get father node
  1002. CString ParentPath = cMyPath;
  1003. LPSTR p = ParentPath.GetBuffer(1);
  1005. p = strrchr(p, '/');
  1006. if (p)
  1007. {
  1008. *p++ = 0;
  1009. ParentPath.ReleaseBuffer();
  1010. if (!CheckPermissions(ParentPath, NODE_DIR, NODE_WRITE, &smParentDir))
  1011. {
  1012. pLock->UnlockWrite();
  1013. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - Not write access to parent dir.", Path);
  1014. return FALSE;
  1015. }
  1016. // Permissions are OK. Now, get ready to create the node
  1017. FsysPath = ResolveFsysPath(smParentDir, smFsys);
  1018. pFsys = (FILE_SYSTEM *)pSmem->__Ptr(smFsys);
  1019. if (!pFsys)
  1020. {
  1021. pLock->UnlockWrite();
  1022. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - No file system on parent dir.", Path);
  1023. return FALSE;
  1024. }
  1025. pDev = LocalDeviceDrivers[pFsys->DevIdx].pDevDr;
  1027. // Add the original file name to the path
  1028. FsysPath += '/';
  1029. FsysPath += p;
  1030. }
  1031. else
  1032. {
  1033. pLock->UnlockWrite();
  1034. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - Cant resolve parent dir.", Path);
  1035. return FALSE;
  1036. }
  1037. }
  1038. else
  1039. {
  1040. pLock->UnlockWrite();
  1041. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - File don't exist.", Path);
  1042. return FALSE;
  1043. }
  1044. }
  1045. else
  1046. {
  1047. if (pNode->f_Locked || (pNode->f_OpenCnt && (m_pFsys->m_CreateHdr.dwDesiredAccess & GENERIC_WRITE)))
  1048. {
  1049. pLock->UnlockWrite();
  1050. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - File is open. Access denied.", Path);
  1051. return FALSE;
  1052. }
  1053. FsysPath = ResolveFsysPath(smFileNode, smFsys);
  1054. pFsys = (FILE_SYSTEM *)pSmem->__Ptr(smFsys);
  1055. pDev = LocalDeviceDrivers[pFsys->DevIdx].pDevDr;
  1056. if (!pDev || FsysPath.IsEmpty() || !pNode)
  1057. {
  1058. pLock->UnlockWrite();
  1059. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - Unresolved internal references.", Path);
  1060. return FALSE;
  1061. }
  1062. if (pNode->f_UseCopy)
  1063. {
  1064. ASSERT(FALSE); // Not yet implemented
  1065. }
  1066. }
  1068. m_pFsys->m_CreateHdr.pFile->m_hFile = pDev->CreateFile(
  1069. FsysPath,
  1070. m_pFsys->m_CreateHdr.dwDesiredAccess,
  1071. m_pFsys->m_CreateHdr.dwShareMode,
  1072. m_pFsys->m_CreateHdr.lpSecurityAttributes,
  1073. m_pFsys->m_CreateHdr.dwCreationDistribution,
  1074. m_pFsys->m_CreateHdr.dwFlagsAndAttributes,
  1075. m_pFsys->m_CreateHdr.hTemplateFile);
  1077. if (m_pFsys->m_CreateHdr.pFile->m_hFile == INVALID_HANDLE_VALUE)
  1078. {
  1079. pLock->UnlockWrite();
  1080. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - Failed to open file.", cMyPath);
  1081. return FALSE;
  1082. }
  1084. // File opened OK. See if this was a new file
  1085. if (smParentDir)
  1086. {
  1087. DIR_NODE *pDir = NULL;
  1088. pNode = NULL;
  1090. ScanPath(cMyPath, FALSE, FALSE, TRUE, FALSE);
  1091. if (FindNodeFromPath(smFileNode, cMyPath))
  1092. {
  1093. pNode = (FILE_NODE *)pSmem->__Ptr(smFileNode);
  1095. if (pNode)
  1096. {
  1097. // The new node does not have any valid 'soft' permissions.
  1098. // Give the user permission to create the file. We'll be a little
  1099. // more restrictive as soon as the file is created :-)
  1100. pNode->Perms &= ~NODE_SETTABLE;
  1101. pNode->Perms |= 0666;
  1102. }
  1103. }
  1105. if (!CheckPermissions(cMyPath, 0, NODE_WRITE, &smFileNode) || !smFileNode)
  1106. {
  1107. pDev->CloseHandle(m_pFsys->m_CreateHdr.pFile->m_hFile);
  1108. m_pFsys->m_CreateHdr.pFile->m_hFile = INVALID_HANDLE_VALUE;
  1109. pLock->UnlockWrite();
  1110. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - Failed to create file.", FsysPath);
  1111. // Delete the node
  1112. if (pNode)
  1113. {
  1114. pNode->f_DeleteFile = TRUE; // Physically erase the file
  1115. DeleteNode(smFileNode);
  1116. }
  1117. return FALSE;
  1118. }
  1120. if (pNode)
  1121. {
  1122. // Set permissions
  1123. pDir = (DIR_NODE *)pSmem->__Ptr(pNode->Father);
  1124. ASSERT(pDir != NULL);
  1126. if (pDir && pDir->SpecialNewFilePerm)
  1127. {
  1128. pNode->Perms &= ~NODE_SETTABLE;
  1129. pNode->Perms |= (pDir->SpecialNewFilePerm & NODE_SETTABLE);
  1130. }
  1132. pNode->Perms &= ~(m_pFsys->m_Umask & NODE_SETTABLE);
  1133. if (m_pFsys->m_AssignTo != INVALID_USER_VALUE)
  1134. pNode->User = m_pFsys->m_AssignTo;
  1135. else
  1136. pNode->User = m_pFsys->m_User;
  1137. pNode->Class = m_pFsys->m_Class;
  1138. if (pDir)
  1139. {
  1140. // Flush..
  1141. pDir->f_Dirty = TRUE;
  1142. Flush(pNode->Father);
  1143. }
  1144. }
  1145. }
  1147. ASSERT(pNode != NULL);
  1148. if (m_pFsys->m_CreateHdr.dwDesiredAccess & GENERIC_WRITE)
  1149. {
  1150. pNode->f_Locked = TRUE;
  1151. }
  1153. m_pFsys->m_CreateHdr.pFile->m_DEV = pDev;
  1154. m_pFsys->m_CreateHdr.pFile->m_smNode = smFileNode;
  1156. // Mark the file as open
  1157. pNode->f_OpenCnt++;
  1159. pLock->UnlockWrite();
  1161. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1162. LogMsg(LOGF_DEBUG,"User opened file %s", FsysPath);
  1163. return TRUE;
  1164. }
  1166. // Change the users working dir
  1167. BOOL CFsysThread::DoChDirUser(LPCSTR Path)
  1168. {
  1169. if (!ChDir(Path))
  1170. return FALSE;
  1172. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1173. LogMsg(LOGF_DEBUG,"User changed directory to %s", m_pFsys->m_CWD);
  1174. return TRUE;
  1175. }
  1177. // Change the users working dir
  1178. BOOL CFsysThread::ChDir(LPCSTR Path)
  1179. {
  1180. CString cMyPath = Path;
  1181. SMEM smNode, smFsys;
  1183. if (!ParsePath(cMyPath))
  1184. {
  1185. m_pFsys->m_FsysErrno = FSE_BAD_PATH;
  1186. return FALSE;
  1187. }
  1189. ScanPath(cMyPath, FALSE, FALSE, FALSE);
  1191. pLock->ReadLock();
  1193. if (!CheckPermissions(cMyPath, NODE_DIR, NODE_EXEC, &smNode))
  1194. {
  1195. pLock->UnlockRead();
  1196. m_pFsys->m_FsysErrno = FSE_PERMISSION_DENIED;
  1197. return FALSE;
  1198. }
  1200. m_pFsys->m_CWD = cMyPath;
  1201. if (smNode)
  1202. m_pFsys->m_DOSCWD = ResolveFsysPath(smNode, smFsys);
  1203. else
  1204. m_pFsys->m_DOSCWD = "**unresolved**";
  1206. pLock->UnlockRead();
  1208. return TRUE;
  1209. }
  1212. // Command line is parsed. Each token is seperated by ;
  1213. // that is - normally "CMD;arg arg arg"
  1214. BOOL CFsysThread::DoPrepereUserCmdLine(LPCSTR CmdLine)
  1215. {
  1216. CString cBuf;
  1217. BOOL BreakAtSpace;
  1219. m_pFsys->m_FsysPath2.Empty(); // Return buffer
  1221. while(*CmdLine)
  1222. {
  1223. BreakAtSpace = (*CmdLine == '-');
  1224. cBuf = "";
  1226. while(*CmdLine)
  1227. {
  1228. if (BreakAtSpace && (*CmdLine == ' '))
  1229. {
  1230. while(*CmdLine == ' ')
  1231. ++CmdLine;
  1232. break;
  1233. }
  1234. if (*CmdLine == 'n')
  1235. {
  1236. while(*CmdLine == 'n')
  1237. ++CmdLine;
  1238. ++CmdLine;
  1239. break;
  1240. }
  1242. cBuf += *CmdLine++;
  1243. }
  1245. if (!cBuf.IsEmpty())
  1246. {
  1247. if (!BreakAtSpace && (strpbrk(cBuf, "~{[*?")))
  1248. {
  1249. LogMsg(LOGF_WARNINGS,"DoPrepereUserCmdLine(%s) - Pattern matching is not yet implemented.", cBuf);
  1250. }
  1251. else
  1252. {
  1253. if (!m_pFsys->m_FsysPath2.IsEmpty())
  1254. m_pFsys->m_FsysPath2 += 'n';
  1255. m_pFsys->m_FsysPath2 += cBuf;
  1256. }
  1257. }
  1258. }
  1260. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1261. return TRUE;
  1262. }
  1264. // List. This is the full implementation of the UNIX ls command.
  1265. // Create the temporary lists, sort it and write to a tmp file.
  1266. // Return the tmp path to the file in user path 2.
  1267. BOOL CFsysThread::DoList(LPCSTR ArgumentsUnparsed)
  1268. {
  1269. CVfSysLs ls;
  1270. ls.m_pFsysThread = this;
  1271. CCmdArgs UnixArgs;
  1272. LPSTR p = m_pFsys->m_FsysPath1.GetBuffer(1);
  1274. for(p = strtok(p, "n"); p; p = strtok(NULL,"n"))
  1275. UnixArgs.AddArg(p);
  1277. ls.Create(&UnixArgs, CLog::GetLog(), NULL, m_pFsys);
  1278. if (ls.Exec() != 0)
  1279. {
  1280. m_pFsys->m_FsysErrno = FSE_UNIX_ERROR;
  1281. LogMsg(LOGF_WARNINGS,"ls command failed.");
  1282. return FALSE;
  1283. }
  1285. m_pFsys->m_FsysPath1.Empty();
  1286. m_pFsys->m_FsysPath2 = ls.m_TmpName;
  1287. fclose(ls.m_stdio);
  1288. ls.m_stdio = NULL;
  1290. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1291. return TRUE;
  1292. }
  1294. // Native War listing. Place output in 
  1295. // m_pFsys->m_FsysPath2
  1297. BOOL CFsysThread::DoWlist(LPCSTR ArgumentsUnparsed)
  1298. {
  1299. ParsePath(m_pFsys->m_FsysPath1);
  1300. ScanPath(m_pFsys->m_FsysPath1, FALSE, FALSE, FALSE);
  1302. pLock->ReadLock();
  1303. CFileList FileList;
  1304. if (BldFileInfoList(FileList,m_pFsys->m_FsysPath1, TRUE))
  1305. FileList.ListRaw(m_pFsys->m_FsysPath2);
  1306. else
  1307. {
  1308. pLock->UnlockRead();
  1309. m_pFsys->m_FsysErrno = FSE_UNIX_ERROR;
  1310. FileList.Empty();
  1311. return FALSE;
  1312. }
  1313. pLock->UnlockRead();
  1314. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1315. return TRUE;
  1316. }
  1318. BOOL CFsysThread::DoChmod(CCmdArgs& Args)
  1319. {
  1320. CChmod Chmod(this);
  1321. if (!Chmod.Create(&Args, CLog::GetLog(), BUFFER_STDIO, m_pFsys))
  1322. return FALSE;
  1324. Chmod.Exec();
  1325. m_pFsys->m_Output = Chmod.m_stdout;
  1327. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1328. return TRUE;
  1329. }
  1331. // Flush security information
  1332. // Calling layer takes tare of locking...
  1333. void CFsysThread::Flush(SMEM smDir)
  1334. {
  1335. DIR_NODE *pDir = (DIR_NODE *)pSmem->__Ptr(smDir);
  1336. if (pDir && pDir->f_Dirty)
  1337. {
  1338. SMEM smFsys;
  1339. CString FsysPath = ResolveFsysPath(smDir, smFsys);
  1340. if (!FsysPath.IsEmpty())
  1341. {
  1342. HANDLE h = CFsysSecurity::OpenSecurityGroupForUpdate(FsysPath);
  1343. if (h != INVALID_HANDLE_VALUE)
  1344. {
  1345. FILE_NODE *pNode;
  1346. DIR_NODE *pThisDir;
  1348. for(pNode = (FILE_NODE *)pSmem->__Ptr(pDir->Son);
  1349. pNode;
  1350. pNode = (FILE_NODE *)pSmem->__Ptr(pNode->Next))
  1351. {
  1352. if (pNode->f_Deleted)
  1353. continue;
  1355. if (pNode->Perms & NODE_DIR)
  1356. pThisDir = (DIR_NODE *)pNode;
  1357. else
  1358. pThisDir = NULL;
  1360. CFsysSecurity::FlushNode(h,
  1361. pNode->Name,
  1362. pNode->Perms & NODE_SETTABLE,
  1363. pNode->User,
  1364. pNode->Class,
  1365. pNode->DlCount,
  1366. pNode->Comment ? pNode->Comment : "",
  1367. pThisDir ? pThisDir->SpecialNewFilePerm : 0);
  1368. }
  1369. CFsysSecurity::CloseSecurityGroup(h);
  1370. pDir->f_Dirty = FALSE;
  1371. }
  1372. }
  1373. }
  1374. }
  1377. BOOL CFsysThread::DoFsysStat()
  1378. {
  1379. pLock->ReadLock();
  1380. SUPER_MEM_BLKS_HDR *pSuper = (SUPER_MEM_BLKS_HDR *)pSmem->m_Blks[0];
  1382. if (!pSuper)
  1383. return FALSE;
  1386. CString cBuf;
  1388. m_pFsys->m_Output = "VfSys shared memory statistics.n-------------------------------n";
  1391. cBuf.Format("Segments: %d (size=%d) Nodes : %d  Used nodes: %d  Total memory: %d  User memory %dn",
  1392. pSuper->NumUsedSegments,
  1393. pSuper->SegmentSize,
  1394. pSuper->NumNodes,
  1395. pSuper->UsedNodes,
  1396. pSuper->PhysMemory,
  1397. pSuper->UserMemory);
  1399. m_pFsys->m_Output += cBuf;
  1401. m_pFsys->m_Output += "nnVfSys statistics.n-----------------n";
  1404. FILE_SYSTEM *pFsys = (FILE_SYSTEM *)pSmem->__Ptr(*(SMEM *)(&pSmem->m_Segments[0].m_pSMH->pUserPtr[USERPTR_FSYS]));
  1405. while(pFsys)
  1406. {
  1407. cBuf.Format("File system '%s' (%s) FlushDelay=%d copy=%dn", 
  1408. pFsys->Vpath, 
  1409. pFsys->DOSPath,
  1410. pFsys->FlushDelay,
  1411. pFsys->DoCopy);
  1413. m_pFsys->m_Output += cBuf;
  1414. pFsys = (FILE_SYSTEM *)pSmem->__Ptr(pFsys->Next);
  1415. }
  1418. pLock->UnlockRead();
  1420. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1421. return TRUE;
  1422. }
  1425. BOOL CFsysThread::DoCreateDirectory(LPCSTR Path)
  1426. {
  1427. CString cMyPath = Path, FsysPath;
  1428. FILE_SYSTEM *pFsys = NULL;
  1429. CDeviceDriver *pDev = NULL;
  1431. if (!ParsePath(cMyPath))
  1432. {
  1433. m_pFsys->m_FsysErrno = FSE_BAD_PATH;
  1434. return FALSE;
  1435. }
  1437. ScanPath(cMyPath, FALSE, FALSE, FALSE);
  1439. pLock->ReadLock();
  1440. if (!CheckPermissions(cMyPath, 0, NODE_WRITE, NULL))
  1441. {
  1442. pLock->UnlockRead();
  1443. m_pFsys->m_FsysErrno = FSE_PERMISSION_DENIED;
  1444. return FALSE;
  1445. }
  1447. // Get the parent dir
  1448. CString ParentDir = cMyPath;
  1449. LPSTR p = ParentDir.GetBuffer(1);
  1450. p = strrchr(p,'/');
  1451. if (!p)
  1452. {
  1453. bad_path:
  1454. pLock->UnlockRead();
  1455. m_pFsys->m_FsysErrno = FSE_BAD_PATH;
  1456. return FALSE;
  1457. }
  1459. *p++ = 0;
  1460. ParentDir.ReleaseBuffer();
  1461. if (ParentDir.IsEmpty())
  1462. ParentDir = "/";
  1464. LPCSTR NewName = p;
  1466. if (!*NewName)
  1467. goto bad_path;
  1469. // Get device driver
  1470. SMEM smFsys, smDir;
  1471. if (!FindNodeFromPath(smDir, ParentDir))
  1472. {
  1473. pLock->UnlockRead();
  1474. m_pFsys->m_FsysErrno = FSE_PATH_NOT_FOUND;
  1475. return FALSE;
  1476. }
  1478. FsysPath = ResolveFsysPath(smDir, smFsys);
  1479. pFsys = (FILE_SYSTEM *)pSmem->__Ptr(smFsys);
  1480. pDev = LocalDeviceDrivers[pFsys->DevIdx].pDevDr;
  1481. if (!pDev || FsysPath.IsEmpty())
  1482. {
  1483. pLock->UnlockWrite();
  1484. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateDirectory(%s) - Unresolved internal references.", Path);
  1485. return FALSE;
  1486. }
  1488. // Finally, create the directory
  1489. if (FsysPath[FsysPath.GetLength()-1] != '/')
  1490. FsysPath += '/';
  1491. FsysPath += NewName;
  1493. if (!pDev->CreateDirectory || !pDev->CreateDirectory(FsysPath))
  1494. {
  1495. pLock->UnlockRead();
  1496. m_pFsys->m_FsysErrno = FSE_PERMISSION_DENIED;
  1497. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateDirectory(%s) - Failed to create directory. (%s)", 
  1498. Path, FsysPath);
  1499. return FALSE;
  1500. }
  1502. pLock->UnlockRead();
  1504. LogMsg(LOGF_FILEACC,"Created directory '%s' (%s)", Path, FsysPath);
  1505. ScanPath(cMyPath, FALSE, FALSE, TRUE);
  1507. pLock->WriteLock();
  1509. FILE_NODE *pNode;
  1510. DIR_NODE *pDir;
  1511. SMEM smNode;
  1512. if (FindNodeFromPath(smNode, cMyPath))
  1513. {
  1514. pNode = (FILE_NODE *)pSmem->__Ptr(smNode);
  1515. if (pNode)
  1516. {
  1517. // Set permissions
  1518. pNode->Perms |= 0777;
  1519. pDir = (DIR_NODE *)pSmem->__Ptr(pNode->Father);
  1520. ASSERT(pDir != NULL);
  1522. if (pDir && pDir->SpecialNewFilePerm)
  1523. {
  1524. pNode->Perms &= ~NODE_SETTABLE;
  1525. pNode->Perms |= (pDir->SpecialNewFilePerm & NODE_SETTABLE);
  1526. }
  1528. pNode->Perms &= ~(m_pFsys->m_Umask & NODE_SETTABLE);
  1529. if (m_pFsys->m_AssignTo != INVALID_USER_VALUE)
  1530. pNode->User = m_pFsys->m_AssignTo;
  1531. else
  1532. pNode->User = m_pFsys->m_User;
  1533. pNode->Class = m_pFsys->m_Class;
  1534. if (pDir)
  1535. {
  1536. // Flush..
  1537. pDir->f_Dirty = TRUE;
  1538. Flush(pNode->Father);
  1539. }
  1540. }
  1541. }
  1543. pLock->UnlockWrite();
  1545. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1546. return TRUE;
  1547. }
  1549. BOOL CFsysThread::DoDeleteGeneric(LPCSTR Path, DWORD Flags)
  1550. {
  1552. CString cMyPath = Path, FsysPath;
  1553. FILE_SYSTEM *pFsys = NULL;
  1554. CDeviceDriver *pDev = NULL;
  1555. CWarTimer Timer;
  1557. if (!ParsePath(cMyPath))
  1558. {
  1559. m_pFsys->m_FsysErrno = FSE_BAD_PATH;
  1560. return FALSE;
  1561. }
  1564. for(; !Timer.TimeOut(1000 * 120); Sleep(1000)) // Try for 2 minues (should be enough for IIS and other shit to close the file...)
  1565. {
  1566. pLock->WriteLock();
  1567. ScanPath(cMyPath, FALSE, FALSE, TRUE, FALSE);
  1568. if (!CheckPermissions(cMyPath, 0, NODE_WRITE, NULL))
  1569. {
  1570. perm_denied:
  1571. pLock->UnlockWrite();
  1572. m_pFsys->m_FsysErrno = FSE_PERMISSION_DENIED;
  1573. return FALSE;
  1574. }
  1576. // Get device driver
  1577. SMEM smFsys, smDir;
  1578. if (!FindNodeFromPath(smDir, cMyPath))
  1579. {
  1580. pLock->UnlockWrite();
  1581. m_pFsys->m_FsysErrno = FSE_PATH_NOT_FOUND;
  1582. return FALSE;
  1583. }
  1585. DIR_NODE *pDir = (DIR_NODE *)pSmem->__Ptr(smDir);
  1587. // Check type
  1588. if (pDir->FileNode.Perms & NODE_DIR) 
  1589. {
  1590. if (!(Flags & DELE_DIR))
  1591. goto perm_denied;
  1592. }
  1593. else if (!(Flags & DELE_FILE))
  1594. goto perm_denied;
  1596. // Check if the file is in use...
  1597. if (pDir->FileNode.f_OpenCnt || pDir->FileNode.f_Locked)
  1598. goto perm_denied; // This can be handled better in the future :-)
  1600. FsysPath = ResolveFsysPath(smDir, smFsys);
  1601. pFsys = (FILE_SYSTEM *)pSmem->__Ptr(smFsys);
  1602. pDev = LocalDeviceDrivers[pFsys->DevIdx].pDevDr;
  1603. if (!pDev || FsysPath.IsEmpty())
  1604. {
  1605. pLock->UnlockWrite();
  1606. LogMsg(LOGF_ERROR,"CFsysThread::DoCreateFile(%s) - Unresolved internal references.", Path);
  1607. return FALSE;
  1608. }
  1610. // Try to delete the file
  1611. if ((pDir->FileNode.Perms & NODE_DIR) && !(pDir->FileNode.Perms & NODE_LINK))
  1612. {
  1613. // This is a bit tricky.. We have to look for .Index.txt and our own security file.
  1614. // If they are the only files in the directory, delete them, and then delete the dir..
  1615. CFileInfo Info;
  1616. CString SearchPath = FsysPath;
  1617. SearchPath += "/*";
  1618. HANDLE h;
  1620. if ((h = pDev->FindFirstFile(SearchPath, Info)) != INVALID_HANDLE_VALUE)
  1621. {
  1622. do
  1623. {
  1624. LPCSTR Name = Info.FileName(); 
  1625. if (!stricmp(Name,".")
  1626. || !stricmp(Name,"..")
  1627. || !stricmp(Name,".Index.txt")
  1628. || !stricmp(Name, SECFILE))
  1629. continue;
  1631. LogMsg(LOGF_DEBUG,"CFsysThread::DoDeleteGeneric(%s) - Directory is not empty.", Path);
  1632. pDev->FindClose(h);
  1633. pLock->UnlockWrite();
  1634. m_pFsys->m_FsysErrno = FSE_PERMISSION_DENIED;
  1635. return FALSE;
  1637. } while(pDev->FindNextFile(h, Info));
  1639. pDev->FindClose(h);
  1640. }
  1642. // Things looks all right... Clean up War files
  1643. {
  1644. CString Target;
  1646. Target = FsysPath;
  1647. Target += "/.Index.txt";
  1648. pDev->DeleteFile(Target);
  1650. Target = FsysPath;
  1651. Target += '/';
  1652. Target += SECFILE;
  1653. pDev->DeleteFile(Target);
  1654. }
  1656. if (pDev->RemoveDirectory(FsysPath))
  1657. {
  1658. pLock->UnlockWrite();
  1659. ScanPath(cMyPath, FALSE, FALSE, TRUE, FALSE);
  1660. LogMsg(LOGF_FILEACC,"Deleted Directory '%s' (%s)", Path, FsysPath);
  1661. break;
  1662. }
  1663. }
  1664. else
  1665. {
  1666. if (pDev->DeleteFile(FsysPath))
  1667. {
  1668. pLock->UnlockWrite();
  1669. ScanPath(cMyPath, FALSE, FALSE, TRUE, FALSE);
  1670. LogMsg(LOGF_FILEACC,"Deleted file '%s' (%s)", Path, FsysPath);
  1671. break;
  1672. }
  1673. }
  1674. pLock->UnlockWrite();
  1675. }
  1677. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1678. return TRUE;
  1679. }
  1681. BOOL CFsysThread::DoCreateLink(LPCSTR From, LPCSTR To)
  1682. {
  1684. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1685. return TRUE;
  1686. }
  1689. BOOL CFsysThread::DoMoveFile(LPCSTR From, LPCSTR To)
  1690. {
  1691. CString FromPath = From, ToPath = To, FsysFromPath, FsysToPath;
  1692. SMEM smFromNode, smToNode, smFromFsys, smToFsys, smToFatherDir;
  1693. CDeviceDriver *pDev = NULL;
  1694. FILE_SYSTEM *pFsys = NULL;
  1695. DIR_NODE *pFatherDir;
  1697. if (!ParsePath(FromPath) || !ParsePath(ToPath))
  1698. {
  1699. m_pFsys->m_FsysErrno = FSE_BAD_PATH;
  1700. return FALSE;
  1701. }
  1703. pLock->WriteLock();
  1705. // Check permissions
  1706. ScanPath(FromPath, FALSE, FALSE, TRUE, FALSE);
  1707. ScanPath(ToPath, FALSE, FALSE, TRUE, FALSE);
  1708. if (!CheckPermissions(FromPath, 0, NODE_WRITE, NULL) 
  1709. || !CheckPermissions(ToPath, 0, NODE_WRITE, NULL))
  1710. {
  1711. perm_denied:
  1712. pLock->UnlockWrite();
  1713. m_pFsys->m_FsysErrno = FSE_PERMISSION_DENIED;
  1714. return FALSE;
  1715. }
  1717. // Get from node data
  1718. if (!FindNodeFromPath(smFromNode, FromPath))
  1719. goto perm_denied;
  1721. DIR_NODE *pFromDir = (DIR_NODE *)pSmem->__Ptr(smFromNode);
  1722. ASSERT(pFromDir != NULL);
  1723. if (!pFromDir)
  1724. goto perm_denied;
  1726. // Don't mess with files that are in use...
  1727. if (ScanForBusyFiles(smFromNode))
  1728. goto perm_denied;
  1730. FsysFromPath = ResolveFsysPath(smFromNode, smFromFsys);
  1732. // Get to node data
  1733. if (FindNodeFromPath(smToNode, ToPath))
  1734. {
  1735. DIR_NODE *pToDir = (DIR_NODE *)pSmem->__Ptr(smToNode);
  1736. if ((pToDir->FileNode.Perms & NODE_DIR) == 0)
  1737. goto perm_denied; // Not a directory
  1738. ToPath += '/';
  1739. LPCSTR p = strrchr(FromPath, '/');
  1740. if (!p || !*++p || (*p == '/'))
  1741. goto perm_denied; // Invalid path
  1742. ToPath += p;
  1743. }
  1745. if (FindNodeFromPath(smToNode, ToPath))
  1746. goto perm_denied; // File exist
  1748. // Get the new path's father dir
  1749. CString ToPathFather = ToPath;
  1750. LPSTR p = ToPathFather.GetBuffer(1);
  1751. p = strrchr(p,'/');
  1752. if (p)
  1753. {
  1754. *p = 0;
  1755. if (!*++p || (*p == '/'))
  1756. goto perm_denied; // Invalid path
  1757. }
  1758. else
  1759. goto perm_denied; // Invalid path
  1761. ToPathFather.ReleaseBuffer();
  1763. if (!FindNodeFromPath(smToFatherDir, ToPathFather))
  1764. goto perm_denied; // No father...
  1766. DIR_NODE *pToFatherDir = (DIR_NODE *)pSmem->__Ptr(smToFatherDir);
  1767. if ((pToFatherDir->FileNode.Perms & NODE_DIR) == 0)
  1768. goto perm_denied; // Not a directory
  1770. FsysToPath = ResolveFsysPath(smToFatherDir, smToFsys);
  1771. FsysToPath += '/';
  1772. FsysToPath +=  p;
  1774. // Use origin's file system
  1775. pFsys = (FILE_SYSTEM *)pSmem->__Ptr(smFromFsys);
  1776. pDev = LocalDeviceDrivers[pFsys->DevIdx].pDevDr;
  1778. // See if we can do a simple rename
  1779. if (smToFatherDir == pFromDir->FileNode.Father)
  1780. {
  1781. CString NewName = p, OldName = pFromDir->FileNode.RealName;
  1782. if (NewName.IsEmpty() || OldName.IsEmpty())
  1783. goto perm_denied; // Illegal path
  1785. if (!pDev->MoveFile(FsysFromPath, FsysToPath))
  1786. goto perm_denied; // Permission denied
  1788. ChangeNodeInformation(&pFromDir->FileNode, NewName, NewName, NULL, NULL);
  1789. goto done;
  1790. }
  1792. // Move
  1793. if (!pDev->MoveFile(FsysFromPath, FsysToPath))
  1794. goto perm_denied; // Permission denied
  1796. // Fix permissions
  1797. // Don't use the file system. Relink the node to the new origin dir and
  1798. // save it.
  1799. UnlinkNode(smFromNode);
  1800. LinkToFather(smFromNode, smToFatherDir);
  1801. pFatherDir = (DIR_NODE *)pSmem->__Ptr(smToFatherDir);
  1802. pFatherDir->f_Dirty = TRUE;
  1803. Flush(smToFatherDir);
  1805. done:
  1806. pLock->UnlockWrite();
  1808. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1809. return TRUE;
  1810. }
  1813. BOOL CFsysThread::DoStat(LPCSTR Path)
  1814. {
  1815. CString cMyPath = Path;
  1816. SMEM smNode;
  1818. if (!ParsePath(cMyPath))
  1819. {
  1820. m_pFsys->m_FsysErrno = FSE_BAD_PATH;
  1821. return FALSE;
  1822. }
  1824. ScanPath(cMyPath, FALSE, FALSE, FALSE);
  1826. pLock->ReadLock();
  1828. if (!CheckPermissions(cMyPath, 0, NODE_READ, &smNode))
  1829. {
  1830. perm_denied:
  1831. pLock->UnlockRead();
  1832. m_pFsys->m_FsysErrno = FSE_PERMISSION_DENIED;
  1833. return FALSE;
  1834. }
  1836. FILE_NODE *pNode = (FILE_NODE *)pSmem->__Ptr(smNode);
  1837. if (!pNode)
  1838. {
  1839. ASSERT(FALSE);
  1840. goto perm_denied;
  1841. }
  1843. m_pFsys->m_FileLen = pNode->Size;
  1844. m_pFsys->m_FileTime = pNode->LastWriteDate;
  1845. m_pFsys->m_FilePerms = pNode->Perms;
  1847. pLock->UnlockRead();
  1849. ::PostMessage(m_CallbackWin, FSM_CALLBACK, (WPARAM)m_pFsys, 0);
  1850. return TRUE;
  1851. }