Packets packets packets...

[badguy4you]

I have been struggling to understand what is a Packet how could i create one with the data i want then send it to my server

So please any one tell if as example i want to send some info from my client to my server, then handle them from the server

how could i do that


[Note] : i have my socket server, also i don't wanna copy and paste codes i want to UNDERSTAND.

My PacketReader.cs

 Spoiler

using System;
using System.IO;
using System.Text;

namespace MethodTestingProject.Packets
{
    class PacketReader : BinaryReader
    {
        private readonly Operation _opcode;
        public Operation GetOpcode() { return _opcode; }

        public PacketReader(byte[] pBuffer, int nSize) :
            base(new MemoryStream(pBuffer, 0, nSize, false, true))
        {
            base.BaseStream.Position = 0;
            _opcode = (Operation)base.ReadUInt16();
            base.ReadByte();
        }

        public override string ReadString()
        {
            var len = ReadUInt16();
            if (len < 1)
                return String.Empty;

            byte[] buffer = ReadBytes(len);
            var pString = Encoding.GetEncoding(1252).GetString(buffer);
            return pString.Substring(0, pString.IndexOf('\0'));
        }

        public string ReadString(int len)
        {
            var buffer = new byte[len];
            var i = 0;

            base.Read(buffer, 0, len);
            for (; i < len; ++i)
                if (buffer[i] == 0)
                    break;
            var pString = Encoding.GetEncoding(1252).GetString(buffer, 0, i);
            return pString;
        }
    }
}

Handler.cs

 Spoiler

using MethodTestingProject.Core;
using MethodTestingProject.Network;

namespace MethodTestingProject.Packets
{
    class Handler
    {
        public static void PacketHandler(Client client, PacketReader packet)
        {
            try
            {
                switch (packet.GetOpcode())
                {
                    case Operation.Connected:
                        Log.Write("1");
                        break;
                    case Operation.Disconnected:
                        Log.Write("2");
                        break;  
                    default:
                        Log.Write("Opcode : {0}", packet.GetOpcode());
                        break;
                }
            }
            catch
            {
                Log.WriteError("Error Parsing : {0}", packet);
            }
        }
    }
}

Operations is an Enum : ushort

