wip

mtglib/internal/relay/relay.go

 )
 
 func Relay(ctx context.Context, log Logger, telegramConn, clientConn net.Conn) {
+	defer telegramConn.Close()
+	defer clientConn.Close()
+
 	ctx, cancel := context.WithCancel(ctx)
 	defer cancel()
 
 
 func pump(log Logger, src, dst net.Conn, wg *sync.WaitGroup, direction string) {
 	defer wg.Done()
-	defer src.Close()
-	defer dst.Close()
 
 	syncer := acquireSyncPair(src, dst)
 	defer releaseSyncPair(syncer)
+	defer syncer.Flush()
 
 	if n, err := syncer.Sync(); err != nil {
-		log.Printf("cannot pump %s (written %d bytes): %w", direction, n, err)
+		log.Printf("cannot pump %s (written %d bytes): %v", direction, n, err)
 	}
 }

mtglib/internal/relay/sync_pair.go

 	"io"
 	"net"
 	"os"
+	"sync"
 	"time"
 )
 
 	writer  *bufio.Writer
 	copyBuf []byte
 
+	mutex  sync.Mutex
 	reader net.Conn
 }
 
 	n, err := s.readBlocking(p, false)
 
 	if errors.Is(err, os.ErrDeadlineExceeded) {
-		if err := s.writer.Flush(); err != nil {
+		if err := s.Flush(); err != nil {
 			return 0, fmt.Errorf("cannot flush writer hand-side: %w", err)
 		}
 
 }
 
 func (s *syncPair) Write(p []byte) (int, error) {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
 	return s.writer.Write(p) // nolint: wrapcheck
 }
 
+func (s *syncPair) Flush() error {
+	s.mutex.Lock()
+	defer s.mutex.Unlock()
+
+	return s.writer.Flush()
+}
+
 func (s *syncPair) readBlocking(p []byte, blocking bool) (int, error) {
 	var deadline time.Time