基于js状态机的http协议解析器

最新推荐文章于 2023-01-19 13:41:28 发布
最新推荐文章于 2023-01-19 13:41:28 发布
阅读量1k 收藏 2
点赞数
分类专栏： javascript
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/THEANARKH/article/details/74515890
版权 
var utils = {
    getType: function(content) {
        return Object.prototype.toString.call(content).match(/\[object (.*)\]/)[1];
    },
    isType: function(content, type) {
        return this.getType(content).toLowerCase() === type.toLowerCase();
    }

};
function FSMTable(arg) {
    if (this instanceof FSMTable) {
        this.table = [];
        if (utils.isType(arg, 'Array')) {
            for(var i = 0 ;i < arg.length; i++) {
                this.table.push(new FSMItem(arg[i]));
            }
        }
        return this;
    }
    return new FSMTable(arg);
}

FSMTable.prototype = {
    append: function(arg) {
        this.table.push(arg);
    },
    getLenght: function() {
        return this.table.length;
    },
    getItem: function(index) {
        if (index >= this.getLenght()) {
            return null;
        }
        return this.table[index];
    },
    setItem: function(state, arg) {
        var len = this.getLenght();
        for (var i = 0; i < len; i++) {
            if (this.table[i]['state'] === state) {
                for (var k in arg) {
                    if (arg.hasOwnProperty(k) && k !== 'state') {
                        this.table[i][k] = arg[k];
                    }
                }
                break;
            }
        }
    },
    delItem: function(state) {
        var len = this.getLenght();
        for (var i = 0; i < len; i++) {
            if (this.table[i]['state'] === state) {
                delete this.table[i];
                break;
            }
        }
    }
}
function FSMItem(arg) {
    this.state = arg.state;
    this.eventHandlers = arg.eventHandlers;
}




function Iterator(content, cfg) {
    this.content = content;
    this.length = 0;
    this.count = 0;
    this.position = 0;
    this.direction = (cfg && cfg.direction) || 0;
    this.init();
}
Iterator.prototype = {
    next: function() {
        if (!this.hasNext()) {
            return null;
        }
        this.count++;
        if (this.direction === 0) {
            return this.content[this.position++];
        } else {
            return this.content[this.position--];
        }

    },
    getData: function() {
        return this.content;
    },
    getPosition: function() {
        return this.position;
    },
    rewind: function(index) {
        if (index  <= this.length && index >= 0) {
            this.position = index;
            this.count = this.direction === 0 ? index : this.length - index;// - 1;
        }
    },
    hasNext: function() {
        return this.count < this.length;
    },
    init: function() {

        var type = utils.getType(this.content);
        switch(type) {
            case 'String': 
                            this.content = this.content.split('');
                            break;
            case 'Array': 
                            this.content = this.content.concat();
                            break;
            case 'Object': 
                        var arr = [];
                        var keys = Object.keys(this.content);
                        for (var i = 0; i< keys.length; i++) {
                            arr.push(this.content[keys[i]]);
                        }
                        this.content = arr;
                        break;
        }

        this.length = this.content.length;
        this.position = this.direction === 0 ? 0 : this.length - 1;
    }
}

