func (h *streamHandler) onPlay(callback float64, r *amf0.Reader) error {
if err := h.disenage(); err != nil {
return errors.New("stream.onPlay.disenage")
}
if stream, err := r.ReadString(); err != nil {
return errors.New("stream.onPlay.read stream")
} else {
if p := newPublication(stream); p.add(h) {
if err := h.newPlayResetResponse(stream, callback); err != nil {
return errors.New("stream.onPlay.reset response")
}
if err := h.newPlaySuccessResponse(stream, callback); err != nil {
return errors.New("stream.onPlay.play response")
}
h.play.p = p
h.play.callback = callback
h.bound++
if err := h.newPlayBoundResponse(h.bound); err != nil {
return errors.New("stream.onPlay.bound response")
}
} else {
if err := h.newPlayFailedResponse(stream, callback); err != nil {
return errors.New("stream.onPlay.failed response")
}
}
return nil
}
}
func (h *connHandler) onSetPeerInfo(callback float64, r *amf0.Reader) error {
const (
keepAliveServer, keepAlivePeer = 1000 * 20, 1000 * 5
)
addrs := []*net.UDPAddr{}
for r.Len() != 0 {
if s, err := r.ReadString(); err != nil {
return errors.New("conn.onSetPeerInfo.read address")
} else if len(s) != 0 {
if addr, err := net.ResolveUDPAddr("udp", s); err == nil {
if ip4 := addr.IP.To4(); ip4 != nil {
addr.IP = ip4
}
addrs = append(addrs, addr)
} else {
xlog.ErrLog.Printf("[session]: parse addr = %s, error = '%v', addr = [%s]\n", s, addr)
}
}
}
h.session.addrs = addrs
if err := h.newKeepAliveResponse(keepAliveServer, keepAlivePeer); err != nil {
return errors.New("conn.onSetPeerInfo.keep alive response")
}
return nil
}
func (h *streamHandler) onBroadcastByXid(callback float64, r *amf0.Reader, reliable bool) error {
if s, err := r.ReadString(); err != nil {
return errors.New("stream.onBroadcastByXid.read xids")
} else if len(s) == 0 {
return nil
} else {
xids := make([]uint32, 0, 32)
for _, v := range strings.Split(s, "_") {
if x, err := strconv.ParseInt(v, 10, 64); err != nil {
return errors.New("stream.onBroadcastByXid.parse xid")
} else {
xids = append(xids, uint32(x))
}
}
BroadcastByXid(xids, r.Bytes(), h.session.xid, reliable)
return nil
}
}
func handleAmfMessage(h messageHandler, r *amf0.Reader, withcallback bool) error {
var err error
name := ""
if name, err = r.ReadString(); err != nil {
return errors.New("message.amf.read name")
}
callback := float64(0)
if withcallback {
if callback, err = r.ReadNumber(); err != nil {
return errors.New("message.amf.read callback")
}
if r.Len() != 0 && r.TestNull() {
if err := r.ReadNull(); err != nil {
return errors.New("message.amf.read null")
}
}
}
return h.OnAmfMessage(name, callback, r)
}
func (h *streamHandler) onPublish(callback float64, r *amf0.Reader) error {
if err := h.disenage(); err != nil {
return errors.New("stream.onPublish.disenage")
}
if stream, err := r.ReadString(); err != nil {
return errors.New("stream.onPublish.read stream")
} else {
if p := newPublication(stream); p.start(h) {
if err := h.newPublishSuccessResponse(stream, callback); err != nil {
return errors.New("stream.onPublish.publish response")
}
h.publish.p, h.unstable = p, !p.reliable
h.publish.callback = callback
if !p.rpc {
call := func(x *streamHandler) {
s := x.session
s.Lock()
defer s.Unlock()
if s.closed || x.play.p != p {
return
}
defer s.flush()
x.newPublishNotifyResponse(p.name, x.play.callback)
}
async.Call(p.gid, func() {
if l, _ := p.list(); l != nil {
for e := l.Front(); e != nil; e = e.Next() {
call(e.Value.(*streamHandler))
}
}
})
}
} else {
if err := h.newPublishFailedResponse(stream, callback); err != nil {
return errors.New("stream.onPublish.failed response")
}
}
return nil
}
}
func (h *connHandler) onRelay(callback float64, r *amf0.Reader) error {
if pidss, err := r.ReadString(); err != nil {
return errors.New("conn.onRelay.read pid")
} else if pidbs, err := hex.DecodeString(pidss); err != nil || len(pidbs) != 0x20 {
return errors.New("conn.onRelay.decode pid")
} else if bs, err := newRelayMessage(h.session.pid, r.Bytes()); err != nil {
return errors.New("conn.onRelay.generate response")
} else {
async.Call(uint64(h.session.xid), func() {
if s := FindByPid(string(pidbs)); s != nil {
s.Lock()
defer s.Unlock()
if s.closed {
return
}
defer s.flush()
if fw := s.mainfw; fw != nil {
fw.AddFragments(true, split(bs)...)
}
}
})
return nil
}
}