Protobuf解包组包

最新推荐文章于 2024-05-14 19:58:54 发布
最新推荐文章于 2024-05-14 19:58:54 发布
阅读量2k 收藏 3
点赞数
分类专栏： C#
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lijijun12321/article/details/89974520
版权

解包代码：

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TcpProto;
using Google.Protobuf;
using System.Threading;
using System.Net;
using System.Net.Sockets;
using System.Diagnostics;
using NewRemoteClient.Lijiun;
using NewRemoteClient.Lijiun.Model;

namespace NewRemoteClient.ganjie
{
    public static class PackageAnl
    {

        static SocketSingleInstance singleton = SocketSingleInstance.GetInstance();
        public static int pageCount;
        /// <summary>
        /// protoTCP解包
        /// </summary>
        /// <param name="proto"></param>
        /// <param name="typeid"></param>
        /// <returns></returns>
        public static IMessage Ap_first(byte[] proto, int typeid)
        {
            IMessage imessage = null;
            switch (typeid)
            {
                case ProtoId.srepm_confirm:                    //监控端认证返回
                    var srepm_confirm = new srepm_confirm();
                    srepm_confirm = srepm_confirm.Parser.ParseFrom(proto);
                    imessage = srepm_confirm;
                    Console.WriteLine("服务器认证监控端返回信息: {0}", srepm_confirm.Status);
                    Console.WriteLine("服务器认证监控端返回");
                    break;
                case ProtoId.srepc_confirm:                    //受控端认证返回
                    var srepc_confirm = new srepc_confirm();
                    srepc_confirm = srepc_confirm.Parser.ParseFrom(proto);
                    imessage = srepc_confirm;
                    Console.WriteLine("服务器认证受控端返回信息: {0}", srepc_confirm.Status);
                    Console.WriteLine("服务器认证受控端返回");
                    break;
                case ProtoId.srepm_heart:                    //监控端心跳返回
                    var srepm_heart = new srepm_heart();
                    srepm_heart = srepm_heart.Parser.ParseFrom(proto);
                    imessage = srepm_heart;
                    Console.WriteLine("服务器心跳包监控端返回信息: {0}", srepm_heart.Heart);
                    Console.WriteLine("服务器心跳包监控端返回");
                    break;
                case ProtoId.srepc_heart:                    //受控端心跳返回
                    var srepc_heart = new srepc_heart();
                    srepc_heart = srepc_heart.Parser.ParseFrom(proto);
                    imessage = srepc_heart;
                    Console.WriteLine("服务器心跳包受控端返回信息: {0}", srepc_heart.Heart);
                    Console.WriteLine("服务器心跳包受控端返回");
                    break;
                case ProtoId.mreq_ctrl:                    //控制请求
                    var mreq_ctrl = new mreq_ctrl();
                    mreq_ctrl = mreq_ctrl.Parser.ParseFrom(proto);
                    imessage = mreq_ctrl;
                    Console.WriteLine(mreq_ctrl.Ctltype);
                    DataSource.ffStatus = true;
                    Console.WriteLine("控制请求");
                    break;
                case ProtoId.srepm_ctrl:                    //控制情况
                    var srepm_ctrl = new srepm_ctrl();
                    srepm_ctrl = srepm_ctrl.Parser.ParseFrom(proto);
                    imessage = srepm_ctrl;
                    Console.WriteLine(srepm_ctrl.Ctrlstatus);
                    Console.WriteLine("控制情况");
                    break;
                case ProtoId.strans_ctrl:
                    var strans_ctrl = new strans_ctrl();
                    strans_ctrl = strans_ctrl.Parser.ParseFrom(proto);
                    imessage = strans_ctrl;
                    Console.WriteLine(strans_ctrl.Ctltype);
                    DataSource.ffStatus = true;
                    break;
                case ProtoId.creqs_plc_feedback:                    //受控端plc信息包
                    var creqs_plc_feedback = new creqs_plc_feedback();
                    creqs_plc_feedback = creqs_plc_feedback.Parser.ParseFrom(proto);
                    imessage = creqs_plc_feedback;
                    Ap_second(creqs_plc_feedback.PlcFeedbackData, ProtoId.plcData);
                    Ap_second(creqs_plc_feedback.Protocol, ProtoId.plcProtocalType);
                    Ap_second(creqs_plc_feedback.FeedType, ProtoId.FeedType);
                    Console.WriteLine("受控端plc信息包" + DataSource.plcSource);
                    break;
                case ProtoId.mreqs_plc_feedback:                    //监控端plc信息包
                    var mreqs_plc_feedback = new mreqs_plc_feedback();
                    mreqs_plc_feedback = mreqs_plc_feedback.Parser.ParseFrom(proto);
                    imessage = mreqs_plc_feedback;
                    Ap_second(mreqs_plc_feedback.PlcFeedbackData, ProtoId.plcData);
                    Ap_second(mreqs_plc_feedback.Protocol, ProtoId.plcProtocalType);
                    Ap_second(mreqs_plc_feedback.FeedType, ProtoId.FeedType);
                    Console.WriteLine("监控端plc信息包");
                    break;
                case ProtoId.srepc_plc_feedback:                    //服务器受控端plc信息包返回
                    var srepc_plc_feedback = new srepc_plc_feedback();
                    srepc_plc_feedback = srepc_plc_feedback.Parser.ParseFrom(proto);
                    imessage = srepc_plc_feedback;
                    Console.WriteLine("服务器受控端plc信息包返回");
                    break;
                case ProtoId.srepm_plc_feedback:                    //服务器监控端plc信息包返回
                    var srepm_plc_feedback = new srepm_plc_feedback();
                    srepm_plc_feedback = srepm_plc_feedback.Parser.ParseFrom(proto);
                    imessage = srepm_plc_feedback;
                    Console.WriteLine("服务器监控端plc信息包返回");
                    break;
                case ProtoId.srepm_chat:                            //服务器监控端信息包返回
                    var srepm_chat = new srepm_chat();
                    srepm_chat = srepm_chat.Parser.ParseFrom(proto);
                    imessage = srepm_chat;
                    Console.WriteLine(srepm_chat.Status);
                    DataSource.chatStatus = srepm_chat.Status;
                    Console.WriteLine("服务器监控端信息包返回");
                    break;
                case ProtoId.spushm_chat:                           //服务器推送监控端聊天信息
                    var spushm_chat = new spushm_chat();
                    spushm_chat = spushm_chat.Parser.ParseFrom(proto);
                    imessage = spushm_chat;
                    Ap_second(spushm_chat.Msg, ProtoId.ChatContent);
                    Console.WriteLine("服务器推送监控端聊天信息");
                    break;
                case ProtoId.srepc_chat:                    //服务器受控端聊天信息包返回
                    var srepc_chat = new srepc_chat();
                    srepc_chat = srepc_chat.Parser.ParseFrom(proto);
                    imessage = srepc_chat;
                    Console.WriteLine(srepc_chat.Status);
                    DataSource.chatStatus = srepc_chat.Status;
                    Console.WriteLine("服务器受控端聊天信息包返回:{0}", DataSource.chatStatus);
                    break;
                case ProtoId.spushc_chat:                    //服务器推送受控端聊天信息包
                    var spushc_chat = new spushc_chat();
                    spushc_chat = spushc_chat.Parser.ParseFrom(proto);
                    imessage = spushc_chat;
                    Ap_second(spushc_chat.Msg, ProtoId.ChatContent);
                    Console.WriteLine("服务器推送监控端端聊天信息包");
                    break;
                case ProtoId.mreqs_confparam:                    //控制端请求界面信息包(初始化使用)
                    var mreqs_confparam = new mreqs_confparam();
                    mreqs_confparam = mreqs_confparam.Parser.ParseFrom(proto);
                    imessage = mreqs_confparam;
                    UISource.UIrefreash_Start = true;
                    Console.WriteLine("控制端请求界面信息包");
                    break;
                case ProtoId.stransc_confparam:                    //服务器控制端请求界面信息返回包
                    var stransc_confparam = new stransc_confparam();
                    stransc_confparam = stransc_confparam.Parser.ParseFrom(proto);
                    imessage = stransc_confparam;
                    UISource.UIrefreash_Start = true;
                    Console.WriteLine("服务器控制端请求界面信息返回包");
                    break;
                case ProtoId.creps_confparam:                    //受控端返回界面信息包（初始化使用）
                    var creps_confparam = new creps_confparam();
                    creps_confparam = creps_confparam.Parser.ParseFrom(proto);
                    imessage = creps_confparam;
                    Ap_second(creps_confparam.Serialconf, ProtoId.SerialConfig);
                    Ap_second(creps_confparam.Recvconf, ProtoId.RecvConfig);
                    Ap_second(creps_confparam.Netconf, ProtoId.NetConfig);
                    Console.WriteLine("受控端返回界面信息包");
                    break;
                case ProtoId.srepm_confparam:                    //服务器推送监控端受控端界面信息包
                    var srepm_confparam = new srepm_confparam();
                    srepm_confparam = srepm_confparam.Parser.ParseFrom(proto);
                    imessage = srepm_confparam;
                    Ap_second(srepm_confparam.Serialconf, ProtoId.SerialConfig);
                    Ap_second(srepm_confparam.Recvconf, ProtoId.RecvConfig);
                    Ap_second(srepm_confparam.Netconf, ProtoId.NetConfig);
                    Console.WriteLine("服务器推送监控端受控端界面信息包");
                    break;
                case ProtoId.creqs_ui_refreash:                    //受控端界面刷新信息包
                    var creqs_ui_refreash = new creqs_ui_refreash();
                    creqs_ui_refreash = creqs_ui_refreash.Parser.ParseFrom(proto);
                    imessage = creqs_ui_refreash;
                    Ap_second(creqs_ui_refreash.Serialconf, ProtoId.SerialConfig);
                    Ap_second(creqs_ui_refreash.Recvconf, ProtoId.RecvConfig);
                    Ap_second(creqs_ui_refreash.Netconf, ProtoId.NetConfig);
                    Console.WriteLine("受控端界面刷新信息包");
                    break;
                case ProtoId.srepc_ui_refreash:                    //服务器受控端界面刷新返回包
                    var srepc_ui_refreash = new srepc_ui_refreash();
                    srepc_ui_refreash = srepc_ui_refreash.Parser.ParseFrom(proto);
                    imessage = srepc_ui_refreash;
                    Console.WriteLine("服务器受控端界面刷新返回包");
                    break;
                case ProtoId.stransm_ui_refreash:                    //服务器推送监控端受控端界面刷新信息包
                    var stransm_ui_refreash = new stransm_ui_refreash();
                    stransm_ui_refreash = stransm_ui_refreash.Parser.ParseFrom(proto);
                    imessage = stransm_ui_refreash;
                    Ap_second(stransm_ui_refreash.Serialconf, ProtoId.SerialConfig);
                    Ap_second(stransm_ui_refreash.Recvconf, ProtoId.RecvConfig);
                    Ap_second(stransm_ui_refreash.Netconf, ProtoId.NetConfig);
                    UISource.UIrefreash_Sync = true;
                    Console.WriteLine("服务器推送监控端受控端界面刷新信息包");
                    break;
                case ProtoId.mreqs_ui_refreash:                    //监控端界面刷新信息包
                    var mreqs_ui_refreash = new mreqs_ui_refreash();
                    mreqs_ui_refreash = mreqs_ui_refreash.Parser.ParseFrom(proto);
                    imessage = mreqs_ui_refreash;
                    Console.WriteLine("监控端界面刷新信息包");
                    break;
                case ProtoId.srepm_ui_refreash:                    //服务器监控端界面刷新返回包
                    var srepm_ui_refreash = new srepm_ui_refreash();
                    srepm_ui_refreash = srepm_ui_refreash.Parser.ParseFrom(proto);
                    imessage = srepm_ui_refreash;
                    Console.WriteLine("服务器监控端界面刷新返回包");
                    break;
                case ProtoId.stransc_ui_refreash:                    //服务器推送受控端监控端界面刷新信息包
                    var stransc_ui_refreash = new stransc_ui_refreash();
                    stransc_ui_refreash = stransc_ui_refreash.Parser.ParseFrom(proto);
                    imessage = stransc_ui_refreash;
                    
                    Console.WriteLine(imessage);


                    Ap_second(stransc_ui_refreash.Serialconf, ProtoId.SerialConfig);
                    Ap_second(stransc_ui_refreash.Recvconf, ProtoId.RecvConfig);
                    Ap_second(stransc_ui_refreash.Netconf, ProtoId.NetConfig);
                    UISource.UIrefreash_Sync = true;
                    Console.WriteLine("服务器推送受控端监控端界面刷新信息包");
                    break;
                case ProtoId.srepc_btn_event:
                    var srepc_btn_event = new srepc_btn_event();
                    srepc_btn_event = srepc_btn_event.Parser.ParseFrom(proto);
                    imessage = srepc_btn_event;
                    Console.WriteLine("控制端按钮点击事件返回包");
                    break;
                case ProtoId.srepm_btn_event:
                    var srepm_btn_event = new srepm_btn_event();
                    srepm_btn_event = srepm_btn_event.Parser.ParseFrom(proto);
                    imessage = srepm_btn_event;
                    Console.WriteLine("控制端按钮点击事件返回包");
                    break;
                case ProtoId.stransc_btn_event:
                    var stransc_btn_event = new stransc_btn_event();
                    stransc_btn_event = stransc_btn_event.Parser.ParseFrom(proto);
                    imessage = stransc_btn_event;
                    Console.WriteLine("服务器推送受控端控制端按钮点击事件包");
                    Ap_second(stransc_btn_event.Btn, ProtoId.ButtonEvent);
                    UISource.UiClickAuthority = true;
                    UISource.UiSend = false;
                    break;
                case ProtoId.stransm_btn_event:
                    var stransm_btn_event = new stransm_btn_event();
                    stransm_btn_event = stransm_btn_event.Parser.ParseFrom(proto);
                    imessage = stransm_btn_event;
                    Console.WriteLine("服务器推送控制端受控端按钮点击事件包");
                    Ap_second(stransm_btn_event.Btn, ProtoId.ButtonEvent);
                    UISource.UiClickAuthority = true;
                    UISource.UiSend = false;
                    break;

                #region 二基
                case ProtoId.srepm_log:
                    Console.WriteLine("日志长度：" + proto.Length);
                    var srepm_log = new srepm_log();
                    srepm_log = srepm_log.Parser.ParseFrom(proto);
                    imessage = srepm_log;
                    Console.WriteLine("服务器返回受控端日志");
                    Ap_second(srepm_log.Query, ProtoId.LogQuery);
                    Ap_second(srepm_log.Rs, ProtoId.LogResult);
                    break;

                case ProtoId.srepc_log:
                    var srepc_log = new srepc_log();
                    srepc_log = srepc_log.Parser.ParseFrom(proto);
                    imessage = srepc_log;
                    Console.WriteLine("服务器返回控制端日志");
                    Ap_second(srepc_log.Query, ProtoId.LogQuery);
                    Ap_second(srepc_log.Rs, ProtoId.LogResult);
                    break;
                #endregion
                default:
                    break;
            }
            return imessage;
        }