[I don't have a username]

Pointers #1

 Spoiler

Now let's look at pointers. This is one of the more advanced things and a lot of people have problem understanding these, but we'll take it one step at a time.

Basically a pointer is pointing to some data in your memory, it could be a variable. It's faster to use pointers than not using pointers, but doing so can screw everything up if not used correctly! That's why they're used in an unsafe environment.

To use a pointer we must allow unsafe coding which you can do under properties and build.



Okay now let's get going, start my declaring a variable.

int myInt = 500;

Now we'll have to declare an unsafe scope or we can make our class/method unsafe, it will do the trick as well. I'll just make my method unsafe (Main)

static unsafe void Main(string[] args)

Now let's create a pointer that points to myInts address in the memory.

int* myPointer = &myInt;

Now you may question what the * and & is. int* means that we're having an int pointer, but what about &? & is taking the address of myInt.

To actually get the address we can just convert int* explicit to an int.

    int address = (int)myPointer;
    Console.WriteLine(address);

To get the value from the pointer we'll have to put a * in front of our pointer and then convert it to an int.

    int value = (int)*myPointer;
    Console.WriteLine(value);

That was the first part of pointers which was basically an introduction.

Structs & Pointers #2

 Spoiler

Now it's time to look at structs. They're a bit different from classes. A struct does not require you to create a new instance of it, but you can do so if you want to.

Let's start out by creating a struct and create 3 variables.

    struct MyStruct
    {
  public int Int32;
  public byte Byte;
  public short Int16;
    }

Now what I want to get into is that every kind of datatype has a specific size (in bytes).
This chart will show how many bytes each data type is:


If we want to create a pointer to a struct we'll have to declare a variable as the size. So let's make a variable for that (It's important that the variable is at the top.) Oh and another thing is that the way our variables are stored in the struct is also the way they'll be when we're pointing to them in memory (It can be different some times, but most of them it's correct.) If you want to specify the offset you can use the FieldOfsset attribute.

    struct MyStruct
    {
  private int Size;
  public int Int32;
  public byte Byte;
  public short Int16;
    }

So what is the size? It's 11.
But why?
How many bytes is an int? 4.
How many bytes is a byte? 1.
How many bytes is a short? 2.
What is 4 + 1 + 2? That's 7.
So why is it 11? Well Size is a variable as well and it's an int which takes 4 bytes.
So 7 + 4? Well that's 11.

Now let's give our struct some values.

    MyStruct structure;
    structure.Int32 = 5141421;
    structure.Byte = 102;
    structure.Int16 = 20000;

Usually we want to convert our struct to a byte pointer, because we want the byte data.

byte* bytePointer = (byte*)&structure;

Now we have created a pointer to our struct.
Now how do we get the data within the struct?
It's now the sizes of our data comes in handy.

If you see the pointer as an array then the following index would be our data.

0,1,2,3 = Size
4,5,6,7 = Int
8 = Byte
9,10 = Short

Remember how you gathered the value from a pointer? Basically we have to do that now. We also have to specify the offset that our data is stored at.
Size is stored at 0, Int is stored at 4, Byte is stored at 8 and Short is stored at 9.
It's important that we're using the correct pointer type otherwise we might get some strange values.

Gets the Int:

int Int = (*(int*)(bytePointer + 4));

Gets the Byte:

byte Byte = (*(byte*)(bytePointer + 8));

Gets the Short:

short Short = (*(short*)(bytePointer + 9));

That was a bit about structs and the last part of pointers.

DataPackets & Packet Structures

 Spoiler

We have already looked a bit into this by using structs, but now we'll look more into it and also how to write/read data using pointers proper by making a datapacket class.

Why do I cover this? Well we'll use this class in the socket tutorial, so it's important you follow here. We won't use structs at any time in this, but the pointer information is still important!

Let's start out by making our datapacket class.
It has to have a variable for a byte array and a property to get it.

It has to be unsafe, because we're going to use pointers.

    public unsafe class DataPacket
    {
  private byte[] _buffer;
  public byte[] DataBuffer
  {
    get
    {
    return _buffer;
    }
  }
    }

Now we'll have to make two constructors. One constructor to pass a byte array to our datapacket and one constructor to give our datapacket a size and an id.

  public DataPacket(byte[] inBuffer)
  {
  }
  public DataPacket(int packetSize, int packetID)
  {
  }

In the constructor for passing a byte array we'll copy the data into a new byte array. We can do that using System.Buffer.BlockCopy, however we can go native as well and use PInvoke from msvcrt.dll with memcpy. Memcpy is far faster, but I felt lazy

  public DataPacket(byte[] inBuffer)
  {
	    _buffer = new byte[inBuffer.Length];
    System.Buffer.BlockCopy(inBuffer, 0, _buffer, 0, inBuffer.Length);
  }

We won't look into the other constructor just yet as we need to create our reading/writing.

First of all we'll need to create a pointer to our buffer. We'll make the pointer a property.

  private byte* dataPointer
  {
    get
    {
    }
  }

Now to create the pointer we'll have to use the fixed keyword.

'    get
    {
    fixed (byte* pointer = _buffer)
    return pointer;
    }

Reading and writing is basically the same with pointers.

I'll make the first write and read method for you then you can make for the rest datatypes. (Don't make for string just yet as I'll get into that after!)

The writing method has to take two parameters. The value and the offset.
Then remember from how we read data from the pointer (in the struct part.)
That's the same way we'll do to write, but instead of returning we'll just give it a value.

  public void WriteByte(byte value, int offset)
  {
    (*(byte*)(dataPointer + offset)) = value;
  }

The same goes for reading, except it should only take one parameter as the offset and then return the value.

  public byte ReadByte(int offset)
  {
    return (*(byte*)(dataPointer + offset));
  }

If you cannot figure out how to make them here is the all, but really... Try yourself.

public void WriteSByte(sbyte value, int offset)
  {
    (*(sbyte*)(dataPointer + offset)) = value;
  }
  public void WriteInt16(short value, int offset)
  {
    (*(short*)(dataPointer + offset)) = value;
  }
  public void WriteInt32(int value, int offset)
  {
    (*(int*)(dataPointer + offset)) = value;
  }
  public void WriteInt64(long value, int offset)
  {
    (*(long*)(dataPointer + offset)) = value;
  }
  public void WriteByte(byte value, int offset)
  {
    (*(byte*)(dataPointer + offset)) = value;
  }
  public void WriteUInt16(ushort value, int offset)
  {
    (*(ushort*)(dataPointer + offset)) = value;
  }
  public void WriteUInt32(uint value, int offset)
  {
    (*(uint*)(dataPointer + offset)) = value;
  }
  public void WriteUInt64(ulong value, int offset)
  {
    (*(ulong*)(dataPointer + offset)) = value;
  }
public sbyte ReadSByte(int offset)
  {
    return (*(sbyte*)(dataPointer + offset));
  }
  public short ReadInt16(int offset)
  {
    return (*(short*)(dataPointer + offset));
  }
  public int ReadInt32(int offset)
  {
    return (*(int*)(dataPointer + offset));
  }
  public long ReadInt64(int offset)
  {
    return (*(long*)(dataPointer + offset));
  }
  public byte ReadByte(int offset)
  {
    return (*(byte*)(dataPointer + offset));
  }
  public ushort ReadUInt16(int offset)
  {
    return (*(ushort*)(dataPointer + offset));
  }
  public uint ReadUInt32(int offset)
  {
    return (*(uint*)(dataPointer + offset));
  }
  public ulong ReadUInt64(int offset)
  {
    return (*(ulong*)(dataPointer + offset));
  }

Now let's look into writing and reading string data.
Remember back at data types that I explained strings are not a real data type? Well they're a collection of unicode characters (char) and a char equals a byte. However we'll have to convert the chars to bytes.
What we can do is loop through all the characters in the string and then conver them to a byte and write them into our buffer.

  public void WriteString(string value, int offset)
  {
    foreach (char _char in value)
    WriteByte((byte)_char, offset++);
  }

The reason we do offset++ it's because we don't want all the characters to be stored at the same offset.

Now there is another writing method for strings we want to implement which is writing the length of the string as well. The reason is that we cannot always know what the length of the string is so we want to have it as dynamicly as we can!

  public void WriteStringWithLength(string value, int offset)
  {
    WriteByte((byte)value.Length, offset);
    offset++;
    WriteString(value, offset);
  }

Basically what the code above does is writing the length of the string into the current offset and then it will add 1 to the offset and write the string values from there.

Now what about reading a string? That's basically the same. We'll have to convert the bytes to characters. A good idea is to use StringBuilder here for a better performance.

  public string ReadString(int offset, int length)
  {
    StringBuilder stringBuilder = new StringBuilder();

    for (int i = 0; i < length; i++)
    {
    byte _byte = ReadByte(offset + i);
    stringBuilder.Append((char)_byte);
    }

    return stringBuilder.ToString();
  }

The code above will read a string with a specific length. Now what about if we could make it dynamicly? Well that would only work if the string was written with the WithLength method, but we'll just have to gather the length from there then.

  public string ReadStringFromLength(int offset)
  {
    byte Length = ReadByte(offset);
    offset++;
    return ReadString(offset, Length);
  }

And that's it. Now we actually have a class that wraps around a datapacket. Now the time to get back to the other constructor comes.

All we have to do is write the size to the offset 0 and the id to the offset 4, because it's an int.

  public DataPacket(int packetSize, int packetID)
  {
    _buffer = new byte[packetSize];
    WriteInt32(packetSize, 0);
    WriteInt32(packetID, 4);
  }

Now what you can use this for is to wrap it around an actual class for a specific packet.

Example:

    public class AuthPacket : DataPacket
    {
  public AuthPacket(byte[] inBuffer)
    : base(inBuffer)
  {
  }

  public AuthPacket(string account, string password)
    : base(8 + account.Length + password.Length, 1000)
  {
    WriteStringWithLength(account, 8);
    WriteStringWithLength(password, account.Length + 8 + 1);
  }

  public string Account
  {
    get
    {
    return ReadStringFromLength(8);
    }
  }

  public string Password
  {
    get
    {
    return ReadStringFromLength(Account.Length + 8 + 1);
    }
  }
    }

Example Usage:

    // creating
    AuthPacket packet = new AuthPacket("test", "1234");
    byte[] buffer = packet.DataBuffer;

    // reading
    Console.WriteLine(packet.Account);
    Console.WriteLine(packet.Password);

I think that was it about datapackets and packet structures!

Sockets #1

 Spoiler

Okay time for a second socket tutorial! This one will be far better as I've learned new ways of doing sockets!

You can find my old tutorial here:


If you haven't read any of the tutorials and just skipped here then if anything is referred to old material then it's up to you to figure it out! I'd strongly suggest to read ALL the parts before jumping into sockets.

I will cover both server and client sockets.

First of all it's important that you understand what a socket is.
A socket is basically an endpoint that is bound to a specific ip and port. You can send/receive data through sockets.

The way we're going to design our sockets will be the following:


The reason I wrote linked is that they'll both be using the same wrapper, but we'll set it up to work for both and the reason is that there is no point in coding the same thing two times.

I will start out by explaining the server part.

A server is an application which is located either on a local machine or an extern machine. You connect to the server through a socket, the servers IP and Port would be the end point.

A server does not necessary has to be something that you connect to on an extern machine, an example could be sql server. If you're hosting the sql server and wants to use it ex. through your application then you'll most likely connect to it local. (It's possible to connect remote to a database server as well, but NEVER, I repeat NEVER do it through your client application, because it'll leave it open to security issues and I have seen a lot of people do that (Usually in the VB section, ironic LOL.)!!)

For this we'll need to use two namespaces:
System.Net and System.Net.Sockets.

Well start by making a class for our socket server.

    public class SocketServer
    {
    }

We'll have to add one variable to it as a Socket.

private Socket _socket;

Now we need a constructor in which we'll create our socket.

_socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);

