• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    公众号

C#_socket拆包_封包_模拟乱序包

原作者: [db:作者] 来自: [db:来源] 收藏 邀请
拆包一直是个硬伤呀,MLGB的,服务端各种乱数据,果断整理下

拆包思路:设计一个网络协议,一般都会分包,一个包就相当于一个逻辑上的命令。
1、如果我们用udp协议,省事的多,一次会收到一个完整的包,但UDP不可靠,顺序也不能保证,当然像QQ对UDP封装的很好,模拟了TCP的可靠性。网上也有一些封装好的可靠的UDP组件,大家用的话可以找找。关于用什么协议好这个问题,本贴不讨论。 2、如果我们用TCP协议不是长连接,像HTTP(不考虑KeepAlive)那样,一个连接上只发送一个包,我们也会很清晰的区分出接受到的每一个包。 3、还有就是我们还用TCP长连接,但每次发送固定长度的包,如果要发送的数据长度不够就用补齐,如果大于固定长度,就分成几个发,这个也很简单实用。 4、再有就是一个包有特定的开始和结尾,比如包头是<bof>包尾是<eof>,我们在可以从头读到尾,并把一个一个的包放入队列,由处理线程去处理。 5、再有一种就是每个包有固定长度的header,这个header里包含一个包的长度信息,我们可以先从头里读出长度信息,然后再借着读这么长的数据,完了这就是一个包。 关于封包的几种类型我就想到这么多,其中的利弊大家一看便知,我就不忽悠了,本文主要介绍最后一种方式,好多网络协议用的都是这种,包括CMPP协议,我们自己设计协议的时候一般不用像CMPP协议那样,因为二进制协议虽然虽然节省网络流量,但可读性不好。出问题,抓个包分析起来太麻烦。我们可以用.net自带的序列功能把要发送的类序列化成XML字符串发送出去,这多好看呀。 由于Socket缓冲区设置及其他的原因,Socket在接受数据的时候有时候不能完整的收到一个包,就是你读出包的长度后,可能不能一次就读取这么多数据。而如果读个半截儿的包就用UTF8Encoding等来解析,会解析出乱码的,我们这里用Encoding.UTF8.GetDecoder()来对包进行成块儿的解析,它就是用来做这种事情的。 下面就来看一下代码,代码的注释很全,演示了一个包从发到接受、解析的全过程,其中接受的过程没有一次收全所有的包,而是收了好几次,但我们最终还是成功的解析了收到的包。 public static void UnPack() { //1、声明通过socket发送的字符串 string toSendStringBySocket = "娃娃士大夫%#¥%My name is 蛙蛙王子!!"; //2、转换成utf-8字节数组 byte[] bsInput = Encoding.UTF8.GetBytes(toSendStringBySocket); //3、计算要发送的字节数组的长度,并写到第一块儿字节数组的开头 //一般协议设计里都有一个长度的Header,这里就是写这个Header int inputBytesCount = bsInput.Length; byte[] bs1 = new byte[4 + 3]; //4是一个int的长度,3是底一块字节数组除了Header剩余的大小 Buffer.BlockCopy(BitConverter.GetBytes(inputBytesCount), 0, bs1, 0, 4); //4、把要发送的字节数组拆分成3块儿发出去,因为socket在接受字节数组的时候 //也可能半截半截儿的接收,我们就是要模拟这种效果下的拆包,因为第一块包写了 //一个4个字节的Header,而第一块字节数组长度是7,所以再写三个字节长度的数据 int offSet = 0; Buffer.BlockCopy(bsInput, offSet, bs1, 4, 3); offSet += bs1.Length - 4; //5、写第二块儿数据 byte[] bs2 = new byte[8]; Buffer.BlockCopy(bsInput, offSet, bs2, 0, bs2.Length); offSet += bs2.Length; //6、写第三块儿数据,我们这里模拟在最后一块数据的末尾加一些乱七八糟的数据 //这些乱七八糟的数据有可能是下一个包的header。 byte[] bs3 = new byte[bsInput.Length - offSet + 4]; Buffer.BlockCopy(bsInput, offSet, bs3, 0, bsInput.Length - offSet); Buffer.BlockCopy(new byte[] { 1, 2, 3, 4 }, 0, bs3, bs3.Length - 4, 4); //7、Socket的接收方在执行BeginReceive函数,并回调函数里把收到的数据放入一个队列里 //dotNet的队列内部就是一个环形数组,这里直接就当环形缓冲区来用了。 Queue<byte[]> bufferPool = new Queue<byte[]>(); bufferPool.Enqueue(bs1); bufferPool.Enqueue(bs2); bufferPool.Enqueue(bs3); //8、初始化一些变量准备解包 //声明一个字符串缓冲区,大小是你的协议里规定的最大的包体长度 char[] chars = new char[256]; //定义一个UTF-8的Decoder,它可以成块的解包,内部自动维护解析状态 //关于它的使用请参考MSDN或者《.net框架设计》 Decoder d = Encoding.UTF8.GetDecoder(); int charLen = 0; //定义每次解包返回的字符长度 int parseBytesCount = 0; //定义已解包的字节数 int LenghHeader = 0; //定义收到包的长度 bool needReadLengthHeader = true; //是否需要读取长度的头 int srcOffSet = 0; //定义要解析的数据块的偏移量 byte[] tempBuffer; //9、当环形缓冲里有数据的时候就一直解析 while (bufferPool.Count > 0) { //10、读取数据包的长度信息,LengthHeader //因为第一块儿包包含长度信息,所以要先读出来 //读了长度包后,要把数据库解析偏移量加4 if(needReadLengthHeader) { LenghHeader = BitConverter.ToInt32(bs1, parseBytesCount); needReadLengthHeader = false; srcOffSet = 4; } //11、从环形缓冲区取出一块儿数据 tempBuffer = bufferPool.Dequeue(); parseBytesCount += tempBuffer.Length-srcOffSet; //更改已解析的字节数 //12、如果已解析的字节数大于数据的长度,那么只解需要解析的字节 if (parseBytesCount > LenghHeader) { parseBytesCount -= tempBuffer.Length; d.GetChars(tempBuffer, srcOffSet, inputBytesCount - parseBytesCount, chars, charLen); //这里记录下当前的临时缓冲区已解析到了什么位置,准备解析下一个包 srcOffSet = inputBytesCount - parseBytesCount; // break; } //13、解析这半拉包 charLen += d.GetChars(tempBuffer, srcOffSet, tempBuffer.Length-srcOffSet, chars, charLen); srcOffSet = 0; } string s = new string(chars); //14、通知包处理线程来处理这个包 Console.WriteLine(s); }

实际场景中应用

 

using UnityEngine;
using System.Collections;
using System;
using System.Threading;
using System.Text;
using System.Net;
using System.Net.Sockets;
using System.Collections.Generic;
using System.IO;
using System.Runtime.InteropServices;
using System.Runtime.Serialization;
using System.Runtime.Serialization.Formatters.Binary;

public class JFSocket
{

    //Socket客户端对象
    private Socket clientSocket;
    //JFPackage.WorldPackage是我封装的结构体,
    //在与服务器交互的时候会传递这个结构体
    //当客户端接到到服务器返回的数据包时,我把结构体add存在链表中。
    public List<JFPackage.WorldPackage> worldpackage;
    //单例模式
    private static JFSocket instance;
    public static JFSocket GetInstance()
    {
        if (instance == null)
        {
            instance = new JFSocket();
        }
        return instance;
     }      

    //单例的构造函数
    JFSocket()
    {
        //创建Socket对象, 这里我的连接类型是TCP
        clientSocket = new Socket (AddressFamily.InterNetwork,SocketType.Stream,ProtocolType.Tcp);
        //服务器IP地址
        IPAddress ipAddress = IPAddress.Parse ("192.168.1.100");
        //服务器端口
        IPEndPoint ipEndpoint = new IPEndPoint (ipAddress, 10060);
        //这是一个异步的建立连接,当连接建立成功时调用connectCallback方法
        IAsyncResult result = clientSocket.BeginConnect (ipEndpoint,new AsyncCallback (connectCallback),clientSocket);
        //这里做一个超时的监测,当连接超过5秒还没成功表示超时
        bool success = result.AsyncWaitHandle.WaitOne( 5000, true );
        if ( !success )
           {
               //超时
              Closed();
            Debug.Log("connect Time Out");
        }else
        {
            //与socket建立连接成功,开启线程接受服务端数据。
            worldpackage = new List<JFPackage.WorldPackage>();
            Thread thread = new Thread(new ThreadStart(ReceiveSorket));
                thread.IsBackground = true;
            thread.Start();
        }
    }

    private void connectCallback(IAsyncResult asyncConnect)
    {
        Debug.Log("connectSuccess");
    }

    private void ReceiveSorket()
    {
        //在这个线程中接受服务器返回的数据
        while (true)
        { 

            if(!clientSocket.Connected)
            {
                //与服务器断开连接跳出循环
                Debug.Log("Failed to clientSocket server.");
                clientSocket.Close();
                break;
            }
            try
            {
                //接受数据保存至bytes当中
                byte[] bytes = new byte[4096];
                //Receive方法中会一直等待服务端回发消息
                //如果没有回发会一直在这里等着。
                int i = clientSocket.Receive(bytes);
                if(i <= 0)
                {
                    clientSocket.Close();
                    break;
                }    

                //这里条件可根据你的情况来判断。
                //因为我目前的项目先要监测包头长度,
                //我的包头长度是2,所以我这里有一个判断
                if(bytes.Length > 2)
                {
                    SplitPackage(bytes,0);
                }else
                {
                    Debug.Log("length is not  >  2");
                }

             }
             catch (Exception e)
             {
                Debug.Log("Failed to clientSocket error." + e);
                clientSocket.Close();
                break;
             }
        }
    }    

    private void SplitPackage(byte[] bytes , int index)
    {
        //在这里进行拆包,因为一次返回的数据包的数量是不定的
        //所以需要给数据包进行查分。
        while(true)
        {
            //包头是2个字节
            byte[] head = new byte[2];
            int headLengthIndex = index + 2;
            //把数据包的前两个字节拷贝出来
            Array.Copy(bytes,index,head,0,2);
            //计算包头的长度
            short length = BitConverter.ToInt16(head,0);
            //当包头的长度大于0 那么需要依次把相同长度的byte数组拷贝出来
            if(length > 0)
            {
                byte[] data = new byte[length];
                //拷贝出这个包的全部字节数
                Array.Copy(bytes,headLengthIndex,data,0,length);
                //把数据包中的字节数组强制转换成数据包的结构体
                //BytesToStruct()方法就是用来转换的
                //这里需要和你们的服务端程序商量,
                JFPackage.WorldPackage wp = new JFPackage.WorldPackage();
                wp = (JFPackage.WorldPackage)BytesToStruct(data,wp.GetType());
                //把每个包的结构体对象添加至链表中。
                worldpackage.Add(wp);
                //将索引指向下一个包的包头
                index  =  headLengthIndex + length;

            }else
            {
                //如果包头为0表示没有包了,那么跳出循环
                break;
            }
        }
    }    

    //向服务端发送一条字符串
    //一般不会发送字符串 应该是发送数据包
    public void SendMessage(string str)
    {
         byte[] msg = Encoding.UTF8.GetBytes(str);

        if(!clientSocket.Connected)
        {
            clientSocket.Close();
            return;
        }
        try
        {
            //int i = clientSocket.Send(msg);
            IAsyncResult asyncSend = clientSocket.BeginSend (msg,0,msg.Length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);
            bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );
            if ( !success )
               {
                  clientSocket.Close();
                Debug.Log("Failed to SendMessage server.");
            }
        }
        catch
        {
             Debug.Log("send message error" );
        }
    }

    //向服务端发送数据包,也就是一个结构体对象
    public void SendMessage(object obj)
    {

        if(!clientSocket.Connected)
        {
            clientSocket.Close();
            return;
        }
        try
        {
            //先得到数据包的长度
            short size = (short)Marshal.SizeOf(obj);
            //把数据包的长度写入byte数组中
            byte [] head = BitConverter.GetBytes(size);
            //把结构体对象转换成数据包,也就是字节数组
            byte[] data = StructToBytes(obj);

            //此时就有了两个字节数组,一个是标记数据包的长度字节数组, 一个是数据包字节数组,
            //同时把这两个字节数组合并成一个字节数组

            byte[] newByte = new byte[head.Length + data.Length];
            Array.Copy(head,0,newByte,0,head.Length);
            Array.Copy(data,0,newByte,head.Length, data.Length);

            //计算出新的字节数组的长度
            int length = Marshal.SizeOf(size) + Marshal.SizeOf(obj);

            //向服务端异步发送这个字节数组
            IAsyncResult asyncSend = clientSocket.BeginSend (newByte,0,length,SocketFlags.None,new AsyncCallback (sendCallback),clientSocket);
            //监测超时
            bool success = asyncSend.AsyncWaitHandle.WaitOne( 5000, true );
            if ( !success )
               {
                  clientSocket.Close();
                Debug.Log("Time Out !");
            } 

        }
        catch (Exception e)
        {
             Debug.Log("send message error: " + e );
        }
    }

    //结构体转字节数组
    public byte[] StructToBytes(object structObj)
    {

        int size = Marshal.SizeOf(structObj);
        IntPtr buffer =  Marshal.AllocHGlobal(size);
        try
          {
              Marshal.StructureToPtr(structObj,buffer,false);
            byte[]  bytes  =   new byte[size];
            Marshal.Copy(buffer, bytes,0,size);
            return   bytes;
          }
          finally
          {
              Marshal.FreeHGlobal(buffer);
          }
    }
    //字节数组转结构体
    public object BytesToStruct(byte[] bytes,   Type   strcutType)
    {
        int size = Marshal.SizeOf(strcutType);
        IntPtr buffer = Marshal.AllocHGlobal(size);
          try
         {
                Marshal.Copy(bytes,0,buffer,size);
               return  Marshal.PtrToStructure(buffer,   strcutType);
          }
        finally
          {
              Marshal.FreeHGlobal(buffer);
          }   

    }

    private void sendCallback (IAsyncResult asyncSend)
    {

    }

    //关闭Socket
    public void Closed()
    {

        if(clientSocket != null && clientSocket.Connected)
        {
            clientSocket.Shutdown(SocketShutdown.Both);
            clientSocket.Close();
        }
        clientSocket = null;
    }

}