        /// <summary>
        /// protoCommon级解包
        /// </summary>
        /// <param name="proto"></param>
        /// <param name="typeid"></param>
        private static void Ap_second(IMessage proto, int typeid)
        {
            switch (typeid)
            {
                case ProtoId.AuthInfo:
                    var AuthInfo = proto as AuthInfo;
                    Console.WriteLine(AuthInfo.Auth);
                    break;
                case ProtoId.Confirm:
                    var Confirm = proto as Confirm;
                    Console.WriteLine(Confirm.MagicNum);
                    break;
                case ProtoId.ConfirmStatus:
                    var ConfirmStatus = proto as ConfirmStatus;
                    Console.WriteLine(ConfirmStatus.MagicNum);
                    break;
                case ProtoId.Heartbeat:
                    var Heartbeat = proto as Heartbeat;
                    Console.WriteLine(Heartbeat.Timestamp);
                    break;
                case ProtoId.ControlType:
                    var ControlType = proto as ControlType;
                    Console.WriteLine(ControlType.Type);
                    break;
                case ProtoId.ControlData:
                    var ControlData = proto as ControlData;
                    Ap_second(ControlData.LEDCtrlData, ProtoId.plcData);
                    break;
                case ProtoId.plcData:                   //plc发送信息
                    var plcData = proto as PlcData;
                    Console.WriteLine("远控端plc信息：\t" + plcData.Word.ToStringUtf8());
                    DataSource.Remoteplc = plcData.Word.ToStringUtf8();
                    break;
                case ProtoId.plcProtocalType:           //plc发送口信息
                    var plcProtocalType = proto as PlcProtocolType;
                    Console.WriteLine(plcProtocalType.Type);
                    DataSource.plcCom = (int)plcProtocalType.Type;
                    Console.WriteLine("端口：" + DataSource.plcCom);
                    break;
                case ProtoId.FeedType:
                    var feedtype = proto as FeedType;
                    Console.WriteLine("来源：" + feedtype.Type);
                    DataSource.plcSource = (int)feedtype.Type;
                    break;
                case ProtoId.ChatContent:           //聊天信息
                    var ChatContent = proto as ChatContent;
                    Console.WriteLine("聊天信息：\t" + ChatContent.Msg);
                    DataSource.chatRec = ChatContent.Msg;
                    break;
                case ProtoId.SerialConfig:           //串口配置界面
                    var SerialConfig = proto as SerialConfig;
                    if (SerialConfig != null)
                    {
                        UISource.cb_portName = SerialConfig.SerialPort;
                        UISource.cb_baudRate = SerialConfig.BaudRate;
                        UISource.cb_dataBit = SerialConfig.DataBits;
                        UISource.cb_checkBit = SerialConfig.CheckBits;
                        UISource.cb_stopBit = SerialConfig.StopBits;
                        UISource.cb_flowControl = SerialConfig.StreamCtrl;
                        UISource.SerialStatus = true;
                    }
                    break;
                case ProtoId.RecvConfig:           //接受设置界面
                    var RecvConfig = proto as RecvConfig;
                    if (RecvConfig != null)
                    {
                        UISource.AsciiRBtn = RecvConfig.Ascii;
                        UISource.HexRBtn = RecvConfig.Hex;
                        UISource.lineFeedCBox = RecvConfig.Autosend;
                        UISource.showSendMsgCBox = RecvConfig.DisplaySend;
                        UISource.showSendTimeCBox = RecvConfig.DisplayTime;
                        UISource.ViewStatus = true;
                    }
                    break;
                case ProtoId.NetConfig:           //网口设置界面
                    var NetConfig = proto as NetConfig;
                    if (NetConfig != null)
                    {
                        UISource.tb_tcpIP = NetConfig.Ip;
                        UISource.tb_tcpPort = NetConfig.Port;
                        UISource.ErthrialStatus = true;
                    }
                    break;
                case ProtoId.ButtonEvent:           //按钮点击
                    var ButtonEvent = proto as ButtonEvent;
                    Console.WriteLine("按钮点击信息：\t" + ButtonEvent.Btn);
                    UISource.UiButtonCheck = true;
                    UISource.UiButton = (int)ButtonEvent.Btn;
                    break;

                #region 二基
                case ProtoId.LogQuery:
                    Console.WriteLine("LogQuery");
                    var LogQuery = proto as LogQuery;
                    if ((int)LogQuery.QueryType == 1)
                    {
                        Console.WriteLine("LogQuery.PageNum: " + LogQuery.PageNum);
                        var send = Packagebui.SendLogQuery(false, LogQuery.Start, LogQuery.End, 2, (int)LogQuery.LogType, 0);
                        singleton.sendMsg(send, ProtoId.mreqs_log);
                    }
                    break;
                case ProtoId.LogResult:
                    Console.WriteLine("LogResult");
                    var LogResult = proto as LogResult;
                    bool status = LogResult.Status;
                    string errmsg = LogResult.Errmsg;
                    var al_test = LogResult.Al;
                    Console.WriteLine(al_test.Count);
                    //pageCount = al_test.Count;
                    var al = LogResult.Al.ToList<ActionLogStct>();
                    var ctl = LogResult.Ctl.ToList<CtrlLogStct>();
                    var chl = LogResult.Chl.ToList<ChatLogStct>();
                    if (al.Count != 0)
                    {
                        Console.WriteLine("动作日志");
                        pageCount = al.Count;
                        foreach (var e in al)
                        {
                            Console.WriteLine(e.RawMessage);
                        }
                        DelegateHelper.ViewActLog(al);
                    }
                    else if (ctl.Count != 0)
                    {
                        Console.WriteLine("控制日志");
                        pageCount = ctl.Count;
                        foreach (var e in ctl)
                        {
                            Console.WriteLine(e.MsgFrom.Auth.ToString());
                        }
                        DelegateHelper.ViewCtrlLog(ctl);
                    }
                    else if (chl.Count != 0)
                    {
                        Console.WriteLine("聊天日志");
                        pageCount = chl.Count;
                        foreach (var e in chl)
                        {
                            Console.WriteLine(e.Status);
                        }
                        DelegateHelper.ViewChatLog(chl);
                    }
                    else
                    {
                        //var P = Packagebui.SendLogQuery(false, "2018-07-25", "2018-07-28", 2, 1, 1);
                        //singleton.sendMsg(P, ProtoId.mreqs_log);
                    }
                    int logsize = LogResult.Logsize;
                    Console.WriteLine("错误信息：" + errmsg);
                    Console.WriteLine("长度：" + logsize.ToString());
                    if (logsize != 0)
                    {
                        LogPage.pageNum = logsize;
                        LogPage.pageNow = 1;
                        if (logsize % 25 == 0)
                            LogPage.pageTotal = logsize / 25;
                        else
                            LogPage.pageTotal = logsize / 25 + 1;
                        Console.WriteLine(LogPage.pageTotal);
                    }
                    break;

                #endregion
                default:
                    break;
            }
        }

