voice.go 22 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872
  1. // Discordgo - Discord bindings for Go
  2. // Available at https://github.com/bwmarrin/discordgo
  3. // Copyright 2015-2016 Bruce Marriner <bruce@sqls.net>. All rights reserved.
  4. // Use of this source code is governed by a BSD-style
  5. // license that can be found in the LICENSE file.
  6. // This file contains code related to Discord voice suppport
  7. package discordgo
  8. import (
  9. "encoding/binary"
  10. "encoding/json"
  11. "fmt"
  12. "log"
  13. "net"
  14. "runtime"
  15. "strings"
  16. "sync"
  17. "time"
  18. "github.com/gorilla/websocket"
  19. "golang.org/x/crypto/nacl/secretbox"
  20. )
  21. // ------------------------------------------------------------------------------------------------
  22. // Code related to both VoiceConnection Websocket and UDP connections.
  23. // ------------------------------------------------------------------------------------------------
  24. // A VoiceConnection struct holds all the data and functions related to a Discord Voice Connection.
  25. type VoiceConnection struct {
  26. sync.RWMutex
  27. Debug bool // If true, print extra logging -- DEPRECATED
  28. LogLevel int
  29. Ready bool // If true, voice is ready to send/receive audio
  30. UserID string
  31. GuildID string
  32. ChannelID string
  33. deaf bool
  34. mute bool
  35. speaking bool
  36. reconnecting bool // If true, voice connection is trying to reconnect
  37. OpusSend chan []byte // Chan for sending opus audio
  38. OpusRecv chan *Packet // Chan for receiving opus audio
  39. wsConn *websocket.Conn
  40. wsMutex sync.Mutex
  41. udpConn *net.UDPConn
  42. session *Session
  43. sessionID string
  44. token string
  45. endpoint string
  46. // Used to send a close signal to goroutines
  47. close chan struct{}
  48. // Used to allow blocking until connected
  49. connected chan bool
  50. // Used to pass the sessionid from onVoiceStateUpdate
  51. // sessionRecv chan string UNUSED ATM
  52. op4 voiceOP4
  53. op2 voiceOP2
  54. voiceSpeakingUpdateHandlers []VoiceSpeakingUpdateHandler
  55. }
  56. // VoiceSpeakingUpdateHandler type provides a function defination for the
  57. // VoiceSpeakingUpdate event
  58. type VoiceSpeakingUpdateHandler func(vc *VoiceConnection, vs *VoiceSpeakingUpdate)
  59. // Speaking sends a speaking notification to Discord over the voice websocket.
  60. // This must be sent as true prior to sending audio and should be set to false
  61. // once finished sending audio.
  62. // b : Send true if speaking, false if not.
  63. func (v *VoiceConnection) Speaking(b bool) (err error) {
  64. v.log(LogDebug, "called (%t)", b)
  65. type voiceSpeakingData struct {
  66. Speaking bool `json:"speaking"`
  67. Delay int `json:"delay"`
  68. }
  69. type voiceSpeakingOp struct {
  70. Op int `json:"op"` // Always 5
  71. Data voiceSpeakingData `json:"d"`
  72. }
  73. if v.wsConn == nil {
  74. return fmt.Errorf("No VoiceConnection websocket.")
  75. }
  76. data := voiceSpeakingOp{5, voiceSpeakingData{b, 0}}
  77. v.wsMutex.Lock()
  78. err = v.wsConn.WriteJSON(data)
  79. v.wsMutex.Unlock()
  80. if err != nil {
  81. v.speaking = false
  82. log.Println("Speaking() write json error:", err)
  83. return
  84. }
  85. v.speaking = b
  86. return
  87. }
  88. // ChangeChannel sends Discord a request to change channels within a Guild
  89. // !!! NOTE !!! This function may be removed in favour of just using ChannelVoiceJoin
  90. func (v *VoiceConnection) ChangeChannel(channelID string, mute, deaf bool) (err error) {
  91. v.log(LogInformational, "called")
  92. data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, &channelID, mute, deaf}}
  93. v.wsMutex.Lock()
  94. err = v.session.wsConn.WriteJSON(data)
  95. v.wsMutex.Unlock()
  96. if err != nil {
  97. return
  98. }
  99. v.ChannelID = channelID
  100. v.deaf = deaf
  101. v.mute = mute
  102. v.speaking = false
  103. return
  104. }
  105. // Disconnect disconnects from this voice channel and closes the websocket
  106. // and udp connections to Discord.
  107. // !!! NOTE !!! this function may be removed in favour of ChannelVoiceLeave
  108. func (v *VoiceConnection) Disconnect() (err error) {
  109. // Send a OP4 with a nil channel to disconnect
  110. if v.sessionID != "" {
  111. data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, nil, true, true}}
  112. v.wsMutex.Lock()
  113. err = v.session.wsConn.WriteJSON(data)
  114. v.wsMutex.Unlock()
  115. v.sessionID = ""
  116. }
  117. // Close websocket and udp connections
  118. v.Close()
  119. v.log(LogInformational, "Deleting VoiceConnection %s", v.GuildID)
  120. delete(v.session.VoiceConnections, v.GuildID)
  121. return
  122. }
  123. // Close closes the voice ws and udp connections
  124. func (v *VoiceConnection) Close() {
  125. v.log(LogInformational, "called")
  126. v.Lock()
  127. defer v.Unlock()
  128. v.Ready = false
  129. v.speaking = false
  130. if v.close != nil {
  131. v.log(LogInformational, "closing v.close")
  132. close(v.close)
  133. v.close = nil
  134. }
  135. if v.udpConn != nil {
  136. v.log(LogInformational, "closing udp")
  137. err := v.udpConn.Close()
  138. if err != nil {
  139. log.Println("error closing udp connection: ", err)
  140. }
  141. v.udpConn = nil
  142. }
  143. if v.wsConn != nil {
  144. v.log(LogInformational, "closing wsConn")
  145. err := v.wsConn.Close()
  146. if err != nil {
  147. log.Println("error closing websocket connection: ", err)
  148. }
  149. v.wsConn = nil
  150. }
  151. }
  152. // AddHandler adds a Handler for VoiceSpeakingUpdate events.
  153. func (v *VoiceConnection) AddHandler(h VoiceSpeakingUpdateHandler) {
  154. v.Lock()
  155. defer v.Unlock()
  156. v.voiceSpeakingUpdateHandlers = append(v.voiceSpeakingUpdateHandlers, h)
  157. }
  158. // VoiceSpeakingUpdate is a struct for a VoiceSpeakingUpdate event.
  159. type VoiceSpeakingUpdate struct {
  160. UserID string `json:"user_id"`
  161. SSRC int `json:"ssrc"`
  162. Speaking bool `json:"speaking"`
  163. }
  164. // ------------------------------------------------------------------------------------------------
  165. // Unexported Internal Functions Below.
  166. // ------------------------------------------------------------------------------------------------
  167. // A voiceOP4 stores the data for the voice operation 4 websocket event
  168. // which provides us with the NaCl SecretBox encryption key
  169. type voiceOP4 struct {
  170. SecretKey [32]byte `json:"secret_key"`
  171. Mode string `json:"mode"`
  172. }
  173. // A voiceOP2 stores the data for the voice operation 2 websocket event
  174. // which is sort of like the voice READY packet
  175. type voiceOP2 struct {
  176. SSRC uint32 `json:"ssrc"`
  177. Port int `json:"port"`
  178. Modes []string `json:"modes"`
  179. HeartbeatInterval time.Duration `json:"heartbeat_interval"`
  180. }
  181. // WaitUntilConnected waits for the Voice Connection to
  182. // become ready, if it does not become ready it retuns an err
  183. func (v *VoiceConnection) waitUntilConnected() error {
  184. v.log(LogInformational, "called")
  185. i := 0
  186. for {
  187. if v.Ready {
  188. return nil
  189. }
  190. if i > 10 {
  191. return fmt.Errorf("Timeout waiting for voice.")
  192. }
  193. time.Sleep(1 * time.Second)
  194. i++
  195. }
  196. }
  197. // Open opens a voice connection. This should be called
  198. // after VoiceChannelJoin is used and the data VOICE websocket events
  199. // are captured.
  200. func (v *VoiceConnection) open() (err error) {
  201. v.log(LogInformational, "called")
  202. v.Lock()
  203. defer v.Unlock()
  204. // Don't open a websocket if one is already open
  205. if v.wsConn != nil {
  206. v.log(LogWarning, "refusing to overwrite non-nil websocket")
  207. return
  208. }
  209. // TODO temp? loop to wait for the SessionID
  210. i := 0
  211. for {
  212. if v.sessionID != "" {
  213. break
  214. }
  215. if i > 20 { // only loop for up to 1 second total
  216. return fmt.Errorf("Did not receive voice Session ID in time.")
  217. }
  218. time.Sleep(50 * time.Millisecond)
  219. i++
  220. }
  221. // Connect to VoiceConnection Websocket
  222. vg := fmt.Sprintf("wss://%s", strings.TrimSuffix(v.endpoint, ":80"))
  223. v.log(LogInformational, "connecting to voice endpoint %s", vg)
  224. v.wsConn, _, err = websocket.DefaultDialer.Dial(vg, nil)
  225. if err != nil {
  226. v.log(LogWarning, "error connecting to voice endpoint %s, %s", vg, err)
  227. v.log(LogDebug, "voice struct: %#v\n", v)
  228. return
  229. }
  230. type voiceHandshakeData struct {
  231. ServerID string `json:"server_id"`
  232. UserID string `json:"user_id"`
  233. SessionID string `json:"session_id"`
  234. Token string `json:"token"`
  235. }
  236. type voiceHandshakeOp struct {
  237. Op int `json:"op"` // Always 0
  238. Data voiceHandshakeData `json:"d"`
  239. }
  240. data := voiceHandshakeOp{0, voiceHandshakeData{v.GuildID, v.UserID, v.sessionID, v.token}}
  241. err = v.wsConn.WriteJSON(data)
  242. if err != nil {
  243. v.log(LogWarning, "error sending init packet, %s", err)
  244. return
  245. }
  246. v.close = make(chan struct{})
  247. go v.wsListen(v.wsConn, v.close)
  248. // add loop/check for Ready bool here?
  249. // then return false if not ready?
  250. // but then wsListen will also err.
  251. return
  252. }
  253. // wsListen listens on the voice websocket for messages and passes them
  254. // to the voice event handler. This is automatically called by the Open func
  255. func (v *VoiceConnection) wsListen(wsConn *websocket.Conn, close <-chan struct{}) {
  256. v.log(LogInformational, "called")
  257. for {
  258. _, message, err := v.wsConn.ReadMessage()
  259. if err != nil {
  260. // Detect if we have been closed manually. If a Close() has already
  261. // happened, the websocket we are listening on will be different to the
  262. // current session.
  263. v.RLock()
  264. sameConnection := v.wsConn == wsConn
  265. v.RUnlock()
  266. if sameConnection {
  267. v.log(LogError, "voice endpoint %s websocket closed unexpectantly, %s", v.endpoint, err)
  268. // Start reconnect goroutine then exit.
  269. go v.reconnect()
  270. }
  271. return
  272. }
  273. // Pass received message to voice event handler
  274. select {
  275. case <-close:
  276. return
  277. default:
  278. go v.onEvent(message)
  279. }
  280. }
  281. }
  282. // wsEvent handles any voice websocket events. This is only called by the
  283. // wsListen() function.
  284. func (v *VoiceConnection) onEvent(message []byte) {
  285. v.log(LogDebug, "received: %s", string(message))
  286. var e Event
  287. if err := json.Unmarshal(message, &e); err != nil {
  288. v.log(LogError, "unmarshall error, %s", err)
  289. return
  290. }
  291. switch e.Operation {
  292. case 2: // READY
  293. if err := json.Unmarshal(e.RawData, &v.op2); err != nil {
  294. v.log(LogError, "OP2 unmarshall error, %s, %s", err, string(e.RawData))
  295. return
  296. }
  297. // Start the voice websocket heartbeat to keep the connection alive
  298. go v.wsHeartbeat(v.wsConn, v.close, v.op2.HeartbeatInterval)
  299. // TODO monitor a chan/bool to verify this was successful
  300. // Start the UDP connection
  301. err := v.udpOpen()
  302. if err != nil {
  303. v.log(LogError, "error opening udp connection, %s", err)
  304. return
  305. }
  306. // Start the opusSender.
  307. // TODO: Should we allow 48000/960 values to be user defined?
  308. if v.OpusSend == nil {
  309. v.OpusSend = make(chan []byte, 2)
  310. }
  311. go v.opusSender(v.udpConn, v.close, v.OpusSend, 48000, 960)
  312. // Start the opusReceiver
  313. if !v.deaf {
  314. if v.OpusRecv == nil {
  315. v.OpusRecv = make(chan *Packet, 2)
  316. }
  317. go v.opusReceiver(v.udpConn, v.close, v.OpusRecv)
  318. }
  319. // Send the ready event
  320. v.connected <- true
  321. return
  322. case 3: // HEARTBEAT response
  323. // add code to use this to track latency?
  324. return
  325. case 4: // udp encryption secret key
  326. v.op4 = voiceOP4{}
  327. if err := json.Unmarshal(e.RawData, &v.op4); err != nil {
  328. v.log(LogError, "OP4 unmarshall error, %s, %s", err, string(e.RawData))
  329. return
  330. }
  331. return
  332. case 5:
  333. if len(v.voiceSpeakingUpdateHandlers) == 0 {
  334. return
  335. }
  336. voiceSpeakingUpdate := &VoiceSpeakingUpdate{}
  337. if err := json.Unmarshal(e.RawData, voiceSpeakingUpdate); err != nil {
  338. v.log(LogError, "OP5 unmarshall error, %s, %s", err, string(e.RawData))
  339. return
  340. }
  341. for _, h := range v.voiceSpeakingUpdateHandlers {
  342. h(v, voiceSpeakingUpdate)
  343. }
  344. default:
  345. v.log(LogError, "unknown voice operation, %d, %s", e.Operation, string(e.RawData))
  346. }
  347. return
  348. }
  349. type voiceHeartbeatOp struct {
  350. Op int `json:"op"` // Always 3
  351. Data int `json:"d"`
  352. }
  353. // NOTE :: When a guild voice server changes how do we shut this down
  354. // properly, so a new connection can be setup without fuss?
  355. //
  356. // wsHeartbeat sends regular heartbeats to voice Discord so it knows the client
  357. // is still connected. If you do not send these heartbeats Discord will
  358. // disconnect the websocket connection after a few seconds.
  359. func (v *VoiceConnection) wsHeartbeat(wsConn *websocket.Conn, close <-chan struct{}, i time.Duration) {
  360. if close == nil || wsConn == nil {
  361. return
  362. }
  363. var err error
  364. ticker := time.NewTicker(i * time.Millisecond)
  365. for {
  366. v.log(LogDebug, "sending heartbeat packet")
  367. v.wsMutex.Lock()
  368. err = wsConn.WriteJSON(voiceHeartbeatOp{3, int(time.Now().Unix())})
  369. v.wsMutex.Unlock()
  370. if err != nil {
  371. v.log(LogError, "error sending heartbeat to voice endpoint %s, %s", v.endpoint, err)
  372. return
  373. }
  374. select {
  375. case <-ticker.C:
  376. // continue loop and send heartbeat
  377. case <-close:
  378. return
  379. }
  380. }
  381. }
  382. // ------------------------------------------------------------------------------------------------
  383. // Code related to the VoiceConnection UDP connection
  384. // ------------------------------------------------------------------------------------------------
  385. type voiceUDPData struct {
  386. Address string `json:"address"` // Public IP of machine running this code
  387. Port uint16 `json:"port"` // UDP Port of machine running this code
  388. Mode string `json:"mode"` // always "xsalsa20_poly1305"
  389. }
  390. type voiceUDPD struct {
  391. Protocol string `json:"protocol"` // Always "udp" ?
  392. Data voiceUDPData `json:"data"`
  393. }
  394. type voiceUDPOp struct {
  395. Op int `json:"op"` // Always 1
  396. Data voiceUDPD `json:"d"`
  397. }
  398. // udpOpen opens a UDP connection to the voice server and completes the
  399. // initial required handshake. This connection is left open in the session
  400. // and can be used to send or receive audio. This should only be called
  401. // from voice.wsEvent OP2
  402. func (v *VoiceConnection) udpOpen() (err error) {
  403. v.Lock()
  404. defer v.Unlock()
  405. if v.wsConn == nil {
  406. return fmt.Errorf("nil voice websocket")
  407. }
  408. if v.udpConn != nil {
  409. return fmt.Errorf("udp connection already open")
  410. }
  411. if v.close == nil {
  412. return fmt.Errorf("nil close channel")
  413. }
  414. if v.endpoint == "" {
  415. return fmt.Errorf("empty endpoint")
  416. }
  417. host := fmt.Sprintf("%s:%d", strings.TrimSuffix(v.endpoint, ":80"), v.op2.Port)
  418. addr, err := net.ResolveUDPAddr("udp", host)
  419. if err != nil {
  420. v.log(LogWarning, "error resolving udp host %s, %s", host, err)
  421. return
  422. }
  423. v.log(LogInformational, "connecting to udp addr %s", addr.String())
  424. v.udpConn, err = net.DialUDP("udp", nil, addr)
  425. if err != nil {
  426. v.log(LogWarning, "error connecting to udp addr %s, %s", addr.String(), err)
  427. return
  428. }
  429. // Create a 70 byte array and put the SSRC code from the Op 2 VoiceConnection event
  430. // into it. Then send that over the UDP connection to Discord
  431. sb := make([]byte, 70)
  432. binary.BigEndian.PutUint32(sb, v.op2.SSRC)
  433. _, err = v.udpConn.Write(sb)
  434. if err != nil {
  435. v.log(LogWarning, "udp write error to %s, %s", addr.String(), err)
  436. return
  437. }
  438. // Create a 70 byte array and listen for the initial handshake response
  439. // from Discord. Once we get it parse the IP and PORT information out
  440. // of the response. This should be our public IP and PORT as Discord
  441. // saw us.
  442. rb := make([]byte, 70)
  443. rlen, _, err := v.udpConn.ReadFromUDP(rb)
  444. if err != nil {
  445. v.log(LogWarning, "udp read error, %s, %s", addr.String(), err)
  446. return
  447. }
  448. if rlen < 70 {
  449. v.log(LogWarning, "received udp packet too small")
  450. return fmt.Errorf("received udp packet too small")
  451. }
  452. // Loop over position 4 though 20 to grab the IP address
  453. // Should never be beyond position 20.
  454. var ip string
  455. for i := 4; i < 20; i++ {
  456. if rb[i] == 0 {
  457. break
  458. }
  459. ip += string(rb[i])
  460. }
  461. // Grab port from position 68 and 69
  462. port := binary.LittleEndian.Uint16(rb[68:70])
  463. // Take the data from above and send it back to Discord to finalize
  464. // the UDP connection handshake.
  465. data := voiceUDPOp{1, voiceUDPD{"udp", voiceUDPData{ip, port, "xsalsa20_poly1305"}}}
  466. v.wsMutex.Lock()
  467. err = v.wsConn.WriteJSON(data)
  468. v.wsMutex.Unlock()
  469. if err != nil {
  470. v.log(LogWarning, "udp write error, %#v, %s", data, err)
  471. return
  472. }
  473. // start udpKeepAlive
  474. go v.udpKeepAlive(v.udpConn, v.close, 5*time.Second)
  475. // TODO: find a way to check that it fired off okay
  476. return
  477. }
  478. // udpKeepAlive sends a udp packet to keep the udp connection open
  479. // This is still a bit of a "proof of concept"
  480. func (v *VoiceConnection) udpKeepAlive(udpConn *net.UDPConn, close <-chan struct{}, i time.Duration) {
  481. if udpConn == nil || close == nil {
  482. return
  483. }
  484. var err error
  485. var sequence uint64
  486. packet := make([]byte, 8)
  487. ticker := time.NewTicker(i)
  488. for {
  489. binary.LittleEndian.PutUint64(packet, sequence)
  490. sequence++
  491. _, err = udpConn.Write(packet)
  492. if err != nil {
  493. v.log(LogError, "write error, %s", err)
  494. return
  495. }
  496. select {
  497. case <-ticker.C:
  498. // continue loop and send keepalive
  499. case <-close:
  500. return
  501. }
  502. }
  503. }
  504. // opusSender will listen on the given channel and send any
  505. // pre-encoded opus audio to Discord. Supposedly.
  506. func (v *VoiceConnection) opusSender(udpConn *net.UDPConn, close <-chan struct{}, opus <-chan []byte, rate, size int) {
  507. if udpConn == nil || close == nil {
  508. return
  509. }
  510. runtime.LockOSThread()
  511. // VoiceConnection is now ready to receive audio packets
  512. // TODO: this needs reviewed as I think there must be a better way.
  513. v.Ready = true
  514. defer func() { v.Ready = false }()
  515. var sequence uint16
  516. var timestamp uint32
  517. var recvbuf []byte
  518. var ok bool
  519. udpHeader := make([]byte, 12)
  520. var nonce [24]byte
  521. // build the parts that don't change in the udpHeader
  522. udpHeader[0] = 0x80
  523. udpHeader[1] = 0x78
  524. binary.BigEndian.PutUint32(udpHeader[8:], v.op2.SSRC)
  525. // start a send loop that loops until buf chan is closed
  526. ticker := time.NewTicker(time.Millisecond * time.Duration(size/(rate/1000)))
  527. for {
  528. // Get data from chan. If chan is closed, return.
  529. select {
  530. case <-close:
  531. return
  532. case recvbuf, ok = <-opus:
  533. if !ok {
  534. return
  535. }
  536. // else, continue loop
  537. }
  538. if !v.speaking {
  539. err := v.Speaking(true)
  540. if err != nil {
  541. v.log(LogError, "error sending speaking packet, %s", err)
  542. }
  543. }
  544. // Add sequence and timestamp to udpPacket
  545. binary.BigEndian.PutUint16(udpHeader[2:], sequence)
  546. binary.BigEndian.PutUint32(udpHeader[4:], timestamp)
  547. // encrypt the opus data
  548. copy(nonce[:], udpHeader)
  549. sendbuf := secretbox.Seal(udpHeader, recvbuf, &nonce, &v.op4.SecretKey)
  550. // block here until we're exactly at the right time :)
  551. // Then send rtp audio packet to Discord over UDP
  552. select {
  553. case <-close:
  554. return
  555. case <-ticker.C:
  556. // continue
  557. }
  558. _, err := udpConn.Write(sendbuf)
  559. if err != nil {
  560. v.log(LogError, "udp write error, %s", err)
  561. v.log(LogDebug, "voice struct: %#v\n", v)
  562. return
  563. }
  564. if (sequence) == 0xFFFF {
  565. sequence = 0
  566. } else {
  567. sequence++
  568. }
  569. if (timestamp + uint32(size)) >= 0xFFFFFFFF {
  570. timestamp = 0
  571. } else {
  572. timestamp += uint32(size)
  573. }
  574. }
  575. }
  576. // A Packet contains the headers and content of a received voice packet.
  577. type Packet struct {
  578. SSRC uint32
  579. Sequence uint16
  580. Timestamp uint32
  581. Type []byte
  582. Opus []byte
  583. PCM []int16
  584. }
  585. // opusReceiver listens on the UDP socket for incoming packets
  586. // and sends them across the given channel
  587. // NOTE :: This function may change names later.
  588. func (v *VoiceConnection) opusReceiver(udpConn *net.UDPConn, close <-chan struct{}, c chan *Packet) {
  589. if udpConn == nil || close == nil {
  590. return
  591. }
  592. p := Packet{}
  593. recvbuf := make([]byte, 1024)
  594. var nonce [24]byte
  595. for {
  596. rlen, err := udpConn.Read(recvbuf)
  597. if err != nil {
  598. // Detect if we have been closed manually. If a Close() has already
  599. // happened, the udp connection we are listening on will be different
  600. // to the current session.
  601. v.RLock()
  602. sameConnection := v.udpConn == udpConn
  603. v.RUnlock()
  604. if sameConnection {
  605. v.log(LogError, "udp read error, %s, %s", v.endpoint, err)
  606. v.log(LogDebug, "voice struct: %#v\n", v)
  607. go v.reconnect()
  608. }
  609. return
  610. }
  611. select {
  612. case <-close:
  613. return
  614. default:
  615. // continue loop
  616. }
  617. // For now, skip anything except audio.
  618. if rlen < 12 || recvbuf[0] != 0x80 {
  619. continue
  620. }
  621. // build a audio packet struct
  622. p.Type = recvbuf[0:2]
  623. p.Sequence = binary.BigEndian.Uint16(recvbuf[2:4])
  624. p.Timestamp = binary.BigEndian.Uint32(recvbuf[4:8])
  625. p.SSRC = binary.BigEndian.Uint32(recvbuf[8:12])
  626. // decrypt opus data
  627. copy(nonce[:], recvbuf[0:12])
  628. p.Opus, _ = secretbox.Open(nil, recvbuf[12:rlen], &nonce, &v.op4.SecretKey)
  629. if c != nil {
  630. c <- &p
  631. }
  632. }
  633. }
  634. // Reconnect will close down a voice connection then immediately try to
  635. // reconnect to that session.
  636. // NOTE : This func is messy and a WIP while I find what works.
  637. // It will be cleaned up once a proven stable option is flushed out.
  638. // aka: this is ugly shit code, please don't judge too harshly.
  639. func (v *VoiceConnection) reconnect() {
  640. v.log(LogInformational, "called")
  641. v.Lock()
  642. if v.reconnecting {
  643. v.log(LogInformational, "already reconnecting to channel %s, exiting", v.ChannelID)
  644. v.Unlock()
  645. return
  646. }
  647. v.reconnecting = true
  648. v.Unlock()
  649. defer func() { v.reconnecting = false }()
  650. /*
  651. if v.session == nil {
  652. v.log(LogInformational, "cannot reconnect with nil session")
  653. return
  654. }
  655. // check that the gateway session is Ready
  656. // this needs more smarts - but the issue is that well the session
  657. // could be not ready and in that case the disconnect below will panic
  658. // one cause for that is if the gw disconnects and starts the reconnect
  659. // processes right before the voice disconnects.
  660. // NOTE: this will probably change but it's a safety net for now
  661. i := 0
  662. for v.session.DataReady == false || v.session.wsConn == nil {
  663. if i > 20 {
  664. v.log(LogInformational, "timeout waiting for ready session, I give up.")
  665. return
  666. }
  667. time.Sleep(1 * time.Second)
  668. i++
  669. }
  670. // Send a OP4 with a nil channel to disconnect
  671. // this may not be required, but is here as a safety for now.
  672. if v.sessionID != "" {
  673. data := voiceChannelJoinOp{4, voiceChannelJoinData{&v.GuildID, nil, true, true}}
  674. v.session.wsMutex.Lock()
  675. err := v.session.wsConn.WriteJSON(data)
  676. v.session.wsMutex.Unlock()
  677. if err != nil {
  678. v.log(LogError, "error sending disconnect packet, %s", err)
  679. }
  680. v.sessionID = ""
  681. }
  682. */
  683. // Close any currently open connections
  684. v.Close()
  685. wait := time.Duration(1)
  686. for {
  687. <-time.After(wait * time.Second)
  688. wait *= 2
  689. if wait > 600 {
  690. wait = 600
  691. }
  692. if v.session.DataReady == false || v.session.wsConn == nil {
  693. v.log(LogInformational, "cannot reconenct to channel %s with unready session", v.ChannelID)
  694. continue
  695. }
  696. v.log(LogInformational, "trying to reconnect to channel %s", v.ChannelID)
  697. // Below is required because ChannelVoiceJoin checks the GuildID
  698. // to decide if we should change channels or open a new connection.
  699. // TODO: Maybe find a better method.
  700. gID := v.GuildID
  701. v.GuildID = ""
  702. v.sessionID = ""
  703. _, err := v.session.ChannelVoiceJoin(gID, v.ChannelID, v.mute, v.deaf)
  704. if err == nil {
  705. v.log(LogInformational, "successfully reconnected to channel %s", v.ChannelID)
  706. return
  707. }
  708. v.log(LogInformational, "error reconnecting to channel %s, %s", v.ChannelID, err)
  709. }
  710. }