为了与服务端达成默契,判断数据包是否完成。我们需要在数据包中定义包头 ,包头一般是这个数据包的长度,也就是结构体对象的长度。正如代码中我们把两个数据类型 short 和 object 合并成一个新的字节数组。

 

然后是数据包结构体的定义,需要注意如果你在做IOS和Android的话数据包中不要包含数组,不然在结构体转换byte数组的时候会出错。

Marshal.StructureToPtr () error : Attempting to JIT compile method

 

JFPackage.cs

 

using UnityEngine;
using System.Collections;
using System.Runtime.InteropServices;

public class JFPackage
{
    //结构体序列化
    [System.Serializable]
    //4字节对齐 iphone 和 android上可以1字节对齐
    [StructLayout(LayoutKind.Sequential, Pack = 4)]
    public struct WorldPackage
    {
         public byte mEquipID;
         public byte mAnimationID;
         public byte mHP;
          public short mPosx;
          public short mPosy;
          public short mPosz;
          public short mRosx;
          public short mRosy;
          public short mRosz;

         public WorldPackage(short posx,short posy,short posz, short rosx, short rosy, short rosz,byte equipID,byte animationID,byte hp)
         {
            mPosx = posx;
            mPosy = posy;
            mPosz = posz;
            mRosx = rosx;
            mRosy = rosy;
            mRosz = rosz;
            mEquipID = equipID;
            mAnimationID = animationID;
            mHP = hp;
         }

    };  

}