        /// <summary>
        /// 发送信息组包
        /// </summary>
        /// <param name="first"></param>
        /// <param name="second"></param>
        /// <param name="thrid"></param>
        /// <returns></returns>
        public static byte[] ListTest(byte[] first, byte[] second, byte[] thrid)
        {
            List<byte> byteSource = new List<byte>();

            Stopwatch sw = new Stopwatch();
            sw.Start();
            byteSource.AddRange(first);
            byteSource.AddRange(second);
            byteSource.AddRange(thrid);

            byte[] data = byteSource.ToArray();

            sw.Stop();
            Console.WriteLine("ListTest " + sw.ElapsedMilliseconds + " 毫秒,数组长度：" + data.Length);
            return data;
        }
    }
}

 

组包代码：

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using TcpProto;
using Google.Protobuf;

namespace NewRemoteClient.ganjie
{
    public static class Packagebui
    {
        /// <summary>
        /// plc信息包
        /// </summary>
        /// <param name="check">判断监控端还是受控端<0.控制端 1.受控端></param>
        /// <param name="plctype">判断串口发送还是网口发送<0.网口发送 1.串口发送 2.网口接收 3.串口接收></param>
        /// <param name="plcdata">发送的信息内容</param>
        /// <returns></returns>
        public static IMessage plcInfo(bool check, int plctype, string plcdata)
        {
            IMessage imessage = null;
            switch (plctype)
            {
                case 0:
                    if (check)
                    {
                        creqs_plc_feedback cplc = new creqs_plc_feedback
                        {
                            Protocol = new PlcProtocolType
                            {
                                Type = PlcProtocolType.Types.protocolType.Ipv4
                            },
                            PlcFeedbackData = new PlcData
                            {
                                Word = ByteString.CopyFromUtf8(plcdata)
                            },
                            Ts = new TimeStamp
                            {
                                Timestamp = (int)GetCurrentTimeUnix()
                            },
                            FeedType = new FeedType
                            {
                                Type = FeedType.Types.feedType.CtrlSend
                            }
                        };
                        imessage = cplc;
                    }
                    else
                    {
                        mreqs_plc_feedback mplc = new mreqs_plc_feedback
                        {
                            Protocol = new PlcProtocolType
                            {
                                Type = PlcProtocolType.Types.protocolType.Ipv4
                            },
                            PlcFeedbackData = new PlcData
                            {
                                Word = ByteString.CopyFromUtf8(plcdata)
                            },
                            Ts = new TimeStamp
                            {
                                Timestamp = (int)GetCurrentTimeUnix()
                            },
                            FeedType = new FeedType
                            {
                                Type = FeedType.Types.feedType.CtrlSend
                            }
                        };
                        imessage = mplc;
                    }
                    break;
                case 1:
                    if (check)
                    {
                        creqs_plc_feedback cplc = new creqs_plc_feedback
                        {
                            Protocol = new PlcProtocolType
                            {
                                Type = PlcProtocolType.Types.protocolType.Serial
                            },
                            PlcFeedbackData = new PlcData
                            {
                                Word = ByteString.CopyFromUtf8(plcdata)
                            },
                            Ts = new TimeStamp
                            {
                                Timestamp = (int)GetCurrentTimeUnix()
                            },
                            FeedType = new FeedType
                            {
                                Type = FeedType.Types.feedType.CtrlSend
                            }
                        };
                        imessage = cplc;
                    }
                    else
                    {
                        mreqs_plc_feedback mplc = new mreqs_plc_feedback
                        {
                            Protocol = new PlcProtocolType
                            {
                                Type = PlcProtocolType.Types.protocolType.Serial
                            },
                            PlcFeedbackData = new PlcData
                            {
                                Word = ByteString.CopyFromUtf8(plcdata)
                            },
                            Ts = new TimeStamp
                            {
                                Timestamp = (int)GetCurrentTimeUnix()
                            },
                            FeedType = new FeedType
                            {
                                Type = FeedType.Types.feedType.CtrlSend
                            }
                        };
                        imessage = mplc;
                    }
                    break;
                case 2:
                    if (check)
                    {
                        creqs_plc_feedback cplc = new creqs_plc_feedback
                        {
                            Protocol = new PlcProtocolType
                            {
                                Type = PlcProtocolType.Types.protocolType.Ipv4
                            },
                            PlcFeedbackData = new PlcData
                            {
                                Word = ByteString.CopyFromUtf8(plcdata)
                            },
                            Ts = new TimeStamp
                            {
                                Timestamp = (int)GetCurrentTimeUnix()
                            },
                            FeedType = new FeedType
                            {
                                Type = FeedType.Types.feedType.CtrlRecv
                            }
                        };
                        imessage = cplc;
                    }
                    else
                    {
                        mreqs_plc_feedback mplc = new mreqs_plc_feedback
                        {
                            Protocol = new PlcProtocolType
                            {
                                Type = PlcProtocolType.Types.protocolType.Ipv4
                            },
                            PlcFeedbackData = new PlcData
                            {
                                Word = ByteString.CopyFromUtf8(plcdata)
                            },
                            Ts = new TimeStamp
                            {
                                Timestamp = (int)GetCurrentTimeUnix()
                            },
                            FeedType = new FeedType
                            {
                                Type = FeedType.Types.feedType.CtrlRecv
                            }
                        };
                        imessage = mplc;
                    }
                    break;
                case 3:
                    if (check)
                    {
                        creqs_plc_feedback cplc = new creqs_plc_feedback
                        {
                            Protocol = new PlcProtocolType
                            {
                                Type = PlcProtocolType.Types.protocolType.Serial
                            },
                            PlcFeedbackData = new PlcData
                            {
                                Word = ByteString.CopyFromUtf8(plcdata)
                            },
                            Ts = new TimeStamp
                            {
                                Timestamp = (int)GetCurrentTimeUnix()
                            },
                            FeedType = new FeedType
                            {
                                Type = FeedType.Types.feedType.CtrlRecv
                            }
                        };
                        imessage = cplc;
                    }
                    else
                    {
                        mreqs_plc_feedback mplc = new mreqs_plc_feedback
                        {
                            Protocol = new PlcProtocolType
                            {
                                Type = PlcProtocolType.Types.protocolType.Serial
                            },
                            PlcFeedbackData = new PlcData
                            {
                                Word = ByteString.CopyFromUtf8(plcdata)
                            },
                            Ts = new TimeStamp
                            {
                                Timestamp = (int)GetCurrentTimeUnix()
                            },
                            FeedType = new FeedType
                            {
                                Type = FeedType.Types.feedType.CtrlRecv
                            }
                        };
                        imessage = mplc;
                    }
                    break;
                default:
                    break;
            }
            Console.WriteLine("***********************plc信息组包完成******************************");
            return imessage;
        }

