csock_info.cs

自定义协议

using System;
using System.IO;
using System.Text;
using System.Collections;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using System.Security.Cryptography;


namespace CodeManagerService
{
	/// <summary>
	/// CService 的摘要说明。
	/// </summary>
	public class CSock_Info
	{
		private DateTime m_dActive;
		private bool m_Enable;
		private Thread threadproc;
		private static Thread threadactive;
		private TcpClient m_sock;
		private static bool bSwitch;
		private String m_sAccount_Home;
		private String m_sPath;
		private static TcpListener cmsg_server_info;
		private static ArrayList cmsg_array_info = null;

		public CSock_Info()
		{
			//
			// TODO: 在此处添加构造函数逻辑
			//
			m_sock = null;
			m_Enable = true;
			m_sPath = "";
		}

		/// <summary>
		/// 错误日志
		/// </summary>
		/// <param name="szMsg">记录信息</param>
		private static void logs(string szMsg)
		{
			DateTime dt=DateTime.Now;
			String szFile=string.Format("c:/log/cmsg_log{0}.log", DateTime.Now.ToLongDateString());
			lock(typeof(CSock_Info))
			{
				using (StreamWriter sw = new StreamWriter(szFile, true)) 
				{
					sw.WriteLine(string.Format("[{0}]:{1}",DateTime.Now, szMsg));
				}
			}
		}

		/// <summary>
		/// 管理线程启动
		/// </summary>
		public static void start()
		{
			// init var
			cmsg_array_info = new ArrayList();

			// init params
			bSwitch = true;
			Int32 port = 8900;
			IPAddress localAddr = IPAddress.Parse("127.0.0.1");
    
			// TcpListener server = new TcpListener(port);
			cmsg_server_info = new TcpListener(port);

			// Start listening for client requests.
			cmsg_server_info.Start();
			logs("cmsg server info listeing...");
			
			//线路检测
			threadactive = new Thread( new ThreadStart( Active_Test ) ); 
			threadactive.IsBackground = true;
			threadactive.Start();
			//*/

			// Enter the listening loop.
			while(bSwitch) 
			{
				TcpClient client = cmsg_server_info.AcceptTcpClient(); 
				CSock_Info cc_sock = new CSock_Info();
				cc_sock.m_sock = client;
				cc_sock.threadproc = new Thread( new ThreadStart( cc_sock.DoProc ) );
				cc_sock.threadproc.IsBackground = true;
				cc_sock.threadproc.Start();
				logs("one cc socket connected.");
				cmsg_array_info.Add(cc_sock);
			}
		}

		/// <summary>
		/// 管理线程结束
		/// </summary>
		public static void stop()
		{
			bSwitch = false;
			cmsg_server_info.Stop();
			logs("cmsg server stop!");

		}

		private void close()
		{
			try
			{
				m_Enable = false;
				m_sock.Close();
				threadproc.Abort();
			}
			finally
			{System.GC.Collect();}
		}


		/// <summary>
		/// 线路检测线程
		/// </summary>
		public static void Active_Test() 
		{
			while(true)
			{
				Thread.Sleep(3000);
				try
				{
					if (cmsg_array_info.Count <= 0 )
						continue;

					// Get a stream object for reading and writing
					for(int i = 0 ; i< cmsg_array_info.Count; i ++)
					{

						//NetworkStream stream =((CSock_Info)cmsg_array_info[i]). m_sock.GetStream();
						CSock_Info cc = (CSock_Info)cmsg_array_info[i];
						if (!bSwitch)
						{
							cc.close();
							cc = null;
							cmsg_array_info.RemoveAt(i);
						}


						//logs("test active!");
						TimeSpan diff1 = DateTime.Now.Subtract(cc.m_dActive);

						//活动测试
						if (!cc.m_Enable ||  diff1.Seconds>30)
						{
							logs("socket 关闭");
							cc.close();
							cc = null;
							cmsg_array_info.RemoveAt(i);
							break;
						}

					}
				}
				catch(SocketException e)
				{
					logs("[Active_Test]cmsg cc socket error!"+ e.Message);
				}
			}
		}



