在哪里安装 live http headers

Live HTTP Headers 是一个 Firefox 浏览器的插件，可以用来查看 HTTP 请求和响应的头信息。要安装它，请按照以下步骤操作：

1. 打开 Firefox 浏览器，点击右上角的菜单按钮（三条横线）。
2. 选择“附加组件”选项。
3. 在左侧菜单中选择“扩展”，然后在右侧搜索栏中输入“Live HTTP Headers”。
4. 找到 Live HTTP Headers 插件并点击“添加到 Firefox”按钮。
5. 等待插件下载和安装完成后，重新启动 Firefox 浏览器。

安装完成后，可以在 Firefox 浏览器的工具菜单中找到 Live HTTP Headers 插件，并使用它来查看 HTTP 请求和响应的头信息。

相关问题

Error [ERR_HTTP_HEADERS_SENT]: Cannot set headers after they are sent to the client

This error occurs when you are trying to send HTTP headers to the client (i.e. the user's browser) after they have already been sent. Once the headers have been sent, they cannot be modified or sent again.

This error typically occurs when there is a logic error in your code, such as sending headers in a loop or sending headers after the response has already been sent.

To fix this error, you will need to carefully review your code and ensure that you are only sending headers once, and that they are being sent before any response data is sent. You may also need to refactor your code to ensure that headers are only being sent in the appropriate places.

Here are a few tips to help you avoid this error:

1. Make sure that you are not sending headers in a loop or conditional statement that may be executed multiple times.

2. If you are using middleware or other third-party libraries, make sure that they are not sending headers after the response has already been sent.

3. Use a tool like Postman or a browser extension like Live HTTP Headers to inspect the headers that are being sent and received, and look for any anomalies that may be causing the error.

4. If you are still having trouble, try using a debugger to step through your code and identify where the headers are being sent and why they may be causing an error.

lua http 源码

以下是 Lua 5.1 版本的 http 模块源码，可以用来实现 HTTP 客户端请求：

-----------------------------------------------------------------------------
-- LuaSocket module for HTTP/1.1 client support
-- Diego Nehab, et al.
-- 04/11/2007
-----------------------------------------------------------------------------
local base = _G
local string = require("string")
local math = require("math")
local socket = require("socket")
local url = require("socket.url")
module("socket.http")

-- the default user agent string
USERAGENT = "LuaSocket 2.0.2"

-- timeout values
TIMEOUT = 60
TIMEOUT_CONNECT = socket._TIMEOUT

-- code 204 is no content, but the server sent a response header
-- code 304 is not modified, so there's no need to resend the content
-- code 205 is a reset content request, we must accept the new content
-- code 206 is a partial content response, we must adjust our range
-- code 301 is a redirect, we must look for the location header
-- code 302 is a redirect, but some buggy servers send content along
-- code 303 is a redirect, but with a get method
-- code 307 is a redirect, but we must keep the method
-- code 401 is a authentication request, we must resend with proper creds
-- code 407 is a proxy authentication request, same as 401
NOCONTENT_CODES = "204 304 205 206"
REDIRECT_CODES = "301 302 303 307"
AUTHREQUIRED_CODES = "401 407"
DEFAULT_REDIRECT_TIMES = 5
-- the default port for each protocol
PORT = { http = 80, https = 443, }

-- get a connection object
local function get_connection(u, redir)
    local proxy = base._PROXY or socket._PROXY
    local conn = {
        try = socket.tcp(),
        proxy = proxy and url.parse(proxy),
        ssl = u.scheme == "https",
        live = true,
        redirected = false,
        redirectcount = 0,
        redirectstring = "",
        host = u.host,
        port = u.port or PORT[u.scheme],
        method = "GET",
        url = u,
        sink = nil,
        headers = { 
            ["user-agent"] = USERAGENT, 
            ["host"] = u.host,
        },
        source = socket.source("close-when-done", conn.try)
    }
    if conn.proxy then
        conn.host = conn.proxy.host
        conn.port = conn.proxy.port
        conn.headers["host"] = u.authority
    end
    if redir then
        conn.redirected = true
        conn.redirectcount = redir.redirectcount + 1
        conn.redirectstring = redir.redirectstring.."\n"..u.request
    end
    return conn
end

-- close a connection
local function close_connection(c)
    if c.try then c.try:close() end
    c.try = nil
    c.live = nil
end

-- receive a line from a connection or a sink
local function receive(fd, pat, t)
    local st, chunk
    local buffer = {}
    local receive_chunk = fd.receive or fd.read or fd
    t = t or TIMEOUT
    repeat
        st, chunk = receive_chunk(fd, pat)
        if st then
            buffer[#buffer + 1] = chunk
        else
            return nil, chunk
        end
    until string.find(buffer[#buffer] or "", pat, nil, true) or st == nil
    return table.concat(buffer)
end

-- send data through a connection or a source
local function send(fd, data)
    if not fd.send then
        if type(fd) ~= "function" then
            error("invalid send source")
        end
        fd(data)
    else
        fd:send(data)
    end
end

-- convert headers to a string
local function headers_to_string(headers)
    local buffer = {}
    for field, value in pairs(headers) do
        buffer[#buffer + 1] = string.format("%s: %s", field, value)
    end
    buffer[#buffer + 1] = ""
    return table.concat(buffer, "\r\n")
end

-- convert headers from a string to a table
local function headers_from_string(header_string)
    local headers = {}
    local pos = 1
    local eol = string.find(header_string, "\n", pos, true)
    while eol do
        local line = string.sub(header_string, pos, eol - 1)
        line = string.gsub(line, "[\r\n]+$", "")
        pos = eol + 1
        eol = string.find(header_string, "\n", pos, true)
        if line ~= "" then
            local field, value = string.match(line, "^(.-):%s*(.*)$")
            if field then
                field = string.lower(field)
                if headers[field] then
                    headers[field] = headers[field]..", "..value
                else
                    headers[field] = value
                end
            end
        else
            break
        end
    end
    return headers
end

-- perform a generic HTTP request
local function request(req)
    local u = url.parse(req.url)
    local c = get_connection(u, req.redirection)
    if not c.try then return nil, "unable to connect to "..u.host end
    c.try:settimeout(TIMEOUT_CONNECT, "t")
    local res = { }
    local pat = "^(.-)\r?\n"
    -- send request line
    local reqline = string.format("%s %s HTTP/1.1", req.method, u.path or "/")
    if u.query then reqline = reqline.."?"..u.query end
    send(c.try, string.format("%s\r\n", reqline))
    -- add headers
    if req.source then
        c.headers["transfer-encoding"] = "chunked"
        c.headers["connection"] = "close"
        c.headers["expect"] = "100-continue"
    end
    for i, header in ipairs(req.headers) do
        local name, value = string.match(header, "^(.-):%s*(.*)$")
        if name then
            c.headers[string.lower(name)] = value
        end
    end
    if not c.headers["host"] then
        c.headers["host"] = u.authority
    end
    send(c.try, headers_to_string(c.headers))
    send(c.try, "\r\n")
    -- send request body
    if req.source then
        local source = req.source
        while true do
            local chunk = source()
            if not chunk then
                send(c.try, "0\r\n\r\n")
                break
            end
            send(c.try, string.format("%x\r\n", string.len(chunk)))
            send(c.try, chunk)
            send(c.try, "\r\n")
        end
    end
    c.try:settimeout(TIMEOUT, "t")
    -- receive response
    local status
    local headers = {}
    local body
    status = receive(c.try, pat)
    if status then
        local ver, code, message = string.match(status, "^(%S+)%s+(%S+)%s+(.-)\r?$")
        if ver and code and message then
            status = {
                major = tonumber(string.match(ver, "HTTP/(%d)%.%d")),
                minor = tonumber(string.match(ver, "HTTP/%d%.(%d)")),
                code = tonumber(code),
                message = message
            }
            -- receive headers
            local header_string, err = receive(c.try, "\r?\n\r?\n")
            if header_string then
                headers = headers_from_string(header_string)
                -- handle 100 Continue responses
                if status.code == 100 then
                    status, headers, body = request(req)
                -- handle 300 redirects
                elseif string.find(REDIRECT_CODES, code, 1, true) then
                    local location = headers.location
                    if location then
                        location = url.absolute(u, location)
                        if req.redirection then
                            if req.redirection.redirectcount >= DEFAULT_REDIRECT_TIMES then
                                return nil, "too many redirections"
                            end
                            if req.redirection.redirectstring:find(location.request, 1, true) then
                                return nil, "infinite redirection loop"
                            end
                        else
                            req.redirection = {
                                redirectcount = 0,
                                redirectstring = req.url.request,
                            }
                        end
                        req.url = location
                        close_connection(c)
                        return request(req)
                    end
                -- handle 401 and 407 authentication requests
                elseif string.find(AUTHREQUIRED_CODES, code, 1, true) then
                    if req.auth and c.headers.authorization then
                        return nil, "invalid authentication credentials"
                    end
                    local auth = headers["www-authenticate"] 
                        or headers["proxy-authenticate"]
                    if auth then
                        local realm = string.match(auth, "realm=\"([^\"]*)\"")
                        if not realm then
                            realm = string.match(auth, "realm=([^,]*)")
                        end
                        if realm then
                            local user, password = req.auth(realm)
                            if user then
                                c.headers.authorization = 
                                    socket.try(socket.url.build({ 
                                        scheme = "basic", 
                                        user = user, 
                                        password = password 
                                    }))
                                close_connection(c)
                                return request(req)
                            end
                        end
                    end
                end
                -- get response body
                local length = tonumber(headers["content-length"])
                if headers["transfer-encoding"] == "chunked" then
                    local decoder = socket.protect(function(chunk)
                        local size = tonumber(chunk, 16)
                        if size == 0 then return "" end
                        return receive(c.try, string.format("^([^\r\n]*)\r?\n(.*)\r?\n.{0,%d}$", size - 1), TIMEOUT)
                    end)
                    body = socket.sink("into-string")
                    while true do
                        local chunk, err = decoder()
                        if err or chunk == "" then break end
                        body(chunk)
                    end
                elseif length then
                    body = receive(c.try, string.format("^%(.{%d})$", length), TIMEOUT)
                elseif headers.connection == "close" then
                    body = receive(c.try, nil, TIMEOUT)
                end
            end
        else
            status = nil
        end
        if not status then
            close_connection(c)
            return nil, "invalid server response"
        end
        res.status = status
        res.headers = headers
        res.body = body
        res.request = req
        return res
    else
        close_connection(c)
        return nil, "unable to receive status line"
    end
end

-- HTTP/1.1 methods
function request_uri(u, req)
    req = req or {}
    req.method = req.method or "GET"
    req.headers = req.headers or {}
    req.url = url.absolute(u, req.url)
    return request(req)
end

function request_string(u, s)
    local req = {
        method = "GET",
        headers = {},
        url = u,
        source = socket.source("string", s),
    }
    req.headers["content-length"] = string.len(s)
    return request(req)
end

function request_file(u, f)
    local req = {
        method = "PUT",
        headers = {},
        url = u,
        source = socket.source("file", f),
    }
    req.headers["content-length"] = socket.filesize(f)
    return request(req)
end

-- HTTP/1.0.0 methods
function get(u, headers)
    return request_uri(u, { method = "GET", headers = headers or {} })
end

function post(u, body, headers)
    return request_uri(u, { 
        method = "POST", 
        headers = headers or {},
        source = socket.source("string", body),
    })
end

function put(u, body, headers)
    return request_uri(u, { 
        method = "PUT", 
        headers = headers or {},
        source = socket.source("string", body),
    })
end

function delete(u, headers)
    return request_uri(u, { method = "DELETE", headers = headers or {} })
end

function options(u, headers)
    return request_uri(u, { method = "OPTIONS", headers = headers or {} })
end

function trace(u, headers)
    return request_uri(u, { method = "TRACE", headers = headers or {} })
end

-- exports
_headers_to_string = headers_to_string
_headers_from_string = headers_from_string

该模块提供了一系列 HTTP 请求方法，可以根据需要进行调用。其中，`request_uri` 方法可以实现对 URL 的请求，`get`、`post`、`put`、`delete`、`options`、`trace` 方法则分别对应了 HTTP 协议中的常见请求方法。