        /// <summary>
        /// 受控端聊天信息组包
        /// </summary>
        /// <param name="chatdata">聊天信息字符串</param>
        /// <returns></returns>
        public static IMessage chatInfo(string chatdata)
        {
            csend_chat csend_chat = new csend_chat
            {
                Msg = new ChatContent
                {
                    Msg = chatdata
                },
                Ts = new TimeStamp
                {
                    Timestamp = (int)GetCurrentTimeUnix()
                }
            };
            Console.WriteLine("聊天信息组包完成!");
            return csend_chat;
        }

        /// <summary>
        /// ff控制信息包
        /// </summary>
        public static IMessage ffmbag()
        {
            mreq_ctrl mreq = new mreq_ctrl
            {
                Ctltype = new ControlType
                {
                    Ts = new TimeStamp
                    {
                        Timestamp = (int)GetCurrentTimeUnix()
                    },
                    Type = ControlType.Types.Type.PushGraph
                },
                Ctldata = new ControlData
                {
                    LEDCtrlData = new PlcData
                    {
                        Word = ByteString.CopyFromUtf8("")
                    }
                }
            };
            return mreq;
        }

        /// <summary>
        /// 认证信息组包<1.position为true为受控端的包>
        /// </summary>
        /// <param name="position"></param>
        /// <returns></returns>
        public static IMessage Cofirm(bool position)
        {
            if (position)
            {
                creq_confirm creq = new creq_confirm
                {
                    Confirm = new Confirm
                    {
                        MagicNum = 1
                    }
                };
                return creq;
            }
            else
            {
                mreq_confirm mreq = new mreq_confirm
                {
                    Confirm = new Confirm
                    {
                        MagicNum = 1
                    }
                };
                return mreq;
            }
        }