		/// <summary>
		/// 工作线程
		/// </summary>
		public void DoProc() 
		{
			try
			{
				Int32 i;
				//byte []buf = new byte[12];
				byte []tmp = null;

				//init param
				int nTotal;
				int nCmd;
				int nSeq;
				MemoryStream ms = null;
				NetworkStream stream = null;

				while(m_Enable)
				{
					Thread.Sleep(50);
					// Get a stream object for reading and writing
					try
					{
						stream = m_sock.GetStream();
					}
					catch(InvalidOperationException ioep)
					{
						m_Enable = false;
						logs(String.Format("(DoProc_sockstream)Source:{0},TargetSite{1},Message{2}", ioep.Source, ioep.TargetSite, ioep.Message));
						ioep=null;break;
					}
					catch(Exception ep)
					{
						logs(String.Format("(DoProc_sockstream)Source:{0},TargetSite{1},Message{2}", ep.Source, ep.TargetSite, ep.Message));
						ep=null;continue;
					}

					if (null == stream)
						continue;

					if (!stream.DataAvailable)
						continue;

					tmp = new byte[1024];

					if ((i = stream.Read(tmp, 0, tmp.Length)) > 4)
					{
						m_dActive = DateTime.Now;
						if (null == ms)
							ms = new MemoryStream(2048);
						else
							ms.Position = ms.Length;
						ms.Write(tmp, 0, i);
					}
					stream.Flush();

					if (ms.Length > 12)
					{
						tmp = new byte[12];
						ms.Position = 0;
						if ((i = ms.Read(tmp, 0, 12)) == 12)
						{
							nTotal = BitConverter.ToInt32(defcmd.b2b(tmp, 0, 4), 0);
							nCmd = BitConverter.ToInt32(defcmd.b2b(tmp, 4, 4), 0);
							nSeq = BitConverter.ToInt32(defcmd.b2b(tmp, 8, 4), 0);
							if (ms.Length >= (nTotal - 12))
								tmp = new byte[nTotal - 12];
							if ((i = ms.Read(tmp, 0, nTotal - 12))> 0)
							{
								ParseCC_Cmd(nCmd, tmp);
								ms.Close();
								ms = null;
							
							}
						}
					}

				}
				// Shutdown and end connection
				m_sock.Close();
			}
			catch(SocketException e)
			{
				logs("cmsg cc socket error!"+ e.Message);
			}
			catch(Exception ep)
			{
				logs(String.Format("(DoProc)Source:{0},TargetSite{1},Message{2}", ep.Source, ep.TargetSite, ep.Message));
				ep = null;
				
			}


		}

