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

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > Ftp服务器 > 查看源码
FtpSession.cs
资源名称：FtpServer.rar　[点击查看]
上传用户：xuelanruo
上传日期：2015-04-02
资源大小：163k
文件大小：35k
源码类别：

Ftp服务器

开发平台：

C#

FtpSession.cs：源码内容
  1. /*
  2. Ftp Dot Net FtpSession Class : manage each client-session
  3. Copyright (C) 
  5. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.
  7. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
  9. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  11. Last modification : 04/26/2004 by Simon FERQUEL
  12. */
  13. using System;
  14. using System.IO;
  15. using System.Data;
  16. using System.Collections;
  17. using System.Net;
  18. using System.Net.Sockets;
  19. using System.Threading;
  22. namespace FtpServerLibrary
  23. {
  24. /// <summary>
  25. /// Description r閟um閑 de FtpSession.
  26. /// </summary>
  27. public class FtpSession
  28. {
  29. private Socket      m_pClientSocket    = null;  // Socket du client
  30. private FtpServer   m_pServer          = null;  // Server parent
  31. private long        m_SessionID ; // Identificateur de la session
  32. private string      m_UserName         = "";    // Nom de l'utilisateur
  33. private string      m_CurrentDir       = "/"; // R閜ertoire courrant
  34. private string      m_renameFrom       = "";
  35. private bool        m_PassiveMode      = false; // Flag mode passif
  36. private TcpListener m_pPassiveListener = null; // Listener en cas de mode passif
  37. private IPEndPoint  m_pDataConEndPoint = null; // "EndPoint" pour la connection de donn閑s
  38. private bool        m_Authenticated    = false; // Flag utilisateur authentifi?
  39. private int         m_BadCmdCount      = 0;     // Nombre de commandes erron閑s
  40. private DateTime    m_SessionStartTime; // Date de d閎ut de session
  41. private EndPoint m_rmtEndPoint; // adresse du client
  42. private int m_offset    = 0; // offset utile en cas d'usage de l'option "resume"
  43. private Hashtable m_vPaths; // Liste des r閜ertoire virtuels appliqu閟 ?l'utilisateur
  46. public void Close()
  47. {
  48. try{this.m_pClientSocket.Close();}
  49. catch{}
  50. try{this.m_pPassiveListener.Stop();}
  51. catch{}
  52. }
  55. #region Propri閠閟
  58. public long SessionID
  59. {
  60. get{return m_SessionID;}
  61. }
  62. public EndPoint RemoteEndPoint
  63. {
  64. get{return this.m_rmtEndPoint;}
  65. }
  67. private string m_ftproot    = "";
  69. public Socket ClientSocket
  70. {
  71. get{return this.m_pClientSocket;}
  72. }
  73. #endregion
  75. /// <summary>
  76. /// Constructeur par defaut
  77. /// </summary>
  78. /// <param name="clientSocket">Socket du client connect?/param>
  79. /// <param name="server">instance ded FtpServer</param>
  80. /// <param name="sessionID">Num閞o de session</param>
  81. public FtpSession(Socket clientSocket,FtpServer server,long sessionID)
  82. {
  83. this.m_pClientSocket=clientSocket;
  84. this.m_rmtEndPoint=clientSocket.RemoteEndPoint;
  85. this.m_pServer=server;
  86. this.m_SessionID=sessionID;
  87. this.m_SessionStartTime=System.DateTime.Now;
  89. }
  92. /// <summary>
  93. /// M閠hode permettant d'envoyer un message au client
  94. /// </summary>
  95. /// <param name="data">Message ?envoyer</param>
  96. private void SendData(string data)
  97. {
  98. Byte[] byte_data = System.Text.Encoding.Default.GetBytes(data.ToCharArray());
  99. m_pClientSocket.Send(byte_data,byte_data.Length,0);
  100. }
  102. /// <summary>
  103. /// Fonction permettant de lire une commande tap閑 par le client.
  104. /// </summary>
  105. /// <param name="clientSocket">Socket du client</param>
  106. /// <param name="timeOut">Nombre de secondes maximum pour la lecture</param>
  107. /// <returns></returns>
  108. private string ReadLine(Socket clientSocket,int timeOut)
  109. {
  110. long lastDataTime   = DateTime.Now.Ticks; //date de derni鑢e r閏eption
  111. ArrayList lineBuf   = new ArrayList(); //Buffer
  112. byte      prevByte  = 0;
  114. while(true)
  115. {
  116. if(clientSocket.Available > 0)
  117. {
  118. // On lit un octet
  119. byte[] currByte = new byte[1];
  120. int countRecieved = clientSocket.Receive(currByte,1,SocketFlags.None);
  121. // Si un octet est re鐄 (parfois ?la premi鑢e tentative, le client n'envoie rien)
  122. if(countRecieved == 1)
  123. {
  124. //on stocke l'octet dans le buffer
  125. lineBuf.Add(currByte[0]);
  127. // Si on arrive en fin de ligne, on renvoie la commande
  128. if((prevByte == (byte)'r' && currByte[0] == (byte)'n'))
  129. {
  130. byte[] retVal = new byte[lineBuf.Count-2];    // On enl鑦e les caract鑢es de fin de ligne 
  131. lineBuf.CopyTo(0,retVal,0,lineBuf.Count-2);
  133. return System.Text.Encoding.Default.GetString(retVal).Trim();
  134. }
  136. // on update la valeur de prevByte
  137. prevByte = currByte[0];
  139. //On met ?jour la date de derni鑢e r閏eption
  140. lastDataTime = DateTime.Now.Ticks;
  141. }
  142. }
  143. else
  144. {
  145. //Si le Timeout est atteint on lance une excepion
  146. if(DateTime.Now.Ticks > lastDataTime + ((long)(timeOut)) * 10000)
  147. {
  148. throw new ReadException(ReadReplyCode.TimeOut,"Read timeout");
  149. }
  150. System.Threading.Thread.Sleep(100);//N閏essaire pour des raisons 関identes de performance
  152. }
  153. }
  154. }
  157. /// <summary>
  158. /// Boucle de lecture et traitement des messages du client
  159. /// </summary>
  160. public void StartProcessing()
  161. {
  162. //le serveur est pr阾
  163. this.SendData(Messages.MessReady());
  165. long lastCmdTime = DateTime.Now.Ticks; //Date de 閏eption de la derni鑢e commande
  166. string lastCmd  = "";
  169. //Tant que le session time out n'est pas atteint ou que la commande "QUIT" n'est pas demand閑, on boucle 
  170. try
  171. {
  172. while(true)
  173. {
  174. //Si des donn閑s arrivent, on commence ?les lire.
  175. if (this.m_pClientSocket.Available >0)
  176. {
  177. try
  178. {
  179. lastCmd=this.ReadLine(m_pClientSocket,this.m_pServer.SessionIdleTimeOut);//Lecture de la Commande
  180. if(!SwitchCommand(lastCmd))//Si la commande est "QUIT" on quitte la boucle de traitement
  181. {
  182. break;
  183. }
  184. }
  185. catch(ReadException rX)
  186. {
  187. //On verifie que le nombre maximum d'erreurs de commandes n'est pas atteint
  188. if(m_BadCmdCount > m_pServer.MaxBadCommands-1)
  189. {
  190. SendData(Messages.MessTooManyBadCmds());//On envoie un message
  191. break;//et on quitte la boucle de traitement
  192. }
  193. m_BadCmdCount++;
  194. switch(rX.ReadReplyCode)//En fonction du type d'ereur (pour l'instant TimeOut et Unknown) on envoie un message
  195. {
  196. case ReadReplyCode.TimeOut:
  197. SendData(Messages.CmdTimeOut());
  198. break;
  200. case ReadReplyCode.UnknownError:
  201. SendData(Messages.UnknownError());
  202. break;
  203. }
  205. }
  206. catch
  207. {
  208. if(!this.m_pClientSocket.Connected)break;//Si le socket a 閠?d閏onnect? on quitte la boucle
  209. SendData(Messages.UnknownError());//Sinon on envoie un message d'erreur inconnu
  210. }
  211. //On update la date de la derni鑢e commande
  212. lastCmdTime = DateTime.Now.Ticks;
  213. }
  215. else
  216. {
  217. //On verifie qu'on n'aie pas atteint le timeOut
  218. if(DateTime.Now.Ticks > lastCmdTime + ((long)(m_pServer.SessionIdleTimeOut)) * 10000)
  219. {
  220. // Notification de fermeture de session
  221. SendData("500 Session timeout, OK FTP server signing offrn");
  222. break;
  223. }
  225. // On attends 100 ms afin d'閏onomiser le cpu (sinon la boucle mange trop de ressources). 
  226. Thread.Sleep(100);
  227. }
  228. }
  230. //Fermeture du Socket
  231. if(m_pClientSocket.Connected)
  232. {
  233. m_pClientSocket.Close();
  234. }
  235. //Destruction de la session
  236. this.m_pServer.RemoveSession(this.m_SessionID);
  238. }
  239. catch
  240. {
  241. this.m_pServer.RemoveSession(this.m_SessionID);
  242. }
  244. }
  246. /// <summary>
  247. /// En fonction de la commande utilisateur donn閑, cette fonction appelle la fonction ad閝uate
  248. /// </summary>
  249. /// <param name="commandTxt">Commande envoy閑</param>
  250. /// <returns>True si la session doit continuer, false si elle doit s'arr阾er (commande QUIT par exemple)</returns>
  251. private bool SwitchCommand(string commandTxt)
  252. {
  253. string[] cmdParts = commandTxt.TrimStart().Split(new char[]{' '});
  254. string   command  = cmdParts[0].ToUpper().Trim();
  256. switch(command)
  257. {
  258. case "QUIT":
  259. QUIT();
  260. return false;
  261. case "USER":
  262. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  263. else
  264. {
  265. if (cmdParts.Length>2)
  266. {
  267. string args="";
  268. for(int i=1;i<cmdParts.Length;i++)
  269. {
  270. args+=cmdParts[i]+" ";
  271. }
  272. USER(args);
  273. }
  274. else
  275. {
  276. USER(cmdParts[1]);
  277. }
  278. }
  279. break;
  280. case "TYPE":
  281. if (cmdParts.Length!=2)SendData(Messages.UnknownError());
  282. else TYPE(cmdParts[1]);
  283. break;
  284. case "PASS":
  285. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  286. else
  287. {
  288. if (cmdParts.Length>2)
  289. {
  290. string args="";
  291. for(int i=1;i<cmdParts.Length;i++)
  292. {
  293. args+=cmdParts[i]+" ";
  294. }
  295. PASS(args);
  296. }
  297. else
  298. {
  299. PASS(cmdParts[1]);
  300. }
  301. }
  302. break;
  303. case "PWD":
  304. PWD();
  305. break;
  307. case "XPWD":
  308. PWD();
  309. break;
  311. case "SYST":
  312. SYST();
  313. break;
  314. case "PORT":
  315. if (cmdParts.Length!=2)SendData(Messages.UnknownError());
  316. else PORT(cmdParts[1]);
  317. break;
  318. case "PASV":
  319. PASV();
  320. break;
  321. case "LIST":
  322. if (cmdParts.Length>1){
  323. if (cmdParts[1].Trim().ToLower()=="-a"||cmdParts[1].Trim().ToLower()=="-l"||cmdParts[1].Trim().ToLower()=="-al")
  324. {
  325. string[] parts=new string[cmdParts.Length-1];
  326. parts[0]=cmdParts[0];
  327. for (int i=2;i<cmdParts.Length;i++)
  328. parts[i-1]=cmdParts[i];
  329. cmdParts=parts;
  330. }
  331. }
  332. if (cmdParts.Length>2)
  333. {
  334. string args="";
  335. for(int i=1;i<cmdParts.Length;i++)
  336. {
  337. args+=cmdParts[i]+" ";
  338. }
  339. LIST(args);
  340. }
  341. else if(cmdParts.Length==2)LIST(cmdParts[1]);
  342. else LIST(String.Empty);
  343. break;
  344. case "NLST":
  345. if (cmdParts.Length>1)
  346. {
  347. if (cmdParts[1].Trim().ToLower()=="-a"||cmdParts[1].Trim().ToLower()=="-l"||cmdParts[1].Trim().ToLower()=="-al")
  348. {
  349. string[] parts=new string[cmdParts.Length-1];
  350. parts[0]=cmdParts[0];
  351. for (int i=2;i<cmdParts.Length;i++)
  352. parts[i-1]=cmdParts[i];
  353. cmdParts=parts;
  354. }
  355. }
  356. if (cmdParts.Length>2)
  357. {
  358. string args="";
  359. for(int i=1;i<cmdParts.Length;i++)
  360. {
  361. args+=cmdParts[i]+" ";
  362. }
  363. LIST(args);
  364. }
  365. else if(cmdParts.Length==2)NLST(cmdParts[1]);
  366. else NLST(String.Empty);
  367. break;
  369. case "CWD":
  370. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  371. else
  372. {
  373. if (cmdParts.Length>2)
  374. {
  375. string args="";
  376. for(int i=1;i<cmdParts.Length;i++)
  377. {
  378. args+=cmdParts[i]+" ";
  379. }
  380. CWD(args);
  381. }
  382. else
  383. {
  384. CWD(cmdParts[1]);
  385. }
  386. }
  387. break;
  388. case "RETR":
  389. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  390. else
  391. {
  392. if (cmdParts.Length>2)
  393. {
  394. string args="";
  395. for(int i=1;i<cmdParts.Length;i++)
  396. {
  397. args+=cmdParts[i]+" ";
  398. }
  399. RETR(args);
  400. }
  401. else
  402. {
  403. RETR(cmdParts[1]);
  404. }
  405. }
  406. break;
  407. case "STOR":
  408. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  409. else
  410. {
  411. if (cmdParts.Length>2)
  412. {
  413. string args="";
  414. for(int i=1;i<cmdParts.Length;i++)
  415. {
  416. args+=cmdParts[i]+" ";
  417. }
  418. STOR(args);
  419. }
  420. else
  421. {
  422. STOR(cmdParts[1]);
  423. }
  424. }
  425. break;
  427. case "DELE":
  428. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  429. else
  430. {
  431. if (cmdParts.Length>2)
  432. {
  433. string args="";
  434. for(int i=1;i<cmdParts.Length;i++)
  435. {
  436. args+=cmdParts[i]+" ";
  437. }
  438. DELE(args);
  439. }
  440. else
  441. {
  442. DELE(cmdParts[1]);
  443. }
  444. }
  445. break;
  447. case "RMD":
  448. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  449. else
  450. {
  451. if (cmdParts.Length>2)
  452. {
  453. string args="";
  454. for(int i=1;i<cmdParts.Length;i++)
  455. {
  456. args+=cmdParts[i]+" ";
  457. }
  458. RMD(args);
  459. }
  460. else
  461. {
  462. RMD(cmdParts[1]);
  463. }
  464. }
  465. break;
  467. case "APPE":
  468. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  469. else
  470. {
  471. if (cmdParts.Length>2)
  472. {
  473. string args="";
  474. for(int i=1;i<cmdParts.Length;i++)
  475. {
  476. args+=cmdParts[i]+" ";
  477. }
  478. APPE(args);
  479. }
  480. else
  481. {
  482. APPE(cmdParts[1]);
  483. }
  484. }
  485. break;
  487. case "RNFR":
  488. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  489. else
  490. {
  491. if (cmdParts.Length>2)
  492. {
  493. string args="";
  494. for(int i=1;i<cmdParts.Length;i++)
  495. {
  496. args+=cmdParts[i]+" ";
  497. }
  498. RNFR(args);
  499. }
  500. else
  501. {
  502. RNFR(cmdParts[1]);
  503. }
  504. }
  505. break;
  507. case "RNTO":
  508. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  509. else
  510. {
  511. if (cmdParts.Length>2)
  512. {
  513. string args="";
  514. for(int i=1;i<cmdParts.Length;i++)
  515. {
  516. args+=cmdParts[i]+" ";
  517. }
  518. RNTO(args);
  519. }
  520. else
  521. {
  522. RNTO(cmdParts[1]);
  523. }
  524. }
  525. break;
  527. case "MKD":
  528. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  529. else
  530. {
  531. if (cmdParts.Length>2)
  532. {
  533. string args="";
  534. for(int i=1;i<cmdParts.Length;i++)
  535. {
  536. args+=cmdParts[i]+" ";
  537. }
  538. MKD(args);
  539. }
  540. else
  541. {
  542. MKD(cmdParts[1]);
  543. }
  544. }
  545. break;
  547. case "REST":
  548. if (cmdParts.Length<2)SendData(Messages.UnknownError());
  549. else
  550. {
  551. if (cmdParts.Length>2)
  552. {
  553. string args="";
  554. for(int i=1;i<cmdParts.Length;i++)
  555. {
  556. args+=cmdParts[i]+" ";
  557. }
  558. REST(args);
  559. }
  560. else
  561. {
  562. REST(cmdParts[1]);
  563. }
  564. }
  565. break;
  567. case "CDUP" :
  568. CWD("..");
  569. break;
  570. case "NOOP" :
  571. NOOP();
  572. break;
  574.                     
  575. default:
  576. SendData("500 Invalid command " + command + "rn");
  577. break;
  579. }
  581. return true;
  582. }
  586. /// <summary>
  587. /// Cette fonction ne fait absoluement rien
  588. /// </summary>
  589. private void NOOP()
  590. {
  591. SendData("200 OK rn");
  592. }
  594. /// <summary>
  595. /// Cr閍tion d'un nouveau r閜ertoire
  596. /// </summary>
  597. /// <param name="argsText">nom du r閜ertoire</param>
  598. private void MKD(string argsText)
  599. {
  600. if(!m_Authenticated)
  601. {
  602. SendData(Messages.AuthReq());
  603. return;
  604. }
  605. string file;
  606. string newCurdir;
  607. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,argsText,this.m_vPaths,out file, out newCurdir))
  608. {
  609. SendData(Messages.AccesDenied());
  610. return;
  611. }
  613. try
  614. {
  615. new DirectoryInfo(file).Create();
  616. SendData("257 Directory Created. rn");
  617. }
  618. catch
  619. {
  620. SendData(Messages.AccesDenied());
  621. return;
  622. }
  623. }
  624. /// <summary>
  625. /// Juste avant un RNTO permet de sp閏ifi?le nom du fichier ?renomer
  626. /// </summary>
  627. /// <param name="argsText"></param>
  628. private void RNFR(string argsText)
  629. {
  630. if(!m_Authenticated)
  631. {
  632. SendData(Messages.AuthReq());
  633. return;
  634. }
  635. string file;
  636. string newCurdir;
  637. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,argsText,this.m_vPaths,out file, out newCurdir)||!(System.IO.File.Exists(file)||System.IO.Directory.Exists(file)))
  638. {
  639. SendData(Messages.AccesDenied());
  640. return;
  641. }
  643. this.m_renameFrom=file;
  644. SendData("350 Please specify destination name.rn");
  646. }
  648. /// <summary>
  649. /// Etape suivant le RNFR
  650. /// </summary>
  651. /// <param name="argsText"></param>
  652. private void RNTO(string argsText)
  653. {
  654. if(!m_Authenticated)
  655. {
  656. SendData(Messages.AuthReq());
  657. return;
  658. }
  659. if(this.m_renameFrom.Length<1)
  660. {
  661. SendData("503 Bad sequence of commands. rn");
  662. return;
  663. }
  665. string file;
  666. string newCurdir;
  667. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,argsText,this.m_vPaths,out file, out newCurdir))
  668. {
  669. SendData(Messages.AccesDenied());
  670. return;
  671. }
  673. try
  674. {
  675. (new System.IO.FileInfo(this.m_renameFrom)).MoveTo(file);
  676. SendData("250 Directory renamed.rn");
  677. }
  678. catch
  679. {
  680. try
  681. {
  682. (new System.IO.DirectoryInfo(this.m_renameFrom)).MoveTo(file);
  683. SendData("250 Directory renamed.rn");
  684. }
  685. catch
  686. {
  687. SendData("550 Error renameing directory or file .rn");
  688. }
  689. }
  690. this.m_renameFrom="";
  692. }
  694. /// <summary>
  695. /// Cette m閠hode permet de d閒inir l'offset a partir duquel un fichier est t閘閏harg?
  696. /// (n閏essaire pour la fonction resume)
  697. /// </summary>
  698. /// <param name="argsText">offset</param>
  699. private void REST(string argsText)
  700. {
  701. if(!m_Authenticated)
  702. {
  703. SendData(Messages.AuthReq());
  704. return;
  705. }
  706. try
  707. {
  708. this.m_offset=Convert.ToInt32(argsText);
  709. SendData("350 Restarting at "+this.m_offset.ToString()+"rn");
  710. }
  711. catch
  712. {
  713. SendData("554 bad argument for RESTrn");
  714. }
  715. }
  716. /// <summary>
  717. /// Cette m閠hode permet ?l'utilisateur d'envoyer la "fin" d'un fichier
  718. /// </summary>
  719. /// <param name="argsText">fichier ?compl閠er</param>
  720. private void APPE(string argsText)
  721. {
  722. if(!m_Authenticated)
  723. {
  724. SendData(Messages.AuthReq());
  725. return;
  726. }
  727. string file;
  728. string newCurdir;
  729. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,argsText,this.m_vPaths,out file, out newCurdir))
  730. {
  731. SendData(Messages.AccesDenied());
  732. return;
  733. }
  735. FileStream fs;
  736. try
  737. {
  738. fs=new FileStream(file,FileMode.OpenOrCreate,FileAccess.Write);
  739. fs.Position=fs.Length;
  740. }
  741. catch
  742. {
  743. SendData(Messages.AccesDenied());
  744. return;
  745. }
  746. Socket socket=this.GetDataConnection();
  747. try
  748. {
  749. if(socket==null||fs==null)
  750. {
  751. throw new Exception();
  752. }
  753. int readed = 1;
  754. byte[] buffer=new byte[4096];
  755. while(readed>0)
  756. {
  757. readed=socket.Receive(buffer);
  758. fs.Write(buffer,0,readed);
  759. }
  760. socket.Shutdown(SocketShutdown.Both);
  761. socket.Close();
  762. SendData(Messages.TrComplete());
  763. }
  764. catch
  765. {
  766. SendData(Messages.TrFailed());
  767. socket.Close();
  768. }
  769. fs.Close();
  771. }
  773. /// <summary>
  774. /// Cette m閠hode permet au client de suprimer un fichier
  775. /// </summary>
  776. /// <param name="argsText">fichier ?supprimer</param>
  777. private void DELE(string argsText)
  778. {
  779. if(!m_Authenticated)
  780. {
  781. SendData(Messages.AuthReq());
  782. return;
  783. }
  784. string file;
  785. string newCurdir;
  786. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,argsText,this.m_vPaths,out file, out newCurdir)||!System.IO.File.Exists(file))
  787. {
  788. SendData(Messages.AccesDenied());
  789. return;
  790. }
  792. try 
  793. {
  794. new FileInfo(file).Delete();
  795. SendData(Messages.DeleOk());
  796. }
  797. catch
  798. {
  799. SendData(Messages.AccesDenied());
  800. }
  801. }
  804. /// <summary>
  805. /// Suppression d'un r閜ertoire
  806. /// </summary>
  807. /// <param name="argsText"></param>
  808. private void RMD(string argsText)
  809. {
  810. if(!m_Authenticated)
  811. {
  812. SendData(Messages.AuthReq());
  813. return;
  814. }
  815. string file;
  816. string newCurdir;
  817. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,argsText,this.m_vPaths,out file, out newCurdir)||!System.IO.Directory.Exists(file))
  818. {
  819. SendData(Messages.AccesDenied());
  820. return;
  821. }
  823. try 
  824. {
  825. new DirectoryInfo(file).Delete();
  826. SendData(Messages.DeleOk());
  827. }
  828. catch
  829. {
  830. SendData(Messages.AccesDenied());
  831. }
  832. }
  833. /// <summary>
  834. /// Cette m閠hode permet au client d'envoyer un fichier
  835. /// </summary>
  836. /// <param name="argsText">Nom du fichier envoy?/param>
  837. private void STOR(string argsText)
  838. {
  839. if(!m_Authenticated)
  840. {
  841. SendData(Messages.AuthReq());
  842. return;
  843. }
  844. string file;
  845. string newCurdir;
  846. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,argsText,this.m_vPaths,out file, out newCurdir))
  847. {
  848. SendData(Messages.AccesDenied());
  849. return;
  850. }
  852. FileStream fs;
  853. try
  854. {
  855. fs=new FileStream(file,FileMode.OpenOrCreate,FileAccess.Write);
  856. fs.Position=this.m_offset;
  857. fs.SetLength(this.m_offset);
  858. }
  859. catch
  860. {
  861. SendData(Messages.AccesDenied());
  862. return;
  863. }
  864. Socket socket=this.GetDataConnection();
  865. try
  866. {
  867. if(socket==null||fs==null)
  868. {
  869. throw new Exception();
  870. }
  871. int readed = 1;
  872. byte[] buffer=new byte[4096];
  873. while(readed>0)
  874. {
  875. readed=socket.Receive(buffer);
  876. fs.Write(buffer,0,readed);
  877. }
  878. socket.Shutdown(SocketShutdown.Both);
  879. socket.Close();
  880. SendData(Messages.TrComplete());
  881. }
  882. catch
  883. {
  884. SendData(Messages.TrFailed());
  885. socket.Close();
  886. }
  887. fs.Close();
  889. }
  892. /// <summary>
  893. /// Cette m閠hode permet au client de t閘閏harger un fichier
  894. /// </summary>
  895. /// <param name="argsText">Fichier ?t閘閏harger (relatif au r閜ertoire courant)</param>
  896. private void RETR(string argsText)
  897. {
  898. if(!m_Authenticated)
  899. {
  900. SendData(Messages.AuthReq());
  901. return;
  902. }
  903. string file;
  904. string newCurdir;
  905. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,argsText,this.m_vPaths,out file,out newCurdir)||!System.IO.File.Exists(file))
  906. {
  907. SendData(Messages.AccesDenied());
  908. return;
  909. }
  910. FileStream fs;
  911. try
  912. {
  913. Socket socket=this.GetDataConnection();
  914. fs=new FileStream(file,FileMode.Open,FileAccess.Read);
  915. fs.Position=this.m_offset;
  916. if(socket==null || fs==null)
  917. {
  918. throw new Exception();
  919. }
  920. int readed = 1;
  921. byte[] buffer=new byte[4096];
  922. while(readed > 0)
  923. {
  924. readed=fs.Read(buffer,0,buffer.Length);
  925. socket.Send(buffer,readed,SocketFlags.None);
  926. }
  927. socket.Shutdown(SocketShutdown.Both);
  928. socket.Close();
  929. SendData(Messages.TrComplete());
  930. }
  931. catch
  932. {
  933. SendData(Messages.TrFailed());
  934. return;
  935. }
  936. fs.Close();
  938. }
  939. /// <summary>
  940. /// Cette m閠hode envoie un message comme quoi la connection va 阾re ferm閑 
  941. /// (elle correspond ?la commande client "QUIT")
  942. /// </summary>
  943. private void QUIT()
  944. {
  945. SendData(Messages.SignOff());
  946. }
  949. /// <summary>
  950. /// Cette m閠hode permet ?l'utilisateur de rentrer son login
  951. /// </summary>
  952. /// <param name="argsText">login</param>
  953. private void USER(string argsText)
  954. {
  955. if(m_Authenticated)
  956. {
  957. SendData(Messages.AlreadyAuth());
  958. return;
  959. }
  960. if(m_UserName.Length > 0)
  961. {
  962. SendData(Messages.UserButNotPass());
  963. return;
  964. }
  966. string userName = argsText;
  968. SendData(Messages.PassReq(argsText));
  969. m_UserName = userName;
  970. }
  972. /// <summary>
  973. /// Cette m閠hode permet ?l'utilisateur de saisir son mot de passe
  974. /// </summary>
  975. /// <param name="argsText">Mot de passe</param>
  976. private void PASS(string argsText)
  977. {
  978. if(m_Authenticated)
  979. {
  980. SendData(Messages.AlreadyAuth());
  981. return;
  982. }
  983. if(m_UserName.Length == 0)
  984. {
  985. SendData(Messages.EnterUser());
  986. return;
  987. }
  989. try
  990. {
  991. if((this.m_ftproot=Helpers.GetFtpRoot(this.m_UserName))==string.Empty)
  992. {
  993. SendData("530 Bad Home");
  994. return;
  995. }
  996. }
  997. catch(Exception e)
  998. {
  999. SendData(e.Message);
  1000. }
  1001. this.m_vPaths=Helpers.VPaths(this.m_UserName);
  1003. // Authentification de l'utilisateur
  1004. if(WinAuth.Auth(m_UserName,argsText))
  1005. {
  1006. m_Authenticated = true;
  1010. SendData(Messages.PassOk());
  1011. }
  1012. else
  1013. {
  1014. SendData(Messages.AuthFailed());
  1015. m_UserName = ""; // R閕nitialisation du nom d'utilisateur
  1016. }
  1018. }
  1021. /// <summary>
  1022. /// Informe l'utilisateur sur le r閜ertoire courrant
  1023. /// </summary>
  1024. private void PWD()
  1025. {
  1027. if(!m_Authenticated)
  1028. {
  1029. SendData(Messages.AuthReq());
  1030. return;
  1031. }
  1033. SendData(Messages.Pwd(m_CurrentDir));
  1034. }
  1036. /// <summary>
  1037. /// Informe l'utilisateur sur le syst鑝e surlequel tourne le serveur
  1038. /// </summary>
  1039. private void SYST()
  1040. {
  1042. if(!m_Authenticated)
  1043. {
  1044. SendData(Messages.AuthReq());
  1045. return;
  1046. }
  1048. SendData("215 Windows_NTrn");
  1049. }
  1051. /// <summary>
  1052. /// D閒init le type de donn閑 transitant entre client et serveur
  1053. /// </summary>
  1054. /// <param name="argsText">type</param>
  1055. private void TYPE(string argsText)
  1056. {
  1058. if(!m_Authenticated)
  1059. {
  1060. SendData(Messages.AuthReq());
  1061. return;
  1062. }
  1063. if(argsText.Trim().ToUpper() == "A" || argsText.Trim().ToUpper() == "I")
  1064. {
  1065. SendData(Messages.TypeSet(argsText));
  1066. }
  1067. else
  1068. {
  1069. SendData(Messages.InvalidType(argsText));
  1070. }
  1071. }
  1074. /// <summary>
  1075. /// La m閠hode port permet de d閒inir l'adresse TCP/IP de la connection de donn閑 avec le client.
  1076. /// En mode PORT, c'est le client qui 閏oute la connection de donn閑, en mode PASV, c'est le serveur.
  1077. /// </summary>
  1078. /// <param name="argsText">suite de 6 octets (sous forme d閏imale) repr閟entant l'ip et le port. i1,i2,i3,i4,p1,p2  (avec p1 octet de poid fort et p2 octet de poid faible)</param>
  1079. private void PORT(string argsText)
  1080. {
  1081. if(!m_Authenticated)
  1082. {
  1083. SendData(Messages.AuthReq());
  1084. return;
  1085. }
  1087. //on s閜are d'abord les diff閞entes parties de l'adresse
  1088. string[] parts = argsText.Split(',');
  1090. //on v閞ifie la syntaxe
  1091. if(parts.Length != 6)
  1092. {
  1093. SendData(Messages.SyntaxError());
  1094. return;
  1095. }
  1097. //On d閒init l'adresse ip
  1098. string ip=parts[0]+"."+parts[1]+"."+parts[2]+"."+parts[3];
  1101. //le port est d閒init par un calcul au niveau bit : la premi鑢e partie est d閏al閑 de 8bits vers l gauche et addition閑 avec la deuxi鑝e partie.
  1102. int    port = (Convert.ToInt32(parts[4]) << 8) | Convert.ToInt32(parts[5]);
  1104. m_pDataConEndPoint = new IPEndPoint(System.Net.Dns.GetHostByAddress(ip).AddressList[0],port);
  1106. this.m_PassiveMode=false;
  1107. SendData(Messages.PortCmdSuccess());
  1108. }
  1111. /// <summary>
  1112. /// La m閠hode pasv permet de d閒inir l'adresse TCP/IP de la connection de donn閑 avec le client.
  1113. /// En mode PORT, c'est le client qui 閏oute la connection de donn閑, en mode PASV, c'est le serveur.
  1114. /// </summary>
  1115. private void PASV()
  1116. {
  1117. if(!m_Authenticated)
  1118. {
  1119. SendData(Messages.AuthReq());
  1120. return;
  1121. }
  1123. //On commence par chercher un port libre pour lancer l'閏oute
  1124. int port = 1025;
  1125. while(true)
  1126. {
  1127. try
  1128. {
  1129. m_pPassiveListener = new TcpListener(IPAddress.Any,port);
  1130. m_pPassiveListener.Start();
  1132. //Si on arrive jusqu'ici, c'est que le port est libre
  1133. break;
  1134. }
  1135. catch
  1136. {
  1137. port++;
  1138. }
  1141. }
  1143. //A partir du socket, on recr?une chaine de type i1,i2,i3,i4,p1,p2
  1144. string ip = m_pClientSocket.LocalEndPoint.ToString();
  1145. ip = ip.Substring(0,ip.IndexOf(":"));
  1146. ip=ip.Replace(".",",");
  1148. //la premi鑢e partie du port est cr殚e en d閜la鏰nt les 8 bits de poids fort vers la droite,
  1149. //la deuxi鑝e est cr閑 en ne prenant que les 8 bits de poids faible (2^8=256)
  1150. ip += "," + (port >> 8) + "," + (port & 255);
  1152. SendData(Messages.PasvCmdSuccess(ip));
  1154. m_PassiveMode = true;
  1156. }
  1158. /// <summary>
  1159. /// Retourne au client la liste du contenu du r閜ertoire courant (ou de celui donn?en argument) avec des d閠ails
  1160. /// </summary>
  1161. private void LIST(string args)
  1162. {
  1163. //l'utilisateur doit 阾re identifi?
  1164. if(!this.m_Authenticated)
  1165. {
  1166. SendData(Messages.AuthReq());
  1167. return;
  1168. }
  1169. try
  1170. {
  1172. string cdir;
  1173. string newCurdir;
  1174. //on formate le r閜ertoire voulu
  1176. //On v閞ifie la validit?du r閜ertoire et on r閏up鑢e le chemin physique que l'on teste ensuite
  1177. //la fct?IsValidDir ne v閞ifie aps la pr閟ence du r閜ertoire car elle est aussi utilis閑 pour cr閑r des fichiers ou des r閜ertoires.
  1178. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,args,this.m_vPaths,out cdir,out newCurdir)||!System.IO.Directory.Exists(cdir))
  1179. {
  1180. SendData(Messages.AccesDenied());
  1181. return;
  1182. }
  1184. //on r閏up鑢e ensuite tous les fichiers et r閜ertoires contenus ainsi que leur propri閠閟
  1185. //pour ensuite les envoyer par le sockets
  1186. ArrayList files=new ArrayList();
  1187. try
  1188. {
  1189. files.AddRange(System.IO.Directory.GetDirectories(cdir));
  1190. files.AddRange(Helpers.VPathsInDir(this.m_CurrentDir,this.m_vPaths));
  1191. files.AddRange(System.IO.Directory.GetFiles(cdir));
  1192. }
  1193. catch
  1194. {
  1195. SendData(Messages.AccesDenied());
  1196. return;
  1197. }
  1199. //On r閏up鑢e le socket de donn閑s
  1200. Socket socket=this.GetDataConnection();
  1201. string msg="";
  1202. foreach (string file in files)
  1203. {
  1205. if(System.IO.File.Exists(file))
  1206. {
  1207. /*msg+=System.IO.File.GetLastWriteTime(file).ToString("MM-dd-yy hh:mm")+" ";
  1208. msg+=new System.IO.FileInfo(file).Length.ToString()+" ";
  1209. msg+=System.IO.Path.GetFileName(file)+"rn";
  1210. */
  1211. msg+="-rwxrwxrwx    0    0    0    ";
  1212. msg+=new System.IO.FileInfo(file).Length.ToString()+" ";
  1213. msg+=MonthFromInt(System.IO.File.GetLastWriteTime(file).Month)+" "+System.IO.File.GetLastWriteTime(file).ToString("dd  hh:mm")+" ";
  1214. msg+=System.IO.Path.GetFileName(file)+"rn";
  1215. }
  1216. else if(System.IO.Directory.Exists(file))
  1217. {
  1218. /*
  1219. msg+=System.IO.Directory.GetLastWriteTime(file).ToString("MM-dd-yy hh:mm")+" ";
  1220. msg+=" <DIR> "+System.IO.Path.GetFileName(file)+"rn";
  1221. */
  1222. msg+="drwxrwxrwx    0    0    0    ";
  1223. msg+=" 4096 ";
  1224. msg+=MonthFromInt(System.IO.Directory.GetLastWriteTime(file).Month)+" "+System.IO.Directory.GetLastWriteTime(file).ToString("dd  hh:mm")+" ";
  1225. msg+=System.IO.Path.GetFileName(file)+"rn";
  1226. }
  1228. else
  1229. {
  1230. msg+="drwxrwxrwx    0    0    0    ";
  1231. msg+=" 4096 ";
  1232. msg+=MonthFromInt(System.DateTime.Now.Month)+" "+System.DateTime.Now.ToString("dd  hh:mm")+" ";
  1233. msg+=file+"rn";
  1234. }
  1236. }
  1237. byte[] toSend=System.Text.Encoding.Default.GetBytes(msg);
  1239. socket.Send(toSend);
  1240. socket.Shutdown(SocketShutdown.Both);
  1241. socket.Close();
  1242. SendData(Messages.TrComplete());
  1243. }
  1244. catch
  1245. {
  1246. SendData(Messages.TrFailed());
  1247. }
  1249. }
  1251. private string MonthFromInt(int month)
  1252. {
  1253. switch(month)
  1254. {
  1255. case 1 :
  1256. return "jan";
  1257. break;
  1258. case 2 :
  1259. return "feb";
  1260. break;
  1261. case 3 :
  1262. return "mar";
  1263. break;
  1264. case 4 :
  1265. return "apr";
  1266. break;
  1267. case 5 :
  1268. return "may";
  1269. break;
  1270. case 6 :
  1271. return "jun";
  1272. break;
  1273. case 7 :
  1274. return "jul";
  1275. break;
  1276. case 8 :
  1277. return "aug";
  1278. break;
  1279. case 9 :
  1280. return "sep";
  1281. break;
  1282. case 10 :
  1283. return "oct";
  1284. break;
  1285. case 11 :
  1286. return "nov";
  1287. break;
  1288. case 12 :
  1289. return "dec";
  1290. break;
  1291. default :
  1292. return "";
  1296. }
  1297. }
  1300. /// <summary>
  1301. /// Retourne au client la liste du contenu du r閜ertoire courant (ou de celui donn?en argument) sans d閠ails
  1302. /// </summary>
  1303. private void NLST(string args)
  1304. {
  1305. //l'utilisateur doit 阾re identifi?
  1306. if(!this.m_Authenticated)
  1307. {
  1308. SendData(Messages.AuthReq());
  1309. return;
  1310. }
  1313. try
  1314. {
  1317. string cdir;
  1318. string newCurdir;
  1319. //on formate le r閜ertoire voulu
  1321. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,args,this.m_vPaths,out cdir, out newCurdir)||!System.IO.Directory.Exists(cdir))
  1322. {
  1323. SendData(Messages.AccesDenied());
  1324. return;
  1325. }
  1326. ArrayList files=new ArrayList();
  1327. try
  1328. {
  1329. files.AddRange(System.IO.Directory.GetDirectories(cdir));
  1330. files.AddRange(Helpers.VPathsInDir(this.m_CurrentDir,this.m_vPaths));
  1331. files.AddRange(System.IO.Directory.GetFiles(cdir));
  1332. }
  1333. catch
  1334. {
  1335. SendData(Messages.AccesDenied());
  1336. return;
  1337. }
  1338. //On r閏up鑢e le socket de donn閑s
  1340. Socket socket=this.GetDataConnection();
  1341. string msg="";
  1342. foreach (string file in files)
  1343. {
  1344. if(System.IO.File.Exists(file))
  1345. {
  1346. msg+=System.IO.Path.GetFileName(file)+"rn";
  1347. }
  1348. else if(System.IO.Directory.Exists(file))
  1349. {
  1351. msg+=System.IO.Path.GetFileName(file)+"rn";
  1352. }
  1354. else
  1355. {
  1356. msg+=file+"rn";
  1357. }
  1358. }
  1360. byte[] toSend=System.Text.Encoding.Default.GetBytes(msg);
  1362. socket.Send(toSend);
  1364. socket.Shutdown(SocketShutdown.Both);
  1365. socket.Close();
  1367. SendData(Messages.TrComplete());
  1368. }
  1369. catch
  1370. {
  1371. SendData(Messages.TrFailed());
  1372. }
  1374. }
  1377. /// <summary>
  1378. /// Changement de r閜ertoire courrant
  1379. /// </summary>
  1380. /// <param name="args">R閜ertoire</param>
  1381. private void CWD(string args)
  1382. {
  1383. try
  1384. {
  1385. if(!this.m_Authenticated)
  1386. {
  1387. SendData(Messages.AuthReq());
  1388. return;
  1389. }
  1390. string cdir;
  1391. string newCurdir;
  1392. if(!Helpers.IsValidDir(this.m_ftproot,this.m_CurrentDir,args.Trim(),this.m_vPaths,out cdir, out newCurdir)||
  1393. !System.IO.Directory.Exists(cdir))
  1394. {
  1395. SendData(Messages.AccesDenied());
  1396. return;
  1397. }
  1400. this.m_CurrentDir=newCurdir;
  1401. SendData(Messages.CwdOk());
  1402. }
  1403. catch
  1404. {
  1405. SendData(Messages.AccesDenied());
  1406. }
  1407. }
  1409. /// <summary>
  1410. /// Fonction permettant d'obtenir le socket de donn閑
  1411. /// </summary>
  1412. /// <returns>Socket de donn閑s</returns>
  1413. private Socket GetDataConnection()
  1414. {
  1415. Socket socket = null;
  1416. try
  1417. {
  1418. //si on est en mode passif
  1419. if(m_PassiveMode)
  1420. {
  1421. long startTime = DateTime.Now.Ticks;
  1422. // On attend que le server est re鐄 une requ鑤e de connection
  1423. while(!m_pPassiveListener.Pending())
  1424. {
  1425. System.Threading.Thread.Sleep(50);
  1427. // Time out apr鑣 30 secondes
  1428. if((DateTime.Now.Ticks - startTime) / 10000 > 20000)
  1429. {
  1430. throw new Exception("Ftp server didn't respond !");
  1431. }
  1432. }
  1434. //On accepte le socket
  1435. socket = m_pPassiveListener.AcceptSocket();
  1437. SendData(Messages.DataOpen());
  1438. }
  1439. else //Si en mode actif
  1440. {
  1442. SendData(Messages.DataOpening());
  1444. socket = new Socket(AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
  1445. socket.Connect(m_pDataConEndPoint);
  1446. }
  1447. }
  1448. catch
  1449. {
  1450. SendData("425 Can't open data connection.rn");
  1451. return null;
  1452. }
  1454. m_PassiveMode = false;
  1456. return socket;
  1457. }
  1458. }
  1459. }