        /// <summary>
        /// 按钮控件信息组包
        /// </summary>
        /// <param name="uiButton"></param>
        /// <param name="preesed"></param>
        /// <returns></returns>
        private static IMessage UIButton(string uiButton, bool preesed)
        {
            UIButton UIButton = new UIButton
            {
                Label = uiButton,
                Preesed = preesed
            };
            return UIButton;
        }

        /// <summary>
        /// 复选框信息组包
        /// </summary>
        /// <param name="uiButton"></param>
        /// <param name="preesed"></param>
        /// <returns></returns>
        private static IMessage UICheckBox(string uiButton, bool preesed)
        {
            UICheckBox UICheckBox = new UICheckBox
            {
                Label = uiButton,
                Checked = preesed
            };
            return UICheckBox;
        }

        /// <summary>
        /// 下拉列表信息组包
        /// </summary>
        /// <param name="contents"></param>
        /// <param name="select_index"></param>
        /// <param name="select_content"></param>
        /// <returns></returns>
        private static IMessage UIListBox(string[] contents, int select_index, string select_content)
        {
            UIListBox UIListBox = new UIListBox
            {
                SelectIndex = select_index,
                SelectContent = select_content
            };
            UIListBox.Contents.Add(contents);
            return UIListBox;
        }

        /// <summary>
        /// 串口配置界面信息包
        /// </summary>
        /// <returns></returns>
        private static IMessage SerialConfig()
        {
            var list = UISource.list_Serial;
            var select_index = UISource.select_index;
            var select_content = UISource.select_content;
            if (select_index != null)
            {
                SerialConfig SerialConfig = new SerialConfig
                {
                    SerialPort = UIListBox(list[0], select_index[0], select_content[0]) as UIListBox,
                    BaudRate = UIListBox(list[1], select_index[1], select_content[1]) as UIListBox,
                    DataBits = UIListBox(list[2], select_index[2], select_content[2]) as UIListBox,
                    CheckBits = UIListBox(list[3], select_index[3], select_content[3]) as UIListBox,
                    StopBits = UIListBox(list[4], select_index[4], select_content[4]) as UIListBox,
                    StreamCtrl = UIListBox(list[5], select_index[5], select_content[5]) as UIListBox
                };
                return SerialConfig;
            }
            else
            {
                SerialConfig SerialConfig = null;
                return SerialConfig;
            }


        }

