Thumbnail
/ rani matterbridge.git

rani/matterbridge.git

Clone URL: https://git.buni.party/rani/matterbridge.git

Info Tree Commits Branches Tags Show Grep RSS

Viewing file on branch master

/ bridge irc handlers.go
1package birc
2
3import (
4 "bytes"
5 "fmt"
6 "io"
7 "strconv"
8 "strings"
9 "time"
10
11 "github.com/lrstanley/girc"
12 "github.com/matterbridge-org/matterbridge/bridge/config"
13 "github.com/matterbridge-org/matterbridge/bridge/helper"
14 "github.com/paulrosania/go-charset/charset"
15 "github.com/saintfish/chardet"
16
17 // We need to import the 'data' package as an implicit dependency.
18 // See: https://godoc.org/github.com/paulrosania/go-charset/charset
19 _ "github.com/paulrosania/go-charset/data"
20)
21
22func (b *Birc) handleCharset(msg *config.Message) error {
23 if b.GetString("Charset") != "" {
24 switch b.GetString("Charset") {
25 case "gbk", "gb18030", "gb2312", "big5", "euc-kr", "euc-jp", "shift-jis", "iso-2022-jp":
26 msg.Text = toUTF8(b.GetString("Charset"), msg.Text)
27 default:
28 buf := new(bytes.Buffer)
29 w, err := charset.NewWriter(b.GetString("Charset"), buf)
30 if err != nil {
31 b.Log.Errorf("charset to utf-8 conversion failed: %s", err)
32 return err
33 }
34 fmt.Fprint(w, msg.Text)
35 w.Close()
36 msg.Text = buf.String()
37 }
38 }
39 return nil
40}
41
42// handleFiles returns true if we have handled the files, otherwise return false
43func (b *Birc) handleFiles(msg *config.Message) bool {
44 if msg.Extra == nil {
45 return false
46 }
47 for _, rmsg := range helper.HandleExtra(msg, b.General) {
48 b.Local <- rmsg
49 }
50 if len(msg.Extra["file"]) == 0 {
51 return false
52 }
53 for _, f := range msg.Extra["file"] {
54 fi := f.(config.FileInfo)
55 if fi.Comment != "" {
56 msg.Text += fi.Comment + " : "
57 }
58 if fi.URL != "" {
59 msg.Text = fi.URL
60 if fi.Comment != "" {
61 msg.Text = fi.Comment + " : " + fi.URL
62 }
63 }
64 b.Local <- config.Message{Text: msg.Text, Username: msg.Username, Channel: msg.Channel, Event: msg.Event}
65 }
66 return true
67}
68
69func (b *Birc) handleInvite(client *girc.Client, event girc.Event) {
70 if len(event.Params) != 2 {
71 return
72 }
73
74 channel := event.Params[1]
75
76 b.Log.Debugf("got invite for %s", channel)
77
78 if _, ok := b.channels[channel]; ok {
79 b.i.Cmd.Join(channel)
80 }
81}
82
83func (b *Birc) handleJoinPart(client *girc.Client, event girc.Event) {
84 if len(event.Params) == 0 {
85 b.Log.Debugf("handleJoinPart: empty Params? %#v", event)
86 return
87 }
88 channel := strings.ToLower(event.Params[0])
89 if event.Command == "KICK" && event.Params[1] == b.Nick {
90 b.Log.Infof("Got kicked from %s by %s", channel, event.Source.Name)
91 time.Sleep(time.Duration(b.GetInt("RejoinDelay")) * time.Second)
92 b.Remote <- config.Message{Username: "system", Text: "rejoin", Channel: channel, Account: b.Account, Event: config.EventRejoinChannels}
93 return
94 }
95 if event.Command == "QUIT" {
96 if event.Source.Name == b.Nick && strings.Contains(event.Last(), "Ping timeout") {
97 b.Log.Infof("%s reconnecting ..", b.Account)
98 b.Remote <- config.Message{Username: "system", Text: "reconnect", Channel: channel, Account: b.Account, Event: config.EventFailure}
99 return
100 }
101 }
102 if event.Source.Name != b.Nick {
103 if b.GetBool("nosendjoinpart") {
104 return
105 }
106 msg := config.Message{Username: "system", Text: event.Source.Name + " " + strings.ToLower(event.Command) + "s", Channel: channel, Account: b.Account, Event: config.EventJoinLeave}
107 if b.GetBool("verbosejoinpart") {
108 b.Log.Debugf("<= Sending verbose JOIN_LEAVE event from %s to gateway", b.Account)
109 msg = config.Message{Username: "system", Text: event.Source.Name + " (" + event.Source.Ident + "@" + event.Source.Host + ") " + strings.ToLower(event.Command) + "s", Channel: channel, Account: b.Account, Event: config.EventJoinLeave}
110 } else {
111 b.Log.Debugf("<= Sending JOIN_LEAVE event from %s to gateway", b.Account)
112 }
113 b.Log.Debugf("<= Message is %#v", msg)
114 b.Remote <- msg
115 return
116 }
117 b.Log.Debugf("handle %#v", event)
118}
119
120func (b *Birc) handleNewConnection(client *girc.Client, event girc.Event) {
121 b.Log.Debug("Registering callbacks")
122 i := b.i
123 b.Nick = event.Params[0]
124
125 b.Log.Debug("Clearing handlers before adding in case of BNC reconnect")
126 i.Handlers.Clear("PRIVMSG")
127 i.Handlers.Clear("CTCP_ACTION")
128 i.Handlers.Clear(girc.RPL_TOPICWHOTIME)
129 i.Handlers.Clear(girc.NOTICE)
130 i.Handlers.Clear("JOIN")
131 i.Handlers.Clear("PART")
132 i.Handlers.Clear("QUIT")
133 i.Handlers.Clear("KICK")
134 i.Handlers.Clear("INVITE")
135
136 i.Handlers.AddBg("PRIVMSG", b.handlePrivMsg)
137 i.Handlers.Add(girc.RPL_TOPICWHOTIME, b.handleTopicWhoTime)
138 i.Handlers.AddBg(girc.NOTICE, b.handleNotice)
139 i.Handlers.AddBg("JOIN", b.handleJoinPart)
140 i.Handlers.AddBg("PART", b.handleJoinPart)
141 i.Handlers.AddBg("QUIT", b.handleJoinPart)
142 i.Handlers.AddBg("KICK", b.handleJoinPart)
143 i.Handlers.Add("INVITE", b.handleInvite)
144}
145
146func (b *Birc) handleNickServ() {
147 if !b.GetBool("UseSASL") && b.GetString("NickServNick") != "" && b.GetString("NickServPassword") != "" {
148 b.Log.Debugf("Sending identify to nickserv %s", b.GetString("NickServNick"))
149 b.i.Cmd.Message(b.GetString("NickServNick"), "IDENTIFY "+b.GetString("NickServPassword"))
150 }
151 if strings.EqualFold(b.GetString("NickServNick"), "Q@CServe.quakenet.org") {
152 b.Log.Debugf("Authenticating %s against %s", b.GetString("NickServUsername"), b.GetString("NickServNick"))
153 b.i.Cmd.Message(b.GetString("NickServNick"), "AUTH "+b.GetString("NickServUsername")+" "+b.GetString("NickServPassword"))
154 }
155 // give nickserv some slack
156 time.Sleep(time.Second * 5)
157 b.authDone = true
158}
159
160func (b *Birc) handleNotice(client *girc.Client, event girc.Event) {
161 if strings.Contains(event.String(), "This nickname is registered") && event.Source.Name == b.GetString("NickServNick") {
162 b.handleNickServ()
163 } else {
164 b.handlePrivMsg(client, event)
165 }
166}
167
168func (b *Birc) handleOther(client *girc.Client, event girc.Event) {
169 if b.GetInt("DebugLevel") == 1 {
170 if event.Command != "CLIENT_STATE_UPDATED" &&
171 event.Command != "CLIENT_GENERAL_UPDATED" {
172 b.Log.Debugf("%#v", event.String())
173 }
174 return
175 }
176 switch event.Command {
177 case "372", "375", "376", "250", "251", "252", "253", "254", "255", "265", "266", "002", "003", "004", "005":
178 return
179 }
180 b.Log.Debugf("%#v", event.String())
181}
182
183func (b *Birc) handleOtherAuth(client *girc.Client, event girc.Event) {
184 b.handleNickServ()
185 b.handleRunCommands()
186 // we are now fully connected
187 // only send on first connection
188 if b.FirstConnection {
189 b.connected <- nil
190 }
191}
192
193func (b *Birc) handlePrivMsg(client *girc.Client, event girc.Event) {
194 if b.skipPrivMsg(event) {
195 return
196 }
197
198 rmsg := config.Message{
199 Username: event.Source.Name,
200 Channel: strings.ToLower(event.Params[0]),
201 Account: b.Account,
202 UserID: event.Source.Ident + "@" + event.Source.Host,
203 }
204
205 b.Log.Debugf("== Receiving PRIVMSG: %s %s %#v", event.Source.Name, event.Last(), event)
206
207 // set action event
208 if ok, ctcp := event.IsCTCP(); ok {
209 if ctcp.Command != girc.CTCP_ACTION {
210 b.Log.Debugf("dropping user ctcp, command: %s", ctcp.Command)
211 return
212 }
213 rmsg.Event = config.EventUserAction
214 }
215
216 // set NOTICE event
217 if event.Command == "NOTICE" {
218 rmsg.Event = config.EventNoticeIRC
219 }
220
221 // strip action, we made an event if it was an action
222 rmsg.Text += event.StripAction()
223
224 // start detecting the charset
225 mycharset := b.GetString("Charset")
226 if mycharset == "" {
227 // detect what were sending so that we convert it to utf-8
228 detector := chardet.NewTextDetector()
229 result, err := detector.DetectBest([]byte(rmsg.Text))
230 if err != nil {
231 b.Log.Infof("detection failed for rmsg.Text: %#v", rmsg.Text)
232 return
233 }
234 b.Log.Debugf("detected %s confidence %#v", result.Charset, result.Confidence)
235 mycharset = result.Charset
236 // if we're not sure, just pick ISO-8859-1
237 if result.Confidence < 80 {
238 mycharset = "ISO-8859-1"
239 }
240 }
241 switch mycharset {
242 case "gbk", "gb18030", "gb2312", "big5", "euc-kr", "euc-jp", "shift-jis", "iso-2022-jp":
243 rmsg.Text = toUTF8(b.GetString("Charset"), rmsg.Text)
244 default:
245 r, err := charset.NewReader(mycharset, strings.NewReader(rmsg.Text))
246 if err != nil {
247 b.Log.Errorf("charset to utf-8 conversion failed: %s", err)
248 return
249 }
250
251 output, _ := io.ReadAll(r)
252 rmsg.Text = string(output)
253 }
254
255 b.Log.Debugf("<= Sending message from %s on %s to gateway", event.Params[0], b.Account)
256 b.Remote <- rmsg
257}
258
259func (b *Birc) handleRunCommands() {
260 for _, cmd := range b.GetStringSlice("RunCommands") {
261 cmd = strings.ReplaceAll(cmd, "{BOTNICK}", b.Nick)
262 if err := b.i.Cmd.SendRaw(cmd); err != nil {
263 b.Log.Errorf("RunCommands %s failed: %s", cmd, err)
264 }
265 time.Sleep(time.Second)
266 }
267}
268
269func (b *Birc) handleTopicWhoTime(client *girc.Client, event girc.Event) {
270 parts := strings.Split(event.Params[2], "!")
271 t, err := strconv.ParseInt(event.Params[3], 10, 64)
272 if err != nil {
273 b.Log.Errorf("Invalid time stamp: %s", event.Params[3])
274 }
275 user := parts[0]
276 if len(parts) > 1 {
277 user += " [" + parts[1] + "]"
278 }
279 b.Log.Debugf("%s: Topic set by %s [%s]", event.Command, user, time.Unix(t, 0))
280}
281