public int Receive(byte[] data, int offset, int count) { try { int received = this.Sock.Receive(data, offset, count, SocketFlags.None); if (received <= 0) { #if DEBUG Console.WriteLine(string.Format("DCing: recvd={0},Err={1}", received, Sock.GetSocketOption(SocketOptionLevel.Socket, SocketOptionName.Error))); #endif this.Disconnect(); return -1; } DataEventArgs dargs = new DataEventArgs(data, received); //this.onDataReceived(this, dargs); return received; } catch (SocketException ex) { Console.WriteLine(">>>> Error In Receive! DCing! <<<<"); this.Disconnect(); return -1; } }
public override void OnDataReceived(object sender, DataEventArgs e) { if (e.Buffer.FindString("HTTP/1.") != -1 && e.Buffer.FindString("\r\n") != -1) { e.Buffer = e.Buffer.ReplaceString("\r\n", "\r\nX-Served-By: Socks5Server\r\n"); e.Count = e.Count + "X-Served-By: Socks5Server\r\n".Length; } }
void Client_onDataSent(object sender, DataEventArgs e) { this.Stats.AddBytes(e.Count, ByteType.Sent); this.Stats.AddPacket(PacketType.Sent); }
void Client_onDataReceived(object sender, DataEventArgs e) { this.Stats.AddBytes(e.Count, ByteType.Received); this.Stats.AddPacket(PacketType.Received); }
/// <summary> /// Allows you to grab/modify data before it's sent to the end server. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public abstract void OnDataSent(object sender, DataEventArgs e);
/// <summary> /// Allows you to grab data before it's sent to the end user. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> public abstract void OnDataReceived(object sender, DataEventArgs e);
void RemoteClient_onDataReceived(object sender, DataEventArgs e) { e.Request = this.ModifiedReq; try { foreach (DataHandler f in Plugins) if (f.Enabled) f.OnDataReceived(this, e); //craft headers & shit. byte[] outputdata = se.ProcessOutputData(e.Buffer, e.Offset, e.Count); //send outputdata's length firs.t Client.Client.Send(BitConverter.GetBytes(outputdata.Length)); e.Buffer = outputdata; e.Offset = 0; e.Count = outputdata.Length; //ok now send data. Client.Client.Send(e.Buffer, e.Offset, e.Count); // if (!RemoteClient.Receiving) // RemoteClient.ReceiveAsyncNew(); // if (!Client.Client.Receiving) // Client.Client.ReceiveAsyncNew(); } catch { Client.Client.Disconnect(); RemoteClient.Disconnect(); OnTunnelDisposing(); } }
void Client_onDataReceived(object sender, DataEventArgs e) { e.Request = this.ModifiedReq; //this should be packet header. try { int torecv = BitConverter.ToInt32(e.Buffer, e.Offset); byte[] newbuff = new byte[torecv]; int recv = Client.Client.Receive(newbuff, 0, newbuff.Length); if (recv == torecv) { //yey //process packet. byte[] output = se.ProcessInputData(newbuff, 0, recv); e.Buffer = output; e.Offset = 0; e.Count = output.Length; //receive full packet. foreach (DataHandler f in Plugins) if (f.Enabled) f.OnDataSent(this, e); RemoteClient.SendAsync(e.Buffer, e.Offset, e.Count); // if (!Client.Client.Receiving) // Client.Client.ReceiveAsyncNew(); // if (!RemoteClient.Receiving) // RemoteClient.ReceiveAsyncNew(); } else { throw new Exception(); } } catch { //disconnect. Client.Client.Disconnect(); RemoteClient.Disconnect(); OnTunnelDisposing(); } }
void RemoteClient_onDataReceived(object sender, DataEventArgs e) { e.Request = this.ModifiedReq; foreach (DataHandler f in Plugins) if (f.Enabled) f.OnDataReceived(this, e); Client.Client.Send(e.Buffer, e.Offset, e.Count); // if (!RemoteClient.Receiving) // RemoteClient.ReceiveAsyncNew(); // if (!Client.Client.Receiving) // Client.Client.ReceiveAsyncNew(); }
public async Task ReceiveAsyncNew() { Receiving = true; // Reusable SocketAsyncEventArgs and awaitable wrapper var args = new SocketAsyncEventArgs(); var buffer = BufferManager.DefaultManager.CheckOut(); args.SetBuffer(buffer, 0, buffer.Length); var awaitable = new SocketAwaitable(args); // Do processing, continually receiving from the socket while (Sock!=null) { try { if (!Sock.Connected) { break; } await Sock.ReceiveAsync(awaitable); int bytesRead = args.BytesTransferred; if (bytesRead <= 0) break; DataEventArgs data = new DataEventArgs(buffer, bytesRead); this.onDataReceived(this, data); } catch (SocketException ex) { break; } //catch (NullReferenceException ex) //{ // break; //} } Receiving = false; BufferManager.DefaultManager.CheckIn(buffer); Disconnect(); }
public bool Send(byte[] buff, int offset, int count) { try { if (this.Sock != null) { if (this.Sock.Send(buff, offset, count, SocketFlags.None) <= 0) { Console.WriteLine("Send Dcing"); this.Disconnect(); return false; } DataEventArgs data = new DataEventArgs(buff, count); this.onDataSent(this, data); return true; } return false; } catch { Console.WriteLine(">>>> Error In Send! DCing! <<<<"); this.Disconnect(); return false; } }
private void DataSent(IAsyncResult res) { try { int sent = ((Socket)res.AsyncState).EndSend(res); if (sent < 0) { this.Sock.Shutdown(SocketShutdown.Send); Disconnect(); return; } #if DEBUG Console.WriteLine("Data Sent: " + sent / 1024.0 + "KB"); #endif DataEventArgs data = new DataEventArgs(new byte[0] { }, sent); this.onDataSent(this, data); } catch { this.Disconnect(); } }
public override void OnDataSent(object sender, DataEventArgs e) { }
void Client_onDataReceived(object sender, DataEventArgs e) { //this should be packet header. try { if (enc.GetAuthType() != AuthTypes.Login && enc.GetAuthType() != AuthTypes.None) { //get total number of bytes. int torecv = BitConverter.ToInt32(e.Buffer, e.Offset); byte[] newbuff = new byte[torecv]; int recv = Client.Receive(newbuff, 0, newbuff.Length); if (recv == torecv) { //yey //process packet. byte[] output = enc.ProcessInputData(newbuff, 0, recv); //receive full packet. e.Buffer = output; e.Offset = 0; e.Count = output.Length; this.OnDataReceived(this, new Socks5ClientDataArgs(this, e.Buffer, e.Count, e.Offset)); } else { throw new Exception(); } } else { this.OnDataReceived(this, new Socks5ClientDataArgs(this, e.Buffer, e.Count, e.Offset)); } } catch { //disconnect. Disconnect(); throw; } }