Let me explain to you why I've chosen to use the following things.

The address family is InterNetwork because we want to connect to the internet, there is also options for Firefox and such, but I won't go into that stuff.

The socket type is Stream, because we want to stream data over the network. Raw is also used a lot, but we don't want that now.

Now for the protocol type. I've chosen Tcp for a simple reason. Tcp will never have its data lost and if it loses any data it will always report back with an error. If we were to choose Udp then we'd be risking a chance that we might lose data, because Udp is about speed. It's faster to use Udp, but they might lose data and it won't report back if any data was lost or anything. Tcp on the other side is about being effecient and that it actually works like it should. Usually Tcp is used for real servers, games and such where Udp is usually used for streaming (Ex. streaming movies) because they'll deliever the data faster, ut it might get lost on the way and such!)

Now we need to create 3 methods.
2 public methods called Start and Accept. The start method should take two parameters, one as a string (IP) and one as an int (Port). The accept method should take no parameters at all.

  public void Start(string IP, int Port)
  {
  }
  public void Accept()
  {
  }

Let's look at the Start method first. In the start method we'll bind the server and start to listen for connections.

To bind our socket to an end point we'll have to create an IPEndPoint from the IP and Port passed as parameters. IPAddress.Parse will parse a string to an IP (If the string is a valid IP lol.)

