Строковое представление байта [] в функции обработчика прокси

Question

Я создаю TCP-прокси с go, но столкнулся с небольшой проблемой. Прежде чем обрабатывать соединение c1 и переадресовывать его на c2, я хочу сделать несколько проверок. Для этого мне нужно строковое представление байтового среза из c1. К сожалению, _, err := io.CopyBuffer(w, r, buf) копирует []byte непосредственно между устройством записи и чтения, и если я сделаю c1.Read() перед функцией cp, []byte уже будет прочитан.

Вот функция, содержащая обработку соединения:

 func (p *proxy) handle(c1 net.Conn) {
        p.log.Printf("accepted %v", c1.RemoteAddr())
        defer p.log.Printf("disconnected %v", c1.RemoteAddr())
        defer c1.Close()
        c2, err := dialer.Dial("tcp", p.dial)
        log.Println("DIAL:", p.dial)
        if err != nil {
            p.log.Print("C2", err)
            return
        }
        defer c2.Close()

        errc := make(chan error, 2)
        cp := func(w io.Writer, r io.Reader) {
            buf := bufferPool.Get().([]byte)
            _, err := io.CopyBuffer(w, r, buf)
            errc <- err
            bufferPool.Put(buf)
        }
        go cp(struct{ io.Writer }{c1}, c2)
        go cp(c2, struct{ io.Reader }{c1})
        err = <-errc
        if err != nil {
            p.log.Print("F-ERROR ->", err)
        }
    }

Есть ли способ "продублировать" []byte, чтобы я мог использовать дубликат для отображения в виде строки?

Answer 1

Вы можете использовать io.MultiReader для объединения двух или более считывателей.Таким образом, вы можете читать () из c1, а затем использовать MultiReader для «воспроизведения» уже прочитанных байтов.

package main

import (
    "bytes"
    "io"
    "log"
    "net"
)

func main() {
    var c1, c2 net.Conn

    buf := make([]byte, 64)
    n, err := c1.Read(buf)
    buf = buf[:n]
    if err != nil {
        log.Fatal(err)
    }

    // TODO: deal with string(buf)

    errc := make(chan error, 2)

    go func() {
        // Replay contents of buf, then copy the unread part of c1.
        _, err := io.Copy(c2, io.MultiReader(bytes.NewReader(buf), c1))
        errc <- err
    }()

    go func() {
        _, err := io.Copy(c1, c2)
        errc <- err
    }()

    err = <-errc
    log.Println(err)
}

В качестве альтернативы просто записать () байты перед началом копирования:

    go func() {
        // Replay contents of buf
        _, err := c2.Write(buf)
        if err != nil {
            errc <- err
            return
        }

        _, err = io.Copy(c2, c1)
        errc <- err
    }()