mirror of https://bitbucket.org/ausocean/av.git
726 lines
18 KiB
Go
726 lines
18 KiB
Go
/*
|
|
NAME
|
|
rtmp.go
|
|
|
|
DESCRIPTION
|
|
RTMP command functionality.
|
|
|
|
AUTHORS
|
|
Saxon Nelson-Milton <saxon@ausocean.org>
|
|
Dan Kortschak <dan@ausocean.org>
|
|
Alan Noble <alan@ausocean.org>
|
|
|
|
LICENSE
|
|
rtmp.go is Copyright (C) 2017-2019 the Australian Ocean Lab (AusOcean)
|
|
|
|
It is free software: you can redistribute it and/or modify them
|
|
under the terms of the GNU General Public License as published by the
|
|
Free Software Foundation, either version 3 of the License, or (at your
|
|
option) any later version.
|
|
|
|
It is distributed in the hope that it will be useful, but WITHOUT
|
|
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
|
|
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
|
|
for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with revid in gpl.txt. If not, see http://www.gnu.org/licenses.
|
|
|
|
Derived from librtmp under the GNU Lesser General Public License 2.1
|
|
Copyright (C) 2005-2008 Team XBMC http://www.xbmc.org
|
|
Copyright (C) 2008-2009 Andrej Stepanchuk
|
|
Copyright (C) 2009-2010 Howard Chu
|
|
*/
|
|
|
|
package rtmp
|
|
|
|
import (
|
|
"bytes"
|
|
"encoding/binary"
|
|
"errors"
|
|
"math/rand"
|
|
"net"
|
|
"strconv"
|
|
"time"
|
|
|
|
"bitbucket.org/ausocean/av/rtmp/amf"
|
|
)
|
|
|
|
const (
|
|
pkg = "rtmp:"
|
|
signatureSize = 1536
|
|
fullHeaderSize = 12
|
|
)
|
|
|
|
// Link flags.
|
|
const (
|
|
linkAuth = 0x0001 // using auth param
|
|
linkLive = 0x0002 // stream is live
|
|
linkSWF = 0x0004 // do SWF verification - not implemented
|
|
linkPlaylist = 0x0008 // send playlist before play - not implemented
|
|
linkBufx = 0x0010 // toggle stream on BufferEmpty msg - not implemented
|
|
)
|
|
|
|
// Protocol features.
|
|
const (
|
|
featureHTTP = 0x01 // not implemented
|
|
featureEncode = 0x02 // not implemented
|
|
featureSSL = 0x04 // not implemented
|
|
featureMFP = 0x08 // not implemented
|
|
featureWrite = 0x10 // publish, not play
|
|
featureHTTP2 = 0x20 // server-side RTMPT - not implemented
|
|
)
|
|
|
|
// RTMP protocols.
|
|
const (
|
|
protoRTMP = 0
|
|
protoRTMPE = featureEncode
|
|
protoRTMPT = featureHTTP
|
|
protoRTMPS = featureSSL
|
|
protoRTMPTE = (featureHTTP | featureEncode)
|
|
protoRTMPTS = (featureHTTP | featureSSL)
|
|
protoRTMFP = featureMFP
|
|
)
|
|
|
|
// RTMP tokens (lexemes).
|
|
// NB: Underscores are deliberately preserved in const names where they exist in the corresponding tokens.
|
|
const (
|
|
av_checkbw = "_checkbw"
|
|
av_onbwcheck = "_onbwcheck"
|
|
av_onbwdone = "_onbwdone"
|
|
av_result = "_result"
|
|
avApp = "app"
|
|
avAudioCodecs = "audioCodecs"
|
|
avCapabilities = "capabilities"
|
|
avClose = "close"
|
|
avCode = "code"
|
|
avConnect = "connect"
|
|
avCreatestream = "createStream"
|
|
avDeletestream = "deleteStream"
|
|
avFCPublish = "FCPublish"
|
|
avFCUnpublish = "FCUnpublish"
|
|
avFlashver = "flashVer"
|
|
avFpad = "fpad"
|
|
avLevel = "level"
|
|
avLive = "live"
|
|
avNetConnectionConnectInvalidApp = "NetConnection.Connect.InvalidApp"
|
|
avNetStreamFailed = "NetStream.Failed"
|
|
avNetStreamPauseNotify = "NetStream.Pause.Notify"
|
|
avNetStreamPlayComplete = "NetStream.Play.Complete"
|
|
avNetStreamPlayFailed = "NetStream.Play.Failed"
|
|
avNetStreamPlayPublishNotify = "NetStream.Play.PublishNotify"
|
|
avNetStreamPlayStart = "NetStream.Play.Start"
|
|
avNetStreamPlayStop = "NetStream.Play.Stop"
|
|
avNetStreamPlayStreamNotFound = "NetStream.Play.StreamNotFound"
|
|
avNetStreamPlayUnpublishNotify = "NetStream.Play.UnpublishNotify"
|
|
avNetStreamPublish_Start = "NetStream.Publish.Start"
|
|
avNetStreamSeekNotify = "NetStream.Seek.Notify"
|
|
avNonprivate = "nonprivate"
|
|
avObjectEncoding = "objectEncoding"
|
|
avOnBWDone = "onBWDone"
|
|
avOnFCSubscribe = "onFCSubscribe"
|
|
avOnFCUnsubscribe = "onFCUnsubscribe"
|
|
avOnStatus = "onStatus"
|
|
avPageUrl = "pageUrl"
|
|
avPing = "ping"
|
|
avPlay = "play"
|
|
avPlaylist_ready = "playlist_ready"
|
|
avPublish = "publish"
|
|
avReleasestream = "releaseStream"
|
|
avSecureToken = "secureToken"
|
|
avSet_playlist = "set_playlist"
|
|
avSwfUrl = "swfUrl"
|
|
avTcUrl = "tcUrl"
|
|
avType = "type"
|
|
avVideoCodecs = "videoCodecs"
|
|
avVideoFunction = "videoFunction"
|
|
)
|
|
|
|
// RTMP protocol strings.
|
|
var rtmpProtocolStrings = [...]string{
|
|
"rtmp",
|
|
"rtmpt",
|
|
"rtmpe",
|
|
"rtmpte",
|
|
"rtmps",
|
|
"rtmpts",
|
|
"",
|
|
"",
|
|
"rtmfp",
|
|
}
|
|
|
|
// RTMP errors.
|
|
var (
|
|
errUnknownScheme = errors.New("rtmp: unknown scheme")
|
|
errInvalidURL = errors.New("rtmp: invalid URL")
|
|
errConnected = errors.New("rtmp: already connected")
|
|
errNotConnected = errors.New("rtmp: not connected")
|
|
errNotWritable = errors.New("rtmp: connection not writable")
|
|
errInvalidHeader = errors.New("rtmp: invalid header")
|
|
errInvalidBody = errors.New("rtmp: invalid body")
|
|
errInvalidFlvTag = errors.New("rtmp: invalid FLV tag")
|
|
errUnimplemented = errors.New("rtmp: unimplemented feature")
|
|
)
|
|
|
|
// connect establishes an RTMP connection.
|
|
func connect(c *Conn) error {
|
|
addr, err := net.ResolveTCPAddr("tcp4", c.link.host+":"+strconv.Itoa(int(c.link.port)))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.link.conn, err = net.DialTCP("tcp4", nil, addr)
|
|
if err != nil {
|
|
c.log(WarnLevel, pkg+"dial failed", "error", err.Error())
|
|
return err
|
|
}
|
|
c.log(DebugLevel, pkg+"connected")
|
|
err = handshake(c)
|
|
if err != nil {
|
|
c.log(WarnLevel, pkg+"handshake failed", "error", err.Error())
|
|
return err
|
|
}
|
|
c.log(DebugLevel, pkg+"handshaked")
|
|
err = sendConnectPacket(c)
|
|
if err != nil {
|
|
c.log(WarnLevel, pkg+"sendConnect failed", "error", err.Error())
|
|
return err
|
|
}
|
|
c.log(DebugLevel, pkg+"negotiating")
|
|
for !c.isPlaying {
|
|
pkt := packet{}
|
|
err = pkt.readFrom(c)
|
|
if err != nil {
|
|
break
|
|
}
|
|
|
|
switch pkt.packetType {
|
|
case packetTypeAudio, packetTypeVideo, packetTypeInfo:
|
|
c.log(WarnLevel, pkg+"got packet before play; ignoring", "type", pkt.packetType)
|
|
default:
|
|
err = handlePacket(c, &pkt)
|
|
if err != nil {
|
|
break
|
|
}
|
|
}
|
|
}
|
|
|
|
if !c.isPlaying {
|
|
return err
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// handlePacket handles a packet that the client has received.
|
|
// NB: Unsupported packet types are logged fatally.
|
|
func handlePacket(c *Conn, pkt *packet) error {
|
|
if pkt.bodySize < 4 {
|
|
return errInvalidBody
|
|
}
|
|
|
|
switch pkt.packetType {
|
|
case packetTypeChunkSize:
|
|
c.inChunkSize = amf.DecodeInt32(pkt.body[:4])
|
|
c.log(DebugLevel, pkg+"set inChunkSize", "size", int(c.inChunkSize))
|
|
|
|
case packetTypeBytesReadReport:
|
|
c.log(DebugLevel, pkg+"received packetTypeBytesReadReport")
|
|
|
|
case packetTypeServerBW:
|
|
c.serverBW = amf.DecodeInt32(pkt.body[:4])
|
|
c.log(DebugLevel, pkg+"set serverBW", "size", int(c.serverBW))
|
|
|
|
case packetTypeClientBW:
|
|
c.clientBW = amf.DecodeInt32(pkt.body[:4])
|
|
c.log(DebugLevel, pkg+"set clientBW", "size", int(c.clientBW))
|
|
if pkt.bodySize > 4 {
|
|
c.clientBW2 = pkt.body[4]
|
|
c.log(DebugLevel, pkg+"set clientBW2", "size", int(c.clientBW2))
|
|
} else {
|
|
c.clientBW2 = 0xff
|
|
}
|
|
|
|
case packetTypeInvoke:
|
|
err := handleInvoke(c, pkt.body[:pkt.bodySize])
|
|
if err != nil {
|
|
c.log(WarnLevel, pkg+"unexpected error from handleInvoke", "error", err.Error())
|
|
return err
|
|
}
|
|
|
|
case packetTypeControl, packetTypeAudio, packetTypeVideo, packetTypeFlashVideo, packetTypeFlexMessage, packetTypeInfo:
|
|
c.log(FatalLevel, pkg+"unsupported packet type "+strconv.Itoa(int(pkt.packetType)))
|
|
|
|
default:
|
|
c.log(WarnLevel, pkg+"unknown packet type", "type", pkt.packetType)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func sendConnectPacket(c *Conn) error {
|
|
var pbuf [4096]byte
|
|
pkt := packet{
|
|
channel: chanControl,
|
|
headerType: headerSizeLarge,
|
|
packetType: packetTypeInvoke,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
enc, err := amf.EncodeString(enc, avConnect)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.numInvokes += 1
|
|
enc, err = amf.EncodeNumber(enc, float64(c.numInvokes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
enc[0] = amf.TypeObject
|
|
enc = enc[1:]
|
|
enc, err = amf.EncodeNamedString(enc, avApp, c.link.app)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc, err = amf.EncodeNamedString(enc, avType, avNonprivate)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc, err = amf.EncodeNamedString(enc, avTcUrl, c.link.url)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc, err = amf.EncodeInt24(enc, amf.TypeObjectEnd)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// add auth string, if any
|
|
if c.link.auth != "" {
|
|
enc, err = amf.EncodeBoolean(enc, c.link.flags&linkAuth != 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc, err = amf.EncodeString(enc, c.link.auth)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
pkt.bodySize = uint32((len(pbuf) - fullHeaderSize) - len(enc))
|
|
|
|
return pkt.writeTo(c, true) // response expected
|
|
}
|
|
|
|
func sendCreateStream(c *Conn) error {
|
|
var pbuf [256]byte
|
|
pkt := packet{
|
|
channel: chanControl,
|
|
headerType: headerSizeMedium,
|
|
packetType: packetTypeInvoke,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
enc, err := amf.EncodeString(enc, avCreatestream)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.numInvokes++
|
|
enc, err = amf.EncodeNumber(enc, float64(c.numInvokes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc[0] = amf.TypeNull
|
|
enc = enc[1:]
|
|
|
|
pkt.bodySize = uint32((len(pbuf) - fullHeaderSize) - len(enc))
|
|
|
|
return pkt.writeTo(c, true) // response expected
|
|
}
|
|
|
|
func sendReleaseStream(c *Conn) error {
|
|
var pbuf [1024]byte
|
|
pkt := packet{
|
|
channel: chanControl,
|
|
headerType: headerSizeMedium,
|
|
packetType: packetTypeInvoke,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
enc, err := amf.EncodeString(enc, avReleasestream)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.numInvokes++
|
|
enc, err = amf.EncodeNumber(enc, float64(c.numInvokes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc[0] = amf.TypeNull
|
|
enc = enc[1:]
|
|
enc, err = amf.EncodeString(enc, c.link.playpath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pkt.bodySize = uint32((len(pbuf) - fullHeaderSize) - len(enc))
|
|
|
|
return pkt.writeTo(c, false)
|
|
}
|
|
|
|
func sendFCPublish(c *Conn) error {
|
|
var pbuf [1024]byte
|
|
pkt := packet{
|
|
channel: chanControl,
|
|
headerType: headerSizeMedium,
|
|
packetType: packetTypeInvoke,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
enc, err := amf.EncodeString(enc, avFCPublish)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.numInvokes++
|
|
enc, err = amf.EncodeNumber(enc, float64(c.numInvokes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc[0] = amf.TypeNull
|
|
enc = enc[1:]
|
|
enc, err = amf.EncodeString(enc, c.link.playpath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
pkt.bodySize = uint32((len(pbuf) - fullHeaderSize) - len(enc))
|
|
|
|
return pkt.writeTo(c, false)
|
|
}
|
|
|
|
func sendFCUnpublish(c *Conn) error {
|
|
var pbuf [1024]byte
|
|
pkt := packet{
|
|
channel: chanControl,
|
|
headerType: headerSizeMedium,
|
|
packetType: packetTypeInvoke,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
enc, err := amf.EncodeString(enc, avFCUnpublish)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.numInvokes++
|
|
enc, err = amf.EncodeNumber(enc, float64(c.numInvokes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc[0] = amf.TypeNull
|
|
enc = enc[1:]
|
|
enc, err = amf.EncodeString(enc, c.link.playpath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
pkt.bodySize = uint32((len(pbuf) - fullHeaderSize) - len(enc))
|
|
|
|
return pkt.writeTo(c, false)
|
|
}
|
|
|
|
func sendPublish(c *Conn) error {
|
|
var pbuf [1024]byte
|
|
pkt := packet{
|
|
channel: chanSource,
|
|
headerType: headerSizeLarge,
|
|
packetType: packetTypeInvoke,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
enc, err := amf.EncodeString(enc, avPublish)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.numInvokes++
|
|
enc, err = amf.EncodeNumber(enc, float64(c.numInvokes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc[0] = amf.TypeNull
|
|
enc = enc[1:]
|
|
enc, err = amf.EncodeString(enc, c.link.playpath)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc, err = amf.EncodeString(enc, avLive)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
pkt.bodySize = uint32((len(pbuf) - fullHeaderSize) - len(enc))
|
|
|
|
return pkt.writeTo(c, true) // response expected
|
|
}
|
|
|
|
func sendDeleteStream(c *Conn, streamID float64) error {
|
|
var pbuf [256]byte
|
|
pkt := packet{
|
|
channel: chanControl,
|
|
headerType: headerSizeMedium,
|
|
packetType: packetTypeInvoke,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
enc, err := amf.EncodeString(enc, avDeletestream)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.numInvokes++
|
|
enc, err = amf.EncodeNumber(enc, float64(c.numInvokes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc[0] = amf.TypeNull
|
|
enc = enc[1:]
|
|
enc, err = amf.EncodeNumber(enc, streamID)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pkt.bodySize = uint32((len(pbuf) - fullHeaderSize) - len(enc))
|
|
|
|
return pkt.writeTo(c, false)
|
|
}
|
|
|
|
// sendBytesReceived tells the server how many bytes the client has received.
|
|
func sendBytesReceived(c *Conn) error {
|
|
var pbuf [256]byte
|
|
pkt := packet{
|
|
channel: chanBytesRead,
|
|
headerType: headerSizeMedium,
|
|
packetType: packetTypeBytesReadReport,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
c.nBytesInSent = c.nBytesIn
|
|
|
|
enc, err := amf.EncodeInt32(enc, c.nBytesIn)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
pkt.bodySize = 4
|
|
|
|
return pkt.writeTo(c, false)
|
|
}
|
|
|
|
func sendCheckBW(c *Conn) error {
|
|
var pbuf [256]byte
|
|
pkt := packet{
|
|
channel: chanControl,
|
|
headerType: headerSizeLarge,
|
|
packetType: packetTypeInvoke,
|
|
buf: pbuf[:],
|
|
body: pbuf[fullHeaderSize:],
|
|
}
|
|
enc := pkt.body
|
|
|
|
enc, err := amf.EncodeString(enc, av_checkbw)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.numInvokes++
|
|
enc, err = amf.EncodeNumber(enc, float64(c.numInvokes))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
enc[0] = amf.TypeNull
|
|
enc = enc[1:]
|
|
|
|
pkt.bodySize = uint32((len(pbuf) - fullHeaderSize) - len(enc))
|
|
|
|
return pkt.writeTo(c, false)
|
|
}
|
|
|
|
func eraseMethod(m []method, i int) []method {
|
|
copy(m[i:], m[i+1:])
|
|
m[len(m)-1] = method{}
|
|
return m[:len(m)-1]
|
|
}
|
|
|
|
// int handleInvoke handles a packet invoke request
|
|
// Side effects: c.isPlaying set to true upon avNetStreamPublish_Start
|
|
func handleInvoke(c *Conn, body []byte) error {
|
|
if body[0] != 0x02 {
|
|
return errInvalidBody
|
|
}
|
|
var obj amf.Object
|
|
_, err := amf.Decode(&obj, body, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
meth, err := obj.StringProperty("", 0)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
txn, err := obj.NumberProperty("", 1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
c.log(DebugLevel, pkg+"invoking method "+meth)
|
|
switch meth {
|
|
case av_result:
|
|
if (c.link.protocol & featureWrite) == 0 {
|
|
return errNotWritable
|
|
}
|
|
var methodInvoked string
|
|
for i, m := range c.methodCalls {
|
|
if float64(m.num) == txn {
|
|
methodInvoked = m.name
|
|
c.methodCalls = eraseMethod(c.methodCalls, i)
|
|
break
|
|
}
|
|
}
|
|
if methodInvoked == "" {
|
|
c.log(WarnLevel, pkg+"received result without matching request", "id", txn)
|
|
return nil
|
|
}
|
|
c.log(DebugLevel, pkg+"received result for "+methodInvoked)
|
|
|
|
switch methodInvoked {
|
|
case avConnect:
|
|
err := sendReleaseStream(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = sendFCPublish(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
err = sendCreateStream(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
case avCreatestream:
|
|
n, err := obj.NumberProperty("", 3)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.streamID = uint32(n)
|
|
err = sendPublish(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
default:
|
|
c.log(FatalLevel, pkg+"unexpected method invoked"+methodInvoked)
|
|
}
|
|
|
|
case avOnBWDone:
|
|
err := sendCheckBW(c)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
case avOnStatus:
|
|
obj2, err := obj.ObjectProperty("", 3)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
code, err := obj2.StringProperty(avCode, -1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
level, err := obj2.StringProperty(avLevel, -1)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.log(DebugLevel, pkg+"onStatus", "code", code, "level", level)
|
|
|
|
if code != avNetStreamPublish_Start {
|
|
c.log(ErrorLevel, pkg+"unexpected response "+code)
|
|
return errUnimplemented
|
|
}
|
|
c.log(DebugLevel, pkg+"playing")
|
|
c.isPlaying = true
|
|
for i, m := range c.methodCalls {
|
|
if m.name == avPublish {
|
|
c.methodCalls = eraseMethod(c.methodCalls, i)
|
|
}
|
|
}
|
|
|
|
default:
|
|
c.log(FatalLevel, pkg+"unsuppoted method "+meth)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func handshake(c *Conn) error {
|
|
var clientbuf [signatureSize + 1]byte
|
|
clientsig := clientbuf[1:]
|
|
|
|
var serversig [signatureSize]byte
|
|
clientbuf[0] = chanControl
|
|
binary.BigEndian.PutUint32(clientsig, uint32(time.Now().UnixNano()/1000000))
|
|
copy(clientsig[4:8], []byte{0, 0, 0, 0})
|
|
|
|
for i := 8; i < signatureSize; i++ {
|
|
clientsig[i] = byte(rand.Intn(256))
|
|
}
|
|
|
|
_, err := c.write(clientbuf[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.log(DebugLevel, pkg+"handshake sent")
|
|
|
|
var typ [1]byte
|
|
_, err = c.read(typ[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
c.log(DebugLevel, pkg+"handshake received")
|
|
|
|
if typ[0] != clientbuf[0] {
|
|
c.log(WarnLevel, pkg+"handshake type mismatch", "sent", clientbuf[0], "received", typ)
|
|
}
|
|
_, err = c.read(serversig[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
// decode server response
|
|
suptime := binary.BigEndian.Uint32(serversig[:4])
|
|
c.log(DebugLevel, pkg+"server uptime", "uptime", suptime)
|
|
|
|
// 2nd part of handshake
|
|
_, err = c.write(serversig[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
_, err = c.read(serversig[:])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
if !bytes.Equal(serversig[:signatureSize], clientbuf[1:signatureSize+1]) {
|
|
c.log(WarnLevel, pkg+"signature mismatch", "serversig", serversig[:signatureSize], "clientsig", clientbuf[1:signatureSize+1])
|
|
}
|
|
return nil
|
|
}
|