func handleClient(p1, p2 net.Conn) {
log.Println("stream opened")
defer log.Println("stream closed")
defer p1.Close()
defer p2.Close()
// start tunnel
p1die := make(chan struct{})
go func() {
io.Copy(p1, p2)
close(p1die)
}()
p2die := make(chan struct{})
go func() {
io.Copy(p2, p1)
close(p2die)
}()
// wait for tunnel termination
select {
case <-p1die:
case <-p2die:
}
}
func (s *Server) onConn(c net.Conn) {
conn := s.newClientConn(c) //新建一个conn
defer func() {
err := recover()
if err != nil {
const size = 4096
buf := make([]byte, size)
buf = buf[:runtime.Stack(buf, false)] //获得当前goroutine的stacktrace
golog.Error("server", "onConn", "error", 0,
"remoteAddr", c.RemoteAddr().String(),
"stack", string(buf),
)
}
conn.Close()
}()
if allowConnect := conn.IsAllowConnect(); allowConnect == false {
err := mysql.NewError(mysql.ER_ACCESS_DENIED_ERROR, "ip address access denied by kingshard.")
conn.writeError(err)
conn.Close()
return
}
if err := conn.Handshake(); err != nil {
golog.Error("server", "onConn", err.Error(), 0)
c.Close()
return
}
conn.Run()
}
func (p *Peer) Accept(conn net.Conn) (_err error) {
defer conn.Close()
p.logFields(SERVE, log.Fields{
"remoteAddr": conn.RemoteAddr(),
}).Debug("accepted connection")
defer func() {
if _err != nil {
p.logErr(SERVE, _err).Error()
}
}()
var failResp string
if p.readAcquire() {
defer p.wg.Done()
} else {
failResp = "sync not available, currently mutating"
}
remoteConfig, err := p.handleConfig(conn, SERVE, failResp)
if err != nil {
return errgo.Mask(err)
}
if failResp == "" {
return p.interactWithClient(conn, remoteConfig, cf.NewBitstring(0))
}
return nil
}
func (tp *TCPProxy) serve(in net.Conn) {
var (
err error
out net.Conn
)
for i := 0; i < tp.numRemotes(); i++ {
remote := tp.pick()
if !remote.isActive() {
continue
}
// TODO: add timeout
out, err = net.Dial("tcp", remote.addr)
if err == nil {
break
}
remote.inactivate()
plog.Warningf("deactivated endpoint [%s] due to %v for %v", remote.addr, err, tp.MonitorInterval)
}
if out == nil {
in.Close()
return
}
go func() {
io.Copy(in, out)
in.Close()
out.Close()
}()
io.Copy(out, in)
out.Close()
in.Close()
}
// sendSshKeepAlive is a helper which sends a [email protected] request // on the specified SSH connections and returns true of the request succeeds // within a specified timeout. func sendSshKeepAlive( sshClient *ssh.Client, conn net.Conn, timeout time.Duration) error { errChannel := make(chan error, 2) if timeout > 0 { time.AfterFunc(timeout, func() { errChannel <- TimeoutError{} }) } go func() { // Random padding to frustrate fingerprinting _, _, err := sshClient.SendRequest( "*****@*****.**", true, MakeSecureRandomPadding(0, TUNNEL_SSH_KEEP_ALIVE_PAYLOAD_MAX_BYTES)) errChannel <- err }() err := <-errChannel if err != nil { sshClient.Close() conn.Close() } return ContextError(err) }
// handleRawConn is run in its own goroutine and handles a just-accepted
// connection that has not had any I/O performed on it yet.
func (s *Server) handleRawConn(rawConn net.Conn) {
conn, authInfo, err := s.useTransportAuthenticator(rawConn)
if err != nil {
s.mu.Lock()
s.errorf("ServerHandshake(%q) failed: %v", rawConn.RemoteAddr(), err)
s.mu.Unlock()
grpclog.Printf("grpc: Server.Serve failed to complete security handshake from %q: %v", rawConn.RemoteAddr(), err)
rawConn.Close()
return
}
s.mu.Lock()
if s.conns == nil {
s.mu.Unlock()
conn.Close()
return
}
s.mu.Unlock()
if s.opts.useHandlerImpl {
s.serveUsingHandler(conn)
} else {
s.serveNewHTTP2Transport(conn, authInfo)
}
}
func (c *Client) do(method, path string, doOptions doOptions) ([]byte, int, error) {
var params io.Reader
if doOptions.data != nil || doOptions.forceJSON {
buf, err := json.Marshal(doOptions.data)
if err != nil {
return nil, -1, err
}
params = bytes.NewBuffer(buf)
}
if path != "/version" && !c.SkipServerVersionCheck && c.expectedAPIVersion == nil {
err := c.checkAPIVersion()
if err != nil {
return nil, -1, err
}
}
req, err := http.NewRequest(method, c.getURL(path), params)
if err != nil {
return nil, -1, err
}
req.Header.Set("User-Agent", userAgent)
if doOptions.data != nil {
req.Header.Set("Content-Type", "application/json")
} else if method == "POST" {
req.Header.Set("Content-Type", "plain/text")
}
var resp *http.Response
protocol := c.endpointURL.Scheme
address := c.endpointURL.Path
if protocol == "unix" {
var dial net.Conn
dial, err = net.Dial(protocol, address)
if err != nil {
return nil, -1, err
}
defer dial.Close()
breader := bufio.NewReader(dial)
err = req.Write(dial)
if err != nil {
return nil, -1, err
}
resp, err = http.ReadResponse(breader, req)
} else {
resp, err = c.HTTPClient.Do(req)
}
if err != nil {
if strings.Contains(err.Error(), "connection refused") {
return nil, -1, ErrConnectionRefused
}
return nil, -1, err
}
defer resp.Body.Close()
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
return nil, -1, err
}
if resp.StatusCode < 200 || resp.StatusCode >= 400 {
return nil, resp.StatusCode, newError(resp.StatusCode, body)
}
return body, resp.StatusCode, nil
}
//handle read and write
func handleConnection(conn net.Conn) {
//handle read
go func(conn net.Conn) {
reader := bufio.NewReader(os.Stdin)
for {
fmt.Print(">>")
line, _, _ := reader.ReadLine()
conn.Write([]byte(line))
}
}(conn)
//handle write
go func(conn net.Conn) {
bs := make([]byte, 1024)
for {
l, err := conn.Read(bs)
if err != nil {
fmt.Fprintf(os.Stderr, "Fatal error: %s", err.Error())
conn.Close()
}
fmt.Println("<<", string(bs[:l]))
}
}(conn)
}
func (c *Client) handle(conn net.Conn, ws *WorkServer) {
defer conn.Close()
reader := gob.NewDecoder(conn)
c.ClientInfo = new(Hyades.ClientInfo)
err := reader.Decode(c.ClientInfo)
if err != nil {
c.FrameWorkError(err)
return
}
c.Owner.Stats.Announced(c.ClientInfo)
log.Println(c.ClientInfo.ComputerName, " Connected")
c.Owner.Stats.Connected()
defer c.Owner.Stats.Disconnected(c.ClientInfo)
lc := logicsocket.Wrap(conn)
workConn := lc.NewConnection(WORK)
go c.ServiceWork(workConn)
heartbeatConn := lc.NewConnection(HEARTBEAT)
c.ServiceHeartBeat(heartbeatConn)
}
func (c *tlsCreds) ClientHandshake(addr string, rawConn net.Conn, timeout time.Duration) (_ net.Conn, _ AuthInfo, err error) {
// borrow some code from tls.DialWithDialer
var errChannel chan error
if timeout != 0 {
errChannel = make(chan error, 2)
time.AfterFunc(timeout, func() {
errChannel <- timeoutError{}
})
}
if c.config.ServerName == "" {
colonPos := strings.LastIndex(addr, ":")
if colonPos == -1 {
colonPos = len(addr)
}
c.config.ServerName = addr[:colonPos]
}
conn := tls.Client(rawConn, &c.config)
if timeout == 0 {
err = conn.Handshake()
} else {
go func() {
errChannel <- conn.Handshake()
}()
err = <-errChannel
}
if err != nil {
rawConn.Close()
return nil, nil, err
}
// TODO(zhaoq): Omit the auth info for client now. It is more for
// information than anything else.
return conn, nil, nil
}
func HandleIncomingSSHConn(nConn net.Conn, config *ssh.ServerConfig) {
DoneCh := make(chan bool)
go TimeoutConnection(DoneCh, nConn)
_, chans, reqs, err := ssh.NewServerConn(nConn, config)
if err == nil {
DoneCh <- true
}
// Right now that we are out of annoying people land.
defer nConn.Close()
go HandleSSHrequests(reqs)
for newChannel := range chans {
if newChannel.ChannelType() != "session" {
newChannel.Reject(ssh.UnknownChannelType, "unknown channel type")
log.Printf("WARNING - Rejecting %s Because they asked for a chan type %s that I don't have", nConn.RemoteAddr().String(), newChannel.ChannelType())
continue
}
channel, requests, err := newChannel.Accept()
if err != nil {
log.Printf("WARNING - Was unable to Accept channel with %s", nConn.RemoteAddr().String())
return
}
go HandleSSHrequests(requests)
go ServeDOSTerm(channel)
}
}
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 handle(conn net.Conn) {
defer conn.Close()
scanner := bufio.NewScanner(conn)
for scanner.Scan() {
ln := scanner.Text()
fs := strings.Fields(ln)
// skip blank lines
if len(fs) < 2 {
continue
}
switch fs[0] {
case "GET":
key := fs[1]
value := data[key]
fmt.Fprintf(conn, "%s\n", value)
case "SET":
if len(fs) != 3 {
io.WriteString(conn, "EXPECTED VALUE\n")
continue
}
key := fs[1]
value := fs[2]
data[key] = value
case "DEL":
default:
io.WriteString(conn, "INVALID COMMAND "+fs[0]+"\n")
}
}
}
// TODO isn't this identical to handleGraphiteTextProtocol?
func handleStatsdTextProtocol(t *trTransceiver, conn net.Conn, timeout int) {
defer conn.Close() // decrements tcpWg
if timeout != 0 {
conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
}
// We use the Scanner, becase it has a MaxScanTokenSize of 64K
connbuf := bufio.NewScanner(conn)
for connbuf.Scan() {
if stat, err := parseStatsdPacket(connbuf.Text()); err == nil {
t.queueStat(stat)
} else {
log.Printf("parseStatsdPacket(): %v", err)
}
if timeout != 0 {
conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
}
}
if err := connbuf.Err(); err != nil {
log.Println("handleStatsdTextProtocol(): Error reading: %v", err)
}
}
// Receive the file in blocks
func Receive(conn net.Conn, filePath string) {
// Defer closing the Connection handle
defer conn.Close()
// Open output file
fout, err := os.Create(filePath)
if err != nil {
log.Println("create ", filePath, "failed...", err)
log.Fatal(err)
}
// Defer closing the output file handle
defer fout.Close()
// File Writer Buffer init.
w := bufio.NewWriter(fout)
inBuffer := make([]byte, blockSize)
for {
numRead, err := conn.Read(inBuffer)
if err != nil || numRead == 0 {
log.Print("Encountered the end of file", numRead, err)
break
}
numWritten, _ := w.Write(inBuffer[:numRead])
log.Println(numRead, "bytes received", numWritten, "bytes written")
w.Flush()
}
}
/*
Close a network connection.
*/
func closeConn(t *testing.T, n net.Conn) error {
err := n.Close()
if err != nil {
t.Errorf("Unexpected n.Close() error: %v\n", err)
}
return err
}
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 (this *StorageClient) storageDeleteFile(tc *TrackerClient, storeServ *StorageServer, remoteFilename string) error {
var (
conn net.Conn
reqBuf []byte
err error
)
conn, err = this.pool.Get()
defer conn.Close()
if err != nil {
return err
}
th := &trackerHeader{}
th.cmd = STORAGE_PROTO_CMD_DELETE_FILE
fileNameLen := len(remoteFilename)
th.pkgLen = int64(FDFS_GROUP_NAME_MAX_LEN + fileNameLen)
th.sendHeader(conn)
req := &deleteFileRequest{}
req.groupName = storeServ.groupName
req.remoteFilename = remoteFilename
reqBuf, err = req.marshal()
if err != nil {
return err
}
TcpSendData(conn, reqBuf)
th.recvHeader(conn)
if th.status != 0 {
return Errno{int(th.status)}
}
return nil
}
func (cmd *cmdSync) PSyncPipeCopy(c net.Conn, br *bufio.Reader, bw *bufio.Writer, offset int64, copyto io.Writer) (int64, error) {
defer c.Close()
var nread atomic2.Int64
go func() {
defer c.Close()
for {
time.Sleep(time.Second * 5)
if err := sendPSyncAck(bw, offset+nread.Get()); err != nil {
return
}
}
}()
var p = make([]byte, 8192)
for {
n, err := br.Read(p)
if err != nil {
return nread.Get(), nil
}
if _, err := copyto.Write(p[:n]); err != nil {
return nread.Get(), err
}
nread.Add(int64(n))
}
}
// handleConnection handles an incoming connection
func (p *Provider) handleConnection(conn net.Conn) {
// Create an RPC server to handle inbound
pe := &providerEndpoint{p: p}
rpcServer := rpc.NewServer()
rpcServer.RegisterName("Client", pe)
rpcCodec := msgpackrpc.NewCodec(false, false, conn)
defer func() {
if !pe.hijacked() {
conn.Close()
}
}()
for !p.IsShutdown() {
if err := rpcServer.ServeRequest(rpcCodec); err != nil {
if err != io.EOF && !strings.Contains(err.Error(), "closed") {
p.logger.Printf("[ERR] scada-client: RPC error: %v", err)
}
return
}
// Handle potential hijack in Client.Connect
if pe.hijacked() {
cb := pe.getHijack()
cb(conn)
return
}
}
}
// Handles incoming requests for both TCP and UDP
func handleGraphiteTextProtocol(t *trTransceiver, conn net.Conn, timeout int) {
defer conn.Close() // decrements tcpWg
if timeout != 0 {
conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
}
// We use the Scanner, becase it has a MaxScanTokenSize of 64K
connbuf := bufio.NewScanner(conn)
for connbuf.Scan() {
packetStr := connbuf.Text()
if dp, err := parseGraphitePacket(packetStr); err != nil {
log.Printf("handleGraphiteTextProtocol(): bad backet: %v")
} else {
t.queueDataPoint(dp)
}
if timeout != 0 {
conn.SetDeadline(time.Now().Add(time.Duration(timeout) * time.Second))
}
}
if err := connbuf.Err(); err != nil {
log.Println("handleGraphiteTextProtocol(): Error reading: %v", err)
}
}
func httpServer(c net.Conn) {
buf := make([]byte, 5120)
nr, _ := c.Read(buf)
fmt.Println(string(buf[:nr]))
c.Write([]byte(stdresponse))
c.Close()
}
func handleConnection(client net.Conn) {
defer client.Close()
// sock version
ver := make([]byte, 1)
if n, _ := client.Read(ver); n != 1 {
log.Println("MethodRequest packet is too short")
return
}
var proxy SockProxy
switch ver[0] {
case 0x04:
proxy = new(Sock4)
case 0x05:
proxy = new(Sock5)
default:
log.Println("invalid socks version:", ver)
return
}
if err := proxy.Proxy(client); err != nil {
log.Println("Proxy error:", err)
return
}
return
}
// This function is expected to be called as a goroutine.
// TODO: Track and log bytes copied, like TCP
func (udp *udpProxySocket) proxyClient(cliAddr net.Addr, svrConn net.Conn, activeClients *clientCache, timeout time.Duration) {
defer svrConn.Close()
var buffer [4096]byte
for {
n, err := svrConn.Read(buffer[0:])
if err != nil {
if !logTimeout(err) {
glog.Errorf("Read failed: %v", err)
}
break
}
svrConn.SetDeadline(time.Now().Add(timeout))
if err != nil {
glog.Errorf("SetDeadline failed: %v", err)
break
}
n, err = udp.WriteTo(buffer[0:n], cliAddr)
if err != nil {
if !logTimeout(err) {
glog.Errorf("WriteTo failed: %v", err)
}
break
}
}
activeClients.mu.Lock()
delete(activeClients.clients, cliAddr.String())
activeClients.mu.Unlock()
}
func handleCient(conn net.Conn) {
conn.SetDeadline(time.Now().Add(2 * time.Minute))
request := make([]byte, 128)
defer conn.Close()
for {
read_len, err := conn.Read(request)
if err != nil {
fmt.Fprintf(os.Stderr, "error: %s", err)
break
}
fmt.Printf(string(read_len))
// if read_len == 0 {
// break
// } else if string(request) == "timestamp" {
daytime := time.Now().String()
conn.Write([]byte(daytime))
// }
}
request = make([]byte, 128)
}
// hanleTCPConn handle a long live tcp connection.
func handleTCPConn(conn net.Conn, rc chan *bufio.Reader) {
addr := conn.RemoteAddr().String()
log.Debug("<%s> handleTcpConn routine start", addr)
rd := newBufioReader(rc, conn)
if args, err := parseCmd(rd); err == nil {
// return buffer bufio.Reader
putBufioReader(rc, rd)
switch args[0] {
case "sub":
SubscribeTCPHandle(conn, args[1:])
break
default:
conn.Write(ParamReply)
log.Warn("<%s> unknown cmd \"%s\"", addr, args[0])
break
}
} else {
// return buffer bufio.Reader
putBufioReader(rc, rd)
log.Error("<%s> parseCmd() error(%v)", addr, err)
}
// close the connection
if err := conn.Close(); err != nil {
log.Error("<%s> conn.Close() error(%v)", addr, err)
}
log.Debug("<%s> handleTcpConn routine stop", addr)
return
}
func (self *ProtobufServer) handleConnection(conn net.Conn) {
log.Info("ProtobufServer: client connected: %s", conn.RemoteAddr().String())
message := make([]byte, 0, MAX_REQUEST_SIZE)
buff := bytes.NewBuffer(message)
var messageSizeU uint32
for {
err := binary.Read(conn, binary.LittleEndian, &messageSizeU)
if err != nil {
log.Error("Error reading from connection (%s): %s", conn.RemoteAddr().String(), err)
self.connectionMapLock.Lock()
delete(self.connectionMap, conn)
self.connectionMapLock.Unlock()
conn.Close()
return
}
messageSize := int64(messageSizeU)
if messageSize > MAX_REQUEST_SIZE {
err = self.handleRequestTooLarge(conn, messageSize, buff)
} else {
err = self.handleRequest(conn, messageSize, buff)
}
if err != nil {
log.Error("Error, closing connection: %s", err)
self.connectionMapLock.Lock()
delete(self.connectionMap, conn)
self.connectionMapLock.Unlock()
conn.Close()
return
}
buff.Reset()
}
}
func (s *Server) onConn(c net.Conn) {
defer s.wg.Done()
h := newHandler(s)
conn, err := server.NewConn(c, s.user, s.password, h)
if err != nil {
log.Errorf("new connection error %s", err.Error())
c.Close()
return
}
h.conn = conn
for {
select {
case <-s.quit:
// Proxy quited, close conection
conn.Close()
return
default:
break
}
err = conn.HandleCommand()
if err != nil {
log.Errorf("handle command error %s", err.Error())
return
}
}
}
func serverHandler(f base.ServerFactory, conn net.Conn, info *pt.ServerInfo) {
defer conn.Close()
termMon.onHandlerStart()
defer termMon.onHandlerFinish()
name := f.Transport().Name()
addrStr := log.ElideAddr(conn.RemoteAddr().String())
log.Infof("%s(%s) - new connection", name, addrStr)
// Instantiate the server transport method and handshake.
remote, err := f.WrapConn(conn)
if err != nil {
log.Warnf("%s(%s) - handshake failed: %s", name, addrStr, log.ElideError(err))
return
}
// Connect to the orport.
orConn, err := pt.DialOr(info, conn.RemoteAddr().String(), name)
if err != nil {
log.Errorf("%s(%s) - failed to connect to ORPort: %s", name, addrStr, log.ElideError(err))
return
}
defer orConn.Close()
if err = copyLoop(orConn, remote); err != nil {
log.Warnf("%s(%s) - closed connection: %s", name, addrStr, log.ElideError(err))
} else {
log.Infof("%s(%s) - closed connection", name, addrStr)
}
return
}
func receiveConn(conn net.Conn){
var buffer []byte
var err error
var n int
// if the max length of request is 128k
// also can use bufio.NewReader().ReadLine()
buffer = make([]byte,128)
for {
n, err = conn.Read(buffer)
// if client connection closed will happen io eof
// other reason example network timeout will happen
// timeout error
if err != nil {
if err == io.EOF {
log.Println("[Request][EOF]:", "client disconnect")
}
conn.Close()
break
}
if n != 0 {
fmt.Println("[Receive]:", string(buffer))
conn.Write(buffer)
}else {
conn.Write([]byte("error request"))
}
buffer = make([]byte, 128) //clear buffer
}
}