function FSM(table,initState,endState,content,cfg) {
    this.iterator = new Iterator(content, cfg);
    this.table = table;
    this.currentState = initState;
    this.endState = endState;
    this.result = [];
    this.currentResult = '';
    this.hooks = (cfg && cfg.hooks) || null;
}
FSM.prototype = {
    getCurrentState: function() {
        return this.currentState;
    },
    setCurrentState: function(state) {
        return this.currentState = state;
    },
    getCurrentResult: function() {
        return this.currentResult;
    },
    setCurrentResult: function(val, mode) {
        mode = mode || 'a';
        switch(mode) {
            case 'a' : this.currentResult += val; break;
            case 'w' : this.currentResult = val; break;
        }
    },
    // 获取状态机生成的结果
    getRawResult: function() {
        return this.result;
    },
    // 利用用户钩子生成的结果
    getResult: function() {
        if (this.hooks.resulSetter) {
            return this.hooks.resulSetter.call(this,this.result);
        }
        return this.getRawResult();
    },
    setResult: function(val, mode) {
        mode = mode || 'a';
        switch(mode) {
            case 'a' : this.result.push(val); break;
            case 'w' : this.result = val; break;
        }

    },
    setHook: function(hookName, hookValue) {
        this.hooks[hookName] = hookValue;
    },
    stateHandler: function() {
        var content = this.getContent();
        var event = this.getEvent(content);
        var tableLength = this.table.getLenght();
        for (var index = 0; index < tableLength; index++) {
            var item = this.table.getItem(index);
            if (item.state === this.currentState && item.eventHandlers[event] && utils.isType(item.eventHandlers[event], 'function')) {
                if (item.eventHandlers[event].call(this,content) === false) {
                    return false;
                } 
                break;
            }
        }
        return true;
    },
    getRest: function() {
        var position = this.iterator.getPosition();
        var data = this.iterator.getData();
        this.iterator.rewind(data.length);
        return data.slice(position,data.length).join('');
    },
    handleResult: function() {
        this.setResult(this.getCurrentResult(),'a');
        this.setCurrentResult('','w');
    },
    // 获取状态机的触发事件，由用户钩子实现
    getEvent: function(content) {
        return this.hooks.eventGetter.call(this,content);
    },
    getContent: function() {
        var content = null;
        if (this.iterator.hasNext()) {
            content = this.iterator.next();
        } 
        return content;
    },
    run: function() {
        var flag;
        do {
            flag = this.stateHandler();
        } while (!!flag);
    }
}


    // 分开回车和换行两种状态是为了处理linux/win/mac系统中，换行的兼容问题
    var STATE = {
        START:0,
        // \n对应的状态
        INLF: 1,
        // \r对应的状态
        INCR: 2,
        // 解析http头时的状态
        INHTTPHEADER: 3,
        // 解析http头对应的值时的状态
        INHTTPHEADERVALUE: 4,
        END:5
    }
    var EVENT = {
        // 获取到一个\r时触发该事件
        GETACR: 0,
        // 获取到一个\n时触发该事件
        GETALF:1,
        // 获取到一个:时触发该事件
        GETACOLON: 2,
        // 获取到一个非以上字符时触发该事件
        GETACHAR: 3,
        END: 4
    };
    // 解析http头时调用
    function httpHeaderHandler(char) {
        this.setCurrentState(STATE.INHTTPHEADER);
        this.setCurrentResult(char,'a');    
    }
    var table = new FSMTable([{
        state:STATE.START,
        eventHandlers: {[EVENT.GETACHAR]: httpHeaderHandler}
    },{
        state:STATE.INHTTPHEADER,
        eventHandlers: {[EVENT.GETACHAR]: httpHeaderHandler, [EVENT.GETACOLON]: function(char) {
            // http请求行的url中可能含有:，这里需要特殊处理
            if (this.getRawResult().length === 0) {
                this.setCurrentResult(char,'a');
                return;
            } 
            // 在解析http头时遇到:则进入解析http头对应的值状态
            this.setCurrentState(STATE.INHTTPHEADERVALUE);
            this.handleResult();
        },[EVENT.GETACR]: function(char) {
            // 这里主有在解析http请求行/响应行时会调用
            this.setCurrentState(STATE.INCR);
            this.handleResult();
        },[EVENT.GETALF]: function(char) {
            // 这里主有在解析http请求行/响应行时会调用
            this.setCurrentState(STATE.INLF);
            this.handleResult();
        }}
    },{
        state:STATE.INHTTPHEADERVALUE,
        eventHandlers: {[EVENT.GETACHAR]: function(char) {
            this.setCurrentResult(char,'a');
        },[EVENT.GETACOLON]: function(char) {
            // http头对应的值中可以含有:，比如cookie中的值，这里需要特殊处理
            this.setCurrentResult(char,'a');
        },[EVENT.GETACR]: function(char) {
            // 遇到回车或换行说明这一行http信息结束
            this.setCurrentState(STATE.INCR);
            this.handleResult();
        },[EVENT.GETALF]: function(char) {
            this.setCurrentState(STATE.INLF);
            this.handleResult();
        }}
    },{
        state:STATE.INCR,
        eventHandlers: {[EVENT.GETACHAR]: httpHeaderHandler, [EVENT.GETACR]: function() {
            // 如果状态机处于INCR状态，又遇到了一个CR，说明接下来是body部分
            this.Body = this.getRest().replace(/^\s/,'');
        }}
    },{
        state:STATE.INLF,
        eventHandlers: {[EVENT.GETACHAR]: httpHeaderHandler, [EVENT.INLF]: function() {
            this.Body = this.getRest().replace(/^\s/,'')    ;
        }}
    },{
        state:STATE.END,
        eventHandlers: {[EVENT.END]: function() {
            // 防止http最后没有两个换行符，或者只有一个，基本不会发生
            if (this.Body === undefined){
                if (this.getRawResult().length % 2 === 0)
                    this.setResult(this.getCurrentResult(),'a');
                this.Body = '';
            } 
            return false;
        }}
    }]);
    // 钩子，用于用户自定义处理
    var hooks = {
        eventGetter:function(content) {
            var event = null;
            if (content === null) {
                event = EVENT.END;
                this.setCurrentState(this.endState);

            }else if(content === ':') {
                event = EVENT.GETACOLON;
            }else if (content === '\n'){
                event = EVENT.GETALF;
            } else if (content === '\r'){
                event = EVENT.GETACR;
            } else {
                event = EVENT.GETACHAR;
            }

            return event;
        },
        resulSetter: function(result) {
            result = result.concat();
            var resultLen = result.length;
            // 整个解析结果由请求行/响应行、http头和值、body组成，所有有body的话说明是偶数。否则是奇数
            // if (this.Body !== undefined){
            //  if (resultLen % 2 !== 0) {
            //      throw new Error('parse error');
            //      return;
            //  }
            //  body['body'] = result.pop();
            // } else {
            //  if (resultLen % 2 === 0) {
            //      throw new Error('parse error');
            //      return;
            //  }
            // }
            var res = [];
            var tmpObj;
            var reqOrResLine = {};
            var body = {};
            body['body'] = this.Body;
            reqOrResLine['reqOrResLine'] = result.shift();
            // 请求行放到数组的第一位
            res.push(reqOrResLine);
            // 处理http头
            for (var i = 0; i < result.length; i = i+2) {
                tmpObj = {key:null,val:null};
                tmpObj['key'] = result[i].replace(/\s*$/,'').replace(/^\s*/,'');
                tmpObj['val'] = result[i+1].replace(/\s*$/,'').replace(/^\s*/,'');
                res.push(tmpObj);
            }
            // body放到数组最后
            res.push(body)
            return res;
        }
    };
    function parseBody(content) {
        this.result = content;
    }
    parseBody.prototype = {

    }
    function parseRequestHeader(content) {
        var result = {};
        var arr = content.split(' ');
        result['method'] = arr[0];
        result['url'] = arr[1];
        result['httpVersion'] = arr[2];
        return result;
    }
    function parseResponseHeader(content) {
        var result = {};
        var arr = content.split(' ');
        result['httpVersion'] = arr[0];
        result['statusCode'] = arr[1];
        result['statusText'] = arr[2];
        return result;
    }
    var fs = require('fs');
    var str = fs.readFile('http.js',(err,data)=> {
        data = data.toString();//.replace(/\n/,'').replace(/\r/,'');
        var fsm = new FSM(table,STATE.START,STATE.END,data, {direction: 0, hooks: hooks});
        fsm.run();
        console.log(fsm.getResult()) 
    })

