http 转发并阻止域

本篇文章主要是结合我之前面试的各种经历和实战开发中遇到的问题解决经验整理的，希望这篇《http 转发并阻止域》对你有很大帮助！欢迎收藏，分享给更多的需要的朋友学习~

我正在尝试实现一个支持域阻止的http转发服务器。我试过了

go io.copy(dst, src)
go io.copy(src, dst)

它在 tcp 转发上就像一个魅力。然后我尝试使用类似的内容进行请求行解析

go func(){
    reader := io.teereader(src, dst)
    textreader := textproto.newreader(bufio.newreader(reader))
    requestline, _ = textreader.readline()
    // ...
    ioutil.readall(reader)
}

它工作正常，但我担心性能不佳（使用 ioutil.readall）。所以我写了下面的代码。

func (f *Forwarder) handle(src, dst net.Conn) {
    defer dst.Close()
    defer src.Close()
    done := make(chan struct{})
    go func() {
        textReader := bufio.NewReader(src)
        requestLine, _ = textReader.ReadString('\n')
        // parse request line and apply domain blocking
        dst.Write([]byte(requestLine))
        io.Copy(dst, src)
        done <- struct{}{}
    }()
    go func() {
        textReader := bufio.NewReader(dst)
        s.statusLine, _ = textReader.ReadString('\n')
        src.Write([]byte(s.statusLine))
        io.Copy(src, dst)
        done <- struct{}{}
    }()
    <-done
    <-done
}

不幸的是，它根本不起作用。请求可以打印出来，但不能打印响应。我被困在这里，不知道出了什么问题。

解决方案

tcp转发是为了实现隧道代理不需要解析数据。反向代理可以使用standard library。

隧道代理的实现是为了分离http和https协议。客户端一般使用隧道发送https，发送connect方法。发送http是get方法。对于https请求服务，只有dail创建连接tcp转换，http请求使用反向代理实现。

func(w http.responsewriter, r *http.request) {
    // check url host
    if r.url.host != "" {
        if r.method == eudore.methodconnect {
            // tunnel proxy
            conn, err := net.dial("tcp", r.url.host)
            if err != nil {
                w.writeheader(502)
                return
            }

            client, _, err := w.hijack()
            if err != nil {
                w.writeheader(502)
                conn.close()
                return
            }
            client.write([]byte("http/1.0 200 ok\r\n\r\n"))
            go func() {
                io.copy(client, conn)
                client.close()
                conn.close()
            }()
            go func() {
                io.copy(conn, client)
                client.close()
                conn.close()
            }()
        } else {
            // reverse proxy
            httputil.newsinglehostreverseproxy(r.url).servehttp(w, r)
        }
    }
}

实现反向代理会解析客户端请求，代理会将请求发送到目标服务器。

反向代理转换请求，未测试：

func(w http.responsewriter, r *http.request) {
    // set host
    r.url.scheme = "http"
    r.url.path = "example.com"
    // send
    resp,err := http.defaultclient.do(r)
    if err != nil {
        w.writeheader(502)
        return
    }

    // write respsonse
    defer resp.body.close()
    w.writeheader(resp.statuscode)
    h := w.header()
    for k,v := range resp.header {
        h[k]=v
    }
    io.copy(w, resp.body)
}

但是，直接转发请求不会处理跳到跳标头。 hop-to-hop header在rfc中有明确的规定。hop-to-hop header是两个连接之间的传输信息。比如客户端到代理和代理到服务器就是两个。客户端到服务器是端到端的。

请直接使用standard library作为反向代理，它已经为您处理了跳到跳标头和升级。

带有过滤器的 newsinglehostreverseproxy 示例：

package main

import (
    "net/http"
    "strings"
    "net/http/httputil"
    "net/url"
)

func main() {
    addr, _ := url.Parse("http://localhost:8088")
    proxy := httputil.NewSingleHostReverseProxy(addr)
    http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
        if strings.HasPrefix(r.URL.Path, "/api/") {
            proxy.ServeHTTP(w, r)
        } else {
            w.WriteHeader(404)
        }
    })
    // Listen Server
}

文中关于的知识介绍，希望对你的学习有所帮助！若是受益匪浅，那就动动鼠标收藏这篇《http 转发并阻止域》文章吧，也可关注golang学习网公众号了解相关技术文章。