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.

ircconn.go 3.3KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139
  1. // Copyright (c) 2020 Shivaram Lingamneni
  2. // released under the MIT license
  3. package irc
  4. import (
  5. "bytes"
  6. "errors"
  7. "net"
  8. "unicode/utf8"
  9. "github.com/gorilla/websocket"
  10. "github.com/goshuirc/irc-go/ircmsg"
  11. "github.com/goshuirc/irc-go/ircreader"
  12. "github.com/oragono/oragono/irc/utils"
  13. )
  14. const (
  15. maxReadQBytes = ircmsg.MaxlenTagsFromClient + MaxLineLen + 1024
  16. initialBufferSize = 1024
  17. )
  18. var (
  19. crlf = []byte{'\r', '\n'}
  20. errWSBinaryMessage = errors.New("WebSocket binary messages are unsupported")
  21. )
  22. // IRCConn abstracts away the distinction between a regular
  23. // net.Conn (which includes both raw TCP and TLS) and a websocket.
  24. // it doesn't expose the net.Conn, io.Reader, or io.Writer interfaces
  25. // because websockets are message-oriented, not stream-oriented, and
  26. // therefore this abstraction is message-oriented as well.
  27. type IRCConn interface {
  28. UnderlyingConn() *utils.WrappedConn
  29. // these take an IRC line or lines, correctly terminated with CRLF:
  30. WriteLine([]byte) error
  31. WriteLines([][]byte) error
  32. // this returns an IRC line, possibly terminated with CRLF, LF, or nothing:
  33. ReadLine() (line []byte, err error)
  34. Close() error
  35. }
  36. // IRCStreamConn is an IRCConn over a regular stream connection.
  37. type IRCStreamConn struct {
  38. conn *utils.WrappedConn
  39. reader ircreader.IRCReader
  40. }
  41. func NewIRCStreamConn(conn *utils.WrappedConn) *IRCStreamConn {
  42. var c IRCStreamConn
  43. c.conn = conn
  44. c.reader.Initialize(conn.Conn, initialBufferSize, maxReadQBytes)
  45. return &c
  46. }
  47. func (cc *IRCStreamConn) UnderlyingConn() *utils.WrappedConn {
  48. return cc.conn
  49. }
  50. func (cc *IRCStreamConn) WriteLine(buf []byte) (err error) {
  51. _, err = cc.conn.Write(buf)
  52. return
  53. }
  54. func (cc *IRCStreamConn) WriteLines(buffers [][]byte) (err error) {
  55. // on Linux, with a plaintext TCP or Unix domain socket,
  56. // the Go runtime will optimize this into a single writev(2) call:
  57. _, err = (*net.Buffers)(&buffers).WriteTo(cc.conn)
  58. return
  59. }
  60. func (cc *IRCStreamConn) ReadLine() ([]byte, error) {
  61. line, err := cc.reader.ReadLine()
  62. if err != nil {
  63. return nil, err
  64. } else if globalUtf8EnforcementSetting && !utf8.Valid(line) {
  65. return line, errInvalidUtf8
  66. } else {
  67. return line, nil
  68. }
  69. }
  70. func (cc *IRCStreamConn) Close() (err error) {
  71. return cc.conn.Close()
  72. }
  73. // IRCWSConn is an IRCConn over a websocket.
  74. type IRCWSConn struct {
  75. conn *websocket.Conn
  76. }
  77. func NewIRCWSConn(conn *websocket.Conn) IRCWSConn {
  78. return IRCWSConn{conn: conn}
  79. }
  80. func (wc IRCWSConn) UnderlyingConn() *utils.WrappedConn {
  81. // just assume that the type is OK
  82. wConn, _ := wc.conn.UnderlyingConn().(*utils.WrappedConn)
  83. return wConn
  84. }
  85. func (wc IRCWSConn) WriteLine(buf []byte) (err error) {
  86. buf = bytes.TrimSuffix(buf, crlf)
  87. // #1483: if we have websockets at all, then we're enforcing utf8
  88. return wc.conn.WriteMessage(websocket.TextMessage, buf)
  89. }
  90. func (wc IRCWSConn) WriteLines(buffers [][]byte) (err error) {
  91. for _, buf := range buffers {
  92. err = wc.WriteLine(buf)
  93. if err != nil {
  94. return
  95. }
  96. }
  97. return
  98. }
  99. func (wc IRCWSConn) ReadLine() (line []byte, err error) {
  100. messageType, line, err := wc.conn.ReadMessage()
  101. if err == nil {
  102. if messageType == websocket.TextMessage {
  103. return line, nil
  104. } else {
  105. return nil, errWSBinaryMessage
  106. }
  107. } else if err == websocket.ErrReadLimit {
  108. return line, ircreader.ErrReadQ
  109. } else {
  110. return line, err
  111. }
  112. }
  113. func (wc IRCWSConn) Close() (err error) {
  114. return wc.conn.Close()
  115. }