public void OnConnected(IAsyncResult iar)
{
StateObj state = (StateObj)iar.AsyncState;
if (state != null)
{
state.OnConnect(state);
}
}
private void HandlePost(StateObj State, string S, string location)
{
string URL = ProcessUrl(location).Replace(" ", String.Empty);
Dictionary <string, string> PostParams = new Dictionary <string, string>();
string Location = S.Substring(5, S.IndexOf(' ', S.IndexOf(' ') + 1) - 4);
Console.WriteLine("Post");
string Str = S.Substring(5);
Console.WriteLine("Trimmed!");
string[] Lines = Str.Split('\n');
int i;
for (i = 0; i < Lines.Length; i++)
{
if (string.IsNullOrWhiteSpace(Lines[i]))
//if (lines[i].Length == 0) //or maybe this suits better..
//if (lines[i].Equals(string.Empty)) //or this
{
//Console.WriteLine(i);
break;
}
//Console.WriteLine(i);
}
if (i != Lines.Length - 1)
{
//Next Line should be the one with post data
Console.WriteLine(Lines[i + 1]);
Console.WriteLine("-----------");
string[] PostParameters = Lines[i + 1].Replace("+", " ").Split('&');
foreach (string PostParameter in PostParameters)
{
string[] KeyAndValue = PostParameter.Split('=');
PostParams.Add(KeyAndValue[0], KeyAndValue[1]);
}
foreach (KeyValuePair <string, string> kvp in PostParams)
{
Console.WriteLine("Key = {0}, Value = {1}", kvp.Key, kvp.Value);
}
//Console.WriteLine(generateJSON(PostParams));
Console.WriteLine("URL:" + URL + " " + Virtdirs.ContainsKey(URL));
if (Virtdirs.ContainsKey(URL))
{
//returnText(State, CallVirtDir(ProcessUrl(cr.RawUrl), Hreq), "text/html");
PrevReq Hreq = new PrevReq(URL, State.Client.RemoteEndPoint.ToString(), State.S.ToString(), "POST", PostParams);
string text = CallVirtDir(URL, Hreq);
SendText(State, GenerateHeader("HTTP/1.1 200 OK", "text/html", Encoding.ASCII.GetByteCount(text)) + text);
}
}
}
void HandleMsg(StateObj state)
{
UITools.log("receive msg compelete and decode msg ---> recever : ");
MsgUnPacker unpacker = MsgUtils.DeserializerMsg(state.RecvBuff.ToByteArray());
unpacker.MsgType = state.MsgType;
unpacker.Receiver = state.Receiver;
unpacker.RecvHandler = state.RecvHandler;
handerMgr.HandleMsg(unpacker);
}
private void ReadClient(IAsyncResult ar)
{
try
{
//We Shoulden't get binary data so use strings!!
string Request = string.Empty;
StateObj State = (StateObj)ar.AsyncState;
Socket Client = State.Client;
int Br = Client.EndReceive(ar);
if (Br > 0)
{
State.S.Append(Encoding.ASCII.GetString(State.Buffer, 0, Br));
Request = Encoding.ASCII.GetString(State.Buffer);
bool Done = false;
string[] Lines = Request.Split('\n');
for (int i = 0; i < Lines.Length; i++)
{
Lines[i] = new string(Lines[i].Where(c => char.IsLetter(c) || char.IsDigit(c)).ToArray());
// Line is empty
if (Lines[i] == null || Lines[i] == "")
{
Done = true;
//Console.WriteLine("done");
}
}
if (Done)
{
//Done
//Console.WriteLine(Request);
//Console.WriteLine("------------------------------------");
Console.WriteLine(State.S.ToString());
HandleClient(State);
}
else
{ //Not done
//Console.WriteLine(Request);
Client.BeginReceive(State.Buffer, 0, State.BL, 0,
new AsyncCallback(ReadClient), State);
}
}
}
catch (Exception E)
{
ErrorArg ErA;
ErA.Location = "MAS2.ReadClient(IAsyncResult ar)";
ErA.Severity = 2; //Lower Severity more important
ErA.TimeAndDate = DateTime.Now.ToString("MMMM,dd,yyyy h:mm:ss tt", CultureInfo.InvariantCulture);
ErA.Error = E.ToString();
HandleError(ErA, "RC");
}
}
public void CloseConnection(StateObj state)
{
try
{
tcpClient.Client.BeginDisconnect(true, new AsyncCallback(OnDisConnect), state);
}
catch (Exception)
{
UITools.logError("Close Connection error");
}
}
static void AnotherTask(object obj)
{
StateObj stObj = obj as StateObj;
int n = stObj.n;
for (int i = 1; i < n; i++)
{
Console.Write("@");
}
Console.WriteLine(n);
stObj.RetVal = n;
}
public void Send(MsgPacker msg)
{
StateObj _state = new StateObj();
_state.MsgType = msg.MsgType;
_state.Receiver = msg.Receiver;
_state.IsNeedRecv = msg.IsNeedRecv;
_state.OnSend = OnSend;
_state.OnReceive = OnReceiveData;
_state.SendBuff = MsgUtils.SerializerMsg(msg);
clientSocket.Send(_state);
}
public bool OpenPhase()
{
if (_server.Connected)
{
_NS = _server.GetStream();
StateObj state = new StateObj(_server.Client);
_server.Client.BeginReceive(state.buffer, 0, StateObj.BufferSize, SocketFlags.None, new AsyncCallback(OnReceive), state);
_status = "Playing";
return true;
}
else
return false;
}
static void Main()
{
StateObj StObj1 = new StateObj();
StateObj StObj2 = new StateObj();
StObj1.n = 10;
StObj2.n = 20;
// ╫╚хннЯее╤с
ThreadPool.QueueUserWorkItem(
new WaitCallback(SomeOtherTask), StObj1);
ThreadPool.QueueUserWorkItem(
new WaitCallback(AnotherTask), StObj2);
Thread.Sleep(1000);
}
private void AcceptClient(IAsyncResult ar)
{
//Main thread can continue
ThreadSignal.Set();
Socket Server = (Socket)ar.AsyncState; //Cast to type socket
Socket Client = Server.EndAccept(ar);
StateObj state = new StateObj();
Console.WriteLine("Client: " + Client.RemoteEndPoint);
state.Client = Client;
Client.BeginReceive(state.Buffer, 0, state.BL, 0,
new AsyncCallback(ReadClient), state);
}
public void ConnectServer(string ip, int port, StateObj state)
{
if (!isInit)
{
UITools.logError("Init ClientSocket first");
return;
}
state.Client = tcpClient.Client;
try
{
tcpClient.BeginConnect(ip, port, new AsyncCallback(OnConnected), state);
}
catch (Exception)
{
state.OnConnectError(state);
}
}
private void HandleClient(StateObj State)
{
try
{
//Console.WriteLine("0");
string S = State.S.ToString();
//Console.WriteLine("Current Buffer:");
//Console.WriteLine(S);
//Console.WriteLine("END");
if (S.Substring(0, 3) == "GET")
{
string Location = S.Substring(4, S.IndexOf(' ', S.IndexOf(' ') + 1) - 4);
Console.WriteLine(Location);
Console.WriteLine("------------------------------------");
HandleFileReq(State, Location);
string e = GenError(404);
SendText(State, e);
}
if (S.Substring(0, 4) == "POST")
{
string Location = S.Substring(4, S.IndexOf(' ', S.IndexOf(' ') + 1) - 4);
Console.WriteLine(Location);
Console.WriteLine("------------------------------------");
HandlePost(State, S, Location);
}
else
{
Console.WriteLine("------------------------------------");
Console.Write("ERROR: 501");
string e = GenError(501);
SendText(State, e);
}
}
catch (Exception E)
{
ErrorArg ErA;
ErA.Location = "MAS2.HandleClient(StateObj State)";
ErA.Severity = 3; //Lower Severity more important
ErA.TimeAndDate = DateTime.Now.ToString("MMMM,dd,yyyy h:mm:ss tt", CultureInfo.InvariantCulture);
ErA.Error = E.ToString();
HandleError(ErA, "HC");
}
}
public void Send(StateObj state)
{
byte[] buff = state.SendBuff;
UITools.log("send Buff size : " + buff.Length);
if (state == null)
{
state = new StateObj();
}
// state.Msg = msg;
state.Client = tcpClient.Client;
try
{
tcpClient.Client.BeginSend(buff, 0, buff.Length, 0, new AsyncCallback(OnSendCallBack), state);
}
catch (Exception e)
{
UITools.log("send data timeout...." + e.Message);
}
}
private bool validateForm(StateObj obj, out string errorMsg)
{
var sb = new StringBuilder();
var errCount = 0;
var exist = repoState.AllEager(f => f.STATECODE == obj.STATECODE && f.COUNTRYCODE == f.COUNTRYCODE).FirstOrDefault();
if (exist != null)
{
sb.AppendLine("State Code Already Exist for the selected Country");
errCount++;
}
if (errCount > 0)
{
errorMsg = sb.ToString();
return(true);
}
errorMsg = sb.ToString();
return(false);
}
private void OnSendCallBack(IAsyncResult iar)
{
StateObj state = (StateObj)iar.AsyncState;
state.OnSend(state);
if (state.IsNeedRecv)
{
try
{
state.Client.BeginReceive(state.RecvTempBuff, 0, state.RecvTempBuff.Length, 0, new AsyncCallback(OnReceive), state);
}
catch (Exception)
{
state.OnRecvError(state);
}
}
else
{
state.OnReceive(state);
}
}
private void SendTextFile(StateObj State, String Locs)
{
try
{
Console.WriteLine("Text transfer was used");
Console.WriteLine("------------------------------------");
string text = File.ReadAllText(Locs);
string Answer;
Answer = GenerateHeader("HTTP/1.1 200 OK", GetType(Path.GetExtension(Locs)), Encoding.ASCII.GetByteCount(text)) + text;
SendText(State, Answer);
}
catch (Exception E)
{
ErrorArg ErA;
ErA.Location = "MAS2.SendTextFile(StateObj State, String Locs)";
ErA.Severity = 3; //Lower Severity more important
ErA.TimeAndDate = DateTime.Now.ToString("MMMM,dd,yyyy h:mm:ss tt", CultureInfo.InvariantCulture);
ErA.Error = E.ToString();
HandleError(ErA, "STF");
}
}
public void TimeoutFunctionality()
{
var stateObj = new StateObj();
ThreadPool.RegisterWaitForSingleObject(stateObj.Handle, (state, isTimedOut) =>
{
if (!isTimedOut) return;
Trace.WriteLine("timeout");
var rh = (StateObj)state;
rh.Handle.Set();
rh.Aborted = true;
}, stateObj, 1000, true);
bool aborted = stateObj.Handle.WaitOne();
}
/// <summary>
/// method with strings to see in the label
/// </summary>
/// <param name="sender"></param>
private void DisplayUI(object sender)
{
StateObj st = (StateObj)sender;
lblCronometro.Invoke((MethodInvoker) delegate
{ //the interface says that it's ready to riceve the object
// Running on the UI thread
lblCronometro.Text = st.Data;
sStatus.Text = st.Alert + " " + st.Message;
if (st.isAlarm)
{
if (MessageBox.Show("Vuoi continuare? \nyes/ reset app, no/close app", "Finito", MessageBoxButtons.YesNo, MessageBoxIcon.Question) == DialogResult.No)
{
Application.Exit(); //exit the application
}
else
{
clearobject(); //method to clear every slot in the program
}
}
});
}
private string GetDir(StateObj State, String Locs)
{
try
{
StringBuilder builder = new StringBuilder();
builder.Append("<html>");
builder.Append("<head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\"></head>");
builder.Append("<body><ul>");
var dirs = Directory.GetDirectories(Locs);
foreach (var d in dirs)
{
var link = d.Replace(RootPath, "").Replace('\\', '/');
builder.Append("<li><DIR> <a href=\"" + link + "\">" + Path.GetFileName(d) + "</a></li>");
}
var files = Directory.GetFiles(Locs);
foreach (var f in files)
{
var link = f.Replace(RootPath, "").Replace('\\', '/');
builder.Append("<li><a href=\"" + link + "\">" + Path.GetFileName(f) + "</a></li>");
}
builder.Append("</ul></body></html>");
return(builder.ToString());
}
catch (Exception E)
{
ErrorArg ErA;
ErA.Location = "MAS2.GetDir(StateObj State, String Locs)";
ErA.Severity = 3; //Lower Severity more important
ErA.TimeAndDate = DateTime.Now.ToString("MMMM,dd,yyyy h:mm:ss tt", CultureInfo.InvariantCulture);
ErA.Error = E.ToString();
HandleError(ErA, "GD");
return("MAS2 - ERROR");
}
}
private void SendText(StateObj State, string M)
{
Socket Client = State.Client;
Byte[] SendBuffer = Encoding.ASCII.GetBytes(M);
try
{
Client.Send(SendBuffer);
Client.Shutdown(SocketShutdown.Both);
Client.Close(); //Disposes for us
//Client.Dispose();
}
catch (Exception E)
{
ErrorArg ErA;
ErA.Location = "MAS2.SendText(StateObj State, string M)";
ErA.Severity = 2; //Lower Severity more important
ErA.TimeAndDate = DateTime.Now.ToString("MMMM,dd,yyyy h:mm:ss tt", CultureInfo.InvariantCulture);
ErA.Error = E.ToString();
HandleError(ErA, "ST");
}
}
private void OnReceive(IAsyncResult iar)
{
StateObj state = (StateObj)iar.AsyncState;
//读取的消息总长度
int len = state.Client.EndReceive(iar);
if (len < 4)
{
UITools.logError("invaild msg");
state.OnRecvError(state);
return;
}
byte[] buff = state.RecvTempBuff;
int msgRealLen = MsgUtils.DecodeMsgRealLen(buff, 0, 4);
UITools.log("msg real length : " + msgRealLen);
state.RecvLen = msgRealLen;
// state.RecvBuff.addRange<byte>(buff, AppConst.MsgHeadLen, len - 4);
state.RecvBuff.Write(buff, AppConst.MsgHeadLen, len - AppConst.MsgHeadLen);
if (state.RecvLen - state.RecvBuff.Length > 0)
{
try
{
state.Client.BeginReceive(state.RecvTempBuff, 0, state.RecvTempBuff.Length, 0, new AsyncCallback(OnReceiveRestData), state);
}
catch (Exception)
{
state.OnRecvError(state);
UITools.log("receive data timeout....");
}
}
else
{
state.OnReceive(state);
}
}
/// <summary>
/// Es wurden Daten gelesen
/// </summary>
/// <param name="ar"></param>
private void ReadCallback(IAsyncResult ar)
{
try
{
int read;
lock (_SerialPortLock) {
if (_port.IsOpen)
{
read = _port.BaseStream.EndRead(ar);
StateObj state = (StateObj)ar.AsyncState;
OnDataReceived?.Invoke(state.data, read);
}
}
StartRead();
}
//Die Verbindung wurde beendet
catch (IOException) {
OnConnectionClosed?.Invoke(this);
//_port.Close();
}
catch (Exception)
{ }
}
void OnSend(StateObj state)
{
UITools.log("send msg compelete and waitFor receive");
}
void OnDisConnect(StateObj state)
{
isConnect = false;
}
public void OnConnect(StateObj state)
{
UITools.log("Connect ro Server and start send msg");
isConnect = true;
}
public ActorWithStashSpec()
{
_state = new StateObj(this);
}
public RespawnEvent(StateObj checkpoint, float maxHealth)
: base("OnRespawn")
{
this.checkpoint = checkpoint;
this.maxHealth = maxHealth;
}
// Properties
// Métodos
/** Creates a new instance of ClasseBase */
public ClasseBase()
{
state = StateObj.stLimpo;
}
public void deletar()
{
state = StateObj.stExcluir;
}
public void editar()
{
state = StateObj.stEditar;
}
public void novo()
{
state = StateObj.stNovo;
}
// Properties
// Métodos
/** Creates a new instance of ClasseBase */
public ClasseBase()
{
state = StateObj.stLimpo;
}
void OnReceiveData(StateObj state)
{
UITools.log("add msg to eventQueue");
eventQueue.Add(state);
}
public void novo()
{
state = StateObj.stNovo;
}
public void editar()
{
state = StateObj.stEditar;
}
public void StartAsyncReceives(byte[] buffer, int size)
{
StateObj state = new StateObj(buffer, size);
sock.BeginReceive(buffer, 0, size, SocketFlags.None, new AsyncCallback(ReceiveCallback), state);
}
public void deletar()
{
state = StateObj.stExcluir;
}
public RespawnEvent(StateObj checkpoint, float maxHealth) : base("OnRespawn")
{
this.checkpoint = checkpoint;
this.maxHealth = maxHealth;
}
/// <summary>
/// bắt đầu nhận thông tin từ server
/// </summary>
/// <returns></returns>
public bool OpenPhase()
{
if (_server.Connected)
{
//_NS = _server.GetStream();
//_NS.Write(_ENCODE.GetBytes("echo ..."), 0, 512);
StateObj state = new StateObj(_server.Client);
_server.Client.BeginReceive(state.buffer, 0, StateObj.BufferSize, SocketFlags.None, new AsyncCallback(OnReceive), state);
return true;
}
else
return false;
}
public ActorWithStashSpec()
{
_state = new StateObj(this);
}
private void StartRead()
{
StateObj state = new StateObj ();
state.data = new byte[BUFFER_SIZE];
lock (_port)
_port.BaseStream.BeginRead (state.data, 0, BUFFER_SIZE, new AsyncCallback (ReadCallback), state);
}