让角色发生移动的时候,调用该方法向服务端发送数据。

 

 

void SendPlayerWorldMessage()
{
                //组成新的结构体对象,包括主角坐标旋转等。
     Vector3 PlayerTransform = transform.localPosition;
     Vector3 PlayerRotation = transform.localRotation.eulerAngles;
                //用short的话是2字节,为了节省包的长度。这里乘以100 避免使用float 4字节。当服务器接受到的时候小数点向前移动两位就是真实的float数据
     short px =  (short)(PlayerTransform.x*100);
     short py =  (short)(PlayerTransform.y*100);
     short pz =  (short)(PlayerTransform.z*100);
     short rx =  (short)(PlayerRotation.x*100);
     short ry =  (short)(PlayerRotation.y*100);
     short rz =  (short)(PlayerRotation.z*100);
     byte equipID = 1;
     byte animationID =9;
     byte hp = 2;
     JFPackage.WorldPackage wordPackage = new JFPackage.WorldPackage(px,py,pz,rx,ry,rz,equipID,animationID,hp);
                //通过Socket发送结构体对象
     mJFsorket.SendMessage(wordPackage);
}

 

接着就是客户端同步服务器的数据,目前是测试阶段所以写的比较简陋,不过原理都是一样的

 

 

//上次同步时间
      private float mSynchronous;

