// NewConnection creates a SSMP connection out of a streaming netwrok connection. // // This method blocks until either a first message is received or a 10s timeout // elapses. // // Each accepted connection spawns a goroutine continuously reading from the // underlying network connection and triggering the Dispatcher. The caller must // keep track of the returned Connection and call the Close method to stop the // read goroutine and close the udnerlying netwrok connection. // // errInvalidLogin is returned if the first message is not a well-formed LOGIN // request. // errUnauthorized is returned if the authenticator doesn't accept the provided // credentials. func NewConnection(c net.Conn, a Authenticator, d *Dispatcher) (*Connection, error) { r := ssmp.NewDecoder(c) c.SetReadDeadline(time.Now().Add(10 * time.Second)) verb, err := r.DecodeVerb() if err != nil || !ssmp.Equal(verb, ssmp.LOGIN) { return nil, ErrInvalidLogin } user, err := r.DecodeId() if err != nil { return nil, ErrInvalidLogin } scheme, err := r.DecodeId() if err != nil { return nil, ErrInvalidLogin } var cred []byte if r.AtEnd() { cred = []byte{} } else if cred, err = r.DecodePayload(); err != nil { return nil, ErrInvalidLogin } if !a.Auth(c, user, scheme, cred) { return nil, ErrUnauthorized } r.Reset() cc := &Connection{ c: c, r: r, User: string(user), } go cc.readLoop(d) cc.Write(respOk) return cc, nil }
func (p *multiplexer) connectToDest(frm *frame, key string, tun *Conn) { defer func() { ex.CatchException(recover()) }() var ( dstConn net.Conn err error target = string(frm.data) ) dstConn, err = net.DialTimeout("tcp", target, GENERAL_SO_TIMEOUT) frm.length = 0 if err != nil { p.router.removePreRegistered(key) log.Errorf("Cannot connect to [%s] for %s error: %s\n", target, key, err) frm.action = FRAME_ACTION_OPEN_N tunWrite2(tun, frm) } else { if log.V(1) { log.Infoln("OPEN", target, "for", key) } dstConn.SetReadDeadline(ZERO_TIME) edge := p.router.register(key, target, tun, dstConn, false) // write edge frm.action = FRAME_ACTION_OPEN_Y if tunWrite2(tun, frm) == nil { p.relay(edge, tun, frm.sid) // read edge } else { // send open_y failed SafeClose(tun) } } }
func (cons *Socket) processConnection(conn net.Conn) { cons.AddWorker() defer cons.WorkerDone() defer conn.Close() buffer := shared.NewBufferedReader(socketBufferGrowSize, cons.flags, cons.offset, cons.delimiter) for cons.IsActive() && !cons.IsFuseBurned() { conn.SetReadDeadline(time.Now().Add(cons.readTimeout)) err := buffer.ReadAll(conn, cons.Enqueue) if err == nil { if err = cons.sendAck(conn, true); err == nil { continue // ### continue, all is well ### } } // Silently exit on disconnect/close if !cons.IsActive() || shared.IsDisconnectedError(err) { return // ### return, connection closed ### } // Ignore timeout related errors if netErr, isNetErr := err.(net.Error); isNetErr && netErr.Timeout() { continue // ### return, ignore timeouts ### } Log.Error.Print("Socket transfer failed: ", err) cons.sendAck(conn, false) // Parser errors do not drop the connection if err != shared.BufferDataInvalid { return // ### return, close connections ### } } }
func handleClient(conn net.Conn) { conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) defer conn.Close() b := bufio.NewReader(conn) for { status, err := b.ReadString('\n') if err != nil { if err == io.EOF { fmt.Println("Client Disconnected.") } else { fmt.Println(err) } break } // Clean up the input status = strings.Replace(status, "\r", "", -1) status = strings.Replace(status, "\n", "", -1) switch status { case "register": fmt.Println("Registered") conn.Write([]byte("Registered Client\n")) break default: break } } }
func connectToStdio(stdin <-chan string, conn net.Conn) { go func() { }() buf := make([]byte, 1024) for { conn.SetReadDeadline(time.Now().Add(time.Millisecond)) n, err := conn.Read(buf[0:]) if err != nil { nerr, ok := err.(net.Error) if !ok || !nerr.Timeout() { log.Println(err) return } } os.Stdout.Write(buf[:n]) select { case msg := <-stdin: _, err := conn.Write([]byte(msg)) if err != nil { return } default: } } }
func ReadMessage(conn net.Conn, timeout time.Duration) (*Message, error) { conn.SetReadDeadline(time.Now().Add(DefaultHeartbeatTimeout)) var lengthBuf [2]byte _, err := conn.Read(lengthBuf[:]) if err != nil { return nil, err } length := int(binary.BigEndian.Uint16(lengthBuf[:])) if length > DefaultMessageLengthCap { return nil, errors.New("message is too long") } buf := bytes.NewBuffer(make([]byte, 0, length)) _, err = io.CopyN(buf, conn, int64(length)) if err != nil { return nil, err } var handle = &codec.MsgpackHandle{} var decoder = codec.NewDecoder(buf, handle) var result = &Message{} err = decoder.Decode(result) if err != nil { return nil, err } return result, nil }
func handleClient(conn net.Conn) { conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) request := make([]byte, 128) defer conn.Close() for { read_len, err := conn.Read(request) fmt.Println(read_len) if err != nil { fmt.Println(err) break } if read_len == 0 { break } else if string(request) == "timestamp" { daytime := strconv.FormatInt(time.Now().Unix(), 10) conn.Write([]byte(daytime)) } else { daytime := time.Now().String() conn.Write([]byte(daytime)) } request = make([]byte, 128) } }
func handleConn(conn net.Conn) { defer conn.Close() for { conn.SetReadDeadline(time.Now().Add(10 * time.Second)) strReq, err := read(conn) if err != nil { if err == io.EOF { fmt.Println("The connection is closed by another side. (Server)") } else { fmt.Printf("Read Error: %s (Server)\n", err) } break } fmt.Printf("Received request: %s (Server)\n", strReq) i32Req, err := strconv.Atoi(strReq) if err != nil { n, err := write(conn, err.Error()) if err != nil { fmt.Printf("Write Eoor (writen %d bytes:) %s (Server)\n", err) } fmt.Printf("Sent response (written %d bytes %s (server)\n", n, err) continue } f64Resp := math.Cbrt(float64(i32Req)) respMsg := fmt.Sprintf("The cube root of %d is %f.", i32Req, f64Resp) n, err := write(conn, respMsg) if err != nil { fmt.Printf("Write Error: %s (Server)\n", err) } fmt.Printf("Sent response (writtn %d bytes:) %s (Server)\n", n, respMsg) } }
// testRacyRead tests that it is safe to mutate the input Read buffer // immediately after cancelation has occurred. func testRacyRead(t *testing.T, c1, c2 net.Conn) { go chunkedCopy(c2, rand.New(rand.NewSource(0))) var wg sync.WaitGroup defer wg.Wait() c1.SetReadDeadline(time.Now().Add(time.Millisecond)) for i := 0; i < 10; i++ { wg.Add(1) go func() { defer wg.Done() b1 := make([]byte, 1024) b2 := make([]byte, 1024) for j := 0; j < 100; j++ { _, err := c1.Read(b1) copy(b1, b2) // Mutate b1 to trigger potential race if err != nil { checkForTimeoutError(t, err) c1.SetReadDeadline(time.Now().Add(time.Millisecond)) } } }() } }
// ---------------------------------------------------------------------- // // RECEIVE LOGIC // // ---------------------------------------------------------------------- func conn_read(conn net.Conn, timeout time.Duration, buffer []byte) (int, error) { if timeout != time.Duration(0) { conn.SetReadDeadline(time.Now().Add(timeout)) } position := 0 length := len(buffer) for position < length { bytesRead, err := conn.Read(buffer[position:]) if err != nil { if err == io.EOF { log.Println("conn_read", "CLOSED") return 0, CHANNEL_CLOSED } else if neterr, ok := err.(net.Error); ok && neterr.Timeout() { log.Println("conn_read", "TIMEOUT") return 0, CHANNEL_TIMEOUT } else { // we should do better than this log.Println("conn_read", err) return 0, CHANNEL_CLOSED } } else { position += bytesRead } } return position, nil }
// monitorConnection is called for bidi connections and watches for the client // to disappear. this func blocks until the connection closes or generates a // a non-timeout error (possibly protocol related). func (w *Writer) monitorConnection(conn net.Conn) { defer close(w.finish) var err error for { conn.SetReadDeadline(time.Now().Add(1 * time.Second)) // test the connection by attempting to read a FINISH control frame. // we should only see this if we've initiated a close by sending a // STOP, but it doesn't hurt to start watching for this before then // because we're really not expecting the client to send anything // else at this point. we also don't have to write anything special // back to the client if we receive it because the client closes their // end of the connection upon sending. _, err = w.readControl(ControlTypeFinish) if err == io.EOF { // connection closed } else if neterr, ok := err.(net.Error); ok && neterr.Timeout() { // timeout time.Sleep(5 * time.Second) // TODO(jdef) extract constant continue } break } w.setError(err) }
func NewConn(client *Client, network, addr string, connectTimeout, readTimeout, writeTimeout time.Duration) (*Conn, error) { client.CountNewConn++ var conn net.Conn var err error if connectTimeout > 0 { conn, err = net.DialTimeout(network, addr, connectTimeout) } else { conn, err = net.Dial(network, addr) } if err != nil { return nil, err } if readTimeout > 0 { conn.SetReadDeadline(time.Now().Add(readTimeout)) } if writeTimeout > 0 { conn.SetWriteDeadline(time.Now().Add(writeTimeout)) } this := &Conn{ Conn: conn, Client: client, ReadTimeout: readTimeout, WriteTimeout: writeTimeout, } return this, nil }
func copyBytes(dst, src net.Conn, wg *sync.WaitGroup, writeDeadline, readDeadline time.Duration) { defer wg.Done() n, err := io.Copy(dst, src) if err != nil { log.Errorf("proxy i/o error: %v", err) } if cr, ok := src.(*net.TCPConn); ok { cr.CloseRead() } else { // For TLS connections. wto := time.Now().Add(writeDeadline) src.SetWriteDeadline(wto) } if cw, ok := dst.(*net.TCPConn); ok { cw.CloseWrite() } else { // For TLS connections. rto := time.Now().Add(readDeadline) dst.SetReadDeadline(rto) } log.Debugf("proxy copied %d bytes %s -> %s", n, src.RemoteAddr(), dst.RemoteAddr()) }
func handleConnection(conn net.Conn) { defer conn.Close() conn.SetReadDeadline(time.Now().Add(time.Second * 3)) r := bufio.NewReader(conn) size, err := r.ReadString(';') if err != nil { log.Println(err) fmt.Fprintf(conn, "Failed to read content length: %v\n", err) return } size = size[:len(size)-1] i, err := strconv.Atoi(size) if err != nil { log.Println(err) fmt.Fprintf(conn, "Failed to get content length from %s: %v\n", size, err) return } b := make([]byte, i) r.Read(b) intent := content.Intent{} if err := json.Unmarshal(b, &intent); err != nil { log.Println(err) fmt.Fprintf(conn, "Failed to decode request: %v", err) } content.Handle(conn, intent) }
func (s *session) proxy(c1, c2 net.Conn) error { if debug { log.Println("Proxy", c1.RemoteAddr(), "->", c2.RemoteAddr()) } atomic.AddInt64(&numProxies, 1) defer atomic.AddInt64(&numProxies, -1) buf := make([]byte, 65536) for { c1.SetReadDeadline(time.Now().Add(networkTimeout)) n, err := c1.Read(buf) if err != nil { return err } atomic.AddInt64(&bytesProxied, int64(n)) if debug { log.Printf("%d bytes from %s to %s", n, c1.RemoteAddr(), c2.RemoteAddr()) } if s.rateLimit != nil { s.rateLimit(int64(n)) } c2.SetWriteDeadline(time.Now().Add(networkTimeout)) _, err = c2.Write(buf[:n]) if err != nil { return err } } }
func (mux *Mux) handleConn(conn net.Conn) error { // Wrap in a buffered connection in order to peek at the first byte. bufConn := newBufConn(conn) // Set a read deadline so connections with no data timeout. if err := conn.SetReadDeadline(time.Now().Add(mux.Timeout)); err != nil { return fmt.Errorf("set read deadline: %s", err) } // Peek at first byte from connection to determine handler. typ, err := bufConn.r.ReadByte() if err != nil { return fmt.Errorf("read header byte: %s", err) } else if err = bufConn.r.UnreadByte(); err != nil { return fmt.Errorf("unread header byte: %s", err) } // Reset read deadline and let the listener handle that. if err := conn.SetReadDeadline(time.Time{}); err != nil { return fmt.Errorf("reset set read deadline: %s", err) } // Lookup handler. h := mux.handlers[typ] if h == nil { return fmt.Errorf("unregistered header byte: 0x%02x", typ) } // Hand off connection to handler. h.c <- bufConn return nil }
func handleConn(conn net.Conn) { defer func() { conn.Close() wg.Done() }() for { conn.SetReadDeadline(time.Now().Add(10 * time.Second)) strReq, err := read(conn) if err != nil { if err == io.EOF { printLog("The connection is closed by another side. (Server)\n") } else { printLog("Read Error: %s (Server)\n", err) } break } printLog("Received request: %s (Server)\n", strReq) i32Req, err := convertToInt32(strReq) if err != nil { n, err := write(conn, err.Error()) if err != nil { printLog("Write Error (written %d bytes): %s (Server)\n", err) } printLog("Sent response (written %d bytes): %s (Server)\n", n, err) continue } f64Resp := cbrt(i32Req) respMsg := fmt.Sprintf("The cube root of %d is %f.", i32Req, f64Resp) n, err := write(conn, respMsg) if err != nil { printLog("Write Error: %s (Server)\n", err) } printLog("Sent response (written %d bytes): %s (Server)\n", n, respMsg) } }
func DefaultDial(proto, realm string) (io.ReadWriteCloser, error) { if proto != "tcp" && proto != "udp" { return nil, ErrInvalidProto(proto) } _, addrs, err := net.LookupSRV("kerberos", proto, realm) if err != nil { _, addrs, err = net.LookupSRV("kerberos-master", proto, realm) if err != nil { return nil, err } } var sock net.Conn for _, a := range addrs { addr := net.JoinHostPort(a.Target, strconv.Itoa(int(a.Port))) sock, err = net.Dial(proto, addr) if err == nil { break } } if err != nil { return nil, err } if proto == "udp" { // For datagram connections, we retry up to three times, then give up sock.SetReadDeadline(time.Now().Add(udpReadTimeout)) } return sock, nil }
func (rcv *TCP) handleConnection(conn net.Conn) { atomic.AddInt32(&rcv.active, 1) defer atomic.AddInt32(&rcv.active, -1) defer conn.Close() reader := bufio.NewReader(conn) for { conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) line, err := reader.ReadBytes('\n') if err != nil { if err == io.EOF { if len(line) > 0 { logrus.Warningf("[tcp] Unfinished line: %#v", line) } } else { atomic.AddUint32(&rcv.errors, 1) logrus.Error(err) } break } if len(line) > 0 { // skip empty lines if msg, err := points.ParseText(string(line)); err != nil { atomic.AddUint32(&rcv.errors, 1) logrus.Info(err) } else { atomic.AddUint32(&rcv.metricsReceived, 1) rcv.out <- msg } } } }
// poll sends a packet and wait for a response. Both operations can timeout, they're retried up to retries times. func poll(conn net.Conn, toSend []byte, respondBuffer []byte, retries int, timeout time.Duration) (int, error) { var err error for i := 0; i < retries+1; i++ { deadline := time.Now().Add(timeout) if err = conn.SetWriteDeadline(deadline); err != nil { log.Printf("Couldn't set write deadline. Retrying. Retry %d/%d\n", i, retries) continue } if _, err = conn.Write(toSend); err != nil { log.Printf("Couldn't write. Retrying. Retry %d/%d\n", i, retries) continue } deadline = time.Now().Add(timeout) if err = conn.SetReadDeadline(deadline); err != nil { log.Printf("Couldn't set read deadline. Retrying. Retry %d/%d\n", i, retries) continue } numRead := 0 if numRead, err = conn.Read(respondBuffer); err != nil { log.Printf("Couldn't read. Retrying. Retry %d/%d\n", i, retries) continue } return numRead, nil } return 0, err }
func slurp(conn net.Conn, maxbytes int, timeout float64) ([]byte, error) { buf := []byte{} readLimit := 32 * 1024 if maxbytes > 0 { readLimit = maxbytes } readBytes := 0 if timeout > 0 { conn.SetReadDeadline(time.Now().Add(time.Duration(timeout) * time.Second)) } for { tmpBuf := make([]byte, readLimit) i, err := conn.Read(tmpBuf) if i > 0 { buf = append(buf, tmpBuf[:i]...) readBytes += i if i < readLimit || (maxbytes > 0 && maxbytes <= readBytes) { break } } if err == io.EOF { return buf, nil } if err != nil { return buf, err } } return buf, nil }
func (srv *Server) readTCP(conn net.Conn, timeout time.Duration) ([]byte, error) { conn.SetReadDeadline(time.Now().Add(timeout)) l := make([]byte, 2) n, err := conn.Read(l) if err != nil || n != 2 { if err != nil { return nil, err } return nil, ErrShortRead } length := binary.BigEndian.Uint16(l) if length == 0 { return nil, ErrShortRead } m := make([]byte, int(length)) n, err = conn.Read(m[:int(length)]) if err != nil || n == 0 { if err != nil { return nil, err } return nil, ErrShortRead } i := n for i < int(length) { j, err := conn.Read(m[i:int(length)]) if err != nil { return nil, err } i += j } n = i m = m[:n] return m, nil }
func handleConn(conn net.Conn) { defer conn.Close() // Read from connection buf := make([]byte, 512) conn.SetReadDeadline(time.Now().Add(TIMEOUT)) n, err := conn.Read(buf) if err != nil { return } // Unmarshal message msg := Message{} err = json.Unmarshal(buf[:n], &msg) // Handle message switch msg.Type { case MSG_VOTE: fmt.Printf("%d: Got vote message.\n", id) go announceVote() fallthrough case MSG_PING: fmt.Printf("%d: Sending 'alive' message.\n", id) response := Message{Type: MSG_ALIVE, Sender: id} conn.Write(response.ToJSON()) case MSG_LEADER: if msg.Sender > id { setLeader(msg.Sender) } else { fmt.Printf("%d: Leader with lower ID. Bullying!\n", id) go announceVote() } } }
func (srv *Server) sentinel(c net.Conn, connClosed chan int) { select { case <-srv.stopAccepting: c.SetReadDeadline(time.Now().Add(3 * time.Second)) case <-connClosed: } }
func handleClient(conn net.Conn) { // defer conn.Close() // daytime := time.Now().String() // conn.Write([]byte(daytime)) conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) // set 2 minutes timeout request := make([]byte, 128) // set maxium request length to 128KB to prevent flood attack defer conn.Close() // close connection before exit for { read_len, err := conn.Read(request) fmt.Println("read info: ", string(request)) if err != nil { fmt.Println(err) break } fmt.Println(string(request)) if read_len == 0 { break // connection already closed by client } else if string(request) == "timestamp" { fmt.Println("daytime timestamp") daytime := strconv.FormatInt(time.Now().Unix(), 10) conn.Write([]byte(daytime)) } else { daytime := time.Now().String() conn.Write([]byte(daytime)) } request = make([]byte, 128) // clear last read content } }
func (mux *Mux) handleConn(conn net.Conn) { defer mux.wg.Done() // Set a read deadline so connections with no data don't timeout. if err := conn.SetReadDeadline(time.Now().Add(mux.Timeout)); err != nil { conn.Close() mux.Logger.Printf("tcp.Mux: cannot set read deadline: %s", err) return } // Read first byte from connection to determine handler. var typ [1]byte if _, err := io.ReadFull(conn, typ[:]); err != nil { conn.Close() mux.Logger.Printf("tcp.Mux: cannot read header byte: %s", err) return } // Reset read deadline and let the listener handle that. if err := conn.SetReadDeadline(time.Time{}); err != nil { conn.Close() mux.Logger.Printf("tcp.Mux: cannot reset set read deadline: %s", err) return } // Retrieve handler based on first byte. handler := mux.m[typ[0]] if handler == nil { conn.Close() mux.Logger.Printf("tcp.Mux: handler not registered: %d", typ[0]) return } // Send connection to handler. The handler is responsible for closing the connection. handler.c <- conn }
func handleClient(conn net.Conn) { conn.SetReadDeadline(time.Now().Add(2 * time.Minute)) // 2分钟无接收信息超时 //func (c *TCPConn) SetReadDeadline(t time.Time) error //func (c *TCPConn) SetWriteDeadline(t time.Time) error defer conn.Close() for { request := make([]byte, 128) //128 位读取信息 read_len, err := conn.Read(request) if err != nil { fmt.Println(err) break } if read_len == 0 { break // connection already closed by client } else if string(request) == "timestamp" { daytime := strconv.FormatInt(time.Now().Unix(), 10) conn.Write([]byte(daytime)) } else { daytime := time.Now().String() conn.Write([]byte(daytime)) } } }
func (s *Server) handle(clientConn net.Conn, id int) { log.Debug("[tcpez] New client(%s)", clientConn.RemoteAddr()) s.clientConns[id] = clientConn for { // Timeout the connection after 5 mins clientConn.SetReadDeadline(time.Now().Add(5 * time.Minute)) header, response, err := s.readHeaderAndHandleRequest(clientConn) if err != nil { if closableError(err) { // EOF the client has disconnected break } log.Error(err.Error()) s.Stats.Increment("operation.failure") return } err = s.sendResponse(clientConn, header, response) if err != nil { if closableError(err) { // EOF the client has disconnected break } log.Error(err.Error()) s.Stats.Increment("operation.failure") return } s.Stats.Increment("operation.success") } log.Debug("Closing connection %v", clientConn) clientConn.Close() delete(s.clientConns, id) }
func (t *Telnet) recv(c net.Conn) (int, error) { buf := make([]byte, 512) count := 0 for { err := c.SetReadDeadline(time.Now().Add(time.Millisecond * 500)) if err != nil { return count, fmt.Errorf("setting read deadline: %v\n", err) } n, err := c.Read(buf) if err != nil { if neterr, ok := err.(net.Error); ok && neterr.Timeout() { return count, nil } return count, fmt.Errorf("read error: %v\n", err) } for i := 0; i < n; i++ { if cnt := t.decodeCommand(buf[i:n]); cnt > 0 { i += cnt continue } t.debugf("%2.2x %c\n", buf[i], buf[i]) } count += n if time.Now().After(t.deadline) { return count, errors.New("deadline exceeded") } } }
func SockRead(con net.Conn, buf []byte) (n int, e error) { var toread int bw_mutex.Lock() TickRecv() if DownloadLimit == 0 { toread = len(buf) } else { toread = int(DownloadLimit) - dl_bytes_so_far if toread > len(buf) { toread = len(buf) } else if toread < 0 { toread = 0 } } dl_bytes_so_far += toread bw_mutex.Unlock() if toread > 0 { // Wait 1 millisecond for a data, timeout if nothing there con.SetReadDeadline(time.Now().Add(100 * time.Millisecond)) n, e = con.Read(buf[:toread]) bw_mutex.Lock() DlBytesTotal += uint64(n) dl_bytes_priod += uint64(n) bw_mutex.Unlock() } else { // supsend a task for awhile, to prevent stucking in a busy loop time.Sleep(100 * time.Millisecond) } return }