// socksAuthRFC1929 authenticates the client via RFC 1929 username/password
// auth. As a design decision any valid username/password is accepted as this
// field is primarily used as an out-of-band argument passing mechanism for
// pluggable transports.
func socksAuthRFC1929(rw *bufio.ReadWriter, req *SocksRequest) (err error) {
sendErrResp := func() {
// Swallow the write/flush error here, we are going to close the
// connection and the original failure is more useful.
resp := []byte{socksAuthRFC1929Ver, socksAuthRFC1929Fail}
rw.Write(resp[:])
socksFlushBuffers(rw)
}
// Validate the fixed parts of the command message.
if err = socksReadByteVerify(rw, "auth version", socksAuthRFC1929Ver); err != nil {
sendErrResp()
return
}
// Read the username.
var ulen byte
if ulen, err = socksReadByte(rw); err != nil {
return
}
if ulen < 1 {
sendErrResp()
err = fmt.Errorf("RFC1929 username with 0 length")
return
}
var uname []byte
if uname, err = socksReadBytes(rw, int(ulen)); err != nil {
return
}
req.Username = string(uname)
// Read the password.
var plen byte
if plen, err = socksReadByte(rw); err != nil {
return
}
if plen < 1 {
sendErrResp()
err = fmt.Errorf("RFC1929 password with 0 length")
return
}
var passwd []byte
if passwd, err = socksReadBytes(rw, int(plen)); err != nil {
return
}
if !(plen == 1 && passwd[0] == 0x00) {
// tor will set the password to 'NUL' if there are no arguments.
req.Password = string(passwd)
}
// Mash the username/password together and parse it as a pluggable
// transport argument string.
if req.Args, err = parseClientParameters(req.Username + req.Password); err != nil {
sendErrResp()
} else {
resp := []byte{socksAuthRFC1929Ver, socksAuthRFC1929Success}
_, err = rw.Write(resp[:])
}
return
}
func recvMsg(rwr *bufio.ReadWriter, userId int64) {
var (
ok bool
conn net.Conn
closeErr error
)
//close old connection and channel
if _, ok = us.chs[userId]; ok {
conn = us.conns[userId]
if closeErr = conn.Close(); closeErr != nil {
println("close old connection error:", userId)
}
}
//是为了其他的服务器可以读取redis的值来判断是否在线
set(userId)
res, _ := get(userId)
log.Debug("%v", res)
pushKafka(userId)
var ta = make(chan Talk, 1)
var ch Channel
ch.ch = ta
us.chs[userId] = ch
for {
talk := <-us.chs[userId].ch
log.Debug("recv:%v", talk)
str := fmt.Sprintf("<script>alert(\"%d:%s\")</script>", talk.userId, talk.msg)
rwr.WriteString(str)
rwr.Flush()
}
}
func getLocal(rw *bufio.ReadWriter) (data []byte, flags uint32, err error) {
if err := rw.Flush(); err != nil {
return nil, 0, err
}
resHeader, err := binprot.ReadResponseHeader(rw)
if err != nil {
return nil, 0, err
}
err = binprot.DecodeError(resHeader)
if err != nil {
if _, ioerr := rw.Discard(int(resHeader.TotalBodyLength)); ioerr != nil {
return nil, 0, ioerr
}
return nil, 0, err
}
var serverFlags uint32
binary.Read(rw, binary.BigEndian, &serverFlags)
// total body - key - extra
dataLen := resHeader.TotalBodyLength - uint32(resHeader.KeyLength) - uint32(resHeader.ExtraLength)
buf := make([]byte, dataLen)
// Read in value
if _, err := io.ReadFull(rw, buf); err != nil {
return nil, 0, err
}
return buf, serverFlags, nil
}
func hijacked500(brw *bufio.ReadWriter, protoMinor int, statuses *statusStats) {
statuses.status5xx.Add(1)
// Assumes HTTP/1.x
s := fmt.Sprintf(resp500Format, protoMinor, time.Now().Format(http.TimeFormat))
brw.WriteString(s)
brw.Flush()
}
func (w *rpcWorker) callRPC(conn *bufio.ReadWriter, req *pdpb.Request) (resp *pdpb.Response, err error) {
// Record some metrics.
start := time.Now()
label := metrics.GetCmdLabel(req)
defer func() {
if err == nil {
cmdCounter.WithLabelValues(label).Inc()
cmdDuration.WithLabelValues(label).Observe(time.Since(start).Seconds())
} else {
cmdFailedCounter.WithLabelValues(label).Inc()
cmdFailedDuration.WithLabelValues(label).Observe(time.Since(start).Seconds())
}
}()
msg := &msgpb.Message{
MsgType: msgpb.MessageType_PdReq,
PdReq: req,
}
if err = util.WriteMessage(conn, newMsgID(), msg); err != nil {
return nil, errors.Errorf("[pd] rpc failed: %v", err)
}
conn.Flush()
if _, err = util.ReadMessage(conn, msg); err != nil {
return nil, errors.Errorf("[pd] rpc failed: %v", err)
}
if msg.GetMsgType() != msgpb.MessageType_PdResp {
return nil, errors.Trace(errInvalidResponse)
}
resp = msg.GetPdResp()
if err = w.checkResponse(resp); err != nil {
return nil, errors.Trace(err)
}
return resp, nil
}
func getMetadataCommon(rw *bufio.ReadWriter) (metadata, error) {
if err := rw.Flush(); err != nil {
return metadata{}, err
}
resHeader, err := binprot.ReadResponseHeader(rw)
if err != nil {
return metadata{}, err
}
err = binprot.DecodeError(resHeader)
if err != nil {
// read in the message "Not found" after a miss
if _, ioerr := rw.Discard(int(resHeader.TotalBodyLength)); ioerr != nil {
return metadata{}, ioerr
}
return metadata{}, err
}
serverFlags := make([]byte, 4)
binary.Read(rw, binary.BigEndian, &serverFlags)
var metaData metadata
binary.Read(rw, binary.BigEndian, &metaData)
return metaData, nil
}
func complex_handshake(rw *bufio.ReadWriter, input []byte) bool {
result, scheme, challenge, digest := validateClient(input)
if !result {
return result
}
log.Debugf("Validate Client %v scheme %v challenge %0X digest %0X", result, scheme, challenge, digest)
s1 := create_s1()
log.Debug("s1 length", len(s1))
off := getDigestOffset(s1, scheme)
log.Debug("s1 digest offset", off)
buf := new(bytes.Buffer)
buf.Write(s1[:off])
buf.Write(s1[off+32:])
tempHash, _ := HMACsha256(buf.Bytes(), GENUINE_FMS_KEY[:36])
copy(s1[off:], tempHash)
log.Debug("s1 length", len(s1))
//compute the challenge digest
tempHash, _ = HMACsha256(digest, GENUINE_FMS_KEY[:68])
log.Debug("s2 length tempHash", len(tempHash))
randBytes := create_s2()
log.Debug("s2 length", len(randBytes))
lastHash, _ := HMACsha256(randBytes, tempHash)
log.Debug("s2 length lastHash", len(lastHash))
log.Debug("s2 length", len(randBytes))
buf = new(bytes.Buffer)
buf.WriteByte(0x03)
buf.Write(s1)
buf.Write(randBytes)
buf.Write(lastHash)
log.Debug("send s0s1s2", buf.Len())
rw.Write(buf.Bytes())
rw.Flush()
ReadBuf(rw, HANDSHAKE_SIZE)
return true
}
/*
* Read command/input from connection.
* @param b *bufioReadWriter - reader
* @return cmd string - read input
* @return err error - error state
*/
func readCmd(b *bufio.ReadWriter) (cmd string, err error) {
line, err := b.ReadBytes('\n')
if err != nil {
return "", err
}
// get rid of enclosing white spaces
return strings.Trim(string(line), " \t\n\v\r"), nil
}
func (ms MemcachedProtocolServer) writeLine(buf *bufio.ReadWriter, s string) error {
_, err := buf.WriteString(fmt.Sprintf("%s\r\n", s))
if err != nil {
return err
}
err = buf.Flush()
return err
}
func writeResponse(bw *bufio.ReadWriter, body ...string) error {
for _, chunk := range body {
if _, err := bw.WriteString(chunk); err != nil {
return err
}
}
return bw.Flush()
}
func writeMessage(w *bufio.ReadWriter, m Message) {
raw := ""
for k, v := range m {
raw += k + ":" + v + "\r\n"
}
raw += "\r\n"
w.WriteString(raw)
w.Flush()
}
func (t TextProt) Prepend(rw *bufio.ReadWriter, key []byte, value []byte) error {
if _, err := fmt.Fprintf(rw, "prepend %s 0 0 %v\r\n%s\r\n", string(key), len(value), string(value)); err != nil {
return err
}
rw.Flush()
_, err := rw.ReadString('\n')
return err
}
func writeReadLine(rw *bufio.ReadWriter, format string, args ...interface{}) ([]byte, error) {
_, err := fmt.Fprintf(rw, format, args...)
if err != nil {
return nil, err
}
if err := rw.Flush(); err != nil {
return nil, err
}
line, err := rw.ReadSlice('\n')
return line, err
}
func pushResponse(bufrw *bufio.ReadWriter, authCode string) bool {
_, err := bufrw.Write([]byte(authCode))
if err == nil {
err = bufrw.Flush()
}
if err != nil {
go_lib.LogErrorf("PushAuthCodeError: %s\n", err)
return false
}
return true
}
func (b BinProt) GetWithOpaque(rw *bufio.ReadWriter, key []byte, opaque int) ([]byte, error) {
// Header
writeReq(rw, Get, len(key), 0, len(key), opaque)
// Body
rw.Write(key)
rw.Flush()
// consume all of the response and return
return consumeResponseCheckOpaque(rw.Reader, opaque)
}
func (b BinProt) GetE(rw *bufio.ReadWriter, key []byte) ([]byte, uint32, uint32, error) {
// Header
writeReq(rw, GetE, len(key), 0, len(key), 0)
// Body
rw.Write(key)
rw.Flush()
// consume all of the response and return
return consumeResponseE(rw.Reader)
}
func (b BinProt) Get(rw *bufio.ReadWriter, key []byte) error {
// Header
writeReq(rw, Get, len(key), 0, len(key))
// Body
rw.Write(key)
rw.Flush()
// consume all of the response and discard
return consumeResponse(rw.Reader)
}
func Part(rw *bufio.ReadWriter, channel string) error {
var (
str string = fmt.Sprintf("PART %s\r\n", channel)
err error
)
_, err = rw.Write([]byte(str))
if err != nil {
return err
}
rw.Flush()
return nil
}
func Quit(rw *bufio.ReadWriter, reason string) error {
var (
str string = fmt.Sprintf("QUIT %s\r\n", reason)
err error
)
_, err = rw.Write([]byte(str))
if err != nil {
return err
}
rw.Flush()
return nil
}
func Register(rw *bufio.ReadWriter, user, real string) error {
var (
str string = fmt.Sprintf("USER %s 0 * :%s\r\n", user, real)
err error
)
_, err = rw.Write([]byte(str))
if err != nil {
return err
}
rw.Flush()
return nil
}
func Ping(rw *bufio.ReadWriter, message string) error {
var (
str string = fmt.Sprintf("PING %s\r\n", message)
err error
)
_, err = rw.Write([]byte(str))
if err != nil {
return err
}
rw.Flush()
return nil
}
func Message(rw *bufio.ReadWriter, target, message string) error {
var (
str string = fmt.Sprintf("PRIVMSG %s :%s\r\n", target, message)
err error
)
_, err = rw.Write([]byte(str))
if err != nil {
return err
}
rw.Flush()
return nil
}
// execute sends a command to redis, then reads and parses the response.
// It uses the old protocol and can be used by simple commands, such as DB.
// Redis protocol <http://redis.io/topics/protocol>
func (c *Client) execute(rw *bufio.ReadWriter, a ...interface{}) (v interface{}, err error) {
//fmt.Printf("\nSending: %#v\n", a)
// old redis protocol.
_, err = fmt.Fprintf(rw, strings.Join(autoconv_args(a), " ")+"\r\n")
if err != nil {
return
}
if err = rw.Flush(); err != nil {
return
}
return c.parseResponse(rw.Reader)
}
func ChangeNick(rw *bufio.ReadWriter, nick string) error {
var (
str string = fmt.Sprintf("NICK %s\r\n", nick)
err error
)
_, err = rw.Write([]byte(str))
if err != nil {
return err
}
rw.Flush()
return nil
}
func pushResponse(bufrw *bufio.ReadWriter, content interface{}, group string, op string) {
literals := fmt.Sprintf("%v", content)
_, err := bufrw.Write([]byte(literals))
if err == nil {
err = bufrw.Flush()
}
if err != nil {
base.Logger().Errorf("Pushing response error (content=%v, group=%s, op=%s): %s\n", literals, group, op, err)
} else {
base.Logger().Errorf("The response '%v' has been pushed. (group=%s, op=%s)\n", literals, group, op)
}
}
func (b BinProt) Delete(rw *bufio.ReadWriter, key []byte) error {
// Header
writeReq(rw, Delete, len(key), 0, len(key), 0)
// Body
rw.Write(key)
rw.Flush()
// consume all of the response and discard
_, err := consumeResponse(rw.Reader)
return err
}
func (b BinProt) GAT(rw *bufio.ReadWriter, key []byte) ([]byte, error) {
// Header
writeReq(rw, GAT, len(key), 4, len(key), 0)
// Extras
binary.Write(rw, binary.BigEndian, common.Exp())
// Body
rw.Write(key)
rw.Flush()
// consume all of the response and return
return consumeResponse(rw.Reader)
}
func (b BinProt) Touch(rw *bufio.ReadWriter, key []byte) error {
// Header
writeReq(rw, Touch, len(key), 4, len(key)+4)
// Extras
binary.Write(rw, binary.BigEndian, common.Exp())
// Body
rw.Write(key)
rw.Flush()
// consume all of the response and discard
return consumeResponse(rw.Reader)
}
func writeChunks(r io.Reader, w *bufio.ReadWriter) error {
buf := make([]byte, 32*1024)
for {
n, err := r.Read(buf)
if n > 0 {
length := fmt.Sprintf("%x\r\n", n)
w.WriteString(length)
_, err := w.Write(buf[0:n])
if err != nil {
return err
}
w.WriteString("\r\n")
w.Flush()
}
if err != nil && err != io.EOF {
return err
}
if err == io.EOF {
break
}
}
return nil
}
// hijack connection
func hijack(rw http.ResponseWriter) (conn net.Conn, err error) {
hj, ok := rw.(http.Hijacker)
if !ok {
err = errors.New("webserver doesn't support hijacking")
return
}
var buf *bufio.ReadWriter
conn, buf, err = hj.Hijack()
if err != nil {
return
}
buf.Flush()
return
}