18-HTTP

    // 开始解析HTTP协议
    int llhttp__on_message_begin(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_message_begin, s);  
      return err;  
    }  

    // 解析出请求url时的回调，最后拿到一个url
    int llhttp__on_url(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_url, s, p, endp - p);  
      return err;  
    }  

    // 解析出HTTP响应状态的回调
    int llhttp__on_status(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_status, s, p, endp - p);  
      return err;  
    }  

    // 解析出头部键时的回调
    int llhttp__on_header_field(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_header_field, s, p, endp - p);  
      return err;  
    }  

    // 解析出头部值时的回调
    int llhttp__on_header_value(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_header_value, s, p, endp - p);  
      return err;  
    }  

    // 解析HTTP头完成时的回调  
    int llhttp__on_headers_complete(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_headers_complete, s);  
      return err;  
    }  

    // 解析完body的回调 
    int llhttp__on_message_complete(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_message_complete, s);  
      return err;  
    }  

    // 解析body时的回调
    int llhttp__on_body(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_body, s, p, endp - p);  
      return err;  
    }  

     // 解析到一个chunk结构头时的回调 
    int llhttp__on_chunk_header(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_chunk_header, s);  
      return err;  
    }  

    // 解析完一个chunk时的回调  
    int llhttp__on_chunk_complete(llhttp_t* s, const char* p, const char* endp) {  
      int err;  
      CALLBACK_MAYBE(s, on_chunk_complete, s);  
      return err;  
    }  

    Local<FunctionTemplate> t=env->NewFunctionTemplate(Parser::New); 
    t->InstanceTemplate()->SetInternalFieldCount(1);  
    t->SetClassName(FIXED_ONE_BYTE_STRING(env->isolate(), 
                      "HTTPParser"));  
    target->Set(env->context(),  
      FIXED_ONE_BYTE_STRING(env->isolate(), "HTTPParser"),   
      t->GetFunction(env->context()).ToLocalChecked()).Check();  

      const parser = new HTTPParser();  

      cleanParser(parser);  
      parser.onIncoming = null;  
      parser[kOnHeaders] = parserOnHeaders;  
      parser[kOnHeadersComplete] = parserOnHeadersComplete;  
      parser[kOnBody] = parserOnBody;  
      parser[kOnMessageComplete] = parserOnMessageComplete; 
      // 初始化HTTP解析器处理的报文类型，这里是响应报文
      parser.initialize(HTTPParser.RESPONSE,
         new HTTPClientAsyncResource('HTTPINCOMINGMESSAGE', req),
         req.maxHeaderSize || 0,
         req.insecureHTTPParser === undefined ?
         isLenient() : req.insecureHTTPParser); 
      // 收到数据后传给解析器处理
      const ret = parser.execute(data);
    }  

    static void Initialize(const FunctionCallbackInfo<Value>& args) {
       Environment* env = Environment::GetCurrent(args);  
       bool lenient = args[3]->IsTrue();  

       uint64_t max_http_header_size = 0;  
       // 头部的最大大小  
       if (args.Length() > 2) {  
         max_http_header_size = args[2].As<Number>()->Value();  
       }  
       // 没有设置则取Node.js的默认值  
       if (max_http_header_size == 0) {  
         max_http_header_size=env->options()->max_http_header_size;
       }  
       // 解析的报文类型  
       llhttp_type_t type =  
           static_cast<llhttp_type_t>(args[0].As<Int32>()->Value());

       CHECK(type == HTTP_REQUEST || type == HTTP_RESPONSE);  
       Parser* parser;  
       ASSIGN_OR_RETURN_UNWRAP(&parser, args.Holder());  
       parser->Init(type, max_http_header_size, lenient);  
     }  

    void Init(llhttp_type_t type, uint64_t max_http_header_size, bool lenient) {  
       // 初始化llhttp  
       llhttp_init(&parser_, type, &settings);  
       llhttp_set_lenient(&parser_, lenient);  
       header_nread_ = 0;  
       url_.Reset();  
       status_message_.Reset();  
       num_fields_ = 0;  
       num_values_ = 0;  
      have_flushed_ = false;  
      got_exception_ = false;  
      max_http_header_size_ = max_http_header_size;  
    }  

    const llhttp_settings_t Parser::settings = {  
      Proxy<Call, &Parser::on_message_begin>::Raw,  
      Proxy<DataCall, &Parser::on_url>::Raw,  
      Proxy<DataCall, &Parser::on_status>::Raw,  
      Proxy<DataCall, &Parser::on_header_field>::Raw,  
      Proxy<DataCall, &Parser::on_header_value>::Raw,  
      Proxy<Call, &Parser::on_headers_complete>::Raw,  
      Proxy<DataCall, &Parser::on_body>::Raw,  
      Proxy<Call, &Parser::on_message_complete>::Raw,  
     Proxy<Call, &Parser::on_chunk_header>::Raw,  
     Proxy<Call, &Parser::on_chunk_complete>::Raw,  
    };  

      // 开始解析报文，一个TCP连接可能会有多个报文  
      int on_message_begin() {  
        num_fields_ = num_values_ = 0;  
        url_.Reset();  
        status_message_.Reset();  
        return 0;  
      }  

    int on_url(const char* at, size_t length) {  
        int rv = TrackHeader(length);  
        if (rv != 0) {  
          return rv;  
        }  

        url_.Update(at, length);  
        return 0;  
      }  

    int on_status(const char* at, size_t length) {  
       int rv = TrackHeader(length);  
       if (rv != 0) {  
         return rv;  
       }  

       status_message_.Update(at, length);  
       return 0;  
     }  

    int on_header_field(const char* at, size_t length) {  
        int rv = TrackHeader(length);  
        if (rv != 0) {  
          return rv;  
        }  
        // 相等说明键对值的解析是一一对应的  
        if (num_fields_ == num_values_) {  
          // start of new field name  
          // 键的数加一  
          num_fields_++;  
          // 超过阈值则先回调js消费掉  
          if (num_fields_ == kMaxHeaderFieldsCount) {  
            // ran out of space - flush to javascript land  
            Flush();  
            // 重新开始  
            num_fields_ = 1;  
            num_values_ = 0;  
          }  
          // 初始化  
          fields_[num_fields_ - 1].Reset();  
        }  

        // 保存键  
        fields_[num_fields_ - 1].Update(at, length);  

        return 0;  
    }  

    void Flush() {  
        HandleScope scope(env()->isolate());  

        Local<Object> obj = object();  
        // JS层的钩子  
        Local<Value> cb = obj->Get(env()->context(), kOnHeaders).ToLocalChecked();  
        if (!cb->IsFunction())  
          return;  

        Local<Value> argv[2] = {  
          CreateHeaders(),  
          url_.ToString(env())  
        };  

        MaybeLocal<Value> r = MakeCallback(cb.As<Function>(),  
                                           arraysize(argv),  
                                           argv);  
        url_.Reset();  
        have_flushed_ = true;  
      } 

    Local<Array> CreateHeaders() {  
       // HTTP头的个数乘以2，因为一个头由键和值组成  
       Local<Value> headers_v[kMaxHeaderFieldsCount * 2];  
       // 保存键和值到HTTP头  
       for (size_t i = 0; i < num_values_; ++i) {  
         headers_v[i * 2] = fields_[i].ToString(env());  
         headers_v[i * 2 + 1] = values_[i].ToString(env());  
       }  

       return Array::New(env()->isolate(), headers_v, num_values_ * 2);  
     }  

    int on_header_value(const char* at, size_t length) {  
       int rv = TrackHeader(length);  
       if (rv != 0) {  
         return rv;  
       }  
       /* 
         值的个数不等于键的个数说明正解析到键对应的值，即一一对应。 
         否则说明一个键存在多个值，则不更新值的个数，多个值累加到一个slot 
       */  
       if (num_values_ != num_fields_) {  
         // start of new header value  
         num_values_++;  
         values_[num_values_ - 1].Reset();  
       }  

       CHECK_LT(num_values_, arraysize(values_));  
       CHECK_EQ(num_values_, num_fields_);  

       values_[num_values_ - 1].Update(at, length);  

       return 0;  
     }  

    int on_headers_complete() {  
        header_nread_ = 0;   
        enum on_headers_complete_arg_index {  
           A_VERSION_MAJOR = 0,  
           A_VERSION_MINOR,  
           A_HEADERS,  
           A_METHOD,  
           A_URL,  
           A_STATUS_CODE,  
          A_STATUS_MESSAGE,  
          A_UPGRADE,  
          A_SHOULD_KEEP_ALIVE,  
          A_MAX  
        };  

        Local<Value> argv[A_MAX];  
        Local<Object> obj = object();  
        Local<Value> cb = obj->Get(env()->context(),  
                                   kOnHeadersComplete).ToLocalChecked();  

        Local<Value> undefined = Undefined(env()->isolate());  
        for (size_t i = 0; i < arraysize(argv); i++)  
          argv[i] = undefined;  
        // 之前flush过，则继续flush到JS层，否则返回全部头给js  
        if (have_flushed_) {  
          // Slow case, flush remaining headers.  
          Flush();  
        } else {  
          // Fast case, pass headers and URL to JS land.  
          argv[A_HEADERS] = CreateHeaders();  
          if (parser_.type == HTTP_REQUEST)  
            argv[A_URL] = url_.ToString(env());  
        }  

        num_fields_ = 0;  
        num_values_ = 0;  

        // METHOD  
        if (parser_.type == HTTP_REQUEST) {  
          argv[A_METHOD] =  
              Uint32::NewFromUnsigned(env()->isolate(), parser_.method);  
        }  

        // STATUS  
        if (parser_.type == HTTP_RESPONSE) {  
          argv[A_STATUS_CODE] =  
              Integer::New(env()->isolate(), parser_.status_code);  
          argv[A_STATUS_MESSAGE] = status_message_.ToString(env());  
        }  

        // VERSION  
        argv[A_VERSION_MAJOR] = Integer::New(env()->isolate(), parser_.http_major);  
        argv[A_VERSION_MINOR] = Integer::New(env()->isolate(), parser_.http_minor);  

        bool should_keep_alive;  
        // 是否定义了keepalive头  
        should_keep_alive = llhttp_should_keep_alive(&parser_);  

        argv[A_SHOULD_KEEP_ALIVE] =  
            Boolean::New(env()->isolate(), should_keep_alive);  
        // 是否是升级协议  
        argv[A_UPGRADE] = Boolean::New(env()->isolate(), parser_.upgrade);  

        MaybeLocal<Value> head_response;  
        {  
          InternalCallbackScope callback_scope(  
              this, InternalCallbackScope::kSkipTaskQueues);  
          head_response = cb.As<Function>()->Call(  
              env()->context(), object(), arraysize(argv), argv);  
        }  

        int64_t val;  

        if (head_response.IsEmpty() || !head_response.ToLocalChecked()  
                                            ->IntegerValue(env()->context())  
                                            .To(&val)) {  
          got_exception_ = true;  
          return -1;  
        }  

        return val;  
      }  

    int on_body(const char* at, size_t length) {  
       EscapableHandleScope scope(env()->isolate());  

       Local<Object> obj = object();  
       Local<Value> cb = obj->Get(env()->context(), kOnBody).ToLocalChecked();  

       // We came from consumed stream  
       if (current_buffer_.IsEmpty()) {  
         // Make sure Buffer will be in parent HandleScope  
         current_buffer_ = scope.Escape(Buffer::Copy(  
             env()->isolate(),  
             current_buffer_data_,  
             current_buffer_len_).ToLocalChecked());  
       }  

       Local<Value> argv[3] = {  
         // 当前解析中的数据  
         current_buffer_,  
         // body开始的位置  
         Integer::NewFromUnsigned(env()->isolate(), at - current_buffer_data_),  
         // body当前长度  
         Integer::NewFromUnsigned(env()->isolate(), length)  
       };  

       MaybeLocal<Value> r = MakeCallback(cb.As<Function>(),  
                                          arraysize(argv),  
                                          argv);   

       return 0;  
     }  

    class FreeList {  
      constructor(name, max, ctor) {  
        this.name = name;  
        // 构造函数  
        this.ctor = ctor;  
        // 节点的最大值  
        this.max = max;  
        // 实例列表  
        this.list = [];  
      }  
      // 分配一个实例  
      alloc() {  
        // 有空闲的则直接返回，否则新建一个  
        return this.list.length > 0 ?  
          this.list.pop() :  
          ReflectApply(this.ctor, this, arguments);  
      }  
      // 释放实例  
      free(obj) {  
        // 小于阈值则放到空闲列表，否则释放（调用方负责释放）  
        if (this.list.length < this.max) {  
          this.list.push(obj);  
          return true;  
        }  
        return false;  
      }  
    }  

    const parsers = new FreeList('parsers', 1000, function parsersCb() {  
      const parser = new HTTPParser();  
      // 初始化字段  
      cleanParser(parser);  
      // 设置钩子  
      parser.onIncoming = null;  
      parser[kOnHeaders] = parserOnHeaders;  
      parser[kOnHeadersComplete] = parserOnHeadersComplete;  
      parser[kOnBody] = parserOnBody;  
      parser[kOnMessageComplete] = parserOnMessageComplete;  

      return parser;  
    });  

    var HTTPParser = process.binding('http_parser').HTTPParser;  
    var parser = new HTTPParser(HTTPParser.REQUEST);  

    const kOnHeaders = HTTPParser.kOnHeaders;  
    const kOnHeadersComplete = HTTPParser.kOnHeadersComplete;  
    const kOnBody = HTTPParser.kOnBody;  
    const kOnMessageComplete = HTTPParser.kOnMessageComplete;  
    const kOnExecute = HTTPParser.kOnExecute;  

    parser[kOnHeaders] = function(headers, url) {  
        console.log('kOnHeaders', headers.length, url);  
    }  
    parser[kOnHeadersComplete] = function(versionMajor, versionMinor, headers, method,  
             url, statusCode, statusMessage, upgrade, shouldKeepAlive) {  
        console.log('kOnHeadersComplete', headers);  
    }  

    parser[kOnBody] = function(b, start, len) {  
        console.log('kOnBody', b.slice(start).toString('utf-8'));  
    }  
    parser[kOnMessageComplete] = function() {  
        console.log('kOnMessageComplete');  
    }  
    parser[kOnExecute] = function() {  
        console.log('kOnExecute');  
    }  

    parser.execute(Buffer.from(  
        'GET / HTTP/1.1\r\n' +  
        'Host: http://localhost\r\n\r\n'   
    ));  

    kOnHeadersComplete [ 'Host', 'http://localhost' ]  
    kOnMessageComplete  

    parser.execute(Buffer.from(  
        'GET / HTTP/1.1\r\n' +  
        'Host: http://localhost\r\n' +  
        'content-length: 1\r\n\r\n'+  
        '1'  
    ));  

    kOnHeadersComplete [ 'Host', 'http://localhost', 'content-length', '1' ]  
    kOnBody 1  
    kOnMessageComplete  

    parser.execute(Buffer.from(  
        'GET / HTTP/1.1\r\n' +  
        'Host: http://localhost\r\n' +  
        'a: b\r\n'+  
         // 很多'a: b\r\n'+
        'content-length: 1\r\n\r\n'+  
        '1'  
    ));  

    kOnHeaders 62 /  
    kOnHeaders 22  
    kOnHeadersComplete undefined  
    kOnBody 1  
    kOnMessageComplete  

    var HTTPParser = process.binding('http_parser').HTTPParser;  
    var parser = new HTTPParser(HTTPParser.REQUEST);  
    var net = require('net');  

    const kOnHeaders = HTTPParser.kOnHeaders;  
    const kOnHeadersComplete = HTTPParser.kOnHeadersComplete;  
    const kOnBody = HTTPParser.kOnBody;  
    const kOnMessageComplete = HTTPParser.kOnMessageComplete;  
    const kOnExecute = HTTPParser.kOnExecute;  

    parser[kOnHeaders] = function(headers, url) {  
        console.log('kOnHeaders', headers.length, url);  
    }  
    parser[kOnHeadersComplete] = function(versionMajor, versionMinor, headers, method,  
             url, statusCode, statusMessage, upgrade, shouldKeepAlive) {  
        console.log('kOnHeadersComplete', headers);  
    }  

    parser[kOnBody] = function(b, start, len) {  
        console.log('kOnBody', b.slice(start).toString('utf-8'));  
    }  
    parser[kOnMessageComplete] = function() {  
        console.log('kOnMessageComplete');  
    }  
    parser[kOnExecute] = function(a,b) {  
        console.log('kOnExecute,解析的字节数：',a);  
    }  
    // 启动一个服务器  
    net.createServer((socket) => {  
      parser.consume(socket._handle);  
    }).listen(80);  

    // 启动一个客户端  
    setTimeout(() => {  
      var socket = net.connect({port: 80});  
      socket.end('GET / HTTP/1.1\r\n' +  
        'Host: http://localhost\r\n' +  
        'content-length: 1\r\n\r\n'+  
        '1');  
    }, 1000);  

    const data = querystring.stringify({  
      'msg': 'hi'  
    });  

    const options = {  
      hostname: 'your domain',  
      path: '/',  
      method: 'POST',  
      headers: {  
        'Content-Type': 'application/x-www-form-urlencoded',  
        'Content-Length': Buffer.byteLength(data)  
      }  
    };  

    const req = http.request(options, (res) => {  
      res.setEncoding('utf8');  
      res.on('data', (chunk) => {  
        console.log(`${chunk}`);  
      });  
      res.on('end', () => {  
        console.log('end');  
      });  
    });  

    req.on('error', (e) => {  
      console.error(`${e.message}`);  
    });  
    // 发送请求的数据  
    req.write(data);  
    // 设置请求结束  
    req.end();  

    function request(url, options, cb) {  
      return new ClientRequest(url, options, cb);  
    }  

    function ClientRequest(input, options, cb) {  
      // 继承OutgoingMessage  
      OutgoingMessage.call(this);  
      // 是否使用agent  
      let agent = options.agent;   
      // 忽略agent的处理，具体参考_http_agent.js，主要用于复用TCP连接  
      this.agent = agent;  
      // 建立连接的超时时间  
      if (options.timeout !== undefined)  
        this.timeout = getTimerDuration(options.timeout, 'timeout');  
      // HTTP头个数的阈值  
      const maxHeaderSize = options.maxHeaderSize;  
      this.maxHeaderSize = maxHeaderSize;  
      // 监听响应事件  
      if (cb) {  
        this.once('response', cb);  
      }  
      // 忽略设置http协议的请求行或请求头的逻辑
      // 建立TCP连接后的回调  
      const oncreate = (err, socket) => {  
        if (called)  
          return;  
        called = true;  
        if (err) {  
          process.nextTick(() => this.emit('error', err));  
          return;  
        }  
        // 建立连接成功，执行回调  
        this.onSocket(socket);  
        // 连接成功后发送数据  
        this._deferToConnect(null, null, () => this._flush());  
      };  

      // 使用agent时，socket由agent提供，否则自己创建socket  
      if (this.agent) {  
        this.agent.addRequest(this, options);  
      } else {  
        // 不使用agent则每次创建一个socket，默认使用net模块的接口
        if (typeof options.createConnection === 'function') {  
          const newSocket = options.createConnection(options, 
                                                          oncreate);  
          if (newSocket && !called) {  
            called = true;  
            this.onSocket(newSocket);  
          } else {  
            return;  
          }  
        } else {  
          this.onSocket(net.createConnection(options));  
        }  
      }  
      // 连接成功后发送待缓存的数据  
      this._deferToConnect(null, null, () => this._flush());  
    }  

    // socket可用时的回调  
    ClientRequest.prototype.onSocket = function onSocket(socket) {  
      process.nextTick(onSocketNT, this, socket);  
    };  

    function onSocketNT(req, socket) {  
      // 申请socket过程中，请求已经终止  
      if (req.aborted) {
        // 不使用agent，直接销毁socekt  
        if (!req.agent) {  
          socket.destroy();  
        } else {  
          // 使用agent触发free事件，由agent处理socekt  
          req.emit('close');  
          socket.emit('free');  
        }  
      } else {  
        // 处理socket  
        tickOnSocket(req, socket);  
      }  
    }  

    // 初始化HTTP解析器和注册data事件等，等待响应  
    function tickOnSocket(req, socket) {  
      // 分配一个HTTP解析器  
      const parser = parsers.alloc();  
      req.socket = socket;  
      // 初始化，处理响应报文  
      parser.initialize(HTTPParser.RESPONSE,  
             new HTTPClientAsyncResource('HTTPINCOMINGMESSAGE', req),          req.maxHeaderSize || 0,  
             req.insecureHTTPParser === undefined ?  
            isLenient() : req.insecureHTTPParser);  
      parser.socket = socket;  
      parser.outgoing = req;  
      req.parser = parser;  

      socket.parser = parser;  
      // socket正处理的请求  
      socket._httpMessage = req;  

      // Propagate headers limit from request object to parser  
      if (typeof req.maxHeadersCount === 'number') {  
        parser.maxHeaderPairs = req.maxHeadersCount << 1;  
      }  
      // 解析完HTTP头部的回调  
      parser.onIncoming = parserOnIncomingClient;  
      socket.removeListener('error', freeSocketErrorListener);  
      socket.on('error', socketErrorListener);  
      socket.on('data', socketOnData);  
      socket.on('end', socketOnEnd);  
      socket.on('close', socketCloseListener);  
      socket.on('drain', ondrain);  

      if (  
        req.timeout !== undefined ||  
        (req.agent && req.agent.options && 
         req.agent.options.timeout)  
      ) {  
        // 处理超时时间  
        listenSocketTimeout(req);  
      }  
      req.emit('socket', socket);  
    }  

    function listenSocketTimeout(req) {  
      // 设置过了则返回  
      if (req.timeoutCb) {  
        return;  
      }  
      // 超时回调  
      req.timeoutCb = emitRequestTimeout;  
      // Delegate socket timeout event.  
      // 设置socket的超时时间，即socket上一定时间后没有响应则触发超时  
      if (req.socket) {  
        req.socket.once('timeout', emitRequestTimeout);  
      } else {  
        req.on('socket', (socket) => {  
          socket.once('timeout', emitRequestTimeout);  
        });  
      }  
    }  

    function emitRequestTimeout() {  
      const req = this._httpMessage;  
      if (req) {  
        req.emit('timeout');  
      }  
    }  

    function socketOnData(d) {  
      const socket = this;  
      const req = this._httpMessage;  
      const parser = this.parser;  
      // 交给HTTP解析器处理  
      const ret = parser.execute(d);  
      // ...  
    }  

    function parserOnHeaders(headers, url) {  
      // 保存头和url  
      if (this.maxHeaderPairs <= 0 ||  
          this._headers.length < this.maxHeaderPairs) {  
        this._headers = this._headers.concat(headers);  
      }  
      this._url += url;
    }  

    function parserOnHeadersComplete(versionMajor, 
                                        versionMinor, 
                                        headers, 
                                        method,  
                                     url, 
                                        statusCode, 
                                        statusMessage, 
                                        upgrade,  
                                     shouldKeepAlive) {  
      const parser = this;  
      const { socket } = parser;  
      // 剩下的HTTP头  
      if (headers === undefined) {  
        headers = parser._headers;  
        parser._headers = [];  
      }  

      if (url === undefined) {  
        url = parser._url;  
        parser._url = '';  
      }  

      // Parser is also used by http client  
      // IncomingMessage  
      const ParserIncomingMessage=(socket && 
                                      socket.server &&  
                                   socket.server[kIncomingMessage]
                                      ) ||                                 
                                      IncomingMessage;  
      // 新建一个IncomingMessage对象  
      const incoming = parser.incoming = new ParserIncomingMessage(socket);  
      incoming.httpVersionMajor = versionMajor;  
      incoming.httpVersionMinor = versionMinor;  
      incoming.httpVersion = `${versionMajor}.${versionMinor}`;  
      incoming.url = url;  
      incoming.upgrade = upgrade;  

      let n = headers.length;  
      // If parser.maxHeaderPairs <= 0 assume that there's no limit.
      if (parser.maxHeaderPairs > 0)  
        n = MathMin(n, parser.maxHeaderPairs);  
      // 更新到保存HTTP头的对象   
      incoming._addHeaderLines(headers, n);  
      // 请求方法或响应行信息  
      if (typeof method === 'number') {  
        // server only  
        incoming.method = methods[method];  
      } else {  
        // client only  
        incoming.statusCode = statusCode;  
        incoming.statusMessage = statusMessage;  
      }  
      // 执行回调  
      return parser.onIncoming(incoming, shouldKeepAlive);  
    }  

    function parserOnIncomingClient(res, shouldKeepAlive) {  
      const socket = this.socket;  
      // 请求对象  
      const req = socket._httpMessage;  
      // 服务器发送了多个响应  
      if (req.res) {  
        socket.destroy();  
        return 0;    
      }  
      req.res = res;  

      if (statusIsInformational(res.statusCode)) {  
        req.res = null;   
        // 请求时设置了expect头，则响应码为100，可以继续发送数据  
        if (res.statusCode === 100) {  
          req.emit('continue');  
        }  
        return 1;   
      }  

      req.res = res;  
      res.req = req;  

      // 等待响应结束，响应结束后会清除定时器  
      res.on('end', responseOnEnd);  
      // 请求终止了或触发response事件，返回false说明没有监听response事件，则丢弃数据  
      if (req.aborted || !req.emit('response', res))  
        res._dump();  

    }  

    http. request('domain', { agent }, (res) => {  
        // 解析body
        res.on('data', (data) => {  
          //   
        });
         // 解析body结束，响应结束
         res.on('end', (data) => {  
          //   
        });  
    });  
    // ...

    function parserOnBody(b, start, len) {  
      const stream = this.incoming;  
      if (len > 0 && !stream._dumped) {  
        const slice = b.slice(start, start + len);  
        // 把数据push到流中，流会触发data事件  
        const ret = stream.push(slice);  
        // 数据过载，暂停接收  
        if (!ret)  
          readStop(this.socket);  
      }  
    }  

    function parserOnMessageComplete() {  
      const parser = this;  
      const stream = parser.incoming;  

      if (stream !== null) {  
        // body解析完了  
        stream.complete = true;  
        // 在body后可能有trailer头，保存下来  
        const headers = parser._headers;  
        if (headers.length) {  
          stream._addHeaderLines(headers, headers.length);  
          parser._headers = [];  
          parser._url = '';  
        }  
        // 流结束  
        stream.push(null);  
      }  

      // 读取下一个响应，如果有的话  
      readStart(parser.socket);  
    }  

    OutgoingMessage.prototype.write = function write(chunk, encoding, callback) {  
      const ret = write_(this, chunk, encoding, callback, false);  
      // 返回false说明需要等待drain事件  
      if (!ret)  
        this[kNeedDrain] = true;  
      return ret;  
    };  

    function write_(msg, chunk, encoding, callback, fromEnd) {  

      // 还没有设置this._header字段，则把请求行和HTTP头拼接到this._header字段  
      if (!msg._header) {  
        msg._implicitHeader();  
      }  

      let ret;  
      // chunk模式则需要额外加一下字段，否则直接发送  
      if (msg.chunkedEncoding && chunk.length !== 0) {  
        let len;  
        if (typeof chunk === 'string')  
          len = Buffer.byteLength(chunk, encoding);  
        else  
          len = chunk.length;  
        /* 
          chunk模式时，http报文的格式如下 
          chunk长度 回车换行 
          数据 回车换行 
        */  
        msg._send(len.toString(16), 'latin1', null);  
        msg._send(crlf_buf, null, null);  
        msg._send(chunk, encoding, null);  
        ret = msg._send(crlf_buf, null, callback);  
      } else {  
        ret = msg._send(chunk, encoding, callback);  
      }  

      return ret;  
    }