wsapi.go 17 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731
  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 low level functions for interacting with the Discord
  7. // data websocket interface.
  8. package discordgo
  9. import (
  10. "errors"
  11. "fmt"
  12. "runtime"
  13. "time"
  14. "github.com/gorilla/websocket"
  15. )
  16. type handshakeProperties struct {
  17. OS string `json:"$os"`
  18. Browser string `json:"$browser"`
  19. Device string `json:"$device"`
  20. Referer string `json:"$referer"`
  21. ReferringDomain string `json:"$referring_domain"`
  22. }
  23. type handshakeData struct {
  24. Version int `json:"v"`
  25. Token string `json:"token"`
  26. Properties handshakeProperties `json:"properties"`
  27. }
  28. type handshakeOp struct {
  29. Op int `json:"op"`
  30. Data handshakeData `json:"d"`
  31. }
  32. // Open opens a websocket connection to Discord.
  33. func (s *Session) Open() (err error) {
  34. s.Lock()
  35. defer func() {
  36. if err != nil {
  37. s.Unlock()
  38. }
  39. }()
  40. if s.wsConn != nil {
  41. err = errors.New("Web socket already opened.")
  42. return
  43. }
  44. // Get the gateway to use for the Websocket connection
  45. g, err := s.Gateway()
  46. if err != nil {
  47. return
  48. }
  49. // TODO: See if there's a use for the http response.
  50. // conn, response, err := websocket.DefaultDialer.Dial(session.Gateway, nil)
  51. s.wsConn, _, err = websocket.DefaultDialer.Dial(g, nil)
  52. if err != nil {
  53. return
  54. }
  55. err = s.wsConn.WriteJSON(handshakeOp{2, handshakeData{3, s.Token, handshakeProperties{runtime.GOOS, "Discordgo v" + VERSION, "", "", ""}}})
  56. if err != nil {
  57. return
  58. }
  59. s.Unlock()
  60. if s.OnConnect != nil {
  61. s.OnConnect(s)
  62. }
  63. return
  64. }
  65. // Close closes a websocket and stops all listening/heartbeat goroutines.
  66. // TODO: Add support for Voice WS/UDP connections
  67. func (s *Session) Close() (err error) {
  68. s.Lock()
  69. s.DataReady = false
  70. if s.listening != nil {
  71. close(s.listening)
  72. s.listening = nil
  73. }
  74. if s.wsConn != nil {
  75. err = s.wsConn.Close()
  76. s.wsConn = nil
  77. }
  78. s.Unlock()
  79. if s.OnDisconnect != nil {
  80. s.OnDisconnect(s)
  81. }
  82. return
  83. }
  84. type updateStatusGame struct {
  85. Name string `json:"name"`
  86. }
  87. type updateStatusData struct {
  88. IdleSince *int `json:"idle_since"`
  89. Game *updateStatusGame `json:"game"`
  90. }
  91. type updateStatusOp struct {
  92. Op int `json:"op"`
  93. Data updateStatusData `json:"d"`
  94. }
  95. // UpdateStatus is used to update the authenticated user's status.
  96. // If idle>0 then set status to idle. If game>0 then set game.
  97. // if otherwise, set status to active, and no game.
  98. func (s *Session) UpdateStatus(idle int, game string) (err error) {
  99. s.RLock()
  100. defer s.RUnlock()
  101. if s.wsConn == nil {
  102. return errors.New("No websocket connection exists.")
  103. }
  104. var usd updateStatusData
  105. if idle > 0 {
  106. usd.IdleSince = &idle
  107. }
  108. if game != "" {
  109. usd.Game = &updateStatusGame{game}
  110. }
  111. err = s.wsConn.WriteJSON(updateStatusOp{3, usd})
  112. return
  113. }
  114. // Listen starts listening to the websocket connection for events.
  115. func (s *Session) Listen() (err error) {
  116. s.RLock()
  117. if s.wsConn == nil {
  118. s.RUnlock()
  119. return errors.New("No websocket connection exists.")
  120. }
  121. if s.listening != nil {
  122. s.RUnlock()
  123. return errors.New("Already listening to websocket.")
  124. }
  125. s.listening = make(chan interface{})
  126. s.RUnlock()
  127. // Keep a reference, as s.listening can be nilled out.
  128. listening := s.listening
  129. for {
  130. messageType, message, err1 := s.wsConn.ReadMessage()
  131. if err1 != nil {
  132. err = err1
  133. // Defer so we get better log ordering.
  134. defer s.Close()
  135. return fmt.Errorf("Websocket Listen Error", err)
  136. }
  137. select {
  138. case <-listening:
  139. return
  140. default:
  141. go s.event(messageType, message)
  142. }
  143. }
  144. return
  145. }
  146. // Not sure how needed this is and where it would be best to call it.
  147. // somewhere.
  148. func unmarshalEvent(event *Event, i interface{}) (err error) {
  149. if err = unmarshal(event.RawData, i); err != nil {
  150. fmt.Println(event.Type, err)
  151. printJSON(event.RawData) // TODO: Better error loggingEvent.
  152. }
  153. return
  154. }
  155. // Front line handler for all Websocket Events. Determines the
  156. // event type and passes the message along to the next handler.
  157. // event is the front line handler for all events. This needs to be
  158. // broken up into smaller functions to be more idiomatic Go.
  159. // Events will be handled by any implemented handler in Session.
  160. // All unhandled events will then be handled by OnEvent.
  161. func (s *Session) event(messageType int, message []byte) (err error) {
  162. if s.Debug {
  163. printJSON(message)
  164. }
  165. var e *Event
  166. if err = unmarshal(message, &e); err != nil {
  167. fmt.Println(err)
  168. return
  169. }
  170. switch e.Type {
  171. case "READY":
  172. var st *Ready
  173. if err = unmarshalEvent(e, &st); err == nil {
  174. go s.heartbeat(st.HeartbeatInterval)
  175. if s.StateEnabled {
  176. s.State.OnReady(st)
  177. }
  178. if s.OnReady != nil {
  179. s.OnReady(s, st)
  180. }
  181. }
  182. if s.OnReady != nil {
  183. return
  184. }
  185. case "VOICE_SERVER_UPDATE":
  186. // TEMP CODE FOR TESTING VOICE
  187. var st *VoiceServerUpdate
  188. if err = unmarshalEvent(e, &st); err == nil {
  189. s.onVoiceServerUpdate(st)
  190. }
  191. return
  192. case "VOICE_STATE_UPDATE":
  193. // TEMP CODE FOR TESTING VOICE
  194. var st *VoiceState
  195. if err = unmarshalEvent(e, &st); err == nil {
  196. s.onVoiceStateUpdate(st)
  197. }
  198. return
  199. case "USER_UPDATE":
  200. if s.OnUserUpdate != nil {
  201. var st *User
  202. if err = unmarshalEvent(e, &st); err == nil {
  203. s.OnUserUpdate(s, st)
  204. }
  205. return
  206. }
  207. case "PRESENCE_UPDATE":
  208. if s.OnPresenceUpdate != nil {
  209. var st *PresenceUpdate
  210. if err = unmarshalEvent(e, &st); err == nil {
  211. s.OnPresenceUpdate(s, st)
  212. }
  213. return
  214. }
  215. case "TYPING_START":
  216. if s.OnTypingStart != nil {
  217. var st *TypingStart
  218. if err = unmarshalEvent(e, &st); err == nil {
  219. s.OnTypingStart(s, st)
  220. }
  221. return
  222. }
  223. /* Never seen this come in but saw it in another Library.
  224. case "MESSAGE_ACK":
  225. if s.OnMessageAck != nil {
  226. }
  227. */
  228. case "MESSAGE_CREATE":
  229. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  230. if !stateEnabled && s.OnMessageCreate == nil {
  231. break
  232. }
  233. var st *Message
  234. if err = unmarshalEvent(e, &st); err == nil {
  235. if stateEnabled {
  236. s.State.MessageAdd(st)
  237. }
  238. if s.OnMessageCreate != nil {
  239. s.OnMessageCreate(s, st)
  240. }
  241. }
  242. if s.OnMessageCreate != nil {
  243. return
  244. }
  245. case "MESSAGE_UPDATE":
  246. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  247. if !stateEnabled && s.OnMessageUpdate == nil {
  248. break
  249. }
  250. var st *Message
  251. if err = unmarshalEvent(e, &st); err == nil {
  252. if stateEnabled {
  253. s.State.MessageAdd(st)
  254. }
  255. if s.OnMessageUpdate != nil {
  256. s.OnMessageUpdate(s, st)
  257. }
  258. }
  259. return
  260. if s.OnMessageUpdate != nil {
  261. return
  262. }
  263. case "MESSAGE_DELETE":
  264. stateEnabled := s.StateEnabled && s.State.MaxMessageCount > 0
  265. if !stateEnabled && s.OnMessageDelete == nil {
  266. break
  267. }
  268. var st *Message
  269. if err = unmarshalEvent(e, &st); err == nil {
  270. if stateEnabled {
  271. s.State.MessageRemove(st)
  272. }
  273. if s.OnMessageDelete != nil {
  274. s.OnMessageDelete(s, st)
  275. }
  276. }
  277. return
  278. if s.OnMessageDelete != nil {
  279. return
  280. }
  281. case "MESSAGE_ACK":
  282. if s.OnMessageAck != nil {
  283. var st *MessageAck
  284. if err = unmarshalEvent(e, &st); err == nil {
  285. s.OnMessageAck(s, st)
  286. }
  287. return
  288. }
  289. case "CHANNEL_CREATE":
  290. if !s.StateEnabled && s.OnChannelCreate == nil {
  291. break
  292. }
  293. var st *Channel
  294. if err = unmarshalEvent(e, &st); err == nil {
  295. if s.StateEnabled {
  296. s.State.ChannelAdd(st)
  297. }
  298. if s.OnChannelCreate != nil {
  299. s.OnChannelCreate(s, st)
  300. }
  301. }
  302. if s.OnChannelCreate != nil {
  303. return
  304. }
  305. case "CHANNEL_UPDATE":
  306. if !s.StateEnabled && s.OnChannelUpdate == nil {
  307. break
  308. }
  309. var st *Channel
  310. if err = unmarshalEvent(e, &st); err == nil {
  311. if s.StateEnabled {
  312. s.State.ChannelAdd(st)
  313. }
  314. if s.OnChannelUpdate != nil {
  315. s.OnChannelUpdate(s, st)
  316. }
  317. }
  318. if s.OnChannelUpdate != nil {
  319. return
  320. }
  321. case "CHANNEL_DELETE":
  322. if !s.StateEnabled && s.OnChannelDelete == nil {
  323. break
  324. }
  325. var st *Channel
  326. if err = unmarshalEvent(e, &st); err == nil {
  327. if s.StateEnabled {
  328. s.State.ChannelRemove(st)
  329. }
  330. if s.OnChannelDelete != nil {
  331. s.OnChannelDelete(s, st)
  332. }
  333. }
  334. if s.OnChannelDelete != nil {
  335. return
  336. }
  337. case "GUILD_CREATE":
  338. if !s.StateEnabled && s.OnGuildCreate == nil {
  339. break
  340. }
  341. var st *Guild
  342. if err = unmarshalEvent(e, &st); err == nil {
  343. if s.StateEnabled {
  344. s.State.GuildAdd(st)
  345. }
  346. if s.OnGuildCreate != nil {
  347. s.OnGuildCreate(s, st)
  348. }
  349. }
  350. if s.OnGuildCreate != nil {
  351. return
  352. }
  353. case "GUILD_UPDATE":
  354. if !s.StateEnabled && s.OnGuildUpdate == nil {
  355. break
  356. }
  357. var st *Guild
  358. if err = unmarshalEvent(e, &st); err == nil {
  359. if s.StateEnabled {
  360. s.State.GuildAdd(st)
  361. }
  362. if s.OnGuildCreate != nil {
  363. s.OnGuildUpdate(s, st)
  364. }
  365. }
  366. if s.OnGuildUpdate != nil {
  367. return
  368. }
  369. case "GUILD_DELETE":
  370. if !s.StateEnabled && s.OnGuildDelete == nil {
  371. break
  372. }
  373. var st *Guild
  374. if err = unmarshalEvent(e, &st); err == nil {
  375. if s.StateEnabled {
  376. s.State.GuildRemove(st)
  377. }
  378. if s.OnGuildDelete != nil {
  379. s.OnGuildDelete(s, st)
  380. }
  381. }
  382. if s.OnGuildDelete != nil {
  383. return
  384. }
  385. case "GUILD_MEMBER_ADD":
  386. if !s.StateEnabled && s.OnGuildMemberAdd == nil {
  387. break
  388. }
  389. var st *Member
  390. if err = unmarshalEvent(e, &st); err == nil {
  391. if s.StateEnabled {
  392. s.State.MemberAdd(st)
  393. }
  394. if s.OnGuildMemberAdd != nil {
  395. s.OnGuildMemberAdd(s, st)
  396. }
  397. }
  398. if s.OnGuildMemberAdd != nil {
  399. return
  400. }
  401. case "GUILD_MEMBER_REMOVE":
  402. if !s.StateEnabled && s.OnGuildMemberRemove == nil {
  403. break
  404. }
  405. var st *Member
  406. if err = unmarshalEvent(e, &st); err == nil {
  407. if s.StateEnabled {
  408. s.State.MemberRemove(st)
  409. }
  410. if s.OnGuildMemberRemove != nil {
  411. s.OnGuildMemberRemove(s, st)
  412. }
  413. }
  414. if s.OnGuildMemberRemove != nil {
  415. return
  416. }
  417. case "GUILD_MEMBER_UPDATE":
  418. if !s.StateEnabled && s.OnGuildMemberUpdate == nil {
  419. break
  420. }
  421. var st *Member
  422. if err = unmarshalEvent(e, &st); err == nil {
  423. if s.StateEnabled {
  424. s.State.MemberAdd(st)
  425. }
  426. if s.OnGuildMemberUpdate != nil {
  427. s.OnGuildMemberUpdate(s, st)
  428. }
  429. }
  430. if s.OnGuildMemberUpdate != nil {
  431. return
  432. }
  433. case "GUILD_ROLE_CREATE":
  434. if s.OnGuildRoleCreate != nil {
  435. var st *GuildRole
  436. if err = unmarshalEvent(e, &st); err == nil {
  437. s.OnGuildRoleCreate(s, st)
  438. }
  439. return
  440. }
  441. case "GUILD_ROLE_UPDATE":
  442. if s.OnGuildRoleUpdate != nil {
  443. var st *GuildRole
  444. if err = unmarshalEvent(e, &st); err == nil {
  445. s.OnGuildRoleUpdate(s, st)
  446. }
  447. return
  448. }
  449. case "GUILD_ROLE_DELETE":
  450. if s.OnGuildRoleDelete != nil {
  451. var st *GuildRoleDelete
  452. if err = unmarshalEvent(e, &st); err == nil {
  453. s.OnGuildRoleDelete(s, st)
  454. }
  455. return
  456. }
  457. case "GUILD_INTEGRATIONS_UPDATE":
  458. if s.OnGuildIntegrationsUpdate != nil {
  459. var st *GuildIntegrationsUpdate
  460. if err = unmarshalEvent(e, &st); err == nil {
  461. s.OnGuildIntegrationsUpdate(s, st)
  462. }
  463. return
  464. }
  465. case "GUILD_BAN_ADD":
  466. if s.OnGuildBanAdd != nil {
  467. var st *GuildBan
  468. if err = unmarshalEvent(e, &st); err == nil {
  469. s.OnGuildBanAdd(s, st)
  470. }
  471. return
  472. }
  473. case "GUILD_BAN_REMOVE":
  474. if s.OnGuildBanRemove != nil {
  475. var st *GuildBan
  476. if err = unmarshalEvent(e, &st); err == nil {
  477. s.OnGuildBanRemove(s, st)
  478. }
  479. return
  480. }
  481. case "GUILD_EMOJIS_UPDATE":
  482. if !s.StateEnabled && s.OnGuildEmojisUpdate == nil {
  483. break
  484. }
  485. var st *GuildEmojisUpdate
  486. if err = unmarshalEvent(e, &st); err == nil {
  487. if s.StateEnabled {
  488. s.State.EmojisAdd(st.GuildID, st.Emojis)
  489. }
  490. if s.OnGuildEmojisUpdate != nil {
  491. s.OnGuildEmojisUpdate(s, st)
  492. }
  493. }
  494. if s.OnGuildEmojisUpdate != nil {
  495. return
  496. }
  497. case "USER_SETTINGS_UPDATE":
  498. if s.OnUserSettingsUpdate != nil {
  499. var st map[string]interface{}
  500. if err = unmarshalEvent(e, &st); err == nil {
  501. s.OnUserSettingsUpdate(s, st)
  502. }
  503. return
  504. }
  505. default:
  506. fmt.Println("UNKNOWN EVENT: ", e.Type)
  507. printJSON(message)
  508. }
  509. // if still here, send to generic OnEvent
  510. if s.OnEvent != nil {
  511. s.OnEvent(s, e)
  512. return
  513. }
  514. return
  515. }
  516. type heartbeatOp struct {
  517. Op int `json:"op"`
  518. Data int `json:"d"`
  519. }
  520. func (s *Session) sendHeartbeat() error {
  521. return s.wsConn.WriteJSON(heartbeatOp{1, int(time.Now().Unix())})
  522. }
  523. // heartbeat sends regular heartbeats to Discord so it knows the client
  524. // is still connected. If you do not send these heartbeats Discord will
  525. // disconnect the websocket connection after a few seconds.
  526. func (s *Session) heartbeat(i time.Duration) {
  527. s.Lock()
  528. // We have been closed between the first Ready event, abort.
  529. if s.listening == nil {
  530. s.Unlock()
  531. return
  532. }
  533. // Keep a reference, as s.listening can be nilled out.
  534. listening := s.listening
  535. s.DataReady = true
  536. s.Unlock()
  537. // Send first heartbeat immediately because lag could put the
  538. // first heartbeat outside the required heartbeat interval window.
  539. err := s.sendHeartbeat()
  540. if err != nil {
  541. fmt.Println("Error sending initial heartbeat:", err)
  542. return
  543. }
  544. ticker := time.NewTicker(i * time.Millisecond)
  545. for {
  546. select {
  547. case <-ticker.C:
  548. err := s.sendHeartbeat()
  549. if err != nil {
  550. fmt.Println("Error sending heartbeat:", err)
  551. return
  552. }
  553. case <-listening:
  554. return
  555. }
  556. }
  557. }
  558. // ------------------------------------------------------------------------------------------------
  559. // Code related to voice connections that initiate over the data websocket
  560. // ------------------------------------------------------------------------------------------------
  561. // A VoiceServerUpdate stores the data received during the Voice Server Update
  562. // data websocket event. This data is used during the initial Voice Channel
  563. // join handshaking.
  564. type VoiceServerUpdate struct {
  565. Token string `json:"token"`
  566. GuildID string `json:"guild_id"`
  567. Endpoint string `json:"endpoint"`
  568. }
  569. type voiceChannelJoinData struct {
  570. GuildID string `json:"guild_id"`
  571. ChannelID string `json:"channel_id"`
  572. SelfMute bool `json:"self_mute"`
  573. SelfDeaf bool `json:"self_deaf"`
  574. }
  575. type voiceChannelJoinOp struct {
  576. Op int `json:"op"`
  577. Data voiceChannelJoinData `json:"d"`
  578. }
  579. // ChannelVoiceJoin joins the session user to a voice channel. After calling
  580. // this func please monitor the Session.Voice.Ready bool to determine when
  581. // it is ready and able to send/receive audio, that should happen quickly.
  582. //
  583. // gID : Guild ID of the channel to join.
  584. // cID : Channel ID of the channel to join.
  585. // mute : If true, you will be set to muted upon joining.
  586. // deaf : If true, you will be set to deafened upon joining.
  587. func (s *Session) ChannelVoiceJoin(gID, cID string, mute, deaf bool) (err error) {
  588. if s.wsConn == nil {
  589. return fmt.Errorf("no websocket connection exists.")
  590. }
  591. // Create new voice{} struct if one does not exist.
  592. // If you create this prior to calling this func then you can manually
  593. // set some variables if needed, such as to enable debugging.
  594. if s.Voice == nil {
  595. s.Voice = &Voice{}
  596. }
  597. // TODO : Determine how to properly change channels and change guild
  598. // and channel when you are already connected to an existing channel.
  599. // Send the request to Discord that we want to join the voice channel
  600. data := voiceChannelJoinOp{4, voiceChannelJoinData{gID, cID, mute, deaf}}
  601. err = s.wsConn.WriteJSON(data)
  602. if err != nil {
  603. return
  604. }
  605. // Store gID and cID for later use
  606. s.Voice.guildID = gID
  607. s.Voice.channelID = cID
  608. return
  609. }
  610. // onVoiceStateUpdate handles Voice State Update events on the data
  611. // websocket. This comes immediately after the call to VoiceChannelJoin
  612. // for the session user.
  613. func (s *Session) onVoiceStateUpdate(st *VoiceState) {
  614. // If s.Voice is nil, we must not have even requested to join
  615. // a voice channel yet, so this shouldn't be processed.
  616. if s.Voice == nil {
  617. return
  618. }
  619. // Need to have this happen at login and store it in the Session
  620. // TODO : This should be done upon connecting to Discord, or
  621. // be moved to a small helper function
  622. self, err := s.User("@me") // TODO: move to Login/New
  623. if err != nil {
  624. fmt.Println(err)
  625. return
  626. }
  627. // This event comes for all users, if it's not for the session
  628. // user just ignore it.
  629. // TODO Move this IF to the event() func
  630. if st.UserID != self.ID {
  631. return
  632. }
  633. // Store the SessionID for later use.
  634. s.Voice.userID = self.ID // TODO: Review
  635. s.Voice.sessionID = st.SessionID
  636. }
  637. // onVoiceServerUpdate handles the Voice Server Update data websocket event.
  638. // This event tells us the information needed to open a voice websocket
  639. // connection and should happen after the VOICE_STATE event.
  640. func (s *Session) onVoiceServerUpdate(st *VoiceServerUpdate) {
  641. // This shouldn't ever be the case, I don't think.
  642. if s.Voice == nil {
  643. return
  644. }
  645. // Store values for later use
  646. s.Voice.token = st.Token
  647. s.Voice.endpoint = st.Endpoint
  648. s.Voice.guildID = st.GuildID
  649. // We now have enough information to open a voice websocket conenction
  650. // so, that's what the next call does.
  651. err := s.Voice.Open()
  652. if err != nil {
  653. fmt.Println("onVoiceServerUpdate Voice.Open error: ", err)
  654. // TODO better logging
  655. }
  656. }