_socket.Bind(new IPEndPoint(IPAddress.Parse(IP), Port));

When we call the Listen method we'll have to pass an int as the parameter. That is the pending queue for our connections. I usually use 100, but you can use any value you want, I've seen some use 500 and such as well, but I'll just use 100.

_socket.Listen(100);

Now let's make a new class and call it SocketClient, because we're going to use that now (We'll not do anything in it yet!)

Now go back to the server.
We'll have to make a new method now which should be private and take one parameter as IAsyncResult. The method itself is a callback from an async callback.

  private void Accept_Callback(IAsyncResult asyncResult)
  {
  }

Now in the Accept method we'll call the BeginAccept method in our socket class and it takes 2 parameters. the async call back (A delegate) and an object (Our SocketClient). We'll create a new instance of the SocketClient here.

  public void Accept()
  {
    _socket.BeginAccept(new AsyncCallback(Accept_Callback), new SocketClient());
  }

Now we need to handle the call back. In the end of the call back call the Accept method again and every thing that we do from now on should be above that!

  private void Accept_Callback(IAsyncResult asyncResult)
  {
    // do things here

    Accept();
  }

Now we'll go into our SocketClient class.

First thing we'll do is making a few variables.

  private byte[] dataHolder;
  private Socket _socket;

The dataHolder is a byte array which should hold all the data that's received.

The _socket is the connection of the client.

Now we'll make a new method returning a bool called EndAccept which should take 2 parameters as a Socket (as server) and IAsyncResult. Basically this should call the Socket.EndAccept method.

  public bool EndAccept(Socket server, IAsyncResult asyncResult)
  {
  }

We should create a try/catch and on catch we'll return false and in try we'll return true.

    try
    {
    return true;
    }
    catch
    {
    return false;
    }

What we'll do now is making the socket in our class equal to the end accept method and pass the async result as parameter.

  public bool EndAccept(Socket server, IAsyncResult asyncResult)
  {
    try
    {
    _socket = server.EndAccept(asyncResult);
    return true;
    }
    catch
    {
    return false;
    }
  }

And that's basically it. What we'll do now is creating 3 delegates (Do it in a new file if you want or wherver you prefer, but not in any class!)

    public delegate void ConnecionEvent(SocketClient Client);
    public delegate void BufferEvent(SocketClient Client, byte[] Buffer);

In the server class we'll have to define the 2 delegates (Make them static!)
2 for connection (OnConnect and OnDisconnect) and 1 for receive (OnReceive)

  public static ConnecionEvent OnConnection, OnDisconnection;
  public static BufferEvent OnReceive;

Now let's return to the accept callback.

First of all we'll check if the connection was accepted and if it's accepted we'll invoke the OnConnection delegate.

However we'll need to invoke the SocketClient and to do that we'll need to get it and we can do that from our async result.

  private void Accept_Callback(IAsyncResult asyncResult)
  {
    SocketClient Client = asyncResult.AsyncState as SocketClient;
    if (Client.EndAccept(_socket, asyncResult))
    {
    OnConnection.Invoke(Client);
    }
    Accept();
  }

Now in the SocketClient class make a method called Receive and it should take no parameters. Call that method after the OnConnection has been invoked.

  private void Accept_Callback(IAsyncResult asyncResult)
  {
    SocketClient Client = asyncResult.AsyncState as SocketClient;
    if (Client.EndAccept(_socket, asyncResult))
    {
    OnConnection.Invoke(Client);
    Client.Receive();
    }
    Accept();
  }

Now our server socket is done. The only thing we need is to receive/send data which is in the SocketClient we'll handle that.

First of all make a private method called ReceiveData which should have one parameter as an int which is the size of the data we want to receive.

  private void ReceiveData(int size)
  {
  }

Now we need to make another call back, this time it's for receive.

  private void Receive_Callback(IAsyncResult asyncResult)
  {
  }

Okay now add two other variables to the class which should be for the data size received and the required data size.

private int requiredSize, currentSize;

And now another variable as a bool which should be indicating whether or not we're recieving the header and it should be true as a start.

private bool isHeader = true;

Now call ReceiveData from Receive with a size of 4, because we want that to get the size of the packet.

  public void Receive()
  {
    ReceiveData(4);
  }

Now in ReceiveData we have to call the BeginReceive method from our socket.

  private void ReceiveData(int size)
  {
    dataHolder = new byte[size];
    _socket.BeginReceive(dataHolder, 0, size, SocketFlags.None, new AsyncCallback(Receive_Callback), null);
  }

Now in the receive callback we have to put a try catch, 2 variables for size and socket-error, but we also have to make a check if it's in header or not.
We also have to check if the receive was a success.

 private void Receive_Callback(IAsyncResult asyncResult)
  {
    try
    {
    SocketError err;
    int receiveSize = _socket.EndReceive(asyncResult, out err);
    if (err != SocketError.Success)
    {
    return;
    }
    if (isHeader)
    {

    }
    else
    {

    }
    }
    catch
    {
    }
  }

Now implemented the data packet class that we used in the previous tutorial.

Before we continue we have to make a disconnect method.
Basically it should just call the Socket.Disconnect method with the parameter as false so the user can connect again! It should also check if the user is already disconnected, because we don't want to invoke the event two times.

  public void Disconnect()
  {
    if (alreadyDisconnected)
    return;
    alreadyDisconnected = true;

    _socket.Disconnect(false);
    SocketServer.OnDisconnection.Invoke(this);
  }

Okay back to the callback.

At this block:

    if (err != SocketError.Success)
    {
    return;
    }

It should disconnect.

Same goes here:

    catch
    {
    }

Result:

 private void Receive_Callback(IAsyncResult asyncResult)
  {
    try
    {
    SocketError err;
    int receiveSize = _socket.EndReceive(asyncResult, out err);
    if (err != SocketError.Success)
    {
		    Disconnect();
    return;
    }
    if (isHeader)
    {

    }
    else
    {

    }
    }
    catch
    {
		Disconnect();
    }
  }

Now we first have to handle the header which is a simple process.
We'll create a new datapacket as the header and it should have the dataholder as parameter. Then the required size should be the headers data (as int) - 4, because we do not want to receive the size again.
Then we'll call ReceiveData with the required size and at last we'll set isHeader to false.

    DataPacket header = new DataPacket(dataHolder);
    requiredSize = (header.ReadInt32(0) - 4);
    ReceiveData(requiredSize);
    isHeader = false;

Now to handle the body.
First of all the currentSize should have added the receivedSize to it.

 currentSize += receiveSize;

Then we'll check if the currentSize is equal to the receivedSize.

    if (currentSize == requiredSize)

And else we'll check if the currentSize is above the requiredSize and if it is then we'll disconnect, because that means we've received an invalid buffer.

    else if (currentSize > requiredSize)
    {
    Disconnect();
    }

This should be the callback as of now:

  private void Receive_Callback(IAsyncResult asyncResult)
  {
    try
    {
    SocketError err;
    int receiveSize = _socket.EndReceive(asyncResult, out err);
    if (err != SocketError.Success)
    {
    Disconnect();
    return;
    }
    if (isHeader)
    {
    DataPacket header = new DataPacket(dataHolder);
    requiredSize = (header.ReadInt32(0) - 4);
    ReceiveData(requiredSize);
    isHeader = false;
    }
    else
    {
    currentSize += receiveSize;
    if (currentSize == requiredSize)
    {

    }
    else if (currentSize > requiredSize)
    {
    Disconnect();
    }
    }
    }
    catch
    {
    Disconnect();
    }
  }

Now if the sizes match we'll reset the currentSize and tell it that it's not in the header anymore.

    currentSize = 0;
    isHeader = true;

Then we'll make a new byte array with the requiredSize and copy the data from dataholder into it.

    byte[] rBuffer = new byte[requiredSize];
    System.Buffer.BlockCopy(dataHolder, 0, rBuffer, 0, requiredSize);

At last we'll invoke the OnReceive event and then start to receive the next header.

SocketServer.OnReceive.Invoke(this, rBuffer);
ReceiveData(4);

Now the last thing to do for the socket client is to make a send method as we also want to send data. This should just take one parameter as a DataPacket and within the method we'll copy the buffer from the data packet into a new byte array.

  public void Send(DataPacket packet)
  {
    int size = packet.DataBuffer.Length;
    byte[] sendBuffer = new byte[size];
    System.Buffer.BlockCopy(packet.DataBuffer, 0, sendBuffer, 0, size);
  }

We'll also call the BeginSend method here, but before that we'll have to check if the client is connected and also lock the client in case of cross-threading problems!

    try
    {
    System.Threading.Monitor.Enter(this);

    if (_socket.Connected)
    {
    _socket.BeginSend(sendBuffer, 0, size, SocketFlags.None, new AsyncCallback(Send_Callback), null);
    }
    }
    finally
    {
    System.Threading.Monitor.Exit(this);
    }

We also need a callback, but I don't think I need to explain this callback...

  private void Send_Callback(IAsyncResult asyncResult)
  {
    try
    {
    int size = _socket.EndSend(asyncResult);
    if (size < 8) // if the size/id is not included in the packet
    Disconnect();
    }
    catch
    {
    Disconnect();
    }
  }

Sockets #2

 Spoiler

Now to the client. I won't really explain a lot about that, because there isn't much to explain. The only difference from that is that the SocketClient class should not be accepted by any server, but connect to one, so the SocketServer class is not needed here and neither is the EndAccept method. All we actually have to do after is implementing the events for disconnecting and receiving.

You should be able to do that by yourself, but if you struggle here is the complete client:

    public delegate void ConnecionEvent(SocketClient Client);
    public delegate void BufferEvent(SocketClient Client, byte[] Buffer);

    public class SocketClient
    {
  private byte[] dataHolder;
  private Socket _socket;

  public ConnecionEvent OnDisconnection;
  public BufferEvent OnReceive;

  public void Receive()
  {
    ReceiveData(4);
  }

  private void ReceiveData(int size)
  {
    dataHolder = new byte[size];
    _socket.BeginReceive(dataHolder, 0, size, SocketFlags.None, new AsyncCallback(Receive_Callback), null);
  }

  private int requiredSize, currentSize;
  private bool isHeader = true;

  private void Receive_Callback(IAsyncResult asyncResult)
  {
    try
    {
    SocketError err;
    int receiveSize = _socket.EndReceive(asyncResult, out err);
    if (err != SocketError.Success)
    {
    Disconnect();
    return;
    }
    if (isHeader)
    {
    DataPacket header = new DataPacket(dataHolder);
    requiredSize = (header.ReadInt32(0) - 4);
    ReceiveData(requiredSize);
    isHeader = false;
    }
    else
    {
    currentSize += receiveSize;
    if (currentSize == requiredSize)
    {
    currentSize = 0;
    isHeader = true;

    byte[] rBuffer = new byte[requiredSize];
    System.Buffer.BlockCopy(dataHolder, 0, rBuffer, 0, requiredSize);
    OnReceive.Invoke(this, rBuffer);
    ReceiveData(4);
    }
    else if (currentSize > requiredSize)
    {
    Disconnect();
    }
    }
    }
    catch
    {
    Disconnect();
    }
  }

  private bool alreadyDisconnected = false;

  public void Disconnect()
  {
    if (alreadyDisconnected)
    return;
    alreadyDisconnected = true;

    _socket.Disconnect(false);
    OnDisconnection.Invoke(this);
  }

  public void Send(DataPacket packet)
  {
    int size = packet.DataBuffer.Length;
    byte[] sendBuffer = new byte[size];
    System.Buffer.BlockCopy(packet.DataBuffer, 0, sendBuffer, 0, size);
    try
    {
    System.Threading.Monitor.Enter(this);

    if (_socket.Connected)
    {
    _socket.BeginSend(sendBuffer, 0, size, SocketFlags.None, new AsyncCallback(Send_Callback), null);
    }
    }
    finally
    {
    System.Threading.Monitor.Exit(this);
    }
  }
  private void Send_Callback(IAsyncResult asyncResult)
  {
    try
    {
    int size = _socket.EndSend(asyncResult);
    if (size < 8) // if the size/id is not included in the packet
    Disconnect();
    }
    catch
    {
    Disconnect();
    }
  }

  public void Connect(string IP, int Port)
  {
    _socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
    _socket.Connect(new IPEndPoint(IPAddress.Parse(IP), Port));
  }
    }

Now what about implementing these two?
Here is an example for the server:

namespace Server
{
    class Program
    {
  static void Main(string[] args)
  {
    SocketServer server = new SocketServer();
    SocketServer.OnConnection = new ConnecionEvent(OnConnection);
    SocketServer.OnDisconnection = new ConnecionEvent(OnDisconnection);
    SocketServer.OnReceive = new BufferEvent(OnReceive);
    server.Start("127.0.0.1", 8886);
    server.Accept();

    while (true)
    Console.ReadLine();
  }

  static void OnConnection(SocketClient Client)
  {
    Console.WriteLine("connected.");
  }
  static void OnDisconnection(SocketClient Client)
  {
    Console.WriteLine("disconnected.");
  }
  static void OnReceive(SocketClient Client, byte[] Packet)
  {
    Console.WriteLine("received data");
    DataPacket packet = new DataPacket(10 + 8, 100);
    packet.WriteString("0123456789", 8);
    Client.Send(packet);
  }
    }
}

Here is an example for the client:

namespace Client
{
    class Program
    {
  static void Main(string[] args)
  {
    SocketClient Client = new SocketClient();
    Console.ReadLine();
    Client.OnDisconnection = new ConnecionEvent(OnDisconnection);
    Client.OnReceive = new BufferEvent(OnReceive);
    Client.Connect("127.0.0.1", 8886);
    Client.Receive();
    while (true)
    {
    Console.ReadLine();
    DataPacket packet = new DataPacket(10 + 8, 100);
    packet.WriteString("0123456789", 8);
    Client.Send(packet);
    }
  }

  static void OnDisconnection(SocketClient Client)
  {
    Console.WriteLine("disconnected.");
  }

  static void OnReceive(SocketClient Client, byte[] Packet)
  {
    Console.WriteLine("received data.");
  }
    }
}

That was my socket tutorial! The difference from my old is that it required packets to be split, this does not!

Ref: (also in my sig.)

[go for it]

well the next words im gona say not a perfect explanation but it's what i know and i think that should be enough information to start with
shit im drunk lmao well
packet is a data , byte array , it's send from/to server and from/to client
why you send packets ?
to add information of what you actually do or what client should show you
so lets give a good example about packet 1004
i won't really go inside about encryptions and stuff , just plain packet explaining after i got it
lemme get a 1004 packet and it's structure
1004: chat packet

Offset	type	value
0	ushort	length
2	ushort	type
4	uint	Chat_Color
8	uint	Chat_Type
12	uint	MessageUID1
16	uint	MessageUID2
20	uint	Chat_Mesh
26	String[25]	_From
(27 + _From.Length)	string[26 + _From.Length])	_to
(29 + _From.Length)	string[(28 + _From.Length) + _To.Length]	_Message