        /// <summary>
        /// 接受设置界面信息包
        /// </summary>
        /// <returns></returns>
        private static IMessage RevConfig()
        {
            var labels = UISource.labels;
            var chekeds = UISource.checkeds;
            if (labels != null)
            {
                RecvConfig RecvConfig = new RecvConfig
                {
                    Ascii = UICheckBox(labels[0], chekeds[0]) as UICheckBox,
                    Hex = UICheckBox(labels[1], chekeds[1]) as UICheckBox,
                    Autosend = UICheckBox(labels[2], chekeds[2]) as UICheckBox,
                    DisplaySend = UICheckBox(labels[3], chekeds[3]) as UICheckBox,
                    DisplayTime = UICheckBox(labels[4], chekeds[4]) as UICheckBox
                };
                return RecvConfig;
            }
            else
            {
                RecvConfig RecvConfig = null;
                return RecvConfig;
            }
        }

        /// <summary>
        /// 网口设置界面组包
        /// </summary>
        /// <returns></returns>
        private static IMessage NetConfig()
        {
            var texts = UISource.texts;
            if (texts != null)
            {
                NetConfig netconfig = new NetConfig
                {
                    Ip = new UITextBox
                    {
                        Content = texts[0]
                    },
                    Port = new UITextBox
                    {
                        Content = texts[1]
                    }
                };
                return netconfig;
            }
            else
            {
                NetConfig netconfig = null;
                return netconfig;
            }

        }

        /// <summary>
        /// 界面刷新包
        /// </summary>
        /// <param name="check">判断组包类型<0.控制端请求包 1.受控端初始化界面信息包 2.受控端刷新界面包 3.控制端刷新界面包></param>
        /// <returns></returns>
        public static IMessage UIrefreash(int check)
        {
            IMessage imessage = null;
            switch (check)
            {
                case 0:
                    mreqs_confparam conf = new mreqs_confparam
                    {
                        Ts = new TimeStamp
                        {
                            Timestamp = (int)GetCurrentTimeUnix()
                        }
                    };
                    imessage = conf;
                    break;
                case 1:
                    creps_confparam c_conf = new creps_confparam
                    {
                        Serialconf = SerialConfig() as SerialConfig,
                        Recvconf = RevConfig() as RecvConfig,
                        Netconf = NetConfig() as NetConfig,
                        Ts = new TimeStamp
                        {
                            Timestamp = (int)GetCurrentTimeUnix()
                        }
                    };
                    imessage = c_conf;
                    break;
                case 2:
                    creqs_ui_refreash c_ui = new creqs_ui_refreash
                    {
                        Serialconf = SerialConfig() as SerialConfig,
                        Recvconf = RevConfig() as RecvConfig,
                        Netconf = NetConfig() as NetConfig,
                        Ts = new TimeStamp
                        {
                            Timestamp = (int)GetCurrentTimeUnix()
                        }
                    };
                    imessage = c_ui;
                    break;
                case 3:
                    mreqs_ui_refreash m_ui = new mreqs_ui_refreash
                    {
                        Serialconf = SerialConfig() as SerialConfig,
                        Recvconf = RevConfig() as RecvConfig,
                        Netconf = NetConfig() as NetConfig,
                        Ts = new TimeStamp
                        {
                            Timestamp = (int)GetCurrentTimeUnix()
                        }
                    };
                    imessage = m_ui;
                    break;

            }
            return imessage;
        }

