// handler handles a single TCP Connection func (t *TcpListener) handler(conn *net.TCPConn, id string) { // connection cleanup function defer func() { t.wg.Done() conn.Close() log.Printf("Closed TCP Connection from %s", conn.RemoteAddr()) // Add one connection potential back to channel when this one closes t.accept <- true t.forget(id) }() scanner := bufio.NewScanner(conn) for { select { case <-t.done: return default: if !scanner.Scan() { return } buf := scanner.Bytes() select { case t.in <- buf: default: log.Printf(dropwarn, string(buf)) } } } }
func serve(conn *net.TCPConn, fileS *File_Server, uid int) { reader := bufio.NewReader(conn) for { msg, msgerr, fatalerr := fs.GetMsg(reader) if fatalerr != nil || msgerr != nil { reply(conn, &fs.Msg{Kind: 'M'}) conn.Close() break } if msgerr != nil { if (!reply(conn, &fs.Msg{Kind: 'M'})) { conn.Close() break } } newchannel := make(chan *fs.Msg, 1) mutex.Lock() fileS.Msgcount = fileS.Msgcount + 1 count := fileS.Msgcount fileS.Channels[count] = newchannel fmt.Println("Listening at", count) mutex.Unlock() modified_msg := Message{uid, count, *msg} // We are adding message id with it. newmsg, _ := json.Marshal(modified_msg) fileS.Raft.Append(newmsg) for { select { case ci := <-fileS.Channels[count]: reply(conn, ci) } break } } }
// Handles connections to a service and calls the handler specified in RunService(). func handleServiceConnection(connection *net.TCPConn, handler ServiceHandler) error { servicecall := ServiceCall{} buffer := make([]byte, PACKET_SIZE) defer connection.Close() length, err := connection.Read(buffer) if err != nil { return err } err = json.Unmarshal(buffer[:length], &servicecall) if err != nil { return err } ret := handler(&servicecall) bytes, err := json.Marshal(ServiceResult{ret}) if err != nil { return err } _, err = connection.Write(bytes) if err != nil { return err } return nil }
func (this *HttpProxyServer) handleConnection(conn *net.TCPConn) { defer conn.Close() reader := bufio.NewReader(conn) request, err := http.ReadRequest(reader) if err != nil { log.Warning("Failed to read http request: ", err) return } log.Info("Request to Method [", request.Method, "] Host [", request.Host, "] with URL [", request.URL, "]") defaultPort := v2net.Port(80) if strings.ToLower(request.URL.Scheme) == "https" { defaultPort = v2net.Port(443) } host := request.Host if len(host) == 0 { host = request.URL.Host } dest, err := parseHost(host, defaultPort) if err != nil { log.Warning("Malformed proxy host (", host, "): ", err) return } if strings.ToUpper(request.Method) == "CONNECT" { this.handleConnect(request, dest, reader, conn) } else { this.handlePlainHTTP(request, dest, reader, conn) } }
func proxy(cliConn *net.TCPConn, rAddr *net.TCPAddr) error { srvConn, err := net.DialTCP("tcp", nil, rAddr) if err != nil { cliConn.Close() return err } defer srvConn.Close() // channels to wait on the close event for each connection serverClosed := make(chan struct{}, 1) clientClosed := make(chan struct{}, 1) go broker(srvConn, cliConn, clientClosed) go broker(cliConn, srvConn, serverClosed) var waitFor chan struct{} select { case <-clientClosed: // the client closed first srvConn.SetLinger(0) srvConn.CloseRead() waitFor = serverClosed case <-serverClosed: cliConn.CloseRead() waitFor = clientClosed } <-waitFor return nil }
func handleConnection(conn *net.TCPConn) error { defer conn.Close() handlerChan <- 1 defer func() { handlerChan <- -1 }() var ws *websocket.Conn conn.SetDeadline(time.Now().Add(socksTimeout)) err := AwaitSocks4aConnect(conn, func(dest string) (*net.TCPAddr, error) { // Disable deadline. conn.SetDeadline(time.Time{}) Log("SOCKS request for %s", dest) destAddr, err := net.ResolveTCPAddr("tcp", dest) if err != nil { return nil, err } wsUrl := url.URL{Scheme: "ws", Host: dest} ws, err = websocket.Dial(wsUrl.String(), "", wsUrl.String()) if err != nil { return nil, err } Log("WebSocket connection to %s", ws.Config().Location.String()) return destAddr, nil }) if err != nil { return err } defer ws.Close() proxy(conn, ws) return nil }
func (server *Server) serveTCP(conn *net.TCPConn, rrp, wrp *sync.Pool, rr *bufio.Reader, wr *bufio.Writer, tr *Timer) { var ( b *Bucket p *Proto hb time.Duration // heartbeat key string err error trd *TimerData ch = NewChannel(Conf.CliProto, Conf.SvrProto) pb = make([]byte, maxPackIntBuf) ) // auth if trd, err = tr.Add(Conf.HandshakeTimeout, conn); err != nil { log.Error("handshake: timer.Add() error(%v)", err) goto failed } key, hb, err = server.authTCP(rr, wr, pb, ch) tr.Del(trd) if err != nil { log.Error("server.authTCP() error(%v)", err) goto failed } // register key->channel b = server.Bucket(key) b.Put(key, ch) // hanshake ok start dispatch goroutine go server.dispatchTCP(conn, wrp, wr, ch, hb, tr) for { // fetch a proto from channel free list if p, err = ch.CliProto.Set(); err != nil { log.Error("%s fetch client proto error(%v)", key, err) goto failed } // parse request protocol if err = server.readTCPRequest(rr, pb, p); err != nil { log.Error("%s read client request error(%v)", key, err) goto failed } // send to writer ch.CliProto.SetAdv() ch.Signal() } failed: // dialog finish // may call twice if err = conn.Close(); err != nil { log.Error("reader: conn.Close() error(%v)") } PutBufioReader(rrp, rr) if b != nil { b.Del(key) log.Debug("wake up dispatch goroutine") ch.Finish() } if err = server.operator.Disconnect(key); err != nil { log.Error("%s operator do disconnect error(%v)", key, err) } log.Debug("%s serverconn goroutine exit", key) return }
// serve serves a single accepted connection func (p *proxy) serve(client *net.TCPConn) { connected := connectedClients.With(p.labels) connected.Inc() defer func() { connected.Dec() _ = client.Close() }() p.mutex.Lock() upstreams := make([]Upstream, len(p.upstreams)) copy(upstreams, p.upstreams) p.mutex.Unlock() // TODO: proper iterator accounting weights and current # of connections for i := range upstreams { j := rand.Intn(i + 1) upstreams[i], upstreams[j] = upstreams[j], upstreams[i] } for _, upstream := range upstreams { p.log(fmt.Sprintf("connecting from %s to %s", client.RemoteAddr(), upstream)) backend, err := net.Dial("tcp", upstream.Addr()) if err != nil { p.log(fmt.Sprintf("error connecting from %s to %s: %s", client.RemoteAddr(), upstream.Addr(), err)) connectionErrors.With(prometheus.Labels{"app": p.app, "upstream": upstream.Addr()}).Inc() continue } p.proxyLoop(client, backend.(*net.TCPConn)) break } }
func handleHost(conn *net.TCPConn) { defer conn.Close() defer fmt.Printf("Closed host conn.\n") w := bufio.NewWriter(conn) name_line := make([]byte, 32) n, err := conn.Read(name_line) if err != nil { // TODO: Log this error fmt.Printf("Failed to read game from host: %v\n", err) return } name := strings.TrimSpace(string(name_line[0:n])) fmt.Printf("Game name: '%s': %d\n", name, len(name)) if !registerGame(name, conn) { w.Write([]byte(fmt.Sprintf("Unable to make game '%s', that name is already in use.\n", name))) return } defer unregisterGame(name) w.Flush() game := getGame(name) game.Run() }
func (proxy *Proxy) handleConnection(in *net.TCPConn) error { defer in.Close() plainOut, err := proxy.connectionFactory() if err != nil { log.Print("could no create outgoing connection", err) return err } out := plainOut.(*net.TCPConn) defer out.Close() serverClosed := make(chan struct{}, 1) clientClosed := make(chan struct{}, 1) go broker(out, in, clientClosed) go broker(in, out, serverClosed) var waitFor chan struct{} select { case <-clientClosed: // the client closed first and any more packets from the server aren't // useful, so we can optionally SetLinger(0) here to recycle the port // faster. out.SetLinger(0) out.CloseRead() waitFor = serverClosed case <-serverClosed: in.CloseRead() waitFor = clientClosed } <-waitFor return nil }
func handleClient(pf *PF, source *net.TCPConn) { atomic.AddInt32(&pf.status.actives, 1) defer func() { atomic.AddInt32(&pf.status.actives, -1) pf.wg.Done() }() settings := pf.settings host := chooseHost(settings.weight, settings.Hosts) if host == nil { source.Close() logger.Println("choose host failed") return } dest, err := net.DialTCP("tcp", nil, host.addr) if err != nil { source.Close() logger.Printf("connect to %s failed: %s", host.addr, err.Error()) return } source.SetKeepAlive(true) source.SetKeepAlivePeriod(time.Second * 60) source.SetLinger(-1) dest.SetLinger(-1) go forward(source, dest) forward(dest, source) //logger.Printf("forward finished, %v -> %v", source.RemoteAddr(), host) }
func forward(source *net.TCPConn, dest *net.TCPConn) { defer func() { dest.Close() }() bufsz := 1 << 12 cache := make([]byte, bufsz) for { // pump from source n, err1 := source.Read(cache) // pour into dest c := 0 var err2 error for c < n { i, err2 := dest.Write(cache[c:n]) if err2 != nil { break } c += i } if err1 != nil || err2 != nil { break } } }
// Demo goroutine start, but main goroutine exit, which kills the connection. // Not useful, but indicates how connections work. // 'Tested' using 'telnet localhost 45678' func getData(tcpConn *net.TCPConn, done chan bool) { for { var buffer = make([]byte, 256) fmt.Println("Starting Read ...") bytesRead, err := tcpConn.Read(buffer) if err != nil { fmt.Printf("Error = %v\n", err) break } // fmt.Println("Bytes Read", tcpConn, bytesRead) bufData := buffer[0:bytesRead] fmt.Println("Buffer", tcpConn, bufData) var data = string(bufData) fmt.Println("Data Read", tcpConn, data) // if strings.HasPrefix(data, "quit") { break } } // fmt.Println("Starting Close() 1") err := tcpConn.Close() if err != nil { fmt.Printf("Error = %v\n", err) panic("wtf05") } // done <- true }
func serve(con *net.TCPConn) { defer con.Close() if *verbose { fmt.Fprintf(os.Stdout, "serving %s\n", con.RemoteAddr().String()) } for { line, err := readUntilCrLf(con) if err != nil { // TODO : pass error message con.Write([]byte("\"internal error\"\r\n")) continue } tokens := strings.Split(string(line), " ", -1) command := tokens[0] if command == "quit" { writeJson(con, "bye.") break } f, ok := commands[command] if ok { f(con, tokens[1:]) } else { writeJson(con, fmt.Sprintf("unknown command '%s'", command)) } } }
func ReadTCPChannel(conn *net.TCPConn, delimiter string, fromSocket chan Message) error { var message string buffer := make([]byte, socketBuffer) for { if n, err := conn.Read(buffer); err != nil || n == 0 { if n == 0 && err == nil { err = errors.New("No bytes") } myLog.Printf("Closing:%v %v\n", conn.RemoteAddr(), err) conn.Close() return err } else { message += string(buffer[0:n]) m := strings.Split(message, delimiter) for i, entry := range m { if i < len(m)-1 { fromSocket <- Message{Msg: entry, RemoteAddr: conn.RemoteAddr()} } else { // overflow message = entry } } } } return nil }
// Read from socket and write to websocket func ReadSocket(ws *websocket.Conn, conn *net.TCPConn) { reader := bufio.NewReader(conn) var line string = "" for { if reader == nil { break } buffer, isPrefix, err := reader.ReadLine() if err != nil { break } // fmt.Println("ReadSocket: got", len(buffer), "bytes") line = line + string(buffer) if !isPrefix { // fmt.Println("Sending message to web socket:", line) err = websocket.Message.Send(ws, line) if err != nil { _ = conn.Close() } line = "" } } fmt.Println("ReadSocket exit") ws.Close() }
func handle(c *net.TCPConn, config Config) { defer c.Close() // TODO c.SetTimeout(60e9) r := bufio.NewReaderSize(c, 4096) for { // Note that everything in this loop should proceed as fast as it can // so we're not blocked and can keep processing // so the validation, the pipeline initiated via table.Dispatch(), etc // must never block. // note that we don't support lines longer than 4096B. that seems very reasonable.. buf, _, err := r.ReadLine() if nil != err { if io.EOF != err { log.Error(err.Error()) } break } buf_copy := make([]byte, len(buf), len(buf)) copy(buf_copy, buf) numIn.Inc(1) table.Dispatch(buf_copy) } }
func onNewConn(source *net.TCPConn, req *NewConnReq) { settings := daemon.settings host := chooseHost(settings.weight, settings.Hosts) if host == nil { source.Close() Error("choose host failed:%v", source.RemoteAddr()) return } dest, err := net.DialTCP("tcp", nil, host.addr) if err != nil { source.Close() Error("connect to %s failed: %s", host.addr, err.Error()) return } dest.SetKeepAlive(true) dest.SetKeepAlivePeriod(time.Second * 60) dest.SetLinger(-1) id := <-daemon.nextidCh link := NewStableLink(id, source, dest, req.key) daemon.eventCh <- link link.Run() daemon.eventCh <- link link.Wait() }
// Read TCP socket and return complete ByteMessage to caller's channel func ReadTCPChannel(conn *net.TCPConn, delimiter []byte, fromSocket chan ByteMessage) error { var message []byte buffer := make([]byte, SocketBuffer) for { if n, err := conn.Read(buffer); err != nil || n == 0 { if n == 0 && err == nil { err = errors.New("No bytes") } Logger.Println("Closing read:", conn.RemoteAddr(), err) conn.Close() return err } else { message = append(message, buffer[0:n]...) m := bytes.Split(message, delimiter) for i, entry := range m { if i < len(m)-1 { fromSocket <- ByteMessage{Msg: entry, RemoteAddr: conn.RemoteAddr()} } else { // overflow message = entry } } } } return nil }
func (s *Service) handleConnection(conn *net.TCPConn) { defer conn.Close() defer s.wg.Done() controller := controller.NewSession(conn, s.repo) defer controller.FinishSession() for { select { case <-s.ch: log.Println("disconnecting", conn.RemoteAddr()) return default: } err := controller.Dispatch() if opErr, ok := err.(*net.OpError); ok && opErr.Timeout() { continue } if err != nil { if err.Error() != "EOF" { log.Println(conn.RemoteAddr(), err) } return } } }
func handleConnWithBufferio(conn *net.TCPConn, req_conn *net.TCPConn, sid string, worker_idf string) { // 发包频率判断 range_count := 1 limit_date := global.Config.Connector.MaxPacketRate var now int64 var start_time int64 var range_times int64 start_time = time.Now().Unix() range_times = int64(global.Config.Connector.MaxPacketRateUnit) //声明一个管道用于接收解包的数据 reader := bufio.NewReader(conn) for { if !global.Config.Enable { conn.Write([]byte(fmt.Sprintf("%s\r\n", global.DISBALE_RESPONSE))) conn.Close() break } // 区间范围内的计数 if limit_date > 0 { now = time.Now().Unix() if (now - start_time) <= range_times { range_count++ } else { start_time = now range_count = 1 } // 判断发包频率是否超过限制 if range_count > limit_date { conn.Write([]byte(global.ERROR_PACKET_RATES + "\n")) conn.Close() break } } msg, err := reader.ReadString('\n') //fmt.Println( "handleConn ReadString: ", string(msg) ) if err != nil { CloseConn(conn, sid) //fmt.Println( "HandleConn connection error: ", err.Error()) break } if msg == "" { continue } go func(sid string, msg string, req_conn *net.TCPConn) { // fmt.Println(conn.RemoteAddr().String(), "receive str:", string(msg) ) worker_idf := GetRandWorkerIdf() worker_data := fmt.Sprintf(`%s||%s||%s||%s`, global.DATA_REQ_MSG, sid, worker_idf, msg) //fmt.Println("req push worker_data 2:", worker_data) req_conn.Write([]byte(worker_data + "\n")) }(sid, msg, req_conn) } }
func (srvr *FileServer) serve(conn *net.TCPConn, clientID int) { reader := bufio.NewReader(conn) for { msg, msgerr, fatalerr := fs.GetMsg(reader) leader := srvr.rn.LeaderId() if leader != srvr.id { //fmt.Println(srvr.id, " : To client ID ", msg, " : Not the Leader, sending an L ") if leader == -1 { // Don't know the leader //fmt.Println("Do not know the current leader") reply(conn, &fs.Msg{Kind: 'L', Contents: []byte("ERR_REDIRECT _")}) } else { content := []byte("ERR_REDIRECT " + srvr.nodeURLs[leader]) //fmt.Println("Redirecting to correct URL : ", srvr.nodeURLs[leader]) reply(conn, &fs.Msg{Kind: 'L', Contents: content, Numbytes: len(content)}) } break } if fatalerr != nil || msgerr != nil { reply(conn, &fs.Msg{Kind: 'M'}) conn.Close() break } msg.ClientID = clientID msg.ServerID = srvr.id data, err := json.Marshal(msg) //fmt.Println("Marshalled data : ", string(data)) check(err) srvr.rn.Append(data) } }
func (peer Peer) downloadFile(file File, conn *net.TCPConn) { if f, ok := status.status["local"].files[file.FileName]; ok { if f.Chunks[file.Chunks[1]] == 1 { return } } else { chunks := make([]int, file.Chunks[0]) for chunk := range chunks { chunks[chunk] = 0 } chunks[file.Chunks[1]] = 1 status.status["local"].files[file.FileName] = File{ FileName: file.FileName, Chunks: chunks, } } status.status["local"].files[file.FileName].Chunks[file.Chunks[1]] = 1 incrementChunkReplication(file.FileName, file.Chunks[1], file.Chunks[0]) err := conn.SetReadBuffer(ChunkSize) checkError(err) readBuffer := make([]byte, ChunkSize) _, err = conn.Read(readBuffer) checkError(err) conn.Close() status.mu.Lock() basepath := path.Dir(file.FileName) fileName := path.Base(file.FileName) err = os.MkdirAll(basepath, 0777) checkError(err) filePath := path.Join(basepath, fileName) localFile, err := os.OpenFile(filePath, os.O_CREATE|os.O_RDWR, 0777) if err != nil { for { localFile, err = os.OpenFile(filePath, os.O_CREATE|os.O_RDWR, 0777) if err == nil { break } } } writeOffset := int64(file.Chunks[1] * ChunkSize) _, err = localFile.WriteAt(bytes.TrimRight(readBuffer, "\x00"), writeOffset) checkError(err) err = localFile.Close() checkError(err) status.mu.Unlock() fmt.Printf("Downloaded file %s:%d \n\n", file.FileName, file.Chunks[1]) fileList := []File{file} haveMessage := encodeMessage(peer.host, peer.port, Have, fileList) sendToAll(haveMessage) return }
func handleConnection(conn *net.TCPConn, no_delay int, packet_bytes int) { defer conn.Close() fmt.Println("handle connection", conn) if no_delay == 0 { if err := conn.SetNoDelay(false); err != nil { fmt.Println("set no delay to false failed.") return } fmt.Println("set no delay to false ok.") } /*SO_SNDBUF := 16384 if err := conn.SetWriteBuffer(SO_SNDBUF); err != nil { fmt.Println("set send SO_SNDBUF failed.") return } fmt.Println("set send SO_SNDBUF to", SO_SNDBUF, "ok.")*/ b := make([]byte, packet_bytes) fmt.Println("write", len(b), "bytes to conn") for { n, err := conn.Write(b) if err != nil { fmt.Println("write data error, n is", n, "and err is", err) break } } }
func sendMessage(hostName string, portNumber int, msg []byte) { tcpAddr, err := net.ResolveTCPAddr("tcp4", net.JoinHostPort(hostName, strconv.Itoa(portNumber))) checkError(err) var conn *net.TCPConn for { conn, err = net.DialTCP("tcp", nil, tcpAddr) if err != nil { switch e := err.(type) { case (*net.OpError): if e.Err.Error() == "connection refused" { return } default: fmt.Println(err) } } else { break } } _, err = conn.Write(msg) checkError(err) conn.Close() return }
func RunTelnet(ws *websocket.Conn, conn *net.TCPConn) { fmt.Println("Running telnet") go ReadSocket(ws, conn) // Read websocket and write to socket. crlf := []byte{13, 10} var msg string for { err := websocket.Message.Receive(ws, &msg) if err != nil { _ = conn.Close() break } _, err = conn.Write([]byte(msg)) if err != nil { break } fmt.Println("Sent message to host:", msg) // Send \r\n (as HTTP protocol requires) _, err = conn.Write(crlf) if err != nil { break } } fmt.Println("RunTelnet exit") }
func tcpShim(inbound, outbound *net.TCPConn, connEvent *events.Connection, eh events.Handler) error { eh.Connection(connEvent) ch := make(chan error, 1) go func() { var err error defer func() { ch <- err }() _, err = io.Copy(inbound, outbound) outbound.CloseRead() inbound.CloseWrite() }() _, err1 := io.Copy(outbound, inbound) inbound.CloseRead() outbound.CloseWrite() err2 := <-ch inbound.Close() outbound.Close() if err1 != nil { return err1 } else { return err2 } }
// 分配连接处理 func (self *AgentSvr) handleConnection(conn *net.TCPConn) { defer conn.Close() defer self.wg.Done() defer func() { if err := recover(); err != nil { Error("handle agent connection:%v failed:%v", conn.RemoteAddr(), err) } }() Info("new agent connection:%v", conn.RemoteAddr()) for { var sz uint32 err := binary.Read(conn, binary.BigEndian, &sz) if err != nil { Error("read conn failed:%v, err:%v", conn.RemoteAddr(), err) break } buf := make([]byte, sz) _, err = io.ReadFull(conn, buf) if err != nil { Error("read conn failed:%v, err:%v", conn.RemoteAddr(), err) break } var req Request if err = json.Unmarshal(buf, &req); err != nil { Error("parse request failed:%v, err:%v", conn.RemoteAddr(), err) } go self.dispatchRequst(conn, &req) } }
func handleClient(conn *net.TCPConn) { defer func() { log.Printf("Disconnect from %v", conn.RemoteAddr()) conn.Close() connectionsM.Lock() delete(connections, conn.RemoteAddr().String()) connectionsM.Unlock() }() log.Printf("Connect from %v", conn.RemoteAddr()) buf := make([]byte, 1024) for { n, err := conn.Read(buf) if n > 0 { messages <- Message{conn, string(buf[:n])} } if err != nil { if err != io.EOF { log.Printf("Error from %v: %s", conn.RemoteAddr(), err) } return } } }
func read_tcp_conn(tcpConn *net.TCPConn, connChan chan []byte) { buffer := make([]byte, 2048) tcpConn.SetReadBuffer(2048) for { n, err := tcpConn.Read(buffer[0:]) if err != nil { log.Println("one tcp connection read function failed!") log.Println("one tcp connection close now!") tcpConn.Close() runtime.Goexit() } else { connChan <- buffer[0 : n-1] } } }