测试http请求，从fiddler中复制

HTTP/1.1 200 OK
Server: nginx
Date: Wed, 05 Jul 2017 17:39:08 GMT
Content-Type: text/html; charset=UTF-8
Connection: close
Vary: Accept-Encoding
X-Powered-By: PHP/5.6.10
Content-Length: 921

xxxxxxxxxxxxxxxxxxxxxxxxxxxx

结果

[ { reqOrResLine: 'HTTP/1.1 200 OK' },
  { key: 'Server', val: 'nginx' },
  { key: 'Date', val: 'Wed, 05 Jul 2017 17:39:08 GMT' },
  { key: 'Content-Type', val: 'text/html; charset=UTF-8' },
  { key: 'Connection', val: 'close' },
  { key: 'Vary', val: 'Accept-Encoding' },
  { key: 'X-Powered-By', val: 'PHP/5.6.10' },
  { key: 'Content-Length', val: '921' },
  { body: 'xxxxxxxxxxxxxxxxxxxxxxxxxxxx' } ]
theanarkh
关注
专栏目录
使用状态机完成对HTTP请求的读取和分析
ad838931963的博客
06-30 1240
使用状态机完成对HTTP请求的读取和分析 主状态机作用(parse_content())：读取请求行与头部行数据 状态：请求行、头部行 从状态机作用(parse_line)：读取每一行数据 状态：读取成功、失败、需要继续读取 parse_request():读取请求行，并将主状态机状态更改为头部行 parse_header():读取头部行 主状态机初始状态为请求行， 循环调用parse_line，若为成功状态继续（失败退出返回失败原因） 并且判断主状态机状态 请求->parse_request()-&
基于状态机的DLT645协议解析
kchuang2008的博客
07-25 2510
DLT645-2007协议格式如下： /* 根据协议格式的状态定义 / #define FRAME_STATES_DLT645_NULL 0 / no synchronisation / #define FRAME_STATES_DLT645_68 1 / have the first Flag Byte r...
HTTP高效解析方法之协议状态机
一只青木呀
08-24 1970
协议状态机 协议状态机原理 平时我们解析单个的URL的时候，都是一个线程从头解析到尾，一个线程完成了所有的事情， 协议状态机就是把这一件事情分成很多份，分发给更多的线程去解决，这样当并发量很大的时候就能很好快速的处理，完美解决了高并发的问题。 协议状态机的每一步都存在输出和跳转，下面我们以一个正确的解析方式来分析一下协议状态机 判断方法:判断HTTP协议的第一个字母是G P 每个状态机都有一个跳转条件和输出结果 确定方法； 确定当前状态，根据状态的类型，跳转到不同方法的处理状态 每一步处理完之后，我们都会
node.js入门（三）http数据解析
banxia2152的博客
05-20 209
在很多场景中，我们的服务器都需要跟用户的浏览器打交道，如表单提交。 表单提交到服务器一般都使用 GET/POST 请求。 1、由于GET请求直接被嵌入在路径中，URL是完整的请求路径，包括了?后面的部分，因此你可以手动解析后面的内容作为GET请求的参数。 项目根目录新建server.js 和 form.html server.js const http = require(...
Web服务器——HTTP状态机解析
热门推荐
AlwaySimple的博客
12-18 1万+
Web服务器——HTTP状态机解析 程序说明 主要练习HTTP解析的状态机的使用。接收一个客户端请求，判断是否是一个正确的GET请求，并解析出相应字段。 运行方法 编译 g++ main.cpp -o main 直接运行也可以，默认ip为127.0.0.1,默认端口为8888 运行 curl 127.0.0.1:7777/index.html 运行结果： 客户端发起请求： # 方式1：命令行...
HTTP协议简介/数据包封装/三次握手/DNS解析
sunshine612的博客
04-28 3737
HTTP协议简介/数据包封装/三次握手/DNS解析1.浏览器背后的故事2.HTTP3.透过TCP/IP看HTTP4.数据包的封装过程5.传输层--TCP三次握手6.DNS域名解析DNS 域名解析协议的工作原理 递归式 迭代式7.HTTP事务处理过程实验---对于浏览器来说HTTP请求到底是什么样子 1.浏览器背后的故事 解释： 打给小红，由姓名的代号来记录， 小红就是域名，电话号就是IP地址，共同...
解析针对 HTTP/2 协议的不同步攻击
HBohan的博客
09-06 848
HTTP/2 很容易被误认为是一种传输层协议，HTTP/2 （原名HTTP/2.0）即超文本传输协议 2.0，是下一代HTTP协议。是由互联网工程任务组（IETF）的Hypertext Transfer Protocol Bis (httpbis)工作小组进行开发。是自1999年http1.1发布后的首个更新。HTTP 2.0在2013年8月进行首次合作共事性测试。在开放互联网上HTTP 2.0将只用于https：//网址，而 http：//网址将继续使用HTTP/1，目的是在开放互联网上增加使用加密技术，
Http协议详解(深入理解)
fanfangyu的博客
07-28 1万+
1xx指示信息，表示请求已接收，继续处理2xx成功，表示请求已被成功接受，处理。
HTTP协议
qq_40776361的博客
01-07 1960
定义 HTTP协议是Hyper Text Transfer Protocol（超文本传输协议）的缩写。HTTP 协议和 TCP/IP 协议族内的其他众多的协议相同， 用于客户端和服务器之间的通信。请求访问文本或图像等资源的一端称为客户端， 而提供资源响应的一端称为服务器端。 URL——统一资源标识符（Uniform Resource Identifiers） 包含了用于查找某个资源的足够的信息，HTTP使用URL来传输数据和建立连接。 一个完整的URL包括以下几部分，例： http://www.aspxfa
【.NET6+Modbus】Modbus TCP协议解析、仿真环境以及基于.NET实现基础通信
pythonxxoo的博客
04-09 3556
Python微信订餐小程序课程视频 https://edu.csdn.net/course/detail/36074 Python实战量化交易理财系统 https://edu.csdn.net/course/detail/35475 **前言：**随着工业化的发展，目前越来越多的开发，从互联网走向传统行业。其中，工业领域也是其中之一，包括各大厂也都在陆陆续续加入工业4.0的进程当中。 工业领域，最核心的基础设施，应该是与下位硬件设备或程序进行通信有关的了，而下位机市场基本上是PLC的天下。而PLC产品就像编
有限状态机解析HTTP请求
weixin_43327696的博客
05-20 3198
一、HTTP报文 HTTP的报文格式： 起始行 头部字段 空 行 消息正文 其中起始行和头部字段成为Header，消息正文称为body。Header和body之间一定要有空行隔开。 请求行的格式： 如下： GET /index.html HTTP/1.1 请求方法为GET, url为/index.html，版本为HTTP/1.1 而请求头部就是用 key:value 更详细的方式说明HTTP报文。 而我们要做的就是解析这样的http请求，并发送应答报文给客户端。 二、程序结构 recv() 是从套接字中读
node.js解析http请求数据
nyist327的专栏
01-27 2350
最近本人在学习开发NodeJs，使用到express框架，对于网上的学习资料甚少，因此本人会经常在开发中做一些总结。 express获取参数有三种方法：官网介绍如下 Checks route params (req.params), ex: /user/:id Checks query string params (req.query), ex: ?id=12 Chec
基于有限状态机实现http解析
flying_pig_todau的博客
03-27 1036
有限状态机:像类似http协议的应用层协议头部包含很多数据类型的字段, 每种类型字段可以映射为逻辑单元的一种执行状态,根据这些状态编写相应的处理逻辑. 自己的表述:解析http这种协议,他在解析的过程中存在不同的状态, 我们在解析的时候根据解析的内存判断不同状态下不同的处理方法,通过状态的转换,实现对协议的解析. 基本框架就是 switch (type) { case TYPEA: process_type_a(); type = TYPEC; break; case T
有限状态机实现解析HTTP报文
最新发布
qq_42120843的博客
01-19 582
有限状态机实现解析HTTP报文
nodejs解析http协议源码解析
标子 的专栏
03-12 1458
上篇文章讲到nodejs创建一个服务并且建立tcp连接的过程。接下来分析一下，在建立tcp连接后，nodejs是如何解析http协议的。我们首先看一下nodejs在建立tcp连接时执行net.js层的回调时做了什么操作。下面是核心代码。 // clientHandle代表一个和客户端建立tcp连接的实体 function onconnection(err, clientHandle) { va...
JavaScript状态模式及状态机模型
大转转FE
04-20 849
这是一篇，我自己都看不完的文章...文章大体就两部分：状态模式的介绍状态机模型的函数库javascript-state-machine的用法和源码解析场景及问题背景：我们...
js之状态模式
linhongyong的博客
12-02 2008
状态模式level01:电灯程序<!DOCTYPE html> <html lang="en"> <head> <meta charset="UTF-8"> <title>Title</title> </head> <body> <script> var Light = function(){ this.state = 'off'; /
JavaWeb-解析Http协议
weixin_44606952的博客
07-28 949
1、协议的含义？ 2、Http协议是什么？ 3、Http的请求协议 4、Http的响应协议 5、如何向服务器发送GET和POST请求？ 6、GET和POST请求的区别 7、GET请求和POST请求的选择
Lighttpd1.4.20源码分析 笔记 状态机之请求处理
jiange_zh的博客
01-20 1914
lighttpd请求处理的过程：1.服务器与客户端建立连接后，连接进入CON_STATE_REQUEST_START状态，服务器做一些标记，如连接开始的时间等。2.连接进入CON_STATE_READ状态，服务器从连接读取HTTP头并存放在con->requeset.request中。若一次调用没能读取全部数据，连接的状态将继续为READ，继续等待剩下的数据可读。 在对joblist进行处理的时候
BGP协议详解：报文格式与状态机解析
"BGP协议分析_报文和状态机" BGP（边界网关协议）是Internet上用于自治系统（AS）之间交换路由信息的一种外部网关协议，它解决了EGP（边缘网关协议）中的路由环路问题，并支持CIDR（无类型域间路由），以有效管理...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值