        /// <summary>
        /// 按钮事件组包<1.串口开始 2.串口停止 3.网口开始 4.网口停止 5.Tab通信助手 6.Tab电路图>
        /// </summary>
        /// <param name="choice"></param>
        /// <returns></returns>
        private static IMessage BtnEvent(int choice)
        {
            ButtonEvent Btns = new ButtonEvent();
            switch (choice)
            {
                case 1:
                    Btns.Btn = ButtonEvent.Types.WhichBtn.Start;
                    break;
                case 2:
                    Btns.Btn = ButtonEvent.Types.WhichBtn.Stop;
                    break;
                case 3:
                    Btns.Btn = ButtonEvent.Types.WhichBtn.TcpStart;
                    break;
                case 4:
                    Btns.Btn = ButtonEvent.Types.WhichBtn.TcpStop;
                    break;
                case 5:
                    Btns.Btn = ButtonEvent.Types.WhichBtn.CommuniAssit;
                    break;
                case 6:
                    Btns.Btn = ButtonEvent.Types.WhichBtn.Diagram;
                    break;
            }
            return Btns;
        }

        /// <summary>
        /// 按钮点击端选择<0.受控端 1.控制端>
        /// </summary>
        /// <param name="authority"></param>
        /// <param name="choice"></param>
        /// <returns></returns>
        public static IMessage ButtonOrTab(bool authority, int choice)
        {
            if (authority)
            {
                creqs_btn_event creqs_btn_even = new creqs_btn_event
                {
                    Ts = new TimeStamp
                    {
                        Timestamp = (int)GetCurrentTimeUnix()
                    },
                    Btn = BtnEvent(choice) as ButtonEvent
                };
                return creqs_btn_even;
            }
            else
            {
                mreqs_btn_event mreqs_btn_event = new mreqs_btn_event
                {
                    Ts = new TimeStamp
                    {
                        Timestamp = (int)GetCurrentTimeUnix()
                    },
                    Btn = BtnEvent(choice) as ButtonEvent
                };
                return mreqs_btn_event;
            }
        }

        public static IMessage Test()
        {
            creps_confparam creps = new creps_confparam
            {
                Serialconf = null,
                Netconf = null,
                Recvconf = null,
                Ts = new TimeStamp
                {
                    Timestamp = (int)GetCurrentTimeUnix()
                }
            };
            return creps;

        }

        /// <summary>
        /// 获取时间戳
        /// </summary>
        /// <returns></returns>
        private static long GetCurrentTimeUnix()
        {
            TimeSpan cha = (DateTime.Now - TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1)));
            long t = (long)cha.TotalSeconds;
            Console.WriteLine("时间戳:\t" + t.ToString());
            return t;
        }

        #region 二基
        /// <summary>
        /// 日志查询
        /// </summary>
        /// <param name="id"></param>
        /// <param name="peedAddr"></param>
        /// <param name="action"></param>
        /// <param name="rawMessage"></param>
        /// <param name="gentime"></param>
        /// <returns></returns>
        public static IMessage LogQuery(string start, string end, int querytype, int logtype, int pagenum)
        {
            LogQuery LQ = new LogQuery();
            LQ.Start = start;
            LQ.End = end;
            LQ.PageNum = pagenum;
            switch (querytype)
            {
                case 1:
                    LQ.QueryType = global::LogQuery.Types.QueryType.Count;
                    break;
                case 2:
                    LQ.QueryType = global::LogQuery.Types.QueryType.Page;
                    break;
            }
            switch (logtype)
            {
                case 1:
                    LQ.LogType = global::LogQuery.Types.LogType.Action;
                    break;
                case 2:
                    LQ.LogType = global::LogQuery.Types.LogType.Ctrl;
                    break;
                case 3:
                    LQ.LogType = global::LogQuery.Types.LogType.Chat;
                    break;
            }
            return LQ;
        }

        /// <summary>
        /// 发送日志查询请求
        /// </summary>
        /// <param name="autority">0.受控端 1控制端</param>
        /// <param name="start">开始时间</param>
        /// <param name="end">截止时间</param>
        /// <param name="querytype">查询类型</param>
        /// <param name="logtype">日志类型</param>
        /// <param name="pagenum">日志页数</param>
        /// <returns></returns>
        public static IMessage SendLogQuery(bool autority, string start, string end, int querytype, int logtype, int pagenum)
        {
            if (autority)
            {
                creqs_log cl = new creqs_log()
                {
                    Ts = new TimeStamp
                    {
                        Timestamp = (int)GetCurrentTimeUnix()
                    },
                    Lq = LogQuery(start, end, querytype, logtype, pagenum) as LogQuery,
                };
                return cl;
            }
            else
            {
                mreqs_log ml = new mreqs_log
                {
                    Ts = new TimeStamp
                    {
                        Timestamp = (int)GetCurrentTimeUnix()
                    },
                    Lq = LogQuery(start, end, querytype, logtype, pagenum) as LogQuery,
                };
                return ml;
            }

        }
        #endregion
    }
}

 

