func getRequest(conn *connection.Conn, auth bool, timeout time.Duration) (host string, ota bool, err error) {
glog.V(5).Infoln("getRequest from remote34342")
connection.SetReadTimeout(conn, timeout)
// buf size should at least have the same size with the largest possible
// request size (when addrType is 3, domain name has at most 256 bytes)
// 1(addrType) + 1(lenByte) + 256(max length address) + 2(port) + 10(hmac-sha1)
buf := make([]byte, 270)
// read till we get possible domain length field
if _, err = io.ReadFull(conn, buf[:idType+1]); err != nil {
glog.Errorln("read buffer from remote connection error:", err)
return
}
// if _, err = io.ReadFull(conn, buf[:64]); err != nil {
// glog.Errorln("read buffer from remote connection error:", err)
// return
// }
// glog.V(5).Infof("Got a Request string is byte:%v string:%v)\r\n", buf, string(buf))
// return
var reqStart, reqEnd int
addrType := buf[idType]
switch addrType & connection.AddrMask {
case typeIPv4:
reqStart, reqEnd = idIP0, idIP0+lenIPv4
case typeIPv6:
reqStart, reqEnd = idIP0, idIP0+lenIPv6
case typeDm:
glog.V(5).Infoln("Got a Domain Addr Type, read start(%v) end(%v)\r\n", idType+1, idDmLen+1)
if _, err = io.ReadFull(conn, buf[idType+1:idDmLen+1]); err != nil {
glog.Errorf("Read from remote err:%v\r\n", err)
return
}
reqStart, reqEnd = idDm0, int(idDm0+buf[idDmLen]+lenDmBase)
default:
err = fmt.Errorf("addr type %d not supported", addrType&connection.AddrMask)
return
}
if _, err = io.ReadFull(conn, buf[reqStart:reqEnd]); err != nil {
return
}
glog.V(5).Infof("Got string from remote %v \r\n", buf[reqStart:reqEnd])
// Return string for typeIP is not most efficient, but browsers (Chrome,
// Safari, Firefox) all seems using typeDm exclusively. So this is not a
// big problem.
switch addrType & connection.AddrMask {
case typeIPv4:
host = net.IP(buf[idIP0 : idIP0+net.IPv4len]).String()
case typeIPv6:
host = net.IP(buf[idIP0 : idIP0+net.IPv6len]).String()
case typeDm:
host = string(buf[idDm0 : idDm0+buf[idDmLen]])
}
glog.V(5).Infof("Got host from remote: %v\r\n", host)
// parse port
port := binary.BigEndian.Uint16(buf[reqEnd-2 : reqEnd])
host = net.JoinHostPort(host, strconv.Itoa(int(port)))
// if specified one time auth enabled, we should verify this
if auth || addrType&connection.OneTimeAuthMask > 0 {
ota = true
if _, err = io.ReadFull(conn, buf[reqEnd:reqEnd+lenHmacSha1]); err != nil {
return
}
iv := conn.GetIv()
key := conn.GetKey()
actualHmacSha1Buf := util.HmacSha1(append(iv, key...), buf[:reqEnd])
if !bytes.Equal(buf[reqEnd:reqEnd+lenHmacSha1], actualHmacSha1Buf) {
err = fmt.Errorf("verify one time auth failed, iv=%v key=%v data=%v", iv, key, buf[:reqEnd])
return
}
}
return
}
func handleConnection(conn *connection.Conn, auth bool, timeout time.Duration) {
var host string
connCnt++ // this maybe not accurate, but should be enough
if connCnt-nextLogConnCnt >= 0 {
// XXX There's no xadd in the atomic package, so it's difficult to log
// the message only once with low cost. Also note nextLogConnCnt maybe
// added twice for current peak connection number level.
log.Printf("Number of client connections reaches %d\n", nextLogConnCnt)
nextLogConnCnt += logCntDelta
}
// function arguments are always evaluated, so surround debug statement
// with if statement
glog.V(5).Infof("new client %s->%s\n", conn.RemoteAddr().String(), conn.LocalAddr())
closed := false
defer func() {
glog.V(5).Infof("closed pipe %s<->%s\n", conn.RemoteAddr(), host)
connCnt--
if !closed {
conn.Close()
}
}()
host, ota, err := getRequest(conn, auth, timeout)
if err != nil {
glog.Errorf("error getting request %v<->%v err:%v", conn.RemoteAddr(), conn.LocalAddr(), err)
return
}
glog.V(5).Infof("connection host:%v ota:%v \r\n", host, ota)
remote, err := net.Dial("tcp", host)
if err != nil {
if ne, ok := err.(*net.OpError); ok && (ne.Err == syscall.EMFILE || ne.Err == syscall.ENFILE) {
// log too many open file error
// EMFILE is process reaches open file limits, ENFILE is system limit
glog.Errorf("dial error:%v\r\n", err)
} else {
glog.Errorf(" connecting to:%v occur err:%v", host, err)
}
return
}
defer func() {
if !closed {
remote.Close()
}
}()
glog.V(5).Infof("piping %s<->%s ota=%v connOta=%v", conn.RemoteAddr(), host, ota, conn.IsOta())
if ota {
go connection.PipeThenCloseOta(conn, remote, timeout)
} else {
go connection.PipeThenClose(conn, remote, timeout)
}
connection.PipeThenClose(remote, conn, timeout)
closed = true
return
}