so lets try to get a packet and see if it fit this packet structure and explain it
fuck that took forever to find old packet logging text on my lap shit

Packet Nr 1959. Server -> Client, Length : 101, PacketType: 1004
5D 00 EC 03 00 00 00 FF D0 07 00 00 00 00 00 00      ;] ì   ÿÐ      
00 00 00 00 00 00 00 00 04 06 53 59 53 54 45 4D      ;        SYSTEM
03 41 4C 4C 00 33 43 6F 6E 67 72 61 74 75 6C 61      ;ALL 3Congratula
74 69 6F 6E 73 21 20 61 68 6D 65 64 31 30 35 35      ;tions! ahmed1055
39 20 77 6F 6E 20 45 78 70 42 61 6C 6C 20 69 6E      ;9 won ExpBall in
20 6C 6F 74 74 65 72 79 2E 00 00 00 00 54 51 53      ; lottery.    TQS
65 72 76 65 72                                       ;erver

forget the titles about packet num. from and to , length and type we will get them from the packet together now
okay now ill split this code out with umm colors ? okay
ill make it like the packet structure , shit i lost words , just look what ill do
fuck i need this types so umm here

Talk = 2000,
Whisper = 2001,
Team = 2003,
Guild = 2004,
TopLeft = 2005,
Clan = 2006,
Qualifier = 2007,
Friend = 2009,
Center = 2011,
Service = 2014,
World = 2021,
PopUP = 2100,
Dialog = 2101,
HawkMessage = 2104,
Website = 2105,
FirstRightCorner = 2108,
ContinueRightCorner = 2109,
GuildBulletin = 2111,
BroadcastMessage = 2500;