void Update ()
{

    mSynchronous +=Time.deltaTime;
    //在Update中每0.5s的时候同步一次
    if(mSynchronous > 0.5f)
    {
        int count = mJFsorket.worldpackage.Count;
        //当接受到的数据包长度大于0 开始同步
        if(count > 0)
        {
                               //遍历数据包中 每个点的坐标
            foreach(JFPackage.WorldPackage wp in mJFsorket.worldpackage)
            {
                float x = (float)(wp.mPosx / 100.0f);
                float y = (float)(wp.mPosy /100.0f);
                float z = (float)(wp.mPosz /100.0f);

                Debug.Log("x = " + x + " y = " + y+" z = " + z);
                  //同步主角的新坐标
                mPlayer.transform.position = new Vector3 (x,y,z);
            }
                               //清空数据包链表
            mJFsorket.worldpackage.Clear();
        }
        mSynchronous = 0;
    }
}

 

单个移动同步包实现了,我了个去

 

 

用到的一些网络传输时数据转换的函数
对于现在的网络世界,Tcp协议是经常用到的协议,Tcp可以确保网络传输数据的有序性,可靠性,那么你的工作就更加简单了,只需要经文件转换为字节数组,送到网络传输,有接收方把收到的字节组装起来就可以了。
      下面说一下将各种数据类型转换为字节数组的方法:
      BitConverter类可以将数值型数据转换为字节数组,同样可以将字节数组装换位数值。
     //把test转化为byte[]
 int test = 1990;
   byte[] data = BitConverter.GetBytes(test);


     //将byte[]转换为Int16

  int test=BitConverter.ToInt16(byte[] data, int offset);


       说明:BitConverter类存在ToString(),但是使用它的结果,可能同你预想的不同。
   //