		/// <summary>
		/// 解释包体
		/// </summary>
		/// <param name="cmd">CC命令</param>
		/// <param name="Packet">包体</param>
		private void ParseCC_Cmd(int cmd, byte[] Packet)
		{
			int nIndex;
			int nLen;
			NetworkStream stream = m_sock.GetStream();
			byte [] bResult = null;
			try
			{
				switch(cmd)
				{
					case defcmd.CONNECT:		//CC登录请求
						/*
						String szPack = "";
						for (int i = 0 ; i < Packet.Length; i ++)
							szPack = String.Format("{0}[{1}]", szPack, Packet[i]);

						logs(szPack);
						//*/

						nIndex = SearchChar(Packet);
						if (nIndex < 0)
						{
							bResult = ResultPacket(defcmd.CONNECT, 3);
							stream.Write(bResult, 0, bResult.Length);
							logs("格式错误!");
							return;
						
						}
						logs(String.Format("nIndex:{0}", nIndex));
						String szAccount = Encoding.GetEncoding(936).GetString(Packet, 0, nIndex);
						logs(szAccount);
						nLen = SearchChar(Packet, nIndex + 1);

						byte bVer = Packet[Packet.Length -11];
						logs(String.Format("version:{0}", bVer));

						//验证版本号
						if (bVer > defcmd.Version)
						{
							bResult = ResultPacket(defcmd.CONNECT, 2);
							stream.Write(bResult, 0, bResult.Length);
							break;
						}
						String szTimestamp = Encoding.Default.GetString(Packet, Packet.Length -10, 10);
						logs(szTimestamp);
						logs(String.Format("nindex[{0}],len[{1}]", nIndex +1, Packet.Length - 13 - nIndex));
						//验证帐号
						if (CheckUser(szAccount, defcmd.b2b(Packet, nIndex +1, Packet.Length - 13 - nIndex), szTimestamp))
						{
							m_Enable = true;
							m_sAccount_Home = szAccount;
							bResult = ResultPacket(defcmd.CONNECT, 0);
							stream.Write(bResult, 0, bResult.Length);
							stream.Flush();
							logs("get connect ");
						}
						else
						{
							m_Enable = false;
							bResult = ResultPacket(defcmd.CONNECT, 1);
							stream.Write(bResult, 0, bResult.Length);
							logs("get voild connect");
						}
						break;
					case defcmd.ACTIION_TEST:		//测试网络连路
						logs("测试网路连路!");
						if (!m_Enable)
						{
							if (null == (bResult = ResultPacket(defcmd.NOTCONNECT, defcmd.ACTIION_TEST)))
								bResult = ResultPacket(defcmd.UNKNOWERROR, defcmd.FLALL);
							stream.Write(bResult, 0, bResult.Length);
						}
						else
						{
							if (null == (bResult = ResultPacket(defcmd.ACTIION_TEST, defcmd.OK)))
								bResult = ResultPacket(defcmd.UNKNOWERROR, defcmd.ACTIION_TEST);
							stream.Write(bResult, 0, bResult.Length);
						}
						stream.Flush();

						break;
					case defcmd.FLALL:		//显示文件目录信息
						logs("显示文件列表信息!");
						if (!m_Enable)
						{
							if (null == (bResult = ResultPacket(defcmd.NOTCONNECT, defcmd.FLALL)))
								bResult = ResultPacket(defcmd.UNKNOWERROR, defcmd.FLALL);
							stream.Write(bResult, 0, bResult.Length);
						}
						else
						{
							if (null == (bResult = ResultPacket(defcmd.FLALL, defcmd.OK)))
								bResult = ResultPacket(defcmd.UNKNOWERROR, defcmd.FLALL);
							stream.Write(bResult, 0, bResult.Length);
						}
						stream.Flush();
						break;
					case defcmd.MKD:	//创建文件侠操作
						logs("cc请求创建文件夹");
						if (!m_Enable)
						{
							bResult = ResultPacket(defcmd.NOTCONNECT, defcmd.MKD);
							stream.Write(bResult, 0, bResult.Length);
						}
						else
						{
							//创建目录信息不足
							if (Packet.Length <= 8)
							{
								bResult = ResultPacket(defcmd.MKD, defcmd.MKDERROR);
								stream.Write(bResult, 0, bResult.Length);
								break;
							}
							String szNewFloder = Encoding.GetEncoding(936).GetString(Packet, 8, Packet.Length - 9);

							if (Directory.Exists(String.Format("{0}/{1}{2}/{3}",defcmd.CMS_HOME,m_sAccount_Home,m_sPath,szNewFloder)))
							{
								bResult = ResultPacket(defcmd.MKD, defcmd.MKDEXISTS);
								stream.Write(bResult, 0, bResult.Length);
								break;
							}
							Directory.CreateDirectory(String.Format("{0}/{1}{2}/{3}",defcmd.CMS_HOME,m_sAccount_Home,m_sPath,szNewFloder));

							bResult = ResultPacket(defcmd.MKD, defcmd.OK);
							stream.Write(bResult, 0, bResult.Length);
						}
						stream.Flush();
						break;

					case defcmd.RMD:
						logs("cc请求删除文件夹");
						if (!m_Enable)
						{
							bResult = ResultPacket(defcmd.NOTCONNECT, defcmd.RMD);
							stream.Write(bResult, 0, bResult.Length);
						}
						else
						{
							//创建目录信息不足
							if (Packet.Length <= 8)
							{
								bResult = ResultPacket(defcmd.RMD, defcmd.RMDERROR);
								stream.Write(bResult, 0, bResult.Length);
								break;
							}
							String szFloder = Encoding.GetEncoding(936).GetString(Packet, 8, Packet.Length - 9);
							if (!Directory.Exists(String.Format("{0}/{1}{2}/{3}",defcmd.CMS_HOME,m_sAccount_Home,m_sPath,szFloder)))
							{
								bResult = ResultPacket(defcmd.RMD, defcmd.CWDNOTEXISTS);
								stream.Write(bResult, 0, bResult.Length);
								break;
							}
							DirectoryInfo di = new DirectoryInfo(String.Format("{0}/{1}{2}/{3}",defcmd.CMS_HOME,m_sAccount_Home,m_sPath,szFloder));

							di.Delete(true);
							di = null;

							bResult = ResultPacket(defcmd.RMD, defcmd.OK);
							stream.Write(bResult, 0, bResult.Length);
						}
						stream.Flush();
						break;

					case defcmd.RND:
						logs("cc请求修改文件夹名字");

						if (!m_Enable)
						{
							bResult = ResultPacket(defcmd.NOTCONNECT, defcmd.RND);
							stream.Write(bResult, 0, bResult.Length);
						}
						else
						{
							//创建目录信息不足
							if (Packet.Length <= 8)
							{
								bResult = ResultPacket(defcmd.RND, defcmd.RNDERROR);
								stream.Write(bResult, 0, bResult.Length);
								break;
							}
							nIndex = SearchChar(Packet, 8);
							String szFloder = Encoding.GetEncoding(936).GetString(Packet, 8, nIndex - 8);