lijijun12321
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
快速上手ProtoBuf
qq_56444564的博客
08-11 182
Buffers语⾔，既易于使⽤，⼜可以在更⼴泛的编程语⾔中使⽤。来指定⽂件语法为proto3，并且必须写在除去注释内容的第⼀⾏。package是⼀个可选的声明符，能表⽰.proto⽂件的命名空间，在项⽬中要有唯⼀性。所以1~15要⽤来标记出现⾮常频繁的字段，要为将来有可能添加的、频繁出现的字段预留⼀些出来。ProtocolBuffers语⾔版本3，简称proto3，是.proto⽂件最新的语法版本。值得⼀提的是，范围为1~15的字段编号需要⼀个字节进⾏编码，16~2047内的数字需要两个字节。
APP爬虫之-Protobuf协议逆向解析
lyd0813的博客
08-27 2393
比如一个APP要返回的数据有电话号码，姓名，年龄这三个字段，你就需要把这三个字段定义在 .proto 文件里，并且指明他们的数据类型，比如姓名和电话是字符串， 年龄是整型。APP常见的对数据加密有三种情况：第一种是，用诸如AES这类加密算法对数据加密，然后在APP里用key进行解密，这类的数据解密的难度不是很大，弄清楚是用的什么加密算法就能反解。这个的难度较大，没有功底，头发撸白都不一定撸出来。上图左边是反解析出来的数据，中中间是参照左边写出来的 .proto 文件，右边是人家原本的 .proto 文件。
Protobuf（基本使用和IDA中的protobuf解包逆向识别和重新利用）
最新发布
llovewuzhengzi的博客
05-14 820
创建一个.proto文件来定义你的数据结构。例如，创建一个。
Google Protocol Buffer
rongrong0206的专栏
12-06 1124
什么是 Google Protocol Buffer？ 假如您在网上搜索，应该会得到类似这样的文字介绍：Google Protocol Buffer( 简称 Protobuf) 是 Google 公司内部的混合语言数据标准，目前已经正在使用的有超过 48,162 种报文格式定义和超过 12,183 个 .proto 文件。他们用于 RPC 系统和持续数据存储系统。Protocol Buffers 是一种轻便高效的结构化数据存储格式，可以用于结构化数据串行化，或者说序列化。它很适合做数据存储或 RPC 数据交
WebSocket接收与发送Protobuf消息及消息的打包与解包
08-27 2932
server: package main import ( //"strings" //"reflect" "bytes" "fmt" "encoding/binary" "net/http" "github.com/gorilla/websocket" "time" "gowebsocket/impl" "github.com/golang/protobuf/proto" ) var( upgrader = websocket.Upgrader{ /.
Protobuf使用
09-20
描述中提到的"多个协议存入一个缓存区"，这通常指的是在protobuf中实现消息的分包和解包，允许在一个消息流中传输不同类型的消息。通过自定义的包装消息类型，可以将不同类型的protobuf消息封装在一起，然后在接收端...
payload-dumper-解包
03-22
总的来说，“payload-dumper-解包”是一个关于二进制文件解析和数据提取的实践，涉及了编程语言（Python）、数据序列化协议（protobuf）、版本控制（Git）以及可能的系统级知识，如固件更新和图像文件格式。...
protobuf-net
09-10
Protobuf(Google Protocol Buffers)是google开发的的一套用于...它和XML和Json数据差不多,把数据已某种形式保存起来.Protobuf相对与XML和Json的不同之处，它是一种二进制的数据格式，具有更高的传输，打包和解包效率.
C++使用protobuf 作为网络消息协议
03-25
"数据的打包和解包"是网络通信的关键步骤。在C++中，我们可以创建protobuf消息对象，填充字段，然后调用`SerializeToString()`方法将其序列化为字符串，这个字符串就可以通过socket发送到服务器。服务器端接收数据后...
Google Protobuf在Linux Socket通讯中的应用.pdf
09-06
我们将通过一个 C++ 编写的 C/S 程序，验证基于 Protobuf 技术的网络收发包的正确性。 Protobuf 的优点包括： * 高效的数据序列化和反序列化机制 * 可扩展的数据格式 * 高效的网络通信 * 可靠的数据传输 ...
C#中使用二进制和ProtoBuf分别进行序列化、反序列化、压缩、解压缩对比测试示例源码.zip
08-21
C#中使用二进制和ProtoBuf分别进行序列化、反序列化、压缩、解压缩对比测试示例源码
Protobuf简单使用及其抓包分析
12-24
Protobuf简单使用及其抓包分析,参考：http://blog.csdn.net/wangqiuyun/article/details/42119835
【ProtoBuf】protobuf序列化协议
qq_32907491的博客
06-02 1006
proto文件的第一行指定了使用proto3语法，说明使用的是proto3版本。如果省略protocol buffer编译器就默认使用proto2语法。他必须是文件中非空非注释行的第一行。message表示消息类型，可以有多个。SendRequest定义中指定了三个字段(name/value键值对)，每个字段都会有名称和类型。repeated是字段规则。Protobuf各个语言标量类型对应关系。
protobuf 打包 与 解包
boshuzhang的专栏
01-09 4644
// excerpts from http://code.google.com/p/muduo/   //   // Use of this source code is governed by a BSD-style license   // that can be found in the License file.  
Protocol Buffer与iOS的交互
黑码哥的技术博客
02-14 873
具体实现之前主要参考的： https://github.com/alexeyxo/protobuf-objc     http://www.jianshu.com/p/5c69bd048750
protoBuf组件介绍（protocol buffers）
weixin_38107457的博客
07-03 196
protoBuf是一种语言无关、平台无关、可扩展的序列化结构数据的方法，它可用于（数据）通信协议、数据存储等 protoBuf组件的安装： 1.下载软件：https://github.com/protocolbuffers/protobuf/releases，下载对应的安装文件 2.讲下载的压缩包解压，并讲解压后的文件夹拷贝到要存放的位置，比如D:\go下 3.添加环境变量：或者将bin目录下的protoc.exe拷贝到gopath下的bin文件夹中，不用添加环境变量 在cmd...
go protobuf tcp 粘包处理 demo
hellozhxy的博客
02-23 862
1.安装相关包 设置代理 set GOPROXY=https://goproxy.cn 安装golang的proto工具包go get -u github.com/golang/protobuf/proto 安装goalng的proto编译支持go get -u github.com/golang/protobuf/protoc-gen-go 查看 protoc 版本 protoc --version 2.创建项目 模拟微服务开发,在某个空文件夹下建立两个文件夹 分别为client...
C++中protobuf解包
01-18
以下是C++中使用protobuf进行解包的示例代码： ```cpp #include #include "Account.pb.h" int main() { // 创建一个Account对象 Account account; // 从文件或网络中读取二进制数据 // 假设数据已经读取到...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值