string data = "this is a test";
string test = BitConverter.ToString(Encoding.ASCII.GetBytes(data));
Console.WriteLine("data = '{0}'", data);
Console.WriteLine("test = '{0}'", test);

结果:
C:\>test
data = 'this is a test'
test = '74-68-69-73-20-69-73-20-61-20-74-65-73-74'
C:\>
       BitConvert.ToString()是把字节数组中的值用16进制显示出来,所以如果要显示文本,要用Encoding.ASCII.GetString()方法。

       如果在2台基于Intel处理器,Ms Windows操作系统的机器上传送数值型数据,那么是没有问题的;但是如果传送给其他计算机,就不见得没有问题。
因为BitConvert.GetBytes()方法是把数值转换为字节并按照一定次序放入数组,这个次序同处理器和操作系统有关。
这个问题同CPU存储二进制数据不同有关,字节数组的存储有2种形式:
低位优先:先存放不重要的数据
高位优先:先存放重要的数据
所以对于相同系统的计算机,处理数值型字节数组没有问题,而对于不同系统的计算机,就会带来问题。
//

using System;
using System.Net;
using System.Text;
class BinaryDataTest
{
public static void Main()
{
int test1 = 45;
double test2 = 3.14159;
int test3 = -1234567890;
bool test4 = false;
byte[] data = new byte[1024];
string output;
data = BitConverter.GetBytes(test1);
output = BitConverter.ToString(data);
Console.WriteLine("test1 = {0}, string = {1}", test1, output);
data = BitConverter.GetBytes(test2);
output = BitConverter.ToString(data);
Console.WriteLine("test2 = {0}, string = {1}", test2, output);
data = BitConverter.GetBytes(test3);
output = BitConverter.ToString(data);
Console.WriteLine("test3 = {0}, string = {1}", test3, output);
data = BitConverter.GetBytes(test4);
output = BitConverter.ToString(data);
Console.WriteLine("test4 = {0}, string = {1}", test4, output);
}
}


结果:
C:\>BinaryDataTest
test1 = 45, string = 2D-00-00-00
test2 = 3.14159, string = 6E- 
                       
                    
                    

鲜花

握手

雷人

路过

鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
上一篇:
C#-DataTable分页代码发布时间:2022-07-13
下一篇:
C#截取1位小数发布时间:2022-07-13
热门推荐
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服(服务时间 9:00~18:00)

在线QQ客服
地址:深圳市南山区西丽大学城创智工业园
电邮:jeky_zhao#qq.com
移动电话:139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap