// Session Event ==================================================================================
protected virtual void SessParse(object sender, SockSess sess)
{
// init request & response
SockRequest request = new SockRequest(sess.lep, sess.rep, sess.RfifoTake());
SockResponse response = new SockResponse();
// rfifo skip
sess.RfifoSkip(request.length);
// dispatch
dispatcher.Handle(request, ref response);
if (response.data != null && response.data.Length != 0)
sessctl.SendSession(sess, response.data);
}
protected virtual void SessDelete(object sender, SockSess sess)
{
}
// Parse Methods ======================================================================
private void sessmgr_sess_parse(object sender, SockSess sess)
{
byte[] data = sess.rdata.Take(sess.rdata_size).ToArray();
sess.rdata_size = 0;
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
if (txtBoxMsg.Text.Length >= 20 * 1024)
txtBoxMsg.Clear();
StringBuilder sb = new StringBuilder();
foreach (var item in data) {
if (item >= 0x20 && item < 0x7f) {
sb.Append(Convert.ToChar(item));
continue;
}
string s = Convert.ToString(item, 16);
if (s.Length == 1)
s = "0" + s;
sb.Append("(" + s + ")");
}
sb.Replace(")(", "");
txtBoxMsg.AppendText(DateTime.Now + " (" +
sess.rep.ToString() + " => " + sess.lep.ToString() + ")\n");
txtBoxMsg.AppendText(sb.ToString() + "\n\n");
txtBoxMsg.ScrollToEnd();
}));
// 兼容老版本字符流
if (sess.rdata[0] == '|' && sess.rdata[1] == 'H' && sess.rdata[2] == 'T') {
rwlock.AcquireReaderLock(-1);
bool IsHandled = false;
string msgstr = Encoding.UTF8.GetString(data);
// 水库代码太恶心，没办法的办法
// 除水库以外，相对正常数据处理
foreach (var item in moduleTable) {
if (item.ID != "HT=" && msgstr.Contains(item.ID)) {
try {
item.Module.Invoke(SMsgProc.FULL_NAME, SMsgProc.HANDLE_MSG, new object[] { ep, msgstr });
}
catch (Exception) { }
IsHandled = true;
break;
}
}
// 正常代码没有处理，则必是水库数据
if (IsHandled == false) {
foreach (var item in moduleTable) {
if (item.ID == "HT=" && msgstr.Contains(item.ID)) {
try {
item.Module.Invoke(SMsgProc.FULL_NAME, SMsgProc.HANDLE_MSG, new object[] { ep, msgstr });
}
catch (Exception) { }
break;
}
}
}
rwlock.ReleaseReaderLock();
return;
}
//// 根据data[1]找到对应模块，处理数据
//rwlock.AcquireReaderLock(-1);
//foreach (var item in moduleTable) {
// if (item.Sock == sess.sock) {
// try {
// item.Module.Invoke(SMsgProc.FullName, SMsgProc.HandleMsgByte, new object[] { data });
// }
// catch (Exception) { }
// break;
// }
//}
//rwlock.ReleaseReaderLock();
}
protected virtual void SessCreate(object sender, SockSess sess)
{
}
// Class Static ========================================================================
public static SockSess Accept(SockSess sess)
{
try {
Socket sock = sess.sock.Accept();
sock.SendTimeout = 1000;
return new SockSess(SockType.accept, sock);
} catch (Exception) {
return null;
}
}
protected override void SessDelete(object sender, SockSess sess)
{
/// ** update DataUI
if (sess.type == SockType.accept)
DataUI.ClientDel(sess.rep);
}
private void cnt_send_term(SockSess sess)
{
SockPack.CntSendTerm send_term = (SockPack.CntSendTerm)SockConvert.BytesToStruct(sess.rdata, typeof(SockPack.CntSendTerm));
sess.rdata[0] = (byte)SockPack.PackName.term_handle;
sess.rdata[1] = (byte)SockPack.PackName.term_handle >> 8;
foreach (var item in term_table) {
if ((item.sdata as TermUnit).CCID.Equals(new string(send_term.ccid))) {
item.sock.Send(sess.rdata, sess.rdata_size, System.Net.Sockets.SocketFlags.None);
break;
}
}
}
private void DeleteSession(SockSess sess)
{
if (sess_delete != null)
sess_delete(this, sess);
log4net.ILog log = log4net.LogManager.GetLogger(typeof(SessCtl));
if (sess.type == SockType.listen)
log.Info(String.Format("Session #* deleted from {0}.", sess.lep.ToString()));
//Console.Write("[Info]: Session #* deleted from {0}.\n", sess.lep.ToString());
else {
log.Info(String.Format("Session #* deleted from {0}.", sess.rep.ToString()));
//Console.Write("[Info]: Session #* deleted from {0}.\n", sess.rep.ToString());
sess.sock.Shutdown(SocketShutdown.Both);
}
sess.sock.Close();
sess_table.Remove(sess);
}
private void cnt_reg_svc(SockSess sess)
{
SockPack.CntRegSvc reg_svc = (SockPack.CntRegSvc)SockConvert.BytesToStruct(sess.rdata, typeof(SockPack.CntRegSvc));
reg_svc.hdr.name++;
SvcUnit svc = new SvcUnit(reg_svc.term_info);
// 如果已有相同类型模块注册，则注册失败，关闭连接
foreach (var item in svc_table) {
if ((item.sdata as SvcUnit).TermInfo.Equals(svc.TermInfo)) {
sess.sock.Send(StructPack(reg_svc,
Encoding.UTF8.GetBytes("Register svc failed: Similar svc already registered!")));
sess.eof = true;
return;
}
}
sess.sock.Send(StructPack(reg_svc, Encoding.UTF8.GetBytes("Register svc success!")));
// 更新模块表，必须放在验证之后
sess.sdata = svc;
// 更新终端表模块信息
foreach (var item in term_table) {
if ((item.sdata as TermUnit).Info.Equals(svc.TermInfo))
(item.sdata as TermUnit).Svc = sess;
}
}
private void cnt_reg_term(SockSess sess)
{
SockPack.CntRegTerm reg_term = (SockPack.CntRegTerm)SockConvert.BytesToStruct(sess.rdata, typeof(SockPack.CntRegTerm));
reg_term.hdr.name++;
TermUnit term = new TermUnit(reg_term.ccid, reg_term.info);
// 如果已有相同类型终端注册，则注册失败，关闭连接
foreach (var item in term_table) {
if ((item.sdata as TermUnit).CCID.Equals(term.CCID)) {
sess.sock.Send(StructPack(reg_term,
Encoding.UTF8.GetBytes("Register term failed: Similar term already registered!")));
sess.eof = true;
return;
}
}
// 发送注册成功信息
sess.sock.Send(StructPack(reg_term, Encoding.UTF8.GetBytes("Register term success!")));
// 更新终端表，必须放在验证之后
sess.sdata = term;
// 获取对应的svc
foreach (var item in svc_table) {
if ((item.sdata as SvcUnit).TermInfo.Equals(new string(reg_term.info))) {
term.Svc = item;
break;
}
}
}
private void cnt_login_user(SockSess sess)
{
SockPack.CntLoginUser login_user = (SockPack.CntLoginUser)SockConvert.BytesToStruct(sess.rdata, typeof(SockPack.CntLoginUser));
login_user.hdr.name++;
UserUnit user = new UserUnit(login_user.userid, login_user.passwd);
// verify login
sess.sdata = user;
}
private void cnt_irq(SockSess sess)
{
if (sess.sdata == null || sess.sdata as TermUnit == null || (sess.sdata as TermUnit).Svc == null)
return;
sess.rdata[0] = (byte)SockPack.PackName.svc_handle;
sess.rdata[1] = (byte)SockPack.PackName.svc_handle >> 8;
(sess.sdata as TermUnit).Svc.sock.Send(sess.rdata, sess.rdata_size, System.Net.Sockets.SocketFlags.None);
}
private void cnt_info_user(SockSess sess)
{
SockPack.CntInfoUser info_user = (SockPack.CntInfoUser)SockConvert.BytesToStruct(sess.rdata, typeof(SockPack.CntInfoUser));
info_user.hdr.name++;
try {
byte[] buffer = new byte[4096];
MemoryStream memoryStream = new MemoryStream(buffer);
XmlSerializer xmlFormat = new XmlSerializer(typeof(List<UserUnit>));
List<UserUnit> list = new List<UserUnit>();
if (new string('0', info_user.userid.Length).Equals(new string(info_user.userid))) {
foreach (var item in term_table)
list.Add(item.sdata as UserUnit);
}
else {
foreach (var item in term_table) {
if ((item.sdata as TermUnit).CCID.Equals(new string(info_user.userid))) {
list.Add(item.sdata as UserUnit);
break;
}
}
}
xmlFormat.Serialize(memoryStream, list);
sess.sock.Send(StructPack(info_user, buffer.Take((int)memoryStream.Position).ToArray()));
memoryStream.Close();
}
catch (Exception ex) {
Console.Write(ex.ToString());
}
}
public void SendSession(SockSess sess, byte[] data)
{
ThreadCheck(false);
if (sess.type == SockType.listen) {
foreach (var child in FindAcceptSession(sess))
child.WfifoSet(data);
} else
sess.WfifoSet(data);
//if (sess.type == SockType.listen) {
// foreach (var child in FindAcceptSession(sess)) {
// try {
// child.sock.Send(data);
// } catch (Exception ex) {
// log4net.ILog log = log4net.LogManager.GetLogger(typeof(SessCtl));
// log.Warn(String.Format("Send data to {0} failed.", child.rep.ToString()), ex);
// child.eof = true;
// }
// }
//} else {
// try {
// sess.sock.Send(data);
// } catch (Exception ex) {
// log4net.ILog log = log4net.LogManager.GetLogger(typeof(SessCtl));
// log.Warn(String.Format("Send data to {0} failed.", sess.rep.ToString()), ex);
// sess.eof = true;
// }
//}
}
// Parse Methods ======================================================================
void sessmgr_sess_delete(object sender, SockSess sess)
{
// 更新终端表模块信息
if ((sess.sdata as SvcUnit) != null) {
foreach (var item in term_table) {
if ((item.sdata as TermUnit).Info.Equals((sess.sdata as SvcUnit).TermInfo))
(item.sdata as TermUnit).Svc = null;
}
}
}
// Self Methods ========================================================================
private void AddSession(SockSess sess)
{
sess_table.Add(sess);
if (sess_create != null)
sess_create(this, sess);
log4net.ILog log = log4net.LogManager.GetLogger(typeof(SessCtl));
if (sess.type == SockType.listen)
log.Info(String.Format("Session #L listened at {0}.", sess.lep.ToString()));
//Console.Write("[Info]: Session #A accepted to {0}.\n", sess.lep.ToString());
else if (sess.type == SockType.accept)
log.Info(String.Format("Session #A accepted to {0}.", sess.lep.ToString()));
//Console.Write("[Info]: Session #A accepted to {0}.\n", sess.rep.ToString());
else// if (sess.type == SockType.connect)
log.Info(String.Format("Session #C connected to {0}.", sess.lep.ToString()));
//Console.Write("[Info]: Session #C connected to {0}.\n", sess.rep.ToString());
}
private void sessmgr_sess_parse(object sender, SockSess sess)
{
// 兼容老版本字符流
if (sess.rdata[0] == '|' && sess.rdata[1] == 'H' && sess.rdata[2] == 'T') {
IDictionary<string, string> dc = AnalyzeString(Encoding.UTF8.GetString(sess.rdata));
string term_info;
if (dc["HT"][0] == 'Z')
term_info = "MMMMNNNNNNNNCZLS";
else if (dc["HT"][0] == 'Q')
term_info = "MMMMNNNNNNNNCCQX";
else if (dc["HT"][0] == 'D')
term_info = "MMMMNNNNNNNNCDXS";
else
term_info = "MMMMNNNNNNNNCCSK";
foreach (var item in svc_table) {
if ((item.sdata as SvcUnit).TermInfo.Equals(term_info)) {
item.sock.Send(sess.rdata, sess.rdata_size, System.Net.Sockets.SocketFlags.None);
break;
}
}
sess.rdata_size = 0;
return;
}
// 验证数据流有效性
SockPack.PackHeader hdr = (SockPack.PackHeader)SockConvert.BytesToStruct(sess.rdata, typeof(SockPack.PackHeader));
if (hdr.len != sess.rdata_size) {
Console.Write("[Error]: Unknow packet from {0}.\n", sess.rep.ToString());
sess.rdata_size = 0;
return;
}
// 根据SockPack.PackName，调用合适的处理方法
switch (hdr.name) {
case SockPack.PackName.alive:
break;
case SockPack.PackName.cnt_irq:
cnt_irq(sess);
break;
case SockPack.PackName.cnt_reg_term:
cnt_reg_term(sess);
break;
case SockPack.PackName.cnt_send_term:
cnt_send_term(sess);
break;
case SockPack.PackName.cnt_info_term:
cnt_info_term(sess);
break;
case SockPack.PackName.cnt_reg_svc:
cnt_reg_svc(sess);
break;
case SockPack.PackName.cnt_login_user:
cnt_login_user(sess);
break;
case SockPack.PackName.cnt_info_user:
cnt_info_user(sess);
break;
default:
break;
}
// 数据流处理完成
sess.rdata_size = 0;
}
private SockSess[] FindAcceptSession(SockSess sess)
{
List<SockSess> retval = new List<SockSess>();
if (sess.type == SockType.listen) {
var subset = from s in sess_table
where s.type == SockType.accept && sess.lep.Port == s.lep.Port
select s;
foreach (var item in subset)
retval.Add(item);
}
return retval.ToArray();
}
private void sessmgr_sess_delete(object sender, SockSess sess)
{
Application.Current.Dispatcher.BeginInvoke(new Action(() =>
{
foreach (var item in moduleTable) {
if (item.Sess == sess) {
item.State = SockState.Closed;
break;
}
}
}));
}
public void DelSession(SockSess sess)
{
ThreadCheck(false);
sess.eof = true;
}
// Session Event ==========================================================================
protected override void SessCreate(object sender, SockSess sess)
{
if (sess.type == SockType.accept) {
sess.sdata = new SessData() {
Ccid = "",
Name = "",
TimeConn = DateTime.Now,
IsAdmin = false,
};
/// ** update DataUI
DataUI.ClientAdd(sess.lep, sess.rep);
}
}