5D 00 EC 03 00 00 00 FF D0 07 00 00 00 00 00 00 ;] ì ÿÐ
00 00 00 00 00 00 00 00 04 06 53 59 53 54 45 4D ; SYSTEM
03 41 4C 4C 00 33 43 6F 6E 67 72 61 74 75 6C 61 ;ALL 3Congratula
74 69 6F 6E 73 21 20 61 68 6D 65 64 31 30 35 35 ;tions! ahmed1055
39 20 77 6F 6E 20 45 78 70 42 61 6C 6C 20 69 6E ;9 won ExpBall in
20 6C 6F 74 74 65 72 79 2E 00 00 00 00 54 51 53 ; lottery. TQS
65 72 76 65 72 ;erver

colors should be kinda fucked up but this is for illustration

okay now lets get started
in brown at offset 0 there is 005D
notice how i read it ? this is ushort , that's how i read it
get calculator , convert this from hex to dec and you should get 93 yes this is the packet length and we add the server/client seal to it to be 101
and usually at tq packets they ALWAYS send the length in the very first ushort in client with offset 0
and they ALWAYS send the packet type in the next ushort at offset 2 which is umm 1004 right ? so umm try to convert 1004 to hex and you should get 3EC on calculator which is actually 03EC and should be written in the packet as EC 03

