You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
484 lines
13 KiB
484 lines
13 KiB
// Copyright 2020 Justine Alexandra Roberts Tunney
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
// Session Description Protocol Library
|
|
//
|
|
// This is the stuff people embed in SIP packets that tells you how to
|
|
// establish audio and/or video sessions.
|
|
//
|
|
// Here's a typical SDP for a phone call sent by Asterisk:
|
|
//
|
|
// v=0
|
|
// o=root 31589 31589 IN IP4 10.0.0.38
|
|
// s=session
|
|
// c=IN IP4 10.0.0.38 <-- ip we should connect to
|
|
// t=0 0
|
|
// m=audio 30126 RTP/AVP 0 101 <-- audio port number and codecs
|
|
// a=rtpmap:0 PCMU/8000 <-- use μ-Law codec at 8000 hz
|
|
// a=rtpmap:101 telephone-event/8000 <-- they support rfc2833 dtmf tones
|
|
// a=fmtp:101 0-16
|
|
// a=silenceSupp:off - - - - <-- they'll freak out if you use VAD
|
|
// a=ptime:20 <-- send packet every 20 milliseconds
|
|
// a=sendrecv <-- they wanna send and receive audio
|
|
//
|
|
// Here's an SDP response from MetaSwitch, meaning the exact same
|
|
// thing as above, but omitting fields we're smart enough to assume:
|
|
//
|
|
// v=0
|
|
// o=- 3366701332 3366701332 IN IP4 1.2.3.4
|
|
// s=-
|
|
// c=IN IP4 1.2.3.4
|
|
// t=0 0
|
|
// m=audio 32898 RTP/AVP 0 101
|
|
// a=rtpmap:101 telephone-event/8000
|
|
// a=ptime:20
|
|
//
|
|
// If you wanted to go where no woman or man has gone before in the
|
|
// voip world, like stream 44.1khz stereo MP3 audio over a IPv6 TCP
|
|
// socket for a Flash player to connect to, you could do something
|
|
// like:
|
|
//
|
|
// v=0
|
|
// o=- 3366701332 3366701332 IN IP6 dead:beef::666
|
|
// s=-
|
|
// c=IN IP6 dead:beef::666
|
|
// t=0 0
|
|
// m=audio 80 TCP/IP 111
|
|
// a=rtpmap:111 MP3/44100/2
|
|
// a=sendonly
|
|
//
|
|
// Reference Material:
|
|
//
|
|
// - SDP RFC: http://tools.ietf.org/html/rfc4566
|
|
// - SIP/SDP Handshake RFC: http://tools.ietf.org/html/rfc3264
|
|
//
|
|
|
|
package sdp
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"github.com/jart/gosip/util"
|
|
"log"
|
|
"net"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const (
|
|
ContentType = "application/sdp"
|
|
MaxLength = 1450
|
|
)
|
|
|
|
// SDP represents a Session Description Protocol SIP payload.
|
|
type SDP struct {
|
|
Origin Origin // This must always be present
|
|
Addr string // Connect to this IP; never blank (from c=)
|
|
Audio *Media // Non-nil if we can establish audio
|
|
Video *Media // Non-nil if we can establish video
|
|
Session string // s= Session Name (default "-")
|
|
Time string // t= Active Time (default "0 0")
|
|
Ptime int // Transmit frame every N milliseconds (default 20)
|
|
SendOnly bool // True if 'a=sendonly' was specified in SDP
|
|
RecvOnly bool // True if 'a=recvonly' was specified in SDP
|
|
Attrs [][2]string // a= lines we don't recognize
|
|
}
|
|
|
|
// Easy way to create a basic, everyday SDP for VoIP.
|
|
func New(addr *net.UDPAddr, codecs ...Codec) *SDP {
|
|
sdp := new(SDP)
|
|
sdp.Addr = addr.IP.String()
|
|
sdp.Origin.ID = util.GenerateOriginID()
|
|
sdp.Origin.Version = sdp.Origin.ID
|
|
sdp.Origin.Addr = sdp.Addr
|
|
sdp.Audio = new(Media)
|
|
sdp.Audio.Proto = "RTP/AVP"
|
|
sdp.Audio.Port = uint16(addr.Port)
|
|
sdp.Audio.Codecs = make([]Codec, len(codecs))
|
|
for i := 0; i < len(codecs); i++ {
|
|
sdp.Audio.Codecs[i] = codecs[i]
|
|
}
|
|
sdp.Attrs = make([][2]string, 0, 8)
|
|
return sdp
|
|
}
|
|
|
|
// parses sdp message text into a happy data structure
|
|
func Parse(s string) (sdp *SDP, err error) {
|
|
sdp = new(SDP)
|
|
sdp.Session = "pokémon"
|
|
sdp.Time = "0 0"
|
|
|
|
// Eat version.
|
|
if !strings.HasPrefix(s, "v=0\r\n") {
|
|
return nil, errors.New("sdp must start with v=0\\r\\n")
|
|
}
|
|
s = s[5:]
|
|
|
|
// Turn into lines.
|
|
lines := strings.Split(s, "\r\n")
|
|
if lines == nil || len(lines) < 2 {
|
|
return nil, errors.New("too few lines in sdp")
|
|
}
|
|
|
|
// We abstract the structure of the media lines so we need a place to store
|
|
// them before assembling the audio/video data structures.
|
|
var audioinfo, videoinfo string
|
|
rtpmaps := make([]string, len(lines))
|
|
rtpmapcnt := 0
|
|
fmtps := make([]string, len(lines))
|
|
fmtpcnt := 0
|
|
sdp.Attrs = make([][2]string, 0, len(lines))
|
|
|
|
// Extract information from SDP.
|
|
var okOrigin, okConn bool
|
|
for _, line := range lines {
|
|
switch {
|
|
case line == "":
|
|
continue
|
|
case len(line) < 3 || line[1] != '=': // empty or invalid line
|
|
log.Println("Bad line in SDP:", line)
|
|
continue
|
|
case line[0] == 'm': // media line
|
|
line = line[2:]
|
|
if strings.HasPrefix(line, "audio ") {
|
|
audioinfo = line[6:]
|
|
} else if strings.HasPrefix(line, "video ") {
|
|
videoinfo = line[6:]
|
|
} else {
|
|
log.Println("Unsupported SDP media line:", line)
|
|
}
|
|
case line[0] == 's': // session line
|
|
sdp.Session = line[2:]
|
|
case line[0] == 't': // active time
|
|
sdp.Time = line[2:]
|
|
case line[0] == 'c': // connect to this ip address
|
|
if okConn {
|
|
log.Println("Dropping extra c= line in sdp:", line)
|
|
continue
|
|
}
|
|
sdp.Addr, err = parseConnLine(line)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
okConn = true
|
|
case line[0] == 'o': // origin line
|
|
err = parseOriginLine(&sdp.Origin, line)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
okOrigin = true
|
|
case line[0] == 'a': // attribute lines
|
|
line = line[2:]
|
|
switch {
|
|
case strings.HasPrefix(line, "rtpmap:"):
|
|
rtpmaps[rtpmapcnt] = line[7:]
|
|
rtpmapcnt++
|
|
case strings.HasPrefix(line, "fmtp:"):
|
|
fmtps[fmtpcnt] = line[5:]
|
|
fmtpcnt++
|
|
case strings.HasPrefix(line, "ptime:"):
|
|
ptimeS := line[6:]
|
|
if ptime, err := strconv.Atoi(ptimeS); err == nil && ptime > 0 {
|
|
sdp.Ptime = ptime
|
|
} else {
|
|
log.Println("Invalid SDP Ptime value", ptimeS)
|
|
}
|
|
case line == "sendrecv":
|
|
case line == "sendonly":
|
|
sdp.SendOnly = true
|
|
case line == "recvonly":
|
|
sdp.RecvOnly = true
|
|
default:
|
|
if n := strings.Index(line, ":"); n >= 0 {
|
|
if n == 0 {
|
|
log.Println("Evil SDP attribute:", line)
|
|
} else {
|
|
l := len(sdp.Attrs)
|
|
sdp.Attrs = sdp.Attrs[0 : l+1]
|
|
sdp.Attrs[l] = [2]string{line[0:n], line[n+1:]}
|
|
}
|
|
} else {
|
|
l := len(sdp.Attrs)
|
|
sdp.Attrs = sdp.Attrs[0 : l+1]
|
|
sdp.Attrs[l] = [2]string{line, ""}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
rtpmaps = rtpmaps[0:rtpmapcnt]
|
|
fmtps = fmtps[0:fmtpcnt]
|
|
|
|
if !okConn || !okOrigin {
|
|
return nil, errors.New("sdp missing mandatory information")
|
|
}
|
|
|
|
// Assemble audio/video information.
|
|
var pts []uint8
|
|
|
|
if audioinfo != "" {
|
|
sdp.Audio = new(Media)
|
|
sdp.Audio.Port, sdp.Audio.Proto, pts, err = parseMediaInfo(audioinfo)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = populateCodecs(sdp.Audio, pts, rtpmaps, fmtps)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
sdp.Video = nil
|
|
}
|
|
|
|
if videoinfo != "" {
|
|
sdp.Video = new(Media)
|
|
sdp.Video.Port, sdp.Video.Proto, pts, err = parseMediaInfo(videoinfo)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
err = populateCodecs(sdp.Video, pts, rtpmaps, fmtps)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
} else {
|
|
sdp.Video = nil
|
|
}
|
|
|
|
if sdp.Audio == nil && sdp.Video == nil {
|
|
return nil, errors.New("sdp has no audio or video information")
|
|
}
|
|
|
|
return sdp, nil
|
|
}
|
|
|
|
func (sdp *SDP) ContentType() string {
|
|
return ContentType
|
|
}
|
|
|
|
func (sdp *SDP) Data() []byte {
|
|
if sdp == nil {
|
|
return nil
|
|
}
|
|
var b bytes.Buffer
|
|
sdp.Append(&b)
|
|
return b.Bytes()
|
|
}
|
|
|
|
func (sdp *SDP) String() string {
|
|
if sdp == nil {
|
|
return ""
|
|
}
|
|
var b bytes.Buffer
|
|
sdp.Append(&b)
|
|
return b.String()
|
|
}
|
|
|
|
func (sdp *SDP) Append(b *bytes.Buffer) {
|
|
b.WriteString("v=0\r\n")
|
|
sdp.Origin.Append(b)
|
|
b.WriteString("s=")
|
|
if sdp.Session == "" {
|
|
b.WriteString("my people call themselves dark angels")
|
|
} else {
|
|
b.WriteString(sdp.Session)
|
|
}
|
|
b.WriteString("\r\n")
|
|
if util.IsIPv6(sdp.Addr) {
|
|
b.WriteString("c=IN IP6 ")
|
|
} else {
|
|
b.WriteString("c=IN IP4 ")
|
|
}
|
|
if sdp.Addr == "" {
|
|
// In case of bugs, keep calm and DDOS NASA.
|
|
b.WriteString("69.28.157.198")
|
|
} else {
|
|
b.WriteString(sdp.Addr)
|
|
}
|
|
b.WriteString("\r\n")
|
|
b.WriteString("t=")
|
|
if sdp.Time == "" {
|
|
b.WriteString("0 0")
|
|
} else {
|
|
b.WriteString(sdp.Time)
|
|
}
|
|
b.WriteString("\r\n")
|
|
if sdp.Audio != nil {
|
|
sdp.Audio.Append("audio", b)
|
|
}
|
|
if sdp.Video != nil {
|
|
sdp.Video.Append("video", b)
|
|
}
|
|
for _, attr := range sdp.Attrs {
|
|
if attr[1] == "" {
|
|
b.WriteString("a=")
|
|
b.WriteString(attr[0])
|
|
b.WriteString("\r\n")
|
|
} else {
|
|
b.WriteString("a=")
|
|
b.WriteString(attr[0])
|
|
b.WriteString(":")
|
|
b.WriteString(attr[1])
|
|
b.WriteString("\r\n")
|
|
}
|
|
}
|
|
if sdp.Ptime > 0 {
|
|
b.WriteString("a=ptime:")
|
|
b.WriteString(strconv.Itoa(sdp.Ptime))
|
|
b.WriteString("\r\n")
|
|
}
|
|
if sdp.SendOnly {
|
|
b.WriteString("a=sendonly\r\n")
|
|
} else if sdp.RecvOnly {
|
|
b.WriteString("a=recvonly\r\n")
|
|
} else {
|
|
b.WriteString("a=sendrecv\r\n")
|
|
}
|
|
}
|
|
|
|
// Here we take the list of payload types from the m= line (e.g. 9 18 0 101)
|
|
// and turn them into a list of codecs.
|
|
//
|
|
// If we couldn't find a matching rtpmap, iana standardized will be filled in
|
|
// like magic.
|
|
func populateCodecs(media *Media, pts []uint8, rtpmaps, fmtps []string) (err error) {
|
|
media.Codecs = make([]Codec, len(pts))
|
|
for n, pt := range pts {
|
|
codec := &media.Codecs[n]
|
|
codec.PT = pt
|
|
prefix := strconv.FormatInt(int64(pt), 10) + " "
|
|
for _, rtpmap := range rtpmaps {
|
|
if strings.HasPrefix(rtpmap, prefix) {
|
|
err = parseRtpmapInfo(codec, rtpmap[len(prefix):])
|
|
if err != nil {
|
|
return err
|
|
}
|
|
break
|
|
}
|
|
}
|
|
if codec.Name == "" {
|
|
if isDynamicPT(pt) {
|
|
return errors.New("dynamic codec missing rtpmap")
|
|
} else {
|
|
if v, ok := StandardCodecs[pt]; ok {
|
|
*codec = v
|
|
} else {
|
|
return errors.New("unknown iana codec id: " +
|
|
strconv.Itoa(int(pt)))
|
|
}
|
|
}
|
|
}
|
|
for _, fmtp := range fmtps {
|
|
if strings.HasPrefix(fmtp, prefix) {
|
|
codec.Fmtp = fmtp[len(prefix):]
|
|
break
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Returns true if IANA says this payload type is dynamic.
|
|
func isDynamicPT(pt uint8) bool {
|
|
return (pt >= 96)
|
|
}
|
|
|
|
// Give me the part of the a=rtpmap line that looks like: "PCMU/8000" or
|
|
// "L16/16000/2".
|
|
func parseRtpmapInfo(codec *Codec, s string) (err error) {
|
|
toks := strings.Split(s, "/")
|
|
if toks != nil && len(toks) >= 2 {
|
|
codec.Name = toks[0]
|
|
codec.Rate, err = strconv.Atoi(toks[1])
|
|
if err != nil {
|
|
return errors.New("invalid rtpmap rate")
|
|
}
|
|
if len(toks) >= 3 {
|
|
codec.Param = toks[2]
|
|
}
|
|
} else {
|
|
return errors.New("invalid rtpmap")
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Give me the part of an "m=" line that looks like: "30126 RTP/AVP 0 101".
|
|
func parseMediaInfo(s string) (port uint16, proto string, pts []uint8, err error) {
|
|
toks := strings.Split(s, " ")
|
|
if toks == nil || len(toks) < 3 {
|
|
return 0, "", nil, errors.New("invalid m= line")
|
|
}
|
|
|
|
// We don't care if they say like "666/2" which is a weird way of saying hey!
|
|
// send ME rtcp too (I think).
|
|
portS := toks[0]
|
|
if n := strings.Index(portS, "/"); n > 0 {
|
|
portS = portS[0:n]
|
|
}
|
|
|
|
// Convert port to int and check range.
|
|
portU, err := strconv.ParseUint(portS, 10, 16)
|
|
if err != nil || !(0 <= port && port <= 65535) {
|
|
return 0, "", nil, errors.New("invalid m= port")
|
|
}
|
|
port = uint16(portU)
|
|
|
|
// Is it rtp? srtp? udp? tcp? etc. (must be 3+ chars)
|
|
proto = toks[1]
|
|
|
|
// The rest of these tokens are payload types sorted by preference.
|
|
pts = make([]uint8, len(toks)-2)
|
|
for n, pt := range toks[2:] {
|
|
pt, err := strconv.ParseUint(pt, 10, 8)
|
|
if err != nil {
|
|
return 0, "", nil, errors.New("invalid pt in m= line")
|
|
}
|
|
pts[n] = byte(pt)
|
|
}
|
|
|
|
return port, proto, pts, nil
|
|
}
|
|
|
|
// I want a string that looks like "c=IN IP4 10.0.0.38".
|
|
func parseConnLine(line string) (addr string, err error) {
|
|
toks := strings.Split(line[2:], " ")
|
|
if toks == nil || len(toks) != 3 {
|
|
return "", errors.New("invalid conn line")
|
|
}
|
|
if toks[0] != "IN" || (toks[1] != "IP4" && toks[1] != "IP6") {
|
|
return "", errors.New("unsupported conn net type")
|
|
}
|
|
addr = toks[2]
|
|
if n := strings.Index(addr, "/"); n >= 0 {
|
|
return "", errors.New("multicast address in c= line D:")
|
|
}
|
|
return addr, nil
|
|
}
|
|
|
|
// I want a string that looks like "o=root 31589 31589 IN IP4 10.0.0.38".
|
|
func parseOriginLine(origin *Origin, line string) error {
|
|
toks := strings.Split(line[2:], " ")
|
|
if toks == nil || len(toks) != 6 {
|
|
return errors.New("invalid origin line")
|
|
}
|
|
if toks[3] != "IN" || (toks[4] != "IP4" && toks[4] != "IP6") {
|
|
return errors.New("unsupported origin net type")
|
|
}
|
|
origin.User = toks[0]
|
|
origin.ID = toks[1]
|
|
origin.Version = toks[2]
|
|
origin.Addr = toks[5]
|
|
if n := strings.Index(origin.Addr, "/"); n >= 0 {
|
|
return errors.New("multicast address in o= line D:")
|
|
}
|
|
return nil
|
|
}
|