so yeah lets move to something more interesting ?
well what is the 00 00 00 FF ? go check the packet structure above
yes indeed it's chat color
what about those 2 uints ? of 00 00 00 00 00 00 00 00 ?
those are MessageUID1 and MessageUID2 , not really important for now

then D0 07 , how to type this down ? yes indeed 07D0 which is 2000 and yup i know you notice this Talk = 2000 , so this chat_type is talk

then 04 06 , pretty unknown to me , dun bother for now

then some long string starting with 53 ending with 2E
so what the hell is that ? isn't this a string ? yes prolly you need to look up the packet structure once more
well how to convert this packets to hex to string (letters and numbers?)
well i actually know them as i used them alot in reverse engineering but here
basically you need to use bit converter in coding and stuff but if you want to read something you may look up for assic converter or umm wait
here is a cool table i was using years before


now what is the last bytes ?
54 51 53 65 72 76 65 72 ? this is tq server seal

im so damn sleepy and can't type anymore
now you got an idea about what's going on about packets and stuff
you won't find packet structure for last packets , you need to try and make wild guesses to figure them out , do something in game and try to figure out what's changed in the packet
goodluck maybe tomorrow ill try to edit this shit to make it more better but that mostly won't happen if i got a hang over >.<
peace out nigga pray for me not to fall while walking to my bed ^^

[shadowman123]

@go for it : am afraid to say that he talks in general .. which means all u posted is useless to him Lol

[pro4never]

The client is responsible for filling in various packet structures and sending them to the server.

What exactly is it you're trying to do? The most common way to send packets TO server is to write a proxy to sit between the client and the server in order to send fake packets to the server (aka botting/aimbotting/etc)

That being said, there's no LEGITIMATE reason to be trying to manually send packets Client>Server. That's what the client exists for in the first place.

[badguy4you]

Originally Posted by pro4never

The client is responsible for filling in various packet structures and sending them to the server.

What exactly is it you're trying to do? The most common way to send packets TO server is to write a proxy to sit between the client and the server in order to send fake packets to the server (aka botting/aimbotting/etc)

That being said, there's no LEGITIMATE reason to be trying to manually send packets Client>Server. That's what the client exists for in the first place.

I want to understand packets in general so i can understand conquer ones if i wanted to.

[I don't have a username]

Okay edited my post.

[badguy4you]

Originally Posted by shadowman123

@go for it : am afraid to say that he talks in general .. which means all u posted is useless to him Lol

Although i am talking in general he helped me alot but still a small question, how could you or anyone who gets a packet from a game to analyze it to know each part What it do, and get all the information about it. ! and indeed create a replay for it

[I don't have a username]

Originally Posted by badguy4you

Although i am talking in general he helped me alot but still a small question, how could you or anyone who gets a packet from a game to analyze it to know each part What it do, and get all the information about it. ! and indeed create a replay for it

Packet analyzing is easy actually as long it's not encrypted and you don't have to reverse the cryptography.

Basically you check each offset with different datatypes until you get a value that is proper.

It can take some time unless you do it automatic. If I can get time I will finish Buu V3 which is so much better than V2 but short on time atm. as I'm coding a few things for a few people xD

I might write a guide for it as well.

[shadowman123]

Originally Posted by badguy4you

Although i am talking in general he helped me alot but still a small question, how could you or anyone who gets a packet from a game to analyze it to know each part What it do, and get all the information about it. ! and indeed create a replay for it

by lots of trial and Error .. ( Analizing packet needs patience ) and Human Scense for example in packet 1004 ( chat packet ) when u type hello my friend Am shadowman u gonna see alot of sucessive bytes at packet dump so by human scense its string information and you can make sure of that by using Hex to String converter

[badguy4you]

if i am receiving packet like this [i am testing on a game called Darkeden] and this is what i receive on login



is this encrypted or what, i think no because the username and password just appears normally but how could i make my own replay to it specially that this game has been terminated and the real server closed. [can't sniff real packets]

I brought you that example to help me learn practically.

[shadowman123]

Originally Posted by badguy4you

if i am receiving packet like this [i am testing on a game called Darkeden] and this is what i receive on login



is this encrypted or what, i think no because the username and password just appears normally but how could i make my own replay to it specially that this game has been terminated and the real server closed. [can't sniff real packets]

I brought you that example to help me learn practically.

so forget about making this game cuz u cant depend on guessing in making packet structure as there are surely loads of packets and each packet have type / length and offsets first 2 are very easy as the client request some of the packets to server then the server send the right action to be done to client .. so the hardest part in this offsets which u cant get by guessing specially if it has long packet length

[pro4never]

Originally Posted by badguy4you

if i am receiving packet like this [i am testing on a game called Darkeden] and this is what i receive on login



is this encrypted or what, i think no because the username and password just appears normally but how could i make my own replay to it specially that this game has been terminated and the real server closed. [can't sniff real packets]

I brought you that example to help me learn practically.

There are 3 main ways.

#1: Sniff real packets (most common and easiest way).

You record a sequence of packets being sent between the client and server as you perform actions, then compare the packets to known values to speed up structuring them and allow yourself to create a full packet structure for the systems being written.

#2: Reverse engineer the client. (bit more difficult, provides a more accurate picture when done properly)

You reverse engineer the client to view how packets are being processed and sent in order to get a very clear picture of how each offset in packets are being used and give yourself a much better idea of how things are being done.

#3: Trial and error. (time consuming, rare and less efficient in most cases)

Use known partial structures and trial and error to fill out unknown offsets or in very rare cases, come up with complete structures.

There's a video from my now defunct proxy paradise project where I get into partial structuring from packet dumps (obviously it's not a complete structure but it gives you a bit of an idea of how to go about it from packet dumps)

[go for it]

omg i should not explain anything when im drunk XD forgot to continue it
well my point from the post was to show a real packet , how server handle it and how client send it , how to get it's structure with testing/guessing
anyway goodluck mate